death-to-remaining-longc-procs-20060804
[openafs.git] / src / dir / 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 <afsconfig.h>
11 #include <afs/param.h>
12
13 RCSID
14     ("$Header$");
15
16 #ifdef KERNEL
17 #if !defined(UKERNEL)
18 #include "h/types.h"
19 #include "h/param.h"
20 #ifdef  AFS_AUX_ENV
21 #include "h/mmu.h"
22 #include "h/seg.h"
23 #include "h/sysmacros.h"
24 #include "h/signal.h"
25 #include "h/errno.h"
26 #endif
27 #include "h/time.h"
28 #if defined(AFS_AIX_ENV) || defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_LINUX20_ENV)
29 #include "h/errno.h"
30 #else
31 #if !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV)
32 #include "h/kernel.h"
33 #endif
34 #endif
35 #if     defined(AFS_SUN56_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_FBSD_ENV) || defined(AFS_DARWIN80_ENV)
36 #include "afs/sysincludes.h"
37 #endif
38 #if !defined(AFS_SGI64_ENV) && !defined(AFS_DARWIN60_ENV)
39 #include "h/user.h"
40 #endif /* AFS_SGI64_ENV */
41 #include "h/uio.h"
42 #ifdef  AFS_OSF_ENV
43 #include <sys/mount.h>
44 #include <sys/vnode.h>
45 #include <ufs/inode.h>
46 #endif
47 #if !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_HPUX110_ENV)
48 #include "h/mbuf.h"
49 #endif
50 #ifndef AFS_LINUX20_ENV
51 #include "netinet/in.h"
52 #endif
53
54 /* afs_buffer.c */
55 /* These are needed because afs_prototypes.h is not included here */
56 extern void *DRead();
57 extern void *DNew();
58
59 #else /* !defined(UKERNEL) */
60 #include "afs/stds.h"
61 #include "afs/sysincludes.h"
62
63 /* afs_buffer.c */
64 /* These are needed because afs_prototypes.h is not included here */
65 extern void *DRead();
66 extern void *DNew();
67
68 #endif /* !defined(UKERNEL) */
69 #include "afs/afs_osi.h"
70
71 #include "afs/dir.h"
72
73 #ifdef AFS_LINUX20_ENV
74 #include "h/string.h"
75 #endif
76
77 /* generic renaming */
78 #define NameBlobs       afs_dir_NameBlobs
79 #define GetBlob         afs_dir_GetBlob
80 #define Create          afs_dir_Create
81 #define Length          afs_dir_Length
82 #define Delete          afs_dir_Delete
83 #define MakeDir         afs_dir_MakeDir
84 #define Lookup          afs_dir_Lookup
85 #define LookupOffset    afs_dir_LookupOffset
86 #define EnumerateDir    afs_dir_EnumerateDir
87 #define IsEmpty         afs_dir_IsEmpty
88 #else /* KERNEL */
89
90 # ifdef HAVE_UNISTD_H
91 #  include <unistd.h>
92 # endif
93 # include <sys/types.h>
94 # include <errno.h>
95 # include "dir.h"
96 #ifdef AFS_NT40_ENV
97 #include <winsock2.h>
98 #else
99 #include <netinet/in.h>
100 #endif
101
102 #ifdef HAVE_STRING_H
103 #include <string.h>
104 #else
105 #ifdef HAVE_STRINGS_H
106 #include <strings.h>
107 #endif
108 #endif
109 #endif /* KERNEL */
110
111 afs_int32 DErrno;
112
113 /* Local static prototypes */
114 static struct DirEntry *FindItem(void *dir, char *ename,
115                                  unsigned short **previtem);
116
117
118 int
119 NameBlobs(char *name)
120 {                               /* Find out how many entries are required to store a name. */
121     register int i;
122     i = strlen(name) + 1;
123     return 1 + ((i + 15) >> 5);
124 }
125
126 /* Create an entry in a file.  Dir is a file representation, while entry is a string name. */
127
128 int
129 Create(void *dir, char *entry, void *voidfid)
130 {
131     afs_int32 *vfid = (afs_int32 *) voidfid;
132     int blobs, firstelt;
133     register int i;
134     register struct DirEntry *ep;
135     unsigned short *pp = NULL;
136     register struct DirHeader *dhp;
137
138     /* check name quality */
139     if (*entry == 0)
140         return EINVAL;
141     /* First check if file already exists. */
142     ep = FindItem(dir, entry, &pp);
143     if (ep) {
144         DRelease(ep, 0);
145         DRelease(pp, 0);
146         return EEXIST;
147     }
148     blobs = NameBlobs(entry);   /* number of entries required */
149     firstelt = FindBlobs(dir, blobs);
150     if (firstelt < 0)
151         return EFBIG;           /* directory is full */
152     /* First, we fill in the directory entry. */
153     ep = GetBlob(dir, firstelt);
154     if (ep == 0)
155         return EIO;
156     ep->flag = FFIRST;
157     ep->fid.vnode = htonl(vfid[1]);
158     ep->fid.vunique = htonl(vfid[2]);
159     strcpy(ep->name, entry);
160     /* Now we just have to thread it on the hash table list. */
161     dhp = (struct DirHeader *)DRead(dir, 0);
162     if (!dhp) {
163         DRelease(ep, 1);
164         return EIO;
165     }
166     i = DirHash(entry);
167     ep->next = dhp->hashTable[i];
168     dhp->hashTable[i] = htons(firstelt);
169     DRelease(dhp, 1);
170     DRelease(ep, 1);
171     return 0;
172 }
173
174 int
175 Length(void *dir)
176 {
177     int i, ctr;
178     struct DirHeader *dhp;
179     dhp = (struct DirHeader *)DRead(dir, 0);
180     if (!dhp)
181         return 0;
182     if (dhp->header.pgcount != 0)
183         ctr = ntohs(dhp->header.pgcount);
184     else {
185         /* old style, count the pages */
186         ctr = 0;
187         for (i = 0; i < MAXPAGES; i++)
188             if (dhp->alloMap[i] != EPP)
189                 ctr++;
190     }
191     DRelease(dhp, 0);
192     return ctr * AFS_PAGESIZE;
193 }
194
195 int
196 Delete(void *dir, char *entry)
197 {
198     /* Delete an entry from a directory, including update of all free entry descriptors. */
199     int nitems, index;
200     register struct DirEntry *firstitem;
201     unsigned short *previtem;
202     firstitem = FindItem(dir, entry, &previtem);
203     if (firstitem == 0)
204         return ENOENT;
205     *previtem = firstitem->next;
206     DRelease(previtem, 1);
207     index = DVOffset(firstitem) / 32;
208     nitems = NameBlobs(firstitem->name);
209     DRelease(firstitem, 0);
210     FreeBlobs(dir, index, nitems);
211     return 0;
212 }
213
214 int
215 FindBlobs(void *dir, int nblobs)
216 {
217     /* Find a bunch of contiguous entries; at least nblobs in a row. */
218     register int i, j, k;
219     int failed = 0;
220     register struct DirHeader *dhp;
221     struct PageHeader *pp;
222     int pgcount;
223
224     dhp = (struct DirHeader *)DRead(dir, 0);    /* read the dir header in first. */
225     if (!dhp)
226         return -1;
227     for (i = 0; i < BIGMAXPAGES; i++) {
228         if (i >= MAXPAGES || dhp->alloMap[i] >= nblobs) {
229             /* if page could contain enough entries */
230             /* If there are EPP free entries, then the page is not even allocated. */
231             if (i >= MAXPAGES) {
232                 /* this pages exists past the end of the old-style dir */
233                 pgcount = ntohs(dhp->header.pgcount);
234                 if (pgcount == 0) {
235                     pgcount = MAXPAGES;
236                     dhp->header.pgcount = htons(pgcount);
237                 }
238                 if (i > pgcount - 1) {
239                     /* this page is bigger than last allocated page */
240                     AddPage(dir, i);
241                     dhp->header.pgcount = htons(i + 1);
242                 }
243             } else if (dhp->alloMap[i] == EPP) {
244                 /* Add the page to the directory. */
245                 AddPage(dir, i);
246                 dhp->alloMap[i] = EPP - 1;
247                 dhp->header.pgcount = htons(i + 1);
248             }
249             pp = (struct PageHeader *)DRead(dir, i);    /* read the page in. */
250             if (!pp) {
251                 DRelease(dhp, 1);
252                 break;
253             }
254             for (j = 0; j <= EPP - nblobs; j++) {
255                 failed = 0;
256                 for (k = 0; k < nblobs; k++)
257                     if ((pp->freebitmap[(j + k) >> 3] >> ((j + k) & 7)) & 1) {
258                         failed = 1;
259                         break;
260                     }
261                 if (!failed)
262                     break;
263                 failed = 1;
264             }
265             if (!failed) {
266                 /* Here we have the first index in j.  We update the allocation maps
267                  * and free up any resources we've got allocated. */
268                 if (i < MAXPAGES)
269                     dhp->alloMap[i] -= nblobs;
270                 DRelease(dhp, 1);
271                 for (k = 0; k < nblobs; k++)
272                     pp->freebitmap[(j + k) >> 3] |= 1 << ((j + k) & 7);
273                 DRelease(pp, 1);
274                 return j + i * EPP;
275             }
276             DRelease(pp, 0);    /* This dir page is unchanged. */
277         }
278     }
279     /* If we make it here, the directory is full. */
280     DRelease(dhp, 1);
281     return -1;
282 }
283
284 void
285 AddPage(void *dir, int pageno)
286 {                               /* Add a page to a directory. */
287     register int i;
288     register struct PageHeader *pp;
289
290     pp = (struct PageHeader *)DNew(dir, pageno);        /* Get a new buffer labelled dir,pageno */
291     pp->tag = htons(1234);
292     if (pageno > 0)
293         pp->pgcount = 0;
294     pp->freecount = EPP - 1;    /* The first dude is already allocated */
295     pp->freebitmap[0] = 0x01;
296     for (i = 1; i < EPP / 8; i++)       /* It's a constant */
297         pp->freebitmap[i] = 0;
298     DRelease(pp, 1);
299 }
300
301 /* Free a whole bunch of directory entries. */
302
303 void
304 FreeBlobs(void *dir, register int firstblob, int nblobs)
305 {
306     register int i;
307     int page;
308     struct DirHeader *dhp;
309     struct PageHeader *pp;
310     page = firstblob / EPP;
311     firstblob -= EPP * page;    /* convert to page-relative entry */
312     dhp = (struct DirHeader *)DRead(dir, 0);
313     if (!dhp)
314         return;
315     if (page < MAXPAGES)
316         dhp->alloMap[page] += nblobs;
317     DRelease(dhp, 1);
318     pp = (struct PageHeader *)DRead(dir, page);
319     if (pp)
320         for (i = 0; i < nblobs; i++)
321             pp->freebitmap[(firstblob + i) >> 3] &=
322                 ~(1 << ((firstblob + i) & 7));
323     DRelease(pp, 1);
324 }
325
326 /*
327  * Format an empty directory properly.  Note that the first 13 entries in a
328  * directory header page are allocated, 1 to the page header, 4 to the
329  * allocation map and 8 to the hash table.
330  */
331 int
332 MakeDir(void *dir, afs_int32 * me, afs_int32 * parent)
333 {
334     register int i;
335     register struct DirHeader *dhp;
336     dhp = (struct DirHeader *)DNew(dir, 0);
337     dhp->header.pgcount = htons(1);
338     dhp->header.tag = htons(1234);
339     dhp->header.freecount = (EPP - DHE - 1);
340     dhp->header.freebitmap[0] = 0xff;
341     dhp->header.freebitmap[1] = 0x1f;
342     for (i = 2; i < EPP / 8; i++)
343         dhp->header.freebitmap[i] = 0;
344     dhp->alloMap[0] = (EPP - DHE - 1);
345     for (i = 1; i < MAXPAGES; i++)
346         dhp->alloMap[i] = EPP;
347     for (i = 0; i < NHASHENT; i++)
348         dhp->hashTable[i] = 0;
349     DRelease(dhp, 1);
350     Create(dir, ".", me);
351     Create(dir, "..", parent);  /* Virtue is its own .. */
352     return 0;
353 }
354
355 /* Look up a file name in directory. */
356
357 int
358 Lookup(void *dir, char *entry, void *voidfid)
359 {
360     afs_int32 *fid = (afs_int32 *) voidfid;
361     register struct DirEntry *firstitem;
362     unsigned short *previtem;
363
364     firstitem = FindItem(dir, entry, &previtem);
365     if (firstitem == 0)
366         return ENOENT;
367     DRelease(previtem, 0);
368     fid[1] = ntohl(firstitem->fid.vnode);
369     fid[2] = ntohl(firstitem->fid.vunique);
370     DRelease(firstitem, 0);
371     return 0;
372 }
373
374 /* Look up a file name in directory. */
375
376 int
377 LookupOffset(void *dir, char *entry, void *voidfid, long *offsetp)
378 {
379     afs_int32 *fid = (afs_int32 *) voidfid;
380     register struct DirEntry *firstitem;
381     unsigned short *previtem;
382
383     firstitem = FindItem(dir, entry, &previtem);
384     if (firstitem == 0)
385         return ENOENT;
386     DRelease(previtem, 0);
387     fid[1] = ntohl(firstitem->fid.vnode);
388     fid[2] = ntohl(firstitem->fid.vunique);
389     if (offsetp)
390         *offsetp = DVOffset(firstitem);
391     DRelease(firstitem, 0);
392     return 0;
393 }
394
395 int
396 EnumerateDir(void *dir, int (*hookproc) (), void *hook)
397 {
398     /* Enumerate the contents of a directory. */
399     register int i;
400     int num;
401     register struct DirHeader *dhp;
402     register struct DirEntry *ep;
403
404     dhp = (struct DirHeader *)DRead(dir, 0);
405     if (!dhp)
406         return EIO;             /* first page should be there */
407     for (i = 0; i < NHASHENT; i++) {
408         /* For each hash chain, enumerate everyone on the list. */
409         num = ntohs(dhp->hashTable[i]);
410         while (num != 0) {
411             /* Walk down the hash table list. */
412             DErrno = 0;
413             ep = GetBlob(dir, num);
414             if (!ep) {
415                 if (DErrno) {
416                     /* we failed, return why */
417                     DRelease(dhp, 0);
418                     return DErrno;
419                 }
420                 break;
421             }
422             num = ntohs(ep->next);
423             (*hookproc) (hook, ep->name, ntohl(ep->fid.vnode),
424                          ntohl(ep->fid.vunique));
425             DRelease(ep, 0);
426         }
427     }
428     DRelease(dhp, 0);
429     return 0;
430 }
431
432 int
433 IsEmpty(void *dir)
434 {
435     /* Enumerate the contents of a directory. */
436     register int i;
437     int num;
438     register struct DirHeader *dhp;
439     register struct DirEntry *ep;
440     dhp = (struct DirHeader *)DRead(dir, 0);
441     if (!dhp)
442         return 0;
443     for (i = 0; i < NHASHENT; i++) {
444         /* For each hash chain, enumerate everyone on the list. */
445         num = ntohs(dhp->hashTable[i]);
446         while (num != 0) {
447             /* Walk down the hash table list. */
448             ep = GetBlob(dir, num);
449             if (!ep)
450                 break;
451             if (strcmp(ep->name, "..") && strcmp(ep->name, ".")) {
452                 DRelease(ep, 0);
453                 DRelease(dhp, 0);
454                 return 1;
455             }
456             num = ntohs(ep->next);
457             DRelease(ep, 0);
458         }
459     }
460     DRelease(dhp, 0);
461     return 0;
462 }
463
464 struct DirEntry *
465 GetBlob(void *dir, afs_int32 blobno)
466 {
467     /* Return a pointer to an entry, given its number. */
468     struct DirEntry *ep;
469     ep = DRead(dir, blobno >> LEPP);
470     if (!ep)
471         return 0;
472     return (struct DirEntry *)(((long)ep) + 32 * (blobno & (EPP - 1)));
473 }
474
475 int
476 DirHash(register char *string)
477 {
478     /* Hash a string to a number between 0 and NHASHENT. */
479     register unsigned char tc;
480     register int hval;
481     register int tval;
482     hval = 0;
483     while ((tc = (*string++))) {
484         hval *= 173;
485         hval += tc;
486     }
487     tval = hval & (NHASHENT - 1);
488     if (tval == 0)
489         return tval;
490     else if (hval < 0)
491         tval = NHASHENT - tval;
492     return tval;
493 }
494
495 static struct DirEntry *
496 FindItem(void *dir, char *ename, unsigned short **previtem)
497 {
498     /* Find a directory entry, given its name.  This entry returns a pointer to a locked buffer, and a pointer to a locked buffer (in previtem) referencing the found item (to aid the delete code).  If no entry is found, however, no items are left locked, and a null pointer is returned instead. */
499     register int i;
500     register struct DirHeader *dhp;
501     register unsigned short *lp;
502     register struct DirEntry *tp;
503     i = DirHash(ename);
504     dhp = (struct DirHeader *)DRead(dir, 0);
505     if (!dhp)
506         return 0;
507     if (dhp->hashTable[i] == 0) {
508         /* no such entry */
509         DRelease(dhp, 0);
510         return 0;
511     }
512     tp = GetBlob(dir, (u_short) ntohs(dhp->hashTable[i]));
513     if (!tp) {
514         DRelease(dhp, 0);
515         return 0;
516     }
517     lp = &(dhp->hashTable[i]);
518     while (1) {
519         /* Look at each hash conflict entry. */
520         if (!strcmp(ename, tp->name)) {
521             /* Found our entry. */
522             *previtem = lp;
523             return tp;
524         }
525         DRelease(lp, 0);
526         lp = &(tp->next);
527         if (tp->next == 0) {
528             /* The end of the line */
529             DRelease(lp, 0);    /* Release all locks. */
530             return 0;
531         }
532         tp = GetBlob(dir, (u_short) ntohs(tp->next));
533         if (!tp) {
534             DRelease(lp, 0);
535             return 0;
536         }
537     }
538 }