2 * Copyright 2000, International Business Machines Corporation and others.
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
10 #include <afsconfig.h>
11 #include <afs/param.h>
17 #include "../h/types.h"
18 #include "../h/param.h"
22 #include "../h/sysmacros.h"
23 #include "../h/signal.h"
24 #include "../h/errno.h"
26 #include "../h/time.h"
27 #if defined(AFS_AIX_ENV) || defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_FBSD_ENV)
28 #include "../h/errno.h"
30 #if !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV)
31 #include "../h/kernel.h"
34 #if defined(AFS_SUN56_ENV) || defined(AFS_HPUX_ENV)
35 #include "../afs/sysincludes.h"
38 #if defined(AFS_FBSD_ENV)
39 #include "../h/lock.h"
41 #include "../vm/vm_extern.h"
42 #include "../vm/pmap.h"
43 #include "../vm/vm_map.h"
44 #endif /* AFS_FBSD_ENV */
45 #include "../h/user.h"
46 #endif /* AFS_SGI64_ENV */
49 #include "../afs/gfs_vfs.h"
50 #include "../afs/gfs_vnode.h"
55 #include <sys/vnode.h>
56 #include <ufs/inode.h>
59 #include <vfs/vnode.h>
60 #include <sys/inode.h>
62 #else /* AFS_MACH_ENV */
64 #include <sys/mount.h>
65 #include <sys/vnode.h>
66 #include <ufs/inode.h>
67 #else /* AFS_OSF_ENV */
70 #if !defined(AFS_SGI_ENV)
72 #endif /* AFS_OSF_ENV */
73 #endif /* AFS_MACH_ENV */
76 #ifndef AFS_LINUX20_ENV
77 #include "../netinet/in.h"
79 #if !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV)
80 #include "../h/mbuf.h"
82 #else /* !defined(UKERNEL) */
83 #include "../afs/stds.h"
84 #include "../afs/sysincludes.h"
85 #endif /* !defined(UKERNEL) */
86 #include "../afs/afs_osi.h"
88 #include "../afs/dir.h"
90 #include "../afs/longc_procs.h"
91 #ifdef AFS_LINUX20_ENV
92 #include "../h/string.h"
95 /* generic renaming */
96 #define NameBlobs afs_dir_NameBlobs
97 #define GetBlob afs_dir_GetBlob
98 #define Create afs_dir_Create
99 #define Length afs_dir_Length
100 #define Delete afs_dir_Delete
101 #define MakeDir afs_dir_MakeDir
102 #define Lookup afs_dir_Lookup
103 #define LookupOffset afs_dir_LookupOffset
104 #define EnumerateDir afs_dir_EnumerateDir
105 #define IsEmpty afs_dir_IsEmpty
108 # include <sys/types.h>
112 #include <winsock2.h>
114 #include <netinet/in.h>
120 static struct DirEntry *FindItem();
121 struct DirEntry *GetBlob();
122 struct DirEntry *DRead();
123 struct DirEntry *DNew();
129 char * name; {/* Find out how many entries are required to store a name. */
132 return 1+((i+15)>>5);
135 int Create (dir, entry, vfid)
139 /* Create an entry in a file. Dir is a file representation, while entry is a string name. */
142 register struct DirEntry *ep;
143 unsigned short *pp = NULL;
144 register struct DirHeader *dhp;
146 /* check name quality */
147 if (*entry == 0) return EINVAL;
148 /* First check if file already exists. */
149 ep = FindItem(dir,entry,&pp);
155 blobs = NameBlobs(entry); /* number of entries required */
156 firstelt = FindBlobs(dir,blobs);
157 if (firstelt < 0) return EFBIG; /* directory is full */
158 /* First, we fill in the directory entry. */
159 ep = GetBlob(dir,firstelt);
160 if (ep == 0) return EIO;
162 ep->fid.vnode = htonl(vfid[1]);
163 ep->fid.vunique = htonl(vfid[2]);
164 strcpy(ep->name,entry);
165 /* Now we just have to thread it on the hash table list. */
166 dhp = (struct DirHeader *) DRead(dir,0);
172 ep->next = dhp->hashTable[i];
173 dhp->hashTable[i] = htons(firstelt);
182 struct DirHeader *dhp;
183 dhp = (struct DirHeader *) DRead(dir,0);
185 if (dhp->header.pgcount != 0) ctr = ntohs(dhp->header.pgcount);
187 /* old style, count the pages */
189 for(i=0;i<MAXPAGES;i++)
190 if (dhp->alloMap[i] != EPP) ctr++;
193 return ctr*AFS_PAGESIZE;
199 /* Delete an entry from a directory, including update of all free entry descriptors. */
201 register struct DirEntry *firstitem;
202 unsigned short *previtem;
203 firstitem = FindItem(dir,entry,&previtem);
204 if (firstitem == 0) 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);
214 FindBlobs (dir,nblobs)
217 /* Find a bunch of contiguous entries; at least nblobs in a row. */
218 register int i, j, k;
220 register struct DirHeader *dhp;
221 struct PageHeader *pp;
224 dhp = (struct DirHeader *) DRead(dir,0); /* read the dir header in first. */
226 for(i=0;i<BIGMAXPAGES;i++) {
227 if (i >= MAXPAGES || dhp->alloMap[i] >= nblobs) {
228 /* if page could contain enough entries */
229 /* If there are EPP free entries, then the page is not even allocated. */
231 /* this pages exists past the end of the old-style dir */
232 pgcount = ntohs(dhp->header.pgcount);
235 dhp->header.pgcount = htons(pgcount);
237 if (i > pgcount - 1) {
238 /* this page is bigger than last allocated page */
240 dhp->header.pgcount = htons(i+1);
243 else if (dhp->alloMap[i] == EPP) {
244 /* Add the page to the directory. */
246 dhp->alloMap[i] = EPP-1;
247 dhp->header.pgcount = htons(i+1);
249 pp = (struct PageHeader *) DRead(dir,i); /* read the page in. */
254 for(j=0;j<=EPP-nblobs;j++) {
256 for(k=0;k<nblobs;k++)
257 if ((pp->freebitmap[(j+k)>>3]>>((j+k)&7)) & 1) {
265 /* Here we have the first index in j. We update the allocation maps
266 and free up any resources we've got allocated. */
267 if (i < MAXPAGES) dhp->alloMap[i] -= nblobs;
269 for (k=0;k<nblobs;k++)
270 pp->freebitmap[(j+k)>>3] |= 1<<((j+k)&7);
274 DRelease(pp, 0); /* This dir page is unchanged. */
277 /* If we make it here, the directory is full. */
282 void AddPage (dir,pageno)
284 int pageno; {/* Add a page to a directory. */
286 register struct PageHeader *pp;
288 pp = (struct PageHeader *) DNew(dir,pageno); /* Get a new buffer labelled dir,pageno */
289 pp->tag = htons(1234);
290 if (pageno > 0) pp->pgcount = 0;
291 pp->freecount = EPP-1; /* The first dude is already allocated */
292 pp->freebitmap[0] = 0x01;
293 for (i=1;i<EPP/8;i++) /* It's a constant */
294 pp->freebitmap[i] = 0;
298 void FreeBlobs(dir,firstblob,nblobs)
300 register int firstblob;
302 /* Free a whole bunch of directory entries. */
305 struct DirHeader *dhp;
306 struct PageHeader *pp;
307 page = firstblob/EPP;
308 firstblob -= EPP*page; /* convert to page-relative entry */
309 dhp = (struct DirHeader *) DRead(dir,0);
311 if (page < MAXPAGES) dhp->alloMap[page] += nblobs;
313 pp = (struct PageHeader *) DRead(dir,page);
314 if (pp) for (i=0;i<nblobs;i++)
315 pp->freebitmap[(firstblob+i)>>3] &= ~(1<<((firstblob+i)&7));
319 MakeDir (dir,me,parent)
323 /* Format an empty directory properly. Note that the first 13 entries in a directory header
324 page are allocated, 1 to the page header, 4 to the allocation map and 8 to the hash table. */
326 register struct DirHeader *dhp;
327 dhp = (struct DirHeader *) DNew(dir,0);
328 dhp->header.pgcount = htons(1);
329 dhp->header.tag = htons(1234);
330 dhp->header.freecount = (EPP-DHE-1);
331 dhp->header.freebitmap[0] = 0xff;
332 dhp->header.freebitmap[1] = 0x1f;
333 for(i=2;i<EPP/8;i++) dhp->header.freebitmap[i] = 0;
334 dhp->alloMap[0]=(EPP-DHE-1);
335 for(i=1;i<MAXPAGES;i++)dhp->alloMap[i] = EPP;
336 for(i=0;i<NHASHENT;i++)dhp->hashTable[i] = 0;
339 Create(dir,"..",parent); /* Virtue is its own .. */
343 Lookup (dir, entry, fid)
346 register afs_int32 *fid; {
347 /* Look up a file name in directory. */
348 register struct DirEntry *firstitem;
349 unsigned short *previtem;
351 firstitem = FindItem(dir,entry,&previtem);
352 if (firstitem == 0) return ENOENT;
353 DRelease(previtem,0);
354 fid[1] = ntohl(firstitem->fid.vnode);
355 fid[2] = ntohl(firstitem->fid.vunique);
356 DRelease(firstitem,0);
360 LookupOffset (dir, entry, fid, offsetp)
364 register afs_int32 *fid; {
365 /* Look up a file name in directory. */
366 register struct DirEntry *firstitem;
367 unsigned short *previtem;
369 firstitem = FindItem(dir,entry,&previtem);
370 if (firstitem == 0) return ENOENT;
371 DRelease(previtem,0);
372 fid[1] = ntohl(firstitem->fid.vnode);
373 fid[2] = ntohl(firstitem->fid.vunique);
375 *offsetp = DVOffset(firstitem);
376 DRelease(firstitem,0);
380 EnumerateDir (dir,hookproc,hook)
384 /* Enumerate the contents of a directory. */
387 register struct DirHeader *dhp;
388 register struct DirEntry *ep;
390 dhp = (struct DirHeader *) DRead(dir,0);
391 if (!dhp) return EIO; /* first page should be there */
392 for(i=0; i<NHASHENT; i++) {
393 /* For each hash chain, enumerate everyone on the list. */
394 num = ntohs(dhp->hashTable[i]);
396 /* Walk down the hash table list. */
398 ep = GetBlob(dir,num);
401 /* we failed, return why */
407 num = ntohs(ep->next);
408 (*hookproc) (hook, ep->name, ntohl(ep->fid.vnode), ntohl(ep->fid.vunique));
418 /* Enumerate the contents of a directory. */
421 register struct DirHeader *dhp;
422 register struct DirEntry *ep;
423 dhp = (struct DirHeader *) DRead(dir,0);
425 for(i=0;i<NHASHENT;i++) {
426 /* For each hash chain, enumerate everyone on the list. */
427 num = ntohs(dhp->hashTable[i]);
429 /* Walk down the hash table list. */
430 ep = GetBlob(dir,num);
432 if (strcmp(ep->name,"..") && strcmp(ep->name,".")) {
437 num = ntohs(ep->next);
445 struct DirEntry *GetBlob (dir, blobno)
448 /* Return a pointer to an entry, given its number. */
450 ep=DRead(dir,blobno>>LEPP);
452 return (struct DirEntry *) (((long)ep)+32*(blobno&(EPP-1)));
456 register char *string; {
457 /* Hash a string to a number between 0 and NHASHENT. */
458 register unsigned char tc;
462 while(tc=(*string++)) {
466 tval = hval & (NHASHENT-1);
467 if (tval == 0) return tval;
468 else if (hval < 0) tval = NHASHENT-tval;
472 static struct DirEntry *FindItem (dir,ename,previtem)
475 unsigned short **previtem; {
476 /* 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. */
478 register struct DirHeader *dhp;
479 register unsigned short *lp;
480 register struct DirEntry *tp;
482 dhp = (struct DirHeader *) DRead(dir,0);
484 if (dhp->hashTable[i] == 0) {
489 tp = GetBlob(dir,(u_short)ntohs(dhp->hashTable[i]));
494 lp = &(dhp->hashTable[i]);
496 /* Look at each hash conflict entry. */
497 if (!strcmp(ename,tp->name)) {
498 /* Found our entry. */
505 /* The end of the line */
506 DRelease(lp,0); /* Release all locks. */
509 tp = GetBlob(dir,(u_short)ntohs(tp->next));