• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * blknum.c --- Functions to handle blk64_t and high/low 64-bit block
3  * number.
4  *
5  * Copyright IBM Corporation, 2007
6  * Author Jose R. Santos <jrs@us.ibm.com>
7  *
8  * %Begin-Header%
9  * This file may be redistributed under the terms of the GNU Public
10  * License.
11  * %End-Header%
12  */
13 
14 #include "config.h"
15 #include "ext2fs.h"
16 
17 /*
18  * Return the group # of a block
19  */
ext2fs_group_of_blk2(ext2_filsys fs,blk64_t blk)20 dgrp_t ext2fs_group_of_blk2(ext2_filsys fs, blk64_t blk)
21 {
22 	return (blk - fs->super->s_first_data_block) /
23 		fs->super->s_blocks_per_group;
24 }
25 
26 /*
27  * Return the first block (inclusive) in a group
28  */
ext2fs_group_first_block2(ext2_filsys fs,dgrp_t group)29 blk64_t ext2fs_group_first_block2(ext2_filsys fs, dgrp_t group)
30 {
31 	return fs->super->s_first_data_block +
32 		EXT2_GROUPS_TO_BLOCKS(fs->super, group);
33 }
34 
35 /*
36  * Return the last block (inclusive) in a group
37  */
ext2fs_group_last_block2(ext2_filsys fs,dgrp_t group)38 blk64_t ext2fs_group_last_block2(ext2_filsys fs, dgrp_t group)
39 {
40 	return (group == fs->group_desc_count - 1 ?
41 		ext2fs_blocks_count(fs->super) - 1 :
42 		ext2fs_group_first_block2(fs, group) +
43 			(fs->super->s_blocks_per_group - 1));
44 }
45 
46 /*
47  * Return the number of blocks in a group
48  */
ext2fs_group_blocks_count(ext2_filsys fs,dgrp_t group)49 int ext2fs_group_blocks_count(ext2_filsys fs, dgrp_t group)
50 {
51 	int num_blocks;
52 
53 	if (group == fs->group_desc_count - 1) {
54 		num_blocks = (ext2fs_blocks_count(fs->super) -
55 				fs->super->s_first_data_block) %
56 			      fs->super->s_blocks_per_group;
57 		if (!num_blocks)
58 			num_blocks = fs->super->s_blocks_per_group;
59 	} else
60 		num_blocks = fs->super->s_blocks_per_group;
61 
62 	return num_blocks;
63 }
64 
65 /*
66  * Return the inode data block count
67  */
ext2fs_inode_data_blocks2(ext2_filsys fs,struct ext2_inode * inode)68 blk64_t ext2fs_inode_data_blocks2(ext2_filsys fs,
69 					struct ext2_inode *inode)
70 {
71 	return (inode->i_blocks |
72 		(ext2fs_has_feature_huge_file(fs->super) ?
73 		 (__u64) inode->osd2.linux2.l_i_blocks_hi << 32 : 0)) -
74 		(inode->i_file_acl ? EXT2_CLUSTER_SIZE(fs->super) >> 9 : 0);
75 }
76 
77 /*
78  * Return the inode i_blocks count
79  */
ext2fs_inode_i_blocks(ext2_filsys fs,struct ext2_inode * inode)80 blk64_t ext2fs_inode_i_blocks(ext2_filsys fs,
81 					struct ext2_inode *inode)
82 {
83 	return (inode->i_blocks |
84 		(ext2fs_has_feature_huge_file(fs->super) ?
85 		 (__u64)inode->osd2.linux2.l_i_blocks_hi << 32 : 0));
86 }
87 
88 /*
89  * Return the fs block count
90  */
ext2fs_blocks_count(struct ext2_super_block * super)91 blk64_t ext2fs_blocks_count(struct ext2_super_block *super)
92 {
93 	return super->s_blocks_count |
94 		(ext2fs_has_feature_64bit(super) ?
95 		(__u64) super->s_blocks_count_hi << 32 : 0);
96 }
97 
98 /*
99  * Set the fs block count
100  */
ext2fs_blocks_count_set(struct ext2_super_block * super,blk64_t blk)101 void ext2fs_blocks_count_set(struct ext2_super_block *super, blk64_t blk)
102 {
103 	super->s_blocks_count = blk;
104 	if (ext2fs_has_feature_64bit(super))
105 		super->s_blocks_count_hi = (__u64) blk >> 32;
106 }
107 
108 /*
109  * Add to the current fs block count
110  */
ext2fs_blocks_count_add(struct ext2_super_block * super,blk64_t blk)111 void ext2fs_blocks_count_add(struct ext2_super_block *super, blk64_t blk)
112 {
113 	blk64_t tmp;
114 	tmp = ext2fs_blocks_count(super) + blk;
115 	ext2fs_blocks_count_set(super, tmp);
116 }
117 
118 /*
119  * Return the fs reserved block count
120  */
ext2fs_r_blocks_count(struct ext2_super_block * super)121 blk64_t ext2fs_r_blocks_count(struct ext2_super_block *super)
122 {
123 	return super->s_r_blocks_count |
124 		(ext2fs_has_feature_64bit(super) ?
125 		(__u64) super->s_r_blocks_count_hi << 32 : 0);
126 }
127 
128 /*
129  * Set the fs reserved block count
130  */
ext2fs_r_blocks_count_set(struct ext2_super_block * super,blk64_t blk)131 void ext2fs_r_blocks_count_set(struct ext2_super_block *super, blk64_t blk)
132 {
133 	super->s_r_blocks_count = blk;
134 	if (ext2fs_has_feature_64bit(super))
135 		super->s_r_blocks_count_hi = (__u64) blk >> 32;
136 }
137 
138 /*
139  * Add to the current reserved fs block count
140  */
ext2fs_r_blocks_count_add(struct ext2_super_block * super,blk64_t blk)141 void ext2fs_r_blocks_count_add(struct ext2_super_block *super, blk64_t blk)
142 {
143 	blk64_t tmp;
144 	tmp = ext2fs_r_blocks_count(super) + blk;
145 	ext2fs_r_blocks_count_set(super, tmp);
146 }
147 
148 /*
149  * Return the fs free block count
150  */
ext2fs_free_blocks_count(struct ext2_super_block * super)151 blk64_t ext2fs_free_blocks_count(struct ext2_super_block *super)
152 {
153 	return super->s_free_blocks_count |
154 		(ext2fs_has_feature_64bit(super) ?
155 		(__u64) super->s_free_blocks_hi << 32 : 0);
156 }
157 
158 /*
159  * Set the fs free block count
160  */
ext2fs_free_blocks_count_set(struct ext2_super_block * super,blk64_t blk)161 void ext2fs_free_blocks_count_set(struct ext2_super_block *super, blk64_t blk)
162 {
163 	super->s_free_blocks_count = blk;
164 	if (ext2fs_has_feature_64bit(super))
165 		super->s_free_blocks_hi = (__u64) blk >> 32;
166 }
167 
168 /*
169  * Add to the current free fs block count
170  */
ext2fs_free_blocks_count_add(struct ext2_super_block * super,blk64_t blk)171 void ext2fs_free_blocks_count_add(struct ext2_super_block *super, blk64_t blk)
172 {
173 	blk64_t tmp;
174 	tmp = ext2fs_free_blocks_count(super) + blk;
175 	ext2fs_free_blocks_count_set(super, tmp);
176 }
177 
178 /*
179  * Get a pointer to a block group descriptor.  We need the explicit
180  * pointer to the group desc for code that swaps block group
181  * descriptors before writing them out, as it wants to make a copy and
182  * do the swap there.
183  */
ext2fs_group_desc(ext2_filsys fs,struct opaque_ext2_group_desc * gdp,dgrp_t group)184 struct ext2_group_desc *ext2fs_group_desc(ext2_filsys fs,
185 					  struct opaque_ext2_group_desc *gdp,
186 					  dgrp_t group)
187 {
188 	int desc_size = EXT2_DESC_SIZE(fs->super) & ~7;
189 
190 	return (struct ext2_group_desc *)((char *)gdp + group * desc_size);
191 }
192 
193 /* Do the same but as an ext4 group desc for internal use here */
ext4fs_group_desc(ext2_filsys fs,struct opaque_ext2_group_desc * gdp,dgrp_t group)194 static struct ext4_group_desc *ext4fs_group_desc(ext2_filsys fs,
195 					  struct opaque_ext2_group_desc *gdp,
196 					  dgrp_t group)
197 {
198 	return (struct ext4_group_desc *)ext2fs_group_desc(fs, gdp, group);
199 }
200 
201 /*
202  * Return the block bitmap checksum of a group
203  */
ext2fs_block_bitmap_checksum(ext2_filsys fs,dgrp_t group)204 __u32 ext2fs_block_bitmap_checksum(ext2_filsys fs, dgrp_t group)
205 {
206 	struct ext4_group_desc *gdp;
207 	__u32 csum;
208 
209 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
210 	csum = gdp->bg_block_bitmap_csum_lo;
211 	if (EXT2_DESC_SIZE(fs->super) >= EXT4_BG_BLOCK_BITMAP_CSUM_HI_LOCATION)
212 		csum |= ((__u32)gdp->bg_block_bitmap_csum_hi << 16);
213 	return csum;
214 }
215 
216 /*
217  * Return the block bitmap block of a group
218  */
ext2fs_block_bitmap_loc(ext2_filsys fs,dgrp_t group)219 blk64_t ext2fs_block_bitmap_loc(ext2_filsys fs, dgrp_t group)
220 {
221 	struct ext4_group_desc *gdp;
222 
223 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
224 	return gdp->bg_block_bitmap |
225 		(ext2fs_has_feature_64bit(fs->super) ?
226 		 (__u64)gdp->bg_block_bitmap_hi << 32 : 0);
227 }
228 
229 /*
230  * Set the block bitmap block of a group
231  */
ext2fs_block_bitmap_loc_set(ext2_filsys fs,dgrp_t group,blk64_t blk)232 void ext2fs_block_bitmap_loc_set(ext2_filsys fs, dgrp_t group, blk64_t blk)
233 {
234 	struct ext4_group_desc *gdp;
235 
236 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
237 	gdp->bg_block_bitmap = blk;
238 	if (ext2fs_has_feature_64bit(fs->super))
239 		gdp->bg_block_bitmap_hi = (__u64) blk >> 32;
240 }
241 
242 /*
243  * Return the inode bitmap checksum of a group
244  */
ext2fs_inode_bitmap_checksum(ext2_filsys fs,dgrp_t group)245 __u32 ext2fs_inode_bitmap_checksum(ext2_filsys fs, dgrp_t group)
246 {
247 	struct ext4_group_desc *gdp;
248 	__u32 csum;
249 
250 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
251 	csum = gdp->bg_inode_bitmap_csum_lo;
252 	if (EXT2_DESC_SIZE(fs->super) >= EXT4_BG_INODE_BITMAP_CSUM_HI_END)
253 		csum |= ((__u32)gdp->bg_inode_bitmap_csum_hi << 16);
254 	return csum;
255 }
256 
257 /*
258  * Return the inode bitmap block of a group
259  */
ext2fs_inode_bitmap_loc(ext2_filsys fs,dgrp_t group)260 blk64_t ext2fs_inode_bitmap_loc(ext2_filsys fs, dgrp_t group)
261 {
262 	struct ext4_group_desc *gdp;
263 
264 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
265 	return gdp->bg_inode_bitmap |
266 		(ext2fs_has_feature_64bit(fs->super) ?
267 		 (__u64) gdp->bg_inode_bitmap_hi << 32 : 0);
268 }
269 
270 /*
271  * Set the inode bitmap block of a group
272  */
ext2fs_inode_bitmap_loc_set(ext2_filsys fs,dgrp_t group,blk64_t blk)273 void ext2fs_inode_bitmap_loc_set(ext2_filsys fs, dgrp_t group, blk64_t blk)
274 {
275 	struct ext4_group_desc *gdp;
276 
277 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
278 	gdp->bg_inode_bitmap = blk;
279 	if (ext2fs_has_feature_64bit(fs->super))
280 		gdp->bg_inode_bitmap_hi = (__u64) blk >> 32;
281 }
282 
283 /*
284  * Return the inode table block of a group
285  */
ext2fs_inode_table_loc(ext2_filsys fs,dgrp_t group)286 blk64_t ext2fs_inode_table_loc(ext2_filsys fs, dgrp_t group)
287 {
288 	struct ext4_group_desc *gdp;
289 
290 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
291 	return gdp->bg_inode_table |
292 		(ext2fs_has_feature_64bit(fs->super) ?
293 		 (__u64) gdp->bg_inode_table_hi << 32 : 0);
294 }
295 
296 /*
297  * Set the inode table block of a group
298  */
ext2fs_inode_table_loc_set(ext2_filsys fs,dgrp_t group,blk64_t blk)299 void ext2fs_inode_table_loc_set(ext2_filsys fs, dgrp_t group, blk64_t blk)
300 {
301 	struct ext4_group_desc *gdp;
302 
303 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
304 	gdp->bg_inode_table = blk;
305 	if (ext2fs_has_feature_64bit(fs->super))
306 		gdp->bg_inode_table_hi = (__u64) blk >> 32;
307 }
308 
309 /*
310  * Return the free blocks count of a group
311  */
ext2fs_bg_free_blocks_count(ext2_filsys fs,dgrp_t group)312 __u32 ext2fs_bg_free_blocks_count(ext2_filsys fs, dgrp_t group)
313 {
314 	struct ext4_group_desc *gdp;
315 
316 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
317 	return gdp->bg_free_blocks_count |
318 		(ext2fs_has_feature_64bit(fs->super) ?
319 		 (__u32) gdp->bg_free_blocks_count_hi << 16 : 0);
320 }
321 
322 /*
323  * Set the free blocks count of a group
324  */
ext2fs_bg_free_blocks_count_set(ext2_filsys fs,dgrp_t group,__u32 n)325 void ext2fs_bg_free_blocks_count_set(ext2_filsys fs, dgrp_t group, __u32 n)
326 {
327 	struct ext4_group_desc *gdp;
328 
329 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
330 	gdp->bg_free_blocks_count = n;
331 
332 	if (ext2fs_has_feature_64bit(fs->super))
333 		gdp->bg_free_blocks_count_hi = (__u32) n >> 16;
334 }
335 
336 /*
337  * Return the free inodes count of a group
338  */
ext2fs_bg_free_inodes_count(ext2_filsys fs,dgrp_t group)339 __u32 ext2fs_bg_free_inodes_count(ext2_filsys fs, dgrp_t group)
340 {
341 	struct ext4_group_desc *gdp;
342 
343 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
344 	return gdp->bg_free_inodes_count |
345 		(ext2fs_has_feature_64bit(fs->super) ?
346 		 (__u32) gdp->bg_free_inodes_count_hi << 16 : 0);
347 }
348 
349 /*
350  * Set the free inodes count of a group
351  */
ext2fs_bg_free_inodes_count_set(ext2_filsys fs,dgrp_t group,__u32 n)352 void ext2fs_bg_free_inodes_count_set(ext2_filsys fs, dgrp_t group, __u32 n)
353 {
354 	struct ext4_group_desc *gdp;
355 
356 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
357 	gdp->bg_free_inodes_count = n;
358 	if (ext2fs_has_feature_64bit(fs->super))
359 		gdp->bg_free_inodes_count_hi = (__u32) n >> 16;
360 }
361 
362 /*
363  * Return the used dirs count of a group
364  */
ext2fs_bg_used_dirs_count(ext2_filsys fs,dgrp_t group)365 __u32 ext2fs_bg_used_dirs_count(ext2_filsys fs, dgrp_t group)
366 {
367 	struct ext4_group_desc *gdp;
368 
369 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
370 	return gdp->bg_used_dirs_count |
371 		(ext2fs_has_feature_64bit(fs->super) ?
372 		 (__u32) gdp->bg_used_dirs_count_hi << 16 : 0);
373 }
374 
375 /*
376  * Set the used dirs count of a group
377  */
ext2fs_bg_used_dirs_count_set(ext2_filsys fs,dgrp_t group,__u32 n)378 void ext2fs_bg_used_dirs_count_set(ext2_filsys fs, dgrp_t group, __u32 n)
379 {
380 	struct ext4_group_desc *gdp;
381 
382 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
383 	gdp->bg_used_dirs_count = n;
384 	if (ext2fs_has_feature_64bit(fs->super))
385 		gdp->bg_used_dirs_count_hi = (__u32) n >> 16;
386 }
387 
388 /*
389  * Return the unused inodes count of a group
390  */
ext2fs_bg_itable_unused(ext2_filsys fs,dgrp_t group)391 __u32 ext2fs_bg_itable_unused(ext2_filsys fs, dgrp_t group)
392 {
393 	struct ext4_group_desc *gdp;
394 
395 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
396 	return gdp->bg_itable_unused |
397 		(ext2fs_has_feature_64bit(fs->super) ?
398 		 (__u32) gdp->bg_itable_unused_hi << 16 : 0);
399 }
400 
401 /*
402  * Set the unused inodes count of a group
403  */
ext2fs_bg_itable_unused_set(ext2_filsys fs,dgrp_t group,__u32 n)404 void ext2fs_bg_itable_unused_set(ext2_filsys fs, dgrp_t group, __u32 n)
405 {
406 	struct ext4_group_desc *gdp;
407 
408 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
409 	gdp->bg_itable_unused = n;
410 	if (ext2fs_has_feature_64bit(fs->super))
411 		gdp->bg_itable_unused_hi = (__u32) n >> 16;
412 }
413 
414 /*
415  * Get the flags for this block group
416  */
ext2fs_bg_flags(ext2_filsys fs,dgrp_t group)417 __u16 ext2fs_bg_flags(ext2_filsys fs, dgrp_t group)
418 {
419 	struct ext4_group_desc *gdp;
420 
421 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
422 	return gdp->bg_flags;
423 }
424 
425 /*
426  * Zero out the flags for this block group
427  */
ext2fs_bg_flags_zap(ext2_filsys fs,dgrp_t group)428 void ext2fs_bg_flags_zap(ext2_filsys fs, dgrp_t group)
429 {
430 	struct ext4_group_desc *gdp;
431 
432 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
433 	gdp->bg_flags = 0;
434 	return;
435 }
436 
437 /*
438  * Get the value of a particular flag for this block group
439  */
ext2fs_bg_flags_test(ext2_filsys fs,dgrp_t group,__u16 bg_flag)440 int ext2fs_bg_flags_test(ext2_filsys fs, dgrp_t group, __u16 bg_flag)
441 {
442 	struct ext4_group_desc *gdp;
443 
444 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
445 	return gdp->bg_flags & bg_flag;
446 }
447 
448 /*
449  * Set a flag or set of flags for this block group
450  */
ext2fs_bg_flags_set(ext2_filsys fs,dgrp_t group,__u16 bg_flags)451 void ext2fs_bg_flags_set(ext2_filsys fs, dgrp_t group, __u16 bg_flags)
452 {
453 	struct ext4_group_desc *gdp;
454 
455 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
456 	gdp->bg_flags |= bg_flags;
457 	return;
458 }
459 
460 /*
461  * Clear a flag or set of flags for this block group
462  */
ext2fs_bg_flags_clear(ext2_filsys fs,dgrp_t group,__u16 bg_flags)463 void ext2fs_bg_flags_clear(ext2_filsys fs, dgrp_t group, __u16 bg_flags)
464 {
465 	struct ext4_group_desc *gdp;
466 
467 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
468 	gdp->bg_flags &= ~bg_flags;
469 	return;
470 }
471 
472 /*
473  * Get the checksum for this block group
474  */
ext2fs_bg_checksum(ext2_filsys fs,dgrp_t group)475 __u16 ext2fs_bg_checksum(ext2_filsys fs, dgrp_t group)
476 {
477 	struct ext4_group_desc *gdp;
478 
479 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
480 	return gdp->bg_checksum;
481 }
482 
483 /*
484  * Set the checksum for this block group to a previously calculated value
485  */
ext2fs_bg_checksum_set(ext2_filsys fs,dgrp_t group,__u16 checksum)486 void ext2fs_bg_checksum_set(ext2_filsys fs, dgrp_t group, __u16 checksum)
487 {
488 	struct ext4_group_desc *gdp;
489 
490 	gdp = ext4fs_group_desc(fs, fs->group_desc, group);
491 	gdp->bg_checksum = checksum;
492 	return;
493 }
494 
495 /*
496  * Get the acl block of a file
497  */
ext2fs_file_acl_block(ext2_filsys fs,const struct ext2_inode * inode)498 blk64_t ext2fs_file_acl_block(ext2_filsys fs, const struct ext2_inode *inode)
499 {
500 	blk64_t	blk = inode->i_file_acl;
501 
502 	if (fs && ext2fs_has_feature_64bit(fs->super))
503 		blk |= ((__u64) inode->osd2.linux2.l_i_file_acl_high) << 32;
504 	return blk;
505 }
506 
507 /*
508  * Set the acl block of a file
509  */
ext2fs_file_acl_block_set(ext2_filsys fs,struct ext2_inode * inode,blk64_t blk)510 void ext2fs_file_acl_block_set(ext2_filsys fs, struct ext2_inode *inode,
511 			       blk64_t blk)
512 {
513 	inode->i_file_acl = blk;
514 	if (fs && ext2fs_has_feature_64bit(fs->super))
515 		inode->osd2.linux2.l_i_file_acl_high = (__u64) blk >> 32;
516 }
517 
518 /*
519  * Set the size of the inode
520  */
ext2fs_inode_size_set(ext2_filsys fs,struct ext2_inode * inode,ext2_off64_t size)521 errcode_t ext2fs_inode_size_set(ext2_filsys fs, struct ext2_inode *inode,
522 				ext2_off64_t size)
523 {
524 	/* Only regular files get to be larger than 4GB */
525 	if (!LINUX_S_ISREG(inode->i_mode) && (size >> 32))
526 		return EXT2_ET_FILE_TOO_BIG;
527 
528 	/* If we're writing a large file, set the large_file flag */
529 	if (LINUX_S_ISREG(inode->i_mode) &&
530 	    ext2fs_needs_large_file_feature(size) &&
531 	    (!ext2fs_has_feature_large_file(fs->super) ||
532 	     fs->super->s_rev_level == EXT2_GOOD_OLD_REV)) {
533 		ext2fs_set_feature_large_file(fs->super);
534 		ext2fs_update_dynamic_rev(fs);
535 		ext2fs_mark_super_dirty(fs);
536 	}
537 
538 	inode->i_size = size & 0xffffffff;
539 	inode->i_size_high = (size >> 32);
540 
541 	return 0;
542 }
543 
544