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_LINUX24_ENV) && defined(HAVE_LINUX_COMPLETION_H)) || 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_LINUX24_ENV) && defined(HAVE_LINUX_COMPLETION_H)
 280 struct afsd_thread_info {
 281 # if defined(AFS_LINUX26_ENV) && !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 #if 0
 915             /* wait for basic init - XXX can't find any reason we need this? */
 916             while (afs_initState < AFSOP_START_BKG)
 917                 afs_osi_Sleep(&afs_initState);
 918 #endif
 919
 920             AFS_COPYIN(AFSKPTR(parm2), (caddr_t)tcell->hosts, sizeof(tcell->hosts),
 921                        code);
 922         }
 923         if (!code) {
 924             AFS_COPYINSTR(AFSKPTR(parm3), tbuffer1, AFS_SMALLOCSIZ,
 925                           &bufferSize, code);
 926             if (!code) {
 927                 if (parm4 & 4) {
 928                     AFS_COPYINSTR(AFSKPTR(parm5), tbuffer, AFS_SMALLOCSIZ,
 929                                   &bufferSize, code);
 930                     if (!code) {
 931                         lcnamep = tbuffer;
 932                         cflags |= CLinkedCell;
 933                     }
 934                 }
 935                 if (parm4 & 8) {
 936                     cflags |= CHush;
 937                 }
 938                 if (!code)
 939                     code =
 940                         afs_NewCell(tbuffer1, tcell->hosts, cflags, lcnamep,
 941                                     0, 0, 0);
 942             }
 943         }
 944         afs_osi_Free(tcell, sizeof(struct afsop_cell));
 945         osi_FreeSmallSpace(tbuffer);
 946         osi_FreeSmallSpace(tbuffer1);
 947     } else if (parm == AFSOP_ADDCELLALIAS) {
 948         /*
 949          * Call arguments:
 950          * parm2 is the alias name
 951          * parm3 is the real cell name
 952          */
 953         char *aliasName = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
 954         char *cellName = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
 955
 956         code = afs_InitDynroot();
 957         if (!code) {
 958             AFS_COPYINSTR(AFSKPTR(parm2), aliasName, AFS_SMALLOCSIZ, &bufferSize,
 959                           code);
 960         }
 961         if (!code)
 962             AFS_COPYINSTR(AFSKPTR(parm3), cellName, AFS_SMALLOCSIZ,
 963                           &bufferSize, code);
 964         if (!code)
 965             afs_NewCellAlias(aliasName, cellName);
 966         osi_FreeSmallSpace(aliasName);
 967         osi_FreeSmallSpace(cellName);
 968     } else if (parm == AFSOP_SET_THISCELL) {
 969         /*
 970          * Call arguments:
 971          * parm2 is the primary cell name
 972          */
 973         char *cell = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
 974
 975         afs_CellInit();
 976         AFS_COPYINSTR(AFSKPTR(parm2), cell, AFS_SMALLOCSIZ, &bufferSize, code);
 977         if (!code)
 978             afs_SetPrimaryCell(cell);
 979         osi_FreeSmallSpace(cell);
 980         if (!code) {
 981             code = afs_InitDynroot();
 982         }
 983     } else if (parm == AFSOP_CACHEINIT) {
 984         struct afs_cacheParams cparms;
 985
 986         if (afs_CacheInit_Done)
 987             goto out;
 988
 989         AFS_COPYIN(AFSKPTR(parm2), (caddr_t) & cparms, sizeof(cparms), code);
 990         if (code) {
 991 #if defined(KERNEL_HAVE_UERROR)
 992             setuerror(code);
 993             code = -1;
 994 #endif
 995             goto out;
 996         }
 997         afs_CacheInit_Done = 1;
 998         code = afs_icl_InitLogs();
 999         if (cparms.setTimeFlag) {
1000             afs_warn("afs: AFSOP_CACHEINIT setTimeFlag ignored; are you "
1001                      "running an old afsd?\n");
1002         }
1003
1004         code =
1005             afs_CacheInit(cparms.cacheScaches, cparms.cacheFiles,
1006                           cparms.cacheBlocks, cparms.cacheDcaches,
1007                           cparms.cacheVolumes, cparms.chunkSize,
1008                           cparms.memCacheFlag, cparms.inodes, cparms.users,
1009                           cparms.dynamic_vcaches);
1010
1011     } else if (parm == AFSOP_CACHEINODE) {
1012         ino_t ainode = parm2;
1013         /* wait for basic init */
1014         while (afs_initState < AFSOP_START_BKG)
1015             afs_osi_Sleep(&afs_initState);
1016
1017 #ifdef AFS_DARWIN80_ENV
1018         get_vfs_context();
1019 #endif
1020         /* do it by inode */
1021 #ifdef AFS_SGI62_ENV
1022         ainode = (ainode << 32) | (parm3 & 0xffffffff);
1023 #endif
1024         code = afs_InitCacheFile(NULL, ainode);
1025 #ifdef AFS_DARWIN80_ENV
1026         put_vfs_context();
1027 #endif
1028     } else if (parm == AFSOP_CACHEDIRS) {
1029         afs_numfilesperdir = parm2;
1030         afs_osi_Wakeup(&afs_initState);
1031     } else if (parm == AFSOP_CACHEFILES) {
1032         afs_numcachefiles = parm2;
1033         afs_osi_Wakeup(&afs_initState);
1034     } else if (parm == AFSOP_ROOTVOLUME) {
1035         /* wait for basic init */
1036         while (afs_initState < AFSOP_START_BKG)
1037             afs_osi_Sleep(&afs_initState);
1038
1039         if (parm2) {
1040             AFS_COPYINSTR(AFSKPTR(parm2), afs_rootVolumeName,
1041                           sizeof(afs_rootVolumeName), &bufferSize, code);
1042             afs_rootVolumeName[sizeof(afs_rootVolumeName) - 1] = 0;
1043         } else
1044             code = 0;
1045     } else if (parm == AFSOP_CACHEFILE || parm == AFSOP_CACHEINFO
1046                || parm == AFSOP_VOLUMEINFO || parm == AFSOP_CELLINFO) {
1047         char *tbuffer = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
1048
1049         code = 0;
1050         AFS_COPYINSTR(AFSKPTR(parm2), tbuffer, AFS_SMALLOCSIZ, &bufferSize,
1051                       code);
1052         if (!code) {
1053             tbuffer[AFS_SMALLOCSIZ - 1] = '\0'; /* null-terminate the name */
1054             /* We have the cache dir copied in.  Call the cache init routine */
1055 #ifdef AFS_DARWIN80_ENV
1056             get_vfs_context();
1057 #endif
1058             if (parm == AFSOP_CACHEFILE) {
1059                 code = afs_InitCacheFile(tbuffer, 0);
1060             } else if (parm == AFSOP_CACHEINFO) {
1061                 code = afs_InitCacheInfo(tbuffer);
1062             } else if (parm == AFSOP_VOLUMEINFO) {
1063                 code = afs_InitVolumeInfo(tbuffer);
1064             } else if (parm == AFSOP_CELLINFO) {
1065                 code = afs_InitCellInfo(tbuffer);
1066             }
1067 #ifdef AFS_DARWIN80_ENV
1068             put_vfs_context();
1069 #endif
1070         }
1071         osi_FreeSmallSpace(tbuffer);
1072     } else if (parm == AFSOP_GO) {
1073         /* the generic initialization calls come here.  One parameter: should we do the
1074          * set-time operation on this workstation */
1075         if (afs_Go_Done)
1076             goto out;
1077         afs_Go_Done = 1;
1078         while (afs_initState < AFSOP_GO)
1079             afs_osi_Sleep(&afs_initState);
1080         afs_initState = 101;
1081         if (parm2) {
1082             /* parm2 used to set afs_setTime */
1083             afs_warn("afs: AFSOP_GO setTime flag ignored; are you running an "
1084                      "old afsd?\n");
1085         }
1086         if (afs_tpct1 + afs_tpct2 != 100) {
1087             afs_tpct1 = 0;
1088             afs_tpct2 = 0;
1089             splitdcache = 0;
1090         } else {
1091             splitdcache = 1;
1092         }
1093         afs_osi_Wakeup(&afs_initState);
1094 #if     (!defined(AFS_NONFSTRANS)) || defined(AFS_AIX_IAUTH_ENV)
1095         afs_nfsclient_init();
1096 #endif
1097         if (afs_uuid_create(&afs_cb_interface.uuid) != 0)
1098             memset(&afs_cb_interface.uuid, 0, sizeof(afsUUID));
1099
1100         printf("found %d non-empty cache files (%d%%).\n",
1101                afs_stats_cmperf.cacheFilesReused,
1102                (100 * afs_stats_cmperf.cacheFilesReused) /
1103                (afs_stats_cmperf.cacheNumEntries ? afs_stats_cmperf.
1104                 cacheNumEntries : 1));
1105     } else if (parm == AFSOP_ADVISEADDR) {
1106         /* pass in the host address to the rx package */
1107         int rxbind = 0;
1108         int refresh = 0;
1109
1110         afs_int32 count = parm2;
1111         afs_int32 *buffer =
1112             afs_osi_Alloc(sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
1113         afs_int32 *maskbuffer =
1114             afs_osi_Alloc(sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
1115         afs_int32 *mtubuffer =
1116             afs_osi_Alloc(sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
1117         int i;
1118
1119         osi_Assert(buffer != NULL);
1120         osi_Assert(maskbuffer != NULL);
1121         osi_Assert(mtubuffer != NULL);
1122         /* This is a refresh */
1123         if (count & 0x40000000) {
1124             count &= ~0x40000000;
1125             /* Can't bind after we start. Fix? */
1126             count &= ~0x80000000;
1127             refresh = 1;
1128         }
1129
1130         /* Bind, but only if there's only one address configured */
1131         if ( count & 0x80000000) {
1132             count &= ~0x80000000;
1133             if (count == 1)
1134                 rxbind=1;
1135         }
1136
1137         if (count > AFS_MAX_INTERFACE_ADDR) {
1138             code = ENOMEM;
1139             count = AFS_MAX_INTERFACE_ADDR;
1140         }
1141
1142         AFS_COPYIN(AFSKPTR(parm3), (caddr_t)buffer, count * sizeof(afs_int32),
1143                    code);
1144         if (parm4 && !code)
1145             AFS_COPYIN(AFSKPTR(parm4), (caddr_t)maskbuffer,
1146                        count * sizeof(afs_int32), code);
1147         if (parm5 && !code)
1148             AFS_COPYIN(AFSKPTR(parm5), (caddr_t)mtubuffer,
1149                        count * sizeof(afs_int32), code);
1150
1151         if (!code) {
1152             afs_cb_interface.numberOfInterfaces = count;
1153             for (i = 0; i < count; i++) {
1154                 afs_cb_interface.addr_in[i] = buffer[i];
1155 #ifdef AFS_USERSPACE_IP_ADDR
1156                 /* AFS_USERSPACE_IP_ADDR means we have no way of finding the
1157                  * machines IP addresses when in the kernel (the in_ifaddr
1158                  * struct is not available), so we pass the info in at
1159                  * startup. We also pass in the subnetmask and mtu size. The
1160                  * subnetmask is used when setting the rank:
1161                  * afsi_SetServerIPRank(); and the mtu size is used when
1162                  * finding the best mtu size. rxi_FindIfnet() is replaced
1163                  * with rxi_Findcbi().
1164                  */
1165                 afs_cb_interface.subnetmask[i] =
1166                     (parm4 ? maskbuffer[i] : 0xffffffff);
1167                 afs_cb_interface.mtu[i] = (parm5 ? mtubuffer[i] : htonl(1500));
1168 #endif
1169             }
1170             rxi_setaddr(buffer[0]);
1171             if (!refresh) {
1172                 if (rxbind)
1173                     rx_bindhost = buffer[0];
1174                 else
1175                     rx_bindhost = htonl(INADDR_ANY);
1176             }
1177         } else {
1178             refresh = 0;
1179         }
1180
1181         afs_osi_Free(buffer, sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
1182         afs_osi_Free(maskbuffer, sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
1183         afs_osi_Free(mtubuffer, sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
1184
1185         if (refresh) {
1186             afs_CheckServers(1, NULL);     /* check down servers */
1187             afs_CheckServers(0, NULL);     /* check up servers */
1188         }
1189     }
1190     else if (parm == AFSOP_SHUTDOWN) {
1191         afs_cold_shutdown = 0;
1192         if (parm2 == 1)
1193             afs_cold_shutdown = 1;
1194         if (afs_globalVFS != 0) {
1195             afs_warn("AFS isn't unmounted yet! Call aborted\n");
1196             code = EACCES;
1197         } else
1198             afs_shutdown();
1199     } else if (parm == AFSOP_AFS_VFSMOUNT) {
1200 #ifdef  AFS_HPUX_ENV
1201         vfsmount(parm2, parm3, parm4, parm5);
1202 #else /* defined(AFS_HPUX_ENV) */
1203 # if defined(KERNEL_HAVE_UERROR)
1204         setuerror(EINVAL);
1205 # else
1206         code = EINVAL;
1207 # endif
1208 #endif /* defined(AFS_HPUX_ENV) */
1209     } else if (parm == AFSOP_CLOSEWAIT) {
1210         afs_SynchronousCloses = 'S';
1211     } else if (parm == AFSOP_GETMTU) {
1212         afs_uint32 mtu = 0;
1213 #if     !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV)
1214 # ifdef AFS_USERSPACE_IP_ADDR
1215         afs_int32 i;
1216         i = rxi_Findcbi(parm2);
1217         mtu = ((i == -1) ? htonl(1500) : afs_cb_interface.mtu[i]);
1218 # else /* AFS_USERSPACE_IP_ADDR */
1219         rx_ifnet_t tifnp;
1220
1221         tifnp = rxi_FindIfnet(parm2, NULL);     /*  make iterative */
1222         mtu = (tifnp ? rx_ifnet_mtu(tifnp) : htonl(1500));
1223 # endif /* else AFS_USERSPACE_IP_ADDR */
1224 #endif /* !AFS_SUN5_ENV */
1225         if (!code)
1226             AFS_COPYOUT((caddr_t) & mtu, AFSKPTR(parm3),
1227                         sizeof(afs_int32), code);
1228 #ifdef AFS_AIX32_ENV
1229 /* this is disabled for now because I can't figure out how to get access
1230  * to these kernel variables.  It's only for supporting user-mode rx
1231  * programs -- it makes a huge difference on the 220's in my testbed,
1232  * though I don't know why. The bosserver does this with /etc/no, so it's
1233  * being handled a different way for the servers right now.  */
1234 /*      {
1235         static adjusted = 0;
1236         extern u_long sb_max_dflt;
1237         if (!adjusted) {
1238           adjusted = 1;
1239           if (sb_max_dflt < 131072) sb_max_dflt = 131072;
1240           if (sb_max < 131072) sb_max = 131072;
1241         }
1242       } */
1243 #endif /* AFS_AIX32_ENV */
1244     } else if (parm == AFSOP_GETMASK) { /* parm2 == addr in net order */
1245         afs_uint32 mask = 0;
1246 #if     !defined(AFS_SUN5_ENV)
1247 # ifdef AFS_USERSPACE_IP_ADDR
1248         afs_int32 i;
1249         i = rxi_Findcbi(parm2);
1250         if (i != -1) {
1251             mask = afs_cb_interface.subnetmask[i];
1252         } else {
1253             code = -1;
1254         }
1255 # else /* AFS_USERSPACE_IP_ADDR */
1256         rx_ifnet_t tifnp;
1257
1258         tifnp = rxi_FindIfnet(parm2, &mask);    /* make iterative */
1259         if (!tifnp)
1260             code = -1;
1261 # endif /* else AFS_USERSPACE_IP_ADDR */
1262 #endif /* !AFS_SUN5_ENV */
1263         if (!code)
1264             AFS_COPYOUT((caddr_t) & mask, AFSKPTR(parm3),
1265                         sizeof(afs_int32), code);
1266     }
1267     else if (parm == AFSOP_AFSDB_HANDLER) {
1268         int sizeArg = (int)parm4;
1269         int kmsgLen = sizeArg & 0xffff;
1270         int cellLen = (sizeArg & 0xffff0000) >> 16;
1271         afs_int32 *kmsg = afs_osi_Alloc(kmsgLen);
1272         char *cellname = afs_osi_Alloc(cellLen);
1273
1274         osi_Assert(kmsg != NULL);
1275         osi_Assert(cellname != NULL);
1276 #ifndef UKERNEL
1277         afs_osi_MaskUserLoop();
1278 #endif
1279         AFS_COPYIN(AFSKPTR(parm2), cellname, cellLen, code);
1280         AFS_COPYIN(AFSKPTR(parm3), kmsg, kmsgLen, code);
1281         if (!code) {
1282             code = afs_AFSDBHandler(cellname, cellLen, kmsg);
1283             if (*cellname == 1)
1284                 *cellname = 0;
1285             if (code == -2) {   /* Shutting down? */
1286                 *cellname = 1;
1287                 code = 0;
1288             }
1289         }
1290         if (!code)
1291             AFS_COPYOUT(cellname, AFSKPTR(parm2), cellLen, code);
1292         afs_osi_Free(kmsg, kmsgLen);
1293         afs_osi_Free(cellname, cellLen);
1294     }
1295     else if (parm == AFSOP_SET_DYNROOT) {
1296         code = afs_SetDynrootEnable(parm2);
1297     } else if (parm == AFSOP_SET_FAKESTAT) {
1298         afs_fakestat_enable = parm2;
1299         code = 0;
1300     } else if (parm == AFSOP_SET_BACKUPTREE) {
1301         afs_bkvolpref = parm2;
1302     } else if (parm == AFSOP_SET_RXPCK) {
1303         rx_extraPackets = parm2;
1304         afscall_set_rxpck_received = 1;
1305     } else if (parm == AFSOP_SET_RXMAXMTU) {
1306         rx_MyMaxSendSize = rx_maxReceiveSizeUser = rx_maxReceiveSize = parm2;
1307     } else if (parm == AFSOP_SET_RXMAXFRAGS) {
1308         rxi_nSendFrags = rxi_nRecvFrags = parm2;
1309     } else if (parm == AFSOP_SET_RMTSYS_FLAG) {
1310         afs_rmtsys_enable = parm2;
1311         code = 0;
1312 #ifndef UKERNEL
1313     } else if (parm == AFSOP_SEED_ENTROPY) {
1314         unsigned char *seedbuf;
1315
1316         if (parm3 > 4096) {
1317             code = EFAULT;
1318         } else {
1319             seedbuf = afs_osi_Alloc(parm3);
1320             AFS_COPYIN(AFSKPTR(parm2), seedbuf, parm3, code);
1321             RAND_seed(seedbuf, parm3);
1322             memset(seedbuf, 0, parm3);
1323             afs_osi_Free(seedbuf, parm3);
1324         }
1325 #endif
1326     } else {
1327         code = EINVAL;
1328     }
1329
1330   out:
1331     AFS_GUNLOCK();
1332 #ifdef AFS_LINUX20_ENV
1333     return -code;
1334 #else
1335     return code;
1336 #endif
1337 }
1338
1339 /*
1340  * Initstate in the range 0 < x < 100 are early initialization states.
1341  * Initstate of 100 means a AFSOP_START operation has been done.  After this,
1342  *  the cache may be initialized.
1343  * Initstate of 101 means a AFSOP_GO operation has been done.  This operation
1344  *  is done after all the cache initialization has been done.
1345  * Initstate of 200 means that the volume has been looked up once, possibly
1346  *  incorrectly.
1347  * Initstate of 300 means that the volume has been *successfully* looked up.
1348  */
1349 int
1350 afs_CheckInit(void)
1351 {
1352     int code = 0;
1353
1354     AFS_STATCNT(afs_CheckInit);
1355     if (afs_initState <= 100)
1356         code = ENXIO;           /* never finished init phase */
1357     else if (afs_initState == 101) {    /* init done, wait for afs_daemon */
1358         while (afs_initState < 200)
1359             afs_osi_Sleep(&afs_initState);
1360     } else if (afs_initState == 200)
1361         code = ETIMEDOUT;       /* didn't find root volume */
1362     return code;
1363 }
1364
1365 enum afs_shutdown_state afs_shuttingdown = AFS_RUNNING;
1366 void
1367 afs_shutdown(void)
1368 {
1369     extern short afs_brsDaemons;
1370     extern afs_int32 afs_CheckServerDaemonStarted;
1371     extern struct afs_osi_WaitHandle AFS_WaitHandler, AFS_CSWaitHandler;
1372     extern struct osi_file *afs_cacheInodep;
1373
1374     AFS_STATCNT(afs_shutdown);
1375     if (afs_initState == 0) {
1376         afs_warn("AFS not initialized - not shutting down\n");
1377       return;
1378     }
1379
1380     if (afs_shuttingdown != AFS_RUNNING)
1381         return;
1382
1383     afs_shuttingdown = AFS_FLUSHING_CB;
1384
1385     /* Give up all of our callbacks if we can. */
1386     afs_FlushVCBs(2);
1387
1388     afs_shuttingdown = AFS_SHUTDOWN;
1389
1390     if (afs_cold_shutdown)
1391         afs_warn("afs: COLD ");
1392     else
1393         afs_warn("afs: WARM ");
1394     afs_warn("shutting down of: vcaches... ");
1395
1396 #if !defined(AFS_FBSD_ENV)
1397     /* The FBSD afs_unmount() calls vflush(), which reclaims all vnodes
1398      * on the mountpoint, flushing them in the process.  In the presence
1399      * of bugs, flushing again here can cause panics. */
1400     afs_FlushAllVCaches();
1401 #endif
1402
1403     afs_termState = AFSOP_STOP_BKG;
1404
1405     afs_warn("BkG... ");
1406     /* Wake-up afs_brsDaemons so that we don't have to wait for a bkg job! */
1407     while (afs_termState == AFSOP_STOP_BKG) {
1408         afs_osi_Wakeup(&afs_brsDaemons);
1409         afs_osi_Sleep(&afs_termState);
1410     }
1411
1412     afs_warn("CB... ");
1413
1414     afs_termState = AFSOP_STOP_RXCALLBACK;
1415     rx_WakeupServerProcs();
1416 #ifdef AFS_AIX51_ENV
1417     shutdown_rxkernel();
1418 #endif
1419     /* close rx server connections here? */
1420     while (afs_termState == AFSOP_STOP_RXCALLBACK)
1421         afs_osi_Sleep(&afs_termState);
1422
1423     afs_warn("afs... ");
1424     while (afs_termState == AFSOP_STOP_AFS) {
1425         afs_osi_CancelWait(&AFS_WaitHandler);
1426         afs_osi_Sleep(&afs_termState);
1427     }
1428     if (afs_CheckServerDaemonStarted) {
1429         while (afs_termState == AFSOP_STOP_CS) {
1430             afs_osi_CancelWait(&AFS_CSWaitHandler);
1431             afs_osi_Sleep(&afs_termState);
1432         }
1433     }
1434     afs_warn("CTrunc... ");
1435     /* Cancel cache truncate daemon. */
1436     while (afs_termState == AFSOP_STOP_TRUNCDAEMON) {
1437         afs_osi_Wakeup((char *)&afs_CacheTruncateDaemon);
1438         afs_osi_Sleep(&afs_termState);
1439     }
1440     afs_warn("AFSDB... ");
1441     afs_StopAFSDB();
1442     while (afs_termState == AFSOP_STOP_AFSDB)
1443         afs_osi_Sleep(&afs_termState);
1444 #if     defined(AFS_SUN5_ENV) || defined(RXK_LISTENER_ENV) || defined(RXK_UPCALL_ENV)
1445     afs_warn("RxEvent... ");
1446     /* cancel rx event daemon */
1447     while (afs_termState == AFSOP_STOP_RXEVENT)
1448         afs_osi_Sleep(&afs_termState);
1449 # if defined(RXK_LISTENER_ENV)
1450 #  ifndef UKERNEL
1451     afs_warn("UnmaskRxkSignals... ");
1452     afs_osi_UnmaskRxkSignals();
1453 #  endif
1454     /* cancel rx listener */
1455     afs_warn("RxListener... ");
1456     osi_StopListener();         /* This closes rx_socket. */
1457     while (afs_termState == AFSOP_STOP_RXK_LISTENER) {
1458         afs_warn("Sleep... ");
1459         afs_osi_Sleep(&afs_termState);
1460     }
1461 # endif
1462 #endif
1463
1464 #if defined(AFS_SUN510_ENV) || defined(RXK_UPCALL_ENV)
1465     afs_warn("NetIfPoller... ");
1466     osi_StopNetIfPoller();
1467 #endif
1468
1469     afs_termState = AFSOP_STOP_COMPLETE;
1470
1471 #ifdef AFS_AIX51_ENV
1472     shutdown_daemons();
1473 #endif
1474     shutdown_CB();
1475     shutdown_bufferpackage();
1476     shutdown_cache();
1477     shutdown_osi();
1478     /*
1479      * Close file only after daemons which can write to it are stopped.
1480      * Need to close before the osinet shutdown to avoid failing check
1481      * for dangling memory allocations.
1482      */
1483     if (afs_cacheInodep) {      /* memcache won't set this */
1484         osi_UFSClose(afs_cacheInodep);  /* Since we always leave it open */
1485         afs_cacheInodep = 0;
1486     }
1487     /*
1488      * Shutdown the ICL logs - needed to free allocated memory space and avoid
1489      * warnings from shutdown_osinet
1490      */
1491     shutdown_icl();
1492     shutdown_osinet();
1493     shutdown_osifile();
1494     shutdown_vnodeops();
1495     shutdown_memcache();
1496     shutdown_xscache();
1497 #if (!defined(AFS_NONFSTRANS) || defined(AFS_AIX_IAUTH_ENV))
1498     shutdown_exporter();
1499     shutdown_nfsclnt();
1500 #endif
1501     shutdown_afstest();
1502     shutdown_AFS();
1503     /* The following hold the cm stats */
1504     memset(&afs_cmstats, 0, sizeof(struct afs_CMStats));
1505     memset(&afs_stats_cmperf, 0, sizeof(struct afs_stats_CMPerf));
1506     memset(&afs_stats_cmfullperf, 0, sizeof(struct afs_stats_CMFullPerf));
1507     afs_warn(" ALL allocated tables... ");
1508
1509     afs_shuttingdown = AFS_RUNNING;
1510     afs_warn("done\n");
1511
1512     return;                     /* Just kill daemons for now */
1513 }
1514
1515 void
1516 shutdown_afstest(void)
1517 {
1518     AFS_STATCNT(shutdown_afstest);
1519     afs_initState = afs_termState = 0;
1520     AFS_Running = afs_CB_Running = 0;
1521     afs_CacheInit_Done = afs_Go_Done = 0;
1522     if (afs_cold_shutdown) {
1523         *afs_rootVolumeName = 0;
1524     }
1525 }