time_t-200408018
[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 #ifdef DJGPP
14 #include "largeint95.h"
15 #endif /* DJGPP */
16
17 typedef struct cm_fid {
18         unsigned long cell;
19         unsigned long volume;
20         unsigned long vnode;
21         unsigned long unique;
22 } cm_fid_t;
23
24 typedef struct cm_accessCache {
25         osi_queue_t q;                  /* queue header */
26         struct cm_user *userp;          /* user having access rights */
27         long rights;                    /* rights */
28 } cm_accessCache_t;
29
30 typedef struct cm_file_lock {
31         osi_queue_t q;                  /* list of all locks */
32         osi_queue_t fileq;              /* per-file list of locks */
33         cm_user_t *userp;
34         LARGE_INTEGER LOffset;
35         LARGE_INTEGER LLength;
36         cm_fid_t fid;
37         unsigned char LockType;
38         unsigned char flags;
39 } cm_file_lock_t;
40
41 #define CM_FILELOCK_FLAG_INVALID        0x1
42 #define CM_FILELOCK_FLAG_WAITING        0x2
43
44 typedef struct cm_prefetch {            /* last region scanned for prefetching */
45         osi_hyper_t base;               /* start of region */
46         osi_hyper_t end;                /* first char past region */
47 } cm_prefetch_t;
48
49 typedef struct cm_scache {
50         osi_queue_t q;                  /* lru queue; cm_scacheLock */
51         struct cm_scache *nextp;        /* next in hash; cm_scacheLock */
52         cm_fid_t fid;
53         long flags;                     /* flags; locked by mx */
54
55         /* synchronization stuff */
56         osi_mutex_t mx;                 /* mutex for this structure */
57         osi_rwlock_t bufCreateLock;     /* read-locked during buffer creation;
58                                          * write-locked to prevent buffers from
59                                          * being created during a truncate op, etc.
60                                          */
61         int refCount;                   /* reference count; cm_scacheLock */
62         osi_queueData_t *bufReadsp;     /* queue of buffers being read */
63         osi_queueData_t *bufWritesp;    /* queue of buffers being written */
64
65         /* parent info for ACLs */
66         long parentVnode;               /* parent vnode for ACL callbacks */
67         long parentUnique;              /* for ACL callbacks */
68
69         /* local modification stat */
70         long mask;                      /* for clientModTime, length and
71                                          * truncPos */
72
73         /* file status */
74         int fileType;                   /* file type */
75         time_t clientModTime;   /* mtime */
76         time_t serverModTime;   /* at server, for concurrent call
77                                          * comparisons */
78         osi_hyper_t length;             /* file length */
79         cm_prefetch_t prefetch;         /* prefetch info structure */
80         int unixModeBits;               /* unix protection mode bits */
81         int linkCount;                  /* link count */
82         long dataVersion;               /* data version */
83         long owner;                     /* file owner */
84         long group;                     /* file owning group */
85
86         /* pseudo file status */
87         osi_hyper_t serverLength;       /* length known to server */
88
89         /* aux file status */
90         osi_hyper_t truncPos;           /* file size to truncate to before
91                                          * storing data */
92
93         /* symlink and mount point info */
94         char *mountPointStringp;        /* the string stored in a mount point;
95                                          * first char is type, then vol name.
96                                          * If this is a normal symlink, we store
97                                          * the link contents here.
98                                          */
99         cm_fid_t *mountRootFidp;        /* mounted on root */
100         time_t    mountRootGen;         /* time to update mountRootFidp? */
101         cm_fid_t *dotdotFidp;           /* parent of volume root */
102
103         /* callback info */
104         struct cm_server *cbServerp;    /* server granting callback */
105         time_t cbExpires;               /* time callback expires */
106
107         /* access cache */
108         long anyAccess;                 /* anonymous user's access */
109         struct cm_aclent *randomACLp;   /* access cache entries */
110
111         /* file locks */
112         osi_queue_t *fileLocks;
113         
114         /* volume info */
115         struct cm_volume *volp;         /* volume info; held reference */
116   
117         /* bulk stat progress */
118         osi_hyper_t bulkStatProgress;   /* track bulk stats of large dirs */
119
120         /* open state */
121         short openReads;                /* opens for reading */
122         short openWrites;               /* open for writing */
123         short openShares;               /* open for read excl */
124         short openExcls;                /* open for exclusives */
125 } cm_scache_t;
126
127 /* mask field - tell what has been modified */
128 #define CM_SCACHEMASK_CLIENTMODTIME     1       /* client mod time */
129 #define CM_SCACHEMASK_LENGTH            2       /* length */
130 #define CM_SCACHEMASK_TRUNCPOS          4       /* truncation position */
131
132 /* fileType values */
133 #define CM_SCACHETYPE_FILE              1       /* a file */
134 #define CM_SCACHETYPE_DIRECTORY         2       /* a dir */
135 #define CM_SCACHETYPE_SYMLINK           3       /* a symbolic link */
136 #define CM_SCACHETYPE_MOUNTPOINT        4       /* a mount point */
137
138 /* flag bits */
139 #define CM_SCACHEFLAG_STATD                 0x01        /* status info is valid */
140 #define CM_SCACHEFLAG_DELETED           0x02    /* file has been deleted */
141 #define CM_SCACHEFLAG_CALLBACK          0x04    /* have a valid callback */
142 #define CM_SCACHEFLAG_STORING           0x08    /* status being stored back */
143 #define CM_SCACHEFLAG_FETCHING          0x10    /* status being fetched */
144 #define CM_SCACHEFLAG_SIZESTORING       0x20    /* status being stored that
145                                                  * changes the data; typically,
146                                                  * this is a truncate op. */
147 #define CM_SCACHEFLAG_INHASH            0x40    /* in the hash table */
148 #define CM_SCACHEFLAG_BULKSTATTING      0x80    /* doing a bulk stat */
149 #define CM_SCACHEFLAG_WAITING           0x200   /* waiting for fetch/store
150                                                  * state to change */
151 #define CM_SCACHEFLAG_PURERO            0x400   /* read-only (not even backup);
152                                                  * for mount point eval */
153 #define CM_SCACHEFLAG_RO                0x800   /* read-only
154                                                  * (can't do write ops) */
155 #define CM_SCACHEFLAG_GETCALLBACK       0x1000  /* we're getting a callback */
156 #define CM_SCACHEFLAG_DATASTORING       0x2000  /* data being stored */
157 #define CM_SCACHEFLAG_PREFETCHING       0x4000  /* somebody is prefetching */
158 #define CM_SCACHEFLAG_OVERQUOTA         0x8000  /* over quota */
159 #define CM_SCACHEFLAG_OUTOFSPACE        0x10000 /* out of space */
160 #define CM_SCACHEFLAG_ASYNCSTORING      0x20000 /* scheduled to store back */
161 #define CM_SCACHEFLAG_LOCKING           0x40000 /* setting/clearing file lock */
162 #define CM_SCACHEFLAG_WATCHED           0x80000 /* directory being watched */
163 #define CM_SCACHEFLAG_WATCHEDSUBTREE    0x100000 /* dir subtree being watched */
164 #define CM_SCACHEFLAG_ANYWATCH \
165                         (CM_SCACHEFLAG_WATCHED | CM_SCACHEFLAG_WATCHEDSUBTREE)
166
167 /* sync flags for calls to the server.  The CM_SCACHEFLAG_FETCHING,
168  * CM_SCACHEFLAG_STORING and CM_SCACHEFLAG_SIZESTORING flags correspond to the
169  * below, except for FETCHDATA and STOREDATA, which correspond to non-null
170  * buffers in bufReadsp and bufWritesp.
171  * These flags correspond to individual RPCs that we may be making, and at most
172  * one can be set in any one call to SyncOp.
173  */
174 #define CM_SCACHESYNC_FETCHSTATUS           0x01        /* fetching status info */
175 #define CM_SCACHESYNC_STORESTATUS           0x02        /* storing status info */
176 #define CM_SCACHESYNC_FETCHDATA             0x04        /* fetch data */
177 #define CM_SCACHESYNC_STOREDATA             0x08        /* store data */
178 #define CM_SCACHESYNC_STORESIZE         0x10    /* store new file size */
179 #define CM_SCACHESYNC_GETCALLBACK       0x20    /* fetching a callback */
180 #define CM_SCACHESYNC_STOREDATA_EXCL    0x40    /* store data */
181 #define CM_SCACHESYNC_ASYNCSTORE        0x80    /* schedule data store */
182 #define CM_SCACHESYNC_LOCK              0x100   /* set/clear file lock */
183
184 /* sync flags for calls within the client; there are no corresponding flags
185  * in the scache entry, because we hold the scache entry locked during the
186  * operations below.
187  */
188 #define CM_SCACHESYNC_GETSTATUS         0x1000  /* read the status */
189 #define CM_SCACHESYNC_SETSTATUS         0x2000  /* e.g. utimes */
190 #define CM_SCACHESYNC_READ              0x4000  /* read data from a chunk */
191 #define CM_SCACHESYNC_WRITE             0x8000  /* write data to a chunk */
192 #define CM_SCACHESYNC_SETSIZE           0x10000 /* shrink the size of a file,
193                                                  * e.g. truncate */
194 #define CM_SCACHESYNC_NEEDCALLBACK      0x20000 /* need a callback on the file */
195 #define CM_SCACHESYNC_CHECKRIGHTS       0x40000 /* check that user has desired
196                                                  * access rights */
197 #define CM_SCACHESYNC_BUFLOCKED         0x80000 /* the buffer is locked */
198 #define CM_SCACHESYNC_NOWAIT            0x100000/* don't wait for the state,
199                                                  * just fail */
200
201 /* flags for cm_MergeStatus */
202 #define CM_MERGEFLAG_FORCE              1       /* check mtime before merging;
203                                                  * used to see if we're merging
204                                                  * in old info.
205                                                  */
206
207 /* hash define.  Must not include the cell, since the callback revocation code
208  * doesn't necessarily know the cell in the case of a multihomed server
209  * contacting us from a mystery address.
210  */
211 #define CM_SCACHE_HASH(fidp)    (((unsigned long)       \
212                                    ((fidp)->volume +    \
213                                     (fidp)->vnode +     \
214                                     (fidp)->unique))    \
215                                         % cm_hashTableSize)
216
217 #include "cm_conn.h"
218 #include "cm_buf.h"
219
220 extern cm_scache_t cm_fakeSCache;
221
222 extern void cm_InitSCache(long);
223
224 extern long cm_GetSCache(cm_fid_t *, cm_scache_t **, struct cm_user *,
225         struct cm_req *);
226
227 extern void cm_PutSCache(cm_scache_t *);
228
229 extern cm_scache_t *cm_GetNewSCache(void);
230
231 extern int cm_FidCmp(cm_fid_t *, cm_fid_t *);
232
233 extern long cm_SyncOp(cm_scache_t *, struct cm_buf *, struct cm_user *,
234         struct cm_req *, long, long);
235
236 extern void cm_SyncOpDone(cm_scache_t *, struct cm_buf *, long);
237
238 extern void cm_MergeStatus(cm_scache_t *, struct AFSFetchStatus *, struct AFSVolSync *,
239         struct cm_user *, int flags);
240
241 extern void cm_AFSFidFromFid(struct AFSFid *, cm_fid_t *);
242
243 extern void cm_HoldSCache(cm_scache_t *);
244
245 extern void cm_ReleaseSCache(cm_scache_t *);
246
247 extern cm_scache_t *cm_FindSCache(cm_fid_t *fidp);
248
249 extern long cm_hashTableSize;
250
251 extern osi_rwlock_t cm_scacheLock;
252
253 extern osi_queue_t *cm_allFileLocks;
254
255 extern cm_scache_t **cm_hashTablep;
256
257 extern void cm_DiscardSCache(cm_scache_t *scp);
258
259 #endif /*  __CM_SCACHE_H_ENV__ */