initial-darwin-support-20010327
[openafs.git] / src / afs / afs_init.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 /*
11  * afs_init.c - initialize AFS client.
12  *
13  * Implements:
14  */
15
16 #include "../afs/param.h"       /* Should be always first */
17 #include "../afs/stds.h"
18 #include "../afs/sysincludes.h" /* Standard vendor system headers */
19 #include "../afs/afsincludes.h" /* Afs-based standard headers */
20 #include "../afs/afs_stats.h"   /* afs statistics */
21
22
23 /* Imported variables */
24 extern afs_int32 afs_waitForever;
25 extern short afs_waitForeverCount;
26 extern afs_int32 afs_FVIndex;
27 extern struct server *afs_setTimeHost;
28 extern struct server *afs_servers[NSERVERS];
29 extern struct unixuser *afs_users[NUSERS];
30 extern struct volume *afs_freeVolList;
31 extern struct volume *afs_volumes[NVOLS];
32 extern afs_int32 afs_volCounter;
33
34 extern afs_rwlock_t afs_xaxs;
35 extern afs_rwlock_t afs_xvolume;
36 extern afs_rwlock_t afs_xuser;
37 extern afs_rwlock_t afs_xserver;
38 #ifndef AFS_AIX41_ENV
39 extern afs_lock_t osi_fsplock;
40 #endif
41 extern afs_lock_t osi_flplock;
42 extern afs_int32 fvTable[NFENTRIES];
43
44 /* afs_cell.c */
45 extern afs_rwlock_t afs_xcell;
46 extern struct afs_q CellLRU;
47 extern afs_int32 afs_cellindex;
48
49 /* afs_conn.c */
50 extern afs_rwlock_t afs_xconn;
51 extern afs_rwlock_t afs_xinterface;
52
53 /* afs_mariner.c */
54 extern struct rx_service *afs_server;
55
56
57 /* afs_mariner.c */
58 extern afs_int32 afs_mariner;
59 extern afs_int32 afs_marinerHost;
60
61 /* afs_volume.c */
62 extern ino_t volumeInode;
63
64 /* afs_osi_pag.c */
65 extern afs_uint32 pag_epoch;
66
67 /* afs_dcache.c */
68 extern afs_rwlock_t afs_xdcache;
69 extern int cacheDiskType;
70 extern afs_int32 afs_fsfragsize;
71 extern ino_t cacheInode;
72 extern struct osi_file *afs_cacheInodep;
73 extern afs_int32 afs_freeDCList;                /*Free list for disk cache entries*/
74
75
76 /* afs_vcache.c */
77 extern afs_rwlock_t afs_xvcache;
78 extern afs_rwlock_t afs_xvcb;
79
80 /* VNOPS/afs_vnop_read.c */
81 extern afs_int32 maxIHint;
82 extern afs_int32 nihints;                   /* # of above actually in-use */
83 extern afs_int32 usedihint;
84
85 /* afs_server.c */
86 extern afs_int32 afs_setTime;
87
88 /* Imported functions. */
89 extern struct rx_securityClass *rxnull_NewServerSecurityObject();
90 extern int RXAFSCB_ExecuteRequest();
91 extern int RXSTATS_ExecuteRequest();
92
93
94 /* afs_osi.c */
95 extern afs_lock_t afs_ftf;
96
97 /* Exported variables */
98 struct osi_dev cacheDev;           /*Cache device*/
99 afs_int32 cacheInfoModTime;                     /*Last time cache info modified*/
100 #if defined(AFS_OSF_ENV) || defined(AFS_DEC_ENV) || defined(AFS_DARWIN_ENV)
101 struct mount *afs_cacheVfsp=0;
102 #elif defined(AFS_LINUX20_ENV)
103 struct super_block *afs_cacheSBp = 0;
104 #else
105 struct vfs *afs_cacheVfsp=0;
106 #endif
107 afs_rwlock_t afs_puttofileLock; /* not used */
108 char *afs_sysname = 0;                  /* So that superuser may change the
109                                          * local value of @sys */
110 struct volume *Initialafs_freeVolList;
111 int afs_memvolumes = 0;
112
113 /* Local variables */
114
115
116 /*
117  * Initialization order is important.  Must first call afs_CacheInit,
118  * then cache file and volume file initialization routines.  Next, the
119  * individual cache entry initialization routines are called.
120  */
121
122
123 /*
124  * afs_CacheInit
125  *
126  * Description:
127  *
128  * Parameters:
129  *      astatSize : The number of stat cache (vnode) entries to
130  *                  allocate.
131  *      afiles    : The number of disk files to allocate to the cache
132  *      ablocks   : The max number of 1 Kbyte blocks that all of
133  *                  the files in the cache may occupy.
134  *      aDentries : Number of dcache entries to allocate.
135  *      aVolumes  : Number of volume cache entries to allocate.
136  *      achunk    : Power of 2 to make the chunks.
137  *      aflags    : Flags passed in.
138  *      inodes    : max inodes to pin down in inode[]
139  *      users     : what should size of per-user access cache be?
140  *
141  * Environment:
142  *      This routine should only be called at initialization time, since
143  *      it reclaims no resources and doesn't sufficiently synchronize
144  *      with other processes.
145  */
146
147 struct cm_initparams cm_initParams;
148 static int afs_cacheinit_flag = 0;
149 int
150 afs_CacheInit(astatSize, afiles, ablocks, aDentries, aVolumes, achunk, aflags,
151               ninodes, nusers)
152     afs_int32 afiles;
153     afs_int32 astatSize, ablocks; 
154     afs_int32 achunk, aflags, ninodes, nusers;
155     afs_int32 aDentries;
156 { /*afs_CacheInit*/
157     extern int afs_memvolumes;
158     register afs_int32 i, preallocs;
159     register struct volume *tv;
160     long code;
161
162     AFS_STATCNT(afs_CacheInit);
163     /*
164      * Jot down the epoch time, namely when this incarnation of the
165      * Cache Manager started.
166      */
167     afs_stats_cmperf.epoch = pag_epoch = osi_Time();
168 #ifdef SYS_NAME_ID
169     afs_stats_cmperf.sysName_ID = SYS_NAME_ID;
170 #else
171     afs_stats_cmperf.sysName_ID = SYS_NAME_ID_UNDEFINED;
172 #endif /* SYS_NAME_ID */
173
174     printf("Starting AFS cache scan...");
175     if (afs_cacheinit_flag)
176         return 0;
177     afs_cacheinit_flag = 1;
178     cacheInfoModTime = 0;
179     maxIHint = ninodes;
180     nihints = 0;
181     usedihint = 0;
182
183     LOCK_INIT(&afs_ftf, "afs_ftf");
184     RWLOCK_INIT(&afs_xaxs, "afs_xaxs");
185     osi_dnlc_init();
186
187
188 #if     defined(AFS_AIX32_ENV) || defined(AFS_HPUX_ENV)
189     /*
190      * We want to also reserve space for the gnode struct which is associated
191      * with each vnode (vcache) one; we want to use the pinned pool for them   
192      * since they're referenced at interrupt level.
193      */
194     if (afs_stats_cmperf.SmallBlocksAlloced + astatSize < 3600)
195       preallocs = astatSize;
196     else {
197       preallocs = 3600 - afs_stats_cmperf.SmallBlocksAlloced;
198       if (preallocs <= 0) preallocs = 10;
199     }
200     osi_AllocMoreSSpace(preallocs);
201 #endif
202     /* 
203      * create volume list structure 
204      */
205     if ( aVolumes < 50 )     aVolumes = 50;  
206     if (aVolumes > 3000) aVolumes = 3000;
207
208     tv = (struct volume *) afs_osi_Alloc(aVolumes * sizeof(struct volume));
209     for (i=0;i<aVolumes-1;i++)
210         tv[i].next = &tv[i+1];
211     tv[aVolumes-1].next = (struct volume *) 0;
212     afs_freeVolList = Initialafs_freeVolList = tv;
213     afs_memvolumes = aVolumes;
214
215     afs_cacheFiles = afiles;
216     afs_cacheStats = astatSize;
217     afs_vcacheInit(astatSize);
218     afs_dcacheInit(afiles, ablocks, aDentries, achunk, aflags);
219
220 #if defined(AFS_AIX_ENV)
221     {
222         static void afs_procsize_init(void);
223
224         afs_procsize_init();
225     }
226 #endif
227
228     /* Save the initialization parameters for later pioctl queries. */
229     cm_initParams.cmi_version = CMI_VERSION;
230     cm_initParams.cmi_nChunkFiles = afiles;
231     cm_initParams.cmi_nStatCaches = astatSize;
232     cm_initParams.cmi_nDataCaches = aDentries;
233     cm_initParams.cmi_nVolumeCaches = aVolumes;
234     cm_initParams.cmi_firstChunkSize = AFS_FIRSTCSIZE;
235     cm_initParams.cmi_otherChunkSize = AFS_OTHERCSIZE;
236     cm_initParams.cmi_cacheSize = ablocks;
237     cm_initParams.cmi_setTime = afs_setTime;
238     cm_initParams.cmi_memCache = (aflags & AFSCALL_INIT_MEMCACHE) ? 1 : 0;
239
240     return 0;
241
242 } /*afs_CacheInit*/
243
244
245 /*
246   * afs_ComputeCacheParams
247   *
248   * Description:
249   *     Set some cache parameters.
250   *
251   * Parameters:
252   *     None.
253   */
254
255 void
256 afs_ComputeCacheParms()
257
258 { /*afs_ComputeCacheParms*/
259
260     register afs_int32 i;
261     afs_int32 afs_maxCacheDirty;
262
263     /*
264      * Don't allow more than 2/3 of the files in the cache to be dirty.
265      */
266     afs_maxCacheDirty = (2*afs_cacheFiles) / 3;
267
268     /*
269      * Also, don't allow more than 2/3 of the total space get filled
270      * with dirty chunks.  Compute the total number of chunks required
271      * to fill the cache, make sure we don't set out limit above 2/3 of
272      * that. If the cache size is greater than 1G, avoid overflow at
273      * the expense of precision on the chunk size.
274      */
275     if (afs_cacheBlocks & 0xffe00000) {
276         i = afs_cacheBlocks / (AFS_FIRSTCSIZE >> 10);
277     }
278     else {
279         i = (afs_cacheBlocks << 10) / AFS_FIRSTCSIZE;
280     }
281     i = (2*i) / 3;
282     if (afs_maxCacheDirty > i)
283         afs_maxCacheDirty = i;
284     if (afs_maxCacheDirty < 1)
285         afs_maxCacheDirty = 1;
286     afs_stats_cmperf.cacheMaxDirtyChunks = afs_maxCacheDirty;
287 } /*afs_ComputeCacheParms*/
288
289
290 /*
291  * afs_InitVolumeInfo
292  *
293  * Description:
294  *      Set up the volume info storage file.
295  *
296  * Parameters:
297  *      afile : the file to be declared to be the volume info storage
298  *              file for AFS.  It must be already truncated to 0 length.
299  *
300  * Environment:
301  *      This function is called only during initialization.
302  *
303  *      WARNING: Data will be written to this file over time by AFS.
304  */
305
306 afs_InitVolumeInfo(afile)
307     register char *afile;
308
309 { /*afs_InitVolumeInfo*/
310
311     afs_int32 code;
312     struct osi_file *tfile;
313     struct vnode *filevp;
314     struct fcache fce;
315
316     AFS_STATCNT(afs_InitVolumeInfo);
317 #ifdef AFS_LINUX22_ENV
318     {
319         struct dentry *dp;
320         code = gop_lookupname(afile, AFS_UIOSYS, 0, (struct vnode **) 0, &dp);
321         if (code) return ENOENT;
322         fce.inode = volumeInode = dp->d_inode->i_ino;
323         dput(dp);
324     }
325 #else
326     code = gop_lookupname(afile, AFS_UIOSYS, 0, (struct vnode **) 0, &filevp);
327     if (code) return ENOENT;
328     fce.inode = volumeInode = afs_vnodeToInumber(filevp);
329 #ifdef AFS_DEC_ENV
330     grele(filevp);
331 #else
332     AFS_RELE((struct vnode *)filevp);
333 #endif
334 #endif /* AFS_LINUX22_ENV */
335     tfile = afs_CFileOpen(fce.inode);
336     afs_CFileTruncate(tfile, 0);
337     afs_CFileClose(tfile);
338     return 0;
339
340 } /*afs_InitVolumeInfo*/
341
342 /*
343  * afs_InitCacheInfo
344  *
345  * Description:
346  *      Set up the given file as the AFS cache info file.
347  *
348  * Parameters:
349  *      afile : Name of the file assumed to be the cache info file
350  *              for the Cache Manager; it will be used as such.
351  * Side Effects:  This sets afs_fragsize, which is used in the cache usage 
352  *                calculations such as in afs_adjustsize()
353  *
354  * Environment:
355  *      This function is called only during initialization.  The given
356  *      file should NOT be truncated to 0 lenght; its contents descrebe
357  *      what data is really in the cache.
358  *
359  *      WARNING: data will be written to this file over time by AFS.
360  *
361  * NOTE: Starting to use separate osi_InitCacheInfo() routines to clean up
362  * code.
363  *
364  */
365 afs_InitCacheInfo(afile)
366     register char *afile;
367
368 { /*afs_InitCacheInfo*/
369
370     register afs_int32 code;
371     struct osi_stat tstat;
372     register struct osi_file *tfile;
373     struct afs_fheader theader;
374     struct vnode *filevp;
375     int goodFile;
376
377     AFS_STATCNT(afs_InitCacheInfo);
378     if(cacheDiskType != AFS_FCACHE_TYPE_UFS)
379         osi_Panic("afs_InitCacheInfo --- called for non-ufs cache!");
380 #ifdef AFS_LINUX22_ENV
381     code = osi_InitCacheInfo(afile);
382     if (code) return code;
383 #else
384     code = gop_lookupname(afile, AFS_UIOSYS, 0, (struct vnode **) 0, &filevp);
385     if (code || !filevp) return ENOENT;
386     {
387 #if     defined(AFS_SUN56_ENV)
388       struct statvfs64 st;
389 #else
390 #if     defined(AFS_HPUX102_ENV)
391       struct k_statvfs st;
392 #else
393 #if     defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) ||defined(AFS_HPUX100_ENV)
394       struct statvfs st;
395 #else 
396 #if defined(AFS_DUX40_ENV)
397       struct nstatfs st;
398 #else
399       struct statfs st;
400 #endif /* DUX40 */
401 #endif /* SUN5 SGI */
402 #endif /* HP 10.20 */
403 #endif /* SUN56 */
404
405 #if     defined(AFS_SGI_ENV)
406 #ifdef AFS_SGI65_ENV
407       VFS_STATVFS(filevp->v_vfsp, &st, (struct vnode *)0, code);
408       if (!code) 
409 #else
410       if (!VFS_STATFS(filevp->v_vfsp, &st, (struct vnode *)0))
411 #endif /* AFS_SGI65_ENV */
412 #else /* AFS_SGI_ENV */
413 #if     defined(AFS_SUN5_ENV) || defined(AFS_HPUX100_ENV)
414       if (!VFS_STATVFS(filevp->v_vfsp, &st)) 
415 #else
416 #ifdef  AFS_OSF_ENV
417       
418       VFS_STATFS(filevp->v_vfsp, code);
419       /* struct copy */
420       st = filevp->v_vfsp->m_stat;
421       if (code == 0)
422 #else   /* AFS_OSF_ENV */
423 #ifdef AFS_AIX41_ENV
424       if (!VFS_STATFS(filevp->v_vfsp, &st, &afs_osi_cred))
425 #else
426 #ifdef AFS_LINUX20_ENV
427           {
428               KERNEL_SPACE_DECL;
429               TO_USER_SPACE();
430
431               VFS_STATFS(filevp->v_vfsp, &st);
432               TO_KERNEL_SPACE();
433           }
434 #else
435 #ifdef AFS_DARWIN_ENV
436         if (!VFS_STATFS(filevp->v_mount, &st, current_proc()))
437 #else 
438         if (!VFS_STATFS(filevp->v_vfsp, &st))  
439 #endif /* AFS_DARWIN_ENV */
440 #endif /* AFS_LINUX20_ENV */
441 #endif /* AIX41 */
442 #endif /* OSF */
443 #endif /* SUN5 HP10 */
444 #endif /* SGI */
445 #if     defined(AFS_SUN5_ENV) || defined(AFS_HPUX100_ENV)
446         afs_fsfragsize = st.f_frsize - 1; 
447 #else
448         afs_fsfragsize = st.f_bsize - 1; 
449 #endif
450     }
451 #ifdef AFS_LINUX20_ENV
452     cacheInode = filevp->i_ino;
453     afs_cacheSBp = filevp->i_sb;
454 #else
455     cacheInode = afs_vnodeToInumber(filevp);
456     cacheDev.dev = afs_vnodeToDev(filevp);
457 #if defined(AFS_SGI62_ENV) || defined(AFS_HAVE_VXFS) || defined(AFS_DARWIN_ENV)
458     afs_InitDualFSCacheOps(filevp);
459 #endif
460     afs_cacheVfsp = filevp->v_vfsp;
461 #endif /* AFS_LINUX20_ENV */
462     AFS_RELE((struct vnode *)filevp);
463 #endif /* AFS_LINUX22_ENV */
464     tfile = osi_UFSOpen(cacheInode);
465     afs_osi_Stat(tfile, &tstat);
466     cacheInfoModTime = tstat.mtime;
467     code = afs_osi_Read(tfile, -1, &theader, sizeof(theader));
468     goodFile = 0;
469     if (code == sizeof(theader)) {
470         /* read the header correctly */
471         if (theader.magic == AFS_FHMAGIC &&
472             theader.firstCSize == AFS_FIRSTCSIZE &&
473             theader.otherCSize == AFS_OTHERCSIZE &&
474             theader.version == AFS_CI_VERSION
475         )
476             goodFile = 1;
477     }
478     if (!goodFile) {
479         /* write out a good file label */
480         theader.magic = AFS_FHMAGIC;
481         theader.firstCSize = AFS_FIRSTCSIZE;
482         theader.otherCSize = AFS_OTHERCSIZE;
483         theader.version = AFS_CI_VERSION;
484         afs_osi_Write(tfile, 0, &theader, sizeof(theader));
485         /*
486          * Truncate the rest of the file, since it may be arbitrarily
487          * wrong
488          */
489         osi_UFSTruncate(tfile, sizeof(struct afs_fheader));
490     }
491     /* Leave the file open now, since reopening the file makes public pool
492      * vnode systems (like OSF/Alpha) much harder to handle, That's because
493      * they can do a vnode recycle operation any time we open a file, which
494      * we'd do on any afs_GetDSlot call, etc.
495      */
496     afs_cacheInodep = (struct osi_file *)tfile;
497     return 0;
498
499 } /*afs_InitCacheInfo*/
500
501 int afs_resourceinit_flag = 0;
502 afs_ResourceInit(preallocs)
503   int preallocs;
504 {
505     register afs_int32 i;
506     static struct rx_securityClass *secobj;
507
508     AFS_STATCNT(afs_ResourceInit);
509     RWLOCK_INIT(&afs_xuser, "afs_xuser");
510     RWLOCK_INIT(&afs_xvolume, "afs_xvolume");
511     RWLOCK_INIT(&afs_xcell, "afs_xcell");
512     RWLOCK_INIT(&afs_xserver, "afs_xserver");
513     RWLOCK_INIT(&afs_xinterface, "afs_xinterface");
514     LOCK_INIT(&afs_puttofileLock, "afs_puttofileLock");
515 #ifndef AFS_AIX32_ENV
516     LOCK_INIT(&osi_fsplock, "osi_fsplock");
517 #endif
518     LOCK_INIT(&osi_flplock, "osi_flplock");
519     RWLOCK_INIT(&afs_xconn, "afs_xconn");
520
521     afs_InitCBQueue(1);  /* initialize callback queues */
522
523     if (afs_resourceinit_flag == 0) {
524         afs_resourceinit_flag = 1;
525         for (i=0;i<NFENTRIES;i++)
526             fvTable[i] = 0;
527         afs_sysname = afs_osi_Alloc(MAXSYSNAME);
528         strcpy(afs_sysname, SYS_NAME);
529         QInit(&CellLRU);        
530 #if     defined(AFS_AIX32_ENV) || defined(AFS_HPUX_ENV)
531     {  extern afs_int32 afs_preallocs;
532
533        if ((preallocs > 256) && (preallocs < 3600))
534            afs_preallocs = preallocs;
535        osi_AllocMoreSSpace(afs_preallocs);
536        osi_AllocMoreMSpace(100); 
537     }
538 #endif
539     }
540     
541     secobj = rxnull_NewServerSecurityObject();
542     afs_server =
543         rx_NewService(0, 1, "afs", &secobj, 1, RXAFSCB_ExecuteRequest);
544     afs_server =
545         rx_NewService(0, RX_STATS_SERVICE_ID, "rpcstats", &secobj, 1,
546                       RXSTATS_ExecuteRequest);
547     rx_StartServer(0);
548     afs_osi_Wakeup(&afs_server);        /* wakeup anyone waiting for it */
549     return 0;
550
551 } /*afs_ResourceInit*/
552
553 #if defined(AFS_AIX_ENV)
554
555 /*
556  * AIX dynamic sizeof(struct proc)
557  *
558  * AIX keeps its proc structures in an array.  The size of struct proc
559  * varies from release to release of the OS.  In order to maintain
560  * binary compatibility with releases later than what we build on, we
561  * need to determine the size of struct proc at run time.
562  *
563  * We need this in order to walk the proc[] array to do PAG garbage
564  * collection.
565  *
566  * We also need this in order to support 'klog -setpag', since the
567  * kernel code needs to locate the proc structure for the parent process
568  * of the current process.
569  *
570  * To compute sizeof(struct proc), we need the addresses of two proc
571  * structures and their corresponding pids.  Given the pids, we can use
572  * the PROCMASK() macro to compute their corresponding indices in the
573  * proc[] array.  By dividing the distance between the pointers by the
574  * number of proc structures, we can compute the size of a single proc
575  * structure.
576  *
577  * We know the base address of the proc table from v.vb_proc:
578  *
579  * <sys/sysconfig.h> declares sysconfig() and SYS_GETPARMS;
580  * (we don't use this, but I note it here for completeness)
581  *
582  * <sys/var.h> declares struct var and external variable v;
583  *
584  * v.v_proc             NPROC
585  * v.vb_proc            &proc[0]
586  * v.ve_proc            &proc[x] (current highwater mark for
587  *                                proc[] array usage)
588  *
589  * The first proc pointer is v.vb_proc, which is the proc structure for
590  * process 0.  Process 0's pointer to its first child is the other proc
591  * pointer.  If process 0 has no children, we simply give up and do not
592  * support features that require knowing the size of struct proc.
593  */
594
595 static void
596 afs_procsize_init(void)
597 {
598     struct proc *p0;    /* pointer to process 0 */
599     struct proc *pN;    /* pointer to process 0's first child */
600     int pN_index;
601     ptrdiff_t pN_offset;
602     int procsize;
603
604     p0 = (struct proc *)v.vb_proc;
605     if (!p0) {
606         afs_gcpags = AFS_GCPAGS_EPROC0;
607         return;
608     }
609
610     pN = p0->p_child;
611     if (!pN) {
612         afs_gcpags = AFS_GCPAGS_EPROCN;
613         return;
614     }
615
616     if (pN->p_pid == p0->p_pid) {
617         afs_gcpags = AFS_GCPAGS_EEQPID;
618         return;
619     }
620
621     pN_index = PROCMASK(pN->p_pid);
622     pN_offset = ((char *)pN - (char *)p0);
623     procsize = pN_offset / pN_index;
624
625     /*
626      * check that the computation was exact
627      */
628
629     if (pN_index * procsize != pN_offset) {
630         afs_gcpags = AFS_GCPAGS_EINEXACT;
631         return;
632     }
633
634     /*
635      * check that the proc table size is a multiple of procsize.
636      */
637
638     if ((((char *)v.ve_proc - (char *)v.vb_proc) % procsize) != 0) {
639         afs_gcpags = AFS_GCPAGS_EPROCEND;
640         return;
641     }
642
643     /* okay, use it */
644
645     afs_gcpags_procsize = procsize;
646 }
647
648 #endif
649
650 /*
651  * shutdown_cache
652  *
653  * Description:
654  *      Clean up and shut down the AFS cache.
655  *
656  * Parameters:
657  *      None.
658  *
659  * Environment:
660  *      Nothing interesting.
661  */
662 void
663 shutdown_cache()
664
665 { /*shutdown_cache*/
666     register struct afs_cbr *tsp, *nsp;
667     extern int afs_cold_shutdown;
668     extern int pagCounter;
669     int i;
670
671   AFS_STATCNT(shutdown_cache);
672   afs_WriteThroughDSlots();
673   if (afs_cold_shutdown) {
674     afs_cacheinit_flag = 0;
675     shutdown_dcache();
676     shutdown_vcache();
677
678     afs_cacheStats = 0;
679     afs_cacheFiles = afs_cacheBlocks = 0;
680     pag_epoch = maxIHint = nihints = usedihint = 0;
681     pagCounter = 0;
682     cacheInode = volumeInode = (ino_t)0;
683
684
685     cacheInfoModTime = 0;
686
687     afs_fsfragsize = 1023;
688     bzero((char *)&afs_stats_cmperf, sizeof(afs_stats_cmperf));
689     bzero((char *)&cacheDev, sizeof(struct osi_dev));
690     osi_dnlc_shutdown();
691   }
692 } /*shutdown_cache*/
693
694
695 void shutdown_vnodeops()
696 {
697     extern int afs_cold_shutdown;
698 #ifndef AFS_LINUX20_ENV
699     extern int afs_rd_stash_i;
700 #endif
701 #ifndef AFS_SUN5_ENV
702     extern int lastWarnTime;
703 #endif
704 #if !defined(AFS_SGI_ENV) && !defined(AFS_SUN_ENV) && !defined(AFS_SUN5_ENV)
705     struct buf *afs_bread_freebp = 0;
706 #endif
707     
708
709     AFS_STATCNT(shutdown_vnodeops);
710     if (afs_cold_shutdown) {
711 #ifndef AFS_SUN5_ENV    /* XXX */
712       lastWarnTime = 0;
713 #endif
714 #ifndef AFS_LINUX20_ENV
715       afs_rd_stash_i = 0;      
716 #endif
717 #if !defined(AFS_SGI_ENV) && !defined(AFS_SUN_ENV) && !defined(AFS_SUN5_ENV)
718       afs_bread_freebp = 0;
719 #endif
720       shutdown_mariner();
721   }
722 }
723
724
725 void shutdown_AFS()
726
727 {
728     int i;
729     register struct srvAddr *sa;
730     extern int afs_cold_shutdown;
731
732     AFS_STATCNT(shutdown_AFS);
733     if (afs_cold_shutdown) {
734       afs_resourceinit_flag = 0; 
735       /* 
736        * Free Cells table allocations 
737        */
738       { 
739         struct cell *tc;
740         register struct afs_q *cq, *tq;
741         for (cq = CellLRU.next; cq != &CellLRU; cq = tq) {
742             tc = QTOC(cq); tq = QNext(cq);
743             if (tc->cellName)
744                 afs_osi_Free(tc->cellName, strlen(tc->cellName)+1);
745             afs_osi_Free(tc, sizeof(struct cell));
746         }
747       }
748       /* 
749        * Free Volumes table allocations 
750        */
751       { 
752         struct volume *tv;
753         for (i = 0; i < NVOLS; i++) {
754             for (tv = afs_volumes[i]; tv; tv = tv->next) {
755                 if (tv->name) {
756                     afs_osi_Free(tv->name, strlen(tv->name)+1);
757                     tv->name = 0;
758                 }
759             }
760             afs_volumes[i] = 0;
761         }
762       }
763
764       /* 
765        * Free FreeVolList allocations 
766        */
767       afs_osi_Free(Initialafs_freeVolList, afs_memvolumes * sizeof(struct volume));
768       afs_freeVolList = Initialafs_freeVolList = 0;
769
770       /* XXX HACK fort MEM systems XXX 
771        *
772        * For -memcache cache managers when we run out of free in memory volumes
773        * we simply malloc more; we won't be able to free those additional volumes.
774        */
775
776       
777
778       /* 
779        * Free Users table allocation 
780        */
781       { 
782         struct unixuser *tu, *ntu;
783         for (i=0; i < NUSERS; i++) {
784             for (tu=afs_users[i]; tu; tu = ntu) {
785                 ntu = tu->next;
786                 if (tu->stp)
787                     afs_osi_Free(tu->stp, tu->stLen);
788                 if (tu->exporter)
789                     EXP_RELE(tu->exporter);
790                 afs_osi_Free(tu, sizeof(struct unixuser));
791             }
792             afs_users[i] = 0;
793         }
794       }
795
796       /* 
797        * Free Servers table allocation 
798        */
799       { 
800         struct server *ts, *nts;
801         struct conn *tc, *ntc;
802         register struct afs_cbr *tcbrp, *tbrp;
803         struct afs_cbr **lcbrpp;
804
805         for (i=0; i < NSERVERS; i++) {
806             for (ts = afs_servers[i]; ts; ts = nts) {
807                 nts = ts->next;
808                 for (sa = ts->addr; sa; sa = sa->next_sa) {     
809                     if (sa->conns) {
810                         /*
811                          * Free all server's connection structs
812                          */
813                         tc = sa->conns;
814                         while (tc) {
815                             ntc = tc->next;
816                             AFS_GUNLOCK();
817                             rx_DestroyConnection(tc->id);
818                             AFS_GLOCK();
819                             afs_osi_Free(tc, sizeof(struct conn));
820                             tc = ntc;
821                         }
822                     }
823                 }
824                 for (tcbrp = ts->cbrs; tcbrp;  tcbrp = tbrp) {
825                     /*
826                      * Free all server's callback structs
827                      */
828                     tbrp = tcbrp->next;
829                     afs_FreeCBR(tcbrp);
830                 }
831                 afs_osi_Free(ts, sizeof(struct server));
832             }
833             afs_servers[i] = 0;
834         }
835       }
836       for (i=0; i<NFENTRIES; i++)
837         fvTable[i] = 0;
838       /* Reinitialize local globals to defaults */
839       afs_osi_Free(afs_sysname, MAXSYSNAME);
840       afs_sysname = 0;
841       afs_marinerHost = 0;
842       QInit(&CellLRU);      
843       afs_setTimeHost = (struct server *)0;
844       afs_volCounter = 1;
845       afs_waitForever = afs_waitForeverCount = 0;
846       afs_cellindex = 0;
847       afs_FVIndex = -1;
848       afs_server = (struct rx_service *)0;
849       RWLOCK_INIT(&afs_xconn, "afs_xconn");
850       bzero((char *)&afs_rootFid, sizeof(struct VenusFid));
851       RWLOCK_INIT(&afs_xuser, "afs_xuser");
852       RWLOCK_INIT(&afs_xvolume, "afs_xvolume"), RWLOCK_INIT(&afs_xcell, "afs_xcell");
853       RWLOCK_INIT(&afs_xserver, "afs_xserver"), LOCK_INIT(&afs_puttofileLock, "afs_puttofileLock");
854     }
855     
856 } /*shutdown_AFS*/