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