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