hpux-1123-update-20031204
[openafs.git] / src / afsd / afsd.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /*
11   *         Information Technology Center
12   *         October 1987
13   *
14   * Description:
15   *     The Andrew File System startup process.  It is responsible for
16   * reading and parsing the various configuration files, starting up
17   * the kernel processes required by AFS and feeding the configuration
18   * information to the kernel.
19   *
20   * Recognized flags are:
21   *     -blocks     The number of blocks available in the workstation cache.
22   *     -files      The target number of files in the workstation cache (Default:
23   *                 1000).
24   *     -rootvol            The name of the root volume to use.
25   *     -stat       The number of stat cache entries.
26   *     -hosts      List of servers to check for volume location info FOR THE
27   *                 HOME CELL.
28   *     -memcache   Use an in-memory cache rather than disk.
29   *     -cachedir    The base directory for the workstation cache.
30   *     -mountdir   The directory on which the AFS is to be mounted.
31   *     -confdir    The configuration directory .
32   *     -nosettime  Don't keep checking the time to avoid drift.
33   *     -verbose     Be chatty.
34   *     -debug     Print out additional debugging info.
35   *     -kerndev    [OBSOLETE] The kernel device for AFS.
36   *     -dontfork   [OBSOLETE] Don't fork off as a new process.
37   *     -daemons   The number of background daemons to start (Default: 2).
38   *     -rmtsys    Also fires up an afs remote sys call (e.g. pioctl, setpag)
39   *                support daemon 
40   *     -chunksize [n]   2^n is the chunksize to be used.  0 is default.
41   *     -dcache    The number of data cache entries.
42   *     -biods     Number of bkg I/O daemons (AIX3.1 only)
43   *     -prealloc  Number of preallocated "small" memory blocks
44   *     -pininodes Number of inodes which can be spared from inode[] for 
45   *                pointing at Vfiles.  If this is set too high, you may have
46   *                system problems, which can only be ameliorated by changing
47   *                NINODE (or equivalent) and rebuilding the kernel.
48   *                This option is now disabled.
49   *     -logfile   Place where to put the logfile (default in <cache>/etc/AFSLog.
50   *     -waitclose make close calls always synchronous (slows em down, tho)
51   *     -files_per_subdir [n]   number of files per cache subdir. (def=2048)
52   *     -shutdown  Shutdown afs daemons
53   *---------------------------------------------------------------------------*/
54
55 #include <afsconfig.h>
56 #include <afs/param.h>
57
58 RCSID
59     ("$Header$");
60
61 #define VFS 1
62
63 #include <afs/cmd.h>
64
65 #include <assert.h>
66 #include <potpourri.h>
67 #include <afs/afsutil.h>
68 #include <stdlib.h>
69 #include <stdio.h>
70 #include <signal.h>
71 #include <string.h>
72 #include <stdlib.h>
73 #include <time.h>
74 #include <sys/types.h>
75 #include <sys/stat.h>
76 #include <sys/file.h>
77 #include <errno.h>
78 #include <sys/time.h>
79 #include <dirent.h>
80
81 #ifdef HAVE_SYS_PARAM_H
82 #include <sys/param.h>
83 #endif
84
85 #ifdef HAVE_SYS_FS_TYPES_H
86 #include <sys/fs_types.h>
87 #endif
88
89 #ifdef HAVE_SYS_MOUNT_H
90 #include <sys/mount.h>
91 #endif
92
93 #ifdef HAVE_SYS_FCNTL_H
94 #include <sys/fcntl.h>
95 #endif
96
97 #ifdef HAVE_SYS_MNTTAB_H
98 #include <sys/mnttab.h>
99 #endif
100
101 #ifdef HAVE_SYS_MNTENT_H
102 #include <sys/mntent.h>
103 #endif
104
105 #ifdef HAVE_MNTENT_H
106 #include <mntent.h>
107 #endif
108
109 #ifdef HAVE_SYS_MOUNT_H
110 #include <sys/mount.h>
111 #endif
112
113 #ifdef HAVE_SYS_VFS_H
114 #include <sys/vfs.h>
115 #endif
116
117 #ifdef HAVE_SYS_FSTYP_H
118 #include <sys/fstyp.h>
119 #endif
120
121 #ifdef HAVE_UNISTD_H
122 #include <unistd.h>
123 #endif
124
125 #ifdef HAVE_FCNTL_H
126 #include <fcntl.h>
127 #endif
128
129 #include <netinet/in.h>
130 #include <afs/afs_args.h>
131 #include <afs/cellconfig.h>
132 #include <afs/auth.h>
133 #include <ctype.h>
134 #include <afs/afssyscalls.h>
135 #include <afs/afsutil.h>
136
137 #ifdef AFS_SGI61_ENV
138 #include <unistd.h>
139 #include <libelf.h>
140 #include <dwarf.h>
141 #include <libdwarf.h>
142 void set_staticaddrs(void);
143 #endif /* AFS_SGI61_ENV */
144 #if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
145 #include <sym.h>
146 #include <symconst.h>
147 #endif
148 #ifdef AFS_SGI65_ENV
149 #include <sched.h>
150 #endif
151 #ifdef AFS_LINUX20_ENV
152 #include <sys/resource.h>
153 #endif
154 #ifdef AFS_DARWIN_ENV
155 #include <mach/mach.h>
156 /* Symbols from the DiskArbitration framework */
157 kern_return_t DiskArbStart(mach_port_t *);
158 kern_return_t DiskArbDiskAppearedWithMountpointPing_auto(char *, unsigned int,
159                                                          char *);
160 #define DISK_ARB_NETWORK_DISK_FLAG 8
161 #endif /* AFS_DARWIN_ENV */
162
163 #ifndef MOUNT_AFS
164 #define MOUNT_AFS AFS_MOUNT_AFS
165 #endif /* MOUNT_AFS */
166
167 #if AFS_HAVE_STATVFS
168 #include <sys/statvfs.h>
169 #else
170 #if defined(AFS_SUN_ENV)
171 #include <sys/vfs.h>
172 #else
173 #if !defined(AFS_OSF_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_XBSD_ENV)
174 #include <sys/statfs.h>
175 #endif
176 #endif
177 #endif
178
179 #undef  VIRTUE
180 #undef  VICE
181
182 #define CACHEINFOFILE   "cacheinfo"
183 #define AFSLOGFILE      "AFSLog"
184 #define DCACHEFILE      "CacheItems"
185 #define VOLINFOFILE     "VolumeItems"
186 #define CELLINFOFILE    "CellItems"
187
188 #define MAXIPADDRS 1024
189
190 char LclCellName[64];
191
192 #define MAX_CACHE_LOOPS 4
193
194 /*
195  * Internet address (old style... should be updated).  This was pulled out of the old 4.2
196  * version of <netinet/in.h>, since it's still useful.
197  */
198 struct in_addr_42 {
199     union {
200         struct {
201             u_char s_b1, s_b2, s_b3, s_b4;
202         } S_un_b;
203         struct {
204             u_short s_w1, s_w2;
205         } S_un_w;
206         afs_uint32 S_addr;
207     } S_un;
208 #define s_host  S_un.S_un_b.s_b2        /* host on imp */
209 #define s_net   S_un.S_un_b.s_b1        /* network */
210 #define s_imp   S_un.S_un_w.s_w2        /* imp */
211 #define s_impno S_un.S_un_b.s_b4        /* imp # */
212 #define s_lh    S_un.S_un_b.s_b3        /* logical host */
213 };
214
215 #define mPrintIPAddr(ipaddr)  printf("[%d.%d.%d.%d] ",          \
216       ((struct in_addr_42 *) &(ipaddr))->S_un.S_un_b.s_b1,      \
217       ((struct in_addr_42 *) &(ipaddr))->S_un.S_un_b.s_b2,      \
218       ((struct in_addr_42 *) &(ipaddr))->S_un.S_un_b.s_b3,      \
219       ((struct in_addr_42 *) &(ipaddr))->S_un.S_un_b.s_b4)
220
221 /*
222  * Global configuration variables.
223  */
224 afs_int32 afs_shutdown = 0;
225 afs_int32 cacheBlocks;          /*Num blocks in the cache */
226 afs_int32 cacheFiles = 1000;    /*Optimal # of files in workstation cache */
227 afs_int32 cacheStatEntries = 300;       /*Number of stat cache entries */
228 char cacheBaseDir[1024];        /*Where the workstation AFS cache lives */
229 char confDir[1024];             /*Where the workstation AFS configuration lives */
230 char fullpn_DCacheFile[1024];   /*Full pathname of DCACHEFILE */
231 char fullpn_VolInfoFile[1024];  /*Full pathname of VOLINFOFILE */
232 char fullpn_CellInfoFile[1024]; /*Full pathanem of CELLINFOFILE */
233 char fullpn_AFSLogFile[1024];   /*Full pathname of AFSLOGFILE */
234 char fullpn_CacheInfo[1024];    /*Full pathname of CACHEINFO */
235 char fullpn_VFile[1024];        /*Full pathname of data cache files */
236 char *vFilePtr;                 /*Ptr to the number part of above pathname */
237 int sawCacheMountDir = 0;       /* from cmd line */
238 int sawCacheBaseDir = 0;
239 int sawCacheBlocks = 0;
240 int sawDCacheSize = 0;
241 int sawBiod = 0;
242 char cacheMountDir[1024];       /*Mount directory for AFS */
243 char rootVolume[64] = "root.afs";       /*AFS root volume name */
244 afs_int32 cacheSetTime = 1;     /*Keep checking time to avoid drift? */
245 afs_int32 isHomeCell;           /*Is current cell info for the home cell? */
246 #ifdef AFS_XBSD_ENV
247 int createAndTrunc = O_RDWR | O_CREAT | O_TRUNC;        /*Create & truncate on open */
248 #else
249 int createAndTrunc = O_CREAT | O_TRUNC; /*Create & truncate on open */
250 #endif
251 int ownerRWmode = 0600;         /*Read/write OK by owner */
252 static int filesSet = 0;        /*True if number of files explicitly set */
253 static int nFilesPerDir = 2048; /* # files per cache dir */
254 static int nDaemons = 2;        /* Number of background daemons */
255 static int chunkSize = 0;       /* 2^chunkSize bytes per chunk */
256 static int dCacheSize = 300;    /* # of dcache entries */
257 static int vCacheSize = 50;     /* # of volume cache entries */
258 static int rootVolSet = 0;      /*True if root volume name explicitly set */
259 int addrNum;                    /*Cell server address index being printed */
260 static int cacheFlags = 0;      /*Flags to cache manager */
261 static int nBiods = 5;          /* AIX3.1 only */
262 static int preallocs = 400;     /* Def # of allocated memory blocks */
263 static int enable_peer_stats = 0;       /* enable rx stats */
264 static int enable_process_stats = 0;    /* enable rx stats */
265 #ifdef AFS_AFSDB_ENV
266 static int enable_afsdb = 0;    /* enable AFSDB support */
267 #endif
268 static int enable_dynroot = 0;  /* enable dynroot support */
269 static int enable_fakestat = 0; /* enable fakestat support */
270 static int enable_backuptree = 0;       /* enable backup tree support */
271 static int enable_nomount = 0;  /* do not mount */
272 #ifdef notdef
273 static int inodes = 60;         /* VERY conservative, but has to be */
274 #endif
275 int afsd_verbose = 0;           /*Are we being chatty? */
276 int afsd_debug = 0;             /*Are we printing debugging info? */
277 int afsd_CloseSynch = 0;        /*Are closes synchronous or not? */
278
279 #ifdef AFS_SGI62_ENV
280 #define AFSD_INO_T ino64_t
281 #else
282 #define AFSD_INO_T afs_uint32
283 #endif
284 struct afsd_file_list {
285     int fileNum;
286     struct afsd_file_list *next;
287 };
288 struct afsd_file_list **cache_dir_filelist = NULL;
289 int *cache_dir_list = NULL;     /* Array of cache subdirs */
290 int *dir_for_V = NULL;          /* Array: dir of each cache file.
291                                  * -1: file does not exist
292                                  * -2: file exists in top-level
293                                  * >=0: file exists in Dxxx
294                                  */
295 AFSD_INO_T *inode_for_V;        /* Array of inodes for desired
296                                  * cache files */
297 int missing_DCacheFile = 1;     /*Is the DCACHEFILE missing? */
298 int missing_VolInfoFile = 1;    /*Is the VOLINFOFILE missing? */
299 int missing_CellInfoFile = 1;   /*Is the CELLINFOFILE missing? */
300 int afsd_rmtsys = 0;            /* Default: don't support rmtsys */
301 struct afs_cacheParams cparams; /* params passed to cache manager */
302
303 static int HandleMTab();
304
305 /* ParseArgs is now obsolete, being handled by cmd */
306
307 /*------------------------------------------------------------------------------
308   * ParseCacheInfoFile
309   *
310   * Description:
311   *     Open the file containing the description of the workstation's AFS cache
312   *     and pull out its contents.  The format of this file is as follows:
313   *
314   *         cacheMountDir:cacheBaseDir:cacheBlocks
315   *
316   * Arguments:
317   *     None.
318   *
319   * Returns:
320   *     0 if everything went well,
321   *     1 otherwise.
322   *
323   * Environment:
324   *     Nothing interesting.
325   *
326   *  Side Effects:
327   *     Sets globals.
328   *---------------------------------------------------------------------------*/
329
330 int
331 ParseCacheInfoFile()
332 {
333     static char rn[] = "ParseCacheInfoFile";    /*This routine's name */
334     FILE *cachefd;              /*Descriptor for cache info file */
335     int parseResult;            /*Result of our fscanf() */
336     afs_int32 tCacheBlocks;
337     char tCacheBaseDir[1024], *tbd, tCacheMountDir[1024], *tmd;
338
339     if (afsd_debug)
340         printf("%s: Opening cache info file '%s'...\n", rn, fullpn_CacheInfo);
341
342     cachefd = fopen(fullpn_CacheInfo, "r");
343     if (!cachefd) {
344         printf("%s: Can't read cache info file '%s'\n", rn, fullpn_CacheInfo);
345         return (1);
346     }
347
348     /*
349      * Parse the contents of the cache info file.  All chars up to the first
350      * colon are the AFS mount directory, all chars to the next colon are the
351      * full path name of the workstation cache directory and all remaining chars
352      * represent the number of blocks in the cache.
353      */
354     tCacheMountDir[0] = tCacheBaseDir[0] = '\0';
355     parseResult =
356         fscanf(cachefd, "%1024[^:]:%1024[^:]:%d", tCacheMountDir,
357                tCacheBaseDir, &tCacheBlocks);
358
359     /*
360      * Regardless of how the parse went, we close the cache info file.
361      */
362     fclose(cachefd);
363
364     if (parseResult == EOF || parseResult < 3) {
365         printf("%s: Format error in cache info file!\n", rn);
366         if (parseResult == EOF)
367             printf("\tEOF encountered before any field parsed.\n");
368         else
369             printf("\t%d out of 3 fields successfully parsed.\n",
370                    parseResult);
371
372         return (1);
373     }
374
375     for (tmd = tCacheMountDir; *tmd == '\n' || *tmd == ' ' || *tmd == '\t';
376          tmd++);
377     for (tbd = tCacheBaseDir; *tbd == '\n' || *tbd == ' ' || *tbd == '\t';
378          tbd++);
379     /* now copy in the fields not explicitly overridden by cmd args */
380     if (!sawCacheMountDir)
381         strcpy(cacheMountDir, tmd);
382     if (!sawCacheBaseDir)
383         strcpy(cacheBaseDir, tbd);
384     if (!sawCacheBlocks)
385         cacheBlocks = tCacheBlocks;
386
387     if (afsd_debug) {
388         printf("%s: Cache info file successfully parsed:\n", rn);
389         printf
390             ("\tcacheMountDir: '%s'\n\tcacheBaseDir: '%s'\n\tcacheBlocks: %d\n",
391              tmd, tbd, tCacheBlocks);
392     }
393     if (!(cacheFlags & AFSCALL_INIT_MEMCACHE))
394         PartSizeOverflow(tbd, cacheBlocks);
395
396     return (0);
397 }
398
399 /*
400  * All failures to open the partition are ignored. Also if the cache dir 
401  * isn't a mounted partition it's also ignored since we can't guarantee 
402  * what will be stored afterwards. Too many if's. This is now purely
403  * advisory. ODS with over 2G partition also gives warning message.
404  */
405 PartSizeOverflow(path, cs)
406      char *path;
407      int cs;
408 {
409     int bsize = -1, totalblks, mint;
410 #if AFS_HAVE_STATVFS
411     struct statvfs statbuf;
412
413     if (statvfs(path, &statbuf) != 0) {
414         if (afsd_debug)
415             printf
416                 ("statvfs failed on %s; skip checking for adequate partition space\n",
417                  path);
418         return 0;
419     }
420     totalblks = statbuf.f_blocks;
421     bsize = statbuf.f_frsize;
422 #else
423     struct statfs statbuf;
424
425     if (statfs(path, &statbuf) < 0) {
426         if (afsd_debug)
427             printf
428                 ("statfs failed on %s; skip checking for adequate partition space\n",
429                  path);
430         return 0;
431     }
432     totalblks = statbuf.f_blocks;
433     bsize = statbuf.f_bsize;
434 #endif
435     if (bsize == -1)
436         return 0;               /* sucess */
437
438     /* now free and totalblks are in fragment units, but we want them in 1K units */
439     if (bsize >= 1024) {
440         totalblks *= (bsize / 1024);
441     } else {
442         totalblks /= (1024 / bsize);
443     }
444
445     mint = totalblks - ((totalblks * 5) / 100);
446     if (cs > mint) {
447         printf
448             ("Cache size (%d) must be less than 95%% of partition size (which is %d). Lower cache size\n",
449              cs, mint);
450     }
451 }
452
453 /*-----------------------------------------------------------------------------
454   * GetVFileNumber
455   *
456   * Description:
457   *     Given the final component of a filename expected to be a data cache file,
458   *     return the integer corresponding to the file.  Note: we reject names that
459   *     are not a ``V'' followed by an integer.  We also reject those names having
460   *     the right format but lying outside the range [0..cacheFiles-1].
461   *
462   * Arguments:
463   *     fname : Char ptr to the filename to parse.
464   *     max   : integer for the highest number to accept
465   *
466   * Returns:
467   *     >= 0 iff the file is really a data cache file numbered from 0 to cacheFiles-1, or
468   *     -1      otherwise.
469   *
470   * Environment:
471   *     Nothing interesting.
472   *
473   * Side Effects:
474   *     None.
475   *---------------------------------------------------------------------------*/
476
477 static int
478 doGetXFileNumber(fname, filechar, maxNum)
479      char *fname;
480      char filechar;
481      int maxNum;
482 {
483     int computedVNumber;        /*The computed file number we return */
484     int filenameLen;            /*Number of chars in filename */
485     int currDigit;              /*Current digit being processed */
486
487     /*
488      * The filename must have at least two characters, the first of which must be a ``filechar''
489      * and the second of which cannot be a zero unless the file is exactly two chars long.
490      */
491     filenameLen = strlen(fname);
492     if (filenameLen < 2)
493         return (-1);
494     if (fname[0] != filechar)
495         return (-1);
496     if ((filenameLen > 2) && (fname[1] == '0'))
497         return (-1);
498
499     /*
500      * Scan through the characters in the given filename, failing immediately if a non-digit
501      * is found.
502      */
503     for (currDigit = 1; currDigit < filenameLen; currDigit++)
504         if (isdigit(fname[currDigit]) == 0)
505             return (-1);
506
507     /*
508      * All relevant characters are digits.  Pull out the decimal number they represent.
509      * Reject it if it's out of range, otherwise return it.
510      */
511     computedVNumber = atoi(++fname);
512     if (computedVNumber < cacheFiles)
513         return (computedVNumber);
514     else
515         return (-1);
516 }
517
518 int
519 GetVFileNumber(fname, maxFile)
520      char *fname;
521      int maxFile;
522 {
523     return doGetXFileNumber(fname, 'V', maxFile);
524 }
525
526 int
527 GetDDirNumber(fname, maxDir)
528      char *fname;
529      int maxDir;
530 {
531     return doGetXFileNumber(fname, 'D', maxDir);
532 }
533
534
535 /*-----------------------------------------------------------------------------
536   * CreateCacheFile
537   *
538   * Description:
539   *     Given a full pathname for a file we need to create for the workstation AFS
540   *     cache, go ahead and create the file.
541   *
542   * Arguments:
543   *     fname : Full pathname of file to create.
544   *     statp : A pointer to a stat buffer which, if NON-NULL, will be
545   *             filled by fstat()
546   *
547   * Returns:
548   *     0   iff the file was created,
549   *     -1  otherwise.
550   *
551   * Environment:
552   *     The given cache file has been found to be missing.
553   *
554   * Side Effects:
555   *     As described.
556   *---------------------------------------------------------------------------*/
557
558 static int
559 CreateCacheSubDir(basename, dirNum)
560      char *basename;
561      int dirNum;
562 {
563     static char rn[] = "CreateCacheSubDir";     /* Routine Name */
564     char dir[1024];
565     int ret;
566
567     /* Build the new cache subdirectory */
568     sprintf(dir, "%s/D%d", basename, dirNum);
569
570     if (afsd_verbose)
571         printf("%s: Creating cache subdir '%s'\n", rn, dir);
572
573     if ((ret = mkdir(dir, 0700)) != 0) {
574         printf("%s: Can't create '%s', error return is %d (%d)\n", rn, dir,
575                ret, errno);
576         if (errno != EEXIST)
577             return (-1);
578     }
579
580     /* Mark this directory as created */
581     cache_dir_list[dirNum] = 0;
582
583     /* And return success */
584     return (0);
585 }
586
587 static int
588 MoveCacheFile(basename, fromDir, toDir, cacheFile, maxDir)
589      char *basename;
590      int fromDir, toDir, cacheFile, maxDir;
591 {
592     static char rn[] = "MoveCacheFile";
593     char from[1024], to[1024];
594     int ret;
595
596     if (cache_dir_list[toDir] < 0
597         && (ret = CreateCacheSubDir(basename, toDir))) {
598         printf("%s: Can't create directory '%s/D%d'\n", rn, basename, toDir);
599         return ret;
600     }
601
602     /* Build the from,to dir */
603     if (fromDir < 0) {
604         /* old-style location */
605         snprintf(from, sizeof(from), "%s/V%d", basename, cacheFile);
606     } else {
607         snprintf(from, sizeof(from), "%s/D%d/V%d", basename, fromDir,
608                  cacheFile);
609     }
610
611     snprintf(to, sizeof(from), "%s/D%d/V%d", basename, toDir, cacheFile);
612
613     if (afsd_verbose)
614         printf("%s: Moving cacheFile from '%s' to '%s'\n", rn, from, to);
615
616     if ((ret = rename(from, to)) != 0) {
617         printf("%s: Can't rename '%s' to '%s', error return is %d (%d)\n", rn,
618                from, to, ret, errno);
619         return -1;
620     }
621
622     /* Reset directory pointer; fix file counts */
623     dir_for_V[cacheFile] = toDir;
624     cache_dir_list[toDir]++;
625     if (fromDir < maxDir && fromDir >= 0)
626         cache_dir_list[fromDir]--;
627
628     return 0;
629 }
630
631 int
632 CreateCacheFile(fname, statp)
633      char *fname;
634      struct stat *statp;
635 {
636     static char rn[] = "CreateCacheFile";       /*Routine name */
637     int cfd;                    /*File descriptor to AFS cache file */
638     int closeResult;            /*Result of close() */
639
640     if (afsd_verbose)
641         printf("%s: Creating cache file '%s'\n", rn, fname);
642     cfd = open(fname, createAndTrunc, ownerRWmode);
643     if (cfd <= 0) {
644         printf("%s: Can't create '%s', error return is %d (%d)\n", rn, fname,
645                cfd, errno);
646         return (-1);
647     }
648     if (statp != NULL) {
649         closeResult = fstat(cfd, statp);
650         if (closeResult) {
651             printf
652                 ("%s: Can't stat newly-created AFS cache file '%s' (code %d)\n",
653                  rn, fname, errno);
654             return (-1);
655         }
656     }
657     closeResult = close(cfd);
658     if (closeResult) {
659         printf
660             ("%s: Can't close newly-created AFS cache file '%s' (code %d)\n",
661              rn, fname, errno);
662         return (-1);
663     }
664
665     return (0);
666 }
667
668 static void
669 CreateFileIfMissing(char *fullpn, int missing)
670 {
671     if (missing) {
672         if (afsd_verbose)
673             printf("CreateFileIfMissing: Creating '%s'\n", fullpn);
674         if (CreateCacheFile(fullpn, NULL))
675             printf("CreateFileIfMissing: Can't create '%s'\n", fullpn);
676     }
677 }
678
679 /*-----------------------------------------------------------------------------
680   * SweepAFSCache
681   *
682   * Description:
683   *     Sweep through the AFS cache directory, recording the inode number for
684   *     each valid data cache file there.  Also, delete any file that doesn't belong
685   *     in the cache directory during this sweep, and remember which of the other
686   *     residents of this directory were seen.  After the sweep, we create any data
687   *     cache files that were missing.
688   *
689   * Arguments:
690   *     vFilesFound : Set to the number of data cache files found.
691   *
692   * Returns:
693   *     0   if everything went well,
694   *     -1 otherwise.
695   *
696   * Environment:
697   *     This routine may be called several times.  If the number of data cache files
698   *     found is less than the global cacheFiles, then the caller will need to call it
699   *     again to record the inodes of the missing zero-length data cache files created
700   *     in the previous call.
701   *
702   * Side Effects:
703   *     Fills up the global inode_for_V array, may create and/or delete files as
704   *     explained above.
705   *---------------------------------------------------------------------------*/
706
707
708 static int
709 doSweepAFSCache(vFilesFound, directory, dirNum, maxDir)
710      int *vFilesFound;
711      char *directory;           /* /path/to/cache/directory */
712      int dirNum;                /* current directory number */
713      int maxDir;                /* maximum directory number */
714 {
715     static char rn[] = "doSweepAFSCache";       /* Routine Name */
716     char fullpn_FileToDelete[1024];     /*File to be deleted from cache */
717     char *fileToDelete;         /*Ptr to last component of above */
718     DIR *cdirp;                 /*Ptr to cache directory structure */
719 #ifdef AFS_SGI62_ENV
720     struct dirent64 *currp;     /*Current directory entry */
721 #else
722     struct dirent *currp;       /*Current directory entry */
723 #endif
724     int vFileNum;               /*Data cache file's associated number */
725     int thisDir;                /* A directory number */
726     int highDir = 0;
727
728     if (afsd_debug)
729         printf("%s: Opening cache directory '%s'\n", rn, directory);
730
731     if (chmod(directory, 0700)) {       /* force it to be 700 */
732         printf("%s: Can't 'chmod 0700' the cache dir, '%s'.\n", rn,
733                directory);
734         return (-1);
735     }
736     cdirp = opendir(directory);
737     if (cdirp == (DIR *) 0) {
738         printf("%s: Can't open AFS cache directory, '%s'.\n", rn, directory);
739         return (-1);
740     }
741
742     /*
743      * Scan the directory entries, remembering data cache file inodes
744      * and the existance of other important residents.  Recurse into
745      * the data subdirectories.
746      *
747      * Delete all files and directories that don't belong here.
748      */
749     sprintf(fullpn_FileToDelete, "%s/", directory);
750     fileToDelete = fullpn_FileToDelete + strlen(fullpn_FileToDelete);
751
752 #ifdef AFS_SGI62_ENV
753     for (currp = readdir64(cdirp); currp; currp = readdir64(cdirp))
754 #else
755     for (currp = readdir(cdirp); currp; currp = readdir(cdirp))
756 #endif
757     {
758         if (afsd_debug) {
759             printf("%s: Current directory entry:\n", rn);
760 #ifdef AFS_SGI62_ENV
761             printf("\tinode=%lld, reclen=%d, name='%s'\n", currp->d_ino,
762                    currp->d_reclen, currp->d_name);
763 #else
764             printf("\tinode=%d, reclen=%d, name='%s'\n", currp->d_ino,
765                    currp->d_reclen, currp->d_name);
766 #endif
767         }
768
769         /*
770          * If dirNum < 0, we are a top-level cache directory and should
771          * only contain sub-directories and other sundry files.  Therefore,
772          * V-files are valid only if dirNum >= 0, and Directories are only
773          * valid if dirNum < 0.
774          */
775
776         if (*(currp->d_name) == 'V'
777             && ((vFileNum = GetVFileNumber(currp->d_name, cacheFiles)) >=
778                 0)) {
779             /*
780              * Found a valid data cache filename.  Remember this
781              * file's inode, directory, and bump the number of files found
782              * total and in this directory.
783              */
784             inode_for_V[vFileNum] = currp->d_ino;
785             dir_for_V[vFileNum] = dirNum;       /* remember this directory */
786
787             if (!maxDir) {
788                 /* If we're in a real subdir, mark this file to be moved
789                  * if we've already got too many files in this directory
790                  */
791                 assert(dirNum >= 0);
792                 cache_dir_list[dirNum]++;       /* keep directory's file count */
793                 if (cache_dir_list[dirNum] > nFilesPerDir) {
794                     /* Too many files -- add to filelist */
795                     struct afsd_file_list *tmp = (struct afsd_file_list *)
796                         malloc(sizeof(*tmp));
797                     if (!tmp)
798                         printf
799                             ("%s: MALLOC FAILED allocating file_list entry\n",
800                              rn);
801                     else {
802                         tmp->fileNum = vFileNum;
803                         tmp->next = cache_dir_filelist[dirNum];
804                         cache_dir_filelist[dirNum] = tmp;
805                     }
806                 }
807             }
808             (*vFilesFound)++;
809         } else if (dirNum < 0 && (*(currp->d_name) == 'D')
810                    && GetDDirNumber(currp->d_name, 1 << 30) >= 0) {
811             int retval = 0;
812             if ((vFileNum = GetDDirNumber(currp->d_name, maxDir)) >= 0) {
813                 /* Found a valid cachefile sub-Directory.  Remember this number
814                  * and recurse into it.  Note that subdirs cannot have subdirs.
815                  */
816                 retval = 1;
817             } else if ((vFileNum = GetDDirNumber(currp->d_name, 1 << 30)) >=
818                        0) {
819                 /* This directory is going away, but figure out if there
820                  * are any cachefiles in here that should be saved by
821                  * moving them to other cache directories.  This directory
822                  * will be removed later.
823                  */
824                 retval = 2;
825             }
826
827             /* Save the highest directory number we've seen */
828             if (vFileNum > highDir)
829                 highDir = vFileNum;
830
831             /* If this directory is staying, be sure to mark it as 'found' */
832             if (retval == 1)
833                 cache_dir_list[vFileNum] = 0;
834
835             /* Print the dirname for recursion */
836             sprintf(fileToDelete, "%s", currp->d_name);
837
838             /* Note: vFileNum is the directory number */
839             retval =
840                 doSweepAFSCache(vFilesFound, fullpn_FileToDelete, vFileNum,
841                                 (retval == 1 ? 0 : -1));
842             if (retval) {
843                 printf("%s: Recursive sweep failed on directory %s\n", rn,
844                        currp->d_name);
845                 return retval;
846             }
847         } else if (dirNum < 0 && strcmp(currp->d_name, DCACHEFILE) == 0) {
848             /*
849              * Found the file holding the dcache entries.
850              */
851             missing_DCacheFile = 0;
852         } else if (dirNum < 0 && strcmp(currp->d_name, VOLINFOFILE) == 0) {
853             /*
854              * Found the file holding the volume info.
855              */
856             missing_VolInfoFile = 0;
857         } else if (dirNum < 0 && strcmp(currp->d_name, CELLINFOFILE) == 0) {
858             /*
859              * Found the file holding the cell info.
860              */
861             missing_CellInfoFile = 0;
862         } else if ((strcmp(currp->d_name, ".") == 0)
863                    || (strcmp(currp->d_name, "..") == 0) ||
864 #ifdef AFS_DECOSF_ENV
865                    /* these are magic AdvFS files */
866                    (strcmp(currp->d_name, ".tags") == 0)
867                    || (strcmp(currp->d_name, "quota.user") == 0)
868                    || (strcmp(currp->d_name, "quota.group") == 0) ||
869 #endif
870 #ifdef AFS_LINUX22_ENV
871                    /* this is the ext3 journal file */
872                    (strcmp(currp->d_name, ".journal") == 0) ||
873 #endif
874                    (strcmp(currp->d_name, "lost+found") == 0)) {
875             /*
876              * Don't do anything - this file is legit, and is to be left alone.
877              */
878         } else {
879             /*
880              * This file/directory doesn't belong in the cache.  Nuke it.
881              */
882             sprintf(fileToDelete, "%s", currp->d_name);
883             if (afsd_verbose)
884                 printf("%s: Deleting '%s'\n", rn, fullpn_FileToDelete);
885             if (unlink(fullpn_FileToDelete)) {
886                 if (errno == EISDIR && *fileToDelete == 'D') {
887                     if (rmdir(fullpn_FileToDelete)) {
888                         printf("%s: Can't rmdir '%s', errno is %d\n", rn,
889                                fullpn_FileToDelete, errno);
890                     }
891                 } else
892                     printf("%s: Can't unlink '%s', errno is %d\n", rn,
893                            fullpn_FileToDelete, errno);
894             }
895         }
896     }
897
898     if (dirNum < 0) {
899
900         /*
901          * Create all the cache files that are missing.
902          */
903         CreateFileIfMissing(fullpn_DCacheFile, missing_DCacheFile);
904         CreateFileIfMissing(fullpn_VolInfoFile, missing_VolInfoFile);
905         CreateFileIfMissing(fullpn_CellInfoFile, missing_CellInfoFile);
906
907         /* ADJUST CACHE FILES */
908
909         /* First, let's walk through the list of files and figure out
910          * if there are any leftover files in extra directories or
911          * missing files.  Move the former and create the latter in
912          * subdirs with extra space.
913          */
914
915         thisDir = 0;            /* Keep track of which subdir has space */
916
917         for (vFileNum = 0; vFileNum < cacheFiles; vFileNum++) {
918             if (dir_for_V[vFileNum] == -1) {
919                 /* This file does not exist.  Create it in the first
920                  * subdir that still has extra space.
921                  */
922                 while (thisDir < maxDir
923                        && cache_dir_list[thisDir] >= nFilesPerDir)
924                     thisDir++;
925                 if (thisDir >= maxDir)
926                     printf("%s: can't find directory to create V%d\n", rn,
927                            vFileNum);
928                 else {
929                     struct stat statb;
930                     assert(inode_for_V[vFileNum] == (AFSD_INO_T) 0);
931                     sprintf(vFilePtr, "D%d/V%d", thisDir, vFileNum);
932                     if (afsd_verbose)
933                         printf("%s: Creating '%s'\n", rn, fullpn_VFile);
934                     if (cache_dir_list[thisDir] < 0
935                         && CreateCacheSubDir(directory, thisDir))
936                         printf("%s: Can't create directory for '%s'\n", rn,
937                                fullpn_VFile);
938                     if (CreateCacheFile(fullpn_VFile, &statb))
939                         printf("%s: Can't create '%s'\n", rn, fullpn_VFile);
940                     else {
941                         inode_for_V[vFileNum] = statb.st_ino;
942                         dir_for_V[vFileNum] = thisDir;
943                         cache_dir_list[thisDir]++;
944                         (*vFilesFound)++;
945                     }
946                 }
947
948             } else if (dir_for_V[vFileNum] >= maxDir
949                        || dir_for_V[vFileNum] == -2) {
950                 /* This file needs to move; move it to the first subdir
951                  * that has extra space.  (-2 means it's in the toplevel)
952                  */
953                 while (thisDir < maxDir
954                        && cache_dir_list[thisDir] >= nFilesPerDir)
955                     thisDir++;
956                 if (thisDir >= maxDir)
957                     printf("%s: can't find directory to move V%d\n", rn,
958                            vFileNum);
959                 else {
960                     if (MoveCacheFile
961                         (directory, dir_for_V[vFileNum], thisDir, vFileNum,
962                          maxDir)) {
963                         /* Cannot move.  Ignore this file??? */
964                         /* XXX */
965                     }
966                 }
967             }
968         }                       /* for */
969
970         /* At this point, we've moved all of the valid cache files
971          * into the valid subdirs, and created all the extra
972          * cachefiles we need to create.  Next, rebalance any subdirs
973          * with too many cache files into the directories with not
974          * enough cache files.  Note that thisDir currently sits at
975          * the lowest subdir that _may_ have room.
976          */
977
978         for (dirNum = 0; dirNum < maxDir; dirNum++) {
979             struct afsd_file_list *thisFile;
980
981             for (thisFile = cache_dir_filelist[dirNum];
982                  thisFile && cache_dir_list[dirNum] >= nFilesPerDir;
983                  thisFile = thisFile->next) {
984                 while (thisDir < maxDir
985                        && cache_dir_list[thisDir] >= nFilesPerDir)
986                     thisDir++;
987                 if (thisDir >= maxDir)
988                     printf("%s: can't find directory to move V%d\n", rn,
989                            vFileNum);
990                 else {
991                     if (MoveCacheFile
992                         (directory, dirNum, thisDir, thisFile->fileNum,
993                          maxDir)) {
994                         /* Cannot move.  Ignore this file??? */
995                         /* XXX */
996                     }
997                 }
998             }                   /* for each file to move */
999         }                       /* for each directory */
1000
1001         /* Remove any directories >= maxDir -- they should be empty */
1002         for (; highDir >= maxDir; highDir--) {
1003             sprintf(fileToDelete, "D%d", highDir);
1004             if (unlink(fullpn_FileToDelete)) {
1005                 if (errno == EISDIR && *fileToDelete == 'D') {
1006                     if (rmdir(fullpn_FileToDelete)) {
1007                         printf("%s: Can't rmdir '%s', errno is %d\n", rn,
1008                                fullpn_FileToDelete, errno);
1009                     }
1010                 } else
1011                     printf("%s: Can't unlink '%s', errno is %d\n", rn,
1012                            fullpn_FileToDelete, errno);
1013             }
1014         }
1015     }
1016
1017     /* dirNum < 0 */
1018     /*
1019      * Close the directory, return success.
1020      */
1021     if (afsd_debug)
1022         printf("%s: Closing cache directory.\n", rn);
1023     closedir(cdirp);
1024     return (0);
1025 }
1026
1027 char *
1028 CheckCacheBaseDir(char *dir)
1029 {
1030     struct stat statbuf;
1031
1032     if (!dir) {
1033         return "cache base dir not specified";
1034     }
1035     if (stat(dir, &statbuf) != 0) {
1036         return "unable to stat cache base directory";
1037     }
1038
1039     /* might want to check here for anything else goofy, like cache pointed at a non-dedicated directory, etc */
1040
1041 #ifdef AFS_LINUX24_ENV
1042     {
1043         int res;
1044         struct statfs statfsbuf;
1045
1046         res = statfs(dir, &statfsbuf);
1047         if (res != 0) {
1048             return "unable to statfs cache base directory";
1049         }
1050         if (statfsbuf.f_type == 0x52654973) {   /* REISERFS_SUPER_MAGIC */
1051             return "cannot use reiserfs as cache partition";
1052         }
1053     }
1054 #endif
1055
1056 #ifdef AFS_HPUX_ENV
1057     {
1058         int res;
1059         struct statfs statfsbuf;
1060         char name[FSTYPSZ];
1061
1062         res = statfs(dir, &statfsbuf);
1063         if (res != 0) {
1064             return "unable to statfs cache base directory";
1065         }
1066
1067         if (sysfs(GETFSTYP, statfsbuf.f_fsid[1], name) != 0) {
1068             return "unable to determine filesystem type for cache base dir";
1069         }
1070
1071         if (strcmp(name, "hfs")) {
1072             return "can only use hfs filesystem for cache partition on hpux";
1073         }
1074     }
1075 #endif
1076
1077 #ifdef AFS_SUN5_ENV
1078     {
1079         FILE *vfstab;
1080         struct mnttab mnt;
1081         struct stat statmnt, statci;
1082
1083         if ((stat(dir, &statci) == 0)
1084             && ((vfstab = fopen(MNTTAB, "r")) != NULL)) {
1085             while (getmntent(vfstab, &mnt) == 0) {
1086                 if (strcmp(dir, mnt.mnt_mountp) != 0) {
1087                     char *cp;
1088                     int rdev = 0;
1089
1090                     if (cp = hasmntopt(&mnt, "dev="))
1091                         rdev =
1092                             (int)strtol(cp + strlen("dev="), (char **)NULL,
1093                                         16);
1094
1095                     if ((rdev == 0) && (stat(mnt.mnt_mountp, &statmnt) == 0))
1096                         rdev = statmnt.st_dev;
1097
1098                     if ((rdev == statci.st_dev)
1099                         && (hasmntopt(&mnt, "logging") != NULL)) {
1100
1101                         fclose(vfstab);
1102                         return
1103                             "mounting a multi-use partition which contains the AFS cache with the\n\"logging\" option may deadlock your system.\n\n";
1104                     }
1105                 }
1106             }
1107
1108             fclose(vfstab);
1109         }
1110     }
1111 #endif
1112
1113     return NULL;
1114 }
1115
1116 int
1117 SweepAFSCache(vFilesFound)
1118      int *vFilesFound;
1119 {
1120     static char rn[] = "SweepAFSCache"; /*Routine name */
1121     int maxDir = (cacheFiles + nFilesPerDir - 1) / nFilesPerDir;
1122     int i;
1123
1124     *vFilesFound = 0;
1125
1126     if (cacheFlags & AFSCALL_INIT_MEMCACHE) {
1127         if (afsd_debug)
1128             printf("%s: Memory Cache, no cache sweep done\n", rn);
1129         return 0;
1130     }
1131
1132     if (cache_dir_list == NULL) {
1133         cache_dir_list = (int *)malloc(maxDir * sizeof(*cache_dir_list));
1134         if (cache_dir_list == NULL) {
1135             printf("%s: Malloc Failed!\n", rn);
1136             return (-1);
1137         }
1138         for (i = 0; i < maxDir; i++)
1139             cache_dir_list[i] = -1;     /* Does not exist */
1140     }
1141
1142     if (cache_dir_filelist == NULL) {
1143         cache_dir_filelist = (struct afsd_file_list **)
1144             malloc(maxDir * sizeof(*cache_dir_filelist));
1145         if (cache_dir_filelist == NULL) {
1146             printf("%s: Malloc Failed!\n", rn);
1147             return (-1);
1148         }
1149         memset(cache_dir_filelist, 0, maxDir * sizeof(*cache_dir_filelist));
1150     }
1151
1152     if (dir_for_V == NULL) {
1153         dir_for_V = (int *)malloc(cacheFiles * sizeof(*dir_for_V));
1154         if (dir_for_V == NULL) {
1155             printf("%s: Malloc Failed!\n", rn);
1156             return (-1);
1157         }
1158         for (i = 0; i < cacheFiles; i++)
1159             dir_for_V[i] = -1;  /* Does not exist */
1160     }
1161
1162     /* Note, setting dirNum to -2 here will cause cachefiles found in
1163      * the toplevel directory to be marked in directory "-2".  This
1164      * allows us to differentiate between 'file not seen' (-1) and
1165      * 'file seen in top-level' (-2).  Then when we try to move the
1166      * file into a subdirectory, we know it's in the top-level instead
1167      * of some other cache subdir.
1168      */
1169     return doSweepAFSCache(vFilesFound, cacheBaseDir, -2, maxDir);
1170 }
1171
1172 static
1173 ConfigCell(aci, arock, adir)
1174      register struct afsconf_cell *aci;
1175      char *arock;
1176      struct afsconf_dir *adir;
1177 {
1178     register int isHomeCell;
1179     register int i, code;
1180     afs_int32 cellFlags = 0;
1181     afs_int32 hosts[MAXHOSTSPERCELL];
1182
1183     /* figure out if this is the home cell */
1184     isHomeCell = (strcmp(aci->name, LclCellName) == 0);
1185     if (!isHomeCell)
1186         cellFlags = 2;          /* not home, suid is forbidden */
1187
1188     /* build address list */
1189     for (i = 0; i < MAXHOSTSPERCELL; i++)
1190         memcpy(&hosts[i], &aci->hostAddr[i].sin_addr, sizeof(afs_int32));
1191
1192     if (aci->linkedCell)
1193         cellFlags |= 4;         /* Flag that linkedCell arg exists,
1194                                  * for upwards compatibility */
1195
1196     /* configure one cell */
1197     code = call_syscall(AFSOP_ADDCELL2, hosts,  /* server addresses */
1198                         aci->name,      /* cell name */
1199                         cellFlags,      /* is this the home cell? */
1200                         aci->linkedCell);       /* Linked cell, if any */
1201     if (code)
1202         printf("Adding cell '%s': error %d\n", aci->name, code);
1203     return 0;
1204 }
1205
1206 static
1207 ConfigCellAlias(aca, arock, adir)
1208      register struct afsconf_cellalias *aca;
1209      char *arock;
1210      struct afsconf_dir *adir;
1211 {
1212     /* push the alias into the kernel */
1213     call_syscall(AFSOP_ADDCELLALIAS, aca->aliasName, aca->realName);
1214     return 0;
1215 }
1216
1217 #ifdef AFS_AFSDB_ENV
1218 static
1219 AfsdbLookupHandler()
1220 {
1221     afs_int32 kernelMsg[64];
1222     char acellName[128];
1223     afs_int32 code;
1224     struct afsconf_cell acellInfo;
1225     int i;
1226
1227     kernelMsg[0] = 0;
1228     kernelMsg[1] = 0;
1229     acellName[0] = '\0';
1230
1231     while (1) {
1232         /* On some platforms you only get 4 args to an AFS call */
1233         int sizeArg = ((sizeof acellName) << 16) | (sizeof kernelMsg);
1234         code =
1235             call_syscall(AFSOP_AFSDB_HANDLER, acellName, kernelMsg, sizeArg);
1236         if (code) {             /* Something is wrong? */
1237             sleep(1);
1238             continue;
1239         }
1240
1241         if (*acellName == 1)    /* Shutting down */
1242             break;
1243
1244         code = afsconf_GetAfsdbInfo(acellName, 0, &acellInfo);
1245         if (code) {
1246             kernelMsg[0] = 0;
1247             kernelMsg[1] = 0;
1248         } else {
1249             kernelMsg[0] = acellInfo.numServers;
1250             if (acellInfo.timeout)
1251                 kernelMsg[1] = acellInfo.timeout - time(0);
1252             else
1253                 kernelMsg[1] = 0;
1254             for (i = 0; i < acellInfo.numServers; i++)
1255                 kernelMsg[i + 2] = acellInfo.hostAddr[i].sin_addr.s_addr;
1256             strncpy(acellName, acellInfo.name, sizeof(acellName));
1257             acellName[sizeof(acellName) - 1] = '\0';
1258         }
1259     }
1260
1261     exit(1);
1262 }
1263 #endif
1264
1265 #ifdef mac2
1266 #include <sys/ioctl.h>
1267 #endif /* mac2 */
1268
1269 #ifdef AFS_SGI65_ENV
1270 #define SET_RTPRI(P) {  \
1271     struct sched_param sp; \
1272     sp.sched_priority = P; \
1273     if (sched_setscheduler(0, SCHED_RR, &sp)<0) { \
1274         perror("sched_setscheduler"); \
1275     } \
1276 }
1277 #define SET_AFSD_RTPRI() SET_RTPRI(68)
1278 #define SET_RX_RTPRI()   SET_RTPRI(199)
1279 #else
1280 #ifdef AFS_LINUX20_ENV
1281 #define SET_AFSD_RTPRI()
1282 #define SET_RX_RTPRI()  do { if (setpriority(PRIO_PROCESS, 0, -10)<0) \
1283                            perror("setting rx priority"); \
1284                          } while (0)
1285 #else
1286 #define SET_AFSD_RTPRI()
1287 #define SET_RX_RTPRI()
1288 #endif
1289 #endif
1290
1291 mainproc(as, arock)
1292      register struct cmd_syndesc *as;
1293      char *arock;
1294 {
1295     static char rn[] = "afsd";  /*Name of this routine */
1296     register afs_int32 code;    /*Result of fork() */
1297     register int i;
1298     int currVFile;              /*Current AFS cache file number passed in */
1299     int mountFlags;             /*Flags passed to mount() */
1300     int lookupResult;           /*Result of GetLocalCellName() */
1301     int cacheIteration;         /*How many times through cache verification */
1302     int vFilesFound;            /*How many data cache files were found in sweep */
1303     struct afsconf_dir *cdir;   /* config dir */
1304     FILE *logfd;
1305     char *fsTypeMsg = NULL;
1306 #ifdef  AFS_SUN5_ENV
1307     struct stat st;
1308 #endif
1309     afs_int32 vfs1_type = -1;
1310 #ifdef AFS_SGI65_ENV
1311     struct sched_param sp;
1312 #endif
1313
1314 #ifdef AFS_SGI_VNODE_GLUE
1315     if (afs_init_kernel_config(-1) < 0) {
1316         printf("Can't determine NUMA configuration, not starting AFS.\n");
1317         exit(1);
1318     }
1319 #endif
1320
1321     /* call atoi on the appropriate parsed results */
1322     if (as->parms[0].items) {
1323         /* -blocks */
1324         cacheBlocks = atoi(as->parms[0].items->data);
1325         sawCacheBlocks = 1;
1326     }
1327     if (as->parms[1].items) {
1328         /* -files */
1329         cacheFiles = atoi(as->parms[1].items->data);
1330         filesSet = 1;           /* set when spec'd on cmd line */
1331     }
1332     if (as->parms[2].items) {
1333         /* -rootvol */
1334         strcpy(rootVolume, as->parms[2].items->data);
1335         rootVolSet = 1;
1336     }
1337     if (as->parms[3].items) {
1338         /* -stat */
1339         cacheStatEntries = atoi(as->parms[3].items->data);
1340     }
1341     if (as->parms[4].items) {
1342         /* -memcache */
1343         cacheBaseDir[0] = '\0';
1344         sawCacheBaseDir = 1;
1345         cacheFlags |= AFSCALL_INIT_MEMCACHE;
1346         if (chunkSize == 0)
1347             chunkSize = 13;
1348     }
1349     if (as->parms[5].items) {
1350         /* -cachedir */
1351         strcpy(cacheBaseDir, as->parms[5].items->data);
1352         sawCacheBaseDir = 1;
1353     }
1354     if (as->parms[6].items) {
1355         /* -mountdir */
1356         strcpy(cacheMountDir, as->parms[6].items->data);
1357         sawCacheMountDir = 1;
1358     }
1359     if (as->parms[7].items) {
1360         /* -daemons */
1361         nDaemons = atoi(as->parms[7].items->data);
1362     }
1363     if (as->parms[8].items) {
1364         /* -nosettime */
1365         cacheSetTime = FALSE;
1366     }
1367     if (as->parms[9].items) {
1368         /* -verbose */
1369         afsd_verbose = 1;
1370     }
1371     if (as->parms[10].items) {
1372         /* -rmtsys */
1373         afsd_rmtsys = 1;
1374     }
1375     if (as->parms[11].items) {
1376         /* -debug */
1377         afsd_debug = 1;
1378         afsd_verbose = 1;
1379     }
1380     if (as->parms[12].items) {
1381         /* -chunksize */
1382         chunkSize = atoi(as->parms[12].items->data);
1383         if (chunkSize < 0 || chunkSize > 30) {
1384             printf("afsd:invalid chunk size spec'd, using default\n");
1385             chunkSize = 0;
1386         }
1387     }
1388     if (as->parms[13].items) {
1389         /* -dcache */
1390         dCacheSize = atoi(as->parms[13].items->data);
1391         sawDCacheSize = 1;
1392     }
1393     if (as->parms[14].items) {
1394         /* -volumes */
1395         vCacheSize = atoi(as->parms[14].items->data);
1396     }
1397     if (as->parms[15].items) {
1398         /* -biods */
1399 #ifndef AFS_AIX32_ENV
1400         printf
1401             ("afsd: [-biods] currently only enabled for aix3.x VM supported systems\n");
1402 #else
1403         nBiods = atoi(as->parms[15].items->data);
1404         sawBiod = 1;
1405 #endif
1406     }
1407     if (as->parms[16].items) {
1408         /* -prealloc */
1409         preallocs = atoi(as->parms[16].items->data);
1410     }
1411 #ifdef notdef
1412     if (as->parms[17].items) {
1413         /* -pininodes */
1414         inodes = atoi(as->parms[17].items->data);
1415     }
1416 #endif
1417     strcpy(confDir, AFSDIR_CLIENT_ETC_DIRPATH);
1418     if (as->parms[17].items) {
1419         /* -confdir */
1420         strcpy(confDir, as->parms[17].items->data);
1421     }
1422     sprintf(fullpn_CacheInfo, "%s/%s", confDir, CACHEINFOFILE);
1423     sprintf(fullpn_AFSLogFile, "%s/%s", confDir, AFSLOGFILE);
1424     if (as->parms[18].items) {
1425         /* -logfile */
1426         strcpy(fullpn_AFSLogFile, as->parms[18].items->data);
1427     }
1428     if (as->parms[19].items) {
1429         /* -waitclose */
1430         afsd_CloseSynch = 1;
1431     }
1432     if (as->parms[20].items) {
1433         /* -shutdown */
1434         afs_shutdown = 1;
1435         /* 
1436          * Cold shutdown is the default
1437          */
1438         printf("afsd: Shutting down all afs processes and afs state\n");
1439         code = call_syscall(AFSOP_SHUTDOWN, 1);
1440         if (code) {
1441             printf("afsd: AFS still mounted; Not shutting down\n");
1442             exit(1);
1443         }
1444         exit(0);
1445     }
1446     if (as->parms[21].items) {
1447         /* -enable_peer_stats */
1448         enable_peer_stats = 1;
1449     }
1450     if (as->parms[22].items) {
1451         /* -enable_process_stats */
1452         enable_process_stats = 1;
1453     }
1454     if (as->parms[23].items) {
1455         /* -mem_alloc_sleep */
1456         cacheFlags |= AFSCALL_INIT_MEMCACHE_SLEEP;
1457     }
1458     if (as->parms[24].items) {
1459         /* -afsdb */
1460 #ifdef AFS_AFSDB_ENV
1461         enable_afsdb = 1;
1462 #else
1463         printf("afsd: No AFSDB support; ignoring -afsdb");
1464 #endif
1465     }
1466     if (as->parms[25].items) {
1467         /* -files_per_subdir */
1468         int res = atoi(as->parms[25].items->data);
1469         if (res < 10 || res > 2 ^ 30) {
1470             printf
1471                 ("afsd:invalid number of files per subdir, \"%s\". Ignored\n",
1472                  as->parms[25].items->data);
1473         } else {
1474             nFilesPerDir = res;
1475         }
1476     }
1477     if (as->parms[26].items) {
1478         /* -dynroot */
1479         enable_dynroot = 1;
1480     }
1481     if (as->parms[27].items) {
1482         /* -fakestat */
1483         enable_fakestat = 2;
1484     }
1485     if (as->parms[28].items) {
1486         /* -fakestat-all */
1487         enable_fakestat = 1;
1488     }
1489     if (as->parms[29].items) {
1490         /* -nomount */
1491         enable_nomount = 1;
1492     }
1493     if (as->parms[30].items) {
1494         /* -backuptree */
1495         enable_backuptree = 1;
1496     }
1497
1498     /*
1499      * Pull out all the configuration info for the workstation's AFS cache and
1500      * the cellular community we're willing to let our users see.
1501      */
1502     cdir = afsconf_Open(confDir);
1503     if (!cdir) {
1504         printf("afsd: some file missing or bad in %s\n", confDir);
1505         exit(1);
1506     }
1507
1508     lookupResult =
1509         afsconf_GetLocalCell(cdir, LclCellName, sizeof(LclCellName));
1510     if (lookupResult) {
1511         printf("%s: Can't get my home cell name!  [Error is %d]\n", rn,
1512                lookupResult);
1513     } else {
1514         if (afsd_verbose)
1515             printf("%s: My home cell is '%s'\n", rn, LclCellName);
1516     }
1517
1518     /* parse cacheinfo file if this is a diskcache */
1519     if (ParseCacheInfoFile()) {
1520         exit(1);
1521     }
1522
1523     if ((logfd = fopen(fullpn_AFSLogFile, "r+")) == 0) {
1524         if (afsd_verbose)
1525             printf("%s: Creating '%s'\n", rn, fullpn_AFSLogFile);
1526         if (CreateCacheFile(fullpn_AFSLogFile, NULL)) {
1527             printf
1528                 ("%s: Can't create '%s' (You may want to use the -logfile option)\n",
1529                  rn, fullpn_AFSLogFile);
1530             exit(1);
1531         }
1532     } else
1533         fclose(logfd);
1534
1535     /* do some random computations in memcache case to get things to work
1536      * reasonably no matter which parameters you set.
1537      */
1538     if (cacheFlags & AFSCALL_INIT_MEMCACHE) {
1539         /* memory cache: size described either as blocks or dcache entries, but
1540          * not both.
1541          */
1542         if (sawDCacheSize) {
1543             if (sawCacheBlocks) {
1544                 printf
1545                     ("%s: can't set cache blocks and dcache size simultaneously when diskless.\n",
1546                      rn);
1547                 exit(1);
1548             }
1549             /* compute the cache size based on # of chunks times the chunk size */
1550             i = (chunkSize == 0 ? 13 : chunkSize);
1551             i = (1 << i);       /* bytes per chunk */
1552             cacheBlocks = i * dCacheSize;
1553             sawCacheBlocks = 1; /* so that ParseCacheInfoFile doesn't overwrite */
1554         } else {
1555             /* compute the dcache size from overall cache size and chunk size */
1556             i = (chunkSize == 0 ? 13 : chunkSize);
1557             /* dCacheSize = (cacheBlocks << 10) / (1<<i); */
1558             if (i > 10) {
1559                 dCacheSize = (cacheBlocks >> (i - 10));
1560             } else if (i < 10) {
1561                 dCacheSize = (cacheBlocks << (10 - i));
1562             } else {
1563                 dCacheSize = cacheBlocks;
1564             }
1565             /* don't have to set sawDCacheSize here since it isn't overwritten
1566              * by ParseCacheInfoFile.
1567              */
1568         }
1569         /* kernel computes # of dcache entries as min of cacheFiles and dCacheSize,
1570          * so we now make them equal.
1571          */
1572         cacheFiles = dCacheSize;
1573     } else {
1574         /* Disk cache:
1575          * Compute the number of cache files based on cache size,
1576          * but only if -files isn't given on the command line.
1577          * Don't let # files be so small as to prevent full utilization 
1578          * of the cache unless user has explicitly asked for it.
1579          * average V-file is ~10K, according to tentative empirical studies.
1580          */
1581         if (!filesSet) {
1582             cacheFiles = cacheBlocks / 10;
1583             if (cacheFiles < 100)
1584                 cacheFiles = 100;
1585             /* Always allow more files than chunks.  Presume average V-file 
1586              * is ~67% of a chunk...  (another guess, perhaps Honeyman will
1587              * have a grad student write a paper).  i is KILOBYTES.
1588              */
1589             i = 1 << (chunkSize ==
1590                       0 ? 6 : (chunkSize < 10 ? 0 : chunkSize - 10));
1591             cacheFiles = max(cacheFiles, 1.5 * (cacheBlocks / i));
1592             /* never permit more files than blocks, while leaving space for
1593              * VolumeInfo and CacheItems files.  VolumeInfo is usually 20K,
1594              * CacheItems is 50 Bytes / file (== 1K/20)
1595              */
1596 #define VOLINFOSZ 20
1597 #define CACHEITMSZ (cacheFiles / 20)
1598 #ifdef AFS_AIX_ENV
1599             cacheFiles =
1600                 min(cacheFiles, (cacheBlocks - VOLINFOSZ - CACHEITMSZ) / 4);
1601 #else
1602             cacheFiles =
1603                 min(cacheFiles, cacheBlocks - VOLINFOSZ - CACHEITMSZ);
1604 #endif
1605             if (cacheFiles < 100)
1606                 fprintf(stderr, "%s: WARNING: cache probably too small!\n",
1607                         rn);
1608         }
1609         if (!sawDCacheSize) {
1610             if ((cacheFiles / 2) > dCacheSize)
1611                 dCacheSize = cacheFiles / 2;
1612             if (dCacheSize > 2000)
1613                 dCacheSize = 2000;
1614         }
1615     }
1616
1617     /*
1618      * Create and zero the inode table for the desired cache files.
1619      */
1620     inode_for_V = (AFSD_INO_T *) malloc(cacheFiles * sizeof(AFSD_INO_T));
1621     if (inode_for_V == (AFSD_INO_T *) 0) {
1622         printf
1623             ("%s: malloc() failed for cache file inode table with %d entries.\n",
1624              rn, cacheFiles);
1625         exit(1);
1626     }
1627     memset(inode_for_V, '\0', (cacheFiles * sizeof(AFSD_INO_T)));
1628     if (afsd_debug)
1629         printf("%s: %d inode_for_V entries at 0x%x, %d bytes\n", rn,
1630                cacheFiles, inode_for_V, (cacheFiles * sizeof(AFSD_INO_T)));
1631
1632     /*
1633      * Set up all the pathnames we'll need for later.
1634      */
1635     sprintf(fullpn_DCacheFile, "%s/%s", cacheBaseDir, DCACHEFILE);
1636     sprintf(fullpn_VolInfoFile, "%s/%s", cacheBaseDir, VOLINFOFILE);
1637     sprintf(fullpn_CellInfoFile, "%s/%s", cacheBaseDir, CELLINFOFILE);
1638     sprintf(fullpn_VFile, "%s/", cacheBaseDir);
1639     vFilePtr = fullpn_VFile + strlen(fullpn_VFile);
1640
1641     if ((fsTypeMsg = CheckCacheBaseDir(cacheBaseDir))) {
1642         printf("%s: WARNING: Cache dir check failed (%s)\n", rn, fsTypeMsg);
1643     }
1644 #if 0
1645     fputs(AFS_GOVERNMENT_MESSAGE, stdout);
1646     fflush(stdout);
1647 #endif
1648
1649     /*
1650      * Set up all the kernel processes needed for AFS.
1651      */
1652 #ifdef mac2
1653     setpgrp(getpid(), 0);
1654 #endif /* mac2 */
1655
1656     /* Initialize RX daemons and services */
1657
1658     /* initialize the rx random number generator from user space */
1659     {
1660         /* parse multihomed address files */
1661         afs_int32 addrbuf[MAXIPADDRS], maskbuf[MAXIPADDRS],
1662             mtubuf[MAXIPADDRS];
1663         char reason[1024];
1664         code =
1665             parseNetFiles(addrbuf, maskbuf, mtubuf, MAXIPADDRS, reason,
1666                           AFSDIR_CLIENT_NETINFO_FILEPATH,
1667                           AFSDIR_CLIENT_NETRESTRICT_FILEPATH);
1668         if (code > 0)
1669             call_syscall(AFSOP_ADVISEADDR, code, addrbuf, maskbuf, mtubuf);
1670         else
1671             printf("ADVISEADDR: Error in specifying interface addresses:%s\n",
1672                    reason);
1673     }
1674
1675     /* Set realtime priority for most threads to same as for biod's. */
1676     SET_AFSD_RTPRI();
1677
1678 #ifdef  AFS_SGI53_ENV
1679 #ifdef AFS_SGI61_ENV
1680     set_staticaddrs();
1681 #else /* AFS_SGI61_ENV */
1682     code = get_nfsstaticaddr();
1683     if (code)
1684         call_syscall(AFSOP_NFSSTATICADDR, code);
1685 #endif /* AFS_SGI61_ENV */
1686 #endif /* AFS_SGI_53_ENV */
1687
1688     /* Start listener, then callback listener. Lastly, start rx event daemon.
1689      * Change in ordering is so that Linux port has socket fd in listener
1690      * process.
1691      * preallocs are passed for both listener and callback server. Only
1692      * the one which actually does the initialization uses them though.
1693      */
1694     if (preallocs < cacheStatEntries + 50)
1695         preallocs = cacheStatEntries + 50;
1696 #ifdef RXK_LISTENER_ENV
1697     if (afsd_verbose)
1698         printf("%s: Forking rx listener daemon.\n", rn);
1699     code = fork();
1700     if (code == 0) {
1701         /* Child */
1702         SET_RX_RTPRI();         /* max advised for non-interrupts */
1703         call_syscall(AFSOP_RXLISTENER_DAEMON, preallocs, enable_peer_stats,
1704                      enable_process_stats);
1705         exit(1);
1706     }
1707 #endif
1708     if (afsd_verbose)
1709         printf("%s: Forking rx callback listener.\n", rn);
1710     code = fork();
1711     if (code == 0) {
1712         /* Child */
1713         call_syscall(AFSOP_START_RXCALLBACK, preallocs);
1714         exit(1);
1715     }
1716 #if defined(AFS_SUN5_ENV) || defined(RXK_LISTENER_ENV)
1717     if (afsd_verbose)
1718         printf("%s: Forking rxevent daemon.\n", rn);
1719     code = fork();
1720     if (code == 0) {
1721         /* Child */
1722         SET_RX_RTPRI();         /* max advised for non-interrupts */
1723         call_syscall(AFSOP_RXEVENT_DAEMON);
1724         exit(1);
1725     }
1726 #endif
1727
1728 #ifdef AFS_AFSDB_ENV
1729     if (enable_afsdb) {
1730         if (afsd_verbose)
1731             printf("%s: Forking AFSDB lookup handler.\n", rn);
1732         code = fork();
1733         if (code == 0) {
1734             AfsdbLookupHandler();
1735             exit(1);
1736         }
1737     }
1738 #endif
1739
1740     code = call_syscall(AFSOP_BASIC_INIT, 1);
1741     if (code)
1742         printf("%s: Error %d in basic initialization.\n", rn, code);
1743
1744     /*
1745      * Tell the kernel some basic information about the workstation's cache.
1746      */
1747     if (afsd_verbose)
1748         printf
1749             ("%s: Calling AFSOP_CACHEINIT: %d stat cache entries, %d optimum cache files, %d blocks in the cache, flags = 0x%x, dcache entries %d\n",
1750              rn, cacheStatEntries, cacheFiles, cacheBlocks, cacheFlags,
1751              dCacheSize);
1752     memset(&cparams, '\0', sizeof(cparams));
1753     cparams.cacheScaches = cacheStatEntries;
1754     cparams.cacheFiles = cacheFiles;
1755     cparams.cacheBlocks = cacheBlocks;
1756     cparams.cacheDcaches = dCacheSize;
1757     cparams.cacheVolumes = vCacheSize;
1758     cparams.chunkSize = chunkSize;
1759     cparams.setTimeFlag = cacheSetTime;
1760     cparams.memCacheFlag = cacheFlags;
1761 #ifdef notdef
1762     cparams.inodes = inodes;
1763 #endif
1764     call_syscall(AFSOP_CACHEINIT, &cparams);
1765     if (afsd_CloseSynch)
1766         call_syscall(AFSOP_CLOSEWAIT);
1767
1768     /*
1769      * Sweep the workstation AFS cache directory, remembering the inodes of
1770      * valid files and deleting extraneous files.  Keep sweeping until we
1771      * have the right number of data cache files or we've swept too many
1772      * times.
1773      *
1774      * This also creates files in the cache directory like VolumeItems and
1775      * CellItems, and thus must be ran before those are sent to the kernel.
1776      */
1777     if (afsd_verbose)
1778         printf("%s: Sweeping workstation's AFS cache directory.\n", rn);
1779     cacheIteration = 0;
1780     /* Memory-cache based system doesn't need any of this */
1781     if (!(cacheFlags & AFSCALL_INIT_MEMCACHE)) {
1782         do {
1783             cacheIteration++;
1784             if (SweepAFSCache(&vFilesFound)) {
1785                 printf("%s: Error on sweep %d of workstation AFS cache \
1786                        directory.\n", rn, cacheIteration);
1787                 exit(1);
1788             }
1789             if (afsd_verbose)
1790                 printf
1791                     ("%s: %d out of %d data cache files found in sweep %d.\n",
1792                      rn, vFilesFound, cacheFiles, cacheIteration);
1793         } while ((vFilesFound < cacheFiles)
1794                  && (cacheIteration < MAX_CACHE_LOOPS));
1795     } else if (afsd_verbose)
1796         printf("%s: Using memory cache, not swept\n", rn);
1797
1798     /*
1799      * Pass the kernel the name of the workstation cache file holding the 
1800      * dcache entries.
1801      */
1802     if (afsd_debug)
1803         printf("%s: Calling AFSOP_CACHEINFO: dcache file is '%s'\n", rn,
1804                fullpn_DCacheFile);
1805     /* once again, meaningless for a memory-based cache. */
1806     if (!(cacheFlags & AFSCALL_INIT_MEMCACHE))
1807         call_syscall(AFSOP_CACHEINFO, fullpn_DCacheFile);
1808
1809     /*
1810      * Pass the kernel the name of the workstation cache file holding the
1811      * cell information.
1812      */
1813     if (afsd_debug)
1814         printf("%s: Calling AFSOP_CELLINFO: cell info file is '%s'\n", rn,
1815                fullpn_CellInfoFile);
1816     call_syscall(AFSOP_CELLINFO, fullpn_CellInfoFile);
1817
1818     if (enable_dynroot) {
1819         if (afsd_verbose)
1820             printf("%s: Enabling dynroot support in kernel.\n", rn);
1821         code = call_syscall(AFSOP_SET_DYNROOT, 1);
1822         if (code)
1823             printf("%s: Error enabling dynroot support.\n", rn);
1824     }
1825
1826     if (enable_fakestat) {
1827         if (afsd_verbose)
1828             printf("%s: Enabling fakestat support in kernel.\n", rn);
1829         code = call_syscall(AFSOP_SET_FAKESTAT, enable_fakestat);
1830         if (code)
1831             printf("%s: Error enabling fakestat support.\n", rn);
1832     }
1833
1834     if (enable_backuptree) {
1835         if (afsd_verbose)
1836             printf("%s: Enabling backup tree support in kernel.\n", rn);
1837         code = call_syscall(AFSOP_SET_BACKUPTREE, enable_backuptree);
1838         if (code)
1839             printf("%s: Error enabling backup tree support.\n", rn);
1840     }
1841
1842     /*
1843      * Tell the kernel about each cell in the configuration.
1844      */
1845     afsconf_CellApply(cdir, ConfigCell, NULL);
1846     afsconf_CellAliasApply(cdir, ConfigCellAlias, NULL);
1847
1848     /*
1849      * Set the primary cell name.
1850      */
1851     call_syscall(AFSOP_SET_THISCELL, LclCellName);
1852
1853     /* Initialize AFS daemon threads. */
1854     if (afsd_verbose)
1855         printf("%s: Forking AFS daemon.\n", rn);
1856     code = fork();
1857     if (code == 0) {
1858         /* Child */
1859         call_syscall(AFSOP_START_AFS);
1860         exit(1);
1861     }
1862
1863     if (afsd_verbose)
1864         printf("%s: Forking Check Server Daemon.\n", rn);
1865     code = fork();
1866     if (code == 0) {
1867         /* Child */
1868         code = call_syscall(AFSOP_START_CS);
1869         if (code)
1870             printf("%s: No check server daemon in client.\n", rn);
1871         exit(1);
1872     }
1873
1874     if (afsd_verbose)
1875         printf("%s: Forking %d background daemons.\n", rn, nDaemons);
1876 #if defined(AFS_SGI_ENV) && defined(AFS_SGI_SHORTSTACK)
1877     /* Add one because for sgi we always "steal" the first daemon for a
1878      * different task if we only have a 4K stack.
1879      */
1880     nDaemons++;
1881 #endif
1882     for (i = 0; i < nDaemons; i++) {
1883         code = fork();
1884         if (code == 0) {
1885             /* Child */
1886 #ifdef  AFS_AIX32_ENV
1887             call_syscall(AFSOP_START_BKG, 0);
1888 #else
1889             call_syscall(AFSOP_START_BKG);
1890 #endif
1891             exit(1);
1892         }
1893     }
1894 #ifdef  AFS_AIX32_ENV
1895     if (!sawBiod)
1896         nBiods = nDaemons * 2;
1897     if (nBiods < 5)
1898         nBiods = 5;
1899     for (i = 0; i < nBiods; i++) {
1900         code = fork();
1901         if (code == 0) {        /* Child */
1902             call_syscall(AFSOP_START_BKG, nBiods);
1903             exit(1);
1904         }
1905     }
1906 #endif
1907
1908     /*
1909      * If the root volume has been explicitly set, tell the kernel.
1910      */
1911     if (rootVolSet) {
1912         if (afsd_verbose)
1913             printf("%s: Calling AFSOP_ROOTVOLUME with '%s'\n", rn,
1914                    rootVolume);
1915         call_syscall(AFSOP_ROOTVOLUME, rootVolume);
1916     }
1917
1918     /*
1919      * Pass the kernel the name of the workstation cache file holding the
1920      * volume information.
1921      */
1922     if (afsd_debug)
1923         printf("%s: Calling AFSOP_VOLUMEINFO: volume info file is '%s'\n", rn,
1924                fullpn_VolInfoFile);
1925     call_syscall(AFSOP_VOLUMEINFO, fullpn_VolInfoFile);
1926
1927     /*
1928      * Pass the kernel the name of the afs logging file holding the volume
1929      * information.
1930      */
1931     if (afsd_debug)
1932         printf("%s: Calling AFSOP_AFSLOG: volume info file is '%s'\n", rn,
1933                fullpn_AFSLogFile);
1934 #if defined(AFS_SGI_ENV)
1935     /* permit explicit -logfile argument to enable logging on memcache systems */
1936     if (!(cacheFlags & AFSCALL_INIT_MEMCACHE) || as->parms[18].items)
1937 #else
1938     if (!(cacheFlags & AFSCALL_INIT_MEMCACHE))  /* ... nor this ... */
1939 #endif
1940         call_syscall(AFSOP_AFSLOG, fullpn_AFSLogFile);
1941
1942     /*
1943      * Give the kernel the names of the AFS files cached on the workstation's
1944      * disk.
1945      */
1946     if (afsd_debug)
1947         printf
1948             ("%s: Calling AFSOP_CACHEINODE for each of the %d files in '%s'\n",
1949              rn, cacheFiles, cacheBaseDir);
1950     if (!(cacheFlags & AFSCALL_INIT_MEMCACHE))  /* ... and again ... */
1951         for (currVFile = 0; currVFile < cacheFiles; currVFile++) {
1952 #ifdef AFS_SGI62_ENV
1953             call_syscall(AFSOP_CACHEINODE,
1954                          (afs_uint32) (inode_for_V[currVFile] >> 32),
1955                          (afs_uint32) (inode_for_V[currVFile] & 0xffffffff));
1956 #else
1957             call_syscall(AFSOP_CACHEINODE, inode_for_V[currVFile]);
1958 #endif
1959         }
1960
1961
1962     /*end for */
1963     /*
1964      * All the necessary info has been passed into the kernel to run an AFS
1965      * system.  Give the kernel our go-ahead.
1966      */
1967     if (afsd_debug)
1968         printf("%s: Calling AFSOP_GO with cacheSetTime = %d\n", rn,
1969                cacheSetTime);
1970     call_syscall(AFSOP_GO, cacheSetTime);
1971
1972     /*
1973      * At this point, we have finished passing the kernel all the info 
1974      * it needs to set up the AFS.  Mount the AFS root.
1975      */
1976     printf("%s: All AFS daemons started.\n", rn);
1977
1978     if (afsd_verbose)
1979         printf("%s: Forking trunc-cache daemon.\n", rn);
1980     code = fork();
1981     if (code == 0) {
1982         /* Child */
1983         call_syscall(AFSOP_START_TRUNCDAEMON);
1984         exit(1);
1985     }
1986
1987     if (!enable_nomount) {
1988
1989         mountFlags = 0;         /* Read/write file system, can do setuid() */
1990 #if     defined(AFS_SUN_ENV) || defined(AFS_SUN5_ENV)
1991 #ifdef  AFS_SUN5_ENV
1992         mountFlags |= MS_DATA;
1993 #else
1994         mountFlags |= M_NEWTYPE;        /* This searches by name in vfs_conf.c so don't need to recompile vfs.c because MOUNT_MAXTYPE has changed; it seems that Sun fixed this at last... */
1995 #endif
1996 #endif
1997
1998 #if defined(AFS_HPUX100_ENV)
1999         mountFlags |= MS_DATA;
2000 #endif
2001
2002         if (afsd_verbose)
2003             printf("%s: Mounting the AFS root on '%s', flags: %d.\n", rn,
2004                    cacheMountDir, mountFlags);
2005 #ifdef AFS_DEC_ENV
2006         if ((mount("AFS", cacheMountDir, mountFlags, GT_AFS, (caddr_t) 0)) <
2007             0) {
2008 #else
2009 #ifdef AFS_FBSD_ENV
2010         if ((mount("AFS", cacheMountDir, mountFlags, (caddr_t) 0)) < 0) {
2011 #else
2012 #ifdef  AFS_AUX_ENV
2013         if ((fsmount(MOUNT_AFS, cacheMountDir, mountFlags, (caddr_t) 0)) < 0) {
2014 #else
2015 #ifdef  AFS_AIX_ENV
2016         if (aix_vmount()) {
2017 #else
2018 #if defined(AFS_HPUX100_ENV)
2019         if ((mount("", cacheMountDir, mountFlags, "afs", NULL, 0)) < 0) {
2020 #else
2021 #ifdef  AFS_HPUX_ENV
2022 #if     defined(AFS_HPUX90_ENV)
2023         {
2024             char buffer[80];
2025             int code;
2026
2027             strcpy(buffer, "afs");
2028             code = vfsmount(-1, cacheMountDir, mountFlags, (caddr_t) buffer);
2029             sscanf(buffer, "%d", &vfs1_type);
2030             if (code < 0) {
2031                 printf
2032                     ("Can't find 'afs' type in the registered filesystem table!\n");
2033                 exit(1);
2034             }
2035             sscanf(buffer, "%d", &vfs1_type);
2036             if (afsd_verbose)
2037                 printf("AFS vfs slot number is %d\n", vfs1_type);
2038         }
2039         if ((vfsmount(vfs1_type, cacheMountDir, mountFlags, (caddr_t) 0)) < 0) {
2040 #else
2041         if (call_syscall
2042             (AFSOP_AFS_VFSMOUNT, MOUNT_AFS, cacheMountDir, mountFlags,
2043              (caddr_t) NULL) < 0) {
2044 #endif
2045 #else
2046 #ifdef  AFS_SUN5_ENV
2047         if ((mount("AFS", cacheMountDir, mountFlags, "afs", NULL, 0)) < 0) {
2048 #else
2049 #if defined(AFS_SGI_ENV)
2050         mountFlags = MS_FSS;
2051         if ((mount(MOUNT_AFS, cacheMountDir, mountFlags, (caddr_t) MOUNT_AFS))
2052             < 0) {
2053 #else
2054 #ifdef AFS_LINUX20_ENV
2055         if ((mount("AFS", cacheMountDir, MOUNT_AFS, 0, NULL)) < 0) {
2056 #else
2057 /* This is the standard mount used by the suns and rts */
2058         if ((mount(MOUNT_AFS, cacheMountDir, mountFlags, (caddr_t) 0)) < 0) {
2059 #endif /* AFS_LINUX20_ENV */
2060 #endif /* AFS_SGI_ENV */
2061 #endif /* AFS_SUN5_ENV */
2062 #endif /* AFS_HPUX100_ENV */
2063 #endif /* AFS_HPUX_ENV */
2064 #endif /* AFS_AIX_ENV */
2065 #endif /* AFS_AUX_ENV */
2066 #endif /* AFS_FBSD_ENV */
2067 #endif /* AFS_DEC_ENV */
2068             printf("%s: Can't mount AFS on %s(%d)\n", rn, cacheMountDir,
2069                    errno);
2070             exit(1);
2071         }
2072
2073         HandleMTab();
2074
2075     }
2076
2077     if (afsd_rmtsys) {
2078         if (afsd_verbose)
2079             printf("%s: Forking 'rmtsys' daemon.\n", rn);
2080         code = fork();
2081         if (code == 0) {
2082             /* Child */
2083             rmtsysd();
2084             exit(1);
2085         }
2086     }
2087     /*
2088      * Exit successfully.
2089      */
2090     exit(0);
2091 }
2092
2093 #include "AFS_component_version_number.c"
2094
2095
2096
2097 main(argc, argv)
2098      int argc;
2099      char **argv;
2100 {
2101     register struct cmd_syndesc *ts;
2102
2103     ts = cmd_CreateSyntax(NULL, mainproc, NULL, "start AFS");
2104     cmd_AddParm(ts, "-blocks", CMD_SINGLE, CMD_OPTIONAL,
2105                 "1024 byte blocks in cache");
2106     cmd_AddParm(ts, "-files", CMD_SINGLE, CMD_OPTIONAL, "files in cache");
2107     cmd_AddParm(ts, "-rootvol", CMD_SINGLE, CMD_OPTIONAL,
2108                 "name of AFS root volume");
2109     cmd_AddParm(ts, "-stat", CMD_SINGLE, CMD_OPTIONAL,
2110                 "number of stat entries");
2111     cmd_AddParm(ts, "-memcache", CMD_FLAG, CMD_OPTIONAL, "run diskless");
2112     cmd_AddParm(ts, "-cachedir", CMD_SINGLE, CMD_OPTIONAL, "cache directory");
2113     cmd_AddParm(ts, "-mountdir", CMD_SINGLE, CMD_OPTIONAL, "mount location");
2114     cmd_AddParm(ts, "-daemons", CMD_SINGLE, CMD_OPTIONAL,
2115                 "number of daemons to use");
2116     cmd_AddParm(ts, "-nosettime", CMD_FLAG, CMD_OPTIONAL,
2117                 "don't set the time");
2118     cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL,
2119                 "display lots of information");
2120     cmd_AddParm(ts, "-rmtsys", CMD_FLAG, CMD_OPTIONAL,
2121                 "start NFS rmtsysd program");
2122     cmd_AddParm(ts, "-debug", CMD_FLAG, CMD_OPTIONAL, "display debug info");
2123     cmd_AddParm(ts, "-chunksize", CMD_SINGLE, CMD_OPTIONAL,
2124                 "log(2) of chunk size");
2125     cmd_AddParm(ts, "-dcache", CMD_SINGLE, CMD_OPTIONAL,
2126                 "number of dcache entries");
2127     cmd_AddParm(ts, "-volumes", CMD_SINGLE, CMD_OPTIONAL,
2128                 "number of volume entries");
2129     cmd_AddParm(ts, "-biods", CMD_SINGLE, CMD_OPTIONAL,
2130                 "number of bkg I/O daemons (aix vm)");
2131
2132     cmd_AddParm(ts, "-prealloc", CMD_SINGLE, CMD_OPTIONAL,
2133                 "number of 'small' preallocated blocks");
2134 #ifdef notdef
2135     cmd_AddParm(ts, "-pininodes", CMD_SINGLE, CMD_OPTIONAL,
2136                 "number of inodes to hog");
2137 #endif
2138     cmd_AddParm(ts, "-confdir", CMD_SINGLE, CMD_OPTIONAL,
2139                 "configuration directory");
2140     cmd_AddParm(ts, "-logfile", CMD_SINGLE, CMD_OPTIONAL,
2141                 "Place to keep the CM log");
2142     cmd_AddParm(ts, "-waitclose", CMD_FLAG, CMD_OPTIONAL,
2143                 "make close calls synchronous");
2144     cmd_AddParm(ts, "-shutdown", CMD_FLAG, CMD_OPTIONAL,
2145                 "Shutdown all afs state");
2146     cmd_AddParm(ts, "-enable_peer_stats", CMD_FLAG, CMD_OPTIONAL | CMD_HIDE,
2147                 "Collect rpc statistics by peer");
2148     cmd_AddParm(ts, "-enable_process_stats", CMD_FLAG,
2149                 CMD_OPTIONAL | CMD_HIDE,
2150                 "Collect rpc statistics for this process");
2151     cmd_AddParm(ts, "-mem_alloc_sleep", CMD_FLAG, (CMD_OPTIONAL | CMD_HIDE),
2152                 "Allow sleeps when allocating memory cache");
2153     cmd_AddParm(ts, "-afsdb", CMD_FLAG, (CMD_OPTIONAL
2154 #ifndef AFS_AFSDB_ENV
2155                                          | CMD_HIDE
2156 #endif
2157                 ), "Enable AFSDB support");
2158     cmd_AddParm(ts, "-files_per_subdir", CMD_SINGLE, CMD_OPTIONAL,
2159                 "log(2) of the number of cache files per cache subdirectory");
2160     cmd_AddParm(ts, "-dynroot", CMD_FLAG, CMD_OPTIONAL,
2161                 "Enable dynroot support");
2162     cmd_AddParm(ts, "-fakestat", CMD_FLAG, CMD_OPTIONAL,
2163                 "Enable fakestat support for cross-cell mounts");
2164     cmd_AddParm(ts, "-fakestat-all", CMD_FLAG, CMD_OPTIONAL,
2165                 "Enable fakestat support for all mounts");
2166     cmd_AddParm(ts, "-nomount", CMD_FLAG, CMD_OPTIONAL, "Do not mount AFS");
2167     cmd_AddParm(ts, "-backuptree", CMD_FLAG, CMD_OPTIONAL,
2168                 "Prefer backup volumes for mointpoints in backup volumes");
2169     return (cmd_Dispatch(argc, argv));
2170 }
2171
2172
2173 #ifdef  AFS_HPUX_ENV
2174 #define MOUNTED_TABLE   MNT_MNTTAB
2175 #else
2176 #ifdef  AFS_SUN5_ENV
2177 #define MOUNTED_TABLE   MNTTAB
2178 #else
2179 #define MOUNTED_TABLE   MOUNTED
2180 #endif
2181 #endif
2182
2183 static int
2184 HandleMTab()
2185 {
2186 #if (defined (AFS_SUN_ENV) || defined (AFS_HPUX_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_LINUX20_ENV)) && !defined(AFS_SUN58_ENV)
2187     FILE *tfilep;
2188 #ifdef  AFS_SUN5_ENV
2189     char tbuf[16];
2190     struct mnttab tmntent;
2191
2192     memset(&tmntent, '\0', sizeof(struct mnttab));
2193     if (!(tfilep = fopen(MOUNTED_TABLE, "a+"))) {
2194         printf("Can't open %s\n", MOUNTED_TABLE);
2195         perror(MNTTAB);
2196         exit(-1);
2197     }
2198     tmntent.mnt_special = "AFS";
2199     tmntent.mnt_mountp = cacheMountDir;
2200     tmntent.mnt_fstype = "xx";
2201     tmntent.mnt_mntopts = "rw";
2202     sprintf(tbuf, "%ld", (long)time((time_t *) 0));
2203     tmntent.mnt_time = tbuf;
2204     putmntent(tfilep, &tmntent);
2205     fclose(tfilep);
2206 #else
2207 #if defined(AFS_SGI_ENV) || defined(AFS_LINUX20_ENV)
2208     struct mntent tmntent;
2209
2210     tfilep = setmntent("/etc/mtab", "a+");
2211     tmntent.mnt_fsname = "AFS";
2212     tmntent.mnt_dir = cacheMountDir;
2213     tmntent.mnt_type = "afs";
2214     tmntent.mnt_opts = "rw";
2215     tmntent.mnt_freq = 1;
2216     tmntent.mnt_passno = 3;
2217     addmntent(tfilep, &tmntent);
2218     endmntent(tfilep);
2219 #else
2220     struct mntent tmntent;
2221
2222     memset(&tmntent, '\0', sizeof(struct mntent));
2223     tfilep = setmntent(MOUNTED_TABLE, "a+");
2224     if (!tfilep) {
2225         printf("Can't open %s for write; Not adding afs entry to it\n",
2226                MOUNTED_TABLE);
2227         return 1;
2228     }
2229     tmntent.mnt_fsname = "AFS";
2230     tmntent.mnt_dir = cacheMountDir;
2231     tmntent.mnt_type = "xx";
2232     tmntent.mnt_opts = "rw";
2233     tmntent.mnt_freq = 1;
2234     tmntent.mnt_passno = 3;
2235 #ifdef  AFS_HPUX_ENV
2236     tmntent.mnt_type = "afs";
2237     tmntent.mnt_time = time(0);
2238     tmntent.mnt_cnode = 0;
2239 #endif
2240     addmntent(tfilep, &tmntent);
2241     endmntent(tfilep);
2242 #endif /* AFS_SGI_ENV */
2243 #endif /* AFS_SUN5_ENV */
2244 #endif /* unreasonable systems */
2245 #ifdef AFS_DARWIN_ENV
2246     mach_port_t diskarb_port;
2247     kern_return_t status;
2248
2249     status = DiskArbStart(&diskarb_port);
2250     if (status == KERN_SUCCESS) {
2251         status =
2252             DiskArbDiskAppearedWithMountpointPing_auto("AFS",
2253                                                        DISK_ARB_NETWORK_DISK_FLAG,
2254                                                        cacheMountDir);
2255     }
2256
2257     return status;
2258 #endif /* AFS_DARWIN_ENV */
2259     return 0;
2260 }
2261
2262 #if !defined(AFS_SGI_ENV) && !defined(AFS_AIX32_ENV)
2263 call_syscall(param1, param2, param3, param4, param5, param6, param7)
2264      long param1, param2, param3, param4, param5, param6, param7;
2265 {
2266     int error;
2267 #ifdef AFS_LINUX20_ENV
2268     long eparm[4];
2269
2270     eparm[0] = param4;
2271     eparm[1] = param5;
2272     eparm[2] = param6;
2273     eparm[3] = param7;
2274
2275     param4 = (long)eparm;
2276 #endif
2277
2278     error =
2279         syscall(AFS_SYSCALL, AFSCALL_CALL, param1, param2, param3, param4,
2280                 param5, param6, param7);
2281     if (afsd_verbose)
2282         printf("SScall(%d, %d, %d)=%d ", AFS_SYSCALL, AFSCALL_CALL, param1,
2283                error);
2284     return (error);
2285 }
2286 #else /* AFS_AIX32_ENV */
2287 #if defined(AFS_SGI_ENV)
2288 call_syscall(call, parm0, parm1, parm2, parm3, parm4)
2289 {
2290
2291     int error;
2292
2293     error = afs_syscall(call, parm0, parm1, parm2, parm3, parm4);
2294     if (afsd_verbose)
2295         printf("SScall(%d, %d)=%d ", call, parm0, error);
2296
2297     return error;
2298 }
2299 #else
2300 call_syscall(call, parm0, parm1, parm2, parm3, parm4, parm5, parm6)
2301 {
2302
2303     return syscall(AFSCALL_CALL, call, parm0, parm1, parm2, parm3, parm4,
2304                    parm5, parm6);
2305 }
2306 #endif /* AFS_SGI_ENV */
2307 #endif /* AFS_AIX32_ENV */
2308
2309
2310 #ifdef  AFS_AIX_ENV
2311 /* Special handling for AIX's afs mount operation since they require much more miscl. information before making the vmount(2) syscall */
2312 #include <sys/vfs.h>
2313
2314 #define ROUNDUP(x)  (((x) + 3) & ~3)
2315
2316 aix_vmount()
2317 {
2318     struct vmount *vmountp;
2319     int size, error;
2320
2321     size = sizeof(struct vmount) + ROUNDUP(strlen(cacheMountDir) + 1) + 5 * 4;
2322     /* Malloc the vmount structure */
2323     if ((vmountp = (struct vmount *)malloc(size)) == (struct vmount *)NULL) {
2324         printf("Can't allocate space for the vmount structure (AIX)\n");
2325         exit(1);
2326     }
2327
2328     /* zero out the vmount structure */
2329     memset(vmountp, '\0', size);
2330
2331     /* transfer info into the vmount structure */
2332     vmountp->vmt_revision = VMT_REVISION;
2333     vmountp->vmt_length = size;
2334     vmountp->vmt_fsid.fsid_dev = 0;
2335     vmountp->vmt_fsid.fsid_type = AFS_MOUNT_AFS;
2336     vmountp->vmt_vfsnumber = 0;
2337     vmountp->vmt_time = 0;      /* We'll put the time soon! */
2338     vmountp->vmt_flags = VFS_DEVMOUNT;  /* read/write permission */
2339     vmountp->vmt_gfstype = AFS_MOUNT_AFS;
2340     vmountdata(vmountp, "AFS", cacheMountDir, "", "", "", "rw");
2341
2342     /* Do the actual mount system call */
2343     error = vmount(vmountp, size);
2344     free(vmountp);
2345     return (error);
2346 }
2347
2348 vmountdata(vmtp, obj, stub, host, hostsname, info, args)
2349      struct vmount *vmtp;
2350      char *obj, *stub, *host, *hostsname, *info, *args;
2351 {
2352     register struct data {
2353         short vmt_off;
2354         short vmt_size;
2355     } *vdp, *vdprev;
2356     register int size;
2357
2358     vdp = (struct data *)vmtp->vmt_data;
2359     vdp->vmt_off = sizeof(struct vmount);
2360     size = ROUNDUP(strlen(obj) + 1);
2361     vdp->vmt_size = size;
2362     strcpy(vmt2dataptr(vmtp, VMT_OBJECT), obj);
2363
2364     vdprev = vdp;
2365     vdp++;
2366     vdp->vmt_off = vdprev->vmt_off + size;
2367     size = ROUNDUP(strlen(stub) + 1);
2368     vdp->vmt_size = size;
2369     strcpy(vmt2dataptr(vmtp, VMT_STUB), stub);
2370
2371     vdprev = vdp;
2372     vdp++;
2373     vdp->vmt_off = vdprev->vmt_off + size;
2374     size = ROUNDUP(strlen(host) + 1);
2375     vdp->vmt_size = size;
2376     strcpy(vmt2dataptr(vmtp, VMT_HOST), host);
2377
2378     vdprev = vdp;
2379     vdp++;
2380     vdp->vmt_off = vdprev->vmt_off + size;
2381     size = ROUNDUP(strlen(hostsname) + 1);
2382     vdp->vmt_size = size;
2383     strcpy(vmt2dataptr(vmtp, VMT_HOSTNAME), hostsname);
2384
2385
2386     vdprev = vdp;
2387     vdp++;
2388     vdp->vmt_off = vdprev->vmt_off + size;
2389     size = ROUNDUP(strlen(info) + 1);
2390     vdp->vmt_size = size;
2391     strcpy(vmt2dataptr(vmtp, VMT_INFO), info);
2392
2393     vdprev = vdp;
2394     vdp++;
2395     vdp->vmt_off = vdprev->vmt_off + size;
2396     size = ROUNDUP(strlen(args) + 1);
2397     vdp->vmt_size = size;
2398     strcpy(vmt2dataptr(vmtp, VMT_ARGS), args);
2399 }
2400 #endif /* AFS_AIX_ENV */
2401
2402 #ifdef  AFS_SGI53_ENV
2403 #ifdef AFS_SGI61_ENV
2404 /* The dwarf structures are searched to find entry points of static functions
2405  * and the addresses of static variables. The file name as well as the
2406  * sybmol name is reaquired.
2407  */
2408
2409 /* Contains list of names to find in given file. */
2410 typedef struct {
2411     char *name;                 /* Name of variable or function. */
2412     afs_hyper_t addr;           /* Address of function, undefined if not found. */
2413     Dwarf_Half type;            /* DW_AT_location for vars, DW_AT_lowpc for func's */
2414     char found;                 /* set if found. */
2415 } staticAddrList;
2416
2417 typedef struct {
2418     char *file;                 /* Name of file containing vars or funcs */
2419     staticAddrList *addrList;   /* List of vars and/or funcs. */
2420     int nAddrs;                 /* # of addrList's */
2421     int found;                  /* set if we've found this file already. */
2422 } staticNameList;
2423
2424 /* routines used to find addresses in /unix */
2425 #if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
2426 void findMDebugStaticAddresses(staticNameList *, int, int);
2427 #endif
2428 void findDwarfStaticAddresses(staticNameList *, int);
2429 void findElfAddresses(Dwarf_Debug, Dwarf_Die, staticNameList *);
2430 void getElfAddress(Dwarf_Debug, Dwarf_Die, staticAddrList *);
2431
2432 #if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
2433 #define AFS_N_FILELISTS 2
2434 #define AFS_SYMS_NEEDED 3
2435 #else /* AFS_SGI62_ENV */
2436 #define AFS_N_FILELISTS 1
2437 #endif /* AFS_SGI62_ENV */
2438
2439
2440
2441 void
2442 set_staticaddrs(void)
2443 {
2444     staticNameList fileList[AFS_N_FILELISTS];
2445
2446     fileList[0].addrList =
2447         (staticAddrList *) calloc(1, sizeof(staticAddrList));
2448     if (!fileList[0].addrList) {
2449         printf("set_staticaddrs: Can't calloc fileList[0].addrList\n");
2450         return;
2451     }
2452     fileList[0].file = "nfs_server.c";
2453     fileList[0].found = 0;
2454     fileList[0].nAddrs = 1;
2455     fileList[0].addrList[0].name = "rfsdisptab_v2";
2456     fileList[0].addrList[0].type = DW_AT_location;
2457     fileList[0].addrList[0].found = 0;
2458
2459 #if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
2460     fileList[1].addrList =
2461         (staticAddrList *) calloc(2, sizeof(staticAddrList));
2462     if (!fileList[1].addrList) {
2463         printf("set_staticaddrs: Can't malloc fileList[1].addrList\n");
2464         return;
2465     }
2466     fileList[1].file = "uipc_socket.c";
2467     fileList[1].found = 0;
2468     fileList[1].nAddrs = 2;
2469     fileList[1].addrList[0].name = "sblock";
2470     fileList[1].addrList[0].type = DW_AT_low_pc;
2471     fileList[1].addrList[0].found = 0;
2472     fileList[1].addrList[1].name = "sbunlock";
2473     fileList[1].addrList[1].type = DW_AT_low_pc;
2474     fileList[1].addrList[1].found = 0;
2475
2476     if (64 != sysconf(_SC_KERN_POINTERS))
2477         findMDebugStaticAddresses(fileList, AFS_N_FILELISTS, AFS_SYMS_NEEDED);
2478     else
2479 #endif /* AFS_SGI62_ENV */
2480         findDwarfStaticAddresses(fileList, AFS_N_FILELISTS);
2481
2482     if (fileList[0].addrList[0].found) {
2483         call_syscall(AFSOP_NFSSTATICADDR2, fileList[0].addrList[0].addr.high,
2484                      fileList[0].addrList[0].addr.low);
2485     } else {
2486         if (afsd_verbose)
2487             printf("NFS V2 is not present in the kernel.\n");
2488     }
2489     free(fileList[0].addrList);
2490 #if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
2491     if (fileList[1].addrList[0].found && fileList[1].addrList[1].found) {
2492         call_syscall(AFSOP_SBLOCKSTATICADDR2,
2493                      fileList[1].addrList[0].addr.high,
2494                      fileList[1].addrList[0].addr.low,
2495                      fileList[1].addrList[1].addr.high,
2496                      fileList[1].addrList[1].addr.low);
2497     } else {
2498         if (!fileList[1].addrList[0].found)
2499             printf("Can't find %s in kernel. Exiting.\n",
2500                    fileList[1].addrList[0].name);
2501         if (!fileList[1].addrList[0].found)
2502             printf("Can't find %s in kernel. Exiting.\n",
2503                    fileList[1].addrList[1].name);
2504         exit(1);
2505     }
2506     free(fileList[1].addrList);
2507 #endif /* AFS_SGI62_ENV */
2508 }
2509
2510
2511 /* Find addresses for static variables and functions. */
2512 void
2513 findDwarfStaticAddresses(staticNameList * nameList, int nLists)
2514 {
2515     int fd;
2516     int i;
2517     int found = 0;
2518     int code;
2519     char *s;
2520     char *hname = (char *)0;
2521     Dwarf_Unsigned dwarf_access = O_RDONLY;
2522     Dwarf_Debug dwarf_debug;
2523     Dwarf_Error dwarf_error;
2524     Dwarf_Unsigned dwarf_cu_header_length;
2525     Dwarf_Unsigned dwarf_abbrev_offset;
2526     Dwarf_Half dwarf_address_size;
2527     Dwarf_Unsigned next_cu_header;
2528     Dwarf_Die dwarf_die;
2529     Dwarf_Die dwarf_next_die;
2530     Dwarf_Die dwarf_child_die;
2531
2532     if (elf_version(EV_CURRENT) == EV_NONE) {
2533         printf("findDwarfStaticAddresses: Bad elf version.\n");
2534         return;
2535     }
2536
2537     if ((fd = open("/unix", O_RDONLY, 0)) < 0) {
2538         printf("findDwarfStaticAddresses: Failed to open /unix.\n");
2539         return;
2540     }
2541     code =
2542         dwarf_init(fd, dwarf_access, NULL, NULL, &dwarf_debug, &dwarf_error);
2543     if (code != DW_DLV_OK) {
2544         /* Nope hope for the elves and dwarves, try intermediate code. */
2545         close(fd);
2546         return;
2547     }
2548
2549     found = 0;
2550     while (1) {
2551         /* Run through the headers until we find ones for files we've
2552          * specified in nameList.
2553          */
2554         code =
2555             dwarf_next_cu_header(dwarf_debug, &dwarf_cu_header_length, NULL,
2556                                  &dwarf_abbrev_offset, &dwarf_address_size,
2557                                  &next_cu_header, &dwarf_error);
2558         if (code == DW_DLV_NO_ENTRY) {
2559             break;
2560         } else if (code == DW_DLV_ERROR) {
2561             printf("findDwarfStaticAddresses: Error reading headers: %s\n",
2562                    dwarf_errmsg(dwarf_error));
2563             break;
2564         }
2565
2566         code = dwarf_siblingof(dwarf_debug, NULL, &dwarf_die, &dwarf_error);
2567         if (code != DW_DLV_OK) {
2568             printf("findDwarfStaticAddresses: Can't get first die. %s\n",
2569                    (code == DW_DLV_ERROR) ? dwarf_errmsg(dwarf_error) : "");
2570             break;
2571         }
2572
2573         /* This is the header, test the name. */
2574         code = dwarf_diename(dwarf_die, &hname, &dwarf_error);
2575         if (code == DW_DLV_OK) {
2576             s = strrchr(hname, '/');
2577             for (i = 0; i < nLists; i++) {
2578                 if (s && !strcmp(s + 1, nameList[i].file)) {
2579                     findElfAddresses(dwarf_debug, dwarf_die, &nameList[i]);
2580                     found++;
2581                     break;
2582                 }
2583             }
2584         } else {
2585             printf
2586                 ("findDwarfStaticAddresses: Can't get name of current header. %s\n",
2587                  (code == DW_DLV_ERROR) ? dwarf_errmsg(dwarf_error) : "");
2588             break;
2589         }
2590         dwarf_dealloc(dwarf_debug, hname, DW_DLA_STRING);
2591         hname = (char *)0;
2592         if (found >= nLists) {  /* we're done */
2593             break;
2594         }
2595     }
2596
2597     /* Frees up all allocated space. */
2598     (void)dwarf_finish(dwarf_debug, &dwarf_error);
2599     close(fd);
2600 }
2601
2602 void
2603 findElfAddresses(Dwarf_Debug dwarf_debug, Dwarf_Die dwarf_die,
2604                  staticNameList * nameList)
2605 {
2606     int i;
2607     Dwarf_Error dwarf_error;
2608     Dwarf_Die dwarf_next_die;
2609     Dwarf_Die dwarf_child_die;
2610     Dwarf_Attribute dwarf_return_attr;
2611     char *vname = (char *)0;
2612     int found = 0;
2613     int code;
2614
2615     /* Drop into this die to find names in addrList. */
2616     code = dwarf_child(dwarf_die, &dwarf_child_die, &dwarf_error);
2617     if (code != DW_DLV_OK) {
2618         printf("findElfAddresses: Can't get child die. %s\n",
2619                (code == DW_DLV_ERROR) ? dwarf_errmsg(dwarf_error) : "");
2620         return;
2621     }
2622
2623     /* Try to find names in each sibling. */
2624     dwarf_next_die = (Dwarf_Die) 0;
2625     do {
2626         code = dwarf_diename(dwarf_child_die, &vname, &dwarf_error);
2627         /* It's possible that some siblings don't have names. */
2628         if (code == DW_DLV_OK) {
2629             for (i = 0; i < nameList->nAddrs; i++) {
2630                 if (!nameList->addrList[i].found) {
2631                     if (!strcmp(vname, nameList->addrList[i].name)) {
2632                         getElfAddress(dwarf_debug, dwarf_child_die,
2633                                       &(nameList->addrList[i]));
2634                         found++;
2635                         break;
2636                     }
2637                 }
2638             }
2639         }
2640         if (dwarf_next_die)
2641             dwarf_dealloc(dwarf_debug, dwarf_next_die, DW_DLA_DIE);
2642
2643         if (found >= nameList->nAddrs) {        /* we're done. */
2644             break;
2645         }
2646
2647         dwarf_next_die = dwarf_child_die;
2648         code =
2649             dwarf_siblingof(dwarf_debug, dwarf_next_die, &dwarf_child_die,
2650                             &dwarf_error);
2651
2652     } while (code == DW_DLV_OK);
2653 }
2654
2655 /* Get address out of current die. */
2656 void
2657 getElfAddress(Dwarf_Debug dwarf_debug, Dwarf_Die dwarf_child_die,
2658               staticAddrList * addrList)
2659 {
2660     int i;
2661     Dwarf_Error dwarf_error;
2662     Dwarf_Attribute dwarf_return_attr;
2663     Dwarf_Bool dwarf_return_bool;
2664     Dwarf_Locdesc *llbuf = NULL;
2665     Dwarf_Signed listlen;
2666     off64_t addr = (off64_t) 0;
2667     int code;
2668
2669     code =
2670         dwarf_hasattr(dwarf_child_die, addrList->type, &dwarf_return_bool,
2671                       &dwarf_error);
2672     if ((code != DW_DLV_OK) || (!dwarf_return_bool)) {
2673         printf("getElfAddress: no address given for %s. %s\n", addrList->name,
2674                (code == DW_DLV_ERROR) ? dwarf_errmsg(dwarf_error) : "");
2675         return;
2676     }
2677     code =
2678         dwarf_attr(dwarf_child_die, addrList->type, &dwarf_return_attr,
2679                    &dwarf_error);
2680     if (code != DW_DLV_OK) {
2681         printf("getElfAddress: Can't get attribute. %s\n",
2682                (code == DW_DLV_ERROR) ? dwarf_errmsg(dwarf_error) : "");
2683         return;
2684     }
2685
2686     switch (addrList->type) {
2687     case DW_AT_location:
2688         code =
2689             dwarf_loclist(dwarf_return_attr, &llbuf, &listlen, &dwarf_error);
2690         if (code != DW_DLV_OK) {
2691             printf("getElfAddress: Can't get location for %s. %s\n",
2692                    addrList->name,
2693                    (code == DW_DLV_ERROR) ? dwarf_errmsg(dwarf_error) : "");
2694             return;
2695         }
2696         if ((listlen != 1) || (llbuf[0].ld_cents != 1)) {
2697             printf("getElfAddress: %s has more than one address.\n",
2698                    addrList->name);
2699             return;
2700         }
2701         addr = llbuf[0].ld_s[0].lr_number;
2702         break;
2703
2704     case DW_AT_low_pc:
2705         code =
2706             dwarf_lowpc(dwarf_child_die, (Dwarf_Addr *) & addr, &dwarf_error);
2707         if (code != DW_DLV_OK) {
2708             printf("getElfAddress: Can't get lowpc for %s. %s\n",
2709                    addrList->name,
2710                    (code == DW_DLV_ERROR) ? dwarf_errmsg(dwarf_error) : "");
2711             return;
2712         }
2713         break;
2714
2715     default:
2716         printf("getElfAddress: Bad case %d in switch.\n", addrList->type);
2717         return;
2718     }
2719
2720     addrList->addr.high = (addr >> 32) & 0xffffffff;
2721     addrList->addr.low = addr & 0xffffffff;
2722     addrList->found = 1;
2723 }
2724
2725 #if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
2726 /* Find symbols in the .mdebug section for 32 bit kernels. */
2727 /*
2728  * do_mdebug()
2729  * On 32bit platforms, we're still using the ucode compilers to build
2730  * the kernel, so we need to get our static text/data from the .mdebug
2731  * section instead of the .dwarf sections.
2732  */
2733 /* SearchNameList searches our bizarre structs for the given string.
2734  * If found, sets the found bit and the address and returns 1.
2735  * Not found returns 0.
2736  */
2737 int
2738 SearchNameList(char *name, afs_uint32 addr, staticNameList * nameList,
2739                int nLists)
2740 {
2741     int i, j;
2742     for (i = 0; i < nLists; i++) {
2743         for (j = 0; j < nameList[i].nAddrs; j++) {
2744             if (nameList[i].addrList[j].found)
2745                 continue;
2746             if (!strcmp(name, nameList[i].addrList[j].name)) {
2747                 nameList[i].addrList[j].addr.high = 0;
2748                 nameList[i].addrList[j].addr.low = addr;
2749                 nameList[i].addrList[j].found = 1;
2750                 return 1;
2751             }
2752         }
2753     }
2754     return 0;
2755 }
2756
2757 static void
2758 SearchMDebug(Elf_Scn * scnp, Elf32_Shdr * shdrp, staticNameList * nameList,
2759              int nLists, int needed)
2760 {
2761     long *buf = (long *)(elf_getdata(scnp, NULL)->d_buf);
2762     u_long addr, mdoff = shdrp->sh_offset;
2763     HDRR *hdrp;
2764     SYMR *symbase, *symp, *symend;
2765     FDR *fdrbase, *fdrp;
2766     int i, j;
2767     char *strbase, *str;
2768     int ifd;
2769     int nFound = 0;
2770
2771     /* get header */
2772     addr = (__psunsigned_t) buf;
2773     hdrp = (HDRR *) addr;
2774
2775     /* setup base addresses */
2776     addr = (u_long) buf + (u_long) (hdrp->cbFdOffset - mdoff);
2777     fdrbase = (FDR *) addr;
2778     addr = (u_long) buf + (u_long) (hdrp->cbSymOffset - mdoff);
2779     symbase = (SYMR *) addr;
2780     addr = (u_long) buf + (u_long) (hdrp->cbSsOffset - mdoff);
2781     strbase = (char *)addr;
2782
2783 #define KEEPER(a,b)     ((a == stStaticProc && b == scText) || \
2784                          (a == stStatic && (b == scData || b == scBss || \
2785                                             b == scSBss || b == scSData)))
2786
2787     for (fdrp = fdrbase; fdrp < &fdrbase[hdrp->ifdMax]; fdrp++) {
2788         str = strbase + fdrp->issBase + fdrp->rss;
2789
2790         /* local symbols for each fd */
2791         for (symp = &symbase[fdrp->isymBase];
2792              symp < &symbase[fdrp->isymBase + fdrp->csym]; symp++) {
2793             if (KEEPER(symp->st, symp->sc)) {
2794                 if (symp->value == 0)
2795                     continue;
2796
2797                 str = strbase + fdrp->issBase + symp->iss;
2798                 /* Look for AFS symbols of interest */
2799                 if (SearchNameList(str, symp->value, nameList, nLists)) {
2800                     nFound++;
2801                     if (nFound >= needed)
2802                         return;
2803                 }
2804             }
2805         }
2806     }
2807 }
2808
2809 /*
2810  * returns section with the name of scn_name, & puts its header in shdr64 or
2811  * shdr32 based on elf's file type
2812  *
2813  */
2814 Elf_Scn *
2815 findMDebugSection(Elf * elf, char *scn_name)
2816 {
2817     Elf64_Ehdr *ehdr64;
2818     Elf32_Ehdr *ehdr32;
2819     Elf_Scn *scn = NULL;
2820     Elf64_Shdr *shdr64;
2821     Elf32_Shdr *shdr32;
2822
2823     if ((ehdr32 = elf32_getehdr(elf)) == NULL)
2824         return (NULL);
2825     do {
2826         if ((scn = elf_nextscn(elf, scn)) == NULL)
2827             break;
2828         if ((shdr32 = elf32_getshdr(scn)) == NULL)
2829             return (NULL);
2830     } while (strcmp
2831              (scn_name,
2832               elf_strptr(elf, ehdr32->e_shstrndx, shdr32->sh_name)));
2833
2834     return (scn);
2835 }
2836
2837
2838 void
2839 findMDebugStaticAddresses(staticNameList * nameList, int nLists, int needed)
2840 {
2841     int fd;
2842     Elf *elf;
2843     Elf_Scn *mdebug_scn;
2844     Elf32_Shdr *mdebug_shdr;
2845     char *names;
2846
2847     if ((fd = open("/unix", O_RDONLY)) == -1) {
2848         printf("findMDebugStaticAddresses: Failed to open /unix.\n");
2849         return;
2850     }
2851
2852     (void)elf_version(EV_CURRENT);
2853     if ((elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
2854         printf
2855             ("findMDebugStaticAddresses: /unix doesn't seem to be an elf file\n");
2856         close(fd);
2857         return;
2858     }
2859     mdebug_scn = findMDebugSection(elf, ".mdebug");
2860     if (!mdebug_scn) {
2861         printf("findMDebugStaticAddresses: Can't find .mdebug section.\n");
2862         goto find_end;
2863     }
2864     mdebug_shdr = elf32_getshdr(mdebug_scn);
2865     if (!mdebug_shdr) {
2866         printf("findMDebugStaticAddresses: Can't find .mdebug header.\n");
2867         goto find_end;
2868     }
2869
2870     (void)SearchMDebug(mdebug_scn, mdebug_shdr, nameList, nLists, needed);
2871
2872   find_end:
2873     elf_end(elf);
2874     close(fd);
2875 }
2876 #endif /* AFS_SGI62_ENV */
2877
2878 #else /* AFS_SGI61_ENV */
2879 #include <nlist.h>
2880 struct nlist nlunix[] = {
2881     {"rfsdisptab_v2"},
2882     {0},
2883 };
2884
2885 get_nfsstaticaddr()
2886 {
2887     int i, j, kmem, count;
2888
2889     if ((kmem = open("/dev/kmem", O_RDONLY)) < 0) {
2890         printf("Warning: can't open /dev/kmem\n");
2891         return 0;
2892     }
2893     if ((j = nlist("/unix", nlunix)) < 0) {
2894         printf("Warning: can't nlist /unix\n");
2895         return 0;
2896     }
2897     i = nlunix[0].n_value;
2898     if (lseek(kmem, i, L_SET /*0 */ ) != i) {
2899         printf("Warning: can't lseek to %x\n", i);
2900         return 0;
2901     }
2902     if ((j = read(kmem, &count, sizeof count)) != sizeof count) {
2903         printf("WARNING: kmem read at %x failed\n", i);
2904         return 0;
2905     }
2906     return i;
2907 }
2908 #endif /* AFS_SGI61_ENV */
2909 #endif /* AFS_SGI53_ENV */