mirror of
https://git.kernel.org/pub/scm/fs/ext2/e2fsprogs.git
synced 2024-12-20 07:20:48 +08:00
bc210074ea
Performed a "make depend" for the upcoming release Many files: Checkins for the 1.10 release.
1075 lines
42 KiB
Plaintext
1075 lines
42 KiB
Plaintext
\input texinfo @c -*-texinfo-*-
|
||
@c %**start of header
|
||
@setfilename libext2fs.info
|
||
@settitle The EXT2FS Library (version 1.11)
|
||
@synindex tp fn
|
||
@comment %**end of header
|
||
|
||
@ifinfo
|
||
@format
|
||
START-INFO-DIR-ENTRY
|
||
* libext2fs: (libext2fs.info). The EXT2FS library.
|
||
END-INFO-DIR-ENTRY
|
||
@end format
|
||
@end ifinfo
|
||
|
||
@c smallbook
|
||
|
||
@iftex
|
||
@finalout
|
||
@end iftex
|
||
|
||
@c Note: the edition number is listed in *three* places; please update
|
||
@c all three. Also, update the month and year where appropriate.
|
||
|
||
@c ==> Update edition number for settitle and subtitle, and in the
|
||
@c ==> following paragraph; update date, too.
|
||
|
||
|
||
@ifinfo
|
||
This file documents the ext2fs library, a library for manipulating the
|
||
ext2 filesystem.
|
||
|
||
Copyright (C) 1997 Theodore Ts'o
|
||
|
||
Permission is granted to make and distribute verbatim copies of
|
||
this manual provided the copyright notice and this permission notice
|
||
are preserved on all copies.
|
||
|
||
@ignore
|
||
Permission is granted to process this file through TeX and print the
|
||
results, provided the printed document carries copying permission
|
||
notice identical to this one except for the removal of this paragraph
|
||
(this paragraph not being relevant to the printed manual).
|
||
|
||
@end ignore
|
||
Permission is granted to copy and distribute modified versions of this
|
||
manual under the conditions for verbatim copying, provided that the entire
|
||
resulting derived work is distributed under the terms of a permission
|
||
notice identical to this one.
|
||
|
||
Permission is granted to copy and distribute translations of this manual
|
||
into another language, under the above conditions for modified versions,
|
||
except that this permission notice may be stated in a translation approved
|
||
by the author.
|
||
@end ifinfo
|
||
|
||
@setchapternewpage on
|
||
@titlepage
|
||
@c use the new format for titles
|
||
|
||
@title The EXT2FS Library
|
||
@subtitle The EXT2FS Library
|
||
@subtitle Version 1.11
|
||
@subtitle April 1997
|
||
|
||
@author by Theodore Ts'o
|
||
|
||
@c Include the Distribution inside the titlepage so
|
||
@c that headings are turned off.
|
||
|
||
@tex
|
||
\global\parindent=0pt
|
||
\global\parskip=8pt
|
||
\global\baselineskip=13pt
|
||
@end tex
|
||
|
||
@page
|
||
@vskip 0pt plus 1filll
|
||
Copyright @copyright{} 1997 Theodore Ts'o
|
||
|
||
@sp 2
|
||
|
||
Permission is granted to make and distribute verbatim copies of
|
||
this manual provided the copyright notice and this permission notice
|
||
are preserved on all copies.
|
||
|
||
Permission is granted to copy and distribute modified versions of this
|
||
manual under the conditions for verbatim copying, provided that the entire
|
||
resulting derived work is distributed under the terms of a permission
|
||
notice identical to this one.
|
||
|
||
Permission is granted to copy and distribute translations of this manual
|
||
into another language, under the above conditions for modified versions,
|
||
except that this permission notice may be stated in a translation approved
|
||
by the Foundation.
|
||
@end titlepage
|
||
@headings double
|
||
|
||
@ifinfo
|
||
@node Top, Introduction to the EXT2FS Library, (dir), (dir)
|
||
|
||
@top The EXT2FS Library
|
||
|
||
This manual documents the EXT2FS Library, version 1.11.
|
||
|
||
@end ifinfo
|
||
|
||
@menu
|
||
* Introduction to the EXT2FS Library::
|
||
* EXT2FS Library Functions::
|
||
* Concept Index::
|
||
* Function Index::
|
||
@end menu
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Introduction to the EXT2FS Library, EXT2FS Library Functions, Top, Top
|
||
@comment node-name, next, previous, up
|
||
@chapter Introduction to the EXT2FS Library
|
||
|
||
The EXT2FS library is designed to allow user-level programs to
|
||
manipulate an ext2 filesystem.
|
||
|
||
@node EXT2FS Library Functions, Concept Index, Introduction to the EXT2FS Library, Top
|
||
@comment node-name, next, previous, up
|
||
@chapter EXT2FS Library Functions
|
||
|
||
@menu
|
||
* Filesystem-level functions::
|
||
* Inode Functions::
|
||
* Directory functions::
|
||
* Bitmap Functions::
|
||
* EXT2 data abstractions::
|
||
* Byte-swapping functions::
|
||
* Other functions::
|
||
@end menu
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Filesystem-level functions, Inode Functions, EXT2FS Library Functions, EXT2FS Library Functions
|
||
@comment node-name, next, previous, up
|
||
@section Filesystem-level functions
|
||
|
||
The following functions operate on a filesystem handle. Most EXT2FS
|
||
Library functions require a filesystem handle as their first argument.
|
||
There are two functions which create a filesystem handle,
|
||
@code{ext2fs_open} and @code{ext2fs_initialize}.
|
||
|
||
The filesystem can also be closed using @code{ext2fs_close}, and any
|
||
changes to the superblock and group descripts can be written out to disk
|
||
using @code{ext2fs_flush}.
|
||
|
||
@menu
|
||
* Opening an ext2 filesystem::
|
||
* Closing and flushing out changes::
|
||
* Initializing a filesystem::
|
||
* Filesystem flag functions::
|
||
@end menu
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Opening an ext2 filesystem, Closing and flushing out changes, Filesystem-level functions, Filesystem-level functions
|
||
@comment node-name, next, previous, up
|
||
@subsection Opening an ext2 filesystem
|
||
|
||
Most libext2fs functions take a filesystem handle of type
|
||
@code{ext2_filsys}. A filesystem handle is created either by opening
|
||
an existing function using @code{ext2fs_open}, or by initializing a new
|
||
filesystem using @code{ext2fs_initialize}.
|
||
|
||
@deftypefun errcode_t ext2fs_open (const char *@var{name}, int @var{flags}, int @var{superblock}, int @var{block_size}, io_manager @var{manager}, ext2_filsys *@var{ret_fs})
|
||
|
||
Opens a filesystem named @var{name}, using the the io_manager
|
||
@var{manager} to define the input/output routines needed to read and
|
||
write the filesystem. In the case of the @code{unix_io} io_manager,
|
||
@var{name} is interpreted as the Unix filename of the filesystem image.
|
||
This is often a device file, such as @file{/dev/hda1}.
|
||
|
||
The @var{superblock} parameter specifies the block number of the
|
||
superblock which should be used when opening the filesystem.
|
||
If @var{superblock} is zero, @code{ext2fs_open} will use the primary
|
||
superblock located at offset 1024 bytes from the start of the filesystem
|
||
image.
|
||
|
||
The @var{block_size} parameter specifies the block size used by the
|
||
filesystem. Normally this is determined automatically from the
|
||
filesystem uperblock. If @var{block_size} is non-zero, it must match
|
||
the block size found in the superblock, or the error
|
||
@code{EXT2_ET_UNEXPECTED_BLOCK_SIZE} will be returned. The
|
||
@var{block_size} parameter is also used to help fund the superblock when
|
||
@var{superblock} is non-zero.
|
||
|
||
The @var{flags} argument contains a bitmask of flags which control how
|
||
the filesystem open should be handled.
|
||
|
||
@table @code
|
||
@item EXT2_FLAG_RW
|
||
Open the filesystem for reading and writing. Without this flag, the
|
||
filesystem is opened for reading only.
|
||
|
||
@item EXT2_FLAG_FORCE
|
||
Open the filesystem regardless of the feature sets listed in the
|
||
superblock.
|
||
|
||
@end table
|
||
@end deftypefun
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Closing and flushing out changes, Initializing a filesystem, Opening an ext2 filesystem, Filesystem-level functions
|
||
@comment node-name, next, previous, up
|
||
@subsection Closing and flushing out changes
|
||
|
||
@deftypefun errcode_t ext2fs_flush (ext2_filsys @var{fs})
|
||
|
||
Write any changes to the high-level filesystem data structures in the
|
||
@var{fs} filesystem. The following data structures will be written out:
|
||
|
||
@itemize @bullet
|
||
@item The filesystem superblock
|
||
@item The filesystem group descriptors
|
||
@item The filesystem bitmaps, if read in via @code{ext2fs_read_bitmaps}.
|
||
@end itemize
|
||
|
||
@end deftypefun
|
||
|
||
@deftypefun void ext2fs_free (ext2_filsys @var{fs})
|
||
|
||
Close the io_manager abstraction for @var{fs} and release all memory
|
||
associated with the filesystem handle.
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_close (ext2_filsys @var{fs})
|
||
|
||
Flush out any changes to the high-level filesystem data structures using
|
||
@code{ext2fs_flush} if the filesystem is marked dirty; then close and
|
||
free the filesystem using @code{ext2fs_free}.
|
||
|
||
@end deftypefun
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Initializing a filesystem, Filesystem flag functions, Closing and flushing out changes, Filesystem-level functions
|
||
@comment node-name, next, previous, up
|
||
@subsection Initializing a filesystem
|
||
|
||
An ext2 filesystem is initializing by the @code{mke2fs} program. The
|
||
two functions described here, @code{ext2fs_initialize} and
|
||
@code{ext2fs_allocate_tables} do much of the initial work for setting up
|
||
a filesystem. However, they don't do the whole job. @code{mke2fs}
|
||
calls @code{ext2fs_initialize} to set up the filesystem superblock, and
|
||
calls @code{ext2fs_allocate_tables} to allocate space for the inode
|
||
table, and the inode and block bitmaps. In addition, @code{mke2fs} must
|
||
also initialize the inode tables by clearing them with zeros, create the
|
||
root and lost+found directories, and reserve the reserved inodes.
|
||
|
||
@deftypefun errcode_t ext2fs_initialize (const char *@var{name}, int @var{flags}, struct ext2_super_block *@var{param}, io_manager @var{manager}, ext2_filsys *@var{ret_fs})
|
||
|
||
This function is used by the @code{mke2fs} program to initialize a
|
||
filesystem. The @code{ext2fs_initialize} function creates a filesystem
|
||
handle which is returned in @var{ret_fs} that has been properly setup
|
||
for a filesystem to be located in @var{name}, using the io_manager
|
||
@var{manager}. The prototype superblock in @var{param} is used to
|
||
supply parameters such as the number of blocks in the filesystem, the
|
||
block size, etc.
|
||
|
||
The @code{ext2fs_initialize} function does not actually do any I/O; that
|
||
will be done when the application program calls @code{ext2fs_close} or
|
||
@code{ext2fs_flush}. Also, this function only initializes the
|
||
superblock and group descriptor structures. It does not create the
|
||
inode table or the root directory. This must be done by the calling
|
||
application, such as @code{mke2fs}.
|
||
|
||
The following values may be set in the @var{param} prototype superblock;
|
||
if a value of 0 is found in a field, @code{ext2fs_initialize} will use a
|
||
default value. The calling application should zero out the prototype
|
||
entire superblock, and then fill in any appropriate values.
|
||
|
||
@table @code
|
||
|
||
@item s_blocks_count
|
||
The number of blocks in the filesystem. This parameter is mandatory and
|
||
must be set by the calling application.
|
||
|
||
@item s_inodes_count
|
||
The number of inodes in the filesystem. The
|
||
default value is determined by calculating the size of the filesystem,
|
||
and creating one inode for every 4096 bytes.
|
||
|
||
@item s_r_blocks_count
|
||
The number of blocks which should be reserved for the superuser. The
|
||
default value is zero blocks.
|
||
|
||
@item s_log_block_size
|
||
The blocksize of the filesystem. Valid values are 0 (1024 bytes), 1
|
||
(2048 bytes), or 2 (4096 bytes). The default blocksize is 1024 bytes.
|
||
|
||
@item s_log_frag_size
|
||
The size of fragments. The ext2 filesystem does not support fragments
|
||
(and may never support fragments). Currently this field must be the
|
||
same as @code{s_log_block_size}.
|
||
|
||
@item s_first_data_block
|
||
The first data block for the filesystem. For filesystem with a
|
||
blocksize of 1024 bytes, this value must be at least 1, since the
|
||
superblock is located in block number 1. For filesystems with larger
|
||
blocksizes, the superblock is still located at an offset of 1024 bytes,
|
||
so the superblock is located in block number 0. By default, this value
|
||
is set to 1 for filesystems with a block size of 1024 bytes, or 0 for
|
||
filesystems with larger blocksizes.
|
||
|
||
@item s_max_mnt_count
|
||
This field defines the number of times that the filesystem can be
|
||
mounted before it should be checked using @code{e2fsck}. When
|
||
@code{e2fsck} is run without the @samp{-f} option, @code{e2fsck} will
|
||
skip the filesystem check if the number of times that the filesystem has
|
||
been mounted is less than @code{s_max_mnt_count} and if the interval
|
||
between the last time a filesystem check was performed and the current
|
||
time is less than @code{s_checkinterval} (see below). The default value
|
||
of @code{s_max_mnt_count} is 20.
|
||
|
||
@item s_checkinterval
|
||
This field defines the minimal interval between filesystem checks. See
|
||
the previous entry for a discussion of how this field is used by
|
||
@code{e2fsck}. The default value of this field is 180 days (six
|
||
months).
|
||
|
||
@item s_errors
|
||
This field defines the behavior which should be used by the kernel of
|
||
errors are detected in the filesystem. Possible values include:
|
||
|
||
@table @samp
|
||
@item EXT2_ERRORS_CONTINUE
|
||
Continue execution when errors are detected.
|
||
|
||
@item EXT2_ERRORS_RO
|
||
Remount the filesystem read-only.
|
||
|
||
@item EXT2_ERRORS_PANIC
|
||
Panic.
|
||
|
||
@end table
|
||
|
||
The default behavior is @samp{EXT2_ERRORS_CONTINUE}.
|
||
|
||
@end table
|
||
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_allocate_tables (ext2_filsys @var{fs})
|
||
Allocate space for the inode table and the block and inode bitmaps. The
|
||
inode tables and block and inode bitmaps aren't actually initialized;
|
||
this function just allocates the space for them.
|
||
@end deftypefun
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Filesystem flag functions, , Initializing a filesystem, Filesystem-level functions
|
||
@comment node-name, next, previous, up
|
||
@subsection Filesystem flag functions
|
||
|
||
The filesystem handle has a number of flags which can be manipulated
|
||
using the following function. Some of these flags affect how the
|
||
libext2fs filesystem behaves; others are provided solely for the
|
||
application's convenience.
|
||
|
||
@deftypefun void ext2fs_mark_changed (ext2_filsys @var{fs})
|
||
@deftypefunx int ext2fs_test_changed (ext2_filsys @var{fs})
|
||
This flag indicates whether or not the filesystem has been changed.
|
||
It is not used by the ext2fs library.
|
||
@end deftypefun
|
||
|
||
@deftypefun void ext2fs_mark_super_dirty (ext2_filsys @var{fs})
|
||
Mark the filesystem @var{fs} as being dirty; this will cause
|
||
the superblock information to be flushed out when @code{ext2fs_close} is
|
||
called. @code{ext2fs_mark_super_dirty} will also set the filesystem
|
||
changed flag. The dirty flag is automatically cleared by
|
||
@code{ext2fs_flush} when the superblock is written to disk.
|
||
@end deftypefun
|
||
|
||
@deftypefun void ext2fs_mark_valid (ext2_filsys @var{fs})
|
||
@deftypefunx void ext2fs_unmark_valid (ext2_filsys @var{fs})
|
||
@deftypefunx int ext2fs_test_valid (ext2_filsys @var{fs})
|
||
This flag indicates whether or not the filesystem is free of errors.
|
||
It is not used by libext2fs, and is solely for the application's
|
||
convenience.
|
||
@end deftypefun
|
||
|
||
@deftypefun void ext2fs_mark_ib_dirty (ext2_filsys @var{fs})
|
||
@deftypefunx void ext2fs_mark_bb_dirty (ext2_filsys @var{fs})
|
||
@deftypefunx int ext2fs_test_ib_dirty (ext2_filsys @var{fs})
|
||
@deftypefunx int ext2fs_test_bb_dirty (ext2_filsys @var{fs})
|
||
These flags indicate whether or not the inode or block bitmaps have been
|
||
modified. If the flag is set, it will cause the appropriate bitmap
|
||
to be written when the filesystem is closed or flushed.
|
||
@end deftypefun
|
||
|
||
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Inode Functions, Directory functions, Filesystem-level functions, EXT2FS Library Functions
|
||
@comment node-name, next, previous, up
|
||
@section Inode Functions
|
||
|
||
@menu
|
||
* Reading and writing inodes::
|
||
* Iterating over inodes in a filesystem::
|
||
* Iterating over blocks in an inode::
|
||
* Inode Convenience Functions::
|
||
@end menu
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Reading and writing inodes, Iterating over inodes in a filesystem, Inode Functions, Inode Functions
|
||
@comment node-name, next, previous, up
|
||
@subsection Reading and writing inodes
|
||
|
||
@deftypefun errcode_t ext2fs_read_inode (ext2_filsys @var{fs}, ino_t @var{ino}, struct ext2_inode *@var{inode})
|
||
Read the inode number @var{ino} into @var{inode}.
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_write_inode(ext2_filsys @var{fs}, ino_t @var{ino}, struct ext2_inode *@var{inode})
|
||
Write @var{inode} to inode @var{ino}.
|
||
@end deftypefun
|
||
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Iterating over inodes in a filesystem, Iterating over blocks in an inode, Reading and writing inodes, Inode Functions
|
||
@comment node-name, next, previous, up
|
||
@subsection Iterating over inodes in a filesystem
|
||
|
||
The inode_scan abstraction is useful for iterating over all the inodes
|
||
in a filesystem.
|
||
|
||
@deftypefun errcode_t ext2fs_open_inode_scan (ext2_filsys @var{fs}, int @var{buffer_blocks}, ext2_inode_scan *@var{scan})
|
||
Initialize the iteration variable @var{scan}. This variable is used by
|
||
@code{ext2fs_get_next_inode}. The @var{buffer_blocks} parameter
|
||
controls how many blocks of the inode table are read in at a time. A
|
||
large number of blocks requires more memory, but reduces the overhead in
|
||
seeking and reading from the disk. If @var{buffer_blocks} is zero, a
|
||
suitable default value will be used.
|
||
@end deftypefun
|
||
|
||
@deftypefun void ext2fs_close_inode_scan (ext2_inode_scan @var{scan})
|
||
Release the memory associated with @var{scan} and invalidate it.
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_get_next_inode (ext2_inode_scan @var{scan}, ino_t *@var{ino}, struct ext2_inode *@var{inode})
|
||
|
||
This function returns the next inode from the filesystem; the inode
|
||
number of the inode is stored in @var{ino}, and the inode is stored in
|
||
@var{inode}.
|
||
|
||
If the inode is located in a block that has been marked as bad,
|
||
@code{ext2fs_get_next_inode} will return the error
|
||
@code{EXT2_ET_BAD_BLOCK_IN_INODE_TABLE}.
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_inode_scan_goto_blockgroup (ext2_inode_scan @var{scan}, int @var{group})
|
||
Start the inode scan at a particular ext2 blockgroup, @var{group}.
|
||
This function may be safely called at any time while @var{scan} is valid.
|
||
@end deftypefun
|
||
|
||
@deftypefun void ext2fs_set_inode_callback (ext2_inode_scan @var{scan}, errcode_t (*done_group)(ext2_filsys @var{fs}, ext2_inode_scan @var{scan}, dgrp_t @var{group}, void * @var{private}), void *@var{done_group_data})
|
||
Register a callback function which will be called by
|
||
@code{ext2_get_next_inode} when all of the inodes in a block group have
|
||
been processed.
|
||
@end deftypefun
|
||
|
||
@deftypefun int ext2fs_inode_scan_flags (ext2_inode_scan @var{scan}, int @var{set_flags}, int @var{clear_flags})
|
||
|
||
Set the scan_flags @var{set_flags} and clear the scan_flags @var{clear_flags}.
|
||
The following flags can be set using this interface:
|
||
|
||
@table @samp
|
||
|
||
@item EXT2_SF_SKIP_MISSING_ITABLE
|
||
When a block group is missing an inode table, skip it. If this flag is
|
||
not set @code{ext2fs_get_next_inode} will return the error
|
||
EXT2_ET_MISSING_INODE_TABLE.
|
||
|
||
@end table
|
||
|
||
@end deftypefun
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Iterating over blocks in an inode, Inode Convenience Functions, Iterating over inodes in a filesystem, Inode Functions
|
||
@comment node-name, next, previous, up
|
||
@subsection Iterating over blocks in an inode
|
||
|
||
@deftypefun errcode_t ext2fs_block_iterate (ext2_filsys @var{fs}, ino_t @var{ino}, int @var{flags}, char *block_buf, int (*func)(ext2_filsys @var{fs}, blk_t *@var{blocknr}, int @var{blockcnt}, void *@var{private}), void *@var{private})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_block_iterate2 (ext2_filsys @var{fs}, ino_t @var{ino}, int @var{flags}, char *@var{block}_buf, int (*func)(ext2_filsys @var{fs}, blk_t *@var{blocknr}, int @var{blockcnt}, blk_t @var{ref_blk}, int @var{ref_offset}, void *@var{private}), void *@var{private})
|
||
@end deftypefun
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Inode Convenience Functions, , Iterating over blocks in an inode, Inode Functions
|
||
@comment node-name, next, previous, up
|
||
@subsection Convenience functions for Inodes
|
||
|
||
@deftypefun errcode_t ext2fs_get_blocks (ext2_filsys @var{fs}, ino_t @var{ino}, blk_t *@var{blocks})
|
||
|
||
Returns an array of blocks corresponding to the direct,
|
||
indirect, doubly indirect, and triply indirect blocks as stored in the
|
||
inode structure.
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_check_directory (ext2_filsys @var{fs}, ino_t @var{ino})
|
||
Returns 0 if @var{ino} is a directory, and @code{ENOTDIR} if it is not.
|
||
@end deftypefun
|
||
|
||
@deftypefun int ext2_inode_has_valid_blocks (struct ext2_inode *@var{inode})
|
||
|
||
Returns 1 if the inode's block entries actually valid block entries, and
|
||
0 if not. Inodes which represent devices and fast symbolic links do not
|
||
contain valid block entries.
|
||
@end deftypefun
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Directory functions, Bitmap Functions, Inode Functions, EXT2FS Library Functions
|
||
@comment node-name, next, previous, up
|
||
@section Directory functions
|
||
|
||
@menu
|
||
* Directory block functions::
|
||
* Iterating over a directory::
|
||
* Creating and expanding directories::
|
||
* Creating and removing directory entries::
|
||
* Looking up filenames::
|
||
* Translating inode numbers to filenames::
|
||
@end menu
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Directory block functions, Iterating over a directory, Directory functions, Directory functions
|
||
@comment node-name, next, previous, up
|
||
@subsection Directory block functions
|
||
|
||
@deftypefun errcode_t ext2fs_read_dir_block (ext2_filsys @var{fs}, blk_t @var{block}, void *@var{buf})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_write_dir_block (ext2_filsys @var{fs}, blk_t @var{block}, void *@var{buf})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_new_dir_block (ext2_filsys @var{fs}, ino_t @var{dir}_ino, ino_t @var{parent_ino}, char **@var{block})
|
||
@end deftypefun
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Iterating over a directory, Creating and expanding directories, Directory block functions, Directory functions
|
||
@comment node-name, next, previous, up
|
||
@subsection Iterating over a directory
|
||
|
||
@deftypefun errcode_t ext2fs_dir_iterate (ext2_filsys @var{fs}, ino_t @var{dir}, int @var{flags}, char *@var{block_buf}, int (*@var{func})(struct ext2_dir_entry *@var{dirent}, int @var{offset}, int @var{blocksize}, char *@var{buf}, void *@var{private}), void *@var{private})
|
||
@end deftypefun
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Creating and expanding directories, Creating and removing directory entries, Iterating over a directory, Directory functions
|
||
@comment node-name, next, previous, up
|
||
@subsection Creating and expanding directories
|
||
|
||
@deftypefun errcode_t ext2fs_mkdir (ext2_filsys @var{fs}, ino_t @var{parent}, ino_t @var{inum}, const char *@var{name})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_expand_dir (ext2_filsys @var{fs}, ino_t @var{dir})
|
||
@end deftypefun
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Creating and removing directory entries, Looking up filenames, Creating and expanding directories, Directory functions
|
||
@comment node-name, next, previous, up
|
||
@subsection Creating and removing directory entries
|
||
|
||
@deftypefun errcode_t ext2fs_link (ext2_filsys @var{fs}, ino_t @var{dir}, const char *@var{name}, ino_t @var{ino}, int flags)
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_unlink (ext2_filsys @var{fs}, ino_t @var{dir}, const char *@var{name}, ino_t @var{ino}, int @var{flags})
|
||
@end deftypefun
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Looking up filenames, Translating inode numbers to filenames, Creating and removing directory entries, Directory functions
|
||
@comment node-name, next, previous, up
|
||
@subsection Looking up filenames
|
||
|
||
@deftypefun errcode_t ext2fs_lookup (ext2_filsys @var{fs}, ino_t @var{dir}, const char *@var{name}, int @var{namelen}, char *@var{buf}, ino_t *@var{inode})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_namei (ext2_filsys @var{fs}, ino_t @var{root}, ino_t @var{cwd}, const char *@var{name}, ino_t *@var{inode})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_namei_follow (ext2_filsys @var{fs}, ino_t @var{root}, ino_t @var{cwd}, const char *@var{name}, ino_t *@var{inode})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_follow_link (ext2_filsys @var{fs}, ino_t @var{root}, ino_t @var{cwd}, ino_t @var{inode}, ino_t *@var{res}_inode)
|
||
@end deftypefun
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Translating inode numbers to filenames, , Looking up filenames, Directory functions
|
||
@comment node-name, next, previous, up
|
||
@subsection Translating inode numbers to filenames
|
||
|
||
@deftypefun errcode_t ext2fs_get_pathname (ext2_filsys @var{fs}, ino_t @var{dir}, ino_t @var{ino}, char **@var{name})
|
||
@end deftypefun
|
||
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Bitmap Functions, EXT2 data abstractions, Directory functions, EXT2FS Library Functions
|
||
@comment node-name, next, previous, up
|
||
@section Bitmap Functions
|
||
|
||
@menu
|
||
* Reading and Writing Bitmaps::
|
||
* Allocating Bitmaps::
|
||
* Free bitmaps::
|
||
* Bitmap Operations::
|
||
* Comparing bitmaps::
|
||
* Modifying Bitmaps::
|
||
* Resizing Bitmaps::
|
||
* Clearing Bitmaps::
|
||
@end menu
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Reading and Writing Bitmaps, Allocating Bitmaps, Bitmap Functions, Bitmap Functions
|
||
@comment node-name, next, previous, up
|
||
@subsection Reading and Writing Bitmaps
|
||
|
||
@deftypefun errcode_t ext2fs_write_inode_bitmap (ext2_filsys @var{fs})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_write_block_bitmap (ext2_filsys @var{fs})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_read_inode_bitmap (ext2_filsys @var{fs})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_read_block_bitmap (ext2_filsys @var{fs})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_read_bitmaps (ext2_filsys @var{fs})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_write_bitmaps (ext2_filsys @var{fs})
|
||
@end deftypefun
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Allocating Bitmaps, Free bitmaps, Reading and Writing Bitmaps, Bitmap Functions
|
||
@comment node-name, next, previous, up
|
||
@subsection Allocating Bitmaps
|
||
|
||
@deftypefun errcode_t ext2fs_allocate_generic_bitmap (__u32 @var{start}, __u32 @var{end}, _u32 @var{real_end}, const char *@var{descr}, ext2fs_generic_bitmap *@var{ret})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_allocate_block_bitmap (ext2_filsys @var{fs}, const char *@var{descr}, ext2fs_block_bitmap *@var{ret})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_allocate_inode_bitmap (ext2_filsys @var{fs}, const char *@var{descr}, ext2fs_inode_bitmap *@var{ret})
|
||
@end deftypefun
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Free bitmaps, Bitmap Operations, Allocating Bitmaps, Bitmap Functions
|
||
@comment node-name, next, previous, up
|
||
@subsection Freeing bitmaps
|
||
|
||
|
||
@deftypefun void ext2fs_free_generic_bitmap (ext2fs_inode_bitmap @var{bitmap})
|
||
@end deftypefun
|
||
|
||
@deftypefun void ext2fs_free_block_bitmap (ext2fs_block_bitmap @var{bitmap})
|
||
@end deftypefun
|
||
|
||
@deftypefun void ext2fs_free_inode_bitmap (ext2fs_inode_bitmap @var{bitmap})
|
||
@end deftypefun
|
||
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Bitmap Operations, Comparing bitmaps, Free bitmaps, Bitmap Functions
|
||
@comment node-name, next, previous, up
|
||
@subsection Bitmap Operations
|
||
|
||
@deftypefun void ext2fs_mark_block_bitmap (ext2fs_block_bitmap @var{bitmap}, blk_t @var{block})
|
||
|
||
@deftypefunx void ext2fs_unmark_block_bitmap (ext2fs_block_bitmap @var{bitmap}, blk_t @var{block})
|
||
|
||
@deftypefunx int ext2fs_test_block_bitmap (ext2fs_block_bitmap @var{bitmap}, blk_t @var{block})
|
||
|
||
These functions set, clear, and test bits in a block bitmap @var{bitmap}.
|
||
@end deftypefun
|
||
|
||
|
||
@deftypefun void ext2fs_mark_inode_bitmap (ext2fs_inode_bitmap @var{bitmap}, ino_t @var{inode})
|
||
|
||
@deftypefunx void ext2fs_unmark_inode_bitmap (ext2fs_inode_bitmap @var{bitmap}, ino_t @var{inode})
|
||
|
||
@deftypefunx int ext2fs_test_inode_bitmap (ext2fs_inode_bitmap @var{bitmap}, ino_t @var{inode})
|
||
|
||
These functions set, clear, and test bits in an inode bitmap @var{bitmap}.
|
||
@end deftypefun
|
||
|
||
@deftypefun void ext2fs_fast_mark_block_bitmap (ext2fs_block_bitmap @var{bitmap}, blk_t @var{block})
|
||
|
||
@deftypefunx void ext2fs_fast_unmark_block_bitmap (ext2fs_block_bitmap @var{bitmap}, blk_t @var{block})
|
||
|
||
@deftypefunx int ext2fs_fast_test_block_bitmap (ext2fs_block_bitmap @var{bitmap}, blk_t @var{block})
|
||
|
||
@deftypefunx void ext2fs_fast_mark_inode_bitmap (ext2fs_inode_bitmap @var{bitmap}, ino_t @var{inode})
|
||
|
||
@deftypefunx void ext2fs_fast_unmark_inode_bitmap (ext2fs_inode_bitmap @var{bitmap}, ino_t @var{inode})
|
||
|
||
@deftypefunx int ext2fs_fast_test_inode_bitmap (ext2fs_inode_bitmap @var{bitmap}, ino_t @var{inode})
|
||
|
||
These ``fast'' functions are like their normal counterparts; however,
|
||
they are implemented as inline functions and do not perform bounds
|
||
checks on the inode number or block number; they are assumed to be
|
||
correct. They should only be used in speed-critical applications, where
|
||
the inode or block number has already been validated by other means.
|
||
@end deftypefun
|
||
|
||
@deftypefun blk_t ext2fs_get_block_bitmap_start (ext2fs_block_bitmap @var{bitmap})
|
||
@deftypefunx ino_t ext2fs_get_inode_bitmap_start (ext2fs_inode_bitmap @var{bitmap})
|
||
Return the first inode or block which is stored in the bitmap.
|
||
@end deftypefun
|
||
|
||
@deftypefun blk_t ext2fs_get_block_bitmap_end (ext2fs_block_bitmap @var{bitmap})
|
||
@deftypefunx ino_t ext2fs_get_inode_bitmap_end (ext2fs_inode_bitmap @var{bitmap})
|
||
|
||
Return the first inode or block which is stored in the bitmap.
|
||
@end deftypefun
|
||
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Comparing bitmaps, Modifying Bitmaps, Bitmap Operations, Bitmap Functions
|
||
@comment node-name, next, previous, up
|
||
@subsection Comparing bitmaps
|
||
|
||
@deftypefun errcode_t ext2fs_compare_block_bitmap (ext2fs_block_bitmap @var{bm1}, ext2fs_block_bitmap @var{bm2})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_compare_inode_bitmap (ext2fs_inode_bitmap @var{bm1}, ext2fs_inode_bitmap @var{bm2})
|
||
@end deftypefun
|
||
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Modifying Bitmaps, Resizing Bitmaps, Comparing bitmaps, Bitmap Functions
|
||
@comment node-name, next, previous, up
|
||
@subsection Modifying Bitmaps
|
||
|
||
@deftypefun errcode_t ext2fs_fudge_inode_bitmap_end (ext2fs_inode_bitmap @var{bitmap}, ino_t @var{end}, ino_t *@var{oend})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_fudge_block_bitmap_end (ext2fs_block_bitmap @var{bitmap}, blk_t @var{end}, blk_t *@var{oend})
|
||
@end deftypefun
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Resizing Bitmaps, Clearing Bitmaps, Modifying Bitmaps, Bitmap Functions
|
||
@comment node-name, next, previous, up
|
||
@subsection Resizing Bitmaps
|
||
|
||
@deftypefun errcode_t ext2fs_resize_generic_bitmap (__u32 @var{new_end}, __u32 @var{new_real_end}, ext2fs_generic_bitmap @var{bmap})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_resize_inode_bitmap (__u32 @var{new_end}, __u32 @var{new_real_end}, ext2fs_inode_bitmap @var{bmap})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_resize_block_bitmap (__u32 @var{new_end}, __u32 @var{new_real_end}, ext2fs_block_bitmap @var{bmap})
|
||
@end deftypefun
|
||
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Clearing Bitmaps, , Resizing Bitmaps, Bitmap Functions
|
||
@comment node-name, next, previous, up
|
||
@subsection Clearing Bitmaps
|
||
|
||
@deftypefun void ext2fs_clear_inode_bitmap (ext2fs_inode_bitmap @var{bitmap})
|
||
@end deftypefun
|
||
|
||
@deftypefun void ext2fs_clear_block_bitmap (ext2fs_block_bitmap @var{bitmap})
|
||
@end deftypefun
|
||
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node EXT2 data abstractions, Byte-swapping functions, Bitmap Functions, EXT2FS Library Functions
|
||
@comment node-name, next, previous, up
|
||
@section EXT2 data abstractions
|
||
|
||
The ext2 library has a number of abstractions which are useful for ext2
|
||
utility programs.
|
||
|
||
@menu
|
||
* Badblocks list management::
|
||
* Directory-block list management::
|
||
* Inode count functions::
|
||
@end menu
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Badblocks list management, Directory-block list management, EXT2 data abstractions, EXT2 data abstractions
|
||
@comment node-name, next, previous, up
|
||
@subsection Badblocks list management
|
||
|
||
|
||
@deftypefun errcode_t ext2fs_badblocks_list_create (ext2_badblocks_list *@var{ret}, int @var{size})
|
||
@end deftypefun
|
||
|
||
@deftypefun void ext2fs_badblocks_list_free (ext2_badblocks_list @var{bb})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_badblocks_list_add (ext2_badblocks_list @var{bb}, blk_t @var{blk})
|
||
@end deftypefun
|
||
|
||
@deftypefun int ext2fs_badblocks_list_test (ext2_badblocks_list @var{bb}, blk_t @var{blk})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_badblocks_list_iterate_begin (ext2_badblocks_list @var{bb}, ext2_badblocks_iterate *@var{ret})
|
||
@end deftypefun
|
||
|
||
@deftypefun int ext2fs_badblocks_list_iterate (ext2_badblocks_iterate iter, blk_t *@var{blk})
|
||
@end deftypefun
|
||
|
||
@deftypefun void ext2fs_badblocks_list_iterate_end (ext2_badblocks_iterate @var{iter})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_update_bb_inode (ext2_filsys @var{fs}, ext2_badblocks_list @var{bb_list})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_read_bb_inode (ext2_filsys @var{fs}, ext2_badblocks_list *@var{bb_list})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_read_bb_FILE (ext2_filsys @var{fs}, FILE *f, ext2_badblocks_list *@var{bb_list}, void (*invalid)(ext2_filsys @var{fs}, blk_t @var{blk}))
|
||
@end deftypefun
|
||
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Directory-block list management, Inode count functions, Badblocks list management, EXT2 data abstractions
|
||
@comment node-name, next, previous, up
|
||
@subsection Directory-block list management
|
||
|
||
The dblist abstraction stores a list of blocks belonging to
|
||
directories. This list can be useful when a program needs to interate
|
||
over all directory entries in a filesystem; @code{e2fsck} does this in
|
||
pass 2 of its operations, and @code{debugfs} needs to do this when it is
|
||
trying to turn an inode number into a pathname.
|
||
|
||
@deftypefun errcode_t ext2fs_init_dblist (ext2_filsys @var{fs}, ext2_dblist *@var{ret_dblist})
|
||
|
||
Creates a dblist data structure and return it in @var{ret_dblist}.
|
||
@end deftypefun
|
||
|
||
@deftypefun void ext2fs_free_dblist (ext2_dblist @var{dblist})
|
||
|
||
Free a dblist data structure.
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_add_dir_block (ext2_dblist @var{dblist}, ino_t @var{ino}, blk_t @var{blk}, int @var{blockcnt})
|
||
|
||
Add an entry to the dblist data structure. This call records the fact
|
||
that block number @var{blockcnt} of directory inode @var{ino} is stored
|
||
in block @var{blk}.
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_set_dir_block (ext2_dblist @var{dblist}, ino_t @var{ino}, blk_t @var{blk}, int @var{blockcnt})
|
||
|
||
Change an entry in the dblist data structure; this changes the location
|
||
of block number @var{blockcnt} of directory indoe @var{ino} to be block
|
||
@var{blk}.
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_dblist_iterate (ext2_dblist @var{dblist}, int (*func)(ext2_filsys @var{fs}, struct ext2_db_entry *@var{db_info}, void *@var{private}), void *@var{private})
|
||
|
||
This iterator calls @var{func} for every entry in the dblist data structure.
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_dblist_dir_iterate (ext2_dblist @var{dblist}, int flags, char *@var{block_buf}, int (*func)(ino_t @var{dir}, int @var{entry}, struct ext2_dir_entry *@var{dirent}, int @var{offset}, int @var{blocksize}, char *@var{buf}, void *@var{private}), void *@var{private})
|
||
|
||
This iterator takes reads in the directory block indicated in each
|
||
dblist entry, and calls @var{func} for each directory entry in each
|
||
directory block. If @var{dblist} contains all the directory blocks in a
|
||
filesystem, this function provides a convenient way to iterate over all
|
||
directory entries for that filesystem.
|
||
@end deftypefun
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Inode count functions, , Directory-block list management, EXT2 data abstractions
|
||
@comment node-name, next, previous, up
|
||
@subsection Inode count functions
|
||
|
||
The icount abstraction is a specialized data type used by @code{e2fsck}
|
||
to store how many times a particular inode is referenced by the
|
||
filesystem. This is used twice; once to store the actual number of times
|
||
that the inode is reference; and once to store the claimed number of times
|
||
the inode is referenced according to the inode structure.
|
||
|
||
This abstraction is designed to be extremely efficient for storing this
|
||
sort of information, by taking advantage of the following properties of
|
||
inode counts, namely (1) inode counts are very often zero (because
|
||
the inode is currrently not in use), and (2) many files have a inode
|
||
count of 1 (because they are a file which has no additional hard links).
|
||
|
||
@deftypefun errcode_t ext2fs_create_icount2(ext2_filsys @var{fs}, int @var{flags}, int @var{size}, ext2_icount_t @var{hint}, ext2_icount_t *@var{ret})
|
||
|
||
Creates an icount stucture for a filesystem @var{fs}, with initial space
|
||
for @var{size} inodes whose count is greater than 1. The @var{flags}
|
||
parameter is either 0 or @code{EXT2_ICOUNT_OPT_INCREMENT}, which
|
||
indicates that icount structure should be able to increment inode counts
|
||
quickly. The icount structure is returned in @var{ret}. The returned
|
||
icount structure initially has a count of zero for all inodes.
|
||
|
||
The @var{hint} parameter allows the caller to optionally pass in another
|
||
icount structure which is used to initialize the array of inodes whose
|
||
count is greater than 1. It is used purely as a speed optimization so
|
||
that the icount structure can determine in advance which inodes are
|
||
likely to contain a count grater than 1.
|
||
@end deftypefun
|
||
|
||
@deftypefun void ext2fs_free_icount(ext2_icount_t @var{icount})
|
||
|
||
Frees an icount structure.
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_icount_fetch(ext2_icount_t @var{icount}, ino_t @var{ino}, __u16 *@var{ret})
|
||
|
||
Returns in @var{ret} fetches the count for a particular inode @var{ino}.
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_icount_increment(ext2_icount_t @var{icount}, ino_t @var{ino}, __u16 *@var{ret})
|
||
|
||
Increments the ref count for inode @var{ino}.
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_icount_decrement(ext2_icount_t @var{icount}, ino_t @var{ino}, __u16 *@var{ret})
|
||
|
||
Decrements the ref count for inode @var{ino}.
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_icount_store(ext2_icount_t @var{icount}, ino_t @var{ino}, __u16 @var{count})
|
||
|
||
Sets the reference count for inode @var{ino} to be @var{count}.
|
||
@end deftypefun
|
||
|
||
@deftypefun ino_t ext2fs_get_icount_size(ext2_icount_t @var{icount})
|
||
|
||
Returns the current number of inodes in @var{icount} which has a count
|
||
greater than 1.
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_icount_validate(ext2_icount_t @var{icount}, FILE *@var{f})
|
||
|
||
Validates the internal rep invariant of @var{icount}; if there are any
|
||
problems, print out debugging information to @var{f}. This function is
|
||
intended for debugging and testing use only.
|
||
@end deftypefun
|
||
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Byte-swapping functions, Other functions, EXT2 data abstractions, EXT2FS Library Functions
|
||
@comment node-name, next, previous, up
|
||
@section Byte-swapping functions
|
||
|
||
@deftypefun void ext2fs_swap_super (struct ext2_super_block * @var{super})
|
||
@end deftypefun
|
||
|
||
@deftypefun void ext2fs_swap_group_desc (struct ext2_group_desc *@var{gdp})
|
||
@end deftypefun
|
||
|
||
@deftypefun void ext2fs_swap_inode (ext2_filsys @var{fs}, struct ext2_inode *@var{to}, struct ext2_inode *@var{from}, int @var{hostorder})
|
||
@end deftypefun
|
||
|
||
@deftypefun int ext2fs_native_flag (void)
|
||
@end deftypefun
|
||
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Other functions, , Byte-swapping functions, EXT2FS Library Functions
|
||
@comment node-name, next, previous, up
|
||
@section Other functions
|
||
|
||
/* alloc.c */
|
||
@deftypefun errcode_t ext2fs_new_inode (ext2_filsys @var{fs}, ino_t @var{dir}, int @var{mode}, ext2fs_inode_bitmap @var{map}, ino_t *@var{ret})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_new_block (ext2_filsys @var{fs}, blk_t @var{goal}, ext2fs_block_bitmap @var{map}, blk_t *@var{ret})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2fs_get_free_blocks (ext2_filsys @var{fs}, blk_t @var{start}, blk_t @var{finish}, int @var{num}, ext2fs_block_bitmap @var{map}, blk_t *@var{ret})
|
||
@end deftypefun
|
||
|
||
/* check_desc.c */
|
||
@deftypefun errcode_t ext2fs_check_desc (ext2_filsys @var{fs})
|
||
@end deftypefun
|
||
|
||
@deftypefun errcode_t ext2_get_num_dirs (ext2_filsys @var{fs}, ino_t *@var{ret_num_dirs})
|
||
@end deftypefun
|
||
|
||
|
||
/* getsize.c */
|
||
@deftypefun errcode_t ext2fs_get_device_size (const char *@var{file}, int @var{blocksize}, blk_t *@var{retblocks})
|
||
@end deftypefun
|
||
|
||
|
||
/* ismounted.c */
|
||
@deftypefun errcode_t ext2fs_check_if_mounted (const char *@var{file}, int *@var{mount_flags})
|
||
@end deftypefun
|
||
|
||
/* version.c */
|
||
|
||
@deftypefun int ext2fs_get_library_version(const char **@var{ver_string}, const char **@var{date_string})
|
||
|
||
This function returns the current version of the ext2 library. The
|
||
return value contains an integer version code, which consists of the
|
||
major version number of the library multiplied by 100, plus the minor
|
||
version number of the library. Hence, if the library version is 1.08,
|
||
the returned value will be 108.
|
||
|
||
If @var{ver_string} and/or @var{date_string} are non-NULL, they will be
|
||
set to point at a constant string containing the library version and/or
|
||
release date, respectively.
|
||
@end deftypefun
|
||
|
||
@deftypefun int ext2fs_parse_version_string(const char *@var{ver_string})
|
||
|
||
This function takes a version string which may included in an
|
||
application and returns a version code using the same algorithm used by
|
||
@code{ext2fs_get_library_version}. It can be used by programs included
|
||
in the @code{e2fsprogs} distribution to assure that they are using an
|
||
up-to-date ext2 shared library.
|
||
@end deftypefun
|
||
|
||
/* inline functions */
|
||
@deftypefun int ext2fs_group_of_blk (ext2_filsys @var{fs}, blk_t @var{blk})
|
||
@end deftypefun
|
||
|
||
@deftypefun int ext2fs_group_of_ino (ext2_filsys @var{fs}, ino_t @var{ino})
|
||
@end deftypefun
|
||
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Concept Index, Function Index, EXT2FS Library Functions, Top
|
||
@comment node-name, next, previous, up
|
||
@unnumbered Concept Index
|
||
@printindex cp
|
||
|
||
@c ----------------------------------------------------------------------
|
||
|
||
@node Function Index, , Concept Index, Top
|
||
@comment node-name, next, previous, up
|
||
@unnumbered Function and Type Index
|
||
@printindex fn
|
||
|
||
|
||
@contents
|
||
@bye
|