sparc64-linux26-20050508
[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
33
34 #if defined(AFS_SUN5_ENV) || defined(AFS_AIX_ENV) || defined(AFS_SGI_ENV) || defined(AFS_HPUX_ENV)
35 #define AFS_MINBUFFERS  100
36 #else
37 #define AFS_MINBUFFERS  50
38 #endif
39
40 struct afsop_cell {
41     afs_int32 hosts[MAXCELLHOSTS];
42     char cellName[100];
43 };
44
45 char afs_zeros[AFS_ZEROS];
46 char afs_rootVolumeName[64] = "";
47 struct afs_icl_set *afs_iclSetp = (struct afs_icl_set *)0;
48 struct afs_icl_set *afs_iclLongTermSetp = (struct afs_icl_set *)0;
49 afs_uint32 rx_bindhost;
50
51 #if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV)
52 kmutex_t afs_global_lock;
53 kmutex_t afs_rxglobal_lock;
54 #endif
55
56 #if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
57 long afs_global_owner;
58 #endif
59
60 #if defined(AFS_OSF_ENV)
61 simple_lock_data_t afs_global_lock;
62 #endif
63
64 #if defined(AFS_DARWIN_ENV)
65 struct lock__bsd__ afs_global_lock;
66 #endif
67
68 #if defined(AFS_XBSD_ENV) && !defined(AFS_FBSD50_ENV)
69 struct lock afs_global_lock;
70 struct proc *afs_global_owner;
71 #endif
72 #ifdef AFS_FBSD50_ENV
73 struct mtx afs_global_mtx;
74 #endif
75
76 #if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV)
77 thread_t afs_global_owner;
78 #endif /* AFS_OSF_ENV */
79
80 #if defined(AFS_AIX41_ENV)
81 simple_lock_data afs_global_lock;
82 #endif
83
84 afs_int32 afs_initState = 0;
85 afs_int32 afs_termState = 0;
86 afs_int32 afs_setTime = 0;
87 int afs_cold_shutdown = 0;
88 char afs_SynchronousCloses = '\0';
89 static int afs_CB_Running = 0;
90 static int AFS_Running = 0;
91 static int afs_CacheInit_Done = 0;
92 static int afs_Go_Done = 0;
93 extern struct interfaceAddr afs_cb_interface;
94 static int afs_RX_Running = 0;
95 static int afs_InitSetup_done = 0;
96
97 afs_int32 afs_rx_deadtime = AFS_RXDEADTIME;
98 afs_int32 afs_rx_harddead = AFS_HARDDEADTIME;
99
100 static int
101   Afscall_icl(long opcode, long p1, long p2, long p3, long p4, long *retval);
102
103 static int afscall_set_rxpck_received = 0;
104
105 #if defined(AFS_HPUX_ENV)
106 extern int afs_vfs_mount();
107 #endif /* defined(AFS_HPUX_ENV) */
108
109 /* This is code which needs to be called once when the first daemon enters
110  * the client. A non-zero return means an error and AFS should not start.
111  */
112 static int
113 afs_InitSetup(int preallocs)
114 {
115     extern void afs_InitStats();
116     int code;
117
118     if (afs_InitSetup_done)
119         return EAGAIN;
120
121 #ifndef AFS_NOSTATS
122     /*
123      * Set up all the AFS statistics variables.  This should be done
124      * exactly once, and it should be done here, the first resource-setting
125      * routine to be called by the CM/RX.
126      */
127     afs_InitStats();
128 #endif /* AFS_NOSTATS */
129
130     memset(afs_zeros, 0, AFS_ZEROS);
131
132     /* start RX */
133     if(!afscall_set_rxpck_received)
134     rx_extraPackets = AFS_NRXPACKETS;   /* smaller # of packets */
135     code = rx_InitHost(rx_bindhost, htons(7001));
136     if (code) {
137         printf("AFS: RX failed to initialize %d).\n", code);
138         return code;
139     }
140     rx_SetRxDeadTime(afs_rx_deadtime);
141     /* resource init creates the services */
142     afs_ResourceInit(preallocs);
143
144     afs_InitSetup_done = 1;
145     afs_osi_Wakeup(&afs_InitSetup_done);
146
147     return code;
148 }
149
150 #if defined(AFS_LINUX24_ENV) && defined(COMPLETION_H_EXISTS)
151 struct afsd_thread_info {
152     unsigned long parm;
153     struct completion *complete;
154 };
155
156 static int
157 afsd_thread(void *rock)
158 {
159     struct afsd_thread_info *arg = rock;
160     unsigned long parm = arg->parm;
161 #ifdef SYS_SETPRIORITY_EXPORTED
162     int (*sys_setpriority) (int, int, int) = sys_call_table[__NR_setpriority];
163 #endif
164 #if defined(AFS_LINUX26_ENV)
165     daemonize("afsd");
166 #else
167     daemonize();
168 #endif
169                                 /* doesn't do much, since we were forked from keventd, but
170                                  * does call mm_release, which wakes up our parent (since it
171                                  * used CLONE_VFORK) */
172 #if !defined(AFS_LINUX26_ENV)
173     reparent_to_init();
174 #endif
175     afs_osi_MaskSignals();
176     switch (parm) {
177     case AFSOP_START_RXCALLBACK:
178         sprintf(current->comm, "afs_cbstart");
179         AFS_GLOCK();
180         complete(arg->complete);
181         afs_CB_Running = 1;
182         while (afs_RX_Running != 2)
183             afs_osi_Sleep(&afs_RX_Running);
184         sprintf(current->comm, "afs_callback");
185         afs_RXCallBackServer();
186         AFS_GUNLOCK();
187         complete_and_exit(0, 0);
188         break;
189     case AFSOP_START_AFS:
190         sprintf(current->comm, "afs_afsstart");
191         AFS_GLOCK();
192         complete(arg->complete);
193         AFS_Running = 1;
194         while (afs_initState < AFSOP_START_AFS)
195             afs_osi_Sleep(&afs_initState);
196         afs_initState = AFSOP_START_BKG;
197         afs_osi_Wakeup(&afs_initState);
198         sprintf(current->comm, "afsd");
199         afs_Daemon();
200         AFS_GUNLOCK();
201         complete_and_exit(0, 0);
202         break;
203     case AFSOP_START_BKG:
204         sprintf(current->comm, "afs_bkgstart");
205         AFS_GLOCK();
206         complete(arg->complete);
207         while (afs_initState < AFSOP_START_BKG)
208             afs_osi_Sleep(&afs_initState);
209         if (afs_initState < AFSOP_GO) {
210             afs_initState = AFSOP_GO;
211             afs_osi_Wakeup(&afs_initState);
212         }
213         sprintf(current->comm, "afs_background");
214         afs_BackgroundDaemon();
215         AFS_GUNLOCK();
216         complete_and_exit(0, 0);
217         break;
218     case AFSOP_START_TRUNCDAEMON:
219         sprintf(current->comm, "afs_trimstart");
220         AFS_GLOCK();
221         complete(arg->complete);
222         while (afs_initState < AFSOP_GO)
223             afs_osi_Sleep(&afs_initState);
224         sprintf(current->comm, "afs_cachetrim");
225         afs_CacheTruncateDaemon();
226         AFS_GUNLOCK();
227         complete_and_exit(0, 0);
228         break;
229     case AFSOP_START_CS:
230         sprintf(current->comm, "afs_checkserver");
231         AFS_GLOCK();
232         complete(arg->complete);
233         afs_CheckServerDaemon();
234         AFS_GUNLOCK();
235         complete_and_exit(0, 0);
236         break;
237     case AFSOP_RXEVENT_DAEMON:
238         sprintf(current->comm, "afs_evtstart");
239 #ifdef SYS_SETPRIORITY_EXPORTED
240         sys_setpriority(PRIO_PROCESS, 0, -10);
241 #else
242 #ifdef CURRENT_INCLUDES_NICE
243         current->nice = -10;
244 #endif
245 #endif
246         AFS_GLOCK();
247         complete(arg->complete);
248         while (afs_initState < AFSOP_START_BKG)
249             afs_osi_Sleep(&afs_initState);
250         sprintf(current->comm, "afs_rxevent");
251         afs_rxevent_daemon();
252         AFS_GUNLOCK();
253         complete_and_exit(0, 0);
254         break;
255     case AFSOP_RXLISTENER_DAEMON:
256         sprintf(current->comm, "afs_lsnstart");
257 #ifdef SYS_SETPRIORITY_EXPORTED
258         sys_setpriority(PRIO_PROCESS, 0, -10);
259 #else
260 #ifdef CURRENT_INCLUDES_NICE
261         current->nice = -10;
262 #endif
263 #endif
264         AFS_GLOCK();
265         complete(arg->complete);
266         afs_initState = AFSOP_START_AFS;
267         afs_osi_Wakeup(&afs_initState);
268         afs_RX_Running = 2;
269         afs_osi_Wakeup(&afs_RX_Running);
270         afs_osi_RxkRegister();
271         sprintf(current->comm, "afs_rxlistener");
272         rxk_Listener();
273         AFS_GUNLOCK();
274         complete_and_exit(0, 0);
275         break;
276     default:
277         printf("Unknown op %ld in StartDaemon()\n", (long)parm);
278         break;
279     }
280     return 0;
281 }
282
283 void
284 afsd_launcher(void *rock)
285 {
286     if (!kernel_thread(afsd_thread, rock, CLONE_VFORK | SIGCHLD))
287         printf("kernel_thread failed. afs startup will not complete\n");
288 }
289
290 void
291 afs_DaemonOp(long parm, long parm2, long parm3, long parm4, long parm5,
292              long parm6)
293 {
294     int code;
295     DECLARE_COMPLETION(c);
296 #if defined(AFS_LINUX26_ENV)
297     struct work_struct tq;
298 #else
299     struct tq_struct tq;
300 #endif
301     struct afsd_thread_info info;
302     if (parm == AFSOP_START_RXCALLBACK) {
303         if (afs_CB_Running)
304             return;
305     } else if (parm == AFSOP_RXLISTENER_DAEMON) {
306         if (afs_RX_Running)
307             return;
308         afs_RX_Running = 1;
309         code = afs_InitSetup(parm2);
310         if (parm3) {
311             rx_enablePeerRPCStats();
312         }
313         if (parm4) {
314             rx_enableProcessRPCStats();
315         }
316         if (code)
317             return;
318     } else if (parm == AFSOP_START_AFS) {
319         if (AFS_Running)
320             return;
321     }                           /* other functions don't need setup in the parent */
322     info.complete = &c;
323     info.parm = parm;
324 #if defined(AFS_LINUX26_ENV)
325     INIT_WORK(&tq, afsd_launcher, &info);
326     schedule_work(&tq);
327 #else
328     tq.sync = 0;
329     INIT_LIST_HEAD(&tq.list);
330     tq.routine = afsd_launcher;
331     tq.data = &info;
332     schedule_task(&tq);
333 #endif
334     AFS_GUNLOCK();
335     /* we need to wait cause we passed stack pointers around.... */
336     wait_for_completion(&c);
337     AFS_GLOCK();
338 }
339 #endif
340
341 /* leaving as is, probably will barf if we add prototypes here since it's likely being called
342 with partial list */
343 int
344 afs_syscall_call(parm, parm2, parm3, parm4, parm5, parm6)
345      long parm, parm2, parm3, parm4, parm5, parm6;
346 {
347     afs_int32 code = 0;
348 #if defined(AFS_SGI61_ENV) || defined(AFS_SUN57_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
349     size_t bufferSize;
350 #else /* AFS_SGI61_ENV */
351     u_int bufferSize;
352 #endif /* AFS_SGI61_ENV */
353
354     AFS_STATCNT(afs_syscall_call);
355 #ifdef  AFS_SUN5_ENV
356     if (!afs_suser(CRED()) && (parm != AFSOP_GETMTU)
357         && (parm != AFSOP_GETMASK)) {
358         /* only root can run this code */
359         return (EACCES);
360 #else
361     if (!afs_suser(NULL) && (parm != AFSOP_GETMTU)
362         && (parm != AFSOP_GETMASK)) {
363         /* only root can run this code */
364 #if defined(KERNEL_HAVE_UERROR)
365         setuerror(EACCES);
366         return (EACCES);
367 #else
368 #if defined(AFS_OSF_ENV)
369         return EACCES;
370 #else /* AFS_OSF_ENV */
371         return EPERM;
372 #endif /* AFS_OSF_ENV */
373 #endif
374 #endif
375     }
376     AFS_GLOCK();
377 #if defined(AFS_LINUX24_ENV) && defined(COMPLETION_H_EXISTS) && !defined(UKERNEL)
378     if (parm < AFSOP_ADDCELL || parm == AFSOP_RXEVENT_DAEMON
379         || parm == AFSOP_RXLISTENER_DAEMON) {
380         afs_DaemonOp(parm, parm2, parm3, parm4, parm5, parm6);
381     }
382 #else /* !(AFS_LINUX24_ENV && !UKERNEL) */
383     if (parm == AFSOP_START_RXCALLBACK) {
384         if (afs_CB_Running)
385             goto out;
386         afs_CB_Running = 1;
387 #ifndef RXK_LISTENER_ENV
388         code = afs_InitSetup(parm2);
389         if (!code)
390 #endif /* !RXK_LISTENER_ENV */
391         {
392 #ifdef RXK_LISTENER_ENV
393             while (afs_RX_Running != 2)
394                 afs_osi_Sleep(&afs_RX_Running);
395 #else /* !RXK_LISTENER_ENV */
396             afs_initState = AFSOP_START_AFS;
397             afs_osi_Wakeup(&afs_initState);
398 #endif /* RXK_LISTENER_ENV */
399             afs_osi_Invisible();
400             afs_RXCallBackServer();
401         }
402 #ifdef AFS_SGI_ENV
403         AFS_GUNLOCK();
404         exit(CLD_EXITED, code);
405 #endif /* AFS_SGI_ENV */
406     }
407 #ifdef RXK_LISTENER_ENV
408     else if (parm == AFSOP_RXLISTENER_DAEMON) {
409         if (afs_RX_Running)
410             goto out;
411         afs_RX_Running = 1;
412         code = afs_InitSetup(parm2);
413         if (parm3) {
414             rx_enablePeerRPCStats();
415         }
416         if (parm4) {
417             rx_enableProcessRPCStats();
418         }
419         if (!code) {
420             afs_initState = AFSOP_START_AFS;
421             afs_osi_Wakeup(&afs_initState);
422             afs_osi_Invisible();
423             afs_RX_Running = 2;
424             afs_osi_Wakeup(&afs_RX_Running);
425 #ifndef UKERNEL
426             afs_osi_RxkRegister();
427 #endif /* !UKERNEL */
428             rxk_Listener();
429         }
430 #ifdef  AFS_SGI_ENV
431         AFS_GUNLOCK();
432         exit(CLD_EXITED, code);
433 #endif /* AFS_SGI_ENV */
434     }
435 #endif /* RXK_LISTENER_ENV */
436     else if (parm == AFSOP_START_AFS) {
437         /* afs daemon */
438         if (AFS_Running)
439             goto out;
440         AFS_Running = 1;
441         while (afs_initState < AFSOP_START_AFS)
442             afs_osi_Sleep(&afs_initState);
443
444         afs_initState = AFSOP_START_BKG;
445         afs_osi_Wakeup(&afs_initState);
446         afs_osi_Invisible();
447         afs_Daemon();
448 #ifdef AFS_SGI_ENV
449         AFS_GUNLOCK();
450         exit(CLD_EXITED, 0);
451 #endif /* AFS_SGI_ENV */
452     } else if (parm == AFSOP_START_CS) {
453         afs_osi_Invisible();
454         afs_CheckServerDaemon();
455 #ifdef AFS_SGI_ENV
456         AFS_GUNLOCK();
457         exit(CLD_EXITED, 0);
458 #endif /* AFS_SGI_ENV */
459     } else if (parm == AFSOP_START_BKG) {
460         while (afs_initState < AFSOP_START_BKG)
461             afs_osi_Sleep(&afs_initState);
462         if (afs_initState < AFSOP_GO) {
463             afs_initState = AFSOP_GO;
464             afs_osi_Wakeup(&afs_initState);
465         }
466         /* start the bkg daemon */
467         afs_osi_Invisible();
468 #ifdef AFS_AIX32_ENV
469         if (parm2)
470             afs_BioDaemon(parm2);
471         else
472 #endif /* AFS_AIX32_ENV */
473             afs_BackgroundDaemon();
474 #ifdef AFS_SGI_ENV
475         AFS_GUNLOCK();
476         exit(CLD_EXITED, 0);
477 #endif /* AFS_SGI_ENV */
478     } else if (parm == AFSOP_START_TRUNCDAEMON) {
479         while (afs_initState < AFSOP_GO)
480             afs_osi_Sleep(&afs_initState);
481         /* start the bkg daemon */
482         afs_osi_Invisible();
483         afs_CacheTruncateDaemon();
484 #ifdef  AFS_SGI_ENV
485         AFS_GUNLOCK();
486         exit(CLD_EXITED, 0);
487 #endif /* AFS_SGI_ENV */
488     }
489 #if defined(AFS_SUN5_ENV) || defined(RXK_LISTENER_ENV)
490     else if (parm == AFSOP_RXEVENT_DAEMON) {
491         while (afs_initState < AFSOP_START_BKG)
492             afs_osi_Sleep(&afs_initState);
493         afs_osi_Invisible();
494         afs_rxevent_daemon();
495 #ifdef AFS_SGI_ENV
496         AFS_GUNLOCK();
497         exit(CLD_EXITED, 0);
498 #endif /* AFS_SGI_ENV */
499     }
500 #endif /* AFS_SUN5_ENV || RXK_LISTENER_ENV */
501 #endif /* AFS_LINUX24_ENV && !UKERNEL */
502     else if (parm == AFSOP_BASIC_INIT) {
503         afs_int32 temp;
504
505         while (!afs_InitSetup_done)
506             afs_osi_Sleep(&afs_InitSetup_done);
507
508 #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)
509         temp = AFS_MINBUFFERS;  /* Should fix this soon */
510 #else
511         /* number of 2k buffers we could get from all of the buffer space */
512         temp = ((afs_bufferpages * NBPG) >> 11);
513         temp = temp >> 2;       /* don't take more than 25% (our magic parameter) */
514         if (temp < AFS_MINBUFFERS)
515             temp = AFS_MINBUFFERS;      /* though we really should have this many */
516 #endif
517         DInit(temp);
518         afs_rootFid.Fid.Volume = 0;
519         code = 0;
520     } else if (parm == AFSOP_BUCKETPCT) {
521         /* need to enable this now, will disable again before GO
522            if we don't have 100% */
523         splitdcache = 1;
524         switch (parm2) {
525         case 1:
526             afs_tpct1 = parm3;
527             break;
528         case 2:
529             afs_tpct2 = parm3;
530             break;
531         }           
532     } else if (parm == AFSOP_ADDCELL) {
533         /* add a cell.  Parameter 2 is 8 hosts (in net order),  parm 3 is the null-terminated
534          * name.  Parameter 4 is the length of the name, including the null.  Parm 5 is the
535          * home cell flag (0x1 bit) and the nosuid flag (0x2 bit) */
536         struct afsop_cell *tcell = afs_osi_Alloc(sizeof(struct afsop_cell));
537
538         AFS_COPYIN((char *)parm2, (char *)tcell->hosts, sizeof(tcell->hosts),
539                    code);
540         if (!code) {
541             if (parm4 > sizeof(tcell->cellName))
542                 code = EFAULT;
543             else {
544                 AFS_COPYIN((char *)parm3, tcell->cellName, parm4, code);
545                 if (!code)
546                     afs_NewCell(tcell->cellName, tcell->hosts, parm5, NULL, 0,
547                                 0, 0);
548             }
549         }
550         afs_osi_Free(tcell, sizeof(struct afsop_cell));
551     } else if (parm == AFSOP_ADDCELL2) {
552         struct afsop_cell *tcell = afs_osi_Alloc(sizeof(struct afsop_cell));
553         char *tbuffer = osi_AllocSmallSpace(AFS_SMALLOCSIZ), *lcnamep = 0;
554         char *tbuffer1 = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
555         int cflags = parm4;
556
557 #if 0
558         /* wait for basic init - XXX can't find any reason we need this? */
559         while (afs_initState < AFSOP_START_BKG)
560             afs_osi_Sleep(&afs_initState);
561 #endif
562
563         AFS_COPYIN((char *)parm2, (char *)tcell->hosts, sizeof(tcell->hosts),
564                    code);
565         if (!code) {
566             AFS_COPYINSTR((char *)parm3, tbuffer1, AFS_SMALLOCSIZ,
567                           &bufferSize, code);
568             if (!code) {
569                 if (parm4 & 4) {
570                     AFS_COPYINSTR((char *)parm5, tbuffer, AFS_SMALLOCSIZ,
571                                   &bufferSize, code);
572                     if (!code) {
573                         lcnamep = tbuffer;
574                         cflags |= CLinkedCell;
575                     }
576                 }
577                 if (!code)
578                     code =
579                         afs_NewCell(tbuffer1, tcell->hosts, cflags, lcnamep,
580                                     0, 0, 0);
581             }
582         }
583         afs_osi_Free(tcell, sizeof(struct afsop_cell));
584         osi_FreeSmallSpace(tbuffer);
585         osi_FreeSmallSpace(tbuffer1);
586     } else if (parm == AFSOP_ADDCELLALIAS) {
587         /*
588          * Call arguments:
589          * parm2 is the alias name
590          * parm3 is the real cell name
591          */
592         char *aliasName = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
593         char *cellName = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
594
595         AFS_COPYINSTR((char *)parm2, aliasName, AFS_SMALLOCSIZ, &bufferSize,
596                       code);
597         if (!code)
598             AFS_COPYINSTR((char *)parm3, cellName, AFS_SMALLOCSIZ,
599                           &bufferSize, code);
600         if (!code)
601             afs_NewCellAlias(aliasName, cellName);
602         osi_FreeSmallSpace(aliasName);
603         osi_FreeSmallSpace(cellName);
604     } else if (parm == AFSOP_SET_THISCELL) {
605         /*
606          * Call arguments:
607          * parm2 is the primary cell name
608          */
609         char *cell = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
610
611         AFS_COPYINSTR((char *)parm2, cell, AFS_SMALLOCSIZ, &bufferSize, code);
612         if (!code)
613             afs_SetPrimaryCell(cell);
614         osi_FreeSmallSpace(cell);
615     } else if (parm == AFSOP_CACHEINIT) {
616         struct afs_cacheParams cparms;
617
618         if (afs_CacheInit_Done)
619             goto out;
620
621         AFS_COPYIN((char *)parm2, (caddr_t) & cparms, sizeof(cparms), code);
622         if (code) {
623 #if defined(KERNEL_HAVE_UERROR)
624             setuerror(code);
625             code = -1;
626 #endif
627             goto out;
628         }
629         afs_CacheInit_Done = 1;
630         {
631             struct afs_icl_log *logp;
632             /* initialize the ICL system */
633             code = afs_icl_CreateLog("cmfx", 60 * 1024, &logp);
634             if (code == 0)
635                 code =
636                     afs_icl_CreateSetWithFlags("cm", logp, NULL,
637                                                ICL_CRSET_FLAG_DEFAULT_OFF,
638                                                &afs_iclSetp);
639             code =
640                 afs_icl_CreateSet("cmlongterm", logp, NULL,
641                                   &afs_iclLongTermSetp);
642         }
643         afs_setTime = cparms.setTimeFlag;
644
645         code =
646             afs_CacheInit(cparms.cacheScaches, cparms.cacheFiles,
647                           cparms.cacheBlocks, cparms.cacheDcaches,
648                           cparms.cacheVolumes, cparms.chunkSize,
649                           cparms.memCacheFlag, cparms.inodes, cparms.users);
650
651     } else if (parm == AFSOP_CACHEINODE) {
652         ino_t ainode = parm2;
653         /* wait for basic init */
654         while (afs_initState < AFSOP_START_BKG)
655             afs_osi_Sleep(&afs_initState);
656
657         /* do it by inode */
658 #ifdef AFS_SGI62_ENV
659         ainode = (ainode << 32) | (parm3 & 0xffffffff);
660 #endif
661         code = afs_InitCacheFile(NULL, ainode);
662     } else if (parm == AFSOP_ROOTVOLUME) {
663         /* wait for basic init */
664         while (afs_initState < AFSOP_START_BKG)
665             afs_osi_Sleep(&afs_initState);
666
667         if (parm2) {
668             AFS_COPYINSTR((char *)parm2, afs_rootVolumeName,
669                           sizeof(afs_rootVolumeName), &bufferSize, code);
670             afs_rootVolumeName[sizeof(afs_rootVolumeName) - 1] = 0;
671         } else
672             code = 0;
673     } else if (parm == AFSOP_CACHEFILE || parm == AFSOP_CACHEINFO
674                || parm == AFSOP_VOLUMEINFO || parm == AFSOP_AFSLOG
675                || parm == AFSOP_CELLINFO) {
676         char *tbuffer = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
677
678         code = 0;
679         AFS_COPYINSTR((char *)parm2, tbuffer, AFS_SMALLOCSIZ, &bufferSize,
680                       code);
681         if (code) {
682             osi_FreeSmallSpace(tbuffer);
683             goto out;
684         }
685         if (!code) {
686             tbuffer[AFS_SMALLOCSIZ - 1] = '\0'; /* null-terminate the name */
687             /* We have the cache dir copied in.  Call the cache init routine */
688             if (parm == AFSOP_CACHEFILE)
689                 code = afs_InitCacheFile(tbuffer, 0);
690             else if (parm == AFSOP_CACHEINFO)
691                 code = afs_InitCacheInfo(tbuffer);
692             else if (parm == AFSOP_VOLUMEINFO)
693                 code = afs_InitVolumeInfo(tbuffer);
694             else if (parm == AFSOP_CELLINFO)
695                 code = afs_InitCellInfo(tbuffer);
696         }
697         osi_FreeSmallSpace(tbuffer);
698     } else if (parm == AFSOP_GO) {
699         /* the generic initialization calls come here.  One parameter: should we do the
700          * set-time operation on this workstation */
701         if (afs_Go_Done)
702             goto out;
703         afs_Go_Done = 1;
704         while (afs_initState < AFSOP_GO)
705             afs_osi_Sleep(&afs_initState);
706         afs_initState = 101;
707         afs_setTime = parm2;
708         if (afs_tpct1 + afs_tpct2 != 100) {
709             afs_tpct1 = 0;
710             afs_tpct2 = 0;
711             splitdcache = 0;
712         } else {        
713             splitdcache = 1;
714         }
715         afs_osi_Wakeup(&afs_initState);
716 #if     (!defined(AFS_NONFSTRANS)) || defined(AFS_AIX_IAUTH_ENV)
717         afs_nfsclient_init();
718 #endif
719         printf("found %d non-empty cache files (%d%%).\n",
720                afs_stats_cmperf.cacheFilesReused,
721                (100 * afs_stats_cmperf.cacheFilesReused) /
722                (afs_stats_cmperf.cacheNumEntries ? afs_stats_cmperf.
723                 cacheNumEntries : 1));
724     } else if (parm == AFSOP_ADVISEADDR) {
725         /* pass in the host address to the rx package */
726         int rxbind = 0;
727         afs_int32 count = parm2;
728         afs_int32 *buffer =
729             afs_osi_Alloc(sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
730         afs_int32 *maskbuffer =
731             afs_osi_Alloc(sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
732         afs_int32 *mtubuffer =
733             afs_osi_Alloc(sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
734         int i;
735
736         /* Bind, but only if there's only one address configured */ 
737         if ( count & 0x80000000) {
738             count &= ~0x80000000;
739             if (count == 1)
740                 rxbind=1;
741         }
742
743         if (count > AFS_MAX_INTERFACE_ADDR) {
744             code = ENOMEM;
745             count = AFS_MAX_INTERFACE_ADDR;
746         }
747
748         AFS_COPYIN((char *)parm3, (char *)buffer, count * sizeof(afs_int32),
749                    code);
750         if (parm4)
751             AFS_COPYIN((char *)parm4, (char *)maskbuffer,
752                        count * sizeof(afs_int32), code);
753         if (parm5)
754             AFS_COPYIN((char *)parm5, (char *)mtubuffer,
755                        count * sizeof(afs_int32), code);
756
757         afs_cb_interface.numberOfInterfaces = count;
758         for (i = 0; i < count; i++) {
759             afs_cb_interface.addr_in[i] = buffer[i];
760 #ifdef AFS_USERSPACE_IP_ADDR
761             /* AFS_USERSPACE_IP_ADDR means we have no way of finding the
762              * machines IP addresses when in the kernel (the in_ifaddr
763              * struct is not available), so we pass the info in at
764              * startup. We also pass in the subnetmask and mtu size. The
765              * subnetmask is used when setting the rank:
766              * afsi_SetServerIPRank(); and the mtu size is used when
767              * finding the best mtu size. rxi_FindIfnet() is replaced
768              * with rxi_Findcbi().
769              */
770             afs_cb_interface.subnetmask[i] =
771                 (parm4 ? maskbuffer[i] : 0xffffffff);
772             afs_cb_interface.mtu[i] = (parm5 ? mtubuffer[i] : htonl(1500));
773 #endif
774         }
775         afs_uuid_create(&afs_cb_interface.uuid);
776         rxi_setaddr(buffer[0]);
777         if (rxbind)
778             rx_bindhost = buffer[0];
779         else
780             rx_bindhost = htonl(INADDR_ANY);
781
782         afs_osi_Free(buffer, sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
783         afs_osi_Free(maskbuffer, sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
784         afs_osi_Free(mtubuffer, sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR);
785     }
786 #ifdef  AFS_SGI53_ENV
787     else if (parm == AFSOP_NFSSTATICADDR) {
788         extern int (*nfs_rfsdisptab_v2) ();
789         nfs_rfsdisptab_v2 = (int (*)())parm2;
790     } else if (parm == AFSOP_NFSSTATICADDR2) {
791         extern int (*nfs_rfsdisptab_v2) ();
792 #ifdef _K64U64
793         nfs_rfsdisptab_v2 = (int (*)())((parm2 << 32) | (parm3 & 0xffffffff));
794 #else /* _K64U64 */
795         nfs_rfsdisptab_v2 = (int (*)())(parm3 & 0xffffffff);
796 #endif /* _K64U64 */
797     }
798 #if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
799     else if (parm == AFSOP_SBLOCKSTATICADDR2) {
800         extern int (*afs_sblockp) ();
801         extern void (*afs_sbunlockp) ();
802 #ifdef _K64U64
803         afs_sblockp = (int (*)())((parm2 << 32) | (parm3 & 0xffffffff));
804         afs_sbunlockp = (void (*)())((parm4 << 32) | (parm5 & 0xffffffff));
805 #else
806         afs_sblockp = (int (*)())(parm3 & 0xffffffff);
807         afs_sbunlockp = (void (*)())(parm5 & 0xffffffff);
808 #endif /* _K64U64 */
809     }
810 #endif /* AFS_SGI62_ENV && !AFS_SGI65_ENV */
811 #endif /* AFS_SGI53_ENV */
812     else if (parm == AFSOP_SHUTDOWN) {
813         afs_cold_shutdown = 0;
814         if (parm2 == 1)
815             afs_cold_shutdown = 1;
816 #ifndef AFS_DARWIN_ENV
817         if (afs_globalVFS != 0) {
818             afs_warn("AFS isn't unmounted yet! Call aborted\n");
819             code = EACCES;
820         } else
821 #endif
822             afs_shutdown();
823     } else if (parm == AFSOP_AFS_VFSMOUNT) {
824 #ifdef  AFS_HPUX_ENV
825         vfsmount(parm2, parm3, parm4, parm5);
826 #else /* defined(AFS_HPUX_ENV) */
827 #if defined(KERNEL_HAVE_UERROR)
828         setuerror(EINVAL);
829 #else
830         code = EINVAL;
831 #endif
832 #endif /* defined(AFS_HPUX_ENV) */
833     } else if (parm == AFSOP_CLOSEWAIT) {
834         afs_SynchronousCloses = 'S';
835     } else if (parm == AFSOP_GETMTU) {
836         afs_uint32 mtu = 0;
837 #if     !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV)
838 #ifdef AFS_USERSPACE_IP_ADDR
839         afs_int32 i;
840         i = rxi_Findcbi(parm2);
841         mtu = ((i == -1) ? htonl(1500) : afs_cb_interface.mtu[i]);
842 #else /* AFS_USERSPACE_IP_ADDR */
843         struct ifnet *tifnp;
844
845         tifnp = rxi_FindIfnet(parm2, NULL);     /*  make iterative */
846         mtu = (tifnp ? tifnp->if_mtu : htonl(1500));
847 #endif /* else AFS_USERSPACE_IP_ADDR */
848 #endif /* !AFS_SUN5_ENV */
849         if (!code)
850             AFS_COPYOUT((caddr_t) & mtu, (caddr_t) parm3, sizeof(afs_int32),
851                         code);
852 #ifdef AFS_AIX32_ENV
853 /* this is disabled for now because I can't figure out how to get access
854  * to these kernel variables.  It's only for supporting user-mode rx
855  * programs -- it makes a huge difference on the 220's in my testbed,
856  * though I don't know why. The bosserver does this with /etc/no, so it's
857  * being handled a different way for the servers right now.  */
858 /*      {
859         static adjusted = 0;
860         extern u_long sb_max_dflt;
861         if (!adjusted) {
862           adjusted = 1;
863           if (sb_max_dflt < 131072) sb_max_dflt = 131072; 
864           if (sb_max < 131072) sb_max = 131072; 
865         }
866       } */
867 #endif /* AFS_AIX32_ENV */
868     } else if (parm == AFSOP_GETMASK) { /* parm2 == addr in net order */
869         afs_uint32 mask = 0;
870 #if     !defined(AFS_SUN5_ENV)
871 #ifdef AFS_USERSPACE_IP_ADDR
872         afs_int32 i;
873         i = rxi_Findcbi(parm2);
874         if (i != -1) {
875             mask = afs_cb_interface.subnetmask[i];
876         } else {
877             code = -1;
878         }
879 #else /* AFS_USERSPACE_IP_ADDR */
880         struct ifnet *tifnp;
881
882         tifnp = rxi_FindIfnet(parm2, &mask);    /* make iterative */
883         if (!tifnp)
884             code = -1;
885 #endif /* else AFS_USERSPACE_IP_ADDR */
886 #endif /* !AFS_SUN5_ENV */
887         if (!code)
888             AFS_COPYOUT((caddr_t) & mask, (caddr_t) parm3, sizeof(afs_int32),
889                         code);
890     }
891 #ifdef AFS_AFSDB_ENV
892     else if (parm == AFSOP_AFSDB_HANDLER) {
893         int sizeArg = (int)parm4;
894         int kmsgLen = sizeArg & 0xffff;
895         int cellLen = (sizeArg & 0xffff0000) >> 16;
896         afs_int32 *kmsg = afs_osi_Alloc(kmsgLen);
897         char *cellname = afs_osi_Alloc(cellLen);
898
899 #ifndef UKERNEL
900         afs_osi_MaskUserLoop();
901 #endif
902         AFS_COPYIN((afs_int32 *) parm2, cellname, cellLen, code);
903         AFS_COPYIN((afs_int32 *) parm3, kmsg, kmsgLen, code);
904         if (!code) {
905             code = afs_AFSDBHandler(cellname, cellLen, kmsg);
906             if (*cellname == 1)
907                 *cellname = 0;
908             if (code == -2) {   /* Shutting down? */
909                 *cellname = 1;
910                 code = 0;
911             }
912         }
913         if (!code)
914             AFS_COPYOUT(cellname, (char *)parm2, cellLen, code);
915         afs_osi_Free(kmsg, kmsgLen);
916         afs_osi_Free(cellname, cellLen);
917     }
918 #endif
919     else if (parm == AFSOP_SET_DYNROOT) {
920         code = afs_SetDynrootEnable(parm2);
921     } else if (parm == AFSOP_SET_FAKESTAT) {
922         afs_fakestat_enable = parm2;
923         code = 0;
924     } else if (parm == AFSOP_SET_BACKUPTREE) {
925         afs_bkvolpref = parm2;
926     } else if (parm == AFSOP_SET_RXPCK) {
927         rx_extraPackets = parm2;
928         afscall_set_rxpck_received = 1;
929     } else
930         code = EINVAL;
931
932   out:
933     AFS_GUNLOCK();
934 #ifdef AFS_LINUX20_ENV
935     return -code;
936 #else
937     return code;
938 #endif
939 }
940
941 #ifdef AFS_AIX32_ENV
942
943 #include "sys/lockl.h"
944
945 /*
946  * syscall -    this is the VRMIX system call entry point.
947  *
948  * NOTE:
949  *      THIS SHOULD BE CHANGED TO afs_syscall(), but requires
950  *      all the user-level calls to `syscall' to change.
951  */
952 syscall(syscall, p1, p2, p3, p4, p5, p6)
953 {
954     register rval1 = 0, code;
955     register monster;
956     int retval = 0;
957 #ifndef AFS_AIX41_ENV
958     extern lock_t kernel_lock;
959     monster = lockl(&kernel_lock, LOCK_SHORT);
960 #endif /* !AFS_AIX41_ENV */
961
962     AFS_STATCNT(syscall);
963     setuerror(0);
964     switch (syscall) {
965     case AFSCALL_CALL:
966         rval1 = afs_syscall_call(p1, p2, p3, p4, p5, p6);
967         break;
968
969     case AFSCALL_SETPAG:
970         AFS_GLOCK();
971         rval1 = afs_setpag();
972         AFS_GUNLOCK();
973         break;
974
975     case AFSCALL_PIOCTL:
976         AFS_GLOCK();
977         rval1 = afs_syscall_pioctl(p1, p2, p3, p4);
978         AFS_GUNLOCK();
979         break;
980
981     case AFSCALL_ICREATE:
982         rval1 = afs_syscall_icreate(p1, p2, p3, p4, p5, p6);
983         break;
984
985     case AFSCALL_IOPEN:
986         rval1 = afs_syscall_iopen(p1, p2, p3);
987         break;
988
989     case AFSCALL_IDEC:
990         rval1 = afs_syscall_iincdec(p1, p2, p3, -1);
991         break;
992
993     case AFSCALL_IINC:
994         rval1 = afs_syscall_iincdec(p1, p2, p3, 1);
995         break;
996
997     case AFSCALL_ICL:
998         AFS_GLOCK();
999         code = Afscall_icl(p1, p2, p3, p4, p5, &retval);
1000         AFS_GUNLOCK();
1001         if (!code)
1002             rval1 = retval;
1003         if (!rval1)
1004             rval1 = code;
1005         break;
1006
1007     default:
1008         rval1 = EINVAL;
1009         setuerror(EINVAL);
1010         break;
1011     }
1012
1013   out:
1014 #ifndef AFS_AIX41_ENV
1015     if (monster != LOCK_NEST)
1016         unlockl(&kernel_lock);
1017 #endif /* !AFS_AIX41_ENV */
1018     return getuerror()? -1 : rval1;
1019 }
1020
1021 /*
1022  * lsetpag -    interface to afs_setpag().
1023  */
1024 lsetpag()
1025 {
1026
1027     AFS_STATCNT(lsetpag);
1028     return syscall(AFSCALL_SETPAG, 0, 0, 0, 0, 0);
1029 }
1030
1031 /*
1032  * lpioctl -    interface to pioctl()
1033  */
1034 lpioctl(path, cmd, cmarg, follow)
1035      char *path, *cmarg;
1036 {
1037
1038     AFS_STATCNT(lpioctl);
1039     return syscall(AFSCALL_PIOCTL, path, cmd, cmarg, follow);
1040 }
1041
1042 #else /* !AFS_AIX32_ENV       */
1043
1044 #if defined(AFS_SGI_ENV)
1045 struct afsargs {
1046     sysarg_t syscall;
1047     sysarg_t parm1;
1048     sysarg_t parm2;
1049     sysarg_t parm3;
1050     sysarg_t parm4;
1051     sysarg_t parm5;
1052 };
1053
1054
1055 int
1056 Afs_syscall(struct afsargs *uap, rval_t * rvp)
1057 {
1058     int error;
1059     long retval;
1060
1061     AFS_STATCNT(afs_syscall);
1062     switch (uap->syscall) {
1063     case AFSCALL_ICL:
1064         retval = 0;
1065         AFS_GLOCK();
1066         error =
1067             Afscall_icl(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
1068                         uap->parm5, &retval);
1069         AFS_GUNLOCK();
1070         rvp->r_val1 = retval;
1071         break;
1072 #ifdef AFS_SGI_XFS_IOPS_ENV
1073     case AFSCALL_IDEC64:
1074         error =
1075             afs_syscall_idec64(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
1076                                uap->parm5);
1077         break;
1078     case AFSCALL_IINC64:
1079         error =
1080             afs_syscall_iinc64(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
1081                                uap->parm5);
1082         break;
1083     case AFSCALL_ILISTINODE64:
1084         error =
1085             afs_syscall_ilistinode64(uap->parm1, uap->parm2, uap->parm3,
1086                                      uap->parm4, uap->parm5);
1087         break;
1088     case AFSCALL_ICREATENAME64:
1089         error =
1090             afs_syscall_icreatename64(uap->parm1, uap->parm2, uap->parm3,
1091                                       uap->parm4, uap->parm5);
1092         break;
1093 #endif
1094 #ifdef AFS_SGI_VNODE_GLUE
1095     case AFSCALL_INIT_KERNEL_CONFIG:
1096         error = afs_init_kernel_config(uap->parm1);
1097         break;
1098 #endif
1099     default:
1100         error =
1101             afs_syscall_call(uap->syscall, uap->parm1, uap->parm2, uap->parm3,
1102                              uap->parm4, uap->parm5);
1103     }
1104     return error;
1105 }
1106
1107 #else /* AFS_SGI_ENV */
1108
1109 struct iparam {
1110     long param1;
1111     long param2;
1112     long param3;
1113     long param4;
1114 };
1115
1116 struct iparam32 {
1117     int param1;
1118     int param2;
1119     int param3;
1120     int param4;
1121 };
1122
1123
1124 #if defined(AFS_HPUX_64BIT_ENV) || defined(AFS_SUN57_64BIT_ENV) || (defined(AFS_LINUX_64BIT_KERNEL) && !defined(AFS_ALPHA_LINUX20_ENV) && !defined(AFS_IA64_LINUX20_ENV))
1125 static void
1126 iparam32_to_iparam(const struct iparam32 *src, struct iparam *dst)
1127 {
1128     dst->param1 = src->param1;
1129     dst->param2 = src->param2;
1130     dst->param3 = src->param3;
1131     dst->param4 = src->param4;
1132 }
1133 #endif
1134
1135 /*
1136  * If you need to change copyin_iparam(), you may also need to change
1137  * copyin_afs_ioctl().
1138  */
1139
1140 static int
1141 copyin_iparam(caddr_t cmarg, struct iparam *dst)
1142 {
1143     int code;
1144
1145 #if defined(AFS_HPUX_64BIT_ENV)
1146     struct iparam32 dst32;
1147
1148     if (is_32bit(u.u_procp)) {  /* is_32bit() in proc_iface.h */
1149         AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code);
1150         if (!code)
1151             iparam32_to_iparam(&dst32, dst);
1152         return code;
1153     }
1154 #endif /* AFS_HPUX_64BIT_ENV */
1155
1156 #if defined(AFS_SUN57_64BIT_ENV)
1157     struct iparam32 dst32;
1158
1159     if (get_udatamodel() == DATAMODEL_ILP32) {
1160         AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code);
1161         if (!code)
1162             iparam32_to_iparam(&dst32, dst);
1163         return code;
1164     }
1165 #endif /* AFS_SUN57_64BIT_ENV */
1166
1167 #if defined(AFS_LINUX_64BIT_KERNEL) && !defined(AFS_ALPHA_LINUX20_ENV) && !defined(AFS_IA64_LINUX20_ENV)
1168     struct iparam32 dst32;
1169
1170 #ifdef AFS_SPARC64_LINUX26_ENV
1171     if (test_thread_flag(TIF_32BIT))
1172 #elif AFS_SPARC64_LINUX24_ENV
1173     if (current->thread.flags & SPARC_FLAG_32BIT)
1174 #elif defined(AFS_SPARC64_LINUX20_ENV)
1175     if (current->tss.flags & SPARC_FLAG_32BIT)
1176
1177 #elif defined(AFS_AMD64_LINUX26_ENV)
1178     if (test_thread_flag(TIF_IA32))
1179 #elif defined(AFS_AMD64_LINUX20_ENV)
1180     if (current->thread.flags & THREAD_IA32)
1181
1182 #elif defined(AFS_PPC64_LINUX26_ENV)
1183     if (current->thread_info->flags & _TIF_32BIT) 
1184 #elif defined(AFS_PPC64_LINUX20_ENV)
1185     if (current->thread.flags & PPC_FLAG_32BIT) 
1186
1187 #elif defined(AFS_S390X_LINUX26_ENV)
1188     if (test_thread_flag(TIF_31BIT))
1189 #elif defined(AFS_S390X_LINUX20_ENV)
1190     if (current->thread.flags & S390_FLAG_31BIT) 
1191
1192 #else
1193 #error iparam32 not done for this linux platform
1194 #endif
1195     {
1196         AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code);
1197         if (!code)
1198             iparam32_to_iparam(&dst32, dst);
1199         return code;
1200     }
1201 #endif /* AFS_LINUX_64BIT_KERNEL */
1202
1203     AFS_COPYIN(cmarg, (caddr_t) dst, sizeof *dst, code);
1204     return code;
1205 }
1206
1207 /* Main entry of all afs system calls */
1208 #ifdef  AFS_SUN5_ENV
1209 extern int afs_sinited;
1210
1211 /** The 32 bit OS expects the members of this structure to be 32 bit
1212  * quantities and the 64 bit OS expects them as 64 bit quanties. Hence
1213  * to accomodate both, *long* is used instead of afs_int32
1214  */
1215
1216 #ifdef AFS_SUN57_ENV
1217 struct afssysa {
1218     long syscall;
1219     long parm1;
1220     long parm2;
1221     long parm3;
1222     long parm4;
1223     long parm5;
1224     long parm6;
1225 };
1226 #else
1227 struct afssysa {
1228     afs_int32 syscall;
1229     afs_int32 parm1;
1230     afs_int32 parm2;
1231     afs_int32 parm3;
1232     afs_int32 parm4;
1233     afs_int32 parm5;
1234     afs_int32 parm6;
1235 };
1236 #endif
1237
1238 Afs_syscall(register struct afssysa *uap, rval_t * rvp)
1239 {
1240     int *retval = &rvp->r_val1;
1241 #else /* AFS_SUN5_ENV */
1242 #if     defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
1243 int
1244 afs3_syscall(p, args, retval)
1245 #ifdef AFS_FBSD50_ENV
1246      struct thread *p;
1247 #else
1248      struct proc *p;
1249 #endif
1250      void *args;
1251      int *retval;
1252 {
1253     register struct a {
1254         long syscall;
1255         long parm1;
1256         long parm2;
1257         long parm3;
1258         long parm4;
1259         long parm5;
1260         long parm6;
1261     } *uap = (struct a *)args;
1262 #else /* AFS_OSF_ENV */
1263 #ifdef AFS_LINUX20_ENV
1264 struct afssysargs {
1265     long syscall;
1266     long parm1;
1267     long parm2;
1268     long parm3;
1269     long parm4;
1270     long parm5;
1271     long parm6;                 /* not actually used - should be removed */
1272 };
1273 /* Linux system calls only set up for 5 arguments. */
1274 asmlinkage long
1275 afs_syscall(long syscall, long parm1, long parm2, long parm3, long parm4)
1276 {
1277     struct afssysargs args, *uap = &args;
1278     long linux_ret = 0;
1279     long *retval = &linux_ret;
1280     long eparm[4];              /* matches AFSCALL_ICL in fstrace.c */
1281 #ifdef AFS_SPARC64_LINUX24_ENV
1282     afs_int32 eparm32[4];
1283 #endif
1284     /* eparm is also used by AFSCALL_CALL in afsd.c */
1285 #else
1286 #if defined(UKERNEL)
1287 Afs_syscall()
1288 {
1289     register struct a {
1290         long syscall;
1291         long parm1;
1292         long parm2;
1293         long parm3;
1294         long parm4;
1295         long parm5;
1296         long parm6;
1297     } *uap = (struct a *)u.u_ap;
1298 #else /* UKERNEL */
1299 int
1300 Afs_syscall()
1301 {
1302     register struct a {
1303         long syscall;
1304         long parm1;
1305         long parm2;
1306         long parm3;
1307         long parm4;
1308         long parm5;
1309         long parm6;
1310     } *uap = (struct a *)u.u_ap;
1311 #endif /* UKERNEL */
1312 #if defined(AFS_HPUX_ENV)
1313     long *retval = &u.u_rval1;
1314 #else
1315     int *retval = &u.u_rval1;
1316 #endif
1317 #endif /* AFS_LINUX20_ENV */
1318 #endif /* AFS_OSF_ENV */
1319 #endif /* AFS_SUN5_ENV */
1320     register int code = 0;
1321
1322     AFS_STATCNT(afs_syscall);
1323 #ifdef        AFS_SUN5_ENV
1324     rvp->r_vals = 0;
1325     if (!afs_sinited) {
1326         return (ENODEV);
1327     }
1328 #endif
1329 #ifdef AFS_LINUX20_ENV
1330     lock_kernel();
1331     /* setup uap for use below - pull out the magic decoder ring to know
1332      * which syscalls have folded argument lists.
1333      */
1334     uap->syscall = syscall;
1335     uap->parm1 = parm1;
1336     uap->parm2 = parm2;
1337     uap->parm3 = parm3;
1338     if (syscall == AFSCALL_ICL || syscall == AFSCALL_CALL) {
1339 #ifdef AFS_SPARC64_LINUX24_ENV
1340 /* from arch/sparc64/kernel/sys_sparc32.c */
1341 #define AA(__x)                                \
1342 ({     unsigned long __ret;            \
1343        __asm__ ("srl   %0, 0, %0"      \
1344                 : "=r" (__ret)         \
1345                 : "0" (__x));          \
1346        __ret;                          \
1347 })
1348
1349
1350 #ifdef AFS_SPARC64_LINUX26_ENV
1351         if (test_thread_flag(TIF_32BIT))
1352 #else
1353         if (current->thread.flags & SPARC_FLAG_32BIT)
1354 #endif
1355         {
1356             AFS_COPYIN((char *)parm4, (char *)eparm32, sizeof(eparm32), code);
1357             eparm[0] = AA(eparm32[0]);
1358             eparm[1] = AA(eparm32[1]);
1359             eparm[2] = AA(eparm32[2]);
1360 #undef AA
1361         } else
1362 #endif
1363             AFS_COPYIN((char *)parm4, (char *)eparm, sizeof(eparm), code);
1364         uap->parm4 = eparm[0];
1365         uap->parm5 = eparm[1];
1366         uap->parm6 = eparm[2];
1367     } else {
1368         uap->parm4 = parm4;
1369         uap->parm5 = 0;
1370         uap->parm6 = 0;
1371     }
1372 #endif
1373
1374 #if defined(AFS_HPUX_ENV)
1375     /*
1376      * There used to be code here (duplicated from osi_Init()) for
1377      * initializing the semaphore used by AFS_GLOCK().  Was the
1378      * duplication to handle the case of a dynamically loaded kernel
1379      * module?
1380      */
1381     osi_InitGlock();
1382 #endif
1383     if (uap->syscall == AFSCALL_CALL) {
1384 #ifdef  AFS_SUN5_ENV
1385         code =
1386             afs_syscall_call(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
1387                              uap->parm5, uap->parm6, rvp, CRED());
1388 #else
1389         code =
1390             afs_syscall_call(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
1391                              uap->parm5, uap->parm6);
1392 #endif
1393     } else if (uap->syscall == AFSCALL_SETPAG) {
1394 #ifdef  AFS_SUN5_ENV
1395         register proc_t *procp;
1396
1397         procp = ttoproc(curthread);
1398         AFS_GLOCK();
1399         code = afs_setpag(&procp->p_cred);
1400         AFS_GUNLOCK();
1401 #else
1402         AFS_GLOCK();
1403 #if     defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
1404         code = afs_setpag(p, args, retval);
1405 #else /* AFS_OSF_ENV */
1406         code = afs_setpag();
1407 #endif
1408         AFS_GUNLOCK();
1409 #endif
1410     } else if (uap->syscall == AFSCALL_PIOCTL) {
1411         AFS_GLOCK();
1412 #if defined(AFS_SUN5_ENV)
1413         code =
1414             afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
1415                                rvp, CRED());
1416 #elif defined(AFS_FBSD50_ENV)
1417         code =
1418             afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
1419                                p->td_ucred);
1420 #elif defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
1421         code =
1422             afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
1423                                p->p_cred->pc_ucred);
1424 #else
1425         code =
1426             afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3,
1427                                uap->parm4);
1428 #endif
1429         AFS_GUNLOCK();
1430     } else if (uap->syscall == AFSCALL_ICREATE) {
1431         struct iparam iparams;
1432
1433         code = copyin_iparam((char *)uap->parm3, &iparams);
1434         if (code) {
1435 #if defined(KERNEL_HAVE_UERROR)
1436             setuerror(code);
1437 #endif
1438         } else
1439 #ifdef  AFS_SUN5_ENV
1440             code =
1441                 afs_syscall_icreate(uap->parm1, uap->parm2, iparams.param1,
1442                                     iparams.param2, iparams.param3,
1443                                     iparams.param4, rvp, CRED());
1444 #else
1445             code =
1446                 afs_syscall_icreate(uap->parm1, uap->parm2, iparams.param1,
1447                                     iparams.param2,
1448 #if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
1449                                     iparams.param3, iparams.param4, retval);
1450 #else
1451                                     iparams.param3, iparams.param4);
1452 #endif
1453 #endif /* AFS_SUN5_ENV */
1454     } else if (uap->syscall == AFSCALL_IOPEN) {
1455 #ifdef  AFS_SUN5_ENV
1456         code =
1457             afs_syscall_iopen(uap->parm1, uap->parm2, uap->parm3, rvp,
1458                               CRED());
1459 #else
1460 #if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
1461         code = afs_syscall_iopen(uap->parm1, uap->parm2, uap->parm3, retval);
1462 #else
1463         code = afs_syscall_iopen(uap->parm1, uap->parm2, uap->parm3);
1464 #endif
1465 #endif /* AFS_SUN5_ENV */
1466     } else if (uap->syscall == AFSCALL_IDEC) {
1467 #ifdef  AFS_SUN5_ENV
1468         code =
1469             afs_syscall_iincdec(uap->parm1, uap->parm2, uap->parm3, -1, rvp,
1470                                 CRED());
1471 #else
1472         code = afs_syscall_iincdec(uap->parm1, uap->parm2, uap->parm3, -1);
1473 #endif /* AFS_SUN5_ENV */
1474     } else if (uap->syscall == AFSCALL_IINC) {
1475 #ifdef  AFS_SUN5_ENV
1476         code =
1477             afs_syscall_iincdec(uap->parm1, uap->parm2, uap->parm3, 1, rvp,
1478                                 CRED());
1479 #else
1480         code = afs_syscall_iincdec(uap->parm1, uap->parm2, uap->parm3, 1);
1481 #endif /* AFS_SUN5_ENV */
1482     } else if (uap->syscall == AFSCALL_ICL) {
1483         AFS_GLOCK();
1484         code =
1485             Afscall_icl(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
1486                         uap->parm5, retval);
1487         AFS_GUNLOCK();
1488 #ifdef AFS_LINUX20_ENV
1489         if (!code) {
1490             /* ICL commands can return values. */
1491             code = -linux_ret;  /* Gets negated again at exit below */
1492         }
1493 #else
1494         if (code) {
1495 #if defined(KERNEL_HAVE_UERROR)
1496             setuerror(code);
1497 #endif
1498         }
1499 #endif /* !AFS_LINUX20_ENV */
1500     } else {
1501 #if defined(KERNEL_HAVE_UERROR)
1502         setuerror(EINVAL);
1503 #else
1504         code = EINVAL;
1505 #endif
1506     }
1507
1508 #ifdef AFS_LINUX20_ENV
1509     code = -code;
1510     unlock_kernel();
1511 #endif
1512     return code;
1513 }
1514 #endif /* AFS_SGI_ENV */
1515 #endif /* !AFS_AIX32_ENV       */
1516
1517 /*
1518  * Initstate in the range 0 < x < 100 are early initialization states.
1519  * Initstate of 100 means a AFSOP_START operation has been done.  After this,
1520  *  the cache may be initialized.
1521  * Initstate of 101 means a AFSOP_GO operation has been done.  This operation
1522  *  is done after all the cache initialization has been done.
1523  * Initstate of 200 means that the volume has been looked up once, possibly
1524  *  incorrectly.
1525  * Initstate of 300 means that the volume has been *successfully* looked up.
1526  */
1527 int
1528 afs_CheckInit(void)
1529 {
1530     register int code = 0;
1531
1532     AFS_STATCNT(afs_CheckInit);
1533     if (afs_initState <= 100)
1534         code = ENXIO;           /* never finished init phase */
1535     else if (afs_initState == 101) {    /* init done, wait for afs_daemon */
1536         while (afs_initState < 200)
1537             afs_osi_Sleep(&afs_initState);
1538     } else if (afs_initState == 200)
1539         code = ETIMEDOUT;       /* didn't find root volume */
1540     return code;
1541 }
1542
1543 int afs_shuttingdown = 0;
1544 void
1545 afs_shutdown(void)
1546 {
1547     extern short afs_brsDaemons;
1548     extern afs_int32 afs_CheckServerDaemonStarted;
1549     extern struct afs_osi_WaitHandle AFS_WaitHandler, AFS_CSWaitHandler;
1550     extern struct osi_file *afs_cacheInodep;
1551
1552     AFS_STATCNT(afs_shutdown);
1553     if (afs_initState == 0) {
1554         afs_warn("AFS not initialized - not shutting down\n");
1555       return;
1556     }
1557
1558     if (afs_shuttingdown)
1559         return;
1560     afs_shuttingdown = 1;
1561     if (afs_cold_shutdown)
1562         afs_warn("COLD ");
1563     else
1564         afs_warn("WARM ");
1565     afs_warn("shutting down of: CB... ");
1566
1567     afs_termState = AFSOP_STOP_RXCALLBACK;
1568     rx_WakeupServerProcs();
1569 #ifdef AFS_AIX51_ENV
1570     shutdown_rxkernel();
1571 #endif
1572     /* shutdown_rxkernel(); */
1573     while (afs_termState == AFSOP_STOP_RXCALLBACK)
1574         afs_osi_Sleep(&afs_termState);
1575
1576     afs_warn("afs... ");
1577     while (afs_termState == AFSOP_STOP_AFS) {
1578         afs_osi_CancelWait(&AFS_WaitHandler);
1579         afs_osi_Sleep(&afs_termState);
1580     }
1581     if (afs_CheckServerDaemonStarted) {
1582         while (afs_termState == AFSOP_STOP_CS) {
1583             afs_osi_CancelWait(&AFS_CSWaitHandler);
1584             afs_osi_Sleep(&afs_termState);
1585         }
1586     }
1587     afs_warn("BkG... ");
1588     /* Wake-up afs_brsDaemons so that we don't have to wait for a bkg job! */
1589     while (afs_termState == AFSOP_STOP_BKG) {
1590         afs_osi_Wakeup(&afs_brsDaemons);
1591         afs_osi_Sleep(&afs_termState);
1592     }
1593     afs_warn("CTrunc... ");
1594     /* Cancel cache truncate daemon. */
1595     while (afs_termState == AFSOP_STOP_TRUNCDAEMON) {
1596         afs_osi_Wakeup((char *)&afs_CacheTruncateDaemon);
1597         afs_osi_Sleep(&afs_termState);
1598     }
1599 #ifdef AFS_AFSDB_ENV
1600     afs_warn("AFSDB... ");
1601     afs_StopAFSDB();
1602     while (afs_termState == AFSOP_STOP_AFSDB)
1603         afs_osi_Sleep(&afs_termState);
1604 #endif
1605 #if     defined(AFS_SUN5_ENV) || defined(RXK_LISTENER_ENV)
1606     afs_warn("RxEvent... ");
1607     /* cancel rx event daemon */
1608     while (afs_termState == AFSOP_STOP_RXEVENT)
1609         afs_osi_Sleep(&afs_termState);
1610 #if defined(RXK_LISTENER_ENV)
1611 #ifndef UKERNEL
1612     afs_warn("UnmaskRxkSignals... ");
1613     afs_osi_UnmaskRxkSignals();
1614 #endif
1615     /* cancel rx listener */
1616     afs_warn("RxListener... ");
1617     osi_StopListener();         /* This closes rx_socket. */
1618     while (afs_termState == AFSOP_STOP_RXK_LISTENER) {
1619         afs_warn("Sleep... ");
1620         afs_osi_Sleep(&afs_termState);
1621     }
1622 #endif
1623 #else
1624     afs_termState = AFSOP_STOP_COMPLETE;
1625 #endif
1626     afs_warn("\n");
1627
1628     /* Close file only after daemons which can write to it are stopped. */
1629     if (afs_cacheInodep) {      /* memcache won't set this */
1630         osi_UFSClose(afs_cacheInodep);  /* Since we always leave it open */
1631         afs_cacheInodep = 0;
1632     }
1633     return;                     /* Just kill daemons for now */
1634 #ifdef notdef
1635     shutdown_CB();
1636     shutdown_AFS();
1637     shutdown_rxkernel();
1638     shutdown_rxevent();
1639     shutdown_rx();
1640     afs_shutdown_BKG();
1641     shutdown_bufferpackage();
1642 #endif
1643 #ifdef AFS_AIX51_ENV
1644     shutdown_daemons();
1645 #endif
1646 #ifdef notdef
1647     shutdown_cache();
1648     shutdown_osi();
1649     shutdown_osinet();
1650     shutdown_osifile();
1651     shutdown_vnodeops();
1652     shutdown_vfsops();
1653     shutdown_exporter();
1654     shutdown_memcache();
1655 #if (!defined(AFS_NONFSTRANS) || defined(AFS_AIX_IAUTH_ENV)) && !defined(AFS_OSF_ENV)
1656     shutdown_nfsclnt();
1657 #endif
1658     shutdown_afstest();
1659     /* The following hold the cm stats */
1660 /*
1661     memset(&afs_cmstats, 0, sizeof(struct afs_CMStats));
1662     memset(&afs_stats_cmperf, 0, sizeof(struct afs_stats_CMPerf));
1663     memset(&afs_stats_cmfullperf, 0, sizeof(struct afs_stats_CMFullPerf));
1664 */
1665     afs_warn(" ALL allocated tables\n");
1666     afs_shuttingdown = 0;
1667 #endif
1668 }
1669
1670 void
1671 shutdown_afstest(void)
1672 {
1673     AFS_STATCNT(shutdown_afstest);
1674     afs_initState = afs_termState = afs_setTime = 0;
1675     AFS_Running = afs_CB_Running = 0;
1676     afs_CacheInit_Done = afs_Go_Done = 0;
1677     if (afs_cold_shutdown) {
1678         *afs_rootVolumeName = 0;
1679     }
1680 }
1681
1682
1683 /* In case there is a bunch of dynamically build bkg daemons to free */
1684 void
1685 afs_shutdown_BKG(void)
1686 {
1687     AFS_STATCNT(shutdown_BKG);
1688 }
1689
1690
1691 #if defined(AFS_OSF_ENV) || defined(AFS_SGI61_ENV)
1692 /* For SGI 6.2, this can is changed to 1 if it's a 32 bit kernel. */
1693 #if defined(AFS_SGI62_ENV) && defined(KERNEL) && !defined(_K64U64)
1694 int afs_icl_sizeofLong = 1;
1695 #else
1696 int afs_icl_sizeofLong = 2;
1697 #endif /* SGI62 */
1698 #else
1699 #if defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL)
1700 int afs_icl_sizeofLong = 2;
1701 #else
1702 int afs_icl_sizeofLong = 1;
1703 #endif
1704 #endif
1705
1706 int afs_icl_inited = 0;
1707
1708 /* init function, called once, under afs_icl_lock */
1709 int
1710 afs_icl_Init(void)
1711 {
1712     afs_icl_inited = 1;
1713     return 0;
1714 }
1715
1716 extern struct afs_icl_log *afs_icl_FindLog();
1717 extern struct afs_icl_set *afs_icl_FindSet();
1718
1719
1720 static int
1721 Afscall_icl(long opcode, long p1, long p2, long p3, long p4, long *retval)
1722 {
1723     afs_int32 *lp, elts, flags;
1724     register afs_int32 code;
1725     struct afs_icl_log *logp;
1726     struct afs_icl_set *setp;
1727 #if defined(AFS_SGI61_ENV) || defined(AFS_SUN57_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
1728     size_t temp;
1729 #else /* AFS_SGI61_ENV */
1730 #if defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL)
1731     afs_uint64 temp;
1732 #else
1733     afs_uint32 temp;
1734 #endif
1735 #endif /* AFS_SGI61_ENV */
1736     char tname[65];
1737     afs_int32 startCookie;
1738     afs_int32 allocated;
1739     struct afs_icl_log *tlp;
1740
1741 #ifdef  AFS_SUN5_ENV
1742     if (!afs_suser(CRED())) {   /* only root can run this code */
1743         return (EACCES);
1744     }
1745 #else
1746     if (!afs_suser(NULL)) {     /* only root can run this code */
1747 #if defined(KERNEL_HAVE_UERROR)
1748         setuerror(EACCES);
1749         return EACCES;
1750 #else
1751         return EPERM;
1752 #endif
1753     }
1754 #endif
1755     switch (opcode) {
1756     case ICL_OP_COPYOUTCLR:     /* copy out data then clear */
1757     case ICL_OP_COPYOUT:        /* copy ouy data */
1758         /* copyout: p1=logname, p2=&buffer, p3=size(words), p4=&cookie
1759          * return flags<<24 + nwords.
1760          * updates cookie to updated start (not end) if we had to
1761          * skip some records.
1762          */
1763         AFS_COPYINSTR((char *)p1, tname, sizeof(tname), &temp, code);
1764         if (code)
1765             return code;
1766         AFS_COPYIN((char *)p4, (char *)&startCookie, sizeof(afs_int32), code);
1767         if (code)
1768             return code;
1769         logp = afs_icl_FindLog(tname);
1770         if (!logp)
1771             return ENOENT;
1772 #define BUFFERSIZE      AFS_LRALLOCSIZ
1773         lp = (afs_int32 *) osi_AllocLargeSpace(AFS_LRALLOCSIZ);
1774         elts = BUFFERSIZE / sizeof(afs_int32);
1775         if (p3 < elts)
1776             elts = p3;
1777         flags = (opcode == ICL_OP_COPYOUT) ? 0 : ICL_COPYOUTF_CLRAFTERREAD;
1778         code =
1779             afs_icl_CopyOut(logp, lp, &elts, (afs_uint32 *) & startCookie,
1780                             &flags);
1781         if (code) {
1782             osi_FreeLargeSpace((struct osi_buffer *)lp);
1783             break;
1784         }
1785         AFS_COPYOUT((char *)lp, (char *)p2, elts * sizeof(afs_int32), code);
1786         if (code)
1787             goto done;
1788         AFS_COPYOUT((char *)&startCookie, (char *)p4, sizeof(afs_int32),
1789                     code);
1790         if (code)
1791             goto done;
1792 #if defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL)
1793         if (!(IS64U))
1794             *retval = ((long)((flags << 24) | (elts & 0xffffff))) << 32;
1795         else
1796 #endif
1797             *retval = (flags << 24) | (elts & 0xffffff);
1798       done:
1799         afs_icl_LogRele(logp);
1800         osi_FreeLargeSpace((struct osi_buffer *)lp);
1801         break;
1802
1803     case ICL_OP_ENUMLOGS:       /* enumerate logs */
1804         /* enumerate logs: p1=index, p2=&name, p3=sizeof(name), p4=&size.
1805          * return 0 for success, otherwise error.
1806          */
1807         for (tlp = afs_icl_allLogs; tlp; tlp = tlp->nextp) {
1808             if (p1-- == 0)
1809                 break;
1810         }
1811         if (!tlp)
1812             return ENOENT;      /* past the end of file */
1813         temp = strlen(tlp->name) + 1;
1814         if (temp > p3)
1815             return EINVAL;
1816         AFS_COPYOUT(tlp->name, (char *)p2, temp, code);
1817         if (!code)              /* copy out size of log */
1818             AFS_COPYOUT((char *)&tlp->logSize, (char *)p4, sizeof(afs_int32),
1819                         code);
1820         break;
1821
1822     case ICL_OP_ENUMLOGSBYSET:  /* enumerate logs by set name */
1823         /* enumerate logs: p1=setname, p2=index, p3=&name, p4=sizeof(name).
1824          * return 0 for success, otherwise error.
1825          */
1826         AFS_COPYINSTR((char *)p1, tname, sizeof(tname), &temp, code);
1827         if (code)
1828             return code;
1829         setp = afs_icl_FindSet(tname);
1830         if (!setp)
1831             return ENOENT;
1832         if (p2 > ICL_LOGSPERSET)
1833             return EINVAL;
1834         if (!(tlp = setp->logs[p2]))
1835             return EBADF;
1836         temp = strlen(tlp->name) + 1;
1837         if (temp > p4)
1838             return EINVAL;
1839         AFS_COPYOUT(tlp->name, (char *)p3, temp, code);
1840         break;
1841
1842     case ICL_OP_CLRLOG: /* clear specified log */
1843         /* zero out the specified log: p1=logname */
1844         AFS_COPYINSTR((char *)p1, tname, sizeof(tname), &temp, code);
1845         if (code)
1846             return code;
1847         logp = afs_icl_FindLog(tname);
1848         if (!logp)
1849             return ENOENT;
1850         code = afs_icl_ZeroLog(logp);
1851         afs_icl_LogRele(logp);
1852         break;
1853
1854     case ICL_OP_CLRSET: /* clear specified set */
1855         /* zero out the specified set: p1=setname */
1856         AFS_COPYINSTR((char *)p1, tname, sizeof(tname), &temp, code);
1857         if (code)
1858             return code;
1859         setp = afs_icl_FindSet(tname);
1860         if (!setp)
1861             return ENOENT;
1862         code = afs_icl_ZeroSet(setp);
1863         afs_icl_SetRele(setp);
1864         break;
1865
1866     case ICL_OP_CLRALL: /* clear all logs */
1867         /* zero out all logs -- no args */
1868         code = 0;
1869         ObtainWriteLock(&afs_icl_lock, 178);
1870         for (tlp = afs_icl_allLogs; tlp; tlp = tlp->nextp) {
1871             tlp->refCount++;    /* hold this guy */
1872             ReleaseWriteLock(&afs_icl_lock);
1873             /* don't clear persistent logs */
1874             if ((tlp->states & ICL_LOGF_PERSISTENT) == 0)
1875                 code = afs_icl_ZeroLog(tlp);
1876             ObtainWriteLock(&afs_icl_lock, 179);
1877             if (--tlp->refCount == 0)
1878                 afs_icl_ZapLog(tlp);
1879             if (code)
1880                 break;
1881         }
1882         ReleaseWriteLock(&afs_icl_lock);
1883         break;
1884
1885     case ICL_OP_ENUMSETS:       /* enumerate all sets */
1886         /* enumerate sets: p1=index, p2=&name, p3=sizeof(name), p4=&states.
1887          * return 0 for success, otherwise error.
1888          */
1889         for (setp = afs_icl_allSets; setp; setp = setp->nextp) {
1890             if (p1-- == 0)
1891                 break;
1892         }
1893         if (!setp)
1894             return ENOENT;      /* past the end of file */
1895         temp = strlen(setp->name) + 1;
1896         if (temp > p3)
1897             return EINVAL;
1898         AFS_COPYOUT(setp->name, (char *)p2, temp, code);
1899         if (!code)              /* copy out size of log */
1900             AFS_COPYOUT((char *)&setp->states, (char *)p4, sizeof(afs_int32),
1901                         code);
1902         break;
1903
1904     case ICL_OP_SETSTAT:        /* set status on a set */
1905         /* activate the specified set: p1=setname, p2=op */
1906         AFS_COPYINSTR((char *)p1, tname, sizeof(tname), &temp, code);
1907         if (code)
1908             return code;
1909         setp = afs_icl_FindSet(tname);
1910         if (!setp)
1911             return ENOENT;
1912         code = afs_icl_SetSetStat(setp, p2);
1913         afs_icl_SetRele(setp);
1914         break;
1915
1916     case ICL_OP_SETSTATALL:     /* set status on all sets */
1917         /* activate the specified set: p1=op */
1918         code = 0;
1919         ObtainWriteLock(&afs_icl_lock, 180);
1920         for (setp = afs_icl_allSets; setp; setp = setp->nextp) {
1921             setp->refCount++;   /* hold this guy */
1922             ReleaseWriteLock(&afs_icl_lock);
1923             /* don't set states on persistent sets */
1924             if ((setp->states & ICL_SETF_PERSISTENT) == 0)
1925                 code = afs_icl_SetSetStat(setp, p1);
1926             ObtainWriteLock(&afs_icl_lock, 181);
1927             if (--setp->refCount == 0)
1928                 afs_icl_ZapSet(setp);
1929             if (code)
1930                 break;
1931         }
1932         ReleaseWriteLock(&afs_icl_lock);
1933         break;
1934
1935     case ICL_OP_SETLOGSIZE:     /* set size of log */
1936         /* set the size of the specified log: p1=logname, p2=size (in words) */
1937         AFS_COPYINSTR((char *)p1, tname, sizeof(tname), &temp, code);
1938         if (code)
1939             return code;
1940         logp = afs_icl_FindLog(tname);
1941         if (!logp)
1942             return ENOENT;
1943         code = afs_icl_LogSetSize(logp, p2);
1944         afs_icl_LogRele(logp);
1945         break;
1946
1947     case ICL_OP_GETLOGINFO:     /* get size of log */
1948         /* zero out the specified log: p1=logname, p2=&logSize, p3=&allocated */
1949         AFS_COPYINSTR((char *)p1, tname, sizeof(tname), &temp, code);
1950         if (code)
1951             return code;
1952         logp = afs_icl_FindLog(tname);
1953         if (!logp)
1954             return ENOENT;
1955         allocated = !!logp->datap;
1956         AFS_COPYOUT((char *)&logp->logSize, (char *)p2, sizeof(afs_int32),
1957                     code);
1958         if (!code)
1959             AFS_COPYOUT((char *)&allocated, (char *)p3, sizeof(afs_int32),
1960                         code);
1961         afs_icl_LogRele(logp);
1962         break;
1963
1964     case ICL_OP_GETSETINFO:     /* get state of set */
1965         /* zero out the specified set: p1=setname, p2=&state */
1966         AFS_COPYINSTR((char *)p1, tname, sizeof(tname), &temp, code);
1967         if (code)
1968             return code;
1969         setp = afs_icl_FindSet(tname);
1970         if (!setp)
1971             return ENOENT;
1972         AFS_COPYOUT((char *)&setp->states, (char *)p2, sizeof(afs_int32),
1973                     code);
1974         afs_icl_SetRele(setp);
1975         break;
1976
1977     default:
1978         code = EINVAL;
1979     }
1980
1981     return code;
1982 }
1983
1984
1985 afs_lock_t afs_icl_lock;
1986
1987 /* exported routine: a 4 parameter event */
1988 int
1989 afs_icl_Event4(register struct afs_icl_set *setp, afs_int32 eventID,
1990                afs_int32 lAndT, long p1, long p2, long p3, long p4)
1991 {
1992     afs_int32 mask;
1993     register int i;
1994     register afs_int32 tmask;
1995     int ix;
1996
1997     /* If things aren't init'ed yet (or the set is inactive), don't panic */
1998     if (!ICL_SETACTIVE(setp))
1999         return 0;
2000
2001     AFS_ASSERT_GLOCK();
2002     mask = lAndT >> 24 & 0xff;  /* mask of which logs to log to */
2003     ix = ICL_EVENTBYTE(eventID);
2004     ObtainReadLock(&setp->lock);
2005     if (setp->eventFlags[ix] & ICL_EVENTMASK(eventID)) {
2006         for (i = 0, tmask = 1; i < ICL_LOGSPERSET; i++, tmask <<= 1) {
2007             if (mask & tmask) {
2008                 afs_icl_AppendRecord(setp->logs[i], eventID, lAndT & 0xffffff,
2009                                      p1, p2, p3, p4);
2010             }
2011             mask &= ~tmask;
2012             if (mask == 0)
2013                 break;          /* break early */
2014         }
2015     }
2016     ReleaseReadLock(&setp->lock);
2017     return 0;
2018 }
2019
2020 /* Next 4 routines should be implemented via var-args or something.
2021  * Whole purpose is to avoid compiler warnings about parameter # mismatches.
2022  * Otherwise, could call afs_icl_Event4 directly.
2023  */
2024 int
2025 afs_icl_Event3(register struct afs_icl_set *setp, afs_int32 eventID,
2026                afs_int32 lAndT, long p1, long p2, long p3)
2027 {
2028     return afs_icl_Event4(setp, eventID, lAndT, p1, p2, p3, (long)0);
2029 }
2030
2031 int
2032 afs_icl_Event2(register struct afs_icl_set *setp, afs_int32 eventID,
2033                afs_int32 lAndT, long p1, long p2)
2034 {
2035     return afs_icl_Event4(setp, eventID, lAndT, p1, p2, (long)0, (long)0);
2036 }
2037
2038 int
2039 afs_icl_Event1(register struct afs_icl_set *setp, afs_int32 eventID,
2040                afs_int32 lAndT, long p1)
2041 {
2042     return afs_icl_Event4(setp, eventID, lAndT, p1, (long)0, (long)0,
2043                           (long)0);
2044 }
2045
2046 int
2047 afs_icl_Event0(register struct afs_icl_set *setp, afs_int32 eventID,
2048                afs_int32 lAndT)
2049 {
2050     return afs_icl_Event4(setp, eventID, lAndT, (long)0, (long)0, (long)0,
2051                           (long)0);
2052 }
2053
2054 struct afs_icl_log *afs_icl_allLogs = 0;
2055
2056 /* function to purge records from the start of the log, until there
2057  * is at least minSpace long's worth of space available without
2058  * making the head and the tail point to the same word.
2059  *
2060  * Log must be write-locked.
2061  */
2062 static void
2063 afs_icl_GetLogSpace(register struct afs_icl_log *logp, afs_int32 minSpace)
2064 {
2065     register unsigned int tsize;
2066
2067     while (logp->logSize - logp->logElements <= minSpace) {
2068         /* eat a record */
2069         tsize = ((logp->datap[logp->firstUsed]) >> 24) & 0xff;
2070         logp->logElements -= tsize;
2071         logp->firstUsed += tsize;
2072         if (logp->firstUsed >= logp->logSize)
2073             logp->firstUsed -= logp->logSize;
2074         logp->baseCookie += tsize;
2075     }
2076 }
2077
2078 /* append string astr to buffer, including terminating null char.
2079  *
2080  * log must be write-locked.
2081  */
2082 #define ICL_CHARSPERLONG        4
2083 static void
2084 afs_icl_AppendString(struct afs_icl_log *logp, char *astr)
2085 {
2086     char *op;                   /* ptr to char to write */
2087     int tc;
2088     register int bib;           /* bytes in buffer */
2089
2090     bib = 0;
2091     op = (char *)&(logp->datap[logp->firstFree]);
2092     while (1) {
2093         tc = *astr++;
2094         *op++ = tc;
2095         if (++bib >= ICL_CHARSPERLONG) {
2096             /* new word */
2097             bib = 0;
2098             if (++(logp->firstFree) >= logp->logSize) {
2099                 logp->firstFree = 0;
2100                 op = (char *)&(logp->datap[0]);
2101             }
2102             logp->logElements++;
2103         }
2104         if (tc == 0)
2105             break;
2106     }
2107     if (bib > 0) {
2108         /* if we've used this word at all, allocate it */
2109         if (++(logp->firstFree) >= logp->logSize) {
2110             logp->firstFree = 0;
2111         }
2112         logp->logElements++;
2113     }
2114 }
2115
2116 /* add a long to the log, ignoring overflow (checked already) */
2117 #define ICL_APPENDINT32(lp, x) \
2118     MACRO_BEGIN \
2119         (lp)->datap[(lp)->firstFree] = (x); \
2120         if (++((lp)->firstFree) >= (lp)->logSize) { \
2121                 (lp)->firstFree = 0; \
2122         } \
2123         (lp)->logElements++; \
2124     MACRO_END
2125
2126 #if defined(AFS_OSF_ENV) || (defined(AFS_SGI61_ENV) && (_MIPS_SZLONG==64)) || (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL))
2127 #define ICL_APPENDLONG(lp, x) \
2128     MACRO_BEGIN \
2129         ICL_APPENDINT32((lp), ((x) >> 32) & 0xffffffffL); \
2130         ICL_APPENDINT32((lp), (x) & 0xffffffffL); \
2131     MACRO_END
2132
2133 #else /* AFS_OSF_ENV */
2134 #define ICL_APPENDLONG(lp, x) ICL_APPENDINT32((lp), (x))
2135 #endif /* AFS_OSF_ENV */
2136
2137 /* routine to tell whether we're dealing with the address or the
2138  * object itself
2139  */
2140 int
2141 afs_icl_UseAddr(int type)
2142 {
2143     if (type == ICL_TYPE_HYPER || type == ICL_TYPE_STRING
2144         || type == ICL_TYPE_FID || type == ICL_TYPE_INT64)
2145         return 1;
2146     else
2147         return 0;
2148 }
2149
2150 /* Function to append a record to the log.  Written for speed
2151  * since we know that we're going to have to make this work fast
2152  * pretty soon, anyway.  The log must be unlocked.
2153  */
2154
2155 void
2156 afs_icl_AppendRecord(register struct afs_icl_log *logp, afs_int32 op,
2157                      afs_int32 types, long p1, long p2, long p3, long p4)
2158 {
2159     int rsize;                  /* record size in longs */
2160     register int tsize;         /* temp size */
2161     osi_timeval_t tv;
2162     int t1, t2, t3, t4;
2163
2164     t4 = types & 0x3f;          /* decode types */
2165     types >>= 6;
2166     t3 = types & 0x3f;
2167     types >>= 6;
2168     t2 = types & 0x3f;
2169     types >>= 6;
2170     t1 = types & 0x3f;
2171
2172     osi_GetTime(&tv);           /* It panics for solaris if inside */
2173     ObtainWriteLock(&logp->lock, 182);
2174     if (!logp->datap) {
2175         ReleaseWriteLock(&logp->lock);
2176         return;
2177     }
2178
2179     /* get timestamp as # of microseconds since some time that doesn't
2180      * change that often.  This algorithm ticks over every 20 minutes
2181      * or so (1000 seconds).  Write a timestamp record if it has.
2182      */
2183     if (tv.tv_sec - logp->lastTS > 1024) {
2184         /* the timer has wrapped -- write a timestamp record */
2185         if (logp->logSize - logp->logElements <= 5)
2186             afs_icl_GetLogSpace(logp, 5);
2187
2188         ICL_APPENDINT32(logp,
2189                         (afs_int32) (5 << 24) + (ICL_TYPE_UNIXDATE << 18));
2190         ICL_APPENDINT32(logp, (afs_int32) ICL_INFO_TIMESTAMP);
2191         ICL_APPENDINT32(logp, (afs_int32) 0);   /* use thread ID zero for clocks */
2192         ICL_APPENDINT32(logp,
2193                         (afs_int32) (tv.tv_sec & 0x3ff) * 1000000 +
2194                         tv.tv_usec);
2195         ICL_APPENDINT32(logp, (afs_int32) tv.tv_sec);
2196
2197         logp->lastTS = tv.tv_sec;
2198     }
2199
2200     rsize = 4;                  /* base case */
2201     if (t1) {
2202         /* compute size of parameter p1.  Only tricky case is string.
2203          * In that case, we have to call strlen to get the string length.
2204          */
2205         ICL_SIZEHACK(t1, p1);
2206     }
2207     if (t2) {
2208         /* compute size of parameter p2.  Only tricky case is string.
2209          * In that case, we have to call strlen to get the string length.
2210          */
2211         ICL_SIZEHACK(t2, p2);
2212     }
2213     if (t3) {
2214         /* compute size of parameter p3.  Only tricky case is string.
2215          * In that case, we have to call strlen to get the string length.
2216          */
2217         ICL_SIZEHACK(t3, p3);
2218     }
2219     if (t4) {
2220         /* compute size of parameter p4.  Only tricky case is string.
2221          * In that case, we have to call strlen to get the string length.
2222          */
2223         ICL_SIZEHACK(t4, p4);
2224     }
2225
2226     /* At this point, we've computed all of the parameter sizes, and
2227      * have in rsize the size of the entire record we want to append.
2228      * Next, we check that we actually have room in the log to do this
2229      * work, and then we do the append.
2230      */
2231     if (rsize > 255) {
2232         ReleaseWriteLock(&logp->lock);
2233         return;                 /* log record too big to express */
2234     }
2235
2236     if (logp->logSize - logp->logElements <= rsize)
2237         afs_icl_GetLogSpace(logp, rsize);
2238
2239     ICL_APPENDINT32(logp,
2240                     (afs_int32) (rsize << 24) + (t1 << 18) + (t2 << 12) +
2241                     (t3 << 6) + t4);
2242     ICL_APPENDINT32(logp, (afs_int32) op);
2243     ICL_APPENDINT32(logp, (afs_int32) osi_ThreadUnique());
2244     ICL_APPENDINT32(logp,
2245                     (afs_int32) (tv.tv_sec & 0x3ff) * 1000000 + tv.tv_usec);
2246
2247     if (t1) {
2248         /* marshall parameter 1 now */
2249         if (t1 == ICL_TYPE_STRING) {
2250             afs_icl_AppendString(logp, (char *)p1);
2251         } else if (t1 == ICL_TYPE_HYPER) {
2252             ICL_APPENDINT32(logp,
2253                             (afs_int32) ((struct afs_hyper_t *)p1)->high);
2254             ICL_APPENDINT32(logp,
2255                             (afs_int32) ((struct afs_hyper_t *)p1)->low);
2256         } else if (t1 == ICL_TYPE_INT64) {
2257 #ifdef AFSLITTLE_ENDIAN
2258 #ifdef AFS_64BIT_CLIENT
2259             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p1)[1]);
2260             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p1)[0]);
2261 #else /* AFS_64BIT_CLIENT */
2262             ICL_APPENDINT32(logp, (afs_int32) p1);
2263             ICL_APPENDINT32(logp, (afs_int32) 0);
2264 #endif /* AFS_64BIT_CLIENT */
2265 #else /* AFSLITTLE_ENDIAN */
2266 #ifdef AFS_64BIT_CLIENT
2267             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p1)[0]);
2268             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p1)[1]);
2269 #else /* AFS_64BIT_CLIENT */
2270             ICL_APPENDINT32(logp, (afs_int32) 0);
2271             ICL_APPENDINT32(logp, (afs_int32) p1);
2272 #endif /* AFS_64BIT_CLIENT */
2273 #endif /* AFSLITTLE_ENDIAN */
2274         } else if (t1 == ICL_TYPE_FID) {
2275             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p1)[0]);
2276             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p1)[1]);
2277             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p1)[2]);
2278             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p1)[3]);
2279         }
2280 #if defined(AFS_OSF_ENV) || (defined(AFS_SGI61_ENV) && (_MIPS_SZLONG==64)) || (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL))
2281         else if (t1 == ICL_TYPE_INT32)
2282             ICL_APPENDINT32(logp, (afs_int32) p1);
2283 #endif /* AFS_OSF_ENV */
2284         else
2285             ICL_APPENDLONG(logp, p1);
2286     }
2287     if (t2) {
2288         /* marshall parameter 2 now */
2289         if (t2 == ICL_TYPE_STRING)
2290             afs_icl_AppendString(logp, (char *)p2);
2291         else if (t2 == ICL_TYPE_HYPER) {
2292             ICL_APPENDINT32(logp,
2293                             (afs_int32) ((struct afs_hyper_t *)p2)->high);
2294             ICL_APPENDINT32(logp,
2295                             (afs_int32) ((struct afs_hyper_t *)p2)->low);
2296         } else if (t2 == ICL_TYPE_INT64) {
2297 #ifdef AFSLITTLE_ENDIAN
2298 #ifdef AFS_64BIT_CLIENT
2299             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p2)[1]);
2300             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p2)[0]);
2301 #else /* AFS_64BIT_CLIENT */
2302             ICL_APPENDINT32(logp, (afs_int32) p2);
2303             ICL_APPENDINT32(logp, (afs_int32) 0);
2304 #endif /* AFS_64BIT_CLIENT */
2305 #else /* AFSLITTLE_ENDIAN */
2306 #ifdef AFS_64BIT_CLIENT
2307             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p2)[0]);
2308             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p2)[1]);
2309 #else /* AFS_64BIT_CLIENT */
2310             ICL_APPENDINT32(logp, (afs_int32) 0);
2311             ICL_APPENDINT32(logp, (afs_int32) p2);
2312 #endif /* AFS_64BIT_CLIENT */
2313 #endif /* AFSLITTLE_ENDIAN */
2314         } else if (t2 == ICL_TYPE_FID) {
2315             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p2)[0]);
2316             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p2)[1]);
2317             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p2)[2]);
2318             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p2)[3]);
2319         }
2320 #if defined(AFS_OSF_ENV) || (defined(AFS_SGI61_ENV) && (_MIPS_SZLONG==64)) || (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL))
2321         else if (t2 == ICL_TYPE_INT32)
2322             ICL_APPENDINT32(logp, (afs_int32) p2);
2323 #endif /* AFS_OSF_ENV */
2324         else
2325             ICL_APPENDLONG(logp, p2);
2326     }
2327     if (t3) {
2328         /* marshall parameter 3 now */
2329         if (t3 == ICL_TYPE_STRING)
2330             afs_icl_AppendString(logp, (char *)p3);
2331         else if (t3 == ICL_TYPE_HYPER) {
2332             ICL_APPENDINT32(logp,
2333                             (afs_int32) ((struct afs_hyper_t *)p3)->high);
2334             ICL_APPENDINT32(logp,
2335                             (afs_int32) ((struct afs_hyper_t *)p3)->low);
2336         } else if (t3 == ICL_TYPE_INT64) {
2337 #ifdef AFSLITTLE_ENDIAN
2338 #ifdef AFS_64BIT_CLIENT
2339             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p3)[1]);
2340             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p3)[0]);
2341 #else /* AFS_64BIT_CLIENT */
2342             ICL_APPENDINT32(logp, (afs_int32) p3);
2343             ICL_APPENDINT32(logp, (afs_int32) 0);
2344 #endif /* AFS_64BIT_CLIENT */
2345 #else /* AFSLITTLE_ENDIAN */
2346 #ifdef AFS_64BIT_CLIENT
2347             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p3)[0]);
2348             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p3)[1]);
2349 #else /* AFS_64BIT_CLIENT */
2350             ICL_APPENDINT32(logp, (afs_int32) 0);
2351             ICL_APPENDINT32(logp, (afs_int32) p3);
2352 #endif /* AFS_64BIT_CLIENT */
2353 #endif /* AFSLITTLE_ENDIAN */
2354         } else if (t3 == ICL_TYPE_FID) {
2355             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p3)[0]);
2356             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p3)[1]);
2357             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p3)[2]);
2358             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p3)[3]);
2359         }
2360 #if defined(AFS_OSF_ENV) || (defined(AFS_SGI61_ENV) && (_MIPS_SZLONG==64)) || (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL))
2361         else if (t3 == ICL_TYPE_INT32)
2362             ICL_APPENDINT32(logp, (afs_int32) p3);
2363 #endif /* AFS_OSF_ENV */
2364         else
2365             ICL_APPENDLONG(logp, p3);
2366     }
2367     if (t4) {
2368         /* marshall parameter 4 now */
2369         if (t4 == ICL_TYPE_STRING)
2370             afs_icl_AppendString(logp, (char *)p4);
2371         else if (t4 == ICL_TYPE_HYPER) {
2372             ICL_APPENDINT32(logp,
2373                             (afs_int32) ((struct afs_hyper_t *)p4)->high);
2374             ICL_APPENDINT32(logp,
2375                             (afs_int32) ((struct afs_hyper_t *)p4)->low);
2376         } else if (t4 == ICL_TYPE_INT64) {
2377 #ifdef AFSLITTLE_ENDIAN
2378 #ifdef AFS_64BIT_CLIENT
2379             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p4)[1]);
2380             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p4)[0]);
2381 #else /* AFS_64BIT_CLIENT */
2382             ICL_APPENDINT32(logp, (afs_int32) p4);
2383             ICL_APPENDINT32(logp, (afs_int32) 0);
2384 #endif /* AFS_64BIT_CLIENT */
2385 #else /* AFSLITTLE_ENDIAN */
2386 #ifdef AFS_64BIT_CLIENT
2387             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p4)[0]);
2388             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p4)[1]);
2389 #else /* AFS_64BIT_CLIENT */
2390             ICL_APPENDINT32(logp, (afs_int32) 0);
2391             ICL_APPENDINT32(logp, (afs_int32) p4);
2392 #endif /* AFS_64BIT_CLIENT */
2393 #endif /* AFSLITTLE_ENDIAN */
2394         } else if (t4 == ICL_TYPE_FID) {
2395             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p4)[0]);
2396             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p4)[1]);
2397             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p4)[2]);
2398             ICL_APPENDINT32(logp, (afs_int32) ((afs_int32 *) p4)[3]);
2399         }
2400 #if defined(AFS_OSF_ENV) || (defined(AFS_SGI61_ENV) && (_MIPS_SZLONG==64)) || (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL))
2401         else if (t4 == ICL_TYPE_INT32)
2402             ICL_APPENDINT32(logp, (afs_int32) p4);
2403 #endif /* AFS_OSF_ENV */
2404         else
2405             ICL_APPENDLONG(logp, p4);
2406     }
2407     ReleaseWriteLock(&logp->lock);
2408 }
2409
2410 /* create a log with size logSize; return it in *outLogpp and tag
2411  * it with name "name."
2412  */
2413 int
2414 afs_icl_CreateLog(char *name, afs_int32 logSize,
2415                   struct afs_icl_log **outLogpp)
2416 {
2417     return afs_icl_CreateLogWithFlags(name, logSize, /*flags */ 0, outLogpp);
2418 }
2419
2420 /* create a log with size logSize; return it in *outLogpp and tag
2421  * it with name "name."  'flags' can be set to make the log unclearable.
2422  */
2423 int
2424 afs_icl_CreateLogWithFlags(char *name, afs_int32 logSize, afs_uint32 flags,
2425                            struct afs_icl_log **outLogpp)
2426 {
2427     register struct afs_icl_log *logp;
2428
2429     /* add into global list under lock */
2430     ObtainWriteLock(&afs_icl_lock, 183);
2431     if (!afs_icl_inited)
2432         afs_icl_Init();
2433
2434     for (logp = afs_icl_allLogs; logp; logp = logp->nextp) {
2435         if (strcmp(logp->name, name) == 0) {
2436             /* found it already created, just return it */
2437             logp->refCount++;
2438             *outLogpp = logp;
2439             if (flags & ICL_CRLOG_FLAG_PERSISTENT) {
2440                 ObtainWriteLock(&logp->lock, 184);
2441                 logp->states |= ICL_LOGF_PERSISTENT;
2442                 ReleaseWriteLock(&logp->lock);
2443             }
2444             ReleaseWriteLock(&afs_icl_lock);
2445             return 0;
2446         }
2447     }
2448
2449     logp = (struct afs_icl_log *)
2450         osi_AllocSmallSpace(sizeof(struct afs_icl_log));
2451     memset((caddr_t) logp, 0, sizeof(*logp));
2452
2453     logp->refCount = 1;
2454     logp->name = osi_AllocSmallSpace(strlen(name) + 1);
2455     strcpy(logp->name, name);
2456     LOCK_INIT(&logp->lock, "logp lock");
2457     logp->logSize = logSize;
2458     logp->datap = NULL;         /* don't allocate it until we need it */
2459
2460     if (flags & ICL_CRLOG_FLAG_PERSISTENT)
2461         logp->states |= ICL_LOGF_PERSISTENT;
2462
2463     logp->nextp = afs_icl_allLogs;
2464     afs_icl_allLogs = logp;
2465     ReleaseWriteLock(&afs_icl_lock);
2466
2467     *outLogpp = logp;
2468     return 0;
2469 }
2470
2471 /* called with a log, a pointer to a buffer, the size of the buffer
2472  * (in *bufSizep), the starting cookie (in *cookiep, use 0 at the start)
2473  * and returns data in the provided buffer, and returns output flags
2474  * in *flagsp.  The flag ICL_COPYOUTF_MISSEDSOME is set if we can't
2475  * find the record with cookie value cookie.
2476  */
2477 int
2478 afs_icl_CopyOut(register struct afs_icl_log *logp, afs_int32 * bufferp,
2479                 afs_int32 * bufSizep, afs_uint32 * cookiep,
2480                 afs_int32 * flagsp)
2481 {
2482     afs_int32 nwords;           /* number of words to copy out */
2483     afs_uint32 startCookie;     /* first cookie to use */
2484     afs_int32 outWords;         /* words we've copied out */
2485     afs_int32 inWords;          /* max words to copy out */
2486     afs_int32 code;             /* return code */
2487     afs_int32 ix;               /* index we're copying from */
2488     afs_int32 outFlags;         /* return flags */
2489     afs_int32 inFlags;          /* flags passed in */
2490     afs_int32 end;
2491
2492     inWords = *bufSizep;        /* max to copy out */
2493     outWords = 0;               /* amount copied out */
2494     startCookie = *cookiep;
2495     outFlags = 0;
2496     inFlags = *flagsp;
2497     code = 0;
2498
2499     ObtainWriteLock(&logp->lock, 185);
2500     if (!logp->datap) {
2501         ReleaseWriteLock(&logp->lock);
2502         goto done;
2503     }
2504
2505     /* first, compute the index of the start cookie we've been passed */
2506     while (1) {
2507         /* (re-)compute where we should start */
2508         if (startCookie < logp->baseCookie) {
2509             if (startCookie)    /* missed some output */
2510                 outFlags |= ICL_COPYOUTF_MISSEDSOME;
2511             /* skip to the first available record */
2512             startCookie = logp->baseCookie;
2513             *cookiep = startCookie;
2514         }
2515
2516         /* compute where we find the first element to copy out */
2517         ix = logp->firstUsed + startCookie - logp->baseCookie;
2518         if (ix >= logp->logSize)
2519             ix -= logp->logSize;
2520
2521         /* if have some data now, break out and process it */
2522         if (startCookie - logp->baseCookie < logp->logElements)
2523             break;
2524
2525         /* At end of log, so clear it if we need to */
2526         if (inFlags & ICL_COPYOUTF_CLRAFTERREAD) {
2527             logp->firstUsed = logp->firstFree = 0;
2528             logp->logElements = 0;
2529         }
2530         /* otherwise, either wait for the data to arrive, or return */
2531         if (!(inFlags & ICL_COPYOUTF_WAITIO)) {
2532             ReleaseWriteLock(&logp->lock);
2533             code = 0;
2534             goto done;
2535         }
2536         logp->states |= ICL_LOGF_WAITING;
2537         ReleaseWriteLock(&logp->lock);
2538         afs_osi_Sleep(&logp->lock);
2539         ObtainWriteLock(&logp->lock, 186);
2540     }
2541     /* copy out data from ix to logSize or firstFree, depending
2542      * upon whether firstUsed <= firstFree (no wrap) or otherwise.
2543      * be careful not to copy out more than nwords.
2544      */
2545     if (ix >= logp->firstUsed) {
2546         if (logp->firstUsed <= logp->firstFree)
2547             /* no wrapping */
2548             end = logp->firstFree;      /* first element not to copy */
2549         else
2550             end = logp->logSize;
2551         nwords = inWords;       /* don't copy more than this */
2552         if (end - ix < nwords)
2553             nwords = end - ix;
2554         if (nwords > 0) {
2555             memcpy((char *)bufferp, (char *)&logp->datap[ix],
2556                    sizeof(afs_int32) * nwords);
2557             outWords += nwords;
2558             inWords -= nwords;
2559             bufferp += nwords;
2560         }
2561         /* if we're going to copy more out below, we'll start here */
2562         ix = 0;
2563     }
2564     /* now, if active part of the log has wrapped, there's more stuff
2565      * starting at the head of the log.  Copy out more from there.
2566      */
2567     if (logp->firstUsed > logp->firstFree && ix < logp->firstFree
2568         && inWords > 0) {
2569         /* (more to) copy out from the wrapped section at the
2570          * start of the log.  May get here even if didn't copy any
2571          * above, if the cookie points directly into the wrapped section.
2572          */
2573         nwords = inWords;
2574         if (logp->firstFree - ix < nwords)
2575             nwords = logp->firstFree - ix;
2576         memcpy((char *)bufferp, (char *)&logp->datap[ix],
2577                sizeof(afs_int32) * nwords);
2578         outWords += nwords;
2579         inWords -= nwords;
2580         bufferp += nwords;
2581     }
2582
2583     ReleaseWriteLock(&logp->lock);
2584
2585   done:
2586     if (code == 0) {
2587         *bufSizep = outWords;
2588         *flagsp = outFlags;
2589     }
2590     return code;
2591 }
2592
2593 /* return basic parameter information about a log */
2594 int
2595 afs_icl_GetLogParms(struct afs_icl_log *logp, afs_int32 * maxSizep,
2596                     afs_int32 * curSizep)
2597 {
2598     ObtainReadLock(&logp->lock);
2599     *maxSizep = logp->logSize;
2600     *curSizep = logp->logElements;
2601     ReleaseReadLock(&logp->lock);
2602     return 0;
2603 }
2604
2605
2606 /* hold and release logs */
2607 int
2608 afs_icl_LogHold(register struct afs_icl_log *logp)
2609 {
2610     ObtainWriteLock(&afs_icl_lock, 187);
2611     logp->refCount++;
2612     ReleaseWriteLock(&afs_icl_lock);
2613     return 0;
2614 }
2615
2616 /* hold and release logs, called with lock already held */
2617 int
2618 afs_icl_LogHoldNL(register struct afs_icl_log *logp)
2619 {
2620     logp->refCount++;
2621     return 0;
2622 }
2623
2624 /* keep track of how many sets believe the log itself is allocated */
2625 int
2626 afs_icl_LogUse(register struct afs_icl_log *logp)
2627 {
2628     ObtainWriteLock(&logp->lock, 188);
2629     if (logp->setCount == 0) {
2630         /* this is the first set actually using the log -- allocate it */
2631         if (logp->logSize == 0) {
2632             /* we weren't passed in a hint and it wasn't set */
2633             logp->logSize = ICL_DEFAULT_LOGSIZE;
2634         }
2635         logp->datap =
2636             (afs_int32 *) afs_osi_Alloc(sizeof(afs_int32) * logp->logSize);
2637 #ifdef  KERNEL_HAVE_PIN
2638         pin((char *)logp->datap, sizeof(afs_int32) * logp->logSize);
2639 #endif
2640     }
2641     logp->setCount++;
2642     ReleaseWriteLock(&logp->lock);
2643     return 0;
2644 }
2645
2646 /* decrement the number of real users of the log, free if possible */
2647 int
2648 afs_icl_LogFreeUse(register struct afs_icl_log *logp)
2649 {
2650     ObtainWriteLock(&logp->lock, 189);
2651     if (--logp->setCount == 0) {
2652         /* no more users -- free it (but keep log structure around) */
2653 #ifdef  KERNEL_HAVE_PIN
2654         unpin((char *)logp->datap, sizeof(afs_int32) * logp->logSize);
2655 #endif
2656         afs_osi_Free(logp->datap, sizeof(afs_int32) * logp->logSize);
2657         logp->firstUsed = logp->firstFree = 0;
2658         logp->logElements = 0;
2659         logp->datap = NULL;
2660     }
2661     ReleaseWriteLock(&logp->lock);
2662     return 0;
2663 }
2664
2665 /* set the size of the log to 'logSize' */
2666 int
2667 afs_icl_LogSetSize(register struct afs_icl_log *logp, afs_int32 logSize)
2668 {
2669     ObtainWriteLock(&logp->lock, 190);
2670     if (!logp->datap) {
2671         /* nothing to worry about since it's not allocated */
2672         logp->logSize = logSize;
2673     } else {
2674         /* reset log */
2675         logp->firstUsed = logp->firstFree = 0;
2676         logp->logElements = 0;
2677
2678         /* free and allocate a new one */
2679 #ifdef  KERNEL_HAVE_PIN
2680         unpin((char *)logp->datap, sizeof(afs_int32) * logp->logSize);
2681 #endif
2682         afs_osi_Free(logp->datap, sizeof(afs_int32) * logp->logSize);
2683         logp->datap =
2684             (afs_int32 *) afs_osi_Alloc(sizeof(afs_int32) * logSize);
2685 #ifdef  KERNEL_HAVE_PIN
2686         pin((char *)logp->datap, sizeof(afs_int32) * logSize);
2687 #endif
2688         logp->logSize = logSize;
2689     }
2690     ReleaseWriteLock(&logp->lock);
2691
2692     return 0;
2693 }
2694
2695 /* free a log.  Called with afs_icl_lock locked. */
2696 int
2697 afs_icl_ZapLog(register struct afs_icl_log *logp)
2698 {
2699     register struct afs_icl_log **lpp, *tp;
2700
2701     for (lpp = &afs_icl_allLogs, tp = *lpp; tp; lpp = &tp->nextp, tp = *lpp) {
2702         if (tp == logp) {
2703             /* found the dude we want to remove */
2704             *lpp = logp->nextp;
2705             osi_FreeSmallSpace(logp->name);
2706 #ifdef KERNEL_HAVE_PIN
2707             unpin((char *)logp->datap, sizeof(afs_int32) * logp->logSize);
2708 #endif
2709             afs_osi_Free(logp->datap, sizeof(afs_int32) * logp->logSize);
2710             osi_FreeSmallSpace(logp);
2711             break;              /* won't find it twice */
2712         }
2713     }
2714     return 0;
2715 }
2716
2717 /* do the release, watching for deleted entries */
2718 int
2719 afs_icl_LogRele(register struct afs_icl_log *logp)
2720 {
2721     ObtainWriteLock(&afs_icl_lock, 191);
2722     if (--logp->refCount == 0 && (logp->states & ICL_LOGF_DELETED)) {
2723         afs_icl_ZapLog(logp);   /* destroys logp's lock! */
2724     }
2725     ReleaseWriteLock(&afs_icl_lock);
2726     return 0;
2727 }
2728
2729 /* do the release, watching for deleted entries, log already held */
2730 int
2731 afs_icl_LogReleNL(register struct afs_icl_log *logp)
2732 {
2733     if (--logp->refCount == 0 && (logp->states & ICL_LOGF_DELETED)) {
2734         afs_icl_ZapLog(logp);   /* destroys logp's lock! */
2735     }
2736     return 0;
2737 }
2738
2739 /* zero out the log */
2740 int
2741 afs_icl_ZeroLog(register struct afs_icl_log *logp)
2742 {
2743     ObtainWriteLock(&logp->lock, 192);
2744     logp->firstUsed = logp->firstFree = 0;
2745     logp->logElements = 0;
2746     logp->baseCookie = 0;
2747     ReleaseWriteLock(&logp->lock);
2748     return 0;
2749 }
2750
2751 /* free a log entry, and drop its reference count */
2752 int
2753 afs_icl_LogFree(register struct afs_icl_log *logp)
2754 {
2755     ObtainWriteLock(&logp->lock, 193);
2756     logp->states |= ICL_LOGF_DELETED;
2757     ReleaseWriteLock(&logp->lock);
2758     afs_icl_LogRele(logp);
2759     return 0;
2760 }
2761
2762 /* find a log by name, returning it held */
2763 struct afs_icl_log *
2764 afs_icl_FindLog(char *name)
2765 {
2766     register struct afs_icl_log *tp;
2767     ObtainWriteLock(&afs_icl_lock, 194);
2768     for (tp = afs_icl_allLogs; tp; tp = tp->nextp) {
2769         if (strcmp(tp->name, name) == 0) {
2770             /* this is the dude we want */
2771             tp->refCount++;
2772             break;
2773         }
2774     }
2775     ReleaseWriteLock(&afs_icl_lock);
2776     return tp;
2777 }
2778
2779 int
2780 afs_icl_EnumerateLogs(int (*aproc)
2781                         (char *name, char *arock, struct afs_icl_log * tp),
2782                       char *arock)
2783 {
2784     register struct afs_icl_log *tp;
2785     register afs_int32 code;
2786
2787     code = 0;
2788     ObtainWriteLock(&afs_icl_lock, 195);
2789     for (tp = afs_icl_allLogs; tp; tp = tp->nextp) {
2790         tp->refCount++;         /* hold this guy */
2791         ReleaseWriteLock(&afs_icl_lock);
2792         ObtainReadLock(&tp->lock);
2793         code = (*aproc) (tp->name, arock, tp);
2794         ReleaseReadLock(&tp->lock);
2795         ObtainWriteLock(&afs_icl_lock, 196);
2796         if (--tp->refCount == 0)
2797             afs_icl_ZapLog(tp);
2798         if (code)
2799             break;
2800     }
2801     ReleaseWriteLock(&afs_icl_lock);
2802     return code;
2803 }
2804
2805 struct afs_icl_set *afs_icl_allSets = 0;
2806
2807 int
2808 afs_icl_CreateSet(char *name, struct afs_icl_log *baseLogp,
2809                   struct afs_icl_log *fatalLogp,
2810                   struct afs_icl_set **outSetpp)
2811 {
2812     return afs_icl_CreateSetWithFlags(name, baseLogp, fatalLogp,
2813                                       /*flags */ 0, outSetpp);
2814 }
2815
2816 /* create a set, given pointers to base and fatal logs, if any.
2817  * Logs are unlocked, but referenced, and *outSetpp is returned
2818  * referenced.  Function bumps reference count on logs, since it
2819  * addds references from the new afs_icl_set.  When the set is destroyed,
2820  * those references will be released.
2821  */
2822 int
2823 afs_icl_CreateSetWithFlags(char *name, struct afs_icl_log *baseLogp,
2824                            struct afs_icl_log *fatalLogp, afs_uint32 flags,
2825                            struct afs_icl_set **outSetpp)
2826 {
2827     register struct afs_icl_set *setp;
2828     register int i;
2829     afs_int32 states = ICL_DEFAULT_SET_STATES;
2830
2831     ObtainWriteLock(&afs_icl_lock, 197);
2832     if (!afs_icl_inited)
2833         afs_icl_Init();
2834
2835     for (setp = afs_icl_allSets; setp; setp = setp->nextp) {
2836         if (strcmp(setp->name, name) == 0) {
2837             setp->refCount++;
2838             *outSetpp = setp;
2839             if (flags & ICL_CRSET_FLAG_PERSISTENT) {
2840                 ObtainWriteLock(&setp->lock, 198);
2841                 setp->states |= ICL_SETF_PERSISTENT;
2842                 ReleaseWriteLock(&setp->lock);
2843             }
2844             ReleaseWriteLock(&afs_icl_lock);
2845             return 0;
2846         }
2847     }
2848
2849     /* determine initial state */
2850     if (flags & ICL_CRSET_FLAG_DEFAULT_ON)
2851         states = ICL_SETF_ACTIVE;
2852     else if (flags & ICL_CRSET_FLAG_DEFAULT_OFF)
2853         states = ICL_SETF_FREED;
2854     if (flags & ICL_CRSET_FLAG_PERSISTENT)
2855         states |= ICL_SETF_PERSISTENT;
2856
2857     setp = (struct afs_icl_set *)afs_osi_Alloc(sizeof(struct afs_icl_set));
2858     memset((caddr_t) setp, 0, sizeof(*setp));
2859     setp->refCount = 1;
2860     if (states & ICL_SETF_FREED)
2861         states &= ~ICL_SETF_ACTIVE;     /* if freed, can't be active */
2862     setp->states = states;
2863
2864     LOCK_INIT(&setp->lock, "setp lock");
2865     /* next lock is obtained in wrong order, hierarchy-wise, but
2866      * it doesn't matter, since no one can find this lock yet, since
2867      * the afs_icl_lock is still held, and thus the obtain can't block.
2868      */
2869     ObtainWriteLock(&setp->lock, 199);
2870     setp->name = osi_AllocSmallSpace(strlen(name) + 1);
2871     strcpy(setp->name, name);
2872     setp->nevents = ICL_DEFAULTEVENTS;
2873     setp->eventFlags = afs_osi_Alloc(ICL_DEFAULTEVENTS);
2874 #ifdef  KERNEL_HAVE_PIN
2875     pin((char *)setp->eventFlags, ICL_DEFAULTEVENTS);
2876 #endif
2877     for (i = 0; i < ICL_DEFAULTEVENTS; i++)
2878         setp->eventFlags[i] = 0xff;     /* default to enabled */
2879
2880     /* update this global info under the afs_icl_lock */
2881     setp->nextp = afs_icl_allSets;
2882     afs_icl_allSets = setp;
2883     ReleaseWriteLock(&afs_icl_lock);
2884
2885     /* set's basic lock is still held, so we can finish init */
2886     if (baseLogp) {
2887         setp->logs[0] = baseLogp;
2888         afs_icl_LogHold(baseLogp);
2889         if (!(setp->states & ICL_SETF_FREED))
2890             afs_icl_LogUse(baseLogp);   /* log is actually being used */
2891     }
2892     if (fatalLogp) {
2893         setp->logs[1] = fatalLogp;
2894         afs_icl_LogHold(fatalLogp);
2895         if (!(setp->states & ICL_SETF_FREED))
2896             afs_icl_LogUse(fatalLogp);  /* log is actually being used */
2897     }
2898     ReleaseWriteLock(&setp->lock);
2899
2900     *outSetpp = setp;
2901     return 0;
2902 }
2903
2904 /* function to change event enabling information for a particular set */
2905 int
2906 afs_icl_SetEnable(struct afs_icl_set *setp, afs_int32 eventID, int setValue)
2907 {
2908     char *tp;
2909
2910     ObtainWriteLock(&setp->lock, 200);
2911     if (!ICL_EVENTOK(setp, eventID)) {
2912         ReleaseWriteLock(&setp->lock);
2913         return -1;
2914     }
2915     tp = &setp->eventFlags[ICL_EVENTBYTE(eventID)];
2916     if (setValue)
2917         *tp |= ICL_EVENTMASK(eventID);
2918     else
2919         *tp &= ~(ICL_EVENTMASK(eventID));
2920     ReleaseWriteLock(&setp->lock);
2921     return 0;
2922 }
2923
2924 /* return indication of whether a particular event ID is enabled
2925  * for tracing.  If *getValuep is set to 0, the event is disabled,
2926  * otherwise it is enabled.  All events start out enabled by default.
2927  */
2928 int
2929 afs_icl_GetEnable(struct afs_icl_set *setp, afs_int32 eventID, int *getValuep)
2930 {
2931     ObtainReadLock(&setp->lock);
2932     if (!ICL_EVENTOK(setp, eventID)) {
2933         ReleaseWriteLock(&setp->lock);
2934         return -1;
2935     }
2936     if (setp->eventFlags[ICL_EVENTBYTE(eventID)] & ICL_EVENTMASK(eventID))
2937         *getValuep = 1;
2938     else
2939         *getValuep = 0;
2940     ReleaseReadLock(&setp->lock);
2941     return 0;
2942 }
2943
2944 /* hold and release event sets */
2945 int
2946 afs_icl_SetHold(register struct afs_icl_set *setp)
2947 {
2948     ObtainWriteLock(&afs_icl_lock, 201);
2949     setp->refCount++;
2950     ReleaseWriteLock(&afs_icl_lock);
2951     return 0;
2952 }
2953
2954 /* free a set.  Called with afs_icl_lock locked */
2955 int
2956 afs_icl_ZapSet(register struct afs_icl_set *setp)
2957 {
2958     register struct afs_icl_set **lpp, *tp;
2959     int i;
2960     register struct afs_icl_log *tlp;
2961
2962     for (lpp = &afs_icl_allSets, tp = *lpp; tp; lpp = &tp->nextp, tp = *lpp) {
2963         if (tp == setp) {
2964             /* found the dude we want to remove */
2965             *lpp = setp->nextp;
2966             osi_FreeSmallSpace(setp->name);
2967 #ifdef  KERNEL_HAVE_PIN
2968             unpin((char *)setp->eventFlags, ICL_DEFAULTEVENTS);
2969 #endif
2970             afs_osi_Free(setp->eventFlags, ICL_DEFAULTEVENTS);
2971             for (i = 0; i < ICL_LOGSPERSET; i++) {
2972                 if ((tlp = setp->logs[i]))
2973                     afs_icl_LogReleNL(tlp);
2974             }
2975             osi_FreeSmallSpace(setp);
2976             break;              /* won't find it twice */
2977         }
2978     }
2979     return 0;
2980 }
2981
2982 /* do the release, watching for deleted entries */
2983 int
2984 afs_icl_SetRele(register struct afs_icl_set *setp)
2985 {
2986     ObtainWriteLock(&afs_icl_lock, 202);
2987     if (--setp->refCount == 0 && (setp->states & ICL_SETF_DELETED)) {
2988         afs_icl_ZapSet(setp);   /* destroys setp's lock! */
2989     }
2990     ReleaseWriteLock(&afs_icl_lock);
2991     return 0;
2992 }
2993
2994 /* free a set entry, dropping its reference count */
2995 int
2996 afs_icl_SetFree(register struct afs_icl_set *setp)
2997 {
2998     ObtainWriteLock(&setp->lock, 203);
2999     setp->states |= ICL_SETF_DELETED;
3000     ReleaseWriteLock(&setp->lock);
3001     afs_icl_SetRele(setp);
3002     return 0;
3003 }
3004
3005 /* find a set by name, returning it held */
3006 struct afs_icl_set *
3007 afs_icl_FindSet(char *name)
3008 {
3009     register struct afs_icl_set *tp;
3010     ObtainWriteLock(&afs_icl_lock, 204);
3011     for (tp = afs_icl_allSets; tp; tp = tp->nextp) {
3012         if (strcmp(tp->name, name) == 0) {
3013             /* this is the dude we want */
3014             tp->refCount++;
3015             break;
3016         }
3017     }
3018     ReleaseWriteLock(&afs_icl_lock);
3019     return tp;
3020 }
3021
3022 /* zero out all the logs in the set */
3023 int
3024 afs_icl_ZeroSet(struct afs_icl_set *setp)
3025 {
3026     register int i;
3027     int code = 0;
3028     int tcode;
3029     struct afs_icl_log *logp;
3030
3031     ObtainReadLock(&setp->lock);
3032     for (i = 0; i < ICL_LOGSPERSET; i++) {
3033         logp = setp->logs[i];
3034         if (logp) {
3035             afs_icl_LogHold(logp);
3036             tcode = afs_icl_ZeroLog(logp);
3037             if (tcode != 0)
3038                 code = tcode;   /* save the last bad one */
3039             afs_icl_LogRele(logp);
3040         }
3041     }
3042     ReleaseReadLock(&setp->lock);
3043     return code;
3044 }
3045
3046 int
3047 afs_icl_EnumerateSets(int (*aproc)
3048                         (char *name, char *arock, struct afs_icl_log * tp),
3049                       char *arock)
3050 {
3051     register struct afs_icl_set *tp, *np;
3052     register afs_int32 code;
3053
3054     code = 0;
3055     ObtainWriteLock(&afs_icl_lock, 205);
3056     for (tp = afs_icl_allSets; tp; tp = np) {
3057         tp->refCount++;         /* hold this guy */
3058         ReleaseWriteLock(&afs_icl_lock);
3059         code = (*aproc) (tp->name, arock, (struct afs_icl_log *)tp);
3060         ObtainWriteLock(&afs_icl_lock, 206);
3061         np = tp->nextp;         /* tp may disappear next, but not np */
3062         if (--tp->refCount == 0 && (tp->states & ICL_SETF_DELETED))
3063             afs_icl_ZapSet(tp);
3064         if (code)
3065             break;
3066     }
3067     ReleaseWriteLock(&afs_icl_lock);
3068     return code;
3069 }
3070
3071 int
3072 afs_icl_AddLogToSet(struct afs_icl_set *setp, struct afs_icl_log *newlogp)
3073 {
3074     register int i;
3075     int code = -1;
3076
3077     ObtainWriteLock(&setp->lock, 207);
3078     for (i = 0; i < ICL_LOGSPERSET; i++) {
3079         if (!setp->logs[i]) {
3080             setp->logs[i] = newlogp;
3081             code = i;
3082             afs_icl_LogHold(newlogp);
3083             if (!(setp->states & ICL_SETF_FREED)) {
3084                 /* bump up the number of sets using the log */
3085                 afs_icl_LogUse(newlogp);
3086             }
3087             break;
3088         }
3089     }
3090     ReleaseWriteLock(&setp->lock);
3091     return code;
3092 }
3093
3094 int
3095 afs_icl_SetSetStat(struct afs_icl_set *setp, int op)
3096 {
3097     int i;
3098     afs_int32 code;
3099     struct afs_icl_log *logp;
3100
3101     ObtainWriteLock(&setp->lock, 208);
3102     switch (op) {
3103     case ICL_OP_SS_ACTIVATE:    /* activate a log */
3104         /*
3105          * If we are not already active, see if we have released
3106          * our demand that the log be allocated (FREED set).  If
3107          * we have, reassert our desire.
3108          */
3109         if (!(setp->states & ICL_SETF_ACTIVE)) {
3110             if (setp->states & ICL_SETF_FREED) {
3111                 /* have to reassert desire for logs */
3112                 for (i = 0; i < ICL_LOGSPERSET; i++) {
3113                     logp = setp->logs[i];
3114                     if (logp) {
3115                         afs_icl_LogHold(logp);
3116                         afs_icl_LogUse(logp);
3117                         afs_icl_LogRele(logp);
3118                     }
3119                 }
3120                 setp->states &= ~ICL_SETF_FREED;
3121             }
3122             setp->states |= ICL_SETF_ACTIVE;
3123         }
3124         code = 0;
3125         break;
3126
3127     case ICL_OP_SS_DEACTIVATE:  /* deactivate a log */
3128         /* this doesn't require anything beyond clearing the ACTIVE flag */
3129         setp->states &= ~ICL_SETF_ACTIVE;
3130         code = 0;
3131         break;
3132
3133     case ICL_OP_SS_FREE:        /* deassert design for log */
3134         /* 
3135          * if we are already in this state, do nothing; otherwise
3136          * deassert desire for log
3137          */
3138         if (setp->states & ICL_SETF_ACTIVE)
3139             code = EINVAL;
3140         else {
3141             if (!(setp->states & ICL_SETF_FREED)) {
3142                 for (i = 0; i < ICL_LOGSPERSET; i++) {
3143                     logp = setp->logs[i];
3144                     if (logp) {
3145                         afs_icl_LogHold(logp);
3146                         afs_icl_LogFreeUse(logp);
3147                         afs_icl_LogRele(logp);
3148                     }
3149                 }
3150                 setp->states |= ICL_SETF_FREED;
3151             }
3152             code = 0;
3153         }
3154         break;
3155
3156     default:
3157         code = EINVAL;
3158     }
3159     ReleaseWriteLock(&setp->lock);
3160     return code;
3161 }