ac55aed3055dd5a0c55a436857f774450fd37a7c
[openafs.git] / src / WINNT / afsd / cm_dir.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 <afs/param.h>
11 #include <afs/stds.h>
12
13 #include <windows.h>
14 #include <string.h>
15 #include <malloc.h>
16 #include <osi.h>
17 #include "afsd.h"
18 #ifdef USE_BPLUS
19 #include "cm_btree.h"
20 #endif
21 #include <rx/rx.h>
22
23
24 afs_int32 DErrno;
25
26 afs_uint32 dir_lookup_hits = 0;
27 afs_uint32 dir_lookup_misses = 0;
28 afs_uint32 dir_create_entry = 0;
29 afs_uint32 dir_remove_entry = 0;
30
31 afs_uint64 dir_lookup_time = 0;
32 afs_uint64 dir_create_time = 0;
33 afs_uint64 dir_remove_time = 0;
34
35 afs_uint64 dir_enums = 0;
36
37 afs_int32  cm_BPlusTrees = 1;
38
39 int cm_MemDumpDirStats(FILE *outputFile, char *cookie, int lock)
40 {
41     int zilch;
42     char output[128];
43
44     sprintf(output, "%s - Dir Lookup   Hits: %-8d\r\n", cookie, dir_lookup_hits);
45     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
46     sprintf(output, "%s -            Misses: %-8d\r\n", cookie, dir_lookup_misses);
47     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
48     sprintf(output, "%s -             Enums: %-8d\r\n", cookie, dir_enums);
49     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
50     sprintf(output, "%s -            Create: %-8d\r\n", cookie, dir_create_entry);
51     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
52     sprintf(output, "%s -            Remove: %-8d\r\n", cookie, dir_remove_entry);
53     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
54
55     sprintf(output, "%s - Dir Times  Lookup: %-16I64d\r\n", cookie, dir_lookup_time);
56     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
57     sprintf(output, "%s -            Create: %-16I64d\r\n", cookie, dir_create_time);
58     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
59     sprintf(output, "%s -            Remove: %-16I64d\r\n", cookie, dir_remove_time);
60     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
61
62     return(0);
63 }
64
65 void cm_DirDumpStats(void)
66 {
67     afsi_log("Dir Lookup   Hits: %-8d", dir_lookup_hits);
68     afsi_log("           Misses: %-8d", dir_lookup_misses);
69     afsi_log("            Enums: %-8d", dir_enums);
70     afsi_log("           Create: %-8d", dir_create_entry);
71     afsi_log("           Remove: %-8d", dir_remove_entry);
72
73     afsi_log("Dir Times  Lookup: %-16I64d", dir_lookup_time);
74     afsi_log("           Create: %-16I64d", dir_create_time);
75     afsi_log("           Remove: %-16I64d", dir_remove_time);
76 }
77
78
79 /* Local static prototypes */
80 static long
81 cm_DirGetBlob(cm_dirOp_t * op,
82               unsigned int blobno, cm_buf_t ** bufferpp, cm_dirEntry_t ** blobpp);
83
84 static long
85 cm_DirFindItem(cm_dirOp_t * op,
86                char *ename,
87                cm_buf_t ** itembufpp, cm_dirEntry_t ** itempp,
88                cm_buf_t ** prevbufpp, unsigned short **previtempp);
89
90 static long
91 cm_DirOpAddBuffer(cm_dirOp_t * op, cm_buf_t * buffer);
92
93 /* flags for cm_DirOpDelBuffer */
94 #define DIROP_MODIFIED  1
95 #define DIROP_SCPLOCKED 2
96
97 static int
98 cm_DirOpDelBuffer(cm_dirOp_t * op, cm_buf_t * buffer, int flags);
99
100 static long
101 cm_DirCheckStatus(cm_dirOp_t * op, int locked);
102
103 static long
104 cm_DirReleasePage(cm_dirOp_t * op, cm_buf_t ** bufferpp, int modified);
105
106 static long
107 cm_DirGetPage(cm_dirOp_t * op,
108               long index, cm_buf_t ** bufferpp, void ** datapp);
109
110 static long
111 cm_DirFindBlobs(cm_dirOp_t * op, int nblobs);
112
113 static long
114 cm_DirAddPage(cm_dirOp_t * op, int pageno);
115
116 static long
117 cm_DirFreeBlobs(cm_dirOp_t * op, int firstblob, int nblobs);
118
119 static long
120 cm_DirPrefetchBuffers(cm_dirOp_t * op);
121
122 /* compute how many 32 byte entries an AFS 3 dir requires for storing
123  * the specified name.
124  */
125 long 
126 cm_NameEntries(char *namep, size_t *lenp)
127 {
128     long i;
129         
130     i = (long)strlen(namep);
131     if (lenp) *lenp = i;
132     return 1 + ((i+16) >> 5);
133 }
134
135 /* Create an entry in a file.  Dir is a file representation, while
136    entry is a string name.
137
138    On entry:
139        op->scp->rw is unlocked
140
141    On exit:
142        op->scp->rw is unlocked
143
144    None of the directory buffers for op->scp should be locked by the
145    calling thread.
146 */
147 long
148 cm_DirCreateEntry(cm_dirOp_t * op, char *entry, cm_fid_t * cfid)
149 {
150     int blobs, firstelt;
151     int i;
152     LARGE_INTEGER start, end;
153
154     cm_dirEntry_t *ep = NULL;
155     cm_buf_t *entrybuf = NULL;
156
157     unsigned short *pp = NULL;
158     cm_buf_t *prevptrbuf = NULL;
159
160     cm_dirHeader_t *dhp = NULL;
161     cm_buf_t *dhpbuf = NULL;
162
163     long code = 0;
164
165     /* check name quality */
166     if (*entry == 0)
167         return EINVAL;
168
169     QueryPerformanceCounter(&start);
170
171     dir_create_entry++;
172
173     osi_Log4(afsd_logp, "cm_DirCreateEntry for op 0x%p, name [%s] and fid[%d,%d]",
174              op, osi_LogSaveString(afsd_logp, entry), cfid->vnode, cfid->unique);
175
176     /* First check if file already exists. */
177     code = cm_DirFindItem(op,
178                           entry,
179                           &entrybuf, &ep,
180                           &prevptrbuf, &pp);
181     if (code == 0) {
182         cm_DirReleasePage(op, &entrybuf, FALSE);
183         cm_DirReleasePage(op, &prevptrbuf, FALSE);
184         code = EEXIST;
185         goto done;
186     }
187
188     blobs = cm_NameEntries(entry, NULL);        /* number of entries required */
189     firstelt = cm_DirFindBlobs(op, blobs);
190     if (firstelt < 0) {
191         osi_Log0(afsd_logp, "cm_DirCreateEntry returning EFBIG");
192         code = EFBIG;           /* directory is full */
193         goto done;
194     }
195
196     /* First, we fill in the directory entry. */
197     code = cm_DirGetBlob(op, firstelt, &entrybuf, &ep);
198     if (code != 0) {
199         code = EIO;
200         goto done;
201     }
202
203     ep->flag = CM_DIR_FFIRST;
204     ep->fid.vnode = htonl(cfid->vnode);
205     ep->fid.unique = htonl(cfid->unique);
206     strcpy(ep->name, entry);
207
208     /* Now we just have to thread it on the hash table list. */
209     code = cm_DirGetPage(op, 0, &dhpbuf, &dhp);
210     if (code != 0) {
211         cm_DirReleasePage(op, &entrybuf, TRUE);
212         code = EIO;
213         goto done;
214     }
215
216     i = cm_DirHash(entry);
217
218     ep->next = dhp->hashTable[i];
219     dhp->hashTable[i] = htons(firstelt);
220
221     cm_DirReleasePage(op, &dhpbuf, TRUE);
222     cm_DirReleasePage(op, &entrybuf, TRUE);
223
224     osi_Log0(afsd_logp, "cm_DirCreateEntry returning success");
225
226     code = 0;
227   done:
228     QueryPerformanceCounter(&end);
229
230     dir_create_time += (end.QuadPart - start.QuadPart);
231     return code;
232 }
233
234 /* Return the length of a directory in pages
235
236    On entry:
237        op->scp->rw is locked
238
239    On exit:
240        op->scp->rw is locked
241
242    The first directory page for op->scp should not be locked by the
243    calling thread.
244 */
245 int
246 cm_DirLength(cm_dirOp_t * op)
247 {
248     int i, ctr;
249     cm_dirHeader_t *dhp = NULL;
250     cm_buf_t       *dhpbuf = NULL;
251
252     long code;
253
254     code = cm_DirGetPage(op, 0, &dhpbuf, &dhp);
255     if (code != 0)
256         return 0;
257
258     if (dhp->header.pgcount != 0)
259         ctr = ntohs(dhp->header.pgcount);
260     else {
261         /* old style, count the pages */
262         ctr = 0;
263         for (i = 0; i < CM_DIR_MAXPAGES; i++)
264             if (dhp->alloMap[i] != CM_DIR_EPP)
265                 ctr++;
266     }
267     cm_DirReleasePage(op, &dhpbuf, FALSE);
268     return ctr * CM_DIR_PAGESIZE;
269 }
270
271 /* Delete a directory entry.
272
273    On entry:
274        op->scp->rw is unlocked
275
276    On exit:
277        op->scp->rw is unlocked
278
279    None of the directory buffers for op->scp should be locked by the
280    calling thread.
281  */
282 int
283 cm_DirDeleteEntry(cm_dirOp_t * op, char *entry)
284 {
285     /* Delete an entry from a directory, including update of all free
286        entry descriptors. */
287
288     int nitems, index;
289     cm_dirEntry_t *firstitem = NULL;
290     cm_buf_t      *itembuf = NULL;
291     unsigned short *previtem = NULL;
292     cm_buf_t      *pibuf = NULL;
293     osi_hyper_t    thyper;
294     unsigned long  junk;
295     long code;
296     LARGE_INTEGER start, end;
297
298     QueryPerformanceCounter(&start);
299
300     osi_Log2(afsd_logp, "cm_DirDeleteEntry for op 0x%p, entry [%s]",
301              op, osi_LogSaveString(afsd_logp, entry));
302
303     code = cm_DirFindItem(op, entry,
304                           &itembuf, &firstitem,
305                           &pibuf, &previtem);
306     if (code != 0) {
307         osi_Log0(afsd_logp, "cm_DirDeleteEntry returning ENOENT");
308         code = ENOENT;
309         goto done;
310     }
311
312     dir_remove_entry++;
313
314     *previtem = firstitem->next;
315     cm_DirReleasePage(op, &pibuf, TRUE);
316
317     thyper = itembuf->offset;
318     thyper = LargeIntegerAdd(thyper,
319                              ConvertLongToLargeInteger(((char *) firstitem) - itembuf->datap));
320     thyper = ExtendedLargeIntegerDivide(thyper, 32, &junk);
321
322     index = thyper.LowPart;
323     osi_assert(thyper.HighPart == 0);
324
325     nitems = cm_NameEntries(firstitem->name, NULL);
326     cm_DirReleasePage(op, &itembuf, FALSE);
327
328     cm_DirFreeBlobs(op, index, nitems);
329
330     osi_Log0(afsd_logp, "cm_DirDeleteEntry returning success");
331     code = 0;
332
333   done:
334     QueryPerformanceCounter(&end);
335
336     dir_remove_time += (end.QuadPart - start.QuadPart);
337
338     return code;
339 }
340
341 /* Find a bunch of contiguous entries; at least nblobs in a row.
342
343    Called with op->scp->rw */
344 static long
345 cm_DirFindBlobs(cm_dirOp_t * op, int nblobs)
346 {
347     int i, j, k;
348     int failed = 0;
349
350     cm_dirHeader_t *dhp = NULL;
351     cm_buf_t *dhpbuf = NULL;
352     int dhpModified = FALSE;
353
354     cm_pageHeader_t *pp = NULL;
355     cm_buf_t *pagebuf = NULL;
356     int pageModified = FALSE;
357
358     int pgcount;
359
360     long code;
361
362     osi_Log2(afsd_logp, "cm_DirFindBlobs for op 0x%p, nblobs = %d",
363              op, nblobs);
364
365     code = cm_DirGetPage(op, 0, &dhpbuf, (void **) &dhp);
366     if (code)
367         return -1;
368
369     for (i = 0; i < CM_DIR_BIGMAXPAGES; i++) {
370         if (i >= CM_DIR_MAXPAGES || dhp->alloMap[i] >= nblobs) {
371             /* if page could contain enough entries */
372             /* If there are CM_DIR_EPP free entries, then the page is
373                not even allocated. */
374             if (i >= CM_DIR_MAXPAGES) {
375
376                 /* this pages exists past the end of the old-style dir */
377                 pgcount = ntohs(dhp->header.pgcount);
378                 if (pgcount == 0) {
379                     pgcount = CM_DIR_MAXPAGES;
380                     dhp->header.pgcount = htons(pgcount);
381                     dhpModified = TRUE;
382                 }
383
384                 if (i > pgcount - 1) {
385                     /* this page is bigger than last allocated page */
386                     cm_DirAddPage(op, i);
387                     dhp->header.pgcount = htons(i + 1);
388                     dhpModified = TRUE;
389                 }
390             } else if (dhp->alloMap[i] == CM_DIR_EPP) {
391                 /* Add the page to the directory. */
392                 cm_DirAddPage(op, i);
393                 dhp->alloMap[i] = CM_DIR_EPP - 1;
394                 dhp->header.pgcount = htons(i + 1);
395                 dhpModified = TRUE;
396             }
397
398             /* the create flag is not set for the GetPage call below
399                since the page should have been added if necessary
400                above. */
401             code = cm_DirGetPage(op, i, &pagebuf, &pp);
402             if (code) {
403                 cm_DirReleasePage(op, &dhpbuf, dhpModified);
404                 break;
405             }
406
407             for (j = 0; j <= CM_DIR_EPP - nblobs; j++) {
408                 failed = 0;
409                 for (k = 0; k < nblobs; k++)
410                     if ((pp->freeBitmap[(j + k) >> 3] >> ((j + k) & 7)) & 1) {
411                         failed = 1;
412                         break;
413                     }
414                 if (!failed)
415                     break;
416                 failed = 1;
417             }
418
419             if (!failed) {
420                 /* Here we have the first index in j.  We update the allocation maps
421                  * and free up any resources we've got allocated. */
422                 if (i < CM_DIR_MAXPAGES) {
423                     dhp->alloMap[i] -= nblobs;
424                     dhpModified = TRUE;
425                 }
426
427                 cm_DirReleasePage(op, &dhpbuf, dhpModified);
428
429                 for (k = 0; k < nblobs; k++)
430                     pp->freeBitmap[(j + k) >> 3] |= 1 << ((j + k) & 7);
431
432                 cm_DirReleasePage(op, &pagebuf, TRUE);
433
434                 osi_Log0(afsd_logp, "cm_DirFindBlobs returning success");
435
436                 return j + i * CM_DIR_EPP;
437             }
438             cm_DirReleasePage(op, &pagebuf, pageModified);
439         }
440     }
441
442     /* If we make it here, the directory is full. */
443     osi_Log0(afsd_logp, "cm_DirFindBlobs directory is full");
444     cm_DirReleasePage(op, &dhpbuf, dhpModified);
445     return -1;
446 }
447
448 /* Add a page to a directory. 
449
450    Called with op->scp->rw
451 */
452 static long
453 cm_DirAddPage(cm_dirOp_t * op, int pageno)
454 {
455     int i;
456     cm_pageHeader_t *pp = NULL;
457     cm_buf_t *pagebuf = NULL;
458     long code = 0;
459
460     osi_Log2(afsd_logp, "cm_DirAddPage for op 0x%p, pageno=%d", op, pageno);
461
462     code = cm_DirGetPage(op, pageno, &pagebuf, (void **) &pp);
463     if (code != 0)
464         return code;
465
466     pp->tag = htons(1234);
467     if (pageno > 0)
468         pp->pgcount = 0;
469     pp->freeCount = CM_DIR_EPP - 1; /* The first dude is already allocated */
470     pp->freeBitmap[0] = 0x01;
471     for (i = 1; i < CM_DIR_EPP / 8; i++) /* It's a constant */
472         pp->freeBitmap[i] = 0;
473
474     cm_DirReleasePage(op, &pagebuf, TRUE);
475
476     osi_Log0(afsd_logp, "cm_DirAddPage returning success");
477
478     return code;
479 }
480
481 /* Free a whole bunch of directory entries.
482
483    Called with op->scp->rw
484 */
485 static long
486 cm_DirFreeBlobs(cm_dirOp_t * op, int firstblob, int nblobs)
487 {
488     int i;
489     int page;
490
491     cm_dirHeader_t *dhp = NULL;
492     cm_buf_t       *dhpbuf = NULL;
493     int             dhpmodified = FALSE;
494
495     cm_pageHeader_t *pp = NULL;
496     cm_buf_t        *pagebuf = NULL;
497     long code = 0;
498
499     osi_Log3(afsd_logp, "cm_DirFreeBlobs for op 0x%p, firstblob=%d, nblobs=%d",
500              op, firstblob, nblobs);
501
502     page = firstblob / CM_DIR_EPP;
503     firstblob -= CM_DIR_EPP * page;     /* convert to page-relative entry */
504
505     code = cm_DirGetPage(op, 0, &dhpbuf, &dhp);
506     if (code)
507         return code;
508
509     if (page < CM_DIR_MAXPAGES) {
510         dhp->alloMap[page] += nblobs;
511         dhpmodified = TRUE;
512     }
513
514     cm_DirReleasePage(op, &dhpbuf, dhpmodified);
515
516     code = cm_DirGetPage(op, page, &pagebuf, &pp);
517     if (code == 0) {
518         for (i = 0; i < nblobs; i++)
519             pp->freeBitmap[(firstblob + i) >> 3] &=
520                 ~(1 << ((firstblob + i) & 7));
521         cm_DirReleasePage(op, &pagebuf, TRUE);
522     }
523
524     osi_Log1(afsd_logp, "cm_DirFreeBlobs returning code 0x%x", code);
525
526     return code;
527 }
528
529 /*
530  * Format an empty directory properly.  Note that the first 13 entries in a
531  * directory header page are allocated, 1 to the page header, 4 to the
532  * allocation map and 8 to the hash table.
533  *
534  * Called with op->scp->rw unlocked
535  */
536 int
537 cm_DirMakeDir(cm_dirOp_t * op, cm_fid_t * me, cm_fid_t * parent)
538 {
539     int i;
540     cm_dirHeader_t *dhp = NULL;
541     cm_buf_t *dhpbuf = NULL;
542     int rc = 0;
543     long code;
544
545     osi_Log3(afsd_logp, "cm_DirMakeDir for op 0x%p, directory fid[%d, %d]",
546              op, me->vnode, me->unique);
547     osi_Log2(afsd_logp, "              parent[%d, %d]",
548              parent->vnode, parent->unique);
549
550     code = cm_DirGetPage(op, 0, &dhpbuf, &dhp);
551     if (code) {
552         rc = 1;
553         goto done;
554     }
555
556     dhp->header.pgcount = htons(1);
557     dhp->header.tag = htons(1234);
558     dhp->header.freeCount = (CM_DIR_EPP - CM_DIR_DHE - 1);
559     dhp->header.freeBitmap[0] = 0xff;
560     dhp->header.freeBitmap[1] = 0x1f;
561     for (i = 2; i < CM_DIR_EPP / 8; i++)
562         dhp->header.freeBitmap[i] = 0;
563     dhp->alloMap[0] = (CM_DIR_EPP - CM_DIR_DHE - 1);
564     for (i = 1; i < CM_DIR_MAXPAGES; i++)
565         dhp->alloMap[i] = CM_DIR_EPP;
566     for (i = 0; i < CM_DIR_NHASHENT; i++)
567         dhp->hashTable[i] = 0;
568
569     cm_DirReleasePage(op, &dhpbuf, TRUE);
570
571     cm_DirCreateEntry(op, ".", me);
572     cm_DirCreateEntry(op, "..", parent);        /* Virtue is its own .. */
573
574     osi_Log0(afsd_logp, "cm_DirMakeDir returning success");
575
576   done:
577     return rc;
578 }
579
580
581 /* Look up a file name in directory.
582
583    On entry:
584        op->scp->rw is unlocked
585
586    On exit:
587        op->scp->rw is unlocked
588
589    None of the directory buffers for op->scp should be locked by the
590    calling thread.
591 */
592 int
593 cm_DirLookup(cm_dirOp_t * op, char *entry, cm_fid_t * cfid)
594 {
595     cm_dirEntry_t *firstitem = NULL;
596     cm_buf_t      *itembuf = NULL;
597     unsigned short *previtem = NULL;
598     cm_buf_t      *pibuf = NULL;
599     long code;
600     LARGE_INTEGER       start;
601     LARGE_INTEGER       end;
602
603     lock_AssertNone(&op->scp->rw);
604
605     QueryPerformanceCounter(&start);
606
607     osi_Log2(afsd_logp, "cm_DirLookup for op 0x%p, entry[%s]",
608              op, osi_LogSaveString(afsd_logp, entry));
609
610     code = cm_DirFindItem(op, entry,
611                           &itembuf, &firstitem,
612                           &pibuf, &previtem);
613
614     if (code == CM_ERROR_NOTINCACHE) {
615         code = cm_DirPrefetchBuffers(op);
616         if (code == 0)
617             code = cm_DirFindItem(op, entry, &itembuf, &firstitem,
618                                   &pibuf, &previtem);
619     }
620
621     if (code != 0) {
622         dir_lookup_misses++;
623         code = ENOENT;
624         goto done;
625     }
626
627     cm_DirReleasePage(op, &pibuf, FALSE);
628
629     cfid->cell = op->scp->fid.cell;
630     cfid->volume = op->scp->fid.volume;
631     cfid->vnode = ntohl(firstitem->fid.vnode);
632     cfid->unique = ntohl(firstitem->fid.unique);
633
634     cm_DirReleasePage(op, &itembuf, FALSE);
635
636     osi_Log2(afsd_logp, "cm_DirLookup returning fid[%d,%d]",
637              cfid->vnode, cfid->unique);
638
639     dir_lookup_hits++;
640     code = 0;
641
642   done:
643     QueryPerformanceCounter(&end);
644
645     dir_lookup_time += (end.QuadPart - start.QuadPart);
646
647     return code;
648 }
649
650 /* Look up a file name in directory.
651
652    On entry:
653        op->scp->rw is locked
654
655    On exit:
656        op->scp->rw is locked
657
658    None of the directory buffers for op->scp should be locked by the
659    calling thread.
660 */
661 int
662 cm_DirLookupOffset(cm_dirOp_t * op, char *entry, cm_fid_t *cfid, osi_hyper_t *offsetp)
663 {
664     cm_dirEntry_t *firstitem = NULL;
665     cm_buf_t      *itembuf = NULL;
666     unsigned short *previtem = NULL;
667     cm_buf_t      *pibuf = NULL;
668
669     long code;
670
671     osi_Log2(afsd_logp, "cm_DirLookupOffset for op 0x%p, entry[%s]",
672              op, osi_LogSaveString(afsd_logp, entry));
673
674     code = cm_DirFindItem(op, entry,
675                           &itembuf, &firstitem,
676                           &pibuf, &previtem);
677     if (code != 0)
678         return ENOENT;
679
680     cm_DirReleasePage(op, &pibuf, FALSE);
681
682     cfid->cell = op->scp->fid.cell;
683     cfid->volume = op->scp->fid.volume;
684     cfid->vnode = ntohl(firstitem->fid.vnode);
685     cfid->unique = ntohl(firstitem->fid.unique);
686     if (offsetp) {
687         osi_hyper_t thyper;
688
689         thyper = itembuf->offset;
690         thyper = LargeIntegerAdd(thyper,
691                                  ConvertLongToLargeInteger(((char *) firstitem) - itembuf->datap));
692
693         *offsetp = thyper;
694     }
695
696     cm_DirReleasePage(op, &itembuf, FALSE);
697
698     osi_Log2(afsd_logp, "cm_DirLookupOffset returning fid[%d,%d]",
699              cfid->vnode, cfid->unique);
700     if (offsetp) {
701         osi_Log2(afsd_logp, "               offset [%x:%x]",
702                  offsetp->HighPart, offsetp->LowPart);
703     }
704
705     return 0;
706 }
707
708 /* Apply a function to every directory entry in a directory.
709
710    On entry:
711        op->scp->rw is locked
712
713    On exit:
714        op->scp->rw is locked
715
716    None of the directory buffers for op->scp should be locked by the
717    calling thread.
718
719    The hook function cannot modify or lock any directory buffers.
720  */
721 int
722 cm_DirApply(cm_dirOp_t * op, int (*hookproc) (void *, char *, long, long), void *hook)
723 {
724     /* Enumerate the contents of a directory. */
725     int i;
726     int num;
727
728     cm_dirHeader_t *dhp = NULL;
729     cm_buf_t       *dhpbuf = NULL;
730
731     cm_dirEntry_t  *ep = NULL;
732     cm_buf_t       *epbuf = NULL;
733
734     long code = 0;
735
736     code = cm_DirGetPage(op, 0, &dhpbuf, &dhp);
737     if (code != 0)
738         return EIO;
739
740     for (i = 0; i < CM_DIR_NHASHENT; i++) {
741         /* For each hash chain, enumerate everyone on the list. */
742         num = ntohs(dhp->hashTable[i]);
743         while (num != 0) {
744             /* Walk down the hash table list. */
745             code = cm_DirGetBlob(op, num, &epbuf, &ep);
746             if (code != 0) {
747                 cm_DirReleasePage(op, &dhpbuf, FALSE);
748                 return code;
749             }
750
751             num = ntohs(ep->next);
752             (*hookproc) (hook, ep->name, ntohl(ep->fid.vnode),
753                          ntohl(ep->fid.unique));
754
755             cm_DirReleasePage(op, &epbuf, FALSE);
756         }
757     }
758     cm_DirReleasePage(op, &dhpbuf, FALSE);
759
760     return 0;
761 }
762
763 /* Check if a directory is empty
764
765    On entry:
766        op->scp->rw is locked
767
768    On exit:
769        op->scp->rw is locked
770
771    None of the directory buffers for op->scp should be locked by the
772    calling thread.
773  */
774 int
775 cm_DirIsEmpty(cm_dirOp_t * op)
776 {
777     /* Enumerate the contents of a directory. */
778     int i;
779     int num;
780
781     cm_dirHeader_t *dhp = NULL;
782     cm_buf_t       *dhpbuf = NULL;
783
784     cm_dirEntry_t  *ep = NULL;
785     cm_buf_t       *epbuf = NULL;
786
787     long code = 0;
788
789     code = cm_DirGetPage(op, 0, &dhpbuf, &dhp);
790     if (code != 0)
791         return 0;
792
793     for (i = 0; i < CM_DIR_NHASHENT; i++) {
794         /* For each hash chain, enumerate everyone on the list. */
795         num = ntohs(dhp->hashTable[i]);
796
797         while (num != 0) {
798             /* Walk down the hash table list. */
799             code = cm_DirGetBlob(op, num, &epbuf, &ep);
800             if (code != 0)
801                 break;
802
803             if (strcmp(ep->name, "..") && strcmp(ep->name, ".")) {
804                 cm_DirReleasePage(op, &epbuf, FALSE);
805                 cm_DirReleasePage(op, &dhpbuf, FALSE);
806                 return 1;
807             }
808             num = ntohs(ep->next);
809             cm_DirReleasePage(op, &epbuf, FALSE);
810         }
811     }
812     cm_DirReleasePage(op, &dhpbuf, FALSE);
813     return 0;
814 }
815
816 /* Return a pointer to an entry, given its number.
817
818    On entry:
819      scp->rw locked
820      if *bufferpp != NULL, then *bufferpp->mx is locked
821
822    During:
823      scp->rw may be unlocked
824      *bufferpp may be released
825
826    On exit:
827      scp->rw locked
828      if *bufferpp != NULL, then *bufferpp->mx is locked
829
830      *bufferpp should be released via cm_DirReleasePage() or any other
831      *call that releases a directory buffer.
832 */
833 static long
834 cm_DirGetBlob(cm_dirOp_t * op,
835               unsigned int blobno, cm_buf_t ** bufferpp, cm_dirEntry_t ** blobpp)
836 {
837     unsigned char * ep;
838     long code = 0;
839
840     osi_Log2(afsd_logp, "cm_DirGetBlob for op 0x%p, blobno=%d",
841              op, blobno);
842
843     code = cm_DirGetPage(op, blobno >> CM_DIR_LEPP,
844                          bufferpp, (void **) &ep);
845     if (code != 0)
846         return code;
847
848     *blobpp = (cm_dirEntry_t *) (ep + 32 * (blobno & (CM_DIR_EPP - 1)));
849
850     return code;
851 }       
852
853 int
854 cm_DirHash(char *string)
855 {
856     /* Hash a string to a number between 0 and NHASHENT. */
857     unsigned char tc;
858     int hval;
859     int tval;
860     hval = 0;
861     while ((tc = (*string++))) {
862         hval *= 173;
863         hval += tc;
864     }
865     tval = hval & (CM_DIR_NHASHENT - 1);
866     if (tval == 0)
867         return tval;
868     else if (hval < 0)
869         tval = CM_DIR_NHASHENT - tval;
870     return tval;
871 }
872
873 /* Find a directory entry, given its name.  This entry returns a
874  * pointer to a locked buffer, and a pointer to a locked buffer (in
875  * previtem) referencing the found item (to aid the delete code).  If
876  * no entry is found, however, no items are left locked, and a null
877  * pointer is returned instead.
878  *
879  * On entry:
880  *  scp->rw locked
881  *
882  * On exit:
883  *  scp->rw locked
884  */
885 static long
886 cm_DirFindItem(cm_dirOp_t * op,
887                char *ename,
888                cm_buf_t ** itembufpp, cm_dirEntry_t ** itempp,
889                cm_buf_t ** prevbufpp, unsigned short **previtempp)
890 {
891     int                  i;
892     cm_dirHeader_t      *dhp = NULL;
893     unsigned short      *lp = NULL;
894     cm_dirEntry_t       *tp = NULL;
895     cm_buf_t            *hashbufp = NULL;
896     cm_buf_t            *itembufp = NULL;
897     long code = 0;
898
899     osi_Log2(afsd_logp, "cm_DirFindItem for op 0x%p, entry[%s]",
900              op, osi_LogSaveString(afsd_logp, ename));
901
902     i = cm_DirHash(ename);
903
904     if (op->scp->fileType != CM_SCACHETYPE_DIRECTORY) {
905         osi_Log0(afsd_logp, "cm_DirFindItem: The scp is not a directory");
906         return CM_ERROR_INVAL;
907     }
908
909     code = cm_DirGetPage(op, 0, &hashbufp, (void **) &dhp);
910     if (code != 0) {
911         return code;
912     }
913
914     if (dhp->hashTable[i] == 0) {
915         /* no such entry */
916         osi_Log1(afsd_logp, "cm_DirFindItem: Hash bucket %d is empty", i);
917         cm_DirReleasePage(op, &hashbufp, FALSE);
918         return ENOENT;
919     }
920
921     code = cm_DirGetBlob(op,
922                          (u_short) ntohs(dhp->hashTable[i]),
923                          &itembufp, &tp);
924     if (code != 0) {
925         cm_DirReleasePage(op, &hashbufp, FALSE);
926         return code;
927     }
928
929     lp = &(dhp->hashTable[i]);
930
931     /* loop invariant:
932
933        lp       : pointer to blob number of entry we are looking at
934        hashbufp : buffer containing lp
935        tp       : pointer to entry we are looking at
936        itembufp : buffer containing tp
937      */
938     while (1) {
939         /* Look at each hash conflict entry. */
940         if (!strcmp(ename, tp->name)) {
941             osi_Log0(afsd_logp, "cm_DirFindItem: returning success");
942             /* Found our entry. */
943             *previtempp = lp;
944             *prevbufpp = hashbufp;
945             *itempp = tp;
946             *itembufpp = itembufp;
947             return 0;
948         }
949
950         lp = &(tp->next);
951         cm_DirReleasePage(op, &hashbufp, FALSE);
952         hashbufp = itembufp;
953
954         itembufp = NULL;
955         tp = NULL;
956
957         if (*lp == 0) {
958             /* The end of the line */
959             osi_Log0(afsd_logp, "cm_DirFindItem: returning ENOENT");
960             cm_DirReleasePage(op, &hashbufp, FALSE);
961             return ENOENT;
962         }
963
964         code = cm_DirGetBlob(op,
965                              (u_short) ntohs(*lp),
966                              &itembufp, &tp);
967
968         if (code != 0) {
969             cm_DirReleasePage(op, &hashbufp, FALSE);
970             return code;
971         }
972     }
973 }
974
975 /* Begin a sequence of directory operations.  
976  * Called with scp->rw unlocked.
977  */
978 long
979 cm_BeginDirOp(cm_scache_t * scp, cm_user_t * userp, cm_req_t * reqp,
980               afs_uint32 lockType, cm_dirOp_t * op)
981 {
982     long code;
983     int i, mxheld = 0, haveWrite = 0;
984
985     osi_Log3(afsd_logp, "Beginning dirOp[0x%p] for scp[0x%p], userp[0x%p]",
986              op, scp, userp);
987
988     memset(op, 0, sizeof(*op));
989
990     cm_HoldSCache(scp);
991     op->scp = scp;
992     cm_HoldUser(userp);
993     op->userp = userp;
994     op->req = *reqp;            /* copy the values from the input */
995
996     op->dirtyBufCount = 0;
997     op->nBuffers = 0;
998
999     for (i=0; i < CM_DIROP_MAXBUFFERS; i++) {
1000         op->buffers[i].flags = 0;
1001     }
1002
1003     if (lockType == CM_DIRLOCK_WRITE) {
1004         lock_ObtainWrite(&scp->dirlock);
1005         haveWrite = 1;
1006     } else { 
1007         lock_ObtainRead(&scp->dirlock);
1008         haveWrite = 0;
1009     }
1010     lock_ObtainWrite(&scp->rw);
1011     mxheld = 1;
1012     code = cm_DirCheckStatus(op, 1);
1013     if (code == 0) {
1014         op->length = scp->length;
1015         op->newLength = op->length;
1016         op->dataVersion = scp->dataVersion;
1017         op->newDataVersion = op->dataVersion;
1018
1019 #ifdef USE_BPLUS
1020         if (!cm_BPlusTrees ||
1021             (scp->dirBplus &&
1022              scp->dirDataVersion == scp->dataVersion)) 
1023         {
1024             /* we know that haveWrite matches lockType at this point */
1025             switch (lockType) {
1026             case CM_DIRLOCK_NONE:
1027                 if (haveWrite)
1028                     lock_ReleaseWrite(&scp->dirlock);
1029                 else
1030                     lock_ReleaseRead(&scp->dirlock);
1031                 break;
1032             case CM_DIRLOCK_READ:
1033                 osi_assert(!haveWrite);
1034                 break;
1035             case CM_DIRLOCK_WRITE:
1036             default:
1037                 osi_assert(haveWrite);
1038             }
1039         } else {
1040             if (!(scp->dirBplus && 
1041                   scp->dirDataVersion == scp->dataVersion)) 
1042             {
1043               repeat:
1044                 if (!haveWrite) {
1045                     if (mxheld) {
1046                         lock_ReleaseWrite(&scp->rw);
1047                         mxheld = 0;
1048                     }
1049                     lock_ConvertRToW(&scp->dirlock);
1050                     haveWrite = 1;
1051                 }
1052                 if (!mxheld) {
1053                     lock_ObtainWrite(&scp->rw);
1054                     mxheld = 1;
1055                 }
1056                 if (scp->dirBplus && 
1057                      scp->dirDataVersion != scp->dataVersion)
1058                 {
1059                     bplus_dv_error++;
1060                     bplus_free_tree++;
1061                     freeBtree(scp->dirBplus);
1062                     scp->dirBplus = NULL;
1063                     scp->dirDataVersion = CM_SCACHE_VERSION_BAD;
1064                 }
1065
1066                 if (!scp->dirBplus) {
1067                     if (mxheld) {
1068                         lock_ReleaseWrite(&scp->rw);
1069                         mxheld = 0;
1070                     }
1071                     code = cm_BPlusDirBuildTree(scp, userp, reqp);
1072                     if (!mxheld) {
1073                         lock_ObtainWrite(&scp->rw);
1074                         mxheld = 1;
1075                     }
1076                     if (code) {
1077                         bplus_free_tree++;
1078                         freeBtree(scp->dirBplus);
1079                         scp->dirBplus = NULL;
1080                         scp->dirDataVersion = CM_SCACHE_VERSION_BAD;
1081                     } else {
1082                         if (op->dataVersion != scp->dataVersion) {
1083                             /* We lost the race, therefore we must update the
1084                              * dirop state and retry to build the tree.
1085                             */
1086                             op->length = scp->length;
1087                             op->newLength = op->length;
1088                             op->dataVersion = scp->dataVersion;
1089                             op->newDataVersion = op->dataVersion;
1090                             goto repeat;
1091                         }
1092
1093                          if (scp->dirBplus)
1094                             scp->dirDataVersion = scp->dataVersion;
1095                     }
1096                 }
1097             }
1098
1099             switch (lockType) {
1100             case CM_DIRLOCK_NONE:
1101                 lock_ReleaseWrite(&scp->dirlock);
1102                 break;
1103             case CM_DIRLOCK_READ:
1104                 lock_ConvertWToR(&scp->dirlock);
1105                 break;
1106             case CM_DIRLOCK_WRITE:
1107             default:
1108                 /* got it already */;
1109             }
1110             haveWrite = 0;
1111         }
1112 #else
1113         /* we know that haveWrite matches lockType at this point */
1114         switch (lockType) {
1115         case CM_DIRLOCK_NONE:
1116             if (haveWrite)
1117                 lock_ReleaseWrite(&scp->dirlock);
1118             else
1119                 lock_ReleaseRead(&scp->dirlock);
1120             break;
1121         case CM_DIRLOCK_READ:
1122             osi_assert(!haveWrite);
1123             break;
1124         case CM_DIRLOCK_WRITE:
1125         default:
1126             osi_assert(haveWrite);
1127         }
1128 #endif
1129         op->lockType = lockType;
1130         if (mxheld)
1131             lock_ReleaseWrite(&scp->rw);
1132     } else {
1133         if (haveWrite)
1134             lock_ReleaseWrite(&scp->dirlock);
1135         else
1136             lock_ReleaseRead(&scp->dirlock);
1137         if (mxheld)
1138             lock_ReleaseWrite(&scp->rw);
1139         cm_EndDirOp(op);
1140     }
1141
1142     return code;
1143 }
1144
1145 /* Check if it is safe for us to perform local directory updates.
1146    Called with op->scp->rw unlocked. */
1147 int
1148 cm_CheckDirOpForSingleChange(cm_dirOp_t * op)
1149 {
1150     long code;
1151     int  rc = 0;
1152
1153     if (op->scp == NULL)
1154         return 0;
1155
1156     lock_ObtainWrite(&op->scp->rw);
1157     code = cm_DirCheckStatus(op, 1);
1158
1159     if (code == 0 &&
1160         op->dataVersion == op->scp->dataVersion - 1) {
1161         /* only one set of changes happened between cm_BeginDirOp()
1162            and this function.  It is safe for us to perform local
1163            changes. */
1164         op->newDataVersion = op->scp->dataVersion;
1165         op->newLength = op->scp->serverLength;
1166
1167         rc = 1;
1168     }
1169     lock_ReleaseWrite(&op->scp->rw); 
1170     
1171     if (rc)
1172         osi_Log0(afsd_logp, "cm_CheckDirOpForSingleChange succeeded");
1173     else
1174         osi_Log3(afsd_logp,
1175                  "cm_CheckDirOpForSingleChange failed.  code=0x%x, old dv=%d, new dv=%d",
1176                  code, op->dataVersion, op->scp->dataVersion);
1177     return rc;
1178 }
1179
1180 /* End a sequence of directory operations.  
1181  * Called with op->scp->rw unlocked.*/
1182 long
1183 cm_EndDirOp(cm_dirOp_t * op)
1184 {
1185     long code = 0;
1186
1187     if (op->scp == NULL)
1188         return 0;
1189
1190     osi_Log2(afsd_logp, "Ending dirOp 0x%p with %d dirty buffer releases",
1191              op, op->dirtyBufCount);
1192
1193     if (op->dirtyBufCount > 0) {
1194 #ifdef USE_BPLUS
1195         /* update the data version on the B+ tree */
1196         if (op->scp->dirBplus && 
1197              op->scp->dirDataVersion == op->dataVersion) {
1198
1199             switch (op->lockType) {
1200             case CM_DIRLOCK_READ:
1201                 lock_ReleaseRead(&op->scp->dirlock);
1202                 /* fall through ... */
1203             case CM_DIRLOCK_NONE:
1204                 lock_ObtainWrite(&op->scp->dirlock);
1205                 op->lockType = CM_DIRLOCK_WRITE;
1206                 break;
1207             case CM_DIRLOCK_WRITE:
1208             default:
1209                 /* already got it */;
1210             }
1211             op->scp->dirDataVersion = op->newDataVersion;
1212         }
1213 #endif
1214
1215         /* we made changes.  We should go through the list of buffers
1216          * and update the dataVersion for each. */
1217         lock_ObtainWrite(&op->scp->rw);
1218         code = buf_ForceDataVersion(op->scp, op->dataVersion, op->newDataVersion);
1219         op->scp->flags |= CM_SCACHEFLAG_LOCAL;
1220         lock_ReleaseWrite(&op->scp->rw);
1221     }
1222
1223     switch (op->lockType) {
1224     case CM_DIRLOCK_NONE:
1225         break;
1226     case CM_DIRLOCK_READ:
1227         lock_ReleaseRead(&op->scp->dirlock);
1228         break;
1229     case CM_DIRLOCK_WRITE:
1230     default:
1231         lock_ReleaseWrite(&op->scp->dirlock);
1232     }
1233
1234     if (op->scp)
1235         cm_ReleaseSCache(op->scp);
1236     op->scp = NULL;
1237
1238     if (op->userp)
1239         cm_ReleaseUser(op->userp);
1240     op->userp = 0;
1241
1242     osi_assertx(op->nBuffers == 0, "Buffer leak after dirOp termination");
1243
1244     return code;
1245 }
1246
1247 /* NOTE: Called without scp->rw and without bufferp->mx */
1248 static long
1249 cm_DirOpAddBuffer(cm_dirOp_t * op, cm_buf_t * bufferp)
1250 {
1251     int i;
1252     long code = 0;
1253
1254     osi_Log2(afsd_logp, "cm_DirOpAddBuffer for op 0x%p, buffer %p", op, bufferp);
1255
1256     if (bufferp == NULL)
1257         return -1;
1258
1259     for (i=0; i < CM_DIROP_MAXBUFFERS; i++) {
1260         if ((op->buffers[i].flags & CM_DIROPBUFF_INUSE) &&
1261             op->buffers[i].bufferp == bufferp) {
1262             break;
1263         }
1264     }
1265
1266     if (i < CM_DIROP_MAXBUFFERS) {
1267         /* we already have this buffer on our list */
1268
1269         op->buffers[i].refcount++;
1270         osi_Log0(afsd_logp,
1271                  "cm_DirOpAddBuffer: the buffer is already listed for the dirOp");
1272         return 0;
1273     } else {
1274         /* we have to add a new buffer */
1275         osi_assertx(op->nBuffers < CM_DIROP_MAXBUFFERS - 1,
1276                     "DirOp has exceeded CM_DIROP_MAXBUFFERS buffers");
1277
1278         for (i=0; i < CM_DIROP_MAXBUFFERS; i++) {
1279             if (!(op->buffers[i].flags & CM_DIROPBUFF_INUSE))
1280                 break;
1281         }
1282
1283         osi_assert(i < CM_DIROP_MAXBUFFERS);
1284
1285         lock_ObtainMutex(&bufferp->mx);
1286         lock_ObtainWrite(&op->scp->rw);
1287
1288         /* Make sure we are synchronized. */
1289         osi_assert(op->lockType != CM_DIRLOCK_NONE);
1290
1291         code = cm_SyncOp(op->scp, bufferp, op->userp, &op->req, PRSFS_LOOKUP,
1292                          CM_SCACHESYNC_NEEDCALLBACK |
1293                          (op->lockType == CM_DIRLOCK_WRITE ? CM_SCACHESYNC_WRITE : CM_SCACHESYNC_READ) |
1294                          CM_SCACHESYNC_BUFLOCKED);
1295
1296         if (code == 0 && bufferp->dataVersion != op->dataVersion) {
1297                 osi_Log2(afsd_logp,
1298                          "cm_DirOpAddBuffer: buffer data version mismatch. buf dv = %d. needs %d", 
1299                          bufferp->dataVersion, op->dataVersion);
1300
1301                 cm_SyncOpDone(op->scp, bufferp,
1302                               CM_SCACHESYNC_NEEDCALLBACK |
1303                               (op->lockType == CM_DIRLOCK_WRITE ? CM_SCACHESYNC_WRITE : CM_SCACHESYNC_READ) |
1304                               CM_SCACHESYNC_BUFLOCKED);
1305             code = CM_ERROR_NOTINCACHE;
1306         }
1307
1308         lock_ReleaseWrite(&op->scp->rw);
1309         lock_ReleaseMutex(&bufferp->mx);
1310
1311         if (code) {
1312             osi_Log1(afsd_logp, "cm_DirOpAddBuffer: failed to sync buffer.  code=0x%x",
1313                      code);
1314             return code;
1315         }
1316
1317         buf_Hold(bufferp);
1318         op->buffers[i].bufferp = bufferp;
1319         op->buffers[i].refcount = 1; /* start with one ref */
1320         op->buffers[i].flags = CM_DIROPBUFF_INUSE;
1321
1322         op->nBuffers++;
1323
1324         osi_Log0(afsd_logp, "cm_DirOpAddBuffer: returning success");
1325
1326         return 0;
1327     }
1328 }
1329
1330 /* Note: Called without op->scp->rw */
1331 static int
1332 cm_DirOpFindBuffer(cm_dirOp_t * op, osi_hyper_t offset, cm_buf_t ** bufferpp)
1333 {
1334     int i;
1335
1336     for (i=0; i < CM_DIROP_MAXBUFFERS; i++) {
1337         if ((op->buffers[i].flags & CM_DIROPBUFF_INUSE) &&
1338             LargeIntegerEqualTo(op->buffers[i].bufferp->offset, offset))
1339             break;
1340     }
1341
1342     if (i < CM_DIROP_MAXBUFFERS) {
1343         /* found it */
1344         op->buffers[i].refcount++;
1345         buf_Hold(op->buffers[i].bufferp);
1346         *bufferpp = op->buffers[i].bufferp;
1347
1348         osi_Log2(afsd_logp, "cm_DirOpFindBuffer: found buffer for offset [%x:%x]",
1349                  offset.HighPart, offset.LowPart);
1350         return 1;
1351     }
1352
1353     osi_Log2(afsd_logp, "cm_DirOpFindBuffer: buffer not found for offset [%x:%x]",
1354              offset.HighPart, offset.LowPart);
1355     return 0;
1356 }
1357
1358
1359 /* NOTE: called with scp->rw held or not depending on the flags */
1360 static int
1361 cm_DirOpDelBuffer(cm_dirOp_t * op, cm_buf_t * bufferp, int flags)
1362 {
1363     int i;
1364
1365     osi_Log3(afsd_logp, "cm_DirOpDelBuffer for op 0x%p, buffer 0x%p, flags=%d",
1366              op, bufferp, flags);
1367
1368     for (i=0; i < CM_DIROP_MAXBUFFERS; i++) {
1369         if ((op->buffers[i].flags & CM_DIROPBUFF_INUSE) &&
1370             op->buffers[i].bufferp == bufferp)
1371             break;
1372     }
1373
1374     if (i < CM_DIROP_MAXBUFFERS) {
1375
1376         if (flags & DIROP_MODIFIED)
1377             op->dirtyBufCount++;
1378
1379         osi_assert(op->buffers[i].refcount > 0);
1380         op->buffers[i].refcount --;
1381
1382         if (op->buffers[i].refcount == 0) {
1383             /* this was the last reference we had */
1384
1385             osi_Log0(afsd_logp, "cm_DirOpDelBuffer: releasing buffer");
1386
1387             /* if this buffer was modified, then we update the data
1388                version of the buffer with the data version of the
1389                scp. */
1390             if (!(flags & DIROP_SCPLOCKED)) {
1391                 lock_ObtainWrite(&op->scp->rw);
1392             }
1393
1394             /* first make sure that the buffer is idle.  It should
1395                have been idle all along. */
1396             osi_assertx((bufferp->cmFlags & (CM_BUF_CMFETCHING |
1397                                             CM_BUF_CMSTORING)) == 0,
1398                         "Buffer is not idle while performing dirOp");
1399
1400             cm_SyncOpDone(op->scp, bufferp,
1401                           CM_SCACHESYNC_NEEDCALLBACK |
1402                          (op->lockType == CM_DIRLOCK_WRITE ? CM_SCACHESYNC_WRITE : CM_SCACHESYNC_READ));
1403
1404 #ifdef DEBUG
1405             osi_assert(bufferp->dataVersion == op->dataVersion);
1406 #endif
1407
1408             lock_ReleaseWrite(&op->scp->rw);
1409
1410             lock_ObtainMutex(&bufferp->mx);
1411
1412             if (flags & DIROP_SCPLOCKED) {
1413                 lock_ObtainWrite(&op->scp->rw);
1414             }
1415
1416             if (flags & DIROP_MODIFIED) {
1417                 /* We don't update the dataversion here.  Instead we
1418                    wait until the dirOp is completed and then flip the
1419                    dataversion on all the buffers in one go.
1420                    Otherwise we won't know if the dataversion is
1421                    current because it was fetched from the server or
1422                    because we touched it during the dirOp. */
1423
1424                 if (bufferp->userp != op->userp) {
1425                     if (bufferp->userp != NULL)
1426                         cm_ReleaseUser(bufferp->userp);
1427                     cm_HoldUser(op->userp);
1428                     bufferp->userp = op->userp;
1429                 }
1430             }
1431
1432             lock_ReleaseMutex(&bufferp->mx);
1433
1434             op->buffers[i].bufferp = NULL;
1435             buf_Release(bufferp);
1436             op->buffers[i].flags = 0;
1437
1438             op->nBuffers--;
1439
1440             return 1;
1441         } else {
1442             /* we have other references to this buffer. so we have to
1443                let it be */
1444             return 0;
1445         }
1446
1447     } else {
1448         osi_Log0(afsd_logp, "cm_DirOpDelBuffer: buffer not found");
1449         osi_assertx(FALSE, "Attempt to delete a non-existent buffer from a dirOp");
1450         return -1;
1451     }
1452 }
1453
1454 /* Check if we have current status and a callback for the given scp.
1455    This should be called before cm_DirGetPage() is called per scp.
1456
1457    On entry:
1458      scp->rw locked state indicated by parameter
1459
1460    On exit:
1461      scp->rw same state as upon entry
1462
1463    During:
1464      scp->rw may be released
1465  */
1466 static long
1467 cm_DirCheckStatus(cm_dirOp_t * op, int scp_locked)
1468 {
1469     long code;
1470
1471     if (!scp_locked)
1472         lock_ObtainWrite(&op->scp->rw);
1473     code = cm_SyncOp(op->scp, NULL, op->userp, &op->req, PRSFS_LOOKUP,
1474                      CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
1475     if (!scp_locked)
1476         lock_ReleaseWrite(&op->scp->rw);
1477
1478     osi_Log2(afsd_logp, "cm_DirCheckStatus for op 0x%p returning code 0x%x",
1479              op, code);
1480
1481     return code;
1482 }
1483
1484 /* Attempt to prefetch all the buffers for this operation.
1485
1486    Called with scp->rw unlocked
1487  */
1488 static long
1489 cm_DirPrefetchBuffers(cm_dirOp_t * op)
1490 {
1491     long code = 0;
1492     osi_hyper_t offset;
1493     cm_buf_t *bufferp = NULL;
1494
1495     osi_Log1(afsd_logp, "cm_DirPrefetchBuffers for op 0x%p", op);
1496
1497     /* prefetching is only done on read operations where we don't
1498        expect the data version to change. */
1499     if (op->dataVersion != op->newDataVersion) {
1500         osi_Log0(afsd_logp, "Skipping prefetch for write operation.");
1501         return CM_ERROR_INVAL;
1502     }
1503
1504     lock_ObtainWrite(&op->scp->rw);
1505
1506     /* When we are prefetching a file, we first flush out any of its
1507        contents just to make sure that we don't end up with buffers
1508        that was locally modified. */
1509
1510     if (op->scp->flags & CM_SCACHEFLAG_LOCAL)
1511         op->scp->bufDataVersionLow = op->scp->dataVersion;
1512
1513     offset = ConvertLongToLargeInteger(0);
1514     while (LargeIntegerLessThan(offset, op->scp->length)) {
1515         osi_Log2(afsd_logp, "Trying prefetch for offset %08x:%08x",
1516                  offset.HighPart, offset.LowPart);
1517         lock_ReleaseWrite(&op->scp->rw);
1518
1519         code = buf_Get(op->scp, &offset, &op->req, &bufferp);
1520
1521         lock_ObtainWrite(&op->scp->rw);
1522
1523         if (code)
1524             break;
1525
1526         while (1) {
1527
1528             code = cm_SyncOp(op->scp, bufferp, op->userp, &op->req, PRSFS_LOOKUP,
1529                              CM_SCACHESYNC_NEEDCALLBACK |
1530                              (op->lockType == CM_DIRLOCK_WRITE ? CM_SCACHESYNC_WRITE : CM_SCACHESYNC_READ));
1531
1532             if (code)
1533                 break;
1534
1535             cm_SyncOpDone(op->scp, bufferp, CM_SCACHESYNC_NEEDCALLBACK |
1536                           (op->lockType == CM_DIRLOCK_WRITE ? CM_SCACHESYNC_WRITE : CM_SCACHESYNC_READ));
1537
1538             if (cm_HaveBuffer(op->scp, bufferp, 0))
1539                 break;
1540
1541             code = cm_GetBuffer(op->scp, bufferp, NULL, op->userp, &op->req);
1542             if (code)
1543                 break;
1544         }
1545
1546         if (code)
1547             break;
1548
1549         if (bufferp) {
1550             buf_Release(bufferp);
1551             bufferp = NULL;
1552         }
1553
1554         offset = LargeIntegerAdd(offset, ConvertLongToLargeInteger(cm_data.buf_blockSize));
1555     }
1556
1557  done:
1558     lock_ReleaseWrite(&op->scp->rw);
1559
1560     osi_Log1(afsd_logp, "cm_DirPrefetchBuffers returning code 0x%x", code);
1561
1562     return code;
1563 }
1564
1565 /* Release a directory buffer that was obtained via a call to
1566    cm_DirGetPage() or any other function that returns a locked, held,
1567    directory page buffer.
1568
1569    Called with scp->rw unlocked
1570  */
1571 static long
1572 cm_DirReleasePage(cm_dirOp_t * op, cm_buf_t ** bufferpp, int modified)
1573 {
1574     long code = 0;
1575
1576     if (!*bufferpp)
1577         return EINVAL;
1578
1579     cm_DirOpDelBuffer(op, *bufferpp,
1580                       ((modified ? DIROP_MODIFIED : 0)));
1581     buf_Release(*bufferpp);
1582     *bufferpp = NULL;
1583
1584     return code;
1585 }
1586
1587 /*
1588    Returns the index'th directory page from scp.  The userp and reqp
1589    will be used to fetch the buffer from the fileserver if necessary.
1590    If the call is successful, a locked and held cm_buf_t is returned
1591    via buferpp and a pointer to the directory page is returned via
1592    datapp.
1593
1594    The returned buffer should be released via a call to
1595    cm_DirReleasePage() or by passing it into a subsequent call to
1596    cm_DirGetPage() for the *same* scp.
1597
1598    If a *locked* buffer for the *same* scp is passed in via bufferpp
1599    to the function, it will check if the requested directory page is
1600    located in the specified buffer.  If not, the buffer will be
1601    released and a new buffer returned that contains the requested
1602    page.
1603
1604    If the specified page exists beyond the EOF for the scp, a new
1605    buffer will be allocated only if create is set to TRUE.
1606
1607    Note: If a buffer is specified on entry via bufferpp, it is assumed
1608    that the buffer is unmodified.  If the buffer is modified, it
1609    should be released via cm_DirReleasePage().
1610
1611    On entry:
1612      scp->rw unlocked.
1613      If *bufferpp is non-NULL, then *bufferpp->mx is locked.
1614
1615    On exit:
1616      scp->rw unlocked
1617      If *bufferpp is non-NULL, then *bufferpp->mx is locked.
1618
1619    During:
1620      scp->rw will be obtained and released
1621
1622  */
1623 static long
1624 cm_DirGetPage(cm_dirOp_t * op,
1625               long index, cm_buf_t ** bufferpp, void ** datapp)
1626 {
1627     osi_hyper_t pageOffset;     /* offset of the dir page from the
1628                                    start of the directory */
1629     osi_hyper_t bufferOffset;   /* offset of the buffer from the start
1630                                    of the directory */
1631     osi_hyper_t thyper;
1632
1633     cm_buf_t * bufferp = NULL;
1634
1635     void * datap = NULL;
1636
1637     long code = 0;
1638
1639     osi_Log2(afsd_logp, "cm_DirGetPage for op 0x%p, index %d", op, index);
1640
1641     pageOffset = ConvertLongToLargeInteger(index * CM_DIR_PAGESIZE);
1642     bufferOffset.HighPart = pageOffset.HighPart;
1643     bufferOffset.LowPart = pageOffset.LowPart & ~(cm_data.buf_blockSize - 1);
1644
1645     bufferp = *bufferpp;
1646     if (bufferp != NULL) {
1647         osi_assert(cm_FidCmp(&bufferp->fid, &op->scp->fid) == 0);
1648
1649         thyper = bufferp->offset;
1650     }
1651
1652     if (!bufferp || !LargeIntegerEqualTo(thyper, bufferOffset)) {
1653         /* wrong buffer */
1654
1655         if (bufferp) {
1656             buf_Release(bufferp);
1657             cm_DirOpDelBuffer(op, bufferp, 0);
1658             bufferp = NULL;
1659         }
1660
1661         /* first check if we are already working with the buffer */
1662         if (cm_DirOpFindBuffer(op, bufferOffset, &bufferp)) {
1663             code = 0;
1664             goto _has_buffer;
1665         }
1666
1667         code = buf_Get(op->scp, &bufferOffset, &op->req, &bufferp);
1668         if (code) {
1669             osi_Log1(afsd_logp, "    buf_Get returned code 0x%x", code);
1670             bufferp = NULL;
1671             goto _exit;
1672         }
1673
1674         osi_assert(bufferp != NULL);
1675
1676         /* DirOpAddBuffer will obtain bufferp->mx if necessary */
1677         code = cm_DirOpAddBuffer(op, bufferp);
1678
1679         if (code != 0) {
1680             /* for some reason, the buffer was rejected.  We can't use
1681                this buffer, and since this is the only buffer we can
1682                potentially use, there's no recourse.*/
1683             buf_Release(bufferp);
1684             bufferp = NULL;
1685             goto _exit;
1686         }
1687     }
1688
1689  _has_buffer:
1690
1691     /* now to figure out where the data is */
1692     thyper = LargeIntegerSubtract(pageOffset, bufferOffset);
1693
1694     osi_assert(thyper.HighPart == 0);
1695     osi_assert(cm_data.buf_blockSize > thyper.LowPart &&
1696                cm_data.buf_blockSize - thyper.LowPart >= CM_DIR_PAGESIZE);
1697
1698     datap = (void *) (((char *)bufferp->datap) + thyper.LowPart);
1699
1700     if (datapp)
1701         *datapp = datap;
1702
1703     /* also, if we are writing past EOF, we should make a note of the
1704        new length */
1705     thyper = LargeIntegerAdd(pageOffset,
1706                              ConvertLongToLargeInteger(CM_DIR_PAGESIZE));
1707     if (LargeIntegerLessThan(op->newLength, thyper)) {
1708         op->newLength = thyper;
1709     }
1710
1711  _exit:
1712
1713     *bufferpp = bufferp;
1714
1715     osi_Log1(afsd_logp, "cm_DirGetPage returning code 0x%x", code);
1716
1717     return code;
1718 }
1719
1720
1721 void
1722 cm_DirEntryListAdd(char * namep, cm_dirEntryList_t ** list)
1723 {
1724     size_t len;
1725     cm_dirEntryList_t * entry;
1726
1727     len = strlen(namep);
1728     len += sizeof(cm_dirEntryList_t);
1729
1730     entry = malloc(len);
1731     if (entry) {
1732         entry->nextp = *list;
1733         strcpy(entry->name, namep);
1734         *list = entry;
1735     }
1736 }
1737
1738 void
1739 cm_DirEntryListFree(cm_dirEntryList_t ** list)
1740 {
1741     cm_dirEntryList_t * entry;
1742     cm_dirEntryList_t * next;
1743
1744     for (entry = *list; entry; entry = next) {
1745         next = entry->nextp;
1746         free(entry);
1747     }
1748
1749     *list = NULL;
1750 }
1751