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