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