e24855d6e5289fdd511e8c6031cf4ab8170b8403
[openafs.git] / 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 RCSID
14     ("$Header$");
15
16 #include "afs/sysincludes.h"    /* Standard vendor system headers */
17 #include "afsincludes.h"        /* Afs-based standard headers */
18 #include "afs/afs_stats.h"
19 #include "rx/rx_globals.h"
20 #if !defined(UKERNEL) && !defined(AFS_LINUX20_ENV)
21 #include "net/if.h"
22 #ifdef AFS_SGI62_ENV
23 #include "h/hashing.h"
24 #endif
25 #if !defined(AFS_HPUX110_ENV) && !defined(AFS_DARWIN60_ENV)
26 #include "netinet/in_var.h"
27 #endif
28 #endif /* !defined(UKERNEL) */
29 #ifdef AFS_LINUX22_ENV
30 #include "h/smp_lock.h"
31 #endif
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 struct afsop_cell {
44     afs_int32 hosts[MAXCELLHOSTS];
45     char cellName[100];
46 };
47
48 char afs_zeros[AFS_ZEROS];
49 char afs_rootVolumeName[64] = "";
50 afs_uint32 rx_bindhost;
51
52 #ifdef AFS_SUN510_ENV
53 ddi_taskq_t *afs_taskq;
54 krwlock_t afsifinfo_lock;
55 #endif
56
57 afs_int32 afs_initState = 0;
58 afs_int32 afs_termState = 0;
59 afs_int32 afs_setTime = 0;
60 int afs_cold_shutdown = 0;
61 char afs_SynchronousCloses = '\0';
62 static int afs_CB_Running = 0;
63 static int AFS_Running = 0;
64 static int afs_CacheInit_Done = 0;
65 static int afs_Go_Done = 0;
66 extern struct interfaceAddr afs_cb_interface;
67 static int afs_RX_Running = 0;
68 static int afs_InitSetup_done = 0;
69
70 afs_int32 afs_rx_deadtime = AFS_RXDEADTIME;
71 afs_int32 afs_rx_harddead = AFS_HARDDEADTIME;
72
73 static int afscall_set_rxpck_received = 0;
74
75 #if defined(AFS_HPUX_ENV)
76 extern int afs_vfs_mount();
77 #endif /* defined(AFS_HPUX_ENV) */
78
79 /* This is code which needs to be called once when the first daemon enters
80  * the client. A non-zero return means an error and AFS should not start.
81  */
82 static int
83 afs_InitSetup(int preallocs)
84 {
85     extern void afs_InitStats();
86     int code;
87
88     if (afs_InitSetup_done)
89         return EAGAIN;
90
91 #ifdef AFS_SUN510_ENV
92     /* Initialize a RW lock for the ifinfo global array */
93     rw_init(&afsifinfo_lock, NULL, RW_DRIVER, NULL);
94
95     /* Create a taskq */
96     afs_taskq = ddi_taskq_create(NULL, "afs_taskq", 2, TASKQ_DEFAULTPRI, 0);
97
98     osi_StartNetIfPoller();
99 #endif
100
101 #ifndef AFS_NOSTATS
102     /*
103      * Set up all the AFS statistics variables.  This should be done
104      * exactly once, and it should be done here, the first resource-setting
105      * routine to be called by the CM/RX.
106      */
107     afs_InitStats();
108 #endif /* AFS_NOSTATS */
109
110     memset(afs_zeros, 0, AFS_ZEROS);
111
112     /* start RX */
113     if(!afscall_set_rxpck_received)
114     rx_extraPackets = AFS_NRXPACKETS;   /* smaller # of packets */
115     code = rx_InitHost(rx_bindhost, htons(7001));
116     if (code) {
117         printf("AFS: RX failed to initialize %d).\n", code);
118         return code;
119     }
120     rx_SetRxDeadTime(afs_rx_deadtime);
121     /* resource init creates the services */
122     afs_ResourceInit(preallocs);
123
124     afs_InitSetup_done = 1;
125     afs_osi_Wakeup(&afs_InitSetup_done);
126
127     return code;
128 }
129 #if defined(AFS_DARWIN80_ENV)
130 struct afsd_thread_info {
131     unsigned long parm;
132 };
133 static int
134 afsd_thread(int *rock)
135 {
136     struct afsd_thread_info *arg = (struct afsd_thread_info *)rock;
137     unsigned long parm = arg->parm;
138
139     switch (parm) {
140     case AFSOP_START_RXCALLBACK:
141         AFS_GLOCK();
142         wakeup(arg);
143         afs_CB_Running = 1;
144         while (afs_RX_Running != 2)
145             afs_osi_Sleep(&afs_RX_Running);
146         afs_RXCallBackServer();
147         AFS_GUNLOCK();
148         thread_terminate(current_thread());
149         break;
150     case AFSOP_START_AFS:
151         AFS_GLOCK();
152         wakeup(arg);
153         AFS_Running = 1;
154         while (afs_initState < AFSOP_START_AFS)
155             afs_osi_Sleep(&afs_initState);
156         afs_initState = AFSOP_START_BKG;
157         afs_osi_Wakeup(&afs_initState);
158         afs_Daemon();
159         AFS_GUNLOCK();
160         thread_terminate(current_thread());
161         break;
162     case AFSOP_START_BKG:
163         AFS_GLOCK();
164         wakeup(arg);
165         while (afs_initState < AFSOP_START_BKG)
166             afs_osi_Sleep(&afs_initState);
167         if (afs_initState < AFSOP_GO) {
168             afs_initState = AFSOP_GO;
169             afs_osi_Wakeup(&afs_initState);
170         }
171         afs_BackgroundDaemon();
172         AFS_GUNLOCK();
173         thread_terminate(current_thread());
174         break;
175     case AFSOP_START_TRUNCDAEMON:
176         AFS_GLOCK();
177         wakeup(arg);
178         while (afs_initState < AFSOP_GO)
179             afs_osi_Sleep(&afs_initState);
180         afs_CacheTruncateDaemon();
181         AFS_GUNLOCK();
182         thread_terminate(current_thread());
183         break;
184     case AFSOP_START_CS:
185         AFS_GLOCK();
186         wakeup(arg);
187         afs_CheckServerDaemon();
188         AFS_GUNLOCK();
189         thread_terminate(current_thread());
190         break;
191     case AFSOP_RXEVENT_DAEMON:
192         AFS_GLOCK();
193         wakeup(arg);
194         while (afs_initState < AFSOP_START_BKG)
195             afs_osi_Sleep(&afs_initState);
196         afs_rxevent_daemon();
197         AFS_GUNLOCK();
198         thread_terminate(current_thread());
199         break;
200     case AFSOP_RXLISTENER_DAEMON:
201         AFS_GLOCK();
202         wakeup(arg);
203         afs_initState = AFSOP_START_AFS;
204         afs_osi_Wakeup(&afs_initState);
205         afs_RX_Running = 2;
206         afs_osi_Wakeup(&afs_RX_Running);
207         afs_osi_RxkRegister();
208         rxk_Listener();
209         AFS_GUNLOCK();
210         thread_terminate(current_thread());
211         break;
212     default:
213         printf("Unknown op %ld in StartDaemon()\n", (long)parm);
214         break;
215     }
216 }
217
218 void
219 afs_DaemonOp(long parm, long parm2, long parm3, long parm4, long parm5,
220              long parm6)
221 {
222     int code;
223     struct afsd_thread_info info;
224     thread_t thread;
225
226     if (parm == AFSOP_START_RXCALLBACK) {
227         if (afs_CB_Running)
228             return;
229     } else if (parm == AFSOP_RXLISTENER_DAEMON) {
230         if (afs_RX_Running)
231             return;
232         afs_RX_Running = 1;
233         code = afs_InitSetup(parm2);
234         if (parm3) {
235             rx_enablePeerRPCStats();
236         }
237         if (parm4) {
238             rx_enableProcessRPCStats();
239         }
240         if (code)
241             return;
242     } else if (parm == AFSOP_START_AFS) {
243         if (AFS_Running)
244             return;
245     }                           /* other functions don't need setup in the parent */
246     info.parm = parm;
247     kernel_thread_start((thread_continue_t)afsd_thread, &info, &thread);
248     AFS_GUNLOCK();
249     /* we need to wait cause we passed stack pointers around.... */
250     msleep(&info, NULL, PVFS, "afs_DaemonOp", NULL);
251     AFS_GLOCK();
252     thread_deallocate(thread);
253 }
254 #endif
255
256
257 #if defined(AFS_LINUX24_ENV) && defined(COMPLETION_H_EXISTS)
258 struct afsd_thread_info {
259 #if defined(AFS_LINUX26_ENV) && !defined(INIT_WORK_HAS_DATA)
260     struct work_struct tq;
261 #endif
262     unsigned long parm;
263     struct completion *complete;
264 };
265
266 static int
267 afsd_thread(void *rock)
268 {
269     struct afsd_thread_info *arg = rock;
270     unsigned long parm = arg->parm;
271 #ifdef SYS_SETPRIORITY_EXPORTED
272     int (*sys_setpriority) (int, int, int) = sys_call_table[__NR_setpriority];
273 #endif
274 #if defined(AFS_LINUX26_ENV)
275     daemonize("afsd");
276 #else
277     daemonize();
278 #endif
279                                 /* doesn't do much, since we were forked from keventd, but
280                                  * does call mm_release, which wakes up our parent (since it
281                                  * used CLONE_VFORK) */
282 #if !defined(AFS_LINUX26_ENV)
283     reparent_to_init();
284 #endif
285     afs_osi_MaskSignals();
286     switch (parm) {
287     case AFSOP_START_RXCALLBACK:
288         sprintf(current->comm, "afs_cbstart");
289         AFS_GLOCK();
290         complete(arg->complete);
291         afs_CB_Running = 1;
292         while (afs_RX_Running != 2)
293             afs_osi_Sleep(&afs_RX_Running);
294         sprintf(current->comm, "afs_callback");
295         afs_RXCallBackServer();
296         AFS_GUNLOCK();
297         complete_and_exit(0, 0);
298         break;
299     case AFSOP_START_AFS:
300         sprintf(current->comm, "afs_afsstart");
301         AFS_GLOCK();
302         complete(arg->complete);
303         AFS_Running = 1;
304         while (afs_initState < AFSOP_START_AFS)
305             afs_osi_Sleep(&afs_initState);
306         afs_initState = AFSOP_START_BKG;
307         afs_osi_Wakeup(&afs_initState);
308         sprintf(current->comm, "afsd");
309         afs_Daemon();
310         AFS_GUNLOCK();
311         complete_and_exit(0, 0);
312         break;
313     case AFSOP_START_BKG:
314         sprintf(current->comm, "afs_bkgstart");
315         AFS_GLOCK();
316         complete(arg->complete);
317         while (afs_initState < AFSOP_START_BKG)
318             afs_osi_Sleep(&afs_initState);
319         if (afs_initState < AFSOP_GO) {
320             afs_initState = AFSOP_GO;
321             afs_osi_Wakeup(&afs_initState);
322         }
323         sprintf(current->comm, "afs_background");
324         afs_BackgroundDaemon();
325         AFS_GUNLOCK();
326         complete_and_exit(0, 0);
327         break;
328     case AFSOP_START_TRUNCDAEMON:
329         sprintf(current->comm, "afs_trimstart");
330         AFS_GLOCK();
331         complete(arg->complete);
332         while (afs_initState < AFSOP_GO)
333             afs_osi_Sleep(&afs_initState);
334         sprintf(current->comm, "afs_cachetrim");
335         afs_CacheTruncateDaemon();
336         AFS_GUNLOCK();
337         complete_and_exit(0, 0);
338         break;
339     case AFSOP_START_CS:
340         sprintf(current->comm, "afs_checkserver");
341         AFS_GLOCK();
342         complete(arg->complete);
343         afs_CheckServerDaemon();
344         AFS_GUNLOCK();
345         complete_and_exit(0, 0);
346         break;
347     case AFSOP_RXEVENT_DAEMON:
348         sprintf(current->comm, "afs_evtstart");
349 #ifdef SYS_SETPRIORITY_EXPORTED
350         sys_setpriority(PRIO_PROCESS, 0, -10);
351 #else
352 #ifdef CURRENT_INCLUDES_NICE
353         current->nice = -10;
354 #endif
355 #endif
356         AFS_GLOCK();
357         complete(arg->complete);
358         while (afs_initState < AFSOP_START_BKG)
359             afs_osi_Sleep(&afs_initState);
360         sprintf(current->comm, "afs_rxevent");
361         afs_rxevent_daemon();
362         AFS_GUNLOCK();
363         complete_and_exit(0, 0);
364         break;
365     case AFSOP_RXLISTENER_DAEMON:
366         sprintf(current->comm, "afs_lsnstart");
367 #ifdef SYS_SETPRIORITY_EXPORTED
368         sys_setpriority(PRIO_PROCESS, 0, -10);
369 #else
370 #ifdef CURRENT_INCLUDES_NICE
371         current->nice = -10;
372 #endif
373 #endif
374         AFS_GLOCK();
375         complete(arg->complete);
376         afs_initState = AFSOP_START_AFS;
377         afs_osi_Wakeup(&afs_initState);
378         afs_RX_Running = 2;
379         afs_osi_Wakeup(&afs_RX_Running);
380         afs_osi_RxkRegister();
381         sprintf(current->comm, "afs_rxlistener");
382         rxk_Listener();
383         AFS_GUNLOCK();
384         complete_and_exit(0, 0);
385         break;
386     default:
387         printf("Unknown op %ld in StartDaemon()\n", (long)parm);
388         break;
389     }
390     return 0;
391 }
392
393 void
394 #if defined(AFS_LINUX26_ENV) && !defined(INIT_WORK_HAS_DATA)
395 afsd_launcher(struct work_struct *work)
396 #else
397 afsd_launcher(void *rock)
398 #endif
399 {
400 #if defined(AFS_LINUX26_ENV) && !defined(INIT_WORK_HAS_DATA)
401     struct afsd_thread_info *rock = container_of(work, struct afsd_thread_info, tq);
402 #endif
403
404     if (!kernel_thread(afsd_thread, (void *)rock, CLONE_VFORK | SIGCHLD))
405         printf("kernel_thread failed. afs startup will not complete\n");
406 }
407
408 void
409 afs_DaemonOp(long parm, long parm2, long parm3, long parm4, long parm5,
410              long parm6)
411 {
412     int code;
413     DECLARE_COMPLETION(c);
414 #if defined(AFS_LINUX26_ENV)
415     struct work_struct tq;
416 #else
417     struct tq_struct tq;
418 #endif
419     struct afsd_thread_info info;
420     if (parm == AFSOP_START_RXCALLBACK) {
421         if (afs_CB_Running)
422             return;
423     } else if (parm == AFSOP_RXLISTENER_DAEMON) {
424         if (afs_RX_Running)
425             return;
426         afs_RX_Running = 1;
427         code = afs_InitSetup(parm2);
428         if (parm3) {
429             rx_enablePeerRPCStats();
430         }
431         if (parm4) {
432             rx_enableProcessRPCStats();
433         }
434         if (code)
435             return;
436     } else if (parm == AFSOP_START_AFS) {
437         if (AFS_Running)
438             return;
439     }                           /* other functions don't need setup in the parent */
440     info.complete = &c;
441     info.parm = parm;
442 #if defined(AFS_LINUX26_ENV)
443 #if !defined(INIT_WORK_HAS_DATA)
444     INIT_WORK(&info.tq, afsd_launcher);
445     schedule_work(&info.tq);
446 #else
447     INIT_WORK(&tq, afsd_launcher, &info);
448     schedule_work(&tq);
449 #endif
450 #else
451     tq.sync = 0;
452     INIT_LIST_HEAD(&tq.list);
453     tq.routine = afsd_launcher;
454     tq.data = &info;
455     schedule_task(&tq);
456 #endif
457     AFS_GUNLOCK();
458     /* we need to wait cause we passed stack pointers around.... */
459     wait_for_completion(&c);
460     AFS_GLOCK();
461 }
462 #endif
463
464 /* leaving as is, probably will barf if we add prototypes here since it's likely being called
465 with partial list */
466 int
467 afs_syscall_call(parm, parm2, parm3, parm4, parm5, parm6)
468      long parm, parm2, parm3, parm4, parm5, parm6;
469 {
470     afs_int32 code = 0;
471 #if defined(AFS_SGI61_ENV) || defined(AFS_SUN57_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
472     size_t bufferSize;
473 #else /* AFS_SGI61_ENV */
474     u_int bufferSize;
475 #endif /* AFS_SGI61_ENV */
476
477     AFS_STATCNT(afs_syscall_call);
478     if (
479 #ifdef  AFS_SUN5_ENV
480         !afs_suser(CRED())
481 #else
482         !afs_suser(NULL)
483 #endif
484                     && (parm != AFSOP_GETMTU) && (parm != AFSOP_GETMASK)) {
485         /* only root can run this code */
486 #if defined(AFS_OSF_ENV) || defined(AFS_SUN5_ENV) || defined(KERNEL_HAVE_UERROR)
487 #if defined(KERNEL_HAVE_UERROR)
488         setuerror(EACCES);
489 #endif
490         code = EACCES;
491 #else
492         code = EPERM;
493 #endif
494         AFS_GLOCK();
495 #ifdef AFS_DARWIN80_ENV
496         put_vfs_context();
497 #endif
498         goto out;
499     }
500     AFS_GLOCK();
501 #ifdef AFS_DARWIN80_ENV
502     put_vfs_context();
503 #endif
504 #if ((defined(AFS_LINUX24_ENV) && defined(COMPLETION_H_EXISTS)) || defined(AFS_DARWIN80_ENV)) && !defined(UKERNEL)
505     if (parm < AFSOP_ADDCELL || parm == AFSOP_RXEVENT_DAEMON
506         || parm == AFSOP_RXLISTENER_DAEMON) {
507         afs_DaemonOp(parm, parm2, parm3, parm4, parm5, parm6);
508     }
509 #else /* !(AFS_LINUX24_ENV && !UKERNEL) */
510     if (parm == AFSOP_START_RXCALLBACK) {
511         if (afs_CB_Running)
512             goto out;
513         afs_CB_Running = 1;
514 #ifndef RXK_LISTENER_ENV
515         code = afs_InitSetup(parm2);
516         if (!code)
517 #endif /* !RXK_LISTENER_ENV */
518         {
519 #ifdef RXK_LISTENER_ENV
520             while (afs_RX_Running != 2)
521                 afs_osi_Sleep(&afs_RX_Running);
522 #else /* !RXK_LISTENER_ENV */
523             afs_initState = AFSOP_START_AFS;
524             afs_osi_Wakeup(&afs_initState);
525 #endif /* RXK_LISTENER_ENV */
526             afs_osi_Invisible();
527             afs_RXCallBackServer();
528         }
529 #ifdef AFS_SGI_ENV
530         AFS_GUNLOCK();
531         exit(CLD_EXITED, code);
532 #endif /* AFS_SGI_ENV */
533     }
534 #ifdef RXK_LISTENER_ENV
535     else if (parm == AFSOP_RXLISTENER_DAEMON) {
536         if (afs_RX_Running)
537             goto out;
538         afs_RX_Running = 1;
539         code = afs_InitSetup(parm2);
540         if (parm3) {
541             rx_enablePeerRPCStats();
542         }
543         if (parm4) {
544             rx_enableProcessRPCStats();
545         }
546         if (!code) {
547             afs_initState = AFSOP_START_AFS;
548             afs_osi_Wakeup(&afs_initState);
549             afs_osi_Invisible();
550             afs_RX_Running = 2;
551             afs_osi_Wakeup(&afs_RX_Running);
552 #ifndef UKERNEL
553             afs_osi_RxkRegister();
554 #endif /* !UKERNEL */
555             rxk_Listener();
556         }
557 #ifdef  AFS_SGI_ENV
558         AFS_GUNLOCK();
559         exit(CLD_EXITED, code);
560 #endif /* AFS_SGI_ENV */
561     }
562 #endif /* RXK_LISTENER_ENV */
563     else if (parm == AFSOP_START_AFS) {
564         /* afs daemon */
565         if (AFS_Running)
566             goto out;
567         AFS_Running = 1;
568         while (afs_initState < AFSOP_START_AFS)
569             afs_osi_Sleep(&afs_initState);
570
571         afs_initState = AFSOP_START_BKG;
572         afs_osi_Wakeup(&afs_initState);
573         afs_osi_Invisible();
574         afs_Daemon();
575 #ifdef AFS_SGI_ENV
576         AFS_GUNLOCK();
577         exit(CLD_EXITED, 0);
578 #endif /* AFS_SGI_ENV */
579     } else if (parm == AFSOP_START_CS) {
580         afs_osi_Invisible();
581         afs_CheckServerDaemon();
582 #ifdef AFS_SGI_ENV
583         AFS_GUNLOCK();
584         exit(CLD_EXITED, 0);
585 #endif /* AFS_SGI_ENV */
586     } else if (parm == AFSOP_START_BKG) {
587         while (afs_initState < AFSOP_START_BKG)
588             afs_osi_Sleep(&afs_initState);
589         if (afs_initState < AFSOP_GO) {
590             afs_initState = AFSOP_GO;
591             afs_osi_Wakeup(&afs_initState);
592         }
593         /* start the bkg daemon */
594         afs_osi_Invisible();
595 #ifdef AFS_AIX32_ENV
596         if (parm2)
597             afs_BioDaemon(parm2);
598         else
599 #endif /* AFS_AIX32_ENV */
600             afs_BackgroundDaemon();
601 #ifdef AFS_SGI_ENV
602         AFS_GUNLOCK();
603         exit(CLD_EXITED, 0);
604 #endif /* AFS_SGI_ENV */
605     } else if (parm == AFSOP_START_TRUNCDAEMON) {
606         while (afs_initState < AFSOP_GO)
607             afs_osi_Sleep(&afs_initState);
608         /* start the bkg daemon */
609         afs_osi_Invisible();
610         afs_CacheTruncateDaemon();
611 #ifdef  AFS_SGI_ENV
612         AFS_GUNLOCK();
613         exit(CLD_EXITED, 0);
614 #endif /* AFS_SGI_ENV */
615     }
616 #if defined(AFS_SUN5_ENV) || defined(RXK_LISTENER_ENV)
617     else if (parm == AFSOP_RXEVENT_DAEMON) {
618         while (afs_initState < AFSOP_START_BKG)
619             afs_osi_Sleep(&afs_initState);
620         afs_osi_Invisible();
621         afs_rxevent_daemon();
622 #ifdef AFS_SGI_ENV
623         AFS_GUNLOCK();
624         exit(CLD_EXITED, 0);
625 #endif /* AFS_SGI_ENV */
626     }
627 #endif /* AFS_SUN5_ENV || RXK_LISTENER_ENV */
628 #endif /* AFS_LINUX24_ENV && !UKERNEL */
629     else if (parm == AFSOP_BASIC_INIT) {
630         afs_int32 temp;
631
632         while (!afs_InitSetup_done)
633             afs_osi_Sleep(&afs_InitSetup_done);
634
635 #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)
636         temp = AFS_MINBUFFERS;  /* Should fix this soon */
637 #else
638         /* number of 2k buffers we could get from all of the buffer space */
639         temp = ((afs_bufferpages * NBPG) >> 11);
640         temp = temp >> 2;       /* don't take more than 25% (our magic parameter) */
641         if (temp < AFS_MINBUFFERS)
642             temp = AFS_MINBUFFERS;      /* though we really should have this many */
643 #endif
644         DInit(temp);
645         afs_rootFid.Fid.Volume = 0;
646         code = 0;
647     } else if (parm == AFSOP_BUCKETPCT) {
648         /* need to enable this now, will disable again before GO
649            if we don't have 100% */
650         splitdcache = 1;
651         switch (parm2) {
652         case 1:
653             afs_tpct1 = parm3;
654             break;
655         case 2:
656             afs_tpct2 = parm3;
657             break;
658         }           
659     } else if (parm == AFSOP_ADDCELL) {
660         /* add a cell.  Parameter 2 is 8 hosts (in net order),  parm 3 is the null-terminated
661          * name.  Parameter 4 is the length of the name, including the null.  Parm 5 is the
662          * home cell flag (0x1 bit) and the nosuid flag (0x2 bit) */
663         struct afsop_cell *tcell = afs_osi_Alloc(sizeof(struct afsop_cell));
664
665         code = afs_InitDynroot();
666         if (!code) {
667             AFS_COPYIN((char *)parm2, (char *)tcell->hosts, sizeof(tcell->hosts),
668                        code);
669         }
670         if (!code) {
671             if (parm4 > sizeof(tcell->cellName))
672                 code = EFAULT;
673             else {
674                 AFS_COPYIN((char *)parm3, tcell->cellName, parm4, code);
675                 if (!code)
676                     afs_NewCell(tcell->cellName, tcell->hosts, parm5, NULL, 0,
677                                 0, 0);
678             }
679         }
680         afs_osi_Free(tcell, sizeof(struct afsop_cell));
681     } else if (parm == AFSOP_ADDCELL2) {
682         struct afsop_cell *tcell = afs_osi_Alloc(sizeof(struct afsop_cell));
683         char *tbuffer = osi_AllocSmallSpace(AFS_SMALLOCSIZ), *lcnamep = 0;
684         char *tbuffer1 = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
685         int cflags = parm4;
686
687         code = afs_InitDynroot();
688         if (!code) {
689 #if 0
690             /* wait for basic init - XXX can't find any reason we need this? */
691             while (afs_initState < AFSOP_START_BKG)
692                 afs_osi_Sleep(&afs_initState);
693 #endif
694
695             AFS_COPYIN((char *)parm2, (char *)tcell->hosts, sizeof(tcell->hosts),
696                        code);
697         }
698         if (!code) {
699             AFS_COPYINSTR((char *)parm3, tbuffer1, AFS_SMALLOCSIZ,
700                           &bufferSize, code);
701             if (!code) {
702                 if (parm4 & 4) {
703                     AFS_COPYINSTR((char *)parm5, tbuffer, AFS_SMALLOCSIZ,
704                                   &bufferSize, code);
705                     if (!code) {
706                         lcnamep = tbuffer;
707                         cflags |= CLinkedCell;
708                     }
709                 }
710                 if (!code)
711                     code =
712                         afs_NewCell(tbuffer1, tcell->hosts, cflags, lcnamep,
713                                     0, 0, 0);
714             }
715         }
716         afs_osi_Free(tcell, sizeof(struct afsop_cell));
717         osi_FreeSmallSpace(tbuffer);
718         osi_FreeSmallSpace(tbuffer1);
719     } else if (parm == AFSOP_ADDCELLALIAS) {
720         /*
721          * Call arguments:
722          * parm2 is the alias name
723          * parm3 is the real cell name
724          */
725         char *aliasName = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
726         char *cellName = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
727
728         code = afs_InitDynroot();
729         if (!code) {
730             AFS_COPYINSTR((char *)parm2, aliasName, AFS_SMALLOCSIZ, &bufferSize,
731                           code);
732         }
733         if (!code)
734             AFS_COPYINSTR((char *)parm3, cellName, AFS_SMALLOCSIZ,
735                           &bufferSize, code);
736         if (!code)
737             afs_NewCellAlias(aliasName, cellName);
738         osi_FreeSmallSpace(aliasName);
739         osi_FreeSmallSpace(cellName);
740     } else if (parm == AFSOP_SET_THISCELL) {
741         /*
742          * Call arguments:
743          * parm2 is the primary cell name
744          */
745         char *cell = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
746
747         code = afs_InitDynroot();
748         if (!code) {
749             AFS_COPYINSTR((char *)parm2, cell, AFS_SMALLOCSIZ, &bufferSize, code);
750         }
751         if (!code)
752             afs_SetPrimaryCell(cell);
753         osi_FreeSmallSpace(cell);
754     } else if (parm == AFSOP_CACHEINIT) {
755         struct afs_cacheParams cparms;
756
757         if (afs_CacheInit_Done)
758             goto out;
759
760         AFS_COPYIN((char *)parm2, (caddr_t) & cparms, sizeof(cparms), code);
761         if (code) {
762 #if defined(KERNEL_HAVE_UERROR)
763             setuerror(code);
764             code = -1;
765 #endif
766             goto out;
767         }
768         afs_CacheInit_Done = 1;
769         code = afs_icl_InitLogs();
770         afs_setTime = cparms.setTimeFlag;
771
772         code =
773             afs_CacheInit(cparms.cacheScaches, cparms.cacheFiles,
774                           cparms.cacheBlocks, cparms.cacheDcaches,
775                           cparms.cacheVolumes, cparms.chunkSize,
776                           cparms.memCacheFlag, cparms.inodes, cparms.users);
777
778     } else if (parm == AFSOP_CACHEINODE) {
779         ino_t ainode = parm2;
780         /* wait for basic init */
781         while (afs_initState < AFSOP_START_BKG)
782             afs_osi_Sleep(&afs_initState);
783
784 #ifdef AFS_DARWIN80_ENV
785         get_vfs_context();
786 #endif
787         /* do it by inode */
788 #ifdef AFS_SGI62_ENV
789         ainode = (ainode << 32) | (parm3 & 0xffffffff);
790 #endif
791         code = afs_InitCacheFile(NULL, ainode);
792 #ifdef AFS_DARWIN80_ENV
793         put_vfs_context();
794 #endif
795     } else if (parm == AFSOP_ROOTVOLUME) {
796         /* wait for basic init */
797         while (afs_initState < AFSOP_START_BKG)
798             afs_osi_Sleep(&afs_initState);
799
800         if (parm2) {
801             AFS_COPYINSTR((char *)parm2, afs_rootVolumeName,
802                           sizeof(afs_rootVolumeName), &bufferSize, code);
803             afs_rootVolumeName[sizeof(afs_rootVolumeName) - 1] = 0;
804         } else
805             code = 0;
806     } else if (parm == AFSOP_CACHEFILE || parm == AFSOP_CACHEINFO
807                || parm == AFSOP_VOLUMEINFO || parm == AFSOP_AFSLOG
808                || parm == AFSOP_CELLINFO) {
809         char *tbuffer = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
810
811         code = 0;
812         AFS_COPYINSTR((char *)parm2, tbuffer, AFS_SMALLOCSIZ, &bufferSize,
813                       code);
814         if (code) {
815             osi_FreeSmallSpace(tbuffer);
816             goto out;
817         }
818         if (!code) {
819             tbuffer[AFS_SMALLOCSIZ - 1] = '\0'; /* null-terminate the name */
820             /* We have the cache dir copied in.  Call the cache init routine */
821 #ifdef AFS_DARWIN80_ENV
822     get_vfs_context();
823 #endif
824             if (parm == AFSOP_CACHEFILE)
825                 code = afs_InitCacheFile(tbuffer, 0);
826             else if (parm == AFSOP_CACHEINFO)
827                 code = afs_InitCacheInfo(tbuffer);
828             else if (parm == AFSOP_VOLUMEINFO)
829                 code = afs_InitVolumeInfo(tbuffer);
830             else if (parm == AFSOP_CELLINFO)
831                 code = afs_InitCellInfo(tbuffer);
832 #ifdef AFS_DARWIN80_ENV
833             put_vfs_context();
834 #endif
835         }
836         osi_FreeSmallSpace(tbuffer);
837     } else if (parm == AFSOP_GO) {
838         /* the generic initialization calls come here.  One parameter: should we do the
839          * set-time operation on this workstation */
840         if (afs_Go_Done)
841             goto out;
842         afs_Go_Done = 1;
843         while (afs_initState < AFSOP_GO)
844             afs_osi_Sleep(&afs_initState);
845         afs_initState = 101;
846         afs_setTime = parm2;
847         if (afs_tpct1 + afs_tpct2 != 100) {
848             afs_tpct1 = 0;
849             afs_tpct2 = 0;
850             splitdcache = 0;
851         } else {        
852             splitdcache = 1;
853         }
854         afs_osi_Wakeup(&afs_initState);
855 #if     (!defined(AFS_NONFSTRANS)) || defined(AFS_AIX_IAUTH_ENV)
856         afs_nfsclient_init();
857 #endif
858         afs_uuid_create(&afs_cb_interface.uuid);
859         printf("found %d non-empty cache files (%d%%).\n",
860                afs_stats_cmperf.cacheFilesReused,
861                (100 * afs_stats_cmperf.cacheFilesReused) /
862                (afs_stats_cmperf.cacheNumEntries ? afs_stats_cmperf.
863                 cacheNumEntries : 1));
864     } else if (parm == AFSOP_ADVISEADDR) {
865         /* pass in the host address to the rx package */
866         int rxbind = 0;
867         int refresh = 0;
868
869         afs_int32 count = parm2;
870         afs_int32 *buffer =
871             afs_osi_Alloc(sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
872         afs_int32 *maskbuffer =
873             afs_osi_Alloc(sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
874         afs_int32 *mtubuffer =
875             afs_osi_Alloc(sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
876         int i;
877
878         /* This is a refresh */
879         if (count & 0x40000000) {
880             count &= ~0x40000000;
881             /* Can't bind after we start. Fix? */
882             count &= ~0x80000000;
883             refresh = 1;
884         }
885
886         /* Bind, but only if there's only one address configured */ 
887         if ( count & 0x80000000) {
888             count &= ~0x80000000;
889             if (count == 1)
890                 rxbind=1;
891         }
892
893         if (count > AFS_MAX_INTERFACE_ADDR) {
894             code = ENOMEM;
895             count = AFS_MAX_INTERFACE_ADDR;
896         }
897
898         AFS_COPYIN((char *)parm3, (char *)buffer, count * sizeof(afs_int32),
899                    code);
900         if (parm4)
901             AFS_COPYIN((char *)parm4, (char *)maskbuffer,
902                        count * sizeof(afs_int32), code);
903         if (parm5)
904             AFS_COPYIN((char *)parm5, (char *)mtubuffer,
905                        count * sizeof(afs_int32), code);
906
907         afs_cb_interface.numberOfInterfaces = count;
908         for (i = 0; i < count; i++) {
909             afs_cb_interface.addr_in[i] = buffer[i];
910 #ifdef AFS_USERSPACE_IP_ADDR
911             /* AFS_USERSPACE_IP_ADDR means we have no way of finding the
912              * machines IP addresses when in the kernel (the in_ifaddr
913              * struct is not available), so we pass the info in at
914              * startup. We also pass in the subnetmask and mtu size. The
915              * subnetmask is used when setting the rank:
916              * afsi_SetServerIPRank(); and the mtu size is used when
917              * finding the best mtu size. rxi_FindIfnet() is replaced
918              * with rxi_Findcbi().
919              */
920             afs_cb_interface.subnetmask[i] =
921                 (parm4 ? maskbuffer[i] : 0xffffffff);
922             afs_cb_interface.mtu[i] = (parm5 ? mtubuffer[i] : htonl(1500));
923 #endif
924         }
925         rxi_setaddr(buffer[0]);
926         if (!refresh) {
927             if (rxbind)
928                 rx_bindhost = buffer[0];
929             else
930                 rx_bindhost = htonl(INADDR_ANY);
931         }
932
933         afs_osi_Free(buffer, sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
934         afs_osi_Free(maskbuffer, sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
935         afs_osi_Free(mtubuffer, sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
936
937         if (refresh) {
938             afs_CheckServers(1, NULL);     /* check down servers */
939             afs_CheckServers(0, NULL);     /* check down servers */
940         }
941     }
942 #ifdef  AFS_SGI53_ENV
943     else if (parm == AFSOP_NFSSTATICADDR) {
944         extern int (*nfs_rfsdisptab_v2) ();
945         nfs_rfsdisptab_v2 = (int (*)())parm2;
946     } else if (parm == AFSOP_NFSSTATICADDR2) {
947         extern int (*nfs_rfsdisptab_v2) ();
948 #ifdef _K64U64
949         nfs_rfsdisptab_v2 = (int (*)())((parm2 << 32) | (parm3 & 0xffffffff));
950 #else /* _K64U64 */
951         nfs_rfsdisptab_v2 = (int (*)())(parm3 & 0xffffffff);
952 #endif /* _K64U64 */
953     }
954 #if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
955     else if (parm == AFSOP_SBLOCKSTATICADDR2) {
956         extern int (*afs_sblockp) ();
957         extern void (*afs_sbunlockp) ();
958 #ifdef _K64U64
959         afs_sblockp = (int (*)())((parm2 << 32) | (parm3 & 0xffffffff));
960         afs_sbunlockp = (void (*)())((parm4 << 32) | (parm5 & 0xffffffff));
961 #else
962         afs_sblockp = (int (*)())(parm3 & 0xffffffff);
963         afs_sbunlockp = (void (*)())(parm5 & 0xffffffff);
964 #endif /* _K64U64 */
965     }
966 #endif /* AFS_SGI62_ENV && !AFS_SGI65_ENV */
967 #endif /* AFS_SGI53_ENV */
968     else if (parm == AFSOP_SHUTDOWN) {
969         afs_cold_shutdown = 0;
970         if (parm2 == 1)
971             afs_cold_shutdown = 1;
972 #ifndef AFS_DARWIN_ENV
973         if (afs_globalVFS != 0) {
974             afs_warn("AFS isn't unmounted yet! Call aborted\n");
975             code = EACCES;
976         } else
977 #endif
978             afs_shutdown();
979     } else if (parm == AFSOP_AFS_VFSMOUNT) {
980 #ifdef  AFS_HPUX_ENV
981         vfsmount(parm2, parm3, parm4, parm5);
982 #else /* defined(AFS_HPUX_ENV) */
983 #if defined(KERNEL_HAVE_UERROR)
984         setuerror(EINVAL);
985 #else
986         code = EINVAL;
987 #endif
988 #endif /* defined(AFS_HPUX_ENV) */
989     } else if (parm == AFSOP_CLOSEWAIT) {
990         afs_SynchronousCloses = 'S';
991     } else if (parm == AFSOP_GETMTU) {
992         afs_uint32 mtu = 0;
993 #if     !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV)
994 #ifdef AFS_USERSPACE_IP_ADDR
995         afs_int32 i;
996         i = rxi_Findcbi(parm2);
997         mtu = ((i == -1) ? htonl(1500) : afs_cb_interface.mtu[i]);
998 #else /* AFS_USERSPACE_IP_ADDR */
999         AFS_IFNET_T tifnp;
1000
1001         tifnp = rxi_FindIfnet(parm2, NULL);     /*  make iterative */
1002         mtu = (tifnp ? ifnet_mtu(tifnp) : htonl(1500));
1003 #endif /* else AFS_USERSPACE_IP_ADDR */
1004 #endif /* !AFS_SUN5_ENV */
1005         if (!code)
1006             AFS_COPYOUT((caddr_t) & mtu, (caddr_t) parm3, sizeof(afs_int32),
1007                         code);
1008 #ifdef AFS_AIX32_ENV
1009 /* this is disabled for now because I can't figure out how to get access
1010  * to these kernel variables.  It's only for supporting user-mode rx
1011  * programs -- it makes a huge difference on the 220's in my testbed,
1012  * though I don't know why. The bosserver does this with /etc/no, so it's
1013  * being handled a different way for the servers right now.  */
1014 /*      {
1015         static adjusted = 0;
1016         extern u_long sb_max_dflt;
1017         if (!adjusted) {
1018           adjusted = 1;
1019           if (sb_max_dflt < 131072) sb_max_dflt = 131072; 
1020           if (sb_max < 131072) sb_max = 131072; 
1021         }
1022       } */
1023 #endif /* AFS_AIX32_ENV */
1024     } else if (parm == AFSOP_GETMASK) { /* parm2 == addr in net order */
1025         afs_uint32 mask = 0;
1026 #if     !defined(AFS_SUN5_ENV)
1027 #ifdef AFS_USERSPACE_IP_ADDR
1028         afs_int32 i;
1029         i = rxi_Findcbi(parm2);
1030         if (i != -1) {
1031             mask = afs_cb_interface.subnetmask[i];
1032         } else {
1033             code = -1;
1034         }
1035 #else /* AFS_USERSPACE_IP_ADDR */
1036         AFS_IFNET_T tifnp;
1037
1038         tifnp = rxi_FindIfnet(parm2, &mask);    /* make iterative */
1039         if (!tifnp)
1040             code = -1;
1041 #endif /* else AFS_USERSPACE_IP_ADDR */
1042 #endif /* !AFS_SUN5_ENV */
1043         if (!code)
1044             AFS_COPYOUT((caddr_t) & mask, (caddr_t) parm3, sizeof(afs_int32),
1045                         code);
1046     }
1047 #ifdef AFS_AFSDB_ENV
1048     else if (parm == AFSOP_AFSDB_HANDLER) {
1049         int sizeArg = (int)parm4;
1050         int kmsgLen = sizeArg & 0xffff;
1051         int cellLen = (sizeArg & 0xffff0000) >> 16;
1052         afs_int32 *kmsg = afs_osi_Alloc(kmsgLen);
1053         char *cellname = afs_osi_Alloc(cellLen);
1054
1055 #ifndef UKERNEL
1056         afs_osi_MaskUserLoop();
1057 #endif
1058         AFS_COPYIN((afs_int32 *) parm2, cellname, cellLen, code);
1059         AFS_COPYIN((afs_int32 *) parm3, kmsg, kmsgLen, code);
1060         if (!code) {
1061             code = afs_AFSDBHandler(cellname, cellLen, kmsg);
1062             if (*cellname == 1)
1063                 *cellname = 0;
1064             if (code == -2) {   /* Shutting down? */
1065                 *cellname = 1;
1066                 code = 0;
1067             }
1068         }
1069         if (!code)
1070             AFS_COPYOUT(cellname, (char *)parm2, cellLen, code);
1071         afs_osi_Free(kmsg, kmsgLen);
1072         afs_osi_Free(cellname, cellLen);
1073     }
1074 #endif
1075     else if (parm == AFSOP_SET_DYNROOT) {
1076         code = afs_SetDynrootEnable(parm2);
1077     } else if (parm == AFSOP_SET_FAKESTAT) {
1078         afs_fakestat_enable = parm2;
1079         code = 0;
1080     } else if (parm == AFSOP_SET_BACKUPTREE) {
1081         afs_bkvolpref = parm2;
1082     } else if (parm == AFSOP_SET_RXPCK) {
1083         rx_extraPackets = parm2;
1084         afscall_set_rxpck_received = 1;
1085     } else
1086         code = EINVAL;
1087
1088   out:
1089     AFS_GUNLOCK();
1090 #ifdef AFS_LINUX20_ENV
1091     return -code;
1092 #else
1093     return code;
1094 #endif
1095 }
1096
1097 /*
1098  * Initstate in the range 0 < x < 100 are early initialization states.
1099  * Initstate of 100 means a AFSOP_START operation has been done.  After this,
1100  *  the cache may be initialized.
1101  * Initstate of 101 means a AFSOP_GO operation has been done.  This operation
1102  *  is done after all the cache initialization has been done.
1103  * Initstate of 200 means that the volume has been looked up once, possibly
1104  *  incorrectly.
1105  * Initstate of 300 means that the volume has been *successfully* looked up.
1106  */
1107 int
1108 afs_CheckInit(void)
1109 {
1110     register int code = 0;
1111
1112     AFS_STATCNT(afs_CheckInit);
1113     if (afs_initState <= 100)
1114         code = ENXIO;           /* never finished init phase */
1115     else if (afs_initState == 101) {    /* init done, wait for afs_daemon */
1116         while (afs_initState < 200)
1117             afs_osi_Sleep(&afs_initState);
1118     } else if (afs_initState == 200)
1119         code = ETIMEDOUT;       /* didn't find root volume */
1120     return code;
1121 }
1122
1123 int afs_shuttingdown = 0;
1124 void
1125 afs_shutdown(void)
1126 {
1127     extern short afs_brsDaemons;
1128     extern afs_int32 afs_CheckServerDaemonStarted;
1129     extern struct afs_osi_WaitHandle AFS_WaitHandler, AFS_CSWaitHandler;
1130     extern struct osi_file *afs_cacheInodep;
1131
1132     AFS_STATCNT(afs_shutdown);
1133     if (afs_initState == 0) {
1134         afs_warn("AFS not initialized - not shutting down\n");
1135       return;
1136     }
1137
1138     if (afs_shuttingdown)
1139         return;
1140     afs_shuttingdown = 1;
1141     if (afs_cold_shutdown)
1142         afs_warn("COLD ");
1143     else
1144         afs_warn("WARM ");
1145     afs_warn("shutting down of: CB... ");
1146
1147     afs_termState = AFSOP_STOP_RXCALLBACK;
1148     rx_WakeupServerProcs();
1149 #ifdef AFS_AIX51_ENV
1150     shutdown_rxkernel();
1151 #endif
1152     /* shutdown_rxkernel(); */
1153     while (afs_termState == AFSOP_STOP_RXCALLBACK)
1154         afs_osi_Sleep(&afs_termState);
1155
1156     afs_warn("afs... ");
1157     while (afs_termState == AFSOP_STOP_AFS) {
1158         afs_osi_CancelWait(&AFS_WaitHandler);
1159         afs_osi_Sleep(&afs_termState);
1160     }
1161     if (afs_CheckServerDaemonStarted) {
1162         while (afs_termState == AFSOP_STOP_CS) {
1163             afs_osi_CancelWait(&AFS_CSWaitHandler);
1164             afs_osi_Sleep(&afs_termState);
1165         }
1166     }
1167     afs_warn("BkG... ");
1168     /* Wake-up afs_brsDaemons so that we don't have to wait for a bkg job! */
1169     while (afs_termState == AFSOP_STOP_BKG) {
1170         afs_osi_Wakeup(&afs_brsDaemons);
1171         afs_osi_Sleep(&afs_termState);
1172     }
1173     afs_warn("CTrunc... ");
1174     /* Cancel cache truncate daemon. */
1175     while (afs_termState == AFSOP_STOP_TRUNCDAEMON) {
1176         afs_osi_Wakeup((char *)&afs_CacheTruncateDaemon);
1177         afs_osi_Sleep(&afs_termState);
1178     }
1179 #ifdef AFS_AFSDB_ENV
1180     afs_warn("AFSDB... ");
1181     afs_StopAFSDB();
1182     while (afs_termState == AFSOP_STOP_AFSDB)
1183         afs_osi_Sleep(&afs_termState);
1184 #endif
1185 #if     defined(AFS_SUN5_ENV) || defined(RXK_LISTENER_ENV)
1186     afs_warn("RxEvent... ");
1187     /* cancel rx event daemon */
1188     while (afs_termState == AFSOP_STOP_RXEVENT)
1189         afs_osi_Sleep(&afs_termState);
1190 #if defined(RXK_LISTENER_ENV)
1191 #ifndef UKERNEL
1192     afs_warn("UnmaskRxkSignals... ");
1193     afs_osi_UnmaskRxkSignals();
1194 #endif
1195     /* cancel rx listener */
1196     afs_warn("RxListener... ");
1197     osi_StopListener();         /* This closes rx_socket. */
1198     while (afs_termState == AFSOP_STOP_RXK_LISTENER) {
1199         afs_warn("Sleep... ");
1200         afs_osi_Sleep(&afs_termState);
1201     }
1202 #endif
1203 #else
1204     afs_termState = AFSOP_STOP_COMPLETE;
1205 #endif
1206     afs_warn("\n");
1207
1208     /* Close file only after daemons which can write to it are stopped. */
1209     if (afs_cacheInodep) {      /* memcache won't set this */
1210         osi_UFSClose(afs_cacheInodep);  /* Since we always leave it open */
1211         afs_cacheInodep = 0;
1212     }
1213     return;                     /* Just kill daemons for now */
1214 #ifdef notdef
1215     shutdown_CB();
1216     shutdown_AFS();
1217     shutdown_rxkernel();
1218     shutdown_rxevent();
1219     shutdown_rx();
1220     afs_shutdown_BKG();
1221     shutdown_bufferpackage();
1222 #endif
1223 #ifdef AFS_AIX51_ENV
1224     shutdown_daemons();
1225 #endif
1226 #ifdef notdef
1227     shutdown_cache();
1228     shutdown_osi();
1229     shutdown_osinet();
1230     shutdown_osifile();
1231     shutdown_vnodeops();
1232     shutdown_vfsops();
1233     shutdown_exporter();
1234     shutdown_memcache();
1235 #if (!defined(AFS_NONFSTRANS) || defined(AFS_AIX_IAUTH_ENV)) && !defined(AFS_OSF_ENV)
1236     shutdown_nfsclnt();
1237 #endif
1238     shutdown_afstest();
1239     /* The following hold the cm stats */
1240 /*
1241     memset(&afs_cmstats, 0, sizeof(struct afs_CMStats));
1242     memset(&afs_stats_cmperf, 0, sizeof(struct afs_stats_CMPerf));
1243     memset(&afs_stats_cmfullperf, 0, sizeof(struct afs_stats_CMFullPerf));
1244 */
1245     afs_warn(" ALL allocated tables\n");
1246     afs_shuttingdown = 0;
1247 #endif
1248 }
1249
1250 void
1251 shutdown_afstest(void)
1252 {
1253     AFS_STATCNT(shutdown_afstest);
1254     afs_initState = afs_termState = afs_setTime = 0;
1255     AFS_Running = afs_CB_Running = 0;
1256     afs_CacheInit_Done = afs_Go_Done = 0;
1257     if (afs_cold_shutdown) {
1258         *afs_rootVolumeName = 0;
1259     }
1260 }
1261
1262
1263 /* In case there is a bunch of dynamically build bkg daemons to free */
1264 void
1265 afs_shutdown_BKG(void)
1266 {
1267     AFS_STATCNT(shutdown_BKG);
1268 }