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