fsstress: consistently index the ops array by OP_ type
[xfstests-dev.git] / ltp / fsstress.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (c) 2000-2002 Silicon Graphics, Inc.
4  * All Rights Reserved.
5  */
6
7 #include <linux/fs.h>
8 #include <setjmp.h>
9 #include <sys/uio.h>
10 #include <stddef.h>
11 #include <stdbool.h>
12 #include <string.h>
13 #include "global.h"
14
15 #ifdef HAVE_BTRFSUTIL_H
16 #include <btrfsutil.h>
17 #endif
18 #ifdef HAVE_LINUX_FIEMAP_H
19 #include <linux/fiemap.h>
20 #endif
21 #ifdef HAVE_SYS_PRCTL_H
22 #include <sys/prctl.h>
23 #endif
24 #ifdef AIO
25 #include <libaio.h>
26 #define AIO_ENTRIES     1
27 io_context_t    io_ctx;
28 #endif
29 #ifdef URING
30 #include <liburing.h>
31 #define URING_ENTRIES   1
32 struct io_uring ring;
33 bool have_io_uring;                     /* to indicate runtime availability */
34 #endif
35 #include <sys/syscall.h>
36 #include <sys/xattr.h>
37
38 #ifndef FS_IOC_GETFLAGS
39 #define FS_IOC_GETFLAGS                 _IOR('f', 1, long)
40 #endif
41 #ifndef FS_IOC_SETFLAGS
42 #define FS_IOC_SETFLAGS                 _IOW('f', 2, long)
43 #endif
44
45 #include <math.h>
46 #define XFS_ERRTAG_MAX          17
47 #define XFS_IDMODULO_MAX        31      /* user/group IDs (1 << x)  */
48 #define XFS_PROJIDMODULO_MAX    16      /* project IDs (1 << x)     */
49 #ifndef IOV_MAX
50 #define IOV_MAX 1024
51 #endif
52
53 #ifndef HAVE_RENAMEAT2
54 #if !defined(SYS_renameat2) && defined(__x86_64__)
55 #define SYS_renameat2 316
56 #endif
57
58 #if !defined(SYS_renameat2) && defined(__i386__)
59 #define SYS_renameat2 353
60 #endif
61
62 static int renameat2(int dfd1, const char *path1,
63                      int dfd2, const char *path2,
64                      unsigned int flags)
65 {
66 #ifdef SYS_renameat2
67         return syscall(SYS_renameat2, dfd1, path1, dfd2, path2, flags);
68 #else
69         errno = ENOSYS;
70         return -1;
71 #endif
72 }
73 #endif
74
75 #ifndef RENAME_NOREPLACE
76 #define RENAME_NOREPLACE        (1 << 0)        /* Don't overwrite target */
77 #endif
78 #ifndef RENAME_EXCHANGE
79 #define RENAME_EXCHANGE         (1 << 1)        /* Exchange source and dest */
80 #endif
81 #ifndef RENAME_WHITEOUT
82 #define RENAME_WHITEOUT         (1 << 2)        /* Whiteout source */
83 #endif
84
85 #define FILELEN_MAX             (32*4096)
86
87 typedef enum {
88         OP_AFSYNC,
89         OP_ALLOCSP,
90         OP_AREAD,
91         OP_ATTR_REMOVE,
92         OP_ATTR_SET,
93         OP_AWRITE,
94         OP_BULKSTAT,
95         OP_BULKSTAT1,
96         OP_CHOWN,
97         OP_CLONERANGE,
98         OP_COPYRANGE,
99         OP_CREAT,
100         OP_DEDUPERANGE,
101         OP_DREAD,
102         OP_DWRITE,
103         OP_FALLOCATE,
104         OP_FDATASYNC,
105         OP_FIEMAP,
106         OP_FREESP,
107         OP_FSYNC,
108         OP_GETATTR,
109         OP_GETDENTS,
110         OP_GETFATTR,
111         OP_LINK,
112         OP_LISTFATTR,
113         OP_MKDIR,
114         OP_MKNOD,
115         OP_MREAD,
116         OP_MWRITE,
117         OP_PUNCH,
118         OP_ZERO,
119         OP_COLLAPSE,
120         OP_INSERT,
121         OP_READ,
122         OP_READLINK,
123         OP_READV,
124         OP_REMOVEFATTR,
125         OP_RENAME,
126         OP_RNOREPLACE,
127         OP_REXCHANGE,
128         OP_RWHITEOUT,
129         OP_RESVSP,
130         OP_RMDIR,
131         OP_SETATTR,
132         OP_SETFATTR,
133         OP_SETXATTR,
134         OP_SNAPSHOT,
135         OP_SPLICE,
136         OP_STAT,
137         OP_SUBVOL_CREATE,
138         OP_SUBVOL_DELETE,
139         OP_SYMLINK,
140         OP_SYNC,
141         OP_TRUNCATE,
142         OP_UNLINK,
143         OP_UNRESVSP,
144         OP_URING_READ,
145         OP_URING_WRITE,
146         OP_WRITE,
147         OP_WRITEV,
148         OP_LAST
149 } opty_t;
150
151 typedef long long opnum_t;
152
153 typedef void (*opfnc_t)(opnum_t, long);
154
155 typedef struct opdesc {
156         char    *name;
157         opfnc_t func;
158         int     freq;
159         int     iswrite;
160 } opdesc_t;
161
162 typedef struct fent {
163         int     id;
164         int     ft;
165         int     parent;
166         int     xattr_counter;
167 } fent_t;
168
169 typedef struct flist {
170         int     nfiles;
171         int     nslots;
172         int     tag;
173         fent_t  *fents;
174 } flist_t;
175
176 typedef struct pathname {
177         int     len;
178         char    *path;
179 } pathname_t;
180
181 struct print_flags {
182         unsigned long mask;
183         const char *name;
184 };
185
186 struct print_string {
187         char *buffer;
188         int len;
189         int max;
190 };
191
192 #define FT_DIR          0
193 #define FT_DIRm         (1 << FT_DIR)
194 #define FT_REG          1
195 #define FT_REGm         (1 << FT_REG)
196 #define FT_SYM          2
197 #define FT_SYMm         (1 << FT_SYM)
198 #define FT_DEV          3
199 #define FT_DEVm         (1 << FT_DEV)
200 #define FT_RTF          4
201 #define FT_RTFm         (1 << FT_RTF)
202 #define FT_SUBVOL       5
203 #define FT_SUBVOLm      (1 << FT_SUBVOL)
204 #define FT_nft          6
205 #define FT_ANYm         ((1 << FT_nft) - 1)
206 #define FT_REGFILE      (FT_REGm | FT_RTFm)
207 #define FT_NOTDIR       (FT_ANYm & (~FT_DIRm & ~FT_SUBVOLm))
208 #define FT_ANYDIR       (FT_DIRm | FT_SUBVOLm)
209
210 #define FLIST_SLOT_INCR 16
211 #define NDCACHE 64
212
213 #define MAXFSIZE        ((1ULL << 63) - 1ULL)
214 #define MAXFSIZE32      ((1ULL << 40) - 1ULL)
215
216 #define XATTR_NAME_BUF_SIZE 18
217
218 void    afsync_f(opnum_t, long);
219 void    allocsp_f(opnum_t, long);
220 void    aread_f(opnum_t, long);
221 void    attr_remove_f(opnum_t, long);
222 void    attr_set_f(opnum_t, long);
223 void    awrite_f(opnum_t, long);
224 void    bulkstat_f(opnum_t, long);
225 void    bulkstat1_f(opnum_t, long);
226 void    chown_f(opnum_t, long);
227 void    clonerange_f(opnum_t, long);
228 void    copyrange_f(opnum_t, long);
229 void    creat_f(opnum_t, long);
230 void    deduperange_f(opnum_t, long);
231 void    dread_f(opnum_t, long);
232 void    dwrite_f(opnum_t, long);
233 void    fallocate_f(opnum_t, long);
234 void    fdatasync_f(opnum_t, long);
235 void    fiemap_f(opnum_t, long);
236 void    freesp_f(opnum_t, long);
237 void    fsync_f(opnum_t, long);
238 char    *gen_random_string(int);
239 void    getattr_f(opnum_t, long);
240 void    getdents_f(opnum_t, long);
241 void    getfattr_f(opnum_t, long);
242 void    link_f(opnum_t, long);
243 void    listfattr_f(opnum_t, long);
244 void    mkdir_f(opnum_t, long);
245 void    mknod_f(opnum_t, long);
246 void    mread_f(opnum_t, long);
247 void    mwrite_f(opnum_t, long);
248 void    punch_f(opnum_t, long);
249 void    zero_f(opnum_t, long);
250 void    collapse_f(opnum_t, long);
251 void    insert_f(opnum_t, long);
252 void    read_f(opnum_t, long);
253 void    readlink_f(opnum_t, long);
254 void    readv_f(opnum_t, long);
255 void    removefattr_f(opnum_t, long);
256 void    rename_f(opnum_t, long);
257 void    rnoreplace_f(opnum_t, long);
258 void    rexchange_f(opnum_t, long);
259 void    rwhiteout_f(opnum_t, long);
260 void    resvsp_f(opnum_t, long);
261 void    rmdir_f(opnum_t, long);
262 void    setattr_f(opnum_t, long);
263 void    setfattr_f(opnum_t, long);
264 void    setxattr_f(opnum_t, long);
265 void    snapshot_f(opnum_t, long);
266 void    splice_f(opnum_t, long);
267 void    stat_f(opnum_t, long);
268 void    subvol_create_f(opnum_t, long);
269 void    subvol_delete_f(opnum_t, long);
270 void    symlink_f(opnum_t, long);
271 void    sync_f(opnum_t, long);
272 void    truncate_f(opnum_t, long);
273 void    unlink_f(opnum_t, long);
274 void    unresvsp_f(opnum_t, long);
275 void    uring_read_f(opnum_t, long);
276 void    uring_write_f(opnum_t, long);
277 void    write_f(opnum_t, long);
278 void    writev_f(opnum_t, long);
279 char    *xattr_flag_to_string(int);
280
281 struct opdesc   ops[OP_LAST]    = {
282      /* [OP_ENUM]          = {"name",          function,        freq, iswrite }, */
283         [OP_AFSYNC]        = {"afsync",        afsync_f,        0, 1 },
284         [OP_ALLOCSP]       = {"allocsp",       allocsp_f,       1, 1 },
285         [OP_AREAD]         = {"aread",         aread_f,         1, 0 },
286         [OP_ATTR_REMOVE]   = {"attr_remove",   attr_remove_f,   0, 1 },
287         [OP_ATTR_SET]      = {"attr_set",      attr_set_f,      0, 1 },
288         [OP_AWRITE]        = {"awrite",        awrite_f,        1, 1 },
289         [OP_BULKSTAT]      = {"bulkstat",      bulkstat_f,      1, 0 },
290         [OP_BULKSTAT1]     = {"bulkstat1",     bulkstat1_f,     1, 0 },
291         [OP_CHOWN]         = {"chown",         chown_f,         3, 1 },
292         [OP_CLONERANGE]    = {"clonerange",    clonerange_f,    4, 1 },
293         [OP_COPYRANGE]     = {"copyrange",     copyrange_f,     4, 1 },
294         [OP_CREAT]         = {"creat",         creat_f,         4, 1 },
295         [OP_DEDUPERANGE]   = {"deduperange",   deduperange_f,   4, 1 },
296         [OP_DREAD]         = {"dread",         dread_f,         4, 0 },
297         [OP_DWRITE]        = {"dwrite",        dwrite_f,        4, 1 },
298         [OP_FALLOCATE]     = {"fallocate",     fallocate_f,     1, 1 },
299         [OP_FDATASYNC]     = {"fdatasync",     fdatasync_f,     1, 1 },
300         [OP_FIEMAP]        = {"fiemap",        fiemap_f,        1, 1 },
301         [OP_FREESP]        = {"freesp",        freesp_f,        1, 1 },
302         [OP_FSYNC]         = {"fsync",         fsync_f,         1, 1 },
303         [OP_GETATTR]       = {"getattr",       getattr_f,       1, 0 },
304         [OP_GETDENTS]      = {"getdents",      getdents_f,      1, 0 },
305         /* get extended attribute */
306         [OP_GETFATTR]      = {"getfattr",      getfattr_f,      1, 0 },
307         [OP_LINK]          = {"link",          link_f,          1, 1 },
308         /* list extent attributes */
309         [OP_LISTFATTR]     = {"listfattr",     listfattr_f,     1, 0 },
310         [OP_MKDIR]         = {"mkdir",         mkdir_f,         2, 1 },
311         [OP_MKNOD]         = {"mknod",         mknod_f,         2, 1 },
312         [OP_MREAD]         = {"mread",         mread_f,         2, 0 },
313         [OP_MWRITE]        = {"mwrite",        mwrite_f,        2, 1 },
314         [OP_PUNCH]         = {"punch",         punch_f,         1, 1 },
315         [OP_ZERO]          = {"zero",          zero_f,          1, 1 },
316         [OP_COLLAPSE]      = {"collapse",      collapse_f,      1, 1 },
317         [OP_INSERT]        = {"insert",        insert_f,        1, 1 },
318         [OP_READ]          = {"read",          read_f,          1, 0 },
319         [OP_READLINK]      = {"readlink",      readlink_f,      1, 0 },
320         [OP_READV]         = {"readv",         readv_f,         1, 0 },
321         /* remove (delete) extended attribute */
322         [OP_REMOVEFATTR]   = {"removefattr",   removefattr_f,   1, 1 },
323         [OP_RENAME]        = {"rename",        rename_f,        2, 1 },
324         [OP_RNOREPLACE]    = {"rnoreplace",    rnoreplace_f,    2, 1 },
325         [OP_REXCHANGE]     = {"rexchange",     rexchange_f,     2, 1 },
326         [OP_RWHITEOUT]     = {"rwhiteout",     rwhiteout_f,     2, 1 },
327         [OP_RESVSP]        = {"resvsp",        resvsp_f,        1, 1 },
328         [OP_RMDIR]         = {"rmdir",         rmdir_f,         1, 1 },
329         /* set attribute flag (FS_IOC_SETFLAGS ioctl) */
330         [OP_SETATTR]       = {"setattr",       setattr_f,       0, 1 },
331         /* set extended attribute */
332         [OP_SETFATTR]      = {"setfattr",      setfattr_f,      2, 1 },
333         /* set project id (XFS_IOC_FSSETXATTR ioctl) */
334         [OP_SETXATTR]      = {"setxattr",      setxattr_f,      1, 1 },
335         [OP_SNAPSHOT]      = {"snapshot",      snapshot_f,      1, 1 },
336         [OP_SPLICE]        = {"splice",        splice_f,        1, 1 },
337         [OP_STAT]          = {"stat",          stat_f,          1, 0 },
338         [OP_SUBVOL_CREATE] = {"subvol_create", subvol_create_f, 1, 1 },
339         [OP_SUBVOL_DELETE] = {"subvol_delete", subvol_delete_f, 1, 1 },
340         [OP_SYMLINK]       = {"symlink",       symlink_f,       2, 1 },
341         [OP_SYNC]          = {"sync",          sync_f,          1, 1 },
342         [OP_TRUNCATE]      = {"truncate",      truncate_f,      2, 1 },
343         [OP_UNLINK]        = {"unlink",        unlink_f,        1, 1 },
344         [OP_UNRESVSP]      = {"unresvsp",      unresvsp_f,      1, 1 },
345         [OP_URING_READ]    = {"uring_read",    uring_read_f,    1, 0 },
346         [OP_URING_WRITE]   = {"uring_write",   uring_write_f,   1, 1 },
347         [OP_WRITE]         = {"write",         write_f,         4, 1 },
348         [OP_WRITEV]        = {"writev",        writev_f,        4, 1 },
349 }, *ops_end;
350
351 flist_t flist[FT_nft] = {
352         { 0, 0, 'd', NULL },
353         { 0, 0, 'f', NULL },
354         { 0, 0, 'l', NULL },
355         { 0, 0, 'c', NULL },
356         { 0, 0, 'r', NULL },
357         { 0, 0, 's', NULL },
358 };
359
360 int             dcache[NDCACHE];
361 int             errrange;
362 int             errtag;
363 opty_t          *freq_table;
364 int             freq_table_size;
365 struct xfs_fsop_geom    geom;
366 char            *homedir;
367 int             *ilist;
368 int             ilistlen;
369 off64_t         maxfsize;
370 char            *myprog;
371 int             namerand;
372 int             nameseq;
373 int             nops;
374 int             nproc = 1;
375 opnum_t         operations = 1;
376 unsigned int    idmodulo = XFS_IDMODULO_MAX;
377 unsigned int    attr_mask = ~0;
378 int             procid;
379 int             rtpct;
380 unsigned long   seed = 0;
381 ino_t           top_ino;
382 int             cleanup = 0;
383 int             verbose = 0;
384 int             verifiable_log = 0;
385 sig_atomic_t    should_stop = 0;
386 sigjmp_buf      *sigbus_jmp = NULL;
387 char            *execute_cmd = NULL;
388 int             execute_freq = 1;
389 struct print_string     flag_str = {0};
390
391 void    add_to_flist(int, int, int, int);
392 void    append_pathname(pathname_t *, char *);
393 int     attr_list_path(pathname_t *, char *, const int);
394 int     attr_remove_path(pathname_t *, const char *);
395 int     attr_set_path(pathname_t *, const char *, const char *, const int);
396 void    check_cwd(void);
397 void    cleanup_flist(void);
398 int     creat_path(pathname_t *, mode_t);
399 void    dcache_enter(int, int);
400 void    dcache_init(void);
401 fent_t  *dcache_lookup(int);
402 void    dcache_purge(int, int);
403 void    del_from_flist(int, int);
404 int     dirid_to_name(char *, int);
405 void    doproc(void);
406 int     fent_to_name(pathname_t *, fent_t *);
407 bool    fents_ancestor_check(fent_t *, fent_t *);
408 void    fix_parent(int, int, bool);
409 void    free_pathname(pathname_t *);
410 int     generate_fname(fent_t *, int, pathname_t *, int *, int *);
411 int     generate_xattr_name(int, char *, int);
412 int     get_fname(int, long, pathname_t *, flist_t **, fent_t **, int *);
413 void    init_pathname(pathname_t *);
414 int     lchown_path(pathname_t *, uid_t, gid_t);
415 int     link_path(pathname_t *, pathname_t *);
416 int     lstat64_path(pathname_t *, struct stat64 *);
417 void    make_freq_table(void);
418 int     mkdir_path(pathname_t *, mode_t);
419 int     mknod_path(pathname_t *, mode_t, dev_t);
420 void    namerandpad(int, char *, int);
421 int     open_file_or_dir(pathname_t *, int);
422 int     open_path(pathname_t *, int);
423 DIR     *opendir_path(pathname_t *);
424 void    process_freq(char *);
425 int     readlink_path(pathname_t *, char *, size_t);
426 int     rename_path(pathname_t *, pathname_t *, int);
427 int     rmdir_path(pathname_t *);
428 void    separate_pathname(pathname_t *, char *, pathname_t *);
429 void    show_ops(int, char *);
430 int     stat64_path(pathname_t *, struct stat64 *);
431 int     symlink_path(const char *, pathname_t *);
432 int     truncate64_path(pathname_t *, off64_t);
433 int     unlink_path(pathname_t *);
434 void    usage(void);
435 void    write_freq(void);
436 void    zero_freq(void);
437 void    non_btrfs_freq(const char *);
438
439 void sg_handler(int signum)
440 {
441         switch (signum) {
442         case SIGTERM:
443                 should_stop = 1;
444                 break;
445         case SIGBUS:
446                 /*
447                  * Only handle SIGBUS when mmap write to a hole and no
448                  * block can be allocated due to ENOSPC, abort otherwise.
449                  */
450                 if (sigbus_jmp) {
451                         siglongjmp(*sigbus_jmp, -1);
452                 } else {
453                         printf("Unknown SIGBUS is caught, Abort!\n");
454                         abort();
455                 }
456                 /* should not reach here */
457                 break;
458         default:
459                 break;
460         }
461 }
462
463 int main(int argc, char **argv)
464 {
465         char            buf[10];
466         int             c;
467         char            *dirname = NULL;
468         char            *logname = NULL;
469         char            rpath[PATH_MAX];
470         int             fd;
471         int             i;
472         int             j;
473         char            *p;
474         int             stat;
475         struct timeval  t;
476         ptrdiff_t       srval;
477         int             nousage = 0;
478         xfs_error_injection_t           err_inj;
479         struct sigaction action;
480         int             loops = 1;
481         const char      *allopts = "cd:e:f:i:l:m:M:n:o:p:rs:S:vVwx:X:zH";
482
483         errrange = errtag = 0;
484         umask(0);
485         nops = sizeof(ops) / sizeof(ops[0]);
486         ops_end = &ops[nops];
487         myprog = argv[0];
488         while ((c = getopt(argc, argv, allopts)) != -1) {
489                 switch (c) {
490                 case 'c':
491                         cleanup = 1;
492                         break;
493                 case 'd':
494                         dirname = optarg;
495                         break;
496                 case 'e':
497                         sscanf(optarg, "%d", &errtag);
498                         if (errtag < 0) {
499                                 errtag = -errtag;
500                                 errrange = 1;
501                         } else if (errtag == 0)
502                                 errtag = -1;
503                         if (errtag >= XFS_ERRTAG_MAX) {
504                                 fprintf(stderr,
505                                         "error tag %d too large (max %d)\n",
506                                         errtag, XFS_ERRTAG_MAX - 1);
507                                 exit(1);
508                         }
509                         break;
510                 case 'f':
511                         process_freq(optarg);
512                         break;
513                 case 'i':
514                         ilist = realloc(ilist, ++ilistlen * sizeof(*ilist));
515                         ilist[ilistlen - 1] = strtol(optarg, &p, 16);
516                         break;
517                 case 'm':
518                         idmodulo = strtoul(optarg, NULL, 0);
519                         if (idmodulo > XFS_IDMODULO_MAX) {
520                                 fprintf(stderr,
521                                         "chown modulo %d too big (max %d)\n",
522                                         idmodulo, XFS_IDMODULO_MAX);
523                                 exit(1);
524                         }
525                         break;
526                 case 'l':
527                         loops = atoi(optarg);
528                         break;
529                 case 'n':
530                         errno = 0;
531                         operations = strtoll(optarg, NULL, 0);
532                         if (errno) {
533                                 perror(optarg);
534                                 exit(1);
535                         }
536                         break;
537                 case 'o':
538                         logname = optarg;
539                         break;
540
541                 case 'p':
542                         nproc = atoi(optarg);
543                         break;
544                 case 'r':
545                         namerand = 1;
546                         break;
547                 case 's':
548                         seed = strtoul(optarg, NULL, 0);
549                         break;
550                 case 'v':
551                         verbose = 1;
552                         break;
553                 case 'w':
554                         write_freq();
555                         break;
556                 case 'x':
557                         execute_cmd = optarg;
558                         break;
559                 case 'z':
560                         zero_freq();
561                         break;
562                 case 'M':
563                         attr_mask = strtoul(optarg, NULL, 0);
564                         break;
565                 case 'S':
566                         i = 0;
567                         if (optarg[0] == 'c')
568                                 i = 1;
569                         show_ops(i, NULL);
570                         printf("\n");
571                         nousage=1;
572                         break;
573                 case 'V':
574                         verifiable_log = 1;
575                         break;
576
577                 case 'X':
578                         execute_freq = strtoul(optarg, NULL, 0);
579                         break;
580                 case '?':
581                         fprintf(stderr, "%s - invalid parameters\n",
582                                 myprog);
583                         /* fall through */
584                 case 'H':
585                         usage();
586                         exit(1);
587                 }
588         }
589
590         if (!dirname) {
591             /* no directory specified */
592             if (!nousage) usage();
593             exit(1);
594         }
595
596         non_btrfs_freq(dirname);
597         (void)mkdir(dirname, 0777);
598         if (logname && logname[0] != '/') {
599                 if (!getcwd(rpath, sizeof(rpath))){
600                         perror("getcwd failed");
601                         exit(1);
602                 }
603         } else {
604                 rpath[0] = '\0';
605         }
606         if (chdir(dirname) < 0) {
607                 perror(dirname);
608                 exit(1);
609         }
610         if (logname) {
611                 char path[PATH_MAX + NAME_MAX + 1];
612                 snprintf(path, sizeof(path), "%s/%s", rpath, logname);
613                 if (freopen(path, "a", stdout) == NULL) {
614                         perror("freopen logfile failed");
615                         exit(1);
616                 }
617         }
618         sprintf(buf, "fss%x", (unsigned int)getpid());
619         fd = creat(buf, 0666);
620         if (lseek64(fd, (off64_t)(MAXFSIZE32 + 1ULL), SEEK_SET) < 0)
621                 maxfsize = (off64_t)MAXFSIZE32;
622         else
623                 maxfsize = (off64_t)MAXFSIZE;
624         make_freq_table();
625         dcache_init();
626         setlinebuf(stdout);
627         if (!seed) {
628                 gettimeofday(&t, (void *)NULL);
629                 seed = (int)t.tv_sec ^ (int)t.tv_usec;
630                 printf("seed = %ld\n", seed);
631         }
632         i = xfsctl(buf, fd, XFS_IOC_FSGEOMETRY, &geom);
633         if (i >= 0 && geom.rtblocks)
634                 rtpct = MIN(MAX(geom.rtblocks * 100 /
635                                 (geom.rtblocks + geom.datablocks), 1), 99);
636         else
637                 rtpct = 0;
638         if (errtag != 0) {
639                 if (errrange == 0) {
640                         if (errtag <= 0) {
641                                 srandom(seed);
642                                 j = random() % 100;
643
644                                 for (i = 0; i < j; i++)
645                                         (void) random();
646
647                                 errtag = (random() % (XFS_ERRTAG_MAX-1)) + 1;
648                         }
649                 } else {
650                         srandom(seed);
651                         j = random() % 100;
652
653                         for (i = 0; i < j; i++)
654                                 (void) random();
655
656                         errtag += (random() % (XFS_ERRTAG_MAX - errtag));
657                 }
658                 printf("Injecting failure on tag #%d\n", errtag);
659                 err_inj.errtag = errtag;
660                 err_inj.fd = fd;
661                 srval = xfsctl(buf, fd, XFS_IOC_ERROR_INJECTION, &err_inj);
662                 if (srval < -1) {
663                         perror("fsstress - XFS_SYSSGI error injection call");
664                         close(fd);
665                         unlink(buf);
666                         exit(1);
667                 }
668         } else
669                 close(fd);
670
671         setpgid(0, 0);
672         action.sa_handler = sg_handler;
673         sigemptyset(&action.sa_mask);
674         action.sa_flags = 0;
675         if (sigaction(SIGTERM, &action, 0)) {
676                 perror("sigaction failed");
677                 exit(1);
678         }
679
680         for (i = 0; i < nproc; i++) {
681                 if (fork() == 0) {
682                         sigemptyset(&action.sa_mask);
683                         action.sa_handler = SIG_DFL;
684                         if (sigaction(SIGTERM, &action, 0))
685                                 return 1;
686                         action.sa_handler = sg_handler;
687                         if (sigaction(SIGBUS, &action, 0))
688                                 return 1;
689 #ifdef HAVE_SYS_PRCTL_H
690                         prctl(PR_SET_PDEATHSIG, SIGKILL);
691                         if (getppid() == 1) /* parent died already? */
692                                 return 0;
693 #endif
694                         if (logname) {
695                                 char path[PATH_MAX + NAME_MAX + 2 + 11];
696                                 snprintf(path, sizeof(path), "%s/%s.%d",
697                                          rpath, logname, i);
698                                 if (freopen(path, "a", stdout) == NULL) {
699                                         perror("freopen logfile failed");
700                                         exit(1);
701                                 }
702                         }
703                         procid = i;
704 #ifdef AIO
705                         if (io_setup(AIO_ENTRIES, &io_ctx) != 0) {
706                                 fprintf(stderr, "io_setup failed\n");
707                                 exit(1);
708                         }
709 #endif
710 #ifdef URING
711                         have_io_uring = true;
712                         /* If ENOSYS, just ignore uring, other errors are fatal. */
713                         if (io_uring_queue_init(URING_ENTRIES, &ring, 0)) {
714                                 if (errno == ENOSYS) {
715                                         have_io_uring = false;
716                                 } else {
717                                         fprintf(stderr, "io_uring_queue_init failed\n");
718                                         exit(1);
719                                 }
720                         }
721 #endif
722                         for (i = 0; !loops || (i < loops); i++)
723                                 doproc();
724 #ifdef AIO
725                         if(io_destroy(io_ctx) != 0) {
726                                 fprintf(stderr, "io_destroy failed");
727                                 return 1;
728                         }
729 #endif
730 #ifdef URING
731                         if (have_io_uring)
732                                 io_uring_queue_exit(&ring);
733 #endif
734                         cleanup_flist();
735                         free(freq_table);
736                         return 0;
737                 }
738         }
739         while (wait(&stat) > 0 && !should_stop) {
740                 continue;
741         }
742         action.sa_flags = SA_RESTART;
743         sigaction(SIGTERM, &action, 0);
744         kill(-getpid(), SIGTERM);
745         while (wait(&stat) > 0)
746                 continue;
747
748         if (errtag != 0) {
749                 err_inj.errtag = 0;
750                 err_inj.fd = fd;
751                 srval = xfsctl(buf, fd, XFS_IOC_ERROR_CLEARALL, &err_inj);
752                 if (srval != 0) {
753                         fprintf(stderr, "Bad ej clear on %s fd=%d (%d).\n",
754                                 buf, fd, errno);
755                         perror("xfsctl(XFS_IOC_ERROR_CLEARALL)");
756                         close(fd);
757                         exit(1);
758                 }
759                 close(fd);
760         }
761
762         free(freq_table);
763         unlink(buf);
764         return 0;
765 }
766
767 int
768 add_string(struct print_string *str, const char *add)
769 {
770         int len = strlen(add);
771
772         if (len <= 0)
773                 return 0;
774
775         if (len > (str->max - 1) - str->len) {
776                 str->len = str->max - 1;
777                 return 0;
778         }
779
780         memcpy(str->buffer + str->len, add, len);
781         str->len += len;
782         str->buffer[str->len] = '\0';
783
784         return len;
785 }
786
787 char *
788 translate_flags(int flags, const char *delim,
789                 const struct print_flags *flag_array)
790 {
791         int i, mask, first = 1;
792         const char *add;
793
794         if (!flag_str.buffer) {
795                 flag_str.buffer = malloc(4096);
796                 flag_str.max = 4096;
797                 flag_str.len = 0;
798         }
799         if (!flag_str.buffer)
800                 return NULL;
801         flag_str.len = 0;
802         flag_str.buffer[0] = '\0';
803
804         for (i = 0;  flag_array[i].name && flags; i++) {
805                 mask = flag_array[i].mask;
806                 if ((flags & mask) != mask)
807                         continue;
808
809                 add = flag_array[i].name;
810                 flags &= ~mask;
811                 if (!first && delim)
812                         add_string(&flag_str, delim);
813                 else
814                         first = 0;
815                 add_string(&flag_str, add);
816         }
817
818         /* Check whether there are any leftover flags. */
819         if (flags) {
820                 int ret;
821                 char number[11];
822
823                 if (!first && delim)
824                         add_string(&flag_str, delim);
825
826                 ret = snprintf(number, 11, "0x%x", flags) > 0;
827                 if (ret > 0 && ret <= 11)
828                         add_string(&flag_str, number);
829         }
830
831         return flag_str.buffer;
832 }
833
834 void
835 add_to_flist(int ft, int id, int parent, int xattr_counter)
836 {
837         fent_t  *fep;
838         flist_t *ftp;
839
840         ftp = &flist[ft];
841         if (ftp->nfiles == ftp->nslots) {
842                 ftp->nslots += FLIST_SLOT_INCR;
843                 ftp->fents = realloc(ftp->fents, ftp->nslots * sizeof(fent_t));
844         }
845         fep = &ftp->fents[ftp->nfiles++];
846         fep->id = id;
847         fep->ft = ft;
848         fep->parent = parent;
849         fep->xattr_counter = xattr_counter;
850 }
851
852 void
853 append_pathname(pathname_t *name, char *str)
854 {
855         int     len;
856
857         len = strlen(str);
858 #ifdef DEBUG
859         /* attempting to append to a dir a zero length path */
860         if (len && *str == '/' && name->len == 0) {
861                 fprintf(stderr, "fsstress: append_pathname failure\n");
862                 assert(chdir(homedir) == 0);
863                 abort();
864                 /* NOTREACHED */
865         }
866 #endif
867         name->path = realloc(name->path, name->len + 1 + len);
868         strcpy(&name->path[name->len], str);
869         name->len += len;
870 }
871
872 int
873 attr_list_count(char *buffer, int buffersize)
874 {
875         char *p = buffer;
876         char *end = buffer + buffersize;
877         int count = 0;
878
879         while (p < end && *p != 0) {
880                 count++;
881                 p += strlen(p) + 1;
882         }
883
884         return count;
885 }
886
887 int
888 attr_list_path(pathname_t *name,
889                char *buffer,
890                const int buffersize)
891 {
892         char            buf[NAME_MAX + 1];
893         pathname_t      newname;
894         int             rval;
895
896         rval = llistxattr(name->path, buffer, buffersize);
897         if (rval >= 0 || errno != ENAMETOOLONG)
898                 return rval;
899         separate_pathname(name, buf, &newname);
900         if (chdir(buf) == 0) {
901                 rval = attr_list_path(&newname, buffer, buffersize);
902                 assert(chdir("..") == 0);
903         }
904         free_pathname(&newname);
905         return rval;
906 }
907
908 int
909 attr_remove_path(pathname_t *name, const char *attrname)
910 {
911         char            buf[NAME_MAX + 1];
912         pathname_t      newname;
913         int             rval;
914
915         rval = lremovexattr(name->path, attrname);
916         if (rval >= 0 || errno != ENAMETOOLONG)
917                 return rval;
918         separate_pathname(name, buf, &newname);
919         if (chdir(buf) == 0) {
920                 rval = attr_remove_path(&newname, attrname);
921                 assert(chdir("..") == 0);
922         }
923         free_pathname(&newname);
924         return rval;
925 }
926
927 int
928 attr_set_path(pathname_t *name, const char *attrname, const char *attrvalue,
929               const int valuelength)
930 {
931         char            buf[NAME_MAX + 1];
932         pathname_t      newname;
933         int             rval;
934
935         rval = lsetxattr(name->path, attrname, attrvalue, valuelength, 0);
936         if (rval >= 0 || errno != ENAMETOOLONG)
937                 return rval;
938         separate_pathname(name, buf, &newname);
939         if (chdir(buf) == 0) {
940                 rval = attr_set_path(&newname, attrname, attrvalue,
941                                      valuelength);
942                 assert(chdir("..") == 0);
943         }
944         free_pathname(&newname);
945         return rval;
946 }
947
948 void
949 check_cwd(void)
950 {
951 #ifdef DEBUG
952         struct stat64   statbuf;
953         int ret;
954
955         ret = stat64(".", &statbuf);
956         if (ret != 0) {
957                 fprintf(stderr, "fsstress: check_cwd stat64() returned %d with errno: %d (%s)\n",
958                         ret, errno, strerror(errno));
959                 goto out;
960         }
961
962         if (statbuf.st_ino == top_ino)
963                 return;
964
965         fprintf(stderr, "fsstress: check_cwd statbuf.st_ino (%llu) != top_ino (%llu)\n",
966                 (unsigned long long) statbuf.st_ino,
967                 (unsigned long long) top_ino);
968 out:
969         assert(chdir(homedir) == 0);
970         fprintf(stderr, "fsstress: check_cwd failure\n");
971         abort();
972         /* NOTREACHED */
973 #endif
974 }
975
976 /*
977  * go thru flist and release all entries
978  *
979  * NOTE: this function shouldn't be called until the end of a process
980  */
981 void
982 cleanup_flist(void)
983 {
984         flist_t *flp;
985         int     i;
986
987         for (i = 0, flp = flist; i < FT_nft; i++, flp++) {
988                 flp->nslots = 0;
989                 flp->nfiles = 0;
990                 free(flp->fents);
991                 flp->fents = NULL;
992         }
993 }
994
995 int
996 creat_path(pathname_t *name, mode_t mode)
997 {
998         char            buf[NAME_MAX + 1];
999         pathname_t      newname;
1000         int             rval;
1001
1002         rval = creat(name->path, mode);
1003         if (rval >= 0 || errno != ENAMETOOLONG)
1004                 return rval;
1005         separate_pathname(name, buf, &newname);
1006         if (chdir(buf) == 0) {
1007                 rval = creat_path(&newname, mode);
1008                 assert(chdir("..") == 0);
1009         }
1010         free_pathname(&newname);
1011         return rval;
1012 }
1013
1014 void
1015 dcache_enter(int dirid, int slot)
1016 {
1017         dcache[dirid % NDCACHE] = slot;
1018 }
1019
1020 void
1021 dcache_init(void)
1022 {
1023         int     i;
1024
1025         for (i = 0; i < NDCACHE; i++)
1026                 dcache[i] = -1;
1027 }
1028
1029 fent_t *
1030 dcache_lookup(int dirid)
1031 {
1032         fent_t  *fep;
1033         int     i;
1034
1035         i = dcache[dirid % NDCACHE];
1036         if (i >= 0 && i < flist[FT_DIR].nfiles &&
1037             (fep = &flist[FT_DIR].fents[i])->id == dirid)
1038                 return fep;
1039         if (i >= 0 && i < flist[FT_SUBVOL].nfiles &&
1040             (fep = &flist[FT_SUBVOL].fents[i])->id == dirid)
1041                 return fep;
1042         return NULL;
1043 }
1044
1045 void
1046 dcache_purge(int dirid, int ft)
1047 {
1048         int     *dcp;
1049         dcp = &dcache[dirid % NDCACHE];
1050         if (*dcp >= 0 && *dcp < flist[ft].nfiles &&
1051             flist[ft].fents[*dcp].id == dirid)
1052                 *dcp = -1;
1053 }
1054
1055 /*
1056  * Delete the item from the list by
1057  * moving last entry over the deleted one;
1058  * unless deleted entry is the last one.
1059  * Input: which file list array and which slot in array
1060  */
1061 void
1062 del_from_flist(int ft, int slot)
1063 {
1064         flist_t *ftp;
1065
1066         ftp = &flist[ft];
1067         if (ft == FT_DIR || ft == FT_SUBVOL)
1068                 dcache_purge(ftp->fents[slot].id, ft);
1069         if (slot != ftp->nfiles - 1) {
1070                 if (ft == FT_DIR || ft == FT_SUBVOL)
1071                         dcache_purge(ftp->fents[ftp->nfiles - 1].id, ft);
1072                 ftp->fents[slot] = ftp->fents[--ftp->nfiles];
1073         } else
1074                 ftp->nfiles--;
1075 }
1076
1077 void
1078 delete_subvol_children(int parid)
1079 {
1080         flist_t *flp;
1081         int     i;
1082 again:
1083         for (i = 0, flp = flist; i < FT_nft; i++, flp++) {
1084                 int c;
1085                 for (c = 0; c < flp->nfiles; c++) {
1086                         if (flp->fents[c].parent == parid) {
1087                                 int id = flp->fents[c].id;
1088                                 del_from_flist(i, c);
1089                                 if (i == FT_DIR || i == FT_SUBVOL)
1090                                         delete_subvol_children(id);
1091                                 goto again;
1092                         }
1093                 }
1094         }
1095 }
1096
1097 fent_t *
1098 dirid_to_fent(int dirid)
1099 {
1100         fent_t  *efep;
1101         fent_t  *fep;
1102         flist_t *flp;
1103         int     ft = FT_DIR;
1104
1105         if ((fep = dcache_lookup(dirid)))
1106                 return fep;
1107 again:
1108         flp = &flist[ft];
1109         for (fep = flp->fents, efep = &fep[flp->nfiles]; fep < efep; fep++) {
1110                 if (fep->id == dirid) {
1111                         dcache_enter(dirid, fep - flp->fents);
1112                         return fep;
1113                 }
1114         }
1115         if (ft == FT_DIR) {
1116                 ft = FT_SUBVOL;
1117                 goto again;
1118         }
1119         return NULL;
1120 }
1121
1122 void
1123 doproc(void)
1124 {
1125         struct stat64   statbuf;
1126         char            buf[10];
1127         char            cmd[64];
1128         opnum_t         opno;
1129         int             rval;
1130         opdesc_t        *p;
1131         long long       dividend;
1132
1133         dividend = (operations + execute_freq) / (execute_freq + 1);
1134         sprintf(buf, "p%x", procid);
1135         (void)mkdir(buf, 0777);
1136         if (chdir(buf) < 0 || stat64(".", &statbuf) < 0) {
1137                 perror(buf);
1138                 _exit(1);
1139         }
1140         top_ino = statbuf.st_ino;
1141         homedir = getcwd(NULL, 0);
1142         if (!homedir) {
1143                 perror("getcwd failed");
1144                 _exit(1);
1145         }
1146         seed += procid;
1147         srandom(seed);
1148         if (namerand)
1149                 namerand = random();
1150         for (opno = 0; opno < operations; opno++) {
1151                 if (execute_cmd && opno && opno % dividend == 0) {
1152                         if (verbose)
1153                                 printf("%lld: execute command %s\n", opno,
1154                                         execute_cmd);
1155                         rval = system(execute_cmd);
1156                         if (rval)
1157                                 fprintf(stderr, "execute command failed with "
1158                                         "%d\n", rval);
1159                 }
1160                 p = &ops[freq_table[random() % freq_table_size]];
1161                 p->func(opno, random());
1162                 /*
1163                  * test for forced shutdown by stat'ing the test
1164                  * directory.  If this stat returns EIO, assume
1165                  * the forced shutdown happened.
1166                  */
1167                 if (errtag != 0 && opno % 100 == 0)  {
1168                         rval = stat64(".", &statbuf);
1169                         if (rval == EIO)  {
1170                                 fprintf(stderr, "Detected EIO\n");
1171                                 goto errout;
1172                         }
1173                 }
1174         }
1175 errout:
1176         assert(chdir("..") == 0);
1177         free(homedir);
1178         if (cleanup) {
1179                 int ret;
1180
1181                 sprintf(cmd, "rm -rf %s", buf);
1182                 ret = system(cmd);
1183                 if (ret != 0)
1184                         perror("cleaning up");
1185                 cleanup_flist();
1186         }
1187 }
1188
1189 /*
1190  * build up a pathname going thru the file entry and all
1191  * its parent entries
1192  * Return 0 on error, 1 on success;
1193  */
1194 int
1195 fent_to_name(pathname_t *name, fent_t *fep)
1196 {
1197         flist_t *flp = &flist[fep->ft];
1198         char    buf[NAME_MAX + 1];
1199         int     i;
1200         fent_t  *pfep;
1201         int     e;
1202
1203         if (fep == NULL)
1204                 return 0;
1205
1206         /* build up parent directory name */
1207         if (fep->parent != -1) {
1208                 pfep = dirid_to_fent(fep->parent);
1209 #ifdef DEBUG
1210                 if (pfep == NULL) {
1211                         fprintf(stderr, "%d: fent-id = %d: can't find parent id: %d\n",
1212                                 procid, fep->id, fep->parent);
1213                 } 
1214 #endif
1215                 if (pfep == NULL)
1216                         return 0;
1217                 e = fent_to_name(name, pfep);
1218                 if (!e)
1219                         return 0;
1220                 append_pathname(name, "/");
1221         }
1222
1223         i = sprintf(buf, "%c%x", flp->tag, fep->id);
1224         namerandpad(fep->id, buf, i);
1225         append_pathname(name, buf);
1226         return 1;
1227 }
1228
1229 bool
1230 fents_ancestor_check(fent_t *fep, fent_t *dfep)
1231 {
1232         fent_t  *tmpfep;
1233
1234         for (tmpfep = fep; tmpfep->parent != -1;
1235              tmpfep = dirid_to_fent(tmpfep->parent)) {
1236                 if (tmpfep->parent == dfep->id)
1237                         return true;
1238         }
1239
1240         return false;
1241 }
1242
1243 void
1244 fix_parent(int oldid, int newid, bool swap)
1245 {
1246         fent_t  *fep;
1247         flist_t *flp;
1248         int     i;
1249         int     j;
1250
1251         for (i = 0, flp = flist; i < FT_nft; i++, flp++) {
1252                 for (j = 0, fep = flp->fents; j < flp->nfiles; j++, fep++) {
1253                         if (fep->parent == oldid)
1254                                 fep->parent = newid;
1255                         else if (swap && fep->parent == newid)
1256                                 fep->parent = oldid;
1257                 }
1258         }
1259 }
1260
1261 void
1262 free_pathname(pathname_t *name)
1263 {
1264         if (name->path) {
1265                 free(name->path);
1266                 name->path = NULL;
1267                 name->len = 0;
1268         }
1269 }
1270
1271 /*
1272  * Generate a filename of type ft.
1273  * If we have a fep which should be a directory then use it
1274  * as the parent path for this new filename i.e. prepend with it.
1275  */
1276 int
1277 generate_fname(fent_t *fep, int ft, pathname_t *name, int *idp, int *v)
1278 {
1279         char    buf[NAME_MAX + 1];
1280         flist_t *flp;
1281         int     id;
1282         int     j;
1283         int     len;
1284         int     e;
1285
1286         /* create name */
1287         flp = &flist[ft];
1288         len = sprintf(buf, "%c%x", flp->tag, id = nameseq++);
1289         namerandpad(id, buf, len);
1290
1291         /* prepend fep parent dir-name to it */
1292         if (fep) {
1293                 e = fent_to_name(name, fep);
1294                 if (!e)
1295                         return 0;
1296                 append_pathname(name, "/");
1297         }
1298         append_pathname(name, buf);
1299
1300         *idp = id;
1301         *v = verbose;
1302         for (j = 0; !*v && j < ilistlen; j++) {
1303                 if (ilist[j] == id) {
1304                         *v = 1;
1305                         break;
1306                 }
1307         }
1308         return 1;
1309 }
1310
1311 int generate_xattr_name(int xattr_num, char *buffer, int buflen)
1312 {
1313         int ret;
1314
1315         ret = snprintf(buffer, buflen, "user.x%d", xattr_num);
1316         if (ret < 0)
1317                 return ret;
1318         if (ret < buflen)
1319                 return 0;
1320         return -EOVERFLOW;
1321 }
1322
1323 /*
1324  * Get file 
1325  * Input: "which" to choose the file-types eg. non-directory
1326  * Input: "r" to choose which file
1327  * Output: file-list, file-entry, name for the chosen file.
1328  * Output: verbose if chosen file is on the ilist.
1329  */
1330 int
1331 get_fname(int which, long r, pathname_t *name, flist_t **flpp, fent_t **fepp,
1332           int *v)
1333 {
1334         int     totalsum = 0; /* total number of matching files */
1335         int     partialsum = 0; /* partial sum of matching files */
1336         fent_t  *fep;
1337         flist_t *flp;
1338         int     i;
1339         int     j;
1340         int     x;
1341         int     e = 1; /* success */
1342
1343         /*
1344          * go thru flist and add up number of files for each
1345          * category that matches with <which>.
1346          */
1347         for (i = 0, flp = flist; i < FT_nft; i++, flp++) {
1348                 if (which & (1 << i))
1349                         totalsum += flp->nfiles;
1350         }
1351         if (totalsum == 0) {
1352                 if (flpp)
1353                         *flpp = NULL;
1354                 if (fepp)
1355                         *fepp = NULL;
1356                 *v = verbose;
1357                 return 0;
1358         }
1359
1360         /*
1361          * Now we have possible matches between 0..totalsum-1.
1362          * And we use r to help us choose which one we want,
1363          * which when bounded by totalsum becomes x.
1364          */ 
1365         x = (int)(r % totalsum);
1366         for (i = 0, flp = flist; i < FT_nft; i++, flp++) {
1367                 if (which & (1 << i)) {
1368                         if (x < partialsum + flp->nfiles) {
1369
1370                                 /* found the matching file entry */
1371                                 fep = &flp->fents[x - partialsum];
1372
1373                                 /* fill-in what we were asked for */
1374                                 if (name) {
1375                                         e = fent_to_name(name, fep);
1376 #ifdef DEBUG
1377                                         if (!e) {
1378                                                 fprintf(stderr, "%d: failed to get path for entry:"
1379                                                                 " id=%d,parent=%d\n",   
1380                                                         procid, fep->id, fep->parent);
1381                                         }
1382 #endif
1383                                 }
1384                                 if (flpp)
1385                                         *flpp = flp;
1386                                 if (fepp)
1387                                         *fepp = fep;
1388
1389                                 /* turn on verbose if its an ilisted file */
1390                                 *v = verbose;
1391                                 for (j = 0; !*v && j < ilistlen; j++) {
1392                                         if (ilist[j] == fep->id) {
1393                                                 *v = 1;
1394                                                 break;
1395                                         }
1396                                 }
1397                                 return e;
1398                         }
1399                         partialsum += flp->nfiles;
1400                 }
1401         }
1402 #ifdef DEBUG
1403         fprintf(stderr, "fsstress: get_fname failure\n");
1404         abort();
1405 #endif
1406         return 0;
1407 }
1408
1409 void
1410 init_pathname(pathname_t *name)
1411 {
1412         name->len = 0;
1413         name->path = NULL;
1414 }
1415
1416 int
1417 lchown_path(pathname_t *name, uid_t owner, gid_t group)
1418 {
1419         char            buf[NAME_MAX + 1];
1420         pathname_t      newname;
1421         int             rval;
1422
1423         rval = lchown(name->path, owner, group);
1424         if (rval >= 0 || errno != ENAMETOOLONG)
1425                 return rval;
1426         separate_pathname(name, buf, &newname);
1427         if (chdir(buf) == 0) {
1428                 rval = lchown_path(&newname, owner, group);
1429                 assert(chdir("..") == 0);
1430         }
1431         free_pathname(&newname);
1432         return rval;
1433 }
1434
1435 int
1436 link_path(pathname_t *name1, pathname_t *name2)
1437 {
1438         char            buf1[NAME_MAX + 1];
1439         char            buf2[NAME_MAX + 1];
1440         int             down1;
1441         pathname_t      newname1;
1442         pathname_t      newname2;
1443         int             rval;
1444
1445         rval = link(name1->path, name2->path);
1446         if (rval >= 0 || errno != ENAMETOOLONG)
1447                 return rval;
1448         separate_pathname(name1, buf1, &newname1);
1449         separate_pathname(name2, buf2, &newname2);
1450         if (strcmp(buf1, buf2) == 0) {
1451                 if (chdir(buf1) == 0) {
1452                         rval = link_path(&newname1, &newname2);
1453                         assert(chdir("..") == 0);
1454                 }
1455         } else {
1456                 if (strcmp(buf1, "..") == 0)
1457                         down1 = 0;
1458                 else if (strcmp(buf2, "..") == 0)
1459                         down1 = 1;
1460                 else if (strlen(buf1) == 0)
1461                         down1 = 0;
1462                 else if (strlen(buf2) == 0)
1463                         down1 = 1;
1464                 else
1465                         down1 = MAX(newname1.len, 3 + name2->len) <=
1466                                 MAX(3 + name1->len, newname2.len);
1467                 if (down1) {
1468                         free_pathname(&newname2);
1469                         append_pathname(&newname2, "../");
1470                         append_pathname(&newname2, name2->path);
1471                         if (chdir(buf1) == 0) {
1472                                 rval = link_path(&newname1, &newname2);
1473                                 assert(chdir("..") == 0);
1474                         }
1475                 } else {
1476                         free_pathname(&newname1);
1477                         append_pathname(&newname1, "../");
1478                         append_pathname(&newname1, name1->path);
1479                         if (chdir(buf2) == 0) {
1480                                 rval = link_path(&newname1, &newname2);
1481                                 assert(chdir("..") == 0);
1482                         }
1483                 }
1484         }
1485         free_pathname(&newname1);
1486         free_pathname(&newname2);
1487         return rval;
1488 }
1489
1490 int
1491 lstat64_path(pathname_t *name, struct stat64 *sbuf)
1492 {
1493         char            buf[NAME_MAX + 1];
1494         pathname_t      newname;
1495         int             rval;
1496
1497         rval = lstat64(name->path, sbuf);
1498         if (rval >= 0 || errno != ENAMETOOLONG)
1499                 return rval;
1500         separate_pathname(name, buf, &newname);
1501         if (chdir(buf) == 0) {
1502                 rval = lstat64_path(&newname, sbuf);
1503                 assert(chdir("..") == 0);
1504         }
1505         free_pathname(&newname);
1506         return rval;
1507 }
1508
1509 void
1510 make_freq_table(void)
1511 {
1512         int             f;
1513         int             i;
1514         opdesc_t        *p;
1515
1516         for (p = ops, f = 0; p < ops_end; p++)
1517                 f += p->freq;
1518         freq_table = malloc(f * sizeof(*freq_table));
1519         freq_table_size = f;
1520         for (p = ops, i = 0; p < ops_end; p++) {
1521                 for (f = 0; f < p->freq; f++, i++)
1522                         freq_table[i] = p - ops;
1523         }
1524 }
1525
1526 int
1527 mkdir_path(pathname_t *name, mode_t mode)
1528 {
1529         char            buf[NAME_MAX + 1];
1530         pathname_t      newname;
1531         int             rval;
1532
1533         rval = mkdir(name->path, mode);
1534         if (rval >= 0 || errno != ENAMETOOLONG)
1535                 return rval;
1536         separate_pathname(name, buf, &newname);
1537         if (chdir(buf) == 0) {
1538                 rval = mkdir_path(&newname, mode);
1539                 assert(chdir("..") == 0);
1540         }
1541         free_pathname(&newname);
1542         return rval;
1543 }
1544
1545 int
1546 mknod_path(pathname_t *name, mode_t mode, dev_t dev)
1547 {
1548         char            buf[NAME_MAX + 1];
1549         pathname_t      newname;
1550         int             rval;
1551
1552         rval = mknod(name->path, mode, dev);
1553         if (rval >= 0 || errno != ENAMETOOLONG)
1554                 return rval;
1555         separate_pathname(name, buf, &newname);
1556         if (chdir(buf) == 0) {
1557                 rval = mknod_path(&newname, mode, dev);
1558                 assert(chdir("..") == 0);
1559         }
1560         free_pathname(&newname);
1561         return rval;
1562 }
1563
1564 void
1565 namerandpad(int id, char *buf, int i)
1566 {
1567         int             bucket;
1568         static int      buckets[] =
1569                                 { 2, 4, 8, 16, 32, 64, 128, NAME_MAX };
1570         int             padlen;
1571         int             padmod;
1572
1573         if (namerand == 0)
1574                 return;
1575         bucket = (id ^ namerand) % (sizeof(buckets) / sizeof(buckets[0]));
1576         padmod = buckets[bucket] + 1 - i;
1577         if (padmod <= 0)
1578                 return;
1579         padlen = (id ^ namerand) % padmod;
1580         if (padlen) {
1581                 memset(&buf[i], 'X', padlen);
1582                 buf[i + padlen] = '\0';
1583         }
1584 }
1585
1586 int
1587 open_file_or_dir(pathname_t *name, int flags)
1588 {
1589         int fd;
1590
1591         fd = open_path(name, flags);
1592         if (fd != -1)
1593                 return fd;
1594         if (fd == -1 && errno != EISDIR)
1595                 return fd;
1596         /* Directories can not be opened in write mode nor direct mode. */
1597         flags &= ~(O_WRONLY | O_DIRECT);
1598         flags |= O_RDONLY | O_DIRECTORY;
1599         return open_path(name, flags);
1600 }
1601
1602 int
1603 open_path(pathname_t *name, int oflag)
1604 {
1605         char            buf[NAME_MAX + 1];
1606         pathname_t      newname;
1607         int             rval;
1608
1609         rval = open(name->path, oflag);
1610         if (rval >= 0 || errno != ENAMETOOLONG)
1611                 return rval;
1612         separate_pathname(name, buf, &newname);
1613         if (chdir(buf) == 0) {
1614                 rval = open_path(&newname, oflag);
1615                 assert(chdir("..") == 0);
1616         }
1617         free_pathname(&newname);
1618         return rval;
1619 }
1620
1621 DIR *
1622 opendir_path(pathname_t *name)
1623 {
1624         char            buf[NAME_MAX + 1];
1625         pathname_t      newname;
1626         DIR             *rval;
1627
1628         rval = opendir(name->path);
1629         if (rval || errno != ENAMETOOLONG)
1630                 return rval;
1631         separate_pathname(name, buf, &newname);
1632         if (chdir(buf) == 0) {
1633                 rval = opendir_path(&newname);
1634                 assert(chdir("..") == 0);
1635         }
1636         free_pathname(&newname);
1637         return rval;
1638 }
1639
1640 void
1641 process_freq(char *arg)
1642 {
1643         opdesc_t        *p;
1644         char            *s;
1645
1646         s = strchr(arg, '=');
1647         if (s == NULL) {
1648                 fprintf(stderr, "bad argument '%s'\n", arg);
1649                 exit(1);
1650         }
1651         *s++ = '\0';
1652         for (p = ops; p < ops_end; p++) {
1653                 if (strcmp(arg, p->name) == 0) {
1654                         p->freq = atoi(s);
1655                         return;
1656                 }
1657         }
1658         fprintf(stderr, "can't find op type %s for -f\n", arg);
1659         exit(1);
1660 }
1661
1662 int
1663 readlink_path(pathname_t *name, char *lbuf, size_t lbufsiz)
1664 {
1665         char            buf[NAME_MAX + 1];
1666         pathname_t      newname;
1667         int             rval;
1668
1669         rval = readlink(name->path, lbuf, lbufsiz);
1670         if (rval >= 0 || errno != ENAMETOOLONG)
1671                 return rval;
1672         separate_pathname(name, buf, &newname);
1673         if (chdir(buf) == 0) {
1674                 rval = readlink_path(&newname, lbuf, lbufsiz);
1675                 assert(chdir("..") == 0);
1676         }
1677         free_pathname(&newname);
1678         return rval;
1679 }
1680
1681 int
1682 rename_path(pathname_t *name1, pathname_t *name2, int mode)
1683 {
1684         char            buf1[NAME_MAX + 1];
1685         char            buf2[NAME_MAX + 1];
1686         int             down1;
1687         pathname_t      newname1;
1688         pathname_t      newname2;
1689         int             rval;
1690
1691         if (mode == 0)
1692                 rval = rename(name1->path, name2->path);
1693         else
1694                 rval = renameat2(AT_FDCWD, name1->path,
1695                                  AT_FDCWD, name2->path, mode);
1696         if (rval >= 0 || errno != ENAMETOOLONG)
1697                 return rval;
1698         separate_pathname(name1, buf1, &newname1);
1699         separate_pathname(name2, buf2, &newname2);
1700         if (strcmp(buf1, buf2) == 0) {
1701                 if (chdir(buf1) == 0) {
1702                         rval = rename_path(&newname1, &newname2, mode);
1703                         assert(chdir("..") == 0);
1704                 }
1705         } else {
1706                 if (strcmp(buf1, "..") == 0)
1707                         down1 = 0;
1708                 else if (strcmp(buf2, "..") == 0)
1709                         down1 = 1;
1710                 else if (strlen(buf1) == 0)
1711                         down1 = 0;
1712                 else if (strlen(buf2) == 0)
1713                         down1 = 1;
1714                 else
1715                         down1 = MAX(newname1.len, 3 + name2->len) <=
1716                                 MAX(3 + name1->len, newname2.len);
1717                 if (down1) {
1718                         free_pathname(&newname2);
1719                         append_pathname(&newname2, "../");
1720                         append_pathname(&newname2, name2->path);
1721                         if (chdir(buf1) == 0) {
1722                                 rval = rename_path(&newname1, &newname2, mode);
1723                                 assert(chdir("..") == 0);
1724                         }
1725                 } else {
1726                         free_pathname(&newname1);
1727                         append_pathname(&newname1, "../");
1728                         append_pathname(&newname1, name1->path);
1729                         if (chdir(buf2) == 0) {
1730                                 rval = rename_path(&newname1, &newname2, mode);
1731                                 assert(chdir("..") == 0);
1732                         }
1733                 }
1734         }
1735         free_pathname(&newname1);
1736         free_pathname(&newname2);
1737         return rval;
1738 }
1739
1740 int
1741 rmdir_path(pathname_t *name)
1742 {
1743         char            buf[NAME_MAX + 1];
1744         pathname_t      newname;
1745         int             rval;
1746
1747         rval = rmdir(name->path);
1748         if (rval >= 0 || errno != ENAMETOOLONG)
1749                 return rval;
1750         separate_pathname(name, buf, &newname);
1751         if (chdir(buf) == 0) {
1752                 rval = rmdir_path(&newname);
1753                 assert(chdir("..") == 0);
1754         }
1755         free_pathname(&newname);
1756         return rval;
1757 }
1758
1759 void
1760 separate_pathname(pathname_t *name, char *buf, pathname_t *newname)
1761 {
1762         char    *slash;
1763
1764         init_pathname(newname);
1765         slash = strchr(name->path, '/');
1766         if (slash == NULL) {
1767                 buf[0] = '\0';
1768                 return;
1769         }
1770         *slash = '\0';
1771         strcpy(buf, name->path);
1772         *slash = '/';
1773         append_pathname(newname, slash + 1);
1774 }
1775
1776 #define WIDTH 80
1777
1778 void
1779 show_ops(int flag, char *lead_str)
1780 {
1781         opdesc_t        *p;
1782
1783         if (flag<0) {
1784                 /* print in list form */
1785                 int             x = WIDTH;
1786                 
1787                 for (p = ops; p < ops_end; p++) {
1788                         if (lead_str != NULL && x+strlen(p->name)>=WIDTH-5)
1789                                 x=printf("%s%s", (p==ops)?"":"\n", lead_str);
1790                         x+=printf("%s ", p->name);
1791                 }
1792                 printf("\n");
1793         } else if (flag == 0) {
1794                 /* Table view style */
1795                 int             f;
1796                 for (f = 0, p = ops; p < ops_end; p++)
1797                         f += p->freq;
1798
1799                 if (f == 0)
1800                         flag = 1;
1801
1802                 for (p = ops; p < ops_end; p++) {
1803                         if (flag != 0 || p->freq > 0) {
1804                                 if (lead_str != NULL)
1805                                         printf("%s", lead_str);
1806                                 printf("%20s %d/%d %s\n",
1807                                 p->name, p->freq, f,
1808                                 (p->iswrite == 0) ? " " : "write op");
1809                         }
1810                 }
1811         } else {
1812                 /* Command line style */
1813                 if (lead_str != NULL)
1814                         printf("%s", lead_str);
1815                 printf ("-z -s %ld -m %d -n %lld -p %d \\\n", seed, idmodulo,
1816                         operations, nproc);
1817                 for (p = ops; p < ops_end; p++)
1818                         if (p->freq > 0)
1819                                 printf("-f %s=%d \\\n",p->name, p->freq);
1820         }
1821 }
1822
1823 int
1824 stat64_path(pathname_t *name, struct stat64 *sbuf)
1825 {
1826         char            buf[NAME_MAX + 1];
1827         pathname_t      newname;
1828         int             rval;
1829
1830         rval = stat64(name->path, sbuf);
1831         if (rval >= 0 || errno != ENAMETOOLONG)
1832                 return rval;
1833         separate_pathname(name, buf, &newname);
1834         if (chdir(buf) == 0) {
1835                 rval = stat64_path(&newname, sbuf);
1836                 assert(chdir("..") == 0);
1837         }
1838         free_pathname(&newname);
1839         return rval;
1840 }
1841
1842 int
1843 symlink_path(const char *name1, pathname_t *name)
1844 {
1845         char            buf[NAME_MAX + 1];
1846         pathname_t      newname;
1847         int             rval;
1848         
1849         if (!strcmp(name1, name->path)) {
1850             printf("yikes! %s %s\n", name1, name->path);
1851             return 0;
1852         }
1853
1854         rval = symlink(name1, name->path);
1855         if (rval >= 0 || errno != ENAMETOOLONG)
1856                 return rval;
1857         separate_pathname(name, buf, &newname);
1858         if (chdir(buf) == 0) {
1859                 rval = symlink_path(name1, &newname);
1860                 assert(chdir("..") == 0);
1861         }
1862         free_pathname(&newname);
1863         return rval;
1864 }
1865
1866 int
1867 truncate64_path(pathname_t *name, off64_t length)
1868 {
1869         char            buf[NAME_MAX + 1];
1870         pathname_t      newname;
1871         int             rval;
1872
1873         rval = truncate64(name->path, length);
1874         if (rval >= 0 || errno != ENAMETOOLONG)
1875                 return rval;
1876         separate_pathname(name, buf, &newname);
1877         if (chdir(buf) == 0) {
1878                 rval = truncate64_path(&newname, length);
1879                 assert(chdir("..") == 0);
1880         }
1881         free_pathname(&newname);
1882         return rval;
1883 }
1884
1885 int
1886 unlink_path(pathname_t *name)
1887 {
1888         char            buf[NAME_MAX + 1];
1889         pathname_t      newname;
1890         int             rval;
1891
1892         rval = unlink(name->path);
1893         if (rval >= 0 || errno != ENAMETOOLONG)
1894                 return rval;
1895         separate_pathname(name, buf, &newname);
1896         if (chdir(buf) == 0) {
1897                 rval = unlink_path(&newname);
1898                 assert(chdir("..") == 0);
1899         }
1900         free_pathname(&newname);
1901         return rval;
1902 }
1903
1904 void
1905 usage(void)
1906 {
1907         printf("Usage: %s -H   or\n", myprog);
1908         printf("       %s [-c][-d dir][-e errtg][-f op_name=freq][-l loops][-n nops]\n",
1909                 myprog);
1910         printf("          [-p nproc][-r len][-s seed][-v][-w][-x cmd][-z][-S][-X ncmd]\n");
1911         printf("where\n");
1912         printf("   -c               clean up the test directory after each run\n");
1913         printf("   -d dir           specifies the base directory for operations\n");
1914         printf("   -e errtg         specifies error injection stuff\n");
1915         printf("   -f op_name=freq  changes the frequency of option name to freq\n");
1916         printf("                    the valid operation names are:\n");
1917         show_ops(-1, "                        ");
1918         printf("   -i filenum       get verbose output for this nth file object\n");
1919         printf("   -l loops         specifies the no. of times the testrun should loop.\n");
1920         printf("                     *use 0 for infinite (default 1)\n");
1921         printf("   -m modulo        uid/gid modulo for chown/chgrp (default 32)\n");
1922         printf("   -n nops          specifies the no. of operations per process (default 1)\n");
1923         printf("   -o logfile       specifies logfile name\n");
1924         printf("   -p nproc         specifies the no. of processes (default 1)\n");
1925         printf("   -r               specifies random name padding\n");
1926         printf("   -s seed          specifies the seed for the random generator (default random)\n");
1927         printf("   -v               specifies verbose mode\n");
1928         printf("   -w               zeros frequencies of non-write operations\n");
1929         printf("   -x cmd           execute command in the middle of operations\n");
1930         printf("   -z               zeros frequencies of all operations\n");
1931         printf("   -S [c,t]         prints the list of operations (omitting zero frequency) in command line or table style\n");
1932         printf("   -V               specifies verifiable logging mode (omitting inode numbers)\n");
1933         printf("   -X ncmd          number of calls to the -x command (default 1)\n");
1934         printf("   -H               prints usage and exits\n");
1935 }
1936
1937 void
1938 write_freq(void)
1939 {
1940         opdesc_t        *p;
1941
1942         for (p = ops; p < ops_end; p++) {
1943                 if (!p->iswrite)
1944                         p->freq = 0;
1945         }
1946 }
1947
1948 void
1949 zero_freq(void)
1950 {
1951         opdesc_t        *p;
1952
1953         for (p = ops; p < ops_end; p++)
1954                 p->freq = 0;
1955 }
1956
1957 #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
1958
1959 opty_t btrfs_ops[] = {
1960         OP_SNAPSHOT,
1961         OP_SUBVOL_CREATE,
1962         OP_SUBVOL_DELETE,
1963 };
1964
1965 void
1966 non_btrfs_freq(const char *path)
1967 {
1968         int                     i;
1969 #ifdef HAVE_BTRFSUTIL_H
1970         enum btrfs_util_error   e;
1971
1972         e = btrfs_util_is_subvolume(path);
1973         if (e != BTRFS_UTIL_ERROR_NOT_BTRFS)
1974                 return;
1975 #endif
1976         for (i = 0; i < ARRAY_SIZE(btrfs_ops); i++)
1977                 ops[btrfs_ops[i]].freq = 0;
1978 }
1979
1980 void inode_info(char *str, size_t sz, struct stat64 *s, int verbose)
1981 {
1982         if (verbose)
1983                 snprintf(str, sz, "[%ld %ld %d %d %lld %lld]",
1984                          verifiable_log ? -1: (long)s->st_ino,
1985                          (long)s->st_nlink,  s->st_uid, s->st_gid,
1986                          (long long) s->st_blocks, (long long) s->st_size);
1987 }
1988
1989 void
1990 afsync_f(opnum_t opno, long r)
1991 {
1992 #ifdef AIO
1993         int             e;
1994         pathname_t      f;
1995         int             fd;
1996         int             v;
1997         struct iocb     iocb;
1998         struct iocb     *iocbs[] = { &iocb };
1999         struct io_event event;
2000
2001         init_pathname(&f);
2002         if (!get_fname(FT_REGFILE | FT_DIRm, r, &f, NULL, NULL, &v)) {
2003                 if (v)
2004                         printf("%d/%lld: afsync - no filename\n", procid, opno);
2005                 free_pathname(&f);
2006                 return;
2007         }
2008         fd = open_file_or_dir(&f, O_WRONLY | O_DIRECT);
2009         e = fd < 0 ? errno : 0;
2010         check_cwd();
2011         if (fd < 0) {
2012                 if (v)
2013                         printf("%d/%lld: afsync - open %s failed %d\n",
2014                                procid, opno, f.path, e);
2015                 free_pathname(&f);
2016                 return;
2017         }
2018
2019         io_prep_fsync(&iocb, fd);
2020         if ((e = io_submit(io_ctx, 1, iocbs)) != 1) {
2021                 if (v)
2022                         printf("%d/%lld: afsync - io_submit %s %d\n",
2023                                procid, opno, f.path, e);
2024                 free_pathname(&f);
2025                 close(fd);
2026                 return;
2027         }
2028         if ((e = io_getevents(io_ctx, 1, 1, &event, NULL)) != 1) {
2029                 if (v)
2030                         printf("%d/%lld: afsync - io_getevents failed %d\n",
2031                                procid, opno, e);
2032                 free_pathname(&f);
2033                 close(fd);
2034                 return;
2035         }
2036
2037         e = event.res2;
2038         if (v)
2039                 printf("%d/%lld: afsync %s %d\n", procid, opno, f.path, e);
2040         free_pathname(&f);
2041         close(fd);
2042 #endif
2043 }
2044
2045 void
2046 allocsp_f(opnum_t opno, long r)
2047 {
2048         int             e;
2049         pathname_t      f;
2050         int             fd;
2051         struct xfs_flock64      fl;
2052         int64_t         lr;
2053         off64_t         off;
2054         struct stat64   stb;
2055         int             v;
2056         char            st[1024];
2057
2058         init_pathname(&f);
2059         if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
2060                 if (v)
2061                         printf("%d/%lld: allocsp - no filename\n", procid, opno);
2062                 free_pathname(&f);
2063                 return;
2064         }
2065         fd = open_path(&f, O_RDWR);
2066         e = fd < 0 ? errno : 0;
2067         check_cwd();
2068         if (fd < 0) {
2069                 if (v)
2070                         printf("%d/%lld: allocsp - open %s failed %d\n",
2071                                 procid, opno, f.path, e);
2072                 free_pathname(&f);
2073                 return;
2074         }
2075         if (fstat64(fd, &stb) < 0) {
2076                 if (v)
2077                         printf("%d/%lld: allocsp - fstat64 %s failed %d\n",
2078                                 procid, opno, f.path, errno);
2079                 free_pathname(&f);
2080                 close(fd);
2081                 return;
2082         }
2083         inode_info(st, sizeof(st), &stb, v);
2084         lr = ((int64_t)random() << 32) + random();
2085         off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
2086         off %= maxfsize;
2087         fl.l_whence = SEEK_SET;
2088         fl.l_start = off;
2089         fl.l_len = 0;
2090         e = xfsctl(f.path, fd, XFS_IOC_ALLOCSP64, &fl) < 0 ? errno : 0;
2091         if (v) {
2092                 printf("%d/%lld: xfsctl(XFS_IOC_ALLOCSP64) %s%s %lld 0 %d\n",
2093                        procid, opno, f.path, st, (long long)off, e);
2094         }
2095         free_pathname(&f);
2096         close(fd);
2097 }
2098
2099 #ifdef AIO
2100 void
2101 do_aio_rw(opnum_t opno, long r, int flags)
2102 {
2103         int64_t         align;
2104         char            *buf = NULL;
2105         struct dioattr  diob;
2106         int             e;
2107         pathname_t      f;
2108         int             fd = -1;
2109         size_t          len;
2110         int64_t         lr;
2111         off64_t         off;
2112         struct stat64   stb;
2113         int             v;
2114         char            st[1024];
2115         char            *dio_env;
2116         struct iocb     iocb;
2117         struct io_event event;
2118         struct iocb     *iocbs[] = { &iocb };
2119         int             iswrite = (flags & (O_WRONLY | O_RDWR)) ? 1 : 0;
2120
2121         init_pathname(&f);
2122         if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
2123                 if (v)
2124                         printf("%d/%lld: do_aio_rw - no filename\n", procid, opno);
2125                 goto aio_out;
2126         }
2127         fd = open_path(&f, flags|O_DIRECT);
2128         e = fd < 0 ? errno : 0;
2129         check_cwd();
2130         if (fd < 0) {
2131                 if (v)
2132                         printf("%d/%lld: do_aio_rw - open %s failed %d\n",
2133                                procid, opno, f.path, e);
2134                 goto aio_out;
2135         }
2136         if (fstat64(fd, &stb) < 0) {
2137                 if (v)
2138                         printf("%d/%lld: do_aio_rw - fstat64 %s failed %d\n",
2139                                procid, opno, f.path, errno);
2140                 goto aio_out;
2141         }
2142         inode_info(st, sizeof(st), &stb, v);
2143         if (!iswrite && stb.st_size == 0) {
2144                 if (v)
2145                         printf("%d/%lld: do_aio_rw - %s%s zero size\n", procid, opno,
2146                                f.path, st);
2147                 goto aio_out;
2148         }
2149         if (xfsctl(f.path, fd, XFS_IOC_DIOINFO, &diob) < 0) {
2150                 if (v)
2151                         printf(
2152                         "%d/%lld: do_aio_rw - xfsctl(XFS_IOC_DIOINFO) %s%s return %d,"
2153                         " fallback to stat()\n",
2154                                 procid, opno, f.path, st, errno);
2155                 diob.d_mem = diob.d_miniosz = stb.st_blksize;
2156                 diob.d_maxiosz = rounddown_64(INT_MAX, diob.d_miniosz);
2157         }
2158         dio_env = getenv("XFS_DIO_MIN");
2159         if (dio_env)
2160                 diob.d_mem = diob.d_miniosz = atoi(dio_env);
2161         align = (int64_t)diob.d_miniosz;
2162         lr = ((int64_t)random() << 32) + random();
2163         len = (random() % FILELEN_MAX) + 1;
2164         len -= (len % align);
2165         if (len <= 0)
2166                 len = align;
2167         else if (len > diob.d_maxiosz)
2168                 len = diob.d_maxiosz;
2169         buf = memalign(diob.d_mem, len);
2170         if (!buf) {
2171                 if (v)
2172                         printf("%d/%lld: do_aio_rw - memalign failed\n",
2173                                procid, opno);
2174                 goto aio_out;
2175         }
2176
2177         if (iswrite) {
2178                 off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
2179                 off -= (off % align);
2180                 off %= maxfsize;
2181                 memset(buf, nameseq & 0xff, len);
2182                 io_prep_pwrite(&iocb, fd, buf, len, off);
2183         } else {
2184                 off = (off64_t)(lr % stb.st_size);
2185                 off -= (off % align);
2186                 io_prep_pread(&iocb, fd, buf, len, off);
2187         }
2188         if ((e = io_submit(io_ctx, 1, iocbs)) != 1) {
2189                 if (v)
2190                         printf("%d/%lld: %s - io_submit failed %d\n",
2191                                procid, opno, iswrite ? "awrite" : "aread", e);
2192                 goto aio_out;
2193         }
2194         if ((e = io_getevents(io_ctx, 1, 1, &event, NULL)) != 1) {
2195                 if (v)
2196                         printf("%d/%lld: %s - io_getevents failed %d\n",
2197                                procid, opno, iswrite ? "awrite" : "aread", e);
2198                 goto aio_out;
2199         }
2200
2201         e = event.res != len ? event.res2 : 0;
2202         if (v)
2203                 printf("%d/%lld: %s %s%s [%lld,%d] %d\n",
2204                        procid, opno, iswrite ? "awrite" : "aread",
2205                        f.path, st, (long long)off, (int)len, e);
2206  aio_out:
2207         if (buf)
2208                 free(buf);
2209         if (fd != -1)
2210                 close(fd);
2211         free_pathname(&f);
2212 }
2213 #endif
2214
2215 #ifdef URING
2216 void
2217 do_uring_rw(opnum_t opno, long r, int flags)
2218 {
2219         char            *buf = NULL;
2220         int             e;
2221         pathname_t      f;
2222         int             fd = -1;
2223         size_t          len;
2224         int64_t         lr;
2225         off64_t         off;
2226         struct stat64   stb;
2227         int             v;
2228         char            st[1024];
2229         struct io_uring_sqe     *sqe;
2230         struct io_uring_cqe     *cqe;
2231         struct iovec    iovec;
2232         int             iswrite = (flags & (O_WRONLY | O_RDWR)) ? 1 : 0;
2233
2234         if (!have_io_uring)
2235                 return;
2236
2237         init_pathname(&f);
2238         if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
2239                 if (v)
2240                         printf("%d/%lld: do_uring_rw - no filename\n", procid, opno);
2241                 goto uring_out;
2242         }
2243         fd = open_path(&f, flags);
2244         e = fd < 0 ? errno : 0;
2245         check_cwd();
2246         if (fd < 0) {
2247                 if (v)
2248                         printf("%d/%lld: do_uring_rw - open %s failed %d\n",
2249                                procid, opno, f.path, e);
2250                 goto uring_out;
2251         }
2252         if (fstat64(fd, &stb) < 0) {
2253                 if (v)
2254                         printf("%d/%lld: do_uring_rw - fstat64 %s failed %d\n",
2255                                procid, opno, f.path, errno);
2256                 goto uring_out;
2257         }
2258         inode_info(st, sizeof(st), &stb, v);
2259         if (!iswrite && stb.st_size == 0) {
2260                 if (v)
2261                         printf("%d/%lld: do_uring_rw - %s%s zero size\n", procid, opno,
2262                                f.path, st);
2263                 goto uring_out;
2264         }
2265         sqe = io_uring_get_sqe(&ring);
2266         if (!sqe) {
2267                 if (v)
2268                         printf("%d/%lld: do_uring_rw - io_uring_get_sqe failed\n",
2269                                procid, opno);
2270                 goto uring_out;
2271         }
2272         lr = ((int64_t)random() << 32) + random();
2273         len = (random() % FILELEN_MAX) + 1;
2274         buf = malloc(len);
2275         if (!buf) {
2276                 if (v)
2277                         printf("%d/%lld: do_uring_rw - malloc failed\n",
2278                                procid, opno);
2279                 goto uring_out;
2280         }
2281         iovec.iov_base = buf;
2282         iovec.iov_len = len;
2283         if (iswrite) {
2284                 off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
2285                 off %= maxfsize;
2286                 memset(buf, nameseq & 0xff, len);
2287                 io_uring_prep_writev(sqe, fd, &iovec, 1, off);
2288         } else {
2289                 off = (off64_t)(lr % stb.st_size);
2290                 io_uring_prep_readv(sqe, fd, &iovec, 1, off);
2291         }
2292
2293         if ((e = io_uring_submit_and_wait(&ring, 1)) != 1) {
2294                 if (v)
2295                         printf("%d/%lld: %s - io_uring_submit failed %d\n", procid, opno,
2296                                iswrite ? "uring_write" : "uring_read", e);
2297                 goto uring_out;
2298         }
2299         if ((e = io_uring_wait_cqe(&ring, &cqe)) < 0) {
2300                 if (v)
2301                         printf("%d/%lld: %s - io_uring_wait_cqe failed %d\n", procid, opno,
2302                                iswrite ? "uring_write" : "uring_read", e);
2303                 goto uring_out;
2304         }
2305         if (v)
2306                 printf("%d/%lld: %s %s%s [%lld, %d(res=%d)] %d\n",
2307                        procid, opno, iswrite ? "uring_write" : "uring_read",
2308                        f.path, st, (long long)off, (int)len, cqe->res, e);
2309         io_uring_cqe_seen(&ring, cqe);
2310
2311  uring_out:
2312         if (buf)
2313                 free(buf);
2314         if (fd != -1)
2315                 close(fd);
2316         free_pathname(&f);
2317 }
2318 #endif
2319
2320 void
2321 aread_f(opnum_t opno, long r)
2322 {
2323 #ifdef AIO
2324         do_aio_rw(opno, r, O_RDONLY);
2325 #endif
2326 }
2327
2328 void
2329 attr_remove_f(opnum_t opno, long r)
2330 {
2331         char                    *bufname;
2332         char                    *bufend;
2333         char                    *aname = NULL;
2334         char                    buf[XATTR_LIST_MAX];
2335         int                     e;
2336         int                     ent;
2337         pathname_t              f;
2338         int                     total = 0;
2339         int                     v;
2340         int                     which;
2341
2342         init_pathname(&f);
2343         if (!get_fname(FT_ANYm, r, &f, NULL, NULL, &v))
2344                 append_pathname(&f, ".");
2345         e = attr_list_path(&f, buf, sizeof(buf));
2346         check_cwd();
2347         if (e > 0)
2348                 total = attr_list_count(buf, e);
2349         if (total == 0) {
2350                 if (v)
2351                         printf("%d/%lld: attr_remove - no attrs for %s\n",
2352                                 procid, opno, f.path);
2353                 free_pathname(&f);
2354                 return;
2355         }
2356
2357         which = (int)(random() % total);
2358         bufname = buf;
2359         bufend = buf + e;
2360         ent = 0;
2361         while (bufname < bufend) {
2362                 if (which < ent) {
2363                         aname = bufname;
2364                         break;
2365                 }
2366                 ent++;
2367                 bufname += strlen(bufname) + 1;
2368         }
2369         if (aname == NULL) {
2370                 if (v)
2371                         printf(
2372                         "%d/%lld: attr_remove - name %d not found at %s\n",
2373                                 procid, opno, which, f.path);
2374                 free_pathname(&f);
2375                 return;
2376         }
2377         if (attr_remove_path(&f, aname) < 0)
2378                 e = errno;
2379         else
2380                 e = 0;
2381         check_cwd();
2382         if (v)
2383                 printf("%d/%lld: attr_remove %s %s %d\n",
2384                         procid, opno, f.path, aname, e);
2385         free_pathname(&f);
2386 }
2387
2388 void
2389 attr_set_f(opnum_t opno, long r)
2390 {
2391         char            aname[10];
2392         char            *aval;
2393         int             e;
2394         pathname_t      f;
2395         int             len;
2396         static int      lengths[] = { 10, 100, 1000, 10000 };
2397         int             li;
2398         int             v;
2399
2400         init_pathname(&f);
2401         if (!get_fname(FT_ANYm, r, &f, NULL, NULL, &v))
2402                 append_pathname(&f, ".");
2403         sprintf(aname, "a%x", nameseq++);
2404         li = (int)(random() % (sizeof(lengths) / sizeof(lengths[0])));
2405         len = (int)(random() % lengths[li]);
2406         if (len == 0)
2407                 len = 1;
2408         aval = malloc(len);
2409         memset(aval, nameseq & 0xff, len);
2410         if (attr_set_path(&f, aname, aval, len) < 0)
2411                 e = errno;
2412         else
2413                 e = 0;
2414         check_cwd();
2415         free(aval);
2416         if (v)
2417                 printf("%d/%lld: attr_set %s %s %d\n", procid, opno, f.path,
2418                         aname, e);
2419         free_pathname(&f);
2420 }
2421
2422 void
2423 awrite_f(opnum_t opno, long r)
2424 {
2425 #ifdef AIO
2426         do_aio_rw(opno, r, O_WRONLY);
2427 #endif
2428 }
2429
2430 void
2431 bulkstat_f(opnum_t opno, long r)
2432 {
2433         int             count;
2434         int             fd;
2435         __u64           last;
2436         int             nent;
2437         struct xfs_bstat        *t;
2438         int64_t         total;
2439         struct xfs_fsop_bulkreq bsr;
2440
2441         last = 0;
2442         nent = (r % 999) + 2;
2443         t = malloc(nent * sizeof(*t));
2444         fd = open(".", O_RDONLY);
2445         total = 0;
2446
2447         bsr.lastip=&last;
2448         bsr.icount=nent;
2449         bsr.ubuffer=t;
2450         bsr.ocount=&count;
2451             
2452         while (xfsctl(".", fd, XFS_IOC_FSBULKSTAT, &bsr) == 0 && count > 0)
2453                 total += count;
2454         free(t);
2455         if (verbose)
2456                 printf("%d/%lld: bulkstat nent %d total %lld\n",
2457                         procid, opno, nent, (long long)total);
2458         close(fd);
2459 }
2460
2461 void
2462 bulkstat1_f(opnum_t opno, long r)
2463 {
2464         int             e;
2465         pathname_t      f;
2466         int             fd;
2467         int             good;
2468         __u64           ino;
2469         struct stat64   s;
2470         struct xfs_bstat        t;
2471         int             v;
2472         struct xfs_fsop_bulkreq bsr;
2473         
2474
2475         good = random() & 1;
2476         if (good) {
2477                /* use an inode we know exists */
2478                 init_pathname(&f);
2479                 if (!get_fname(FT_ANYm, r, &f, NULL, NULL, &v))
2480                         append_pathname(&f, ".");
2481                 ino = stat64_path(&f, &s) < 0 ? (ino64_t)r : s.st_ino;
2482                 check_cwd();
2483                 free_pathname(&f);
2484         } else {
2485                 /* 
2486                  * pick a random inode 
2487                  *
2488                  * note this can generate kernel warning messages
2489                  * since bulkstat_one will read the disk block that
2490                  * would contain a given inode even if that disk
2491                  * block doesn't contain inodes.
2492                  *
2493                  * this is detected later, but not until after the
2494                  * warning is displayed.
2495                  *
2496                  * "XFS: device 0x825- bad inode magic/vsn daddr 0x0 #0"
2497                  *
2498                  */
2499                 ino = (ino64_t)r;
2500                 v = verbose;
2501         }
2502         fd = open(".", O_RDONLY);
2503         
2504         bsr.lastip=&ino;
2505         bsr.icount=1;
2506         bsr.ubuffer=&t;
2507         bsr.ocount=NULL;
2508         e = xfsctl(".", fd, XFS_IOC_FSBULKSTAT_SINGLE, &bsr) < 0 ? errno : 0;
2509         if (v)
2510                 printf("%d/%lld: bulkstat1 %s ino %lld %d\n",
2511                        procid, opno, good?"real":"random",
2512                        verifiable_log ? -1LL : (long long)ino, e);
2513         close(fd);
2514 }
2515
2516 void
2517 chown_f(opnum_t opno, long r)
2518 {
2519         int             e;
2520         pathname_t      f;
2521         int             nbits;
2522         uid_t           u;
2523         gid_t           g;
2524         int             v;
2525
2526         init_pathname(&f);
2527         if (!get_fname(FT_ANYm, r, &f, NULL, NULL, &v))
2528                 append_pathname(&f, ".");
2529         u = (uid_t)random();
2530         g = (gid_t)random();
2531         nbits = (int)(random() % idmodulo);
2532         u &= (1 << nbits) - 1;
2533         g &= (1 << nbits) - 1;
2534         e = lchown_path(&f, u, g) < 0 ? errno : 0;
2535         check_cwd();
2536         if (v)
2537                 printf("%d/%lld: chown %s %d/%d %d\n", procid, opno, f.path, (int)u, (int)g, e);
2538         free_pathname(&f);
2539 }
2540
2541 /* reflink some arbitrary range of f1 to f2. */
2542 void
2543 clonerange_f(
2544         opnum_t                 opno,
2545         long                    r)
2546 {
2547 #ifdef FICLONERANGE
2548         struct file_clone_range fcr;
2549         struct pathname         fpath1;
2550         struct pathname         fpath2;
2551         struct stat64           stat1;
2552         struct stat64           stat2;
2553         char                    inoinfo1[1024];
2554         char                    inoinfo2[1024];
2555         off64_t                 lr;
2556         off64_t                 off1;
2557         off64_t                 off2;
2558         off64_t                 max_off2;
2559         size_t                  len;
2560         int                     v1;
2561         int                     v2;
2562         int                     fd1;
2563         int                     fd2;
2564         int                     ret;
2565         int                     e;
2566
2567         /* Load paths */
2568         init_pathname(&fpath1);
2569         if (!get_fname(FT_REGm, r, &fpath1, NULL, NULL, &v1)) {
2570                 if (v1)
2571                         printf("%d/%lld: clonerange read - no filename\n",
2572                                 procid, opno);
2573                 goto out_fpath1;
2574         }
2575
2576         init_pathname(&fpath2);
2577         if (!get_fname(FT_REGm, random(), &fpath2, NULL, NULL, &v2)) {
2578                 if (v2)
2579                         printf("%d/%lld: clonerange write - no filename\n",
2580                                 procid, opno);
2581                 goto out_fpath2;
2582         }
2583
2584         /* Open files */
2585         fd1 = open_path(&fpath1, O_RDONLY);
2586         e = fd1 < 0 ? errno : 0;
2587         check_cwd();
2588         if (fd1 < 0) {
2589                 if (v1)
2590                         printf("%d/%lld: clonerange read - open %s failed %d\n",
2591                                 procid, opno, fpath1.path, e);
2592                 goto out_fpath2;
2593         }
2594
2595         fd2 = open_path(&fpath2, O_WRONLY);
2596         e = fd2 < 0 ? errno : 0;
2597         check_cwd();
2598         if (fd2 < 0) {
2599                 if (v2)
2600                         printf("%d/%lld: clonerange write - open %s failed %d\n",
2601                                 procid, opno, fpath2.path, e);
2602                 goto out_fd1;
2603         }
2604
2605         /* Get file stats */
2606         if (fstat64(fd1, &stat1) < 0) {
2607                 if (v1)
2608                         printf("%d/%lld: clonerange read - fstat64 %s failed %d\n",
2609                                 procid, opno, fpath1.path, errno);
2610                 goto out_fd2;
2611         }
2612         inode_info(inoinfo1, sizeof(inoinfo1), &stat1, v1);
2613
2614         if (fstat64(fd2, &stat2) < 0) {
2615                 if (v2)
2616                         printf("%d/%lld: clonerange write - fstat64 %s failed %d\n",
2617                                 procid, opno, fpath2.path, errno);
2618                 goto out_fd2;
2619         }
2620         inode_info(inoinfo2, sizeof(inoinfo2), &stat2, v2);
2621
2622         /* Calculate offsets */
2623         len = (random() % FILELEN_MAX) + 1;
2624         len = rounddown_64(len, stat1.st_blksize);
2625         if (len == 0)
2626                 len = stat1.st_blksize;
2627         if (len > stat1.st_size)
2628                 len = stat1.st_size;
2629
2630         lr = ((int64_t)random() << 32) + random();
2631         if (stat1.st_size == len)
2632                 off1 = 0;
2633         else
2634                 off1 = (off64_t)(lr % MIN(stat1.st_size - len, MAXFSIZE));
2635         off1 %= maxfsize;
2636         off1 = rounddown_64(off1, stat1.st_blksize);
2637
2638         /*
2639          * If srcfile == destfile, randomly generate destination ranges
2640          * until we find one that doesn't overlap the source range.
2641          */
2642         max_off2 = MIN(stat2.st_size + (1024ULL * stat2.st_blksize), MAXFSIZE);
2643         do {
2644                 lr = ((int64_t)random() << 32) + random();
2645                 off2 = (off64_t)(lr % max_off2);
2646                 off2 %= maxfsize;
2647                 off2 = rounddown_64(off2, stat2.st_blksize);
2648         } while (stat1.st_ino == stat2.st_ino && llabs(off2 - off1) < len);
2649
2650         /* Clone data blocks */
2651         fcr.src_fd = fd1;
2652         fcr.src_offset = off1;
2653         fcr.src_length = len;
2654         fcr.dest_offset = off2;
2655
2656         ret = ioctl(fd2, FICLONERANGE, &fcr);
2657         e = ret < 0 ? errno : 0;
2658         if (v1 || v2) {
2659                 printf("%d/%lld: clonerange %s%s [%lld,%lld] -> %s%s [%lld,%lld]",
2660                         procid, opno,
2661                         fpath1.path, inoinfo1, (long long)off1, (long long)len,
2662                         fpath2.path, inoinfo2, (long long)off2, (long long)len);
2663
2664                 if (ret < 0)
2665                         printf(" error %d", e);
2666                 printf("\n");
2667         }
2668
2669 out_fd2:
2670         close(fd2);
2671 out_fd1:
2672         close(fd1);
2673 out_fpath2:
2674         free_pathname(&fpath2);
2675 out_fpath1:
2676         free_pathname(&fpath1);
2677 #endif
2678 }
2679
2680 /* copy some arbitrary range of f1 to f2. */
2681 void
2682 copyrange_f(
2683         opnum_t                 opno,
2684         long                    r)
2685 {
2686 #ifdef HAVE_COPY_FILE_RANGE
2687         struct pathname         fpath1;
2688         struct pathname         fpath2;
2689         struct stat64           stat1;
2690         struct stat64           stat2;
2691         char                    inoinfo1[1024];
2692         char                    inoinfo2[1024];
2693         loff_t                  lr;
2694         loff_t                  off1;
2695         loff_t                  off2;
2696         loff_t                  offset1;
2697         loff_t                  offset2;
2698         loff_t                  max_off2;
2699         size_t                  len;
2700         size_t                  length;
2701         int                     tries = 0;
2702         int                     v1;
2703         int                     v2;
2704         int                     fd1;
2705         int                     fd2;
2706         size_t                  ret = 0;
2707         int                     e;
2708
2709         /* Load paths */
2710         init_pathname(&fpath1);
2711         if (!get_fname(FT_REGm, r, &fpath1, NULL, NULL, &v1)) {
2712                 if (v1)
2713                         printf("%d/%lld: copyrange read - no filename\n",
2714                                 procid, opno);
2715                 goto out_fpath1;
2716         }
2717
2718         init_pathname(&fpath2);
2719         if (!get_fname(FT_REGm, random(), &fpath2, NULL, NULL, &v2)) {
2720                 if (v2)
2721                         printf("%d/%lld: copyrange write - no filename\n",
2722                                 procid, opno);
2723                 goto out_fpath2;
2724         }
2725
2726         /* Open files */
2727         fd1 = open_path(&fpath1, O_RDONLY);
2728         e = fd1 < 0 ? errno : 0;
2729         check_cwd();
2730         if (fd1 < 0) {
2731                 if (v1)
2732                         printf("%d/%lld: copyrange read - open %s failed %d\n",
2733                                 procid, opno, fpath1.path, e);
2734                 goto out_fpath2;
2735         }
2736
2737         fd2 = open_path(&fpath2, O_WRONLY);
2738         e = fd2 < 0 ? errno : 0;
2739         check_cwd();
2740         if (fd2 < 0) {
2741                 if (v2)
2742                         printf("%d/%lld: copyrange write - open %s failed %d\n",
2743                                 procid, opno, fpath2.path, e);
2744                 goto out_fd1;
2745         }
2746
2747         /* Get file stats */
2748         if (fstat64(fd1, &stat1) < 0) {
2749                 if (v1)
2750                         printf("%d/%lld: copyrange read - fstat64 %s failed %d\n",
2751                                 procid, opno, fpath1.path, errno);
2752                 goto out_fd2;
2753         }
2754         inode_info(inoinfo1, sizeof(inoinfo1), &stat1, v1);
2755
2756         if (fstat64(fd2, &stat2) < 0) {
2757                 if (v2)
2758                         printf("%d/%lld: copyrange write - fstat64 %s failed %d\n",
2759                                 procid, opno, fpath2.path, errno);
2760                 goto out_fd2;
2761         }
2762         inode_info(inoinfo2, sizeof(inoinfo2), &stat2, v2);
2763
2764         /* Calculate offsets */
2765         len = (random() % FILELEN_MAX) + 1;
2766         if (len == 0)
2767                 len = stat1.st_blksize;
2768         if (len > stat1.st_size)
2769                 len = stat1.st_size;
2770
2771         lr = ((int64_t)random() << 32) + random();
2772         if (stat1.st_size == len)
2773                 off1 = 0;
2774         else
2775                 off1 = (off64_t)(lr % MIN(stat1.st_size - len, MAXFSIZE));
2776         off1 %= maxfsize;
2777
2778         /*
2779          * If srcfile == destfile, randomly generate destination ranges
2780          * until we find one that doesn't overlap the source range.
2781          */
2782         max_off2 = MIN(stat2.st_size + (1024ULL * stat2.st_blksize), MAXFSIZE);
2783         do {
2784                 lr = ((int64_t)random() << 32) + random();
2785                 off2 = (off64_t)(lr % max_off2);
2786                 off2 %= maxfsize;
2787         } while (stat1.st_ino == stat2.st_ino && llabs(off2 - off1) < len);
2788
2789         /*
2790          * Since len, off1 and off2 will be changed later, preserve their
2791          * original values.
2792          */
2793         length = len;
2794         offset1 = off1;
2795         offset2 = off2;
2796
2797         while (len > 0) {
2798                 ret = syscall(__NR_copy_file_range, fd1, &off1, fd2, &off2,
2799                               len, 0);
2800                 if (ret < 0) {
2801                         if (errno != EAGAIN || tries++ >= 300)
2802                                 break;
2803                 } else if (ret > len || ret == 0)
2804                         break;
2805                 else if (ret > 0)
2806                         len -= ret;
2807         }
2808         e = ret < 0 ? errno : 0;
2809         if (v1 || v2) {
2810                 printf("%d/%lld: copyrange %s%s [%lld,%lld] -> %s%s [%lld,%lld]",
2811                         procid, opno,
2812                         fpath1.path, inoinfo1,
2813                         (long long)offset1, (long long)length,
2814                         fpath2.path, inoinfo2,
2815                         (long long)offset2, (long long)length);
2816
2817                 if (ret < 0)
2818                         printf(" error %d", e);
2819                 else if (len && ret > len)
2820                         printf(" asked for %lld, copied %lld??\n",
2821                                 (long long)len, (long long)ret);
2822                 printf("\n");
2823         }
2824
2825 out_fd2:
2826         close(fd2);
2827 out_fd1:
2828         close(fd1);
2829 out_fpath2:
2830         free_pathname(&fpath2);
2831 out_fpath1:
2832         free_pathname(&fpath1);
2833 #endif
2834 }
2835
2836 /* dedupe some arbitrary range of f1 to f2...fn. */
2837 void
2838 deduperange_f(
2839         opnum_t                 opno,
2840         long                    r)
2841 {
2842 #ifdef FIDEDUPERANGE
2843 #define INFO_SZ                 1024
2844         struct file_dedupe_range *fdr;
2845         struct pathname         *fpath;
2846         struct stat64           *stat;
2847         char                    *info;
2848         off64_t                 *off;
2849         int                     *v;
2850         int                     *fd;
2851         int                     nr;
2852         off64_t                 lr;
2853         size_t                  len;
2854         int                     ret;
2855         int                     i;
2856         int                     e;
2857
2858         if (flist[FT_REG].nfiles < 2)
2859                 return;
2860
2861         /* Pick somewhere between 2 and 128 files. */
2862         do {
2863                 nr = random() % (flist[FT_REG].nfiles + 1);
2864         } while (nr < 2 || nr > 128);
2865
2866         /* Alloc memory */
2867         fdr = malloc(nr * sizeof(struct file_dedupe_range_info) +
2868                      sizeof(struct file_dedupe_range));
2869         if (!fdr) {
2870                 printf("%d/%lld: line %d error %d\n",
2871                         procid, opno, __LINE__, errno);
2872                 return;
2873         }
2874         memset(fdr, 0, (nr * sizeof(struct file_dedupe_range_info) +
2875                         sizeof(struct file_dedupe_range)));
2876
2877         fpath = calloc(nr, sizeof(struct pathname));
2878         if (!fpath) {
2879                 printf("%d/%lld: line %d error %d\n",
2880                         procid, opno, __LINE__, errno);
2881                 goto out_fdr;
2882         }
2883
2884         stat = calloc(nr, sizeof(struct stat64));
2885         if (!stat) {
2886                 printf("%d/%lld: line %d error %d\n",
2887                         procid, opno, __LINE__, errno);
2888                 goto out_paths;
2889         }
2890
2891         info = calloc(nr, INFO_SZ);
2892         if (!info) {
2893                 printf("%d/%lld: line %d error %d\n",
2894                         procid, opno, __LINE__, errno);
2895                 goto out_stats;
2896         }
2897
2898         off = calloc(nr, sizeof(off64_t));
2899         if (!off) {
2900                 printf("%d/%lld: line %d error %d\n",
2901                         procid, opno, __LINE__, errno);
2902                 goto out_info;
2903         }
2904
2905         v = calloc(nr, sizeof(int));
2906         if (!v) {
2907                 printf("%d/%lld: line %d error %d\n",
2908                         procid, opno, __LINE__, errno);
2909                 goto out_offsets;
2910         }
2911         fd = calloc(nr, sizeof(int));
2912         if (!fd) {
2913                 printf("%d/%lld: line %d error %d\n",
2914                         procid, opno, __LINE__, errno);
2915                 goto out_v;
2916         }
2917         memset(fd, 0xFF, nr * sizeof(int));
2918
2919         /* Get paths for all files */
2920         for (i = 0; i < nr; i++)
2921                 init_pathname(&fpath[i]);
2922
2923         if (!get_fname(FT_REGm, r, &fpath[0], NULL, NULL, &v[0])) {
2924                 if (v[0])
2925                         printf("%d/%lld: deduperange read - no filename\n",
2926                                 procid, opno);
2927                 goto out_pathnames;
2928         }
2929
2930         for (i = 1; i < nr; i++) {
2931                 if (!get_fname(FT_REGm, random(), &fpath[i], NULL, NULL, &v[i])) {
2932                         if (v[i])
2933                                 printf("%d/%lld: deduperange write - no filename\n",
2934                                         procid, opno);
2935                         goto out_pathnames;
2936                 }
2937         }
2938
2939         /* Open files */
2940         fd[0] = open_path(&fpath[0], O_RDONLY);
2941         e = fd[0] < 0 ? errno : 0;
2942         check_cwd();
2943         if (fd[0] < 0) {
2944                 if (v[0])
2945                         printf("%d/%lld: deduperange read - open %s failed %d\n",
2946                                 procid, opno, fpath[0].path, e);
2947                 goto out_pathnames;
2948         }
2949
2950         for (i = 1; i < nr; i++) {
2951                 fd[i] = open_path(&fpath[i], O_WRONLY);
2952                 e = fd[i] < 0 ? errno : 0;
2953                 check_cwd();
2954                 if (fd[i] < 0) {
2955                         if (v[i])
2956                                 printf("%d/%lld: deduperange write - open %s failed %d\n",
2957                                         procid, opno, fpath[i].path, e);
2958                         goto out_fds;
2959                 }
2960         }
2961
2962         /* Get file stats */
2963         if (fstat64(fd[0], &stat[0]) < 0) {
2964                 if (v[0])
2965                         printf("%d/%lld: deduperange read - fstat64 %s failed %d\n",
2966                                 procid, opno, fpath[0].path, errno);
2967                 goto out_fds;
2968         }
2969
2970         inode_info(&info[0], INFO_SZ, &stat[0], v[0]);
2971
2972         for (i = 1; i < nr; i++) {
2973                 if (fstat64(fd[i], &stat[i]) < 0) {
2974                         if (v[i])
2975                                 printf("%d/%lld: deduperange write - fstat64 %s failed %d\n",
2976                                         procid, opno, fpath[i].path, errno);
2977                         goto out_fds;
2978                 }
2979                 inode_info(&info[i * INFO_SZ], INFO_SZ, &stat[i], v[i]);
2980         }
2981
2982         /* Never try to dedupe more than half of the src file. */
2983         len = (random() % FILELEN_MAX) + 1;
2984         len = rounddown_64(len, stat[0].st_blksize);
2985         if (len == 0)
2986                 len = stat[0].st_blksize / 2;
2987         if (len > stat[0].st_size / 2)
2988                 len = stat[0].st_size / 2;
2989
2990         /* Calculate offsets */
2991         lr = ((int64_t)random() << 32) + random();
2992         if (stat[0].st_size == len)
2993                 off[0] = 0;
2994         else
2995                 off[0] = (off64_t)(lr % MIN(stat[0].st_size - len, MAXFSIZE));
2996         off[0] %= maxfsize;
2997         off[0] = rounddown_64(off[0], stat[0].st_blksize);
2998
2999         /*
3000          * If srcfile == destfile[i], randomly generate destination ranges
3001          * until we find one that doesn't overlap the source range.
3002          */
3003         for (i = 1; i < nr; i++) {
3004                 int     tries = 0;
3005
3006                 do {
3007                         lr = ((int64_t)random() << 32) + random();
3008                         if (stat[i].st_size <= len)
3009                                 off[i] = 0;
3010                         else
3011                                 off[i] = (off64_t)(lr % MIN(stat[i].st_size - len, MAXFSIZE));
3012                         off[i] %= maxfsize;
3013                         off[i] = rounddown_64(off[i], stat[i].st_blksize);
3014                 } while (stat[0].st_ino == stat[i].st_ino &&
3015                          llabs(off[i] - off[0]) < len &&
3016                          tries++ < 10);
3017         }
3018
3019         /* Clone data blocks */
3020         fdr->src_offset = off[0];
3021         fdr->src_length = len;
3022         fdr->dest_count = nr - 1;
3023         for (i = 1; i < nr; i++) {
3024                 fdr->info[i - 1].dest_fd = fd[i];
3025                 fdr->info[i - 1].dest_offset = off[i];
3026         }
3027
3028         ret = ioctl(fd[0], FIDEDUPERANGE, fdr);
3029         e = ret < 0 ? errno : 0;
3030         if (v[0]) {
3031                 printf("%d/%lld: deduperange from %s%s [%lld,%lld]",
3032                         procid, opno,
3033                         fpath[0].path, &info[0], (long long)off[0],
3034                         (long long)len);
3035                 if (ret < 0)
3036                         printf(" error %d", e);
3037                 printf("\n");
3038         }
3039         if (ret < 0)
3040                 goto out_fds;
3041
3042         for (i = 1; i < nr; i++) {
3043                 e = fdr->info[i - 1].status < 0 ? fdr->info[i - 1].status : 0;
3044                 if (v[i]) {
3045                         printf("%d/%lld: ...to %s%s [%lld,%lld]",
3046                                 procid, opno,
3047                                 fpath[i].path, &info[i * INFO_SZ],
3048                                 (long long)off[i], (long long)len);
3049                         if (fdr->info[i - 1].status < 0)
3050                                 printf(" error %d", e);
3051                         if (fdr->info[i - 1].status == FILE_DEDUPE_RANGE_SAME)
3052                                 printf(" %llu bytes deduplicated",
3053                                         fdr->info[i - 1].bytes_deduped);
3054                         if (fdr->info[i - 1].status == FILE_DEDUPE_RANGE_DIFFERS)
3055                                 printf(" differed");
3056                         printf("\n");
3057                 }
3058         }
3059
3060 out_fds:
3061         for (i = 0; i < nr; i++)
3062                 if (fd[i] >= 0)
3063                         close(fd[i]);
3064 out_pathnames:
3065         for (i = 0; i < nr; i++)
3066                 free_pathname(&fpath[i]);
3067
3068         free(fd);
3069 out_v:
3070         free(v);
3071 out_offsets:
3072         free(off);
3073 out_info:
3074         free(info);
3075 out_stats:
3076         free(stat);
3077 out_paths:
3078         free(fpath);
3079 out_fdr:
3080         free(fdr);
3081 #endif
3082 }
3083
3084 void
3085 setxattr_f(opnum_t opno, long r)
3086 {
3087 #ifdef XFS_XFLAG_EXTSIZE
3088         struct fsxattr  fsx;
3089         int             fd;
3090         int             e;
3091         pathname_t      f;
3092         int             nbits;
3093         uint            p;
3094         int             v;
3095
3096         init_pathname(&f);
3097         if (!get_fname(FT_ANYm, r, &f, NULL, NULL, &v))
3098                 append_pathname(&f, ".");
3099         fd = open_path(&f, O_RDWR);
3100         e = fd < 0 ? errno : 0;
3101         check_cwd();
3102
3103         /* project ID */
3104         p = (uint)random();
3105         e = MIN(idmodulo, XFS_PROJIDMODULO_MAX);
3106         nbits = (int)(random() % e);
3107         p &= (1 << nbits) - 1;
3108
3109         if ((e = xfsctl(f.path, fd, XFS_IOC_FSGETXATTR, &fsx)) == 0) {
3110                 fsx.fsx_projid = p;
3111                 e = xfsctl(f.path, fd, XFS_IOC_FSSETXATTR, &fsx);
3112         }
3113         if (v)
3114                 printf("%d/%lld: setxattr %s %u %d\n", procid, opno, f.path, p, e);
3115         free_pathname(&f);
3116         close(fd);
3117 #endif
3118 }
3119
3120 void
3121 splice_f(opnum_t opno, long r)
3122 {
3123         struct pathname         fpath1;
3124         struct pathname         fpath2;
3125         struct stat64           stat1;
3126         struct stat64           stat2;
3127         char                    inoinfo1[1024];
3128         char                    inoinfo2[1024];
3129         loff_t                  lr;
3130         loff_t                  off1, off2;
3131         size_t                  len;
3132         loff_t                  offset1, offset2;
3133         size_t                  length;
3134         size_t                  total;
3135         int                     v1;
3136         int                     v2;
3137         int                     fd1;
3138         int                     fd2;
3139         ssize_t                 ret1 = 0, ret2 = 0;
3140         size_t                  bytes;
3141         int                     e;
3142         int                     filedes[2];
3143
3144         /* Load paths */
3145         init_pathname(&fpath1);
3146         if (!get_fname(FT_REGm, r, &fpath1, NULL, NULL, &v1)) {
3147                 if (v1)
3148                         printf("%d/%lld: splice read - no filename\n",
3149                                 procid, opno);
3150                 goto out_fpath1;
3151         }
3152
3153         init_pathname(&fpath2);
3154         if (!get_fname(FT_REGm, random(), &fpath2, NULL, NULL, &v2)) {
3155                 if (v2)
3156                         printf("%d/%lld: splice write - no filename\n",
3157                                 procid, opno);
3158                 goto out_fpath2;
3159         }
3160
3161         /* Open files */
3162         fd1 = open_path(&fpath1, O_RDONLY);
3163         e = fd1 < 0 ? errno : 0;
3164         check_cwd();
3165         if (fd1 < 0) {
3166                 if (v1)
3167                         printf("%d/%lld: splice read - open %s failed %d\n",
3168                                 procid, opno, fpath1.path, e);
3169                 goto out_fpath2;
3170         }
3171
3172         fd2 = open_path(&fpath2, O_WRONLY);
3173         e = fd2 < 0 ? errno : 0;
3174         check_cwd();
3175         if (fd2 < 0) {
3176                 if (v2)
3177                         printf("%d/%lld: splice write - open %s failed %d\n",
3178                                 procid, opno, fpath2.path, e);
3179                 goto out_fd1;
3180         }
3181
3182         /* Get file stats */
3183         if (fstat64(fd1, &stat1) < 0) {
3184                 if (v1)
3185                         printf("%d/%lld: splice read - fstat64 %s failed %d\n",
3186                                 procid, opno, fpath1.path, errno);
3187                 goto out_fd2;
3188         }
3189         inode_info(inoinfo1, sizeof(inoinfo1), &stat1, v1);
3190
3191         if (fstat64(fd2, &stat2) < 0) {
3192                 if (v2)
3193                         printf("%d/%lld: splice write - fstat64 %s failed %d\n",
3194                                 procid, opno, fpath2.path, errno);
3195                 goto out_fd2;
3196         }
3197         inode_info(inoinfo2, sizeof(inoinfo2), &stat2, v2);
3198
3199         /* Calculate offsets */
3200         len = (random() % FILELEN_MAX) + 1;
3201         if (len == 0)
3202                 len = stat1.st_blksize;
3203         if (len > stat1.st_size)
3204                 len = stat1.st_size;
3205
3206         lr = ((int64_t)random() << 32) + random();
3207         if (stat1.st_size == len)
3208                 off1 = 0;
3209         else
3210                 off1 = (off64_t)(lr % MIN(stat1.st_size - len, MAXFSIZE));
3211         off1 %= maxfsize;
3212
3213         /*
3214          * splice can overlap write, so the offset of the target file can be
3215          * any number. But to avoid too large offset, add a clamp of 1024 blocks
3216          * past the current dest file EOF
3217          */
3218         lr = ((int64_t)random() << 32) + random();
3219         off2 = (off64_t)(lr % MIN(stat2.st_size + (1024ULL * stat2.st_blksize), MAXFSIZE));
3220
3221         /*
3222          * Since len, off1 and off2 will be changed later, preserve their
3223          * original values.
3224          */
3225         length = len;
3226         offset1 = off1;
3227         offset2 = off2;
3228
3229         /* Pipe initialize */
3230         if (pipe(filedes) < 0) {
3231                 if (v1 || v2) {
3232                         printf("%d/%lld: splice - pipe failed %d\n",
3233                                 procid, opno, errno);
3234                         goto out_fd2;
3235                 }
3236         }
3237
3238         bytes = 0;
3239         total = 0;
3240         while (len > 0) {
3241                 /* move to pipe buffer */
3242                 ret1 = splice(fd1, &off1, filedes[1], NULL, len, 0);
3243                 if (ret1 <= 0) {
3244                         break;
3245                 }
3246                 bytes = ret1;
3247
3248                 /* move from pipe buffer to dst file */
3249                 while (bytes > 0) {
3250                         ret2 = splice(filedes[0], NULL, fd2, &off2, bytes, 0);
3251                         if (ret2 < 0) {
3252                                 break;
3253                         }
3254                         bytes -= ret2;
3255                 }
3256                 if (ret2 < 0)
3257                         break;
3258
3259                 len -= ret1;
3260                 total += ret1;
3261         }
3262
3263         if (ret1 < 0 || ret2 < 0)
3264                 e = errno;
3265         else
3266                 e = 0;
3267         if (v1 || v2) {
3268                 printf("%d/%lld: splice %s%s [%lld,%lld] -> %s%s [%lld,%lld] %d",
3269                         procid, opno,
3270                         fpath1.path, inoinfo1, (long long)offset1, (long long)length,
3271                         fpath2.path, inoinfo2, (long long)offset2, (long long)length, e);
3272
3273                 if (length && length > total)
3274                         printf(" asked for %lld, spliced %lld??\n",
3275                                 (long long)length, (long long)total);
3276                 printf("\n");
3277         }
3278
3279         close(filedes[0]);
3280         close(filedes[1]);
3281 out_fd2:
3282         close(fd2);
3283 out_fd1:
3284         close(fd1);
3285 out_fpath2:
3286         free_pathname(&fpath2);
3287 out_fpath1:
3288         free_pathname(&fpath1);
3289 }
3290
3291 void
3292 creat_f(opnum_t opno, long r)
3293 {
3294         struct fsxattr  a;
3295         int             e;
3296         int             e1;
3297         int             extsize;
3298         pathname_t      f;
3299         int             fd;
3300         fent_t          *fep;
3301         int             id;
3302         int             parid;
3303         int             type;
3304         int             v;
3305         int             v1;
3306
3307         if (!get_fname(FT_ANYDIR, r, NULL, NULL, &fep, &v1))
3308                 parid = -1;
3309         else
3310                 parid = fep->id;
3311         init_pathname(&f);
3312         e1 = (random() % 100);
3313         type = rtpct ? ((e1 > rtpct) ? FT_REG : FT_RTF) : FT_REG;
3314 #ifdef NOTYET
3315         if (type == FT_RTF)     /* rt always gets an extsize */
3316                 extsize = (random() % 10) + 1;
3317         else if (e1 < 10)       /* one-in-ten get an extsize */
3318                 extsize = random() % 1024;
3319         else
3320 #endif
3321                 extsize = 0;
3322         e = generate_fname(fep, type, &f, &id, &v);
3323         v |= v1;
3324         if (!e) {
3325                 if (v) {
3326                         (void)fent_to_name(&f, fep);
3327                         printf("%d/%lld: creat - no filename from %s\n",
3328                                 procid, opno, f.path);
3329                 }
3330                 free_pathname(&f);
3331                 return;
3332         }
3333         fd = creat_path(&f, 0666);
3334         e = fd < 0 ? errno : 0;
3335         e1 = 0;
3336         check_cwd();
3337         if (fd >= 0) {
3338                 if (extsize &&
3339                     xfsctl(f.path, fd, XFS_IOC_FSGETXATTR, &a) >= 0) {
3340                         if (type == FT_RTF) {
3341                                 a.fsx_xflags |= XFS_XFLAG_REALTIME;
3342                                 a.fsx_extsize = extsize *
3343                                                 geom.rtextsize * geom.blocksize;
3344 #ifdef NOTYET
3345                         } else if (extsize) {
3346                                 a.fsx_xflags |= XFS_XFLAG_EXTSIZE;
3347                                 a.fsx_extsize = extsize * geom.blocksize;
3348 #endif
3349                         }
3350                         if (xfsctl(f.path, fd, XFS_IOC_FSSETXATTR, &a) < 0)
3351                                 e1 = errno;
3352                 }
3353                 add_to_flist(type, id, parid, 0);
3354                 close(fd);
3355         }
3356         if (v) {
3357                 printf("%d/%lld: creat %s x:%d %d %d\n", procid, opno, f.path,
3358                         extsize ? a.fsx_extsize : 0, e, e1);
3359                 printf("%d/%lld: creat add id=%d,parent=%d\n", procid, opno, id, parid);
3360         }
3361         free_pathname(&f);
3362 }
3363
3364 void
3365 dread_f(opnum_t opno, long r)
3366 {
3367         int64_t         align;
3368         char            *buf;
3369         struct dioattr  diob;
3370         int             e;
3371         pathname_t      f;
3372         int             fd;
3373         size_t          len;
3374         int64_t         lr;
3375         off64_t         off;
3376         struct stat64   stb;
3377         int             v;
3378         char            st[1024];
3379         char            *dio_env;
3380