Initial revision
[nfs-utils.git] / utils / nhfsstone / nhfsstone.c
1 #ifndef lint
2 static char sccsid[] = "@(#)nhfsstone.c 1.22 90/05/08 Copyright (c) 1990, Legato Systems Inc";
3 #endif
4
5 /*
6  * Copyright (c) 1990 Legato Systems Inc.
7  *
8  * See DISCLAIMER file for restrictions
9  *
10  * Ported to Linux by Olaf Kirch <okir@monad.swb.de>
11  */
12
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <unistd.h>
16 #include <string.h>
17 #include <ctype.h>
18 #include <errno.h>
19 #include <fcntl.h>
20 #include <sys/param.h>
21 #include <sys/time.h>
22 #include <sys/vfs.h>
23 #include <sys/stat.h>
24 #include <sys/wait.h>
25 #ifdef BSD
26 #include <sys/dir.h>
27 #define dirent  direct
28 #else
29 #include <dirent.h>
30 #endif
31 #include <signal.h>
32
33 #ifndef NULL
34 #define NULL    0
35 #endif
36
37 /*
38  * Usage: nhfsstone [-v] [[-t secs] | [-c calls]] [-l load] [-p nprocs]
39  *                                              [-m mixfile] [dir]...
40  *
41  * Generates an artifical NFS client load based on a given mix of
42  * operations.
43  *
44  * Strategy: loop for some number of NFS calls doing a random sleep
45  * followed by a call to one of the op generator routines. The routines
46  * are called based on a weighting factor determined by the difference
47  * between the current ops percentages (derived from kernel NFS stats)
48  * and a set of default percentages or a mix supplied by the caller.
49  *
50  * The generator routines try very hard to guess how many NFS operations
51  * they are generating so that the calling routine can keep a running
52  * estimate of the number of calls and the mix to avoid having to get
53  * the NFS statistics from the kernel too often.
54  *
55  * The operations are done in a directory that has a set of file names
56  * that are long enough that they won't be cached by the name cache
57  * in the kernel. The "lookup" operation steps through the names and
58  * creates a file if that name does not exist, or closes and reopens it
59  * if it does. This generates a table of open file descriptors. Most of the
60  * other operations are done on random descriptors in the table. The "getattr"
61  * operation tries to avoid the kernel attribute cache by doing "fstat"
62  * system calls on random descriptors in the table. There must be enough
63  * files in the directory so that, on average, the getattr operation hits
64  * any file less often than once each 6 seconds (the default timeout for
65  * the attributes cache).
66  *
67  * The parent process starts children to do the real work of generating load.
68  * The parent coordinates them so that they all start at the same time, and
69  * collects statistics from them when they are done. To coordinate the
70  * start up, the parent waits for each child to write one byte into
71  * a common log file (opened in append mode to avoid overwriting).
72  * After they write a byte the children pause, and the parent send SIGUSR1
73  * when it has heard from all of the kids. The children write their statistics
74  * into the same common log file and the parent reads and accumulates the
75  * statics and prints them out.
76  *
77  * This code will only compile and run on 4.X BSD based systems.
78  */
79
80 #define DEFAULT_LOAD    30              /* default calls per sec */
81 #define DEFAULT_CALLS   5000            /* default number of calls */
82 #define NFILES          40              /* number of test files/dir */
83 #define BUFSIZE         8192            /* block size for read and write */
84 #define MAXFILESIZE     32              /* size, in blocks, of large file */
85 #define SAMPLETIME      5               /* secs between samples of NFS stats */
86 #define NPROCS          7               /* number of children to run */
87
88
89 /*
90  * The names of NFS operations
91  */
92 char *Opnames[] = {
93         "null", "getattr", "setattr", "root", "lookup", "readlink", "read",
94         "wrcache", "write", "create", "remove", "rename", "link", "symlink",
95         "mkdir", "rmdir", "readdir", "fsstat",
96 };
97
98 /*
99  * NFS operation numbers
100  *
101  * Used to index the Opnames, Mix and statistics arrays.
102  */
103 #define NOPS            18              /* number of NFS ops */
104 #define NULLCALL        0
105 #define GETATTR         1
106 #define SETATTR         2
107 #define ROOT            3
108 #define LOOKUP          4
109 #define READLINK        5
110 #define READ            6
111 #define WRCACHE         7
112 #define WRITE           8
113 #define CREATE          9
114 #define REMOVE          10
115 #define RENAME          11
116 #define LINK            12
117 #define SYMLINK         13
118 #define MKDIR           14
119 #define RMDIR           15
120 #define READDIR         16
121 #define FSSTAT          17
122
123 /*
124  * Operations counts
125  */
126 struct count {
127         int             total;
128         int             calls[NOPS];
129 };
130
131 /*
132  * Software development mix for server with about 50/50 mix of
133  * diskless and diskful clients running SunOS 4.0.
134  */
135 int     Mix[NOPS] = {
136         0,              /* null */
137         13,             /* getattr */
138         1,              /* setattr */
139         0,              /* root */
140         34,             /* lookup */
141         8,              /* readlink */
142         22,             /* read */
143         0,              /* wrcache */
144         15,             /* write */
145         2,              /* create */
146         1,              /* remove */
147         0,              /* rename */
148         0,              /* link */
149         0,              /* symlink */
150         0,              /* mkdir */
151         0,              /* rmdir */
152         3,              /* readdir */
153         1,              /* fsstat */
154 };
155
156 /* Prototype decls */
157 int     setmix(FILE *fp);
158 void    usage(void);
159 void    init_logfile(void);
160 void    init_counters(void);
161 void    get_delta(struct count *start, struct count *cur);
162 void    init_testdir(int dirnum, char *parentdir);
163 void    do_op(int rpct);
164 void    op(int opnum);
165 void    nextfile(void);
166 int     createfile(void);
167 int     openfile(void);
168 int     writefile(void);
169 void    collect_counters(void);
170 int     check_counters(void);
171 void    print(void);
172 void    msec_sleep(int msecs);
173 void    get_opct(struct count *count);
174 int     substr(char *sp, char *subsp);
175 int     check_access(struct stat statb);
176 void    error(char *str);
177
178 /*
179  * NFS operations generator routines
180  */
181 int     op_null();
182 int     op_getattr();
183 int     op_setattr();
184 int     op_root();
185 int     op_lookup();
186 int     op_readlink();
187 int     op_read();
188 int     op_wrcache();
189 int     op_write();
190 int     op_create();
191 int     op_remove();
192 int     op_rename();
193 int     op_link();
194 int     op_symlink();
195 int     op_mkdir();
196 int     op_rmdir();
197 int     op_readdir();
198 int     op_fsstat();
199
200 /*
201  * Operations generator vector
202  */
203 struct op_vect {
204         int     (*funct)();     /* op */
205 } Op_vect[NOPS] = {
206         { op_null },
207         { op_getattr },
208         { op_setattr },
209         { op_root },
210         { op_lookup },
211         { op_readlink },
212         { op_read },
213         { op_wrcache },
214         { op_write },
215         { op_create },
216         { op_remove },
217         { op_rename },
218         { op_link },
219         { op_symlink },
220         { op_mkdir },
221         { op_rmdir },
222         { op_readdir },
223         { op_fsstat },
224 };
225
226 /*
227  * Name sub-strings
228  */
229 #define DIRSTR  "dir"                   /* directory */
230 #define SYMSTR  "sym"                   /* symbolic link */
231 #define LINSTR  "lin"                   /* hard link */
232
233 struct timeval  Optime[NOPS+1];         /* cumulative running time for ops */
234 struct count Curct;                     /* total number ops called */
235 int     Openfd[NFILES];                 /* open file descriptors */
236 int     Curnum;                         /* current file number */
237 int     Symnum;                         /* current symlink file number */
238 int     Linknum;                        /* current link file number */
239 int     Dirnum;                         /* current directory number */
240 DIR     *Testdir;                       /* my test directory */
241 char    Testdirname[MAXNAMLEN*2];       /* my test directory name */
242 char    Curname[MAXNAMLEN];             /* current file name */
243 char    Dirname[MAXNAMLEN];             /* current directory name */
244 char    Symname[MAXNAMLEN];             /* symlink file name */
245 char    Linkname[MAXNAMLEN];            /* link file name */
246 char    *Otherspec = "%s/%03d";         /* sprintf spec for other names */
247 char    *Rename1 = "rename1";           /* first name of rename pair */
248 char    *Rename2 = "rename2";           /* second name of rename pair */
249 char    *Symlinkpath = "./symlinknamelongstuff";
250                                         /* symlink file data */
251 char    *Myname;                        /* name program invoked under */
252 char    Namebuf[MAXNAMLEN];             /* unique name for this program */
253 int     Log;                            /* synchronization log */
254 char    Logname[MAXNAMLEN];             /* synchronization log name */
255 int     Kmem;                           /* /dev/kmem file descriptor */
256 off_t   Statoffset;                     /* offset to op count in NFS stats */
257 int     Nprocs;                         /* sub-processes started */
258 int     Verbose;                        /* print more info */
259 int     Testop = -1;                    /* operation to test */
260 int     Saveerrno;                      /* place to save errno */
261
262 #define subtime(t1, t2) {if ((t1.tv_usec -= t2.tv_usec) >= 1000000) {\
263                                 t1.tv_sec += (t1.tv_usec / 1000000); \
264                                 t1.tv_usec %= 1000000; \
265                          } else if (t1.tv_usec < 0) { \
266                                 t1.tv_usec += 1000000; \
267                                 t1.tv_sec--; \
268                          } \
269                          t1.tv_sec -= t2.tv_sec; \
270                         }
271
272 #define addtime(t1, t2) {if ((t1.tv_usec += t2.tv_usec) >= 1000000) {\
273                                 t1.tv_sec += (t1.tv_usec / 1000000); \
274                                 t1.tv_usec %= 1000000; \
275                          } else if (t1.tv_usec < 0) { \
276                                 t1.tv_usec += 1000000; \
277                                 t1.tv_sec--; \
278                          } \
279                          t1.tv_sec += t2.tv_sec; \
280                         }
281
282 /*
283  * Used to catch the parent's "start" signal
284  */
285 void
286 startup()
287 {
288
289         return;
290 }
291
292 /*
293  * Clean up and exit
294  */
295 void
296 cleanup()
297 {
298
299         (void) unlink(Logname);
300         exit(1);
301 }
302
303 int
304 main(int argc, char **argv)
305 {
306         int runtime;            /* length of run, in seconds */
307         int load;               /* load factor, in client loads */
308         int ncalls;             /* total number of calls to make */
309         int avgmspc;            /* average millisec per call */
310         int mspc;               /* millisec per call */
311         int wantcalls;          /* ncalls that should have happend by now */
312         int pid;                /* process id */
313         int delay;              /* msecs since last checked current time */
314         int randnum;            /* a random number */
315         int oldmask;            /* saved signal mask */
316         int sampletime;         /* secs between reading kernel stats */
317         char *opts;             /* option parsing */
318         int pct;
319         int procnum;
320         FILE *fp;
321         struct timeval curtime;
322         struct timeval starttime;
323         struct count startct;
324         struct stat statb;
325         char workdir[MAXPATHLEN];
326         char *getwd();
327
328         Myname = argv[0];
329
330         argc--;
331         argv++;
332
333         load = DEFAULT_LOAD;
334         ncalls = 0;
335         runtime = 0;
336         Nprocs = NPROCS;
337         pid = 0;
338
339         (void) umask(0);
340
341         /*
342          * Parse options
343          */
344         while (argc && **argv == '-') {
345                 opts = &argv[0][1];
346                 while (*opts) {
347                         switch (*opts) {
348
349                         case 'c':
350                                 /*
351                                  * Set number of calls
352                                  */
353                                 if (!isdigit(argv[1][0])) {
354                                         (void) fprintf(stderr,
355                                             "%s: illegal calls value %s\n",
356                                             Myname, argv[1]);
357                                         exit(1);
358                                 }
359                                 ncalls = atoi(argv[1]);
360                                 argv++;
361                                 argc--;
362                                 break;
363
364                         case 'l':
365                                 /*
366                                  * Set load
367                                  */
368                                 if (!isdigit(argv[1][0])) {
369                                         (void) fprintf(stderr,
370                                             "%s: illegal load value %s\n",
371                                             Myname, argv[1]);
372                                         exit(1);
373                                 }
374                                 load = atoi(argv[1]);
375                                 argv++;
376                                 argc--;
377                                 break;
378
379                         case 'm':
380                                 /*
381                                  * Set mix from a file
382                                  */
383                                 if ((fp = fopen(argv[1], "r")) == NULL) {
384                                         Saveerrno = errno;
385                                         (void) fprintf(stderr,
386                                             "%s: bad mix file", Myname);
387                                         errno = Saveerrno;
388                                         perror("");
389                                         exit(1);
390                                 }
391                                 if (setmix(fp) < 0) {
392                                         exit(1);
393                                 }
394                                 (void) fclose(fp);
395                                 argv++;
396                                 argc--;
397                                 break;
398
399                         case 'p':
400                                 /*
401                                  * Set number of child processes
402                                  */
403                                 if (!isdigit(argv[1][0])) {
404                                         (void) fprintf(stderr,
405                                             "%s: illegal procs value %s\n",
406                                             Myname, argv[1]);
407                                         exit(1);
408                                 }
409                                 Nprocs = atoi(argv[1]);
410                                 argv++;
411                                 argc--;
412                                 break;
413
414                         case 'T':
415                                 /*
416                                  * Set test mode, number following is opnum
417                                  */
418                                 if (!isdigit(argv[1][0])) {
419                                         (void) fprintf(stderr,
420                                             "%s: illegal test value %s\n",
421                                             Myname, argv[1]);
422                                         exit(1);
423                                 }
424                                 Testop = atoi(argv[1]);
425                                 if (Testop >= NOPS) {
426                                         (void) fprintf(stderr,
427                                             "%s: illegal test value %d\n",
428                                             Myname, Testop);
429                                         exit(1);
430                                 }
431                                 argv++;
432                                 argc--;
433                                 break;
434
435                         case 't':
436                                 /*
437                                  * Set running time
438                                  */
439                                 if (!isdigit(argv[1][0])) {
440                                         (void) fprintf(stderr,
441                                             "%s: illegal time value %s\n",
442                                             Myname, argv[1]);
443                                         exit(1);
444                                 }
445                                 runtime = atoi(argv[1]);
446                                 argv++;
447                                 argc--;
448                                 break;
449
450                         case 'v':
451                                 /*
452                                  * Set verbose mode
453                                  */
454                                 Verbose++;
455                                 break;
456
457                         default:
458                                 usage();
459                                 exit(1);
460
461                         }
462                         opts++;
463                 }
464                 argv++;
465                 argc--;
466         }
467
468         init_logfile();         /* Set up synchronizatin log file */
469
470         if (getcwd(workdir, sizeof(workdir)) == (char *) 0) {
471                 Saveerrno = errno;
472                 (void) fprintf(stderr,
473                     "%s: can't find current directory ", Myname);
474                 errno = Saveerrno;
475                 perror("");
476                 exit(1);
477         }
478
479         (void) signal(SIGINT, cleanup);
480         (void) signal(SIGUSR1, startup);
481         oldmask = sigblock(sigmask(SIGUSR1));
482
483         if (ncalls == 0) {
484                 if (runtime == 0) {
485                         ncalls = DEFAULT_CALLS;
486                 } else {
487                         ncalls = runtime * load;
488                 }
489         }
490         avgmspc = Nprocs * 1000 / load;
491
492         /*
493          * Fork kids
494          */
495         for (procnum = 0; procnum < Nprocs; procnum++) {
496                 if ((pid = fork()) == -1) {
497                         Saveerrno = errno;
498                         (void) fprintf(stderr, "%s: can't fork ", Myname);
499                         errno = Saveerrno;
500                         perror("");
501                         (void) kill(0, SIGINT);
502                         exit(1);
503                 }
504                 /*
505                  * Kids go initialize
506                  */
507                 if (pid == 0) {
508                         break;
509                 }
510         }
511
512         /*
513          * Parent: wait for kids to get ready, start them, wait for them to
514          * finish, read and accumulate results.
515          */
516         if (pid != 0) {
517                 /*
518                  * wait for kids to initialize
519                  */
520                 do {
521                         sleep(1);
522                         if (fstat(Log, &statb) == -1) {
523                                 (void) fprintf(stderr, "%s: can't stat log %s",
524                                     Myname, Logname);
525                                 (void) kill(0, SIGINT);
526                                 exit(1);
527                         }
528                 } while (statb.st_size != Nprocs);
529
530                 if (ftruncate(Log, 0L) == -1) {
531                         (void) fprintf(stderr, "%s: can't truncate log %s",
532                             Myname, Logname);
533                         (void) kill(0, SIGINT);
534                         exit(1);
535                 }
536
537                 sync();
538                 sleep(3);
539
540                 /*
541                  * Be sure there isn't something else going on
542                  */
543                 get_opct(&startct);
544                 msec_sleep(2000);
545                 get_delta(&startct, &Curct);
546                 if (Curct.total > 20) {
547                         (void) fprintf(stderr,
548                             "%s: too much background activity (%d calls/sec)\n",
549                             Myname, Curct.total);
550                         (void) kill(0, SIGINT);
551                         exit(1);
552                 }
553
554                 /*
555                  * get starting stats
556                  */
557                 get_opct(&startct);
558
559                 /*
560                  * Start kids
561                  */
562                 (void) kill(0, SIGUSR1);
563
564                 /*
565                  * Kids started, wait for first one to finish, signal the
566                  * rest and wait for them to finish.
567                  */
568                 if (wait((union wait *) 0) != -1) {
569                         (void) kill(0, SIGUSR1);
570                         while (wait((union wait *) 0) != -1)
571                                 /* nothing */;
572                 }
573
574                 /*
575                  * Initialize and sum up counters
576                  */
577                 init_counters();
578                 get_delta(&startct, &Curct);
579                 collect_counters();
580                 if (check_counters() == -1) {
581                         Verbose = 1;
582                 }
583                 print();
584
585                 (void) close(Log);
586                 (void) unlink(Logname);
587
588                 exit(0);
589         }
590
591         /*
592          * Children: initialize, then notify parent through log file,
593          * wait to get signal, beat the snot out of the server, write
594          * stats to the log file, and exit.
595          */
596
597         /*
598          * Change my name for error logging
599          */
600         (void) sprintf(Namebuf, "%s%d", Myname, procnum);
601         Myname = Namebuf;
602
603         /*
604          * Initialize and cd to test directory
605          */
606         if (argc != 0) {
607                 init_testdir(procnum, argv[procnum % argc]);
608         } else {
609                 init_testdir(procnum, ".");
610         }
611         if ((Testdir = opendir(".")) == NULL) {
612                 Saveerrno = errno;
613                 (void) fprintf(stderr,
614                     "%s: can't open test directory ", Myname);
615                 errno = Saveerrno;
616                 perror(Testdirname);
617                 exit(1);
618         }
619
620         init_counters();
621         srandom(procnum+1);
622
623         /*
624          * Tell parent I'm ready then wait for go ahead
625          */
626         if (write(Log, " ", 1) != 1) {
627                 (void) fprintf(stderr, "%s: can't write sync file %s",
628                     Myname, Logname);
629                 (void) kill(0, SIGINT);
630                 exit(1);
631         }
632
633         sigpause(oldmask);
634
635         /*
636          * Initialize counters
637          */
638         get_opct(&startct);
639         (void) gettimeofday(&starttime, (struct timezone *)NULL);
640         sampletime = starttime.tv_sec + ((int) random()) % (2 * SAMPLETIME);
641         curtime = starttime;
642
643         /*
644          * Do pseudo NFS operations and adapt to dynamic changes in load
645          * by adjusting the sleep time between operations based on the
646          * number of calls that should have occured since starttime and
647          * the number that have actually occured.  A delay is used to avoid
648          * doing gettimeofday calls too often, and a sampletime is
649          * used to avoid reading kernel NFS stats too often.
650          * If parent interrupts, get out and clean up.
651          */
652         delay = 0;
653         mspc = avgmspc;
654         for (;;) {
655                 randnum = (int) random();
656                 if (mspc > 0) {
657                         msec_sleep(randnum % (mspc << 1));
658                 }
659
660                 /*
661                  * Do the NFS operation
662                  * We use a random number from 0-199 to avoid starvation
663                  * of the operations at the end of the mix.
664                  */
665                 do_op(randnum % 200);
666
667                 /*
668                  * Do a gettimeofday call only once per second
669                  */
670                 delay += mspc;
671                 if (delay > 1000 || Curct.total >= ncalls) {
672                         delay = 0;
673                         (void) gettimeofday(&curtime, (struct timezone *)NULL);
674
675                         /*
676                          * If sample time is up, check the kernel stats
677                          * and adjust our parameters to either catch up or
678                          * slow down.
679                          */
680                         if (curtime.tv_sec > sampletime ||
681                             Curct.total >= ncalls) {
682                                 sampletime = curtime.tv_sec + SAMPLETIME;
683                                 get_delta(&startct, &Curct);
684                                 if (Curct.total >= ncalls) {
685                                         break;
686                                 }
687                                 wantcalls =
688                                     ((curtime.tv_sec - starttime.tv_sec) * 1000
689                                     +(curtime.tv_usec-starttime.tv_usec) / 1000)
690                                     * Nprocs / avgmspc;
691                                 pct = 1000 * (Curct.total - wantcalls) / ncalls;
692                                 mspc = avgmspc + avgmspc * pct / 20;
693                                 if (mspc <= 0) {
694                                         /*
695                                          * mspc must be positive or we will
696                                          * never advance time.
697                                          */
698                                         mspc = 10;
699                                 }
700                         }
701                 }
702         }
703
704         /*
705          * Store total time in last slot of counts array
706          */
707         Optime[NOPS].tv_sec = curtime.tv_sec - starttime.tv_sec;
708         Optime[NOPS].tv_usec = curtime.tv_usec - starttime.tv_usec;
709
710         /*
711          * write stats to log file (append mode)
712          */
713         if (write(Log, (char *)Optime, sizeof (Optime)) == -1) {
714                 Saveerrno = errno;
715                 (void) fprintf(stderr, "%s: can't write log ", Myname);
716                 errno = Saveerrno;
717                 perror("");
718                 (void) kill(0, SIGINT);
719                 exit(1);
720         }
721         (void) close(Log);
722
723         exit(0);
724 }
725
726 /*
727  * Initialize test directory
728  *
729  * If the directory already exists, check to see that all of the
730  * files exist and we can write them.  If directory doesn't exist
731  * create it and fill it using the LOOKUP and WRITE ops.
732  * Chdir to the directory.
733  */
734 void
735 init_testdir(int dirnum, char *parentdir)
736 {
737         int i;
738         int fd;
739         char cmd[256];
740         struct stat statb;
741
742         (void) sprintf(Testdirname, "%s/testdir%d", parentdir, dirnum);
743         if (stat(Testdirname, &statb) == -1) {
744                 if (mkdir(Testdirname, 0777) == -1) {
745                         Saveerrno = errno;
746                         (void) fprintf(stderr,
747                             "%s: can't create test directory ", Myname);
748                         errno = Saveerrno;
749                         perror(Testdirname);
750                         (void) kill(0, SIGINT);
751                         exit(1);
752                 }
753                 if (chdir(Testdirname) == -1) {
754                         Saveerrno = errno;
755                         (void) fprintf(stderr,
756                             "%s: can't cd to test directory ", Myname);
757                         errno = Saveerrno;
758                         perror(Testdirname);
759                         (void) kill(0, SIGINT);
760                         exit(1);
761                 }
762
763                 /*
764                  * create some files with long names and average size
765                  */
766                 for (i = 0; i < NFILES; i++) {
767                         nextfile();
768                         (void) createfile();
769                         if (Openfd[Curnum] == 0 || writefile() == 0) {
770                                 Saveerrno = errno;
771                                 (void) fprintf(stderr,
772                                     "%s: can't create test file '%s'\n",
773                                     Myname, Curname);
774                                 errno = Saveerrno;
775                                 perror(Testdirname);
776                                 (void) kill(0, SIGINT);
777                                 exit(1);
778                         }
779                 }
780         } else {
781                 if (chdir(Testdirname) == -1) {
782                         Saveerrno = errno;
783                         (void) fprintf(stderr,
784                             "%s: can't cd to test directory ", Myname);
785                         errno = Saveerrno;
786                         perror(Testdirname);
787                         (void) kill(0, SIGINT);
788                         exit(1);
789                 }
790
791                 /*
792                  * Verify that we can read and write the test dir
793                  */
794                 if (check_access(statb) == -1) {
795                         (void) fprintf(stderr,
796                             "%s: wrong permissions on test dir %s\n",
797                             Myname, Testdirname);
798                         (void) kill(0, SIGINT);
799                         exit(1);
800                 }
801
802                 /*
803                  * Verify that we can read and write all the files
804                  */
805                 for (i = 0; i < NFILES; i++) {
806                         nextfile();
807                         if (stat(Curname, &statb) == -1 || statb.st_size == 0) {
808                                 /*
809                                  * File doesn't exist or is 0 size
810                                  */
811                                 (void) createfile();
812                                 if (Openfd[Curnum] == 0 || writefile() == 0) {
813                                         (void) kill(0, SIGINT);
814                                         exit(1);
815                                 }
816                         } else if (check_access(statb) == -1) {
817                                 /*
818                                  * should try to remove and recreate it
819                                  */
820                                 (void) fprintf(stderr,
821                                     "%s: wrong permissions on testfile %s\n",
822                                     Myname, Curname);
823                                 (void) kill(0, SIGINT);
824                                 exit(1);
825                         } else if (Openfd[Curnum] == 0) {
826                                 (void) openfile();
827                                 if (Openfd[Curnum] == 0) {
828                                         (void) kill(0, SIGINT);
829                                         exit(1);
830                                 }
831                         }
832                 }
833         }
834
835         /*
836          * Start with Rename1 and no Rename2 so the
837          * rename op can ping pong back and forth.
838          */
839         (void) unlink(Rename2);
840         if ((fd = open(Rename1, O_CREAT|O_TRUNC|O_RDWR, 0666)) == -1) {
841                 Saveerrno = errno;
842                 (void) fprintf(stderr, "%s: can't create rename file ", Myname);
843                 errno = Saveerrno;
844                 perror(Rename1);
845                 (void) kill(0, SIGINT);
846                 exit(1);
847         }
848
849         /*
850          * Remove and recreate the test sub-directories
851          * for mkdir symlink and hard link.
852          */
853         (void) sprintf(cmd, "rm -rf %s %s %s", DIRSTR, SYMSTR, LINSTR);
854         if (system(cmd) != 0) {
855                 (void) fprintf(stderr, "%s: can't %s\n", Myname, cmd);
856                 (void) kill(0, SIGINT);
857                 exit(1);
858         }
859
860         if (mkdir(DIRSTR, 0777) == -1) {
861                 (void) fprintf(stderr,
862                     "%s: can't create subdir %s\n", Myname, DIRSTR);
863                 (void) kill(0, SIGINT);
864                 exit(1);
865         }
866
867         if (mkdir(SYMSTR, 0777) == -1) {
868                 (void) fprintf(stderr,
869                     "%s: can't create subdir %s\n", Myname, SYMSTR);
870                 (void) kill(0, SIGINT);
871                 exit(1);
872         }
873         op(SYMLINK);
874
875         if (mkdir(LINSTR, 0777) == -1) {
876                 (void) fprintf(stderr, "%s: can't create subdir %s\n", Myname,
877                     LINSTR);
878                 (void) kill(0, SIGINT);
879                 exit(1);
880         }
881
882         (void) close(fd);
883 }
884
885 /*
886  * The routines below attempt to do over-the-wire operations.
887  * Each op tries to cause one or more of a particular
888  * NFS operation to go over the wire.  OPs return the number
889  * of OTW calls they think they have generated.
890  *
891  * An array of open file descriptors is kept for the files in each
892  * test directory. The open fd's are used to get access to the files
893  * without generating lookups. An fd value of 0 mean the corresponding
894  * file name is closed.  Ops that need a name use Curname.
895  */
896
897 /*
898  * Call an op based on a random number and the current
899  * op calling weights. Op weights are derived from the
900  * mix percentage and the current NFS stats mix percentage.
901  */
902 void
903 do_op(int rpct)
904 {
905         int opnum;
906         int weight;
907         int oppct;
908
909         if (Testop != -1) {
910                 nextfile();
911                 op(Testop);
912                 return;
913         }
914         for (opnum = rpct % NOPS; rpct >= 0; opnum = (opnum + 1) % NOPS) {
915                 if (Curct.total) {
916                         oppct = (Curct.calls[opnum] * 100) / Curct.total;
917                 } else {
918                         oppct = 0;
919                 }
920                 /*
921                  * Weight is mix percent - (how far off we are * fudge)
922                  * fudge factor is required because some ops (read, write)
923                  * generate many NFS calls for a single op call
924                  */
925                 weight = Mix[opnum] - ((oppct - Mix[opnum]) << 4);
926                 if (weight <= 0) {
927                         continue;
928                 }
929                 rpct -= weight;
930                 if (rpct < 0) {
931                         if (opnum == RMDIR && Dirnum == 0) {
932                                 op(MKDIR);
933                         } else if (opnum != CREATE && opnum != LOOKUP &&
934                             opnum != REMOVE) {
935                                 nextfile();
936                         }
937                         op(opnum);
938                         if (Openfd[Curnum] == 0) {
939                                 op(CREATE);
940 #ifdef XXX
941                                 op(WRITE);
942 #endif /* XXX */
943                         }
944                         return;
945                 }
946         }
947 }
948
949 /*
950  * Call an op generator and keep track of its running time
951  */
952 void
953 op(int opnum)
954 {
955         struct timeval start;
956         struct timeval stop;
957         int nops;
958
959         (void) gettimeofday(&start, (struct timezone *)NULL);
960         nops = (*Op_vect[opnum].funct)();
961         (void) gettimeofday(&stop, (struct timezone *)NULL);
962         stop.tv_sec -= start.tv_sec;
963         stop.tv_usec -= start.tv_usec;
964
965 #ifdef SUNOS4
966         /*
967          * SunOS 4.0 does a lookup and a getattr on each open
968          * so we have to account for that in the getattr op
969          */
970         if (opnum == GETATTR && nops == 2) {
971                 nops = 1;
972                 stop.tv_sec /= 2;
973                 stop.tv_usec /= 2;
974                 Curct.total += Nprocs;
975                 Curct.calls[LOOKUP] += Nprocs;
976                 addtime(Optime[LOOKUP], stop);
977         }
978 #endif
979
980         nops *= Nprocs;
981         Curct.total += nops;
982         Curct.calls[opnum] += nops;
983         addtime(Optime[opnum], stop);
984 }
985
986 /*
987  * Advance file number (Curnum) and name (Curname)
988  */
989 void
990 nextfile(void)
991 {
992         static char *numpart = NULL;
993         int num;
994
995         Curnum = (Curnum + 1) % NFILES;
996         if (numpart == NULL) {
997                 (void) sprintf(Curname, "%03dabcdefghijklmn", Curnum);
998                 numpart = Curname;
999         } else {
1000                 num = Curnum;
1001                 numpart[0] = '0' + num / 100;
1002                 num %= 100;
1003                 numpart[1] = '0' + num / 10;
1004                 num %= 10;
1005                 numpart[2] = '0' + num;
1006         }
1007 }
1008
1009 int
1010 createfile(void)
1011 {
1012         int ret;
1013         int fd;
1014
1015         ret = 0;
1016         fd = Openfd[Curnum];
1017
1018         if ((fd && close(fd) == -1) ||
1019             (fd = open(Curname, O_CREAT|O_RDWR|O_TRUNC, 0666)) == -1) {
1020                 fd = 0;
1021                 ret = -1;
1022                 error("create");
1023         }
1024         Openfd[Curnum] = fd;
1025         return (ret);
1026 }
1027
1028 int
1029 openfile(void)
1030 {
1031         int ret;
1032         int fd;
1033
1034         ret = 0;
1035         fd = Openfd[Curnum];
1036         if (fd == 0 && (fd = open(Curname, O_RDWR, 0666)) == -1) {
1037                 fd = 0;
1038                 ret = -1;
1039                 error("open");
1040         }
1041         Openfd[Curnum] = fd;
1042         return (ret);
1043 }
1044
1045 int
1046 writefile(void)
1047 {
1048         int fd;
1049         int wrote;
1050         int bufs;
1051         int size;
1052         int randnum;
1053         char buf[BUFSIZE];
1054
1055         fd = Openfd[Curnum];
1056
1057         if (lseek(fd, 0L, 0) == (off_t) -1) {
1058                 error("write: lseek");
1059                 return (-1);
1060         }
1061
1062         randnum = (int) random();
1063         bufs = randnum % 100;   /* using this for distribution desired */
1064         /*
1065          * Attempt to create a distribution of file sizes
1066          * to reflect reality.  Most files are small,
1067          * but there are a few files that are very large.
1068          *
1069          * The sprite paper (USENIX 198?) claims :
1070          *      50% of all files are < 2.5K
1071          *      80% of all file accesses are to files < 10K
1072          *      40% of all file I/O is to files > 25K
1073          *
1074          * static examination of the files in our file system
1075          * seems to support the claim that 50% of all files are
1076          * smaller than 2.5K
1077          */
1078         if (bufs < 50)  {
1079                 bufs = (randnum % 3) + 1;
1080                 size = 1024;
1081         } else if (bufs < 97) {
1082                 bufs = (randnum % 6) + 1;
1083                 size = BUFSIZE;
1084         } else {
1085                 bufs = MAXFILESIZE;
1086                 size = BUFSIZE;
1087         }
1088
1089         for (wrote = 0; wrote < bufs; wrote++) {
1090                 if (write(fd, buf, size) == -1) {
1091                         error("write");
1092                         break;
1093                 }
1094         }
1095
1096         return (wrote);
1097 }
1098
1099 int
1100 op_null(void)
1101 {
1102
1103         return (1);
1104 }
1105
1106
1107 /*
1108  * Generate a getattr call by fstat'ing the current file
1109  * or by closing and re-opening it. This helps to keep the
1110  * attribute cache cold.
1111  */
1112 int
1113 op_getattr(void)
1114 {
1115         struct stat statb;
1116
1117         if ((random() % 2) == 0) {
1118                 (void) close(Openfd[Curnum]);
1119                 Openfd[Curnum] = 0;
1120                 if (openfile() == -1) {
1121                         return (0);
1122                 }
1123                 return (2);
1124         }
1125         if (fstat(Openfd[Curnum], &statb) == -1) {
1126                 error("getattr");
1127         }
1128         return (1);
1129 }
1130
1131
1132 int op_setattr(void)
1133 {
1134
1135         if (fchmod(Openfd[Curnum], 0666) == -1) {
1136                 error("setattr");
1137         }
1138         return (1);
1139 }
1140
1141
1142 int op_root(void)
1143 {
1144
1145         error("root");
1146         return (0);
1147 }
1148
1149
1150 /*
1151  * Generate a lookup by stat'ing the current name.
1152  */
1153 int op_lookup(void)
1154 {
1155         struct stat statb;
1156
1157         if (stat(Curname, &statb) == -1) {
1158                 error("lookup");
1159         }
1160         return (1);
1161 }
1162
1163
1164 int op_read(void)
1165 {
1166         int got;
1167         int bufs;
1168         int fd;
1169         char buf[BUFSIZE];
1170
1171         bufs = 0;
1172         fd = Openfd[Curnum];
1173
1174         if (lseek(fd, 0L, 0) == (off_t) -1) {
1175                 error("read: lseek");
1176                 return (0);
1177         }
1178
1179         while ((got = read(fd, buf, sizeof (buf))) > 0) {
1180                 bufs++;
1181         }
1182
1183         if (got == -1) {
1184                 error("read");
1185         } else {
1186                 bufs++;         /* did one extra read to find EOF */
1187         }
1188         return (bufs);
1189 }
1190
1191
1192 int op_wrcache(void)
1193 {
1194         error("wrcache");
1195         return 0;
1196 }
1197
1198
1199 int op_write(void)
1200 {
1201         int bufs;
1202
1203         bufs = writefile();
1204         if (bufs == 0) {
1205                 return (0);
1206         }
1207         (void) fsync(Openfd[Curnum]);
1208
1209         return (bufs + 2);
1210 }
1211
1212
1213 int op_create(void)
1214 {
1215
1216         if (createfile() == -1) {
1217                 return (0);
1218         }
1219         return (1);
1220 }
1221
1222
1223 int op_remove(void)
1224 {
1225         int fd;
1226         int got;
1227
1228         if (Linknum > 0) {
1229                 got = unlink(Linkname);
1230                 Linknum--;
1231                 (void) sprintf(Linkname, Otherspec, LINSTR, Linknum);
1232         } else if (Symnum > 1) {
1233                 got = unlink(Symname);
1234                 Symnum--;
1235                 (void) sprintf(Symname, Otherspec, SYMSTR, Symnum);
1236         } else {
1237                 fd = Openfd[Curnum];
1238
1239                 if (fd && (close(fd) == -1)) {
1240                         error("remove: close");
1241                 }
1242                 Openfd[Curnum] = 0;
1243                 got = unlink(Curname);
1244         }
1245         if (got == -1) {
1246                 error("remove");
1247         }
1248         return (1);
1249 }
1250
1251
1252 int toggle = 0;
1253
1254 int op_rename(void)
1255 {
1256         int got;
1257
1258         if (toggle++ & 01) {
1259                 got = rename(Rename2, Rename1);
1260         } else {
1261                 got = rename(Rename1, Rename2);
1262         }
1263         if (got == -1) {
1264                 error("rename");
1265         }
1266         return (1);
1267 }
1268
1269
1270 int op_link(void)
1271 {
1272
1273         Linknum++;
1274         (void) sprintf(Linkname, Otherspec, LINSTR, Linknum);
1275         if (link(Curname, Linkname) == -1) {
1276                 error("link");
1277         }
1278         return (1);
1279 }
1280
1281
1282 int op_readlink(void)
1283 {
1284         char    buf[MAXPATHLEN];
1285
1286         if (Symnum == 0) {
1287                 error("readlink");
1288                 return (0);
1289         }
1290         if (readlink(Symname, buf, sizeof (buf)) == -1) {
1291                 error("readlink");
1292         }
1293         return (1);
1294 }
1295
1296
1297 int op_symlink(void)
1298 {
1299
1300         Symnum++;
1301         (void) sprintf(Symname, Otherspec, SYMSTR, Symnum);
1302         if (symlink(Symlinkpath, Symname) == -1) {
1303                 error("symlink");
1304         }
1305         return (1);
1306 }
1307
1308
1309 int op_mkdir(void)
1310 {
1311
1312         Dirnum++;
1313         (void) sprintf(Dirname, Otherspec, DIRSTR, Dirnum);
1314         if (mkdir(Dirname, 0777) == -1) {
1315                 error("mkdir");
1316         }
1317         return (1);
1318 }
1319
1320
1321 int op_rmdir(void)
1322 {
1323
1324         if (Dirnum == 0) {
1325                 error("rmdir");
1326                 return (0);
1327         }
1328         if (rmdir(Dirname) == -1) {
1329                 error("rmdir");
1330         }
1331         Dirnum--;
1332         (void) sprintf(Dirname, Otherspec, DIRSTR, Dirnum);
1333         return (1);
1334 }
1335
1336
1337 int op_readdir(void)
1338 {
1339
1340         rewinddir(Testdir);
1341         while (readdir(Testdir) != (struct dirent *)NULL)
1342                 /* nothing */;
1343         return (1);
1344 }
1345
1346
1347 int op_fsstat(void)
1348 {
1349         struct statfs statfsb;
1350
1351         if (statfs(".", &statfsb) == -1) {
1352                 error("statfs");
1353         }
1354         return (1);
1355 }
1356
1357
1358 /*
1359  * Utility routines
1360  */
1361
1362 /*
1363  * Read counter arrays out of log file and accumulate them in "Optime"
1364  */
1365 void
1366 collect_counters(void)
1367 {
1368         int i;
1369         int j;
1370
1371         (void) lseek(Log, 0L, 0);
1372
1373         for (i = 0; i < Nprocs; i++) {
1374                 struct timeval buf[NOPS+1];
1375
1376                 if (read(Log, (char *)buf, sizeof (buf)) == -1) {
1377                         Saveerrno = errno;
1378                         (void) fprintf(stderr, "%s: can't read log ", Myname);
1379                         errno = Saveerrno;
1380                         perror("");
1381                         (void) kill(0, SIGINT);
1382                         exit(1);
1383                 }
1384
1385                 for (j = 0; j < NOPS+1; j++) {
1386                         addtime(Optime[j], buf[j]);
1387                 }
1388         }
1389 }
1390
1391 /*
1392  * Check consistance of results
1393  */
1394 int
1395 check_counters(void)
1396 {
1397         int i;
1398         int mixdiff;
1399         int got;
1400         int want;
1401
1402         mixdiff = 0;
1403         for (i = 0; i < NOPS; i++) {
1404                 got = Curct.calls[i] * 10000 / Curct.total;
1405                 want = Mix[i] * 100;
1406                 if (got > want) {
1407                         mixdiff += got - want;
1408                 } else {
1409                         mixdiff += want - got;
1410                 }
1411         }
1412         if (mixdiff > 1000) {
1413                 (void) fprintf(stdout,
1414                     "%s: INVALID RUN, mix generated is off by %d.%02d%%\n",
1415                     Myname, mixdiff / 100, mixdiff % 100);
1416                 return (-1);
1417         }
1418         return (0);
1419 }
1420
1421 /*
1422  * Print results
1423  */
1424 void
1425 print(void)
1426 {
1427         int totalmsec;
1428         int runtime;
1429         int msec;
1430         int i;
1431
1432         totalmsec = 0;
1433         for (i = 0; i < NOPS; i++) {
1434                 totalmsec += Optime[i].tv_sec * 1000;
1435                 totalmsec += Optime[i].tv_usec / 1000;
1436         }
1437
1438         if (Verbose) {
1439            const char *format = sizeof (Optime[0].tv_sec) == sizeof (long)
1440              ? "%-10s%3d%%    %2d.%02d%%   %6d   %4ld.%02ld    %4d.%02d    %2d.%02d%%\n"
1441              : "%-10s%3d%%    %2d.%02d%%   %6d   %4d.%02d    %4d.%02d    %2d.%02d%%\n";
1442                 (void) fprintf(stdout,
1443 "op        want       got    calls      secs  msec/call    time %%\n");
1444                 for (i = 0; i < NOPS; i++) {
1445                         msec = Optime[i].tv_sec * 1000
1446                             + Optime[i].tv_usec / 1000;
1447                         (void) fprintf(stdout, format,
1448                             Opnames[i], Mix[i],
1449                             Curct.calls[i] * 100 / Curct.total,
1450                             (Curct.calls[i] * 100 % Curct.total)
1451                                 * 100 / Curct.total,
1452                             Curct.calls[i],
1453                             Optime[i].tv_sec, Optime[i].tv_usec / 10000,
1454                             Curct.calls[i]
1455                                 ? msec / Curct.calls[i]
1456                                 : 0,
1457                             Curct.calls[i]
1458                                 ? (msec % Curct.calls[i]) * 100 / Curct.calls[i]
1459                                 : 0,
1460                             msec * 100 / totalmsec,
1461                             (msec * 100 % totalmsec) * 100 / totalmsec);
1462                 }
1463         }
1464
1465         runtime = Optime[NOPS].tv_sec / Nprocs;
1466         (void) fprintf(stdout,
1467             "%d sec %d calls %d.%02d calls/sec %d.%02d msec/call\n",
1468             runtime, Curct.total,
1469             Curct.total / runtime,
1470             ((Curct.total % runtime) * 100) / runtime,
1471             totalmsec / Curct.total,
1472             ((totalmsec % Curct.total) * 100) / Curct.total);
1473 }
1474
1475 /*
1476  * Use select to sleep for some number of milliseconds
1477  * granularity is 20 msec
1478  */
1479 void
1480 msec_sleep(int msecs)
1481 {
1482         struct timeval sleeptime;
1483
1484         if (msecs < 20) {
1485                 return;
1486         }
1487         sleeptime.tv_sec = msecs / 1000;
1488         sleeptime.tv_usec = (msecs % 1000) * 1000;
1489
1490         if (select(0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &sleeptime) == -1){
1491                 Saveerrno = errno;
1492                 (void) fprintf(stderr, "%s: select failed ", Myname);
1493                 errno = Saveerrno;
1494                 perror("");
1495                 (void) kill(0, SIGINT);
1496                 exit(1);
1497         }
1498 }
1499
1500 /*
1501  * Open the synchronization file with append mode
1502  */
1503 void
1504 init_logfile(void)
1505 {
1506
1507         (void) sprintf(Logname, "/tmp/nhfsstone%d", getpid());
1508         if ((Log = open(Logname, O_RDWR|O_CREAT|O_TRUNC|O_APPEND, 0666)) == -1){
1509                 Saveerrno = errno;
1510                 (void) fprintf(stderr,
1511                     "%s: can't open log file %s ", Myname, Logname);
1512                 errno = Saveerrno;
1513                 perror("");
1514                 exit(1);
1515         }
1516 }
1517
1518 /*
1519  * Zero counters
1520  */
1521 void
1522 init_counters(void)
1523 {
1524         int i;
1525
1526         Curct.total = 0;
1527         for (i = 0; i < NOPS; i++) {
1528                 Curct.calls[i] = 0;
1529                 Optime[i].tv_sec = 0;
1530                 Optime[i].tv_usec = 0;
1531         }
1532         Optime[NOPS].tv_sec = 0;
1533         Optime[NOPS].tv_usec = 0;
1534 }
1535
1536 /*
1537  * Set cur = cur - start
1538  */
1539 void
1540 get_delta(struct count *start, struct count *cur)
1541 {
1542         int i;
1543
1544         get_opct(cur);
1545         cur->total -= start->total;
1546         for (i = 0; i < NOPS; i++) {
1547                 cur->calls[i] -= start->calls[i];
1548         }
1549 }
1550
1551 /*
1552  * Read kernel stats
1553  */
1554 void
1555 get_opct(struct count *count)
1556 {
1557         static FILE     *fp = NULL;
1558         char            buffer[256];
1559         int i;
1560
1561         if (fp == NULL && !(fp = fopen("/proc/net/rpc/nfs", "r"))) {
1562                 perror("/proc/net/rpc/nfs");
1563                 (void) kill(0, SIGINT);
1564                 exit(1);
1565         } else {
1566                 fflush(fp);
1567                 rewind(fp);
1568         }
1569
1570         while (fgets(buffer, sizeof(buffer), fp) != NULL) {
1571                 char    *sp, *line = buffer;
1572
1573                 if ((sp = strchr(line, '\n')) != NULL)
1574                         *sp = '\0';
1575                 if (!(sp = strtok(line, " \t")) || strcmp(line, "proc2"))
1576                         continue;
1577                 if (!(sp = strtok(NULL, " \t")))
1578                         goto bummer;
1579                 count->total = 0;
1580                 for (i = 0; i < 18; i++) {
1581                         if (!(sp = strtok(NULL, " \t")))
1582                                 goto bummer;
1583                         /* printf("call %d -> %s\n", i, sp); */
1584                         count->calls[i] = atoi(sp);
1585                         count->total += count->calls[i];
1586                 }
1587                 /* printf("total calls %d\n", count->total); */
1588                 break;
1589         }
1590
1591         return;
1592
1593 bummer:
1594         fprintf(stderr, "parse error in /proc/net/rpc/nfs!\n");
1595         kill(0, SIGINT);
1596         exit(1);
1597 }
1598
1599 #define LINELEN         128             /* max bytes/line in mix file */
1600 #define MIX_START       0
1601 #define MIX_DATALINE    1
1602 #define MIX_DONE        2
1603 #define MIX_FIRSTLINE   3
1604
1605 /*
1606  * Mix file parser.
1607  * Assumes that the input file is in the same format as
1608  * the output of the nfsstat(8) command.
1609  *
1610  * Uses a simple state transition to keep track of what to expect.
1611  * Parsing is done a line at a time.
1612  *
1613  * State           Input                action          New state
1614  * MIX_START       ".*nfs:.*"           skip one line   MIX_FIRSTLINE
1615  * MIX_FIRSTLINE   ".*[0-9]*.*"         get ncalls      MIX_DATALINE
1616  * MIX_DATALINE    "[0-9]* [0-9]*%"X6   get op counts   MIX_DATALINE
1617  * MIX_DATALINE    "[0-9]* [0-9]*%"X4   get op counts   MIX_DONE
1618  * MIX_DONE        EOF                  return
1619  */
1620 int
1621 setmix(FILE *fp)
1622 {
1623         int state;
1624         int got;
1625         int opnum;
1626         int calls;
1627         int len;
1628         char line[LINELEN];
1629
1630         state = MIX_START;
1631         opnum = 0;
1632
1633         while (state != MIX_DONE && fgets(line, LINELEN, fp)) {
1634
1635                 switch (state) {
1636
1637                 case MIX_START:
1638                         len = strlen(line);
1639                         if (len >= 4 && substr(line, "nfs:")) {
1640                                 if (fgets(line, LINELEN, fp) == NULL) {
1641                                         (void) fprintf(stderr,
1642 "%s: bad mix format: unexpected EOF after 'nfs:'\n", Myname);
1643                                         return (-1);
1644                                 }
1645                                 state = MIX_FIRSTLINE;
1646                         }
1647                         break;
1648
1649                 case MIX_FIRSTLINE:
1650                         got = sscanf(line, "%d", &calls);
1651                         if (got != 1) {
1652                                 (void) fprintf(stderr,
1653 "%s: bad mix format: can't find 'calls' value %d\n", Myname, got);
1654                                 return (-1);
1655                         }
1656                         if (fgets(line, LINELEN, fp) == NULL) {
1657                                 (void) fprintf(stderr,
1658 "%s: bad mix format: unexpected EOF after 'calls'\n", Myname);
1659                                 return (-1);
1660                         }
1661                         state = MIX_DATALINE;
1662                         break;
1663
1664                 case MIX_DATALINE:
1665                         got = sscanf(line,
1666         "%d %*d%% %d %*d%% %d %*d%% %d %*d%% %d %*d%% %d %*d%% %d %*d%%",
1667         &Mix[opnum], &Mix[opnum+1], &Mix[opnum+2], &Mix[opnum+3],
1668         &Mix[opnum+4], &Mix[opnum+5], &Mix[opnum+6]);
1669                         if (got == 4 && opnum == 14) {
1670                                 /*
1671                                  * looks like the last line
1672                                  */
1673                                 state = MIX_DONE;
1674                         } else if (got == 7) {
1675                                 opnum += 7;
1676                                 if (fgets(line, LINELEN, fp) == NULL) {
1677                                         (void) fprintf(stderr,
1678 "%s: bad mix format: unexpected EOF after 'calls'\n", Myname);
1679                                         return (-1);
1680                                 }
1681                         } else {
1682                                 (void) fprintf(stderr,
1683 "%s: bad mix format: can't find %d op values\n", Myname, got);
1684                                 return (-1);
1685                         }
1686                         break;
1687                 default:
1688                         (void) fprintf(stderr,
1689                             "%s: unknown state %d\n", Myname, state);
1690                         return (-1);
1691                 }
1692         }
1693         if (state != MIX_DONE) {
1694                 (void) fprintf(stderr,
1695                     "%s: bad mix format: unexpected EOF\n", Myname);
1696                 return (-1);
1697         }
1698         for (opnum = 0; opnum < NOPS; opnum++) {
1699                 Mix[opnum] = Mix[opnum] * 100 / calls
1700                     + ((Mix[opnum] * 1000 / calls % 10) >= 5);
1701         }
1702         return (0);
1703 }
1704
1705 /*
1706  * return true if sp contains the substring subsp, false otherwise
1707  */
1708 int
1709 substr(char *sp, char *subsp)
1710 {
1711         int found;
1712         int want;
1713         char *s2;
1714
1715         if (sp == NULL || subsp == NULL) {
1716                 return (0);
1717         }
1718
1719         want = strlen(subsp);
1720
1721         while (*sp != '\0') {
1722                 while (*sp != *subsp && *sp != '\0') {
1723                         sp++;
1724                 }
1725                 found = 0;
1726                 s2 = subsp;
1727                 while (*sp == *s2) {
1728                         sp++;
1729                         s2++;
1730                         found++;
1731                 }
1732                 if (found == want) {
1733                         return (1);
1734                 }
1735         }
1736         return (0);
1737 }
1738
1739 /*
1740  * check to make sure that we have
1741  * both read and write permissions
1742  * for this file or directory.
1743  */
1744 int
1745 check_access(struct stat statb)
1746 {
1747         int gidsetlen;
1748         gid_t gidset[NGROUPS];
1749         int i;
1750
1751         if (statb.st_uid == getuid()) {
1752                 if ((statb.st_mode & 0200) && (statb.st_mode & 0400)) {
1753                         return 1;
1754                 } else {
1755                         return -1;
1756                 }
1757         }
1758
1759         gidsetlen = NGROUPS;
1760
1761         if (getgroups(gidsetlen, gidset) == -1) {
1762                 perror("getgroups");
1763                 return -1;
1764         }
1765
1766         for (i = 0; i < NGROUPS; i++) {
1767                 if (statb.st_gid == gidset[i]) {
1768                         if ((statb.st_mode & 020) && (statb.st_mode & 040)) {
1769                                 return 1;
1770                         } else {
1771                                 return -1;
1772                         }
1773                 }
1774         }
1775
1776         if ((statb.st_mode & 02) && (statb.st_mode & 04)) {
1777                 return 1;
1778         } else {
1779                 return -1;
1780         }
1781 }
1782
1783 void
1784 usage(void)
1785 {
1786
1787         (void) fprintf(stderr, "usage: %s [-v] [[-t secs] | [-c calls]] [-l load] [-p nprocs] [-m mixfile] [dir]...\n", Myname);
1788 }
1789
1790 void
1791 error(char *str)
1792 {
1793
1794         Saveerrno = errno;
1795         (void) fprintf(stderr, "%s: op failed: %s ", Myname, str);
1796         errno = Saveerrno;
1797         perror("");
1798 }