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