#define AFS_NRXPACKETS 80
#define AFS_RXDEADTIME 50
#define AFS_HARDDEADTIME 120
+#define AFS_IDLEDEADTIME 50
+#define AFS_BLKBITS 12
+#define AFS_BLKSIZE (1 << AFS_BLKBITS)
extern afs_int32 afs_rx_deadtime;
extern afs_int32 afs_rx_harddead;
+extern afs_int32 afs_rx_idledead;
struct sysname_info {
char *name;
#define BOP_STORE 2 /* parm1 is chunk to store */
#define BOP_PATH 3 /* parm1 is path, parm2 is chunk to fetch */
+#if defined(AFS_CACHE_BYPASS)
+#define BOP_FETCH_NOCACHE 4 /* parms are: vnode ptr, offset, segment ptr, addr, cred ptr */
+#endif
+
#define B_DONTWAIT 1 /* On failure return; don't wait */
/* protocol is: refCount is incremented by user to take block out of free pool.
afs_int32 uid; /* user id making the request */
afs_int32 busyCount; /* how many busies we've seen so far */
afs_int32 flags; /* things like O_SYNC, O_NONBLOCK go here */
- char initd; /* if non-zero, non-uid fields meaningful */
+ char initd; /* if non-zero, Error fields meaningful */
char accessError; /* flags for overriding error return code */
char volumeError; /* encountered a missing or busy volume */
char networkError; /* encountered network problems */
char permWriteError; /* fileserver returns permenent error. */
+ char tokenError; /* a token error other than expired. */
+ char idleError; /* the server idled too long */
+ char skipserver[MAXHOSTS];
};
#define VOLMISSING 1
#define VOLBUSY 2
time_t timeout; /* data expire time, if non-zero */
struct cell_name *cnamep; /* pointer to our cell_name */
afs_rwlock_t lock; /* protects cell data */
+ unsigned char cellHandle[16]; /* deterministic handle for this cell */
};
struct cell_name {
#define UPrimary 4 /* on iff primary identity */
#define UNeedsReset 8 /* needs afs_ResetAccessCache call done */
#define UPAGCounted 16 /* entry seen during PAG search (for stats) */
+#define UNFSGetCreds 32 /* getting creds for NFS client */
/* A flag used by afs_GCPAGs to keep track of
* which entries in afs_users need to be deleted.
* The lifetime of its presence in the table is the
extern afs_int32 afs_gcpags;
extern afs_int32 afs_gcpags_procsize;
extern afs_int32 afs_bkvolpref;
+extern char afs_cachebasedir[1024];
+extern afs_int32 afs_numcachefiles;
+extern afs_int32 afs_numfilesperdir;
struct unixuser {
struct unixuser *next; /* next hash pointer */
char *stp; /* pointer to ticket itself */
struct ClearToken ct;
struct afs_exporter *exporter; /* more info about the exporter for the remote user */
+ void *cellinfo; /* pointer to cell info (PAG manager only) */
};
struct conn {
#define QInit(q) ((q)->prev = (q)->next = (q))
#define QAdd(q,e) ((e)->next = (q)->next, (e)->prev = (q), \
(q)->next->prev = (e), (q)->next = (e))
-#define QRemove(e) ((e)->next->prev = (e)->prev, (e)->prev->next = (e)->next)
+#define QRemove(e) ((e)->next->prev = (e)->prev, (e)->prev->next = (e)->next, (e)->prev = NULL, (e)->next = NULL)
#define QNext(e) ((e)->next)
#define QPrev(e) ((e)->prev)
#define QEmpty(q) ((q)->prev == (q))
*/
#define QTOV(e) ((struct vcache *)(((char *) (e)) - (((char *)(&(((struct vcache *)(e))->vlruq))) - ((char *)(e)))))
#define QTOC(e) ((struct cell *)((char *) (e)))
+#define QTOVH(e) ((struct vcache *)(((char *) (e)) - (((char *)(&(((struct vcache *)(e))->vhashq))) - ((char *)(e)))))
#define SRVADDR_MH 1
#define SRVADDR_ISDOWN 0x20 /* same as SRVR_ISDOWN */
#ifdef AFS_OSF_ENV
#define CWired 0x00000800 /* OSF hack only */
#else
+#ifdef AFS_DARWIN80_ENV
+#define CDeadVnode 0x00000800
+#else
#ifdef AFS_DARWIN_ENV
#define CUBCinit 0x00000800
#else
#define CWRITE_IGN 0x00000800 /* Next OS hack only */
#endif
#endif
+#endif
#define CUnique 0x00001000 /* vc's uniquifier - latest unifiquier for fid */
#define CForeign 0x00002000 /* this is a non-afs vcache */
+#define CReadDir 0x00004000 /* readdir in progress */
#define CUnlinked 0x00010000
#define CBulkStat 0x00020000 /* loaded by a bulk stat, and not ref'd since */
#define CUnlinkedDel 0x00040000
#define CVFlushed 0x00080000
#define CCore1 0x00100000 /* osf1 core file; not same as CCore above */
+#ifdef AFS_LINUX22_ENV
+#define CPageWrite 0x00200000 /* to detect vm deadlock - linux */
+#else
#define CWritingUFS 0x00200000 /* to detect vm deadlock - used by sgi */
+#endif
#define CCreating 0x00400000 /* avoid needless store after open truncate */
#define CPageHog 0x00800000 /* AIX - dumping large cores is a page hog. */
#define CDCLock 0x02000000 /* Vnode lock held over call to GetDownD */
#define CBulkFetching 0x04000000 /* stats are being fetched by bulk stat */
#define CExtendedFile 0x08000000 /* extended file via ftruncate call. */
+#define CVInit 0x10000000 /* being initialized */
/* vcache vstate bits */
#define VRevokeWait 0x1
#define VPageCleaning 0x2 /* Solaris - Cache Trunc Daemon sez keep out */
+#if defined(AFS_DISCON_ENV)
+
+/* Dirty disconnected vcache flags. */
+#define VDisconSetTime 0x00000001 /* set time. */
+#define VDisconSetMode 0x00000002 /* set mode. */
+/* XXX: to be continued ? */
+#define VDisconTrunc 0x00000020 /* truncate file. */
+#define VDisconSetAttrMask 0x0000003F /* Masks for setattr ops. */
+#define VDisconWriteClose 0x00000400 /* Write op on file close. */
+#define VDisconWriteFlush 0x00000800 /* Write op on normal fsync/flush. */
+#define VDisconWriteOsiFlush 0x00001000 /* Write op on osi flush. */
+
+#define VDisconShadowed 0x00002000 /* Shadowed dir. */
+#define VDisconRemove 0x00004000 /* Remove vnop. */
+#define VDisconCreate 0x00008000 /* Create vnop. */
+#define VDisconRename 0x00010000 /* Rename vnop. */
+#define VDisconRenameSameDir 0x00020000 /* Rename in same dir. */
+
+/*... to be continued ... */
+#endif
+
+#if defined(AFS_CACHE_BYPASS)
+/* vcache (file) cachingStates bits */
+#define FCSDesireBypass 0x1 /* This file should bypass the cache */
+#define FCSBypass 0x2 /* This file is currently NOT being cached */
+#define FCSManuallySet 0x4 /* The bypass flags were set, or reset, manually (via pioctl)
+ and should not be overridden by the file's name */
+
+/* Flag values used by the Transition routines */
+#define TRANSChangeDesiredBit 0x1 /* The Transition routine should set or
+ * reset the FCSDesireBypass bit */
+#define TRANSVcacheIsLocked 0x2 /* The Transition routine does not need to
+ * lock vcache (it's already locked) */
+#define TRANSSetManualBit 0x4 /* The Transition routine should set FCSManuallySet so that
+ * filename checking does not override pioctl requests */
+#endif /* AFS_CACHE_BYPASS */
+
#define CPSIZE 2
#if defined(AFS_XBSD_ENV) || defined(AFS_DARWIN_ENV)
#define vrefCount v->v_usecount
#define vrefCount v.v_count
#endif /* AFS_XBSD_ENV */
-#if defined(AFS_LINUX24_ENV)
-#define VREFCOUNT(v) atomic_read(&((vnode_t *) v)->v_count)
-#define VREFCOUNT_SET(v, c) atomic_set(&((vnode_t *) v)->v_count, c)
-#define VREFCOUNT_DEC(v) atomic_dec(&((vnode_t *) v)->v_count)
-#define VREFCOUNT_INC(v) atomic_inc(&((vnode_t *) v)->v_count)
+#if defined(AFS_DARWIN80_ENV)
+#define VREFCOUNT_GT(v, y) vnode_isinuse(AFSTOV(v), (y))
+#elif defined(AFS_XBSD_ENV) || defined(AFS_DARWIN_ENV)
+#define VREFCOUNT(v) ((v)->vrefCount)
+#define VREFCOUNT_GT(v, y) (AFSTOV(v)->v_usecount > (y))
+#elif defined(AFS_LINUX24_ENV)
+#define VREFCOUNT(v) atomic_read(&(AFSTOV(v)->v_count))
+#define VREFCOUNT_GT(v, y) (VREFCOUNT(v)>y)
+#define VREFCOUNT_SET(v, c) atomic_set(&(AFSTOV(v)->v_count), c)
+#define VREFCOUNT_DEC(v) atomic_dec(&(AFSTOV(v)->v_count))
+#define VREFCOUNT_INC(v) atomic_inc(&(AFSTOV(v)->v_count))
#else
#define VREFCOUNT(v) ((v)->vrefCount)
+#define VREFCOUNT_GT(v,y) ((v)->vrefCount > (y))
#define VREFCOUNT_SET(v, c) (v)->vrefCount = c;
#define VREFCOUNT_DEC(v) (v)->vrefCount--;
#define VREFCOUNT_INC(v) (v)->vrefCount++;
extern afs_int32 vmPageHog; /* counter for # of vnodes which are page hogs. */
-/*
- * Fast map from vcache to dcache
- */
-struct vtodc {
- struct dcache *dc;
- afs_uint32 stamp;
- struct osi_file *f;
- afs_offs_t minLoc; /* smallest offset into dc. */
- afs_offs_t len; /* largest offset into dc. */
-};
-
-extern afs_uint32 afs_stampValue; /* stamp for pair's usage */
-#define MakeStamp() (++afs_stampValue)
-
-#if defined(AFS_XBSD_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_DARWIN80_ENV)
+#define VTOAFS(v) ((struct vcache *)vnode_fsnode((v)))
+#define AFSTOV(vc) ((vc)->v)
+#elif defined(AFS_XBSD_ENV) || defined(AFS_DARWIN_ENV) || (defined(AFS_LINUX22_ENV) && !defined(STRUCT_SUPER_HAS_ALLOC_INODE))
#define VTOAFS(v) ((struct vcache *)(v)->v_data)
#define AFSTOV(vc) ((vc)->v)
#else
#define AFSTOV(V) (&(V)->v)
#endif
-#ifdef AFS_LINUX22_ENV
-#define ITOAFS(V) ((struct vcache*)(V))
-#define AFSTOI(V) (struct inode *)(&(V)->v)
-#endif
-
/* INVARIANTs: (vlruq.next != NULL) == (vlruq.prev != NULL)
* nextfree => !vlruq.next && ! vlruq.prev
* !(avc->nextfree) && !avc->vlruq.next => (FreeVCList == avc->nextfree)
*/
struct vcache {
-#if defined(AFS_XBSD_ENV)||defined(AFS_DARWIN_ENV)
+#if defined(AFS_XBSD_ENV) || defined(AFS_DARWIN_ENV) || (defined(AFS_LINUX22_ENV) && !defined(STRUCT_SUPER_HAS_ALLOC_INODE))
struct vnode *v;
#else
struct vnode v; /* Has reference count in v.v_count */
#endif
struct afs_q vlruq; /* lru q next and prev */
+#if !defined(AFS_LINUX22_ENV)
struct vcache *nextfree; /* next on free list (if free) */
+#endif
struct vcache *hnext; /* Hash next */
- struct vcache *vhnext; /* vol hash next */
+ struct afs_q vhashq; /* Hashed per-volume list */
+
+#if defined(AFS_DISCON_ENV)
+ /*! Next element in afs_DDirtyVCList. Lock it with afs_DDirtyVCListLock. */
+ struct vcache *ddirty_next;
+ /*! Disconnected flags for this vcache element. */
+ uint32_t ddirty_flags;
+ /*! Shadow vnode + unique keep the shadow dir location. */
+ afs_uint32 shVnode;
+ afs_uint32 shUnique;
+ /*! The old parent FID for renamed vnodes. */
+ afs_uint32 oldVnode;
+ afs_uint32 oldUnique;
+#endif
+
struct VenusFid fid;
struct mstat {
afs_size_t Length;
afs_uint32 Group;
afs_uint16 Mode; /* XXXX Should be afs_int32 XXXX */
afs_uint16 LinkCount;
+#ifdef AFS_DARWIN80_ENV
+ afs_uint16 Type;
+#else
/* vnode type is in v.v_type */
+#endif
} m;
afs_rwlock_t lock; /* The lock on the vcache contents. */
#if defined(AFS_SUN5_ENV)
#ifdef AFS_AIX_ENV
int ownslock; /* pid of owner of excl lock, else 0 - defect 3083 */
#endif
-#ifdef AFS_DARWIN_ENV
+#ifdef AFS_DARWIN80_ENV
+ lck_mtx_t *rwlock;
+#elif defined(AFS_DARWIN_ENV)
struct lock__bsd__ rwlock;
#endif
#ifdef AFS_XBSD_ENV
* this file. */
short flockCount; /* count of flock readers, or -1 if writer */
char mvstat; /* 0->normal, 1->mt pt, 2->root. */
+
+#if defined(AFS_CACHE_BYPASS)
+ char cachingStates; /* Caching policies for this file */
+ afs_uint32 cachingTransitions; /* # of times file has flopped between caching and not */
+#if defined(AFS_LINUX24_ENV)
+ off_t next_seq_offset; /* Next sequential offset (used by prefetch/readahead) */
+#else
+ off_t next_seq_blk_offset; /* accounted in blocks for Solaris & IRIX */
+#endif
+#endif
+
afs_uint32 states; /* state bits */
#if defined(AFS_SUN5_ENV)
afs_uint32 vstates; /* vstate bits */
#endif /* defined(AFS_SUN5_ENV) */
- struct vtodc quick;
- afs_uint32 symhintstamp;
- union {
- struct vcache *symhint;
- struct dcache *dchint;
- } h1;
+ struct dcache *dchint;
+ struct dcache *dcreaddir; /* dcache for in-progress readdir */
+ unsigned int readdir_pid; /* pid of the thread in readdir */
#ifdef AFS_LINUX22_ENV
u_short mapcnt; /* Number of mappings of this file. */
#endif
#endif
};
-#define afs_symhint_inval(avc)
-
-
#define DONT_CHECK_MODE_BITS 0
#define CHECK_MODE_BITS 1
#define CMB_ALLOW_EXEC_AS_READ 2 /* For the NFS xlator */
#endif
#endif
+
+#ifdef KERNEL
+/* it does not compile outside kernel */
struct buffer {
afs_int32 fid; /* is adc->index, the cache file number */
afs_inode_t inode; /* is adc->f.inode, the inode number of the cac\
char lockers;
char dirty;
char hashIndex;
-#if AFS_USEBUFFERS
+#if defined(AFS_USEBUFFERS)
struct buf *bufp;
#endif
afs_rwlock_t lock; /* the lock for this structure */
afs_int32 chunkBytes; /* Num bytes in this chunk */
char states; /* Has this chunk been modified? */
};
+#endif
/* magic numbers to specify the cache type */
char dflags; /* Data flags */
char mflags; /* Meta flags */
struct fcache f; /* disk image */
- afs_int32 stamp; /* used with vtodc struct for hints */
afs_int32 bucket; /* which bucket these dcache entries are in */
/*
* Locking rules:
* Note that dcache.lock(W) gives you the right to update mflags,
* as dcache.mflock(W) can only be held with dcache.lock(R).
*
- * dcache.stamp is protected by the associated vcache lock, because
- * it's only purpose is to establish correspondence between vcache
- * and dcache entries.
- *
* dcache.index, dcache.f.fid, dcache.f.chunk and dcache.f.inode are
* write-protected by afs_xdcache and read-protected by refCount.
* Once an entry is referenced, these values cannot change, and if
* ensuring noone else has a refCount on it).
*/
};
-/* this is obsolete and should be removed */
-#define ihint stamp
/* afs_memcache.c */
struct memCacheEntry {
/*#define afs_DirtyPages(avc) (((avc)->states & CDirty) || osi_VMDirty_p((avc)))*/
#define afs_DirtyPages(avc) ((avc)->states & CDirty)
+#define afs_InReadDir(avc) (((avc)->states & CReadDir) && (avc)->readdir_pid == MyPidxx)
+
/* The PFlush algorithm makes use of the fact that Fid.Unique is not used in
below hash algorithms. Change it if need be so that flushing algorithm
doesn't move things from one hash chain to another
extern afs_int32 afs_cacheBlocks; /*1K blocks in cache */
extern afs_int32 afs_cacheStats; /*Stat entries in cache */
extern struct vcache *afs_vhashT[VCSIZE]; /*Stat cache hash table */
-extern struct vcache *afs_vhashTV[VCSIZE]; /* cache hash table on volume */
+extern struct afs_q afs_vhashTV[VCSIZE]; /* cache hash table on volume */
extern afs_int32 afs_initState; /*Initialization state */
extern afs_int32 afs_termState; /* Termination state */
extern struct VenusFid afs_rootFid; /*Root for whole file system */
* GetVCache incantation, and could eliminate even this code from afs_UFSRead
* by making intentionally invalidating quick.stamp in the various callbacks
* expiration/breaking code */
-#ifdef AFS_LINUX20_ENV
-#define afs_VerifyVCache(avc, areq) \
- (((avc)->states & CStatd) ? (vcache2inode(avc), 0) : \
- afs_VerifyVCache2((avc),areq))
-#else
#ifdef AFS_DARWIN_ENV
#define afs_VerifyVCache(avc, areq) \
(((avc)->states & CStatd) ? (osi_VM_Setup(avc, 0), 0) : \
#define afs_VerifyVCache(avc, areq) \
(((avc)->states & CStatd) ? 0 : afs_VerifyVCache2((avc),areq))
#endif
-#endif
#define DO_STATS 1 /* bits used by FindVCache */
#define DO_VLRU 2
+#define IS_SLOCK 4
+#define IS_WLOCK 8
/* values for flag param of afs_CheckVolumeNames */
#define AFS_VOLCHECK_EXPIRED 0x1 /* volumes whose callbacks have expired */
#define CM_CACHESIZEDRAINEDPCT 95 /* wakeup processes when down to here. */
#define CM_WAITFORDRAINPCT 98 /* sleep if cache is this full. */
+/* when afs_cacheBlocks is large, settle for slightly decreased precision */
+#define PERCENT(p, v) \
+ ((afs_cacheBlocks & 0xffe00000) ? ((v) / 100 * (p)) : ((p) * (v) / 100))
+
#define afs_CacheIsTooFull() \
(afs_blocksUsed - afs_blocksDiscarded > \
- (CM_DCACHECOUNTFREEPCT*afs_cacheBlocks)/100 || \
+ PERCENT(CM_DCACHECOUNTFREEPCT, afs_cacheBlocks) || \
afs_freeDCCount - afs_discardDCCount < \
- ((100-CM_DCACHECOUNTFREEPCT)*afs_cacheFiles)/100)
+ PERCENT(100 - CM_DCACHECOUNTFREEPCT, afs_cacheFiles))
/* Handy max length of a numeric string. */
#define CVBS 12 /* max afs_int32 is 2^32 ~ 4*10^9, +1 for NULL, +luck */
};
extern int afs_fakestat_enable;
-
-/* First 32 bits of capabilities */
-#define CAPABILITY_ERRORTRANS (1<<0)
-
-#define CAPABILITY_BITS 1
-
#endif /* _AFS_H_ */
git://git.openafs.org / openafs.git / blobdiff