src/afsd/afsd.c

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