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