Windows: do not drop lock unnecessarily
[openafs.git] / src / WINNT / afsd / cm_buf.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 /* Copyright (C) 1994 Cazamar Systems, Inc. */
11
12 #ifndef OPENAFS_WINNT_AFSD_BUF_H
13 #define OPENAFS_WINNT_AFSD_BUF_H 1
14
15 #include <osi.h>
16 #ifdef DISKCACHE95
17 #include "cm_diskcache.h"
18 #endif /* DISKCACHE95 */
19
20 /* default # of buffers if not changed */
21 #define CM_BUF_BUFFERS  100
22
23 /* default buffer size */
24 #define CM_BUF_BLOCKSIZE CM_CONFIGDEFAULT_BLOCKSIZE
25
26 /* cache type */
27 #define CM_BUF_CACHETYPE_FILE 1
28 #define CM_BUF_CACHETYPE_VIRTUAL 2
29 extern int buf_cacheType;
30
31 /* force it to be signed so that mod comes out positive or 0 */
32 #define BUF_HASH(fidp,offsetp) ((((fidp)->hash \
33                                 +(offsetp)->LowPart) / cm_data.buf_blockSize)   \
34                                    % cm_data.buf_hashSize)
35
36 /* another hash fn */
37 #define BUF_FILEHASH(fidp) ((fidp)->hash % cm_data.buf_hashSize)
38
39 #define CM_BUF_MAGIC    ('B' | 'U' <<8 | 'F'<<16 | 'F'<<24)
40
41 #define CM_BUF_VERSION_BAD 0xFFFFFFFFFFFFFFFF
42
43 /* represents a single buffer */
44 typedef struct cm_buf {
45     osi_queue_t q;              /* queue of all zero-refcount buffers */
46     afs_uint32 qFlags;          /* queue/hash state flags - buf_globalLock */
47     afs_uint32     magic;
48     struct cm_buf *allp;        /* next in all list */
49     struct cm_buf *hashp;       /* hash bucket pointer */
50     struct cm_buf *fileHashp;   /* file hash bucket pointer */
51     struct cm_buf *fileHashBackp;       /* file hash bucket back pointer */
52                                 /*
53                                  * The file hash chain is doubly linked, since
54                                  * these chains can get rather long.  The
55                                  * regular hash chain is only singly linked,
56                                  * since the chains should be short if the
57                                  * hash function is good and if there are
58                                  * enough buckets for the size of the cache.
59                                  */
60     struct cm_buf *dirtyp;      /* next in the dirty list */
61     osi_mutex_t mx;             /* mutex protecting structure except refcount */
62     afs_int32 refCount;         /* reference count (buf_globalLock) */
63     afs_uint32 dirtyCounter;    /* bumped at each dirty->clean transition */
64     osi_hyper_t offset;         /* offset */
65     cm_fid_t fid;               /* file ID */
66     char *datap;                /* data in this buffer */
67     afs_uint32 flags;           /* flags we're using - mx */
68     afs_uint32 error;           /* last error code, if CM_BUF_ERROR is set */
69     cm_user_t *userp;           /* user who wrote to the buffer last */
70
71     /* fields added for the CM; locked by scp->mx */
72     afs_uint64 dataVersion;     /* data version of this page */
73     afs_uint32 cmFlags;         /* flags for cm */
74
75     /* syncop state */
76     afs_uint32 waitCount;       /* number of threads waiting */
77     afs_uint32 waitRequests;    /* num of thread wait requests */
78
79     afs_uint32 dirty_offset;    /* offset from beginning of buffer containing dirty bytes */
80     afs_uint32 dirty_length;      /* number of dirty bytes within the buffer */
81
82 #ifdef DISKCACHE95
83     cm_diskcache_t *dcp;        /* diskcache structure */
84 #endif /* DISKCACHE95 */
85 #ifdef DEBUG
86     cm_scache_t *scp;           /* for debugging, the scache object belonging to */
87                                 /* the fid at the time of fid assignment. */
88 #else
89     void * dummy;
90 #endif
91 } cm_buf_t;
92
93 /* values for cmFlags */
94 #define CM_BUF_CMFETCHING       1       /* fetching this buffer */
95 #define CM_BUF_CMSTORING        2       /* storing this buffer */
96 #define CM_BUF_CMFULLYFETCHED   4       /* read-while-fetching optimization */
97 #define CM_BUF_CMWRITING        8       /* writing to this buffer */
98 #define CM_BUF_CMBKGFETCH      16       /* background fetch queued by
99                                          * prefetch or redirector */
100 /* waiting is done based on scp->flags.  Removing bits from cmFlags
101    should be followed by waking the scp. */
102
103 /* values for qFlags */
104 #define CM_BUF_QINHASH  1       /* in the hash table */
105 #define CM_BUF_QINLRU   2       /* in lru queue (aka free list) */
106 #define CM_BUF_QINDL    4       /* in the dirty list */
107 #define CM_BUF_QREDIR   8       /* buffer held by the redirector */
108
109 /* values for flags */
110 #define CM_BUF_READING  1       /* now reading buffer from the disk */
111 #define CM_BUF_WRITING  2       /* now writing buffer to the disk */
112 #define CM_BUF_DIRTY    8       /* buffer is dirty */
113 #define CM_BUF_ERROR    0x20    /* something went wrong on delayed write */
114 #define CM_BUF_WAITING  0x40    /* someone's waiting for a flag to change */
115 #define CM_BUF_EOF      0x80    /* read 0 bytes; used for detecting EOF */
116
117 typedef struct cm_buf_ops {
118     long (*Writep)(void *vscp, osi_hyper_t *offsetp,
119                    long length, long flags,
120                    struct cm_user *userp,
121                    struct cm_req *reqp);
122     long (*Readp)(cm_buf_t *bufp, long length,
123                   long *bytesReadp, struct cm_user *userp);
124     long (*Stabilizep)(void *vscp, struct cm_user *userp, struct cm_req *reqp);
125     long (*Unstabilizep)(void *vscp, struct cm_user *userp);
126 } cm_buf_ops_t;
127
128 #define CM_BUF_WRITE_SCP_LOCKED 0x1
129
130 /* global locks */
131 extern osi_rwlock_t buf_globalLock;
132
133 extern long buf_Init(int newFile, cm_buf_ops_t *, afs_uint64 nbuffers);
134
135 extern void buf_Shutdown(void);
136
137 extern long buf_CountFreeList(void);
138
139 #ifdef DEBUG_REFCOUNT
140 extern void buf_ReleaseDbg(cm_buf_t *, char *, long);
141
142 extern void buf_HoldDbg(cm_buf_t *, char *, long);
143
144 extern void buf_ReleaseLockedDbg(cm_buf_t *, afs_uint32, char *, long);
145
146 extern void buf_HoldLockedDbg(cm_buf_t *, char *, long);
147
148 #define buf_Release(bufp) buf_ReleaseDbg(bufp, __FILE__, __LINE__)
149 #define buf_Hold(bufp)    buf_HoldDbg(bufp, __FILE__, __LINE__)
150 #define buf_ReleaseLocked(bufp, lock) buf_ReleaseLockedDbg(bufp, lock, __FILE__, __LINE__)
151 #define buf_HoldLocked(bufp) buf_HoldLockedDbg(bufp, __FILE__, __LINE__)
152 #else
153 extern void buf_Release(cm_buf_t *);
154
155 extern void buf_Hold(cm_buf_t *);
156
157 extern void buf_ReleaseLocked(cm_buf_t *, afs_uint32);
158
159 extern void buf_HoldLocked(cm_buf_t *);
160 #endif
161
162 extern void buf_WaitIO(cm_scache_t *, cm_buf_t *);
163
164 extern cm_buf_t *buf_FindLocked(struct cm_scache *, osi_hyper_t *);
165
166 extern cm_buf_t *buf_Find(struct cm_scache *, osi_hyper_t *);
167
168 extern cm_buf_t *buf_FindAllLocked(struct cm_scache *, osi_hyper_t *, afs_uint32 flags);
169
170 extern cm_buf_t *buf_FindAll(struct cm_scache *, osi_hyper_t *, afs_uint32 flags);
171
172 extern long buf_GetNewLocked(struct cm_scache *, osi_hyper_t *, cm_req_t *, cm_buf_t **);
173
174 extern long buf_Get(struct cm_scache *, osi_hyper_t *, cm_req_t *, cm_buf_t **);
175
176 extern afs_uint32 buf_CleanAsyncLocked(cm_scache_t *, cm_buf_t *, cm_req_t *, afs_uint32 flags, afs_uint32 *);
177
178 extern afs_uint32 buf_CleanAsync(cm_scache_t *, cm_buf_t *, cm_req_t *, afs_uint32 flags, afs_uint32 *);
179
180 extern void buf_CleanWait(cm_scache_t *, cm_buf_t *, afs_uint32 locked);
181
182 extern void buf_SetDirty(cm_buf_t *, afs_uint32 offset, afs_uint32 length, cm_user_t *);
183
184 extern long buf_CleanAndReset(void);
185
186 extern void buf_ReserveBuffers(afs_uint64);
187
188 extern int buf_TryReserveBuffers(afs_uint64);
189
190 extern void buf_UnreserveBuffers(afs_uint64);
191
192 #ifdef TESTING
193 extern void buf_ValidateBufQueues(void);
194 #endif /* TESTING */
195
196 extern osi_log_t *buf_logp;
197
198 extern long buf_Truncate(struct cm_scache *scp, cm_user_t *userp,
199         cm_req_t *reqp, osi_hyper_t *sizep);
200
201 extern long buf_CleanVnode(struct cm_scache *scp, cm_user_t *userp,
202         cm_req_t *reqp);
203
204 extern long buf_FlushCleanPages(cm_scache_t *scp, cm_user_t *userp,
205         cm_req_t *reqp);
206
207 extern long buf_SetNBuffers(afs_uint64 nbuffers);
208
209 extern long buf_ValidateBuffers(void);
210
211 extern void buf_ForceTrace(BOOL flush);
212
213 extern long buf_DirtyBuffersExist(cm_fid_t * fidp);
214
215 extern long buf_CleanDirtyBuffers(cm_scache_t *scp);
216
217 extern long buf_ForceDataVersion(cm_scache_t * scp, afs_uint64 fromVersion, afs_uint64 toVersion);
218
219 extern int cm_DumpBufHashTable(FILE *outputFile, char *cookie, int lock);
220
221 /* error codes */
222 #define CM_BUF_EXISTS   1       /* buffer exists, and shouldn't */
223 #endif /* OPENAFS_WINNT_AFSD_BUF_H */