a3459f92c1c1206e4139d1579a40af6266ce6539
[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   *     -shutdown  Shutdown afs daemons
52   *---------------------------------------------------------------------------*/
53
54 #define VFS 1
55
56 #include <afs/param.h>
57 #include <afs/cmd.h>
58
59 #include <assert.h>
60 #include <itc.h>
61 #include <afs/afsutil.h>
62 #undef in
63 #undef out
64 #include <stdlib.h>
65 #include <stdio.h>
66 #include <signal.h>
67 #include <string.h>
68 #include <stdlib.h>
69 #include <time.h>
70 #include <sys/types.h>
71 #include <sys/stat.h>
72 #include <sys/file.h>
73 #include <errno.h>
74 #include <sys/time.h>
75 #ifdef  AFS_DEC_ENV
76 #include <sys/param.h>
77 #include <sys/fs_types.h>
78 #endif
79 #if     defined(AFS_SUN_ENV)
80 #include <sys/vfs.h>
81 #endif
82 #ifndef AFS_AIX41_ENV
83 #include <sys/mount.h>
84 #endif
85 #include <dirent.h>
86 #ifdef    AFS_SUN5_ENV
87 #include <sys/fcntl.h>
88 #include <sys/mnttab.h>
89 #include <sys/mntent.h>
90 #else
91 #if     defined(AFS_SUN_ENV) || defined(AFS_SGI_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_LINUX20_ENV)
92 #include <mntent.h>
93 #endif
94 #endif
95
96 #if defined(AFS_OSF_ENV) || defined(AFS_DEC_ENV) || defined(AFS_DARWIN_ENV)
97 #include <sys/mount.h>
98 #else
99 #include <sys/vfs.h>
100 #endif
101
102 #include <netinet/in.h>
103 #include <afs/afs_args.h>
104 #include <afs/cellconfig.h>
105 #include <afs/auth.h>
106 #include <ctype.h>
107 #include <afs/afssyscalls.h>
108 #include <afs/afsutil.h>
109
110 #ifdef AFS_SGI61_ENV
111 #include <unistd.h>
112 #include <libelf.h>
113 #include <dwarf.h>
114 #include <libdwarf.h>
115 void set_staticaddrs(void);
116 #endif /* AFS_SGI61_ENV */
117 #if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
118 #include <sym.h>
119 #include <symconst.h>
120 #endif
121 #ifdef AFS_SGI65_ENV
122 #include <sched.h>
123 #endif
124 #ifdef AFS_LINUX20_ENV
125 #include <sys/resource.h>
126 #endif
127
128 #ifndef MOUNT_AFS
129 #define MOUNT_AFS AFS_MOUNT_AFS
130 #endif /* MOUNT_AFS */
131
132 #if AFS_HAVE_STATVFS
133 #include <sys/statvfs.h>
134 #else
135 #if !defined(AFS_OSF_ENV) && !defined(AFS_DARWIN_ENV)
136 #include <sys/statfs.h>
137 #endif
138 #endif
139
140 #undef  VIRTUE
141 #undef  VICE
142
143 #define CACHEINFOFILE   "cacheinfo"
144 #define AFSLOGFILE      "AFSLog"
145 #define DCACHEFILE      "CacheItems"
146 #define VOLINFOFILE     "VolumeItems"
147
148 #define MAXIPADDRS 1024
149
150 char LclCellName[64];
151
152 #define MAX_CACHE_LOOPS 4
153
154 /*
155  * Internet address (old style... should be updated).  This was pulled out of the old 4.2
156  * version of <netinet/in.h>, since it's still useful.
157  */
158 struct in_addr_42 {
159         union {
160                 struct { u_char s_b1,s_b2,s_b3,s_b4; } S_un_b;
161                 struct { u_short s_w1,s_w2; } S_un_w;
162                 afs_uint32 S_addr;
163         } S_un;
164 #define s_host  S_un.S_un_b.s_b2        /* host on imp */
165 #define s_net   S_un.S_un_b.s_b1        /* network */
166 #define s_imp   S_un.S_un_w.s_w2        /* imp */
167 #define s_impno S_un.S_un_b.s_b4        /* imp # */
168 #define s_lh    S_un.S_un_b.s_b3        /* logical host */
169 };
170
171 #define mPrintIPAddr(ipaddr)  printf("[%d.%d.%d.%d] ",          \
172       ((struct in_addr_42 *) &(ipaddr))->S_un.S_un_b.s_b1,      \
173       ((struct in_addr_42 *) &(ipaddr))->S_un.S_un_b.s_b2,      \
174       ((struct in_addr_42 *) &(ipaddr))->S_un.S_un_b.s_b3,      \
175       ((struct in_addr_42 *) &(ipaddr))->S_un.S_un_b.s_b4)
176
177 /*
178  * Global configuration variables.
179  */
180 afs_int32 afs_shutdown = 0;
181 afs_int32 cacheBlocks;                  /*Num blocks in the cache*/
182 afs_int32 cacheFiles    = 1000;                 /*Optimal # of files in workstation cache*/
183 afs_int32 cacheStatEntries =    300;            /*Number of stat cache entries*/
184 char cacheBaseDir[1024];                /*Where the workstation AFS cache lives*/
185 char confDir[1024];                     /*Where the workstation AFS configuration lives*/
186 char fullpn_DCacheFile[1024];           /*Full pathname of DCACHEFILE*/
187 char fullpn_VolInfoFile[1024];          /*Full pathname of VOLINFOFILE*/
188 char fullpn_AFSLogFile[1024];           /*Full pathname of AFSLOGFILE*/
189 char fullpn_CacheInfo[1024];            /*Full pathname of CACHEINFO*/
190 char fullpn_VFile[1024];                /*Full pathname of data cache files*/
191 char *vFileNumber;                      /*Ptr to the number part of above pathname*/
192 int sawCacheMountDir = 0;               /* from cmd line */
193 int sawCacheBaseDir = 0;
194 int sawCacheBlocks = 0;
195 int sawDCacheSize = 0;
196 int sawBiod = 0;
197 char cacheMountDir[1024];               /*Mount directory for AFS*/
198 char rootVolume[64] = "root.afs";       /*AFS root volume name*/
199 afs_int32 cacheSetTime = 1;                     /*Keep checking time to avoid drift?*/
200 afs_int32 isHomeCell;                   /*Is current cell info for the home cell?*/
201 afs_int32 lookingForHomeCell;           /*Are we still looking for the home cell?*/
202 int createAndTrunc = O_CREAT | O_TRUNC; /*Create & truncate on open*/
203 int ownerRWmode = 0600;                 /*Read/write OK by owner*/
204 static int filesSet = 0;                /*True if number of files explicitly set*/
205 static int nDaemons = 2;                /* Number of background daemons */
206 static int chunkSize = 0;               /* 2^chunkSize bytes per chunk */
207 static int dCacheSize = 300;            /* # of dcache entries */
208 static int vCacheSize = 50;             /* # of volume cache entries */
209 static int rootVolSet = 0;              /*True if root volume name explicitly set*/
210 int addrNum;                            /*Cell server address index being printed*/
211 static int cacheFlags = 0;              /*Flags to cache manager*/
212 static int nBiods = 5;                  /* AIX3.1 only */
213 static int preallocs = 400;             /* Def # of allocated memory blocks */
214 static int enable_peer_stats = 0;       /* enable rx stats */
215 static int enable_process_stats = 0;    /* enable rx stats */
216 #ifdef notdef
217 static int inodes = 60;                 /* VERY conservative, but has to be */
218 #endif
219 int afsd_verbose = 0;                   /*Are we being chatty?*/
220 int afsd_debug = 0;                     /*Are we printing debugging info?*/
221 int afsd_CloseSynch = 0;                /*Are closes synchronous or not? */
222
223 #ifdef AFS_SGI62_ENV
224 #define AFSD_INO_T ino64_t
225 #else
226 #define AFSD_INO_T afs_uint32
227 #endif
228 AFSD_INO_T *inode_for_V;                /* Array of inodes for desired
229                                          * cache files */
230 int missing_DCacheFile  = 1;            /*Is the DCACHEFILE missing?*/
231 int missing_VolInfoFile = 1;            /*Is the VOLINFOFILE missing?*/
232 int afsd_rmtsys = 0;                            /* Default: don't support rmtsys */
233 struct afs_cacheParams cparams;          /* params passed to cache manager */
234
235 static int HandleMTab();
236
237 /* ParseArgs is now obsolete, being handled by cmd */
238
239 /*------------------------------------------------------------------------------
240   * ParseCacheInfoFile
241   *
242   * Description:
243   *     Open the file containing the description of the workstation's AFS cache
244   *     and pull out its contents.  The format of this file is as follows:
245   *
246   *         cacheMountDir:cacheBaseDir:cacheBlocks
247   *
248   * Arguments:
249   *     None.
250   *
251   * Returns:
252   *     0 if everything went well,
253   *     1 otherwise.
254   *
255   * Environment:
256   *     Nothing interesting.
257   *
258   *  Side Effects:
259   *     Sets globals.
260   *---------------------------------------------------------------------------*/
261
262 int ParseCacheInfoFile()
263 {
264     static char rn[]="ParseCacheInfoFile";      /*This routine's name*/
265     FILE *cachefd;                              /*Descriptor for cache info file*/
266     int parseResult;                            /*Result of our fscanf()*/
267     afs_int32 tCacheBlocks;
268     char tCacheBaseDir[1024], *tbd, tCacheMountDir[1024], *tmd;
269
270     if (afsd_debug)
271         printf("%s: Opening cache info file '%s'...\n",
272             rn, fullpn_CacheInfo);
273
274     cachefd = fopen(fullpn_CacheInfo, "r");
275     if (!cachefd) {
276         printf("%s: Can't read cache info file '%s'\n",
277                rn, fullpn_CacheInfo);
278         return(1);
279     }
280
281     /*
282      * Parse the contents of the cache info file.  All chars up to the first
283      * colon are the AFS mount directory, all chars to the next colon are the
284      * full path name of the workstation cache directory and all remaining chars
285      * represent the number of blocks in the cache.
286      */
287     tCacheMountDir[0] = tCacheBaseDir[0] = '\0';
288     parseResult = fscanf(cachefd,
289                           "%1024[^:]:%1024[^:]:%d",
290                           tCacheMountDir, tCacheBaseDir, &tCacheBlocks);
291
292     /*
293      * Regardless of how the parse went, we close the cache info file.
294      */
295     fclose(cachefd);
296
297     if (parseResult == EOF || parseResult < 3) {
298         printf("%s: Format error in cache info file!\n",
299                rn);
300         if (parseResult == EOF)
301             printf("\tEOF encountered before any field parsed.\n");
302         else
303             printf("\t%d out of 3 fields successfully parsed.\n",
304                    parseResult);
305
306         printf("\tcacheMountDir: '%s'\n\tcacheBaseDir: '%s'\n\tcacheBlocks: %d\n",
307                cacheMountDir, cacheBaseDir, cacheBlocks);
308         return(1);
309     }
310
311     for (tmd = tCacheMountDir; *tmd == '\n' || *tmd == ' ' || *tmd == '\t'; tmd++) ;
312     for (tbd = tCacheBaseDir; *tbd == '\n' || *tbd == ' ' || *tbd == '\t'; tbd++) ;
313     /* now copy in the fields not explicitly overridden by cmd args */
314     if (!sawCacheMountDir) 
315         strcpy(cacheMountDir, tmd);
316     if (!sawCacheBaseDir)
317         strcpy(cacheBaseDir, tbd);
318     if  (!sawCacheBlocks)
319         cacheBlocks = tCacheBlocks;
320
321     if (afsd_debug) {
322         printf("%s: Cache info file successfully parsed:\n",
323                rn);
324         printf("\tcacheMountDir: '%s'\n\tcacheBaseDir: '%s'\n\tcacheBlocks: %d\n",
325                tmd, tbd, tCacheBlocks);
326     }
327     if (! (cacheFlags & AFSCALL_INIT_MEMCACHE))
328         PartSizeOverflow(tbd, cacheBlocks);
329
330     return(0);
331 }
332
333 /*
334  * All failures to open the partition are ignored. Also if the cache dir 
335  * isn't a mounted partition it's also ignored since we can't guarantee 
336  * what will be stored afterwards. Too many if's. This is now purely
337  * advisory. ODS with over 2G partition also gives warning message.
338  */
339 PartSizeOverflow(path, cs)
340 char *path;
341 int cs;
342 {
343     int bsize=-1, totalblks, mint;
344 #if AFS_HAVE_STATVFS
345     struct statvfs statbuf;
346
347     if (statvfs(path, &statbuf) != 0) {  
348         if (afsd_debug) printf("statvfs failed on %s; skip checking for adequate partition space\n", path);
349         return 0;
350     }
351     totalblks = statbuf.f_blocks;
352     bsize = statbuf.f_frsize;
353 #else
354     struct statfs statbuf;
355
356     if (statfs(path, &statbuf) < 0) {
357         if (afsd_debug) printf("statfs failed on %s; skip checking for adequate partition space\n", path);
358         return 0;
359     }
360     totalblks = statbuf.f_blocks;
361     bsize = statbuf.f_bsize;
362 #endif
363     if (bsize == -1) return 0;  /* sucess */
364
365     /* now free and totalblks are in fragment units, but we want them in 1K units */
366     if (bsize >= 1024) {
367         totalblks *= (bsize / 1024);
368     } else {
369         totalblks /= (1024/bsize);
370     }
371
372     mint = totalblks - ((totalblks * 5) / 100);
373     if (cs > mint) {
374         printf("Cache size (%d) must be less than 95%% of partition size (which is %d). Lower cache size\n", 
375                cs, mint);
376     } 
377 }
378
379 /*-----------------------------------------------------------------------------
380   * GetVFileNumber
381   *
382   * Description:
383   *     Given the final component of a filename expected to be a data cache file,
384   *     return the integer corresponding to the file.  Note: we reject names that
385   *     are not a ``V'' followed by an integer.  We also reject those names having
386   *     the right format but lying outside the range [0..cacheFiles-1].
387   *
388   * Arguments:
389   *     fname : Char ptr to the filename to parse.
390   *
391   * Returns:
392   *     >= 0 iff the file is really a data cache file numbered from 0 to cacheFiles-1, or
393   *     -1      otherwise.
394   *
395   * Environment:
396   *     Nothing interesting.
397   *
398   * Side Effects:
399   *     None.
400   *---------------------------------------------------------------------------*/
401
402 int GetVFileNumber(fname)
403     char *fname;
404 {
405     int computedVNumber;    /*The computed file number we return*/
406     int filenameLen;        /*Number of chars in filename*/
407     int currDigit;          /*Current digit being processed*/
408
409     /*
410      * The filename must have at least two characters, the first of which must be a ``V''
411      * and the second of which cannot be a zero unless the file is exactly two chars long.
412      */
413     filenameLen = strlen(fname);
414     if (filenameLen < 2)
415         return(-1);
416     if (fname[0] != 'V')
417         return(-1);
418     if ((filenameLen > 2) && (fname[1] == '0'))
419         return(-1);
420
421     /*
422      * Scan through the characters in the given filename, failing immediately if a non-digit
423      * is found.
424      */
425     for (currDigit = 1; currDigit < filenameLen; currDigit++)
426         if (isdigit(fname[currDigit]) == 0)
427             return(-1);
428
429     /*
430      * All relevant characters are digits.  Pull out the decimal number they represent.
431      * Reject it if it's out of range, otherwise return it.
432      */
433     computedVNumber = atoi(++fname);
434     if (computedVNumber < cacheFiles)
435         return(computedVNumber);
436     else
437         return(-1);
438 }
439
440 /*-----------------------------------------------------------------------------
441   * CreateCacheFile
442   *
443   * Description:
444   *     Given a full pathname for a file we need to create for the workstation AFS
445   *     cache, go ahead and create the file.
446   *
447   * Arguments:
448   *     fname : Full pathname of file to create.
449   *
450   * Returns:
451   *     0   iff the file was created,
452   *     -1  otherwise.
453   *
454   * Environment:
455   *     The given cache file has been found to be missing.
456   *
457   * Side Effects:
458   *     As described.
459   *---------------------------------------------------------------------------*/
460
461 int CreateCacheFile(fname)
462     char *fname;
463 {
464     static char rn[] = "CreateCacheFile";   /*Routine name*/
465     int cfd;                                /*File descriptor to AFS cache file*/
466     int closeResult;                        /*Result of close()*/
467
468     if (afsd_verbose)
469         printf("%s: Creating cache file '%s'\n",
470                rn, fname);
471     cfd = open(fname, createAndTrunc, ownerRWmode);
472     if  (cfd <= 0) {
473         printf("%s: Can't create '%s', error return is %d (%d)\n",
474                rn, fname, cfd, errno);
475         return(-1);
476     }
477     closeResult = close(cfd);
478     if  (closeResult) {
479         printf("%s: Can't close newly-created AFS cache file '%s' (code %d)\n",
480                rn, fname, errno);
481         return(-1);
482     }
483
484     return(0);
485 }
486
487 /*-----------------------------------------------------------------------------
488   * SweepAFSCache
489   *
490   * Description:
491   *     Sweep through the AFS cache directory, recording the inode number for
492   *     each valid data cache file there.  Also, delete any file that doesn't beint32
493   *     in the cache directory during this sweep, and remember which of the other
494   *     residents of this directory were seen.  After the sweep, we create any data
495   *     cache files that were missing.
496   *
497   * Arguments:
498   *     vFilesFound : Set to the number of data cache files found.
499   *
500   * Returns:
501   *     0   if everything went well,
502   *     -1 otherwise.
503   *
504   * Environment:
505   *     This routine may be called several times.  If the number of data cache files
506   *     found is less than the global cacheFiles, then the caller will need to call it
507   *     again to record the inodes of the missing zero-length data cache files created
508   *     in the previous call.
509   *
510   * Side Effects:
511   *     Fills up the global inode_for_V array, may create and/or delete files as
512   *     explained above.
513   *---------------------------------------------------------------------------*/
514
515 int SweepAFSCache(vFilesFound)
516     int *vFilesFound;
517 {
518     static char rn[] = "SweepAFSCache"; /*Routine name*/
519     char fullpn_FileToDelete[1024];     /*File to be deleted from cache*/
520     char *fileToDelete;                 /*Ptr to last component of above*/
521     DIR *cdirp;                         /*Ptr to cache directory structure*/
522 #ifdef AFS_SGI62_ENV
523     struct dirent64 *currp;             /*Current directory entry*/
524 #else
525     struct dirent *currp;               /*Current directory entry*/
526 #endif
527     int vFileNum;                       /*Data cache file's associated number*/
528
529     if (cacheFlags & AFSCALL_INIT_MEMCACHE) {
530         if (afsd_debug)
531             printf("%s: Memory Cache, no cache sweep done\n", rn);
532         *vFilesFound = 0;
533         return 0;
534     }
535
536     if (afsd_debug)
537         printf("%s: Opening cache directory '%s'\n",
538                rn, cacheBaseDir);
539
540     if (chmod(cacheBaseDir, 0700)) {            /* force it to be 700 */
541         printf("%s: Can't 'chmod 0700' the cache dir, '%s'.\n",
542                rn, cacheBaseDir);
543         return (-1);
544     }
545     cdirp = opendir(cacheBaseDir);
546     if (cdirp == (DIR *)0) {
547         printf("%s: Can't open AFS cache directory, '%s'.\n",
548                rn, cacheBaseDir);
549         return(-1);
550     }
551
552     /*
553      * Scan the directory entries, remembering data cache file inodes and the existance
554      * of other important residents.  Delete all files that don't belong here.
555      */
556     *vFilesFound = 0;
557     sprintf(fullpn_FileToDelete, "%s/", cacheBaseDir);
558     fileToDelete = fullpn_FileToDelete + strlen(fullpn_FileToDelete);
559
560 #ifdef AFS_SGI62_ENV
561     for (currp = readdir64(cdirp); currp; currp = readdir64(cdirp))
562 #else
563     for (currp = readdir(cdirp); currp; currp = readdir(cdirp))
564 #endif
565         {
566         if (afsd_debug) {
567             printf("%s: Current directory entry:\n",
568                    rn);
569 #ifdef AFS_SGI62_ENV
570             printf("\tinode=%lld, reclen=%d, name='%s'\n",
571                    currp->d_ino, currp->d_reclen, currp->d_name);
572 #else
573             printf("\tinode=%d, reclen=%d, name='%s'\n",
574                    currp->d_ino, currp->d_reclen, currp->d_name);
575 #endif
576         }
577
578         /*
579          * Guess current entry is for a data cache file.
580          */
581         vFileNum = GetVFileNumber(currp->d_name);
582         if (vFileNum >= 0) {
583             /*
584              * Found a valid data cache filename.  Remember this file's inode and bump
585              * the number of files found.
586              */
587             inode_for_V[vFileNum] = currp->d_ino;
588             (*vFilesFound)++;
589         }
590         else if (strcmp(currp->d_name, DCACHEFILE) == 0) {
591             /*
592              * Found the file holding the dcache entries.
593              */
594             missing_DCacheFile = 0;
595         }
596         else if (strcmp(currp->d_name, VOLINFOFILE) == 0) {
597             /*
598              * Found the file holding the volume info.
599              */
600             missing_VolInfoFile = 0;
601         }
602         else  if ((strcmp(currp->d_name,          ".") == 0) ||
603                   (strcmp(currp->d_name,         "..") == 0) ||
604 #ifdef AFS_DECOSF_ENV
605                   /* these are magic AdvFS files */
606                   (strcmp(currp->d_name,         ".tags") == 0) ||
607                   (strcmp(currp->d_name,         "quota.user") == 0) ||
608                   (strcmp(currp->d_name,         "quota.group") == 0) ||
609 #endif
610                   (strcmp(currp->d_name, "lost+found") == 0)) {
611             /*
612              * Don't do anything - this file is legit, and is to be left alone.
613              */
614         }
615         else {
616             /*
617              * This file doesn't belong in the cache.  Nuke it.
618              */
619             sprintf(fileToDelete, "%s", currp->d_name);
620             if (afsd_verbose)
621                 printf("%s: Deleting '%s'\n",
622                        rn, fullpn_FileToDelete);
623             if (unlink(fullpn_FileToDelete)) {
624                 printf("%s: Can't unlink '%s', errno is %d\n",
625                        rn, fullpn_FileToDelete, errno);
626             }
627         }
628     }
629
630     /*
631      * Create all the cache files that are missing.
632      */
633     if (missing_DCacheFile) {
634         if (afsd_verbose)
635             printf("%s: Creating '%s'\n",
636                    rn, fullpn_DCacheFile);
637         if (CreateCacheFile(fullpn_DCacheFile))
638             printf("%s: Can't create '%s'\n",
639                    rn, fullpn_DCacheFile);
640     }
641     if (missing_VolInfoFile) {
642         if (afsd_verbose)
643             printf("%s: Creating '%s'\n",
644                    rn, fullpn_VolInfoFile);
645         if (CreateCacheFile(fullpn_VolInfoFile))
646             printf("%s: Can't create '%s'\n",
647                    rn, fullpn_VolInfoFile);
648     }
649
650     if (*vFilesFound < cacheFiles) {
651         /*
652          * We came up short on the number of data cache files found.  Scan through the inode
653          * list and create all missing files.
654          */
655         for (vFileNum = 0; vFileNum < cacheFiles; vFileNum++)
656             if (inode_for_V[vFileNum] == (AFSD_INO_T)0) {
657                 sprintf(vFileNumber, "%d", vFileNum);
658                 if (afsd_verbose)
659                     printf("%s: Creating '%s'\n",
660                            rn, fullpn_VFile);
661                 if (CreateCacheFile(fullpn_VFile))
662                     printf("%s: Can't create '%s'\n",
663                            rn, fullpn_VFile);
664             }
665     }
666     
667     /*
668      * Close the directory, return success.
669      */
670     if (afsd_debug)
671         printf("%s: Closing cache directory.\n",
672                rn);
673     closedir(cdirp);
674     return(0);
675 }
676
677 static ConfigCell(aci, arock, adir)
678 register struct afsconf_cell *aci;
679 char *arock;
680 struct afsconf_dir *adir; {
681     register int isHomeCell;
682     register int i;
683     afs_int32 cellFlags;
684     afs_int32 hosts[MAXHOSTSPERCELL];
685     
686     /* figure out if this is the home cell */
687     isHomeCell = (strcmp(aci->name, LclCellName) == 0);
688     if (isHomeCell) {
689         lookingForHomeCell = 0;
690         cellFlags = 1;      /* home cell, suid is ok */
691     }
692     else {
693         cellFlags = 2;      /* not home, suid is forbidden */
694     }
695     
696     /* build address list */
697     for(i=0;i<MAXHOSTSPERCELL;i++)
698         memcpy(&hosts[i], &aci->hostAddr[i].sin_addr, sizeof(afs_int32));
699
700     if (aci->linkedCell) cellFlags |= 4; /* Flag that linkedCell arg exists,
701                                             for upwards compatibility */
702
703     /* configure one cell */
704     call_syscall(AFSOP_ADDCELL2,
705              hosts,                     /* server addresses */
706              aci->name,                 /* cell name */
707              cellFlags,                 /* is this the home cell? */
708              aci->linkedCell);          /* Linked cell, if any */
709     return 0;
710 }
711
712 #ifdef mac2
713 #include <sys/ioctl.h>
714 #endif /* mac2 */
715
716 #ifdef AFS_SGI65_ENV
717 #define SET_RTPRI(P) {  \
718     struct sched_param sp; \
719     sp.sched_priority = P; \
720     if (sched_setscheduler(0, SCHED_RR, &sp)<0) { \
721         perror("sched_setscheduler"); \
722     } \
723 }
724 #define SET_AFSD_RTPRI() SET_RTPRI(68)
725 #define SET_RX_RTPRI()   SET_RTPRI(199)
726 #else
727 #ifdef AFS_LINUX20_ENV
728 #define SET_AFSD_RTPRI()
729 #define SET_RX_RTPRI()  do { if (setpriority(PRIO_PROCESS, 0, -10)<0) \
730                            perror("setting rx priority"); \
731                          } while (0)
732 #else
733 #define SET_AFSD_RTPRI() 
734 #define SET_RX_RTPRI()   
735 #endif
736 #endif
737
738 mainproc(as, arock)
739   register struct cmd_syndesc *as;
740   char *arock;
741 {
742     static char rn[] = "afsd";      /*Name of this routine*/
743     register afs_int32 code;                /*Result of fork()*/
744     register int i;
745     int currVFile;                  /*Current AFS cache file number passed in*/
746     int mountFlags;                 /*Flags passed to mount()*/
747     int lookupResult;               /*Result of GetLocalCellName()*/
748     int cacheIteration;             /*How many times through cache verification*/
749     int vFilesFound;                /*How many data cache files were found in sweep*/
750     struct afsconf_dir *cdir;       /* config dir */
751     FILE *logfd;
752 #ifdef  AFS_SUN5_ENV
753     struct stat st;
754 #endif
755     afs_int32 vfs1_type = -1;
756 #ifdef AFS_SGI65_ENV
757     struct sched_param sp;
758 #endif
759
760 #ifdef AFS_SGI_VNODE_GLUE
761     if (afs_init_kernel_config(-1) <0) {
762         printf("Can't determine NUMA configuration, not starting AFS.\n");
763         exit(1);
764     }
765 #endif
766
767     /* call atoi on the appropriate parsed results */
768     if (as->parms[0].items) {
769         /* -blocks */
770         cacheBlocks = atoi(as->parms[0].items->data);
771         sawCacheBlocks = 1;
772     }
773     if (as->parms[1].items) {
774         /* -files */
775         cacheFiles = atoi(as->parms[1].items->data);
776         filesSet = 1;   /* set when spec'd on cmd line */
777     }
778     if (as->parms[2].items) {
779         /* -rootvol */
780         strcpy(rootVolume, as->parms[2].items->data);
781         rootVolSet = 1;
782     }
783     if (as->parms[3].items) {
784         /* -stat */
785         cacheStatEntries = atoi(as->parms[3].items->data);
786     }
787     if (as->parms[4].items) {
788         /* -memcache */
789         cacheBaseDir[0] = '\0';
790         sawCacheBaseDir = 1;
791         cacheFlags |= AFSCALL_INIT_MEMCACHE;
792         if (chunkSize == 0)
793             chunkSize = 13;
794     }
795     if (as->parms[5].items) {
796         /* -cachedir */
797         strcpy(cacheBaseDir, as->parms[5].items->data);
798         sawCacheBaseDir = 1;
799     }
800     if (as->parms[6].items) {
801         /* -mountdir */
802         strcpy(cacheMountDir, as->parms[6].items->data);
803         sawCacheMountDir = 1;
804     }
805     if (as->parms[7].items) {
806         /* -daemons */
807         nDaemons = atoi(as->parms[7].items->data);
808     }
809     if (as->parms[8].items) {
810         /* -nosettime */
811         cacheSetTime = FALSE;
812     }
813     if (as->parms[9].items) {
814         /* -verbose */
815         afsd_verbose = 1;
816     }
817     if (as->parms[10].items) {
818         /* -rmtsys */
819         afsd_rmtsys = 1;
820     }
821     if (as->parms[11].items) {
822         /* -debug */
823         afsd_debug = 1;
824         afsd_verbose = 1;
825     }
826     if (as->parms[12].items) {
827         /* -chunksize */
828         chunkSize = atoi(as->parms[12].items->data);
829         if (chunkSize < 0 || chunkSize > 30) {
830             printf("afsd:invalid chunk size spec'd, using default\n");
831             chunkSize = 0;
832         }
833     }
834     if (as->parms[13].items) {
835         /* -dcache */
836         dCacheSize = atoi(as->parms[13].items->data);
837         sawDCacheSize = 1;
838     }
839     if (as->parms[14].items) {
840         /* -volumes */
841         vCacheSize = atoi(as->parms[14].items->data);
842     }
843     if (as->parms[15].items) {
844         /* -biods */
845 #ifndef AFS_AIX32_ENV
846         printf("afsd: [-biods] currently only enabled for aix3.x VM supported systems\n");
847 #else
848         nBiods = atoi(as->parms[15].items->data);
849         sawBiod = 1;
850 #endif
851     }
852     if (as->parms[16].items) {
853         /* -prealloc */
854         preallocs = atoi(as->parms[16].items->data);
855     }
856 #ifdef notdef 
857     if (as->parms[17].items) {
858         /* -pininodes */
859         inodes = atoi(as->parms[17].items->data);
860     }
861 #endif
862     strcpy(confDir, AFSDIR_CLIENT_ETC_DIRPATH);
863     if (as->parms[17].items) {
864         /* -confdir */
865         strcpy(confDir, as->parms[17].items->data);
866     }
867     sprintf(fullpn_CacheInfo,  "%s/%s", confDir, CACHEINFOFILE);
868     sprintf(fullpn_AFSLogFile,  "%s/%s", confDir, AFSLOGFILE);
869     if (as->parms[18].items) {
870         /* -logfile */
871         strcpy(fullpn_AFSLogFile, as->parms[18].items->data);
872     }
873     if (as->parms[19].items) {
874       /* -waitclose */
875       afsd_CloseSynch = 1;
876     }
877     if (as->parms[20].items) {
878         /* -shutdown */
879         afs_shutdown = 1;
880         /* 
881          * Cold shutdown is the default
882          */
883         printf("afsd: Shutting down all afs processes and afs state\n");
884         call_syscall(AFSOP_SHUTDOWN, 1);
885         exit(0);
886     }
887     if (as->parms[21].items) {
888         /* -enable_peer_stats */
889         enable_peer_stats = 1;
890     }
891     if (as->parms[22].items) {
892         /* -enable_process_stats */
893         enable_process_stats = 1;
894     }
895     if (as->parms[23].items) {
896         /* -mem_alloc_sleep */
897         cacheFlags |= AFSCALL_INIT_MEMCACHE_SLEEP;
898     }
899
900     /*
901      * Pull out all the configuration info for the workstation's AFS cache and
902      * the cellular community we're willing to let our users see.
903      */
904     cdir = afsconf_Open(confDir);
905     if (!cdir) {
906         printf("afsd: some file missing or bad in %s\n", confDir);
907         exit(1);
908     }
909
910     lookupResult = afsconf_GetLocalCell(cdir, LclCellName, sizeof(LclCellName));
911     if (lookupResult) {
912         printf("%s: Can't get my home cell name!  [Error is %d]\n",
913                rn, lookupResult);
914     }
915     else {
916         if (afsd_verbose)
917             printf("%s: My home cell is '%s'\n",
918                    rn, LclCellName);
919     }
920
921     /* parse cacheinfo file if this is a diskcache */
922     if (ParseCacheInfoFile()) {
923         exit(1);
924     }
925
926     if ((logfd = fopen(fullpn_AFSLogFile,"r+")) == 0) {
927         if (afsd_verbose)  printf("%s: Creating '%s'\n",  rn, fullpn_AFSLogFile);
928         if (CreateCacheFile(fullpn_AFSLogFile)) {
929             printf("%s: Can't create '%s' (You may want to use the -logfile option)\n",  rn, fullpn_AFSLogFile);
930             exit(1);
931         }
932     } else
933         fclose(logfd);
934
935     /* do some random computations in memcache case to get things to work
936      * reasonably no matter which parameters you set.
937      */
938     if (cacheFlags & AFSCALL_INIT_MEMCACHE) {
939         /* memory cache: size described either as blocks or dcache entries, but
940          * not both.
941          */
942         if (sawDCacheSize) {
943             if (sawCacheBlocks) {
944                 printf("%s: can't set cache blocks and dcache size simultaneously when diskless.\n", rn);
945                 exit(1);
946             }
947             /* compute the cache size based on # of chunks times the chunk size */
948             i = (chunkSize == 0? 13 : chunkSize);
949             i = (1<<i); /* bytes per chunk */
950             cacheBlocks = i * dCacheSize;
951             sawCacheBlocks = 1; /* so that ParseCacheInfoFile doesn't overwrite */
952         }
953         else {
954             /* compute the dcache size from overall cache size and chunk size */
955             i = (chunkSize == 0? 13 : chunkSize);
956             /* dCacheSize = (cacheBlocks << 10) / (1<<i); */
957             if (i > 10) {
958                 dCacheSize = (cacheBlocks >> (i-10));
959             } else if (i < 10) {
960                 dCacheSize = (cacheBlocks << (10-i));
961             } else {
962                 dCacheSize = cacheBlocks;
963             }
964             /* don't have to set sawDCacheSize here since it isn't overwritten
965              * by ParseCacheInfoFile.
966              */
967         }
968         /* kernel computes # of dcache entries as min of cacheFiles and dCacheSize,
969          * so we now make them equal.
970          */
971         cacheFiles = dCacheSize;
972     }
973     else {
974         /* Disk cache:
975          * Compute the number of cache files based on cache size,
976          * but only if -files isn't given on the command line.
977          * Don't let # files be so small as to prevent full utilization 
978          * of the cache unless user has explicitly asked for it.
979          * average V-file is ~10K, according to tentative empirical studies.
980          */
981         if (!filesSet) {
982             cacheFiles = cacheBlocks / 10;       
983             if (cacheFiles <  100) cacheFiles =  100;
984             /* Always allow more files than chunks.  Presume average V-file 
985              * is ~67% of a chunk...  (another guess, perhaps Honeyman will
986              * have a grad student write a paper).  i is KILOBYTES.
987              */
988             i = 1 << (chunkSize == 0? 6 : (chunkSize<10 ? 0 : chunkSize -10));
989             cacheFiles = max(cacheFiles, 1.5 * (cacheBlocks / i));
990             /* never permit more files than blocks, while leaving space for
991              * VolumeInfo and CacheItems files.  VolumeInfo is usually 20K,
992              * CacheItems is 50 Bytes / file (== 1K/20)
993              */
994 #define VOLINFOSZ 20
995 #define CACHEITMSZ (cacheFiles / 20)
996 #ifdef AFS_AIX_ENV
997             cacheFiles= min(cacheFiles,(cacheBlocks -VOLINFOSZ -CACHEITMSZ)/4);
998 #else
999             cacheFiles = min(cacheFiles, cacheBlocks - VOLINFOSZ - CACHEITMSZ);
1000 #endif
1001             if (cacheFiles <  100) 
1002               fprintf (stderr, "%s: WARNING: cache probably too small!\n", rn);
1003         }
1004         if (!sawDCacheSize) {
1005             if ((cacheFiles / 2) > dCacheSize)
1006                 dCacheSize = cacheFiles / 2;
1007             if (dCacheSize > 2000)
1008                 dCacheSize = 2000;
1009         }
1010     }
1011
1012     /*
1013      * Create and zero the inode table for the desired cache files.
1014      */
1015     inode_for_V = (AFSD_INO_T *) malloc(cacheFiles * sizeof(AFSD_INO_T));
1016     if (inode_for_V == (AFSD_INO_T *)0) {
1017         printf("%s: malloc() failed for cache file inode table with %d entries.\n",
1018                rn, cacheFiles);
1019         exit(1);
1020     }
1021     memset(inode_for_V, '\0', (cacheFiles * sizeof(AFSD_INO_T)));
1022     if (afsd_debug)
1023         printf("%s: %d inode_for_V entries at 0x%x, %d bytes\n",
1024                rn, cacheFiles, inode_for_V,
1025                (cacheFiles * sizeof(AFSD_INO_T)));
1026
1027     /*
1028      * Set up all the pathnames we'll need for later.
1029      */
1030     sprintf(fullpn_DCacheFile,  "%s/%s", cacheBaseDir, DCACHEFILE);
1031     sprintf(fullpn_VolInfoFile, "%s/%s", cacheBaseDir, VOLINFOFILE);
1032     sprintf(fullpn_VFile,       "%s/V",  cacheBaseDir);
1033     vFileNumber = fullpn_VFile + strlen(fullpn_VFile);
1034
1035 #if 0
1036     fputs(AFS_GOVERNMENT_MESSAGE, stdout); 
1037     fflush(stdout);
1038 #endif
1039
1040     /*
1041      * Set up all the kernel processes needed for AFS.
1042      */
1043 #ifdef mac2
1044     setpgrp(getpid(), 0);
1045 #endif /* mac2 */
1046
1047     /* Initialize RX daemons and services */
1048
1049     /* initialize the rx random number generator from user space */
1050     {
1051       /* parse multihomed address files */
1052       afs_int32 addrbuf[MAXIPADDRS],maskbuf[MAXIPADDRS],mtubuf[MAXIPADDRS];
1053       char reason[1024];
1054       code=parseNetFiles(addrbuf,maskbuf,mtubuf,MAXIPADDRS,reason,
1055                     AFSDIR_CLIENT_NETINFO_FILEPATH,
1056                     AFSDIR_CLIENT_NETRESTRICT_FILEPATH);
1057       if(code>0) 
1058         call_syscall(AFSOP_ADVISEADDR, code, addrbuf, maskbuf, mtubuf);
1059       else 
1060         printf("ADVISEADDR: Error in specifying interface addresses:%s\n",reason);
1061     }
1062
1063     /* Set realtime priority for most threads to same as for biod's. */
1064     SET_AFSD_RTPRI();
1065
1066 #ifdef  AFS_SGI53_ENV
1067 #ifdef AFS_SGI61_ENV
1068     set_staticaddrs();
1069 #else /* AFS_SGI61_ENV */
1070     code = get_nfsstaticaddr();
1071     if (code)
1072         call_syscall(AFSOP_NFSSTATICADDR, code);
1073 #endif /* AFS_SGI61_ENV */
1074 #endif /* AFS_SGI_53_ENV */
1075
1076     /* Start listener, then callback listener. Lastly, start rx event daemon.
1077      * Change in ordering is so that Linux port has socket fd in listener
1078      * process.
1079      * preallocs are passed for both listener and callback server. Only
1080      * the one which actually does the initialization uses them though.
1081      */
1082     if (preallocs < cacheStatEntries+50)
1083         preallocs = cacheStatEntries+50;
1084 #ifdef RXK_LISTENER_ENV
1085     if (afsd_verbose)
1086         printf("%s: Forking rx listener daemon.\n", rn);
1087     code = fork();
1088     if (code == 0) {
1089         /* Child */
1090         SET_RX_RTPRI(); /* max advised for non-interrupts */
1091         call_syscall(AFSOP_RXLISTENER_DAEMON,
1092                      preallocs,
1093                      enable_peer_stats,
1094                      enable_process_stats);
1095         exit(1);
1096     }
1097 #endif
1098     if (afsd_verbose)
1099         printf("%s: Forking rx callback listener.\n", rn);
1100     code = fork();
1101     if (code == 0) {
1102         /* Child */
1103         call_syscall(AFSOP_START_RXCALLBACK, preallocs);
1104         exit(1);
1105     }
1106 #if defined(AFS_SUN5_ENV) || defined(RXK_LISTENER_ENV)
1107     if (afsd_verbose)
1108         printf("%s: Forking rxevent daemon.\n", rn);
1109     code = fork();
1110     if (code == 0) {
1111         /* Child */
1112         SET_RX_RTPRI(); /* max advised for non-interrupts */
1113         call_syscall(AFSOP_RXEVENT_DAEMON);
1114         exit(1);
1115     }
1116 #endif
1117
1118     /* Initialize AFS daemon threads. */
1119     if (afsd_verbose)
1120         printf("%s: Forking AFS daemon.\n", rn);
1121     code = fork();
1122     if (code == 0) {
1123         /* Child */
1124         call_syscall(AFSOP_START_AFS);
1125         exit(1);
1126     }
1127
1128     if (afsd_verbose)
1129         printf("%s: Forking Check Server Daemon.\n", rn);
1130     code = fork();
1131     if (code == 0) {
1132         /* Child */
1133         code = call_syscall(AFSOP_START_CS);
1134         if (code)
1135             printf("%s: No check server daemon in client.\n", rn);
1136         exit(1);
1137     }
1138
1139     if (afsd_verbose)
1140         printf("%s: Forking %d background daemons.\n", rn, nDaemons);
1141 #if defined(AFS_SGI_ENV) && defined(AFS_SGI_SHORTSTACK)
1142     /* Add one because for sgi we always "steal" the first daemon for a
1143      * different task if we only have a 4K stack.
1144      */
1145     nDaemons++;
1146 #endif
1147     for (i=0;i<nDaemons;i++) {
1148         code = fork();
1149         if (code == 0) {
1150             /* Child */
1151 #ifdef  AFS_AIX32_ENV
1152             call_syscall(AFSOP_START_BKG, 0);
1153 #else
1154             call_syscall(AFSOP_START_BKG);
1155 #endif
1156             exit(1);
1157         }
1158     }
1159 #ifdef  AFS_AIX32_ENV
1160     if (!sawBiod) 
1161         nBiods = nDaemons * 2;
1162     if (nBiods < 5)
1163         nBiods = 5;
1164     for (i=0; i< nBiods;i++) {
1165         code = fork();
1166         if (code == 0) {        /* Child */
1167             call_syscall(AFSOP_START_BKG, nBiods);
1168             exit(1);
1169         }
1170     }
1171 #endif
1172
1173     /*
1174      * Tell the kernel about each cell in the configuration.
1175      */
1176     lookingForHomeCell = 1;
1177
1178     afsconf_CellApply(cdir, ConfigCell, (char *) 0);
1179
1180     /*
1181      * If we're still looking for the home cell after the whole cell configuration database
1182      * has been parsed, there's something wrong.
1183      */
1184     if (lookingForHomeCell) {
1185         printf("%s: Can't find information for home cell '%s' in cell database!\n",
1186                rn, LclCellName);
1187     }
1188
1189     /*
1190          * If the root volume has been explicitly set, tell the kernel.
1191          */
1192     if (rootVolSet) {
1193         if (afsd_verbose)
1194             printf("%s: Calling AFSOP_ROOTVOLUME with '%s'\n",
1195               rn, rootVolume);
1196         call_syscall(AFSOP_ROOTVOLUME, rootVolume);
1197     }
1198
1199     /*
1200      * Tell the kernel some basic information about the workstation's cache.
1201      */
1202     if (afsd_verbose)
1203         printf("%s: Calling AFSOP_CACHEINIT: %d stat cache entries, %d optimum cache files, %d blocks in the cache, flags = 0x%x, dcache entries %d\n",
1204                rn, cacheStatEntries, cacheFiles, cacheBlocks, cacheFlags,
1205                dCacheSize);
1206     memset(&cparams, '\0', sizeof(cparams));
1207     cparams.cacheScaches = cacheStatEntries;
1208     cparams.cacheFiles = cacheFiles;
1209     cparams.cacheBlocks = cacheBlocks;
1210     cparams.cacheDcaches = dCacheSize;
1211     cparams.cacheVolumes = vCacheSize;
1212     cparams.chunkSize = chunkSize;
1213     cparams.setTimeFlag = cacheSetTime;
1214     cparams.memCacheFlag = cacheFlags;
1215 #ifdef notdef
1216     cparams.inodes       = inodes;
1217 #endif
1218     call_syscall(AFSOP_CACHEINIT, &cparams);
1219     if (afsd_CloseSynch) 
1220       call_syscall(AFSOP_CLOSEWAIT);
1221
1222     /*
1223      * Sweep the workstation AFS cache directory, remembering the inodes of
1224      * valid files and deleting extraneous files.  Keep sweeping until we
1225      * have the right number of data cache files or we've swept too many
1226      * times.
1227      */
1228     if (afsd_verbose)
1229         printf("%s: Sweeping workstation's AFS cache directory.\n",
1230                rn);
1231     cacheIteration = 0;
1232     /* Memory-cache based system doesn't need any of this */
1233     if(!(cacheFlags & AFSCALL_INIT_MEMCACHE)) {
1234         do {
1235             cacheIteration++;
1236             if (SweepAFSCache(&vFilesFound)) {
1237                 printf("%s: Error on sweep %d of workstation AFS cache \
1238                        directory.\n", rn, cacheIteration);
1239                 exit(1);
1240             }
1241             if (afsd_verbose)
1242                 printf("%s: %d out of %d data cache files found in sweep %d.\n",
1243                        rn, vFilesFound, cacheFiles, cacheIteration);
1244         } while ((vFilesFound < cacheFiles) &&
1245                  (cacheIteration < MAX_CACHE_LOOPS));
1246     } else if(afsd_verbose)
1247         printf("%s: Using memory cache, not swept\n", rn);
1248
1249     /*
1250      * Pass the kernel the name of the workstation cache file holding the 
1251      * dcache entries.
1252      */
1253     if (afsd_debug)
1254         printf("%s: Calling AFSOP_CACHEINFO: dcache file is '%s'\n",
1255                rn, fullpn_DCacheFile);
1256     /* once again, meaningless for a memory-based cache. */
1257     if(!(cacheFlags & AFSCALL_INIT_MEMCACHE))
1258         call_syscall(AFSOP_CACHEINFO, fullpn_DCacheFile);
1259
1260     /*
1261      * Pass the kernel the name of the workstation cache file holding the
1262      * volume information.
1263      */
1264     if (afsd_debug)
1265         printf("%s: Calling AFSOP_VOLUMEINFO: volume info file is '%s'\n",
1266                rn, fullpn_VolInfoFile);
1267     call_syscall(AFSOP_VOLUMEINFO,fullpn_VolInfoFile);
1268
1269     /*
1270      * Pass the kernel the name of the afs logging file holding the volume
1271      * information.
1272      */
1273     if (afsd_debug)
1274         printf("%s: Calling AFSOP_AFSLOG: volume info file is '%s'\n",
1275                rn, fullpn_AFSLogFile);
1276 #if defined(AFS_SGI_ENV)
1277     /* permit explicit -logfile argument to enable logging on memcache systems */
1278     if (!(cacheFlags & AFSCALL_INIT_MEMCACHE) || as->parms[18].items)
1279 #else
1280     if (!(cacheFlags & AFSCALL_INIT_MEMCACHE)) /* ... nor this ... */
1281 #endif
1282         call_syscall(AFSOP_AFSLOG,fullpn_AFSLogFile);
1283
1284     /*
1285      * Give the kernel the names of the AFS files cached on the workstation's
1286      * disk.
1287      */
1288     if (afsd_debug)
1289         printf("%s: Calling AFSOP_CACHEINODE for each of the %d files in '%s'\n",
1290                rn, cacheFiles, cacheBaseDir);
1291     if (!(cacheFlags & AFSCALL_INIT_MEMCACHE)) /* ... and again ... */
1292         for (currVFile = 0; currVFile < cacheFiles; currVFile++) {
1293 #ifdef AFS_SGI62_ENV
1294             call_syscall(AFSOP_CACHEINODE,
1295                          (afs_uint32)(inode_for_V[currVFile]>>32),
1296                          (afs_uint32)(inode_for_V[currVFile] & 0xffffffff));
1297 #else
1298             call_syscall(AFSOP_CACHEINODE, inode_for_V[currVFile]);
1299 #endif
1300         } /*end for*/
1301
1302
1303     /*
1304      * All the necessary info has been passed into the kernel to run an AFS
1305      * system.  Give the kernel our go-ahead.
1306      */
1307     if (afsd_debug)
1308          printf("%s: Calling AFSOP_GO with cacheSetTime = %d\n",
1309                 rn, cacheSetTime);
1310      call_syscall(AFSOP_GO, cacheSetTime);
1311
1312     /*
1313      * At this point, we have finished passing the kernel all the info 
1314      * it needs to set up the AFS.  Mount the AFS root.
1315      */
1316     printf("%s: All AFS daemons started.\n", rn);
1317
1318     if (afsd_verbose)
1319         printf("%s: Forking trunc-cache daemon.\n", rn);
1320     code = fork();
1321     if (code == 0) {
1322         /* Child */
1323         call_syscall(AFSOP_START_TRUNCDAEMON);
1324         exit(1);
1325     }
1326
1327     mountFlags = 0;     /* Read/write file system, can do setuid() */
1328 #if     defined(AFS_SUN_ENV) || defined(AFS_SUN5_ENV)
1329 #ifdef  AFS_SUN5_ENV
1330     mountFlags |= MS_DATA;
1331 #else
1332     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... */
1333 #endif
1334 #endif
1335
1336 #if defined(AFS_HPUX100_ENV)
1337         mountFlags |= MS_DATA;
1338 #endif
1339
1340     if (afsd_verbose)
1341         printf("%s: Mounting the AFS root on '%s', flags: %d.\n",
1342                rn, cacheMountDir, mountFlags);
1343 #ifdef AFS_DEC_ENV
1344     if ((mount("AFS",cacheMountDir,mountFlags,GT_AFS,(caddr_t) 0)) < 0) {
1345 #else
1346 #ifdef  AFS_AUX_ENV
1347     if ((fsmount(MOUNT_AFS,cacheMountDir,mountFlags,(caddr_t) 0)) < 0)  {
1348 #else
1349 #ifdef  AFS_AIX_ENV
1350     if (aix_vmount()) {
1351 #else
1352 #if defined(AFS_HPUX100_ENV)
1353     if ((mount("",cacheMountDir,mountFlags,"afs", (char *)0, 0)) < 0) {
1354 #else
1355 #ifdef  AFS_HPUX_ENV
1356 #if     defined(AFS_HPUX90_ENV)
1357     { 
1358         char buffer[80];
1359         int code;
1360
1361         strcpy(buffer, "afs");
1362         code = vfsmount(-1,cacheMountDir,mountFlags,(caddr_t) buffer);
1363         sscanf(buffer, "%d", &vfs1_type);
1364         if (code < 0) {
1365             printf("Can't find 'afs' type in the registered filesystem table!\n");
1366             exit(1);
1367         }
1368         sscanf(buffer, "%d", &vfs1_type);
1369         if (afsd_verbose)
1370             printf("AFS vfs slot number is %d\n", vfs1_type);
1371     }
1372     if ((vfsmount(vfs1_type,cacheMountDir,mountFlags,(caddr_t) 0)) < 0) {
1373 #else
1374     if (call_syscall(AFSOP_AFS_VFSMOUNT, MOUNT_AFS, cacheMountDir,
1375                      mountFlags, (caddr_t)NULL) < 0) {
1376 #endif
1377 #else
1378 #ifdef  AFS_SUN5_ENV
1379     if ((mount("AFS",cacheMountDir,mountFlags,"afs", (char *)0, 0)) < 0) {
1380 #else
1381 #if defined(AFS_SGI_ENV)
1382     mountFlags = MS_FSS;
1383
1384     if ((mount(MOUNT_AFS,cacheMountDir,mountFlags,(caddr_t) MOUNT_AFS)) < 0) {
1385 #else
1386 #ifdef AFS_LINUX20_ENV
1387     if ((mount("AFS", cacheMountDir, MOUNT_AFS, 0, NULL))<0) {
1388 #else
1389 /* This is the standard mount used by the suns and rts */
1390     if ((mount(MOUNT_AFS,cacheMountDir,mountFlags,(caddr_t) 0)) < 0) {
1391 #endif /* AFS_LINUX20_ENV */
1392 #endif /* AFS_SGI_ENV */
1393 #endif /* AFS_SUN5_ENV */
1394 #endif /* AFS_HPUX100_ENV */
1395 #endif /* AFS_HPUX_ENV */
1396 #endif /* AFS_AIX_ENV */
1397 #endif /* AFS_AUX_ENV */
1398 #endif /* AFS_DEC_ENV */
1399          printf("%s: Can't mount AFS on %s(%d)\n",
1400                    rn, cacheMountDir, errno);
1401          exit(1);
1402     }
1403
1404     HandleMTab();
1405
1406     if (afsd_rmtsys) {
1407         if (afsd_verbose)
1408             printf("%s: Forking 'rmtsys' daemon.\n", rn);
1409         code = fork();
1410         if (code == 0) {
1411             /* Child */
1412             rmtsysd();
1413             exit(1);
1414         }
1415     }
1416     /*
1417      * Exit successfully.
1418      */
1419     exit(0);
1420 }
1421
1422 #include "AFS_component_version_number.c"
1423
1424
1425
1426 main(argc, argv)
1427 int argc;
1428 char **argv; {
1429     register struct cmd_syndesc *ts;
1430
1431     ts = cmd_CreateSyntax((char *) 0, mainproc, (char *) 0, "start AFS");
1432     cmd_AddParm(ts, "-blocks", CMD_SINGLE, CMD_OPTIONAL, "1024 byte blocks in cache");
1433     cmd_AddParm(ts, "-files", CMD_SINGLE, CMD_OPTIONAL, "files in cache");
1434     cmd_AddParm(ts, "-rootvol", CMD_SINGLE, CMD_OPTIONAL, "name of AFS root volume");
1435     cmd_AddParm(ts, "-stat", CMD_SINGLE, CMD_OPTIONAL, "number of stat entries");
1436     cmd_AddParm(ts, "-memcache", CMD_FLAG, CMD_OPTIONAL, "run diskless");
1437     cmd_AddParm(ts, "-cachedir", CMD_SINGLE, CMD_OPTIONAL, "cache directory");
1438     cmd_AddParm(ts, "-mountdir", CMD_SINGLE, CMD_OPTIONAL, "mount location");
1439     cmd_AddParm(ts, "-daemons", CMD_SINGLE, CMD_OPTIONAL, "number of daemons to use");
1440     cmd_AddParm(ts, "-nosettime", CMD_FLAG, CMD_OPTIONAL, "don't set the time");
1441     cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, "display lots of information");
1442     cmd_AddParm(ts, "-rmtsys", CMD_FLAG, CMD_OPTIONAL, "start NFS rmtsysd program");
1443     cmd_AddParm(ts, "-debug", CMD_FLAG, CMD_OPTIONAL, "display debug info");
1444     cmd_AddParm(ts, "-chunksize", CMD_SINGLE, CMD_OPTIONAL, "log(2) of chunk size");
1445     cmd_AddParm(ts, "-dcache", CMD_SINGLE, CMD_OPTIONAL, "number of dcache entries");
1446     cmd_AddParm(ts, "-volumes", CMD_SINGLE, CMD_OPTIONAL, "number of volume entries");
1447     cmd_AddParm(ts, "-biods", CMD_SINGLE, CMD_OPTIONAL, "number of bkg I/O daemons (aix vm)");
1448
1449     cmd_AddParm(ts, "-prealloc", CMD_SINGLE, CMD_OPTIONAL, "number of 'small' preallocated blocks");
1450 #ifdef notdef
1451     cmd_AddParm(ts, "-pininodes", CMD_SINGLE, CMD_OPTIONAL, "number of inodes to hog"); 
1452 #endif
1453     cmd_AddParm(ts, "-confdir", CMD_SINGLE, CMD_OPTIONAL, "configuration directory");
1454     cmd_AddParm(ts, "-logfile", CMD_SINGLE, CMD_OPTIONAL, "Place to keep the CM log");
1455     cmd_AddParm(ts, "-waitclose", CMD_FLAG, CMD_OPTIONAL, "make close calls synchronous");
1456     cmd_AddParm(ts, "-shutdown", CMD_FLAG, CMD_OPTIONAL, "Shutdown all afs state");
1457     cmd_AddParm(ts, "-enable_peer_stats", CMD_FLAG, CMD_OPTIONAL|CMD_HIDE, "Collect rpc statistics by peer");
1458     cmd_AddParm(ts, "-enable_process_stats", CMD_FLAG, CMD_OPTIONAL|CMD_HIDE, "Collect rpc statistics for this process");
1459     cmd_AddParm(ts, "-mem_alloc_sleep", CMD_FLAG, (CMD_OPTIONAL | CMD_HIDE), "Allow sleeps when allocating memory cache");
1460     return (cmd_Dispatch(argc, argv));
1461 }
1462
1463
1464 #ifdef  AFS_HPUX_ENV
1465 #define MOUNTED_TABLE   MNT_MNTTAB
1466 #else
1467 #ifdef  AFS_SUN5_ENV
1468 #define MOUNTED_TABLE   MNTTAB
1469 #else
1470 #define MOUNTED_TABLE   MOUNTED
1471 #endif
1472 #endif
1473
1474 static int HandleMTab() {
1475 #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)
1476     FILE *tfilep;
1477 #ifdef  AFS_SUN5_ENV
1478     char tbuf[16];
1479     struct mnttab tmntent;
1480
1481     memset(&tmntent, '\0', sizeof(struct mnttab));
1482     if (!(tfilep = fopen(MOUNTED_TABLE, "a+"))) {
1483         printf("Can't open %s\n", MOUNTED_TABLE);
1484         perror(MNTTAB);
1485         exit(-1);
1486     }
1487     tmntent.mnt_special = "AFS";
1488     tmntent.mnt_mountp = cacheMountDir;
1489     tmntent.mnt_fstype = "xx";
1490     tmntent.mnt_mntopts = "rw";
1491     sprintf(tbuf, "%ld", (long)time((time_t *)0));
1492     tmntent.mnt_time = tbuf;
1493     putmntent(tfilep, &tmntent);
1494     fclose(tfilep);
1495 #else
1496 #if defined(AFS_SGI_ENV) || defined(AFS_LINUX20_ENV)
1497     struct mntent tmntent;
1498
1499     tfilep = setmntent("/etc/mtab", "a+");
1500     tmntent.mnt_fsname = "AFS";
1501     tmntent.mnt_dir = cacheMountDir;
1502     tmntent.mnt_type = "afs";
1503     tmntent.mnt_opts = "rw";
1504     tmntent.mnt_freq = 1;
1505     tmntent.mnt_passno = 3;
1506     addmntent(tfilep, &tmntent);
1507     endmntent(tfilep);
1508 #else
1509     struct mntent tmntent;
1510
1511     memset(&tmntent, '\0', sizeof(struct mntent));
1512     tfilep = setmntent(MOUNTED_TABLE, "a+");
1513     if (!tfilep) {
1514         printf("Can't open %s for write; Not adding afs entry to it\n",
1515                MOUNTED_TABLE);
1516         return 1;
1517     }
1518     tmntent.mnt_fsname = "AFS";
1519     tmntent.mnt_dir = cacheMountDir;
1520     tmntent.mnt_type = "xx";
1521     tmntent.mnt_opts = "rw";
1522     tmntent.mnt_freq = 1;
1523     tmntent.mnt_passno = 3;
1524 #ifdef  AFS_HPUX_ENV
1525     tmntent.mnt_time = time(0);
1526     tmntent.mnt_cnode = 0;
1527 #endif
1528     addmntent(tfilep, &tmntent);
1529     endmntent(tfilep);
1530 #endif  /* AFS_SGI_ENV */
1531 #endif  /* AFS_SUN5_ENV */
1532 #endif  /* unreasonable systems */
1533     return 0;
1534 }
1535
1536 #if !defined(AFS_SGI_ENV) && !defined(AFS_AIX32_ENV)
1537 call_syscall(param1, param2, param3, param4, param5, param6, param7)
1538 long param1, param2, param3, param4, param5, param6, param7;
1539 {
1540     int error;
1541
1542     error = syscall(AFS_SYSCALL, AFSCALL_CALL, param1, param2, param3, param4, param5, param6, param7);
1543     if (afsd_verbose) printf("SScall(%d, %d)=%d ", AFS_SYSCALL, AFSCALL_CALL, error);
1544     return (error);
1545 }
1546 #else   /* AFS_AIX32_ENV */
1547 #if defined(AFS_SGI_ENV)
1548 call_syscall(call, parm0, parm1, parm2, parm3, parm4)
1549 {
1550
1551         int error;
1552
1553         error = afs_syscall(call, parm0, parm1, parm2, parm3, parm4);
1554         if (afsd_verbose) printf("SScall(%d, %d)=%d ", call, parm0, error);
1555
1556         return error;
1557 }
1558 #else
1559 call_syscall(call, parm0, parm1, parm2, parm3, parm4, parm5, parm6) {
1560
1561     return syscall(AFSCALL_CALL, call, parm0, parm1, parm2, parm3, parm4, parm5, parm6);
1562 }
1563 #endif /* AFS_SGI_ENV */
1564 #endif /* AFS_AIX32_ENV */
1565
1566
1567 #ifdef  AFS_AIX_ENV
1568 /* Special handling for AIX's afs mount operation since they require much more miscl. information before making the vmount(2) syscall */
1569 #include <sys/vfs.h>
1570
1571 #define ROUNDUP(x)  (((x) + 3) & ~3)
1572
1573 aix_vmount() {
1574     struct vmount   *vmountp;
1575     int size, error;
1576
1577     size = sizeof(struct vmount) + ROUNDUP(strlen(cacheMountDir)+1) + 5*4;
1578     /* Malloc the vmount structure */
1579     if ((vmountp = (struct vmount *)malloc(size)) == (struct vmount *)NULL) {
1580          printf("Can't allocate space for the vmount structure (AIX)\n");
1581          exit(1);
1582     }
1583
1584     /* zero out the vmount structure */
1585     memset(vmountp, '\0', size);
1586  
1587     /* transfer info into the vmount structure */
1588     vmountp->vmt_revision = VMT_REVISION;
1589     vmountp->vmt_length = size;
1590     vmountp->vmt_fsid.fsid_dev = 0;
1591     vmountp->vmt_fsid.fsid_type = AFS_MOUNT_AFS;
1592     vmountp->vmt_vfsnumber = 0;
1593     vmountp->vmt_time = 0;/* We'll put the time soon! */
1594     vmountp->vmt_flags = VFS_DEVMOUNT;  /* read/write permission */
1595     vmountp->vmt_gfstype = AFS_MOUNT_AFS;
1596     vmountdata(vmountp, "AFS", cacheMountDir, "", "", "", "rw");
1597     
1598     /* Do the actual mount system call */
1599     error = vmount(vmountp, size);
1600     free(vmountp);
1601     return(error);
1602 }
1603
1604 vmountdata(vmtp, obj, stub, host, hostsname, info, args)
1605 struct vmount   *vmtp;
1606 char    *obj, *stub, *host, *hostsname, *info, *args;
1607 {
1608         register struct data {
1609                                 short   vmt_off;
1610                                 short   vmt_size;
1611                         } *vdp, *vdprev;
1612         register int    size;
1613
1614         vdp = (struct data *)vmtp->vmt_data;
1615         vdp->vmt_off = sizeof(struct vmount);
1616         size = ROUNDUP(strlen(obj) + 1);
1617         vdp->vmt_size = size;
1618         strcpy(vmt2dataptr(vmtp, VMT_OBJECT), obj);
1619
1620         vdprev = vdp;
1621         vdp++;
1622         vdp->vmt_off =  vdprev->vmt_off + size;
1623         size = ROUNDUP(strlen(stub) + 1);
1624         vdp->vmt_size = size;
1625         strcpy(vmt2dataptr(vmtp, VMT_STUB), stub);
1626
1627         vdprev = vdp;
1628         vdp++;
1629         vdp->vmt_off = vdprev->vmt_off + size;
1630         size = ROUNDUP(strlen(host) + 1);
1631         vdp->vmt_size = size;
1632         strcpy(vmt2dataptr(vmtp, VMT_HOST), host);
1633
1634         vdprev = vdp;
1635         vdp++;
1636         vdp->vmt_off = vdprev->vmt_off + size;
1637         size = ROUNDUP(strlen(hostsname) + 1);
1638         vdp->vmt_size = size;
1639         strcpy(vmt2dataptr(vmtp, VMT_HOSTNAME), hostsname);
1640
1641
1642         vdprev = vdp;
1643         vdp++;
1644         vdp->vmt_off =  vdprev->vmt_off + size;
1645         size = ROUNDUP(strlen(info) + 1);
1646         vdp->vmt_size = size;
1647         strcpy(vmt2dataptr(vmtp, VMT_INFO), info);
1648
1649         vdprev = vdp;
1650         vdp++;
1651         vdp->vmt_off =  vdprev->vmt_off + size;
1652         size = ROUNDUP(strlen(args) + 1);
1653         vdp->vmt_size = size;
1654         strcpy(vmt2dataptr(vmtp, VMT_ARGS), args);
1655 }
1656 #endif /* AFS_AIX_ENV */
1657
1658 #ifdef  AFS_SGI53_ENV
1659 #ifdef AFS_SGI61_ENV
1660 /* The dwarf structures are searched to find entry points of static functions
1661  * and the addresses of static variables. The file name as well as the
1662  * sybmol name is reaquired.
1663  */
1664
1665 /* Contains list of names to find in given file. */
1666 typedef struct {
1667     char *name;         /* Name of variable or function. */
1668     afs_hyper_t addr;   /* Address of function, undefined if not found. */
1669     Dwarf_Half type; /* DW_AT_location for vars, DW_AT_lowpc for func's */
1670     char found;         /* set if found. */
1671 } staticAddrList;
1672
1673 typedef struct  {
1674     char *file;                 /* Name of file containing vars or funcs */
1675     staticAddrList *addrList;   /* List of vars and/or funcs. */
1676     int nAddrs;                 /* # of addrList's */
1677     int found;                  /* set if we've found this file already. */
1678 } staticNameList;
1679
1680 /* routines used to find addresses in /unix */
1681 #if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
1682 void findMDebugStaticAddresses(staticNameList *, int, int);
1683 #endif
1684 void findDwarfStaticAddresses(staticNameList *, int);
1685 void findElfAddresses(Dwarf_Debug, Dwarf_Die, staticNameList *);
1686 void getElfAddress(Dwarf_Debug, Dwarf_Die, staticAddrList *);
1687
1688 #if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
1689 #define AFS_N_FILELISTS 2
1690 #define AFS_SYMS_NEEDED 3
1691 #else /* AFS_SGI62_ENV */
1692 #define AFS_N_FILELISTS 1
1693 #endif /* AFS_SGI62_ENV */
1694
1695
1696
1697 void set_staticaddrs(void)
1698 {
1699     staticNameList fileList[AFS_N_FILELISTS];
1700
1701     fileList[0].addrList = (staticAddrList*)calloc(1, sizeof(staticAddrList));
1702     if (!fileList[0].addrList) {
1703         printf("set_staticaddrs: Can't calloc fileList[0].addrList\n");
1704         return;
1705     }
1706     fileList[0].file = "nfs_server.c";
1707     fileList[0].found = 0;
1708     fileList[0].nAddrs = 1;
1709     fileList[0].addrList[0].name = "rfsdisptab_v2";
1710     fileList[0].addrList[0].type = DW_AT_location;
1711     fileList[0].addrList[0].found = 0;
1712
1713 #if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
1714     fileList[1].addrList = (staticAddrList*)calloc(2, sizeof(staticAddrList));
1715     if (!fileList[1].addrList) {
1716         printf("set_staticaddrs: Can't malloc fileList[1].addrList\n");
1717         return;
1718     }
1719     fileList[1].file = "uipc_socket.c";
1720     fileList[1].found = 0;
1721     fileList[1].nAddrs = 2;
1722     fileList[1].addrList[0].name = "sblock";
1723     fileList[1].addrList[0].type = DW_AT_low_pc;
1724     fileList[1].addrList[0].found = 0;
1725     fileList[1].addrList[1].name = "sbunlock";
1726     fileList[1].addrList[1].type = DW_AT_low_pc;
1727     fileList[1].addrList[1].found = 0;
1728
1729     if (64 != sysconf(_SC_KERN_POINTERS))
1730         findMDebugStaticAddresses(fileList, AFS_N_FILELISTS, AFS_SYMS_NEEDED);
1731     else
1732 #endif /* AFS_SGI62_ENV */
1733         findDwarfStaticAddresses(fileList, AFS_N_FILELISTS);
1734
1735     if (fileList[0].addrList[0].found) {
1736         call_syscall(AFSOP_NFSSTATICADDR2, fileList[0].addrList[0].addr.high,
1737                      fileList[0].addrList[0].addr.low);
1738     }
1739     else {
1740         if (afsd_verbose)
1741             printf("NFS V2 is not present in the kernel.\n");
1742     }
1743     free(fileList[0].addrList);
1744 #if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
1745     if (fileList[1].addrList[0].found && fileList[1].addrList[1].found) {
1746         call_syscall(AFSOP_SBLOCKSTATICADDR2,
1747                      fileList[1].addrList[0].addr.high,
1748                      fileList[1].addrList[0].addr.low,
1749                      fileList[1].addrList[1].addr.high,
1750                      fileList[1].addrList[1].addr.low);
1751     }
1752     else {
1753         if (!fileList[1].addrList[0].found)
1754             printf("Can't find %s in kernel. Exiting.\n",
1755                    fileList[1].addrList[0].name);
1756         if (!fileList[1].addrList[0].found)
1757             printf("Can't find %s in kernel. Exiting.\n",
1758                    fileList[1].addrList[1].name);
1759         exit(1);
1760     }
1761     free(fileList[1].addrList);
1762 #endif /* AFS_SGI62_ENV */
1763 }
1764
1765
1766 /* Find addresses for static variables and functions. */
1767 void
1768 findDwarfStaticAddresses(staticNameList * nameList, int nLists)
1769 {
1770     int fd;
1771     int i;
1772     int found = 0;
1773     int code;
1774     char *s;
1775     char *hname = (char*)0;
1776     Dwarf_Unsigned dwarf_access = O_RDONLY;
1777     Dwarf_Debug dwarf_debug;
1778     Dwarf_Error dwarf_error;
1779     Dwarf_Unsigned dwarf_cu_header_length;
1780     Dwarf_Unsigned dwarf_abbrev_offset;
1781     Dwarf_Half dwarf_address_size;
1782     Dwarf_Unsigned next_cu_header;
1783     Dwarf_Die dwarf_die;
1784     Dwarf_Die dwarf_next_die;
1785     Dwarf_Die dwarf_child_die;
1786
1787     if (elf_version(EV_CURRENT) == EV_NONE) {
1788         printf("findDwarfStaticAddresses: Bad elf version.\n");
1789         return;
1790     }
1791
1792     if ((fd=open("/unix", O_RDONLY,0))<0) {
1793         printf("findDwarfStaticAddresses: Failed to open /unix.\n");
1794         return;
1795     }
1796     code = dwarf_init(fd, dwarf_access, NULL, NULL, &dwarf_debug,
1797                       &dwarf_error);
1798     if (code != DW_DLV_OK) {
1799         /* Nope hope for the elves and dwarves, try intermediate code. */
1800         close(fd);
1801         return;
1802     }
1803
1804     found = 0;
1805     while (1) {
1806         /* Run through the headers until we find ones for files we've
1807          * specified in nameList.
1808          */
1809         code = dwarf_next_cu_header(dwarf_debug,
1810                                     &dwarf_cu_header_length, NULL,
1811                                     &dwarf_abbrev_offset,
1812                                     &dwarf_address_size,
1813                                     &next_cu_header,
1814                                     &dwarf_error);
1815         if (code == DW_DLV_NO_ENTRY) {
1816             break;
1817         }
1818         else if (code == DW_DLV_ERROR) {
1819             printf("findDwarfStaticAddresses: Error reading headers: %s\n",
1820                    dwarf_errmsg(dwarf_error));
1821             break;
1822         }
1823
1824         code = dwarf_siblingof(dwarf_debug, NULL, &dwarf_die, &dwarf_error);
1825         if (code != DW_DLV_OK) {
1826             printf("findDwarfStaticAddresses: Can't get first die. %s\n",
1827                    (code == DW_DLV_ERROR) ? dwarf_errmsg(dwarf_error) : "");
1828             break;
1829         }
1830
1831         /* This is the header, test the name. */
1832         code = dwarf_diename(dwarf_die, &hname, &dwarf_error);
1833         if (code == DW_DLV_OK) {
1834             s = strrchr(hname, '/');
1835             for (i=0; i<nLists; i++) {
1836                 if (s && !strcmp(s+1, nameList[i].file)) {
1837                     findElfAddresses(dwarf_debug, dwarf_die, &nameList[i]);
1838                     found ++;
1839                     break;
1840                 }
1841             }
1842         }
1843         else {
1844             printf("findDwarfStaticAddresses: Can't get name of current header. %s\n",
1845                    (code == DW_DLV_ERROR) ? dwarf_errmsg(dwarf_error) : "");
1846             break;
1847         }
1848         dwarf_dealloc(dwarf_debug, hname, DW_DLA_STRING);
1849         hname = (char*)0;
1850         if (found >= nLists) { /* we're done */
1851             break;
1852         }
1853     }
1854
1855      /* Frees up all allocated space. */
1856     (void) dwarf_finish(dwarf_debug, &dwarf_error);
1857     close(fd);
1858 }
1859
1860 void
1861 findElfAddresses(Dwarf_Debug dwarf_debug, Dwarf_Die dwarf_die,
1862                  staticNameList * nameList)
1863 {
1864     int i;
1865     Dwarf_Error dwarf_error;
1866     Dwarf_Die dwarf_next_die;
1867     Dwarf_Die dwarf_child_die;
1868     Dwarf_Attribute dwarf_return_attr;
1869     char *vname = (char*)0;
1870     int found = 0;
1871     int code;
1872     
1873     /* Drop into this die to find names in addrList. */
1874     code = dwarf_child(dwarf_die, &dwarf_child_die, &dwarf_error);
1875     if (code != DW_DLV_OK) {
1876         printf("findElfAddresses: Can't get child die. %s\n",
1877                (code == DW_DLV_ERROR) ? dwarf_errmsg(dwarf_error) : "");
1878         return;
1879     }
1880
1881     /* Try to find names in each sibling. */
1882     dwarf_next_die = (Dwarf_Die)0;
1883     do {
1884         code = dwarf_diename(dwarf_child_die, &vname,
1885                              &dwarf_error);
1886         /* It's possible that some siblings don't have names. */
1887         if (code == DW_DLV_OK) {
1888             for (i=0; i<nameList->nAddrs; i++) {
1889                 if (!nameList->addrList[i].found) {
1890                     if (!strcmp(vname, nameList->addrList[i].name)) {
1891                         getElfAddress(dwarf_debug, dwarf_child_die,
1892                                           &(nameList->addrList[i]));
1893                         found ++;
1894                         break;
1895                     }
1896                 }
1897             }
1898         }
1899         if (dwarf_next_die)
1900             dwarf_dealloc(dwarf_debug, dwarf_next_die, DW_DLA_DIE);
1901
1902         if (found >= nameList->nAddrs) { /* we're done. */
1903             break;
1904         }
1905
1906         dwarf_next_die = dwarf_child_die;
1907         code = dwarf_siblingof(dwarf_debug, dwarf_next_die,
1908                                &dwarf_child_die,
1909                                &dwarf_error);
1910      
1911     } while(code == DW_DLV_OK);
1912 }
1913
1914 /* Get address out of current die. */
1915 void
1916 getElfAddress(Dwarf_Debug dwarf_debug,
1917               Dwarf_Die dwarf_child_die, staticAddrList *addrList)
1918 {
1919     int i;
1920     Dwarf_Error dwarf_error;
1921     Dwarf_Attribute dwarf_return_attr;
1922     Dwarf_Bool dwarf_return_bool;
1923     Dwarf_Locdesc *llbuf = NULL;
1924     Dwarf_Signed listlen;
1925     off64_t addr = (off64_t)0;
1926     int code;
1927
1928     code = dwarf_hasattr(dwarf_child_die, addrList->type,
1929                          &dwarf_return_bool, &dwarf_error);
1930     if ((code !=  DW_DLV_OK) || (!dwarf_return_bool)) {
1931         printf("getElfAddress: no address given for %s. %s\n",
1932                addrList->name, (code == DW_DLV_ERROR) ? dwarf_errmsg(dwarf_error) : "");
1933         return;
1934     }
1935     code = dwarf_attr(dwarf_child_die, addrList->type,
1936                       &dwarf_return_attr,  &dwarf_error);
1937     if (code !=  DW_DLV_OK) {
1938         printf("getElfAddress: Can't get attribute. %s\n",
1939                (code == DW_DLV_ERROR) ? dwarf_errmsg(dwarf_error) : "");
1940         return;
1941     }
1942
1943     switch (addrList->type) {
1944     case DW_AT_location:
1945         code = dwarf_loclist(dwarf_return_attr, &llbuf,
1946                              &listlen, &dwarf_error);
1947         if (code !=   DW_DLV_OK) {
1948             printf("getElfAddress: Can't get location for %s. %s\n",
1949                    addrList->name,
1950                    (code == DW_DLV_ERROR) ? dwarf_errmsg(dwarf_error) : "");
1951             return;
1952         }
1953         if ((listlen != 1) || (llbuf[0].ld_cents != 1)) {
1954             printf("getElfAddress: %s has more than one address.\n",
1955                    addrList->name);
1956             return;
1957         }
1958         addr = llbuf[0].ld_s[0].lr_number;
1959         break;
1960
1961     case DW_AT_low_pc:
1962         code = dwarf_lowpc(dwarf_child_die, (Dwarf_Addr*)&addr, &dwarf_error);
1963         if ( code !=  DW_DLV_OK) {
1964             printf("getElfAddress: Can't get lowpc for %s. %s\n",
1965                    addrList->name,
1966                    (code == DW_DLV_ERROR) ? dwarf_errmsg(dwarf_error) : "");
1967             return;
1968         }
1969         break;
1970         
1971     default:
1972         printf("getElfAddress: Bad case %d in switch.\n", addrList->type);
1973         return;
1974     }
1975
1976     addrList->addr.high = (addr>>32) & 0xffffffff;
1977     addrList->addr.low  = addr & 0xffffffff;
1978     addrList->found = 1;
1979 }
1980
1981 #if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
1982 /* Find symbols in the .mdebug section for 32 bit kernels. */
1983 /*
1984  * do_mdebug()
1985  * On 32bit platforms, we're still using the ucode compilers to build
1986  * the kernel, so we need to get our static text/data from the .mdebug
1987  * section instead of the .dwarf sections.
1988  */
1989 /* SearchNameList searches our bizarre structs for the given string.
1990  * If found, sets the found bit and the address and returns 1.
1991  * Not found returns 0.
1992  */
1993 int SearchNameList(char *name, afs_uint32 addr, staticNameList *nameList,
1994                    int nLists)
1995 {
1996     int i, j;                   
1997     for (i=0; i<nLists; i++) {
1998         for (j=0; j<nameList[i].nAddrs; j++) {
1999             if (nameList[i].addrList[j].found)
2000                 continue;
2001             if (!strcmp(name, nameList[i].addrList[j].name)) {
2002                 nameList[i].addrList[j].addr.high = 0;
2003                 nameList[i].addrList[j].addr.low = addr;
2004                 nameList[i].addrList[j].found = 1;
2005                 return 1;
2006             }
2007         }
2008     }
2009     return 0;
2010 }
2011                                         
2012 static void
2013 SearchMDebug(Elf_Scn *scnp, Elf32_Shdr *shdrp, staticNameList * nameList,
2014              int nLists, int needed)
2015 {
2016     long *buf = (long *)(elf_getdata(scnp, NULL)->d_buf); 
2017     u_long addr, mdoff = shdrp->sh_offset;
2018     HDRR *hdrp;
2019     SYMR *symbase, *symp, *symend;
2020     FDR *fdrbase, *fdrp;
2021     int i, j;
2022     char *strbase, *str;
2023     int ifd;
2024     int nFound = 0;
2025     
2026     /* get header */
2027     addr = (__psunsigned_t)buf;
2028     hdrp = (HDRR *)addr;
2029     
2030     /* setup base addresses */
2031     addr = (u_long)buf + (u_long)(hdrp->cbFdOffset - mdoff);
2032     fdrbase = (FDR *)addr;
2033     addr = (u_long)buf + (u_long)(hdrp->cbSymOffset - mdoff);
2034     symbase = (SYMR *)addr;
2035     addr = (u_long)buf + (u_long)(hdrp->cbSsOffset - mdoff);
2036     strbase = (char *)addr;
2037     
2038 #define KEEPER(a,b)     ((a == stStaticProc && b == scText) || \
2039                          (a == stStatic && (b == scData || b == scBss || \
2040                                             b == scSBss || b == scSData)))
2041         
2042     for (fdrp = fdrbase; fdrp < &fdrbase[hdrp->ifdMax]; fdrp++) {
2043         str = strbase + fdrp->issBase + fdrp->rss;
2044         
2045         /* local symbols for each fd */
2046         for (symp = &symbase[fdrp->isymBase];
2047              symp < &symbase[fdrp->isymBase+fdrp->csym];
2048              symp++) {
2049             if (KEEPER(symp->st, symp->sc)) {
2050                 if (symp->value == 0)
2051                     continue;
2052                 
2053                 str = strbase + fdrp->issBase + symp->iss;
2054                 /* Look for AFS symbols of interest */
2055                 if (SearchNameList(str, symp->value,
2056                                    nameList, nLists)) {
2057                     nFound ++;
2058                     if (nFound >= needed)
2059                         return;
2060                 }
2061             }
2062         }
2063     }
2064 }
2065     
2066 /*
2067  * returns section with the name of scn_name, & puts its header in shdr64 or
2068  * shdr32 based on elf's file type
2069  *
2070  */
2071 Elf_Scn *
2072 findMDebugSection(Elf *elf, char *scn_name)
2073 {
2074         Elf64_Ehdr *ehdr64;
2075         Elf32_Ehdr *ehdr32;
2076         Elf_Scn *scn = NULL;
2077         Elf64_Shdr *shdr64;
2078         Elf32_Shdr *shdr32;
2079
2080         if ((ehdr32 = elf32_getehdr(elf)) == NULL)
2081                 return(NULL);
2082         do {
2083                 if ((scn = elf_nextscn(elf, scn)) == NULL)
2084                         break;
2085                 if ((shdr32 = elf32_getshdr(scn)) == NULL)
2086                         return(NULL);
2087         } while (strcmp(scn_name, elf_strptr(elf, ehdr32->e_shstrndx,
2088                                                   shdr32->sh_name)));
2089
2090         return(scn);    
2091 }
2092
2093
2094 void findMDebugStaticAddresses(staticNameList * nameList, int nLists,
2095                                int needed)
2096 {
2097     int fd;
2098     Elf *elf;
2099     Elf_Scn *mdebug_scn;
2100     Elf32_Shdr *mdebug_shdr;
2101     char *names;
2102
2103     if ((fd = open("/unix", O_RDONLY)) == -1) {
2104         printf("findMDebugStaticAddresses: Failed to open /unix.\n");
2105         return;
2106     }
2107
2108     (void)elf_version(EV_CURRENT);
2109     if((elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
2110         printf("findMDebugStaticAddresses: /unix doesn't seem to be an elf file\n");
2111         close(fd);
2112         return;
2113     }
2114     mdebug_scn = findMDebugSection(elf, ".mdebug");
2115     if (!mdebug_scn) {
2116         printf("findMDebugStaticAddresses: Can't find .mdebug section.\n");
2117         goto find_end;
2118     }
2119     mdebug_shdr = elf32_getshdr(mdebug_scn);
2120     if (!mdebug_shdr) {
2121         printf("findMDebugStaticAddresses: Can't find .mdebug header.\n");
2122         goto find_end;
2123     }
2124
2125     (void) SearchMDebug(mdebug_scn, mdebug_shdr, nameList, nLists, needed);
2126
2127  find_end:
2128     elf_end(elf);
2129     close(fd);
2130 }
2131 #endif /* AFS_SGI62_ENV */
2132
2133 #else /* AFS_SGI61_ENV */
2134 #include <nlist.h>
2135 struct  nlist nlunix[] = {
2136    { "rfsdisptab_v2" },
2137    { 0 },
2138 };
2139
2140 get_nfsstaticaddr() {
2141     int i, j, kmem, count;
2142
2143     if ((kmem = open("/dev/kmem", O_RDONLY)) < 0) {
2144         printf("Warning: can't open /dev/kmem\n");
2145         return 0;
2146     }
2147     if ((j = nlist("/unix", nlunix)) < 0) {
2148         printf("Warning: can't nlist /unix\n");
2149         return 0;
2150     }
2151     i = nlunix[0].n_value;
2152     if (lseek(kmem, i, L_SET/*0*/) != i) {
2153         printf("Warning: can't lseek to %x\n", i);      
2154         return 0;
2155     }
2156     if ((j = read(kmem, &count, sizeof count)) != sizeof count) {
2157         printf("WARNING: kmem read at %x failed\n", i);
2158         return 0;
2159     }
2160     return i;
2161 }
2162 #endif /* AFS_SGI61_ENV */
2163 #endif /* AFS_SGI53_ENV */