mirror of
https://github.com/kdave/btrfs-progs
synced 2024-12-27 00:22:22 +00:00
d52686fc2a
Bring the 'delete_subvol_children' function under the HAVE_BTRFSUTIL_H define and fix the following warnings. This function is called only when 'HAVE_BTRFSUTILS_H' is defined. tests/fsstress.c:1183:1: warning: ‘delete_subvol_children’ defined but not used [-Wunused-function] 1183 | delete_subvol_children(int parid Signed-off-by: Anand Jain <anand.jain@oracle.com> Signed-off-by: David Sterba <dsterba@suse.com>
5560 lines
120 KiB
C
5560 lines
120 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (c) 2000-2002 Silicon Graphics, Inc.
|
|
* All Rights Reserved.
|
|
*/
|
|
|
|
/*
|
|
* Copied from fstests/ltp/fsstress.c, modified to make it compile without XFS
|
|
* features and headers
|
|
*/
|
|
|
|
#include <linux/fs.h>
|
|
#include <setjmp.h>
|
|
#include <sys/uio.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <sys/time.h>
|
|
#include <sys/wait.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/param.h>
|
|
#include <malloc.h>
|
|
#include <limits.h>
|
|
#include <dirent.h>
|
|
#include <stddef.h>
|
|
#include <stdbool.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <signal.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <assert.h>
|
|
#include <getopt.h>
|
|
#include "common/internal.h"
|
|
|
|
#define AIO
|
|
#define URING
|
|
|
|
#ifdef HAVE_BTRFSUTIL_H
|
|
#include <btrfsutil.h>
|
|
#endif
|
|
#ifdef HAVE_LINUX_FIEMAP_H
|
|
#include <linux/fiemap.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_PRCTL_H
|
|
#include <sys/prctl.h>
|
|
#endif
|
|
#ifdef AIO
|
|
#include <libaio.h>
|
|
#define AIO_ENTRIES 1
|
|
io_context_t io_ctx;
|
|
#endif
|
|
#ifdef URING
|
|
#include <liburing.h>
|
|
#define URING_ENTRIES 1
|
|
struct io_uring ring;
|
|
bool have_io_uring; /* to indicate runtime availability */
|
|
#endif
|
|
#include <sys/syscall.h>
|
|
#include <sys/xattr.h>
|
|
|
|
#ifndef FS_IOC_GETFLAGS
|
|
#define FS_IOC_GETFLAGS _IOR('f', 1, long)
|
|
#endif
|
|
#ifndef FS_IOC_SETFLAGS
|
|
#define FS_IOC_SETFLAGS _IOW('f', 2, long)
|
|
#endif
|
|
|
|
#include <math.h>
|
|
#define XFS_ERRTAG_MAX 17
|
|
#define XFS_IDMODULO_MAX 31 /* user/group IDs (1 << x) */
|
|
#define XFS_PROJIDMODULO_MAX 16 /* project IDs (1 << x) */
|
|
#ifndef IOV_MAX
|
|
#define IOV_MAX 1024
|
|
#endif
|
|
|
|
#ifndef HAVE_RENAMEAT2
|
|
#if !defined(SYS_renameat2) && defined(__x86_64__)
|
|
#define SYS_renameat2 316
|
|
#endif
|
|
|
|
#if !defined(SYS_renameat2) && defined(__i386__)
|
|
#define SYS_renameat2 353
|
|
#endif
|
|
|
|
#if 0
|
|
static int renameat2(int dfd1, const char *path1,
|
|
int dfd2, const char *path2,
|
|
unsigned int flags)
|
|
{
|
|
#ifdef SYS_renameat2
|
|
return syscall(SYS_renameat2, dfd1, path1, dfd2, path2, flags);
|
|
#else
|
|
errno = ENOSYS;
|
|
return -1;
|
|
#endif
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
static inline unsigned long long
|
|
rounddown_64(unsigned long long x, unsigned int y)
|
|
{
|
|
x /= y;
|
|
return x * y;
|
|
}
|
|
|
|
static inline unsigned long long
|
|
roundup_64(unsigned long long x, unsigned int y)
|
|
{
|
|
return rounddown_64(x + y - 1, y);
|
|
}
|
|
|
|
struct dioattr {
|
|
__u32 d_mem; /* data buffer memory alignment */
|
|
__u32 d_miniosz; /* min xfer size */
|
|
__u32 d_maxiosz; /* max xfer size */
|
|
};
|
|
|
|
#ifndef RENAME_NOREPLACE
|
|
#define RENAME_NOREPLACE (1 << 0) /* Don't overwrite target */
|
|
#endif
|
|
#ifndef RENAME_EXCHANGE
|
|
#define RENAME_EXCHANGE (1 << 1) /* Exchange source and dest */
|
|
#endif
|
|
#ifndef RENAME_WHITEOUT
|
|
#define RENAME_WHITEOUT (1 << 2) /* Whiteout source */
|
|
#endif
|
|
|
|
#define FILELEN_MAX (32*4096)
|
|
|
|
typedef enum {
|
|
OP_AFSYNC,
|
|
/* OP_ALLOCSP, */
|
|
OP_AREAD,
|
|
OP_ATTR_REMOVE,
|
|
OP_ATTR_SET,
|
|
OP_AWRITE,
|
|
/* OP_BULKSTAT, */
|
|
/* OP_BULKSTAT1, */
|
|
OP_CHOWN,
|
|
OP_CLONERANGE,
|
|
OP_COPYRANGE,
|
|
OP_CREAT,
|
|
OP_DEDUPERANGE,
|
|
OP_DREAD,
|
|
OP_DWRITE,
|
|
OP_FALLOCATE,
|
|
OP_FDATASYNC,
|
|
OP_FIEMAP,
|
|
/* OP_FREESP, */
|
|
OP_FSYNC,
|
|
OP_GETATTR,
|
|
OP_GETDENTS,
|
|
OP_GETFATTR,
|
|
OP_LINK,
|
|
OP_LISTFATTR,
|
|
OP_MKDIR,
|
|
OP_MKNOD,
|
|
OP_MREAD,
|
|
OP_MWRITE,
|
|
OP_PUNCH,
|
|
OP_ZERO,
|
|
OP_COLLAPSE,
|
|
OP_INSERT,
|
|
OP_READ,
|
|
OP_READLINK,
|
|
OP_READV,
|
|
OP_REMOVEFATTR,
|
|
OP_RENAME,
|
|
OP_RNOREPLACE,
|
|
OP_REXCHANGE,
|
|
OP_RWHITEOUT,
|
|
/* OP_RESVSP, */
|
|
OP_RMDIR,
|
|
OP_SETATTR,
|
|
OP_SETFATTR,
|
|
OP_SETXATTR,
|
|
OP_SNAPSHOT,
|
|
OP_SPLICE,
|
|
OP_STAT,
|
|
OP_SUBVOL_CREATE,
|
|
OP_SUBVOL_DELETE,
|
|
OP_SYMLINK,
|
|
OP_SYNC,
|
|
OP_TRUNCATE,
|
|
OP_UNLINK,
|
|
/* OP_UNRESVSP, */
|
|
OP_URING_READ,
|
|
OP_URING_WRITE,
|
|
OP_WRITE,
|
|
OP_WRITEV,
|
|
/* OP_XCHGRANGE, */
|
|
OP_LAST
|
|
} opty_t;
|
|
|
|
typedef long long opnum_t;
|
|
|
|
typedef void (*opfnc_t)(opnum_t, long);
|
|
|
|
typedef struct opdesc {
|
|
char *name;
|
|
opfnc_t func;
|
|
int freq;
|
|
int iswrite;
|
|
} opdesc_t;
|
|
|
|
typedef struct fent {
|
|
int id;
|
|
int ft;
|
|
int parent;
|
|
int xattr_counter;
|
|
} fent_t;
|
|
|
|
typedef struct flist {
|
|
int nfiles;
|
|
int nslots;
|
|
int tag;
|
|
fent_t *fents;
|
|
} flist_t;
|
|
|
|
typedef struct pathname {
|
|
int len;
|
|
char *path;
|
|
} pathname_t;
|
|
|
|
struct print_flags {
|
|
unsigned long mask;
|
|
const char *name;
|
|
};
|
|
|
|
struct print_string {
|
|
char *buffer;
|
|
int len;
|
|
int max;
|
|
};
|
|
|
|
#define FT_DIR 0
|
|
#define FT_DIRm (1 << FT_DIR)
|
|
#define FT_REG 1
|
|
#define FT_REGm (1 << FT_REG)
|
|
#define FT_SYM 2
|
|
#define FT_SYMm (1 << FT_SYM)
|
|
#define FT_DEV 3
|
|
#define FT_DEVm (1 << FT_DEV)
|
|
#define FT_RTF 4
|
|
#define FT_RTFm (1 << FT_RTF)
|
|
#define FT_SUBVOL 5
|
|
#define FT_SUBVOLm (1 << FT_SUBVOL)
|
|
#define FT_nft 6
|
|
#define FT_ANYm ((1 << FT_nft) - 1)
|
|
#define FT_REGFILE (FT_REGm | FT_RTFm)
|
|
#define FT_NOTDIR (FT_ANYm & (~FT_DIRm & ~FT_SUBVOLm))
|
|
#define FT_ANYDIR (FT_DIRm | FT_SUBVOLm)
|
|
|
|
#define FLIST_SLOT_INCR 16
|
|
#define NDCACHE 64
|
|
|
|
#define MAXFSIZE ((1ULL << 63) - 1ULL)
|
|
#define MAXFSIZE32 ((1ULL << 40) - 1ULL)
|
|
|
|
#define XATTR_NAME_BUF_SIZE 18
|
|
|
|
void afsync_f(opnum_t, long);
|
|
void aread_f(opnum_t, long);
|
|
void attr_remove_f(opnum_t, long);
|
|
void attr_set_f(opnum_t, long);
|
|
void awrite_f(opnum_t, long);
|
|
/* void bulkstat_f(opnum_t, long); */
|
|
/* void bulkstat1_f(opnum_t, long); */
|
|
void chown_f(opnum_t, long);
|
|
void clonerange_f(opnum_t, long);
|
|
void copyrange_f(opnum_t, long);
|
|
void creat_f(opnum_t, long);
|
|
void deduperange_f(opnum_t, long);
|
|
void dread_f(opnum_t, long);
|
|
void dwrite_f(opnum_t, long);
|
|
void fallocate_f(opnum_t, long);
|
|
void fdatasync_f(opnum_t, long);
|
|
void fiemap_f(opnum_t, long);
|
|
void fsync_f(opnum_t, long);
|
|
char *gen_random_string(int);
|
|
void getattr_f(opnum_t, long);
|
|
void getdents_f(opnum_t, long);
|
|
void getfattr_f(opnum_t, long);
|
|
void link_f(opnum_t, long);
|
|
void listfattr_f(opnum_t, long);
|
|
void mkdir_f(opnum_t, long);
|
|
void mknod_f(opnum_t, long);
|
|
void mread_f(opnum_t, long);
|
|
void mwrite_f(opnum_t, long);
|
|
void punch_f(opnum_t, long);
|
|
void zero_f(opnum_t, long);
|
|
void collapse_f(opnum_t, long);
|
|
void insert_f(opnum_t, long);
|
|
void read_f(opnum_t, long);
|
|
void readlink_f(opnum_t, long);
|
|
void readv_f(opnum_t, long);
|
|
void removefattr_f(opnum_t, long);
|
|
void rename_f(opnum_t, long);
|
|
void rnoreplace_f(opnum_t, long);
|
|
void rexchange_f(opnum_t, long);
|
|
void rwhiteout_f(opnum_t, long);
|
|
/* void resvsp_f(opnum_t, long); */
|
|
void rmdir_f(opnum_t, long);
|
|
void setattr_f(opnum_t, long);
|
|
void setfattr_f(opnum_t, long);
|
|
void setxattr_f(opnum_t, long);
|
|
void snapshot_f(opnum_t, long);
|
|
void splice_f(opnum_t, long);
|
|
void stat_f(opnum_t, long);
|
|
void subvol_create_f(opnum_t, long);
|
|
void subvol_delete_f(opnum_t, long);
|
|
void symlink_f(opnum_t, long);
|
|
void sync_f(opnum_t, long);
|
|
void truncate_f(opnum_t, long);
|
|
void unlink_f(opnum_t, long);
|
|
/* void unresvsp_f(opnum_t, long); */
|
|
void uring_read_f(opnum_t, long);
|
|
void uring_write_f(opnum_t, long);
|
|
void write_f(opnum_t, long);
|
|
void writev_f(opnum_t, long);
|
|
/* void xchgrange_f(opnum_t, long); */
|
|
|
|
char *xattr_flag_to_string(int);
|
|
|
|
struct opdesc ops[OP_LAST] = {
|
|
/* [OP_ENUM] = {"name", function, freq, iswrite }, */
|
|
[OP_AFSYNC] = {"afsync", afsync_f, 0, 1 },
|
|
[OP_AREAD] = {"aread", aread_f, 1, 0 },
|
|
[OP_ATTR_REMOVE] = {"attr_remove", attr_remove_f, 0, 1 },
|
|
[OP_ATTR_SET] = {"attr_set", attr_set_f, 0, 1 },
|
|
[OP_AWRITE] = {"awrite", awrite_f, 1, 1 },
|
|
/* [OP_BULKSTAT] = {"bulkstat", bulkstat_f, 1, 0 }, */
|
|
/* [OP_BULKSTAT1] = {"bulkstat1", bulkstat1_f, 1, 0 }, */
|
|
[OP_CHOWN] = {"chown", chown_f, 3, 1 },
|
|
[OP_CLONERANGE] = {"clonerange", clonerange_f, 4, 1 },
|
|
[OP_COPYRANGE] = {"copyrange", copyrange_f, 4, 1 },
|
|
[OP_CREAT] = {"creat", creat_f, 4, 1 },
|
|
[OP_DEDUPERANGE] = {"deduperange", deduperange_f, 4, 1 },
|
|
[OP_DREAD] = {"dread", dread_f, 4, 0 },
|
|
[OP_DWRITE] = {"dwrite", dwrite_f, 4, 1 },
|
|
[OP_FALLOCATE] = {"fallocate", fallocate_f, 1, 1 },
|
|
[OP_FDATASYNC] = {"fdatasync", fdatasync_f, 1, 1 },
|
|
[OP_FIEMAP] = {"fiemap", fiemap_f, 1, 1 },
|
|
[OP_FSYNC] = {"fsync", fsync_f, 1, 1 },
|
|
[OP_GETATTR] = {"getattr", getattr_f, 1, 0 },
|
|
[OP_GETDENTS] = {"getdents", getdents_f, 1, 0 },
|
|
/* get extended attribute */
|
|
[OP_GETFATTR] = {"getfattr", getfattr_f, 1, 0 },
|
|
[OP_LINK] = {"link", link_f, 1, 1 },
|
|
/* list extent attributes */
|
|
[OP_LISTFATTR] = {"listfattr", listfattr_f, 1, 0 },
|
|
[OP_MKDIR] = {"mkdir", mkdir_f, 2, 1 },
|
|
[OP_MKNOD] = {"mknod", mknod_f, 2, 1 },
|
|
[OP_MREAD] = {"mread", mread_f, 2, 0 },
|
|
[OP_MWRITE] = {"mwrite", mwrite_f, 2, 1 },
|
|
[OP_PUNCH] = {"punch", punch_f, 1, 1 },
|
|
[OP_ZERO] = {"zero", zero_f, 1, 1 },
|
|
[OP_COLLAPSE] = {"collapse", collapse_f, 1, 1 },
|
|
[OP_INSERT] = {"insert", insert_f, 1, 1 },
|
|
[OP_READ] = {"read", read_f, 1, 0 },
|
|
[OP_READLINK] = {"readlink", readlink_f, 1, 0 },
|
|
[OP_READV] = {"readv", readv_f, 1, 0 },
|
|
/* remove (delete) extended attribute */
|
|
[OP_REMOVEFATTR] = {"removefattr", removefattr_f, 1, 1 },
|
|
[OP_RENAME] = {"rename", rename_f, 2, 1 },
|
|
[OP_RNOREPLACE] = {"rnoreplace", rnoreplace_f, 2, 1 },
|
|
[OP_REXCHANGE] = {"rexchange", rexchange_f, 2, 1 },
|
|
[OP_RWHITEOUT] = {"rwhiteout", rwhiteout_f, 2, 1 },
|
|
/* [OP_RESVSP] = {"resvsp", resvsp_f, 1, 1 }, */
|
|
[OP_RMDIR] = {"rmdir", rmdir_f, 1, 1 },
|
|
/* set attribute flag (FS_IOC_SETFLAGS ioctl) */
|
|
[OP_SETATTR] = {"setattr", setattr_f, 0, 1 },
|
|
/* set extended attribute */
|
|
[OP_SETFATTR] = {"setfattr", setfattr_f, 2, 1 },
|
|
/* set project id (XFS_IOC_FSSETXATTR ioctl) */
|
|
[OP_SETXATTR] = {"setxattr", setxattr_f, 1, 1 },
|
|
[OP_SNAPSHOT] = {"snapshot", snapshot_f, 1, 1 },
|
|
[OP_SPLICE] = {"splice", splice_f, 1, 1 },
|
|
[OP_STAT] = {"stat", stat_f, 1, 0 },
|
|
[OP_SUBVOL_CREATE] = {"subvol_create", subvol_create_f, 1, 1 },
|
|
[OP_SUBVOL_DELETE] = {"subvol_delete", subvol_delete_f, 1, 1 },
|
|
[OP_SYMLINK] = {"symlink", symlink_f, 2, 1 },
|
|
[OP_SYNC] = {"sync", sync_f, 1, 1 },
|
|
[OP_TRUNCATE] = {"truncate", truncate_f, 2, 1 },
|
|
[OP_UNLINK] = {"unlink", unlink_f, 1, 1 },
|
|
/* [OP_UNRESVSP] = {"unresvsp", unresvsp_f, 1, 1 }, */
|
|
[OP_URING_READ] = {"uring_read", uring_read_f, 1, 0 },
|
|
[OP_URING_WRITE] = {"uring_write", uring_write_f, 1, 1 },
|
|
[OP_WRITE] = {"write", write_f, 4, 1 },
|
|
[OP_WRITEV] = {"writev", writev_f, 4, 1 },
|
|
/* [OP_XCHGRANGE] = {"xchgrange", xchgrange_f, 2, 1 }, */
|
|
}, *ops_end;
|
|
|
|
flist_t flist[FT_nft] = {
|
|
{ 0, 0, 'd', NULL },
|
|
{ 0, 0, 'f', NULL },
|
|
{ 0, 0, 'l', NULL },
|
|
{ 0, 0, 'c', NULL },
|
|
{ 0, 0, 'r', NULL },
|
|
{ 0, 0, 's', NULL },
|
|
};
|
|
|
|
int dcache[NDCACHE];
|
|
int errrange;
|
|
int errtag;
|
|
opty_t *freq_table;
|
|
int freq_table_size;
|
|
/* struct xfs_fsop_geom geom; */
|
|
char *homedir;
|
|
int *ilist;
|
|
int ilistlen;
|
|
off64_t maxfsize;
|
|
char *myprog;
|
|
int namerand;
|
|
int nameseq;
|
|
int nops;
|
|
int nproc = 1;
|
|
opnum_t operations = 1;
|
|
unsigned int idmodulo = XFS_IDMODULO_MAX;
|
|
unsigned int attr_mask = ~0;
|
|
int procid;
|
|
int rtpct;
|
|
unsigned long seed = 0;
|
|
ino_t top_ino;
|
|
int cleanup = 0;
|
|
int verbose = 0;
|
|
int verifiable_log = 0;
|
|
sig_atomic_t should_stop = 0;
|
|
sigjmp_buf *sigbus_jmp = NULL;
|
|
char *execute_cmd = NULL;
|
|
int execute_freq = 1;
|
|
struct print_string flag_str = {0};
|
|
|
|
struct timespec deadline = { 0 };
|
|
|
|
void add_to_flist(int, int, int, int);
|
|
void append_pathname(pathname_t *, char *);
|
|
int attr_list_path(pathname_t *, char *, const int);
|
|
int attr_remove_path(pathname_t *, const char *);
|
|
int attr_set_path(pathname_t *, const char *, const char *, const int);
|
|
void check_cwd(void);
|
|
void cleanup_flist(void);
|
|
int creat_path(pathname_t *, mode_t);
|
|
void dcache_enter(int, int);
|
|
void dcache_init(void);
|
|
fent_t *dcache_lookup(int);
|
|
void dcache_purge(int, int);
|
|
void del_from_flist(int, int);
|
|
int dirid_to_name(char *, int);
|
|
void doproc(void);
|
|
int fent_to_name(pathname_t *, fent_t *);
|
|
bool fents_ancestor_check(fent_t *, fent_t *);
|
|
void fix_parent(int, int, bool);
|
|
void free_pathname(pathname_t *);
|
|
int generate_fname(fent_t *, int, pathname_t *, int *, int *);
|
|
int generate_xattr_name(int, char *, int);
|
|
int get_fname(int, long, pathname_t *, flist_t **, fent_t **, int *);
|
|
void init_pathname(pathname_t *);
|
|
int lchown_path(pathname_t *, uid_t, gid_t);
|
|
int link_path(pathname_t *, pathname_t *);
|
|
int lstat64_path(pathname_t *, struct stat64 *);
|
|
void make_freq_table(void);
|
|
int mkdir_path(pathname_t *, mode_t);
|
|
int mknod_path(pathname_t *, mode_t, dev_t);
|
|
void namerandpad(int, char *, int);
|
|
int open_file_or_dir(pathname_t *, int);
|
|
int open_path(pathname_t *, int);
|
|
DIR *opendir_path(pathname_t *);
|
|
void process_freq(char *);
|
|
int readlink_path(pathname_t *, char *, size_t);
|
|
int rename_path(pathname_t *, pathname_t *, int);
|
|
int rmdir_path(pathname_t *);
|
|
void separate_pathname(pathname_t *, char *, pathname_t *);
|
|
void show_ops(int, char *);
|
|
int stat64_path(pathname_t *, struct stat64 *);
|
|
int symlink_path(const char *, pathname_t *);
|
|
int truncate64_path(pathname_t *, off64_t);
|
|
int unlink_path(pathname_t *);
|
|
void usage(void);
|
|
void read_freq(void);
|
|
void write_freq(void);
|
|
void zero_freq(void);
|
|
void non_btrfs_freq(const char *);
|
|
|
|
static void sg_handler(int signum)
|
|
{
|
|
switch (signum) {
|
|
case SIGTERM:
|
|
should_stop = 1;
|
|
break;
|
|
case SIGBUS:
|
|
/*
|
|
* Only handle SIGBUS when mmap write to a hole and no
|
|
* block can be allocated due to ENOSPC, abort otherwise.
|
|
*/
|
|
if (sigbus_jmp) {
|
|
siglongjmp(*sigbus_jmp, -1);
|
|
} else {
|
|
printf("Unknown SIGBUS is caught, Abort!\n");
|
|
abort();
|
|
}
|
|
/* should not reach here */
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static bool
|
|
keep_looping(int i, int loops)
|
|
{
|
|
int ret;
|
|
|
|
if (deadline.tv_nsec) {
|
|
struct timespec now;
|
|
|
|
ret = clock_gettime(CLOCK_MONOTONIC, &now);
|
|
if (ret) {
|
|
perror("CLOCK_MONOTONIC");
|
|
return false;
|
|
}
|
|
|
|
return now.tv_sec <= deadline.tv_sec;
|
|
}
|
|
|
|
if (!loops)
|
|
return true;
|
|
|
|
return i < loops;
|
|
}
|
|
|
|
static struct option longopts[] = {
|
|
{"duration", optional_argument, 0, 256},
|
|
{ }
|
|
};
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
char buf[10];
|
|
int c;
|
|
char *dirname = NULL;
|
|
char *logname = NULL;
|
|
char rpath[PATH_MAX];
|
|
int fd;
|
|
int i;
|
|
/* int j; */
|
|
char *p;
|
|
int stat;
|
|
struct timeval t;
|
|
/* ptrdiff_t srval; */
|
|
int nousage = 0;
|
|
/* xfs_error_injection_t err_inj; */
|
|
struct sigaction action;
|
|
int loops = 1;
|
|
const char *allopts = "cd:e:f:i:l:m:M:n:o:p:rRs:S:vVwx:X:zH";
|
|
long long duration;
|
|
|
|
errrange = errtag = 0;
|
|
umask(0);
|
|
nops = sizeof(ops) / sizeof(ops[0]);
|
|
ops_end = &ops[nops];
|
|
myprog = argv[0];
|
|
while ((c = getopt_long(argc, argv, allopts, longopts, NULL)) != -1) {
|
|
switch (c) {
|
|
case 'c':
|
|
cleanup = 1;
|
|
break;
|
|
case 'd':
|
|
dirname = optarg;
|
|
break;
|
|
case 'e':
|
|
sscanf(optarg, "%d", &errtag);
|
|
if (errtag < 0) {
|
|
errtag = -errtag;
|
|
errrange = 1;
|
|
} else if (errtag == 0)
|
|
errtag = -1;
|
|
if (errtag >= XFS_ERRTAG_MAX) {
|
|
fprintf(stderr,
|
|
"error tag %d too large (max %d)\n",
|
|
errtag, XFS_ERRTAG_MAX - 1);
|
|
exit(1);
|
|
}
|
|
break;
|
|
case 'f':
|
|
process_freq(optarg);
|
|
break;
|
|
case 'i':
|
|
ilist = realloc(ilist, ++ilistlen * sizeof(*ilist));
|
|
ilist[ilistlen - 1] = strtol(optarg, &p, 16);
|
|
break;
|
|
case 'm':
|
|
idmodulo = strtoul(optarg, NULL, 0);
|
|
if (idmodulo > XFS_IDMODULO_MAX) {
|
|
fprintf(stderr,
|
|
"chown modulo %d too big (max %d)\n",
|
|
idmodulo, XFS_IDMODULO_MAX);
|
|
exit(1);
|
|
}
|
|
break;
|
|
case 'l':
|
|
loops = atoi(optarg);
|
|
break;
|
|
case 'n':
|
|
errno = 0;
|
|
operations = strtoll(optarg, NULL, 0);
|
|
if (errno) {
|
|
perror(optarg);
|
|
exit(1);
|
|
}
|
|
break;
|
|
case 'o':
|
|
logname = optarg;
|
|
break;
|
|
|
|
case 'p':
|
|
nproc = atoi(optarg);
|
|
break;
|
|
case 'r':
|
|
namerand = 1;
|
|
break;
|
|
case 'R':
|
|
read_freq();
|
|
break;
|
|
case 's':
|
|
seed = strtoul(optarg, NULL, 0);
|
|
break;
|
|
case 'v':
|
|
verbose = 1;
|
|
break;
|
|
case 'w':
|
|
write_freq();
|
|
break;
|
|
case 'x':
|
|
execute_cmd = optarg;
|
|
break;
|
|
case 'z':
|
|
zero_freq();
|
|
break;
|
|
case 'M':
|
|
attr_mask = strtoul(optarg, NULL, 0);
|
|
break;
|
|
case 'S':
|
|
i = 0;
|
|
if (optarg[0] == 'c')
|
|
i = 1;
|
|
show_ops(i, NULL);
|
|
printf("\n");
|
|
nousage=1;
|
|
break;
|
|
case 'V':
|
|
verifiable_log = 1;
|
|
break;
|
|
|
|
case 'X':
|
|
execute_freq = strtoul(optarg, NULL, 0);
|
|
break;
|
|
case 256: /* --duration */
|
|
if (!optarg) {
|
|
fprintf(stderr, "Specify time with --duration=\n");
|
|
exit(87);
|
|
}
|
|
duration = strtoll(optarg, NULL, 0);
|
|
if (duration < 1) {
|
|
fprintf(stderr, "%lld: invalid duration\n", duration);
|
|
exit(88);
|
|
}
|
|
|
|
i = clock_gettime(CLOCK_MONOTONIC, &deadline);
|
|
if (i) {
|
|
perror("CLOCK_MONOTONIC");
|
|
exit(89);
|
|
}
|
|
|
|
deadline.tv_sec += duration;
|
|
deadline.tv_nsec = 1;
|
|
break;
|
|
case '?':
|
|
fprintf(stderr, "%s - invalid parameters\n",
|
|
myprog);
|
|
/* fall through */
|
|
case 'H':
|
|
usage();
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
if (!dirname) {
|
|
/* no directory specified */
|
|
if (!nousage) usage();
|
|
exit(1);
|
|
}
|
|
|
|
non_btrfs_freq(dirname);
|
|
(void)mkdir(dirname, 0777);
|
|
if (logname && logname[0] != '/') {
|
|
if (!getcwd(rpath, sizeof(rpath))){
|
|
perror("getcwd failed");
|
|
exit(1);
|
|
}
|
|
} else {
|
|
rpath[0] = '\0';
|
|
}
|
|
if (chdir(dirname) < 0) {
|
|
perror(dirname);
|
|
exit(1);
|
|
}
|
|
if (logname) {
|
|
char path[PATH_MAX + NAME_MAX + 1];
|
|
snprintf(path, sizeof(path), "%s/%s", rpath, logname);
|
|
if (freopen(path, "a", stdout) == NULL) {
|
|
perror("freopen logfile failed");
|
|
exit(1);
|
|
}
|
|
}
|
|
sprintf(buf, "fss%x", (unsigned int)getpid());
|
|
fd = creat(buf, 0666);
|
|
if (lseek64(fd, (off64_t)(MAXFSIZE32 + 1ULL), SEEK_SET) < 0)
|
|
maxfsize = (off64_t)MAXFSIZE32;
|
|
else
|
|
maxfsize = (off64_t)MAXFSIZE;
|
|
make_freq_table();
|
|
dcache_init();
|
|
setlinebuf(stdout);
|
|
if (!seed) {
|
|
gettimeofday(&t, (void *)NULL);
|
|
seed = (int)t.tv_sec ^ (int)t.tv_usec;
|
|
printf("seed = %ld\n", seed);
|
|
}
|
|
#if 0
|
|
i = xfsctl(buf, fd, XFS_IOC_FSGEOMETRY, &geom);
|
|
if (i >= 0 && geom.rtblocks)
|
|
rtpct = MIN(MAX(geom.rtblocks * 100 /
|
|
(geom.rtblocks + geom.datablocks), 1), 99);
|
|
else
|
|
rtpct = 0;
|
|
if (errtag != 0) {
|
|
if (errrange == 0) {
|
|
if (errtag <= 0) {
|
|
srandom(seed);
|
|
j = random() % 100;
|
|
|
|
for (i = 0; i < j; i++)
|
|
(void) random();
|
|
|
|
errtag = (random() % (XFS_ERRTAG_MAX-1)) + 1;
|
|
}
|
|
} else {
|
|
srandom(seed);
|
|
j = random() % 100;
|
|
|
|
for (i = 0; i < j; i++)
|
|
(void) random();
|
|
|
|
errtag += (random() % (XFS_ERRTAG_MAX - errtag));
|
|
}
|
|
printf("Injecting failure on tag #%d\n", errtag);
|
|
err_inj.errtag = errtag;
|
|
err_inj.fd = fd;
|
|
srval = xfsctl(buf, fd, XFS_IOC_ERROR_INJECTION, &err_inj);
|
|
if (srval < -1) {
|
|
perror("fsstress - XFS_SYSSGI error injection call");
|
|
close(fd);
|
|
unlink(buf);
|
|
exit(1);
|
|
}
|
|
} else
|
|
close(fd);
|
|
#endif
|
|
|
|
setpgid(0, 0);
|
|
action.sa_handler = sg_handler;
|
|
sigemptyset(&action.sa_mask);
|
|
action.sa_flags = 0;
|
|
if (sigaction(SIGTERM, &action, 0)) {
|
|
perror("sigaction failed");
|
|
exit(1);
|
|
}
|
|
|
|
for (i = 0; i < nproc; i++) {
|
|
if (fork() == 0) {
|
|
sigemptyset(&action.sa_mask);
|
|
action.sa_handler = SIG_DFL;
|
|
if (sigaction(SIGTERM, &action, 0))
|
|
return 1;
|
|
action.sa_handler = sg_handler;
|
|
if (sigaction(SIGBUS, &action, 0))
|
|
return 1;
|
|
#ifdef HAVE_SYS_PRCTL_H
|
|
prctl(PR_SET_PDEATHSIG, SIGKILL);
|
|
if (getppid() == 1) /* parent died already? */
|
|
return 0;
|
|
#endif
|
|
if (logname) {
|
|
char path[PATH_MAX + NAME_MAX + 2 + 11];
|
|
snprintf(path, sizeof(path), "%s/%s.%d",
|
|
rpath, logname, i);
|
|
if (freopen(path, "a", stdout) == NULL) {
|
|
perror("freopen logfile failed");
|
|
exit(1);
|
|
}
|
|
}
|
|
procid = i;
|
|
#ifdef AIO
|
|
if (io_setup(AIO_ENTRIES, &io_ctx) != 0) {
|
|
fprintf(stderr, "io_setup failed\n");
|
|
exit(1);
|
|
}
|
|
#endif
|
|
#ifdef URING
|
|
have_io_uring = true;
|
|
/* If ENOSYS, just ignore uring, other errors are fatal. */
|
|
if (io_uring_queue_init(URING_ENTRIES, &ring, 0)) {
|
|
if (errno == ENOSYS) {
|
|
have_io_uring = false;
|
|
} else {
|
|
fprintf(stderr, "io_uring_queue_init failed\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
#endif
|
|
for (i = 0; keep_looping(i, loops); i++)
|
|
doproc();
|
|
#ifdef AIO
|
|
if(io_destroy(io_ctx) != 0) {
|
|
fprintf(stderr, "io_destroy failed");
|
|
return 1;
|
|
}
|
|
#endif
|
|
#ifdef URING
|
|
if (have_io_uring)
|
|
io_uring_queue_exit(&ring);
|
|
#endif
|
|
cleanup_flist();
|
|
free(freq_table);
|
|
return 0;
|
|
}
|
|
}
|
|
while (wait(&stat) > 0 && !should_stop) {
|
|
continue;
|
|
}
|
|
action.sa_flags = SA_RESTART;
|
|
sigaction(SIGTERM, &action, 0);
|
|
kill(-getpid(), SIGTERM);
|
|
while (wait(&stat) > 0)
|
|
continue;
|
|
|
|
#if 0
|
|
if (errtag != 0) {
|
|
err_inj.errtag = 0;
|
|
err_inj.fd = fd;
|
|
srval = xfsctl(buf, fd, XFS_IOC_ERROR_CLEARALL, &err_inj);
|
|
if (srval != 0) {
|
|
fprintf(stderr, "Bad ej clear on %s fd=%d (%d).\n",
|
|
buf, fd, errno);
|
|
perror("xfsctl(XFS_IOC_ERROR_CLEARALL)");
|
|
close(fd);
|
|
exit(1);
|
|
}
|
|
close(fd);
|
|
}
|
|
#endif
|
|
|
|
free(freq_table);
|
|
unlink(buf);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
add_string(struct print_string *str, const char *add)
|
|
{
|
|
int len = strlen(add);
|
|
|
|
if (len <= 0)
|
|
return 0;
|
|
|
|
if (len > (str->max - 1) - str->len) {
|
|
str->len = str->max - 1;
|
|
return 0;
|
|
}
|
|
|
|
memcpy(str->buffer + str->len, add, len);
|
|
str->len += len;
|
|
str->buffer[str->len] = '\0';
|
|
|
|
return len;
|
|
}
|
|
|
|
static char *
|
|
translate_flags(int flags, const char *delim,
|
|
const struct print_flags *flag_array)
|
|
{
|
|
int i, mask, first = 1;
|
|
const char *add;
|
|
|
|
if (!flag_str.buffer) {
|
|
flag_str.buffer = malloc(4096);
|
|
flag_str.max = 4096;
|
|
flag_str.len = 0;
|
|
}
|
|
if (!flag_str.buffer)
|
|
return NULL;
|
|
flag_str.len = 0;
|
|
flag_str.buffer[0] = '\0';
|
|
|
|
for (i = 0; flag_array[i].name && flags; i++) {
|
|
mask = flag_array[i].mask;
|
|
if ((flags & mask) != mask)
|
|
continue;
|
|
|
|
add = flag_array[i].name;
|
|
flags &= ~mask;
|
|
if (!first && delim)
|
|
add_string(&flag_str, delim);
|
|
else
|
|
first = 0;
|
|
add_string(&flag_str, add);
|
|
}
|
|
|
|
/* Check whether there are any leftover flags. */
|
|
if (flags) {
|
|
int ret;
|
|
char number[11];
|
|
|
|
if (!first && delim)
|
|
add_string(&flag_str, delim);
|
|
|
|
ret = snprintf(number, 11, "0x%x", flags) > 0;
|
|
if (ret > 0 && ret <= 11)
|
|
add_string(&flag_str, number);
|
|
}
|
|
|
|
return flag_str.buffer;
|
|
}
|
|
|
|
void
|
|
add_to_flist(int ft, int id, int parent, int xattr_counter)
|
|
{
|
|
fent_t *fep;
|
|
flist_t *ftp;
|
|
|
|
ftp = &flist[ft];
|
|
if (ftp->nfiles == ftp->nslots) {
|
|
ftp->nslots += FLIST_SLOT_INCR;
|
|
ftp->fents = realloc(ftp->fents, ftp->nslots * sizeof(fent_t));
|
|
}
|
|
fep = &ftp->fents[ftp->nfiles++];
|
|
fep->id = id;
|
|
fep->ft = ft;
|
|
fep->parent = parent;
|
|
fep->xattr_counter = xattr_counter;
|
|
}
|
|
|
|
void
|
|
append_pathname(pathname_t *name, char *str)
|
|
{
|
|
int len;
|
|
|
|
len = strlen(str);
|
|
#ifdef DEBUG
|
|
/* attempting to append to a dir a zero length path */
|
|
if (len && *str == '/' && name->len == 0) {
|
|
fprintf(stderr, "fsstress: append_pathname failure\n");
|
|
assert(chdir(homedir) == 0);
|
|
abort();
|
|
/* NOTREACHED */
|
|
}
|
|
#endif
|
|
name->path = realloc(name->path, name->len + 1 + len);
|
|
strcpy(&name->path[name->len], str);
|
|
name->len += len;
|
|
}
|
|
|
|
static int
|
|
attr_list_count(char *buffer, int buffersize)
|
|
{
|
|
char *p = buffer;
|
|
char *end = buffer + buffersize;
|
|
int count = 0;
|
|
|
|
while (p < end && *p != 0) {
|
|
count++;
|
|
p += strlen(p) + 1;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
int
|
|
attr_list_path(pathname_t *name,
|
|
char *buffer,
|
|
const int buffersize)
|
|
{
|
|
char buf[NAME_MAX + 1];
|
|
pathname_t newname;
|
|
int rval;
|
|
|
|
rval = llistxattr(name->path, buffer, buffersize);
|
|
if (rval >= 0 || errno != ENAMETOOLONG)
|
|
return rval;
|
|
separate_pathname(name, buf, &newname);
|
|
if (chdir(buf) == 0) {
|
|
rval = attr_list_path(&newname, buffer, buffersize);
|
|
assert(chdir("..") == 0);
|
|
}
|
|
free_pathname(&newname);
|
|
return rval;
|
|
}
|
|
|
|
int
|
|
attr_remove_path(pathname_t *name, const char *attrname)
|
|
{
|
|
char buf[NAME_MAX + 1];
|
|
pathname_t newname;
|
|
int rval;
|
|
|
|
rval = lremovexattr(name->path, attrname);
|
|
if (rval >= 0 || errno != ENAMETOOLONG)
|
|
return rval;
|
|
separate_pathname(name, buf, &newname);
|
|
if (chdir(buf) == 0) {
|
|
rval = attr_remove_path(&newname, attrname);
|
|
assert(chdir("..") == 0);
|
|
}
|
|
free_pathname(&newname);
|
|
return rval;
|
|
}
|
|
|
|
int
|
|
attr_set_path(pathname_t *name, const char *attrname, const char *attrvalue,
|
|
const int valuelength)
|
|
{
|
|
char buf[NAME_MAX + 1];
|
|
pathname_t newname;
|
|
int rval;
|
|
|
|
rval = lsetxattr(name->path, attrname, attrvalue, valuelength, 0);
|
|
if (rval >= 0 || errno != ENAMETOOLONG)
|
|
return rval;
|
|
separate_pathname(name, buf, &newname);
|
|
if (chdir(buf) == 0) {
|
|
rval = attr_set_path(&newname, attrname, attrvalue,
|
|
valuelength);
|
|
assert(chdir("..") == 0);
|
|
}
|
|
free_pathname(&newname);
|
|
return rval;
|
|
}
|
|
|
|
void
|
|
check_cwd(void)
|
|
{
|
|
#ifdef DEBUG
|
|
struct stat64 statbuf;
|
|
int ret;
|
|
|
|
ret = stat64(".", &statbuf);
|
|
if (ret != 0) {
|
|
fprintf(stderr, "fsstress: check_cwd stat64() returned %d with errno: %d (%s)\n",
|
|
ret, errno, strerror(errno));
|
|
goto out;
|
|
}
|
|
|
|
if (statbuf.st_ino == top_ino)
|
|
return;
|
|
|
|
fprintf(stderr, "fsstress: check_cwd statbuf.st_ino (%llu) != top_ino (%llu)\n",
|
|
(unsigned long long) statbuf.st_ino,
|
|
(unsigned long long) top_ino);
|
|
out:
|
|
assert(chdir(homedir) == 0);
|
|
fprintf(stderr, "fsstress: check_cwd failure\n");
|
|
abort();
|
|
/* NOTREACHED */
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* go thru flist and release all entries
|
|
*
|
|
* NOTE: this function shouldn't be called until the end of a process
|
|
*/
|
|
void
|
|
cleanup_flist(void)
|
|
{
|
|
flist_t *flp;
|
|
int i;
|
|
|
|
for (i = 0, flp = flist; i < FT_nft; i++, flp++) {
|
|
flp->nslots = 0;
|
|
flp->nfiles = 0;
|
|
free(flp->fents);
|
|
flp->fents = NULL;
|
|
}
|
|
}
|
|
|
|
int
|
|
creat_path(pathname_t *name, mode_t mode)
|
|
{
|
|
char buf[NAME_MAX + 1];
|
|
pathname_t newname;
|
|
int rval;
|
|
|
|
rval = creat(name->path, mode);
|
|
if (rval >= 0 || errno != ENAMETOOLONG)
|
|
return rval;
|
|
separate_pathname(name, buf, &newname);
|
|
if (chdir(buf) == 0) {
|
|
rval = creat_path(&newname, mode);
|
|
assert(chdir("..") == 0);
|
|
}
|
|
free_pathname(&newname);
|
|
return rval;
|
|
}
|
|
|
|
void
|
|
dcache_enter(int dirid, int slot)
|
|
{
|
|
dcache[dirid % NDCACHE] = slot;
|
|
}
|
|
|
|
void
|
|
dcache_init(void)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < NDCACHE; i++)
|
|
dcache[i] = -1;
|
|
}
|
|
|
|
fent_t *
|
|
dcache_lookup(int dirid)
|
|
{
|
|
fent_t *fep;
|
|
int i;
|
|
|
|
i = dcache[dirid % NDCACHE];
|
|
if (i >= 0 && i < flist[FT_DIR].nfiles &&
|
|
(fep = &flist[FT_DIR].fents[i])->id == dirid)
|
|
return fep;
|
|
if (i >= 0 && i < flist[FT_SUBVOL].nfiles &&
|
|
(fep = &flist[FT_SUBVOL].fents[i])->id == dirid)
|
|
return fep;
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
dcache_purge(int dirid, int ft)
|
|
{
|
|
int *dcp;
|
|
dcp = &dcache[dirid % NDCACHE];
|
|
if (*dcp >= 0 && *dcp < flist[ft].nfiles &&
|
|
flist[ft].fents[*dcp].id == dirid)
|
|
*dcp = -1;
|
|
}
|
|
|
|
/*
|
|
* Delete the item from the list by
|
|
* moving last entry over the deleted one;
|
|
* unless deleted entry is the last one.
|
|
* Input: which file list array and which slot in array
|
|
*/
|
|
void
|
|
del_from_flist(int ft, int slot)
|
|
{
|
|
flist_t *ftp;
|
|
|
|
ftp = &flist[ft];
|
|
if (ft == FT_DIR || ft == FT_SUBVOL)
|
|
dcache_purge(ftp->fents[slot].id, ft);
|
|
if (slot != ftp->nfiles - 1) {
|
|
if (ft == FT_DIR || ft == FT_SUBVOL)
|
|
dcache_purge(ftp->fents[ftp->nfiles - 1].id, ft);
|
|
ftp->fents[slot] = ftp->fents[--ftp->nfiles];
|
|
} else
|
|
ftp->nfiles--;
|
|
}
|
|
|
|
#ifdef HAVE_BTRFSUTIL_H
|
|
static void
|
|
delete_subvol_children(int parid)
|
|
{
|
|
flist_t *flp;
|
|
int i;
|
|
again:
|
|
for (i = 0, flp = flist; i < FT_nft; i++, flp++) {
|
|
int c;
|
|
for (c = 0; c < flp->nfiles; c++) {
|
|
if (flp->fents[c].parent == parid) {
|
|
int id = flp->fents[c].id;
|
|
del_from_flist(i, c);
|
|
if (i == FT_DIR || i == FT_SUBVOL)
|
|
delete_subvol_children(id);
|
|
goto again;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static fent_t *
|
|
dirid_to_fent(int dirid)
|
|
{
|
|
fent_t *efep;
|
|
fent_t *fep;
|
|
flist_t *flp;
|
|
int ft = FT_DIR;
|
|
|
|
if ((fep = dcache_lookup(dirid)))
|
|
return fep;
|
|
again:
|
|
flp = &flist[ft];
|
|
for (fep = flp->fents, efep = &fep[flp->nfiles]; fep < efep; fep++) {
|
|
if (fep->id == dirid) {
|
|
dcache_enter(dirid, fep - flp->fents);
|
|
return fep;
|
|
}
|
|
}
|
|
if (ft == FT_DIR) {
|
|
ft = FT_SUBVOL;
|
|
goto again;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static bool
|
|
keep_running(opnum_t opno, opnum_t operations)
|
|
{
|
|
int ret;
|
|
|
|
if (deadline.tv_nsec) {
|
|
struct timespec now;
|
|
|
|
ret = clock_gettime(CLOCK_MONOTONIC, &now);
|
|
if (ret) {
|
|
perror("CLOCK_MONOTONIC");
|
|
return false;
|
|
}
|
|
|
|
return now.tv_sec <= deadline.tv_sec;
|
|
}
|
|
|
|
return opno < operations;
|
|
}
|
|
|
|
void
|
|
doproc(void)
|
|
{
|
|
struct stat64 statbuf;
|
|
char buf[10];
|
|
char cmd[64];
|
|
opnum_t opno;
|
|
int rval;
|
|
opdesc_t *p;
|
|
long long dividend;
|
|
|
|
dividend = (operations + execute_freq) / (execute_freq + 1);
|
|
sprintf(buf, "p%x", procid);
|
|
(void)mkdir(buf, 0777);
|
|
if (chdir(buf) < 0 || stat64(".", &statbuf) < 0) {
|
|
perror(buf);
|
|
_exit(1);
|
|
}
|
|
top_ino = statbuf.st_ino;
|
|
homedir = getcwd(NULL, 0);
|
|
if (!homedir) {
|
|
perror("getcwd failed");
|
|
_exit(1);
|
|
}
|
|
seed += procid;
|
|
srandom(seed);
|
|
if (namerand)
|
|
namerand = random();
|
|
for (opno = 0; keep_running(opno, operations); opno++) {
|
|
if (execute_cmd && opno && opno % dividend == 0) {
|
|
if (verbose)
|
|
printf("%lld: execute command %s\n", opno,
|
|
execute_cmd);
|
|
rval = system(execute_cmd);
|
|
if (rval)
|
|
fprintf(stderr, "execute command failed with "
|
|
"%d\n", rval);
|
|
}
|
|
p = &ops[freq_table[random() % freq_table_size]];
|
|
p->func(opno, random());
|
|
/*
|
|
* test for forced shutdown by stat'ing the test
|
|
* directory. If this stat returns EIO, assume
|
|
* the forced shutdown happened.
|
|
*/
|
|
if (errtag != 0 && opno % 100 == 0) {
|
|
rval = stat64(".", &statbuf);
|
|
if (rval == EIO) {
|
|
fprintf(stderr, "Detected EIO\n");
|
|
goto errout;
|
|
}
|
|
}
|
|
}
|
|
errout:
|
|
assert(chdir("..") == 0);
|
|
free(homedir);
|
|
if (cleanup) {
|
|
int ret;
|
|
|
|
sprintf(cmd, "rm -rf %s", buf);
|
|
ret = system(cmd);
|
|
if (ret != 0)
|
|
perror("cleaning up");
|
|
cleanup_flist();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* build up a pathname going thru the file entry and all
|
|
* its parent entries
|
|
* Return 0 on error, 1 on success;
|
|
*/
|
|
int
|
|
fent_to_name(pathname_t *name, fent_t *fep)
|
|
{
|
|
flist_t *flp = &flist[fep->ft];
|
|
char buf[NAME_MAX + 1];
|
|
int i;
|
|
fent_t *pfep;
|
|
int e;
|
|
|
|
if (fep == NULL)
|
|
return 0;
|
|
|
|
/* build up parent directory name */
|
|
if (fep->parent != -1) {
|
|
pfep = dirid_to_fent(fep->parent);
|
|
#ifdef DEBUG
|
|
if (pfep == NULL) {
|
|
fprintf(stderr, "%d: fent-id = %d: can't find parent id: %d\n",
|
|
procid, fep->id, fep->parent);
|
|
}
|
|
#endif
|
|
if (pfep == NULL)
|
|
return 0;
|
|
e = fent_to_name(name, pfep);
|
|
if (!e)
|
|
return 0;
|
|
append_pathname(name, "/");
|
|
}
|
|
|
|
i = sprintf(buf, "%c%x", flp->tag, fep->id);
|
|
namerandpad(fep->id, buf, i);
|
|
append_pathname(name, buf);
|
|
return 1;
|
|
}
|
|
|
|
bool
|
|
fents_ancestor_check(fent_t *fep, fent_t *dfep)
|
|
{
|
|
fent_t *tmpfep;
|
|
|
|
for (tmpfep = fep; tmpfep->parent != -1;
|
|
tmpfep = dirid_to_fent(tmpfep->parent)) {
|
|
if (tmpfep->parent == dfep->id)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void
|
|
fix_parent(int oldid, int newid, bool swap)
|
|
{
|
|
fent_t *fep;
|
|
flist_t *flp;
|
|
int i;
|
|
int j;
|
|
|
|
for (i = 0, flp = flist; i < FT_nft; i++, flp++) {
|
|
for (j = 0, fep = flp->fents; j < flp->nfiles; j++, fep++) {
|
|
if (fep->parent == oldid)
|
|
fep->parent = newid;
|
|
else if (swap && fep->parent == newid)
|
|
fep->parent = oldid;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
free_pathname(pathname_t *name)
|
|
{
|
|
if (name->path) {
|
|
free(name->path);
|
|
name->path = NULL;
|
|
name->len = 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Generate a filename of type ft.
|
|
* If we have a fep which should be a directory then use it
|
|
* as the parent path for this new filename i.e. prepend with it.
|
|
*/
|
|
int
|
|
generate_fname(fent_t *fep, int ft, pathname_t *name, int *idp, int *v)
|
|
{
|
|
char buf[NAME_MAX + 1];
|
|
flist_t *flp;
|
|
int id;
|
|
int j;
|
|
int len;
|
|
int e;
|
|
|
|
/* create name */
|
|
flp = &flist[ft];
|
|
len = sprintf(buf, "%c%x", flp->tag, id = nameseq++);
|
|
namerandpad(id, buf, len);
|
|
|
|
/* prepend fep parent dir-name to it */
|
|
if (fep) {
|
|
e = fent_to_name(name, fep);
|
|
if (!e)
|
|
return 0;
|
|
append_pathname(name, "/");
|
|
}
|
|
append_pathname(name, buf);
|
|
|
|
*idp = id;
|
|
*v = verbose;
|
|
for (j = 0; !*v && j < ilistlen; j++) {
|
|
if (ilist[j] == id) {
|
|
*v = 1;
|
|
break;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int generate_xattr_name(int xattr_num, char *buffer, int buflen)
|
|
{
|
|
int ret;
|
|
|
|
ret = snprintf(buffer, buflen, "user.x%d", xattr_num);
|
|
if (ret < 0)
|
|
return ret;
|
|
if (ret < buflen)
|
|
return 0;
|
|
return -EOVERFLOW;
|
|
}
|
|
|
|
/*
|
|
* Get file
|
|
* Input: "which" to choose the file-types eg. non-directory
|
|
* Input: "r" to choose which file
|
|
* Output: file-list, file-entry, name for the chosen file.
|
|
* Output: verbose if chosen file is on the ilist.
|
|
*/
|
|
int
|
|
get_fname(int which, long r, pathname_t *name, flist_t **flpp, fent_t **fepp,
|
|
int *v)
|
|
{
|
|
int totalsum = 0; /* total number of matching files */
|
|
int partialsum = 0; /* partial sum of matching files */
|
|
fent_t *fep;
|
|
flist_t *flp;
|
|
int i;
|
|
int j;
|
|
int x;
|
|
int e = 1; /* success */
|
|
|
|
/*
|
|
* go thru flist and add up number of files for each
|
|
* category that matches with <which>.
|
|
*/
|
|
for (i = 0, flp = flist; i < FT_nft; i++, flp++) {
|
|
if (which & (1 << i))
|
|
totalsum += flp->nfiles;
|
|
}
|
|
if (totalsum == 0) {
|
|
if (flpp)
|
|
*flpp = NULL;
|
|
if (fepp)
|
|
*fepp = NULL;
|
|
*v = verbose;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Now we have possible matches between 0..totalsum-1.
|
|
* And we use r to help us choose which one we want,
|
|
* which when bounded by totalsum becomes x.
|
|
*/
|
|
x = (int)(r % totalsum);
|
|
for (i = 0, flp = flist; i < FT_nft; i++, flp++) {
|
|
if (which & (1 << i)) {
|
|
if (x < partialsum + flp->nfiles) {
|
|
|
|
/* found the matching file entry */
|
|
fep = &flp->fents[x - partialsum];
|
|
|
|
/* fill-in what we were asked for */
|
|
if (name) {
|
|
e = fent_to_name(name, fep);
|
|
#ifdef DEBUG
|
|
if (!e) {
|
|
fprintf(stderr, "%d: failed to get path for entry:"
|
|
" id=%d,parent=%d\n",
|
|
procid, fep->id, fep->parent);
|
|
}
|
|
#endif
|
|
}
|
|
if (flpp)
|
|
*flpp = flp;
|
|
if (fepp)
|
|
*fepp = fep;
|
|
|
|
/* turn on verbose if its an ilisted file */
|
|
*v = verbose;
|
|
for (j = 0; !*v && j < ilistlen; j++) {
|
|
if (ilist[j] == fep->id) {
|
|
*v = 1;
|
|
break;
|
|
}
|
|
}
|
|
return e;
|
|
}
|
|
partialsum += flp->nfiles;
|
|
}
|
|
}
|
|
#ifdef DEBUG
|
|
fprintf(stderr, "fsstress: get_fname failure\n");
|
|
abort();
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
init_pathname(pathname_t *name)
|
|
{
|
|
name->len = 0;
|
|
name->path = NULL;
|
|
}
|
|
|
|
int
|
|
lchown_path(pathname_t *name, uid_t owner, gid_t group)
|
|
{
|
|
char buf[NAME_MAX + 1];
|
|
pathname_t newname;
|
|
int rval;
|
|
|
|
rval = lchown(name->path, owner, group);
|
|
if (rval >= 0 || errno != ENAMETOOLONG)
|
|
return rval;
|
|
separate_pathname(name, buf, &newname);
|
|
if (chdir(buf) == 0) {
|
|
rval = lchown_path(&newname, owner, group);
|
|
assert(chdir("..") == 0);
|
|
}
|
|
free_pathname(&newname);
|
|
return rval;
|
|
}
|
|
|
|
int
|
|
link_path(pathname_t *name1, pathname_t *name2)
|
|
{
|
|
char buf1[NAME_MAX + 1];
|
|
char buf2[NAME_MAX + 1];
|
|
int down1;
|
|
pathname_t newname1;
|
|
pathname_t newname2;
|
|
int rval;
|
|
|
|
rval = link(name1->path, name2->path);
|
|
if (rval >= 0 || errno != ENAMETOOLONG)
|
|
return rval;
|
|
separate_pathname(name1, buf1, &newname1);
|
|
separate_pathname(name2, buf2, &newname2);
|
|
if (strcmp(buf1, buf2) == 0) {
|
|
if (chdir(buf1) == 0) {
|
|
rval = link_path(&newname1, &newname2);
|
|
assert(chdir("..") == 0);
|
|
}
|
|
} else {
|
|
if (strcmp(buf1, "..") == 0)
|
|
down1 = 0;
|
|
else if (strcmp(buf2, "..") == 0)
|
|
down1 = 1;
|
|
else if (strlen(buf1) == 0)
|
|
down1 = 0;
|
|
else if (strlen(buf2) == 0)
|
|
down1 = 1;
|
|
else
|
|
down1 = MAX(newname1.len, 3 + name2->len) <=
|
|
MAX(3 + name1->len, newname2.len);
|
|
if (down1) {
|
|
free_pathname(&newname2);
|
|
append_pathname(&newname2, "../");
|
|
append_pathname(&newname2, name2->path);
|
|
if (chdir(buf1) == 0) {
|
|
rval = link_path(&newname1, &newname2);
|
|
assert(chdir("..") == 0);
|
|
}
|
|
} else {
|
|
free_pathname(&newname1);
|
|
append_pathname(&newname1, "../");
|
|
append_pathname(&newname1, name1->path);
|
|
if (chdir(buf2) == 0) {
|
|
rval = link_path(&newname1, &newname2);
|
|
assert(chdir("..") == 0);
|
|
}
|
|
}
|
|
}
|
|
free_pathname(&newname1);
|
|
free_pathname(&newname2);
|
|
return rval;
|
|
}
|
|
|
|
int
|
|
lstat64_path(pathname_t *name, struct stat64 *sbuf)
|
|
{
|
|
char buf[NAME_MAX + 1];
|
|
pathname_t newname;
|
|
int rval;
|
|
|
|
rval = lstat64(name->path, sbuf);
|
|
if (rval >= 0 || errno != ENAMETOOLONG)
|
|
return rval;
|
|
separate_pathname(name, buf, &newname);
|
|
if (chdir(buf) == 0) {
|
|
rval = lstat64_path(&newname, sbuf);
|
|
assert(chdir("..") == 0);
|
|
}
|
|
free_pathname(&newname);
|
|
return rval;
|
|
}
|
|
|
|
void
|
|
make_freq_table(void)
|
|
{
|
|
int f;
|
|
int i;
|
|
opdesc_t *p;
|
|
|
|
for (p = ops, f = 0; p < ops_end; p++)
|
|
f += p->freq;
|
|
freq_table = malloc(f * sizeof(*freq_table));
|
|
freq_table_size = f;
|
|
for (p = ops, i = 0; p < ops_end; p++) {
|
|
for (f = 0; f < p->freq; f++, i++)
|
|
freq_table[i] = p - ops;
|
|
}
|
|
}
|
|
|
|
int
|
|
mkdir_path(pathname_t *name, mode_t mode)
|
|
{
|
|
char buf[NAME_MAX + 1];
|
|
pathname_t newname;
|
|
int rval;
|
|
|
|
rval = mkdir(name->path, mode);
|
|
if (rval >= 0 || errno != ENAMETOOLONG)
|
|
return rval;
|
|
separate_pathname(name, buf, &newname);
|
|
if (chdir(buf) == 0) {
|
|
rval = mkdir_path(&newname, mode);
|
|
assert(chdir("..") == 0);
|
|
}
|
|
free_pathname(&newname);
|
|
return rval;
|
|
}
|
|
|
|
int
|
|
mknod_path(pathname_t *name, mode_t mode, dev_t dev)
|
|
{
|
|
char buf[NAME_MAX + 1];
|
|
pathname_t newname;
|
|
int rval;
|
|
|
|
rval = mknod(name->path, mode, dev);
|
|
if (rval >= 0 || errno != ENAMETOOLONG)
|
|
return rval;
|
|
separate_pathname(name, buf, &newname);
|
|
if (chdir(buf) == 0) {
|
|
rval = mknod_path(&newname, mode, dev);
|
|
assert(chdir("..") == 0);
|
|
}
|
|
free_pathname(&newname);
|
|
return rval;
|
|
}
|
|
|
|
void
|
|
namerandpad(int id, char *buf, int i)
|
|
{
|
|
int bucket;
|
|
static int buckets[] =
|
|
{ 2, 4, 8, 16, 32, 64, 128, NAME_MAX };
|
|
int padlen;
|
|
int padmod;
|
|
|
|
if (namerand == 0)
|
|
return;
|
|
bucket = (id ^ namerand) % (sizeof(buckets) / sizeof(buckets[0]));
|
|
padmod = buckets[bucket] + 1 - i;
|
|
if (padmod <= 0)
|
|
return;
|
|
padlen = (id ^ namerand) % padmod;
|
|
if (padlen) {
|
|
memset(&buf[i], 'X', padlen);
|
|
buf[i + padlen] = '\0';
|
|
}
|
|
}
|
|
|
|
int
|
|
open_file_or_dir(pathname_t *name, int flags)
|
|
{
|
|
int fd;
|
|
|
|
fd = open_path(name, flags);
|
|
if (fd != -1)
|
|
return fd;
|
|
if (fd == -1 && errno != EISDIR)
|
|
return fd;
|
|
/* Directories can not be opened in write mode nor direct mode. */
|
|
flags &= ~(O_WRONLY | O_DIRECT);
|
|
flags |= O_RDONLY | O_DIRECTORY;
|
|
return open_path(name, flags);
|
|
}
|
|
|
|
int
|
|
open_path(pathname_t *name, int oflag)
|
|
{
|
|
char buf[NAME_MAX + 1];
|
|
pathname_t newname;
|
|
int rval;
|
|
|
|
rval = open(name->path, oflag);
|
|
if (rval >= 0 || errno != ENAMETOOLONG)
|
|
return rval;
|
|
separate_pathname(name, buf, &newname);
|
|
if (chdir(buf) == 0) {
|
|
rval = open_path(&newname, oflag);
|
|
assert(chdir("..") == 0);
|
|
}
|
|
free_pathname(&newname);
|
|
return rval;
|
|
}
|
|
|
|
DIR *
|
|
opendir_path(pathname_t *name)
|
|
{
|
|
char buf[NAME_MAX + 1];
|
|
pathname_t newname;
|
|
DIR *rval;
|
|
|
|
rval = opendir(name->path);
|
|
if (rval || errno != ENAMETOOLONG)
|
|
return rval;
|
|
separate_pathname(name, buf, &newname);
|
|
if (chdir(buf) == 0) {
|
|
rval = opendir_path(&newname);
|
|
assert(chdir("..") == 0);
|
|
}
|
|
free_pathname(&newname);
|
|
return rval;
|
|
}
|
|
|
|
void
|
|
process_freq(char *arg)
|
|
{
|
|
opdesc_t *p;
|
|
char *s;
|
|
|
|
s = strchr(arg, '=');
|
|
if (s == NULL) {
|
|
fprintf(stderr, "bad argument '%s'\n", arg);
|
|
exit(1);
|
|
}
|
|
*s++ = '\0';
|
|
for (p = ops; p < ops_end; p++) {
|
|
if (strcmp(arg, p->name) == 0) {
|
|
p->freq = atoi(s);
|
|
return;
|
|
}
|
|
}
|
|
fprintf(stderr, "can't find op type %s for -f\n", arg);
|
|
exit(1);
|
|
}
|
|
|
|
int
|
|
readlink_path(pathname_t *name, char *lbuf, size_t lbufsiz)
|
|
{
|
|
char buf[NAME_MAX + 1];
|
|
pathname_t newname;
|
|
int rval;
|
|
|
|
rval = readlink(name->path, lbuf, lbufsiz);
|
|
if (rval >= 0 || errno != ENAMETOOLONG)
|
|
return rval;
|
|
separate_pathname(name, buf, &newname);
|
|
if (chdir(buf) == 0) {
|
|
rval = readlink_path(&newname, lbuf, lbufsiz);
|
|
assert(chdir("..") == 0);
|
|
}
|
|
free_pathname(&newname);
|
|
return rval;
|
|
}
|
|
|
|
int
|
|
rename_path(pathname_t *name1, pathname_t *name2, int mode)
|
|
{
|
|
char buf1[NAME_MAX + 1];
|
|
char buf2[NAME_MAX + 1];
|
|
int down1;
|
|
pathname_t newname1;
|
|
pathname_t newname2;
|
|
int rval;
|
|
|
|
if (mode == 0)
|
|
rval = rename(name1->path, name2->path);
|
|
else
|
|
rval = renameat2(AT_FDCWD, name1->path,
|
|
AT_FDCWD, name2->path, mode);
|
|
if (rval >= 0 || errno != ENAMETOOLONG)
|
|
return rval;
|
|
separate_pathname(name1, buf1, &newname1);
|
|
separate_pathname(name2, buf2, &newname2);
|
|
if (strcmp(buf1, buf2) == 0) {
|
|
if (chdir(buf1) == 0) {
|
|
rval = rename_path(&newname1, &newname2, mode);
|
|
assert(chdir("..") == 0);
|
|
}
|
|
} else {
|
|
if (strcmp(buf1, "..") == 0)
|
|
down1 = 0;
|
|
else if (strcmp(buf2, "..") == 0)
|
|
down1 = 1;
|
|
else if (strlen(buf1) == 0)
|
|
down1 = 0;
|
|
else if (strlen(buf2) == 0)
|
|
down1 = 1;
|
|
else
|
|
down1 = MAX(newname1.len, 3 + name2->len) <=
|
|
MAX(3 + name1->len, newname2.len);
|
|
if (down1) {
|
|
free_pathname(&newname2);
|
|
append_pathname(&newname2, "../");
|
|
append_pathname(&newname2, name2->path);
|
|
if (chdir(buf1) == 0) {
|
|
rval = rename_path(&newname1, &newname2, mode);
|
|
assert(chdir("..") == 0);
|
|
}
|
|
} else {
|
|
free_pathname(&newname1);
|
|
append_pathname(&newname1, "../");
|
|
append_pathname(&newname1, name1->path);
|
|
if (chdir(buf2) == 0) {
|
|
rval = rename_path(&newname1, &newname2, mode);
|
|
assert(chdir("..") == 0);
|
|
}
|
|
}
|
|
}
|
|
free_pathname(&newname1);
|
|
free_pathname(&newname2);
|
|
return rval;
|
|
}
|
|
|
|
int
|
|
rmdir_path(pathname_t *name)
|
|
{
|
|
char buf[NAME_MAX + 1];
|
|
pathname_t newname;
|
|
int rval;
|
|
|
|
rval = rmdir(name->path);
|
|
if (rval >= 0 || errno != ENAMETOOLONG)
|
|
return rval;
|
|
separate_pathname(name, buf, &newname);
|
|
if (chdir(buf) == 0) {
|
|
rval = rmdir_path(&newname);
|
|
assert(chdir("..") == 0);
|
|
}
|
|
free_pathname(&newname);
|
|
return rval;
|
|
}
|
|
|
|
void
|
|
separate_pathname(pathname_t *name, char *buf, pathname_t *newname)
|
|
{
|
|
char *slash;
|
|
|
|
init_pathname(newname);
|
|
slash = strchr(name->path, '/');
|
|
if (slash == NULL) {
|
|
buf[0] = '\0';
|
|
return;
|
|
}
|
|
*slash = '\0';
|
|
strcpy(buf, name->path);
|
|
*slash = '/';
|
|
append_pathname(newname, slash + 1);
|
|
}
|
|
|
|
#define WIDTH 80
|
|
|
|
void
|
|
show_ops(int flag, char *lead_str)
|
|
{
|
|
opdesc_t *p;
|
|
|
|
if (flag<0) {
|
|
/* print in list form */
|
|
int x = WIDTH;
|
|
|
|
for (p = ops; p < ops_end; p++) {
|
|
if (lead_str != NULL && x+strlen(p->name)>=WIDTH-5)
|
|
x=printf("%s%s", (p==ops)?"":"\n", lead_str);
|
|
x+=printf("%s ", p->name);
|
|
}
|
|
printf("\n");
|
|
} else if (flag == 0) {
|
|
/* Table view style */
|
|
int f;
|
|
for (f = 0, p = ops; p < ops_end; p++)
|
|
f += p->freq;
|
|
|
|
if (f == 0)
|
|
flag = 1;
|
|
|
|
for (p = ops; p < ops_end; p++) {
|
|
if (flag != 0 || p->freq > 0) {
|
|
if (lead_str != NULL)
|
|
printf("%s", lead_str);
|
|
printf("%20s %d/%d %s\n",
|
|
p->name, p->freq, f,
|
|
(p->iswrite == 0) ? " " : "write op");
|
|
}
|
|
}
|
|
} else {
|
|
/* Command line style */
|
|
if (lead_str != NULL)
|
|
printf("%s", lead_str);
|
|
printf ("-z -s %ld -m %d -n %lld -p %d \\\n", seed, idmodulo,
|
|
operations, nproc);
|
|
for (p = ops; p < ops_end; p++)
|
|
if (p->freq > 0)
|
|
printf("-f %s=%d \\\n",p->name, p->freq);
|
|
}
|
|
}
|
|
|
|
int
|
|
stat64_path(pathname_t *name, struct stat64 *sbuf)
|
|
{
|
|
char buf[NAME_MAX + 1];
|
|
pathname_t newname;
|
|
int rval;
|
|
|
|
rval = stat64(name->path, sbuf);
|
|
if (rval >= 0 || errno != ENAMETOOLONG)
|
|
return rval;
|
|
separate_pathname(name, buf, &newname);
|
|
if (chdir(buf) == 0) {
|
|
rval = stat64_path(&newname, sbuf);
|
|
assert(chdir("..") == 0);
|
|
}
|
|
free_pathname(&newname);
|
|
return rval;
|
|
}
|
|
|
|
int
|
|
symlink_path(const char *name1, pathname_t *name)
|
|
{
|
|
char buf[NAME_MAX + 1];
|
|
pathname_t newname;
|
|
int rval;
|
|
|
|
if (!strcmp(name1, name->path)) {
|
|
printf("yikes! %s %s\n", name1, name->path);
|
|
return 0;
|
|
}
|
|
|
|
rval = symlink(name1, name->path);
|
|
if (rval >= 0 || errno != ENAMETOOLONG)
|
|
return rval;
|
|
separate_pathname(name, buf, &newname);
|
|
if (chdir(buf) == 0) {
|
|
rval = symlink_path(name1, &newname);
|
|
assert(chdir("..") == 0);
|
|
}
|
|
free_pathname(&newname);
|
|
return rval;
|
|
}
|
|
|
|
int
|
|
truncate64_path(pathname_t *name, off64_t length)
|
|
{
|
|
char buf[NAME_MAX + 1];
|
|
pathname_t newname;
|
|
int rval;
|
|
|
|
rval = truncate64(name->path, length);
|
|
if (rval >= 0 || errno != ENAMETOOLONG)
|
|
return rval;
|
|
separate_pathname(name, buf, &newname);
|
|
if (chdir(buf) == 0) {
|
|
rval = truncate64_path(&newname, length);
|
|
assert(chdir("..") == 0);
|
|
}
|
|
free_pathname(&newname);
|
|
return rval;
|
|
}
|
|
|
|
int
|
|
unlink_path(pathname_t *name)
|
|
{
|
|
char buf[NAME_MAX + 1];
|
|
pathname_t newname;
|
|
int rval;
|
|
|
|
rval = unlink(name->path);
|
|
if (rval >= 0 || errno != ENAMETOOLONG)
|
|
return rval;
|
|
separate_pathname(name, buf, &newname);
|
|
if (chdir(buf) == 0) {
|
|
rval = unlink_path(&newname);
|
|
assert(chdir("..") == 0);
|
|
}
|
|
free_pathname(&newname);
|
|
return rval;
|
|
}
|
|
|
|
void
|
|
usage(void)
|
|
{
|
|
printf("Usage: %s -H or\n", myprog);
|
|
printf(" %s [-c][-d dir][-e errtg][-f op_name=freq][-l loops][-n nops]\n",
|
|
myprog);
|
|
printf(" [-p nproc][-r len][-s seed][-v][-w][-x cmd][-z][-S][-X ncmd]\n");
|
|
printf("where\n");
|
|
printf(" -c clean up the test directory after each run\n");
|
|
printf(" -d dir specifies the base directory for operations\n");
|
|
printf(" -e errtg specifies error injection stuff\n");
|
|
printf(" -f op_name=freq changes the frequency of option name to freq\n");
|
|
printf(" the valid operation names are:\n");
|
|
show_ops(-1, " ");
|
|
printf(" -i filenum get verbose output for this nth file object\n");
|
|
printf(" -l loops specifies the no. of times the testrun should loop.\n");
|
|
printf(" *use 0 for infinite (default 1)\n");
|
|
printf(" -m modulo uid/gid modulo for chown/chgrp (default 32)\n");
|
|
printf(" -n nops specifies the no. of operations per process (default 1)\n");
|
|
printf(" -o logfile specifies logfile name\n");
|
|
printf(" -p nproc specifies the no. of processes (default 1)\n");
|
|
printf(" -r specifies random name padding\n");
|
|
printf(" -R zeros frequencies of write operations\n");
|
|
printf(" -s seed specifies the seed for the random generator (default random)\n");
|
|
printf(" -v specifies verbose mode\n");
|
|
printf(" -w zeros frequencies of non-write operations\n");
|
|
printf(" -x cmd execute command in the middle of operations\n");
|
|
printf(" -z zeros frequencies of all operations\n");
|
|
printf(" -S [c,t] prints the list of operations (omitting zero frequency) in command line or table style\n");
|
|
printf(" -V specifies verifiable logging mode (omitting inode numbers)\n");
|
|
printf(" -X ncmd number of calls to the -x command (default 1)\n");
|
|
printf(" -H prints usage and exits\n");
|
|
printf(" --duration=s ignore any -n setting and run for this many seconds\n");
|
|
}
|
|
|
|
void
|
|
read_freq(void)
|
|
{
|
|
opdesc_t *p;
|
|
|
|
for (p = ops; p < ops_end; p++) {
|
|
if (p->iswrite)
|
|
p->freq = 0;
|
|
}
|
|
}
|
|
|
|
void
|
|
write_freq(void)
|
|
{
|
|
opdesc_t *p;
|
|
|
|
for (p = ops; p < ops_end; p++) {
|
|
if (!p->iswrite)
|
|
p->freq = 0;
|
|
}
|
|
}
|
|
|
|
void
|
|
zero_freq(void)
|
|
{
|
|
opdesc_t *p;
|
|
|
|
for (p = ops; p < ops_end; p++)
|
|
p->freq = 0;
|
|
}
|
|
|
|
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
|
|
|
|
opty_t btrfs_ops[] = {
|
|
OP_SNAPSHOT,
|
|
OP_SUBVOL_CREATE,
|
|
OP_SUBVOL_DELETE,
|
|
};
|
|
|
|
void
|
|
non_btrfs_freq(const char *path)
|
|
{
|
|
int i;
|
|
#ifdef HAVE_BTRFSUTIL_H
|
|
enum btrfs_util_error e;
|
|
|
|
e = btrfs_util_is_subvolume(path);
|
|
if (e != BTRFS_UTIL_ERROR_NOT_BTRFS)
|
|
return;
|
|
#endif
|
|
for (i = 0; i < ARRAY_SIZE(btrfs_ops); i++)
|
|
ops[btrfs_ops[i]].freq = 0;
|
|
}
|
|
|
|
static void inode_info(char *str, size_t sz, struct stat64 *s, int verbose)
|
|
{
|
|
if (verbose)
|
|
snprintf(str, sz, "[%ld %ld %d %d %lld %lld]",
|
|
verifiable_log ? -1: (long)s->st_ino,
|
|
(long)s->st_nlink, s->st_uid, s->st_gid,
|
|
(long long) s->st_blocks, (long long) s->st_size);
|
|
}
|
|
|
|
void
|
|
afsync_f(opnum_t opno, long r)
|
|
{
|
|
#ifdef AIO
|
|
int e;
|
|
pathname_t f;
|
|
int fd;
|
|
int v;
|
|
struct iocb iocb;
|
|
struct iocb *iocbs[] = { &iocb };
|
|
struct io_event event;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_REGFILE | FT_DIRm, r, &f, NULL, NULL, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: afsync - no filename\n", procid, opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
fd = open_file_or_dir(&f, O_WRONLY | O_DIRECT);
|
|
e = fd < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd < 0) {
|
|
if (v)
|
|
printf("%d/%lld: afsync - open %s failed %d\n",
|
|
procid, opno, f.path, e);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
|
|
io_prep_fsync(&iocb, fd);
|
|
if ((e = io_submit(io_ctx, 1, iocbs)) != 1) {
|
|
if (v)
|
|
printf("%d/%lld: afsync - io_submit %s %d\n",
|
|
procid, opno, f.path, e);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
return;
|
|
}
|
|
if ((e = io_getevents(io_ctx, 1, 1, &event, NULL)) != 1) {
|
|
if (v)
|
|
printf("%d/%lld: afsync - io_getevents failed %d\n",
|
|
procid, opno, e);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
return;
|
|
}
|
|
|
|
e = event.res2;
|
|
if (v)
|
|
printf("%d/%lld: afsync %s %d\n", procid, opno, f.path, e);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
#endif
|
|
}
|
|
|
|
#ifdef AIO
|
|
static void
|
|
do_aio_rw(opnum_t opno, long r, int flags)
|
|
{
|
|
int64_t align;
|
|
char *buf = NULL;
|
|
struct dioattr diob;
|
|
int e;
|
|
pathname_t f;
|
|
int fd = -1;
|
|
size_t len;
|
|
int64_t lr;
|
|
off64_t off;
|
|
struct stat64 stb;
|
|
int v;
|
|
char st[1024];
|
|
char *dio_env;
|
|
struct iocb iocb;
|
|
struct io_event event;
|
|
struct iocb *iocbs[] = { &iocb };
|
|
int iswrite = (flags & (O_WRONLY | O_RDWR)) ? 1 : 0;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: do_aio_rw - no filename\n", procid, opno);
|
|
goto aio_out;
|
|
}
|
|
fd = open_path(&f, flags|O_DIRECT);
|
|
e = fd < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd < 0) {
|
|
if (v)
|
|
printf("%d/%lld: do_aio_rw - open %s failed %d\n",
|
|
procid, opno, f.path, e);
|
|
goto aio_out;
|
|
}
|
|
if (fstat64(fd, &stb) < 0) {
|
|
if (v)
|
|
printf("%d/%lld: do_aio_rw - fstat64 %s failed %d\n",
|
|
procid, opno, f.path, errno);
|
|
goto aio_out;
|
|
}
|
|
inode_info(st, sizeof(st), &stb, v);
|
|
if (!iswrite && stb.st_size == 0) {
|
|
if (v)
|
|
printf("%d/%lld: do_aio_rw - %s%s zero size\n", procid, opno,
|
|
f.path, st);
|
|
goto aio_out;
|
|
}
|
|
#if 0
|
|
if (xfsctl(f.path, fd, XFS_IOC_DIOINFO, &diob) < 0) {
|
|
#endif
|
|
if (v)
|
|
printf(
|
|
"%d/%lld: do_aio_rw - xfsctl(XFS_IOC_DIOINFO) %s%s return %d,"
|
|
" fallback to stat()\n",
|
|
procid, opno, f.path, st, errno);
|
|
diob.d_mem = diob.d_miniosz = stb.st_blksize;
|
|
diob.d_maxiosz = rounddown_64(INT_MAX, diob.d_miniosz);
|
|
#if 0
|
|
}
|
|
#endif
|
|
dio_env = getenv("XFS_DIO_MIN");
|
|
if (dio_env)
|
|
diob.d_mem = diob.d_miniosz = atoi(dio_env);
|
|
align = (int64_t)diob.d_miniosz;
|
|
lr = ((int64_t)random() << 32) + random();
|
|
len = (random() % FILELEN_MAX) + 1;
|
|
len -= (len % align);
|
|
if (len <= 0)
|
|
len = align;
|
|
else if (len > diob.d_maxiosz)
|
|
len = diob.d_maxiosz;
|
|
buf = memalign(diob.d_mem, len);
|
|
if (!buf) {
|
|
if (v)
|
|
printf("%d/%lld: do_aio_rw - memalign failed\n",
|
|
procid, opno);
|
|
goto aio_out;
|
|
}
|
|
|
|
if (iswrite) {
|
|
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
|
|
off -= (off % align);
|
|
off %= maxfsize;
|
|
memset(buf, nameseq & 0xff, len);
|
|
io_prep_pwrite(&iocb, fd, buf, len, off);
|
|
} else {
|
|
off = (off64_t)(lr % stb.st_size);
|
|
off -= (off % align);
|
|
io_prep_pread(&iocb, fd, buf, len, off);
|
|
}
|
|
if ((e = io_submit(io_ctx, 1, iocbs)) != 1) {
|
|
if (v)
|
|
printf("%d/%lld: %s - io_submit failed %d\n",
|
|
procid, opno, iswrite ? "awrite" : "aread", e);
|
|
goto aio_out;
|
|
}
|
|
if ((e = io_getevents(io_ctx, 1, 1, &event, NULL)) != 1) {
|
|
if (v)
|
|
printf("%d/%lld: %s - io_getevents failed %d\n",
|
|
procid, opno, iswrite ? "awrite" : "aread", e);
|
|
goto aio_out;
|
|
}
|
|
|
|
e = event.res != len ? event.res2 : 0;
|
|
if (v)
|
|
printf("%d/%lld: %s %s%s [%lld,%d] %d\n",
|
|
procid, opno, iswrite ? "awrite" : "aread",
|
|
f.path, st, (long long)off, (int)len, e);
|
|
aio_out:
|
|
if (buf)
|
|
free(buf);
|
|
if (fd != -1)
|
|
close(fd);
|
|
free_pathname(&f);
|
|
}
|
|
#endif
|
|
|
|
#ifdef URING
|
|
static void
|
|
do_uring_rw(opnum_t opno, long r, int flags)
|
|
{
|
|
char *buf = NULL;
|
|
int e;
|
|
pathname_t f;
|
|
int fd = -1;
|
|
size_t len;
|
|
int64_t lr;
|
|
off64_t off;
|
|
struct stat64 stb;
|
|
int v;
|
|
char st[1024];
|
|
struct io_uring_sqe *sqe;
|
|
struct io_uring_cqe *cqe;
|
|
struct iovec iovec;
|
|
int iswrite = (flags & (O_WRONLY | O_RDWR)) ? 1 : 0;
|
|
|
|
if (!have_io_uring)
|
|
return;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: do_uring_rw - no filename\n", procid, opno);
|
|
goto uring_out;
|
|
}
|
|
fd = open_path(&f, flags);
|
|
e = fd < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd < 0) {
|
|
if (v)
|
|
printf("%d/%lld: do_uring_rw - open %s failed %d\n",
|
|
procid, opno, f.path, e);
|
|
goto uring_out;
|
|
}
|
|
if (fstat64(fd, &stb) < 0) {
|
|
if (v)
|
|
printf("%d/%lld: do_uring_rw - fstat64 %s failed %d\n",
|
|
procid, opno, f.path, errno);
|
|
goto uring_out;
|
|
}
|
|
inode_info(st, sizeof(st), &stb, v);
|
|
if (!iswrite && stb.st_size == 0) {
|
|
if (v)
|
|
printf("%d/%lld: do_uring_rw - %s%s zero size\n", procid, opno,
|
|
f.path, st);
|
|
goto uring_out;
|
|
}
|
|
sqe = io_uring_get_sqe(&ring);
|
|
if (!sqe) {
|
|
if (v)
|
|
printf("%d/%lld: do_uring_rw - io_uring_get_sqe failed\n",
|
|
procid, opno);
|
|
goto uring_out;
|
|
}
|
|
lr = ((int64_t)random() << 32) + random();
|
|
len = (random() % FILELEN_MAX) + 1;
|
|
buf = malloc(len);
|
|
if (!buf) {
|
|
if (v)
|
|
printf("%d/%lld: do_uring_rw - malloc failed\n",
|
|
procid, opno);
|
|
goto uring_out;
|
|
}
|
|
iovec.iov_base = buf;
|
|
iovec.iov_len = len;
|
|
if (iswrite) {
|
|
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
|
|
off %= maxfsize;
|
|
memset(buf, nameseq & 0xff, len);
|
|
io_uring_prep_writev(sqe, fd, &iovec, 1, off);
|
|
} else {
|
|
off = (off64_t)(lr % stb.st_size);
|
|
io_uring_prep_readv(sqe, fd, &iovec, 1, off);
|
|
}
|
|
|
|
if ((e = io_uring_submit_and_wait(&ring, 1)) != 1) {
|
|
if (v)
|
|
printf("%d/%lld: %s - io_uring_submit failed %d\n", procid, opno,
|
|
iswrite ? "uring_write" : "uring_read", e);
|
|
goto uring_out;
|
|
}
|
|
if ((e = io_uring_wait_cqe(&ring, &cqe)) < 0) {
|
|
if (v)
|
|
printf("%d/%lld: %s - io_uring_wait_cqe failed %d\n", procid, opno,
|
|
iswrite ? "uring_write" : "uring_read", e);
|
|
goto uring_out;
|
|
}
|
|
if (v)
|
|
printf("%d/%lld: %s %s%s [%lld, %d(res=%d)] %d\n",
|
|
procid, opno, iswrite ? "uring_write" : "uring_read",
|
|
f.path, st, (long long)off, (int)len, cqe->res, e);
|
|
io_uring_cqe_seen(&ring, cqe);
|
|
|
|
uring_out:
|
|
if (buf)
|
|
free(buf);
|
|
if (fd != -1)
|
|
close(fd);
|
|
free_pathname(&f);
|
|
}
|
|
#endif
|
|
|
|
void
|
|
aread_f(opnum_t opno, long r)
|
|
{
|
|
#ifdef AIO
|
|
do_aio_rw(opno, r, O_RDONLY);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
attr_remove_f(opnum_t opno, long r)
|
|
{
|
|
char *bufname;
|
|
char *bufend;
|
|
char *aname = NULL;
|
|
char buf[XATTR_LIST_MAX];
|
|
int e;
|
|
int ent;
|
|
pathname_t f;
|
|
int total = 0;
|
|
int v;
|
|
int which;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_ANYm, r, &f, NULL, NULL, &v))
|
|
append_pathname(&f, ".");
|
|
e = attr_list_path(&f, buf, sizeof(buf));
|
|
check_cwd();
|
|
if (e > 0)
|
|
total = attr_list_count(buf, e);
|
|
if (total == 0) {
|
|
if (v)
|
|
printf("%d/%lld: attr_remove - no attrs for %s\n",
|
|
procid, opno, f.path);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
|
|
which = (int)(random() % total);
|
|
bufname = buf;
|
|
bufend = buf + e;
|
|
ent = 0;
|
|
while (bufname < bufend) {
|
|
if (which < ent) {
|
|
aname = bufname;
|
|
break;
|
|
}
|
|
ent++;
|
|
bufname += strlen(bufname) + 1;
|
|
}
|
|
if (aname == NULL) {
|
|
if (v)
|
|
printf(
|
|
"%d/%lld: attr_remove - name %d not found at %s\n",
|
|
procid, opno, which, f.path);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
if (attr_remove_path(&f, aname) < 0)
|
|
e = errno;
|
|
else
|
|
e = 0;
|
|
check_cwd();
|
|
if (v)
|
|
printf("%d/%lld: attr_remove %s %s %d\n",
|
|
procid, opno, f.path, aname, e);
|
|
free_pathname(&f);
|
|
}
|
|
|
|
void
|
|
attr_set_f(opnum_t opno, long r)
|
|
{
|
|
char aname[10];
|
|
char *aval;
|
|
int e;
|
|
pathname_t f;
|
|
int len;
|
|
static int lengths[] = { 10, 100, 1000, 10000 };
|
|
int li;
|
|
int v;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_ANYm, r, &f, NULL, NULL, &v))
|
|
append_pathname(&f, ".");
|
|
sprintf(aname, "a%x", nameseq++);
|
|
li = (int)(random() % (sizeof(lengths) / sizeof(lengths[0])));
|
|
len = (int)(random() % lengths[li]);
|
|
if (len == 0)
|
|
len = 1;
|
|
aval = malloc(len);
|
|
memset(aval, nameseq & 0xff, len);
|
|
if (attr_set_path(&f, aname, aval, len) < 0)
|
|
e = errno;
|
|
else
|
|
e = 0;
|
|
check_cwd();
|
|
free(aval);
|
|
if (v)
|
|
printf("%d/%lld: attr_set %s %s %d\n", procid, opno, f.path,
|
|
aname, e);
|
|
free_pathname(&f);
|
|
}
|
|
|
|
void
|
|
awrite_f(opnum_t opno, long r)
|
|
{
|
|
#ifdef AIO
|
|
do_aio_rw(opno, r, O_WRONLY);
|
|
#endif
|
|
}
|
|
|
|
#if 0
|
|
void
|
|
bulkstat_f(opnum_t opno, long r)
|
|
{
|
|
int count;
|
|
int fd;
|
|
__u64 last;
|
|
int nent;
|
|
struct xfs_bstat *t;
|
|
int64_t total;
|
|
struct xfs_fsop_bulkreq bsr;
|
|
|
|
last = 0;
|
|
nent = (r % 999) + 2;
|
|
t = malloc(nent * sizeof(*t));
|
|
fd = open(".", O_RDONLY);
|
|
total = 0;
|
|
|
|
bsr.lastip=&last;
|
|
bsr.icount=nent;
|
|
bsr.ubuffer=t;
|
|
bsr.ocount=&count;
|
|
|
|
while (xfsctl(".", fd, XFS_IOC_FSBULKSTAT, &bsr) == 0 && count > 0)
|
|
total += count;
|
|
free(t);
|
|
if (verbose)
|
|
printf("%d/%lld: bulkstat nent %d total %lld\n",
|
|
procid, opno, nent, (long long)total);
|
|
close(fd);
|
|
}
|
|
|
|
void
|
|
bulkstat1_f(opnum_t opno, long r)
|
|
{
|
|
int e;
|
|
pathname_t f;
|
|
int fd;
|
|
int good;
|
|
__u64 ino;
|
|
struct stat64 s;
|
|
struct xfs_bstat t;
|
|
int v;
|
|
struct xfs_fsop_bulkreq bsr;
|
|
|
|
|
|
good = random() & 1;
|
|
if (good) {
|
|
/* use an inode we know exists */
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_ANYm, r, &f, NULL, NULL, &v))
|
|
append_pathname(&f, ".");
|
|
ino = stat64_path(&f, &s) < 0 ? (ino64_t)r : s.st_ino;
|
|
check_cwd();
|
|
free_pathname(&f);
|
|
} else {
|
|
/*
|
|
* pick a random inode
|
|
*
|
|
* note this can generate kernel warning messages
|
|
* since bulkstat_one will read the disk block that
|
|
* would contain a given inode even if that disk
|
|
* block doesn't contain inodes.
|
|
*
|
|
* this is detected later, but not until after the
|
|
* warning is displayed.
|
|
*
|
|
* "XFS: device 0x825- bad inode magic/vsn daddr 0x0 #0"
|
|
*
|
|
*/
|
|
ino = (ino64_t)r;
|
|
v = verbose;
|
|
}
|
|
fd = open(".", O_RDONLY);
|
|
|
|
bsr.lastip=&ino;
|
|
bsr.icount=1;
|
|
bsr.ubuffer=&t;
|
|
bsr.ocount=NULL;
|
|
e = xfsctl(".", fd, XFS_IOC_FSBULKSTAT_SINGLE, &bsr) < 0 ? errno : 0;
|
|
if (v)
|
|
printf("%d/%lld: bulkstat1 %s ino %lld %d\n",
|
|
procid, opno, good?"real":"random",
|
|
verifiable_log ? -1LL : (long long)ino, e);
|
|
close(fd);
|
|
}
|
|
#endif
|
|
|
|
void
|
|
chown_f(opnum_t opno, long r)
|
|
{
|
|
int e;
|
|
pathname_t f;
|
|
int nbits;
|
|
uid_t u;
|
|
gid_t g;
|
|
int v;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_ANYm, r, &f, NULL, NULL, &v))
|
|
append_pathname(&f, ".");
|
|
u = (uid_t)random();
|
|
g = (gid_t)random();
|
|
nbits = (int)(random() % idmodulo);
|
|
u &= (1 << nbits) - 1;
|
|
g &= (1 << nbits) - 1;
|
|
e = lchown_path(&f, u, g) < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (v)
|
|
printf("%d/%lld: chown %s %d/%d %d\n", procid, opno, f.path, (int)u, (int)g, e);
|
|
free_pathname(&f);
|
|
}
|
|
|
|
#if 0
|
|
/* exchange some arbitrary range of f1 to f2...fn. */
|
|
void
|
|
xchgrange_f(
|
|
opnum_t opno,
|
|
long r)
|
|
{
|
|
#ifdef FIEXCHANGE_RANGE
|
|
struct file_xchg_range fxr = { 0 };
|
|
static __u64 swap_flags = 0;
|
|
struct pathname fpath1;
|
|
struct pathname fpath2;
|
|
struct stat64 stat1;
|
|
struct stat64 stat2;
|
|
char inoinfo1[1024];
|
|
char inoinfo2[1024];
|
|
off64_t lr;
|
|
off64_t off1;
|
|
off64_t off2;
|
|
off64_t max_off2;
|
|
size_t len;
|
|
int v1;
|
|
int v2;
|
|
int fd1;
|
|
int fd2;
|
|
int ret;
|
|
int tries = 0;
|
|
int e;
|
|
|
|
/* Load paths */
|
|
init_pathname(&fpath1);
|
|
if (!get_fname(FT_REGm, r, &fpath1, NULL, NULL, &v1)) {
|
|
if (v1)
|
|
printf("%d/%lld: xchgrange read - no filename\n",
|
|
procid, opno);
|
|
goto out_fpath1;
|
|
}
|
|
|
|
init_pathname(&fpath2);
|
|
if (!get_fname(FT_REGm, random(), &fpath2, NULL, NULL, &v2)) {
|
|
if (v2)
|
|
printf("%d/%lld: xchgrange write - no filename\n",
|
|
procid, opno);
|
|
goto out_fpath2;
|
|
}
|
|
|
|
/* Open files */
|
|
fd1 = open_path(&fpath1, O_RDONLY);
|
|
e = fd1 < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd1 < 0) {
|
|
if (v1)
|
|
printf("%d/%lld: xchgrange read - open %s failed %d\n",
|
|
procid, opno, fpath1.path, e);
|
|
goto out_fpath2;
|
|
}
|
|
|
|
fd2 = open_path(&fpath2, O_WRONLY);
|
|
e = fd2 < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd2 < 0) {
|
|
if (v2)
|
|
printf("%d/%lld: xchgrange write - open %s failed %d\n",
|
|
procid, opno, fpath2.path, e);
|
|
goto out_fd1;
|
|
}
|
|
|
|
/* Get file stats */
|
|
if (fstat64(fd1, &stat1) < 0) {
|
|
if (v1)
|
|
printf("%d/%lld: xchgrange read - fstat64 %s failed %d\n",
|
|
procid, opno, fpath1.path, errno);
|
|
goto out_fd2;
|
|
}
|
|
inode_info(inoinfo1, sizeof(inoinfo1), &stat1, v1);
|
|
|
|
if (fstat64(fd2, &stat2) < 0) {
|
|
if (v2)
|
|
printf("%d/%lld: xchgrange write - fstat64 %s failed %d\n",
|
|
procid, opno, fpath2.path, errno);
|
|
goto out_fd2;
|
|
}
|
|
inode_info(inoinfo2, sizeof(inoinfo2), &stat2, v2);
|
|
|
|
if (stat1.st_size < (stat1.st_blksize * 2) ||
|
|
stat2.st_size < (stat2.st_blksize * 2)) {
|
|
if (v2)
|
|
printf("%d/%lld: xchgrange - files are too small\n",
|
|
procid, opno);
|
|
goto out_fd2;
|
|
}
|
|
|
|
/* Never let us swap more than 1/4 of the files. */
|
|
len = (random() % FILELEN_MAX) + 1;
|
|
if (len > stat1.st_size / 4)
|
|
len = stat1.st_size / 4;
|
|
if (len > stat2.st_size / 4)
|
|
len = stat2.st_size / 4;
|
|
len = rounddown_64(len, stat1.st_blksize);
|
|
if (len == 0)
|
|
len = stat1.st_blksize;
|
|
|
|
/* Calculate offsets */
|
|
lr = ((int64_t)random() << 32) + random();
|
|
if (stat1.st_size == len)
|
|
off1 = 0;
|
|
else
|
|
off1 = (off64_t)(lr % MIN(stat1.st_size - len, MAXFSIZE));
|
|
off1 %= maxfsize;
|
|
off1 = rounddown_64(off1, stat1.st_blksize);
|
|
|
|
/*
|
|
* If srcfile == destfile, randomly generate destination ranges
|
|
* until we find one that doesn't overlap the source range.
|
|
*/
|
|
max_off2 = MIN(stat2.st_size - len, MAXFSIZE);
|
|
do {
|
|
lr = ((int64_t)random() << 32) + random();
|
|
if (stat2.st_size == len)
|
|
off2 = 0;
|
|
else
|
|
off2 = (off64_t)(lr % max_off2);
|
|
off2 %= maxfsize;
|
|
off2 = rounddown_64(off2, stat2.st_blksize);
|
|
} while (stat1.st_ino == stat2.st_ino &&
|
|
llabs(off2 - off1) < len &&
|
|
tries++ < 10);
|
|
|
|
/* Swap data blocks */
|
|
fxr.file1_fd = fd1;
|
|
fxr.file1_offset = off1;
|
|
fxr.length = len;
|
|
fxr.file2_offset = off2;
|
|
fxr.flags = swap_flags;
|
|
|
|
retry:
|
|
ret = ioctl(fd2, FIEXCHANGE_RANGE, &fxr);
|
|
e = ret < 0 ? errno : 0;
|
|
if (e == EOPNOTSUPP && !(swap_flags & FILE_XCHG_RANGE_NONATOMIC)) {
|
|
swap_flags = FILE_XCHG_RANGE_NONATOMIC;
|
|
fxr.flags |= swap_flags;
|
|
goto retry;
|
|
}
|
|
if (v1 || v2) {
|
|
printf("%d/%lld: xchgrange %s%s [%lld,%lld] -> %s%s [%lld,%lld]",
|
|
procid, opno,
|
|
fpath1.path, inoinfo1, (long long)off1, (long long)len,
|
|
fpath2.path, inoinfo2, (long long)off2, (long long)len);
|
|
|
|
if (ret < 0)
|
|
printf(" error %d", e);
|
|
printf("\n");
|
|
}
|
|
|
|
out_fd2:
|
|
close(fd2);
|
|
out_fd1:
|
|
close(fd1);
|
|
out_fpath2:
|
|
free_pathname(&fpath2);
|
|
out_fpath1:
|
|
free_pathname(&fpath1);
|
|
#endif
|
|
}
|
|
|
|
#endif
|
|
|
|
/* reflink some arbitrary range of f1 to f2. */
|
|
void
|
|
clonerange_f(
|
|
opnum_t opno,
|
|
long r)
|
|
{
|
|
#ifdef FICLONERANGE
|
|
struct file_clone_range fcr;
|
|
struct pathname fpath1;
|
|
struct pathname fpath2;
|
|
struct stat64 stat1;
|
|
struct stat64 stat2;
|
|
char inoinfo1[1024];
|
|
char inoinfo2[1024];
|
|
off64_t lr;
|
|
off64_t off1;
|
|
off64_t off2;
|
|
off64_t max_off2;
|
|
size_t len;
|
|
int v1;
|
|
int v2;
|
|
int fd1;
|
|
int fd2;
|
|
int ret;
|
|
int e;
|
|
|
|
/* Load paths */
|
|
init_pathname(&fpath1);
|
|
if (!get_fname(FT_REGm, r, &fpath1, NULL, NULL, &v1)) {
|
|
if (v1)
|
|
printf("%d/%lld: clonerange read - no filename\n",
|
|
procid, opno);
|
|
goto out_fpath1;
|
|
}
|
|
|
|
init_pathname(&fpath2);
|
|
if (!get_fname(FT_REGm, random(), &fpath2, NULL, NULL, &v2)) {
|
|
if (v2)
|
|
printf("%d/%lld: clonerange write - no filename\n",
|
|
procid, opno);
|
|
goto out_fpath2;
|
|
}
|
|
|
|
/* Open files */
|
|
fd1 = open_path(&fpath1, O_RDONLY);
|
|
e = fd1 < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd1 < 0) {
|
|
if (v1)
|
|
printf("%d/%lld: clonerange read - open %s failed %d\n",
|
|
procid, opno, fpath1.path, e);
|
|
goto out_fpath2;
|
|
}
|
|
|
|
fd2 = open_path(&fpath2, O_WRONLY);
|
|
e = fd2 < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd2 < 0) {
|
|
if (v2)
|
|
printf("%d/%lld: clonerange write - open %s failed %d\n",
|
|
procid, opno, fpath2.path, e);
|
|
goto out_fd1;
|
|
}
|
|
|
|
/* Get file stats */
|
|
if (fstat64(fd1, &stat1) < 0) {
|
|
if (v1)
|
|
printf("%d/%lld: clonerange read - fstat64 %s failed %d\n",
|
|
procid, opno, fpath1.path, errno);
|
|
goto out_fd2;
|
|
}
|
|
inode_info(inoinfo1, sizeof(inoinfo1), &stat1, v1);
|
|
|
|
if (fstat64(fd2, &stat2) < 0) {
|
|
if (v2)
|
|
printf("%d/%lld: clonerange write - fstat64 %s failed %d\n",
|
|
procid, opno, fpath2.path, errno);
|
|
goto out_fd2;
|
|
}
|
|
inode_info(inoinfo2, sizeof(inoinfo2), &stat2, v2);
|
|
|
|
/* Calculate offsets */
|
|
len = (random() % FILELEN_MAX) + 1;
|
|
len = rounddown_64(len, stat1.st_blksize);
|
|
if (len == 0)
|
|
len = stat1.st_blksize;
|
|
if (len > stat1.st_size)
|
|
len = stat1.st_size;
|
|
|
|
lr = ((int64_t)random() << 32) + random();
|
|
if (stat1.st_size == len)
|
|
off1 = 0;
|
|
else
|
|
off1 = (off64_t)(lr % MIN(stat1.st_size - len, MAXFSIZE));
|
|
off1 %= maxfsize;
|
|
off1 = rounddown_64(off1, stat1.st_blksize);
|
|
|
|
/*
|
|
* If srcfile == destfile, randomly generate destination ranges
|
|
* until we find one that doesn't overlap the source range.
|
|
*/
|
|
max_off2 = MIN(stat2.st_size + (1024ULL * stat2.st_blksize), MAXFSIZE);
|
|
do {
|
|
lr = ((int64_t)random() << 32) + random();
|
|
off2 = (off64_t)(lr % max_off2);
|
|
off2 %= maxfsize;
|
|
off2 = rounddown_64(off2, stat2.st_blksize);
|
|
} while (stat1.st_ino == stat2.st_ino && llabs(off2 - off1) < len);
|
|
|
|
/* Clone data blocks */
|
|
fcr.src_fd = fd1;
|
|
fcr.src_offset = off1;
|
|
fcr.src_length = len;
|
|
fcr.dest_offset = off2;
|
|
|
|
ret = ioctl(fd2, FICLONERANGE, &fcr);
|
|
e = ret < 0 ? errno : 0;
|
|
if (v1 || v2) {
|
|
printf("%d/%lld: clonerange %s%s [%lld,%lld] -> %s%s [%lld,%lld]",
|
|
procid, opno,
|
|
fpath1.path, inoinfo1, (long long)off1, (long long)len,
|
|
fpath2.path, inoinfo2, (long long)off2, (long long)len);
|
|
|
|
if (ret < 0)
|
|
printf(" error %d", e);
|
|
printf("\n");
|
|
}
|
|
|
|
out_fd2:
|
|
close(fd2);
|
|
out_fd1:
|
|
close(fd1);
|
|
out_fpath2:
|
|
free_pathname(&fpath2);
|
|
out_fpath1:
|
|
free_pathname(&fpath1);
|
|
#endif
|
|
}
|
|
|
|
/* copy some arbitrary range of f1 to f2. */
|
|
void
|
|
copyrange_f(
|
|
opnum_t opno,
|
|
long r)
|
|
{
|
|
#ifdef HAVE_COPY_FILE_RANGE
|
|
struct pathname fpath1;
|
|
struct pathname fpath2;
|
|
struct stat64 stat1;
|
|
struct stat64 stat2;
|
|
char inoinfo1[1024];
|
|
char inoinfo2[1024];
|
|
loff_t lr;
|
|
loff_t off1;
|
|
loff_t off2;
|
|
loff_t offset1;
|
|
loff_t offset2;
|
|
loff_t max_off2;
|
|
size_t len;
|
|
size_t length;
|
|
int tries = 0;
|
|
int v1;
|
|
int v2;
|
|
int fd1;
|
|
int fd2;
|
|
size_t ret = 0;
|
|
int e;
|
|
|
|
/* Load paths */
|
|
init_pathname(&fpath1);
|
|
if (!get_fname(FT_REGm, r, &fpath1, NULL, NULL, &v1)) {
|
|
if (v1)
|
|
printf("%d/%lld: copyrange read - no filename\n",
|
|
procid, opno);
|
|
goto out_fpath1;
|
|
}
|
|
|
|
init_pathname(&fpath2);
|
|
if (!get_fname(FT_REGm, random(), &fpath2, NULL, NULL, &v2)) {
|
|
if (v2)
|
|
printf("%d/%lld: copyrange write - no filename\n",
|
|
procid, opno);
|
|
goto out_fpath2;
|
|
}
|
|
|
|
/* Open files */
|
|
fd1 = open_path(&fpath1, O_RDONLY);
|
|
e = fd1 < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd1 < 0) {
|
|
if (v1)
|
|
printf("%d/%lld: copyrange read - open %s failed %d\n",
|
|
procid, opno, fpath1.path, e);
|
|
goto out_fpath2;
|
|
}
|
|
|
|
fd2 = open_path(&fpath2, O_WRONLY);
|
|
e = fd2 < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd2 < 0) {
|
|
if (v2)
|
|
printf("%d/%lld: copyrange write - open %s failed %d\n",
|
|
procid, opno, fpath2.path, e);
|
|
goto out_fd1;
|
|
}
|
|
|
|
/* Get file stats */
|
|
if (fstat64(fd1, &stat1) < 0) {
|
|
if (v1)
|
|
printf("%d/%lld: copyrange read - fstat64 %s failed %d\n",
|
|
procid, opno, fpath1.path, errno);
|
|
goto out_fd2;
|
|
}
|
|
inode_info(inoinfo1, sizeof(inoinfo1), &stat1, v1);
|
|
|
|
if (fstat64(fd2, &stat2) < 0) {
|
|
if (v2)
|
|
printf("%d/%lld: copyrange write - fstat64 %s failed %d\n",
|
|
procid, opno, fpath2.path, errno);
|
|
goto out_fd2;
|
|
}
|
|
inode_info(inoinfo2, sizeof(inoinfo2), &stat2, v2);
|
|
|
|
/* Calculate offsets */
|
|
len = (random() % FILELEN_MAX) + 1;
|
|
if (len == 0)
|
|
len = stat1.st_blksize;
|
|
if (len > stat1.st_size)
|
|
len = stat1.st_size;
|
|
|
|
lr = ((int64_t)random() << 32) + random();
|
|
if (stat1.st_size == len)
|
|
off1 = 0;
|
|
else
|
|
off1 = (off64_t)(lr % MIN(stat1.st_size - len, MAXFSIZE));
|
|
off1 %= maxfsize;
|
|
|
|
/*
|
|
* If srcfile == destfile, randomly generate destination ranges
|
|
* until we find one that doesn't overlap the source range.
|
|
*/
|
|
max_off2 = MIN(stat2.st_size + (1024ULL * stat2.st_blksize), MAXFSIZE);
|
|
do {
|
|
lr = ((int64_t)random() << 32) + random();
|
|
off2 = (off64_t)(lr % max_off2);
|
|
off2 %= maxfsize;
|
|
} while (stat1.st_ino == stat2.st_ino && llabs(off2 - off1) < len);
|
|
|
|
/*
|
|
* Since len, off1 and off2 will be changed later, preserve their
|
|
* original values.
|
|
*/
|
|
length = len;
|
|
offset1 = off1;
|
|
offset2 = off2;
|
|
|
|
while (len > 0) {
|
|
ret = syscall(__NR_copy_file_range, fd1, &off1, fd2, &off2,
|
|
len, 0);
|
|
if (ret < 0) {
|
|
if (errno != EAGAIN || tries++ >= 300)
|
|
break;
|
|
} else if (ret > len || ret == 0)
|
|
break;
|
|
else if (ret > 0)
|
|
len -= ret;
|
|
}
|
|
e = ret < 0 ? errno : 0;
|
|
if (v1 || v2) {
|
|
printf("%d/%lld: copyrange %s%s [%lld,%lld] -> %s%s [%lld,%lld]",
|
|
procid, opno,
|
|
fpath1.path, inoinfo1,
|
|
(long long)offset1, (long long)length,
|
|
fpath2.path, inoinfo2,
|
|
(long long)offset2, (long long)length);
|
|
|
|
if (ret < 0)
|
|
printf(" error %d", e);
|
|
else if (len && ret > len)
|
|
printf(" asked for %lld, copied %lld??\n",
|
|
(long long)len, (long long)ret);
|
|
printf("\n");
|
|
}
|
|
|
|
out_fd2:
|
|
close(fd2);
|
|
out_fd1:
|
|
close(fd1);
|
|
out_fpath2:
|
|
free_pathname(&fpath2);
|
|
out_fpath1:
|
|
free_pathname(&fpath1);
|
|
#endif
|
|
}
|
|
|
|
/* dedupe some arbitrary range of f1 to f2...fn. */
|
|
void
|
|
deduperange_f(
|
|
opnum_t opno,
|
|
long r)
|
|
{
|
|
#ifdef FIDEDUPERANGE
|
|
#define INFO_SZ 1024
|
|
struct file_dedupe_range *fdr;
|
|
struct pathname *fpath;
|
|
struct stat64 *stat;
|
|
char *info;
|
|
off64_t *off;
|
|
int *v;
|
|
int *fd;
|
|
int nr;
|
|
off64_t lr;
|
|
size_t len;
|
|
int ret;
|
|
int i;
|
|
int e;
|
|
|
|
if (flist[FT_REG].nfiles < 2)
|
|
return;
|
|
|
|
/* Pick somewhere between 2 and 128 files. */
|
|
do {
|
|
nr = random() % (flist[FT_REG].nfiles + 1);
|
|
} while (nr < 2 || nr > 128);
|
|
|
|
/* Alloc memory */
|
|
fdr = malloc(nr * sizeof(struct file_dedupe_range_info) +
|
|
sizeof(struct file_dedupe_range));
|
|
if (!fdr) {
|
|
printf("%d/%lld: line %d error %d\n",
|
|
procid, opno, __LINE__, errno);
|
|
return;
|
|
}
|
|
memset(fdr, 0, (nr * sizeof(struct file_dedupe_range_info) +
|
|
sizeof(struct file_dedupe_range)));
|
|
|
|
fpath = calloc(nr, sizeof(struct pathname));
|
|
if (!fpath) {
|
|
printf("%d/%lld: line %d error %d\n",
|
|
procid, opno, __LINE__, errno);
|
|
goto out_fdr;
|
|
}
|
|
|
|
stat = calloc(nr, sizeof(struct stat64));
|
|
if (!stat) {
|
|
printf("%d/%lld: line %d error %d\n",
|
|
procid, opno, __LINE__, errno);
|
|
goto out_paths;
|
|
}
|
|
|
|
info = calloc(nr, INFO_SZ);
|
|
if (!info) {
|
|
printf("%d/%lld: line %d error %d\n",
|
|
procid, opno, __LINE__, errno);
|
|
goto out_stats;
|
|
}
|
|
|
|
off = calloc(nr, sizeof(off64_t));
|
|
if (!off) {
|
|
printf("%d/%lld: line %d error %d\n",
|
|
procid, opno, __LINE__, errno);
|
|
goto out_info;
|
|
}
|
|
|
|
v = calloc(nr, sizeof(int));
|
|
if (!v) {
|
|
printf("%d/%lld: line %d error %d\n",
|
|
procid, opno, __LINE__, errno);
|
|
goto out_offsets;
|
|
}
|
|
fd = calloc(nr, sizeof(int));
|
|
if (!fd) {
|
|
printf("%d/%lld: line %d error %d\n",
|
|
procid, opno, __LINE__, errno);
|
|
goto out_v;
|
|
}
|
|
memset(fd, 0xFF, nr * sizeof(int));
|
|
|
|
/* Get paths for all files */
|
|
for (i = 0; i < nr; i++)
|
|
init_pathname(&fpath[i]);
|
|
|
|
if (!get_fname(FT_REGm, r, &fpath[0], NULL, NULL, &v[0])) {
|
|
if (v[0])
|
|
printf("%d/%lld: deduperange read - no filename\n",
|
|
procid, opno);
|
|
goto out_pathnames;
|
|
}
|
|
|
|
for (i = 1; i < nr; i++) {
|
|
if (!get_fname(FT_REGm, random(), &fpath[i], NULL, NULL, &v[i])) {
|
|
if (v[i])
|
|
printf("%d/%lld: deduperange write - no filename\n",
|
|
procid, opno);
|
|
goto out_pathnames;
|
|
}
|
|
}
|
|
|
|
/* Open files */
|
|
fd[0] = open_path(&fpath[0], O_RDONLY);
|
|
e = fd[0] < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd[0] < 0) {
|
|
if (v[0])
|
|
printf("%d/%lld: deduperange read - open %s failed %d\n",
|
|
procid, opno, fpath[0].path, e);
|
|
goto out_pathnames;
|
|
}
|
|
|
|
for (i = 1; i < nr; i++) {
|
|
fd[i] = open_path(&fpath[i], O_WRONLY);
|
|
e = fd[i] < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd[i] < 0) {
|
|
if (v[i])
|
|
printf("%d/%lld: deduperange write - open %s failed %d\n",
|
|
procid, opno, fpath[i].path, e);
|
|
goto out_fds;
|
|
}
|
|
}
|
|
|
|
/* Get file stats */
|
|
if (fstat64(fd[0], &stat[0]) < 0) {
|
|
if (v[0])
|
|
printf("%d/%lld: deduperange read - fstat64 %s failed %d\n",
|
|
procid, opno, fpath[0].path, errno);
|
|
goto out_fds;
|
|
}
|
|
|
|
inode_info(&info[0], INFO_SZ, &stat[0], v[0]);
|
|
|
|
for (i = 1; i < nr; i++) {
|
|
if (fstat64(fd[i], &stat[i]) < 0) {
|
|
if (v[i])
|
|
printf("%d/%lld: deduperange write - fstat64 %s failed %d\n",
|
|
procid, opno, fpath[i].path, errno);
|
|
goto out_fds;
|
|
}
|
|
inode_info(&info[i * INFO_SZ], INFO_SZ, &stat[i], v[i]);
|
|
}
|
|
|
|
/* Never try to dedupe more than half of the src file. */
|
|
len = (random() % FILELEN_MAX) + 1;
|
|
len = rounddown_64(len, stat[0].st_blksize);
|
|
if (len == 0)
|
|
len = stat[0].st_blksize / 2;
|
|
if (len > stat[0].st_size / 2)
|
|
len = stat[0].st_size / 2;
|
|
|
|
/* Calculate offsets */
|
|
lr = ((int64_t)random() << 32) + random();
|
|
if (stat[0].st_size == len)
|
|
off[0] = 0;
|
|
else
|
|
off[0] = (off64_t)(lr % MIN(stat[0].st_size - len, MAXFSIZE));
|
|
off[0] %= maxfsize;
|
|
off[0] = rounddown_64(off[0], stat[0].st_blksize);
|
|
|
|
/*
|
|
* If srcfile == destfile[i], randomly generate destination ranges
|
|
* until we find one that doesn't overlap the source range.
|
|
*/
|
|
for (i = 1; i < nr; i++) {
|
|
int tries = 0;
|
|
|
|
do {
|
|
lr = ((int64_t)random() << 32) + random();
|
|
if (stat[i].st_size <= len)
|
|
off[i] = 0;
|
|
else
|
|
off[i] = (off64_t)(lr % MIN(stat[i].st_size - len, MAXFSIZE));
|
|
off[i] %= maxfsize;
|
|
off[i] = rounddown_64(off[i], stat[i].st_blksize);
|
|
} while (stat[0].st_ino == stat[i].st_ino &&
|
|
llabs(off[i] - off[0]) < len &&
|
|
tries++ < 10);
|
|
}
|
|
|
|
/* Clone data blocks */
|
|
fdr->src_offset = off[0];
|
|
fdr->src_length = len;
|
|
fdr->dest_count = nr - 1;
|
|
for (i = 1; i < nr; i++) {
|
|
fdr->info[i - 1].dest_fd = fd[i];
|
|
fdr->info[i - 1].dest_offset = off[i];
|
|
}
|
|
|
|
ret = ioctl(fd[0], FIDEDUPERANGE, fdr);
|
|
e = ret < 0 ? errno : 0;
|
|
if (v[0]) {
|
|
printf("%d/%lld: deduperange from %s%s [%lld,%lld]",
|
|
procid, opno,
|
|
fpath[0].path, &info[0], (long long)off[0],
|
|
(long long)len);
|
|
if (ret < 0)
|
|
printf(" error %d", e);
|
|
printf("\n");
|
|
}
|
|
if (ret < 0)
|
|
goto out_fds;
|
|
|
|
for (i = 1; i < nr; i++) {
|
|
e = fdr->info[i - 1].status < 0 ? fdr->info[i - 1].status : 0;
|
|
if (v[i]) {
|
|
printf("%d/%lld: ...to %s%s [%lld,%lld]",
|
|
procid, opno,
|
|
fpath[i].path, &info[i * INFO_SZ],
|
|
(long long)off[i], (long long)len);
|
|
if (fdr->info[i - 1].status < 0)
|
|
printf(" error %d", e);
|
|
if (fdr->info[i - 1].status == FILE_DEDUPE_RANGE_SAME)
|
|
printf(" %llu bytes deduplicated",
|
|
fdr->info[i - 1].bytes_deduped);
|
|
if (fdr->info[i - 1].status == FILE_DEDUPE_RANGE_DIFFERS)
|
|
printf(" differed");
|
|
printf("\n");
|
|
}
|
|
}
|
|
|
|
out_fds:
|
|
for (i = 0; i < nr; i++)
|
|
if (fd[i] >= 0)
|
|
close(fd[i]);
|
|
out_pathnames:
|
|
for (i = 0; i < nr; i++)
|
|
free_pathname(&fpath[i]);
|
|
|
|
free(fd);
|
|
out_v:
|
|
free(v);
|
|
out_offsets:
|
|
free(off);
|
|
out_info:
|
|
free(info);
|
|
out_stats:
|
|
free(stat);
|
|
out_paths:
|
|
free(fpath);
|
|
out_fdr:
|
|
free(fdr);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
setxattr_f(opnum_t opno, long r)
|
|
{
|
|
#ifdef XFS_XFLAG_EXTSIZE
|
|
struct fsxattr fsx;
|
|
int fd;
|
|
int e;
|
|
pathname_t f;
|
|
int nbits;
|
|
uint p;
|
|
int v;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_ANYm, r, &f, NULL, NULL, &v))
|
|
append_pathname(&f, ".");
|
|
fd = open_path(&f, O_RDWR);
|
|
e = fd < 0 ? errno : 0;
|
|
check_cwd();
|
|
|
|
/* project ID */
|
|
p = (uint)random();
|
|
e = MIN(idmodulo, XFS_PROJIDMODULO_MAX);
|
|
nbits = (int)(random() % e);
|
|
p &= (1 << nbits) - 1;
|
|
|
|
if ((e = xfsctl(f.path, fd, XFS_IOC_FSGETXATTR, &fsx)) == 0) {
|
|
fsx.fsx_projid = p;
|
|
e = xfsctl(f.path, fd, XFS_IOC_FSSETXATTR, &fsx);
|
|
}
|
|
if (v)
|
|
printf("%d/%lld: setxattr %s %u %d\n", procid, opno, f.path, p, e);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
splice_f(opnum_t opno, long r)
|
|
{
|
|
struct pathname fpath1;
|
|
struct pathname fpath2;
|
|
struct stat64 stat1;
|
|
struct stat64 stat2;
|
|
char inoinfo1[1024];
|
|
char inoinfo2[1024];
|
|
loff_t lr;
|
|
loff_t off1, off2;
|
|
size_t len;
|
|
loff_t offset1, offset2;
|
|
size_t length;
|
|
size_t total;
|
|
int v1;
|
|
int v2;
|
|
int fd1;
|
|
int fd2;
|
|
ssize_t ret1 = 0, ret2 = 0;
|
|
size_t bytes;
|
|
int e;
|
|
int filedes[2];
|
|
|
|
/* Load paths */
|
|
init_pathname(&fpath1);
|
|
if (!get_fname(FT_REGm, r, &fpath1, NULL, NULL, &v1)) {
|
|
if (v1)
|
|
printf("%d/%lld: splice read - no filename\n",
|
|
procid, opno);
|
|
goto out_fpath1;
|
|
}
|
|
|
|
init_pathname(&fpath2);
|
|
if (!get_fname(FT_REGm, random(), &fpath2, NULL, NULL, &v2)) {
|
|
if (v2)
|
|
printf("%d/%lld: splice write - no filename\n",
|
|
procid, opno);
|
|
goto out_fpath2;
|
|
}
|
|
|
|
/* Open files */
|
|
fd1 = open_path(&fpath1, O_RDONLY);
|
|
e = fd1 < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd1 < 0) {
|
|
if (v1)
|
|
printf("%d/%lld: splice read - open %s failed %d\n",
|
|
procid, opno, fpath1.path, e);
|
|
goto out_fpath2;
|
|
}
|
|
|
|
fd2 = open_path(&fpath2, O_WRONLY);
|
|
e = fd2 < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd2 < 0) {
|
|
if (v2)
|
|
printf("%d/%lld: splice write - open %s failed %d\n",
|
|
procid, opno, fpath2.path, e);
|
|
goto out_fd1;
|
|
}
|
|
|
|
/* Get file stats */
|
|
if (fstat64(fd1, &stat1) < 0) {
|
|
if (v1)
|
|
printf("%d/%lld: splice read - fstat64 %s failed %d\n",
|
|
procid, opno, fpath1.path, errno);
|
|
goto out_fd2;
|
|
}
|
|
inode_info(inoinfo1, sizeof(inoinfo1), &stat1, v1);
|
|
|
|
if (fstat64(fd2, &stat2) < 0) {
|
|
if (v2)
|
|
printf("%d/%lld: splice write - fstat64 %s failed %d\n",
|
|
procid, opno, fpath2.path, errno);
|
|
goto out_fd2;
|
|
}
|
|
inode_info(inoinfo2, sizeof(inoinfo2), &stat2, v2);
|
|
|
|
/* Calculate offsets */
|
|
len = (random() % FILELEN_MAX) + 1;
|
|
if (len == 0)
|
|
len = stat1.st_blksize;
|
|
if (len > stat1.st_size)
|
|
len = stat1.st_size;
|
|
|
|
lr = ((int64_t)random() << 32) + random();
|
|
if (stat1.st_size == len)
|
|
off1 = 0;
|
|
else
|
|
off1 = (off64_t)(lr % MIN(stat1.st_size - len, MAXFSIZE));
|
|
off1 %= maxfsize;
|
|
|
|
/*
|
|
* splice can overlap write, so the offset of the target file can be
|
|
* any number. But to avoid too large offset, add a clamp of 1024 blocks
|
|
* past the current dest file EOF
|
|
*/
|
|
lr = ((int64_t)random() << 32) + random();
|
|
off2 = (off64_t)(lr % MIN(stat2.st_size + (1024ULL * stat2.st_blksize), MAXFSIZE));
|
|
|
|
/*
|
|
* Since len, off1 and off2 will be changed later, preserve their
|
|
* original values.
|
|
*/
|
|
length = len;
|
|
offset1 = off1;
|
|
offset2 = off2;
|
|
|
|
/* Pipe initialize */
|
|
if (pipe(filedes) < 0) {
|
|
if (v1 || v2) {
|
|
printf("%d/%lld: splice - pipe failed %d\n",
|
|
procid, opno, errno);
|
|
goto out_fd2;
|
|
}
|
|
}
|
|
|
|
bytes = 0;
|
|
total = 0;
|
|
while (len > 0) {
|
|
/* move to pipe buffer */
|
|
ret1 = splice(fd1, &off1, filedes[1], NULL, len, 0);
|
|
if (ret1 <= 0) {
|
|
break;
|
|
}
|
|
bytes = ret1;
|
|
|
|
/* move from pipe buffer to dst file */
|
|
while (bytes > 0) {
|
|
ret2 = splice(filedes[0], NULL, fd2, &off2, bytes, 0);
|
|
if (ret2 < 0) {
|
|
break;
|
|
}
|
|
bytes -= ret2;
|
|
}
|
|
if (ret2 < 0)
|
|
break;
|
|
|
|
len -= ret1;
|
|
total += ret1;
|
|
}
|
|
|
|
if (ret1 < 0 || ret2 < 0)
|
|
e = errno;
|
|
else
|
|
e = 0;
|
|
if (v1 || v2) {
|
|
printf("%d/%lld: splice %s%s [%lld,%lld] -> %s%s [%lld,%lld] %d",
|
|
procid, opno,
|
|
fpath1.path, inoinfo1, (long long)offset1, (long long)length,
|
|
fpath2.path, inoinfo2, (long long)offset2, (long long)length, e);
|
|
|
|
if (length && length > total)
|
|
printf(" asked for %lld, spliced %lld??\n",
|
|
(long long)length, (long long)total);
|
|
printf("\n");
|
|
}
|
|
|
|
close(filedes[0]);
|
|
close(filedes[1]);
|
|
out_fd2:
|
|
close(fd2);
|
|
out_fd1:
|
|
close(fd1);
|
|
out_fpath2:
|
|
free_pathname(&fpath2);
|
|
out_fpath1:
|
|
free_pathname(&fpath1);
|
|
}
|
|
|
|
void
|
|
creat_f(opnum_t opno, long r)
|
|
{
|
|
struct fsxattr a;
|
|
int e;
|
|
int e1;
|
|
int extsize;
|
|
pathname_t f;
|
|
int fd;
|
|
fent_t *fep;
|
|
int id;
|
|
int parid;
|
|
int type;
|
|
int v;
|
|
int v1;
|
|
|
|
if (!get_fname(FT_ANYDIR, r, NULL, NULL, &fep, &v1))
|
|
parid = -1;
|
|
else
|
|
parid = fep->id;
|
|
init_pathname(&f);
|
|
e1 = (random() % 100);
|
|
type = rtpct ? ((e1 > rtpct) ? FT_REG : FT_RTF) : FT_REG;
|
|
#ifdef NOTYET
|
|
if (type == FT_RTF) /* rt always gets an extsize */
|
|
extsize = (random() % 10) + 1;
|
|
else if (e1 < 10) /* one-in-ten get an extsize */
|
|
extsize = random() % 1024;
|
|
else
|
|
#endif
|
|
extsize = 0;
|
|
e = generate_fname(fep, type, &f, &id, &v);
|
|
v |= v1;
|
|
if (!e) {
|
|
if (v) {
|
|
(void)fent_to_name(&f, fep);
|
|
printf("%d/%lld: creat - no filename from %s\n",
|
|
procid, opno, f.path);
|
|
}
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
fd = creat_path(&f, 0666);
|
|
e = fd < 0 ? errno : 0;
|
|
e1 = 0;
|
|
check_cwd();
|
|
if (fd >= 0) {
|
|
#if 0
|
|
if (extsize &&
|
|
xfsctl(f.path, fd, XFS_IOC_FSGETXATTR, &a) >= 0) {
|
|
if (type == FT_RTF) {
|
|
a.fsx_xflags |= XFS_XFLAG_REALTIME;
|
|
a.fsx_extsize = extsize *
|
|
geom.rtextsize * geom.blocksize;
|
|
#ifdef NOTYET
|
|
} else if (extsize) {
|
|
a.fsx_xflags |= XFS_XFLAG_EXTSIZE;
|
|
a.fsx_extsize = extsize * geom.blocksize;
|
|
#endif
|
|
}
|
|
if (xfsctl(f.path, fd, XFS_IOC_FSSETXATTR, &a) < 0)
|
|
e1 = errno;
|
|
}
|
|
add_to_flist(type, id, parid, 0);
|
|
#endif
|
|
close(fd);
|
|
}
|
|
if (v) {
|
|
printf("%d/%lld: creat %s x:%d %d %d\n", procid, opno, f.path,
|
|
extsize ? a.fsx_extsize : 0, e, e1);
|
|
printf("%d/%lld: creat add id=%d,parent=%d\n", procid, opno, id, parid);
|
|
}
|
|
free_pathname(&f);
|
|
}
|
|
|
|
void
|
|
dread_f(opnum_t opno, long r)
|
|
{
|
|
int64_t align;
|
|
char *buf;
|
|
struct dioattr diob;
|
|
int e;
|
|
pathname_t f;
|
|
int fd;
|
|
size_t len;
|
|
int64_t lr;
|
|
off64_t off;
|
|
struct stat64 stb;
|
|
int v;
|
|
char st[1024];
|
|
char *dio_env;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: dread - no filename\n", procid, opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
fd = open_path(&f, O_RDONLY|O_DIRECT);
|
|
e = fd < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd < 0) {
|
|
if (v)
|
|
printf("%d/%lld: dread - open %s failed %d\n",
|
|
procid, opno, f.path, e);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
if (fstat64(fd, &stb) < 0) {
|
|
if (v)
|
|
printf("%d/%lld: dread - fstat64 %s failed %d\n",
|
|
procid, opno, f.path, errno);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
return;
|
|
}
|
|
inode_info(st, sizeof(st), &stb, v);
|
|
if (stb.st_size == 0) {
|
|
if (v)
|
|
printf("%d/%lld: dread - %s%s zero size\n", procid, opno,
|
|
f.path, st);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
return;
|
|
}
|
|
#if 0
|
|
if (xfsctl(f.path, fd, XFS_IOC_DIOINFO, &diob) < 0) {
|
|
#endif
|
|
if (v)
|
|
printf(
|
|
"%d/%lld: dread - xfsctl(XFS_IOC_DIOINFO) %s%s return %d,"
|
|
" fallback to stat()\n",
|
|
procid, opno, f.path, st, errno);
|
|
diob.d_mem = diob.d_miniosz = stb.st_blksize;
|
|
diob.d_maxiosz = rounddown_64(INT_MAX, diob.d_miniosz);
|
|
#if 0
|
|
}
|
|
#endif
|
|
|
|
dio_env = getenv("XFS_DIO_MIN");
|
|
if (dio_env)
|
|
diob.d_mem = diob.d_miniosz = atoi(dio_env);
|
|
|
|
align = (int64_t)diob.d_miniosz;
|
|
lr = ((int64_t)random() << 32) + random();
|
|
off = (off64_t)(lr % stb.st_size);
|
|
off -= (off % align);
|
|
lseek64(fd, off, SEEK_SET);
|
|
len = (random() % FILELEN_MAX) + 1;
|
|
len -= (len % align);
|
|
if (len <= 0)
|
|
len = align;
|
|
else if (len > diob.d_maxiosz)
|
|
len = diob.d_maxiosz;
|
|
buf = memalign(diob.d_mem, len);
|
|
e = read(fd, buf, len) < 0 ? errno : 0;
|
|
free(buf);
|
|
if (v)
|
|
printf("%d/%lld: dread %s%s [%lld,%d] %d\n",
|
|
procid, opno, f.path, st, (long long)off, (int)len, e);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
}
|
|
|
|
void
|
|
dwrite_f(opnum_t opno, long r)
|
|
{
|
|
int64_t align;
|
|
char *buf;
|
|
struct dioattr diob;
|
|
int e;
|
|
pathname_t f;
|
|
int fd;
|
|
size_t len;
|
|
int64_t lr;
|
|
off64_t off;
|
|
struct stat64 stb;
|
|
int v;
|
|
char st[1024];
|
|
char *dio_env;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: dwrite - no filename\n", procid, opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
fd = open_path(&f, O_WRONLY|O_DIRECT);
|
|
e = fd < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd < 0) {
|
|
if (v)
|
|
printf("%d/%lld: dwrite - open %s failed %d\n",
|
|
procid, opno, f.path, e);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
if (fstat64(fd, &stb) < 0) {
|
|
if (v)
|
|
printf("%d/%lld: dwrite - fstat64 %s failed %d\n",
|
|
procid, opno, f.path, errno);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
return;
|
|
}
|
|
inode_info(st, sizeof(st), &stb, v);
|
|
#if 0
|
|
if (xfsctl(f.path, fd, XFS_IOC_DIOINFO, &diob) < 0) {
|
|
#endif
|
|
if (v)
|
|
printf("%d/%lld: dwrite - xfsctl(XFS_IOC_DIOINFO)"
|
|
" %s%s return %d, fallback to stat()\n",
|
|
procid, opno, f.path, st, errno);
|
|
diob.d_mem = diob.d_miniosz = stb.st_blksize;
|
|
diob.d_maxiosz = rounddown_64(INT_MAX, diob.d_miniosz);
|
|
#if 0
|
|
}
|
|
#endif
|
|
|
|
dio_env = getenv("XFS_DIO_MIN");
|
|
if (dio_env)
|
|
diob.d_mem = diob.d_miniosz = atoi(dio_env);
|
|
|
|
align = (int64_t)diob.d_miniosz;
|
|
lr = ((int64_t)random() << 32) + random();
|
|
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
|
|
off -= (off % align);
|
|
lseek64(fd, off, SEEK_SET);
|
|
len = (random() % FILELEN_MAX) + 1;
|
|
len -= (len % align);
|
|
if (len <= 0)
|
|
len = align;
|
|
else if (len > diob.d_maxiosz)
|
|
len = diob.d_maxiosz;
|
|
buf = memalign(diob.d_mem, len);
|
|
off %= maxfsize;
|
|
lseek64(fd, off, SEEK_SET);
|
|
memset(buf, nameseq & 0xff, len);
|
|
e = write(fd, buf, len) < 0 ? errno : 0;
|
|
free(buf);
|
|
if (v)
|
|
printf("%d/%lld: dwrite %s%s [%lld,%d] %d\n",
|
|
procid, opno, f.path, st, (long long)off, (int)len, e);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
}
|
|
|
|
|
|
#ifdef HAVE_LINUX_FALLOC_H
|
|
struct print_flags falloc_flags [] = {
|
|
{ FALLOC_FL_KEEP_SIZE, "KEEP_SIZE"},
|
|
{ FALLOC_FL_PUNCH_HOLE, "PUNCH_HOLE"},
|
|
{ FALLOC_FL_NO_HIDE_STALE, "NO_HIDE_STALE"},
|
|
{ FALLOC_FL_COLLAPSE_RANGE, "COLLAPSE_RANGE"},
|
|
{ FALLOC_FL_ZERO_RANGE, "ZERO_RANGE"},
|
|
{ FALLOC_FL_INSERT_RANGE, "INSERT_RANGE"},
|
|
{ -1, NULL}
|
|
};
|
|
|
|
#define translate_falloc_flags(mode) \
|
|
({translate_flags(mode, "|", falloc_flags);})
|
|
#endif
|
|
|
|
#ifdef HAVE_LINUX_FALLOC_H
|
|
static void
|
|
do_fallocate(opnum_t opno, long r, int mode)
|
|
{
|
|
int e;
|
|
pathname_t f;
|
|
int fd;
|
|
int64_t lr;
|
|
off64_t off;
|
|
off64_t len;
|
|
struct stat64 stb;
|
|
int v;
|
|
char st[1024];
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: do_fallocate - no filename\n", procid, opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
fd = open_path(&f, O_RDWR);
|
|
if (fd < 0) {
|
|
if (v)
|
|
printf("%d/%lld: do_fallocate - open %s failed %d\n",
|
|
procid, opno, f.path, errno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
check_cwd();
|
|
if (fstat64(fd, &stb) < 0) {
|
|
if (v)
|
|
printf("%d/%lld: do_fallocate - fstat64 %s failed %d\n",
|
|
procid, opno, f.path, errno);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
return;
|
|
}
|
|
inode_info(st, sizeof(st), &stb, v);
|
|
lr = ((int64_t)random() << 32) + random();
|
|
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
|
|
off %= maxfsize;
|
|
len = (off64_t)(random() % (1024 * 1024));
|
|
/*
|
|
* Collapse/insert range requires off and len to be block aligned,
|
|
* make it more likely to be the case.
|
|
*/
|
|
if ((mode & (FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_INSERT_RANGE)) &&
|
|
(opno % 2)) {
|
|
off = roundup_64(off, stb.st_blksize);
|
|
len = roundup_64(len, stb.st_blksize);
|
|
}
|
|
mode |= FALLOC_FL_KEEP_SIZE & random();
|
|
e = fallocate(fd, mode, (loff_t)off, (loff_t)len) < 0 ? errno : 0;
|
|
if (v)
|
|
printf("%d/%lld: fallocate(%s) %s %st %lld %lld %d\n",
|
|
procid, opno, translate_falloc_flags(mode),
|
|
f.path, st, (long long)off, (long long)len, e);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
}
|
|
#endif
|
|
|
|
void
|
|
fallocate_f(opnum_t opno, long r)
|
|
{
|
|
#ifdef HAVE_LINUX_FALLOC_H
|
|
do_fallocate(opno, r, 0);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
fdatasync_f(opnum_t opno, long r)
|
|
{
|
|
int e;
|
|
pathname_t f;
|
|
int fd;
|
|
int v;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: fdatasync - no filename\n",
|
|
procid, opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
fd = open_path(&f, O_WRONLY);
|
|
e = fd < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd < 0) {
|
|
if (v)
|
|
printf("%d/%lld: fdatasync - open %s failed %d\n",
|
|
procid, opno, f.path, e);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
e = fdatasync(fd) < 0 ? errno : 0;
|
|
if (v)
|
|
printf("%d/%lld: fdatasync %s %d\n", procid, opno, f.path, e);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
}
|
|
|
|
#ifdef HAVE_LINUX_FIEMAP_H
|
|
struct print_flags fiemap_flags[] = {
|
|
{ FIEMAP_FLAG_SYNC, "SYNC"},
|
|
{ FIEMAP_FLAG_XATTR, "XATTR"},
|
|
{ -1, NULL}
|
|
};
|
|
|
|
#define translate_fiemap_flags(mode) \
|
|
({translate_flags(mode, "|", fiemap_flags);})
|
|
#endif
|
|
|
|
void
|
|
fiemap_f(opnum_t opno, long r)
|
|
{
|
|
#ifdef HAVE_LINUX_FIEMAP_H
|
|
int e;
|
|
pathname_t f;
|
|
int fd;
|
|
int64_t lr;
|
|
off64_t off;
|
|
struct stat64 stb;
|
|
int v;
|
|
char st[1024];
|
|
int blocks_to_map;
|
|
struct fiemap *fiemap;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: fiemap - no filename\n", procid, opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
fd = open_path(&f, O_RDWR);
|
|
e = fd < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd < 0) {
|
|
if (v)
|
|
printf("%d/%lld: fiemap - open %s failed %d\n",
|
|
procid, opno, f.path, e);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
if (fstat64(fd, &stb) < 0) {
|
|
if (v)
|
|
printf("%d/%lld: fiemap - fstat64 %s failed %d\n",
|
|
procid, opno, f.path, errno);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
return;
|
|
}
|
|
inode_info(st, sizeof(st), &stb, v);
|
|
blocks_to_map = random() & 0xffff;
|
|
fiemap = (struct fiemap *)malloc(sizeof(struct fiemap) +
|
|
(blocks_to_map * sizeof(struct fiemap_extent)));
|
|
if (!fiemap) {
|
|
if (v)
|
|
printf("%d/%lld: malloc failed \n", procid, opno);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
return;
|
|
}
|
|
lr = ((int64_t)random() << 32) + random();
|
|
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
|
|
off %= maxfsize;
|
|
fiemap->fm_flags = random() & (FIEMAP_FLAGS_COMPAT | 0x10000);
|
|
fiemap->fm_extent_count = blocks_to_map;
|
|
fiemap->fm_mapped_extents = random() & 0xffff;
|
|
fiemap->fm_start = off;
|
|
fiemap->fm_length = ((int64_t)random() << 32) + random();
|
|
|
|
e = ioctl(fd, FS_IOC_FIEMAP, (unsigned long)fiemap);
|
|
if (v)
|
|
printf("%d/%lld: ioctl(FIEMAP) %s%s %lld %lld (%s) %d\n",
|
|
procid, opno, f.path, st, (long long)fiemap->fm_start,
|
|
(long long) fiemap->fm_length,
|
|
translate_fiemap_flags(fiemap->fm_flags), e);
|
|
free(fiemap);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
fsync_f(opnum_t opno, long r)
|
|
{
|
|
int e;
|
|
pathname_t f;
|
|
int fd;
|
|
int v;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_REGFILE | FT_DIRm, r, &f, NULL, NULL, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: fsync - no filename\n", procid, opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
fd = open_file_or_dir(&f, O_WRONLY);
|
|
e = fd < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd < 0) {
|
|
if (v)
|
|
printf("%d/%lld: fsync - open %s failed %d\n",
|
|
procid, opno, f.path, e);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
e = fsync(fd) < 0 ? errno : 0;
|
|
if (v)
|
|
printf("%d/%lld: fsync %s %d\n", procid, opno, f.path, e);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
}
|
|
|
|
char *
|
|
gen_random_string(int len)
|
|
{
|
|
static const char charset[] = "0123456789"
|
|
"abcdefghijklmnopqrstuvwxyz"
|
|
"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
|
int i;
|
|
char *s;
|
|
|
|
if (len == 0)
|
|
return NULL;
|
|
|
|
s = malloc(len);
|
|
if (!s)
|
|
return NULL;
|
|
|
|
for (i = 0; i < len; i++)
|
|
s[i] = charset[random() % sizeof(charset)];
|
|
|
|
return s;
|
|
}
|
|
|
|
void
|
|
getattr_f(opnum_t opno, long r)
|
|
{
|
|
int fd;
|
|
int e;
|
|
pathname_t f;
|
|
uint fl;
|
|
int v;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_ANYm, r, &f, NULL, NULL, &v))
|
|
append_pathname(&f, ".");
|
|
fd = open_path(&f, O_RDWR);
|
|
e = fd < 0 ? errno : 0;
|
|
check_cwd();
|
|
|
|
e = ioctl(fd, FS_IOC_GETFLAGS, &fl);
|
|
if (v)
|
|
printf("%d/%lld: getattr %s %u %d\n", procid, opno, f.path, fl, e);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
}
|
|
|
|
void
|
|
getdents_f(opnum_t opno, long r)
|
|
{
|
|
DIR *dir;
|
|
pathname_t f;
|
|
int v;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_ANYDIR, r, &f, NULL, NULL, &v))
|
|
append_pathname(&f, ".");
|
|
dir = opendir_path(&f);
|
|
check_cwd();
|
|
if (dir == NULL) {
|
|
if (v)
|
|
printf("%d/%lld: getdents - can't open %s\n",
|
|
procid, opno, f.path);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
while (readdir64(dir) != NULL)
|
|
continue;
|
|
if (v)
|
|
printf("%d/%lld: getdents %s 0\n", procid, opno, f.path);
|
|
free_pathname(&f);
|
|
closedir(dir);
|
|
}
|
|
|
|
void
|
|
getfattr_f(opnum_t opno, long r)
|
|
{
|
|
fent_t *fep;
|
|
int e;
|
|
pathname_t f;
|
|
int v;
|
|
char name[XATTR_NAME_BUF_SIZE];
|
|
char *value = NULL;
|
|
int value_len;
|
|
int xattr_num;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_REGFILE | FT_ANYDIR, r, &f, NULL, &fep, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: getfattr - no filename\n", procid, opno);
|
|
goto out;
|
|
}
|
|
check_cwd();
|
|
|
|
/*
|
|
* If the file/dir has xattrs, pick one randomly, otherwise attempt
|
|
* to read a xattr that doesn't exist (fgetxattr should fail with
|
|
* errno set to ENOATTR (61) in this case).
|
|
*/
|
|
if (fep->xattr_counter > 0)
|
|
xattr_num = (random() % fep->xattr_counter) + 1;
|
|
else
|
|
xattr_num = 0;
|
|
|
|
e = generate_xattr_name(xattr_num, name, sizeof(name));
|
|
if (e < 0) {
|
|
printf("%d/%lld: getfattr - file %s failed to generate xattr name: %d\n",
|
|
procid, opno, f.path, e);
|
|
goto out;
|
|
}
|
|
|
|
value_len = getxattr(f.path, name, NULL, 0);
|
|
if (value_len < 0) {
|
|
if (v)
|
|
printf("%d/%lld: getfattr file %s name %s failed %d\n",
|
|
procid, opno, f.path, name, errno);
|
|
goto out;
|
|
}
|
|
|
|
/* A xattr without value.*/
|
|
if (value_len == 0) {
|
|
e = 0;
|
|
goto out_log;
|
|
}
|
|
|
|
value = malloc(value_len);
|
|
if (!value) {
|
|
if (v)
|
|
printf("%d/%lld: getfattr file %s failed to allocate buffer with %d bytes\n",
|
|
procid, opno, f.path, value_len);
|
|
goto out;
|
|
}
|
|
|
|
e = getxattr(f.path, name, value, value_len) < 0 ? errno : 0;
|
|
out_log:
|
|
if (v)
|
|
printf("%d/%lld: getfattr file %s name %s value length %d %d\n",
|
|
procid, opno, f.path, name, value_len, e);
|
|
out:
|
|
free(value);
|
|
free_pathname(&f);
|
|
}
|
|
|
|
void
|
|
link_f(opnum_t opno, long r)
|
|
{
|
|
int e;
|
|
pathname_t f;
|
|
fent_t *fep;
|
|
fent_t *fep_src;
|
|
flist_t *flp;
|
|
int id;
|
|
pathname_t l;
|
|
int parid;
|
|
int v;
|
|
int v1;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_NOTDIR, r, &f, &flp, &fep_src, &v1)) {
|
|
if (v1)
|
|
printf("%d/%lld: link - no file\n", procid, opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
if (!get_fname(FT_DIRm, random(), NULL, NULL, &fep, &v))
|
|
parid = -1;
|
|
else
|
|
parid = fep->id;
|
|
v |= v1;
|
|
init_pathname(&l);
|
|
e = generate_fname(fep, flp - flist, &l, &id, &v1);
|
|
v |= v1;
|
|
if (!e) {
|
|
if (v) {
|
|
(void)fent_to_name(&l, fep);
|
|
printf("%d/%lld: link - no filename from %s\n",
|
|
procid, opno, l.path);
|
|
}
|
|
free_pathname(&l);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
e = link_path(&f, &l) < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (e == 0)
|
|
add_to_flist(flp - flist, id, parid, fep_src->xattr_counter);
|
|
if (v) {
|
|
printf("%d/%lld: link %s %s %d\n", procid, opno, f.path, l.path,
|
|
e);
|
|
printf("%d/%lld: link add id=%d,parent=%d\n", procid, opno, id, parid);
|
|
}
|
|
free_pathname(&l);
|
|
free_pathname(&f);
|
|
}
|
|
|
|
void
|
|
listfattr_f(opnum_t opno, long r)
|
|
{
|
|
fent_t *fep;
|
|
int e;
|
|
pathname_t f;
|
|
int v;
|
|
char *buffer = NULL;
|
|
int buffer_len;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_REGFILE | FT_ANYDIR, r, &f, NULL, &fep, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: listfattr - no filename\n", procid, opno);
|
|
goto out;
|
|
}
|
|
check_cwd();
|
|
|
|
e = listxattr(f.path, NULL, 0);
|
|
if (e < 0) {
|
|
if (v)
|
|
printf("%d/%lld: listfattr %s failed %d\n",
|
|
procid, opno, f.path, errno);
|
|
goto out;
|
|
}
|
|
buffer_len = e;
|
|
if (buffer_len == 0) {
|
|
if (v)
|
|
printf("%d/%lld: listfattr %s - has no extended attributes\n",
|
|
procid, opno, f.path);
|
|
goto out;
|
|
}
|
|
|
|
buffer = malloc(buffer_len);
|
|
if (!buffer) {
|
|
if (v)
|
|
printf("%d/%lld: listfattr %s failed to allocate buffer with %d bytes\n",
|
|
procid, opno, f.path, buffer_len);
|
|
goto out;
|
|
}
|
|
|
|
e = listxattr(f.path, buffer, buffer_len) < 0 ? errno : 0;
|
|
if (v)
|
|
printf("%d/%lld: listfattr %s buffer length %d %d\n",
|
|
procid, opno, f.path, buffer_len, e);
|
|
out:
|
|
free(buffer);
|
|
free_pathname(&f);
|
|
}
|
|
|
|
void
|
|
mkdir_f(opnum_t opno, long r)
|
|
{
|
|
int e;
|
|
pathname_t f;
|
|
fent_t *fep;
|
|
int id;
|
|
int parid;
|
|
int v;
|
|
int v1;
|
|
|
|
if (!get_fname(FT_ANYDIR, r, NULL, NULL, &fep, &v))
|
|
parid = -1;
|
|
else
|
|
parid = fep->id;
|
|
init_pathname(&f);
|
|
e = generate_fname(fep, FT_DIR, &f, &id, &v1);
|
|
v |= v1;
|
|
if (!e) {
|
|
if (v) {
|
|
(void)fent_to_name(&f, fep);
|
|
printf("%d/%lld: mkdir - no filename from %s\n",
|
|
procid, opno, f.path);
|
|
}
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
e = mkdir_path(&f, 0777) < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (e == 0)
|
|
add_to_flist(FT_DIR, id, parid, 0);
|
|
if (v) {
|
|
printf("%d/%lld: mkdir %s %d\n", procid, opno, f.path, e);
|
|
printf("%d/%lld: mkdir add id=%d,parent=%d\n", procid, opno, id, parid);
|
|
}
|
|
free_pathname(&f);
|
|
}
|
|
|
|
void
|
|
mknod_f(opnum_t opno, long r)
|
|
{
|
|
int e;
|
|
pathname_t f;
|
|
fent_t *fep;
|
|
int id;
|
|
int parid;
|
|
int v;
|
|
int v1;
|
|
|
|
if (!get_fname(FT_ANYDIR, r, NULL, NULL, &fep, &v))
|
|
parid = -1;
|
|
else
|
|
parid = fep->id;
|
|
init_pathname(&f);
|
|
e = generate_fname(fep, FT_DEV, &f, &id, &v1);
|
|
v |= v1;
|
|
if (!e) {
|
|
if (v) {
|
|
(void)fent_to_name(&f, fep);
|
|
printf("%d/%lld: mknod - no filename from %s\n",
|
|
procid, opno, f.path);
|
|
}
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
e = mknod_path(&f, S_IFCHR|0444, 0) < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (e == 0)
|
|
add_to_flist(FT_DEV, id, parid, 0);
|
|
if (v) {
|
|
printf("%d/%lld: mknod %s %d\n", procid, opno, f.path, e);
|
|
printf("%d/%lld: mknod add id=%d,parent=%d\n", procid, opno, id, parid);
|
|
}
|
|
free_pathname(&f);
|
|
}
|
|
|
|
#ifdef HAVE_SYS_MMAN_H
|
|
struct print_flags mmap_flags[] = {
|
|
{ MAP_SHARED, "SHARED"},
|
|
{ MAP_PRIVATE, "PRIVATE"},
|
|
{ -1, NULL}
|
|
};
|
|
|
|
#define translate_mmap_flags(flags) \
|
|
({translate_flags(flags, "|", mmap_flags);})
|
|
#endif
|
|
|
|
#ifdef HAVE_SYS_MMAN_H
|
|
static void
|
|
do_mmap(opnum_t opno, long r, int prot)
|
|
{
|
|
char *addr;
|
|
int e;
|
|
pathname_t f;
|
|
int fd;
|
|
size_t len;
|
|
int64_t lr;
|
|
off64_t off;
|
|
int flags;
|
|
struct stat64 stb;
|
|
int v;
|
|
char st[1024];
|
|
sigjmp_buf sigbus_jmpbuf;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: do_mmap - no filename\n", procid, opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
fd = open_path(&f, O_RDWR);
|
|
e = fd < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd < 0) {
|
|
if (v)
|
|
printf("%d/%lld: do_mmap - open %s failed %d\n",
|
|
procid, opno, f.path, e);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
if (fstat64(fd, &stb) < 0) {
|
|
if (v)
|
|
printf("%d/%lld: do_mmap - fstat64 %s failed %d\n",
|
|
procid, opno, f.path, errno);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
return;
|
|
}
|
|
inode_info(st, sizeof(st), &stb, v);
|
|
if (stb.st_size == 0) {
|
|
if (v)
|
|
printf("%d/%lld: do_mmap - %s%s zero size\n", procid, opno,
|
|
f.path, st);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
return;
|
|
}
|
|
|
|
lr = ((int64_t)random() << 32) + random();
|
|
off = (off64_t)(lr % stb.st_size);
|
|
off = rounddown_64(off, sysconf(_SC_PAGE_SIZE));
|
|
len = (size_t)(random() % MIN(stb.st_size - off, FILELEN_MAX)) + 1;
|
|
|
|
flags = (random() % 2) ? MAP_SHARED : MAP_PRIVATE;
|
|
addr = mmap(NULL, len, prot, flags, fd, off);
|
|
e = (addr == MAP_FAILED) ? errno : 0;
|
|
if (e) {
|
|
if (v)
|
|
printf("%d/%lld: do_mmap - mmap failed %s%s [%lld,%d,%s] %d\n",
|
|
procid, opno, f.path, st, (long long)off,
|
|
(int)len, translate_mmap_flags(flags), e);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
return;
|
|
}
|
|
|
|
if (prot & PROT_WRITE) {
|
|
if ((e = sigsetjmp(sigbus_jmpbuf, 1)) == 0) {
|
|
sigbus_jmp = &sigbus_jmpbuf;
|
|
memset(addr, nameseq & 0xff, len);
|
|
}
|
|
} else {
|
|
char *buf;
|
|
if ((buf = malloc(len)) != NULL) {
|
|
memcpy(buf, addr, len);
|
|
free(buf);
|
|
}
|
|
}
|
|
munmap(addr, len);
|
|
/* set NULL to stop other functions from doing siglongjmp */
|
|
sigbus_jmp = NULL;
|
|
|
|
if (v)
|
|
printf("%d/%lld: %s %s%s [%lld,%d,%s] %s\n",
|
|
procid, opno, (prot & PROT_WRITE) ? "mwrite" : "mread",
|
|
f.path, st, (long long)off, (int)len,
|
|
translate_mmap_flags(flags),
|
|
(e == 0) ? "0" : "Bus error");
|
|
|
|
free_pathname(&f);
|
|
close(fd);
|
|
}
|
|
#endif
|
|
|
|
void
|
|
mread_f(opnum_t opno, long r)
|
|
{
|
|
#ifdef HAVE_SYS_MMAN_H
|
|
do_mmap(opno, r, PROT_READ);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
mwrite_f(opnum_t opno, long r)
|
|
{
|
|
#ifdef HAVE_SYS_MMAN_H
|
|
do_mmap(opno, r, PROT_WRITE);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
punch_f(opnum_t opno, long r)
|
|
{
|
|
#ifdef HAVE_LINUX_FALLOC_H
|
|
do_fallocate(opno, r, FALLOC_FL_PUNCH_HOLE);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
zero_f(opnum_t opno, long r)
|
|
{
|
|
#ifdef HAVE_LINUX_FALLOC_H
|
|
do_fallocate(opno, r, FALLOC_FL_ZERO_RANGE);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
collapse_f(opnum_t opno, long r)
|
|
{
|
|
#ifdef HAVE_LINUX_FALLOC_H
|
|
do_fallocate(opno, r, FALLOC_FL_COLLAPSE_RANGE);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
insert_f(opnum_t opno, long r)
|
|
{
|
|
#ifdef HAVE_LINUX_FALLOC_H
|
|
do_fallocate(opno, r, FALLOC_FL_INSERT_RANGE);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
read_f(opnum_t opno, long r)
|
|
{
|
|
char *buf;
|
|
int e;
|
|
pathname_t f;
|
|
int fd;
|
|
size_t len;
|
|
int64_t lr;
|
|
off64_t off;
|
|
struct stat64 stb;
|
|
int v;
|
|
char st[1024];
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: read - no filename\n", procid, opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
fd = open_path(&f, O_RDONLY);
|
|
e = fd < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd < 0) {
|
|
if (v)
|
|
printf("%d/%lld: read - open %s failed %d\n",
|
|
procid, opno, f.path, e);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
if (fstat64(fd, &stb) < 0) {
|
|
if (v)
|
|
printf("%d/%lld: read - fstat64 %s failed %d\n",
|
|
procid, opno, f.path, errno);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
return;
|
|
}
|
|
inode_info(st, sizeof(st), &stb, v);
|
|
if (stb.st_size == 0) {
|
|
if (v)
|
|
printf("%d/%lld: read - %s%s zero size\n", procid, opno,
|
|
f.path, st);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
return;
|
|
}
|
|
lr = ((int64_t)random() << 32) + random();
|
|
off = (off64_t)(lr % stb.st_size);
|
|
lseek64(fd, off, SEEK_SET);
|
|
len = (random() % FILELEN_MAX) + 1;
|
|
buf = malloc(len);
|
|
e = read(fd, buf, len) < 0 ? errno : 0;
|
|
free(buf);
|
|
if (v)
|
|
printf("%d/%lld: read %s%s [%lld,%d] %d\n",
|
|
procid, opno, f.path, st, (long long)off, (int)len, e);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
}
|
|
|
|
void
|
|
readlink_f(opnum_t opno, long r)
|
|
{
|
|
char buf[PATH_MAX];
|
|
int e;
|
|
pathname_t f;
|
|
int v;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_SYMm, r, &f, NULL, NULL, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: readlink - no filename\n", procid, opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
e = readlink_path(&f, buf, PATH_MAX) < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (v)
|
|
printf("%d/%lld: readlink %s %d\n", procid, opno, f.path, e);
|
|
free_pathname(&f);
|
|
}
|
|
|
|
void
|
|
readv_f(opnum_t opno, long r)
|
|
{
|
|
char *buf;
|
|
int e;
|
|
pathname_t f;
|
|
int fd;
|
|
size_t len;
|
|
int64_t lr;
|
|
off64_t off;
|
|
struct stat64 stb;
|
|
int v;
|
|
char st[1024];
|
|
struct iovec *iov = NULL;
|
|
int iovcnt;
|
|
size_t iovb;
|
|
size_t iovl;
|
|
int i;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: readv - no filename\n", procid, opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
fd = open_path(&f, O_RDONLY);
|
|
e = fd < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd < 0) {
|
|
if (v)
|
|
printf("%d/%lld: readv - open %s failed %d\n",
|
|
procid, opno, f.path, e);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
if (fstat64(fd, &stb) < 0) {
|
|
if (v)
|
|
printf("%d/%lld: readv - fstat64 %s failed %d\n",
|
|
procid, opno, f.path, errno);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
return;
|
|
}
|
|
inode_info(st, sizeof(st), &stb, v);
|
|
if (stb.st_size == 0) {
|
|
if (v)
|
|
printf("%d/%lld: readv - %s%s zero size\n", procid, opno,
|
|
f.path, st);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
return;
|
|
}
|
|
lr = ((int64_t)random() << 32) + random();
|
|
off = (off64_t)(lr % stb.st_size);
|
|
lseek64(fd, off, SEEK_SET);
|
|
len = (random() % FILELEN_MAX) + 1;
|
|
buf = malloc(len);
|
|
|
|
iovcnt = (random() % MIN(len, IOV_MAX)) + 1;
|
|
iov = calloc(iovcnt, sizeof(struct iovec));
|
|
iovl = len / iovcnt;
|
|
iovb = 0;
|
|
for (i=0; i<iovcnt; i++) {
|
|
(iov + i)->iov_base = (buf + iovb);
|
|
(iov + i)->iov_len = iovl;
|
|
iovb += iovl;
|
|
}
|
|
|
|
e = readv(fd, iov, iovcnt) < 0 ? errno : 0;
|
|
free(buf);
|
|
if (v)
|
|
printf("%d/%lld: readv %s%s [%lld,%d,%d] %d\n",
|
|
procid, opno, f.path, st, (long long)off, (int)iovl,
|
|
iovcnt, e);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
}
|
|
|
|
void
|
|
removefattr_f(opnum_t opno, long r)
|
|
{
|
|
fent_t *fep;
|
|
int e;
|
|
pathname_t f;
|
|
int v;
|
|
char name[XATTR_NAME_BUF_SIZE];
|
|
int xattr_num;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_REGFILE | FT_ANYDIR, r, &f, NULL, &fep, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: removefattr - no filename\n", procid, opno);
|
|
goto out;
|
|
}
|
|
check_cwd();
|
|
|
|
/*
|
|
* If the file/dir has xattrs, pick one randomly, otherwise attempt to
|
|
* remove a xattr that doesn't exist (fremovexattr should fail with
|
|
* errno set to ENOATTR (61) in this case).
|
|
*/
|
|
if (fep->xattr_counter > 0)
|
|
xattr_num = (random() % fep->xattr_counter) + 1;
|
|
else
|
|
xattr_num = 0;
|
|
|
|
e = generate_xattr_name(xattr_num, name, sizeof(name));
|
|
if (e < 0) {
|
|
printf("%d/%lld: removefattr - file %s failed to generate xattr name: %d\n",
|
|
procid, opno, f.path, e);
|
|
goto out;
|
|
}
|
|
|
|
e = removexattr(f.path, name) < 0 ? errno : 0;
|
|
if (v)
|
|
printf("%d/%lld: removefattr file %s name %s %d\n",
|
|
procid, opno, f.path, name, e);
|
|
out:
|
|
free_pathname(&f);
|
|
}
|
|
|
|
struct print_flags renameat2_flags [] = {
|
|
{ RENAME_NOREPLACE, "NOREPLACE"},
|
|
{ RENAME_EXCHANGE, "EXCHANGE"},
|
|
{ RENAME_WHITEOUT, "WHITEOUT"},
|
|
{ -1, NULL}
|
|
};
|
|
|
|
#define translate_renameat2_flags(mode) \
|
|
({translate_flags(mode, "|", renameat2_flags);})
|
|
|
|
static void
|
|
do_renameat2(opnum_t opno, long r, int mode)
|
|
{
|
|
fent_t *dfep;
|
|
int e;
|
|
pathname_t f;
|
|
fent_t *fep;
|
|
flist_t *flp;
|
|
int id;
|
|
pathname_t newf;
|
|
int oldid = 0;
|
|
int parid;
|
|
int oldparid = 0;
|
|
int which;
|
|
int v;
|
|
int v1;
|
|
|
|
/* get an existing path for the source of the rename */
|
|
init_pathname(&f);
|
|
which = (mode == RENAME_WHITEOUT) ? FT_DEVm : FT_ANYm;
|
|
if (!get_fname(which, r, &f, &flp, &fep, &v1)) {
|
|
if (v1)
|
|
printf("%d/%lld: rename - no source filename\n",
|
|
procid, opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Both pathnames must exist for the RENAME_EXCHANGE, and in
|
|
* order to maintain filelist/filename integrity, we should
|
|
* restrict exchange operation to files of the same type.
|
|
*/
|
|
if (mode == RENAME_EXCHANGE) {
|
|
which = 1 << (flp - flist);
|
|
init_pathname(&newf);
|
|
if (!get_fname(which, random(), &newf, NULL, &dfep, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: rename - no target filename\n",
|
|
procid, opno);
|
|
free_pathname(&newf);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
if (which == FT_DIRm && (fents_ancestor_check(fep, dfep) ||
|
|
fents_ancestor_check(dfep, fep))) {
|
|
if (v)
|
|
printf("%d/%lld: rename(REXCHANGE) %s and %s "
|
|
"have ancestor-descendant relationship\n",
|
|
procid, opno, f.path, newf.path);
|
|
free_pathname(&newf);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
v |= v1;
|
|
id = dfep->id;
|
|
parid = dfep->parent;
|
|
} else {
|
|
/*
|
|
* Get an existing directory for the destination parent
|
|
* directory name.
|
|
*/
|
|
if (!get_fname(FT_DIRm, random(), NULL, NULL, &dfep, &v))
|
|
parid = -1;
|
|
else
|
|
parid = dfep->id;
|
|
v |= v1;
|
|
|
|
/*
|
|
* Generate a new path using an existing parent directory
|
|
* in name.
|
|
*/
|
|
init_pathname(&newf);
|
|
e = generate_fname(dfep, flp - flist, &newf, &id, &v1);
|
|
v |= v1;
|
|
if (!e) {
|
|
if (v) {
|
|
(void)fent_to_name(&f, dfep);
|
|
printf("%d/%lld: rename - no filename from %s\n",
|
|
procid, opno, f.path);
|
|
}
|
|
free_pathname(&newf);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
}
|
|
e = rename_path(&f, &newf, mode) < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (e == 0) {
|
|
int xattr_counter = fep->xattr_counter;
|
|
bool swap = (mode == RENAME_EXCHANGE) ? true : false;
|
|
int ft = flp - flist;
|
|
|
|
oldid = fep->id;
|
|
oldparid = fep->parent;
|
|
|
|
/*
|
|
* Swap the parent ids for RENAME_EXCHANGE, and replace the
|
|
* old parent id for the others.
|
|
*/
|
|
if (ft == FT_DIR || ft == FT_SUBVOL)
|
|
fix_parent(oldid, id, swap);
|
|
|
|
if (mode == RENAME_WHITEOUT) {
|
|
fep->xattr_counter = 0;
|
|
add_to_flist(flp - flist, id, parid, xattr_counter);
|
|
} else if (mode == RENAME_EXCHANGE) {
|
|
fep->xattr_counter = dfep->xattr_counter;
|
|
dfep->xattr_counter = xattr_counter;
|
|
} else {
|
|
del_from_flist(flp - flist, fep - flp->fents);
|
|
add_to_flist(flp - flist, id, parid, xattr_counter);
|
|
}
|
|
}
|
|
if (v) {
|
|
printf("%d/%lld: rename(%s) %s to %s %d\n", procid,
|
|
opno, translate_renameat2_flags(mode), f.path,
|
|
newf.path, e);
|
|
if (e == 0) {
|
|
printf("%d/%lld: rename source entry: id=%d,parent=%d\n",
|
|
procid, opno, oldid, oldparid);
|
|
printf("%d/%lld: rename target entry: id=%d,parent=%d\n",
|
|
procid, opno, id, parid);
|
|
}
|
|
}
|
|
free_pathname(&newf);
|
|
free_pathname(&f);
|
|
}
|
|
|
|
void
|
|
rename_f(opnum_t opno, long r)
|
|
{
|
|
do_renameat2(opno, r, 0);
|
|
}
|
|
|
|
void
|
|
rnoreplace_f(opnum_t opno, long r)
|
|
{
|
|
do_renameat2(opno, r, RENAME_NOREPLACE);
|
|
}
|
|
|
|
void
|
|
rexchange_f(opnum_t opno, long r)
|
|
{
|
|
do_renameat2(opno, r, RENAME_EXCHANGE);
|
|
}
|
|
|
|
void
|
|
rwhiteout_f(opnum_t opno, long r)
|
|
{
|
|
do_renameat2(opno, r, RENAME_WHITEOUT);
|
|
}
|
|
|
|
#if 0
|
|
void
|
|
resvsp_f(opnum_t opno, long r)
|
|
{
|
|
int e;
|
|
pathname_t f;
|
|
int fd;
|
|
struct xfs_flock64 fl;
|
|
int64_t lr;
|
|
off64_t off;
|
|
struct stat64 stb;
|
|
int v;
|
|
char st[1024];
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: resvsp - no filename\n", procid, opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
fd = open_path(&f, O_RDWR);
|
|
e = fd < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd < 0) {
|
|
if (v)
|
|
printf("%d/%lld: resvsp - open %s failed %d\n",
|
|
procid, opno, f.path, e);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
if (fstat64(fd, &stb) < 0) {
|
|
if (v)
|
|
printf("%d/%lld: resvsp - fstat64 %s failed %d\n",
|
|
procid, opno, f.path, errno);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
return;
|
|
}
|
|
inode_info(st, sizeof(st), &stb, v);
|
|
lr = ((int64_t)random() << 32) + random();
|
|
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
|
|
off %= maxfsize;
|
|
fl.l_whence = SEEK_SET;
|
|
fl.l_start = off;
|
|
fl.l_len = (off64_t)(random() % (1024 * 1024));
|
|
e = xfsctl(f.path, fd, XFS_IOC_RESVSP64, &fl) < 0 ? errno : 0;
|
|
if (v)
|
|
printf("%d/%lld: xfsctl(XFS_IOC_RESVSP64) %s%s %lld %lld %d\n",
|
|
procid, opno, f.path, st,
|
|
(long long)off, (long long)fl.l_len, e);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
}
|
|
#endif
|
|
|
|
void
|
|
rmdir_f(opnum_t opno, long r)
|
|
{
|
|
int e;
|
|
pathname_t f;
|
|
fent_t *fep;
|
|
int oldid;
|
|
int oldparid;
|
|
int v;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_DIRm, r, &f, NULL, &fep, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: rmdir - no directory\n", procid, opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
e = rmdir_path(&f) < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (e == 0) {
|
|
oldid = fep->id;
|
|
oldparid = fep->parent;
|
|
del_from_flist(FT_DIR, fep - flist[FT_DIR].fents);
|
|
}
|
|
if (v) {
|
|
printf("%d/%lld: rmdir %s %d\n", procid, opno, f.path, e);
|
|
if (e == 0)
|
|
printf("%d/%lld: rmdir del entry: id=%d,parent=%d\n",
|
|
procid, opno, oldid, oldparid);
|
|
}
|
|
free_pathname(&f);
|
|
}
|
|
|
|
void
|
|
setattr_f(opnum_t opno, long r)
|
|
{
|
|
int fd;
|
|
int e;
|
|
pathname_t f;
|
|
uint fl;
|
|
int v;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_ANYm, r, &f, NULL, NULL, &v))
|
|
append_pathname(&f, ".");
|
|
fd = open_path(&f, O_RDWR);
|
|
e = fd < 0 ? errno : 0;
|
|
check_cwd();
|
|
|
|
fl = attr_mask & (uint)random();
|
|
e = ioctl(fd, FS_IOC_SETFLAGS, &fl);
|
|
if (v)
|
|
printf("%d/%lld: setattr %s %x %d\n", procid, opno, f.path, fl, e);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
}
|
|
|
|
void
|
|
setfattr_f(opnum_t opno, long r)
|
|
{
|
|
int e;
|
|
pathname_t f;
|
|
fent_t *fep;
|
|
int v;
|
|
int value_len;
|
|
char name[XATTR_NAME_BUF_SIZE];
|
|
char *value = NULL;
|
|
int flag = 0;
|
|
int xattr_num;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_REGFILE | FT_ANYDIR, r, &f, NULL, &fep, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: setfattr - no filename\n", procid, opno);
|
|
goto out;
|
|
}
|
|
check_cwd();
|
|
|
|
if ((fep->xattr_counter > 0) && (random() % 2)) {
|
|
/*
|
|
* Use an existing xattr name for replacing its value or
|
|
* create again a xattr that was previously deleted.
|
|
*/
|
|
xattr_num = (random() % fep->xattr_counter) + 1;
|
|
if (random() % 2)
|
|
flag = XATTR_REPLACE;
|
|
} else {
|
|
/* Use a new xattr name. */
|
|
xattr_num = fep->xattr_counter + 1;
|
|
/*
|
|
* Don't always use the create flag because even if our xattr
|
|
* counter is 0, we may still have xattrs associated to this
|
|
* file (this happens when xattrs are added to a file through
|
|
* one of its other hard links), so we can end up updating an
|
|
* existing xattr too.
|
|
*/
|
|
if (random() % 2)
|
|
flag = XATTR_CREATE;
|
|
}
|
|
|
|
/*
|
|
* The maximum supported value size depends on the filesystem
|
|
* implementation, but 100 bytes is a safe value for most filesystems
|
|
* at least.
|
|
*/
|
|
value_len = random() % 101;
|
|
value = gen_random_string(value_len);
|
|
if (!value && value_len > 0) {
|
|
if (v)
|
|
printf("%d/%lld: setfattr - file %s failed to allocate value with %d bytes\n",
|
|
procid, opno, f.path, value_len);
|
|
goto out;
|
|
}
|
|
e = generate_xattr_name(xattr_num, name, sizeof(name));
|
|
if (e < 0) {
|
|
printf("%d/%lld: setfattr - file %s failed to generate xattr name: %d\n",
|
|
procid, opno, f.path, e);
|
|
goto out;
|
|
}
|
|
|
|
e = setxattr(f.path, name, value, value_len, flag) < 0 ? errno : 0;
|
|
if (e == 0)
|
|
fep->xattr_counter++;
|
|
if (v)
|
|
printf("%d/%lld: setfattr file %s name %s flag %s value length %d: %d\n",
|
|
procid, opno, f.path, name, xattr_flag_to_string(flag),
|
|
value_len, e);
|
|
out:
|
|
free(value);
|
|
free_pathname(&f);
|
|
}
|
|
|
|
void
|
|
snapshot_f(opnum_t opno, long r)
|
|
{
|
|
#ifdef HAVE_BTRFSUTIL_H
|
|
enum btrfs_util_error e;
|
|
pathname_t f;
|
|
pathname_t newf;
|
|
fent_t *fep;
|
|
int id;
|
|
int parid;
|
|
int v;
|
|
int v1;
|
|
int err;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_SUBVOLm, r, &f, NULL, &fep, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: snapshot - no subvolume\n", procid,
|
|
opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
init_pathname(&newf);
|
|
parid = fep->id;
|
|
err = generate_fname(fep, FT_SUBVOL, &newf, &id, &v1);
|
|
v |= v1;
|
|
if (!err) {
|
|
if (v) {
|
|
(void)fent_to_name(&f, fep);
|
|
printf("%d/%lld: snapshot - no filename from %s\n",
|
|
procid, opno, f.path);
|
|
}
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
e = btrfs_util_create_snapshot(f.path, newf.path, 0, NULL, NULL);
|
|
if (e == BTRFS_UTIL_OK)
|
|
add_to_flist(FT_SUBVOL, id, parid, 0);
|
|
if (v) {
|
|
printf("%d/%lld: snapshot %s->%s %d(%s)\n", procid, opno,
|
|
f.path, newf.path, e, btrfs_util_strerror(e));
|
|
printf("%d/%lld: snapshot add id=%d,parent=%d\n", procid, opno,
|
|
id, parid);
|
|
}
|
|
free_pathname(&newf);
|
|
free_pathname(&f);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
stat_f(opnum_t opno, long r)
|
|
{
|
|
int e;
|
|
pathname_t f;
|
|
struct stat64 stb;
|
|
int v;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_ANYm, r, &f, NULL, NULL, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: stat - no entries\n", procid, opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
e = lstat64_path(&f, &stb) < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (v)
|
|
printf("%d/%lld: stat %s %d\n", procid, opno, f.path, e);
|
|
free_pathname(&f);
|
|
}
|
|
|
|
void
|
|
subvol_create_f(opnum_t opno, long r)
|
|
{
|
|
#ifdef HAVE_BTRFSUTIL_H
|
|
enum btrfs_util_error e;
|
|
pathname_t f;
|
|
fent_t *fep;
|
|
int id;
|
|
int parid;
|
|
int v;
|
|
int v1;
|
|
int err;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_ANYDIR, r, NULL, NULL, &fep, &v))
|
|
parid = -1;
|
|
else
|
|
parid = fep->id;
|
|
err = generate_fname(fep, FT_SUBVOL, &f, &id, &v1);
|
|
v |= v1;
|
|
if (!err) {
|
|
if (v) {
|
|
(void)fent_to_name(&f, fep);
|
|
printf("%d/%lld: subvol_create - no filename from %s\n",
|
|
procid, opno, f.path);
|
|
}
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
e = btrfs_util_create_subvolume(f.path, 0, NULL, NULL);
|
|
if (e == BTRFS_UTIL_OK)
|
|
add_to_flist(FT_SUBVOL, id, parid, 0);
|
|
if (v) {
|
|
printf("%d/%lld: subvol_create %s %d(%s)\n", procid, opno,
|
|
f.path, e, btrfs_util_strerror(e));
|
|
printf("%d/%lld: subvol_create add id=%d,parent=%d\n", procid,
|
|
opno, id, parid);
|
|
}
|
|
free_pathname(&f);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
subvol_delete_f(opnum_t opno, long r)
|
|
{
|
|
#ifdef HAVE_BTRFSUTIL_H
|
|
enum btrfs_util_error e;
|
|
pathname_t f;
|
|
fent_t *fep;
|
|
int v;
|
|
int oldid;
|
|
int oldparid;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_SUBVOLm, r, &f, NULL, &fep, &v)) {
|
|
if (v)
|
|
printf("%d:%lld: subvol_delete - no subvolume\n", procid,
|
|
opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
e = btrfs_util_delete_subvolume(f.path, 0);
|
|
check_cwd();
|
|
if (e == BTRFS_UTIL_OK) {
|
|
oldid = fep->id;
|
|
oldparid = fep->parent;
|
|
delete_subvol_children(oldid);
|
|
del_from_flist(FT_SUBVOL, fep - flist[FT_SUBVOL].fents);
|
|
}
|
|
if (v) {
|
|
printf("%d/%lld: subvol_delete %s %d(%s)\n", procid, opno, f.path,
|
|
e, btrfs_util_strerror(e));
|
|
if (e == BTRFS_UTIL_OK)
|
|
printf("%d/%lld: subvol_delete del entry: id=%d,parent=%d\n",
|
|
procid, opno, oldid, oldparid);
|
|
}
|
|
free_pathname(&f);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
symlink_f(opnum_t opno, long r)
|
|
{
|
|
int e;
|
|
pathname_t f;
|
|
fent_t *fep;
|
|
int i;
|
|
int id;
|
|
int len;
|
|
int parid;
|
|
int v;
|
|
int v1;
|
|
char *val;
|
|
|
|
if (!get_fname(FT_ANYDIR, r, NULL, NULL, &fep, &v))
|
|
parid = -1;
|
|
else
|
|
parid = fep->id;
|
|
init_pathname(&f);
|
|
e = generate_fname(fep, FT_SYM, &f, &id, &v1);
|
|
v |= v1;
|
|
if (!e) {
|
|
if (v) {
|
|
(void)fent_to_name(&f, fep);
|
|
printf("%d/%lld: symlink - no filename from %s\n",
|
|
procid, opno, f.path);
|
|
}
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
len = (int)(random() % PATH_MAX);
|
|
val = malloc(len + 1);
|
|
if (len)
|
|
memset(val, 'x', len);
|
|
val[len] = '\0';
|
|
for (i = 10; i < len - 1; i += 10)
|
|
val[i] = '/';
|
|
e = symlink_path(val, &f) < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (e == 0)
|
|
add_to_flist(FT_SYM, id, parid, 0);
|
|
free(val);
|
|
if (v) {
|
|
printf("%d/%lld: symlink %s %d\n", procid, opno, f.path, e);
|
|
printf("%d/%lld: symlink add id=%d,parent=%d\n", procid, opno, id, parid);
|
|
}
|
|
free_pathname(&f);
|
|
}
|
|
|
|
/* ARGSUSED */
|
|
void
|
|
sync_f(opnum_t opno, long r)
|
|
{
|
|
sync();
|
|
if (verbose)
|
|
printf("%d/%lld: sync\n", procid, opno);
|
|
}
|
|
|
|
void
|
|
truncate_f(opnum_t opno, long r)
|
|
{
|
|
int e;
|
|
pathname_t f;
|
|
int64_t lr;
|
|
off64_t off;
|
|
struct stat64 stb;
|
|
int v;
|
|
char st[1024];
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: truncate - no filename\n", procid, opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
e = stat64_path(&f, &stb) < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (e > 0) {
|
|
if (v)
|
|
printf("%d/%lld: truncate - stat64 %s failed %d\n",
|
|
procid, opno, f.path, e);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
inode_info(st, sizeof(st), &stb, v);
|
|
lr = ((int64_t)random() << 32) + random();
|
|
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
|
|
off %= maxfsize;
|
|
e = truncate64_path(&f, off) < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (v)
|
|
printf("%d/%lld: truncate %s%s %lld %d\n", procid, opno, f.path,
|
|
st, (long long)off, e);
|
|
free_pathname(&f);
|
|
}
|
|
|
|
void
|
|
unlink_f(opnum_t opno, long r)
|
|
{
|
|
int e;
|
|
pathname_t f;
|
|
fent_t *fep;
|
|
flist_t *flp;
|
|
int oldid;
|
|
int oldparid;
|
|
int v;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_NOTDIR, r, &f, &flp, &fep, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: unlink - no file\n", procid, opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
e = unlink_path(&f) < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (e == 0) {
|
|
oldid = fep->id;
|
|
oldparid = fep->parent;
|
|
del_from_flist(flp - flist, fep - flp->fents);
|
|
}
|
|
if (v) {
|
|
printf("%d/%lld: unlink %s %d\n", procid, opno, f.path, e);
|
|
if (e == 0)
|
|
printf("%d/%lld: unlink del entry: id=%d,parent=%d\n",
|
|
procid, opno, oldid, oldparid);
|
|
}
|
|
free_pathname(&f);
|
|
}
|
|
|
|
#if 0
|
|
void
|
|
unresvsp_f(opnum_t opno, long r)
|
|
{
|
|
int e;
|
|
pathname_t f;
|
|
int fd;
|
|
struct xfs_flock64 fl;
|
|
int64_t lr;
|
|
off64_t off;
|
|
struct stat64 stb;
|
|
int v;
|
|
char st[1024];
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: unresvsp - no filename\n", procid, opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
fd = open_path(&f, O_RDWR);
|
|
e = fd < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd < 0) {
|
|
if (v)
|
|
printf("%d/%lld: unresvsp - open %s failed %d\n",
|
|
procid, opno, f.path, e);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
if (fstat64(fd, &stb) < 0) {
|
|
if (v)
|
|
printf("%d/%lld: unresvsp - fstat64 %s failed %d\n",
|
|
procid, opno, f.path, errno);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
return;
|
|
}
|
|
inode_info(st, sizeof(st), &stb, v);
|
|
lr = ((int64_t)random() << 32) + random();
|
|
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
|
|
off %= maxfsize;
|
|
fl.l_whence = SEEK_SET;
|
|
fl.l_start = off;
|
|
fl.l_len = (off64_t)(random() % (1 << 20));
|
|
e = xfsctl(f.path, fd, XFS_IOC_UNRESVSP64, &fl) < 0 ? errno : 0;
|
|
if (v)
|
|
printf("%d/%lld: xfsctl(XFS_IOC_UNRESVSP64) %s%s %lld %lld %d\n",
|
|
procid, opno, f.path, st,
|
|
(long long)off, (long long)fl.l_len, e);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
}
|
|
#endif
|
|
|
|
void
|
|
uring_read_f(opnum_t opno, long r)
|
|
{
|
|
#ifdef URING
|
|
do_uring_rw(opno, r, O_RDONLY);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
uring_write_f(opnum_t opno, long r)
|
|
{
|
|
#ifdef URING
|
|
do_uring_rw(opno, r, O_WRONLY);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
write_f(opnum_t opno, long r)
|
|
{
|
|
char *buf;
|
|
int e;
|
|
pathname_t f;
|
|
int fd;
|
|
size_t len;
|
|
int64_t lr;
|
|
off64_t off;
|
|
struct stat64 stb;
|
|
int v;
|
|
char st[1024];
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_REGm, r, &f, NULL, NULL, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: write - no filename\n", procid, opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
fd = open_path(&f, O_WRONLY);
|
|
e = fd < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd < 0) {
|
|
if (v)
|
|
printf("%d/%lld: write - open %s failed %d\n",
|
|
procid, opno, f.path, e);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
if (fstat64(fd, &stb) < 0) {
|
|
if (v)
|
|
printf("%d/%lld: write - fstat64 %s failed %d\n",
|
|
procid, opno, f.path, errno);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
return;
|
|
}
|
|
inode_info(st, sizeof(st), &stb, v);
|
|
lr = ((int64_t)random() << 32) + random();
|
|
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
|
|
off %= maxfsize;
|
|
lseek64(fd, off, SEEK_SET);
|
|
len = (random() % FILELEN_MAX) + 1;
|
|
buf = malloc(len);
|
|
memset(buf, nameseq & 0xff, len);
|
|
e = write(fd, buf, len) < 0 ? errno : 0;
|
|
free(buf);
|
|
if (v)
|
|
printf("%d/%lld: write %s%s [%lld,%d] %d\n",
|
|
procid, opno, f.path, st, (long long)off, (int)len, e);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
}
|
|
|
|
void
|
|
writev_f(opnum_t opno, long r)
|
|
{
|
|
char *buf;
|
|
int e;
|
|
pathname_t f;
|
|
int fd;
|
|
size_t len;
|
|
int64_t lr;
|
|
off64_t off;
|
|
struct stat64 stb;
|
|
int v;
|
|
char st[1024];
|
|
struct iovec *iov = NULL;
|
|
int iovcnt;
|
|
size_t iovb;
|
|
size_t iovl;
|
|
int i;
|
|
|
|
init_pathname(&f);
|
|
if (!get_fname(FT_REGm, r, &f, NULL, NULL, &v)) {
|
|
if (v)
|
|
printf("%d/%lld: writev - no filename\n", procid, opno);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
fd = open_path(&f, O_WRONLY);
|
|
e = fd < 0 ? errno : 0;
|
|
check_cwd();
|
|
if (fd < 0) {
|
|
if (v)
|
|
printf("%d/%lld: writev - open %s failed %d\n",
|
|
procid, opno, f.path, e);
|
|
free_pathname(&f);
|
|
return;
|
|
}
|
|
if (fstat64(fd, &stb) < 0) {
|
|
if (v)
|
|
printf("%d/%lld: writev - fstat64 %s failed %d\n",
|
|
procid, opno, f.path, errno);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
return;
|
|
}
|
|
inode_info(st, sizeof(st), &stb, v);
|
|
lr = ((int64_t)random() << 32) + random();
|
|
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
|
|
off %= maxfsize;
|
|
lseek64(fd, off, SEEK_SET);
|
|
len = (random() % FILELEN_MAX) + 1;
|
|
buf = malloc(len);
|
|
memset(buf, nameseq & 0xff, len);
|
|
|
|
iovcnt = (random() % MIN(len, IOV_MAX)) + 1;
|
|
iov = calloc(iovcnt, sizeof(struct iovec));
|
|
iovl = len / iovcnt;
|
|
iovb = 0;
|
|
for (i=0; i<iovcnt; i++) {
|
|
(iov + i)->iov_base = (buf + iovb);
|
|
(iov + i)->iov_len = iovl;
|
|
iovb += iovl;
|
|
}
|
|
|
|
e = writev(fd, iov, iovcnt) < 0 ? errno : 0;
|
|
free(buf);
|
|
free(iov);
|
|
if (v)
|
|
printf("%d/%lld: writev %s%s [%lld,%d,%d] %d\n",
|
|
procid, opno, f.path, st, (long long)off, (int)iovl,
|
|
iovcnt, e);
|
|
free_pathname(&f);
|
|
close(fd);
|
|
}
|
|
|
|
char *
|
|
xattr_flag_to_string(int flag)
|
|
{
|
|
if (flag == XATTR_CREATE)
|
|
return "create";
|
|
if (flag == XATTR_REPLACE)
|
|
return "replace";
|
|
return "none";
|
|
}
|