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 #define MOUNTPOINTLEN   1024
  18
  19 typedef struct cm_fid {
  20         unsigned long cell;
  21         unsigned long volume;
  22         unsigned long vnode;
  23         unsigned long unique;
  24 } cm_fid_t;
  25
  26 #if 0
  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 */
  31 } cm_accessCache_t;
  32 #endif
  33
  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;
  37
  38 typedef struct cm_range {
  39     afs_int64 offset;
  40     afs_int64 length;
  41 } cm_range_t;
  42
  43 /* forward dcls */
  44 struct cm_scache;
  45 typedef struct cm_scache cm_scache_t;
  46
  47 typedef struct cm_file_lock {
  48     osi_queue_t q;              /* list of all locks [protected by
  49                                    cm_scacheLock] */
  50     osi_queue_t fileq;          /* per-file list of locks [protected
  51                                    by scp->mx]*/
  52
  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] */
  57 #ifdef DEBUG
  58     cm_fid_t   fid;
  59 #endif
  60
  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
  68                                  * cm_scacheLock] */
  69 } cm_file_lock_t;
  70
  71 #define CM_FILELOCK_FLAG_DELETED         0x01
  72 #define CM_FILELOCK_FLAG_LOST            0x02
  73
  74 /* the following are mutually exclusive */
  75 #define CM_FILELOCK_FLAG_WAITLOCK        0x04
  76 #define CM_FILELOCK_FLAG_WAITUNLOCK      0x0C
  77
  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
  83
  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
  88
  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 */
  92 } cm_prefetch_t;
  93
  94 #define CM_SCACHE_MAGIC ('S' | 'C'<<8 | 'A'<<16 | 'C'<<24)
  95
  96 typedef struct cm_scache {
  97     osi_queue_t q;              /* lru queue; cm_scacheLock */
  98     afs_uint32      magic;
  99     struct cm_scache *nextp;    /* next in hash; cm_scacheLock */
 100     cm_fid_t fid;
 101     afs_uint32 flags;           /* flags; locked by mx */
 102
 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.
 108                                  */
 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 */
 112
 113     /* parent info for ACLs */
 114     afs_uint32 parentVnode;             /* parent vnode for ACL callbacks */
 115     afs_uint32 parentUnique;    /* for ACL callbacks */
 116
 117     /* local modification stat */
 118     afs_uint32 mask;            /* for clientModTime, length and
 119                                  * truncPos */
 120
 121     /* file status */
 122     afs_uint32 fileType;                /* file type */
 123     time_t clientModTime;               /* mtime */
 124     time_t serverModTime;               /* at server, for concurrent call
 125                                          * comparisons */
 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 */
 133
 134     /* pseudo file status */
 135     osi_hyper_t serverLength;   /* length known to server */
 136
 137     /* aux file status */
 138     osi_hyper_t truncPos;       /* file size to truncate to before
 139                                  * storing data */
 140
 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.
 146                                          */
 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 */
 150
 151     /* callback info */
 152     struct cm_server *cbServerp;        /* server granting callback */
 153     time_t cbExpires;           /* time callback expires */
 154
 155     /* access cache */
 156     long anyAccess;                     /* anonymous user's access */
 157     struct cm_aclent *randomACLp;       /* access cache entries */
 158
 159     /* file locks */
 160     afs_int32    serverLock;    /* current lock we have acquired on
 161                                  * this file.  One of (-1), LockRead
 162                                  * or LockWrite. [protected by
 163                                  * scp->mx].  In the future, this
 164                                  * should be replaced by a queue of
 165                                  * cm_server_lock_t objects which keep
 166                                  * track of lock type, the user for
 167                                  * whom the lock was obtained, the
 168                                  * dataVersion at the time the lock
 169                                  * was asserted last, lastRefreshCycle
 170                                  * and lateUpdateTime.
 171                                  */
 172     unsigned long lastRefreshCycle; /* protected with cm_scacheLock
 173                                      * for all scaches. */
 174     afs_uint32 lockDataVersion; /* dataVersion of the scp at the time
 175                                    the server lock for the scp was
 176                                    asserted for this lock the last
 177                                    time. */
 178     osi_queue_t *fileLocksH;    /* queue of locks (head) */
 179     osi_queue_t *fileLocksT;    /* queue of locks (tail) */
 180
 181     afs_uint32   sharedLocks;   /* number of shared locks on
 182                                  * ::fileLocks.  This count does not
 183                                  * include locks which have
 184                                  * CM_FILELOCK_FLAG_CLIENTONLY set. */
 185
 186     afs_uint32   exclusiveLocks; /* number of exclusive locks on
 187                                   * ::fileLocks.  This count does not
 188                                   * include locks which have
 189                                   * CM_FILELOCK_FLAG_CLIENTONLY set.
 190                                   */
 191
 192     afs_uint32   clientLocks;   /* number of locks on ::fileLocks that
 193                                    have CM_FILELOCK_FLAG_CLIENTONLY
 194                                    set. */
 195
 196     /* volume info */
 197     struct cm_volume *volp;             /* volume info; held reference */
 198
 199     /* bulk stat progress */
 200     osi_hyper_t bulkStatProgress;       /* track bulk stats of large dirs */
 201
 202     /* open state */
 203     afs_uint16 openReads;               /* open for reading */
 204     afs_uint16 openWrites;              /* open for writing */
 205     afs_uint16 openShares;              /* open for read excl */
 206     afs_uint16 openExcls;               /* open for exclusives */
 207
 208     /* syncop state */
 209     afs_uint32 waitCount;           /* number of threads waiting */
 210     afs_uint32 waitRequests;        /* num of thread wait requests */
 211 } cm_scache_t;
 212
 213 /* mask field - tell what has been modified */
 214 #define CM_SCACHEMASK_CLIENTMODTIME     1       /* client mod time */
 215 #define CM_SCACHEMASK_LENGTH            2       /* length */
 216 #define CM_SCACHEMASK_TRUNCPOS          4       /* truncation position */
 217
 218 /* fileType values */
 219 #define CM_SCACHETYPE_FILE              1       /* a file */
 220 #define CM_SCACHETYPE_DIRECTORY         2       /* a dir */
 221 #define CM_SCACHETYPE_SYMLINK           3       /* a symbolic link */
 222 #define CM_SCACHETYPE_MOUNTPOINT        4       /* a mount point */
 223 #define CM_SCACHETYPE_DFSLINK           5       /* a Microsoft Dfs link */
 224 #define CM_SCACHETYPE_INVALID           99      /* an invalid link */
 225
 226 /* flag bits */
 227 #define CM_SCACHEFLAG_STATD             0x01    /* status info is valid */
 228 #define CM_SCACHEFLAG_DELETED           0x02    /* file has been deleted */
 229 #define CM_SCACHEFLAG_CALLBACK          0x04    /* have a valid callback */
 230 #define CM_SCACHEFLAG_STORING           0x08    /* status being stored back */
 231 #define CM_SCACHEFLAG_FETCHING          0x10    /* status being fetched */
 232 #define CM_SCACHEFLAG_SIZESTORING       0x20    /* status being stored that
 233                                                  * changes the data; typically,
 234                                                  * this is a truncate op. */
 235 #define CM_SCACHEFLAG_INHASH            0x40    /* in the hash table */
 236 #define CM_SCACHEFLAG_BULKSTATTING      0x80    /* doing a bulk stat */
 237 #define CM_SCACHEFLAG_WAITING           0x200   /* waiting for fetch/store
 238                                                  * state to change */
 239 #define CM_SCACHEFLAG_PURERO            0x400   /* read-only (not even backup);
 240                                                  * for mount point eval */
 241 #define CM_SCACHEFLAG_RO                0x800   /* read-only
 242                                                  * (can't do write ops) */
 243 #define CM_SCACHEFLAG_GETCALLBACK       0x1000  /* we're getting a callback */
 244 #define CM_SCACHEFLAG_DATASTORING       0x2000  /* data being stored */
 245 #define CM_SCACHEFLAG_PREFETCHING       0x4000  /* somebody is prefetching */
 246 #define CM_SCACHEFLAG_OVERQUOTA         0x8000  /* over quota */
 247 #define CM_SCACHEFLAG_OUTOFSPACE        0x10000 /* out of space */
 248 #define CM_SCACHEFLAG_ASYNCSTORING      0x20000 /* scheduled to store back */
 249 #define CM_SCACHEFLAG_LOCKING           0x40000 /* setting/clearing file lock */
 250 #define CM_SCACHEFLAG_WATCHED           0x80000 /* directory being watched */
 251 #define CM_SCACHEFLAG_WATCHEDSUBTREE    0x100000 /* dir subtree being watched */
 252 #define CM_SCACHEFLAG_ANYWATCH \
 253                         (CM_SCACHEFLAG_WATCHED | CM_SCACHEFLAG_WATCHEDSUBTREE)
 254
 255 /* sync flags for calls to the server.  The CM_SCACHEFLAG_FETCHING,
 256  * CM_SCACHEFLAG_STORING and CM_SCACHEFLAG_SIZESTORING flags correspond to the
 257  * below, except for FETCHDATA and STOREDATA, which correspond to non-null
 258  * buffers in bufReadsp and bufWritesp.
 259  * These flags correspond to individual RPCs that we may be making, and at most
 260  * one can be set in any one call to SyncOp.
 261  */
 262 #define CM_SCACHESYNC_FETCHSTATUS           0x01        /* fetching status info */
 263 #define CM_SCACHESYNC_STORESTATUS           0x02        /* storing status info */
 264 #define CM_SCACHESYNC_FETCHDATA             0x04        /* fetch data */
 265 #define CM_SCACHESYNC_STOREDATA             0x08        /* store data */
 266 #define CM_SCACHESYNC_STORESIZE         0x10    /* store new file size */
 267 #define CM_SCACHESYNC_GETCALLBACK       0x20    /* fetching a callback */
 268 #define CM_SCACHESYNC_STOREDATA_EXCL    0x40    /* store data */
 269 #define CM_SCACHESYNC_ASYNCSTORE        0x80    /* schedule data store */
 270 #define CM_SCACHESYNC_LOCK              0x100   /* set/clear file lock */
 271
 272 /* sync flags for calls within the client; there are no corresponding flags
 273  * in the scache entry, because we hold the scache entry locked during the
 274  * operations below.
 275  */
 276 #define CM_SCACHESYNC_GETSTATUS         0x1000  /* read the status */
 277 #define CM_SCACHESYNC_SETSTATUS         0x2000  /* e.g. utimes */
 278 #define CM_SCACHESYNC_READ              0x4000  /* read data from a chunk */
 279 #define CM_SCACHESYNC_WRITE             0x8000  /* write data to a chunk */
 280 #define CM_SCACHESYNC_SETSIZE           0x10000 /* shrink the size of a file,
 281                                                  * e.g. truncate */
 282 #define CM_SCACHESYNC_NEEDCALLBACK      0x20000 /* need a callback on the file */
 283 #define CM_SCACHESYNC_CHECKRIGHTS       0x40000 /* check that user has desired
 284                                                  * access rights */
 285 #define CM_SCACHESYNC_BUFLOCKED         0x80000 /* the buffer is locked */
 286 #define CM_SCACHESYNC_NOWAIT            0x100000/* don't wait for the state,
 287                                                  * just fail */
 288
 289 /* flags for cm_MergeStatus */
 290 #define CM_MERGEFLAG_FORCE              1       /* check mtime before merging;
 291                                                  * used to see if we're merging
 292                                                  * in old info.
 293                                                  */
 294
 295 /* hash define.  Must not include the cell, since the callback revocation code
 296  * doesn't necessarily know the cell in the case of a multihomed server
 297  * contacting us from a mystery address.
 298  */
 299 #define CM_SCACHE_HASH(fidp)    (((unsigned long)       \
 300                                    ((fidp)->volume +    \
 301                                     (fidp)->vnode +     \
 302                                     (fidp)->unique))    \
 303                                         % cm_data.hashTableSize)
 304
 305 #include "cm_conn.h"
 306 #include "cm_buf.h"
 307
 308 extern void cm_InitSCache(int, long);
 309
 310 extern long cm_GetSCache(cm_fid_t *, cm_scache_t **, struct cm_user *,
 311         struct cm_req *);
 312
 313 extern void cm_PutSCache(cm_scache_t *);
 314
 315 extern cm_scache_t *cm_GetNewSCache(void);
 316
 317 extern int cm_FidCmp(cm_fid_t *, cm_fid_t *);
 318
 319 extern long cm_SyncOp(cm_scache_t *, struct cm_buf *, struct cm_user *,
 320         struct cm_req *, long, long);
 321
 322 extern void cm_SyncOpDone(cm_scache_t *, struct cm_buf *, long);
 323
 324 extern void cm_MergeStatus(cm_scache_t *, struct AFSFetchStatus *, struct AFSVolSync *,
 325         struct cm_user *, int flags);
 326
 327 extern void cm_AFSFidFromFid(struct AFSFid *, cm_fid_t *);
 328
 329 extern void cm_HoldSCacheNoLock(cm_scache_t *);
 330
 331 extern void cm_HoldSCache(cm_scache_t *);
 332
 333 extern void cm_ReleaseSCacheNoLock(cm_scache_t *);
 334
 335 extern void cm_ReleaseSCache(cm_scache_t *);
 336
 337 extern cm_scache_t *cm_FindSCache(cm_fid_t *fidp);
 338
 339 extern cm_scache_t *cm_FindSCacheParent(cm_scache_t *);
 340
 341 extern osi_rwlock_t cm_scacheLock;
 342
 343 extern osi_queue_t *cm_allFileLocks;
 344
 345 extern osi_queue_t *cm_freeFileLocks;
 346
 347 extern unsigned long cm_lockRefreshCycle;
 348
 349 extern void cm_DiscardSCache(cm_scache_t *scp);
 350
 351 extern int cm_FindFileType(cm_fid_t *fidp);
 352
 353 extern long cm_ValidateSCache(void);
 354
 355 extern long cm_ShutdownSCache(void);
 356
 357 #endif /*  __CM_SCACHE_H_ENV__ */