diff options
Diffstat (limited to 'e2fsprogs/ext2fs/ext2fs_inline.c')
-rw-r--r-- | e2fsprogs/ext2fs/ext2fs_inline.c | 367 |
1 files changed, 0 insertions, 367 deletions
diff --git a/e2fsprogs/ext2fs/ext2fs_inline.c b/e2fsprogs/ext2fs/ext2fs_inline.c deleted file mode 100644 index da1cf5be5..000000000 --- a/e2fsprogs/ext2fs/ext2fs_inline.c +++ /dev/null | |||
@@ -1,367 +0,0 @@ | |||
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 = realloc(p, size); | ||
54 | if (!p) | ||
55 | return EXT2_ET_NO_MEMORY; | ||
56 | memcpy(ptr, &p, sizeof (p)); | ||
57 | return 0; | ||
58 | } | ||
59 | |||
60 | /* | ||
61 | * Mark a filesystem superblock as dirty | ||
62 | */ | ||
63 | void ext2fs_mark_super_dirty(ext2_filsys fs) | ||
64 | { | ||
65 | fs->flags |= EXT2_FLAG_DIRTY | EXT2_FLAG_CHANGED; | ||
66 | } | ||
67 | |||
68 | /* | ||
69 | * Mark a filesystem as changed | ||
70 | */ | ||
71 | void ext2fs_mark_changed(ext2_filsys fs) | ||
72 | { | ||
73 | fs->flags |= EXT2_FLAG_CHANGED; | ||
74 | } | ||
75 | |||
76 | /* | ||
77 | * Check to see if a filesystem has changed | ||
78 | */ | ||
79 | int ext2fs_test_changed(ext2_filsys fs) | ||
80 | { | ||
81 | return (fs->flags & EXT2_FLAG_CHANGED); | ||
82 | } | ||
83 | |||
84 | /* | ||
85 | * Mark a filesystem as valid | ||
86 | */ | ||
87 | void ext2fs_mark_valid(ext2_filsys fs) | ||
88 | { | ||
89 | fs->flags |= EXT2_FLAG_VALID; | ||
90 | } | ||
91 | |||
92 | /* | ||
93 | * Mark a filesystem as NOT valid | ||
94 | */ | ||
95 | void ext2fs_unmark_valid(ext2_filsys fs) | ||
96 | { | ||
97 | fs->flags &= ~EXT2_FLAG_VALID; | ||
98 | } | ||
99 | |||
100 | /* | ||
101 | * Check to see if a filesystem is valid | ||
102 | */ | ||
103 | int ext2fs_test_valid(ext2_filsys fs) | ||
104 | { | ||
105 | return (fs->flags & EXT2_FLAG_VALID); | ||
106 | } | ||
107 | |||
108 | /* | ||
109 | * Mark the inode bitmap as dirty | ||
110 | */ | ||
111 | void ext2fs_mark_ib_dirty(ext2_filsys fs) | ||
112 | { | ||
113 | fs->flags |= EXT2_FLAG_IB_DIRTY | EXT2_FLAG_CHANGED; | ||
114 | } | ||
115 | |||
116 | /* | ||
117 | * Mark the block bitmap as dirty | ||
118 | */ | ||
119 | void ext2fs_mark_bb_dirty(ext2_filsys fs) | ||
120 | { | ||
121 | fs->flags |= EXT2_FLAG_BB_DIRTY | EXT2_FLAG_CHANGED; | ||
122 | } | ||
123 | |||
124 | /* | ||
125 | * Check to see if a filesystem's inode bitmap is dirty | ||
126 | */ | ||
127 | int ext2fs_test_ib_dirty(ext2_filsys fs) | ||
128 | { | ||
129 | return (fs->flags & EXT2_FLAG_IB_DIRTY); | ||
130 | } | ||
131 | |||
132 | /* | ||
133 | * Check to see if a filesystem's block bitmap is dirty | ||
134 | */ | ||
135 | int ext2fs_test_bb_dirty(ext2_filsys fs) | ||
136 | { | ||
137 | return (fs->flags & EXT2_FLAG_BB_DIRTY); | ||
138 | } | ||
139 | |||
140 | /* | ||
141 | * Return the group # of a block | ||
142 | */ | ||
143 | int ext2fs_group_of_blk(ext2_filsys fs, blk_t blk) | ||
144 | { | ||
145 | return (blk - fs->super->s_first_data_block) / | ||
146 | fs->super->s_blocks_per_group; | ||
147 | } | ||
148 | |||
149 | /* | ||
150 | * Return the group # of an inode number | ||
151 | */ | ||
152 | int ext2fs_group_of_ino(ext2_filsys fs, ext2_ino_t ino) | ||
153 | { | ||
154 | return (ino - 1) / fs->super->s_inodes_per_group; | ||
155 | } | ||
156 | |||
157 | blk_t ext2fs_inode_data_blocks(ext2_filsys fs, | ||
158 | struct ext2_inode *inode) | ||
159 | { | ||
160 | return inode->i_blocks - | ||
161 | (inode->i_file_acl ? fs->blocksize >> 9 : 0); | ||
162 | } | ||
163 | |||
164 | |||
165 | |||
166 | |||
167 | |||
168 | |||
169 | |||
170 | |||
171 | |||
172 | __u16 ext2fs_swab16(__u16 val) | ||
173 | { | ||
174 | return (val >> 8) | (val << 8); | ||
175 | } | ||
176 | |||
177 | __u32 ext2fs_swab32(__u32 val) | ||
178 | { | ||
179 | return ((val>>24) | ((val>>8)&0xFF00) | | ||
180 | ((val<<8)&0xFF0000) | (val<<24)); | ||
181 | } | ||
182 | |||
183 | int ext2fs_test_generic_bitmap(ext2fs_generic_bitmap bitmap, | ||
184 | blk_t bitno); | ||
185 | |||
186 | int ext2fs_test_generic_bitmap(ext2fs_generic_bitmap bitmap, | ||
187 | blk_t bitno) | ||
188 | { | ||
189 | if ((bitno < bitmap->start) || (bitno > bitmap->end)) { | ||
190 | ext2fs_warn_bitmap2(bitmap, EXT2FS_TEST_ERROR, bitno); | ||
191 | return 0; | ||
192 | } | ||
193 | return ext2fs_test_bit(bitno - bitmap->start, bitmap->bitmap); | ||
194 | } | ||
195 | |||
196 | int ext2fs_mark_block_bitmap(ext2fs_block_bitmap bitmap, | ||
197 | blk_t block) | ||
198 | { | ||
199 | return ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) | ||
200 | bitmap, | ||
201 | block); | ||
202 | } | ||
203 | |||
204 | int ext2fs_unmark_block_bitmap(ext2fs_block_bitmap bitmap, | ||
205 | blk_t block) | ||
206 | { | ||
207 | return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, | ||
208 | block); | ||
209 | } | ||
210 | |||
211 | int ext2fs_test_block_bitmap(ext2fs_block_bitmap bitmap, | ||
212 | blk_t block) | ||
213 | { | ||
214 | return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap, | ||
215 | block); | ||
216 | } | ||
217 | |||
218 | int ext2fs_mark_inode_bitmap(ext2fs_inode_bitmap bitmap, | ||
219 | ext2_ino_t inode) | ||
220 | { | ||
221 | return ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap, | ||
222 | inode); | ||
223 | } | ||
224 | |||
225 | int ext2fs_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap, | ||
226 | ext2_ino_t inode) | ||
227 | { | ||
228 | return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, | ||
229 | inode); | ||
230 | } | ||
231 | |||
232 | int ext2fs_test_inode_bitmap(ext2fs_inode_bitmap bitmap, | ||
233 | ext2_ino_t inode) | ||
234 | { | ||
235 | return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap, | ||
236 | inode); | ||
237 | } | ||
238 | |||
239 | void ext2fs_fast_mark_block_bitmap(ext2fs_block_bitmap bitmap, | ||
240 | blk_t block) | ||
241 | { | ||
242 | ext2fs_set_bit(block - bitmap->start, bitmap->bitmap); | ||
243 | } | ||
244 | |||
245 | void ext2fs_fast_unmark_block_bitmap(ext2fs_block_bitmap bitmap, | ||
246 | blk_t block) | ||
247 | { | ||
248 | ext2fs_clear_bit(block - bitmap->start, bitmap->bitmap); | ||
249 | } | ||
250 | |||
251 | int ext2fs_fast_test_block_bitmap(ext2fs_block_bitmap bitmap, | ||
252 | blk_t block) | ||
253 | { | ||
254 | return ext2fs_test_bit(block - bitmap->start, bitmap->bitmap); | ||
255 | } | ||
256 | |||
257 | void ext2fs_fast_mark_inode_bitmap(ext2fs_inode_bitmap bitmap, | ||
258 | ext2_ino_t inode) | ||
259 | { | ||
260 | ext2fs_set_bit(inode - bitmap->start, bitmap->bitmap); | ||
261 | } | ||
262 | |||
263 | void ext2fs_fast_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap, | ||
264 | ext2_ino_t inode) | ||
265 | { | ||
266 | ext2fs_clear_bit(inode - bitmap->start, bitmap->bitmap); | ||
267 | } | ||
268 | |||
269 | int ext2fs_fast_test_inode_bitmap(ext2fs_inode_bitmap bitmap, | ||
270 | ext2_ino_t inode) | ||
271 | { | ||
272 | return ext2fs_test_bit(inode - bitmap->start, bitmap->bitmap); | ||
273 | } | ||
274 | |||
275 | blk_t ext2fs_get_block_bitmap_start(ext2fs_block_bitmap bitmap) | ||
276 | { | ||
277 | return bitmap->start; | ||
278 | } | ||
279 | |||
280 | ext2_ino_t ext2fs_get_inode_bitmap_start(ext2fs_inode_bitmap bitmap) | ||
281 | { | ||
282 | return bitmap->start; | ||
283 | } | ||
284 | |||
285 | blk_t ext2fs_get_block_bitmap_end(ext2fs_block_bitmap bitmap) | ||
286 | { | ||
287 | return bitmap->end; | ||
288 | } | ||
289 | |||
290 | ext2_ino_t ext2fs_get_inode_bitmap_end(ext2fs_inode_bitmap bitmap) | ||
291 | { | ||
292 | return bitmap->end; | ||
293 | } | ||
294 | |||
295 | int ext2fs_test_block_bitmap_range(ext2fs_block_bitmap bitmap, | ||
296 | blk_t block, int num) | ||
297 | { | ||
298 | int i; | ||
299 | |||
300 | if ((block < bitmap->start) || (block+num-1 > bitmap->end)) { | ||
301 | ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_TEST, | ||
302 | block, bitmap->description); | ||
303 | return 0; | ||
304 | } | ||
305 | for (i=0; i < num; i++) { | ||
306 | if (ext2fs_fast_test_block_bitmap(bitmap, block+i)) | ||
307 | return 0; | ||
308 | } | ||
309 | return 1; | ||
310 | } | ||
311 | |||
312 | int ext2fs_fast_test_block_bitmap_range(ext2fs_block_bitmap bitmap, | ||
313 | blk_t block, int num) | ||
314 | { | ||
315 | int i; | ||
316 | |||
317 | for (i=0; i < num; i++) { | ||
318 | if (ext2fs_fast_test_block_bitmap(bitmap, block+i)) | ||
319 | return 0; | ||
320 | } | ||
321 | return 1; | ||
322 | } | ||
323 | |||
324 | void ext2fs_mark_block_bitmap_range(ext2fs_block_bitmap bitmap, | ||
325 | blk_t block, int num) | ||
326 | { | ||
327 | int i; | ||
328 | |||
329 | if ((block < bitmap->start) || (block+num-1 > bitmap->end)) { | ||
330 | ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_MARK, block, | ||
331 | bitmap->description); | ||
332 | return; | ||
333 | } | ||
334 | for (i=0; i < num; i++) | ||
335 | ext2fs_set_bit(block + i - bitmap->start, bitmap->bitmap); | ||
336 | } | ||
337 | |||
338 | void ext2fs_fast_mark_block_bitmap_range(ext2fs_block_bitmap bitmap, | ||
339 | blk_t block, int num) | ||
340 | { | ||
341 | int i; | ||
342 | |||
343 | for (i=0; i < num; i++) | ||
344 | ext2fs_set_bit(block + i - bitmap->start, bitmap->bitmap); | ||
345 | } | ||
346 | |||
347 | void ext2fs_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap, | ||
348 | blk_t block, int num) | ||
349 | { | ||
350 | int i; | ||
351 | |||
352 | if ((block < bitmap->start) || (block+num-1 > bitmap->end)) { | ||
353 | ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_UNMARK, block, | ||
354 | bitmap->description); | ||
355 | return; | ||
356 | } | ||
357 | for (i=0; i < num; i++) | ||
358 | ext2fs_clear_bit(block + i - bitmap->start, bitmap->bitmap); | ||
359 | } | ||
360 | |||
361 | void ext2fs_fast_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap, | ||
362 | blk_t block, int num) | ||
363 | { | ||
364 | int i; | ||
365 | for (i=0; i < num; i++) | ||
366 | ext2fs_clear_bit(block + i - bitmap->start, bitmap->bitmap); | ||
367 | } | ||