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