afsd-bitch-about-xfs-not-about-dir-for-memcache-20040708
[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         } else if  (statfsbuf.f_type == 0x58465342) { /* XFS_SUPER_MAGIC */
1053             return "cannot use xfs as cache partition";
1054         }
1055     }
1056 #endif
1057
1058 #ifdef AFS_HPUX_ENV
1059     {
1060         int res;
1061         struct statfs statfsbuf;
1062         char name[FSTYPSZ];
1063
1064         res = statfs(dir, &statfsbuf);
1065         if (res != 0) {
1066             return "unable to statfs cache base directory";
1067         }
1068
1069         if (sysfs(GETFSTYP, statfsbuf.f_fsid[1], name) != 0) {
1070             return "unable to determine filesystem type for cache base dir";
1071         }
1072
1073         if (strcmp(name, "hfs")) {
1074             return "can only use hfs filesystem for cache partition on hpux";
1075         }
1076     }
1077 #endif
1078
1079 #ifdef AFS_SUN5_ENV
1080     {
1081         FILE *vfstab;
1082         struct mnttab mnt;
1083         struct stat statmnt, statci;
1084
1085         if ((stat(dir, &statci) == 0)
1086             && ((vfstab = fopen(MNTTAB, "r")) != NULL)) {
1087             while (getmntent(vfstab, &mnt) == 0) {
1088                 if (strcmp(dir, mnt.mnt_mountp) != 0) {
1089                     char *cp;
1090                     int rdev = 0;
1091
1092                     if (cp = hasmntopt(&mnt, "dev="))
1093                         rdev =
1094                             (int)strtol(cp + strlen("dev="), (char **)NULL,
1095                                         16);
1096
1097                     if ((rdev == 0) && (stat(mnt.mnt_mountp, &statmnt) == 0))
1098                         rdev = statmnt.st_dev;
1099
1100                     if ((rdev == statci.st_dev)
1101                         && (hasmntopt(&mnt, "logging") != NULL)) {
1102
1103                         fclose(vfstab);
1104                         return
1105                             "mounting a multi-use partition which contains the AFS cache with the\n\"logging\" option may deadlock your system.\n\n";
1106                     }
1107                 }
1108             }
1109
1110             fclose(vfstab);
1111         }
1112     }
1113 #endif
1114
1115     return NULL;
1116 }
1117
1118 int
1119 SweepAFSCache(vFilesFound)
1120      int *vFilesFound;
1121 {
1122     static char rn[] = "SweepAFSCache"; /*Routine name */
1123     int maxDir = (cacheFiles + nFilesPerDir - 1) / nFilesPerDir;
1124     int i;
1125
1126     *vFilesFound = 0;
1127
1128     if (cacheFlags & AFSCALL_INIT_MEMCACHE) {
1129         if (afsd_debug)
1130             printf("%s: Memory Cache, no cache sweep done\n", rn);
1131         return 0;
1132     }
1133
1134     if (cache_dir_list == NULL) {
1135         cache_dir_list = (int *)malloc(maxDir * sizeof(*cache_dir_list));
1136         if (cache_dir_list == NULL) {
1137             printf("%s: Malloc Failed!\n", rn);
1138             return (-1);
1139         }
1140         for (i = 0; i < maxDir; i++)
1141             cache_dir_list[i] = -1;     /* Does not exist */
1142     }
1143
1144     if (cache_dir_filelist == NULL) {
1145         cache_dir_filelist = (struct afsd_file_list **)
1146             malloc(maxDir * sizeof(*cache_dir_filelist));
1147         if (cache_dir_filelist == NULL) {
1148             printf("%s: Malloc Failed!\n", rn);
1149             return (-1);
1150         }
1151         memset(cache_dir_filelist, 0, maxDir * sizeof(*cache_dir_filelist));
1152     }
1153
1154     if (dir_for_V == NULL) {
1155         dir_for_V = (int *)malloc(cacheFiles * sizeof(*dir_for_V));
1156         if (dir_for_V == NULL) {
1157             printf("%s: Malloc Failed!\n", rn);
1158             return (-1);
1159         }
1160         for (i = 0; i < cacheFiles; i++)
1161             dir_for_V[i] = -1;  /* Does not exist */
1162     }
1163
1164     /* Note, setting dirNum to -2 here will cause cachefiles found in
1165      * the toplevel directory to be marked in directory "-2".  This
1166      * allows us to differentiate between 'file not seen' (-1) and
1167      * 'file seen in top-level' (-2).  Then when we try to move the
1168      * file into a subdirectory, we know it's in the top-level instead
1169      * of some other cache subdir.
1170      */
1171     return doSweepAFSCache(vFilesFound, cacheBaseDir, -2, maxDir);
1172 }
1173
1174 static
1175 ConfigCell(aci, arock, adir)
1176      register struct afsconf_cell *aci;
1177      char *arock;
1178      struct afsconf_dir *adir;
1179 {
1180     register int isHomeCell;
1181     register int i, code;
1182     afs_int32 cellFlags = 0;
1183     afs_int32 hosts[MAXHOSTSPERCELL];
1184
1185     /* figure out if this is the home cell */
1186     isHomeCell = (strcmp(aci->name, LclCellName) == 0);
1187     if (!isHomeCell)
1188         cellFlags = 2;          /* not home, suid is forbidden */
1189
1190     /* build address list */
1191     for (i = 0; i < MAXHOSTSPERCELL; i++)
1192         memcpy(&hosts[i], &aci->hostAddr[i].sin_addr, sizeof(afs_int32));
1193
1194     if (aci->linkedCell)
1195         cellFlags |= 4;         /* Flag that linkedCell arg exists,
1196                                  * for upwards compatibility */
1197
1198     /* configure one cell */
1199     code = call_syscall(AFSOP_ADDCELL2, hosts,  /* server addresses */
1200                         aci->name,      /* cell name */
1201                         cellFlags,      /* is this the home cell? */
1202                         aci->linkedCell);       /* Linked cell, if any */
1203     if (code)
1204         printf("Adding cell '%s': error %d\n", aci->name, code);
1205     return 0;
1206 }
1207
1208 static
1209 ConfigCellAlias(aca, arock, adir)
1210      register struct afsconf_cellalias *aca;
1211      char *arock;
1212      struct afsconf_dir *adir;
1213 {
1214     /* push the alias into the kernel */
1215     call_syscall(AFSOP_ADDCELLALIAS, aca->aliasName, aca->realName);
1216     return 0;
1217 }
1218
1219 #ifdef AFS_AFSDB_ENV
1220 static
1221 AfsdbLookupHandler()
1222 {
1223     afs_int32 kernelMsg[64];
1224     char acellName[128];
1225     afs_int32 code;
1226     struct afsconf_cell acellInfo;
1227     int i;
1228
1229     kernelMsg[0] = 0;
1230     kernelMsg[1] = 0;
1231     acellName[0] = '\0';
1232
1233     while (1) {
1234         /* On some platforms you only get 4 args to an AFS call */
1235         int sizeArg = ((sizeof acellName) << 16) | (sizeof kernelMsg);
1236         code =
1237             call_syscall(AFSOP_AFSDB_HANDLER, acellName, kernelMsg, sizeArg);
1238         if (code) {             /* Something is wrong? */
1239             sleep(1);
1240             continue;
1241         }
1242
1243         if (*acellName == 1)    /* Shutting down */
1244             break;
1245
1246         code = afsconf_GetAfsdbInfo(acellName, 0, &acellInfo);
1247         if (code) {
1248             kernelMsg[0] = 0;
1249             kernelMsg[1] = 0;
1250         } else {
1251             kernelMsg[0] = acellInfo.numServers;
1252             if (acellInfo.timeout)
1253                 kernelMsg[1] = acellInfo.timeout - time(0);
1254             else
1255                 kernelMsg[1] = 0;
1256             for (i = 0; i < acellInfo.numServers; i++)
1257                 kernelMsg[i + 2] = acellInfo.hostAddr[i].sin_addr.s_addr;
1258             strncpy(acellName, acellInfo.name, sizeof(acellName));
1259             acellName[sizeof(acellName) - 1] = '\0';
1260         }
1261     }
1262
1263     exit(1);
1264 }
1265 #endif
1266
1267 #ifdef mac2
1268 #include <sys/ioctl.h>
1269 #endif /* mac2 */
1270
1271 #ifdef AFS_SGI65_ENV
1272 #define SET_RTPRI(P) {  \
1273     struct sched_param sp; \
1274     sp.sched_priority = P; \
1275     if (sched_setscheduler(0, SCHED_RR, &sp)<0) { \
1276         perror("sched_setscheduler"); \
1277     } \
1278 }
1279 #define SET_AFSD_RTPRI() SET_RTPRI(68)
1280 #define SET_RX_RTPRI()   SET_RTPRI(199)
1281 #else
1282 #ifdef AFS_LINUX20_ENV
1283 #define SET_AFSD_RTPRI()
1284 #define SET_RX_RTPRI()  do { if (setpriority(PRIO_PROCESS, 0, -10)<0) \
1285                            perror("setting rx priority"); \
1286                          } while (0)
1287 #else
1288 #define SET_AFSD_RTPRI()
1289 #define SET_RX_RTPRI()
1290 #endif
1291 #endif
1292
1293 mainproc(as, arock)
1294      register struct cmd_syndesc *as;
1295      char *arock;
1296 {
1297     static char rn[] = "afsd";  /*Name of this routine */
1298     register afs_int32 code;    /*Result of fork() */
1299     register int i;
1300     int currVFile;              /*Current AFS cache file number passed in */
1301     int mountFlags;             /*Flags passed to mount() */
1302     int lookupResult;           /*Result of GetLocalCellName() */
1303     int cacheIteration;         /*How many times through cache verification */
1304     int vFilesFound;            /*How many data cache files were found in sweep */
1305     struct afsconf_dir *cdir;   /* config dir */
1306     FILE *logfd;
1307     char *fsTypeMsg = NULL;
1308 #ifdef  AFS_SUN5_ENV
1309     struct stat st;
1310 #endif
1311     afs_int32 vfs1_type = -1;
1312 #ifdef AFS_SGI65_ENV
1313     struct sched_param sp;
1314 #endif
1315
1316 #ifdef AFS_SGI_VNODE_GLUE
1317     if (afs_init_kernel_config(-1) < 0) {
1318         printf("Can't determine NUMA configuration, not starting AFS.\n");
1319         exit(1);
1320     }
1321 #endif
1322
1323     /* call atoi on the appropriate parsed results */
1324     if (as->parms[0].items) {
1325         /* -blocks */
1326         cacheBlocks = atoi(as->parms[0].items->data);
1327         sawCacheBlocks = 1;
1328     }
1329     if (as->parms[1].items) {
1330         /* -files */
1331         cacheFiles = atoi(as->parms[1].items->data);
1332         filesSet = 1;           /* set when spec'd on cmd line */
1333     }
1334     if (as->parms[2].items) {
1335         /* -rootvol */
1336         strcpy(rootVolume, as->parms[2].items->data);
1337         rootVolSet = 1;
1338     }
1339     if (as->parms[3].items) {
1340         /* -stat */
1341         cacheStatEntries = atoi(as->parms[3].items->data);
1342     }
1343     if (as->parms[4].items) {
1344         /* -memcache */
1345         cacheBaseDir[0] = '\0';
1346         sawCacheBaseDir = 1;
1347         cacheFlags |= AFSCALL_INIT_MEMCACHE;
1348         if (chunkSize == 0)
1349             chunkSize = 13;
1350     }
1351     if (as->parms[5].items) {
1352         /* -cachedir */
1353         strcpy(cacheBaseDir, as->parms[5].items->data);
1354         sawCacheBaseDir = 1;
1355     }
1356     if (as->parms[6].items) {
1357         /* -mountdir */
1358         strcpy(cacheMountDir, as->parms[6].items->data);
1359         sawCacheMountDir = 1;
1360     }
1361     if (as->parms[7].items) {
1362         /* -daemons */
1363         nDaemons = atoi(as->parms[7].items->data);
1364     }
1365     if (as->parms[8].items) {
1366         /* -nosettime */
1367         cacheSetTime = FALSE;
1368     }
1369     if (as->parms[9].items) {
1370         /* -verbose */
1371         afsd_verbose = 1;
1372     }
1373     if (as->parms[10].items) {
1374         /* -rmtsys */
1375         afsd_rmtsys = 1;
1376     }
1377     if (as->parms[11].items) {
1378         /* -debug */
1379         afsd_debug = 1;
1380         afsd_verbose = 1;
1381     }
1382     if (as->parms[12].items) {
1383         /* -chunksize */
1384         chunkSize = atoi(as->parms[12].items->data);
1385         if (chunkSize < 0 || chunkSize > 30) {
1386             printf("afsd:invalid chunk size spec'd, using default\n");
1387             chunkSize = 0;
1388         }
1389     }
1390     if (as->parms[13].items) {
1391         /* -dcache */
1392         dCacheSize = atoi(as->parms[13].items->data);
1393         sawDCacheSize = 1;
1394     }
1395     if (as->parms[14].items) {
1396         /* -volumes */
1397         vCacheSize = atoi(as->parms[14].items->data);
1398     }
1399     if (as->parms[15].items) {
1400         /* -biods */
1401 #ifndef AFS_AIX32_ENV
1402         printf
1403             ("afsd: [-biods] currently only enabled for aix3.x VM supported systems\n");
1404 #else
1405         nBiods = atoi(as->parms[15].items->data);
1406         sawBiod = 1;
1407 #endif
1408     }
1409     if (as->parms[16].items) {
1410         /* -prealloc */
1411         preallocs = atoi(as->parms[16].items->data);
1412     }
1413 #ifdef notdef
1414     if (as->parms[17].items) {
1415         /* -pininodes */
1416         inodes = atoi(as->parms[17].items->data);
1417     }
1418 #endif
1419     strcpy(confDir, AFSDIR_CLIENT_ETC_DIRPATH);
1420     if (as->parms[17].items) {
1421         /* -confdir */
1422         strcpy(confDir, as->parms[17].items->data);
1423     }
1424     sprintf(fullpn_CacheInfo, "%s/%s", confDir, CACHEINFOFILE);
1425     sprintf(fullpn_AFSLogFile, "%s/%s", confDir, AFSLOGFILE);
1426     if (as->parms[18].items) {
1427         /* -logfile */
1428         strcpy(fullpn_AFSLogFile, as->parms[18].items->data);
1429     }
1430     if (as->parms[19].items) {
1431         /* -waitclose */
1432         afsd_CloseSynch = 1;
1433     }
1434     if (as->parms[20].items) {
1435         /* -shutdown */
1436         afs_shutdown = 1;
1437         /* 
1438          * Cold shutdown is the default
1439          */
1440         printf("afsd: Shutting down all afs processes and afs state\n");
1441         code = call_syscall(AFSOP_SHUTDOWN, 1);
1442         if (code) {
1443             printf("afsd: AFS still mounted; Not shutting down\n");
1444             exit(1);
1445         }
1446         exit(0);
1447     }
1448     if (as->parms[21].items) {
1449         /* -enable_peer_stats */
1450         enable_peer_stats = 1;
1451     }
1452     if (as->parms[22].items) {
1453         /* -enable_process_stats */
1454         enable_process_stats = 1;
1455     }
1456     if (as->parms[23].items) {
1457         /* -mem_alloc_sleep */
1458         cacheFlags |= AFSCALL_INIT_MEMCACHE_SLEEP;
1459     }
1460     if (as->parms[24].items) {
1461         /* -afsdb */
1462 #ifdef AFS_AFSDB_ENV
1463         enable_afsdb = 1;
1464 #else
1465         printf("afsd: No AFSDB support; ignoring -afsdb");
1466 #endif
1467     }
1468     if (as->parms[25].items) {
1469         /* -files_per_subdir */
1470         int res = atoi(as->parms[25].items->data);
1471         if (res < 10 || res > 2 ^ 30) {
1472             printf
1473                 ("afsd:invalid number of files per subdir, \"%s\". Ignored\n",
1474                  as->parms[25].items->data);
1475         } else {
1476             nFilesPerDir = res;
1477         }
1478     }
1479     if (as->parms[26].items) {
1480         /* -dynroot */
1481         enable_dynroot = 1;
1482     }
1483     if (as->parms[27].items) {
1484         /* -fakestat */
1485         enable_fakestat = 2;
1486     }
1487     if (as->parms[28].items) {
1488         /* -fakestat-all */
1489         enable_fakestat = 1;
1490     }
1491     if (as->parms[29].items) {
1492         /* -nomount */
1493         enable_nomount = 1;
1494     }
1495     if (as->parms[30].items) {
1496         /* -backuptree */
1497         enable_backuptree = 1;
1498     }
1499
1500     /*
1501      * Pull out all the configuration info for the workstation's AFS cache and
1502      * the cellular community we're willing to let our users see.
1503      */
1504     cdir = afsconf_Open(confDir);
1505     if (!cdir) {
1506         printf("afsd: some file missing or bad in %s\n", confDir);
1507         exit(1);
1508     }
1509
1510     lookupResult =
1511         afsconf_GetLocalCell(cdir, LclCellName, sizeof(LclCellName));
1512     if (lookupResult) {
1513         printf("%s: Can't get my home cell name!  [Error is %d]\n", rn,
1514                lookupResult);
1515     } else {
1516         if (afsd_verbose)
1517             printf("%s: My home cell is '%s'\n", rn, LclCellName);
1518     }
1519
1520     /* parse cacheinfo file if this is a diskcache */
1521     if (ParseCacheInfoFile()) {
1522         exit(1);
1523     }
1524
1525     if ((logfd = fopen(fullpn_AFSLogFile, "r+")) == 0) {
1526         if (afsd_verbose)
1527             printf("%s: Creating '%s'\n", rn, fullpn_AFSLogFile);
1528         if (CreateCacheFile(fullpn_AFSLogFile, NULL)) {
1529             printf
1530                 ("%s: Can't create '%s' (You may want to use the -logfile option)\n",
1531                  rn, fullpn_AFSLogFile);
1532             exit(1);
1533         }
1534     } else
1535         fclose(logfd);
1536
1537     /* do some random computations in memcache case to get things to work
1538      * reasonably no matter which parameters you set.
1539      */
1540     if (cacheFlags & AFSCALL_INIT_MEMCACHE) {
1541         /* memory cache: size described either as blocks or dcache entries, but
1542          * not both.
1543          */
1544         if (sawDCacheSize) {
1545             if (sawCacheBlocks) {
1546                 printf
1547                     ("%s: can't set cache blocks and dcache size simultaneously when diskless.\n",
1548                      rn);
1549                 exit(1);
1550             }
1551             /* compute the cache size based on # of chunks times the chunk size */
1552             i = (chunkSize == 0 ? 13 : chunkSize);
1553             i = (1 << i);       /* bytes per chunk */
1554             cacheBlocks = i * dCacheSize;
1555             sawCacheBlocks = 1; /* so that ParseCacheInfoFile doesn't overwrite */
1556         } else {
1557             /* compute the dcache size from overall cache size and chunk size */
1558             i = (chunkSize == 0 ? 13 : chunkSize);
1559             /* dCacheSize = (cacheBlocks << 10) / (1<<i); */
1560             if (i > 10) {
1561                 dCacheSize = (cacheBlocks >> (i - 10));
1562             } else if (i < 10) {
1563                 dCacheSize = (cacheBlocks << (10 - i));
1564             } else {
1565                 dCacheSize = cacheBlocks;
1566             }
1567             /* don't have to set sawDCacheSize here since it isn't overwritten
1568              * by ParseCacheInfoFile.
1569              */
1570         }
1571         /* kernel computes # of dcache entries as min of cacheFiles and dCacheSize,
1572          * so we now make them equal.
1573          */
1574         cacheFiles = dCacheSize;
1575     } else {
1576         /* Disk cache:
1577          * Compute the number of cache files based on cache size,
1578          * but only if -files isn't given on the command line.
1579          * Don't let # files be so small as to prevent full utilization 
1580          * of the cache unless user has explicitly asked for it.
1581          * average V-file is ~10K, according to tentative empirical studies.
1582          */
1583         if (!filesSet) {
1584             cacheFiles = cacheBlocks / 10;
1585             if (cacheFiles < 100)
1586                 cacheFiles = 100;
1587             /* Always allow more files than chunks.  Presume average V-file 
1588              * is ~67% of a chunk...  (another guess, perhaps Honeyman will
1589              * have a grad student write a paper).  i is KILOBYTES.
1590              */
1591             i = 1 << (chunkSize ==
1592                       0 ? 6 : (chunkSize < 10 ? 0 : chunkSize - 10));
1593             cacheFiles = max(cacheFiles, 1.5 * (cacheBlocks / i));
1594             /* never permit more files than blocks, while leaving space for
1595              * VolumeInfo and CacheItems files.  VolumeInfo is usually 20K,
1596              * CacheItems is 50 Bytes / file (== 1K/20)
1597              */
1598 #define VOLINFOSZ 20
1599 #define CACHEITMSZ (cacheFiles / 20)
1600 #ifdef AFS_AIX_ENV
1601             cacheFiles =
1602                 min(cacheFiles, (cacheBlocks - VOLINFOSZ - CACHEITMSZ) / 4);
1603 #else
1604             cacheFiles =
1605                 min(cacheFiles, cacheBlocks - VOLINFOSZ - CACHEITMSZ);
1606 #endif
1607             if (cacheFiles < 100)
1608                 fprintf(stderr, "%s: WARNING: cache probably too small!\n",
1609                         rn);
1610         }
1611         if (!sawDCacheSize) {
1612             if ((cacheFiles / 2) > dCacheSize)
1613                 dCacheSize = cacheFiles / 2;
1614             if (dCacheSize > 2000)
1615                 dCacheSize = 2000;
1616         }
1617     }
1618
1619     /*
1620      * Create and zero the inode table for the desired cache files.
1621      */
1622     inode_for_V = (AFSD_INO_T *) malloc(cacheFiles * sizeof(AFSD_INO_T));
1623     if (inode_for_V == (AFSD_INO_T *) 0) {
1624         printf
1625             ("%s: malloc() failed for cache file inode table with %d entries.\n",
1626              rn, cacheFiles);
1627         exit(1);
1628     }
1629     memset(inode_for_V, '\0', (cacheFiles * sizeof(AFSD_INO_T)));
1630     if (afsd_debug)
1631         printf("%s: %d inode_for_V entries at 0x%x, %d bytes\n", rn,
1632                cacheFiles, inode_for_V, (cacheFiles * sizeof(AFSD_INO_T)));
1633
1634     /*
1635      * Set up all the pathnames we'll need for later.
1636      */
1637     sprintf(fullpn_DCacheFile, "%s/%s", cacheBaseDir, DCACHEFILE);
1638     sprintf(fullpn_VolInfoFile, "%s/%s", cacheBaseDir, VOLINFOFILE);
1639     sprintf(fullpn_CellInfoFile, "%s/%s", cacheBaseDir, CELLINFOFILE);
1640     sprintf(fullpn_VFile, "%s/", cacheBaseDir);
1641     vFilePtr = fullpn_VFile + strlen(fullpn_VFile);
1642
1643     if  (!(cacheFlags & AFSCALL_INIT_MEMCACHE) && (fsTypeMsg = CheckCacheBaseDir(cacheBaseDir))) {
1644         printf("%s: WARNING: Cache dir check failed (%s)\n", rn, fsTypeMsg);
1645     }
1646 #if 0
1647     fputs(AFS_GOVERNMENT_MESSAGE, stdout);
1648     fflush(stdout);
1649 #endif
1650
1651     /*
1652      * Set up all the kernel processes needed for AFS.
1653      */
1654 #ifdef mac2
1655     setpgrp(getpid(), 0);
1656 #endif /* mac2 */
1657
1658     /* Initialize RX daemons and services */
1659
1660     /* initialize the rx random number generator from user space */
1661     {
1662         /* parse multihomed address files */
1663         afs_int32 addrbuf[MAXIPADDRS], maskbuf[MAXIPADDRS],
1664             mtubuf[MAXIPADDRS];
1665         char reason[1024];
1666         code =
1667             parseNetFiles(addrbuf, maskbuf, mtubuf, MAXIPADDRS, reason,
1668                           AFSDIR_CLIENT_NETINFO_FILEPATH,
1669                           AFSDIR_CLIENT_NETRESTRICT_FILEPATH);
1670         if (code > 0)
1671             call_syscall(AFSOP_ADVISEADDR, code, addrbuf, maskbuf, mtubuf);
1672         else
1673             printf("ADVISEADDR: Error in specifying interface addresses:%s\n",
1674                    reason);
1675     }
1676
1677     /* Set realtime priority for most threads to same as for biod's. */
1678     SET_AFSD_RTPRI();
1679
1680 #ifdef  AFS_SGI53_ENV
1681 #ifdef AFS_SGI61_ENV
1682     set_staticaddrs();
1683 #else /* AFS_SGI61_ENV */
1684     code = get_nfsstaticaddr();
1685     if (code)
1686         call_syscall(AFSOP_NFSSTATICADDR, code);
1687 #endif /* AFS_SGI61_ENV */
1688 #endif /* AFS_SGI_53_ENV */
1689
1690     /* Start listener, then callback listener. Lastly, start rx event daemon.
1691      * Change in ordering is so that Linux port has socket fd in listener
1692      * process.
1693      * preallocs are passed for both listener and callback server. Only
1694      * the one which actually does the initialization uses them though.
1695      */
1696     if (preallocs < cacheStatEntries + 50)
1697         preallocs = cacheStatEntries + 50;
1698 #ifdef RXK_LISTENER_ENV
1699     if (afsd_verbose)
1700         printf("%s: Forking rx listener daemon.\n", rn);
1701     code = fork();
1702     if (code == 0) {
1703         /* Child */
1704         SET_RX_RTPRI();         /* max advised for non-interrupts */
1705         call_syscall(AFSOP_RXLISTENER_DAEMON, preallocs, enable_peer_stats,
1706                      enable_process_stats);
1707         exit(1);
1708     }
1709 #endif
1710     if (afsd_verbose)
1711         printf("%s: Forking rx callback listener.\n", rn);
1712     code = fork();
1713     if (code == 0) {
1714         /* Child */
1715         call_syscall(AFSOP_START_RXCALLBACK, preallocs);
1716         exit(1);
1717     }
1718 #if defined(AFS_SUN5_ENV) || defined(RXK_LISTENER_ENV)
1719     if (afsd_verbose)
1720         printf("%s: Forking rxevent daemon.\n", rn);
1721     code = fork();
1722     if (code == 0) {
1723         /* Child */
1724         SET_RX_RTPRI();         /* max advised for non-interrupts */
1725         call_syscall(AFSOP_RXEVENT_DAEMON);
1726         exit(1);
1727     }
1728 #endif
1729
1730 #ifdef AFS_AFSDB_ENV
1731     if (enable_afsdb) {
1732         if (afsd_verbose)
1733             printf("%s: Forking AFSDB lookup handler.\n", rn);
1734         code = fork();
1735         if (code == 0) {
1736             AfsdbLookupHandler();
1737             exit(1);
1738         }
1739     }
1740 #endif
1741
1742     code = call_syscall(AFSOP_BASIC_INIT, 1);
1743     if (code)
1744         printf("%s: Error %d in basic initialization.\n", rn, code);
1745
1746     /*
1747      * Tell the kernel some basic information about the workstation's cache.
1748      */
1749     if (afsd_verbose)
1750         printf
1751             ("%s: Calling AFSOP_CACHEINIT: %d stat cache entries, %d optimum cache files, %d blocks in the cache, flags = 0x%x, dcache entries %d\n",
1752              rn, cacheStatEntries, cacheFiles, cacheBlocks, cacheFlags,
1753              dCacheSize);
1754     memset(&cparams, '\0', sizeof(cparams));
1755     cparams.cacheScaches = cacheStatEntries;
1756     cparams.cacheFiles = cacheFiles;
1757     cparams.cacheBlocks = cacheBlocks;
1758     cparams.cacheDcaches = dCacheSize;
1759     cparams.cacheVolumes = vCacheSize;
1760     cparams.chunkSize = chunkSize;
1761     cparams.setTimeFlag = cacheSetTime;
1762     cparams.memCacheFlag = cacheFlags;
1763 #ifdef notdef
1764     cparams.inodes = inodes;
1765 #endif
1766     call_syscall(AFSOP_CACHEINIT, &cparams);
1767     if (afsd_CloseSynch)
1768         call_syscall(AFSOP_CLOSEWAIT);
1769
1770     /*
1771      * Sweep the workstation AFS cache directory, remembering the inodes of
1772      * valid files and deleting extraneous files.  Keep sweeping until we
1773      * have the right number of data cache files or we've swept too many
1774      * times.
1775      *
1776      * This also creates files in the cache directory like VolumeItems and
1777      * CellItems, and thus must be ran before those are sent to the kernel.
1778      */
1779     if (afsd_verbose)
1780         printf("%s: Sweeping workstation's AFS cache directory.\n", rn);
1781     cacheIteration = 0;
1782     /* Memory-cache based system doesn't need any of this */
1783     if (!(cacheFlags & AFSCALL_INIT_MEMCACHE)) {
1784         do {
1785             cacheIteration++;
1786             if (SweepAFSCache(&vFilesFound)) {
1787                 printf("%s: Error on sweep %d of workstation AFS cache \
1788                        directory.\n", rn, cacheIteration);
1789                 exit(1);
1790             }
1791             if (afsd_verbose)
1792                 printf
1793                     ("%s: %d out of %d data cache files found in sweep %d.\n",
1794                      rn, vFilesFound, cacheFiles, cacheIteration);
1795         } while ((vFilesFound < cacheFiles)
1796                  && (cacheIteration < MAX_CACHE_LOOPS));
1797     } else if (afsd_verbose)
1798         printf("%s: Using memory cache, not swept\n", rn);
1799
1800     /*
1801      * Pass the kernel the name of the workstation cache file holding the 
1802      * dcache entries.
1803      */
1804     if (afsd_debug)
1805         printf("%s: Calling AFSOP_CACHEINFO: dcache file is '%s'\n", rn,
1806                fullpn_DCacheFile);
1807     /* once again, meaningless for a memory-based cache. */
1808     if (!(cacheFlags & AFSCALL_INIT_MEMCACHE))
1809         call_syscall(AFSOP_CACHEINFO, fullpn_DCacheFile);
1810
1811     /*
1812      * Pass the kernel the name of the workstation cache file holding the
1813      * cell information.
1814      */
1815     if (afsd_debug)
1816         printf("%s: Calling AFSOP_CELLINFO: cell info file is '%s'\n", rn,
1817                fullpn_CellInfoFile);
1818     call_syscall(AFSOP_CELLINFO, fullpn_CellInfoFile);
1819
1820     if (enable_dynroot) {
1821         if (afsd_verbose)
1822             printf("%s: Enabling dynroot support in kernel.\n", rn);
1823         code = call_syscall(AFSOP_SET_DYNROOT, 1);
1824         if (code)
1825             printf("%s: Error enabling dynroot support.\n", rn);
1826     }
1827
1828     if (enable_fakestat) {
1829         if (afsd_verbose)
1830             printf("%s: Enabling fakestat support in kernel.\n", rn);
1831         code = call_syscall(AFSOP_SET_FAKESTAT, enable_fakestat);
1832         if (code)
1833             printf("%s: Error enabling fakestat support.\n", rn);
1834     }
1835
1836     if (enable_backuptree) {
1837         if (afsd_verbose)
1838             printf("%s: Enabling backup tree support in kernel.\n", rn);
1839         code = call_syscall(AFSOP_SET_BACKUPTREE, enable_backuptree);
1840         if (code)
1841             printf("%s: Error enabling backup tree support.\n", rn);
1842     }
1843
1844     /*
1845      * Tell the kernel about each cell in the configuration.
1846      */
1847     afsconf_CellApply(cdir, ConfigCell, NULL);
1848     afsconf_CellAliasApply(cdir, ConfigCellAlias, NULL);
1849
1850     /*
1851      * Set the primary cell name.
1852      */
1853     call_syscall(AFSOP_SET_THISCELL, LclCellName);
1854
1855     /* Initialize AFS daemon threads. */
1856     if (afsd_verbose)
1857         printf("%s: Forking AFS daemon.\n", rn);
1858     code = fork();
1859     if (code == 0) {
1860         /* Child */
1861         call_syscall(AFSOP_START_AFS);
1862         exit(1);
1863     }
1864
1865     if (afsd_verbose)
1866         printf("%s: Forking Check Server Daemon.\n", rn);
1867     code = fork();
1868     if (code == 0) {
1869         /* Child */
1870         code = call_syscall(AFSOP_START_CS);
1871         if (code)
1872             printf("%s: No check server daemon in client.\n", rn);
1873         exit(1);
1874     }
1875
1876     if (afsd_verbose)
1877         printf("%s: Forking %d background daemons.\n", rn, nDaemons);
1878 #if defined(AFS_SGI_ENV) && defined(AFS_SGI_SHORTSTACK)
1879     /* Add one because for sgi we always "steal" the first daemon for a
1880      * different task if we only have a 4K stack.
1881      */
1882     nDaemons++;
1883 #endif
1884     for (i = 0; i < nDaemons; i++) {
1885         code = fork();
1886         if (code == 0) {
1887             /* Child */
1888 #ifdef  AFS_AIX32_ENV
1889             call_syscall(AFSOP_START_BKG, 0);
1890 #else
1891             call_syscall(AFSOP_START_BKG);
1892 #endif
1893             exit(1);
1894         }
1895     }
1896 #ifdef  AFS_AIX32_ENV
1897     if (!sawBiod)
1898         nBiods = nDaemons * 2;
1899     if (nBiods < 5)
1900         nBiods = 5;
1901     for (i = 0; i < nBiods; i++) {
1902         code = fork();
1903         if (code == 0) {        /* Child */
1904             call_syscall(AFSOP_START_BKG, nBiods);
1905             exit(1);
1906         }
1907     }
1908 #endif
1909
1910     /*
1911      * If the root volume has been explicitly set, tell the kernel.
1912      */
1913     if (rootVolSet) {
1914         if (afsd_verbose)
1915             printf("%s: Calling AFSOP_ROOTVOLUME with '%s'\n", rn,
1916                    rootVolume);
1917         call_syscall(AFSOP_ROOTVOLUME, rootVolume);
1918     }
1919
1920     /*
1921      * Pass the kernel the name of the workstation cache file holding the
1922      * volume information.
1923      */
1924     if (afsd_debug)
1925         printf("%s: Calling AFSOP_VOLUMEINFO: volume info file is '%s'\n", rn,
1926                fullpn_VolInfoFile);
1927     call_syscall(AFSOP_VOLUMEINFO, fullpn_VolInfoFile);
1928
1929     /*
1930      * Pass the kernel the name of the afs logging file holding the volume
1931      * information.
1932      */
1933     if (afsd_debug)
1934         printf("%s: Calling AFSOP_AFSLOG: volume info file is '%s'\n", rn,
1935                fullpn_AFSLogFile);
1936 #if defined(AFS_SGI_ENV)
1937     /* permit explicit -logfile argument to enable logging on memcache systems */
1938     if (!(cacheFlags & AFSCALL_INIT_MEMCACHE) || as->parms[18].items)
1939 #else
1940     if (!(cacheFlags & AFSCALL_INIT_MEMCACHE))  /* ... nor this ... */
1941 #endif
1942         call_syscall(AFSOP_AFSLOG, fullpn_AFSLogFile);
1943
1944     /*
1945      * Give the kernel the names of the AFS files cached on the workstation's
1946      * disk.
1947      */
1948     if (afsd_debug)
1949         printf
1950             ("%s: Calling AFSOP_CACHEINODE for each of the %d files in '%s'\n",
1951              rn, cacheFiles, cacheBaseDir);
1952     if (!(cacheFlags & AFSCALL_INIT_MEMCACHE))  /* ... and again ... */
1953         for (currVFile = 0; currVFile < cacheFiles; currVFile++) {
1954 #ifdef AFS_SGI62_ENV
1955             call_syscall(AFSOP_CACHEINODE,
1956                          (afs_uint32) (inode_for_V[currVFile] >> 32),
1957                          (afs_uint32) (inode_for_V[currVFile] & 0xffffffff));
1958 #else
1959             call_syscall(AFSOP_CACHEINODE, inode_for_V[currVFile]);
1960 #endif
1961         }
1962
1963
1964     /*end for */
1965     /*
1966      * All the necessary info has been passed into the kernel to run an AFS
1967      * system.  Give the kernel our go-ahead.
1968      */
1969     if (afsd_debug)
1970         printf("%s: Calling AFSOP_GO with cacheSetTime = %d\n", rn,
1971                cacheSetTime);
1972     call_syscall(AFSOP_GO, cacheSetTime);
1973
1974     /*
1975      * At this point, we have finished passing the kernel all the info 
1976      * it needs to set up the AFS.  Mount the AFS root.
1977      */
1978     printf("%s: All AFS daemons started.\n", rn);
1979
1980     if (afsd_verbose)
1981         printf("%s: Forking trunc-cache daemon.\n", rn);
1982     code = fork();
1983     if (code == 0) {
1984         /* Child */
1985         call_syscall(AFSOP_START_TRUNCDAEMON);
1986         exit(1);
1987     }
1988
1989     if (!enable_nomount) {
1990
1991         mountFlags = 0;         /* Read/write file system, can do setuid() */
1992 #if     defined(AFS_SUN_ENV) || defined(AFS_SUN5_ENV)
1993 #ifdef  AFS_SUN5_ENV
1994         mountFlags |= MS_DATA;
1995 #else
1996         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... */
1997 #endif
1998 #endif
1999
2000 #if defined(AFS_HPUX100_ENV)
2001         mountFlags |= MS_DATA;
2002 #endif
2003
2004         if (afsd_verbose)
2005             printf("%s: Mounting the AFS root on '%s', flags: %d.\n", rn,
2006                    cacheMountDir, mountFlags);
2007 #ifdef AFS_DEC_ENV
2008         if ((mount("AFS", cacheMountDir, mountFlags, GT_AFS, (caddr_t) 0)) <
2009             0) {
2010 #else
2011 #ifdef AFS_FBSD_ENV
2012         if ((mount("AFS", cacheMountDir, mountFlags, (caddr_t) 0)) < 0) {
2013 #else
2014 #ifdef  AFS_AUX_ENV
2015         if ((fsmount(MOUNT_AFS, cacheMountDir, mountFlags, (caddr_t) 0)) < 0) {
2016 #else
2017 #ifdef  AFS_AIX_ENV
2018         if (aix_vmount()) {
2019 #else
2020 #if defined(AFS_HPUX100_ENV)
2021         if ((mount("", cacheMountDir, mountFlags, "afs", NULL, 0)) < 0) {
2022 #else
2023 #ifdef  AFS_HPUX_ENV
2024 #if     defined(AFS_HPUX90_ENV)
2025         {
2026             char buffer[80];
2027             int code;
2028
2029             strcpy(buffer, "afs");
2030             code = vfsmount(-1, cacheMountDir, mountFlags, (caddr_t) buffer);
2031             sscanf(buffer, "%d", &vfs1_type);
2032             if (code < 0) {
2033                 printf
2034                     ("Can't find 'afs' type in the registered filesystem table!\n");
2035                 exit(1);
2036             }
2037             sscanf(buffer, "%d", &vfs1_type);
2038             if (afsd_verbose)
2039                 printf("AFS vfs slot number is %d\n", vfs1_type);
2040         }
2041         if ((vfsmount(vfs1_type, cacheMountDir, mountFlags, (caddr_t) 0)) < 0) {
2042 #else
2043         if (call_syscall
2044             (AFSOP_AFS_VFSMOUNT, MOUNT_AFS, cacheMountDir, mountFlags,
2045              (caddr_t) NULL) < 0) {
2046 #endif
2047 #else
2048 #ifdef  AFS_SUN5_ENV
2049         if ((mount("AFS", cacheMountDir, mountFlags, "afs", NULL, 0)) < 0) {
2050 #else
2051 #if defined(AFS_SGI_ENV)
2052         mountFlags = MS_FSS;
2053         if ((mount(MOUNT_AFS, cacheMountDir, mountFlags, (caddr_t) MOUNT_AFS))
2054             < 0) {
2055 #else
2056 #ifdef AFS_LINUX20_ENV
2057         if ((mount("AFS", cacheMountDir, MOUNT_AFS, 0, NULL)) < 0) {
2058 #else
2059 /* This is the standard mount used by the suns and rts */
2060         if ((mount(MOUNT_AFS, cacheMountDir, mountFlags, (caddr_t) 0)) < 0) {
2061 #endif /* AFS_LINUX20_ENV */
2062 #endif /* AFS_SGI_ENV */
2063 #endif /* AFS_SUN5_ENV */
2064 #endif /* AFS_HPUX100_ENV */
2065 #endif /* AFS_HPUX_ENV */
2066 #endif /* AFS_AIX_ENV */
2067 #endif /* AFS_AUX_ENV */
2068 #endif /* AFS_FBSD_ENV */
2069 #endif /* AFS_DEC_ENV */
2070             printf("%s: Can't mount AFS on %s(%d)\n", rn, cacheMountDir,
2071                    errno);
2072             exit(1);
2073         }
2074
2075         HandleMTab();
2076
2077     }
2078
2079     if (afsd_rmtsys) {
2080         if (afsd_verbose)
2081             printf("%s: Forking 'rmtsys' daemon.\n", rn);
2082         code = fork();
2083         if (code == 0) {
2084             /* Child */
2085             rmtsysd();
2086             exit(1);
2087         }
2088     }
2089     /*
2090      * Exit successfully.
2091      */
2092     exit(0);
2093 }
2094
2095 #include "AFS_component_version_number.c"
2096
2097
2098
2099 main(argc, argv)
2100      int argc;
2101      char **argv;
2102 {
2103     register struct cmd_syndesc *ts;
2104
2105     ts = cmd_CreateSyntax(NULL, mainproc, NULL, "start AFS");
2106     cmd_AddParm(ts, "-blocks", CMD_SINGLE, CMD_OPTIONAL,
2107                 "1024 byte blocks in cache");
2108     cmd_AddParm(ts, "-files", CMD_SINGLE, CMD_OPTIONAL, "files in cache");
2109     cmd_AddParm(ts, "-rootvol", CMD_SINGLE, CMD_OPTIONAL,
2110                 "name of AFS root volume");
2111     cmd_AddParm(ts, "-stat", CMD_SINGLE, CMD_OPTIONAL,
2112                 "number of stat entries");
2113     cmd_AddParm(ts, "-memcache", CMD_FLAG, CMD_OPTIONAL, "run diskless");
2114     cmd_AddParm(ts, "-cachedir", CMD_SINGLE, CMD_OPTIONAL, "cache directory");
2115     cmd_AddParm(ts, "-mountdir", CMD_SINGLE, CMD_OPTIONAL, "mount location");
2116     cmd_AddParm(ts, "-daemons", CMD_SINGLE, CMD_OPTIONAL,
2117                 "number of daemons to use");
2118     cmd_AddParm(ts, "-nosettime", CMD_FLAG, CMD_OPTIONAL,
2119                 "don't set the time");
2120     cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL,
2121                 "display lots of information");
2122     cmd_AddParm(ts, "-rmtsys", CMD_FLAG, CMD_OPTIONAL,
2123                 "start NFS rmtsysd program");
2124     cmd_AddParm(ts, "-debug", CMD_FLAG, CMD_OPTIONAL, "display debug info");
2125     cmd_AddParm(ts, "-chunksize", CMD_SINGLE, CMD_OPTIONAL,
2126                 "log(2) of chunk size");
2127     cmd_AddParm(ts, "-dcache", CMD_SINGLE, CMD_OPTIONAL,
2128                 "number of dcache entries");
2129     cmd_AddParm(ts, "-volumes", CMD_SINGLE, CMD_OPTIONAL,
2130                 "number of volume entries");
2131     cmd_AddParm(ts, "-biods", CMD_SINGLE, CMD_OPTIONAL,
2132                 "number of bkg I/O daemons (aix vm)");
2133
2134     cmd_AddParm(ts, "-prealloc", CMD_SINGLE, CMD_OPTIONAL,
2135                 "number of 'small' preallocated blocks");
2136 #ifdef notdef
2137     cmd_AddParm(ts, "-pininodes", CMD_SINGLE, CMD_OPTIONAL,
2138                 "number of inodes to hog");
2139 #endif
2140     cmd_AddParm(ts, "-confdir", CMD_SINGLE, CMD_OPTIONAL,
2141                 "configuration directory");
2142     cmd_AddParm(ts, "-logfile", CMD_SINGLE, CMD_OPTIONAL,
2143                 "Place to keep the CM log");
2144     cmd_AddParm(ts, "-waitclose", CMD_FLAG, CMD_OPTIONAL,
2145                 "make close calls synchronous");
2146     cmd_AddParm(ts, "-shutdown", CMD_FLAG, CMD_OPTIONAL,
2147                 "Shutdown all afs state");
2148     cmd_AddParm(ts, "-enable_peer_stats", CMD_FLAG, CMD_OPTIONAL | CMD_HIDE,
2149                 "Collect rpc statistics by peer");
2150     cmd_AddParm(ts, "-enable_process_stats", CMD_FLAG,
2151                 CMD_OPTIONAL | CMD_HIDE,
2152                 "Collect rpc statistics for this process");
2153     cmd_AddParm(ts, "-mem_alloc_sleep", CMD_FLAG, (CMD_OPTIONAL | CMD_HIDE),
2154                 "Allow sleeps when allocating memory cache");
2155     cmd_AddParm(ts, "-afsdb", CMD_FLAG, (CMD_OPTIONAL
2156 #ifndef AFS_AFSDB_ENV
2157                                          | CMD_HIDE
2158 #endif
2159                 ), "Enable AFSDB support");
2160     cmd_AddParm(ts, "-files_per_subdir", CMD_SINGLE, CMD_OPTIONAL,
2161                 "log(2) of the number of cache files per cache subdirectory");
2162     cmd_AddParm(ts, "-dynroot", CMD_FLAG, CMD_OPTIONAL,
2163                 "Enable dynroot support");
2164     cmd_AddParm(ts, "-fakestat", CMD_FLAG, CMD_OPTIONAL,
2165                 "Enable fakestat support for cross-cell mounts");
2166     cmd_AddParm(ts, "-fakestat-all", CMD_FLAG, CMD_OPTIONAL,
2167                 "Enable fakestat support for all mounts");
2168     cmd_AddParm(ts, "-nomount", CMD_FLAG, CMD_OPTIONAL, "Do not mount AFS");
2169     cmd_AddParm(ts, "-backuptree", CMD_FLAG, CMD_OPTIONAL,
2170                 "Prefer backup volumes for mointpoints in backup volumes");
2171     return (cmd_Dispatch(argc, argv));
2172 }
2173
2174
2175 #ifdef  AFS_HPUX_ENV
2176 #define MOUNTED_TABLE   MNT_MNTTAB
2177 #else
2178 #ifdef  AFS_SUN5_ENV
2179 #define MOUNTED_TABLE   MNTTAB
2180 #else
2181 #define MOUNTED_TABLE   MOUNTED
2182 #endif
2183 #endif
2184
2185 static int
2186 HandleMTab()
2187 {
2188 #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)
2189     FILE *tfilep;
2190 #ifdef  AFS_SUN5_ENV
2191     char tbuf[16];
2192     struct mnttab tmntent;
2193
2194     memset(&tmntent, '\0', sizeof(struct mnttab));
2195     if (!(tfilep = fopen(MOUNTED_TABLE, "a+"))) {
2196         printf("Can't open %s\n", MOUNTED_TABLE);
2197         perror(MNTTAB);
2198         exit(-1);
2199     }
2200     tmntent.mnt_special = "AFS";
2201     tmntent.mnt_mountp = cacheMountDir;
2202     tmntent.mnt_fstype = "xx";
2203     tmntent.mnt_mntopts = "rw";
2204     sprintf(tbuf, "%ld", (long)time((time_t *) 0));
2205     tmntent.mnt_time = tbuf;
2206     putmntent(tfilep, &tmntent);
2207     fclose(tfilep);
2208 #else
2209 #if defined(AFS_SGI_ENV) || defined(AFS_LINUX20_ENV)
2210     struct mntent tmntent;
2211
2212     tfilep = setmntent("/etc/mtab", "a+");
2213     tmntent.mnt_fsname = "AFS";
2214     tmntent.mnt_dir = cacheMountDir;
2215     tmntent.mnt_type = "afs";
2216     tmntent.mnt_opts = "rw";
2217     tmntent.mnt_freq = 1;
2218     tmntent.mnt_passno = 3;
2219     addmntent(tfilep, &tmntent);
2220     endmntent(tfilep);
2221 #else
2222     struct mntent tmntent;
2223
2224     memset(&tmntent, '\0', sizeof(struct mntent));
2225     tfilep = setmntent(MOUNTED_TABLE, "a+");
2226     if (!tfilep) {
2227         printf("Can't open %s for write; Not adding afs entry to it\n",
2228                MOUNTED_TABLE);
2229         return 1;
2230     }
2231     tmntent.mnt_fsname = "AFS";
2232     tmntent.mnt_dir = cacheMountDir;
2233     tmntent.mnt_type = "xx";
2234     tmntent.mnt_opts = "rw";
2235     tmntent.mnt_freq = 1;
2236     tmntent.mnt_passno = 3;
2237 #ifdef  AFS_HPUX_ENV
2238     tmntent.mnt_type = "afs";
2239     tmntent.mnt_time = time(0);
2240     tmntent.mnt_cnode = 0;
2241 #endif
2242     addmntent(tfilep, &tmntent);
2243     endmntent(tfilep);
2244 #endif /* AFS_SGI_ENV */
2245 #endif /* AFS_SUN5_ENV */
2246 #endif /* unreasonable systems */
2247 #ifdef AFS_DARWIN_ENV
2248     mach_port_t diskarb_port;
2249     kern_return_t status;
2250
2251     status = DiskArbStart(&diskarb_port);
2252     if (status == KERN_SUCCESS) {
2253         status =
2254             DiskArbDiskAppearedWithMountpointPing_auto("AFS",
2255                                                        DISK_ARB_NETWORK_DISK_FLAG,
2256                                                        cacheMountDir);
2257     }
2258
2259     return status;
2260 #endif /* AFS_DARWIN_ENV */
2261     return 0;
2262 }
2263
2264 #if !defined(AFS_SGI_ENV) && !defined(AFS_AIX32_ENV)
2265
2266 call_syscall(param1, param2, param3, param4, param5, param6, param7)
2267      long param1, param2, param3, param4, param5, param6, param7;
2268 {
2269     int error;
2270 #ifdef AFS_LINUX20_ENV
2271     long eparm[4];
2272     struct afsprocdata syscall_data;
2273     int fd = open(PROC_SYSCALL_FNAME,O_RDWR);
2274
2275     eparm[0] = param4;
2276     eparm[1] = param5;
2277     eparm[2] = param6;
2278     eparm[3] = param7;
2279
2280     param4 = (long)eparm;
2281
2282     syscall_data.syscall = AFSCALL_CALL;
2283     syscall_data.param1 = param1;
2284     syscall_data.param2 = param2;
2285     syscall_data.param3 = param3;
2286     syscall_data.param4 = param4;
2287     if(fd > 0) {
2288        error = ioctl(fd, VIOC_SYSCALL, &syscall_data);
2289        close(fd);
2290     }
2291     else
2292 #endif
2293     error =
2294         syscall(AFS_SYSCALL, AFSCALL_CALL, param1, param2, param3, param4,
2295                 param5, param6, param7);
2296
2297     if (afsd_verbose)
2298         printf("SScall(%d, %d, %d)=%d ", AFS_SYSCALL, AFSCALL_CALL, param1,
2299                error);
2300     return (error);
2301 }
2302 #else /* AFS_AIX32_ENV */
2303 #if defined(AFS_SGI_ENV)
2304 call_syscall(call, parm0, parm1, parm2, parm3, parm4)
2305 {
2306
2307     int error;
2308
2309     error = afs_syscall(call, parm0, parm1, parm2, parm3, parm4);
2310     if (afsd_verbose)
2311         printf("SScall(%d, %d)=%d ", call, parm0, error);
2312
2313     return error;
2314 }
2315 #else
2316 call_syscall(call, parm0, parm1, parm2, parm3, parm4, parm5, parm6)
2317 {
2318
2319     return syscall(AFSCALL_CALL, call, parm0, parm1, parm2, parm3, parm4,
2320                    parm5, parm6);
2321 }
2322 #endif /* AFS_SGI_ENV */
2323 #endif /* AFS_AIX32_ENV */
2324
2325
2326 #ifdef  AFS_AIX_ENV
2327 /* Special handling for AIX's afs mount operation since they require much more miscl. information before making the vmount(2) syscall */
2328 #include <sys/vfs.h>
2329
2330 #define ROUNDUP(x)  (((x) + 3) & ~3)
2331
2332 aix_vmount()
2333 {
2334     struct vmount *vmountp;
2335     int size, error;
2336
2337     size = sizeof(struct vmount) + ROUNDUP(strlen(cacheMountDir) + 1) + 5 * 4;
2338     /* Malloc the vmount structure */
2339     if ((vmountp = (struct vmount *)malloc(size)) == (struct vmount *)NULL) {
2340         printf("Can't allocate space for the vmount structure (AIX)\n");
2341         exit(1);
2342     }
2343
2344     /* zero out the vmount structure */
2345     memset(vmountp, '\0', size);
2346
2347     /* transfer info into the vmount structure */
2348     vmountp->vmt_revision = VMT_REVISION;
2349     vmountp->vmt_length = size;
2350     vmountp->vmt_fsid.fsid_dev = 0;
2351     vmountp->vmt_fsid.fsid_type = AFS_MOUNT_AFS;
2352     vmountp->vmt_vfsnumber = 0;
2353     vmountp->vmt_time = 0;      /* We'll put the time soon! */
2354     vmountp->vmt_flags = VFS_DEVMOUNT;  /* read/write permission */
2355     vmountp->vmt_gfstype = AFS_MOUNT_AFS;
2356     vmountdata(vmountp, "AFS", cacheMountDir, "", "", "", "rw");
2357
2358     /* Do the actual mount system call */
2359     error = vmount(vmountp, size);
2360     free(vmountp);
2361     return (error);
2362 }
2363
2364 vmountdata(vmtp, obj, stub, host, hostsname, info, args)
2365      struct vmount *vmtp;
2366      char *obj, *stub, *host, *hostsname, *info, *args;
2367 {
2368     register struct data {
2369         short vmt_off;
2370         short vmt_size;
2371     } *vdp, *vdprev;
2372     register int size;
2373
2374     vdp = (struct data *)vmtp->vmt_data;
2375     vdp->vmt_off = sizeof(struct vmount);
2376     size = ROUNDUP(strlen(obj) + 1);
2377     vdp->vmt_size = size;
2378     strcpy(vmt2dataptr(vmtp, VMT_OBJECT), obj);
2379
2380     vdprev = vdp;
2381     vdp++;
2382     vdp->vmt_off = vdprev->vmt_off + size;
2383     size = ROUNDUP(strlen(stub) + 1);
2384     vdp->vmt_size = size;
2385     strcpy(vmt2dataptr(vmtp, VMT_STUB), stub);
2386
2387     vdprev = vdp;
2388     vdp++;
2389     vdp->vmt_off = vdprev->vmt_off + size;
2390     size = ROUNDUP(strlen(host) + 1);
2391     vdp->vmt_size = size;
2392     strcpy(vmt2dataptr(vmtp, VMT_HOST), host);
2393
2394     vdprev = vdp;
2395     vdp++;
2396     vdp->vmt_off = vdprev->vmt_off + size;
2397     size = ROUNDUP(strlen(hostsname) + 1);
2398     vdp->vmt_size = size;
2399     strcpy(vmt2dataptr(vmtp, VMT_HOSTNAME), hostsname);
2400
2401
2402     vdprev = vdp;
2403     vdp++;
2404     vdp->vmt_off = vdprev->vmt_off + size;
2405     size = ROUNDUP(strlen(info) + 1);
2406     vdp->vmt_size = size;
2407     strcpy(vmt2dataptr(vmtp, VMT_INFO), info);
2408
2409     vdprev = vdp;
2410     vdp++;
2411     vdp->vmt_off = vdprev->vmt_off + size;
2412     size = ROUNDUP(strlen(args) + 1);
2413     vdp->vmt_size = size;
2414     strcpy(vmt2dataptr(vmtp, VMT_ARGS), args);
2415 }
2416 #endif /* AFS_AIX_ENV */
2417
2418 #ifdef  AFS_SGI53_ENV
2419 #ifdef AFS_SGI61_ENV
2420 /* The dwarf structures are searched to find entry points of static functions
2421  * and the addresses of static variables. The file name as well as the
2422  * sybmol name is reaquired.
2423  */
2424
2425 /* Contains list of names to find in given file. */
2426 typedef struct {
2427     char *name;                 /* Name of variable or function. */
2428     afs_hyper_t addr;           /* Address of function, undefined if not found. */
2429     Dwarf_Half type;            /* DW_AT_location for vars, DW_AT_lowpc for func's */
2430     char found;                 /* set if found. */
2431 } staticAddrList;
2432
2433 typedef struct {
2434     char *file;                 /* Name of file containing vars or funcs */
2435     staticAddrList *addrList;   /* List of vars and/or funcs. */
2436     int nAddrs;                 /* # of addrList's */
2437     int found;                  /* set if we've found this file already. */
2438 } staticNameList;
2439
2440 /* routines used to find addresses in /unix */
2441 #if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
2442 void findMDebugStaticAddresses(staticNameList *, int, int);
2443 #endif
2444 void findDwarfStaticAddresses(staticNameList *, int);
2445 void findElfAddresses(Dwarf_Debug, Dwarf_Die, staticNameList *);
2446 void getElfAddress(Dwarf_Debug, Dwarf_Die, staticAddrList *);
2447
2448 #if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
2449 #define AFS_N_FILELISTS 2
2450 #define AFS_SYMS_NEEDED 3
2451 #else /* AFS_SGI62_ENV */
2452 #define AFS_N_FILELISTS 1
2453 #endif /* AFS_SGI62_ENV */
2454
2455
2456
2457 void
2458 set_staticaddrs(void)
2459 {
2460     staticNameList fileList[AFS_N_FILELISTS];
2461
2462     fileList[0].addrList =
2463         (staticAddrList *) calloc(1, sizeof(staticAddrList));
2464     if (!fileList[0].addrList) {
2465         printf("set_staticaddrs: Can't calloc fileList[0].addrList\n");
2466         return;
2467     }
2468     fileList[0].file = "nfs_server.c";
2469     fileList[0].found = 0;
2470     fileList[0].nAddrs = 1;
2471     fileList[0].addrList[0].name = "rfsdisptab_v2";
2472     fileList[0].addrList[0].type = DW_AT_location;
2473     fileList[0].addrList[0].found = 0;
2474
2475 #if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
2476     fileList[1].addrList =
2477         (staticAddrList *) calloc(2, sizeof(staticAddrList));
2478     if (!fileList[1].addrList) {
2479         printf("set_staticaddrs: Can't malloc fileList[1].addrList\n");
2480         return;
2481     }
2482     fileList[1].file = "uipc_socket.c";
2483     fileList[1].found = 0;
2484     fileList[1].nAddrs = 2;
2485     fileList[1].addrList[0].name = "sblock";
2486     fileList[1].addrList[0].type = DW_AT_low_pc;
2487     fileList[1].addrList[0].found = 0;
2488     fileList[1].addrList[1].name = "sbunlock";
2489     fileList[1].addrList[1].type = DW_AT_low_pc;
2490     fileList[1].addrList[1].found = 0;
2491
2492     if (64 != sysconf(_SC_KERN_POINTERS))
2493         findMDebugStaticAddresses(fileList, AFS_N_FILELISTS, AFS_SYMS_NEEDED);
2494     else
2495 #endif /* AFS_SGI62_ENV */
2496         findDwarfStaticAddresses(fileList, AFS_N_FILELISTS);
2497
2498     if (fileList[0].addrList[0].found) {
2499         call_syscall(AFSOP_NFSSTATICADDR2, fileList[0].addrList[0].addr.high,
2500                      fileList[0].addrList[0].addr.low);
2501     } else {
2502         if (afsd_verbose)
2503             printf("NFS V2 is not present in the kernel.\n");
2504     }
2505     free(fileList[0].addrList);
2506 #if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
2507     if (fileList[1].addrList[0].found && fileList[1].addrList[1].found) {
2508         call_syscall(AFSOP_SBLOCKSTATICADDR2,
2509                      fileList[1].addrList[0].addr.high,
2510                      fileList[1].addrList[0].addr.low,
2511                      fileList[1].addrList[1].addr.high,
2512                      fileList[1].addrList[1].addr.low);
2513     } else {
2514         if (!fileList[1].addrList[0].found)
2515             printf("Can't find %s in kernel. Exiting.\n",
2516                    fileList[1].addrList[0].name);
2517         if (!fileList[1].addrList[0].found)
2518             printf("Can't find %s in kernel. Exiting.\n",
2519                    fileList[1].addrList[1].name);
2520         exit(1);
2521     }
2522     free(fileList[1].addrList);
2523 #endif /* AFS_SGI62_ENV */
2524 }
2525
2526
2527 /* Find addresses for static variables and functions. */
2528 void
2529 findDwarfStaticAddresses(staticNameList * nameList, int nLists)
2530 {
2531     int fd;
2532     int i;
2533     int found = 0;
2534     int code;
2535     char *s;
2536     char *hname = (char *)0;
2537     Dwarf_Unsigned dwarf_access = O_RDONLY;
2538     Dwarf_Debug dwarf_debug;
2539     Dwarf_Error dwarf_error;
2540     Dwarf_Unsigned dwarf_cu_header_length;
2541     Dwarf_Unsigned dwarf_abbrev_offset;
2542     Dwarf_Half dwarf_address_size;
2543     Dwarf_Unsigned next_cu_header;
2544     Dwarf_Die dwarf_die;
2545     Dwarf_Die dwarf_next_die;
2546     Dwarf_Die dwarf_child_die;
2547
2548     if (elf_version(EV_CURRENT) == EV_NONE) {
2549         printf("findDwarfStaticAddresses: Bad elf version.\n");
2550         return;
2551     }
2552
2553     if ((fd = open("/unix", O_RDONLY, 0)) < 0) {
2554         printf("findDwarfStaticAddresses: Failed to open /unix.\n");
2555         return;
2556     }
2557     code =
2558         dwarf_init(fd, dwarf_access, NULL, NULL, &dwarf_debug, &dwarf_error);
2559     if (code != DW_DLV_OK) {
2560         /* Nope hope for the elves and dwarves, try intermediate code. */
2561         close(fd);
2562         return;
2563     }
2564
2565     found = 0;
2566     while (1) {
2567         /* Run through the headers until we find ones for files we've
2568          * specified in nameList.
2569          */
2570         code =
2571             dwarf_next_cu_header(dwarf_debug, &dwarf_cu_header_length, NULL,
2572                                  &dwarf_abbrev_offset, &dwarf_address_size,
2573                                  &next_cu_header, &dwarf_error);
2574         if (code == DW_DLV_NO_ENTRY) {
2575             break;
2576         } else if (code == DW_DLV_ERROR) {
2577             printf("findDwarfStaticAddresses: Error reading headers: %s\n",
2578                    dwarf_errmsg(dwarf_error));
2579             break;
2580         }
2581
2582         code = dwarf_siblingof(dwarf_debug, NULL, &dwarf_die, &dwarf_error);
2583         if (code != DW_DLV_OK) {
2584             printf("findDwarfStaticAddresses: Can't get first die. %s\n",
2585                    (code == DW_DLV_ERROR) ? dwarf_errmsg(dwarf_error) : "");
2586             break;
2587         }
2588
2589         /* This is the header, test the name. */
2590         code = dwarf_diename(dwarf_die, &hname, &dwarf_error);
2591         if (code == DW_DLV_OK) {
2592             s = strrchr(hname, '/');
2593             for (i = 0; i < nLists; i++) {
2594                 if (s && !strcmp(s + 1, nameList[i].file)) {
2595                     findElfAddresses(dwarf_debug, dwarf_die, &nameList[i]);
2596                     found++;
2597                     break;
2598                 }
2599             }
2600         } else {
2601             printf
2602                 ("findDwarfStaticAddresses: Can't get name of current header. %s\n",
2603                  (code == DW_DLV_ERROR) ? dwarf_errmsg(dwarf_error) : "");
2604             break;
2605         }
2606         dwarf_dealloc(dwarf_debug, hname, DW_DLA_STRING);
2607         hname = (char *)0;
2608         if (found >= nLists) {  /* we're done */
2609             break;
2610         }
2611     }
2612
2613     /* Frees up all allocated space. */
2614     (void)dwarf_finish(dwarf_debug, &dwarf_error);
2615     close(fd);
2616 }
2617
2618 void
2619 findElfAddresses(Dwarf_Debug dwarf_debug, Dwarf_Die dwarf_die,
2620                  staticNameList * nameList)
2621 {
2622     int i;
2623     Dwarf_Error dwarf_error;
2624     Dwarf_Die dwarf_next_die;
2625     Dwarf_Die dwarf_child_die;
2626     Dwarf_Attribute dwarf_return_attr;
2627     char *vname = (char *)0;
2628     int found = 0;
2629     int code;
2630
2631     /* Drop into this die to find names in addrList. */
2632     code = dwarf_child(dwarf_die, &dwarf_child_die, &dwarf_error);
2633     if (code != DW_DLV_OK) {
2634         printf("findElfAddresses: Can't get child die. %s\n",
2635                (code == DW_DLV_ERROR) ? dwarf_errmsg(dwarf_error) : "");
2636         return;
2637     }
2638
2639     /* Try to find names in each sibling. */
2640     dwarf_next_die = (Dwarf_Die) 0;
2641     do {
2642         code = dwarf_diename(dwarf_child_die, &vname, &dwarf_error);
2643         /* It's possible that some siblings don't have names. */
2644         if (code == DW_DLV_OK) {
2645             for (i = 0; i < nameList->nAddrs; i++) {
2646                 if (!nameList->addrList[i].found) {
2647                     if (!strcmp(vname, nameList->addrList[i].name)) {
2648                         getElfAddress(dwarf_debug, dwarf_child_die,
2649                                       &(nameList->addrList[i]));
2650                         found++;
2651                         break;
2652                     }
2653                 }
2654             }
2655         }
2656         if (dwarf_next_die)
2657             dwarf_dealloc(dwarf_debug, dwarf_next_die, DW_DLA_DIE);
2658
2659         if (found >= nameList->nAddrs) {        /* we're done. */
2660             break;
2661         }
2662
2663         dwarf_next_die = dwarf_child_die;
2664         code =
2665             dwarf_siblingof(dwarf_debug, dwarf_next_die, &dwarf_child_die,
2666                             &dwarf_error);
2667
2668     } while (code == DW_DLV_OK);
2669 }
2670
2671 /* Get address out of current die. */
2672 void
2673 getElfAddress(Dwarf_Debug dwarf_debug, Dwarf_Die dwarf_child_die,
2674               staticAddrList * addrList)
2675 {
2676     int i;
2677     Dwarf_Error dwarf_error;
2678     Dwarf_Attribute dwarf_return_attr;
2679     Dwarf_Bool dwarf_return_bool;
2680     Dwarf_Locdesc *llbuf = NULL;
2681     Dwarf_Signed listlen;
2682     off64_t addr = (off64_t) 0;
2683     int code;
2684
2685     code =
2686         dwarf_hasattr(dwarf_child_die, addrList->type, &dwarf_return_bool,
2687                       &dwarf_error);
2688     if ((code != DW_DLV_OK) || (!dwarf_return_bool)) {
2689         printf("getElfAddress: no address given for %s. %s\n", addrList->name,
2690                (code == DW_DLV_ERROR) ? dwarf_errmsg(dwarf_error) : "");
2691         return;
2692     }
2693     code =
2694         dwarf_attr(dwarf_child_die, addrList->type, &dwarf_return_attr,
2695                    &dwarf_error);
2696     if (code != DW_DLV_OK) {
2697         printf("getElfAddress: Can't get attribute. %s\n",
2698                (code == DW_DLV_ERROR) ? dwarf_errmsg(dwarf_error) : "");
2699         return;
2700     }
2701
2702     switch (addrList->type) {
2703     case DW_AT_location:
2704         code =
2705             dwarf_loclist(dwarf_return_attr, &llbuf, &listlen, &dwarf_error);
2706         if (code != DW_DLV_OK) {
2707             printf("getElfAddress: Can't get location for %s. %s\n",
2708                    addrList->name,
2709                    (code == DW_DLV_ERROR) ? dwarf_errmsg(dwarf_error) : "");
2710             return;
2711         }
2712         if ((listlen != 1) || (llbuf[0].ld_cents != 1)) {
2713             printf("getElfAddress: %s has more than one address.\n",
2714                    addrList->name);
2715             return;
2716         }
2717         addr = llbuf[0].ld_s[0].lr_number;
2718         break;
2719
2720     case DW_AT_low_pc:
2721         code =
2722             dwarf_lowpc(dwarf_child_die, (Dwarf_Addr *) & addr, &dwarf_error);
2723         if (code != DW_DLV_OK) {
2724             printf("getElfAddress: Can't get lowpc for %s. %s\n",
2725                    addrList->name,
2726                    (code == DW_DLV_ERROR) ? dwarf_errmsg(dwarf_error) : "");
2727             return;
2728         }
2729         break;
2730
2731     default:
2732         printf("getElfAddress: Bad case %d in switch.\n", addrList->type);
2733         return;
2734     }
2735
2736     addrList->addr.high = (addr >> 32) & 0xffffffff;
2737     addrList->addr.low = addr & 0xffffffff;
2738     addrList->found = 1;
2739 }
2740
2741 #if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
2742 /* Find symbols in the .mdebug section for 32 bit kernels. */
2743 /*
2744  * do_mdebug()
2745  * On 32bit platforms, we're still using the ucode compilers to build
2746  * the kernel, so we need to get our static text/data from the .mdebug
2747  * section instead of the .dwarf sections.
2748  */
2749 /* SearchNameList searches our bizarre structs for the given string.
2750  * If found, sets the found bit and the address and returns 1.
2751  * Not found returns 0.
2752  */
2753 int
2754 SearchNameList(char *name, afs_uint32 addr, staticNameList * nameList,
2755                int nLists)
2756 {
2757     int i, j;
2758     for (i = 0; i < nLists; i++) {
2759         for (j = 0; j < nameList[i].nAddrs; j++) {
2760             if (nameList[i].addrList[j].found)
2761                 continue;
2762             if (!strcmp(name, nameList[i].addrList[j].name)) {
2763                 nameList[i].addrList[j].addr.high = 0;
2764                 nameList[i].addrList[j].addr.low = addr;
2765                 nameList[i].addrList[j].found = 1;
2766                 return 1;
2767             }
2768         }
2769     }
2770     return 0;
2771 }
2772
2773 static void
2774 SearchMDebug(Elf_Scn * scnp, Elf32_Shdr * shdrp, staticNameList * nameList,
2775              int nLists, int needed)
2776 {
2777     long *buf = (long *)(elf_getdata(scnp, NULL)->d_buf);
2778     u_long addr, mdoff = shdrp->sh_offset;
2779     HDRR *hdrp;
2780     SYMR *symbase, *symp, *symend;
2781     FDR *fdrbase, *fdrp;
2782     int i, j;
2783     char *strbase, *str;
2784     int ifd;
2785     int nFound = 0;
2786
2787     /* get header */
2788     addr = (__psunsigned_t) buf;
2789     hdrp = (HDRR *) addr;
2790
2791     /* setup base addresses */
2792     addr = (u_long) buf + (u_long) (hdrp->cbFdOffset - mdoff);
2793     fdrbase = (FDR *) addr;
2794     addr = (u_long) buf + (u_long) (hdrp->cbSymOffset - mdoff);
2795     symbase = (SYMR *) addr;
2796     addr = (u_long) buf + (u_long) (hdrp->cbSsOffset - mdoff);
2797     strbase = (char *)addr;
2798
2799 #define KEEPER(a,b)     ((a == stStaticProc && b == scText) || \
2800                          (a == stStatic && (b == scData || b == scBss || \
2801                                             b == scSBss || b == scSData)))
2802
2803     for (fdrp = fdrbase; fdrp < &fdrbase[hdrp->ifdMax]; fdrp++) {
2804         str = strbase + fdrp->issBase + fdrp->rss;
2805
2806         /* local symbols for each fd */
2807         for (symp = &symbase[fdrp->isymBase];
2808              symp < &symbase[fdrp->isymBase + fdrp->csym]; symp++) {
2809             if (KEEPER(symp->st, symp->sc)) {
2810                 if (symp->value == 0)
2811                     continue;
2812
2813                 str = strbase + fdrp->issBase + symp->iss;
2814                 /* Look for AFS symbols of interest */
2815                 if (SearchNameList(str, symp->value, nameList, nLists)) {
2816                     nFound++;
2817                     if (nFound >= needed)
2818                         return;
2819                 }
2820             }
2821         }
2822     }
2823 }
2824
2825 /*
2826  * returns section with the name of scn_name, & puts its header in shdr64 or
2827  * shdr32 based on elf's file type
2828  *
2829  */
2830 Elf_Scn *
2831 findMDebugSection(Elf * elf, char *scn_name)
2832 {
2833     Elf64_Ehdr *ehdr64;
2834     Elf32_Ehdr *ehdr32;
2835     Elf_Scn *scn = NULL;
2836     Elf64_Shdr *shdr64;
2837     Elf32_Shdr *shdr32;
2838
2839     if ((ehdr32 = elf32_getehdr(elf)) == NULL)
2840         return (NULL);
2841     do {
2842         if ((scn = elf_nextscn(elf, scn)) == NULL)
2843             break;
2844         if ((shdr32 = elf32_getshdr(scn)) == NULL)
2845             return (NULL);
2846     } while (strcmp
2847              (scn_name,
2848               elf_strptr(elf, ehdr32->e_shstrndx, shdr32->sh_name)));
2849
2850     return (scn);
2851 }
2852
2853
2854 void
2855 findMDebugStaticAddresses(staticNameList * nameList, int nLists, int needed)
2856 {
2857     int fd;
2858     Elf *elf;
2859     Elf_Scn *mdebug_scn;
2860     Elf32_Shdr *mdebug_shdr;
2861     char *names;
2862
2863     if ((fd = open("/unix", O_RDONLY)) == -1) {
2864         printf("findMDebugStaticAddresses: Failed to open /unix.\n");
2865         return;
2866     }
2867
2868     (void)elf_version(EV_CURRENT);
2869     if ((elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
2870         printf
2871             ("findMDebugStaticAddresses: /unix doesn't seem to be an elf file\n");
2872         close(fd);
2873         return;
2874     }
2875     mdebug_scn = findMDebugSection(elf, ".mdebug");
2876     if (!mdebug_scn) {
2877         printf("findMDebugStaticAddresses: Can't find .mdebug section.\n");
2878         goto find_end;
2879     }
2880     mdebug_shdr = elf32_getshdr(mdebug_scn);
2881     if (!mdebug_shdr) {
2882         printf("findMDebugStaticAddresses: Can't find .mdebug header.\n");
2883         goto find_end;
2884     }
2885
2886     (void)SearchMDebug(mdebug_scn, mdebug_shdr, nameList, nLists, needed);
2887
2888   find_end:
2889     elf_end(elf);
2890     close(fd);
2891 }
2892 #endif /* AFS_SGI62_ENV */
2893
2894 #else /* AFS_SGI61_ENV */
2895 #include <nlist.h>
2896 struct nlist nlunix[] = {
2897     {"rfsdisptab_v2"},
2898     {0},
2899 };
2900
2901 get_nfsstaticaddr()
2902 {
2903     int i, j, kmem, count;
2904
2905     if ((kmem = open("/dev/kmem", O_RDONLY)) < 0) {
2906         printf("Warning: can't open /dev/kmem\n");
2907         return 0;
2908     }
2909     if ((j = nlist("/unix", nlunix)) < 0) {
2910         printf("Warning: can't nlist /unix\n");
2911         return 0;
2912     }
2913     i = nlunix[0].n_value;
2914     if (lseek(kmem, i, L_SET /*0 */ ) != i) {
2915         printf("Warning: can't lseek to %x\n", i);
2916         return 0;
2917     }
2918     if ((j = read(kmem, &count, sizeof count)) != sizeof count) {
2919         printf("WARNING: kmem read at %x failed\n", i);
2920         return 0;
2921     }
2922     return i;
2923 }
2924 #endif /* AFS_SGI61_ENV */
2925 #endif /* AFS_SGI53_ENV */