Standardize License information
[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)
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 #if defined(AFS_SGI62_ENV) || defined(AFS_HAVE_VXFS)
329     fce.inode = volumeInode = VnodeToIno(filevp);
330 #else
331     fce.inode = volumeInode = VTOI(filevp)->i_number;
332 #endif
333 #ifdef AFS_DEC_ENV
334     grele(filevp);
335 #else
336     AFS_RELE((struct vnode *)filevp);
337 #endif
338 #endif /* AFS_LINUX22_ENV */
339     tfile = afs_CFileOpen(fce.inode);
340     afs_CFileTruncate(tfile, 0);
341     afs_CFileClose(tfile);
342     return 0;
343
344 } /*afs_InitVolumeInfo*/
345
346 /*
347  * afs_InitCacheInfo
348  *
349  * Description:
350  *      Set up the given file as the AFS cache info file.
351  *
352  * Parameters:
353  *      afile : Name of the file assumed to be the cache info file
354  *              for the Cache Manager; it will be used as such.
355  * Side Effects:  This sets afs_fragsize, which is used in the cache usage 
356  *                calculations such as in afs_adjustsize()
357  *
358  * Environment:
359  *      This function is called only during initialization.  The given
360  *      file should NOT be truncated to 0 lenght; its contents descrebe
361  *      what data is really in the cache.
362  *
363  *      WARNING: data will be written to this file over time by AFS.
364  *
365  * NOTE: Starting to use separate osi_InitCacheInfo() routines to clean up
366  * code.
367  *
368  */
369 afs_InitCacheInfo(afile)
370     register char *afile;
371
372 { /*afs_InitCacheInfo*/
373
374     register afs_int32 code;
375     struct osi_stat tstat;
376     register struct osi_file *tfile;
377     struct afs_fheader theader;
378     struct vnode *filevp;
379     int goodFile;
380
381     AFS_STATCNT(afs_InitCacheInfo);
382     if(cacheDiskType != AFS_FCACHE_TYPE_UFS)
383         osi_Panic("afs_InitCacheInfo --- called for non-ufs cache!");
384 #ifdef AFS_LINUX22_ENV
385     code = osi_InitCacheInfo(afile);
386     if (code) return code;
387 #else
388     code = gop_lookupname(afile, AFS_UIOSYS, 0, (struct vnode **) 0, &filevp);
389     if (code || !filevp) return ENOENT;
390     {
391 #if     defined(AFS_SUN56_ENV)
392       struct statvfs64 st;
393 #else
394 #if     defined(AFS_HPUX102_ENV)
395       struct k_statvfs st;
396 #else
397 #if     defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) ||defined(AFS_HPUX100_ENV)
398       struct statvfs st;
399 #else 
400 #if defined(AFS_DUX40_ENV)
401       struct nstatfs st;
402 #else
403       struct statfs st;
404 #endif /* DUX40 */
405 #endif /* SUN5 SGI */
406 #endif /* HP 10.20 */
407 #endif /* SUN56 */
408
409 #if     defined(AFS_SGI_ENV)
410 #ifdef AFS_SGI65_ENV
411       VFS_STATVFS(filevp->v_vfsp, &st, (struct vnode *)0, code);
412       if (!code) 
413 #else
414       if (!VFS_STATFS(filevp->v_vfsp, &st, (struct vnode *)0))
415 #endif /* AFS_SGI65_ENV */
416 #else /* AFS_SGI_ENV */
417 #if     defined(AFS_SUN5_ENV) || defined(AFS_HPUX100_ENV)
418       if (!VFS_STATVFS(filevp->v_vfsp, &st)) 
419 #else
420 #ifdef  AFS_OSF_ENV
421       
422       VFS_STATFS(filevp->v_vfsp, code);
423       /* struct copy */
424       st = filevp->v_vfsp->m_stat;
425       if (code == 0)
426 #else   /* AFS_OSF_ENV */
427 #ifdef AFS_AIX41_ENV
428       if (!VFS_STATFS(filevp->v_vfsp, &st, &afs_osi_cred))
429 #else
430 #ifdef AFS_LINUX20_ENV
431           {
432               KERNEL_SPACE_DECL;
433               TO_USER_SPACE();
434
435               VFS_STATFS(filevp->v_vfsp, &st);
436               TO_KERNEL_SPACE();
437           }
438 #else
439         if (!VFS_STATFS(filevp->v_vfsp, &st))  
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 #if defined(AFS_SGI62_ENV) || defined(AFS_HAVE_VXFS)
456     afs_InitDualFSCacheOps(filevp);
457     cacheInode = VnodeToIno(filevp);
458     cacheDev.dev = VnodeToDev(filevp);
459 #else
460     cacheInode = VTOI(filevp)->i_number;
461     cacheDev.dev = VTOI(filevp)->i_dev;
462 #endif
463     afs_cacheVfsp = filevp->v_vfsp;
464 #endif /* AFS_LINUX20_ENV */
465     AFS_RELE((struct vnode *)filevp);
466 #endif /* AFS_LINUX22_ENV */
467     tfile = osi_UFSOpen(cacheInode);
468     afs_osi_Stat(tfile, &tstat);
469     cacheInfoModTime = tstat.mtime;
470     code = afs_osi_Read(tfile, -1, &theader, sizeof(theader));
471     goodFile = 0;
472     if (code == sizeof(theader)) {
473         /* read the header correctly */
474         if (theader.magic == AFS_FHMAGIC &&
475             theader.firstCSize == AFS_FIRSTCSIZE &&
476             theader.otherCSize == AFS_OTHERCSIZE &&
477             theader.version == AFS_CI_VERSION
478         )
479             goodFile = 1;
480     }
481     if (!goodFile) {
482         /* write out a good file label */
483         theader.magic = AFS_FHMAGIC;
484         theader.firstCSize = AFS_FIRSTCSIZE;
485         theader.otherCSize = AFS_OTHERCSIZE;
486         theader.version = AFS_CI_VERSION;
487         afs_osi_Write(tfile, 0, &theader, sizeof(theader));
488         /*
489          * Truncate the rest of the file, since it may be arbitrarily
490          * wrong
491          */
492         osi_UFSTruncate(tfile, sizeof(struct afs_fheader));
493     }
494     /* Leave the file open now, since reopening the file makes public pool
495      * vnode systems (like OSF/Alpha) much harder to handle, That's because
496      * they can do a vnode recycle operation any time we open a file, which
497      * we'd do on any afs_GetDSlot call, etc.
498      */
499     afs_cacheInodep = (struct osi_file *)tfile;
500     return 0;
501
502 } /*afs_InitCacheInfo*/
503
504 int afs_resourceinit_flag = 0;
505 afs_ResourceInit(preallocs)
506   int preallocs;
507 {
508     register afs_int32 i;
509     static struct rx_securityClass *secobj;
510
511     AFS_STATCNT(afs_ResourceInit);
512     RWLOCK_INIT(&afs_xuser, "afs_xuser");
513     RWLOCK_INIT(&afs_xvolume, "afs_xvolume");
514     RWLOCK_INIT(&afs_xcell, "afs_xcell");
515     RWLOCK_INIT(&afs_xserver, "afs_xserver");
516     RWLOCK_INIT(&afs_xinterface, "afs_xinterface");
517     LOCK_INIT(&afs_puttofileLock, "afs_puttofileLock");
518 #ifndef AFS_AIX32_ENV
519     LOCK_INIT(&osi_fsplock, "osi_fsplock");
520 #endif
521     LOCK_INIT(&osi_flplock, "osi_flplock");
522     RWLOCK_INIT(&afs_xconn, "afs_xconn");
523
524     afs_InitCBQueue(1);  /* initialize callback queues */
525
526     if (afs_resourceinit_flag == 0) {
527         afs_resourceinit_flag = 1;
528         for (i=0;i<NFENTRIES;i++)
529             fvTable[i] = 0;
530         afs_sysname = afs_osi_Alloc(MAXSYSNAME);
531         strcpy(afs_sysname, SYS_NAME);
532         QInit(&CellLRU);        
533 #if     defined(AFS_AIX32_ENV) || defined(AFS_HPUX_ENV)
534     {  extern afs_int32 afs_preallocs;
535
536        if ((preallocs > 256) && (preallocs < 3600))
537            afs_preallocs = preallocs;
538        osi_AllocMoreSSpace(afs_preallocs);
539        osi_AllocMoreMSpace(100); 
540     }
541 #endif
542     }
543     
544     secobj = rxnull_NewServerSecurityObject();
545     afs_server =
546         rx_NewService(0, 1, "afs", &secobj, 1, RXAFSCB_ExecuteRequest);
547     afs_server =
548         rx_NewService(0, RX_STATS_SERVICE_ID, "rpcstats", &secobj, 1,
549                       RXSTATS_ExecuteRequest);
550     rx_StartServer(0);
551     afs_osi_Wakeup(&afs_server);        /* wakeup anyone waiting for it */
552     return 0;
553
554 } /*afs_ResourceInit*/
555
556 #if defined(AFS_AIX_ENV)
557
558 /*
559  * AIX dynamic sizeof(struct proc)
560  *
561  * AIX keeps its proc structures in an array.  The size of struct proc
562  * varies from release to release of the OS.  In order to maintain
563  * binary compatibility with releases later than what we build on, we
564  * need to determine the size of struct proc at run time.
565  *
566  * We need this in order to walk the proc[] array to do PAG garbage
567  * collection.
568  *
569  * We also need this in order to support 'klog -setpag', since the
570  * kernel code needs to locate the proc structure for the parent process
571  * of the current process.
572  *
573  * To compute sizeof(struct proc), we need the addresses of two proc
574  * structures and their corresponding pids.  Given the pids, we can use
575  * the PROCMASK() macro to compute their corresponding indices in the
576  * proc[] array.  By dividing the distance between the pointers by the
577  * number of proc structures, we can compute the size of a single proc
578  * structure.
579  *
580  * We know the base address of the proc table from v.vb_proc:
581  *
582  * <sys/sysconfig.h> declares sysconfig() and SYS_GETPARMS;
583  * (we don't use this, but I note it here for completeness)
584  *
585  * <sys/var.h> declares struct var and external variable v;
586  *
587  * v.v_proc             NPROC
588  * v.vb_proc            &proc[0]
589  * v.ve_proc            &proc[x] (current highwater mark for
590  *                                proc[] array usage)
591  *
592  * The first proc pointer is v.vb_proc, which is the proc structure for
593  * process 0.  Process 0's pointer to its first child is the other proc
594  * pointer.  If process 0 has no children, we simply give up and do not
595  * support features that require knowing the size of struct proc.
596  */
597
598 static void
599 afs_procsize_init(void)
600 {
601     struct proc *p0;    /* pointer to process 0 */
602     struct proc *pN;    /* pointer to process 0's first child */
603     int pN_index;
604     ptrdiff_t pN_offset;
605     int procsize;
606
607     p0 = (struct proc *)v.vb_proc;
608     if (!p0) {
609         afs_gcpags = AFS_GCPAGS_EPROC0;
610         return;
611     }
612
613     pN = p0->p_child;
614     if (!pN) {
615         afs_gcpags = AFS_GCPAGS_EPROCN;
616         return;
617     }
618
619     if (pN->p_pid == p0->p_pid) {
620         afs_gcpags = AFS_GCPAGS_EEQPID;
621         return;
622     }
623
624     pN_index = PROCMASK(pN->p_pid);
625     pN_offset = ((char *)pN - (char *)p0);
626     procsize = pN_offset / pN_index;
627
628     /*
629      * check that the computation was exact
630      */
631
632     if (pN_index * procsize != pN_offset) {
633         afs_gcpags = AFS_GCPAGS_EINEXACT;
634         return;
635     }
636
637     /*
638      * check that the proc table size is a multiple of procsize.
639      */
640
641     if ((((char *)v.ve_proc - (char *)v.vb_proc) % procsize) != 0) {
642         afs_gcpags = AFS_GCPAGS_EPROCEND;
643         return;
644     }
645
646     /* okay, use it */
647
648     afs_gcpags_procsize = procsize;
649 }
650
651 #endif
652
653 /*
654  * shutdown_cache
655  *
656  * Description:
657  *      Clean up and shut down the AFS cache.
658  *
659  * Parameters:
660  *      None.
661  *
662  * Environment:
663  *      Nothing interesting.
664  */
665 void
666 shutdown_cache()
667
668 { /*shutdown_cache*/
669     register struct afs_cbr *tsp, *nsp;
670     extern int afs_cold_shutdown;
671     extern int pagCounter;
672     int i;
673
674   AFS_STATCNT(shutdown_cache);
675   afs_WriteThroughDSlots();
676   if (afs_cold_shutdown) {
677     afs_cacheinit_flag = 0;
678     shutdown_dcache();
679     shutdown_vcache();
680
681     afs_cacheStats = 0;
682     afs_cacheFiles = afs_cacheBlocks = 0;
683     pag_epoch = maxIHint = nihints = usedihint = 0;
684     pagCounter = 0;
685     cacheInode = volumeInode = (ino_t)0;
686
687
688     cacheInfoModTime = 0;
689
690     afs_fsfragsize = 1023;
691     bzero((char *)&afs_stats_cmperf, sizeof(afs_stats_cmperf));
692     bzero((char *)&cacheDev, sizeof(struct osi_dev));
693     osi_dnlc_shutdown();
694   }
695 } /*shutdown_cache*/
696
697
698 void shutdown_vnodeops()
699 {
700     extern int afs_cold_shutdown;
701 #ifndef AFS_LINUX20_ENV
702     extern int afs_rd_stash_i;
703 #endif
704 #ifndef AFS_SUN5_ENV
705     extern int lastWarnTime;
706 #endif
707 #if !defined(AFS_SGI_ENV) && !defined(AFS_SUN_ENV) && !defined(AFS_SUN5_ENV)
708     struct buf *afs_bread_freebp = 0;
709 #endif
710     
711
712     AFS_STATCNT(shutdown_vnodeops);
713     if (afs_cold_shutdown) {
714 #ifndef AFS_SUN5_ENV    /* XXX */
715       lastWarnTime = 0;
716 #endif
717 #ifndef AFS_LINUX20_ENV
718       afs_rd_stash_i = 0;      
719 #endif
720 #if !defined(AFS_SGI_ENV) && !defined(AFS_SUN_ENV) && !defined(AFS_SUN5_ENV)
721       afs_bread_freebp = 0;
722 #endif
723       shutdown_mariner();
724   }
725 }
726
727
728 void shutdown_AFS()
729
730 {
731     int i;
732     register struct srvAddr *sa;
733     extern int afs_cold_shutdown;
734
735     AFS_STATCNT(shutdown_AFS);
736     if (afs_cold_shutdown) {
737       afs_resourceinit_flag = 0; 
738       /* 
739        * Free Cells table allocations 
740        */
741       { 
742         struct cell *tc;
743         register struct afs_q *cq, *tq;
744         for (cq = CellLRU.next; cq != &CellLRU; cq = tq) {
745             tc = QTOC(cq); tq = QNext(cq);
746             if (tc->cellName)
747                 afs_osi_Free(tc->cellName, strlen(tc->cellName)+1);
748             afs_osi_Free(tc, sizeof(struct cell));
749         }
750       }
751       /* 
752        * Free Volumes table allocations 
753        */
754       { 
755         struct volume *tv;
756         for (i = 0; i < NVOLS; i++) {
757             for (tv = afs_volumes[i]; tv; tv = tv->next) {
758                 if (tv->name) {
759                     afs_osi_Free(tv->name, strlen(tv->name)+1);
760                     tv->name = 0;
761                 }
762             }
763             afs_volumes[i] = 0;
764         }
765       }
766
767       /* 
768        * Free FreeVolList allocations 
769        */
770       afs_osi_Free(Initialafs_freeVolList, afs_memvolumes * sizeof(struct volume));
771       afs_freeVolList = Initialafs_freeVolList = 0;
772
773       /* XXX HACK fort MEM systems XXX 
774        *
775        * For -memcache cache managers when we run out of free in memory volumes
776        * we simply malloc more; we won't be able to free those additional volumes.
777        */
778
779       
780
781       /* 
782        * Free Users table allocation 
783        */
784       { 
785         struct unixuser *tu, *ntu;
786         for (i=0; i < NUSERS; i++) {
787             for (tu=afs_users[i]; tu; tu = ntu) {
788                 ntu = tu->next;
789                 if (tu->stp)
790                     afs_osi_Free(tu->stp, tu->stLen);
791                 if (tu->exporter)
792                     EXP_RELE(tu->exporter);
793                 afs_osi_Free(tu, sizeof(struct unixuser));
794             }
795             afs_users[i] = 0;
796         }
797       }
798
799       /* 
800        * Free Servers table allocation 
801        */
802       { 
803         struct server *ts, *nts;
804         struct conn *tc, *ntc;
805         register struct afs_cbr *tcbrp, *tbrp;
806         struct afs_cbr **lcbrpp;
807
808         for (i=0; i < NSERVERS; i++) {
809             for (ts = afs_servers[i]; ts; ts = nts) {
810                 nts = ts->next;
811                 for (sa = ts->addr; sa; sa = sa->next_sa) {     
812                     if (sa->conns) {
813                         /*
814                          * Free all server's connection structs
815                          */
816                         tc = sa->conns;
817                         while (tc) {
818                             ntc = tc->next;
819                             AFS_GUNLOCK();
820                             rx_DestroyConnection(tc->id);
821                             AFS_GLOCK();
822                             afs_osi_Free(tc, sizeof(struct conn));
823                             tc = ntc;
824                         }
825                     }
826                 }
827                 for (tcbrp = ts->cbrs; tcbrp;  tcbrp = tbrp) {
828                     /*
829                      * Free all server's callback structs
830                      */
831                     tbrp = tcbrp->next;
832                     afs_FreeCBR(tcbrp);
833                 }
834                 afs_osi_Free(ts, sizeof(struct server));
835             }
836             afs_servers[i] = 0;
837         }
838       }
839       for (i=0; i<NFENTRIES; i++)
840         fvTable[i] = 0;
841       /* Reinitialize local globals to defaults */
842       afs_osi_Free(afs_sysname, MAXSYSNAME);
843       afs_sysname = 0;
844       afs_marinerHost = 0;
845       QInit(&CellLRU);      
846       afs_setTimeHost = (struct server *)0;
847       afs_volCounter = 1;
848       afs_waitForever = afs_waitForeverCount = 0;
849       afs_cellindex = 0;
850       afs_FVIndex = -1;
851       afs_server = (struct rx_service *)0;
852       RWLOCK_INIT(&afs_xconn, "afs_xconn");
853       bzero((char *)&afs_rootFid, sizeof(struct VenusFid));
854       RWLOCK_INIT(&afs_xuser, "afs_xuser");
855       RWLOCK_INIT(&afs_xvolume, "afs_xvolume"), RWLOCK_INIT(&afs_xcell, "afs_xcell");
856       RWLOCK_INIT(&afs_xserver, "afs_xserver"), LOCK_INIT(&afs_puttofileLock, "afs_puttofileLock");
857     }
858     
859 } /*shutdown_AFS*/