2 * Copyright 2000, International Business Machines Corporation and others.
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
10 #ifndef __CM_SCACHE_H_ENV__
11 #define __CM_SCACHE_H_ENV__ 1
14 #include "largeint95.h"
17 #define MOUNTPOINTLEN 1024
19 typedef struct cm_fid {
27 typedef struct cm_accessCache {
28 osi_queue_t q; /* queue header */
29 struct cm_user *userp; /* user having access rights */
30 unsigned long rights; /* rights */
34 /* Key used for byte range locking. Each unique key identifies a
35 unique client per cm_scache_t for the purpose of locking. */
36 typedef afs_uint64 cm_key_t;
38 typedef struct cm_range {
45 typedef struct cm_scache cm_scache_t;
47 typedef struct cm_file_lock {
48 osi_queue_t q; /* list of all locks [protected by
50 osi_queue_t fileq; /* per-file list of locks [protected
53 cm_user_t *userp; /* The user to which this lock belongs
54 to [immutable; held] */
55 cm_scache_t *scp; /* The scache to which this lock
56 applies to [immutable; held] */
61 cm_range_t range; /* Range for the lock [immutable] */
62 cm_key_t key; /* Key for the lock [immutable] */
63 unsigned char lockType; /* LockRead or LockWrite [immutable] */
64 unsigned char flags; /* combination of CM_FILELOCK_FLAG__*
65 * [protected by cm_scacheLock] */
66 time_t lastUpdate; /* time of last assertion with
67 * server. [protected by
71 #define CM_FILELOCK_FLAG_DELETED 0x01
72 #define CM_FILELOCK_FLAG_LOST 0x02
74 /* the following are mutually exclusive */
75 #define CM_FILELOCK_FLAG_WAITLOCK 0x04
76 #define CM_FILELOCK_FLAG_WAITUNLOCK 0x0C
78 /* the following is used to indicate that there are no server side
79 locks associated with this lock. This is true for locks obtained
80 against files in RO volumes as well as files residing on servers
81 that disable client side byte range locking. */
82 #define CM_FILELOCK_FLAG_CLIENTONLY 0x10
84 #define CM_FLSHARE_OFFSET_HIGH 0x01000000
85 #define CM_FLSHARE_OFFSET_LOW 0x00000000
86 #define CM_FLSHARE_LENGTH_HIGH 0x00000000
87 #define CM_FLSHARE_LENGTH_LOW 0x00000001
89 typedef struct cm_prefetch { /* last region scanned for prefetching */
90 osi_hyper_t base; /* start of region */
91 osi_hyper_t end; /* first char past region */
94 #define CM_SCACHE_MAGIC ('S' | 'C'<<8 | 'A'<<16 | 'C'<<24)
96 typedef struct cm_scache {
97 osi_queue_t q; /* lru queue; cm_scacheLock */
99 struct cm_scache *nextp; /* next in hash; cm_scacheLock */
101 afs_uint32 flags; /* flags; locked by mx */
103 /* synchronization stuff */
104 osi_mutex_t mx; /* mutex for this structure */
105 osi_rwlock_t bufCreateLock; /* read-locked during buffer creation;
106 * write-locked to prevent buffers from
107 * being created during a truncate op, etc.
109 afs_uint32 refCount; /* reference count; cm_scacheLock */
110 osi_queueData_t *bufReadsp; /* queue of buffers being read */
111 osi_queueData_t *bufWritesp; /* queue of buffers being written */
113 /* parent info for ACLs */
114 afs_uint32 parentVnode; /* parent vnode for ACL callbacks */
115 afs_uint32 parentUnique; /* for ACL callbacks */
117 /* local modification stat */
118 afs_uint32 mask; /* for clientModTime, length and
122 afs_uint32 fileType; /* file type */
123 time_t clientModTime; /* mtime */
124 time_t serverModTime; /* at server, for concurrent call
126 osi_hyper_t length; /* file length */
127 cm_prefetch_t prefetch; /* prefetch info structure */
128 afs_uint32 unixModeBits; /* unix protection mode bits */
129 afs_uint32 linkCount; /* link count */
130 afs_uint32 dataVersion; /* data version */
131 afs_uint32 owner; /* file owner */
132 afs_uint32 group; /* file owning group */
134 /* pseudo file status */
135 osi_hyper_t serverLength; /* length known to server */
137 /* aux file status */
138 osi_hyper_t truncPos; /* file size to truncate to before
141 /* symlink and mount point info */
142 char mountPointStringp[MOUNTPOINTLEN]; /* the string stored in a mount point;
143 * first char is type, then vol name.
144 * If this is a normal symlink, we store
145 * the link contents here.
147 cm_fid_t mountRootFid; /* mounted on root */
148 time_t mountRootGen; /* time to update mountRootFidp? */
149 cm_fid_t dotdotFid; /* parent of volume root */
152 struct cm_server *cbServerp; /* server granting callback */
153 time_t cbExpires; /* time callback expires */
156 long anyAccess; /* anonymous user's access */
157 struct cm_aclent *randomACLp; /* access cache entries */
160 afs_int32 serverLock; /* current lock we have acquired on
161 * this file. One of (-1), LockRead
162 * or LockWrite. [protected by
165 unsigned long lastRefreshCycle; /* protected with cm_scacheLock
166 * for all scaches. */
167 osi_queue_t *fileLocksH; /* queue of locks (head) */
168 osi_queue_t *fileLocksT; /* queue of locks (tail) */
169 afs_uint32 sharedLocks; /* number of shared locks on
171 afs_uint32 exclusiveLocks; /* number of exclusive locks on
176 struct cm_volume *volp; /* volume info; held reference */
178 /* bulk stat progress */
179 osi_hyper_t bulkStatProgress; /* track bulk stats of large dirs */
182 afs_uint16 openReads; /* open for reading */
183 afs_uint16 openWrites; /* open for writing */
184 afs_uint16 openShares; /* open for read excl */
185 afs_uint16 openExcls; /* open for exclusives */
188 afs_uint32 waitCount; /* number of threads waiting */
189 afs_uint32 waitRequests; /* num of thread wait requests */
192 /* mask field - tell what has been modified */
193 #define CM_SCACHEMASK_CLIENTMODTIME 1 /* client mod time */
194 #define CM_SCACHEMASK_LENGTH 2 /* length */
195 #define CM_SCACHEMASK_TRUNCPOS 4 /* truncation position */
197 /* fileType values */
198 #define CM_SCACHETYPE_FILE 1 /* a file */
199 #define CM_SCACHETYPE_DIRECTORY 2 /* a dir */
200 #define CM_SCACHETYPE_SYMLINK 3 /* a symbolic link */
201 #define CM_SCACHETYPE_MOUNTPOINT 4 /* a mount point */
202 #define CM_SCACHETYPE_DFSLINK 5 /* a Microsoft Dfs link */
203 #define CM_SCACHETYPE_INVALID 99 /* an invalid link */
206 #define CM_SCACHEFLAG_STATD 0x01 /* status info is valid */
207 #define CM_SCACHEFLAG_DELETED 0x02 /* file has been deleted */
208 #define CM_SCACHEFLAG_CALLBACK 0x04 /* have a valid callback */
209 #define CM_SCACHEFLAG_STORING 0x08 /* status being stored back */
210 #define CM_SCACHEFLAG_FETCHING 0x10 /* status being fetched */
211 #define CM_SCACHEFLAG_SIZESTORING 0x20 /* status being stored that
212 * changes the data; typically,
213 * this is a truncate op. */
214 #define CM_SCACHEFLAG_INHASH 0x40 /* in the hash table */
215 #define CM_SCACHEFLAG_BULKSTATTING 0x80 /* doing a bulk stat */
216 #define CM_SCACHEFLAG_WAITING 0x200 /* waiting for fetch/store
218 #define CM_SCACHEFLAG_PURERO 0x400 /* read-only (not even backup);
219 * for mount point eval */
220 #define CM_SCACHEFLAG_RO 0x800 /* read-only
221 * (can't do write ops) */
222 #define CM_SCACHEFLAG_GETCALLBACK 0x1000 /* we're getting a callback */
223 #define CM_SCACHEFLAG_DATASTORING 0x2000 /* data being stored */
224 #define CM_SCACHEFLAG_PREFETCHING 0x4000 /* somebody is prefetching */
225 #define CM_SCACHEFLAG_OVERQUOTA 0x8000 /* over quota */
226 #define CM_SCACHEFLAG_OUTOFSPACE 0x10000 /* out of space */
227 #define CM_SCACHEFLAG_ASYNCSTORING 0x20000 /* scheduled to store back */
228 #define CM_SCACHEFLAG_LOCKING 0x40000 /* setting/clearing file lock */
229 #define CM_SCACHEFLAG_WATCHED 0x80000 /* directory being watched */
230 #define CM_SCACHEFLAG_WATCHEDSUBTREE 0x100000 /* dir subtree being watched */
231 #define CM_SCACHEFLAG_ANYWATCH \
232 (CM_SCACHEFLAG_WATCHED | CM_SCACHEFLAG_WATCHEDSUBTREE)
234 /* sync flags for calls to the server. The CM_SCACHEFLAG_FETCHING,
235 * CM_SCACHEFLAG_STORING and CM_SCACHEFLAG_SIZESTORING flags correspond to the
236 * below, except for FETCHDATA and STOREDATA, which correspond to non-null
237 * buffers in bufReadsp and bufWritesp.
238 * These flags correspond to individual RPCs that we may be making, and at most
239 * one can be set in any one call to SyncOp.
241 #define CM_SCACHESYNC_FETCHSTATUS 0x01 /* fetching status info */
242 #define CM_SCACHESYNC_STORESTATUS 0x02 /* storing status info */
243 #define CM_SCACHESYNC_FETCHDATA 0x04 /* fetch data */
244 #define CM_SCACHESYNC_STOREDATA 0x08 /* store data */
245 #define CM_SCACHESYNC_STORESIZE 0x10 /* store new file size */
246 #define CM_SCACHESYNC_GETCALLBACK 0x20 /* fetching a callback */
247 #define CM_SCACHESYNC_STOREDATA_EXCL 0x40 /* store data */
248 #define CM_SCACHESYNC_ASYNCSTORE 0x80 /* schedule data store */
249 #define CM_SCACHESYNC_LOCK 0x100 /* set/clear file lock */
251 /* sync flags for calls within the client; there are no corresponding flags
252 * in the scache entry, because we hold the scache entry locked during the
255 #define CM_SCACHESYNC_GETSTATUS 0x1000 /* read the status */
256 #define CM_SCACHESYNC_SETSTATUS 0x2000 /* e.g. utimes */
257 #define CM_SCACHESYNC_READ 0x4000 /* read data from a chunk */
258 #define CM_SCACHESYNC_WRITE 0x8000 /* write data to a chunk */
259 #define CM_SCACHESYNC_SETSIZE 0x10000 /* shrink the size of a file,
261 #define CM_SCACHESYNC_NEEDCALLBACK 0x20000 /* need a callback on the file */
262 #define CM_SCACHESYNC_CHECKRIGHTS 0x40000 /* check that user has desired
264 #define CM_SCACHESYNC_BUFLOCKED 0x80000 /* the buffer is locked */
265 #define CM_SCACHESYNC_NOWAIT 0x100000/* don't wait for the state,
268 /* flags for cm_MergeStatus */
269 #define CM_MERGEFLAG_FORCE 1 /* check mtime before merging;
270 * used to see if we're merging
274 /* hash define. Must not include the cell, since the callback revocation code
275 * doesn't necessarily know the cell in the case of a multihomed server
276 * contacting us from a mystery address.
278 #define CM_SCACHE_HASH(fidp) (((unsigned long) \
282 % cm_data.hashTableSize)
287 extern void cm_InitSCache(int, long);
289 extern long cm_GetSCache(cm_fid_t *, cm_scache_t **, struct cm_user *,
292 extern void cm_PutSCache(cm_scache_t *);
294 extern cm_scache_t *cm_GetNewSCache(void);
296 extern int cm_FidCmp(cm_fid_t *, cm_fid_t *);
298 extern long cm_SyncOp(cm_scache_t *, struct cm_buf *, struct cm_user *,
299 struct cm_req *, long, long);
301 extern void cm_SyncOpDone(cm_scache_t *, struct cm_buf *, long);
303 extern void cm_MergeStatus(cm_scache_t *, struct AFSFetchStatus *, struct AFSVolSync *,
304 struct cm_user *, int flags);
306 extern void cm_AFSFidFromFid(struct AFSFid *, cm_fid_t *);
308 extern void cm_HoldSCacheNoLock(cm_scache_t *);
310 extern void cm_HoldSCache(cm_scache_t *);
312 extern void cm_ReleaseSCacheNoLock(cm_scache_t *);
314 extern void cm_ReleaseSCache(cm_scache_t *);
316 extern cm_scache_t *cm_FindSCache(cm_fid_t *fidp);
318 extern osi_rwlock_t cm_scacheLock;
320 extern osi_queue_t *cm_allFileLocks;
322 extern osi_queue_t *cm_freeFileLocks;
324 extern unsigned long cm_lockRefreshCycle;
326 extern void cm_DiscardSCache(cm_scache_t *scp);
328 extern int cm_FindFileType(cm_fid_t *fidp);
330 extern long cm_ValidateSCache(void);
332 extern long cm_ShutdownSCache(void);
334 #endif /* __CM_SCACHE_H_ENV__ */