Windows: Add cm_req_t parameter to cm_MergeStatus
[openafs.git] / src / WINNT / afsd / cm_scache.h
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 #ifndef __CM_SCACHE_H_ENV__
11 #define __CM_SCACHE_H_ENV__ 1
12
13 #define MOUNTPOINTLEN   1024    /* max path length for symlink; same as AFSPATHMAX */
14
15 typedef struct cm_fid {
16     afs_uint32 cell;
17     afs_uint32 volume;
18     afs_uint32 vnode;
19     afs_uint32 unique;
20     afs_uint32 hash;
21 } cm_fid_t;
22
23
24 /* Key used for byte range locking.  Each unique key identifies a
25    unique client per cm_scache_t for the purpose of locking. */
26 typedef struct cm_key {
27     afs_offs_t process_id;      /* process IDs can be 64bit on 64bit environments */
28     afs_uint16 session_id;
29     afs_uint16 file_id;
30 } cm_key_t;
31
32 typedef struct cm_range {
33     afs_int64 offset;
34     afs_int64 length;
35 } cm_range_t;
36
37 /* forward dcls */
38 struct cm_scache;
39 typedef struct cm_scache cm_scache_t;
40
41 typedef struct cm_file_lock {
42     osi_queue_t q;              /* list of all locks [protected by
43                                    cm_scacheLock] */
44     osi_queue_t fileq;          /* per-file list of locks [protected
45                                    by scp->rw]*/
46     
47     cm_user_t *userp;           /* The user to which this lock belongs
48                                    to [immutable; held] */
49     cm_scache_t *scp;           /* The scache to which this lock
50                                    applies to [immutable; held] */
51 #ifdef DEBUG
52     cm_fid_t   fid;
53 #endif
54
55     cm_range_t range;           /* Range for the lock [immutable] */
56     cm_key_t key;               /* Key for the lock [immutable] */
57     unsigned char lockType;     /* LockRead or LockWrite [immutable] */
58     unsigned char flags;        /* combination of CM_FILELOCK_FLAG__*
59                                  * [protected by cm_scacheLock] */
60     time_t lastUpdate;          /* time of last assertion with
61                                  * server. [protected by
62                                  * cm_scacheLock] */
63 } cm_file_lock_t;
64
65 #define CM_FILELOCK_FLAG_DELETED         0x01
66 #define CM_FILELOCK_FLAG_LOST            0x02
67
68 /* the following are mutually exclusive */
69 #define CM_FILELOCK_FLAG_WAITLOCK        0x04
70 #define CM_FILELOCK_FLAG_WAITUNLOCK      0x0C
71
72 /* the following is used to indicate that there are no server side
73    locks associated with this lock.  This is true for locks obtained
74    against files in RO volumes as well as files residing on servers
75    that disable client side byte range locking. */
76 #define CM_FILELOCK_FLAG_CLIENTONLY      0x10
77
78 #define CM_FLSHARE_OFFSET_HIGH           0x01000000
79 #define CM_FLSHARE_OFFSET_LOW            0x00000000
80 #define CM_FLSHARE_LENGTH_HIGH           0x00000000
81 #define CM_FLSHARE_LENGTH_LOW            0x00000001
82
83 typedef struct cm_prefetch {            /* last region scanned for prefetching */
84         osi_hyper_t base;               /* start of region */
85         osi_hyper_t end;                /* first char past region */
86 } cm_prefetch_t;
87
88 #define CM_SCACHE_MAGIC ('S' | 'C'<<8 | 'A'<<16 | 'C'<<24)
89
90 typedef struct cm_scache {
91     osi_queue_t q;                      /* lru queue; cm_scacheLock */
92     afs_uint32      magic;
93     struct cm_scache *nextp;            /* next in hash; cm_scacheLock */
94     struct cm_scache *allNextp;         /* next in all scache list; cm_scacheLock */
95     cm_fid_t fid;
96     afs_uint32 flags;                   /* flags; locked by rw */
97
98     /* synchronization stuff */
99     osi_rwlock_t rw;                    /* rwlock for this structure */
100     osi_rwlock_t bufCreateLock;         /* read-locked during buffer creation;
101                                          * write-locked to prevent buffers from
102                                          * being created during a truncate op, etc.
103                                          */
104     afs_int32 refCount;                 /* reference count; cm_scacheLock */
105     osi_queueData_t *bufReadsp;         /* queue of buffers being read */
106     osi_queueData_t *bufWritesp;        /* queue of buffers being written */
107
108     /* parent info for ACLs */
109     afs_uint32 parentVnode;             /* parent vnode for ACL callbacks */
110     afs_uint32 parentUnique;            /* for ACL callbacks */
111
112     /* local modification stat */
113     afs_uint32 mask;                    /* for clientModTime, length and
114                                          * truncPos */
115
116     /* file status */
117     afs_uint32 fileType;                /* file type */
118     time_t clientModTime;               /* mtime */
119     time_t serverModTime;               /* at server, for concurrent call
120                                          * comparisons */
121     osi_hyper_t length;                 /* file length */
122     cm_prefetch_t prefetch;             /* prefetch info structure */
123     afs_uint32 unixModeBits;            /* unix protection mode bits */
124     afs_uint32 linkCount;               /* link count */
125     afs_uint64 dataVersion;             /* data version */
126     afs_uint64 bufDataVersionLow;       /* range of valid cm_buf_t dataVersions */
127     afs_uint32 owner;                   /* file owner */
128     afs_uint32 group;                   /* file owning group */
129     cm_user_t *creator;                 /* user, if new file */
130
131     /* pseudo file status */
132     osi_hyper_t serverLength;           /* length known to server */
133
134     /* aux file status */
135     osi_hyper_t truncPos;               /* file size to truncate to before
136                                          * storing data */
137
138     /* symlink and mount point info */
139     char mountPointStringp[MOUNTPOINTLEN];      /* the string stored in a mount point;
140                                                  * first char is type, then vol name.
141                                          * If this is a normal symlink, we store
142                                          * the link contents here.
143                                          */
144     cm_fid_t  mountRootFid;             /* mounted on root */
145     time_t    mountRootGen;             /* time to update mountRootFidp? */
146     cm_fid_t  dotdotFid;                /* parent of volume root */
147
148     /* callback info */
149     struct cm_server *cbServerp;        /* server granting callback */
150     time_t cbExpires;                   /* time callback expires */
151
152     /* access cache */
153     long anyAccess;                     /* anonymous user's access */
154     struct cm_aclent *randomACLp;       /* access cache entries */
155
156     /* file locks */
157     afs_int32    serverLock;    /* current lock we have acquired on
158                                  * this file.  One of (-1), LockRead
159                                  * or LockWrite. [protected by
160                                  * scp->rw].  In the future, this
161                                  * should be replaced by a queue of
162                                  * cm_server_lock_t objects which keep
163                                  * track of lock type, the user for
164                                  * whom the lock was obtained, the
165                                  * dataVersion at the time the lock
166                                  * was asserted last, lastRefreshCycle
167                                  * and lateUpdateTime.
168                                  */
169     unsigned long lastRefreshCycle; /* protected with cm_scacheLock
170                                      * for all scaches. */
171     afs_uint64  lockDataVersion; /* dataVersion of the scp at the time
172                                    the server lock for the scp was
173                                    asserted for this lock the last
174                                    time. */
175     osi_queue_t *fileLocksH;    /* queue of locks (head) */
176     osi_queue_t *fileLocksT;    /* queue of locks (tail) */
177
178     afs_uint32   sharedLocks;   /* number of shared locks on
179                                  * ::fileLocks.  This count does not
180                                  * include locks which have
181                                  * CM_FILELOCK_FLAG_CLIENTONLY set. */
182
183     afs_uint32   exclusiveLocks; /* number of exclusive locks on
184                                   * ::fileLocks.  This count does not
185                                   * include locks which have
186                                   * CM_FILELOCK_FLAG_CLIENTONLY set.
187                                   */
188
189     afs_uint32   clientLocks;   /* number of locks on ::fileLocks that
190                                    have CM_FILELOCK_FLAG_CLIENTONLY
191                                    set. */
192         
193     /* bulk stat progress */
194     osi_hyper_t bulkStatProgress;       /* track bulk stats of large dirs */
195
196 #ifdef USE_BPLUS
197     /* directory B+ tree */             /* only allocated if is directory */
198     osi_rwlock_t dirlock;               /* controls access to dirBplus */
199     afs_uint64   dirDataVersion;        /* data version represented by dirBplus */
200     struct tree *dirBplus;              /* dirBplus */
201 #endif
202
203     /* open state */
204     afs_uint16 openReads;               /* open for reading */
205     afs_uint16 openWrites;              /* open for writing */
206     afs_uint16 openShares;              /* open for read excl */
207     afs_uint16 openExcls;               /* open for exclusives */
208
209     /* syncop state */
210     afs_uint32 waitCount;           /* number of threads waiting */
211     afs_uint32 waitRequests;        /* num of thread wait requests */
212     osi_queue_t * waitQueueH;       /* Queue of waiting threads.
213                                        Holds queue of
214                                        cm_scache_waiter_t
215                                        objects. Protected by
216                                        cm_cacheLock. */
217     osi_queue_t * waitQueueT;       /* locked by cm_scacheLock */
218 } cm_scache_t;
219
220 /* dataVersion */
221 #define CM_SCACHE_VERSION_BAD           0xFFFFFFFFFFFFFFFF
222
223 /* mask field - tell what has been modified */
224 #define CM_SCACHEMASK_CLIENTMODTIME     1       /* client mod time */
225 #define CM_SCACHEMASK_LENGTH            2       /* length */
226 #define CM_SCACHEMASK_TRUNCPOS          4       /* truncation position */
227
228 /* fileType values */
229 #define CM_SCACHETYPE_UNKNOWN           0       /* unknown */
230 #define CM_SCACHETYPE_FILE              1       /* a file */
231 #define CM_SCACHETYPE_DIRECTORY         2       /* a dir */
232 #define CM_SCACHETYPE_SYMLINK           3       /* a symbolic link */
233 #define CM_SCACHETYPE_MOUNTPOINT        4       /* a mount point */
234 #define CM_SCACHETYPE_DFSLINK           5       /* a Microsoft Dfs link */
235 #define CM_SCACHETYPE_INVALID           99      /* an invalid link */
236
237 /* flag bits */
238 #define CM_SCACHEFLAG_STATD             0x01    /* status info is valid */
239 #define CM_SCACHEFLAG_DELETED           0x02    /* file has been deleted */
240 #define CM_SCACHEFLAG_CALLBACK          0x04    /* have a valid callback */
241 #define CM_SCACHEFLAG_STORING           0x08    /* status being stored back */
242 #define CM_SCACHEFLAG_FETCHING          0x10    /* status being fetched */
243 #define CM_SCACHEFLAG_SIZESTORING       0x20    /* status being stored that
244                                                  * changes the data; typically,
245                                                  * this is a truncate op. */
246 #define CM_SCACHEFLAG_INHASH            0x40    /* in the hash table */
247 #define CM_SCACHEFLAG_BULKSTATTING      0x80    /* doing a bulk stat */
248 #define CM_SCACHEFLAG_WAITING           0x200   /* waiting for fetch/store
249                                                  * state to change */
250 #define CM_SCACHEFLAG_PURERO            0x400   /* read-only (not even backup);
251                                                  * for mount point eval */
252 #define CM_SCACHEFLAG_RO                0x800   /* read-only
253                                                  * (can't do write ops) */
254 #define CM_SCACHEFLAG_GETCALLBACK       0x1000  /* we're getting a callback */
255 #define CM_SCACHEFLAG_DATASTORING       0x2000  /* data being stored */
256 #define CM_SCACHEFLAG_PREFETCHING       0x4000  /* somebody is prefetching */
257 #define CM_SCACHEFLAG_OVERQUOTA         0x8000  /* over quota */
258 #define CM_SCACHEFLAG_OUTOFSPACE        0x10000 /* out of space */
259 #define CM_SCACHEFLAG_ASYNCSTORING      0x20000 /* scheduled to store back */
260 #define CM_SCACHEFLAG_LOCKING           0x40000 /* setting/clearing file lock */
261 #define CM_SCACHEFLAG_WATCHED           0x80000 /* directory being watched */
262 #define CM_SCACHEFLAG_WATCHEDSUBTREE    0x100000 /* dir subtree being watched */
263 #define CM_SCACHEFLAG_ANYWATCH \
264                         (CM_SCACHEFLAG_WATCHED | CM_SCACHEFLAG_WATCHEDSUBTREE)
265
266 #define CM_SCACHEFLAG_EACCESS           0x200000 /* Bulk Stat returned EACCES */
267 #define CM_SCACHEFLAG_SMB_FID           0x400000
268 #define CM_SCACHEFLAG_LOCAL             0x800000 /* Locally modified */
269
270 /* sync flags for calls to the server.  The CM_SCACHEFLAG_FETCHING,
271  * CM_SCACHEFLAG_STORING and CM_SCACHEFLAG_SIZESTORING flags correspond to the
272  * below, except for FETCHDATA and STOREDATA, which correspond to non-null
273  * buffers in bufReadsp and bufWritesp.
274  * These flags correspond to individual RPCs that we may be making, and at most
275  * one can be set in any one call to SyncOp.
276  */
277 #define CM_SCACHESYNC_FETCHSTATUS           0x01        /* fetching status info */
278 #define CM_SCACHESYNC_STORESTATUS           0x02        /* storing status info */
279 #define CM_SCACHESYNC_FETCHDATA             0x04        /* fetch data */
280 #define CM_SCACHESYNC_STOREDATA             0x08        /* store data */
281 #define CM_SCACHESYNC_STORESIZE         0x10    /* store new file size */
282 #define CM_SCACHESYNC_GETCALLBACK       0x20    /* fetching a callback */
283 #define CM_SCACHESYNC_STOREDATA_EXCL    0x40    /* store data */
284 #define CM_SCACHESYNC_ASYNCSTORE        0x80    /* schedule data store */
285 #define CM_SCACHESYNC_LOCK              0x100   /* set/clear file lock */
286
287 /* sync flags for calls within the client; there are no corresponding flags
288  * in the scache entry, because we hold the scache entry locked during the
289  * operations below.
290  */
291 #define CM_SCACHESYNC_GETSTATUS         0x1000  /* read the status */
292 #define CM_SCACHESYNC_SETSTATUS         0x2000  /* e.g. utimes */
293 #define CM_SCACHESYNC_READ              0x4000  /* read data from a chunk */
294 #define CM_SCACHESYNC_WRITE             0x8000  /* write data to a chunk */
295 #define CM_SCACHESYNC_SETSIZE           0x10000 /* shrink the size of a file,
296                                                  * e.g. truncate */
297 #define CM_SCACHESYNC_NEEDCALLBACK      0x20000 /* need a callback on the file */
298 #define CM_SCACHESYNC_CHECKRIGHTS       0x40000 /* check that user has desired
299                                                  * access rights */
300 #define CM_SCACHESYNC_BUFLOCKED         0x80000 /* the buffer is locked */
301 #define CM_SCACHESYNC_NOWAIT            0x100000/* don't wait for the state,
302                                                  * just fail */
303 #define CM_SCACHESYNC_FORCECB           0x200000/* when calling cm_GetCallback()
304                                                  * set the force flag */
305
306 /* flags for cm_RecycleSCache   */
307 #define CM_SCACHE_RECYCLEFLAG_DESTROY_BUFFERS   0x1
308
309 /* flags for cm_MergeStatus */
310 #define CM_MERGEFLAG_FORCE              1       /* check mtime before merging;
311                                                  * used to see if we're merging
312                                                  * in old info.
313                                                  */
314 #define CM_MERGEFLAG_STOREDATA          2       /* Merge due to storedata op */
315 #define CM_MERGEFLAG_DIROP              4       /* Merge due to directory op */ 
316
317 /* hash define.  Must not include the cell, since the callback revocation code
318  * doesn't necessarily know the cell in the case of a multihomed server
319  * contacting us from a mystery address.
320  */
321 #define CM_SCACHE_HASH(fidp)    (((unsigned long)       \
322                                    ((fidp)->volume +    \
323                                     (fidp)->vnode +     \
324                                     (fidp)->unique))    \
325                                         % cm_data.scacheHashTableSize)
326
327 #include "cm_conn.h"
328 #include "cm_buf.h"
329
330 typedef struct cm_scache_waiter {
331     osi_queue_t q;
332     afs_int32   threadId;
333
334     cm_scache_t *scp;
335     afs_int32   flags;
336     cm_buf_t    *bufp;
337 } cm_scache_waiter_t;
338
339 extern void cm_InitSCache(int, long);
340
341 #ifdef DEBUG_REFCOUNT
342 extern long cm_GetSCacheDbg(cm_fid_t *, cm_scache_t **, struct cm_user *,
343         struct cm_req *, char *, long);
344
345 #define cm_GetSCache(a,b,c,d)  cm_GetSCacheDbg(a,b,c,d,__FILE__,__LINE__)
346 #else
347 extern long cm_GetSCache(cm_fid_t *, cm_scache_t **, struct cm_user *,
348         struct cm_req *);
349 #endif
350
351 extern cm_scache_t *cm_GetNewSCache(void);
352
353 extern __inline int cm_FidCmp(cm_fid_t *, cm_fid_t *);
354
355 extern void cm_SetFid(cm_fid_t *, afs_uint32 cell, afs_uint32 volume, afs_uint32 vnode, afs_uint32 unique);
356
357 extern long cm_SyncOp(cm_scache_t *, struct cm_buf *, struct cm_user *,
358         struct cm_req *, afs_uint32, afs_uint32);
359
360 extern void cm_SyncOpDone(cm_scache_t *, struct cm_buf *, afs_uint32);
361
362 extern void cm_MergeStatus(cm_scache_t * dscp, cm_scache_t * scp, 
363                            struct AFSFetchStatus * statusp, 
364                            struct AFSVolSync * volsyncp,
365                            struct cm_user *userp, 
366                            cm_req_t *reqp,
367                            afs_uint32 flags);
368
369 extern void cm_AFSFidFromFid(struct AFSFid *, cm_fid_t *);
370
371 #ifdef DEBUG_REFCOUNT
372 extern void cm_HoldSCacheNoLockDbg(cm_scache_t *, char *, long);
373
374 extern void cm_HoldSCacheDbg(cm_scache_t *, char *, long);
375
376 extern void cm_ReleaseSCacheNoLockDbg(cm_scache_t *, char *, long);
377
378 extern void cm_ReleaseSCacheDbg(cm_scache_t *, char *, long);
379
380 #define cm_HoldSCacheNoLock(scp)    cm_HoldSCacheNoLockDbg(scp, __FILE__, __LINE__)
381 #define cm_HoldSCache(scp)          cm_HoldSCacheDbg(scp, __FILE__, __LINE__)
382 #define cm_ReleaseSCacheNoLock(scp) cm_ReleaseSCacheNoLockDbg(scp, __FILE__, __LINE__)
383 #define cm_ReleaseSCache(scp)       cm_ReleaseSCacheDbg(scp, __FILE__, __LINE__)
384 #else
385 extern void cm_HoldSCacheNoLock(cm_scache_t *);
386
387 extern void cm_HoldSCache(cm_scache_t *);
388
389 extern void cm_ReleaseSCacheNoLock(cm_scache_t *);
390
391 extern void cm_ReleaseSCache(cm_scache_t *);
392 #endif
393 extern cm_scache_t *cm_FindSCache(cm_fid_t *fidp);
394
395 extern cm_scache_t *cm_FindSCacheParent(cm_scache_t *);
396
397 extern osi_rwlock_t cm_scacheLock;
398
399 extern osi_queue_t *cm_allFileLocks;
400
401 extern osi_queue_t *cm_freeFileLocks;
402
403 extern unsigned long cm_lockRefreshCycle;
404
405 extern void cm_DiscardSCache(cm_scache_t *scp);
406
407 extern int cm_FindFileType(cm_fid_t *fidp);
408
409 extern long cm_ValidateSCache(void);
410
411 extern long cm_ShutdownSCache(void);
412
413 extern void cm_SuspendSCache(void);
414
415 extern long cm_RecycleSCache(cm_scache_t *scp, afs_int32 flags);
416
417 extern void cm_RemoveSCacheFromHashTable(cm_scache_t *scp);
418
419 extern void cm_AdjustScacheLRU(cm_scache_t *scp);
420
421 extern int cm_DumpSCache(FILE *outputFile, char *cookie, int lock);
422
423 extern void cm_ResetSCacheDirectory(cm_scache_t *scp, afs_int32 locked);
424 #endif /*  __CM_SCACHE_H_ENV__ */