#include "afs/afs_consts.h"
#endif
+/* jhash.h is a standalone header and is fine to pull into kernel code. */
+#include <opr/jhash.h>
+
/*
* afs_fsfragsize cannot be less than 1023, or some cache-tracking
* calculations will be incorrect (since we track cache usage in kb).
/* Upper bound on number of iovecs out uio routines will deal with. */
#define AFS_MAXIOVCNT 16
-
-extern int afs_shuttingdown;
+enum afs_shutdown_state {
+ AFS_RUNNING = 0,
+ AFS_FLUSHING_CB = 1,
+ AFS_SHUTDOWN = 2,
+};
+extern enum afs_shutdown_state afs_shuttingdown;
/*
* Macros to uniquely identify the AFS vfs struct
*/
#define AFS_VFSMAGIC 0x1234
-#if defined(AFS_SUN5_ENV) || defined(AFS_HPUX90_ENV) || defined(AFS_LINUX20_ENV)
-#define AFS_VFSFSID 99
-#else
-#if defined(AFS_SGI_ENV)
-#define AFS_VFSFSID afs_fstype
+
+#if defined(UKERNEL)
+# if defined(AFS_USR_AIX_ENV) || defined(AFS_USR_SGI_ENV)
+# define AFS_VFSFSID AFS_MOUNT_AFS
+# else
+# define AFS_VFSFSID 99
+# endif
+#elif defined(AFS_SUN5_ENV) || defined(AFS_HPUX90_ENV) || defined(AFS_LINUX20_ENV)
+# define AFS_VFSFSID 99
+#elif defined(AFS_SGI_ENV)
+# define AFS_VFSFSID afs_fstype
#else
-#define AFS_VFSFSID AFS_MOUNT_AFS
-#endif
+# define AFS_VFSFSID AFS_MOUNT_AFS
#endif
+/* use this value for reporting total space, free space, etc.
+ * fake a high number to satisfy programs that use the statfs call to make sure
+ * that there's enough space in the device partition before storing something
+ * there. keep it just under 2^31, to try and be safe about not breaking
+ * stuff that looks at the amount of free space. */
+#define AFS_VFS_FAKEFREE (2147483647)
/* Moved from VNOPS/afs_vnop_flocks so can be used in prototypes */
#if defined(AFS_HPUX102_ENV)
#define AFS_FLOCK k_flock
#else
-#if defined(AFS_SUN56_ENV) || (defined(AFS_LINUX24_ENV) && !(defined(AFS_LINUX26_ENV) && defined(AFS_LINUX_64BIT_KERNEL)))
+#if defined(AFS_SUN5_ENV) || (defined(AFS_LINUX24_ENV) && !(defined(AFS_LINUX26_ENV) && defined(AFS_LINUX_64BIT_KERNEL)))
#define AFS_FLOCK flock64
#else
#define AFS_FLOCK flock
#define NSERVERS 16 /* hash table size for server table */
#define NVOLS 64 /* hash table size for volume table */
#define NFENTRIES 256 /* hash table size for disk volume table */
-#define VCSIZE 1024 /* stat cache hash table size */
-#define DCSIZE 512 /* disk cache hash table size */
+#define VCSIZEBITS 16 /* log of stat cache hash table size */
+#define VCSIZE (opr_jhash_size(VCSIZEBITS))
#define CBRSIZE 512 /* call back returns hash table size */
#define PIGGYSIZE 1350 /* max piggyback size */
#define MAXVOLS 128 /* max vols we can store */
#define MAXSYSNAME 128 /* max sysname (i.e. @sys) size */
#define MAXNUMSYSNAMES 32 /* max that current constants allow */
+#define MAXROOTVOLNAMELEN 64 /* max length of root volume name */
#define NOTOKTIMEOUT (2*3600) /* time after which to timeout conns sans tokens */
#define NOPAG 0xffffffff
-#define AFS_NCBRS 1024 /* max # of call back return entries */
+
+
+
#define AFS_MAXCBRSCALL 32 /* max to return in a given call (must be <= AFSCBMAX) */
-#define AFS_SALLOC_LOW_WATER 250 /* Min free blocks before allocating more */
-#define AFS_LRALLOCSIZ 4096 /* "Large" allocated size */
#define VCACHE_FREE 5
+#define VCACHE_DYNAMIC_STRESSED 10000
+#define VCACHE_STRESS_LOGINTERVAL (60*60*4) /* 4 hours */
#define AFS_NRXPACKETS 80
#define AFS_RXDEADTIME 50
#define AFS_HARDDEADTIME 120
-#define AFS_IDLEDEADTIME 50
+#define AFS_IDLEDEADTIME 1200
+#define AFS_IDLEDEADTIME_REP 180 /* more than fs's cb dead time */
#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;
+extern afs_int32 afs_rx_idledead_rep;
struct sysname_info {
char *name;
#define BOP_FETCH 1 /* parm1 is chunk to get */
#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
#ifdef AFS_DARWIN_ENV
#define BOP_MOVE 5 /* ptr1 afs_uspc_param ptr2 sname ptr3 dname */
#endif
+#define BOP_PARTIAL_STORE 6 /* parm1 is chunk to store */
+#define BOP_INVALIDATE_SEGMENTS 7 /* no parms: just uses the 'bp->vc' vcache */
#define B_DONTWAIT 1 /* On failure return; don't wait */
afs_ucred_t *cred; /* credentials to use for operation */
afs_size_t size_parm[BPARMS]; /* random parameters */
void *ptr_parm[BPARMS]; /* pointer parameters */
- afs_int32 code; /* return code */
+ afs_int32 code_raw; /* return code from AFS routines */
+ afs_int32 code_checkcode; /* the afs_CheckCode-translated code */
short refCount; /* use counter for this structure */
char opcode; /* what to do (store, fetch, etc) */
char flags; /* free, etc */
struct AFSFid Fid;
};
-/* Temporary struct to be passed between afs_fid and afs_vget; in SunOS4.x we can only pass a maximum of 10 bytes for a handle (we ideally need 16!) */
+/* Temporary struct to be passed between afs_fid and afs_vget */
struct SmallFid {
afs_int32 Volume;
afs_int32 CellAndUnique;
char tokenError; /* a token error other than expired. */
char idleError; /* the server idled too long */
char skipserver[AFS_MAXHOSTS];
+ afs_int32 lasterror[AFS_MAXHOSTS];
};
#define VOLMISSING 1
#define VOLBUSY 2
struct afs_cbr *hash_next;
struct AFSFid fid;
- unsigned int dynalloc:1;
};
+#ifdef AFS_LINUX22_ENV
+/* On Linux, we have to be able to allocate the storage for this using
+ * kmalloc, as otherwise we may deadlock. So, it needs to be able to fit
+ * in a single page
+ */
+# define AFS_NCBRS PAGE_SIZE/sizeof(struct afs_cbr)
+#else
+# define AFS_NCBRS 1024 /* max # of call back return entries */
+#endif
+
/* cellinfo file magic number */
#define AFS_CELLINFO_MAGIC 0xf32817cd
struct tokenJar *tokens;
struct afs_exporter *exporter; /* more info about the exporter for the remote user */
void *cellinfo; /* pointer to cell info (PAG manager only) */
+ afs_rwlock_t lock;
};
+#define CVEC_LEN 3 /* per-user connection pool */
+
+struct sa_conn_vector;
+typedef struct sa_conn_vector * p_sa_conn_vector; /* forward decl */
+
+#define CONN_REPLICATED 0x1
+
struct afs_conn {
- /* Per-connection block. */
- struct afs_conn *next; /* Next dude same server. */
+ int refCount;
+ int activated;
+ char forceConnectFS; /* Should we try again with these tokens? */
+ struct rx_connection *id; /* RPC connid */
+ struct sa_conn_vector *parent; /* the con_vector which contains us */
+};
+
+/* An sa_conn_vector replaces the erstwhile list of conn
+ structures maintained by the cache manager. The sa_conn_vector
+ contains a C array of connections which, if non-zero, represent
+ connections to AFS servers.
+*/
+
+struct sa_conn_vector {
+ /* linked-list machinery */
+ struct sa_conn_vector *next;
+
+ /* AFS conn-identifying info */
struct unixuser *user; /* user validated with respect to. */
- struct rx_connection *id; /* RPC connid. */
struct srvAddr *srvr; /* server associated with this conn */
short refCount; /* reference count for allocation */
unsigned short port; /* port associated with this connection */
- char forceConnectFS; /* Should we try again with these tokens? */
-};
+ int flags;
+ /* next connection to return when all in cvec are fully utilized */
+ int select_index;
+
+ /* connections vector */
+ struct afs_conn cvec[CVEC_LEN];
+};
#define SQNULL -1
#define SRVADDR_MH 1
#define SRVADDR_ISDOWN 0x20 /* same as SRVR_ISDOWN */
#define SRVADDR_NOUSE 0x40 /* Don't use this srvAddr */
+
struct srvAddr {
struct srvAddr *next_bkt; /* next item in hash bucket */
struct srvAddr *next_sa; /* another interface on same host */
struct server *server; /* back to parent */
- struct afs_conn *conns; /* All user connections to this server */
+ struct sa_conn_vector *conns; /* All user connections to this server */
+ struct afs_conn *natping;
afs_int32 sa_ip; /* Host addr in network byte order */
u_short sa_iprank; /* indiv ip address priority */
u_short sa_portal; /* port addr in network byte order */
#define SRV_CAPABILITIES(ts) \
{ if ( !(ts->flags & SCAPS_KNOWN)) afs_GetCapabilities(ts); ts->capabilities; }
-#define afs_serverSetNo64Bit(s) ((s)->srvr->server->flags |= SNO_64BIT)
-#define afs_serverHasNo64Bit(s) ((s)->srvr->server->flags & SNO_64BIT)
+#define afs_serverSetNo64Bit(s) (((struct sa_conn_vector*)(s)->parent)->srvr->server->flags |= SNO_64BIT)
+#define afs_serverHasNo64Bit(s) (((struct sa_conn_vector*)(s)->parent)->srvr->server->flags & SNO_64BIT)
struct server {
union {
/* state bits for volume */
#define VRO 1 /* volume is readonly */
#define VRecheck 2 /* recheck volume info with server */
-#define VBackup 4 /* is this a backup volume? */
-#define VForeign 8 /* this is a non-afs volume */
-#define VResort 16 /* server order was rearranged, sort when able */
-#define VMoreReps 32 /* This volume has more replicas than we are */
- /* keeping track of now -- check with VLDB */
+#define VBackup 4 /* is this a backup volume? */
+#define VForeign 8 /* this is a non-afs volume */
+#define VPartVisible 16 /* Volume's partition is visible on the client */
+#define VHardMount 32 /* we are hard-mount waiting for the vol */
enum repstate { not_busy, end_not_busy = 6, rd_busy, rdwr_busy, offline };
afs_int32 roVol;
afs_int32 backVol;
afs_int32 rwVol; /* For r/o vols, original read/write volume. */
- afs_int32 accessTime; /* last time we used it */
+ afs_int32 setupTime; /* time volume was setup from vldb info */
afs_int32 vtix; /* volume table index */
afs_int32 copyDate; /* copyDate field, for tracking vol releases */
afs_int32 expireTime; /* for per-volume callbacks... */
#define CCore 0x00000010 /* storing a core file, needed since we don't get an open */
#define CDirty 0x00000020 /* file has been modified since first open (... O_RDWR) */
#define CSafeStore 0x00000040 /* close must wait for store to finish (should be in fd) */
-#define CMAPPED 0x00000080 /* Mapped files; primarily used by SunOS 4.0.x */
+#define CMAPPED 0x00000080 /* Mapped files */
#define CNSHARE 0x00000100 /* support O_NSHARE semantics */
#define CLied 0x00000200
#define CTruth 0x00000400
#define CBulkStat 0x00020000 /* loaded by a bulk stat, and not ref'd since */
#define CUnlinkedDel 0x00040000
#define CVFlushed 0x00080000
-#ifdef AFS_LINUX22_ENV
-#define CPageWrite 0x00200000 /* to detect vm deadlock - linux */
-#elif defined(AFS_SGI_ENV)
+#if defined(AFS_SGI_ENV)
#define CWritingUFS 0x00200000 /* to detect vm deadlock - used by sgi */
#elif defined(AFS_DARWIN80_ENV)
#define CEvent 0x00200000 /* to preclude deadlock when sending events */
#endif
#define CCreating 0x00400000 /* avoid needless store after open truncate */
#define CPageHog 0x00800000 /* AIX - dumping large cores is a page hog. */
+#define CCorrupt 0x01000000 /* corrupt dir already reported */
#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 */
#define CMetaDirty 0x20000000 /* vnode meta-data needs to be flushed */
+#define CPartVisible 0x40000000 /* fileserver partition visible on client */
/* vcache vstate bits */
#define VRevokeWait 0x1
/*... to be continued ... */
-#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 */
* 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
+#elif defined(AFS_SUN511_ENV)
+# define vrefCount v->v_count
#else
#define vrefCount v.v_count
#endif /* AFS_XBSD_ENV */
#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++;
+#define VREFCOUNT_SET(v, c) (v)->vrefCount = c
+#define VREFCOUNT_DEC(v) (v)->vrefCount--
+#define VREFCOUNT_INC(v) (v)->vrefCount++
#define d_unhash(d) list_empty(&(d)->d_hash)
#define dget_locked(d) dget(d)
#endif
#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_OPERATIONS_HAS_ALLOC_INODE))
+#elif defined(AFS_NBSD40_ENV)
+struct nbvdata {
+ struct genfs_node gfsn;
+ struct vcache *afsvc;
+};
+#define VTOAFS(v) ((((struct nbvdata *)((v)->v_data)))->afsvc)
+#define AFSTOV(vc) ((vc)->v)
+#elif defined(AFS_XBSD_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_SUN511_ENV) || (defined(AFS_LINUX22_ENV) && !defined(STRUCT_SUPER_OPERATIONS_HAS_ALLOC_INODE))
#define VTOAFS(v) ((struct vcache *)(v)->v_data)
#define AFSTOV(vc) ((vc)->v)
#else
struct afs_vnuniq oldParent;
};
+/* Values for 'mvstat' in struct vcache */
+#define AFS_MVSTAT_FILE (0x0) /* regular file or directory */
+#define AFS_MVSTAT_MTPT (0x1) /* mountpoint */
+#define AFS_MVSTAT_ROOT (0x2) /* volume root dir */
+
+#ifdef AFS_SUN5_ENV
+/*
+ * This is for the multiPage field in struct vcache. Each one of these
+ * represents an outstanding getpage request that is larger than a single page.
+ * Recording these is necessary to prevent afs_GetOnePage from trying to evict
+ * a dcache entry that an earlier afs_GetOnePage call got in the same getpage
+ * request. See osi_VM_MultiPageConflict and afs_getpage.
+ */
+struct multiPage_range {
+ struct afs_q q;
+ offset_t off; /**< offset of getpage request */
+ u_int len; /**< length of getpage request */
+};
+#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) || (defined(AFS_LINUX22_ENV) && !defined(STRUCT_SUPER_OPERATIONS_HAS_ALLOC_INODE))
+#if defined(AFS_XBSD_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_SUN511_ENV) || (defined(AFS_LINUX22_ENV) && !defined(STRUCT_SUPER_OPERATIONS_HAS_ALLOC_INODE))
struct vnode *v;
#else
struct vnode v; /* Has reference count in v.v_count */
krwlock_t rwlock;
struct cred *credp;
#endif
-#ifdef AFS_BOZONLOCK_ENV
- afs_bozoLock_t pvnLock; /* see locks.x */
-#endif
#ifdef AFS_AIX32_ENV
afs_lock_t pvmlock;
vmhandle_t vmh;
struct lock__bsd__ rwlock;
#endif
#ifdef AFS_XBSD_ENV
-# if defined(AFS_NBSD50_ENV)
- struct krwlock rwlock;
-# elif !defined(AFS_DFBSD_ENV)
+#if !defined(AFS_DFBSD_ENV) && !defined(AFS_NBSD_ENV)
struct lock rwlock;
#endif
#endif
- struct VenusFid *mvid; /* Either parent dir (if root) or root (if mt pt) */
+ union {
+ char *silly_name; /* For sillyrenamed regular files, the silly
+ * name the file was renamed to. */
+ struct VenusFid *target_root; /* For mountpoints, the fid of the root dir
+ * in the target volume. */
+ struct VenusFid *parent; /* For root dir vcaches, the fid of the
+ * parent dir. */
+ } mvid;
+
char *linkData; /* Link data if a symlink. */
afs_hyper_t flushDV; /* data version last flushed from text */
afs_hyper_t mapDV; /* data version last flushed from map */
short execsOrWriters; /* The number of execs (if < 0) or writers (if > 0) of
* this file. */
short flockCount; /* count of flock readers, or -1 if writer */
- char mvstat; /* 0->normal, 1->mt pt, 2->root. */
+ char mvstat; /* see the AFS_MVSTAT_* constants */
+
+ char cachingStates; /* Caching policies for this file */
+ afs_uint32 cachingTransitions; /* # of times file has flopped between caching and not */
-#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
+ off_t next_seq_offset; /* Next sequential offset (used by prefetch/readahead) */
+#elif defined(AFS_SUN5_ENV) || defined(AFS_SGI65_ENV)
+ off_t next_seq_blk_offset; /* accounted in blocks for Solaris & IRIX */
#endif
#if defined(AFS_SUN5_ENV)
#if defined(AFS_LINUX26_ENV)
cred_t *cred; /* last writer's cred */
#endif
+#ifdef AFS_LINUX24_ENV
+ struct dentry *target_link; /* dentry we prefer, when we are redirecting
+ * all requests due to duplicate dentry aliases.
+ * See LINUX/osi_vnodeops.c. Note that this is
+ * NOT an actual reference to a dentry, so this
+ * pointer MUST NOT be dereferenced on its own. */
+#endif
afs_int32 vc_error; /* stash write error for this vnode. */
int xlatordv; /* Used by nfs xlator */
afs_ucred_t *uncred;
int asynchrony; /* num kbytes to store behind */
#ifdef AFS_SUN5_ENV
- short multiPage; /* count of multi-page getpages in progress */
+ struct afs_q multiPage; /* list of multiPage_range structs */
+#endif
+ int protocol; /* RX_FILESERVER, RX_OSD, ... defined in afsint.xg */
+#if !defined(UKERNEL)
+ void *vpacRock; /* used to read or write in visible partitions */
+#endif
+ afs_uint32 lastBRLWarnTime; /* last time we warned about byte-range locks */
+#ifdef AFS_LINUX26_ENV
+ spinlock_t pagewriter_lock;
+ struct list_head pagewriters; /* threads that are writing vm pages */
#endif
};
+#ifdef AFS_LINUX26_ENV
+struct pagewriter {
+ struct list_head link;
+ pid_t writer;
+};
+#endif
+
#define DONT_CHECK_MODE_BITS 0
#define CHECK_MODE_BITS 1
#define CMB_ALLOW_EXEC_AS_READ 2 /* For the NFS xlator */
#if defined(AFS_CACHE_VNODE_PATH)
typedef char *afs_ufs_dcache_id_t;
-#elif defined(AFS_SGI61_ENV) || defined(AFS_SUN57_64BIT_ENV)
+#elif defined(AFS_SGI61_ENV) || defined(AFS_SUN5_64BIT_ENV)
/* Using ino64_t here so that user level debugging programs compile
* the size correctly.
*/
avc->f.states |= CCore; /* causes close to be called later */ \
\
/* The cred and vnode holds will be released in afs_FlushActiveVcaches */ \
- AFS_FAST_HOLD(avc); /* So it won't disappear */ \
+ osi_Assert(osi_vnhold(avc) == 0); /* So it won't disappear */ \
CRKEEP(avc, acred); /* Should use a better place for the creds */ \
} \
else { \
#define AFS_ZEROS 64 /* zero buffer */
-/*#define afs_DirtyPages(avc) (((avc)->f.states & CDirty) || osi_VMDirty_p((avc)))*/
#define afs_DirtyPages(avc) ((avc)->f.states & CDirty)
#define afs_InReadDir(avc) (((avc)->f.states & CReadDir) && (avc)->readdir_pid == MyPidxx2Pid(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 int afs_dhashsize; */
-#define DCHash(v, c) ((((v)->Fid.Vnode + (v)->Fid.Volume + (c))) & (afs_dhashsize-1))
- /*Vnode, Chunk -> Hash table index */
-#define DVHash(v) ((((v)->Fid.Vnode + (v)->Fid.Volume )) & (afs_dhashsize-1))
- /*Vnode -> Other hash table index */
-/* don't hash on the cell, our callback-breaking code sometimes fails to compute
- the cell correctly, and only scans one hash bucket */
-#define VCHash(fid) (((fid)->Fid.Volume + (fid)->Fid.Vnode) & (VCSIZE-1))
-/* Hash only on volume to speed up volume callbacks. */
-#define VCHashV(fid) ((fid)->Fid.Volume & (VCSIZE-1))
-
extern struct dcache **afs_indexTable; /*Pointers to in-memory dcache entries */
extern afs_int32 *afs_indexUnique; /*dcache entry Fid.Unique */
extern afs_int32 *afs_dvnextTbl; /*Dcache hash table links */
extern afs_int32 afs_cacheFiles; /*Size of afs_indexTable */
extern afs_int32 afs_cacheBlocks; /*1K blocks in cache */
extern afs_int32 afs_cacheStats; /*Stat entries in cache */
+extern afs_uint32 afs_WaitForCacheDrainCount;
extern struct vcache *afs_vhashT[VCSIZE]; /*Stat cache hash table */
extern struct afs_q afs_vhashTV[VCSIZE]; /* cache hash table on volume */
extern afs_int32 afs_initState; /*Initialization state */
#define DO_VLRU 2
#define IS_SLOCK 4
#define IS_WLOCK 8
-#define FIND_CDEAD 16
+
+/* values for adown value of afs_LoopServers */
+#define AFS_LS_UP 0
+#define AFS_LS_DOWN 1
+#define AFS_LS_ALL 2
/* values for flag param of afs_CheckVolumeNames */
#define AFS_VOLCHECK_EXPIRED 0x1 /* volumes whose callbacks have expired */
#define AFS_FSPORT ((unsigned short) htons(7000))
#define AFS_VLPORT ((unsigned short) htons(7003))
-
-#define afs_read(avc, uio, acred, albn, abpp, nolock) \
- (*(afs_cacheType->vread))(avc, uio, acred, albn, abpp, nolock)
-#define afs_write(avc, uio, aio, acred, nolock) \
- (*(afs_cacheType->vwrite))(avc, uio, aio, acred, nolock)
+#define AFS_RXOSDPORT ((unsigned short) htons(7011))
#define afs_rdwr(avc, uio, rw, io, cred) \
- (((rw) == UIO_WRITE) ? afs_write(avc, uio, io, cred, 0) : afs_read(avc, uio, cred, 0, 0, 0))
+ (((rw) == UIO_WRITE) ? afs_write(avc, uio, io, cred, 0) : afs_read(avc, uio, cred, 0))
#define afs_nlrdwr(avc, uio, rw, io, cred) \
- (((rw) == UIO_WRITE) ? afs_write(avc, uio, io, cred, 1) : afs_read(avc, uio, cred, 0, 0, 1))
+ (((rw) == UIO_WRITE) ? afs_write(avc, uio, io, cred, 1) : afs_read(avc, uio, cred, 1))
/* Cache size truncation uses the following low and high water marks:
- * If the cache is more than 95% full (CM_DCACHECOUNTFREEPCT), the cache
- * truncation daemon is awakened and will free up space until the cache is 85%
- * (CM_DCACHESPACEFREEPCT - CM_DCACHEEXTRAPCT) full.
+ * If the cache is more than 90% full by space (CM_DCACHESPACEFREEPCT) or
+ * 95% full by # of chunks (CM_DCACHECOUNTFREEPCT), the cache truncation
+ * daemon is awakened and will start freeing space. The cache truncation
+ * daemon will continue to free space until the cache is at most 85% full
+ * by space (CM_DCACHESPACEFREEPCT - CM_DCACHEEXTRAPCT). The cache truncation
+ * daemon will also try to free space until the cache is at most 90% full by
+ * chunks (CM_DCACHECOUNTFREEPCT - CM_DCACHEEXTRAPCT), but the 85% space limit
+ * is the only limit that we must hit.
* afs_UFSWrite and afs_GetDCache (when it needs to fetch data) will wait on
* afs_WaitForCacheDrain if the cache is 98% (CM_WAITFORDRAINPCT) full.
* afs_GetDownD wakes those processes once the cache is 95% full
#define afs_CacheIsTooFull() \
(afs_blocksUsed - afs_blocksDiscarded > \
- PERCENT(CM_DCACHECOUNTFREEPCT, afs_cacheBlocks) || \
+ PERCENT(CM_DCACHESPACEFREEPCT, afs_cacheBlocks) || \
afs_freeDCCount - afs_discardDCCount < \
PERCENT(100 - CM_DCACHECOUNTFREEPCT, afs_cacheFiles))
};
extern int afs_fakestat_enable;
-
-#ifdef AFS_MAXVCOUNT_ENV
+extern int afs_rmtsys_enable;
extern int afsd_dynamic_vcaches;
-#else
-#define afsd_dynamic_vcaches 0
-#endif
/*
* Wrappers for access to credentials structure members
*/
#if defined(AFS_NBSD40_ENV)
/* in osi_machdep.h as expected */
+#elif defined (AFS_DARWIN110_ENV)
+#define afs_cr_uid(cred) kauth_cred_getuid((kauth_cred_t)(cred))
+#define afs_cr_gid(cred) kauth_cred_getgid((kauth_cred_t)(cred))
#elif !(defined(AFS_LINUX26_ENV) && defined(STRUCT_TASK_STRUCT_HAS_CRED))
#define afs_cr_uid(cred) ((cred)->cr_uid)
#define afs_cr_gid(cred) ((cred)->cr_gid)
+#if !defined(AFS_OBSD_ENV)
#define afs_cr_ruid(cred) ((cred)->cr_ruid)
#define afs_cr_rgid(cred) ((cred)->cr_rgid)
+#endif
+#if !defined(AFS_DARWIN110_ENV)
static_inline void
afs_set_cr_uid(afs_ucred_t *cred, uid_t uid) {
cred->cr_uid = uid;
afs_set_cr_gid(afs_ucred_t *cred, gid_t gid) {
cred->cr_gid = gid;
}
+#if !defined(AFS_OBSD_ENV)
static_inline void
afs_set_cr_ruid(afs_ucred_t *cred, uid_t uid) {
cred->cr_ruid = uid;
afs_set_cr_rgid(afs_ucred_t *cred, gid_t gid) {
cred->cr_rgid = gid;
}
+#endif /* ! AFS_OBSD_ENV */
+#endif /* ! AFS_DARWIN110_ENV */
#endif
+
+#ifdef AFS_SUN5_ENV
+
+/** The 32 bit OS expects the members of this structure to be 32 bit
+ * quantities and the 64 bit OS expects them as 64 bit quanties. Hence
+ * to accomodate both, *long* is used instead of afs_int32
+ */
+
+struct afssysa {
+ long syscall;
+ long parm1;
+ long parm2;
+ long parm3;
+ long parm4;
+ long parm5;
+ long parm6;
+};
+extern int Afs_syscall(struct afssysa *uap, rval_t *rvp);
+#endif /* AFS_SUN5_ENV */
+
+/*
+ * Various definitions for osi_sleep and its event hash table
+ * DFBSD has no osi_sleep, and HPUX has its own hack for this stuff
+ */
+#define AFS_EVHASHSIZE 128 /* size of afs_evhasht, must be power of 2 */
+
+typedef struct afs_event {
+ struct afs_event *next; /* next in hash chain */
+ char *event; /* lwp event: an address */
+ int refcount; /* Is it in use? */
+ int seq; /* Sequence number: this is incremented
+ * by wakeup calls; wait will not return until
+ * it changes */
+#if defined(AFS_AIX_ENV)
+ tid_t cond;
+#elif defined(AFS_DARWIN_ENV)
+# ifdef AFS_DARWIN80_ENV
+ lck_mtx_t *lck;
+ thread_t owner;
+# endif
+ /* no cond member */
+#elif defined(AFS_FBSD_ENV) || defined(AFS_OBSD_ENV)
+ int cond; /* "all this gluck should probably be replaced by CVs" */
+#elif defined(AFS_LINUX24_ENV)
+ wait_queue_head_t cond;
+#elif defined(AFS_NBSD_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV)
+ kcondvar_t cond; /* Currently associated condition variable */
+#endif
+} afs_event_t;
+
+extern afs_event_t *afs_evhasht[AFS_EVHASHSIZE]; /* Hash table for events */
+
#endif /* _AFS_H_ */
git://git.openafs.org / openafs.git / blobdiff