lib/ext2fs/ext2fs.h

   1 /*
   2  * ext2fs.h --- ext2fs
   3  *
   4  * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o.
   5  *
   6  * %Begin-Header%
   7  * This file may be redistributed under the terms of the GNU Library
   8  * General Public License, version 2.
   9  * %End-Header%
  10  */
  11
  12 #ifndef _EXT2FS_EXT2FS_H
  13 #define _EXT2FS_EXT2FS_H
  14
  15 #ifdef __GNUC__
  16 #define EXT2FS_ATTR(x) __attribute__(x)
  17 #else
  18 #define EXT2FS_ATTR(x)
  19 #endif
  20
  21 #ifdef __cplusplus
  22 extern "C" {
  23 #endif
  24
  25 /*
  26  * Non-GNU C compilers won't necessarily understand inline
  27  */
  28 #if (!defined(__GNUC__) && !defined(__WATCOMC__))
  29 #define NO_INLINE_FUNCS
  30 #endif
  31
  32 /*
  33  * Where the master copy of the superblock is located, and how big
  34  * superblocks are supposed to be.  We define SUPERBLOCK_SIZE because
  35  * the size of the superblock structure is not necessarily trustworthy
  36  * (some versions have the padding set up so that the superblock is
  37  * 1032 bytes long).
  38  */
  39 #define SUPERBLOCK_OFFSET       1024
  40 #define SUPERBLOCK_SIZE         1024
  41
  42 #define UUID_STR_SIZE 37
  43
  44 /*
  45  * The last ext2fs revision level that this version of the library is
  46  * able to support.
  47  */
  48 #define EXT2_LIB_CURRENT_REV    EXT2_DYNAMIC_REV
  49
  50 #ifdef HAVE_SYS_TYPES_H
  51 #include <sys/types.h>
  52 #endif
  53
  54 #include <stdio.h>
  55 #include <stdlib.h>
  56 #include <string.h>
  57 #include <errno.h>
  58
  59 #if EXT2_FLAT_INCLUDES
  60 #include "e2_types.h"
  61 #include "ext2_fs.h"
  62 #include "ext3_extents.h"
  63 #else
  64 #include <ext2fs/ext2_types.h>
  65 #include <ext2fs/ext2_fs.h>
  66 #include <ext2fs/ext3_extents.h>
  67 #endif /* EXT2_FLAT_INCLUDES */
  68
  69 typedef __u32 __bitwise         ext2_ino_t;
  70 typedef __u32 __bitwise         blk_t;
  71 typedef __u64 __bitwise         blk64_t;
  72 typedef __u32 __bitwise         dgrp_t;
  73 typedef __u32 __bitwise         ext2_off_t;
  74 typedef __u64 __bitwise         ext2_off64_t;
  75 typedef __s64 __bitwise         e2_blkcnt_t;
  76 typedef __u32 __bitwise         ext2_dirhash_t;
  77
  78 #if EXT2_FLAT_INCLUDES
  79 #include "com_err.h"
  80 #include "ext2_io.h"
  81 #include "ext2_err.h"
  82 #include "ext2_ext_attr.h"
  83 #else
  84 #include <et/com_err.h>
  85 #include <ext2fs/ext2_io.h>
  86 #include <ext2fs/ext2_err.h>
  87 #include <ext2fs/ext2_ext_attr.h>
  88 #endif
  89
  90 /*
  91  * Portability help for Microsoft Visual C++
  92  */
  93 #ifdef _MSC_VER
  94 #define EXT2_QSORT_TYPE int __cdecl
  95 #else
  96 #define EXT2_QSORT_TYPE int
  97 #endif
  98
  99 typedef struct struct_ext2_filsys *ext2_filsys;
 100
 101 #define EXT2FS_MARK_ERROR       0
 102 #define EXT2FS_UNMARK_ERROR     1
 103 #define EXT2FS_TEST_ERROR       2
 104
 105 typedef struct ext2fs_struct_generic_bitmap *ext2fs_generic_bitmap;
 106 typedef struct ext2fs_struct_generic_bitmap *ext2fs_inode_bitmap;
 107 typedef struct ext2fs_struct_generic_bitmap *ext2fs_block_bitmap;
 108
 109 #define EXT2_FIRST_INODE(s)     EXT2_FIRST_INO(s)
 110
 111
 112 /*
 113  * Badblocks list definitions
 114  */
 115
 116 typedef struct ext2_struct_u32_list *ext2_badblocks_list;
 117 typedef struct ext2_struct_u32_iterate *ext2_badblocks_iterate;
 118
 119 typedef struct ext2_struct_u32_list *ext2_u32_list;
 120 typedef struct ext2_struct_u32_iterate *ext2_u32_iterate;
 121
 122 /* old */
 123 typedef struct ext2_struct_u32_list *badblocks_list;
 124 typedef struct ext2_struct_u32_iterate *badblocks_iterate;
 125
 126 #define BADBLOCKS_FLAG_DIRTY    1
 127
 128 /*
 129  * ext2_dblist structure and abstractions (see dblist.c)
 130  */
 131 struct ext2_db_entry2 {
 132         ext2_ino_t      ino;
 133         blk64_t blk;
 134         e2_blkcnt_t     blockcnt;
 135 };
 136
 137 /* Ye Olde 32-bit version */
 138 struct ext2_db_entry {
 139         ext2_ino_t      ino;
 140         blk_t   blk;
 141         int     blockcnt;
 142 };
 143
 144 typedef struct ext2_struct_dblist *ext2_dblist;
 145
 146 #define DBLIST_ABORT    1
 147
 148 /*
 149  * ext2_fileio definitions
 150  */
 151
 152 #define EXT2_FILE_WRITE         0x0001
 153 #define EXT2_FILE_CREATE        0x0002
 154
 155 #define EXT2_FILE_MASK          0x00FF
 156
 157 #define EXT2_FILE_BUF_DIRTY     0x4000
 158 #define EXT2_FILE_BUF_VALID     0x2000
 159
 160 typedef struct ext2_file *ext2_file_t;
 161
 162 #define EXT2_SEEK_SET   0
 163 #define EXT2_SEEK_CUR   1
 164 #define EXT2_SEEK_END   2
 165
 166 /*
 167  * Flags for the ext2_filsys structure and for ext2fs_open()
 168  */
 169 #define EXT2_FLAG_RW                    0x01
 170 #define EXT2_FLAG_CHANGED               0x02
 171 #define EXT2_FLAG_DIRTY                 0x04
 172 #define EXT2_FLAG_VALID                 0x08
 173 #define EXT2_FLAG_IB_DIRTY              0x10
 174 #define EXT2_FLAG_BB_DIRTY              0x20
 175 #define EXT2_FLAG_SWAP_BYTES            0x40
 176 #define EXT2_FLAG_SWAP_BYTES_READ       0x80
 177 #define EXT2_FLAG_SWAP_BYTES_WRITE      0x100
 178 #define EXT2_FLAG_MASTER_SB_ONLY        0x200
 179 #define EXT2_FLAG_FORCE                 0x400
 180 #define EXT2_FLAG_SUPER_ONLY            0x800
 181 #define EXT2_FLAG_JOURNAL_DEV_OK        0x1000
 182 #define EXT2_FLAG_IMAGE_FILE            0x2000
 183 #define EXT2_FLAG_EXCLUSIVE             0x4000
 184 #define EXT2_FLAG_SOFTSUPP_FEATURES     0x8000
 185 #define EXT2_FLAG_NOFREE_ON_ERROR       0x10000
 186 #define EXT2_FLAG_64BITS                0x20000
 187 #define EXT2_FLAG_PRINT_PROGRESS        0x40000
 188 #define EXT2_FLAG_DIRECT_IO             0x80000
 189 #define EXT2_FLAG_SKIP_MMP              0x100000
 190 #define EXT2_FLAG_IGNORE_CSUM_ERRORS    0x200000
 191
 192 /*
 193  * Special flag in the ext2 inode i_flag field that means that this is
 194  * a new inode.  (So that ext2_write_inode() can clear extra fields.)
 195  */
 196 #define EXT2_NEW_INODE_FL       0x80000000
 197
 198 /*
 199  * Flags for mkjournal
 200  */
 201 #define EXT2_MKJOURNAL_V1_SUPER 0x0000001 /* create V1 superblock (deprecated) */
 202 #define EXT2_MKJOURNAL_LAZYINIT 0x0000002 /* don't zero journal inode before use*/
 203 #define EXT2_MKJOURNAL_NO_MNT_CHECK 0x0000004 /* don't check mount status */
 204
 205 struct opaque_ext2_group_desc;
 206
 207 struct struct_ext2_filsys {
 208         errcode_t                       magic;
 209         io_channel                      io;
 210         int                             flags;
 211         char *                          device_name;
 212         struct ext2_super_block *       super;
 213         unsigned int                    blocksize;
 214         int                             fragsize;
 215         dgrp_t                          group_desc_count;
 216         unsigned long                   desc_blocks;
 217         struct opaque_ext2_group_desc * group_desc;
 218         unsigned int                    inode_blocks_per_group;
 219         ext2fs_inode_bitmap             inode_map;
 220         ext2fs_block_bitmap             block_map;
 221         /* XXX FIXME-64: not 64-bit safe, but not used? */
 222         errcode_t (*get_blocks)(ext2_filsys fs, ext2_ino_t ino, blk_t *blocks);
 223         errcode_t (*check_directory)(ext2_filsys fs, ext2_ino_t ino);
 224         errcode_t (*write_bitmaps)(ext2_filsys fs);
 225         errcode_t (*read_inode)(ext2_filsys fs, ext2_ino_t ino,
 226                                 struct ext2_inode *inode);
 227         errcode_t (*write_inode)(ext2_filsys fs, ext2_ino_t ino,
 228                                 struct ext2_inode *inode);
 229         ext2_badblocks_list             badblocks;
 230         ext2_dblist                     dblist;
 231         __u32                           stride; /* for mke2fs */
 232         struct ext2_super_block *       orig_super;
 233         struct ext2_image_hdr *         image_header;
 234         __u32                           umask;
 235         time_t                          now;
 236         int                             cluster_ratio_bits;
 237         __u16                           default_bitmap_type;
 238         __u16                           pad;
 239         /*
 240          * Reserved for future expansion
 241          */
 242         __u32                           reserved[5];
 243
 244         /*
 245          * Reserved for the use of the calling application.
 246          */
 247         void *                          priv_data;
 248
 249         /*
 250          * Inode cache
 251          */
 252         struct ext2_inode_cache         *icache;
 253         io_channel                      image_io;
 254
 255         /*
 256          * More callback functions
 257          */
 258         errcode_t (*get_alloc_block)(ext2_filsys fs, blk64_t goal,
 259                                      blk64_t *ret);
 260         void (*block_alloc_stats)(ext2_filsys fs, blk64_t blk, int inuse);
 261
 262         /*
 263          * Buffers for Multiple mount protection(MMP) block.
 264          */
 265         void *mmp_buf;
 266         void *mmp_cmp;
 267         int mmp_fd;
 268
 269         /*
 270          * Time at which e2fsck last updated the MMP block.
 271          */
 272         long mmp_last_written;
 273
 274         /* progress operation functions */
 275         struct ext2fs_progress_ops *progress_ops;
 276
 277         /* Precomputed FS UUID checksum for seeding other checksums */
 278         __u32 csum_seed;
 279
 280         io_channel                      journal_io;
 281         char                            *journal_name;
 282
 283         /* New block range allocation hooks */
 284         errcode_t (*new_range)(ext2_filsys fs, int flags, blk64_t goal,
 285                                blk64_t len, blk64_t *pblk, blk64_t *plen);
 286         void (*block_alloc_stats_range)(ext2_filsys fs, blk64_t blk, blk_t num,
 287                                         int inuse);
 288 };
 289
 290 #if EXT2_FLAT_INCLUDES
 291 #include "e2_bitops.h"
 292 #else
 293 #include <ext2fs/bitops.h>
 294 #endif
 295
 296 /*
 297  * 64-bit bitmap backend types
 298  */
 299 #define EXT2FS_BMAP64_BITARRAY  1
 300 #define EXT2FS_BMAP64_RBTREE    2
 301 #define EXT2FS_BMAP64_AUTODIR   3
 302
 303 /*
 304  * Return flags for the block iterator functions
 305  */
 306 #define BLOCK_CHANGED                   1
 307 #define BLOCK_ABORT                     2
 308 #define BLOCK_ERROR                     4
 309 #define BLOCK_INLINE_DATA_CHANGED       8
 310
 311 /*
 312  * Block interate flags
 313  *
 314  * BLOCK_FLAG_APPEND, or BLOCK_FLAG_HOLE, indicates that the interator
 315  * function should be called on blocks where the block number is zero.
 316  * This is used by ext2fs_expand_dir() to be able to add a new block
 317  * to an inode.  It can also be used for programs that want to be able
 318  * to deal with files that contain "holes".
 319  *
 320  * BLOCK_FLAG_DEPTH_TRAVERSE indicates that the iterator function for
 321  * the indirect, doubly indirect, etc. blocks should be called after
 322  * all of the blocks containined in the indirect blocks are processed.
 323  * This is useful if you are going to be deallocating blocks from an
 324  * inode.
 325  *
 326  * BLOCK_FLAG_DATA_ONLY indicates that the iterator function should be
 327  * called for data blocks only.
 328  *
 329  * BLOCK_FLAG_READ_ONLY is a promise by the caller that it will not
 330  * modify returned block number.
 331  *
 332  * BLOCK_FLAG_NO_LARGE is for internal use only.  It informs
 333  * ext2fs_block_iterate2 that large files won't be accepted.
 334  */
 335 #define BLOCK_FLAG_APPEND       1
 336 #define BLOCK_FLAG_HOLE         1
 337 #define BLOCK_FLAG_DEPTH_TRAVERSE       2
 338 #define BLOCK_FLAG_DATA_ONLY    4
 339 #define BLOCK_FLAG_READ_ONLY    8
 340
 341 #define BLOCK_FLAG_NO_LARGE     0x1000
 342
 343 /*
 344  * Magic "block count" return values for the block iterator function.
 345  */
 346 #define BLOCK_COUNT_IND         (-1)
 347 #define BLOCK_COUNT_DIND        (-2)
 348 #define BLOCK_COUNT_TIND        (-3)
 349 #define BLOCK_COUNT_TRANSLATOR  (-4)
 350
 351 #if 0
 352 /*
 353  * Flags for ext2fs_move_blocks
 354  */
 355 #define EXT2_BMOVE_GET_DBLIST   0x0001
 356 #define EXT2_BMOVE_DEBUG        0x0002
 357 #endif
 358
 359 /*
 360  * Generic (non-filesystem layout specific) extents structure
 361  */
 362
 363 #define EXT2_EXTENT_FLAGS_LEAF          0x0001
 364 #define EXT2_EXTENT_FLAGS_UNINIT        0x0002
 365 #define EXT2_EXTENT_FLAGS_SECOND_VISIT  0x0004
 366
 367 struct ext2fs_extent {
 368         blk64_t e_pblk;         /* first physical block */
 369         blk64_t e_lblk;         /* first logical block extent covers */
 370         __u32   e_len;          /* number of blocks covered by extent */
 371         __u32   e_flags;        /* extent flags */
 372 };
 373
 374 typedef struct ext2_extent_handle *ext2_extent_handle_t;
 375 typedef struct ext2_extent_path *ext2_extent_path_t;
 376
 377 /*
 378  * Flags used by ext2fs_extent_get()
 379  */
 380 #define EXT2_EXTENT_CURRENT     0x0000
 381 #define EXT2_EXTENT_MOVE_MASK   0x000F
 382 #define EXT2_EXTENT_ROOT        0x0001
 383 #define EXT2_EXTENT_LAST_LEAF   0x0002
 384 #define EXT2_EXTENT_FIRST_SIB   0x0003
 385 #define EXT2_EXTENT_LAST_SIB    0x0004
 386 #define EXT2_EXTENT_NEXT_SIB    0x0005
 387 #define EXT2_EXTENT_PREV_SIB    0x0006
 388 #define EXT2_EXTENT_NEXT_LEAF   0x0007
 389 #define EXT2_EXTENT_PREV_LEAF   0x0008
 390 #define EXT2_EXTENT_NEXT        0x0009
 391 #define EXT2_EXTENT_PREV        0x000A
 392 #define EXT2_EXTENT_UP          0x000B
 393 #define EXT2_EXTENT_DOWN        0x000C
 394 #define EXT2_EXTENT_DOWN_AND_LAST 0x000D
 395
 396 /*
 397  * Flags used by ext2fs_extent_insert()
 398  */
 399 #define EXT2_EXTENT_INSERT_AFTER        0x0001 /* insert after handle loc'n */
 400 #define EXT2_EXTENT_INSERT_NOSPLIT      0x0002 /* insert may not cause split */
 401
 402 /*
 403  * Flags used by ext2fs_extent_delete()
 404  */
 405 #define EXT2_EXTENT_DELETE_KEEP_EMPTY   0x001 /* keep node if last extnt gone */
 406
 407 /*
 408  * Flags used by ext2fs_extent_set_bmap()
 409  */
 410 #define EXT2_EXTENT_SET_BMAP_UNINIT     0x0001
 411
 412 /*
 413  * Data structure returned by ext2fs_extent_get_info()
 414  */
 415 struct ext2_extent_info {
 416         int             curr_entry;
 417         int             curr_level;
 418         int             num_entries;
 419         int             max_entries;
 420         int             max_depth;
 421         int             bytes_avail;
 422         blk64_t         max_lblk;
 423         blk64_t         max_pblk;
 424         __u32           max_len;
 425         __u32           max_uninit_len;
 426 };
 427
 428 /*
 429  * Flags for directory block reading and writing functions
 430  */
 431 #define EXT2_DIRBLOCK_V2_STRUCT 0x0001
 432
 433 /*
 434  * Return flags for the directory iterator functions
 435  */
 436 #define DIRENT_CHANGED  1
 437 #define DIRENT_ABORT    2
 438 #define DIRENT_ERROR    3
 439
 440 /*
 441  * Directory iterator flags
 442  */
 443
 444 #define DIRENT_FLAG_INCLUDE_EMPTY       1
 445 #define DIRENT_FLAG_INCLUDE_REMOVED     2
 446 #define DIRENT_FLAG_INCLUDE_CSUM        4
 447 #define DIRENT_FLAG_INCLUDE_INLINE_DATA 8
 448
 449 #define DIRENT_DOT_FILE         1
 450 #define DIRENT_DOT_DOT_FILE     2
 451 #define DIRENT_OTHER_FILE       3
 452 #define DIRENT_DELETED_FILE     4
 453 #define DIRENT_CHECKSUM         5
 454
 455 /*
 456  * Inode scan definitions
 457  */
 458 typedef struct ext2_struct_inode_scan *ext2_inode_scan;
 459
 460 /*
 461  * ext2fs_scan flags
 462  */
 463 #define EXT2_SF_CHK_BADBLOCKS   0x0001
 464 #define EXT2_SF_BAD_INODE_BLK   0x0002
 465 #define EXT2_SF_BAD_EXTRA_BYTES 0x0004
 466 #define EXT2_SF_SKIP_MISSING_ITABLE     0x0008
 467 #define EXT2_SF_DO_LAZY         0x0010
 468 #define EXT2_SF_WARN_GARBAGE_INODES     0x0020
 469
 470 /*
 471  * ext2fs_check_if_mounted flags
 472  */
 473 #define EXT2_MF_MOUNTED         1
 474 #define EXT2_MF_ISROOT          2
 475 #define EXT2_MF_READONLY        4
 476 #define EXT2_MF_SWAP            8
 477 #define EXT2_MF_BUSY            16
 478
 479 /*
 480  * Ext2/linux mode flags.  We define them here so that we don't need
 481  * to depend on the OS's sys/stat.h, since we may be compiling on a
 482  * non-Linux system.
 483  */
 484 #define LINUX_S_IFMT  00170000
 485 #define LINUX_S_IFSOCK 0140000
 486 #define LINUX_S_IFLNK    0120000
 487 #define LINUX_S_IFREG  0100000
 488 #define LINUX_S_IFBLK  0060000
 489 #define LINUX_S_IFDIR  0040000
 490 #define LINUX_S_IFCHR  0020000
 491 #define LINUX_S_IFIFO  0010000
 492 #define LINUX_S_ISUID  0004000
 493 #define LINUX_S_ISGID  0002000
 494 #define LINUX_S_ISVTX  0001000
 495
 496 #define LINUX_S_IRWXU 00700
 497 #define LINUX_S_IRUSR 00400
 498 #define LINUX_S_IWUSR 00200
 499 #define LINUX_S_IXUSR 00100
 500
 501 #define LINUX_S_IRWXG 00070
 502 #define LINUX_S_IRGRP 00040
 503 #define LINUX_S_IWGRP 00020
 504 #define LINUX_S_IXGRP 00010
 505
 506 #define LINUX_S_IRWXO 00007
 507 #define LINUX_S_IROTH 00004
 508 #define LINUX_S_IWOTH 00002
 509 #define LINUX_S_IXOTH 00001
 510
 511 #define LINUX_S_ISLNK(m)        (((m) & LINUX_S_IFMT) == LINUX_S_IFLNK)
 512 #define LINUX_S_ISREG(m)        (((m) & LINUX_S_IFMT) == LINUX_S_IFREG)
 513 #define LINUX_S_ISDIR(m)        (((m) & LINUX_S_IFMT) == LINUX_S_IFDIR)
 514 #define LINUX_S_ISCHR(m)        (((m) & LINUX_S_IFMT) == LINUX_S_IFCHR)
 515 #define LINUX_S_ISBLK(m)        (((m) & LINUX_S_IFMT) == LINUX_S_IFBLK)
 516 #define LINUX_S_ISFIFO(m)       (((m) & LINUX_S_IFMT) == LINUX_S_IFIFO)
 517 #define LINUX_S_ISSOCK(m)       (((m) & LINUX_S_IFMT) == LINUX_S_IFSOCK)
 518
 519 /*
 520  * ext2 size of an inode
 521  */
 522 #define EXT2_I_SIZE(i)  ((i)->i_size | ((__u64) (i)->i_size_high << 32))
 523
 524 /*
 525  * ext2_icount_t abstraction
 526  */
 527 #define EXT2_ICOUNT_OPT_INCREMENT       0x01
 528
 529 typedef struct ext2_icount *ext2_icount_t;
 530
 531 /*
 532  * Flags for ext2fs_bmap
 533  */
 534 #define BMAP_ALLOC      0x0001
 535 #define BMAP_SET        0x0002
 536 #define BMAP_UNINIT     0x0004
 537 #define BMAP_ZERO       0x0008
 538
 539 /*
 540  * Returned flags from ext2fs_bmap
 541  */
 542 #define BMAP_RET_UNINIT 0x0001
 543
 544 /*
 545  * Flags for imager.c functions
 546  */
 547 #define IMAGER_FLAG_INODEMAP    1
 548 #define IMAGER_FLAG_SPARSEWRITE 2
 549
 550 /*
 551  * For checking structure magic numbers...
 552  */
 553
 554 #define EXT2_CHECK_MAGIC(struct, code) \
 555           if ((struct)->magic != (code)) return (code)
 556
 557 /*
 558  * Features supported by this version of the library
 559  */
 560 #define EXT2_LIB_FEATURE_COMPAT_SUPP    (EXT2_FEATURE_COMPAT_DIR_PREALLOC|\
 561                                          EXT2_FEATURE_COMPAT_IMAGIC_INODES|\
 562                                          EXT3_FEATURE_COMPAT_HAS_JOURNAL|\
 563                                          EXT2_FEATURE_COMPAT_RESIZE_INODE|\
 564                                          EXT2_FEATURE_COMPAT_DIR_INDEX|\
 565                                          EXT2_FEATURE_COMPAT_EXT_ATTR|\
 566                                          EXT4_FEATURE_COMPAT_SPARSE_SUPER2)
 567
 568 #ifdef CONFIG_MMP
 569 #define EXT4_LIB_INCOMPAT_MMP           EXT4_FEATURE_INCOMPAT_MMP
 570 #else
 571 #define EXT4_LIB_INCOMPAT_MMP           (0)
 572 #endif
 573
 574 #define EXT2_LIB_FEATURE_INCOMPAT_SUPP  (EXT2_FEATURE_INCOMPAT_FILETYPE|\
 575                                          EXT3_FEATURE_INCOMPAT_JOURNAL_DEV|\
 576                                          EXT2_FEATURE_INCOMPAT_META_BG|\
 577                                          EXT3_FEATURE_INCOMPAT_RECOVER|\
 578                                          EXT3_FEATURE_INCOMPAT_EXTENTS|\
 579                                          EXT4_FEATURE_INCOMPAT_FLEX_BG|\
 580                                          EXT4_LIB_INCOMPAT_MMP|\
 581                                          EXT4_FEATURE_INCOMPAT_64BIT|\
 582                                          EXT4_FEATURE_INCOMPAT_INLINE_DATA|\
 583                                          EXT4_FEATURE_INCOMPAT_ENCRYPT)
 584
 585 #define EXT2_LIB_FEATURE_RO_COMPAT_SUPP (EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER|\
 586                                          EXT4_FEATURE_RO_COMPAT_HUGE_FILE|\
 587                                          EXT2_FEATURE_RO_COMPAT_LARGE_FILE|\
 588                                          EXT4_FEATURE_RO_COMPAT_DIR_NLINK|\
 589                                          EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE|\
 590                                          EXT4_FEATURE_RO_COMPAT_GDT_CSUM|\
 591                                          EXT4_FEATURE_RO_COMPAT_BIGALLOC|\
 592                                          EXT4_FEATURE_RO_COMPAT_QUOTA|\
 593                                          EXT4_FEATURE_RO_COMPAT_METADATA_CSUM|\
 594                                          EXT4_FEATURE_RO_COMPAT_READONLY)
 595
 596 /*
 597  * These features are only allowed if EXT2_FLAG_SOFTSUPP_FEATURES is passed
 598  * to ext2fs_openfs()
 599  */
 600 #define EXT2_LIB_SOFTSUPP_INCOMPAT      (0)
 601 #define EXT2_LIB_SOFTSUPP_RO_COMPAT     (EXT4_FEATURE_RO_COMPAT_REPLICA)
 602
 603
 604 /* Translate a block number to a cluster number */
 605 #define EXT2FS_CLUSTER_RATIO(fs)        (1 << (fs)->cluster_ratio_bits)
 606 #define EXT2FS_CLUSTER_MASK(fs)         (EXT2FS_CLUSTER_RATIO(fs) - 1)
 607 #define EXT2FS_B2C(fs, blk)             ((blk) >> (fs)->cluster_ratio_bits)
 608 /* Translate a cluster number to a block number */
 609 #define EXT2FS_C2B(fs, cluster)         ((cluster) << (fs)->cluster_ratio_bits)
 610 /* Translate # of blks to # of clusters */
 611 #define EXT2FS_NUM_B2C(fs, blks)        (((blks) + EXT2FS_CLUSTER_MASK(fs)) >> \
 612                                          (fs)->cluster_ratio_bits)
 613
 614 #if defined(HAVE_FSTAT64) && !defined(__OSX_AVAILABLE_BUT_DEPRECATED)
 615 typedef struct stat64 ext2fs_struct_stat;
 616 #else
 617 typedef struct stat ext2fs_struct_stat;
 618 #endif
 619
 620 /*
 621  * For ext2fs_close2() and ext2fs_flush2(), this flag allows you to
 622  * avoid the fsync call.
 623  */
 624 #define EXT2_FLAG_FLUSH_NO_SYNC          1
 625
 626 /*
 627  * Modify and iterate extended attributes
 628  */
 629 struct ext2_xattr_handle;
 630 #define XATTR_ABORT     1
 631 #define XATTR_CHANGED   2
 632
 633 /*
 634  * function prototypes
 635  */
 636 static inline int ext2fs_has_group_desc_csum(ext2_filsys fs)
 637 {
 638         return EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
 639                         EXT4_FEATURE_RO_COMPAT_GDT_CSUM |
 640                         EXT4_FEATURE_RO_COMPAT_METADATA_CSUM);
 641 }
 642
 643 /* The LARGE_FILE feature should be set if we have stored files 2GB+ in size */
 644 static inline int ext2fs_needs_large_file_feature(unsigned long long file_size)
 645 {
 646         return file_size >= 0x80000000ULL;
 647 }
 648
 649 /* alloc.c */
 650 extern errcode_t ext2fs_new_inode(ext2_filsys fs, ext2_ino_t dir, int mode,
 651                                   ext2fs_inode_bitmap map, ext2_ino_t *ret);
 652 extern errcode_t ext2fs_new_block(ext2_filsys fs, blk_t goal,
 653                                   ext2fs_block_bitmap map, blk_t *ret);
 654 extern errcode_t ext2fs_new_block2(ext2_filsys fs, blk64_t goal,
 655                                    ext2fs_block_bitmap map, blk64_t *ret);
 656 extern errcode_t ext2fs_get_free_blocks(ext2_filsys fs, blk_t start,
 657                                         blk_t finish, int num,
 658                                         ext2fs_block_bitmap map,
 659                                         blk_t *ret);
 660 extern errcode_t ext2fs_get_free_blocks2(ext2_filsys fs, blk64_t start,
 661                                          blk64_t finish, int num,
 662                                          ext2fs_block_bitmap map,
 663                                          blk64_t *ret);
 664 extern errcode_t ext2fs_alloc_block(ext2_filsys fs, blk_t goal,
 665                                     char *block_buf, blk_t *ret);
 666 extern errcode_t ext2fs_alloc_block2(ext2_filsys fs, blk64_t goal,
 667                                      char *block_buf, blk64_t *ret);
 668 extern void ext2fs_set_alloc_block_callback(ext2_filsys fs,
 669                                             errcode_t (*func)(ext2_filsys fs,
 670                                                               blk64_t goal,
 671                                                               blk64_t *ret),
 672                                             errcode_t (**old)(ext2_filsys fs,
 673                                                               blk64_t goal,
 674                                                               blk64_t *ret));
 675 blk64_t ext2fs_find_inode_goal(ext2_filsys fs, ext2_ino_t ino,
 676                                struct ext2_inode *inode, blk64_t lblk);
 677 extern void ext2fs_set_new_range_callback(ext2_filsys fs,
 678         errcode_t (*func)(ext2_filsys fs, int flags, blk64_t goal,
 679                                blk64_t len, blk64_t *pblk, blk64_t *plen),
 680         errcode_t (**old)(ext2_filsys fs, int flags, blk64_t goal,
 681                                blk64_t len, blk64_t *pblk, blk64_t *plen));
 682 extern void ext2fs_set_block_alloc_stats_range_callback(ext2_filsys fs,
 683         void (*func)(ext2_filsys fs, blk64_t blk,
 684                                     blk_t num, int inuse),
 685         void (**old)(ext2_filsys fs, blk64_t blk,
 686                                     blk_t num, int inuse));
 687 #define EXT2_NEWRANGE_FIXED_GOAL        (0x1)
 688 #define EXT2_NEWRANGE_MIN_LENGTH        (0x2)
 689 #define EXT2_NEWRANGE_ALL_FLAGS         (0x3)
 690 errcode_t ext2fs_new_range(ext2_filsys fs, int flags, blk64_t goal,
 691                            blk64_t len, ext2fs_block_bitmap map, blk64_t *pblk,
 692                            blk64_t *plen);
 693 #define EXT2_ALLOCRANGE_FIXED_GOAL      (0x1)
 694 #define EXT2_ALLOCRANGE_ZERO_BLOCKS     (0x2)
 695 #define EXT2_ALLOCRANGE_ALL_FLAGS       (0x3)
 696 errcode_t ext2fs_alloc_range(ext2_filsys fs, int flags, blk64_t goal,
 697                              blk_t len, blk64_t *ret);
 698
 699 /* alloc_sb.c */
 700 extern int ext2fs_reserve_super_and_bgd(ext2_filsys fs,
 701                                         dgrp_t group,
 702                                         ext2fs_block_bitmap bmap);
 703 extern void ext2fs_set_block_alloc_stats_callback(ext2_filsys fs,
 704                                                   void (*func)(ext2_filsys fs,
 705                                                                blk64_t blk,
 706                                                                int inuse),
 707                                                   void (**old)(ext2_filsys fs,
 708                                                                blk64_t blk,
 709                                                                int inuse));
 710
 711 /* alloc_stats.c */
 712 void ext2fs_inode_alloc_stats(ext2_filsys fs, ext2_ino_t ino, int inuse);
 713 void ext2fs_inode_alloc_stats2(ext2_filsys fs, ext2_ino_t ino,
 714                                int inuse, int isdir);
 715 void ext2fs_block_alloc_stats(ext2_filsys fs, blk_t blk, int inuse);
 716 void ext2fs_block_alloc_stats2(ext2_filsys fs, blk64_t blk, int inuse);
 717 void ext2fs_block_alloc_stats_range(ext2_filsys fs, blk64_t blk,
 718                                     blk_t num, int inuse);
 719
 720 /* alloc_tables.c */
 721 extern errcode_t ext2fs_allocate_tables(ext2_filsys fs);
 722 extern errcode_t ext2fs_allocate_group_table(ext2_filsys fs, dgrp_t group,
 723                                              ext2fs_block_bitmap bmap);
 724
 725 /* badblocks.c */
 726 extern errcode_t ext2fs_u32_list_create(ext2_u32_list *ret, int size);
 727 extern errcode_t ext2fs_u32_list_add(ext2_u32_list bb, __u32 blk);
 728 extern int ext2fs_u32_list_find(ext2_u32_list bb, __u32 blk);
 729 extern int ext2fs_u32_list_test(ext2_u32_list bb, blk_t blk);
 730 extern errcode_t ext2fs_u32_list_iterate_begin(ext2_u32_list bb,
 731                                                ext2_u32_iterate *ret);
 732 extern int ext2fs_u32_list_iterate(ext2_u32_iterate iter, blk_t *blk);
 733 extern void ext2fs_u32_list_iterate_end(ext2_u32_iterate iter);
 734 extern errcode_t ext2fs_u32_copy(ext2_u32_list src, ext2_u32_list *dest);
 735 extern int ext2fs_u32_list_equal(ext2_u32_list bb1, ext2_u32_list bb2);
 736
 737 extern errcode_t ext2fs_badblocks_list_create(ext2_badblocks_list *ret,
 738                                             int size);
 739 extern errcode_t ext2fs_badblocks_list_add(ext2_badblocks_list bb,
 740                                            blk_t blk);
 741 extern int ext2fs_badblocks_list_test(ext2_badblocks_list bb,
 742                                     blk_t blk);
 743 extern int ext2fs_u32_list_del(ext2_u32_list bb, __u32 blk);
 744 extern void ext2fs_badblocks_list_del(ext2_u32_list bb, __u32 blk);
 745 extern errcode_t
 746         ext2fs_badblocks_list_iterate_begin(ext2_badblocks_list bb,
 747                                             ext2_badblocks_iterate *ret);
 748 extern int ext2fs_badblocks_list_iterate(ext2_badblocks_iterate iter,
 749                                          blk_t *blk);
 750 extern void ext2fs_badblocks_list_iterate_end(ext2_badblocks_iterate iter);
 751 extern errcode_t ext2fs_badblocks_copy(ext2_badblocks_list src,
 752                                        ext2_badblocks_list *dest);
 753 extern int ext2fs_badblocks_equal(ext2_badblocks_list bb1,
 754                                   ext2_badblocks_list bb2);
 755 extern int ext2fs_u32_list_count(ext2_u32_list bb);
 756
 757 /* bb_compat */
 758 extern errcode_t badblocks_list_create(badblocks_list *ret, int size);
 759 extern errcode_t badblocks_list_add(badblocks_list bb, blk_t blk);
 760 extern int badblocks_list_test(badblocks_list bb, blk_t blk);
 761 extern errcode_t badblocks_list_iterate_begin(badblocks_list bb,
 762                                               badblocks_iterate *ret);
 763 extern int badblocks_list_iterate(badblocks_iterate iter, blk_t *blk);
 764 extern void badblocks_list_iterate_end(badblocks_iterate iter);
 765 extern void badblocks_list_free(badblocks_list bb);
 766
 767 /* bb_inode.c */
 768 extern errcode_t ext2fs_update_bb_inode(ext2_filsys fs,
 769                                         ext2_badblocks_list bb_list);
 770
 771 /* bitmaps.c */
 772 extern void ext2fs_free_block_bitmap(ext2fs_block_bitmap bitmap);
 773 extern void ext2fs_free_inode_bitmap(ext2fs_inode_bitmap bitmap);
 774 extern errcode_t ext2fs_copy_bitmap(ext2fs_generic_bitmap src,
 775                                     ext2fs_generic_bitmap *dest);
 776 extern errcode_t ext2fs_write_inode_bitmap(ext2_filsys fs);
 777 extern errcode_t ext2fs_write_block_bitmap (ext2_filsys fs);
 778 extern errcode_t ext2fs_read_inode_bitmap (ext2_filsys fs);
 779 extern errcode_t ext2fs_read_block_bitmap(ext2_filsys fs);
 780 extern errcode_t ext2fs_allocate_block_bitmap(ext2_filsys fs,
 781                                               const char *descr,
 782                                               ext2fs_block_bitmap *ret);
 783 extern errcode_t ext2fs_allocate_subcluster_bitmap(ext2_filsys fs,
 784                                                    const char *descr,
 785                                                    ext2fs_block_bitmap *ret);
 786 extern int ext2fs_get_bitmap_granularity(ext2fs_block_bitmap bitmap);
 787 extern errcode_t ext2fs_allocate_inode_bitmap(ext2_filsys fs,
 788                                               const char *descr,
 789                                               ext2fs_inode_bitmap *ret);
 790 extern errcode_t ext2fs_fudge_inode_bitmap_end(ext2fs_inode_bitmap bitmap,
 791                                                ext2_ino_t end, ext2_ino_t *oend);
 792 extern errcode_t ext2fs_fudge_block_bitmap_end(ext2fs_block_bitmap bitmap,
 793                                                blk_t end, blk_t *oend);
 794 extern errcode_t ext2fs_fudge_block_bitmap_end2(ext2fs_block_bitmap bitmap,
 795                                          blk64_t end, blk64_t *oend);
 796 extern void ext2fs_clear_inode_bitmap(ext2fs_inode_bitmap bitmap);
 797 extern void ext2fs_clear_block_bitmap(ext2fs_block_bitmap bitmap);
 798 extern errcode_t ext2fs_read_bitmaps(ext2_filsys fs);
 799 extern errcode_t ext2fs_write_bitmaps(ext2_filsys fs);
 800 extern errcode_t ext2fs_resize_inode_bitmap(__u32 new_end, __u32 new_real_end,
 801                                             ext2fs_inode_bitmap bmap);
 802 extern errcode_t ext2fs_resize_inode_bitmap2(__u64 new_end,
 803                                              __u64 new_real_end,
 804                                              ext2fs_inode_bitmap bmap);
 805 extern errcode_t ext2fs_resize_block_bitmap(__u32 new_end, __u32 new_real_end,
 806                                             ext2fs_block_bitmap bmap);
 807 extern errcode_t ext2fs_resize_block_bitmap2(__u64 new_end,
 808                                              __u64 new_real_end,
 809                                              ext2fs_block_bitmap bmap);
 810 extern errcode_t ext2fs_compare_block_bitmap(ext2fs_block_bitmap bm1,
 811                                              ext2fs_block_bitmap bm2);
 812 extern errcode_t ext2fs_compare_inode_bitmap(ext2fs_inode_bitmap bm1,
 813                                              ext2fs_inode_bitmap bm2);
 814 extern errcode_t ext2fs_set_inode_bitmap_range(ext2fs_inode_bitmap bmap,
 815                                         ext2_ino_t start, unsigned int num,
 816                                         void *in);
 817 extern errcode_t ext2fs_set_inode_bitmap_range2(ext2fs_inode_bitmap bmap,
 818                                          __u64 start, size_t num,
 819                                          void *in);
 820 extern errcode_t ext2fs_get_inode_bitmap_range(ext2fs_inode_bitmap bmap,
 821                                         ext2_ino_t start, unsigned int num,
 822                                         void *out);
 823 extern errcode_t ext2fs_get_inode_bitmap_range2(ext2fs_inode_bitmap bmap,
 824                                          __u64 start, size_t num,
 825                                          void *out);
 826 extern errcode_t ext2fs_set_block_bitmap_range(ext2fs_block_bitmap bmap,
 827                                         blk_t start, unsigned int num,
 828                                         void *in);
 829 extern errcode_t ext2fs_set_block_bitmap_range2(ext2fs_block_bitmap bmap,
 830                                          blk64_t start, size_t num,
 831                                          void *in);
 832 extern errcode_t ext2fs_get_block_bitmap_range(ext2fs_block_bitmap bmap,
 833                                         blk_t start, unsigned int num,
 834                                         void *out);
 835 extern errcode_t ext2fs_get_block_bitmap_range2(ext2fs_block_bitmap bmap,
 836                                          blk64_t start, size_t num,
 837                                          void *out);
 838
 839 /* blknum.c */
 840 extern __u32 ext2fs_inode_bitmap_checksum(ext2_filsys fs, dgrp_t group);
 841 extern __u32 ext2fs_block_bitmap_checksum(ext2_filsys fs, dgrp_t group);
 842 extern dgrp_t ext2fs_group_of_blk2(ext2_filsys fs, blk64_t);
 843 extern blk64_t ext2fs_group_first_block2(ext2_filsys fs, dgrp_t group);
 844 extern blk64_t ext2fs_group_last_block2(ext2_filsys fs, dgrp_t group);
 845 extern int ext2fs_group_blocks_count(ext2_filsys fs, dgrp_t group);
 846 extern blk64_t ext2fs_inode_data_blocks2(ext2_filsys fs,
 847                                          struct ext2_inode *inode);
 848 extern blk64_t ext2fs_inode_i_blocks(ext2_filsys fs,
 849                                          struct ext2_inode *inode);
 850 extern blk64_t ext2fs_blocks_count(struct ext2_super_block *super);
 851 extern void ext2fs_blocks_count_set(struct ext2_super_block *super,
 852                                     blk64_t blk);
 853 extern void ext2fs_blocks_count_add(struct ext2_super_block *super,
 854                                     blk64_t blk);
 855 extern blk64_t ext2fs_r_blocks_count(struct ext2_super_block *super);
 856 extern void ext2fs_r_blocks_count_set(struct ext2_super_block *super,
 857                                       blk64_t blk);
 858 extern void ext2fs_r_blocks_count_add(struct ext2_super_block *super,
 859                                       blk64_t blk);
 860 extern blk64_t ext2fs_free_blocks_count(struct ext2_super_block *super);
 861 extern void ext2fs_free_blocks_count_set(struct ext2_super_block *super,
 862                                          blk64_t blk);
 863 extern void ext2fs_free_blocks_count_add(struct ext2_super_block *super,
 864                                          blk64_t blk);
 865 /* Block group descriptor accessor functions */
 866 extern struct ext2_group_desc *ext2fs_group_desc(ext2_filsys fs,
 867                                           struct opaque_ext2_group_desc *gdp,
 868                                           dgrp_t group);
 869 extern blk64_t ext2fs_block_bitmap_csum(ext2_filsys fs, dgrp_t group);
 870 extern blk64_t ext2fs_block_bitmap_loc(ext2_filsys fs, dgrp_t group);
 871 extern void ext2fs_block_bitmap_loc_set(ext2_filsys fs, dgrp_t group,
 872                                         blk64_t blk);
 873 extern __u32 ext2fs_inode_bitmap_csum(ext2_filsys fs, dgrp_t group);
 874 extern blk64_t ext2fs_inode_bitmap_loc(ext2_filsys fs, dgrp_t group);
 875 extern void ext2fs_inode_bitmap_loc_set(ext2_filsys fs, dgrp_t group,
 876                                         blk64_t blk);
 877 extern blk64_t ext2fs_inode_table_loc(ext2_filsys fs, dgrp_t group);
 878 extern void ext2fs_inode_table_loc_set(ext2_filsys fs, dgrp_t group,
 879                                        blk64_t blk);
 880 extern __u32 ext2fs_bg_free_blocks_count(ext2_filsys fs, dgrp_t group);
 881 extern void ext2fs_bg_free_blocks_count_set(ext2_filsys fs, dgrp_t group,
 882                                          __u32 n);
 883 extern __u32 ext2fs_bg_free_inodes_count(ext2_filsys fs, dgrp_t group);
 884 extern void ext2fs_bg_free_inodes_count_set(ext2_filsys fs, dgrp_t group,
 885                                          __u32 n);
 886 extern __u32 ext2fs_bg_used_dirs_count(ext2_filsys fs, dgrp_t group);
 887 extern void ext2fs_bg_used_dirs_count_set(ext2_filsys fs, dgrp_t group,
 888                                        __u32 n);
 889 extern __u32 ext2fs_bg_itable_unused(ext2_filsys fs, dgrp_t group);
 890 extern void ext2fs_bg_itable_unused_set(ext2_filsys fs, dgrp_t group,
 891                                      __u32 n);
 892 extern __u16 ext2fs_bg_flags(ext2_filsys fs, dgrp_t group);
 893 extern void ext2fs_bg_flags_zap(ext2_filsys fs, dgrp_t group);
 894 extern int ext2fs_bg_flags_test(ext2_filsys fs, dgrp_t group, __u16 bg_flag);
 895 extern void ext2fs_bg_flags_set(ext2_filsys fs, dgrp_t group, __u16 bg_flags);
 896 extern void ext2fs_bg_flags_clear(ext2_filsys fs, dgrp_t group, __u16 bg_flags);
 897 extern __u16 ext2fs_bg_checksum(ext2_filsys fs, dgrp_t group);
 898 extern void ext2fs_bg_checksum_set(ext2_filsys fs, dgrp_t group, __u16 checksum);
 899 extern blk64_t ext2fs_file_acl_block(ext2_filsys fs,
 900                                      const struct ext2_inode *inode);
 901 extern void ext2fs_file_acl_block_set(ext2_filsys fs,
 902                                       struct ext2_inode *inode, blk64_t blk);
 903 extern errcode_t ext2fs_inode_size_set(ext2_filsys fs, struct ext2_inode *inode,
 904                                        ext2_off64_t size);
 905
 906 /* block.c */
 907 extern errcode_t ext2fs_block_iterate(ext2_filsys fs,
 908                                       ext2_ino_t        ino,
 909                                       int       flags,
 910                                       char *block_buf,
 911                                       int (*func)(ext2_filsys fs,
 912                                                   blk_t *blocknr,
 913                                                   int   blockcnt,
 914                                                   void  *priv_data),
 915                                       void *priv_data);
 916 errcode_t ext2fs_block_iterate2(ext2_filsys fs,
 917                                 ext2_ino_t      ino,
 918                                 int     flags,
 919                                 char *block_buf,
 920                                 int (*func)(ext2_filsys fs,
 921                                             blk_t       *blocknr,
 922                                             e2_blkcnt_t blockcnt,
 923                                             blk_t       ref_blk,
 924                                             int         ref_offset,
 925                                             void        *priv_data),
 926                                 void *priv_data);
 927 errcode_t ext2fs_block_iterate3(ext2_filsys fs,
 928                                 ext2_ino_t ino,
 929                                 int     flags,
 930                                 char *block_buf,
 931                                 int (*func)(ext2_filsys fs,
 932                                             blk64_t     *blocknr,
 933                                             e2_blkcnt_t blockcnt,
 934                                             blk64_t     ref_blk,
 935                                             int         ref_offset,
 936                                             void        *priv_data),
 937                                 void *priv_data);
 938
 939 /* bmap.c */
 940 extern errcode_t ext2fs_bmap(ext2_filsys fs, ext2_ino_t ino,
 941                              struct ext2_inode *inode,
 942                              char *block_buf, int bmap_flags,
 943                              blk_t block, blk_t *phys_blk);
 944 extern errcode_t ext2fs_bmap2(ext2_filsys fs, ext2_ino_t ino,
 945                               struct ext2_inode *inode,
 946                               char *block_buf, int bmap_flags, blk64_t block,
 947                               int *ret_flags, blk64_t *phys_blk);
 948 errcode_t ext2fs_map_cluster_block(ext2_filsys fs, ext2_ino_t ino,
 949                                    struct ext2_inode *inode, blk64_t lblk,
 950                                    blk64_t *pblk);
 951
 952 #if 0
 953 /* bmove.c */
 954 extern errcode_t ext2fs_move_blocks(ext2_filsys fs,
 955                                     ext2fs_block_bitmap reserve,
 956                                     ext2fs_block_bitmap alloc_map,
 957                                     int flags);
 958 #endif
 959
 960 /* check_desc.c */
 961 extern errcode_t ext2fs_check_desc(ext2_filsys fs);
 962
 963 /* closefs.c */
 964 extern errcode_t ext2fs_close(ext2_filsys fs);
 965 extern errcode_t ext2fs_close2(ext2_filsys fs, int flags);
 966 extern errcode_t ext2fs_close_free(ext2_filsys *fs);
 967 extern errcode_t ext2fs_flush(ext2_filsys fs);
 968 extern errcode_t ext2fs_flush2(ext2_filsys fs, int flags);
 969 extern int ext2fs_bg_has_super(ext2_filsys fs, dgrp_t group_block);
 970 extern errcode_t ext2fs_super_and_bgd_loc2(ext2_filsys fs,
 971                                     dgrp_t group,
 972                                     blk64_t *ret_super_blk,
 973                                     blk64_t *ret_old_desc_blk,
 974                                     blk64_t *ret_new_desc_blk,
 975                                     blk_t *ret_used_blks);
 976 extern int ext2fs_super_and_bgd_loc(ext2_filsys fs,
 977                                     dgrp_t group,
 978                                     blk_t *ret_super_blk,
 979                                     blk_t *ret_old_desc_blk,
 980                                     blk_t *ret_new_desc_blk,
 981                                     int *ret_meta_bg);
 982 extern void ext2fs_update_dynamic_rev(ext2_filsys fs);
 983
 984 /* crc32c.c */
 985 extern __u32 ext2fs_crc32_be(__u32 crc, unsigned char const *p, size_t len);
 986 extern __u32 ext2fs_crc32c_le(__u32 crc, unsigned char const *p, size_t len);
 987
 988 /* csum.c */
 989 extern errcode_t ext2fs_mmp_csum_set(ext2_filsys fs, struct mmp_struct *mmp);
 990 extern int ext2fs_mmp_csum_verify(ext2_filsys, struct mmp_struct *mmp);
 991 extern int ext2fs_verify_csum_type(ext2_filsys fs, struct ext2_super_block *sb);
 992 extern errcode_t ext2fs_superblock_csum_set(ext2_filsys fs,
 993                                             struct ext2_super_block *sb);
 994 extern int ext2fs_superblock_csum_verify(ext2_filsys fs,
 995                                          struct ext2_super_block *sb);
 996 extern errcode_t ext2fs_ext_attr_block_csum_set(ext2_filsys fs,
 997                                         ext2_ino_t inum, blk64_t block,
 998                                         struct ext2_ext_attr_header *hdr);
 999 extern int ext2fs_ext_attr_block_csum_verify(ext2_filsys fs, ext2_ino_t inum,
1000                                              blk64_t block,
1001                                              struct ext2_ext_attr_header *hdr);
1002 #define EXT2_DIRENT_TAIL(block, blocksize) \
1003         ((struct ext2_dir_entry_tail *)(((char *)(block)) + \
1004         (blocksize) - sizeof(struct ext2_dir_entry_tail)))
1005
1006 extern void ext2fs_initialize_dirent_tail(ext2_filsys fs,
1007                                           struct ext2_dir_entry_tail *t);
1008 extern int ext2fs_dirent_has_tail(ext2_filsys fs,
1009                                   struct ext2_dir_entry *dirent);
1010 extern int ext2fs_dirent_csum_verify(ext2_filsys fs, ext2_ino_t inum,
1011                                      struct ext2_dir_entry *dirent);
1012 extern int ext2fs_dir_block_csum_verify(ext2_filsys fs, ext2_ino_t inum,
1013                                         struct ext2_dir_entry *dirent);
1014 extern errcode_t ext2fs_dir_block_csum_set(ext2_filsys fs, ext2_ino_t inum,
1015                                            struct ext2_dir_entry *dirent);
1016 extern errcode_t ext2fs_get_dx_countlimit(ext2_filsys fs,
1017                                           struct ext2_dir_entry *dirent,
1018                                           struct ext2_dx_countlimit **cc,
1019                                           int *offset);
1020 extern errcode_t ext2fs_extent_block_csum_set(ext2_filsys fs,
1021                                               ext2_ino_t inum,
1022                                               struct ext3_extent_header *eh);
1023 extern int ext2fs_extent_block_csum_verify(ext2_filsys fs,
1024                                            ext2_ino_t inum,
1025                                            struct ext3_extent_header *eh);
1026 extern errcode_t ext2fs_block_bitmap_csum_set(ext2_filsys fs, dgrp_t group,
1027                                               char *bitmap, int size);
1028 extern int ext2fs_block_bitmap_csum_verify(ext2_filsys fs, dgrp_t group,
1029                                            char *bitmap, int size);
1030 extern errcode_t ext2fs_inode_bitmap_csum_set(ext2_filsys fs, dgrp_t group,
1031                                               char *bitmap, int size);
1032 extern int ext2fs_inode_bitmap_csum_verify(ext2_filsys fs, dgrp_t group,
1033                                            char *bitmap, int size);
1034 extern errcode_t ext2fs_inode_csum_set(ext2_filsys fs, ext2_ino_t inum,
1035                                        struct ext2_inode_large *inode);
1036 extern int ext2fs_inode_csum_verify(ext2_filsys fs, ext2_ino_t inum,
1037                                     struct ext2_inode_large *inode);
1038 extern void ext2fs_group_desc_csum_set(ext2_filsys fs, dgrp_t group);
1039 extern int ext2fs_group_desc_csum_verify(ext2_filsys fs, dgrp_t group);
1040 extern errcode_t ext2fs_set_gdt_csum(ext2_filsys fs);
1041 extern __u16 ext2fs_group_desc_csum(ext2_filsys fs, dgrp_t group);
1042
1043 /* dblist.c */
1044 extern errcode_t ext2fs_init_dblist(ext2_filsys fs, ext2_dblist *ret_dblist);
1045 extern errcode_t ext2fs_add_dir_block(ext2_dblist dblist, ext2_ino_t ino,
1046                                       blk_t blk, int blockcnt);
1047 extern errcode_t ext2fs_add_dir_block2(ext2_dblist dblist, ext2_ino_t ino,
1048                                        blk64_t blk, e2_blkcnt_t blockcnt);
1049 extern void ext2fs_dblist_sort(ext2_dblist dblist,
1050                                EXT2_QSORT_TYPE (*sortfunc)(const void *,
1051                                                            const void *));
1052 extern void ext2fs_dblist_sort2(ext2_dblist dblist,
1053                                 EXT2_QSORT_TYPE (*sortfunc)(const void *,
1054                                                             const void *));
1055 extern errcode_t ext2fs_dblist_iterate(ext2_dblist dblist,
1056         int (*func)(ext2_filsys fs, struct ext2_db_entry *db_info,
1057                     void        *priv_data),
1058         void *priv_data);
1059 extern errcode_t ext2fs_dblist_iterate2(ext2_dblist dblist,
1060         int (*func)(ext2_filsys fs, struct ext2_db_entry2 *db_info,
1061                     void        *priv_data),
1062         void *priv_data);
1063 extern errcode_t ext2fs_dblist_iterate3(ext2_dblist dblist,
1064         int (*func)(ext2_filsys fs, struct ext2_db_entry2 *db_info,
1065                     void        *priv_data),
1066         unsigned long long start,
1067         unsigned long long count,
1068         void *priv_data);
1069 extern errcode_t ext2fs_set_dir_block(ext2_dblist dblist, ext2_ino_t ino,
1070                                       blk_t blk, int blockcnt);
1071 extern errcode_t ext2fs_set_dir_block2(ext2_dblist dblist, ext2_ino_t ino,
1072                                        blk64_t blk, e2_blkcnt_t blockcnt);
1073 extern errcode_t ext2fs_copy_dblist(ext2_dblist src,
1074                                     ext2_dblist *dest);
1075 extern int ext2fs_dblist_count(ext2_dblist dblist);
1076 extern blk64_t ext2fs_dblist_count2(ext2_dblist dblist);
1077 extern errcode_t ext2fs_dblist_get_last(ext2_dblist dblist,
1078                                         struct ext2_db_entry **entry);
1079 extern errcode_t ext2fs_dblist_get_last2(ext2_dblist dblist,
1080                                         struct ext2_db_entry2 **entry);
1081 extern errcode_t ext2fs_dblist_drop_last(ext2_dblist dblist);
1082
1083 /* dblist_dir.c */
1084 extern errcode_t
1085         ext2fs_dblist_dir_iterate(ext2_dblist dblist,
1086                                   int   flags,
1087                                   char  *block_buf,
1088                                   int (*func)(ext2_ino_t        dir,
1089                                               int               entry,
1090                                               struct ext2_dir_entry *dirent,
1091                                               int       offset,
1092                                               int       blocksize,
1093                                               char      *buf,
1094                                               void      *priv_data),
1095                                   void *priv_data);
1096
1097 #if 0
1098 /* digest_encode.c */
1099 #define EXT2FS_DIGEST_SIZE EXT2FS_SHA256_LENGTH
1100 extern int ext2fs_digest_encode(const char *src, int len, char *dst);
1101 extern int ext2fs_digest_decode(const char *src, int len, char *dst);
1102 #endif
1103
1104 /* dirblock.c */
1105 extern errcode_t ext2fs_read_dir_block(ext2_filsys fs, blk_t block,
1106                                        void *buf);
1107 extern errcode_t ext2fs_read_dir_block2(ext2_filsys fs, blk_t block,
1108                                         void *buf, int flags);
1109 extern errcode_t ext2fs_read_dir_block3(ext2_filsys fs, blk64_t block,
1110                                         void *buf, int flags);
1111 extern errcode_t ext2fs_read_dir_block4(ext2_filsys fs, blk64_t block,
1112                                         void *buf, int flags, ext2_ino_t ino);
1113 extern errcode_t ext2fs_write_dir_block(ext2_filsys fs, blk_t block,
1114                                         void *buf);
1115 extern errcode_t ext2fs_write_dir_block2(ext2_filsys fs, blk_t block,
1116                                          void *buf, int flags);
1117 extern errcode_t ext2fs_write_dir_block3(ext2_filsys fs, blk64_t block,
1118                                          void *buf, int flags);
1119 extern errcode_t ext2fs_write_dir_block4(ext2_filsys fs, blk64_t block,
1120                                          void *buf, int flags, ext2_ino_t ino);
1121
1122 /* dirhash.c */
1123 extern errcode_t ext2fs_dirhash(int version, const char *name, int len,
1124                                 const __u32 *seed,
1125                                 ext2_dirhash_t *ret_hash,
1126                                 ext2_dirhash_t *ret_minor_hash);
1127
1128
1129 /* dir_iterate.c */
1130 extern errcode_t ext2fs_get_rec_len(ext2_filsys fs,
1131                                     struct ext2_dir_entry *dirent,
1132                                     unsigned int *rec_len);
1133 extern errcode_t ext2fs_set_rec_len(ext2_filsys fs,
1134                                     unsigned int len,
1135                                     struct ext2_dir_entry *dirent);
1136 extern errcode_t ext2fs_dir_iterate(ext2_filsys fs,
1137                               ext2_ino_t dir,
1138                               int flags,
1139                               char *block_buf,
1140                               int (*func)(struct ext2_dir_entry *dirent,
1141                                           int   offset,
1142                                           int   blocksize,
1143                                           char  *buf,
1144                                           void  *priv_data),
1145                               void *priv_data);
1146 extern errcode_t ext2fs_dir_iterate2(ext2_filsys fs,
1147                               ext2_ino_t dir,
1148                               int flags,
1149                               char *block_buf,
1150                               int (*func)(ext2_ino_t    dir,
1151                                           int   entry,
1152                                           struct ext2_dir_entry *dirent,
1153                                           int   offset,
1154                                           int   blocksize,
1155                                           char  *buf,
1156                                           void  *priv_data),
1157                               void *priv_data);
1158
1159 /* dupfs.c */
1160 extern errcode_t ext2fs_dup_handle(ext2_filsys src, ext2_filsys *dest);
1161
1162 /* expanddir.c */
1163 extern errcode_t ext2fs_expand_dir(ext2_filsys fs, ext2_ino_t dir);
1164
1165 /* ext_attr.c */
1166 extern __u32 ext2fs_ext_attr_hash_entry(struct ext2_ext_attr_entry *entry,
1167                                         void *data);
1168 extern errcode_t ext2fs_read_ext_attr(ext2_filsys fs, blk_t block, void *buf);
1169 extern errcode_t ext2fs_read_ext_attr2(ext2_filsys fs, blk64_t block,
1170                                        void *buf);
1171 extern errcode_t ext2fs_read_ext_attr3(ext2_filsys fs, blk64_t block,
1172                                        void *buf, ext2_ino_t inum);
1173 extern errcode_t ext2fs_write_ext_attr(ext2_filsys fs, blk_t block,
1174                                        void *buf);
1175 extern errcode_t ext2fs_write_ext_attr2(ext2_filsys fs, blk64_t block,
1176                                        void *buf);
1177 extern errcode_t ext2fs_write_ext_attr3(ext2_filsys fs, blk64_t block,
1178                                        void *buf, ext2_ino_t inum);
1179 extern errcode_t ext2fs_adjust_ea_refcount(ext2_filsys fs, blk_t blk,
1180                                            char *block_buf,
1181                                            int adjust, __u32 *newcount);
1182 extern errcode_t ext2fs_adjust_ea_refcount2(ext2_filsys fs, blk64_t blk,
1183                                            char *block_buf,
1184                                            int adjust, __u32 *newcount);
1185 extern errcode_t ext2fs_adjust_ea_refcount3(ext2_filsys fs, blk64_t blk,
1186                                            char *block_buf,
1187                                            int adjust, __u32 *newcount,
1188                                            ext2_ino_t inum);
1189 errcode_t ext2fs_xattrs_write(struct ext2_xattr_handle *handle);
1190 errcode_t ext2fs_xattrs_read(struct ext2_xattr_handle *handle);
1191 errcode_t ext2fs_xattrs_iterate(struct ext2_xattr_handle *h,
1192                                 int (*func)(char *name, char *value,
1193                                             size_t value_len, void *data),
1194                                 void *data);
1195 errcode_t ext2fs_xattr_get(struct ext2_xattr_handle *h, const char *key,
1196                            void **value, size_t *value_len);
1197 errcode_t ext2fs_xattr_set(struct ext2_xattr_handle *handle,
1198                            const char *key,
1199                            const void *value,
1200                            size_t value_len);
1201 errcode_t ext2fs_xattr_remove(struct ext2_xattr_handle *handle,
1202                               const char *key);
1203 errcode_t ext2fs_xattrs_open(ext2_filsys fs, ext2_ino_t ino,
1204                              struct ext2_xattr_handle **handle);
1205 errcode_t ext2fs_xattrs_close(struct ext2_xattr_handle **handle);
1206 errcode_t ext2fs_free_ext_attr(ext2_filsys fs, ext2_ino_t ino,
1207                                struct ext2_inode_large *inode);
1208 errcode_t ext2fs_xattrs_count(struct ext2_xattr_handle *handle, size_t *count);
1209 errcode_t ext2fs_xattr_inode_max_size(ext2_filsys fs, ext2_ino_t ino,
1210                                       size_t *size);
1211
1212 /* extent.c */
1213 extern errcode_t ext2fs_extent_header_verify(void *ptr, int size);
1214 extern errcode_t ext2fs_extent_open(ext2_filsys fs, ext2_ino_t ino,
1215                                     ext2_extent_handle_t *handle);
1216 extern errcode_t ext2fs_extent_open2(ext2_filsys fs, ext2_ino_t ino,
1217                                         struct ext2_inode *inode,
1218                                         ext2_extent_handle_t *ret_handle);
1219 extern void ext2fs_extent_free(ext2_extent_handle_t handle);
1220 extern errcode_t ext2fs_extent_get(ext2_extent_handle_t handle,
1221                                    int flags, struct ext2fs_extent *extent);
1222 extern errcode_t ext2fs_extent_node_split(ext2_extent_handle_t handle);
1223 extern errcode_t ext2fs_extent_replace(ext2_extent_handle_t handle, int flags,
1224                                        struct ext2fs_extent *extent);
1225 extern errcode_t ext2fs_extent_insert(ext2_extent_handle_t handle, int flags,
1226                                       struct ext2fs_extent *extent);
1227 extern errcode_t ext2fs_extent_set_bmap(ext2_extent_handle_t handle,
1228                                         blk64_t logical, blk64_t physical,
1229                                         int flags);
1230 extern errcode_t ext2fs_extent_delete(ext2_extent_handle_t handle, int flags);
1231 extern errcode_t ext2fs_extent_get_info(ext2_extent_handle_t handle,
1232                                         struct ext2_extent_info *info);
1233 extern errcode_t ext2fs_extent_goto(ext2_extent_handle_t handle,
1234                                     blk64_t blk);
1235 extern errcode_t ext2fs_extent_goto2(ext2_extent_handle_t handle,
1236                                      int leaf_level, blk64_t blk);
1237 extern errcode_t ext2fs_extent_fix_parents(ext2_extent_handle_t handle);
1238 size_t ext2fs_max_extent_depth(ext2_extent_handle_t handle);
1239
1240 /* fallocate.c */
1241 #define EXT2_FALLOCATE_ZERO_BLOCKS      (0x1)
1242 #define EXT2_FALLOCATE_FORCE_INIT       (0x2)
1243 #define EXT2_FALLOCATE_FORCE_UNINIT     (0x4)
1244 #define EXT2_FALLOCATE_INIT_BEYOND_EOF  (0x8)
1245 #define EXT2_FALLOCATE_ALL_FLAGS        (0xF)
1246 errcode_t ext2fs_fallocate(ext2_filsys fs, int flags, ext2_ino_t ino,
1247                            struct ext2_inode *inode, blk64_t goal,
1248                            blk64_t start, blk64_t len);
1249
1250 /* fileio.c */
1251 extern errcode_t ext2fs_file_open2(ext2_filsys fs, ext2_ino_t ino,
1252                                    struct ext2_inode *inode,
1253                                    int flags, ext2_file_t *ret);
1254 extern errcode_t ext2fs_file_open(ext2_filsys fs, ext2_ino_t ino,
1255                                   int flags, ext2_file_t *ret);
1256 extern ext2_filsys ext2fs_file_get_fs(ext2_file_t file);
1257 struct ext2_inode *ext2fs_file_get_inode(ext2_file_t file);
1258 extern ext2_ino_t ext2fs_file_get_inode_num(ext2_file_t file);
1259 extern errcode_t ext2fs_file_close(ext2_file_t file);
1260 extern errcode_t ext2fs_file_flush(ext2_file_t file);
1261 extern errcode_t ext2fs_file_read(ext2_file_t file, void *buf,
1262                                   unsigned int wanted, unsigned int *got);
1263 extern errcode_t ext2fs_file_write(ext2_file_t file, const void *buf,
1264                                    unsigned int nbytes, unsigned int *written);
1265 extern errcode_t ext2fs_file_llseek(ext2_file_t file, __u64 offset,
1266                                    int whence, __u64 *ret_pos);
1267 extern errcode_t ext2fs_file_lseek(ext2_file_t file, ext2_off_t offset,
1268                                    int whence, ext2_off_t *ret_pos);
1269 errcode_t ext2fs_file_get_lsize(ext2_file_t file, __u64 *ret_size);
1270 extern ext2_off_t ext2fs_file_get_size(ext2_file_t file);
1271 extern errcode_t ext2fs_file_set_size(ext2_file_t file, ext2_off_t size);
1272 extern errcode_t ext2fs_file_set_size2(ext2_file_t file, ext2_off64_t size);
1273
1274 /* finddev.c */
1275 extern char *ext2fs_find_block_device(dev_t device);
1276
1277 /* flushb.c */
1278 extern errcode_t ext2fs_sync_device(int fd, int flushb);
1279
1280 /* freefs.c */
1281 extern void ext2fs_free(ext2_filsys fs);
1282 extern void ext2fs_free_dblist(ext2_dblist dblist);
1283 extern void ext2fs_badblocks_list_free(ext2_badblocks_list bb);
1284 extern void ext2fs_u32_list_free(ext2_u32_list bb);
1285
1286 /* gen_bitmap.c */
1287 extern void ext2fs_free_generic_bitmap(ext2fs_inode_bitmap bitmap);
1288 extern errcode_t ext2fs_make_generic_bitmap(errcode_t magic, ext2_filsys fs,
1289                                             __u32 start, __u32 end,
1290                                             __u32 real_end,
1291                                             const char *descr, char *init_map,
1292                                             ext2fs_generic_bitmap *ret);
1293 extern errcode_t ext2fs_allocate_generic_bitmap(__u32 start,
1294                                                 __u32 end,
1295                                                 __u32 real_end,
1296                                                 const char *descr,
1297                                                 ext2fs_generic_bitmap *ret);
1298 extern errcode_t ext2fs_copy_generic_bitmap(ext2fs_generic_bitmap src,
1299                                             ext2fs_generic_bitmap *dest);
1300 extern void ext2fs_clear_generic_bitmap(ext2fs_generic_bitmap bitmap);
1301 extern errcode_t ext2fs_fudge_generic_bitmap_end(ext2fs_inode_bitmap bitmap,
1302                                                  errcode_t magic,
1303                                                  errcode_t neq,
1304                                                  ext2_ino_t end,
1305                                                  ext2_ino_t *oend);
1306 extern void ext2fs_set_generic_bitmap_padding(ext2fs_generic_bitmap map);
1307 extern errcode_t ext2fs_resize_generic_bitmap(errcode_t magic,
1308                                               __u32 new_end,
1309                                               __u32 new_real_end,
1310                                               ext2fs_generic_bitmap bmap);
1311 extern errcode_t ext2fs_compare_generic_bitmap(errcode_t magic, errcode_t neq,
1312                                                ext2fs_generic_bitmap bm1,
1313                                                ext2fs_generic_bitmap bm2);
1314 extern errcode_t ext2fs_get_generic_bitmap_range(ext2fs_generic_bitmap bmap,
1315                                                  errcode_t magic,
1316                                                  __u32 start, __u32 num,
1317                                                  void *out);
1318 extern errcode_t ext2fs_set_generic_bitmap_range(ext2fs_generic_bitmap bmap,
1319                                                  errcode_t magic,
1320                                                  __u32 start, __u32 num,
1321                                                  void *in);
1322 extern errcode_t ext2fs_find_first_zero_generic_bitmap(ext2fs_generic_bitmap bitmap,
1323                                                        __u32 start, __u32 end,
1324                                                        __u32 *out);
1325 extern errcode_t ext2fs_find_first_set_generic_bitmap(ext2fs_generic_bitmap bitmap,
1326                                                        __u32 start, __u32 end,
1327                                                        __u32 *out);
1328
1329 /* gen_bitmap64.c */
1330 void ext2fs_free_generic_bmap(ext2fs_generic_bitmap bmap);
1331 errcode_t ext2fs_alloc_generic_bmap(ext2_filsys fs, errcode_t magic,
1332                                     int type, __u64 start, __u64 end,
1333                                     __u64 real_end,
1334                                     const char *descr,
1335                                     ext2fs_generic_bitmap *ret);
1336 errcode_t ext2fs_copy_generic_bmap(ext2fs_generic_bitmap src,
1337                                    ext2fs_generic_bitmap *dest);
1338 void ext2fs_clear_generic_bmap(ext2fs_generic_bitmap bitmap);
1339 errcode_t ext2fs_fudge_generic_bmap_end(ext2fs_generic_bitmap bitmap,
1340                                         errcode_t neq,
1341                                         __u64 end, __u64 *oend);
1342 void ext2fs_set_generic_bmap_padding(ext2fs_generic_bitmap bmap);
1343 errcode_t ext2fs_resize_generic_bmap(ext2fs_generic_bitmap bmap,
1344                                      __u64 new_end,
1345                                      __u64 new_real_end);
1346 errcode_t ext2fs_compare_generic_bmap(errcode_t neq,
1347                                       ext2fs_generic_bitmap bm1,
1348                                       ext2fs_generic_bitmap bm2);
1349 errcode_t ext2fs_get_generic_bmap_range(ext2fs_generic_bitmap bmap,
1350                                         __u64 start, unsigned int num,
1351                                         void *out);
1352 errcode_t ext2fs_set_generic_bmap_range(ext2fs_generic_bitmap bmap,
1353                                         __u64 start, unsigned int num,
1354                                         void *in);
1355 errcode_t ext2fs_convert_subcluster_bitmap(ext2_filsys fs,
1356                                            ext2fs_block_bitmap *bitmap);
1357
1358 /* get_num_dirs.c */
1359 extern errcode_t ext2fs_get_num_dirs(ext2_filsys fs, ext2_ino_t *ret_num_dirs);
1360
1361 /* getsize.c */
1362 extern errcode_t ext2fs_get_device_size(const char *file, int blocksize,
1363                                         blk_t *retblocks);
1364 extern errcode_t ext2fs_get_device_size2(const char *file, int blocksize,
1365                                         blk64_t *retblocks);
1366
1367 /* getsectsize.c */
1368 extern int ext2fs_get_dio_alignment(int fd);
1369 errcode_t ext2fs_get_device_sectsize(const char *file, int *sectsize);
1370 errcode_t ext2fs_get_device_phys_sectsize(const char *file, int *sectsize);
1371
1372 /* i_block.c */
1373 errcode_t ext2fs_iblk_add_blocks(ext2_filsys fs, struct ext2_inode *inode,
1374                                  blk64_t num_blocks);
1375 errcode_t ext2fs_iblk_sub_blocks(ext2_filsys fs, struct ext2_inode *inode,
1376                                  blk64_t num_blocks);
1377 errcode_t ext2fs_iblk_set(ext2_filsys fs, struct ext2_inode *inode, blk64_t b);
1378
1379 /* imager.c */
1380 extern errcode_t ext2fs_image_inode_write(ext2_filsys fs, int fd, int flags);
1381 extern errcode_t ext2fs_image_inode_read(ext2_filsys fs, int fd, int flags);
1382 extern errcode_t ext2fs_image_super_write(ext2_filsys fs, int fd, int flags);
1383 extern errcode_t ext2fs_image_super_read(ext2_filsys fs, int fd, int flags);
1384 extern errcode_t ext2fs_image_bitmap_write(ext2_filsys fs, int fd, int flags);
1385 extern errcode_t ext2fs_image_bitmap_read(ext2_filsys fs, int fd, int flags);
1386
1387 /* ind_block.c */
1388 errcode_t ext2fs_read_ind_block(ext2_filsys fs, blk_t blk, void *buf);
1389 errcode_t ext2fs_write_ind_block(ext2_filsys fs, blk_t blk, void *buf);
1390
1391 /* initialize.c */
1392 extern errcode_t ext2fs_initialize(const char *name, int flags,
1393                                    struct ext2_super_block *param,
1394                                    io_manager manager, ext2_filsys *ret_fs);
1395
1396 /* icount.c */
1397 extern void ext2fs_free_icount(ext2_icount_t icount);
1398 extern errcode_t ext2fs_create_icount_tdb(ext2_filsys fs, char *tdb_dir,
1399                                           int flags, ext2_icount_t *ret);
1400 extern errcode_t ext2fs_create_icount2(ext2_filsys fs, int flags,
1401                                        unsigned int size,
1402                                        ext2_icount_t hint, ext2_icount_t *ret);
1403 extern errcode_t ext2fs_create_icount(ext2_filsys fs, int flags,
1404                                       unsigned int size,
1405                                       ext2_icount_t *ret);
1406 extern errcode_t ext2fs_icount_fetch(ext2_icount_t icount, ext2_ino_t ino,
1407                                      __u16 *ret);
1408 extern errcode_t ext2fs_icount_increment(ext2_icount_t icount, ext2_ino_t ino,
1409                                          __u16 *ret);
1410 extern errcode_t ext2fs_icount_decrement(ext2_icount_t icount, ext2_ino_t ino,
1411                                          __u16 *ret);
1412 extern errcode_t ext2fs_icount_store(ext2_icount_t icount, ext2_ino_t ino,
1413                                      __u16 count);
1414 extern ext2_ino_t ext2fs_get_icount_size(ext2_icount_t icount);
1415 errcode_t ext2fs_icount_validate(ext2_icount_t icount, FILE *);
1416
1417 /* inline.c */
1418
1419 extern errcode_t ext2fs_get_memalign(unsigned long size,
1420                                      unsigned long align, void *ptr);
1421
1422 /* inline_data.c */
1423 extern errcode_t ext2fs_inline_data_init(ext2_filsys fs, ext2_ino_t ino);
1424 extern errcode_t ext2fs_inline_data_size(ext2_filsys fs, ext2_ino_t ino,
1425                                          size_t *size);
1426 extern errcode_t ext2fs_inline_data_get(ext2_filsys fs, ext2_ino_t ino,
1427                                         struct ext2_inode *inode,
1428                                         void *buf, size_t *size);
1429 extern errcode_t ext2fs_inline_data_set(ext2_filsys fs, ext2_ino_t ino,
1430                                         struct ext2_inode *inode,
1431                                         void *buf, size_t size);
1432
1433 /* inode.c */
1434 extern errcode_t ext2fs_create_inode_cache(ext2_filsys fs,
1435                                            unsigned int cache_size);
1436 extern void ext2fs_free_inode_cache(struct ext2_inode_cache *icache);
1437 extern errcode_t ext2fs_flush_icache(ext2_filsys fs);
1438 extern errcode_t ext2fs_get_next_inode_full(ext2_inode_scan scan,
1439                                             ext2_ino_t *ino,
1440                                             struct ext2_inode *inode,
1441                                             int bufsize);
1442 #define EXT2_INODE_SCAN_DEFAULT_BUFFER_BLOCKS   8
1443 extern errcode_t ext2fs_open_inode_scan(ext2_filsys fs, int buffer_blocks,
1444                                   ext2_inode_scan *ret_scan);
1445 extern void ext2fs_close_inode_scan(ext2_inode_scan scan);
1446 extern errcode_t ext2fs_get_next_inode(ext2_inode_scan scan, ext2_ino_t *ino,
1447                                struct ext2_inode *inode);
1448 extern errcode_t ext2fs_inode_scan_goto_blockgroup(ext2_inode_scan scan,
1449                                                    int  group);
1450 extern void ext2fs_set_inode_callback
1451         (ext2_inode_scan scan,
1452          errcode_t (*done_group)(ext2_filsys fs,
1453                                  ext2_inode_scan scan,
1454                                  dgrp_t group,
1455                                  void * priv_data),
1456          void *done_group_data);
1457 extern int ext2fs_inode_scan_flags(ext2_inode_scan scan, int set_flags,
1458                                    int clear_flags);
1459 extern errcode_t ext2fs_read_inode_full(ext2_filsys fs, ext2_ino_t ino,
1460                                         struct ext2_inode * inode,
1461                                         int bufsize);
1462 extern errcode_t ext2fs_read_inode (ext2_filsys fs, ext2_ino_t ino,
1463                             struct ext2_inode * inode);
1464 extern errcode_t ext2fs_write_inode_full(ext2_filsys fs, ext2_ino_t ino,
1465                                          struct ext2_inode * inode,
1466                                          int bufsize);
1467 extern errcode_t ext2fs_write_inode(ext2_filsys fs, ext2_ino_t ino,
1468                             struct ext2_inode * inode);
1469 extern errcode_t ext2fs_write_new_inode(ext2_filsys fs, ext2_ino_t ino,
1470                             struct ext2_inode * inode);
1471 extern errcode_t ext2fs_get_blocks(ext2_filsys fs, ext2_ino_t ino, blk_t *blocks);
1472 extern errcode_t ext2fs_check_directory(ext2_filsys fs, ext2_ino_t ino);
1473
1474 /* inode_io.c */
1475 extern io_manager inode_io_manager;
1476 extern errcode_t ext2fs_inode_io_intern(ext2_filsys fs, ext2_ino_t ino,
1477                                         char **name);
1478 extern errcode_t ext2fs_inode_io_intern2(ext2_filsys fs, ext2_ino_t ino,
1479                                          struct ext2_inode *inode,
1480                                          char **name);
1481
1482 /* ismounted.c */
1483 extern errcode_t ext2fs_check_if_mounted(const char *file, int *mount_flags);
1484 extern errcode_t ext2fs_check_mount_point(const char *device, int *mount_flags,
1485                                           char *mtpt, int mtlen);
1486
1487 /* punch.c */
1488 /*
1489  * NOTE: This function removes from an inode the blocks "start", "end", and
1490  * every block in between.
1491  */
1492 extern errcode_t ext2fs_punch(ext2_filsys fs, ext2_ino_t ino,
1493                               struct ext2_inode *inode,
1494                               char *block_buf, blk64_t start,
1495                               blk64_t end);
1496
1497 /* namei.c */
1498 extern errcode_t ext2fs_lookup(ext2_filsys fs, ext2_ino_t dir, const char *name,
1499                          int namelen, char *buf, ext2_ino_t *inode);
1500 extern errcode_t ext2fs_namei(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd,
1501                         const char *name, ext2_ino_t *inode);
1502 errcode_t ext2fs_namei_follow(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd,
1503                               const char *name, ext2_ino_t *inode);
1504 extern errcode_t ext2fs_follow_link(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd,
1505                         ext2_ino_t inode, ext2_ino_t *res_inode);
1506
1507 /* native.c */
1508 int ext2fs_native_flag(void);
1509
1510 /* newdir.c */
1511 extern errcode_t ext2fs_new_dir_block(ext2_filsys fs, ext2_ino_t dir_ino,
1512                                 ext2_ino_t parent_ino, char **block);
1513 extern errcode_t ext2fs_new_dir_inline_data(ext2_filsys fs, ext2_ino_t dir_ino,
1514                                 ext2_ino_t parent_ino, __u32 *iblock);
1515
1516 /* mkdir.c */
1517 extern errcode_t ext2fs_mkdir(ext2_filsys fs, ext2_ino_t parent, ext2_ino_t inum,
1518                               const char *name);
1519
1520 /* mkjournal.c */
1521 extern errcode_t ext2fs_zero_blocks(ext2_filsys fs, blk_t blk, int num,
1522                                     blk_t *ret_blk, int *ret_count);
1523 extern errcode_t ext2fs_zero_blocks2(ext2_filsys fs, blk64_t blk, int num,
1524                                      blk64_t *ret_blk, int *ret_count);
1525 extern errcode_t ext2fs_create_journal_superblock(ext2_filsys fs,
1526                                                   __u32 num_blocks, int flags,
1527                                                   char  **ret_jsb);
1528 extern errcode_t ext2fs_add_journal_device(ext2_filsys fs,
1529                                            ext2_filsys journal_dev);
1530 extern errcode_t ext2fs_add_journal_inode(ext2_filsys fs, blk_t num_blocks,
1531                                           int flags);
1532 extern errcode_t ext2fs_add_journal_inode2(ext2_filsys fs, blk_t num_blocks,
1533                                            blk64_t goal, int flags);
1534 extern int ext2fs_default_journal_size(__u64 num_blocks);
1535 extern int ext2fs_journal_sb_start(int blocksize);
1536
1537 /* openfs.c */
1538 extern errcode_t ext2fs_open(const char *name, int flags, int superblock,
1539                              unsigned int block_size, io_manager manager,
1540                              ext2_filsys *ret_fs);
1541 extern errcode_t ext2fs_open2(const char *name, const char *io_options,
1542                               int flags, int superblock,
1543                               unsigned int block_size, io_manager manager,
1544                               ext2_filsys *ret_fs);
1545 /*
1546  * The dgrp_t argument to these two functions is not actually a group number
1547  * but a block number offset within a group table!  Convert with the formula
1548  * (group_number / groups_per_block).
1549  */
1550 extern blk64_t ext2fs_descriptor_block_loc2(ext2_filsys fs,
1551                                         blk64_t group_block, dgrp_t i);
1552 extern blk_t ext2fs_descriptor_block_loc(ext2_filsys fs, blk_t group_block,
1553                                          dgrp_t i);
1554 errcode_t ext2fs_get_data_io(ext2_filsys fs, io_channel *old_io);
1555 errcode_t ext2fs_set_data_io(ext2_filsys fs, io_channel new_io);
1556 errcode_t ext2fs_rewrite_to_io(ext2_filsys fs, io_channel new_io);
1557
1558 /* get_pathname.c */
1559 extern errcode_t ext2fs_get_pathname(ext2_filsys fs, ext2_ino_t dir, ext2_ino_t ino,
1560                                char **name);
1561
1562 /* link.c */
1563 errcode_t ext2fs_link(ext2_filsys fs, ext2_ino_t dir, const char *name,
1564                       ext2_ino_t ino, int flags);
1565 errcode_t ext2fs_unlink(ext2_filsys fs, ext2_ino_t dir, const char *name,
1566                         ext2_ino_t ino, int flags);
1567
1568 /* symlink.c */
1569 errcode_t ext2fs_symlink(ext2_filsys fs, ext2_ino_t parent, ext2_ino_t ino,
1570                          const char *name, const char *target);
1571
1572 /* mmp.c */
1573 errcode_t ext2fs_mmp_read(ext2_filsys fs, blk64_t mmp_blk, void *buf);
1574 errcode_t ext2fs_mmp_write(ext2_filsys fs, blk64_t mmp_blk, void *buf);
1575 errcode_t ext2fs_mmp_clear(ext2_filsys fs);
1576 errcode_t ext2fs_mmp_init(ext2_filsys fs);
1577 errcode_t ext2fs_mmp_start(ext2_filsys fs);
1578 errcode_t ext2fs_mmp_update(ext2_filsys fs);
1579 errcode_t ext2fs_mmp_update2(ext2_filsys fs, int immediately);
1580 errcode_t ext2fs_mmp_stop(ext2_filsys fs);
1581 unsigned ext2fs_mmp_new_seq(void);
1582
1583 /* read_bb.c */
1584 extern errcode_t ext2fs_read_bb_inode(ext2_filsys fs,
1585                                       ext2_badblocks_list *bb_list);
1586
1587 /* read_bb_file.c */
1588 extern errcode_t ext2fs_read_bb_FILE2(ext2_filsys fs, FILE *f,
1589                                       ext2_badblocks_list *bb_list,
1590                                       void *priv_data,
1591                                       void (*invalid)(ext2_filsys fs,
1592                                                       blk_t blk,
1593                                                       char *badstr,
1594                                                       void *priv_data));
1595 extern errcode_t ext2fs_read_bb_FILE(ext2_filsys fs, FILE *f,
1596                                      ext2_badblocks_list *bb_list,
1597                                      void (*invalid)(ext2_filsys fs,
1598                                                      blk_t blk));
1599
1600 /* res_gdt.c */
1601 extern errcode_t ext2fs_create_resize_inode(ext2_filsys fs);
1602
1603 /*sha256.c */
1604 #define EXT2FS_SHA256_LENGTH 32
1605 #if 0
1606 extern void ext2fs_sha256(const unsigned char *in, unsigned long in_size,
1607                    unsigned char out[EXT2FS_SHA256_LENGTH]);
1608 #endif
1609
1610 /* sha512.c */
1611 #define EXT2FS_SHA512_LENGTH 64
1612 extern void ext2fs_sha512(const unsigned char *in, unsigned long in_size,
1613                           unsigned char out[EXT2FS_SHA512_LENGTH]);
1614
1615 /* swapfs.c */
1616 extern errcode_t ext2fs_dirent_swab_in2(ext2_filsys fs, char *buf, size_t size,
1617                                         int flags);
1618 extern errcode_t ext2fs_dirent_swab_in(ext2_filsys fs, char *buf, int flags);
1619 extern errcode_t ext2fs_dirent_swab_out2(ext2_filsys fs, char *buf, size_t size,
1620                                          int flags);
1621 extern errcode_t ext2fs_dirent_swab_out(ext2_filsys fs, char *buf, int flags);
1622 extern void ext2fs_swap_ext_attr(char *to, char *from, int bufsize,
1623                                  int has_header);
1624 extern void ext2fs_swap_ext_attr_header(struct ext2_ext_attr_header *to_header,
1625                                         struct ext2_ext_attr_header *from_hdr);
1626 extern void ext2fs_swap_ext_attr_entry(struct ext2_ext_attr_entry *to_entry,
1627                                        struct ext2_ext_attr_entry *from_entry);
1628 extern void ext2fs_swap_super(struct ext2_super_block * super);
1629 extern void ext2fs_swap_group_desc(struct ext2_group_desc *gdp);
1630 extern void ext2fs_swap_group_desc2(ext2_filsys, struct ext2_group_desc *gdp);
1631 extern void ext2fs_swap_inode_full(ext2_filsys fs, struct ext2_inode_large *t,
1632                                    struct ext2_inode_large *f, int hostorder,
1633                                    int bufsize);
1634 extern void ext2fs_swap_inode(ext2_filsys fs,struct ext2_inode *t,
1635                               struct ext2_inode *f, int hostorder);
1636 extern void ext2fs_swap_mmp(struct mmp_struct *mmp);
1637
1638 /* unix_io.c */
1639 extern int ext2fs_open_file(const char *pathname, int flags, mode_t mode);
1640 extern int ext2fs_stat(const char *path, ext2fs_struct_stat *buf);
1641 extern int ext2fs_fstat(int fd, ext2fs_struct_stat *buf);
1642
1643 /* valid_blk.c */
1644 extern int ext2fs_inode_has_valid_blocks(struct ext2_inode *inode);
1645 extern int ext2fs_inode_has_valid_blocks2(ext2_filsys fs,
1646                                           struct ext2_inode *inode);
1647
1648 /* version.c */
1649 extern int ext2fs_parse_version_string(const char *ver_string);
1650 extern int ext2fs_get_library_version(const char **ver_string,
1651                                       const char **date_string);
1652
1653 /* write_bb_file.c */
1654 extern errcode_t ext2fs_write_bb_FILE(ext2_badblocks_list bb_list,
1655                                       unsigned int flags,
1656                                       FILE *f);
1657
1658
1659 /* inline functions */
1660 #ifdef NO_INLINE_FUNCS
1661 extern void ext2fs_init_csum_seed(ext2_filsys fs);
1662 extern errcode_t ext2fs_get_mem(unsigned long size, void *ptr);
1663 extern errcode_t ext2fs_get_memzero(unsigned long size, void *ptr);
1664 extern errcode_t ext2fs_get_array(unsigned long count,
1665                                   unsigned long size, void *ptr);
1666 extern errcode_t ext2fs_get_arrayzero(unsigned long count,
1667                                       unsigned long size, void *ptr);
1668 extern errcode_t ext2fs_free_mem(void *ptr);
1669 extern errcode_t ext2fs_resize_mem(unsigned long old_size,
1670                                    unsigned long size, void *ptr);
1671 extern void ext2fs_mark_super_dirty(ext2_filsys fs);
1672 extern void ext2fs_mark_changed(ext2_filsys fs);
1673 extern int ext2fs_test_changed(ext2_filsys fs);
1674 extern void ext2fs_mark_valid(ext2_filsys fs);
1675 extern void ext2fs_unmark_valid(ext2_filsys fs);
1676 extern int ext2fs_test_valid(ext2_filsys fs);
1677 extern void ext2fs_mark_ib_dirty(ext2_filsys fs);
1678 extern void ext2fs_mark_bb_dirty(ext2_filsys fs);
1679 extern int ext2fs_test_ib_dirty(ext2_filsys fs);
1680 extern int ext2fs_test_bb_dirty(ext2_filsys fs);
1681 extern dgrp_t ext2fs_group_of_blk(ext2_filsys fs, blk_t blk);
1682 extern dgrp_t ext2fs_group_of_ino(ext2_filsys fs, ext2_ino_t ino);
1683 extern blk_t ext2fs_group_first_block(ext2_filsys fs, dgrp_t group);
1684 extern blk_t ext2fs_group_last_block(ext2_filsys fs, dgrp_t group);
1685 extern blk_t ext2fs_inode_data_blocks(ext2_filsys fs,
1686                                       struct ext2_inode *inode);
1687 extern unsigned int ext2fs_div_ceil(unsigned int a, unsigned int b);
1688 extern __u64 ext2fs_div64_ceil(__u64 a, __u64 b);
1689 extern int ext2fs_dirent_name_len(const struct ext2_dir_entry *entry);
1690 extern void ext2fs_dirent_set_name_len(struct ext2_dir_entry *entry, int len);
1691 extern int ext2fs_dirent_file_type(const struct ext2_dir_entry *entry);
1692 extern void ext2fs_dirent_set_file_type(struct ext2_dir_entry *entry, int type);
1693
1694 #endif
1695
1696 /*
1697  * The actual inlined functions definitions themselves...
1698  *
1699  * If NO_INLINE_FUNCS is defined, then we won't try to do inline
1700  * functions at all!
1701  */
1702 #if (defined(INCLUDE_INLINE_FUNCS) || !defined(NO_INLINE_FUNCS))
1703 #ifdef INCLUDE_INLINE_FUNCS
1704 #define _INLINE_ extern
1705 #else
1706 #if (__STDC_VERSION__ >= 199901L)
1707 #define _INLINE_ inline
1708 #else
1709 #ifdef __GNUC__
1710 #define _INLINE_ extern __inline__
1711 #else                           /* For Watcom C */
1712 #define _INLINE_ extern inline
1713 #endif /* __GNUC__ */
1714 #endif /* __STDC_VERSION__ >= 199901L */
1715 #endif
1716
1717 _INLINE_ void ext2fs_init_csum_seed(ext2_filsys fs)
1718 {
1719         if (!EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
1720                                         EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
1721                 return;
1722
1723         fs->csum_seed = ext2fs_crc32c_le(~0, fs->super->s_uuid,
1724                                          sizeof(fs->super->s_uuid));
1725 }
1726
1727 #ifndef EXT2_CUSTOM_MEMORY_ROUTINES
1728 #include <string.h>
1729 /*
1730  *  Allocate memory.  The 'ptr' arg must point to a pointer.
1731  */
1732 _INLINE_ errcode_t ext2fs_get_mem(unsigned long size, void *ptr)
1733 {
1734         void *pp;
1735
1736         pp = malloc(size);
1737         if (!pp)
1738                 return EXT2_ET_NO_MEMORY;
1739         memcpy(ptr, &pp, sizeof (pp));
1740         return 0;
1741 }
1742
1743 _INLINE_ errcode_t ext2fs_get_memzero(unsigned long size, void *ptr)
1744 {
1745         void *pp;
1746
1747         pp = malloc(size);
1748         if (!pp)
1749                 return EXT2_ET_NO_MEMORY;
1750         memset(pp, 0, size);
1751         memcpy(ptr, &pp, sizeof(pp));
1752         return 0;
1753 }
1754
1755 _INLINE_ errcode_t ext2fs_get_array(unsigned long count, unsigned long size, void *ptr)
1756 {
1757         if (count && (~0UL)/count < size)
1758                 return EXT2_ET_NO_MEMORY;
1759         return ext2fs_get_mem(count*size, ptr);
1760 }
1761
1762 _INLINE_ errcode_t ext2fs_get_arrayzero(unsigned long count,
1763                                         unsigned long size, void *ptr)
1764 {
1765         void *pp;
1766
1767         if (count && (~0UL)/count < size)
1768                 return EXT2_ET_NO_MEMORY;
1769         pp = calloc(count, size);
1770         if (!pp)
1771                 return EXT2_ET_NO_MEMORY;
1772         memcpy(ptr, &pp, sizeof(pp));
1773         return 0;
1774 }
1775
1776 /*
1777  * Free memory.  The 'ptr' arg must point to a pointer.
1778  */
1779 _INLINE_ errcode_t ext2fs_free_mem(void *ptr)
1780 {
1781         void *p;
1782
1783         memcpy(&p, ptr, sizeof(p));
1784         free(p);
1785         p = 0;
1786         memcpy(ptr, &p, sizeof(p));
1787         return 0;
1788 }
1789
1790 /*
1791  *  Resize memory.  The 'ptr' arg must point to a pointer.
1792  */
1793 _INLINE_ errcode_t ext2fs_resize_mem(unsigned long EXT2FS_ATTR((unused)) old_size,
1794                                      unsigned long size, void *ptr)
1795 {
1796         void *p;
1797
1798         /* Use "memcpy" for pointer assignments here to avoid problems
1799          * with C99 strict type aliasing rules. */
1800         memcpy(&p, ptr, sizeof(p));
1801         p = realloc(p, size);
1802         if (!p)
1803                 return EXT2_ET_NO_MEMORY;
1804         memcpy(ptr, &p, sizeof(p));
1805         return 0;
1806 }
1807 #endif  /* Custom memory routines */
1808
1809 /*
1810  * Mark a filesystem superblock as dirty
1811  */
1812 _INLINE_ void ext2fs_mark_super_dirty(ext2_filsys fs)
1813 {
1814         fs->flags |= EXT2_FLAG_DIRTY | EXT2_FLAG_CHANGED;
1815 }
1816
1817 /*
1818  * Mark a filesystem as changed
1819  */
1820 _INLINE_ void ext2fs_mark_changed(ext2_filsys fs)
1821 {
1822         fs->flags |= EXT2_FLAG_CHANGED;
1823 }
1824
1825 /*
1826  * Check to see if a filesystem has changed
1827  */
1828 _INLINE_ int ext2fs_test_changed(ext2_filsys fs)
1829 {
1830         return (fs->flags & EXT2_FLAG_CHANGED);
1831 }
1832
1833 /*
1834  * Mark a filesystem as valid
1835  */
1836 _INLINE_ void ext2fs_mark_valid(ext2_filsys fs)
1837 {
1838         fs->flags |= EXT2_FLAG_VALID;
1839 }
1840
1841 /*
1842  * Mark a filesystem as NOT valid
1843  */
1844 _INLINE_ void ext2fs_unmark_valid(ext2_filsys fs)
1845 {
1846         fs->flags &= ~EXT2_FLAG_VALID;
1847 }
1848
1849 /*
1850  * Check to see if a filesystem is valid
1851  */
1852 _INLINE_ int ext2fs_test_valid(ext2_filsys fs)
1853 {
1854         return (fs->flags & EXT2_FLAG_VALID);
1855 }
1856
1857 /*
1858  * Mark the inode bitmap as dirty
1859  */
1860 _INLINE_ void ext2fs_mark_ib_dirty(ext2_filsys fs)
1861 {
1862         fs->flags |= EXT2_FLAG_IB_DIRTY | EXT2_FLAG_CHANGED;
1863 }
1864
1865 /*
1866  * Mark the block bitmap as dirty
1867  */
1868 _INLINE_ void ext2fs_mark_bb_dirty(ext2_filsys fs)
1869 {
1870         fs->flags |= EXT2_FLAG_BB_DIRTY | EXT2_FLAG_CHANGED;
1871 }
1872
1873 /*
1874  * Check to see if a filesystem's inode bitmap is dirty
1875  */
1876 _INLINE_ int ext2fs_test_ib_dirty(ext2_filsys fs)
1877 {
1878         return (fs->flags & EXT2_FLAG_IB_DIRTY);
1879 }
1880
1881 /*
1882  * Check to see if a filesystem's block bitmap is dirty
1883  */
1884 _INLINE_ int ext2fs_test_bb_dirty(ext2_filsys fs)
1885 {
1886         return (fs->flags & EXT2_FLAG_BB_DIRTY);
1887 }
1888
1889 /*
1890  * Return the group # of a block
1891  */
1892 _INLINE_ dgrp_t ext2fs_group_of_blk(ext2_filsys fs, blk_t blk)
1893 {
1894         return ext2fs_group_of_blk2(fs, blk);
1895 }
1896 /*
1897  * Return the group # of an inode number
1898  */
1899 _INLINE_ dgrp_t ext2fs_group_of_ino(ext2_filsys fs, ext2_ino_t ino)
1900 {
1901         return (ino - 1) / fs->super->s_inodes_per_group;
1902 }
1903
1904 /*
1905  * Return the first block (inclusive) in a group
1906  */
1907 _INLINE_ blk_t ext2fs_group_first_block(ext2_filsys fs, dgrp_t group)
1908 {
1909         return (blk_t) ext2fs_group_first_block2(fs, group);
1910 }
1911
1912 /*
1913  * Return the last block (inclusive) in a group
1914  */
1915 _INLINE_ blk_t ext2fs_group_last_block(ext2_filsys fs, dgrp_t group)
1916 {
1917         return (blk_t) ext2fs_group_last_block2(fs, group);
1918 }
1919
1920 _INLINE_ blk_t ext2fs_inode_data_blocks(ext2_filsys fs,
1921                                         struct ext2_inode *inode)
1922 {
1923         return (blk_t) ext2fs_inode_data_blocks2(fs, inode);
1924 }
1925
1926 /*
1927  * This is an efficient, overflow safe way of calculating ceil((1.0 * a) / b)
1928  */
1929 _INLINE_ unsigned int ext2fs_div_ceil(unsigned int a, unsigned int b)
1930 {
1931         if (!a)
1932                 return 0;
1933         return ((a - 1) / b) + 1;
1934 }
1935
1936 _INLINE_ __u64 ext2fs_div64_ceil(__u64 a, __u64 b)
1937 {
1938         if (!a)
1939                 return 0;
1940         return ((a - 1) / b) + 1;
1941 }
1942
1943 _INLINE_ int ext2fs_dirent_name_len(const struct ext2_dir_entry *entry)
1944 {
1945         return entry->name_len & 0xff;
1946 }
1947
1948 _INLINE_ void ext2fs_dirent_set_name_len(struct ext2_dir_entry *entry, int len)
1949 {
1950         entry->name_len = (entry->name_len & 0xff00) | (len & 0xff);
1951 }
1952
1953 _INLINE_ int ext2fs_dirent_file_type(const struct ext2_dir_entry *entry)
1954 {
1955         return entry->name_len >> 8;
1956 }
1957
1958 _INLINE_ void ext2fs_dirent_set_file_type(struct ext2_dir_entry *entry, int type)
1959 {
1960         entry->name_len = (entry->name_len & 0xff) | (type << 8);
1961 }
1962
1963 #undef _INLINE_
1964 #endif
1965
1966 #ifdef __cplusplus
1967 }
1968 #endif
1969
1970 #endif /* _EXT2FS_EXT2FS_H */