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