contrib/fsstress.c

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