src/afs/afs_call.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 #include <afsconfig.h>
  11 #include "afs/param.h"
  12
  13 #if defined(HAVE_LINUX_KTHREAD_RUN) && !defined(UKERNEL)
  14 #  include "h/kthread.h"
  15 #endif
  16
  17 #include "afs/sysincludes.h"    /* Standard vendor system headers */
  18 #include "afsincludes.h"        /* Afs-based standard headers */
  19 #include "afs/afs_stats.h"
  20 #include "rx/rx_globals.h"
  21 #if !defined(UKERNEL)
  22 # if !defined(AFS_LINUX20_ENV)
  23 #  include "net/if.h"
  24 #  ifdef AFS_SGI62_ENV
  25 #   include "h/hashing.h"
  26 #  endif
  27 #  if !defined(AFS_HPUX110_ENV) && !defined(AFS_DARWIN_ENV)
  28 #   include "netinet/in_var.h"
  29 #  endif
  30 # endif
  31 #endif /* !defined(UKERNEL) */
  32 #ifdef AFS_SUN510_ENV
  33 #include "h/ksynch.h"
  34 #include "h/sunddi.h"
  35 #endif
  36 #include <hcrypto/rand.h>
  37
  38 #if defined(AFS_SUN5_ENV) || defined(AFS_AIX_ENV) || defined(AFS_SGI_ENV) || defined(AFS_HPUX_ENV)
  39 #define AFS_MINBUFFERS  100
  40 #else
  41 #define AFS_MINBUFFERS  50
  42 #endif
  43
  44 #if (defined(AFS_SUN5_ENV) || defined(AFS_LINUX26_ENV) || defined(AFS_DARWIN80_ENV)) && !defined(UKERNEL)
  45 /* If AFS_DAEMONOP_ENV is defined, it indicates we run "daemon" AFS syscalls by
  46  * spawning a kernel thread to do the work, instead of running them in the
  47  * calling process. */
  48 # define AFS_DAEMONOP_ENV
  49 #endif
  50
  51 struct afsop_cell {
  52     afs_int32 hosts[AFS_MAXCELLHOSTS];
  53     char cellName[100];
  54 };
  55
  56 char afs_zeros[AFS_ZEROS];
  57 char afs_rootVolumeName[64] = "";
  58 afs_uint32 rx_bindhost;
  59
  60 #ifdef AFS_SUN510_ENV
  61 ddi_taskq_t *afs_taskq;
  62 krwlock_t afsifinfo_lock;
  63 #endif
  64
  65 afs_int32 afs_initState = 0;
  66 afs_int32 afs_termState = 0;
  67 int afs_cold_shutdown = 0;
  68 char afs_SynchronousCloses = '\0';
  69 static int afs_CB_Running = 0;
  70 static int AFS_Running = 0;
  71 static int afs_CacheInit_Done = 0;
  72 static int afs_Go_Done = 0;
  73 extern struct interfaceAddr afs_cb_interface;
  74 #ifdef RXK_LISTENER_ENV
  75 static int afs_RX_Running = 0;
  76 #endif
  77 static int afs_InitSetup_done = 0;
  78 afs_int32 afs_numcachefiles = -1;
  79 afs_int32 afs_numfilesperdir = -1;
  80 char afs_cachebasedir[1024];
  81 afs_int32 afs_rmtsys_enable = 0;
  82
  83 afs_int32 afs_rx_deadtime = AFS_RXDEADTIME;
  84 afs_int32 afs_rx_harddead = AFS_HARDDEADTIME;
  85 afs_int32 afs_rx_idledead = AFS_IDLEDEADTIME;
  86 afs_int32 afs_rx_idledead_rep = AFS_IDLEDEADTIME_REP;
  87
  88 static int afscall_set_rxpck_received = 0;
  89
  90 /* This is code which needs to be called once when the first daemon enters
  91  * the client. A non-zero return means an error and AFS should not start.
  92  */
  93 static int
  94 afs_InitSetup(int preallocs)
  95 {
  96     int code;
  97
  98     if (afs_InitSetup_done)
  99         return EAGAIN;
 100
 101 #ifdef AFS_SUN510_ENV
 102     /* Initialize a RW lock for the ifinfo global array */
 103     rw_init(&afsifinfo_lock, NULL, RW_DRIVER, NULL);
 104
 105     /* Create a taskq */
 106     afs_taskq = ddi_taskq_create(NULL, "afs_taskq", 2, TASKQ_DEFAULTPRI, 0);
 107
 108     osi_StartNetIfPoller();
 109 #endif
 110
 111 #ifndef AFS_NOSTATS
 112     /*
 113      * Set up all the AFS statistics variables.  This should be done
 114      * exactly once, and it should be done here, the first resource-setting
 115      * routine to be called by the CM/RX.
 116      */
 117     afs_InitStats();
 118 #endif /* AFS_NOSTATS */
 119
 120     memset(afs_zeros, 0, AFS_ZEROS);
 121
 122     /* start RX */
 123     if(!afscall_set_rxpck_received)
 124     rx_extraPackets = AFS_NRXPACKETS;   /* smaller # of packets */
 125     code = rx_InitHost(rx_bindhost, htons(7001));
 126     if (code) {
 127         afs_warn("AFS: RX failed to initialize %d).\n", code);
 128         return code;
 129     }
 130     rx_SetRxDeadTime(afs_rx_deadtime);
 131     /* resource init creates the services */
 132     afs_ResourceInit(preallocs);
 133
 134     afs_InitSetup_done = 1;
 135     afs_osi_Wakeup(&afs_InitSetup_done);
 136
 137     return code;
 138 }
 139
 140 #ifdef AFS_DAEMONOP_ENV
 141 static int
 142 daemonOp_common(long parm, long parm2, long parm3, long parm4, long parm5,
 143                 long parm6)
 144 {
 145     int code;
 146     if (parm == AFSOP_START_RXCALLBACK) {
 147         if (afs_CB_Running)
 148             return -1;
 149 # ifdef RXK_LISTENER_ENV
 150     } else if (parm == AFSOP_RXLISTENER_DAEMON) {
 151         if (afs_RX_Running)
 152             return -1;
 153         afs_RX_Running = 1;
 154 # endif
 155         code = afs_InitSetup(parm2);
 156         if (parm3) {
 157             rx_enablePeerRPCStats();
 158         }
 159         if (parm4) {
 160             rx_enableProcessRPCStats();
 161         }
 162         if (code)
 163             return -1;
 164     } else if (parm == AFSOP_START_AFS) {
 165         if (AFS_Running)
 166             return -1;
 167     }                           /* other functions don't need setup in the parent */
 168     return 0;
 169 }
 170 #endif /* AFS_DAEMONOP_ENV */
 171
 172 #if defined(AFS_DARWIN80_ENV)
 173 struct afsd_thread_info {
 174     unsigned long parm;
 175 };
 176 static int
 177 afsd_thread(int *rock)
 178 {
 179     struct afsd_thread_info *arg = (struct afsd_thread_info *)rock;
 180     unsigned long parm = arg->parm;
 181
 182     switch (parm) {
 183     case AFSOP_START_RXCALLBACK:
 184         AFS_GLOCK();
 185         wakeup(arg);
 186         afs_CB_Running = 1;
 187 #ifndef RXK_LISTENER_ENV
 188         afs_initState = AFSOP_START_AFS;
 189         afs_osi_Wakeup(&afs_initState);
 190 #else
 191         while (afs_RX_Running != 2)
 192             afs_osi_Sleep(&afs_RX_Running);
 193 #endif
 194         afs_RXCallBackServer();
 195         AFS_GUNLOCK();
 196         thread_terminate(current_thread());
 197         break;
 198     case AFSOP_START_AFS:
 199         AFS_GLOCK();
 200         wakeup(arg);
 201         AFS_Running = 1;
 202         while (afs_initState < AFSOP_START_AFS)
 203             afs_osi_Sleep(&afs_initState);
 204         afs_initState = AFSOP_START_BKG;
 205         afs_osi_Wakeup(&afs_initState);
 206         afs_Daemon();
 207         AFS_GUNLOCK();
 208         thread_terminate(current_thread());
 209         break;
 210     case AFSOP_START_BKG:
 211         afs_warn("Install matching afsd! Old background daemons not supported.\n");
 212         thread_terminate(current_thread());
 213         break;
 214     case AFSOP_START_TRUNCDAEMON:
 215         AFS_GLOCK();
 216         wakeup(arg);
 217         while (afs_initState < AFSOP_GO)
 218             afs_osi_Sleep(&afs_initState);
 219         afs_CacheTruncateDaemon();
 220         AFS_GUNLOCK();
 221         thread_terminate(current_thread());
 222         break;
 223     case AFSOP_START_CS:
 224         AFS_GLOCK();
 225         wakeup(arg);
 226         afs_CheckServerDaemon();
 227         AFS_GUNLOCK();
 228         thread_terminate(current_thread());
 229         break;
 230     case AFSOP_RXEVENT_DAEMON:
 231         AFS_GLOCK();
 232         wakeup(arg);
 233         while (afs_initState < AFSOP_START_BKG)
 234             afs_osi_Sleep(&afs_initState);
 235         afs_rxevent_daemon();
 236         AFS_GUNLOCK();
 237         thread_terminate(current_thread());
 238         break;
 239 #ifdef RXK_LISTENER_ENV
 240     case AFSOP_RXLISTENER_DAEMON:
 241         AFS_GLOCK();
 242         wakeup(arg);
 243         afs_initState = AFSOP_START_AFS;
 244         afs_osi_Wakeup(&afs_initState);
 245         afs_RX_Running = 2;
 246         afs_osi_Wakeup(&afs_RX_Running);
 247         afs_osi_RxkRegister();
 248         rxk_Listener();
 249         AFS_GUNLOCK();
 250         thread_terminate(current_thread());
 251         break;
 252 #endif
 253     default:
 254         afs_warn("Unknown op %ld in StartDaemon()\n", (long)parm);
 255         break;
 256     }
 257 }
 258
 259 void
 260 afs_DaemonOp(long parm, long parm2, long parm3, long parm4, long parm5,
 261              long parm6)
 262 {
 263     struct afsd_thread_info info;
 264     thread_t thread;
 265     if (daemonOp_common(parm, parm2, parm3, parm4, parm5, parm6)) {
 266         return;
 267     }
 268     info.parm = parm;
 269     kernel_thread_start((thread_continue_t)afsd_thread, &info, &thread);
 270     AFS_GUNLOCK();
 271     /* we need to wait cause we passed stack pointers around.... */
 272     msleep(&info, NULL, PVFS, "afs_DaemonOp", NULL);
 273     AFS_GLOCK();
 274     thread_deallocate(thread);
 275 }
 276 #endif
 277
 278
 279 #if defined(AFS_LINUX26_ENV)
 280 struct afsd_thread_info {
 281 # if !defined(INIT_WORK_HAS_DATA)
 282     struct work_struct tq;
 283 # endif
 284     unsigned long parm;
 285     struct completion *complete;
 286 };
 287
 288 static int
 289 afsd_thread(void *rock)
 290 {
 291     struct afsd_thread_info *arg = rock;
 292     unsigned long parm = arg->parm;
 293 # ifdef SYS_SETPRIORITY_EXPORTED
 294     int (*sys_setpriority) (int, int, int) = sys_call_table[__NR_setpriority];
 295 # endif
 296 # if !defined(HAVE_LINUX_KTHREAD_RUN)
 297 #  if defined(AFS_LINUX26_ENV)
 298     daemonize("afsd");
 299 #  else
 300     daemonize();
 301 #  endif
 302 # endif /* !HAVE_LINUX_KTHREAD_RUN */
 303                                 /* doesn't do much, since we were forked from keventd, but
 304                                  * does call mm_release, which wakes up our parent (since it
 305                                  * used CLONE_VFORK) */
 306 # if !defined(AFS_LINUX26_ENV)
 307     reparent_to_init();
 308 # endif
 309     afs_osi_MaskSignals();
 310     switch (parm) {
 311     case AFSOP_START_RXCALLBACK:
 312         sprintf(current->comm, "afs_cbstart");
 313         AFS_GLOCK();
 314         complete(arg->complete);
 315         afs_CB_Running = 1;
 316 #if !defined(RXK_LISTENER_ENV)
 317         afs_initState = AFSOP_START_AFS;
 318         afs_osi_Wakeup(&afs_initState);
 319 #else
 320         while (afs_RX_Running != 2)
 321             afs_osi_Sleep(&afs_RX_Running);
 322 #endif
 323         sprintf(current->comm, "afs_callback");
 324         afs_RXCallBackServer();
 325         AFS_GUNLOCK();
 326         complete_and_exit(0, 0);
 327         break;
 328     case AFSOP_START_AFS:
 329         sprintf(current->comm, "afs_afsstart");
 330         AFS_GLOCK();
 331         complete(arg->complete);
 332         AFS_Running = 1;
 333         while (afs_initState < AFSOP_START_AFS)
 334             afs_osi_Sleep(&afs_initState);
 335         afs_initState = AFSOP_START_BKG;
 336         afs_osi_Wakeup(&afs_initState);
 337         sprintf(current->comm, "afsd");
 338         afs_Daemon();
 339         AFS_GUNLOCK();
 340         complete_and_exit(0, 0);
 341         break;
 342     case AFSOP_START_BKG:
 343 #ifdef AFS_NEW_BKG
 344         afs_warn("Install matching afsd! Old background daemons not supported.\n");
 345 #else
 346         sprintf(current->comm, "afs_bkgstart");
 347         AFS_GLOCK();
 348         complete(arg->complete);
 349         while (afs_initState < AFSOP_START_BKG)
 350             afs_osi_Sleep(&afs_initState);
 351         if (afs_initState < AFSOP_GO) {
 352             afs_initState = AFSOP_GO;
 353             afs_osi_Wakeup(&afs_initState);
 354         }
 355         sprintf(current->comm, "afs_background");
 356         afs_BackgroundDaemon();
 357         AFS_GUNLOCK();
 358 #endif
 359         complete_and_exit(0, 0);
 360         break;
 361     case AFSOP_START_TRUNCDAEMON:
 362         sprintf(current->comm, "afs_trimstart");
 363         AFS_GLOCK();
 364         complete(arg->complete);
 365         while (afs_initState < AFSOP_GO)
 366             afs_osi_Sleep(&afs_initState);
 367         sprintf(current->comm, "afs_cachetrim");
 368         afs_CacheTruncateDaemon();
 369         AFS_GUNLOCK();
 370         complete_and_exit(0, 0);
 371         break;
 372     case AFSOP_START_CS:
 373         sprintf(current->comm, "afs_checkserver");
 374         AFS_GLOCK();
 375         complete(arg->complete);
 376         afs_CheckServerDaemon();
 377         AFS_GUNLOCK();
 378         complete_and_exit(0, 0);
 379         break;
 380     case AFSOP_RXEVENT_DAEMON:
 381         sprintf(current->comm, "afs_evtstart");
 382 # ifdef SYS_SETPRIORITY_EXPORTED
 383         sys_setpriority(PRIO_PROCESS, 0, -10);
 384 # else
 385 #  ifdef CURRENT_INCLUDES_NICE
 386         current->nice = -10;
 387 #  endif
 388 # endif
 389         AFS_GLOCK();
 390         complete(arg->complete);
 391         while (afs_initState < AFSOP_START_BKG)
 392             afs_osi_Sleep(&afs_initState);
 393         sprintf(current->comm, "afs_rxevent");
 394         afs_rxevent_daemon();
 395         AFS_GUNLOCK();
 396         complete_and_exit(0, 0);
 397         break;
 398 #ifdef RXK_LISTENER_ENV
 399     case AFSOP_RXLISTENER_DAEMON:
 400         sprintf(current->comm, "afs_lsnstart");
 401 # ifdef SYS_SETPRIORITY_EXPORTED
 402         sys_setpriority(PRIO_PROCESS, 0, -10);
 403 # else
 404 #  ifdef CURRENT_INCLUDES_NICE
 405         current->nice = -10;
 406 #  endif
 407 # endif
 408         AFS_GLOCK();
 409         complete(arg->complete);
 410         afs_initState = AFSOP_START_AFS;
 411         afs_osi_Wakeup(&afs_initState);
 412         afs_RX_Running = 2;
 413         afs_osi_Wakeup(&afs_RX_Running);
 414         afs_osi_RxkRegister();
 415         sprintf(current->comm, "afs_rxlistener");
 416         rxk_Listener();
 417         AFS_GUNLOCK();
 418         complete_and_exit(0, 0);
 419         break;
 420 #endif
 421     default:
 422         afs_warn("Unknown op %ld in StartDaemon()\n", (long)parm);
 423         break;
 424     }
 425     return 0;
 426 }
 427
 428 void
 429 # if defined(AFS_LINUX26_ENV) && !defined(INIT_WORK_HAS_DATA)
 430 afsd_launcher(struct work_struct *work)
 431 # else
 432 afsd_launcher(void *rock)
 433 # endif
 434 {
 435 # if defined(AFS_LINUX26_ENV) && !defined(INIT_WORK_HAS_DATA)
 436     struct afsd_thread_info *rock = container_of(work, struct afsd_thread_info, tq);
 437 # endif
 438
 439 # if defined(HAVE_LINUX_KTHREAD_RUN)
 440     if (IS_ERR(kthread_run(afsd_thread, (void *)rock, "afsd"))) {
 441         afs_warn("kthread_run failed; afs startup will not complete\n");
 442     }
 443 # else /* !HAVE_LINUX_KTHREAD_RUN */
 444     if (!kernel_thread(afsd_thread, (void *)rock, CLONE_VFORK | SIGCHLD))
 445         afs_warn("kernel_thread failed. afs startup will not complete\n");
 446 # endif /* !HAVE_LINUX_KTHREAD_RUN */
 447 }
 448
 449 void
 450 afs_DaemonOp(long parm, long parm2, long parm3, long parm4, long parm5,
 451              long parm6)
 452 {
 453     DECLARE_COMPLETION(c);
 454 # if defined(AFS_LINUX26_ENV)
 455 #  if defined(INIT_WORK_HAS_DATA)
 456     struct work_struct tq;
 457 #  endif
 458 # else
 459     struct tq_struct tq;
 460 # endif
 461     struct afsd_thread_info info;
 462     if (daemonOp_common(parm, parm2, parm3, parm4, parm5, parm6)) {
 463         return;
 464     }
 465     info.complete = &c;
 466     info.parm = parm;
 467 # if defined(AFS_LINUX26_ENV)
 468 #  if !defined(INIT_WORK_HAS_DATA)
 469     INIT_WORK(&info.tq, afsd_launcher);
 470     schedule_work(&info.tq);
 471 #  else
 472     INIT_WORK(&tq, afsd_launcher, &info);
 473     schedule_work(&tq);
 474 #  endif
 475 # else
 476     tq.sync = 0;
 477     INIT_LIST_HEAD(&tq.list);
 478     tq.routine = afsd_launcher;
 479     tq.data = &info;
 480     schedule_task(&tq);
 481 # endif
 482     AFS_GUNLOCK();
 483     /* we need to wait cause we passed stack pointers around.... */
 484     wait_for_completion(&c);
 485     AFS_GLOCK();
 486 }
 487 #endif
 488
 489 #ifdef AFS_SUN5_ENV
 490 struct afs_daemonop_args {
 491     kcondvar_t cv;
 492     long parm;
 493 };
 494
 495 static void
 496 afsd_thread(struct afs_daemonop_args *args)
 497 {
 498     long parm = args->parm;
 499
 500     AFS_GLOCK();
 501     cv_signal(&args->cv);
 502
 503     switch (parm) {
 504     case AFSOP_START_RXCALLBACK:
 505         if (afs_CB_Running)
 506             goto out;
 507         afs_CB_Running = 1;
 508         while (afs_RX_Running != 2)
 509             afs_osi_Sleep(&afs_RX_Running);
 510         afs_RXCallBackServer();
 511         AFS_GUNLOCK();
 512         return;
 513     case AFSOP_START_AFS:
 514         if (AFS_Running)
 515             goto out;
 516         AFS_Running = 1;
 517         while (afs_initState < AFSOP_START_AFS)
 518             afs_osi_Sleep(&afs_initState);
 519         afs_initState = AFSOP_START_BKG;
 520         afs_osi_Wakeup(&afs_initState);
 521         afs_Daemon();
 522         AFS_GUNLOCK();
 523         return;
 524     case AFSOP_START_BKG:
 525         while (afs_initState < AFSOP_START_BKG)
 526             afs_osi_Sleep(&afs_initState);
 527         if (afs_initState < AFSOP_GO) {
 528             afs_initState = AFSOP_GO;
 529             afs_osi_Wakeup(&afs_initState);
 530         }
 531         afs_BackgroundDaemon();
 532         AFS_GUNLOCK();
 533         return;
 534     case AFSOP_START_TRUNCDAEMON:
 535         while (afs_initState < AFSOP_GO)
 536             afs_osi_Sleep(&afs_initState);
 537         afs_CacheTruncateDaemon();
 538         AFS_GUNLOCK();
 539         return;
 540     case AFSOP_START_CS:
 541         afs_CheckServerDaemon();
 542         AFS_GUNLOCK();
 543         return;
 544     case AFSOP_RXEVENT_DAEMON:
 545         while (afs_initState < AFSOP_START_BKG)
 546             afs_osi_Sleep(&afs_initState);
 547         afs_rxevent_daemon();
 548         AFS_GUNLOCK();
 549         return;
 550     case AFSOP_RXLISTENER_DAEMON:
 551         afs_initState = AFSOP_START_AFS;
 552         afs_osi_Wakeup(&afs_initState);
 553         afs_RX_Running = 2;
 554         afs_osi_Wakeup(&afs_RX_Running);
 555         afs_osi_RxkRegister();
 556         rxk_Listener();
 557         AFS_GUNLOCK();
 558         return;
 559     default:
 560         AFS_GUNLOCK();
 561         afs_warn("Unknown op %ld in afsd_thread()\n", parm);
 562         return;
 563     }
 564  out:
 565     AFS_GUNLOCK();
 566     return;
 567 }
 568
 569 static void
 570 afs_DaemonOp(long parm, long parm2, long parm3, long parm4, long parm5,
 571              long parm6)
 572 {
 573     struct afs_daemonop_args args;
 574
 575     if (daemonOp_common(parm, parm2, parm3, parm4, parm5, parm6)) {
 576         return;
 577     }
 578
 579     args.parm = parm;
 580
 581     cv_init(&args.cv, "AFS DaemonOp cond var", CV_DEFAULT, NULL);
 582
 583     if (thread_create(NULL, 0, afsd_thread, &args, 0, &p0, TS_RUN,
 584         minclsyspri) == NULL) {
 585
 586         afs_warn("thread_create failed: AFS startup will not complete\n");
 587     }
 588
 589     /* we passed &args to the new thread, which is on the stack. wait until
 590      * it has read the arguments so it doesn't try to read the args after we
 591      * have returned */
 592     cv_wait(&args.cv, &afs_global_lock);
 593
 594     cv_destroy(&args.cv);
 595 }
 596 #endif /* AFS_SUN5_ENV */
 597
 598 #ifdef AFS_DARWIN100_ENV
 599 # define AFSKPTR(X) k ## X
 600 int
 601 afs_syscall_call(long parm, long parm2, long parm3,
 602                  long parm4, long parm5, long parm6)
 603 {
 604     return afs_syscall64_call(CAST_USER_ADDR_T((parm)),
 605                               CAST_USER_ADDR_T((parm2)),
 606                               CAST_USER_ADDR_T((parm3)),
 607                               CAST_USER_ADDR_T((parm4)),
 608                               CAST_USER_ADDR_T((parm5)),
 609                               CAST_USER_ADDR_T((parm6)));
 610 }
 611 #else
 612 # define AFSKPTR(X) ((caddr_t)X)
 613 #endif
 614 int
 615 #ifdef AFS_DARWIN100_ENV
 616 afs_syscall64_call(user_addr_t kparm, user_addr_t kparm2, user_addr_t kparm3,
 617                  user_addr_t kparm4, user_addr_t kparm5, user_addr_t kparm6)
 618 #else
 619 afs_syscall_call(long parm, long parm2, long parm3,
 620                  long parm4, long parm5, long parm6)
 621 #endif
 622 {
 623     afs_int32 code = 0;
 624 #if defined(AFS_SGI61_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
 625     size_t bufferSize;
 626 #else /* AFS_SGI61_ENV */
 627     u_int bufferSize;
 628 #endif /* AFS_SGI61_ENV */
 629 #ifdef AFS_DARWIN100_ENV
 630     /* AFSKPTR macro relies on this name format/mapping */
 631     afs_uint32 parm = (afs_uint32)kparm;
 632     afs_uint32 parm2 = (afs_uint32)kparm2;
 633     afs_uint32 parm3 = (afs_uint32)kparm3;
 634     afs_uint32 parm4 = (afs_uint32)kparm4;
 635     afs_uint32 parm5 = (afs_uint32)kparm5;
 636     afs_uint32 parm6 = (afs_uint32)kparm6;
 637 #endif
 638
 639     AFS_STATCNT(afs_syscall_call);
 640     if (
 641 #ifdef  AFS_SUN5_ENV
 642         !afs_suser(CRED())
 643 #else
 644         !afs_suser(NULL)
 645 #endif
 646                     && (parm != AFSOP_GETMTU) && (parm != AFSOP_GETMASK)) {
 647         /* only root can run this code */
 648 #if defined(AFS_SUN5_ENV) || defined(KERNEL_HAVE_UERROR)
 649 # if defined(KERNEL_HAVE_UERROR)
 650         setuerror(EACCES);
 651 # endif
 652         code = EACCES;
 653 #else
 654         code = EPERM;
 655 #endif
 656         AFS_GLOCK();
 657 #ifdef AFS_DARWIN80_ENV
 658         put_vfs_context();
 659 #endif
 660         goto out;
 661     }
 662     AFS_GLOCK();
 663 #ifdef AFS_DARWIN80_ENV
 664     put_vfs_context();
 665 #endif
 666 #ifdef AFS_DAEMONOP_ENV
 667 # if defined(AFS_NEW_BKG)
 668     if (parm == AFSOP_BKG_HANDLER) {
 669         /* if afs_uspc_param grows this should be checked */
 670         struct afs_uspc_param *mvParam = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
 671         void *param2;
 672         void *param1;
 673         int namebufsz;
 674
 675         AFS_COPYIN(AFSKPTR(parm2), (caddr_t)mvParam,
 676                    sizeof(struct afs_uspc_param), code);
 677         namebufsz = mvParam->bufSz;
 678         param1 = afs_osi_Alloc(namebufsz);
 679         osi_Assert(param1 != NULL);
 680         param2 = afs_osi_Alloc(namebufsz);
 681         osi_Assert(param2 != NULL);
 682
 683         while (afs_initState < AFSOP_START_BKG)
 684             afs_osi_Sleep(&afs_initState);
 685         if (afs_initState < AFSOP_GO) {
 686             afs_initState = AFSOP_GO;
 687             afs_osi_Wakeup(&afs_initState);
 688         }
 689
 690         code = afs_BackgroundDaemon(mvParam, param1, param2);
 691
 692         if (!code) {
 693             mvParam->retval = 0;
 694             /* for reqs where pointers are strings: */
 695             if (mvParam->reqtype == AFS_USPC_UMV) {
 696                 /* don't copy out random kernel memory */
 697                 AFS_COPYOUT(param2, AFSKPTR(parm4),
 698                             MIN(namebufsz, strlen((char *)param2)+1), code);
 699                 AFS_COPYOUT(param1, AFSKPTR(parm3),
 700                             MIN(namebufsz, strlen((char *)param1)+1), code);
 701             }
 702             AFS_COPYOUT((caddr_t)mvParam, AFSKPTR(parm2),
 703                        sizeof(struct afs_uspc_param), code);
 704         }
 705
 706         afs_osi_Free(param1, namebufsz);
 707         afs_osi_Free(param2, namebufsz);
 708         osi_FreeSmallSpace(mvParam);
 709     } else
 710 # endif /* AFS_NEW_BKG */
 711     if (parm < AFSOP_ADDCELL || parm == AFSOP_RXEVENT_DAEMON
 712         || parm == AFSOP_RXLISTENER_DAEMON) {
 713         afs_DaemonOp(parm, parm2, parm3, parm4, parm5, parm6);
 714     }
 715 #else /* !AFS_DAEMONOP_ENV */
 716     if (parm == AFSOP_START_RXCALLBACK) {
 717         if (afs_CB_Running)
 718             goto out;
 719         afs_CB_Running = 1;
 720 # ifndef RXK_LISTENER_ENV
 721         code = afs_InitSetup(parm2);
 722         if (!code)
 723 # endif /* !RXK_LISTENER_ENV */
 724         {
 725 # ifdef RXK_LISTENER_ENV
 726             while (afs_RX_Running != 2)
 727                 afs_osi_Sleep(&afs_RX_Running);
 728 # else /* !RXK_LISTENER_ENV */
 729             if (parm3) {
 730                 rx_enablePeerRPCStats();
 731             }
 732             if (parm4) {
 733                 rx_enableProcessRPCStats();
 734             }
 735             afs_initState = AFSOP_START_AFS;
 736             afs_osi_Wakeup(&afs_initState);
 737 # endif /* RXK_LISTENER_ENV */
 738             afs_osi_Invisible();
 739             afs_RXCallBackServer();
 740             afs_osi_Visible();
 741         }
 742 # ifdef AFS_SGI_ENV
 743         AFS_GUNLOCK();
 744         exit(CLD_EXITED, code);
 745 # endif /* AFS_SGI_ENV */
 746     }
 747 # ifdef RXK_LISTENER_ENV
 748     else if (parm == AFSOP_RXLISTENER_DAEMON) {
 749         if (afs_RX_Running)
 750             goto out;
 751         afs_RX_Running = 1;
 752         code = afs_InitSetup(parm2);
 753         if (parm3) {
 754             rx_enablePeerRPCStats();
 755         }
 756         if (parm4) {
 757             rx_enableProcessRPCStats();
 758         }
 759         if (!code) {
 760             afs_initState = AFSOP_START_AFS;
 761             afs_osi_Wakeup(&afs_initState);
 762             afs_osi_Invisible();
 763             afs_RX_Running = 2;
 764             afs_osi_Wakeup(&afs_RX_Running);
 765 #  ifndef UKERNEL
 766             afs_osi_RxkRegister();
 767 #  endif /* !UKERNEL */
 768             rxk_Listener();
 769             afs_osi_Visible();
 770         }
 771 #  ifdef        AFS_SGI_ENV
 772         AFS_GUNLOCK();
 773         exit(CLD_EXITED, code);
 774 #  endif /* AFS_SGI_ENV */
 775     }
 776 # endif /* RXK_LISTENER_ENV */
 777     else if (parm == AFSOP_START_AFS) {
 778         /* afs daemon */
 779         if (AFS_Running)
 780             goto out;
 781         AFS_Running = 1;
 782         while (afs_initState < AFSOP_START_AFS)
 783             afs_osi_Sleep(&afs_initState);
 784
 785         afs_initState = AFSOP_START_BKG;
 786         afs_osi_Wakeup(&afs_initState);
 787         afs_osi_Invisible();
 788         afs_Daemon();
 789         afs_osi_Visible();
 790 # ifdef AFS_SGI_ENV
 791         AFS_GUNLOCK();
 792         exit(CLD_EXITED, 0);
 793 # endif /* AFS_SGI_ENV */
 794     } else if (parm == AFSOP_START_CS) {
 795         afs_osi_Invisible();
 796         afs_CheckServerDaemon();
 797         afs_osi_Visible();
 798 # ifdef AFS_SGI_ENV
 799         AFS_GUNLOCK();
 800         exit(CLD_EXITED, 0);
 801 # endif /* AFS_SGI_ENV */
 802 # ifndef AFS_NEW_BKG
 803     } else if (parm == AFSOP_START_BKG) {
 804         while (afs_initState < AFSOP_START_BKG)
 805             afs_osi_Sleep(&afs_initState);
 806         if (afs_initState < AFSOP_GO) {
 807             afs_initState = AFSOP_GO;
 808             afs_osi_Wakeup(&afs_initState);
 809         }
 810         /* start the bkg daemon */
 811         afs_osi_Invisible();
 812 #  ifdef AFS_AIX32_ENV
 813         if (parm2)
 814             afs_BioDaemon(parm2);
 815         else
 816 #  endif /* AFS_AIX32_ENV */
 817             afs_BackgroundDaemon();
 818         afs_osi_Visible();
 819 #  ifdef AFS_SGI_ENV
 820         AFS_GUNLOCK();
 821         exit(CLD_EXITED, 0);
 822 #  endif /* AFS_SGI_ENV */
 823 # endif /* ! AFS_NEW_BKG */
 824     } else if (parm == AFSOP_START_TRUNCDAEMON) {
 825         while (afs_initState < AFSOP_GO)
 826             afs_osi_Sleep(&afs_initState);
 827         /* start the bkg daemon */
 828         afs_osi_Invisible();
 829         afs_CacheTruncateDaemon();
 830         afs_osi_Visible();
 831 # ifdef AFS_SGI_ENV
 832         AFS_GUNLOCK();
 833         exit(CLD_EXITED, 0);
 834 # endif /* AFS_SGI_ENV */
 835     }
 836 # if defined(AFS_SUN5_ENV) || defined(RXK_LISTENER_ENV) || defined(RXK_UPCALL_ENV)
 837     else if (parm == AFSOP_RXEVENT_DAEMON) {
 838         while (afs_initState < AFSOP_START_BKG)
 839             afs_osi_Sleep(&afs_initState);
 840         afs_osi_Invisible();
 841         afs_rxevent_daemon();
 842         afs_osi_Visible();
 843 #  ifdef AFS_SGI_ENV
 844         AFS_GUNLOCK();
 845         exit(CLD_EXITED, 0);
 846 #  endif /* AFS_SGI_ENV */
 847     }
 848 # endif /* AFS_SUN5_ENV || RXK_LISTENER_ENV || RXK_UPCALL_ENV */
 849 #endif /* AFS_DAEMONOP_ENV */
 850     else if (parm == AFSOP_BASIC_INIT) {
 851         afs_int32 temp;
 852
 853         while (!afs_InitSetup_done)
 854             afs_osi_Sleep(&afs_InitSetup_done);
 855
 856 #if defined(AFS_SGI_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV) || defined(AFS_SUN5_ENV)
 857         temp = AFS_MINBUFFERS;  /* Should fix this soon */
 858 #else
 859         /* number of 2k buffers we could get from all of the buffer space */
 860         temp = ((afs_bufferpages * NBPG) >> 11);
 861         temp = temp >> 2;       /* don't take more than 25% (our magic parameter) */
 862         if (temp < AFS_MINBUFFERS)
 863             temp = AFS_MINBUFFERS;      /* though we really should have this many */
 864 #endif
 865         DInit(temp);
 866         afs_rootFid.Fid.Volume = 0;
 867         code = 0;
 868     } else if (parm == AFSOP_BUCKETPCT) {
 869         /* need to enable this now, will disable again before GO
 870            if we don't have 100% */
 871         splitdcache = 1;
 872         switch (parm2) {
 873         case 1:
 874             afs_tpct1 = parm3;
 875             break;
 876         case 2:
 877             afs_tpct2 = parm3;
 878             break;
 879         }
 880     } else if (parm == AFSOP_ADDCELL) {
 881         /* add a cell.  Parameter 2 is 8 hosts (in net order),  parm 3 is the null-terminated
 882          * name.  Parameter 4 is the length of the name, including the null.  Parm 5 is the
 883          * home cell flag (0x1 bit) and the nosuid flag (0x2 bit) */
 884         struct afsop_cell *tcell = afs_osi_Alloc(sizeof(struct afsop_cell));
 885
 886         osi_Assert(tcell != NULL);
 887         code = afs_InitDynroot();
 888         if (!code) {
 889             AFS_COPYIN(AFSKPTR(parm2), (caddr_t)tcell->hosts, sizeof(tcell->hosts),
 890                        code);
 891         }
 892         if (!code) {
 893             if (parm4 > sizeof(tcell->cellName))
 894                 code = EFAULT;
 895             else {
 896               AFS_COPYIN(AFSKPTR(parm3), (caddr_t)tcell->cellName, parm4, code);
 897                 if (!code)
 898                     afs_NewCell(tcell->cellName, tcell->hosts, parm5, NULL, 0,
 899                                 0, 0);
 900             }
 901         }
 902         afs_osi_Free(tcell, sizeof(struct afsop_cell));
 903     } else if (parm == AFSOP_ADDCELL2) {
 904         struct afsop_cell *tcell = afs_osi_Alloc(sizeof(struct afsop_cell));
 905         char *tbuffer = osi_AllocSmallSpace(AFS_SMALLOCSIZ), *lcnamep = 0;
 906         char *tbuffer1 = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
 907         int cflags = parm4;
 908
 909         osi_Assert(tcell != NULL);
 910         osi_Assert(tbuffer != NULL);
 911         osi_Assert(tbuffer1 != NULL);
 912         code = afs_InitDynroot();
 913         if (!code) {
 914             AFS_COPYIN(AFSKPTR(parm2), (caddr_t)tcell->hosts, sizeof(tcell->hosts),
 915                        code);
 916         }
 917         if (!code) {
 918             AFS_COPYINSTR(AFSKPTR(parm3), tbuffer1, AFS_SMALLOCSIZ,
 919                           &bufferSize, code);
 920             if (!code) {
 921                 if (parm4 & 4) {
 922                     AFS_COPYINSTR(AFSKPTR(parm5), tbuffer, AFS_SMALLOCSIZ,
 923                                   &bufferSize, code);
 924                     if (!code) {
 925                         lcnamep = tbuffer;
 926                         cflags |= CLinkedCell;
 927                     }
 928                 }
 929                 if (parm4 & 8) {
 930                     cflags |= CHush;
 931                 }
 932                 if (!code)
 933                     code =
 934                         afs_NewCell(tbuffer1, tcell->hosts, cflags, lcnamep,
 935                                     0, 0, 0);
 936             }
 937         }
 938         afs_osi_Free(tcell, sizeof(struct afsop_cell));
 939         osi_FreeSmallSpace(tbuffer);
 940         osi_FreeSmallSpace(tbuffer1);
 941     } else if (parm == AFSOP_ADDCELLALIAS) {
 942         /*
 943          * Call arguments:
 944          * parm2 is the alias name
 945          * parm3 is the real cell name
 946          */
 947         char *aliasName = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
 948         char *cellName = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
 949
 950         code = afs_InitDynroot();
 951         if (!code) {
 952             AFS_COPYINSTR(AFSKPTR(parm2), aliasName, AFS_SMALLOCSIZ, &bufferSize,
 953                           code);
 954         }
 955         if (!code)
 956             AFS_COPYINSTR(AFSKPTR(parm3), cellName, AFS_SMALLOCSIZ,
 957                           &bufferSize, code);
 958         if (!code)
 959             afs_NewCellAlias(aliasName, cellName);
 960         osi_FreeSmallSpace(aliasName);
 961         osi_FreeSmallSpace(cellName);
 962     } else if (parm == AFSOP_SET_THISCELL) {
 963         /*
 964          * Call arguments:
 965          * parm2 is the primary cell name
 966          */
 967         char *cell = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
 968
 969         afs_CellInit();
 970         AFS_COPYINSTR(AFSKPTR(parm2), cell, AFS_SMALLOCSIZ, &bufferSize, code);
 971         if (!code)
 972             afs_SetPrimaryCell(cell);
 973         osi_FreeSmallSpace(cell);
 974         if (!code) {
 975             code = afs_InitDynroot();
 976         }
 977     } else if (parm == AFSOP_CACHEINIT) {
 978         struct afs_cacheParams cparms;
 979
 980         if (afs_CacheInit_Done)
 981             goto out;
 982
 983         AFS_COPYIN(AFSKPTR(parm2), (caddr_t) & cparms, sizeof(cparms), code);
 984         if (code) {
 985 #if defined(KERNEL_HAVE_UERROR)
 986             setuerror(code);
 987             code = -1;
 988 #endif
 989             goto out;
 990         }
 991         afs_CacheInit_Done = 1;
 992         code = afs_icl_InitLogs();
 993         if (cparms.setTimeFlag) {
 994             afs_warn("afs: AFSOP_CACHEINIT setTimeFlag ignored; are you "
 995                      "running an old afsd?\n");
 996         }
 997
 998         code =
 999             afs_CacheInit(cparms.cacheScaches, cparms.cacheFiles,
1000                           cparms.cacheBlocks, cparms.cacheDcaches,
1001                           cparms.cacheVolumes, cparms.chunkSize,
1002                           cparms.memCacheFlag, cparms.inodes, cparms.users,
1003                           cparms.dynamic_vcaches);
1004
1005     } else if (parm == AFSOP_CACHEINODE) {
1006         ino_t ainode = parm2;
1007         /* wait for basic init */
1008         while (afs_initState < AFSOP_START_BKG)
1009             afs_osi_Sleep(&afs_initState);
1010
1011 #ifdef AFS_DARWIN80_ENV
1012         get_vfs_context();
1013 #endif
1014         /* do it by inode */
1015 #ifdef AFS_SGI62_ENV
1016         ainode = (ainode << 32) | (parm3 & 0xffffffff);
1017 #endif
1018         code = afs_InitCacheFile(NULL, ainode);
1019 #ifdef AFS_DARWIN80_ENV
1020         put_vfs_context();
1021 #endif
1022     } else if (parm == AFSOP_CACHEDIRS) {
1023         afs_numfilesperdir = parm2;
1024         afs_osi_Wakeup(&afs_initState);
1025     } else if (parm == AFSOP_CACHEFILES) {
1026         afs_numcachefiles = parm2;
1027         afs_osi_Wakeup(&afs_initState);
1028     } else if (parm == AFSOP_ROOTVOLUME) {
1029         /* wait for basic init */
1030         while (afs_initState < AFSOP_START_BKG)
1031             afs_osi_Sleep(&afs_initState);
1032
1033         if (parm2) {
1034             AFS_COPYINSTR(AFSKPTR(parm2), afs_rootVolumeName,
1035                           sizeof(afs_rootVolumeName), &bufferSize, code);
1036             afs_rootVolumeName[sizeof(afs_rootVolumeName) - 1] = 0;
1037         } else
1038             code = 0;
1039     } else if (parm == AFSOP_CACHEFILE || parm == AFSOP_CACHEINFO
1040                || parm == AFSOP_VOLUMEINFO || parm == AFSOP_CELLINFO) {
1041         char *tbuffer = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
1042
1043         code = 0;
1044         AFS_COPYINSTR(AFSKPTR(parm2), tbuffer, AFS_SMALLOCSIZ, &bufferSize,
1045                       code);
1046         if (!code) {
1047             tbuffer[AFS_SMALLOCSIZ - 1] = '\0'; /* null-terminate the name */
1048             /* We have the cache dir copied in.  Call the cache init routine */
1049 #ifdef AFS_DARWIN80_ENV
1050             get_vfs_context();
1051 #endif
1052             if (parm == AFSOP_CACHEFILE) {
1053                 code = afs_InitCacheFile(tbuffer, 0);
1054             } else if (parm == AFSOP_CACHEINFO) {
1055                 code = afs_InitCacheInfo(tbuffer);
1056             } else if (parm == AFSOP_VOLUMEINFO) {
1057                 code = afs_InitVolumeInfo(tbuffer);
1058             } else if (parm == AFSOP_CELLINFO) {
1059                 code = afs_InitCellInfo(tbuffer);
1060             }
1061 #ifdef AFS_DARWIN80_ENV
1062             put_vfs_context();
1063 #endif
1064         }
1065         osi_FreeSmallSpace(tbuffer);
1066     } else if (parm == AFSOP_GO) {
1067         /* the generic initialization calls come here.  One parameter: should we do the
1068          * set-time operation on this workstation */
1069         if (afs_Go_Done)
1070             goto out;
1071         afs_Go_Done = 1;
1072         while (afs_initState < AFSOP_GO)
1073             afs_osi_Sleep(&afs_initState);
1074         afs_initState = 101;
1075         if (parm2) {
1076             /* parm2 used to set afs_setTime */
1077             afs_warn("afs: AFSOP_GO setTime flag ignored; are you running an "
1078                      "old afsd?\n");
1079         }
1080         if (afs_tpct1 + afs_tpct2 != 100) {
1081             afs_tpct1 = 0;
1082             afs_tpct2 = 0;
1083             splitdcache = 0;
1084         } else {
1085             splitdcache = 1;
1086         }
1087         afs_osi_Wakeup(&afs_initState);
1088 #if     (!defined(AFS_NONFSTRANS)) || defined(AFS_AIX_IAUTH_ENV)
1089         afs_nfsclient_init();
1090 #endif
1091         if (afs_uuid_create(&afs_cb_interface.uuid) != 0)
1092             memset(&afs_cb_interface.uuid, 0, sizeof(afsUUID));
1093
1094         printf("found %d non-empty cache files (%d%%).\n",
1095                afs_stats_cmperf.cacheFilesReused,
1096                (100 * afs_stats_cmperf.cacheFilesReused) /
1097                (afs_stats_cmperf.cacheNumEntries ? afs_stats_cmperf.
1098                 cacheNumEntries : 1));
1099     } else if (parm == AFSOP_ADVISEADDR) {
1100         /* pass in the host address to the rx package */
1101         int rxbind = 0;
1102         int refresh = 0;
1103
1104         afs_int32 count = parm2;
1105         afs_int32 *buffer =
1106             afs_osi_Alloc(sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
1107         afs_int32 *maskbuffer =
1108             afs_osi_Alloc(sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
1109         afs_int32 *mtubuffer =
1110             afs_osi_Alloc(sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
1111         int i;
1112
1113         osi_Assert(buffer != NULL);
1114         osi_Assert(maskbuffer != NULL);
1115         osi_Assert(mtubuffer != NULL);
1116         /* This is a refresh */
1117         if (count & 0x40000000) {
1118             count &= ~0x40000000;
1119             /* Can't bind after we start. Fix? */
1120             count &= ~0x80000000;
1121             refresh = 1;
1122         }
1123
1124         /* Bind, but only if there's only one address configured */
1125         if ( count & 0x80000000) {
1126             count &= ~0x80000000;
1127             if (count == 1)
1128                 rxbind=1;
1129         }
1130
1131         if (count > AFS_MAX_INTERFACE_ADDR) {
1132             code = ENOMEM;
1133             count = AFS_MAX_INTERFACE_ADDR;
1134         }
1135
1136         AFS_COPYIN(AFSKPTR(parm3), (caddr_t)buffer, count * sizeof(afs_int32),
1137                    code);
1138         if (parm4 && !code)
1139             AFS_COPYIN(AFSKPTR(parm4), (caddr_t)maskbuffer,
1140                        count * sizeof(afs_int32), code);
1141         if (parm5 && !code)
1142             AFS_COPYIN(AFSKPTR(parm5), (caddr_t)mtubuffer,
1143                        count * sizeof(afs_int32), code);
1144
1145         if (!code) {
1146             afs_cb_interface.numberOfInterfaces = count;
1147             for (i = 0; i < count; i++) {
1148                 afs_cb_interface.addr_in[i] = buffer[i];
1149 #ifdef AFS_USERSPACE_IP_ADDR
1150                 /* AFS_USERSPACE_IP_ADDR means we have no way of finding the
1151                  * machines IP addresses when in the kernel (the in_ifaddr
1152                  * struct is not available), so we pass the info in at
1153                  * startup. We also pass in the subnetmask and mtu size. The
1154                  * subnetmask is used when setting the rank:
1155                  * afsi_SetServerIPRank(); and the mtu size is used when
1156                  * finding the best mtu size. rxi_FindIfnet() is replaced
1157                  * with rxi_Findcbi().
1158                  */
1159                 afs_cb_interface.subnetmask[i] =
1160                     (parm4 ? maskbuffer[i] : 0xffffffff);
1161                 afs_cb_interface.mtu[i] = (parm5 ? mtubuffer[i] : htonl(1500));
1162 #endif
1163             }
1164             rxi_setaddr(buffer[0]);
1165             if (!refresh) {
1166                 if (rxbind)
1167                     rx_bindhost = buffer[0];
1168                 else
1169                     rx_bindhost = htonl(INADDR_ANY);
1170             }
1171         } else {
1172             refresh = 0;
1173         }
1174
1175         afs_osi_Free(buffer, sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
1176         afs_osi_Free(maskbuffer, sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
1177         afs_osi_Free(mtubuffer, sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
1178
1179         if (refresh) {
1180             afs_CheckServers(1, NULL);     /* check down servers */
1181             afs_CheckServers(0, NULL);     /* check up servers */
1182         }
1183     }
1184     else if (parm == AFSOP_SHUTDOWN) {
1185         afs_cold_shutdown = 0;
1186         if (parm2 == 1)
1187             afs_cold_shutdown = 1;
1188         if (afs_globalVFS != 0) {
1189             afs_warn("AFS isn't unmounted yet! Call aborted\n");
1190             code = EACCES;
1191         } else
1192             afs_shutdown();
1193     } else if (parm == AFSOP_AFS_VFSMOUNT) {
1194 #ifdef  AFS_HPUX_ENV
1195         vfsmount(parm2, parm3, parm4, parm5);
1196 #else /* defined(AFS_HPUX_ENV) */
1197 # if defined(KERNEL_HAVE_UERROR)
1198         setuerror(EINVAL);
1199 # else
1200         code = EINVAL;
1201 # endif
1202 #endif /* defined(AFS_HPUX_ENV) */
1203     } else if (parm == AFSOP_CLOSEWAIT) {
1204         afs_SynchronousCloses = 'S';
1205     } else if (parm == AFSOP_GETMTU) {
1206         afs_uint32 mtu = 0;
1207 #if     !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV)
1208 # ifdef AFS_USERSPACE_IP_ADDR
1209         afs_int32 i;
1210         i = rxi_Findcbi(parm2);
1211         mtu = ((i == -1) ? htonl(1500) : afs_cb_interface.mtu[i]);
1212 # else /* AFS_USERSPACE_IP_ADDR */
1213         rx_ifnet_t tifnp;
1214
1215         tifnp = rxi_FindIfnet(parm2, NULL);     /*  make iterative */
1216         mtu = (tifnp ? rx_ifnet_mtu(tifnp) : htonl(1500));
1217 # endif /* else AFS_USERSPACE_IP_ADDR */
1218 #endif /* !AFS_SUN5_ENV */
1219         if (!code)
1220             AFS_COPYOUT((caddr_t) & mtu, AFSKPTR(parm3),
1221                         sizeof(afs_int32), code);
1222     } else if (parm == AFSOP_GETMASK) { /* parm2 == addr in net order */
1223         afs_uint32 mask = 0;
1224 #if     !defined(AFS_SUN5_ENV)
1225 # ifdef AFS_USERSPACE_IP_ADDR
1226         afs_int32 i;
1227         i = rxi_Findcbi(parm2);
1228         if (i != -1) {
1229             mask = afs_cb_interface.subnetmask[i];
1230         } else {
1231             code = -1;
1232         }
1233 # else /* AFS_USERSPACE_IP_ADDR */
1234         rx_ifnet_t tifnp;
1235
1236         tifnp = rxi_FindIfnet(parm2, &mask);    /* make iterative */
1237         if (!tifnp)
1238             code = -1;
1239 # endif /* else AFS_USERSPACE_IP_ADDR */
1240 #endif /* !AFS_SUN5_ENV */
1241         if (!code)
1242             AFS_COPYOUT((caddr_t) & mask, AFSKPTR(parm3),
1243                         sizeof(afs_int32), code);
1244     }
1245     else if (parm == AFSOP_AFSDB_HANDLER) {
1246         int sizeArg = (int)parm4;
1247         int kmsgLen = sizeArg & 0xffff;
1248         int cellLen = (sizeArg & 0xffff0000) >> 16;
1249         afs_int32 *kmsg = afs_osi_Alloc(kmsgLen);
1250         char *cellname = afs_osi_Alloc(cellLen);
1251
1252         osi_Assert(kmsg != NULL);
1253         osi_Assert(cellname != NULL);
1254 #ifndef UKERNEL
1255         afs_osi_MaskUserLoop();
1256 #endif
1257         AFS_COPYIN(AFSKPTR(parm2), cellname, cellLen, code);
1258         AFS_COPYIN(AFSKPTR(parm3), kmsg, kmsgLen, code);
1259         if (!code) {
1260             code = afs_AFSDBHandler(cellname, cellLen, kmsg);
1261             if (*cellname == 1)
1262                 *cellname = 0;
1263             if (code == -2) {   /* Shutting down? */
1264                 *cellname = 1;
1265                 code = 0;
1266             }
1267         }
1268         if (!code)
1269             AFS_COPYOUT(cellname, AFSKPTR(parm2), cellLen, code);
1270         afs_osi_Free(kmsg, kmsgLen);
1271         afs_osi_Free(cellname, cellLen);
1272     }
1273     else if (parm == AFSOP_SET_DYNROOT) {
1274         code = afs_SetDynrootEnable(parm2);
1275     } else if (parm == AFSOP_SET_FAKESTAT) {
1276         afs_fakestat_enable = parm2;
1277         code = 0;
1278     } else if (parm == AFSOP_SET_BACKUPTREE) {
1279         afs_bkvolpref = parm2;
1280     } else if (parm == AFSOP_SET_RXPCK) {
1281         rx_extraPackets = parm2;
1282         afscall_set_rxpck_received = 1;
1283     } else if (parm == AFSOP_SET_RXMAXMTU) {
1284         rx_MyMaxSendSize = rx_maxReceiveSizeUser = rx_maxReceiveSize = parm2;
1285     } else if (parm == AFSOP_SET_RXMAXFRAGS) {
1286         rxi_nSendFrags = rxi_nRecvFrags = parm2;
1287     } else if (parm == AFSOP_SET_RMTSYS_FLAG) {
1288         afs_rmtsys_enable = parm2;
1289         code = 0;
1290 #ifndef UKERNEL
1291     } else if (parm == AFSOP_SEED_ENTROPY) {
1292         unsigned char *seedbuf;
1293
1294         if (parm3 > 4096) {
1295             code = EFAULT;
1296         } else {
1297             seedbuf = afs_osi_Alloc(parm3);
1298             AFS_COPYIN(AFSKPTR(parm2), seedbuf, parm3, code);
1299             RAND_seed(seedbuf, parm3);
1300             memset(seedbuf, 0, parm3);
1301             afs_osi_Free(seedbuf, parm3);
1302         }
1303 #endif
1304     } else {
1305         code = EINVAL;
1306     }
1307
1308   out:
1309     AFS_GUNLOCK();
1310 #ifdef AFS_LINUX20_ENV
1311     return -code;
1312 #else
1313     return code;
1314 #endif
1315 }
1316
1317 /*
1318  * Initstate in the range 0 < x < 100 are early initialization states.
1319  * Initstate of 100 means a AFSOP_START operation has been done.  After this,
1320  *  the cache may be initialized.
1321  * Initstate of 101 means a AFSOP_GO operation has been done.  This operation
1322  *  is done after all the cache initialization has been done.
1323  * Initstate of 200 means that the volume has been looked up once, possibly
1324  *  incorrectly.
1325  * Initstate of 300 means that the volume has been *successfully* looked up.
1326  */
1327 int
1328 afs_CheckInit(void)
1329 {
1330     int code = 0;
1331
1332     AFS_STATCNT(afs_CheckInit);
1333     if (afs_initState <= 100)
1334         code = ENXIO;           /* never finished init phase */
1335     else if (afs_initState == 101) {    /* init done, wait for afs_daemon */
1336         while (afs_initState < 200)
1337             afs_osi_Sleep(&afs_initState);
1338     } else if (afs_initState == 200)
1339         code = ETIMEDOUT;       /* didn't find root volume */
1340     return code;
1341 }
1342
1343 enum afs_shutdown_state afs_shuttingdown = AFS_RUNNING;
1344 void
1345 afs_shutdown(void)
1346 {
1347     extern short afs_brsDaemons;
1348     extern afs_int32 afs_CheckServerDaemonStarted;
1349     extern struct afs_osi_WaitHandle AFS_WaitHandler, AFS_CSWaitHandler;
1350     extern struct osi_file *afs_cacheInodep;
1351
1352     AFS_STATCNT(afs_shutdown);
1353     if (afs_initState == 0) {
1354         afs_warn("AFS not initialized - not shutting down\n");
1355       return;
1356     }
1357
1358     if (afs_shuttingdown != AFS_RUNNING)
1359         return;
1360
1361     afs_shuttingdown = AFS_FLUSHING_CB;
1362
1363     /* Give up all of our callbacks if we can. */
1364     afs_FlushVCBs(2);
1365
1366     afs_shuttingdown = AFS_SHUTDOWN;
1367
1368     if (afs_cold_shutdown)
1369         afs_warn("afs: COLD ");
1370     else
1371         afs_warn("afs: WARM ");
1372     afs_warn("shutting down of: vcaches... ");
1373
1374 #if !defined(AFS_FBSD_ENV)
1375     /* The FBSD afs_unmount() calls vflush(), which reclaims all vnodes
1376      * on the mountpoint, flushing them in the process.  In the presence
1377      * of bugs, flushing again here can cause panics. */
1378     afs_FlushAllVCaches();
1379 #endif
1380
1381     afs_termState = AFSOP_STOP_BKG;
1382
1383     afs_warn("BkG... ");
1384     /* Wake-up afs_brsDaemons so that we don't have to wait for a bkg job! */
1385     while (afs_termState == AFSOP_STOP_BKG) {
1386         afs_osi_Wakeup(&afs_brsDaemons);
1387         afs_osi_Sleep(&afs_termState);
1388     }
1389
1390     afs_warn("CB... ");
1391
1392     afs_termState = AFSOP_STOP_RXCALLBACK;
1393     rx_WakeupServerProcs();
1394 #ifdef AFS_AIX51_ENV
1395     shutdown_rxkernel();
1396 #endif
1397     /* close rx server connections here? */
1398     while (afs_termState == AFSOP_STOP_RXCALLBACK)
1399         afs_osi_Sleep(&afs_termState);
1400
1401     afs_warn("afs... ");
1402     while (afs_termState == AFSOP_STOP_AFS) {
1403         afs_osi_CancelWait(&AFS_WaitHandler);
1404         afs_osi_Sleep(&afs_termState);
1405     }
1406     if (afs_CheckServerDaemonStarted) {
1407         while (afs_termState == AFSOP_STOP_CS) {
1408             afs_osi_CancelWait(&AFS_CSWaitHandler);
1409             afs_osi_Sleep(&afs_termState);
1410         }
1411     }
1412     afs_warn("CTrunc... ");
1413     /* Cancel cache truncate daemon. */
1414     while (afs_termState == AFSOP_STOP_TRUNCDAEMON) {
1415         afs_osi_Wakeup((char *)&afs_CacheTruncateDaemon);
1416         afs_osi_Sleep(&afs_termState);
1417     }
1418     afs_warn("AFSDB... ");
1419     afs_StopAFSDB();
1420     while (afs_termState == AFSOP_STOP_AFSDB)
1421         afs_osi_Sleep(&afs_termState);
1422 #if     defined(AFS_SUN5_ENV) || defined(RXK_LISTENER_ENV) || defined(RXK_UPCALL_ENV)
1423     afs_warn("RxEvent... ");
1424     /* cancel rx event daemon */
1425     while (afs_termState == AFSOP_STOP_RXEVENT)
1426         afs_osi_Sleep(&afs_termState);
1427 # if defined(RXK_LISTENER_ENV)
1428 #  ifndef UKERNEL
1429     afs_warn("UnmaskRxkSignals... ");
1430     afs_osi_UnmaskRxkSignals();
1431 #  endif
1432     /* cancel rx listener */
1433     afs_warn("RxListener... ");
1434     osi_StopListener();         /* This closes rx_socket. */
1435     while (afs_termState == AFSOP_STOP_RXK_LISTENER) {
1436         afs_warn("Sleep... ");
1437         afs_osi_Sleep(&afs_termState);
1438     }
1439 # endif
1440 #endif
1441
1442 #if defined(AFS_SUN510_ENV) || defined(RXK_UPCALL_ENV)
1443     afs_warn("NetIfPoller... ");
1444     osi_StopNetIfPoller();
1445 #endif
1446
1447     afs_termState = AFSOP_STOP_COMPLETE;
1448
1449 #ifdef AFS_AIX51_ENV
1450     shutdown_daemons();
1451 #endif
1452     shutdown_CB();
1453     shutdown_bufferpackage();
1454     shutdown_cache();
1455     shutdown_osi();
1456     /*
1457      * Close file only after daemons which can write to it are stopped.
1458      * Need to close before the osinet shutdown to avoid failing check
1459      * for dangling memory allocations.
1460      */
1461     if (afs_cacheInodep) {      /* memcache won't set this */
1462         osi_UFSClose(afs_cacheInodep);  /* Since we always leave it open */
1463         afs_cacheInodep = 0;
1464     }
1465     /*
1466      * Shutdown the ICL logs - needed to free allocated memory space and avoid
1467      * warnings from shutdown_osinet
1468      */
1469     shutdown_icl();
1470     shutdown_osinet();
1471     shutdown_osifile();
1472     shutdown_vnodeops();
1473     shutdown_memcache();
1474     shutdown_xscache();
1475 #if (!defined(AFS_NONFSTRANS) || defined(AFS_AIX_IAUTH_ENV))
1476     shutdown_exporter();
1477     shutdown_nfsclnt();
1478 #endif
1479     shutdown_afstest();
1480     shutdown_AFS();
1481     /* The following hold the cm stats */
1482     memset(&afs_cmstats, 0, sizeof(struct afs_CMStats));
1483     memset(&afs_stats_cmperf, 0, sizeof(struct afs_stats_CMPerf));
1484     memset(&afs_stats_cmfullperf, 0, sizeof(struct afs_stats_CMFullPerf));
1485     afs_warn(" ALL allocated tables... ");
1486
1487     afs_shuttingdown = AFS_RUNNING;
1488     afs_warn("done\n");
1489
1490     return;                     /* Just kill daemons for now */
1491 }
1492
1493 void
1494 shutdown_afstest(void)
1495 {
1496     AFS_STATCNT(shutdown_afstest);
1497     afs_initState = afs_termState = 0;
1498     AFS_Running = afs_CB_Running = 0;
1499     afs_CacheInit_Done = afs_Go_Done = 0;
1500     if (afs_cold_shutdown) {
1501         *afs_rootVolumeName = 0;
1502     }
1503 }