Contents of /trunk/mkinitrd-magellan/busybox/e2fsprogs/old_e2fsprogs/ext2fs/ext2fs_inline.c
Parent Directory | Revision Log
Revision 984 -
(show annotations)
(download)
Sun May 30 11:32:42 2010 UTC (13 years, 11 months ago) by niro
File MIME type: text/plain
File size: 7398 byte(s)
Sun May 30 11:32:42 2010 UTC (13 years, 11 months ago) by niro
File MIME type: text/plain
File size: 7398 byte(s)
-updated to busybox-1.16.1 and enabled blkid/uuid support in default config
1 | /* vi: set sw=4 ts=4: */ |
2 | /* |
3 | * ext2fs.h --- ext2fs |
4 | * |
5 | * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o. |
6 | * |
7 | * %Begin-Header% |
8 | * This file may be redistributed under the terms of the GNU Public |
9 | * License. |
10 | * %End-Header% |
11 | */ |
12 | |
13 | #include "ext2fs.h" |
14 | #include "bitops.h" |
15 | #include <string.h> |
16 | |
17 | /* |
18 | * Allocate memory |
19 | */ |
20 | errcode_t ext2fs_get_mem(unsigned long size, void *ptr) |
21 | { |
22 | void **pp = (void **)ptr; |
23 | |
24 | *pp = malloc(size); |
25 | if (!*pp) |
26 | return EXT2_ET_NO_MEMORY; |
27 | return 0; |
28 | } |
29 | |
30 | /* |
31 | * Free memory |
32 | */ |
33 | errcode_t ext2fs_free_mem(void *ptr) |
34 | { |
35 | void **pp = (void **)ptr; |
36 | |
37 | free(*pp); |
38 | *pp = 0; |
39 | return 0; |
40 | } |
41 | |
42 | /* |
43 | * Resize memory |
44 | */ |
45 | errcode_t ext2fs_resize_mem(unsigned long EXT2FS_ATTR((unused)) old_size, |
46 | unsigned long size, void *ptr) |
47 | { |
48 | void *p; |
49 | |
50 | /* Use "memcpy" for pointer assignments here to avoid problems |
51 | * with C99 strict type aliasing rules. */ |
52 | memcpy(&p, ptr, sizeof (p)); |
53 | p = xrealloc(p, size); |
54 | memcpy(ptr, &p, sizeof (p)); |
55 | return 0; |
56 | } |
57 | |
58 | /* |
59 | * Mark a filesystem superblock as dirty |
60 | */ |
61 | void ext2fs_mark_super_dirty(ext2_filsys fs) |
62 | { |
63 | fs->flags |= EXT2_FLAG_DIRTY | EXT2_FLAG_CHANGED; |
64 | } |
65 | |
66 | /* |
67 | * Mark a filesystem as changed |
68 | */ |
69 | void ext2fs_mark_changed(ext2_filsys fs) |
70 | { |
71 | fs->flags |= EXT2_FLAG_CHANGED; |
72 | } |
73 | |
74 | /* |
75 | * Check to see if a filesystem has changed |
76 | */ |
77 | int ext2fs_test_changed(ext2_filsys fs) |
78 | { |
79 | return (fs->flags & EXT2_FLAG_CHANGED); |
80 | } |
81 | |
82 | /* |
83 | * Mark a filesystem as valid |
84 | */ |
85 | void ext2fs_mark_valid(ext2_filsys fs) |
86 | { |
87 | fs->flags |= EXT2_FLAG_VALID; |
88 | } |
89 | |
90 | /* |
91 | * Mark a filesystem as NOT valid |
92 | */ |
93 | void ext2fs_unmark_valid(ext2_filsys fs) |
94 | { |
95 | fs->flags &= ~EXT2_FLAG_VALID; |
96 | } |
97 | |
98 | /* |
99 | * Check to see if a filesystem is valid |
100 | */ |
101 | int ext2fs_test_valid(ext2_filsys fs) |
102 | { |
103 | return (fs->flags & EXT2_FLAG_VALID); |
104 | } |
105 | |
106 | /* |
107 | * Mark the inode bitmap as dirty |
108 | */ |
109 | void ext2fs_mark_ib_dirty(ext2_filsys fs) |
110 | { |
111 | fs->flags |= EXT2_FLAG_IB_DIRTY | EXT2_FLAG_CHANGED; |
112 | } |
113 | |
114 | /* |
115 | * Mark the block bitmap as dirty |
116 | */ |
117 | void ext2fs_mark_bb_dirty(ext2_filsys fs) |
118 | { |
119 | fs->flags |= EXT2_FLAG_BB_DIRTY | EXT2_FLAG_CHANGED; |
120 | } |
121 | |
122 | /* |
123 | * Check to see if a filesystem's inode bitmap is dirty |
124 | */ |
125 | int ext2fs_test_ib_dirty(ext2_filsys fs) |
126 | { |
127 | return (fs->flags & EXT2_FLAG_IB_DIRTY); |
128 | } |
129 | |
130 | /* |
131 | * Check to see if a filesystem's block bitmap is dirty |
132 | */ |
133 | int ext2fs_test_bb_dirty(ext2_filsys fs) |
134 | { |
135 | return (fs->flags & EXT2_FLAG_BB_DIRTY); |
136 | } |
137 | |
138 | /* |
139 | * Return the group # of a block |
140 | */ |
141 | int ext2fs_group_of_blk(ext2_filsys fs, blk_t blk) |
142 | { |
143 | return (blk - fs->super->s_first_data_block) / |
144 | fs->super->s_blocks_per_group; |
145 | } |
146 | |
147 | /* |
148 | * Return the group # of an inode number |
149 | */ |
150 | int ext2fs_group_of_ino(ext2_filsys fs, ext2_ino_t ino) |
151 | { |
152 | return (ino - 1) / fs->super->s_inodes_per_group; |
153 | } |
154 | |
155 | blk_t ext2fs_inode_data_blocks(ext2_filsys fs, |
156 | struct ext2_inode *inode) |
157 | { |
158 | return inode->i_blocks - |
159 | (inode->i_file_acl ? fs->blocksize >> 9 : 0); |
160 | } |
161 | |
162 | |
163 | |
164 | |
165 | |
166 | |
167 | |
168 | |
169 | |
170 | __u16 ext2fs_swab16(__u16 val) |
171 | { |
172 | return (val >> 8) | (val << 8); |
173 | } |
174 | |
175 | __u32 ext2fs_swab32(__u32 val) |
176 | { |
177 | return ((val>>24) | ((val>>8)&0xFF00) | |
178 | ((val<<8)&0xFF0000) | (val<<24)); |
179 | } |
180 | |
181 | int ext2fs_test_generic_bitmap(ext2fs_generic_bitmap bitmap, |
182 | blk_t bitno); |
183 | |
184 | int ext2fs_test_generic_bitmap(ext2fs_generic_bitmap bitmap, |
185 | blk_t bitno) |
186 | { |
187 | if ((bitno < bitmap->start) || (bitno > bitmap->end)) { |
188 | ext2fs_warn_bitmap2(bitmap, EXT2FS_TEST_ERROR, bitno); |
189 | return 0; |
190 | } |
191 | return ext2fs_test_bit(bitno - bitmap->start, bitmap->bitmap); |
192 | } |
193 | |
194 | int ext2fs_mark_block_bitmap(ext2fs_block_bitmap bitmap, |
195 | blk_t block) |
196 | { |
197 | return ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) |
198 | bitmap, |
199 | block); |
200 | } |
201 | |
202 | int ext2fs_unmark_block_bitmap(ext2fs_block_bitmap bitmap, |
203 | blk_t block) |
204 | { |
205 | return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, |
206 | block); |
207 | } |
208 | |
209 | int ext2fs_test_block_bitmap(ext2fs_block_bitmap bitmap, |
210 | blk_t block) |
211 | { |
212 | return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap, |
213 | block); |
214 | } |
215 | |
216 | int ext2fs_mark_inode_bitmap(ext2fs_inode_bitmap bitmap, |
217 | ext2_ino_t inode) |
218 | { |
219 | return ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap, |
220 | inode); |
221 | } |
222 | |
223 | int ext2fs_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap, |
224 | ext2_ino_t inode) |
225 | { |
226 | return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, |
227 | inode); |
228 | } |
229 | |
230 | int ext2fs_test_inode_bitmap(ext2fs_inode_bitmap bitmap, |
231 | ext2_ino_t inode) |
232 | { |
233 | return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap, |
234 | inode); |
235 | } |
236 | |
237 | void ext2fs_fast_mark_block_bitmap(ext2fs_block_bitmap bitmap, |
238 | blk_t block) |
239 | { |
240 | ext2fs_set_bit(block - bitmap->start, bitmap->bitmap); |
241 | } |
242 | |
243 | void ext2fs_fast_unmark_block_bitmap(ext2fs_block_bitmap bitmap, |
244 | blk_t block) |
245 | { |
246 | ext2fs_clear_bit(block - bitmap->start, bitmap->bitmap); |
247 | } |
248 | |
249 | int ext2fs_fast_test_block_bitmap(ext2fs_block_bitmap bitmap, |
250 | blk_t block) |
251 | { |
252 | return ext2fs_test_bit(block - bitmap->start, bitmap->bitmap); |
253 | } |
254 | |
255 | void ext2fs_fast_mark_inode_bitmap(ext2fs_inode_bitmap bitmap, |
256 | ext2_ino_t inode) |
257 | { |
258 | ext2fs_set_bit(inode - bitmap->start, bitmap->bitmap); |
259 | } |
260 | |
261 | void ext2fs_fast_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap, |
262 | ext2_ino_t inode) |
263 | { |
264 | ext2fs_clear_bit(inode - bitmap->start, bitmap->bitmap); |
265 | } |
266 | |
267 | int ext2fs_fast_test_inode_bitmap(ext2fs_inode_bitmap bitmap, |
268 | ext2_ino_t inode) |
269 | { |
270 | return ext2fs_test_bit(inode - bitmap->start, bitmap->bitmap); |
271 | } |
272 | |
273 | blk_t ext2fs_get_block_bitmap_start(ext2fs_block_bitmap bitmap) |
274 | { |
275 | return bitmap->start; |
276 | } |
277 | |
278 | ext2_ino_t ext2fs_get_inode_bitmap_start(ext2fs_inode_bitmap bitmap) |
279 | { |
280 | return bitmap->start; |
281 | } |
282 | |
283 | blk_t ext2fs_get_block_bitmap_end(ext2fs_block_bitmap bitmap) |
284 | { |
285 | return bitmap->end; |
286 | } |
287 | |
288 | ext2_ino_t ext2fs_get_inode_bitmap_end(ext2fs_inode_bitmap bitmap) |
289 | { |
290 | return bitmap->end; |
291 | } |
292 | |
293 | int ext2fs_test_block_bitmap_range(ext2fs_block_bitmap bitmap, |
294 | blk_t block, int num) |
295 | { |
296 | int i; |
297 | |
298 | if ((block < bitmap->start) || (block+num-1 > bitmap->end)) { |
299 | ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_TEST, |
300 | block, bitmap->description); |
301 | return 0; |
302 | } |
303 | for (i=0; i < num; i++) { |
304 | if (ext2fs_fast_test_block_bitmap(bitmap, block+i)) |
305 | return 0; |
306 | } |
307 | return 1; |
308 | } |
309 | |
310 | int ext2fs_fast_test_block_bitmap_range(ext2fs_block_bitmap bitmap, |
311 | blk_t block, int num) |
312 | { |
313 | int i; |
314 | |
315 | for (i=0; i < num; i++) { |
316 | if (ext2fs_fast_test_block_bitmap(bitmap, block+i)) |
317 | return 0; |
318 | } |
319 | return 1; |
320 | } |
321 | |
322 | void ext2fs_mark_block_bitmap_range(ext2fs_block_bitmap bitmap, |
323 | blk_t block, int num) |
324 | { |
325 | int i; |
326 | |
327 | if ((block < bitmap->start) || (block+num-1 > bitmap->end)) { |
328 | ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_MARK, block, |
329 | bitmap->description); |
330 | return; |
331 | } |
332 | for (i=0; i < num; i++) |
333 | ext2fs_set_bit(block + i - bitmap->start, bitmap->bitmap); |
334 | } |
335 | |
336 | void ext2fs_fast_mark_block_bitmap_range(ext2fs_block_bitmap bitmap, |
337 | blk_t block, int num) |
338 | { |
339 | int i; |
340 | |
341 | for (i=0; i < num; i++) |
342 | ext2fs_set_bit(block + i - bitmap->start, bitmap->bitmap); |
343 | } |
344 | |
345 | void ext2fs_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap, |
346 | blk_t block, int num) |
347 | { |
348 | int i; |
349 | |
350 | if ((block < bitmap->start) || (block+num-1 > bitmap->end)) { |
351 | ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_UNMARK, block, |
352 | bitmap->description); |
353 | return; |
354 | } |
355 | for (i=0; i < num; i++) |
356 | ext2fs_clear_bit(block + i - bitmap->start, bitmap->bitmap); |
357 | } |
358 | |
359 | void ext2fs_fast_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap, |
360 | blk_t block, int num) |
361 | { |
362 | int i; |
363 | for (i=0; i < num; i++) |
364 | ext2fs_clear_bit(block + i - bitmap->start, bitmap->bitmap); |
365 | } |