mirror of
https://github.com/wiidev/usbloadergx.git
synced 2024-11-16 00:15:08 +01:00
0f17471b27
*Added sources of the custom libs to the branches *Fixed crash when switching from list layout to grid/carousel layout *Removed 1:1 copy option because its meaningless and almost the same as installing all partitions *Fixed install partition selection. This option needs a reset. Go to settings and reselect your option for this. *Fixed schinese and tchinese language modes (filename bugs. has to be schinese.lang and tchinese.lang like on SVN) *Fixed bug in sound buffer circle *Fixed incorrect behaviour of x-flip when selecting system like (thx Cyan for the patch) *Accept ios revision 65535 for Waninkokos IOSes (thx to PPSainity for pointing it out) *Merged the new theming style branch into trunk. Just as a reminder: ALL old themes will not work until the themers did port it to the new style! *Removed old theme style completely Theme example: The example file of the theme is the Default.them file. It can be found in the SVN trunk. Change in loading of themes: When selecting a theme now a list of all .them files in a folder is displayed. The image folder of that theme has to be in the same folder as the .them file. The image path is defined in the head of the .them file in the line with "Image-Folder: Example\n".
1573 lines
50 KiB
C
1573 lines
50 KiB
C
/*
|
|
* ext2fs.h --- ext2fs
|
|
*
|
|
* Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o.
|
|
*
|
|
* %Begin-Header%
|
|
* This file may be redistributed under the terms of the GNU Library
|
|
* General Public License, version 2.
|
|
* %End-Header%
|
|
*/
|
|
|
|
#ifndef _EXT2FS_EXT2FS_H
|
|
#define _EXT2FS_EXT2FS_H
|
|
|
|
#ifdef __GNUC__
|
|
#define EXT2FS_ATTR(x) __attribute__(x)
|
|
#else
|
|
#define EXT2FS_ATTR(x)
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/*
|
|
* Non-GNU C compilers won't necessarily understand inline
|
|
*/
|
|
#if (!defined(__GNUC__) && !defined(__WATCOMC__))
|
|
#define NO_INLINE_FUNCS
|
|
#endif
|
|
|
|
/*
|
|
* Where the master copy of the superblock is located, and how big
|
|
* superblocks are supposed to be. We define SUPERBLOCK_SIZE because
|
|
* the size of the superblock structure is not necessarily trustworthy
|
|
* (some versions have the padding set up so that the superblock is
|
|
* 1032 bytes long).
|
|
*/
|
|
#define SUPERBLOCK_OFFSET 1024
|
|
#define SUPERBLOCK_SIZE 1024
|
|
|
|
/*
|
|
* The last ext2fs revision level that this version of the library is
|
|
* able to support.
|
|
*/
|
|
#define EXT2_LIB_CURRENT_REV EXT2_DYNAMIC_REV
|
|
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
|
|
#include "ext2_types.h"
|
|
#include "com_err.h"
|
|
#include "ext2_fs.h"
|
|
#include "ext3_extents.h"
|
|
|
|
typedef __u32 ext2_ino_t;
|
|
typedef __u32 blk_t;
|
|
typedef __u64 blk64_t;
|
|
typedef __u32 dgrp_t;
|
|
typedef __u32 ext2_off_t;
|
|
typedef __u64 ext2_off64_t;
|
|
typedef __s64 e2_blkcnt_t;
|
|
typedef __u32 ext2_dirhash_t;
|
|
|
|
#include "ext2_io.h"
|
|
#include "ext2_err.h"
|
|
#include "ext2_ext_attr.h"
|
|
|
|
/*
|
|
* Portability help for Microsoft Visual C++
|
|
*/
|
|
#ifdef _MSC_VER
|
|
#define EXT2_QSORT_TYPE int __cdecl
|
|
#else
|
|
#define EXT2_QSORT_TYPE int
|
|
#endif
|
|
|
|
typedef struct struct_ext2_filsys *ext2_filsys;
|
|
|
|
#define EXT2FS_MARK_ERROR 0
|
|
#define EXT2FS_UNMARK_ERROR 1
|
|
#define EXT2FS_TEST_ERROR 2
|
|
|
|
typedef struct ext2fs_struct_generic_bitmap *ext2fs_generic_bitmap;
|
|
typedef struct ext2fs_struct_generic_bitmap *ext2fs_inode_bitmap;
|
|
typedef struct ext2fs_struct_generic_bitmap *ext2fs_block_bitmap;
|
|
|
|
#define EXT2_FIRST_INODE(s) EXT2_FIRST_INO(s)
|
|
|
|
|
|
/*
|
|
* Badblocks list definitions
|
|
*/
|
|
|
|
typedef struct ext2_struct_u32_list *ext2_badblocks_list;
|
|
typedef struct ext2_struct_u32_iterate *ext2_badblocks_iterate;
|
|
|
|
typedef struct ext2_struct_u32_list *ext2_u32_list;
|
|
typedef struct ext2_struct_u32_iterate *ext2_u32_iterate;
|
|
|
|
/* old */
|
|
typedef struct ext2_struct_u32_list *badblocks_list;
|
|
typedef struct ext2_struct_u32_iterate *badblocks_iterate;
|
|
|
|
#define BADBLOCKS_FLAG_DIRTY 1
|
|
|
|
/*
|
|
* ext2_dblist structure and abstractions (see dblist.c)
|
|
*/
|
|
struct ext2_db_entry2 {
|
|
ext2_ino_t ino;
|
|
blk64_t blk;
|
|
e2_blkcnt_t blockcnt;
|
|
};
|
|
|
|
/* Ye Olde 32-bit version */
|
|
struct ext2_db_entry {
|
|
ext2_ino_t ino;
|
|
blk_t blk;
|
|
int blockcnt;
|
|
};
|
|
|
|
typedef struct ext2_struct_dblist *ext2_dblist;
|
|
|
|
#define DBLIST_ABORT 1
|
|
|
|
/*
|
|
* ext2_fileio definitions
|
|
*/
|
|
|
|
#define EXT2_FILE_WRITE 0x0001
|
|
#define EXT2_FILE_CREATE 0x0002
|
|
|
|
#define EXT2_FILE_MASK 0x00FF
|
|
|
|
#define EXT2_FILE_BUF_DIRTY 0x4000
|
|
#define EXT2_FILE_BUF_VALID 0x2000
|
|
|
|
typedef struct ext2_file *ext2_file_t;
|
|
|
|
#define EXT2_SEEK_SET 0
|
|
#define EXT2_SEEK_CUR 1
|
|
#define EXT2_SEEK_END 2
|
|
|
|
/*
|
|
* Flags for the ext2_filsys structure and for ext2fs_open()
|
|
*/
|
|
#define EXT2_FLAG_RW 0x01
|
|
#define EXT2_FLAG_CHANGED 0x02
|
|
#define EXT2_FLAG_DIRTY 0x04
|
|
#define EXT2_FLAG_VALID 0x08
|
|
#define EXT2_FLAG_IB_DIRTY 0x10
|
|
#define EXT2_FLAG_BB_DIRTY 0x20
|
|
#define EXT2_FLAG_SWAP_BYTES 0x40
|
|
#define EXT2_FLAG_SWAP_BYTES_READ 0x80
|
|
#define EXT2_FLAG_SWAP_BYTES_WRITE 0x100
|
|
#define EXT2_FLAG_MASTER_SB_ONLY 0x200
|
|
#define EXT2_FLAG_FORCE 0x400
|
|
#define EXT2_FLAG_SUPER_ONLY 0x800
|
|
#define EXT2_FLAG_JOURNAL_DEV_OK 0x1000
|
|
#define EXT2_FLAG_IMAGE_FILE 0x2000
|
|
#define EXT2_FLAG_EXCLUSIVE 0x4000
|
|
#define EXT2_FLAG_SOFTSUPP_FEATURES 0x8000
|
|
#define EXT2_FLAG_NOFREE_ON_ERROR 0x10000
|
|
#define EXT2_FLAG_64BITS 0x20000
|
|
#define EXT2_FLAG_PRINT_PROGRESS 0x40000
|
|
#define EXT2_FLAG_DIRECT_IO 0x80000
|
|
|
|
/*
|
|
* Special flag in the ext2 inode i_flag field that means that this is
|
|
* a new inode. (So that ext2_write_inode() can clear extra fields.)
|
|
*/
|
|
#define EXT2_NEW_INODE_FL 0x80000000
|
|
|
|
/*
|
|
* Flags for mkjournal
|
|
*
|
|
* EXT2_MKJOURNAL_V1_SUPER Make a (deprecated) V1 journal superblock
|
|
*/
|
|
#define EXT2_MKJOURNAL_V1_SUPER 0x0000001
|
|
|
|
struct opaque_ext2_group_desc;
|
|
|
|
struct struct_ext2_filsys {
|
|
errcode_t magic;
|
|
io_channel io;
|
|
int flags;
|
|
char * device_name;
|
|
struct ext2_super_block * super;
|
|
unsigned int blocksize;
|
|
int fragsize;
|
|
dgrp_t group_desc_count;
|
|
unsigned long desc_blocks;
|
|
struct opaque_ext2_group_desc * group_desc;
|
|
int inode_blocks_per_group;
|
|
ext2fs_inode_bitmap inode_map;
|
|
ext2fs_block_bitmap block_map;
|
|
/* XXX FIXME-64: not 64-bit safe, but not used? */
|
|
errcode_t (*get_blocks)(ext2_filsys fs, ext2_ino_t ino, blk_t *blocks);
|
|
errcode_t (*check_directory)(ext2_filsys fs, ext2_ino_t ino);
|
|
errcode_t (*write_bitmaps)(ext2_filsys fs);
|
|
errcode_t (*read_inode)(ext2_filsys fs, ext2_ino_t ino,
|
|
struct ext2_inode *inode);
|
|
errcode_t (*write_inode)(ext2_filsys fs, ext2_ino_t ino,
|
|
struct ext2_inode *inode);
|
|
ext2_badblocks_list badblocks;
|
|
ext2_dblist dblist;
|
|
__u32 stride; /* for mke2fs */
|
|
struct ext2_super_block * orig_super;
|
|
struct ext2_image_hdr * image_header;
|
|
__u32 umask;
|
|
time_t now;
|
|
/*
|
|
* Reserved for future expansion
|
|
*/
|
|
__u32 reserved[7];
|
|
|
|
/*
|
|
* Reserved for the use of the calling application.
|
|
*/
|
|
void * priv_data;
|
|
|
|
/*
|
|
* Inode cache
|
|
*/
|
|
struct ext2_inode_cache *icache;
|
|
io_channel image_io;
|
|
|
|
/*
|
|
* More callback functions
|
|
*/
|
|
errcode_t (*get_alloc_block)(ext2_filsys fs, blk64_t goal,
|
|
blk64_t *ret);
|
|
void (*block_alloc_stats)(ext2_filsys fs, blk64_t blk, int inuse);
|
|
};
|
|
|
|
#include "bitops.h"
|
|
|
|
/*
|
|
* Return flags for the block iterator functions
|
|
*/
|
|
#define BLOCK_CHANGED 1
|
|
#define BLOCK_ABORT 2
|
|
#define BLOCK_ERROR 4
|
|
|
|
/*
|
|
* Block interate flags
|
|
*
|
|
* BLOCK_FLAG_APPEND, or BLOCK_FLAG_HOLE, indicates that the interator
|
|
* function should be called on blocks where the block number is zero.
|
|
* This is used by ext2fs_expand_dir() to be able to add a new block
|
|
* to an inode. It can also be used for programs that want to be able
|
|
* to deal with files that contain "holes".
|
|
*
|
|
* BLOCK_FLAG_DEPTH_TRAVERSE indicates that the iterator function for
|
|
* the indirect, doubly indirect, etc. blocks should be called after
|
|
* all of the blocks containined in the indirect blocks are processed.
|
|
* This is useful if you are going to be deallocating blocks from an
|
|
* inode.
|
|
*
|
|
* BLOCK_FLAG_DATA_ONLY indicates that the iterator function should be
|
|
* called for data blocks only.
|
|
*
|
|
* BLOCK_FLAG_READ_ONLY is a promise by the caller that it will not
|
|
* modify returned block number.
|
|
*
|
|
* BLOCK_FLAG_NO_LARGE is for internal use only. It informs
|
|
* ext2fs_block_iterate2 that large files won't be accepted.
|
|
*/
|
|
#define BLOCK_FLAG_APPEND 1
|
|
#define BLOCK_FLAG_HOLE 1
|
|
#define BLOCK_FLAG_DEPTH_TRAVERSE 2
|
|
#define BLOCK_FLAG_DATA_ONLY 4
|
|
#define BLOCK_FLAG_READ_ONLY 8
|
|
|
|
#define BLOCK_FLAG_NO_LARGE 0x1000
|
|
|
|
/*
|
|
* Magic "block count" return values for the block iterator function.
|
|
*/
|
|
#define BLOCK_COUNT_IND (-1)
|
|
#define BLOCK_COUNT_DIND (-2)
|
|
#define BLOCK_COUNT_TIND (-3)
|
|
#define BLOCK_COUNT_TRANSLATOR (-4)
|
|
|
|
/*
|
|
* Flags for ext2fs_move_blocks
|
|
*/
|
|
#define EXT2_BMOVE_GET_DBLIST 0x0001
|
|
#define EXT2_BMOVE_DEBUG 0x0002
|
|
|
|
/*
|
|
* Generic (non-filesystem layout specific) extents structure
|
|
*/
|
|
|
|
#define EXT2_EXTENT_FLAGS_LEAF 0x0001
|
|
#define EXT2_EXTENT_FLAGS_UNINIT 0x0002
|
|
#define EXT2_EXTENT_FLAGS_SECOND_VISIT 0x0004
|
|
|
|
struct ext2fs_extent {
|
|
blk64_t e_pblk; /* first physical block */
|
|
blk64_t e_lblk; /* first logical block extent covers */
|
|
__u32 e_len; /* number of blocks covered by extent */
|
|
__u32 e_flags; /* extent flags */
|
|
};
|
|
|
|
typedef struct ext2_extent_handle *ext2_extent_handle_t;
|
|
typedef struct ext2_extent_path *ext2_extent_path_t;
|
|
|
|
/*
|
|
* Flags used by ext2fs_extent_get()
|
|
*/
|
|
#define EXT2_EXTENT_CURRENT 0x0000
|
|
#define EXT2_EXTENT_MOVE_MASK 0x000F
|
|
#define EXT2_EXTENT_ROOT 0x0001
|
|
#define EXT2_EXTENT_LAST_LEAF 0x0002
|
|
#define EXT2_EXTENT_FIRST_SIB 0x0003
|
|
#define EXT2_EXTENT_LAST_SIB 0x0004
|
|
#define EXT2_EXTENT_NEXT_SIB 0x0005
|
|
#define EXT2_EXTENT_PREV_SIB 0x0006
|
|
#define EXT2_EXTENT_NEXT_LEAF 0x0007
|
|
#define EXT2_EXTENT_PREV_LEAF 0x0008
|
|
#define EXT2_EXTENT_NEXT 0x0009
|
|
#define EXT2_EXTENT_PREV 0x000A
|
|
#define EXT2_EXTENT_UP 0x000B
|
|
#define EXT2_EXTENT_DOWN 0x000C
|
|
#define EXT2_EXTENT_DOWN_AND_LAST 0x000D
|
|
|
|
/*
|
|
* Flags used by ext2fs_extent_insert()
|
|
*/
|
|
#define EXT2_EXTENT_INSERT_AFTER 0x0001 /* insert after handle loc'n */
|
|
#define EXT2_EXTENT_INSERT_NOSPLIT 0x0002 /* insert may not cause split */
|
|
|
|
/*
|
|
* Flags used by ext2fs_extent_delete()
|
|
*/
|
|
#define EXT2_EXTENT_DELETE_KEEP_EMPTY 0x001 /* keep node if last extnt gone */
|
|
|
|
/*
|
|
* Flags used by ext2fs_extent_set_bmap()
|
|
*/
|
|
#define EXT2_EXTENT_SET_BMAP_UNINIT 0x0001
|
|
|
|
/*
|
|
* Data structure returned by ext2fs_extent_get_info()
|
|
*/
|
|
struct ext2_extent_info {
|
|
int curr_entry;
|
|
int curr_level;
|
|
int num_entries;
|
|
int max_entries;
|
|
int max_depth;
|
|
int bytes_avail;
|
|
blk64_t max_lblk;
|
|
blk64_t max_pblk;
|
|
__u32 max_len;
|
|
__u32 max_uninit_len;
|
|
};
|
|
|
|
/*
|
|
* Flags for directory block reading and writing functions
|
|
*/
|
|
#define EXT2_DIRBLOCK_V2_STRUCT 0x0001
|
|
|
|
/*
|
|
* Return flags for the directory iterator functions
|
|
*/
|
|
#define DIRENT_CHANGED 1
|
|
#define DIRENT_ABORT 2
|
|
#define DIRENT_ERROR 3
|
|
|
|
/*
|
|
* Directory iterator flags
|
|
*/
|
|
|
|
#define DIRENT_FLAG_INCLUDE_EMPTY 1
|
|
#define DIRENT_FLAG_INCLUDE_REMOVED 2
|
|
|
|
#define DIRENT_DOT_FILE 1
|
|
#define DIRENT_DOT_DOT_FILE 2
|
|
#define DIRENT_OTHER_FILE 3
|
|
#define DIRENT_DELETED_FILE 4
|
|
|
|
/*
|
|
* Inode scan definitions
|
|
*/
|
|
typedef struct ext2_struct_inode_scan *ext2_inode_scan;
|
|
|
|
/*
|
|
* ext2fs_scan flags
|
|
*/
|
|
#define EXT2_SF_CHK_BADBLOCKS 0x0001
|
|
#define EXT2_SF_BAD_INODE_BLK 0x0002
|
|
#define EXT2_SF_BAD_EXTRA_BYTES 0x0004
|
|
#define EXT2_SF_SKIP_MISSING_ITABLE 0x0008
|
|
#define EXT2_SF_DO_LAZY 0x0010
|
|
|
|
/*
|
|
* ext2fs_check_if_mounted flags
|
|
*/
|
|
#define EXT2_MF_MOUNTED 1
|
|
#define EXT2_MF_ISROOT 2
|
|
#define EXT2_MF_READONLY 4
|
|
#define EXT2_MF_SWAP 8
|
|
#define EXT2_MF_BUSY 16
|
|
|
|
/*
|
|
* Ext2/linux mode flags. We define them here so that we don't need
|
|
* to depend on the OS's sys/stat.h, since we may be compiling on a
|
|
* non-Linux system.
|
|
*/
|
|
#define LINUX_S_IFMT 00170000
|
|
#define LINUX_S_IFSOCK 0140000
|
|
#define LINUX_S_IFLNK 0120000
|
|
#define LINUX_S_IFREG 0100000
|
|
#define LINUX_S_IFBLK 0060000
|
|
#define LINUX_S_IFDIR 0040000
|
|
#define LINUX_S_IFCHR 0020000
|
|
#define LINUX_S_IFIFO 0010000
|
|
#define LINUX_S_ISUID 0004000
|
|
#define LINUX_S_ISGID 0002000
|
|
#define LINUX_S_ISVTX 0001000
|
|
|
|
#define LINUX_S_IRWXU 00700
|
|
#define LINUX_S_IRUSR 00400
|
|
#define LINUX_S_IWUSR 00200
|
|
#define LINUX_S_IXUSR 00100
|
|
|
|
#define LINUX_S_IRWXG 00070
|
|
#define LINUX_S_IRGRP 00040
|
|
#define LINUX_S_IWGRP 00020
|
|
#define LINUX_S_IXGRP 00010
|
|
|
|
#define LINUX_S_IRWXO 00007
|
|
#define LINUX_S_IROTH 00004
|
|
#define LINUX_S_IWOTH 00002
|
|
#define LINUX_S_IXOTH 00001
|
|
|
|
#define LINUX_S_ISLNK(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFLNK)
|
|
#define LINUX_S_ISREG(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFREG)
|
|
#define LINUX_S_ISDIR(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFDIR)
|
|
#define LINUX_S_ISCHR(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFCHR)
|
|
#define LINUX_S_ISBLK(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFBLK)
|
|
#define LINUX_S_ISFIFO(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFIFO)
|
|
#define LINUX_S_ISSOCK(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFSOCK)
|
|
|
|
/*
|
|
* ext2 size of an inode
|
|
*/
|
|
#define EXT2_I_SIZE(i) ((i)->i_size | ((__u64) (i)->i_size_high << 32))
|
|
|
|
/*
|
|
* ext2_icount_t abstraction
|
|
*/
|
|
#define EXT2_ICOUNT_OPT_INCREMENT 0x01
|
|
|
|
typedef struct ext2_icount *ext2_icount_t;
|
|
|
|
/*
|
|
* Flags for ext2fs_bmap
|
|
*/
|
|
#define BMAP_ALLOC 0x0001
|
|
#define BMAP_SET 0x0002
|
|
|
|
/*
|
|
* Returned flags from ext2fs_bmap
|
|
*/
|
|
#define BMAP_RET_UNINIT 0x0001
|
|
|
|
/*
|
|
* Flags for imager.c functions
|
|
*/
|
|
#define IMAGER_FLAG_INODEMAP 1
|
|
#define IMAGER_FLAG_SPARSEWRITE 2
|
|
|
|
/*
|
|
* For checking structure magic numbers...
|
|
*/
|
|
|
|
#define EXT2_CHECK_MAGIC(struct, code) \
|
|
if ((struct)->magic != (code)) return (code)
|
|
|
|
|
|
/*
|
|
* For ext2 compression support
|
|
*/
|
|
#define EXT2FS_COMPRESSED_BLKADDR ((blk_t) -1)
|
|
#define HOLE_BLKADDR(_b) ((_b) == 0 || (_b) == EXT2FS_COMPRESSED_BLKADDR)
|
|
|
|
/*
|
|
* Features supported by this version of the library
|
|
*/
|
|
#define EXT2_LIB_FEATURE_COMPAT_SUPP (EXT2_FEATURE_COMPAT_DIR_PREALLOC|\
|
|
EXT2_FEATURE_COMPAT_IMAGIC_INODES|\
|
|
EXT3_FEATURE_COMPAT_HAS_JOURNAL|\
|
|
EXT2_FEATURE_COMPAT_RESIZE_INODE|\
|
|
EXT2_FEATURE_COMPAT_DIR_INDEX|\
|
|
EXT2_FEATURE_COMPAT_EXT_ATTR)
|
|
|
|
/* This #ifdef is temporary until compression is fully supported */
|
|
#ifdef ENABLE_COMPRESSION
|
|
#ifndef I_KNOW_THAT_COMPRESSION_IS_EXPERIMENTAL
|
|
/* If the below warning bugs you, then have
|
|
`CPPFLAGS=-DI_KNOW_THAT_COMPRESSION_IS_EXPERIMENTAL' in your
|
|
environment at configure time. */
|
|
#warning "Compression support is experimental"
|
|
#endif
|
|
#define EXT2_LIB_FEATURE_INCOMPAT_SUPP (EXT2_FEATURE_INCOMPAT_FILETYPE|\
|
|
EXT2_FEATURE_INCOMPAT_COMPRESSION|\
|
|
EXT3_FEATURE_INCOMPAT_JOURNAL_DEV|\
|
|
EXT2_FEATURE_INCOMPAT_META_BG|\
|
|
EXT3_FEATURE_INCOMPAT_RECOVER|\
|
|
EXT3_FEATURE_INCOMPAT_EXTENTS|\
|
|
EXT4_FEATURE_INCOMPAT_FLEX_BG|\
|
|
EXT4_FEATURE_INCOMPAT_64BIT)
|
|
#else
|
|
#define EXT2_LIB_FEATURE_INCOMPAT_SUPP (EXT2_FEATURE_INCOMPAT_FILETYPE|\
|
|
EXT3_FEATURE_INCOMPAT_JOURNAL_DEV|\
|
|
EXT2_FEATURE_INCOMPAT_META_BG|\
|
|
EXT3_FEATURE_INCOMPAT_RECOVER|\
|
|
EXT3_FEATURE_INCOMPAT_EXTENTS|\
|
|
EXT4_FEATURE_INCOMPAT_FLEX_BG|\
|
|
EXT4_FEATURE_INCOMPAT_64BIT)
|
|
#endif
|
|
#define EXT2_LIB_FEATURE_RO_COMPAT_SUPP (EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER|\
|
|
EXT4_FEATURE_RO_COMPAT_HUGE_FILE|\
|
|
EXT2_FEATURE_RO_COMPAT_LARGE_FILE|\
|
|
EXT4_FEATURE_RO_COMPAT_DIR_NLINK|\
|
|
EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE|\
|
|
EXT4_FEATURE_RO_COMPAT_GDT_CSUM)
|
|
|
|
/*
|
|
* These features are only allowed if EXT2_FLAG_SOFTSUPP_FEATURES is passed
|
|
* to ext2fs_openfs()
|
|
*/
|
|
#define EXT2_LIB_SOFTSUPP_INCOMPAT (0)
|
|
#define EXT2_LIB_SOFTSUPP_RO_COMPAT (0)
|
|
|
|
/*
|
|
* function prototypes
|
|
*/
|
|
|
|
/* alloc.c */
|
|
extern errcode_t ext2fs_new_inode(ext2_filsys fs, ext2_ino_t dir, int mode,
|
|
ext2fs_inode_bitmap map, ext2_ino_t *ret);
|
|
extern errcode_t ext2fs_new_block(ext2_filsys fs, blk_t goal,
|
|
ext2fs_block_bitmap map, blk_t *ret);
|
|
extern errcode_t ext2fs_new_block2(ext2_filsys fs, blk64_t goal,
|
|
ext2fs_block_bitmap map, blk64_t *ret);
|
|
extern errcode_t ext2fs_get_free_blocks(ext2_filsys fs, blk_t start,
|
|
blk_t finish, int num,
|
|
ext2fs_block_bitmap map,
|
|
blk_t *ret);
|
|
extern errcode_t ext2fs_get_free_blocks2(ext2_filsys fs, blk64_t start,
|
|
blk64_t finish, int num,
|
|
ext2fs_block_bitmap map,
|
|
blk64_t *ret);
|
|
extern errcode_t ext2fs_alloc_block(ext2_filsys fs, blk_t goal,
|
|
char *block_buf, blk_t *ret);
|
|
extern errcode_t ext2fs_alloc_block2(ext2_filsys fs, blk64_t goal,
|
|
char *block_buf, blk64_t *ret);
|
|
extern void ext2fs_set_alloc_block_callback(ext2_filsys fs,
|
|
errcode_t (*func)(ext2_filsys fs,
|
|
blk64_t goal,
|
|
blk64_t *ret),
|
|
errcode_t (**old)(ext2_filsys fs,
|
|
blk64_t goal,
|
|
blk64_t *ret));
|
|
|
|
/* alloc_sb.c */
|
|
extern int ext2fs_reserve_super_and_bgd(ext2_filsys fs,
|
|
dgrp_t group,
|
|
ext2fs_block_bitmap bmap);
|
|
extern void ext2fs_set_block_alloc_stats_callback(ext2_filsys fs,
|
|
void (*func)(ext2_filsys fs,
|
|
blk64_t blk,
|
|
int inuse),
|
|
void (**old)(ext2_filsys fs,
|
|
blk64_t blk,
|
|
int inuse));
|
|
|
|
/* alloc_stats.c */
|
|
void ext2fs_inode_alloc_stats(ext2_filsys fs, ext2_ino_t ino, int inuse);
|
|
void ext2fs_inode_alloc_stats2(ext2_filsys fs, ext2_ino_t ino,
|
|
int inuse, int isdir);
|
|
void ext2fs_block_alloc_stats(ext2_filsys fs, blk_t blk, int inuse);
|
|
void ext2fs_block_alloc_stats2(ext2_filsys fs, blk64_t blk, int inuse);
|
|
|
|
/* alloc_tables.c */
|
|
extern errcode_t ext2fs_allocate_tables(ext2_filsys fs);
|
|
extern errcode_t ext2fs_allocate_group_table(ext2_filsys fs, dgrp_t group,
|
|
ext2fs_block_bitmap bmap);
|
|
|
|
/* badblocks.c */
|
|
extern errcode_t ext2fs_u32_list_create(ext2_u32_list *ret, int size);
|
|
extern errcode_t ext2fs_u32_list_add(ext2_u32_list bb, __u32 blk);
|
|
extern int ext2fs_u32_list_find(ext2_u32_list bb, __u32 blk);
|
|
extern int ext2fs_u32_list_test(ext2_u32_list bb, blk_t blk);
|
|
extern errcode_t ext2fs_u32_list_iterate_begin(ext2_u32_list bb,
|
|
ext2_u32_iterate *ret);
|
|
extern int ext2fs_u32_list_iterate(ext2_u32_iterate iter, blk_t *blk);
|
|
extern void ext2fs_u32_list_iterate_end(ext2_u32_iterate iter);
|
|
extern errcode_t ext2fs_u32_copy(ext2_u32_list src, ext2_u32_list *dest);
|
|
extern int ext2fs_u32_list_equal(ext2_u32_list bb1, ext2_u32_list bb2);
|
|
|
|
extern errcode_t ext2fs_badblocks_list_create(ext2_badblocks_list *ret,
|
|
int size);
|
|
extern errcode_t ext2fs_badblocks_list_add(ext2_badblocks_list bb,
|
|
blk_t blk);
|
|
extern int ext2fs_badblocks_list_test(ext2_badblocks_list bb,
|
|
blk_t blk);
|
|
extern int ext2fs_u32_list_del(ext2_u32_list bb, __u32 blk);
|
|
extern void ext2fs_badblocks_list_del(ext2_u32_list bb, __u32 blk);
|
|
extern errcode_t
|
|
ext2fs_badblocks_list_iterate_begin(ext2_badblocks_list bb,
|
|
ext2_badblocks_iterate *ret);
|
|
extern int ext2fs_badblocks_list_iterate(ext2_badblocks_iterate iter,
|
|
blk_t *blk);
|
|
extern void ext2fs_badblocks_list_iterate_end(ext2_badblocks_iterate iter);
|
|
extern errcode_t ext2fs_badblocks_copy(ext2_badblocks_list src,
|
|
ext2_badblocks_list *dest);
|
|
extern int ext2fs_badblocks_equal(ext2_badblocks_list bb1,
|
|
ext2_badblocks_list bb2);
|
|
extern int ext2fs_u32_list_count(ext2_u32_list bb);
|
|
|
|
/* bb_compat */
|
|
extern errcode_t badblocks_list_create(badblocks_list *ret, int size);
|
|
extern errcode_t badblocks_list_add(badblocks_list bb, blk_t blk);
|
|
extern int badblocks_list_test(badblocks_list bb, blk_t blk);
|
|
extern errcode_t badblocks_list_iterate_begin(badblocks_list bb,
|
|
badblocks_iterate *ret);
|
|
extern int badblocks_list_iterate(badblocks_iterate iter, blk_t *blk);
|
|
extern void badblocks_list_iterate_end(badblocks_iterate iter);
|
|
extern void badblocks_list_free(badblocks_list bb);
|
|
|
|
/* bb_inode.c */
|
|
extern errcode_t ext2fs_update_bb_inode(ext2_filsys fs,
|
|
ext2_badblocks_list bb_list);
|
|
|
|
/* bitmaps.c */
|
|
extern void ext2fs_free_block_bitmap(ext2fs_block_bitmap bitmap);
|
|
extern void ext2fs_free_inode_bitmap(ext2fs_inode_bitmap bitmap);
|
|
extern errcode_t ext2fs_copy_bitmap(ext2fs_generic_bitmap src,
|
|
ext2fs_generic_bitmap *dest);
|
|
extern errcode_t ext2fs_write_inode_bitmap(ext2_filsys fs);
|
|
extern errcode_t ext2fs_write_block_bitmap (ext2_filsys fs);
|
|
extern errcode_t ext2fs_read_inode_bitmap (ext2_filsys fs);
|
|
extern errcode_t ext2fs_read_block_bitmap(ext2_filsys fs);
|
|
extern errcode_t ext2fs_allocate_block_bitmap(ext2_filsys fs,
|
|
const char *descr,
|
|
ext2fs_block_bitmap *ret);
|
|
extern errcode_t ext2fs_allocate_inode_bitmap(ext2_filsys fs,
|
|
const char *descr,
|
|
ext2fs_inode_bitmap *ret);
|
|
extern errcode_t ext2fs_fudge_inode_bitmap_end(ext2fs_inode_bitmap bitmap,
|
|
ext2_ino_t end, ext2_ino_t *oend);
|
|
extern errcode_t ext2fs_fudge_block_bitmap_end(ext2fs_block_bitmap bitmap,
|
|
blk_t end, blk_t *oend);
|
|
extern errcode_t ext2fs_fudge_block_bitmap_end2(ext2fs_block_bitmap bitmap,
|
|
blk64_t end, blk64_t *oend);
|
|
extern void ext2fs_clear_inode_bitmap(ext2fs_inode_bitmap bitmap);
|
|
extern void ext2fs_clear_block_bitmap(ext2fs_block_bitmap bitmap);
|
|
extern errcode_t ext2fs_read_bitmaps(ext2_filsys fs);
|
|
extern errcode_t ext2fs_write_bitmaps(ext2_filsys fs);
|
|
extern errcode_t ext2fs_resize_inode_bitmap(__u32 new_end, __u32 new_real_end,
|
|
ext2fs_inode_bitmap bmap);
|
|
extern errcode_t ext2fs_resize_inode_bitmap2(__u64 new_end,
|
|
__u64 new_real_end,
|
|
ext2fs_inode_bitmap bmap);
|
|
extern errcode_t ext2fs_resize_block_bitmap(__u32 new_end, __u32 new_real_end,
|
|
ext2fs_block_bitmap bmap);
|
|
extern errcode_t ext2fs_resize_block_bitmap2(__u64 new_end,
|
|
__u64 new_real_end,
|
|
ext2fs_block_bitmap bmap);
|
|
extern errcode_t ext2fs_compare_block_bitmap(ext2fs_block_bitmap bm1,
|
|
ext2fs_block_bitmap bm2);
|
|
extern errcode_t ext2fs_compare_inode_bitmap(ext2fs_inode_bitmap bm1,
|
|
ext2fs_inode_bitmap bm2);
|
|
extern errcode_t ext2fs_set_inode_bitmap_range(ext2fs_inode_bitmap bmap,
|
|
ext2_ino_t start, unsigned int num,
|
|
void *in);
|
|
extern errcode_t ext2fs_set_inode_bitmap_range2(ext2fs_inode_bitmap bmap,
|
|
__u64 start, size_t num,
|
|
void *in);
|
|
extern errcode_t ext2fs_get_inode_bitmap_range(ext2fs_inode_bitmap bmap,
|
|
ext2_ino_t start, unsigned int num,
|
|
void *out);
|
|
extern errcode_t ext2fs_get_inode_bitmap_range2(ext2fs_inode_bitmap bmap,
|
|
__u64 start, size_t num,
|
|
void *out);
|
|
extern errcode_t ext2fs_set_block_bitmap_range(ext2fs_block_bitmap bmap,
|
|
blk_t start, unsigned int num,
|
|
void *in);
|
|
extern errcode_t ext2fs_set_block_bitmap_range2(ext2fs_block_bitmap bmap,
|
|
blk64_t start, size_t num,
|
|
void *in);
|
|
extern errcode_t ext2fs_get_block_bitmap_range(ext2fs_block_bitmap bmap,
|
|
blk_t start, unsigned int num,
|
|
void *out);
|
|
extern errcode_t ext2fs_get_block_bitmap_range2(ext2fs_block_bitmap bmap,
|
|
blk64_t start, size_t num,
|
|
void *out);
|
|
|
|
/* blknum.c */
|
|
extern dgrp_t ext2fs_group_of_blk2(ext2_filsys fs, blk64_t);
|
|
extern blk64_t ext2fs_group_first_block2(ext2_filsys fs, dgrp_t group);
|
|
extern blk64_t ext2fs_group_last_block2(ext2_filsys fs, dgrp_t group);
|
|
extern blk64_t ext2fs_inode_data_blocks2(ext2_filsys fs,
|
|
struct ext2_inode *inode);
|
|
extern blk64_t ext2fs_inode_i_blocks(ext2_filsys fs,
|
|
struct ext2_inode *inode);
|
|
extern blk64_t ext2fs_blocks_count(struct ext2_super_block *super);
|
|
extern void ext2fs_blocks_count_set(struct ext2_super_block *super,
|
|
blk64_t blk);
|
|
extern void ext2fs_blocks_count_add(struct ext2_super_block *super,
|
|
blk64_t blk);
|
|
extern blk64_t ext2fs_r_blocks_count(struct ext2_super_block *super);
|
|
extern void ext2fs_r_blocks_count_set(struct ext2_super_block *super,
|
|
blk64_t blk);
|
|
extern void ext2fs_r_blocks_count_add(struct ext2_super_block *super,
|
|
blk64_t blk);
|
|
extern blk64_t ext2fs_free_blocks_count(struct ext2_super_block *super);
|
|
extern void ext2fs_free_blocks_count_set(struct ext2_super_block *super,
|
|
blk64_t blk);
|
|
extern void ext2fs_free_blocks_count_add(struct ext2_super_block *super,
|
|
blk64_t blk);
|
|
/* Block group descriptor accessor functions */
|
|
extern struct ext2_group_desc *ext2fs_group_desc(ext2_filsys fs,
|
|
struct opaque_ext2_group_desc *gdp,
|
|
dgrp_t group);
|
|
extern blk64_t ext2fs_block_bitmap_loc(ext2_filsys fs, dgrp_t group);
|
|
extern void ext2fs_block_bitmap_loc_set(ext2_filsys fs, dgrp_t group,
|
|
blk64_t blk);
|
|
extern blk64_t ext2fs_inode_bitmap_loc(ext2_filsys fs, dgrp_t group);
|
|
extern void ext2fs_inode_bitmap_loc_set(ext2_filsys fs, dgrp_t group,
|
|
blk64_t blk);
|
|
extern blk64_t ext2fs_inode_table_loc(ext2_filsys fs, dgrp_t group);
|
|
extern void ext2fs_inode_table_loc_set(ext2_filsys fs, dgrp_t group,
|
|
blk64_t blk);
|
|
extern __u32 ext2fs_bg_free_blocks_count(ext2_filsys fs, dgrp_t group);
|
|
extern void ext2fs_bg_free_blocks_count_set(ext2_filsys fs, dgrp_t group,
|
|
__u32 n);
|
|
extern __u32 ext2fs_bg_free_inodes_count(ext2_filsys fs, dgrp_t group);
|
|
extern void ext2fs_bg_free_inodes_count_set(ext2_filsys fs, dgrp_t group,
|
|
__u32 n);
|
|
extern __u32 ext2fs_bg_used_dirs_count(ext2_filsys fs, dgrp_t group);
|
|
extern void ext2fs_bg_used_dirs_count_set(ext2_filsys fs, dgrp_t group,
|
|
__u32 n);
|
|
extern __u32 ext2fs_bg_itable_unused(ext2_filsys fs, dgrp_t group);
|
|
extern void ext2fs_bg_itable_unused_set(ext2_filsys fs, dgrp_t group,
|
|
__u32 n);
|
|
extern __u16 ext2fs_bg_flags(ext2_filsys fs, dgrp_t group);
|
|
extern void ext2fs_bg_flags_zap(ext2_filsys fs, dgrp_t group);
|
|
extern int ext2fs_bg_flags_test(ext2_filsys fs, dgrp_t group, __u16 bg_flag);
|
|
extern void ext2fs_bg_flags_set(ext2_filsys fs, dgrp_t group, __u16 bg_flags);
|
|
extern void ext2fs_bg_flags_clear(ext2_filsys fs, dgrp_t group, __u16 bg_flags);
|
|
extern __u16 ext2fs_bg_checksum(ext2_filsys fs, dgrp_t group);
|
|
extern void ext2fs_bg_checksum_set(ext2_filsys fs, dgrp_t group, __u16 checksum);
|
|
extern blk64_t ext2fs_file_acl_block(const struct ext2_inode *inode);
|
|
extern void ext2fs_file_acl_block_set(struct ext2_inode *inode, blk64_t blk);
|
|
|
|
/* block.c */
|
|
extern errcode_t ext2fs_block_iterate(ext2_filsys fs,
|
|
ext2_ino_t ino,
|
|
int flags,
|
|
char *block_buf,
|
|
int (*func)(ext2_filsys fs,
|
|
blk_t *blocknr,
|
|
int blockcnt,
|
|
void *priv_data),
|
|
void *priv_data);
|
|
errcode_t ext2fs_block_iterate2(ext2_filsys fs,
|
|
ext2_ino_t ino,
|
|
int flags,
|
|
char *block_buf,
|
|
int (*func)(ext2_filsys fs,
|
|
blk_t *blocknr,
|
|
e2_blkcnt_t blockcnt,
|
|
blk_t ref_blk,
|
|
int ref_offset,
|
|
void *priv_data),
|
|
void *priv_data);
|
|
errcode_t ext2fs_block_iterate3(ext2_filsys fs,
|
|
ext2_ino_t ino,
|
|
int flags,
|
|
char *block_buf,
|
|
int (*func)(ext2_filsys fs,
|
|
blk64_t *blocknr,
|
|
e2_blkcnt_t blockcnt,
|
|
blk64_t ref_blk,
|
|
int ref_offset,
|
|
void *priv_data),
|
|
void *priv_data);
|
|
|
|
/* bmap.c */
|
|
extern errcode_t ext2fs_bmap(ext2_filsys fs, ext2_ino_t ino,
|
|
struct ext2_inode *inode,
|
|
char *block_buf, int bmap_flags,
|
|
blk_t block, blk_t *phys_blk);
|
|
extern errcode_t ext2fs_bmap2(ext2_filsys fs, ext2_ino_t ino,
|
|
struct ext2_inode *inode,
|
|
char *block_buf, int bmap_flags, blk64_t block,
|
|
int *ret_flags, blk64_t *phys_blk);
|
|
|
|
#if 0
|
|
/* bmove.c */
|
|
extern errcode_t ext2fs_move_blocks(ext2_filsys fs,
|
|
ext2fs_block_bitmap reserve,
|
|
ext2fs_block_bitmap alloc_map,
|
|
int flags);
|
|
#endif
|
|
|
|
/* check_desc.c */
|
|
extern errcode_t ext2fs_check_desc(ext2_filsys fs);
|
|
|
|
/* closefs.c */
|
|
extern errcode_t ext2fs_close(ext2_filsys fs);
|
|
extern errcode_t ext2fs_flush(ext2_filsys fs);
|
|
extern int ext2fs_bg_has_super(ext2_filsys fs, int group_block);
|
|
extern errcode_t ext2fs_super_and_bgd_loc2(ext2_filsys fs,
|
|
dgrp_t group,
|
|
blk64_t *ret_super_blk,
|
|
blk64_t *ret_old_desc_blk,
|
|
blk64_t *ret_new_desc_blk,
|
|
blk_t *ret_used_blks);
|
|
extern int ext2fs_super_and_bgd_loc(ext2_filsys fs,
|
|
dgrp_t group,
|
|
blk_t *ret_super_blk,
|
|
blk_t *ret_old_desc_blk,
|
|
blk_t *ret_new_desc_blk,
|
|
int *ret_meta_bg);
|
|
extern void ext2fs_update_dynamic_rev(ext2_filsys fs);
|
|
|
|
/* csum.c */
|
|
extern void ext2fs_group_desc_csum_set(ext2_filsys fs, dgrp_t group);
|
|
extern int ext2fs_group_desc_csum_verify(ext2_filsys fs, dgrp_t group);
|
|
extern errcode_t ext2fs_set_gdt_csum(ext2_filsys fs);
|
|
|
|
/* dblist.c */
|
|
|
|
extern errcode_t ext2fs_get_num_dirs(ext2_filsys fs, ext2_ino_t *ret_num_dirs);
|
|
extern errcode_t ext2fs_init_dblist(ext2_filsys fs, ext2_dblist *ret_dblist);
|
|
extern errcode_t ext2fs_add_dir_block(ext2_dblist dblist, ext2_ino_t ino,
|
|
blk_t blk, int blockcnt);
|
|
extern errcode_t ext2fs_add_dir_block2(ext2_dblist dblist, ext2_ino_t ino,
|
|
blk64_t blk, e2_blkcnt_t blockcnt);
|
|
extern void ext2fs_dblist_sort(ext2_dblist dblist,
|
|
EXT2_QSORT_TYPE (*sortfunc)(const void *,
|
|
const void *));
|
|
extern void ext2fs_dblist_sort2(ext2_dblist dblist,
|
|
EXT2_QSORT_TYPE (*sortfunc)(const void *,
|
|
const void *));
|
|
extern errcode_t ext2fs_dblist_iterate(ext2_dblist dblist,
|
|
int (*func)(ext2_filsys fs, struct ext2_db_entry *db_info,
|
|
void *priv_data),
|
|
void *priv_data);
|
|
extern errcode_t ext2fs_dblist_iterate2(ext2_dblist dblist,
|
|
int (*func)(ext2_filsys fs, struct ext2_db_entry2 *db_info,
|
|
void *priv_data),
|
|
void *priv_data);
|
|
extern errcode_t ext2fs_set_dir_block(ext2_dblist dblist, ext2_ino_t ino,
|
|
blk_t blk, int blockcnt);
|
|
extern errcode_t ext2fs_set_dir_block2(ext2_dblist dblist, ext2_ino_t ino,
|
|
blk64_t blk, e2_blkcnt_t blockcnt);
|
|
extern errcode_t ext2fs_copy_dblist(ext2_dblist src,
|
|
ext2_dblist *dest);
|
|
extern int ext2fs_dblist_count(ext2_dblist dblist);
|
|
extern blk64_t ext2fs_dblist_count2(ext2_dblist dblist);
|
|
extern errcode_t ext2fs_dblist_get_last(ext2_dblist dblist,
|
|
struct ext2_db_entry **entry);
|
|
extern errcode_t ext2fs_dblist_get_last2(ext2_dblist dblist,
|
|
struct ext2_db_entry2 **entry);
|
|
extern errcode_t ext2fs_dblist_drop_last(ext2_dblist dblist);
|
|
|
|
/* dblist_dir.c */
|
|
extern errcode_t
|
|
ext2fs_dblist_dir_iterate(ext2_dblist dblist,
|
|
int flags,
|
|
char *block_buf,
|
|
int (*func)(ext2_ino_t dir,
|
|
int entry,
|
|
struct ext2_dir_entry *dirent,
|
|
int offset,
|
|
int blocksize,
|
|
char *buf,
|
|
void *priv_data),
|
|
void *priv_data);
|
|
|
|
/* dirblock.c */
|
|
extern errcode_t ext2fs_read_dir_block(ext2_filsys fs, blk_t block,
|
|
void *buf);
|
|
extern errcode_t ext2fs_read_dir_block2(ext2_filsys fs, blk_t block,
|
|
void *buf, int flags);
|
|
extern errcode_t ext2fs_read_dir_block3(ext2_filsys fs, blk64_t block,
|
|
void *buf, int flags);
|
|
extern errcode_t ext2fs_write_dir_block(ext2_filsys fs, blk_t block,
|
|
void *buf);
|
|
extern errcode_t ext2fs_write_dir_block2(ext2_filsys fs, blk_t block,
|
|
void *buf, int flags);
|
|
extern errcode_t ext2fs_write_dir_block3(ext2_filsys fs, blk64_t block,
|
|
void *buf, int flags);
|
|
|
|
/* dirhash.c */
|
|
extern errcode_t ext2fs_dirhash(int version, const char *name, int len,
|
|
const __u32 *seed,
|
|
ext2_dirhash_t *ret_hash,
|
|
ext2_dirhash_t *ret_minor_hash);
|
|
|
|
|
|
/* dir_iterate.c */
|
|
extern errcode_t ext2fs_get_rec_len(ext2_filsys fs,
|
|
struct ext2_dir_entry *dirent,
|
|
unsigned int *rec_len);
|
|
extern errcode_t ext2fs_set_rec_len(ext2_filsys fs,
|
|
unsigned int len,
|
|
struct ext2_dir_entry *dirent);
|
|
extern errcode_t ext2fs_dir_iterate(ext2_filsys fs,
|
|
ext2_ino_t dir,
|
|
int flags,
|
|
char *block_buf,
|
|
int (*func)(struct ext2_dir_entry *dirent,
|
|
int offset,
|
|
int blocksize,
|
|
char *buf,
|
|
void *priv_data),
|
|
void *priv_data);
|
|
extern errcode_t ext2fs_dir_iterate2(ext2_filsys fs,
|
|
ext2_ino_t dir,
|
|
int flags,
|
|
char *block_buf,
|
|
int (*func)(ext2_ino_t dir,
|
|
int entry,
|
|
struct ext2_dir_entry *dirent,
|
|
int offset,
|
|
int blocksize,
|
|
char *buf,
|
|
void *priv_data),
|
|
void *priv_data);
|
|
|
|
/* dupfs.c */
|
|
extern errcode_t ext2fs_dup_handle(ext2_filsys src, ext2_filsys *dest);
|
|
|
|
/* expanddir.c */
|
|
extern errcode_t ext2fs_expand_dir(ext2_filsys fs, ext2_ino_t dir);
|
|
|
|
/* ext_attr.c */
|
|
extern __u32 ext2fs_ext_attr_hash_entry(struct ext2_ext_attr_entry *entry,
|
|
void *data);
|
|
extern errcode_t ext2fs_read_ext_attr(ext2_filsys fs, blk_t block, void *buf);
|
|
extern errcode_t ext2fs_read_ext_attr2(ext2_filsys fs, blk64_t block,
|
|
void *buf);
|
|
extern errcode_t ext2fs_write_ext_attr(ext2_filsys fs, blk_t block,
|
|
void *buf);
|
|
extern errcode_t ext2fs_write_ext_attr2(ext2_filsys fs, blk64_t block,
|
|
void *buf);
|
|
extern errcode_t ext2fs_adjust_ea_refcount(ext2_filsys fs, blk_t blk,
|
|
char *block_buf,
|
|
int adjust, __u32 *newcount);
|
|
extern errcode_t ext2fs_adjust_ea_refcount2(ext2_filsys fs, blk64_t blk,
|
|
char *block_buf,
|
|
int adjust, __u32 *newcount);
|
|
|
|
/* extent.c */
|
|
extern errcode_t ext2fs_extent_header_verify(void *ptr, int size);
|
|
extern errcode_t ext2fs_extent_open(ext2_filsys fs, ext2_ino_t ino,
|
|
ext2_extent_handle_t *handle);
|
|
extern errcode_t ext2fs_extent_open2(ext2_filsys fs, ext2_ino_t ino,
|
|
struct ext2_inode *inode,
|
|
ext2_extent_handle_t *ret_handle);
|
|
extern void ext2fs_extent_free(ext2_extent_handle_t handle);
|
|
extern errcode_t ext2fs_extent_get(ext2_extent_handle_t handle,
|
|
int flags, struct ext2fs_extent *extent);
|
|
extern errcode_t ext2fs_extent_replace(ext2_extent_handle_t handle, int flags,
|
|
struct ext2fs_extent *extent);
|
|
extern errcode_t ext2fs_extent_insert(ext2_extent_handle_t handle, int flags,
|
|
struct ext2fs_extent *extent);
|
|
extern errcode_t ext2fs_extent_set_bmap(ext2_extent_handle_t handle,
|
|
blk64_t logical, blk64_t physical,
|
|
int flags);
|
|
extern errcode_t ext2fs_extent_delete(ext2_extent_handle_t handle, int flags);
|
|
extern errcode_t ext2fs_extent_get_info(ext2_extent_handle_t handle,
|
|
struct ext2_extent_info *info);
|
|
extern errcode_t ext2fs_extent_goto(ext2_extent_handle_t handle,
|
|
blk64_t blk);
|
|
|
|
/* fileio.c */
|
|
extern errcode_t ext2fs_file_open2(ext2_filsys fs, ext2_ino_t ino,
|
|
struct ext2_inode *inode,
|
|
int flags, ext2_file_t *ret);
|
|
extern errcode_t ext2fs_file_open(ext2_filsys fs, ext2_ino_t ino,
|
|
int flags, ext2_file_t *ret);
|
|
extern ext2_filsys ext2fs_file_get_fs(ext2_file_t file);
|
|
struct ext2_inode *ext2fs_file_get_inode(ext2_file_t file);
|
|
extern errcode_t ext2fs_file_close(ext2_file_t file);
|
|
extern errcode_t ext2fs_file_flush(ext2_file_t file);
|
|
extern errcode_t ext2fs_file_read(ext2_file_t file, void *buf,
|
|
unsigned int wanted, unsigned int *got);
|
|
extern errcode_t ext2fs_file_write(ext2_file_t file, const void *buf,
|
|
unsigned int nbytes, unsigned int *written);
|
|
extern errcode_t ext2fs_file_llseek(ext2_file_t file, __u64 offset,
|
|
int whence, __u64 *ret_pos);
|
|
extern errcode_t ext2fs_file_lseek(ext2_file_t file, ext2_off_t offset,
|
|
int whence, ext2_off_t *ret_pos);
|
|
errcode_t ext2fs_file_get_lsize(ext2_file_t file, __u64 *ret_size);
|
|
extern ext2_off_t ext2fs_file_get_size(ext2_file_t file);
|
|
extern errcode_t ext2fs_file_set_size(ext2_file_t file, ext2_off_t size);
|
|
extern errcode_t ext2fs_file_set_size2(ext2_file_t file, ext2_off64_t size);
|
|
|
|
/* finddev.c */
|
|
extern char *ext2fs_find_block_device(dev_t device);
|
|
|
|
/* flushb.c */
|
|
extern errcode_t ext2fs_sync_device(int fd, int flushb);
|
|
|
|
/* freefs.c */
|
|
extern void ext2fs_free(ext2_filsys fs);
|
|
extern void ext2fs_free_dblist(ext2_dblist dblist);
|
|
extern void ext2fs_badblocks_list_free(ext2_badblocks_list bb);
|
|
extern void ext2fs_u32_list_free(ext2_u32_list bb);
|
|
|
|
/* gen_bitmap.c */
|
|
extern void ext2fs_free_generic_bitmap(ext2fs_inode_bitmap bitmap);
|
|
extern errcode_t ext2fs_make_generic_bitmap(errcode_t magic, ext2_filsys fs,
|
|
__u32 start, __u32 end,
|
|
__u32 real_end,
|
|
const char *descr, char *init_map,
|
|
ext2fs_generic_bitmap *ret);
|
|
extern errcode_t ext2fs_allocate_generic_bitmap(__u32 start,
|
|
__u32 end,
|
|
__u32 real_end,
|
|
const char *descr,
|
|
ext2fs_generic_bitmap *ret);
|
|
extern errcode_t ext2fs_copy_generic_bitmap(ext2fs_generic_bitmap src,
|
|
ext2fs_generic_bitmap *dest);
|
|
extern void ext2fs_clear_generic_bitmap(ext2fs_generic_bitmap bitmap);
|
|
extern errcode_t ext2fs_fudge_generic_bitmap_end(ext2fs_inode_bitmap bitmap,
|
|
errcode_t magic,
|
|
errcode_t neq,
|
|
ext2_ino_t end,
|
|
ext2_ino_t *oend);
|
|
extern void ext2fs_set_generic_bitmap_padding(ext2fs_generic_bitmap map);
|
|
extern errcode_t ext2fs_resize_generic_bitmap(errcode_t magic,
|
|
__u32 new_end,
|
|
__u32 new_real_end,
|
|
ext2fs_generic_bitmap bmap);
|
|
extern errcode_t ext2fs_compare_generic_bitmap(errcode_t magic, errcode_t neq,
|
|
ext2fs_generic_bitmap bm1,
|
|
ext2fs_generic_bitmap bm2);
|
|
extern errcode_t ext2fs_get_generic_bitmap_range(ext2fs_generic_bitmap bmap,
|
|
errcode_t magic,
|
|
__u32 start, __u32 num,
|
|
void *out);
|
|
extern errcode_t ext2fs_set_generic_bitmap_range(ext2fs_generic_bitmap bmap,
|
|
errcode_t magic,
|
|
__u32 start, __u32 num,
|
|
void *in);
|
|
|
|
/* gen_bitmap64.c */
|
|
void ext2fs_free_generic_bmap(ext2fs_generic_bitmap bmap);
|
|
errcode_t ext2fs_alloc_generic_bmap(ext2_filsys fs, errcode_t magic,
|
|
int type, __u64 start, __u64 end,
|
|
__u64 real_end,
|
|
const char *descr,
|
|
ext2fs_generic_bitmap *ret);
|
|
errcode_t ext2fs_copy_generic_bmap(ext2fs_generic_bitmap src,
|
|
ext2fs_generic_bitmap *dest);
|
|
void ext2fs_clear_generic_bmap(ext2fs_generic_bitmap bitmap);
|
|
errcode_t ext2fs_fudge_generic_bmap_end(ext2fs_generic_bitmap bitmap,
|
|
errcode_t neq,
|
|
__u64 end, __u64 *oend);
|
|
void ext2fs_set_generic_bmap_padding(ext2fs_generic_bitmap bmap);
|
|
errcode_t ext2fs_resize_generic_bmap(ext2fs_generic_bitmap bmap,
|
|
__u64 new_end,
|
|
__u64 new_real_end);
|
|
errcode_t ext2fs_compare_generic_bmap(errcode_t neq,
|
|
ext2fs_generic_bitmap bm1,
|
|
ext2fs_generic_bitmap bm2);
|
|
errcode_t ext2fs_get_generic_bmap_range(ext2fs_generic_bitmap bmap,
|
|
__u64 start, unsigned int num,
|
|
void *out);
|
|
errcode_t ext2fs_set_generic_bmap_range(ext2fs_generic_bitmap bmap,
|
|
__u64 start, unsigned int num,
|
|
void *in);
|
|
|
|
/* getsize.c */
|
|
extern errcode_t ext2fs_get_device_size(const char *file, int blocksize,
|
|
blk_t *retblocks);
|
|
extern errcode_t ext2fs_get_device_size2(const char *file, int blocksize,
|
|
blk64_t *retblocks);
|
|
|
|
/* getsectsize.c */
|
|
errcode_t ext2fs_get_device_sectsize(const char *file, int *sectsize);
|
|
errcode_t ext2fs_get_device_phys_sectsize(const char *file, int *sectsize);
|
|
|
|
/* i_block.c */
|
|
errcode_t ext2fs_iblk_add_blocks(ext2_filsys fs, struct ext2_inode *inode,
|
|
blk64_t num_blocks);
|
|
errcode_t ext2fs_iblk_sub_blocks(ext2_filsys fs, struct ext2_inode *inode,
|
|
blk64_t num_blocks);
|
|
errcode_t ext2fs_iblk_set(ext2_filsys fs, struct ext2_inode *inode, blk64_t b);
|
|
|
|
/* imager.c */
|
|
extern errcode_t ext2fs_image_inode_write(ext2_filsys fs, int fd, int flags);
|
|
extern errcode_t ext2fs_image_inode_read(ext2_filsys fs, int fd, int flags);
|
|
extern errcode_t ext2fs_image_super_write(ext2_filsys fs, int fd, int flags);
|
|
extern errcode_t ext2fs_image_super_read(ext2_filsys fs, int fd, int flags);
|
|
extern errcode_t ext2fs_image_bitmap_write(ext2_filsys fs, int fd, int flags);
|
|
extern errcode_t ext2fs_image_bitmap_read(ext2_filsys fs, int fd, int flags);
|
|
|
|
/* ind_block.c */
|
|
errcode_t ext2fs_read_ind_block(ext2_filsys fs, blk_t blk, void *buf);
|
|
errcode_t ext2fs_write_ind_block(ext2_filsys fs, blk_t blk, void *buf);
|
|
|
|
/* initialize.c */
|
|
extern errcode_t ext2fs_initialize(const char *name, int flags,
|
|
struct ext2_super_block *param,
|
|
io_manager manager, ext2_filsys *ret_fs);
|
|
|
|
/* icount.c */
|
|
extern void ext2fs_free_icount(ext2_icount_t icount);
|
|
extern errcode_t ext2fs_create_icount_tdb(ext2_filsys fs, char *tdb_dir,
|
|
int flags, ext2_icount_t *ret);
|
|
extern errcode_t ext2fs_create_icount2(ext2_filsys fs, int flags,
|
|
unsigned int size,
|
|
ext2_icount_t hint, ext2_icount_t *ret);
|
|
extern errcode_t ext2fs_create_icount(ext2_filsys fs, int flags,
|
|
unsigned int size,
|
|
ext2_icount_t *ret);
|
|
extern errcode_t ext2fs_icount_fetch(ext2_icount_t icount, ext2_ino_t ino,
|
|
__u16 *ret);
|
|
extern errcode_t ext2fs_icount_increment(ext2_icount_t icount, ext2_ino_t ino,
|
|
__u16 *ret);
|
|
extern errcode_t ext2fs_icount_decrement(ext2_icount_t icount, ext2_ino_t ino,
|
|
__u16 *ret);
|
|
extern errcode_t ext2fs_icount_store(ext2_icount_t icount, ext2_ino_t ino,
|
|
__u16 count);
|
|
extern ext2_ino_t ext2fs_get_icount_size(ext2_icount_t icount);
|
|
errcode_t ext2fs_icount_validate(ext2_icount_t icount, FILE *);
|
|
|
|
/* inode.c */
|
|
extern errcode_t ext2fs_flush_icache(ext2_filsys fs);
|
|
extern errcode_t ext2fs_get_next_inode_full(ext2_inode_scan scan,
|
|
ext2_ino_t *ino,
|
|
struct ext2_inode *inode,
|
|
int bufsize);
|
|
extern errcode_t ext2fs_open_inode_scan(ext2_filsys fs, int buffer_blocks,
|
|
ext2_inode_scan *ret_scan);
|
|
extern void ext2fs_close_inode_scan(ext2_inode_scan scan);
|
|
extern errcode_t ext2fs_get_next_inode(ext2_inode_scan scan, ext2_ino_t *ino,
|
|
struct ext2_inode *inode);
|
|
extern errcode_t ext2fs_inode_scan_goto_blockgroup(ext2_inode_scan scan,
|
|
int group);
|
|
extern void ext2fs_set_inode_callback
|
|
(ext2_inode_scan scan,
|
|
errcode_t (*done_group)(ext2_filsys fs,
|
|
ext2_inode_scan scan,
|
|
dgrp_t group,
|
|
void * priv_data),
|
|
void *done_group_data);
|
|
extern int ext2fs_inode_scan_flags(ext2_inode_scan scan, int set_flags,
|
|
int clear_flags);
|
|
extern errcode_t ext2fs_read_inode_full(ext2_filsys fs, ext2_ino_t ino,
|
|
struct ext2_inode * inode,
|
|
int bufsize);
|
|
extern errcode_t ext2fs_read_inode (ext2_filsys fs, ext2_ino_t ino,
|
|
struct ext2_inode * inode);
|
|
extern errcode_t ext2fs_write_inode_full(ext2_filsys fs, ext2_ino_t ino,
|
|
struct ext2_inode * inode,
|
|
int bufsize);
|
|
extern errcode_t ext2fs_write_inode(ext2_filsys fs, ext2_ino_t ino,
|
|
struct ext2_inode * inode);
|
|
extern errcode_t ext2fs_write_new_inode(ext2_filsys fs, ext2_ino_t ino,
|
|
struct ext2_inode * inode);
|
|
extern errcode_t ext2fs_get_blocks(ext2_filsys fs, ext2_ino_t ino, blk_t *blocks);
|
|
extern errcode_t ext2fs_check_directory(ext2_filsys fs, ext2_ino_t ino);
|
|
|
|
/* inode_io.c */
|
|
extern io_manager inode_io_manager;
|
|
extern errcode_t ext2fs_inode_io_intern(ext2_filsys fs, ext2_ino_t ino,
|
|
char **name);
|
|
extern errcode_t ext2fs_inode_io_intern2(ext2_filsys fs, ext2_ino_t ino,
|
|
struct ext2_inode *inode,
|
|
char **name);
|
|
|
|
/* ismounted.c */
|
|
extern errcode_t ext2fs_check_if_mounted(const char *file, int *mount_flags);
|
|
extern errcode_t ext2fs_check_mount_point(const char *device, int *mount_flags,
|
|
char *mtpt, int mtlen);
|
|
|
|
/* punch.c */
|
|
extern errcode_t ext2fs_punch(ext2_filsys fs, ext2_ino_t ino,
|
|
struct ext2_inode *inode,
|
|
char *block_buf, blk64_t start,
|
|
blk64_t end);
|
|
|
|
/* namei.c */
|
|
extern errcode_t ext2fs_lookup(ext2_filsys fs, ext2_ino_t dir, const char *name,
|
|
int namelen, char *buf, ext2_ino_t *inode);
|
|
extern errcode_t ext2fs_namei(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd,
|
|
const char *name, ext2_ino_t *inode);
|
|
errcode_t ext2fs_namei_follow(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd,
|
|
const char *name, ext2_ino_t *inode);
|
|
extern errcode_t ext2fs_follow_link(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd,
|
|
ext2_ino_t inode, ext2_ino_t *res_inode);
|
|
|
|
/* native.c */
|
|
int ext2fs_native_flag(void);
|
|
|
|
/* newdir.c */
|
|
extern errcode_t ext2fs_new_dir_block(ext2_filsys fs, ext2_ino_t dir_ino,
|
|
ext2_ino_t parent_ino, char **block);
|
|
|
|
/* mkdir.c */
|
|
extern errcode_t ext2fs_mkdir(ext2_filsys fs, ext2_ino_t parent, ext2_ino_t inum,
|
|
const char *name);
|
|
|
|
/* mkjournal.c */
|
|
extern errcode_t ext2fs_zero_blocks(ext2_filsys fs, blk_t blk, int num,
|
|
blk_t *ret_blk, int *ret_count);
|
|
extern errcode_t ext2fs_zero_blocks2(ext2_filsys fs, blk64_t blk, int num,
|
|
blk64_t *ret_blk, int *ret_count);
|
|
extern errcode_t ext2fs_create_journal_superblock(ext2_filsys fs,
|
|
__u32 size, int flags,
|
|
char **ret_jsb);
|
|
extern errcode_t ext2fs_add_journal_device(ext2_filsys fs,
|
|
ext2_filsys journal_dev);
|
|
extern errcode_t ext2fs_add_journal_inode(ext2_filsys fs, blk_t size,
|
|
int flags);
|
|
extern int ext2fs_default_journal_size(__u64 blocks);
|
|
|
|
/* openfs.c */
|
|
extern errcode_t ext2fs_open(const char *name, int flags, int superblock,
|
|
unsigned int block_size, io_channel * chan,
|
|
ext2_filsys *ret_fs);
|
|
extern errcode_t ext2fs_open2(const char *name, const char *io_options,
|
|
int flags, int superblock,
|
|
unsigned int block_size, io_channel * chan,
|
|
ext2_filsys *ret_fs);
|
|
extern blk64_t ext2fs_descriptor_block_loc2(ext2_filsys fs,
|
|
blk64_t group_block, dgrp_t i);
|
|
extern blk_t ext2fs_descriptor_block_loc(ext2_filsys fs, blk_t group_block,
|
|
dgrp_t i);
|
|
errcode_t ext2fs_get_data_io(ext2_filsys fs, io_channel *old_io);
|
|
errcode_t ext2fs_set_data_io(ext2_filsys fs, io_channel new_io);
|
|
errcode_t ext2fs_rewrite_to_io(ext2_filsys fs, io_channel new_io);
|
|
|
|
/* get_pathname.c */
|
|
extern errcode_t ext2fs_get_pathname(ext2_filsys fs, ext2_ino_t dir, ext2_ino_t ino,
|
|
char **name);
|
|
|
|
/* link.c */
|
|
errcode_t ext2fs_link(ext2_filsys fs, ext2_ino_t dir, const char *name,
|
|
ext2_ino_t ino, int flags);
|
|
errcode_t ext2fs_unlink(ext2_filsys fs, ext2_ino_t dir, const char *name,
|
|
ext2_ino_t ino, int flags);
|
|
|
|
/* read_bb.c */
|
|
extern errcode_t ext2fs_read_bb_inode(ext2_filsys fs,
|
|
ext2_badblocks_list *bb_list);
|
|
|
|
/* read_bb_file.c */
|
|
extern errcode_t ext2fs_read_bb_FILE2(ext2_filsys fs, FILE *f,
|
|
ext2_badblocks_list *bb_list,
|
|
void *priv_data,
|
|
void (*invalid)(ext2_filsys fs,
|
|
blk_t blk,
|
|
char *badstr,
|
|
void *priv_data));
|
|
extern errcode_t ext2fs_read_bb_FILE(ext2_filsys fs, FILE *f,
|
|
ext2_badblocks_list *bb_list,
|
|
void (*invalid)(ext2_filsys fs,
|
|
blk_t blk));
|
|
|
|
/* res_gdt.c */
|
|
extern errcode_t ext2fs_create_resize_inode(ext2_filsys fs);
|
|
|
|
/* swapfs.c */
|
|
extern void ext2fs_swap_ext_attr(char *to, char *from, int bufsize,
|
|
int has_header);
|
|
extern void ext2fs_swap_ext_attr_header(struct ext2_ext_attr_header *to_header,
|
|
struct ext2_ext_attr_header *from_hdr);
|
|
extern void ext2fs_swap_ext_attr_entry(struct ext2_ext_attr_entry *to_entry,
|
|
struct ext2_ext_attr_entry *from_entry);
|
|
extern void ext2fs_swap_super(struct ext2_super_block * super);
|
|
extern void ext2fs_swap_group_desc(struct ext2_group_desc *gdp);
|
|
extern void ext2fs_swap_group_desc2(ext2_filsys, struct ext2_group_desc *gdp);
|
|
extern void ext2fs_swap_inode_full(ext2_filsys fs, struct ext2_inode_large *t,
|
|
struct ext2_inode_large *f, int hostorder,
|
|
int bufsize);
|
|
extern void ext2fs_swap_inode(ext2_filsys fs,struct ext2_inode *t,
|
|
struct ext2_inode *f, int hostorder);
|
|
|
|
/* valid_blk.c */
|
|
extern int ext2fs_inode_has_valid_blocks(struct ext2_inode *inode);
|
|
|
|
/* version.c */
|
|
extern int ext2fs_parse_version_string(const char *ver_string);
|
|
extern int ext2fs_get_library_version(const char **ver_string,
|
|
const char **date_string);
|
|
|
|
/* write_bb_file.c */
|
|
extern errcode_t ext2fs_write_bb_FILE(ext2_badblocks_list bb_list,
|
|
unsigned int flags,
|
|
FILE *f);
|
|
|
|
|
|
/* inline functions */
|
|
extern errcode_t ext2fs_get_mem(unsigned long size, void *ptr);
|
|
extern errcode_t ext2fs_get_memalign(unsigned long size,
|
|
unsigned long align, void *ptr);
|
|
extern errcode_t ext2fs_free_mem(void *ptr);
|
|
extern errcode_t ext2fs_resize_mem(unsigned long old_size,
|
|
unsigned long size, void *ptr);
|
|
extern void ext2fs_mark_super_dirty(ext2_filsys fs);
|
|
extern void ext2fs_mark_changed(ext2_filsys fs);
|
|
extern int ext2fs_test_changed(ext2_filsys fs);
|
|
extern void ext2fs_mark_valid(ext2_filsys fs);
|
|
extern void ext2fs_unmark_valid(ext2_filsys fs);
|
|
extern int ext2fs_test_valid(ext2_filsys fs);
|
|
extern void ext2fs_mark_ib_dirty(ext2_filsys fs);
|
|
extern void ext2fs_mark_bb_dirty(ext2_filsys fs);
|
|
extern int ext2fs_test_ib_dirty(ext2_filsys fs);
|
|
extern int ext2fs_test_bb_dirty(ext2_filsys fs);
|
|
extern int ext2fs_group_of_blk(ext2_filsys fs, blk_t blk);
|
|
extern int ext2fs_group_of_ino(ext2_filsys fs, ext2_ino_t ino);
|
|
extern blk_t ext2fs_group_first_block(ext2_filsys fs, dgrp_t group);
|
|
extern blk_t ext2fs_group_last_block(ext2_filsys fs, dgrp_t group);
|
|
extern blk_t ext2fs_inode_data_blocks(ext2_filsys fs,
|
|
struct ext2_inode *inode);
|
|
extern unsigned int ext2fs_div_ceil(unsigned int a, unsigned int b);
|
|
extern __u64 ext2fs_div64_ceil(__u64 a, __u64 b);
|
|
|
|
/*
|
|
* The actual inlined functions definitions themselves...
|
|
*
|
|
* If NO_INLINE_FUNCS is defined, then we won't try to do inline
|
|
* functions at all!
|
|
*/
|
|
#if (defined(INCLUDE_INLINE_FUNCS) || !defined(NO_INLINE_FUNCS))
|
|
#ifdef INCLUDE_INLINE_FUNCS
|
|
#define _INLINE_ extern
|
|
#else
|
|
#ifdef __GNUC__
|
|
#define _INLINE_ extern __inline__
|
|
#else /* For Watcom C */
|
|
#define _INLINE_ extern inline
|
|
#endif
|
|
#endif
|
|
|
|
#ifndef EXT2_CUSTOM_MEMORY_ROUTINES
|
|
#include <string.h>
|
|
#include "mem_allocate.h"
|
|
/*
|
|
* Allocate memory
|
|
*/
|
|
_INLINE_ errcode_t ext2fs_get_mem(unsigned long size, void *ptr)
|
|
{
|
|
void *pp;
|
|
|
|
pp = mem_alloc(size);
|
|
if (!pp)
|
|
return EXT2_ET_NO_MEMORY;
|
|
memcpy(ptr, &pp, sizeof (pp));
|
|
return 0;
|
|
}
|
|
|
|
_INLINE_ errcode_t ext2fs_get_memalign(unsigned long size,
|
|
unsigned long align, void *ptr)
|
|
{
|
|
void *pp;
|
|
|
|
#ifdef HWRVL
|
|
pp = mem_align(32, size);
|
|
#else
|
|
pp = mem_alloc(size);
|
|
#endif
|
|
if (!pp)
|
|
return EXT2_ET_NO_MEMORY;
|
|
|
|
memcpy(ptr, &pp, sizeof (pp));
|
|
return 0;
|
|
}
|
|
|
|
_INLINE_ errcode_t ext2fs_get_array(unsigned long count, unsigned long size, void *ptr)
|
|
{
|
|
if (count && (-1UL)/count<size)
|
|
return EXT2_ET_NO_MEMORY; //maybe define EXT2_ET_OVERFLOW ?
|
|
return ext2fs_get_mem(count*size, ptr);
|
|
}
|
|
|
|
/*
|
|
* Free memory
|
|
*/
|
|
_INLINE_ errcode_t ext2fs_free_mem(void *ptr)
|
|
{
|
|
void *p;
|
|
|
|
memcpy(&p, ptr, sizeof(p));
|
|
mem_free(p);
|
|
p = 0;
|
|
memcpy(ptr, &p, sizeof(p));
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Resize memory
|
|
*/
|
|
_INLINE_ errcode_t ext2fs_resize_mem(unsigned long EXT2FS_ATTR((unused)) old_size,
|
|
unsigned long size, void *ptr)
|
|
{
|
|
void *p;
|
|
|
|
/* Use "memcpy" for pointer assignments here to avoid problems
|
|
* with C99 strict type aliasing rules. */
|
|
memcpy(&p, ptr, sizeof(p));
|
|
p = mem_realloc(p, size);
|
|
if (!p)
|
|
return EXT2_ET_NO_MEMORY;
|
|
memcpy(ptr, &p, sizeof(p));
|
|
return 0;
|
|
}
|
|
#endif /* Custom memory routines */
|
|
|
|
/*
|
|
* Mark a filesystem superblock as dirty
|
|
*/
|
|
_INLINE_ void ext2fs_mark_super_dirty(ext2_filsys fs)
|
|
{
|
|
fs->flags |= EXT2_FLAG_DIRTY | EXT2_FLAG_CHANGED;
|
|
}
|
|
|
|
/*
|
|
* Mark a filesystem as changed
|
|
*/
|
|
_INLINE_ void ext2fs_mark_changed(ext2_filsys fs)
|
|
{
|
|
fs->flags |= EXT2_FLAG_CHANGED;
|
|
}
|
|
|
|
/*
|
|
* Check to see if a filesystem has changed
|
|
*/
|
|
_INLINE_ int ext2fs_test_changed(ext2_filsys fs)
|
|
{
|
|
return (fs->flags & EXT2_FLAG_CHANGED);
|
|
}
|
|
|
|
/*
|
|
* Mark a filesystem as valid
|
|
*/
|
|
_INLINE_ void ext2fs_mark_valid(ext2_filsys fs)
|
|
{
|
|
fs->flags |= EXT2_FLAG_VALID;
|
|
}
|
|
|
|
/*
|
|
* Mark a filesystem as NOT valid
|
|
*/
|
|
_INLINE_ void ext2fs_unmark_valid(ext2_filsys fs)
|
|
{
|
|
fs->flags &= ~EXT2_FLAG_VALID;
|
|
}
|
|
|
|
/*
|
|
* Check to see if a filesystem is valid
|
|
*/
|
|
_INLINE_ int ext2fs_test_valid(ext2_filsys fs)
|
|
{
|
|
return (fs->flags & EXT2_FLAG_VALID);
|
|
}
|
|
|
|
/*
|
|
* Mark the inode bitmap as dirty
|
|
*/
|
|
_INLINE_ void ext2fs_mark_ib_dirty(ext2_filsys fs)
|
|
{
|
|
fs->flags |= EXT2_FLAG_IB_DIRTY | EXT2_FLAG_CHANGED;
|
|
}
|
|
|
|
/*
|
|
* Mark the block bitmap as dirty
|
|
*/
|
|
_INLINE_ void ext2fs_mark_bb_dirty(ext2_filsys fs)
|
|
{
|
|
fs->flags |= EXT2_FLAG_BB_DIRTY | EXT2_FLAG_CHANGED;
|
|
}
|
|
|
|
/*
|
|
* Check to see if a filesystem's inode bitmap is dirty
|
|
*/
|
|
_INLINE_ int ext2fs_test_ib_dirty(ext2_filsys fs)
|
|
{
|
|
return (fs->flags & EXT2_FLAG_IB_DIRTY);
|
|
}
|
|
|
|
/*
|
|
* Check to see if a filesystem's block bitmap is dirty
|
|
*/
|
|
_INLINE_ int ext2fs_test_bb_dirty(ext2_filsys fs)
|
|
{
|
|
return (fs->flags & EXT2_FLAG_BB_DIRTY);
|
|
}
|
|
|
|
/*
|
|
* Return the group # of a block
|
|
*/
|
|
_INLINE_ int ext2fs_group_of_blk(ext2_filsys fs, blk_t blk)
|
|
{
|
|
return ext2fs_group_of_blk2(fs, blk);
|
|
}
|
|
/*
|
|
* Return the group # of an inode number
|
|
*/
|
|
_INLINE_ int ext2fs_group_of_ino(ext2_filsys fs, ext2_ino_t ino)
|
|
{
|
|
return (ino - 1) / fs->super->s_inodes_per_group;
|
|
}
|
|
|
|
/*
|
|
* Return the first block (inclusive) in a group
|
|
*/
|
|
_INLINE_ blk_t ext2fs_group_first_block(ext2_filsys fs, dgrp_t group)
|
|
{
|
|
return ext2fs_group_first_block2(fs, group);
|
|
}
|
|
|
|
/*
|
|
* Return the last block (inclusive) in a group
|
|
*/
|
|
_INLINE_ blk_t ext2fs_group_last_block(ext2_filsys fs, dgrp_t group)
|
|
{
|
|
return ext2fs_group_last_block2(fs, group);
|
|
}
|
|
|
|
_INLINE_ blk_t ext2fs_inode_data_blocks(ext2_filsys fs,
|
|
struct ext2_inode *inode)
|
|
{
|
|
return ext2fs_inode_data_blocks2(fs, inode);
|
|
}
|
|
|
|
/*
|
|
* This is an efficient, overflow safe way of calculating ceil((1.0 * a) / b)
|
|
*/
|
|
_INLINE_ unsigned int ext2fs_div_ceil(unsigned int a, unsigned int b)
|
|
{
|
|
if (!a)
|
|
return 0;
|
|
return ((a - 1) / b) + 1;
|
|
}
|
|
|
|
_INLINE_ __u64 ext2fs_div64_ceil(__u64 a, __u64 b)
|
|
{
|
|
if (!a)
|
|
return 0;
|
|
return ((a - 1) / b) + 1;
|
|
}
|
|
|
|
#undef _INLINE_
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* _EXT2FS_EXT2FS_H */
|