lib/ext2fs/blknum.c

   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  */
  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  */
  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  */
  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  */
  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  */
  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  */
  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  */
  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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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 */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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