protoize-buffer-20031208
[openafs.git] / src / dir / buffer.c
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 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 RCSID
14     ("$Header$");
15
16 #include <stdlib.h>
17 #include <lock.h>
18
19 #ifdef AFS_64BIT_IOPS_ENV
20 #define BUFFER_FID_SIZE (9 + 2*sizeof(char*)/sizeof(int))
21 #else
22 #define BUFFER_FID_SIZE (6 + 2*sizeof(char*)/sizeof(int))
23 #endif
24
25 struct buffer {
26     /* fid is used for Unique cache key + i/o addressing.
27      * fid size is based on 4 + size of inode and size of pointer
28      */
29     afs_int32 fid[BUFFER_FID_SIZE];
30     afs_int32 page;
31     afs_int32 accesstime;
32     struct buffer *hashNext;
33     void *data;
34     char lockers;
35     char dirty;
36     char hashIndex;
37     struct Lock lock;
38 };
39
40 #include "dir.h"
41
42 struct Lock afs_bufferLock;
43
44 /* page size */
45 #define BUFFER_PAGE_SIZE 2048
46 /* log page size */
47 #define LOGPS 11
48 /* page hash table size */
49 #define PHSIZE 32
50 /* The hash table should be somewhat efficient even if there are only
51  * a few partitions (less than 32). So the hash for the fileserver is now
52  * based on the volume id. This means this macro is dependent upon the
53  * layout of DirHandle in viced/viced.h, vol/salvage.h and volser/salvage.h.
54  */
55 #define pHash(fid) ((fid)[0] & (PHSIZE-1))
56 #define vHash(vid) (vid & (PHSIZE-1))
57
58 /* admittedly system dependent, this is the maximum signed 32-bit value */
59 #define BUFFER_LONG_MAX   2147483647
60 #ifndef NULL
61 #define NULL 0
62 #endif
63
64 static struct buffer **Buffers;
65
66 char *BufferData;
67
68 static struct buffer *phTable[PHSIZE];  /* page hash table */
69 static struct buffer *LastBuffer;
70 int nbuffers;
71 int timecounter;
72 static int calls = 0, ios = 0;
73
74 struct buffer *newslot();
75
76 int
77 DStat(int *abuffers, int *acalls, int *aios)
78 {
79     *abuffers = nbuffers;
80     *acalls = calls;
81     *aios = ios;
82     return 0;
83 }
84
85 int
86 DInit(int abuffers)
87 {
88     /* Initialize the venus buffer system. */
89     register int i, tsize;
90     register struct buffer *tb;
91     register char *tp;
92
93     Lock_Init(&afs_bufferLock);
94     /* Align each element of Buffers on a doubleword boundary */
95     tsize = (sizeof(struct buffer) + 7) & ~7;
96     tp = (char *)malloc(abuffers * tsize);
97     Buffers = (struct buffer **)malloc(abuffers * sizeof(struct buffer *));
98     BufferData = (char *)malloc(abuffers * BUFFER_PAGE_SIZE);
99     timecounter = 0;
100     LastBuffer = (struct buffer *)tp;
101     nbuffers = abuffers;
102     for (i = 0; i < PHSIZE; i++)
103         phTable[i] = 0;
104     for (i = 0; i < abuffers; i++) {
105         /* Fill in each buffer with an empty indication. */
106         tb = (struct buffer *)tp;
107         Buffers[i] = tb;
108         tp += tsize;
109         FidZero(tb->fid);
110         tb->accesstime = tb->lockers = 0;
111         tb->data = &BufferData[BUFFER_PAGE_SIZE * i];
112         tb->hashIndex = 0;
113         tb->dirty = 0;
114         Lock_Init(&tb->lock);
115     }
116     return 0;
117 }
118
119 void *
120 DRead(register afs_int32 *fid, register int page)
121 {
122     /* Read a page from the disk. */
123     register struct buffer *tb, *tb2, **bufhead;
124
125     ObtainWriteLock(&afs_bufferLock);
126     calls++;
127
128 #define bufmatch(tb) (tb->page == page && FidEq(tb->fid, fid))
129 #define buf_Front(head,parent,p) {(parent)->hashNext = (p)->hashNext; (p)->hashNext= *(head);*(head)=(p);}
130
131     /* this apparently-complicated-looking code is simply an example of
132      * a little bit of loop unrolling, and is a standard linked-list
133      * traversal trick. It saves a few assignments at the the expense
134      * of larger code size.  This could be simplified by better use of
135      * macros.  With the use of these LRU queues, the old one-cache is
136      * probably obsolete.
137      */
138     if (tb = phTable[pHash(fid)]) {     /* ASSMT HERE */
139         if (bufmatch(tb)) {
140             ObtainWriteLock(&tb->lock);
141             tb->lockers++;
142             ReleaseWriteLock(&afs_bufferLock);
143             tb->accesstime = ++timecounter;
144             ReleaseWriteLock(&tb->lock);
145             return tb->data;
146         } else {
147             bufhead = &(phTable[pHash(fid)]);
148             while (tb2 = tb->hashNext) {
149                 if (bufmatch(tb2)) {
150                     buf_Front(bufhead, tb, tb2);
151                     ObtainWriteLock(&tb2->lock);
152                     tb2->lockers++;
153                     ReleaseWriteLock(&afs_bufferLock);
154                     tb2->accesstime = ++timecounter;
155                     ReleaseWriteLock(&tb2->lock);
156                     return tb2->data;
157                 }
158                 if (tb = tb2->hashNext) {       /* ASSIGNMENT HERE! */
159                     if (bufmatch(tb)) {
160                         buf_Front(bufhead, tb2, tb);
161                         ObtainWriteLock(&tb->lock);
162                         tb->lockers++;
163                         ReleaseWriteLock(&afs_bufferLock);
164                         tb->accesstime = ++timecounter;
165                         ReleaseWriteLock(&tb->lock);
166                         return tb->data;
167                     }
168                 } else
169                     break;
170             }
171         }
172     } else
173         tb2 = NULL;
174
175     /* can't find it */
176     /* The last thing we looked at was either tb or tb2 (or nothing). That
177      * is at least the oldest buffer on one particular hash chain, so it's
178      * a pretty good place to start looking for the truly oldest buffer.
179      */
180     tb = newslot(fid, page, (tb ? tb : tb2));
181     ios++;
182     ObtainWriteLock(&tb->lock);
183     tb->lockers++;
184     ReleaseWriteLock(&afs_bufferLock);
185     if (ReallyRead(tb->fid, tb->page, tb->data)) {
186         tb->lockers--;
187         FidZap(tb->fid);        /* disaster */
188         ReleaseWriteLock(&tb->lock);
189         return 0;
190     }
191     /* Note that findslot sets the page field in the buffer equal to
192      * what it is searching for.
193      */
194     ReleaseWriteLock(&tb->lock);
195     return tb->data;
196 }
197
198 static int
199 FixupBucket(register struct buffer *ap)
200 {
201     register struct buffer **lp, *tp;
202     register int i;
203
204     /* first try to get it out of its current hash bucket, in which it might not be */
205     i = ap->hashIndex;
206     lp = &phTable[i];
207     for (tp = *lp; tp; tp = tp->hashNext) {
208         if (tp == ap) {
209             *lp = tp->hashNext;
210             break;
211         }
212         lp = &tp->hashNext;
213     }
214     /* now figure the new hash bucket */
215     i = pHash(ap->fid);
216     ap->hashIndex = i;          /* remember where we are for deletion */
217     ap->hashNext = phTable[i];  /* add us to the list */
218     phTable[i] = ap;            /* at the front, since it's LRU */
219     return 0;
220 }
221
222 struct buffer *
223 newslot(afs_int32 *afid, afs_int32 apage, register struct buffer *lp)
224 {
225     /* Find a usable buffer slot */
226     register afs_int32 i;
227     afs_int32 lt;
228     register struct buffer **tbp;
229
230     if (lp && (lp->lockers == 0)) {
231         lt = lp->accesstime;
232     } else {
233         lp = 0;
234         lt = BUFFER_LONG_MAX;
235     }
236
237     tbp = Buffers;
238     for (i = 0; i < nbuffers; i++, tbp++) {
239         if ((*tbp)->lockers == 0) {
240             if ((*tbp)->accesstime < lt) {
241                 lp = (*tbp);
242                 lt = (*tbp)->accesstime;
243             }
244         }
245     }
246
247     /* There are no unlocked buffers */
248     if (lp == 0) {
249         if (lt < 0)
250             Die("accesstime counter wrapped");
251         else
252             Die("all buffers locked");
253     }
254
255     /* We do not need to lock the buffer here because it has no lockers
256      * and the afs_bufferLock prevents other threads from zapping this
257      * buffer while we are writing it out */
258     if (lp->dirty) {
259         if (ReallyWrite(lp->fid, lp->page, lp->data))
260             Die("writing bogus buffer");
261         lp->dirty = 0;
262     }
263
264     /* Now fill in the header. */
265     FidZap(lp->fid);
266     FidCpy(lp->fid, afid);      /* set this */
267     lp->page = apage;
268     lp->accesstime = ++timecounter;
269
270     FixupBucket(lp);            /* move to the right hash bucket */
271
272     return lp;
273 }
274
275 void
276 DRelease(register struct buffer *bp, int flag)
277 {
278     /* Release a buffer, specifying whether or not the buffer has been modified by the locker. */
279     register int index;
280
281     if (!bp)
282         return;
283     index = ((char *)bp - BufferData) >> LOGPS;
284     bp = Buffers[index];
285     ObtainWriteLock(&bp->lock);
286     bp->lockers--;
287     if (flag)
288         bp->dirty = 1;
289     ReleaseWriteLock(&bp->lock);
290 }
291
292 int
293 DVOffset(register void *ap)
294 {
295     /* Return the byte within a file represented by a buffer pointer. */
296     register struct buffer *bp = ap;
297     register int index;
298
299     index = ((char *)bp - BufferData) >> LOGPS;
300     if (index < 0 || index >= nbuffers)
301         return -1;
302     bp = Buffers[index];
303     return BUFFER_PAGE_SIZE * bp->page + (char *)ap - (char *)bp->data;
304 }
305
306 void
307 DZap(register afs_int32 *fid)
308 {
309     /* Destroy all buffers pertaining to a particular fid. */
310     register struct buffer *tb;
311     ObtainReadLock(&afs_bufferLock);
312     for (tb = phTable[pHash(fid)]; tb; tb = tb->hashNext)
313         if (FidEq(tb->fid, fid)) {
314             ObtainWriteLock(&tb->lock);
315             FidZap(tb->fid);
316             tb->dirty = 0;
317             ReleaseWriteLock(&tb->lock);
318         }
319     ReleaseReadLock(&afs_bufferLock);
320 }
321
322 int
323 DFlushVolume(register afs_int32 vid)
324 {
325     /* Flush all data and release all inode handles for a particular volume */
326     register struct buffer *tb;
327     register int code, rcode = 0;
328     ObtainReadLock(&afs_bufferLock);
329     for (tb = phTable[vHash(vid)]; tb; tb = tb->hashNext)
330         if (FidVolEq(tb->fid, vid)) {
331             ObtainWriteLock(&tb->lock);
332             if (tb->dirty) {
333                 code = ReallyWrite(tb->fid, tb->page, tb->data);
334                 if (code && !rcode)
335                     rcode = code;
336                 tb->dirty = 0;
337             }
338             FidZap(tb->fid);
339             ReleaseWriteLock(&tb->lock);
340         }
341     ReleaseReadLock(&afs_bufferLock);
342     return rcode;
343 }
344
345 int
346 DFlushEntry(register afs_int32 *fid)
347 {
348     /* Flush pages modified by one entry. */
349     register struct buffer *tb;
350     int code;
351
352     ObtainReadLock(&afs_bufferLock);
353     for (tb = phTable[pHash(fid)]; tb; tb = tb->hashNext)
354         if (FidEq(tb->fid, fid) && tb->dirty) {
355             ObtainWriteLock(&tb->lock);
356             if (tb->dirty) {
357                 code = ReallyWrite(tb->fid, tb->page, tb->data);
358                 if (code) {
359                     ReleaseWriteLock(&tb->lock);
360                     ReleaseReadLock(&afs_bufferLock);
361                     return code;
362                 }
363                 tb->dirty = 0;
364             }
365             ReleaseWriteLock(&tb->lock);
366         }
367     ReleaseReadLock(&afs_bufferLock);
368     return 0;
369 }
370
371 int
372 DFlush()
373 {
374     /* Flush all the modified buffers. */
375     register int i;
376     register struct buffer **tbp;
377     afs_int32 code, rcode;
378
379     rcode = 0;
380     tbp = Buffers;
381     ObtainReadLock(&afs_bufferLock);
382     for (i = 0; i < nbuffers; i++, tbp++) {
383         if ((*tbp)->dirty) {
384             ObtainWriteLock(&(*tbp)->lock);
385             (*tbp)->lockers++;
386             ReleaseReadLock(&afs_bufferLock);
387             if ((*tbp)->dirty) {
388                 code = ReallyWrite((*tbp)->fid, (*tbp)->page, (*tbp)->data);
389                 if (!code)
390                     (*tbp)->dirty = 0;  /* Clear the dirty flag */
391                 if (code && !rcode) {
392                     rcode = code;
393                 }
394             }
395             (*tbp)->lockers--;
396             ReleaseWriteLock(&(*tbp)->lock);
397             ObtainReadLock(&afs_bufferLock);
398         }
399     }
400     ReleaseReadLock(&afs_bufferLock);
401     return rcode;
402 }
403
404 void *
405 DNew(register afs_int32 *fid, register int page)
406 {
407     /* Same as read, only do *not* even try to read the page,
408      * since it probably doesn't exist.
409      */
410     register struct buffer *tb;
411     ObtainWriteLock(&afs_bufferLock);
412     if ((tb = newslot(fid, page, 0)) == 0) {
413         ReleaseWriteLock(&afs_bufferLock);
414         return 0;
415     }
416     ObtainWriteLock(&tb->lock);
417     tb->lockers++;
418     ReleaseWriteLock(&afs_bufferLock);
419     ReleaseWriteLock(&tb->lock);
420     return tb->data;
421 }