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