[B<-settime>] [B<-shutdown>]
S<<< [B<-splitcache> <I<RW/RO ratio>>] >>>
S<<< [B<-stat> <I<number of stat entries>>] >>> [B<-verbose>]
+ [B<-disable-dynamic-vcaches>]
S<<< [B<-volumes> <I<number of volume entries>>] >>>
[B<-waitclose>]
Specifies the number of memory structures to allocate for storing volume
location information. The default value is C<50>.
+=item B<-disable-dynamic-vcaches>
+
+By default, dynamic vcache overrides the B<-stat> option by using the value of
+B<-stat> (or the default) as the initial size of the stat (or vcache) pool and
+increases the pool dynamically as needed on supported platforms. This flag will
+disable this new functionality and honor the '-stat' setting.
+
=item B<-waitclose>
Has no effect on the operation of the Cache Manager. The behavior it
afs_CacheInit(cparms.cacheScaches, cparms.cacheFiles,
cparms.cacheBlocks, cparms.cacheDcaches,
cparms.cacheVolumes, cparms.chunkSize,
- cparms.memCacheFlag, cparms.inodes, cparms.users);
+ cparms.memCacheFlag, cparms.inodes, cparms.users,
+ cparms.dynamic_vcaches);
} else if (parm == AFSOP_CACHEINODE) {
ino_t ainode = parm2;
*/
/* Sanity check on the callback queue. Allow for slop in the computation. */
-#ifdef AFS_OSF_ENV
+#if defined(AFS_OSF_ENV) || defined(AFS_LINUX22_ENV)
#define CBQ_LIMIT (afs_maxvcount + 10)
#else
#define CBQ_LIMIT (afs_cacheStats + afs_stats_cmperf.vcacheXAllocs + 10)
#define afs_CheckRXEpoch() {if (rxepoch_checked == 0 && rxkad_EpochWasSet) { \
rxepoch_checked = 1; afs_GCUserData(/* force flag */ 1); } }
+extern int afsd_dynamic_vcaches;
+
/* PAG garbage collection */
/* We induce a compile error if param.h does not define AFS_GCPAGS */
afs_int32 afs_gcpags = AFS_GCPAGS;
struct afs_exporter *exporter;
afs_int32 now;
afs_int32 last3MinCheck, last10MinCheck, last60MinCheck, lastNMinCheck;
- afs_int32 last1MinCheck;
+ afs_int32 last1MinCheck, last5MinCheck;
afs_uint32 lastCBSlotBump;
char cs_warned = 0;
AFS_STATCNT(afs_Daemon);
last1MinCheck = last3MinCheck = last60MinCheck = last10MinCheck =
- lastNMinCheck = 0;
+ last5MinCheck = lastNMinCheck = 0;
afs_rootFid.Fid.Volume = 0;
while (afs_initState < 101)
last3MinCheck = now - 90 + ((afs_random() & 0x7fffffff) % 180);
last60MinCheck = now - 1800 + ((afs_random() & 0x7fffffff) % 3600);
last10MinCheck = now - 300 + ((afs_random() & 0x7fffffff) % 600);
+ last5MinCheck = now - 150 + ((afs_random() & 0x7fffffff) % 300);
lastNMinCheck = now - 90 + ((afs_random() & 0x7fffffff) % 180);
/* start off with afs_initState >= 101 (basic init done) */
* tickets */
last3MinCheck = now;
}
+#ifdef AFS_MAXVCOUNT_ENV
+ if (afsd_dynamic_vcaches && (last5MinCheck + 300 < now)) {
+ /* start with trying to drop us back to our base usage */
+ int anumber;
+ if (afs_maxvcount <= afs_cacheStats)
+ anumber = VCACHE_FREE;
+ else
+ anumber = VCACHE_FREE + (afs_maxvcount - afs_cacheStats);
+
+ afs_ShakeLooseVCaches(anumber);
+ last5MinCheck = now;
+ }
+#endif
if (!afs_CheckServerDaemonStarted) {
/* Do the check here if the correct afsd is not installed. */
if (!cs_warned) {
static struct vnode *volumeVnode;
#endif
+/* This is the kernel side of the dynamic vcache setting */
+int afsd_dynamic_vcaches = 0; /* Enable dynamic-vcache support */
+
/*
* Initialization order is important. Must first call afs_CacheInit,
* then cache file and volume file initialization routines. Next, the
int
afs_CacheInit(afs_int32 astatSize, afs_int32 afiles, afs_int32 ablocks,
afs_int32 aDentries, afs_int32 aVolumes, afs_int32 achunk,
- afs_int32 aflags, afs_int32 ninodes, afs_int32 nusers)
+ afs_int32 aflags, afs_int32 ninodes, afs_int32 nusers, afs_int32 dynamic_vcaches)
{
register afs_int32 i;
register struct volume *tv;
afs_stats_cmperf.sysName_ID = SYS_NAME_ID_UNDEFINED;
#endif /* SYS_NAME_ID */
+#ifdef AFS_MAXVCOUNT_ENV
+ afsd_dynamic_vcaches = dynamic_vcaches;
+ printf("%s dynamically allocated vcaches\n", ( afsd_dynamic_vcaches ? "enabling" : "disabling" ));
+#else
+ afsd_dynamic_vcaches = 0;
+#endif
+
printf("Starting AFS cache scan...");
if (afs_cacheinit_flag)
return 0;
afs_int32 ablocks, afs_int32 aDentries,
afs_int32 aVolumes, afs_int32 achunk,
afs_int32 aflags, afs_int32 ninodes,
- afs_int32 nusers);
+ afs_int32 nusers, afs_int32 dynamic_vcaches);
extern void afs_ComputeCacheParms(void);
extern int afs_InitCacheInfo(register char *afile);
extern int afs_InitVolumeInfo(char *afile);
static struct afs_cbr *afs_cbrHashT[CBRSIZE];
afs_int32 afs_bulkStatsLost;
int afs_norefpanic = 0;
+extern int afsd_dynamic_vcaches;
/* Forward declarations */
static afs_int32 afs_QueueVCB(struct vcache *avc);
VN_UNLOCK(AFSTOV(avc));
#endif
AFS_RELE(AFSTOV(avc));
+ afs_stats_cmperf.vcacheXAllocs--;
} else {
if (afs_norefpanic) {
printf("flush vc refcnt < 1");
#endif
}
-/*
- * afs_NewVCache
- *
- * Description:
- * This routine is responsible for allocating a new cache entry
- * from the free list. It formats the cache entry and inserts it
- * into the appropriate hash tables. It must be called with
- * afs_xvcache write-locked so as to prevent several processes from
- * trying to create a new cache entry simultaneously.
- *
- * Parameters:
- * afid : The file id of the file whose cache entry is being
- * created.
- */
-/* LOCK: afs_NewVCache afs_xvcache W */
-struct vcache *
-afs_NewVCache(struct VenusFid *afid, struct server *serverp)
+static int
+afs_ShakeLooseVCaches(afs_int32 anumber)
{
- struct vcache *tvc;
+#if defined(AFS_OSF_ENV) || defined(AFS_LINUX22_ENV)
afs_int32 i, j;
- afs_int32 anumber = VCACHE_FREE;
-#ifdef AFS_AIX_ENV
- struct gnode *gnodepnt;
-#endif
-#ifdef AFS_OSF_ENV
- struct vcache *nvc;
-#endif /* AFS_OSF_ENV */
+ struct vcache *tvc;
struct afs_q *tq, *uq;
int code, fv_slept;
+ afs_int32 target = anumber;
+ int haveGlock = 1;
- AFS_STATCNT(afs_NewVCache);
-
- afs_FlushReclaimedVcaches();
+ /* Should probably deal better */
+ if (!ISAFS_GLOCK()) {
+ haveGlock = 0;
+ AFS_GLOCK();
+ }
-#if defined(AFS_OSF_ENV) || defined(AFS_LINUX22_ENV)
-#if defined(AFS_OSF30_ENV) || defined(AFS_LINUX22_ENV)
- if (afs_vcount >= afs_maxvcount)
-#else
- /*
- * If we are using > 33 % of the total system vnodes for AFS vcache
- * entries or we are using the maximum number of vcache entries,
- * then free some. (if our usage is > 33% we should free some, if
- * our usage is > afs_maxvcount, set elsewhere to 0.5*nvnode,
- * we _must_ free some -- no choice).
- */
- if (((3 * afs_vcount) > nvnode) || (afs_vcount >= afs_maxvcount))
+ if (
+#ifdef AFS_MAXVCOUNT_ENV
+ afsd_dynamic_vcaches || /* Always run if dynamic vcaches are enabled. */
#endif
- {
+ afs_vcount >= afs_maxvcount
+ ) {
int i;
char *panicstr;
uq = QPrev(tq);
if (tvc->states & CVFlushed) {
refpanic("CVFlushed on VLRU");
- } else if (i++ > afs_maxvcount) {
+ } else if (
+#ifdef AFS_MAXVCOUNT_ENV
+ ! afsd_dynamic_vcaches &&
+#endif
+ i++ > afs_maxvcount) {
refpanic("Exceeded pool of AFS vnodes(VLRU cycle?)");
} else if (QNext(uq) != tq) {
refpanic("VLRU inconsistent");
if (tq == uq)
break;
}
- if (anumber == VCACHE_FREE) {
- printf("afs_NewVCache: warning none freed, using %d of %d\n",
+ if (
+#ifdef AFS_MAXVCOUNT_ENV
+ !afsd_dynamic_vcaches &&
+#endif
+ anumber == target) {
+ printf("afs_ShakeLooseVCaches: warning none freed, using %d of %d\n",
afs_vcount, afs_maxvcount);
- if (afs_vcount >= afs_maxvcount) {
- printf("afs_NewVCache - none freed\n");
- return NULL;
- }
}
}
+/*
+ printf("recycled %d entries\n", target-anumber);
+*/
+ if (!haveGlock)
+ AFS_GUNLOCK();
+#endif
+ return 0;
+}
-#if defined(AFS_LINUX22_ENV)
+
+static struct vcache *
+afs_AllocVCache(void)
{
+ struct vcache *tvc;
+#if defined(AFS_OSF30_ENV)
+ struct vcache *nvc;
+ AFS_GUNLOCK();
+ if (getnewvnode(MOUNT_AFS, &Afs_vnodeops, &nvc)) {
+ /* What should we do ???? */
+ osi_Panic("afs_AllocVCache: no more vnodes");
+ }
+ AFS_GLOCK();
+
+ tvc = nvc;
+ tvc->nextfree = NULL;
+ afs_vcount++;
+#elif defined(AFS_LINUX22_ENV)
struct inode *ip;
AFS_GUNLOCK();
ip = new_inode(afs_globalVFS);
if (!ip)
- osi_Panic("afs_NewVCache: no more inodes");
+ osi_Panic("afs_AllocVCache: no more inodes");
AFS_GLOCK();
#if defined(STRUCT_SUPER_HAS_ALLOC_INODE)
tvc = VTOAFS(ip);
ip->u.generic_ip = tvc;
tvc->v = ip;
#endif
-}
+
+ afs_vcount++;
+#ifdef AFS_MAXVCOUNT_ENV
+ /* track the peak */
+ if (afsd_dynamic_vcaches && afs_maxvcount < afs_vcount) {
+ afs_maxvcount = afs_vcount;
+ printf("peak vnodes: %d\n", afs_maxvcount);
+ }
+#endif
+ afs_stats_cmperf.vcacheXAllocs++; /* count in case we have a leak */
#else
- AFS_GUNLOCK();
- if (getnewvnode(MOUNT_AFS, &Afs_vnodeops, &nvc)) {
- /* What should we do ???? */
- osi_Panic("afs_NewVCache: no more vnodes");
+ /* none free, making one is better than a panic */
+ afs_stats_cmperf.vcacheXAllocs++; /* count in case we have a leak */
+ tvc = (struct vcache *)afs_osi_Alloc(sizeof(struct vcache));
+#if defined(AFS_DARWIN_ENV) && !defined(UKERNEL)
+ tvc->v = NULL; /* important to clean this, or use memset 0 */
+#endif
+#ifdef KERNEL_HAVE_PIN
+ pin((char *)tvc, sizeof(struct vcache)); /* XXX */
+#endif
+#if defined(AFS_SGI_ENV)
+ {
+ char name[METER_NAMSZ];
+ memset(tvc, 0, sizeof(struct vcache));
+ tvc->v.v_number = ++afsvnumbers;
+ tvc->vc_rwlockid = OSI_NO_LOCKID;
+ initnsema(&tvc->vc_rwlock, 1,
+ makesname(name, "vrw", tvc->v.v_number));
+#ifndef AFS_SGI53_ENV
+ initnsema(&tvc->v.v_sync, 0,
+ makesname(name, "vsy", tvc->v.v_number));
+#endif
+#ifndef AFS_SGI62_ENV
+ initnlock(&tvc->v.v_lock,
+ makesname(name, "vlk", tvc->v.v_number));
+#endif
}
- AFS_GLOCK();
+#endif /* AFS_SGI_ENV */
+#endif
+ return tvc;
+}
- tvc = nvc;
- tvc->nextfree = NULL;
+/*!
+ * This routine is responsible for allocating a new cache entry
+ * from the free list. It formats the cache entry and inserts it
+ * into the appropriate hash tables. It must be called with
+ * afs_xvcache write-locked so as to prevent several processes from
+ * trying to create a new cache entry simultaneously.
+ *
+ * LOCK: afs_NewVCache afs_xvcache W
+ *
+ * \param afid The file id of the file whose cache entry is being created.
+ *
+ * \return The new vcache struct.
+ */
+struct vcache *
+afs_NewVCache(struct VenusFid *afid, struct server *serverp)
+{
+ struct vcache *tvc;
+ afs_int32 i, j;
+ afs_int32 anumber = VCACHE_FREE;
+#ifdef AFS_AIX_ENV
+ struct gnode *gnodepnt;
#endif
- afs_vcount++;
+ struct afs_q *tq, *uq;
+ int code, fv_slept;
+
+ AFS_STATCNT(afs_NewVCache);
+
+ afs_FlushReclaimedVcaches();
+
+#if defined(AFS_OSF_ENV) || defined(AFS_LINUX22_ENV)
+#ifdef AFS_MAXVCOUNT_ENV
+ if(!afsd_dynamic_vcaches) {
+#endif
+ afs_ShakeLooseVCaches(anumber);
+ if (afs_vcount >= afs_maxvcount) {
+ printf("afs_NewVCache - none freed\n");
+ return NULL;
+ }
+#ifdef AFS_MAXVCOUNT_ENV
+ }
+#endif
+ tvc = afs_AllocVCache();
#else /* AFS_OSF_ENV */
/* pull out a free cache entry */
if (!freeVCList) {
}
}
if (!freeVCList) {
- /* none free, making one is better than a panic */
- afs_stats_cmperf.vcacheXAllocs++; /* count in case we have a leak */
- tvc = (struct vcache *)afs_osi_Alloc(sizeof(struct vcache));
-#if defined(AFS_DARWIN_ENV) && !defined(UKERNEL)
- tvc->v = NULL; /* important to clean this, or use memset 0 */
-#endif
-#ifdef KERNEL_HAVE_PIN
- pin((char *)tvc, sizeof(struct vcache)); /* XXX */
-#endif
-#if defined(AFS_SGI_ENV)
- {
- char name[METER_NAMSZ];
- memset(tvc, 0, sizeof(struct vcache));
- tvc->v.v_number = ++afsvnumbers;
- tvc->vc_rwlockid = OSI_NO_LOCKID;
- initnsema(&tvc->vc_rwlock, 1,
- makesname(name, "vrw", tvc->v.v_number));
-#ifndef AFS_SGI53_ENV
- initnsema(&tvc->v.v_sync, 0,
- makesname(name, "vsy", tvc->v.v_number));
-#endif
-#ifndef AFS_SGI62_ENV
- initnlock(&tvc->v.v_lock,
- makesname(name, "vlk", tvc->v.v_number));
-#endif
- }
-#endif /* AFS_SGI_ENV */
+ tvc = afs_AllocVCache();
} else {
tvc = freeVCList; /* take from free list */
freeVCList = tvc->nextfree;
newvcache = 1;
ConvertWToSLock(&afs_xvcache);
- if (!tvc)
+ if (tvc == NULL)
{
ReleaseSharedLock(&afs_xvcache);
return NULL;
* -nosettime Don't keep checking the time to avoid drift (default).
* -settime Keep checking the time to avoid drift.
* -verbose Be chatty.
+ * -disable-dynamic-vcaches Disable the use of -stat value as the starting size of
+ * the size of the vcache/stat cache pool,
+ * but increase that pool dynamically as needed.
* -debug Print out additional debugging info.
* -kerndev [OBSOLETE] The kernel device for AFS.
* -dontfork [OBSOLETE] Don't fork off as a new process.
#ifdef notdef
static int inodes = 60; /* VERY conservative, but has to be */
#endif
+int afsd_dynamic_vcaches = 0; /* Enable dynamic-vcache support */
int afsd_verbose = 0; /*Are we being chatty? */
int afsd_debug = 0; /*Are we printing debugging info? */
int afsd_CloseSynch = 0; /*Are closes synchronous or not? */
}
}
+ if (as->parms[34].items) {
+#ifdef AFS_MAXVCOUNT_ENV
+ /* -disable-dynamic-vcaches */
+ afsd_dynamic_vcaches = FALSE;
+#else
+ printf("afsd: Error toggling flag, dynamically allocated vcaches not supported on your platform\n");
+ exit(1);
+#endif
+ }
+#ifdef AFS_MAXVCOUNT_ENV
+ else {
+ /* -dynamic-vcaches */
+ afsd_dynamic_vcaches = TRUE;
+ }
+
+ if (afsd_verbose)
+ printf("afsd: %s dynamically allocated vcaches\n", ( afsd_dynamic_vcaches ? "enabling" : "disabling" ));
+#endif
+
/*
* Pull out all the configuration info for the workstation's AFS cache and
* the cellular community we're willing to let our users see.
cparams.chunkSize = chunkSize;
cparams.setTimeFlag = cacheSetTime;
cparams.memCacheFlag = cacheFlags;
+ cparams.dynamic_vcaches = afsd_dynamic_vcaches;
#ifdef notdef
cparams.inodes = inodes;
#endif
cmd_AddParm(ts, "-settime", CMD_FLAG, CMD_OPTIONAL,
"set the time");
cmd_AddParm(ts, "-rxpck", CMD_SINGLE, CMD_OPTIONAL, "set rx_extraPackets to this value");
+ cmd_AddParm(ts, "-disable-dynamic-vcaches", CMD_FLAG, CMD_OPTIONAL, "disable stat/vcache cache growing as needed");
return (cmd_Dispatch(argc, argv));
}
afs_int32 memCacheFlag;
afs_int32 inodes;
afs_int32 users;
+ afs_int32 dynamic_vcaches;
};
/*
#define AFS_64BIT_ENV 1 /* Defines afs_int32 as int, not long. */
#define AFS_64BITPOINTER_ENV 1 /* pointers are 64 bits. */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#ifdef CONFIG_SMP
#define AFS_64BIT_ENV 1 /* Defines afs_int32 as int, not long. */
#define AFS_64BITPOINTER_ENV 1 /* pointers are 64 bits. */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#ifdef CONFIG_SMP
#define AFS_64BIT_ENV 1
#define AFS_64BIT_CLIENT 1
#define AFS_64BITPOINTER_ENV 1 /* pointers are 64 bits */
-
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#define AFS_64BIT_CLIENT 1
#define AFS_64BITPOINTER_ENV 1 /* pointers are 64 bits. */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#define AFS_64BIT_ENV 1
#define AFS_64BIT_CLIENT 1
#define AFS_64BITPOINTER_ENV 1 /* pointers are 64 bits */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#define AFS_SYSCALL 137
#define AFS_64BIT_IOPS_ENV 1
#define AFS_NAMEI_ENV 1 /* User space interface to file system */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#ifdef CONFIG_SMP
#define AFS_NAMEI_ENV 1 /* User space interface to file system */
#define AFS_64BIT_ENV 1
#define AFS_64BIT_CLIENT 1
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#define AFS_NAMEI_ENV 1 /* User space interface to file system */
#define AFS_64BIT_ENV 1
#define AFS_64BIT_CLIENT 1
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#define AFS_SYSCALL 137
#define AFS_64BIT_IOPS_ENV 1
#define AFS_NAMEI_ENV 1 /* User space interface to file system */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#ifdef CONFIG_SMP
#define AFS_NAMEI_ENV 1 /* User space interface to file system */
#define AFS_64BIT_ENV 1
#define AFS_64BIT_CLIENT 1
+#define AFS_MAXVCOUNT_ENV 1
#ifdef AFS_LARGEFILE_ENV
#define _FILE_OFFSET_BITS 64
#define AFS_NAMEI_ENV 1 /* User space interface to file system */
#define AFS_64BIT_ENV 1
#define AFS_64BIT_CLIENT 1
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#define AFS_64BIT_CLIENT 1
#define AFS_64BITPOINTER_ENV 1 /* pointers are 64 bits. */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#define AFS_64BIT_CLIENT 1
#define AFS_64BITPOINTER_ENV 1 /* pointers are 64 bits. */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#include <linux/init.h>
#define AFS_64BIT_CLIENT 1
#define AFS_64BIT_IOPS_ENV 1
#define AFS_NAMEI_ENV 1 /* User space interface to file system */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#define AFS_64BIT_CLIENT 1
#define AFS_64BITPOINTER_ENV 1 /* pointers are 64 bits. */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#define AFS_64BIT_CLIENT 1
#define AFS_64BITPOINTER_ENV 1 /* pointers are 64 bits. */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#define AFS_SYSCALL 137
#define AFS_64BIT_IOPS_ENV 1
#define AFS_NAMEI_ENV 1 /* User space interface to file system */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#ifdef CONFIG_SMP
#define AFS_64BIT_CLIENT 1
#define AFS_64BIT_IOPS_ENV 1
#define AFS_NAMEI_ENV 1 /* User space interface to file system */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#define AFS_64BIT_CLIENT 1
#define AFS_64BIT_IOPS_ENV 1
#define AFS_NAMEI_ENV 1 /* User space interface to file system */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#define AFS_SYSCALL 137
#define AFS_64BIT_IOPS_ENV 1
#define AFS_NAMEI_ENV 1 /* User space interface to file system */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#ifdef CONFIG_SMP
#define AFS_64BIT_CLIENT 1
#define AFS_64BIT_IOPS_ENV 1
#define AFS_NAMEI_ENV 1 /* User space interface to file system */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#define AFS_64BIT_CLIENT 1
#define AFS_64BIT_IOPS_ENV 1
#define AFS_NAMEI_ENV 1 /* User space interface to file system */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#define AFS_64BIT_KERNEL 1
#define AFS_64BIT_IOPS_ENV 1
#define AFS_NAMEI_ENV 1 /* User space interface to file system */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#define AFS_LINUX_64BIT_KERNEL 1
#define AFS_64BIT_IOPS_ENV 1
#define AFS_NAMEI_ENV 1 /* User space interface to file system */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#define AFS_64BIT_ENV 1 /* Defines afs_int32 as int, not long. */
#define AFS_32BIT_USR_ENV 1 /* user level processes are 32bit */
#define AFS_64BITPOINTER_ENV 1 /* pointers are 64 bits. */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#ifdef CONFIG_SMP
#define AFS_64BIT_CLIENT 1
#define AFS_32BIT_USR_ENV 1
#define AFS_64BITPOINTER_ENV 1 /* pointers are 64 bits. */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#define AFS_64BIT_CLIENT 1
#define AFS_32BIT_USR_ENV 1
#define AFS_64BITPOINTER_ENV 1 /* pointers are 64 bits. */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#define AFS_SYSCALL 227
#define AFS_64BIT_IOPS_ENV 1
#define AFS_NAMEI_ENV 1 /* User space interface to file system */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#ifdef CONFIG_SMP
#define AFS_64BIT_CLIENT 1
#define AFS_64BIT_IOPS_ENV 1
#define AFS_NAMEI_ENV 1 /* User space interface to file system */
+#define AFS_MAXVCOUNT_ENV 1
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
git://git.openafs.org / openafs.git / commitdiff