ltp/fsstress.c

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