f2fs_io.c File Reference

#include <errno.h>
#include <fcntl.h>
#include <getopt.h>
#include <inttypes.h>
#include <limits.h>
#include <linux/fs.h>
#include <signal.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/sendfile.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <termios.h>
#include <time.h>
#include <unistd.h>
#include <sys/xattr.h>
#include <android_config.h>
#include "f2fs_io.h"

Include dependency graph for f2fs_io.c:

Classes
struct	cmd_desc

Macros
#define	_GNU_SOURCE
#define	O_LARGEFILE   0
#define	__SANE_USERSPACE_TYPES__   /* For PPC64, to get LL64 types */
#define	fsync_desc   "fsync"
#define	fsync_help
#define	fdatasync_desc   "fdatasync"
#define	fdatasync_help
#define	set_verity_desc   "Set fs-verity"
#define	set_verity_help
#define	getflags_desc   "getflags ioctl"
#define	getflags_help
#define	setflags_desc   "setflags ioctl"
#define	setflags_help
#define	clearflags_desc   "clearflags ioctl"
#define	clearflags_help
#define	shutdown_desc   "shutdown filesystem"
#define	shutdown_help
#define	fadvise_desc   "fadvise"
#define	fadvise_help
#define	ioprio_desc   "ioprio"
#define	ioprio_help
#define	pinfile_desc   "pin file control"
#define	pinfile_help
#define	fallocate_desc   "fallocate"
#define	fallocate_help
#define	erase_desc   "erase a block device"
#define	erase_help
#define	write_desc   "write data into file"
#define	write_help
#define	write_advice_desc   "write data into file with a hint"
#define	write_advice_help
#define	read_desc   "read data from file"
#define	read_help
#define	fragread_desc   "read data with a fragmented buffer from file"
#define	fragread_help
#define	PAGE_SIZE   sysconf(_SC_PAGESIZE)
#define	ALLOC_SIZE   (2 * 1024 * 1024 - 4 * 1024)
#define	randread_desc   "random read data from file"
#define	randread_help
#define	fiemap_desc   "get block address in file"
#define	fiemap_help   "f2fs_io fiemap [offset in 4kb] [count in 4kb] [file_path]\n\n"\
#define	gc_urgent_desc   "start/end/run gc_urgent for given time period"
#define	gc_urgent_help
#define	defrag_file_desc   "do defragment on file"
#define	defrag_file_help
#define	copy_desc   "copy a file"
#define	copy_help
#define	get_cblocks_desc   "get number of reserved blocks on compress inode"
#define	get_cblocks_help   "f2fs_io get_cblocks [file]\n\n"
#define	release_cblocks_desc   "release reserved blocks on compress inode"
#define	release_cblocks_help   "f2fs_io release_cblocks [file]\n\n"
#define	reserve_cblocks_desc   "reserve blocks on compress inode"
#define	reserve_cblocks_help   "f2fs_io reserve_cblocks [file]\n\n"
#define	get_coption_desc   "get compression option of a compressed file"
#define	get_coption_help
#define	set_coption_desc   "set compression option of a compressed file"
#define	set_coption_help
#define	decompress_desc   "decompress an already compressed file"
#define	decompress_help   "f2fs_io decompress [file_path]\n\n"
#define	compress_desc   "compress a compression enabled file"
#define	compress_help   "f2fs_io compress [file_path]\n\n"
#define	get_filename_encrypt_mode_desc   "get file name encrypt mode"
#define	get_filename_encrypt_mode_help
#define	rename_desc   "rename source to target file with fsync option"
#define	rename_help
#define	gc_desc   "trigger filesystem GC"
#define	gc_help   "f2fs_io gc sync_mode [file_path]\n\n"
#define	checkpoint_desc   "trigger filesystem checkpoint"
#define	checkpoint_help   "f2fs_io checkpoint [file_path]\n\n"
#define	precache_extents_desc   "trigger precache extents"
#define	precache_extents_help   "f2fs_io precache_extents [file_path]\n\n"
#define	move_range_desc   "moving a range of data blocks from source file to destination file"
#define	move_range_help
#define	gc_range_desc   "trigger filesystem gc_range"
#define	gc_range_help
#define	listxattr_desc   "listxattr"
#define	listxattr_help   "f2fs_io listxattr [file_path]\n\n"
#define	setxattr_desc   "setxattr"
#define	setxattr_help   "f2fs_io setxattr [name] [value] [file_path]\n\n"
#define	removexattr_desc   "removexattr"
#define	removexattr_help   "f2fs_io removexattr [name] [file_path]\n\n"
#define	lseek_desc   "do lseek for a file"
#define	lseek_help
#define	get_advise_desc   "get_advise"
#define	get_advise_help   "f2fs_io get_advise [file_path]\n\n"
#define	ftruncate_desc   "ftruncate a file"
#define	ftruncate_help
#define	CMD_HIDDEN   0x0001
#define	CMD(name)   { #name, do_##name, name##_desc, name##_help, 0 }
#define	_CMD(name)   { #name, do_##name, NULL, NULL, CMD_HIDDEN }

Functions
static void	__attribute__ ((noreturn))
static void	__attribute__ ((noreturn, format(printf, 1, 2)))
static void *	xmalloc (size_t size)
static void *	aligned_xalloc (size_t alignment, size_t size)
static int	xopen (const char *pathname, int flags, mode_t mode)
static ssize_t	xread (int fd, void *buf, size_t count)
static void	full_write (int fd, const void *buf, size_t count)
static u64	get_current_us ()
static void	do_fsync (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_fdatasync (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_set_verity (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_getflags (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_setflags (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_clearflags (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_shutdown (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_fadvise (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_ioprio (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_pinfile (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_fallocate (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_erase (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_write_with_advice (int argc, char **argv, const struct cmd_desc *cmd, bool with_advice)
static void	do_write (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_write_advice (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_read (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_fragread (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_randread (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_fiemap (int UNUSED(argc), char **UNUSED(argv), const struct cmd_desc *UNUSED(cmd))
static void	do_gc_urgent (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_defrag_file (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_copy (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_get_cblocks (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_release_cblocks (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_reserve_cblocks (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_get_coption (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_set_coption (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_decompress (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_compress (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_get_filename_encrypt_mode (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_rename (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_gc (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_checkpoint (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_precache_extents (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_move_range (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_gc_range (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_listxattr (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_setxattr (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_removexattr (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_lseek (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_get_advise (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_ftruncate (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_help (int argc, char **argv, const struct cmd_desc *cmd)
static void	do_help (int argc, char **argv, const struct cmd_desc *UNUSED(cmd))
static void	die_signal_handler (int UNUSED(signum), siginfo_t *UNUSED(siginfo), void *UNUSED(context))
static void	sigcatcher_setup (void)
int	main (int argc, char **argv)

Variables
const struct cmd_desc	cmd_list []

Macro Definition Documentation

__SANE_USERSPACE_TYPES__

#define __SANE_USERSPACE_TYPES__   /* For PPC64, to get LL64 types */

_CMD

#define _CMD

(

name

)

{ #name, do_##name, NULL, NULL, CMD_HIDDEN }

_GNU_SOURCE

#define _GNU_SOURCE

ALLOC_SIZE

#define ALLOC_SIZE   (2 * 1024 * 1024 - 4 * 1024)

checkpoint_desc

#define checkpoint_desc   "trigger filesystem checkpoint"

checkpoint_help

#define checkpoint_help   "f2fs_io checkpoint [file_path]\n\n"

clearflags_desc

#define clearflags_desc   "clearflags ioctl"

clearflags_help

#define clearflags_help

Value:

"f2fs_io clearflags [flag] [file]\n\n"              \
"clear a flag given the file\n"                 \
"flag can be\n"                         \
"  compression\n"                       \
"  nocompression\n"                     \
"  immutable\n"                         \
"  nocow\n"

CMD

#define CMD

(

name

)

{ #name, do_##name, name##_desc, name##_help, 0 }

CMD_HIDDEN

#define CMD_HIDDEN   0x0001

compress_desc

#define compress_desc   "compress a compression enabled file"

compress_help

#define compress_help   "f2fs_io compress [file_path]\n\n"

copy_desc

#define copy_desc   "copy a file"

copy_help

#define copy_help

Value:

"f2fs_io copy [-d] [-m] [-s] src_path dst_path\n\n"         \
"  src_path  : path to source file\n"                   \
"  dst_path  : path to destination file\n"              \
"  -d        : use direct I/O\n"                    \
"  -m        : mmap the source file\n"                  \
"  -s        : use sendfile\n"                      \

decompress_desc

#define decompress_desc   "decompress an already compressed file"

decompress_help

#define decompress_help   "f2fs_io decompress [file_path]\n\n"

defrag_file_desc

#define defrag_file_desc   "do defragment on file"

defrag_file_help

#define defrag_file_help

Value:

"f2fs_io defrag_file [start] [length] [file_path]\n\n"      \
"  start     : start offset of defragment region, unit: bytes\n"    \
"  length    : bytes number of defragment region\n"         \

erase_desc

#define erase_desc   "erase a block device"

erase_help

#define erase_help

Value:

"f2fs_io erase [block_device_path]\n\n"     \
"Send DISCARD | BLKSECDISCARD comamnd to"   \
"block device in block_device_path\n"       \

fadvise_desc

#define fadvise_desc   "fadvise"

fadvise_help

#define fadvise_help

Value:

"f2fs_io fadvise [advice] [offset] [length] [file]\n\n"     \
"fadvice given the file\n"                  \
"advice can be\n"                       \
" willneed\n"                           \
" dontneed\n"                           \
" noreuse\n"                            \
" sequential\n"                         \
" random\n"                         \

fallocate_desc

#define fallocate_desc   "fallocate"

fallocate_help

#define fallocate_help

Value:

"f2fs_io fallocate [-c] [-i] [-p] [-z] [keep_size] [offset] [length] [file]\n\n"    \
"fallocate given the file\n"                    \
" [keep_size] : 1 or 0\n"                   \
" -c : collapse range\n"                    \
" -i : insert range\n"                      \
" -p : punch hole\n"                        \
" -z : zero range\n"                        \

fdatasync_desc

#define fdatasync_desc   "fdatasync"

fdatasync_help

#define fdatasync_help

Value:

"f2fs_io fdatasync [file]\n\n"                  \
"fdatasync given the file\n"                    \

fiemap_desc

#define fiemap_desc   "get block address in file"

fiemap_help

#define fiemap_help   "f2fs_io fiemap [offset in 4kb] [count in 4kb] [file_path]\n\n"\

fragread_desc

#define fragread_desc   "read data with a fragmented buffer from file"

fragread_help

#define fragread_help

Value:

"f2fs_io fragread [chunk_size in 4kb] [offset in chunk_size] [count] [advice] [file_path]\n\n"  \
"Read data in file_path and print nbytes\n"     \
"advice can be\n"                   \
" 1 : set sequential|willneed\n"            \
" 0 : none\n"                       \

fsync_desc

#define fsync_desc   "fsync"

fsync_help

#define fsync_help

Value:

"f2fs_io fsync [file]\n\n"                  \
"fsync given the file\n"                    \

ftruncate_desc

#define ftruncate_desc   "ftruncate a file"

ftruncate_help

#define ftruncate_help

Value:

"f2fs_io ftruncate [length] [file_path]\n\n"    \
"Do ftruncate a file in file_path with the length\n"    \

gc_desc

#define gc_desc   "trigger filesystem GC"

gc_help

#define gc_help   "f2fs_io gc sync_mode [file_path]\n\n"

gc_range_desc

#define gc_range_desc   "trigger filesystem gc_range"

gc_range_help

#define gc_range_help

Value:

"f2fs_io gc_range [sync_mode] [start] [length] [file_path]\n\n"\
"  sync_mode : 0: asynchronous, 1: synchronous\n"           \
"  start     : start offset of defragment region, unit: 4kb\n"  \
"  length    : bytes number of defragment region, unit: 4kb\n"  \

gc_urgent_desc

#define gc_urgent_desc   "start/end/run gc_urgent for given time period"

gc_urgent_help

#define gc_urgent_help

Value:

"f2fs_io gc_urgent $dev [start/end/run] [time in sec]\n\n"\
" - f2fs_io gc_urgent sda21 start\n"        \
" - f2fs_io gc_urgent sda21 end\n"      \
" - f2fs_io gc_urgent sda21 run 10\n"       \

get_advise_desc

#define get_advise_desc   "get_advise"

get_advise_help

#define get_advise_help   "f2fs_io get_advise [file_path]\n\n"

get_cblocks_desc

#define get_cblocks_desc   "get number of reserved blocks on compress inode"

get_cblocks_help

#define get_cblocks_help   "f2fs_io get_cblocks [file]\n\n"

get_coption_desc

#define get_coption_desc   "get compression option of a compressed file"

get_coption_help

#define get_coption_help

Value:

"f2fs_io get_coption [file]\n\n"    \
"  algorithm        : compression algorithm (0:lzo, 1: lz4, 2:zstd, 3:lzorle)\n"    \
"  log_cluster_size : compression cluster log size (2 <= log_size <= 8)\n"

get_filename_encrypt_mode_desc

#define get_filename_encrypt_mode_desc   "get file name encrypt mode"

get_filename_encrypt_mode_help

#define get_filename_encrypt_mode_help

Value:

"f2fs_io filename_encrypt_mode [file or directory path]\n\n"        \
"Get the file name encription mode of the given file/directory.\n"  \

getflags_desc

#define getflags_desc   "getflags ioctl"

getflags_help

#define getflags_help

Value:

"f2fs_io getflags [file]\n\n"                   \
"get a flag given the file\n"                   \
"flag can show \n"                      \
"  encryption\n"                        \
"  nocow(pinned)\n"                     \
"  inline_data\n"                       \
"  verity\n"                            \
"  casefold\n"                          \
"  compression\n"                       \
"  nocompression\n"                     \
"  immutable\n"

ioprio_desc

#define ioprio_desc   "ioprio"

ioprio_help

#define ioprio_help

Value:

"f2fs_io ioprio [hint] [file]\n\n"              \
"ioprio given the file\n"                   \
"hint can be\n"                         \
" ioprio_write\n"                       \

listxattr_desc

#define listxattr_desc   "listxattr"

listxattr_help

#define listxattr_help   "f2fs_io listxattr [file_path]\n\n"

lseek_desc

#define lseek_desc   "do lseek for a file"

lseek_help

#define lseek_help

Value:

"f2fs_io lseek [whence] [offset] [file_path]\n\n"   \
"Do lseek file data in file_path and return the adjusted file offset\n" \
"whence can be\n"                   \
"  set  : SEEK_SET, The file offset is set to offset bytes\n"   \
"  cur  : SEEK_CUR, The file offset is set to its current location plus offset bytes\n" \
"  end  : SEEK_END, The file offset is set to the size of the file plus offset bytes\n" \
"  data : SEEK_DATA, set the file offset to the next data location from offset\n"   \
"  hole : SEEK_HOLE, set the file offset to the next hole from offset\n"

move_range_desc

#define move_range_desc   "moving a range of data blocks from source file to destination file"

move_range_help

#define move_range_help

Value:

"f2fs_io move_range [src_path] [dst_path] [src_start] [dst_start] " \
"[length]\n\n"                              \
"  src_path  : path to source file\n"                   \
"  dst_path  : path to destination file\n"              \
"  src_start : start offset of src file move region, unit: bytes\n" \
"  dst_start : start offset of dst file move region, unit: bytes\n" \
"  length    : size to move\n"                      \

O_LARGEFILE

#define O_LARGEFILE   0

PAGE_SIZE

#define PAGE_SIZE   sysconf(_SC_PAGESIZE)

pinfile_desc

#define pinfile_desc   "pin file control"

pinfile_help

#define pinfile_help

Value:

"f2fs_io pinfile [get|set|unset] [file] {size}\n\n"     \
"get/set/unset pinning given the file\n"            \
"{size} is fallocate length and optional only for set operations\n"

precache_extents_desc

#define precache_extents_desc   "trigger precache extents"

precache_extents_help

#define precache_extents_help   "f2fs_io precache_extents [file_path]\n\n"

randread_desc

#define randread_desc   "random read data from file"

randread_help

#define randread_help

Value:

"f2fs_io randread [chunk_size in 4kb] [count] [IO] [advise] [file_path]\n\n"    \
"Do random read data in file_path\n"        \
"IO can be\n"                       \
"  buffered : buffered IO\n"                \
"  dio      : direct IO\n"              \
"  mmap     : mmap IO\n"                \
"advice can be\n"                   \
" 1 : set random|willneed\n"                \
" 0 : none\n"                       \

read_desc

#define read_desc   "read data from file"

read_help

#define read_help

Value:

"f2fs_io read [chunk_size in 4kb] [offset in chunk_size] [count] [IO] [advice] [print_nbytes] [file_path]\n\n"  \
"Read data in file_path and print nbytes\n"     \
"IO can be\n"                       \
"  buffered : buffered IO\n"                \
"  dio      : direct IO\n"              \
"  mmap     : mmap IO\n"                \
"advice can be\n"                   \
" 1 : set sequential|willneed\n"            \
" 0 : none\n"                       \

release_cblocks_desc

#define release_cblocks_desc   "release reserved blocks on compress inode"

release_cblocks_help

#define release_cblocks_help   "f2fs_io release_cblocks [file]\n\n"

removexattr_desc

#define removexattr_desc   "removexattr"

removexattr_help

#define removexattr_help   "f2fs_io removexattr [name] [file_path]\n\n"

rename_desc

#define rename_desc   "rename source to target file with fsync option"

rename_help

#define rename_help

Value:

"f2fs_io rename [src_path] [target_path] [fsync_after_rename]\n\n"  \
"e.g., f2fs_io rename source dest 1\n"                  \
"      1. open(source)\n"                       \
"      2. rename(source, dest)\n"                   \
"      3. fsync(source)\n"                      \
"      4. close(source)\n"

reserve_cblocks_desc

#define reserve_cblocks_desc   "reserve blocks on compress inode"

reserve_cblocks_help

#define reserve_cblocks_help   "f2fs_io reserve_cblocks [file]\n\n"

set_coption_desc

#define set_coption_desc   "set compression option of a compressed file"

set_coption_help

#define set_coption_help

Value:

"f2fs_io set_coption [algorithm] [log_cluster_size] [file_path]\n\n"    \
"  algorithm        : compression algorithm (0:lzo, 1: lz4, 2:zstd, 3:lzorle)\n"    \
"  log_cluster_size : compression cluster log size (2 <= log_size <= 8)\n"

set_verity_desc

#define set_verity_desc   "Set fs-verity"

set_verity_help

#define set_verity_help

Value:

"f2fs_io set_verity [file]\n\n"             \
"Set fsverity bit given a file\n"           \

setflags_desc

#define setflags_desc   "setflags ioctl"

setflags_help

#define setflags_help

Value:

"f2fs_io setflags [flag] [file]\n\n"                \
"set a flag given the file\n"                   \
"flag can be\n"                         \
"  casefold\n"                          \
"  compression\n"                       \
"  nocompression\n"                     \
"  immutable\n"                         \
"  nocow\n"

setxattr_desc

#define setxattr_desc   "setxattr"

setxattr_help

#define setxattr_help   "f2fs_io setxattr [name] [value] [file_path]\n\n"

shutdown_desc

#define shutdown_desc   "shutdown filesystem"

shutdown_help

#define shutdown_help

Value:

"f2fs_io shutdown [level] [dir]\n\n"            \
"Freeze and stop all IOs given mount point\n"       \
"level can be\n"                    \
"  0 : going down with full sync\n"         \
"  1 : going down with checkpoint only\n"       \
"  2 : going down with no sync\n"           \
"  3 : going down with metadata flush\n"        \
"  4 : going down with fsck mark\n"

write_advice_desc

#define write_advice_desc   "write data into file with a hint"

write_advice_help

#define write_advice_help

Value:

"f2fs_io write_advice [chunk_size in 4kb] [offset in chunk_size] [count] [pattern] [IO] [advise] [file_path] {delay}\n\n"   \
"Write given patten data in file_path\n"        \
"pattern can be\n"                  \
"  zero          : zeros\n"             \
"  inc_num       : incrementing numbers\n"      \
"  rand          : random numbers\n"            \
"IO can be\n"                       \
"  buffered      : buffered IO\n"           \
"  dio           : O_DIRECT\n"              \
"  dsync         : O_DIRECT | O_DSYNC\n"        \
"  osync         : O_SYNC\n"                \
"  atomic_commit : atomic write & commit\n"     \
"  atomic_abort  : atomic write & abort\n"      \
"  atomic_rcommit: atomic replace & commit\n"       \
"  atomic_rabort : atomic replace & abort\n"        \
"advise can be\n"                   \
"  cold : indicate a cold file\n"           \
"  hot  : indicate a hot file\n"            \
"{delay} is in ms unit and optional only for atomic operations\n"

write_desc

#define write_desc   "write data into file"

write_help

#define write_help

Value:

"f2fs_io write [chunk_size in 4kb] [offset in chunk_size] [count] [pattern] [IO] [file_path] {delay}\n\n"   \
"Write given patten data in file_path\n"        \
"pattern can be\n"                  \
"  zero          : zeros\n"             \
"  inc_num       : incrementing numbers\n"      \
"  rand          : random numbers\n"            \
"IO can be\n"                       \
"  buffered      : buffered IO\n"           \
"  dio           : O_DIRECT\n"              \
"  dsync         : O_DIRECT | O_DSYNC\n"        \
"  osync         : O_SYNC\n"                \
"  atomic_commit : atomic write & commit\n"     \
"  atomic_abort  : atomic write & abort\n"      \
"  atomic_rcommit: atomic replace & commit\n"       \
"  atomic_rabort : atomic replace & abort\n"        \
"{delay} is in ms unit and optional only for atomic operations\n"

Function Documentation

__attribute__() [1/2]

static void __attribute__ ( (noreturn)  )

static

__attribute__() [2/2]

static void __attribute__ ( (noreturn, format(printf, 1, 2))  )

static

aligned_xalloc()

static void * aligned_xalloc ( size_t  alignment, size_t  size  )

static

die_signal_handler()

static void die_signal_handler ( int   UNUSEDsignum, siginfo_t *  UNUSEDsiginfo, void *  UNUSEDcontext  )

static

do_checkpoint()

static void do_checkpoint ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_clearflags()

static void do_clearflags ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_compress()

static void do_compress ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_copy()

static void do_copy ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_decompress()

static void do_decompress ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_defrag_file()

static void do_defrag_file ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_erase()

static void do_erase ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_fadvise()

static void do_fadvise ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_fallocate()

static void do_fallocate ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_fdatasync()

static void do_fdatasync ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_fiemap()

static void do_fiemap ( int   UNUSEDargc, char **  UNUSEDargv, const struct cmd_desc *  UNUSEDcmd  )

static

do_fragread()

static void do_fragread ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_fsync()

static void do_fsync ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_ftruncate()

static void do_ftruncate ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_gc()

static void do_gc ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_gc_range()

static void do_gc_range ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_gc_urgent()

static void do_gc_urgent ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_get_advise()

static void do_get_advise ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_get_cblocks()

static void do_get_cblocks ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_get_coption()

static void do_get_coption ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_get_filename_encrypt_mode()

static void do_get_filename_encrypt_mode ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_getflags()

static void do_getflags ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_help() [1/2]

static void do_help ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_help() [2/2]

static void do_help ( int  argc, char **  argv, const struct cmd_desc *  UNUSEDcmd  )

static

do_ioprio()

static void do_ioprio ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_listxattr()

static void do_listxattr ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_lseek()

static void do_lseek ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_move_range()

static void do_move_range ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_pinfile()

static void do_pinfile ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_precache_extents()

static void do_precache_extents ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_randread()

static void do_randread ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_read()

static void do_read ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_release_cblocks()

static void do_release_cblocks ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_removexattr()

static void do_removexattr ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_rename()

static void do_rename ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_reserve_cblocks()

static void do_reserve_cblocks ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_set_coption()

static void do_set_coption ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_set_verity()

static void do_set_verity ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_setflags()

static void do_setflags ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_setxattr()

static void do_setxattr ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_shutdown()

static void do_shutdown ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_write()

static void do_write ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_write_advice()

static void do_write_advice ( int  argc, char **  argv, const struct cmd_desc *  cmd  )

static

do_write_with_advice()

static void do_write_with_advice ( int  argc, char **  argv, const struct cmd_desc *  cmd, bool  with_advice  )

static

full_write()

static void full_write ( int  fd, const void *  buf, size_t  count  )

static

get_current_us()

static u64 get_current_us ( )

static

main()

int main	(	int	argc,
		char **	argv
	)

sigcatcher_setup()

static void sigcatcher_setup ( void  )

static

xmalloc()

static void * xmalloc ( size_t  size )

static

xopen()

static int xopen ( const char *  pathname, int  flags, mode_t  mode  )

static

xread()

static ssize_t xread ( int  fd, void *  buf, size_t  count  )

static

Variable Documentation

cmd_list

const struct cmd_desc cmd_list[]