Whamcloud - gitweb
append_pathname: check the value returned by realloc
[tools/e2fsprogs.git] / contrib / fsstress.c
1 /*
2  * Copyright (c) 2000 Silicon Graphics, Inc.  All Rights Reserved.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms of version 2 of the GNU General Public License as
6  * published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it would be useful, but
9  * WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11  *
12  * Further, this software is distributed without any warranty that it is
13  * free of the rightful claim of any third person regarding infringement
14  * or the like.  Any license provided herein, whether implied or
15  * otherwise, applies only to this software file.  Patent licenses, if
16  * any, provided herein do not apply to combinations of this program with
17  * other software, or any other product whatsoever.
18  *
19  * You should have received a copy of the GNU General Public License along
20  * with this program; if not, write the Free Software Foundation, Inc.,
21  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22  *
23  * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
24  * Mountain View, CA  94043, or:
25  *
26  * http://www.sgi.com
27  *
28  * For further information regarding this notice, see:
29  *
30  * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
31  */
32
33 #define NO_XFS
34 #define HAVE_SYS_PRCTL_H
35 #define _LARGEFILE64_SOURCE
36
37 #define MAXNAMELEN 1024
38 struct dioattr {
39         int d_miniosz, d_maxiosz, d_mem;
40 };
41
42 #define MIN(a,b) ((a)<(b) ? (a):(b))
43 #define MAX(a,b) ((a)>(b) ? (a):(b))
44
45 #include <sys/stat.h>
46 #include <sys/statvfs.h>
47 #include <sys/time.h>
48 #include <sys/ioctl.h>
49 #include <sys/wait.h>
50 #include <sys/types.h>
51 #include <fcntl.h>
52 #include <stdlib.h>
53 #include <dirent.h>
54 #include <errno.h>
55 #include <string.h>
56 #include <stdlib.h>
57 #include <stdio.h>
58 #include <unistd.h>
59
60 #ifndef O_DIRECT
61 #define O_DIRECT 040000
62 #endif
63
64 #ifdef HAVE_SYS_PRCTL_H
65 # include <sys/prctl.h>
66 #endif
67
68 #define XFS_ERRTAG_MAX          17
69
70 typedef enum {
71 #ifndef NO_XFS
72         OP_ALLOCSP,
73         OP_ATTR_REMOVE,
74         OP_ATTR_SET,
75         OP_BULKSTAT,
76         OP_BULKSTAT1,
77 #endif
78         OP_CHOWN,
79         OP_CREAT,
80         OP_DREAD,
81         OP_DWRITE,
82         OP_FDATASYNC,
83 #ifndef NO_XFS
84         OP_FREESP,
85 #endif
86         OP_FSYNC,
87         OP_GETDENTS,
88         OP_LINK,
89         OP_MKDIR,
90         OP_MKNOD,
91         OP_READ,
92         OP_READLINK,
93         OP_RENAME,
94 #ifndef NO_XFS
95         OP_RESVSP,
96 #endif
97         OP_RMDIR,
98         OP_STAT,
99         OP_SYMLINK,
100         OP_SYNC,
101         OP_TRUNCATE,
102         OP_UNLINK,
103 #ifndef NO_XFS
104         OP_UNRESVSP,
105 #endif
106         OP_WRITE,
107         OP_LAST
108 } opty_t;
109
110 typedef void (*opfnc_t) (int, long);
111
112 typedef struct opdesc {
113         opty_t op;
114         char *name;
115         opfnc_t func;
116         int freq;
117         int iswrite;
118         int isxfs;
119 } opdesc_t;
120
121 typedef struct fent {
122         int id;
123         int parent;
124 } fent_t;
125
126 typedef struct flist {
127         int nfiles;
128         int nslots;
129         int tag;
130         fent_t *fents;
131 } flist_t;
132
133 typedef struct pathname {
134         int len;
135         char *path;
136 } pathname_t;
137
138 #define FT_DIR  0
139 #define FT_DIRm (1 << FT_DIR)
140 #define FT_REG  1
141 #define FT_REGm (1 << FT_REG)
142 #define FT_SYM  2
143 #define FT_SYMm (1 << FT_SYM)
144 #define FT_DEV  3
145 #define FT_DEVm (1 << FT_DEV)
146 #define FT_RTF  4
147 #define FT_RTFm (1 << FT_RTF)
148 #define FT_nft  5
149 #define FT_ANYm ((1 << FT_nft) - 1)
150 #define FT_REGFILE      (FT_REGm | FT_RTFm)
151 #define FT_NOTDIR       (FT_ANYm & ~FT_DIRm)
152
153 #define FLIST_SLOT_INCR 16
154 #define NDCACHE 64
155
156 #define MAXFSIZE        ((1ULL << 63) - 1ULL)
157 #define MAXFSIZE32      ((1ULL << 40) - 1ULL)
158
159 void allocsp_f(int, long);
160 void attr_remove_f(int, long);
161 void attr_set_f(int, long);
162 void bulkstat_f(int, long);
163 void bulkstat1_f(int, long);
164 void chown_f(int, long);
165 void creat_f(int, long);
166 void dread_f(int, long);
167 void dwrite_f(int, long);
168 void fdatasync_f(int, long);
169 void freesp_f(int, long);
170 void fsync_f(int, long);
171 void getdents_f(int, long);
172 void link_f(int, long);
173 void mkdir_f(int, long);
174 void mknod_f(int, long);
175 void read_f(int, long);
176 void readlink_f(int, long);
177 void rename_f(int, long);
178 void resvsp_f(int, long);
179 void rmdir_f(int, long);
180 void stat_f(int, long);
181 void symlink_f(int, long);
182 void sync_f(int, long);
183 void truncate_f(int, long);
184 void unlink_f(int, long);
185 void unresvsp_f(int, long);
186 void write_f(int, long);
187
188 opdesc_t ops[] = {
189 #ifndef NO_XFS
190         {OP_ALLOCSP, "allocsp", allocsp_f, 1, 1, 1},
191         {OP_ATTR_REMOVE, "attr_remove", attr_remove_f, /* 1 */ 0, 1, 1},
192         {OP_ATTR_SET, "attr_set", attr_set_f, /* 2 */ 0, 1, 1},
193         {OP_BULKSTAT, "bulkstat", bulkstat_f, 1, 0, 1},
194         {OP_BULKSTAT1, "bulkstat1", bulkstat1_f, 1, 0, 1},
195 #endif
196         {OP_CHOWN, "chown", chown_f, 3, 1, 0},
197         {OP_CREAT, "creat", creat_f, 4, 1, 0},
198         {OP_DREAD, "dread", dread_f, 4, 0, 0},
199         {OP_DWRITE, "dwrite", dwrite_f, 4, 1, 0},
200         {OP_FDATASYNC, "fdatasync", fdatasync_f, 1, 1, 0},
201 #ifndef NO_XFS
202         {OP_FREESP, "freesp", freesp_f, 1, 1, 1},
203 #endif
204         {OP_FSYNC, "fsync", fsync_f, 1, 1, 0},
205         {OP_GETDENTS, "getdents", getdents_f, 1, 0, 0},
206         {OP_LINK, "link", link_f, 1, 1, 0},
207         {OP_MKDIR, "mkdir", mkdir_f, 2, 1, 0},
208         {OP_MKNOD, "mknod", mknod_f, 2, 1, 0},
209         {OP_READ, "read", read_f, 1, 0, 0},
210         {OP_READLINK, "readlink", readlink_f, 1, 0, 0},
211         {OP_RENAME, "rename", rename_f, 2, 1, 0},
212 #ifndef NO_XFS
213         {OP_RESVSP, "resvsp", resvsp_f, 1, 1, 1},
214 #endif
215         {OP_RMDIR, "rmdir", rmdir_f, 1, 1, 0},
216         {OP_STAT, "stat", stat_f, 1, 0, 0},
217         {OP_SYMLINK, "symlink", symlink_f, 2, 1, 0},
218         {OP_SYNC, "sync", sync_f, 1, 0, 0},
219         {OP_TRUNCATE, "truncate", truncate_f, 2, 1, 0},
220         {OP_UNLINK, "unlink", unlink_f, 1, 1, 0},
221 #ifndef NO_XFS
222         {OP_UNRESVSP, "unresvsp", unresvsp_f, 1, 1, 1},
223 #endif
224         {OP_WRITE, "write", write_f, 4, 1, 0},
225 }, *ops_end;
226
227 flist_t flist[FT_nft] = {
228         {0, 0, 'd', NULL},
229         {0, 0, 'f', NULL},
230         {0, 0, 'l', NULL},
231         {0, 0, 'c', NULL},
232         {0, 0, 'r', NULL},
233 };
234
235 int dcache[NDCACHE];
236 int errrange;
237 int errtag;
238 opty_t *freq_table;
239 int freq_table_size;
240 #ifndef NO_XFS
241 xfs_fsop_geom_t geom;
242 #endif
243 char *homedir;
244 int *ilist;
245 int ilistlen;
246 off64_t maxfsize;
247 char *myprog;
248 int namerand;
249 int nameseq;
250 int nops;
251 int nproc = 1;
252 int operations = 1;
253 int procid;
254 int rtpct;
255 unsigned long seed = 0;
256 ino_t top_ino;
257 int verbose = 0;
258 #ifndef NO_XFS
259 int no_xfs = 0;
260 #else
261 int no_xfs = 1;
262 #endif
263 sig_atomic_t should_stop = 0;
264
265 void add_to_flist(int, int, int);
266 void append_pathname(pathname_t *, char *);
267 #ifndef NO_XFS
268 int attr_list_path(pathname_t *, char *, const int, int, attrlist_cursor_t *);
269 int attr_remove_path(pathname_t *, const char *, int);
270 int attr_set_path(pathname_t *, const char *, const char *, const int, int);
271 #endif
272 void check_cwd(void);
273 int creat_path(pathname_t *, mode_t);
274 void dcache_enter(int, int);
275 void dcache_init(void);
276 fent_t *dcache_lookup(int);
277 void dcache_purge(int);
278 void del_from_flist(int, int);
279 int dirid_to_name(char *, int);
280 void doproc(void);
281 void fent_to_name(pathname_t *, flist_t *, fent_t *);
282 void fix_parent(int, int);
283 void free_pathname(pathname_t *);
284 int generate_fname(fent_t *, int, pathname_t *, int *, int *);
285 int get_fname(int, long, pathname_t *, flist_t **, fent_t **, int *);
286 void init_pathname(pathname_t *);
287 int lchown_path(pathname_t *, uid_t, gid_t);
288 int link_path(pathname_t *, pathname_t *);
289 int lstat64_path(pathname_t *, struct stat64 *);
290 void make_freq_table(void);
291 int mkdir_path(pathname_t *, mode_t);
292 int mknod_path(pathname_t *, mode_t, dev_t);
293 void namerandpad(int, char *, int);
294 int open_path(pathname_t *, int);
295 DIR *opendir_path(pathname_t *);
296 void process_freq(char *);
297 int readlink_path(pathname_t *, char *, size_t);
298 int rename_path(pathname_t *, pathname_t *);
299 int rmdir_path(pathname_t *);
300 void separate_pathname(pathname_t *, char *, pathname_t *);
301 void show_ops(int, char *);
302 int stat64_path(pathname_t *, struct stat64 *);
303 int symlink_path(const char *, pathname_t *);
304 int truncate64_path(pathname_t *, off64_t);
305 int unlink_path(pathname_t *);
306 void usage(void);
307 void write_freq(void);
308 void zero_freq(void);
309
310 void sg_handler(int signum)
311 {
312         should_stop = 1;
313 }
314
315 int main(int argc, char **argv)
316 {
317         char buf[10];
318         int c;
319         char *dirname = NULL;
320         int fd;
321         int i;
322         int cleanup = 0;
323         int loops = 1;
324         int loopcntr = 1;
325         char cmd[256];
326 #ifndef NO_XFS
327         int j;
328 #endif
329         char *p;
330         int stat;
331         struct timeval t;
332 #ifndef NO_XFS
333         ptrdiff_t srval;
334 #endif
335         int nousage = 0;
336 #ifndef NO_XFS
337         xfs_error_injection_t err_inj;
338 #endif
339         struct sigaction action;
340
341         errrange = errtag = 0;
342         umask(0);
343         nops = sizeof(ops) / sizeof(ops[0]);
344         ops_end = &ops[nops];
345         myprog = argv[0];
346         while ((c = getopt(argc, argv, "cd:e:f:i:l:n:p:rs:vwzHSX")) != -1) {
347                 switch (c) {
348                 case 'c':
349                         /*Don't cleanup */
350                         cleanup = 1;
351                         break;
352                 case 'd':
353                         dirname = optarg;
354                         break;
355                 case 'e':
356                         sscanf(optarg, "%d", &errtag);
357                         if (errtag < 0) {
358                                 errtag = -errtag;
359                                 errrange = 1;
360                         } else if (errtag == 0)
361                                 errtag = -1;
362                         if (errtag >= XFS_ERRTAG_MAX) {
363                                 fprintf(stderr,
364                                         "error tag %d too large (max %d)\n",
365                                         errtag, XFS_ERRTAG_MAX - 1);
366                                 exit(1);
367                         }
368                         break;
369                 case 'f':
370                         process_freq(optarg);
371                         break;
372                 case 'i':
373                         ilist = realloc(ilist, ++ilistlen * sizeof(*ilist));
374                         ilist[ilistlen - 1] = strtol(optarg, &p, 16);
375                         break;
376                 case 'l':
377                         loops = atoi(optarg);
378                         break;
379                 case 'n':
380                         operations = atoi(optarg);
381                         break;
382                 case 'p':
383                         nproc = atoi(optarg);
384                         break;
385                 case 'r':
386                         namerand = 1;
387                         break;
388                 case 's':
389                         seed = strtoul(optarg, NULL, 0);
390                         break;
391                 case 'v':
392                         verbose = 1;
393                         break;
394                 case 'w':
395                         write_freq();
396                         break;
397                 case 'z':
398                         zero_freq();
399                         break;
400                 case 'S':
401                         show_ops(0, NULL);
402                         printf("\n");
403                         nousage = 1;
404                         break;
405                 case '?':
406                         fprintf(stderr, "%s - invalid parameters\n", myprog);
407                         /* fall through */
408                 case 'H':
409                         usage();
410                         exit(1);
411                 case 'X':
412                         no_xfs = 1;
413                         break;
414                 }
415         }
416
417         if (no_xfs && errtag) {
418                 fprintf(stderr, "error injection only works on XFS\n");
419                 exit(1);
420         }
421
422         if (no_xfs) {
423                 int i;
424                 for (i = 0; ops + i < ops_end; ++i) {
425                         if (ops[i].isxfs)
426                                 ops[i].freq = 0;
427                 }
428         }
429
430         make_freq_table();
431
432         while (((loopcntr <= loops) || (loops == 0)) && !should_stop) {
433                 if (!dirname) {
434                         /* no directory specified */
435                         if (!nousage)
436                                 usage();
437                         exit(1);
438                 }
439
440                 (void)mkdir(dirname, 0777);
441                 if (chdir(dirname) < 0) {
442                         perror(dirname);
443                         exit(1);
444                 }
445                 sprintf(buf, "fss%x", getpid());
446                 fd = creat(buf, 0666);
447                 if (lseek64(fd, (off64_t) (MAXFSIZE32 + 1ULL), SEEK_SET) < 0)
448                         maxfsize = (off64_t) MAXFSIZE32;
449                 else
450                         maxfsize = (off64_t) MAXFSIZE;
451                 dcache_init();
452                 setlinebuf(stdout);
453                 if (!seed) {
454                         gettimeofday(&t, NULL);
455                         seed = (int)t.tv_sec ^ (int)t.tv_usec;
456                         printf("seed = %ld\n", seed);
457                 }
458 #ifndef NO_XFS
459                 if (!no_xfs) {
460                         memset(&geom, 0, sizeof(geom));
461                         i = ioctl(fd, XFS_IOC_FSGEOMETRY, &geom);
462                         if (i >= 0 && geom.rtblocks)
463                                 rtpct = MIN(MAX(geom.rtblocks * 100 /
464                                                 (geom.rtblocks +
465                                                  geom.datablocks), 1), 99);
466                         else
467                                 rtpct = 0;
468                 }
469                 if (errtag != 0) {
470                         if (errrange == 0) {
471                                 if (errtag <= 0) {
472                                         srandom(seed);
473                                         j = random() % 100;
474
475                                         for (i = 0; i < j; i++)
476                                                 (void)random();
477
478                                         errtag =
479                                             (random() % (XFS_ERRTAG_MAX - 1)) +
480                                             1;
481                                 }
482                         } else {
483                                 srandom(seed);
484                                 j = random() % 100;
485
486                                 for (i = 0; i < j; i++)
487                                         (void)random();
488
489                                 errtag +=
490                                     (random() % (XFS_ERRTAG_MAX - errtag));
491                         }
492                         printf("Injecting failure on tag #%d\n", errtag);
493                         memset(&err_inj, 0, sizeof(err_inj));
494                         err_inj.errtag = errtag;
495                         err_inj.fd = fd;
496                         srval = ioctl(fd, XFS_IOC_ERROR_INJECTION, &err_inj);
497                         if (srval < -1) {
498                                 perror
499                                     ("fsstress - XFS_SYSSGI error injection call");
500                                 close(fd);
501                                 unlink(buf);
502                                 exit(1);
503                         }
504                 } else
505 #endif
506                         close(fd);
507                 unlink(buf);
508
509
510                 if (nproc == 1) {
511                         procid = 0;
512                         doproc();
513                 } else {
514                         setpgid(0, 0);
515                         action.sa_handler = sg_handler;
516                         sigemptyset(&action.sa_mask);
517                         action.sa_flags = 0;
518                         if (sigaction(SIGTERM, &action, 0)) {
519                                 perror("sigaction failed");
520                                 exit(1);
521                         }
522
523                         for (i = 0; i < nproc; i++) {
524                                 if (fork() == 0) {
525
526                                         action.sa_handler = SIG_DFL;
527                                         sigemptyset(&action.sa_mask);
528                                         if (sigaction(SIGTERM, &action, 0))
529                                                 return 1;
530 #ifdef HAVE_SYS_PRCTL_H
531                                         prctl(PR_SET_PDEATHSIG, SIGKILL);
532                                         if (getppid() == 1) /* parent died already? */
533                                                 return 0;
534 #endif
535                                         procid = i;
536                                         doproc();
537                                         return 0;
538                                 }
539                         }
540                         while (wait(&stat) > 0 && !should_stop) {
541                                 continue;
542                         }
543                         if (should_stop) {
544                                 action.sa_flags = SA_RESTART;
545                                 sigaction(SIGTERM, &action, 0);
546                                 kill(-getpid(), SIGTERM);
547                                 while (wait(&stat) > 0)
548                                         continue;
549                         }
550                 }
551 #ifndef NO_XFS
552                 if (errtag != 0) {
553                         memset(&err_inj, 0, sizeof(err_inj));
554                         err_inj.errtag = 0;
555                         err_inj.fd = fd;
556                         if ((srval =
557                              ioctl(fd, XFS_IOC_ERROR_CLEARALL,
558                                    &err_inj)) != 0) {
559                                 fprintf(stderr, "Bad ej clear on %d (%d).\n",
560                                         fd, errno);
561                                 perror
562                                     ("fsstress - XFS_SYSSGI clear error injection call");
563                                 close(fd);
564                                 exit(1);
565                         }
566                         close(fd);
567                 }
568 #endif
569                 if (cleanup == 0) {
570                         sprintf(cmd, "rm -rf %s/*", dirname);
571                         system(cmd);
572                         for (i = 0; i < FT_nft; i++) {
573                                 flist[i].nslots = 0;
574                                 flist[i].nfiles = 0;
575                                 free(flist[i].fents);
576                                 flist[i].fents = NULL;
577                         }
578                 }
579                 loopcntr++;
580         }
581         return 0;
582 }
583
584 void add_to_flist(int ft, int id, int parent)
585 {
586         fent_t *fep;
587         flist_t *ftp;
588
589         ftp = &flist[ft];
590         if (ftp->nfiles == ftp->nslots) {
591                 ftp->nslots += FLIST_SLOT_INCR;
592                 ftp->fents = realloc(ftp->fents, ftp->nslots * sizeof(fent_t));
593         }
594         fep = &ftp->fents[ftp->nfiles++];
595         fep->id = id;
596         fep->parent = parent;
597 }
598
599 void append_pathname(pathname_t * name, char *str)
600 {
601         int len;
602         char *path;
603
604         len = strlen(str);
605 #ifdef DEBUG
606         if (len && *str == '/' && name->len == 0) {
607                 fprintf(stderr, "fsstress: append_pathname failure\n");
608                 chdir(homedir);
609                 abort();
610
611         }
612 #endif
613         path = realloc(name->path, name->len + 1 + len);
614         if (path == NULL) {
615                 fprintf(stderr, "fsstress: append_pathname realloc failed\n");
616                 chdir(homedir);
617                 abort();
618         }
619         name->path = path;
620         strcpy(&name->path[name->len], str);
621         name->len += len;
622 }
623
624 #ifndef NO_XFS
625 int
626 attr_list_path(pathname_t * name, char *buffer, const int buffersize, int flags,
627                attrlist_cursor_t * cursor)
628 {
629         char buf[MAXNAMELEN];
630         pathname_t newname;
631         int rval;
632
633         rval = attr_list(name->path, buffer, buffersize, flags, cursor);
634         if (rval >= 0 || errno != ENAMETOOLONG)
635                 return rval;
636         separate_pathname(name, buf, &newname);
637         if (chdir(buf) == 0) {
638                 rval = attr_list_path(&newname, buffer, buffersize, flags,
639                                       cursor);
640                 chdir("..");
641         }
642         free_pathname(&newname);
643         return rval;
644 }
645
646 int attr_remove_path(pathname_t * name, const char *attrname, int flags)
647 {
648         char buf[MAXNAMELEN];
649         pathname_t newname;
650         int rval;
651
652         rval = attr_remove(name->path, attrname, flags);
653         if (rval >= 0 || errno != ENAMETOOLONG)
654                 return rval;
655         separate_pathname(name, buf, &newname);
656         if (chdir(buf) == 0) {
657                 rval = attr_remove_path(&newname, attrname, flags);
658                 chdir("..");
659         }
660         free_pathname(&newname);
661         return rval;
662 }
663
664 int
665 attr_set_path(pathname_t * name, const char *attrname, const char *attrvalue,
666               const int valuelength, int flags)
667 {
668         char buf[MAXNAMELEN];
669         pathname_t newname;
670         int rval;
671
672         rval = attr_set(name->path, attrname, attrvalue, valuelength, flags);
673         if (rval >= 0 || errno != ENAMETOOLONG)
674                 return rval;
675         separate_pathname(name, buf, &newname);
676         if (chdir(buf) == 0) {
677                 rval = attr_set_path(&newname, attrname, attrvalue, valuelength,
678                                      flags);
679                 chdir("..");
680         }
681         free_pathname(&newname);
682         return rval;
683 }
684 #endif
685
686 void check_cwd(void)
687 {
688 #ifdef DEBUG
689         struct stat64 statbuf;
690
691         if (stat64(".", &statbuf) == 0 && statbuf.st_ino == top_ino)
692                 return;
693         chdir(homedir);
694         fprintf(stderr, "fsstress: check_cwd failure\n");
695         abort();
696
697 #endif
698 }
699
700 int creat_path(pathname_t * name, mode_t mode)
701 {
702         char buf[MAXNAMELEN];
703         pathname_t newname;
704         int rval;
705
706         rval = creat(name->path, mode);
707         if (rval >= 0 || errno != ENAMETOOLONG)
708                 return rval;
709         separate_pathname(name, buf, &newname);
710         if (chdir(buf) == 0) {
711                 rval = creat_path(&newname, mode);
712                 chdir("..");
713         }
714         free_pathname(&newname);
715         return rval;
716 }
717
718 void dcache_enter(int dirid, int slot)
719 {
720         dcache[dirid % NDCACHE] = slot;
721 }
722
723 void dcache_init(void)
724 {
725         int i;
726
727         for (i = 0; i < NDCACHE; i++)
728                 dcache[i] = -1;
729 }
730
731 fent_t *dcache_lookup(int dirid)
732 {
733         fent_t *fep;
734         int i;
735
736         i = dcache[dirid % NDCACHE];
737         if (i >= 0 && (fep = &flist[FT_DIR].fents[i])->id == dirid)
738                 return fep;
739         return NULL;
740 }
741
742 void dcache_purge(int dirid)
743 {
744         int *dcp;
745
746         dcp = &dcache[dirid % NDCACHE];
747         if (*dcp >= 0 && flist[FT_DIR].fents[*dcp].id == dirid)
748                 *dcp = -1;
749 }
750
751 void del_from_flist(int ft, int slot)
752 {
753         flist_t *ftp;
754
755         ftp = &flist[ft];
756         if (ft == FT_DIR)
757                 dcache_purge(ftp->fents[slot].id);
758         if (slot != ftp->nfiles - 1) {
759                 if (ft == FT_DIR)
760                         dcache_purge(ftp->fents[ftp->nfiles - 1].id);
761                 ftp->fents[slot] = ftp->fents[--ftp->nfiles];
762         } else
763                 ftp->nfiles--;
764 }
765
766 fent_t *dirid_to_fent(int dirid)
767 {
768         fent_t *efep;
769         fent_t *fep;
770         flist_t *flp;
771
772         if ((fep = dcache_lookup(dirid)))
773                 return fep;
774         flp = &flist[FT_DIR];
775         for (fep = flp->fents, efep = &fep[flp->nfiles]; fep < efep; fep++) {
776                 if (fep->id == dirid) {
777                         dcache_enter(dirid, fep - flp->fents);
778                         return fep;
779                 }
780         }
781         return NULL;
782 }
783
784 void doproc(void)
785 {
786         struct stat64 statbuf;
787         char buf[10];
788         int opno;
789         int rval;
790         opdesc_t *p;
791
792         sprintf(buf, "p%x", procid);
793         (void)mkdir(buf, 0777);
794         if (chdir(buf) < 0 || stat64(".", &statbuf) < 0) {
795                 perror(buf);
796                 _exit(1);
797         }
798         top_ino = statbuf.st_ino;
799         homedir = getcwd(NULL, -1);
800         seed += procid;
801         srandom(seed);
802         if (namerand)
803                 namerand = random();
804         for (opno = 0; opno < operations; opno++) {
805                 p = &ops[freq_table[random() % freq_table_size]];
806                 if ((unsigned long)p->func < 4096)
807                         abort();
808
809                 p->func(opno, random());
810                 /*
811                  * test for forced shutdown by stat'ing the test
812                  * directory.  If this stat returns EIO, assume
813                  * the forced shutdown happened.
814                  */
815                 if (errtag != 0 && opno % 100 == 0) {
816                         rval = stat64(".", &statbuf);
817                         if (rval == EIO) {
818                                 fprintf(stderr, "Detected EIO\n");
819                                 return;
820                         }
821                 }
822         }
823 }
824
825 void fent_to_name(pathname_t * name, flist_t * flp, fent_t * fep)
826 {
827         char buf[MAXNAMELEN];
828         int i;
829         fent_t *pfep;
830
831         if (fep == NULL)
832                 return;
833         if (fep->parent != -1) {
834                 pfep = dirid_to_fent(fep->parent);
835                 fent_to_name(name, &flist[FT_DIR], pfep);
836                 append_pathname(name, "/");
837         }
838         i = sprintf(buf, "%c%x", flp->tag, fep->id);
839         namerandpad(fep->id, buf, i);
840         append_pathname(name, buf);
841 }
842
843 void fix_parent(int oldid, int newid)
844 {
845         fent_t *fep;
846         flist_t *flp;
847         int i;
848         int j;
849
850         for (i = 0, flp = flist; i < FT_nft; i++, flp++) {
851                 for (j = 0, fep = flp->fents; j < flp->nfiles; j++, fep++) {
852                         if (fep->parent == oldid)
853                                 fep->parent = newid;
854                 }
855         }
856 }
857
858 void free_pathname(pathname_t * name)
859 {
860         if (name->path) {
861                 free(name->path);
862                 name->path = NULL;
863                 name->len = 0;
864         }
865 }
866
867 int generate_fname(fent_t * fep, int ft, pathname_t * name, int *idp, int *v)
868 {
869         char buf[MAXNAMELEN];
870         flist_t *flp;
871         int id;
872         int j;
873         int len;
874
875         flp = &flist[ft];
876         len = sprintf(buf, "%c%x", flp->tag, id = nameseq++);
877         namerandpad(id, buf, len);
878         if (fep) {
879                 fent_to_name(name, &flist[FT_DIR], fep);
880                 append_pathname(name, "/");
881         }
882         append_pathname(name, buf);
883         *idp = id;
884         *v = verbose;
885         for (j = 0; !*v && j < ilistlen; j++) {
886                 if (ilist[j] == id) {
887                         *v = 1;
888                         break;
889                 }
890         }
891         return 1;
892 }
893
894 int
895 get_fname(int which, long r, pathname_t * name, flist_t ** flpp, fent_t ** fepp,
896           int *v)
897 {
898         int c;
899         fent_t *fep;
900         flist_t *flp;
901         int i;
902         int j;
903         int x;
904
905         for (i = 0, c = 0, flp = flist; i < FT_nft; i++, flp++) {
906                 if (which & (1 << i))
907                         c += flp->nfiles;
908         }
909         if (c == 0) {
910                 if (flpp)
911                         *flpp = NULL;
912                 if (fepp)
913                         *fepp = NULL;
914                 *v = verbose;
915                 return 0;
916         }
917         x = (int)(r % c);
918         for (i = 0, c = 0, flp = flist; i < FT_nft; i++, flp++) {
919                 if (which & (1 << i)) {
920                         if (x < c + flp->nfiles) {
921                                 fep = &flp->fents[x - c];
922                                 if (name)
923                                         fent_to_name(name, flp, fep);
924                                 if (flpp)
925                                         *flpp = flp;
926                                 if (fepp)
927                                         *fepp = fep;
928                                 *v = verbose;
929                                 for (j = 0; !*v && j < ilistlen; j++) {
930                                         if (ilist[j] == fep->id) {
931                                                 *v = 1;
932                                                 break;
933                                         }
934                                 }
935                                 return 1;
936                         }
937                         c += flp->nfiles;
938                 }
939         }
940 #ifdef DEBUG
941         fprintf(stderr, "fsstress: get_fname failure\n");
942         abort();
943 #endif
944         return -1;
945
946 }
947
948 void init_pathname(pathname_t * name)
949 {
950         name->len = 0;
951         name->path = NULL;
952 }
953
954 int lchown_path(pathname_t * name, uid_t owner, gid_t group)
955 {
956         char buf[MAXNAMELEN];
957         pathname_t newname;
958         int rval;
959
960         rval = lchown(name->path, owner, group);
961         if (rval >= 0 || errno != ENAMETOOLONG)
962                 return rval;
963         separate_pathname(name, buf, &newname);
964         if (chdir(buf) == 0) {
965                 rval = lchown_path(&newname, owner, group);
966                 chdir("..");
967         }
968         free_pathname(&newname);
969         return rval;
970 }
971
972 int link_path(pathname_t * name1, pathname_t * name2)
973 {
974         char buf1[MAXNAMELEN];
975         char buf2[MAXNAMELEN];
976         int down1;
977         pathname_t newname1;
978         pathname_t newname2;
979         int rval;
980
981         rval = link(name1->path, name2->path);
982         if (rval >= 0 || errno != ENAMETOOLONG)
983                 return rval;
984         separate_pathname(name1, buf1, &newname1);
985         separate_pathname(name2, buf2, &newname2);
986         if (strcmp(buf1, buf2) == 0) {
987                 if (chdir(buf1) == 0) {
988                         rval = link_path(&newname1, &newname2);
989                         chdir("..");
990                 }
991         } else {
992                 if (strcmp(buf1, "..") == 0)
993                         down1 = 0;
994                 else if (strcmp(buf2, "..") == 0)
995                         down1 = 1;
996                 else if (strlen(buf1) == 0)
997                         down1 = 0;
998                 else if (strlen(buf2) == 0)
999                         down1 = 1;
1000                 else
1001                         down1 = MAX(newname1.len, 3 + name2->len) <=
1002                             MAX(3 + name1->len, newname2.len);
1003                 if (down1) {
1004                         free_pathname(&newname2);
1005                         append_pathname(&newname2, "../");
1006                         append_pathname(&newname2, name2->path);
1007                         if (chdir(buf1) == 0) {
1008                                 rval = link_path(&newname1, &newname2);
1009                                 chdir("..");
1010                         }
1011                 } else {
1012                         free_pathname(&newname1);
1013                         append_pathname(&newname1, "../");
1014                         append_pathname(&newname1, name1->path);
1015                         if (chdir(buf2) == 0) {
1016                                 rval = link_path(&newname1, &newname2);
1017                                 chdir("..");
1018                         }
1019                 }
1020         }
1021         free_pathname(&newname1);
1022         free_pathname(&newname2);
1023         return rval;
1024 }
1025
1026 int lstat64_path(pathname_t * name, struct stat64 *sbuf)
1027 {
1028         char buf[MAXNAMELEN];
1029         pathname_t newname;
1030         int rval;
1031
1032         rval = lstat64(name->path, sbuf);
1033         if (rval >= 0 || errno != ENAMETOOLONG)
1034                 return rval;
1035         separate_pathname(name, buf, &newname);
1036         if (chdir(buf) == 0) {
1037                 rval = lstat64_path(&newname, sbuf);
1038                 chdir("..");
1039         }
1040         free_pathname(&newname);
1041         return rval;
1042 }
1043
1044 void make_freq_table(void)
1045 {
1046         int f;
1047         int i;
1048         opdesc_t *p;
1049
1050         for (p = ops, f = 0; p < ops_end; p++)
1051                 f += p->freq;
1052         freq_table = malloc(f * sizeof(*freq_table));
1053         freq_table_size = f;
1054         for (p = ops, i = 0; p < ops_end; p++) {
1055                 for (f = 0; f < p->freq; f++, i++)
1056                         freq_table[i] = p->op;
1057         }
1058 }
1059
1060 int mkdir_path(pathname_t * name, mode_t mode)
1061 {
1062         char buf[MAXNAMELEN];
1063         pathname_t newname;
1064         int rval;
1065
1066         rval = mkdir(name->path, mode);
1067         if (rval >= 0 || errno != ENAMETOOLONG)
1068                 return rval;
1069         separate_pathname(name, buf, &newname);
1070         if (chdir(buf) == 0) {
1071                 rval = mkdir_path(&newname, mode);
1072                 chdir("..");
1073         }
1074         free_pathname(&newname);
1075         return rval;
1076 }
1077
1078 int mknod_path(pathname_t * name, mode_t mode, dev_t dev)
1079 {
1080         char buf[MAXNAMELEN];
1081         pathname_t newname;
1082         int rval;
1083
1084         rval = mknod(name->path, mode, dev);
1085         if (rval >= 0 || errno != ENAMETOOLONG)
1086                 return rval;
1087         separate_pathname(name, buf, &newname);
1088         if (chdir(buf) == 0) {
1089                 rval = mknod_path(&newname, mode, dev);
1090                 chdir("..");
1091         }
1092         free_pathname(&newname);
1093         return rval;
1094 }
1095
1096 void namerandpad(int id, char *buf, int i)
1097 {
1098         int bucket;
1099         static int buckets[] = { 2, 4, 8, 16, 32, 64, 128, MAXNAMELEN - 1 };
1100         int padlen;
1101         int padmod;
1102
1103         if (namerand == 0)
1104                 return;
1105         bucket = (id ^ namerand) % (sizeof(buckets) / sizeof(buckets[0]));
1106         padmod = buckets[bucket] + 1 - i;
1107         if (padmod <= 0)
1108                 return;
1109         padlen = (id ^ namerand) % padmod;
1110         if (padlen) {
1111                 memset(&buf[i], 'X', padlen);
1112                 buf[i + padlen] = '\0';
1113         }
1114 }
1115
1116 int open_path(pathname_t * name, int oflag)
1117 {
1118         char buf[MAXNAMELEN];
1119         pathname_t newname;
1120         int rval;
1121
1122         rval = open(name->path, oflag);
1123         if (rval >= 0 || errno != ENAMETOOLONG)
1124                 return rval;
1125         separate_pathname(name, buf, &newname);
1126         if (chdir(buf) == 0) {
1127                 rval = open_path(&newname, oflag);
1128                 chdir("..");
1129         }
1130         free_pathname(&newname);
1131         return rval;
1132 }
1133
1134 DIR *opendir_path(pathname_t * name)
1135 {
1136         char buf[MAXNAMELEN];
1137         pathname_t newname;
1138         DIR *rval;
1139
1140         rval = opendir(name->path);
1141         if (rval || errno != ENAMETOOLONG)
1142                 return rval;
1143         separate_pathname(name, buf, &newname);
1144         if (chdir(buf) == 0) {
1145                 rval = opendir_path(&newname);
1146                 chdir("..");
1147         }
1148         free_pathname(&newname);
1149         return rval;
1150 }
1151
1152 void process_freq(char *arg)
1153 {
1154         opdesc_t *p;
1155         char *s;
1156
1157         s = strchr(arg, '=');
1158         if (s == NULL) {
1159                 fprintf(stderr, "bad argument '%s'\n", arg);
1160                 exit(1);
1161         }
1162         *s++ = '\0';
1163         for (p = ops; p < ops_end; p++) {
1164                 if (strcmp(arg, p->name) == 0) {
1165                         p->freq = atoi(s);
1166                         return;
1167                 }
1168         }
1169         fprintf(stderr, "can't find op type %s for -f\n", arg);
1170         exit(1);
1171 }
1172
1173 int readlink_path(pathname_t * name, char *lbuf, size_t lbufsiz)
1174 {
1175         char buf[MAXNAMELEN];
1176         pathname_t newname;
1177         int rval;
1178
1179         rval = readlink(name->path, lbuf, lbufsiz);
1180         if (rval >= 0 || errno != ENAMETOOLONG)
1181                 return rval;
1182         separate_pathname(name, buf, &newname);
1183         if (chdir(buf) == 0) {
1184                 rval = readlink_path(&newname, lbuf, lbufsiz);
1185                 chdir("..");
1186         }
1187         free_pathname(&newname);
1188         return rval;
1189 }
1190
1191 int rename_path(pathname_t * name1, pathname_t * name2)
1192 {
1193         char buf1[MAXNAMELEN];
1194         char buf2[MAXNAMELEN];
1195         int down1;
1196         pathname_t newname1;
1197         pathname_t newname2;
1198         int rval;
1199
1200         rval = rename(name1->path, name2->path);
1201         if (rval >= 0 || errno != ENAMETOOLONG)
1202                 return rval;
1203         separate_pathname(name1, buf1, &newname1);
1204         separate_pathname(name2, buf2, &newname2);
1205         if (strcmp(buf1, buf2) == 0) {
1206                 if (chdir(buf1) == 0) {
1207                         rval = rename_path(&newname1, &newname2);
1208                         chdir("..");
1209                 }
1210         } else {
1211                 if (strcmp(buf1, "..") == 0)
1212                         down1 = 0;
1213                 else if (strcmp(buf2, "..") == 0)
1214                         down1 = 1;
1215                 else if (strlen(buf1) == 0)
1216                         down1 = 0;
1217                 else if (strlen(buf2) == 0)
1218                         down1 = 1;
1219                 else
1220                         down1 = MAX(newname1.len, 3 + name2->len) <=
1221                             MAX(3 + name1->len, newname2.len);
1222                 if (down1) {
1223                         free_pathname(&newname2);
1224                         append_pathname(&newname2, "../");
1225                         append_pathname(&newname2, name2->path);
1226                         if (chdir(buf1) == 0) {
1227                                 rval = rename_path(&newname1, &newname2);
1228                                 chdir("..");
1229                         }
1230                 } else {
1231                         free_pathname(&newname1);
1232                         append_pathname(&newname1, "../");
1233                         append_pathname(&newname1, name1->path);
1234                         if (chdir(buf2) == 0) {
1235                                 rval = rename_path(&newname1, &newname2);
1236                                 chdir("..");
1237                         }
1238                 }
1239         }
1240         free_pathname(&newname1);
1241         free_pathname(&newname2);
1242         return rval;
1243 }
1244
1245 int rmdir_path(pathname_t * name)
1246 {
1247         char buf[MAXNAMELEN];
1248         pathname_t newname;
1249         int rval;
1250
1251         rval = rmdir(name->path);
1252         if (rval >= 0 || errno != ENAMETOOLONG)
1253                 return rval;
1254         separate_pathname(name, buf, &newname);
1255         if (chdir(buf) == 0) {
1256                 rval = rmdir_path(&newname);
1257                 chdir("..");
1258         }
1259         free_pathname(&newname);
1260         return rval;
1261 }
1262
1263 void separate_pathname(pathname_t * name, char *buf, pathname_t * newname)
1264 {
1265         char *slash;
1266
1267         init_pathname(newname);
1268         slash = strchr(name->path, '/');
1269         if (slash == NULL) {
1270                 buf[0] = '\0';
1271                 return;
1272         }
1273         *slash = '\0';
1274         strcpy(buf, name->path);
1275         *slash = '/';
1276         append_pathname(newname, slash + 1);
1277 }
1278
1279 #define WIDTH 80
1280
1281 void show_ops(int flag, char *lead_str)
1282 {
1283         opdesc_t *p;
1284
1285         if (flag < 0) {
1286                 /* print in list form */
1287                 int x = WIDTH;
1288
1289                 for (p = ops; p < ops_end; p++) {
1290                         if (lead_str != NULL
1291                             && x + strlen(p->name) >= WIDTH - 5)
1292                                 x = printf("%s%s", (p == ops) ? "" : "\n",
1293                                            lead_str);
1294                         x += printf("%s ", p->name);
1295                 }
1296                 printf("\n");
1297         } else {
1298                 int f;
1299                 for (f = 0, p = ops; p < ops_end; p++)
1300                         f += p->freq;
1301
1302                 if (f == 0)
1303                         flag = 1;
1304
1305                 for (p = ops; p < ops_end; p++) {
1306                         if (flag != 0 || p->freq > 0) {
1307                                 if (lead_str != NULL)
1308                                         printf("%s", lead_str);
1309                                 printf("%20s %d/%d %s\n",
1310                                        p->name, p->freq, f,
1311                                        (p->iswrite == 0) ? " " : "write op");
1312                         }
1313                 }
1314         }
1315 }
1316
1317 int stat64_path(pathname_t * name, struct stat64 *sbuf)
1318 {
1319         char buf[MAXNAMELEN];
1320         pathname_t newname;
1321         int rval;
1322
1323         rval = stat64(name->path, sbuf);
1324         if (rval >= 0 || errno != ENAMETOOLONG)
1325                 return rval;
1326         separate_pathname(name, buf, &newname);
1327         if (chdir(buf) == 0) {
1328                 rval = stat64_path(&newname, sbuf);
1329                 chdir("..");
1330         }
1331         free_pathname(&newname);
1332         return rval;
1333 }
1334
1335 int symlink_path(const char *name1, pathname_t * name)
1336 {
1337         char buf[MAXNAMELEN];
1338         pathname_t newname;
1339         int rval;
1340
1341         if (!strcmp(name1, name->path)) {
1342                 printf("yikes! %s %s\n", name1, name->path);
1343                 return 0;
1344         }
1345
1346         rval = symlink(name1, name->path);
1347         if (rval >= 0 || errno != ENAMETOOLONG)
1348                 return rval;
1349         separate_pathname(name, buf, &newname);
1350         if (chdir(buf) == 0) {
1351                 rval = symlink_path(name1, &newname);
1352                 chdir("..");
1353         }
1354         free_pathname(&newname);
1355         return rval;
1356 }
1357
1358 int truncate64_path(pathname_t * name, off64_t length)
1359 {
1360         char buf[MAXNAMELEN];
1361         pathname_t newname;
1362         int rval;
1363
1364         rval = truncate64(name->path, length);
1365         if (rval >= 0 || errno != ENAMETOOLONG)
1366                 return rval;
1367         separate_pathname(name, buf, &newname);
1368         if (chdir(buf) == 0) {
1369                 rval = truncate64_path(&newname, length);
1370                 chdir("..");
1371         }
1372         free_pathname(&newname);
1373         return rval;
1374 }
1375
1376 int unlink_path(pathname_t * name)
1377 {
1378         char buf[MAXNAMELEN];
1379         pathname_t newname;
1380         int rval;
1381
1382         rval = unlink(name->path);
1383         if (rval >= 0 || errno != ENAMETOOLONG)
1384                 return rval;
1385         separate_pathname(name, buf, &newname);
1386         if (chdir(buf) == 0) {
1387                 rval = unlink_path(&newname);
1388                 chdir("..");
1389         }
1390         free_pathname(&newname);
1391         return rval;
1392 }
1393
1394 void usage(void)
1395 {
1396         printf("Usage: %s -H   or\n", myprog);
1397         printf
1398             ("       %s [-c][-d dir][-e errtg][-f op_name=freq][-l loops][-n nops]\n",
1399              myprog);
1400         printf("          [-p nproc][-r len][-s seed][-v][-w][-z][-S]\n");
1401         printf("where\n");
1402         printf
1403             ("   -c               specifies not to remove files(cleanup) after execution\n");
1404         printf
1405             ("   -d dir           specifies the base directory for operations\n");
1406         printf("   -e errtg         specifies error injection stuff\n");
1407         printf
1408             ("   -f op_name=freq  changes the frequency of option name to freq\n");
1409         printf("                    the valid operation names are:\n");
1410         show_ops(-1, "                        ");
1411         printf
1412             ("   -l loops         specifies the no. of times the testrun should loop.\n");
1413         printf("                     *use 0 for infinite (default 1)\n");
1414         printf
1415             ("   -n nops          specifies the no. of operations per process (default 1)\n");
1416         printf
1417             ("   -p nproc         specifies the no. of processes (default 1)\n");
1418         printf("   -r               specifies random name padding\n");
1419         printf
1420             ("   -s seed          specifies the seed for the random generator (default random)\n");
1421         printf("   -v               specifies verbose mode\n");
1422         printf
1423             ("   -w               zeros frequencies of non-write operations\n");
1424         printf("   -z               zeros frequencies of all operations\n");
1425         printf
1426             ("   -S               prints the table of operations (omitting zero frequency)\n");
1427         printf("   -H               prints usage and exits\n");
1428         printf
1429             ("   -X               don't do anything XFS specific (default with -DNO_XFS)\n");
1430 }
1431
1432 void write_freq(void)
1433 {
1434         opdesc_t *p;
1435
1436         for (p = ops; p < ops_end; p++) {
1437                 if (!p->iswrite)
1438                         p->freq = 0;
1439         }
1440 }
1441
1442 void zero_freq(void)
1443 {
1444         opdesc_t *p;
1445
1446         for (p = ops; p < ops_end; p++)
1447                 p->freq = 0;
1448 }
1449
1450 #ifndef NO_XFS
1451
1452 void allocsp_f(int opno, long r)
1453 {
1454         int e;
1455         pathname_t f;
1456         int fd;
1457         struct xfs_flock64 fl;
1458         __s64 lr;
1459         __s64 off;
1460         struct stat64 stb;
1461         int v;
1462
1463         init_pathname(&f);
1464         if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
1465                 if (v)
1466                         printf("%d/%d: allocsp - no filename\n", procid, opno);
1467                 free_pathname(&f);
1468                 return;
1469         }
1470         fd = open_path(&f, O_RDWR);
1471         e = fd < 0 ? errno : 0;
1472         check_cwd();
1473         if (fd < 0) {
1474                 if (v)
1475                         printf("%d/%d: allocsp - open %s failed %d\n",
1476                                procid, opno, f.path, e);
1477                 free_pathname(&f);
1478                 return;
1479         }
1480         if (fstat64(fd, &stb) < 0) {
1481                 if (v)
1482                         printf("%d/%d: allocsp - fstat64 %s failed %d\n",
1483                                procid, opno, f.path, errno);
1484                 free_pathname(&f);
1485                 close(fd);
1486                 return;
1487         }
1488         lr = ((__s64) random() << 32) + random();
1489         off = lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE);
1490         off %= maxfsize;
1491         memset(&fl, 0, sizeof(fl));
1492         fl.l_whence = SEEK_SET;
1493         fl.l_start = off;
1494         fl.l_len = 0;
1495         e = ioctl(fd, XFS_IOC_ALLOCSP64, &fl) < 0 ? errno : 0;
1496         if (v)
1497                 printf("%d/%d: ioctl(XFS_IOC_ALLOCSP64) %s %lld 0 %d\n",
1498                        procid, opno, f.path, (long long)off, e);
1499         free_pathname(&f);
1500         close(fd);
1501 }
1502
1503 void attr_remove_f(int opno, long r)
1504 {
1505         attrlist_ent_t *aep;
1506         attrlist_t *alist;
1507         char *aname;
1508         char buf[4096];
1509         attrlist_cursor_t cursor;
1510         int e;
1511         int ent;
1512         pathname_t f;
1513         int total;
1514         int v;
1515         int which;
1516
1517         init_pathname(&f);
1518         if (!get_fname(FT_ANYm, r, &f, NULL, NULL, &v))
1519                 append_pathname(&f, ".");
1520         total = 0;
1521         memset(&cursor, 0x00, sizeof(cursor));
1522         do {
1523                 e = attr_list_path(&f, buf, sizeof(buf), ATTR_DONTFOLLOW,
1524                                    &cursor);
1525                 check_cwd();
1526                 if (e)
1527                         break;
1528                 alist = (attrlist_t *) buf;
1529                 total += alist->al_count;
1530         } while (alist->al_more);
1531         if (total == 0) {
1532                 if (v)
1533                         printf("%d/%d: attr_remove - no attrs for %s\n",
1534                                procid, opno, f.path);
1535                 free_pathname(&f);
1536                 return;
1537         }
1538         which = (int)(random() % total);
1539         memset(&cursor, 0x00, sizeof(cursor));
1540         ent = 0;
1541         aname = NULL;
1542         do {
1543                 e = attr_list_path(&f, buf, sizeof(buf), ATTR_DONTFOLLOW,
1544                                    &cursor);
1545                 check_cwd();
1546                 if (e)
1547                         break;
1548                 alist = (attrlist_t *) buf;
1549                 if (which < ent + alist->al_count) {
1550                         aep = (attrlist_ent_t *)
1551                             & buf[alist->al_offset[which - ent]];
1552                         aname = aep->a_name;
1553                         break;
1554                 }
1555                 ent += alist->al_count;
1556         } while (alist->al_more);
1557         if (aname == NULL) {
1558                 if (v)
1559                         printf("%d/%d: attr_remove - name %d not found at %s\n",
1560                                procid, opno, which, f.path);
1561                 free_pathname(&f);
1562                 return;
1563         }
1564         e = attr_remove_path(&f, aname, ATTR_DONTFOLLOW) < 0 ? errno : 0;
1565         check_cwd();
1566         if (v)
1567                 printf("%d/%d: attr_remove %s %s %d\n",
1568                        procid, opno, f.path, aname, e);
1569         free_pathname(&f);
1570 }
1571
1572 void attr_set_f(int opno, long r)
1573 {
1574         char aname[10];
1575         char *aval;
1576         int e;
1577         pathname_t f;
1578         int len;
1579         static int lengths[] = { 10, 100, 1000, 10000 };
1580         int li;
1581         int v;
1582
1583         init_pathname(&f);
1584         if (!get_fname(FT_ANYm, r, &f, NULL, NULL, &v))
1585                 append_pathname(&f, ".");
1586         sprintf(aname, "a%x", nameseq++);
1587         li = (int)(random() % (sizeof(lengths) / sizeof(lengths[0])));
1588         len = (int)(random() % lengths[li]);
1589         if (len == 0)
1590                 len = 1;
1591         aval = malloc(len);
1592         memset(aval, nameseq & 0xff, len);
1593         e = attr_set_path(&f, aname, aval, len, ATTR_DONTFOLLOW) < 0 ?
1594             errno : 0;
1595         check_cwd();
1596         free(aval);
1597         if (v)
1598                 printf("%d/%d: attr_set %s %s %d\n", procid, opno, f.path,
1599                        aname, e);
1600         free_pathname(&f);
1601 }
1602
1603 void bulkstat_f(int opno, long r)
1604 {
1605         __s32 count;
1606         int fd;
1607         __u64 last;
1608         __s32 nent;
1609         xfs_bstat_t *t;
1610         __int64_t total;
1611         xfs_fsop_bulkreq_t bsr;
1612
1613         last = 0;
1614         nent = (r % 999) + 2;
1615         t = malloc(nent * sizeof(*t));
1616         fd = open(".", O_RDONLY);
1617         total = 0;
1618
1619         memset(&bsr, 0, sizeof(bsr));
1620         bsr.lastip = &last;
1621         bsr.icount = nent;
1622         bsr.ubuffer = t;
1623         bsr.ocount = &count;
1624
1625         while (ioctl(fd, XFS_IOC_FSBULKSTAT, &bsr) == 0 && count > 0)
1626                 total += count;
1627         free(t);
1628         if (verbose)
1629                 printf("%d/%d: bulkstat nent %d total %lld\n",
1630                        procid, opno, (int)nent, (long long)total);
1631         close(fd);
1632 }
1633
1634 void bulkstat1_f(int opno, long r)
1635 {
1636         int e;
1637         pathname_t f;
1638         int fd;
1639         int good;
1640         __u64 ino;
1641         struct stat64 s;
1642         xfs_bstat_t t;
1643         int v;
1644         xfs_fsop_bulkreq_t bsr;
1645
1646         good = random() & 1;
1647         if (good) {
1648                 /* use an inode we know exists */
1649                 init_pathname(&f);
1650                 if (!get_fname(FT_ANYm, r, &f, NULL, NULL, &v))
1651                         append_pathname(&f, ".");
1652                 ino = stat64_path(&f, &s) < 0 ? (ino64_t) r : s.st_ino;
1653                 check_cwd();
1654                 free_pathname(&f);
1655         } else {
1656                 /*
1657                  * pick a random inode
1658                  *
1659                  * note this can generate kernel warning messages
1660                  * since bulkstat_one will read the disk block that
1661                  * would contain a given inode even if that disk
1662                  * block doesn't contain inodes.
1663                  *
1664                  * this is detected later, but not until after the
1665                  * warning is displayed.
1666                  *
1667                  * "XFS: device 0x825- bad inode magic/vsn daddr 0x0 #0"
1668                  *
1669                  */
1670                 ino = (ino64_t) r;
1671                 v = verbose;
1672         }
1673         fd = open(".", O_RDONLY);
1674
1675         memset(&bsr, 0, sizeof(bsr));
1676         bsr.lastip = &ino;
1677         bsr.icount = 1;
1678         bsr.ubuffer = &t;
1679         bsr.ocount = NULL;
1680
1681         e = ioctl(fd, XFS_IOC_FSBULKSTAT_SINGLE, &bsr) < 0 ? errno : 0;
1682         if (v)
1683                 printf("%d/%d: bulkstat1 %s ino %lld %d\n",
1684                        procid, opno, good ? "real" : "random",
1685                        (long long)ino, e);
1686         close(fd);
1687 }
1688
1689 #endif
1690
1691 void chown_f(int opno, long r)
1692 {
1693         int e;
1694         pathname_t f;
1695         int nbits;
1696         uid_t u;
1697         int v;
1698
1699         init_pathname(&f);
1700         if (!get_fname(FT_ANYm, r, &f, NULL, NULL, &v))
1701                 append_pathname(&f, ".");
1702         u = (uid_t) random();
1703         nbits = (int)(random() % 32);
1704         u &= (1 << nbits) - 1;
1705         e = lchown_path(&f, u, -1) < 0 ? errno : 0;
1706         check_cwd();
1707         if (v)
1708                 printf("%d/%d: chown %s %d %d\n", procid, opno, f.path, u, e);
1709         free_pathname(&f);
1710 }
1711
1712 void creat_f(int opno, long r)
1713 {
1714         int e;
1715         int e1;
1716         int extsize;
1717         pathname_t f;
1718         int fd;
1719         fent_t *fep;
1720         int id;
1721         int parid;
1722         int type;
1723         int v;
1724         int v1;
1725         int esz = 0;
1726
1727         if (!get_fname(FT_DIRm, r, NULL, NULL, &fep, &v1))
1728                 parid = -1;
1729         else
1730                 parid = fep->id;
1731         init_pathname(&f);
1732         type = rtpct ? ((random() % 100) > rtpct ? FT_REG : FT_RTF) : FT_REG;
1733         if (type == FT_RTF)
1734                 extsize = (random() % 10) + 1;
1735         else
1736                 extsize = 0;
1737         e = generate_fname(fep, type, &f, &id, &v);
1738         v |= v1;
1739         if (!e) {
1740                 if (v) {
1741                         fent_to_name(&f, &flist[FT_DIR], fep);
1742                         printf("%d/%d: creat - no filename from %s\n",
1743                                procid, opno, f.path);
1744                 }
1745                 free_pathname(&f);
1746                 return;
1747         }
1748         fd = creat_path(&f, 0666);
1749         e = fd < 0 ? errno : 0;
1750         e1 = 0;
1751         check_cwd();
1752         esz = 0;
1753         if (fd >= 0) {
1754 #ifndef NO_XFS
1755                 struct fsxattr a;
1756                 memset(&a, 0, sizeof(a));
1757                 if (extsize && ioctl(fd, XFS_IOC_FSGETXATTR, &a) >= 0) {
1758                         a.fsx_xflags |= XFS_XFLAG_REALTIME;
1759                         a.fsx_extsize =
1760                             geom.rtextsize * geom.blocksize * extsize;
1761                         if (ioctl(fd, XFS_IOC_FSSETXATTR, &a) < 0)
1762                                 e1 = errno;
1763                         esz = a.fsx_extsize;
1764
1765                 }
1766 #endif
1767                 add_to_flist(type, id, parid);
1768                 close(fd);
1769         }
1770         if (v)
1771                 printf("%d/%d: creat %s x:%d %d %d\n", procid, opno, f.path,
1772                        esz, e, e1);
1773         free_pathname(&f);
1774 }
1775
1776 int setdirect(int fd)
1777 {
1778         static int no_direct;
1779         int flags;
1780
1781         if (no_direct)
1782                 return 0;
1783
1784         flags = fcntl(fd, F_GETFL, 0);
1785         if (flags < 0)
1786                 return 0;
1787
1788         if (fcntl(fd, F_SETFL, flags | O_DIRECT) < 0) {
1789                 if (no_xfs) {
1790                         no_direct = 1;
1791                         return 0;
1792                 }
1793                 printf("cannot set O_DIRECT: %s\n", strerror(errno));
1794                 return 0;
1795         }
1796
1797         return 1;
1798 }
1799
1800 void dread_f(int opno, long r)
1801 {
1802         __int64_t align;
1803         char *buf = NULL;
1804         struct dioattr diob;
1805         int e;
1806         pathname_t f;
1807         int fd;
1808         size_t len;
1809         __int64_t lr;
1810         off64_t off;
1811         struct stat64 stb;
1812         int v;
1813
1814         init_pathname(&f);
1815         if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
1816                 if (v)
1817                         printf("%d/%d: dread - no filename\n", procid, opno);
1818                 free_pathname(&f);
1819                 return;
1820         }
1821         fd = open_path(&f, O_RDONLY);
1822
1823         e = fd < 0 ? errno : 0;
1824         check_cwd();
1825         if (fd < 0) {
1826                 if (v)
1827                         printf("%d/%d: dread - open %s failed %d\n",
1828                                procid, opno, f.path, e);
1829                 free_pathname(&f);
1830                 return;
1831         }
1832
1833         if (!setdirect(fd)) {
1834                 close(fd);
1835                 free_pathname(&f);
1836                 return;
1837         }
1838
1839         if (fstat64(fd, &stb) < 0) {
1840                 if (v)
1841                         printf("%d/%d: dread - fstat64 %s failed %d\n",
1842                                procid, opno, f.path, errno);
1843                 free_pathname(&f);
1844                 close(fd);
1845                 return;
1846         }
1847         if (stb.st_size == 0) {
1848                 if (v)
1849                         printf("%d/%d: dread - %s zero size\n", procid, opno,
1850                                f.path);
1851                 free_pathname(&f);
1852                 close(fd);
1853                 return;
1854         }
1855
1856         memset(&diob, 0, sizeof(diob));
1857         if (no_xfs) {
1858                 diob.d_miniosz = stb.st_blksize;
1859                 diob.d_maxiosz = stb.st_blksize * 256;  /* good number ? */
1860                 diob.d_mem = stb.st_blksize;
1861         }
1862 #ifndef NO_XFS
1863         else if (ioctl(fd, XFS_IOC_DIOINFO, &diob) < 0) {
1864                 if (v)
1865                         printf
1866                             ("%d/%d: dread - ioctl(fd, XFS_IOC_DIOINFO) %s failed %d\n",
1867                              procid, opno, f.path, errno);
1868                 free_pathname(&f);
1869                 close(fd);
1870                 return;
1871         }
1872 #endif
1873         align = (__int64_t) diob.d_miniosz;
1874         lr = ((__int64_t) random() << 32) + random();
1875         off = (off64_t) (lr % stb.st_size);
1876         off -= (off % align);
1877         lseek64(fd, off, SEEK_SET);
1878         len = (random() % (getpagesize() * 32)) + 1;
1879         len -= (len % align);
1880         if (len <= 0)
1881                 len = align;
1882         else if (len > diob.d_maxiosz)
1883                 len = diob.d_maxiosz;
1884         if ((e = posix_memalign((void **)&buf, diob.d_mem, len)) != 0) {
1885                 fprintf(stderr, "posix_memalign: %s\n", strerror(e));
1886                 exit(1);
1887         }
1888         if (buf == NULL) {
1889                 fprintf(stderr, "posix_memalign: buf is NULL\n");
1890                 exit(1);
1891         }
1892         e = read(fd, buf, len) < 0 ? errno : 0;
1893         free(buf);
1894         if (v)
1895                 printf("%d/%d: dread %s [%lld,%ld] %d\n",
1896                        procid, opno, f.path, (long long int)off, (long)len, e);
1897         free_pathname(&f);
1898         close(fd);
1899 }
1900
1901 void dwrite_f(int opno, long r)
1902 {
1903         __int64_t align;
1904         char *buf = NULL;
1905         struct dioattr diob;
1906         int e;
1907         pathname_t f;
1908         int fd;
1909         size_t len;
1910         __int64_t lr;
1911         off64_t off;
1912         struct stat64 stb;
1913         int v;
1914
1915         init_pathname(&f);
1916         if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
1917                 if (v)
1918                         printf("%d/%d: dwrite - no filename\n", procid, opno);
1919                 free_pathname(&f);
1920                 return;
1921         }
1922         fd = open_path(&f, O_WRONLY);
1923         e = fd < 0 ? errno : 0;
1924         check_cwd();
1925         if (fd < 0) {
1926                 if (v)
1927                         printf("%d/%d: dwrite - open %s failed %d\n",
1928                                procid, opno, f.path, e);
1929                 free_pathname(&f);
1930                 return;
1931         }
1932
1933         if (!setdirect(fd)) {
1934                 close(fd);
1935                 free_pathname(&f);
1936                 return;
1937         }
1938         if (fstat64(fd, &stb) < 0) {
1939                 if (v)
1940                         printf("%d/%d: dwrite - fstat64 %s failed %d\n",
1941                                procid, opno, f.path, errno);
1942                 free_pathname(&f);
1943                 close(fd);
1944                 return;
1945         }
1946         memset(&diob, 0, sizeof(diob));
1947         if (no_xfs) {
1948                 diob.d_miniosz = stb.st_blksize;
1949                 diob.d_maxiosz = stb.st_blksize * 256;  /* good number ? */
1950                 diob.d_mem = stb.st_blksize;
1951         }
1952 #ifndef NO_XFS
1953         else if (ioctl(fd, XFS_IOC_DIOINFO, &diob) < 0) {
1954                 if (v)
1955                         printf
1956                             ("%d/%d: dwrite - ioctl(fd, XFS_IOC_DIOINFO) %s failed %d\n",
1957                              procid, opno, f.path, errno);
1958                 free_pathname(&f);
1959                 close(fd);
1960                 return;
1961         }
1962 #endif
1963         align = (__int64_t) diob.d_miniosz;
1964         lr = ((__int64_t) random() << 32) + random();
1965         off = (off64_t) (lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
1966         off -= (off % align);
1967         lseek64(fd, off, SEEK_SET);
1968         len = (random() % (getpagesize() * 32)) + 1;
1969         len -= (len % align);
1970         if (len <= 0)
1971                 len = align;
1972         else if (len > diob.d_maxiosz)
1973                 len = diob.d_maxiosz;
1974         if ((e = posix_memalign((void **)&buf, diob.d_mem, len)) != 0) {
1975                 fprintf(stderr, "posix_memalign: %s\n", strerror(e));
1976                 exit(1);
1977         }
1978         if (buf == NULL) {
1979                 fprintf(stderr, "posix_memalign: buf is NULL\n");
1980                 exit(1);
1981         }
1982         off %= maxfsize;
1983         lseek64(fd, off, SEEK_SET);
1984         memset(buf, nameseq & 0xff, len);
1985         e = write(fd, buf, len) < 0 ? errno : 0;
1986         free(buf);
1987         if (v)
1988                 printf("%d/%d: dwrite %s [%lld,%ld] %d\n",
1989                        procid, opno, f.path, (long long)off, (long int)len, e);
1990         free_pathname(&f);
1991         close(fd);
1992 }
1993
1994 void fdatasync_f(int opno, long r)
1995 {
1996         int e;
1997         pathname_t f;
1998         int fd;
1999         int v;
2000
2001         init_pathname(&f);
2002         if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
2003                 if (v)
2004                         printf("%d/%d: fdatasync - no filename\n",
2005                                procid, opno);
2006                 free_pathname(&f);
2007                 return;
2008         }
2009         fd = open_path(&f, O_WRONLY);
2010         e = fd < 0 ? errno : 0;
2011         check_cwd();
2012         if (fd < 0) {
2013                 if (v)
2014                         printf("%d/%d: fdatasync - open %s failed %d\n",
2015                                procid, opno, f.path, e);
2016                 free_pathname(&f);
2017                 return;
2018         }
2019         e = fdatasync(fd) < 0 ? errno : 0;
2020         if (v)
2021                 printf("%d/%d: fdatasync %s %d\n", procid, opno, f.path, e);
2022         free_pathname(&f);
2023         close(fd);
2024 }
2025
2026 #ifndef NO_XFS
2027 void freesp_f(int opno, long r)
2028 {
2029         int e;
2030         pathname_t f;
2031         int fd;
2032         struct xfs_flock64 fl;
2033         __s64 lr;
2034         __s64 off;
2035         struct stat64 stb;
2036         int v;
2037
2038         init_pathname(&f);
2039         if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
2040                 if (v)
2041                         printf("%d/%d: freesp - no filename\n", procid, opno);
2042                 free_pathname(&f);
2043                 return;
2044         }
2045         fd = open_path(&f, O_RDWR);
2046         e = fd < 0 ? errno : 0;
2047         check_cwd();
2048         if (fd < 0) {
2049                 if (v)
2050                         printf("%d/%d: freesp - open %s failed %d\n",
2051                                procid, opno, f.path, e);
2052                 free_pathname(&f);
2053                 return;
2054         }
2055         if (fstat64(fd, &stb) < 0) {
2056                 if (v)
2057                         printf("%d/%d: freesp - fstat64 %s failed %d\n",
2058                                procid, opno, f.path, errno);
2059                 free_pathname(&f);
2060                 close(fd);
2061                 return;
2062         }
2063         lr = ((__s64) random() << 32) + random();
2064         off = lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE);
2065         off %= maxfsize;
2066         memset(&fl, 0, sizeof(fl));
2067         fl.l_whence = SEEK_SET;
2068         fl.l_start = off;
2069         fl.l_len = 0;
2070         e = ioctl(fd, XFS_IOC_FREESP64, &fl) < 0 ? errno : 0;
2071         if (v)
2072                 printf("%d/%d: ioctl(XFS_IOC_FREESP64) %s %lld 0 %d\n",
2073                        procid, opno, f.path, (long long)off, e);
2074         free_pathname(&f);
2075         close(fd);
2076 }
2077
2078 #endif
2079
2080 void fsync_f(int opno, long r)
2081 {
2082         int e;
2083         pathname_t f;
2084         int fd;
2085         int v;
2086
2087         init_pathname(&f);
2088         if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
2089                 if (v)
2090                         printf("%d/%d: fsync - no filename\n", procid, opno);
2091                 free_pathname(&f);
2092                 return;
2093         }
2094         fd = open_path(&f, O_WRONLY);
2095         e = fd < 0 ? errno : 0;
2096         check_cwd();
2097         if (fd < 0) {
2098                 if (v)
2099                         printf("%d/%d: fsync - open %s failed %d\n",
2100                                procid, opno, f.path, e);
2101                 free_pathname(&f);
2102                 return;
2103         }
2104         e = fsync(fd) < 0 ? errno : 0;
2105         if (v)
2106                 printf("%d/%d: fsync %s %d\n", procid, opno, f.path, e);
2107         free_pathname(&f);
2108         close(fd);
2109 }
2110
2111 void getdents_f(int opno, long r)
2112 {
2113         DIR *dir;
2114         pathname_t f;
2115         int v;
2116
2117         init_pathname(&f);
2118         if (!get_fname(FT_DIRm, r, &f, NULL, NULL, &v))
2119                 append_pathname(&f, ".");
2120         dir = opendir_path(&f);
2121         check_cwd();
2122         if (dir == NULL) {
2123                 if (v)
2124                         printf("%d/%d: getdents - can't open %s\n",
2125                                procid, opno, f.path);
2126                 free_pathname(&f);
2127                 return;
2128         }
2129         while (readdir64(dir) != NULL)
2130                 continue;
2131         if (v)
2132                 printf("%d/%d: getdents %s 0\n", procid, opno, f.path);
2133         free_pathname(&f);
2134         closedir(dir);
2135 }
2136
2137 void link_f(int opno, long r)
2138 {
2139         int e;
2140         pathname_t f;
2141         fent_t *fep;
2142         flist_t *flp;
2143         int id;
2144         pathname_t l;
2145         int parid;
2146         int v;
2147         int v1;
2148
2149         init_pathname(&f);
2150         if (!get_fname(FT_NOTDIR, r, &f, &flp, NULL, &v1)) {
2151                 if (v1)
2152                         printf("%d/%d: link - no file\n", procid, opno);
2153                 free_pathname(&f);
2154                 return;
2155         }
2156         if (!get_fname(FT_DIRm, random(), NULL, NULL, &fep, &v))
2157                 parid = -1;
2158         else
2159                 parid = fep->id;
2160         v |= v1;
2161         init_pathname(&l);
2162         e = generate_fname(fep, flp - flist, &l, &id, &v1);
2163         v |= v1;
2164         if (!e) {
2165                 if (v) {
2166                         fent_to_name(&l, &flist[FT_DIR], fep);
2167                         printf("%d/%d: link - no filename from %s\n",
2168                                procid, opno, l.path);
2169                 }
2170                 free_pathname(&l);
2171                 free_pathname(&f);
2172                 return;
2173         }
2174         e = link_path(&f, &l) < 0 ? errno : 0;
2175         check_cwd();
2176         if (e == 0)
2177                 add_to_flist(flp - flist, id, parid);
2178         if (v)
2179                 printf("%d/%d: link %s %s %d\n", procid, opno, f.path, l.path,
2180                        e);
2181         free_pathname(&l);
2182         free_pathname(&f);
2183 }
2184
2185 void mkdir_f(int opno, long r)
2186 {
2187         int e;
2188         pathname_t f;
2189         fent_t *fep;
2190         int id;
2191         int parid;
2192         int v;
2193         int v1;
2194
2195         if (!get_fname(FT_DIRm, r, NULL, NULL, &fep, &v))
2196                 parid = -1;
2197         else
2198                 parid = fep->id;
2199         init_pathname(&f);
2200         e = generate_fname(fep, FT_DIR, &f, &id, &v1);
2201         v |= v1;
2202         if (!e) {
2203                 if (v) {
2204                         fent_to_name(&f, &flist[FT_DIR], fep);
2205                         printf("%d/%d: mkdir - no filename from %s\n",
2206                                procid, opno, f.path);
2207                 }
2208                 free_pathname(&f);
2209                 return;
2210         }
2211         e = mkdir_path(&f, 0777) < 0 ? errno : 0;
2212         check_cwd();
2213         if (e == 0)
2214                 add_to_flist(FT_DIR, id, parid);
2215         if (v)
2216                 printf("%d/%d: mkdir %s %d\n", procid, opno, f.path, e);
2217         free_pathname(&f);
2218 }
2219
2220 void mknod_f(int opno, long r)
2221 {
2222         int e;
2223         pathname_t f;
2224         fent_t *fep;
2225         int id;
2226         int parid;
2227         int v;
2228         int v1;
2229
2230         if (!get_fname(FT_DIRm, r, NULL, NULL, &fep, &v))
2231                 parid = -1;
2232         else
2233                 parid = fep->id;
2234         init_pathname(&f);
2235         e = generate_fname(fep, FT_DEV, &f, &id, &v1);
2236         v |= v1;
2237         if (!e) {
2238                 if (v) {
2239                         fent_to_name(&f, &flist[FT_DIR], fep);
2240                         printf("%d/%d: mknod - no filename from %s\n",
2241                                procid, opno, f.path);
2242                 }
2243                 free_pathname(&f);
2244                 return;
2245         }
2246         e = mknod_path(&f, S_IFCHR | 0444, 0) < 0 ? errno : 0;
2247         check_cwd();
2248         if (e == 0)
2249                 add_to_flist(FT_DEV, id, parid);
2250         if (v)
2251                 printf("%d/%d: mknod %s %d\n", procid, opno, f.path, e);
2252         free_pathname(&f);
2253 }
2254
2255 void read_f(int opno, long r)
2256 {
2257         char *buf;
2258         int e;
2259         pathname_t f;
2260         int fd;
2261         size_t len;
2262         __int64_t lr;
2263         off64_t off;
2264         struct stat64 stb;
2265         int v;
2266
2267         init_pathname(&f);
2268         if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
2269                 if (v)
2270                         printf("%d/%d: read - no filename\n", procid, opno);
2271                 free_pathname(&f);
2272                 return;
2273         }
2274         fd = open_path(&f, O_RDONLY);
2275         e = fd < 0 ? errno : 0;
2276         check_cwd();
2277         if (fd < 0) {
2278                 if (v)
2279                         printf("%d/%d: read - open %s failed %d\n",
2280                                procid, opno, f.path, e);
2281                 free_pathname(&f);
2282                 return;
2283         }
2284         if (fstat64(fd, &stb) < 0) {
2285                 if (v)
2286                         printf("%d/%d: read - fstat64 %s failed %d\n",
2287                                procid, opno, f.path, errno);
2288                 free_pathname(&f);
2289                 close(fd);
2290                 return;
2291         }
2292         if (stb.st_size == 0) {
2293                 if (v)
2294                         printf("%d/%d: read - %s zero size\n", procid, opno,
2295                                f.path);
2296                 free_pathname(&f);
2297                 close(fd);
2298                 return;
2299         }
2300         lr = ((__int64_t) random() << 32) + random();
2301         off = (off64_t) (lr % stb.st_size);
2302         lseek64(fd, off, SEEK_SET);
2303         len = (random() % (getpagesize() * 32)) + 1;
2304         buf = malloc(len);
2305         e = read(fd, buf, len) < 0 ? errno : 0;
2306         free(buf);
2307         if (v)
2308                 printf("%d/%d: read %s [%lld,%ld] %d\n",
2309                        procid, opno, f.path, (long long)off, (long int)len, e);
2310         free_pathname(&f);
2311         close(fd);
2312 }
2313
2314 void readlink_f(int opno, long r)
2315 {
2316         char buf[PATH_MAX];
2317         int e;
2318         pathname_t f;
2319         int v;
2320
2321         init_pathname(&f);
2322         if (!get_fname(FT_SYMm, r, &f, NULL, NULL, &v)) {
2323                 if (v)
2324                         printf("%d/%d: readlink - no filename\n", procid, opno);
2325                 free_pathname(&f);
2326                 return;
2327         }
2328         e = readlink_path(&f, buf, PATH_MAX) < 0 ? errno : 0;
2329         check_cwd();
2330         if (v)
2331                 printf("%d/%d: readlink %s %d\n", procid, opno, f.path, e);
2332         free_pathname(&f);
2333 }
2334
2335 void rename_f(int opno, long r)
2336 {
2337         fent_t *dfep;
2338         int e;
2339         pathname_t f;
2340         fent_t *fep;
2341         flist_t *flp;
2342         int id;
2343         pathname_t newf;
2344         int oldid;
2345         int parid;
2346         int v;
2347         int v1;
2348
2349         init_pathname(&f);
2350         if (!get_fname(FT_ANYm, r, &f, &flp, &fep, &v1)) {
2351                 if (v1)
2352                         printf("%d/%d: rename - no filename\n", procid, opno);
2353                 free_pathname(&f);
2354                 return;
2355         }
2356         if (!get_fname(FT_DIRm, random(), NULL, NULL, &dfep, &v))
2357                 parid = -1;
2358         else
2359                 parid = dfep->id;
2360         v |= v1;
2361         init_pathname(&newf);
2362         e = generate_fname(dfep, flp - flist, &newf, &id, &v1);
2363         v |= v1;
2364         if (!e) {
2365                 if (v) {
2366                         fent_to_name(&f, &flist[FT_DIR], dfep);
2367                         printf("%d/%d: rename - no filename from %s\n",
2368                                procid, opno, f.path);
2369                 }
2370                 free_pathname(&newf);
2371                 free_pathname(&f);
2372                 return;
2373         }
2374         e = rename_path(&f, &newf) < 0 ? errno : 0;
2375         check_cwd();
2376         if (e == 0) {
2377                 if (flp - flist == FT_DIR) {
2378                         oldid = fep->id;
2379                         fix_parent(oldid, id);
2380                 }
2381                 del_from_flist(flp - flist, fep - flp->fents);
2382                 add_to_flist(flp - flist, id, parid);
2383         }
2384         if (v)
2385                 printf("%d/%d: rename %s to %s %d\n", procid, opno, f.path,
2386                        newf.path, e);
2387         free_pathname(&newf);
2388         free_pathname(&f);
2389 }
2390
2391 #ifndef NO_XFS
2392 void resvsp_f(int opno, long r)
2393 {
2394         int e;
2395         pathname_t f;
2396         int fd;
2397         struct xfs_flock64 fl;
2398         __s64 lr;
2399         __s64 off;
2400         struct stat64 stb;
2401         int v;
2402
2403         init_pathname(&f);
2404         if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
2405                 if (v)
2406                         printf("%d/%d: resvsp - no filename\n", procid, opno);
2407                 free_pathname(&f);
2408                 return;
2409         }
2410         fd = open_path(&f, O_RDWR);
2411         e = fd < 0 ? errno : 0;
2412         check_cwd();
2413         if (fd < 0) {
2414                 if (v)
2415                         printf("%d/%d: resvsp - open %s failed %d\n",
2416                                procid, opno, f.path, e);
2417                 free_pathname(&f);
2418                 return;
2419         }
2420         if (fstat64(fd, &stb) < 0) {
2421                 if (v)
2422                         printf("%d/%d: resvsp - fstat64 %s failed %d\n",
2423                                procid, opno, f.path, errno);
2424                 free_pathname(&f);
2425                 close(fd);
2426                 return;
2427         }
2428         lr = ((__s64) random() << 32) + random();
2429         off = lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE);
2430         off %= maxfsize;
2431         memset(&fl, 0, sizeof(fl));
2432         fl.l_whence = SEEK_SET;
2433         fl.l_start = off;
2434         fl.l_len = (__s64) (random() % (1024 * 1024));
2435         e = ioctl(fd, XFS_IOC_RESVSP64, &fl) < 0 ? errno : 0;
2436         if (v)
2437                 printf("%d/%d: ioctl(XFS_IOC_RESVSP64) %s %lld %lld %d\n",
2438                        procid, opno, f.path, (long long)off,
2439                        (long long)fl.l_len, e);
2440         free_pathname(&f);
2441         close(fd);
2442 }
2443 #endif
2444
2445 void rmdir_f(int opno, long r)
2446 {
2447         int e;
2448         pathname_t f;
2449         fent_t *fep;
2450         int v;
2451
2452         init_pathname(&f);
2453         if (!get_fname(FT_DIRm, r, &f, NULL, &fep, &v)) {
2454                 if (v)
2455                         printf("%d/%d: rmdir - no directory\n", procid, opno);
2456                 free_pathname(&f);
2457                 return;
2458         }
2459         e = rmdir_path(&f) < 0 ? errno : 0;
2460         check_cwd();
2461         if (e == 0)
2462                 del_from_flist(FT_DIR, fep - flist[FT_DIR].fents);
2463         if (v)
2464                 printf("%d/%d: rmdir %s %d\n", procid, opno, f.path, e);
2465         free_pathname(&f);
2466 }
2467
2468 void stat_f(int opno, long r)
2469 {
2470         int e;
2471         pathname_t f;
2472         struct stat64 stb;
2473         int v;
2474
2475         init_pathname(&f);
2476         if (!get_fname(FT_ANYm, r, &f, NULL, NULL, &v)) {
2477                 if (v)
2478                         printf("%d/%d: stat - no entries\n", procid, opno);
2479                 free_pathname(&f);
2480                 return;
2481         }
2482         e = lstat64_path(&f, &stb) < 0 ? errno : 0;
2483         check_cwd();
2484         if (v)
2485                 printf("%d/%d: stat %s %d\n", procid, opno, f.path, e);
2486         free_pathname(&f);
2487 }
2488
2489 void symlink_f(int opno, long r)
2490 {
2491         int e;
2492         pathname_t f;
2493         fent_t *fep;
2494         int i;
2495         int id;
2496         int len;
2497         int parid;
2498         int v;
2499         int v1;
2500         char *val;
2501
2502         if (!get_fname(FT_DIRm, r, NULL, NULL, &fep, &v))
2503                 parid = -1;
2504         else
2505                 parid = fep->id;
2506         init_pathname(&f);
2507         e = generate_fname(fep, FT_SYM, &f, &id, &v1);
2508         v |= v1;
2509         if (!e) {
2510                 if (v) {
2511                         fent_to_name(&f, &flist[FT_DIR], fep);
2512                         printf("%d/%d: symlink - no filename from %s\n",
2513                                procid, opno, f.path);
2514                 }
2515                 free_pathname(&f);
2516                 return;
2517         }
2518         len = (int)(random() % PATH_MAX);
2519         val = malloc(len + 1);
2520         if (len)
2521                 memset(val, 'x', len);
2522         val[len] = '\0';
2523         for (i = 10; i < len - 1; i += 10)
2524                 val[i] = '/';
2525         e = symlink_path(val, &f) < 0 ? errno : 0;
2526         check_cwd();
2527         if (e == 0)
2528                 add_to_flist(FT_SYM, id, parid);
2529         free(val);
2530         if (v)
2531                 printf("%d/%d: symlink %s %d\n", procid, opno, f.path, e);
2532         free_pathname(&f);
2533 }
2534
2535 /* ARGSUSED */
2536 void sync_f(int opno, long r)
2537 {
2538         sync();
2539         if (verbose)
2540                 printf("%d/%d: sync\n", procid, opno);
2541 }
2542
2543 void truncate_f(int opno, long r)
2544 {
2545         int e;
2546         pathname_t f;
2547         __int64_t lr;
2548         off64_t off;
2549         struct stat64 stb;
2550         int v;
2551
2552         init_pathname(&f);
2553         if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
2554                 if (v)
2555                         printf("%d/%d: truncate - no filename\n", procid, opno);
2556                 free_pathname(&f);
2557                 return;
2558         }
2559         e = stat64_path(&f, &stb) < 0 ? errno : 0;
2560         check_cwd();
2561         if (e > 0) {
2562                 if (v)
2563                         printf("%d/%d: truncate - stat64 %s failed %d\n",
2564                                procid, opno, f.path, e);
2565                 free_pathname(&f);
2566                 return;
2567         }
2568         lr = ((__int64_t) random() << 32) + random();
2569         off = lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE);
2570         off %= maxfsize;
2571         e = truncate64_path(&f, off) < 0 ? errno : 0;
2572         check_cwd();
2573         if (v)
2574                 printf("%d/%d: truncate %s %lld %d\n", procid, opno, f.path,
2575                        (long long)off, e);
2576         free_pathname(&f);
2577 }
2578
2579 void unlink_f(int opno, long r)
2580 {
2581         int e;
2582         pathname_t f;
2583         fent_t *fep;
2584         flist_t *flp;
2585         int v;
2586
2587         init_pathname(&f);
2588         if (!get_fname(FT_NOTDIR, r, &f, &flp, &fep, &v)) {
2589                 if (v)
2590                         printf("%d/%d: unlink - no file\n", procid, opno);
2591                 free_pathname(&f);
2592                 return;
2593         }
2594         e = unlink_path(&f) < 0 ? errno : 0;
2595         check_cwd();
2596         if (e == 0)
2597                 del_from_flist(flp - flist, fep - flp->fents);
2598         if (v)
2599                 printf("%d/%d: unlink %s %d\n", procid, opno, f.path, e);
2600         free_pathname(&f);
2601 }
2602
2603 #ifndef NO_XFS
2604 void unresvsp_f(int opno, long r)
2605 {
2606         int e;
2607         pathname_t f;
2608         int fd;
2609         struct xfs_flock64 fl;
2610         __s64 lr;
2611         __s64 off;
2612         struct stat64 stb;
2613         int v;
2614
2615         init_pathname(&f);
2616         if (!get_fname(FT_REGFILE, r, &f, NULL, NULL, &v)) {
2617                 if (v)
2618                         printf("%d/%d: unresvsp - no filename\n", procid, opno);
2619                 free_pathname(&f);
2620                 return;
2621         }
2622         fd = open_path(&f, O_RDWR);
2623         e = fd < 0 ? errno : 0;
2624         check_cwd();
2625         if (fd < 0) {
2626                 if (v)
2627                         printf("%d/%d: unresvsp - open %s failed %d\n",
2628                                procid, opno, f.path, e);
2629                 free_pathname(&f);
2630                 return;
2631         }
2632         if (fstat64(fd, &stb) < 0) {
2633                 if (v)
2634                         printf("%d/%d: unresvsp - fstat64 %s failed %d\n",
2635                                procid, opno, f.path, errno);
2636                 free_pathname(&f);
2637                 close(fd);
2638                 return;
2639         }
2640         lr = ((__s64) random() << 32) + random();
2641         off = lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE);
2642         off %= maxfsize;
2643         memset(&fl, 0, sizeof(fl));
2644         fl.l_whence = SEEK_SET;
2645         fl.l_start = off;
2646         fl.l_len = (__s64) (random() % (1 << 20));
2647         e = ioctl(fd, XFS_IOC_UNRESVSP64, &fl) < 0 ? errno : 0;
2648         if (v)
2649                 printf("%d/%d: ioctl(XFS_IOC_UNRESVSP64) %s %lld %lld %d\n",
2650                        procid, opno, f.path, (long long)off,
2651                        (long long)fl.l_len, e);
2652         free_pathname(&f);
2653         close(fd);
2654 }
2655 #endif
2656
2657 void write_f(int opno, long r)
2658 {
2659         char *buf;
2660         int e;
2661         pathname_t f;
2662         int fd;
2663         size_t len;
2664         __int64_t lr;
2665         off64_t off;
2666         struct stat64 stb;
2667         int v;
2668
2669         init_pathname(&f);
2670         if (!get_fname(FT_REGm, r, &f, NULL, NULL, &v)) {
2671                 if (v)
2672                         printf("%d/%d: write - no filename\n", procid, opno);
2673                 free_pathname(&f);
2674                 return;
2675         }
2676         fd = open_path(&f, O_WRONLY);
2677         e = fd < 0 ? errno : 0;
2678         check_cwd();
2679         if (fd < 0) {
2680                 if (v)
2681                         printf("%d/%d: write - open %s failed %d\n",
2682                                procid, opno, f.path, e);
2683                 free_pathname(&f);
2684                 return;
2685         }
2686         if (fstat64(fd, &stb) < 0) {
2687                 if (v)
2688                         printf("%d/%d: write - fstat64 %s failed %d\n",
2689                                procid, opno, f.path, errno);
2690                 free_pathname(&f);
2691                 close(fd);
2692                 return;
2693         }
2694         lr = ((__int64_t) random() << 32) + random();
2695         off = (off64_t) (lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
2696         off %= maxfsize;
2697         lseek64(fd, off, SEEK_SET);
2698         len = (random() % (getpagesize() * 32)) + 1;
2699         buf = malloc(len);
2700         memset(buf, nameseq & 0xff, len);
2701         e = write(fd, buf, len) < 0 ? errno : 0;
2702         free(buf);
2703         if (v)
2704                 printf("%d/%d: write %s [%lld,%ld] %d\n",
2705                        procid, opno, f.path, (long long)off, (long int)len, e);
2706         free_pathname(&f);
2707         close(fd);
2708 }