namei: Remove namei_SetNonZLC
[openafs.git] / src / vol / namei_ops.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 /* I/O operations for the Unix open by name (namei) interface. */
11
12 #include <afsconfig.h>
13 #include <afs/param.h>
14
15 #include <roken.h>
16
17
18 #ifdef AFS_NAMEI_ENV
19
20 #ifdef HAVE_SYS_FILE_H
21 # include <sys/file.h>
22 #endif
23
24 #ifdef AFS_NT40_ENV
25 #define DELETE_ZLC
26 #include <windows.h>
27 #include <winnt.h>
28 #include <winbase.h>
29 #include <direct.h>
30 #endif
31
32 #include <afs/opr.h>
33 #include <rx/rx_queue.h>
34 #ifdef AFS_PTHREAD_ENV
35 # include <opr/lock.h>
36 #endif
37 #include <lock.h>
38 #include <afs/afsutil.h>
39 #include <lwp.h>
40 #include "nfs.h"
41 #include <afs/afsint.h>
42 #include "ihandle.h"
43 #include "vnode.h"
44 #include "volume.h"
45 #include "viceinode.h"
46 #include "voldefs.h"
47 #include "partition.h"
48 #include "fssync.h"
49 #include "volume_inline.h"
50 #include "common.h"
51 #include <afs/errors.h>
52
53 #ifdef AFS_NT40_ENV
54 #include <afs/errmap_nt.h>
55 #endif
56
57 #ifndef LOCK_SH
58 #define   LOCK_SH   1    /* shared lock */
59 #define   LOCK_EX   2    /* exclusive lock */
60 #define   LOCK_NB   4    /* don't block when locking */
61 #define   LOCK_UN   8    /* unlock */
62 #endif
63
64 #ifdef AFS_SALSRV_ENV
65 #include <pthread.h>
66 #include <afs/work_queue.h>
67 #include <afs/thread_pool.h>
68 #include <vol/vol-salvage.h>
69 #endif
70
71 int Testing=0;
72
73 static void namei_UnlockLinkCount(FdHandle_t * fdP, Inode ino);
74
75 afs_sfsize_t
76 namei_iread(IHandle_t * h, afs_foff_t offset, char *buf, afs_fsize_t size)
77 {
78     afs_sfsize_t nBytes;
79     FdHandle_t *fdP;
80
81     fdP = IH_OPEN(h);
82     if (fdP == NULL)
83         return -1;
84
85     nBytes = FDH_PREAD(fdP, buf, size, offset);
86     if (nBytes < 0)
87         FDH_REALLYCLOSE(fdP);
88     else
89         FDH_CLOSE(fdP);
90     return nBytes;
91 }
92
93 afs_sfsize_t
94 namei_iwrite(IHandle_t * h, afs_foff_t offset, char *buf, afs_fsize_t size)
95 {
96     afs_sfsize_t nBytes;
97     FdHandle_t *fdP;
98
99     fdP = IH_OPEN(h);
100     if (fdP == NULL)
101         return -1;
102
103     nBytes = FDH_PWRITE(fdP, buf, size, offset);
104     if (nBytes < 0)
105         FDH_REALLYCLOSE(fdP);
106     else
107         FDH_CLOSE(fdP);
108     return nBytes;
109 }
110
111 #ifdef AFS_NT40_ENV
112 /* Inode number format:
113  * low 32 bits - if a regular file or directory, the vnode; else the type.
114  * 32-36 - uniquifier tag and index into counts array for this vnode. Only
115  *         two of the available bits are currently used. The rest are
116  *         present in case we ever increase the number of types of volumes
117  *         in the volume group.
118  * bit 37 : 1  == special, 0 == regular
119  */
120 # define NAMEI_VNODEMASK    0x00ffffffff
121 # define NAMEI_TAGSHIFT     32
122 # define NAMEI_INODESPECIAL 0x2000000000
123 # define NAMEI_SPECDIR "R"
124 # define NAMEI_SPECDIRC 'R'
125 #else /* !AFS_NT40_ENV */
126 /* Inode number format:
127  * low 26 bits - vnode number - all 1's if volume special file.
128  * next 3 bits - tag
129  * next 3 bits spare (0's)
130  * high 32 bits - uniquifier (regular) or type if spare
131  */
132 # define NAMEI_VNODEMASK    0x003ffffff
133 # define NAMEI_TAGSHIFT     26
134 # define NAMEI_UNIQMASK     0xffffffff
135 # define NAMEI_UNIQSHIFT    32
136 # define NAMEI_INODESPECIAL ((Inode)NAMEI_VNODEMASK)
137 /* dir1 is the high 8 bits of the 26 bit vnode */
138 # define VNO_DIR1(vno) ((vno >> 14) & 0xff)
139 /* dir2 is the next 9 bits */
140 # define VNO_DIR2(vno) ((vno >> 9) & 0x1ff)
141 /* "name" is the low 9 bits of the vnode, the 3 bit tag and the uniq */
142 # define NAMEI_SPECDIR "special"
143 #endif /* !AFS_NT40_ENV */
144 #define NAMEI_TAGMASK      0x7
145 #define NAMEI_VNODESPECIAL NAMEI_VNODEMASK
146
147 #define NAMEI_SPECDIRLEN (sizeof(NAMEI_SPECDIR)-1)
148
149 #define NAMEI_MAXVOLS 5         /* Maximum supported number of volumes per volume
150                                  * group, not counting temporary (move) volumes.
151                                  * This is the number of separate files, all having
152                                  * the same vnode number, which can occur in a volume
153                                  * group at once.
154                                  */
155
156 #ifndef AFS_NT40_ENV
157 typedef struct {
158     int ogm_owner;
159     int ogm_group;
160     int ogm_mode;
161 } namei_ogm_t;
162 #endif
163
164 static int GetFreeTag(IHandle_t * ih, int vno);
165
166 /* namei_HandleToInodeDir
167  *
168  * Construct the path name of the directory holding the inode data.
169  * Format: /<vicepx>/INODEDIR
170  *
171  */
172 #ifdef AFS_NT40_ENV
173 static void
174 namei_HandleToInodeDir(namei_t * name, IHandle_t * ih)
175 {
176     memset(name, '\0', sizeof(*name));
177     nt_DevToDrive(name->n_drive, ih->ih_dev);
178     strlcpy(name->n_path, name->n_drive, sizeof(name->n_path));
179 }
180
181 #else
182 /* Format: /<vicepx>/INODEDIR */
183 #define PNAME_BLEN 64
184 static void
185 namei_HandleToInodeDir(namei_t * name, IHandle_t * ih)
186 {
187     size_t offset;
188
189     memset(name, '\0', sizeof(*name));
190
191     /*
192      * Add the /vicepXX string to the start of name->n_base and then calculate
193      * offset as the number of bytes we know we added.
194      *
195      * FIXME: This embeds knowledge of the vice partition naming scheme and
196      * mapping from device numbers.  There needs to be an API that tells us
197      * this offset.
198      */
199     volutil_PartitionName_r(ih->ih_dev, name->n_base, sizeof(name->n_base));
200     offset = VICE_PREFIX_SIZE + (ih->ih_dev > 25 ? 2 : 1);
201     name->n_base[offset] = OS_DIRSEPC;
202     offset++;
203     strlcpy(name->n_base + offset, INODEDIR, sizeof(name->n_base) - offset);
204     strlcpy(name->n_path, name->n_base, sizeof(name->n_path));
205 }
206 #endif
207
208 #define addtoname(N, C)                                         \
209 do {                                                            \
210     if ((N)->n_path[strlen((N)->n_path)-1] != OS_DIRSEPC)       \
211         strlcat((N)->n_path, OS_DIRSEP, sizeof((N)->n_path));   \
212     strlcat((N)->n_path, (C), sizeof((N)->n_path));             \
213 } while(0)
214
215
216 #ifdef AFS_NT40_ENV
217 static void
218 namei_HandleToVolDir(namei_t * name, IHandle_t * ih)
219 {
220     /* X:\Vol_XXXXXXX.data */
221     b32_string_t str1;
222     char *namep;
223
224     namei_HandleToInodeDir(name, ih);
225     /* nt_drive added to name by namei_HandleToInodeDir() */
226     namep = name->n_voldir;
227     (void)memcpy(namep, "\\Vol_", 5);
228     namep += 5;
229     (void)strcpy(namep, int_to_base32(str1, ih->ih_vid));
230     namep += strlen(namep);
231     memcpy(namep, ".data", 5);
232     namep += 5;
233     *namep = '\0';
234     addtoname(name, name->n_voldir);
235 }
236 #else
237 static void
238 namei_HandleToVolDir(namei_t * name, IHandle_t * ih)
239 {
240     lb64_string_t tmp;
241
242     namei_HandleToInodeDir(name, ih);
243     (void)int32_to_flipbase64(tmp, (int64_t) (ih->ih_vid & 0xff));
244     strlcpy(name->n_voldir1, tmp, sizeof(name->n_voldir1));
245     addtoname(name, name->n_voldir1);
246     (void)int32_to_flipbase64(tmp, (int64_t) ih->ih_vid);
247     strlcpy(name->n_voldir2, tmp, sizeof(name->n_voldir2));
248     addtoname(name, name->n_voldir2);
249 }
250 #endif
251
252 /* namei_HandleToName
253  *
254  * Constructs a file name for the fully qualified handle.
255  */
256 #ifdef AFS_NT40_ENV
257 /* Note that special files end up in X:\Vol_XXXXXXX.data\R */
258 void
259 namei_HandleToName(namei_t * name, IHandle_t * ih)
260 {
261     int vno = (int)(ih->ih_ino & NAMEI_VNODEMASK);
262     int special = (ih->ih_ino & NAMEI_INODESPECIAL)?1:0;
263     int tag = (int)((ih->ih_ino >> NAMEI_TAGSHIFT) & NAMEI_TAGMASK);
264     b32_string_t str1;
265     char *namep;
266     namei_HandleToVolDir(name, ih);
267
268     if (special) {
269         name->n_dir[0] = NAMEI_SPECDIRC;
270     } else {
271         if (vno & 0x1)
272             name->n_dir[0] = 'Q';
273         else
274             name->n_dir[0] = ((vno & 0x1f) >> 1) + 'A';
275
276     }
277     name->n_dir[1] = '\0';
278     addtoname(name, name->n_dir);
279     /* X:\Vol_XXXXXXX.data\X\V_XXXXXXX.XXX */
280     namep = name->n_inode;
281     (void)memcpy(namep, "\\V_", 3);
282     namep += 3;
283     (void)strcpy(namep, int_to_base32(str1, vno));
284     namep += strlen(namep);
285     *(namep++) = '.';
286     (void)strcpy(namep, int_to_base32(str1, tag));
287     namep += strlen(namep);
288     addtoname(name, name->n_inode);
289 }
290 #else
291 /* Note that special files end up in /vicepX/InodeDir/Vxx/V*.data/special */
292 void
293 namei_HandleToName(namei_t * name, IHandle_t * ih)
294 {
295     int vno = (int)(ih->ih_ino & NAMEI_VNODEMASK);
296     lb64_string_t str;
297
298     namei_HandleToVolDir(name, ih);
299
300     if (vno == NAMEI_VNODESPECIAL) {
301         strlcpy(name->n_dir1, NAMEI_SPECDIR, sizeof(name->n_dir1));
302         addtoname(name, name->n_dir1);
303         name->n_dir2[0] = '\0';
304     } else {
305         (void)int32_to_flipbase64(str, VNO_DIR1(vno));
306         strlcpy(name->n_dir1, str, sizeof(name->n_dir1));
307         addtoname(name, name->n_dir1);
308         (void)int32_to_flipbase64(str, VNO_DIR2(vno));
309         strlcpy(name->n_dir2, str, sizeof(name->n_dir2));
310         addtoname(name, name->n_dir2);
311     }
312     (void)int64_to_flipbase64(str, (int64_t) ih->ih_ino);
313     strlcpy(name->n_inode, str, sizeof(name->n_inode));
314     addtoname(name, name->n_inode);
315 }
316 #endif
317
318 #ifndef AFS_NT40_ENV
319 /* The following is a warning to tell sys-admins to not muck about in this
320  * name space.
321  */
322 #define VICE_README "These files and directories are a part of the AFS \
323 namespace. Modifying them\nin any way will result in loss of AFS data,\n\
324 ownership and permissions included.\n"
325 int
326 namei_ViceREADME(char *partition)
327 {
328     char filename[32];
329     int fd;
330
331     /* Create the inode directory if we're starting for the first time */
332     snprintf(filename, sizeof filename, "%s" OS_DIRSEP "%s", partition,
333              INODEDIR);
334     mkdir(filename, 0700);
335
336     snprintf(filename, sizeof filename,
337              "%s" OS_DIRSEP "%s" OS_DIRSEP "README",
338              partition, INODEDIR);
339     fd = OS_OPEN(filename, O_WRONLY | O_CREAT | O_TRUNC, 0444);
340     if (fd != INVALID_FD) {
341         (void)OS_WRITE(fd, VICE_README, strlen(VICE_README));
342         OS_CLOSE(fd);
343     }
344     return (errno);
345 }
346 #endif
347
348 /* namei_CreateDataDirectories
349  *
350  * If creating the file failed because of ENOENT or ENOTDIR, try
351  * creating all the directories first.
352  */
353 #ifdef AFS_NT40_ENV
354 static int
355 namei_CreateDataDirectories(namei_t * name, int *created)
356 {
357     char tmp[256];
358     char *s;
359     int i;
360
361     *created = 0;
362     snprintf(tmp, 256, "%s" OS_DIRSEP "%s", name->n_drive, name->n_voldir);
363
364     if (mkdir(tmp) < 0) {
365         if (errno != EEXIST)
366             return -1;
367     } else
368         *created = 1;
369
370     s = tmp;
371     s += strlen(tmp);
372
373     *s++ = OS_DIRSEPC;
374     *(s + 1) = '\0';
375     for (i = 'A'; i <= NAMEI_SPECDIRC; i++) {
376         *s = (char)i;
377         if (mkdir(tmp) < 0 && errno != EEXIST)
378             return -1;
379     }
380     return 0;
381 }
382 #else
383 #define create_dir() \
384 do { \
385     if (mkdir(tmp, 0700)<0) { \
386         if (errno != EEXIST) \
387             return -1; \
388     } \
389     else { \
390         *created = 1; \
391     } \
392 } while (0)
393
394 #define create_nextdir(A) \
395 do { \
396          strcat(tmp, OS_DIRSEP); strcat(tmp, A); create_dir();  \
397 } while(0)
398
399 static int
400 namei_CreateDataDirectories(namei_t * name, int *created)
401 {
402     char tmp[256];
403
404     *created = 0;
405
406     strlcpy(tmp, name->n_base, sizeof(tmp));
407     create_dir();
408
409     create_nextdir(name->n_voldir1);
410     create_nextdir(name->n_voldir2);
411     create_nextdir(name->n_dir1);
412     if (name->n_dir2[0]) {
413         create_nextdir(name->n_dir2);
414     }
415     return 0;
416 }
417 #endif
418
419 #ifndef AFS_NT40_ENV
420 /* delTree(): Deletes an entire tree of directories (no files)
421  * Input:
422  *   root : Full path to the subtree. Should be big enough for PATH_MAX
423  *   tree : the subtree to be deleted is rooted here. Specifies only the
424  *          subtree beginning at tree (not the entire path). It should be
425  *          a pointer into the "root" buffer.
426  * Output:
427  *  errp : errno of the first error encountered during the directory cleanup.
428  *         *errp should have been initialized to 0.
429  *
430  * Return Values:
431  *  -1  : If errors were encountered during cleanup and error is set to
432  *        the first errno.
433  *   0  : Success.
434  *
435  * If there are errors, we try to work around them and delete as many
436  * directories as possible. We don't attempt to remove directories that still
437  * have non-dir entries in them.
438  */
439 static int
440 delTree(char *root, char *tree, int *errp)
441 {
442     char *cp;
443     DIR *ds;
444     struct dirent *dirp;
445     struct afs_stat st;
446
447     if (*tree) {
448         /* delete the children first */
449         cp = strchr(tree, OS_DIRSEPC);
450         if (cp) {
451             delTree(root, cp + 1, errp);
452             *cp = '\0';
453         } else
454             cp = tree + strlen(tree);   /* move cp to the end of string tree */
455
456         /* now delete all entries in this dir */
457         if ((ds = opendir(root)) != NULL) {
458             errno = 0;
459             while ((dirp = readdir(ds))) {
460                 /* ignore . and .. */
461                 if (!strcmp(dirp->d_name, ".") || !strcmp(dirp->d_name, ".."))
462                     continue;
463                 /* since root is big enough, we reuse the space to
464                  * concatenate the dirname to the current tree
465                  */
466                 strcat(root, OS_DIRSEP);
467                 strcat(root, dirp->d_name);
468                 if (afs_stat(root, &st) == 0 && S_ISDIR(st.st_mode)) {
469                     /* delete this subtree */
470                     delTree(root, cp + 1, errp);
471                 } else
472                     *errp = *errp ? *errp : errno;
473
474                 /* recover path to our cur tree by truncating it to
475                  * its original len
476                  */
477                 *cp = 0;
478             }
479             /* if (!errno) -- closedir not implicit if we got an error */
480             closedir(ds);
481         }
482
483         /* finally axe the current dir */
484         if (rmdir(root))
485             *errp = *errp ? *errp : errno;
486
487 #ifndef AFS_PTHREAD_ENV         /* let rx get some work done */
488         IOMGR_Poll();
489 #endif /* !AFS_PTHREAD_ENV */
490
491     }
492
493     /* if valid tree */
494     /* if we encountered errors during cleanup, we return a -1 */
495     if (*errp)
496         return -1;
497
498     return 0;
499
500 }
501 #endif
502
503 /* namei_RemoveDataDirectories
504  * Return Values:
505  * Returns 0 on success.
506  * Returns -1 on error. Typically, callers ignore this error because we
507  * can continue running if the removes fail. The salvage process will
508  * finish tidying up for us.
509  */
510
511 #ifdef AFS_NT40_ENV
512 static int
513 namei_RemoveDataDirectories(namei_t * name)
514 {
515     int code = 0;
516     char *path;
517     char tmp[256];
518     int i;
519
520     snprintf(tmp, 256, "%s" OS_DIRSEP "%s", name->n_drive, name->n_voldir);
521
522     path = tmp;
523     path += strlen(path);
524     *path++ = OS_DIRSEPC;
525     *(path + 1) = '\0';
526     for (i = 'A'; i <= NAMEI_SPECDIRC; i++) {
527         *path = (char)i;
528         if (rmdir(name->n_path) < 0 && errno != ENOENT)
529             code = -1;
530     }
531
532     if (!code) {
533         /* Delete the Vol_NNNNNN.data directory. */
534         path--;
535         *path = '\0';
536         if (rmdir(name->n_path) < 0 && errno != ENOENT) {
537             code = -1;
538         }
539     }
540     return code;
541 }
542 #else
543 /*
544  * We only use the n_base and n_voldir1 entries
545  * and only do rmdir's.
546  */
547 static int
548 namei_RemoveDataDirectories(namei_t * name)
549 {
550     int code = 0;
551     char *path;
552     int prefixlen = strlen(name->n_base), err = 0;
553     int vollen = strlen(name->n_voldir1);
554     char pbuf[MAXPATHLEN];
555
556     path = pbuf;
557
558     strlcpy(path, name->n_path, sizeof(pbuf));
559
560     /* move past the prefix and n_voldir1 */
561     path = path + prefixlen + 1 + vollen + 1;   /* skip over the trailing / */
562
563     /* now delete all dirs upto path */
564     code = delTree(pbuf, path, &err);
565
566     /* We've now deleted everything under /n_base/n_voldir1/n_voldir2 that
567      * we could. Do not delete /n_base/n_voldir1, since doing such might
568      * interrupt another thread trying to create a volume. We could introduce
569      * some locking to make this safe (or only remove it for whole-partition
570      * salvages), but by not deleting it we only leave behind a maximum of
571      * 256 empty directories. So at least for now, don't bother. */
572     return code;
573 }
574 #endif
575
576 /* Create the file in the name space.
577  *
578  * Parameters stored as follows:
579  * Regular files:
580  * p1 - volid - implied in containing directory.
581  * p2 - vnode - name is <vno:31-23>/<vno:22-15>/<vno:15-0><uniq:31-5><tag:2-0>
582  * p3 - uniq -- bits 4-0 are in mode bits 4-0
583  * p4 - dv ---- dv:15-0 in uid, dv:29-16 in gid, dv:31-30 in mode:6-5
584  * Special files:
585  * p1 - volid - creation time - dwHighDateTime
586  * p2 - vnode - -1 means special, file goes in "S" subdirectory.
587  * p3 - type -- name is <type>.<tag> where tag is a file name unqiquifier.
588  * p4 - parid - parent volume id - implied in containing directory.
589  *
590  * Return value is the inode number or (Inode)-1 if error.
591  * We "know" there is only one link table, so return EEXIST if there already
592  * is a link table. It's up to the calling code to test errno and increment
593  * the link count.
594  */
595
596 /* namei_MakeSpecIno
597  *
598  * This function is called by VCreateVolume to hide the implementation
599  * details of the inode numbers. This only allows for 7 volume special
600  * types, but if we get that far, this could should be dead by then.
601  */
602 Inode
603 namei_MakeSpecIno(VolumeId volid, int type)
604 {
605     Inode ino;
606     ino = NAMEI_INODESPECIAL;
607 #ifdef AFS_NT40_ENV
608     ino |= type;
609     /* tag is always 0 for special */
610 #else
611     type &= NAMEI_TAGMASK;
612     ino |= ((Inode) type) << NAMEI_TAGSHIFT;
613     ino |= ((Inode) volid) << NAMEI_UNIQSHIFT;
614 #endif
615     return ino;
616 }
617
618 #ifdef AFS_NT40_ENV
619 /* SetOGM */
620 static int
621 SetOGM(FD_t fd, int parm, int tag)
622 {
623     return -1;
624 }
625
626 static int
627 SetWinOGM(FD_t fd, int p1, int p2)
628 {
629     BOOL code;
630     FILETIME ftime;
631
632     ftime.dwHighDateTime = p1;
633     ftime.dwLowDateTime = p2;
634
635     code = SetFileTime(fd, &ftime, NULL /*access*/, NULL /*write*/);
636     if (!code)
637         return -1;
638     return 0;
639 }
640
641 static int
642 GetWinOGM(FD_t fd, int *p1, int *p2)
643 {
644     BOOL code;
645     FILETIME ftime;
646
647     code = GetFileTime(fd, &ftime, NULL /*access*/, NULL /*write*/);
648     if (!code)
649         return -1;
650
651     *p1 = ftime.dwHighDateTime;
652     *p2 = ftime.dwLowDateTime;
653
654     return 0;
655 }
656
657 static int
658 CheckOGM(FdHandle_t *fdP, int p1)
659 {
660     int ogm_p1, ogm_p2;
661
662     if (GetWinOGM(fdP->fd_fd, &ogm_p1, &ogm_p2)) {
663         return -1;
664     }
665
666     if (ogm_p1 != p1) {
667         return -1;
668     }
669
670     return 0;
671 }
672
673 static int
674 FixSpecialOGM(FdHandle_t *fdP, int check)
675 {
676     Inode ino = fdP->fd_ih->ih_ino;
677     VnodeId vno = NAMEI_VNODESPECIAL, ogm_vno;
678     int ogm_volid;
679
680     if (GetWinOGM(fdP->fd_fd, &ogm_volid, &ogm_vno)) {
681         return -1;
682     }
683
684     /* the only thing we can check is the vnode number; for the volid we have
685      * nothing else to compare against */
686     if (vno != ogm_vno) {
687         if (check) {
688             return -1;
689         }
690         if (SetWinOGM(fdP->fd_fd, ogm_volid, vno)) {
691             return -1;
692         }
693     }
694     return 0;
695 }
696
697 #else /* AFS_NT40_ENV */
698 /* SetOGM - set owner group and mode bits from parm and tag */
699 static int
700 SetOGM(FD_t fd, int parm, int tag)
701 {
702 /*
703  * owner - low 15 bits of parm.
704  * group - next 15 bits of parm.
705  * mode - 2 bits of parm, then lowest = 3 bits of tag.
706  */
707     int owner, group, mode;
708
709     owner = parm & 0x7fff;
710     group = (parm >> 15) & 0x7fff;
711     if (fchown(fd, owner, group) < 0)
712         return -1;
713
714     mode = (parm >> 27) & 0x18;
715     mode |= tag & 0x7;
716     if (fchmod(fd, mode) < 0)
717         return -1;
718     return 0;
719 }
720
721 /* GetOGM - get parm and tag from owner, group and mode bits. */
722 static void
723 GetOGMFromStat(struct afs_stat_st *status, int *parm, int *tag)
724 {
725     *parm = status->st_uid | (status->st_gid << 15);
726     *parm |= (status->st_mode & 0x18) << 27;
727     *tag = status->st_mode & 0x7;
728 }
729
730 static int
731 GetOGM(FdHandle_t *fdP, int *parm, int *tag)
732 {
733     struct afs_stat_st status;
734     if (afs_fstat(fdP->fd_fd, &status) < 0)
735         return -1;
736     GetOGMFromStat(&status, parm, tag);
737     return 0;
738 }
739
740 static int
741 CheckOGM(FdHandle_t *fdP, int p1)
742 {
743     int parm, tag;
744
745     if (GetOGM(fdP, &parm, &tag) < 0)
746         return -1;
747     if (parm != p1)
748         return -1;
749
750     return 0;
751 }
752
753 static int
754 FixSpecialOGM(FdHandle_t *fdP, int check)
755 {
756     int inode_volid, ogm_volid;
757     int inode_type, ogm_type;
758     Inode ino = fdP->fd_ih->ih_ino;
759
760     inode_volid = ((ino >> NAMEI_UNIQSHIFT) & NAMEI_UNIQMASK);
761     inode_type = (int)((ino >> NAMEI_TAGSHIFT) & NAMEI_TAGMASK);
762
763     if (GetOGM(fdP, &ogm_volid, &ogm_type) < 0) {
764         Log("Error retrieving OGM info\n");
765         return -1;
766     }
767
768     if (inode_volid != ogm_volid || inode_type != ogm_type) {
769         Log("%sIncorrect OGM data (ino: vol %u type %d) (ogm: vol %u type %d)\n",
770             check?"":"Fixing ", inode_volid, inode_type, ogm_volid, ogm_type);
771
772         if (check) {
773             return -1;
774         }
775
776         if (SetOGM(fdP->fd_fd, inode_volid, inode_type) < 0) {
777             Log("Error setting OGM data\n");
778             return -1;
779         }
780     }
781     return 0;
782 }
783
784 #endif /* !AFS_NT40_ENV */
785
786 /**
787  * Check/fix the OGM data for an inode
788  *
789  * @param[in] fdP   Open file handle for the inode to check
790  * @param[in] check 1 to just check the OGM data, and return an error if it
791  *                  is incorrect. 0 to fix the OGM data if it is incorrect.
792  *
793  * @pre fdP must be for a special inode
794  *
795  * @return status
796  *  @retval 0 success
797  *  @retval -1 error
798  */
799 int
800 namei_FixSpecialOGM(FdHandle_t *fdP, int check)
801 {
802     int vnode;
803     Inode ino = fdP->fd_ih->ih_ino;
804
805     vnode = (int)(ino & NAMEI_VNODEMASK);
806     if (vnode != NAMEI_VNODESPECIAL) {
807         Log("FixSpecialOGM: non-special vnode %u\n", vnode);
808         return -1;
809     }
810
811     return FixSpecialOGM(fdP, check);
812 }
813
814 int big_vno = 0;                /* Just in case we ever do 64 bit vnodes. */
815
816 /* Derive the name and create it O_EXCL. If that fails we have an error.
817  * Get the tag from a free column in the link table.
818  */
819 #ifdef AFS_NT40_ENV
820 Inode
821 namei_icreate(IHandle_t * lh, char *part, afs_uint32 p1, afs_uint32 p2, afs_uint32 p3, afs_uint32 p4)
822 {
823     namei_t name;
824     FD_t fd = INVALID_FD;
825     int code = 0;
826     int created_dir = 0;
827     IHandle_t tmp;
828     FdHandle_t *fdP;
829     FdHandle_t tfd;
830     int type, tag;
831     int ogm_p1, ogm_p2;
832     char *p;
833     b32_string_t str1;
834
835     memset((void *)&tmp, 0, sizeof(IHandle_t));
836     memset(&tfd, 0, sizeof(FdHandle_t));
837
838     tmp.ih_dev = nt_DriveToDev(part);
839     if (tmp.ih_dev == -1) {
840         errno = EINVAL;
841         return -1;
842     }
843
844     if (p2 == INODESPECIAL) {
845         /* Parameters for special file:
846          * p1 - volume id - goes into owner/group/mode
847          * p2 - vnode == INODESPECIAL
848          * p3 - type
849          * p4 - parent volume id
850          */
851         ogm_p1 = p1;
852         ogm_p2 = p2;
853         type = p3;
854         tmp.ih_vid = p4;        /* Use parent volume id, where this file will be. */
855         tmp.ih_ino = namei_MakeSpecIno(p1, p3);
856     } else {
857         int vno = p2 & NAMEI_VNODEMASK;
858         /* Parameters for regular file:
859          * p1 - volume id
860          * p2 - vnode
861          * p3 - uniq
862          * p4 - dv
863          */
864
865         if (vno != p2) {
866             big_vno++;
867             errno = EINVAL;
868             return -1;
869         }
870
871         tmp.ih_vid = p1;
872         tmp.ih_ino = (Inode) p2;
873         ogm_p1 = p3;
874         ogm_p2 = p4;
875     }
876
877     namei_HandleToName(&name, &tmp);
878     p = strrchr((char *)&name.n_path, '.');
879     p++;
880     for (tag = 0; tag < NAMEI_MAXVOLS; tag++) {
881         *p = *int_to_base32(str1, tag);
882         fd = OS_OPEN((char *)&name.n_path, O_CREAT | O_RDWR | O_EXCL, 0666);
883         if (fd == INVALID_FD) {
884             if (errno == ENOTDIR || errno == ENOENT) {
885                 if (namei_CreateDataDirectories(&name, &created_dir) == 0)
886                     fd = OS_OPEN((char *)&name.n_path, O_CREAT | O_RDWR | O_EXCL, 0666);
887             }
888         }
889
890         if (fd != INVALID_FD)
891             break;
892         if (p2 == INODESPECIAL && p3 == VI_LINKTABLE)
893             break;
894     }
895     if (fd == INVALID_FD) {
896         code = -1;
897         goto bad;
898     }
899     tmp.ih_ino &= ~(((Inode) NAMEI_TAGMASK) << NAMEI_TAGSHIFT);
900     tmp.ih_ino |= (((Inode) tag) << NAMEI_TAGSHIFT);
901
902     if (!code) {
903         if (SetWinOGM(fd, ogm_p1, ogm_p2)) {
904             errno = OS_ERROR(EBADF);
905             code = -1;
906         }
907     }
908
909     if (!code) {
910         if (p2 != INODESPECIAL) {
911             if (fd == INVALID_FD) {
912                 errno = ENOENT;
913                 code = nt_unlink((char *)&name.n_path);
914                 code = -1;
915                 goto bad;
916             }
917             fdP = IH_OPEN(lh);
918             if (fdP == NULL) {
919                 code = -1;
920                 goto bad;
921             }
922             code = namei_SetLinkCount(fdP, tmp.ih_ino, 1, 0);
923             FDH_CLOSE(fdP);
924         } else if (p2 == INODESPECIAL && p3 == VI_LINKTABLE) {
925             if (fd == INVALID_FD)
926                 goto bad;
927             /* hack at tmp to setup for set link count call. */
928             tfd.fd_fd = fd;
929             code = namei_SetLinkCount(&tfd, (Inode) 0, 1, 0);
930         }
931     }
932
933 bad:
934     if (fd != INVALID_FD)
935         OS_CLOSE(fd);
936
937     if (code || (fd == INVALID_FD)) {
938         if (p2 != INODESPECIAL) {
939             fdP = IH_OPEN(lh);
940             if (fdP) {
941                 namei_SetLinkCount(fdP, tmp.ih_ino, 0, 0);
942                 FDH_CLOSE(fdP);
943             }
944         }
945
946         if (created_dir) {
947             int save_errno = errno;
948             namei_RemoveDataDirectories(&name);
949             errno = save_errno;
950         }
951     }
952     return (code || (fd == INVALID_FD)) ? (Inode) -1 : tmp.ih_ino;
953 }
954 #else /* !AFS_NT40_ENV */
955 Inode
956 icreate(IHandle_t * lh, char *part, afs_uint32 p1, afs_uint32 p2, afs_uint32 p3, afs_uint32 p4,
957         FD_t *afd, Inode *ainode)
958 {
959     namei_t name;
960     int fd = INVALID_FD;
961     int code = 0;
962     int created_dir = 0;
963     IHandle_t tmp;
964     FdHandle_t *fdP;
965     FdHandle_t tfd;
966     int tag;
967     int ogm_parm;
968
969     memset((void *)&tmp, 0, sizeof(IHandle_t));
970     memset(&tfd, 0, sizeof(FdHandle_t));
971
972     tmp.ih_dev = volutil_GetPartitionID(part);
973     if (tmp.ih_dev == -1) {
974         errno = EINVAL;
975         return -1;
976     }
977
978     if (p2 == -1) {
979         /* Parameters for special file:
980          * p1 - volume id - goes into owner/group/mode
981          * p2 - vnode == -1
982          * p3 - type
983          * p4 - parent volume id
984          */
985         ogm_parm = p1;
986
987         tag = p3;
988         tmp.ih_vid = p4;        /* Use parent volume id, where this file will be. */
989         tmp.ih_ino = namei_MakeSpecIno(p1, p3);
990     } else {
991         int vno = p2 & NAMEI_VNODEMASK;
992         /* Parameters for regular file:
993          * p1 - volume id
994          * p2 - vnode
995          * p3 - uniq
996          * p4 - dv
997          */
998
999         if (vno != p2) {
1000             big_vno++;
1001             errno = EINVAL;
1002             return -1;
1003         }
1004         /* If GetFreeTag succeeds, it atomically sets link count to 1. */
1005         tag = GetFreeTag(lh, p2);
1006         if (tag < 0)
1007             goto bad;
1008
1009         tmp.ih_vid = p1;
1010         tmp.ih_ino = (Inode) p2;
1011         /* name is <uniq(p3)><tag><vno(p2)> */
1012         tmp.ih_ino |= ((Inode) tag) << NAMEI_TAGSHIFT;
1013         tmp.ih_ino |= ((Inode) p3) << NAMEI_UNIQSHIFT;
1014
1015         ogm_parm = p4;
1016     }
1017
1018     namei_HandleToName(&name, &tmp);
1019     fd = OS_OPEN(name.n_path, O_CREAT | O_EXCL | O_RDWR, 0);
1020     if (fd == INVALID_FD) {
1021         if (errno == ENOTDIR || errno == ENOENT) {
1022             if (namei_CreateDataDirectories(&name, &created_dir) < 0)
1023                 goto bad;
1024             fd = OS_OPEN(name.n_path, O_CREAT | O_EXCL | O_RDWR,
1025                           0);
1026             if (fd == INVALID_FD)
1027                 goto bad;
1028         } else {
1029             goto bad;
1030         }
1031     }
1032     if (SetOGM(fd, ogm_parm, tag) < 0) {
1033         OS_CLOSE(fd);
1034         fd = INVALID_FD;
1035         goto bad;
1036     }
1037
1038     if (p2 == (afs_uint32)-1 && p3 == VI_LINKTABLE) {
1039         /* hack at tmp to setup for set link count call. */
1040         memset((void *)&tfd, 0, sizeof(FdHandle_t));    /* minimalistic still, but a little cleaner */
1041         tfd.fd_ih = &tmp;
1042         tfd.fd_fd = fd;
1043         code = namei_SetLinkCount(&tfd, (Inode) 0, 1, 0);
1044     }
1045
1046   bad:
1047     if (code || (fd == INVALID_FD)) {
1048         if (p2 != -1) {
1049             fdP = IH_OPEN(lh);
1050             if (fdP) {
1051                 namei_SetLinkCount(fdP, tmp.ih_ino, 0, 0);
1052                 FDH_CLOSE(fdP);
1053             }
1054         }
1055     }
1056
1057     *afd = fd;
1058     *ainode = tmp.ih_ino;
1059
1060     return code;
1061 }
1062
1063 Inode
1064 namei_icreate(IHandle_t * lh, char *part,
1065               afs_uint32 p1, afs_uint32 p2, afs_uint32 p3, afs_uint32 p4)
1066 {
1067     Inode ino = 0;
1068     int fd = INVALID_FD;
1069     int code;
1070
1071     code = icreate(lh, part, p1, p2, p3, p4, &fd, &ino);
1072     if (fd != INVALID_FD) {
1073         close(fd);
1074     }
1075     return (code || (fd == INVALID_FD)) ? (Inode) - 1 : ino;
1076 }
1077
1078 IHandle_t *
1079 namei_icreate_init(IHandle_t * lh, int dev, char *part,
1080                    afs_uint32 p1, afs_uint32 p2, afs_uint32 p3, afs_uint32 p4)
1081 {
1082     Inode ino = 0;
1083     int fd = INVALID_FD;
1084     int code;
1085     IHandle_t *ihP;
1086     FdHandle_t *fdP;
1087
1088     code = icreate(lh, part, p1, p2, p3, p4, &fd, &ino);
1089     if (fd == INVALID_FD) {
1090         return NULL;
1091     }
1092     if (code) {
1093         close(fd);
1094         return NULL;
1095     }
1096
1097     IH_INIT(ihP, dev, p1, ino);
1098     fdP = ih_attachfd(ihP, fd);
1099     if (!fdP) {
1100         close(fd);
1101     } else {
1102         FDH_CLOSE(fdP);
1103     }
1104
1105     return ihP;
1106 }
1107 #endif
1108
1109 /* namei_iopen */
1110 FD_t
1111 namei_iopen(IHandle_t * h)
1112 {
1113     FD_t fd;
1114     namei_t name;
1115
1116     /* Convert handle to file name. */
1117     namei_HandleToName(&name, h);
1118     fd = OS_OPEN((char *)&name.n_path, O_RDWR, 0666);
1119     return fd;
1120 }
1121
1122 /* Need to detect vol special file and just unlink. In those cases, the
1123  * handle passed in _is_ for the inode. We only check p1 for the special
1124  * files.
1125  */
1126 int
1127 namei_dec(IHandle_t * ih, Inode ino, int p1)
1128 {
1129     int count = 0;
1130     namei_t name;
1131     int code = 0;
1132     FdHandle_t *fdP;
1133
1134     if ((ino & NAMEI_INODESPECIAL) == NAMEI_INODESPECIAL) {
1135         IHandle_t *tmp;
1136         int type = (int)((ino >> NAMEI_TAGSHIFT) & NAMEI_TAGMASK);
1137
1138         /* Verify this is the right file. */
1139         IH_INIT(tmp, ih->ih_dev, ih->ih_vid, ino);
1140
1141         namei_HandleToName(&name, tmp);
1142
1143         fdP = IH_OPEN(tmp);
1144         if (fdP == NULL) {
1145             IH_RELEASE(tmp);
1146             errno = OS_ERROR(ENOENT);
1147             return -1;
1148         }
1149
1150         if (CheckOGM(fdP, p1) < 0) {
1151             FDH_REALLYCLOSE(fdP);
1152             IH_RELEASE(tmp);
1153             errno = OS_ERROR(EINVAL);
1154             return -1;
1155         }
1156
1157         /* If it's the link table itself, decrement the link count. */
1158         if (type == VI_LINKTABLE) {
1159           if ((count = namei_GetLinkCount(fdP, (Inode) 0, 1, 0, 1)) < 0) {
1160                 FDH_REALLYCLOSE(fdP);
1161                 IH_RELEASE(tmp);
1162                 return -1;
1163             }
1164
1165             count--;
1166             if (count > 0) {
1167                 /* if our count is non-zero, we just set our new linkcount and
1168                  * return. But if our count is 0, don't bother updating the
1169                  * linktable, since we're about to delete the link table,
1170                  * below. */
1171                 if (namei_SetLinkCount(fdP, (Inode) 0, count < 0 ? 0 : count, 1) < 0) {
1172                     FDH_REALLYCLOSE(fdP);
1173                     IH_RELEASE(tmp);
1174                     return -1;
1175                 }
1176
1177                 FDH_CLOSE(fdP);
1178                 IH_RELEASE(tmp);
1179                 return 0;
1180             }
1181
1182             namei_UnlockLinkCount(fdP, (Inode) 0);
1183         }
1184
1185         /* We should IH_REALLYCLOSE right before deleting the special file from
1186          * disk, to ensure that somebody else cannot create a special inode,
1187          * then IH_OPEN that special inode and get back a cached fd for the
1188          * file we are deleting here (instead of an fd for the file they just
1189          * created). */
1190         IH_REALLYCLOSE(tmp);
1191         FDH_REALLYCLOSE(fdP);
1192         IH_RELEASE(tmp);
1193
1194         if ((code = OS_UNLINK(name.n_path)) == 0) {
1195             if (type == VI_LINKTABLE) {
1196                 /* Try to remove directory. If it fails, that's ok.
1197                  * Salvage will clean up.
1198                  */
1199                 char *slash = strrchr(name.n_path, OS_DIRSEPC);
1200                 if (slash) {
1201                     /* avoid an rmdir() on the file we just unlinked */
1202                     *slash = '\0';
1203                 }
1204                 (void)namei_RemoveDataDirectories(&name);
1205             }
1206         }
1207     } else {
1208         /* Get a file descriptor handle for this Inode */
1209         fdP = IH_OPEN(ih);
1210         if (fdP == NULL) {
1211             return -1;
1212         }
1213
1214         if ((count = namei_GetLinkCount(fdP, ino, 1, 0, 1)) < 0) {
1215             FDH_REALLYCLOSE(fdP);
1216             return -1;
1217         }
1218
1219         count--;
1220         if (count >= 0) {
1221             if (namei_SetLinkCount(fdP, ino, count, 1) < 0) {
1222                 FDH_REALLYCLOSE(fdP);
1223                 return -1;
1224             }
1225         } else {
1226             IHandle_t *th;
1227             IH_INIT(th, ih->ih_dev, ih->ih_vid, ino);
1228             Log("Warning: Lost ref on ihandle dev %d vid %" AFS_VOLID_FMT " ino %lld\n",
1229                 th->ih_dev, afs_printable_VolumeId_lu(th->ih_vid), (afs_int64)th->ih_ino);
1230             IH_RELEASE(th);
1231
1232             /* If we're less than 0, someone presumably unlinked;
1233                don't bother setting count to 0, but we need to drop a lock */
1234             if (namei_SetLinkCount(fdP, ino, 0, 1) < 0) {
1235                 FDH_REALLYCLOSE(fdP);
1236                 return -1;
1237             }
1238         }
1239         if (count == 0) {
1240             IHandle_t *th;
1241             IH_INIT(th, ih->ih_dev, ih->ih_vid, ino);
1242
1243             namei_HandleToName(&name, th);
1244             IH_RELEASE(th);
1245             code = OS_UNLINK(name.n_path);
1246         }
1247         FDH_CLOSE(fdP);
1248     }
1249
1250     return code;
1251 }
1252
1253 int
1254 namei_inc(IHandle_t * h, Inode ino, int p1)
1255 {
1256     int count;
1257     int code = 0;
1258     FdHandle_t *fdP;
1259
1260     if ((ino & NAMEI_INODESPECIAL) == NAMEI_INODESPECIAL) {
1261         int type = (int)((ino >> NAMEI_TAGSHIFT) & NAMEI_TAGMASK);
1262         if (type != VI_LINKTABLE)
1263             return 0;
1264         ino = (Inode) 0;
1265     }
1266
1267     /* Get a file descriptor handle for this Inode */
1268     fdP = IH_OPEN(h);
1269     if (fdP == NULL) {
1270         return -1;
1271     }
1272
1273     if ((count = namei_GetLinkCount(fdP, ino, 1, 0, 1)) < 0)
1274         code = -1;
1275     else {
1276         count++;
1277         if (count > 7) {
1278             errno = OS_ERROR(EINVAL);
1279             code = -1;
1280             count = 7;
1281         }
1282         if (namei_SetLinkCount(fdP, ino, count, 1) < 0)
1283             code = -1;
1284     }
1285     if (code) {
1286         FDH_REALLYCLOSE(fdP);
1287     } else {
1288         FDH_CLOSE(fdP);
1289     }
1290     return code;
1291 }
1292
1293 #ifndef AFS_NT40_ENV
1294 int
1295 namei_replace_file_by_hardlink(IHandle_t *hLink, IHandle_t *hTarget)
1296 {
1297     afs_int32 code;
1298     namei_t nameLink;
1299     namei_t nameTarget;
1300
1301     /* Convert handle to file name. */
1302     namei_HandleToName(&nameLink, hLink);
1303     namei_HandleToName(&nameTarget, hTarget);
1304
1305     OS_UNLINK(nameLink.n_path);
1306     code = link(nameTarget.n_path, nameLink.n_path);
1307     return code;
1308 }
1309
1310 int
1311 namei_copy_on_write(IHandle_t *h)
1312 {
1313     afs_int32 code = 0;
1314     FD_t fd;
1315     namei_t name;
1316     FdHandle_t *fdP;
1317     struct afs_stat_st tstat;
1318     afs_foff_t offset;
1319
1320     namei_HandleToName(&name, h);
1321     if (afs_stat(name.n_path, &tstat) < 0)
1322         return EIO;
1323     if (tstat.st_nlink > 1) {                   /* do a copy on write */
1324         char path[259];
1325         char *buf;
1326         afs_size_t size;
1327         ssize_t tlen;
1328
1329         fdP = IH_OPEN(h);
1330         if (!fdP)
1331             return EIO;
1332         snprintf(path, sizeof(path), "%s-tmp", name.n_path);
1333         fd = OS_OPEN(path, O_CREAT | O_EXCL | O_RDWR, 0);
1334         if (fd == INVALID_FD) {
1335             FDH_CLOSE(fdP);
1336             return EIO;
1337         }
1338         buf = malloc(8192);
1339         if (!buf) {
1340             OS_CLOSE(fd);
1341             OS_UNLINK(path);
1342             FDH_CLOSE(fdP);
1343             return ENOMEM;
1344         }
1345         size = tstat.st_size;
1346         offset = 0;
1347         while (size) {
1348             tlen = size > 8192 ? 8192 : size;
1349             if (FDH_PREAD(fdP, buf, tlen, offset) != tlen)
1350                 break;
1351             if (OS_WRITE(fd, buf, tlen) != tlen)
1352                 break;
1353             size -= tlen;
1354             offset += tlen;
1355         }
1356         OS_CLOSE(fd);
1357         FDH_REALLYCLOSE(fdP);
1358         free(buf);
1359         if (size)
1360             code = EIO;
1361         else {
1362             OS_UNLINK(name.n_path);
1363             code = rename(path, name.n_path);
1364         }
1365     }
1366     return code;
1367 }
1368 #endif
1369
1370 /************************************************************************
1371  * File Name Structure
1372  ************************************************************************
1373  *
1374  * Each AFS file needs a unique name and it needs to be findable with
1375  * minimal lookup time. Note that the constraint on the number of files and
1376  * directories in a volume is the size of the vnode index files and the
1377  * max file size AFS supports (for internal files) of 2^31. Since a record
1378  * in the small vnode index file is 64 bytes long, we can have at most
1379  * (2^31)/64 or 33554432 files. A record in the large index file is
1380  * 256 bytes long, giving a maximum of (2^31)/256 = 8388608 directories.
1381  * Another layout parameter is that there is roughly a 16 to 1 ratio between
1382  * the number of files and the number of directories.
1383  *
1384  * Using this information we can see that a layout of 256 directories, each
1385  * with 512 subdirectories and each of those having 512 files gives us
1386  * 256*512*512 = 67108864 AFS files and directories.
1387  *
1388  * The volume, vnode, uniquifier and data version, as well as the tag
1389  * are required, either for finding the file or for salvaging. It's best to
1390  * restrict the name to something that can be mapped into 64 bits so the
1391  * "Inode" is easily comparable (using "==") to other "Inodes". The tag
1392  * is used to distinguish between different versions of the same file
1393  * which are currently in the RW and clones of a volume. See "Link Table
1394  * Organization" below for more information on the tag. The tag is
1395  * required in the name of the file to ensure a unique name.
1396  *
1397  * ifdef AFS_NT40_ENV
1398  * The data for each volume group is in a separate directory. The name of the
1399  * volume is of the form: Vol_NNNNNN.data, where NNNNNN is a base 32
1400  * representation of the RW volume ID (even where the RO is the only volume
1401  * on the partition). Below that are separate subdirectories for the
1402  * AFS directories and special files. There are also 16 directories for files,
1403  * hashed on the low 5 bits (recall bit0 is always 0) of the vnode number.
1404  * These directories are named:
1405  * A - P - 16 file directories.
1406  * Q ----- data directory
1407  * R ----- special files directory
1408  *
1409  * The vnode is hashed into the directory using the low bits of the
1410  * vnode number.
1411  *
1412  * The format of a file name for a regular file is:
1413  * Y:\Vol_NNNNNN.data\X\V_IIIIII.J
1414  * Y - partition encoded as drive letter, starting with D
1415  * NNNNNN - base 32 encoded volume number of RW volume
1416  * X - hash directory, as above
1417  * IIIIII - base 32 encoded vnode number
1418  * J - base 32 encoded tag
1419  *
1420  * uniq is stored in the dwHighDateTime creation time field
1421  * dv is stored in the dwLowDateTime creation time field
1422  *
1423  * Special inodes are always in the R directory, as above, and are
1424  * encoded:
1425  * True child volid is stored in the dwHighDateTime creation time field
1426  * vnode number is always -1 (Special)
1427  * type is the IIIIII part of the filename
1428  * uniq is the J part of the filename
1429  * parent volume id is implied in the containing directory
1430  *
1431  * else
1432  * We can store data in the uid, gid and mode bits of the files, provided
1433  * the directories have root only access. This gives us 15 bits for each
1434  * of uid and gid (GNU chown considers 65535 to mean "don't change").
1435  * There are 9 available mode bits. Adn we need to store a total of
1436  * 32 (volume id) + 26 (vnode) + 32 (uniquifier) + 32 (data-version) + 3 (tag)
1437  * or 131 bits somewhere.
1438  *
1439  * The format of a file name for a regular file is:
1440  * /vicepX/AFSIDat/V1/V2/AA/BB/<tag><uniq><vno>
1441  * V1 - low 8 bits of RW volume id
1442  * V2 - all bits of RW volume id
1443  * AA - high 8 bits of vnode number.
1444  * BB - next 9 bits of vnode number.
1445  * <tag><uniq><vno> - file name
1446  *
1447  * Volume special files are stored in a separate directory:
1448  * /vicepX/AFSIDat/V1/V2/special/<tag><uniq><vno>
1449  *
1450  *
1451  * The vnode is hashed into the directory using the high bits of the
1452  * vnode number. This is so that consecutively created vnodes are in
1453  * roughly the same area on the disk. This will at least be optimal if
1454  * the user is creating many files in the same AFS directory. The name
1455  * should be formed so that the leading characters are different as quickly
1456  * as possible, leading to faster discards of incorrect matches in the
1457  * lookup code.
1458  *
1459  * endif
1460  *
1461  */
1462
1463
1464 /************************************************************************
1465  *  Link Table Organization
1466  ************************************************************************
1467  *
1468  * The link table volume special file is used to hold the link counts that
1469  * are held in the inodes in inode based AFS vice filesystems. For user
1470  * space access, the link counts are being kept in a separate
1471  * volume special file. The file begins with the usual version stamp
1472  * information and is then followed by one row per vnode number. vnode 0
1473  * is used to hold the link count of the link table itself. That is because
1474  * the same link table is shared among all the volumes of the volume group
1475  * and is deleted only when the last volume of a volume group is deleted.
1476  *
1477  * Within each row, the columns are 3 bits wide. They can each hold a 0 based
1478  * link count from 0 through 7. Each colume represents a unique instance of
1479  * that vnode. Say we have a file shared between the RW and a RO and a
1480  * different version of the file (or a different uniquifer) for the BU volume.
1481  * Then one column would be holding the link count of 2 for the RW and RO
1482  * and a different column would hold the link count of 1 for the BU volume.
1483  * # ifdef AFS_NT40_ENV
1484  * The column used is determined for NT by the uniquifier tag applied to
1485  * generate a unique file name in the NTFS namespace. The file name is
1486  * of the form "V_<vno>.<tag>" . And the <tag> is also the column number
1487  * in the link table.
1488  * # else
1489  * Note that we allow only 5 volumes per file, giving 15 bits used in the
1490  * short.
1491  * # endif
1492  */
1493 #define LINKTABLE_WIDTH 2
1494 #define LINKTABLE_SHIFT 1       /* log 2 = 1 */
1495
1496 /**
1497  * compute namei link table file and bit offset from inode number.
1498  *
1499  * @param[in]   ino     inode number
1500  * @param[out]  offset  link table file offset
1501  * @param[out]  index   bit offset within 2-byte record
1502  *
1503  * @internal
1504  */
1505 static void
1506 namei_GetLCOffsetAndIndexFromIno(Inode ino, afs_foff_t * offset, int *index)
1507 {
1508     int toff = (int)(ino & NAMEI_VNODEMASK);
1509     int tindex = (int)((ino >> NAMEI_TAGSHIFT) & NAMEI_TAGMASK);
1510
1511     *offset = (afs_foff_t) ((toff << LINKTABLE_SHIFT) + 8);     /* * 2 + sizeof stamp */
1512     *index = (tindex << 1) + tindex;
1513 }
1514
1515 #ifdef AFS_PTHREAD_ENV
1516 /* XXX do static initializers work for WINNT/pthread? */
1517 pthread_mutex_t _namei_glc_lock = PTHREAD_MUTEX_INITIALIZER;
1518 #define NAMEI_GLC_LOCK opr_mutex_enter(&_namei_glc_lock)
1519 #define NAMEI_GLC_UNLOCK opr_mutex_exit(&_namei_glc_lock)
1520 #else /* !AFS_PTHREAD_ENV */
1521 #define NAMEI_GLC_LOCK
1522 #define NAMEI_GLC_UNLOCK
1523 #endif /* !AFS_PTHREAD_ENV */
1524
1525 /**
1526  * get the link count of an inode.
1527  *
1528  * @param[in]  h        namei link count table file handle
1529  * @param[in]  ino      inode number for which we are requesting a link count
1530  * @param[in]  lockit   if asserted, return with lock held on link table file
1531  * @param[in]  fixup    if asserted, write 1 to link count when read() returns
1532  *                      zero (at EOF)
1533  * @param[in]  nowrite  return success on zero byte read or ZLC
1534  *
1535  * @post if lockit asserted and lookup was successful, will return with write
1536  *       lock on link table file descriptor
1537  *
1538  * @return link count
1539  *    @retval -1 namei link table i/o error
1540  *
1541  * @internal
1542  */
1543 int
1544 namei_GetLinkCount(FdHandle_t * h, Inode ino, int lockit, int fixup, int nowrite)
1545 {
1546     unsigned short row = 0;
1547     afs_foff_t offset;
1548     ssize_t rc;
1549     int index;
1550
1551     /* there's no linktable yet. the salvager will create one later */
1552     if (h->fd_fd == INVALID_FD && fixup)
1553        return 1;
1554     namei_GetLCOffsetAndIndexFromIno(ino, &offset, &index);
1555
1556     if (lockit) {
1557         if (FDH_LOCKFILE(h, offset) != 0)
1558             return -1;
1559     }
1560
1561     rc = FDH_PREAD(h, (char*)&row, sizeof(row), offset);
1562     if (rc == -1)
1563         goto bad_getLinkByte;
1564
1565     if ((rc == 0 || !((row >> index) & NAMEI_TAGMASK)) && fixup && nowrite)
1566         return 1;
1567     if (rc == 0 && fixup) {
1568         /*
1569          * extend link table and write a link count of 1 for ino
1570          *
1571          * in order to make MT-safe, truncation (extension really)
1572          * must happen under a mutex
1573          */
1574         NAMEI_GLC_LOCK;
1575         if (FDH_SIZE(h) >= offset+sizeof(row)) {
1576             NAMEI_GLC_UNLOCK;
1577             goto bad_getLinkByte;
1578         }
1579         FDH_TRUNC(h, offset+sizeof(row));
1580         row = 1 << index;
1581         rc = FDH_PWRITE(h, (char *)&row, sizeof(row), offset);
1582         NAMEI_GLC_UNLOCK;
1583     }
1584     if (rc != sizeof(row)) {
1585         goto bad_getLinkByte;
1586     }
1587
1588     if (fixup && !((row >> index) & NAMEI_TAGMASK)) {
1589         /*
1590          * fix up zlc
1591          *
1592          * in order to make this mt-safe, we need to do the read-modify-write
1593          * under a mutex.  thus, we repeat the read inside the lock.
1594          */
1595         NAMEI_GLC_LOCK;
1596         rc = FDH_PREAD(h, (char *)&row, sizeof(row), offset);
1597         if (rc == sizeof(row)) {
1598             row |= 1<<index;
1599             rc = FDH_PWRITE(h, (char *)&row, sizeof(row), offset);
1600         }
1601         NAMEI_GLC_UNLOCK;
1602         if (rc != sizeof(row))
1603             goto bad_getLinkByte;
1604     }
1605
1606     return (int)((row >> index) & NAMEI_TAGMASK);
1607
1608   bad_getLinkByte:
1609     if (lockit)
1610         FDH_UNLOCKFILE(h, offset);
1611     return -1;
1612 }
1613
1614 /* Return a free column index for this vnode. */
1615 static int
1616 GetFreeTag(IHandle_t * ih, int vno)
1617 {
1618     FdHandle_t *fdP;
1619     afs_foff_t offset;
1620     int col;
1621     int coldata;
1622     short row;
1623     ssize_t nBytes;
1624
1625
1626     fdP = IH_OPEN(ih);
1627     if (fdP == NULL)
1628         return -1;
1629
1630     /* Only one manipulates at a time. */
1631     if (FDH_LOCKFILE(fdP, offset) != 0) {
1632         FDH_REALLYCLOSE(fdP);
1633         return -1;
1634     }
1635
1636     offset = (vno << LINKTABLE_SHIFT) + 8;      /* * 2 + sizeof stamp */
1637
1638     nBytes = FDH_PREAD(fdP, (char *)&row, sizeof(row), offset);
1639     if (nBytes != sizeof(row)) {
1640         if (nBytes != 0)
1641             goto badGetFreeTag;
1642         row = 0;
1643     }
1644
1645     /* Now find a free column in this row and claim it. */
1646     for (col = 0; col < NAMEI_MAXVOLS; col++) {
1647         coldata = 7 << (col * 3);
1648         if ((row & coldata) == 0)
1649             break;
1650     }
1651     if (col >= NAMEI_MAXVOLS) {
1652         errno = ENOSPC;
1653         goto badGetFreeTag;
1654     }
1655
1656     coldata = 1 << (col * 3);
1657     row |= coldata;
1658
1659     if (FDH_PWRITE(fdP, (char *)&row, sizeof(row), offset) != sizeof(row)) {
1660         goto badGetFreeTag;
1661     }
1662     (void)FDH_SYNC(fdP);
1663     FDH_UNLOCKFILE(fdP, offset);
1664     FDH_CLOSE(fdP);
1665     return col;
1666
1667   badGetFreeTag:
1668     FDH_UNLOCKFILE(fdP, offset);
1669     FDH_REALLYCLOSE(fdP);
1670     return -1;
1671 }
1672
1673
1674
1675 /* namei_SetLinkCount
1676  * If locked is set, assume file is locked. Otherwise, lock file before
1677  * proceeding to modify it.
1678  */
1679 int
1680 namei_SetLinkCount(FdHandle_t * fdP, Inode ino, int count, int locked)
1681 {
1682     afs_foff_t offset;
1683     int index;
1684     unsigned short row;
1685     int bytesRead;
1686     ssize_t nBytes = -1;
1687
1688     namei_GetLCOffsetAndIndexFromIno(ino, &offset, &index);
1689
1690     if (!locked) {
1691         if (FDH_LOCKFILE(fdP, offset) != 0) {
1692             return -1;
1693         }
1694     }
1695
1696     nBytes = FDH_PREAD(fdP, (char *)&row, sizeof(row), offset);
1697     if (nBytes != sizeof(row)) {
1698         if (nBytes != 0) {
1699             errno = OS_ERROR(EBADF);
1700             goto bad_SetLinkCount;
1701         }
1702         row = 0;
1703     }
1704
1705     bytesRead = 7 << index;
1706     count <<= index;
1707     row &= (unsigned short)~bytesRead;
1708     row |= (unsigned short)count;
1709
1710     if (FDH_PWRITE(fdP, (char *)&row, sizeof(short), offset) != sizeof(short)) {
1711         errno = OS_ERROR(EBADF);
1712         goto bad_SetLinkCount;
1713     }
1714     (void)FDH_SYNC(fdP);
1715
1716     nBytes = 0;
1717
1718
1719   bad_SetLinkCount:
1720     FDH_UNLOCKFILE(fdP, offset);
1721
1722     /* disallowed above 7, so... */
1723     return (int)nBytes;
1724 }
1725
1726 static void
1727 namei_UnlockLinkCount(FdHandle_t * fdP, Inode ino)
1728 {
1729     afs_foff_t offset;
1730     int index;
1731
1732     namei_GetLCOffsetAndIndexFromIno(ino, &offset, &index);
1733
1734     FDH_UNLOCKFILE(fdP, offset);
1735 }
1736
1737
1738 /* ListViceInodes - write inode data to a results file. */
1739 static int DecodeInode(char *dpath, char *name, struct ViceInodeInfo *info,
1740                        IHandle_t *myIH);
1741 static int DecodeVolumeName(char *name, VolumeId *vid);
1742 static int namei_ListAFSSubDirs(IHandle_t * dirIH,
1743                                 int (*write_fun) (FD_t,
1744                                                   struct ViceInodeInfo *,
1745                                                   char *, char *), FD_t fp,
1746                                 int (*judgeFun) (struct ViceInodeInfo *,
1747                                                  VolumeId vid, void *),
1748                                 VolumeId singleVolumeNumber, void *rock);
1749
1750
1751 /* WriteInodeInfo
1752  *
1753  * Write the inode data to the results file.
1754  *
1755  * Returns -2 on error, 0 on success.
1756  *
1757  * This is written as a callback simply so that other listing routines
1758  * can use the same inode reading code.
1759  */
1760 static int
1761 WriteInodeInfo(FD_t fp, struct ViceInodeInfo *info, char *dir, char *name)
1762 {
1763     size_t n;
1764     n = OS_WRITE(fp, info, sizeof(*info));
1765     return (n == sizeof(*info)) ? 0 : -2;
1766 }
1767
1768
1769 int mode_errors;                /* Number of errors found in mode bits on directories. */
1770 void
1771 VerifyDirPerms(char *path)
1772 {
1773     struct afs_stat_st status;
1774
1775     if (afs_stat(path, &status) < 0) {
1776         Log("Unable to stat %s. Please manually verify mode bits for this"
1777             " directory\n", path);
1778     } else {
1779         if (((status.st_mode & 0777) != 0700) || (status.st_uid != 0))
1780             mode_errors++;
1781     }
1782 }
1783
1784 /**
1785  * Fill the results file with the requested inode information.
1786  *
1787  * This code optimizes single volume salvages by just looking at that one
1788  * volume's directory.
1789  *
1790  * @param[in]   devname             device name string
1791  * @param[in]   moutnedOn           vice partition mount point
1792  * @param[in]   resultFile          result file in which to write inode
1793  *                                  metadata.  If NULL, write routine is not
1794  *                                  called.
1795  * @param[in]   judgeInode          filter function pointer.  if not NULL, only
1796  *                                  inodes for which this routine returns non-
1797  *                                  zero will be written to the results file.
1798  * @param[in]   singleVolumeNumber  volume id filter
1799  * @param[out]  forcep              always set to 0 for namei impl
1800  * @param[in]   forceR              not used by namei impl
1801  * @param[in]   wpath               not used by namei impl
1802  * @param[in]   rock                opaque pointer passed to judgeInode
1803  *
1804  * @return operation status
1805  *    @retval 0   success
1806  *    @retval -1  complete failure, salvage should terminate.
1807  *    @retval -2  not enough space on partition, salvager has error message
1808  *                for this.
1809  */
1810 int
1811 ListViceInodes(char *devname, char *mountedOn, FD_t inodeFile,
1812                int (*judgeInode) (struct ViceInodeInfo * info, VolumeId vid, void *rock),
1813                VolumeId singleVolumeNumber, int *forcep, int forceR, char *wpath,
1814                void *rock)
1815 {
1816     int ninodes;
1817
1818     *forcep = 0; /* no need to salvage until further notice */
1819
1820     /* Verify protections on directories. */
1821     mode_errors = 0;
1822     VerifyDirPerms(mountedOn);
1823
1824     ninodes =
1825         namei_ListAFSFiles(mountedOn, WriteInodeInfo, inodeFile, judgeInode,
1826                            singleVolumeNumber, rock);
1827
1828     if (inodeFile == INVALID_FD)
1829         return ninodes;
1830
1831     if (ninodes < 0) {
1832         return ninodes;
1833     }
1834
1835     if (OS_SYNC(inodeFile) == -1) {
1836         Log("Unable to successfully fsync inode file for %s\n", mountedOn);
1837         return -2;
1838     }
1839
1840     /*
1841      * Paranoia:  check that the file is really the right size
1842      */
1843     if (OS_SIZE(inodeFile) != ninodes * sizeof(struct ViceInodeInfo)) {
1844         Log("Wrong size (%d instead of %lu) in inode file for %s\n",
1845             (int) OS_SIZE(inodeFile),
1846             (long unsigned int) ninodes * sizeof(struct ViceInodeInfo),
1847             mountedOn);
1848         return -2;
1849     }
1850     return 0;
1851 }
1852
1853
1854 /**
1855  * Collect all the matching AFS files on the drive.
1856  * If singleVolumeNumber is non-zero, just return files for that volume.
1857  *
1858  * @param[in] dev                 vice partition path
1859  * @param[in] writeFun            function pointer to a function which
1860  *                                writes inode information to FILE fp
1861  * @param[in] fp                  file stream where inode metadata is sent
1862  * @param[in] judgeFun            filter function pointer.  if not NULL,
1863  *                                only entries for which a non-zero value
1864  *                                is returned are written to fp
1865  * @param[in] singleVolumeNumber  volume id filter.  if nonzero, only
1866  *                                process files for that specific volume id
1867  * @param[in] rock                opaque pointer passed into writeFun and
1868  *                                judgeFun
1869  *
1870  * @return operation status
1871  *    @retval <0 error
1872  *    @retval >=0 number of matching files found
1873  */
1874 int
1875 namei_ListAFSFiles(char *dev,
1876                    int (*writeFun) (FD_t, struct ViceInodeInfo *, char *,
1877                                     char *),
1878                    FD_t fp,
1879                    int (*judgeFun) (struct ViceInodeInfo *, VolumeId, void *),
1880                    VolumeId singleVolumeNumber, void *rock)
1881 {
1882     IHandle_t ih;
1883     namei_t name;
1884     int ninodes = 0;
1885     DIR *dirp1;
1886     struct dirent *dp1;
1887 #ifndef AFS_NT40_ENV
1888     DIR *dirp2;
1889     struct dirent *dp2;
1890     char path2[512];
1891 #endif
1892 #ifdef DELETE_ZLC
1893     static void FreeZLCList(void);
1894 #endif
1895
1896     memset((void *)&ih, 0, sizeof(IHandle_t));
1897 #ifdef AFS_NT40_ENV
1898     ih.ih_dev = nt_DriveToDev(dev);
1899 #else
1900     ih.ih_dev = volutil_GetPartitionID(dev);
1901 #endif
1902
1903     if (singleVolumeNumber) {
1904         ih.ih_vid = singleVolumeNumber;
1905         namei_HandleToVolDir(&name, &ih);
1906         ninodes =
1907             namei_ListAFSSubDirs(&ih, writeFun, fp, judgeFun,
1908                                  singleVolumeNumber, rock);
1909         if (ninodes < 0)
1910             return ninodes;
1911     } else {
1912         /* Find all volume data directories and descend through them. */
1913         namei_HandleToInodeDir(&name, &ih);
1914         ninodes = 0;
1915         dirp1 = opendir(name.n_path);
1916         if (!dirp1)
1917             return 0;
1918         while ((dp1 = readdir(dirp1))) {
1919 #ifdef AFS_NT40_ENV
1920             /* Heirarchy is one level on Windows */
1921             if (!DecodeVolumeName(dp1->d_name, &ih.ih_vid)) {
1922                 ninodes +=
1923                     namei_ListAFSSubDirs(&ih, writeFun, fp, judgeFun,
1924                                          0, rock);
1925             }
1926 #else
1927             if (*dp1->d_name == '.')
1928                 continue;
1929             snprintf(path2, sizeof(path2), "%s" OS_DIRSEP "%s", name.n_path,
1930                      dp1->d_name);
1931             dirp2 = opendir(path2);
1932             if (dirp2) {
1933                 while ((dp2 = readdir(dirp2))) {
1934                     if (*dp2->d_name == '.')
1935                         continue;
1936                     if (!DecodeVolumeName(dp2->d_name, &ih.ih_vid)) {
1937                         ninodes +=
1938                             namei_ListAFSSubDirs(&ih, writeFun, fp, judgeFun,
1939                                                  0, rock);
1940                     }
1941                 }
1942                 closedir(dirp2);
1943             }
1944 #endif
1945         }
1946         closedir(dirp1);
1947     }
1948 #ifdef DELETE_ZLC
1949     FreeZLCList();
1950 #endif
1951     return ninodes;
1952 }
1953
1954 #ifdef DELETE_ZLC
1955 static void AddToZLCDeleteList(char dir, char *name);
1956 static void DeleteZLCFiles(char *path);
1957 #endif
1958
1959 /**
1960  * examine a namei volume special file.
1961  *
1962  * @param[in] path1               volume special directory path
1963  * @param[in] dname               directory entry name
1964  * @param[in] myIH                inode handle to volume directory
1965  * @param[out] linkHandle         namei link count fd handle.  if
1966  *                                the inode in question is the link
1967  *                                table, then the FdHandle is populated
1968  * @param[in] writeFun            metadata write function pointer
1969  * @param[in] fp                  file pointer where inode metadata
1970  *                                is written by (*writeFun)()
1971  * @param[in] judgeFun            inode filter function pointer.  if
1972  *                                not NULL, only inodes for which this
1973  *                                function returns non-zero are recorded
1974  *                                into fp by writeFun
1975  * @param[in] singleVolumeNumer   volume id filter.  if non-zero, only
1976  *                                inodes associated with this volume id
1977  *                                are recorded by writeFun
1978  * @param[in] rock                opaque pointer passed to writeFun and
1979  *                                judgeFun
1980  *
1981  * @return operation status
1982  *    @retval 1 count this inode
1983  *    @retval 0 don't count this inode
1984  *    @retval -1 failure
1985  *
1986  * @internal
1987  */
1988 static int
1989 _namei_examine_special(char * path1,
1990                        char * dname,
1991                        IHandle_t * myIH,
1992                        FdHandle_t * linkHandle,
1993                        int (*writeFun) (FD_t, struct ViceInodeInfo *, char *,
1994                                         char *),
1995                        FD_t fp,
1996                        int (*judgeFun) (struct ViceInodeInfo *, VolumeId, void *),
1997                        VolumeId singleVolumeNumber,
1998                        void *rock)
1999 {
2000     int ret = 0;
2001     struct ViceInodeInfo info;
2002
2003     if (DecodeInode(path1, dname, &info, myIH) < 0) {
2004         ret = 0;
2005         goto error;
2006     }
2007
2008     if (info.u.param[2] != VI_LINKTABLE) {
2009         info.linkCount = 1;
2010     } else if (info.u.param[0] != myIH->ih_vid) {
2011         /* VGID encoded in linktable filename and/or OGM data isn't
2012          * consistent with VGID encoded in namei path */
2013         Log("namei_ListAFSSubDirs: warning: inconsistent linktable "
2014             "filename \"%s" OS_DIRSEP "%s\"; salvager will delete it "
2015             "(dir_vgid=%" AFS_VOLID_FMT ", inode_vgid=%" AFS_VOLID_FMT ")\n",
2016             path1, dname, afs_printable_VolumeId_lu(myIH->ih_vid),
2017             afs_printable_VolumeId_lu(info.u.param[0]));
2018         /* We need to set the linkCount to _something_, so linkCount
2019          * doesn't just contain stack garbage. Set it to 0, so in case
2020          * the salvager or whatever our caller is does try to process
2021          * this like a normal file, we won't try to INC or DEC it. */
2022         info.linkCount = 0;
2023     } else {
2024         char path2[512];
2025         /* Open this handle */
2026         snprintf(path2, sizeof(path2),
2027                  "%s" OS_DIRSEP "%s", path1, dname);
2028         linkHandle->fd_fd = OS_OPEN(path2, Testing ? O_RDONLY : O_RDWR, 0666);
2029         info.linkCount =
2030             namei_GetLinkCount(linkHandle, (Inode) 0, 1, 1, Testing);
2031     }
2032
2033     if (!judgeFun ||
2034         (*judgeFun) (&info, singleVolumeNumber, rock)) {
2035         ret = (*writeFun) (fp, &info, path1, dname);
2036         if (ret < 0) {
2037             Log("_namei_examine_special: writeFun returned %d\n", ret);
2038             ret = -1;
2039         } else {
2040             ret = 1;
2041         }
2042     }
2043
2044  error:
2045     return ret;
2046 }
2047
2048 /**
2049  * examine a namei file.
2050  *
2051  * @param[in] path3               volume special directory path
2052  * @param[in] dname               directory entry name
2053  * @param[in] myIH                inode handle to volume directory
2054  * @param[in] linkHandle          namei link count fd handle.
2055  * @param[in] writeFun            metadata write function pointer
2056  * @param[in] fp                  file pointer where inode metadata
2057  *                                is written by (*writeFun)()
2058  * @param[in] judgeFun            inode filter function pointer.  if
2059  *                                not NULL, only inodes for which this
2060  *                                function returns non-zero are recorded
2061  *                                into fp by writeFun
2062  * @param[in] singleVolumeNumer   volume id filter.  if non-zero, only
2063  *                                inodes associated with this volume id
2064  *                                are recorded by writeFun
2065  * @param[in] rock                opaque pointer passed to writeFun and
2066  *                                judgeFun
2067  *
2068  * @return operation status
2069  *    @retval 1 count this inode
2070  *    @retval 0 don't count this inode
2071  *    @retval -1 failure
2072  *    @retval -2 request ZLC delete
2073  *
2074  * @internal
2075  */
2076 static int
2077 _namei_examine_reg(char * path3,
2078                    char * dname,
2079                    IHandle_t * myIH,
2080                    FdHandle_t * linkHandle,
2081                    int (*writeFun) (FD_t, struct ViceInodeInfo *, char *,
2082                                     char *),
2083                    FD_t fp,
2084                    int (*judgeFun) (struct ViceInodeInfo *, VolumeId, void *),
2085                    VolumeId singleVolumeNumber,
2086                    void *rock)
2087 {
2088     int ret = 0;
2089     struct ViceInodeInfo info;
2090 #ifdef DELETE_ZLC
2091     int dirl; /* Windows-only (one level hash dir) */
2092 #endif
2093
2094     if (DecodeInode(path3, dname, &info, myIH) < 0) {
2095         goto error;
2096     }
2097
2098     info.linkCount =
2099         namei_GetLinkCount(linkHandle,
2100                             info.inodeNumber, 1, 1, Testing);
2101     if (info.linkCount == 0) {
2102 #ifdef DELETE_ZLC
2103         Log("Found 0 link count file %s" OS_DIRSEP "%s, deleting it.\n", path3, dname);
2104 #ifdef AFS_SALSRV_ENV
2105         /* defer -- the AddToZLCDeleteList() interface is not MT-safe */
2106         ret = -2;
2107 #else /* !AFS_SALSRV_ENV */
2108         dirl = path3[strlen(path3)-1];
2109         AddToZLCDeleteList((char)dirl, dname);
2110 #endif /* !AFS_SALSRV_ENV */
2111 #else /* !DELETE_ZLC */
2112         Log("Found 0 link count file %s" OS_DIRSEP "%s.\n", path3,
2113             dname);
2114 #endif
2115         goto error;
2116     }
2117
2118     if (!judgeFun ||
2119         (*judgeFun) (&info, singleVolumeNumber, rock)) {
2120         ret = (*writeFun) (fp, &info, path3, dname);
2121         if (ret < 0) {
2122             Log("_namei_examine_reg: writeFun returned %d\n", ret);
2123             ret = -1;
2124         } else {
2125             ret = 1;
2126         }
2127     }
2128
2129  error:
2130     return ret;
2131 }
2132
2133 /**
2134  * listsubdirs work queue node.
2135  */
2136 struct listsubdirs_work_node {
2137 #ifdef AFS_SALSRV_ENV
2138     int *error;                         /**< *error set if an error was
2139                                          *   encountered in any listsubdirs
2140                                          *   thread. */
2141 #endif
2142
2143     IHandle_t * IH;                     /**< volume directory handle */
2144     FdHandle_t *linkHandle;             /**< namei link count fd handle. when
2145                                          *   examinining the link table special
2146                                          *   inode, this will be pointed at the
2147                                          *   link table
2148                                          */
2149     FD_t fp;                            /**< file pointer for writeFun */
2150
2151     /** function which will write inode metadata to fp */
2152     int (*writeFun) (FD_t, struct ViceInodeInfo *, char *, char *);
2153
2154     /** inode filter function */
2155     int (*judgeFun) (struct ViceInodeInfo *, VolumeId, void *);
2156     VolumeId singleVolumeNumber;             /**< volume id filter */
2157     void * rock;                        /**< pointer passed to writeFun and judgeFun */
2158     int code;                           /**< return code from examine function */
2159     int special;                        /**< asserted when this is a volume
2160                                          *   special file */
2161 };
2162
2163 /**
2164  * simple wrapper around _namei_examine_special and _namei_examine_reg.
2165  *
2166  * @param[in] work  the struct listsubdirs_work_node for the associated
2167  *                  "list subdirs" job
2168  * @param[in] dir   the directory to examine
2169  * @param[in] filename  the filename in 'dir' to examine
2170  *
2171  * @return operation status
2172  *   @retval 1  count this inode
2173  *   @retval 0  don't count this inode
2174  *   @retval -1 failure
2175  */
2176 static_inline int
2177 _namei_examine_file(const struct listsubdirs_work_node *work, char *dir,
2178                     char *filename)
2179 {
2180     if (work->special) {
2181         return _namei_examine_special(dir, filename, work->IH,
2182                                       work->linkHandle, work->writeFun, work->fp,
2183                                       work->judgeFun, work->singleVolumeNumber,
2184                                       work->rock);
2185     } else {
2186         return _namei_examine_reg(dir, filename, work->IH,
2187                                   work->linkHandle, work->writeFun, work->fp,
2188                                   work->judgeFun, work->singleVolumeNumber,
2189                                   work->rock);
2190     }
2191 }
2192
2193
2194 #ifdef AFS_SALSRV_ENV
2195 /** @addtogroup afs_vol_salsrv_pario */
2196 /*@{*/
2197
2198 /**
2199  * arguments for the _namei_examine_file_cbk callback function.
2200  */
2201 struct listsubdirs_args {
2202     const struct listsubdirs_work_node *work; /**< arguments that are the same
2203                                                *   for all invocations of
2204                                                *   _namei_examine_file_cbk, in
2205                                                *   threads */
2206     int *result;        /**< where we can store the return code of _namei_examine_file */
2207
2208     char dir[512];      /**< directory to examine */
2209     char filename[256]; /**< filename in 'dir' to examine */
2210 };
2211
2212 /**
2213  * a node in the list of results of listsubdir jobs.
2214  */
2215 struct listsubdirs_result {
2216     struct rx_queue q;
2217     int inodes;        /**< return value from _namei_examine_file */
2218 };
2219
2220 /**
2221  * clean up a list of 'struct listsubdirs_result's and interpret the results.
2222  *
2223  * @param[in] resultlist  a list of 'struct listsubdirs_result's
2224  *
2225  * @return number of inodes found
2226  *   @retval -1  error
2227  */
2228 static int
2229 _namei_listsubdirs_cleanup_results(struct rx_queue *resultlist)
2230 {
2231     struct listsubdirs_result *res, *nres;
2232     int ret = 0;
2233
2234     for(queue_Scan(resultlist, res, nres, listsubdirs_result)) {
2235         if (ret < 0) {
2236             /* noop, retain erroneous error code */
2237         } else if (res->inodes < 0) {
2238             ret = -1;
2239         } else {
2240             ret += res->inodes;
2241         }
2242
2243         queue_Remove(res);
2244         free(res);
2245         res = NULL;
2246     }
2247
2248     return ret;
2249 }
2250
2251 /**
2252  * wait for the spawned listsubdirs jobs to finish, and return how many inodes
2253  * they found.
2254  *
2255  * @param[in] queue    queue to wait to finish
2256  * @param[in] resultlist list of 'struct listsubdirs_result's that the queued
2257  *                       jobs are storing their results in
2258  *
2259  * @return number of inodes found
2260  *   @retval -1  error
2261  */
2262 static int
2263 _namei_listsubdirs_wait(struct afs_work_queue *queue, struct rx_queue *resultlist)
2264 {
2265     int code;
2266
2267     code = afs_wq_wait_all(queue);
2268     if (code) {
2269         return -1;
2270     }
2271
2272     return _namei_listsubdirs_cleanup_results(resultlist);
2273 }
2274
2275 /**
2276  * work queue entry point for examining namei files.
2277  *
2278  * @param[in] queue        pointer to struct Vwork_queue
2279  * @param[in] node         pointer to struct Vwork_queue_node
2280  * @param[in] queue_rock   opaque pointer to struct salsrv_pool_state
2281  * @param[in] node_rock    opaque pointer to struct listsubdirs_work_node
2282  * @param[in] caller_rock  opaque pointer to struct salsrv_worker_thread_state
2283  *
2284  * @return operation status
2285  *
2286  * @see Vwork_queue_callback_func_t
2287  *
2288  * @internal
2289  */
2290 static int
2291 _namei_examine_file_cbk(struct afs_work_queue *queue,
2292                         struct afs_work_queue_node *node,
2293                         void *queue_rock,
2294                         void *node_rock,
2295                         void *caller_rock)
2296 {
2297     int code;
2298     struct listsubdirs_args *args = node_rock;
2299     const struct listsubdirs_work_node * work = args->work;
2300     char *dir = args->dir;
2301     char *filename = args->filename;
2302
2303     code = _namei_examine_file(work, dir, filename);
2304
2305     *(args->result) = code;
2306
2307     if (code < 0) {
2308         *(work->error) = 1;
2309         /* we've errored, so no point in letting more jobs continue */
2310         afs_wq_shutdown(queue);
2311     }
2312
2313     return 0;
2314 }
2315
2316 static pthread_once_t wq_once = PTHREAD_ONCE_INIT;
2317 static pthread_key_t wq_key;
2318
2319 /**
2320  * create the wq_key key for storing a work queue.
2321  */
2322 static void
2323 _namei_wq_keycreate(void)
2324 {
2325     opr_Verify(pthread_key_create(&wq_key, NULL) == 0);
2326 }
2327
2328 /**
2329  * set the work queue for this thread to use for backgrounding namei ops.
2330  *
2331  * The work queue will be used in ListAFSSubdirs (called indirectly by
2332  * ListViceInodes) to examine files in parallel.
2333  *
2334  * @param[in] wq  the work queue to use
2335  */
2336 void
2337 namei_SetWorkQueue(struct afs_work_queue *wq)
2338 {
2339     opr_Verify(pthread_once(&wq_once, _namei_wq_keycreate) == 0);
2340
2341     opr_Verify(pthread_setspecific(wq_key, wq) == 0);
2342 }
2343
2344 /**
2345  * enqueue an examine file work unit.
2346  *
2347  * @param[in] work     the _namei_examine_file arguments that are common to
2348  *                     all callers within the same ListAFSFiles operation
2349  * @param[in] dir      the specific directory to look at (string will be
2350  *                     copied; can be stack/temporary memory)
2351  * @param[in] filename the filename to look at (string will be copied; can be
2352  *                     stack/temporary memory)
2353  * @param[in] wq       work queue to enqueue this work unit to
2354  * @param[in] resultlist the list to append the 'struct listsubdirs_result' to
2355  *                       for the enqueued work unit
2356  *
2357  * @return operation status
2358  *    @retval 0 success
2359  *    @retval -1 fatal error
2360  *
2361  * @note errors MUST be indicated by a -1 error code and nothing else, to be
2362  *       compatible with _namei_examine_reg and _namei_examine_special
2363  *
2364  * @internal
2365  */
2366 static int
2367 _namei_examine_file_spawn(const struct listsubdirs_work_node *work,
2368                           const char *dir, const char *filename,
2369                           struct afs_work_queue *wq,
2370                           struct rx_queue *resultlist)
2371 {
2372     int code, ret = 0;
2373     struct listsubdirs_args *args = NULL;
2374     struct listsubdirs_result *result = NULL;
2375     struct afs_work_queue_node *node = NULL;
2376     struct afs_work_queue_add_opts opts;
2377
2378     args = malloc(sizeof(*args));
2379     if (args == NULL) {
2380         ret = -1;
2381         goto error;
2382     }
2383
2384     result = malloc(sizeof(*result));
2385     if (result == NULL) {
2386         ret = -1;
2387         goto error;
2388     }
2389
2390     code = afs_wq_node_alloc(&node);
2391     if (code) {
2392         ret = -1;
2393         goto error;
2394     }
2395     code = afs_wq_node_set_detached(node);
2396     if (code) {
2397         ret = -1;
2398         goto error;
2399     }
2400
2401     args->work = work;
2402     args->result = &result->inodes;
2403     strlcpy(args->dir, dir, sizeof(args->dir));
2404     strlcpy(args->filename, filename, sizeof(args->filename));
2405
2406     code = afs_wq_node_set_callback(node,
2407                                          &_namei_examine_file_cbk,
2408                                          args, &free);
2409     if (code) {
2410         ret = -1;
2411         goto error;
2412     }
2413     args = NULL;
2414
2415     afs_wq_add_opts_init(&opts);
2416     opts.donate = 1;
2417
2418     code = afs_wq_add(wq, node, &opts);
2419     if (code) {
2420         ret = -1;
2421         goto error;
2422     }
2423     node = NULL;
2424
2425     queue_Append(resultlist, result);
2426     result = NULL;
2427
2428  error:
2429     if (node) {
2430         afs_wq_node_put(node);
2431         node = NULL;
2432     }
2433     if (args) {
2434         free(args);
2435         args = NULL;
2436     }
2437     if (result) {
2438         free(result);
2439         result = NULL;
2440     }
2441
2442     return ret;
2443 }
2444
2445 /*@}*/
2446 #else /* !AFS_SALSRV_ENV */
2447 # define _namei_examine_file_spawn(work, dir, file, wq, resultlist) \
2448          _namei_examine_file(work, dir, file)
2449 #endif /* !AFS_SALSRV_ENV */
2450
2451 /**
2452  * traverse and check inodes.
2453  *
2454  * @param[in] dirIH               volume group directory handle
2455  * @param[in] writeFun            function pointer which will write inode
2456  *                                metadata to FILE stream fp
2457  * @param[in] fp                  file stream where inode metadata gets
2458  *                                written
2459  * @param[in] judgeFun            inode filter function.  if not NULL, only
2460  *                                inodes for which the filter returns non-zero
2461  *                                will be written out by writeFun
2462  * @param[in] singleVolumeNumber  volume id filter.  only inodes matching this
2463  *                                filter are written out by writeFun
2464  * @param[in] rock                opaque pointer passed to judgeFun and writeFun
2465  *
2466  * @return operation status
2467  *    @retval <0 error
2468  *    @retval >=0 number of matching inodes found
2469  *
2470  * @todo the salsrv implementation may consume a lot of
2471  *       memory for a large volume.  at some point we should
2472  *       probably write a background thread to asynchronously
2473  *       clean up the resultlist nodes to reduce memory footprint
2474  *
2475  * @internal
2476  */
2477 static int
2478 namei_ListAFSSubDirs(IHandle_t * dirIH,
2479                      int (*writeFun) (FD_t, struct ViceInodeInfo *, char *,
2480                                       char *),
2481                      FD_t fp,
2482                      int (*judgeFun) (struct ViceInodeInfo *, VolumeId, void *),
2483                      VolumeId singleVolumeNumber, void *rock)
2484 {
2485     int code = 0, ret = 0;
2486     IHandle_t myIH = *dirIH;
2487     namei_t name;
2488     char path1[512], path3[512];
2489     DIR *dirp1, *dirp3;
2490 #ifndef AFS_NT40_ENV
2491     DIR *dirp2;
2492     struct dirent *dp2;
2493     char path2[512];
2494 #endif
2495     struct dirent *dp1, *dp3;
2496     FdHandle_t linkHandle;
2497     int ninodes = 0;
2498     struct listsubdirs_work_node work;
2499 #ifdef AFS_SALSRV_ENV
2500     int error = 0;
2501     struct afs_work_queue *wq;
2502     int wq_up = 0;
2503     struct rx_queue resultlist;
2504 #endif
2505
2506     namei_HandleToVolDir(&name, &myIH);
2507     strlcpy(path1, name.n_path, sizeof(path1));
2508
2509     /* Do the directory containing the special files first to pick up link
2510      * counts.
2511      */
2512     (void)strcat(path1, OS_DIRSEP);
2513     (void)strcat(path1, NAMEI_SPECDIR);
2514
2515     linkHandle.fd_fd = INVALID_FD;
2516 #ifdef AFS_SALSRV_ENV
2517     opr_Verify(pthread_once(&wq_once, _namei_wq_keycreate) == 0);
2518
2519     wq = pthread_getspecific(wq_key);
2520     if (!wq) {
2521         ret = -1;
2522         goto error;
2523     }
2524     wq_up = 1;
2525     queue_Init(&resultlist);
2526 #endif
2527
2528     memset(&work, 0, sizeof(work));
2529     work.linkHandle = &linkHandle;
2530     work.IH = &myIH;
2531     work.fp = fp;
2532     work.writeFun = writeFun;
2533     work.judgeFun = judgeFun;
2534     work.singleVolumeNumber = singleVolumeNumber;
2535     work.rock = rock;
2536     work.special = 1;
2537 #ifdef AFS_SALSRV_ENV
2538     work.error = &error;
2539 #endif
2540
2541     dirp1 = opendir(path1);
2542     if (dirp1) {
2543         while ((dp1 = readdir(dirp1))) {
2544             if (*dp1->d_name == '.')
2545                 continue;
2546
2547 #ifdef AFS_SALSRV_ENV
2548             if (error) {
2549                 closedir(dirp1);
2550                 ret = -1;
2551                 goto error;
2552             }
2553 #endif /* AFS_SALSRV_ENV */
2554
2555             code = _namei_examine_file_spawn(&work, path1, dp1->d_name, wq, &resultlist);
2556
2557             switch (code) {
2558             case -1:
2559                 /* fatal error */
2560                 closedir(dirp1);
2561                 ret = -1;
2562                 goto error;
2563
2564             case 1:
2565                 /* count this inode */
2566 #ifndef AFS_SALSRV_ENV
2567                 ninodes++;
2568 #endif
2569                 break;
2570             }
2571         }
2572         closedir(dirp1);
2573     }
2574
2575 #ifdef AFS_SALSRV_ENV
2576     /* effectively a barrier */
2577     code = _namei_listsubdirs_wait(wq, &resultlist);
2578     if (code < 0 || error) {
2579         ret = -1;
2580         goto error;
2581     }
2582     error = 0;
2583     ninodes += code;
2584 #endif
2585
2586     if (linkHandle.fd_fd == INVALID_FD) {
2587         Log("namei_ListAFSSubDirs: warning: VG %" AFS_VOLID_FMT " does not have a link table; "
2588             "salvager will recreate it.\n", afs_printable_VolumeId_lu(dirIH->ih_vid));
2589     }
2590
2591     /* Now run through all the other subdirs */
2592     namei_HandleToVolDir(&name, &myIH);
2593     strlcpy(path1, name.n_path, sizeof(path1));
2594
2595     work.special = 0;
2596
2597     dirp1 = opendir(path1);
2598     if (dirp1) {
2599         while ((dp1 = readdir(dirp1))) {
2600 #ifndef AFS_NT40_ENV
2601             if (*dp1->d_name == '.')
2602                 continue;
2603 #endif
2604             if (!strcmp(dp1->d_name, NAMEI_SPECDIR))
2605                 continue;
2606
2607 #ifndef AFS_NT40_ENV /* This level missing on Windows */
2608             /* Now we've got a next level subdir. */
2609             snprintf(path2, sizeof(path2), "%s" OS_DIRSEP "%s",
2610                      path1, dp1->d_name);
2611             dirp2 = opendir(path2);
2612             if (dirp2) {
2613                 while ((dp2 = readdir(dirp2))) {
2614                     if (*dp2->d_name == '.')
2615                         continue;
2616
2617                     /* Now we've got to the actual data */
2618                     snprintf(path3, sizeof(path3), "%s" OS_DIRSEP "%s",
2619                              path2, dp2->d_name);
2620 #else
2621                     /* Now we've got to the actual data */
2622                     snprintf(path3, sizeof(path3), "%s" OS_DIRSEP "%s",
2623                              path1, dp1->d_name);
2624 #endif
2625                     dirp3 = opendir(path3);
2626                     if (dirp3) {
2627                         while ((dp3 = readdir(dirp3))) {
2628 #ifndef AFS_NT40_ENV
2629                             if (*dp3->d_name == '.')
2630                                 continue;
2631 #endif
2632
2633 #ifdef AFS_SALSRV_ENV
2634                             if (error) {
2635                                 closedir(dirp3);
2636 #ifndef AFS_NT40_ENV
2637                                 closedir(dirp2);
2638 #endif
2639                                 closedir(dirp1);
2640                                 ret = -1;
2641                                 goto error;
2642                             }
2643 #endif /* AFS_SALSRV_ENV */
2644
2645                             code = _namei_examine_file_spawn(&work, path3,
2646                                                              dp3->d_name, wq,
2647                                                              &resultlist);
2648
2649                             switch (code) {
2650                             case -1:
2651                                 closedir(dirp3);
2652 #ifndef AFS_NT40_ENV
2653                                 closedir(dirp2);
2654 #endif
2655                                 closedir(dirp1);
2656                                 ret = -1;
2657                                 goto error;
2658
2659                             case 1:
2660 #ifndef AFS_SALSRV_ENV
2661                                 ninodes++;
2662 #endif
2663                                 break;
2664                             }
2665                         }
2666                         closedir(dirp3);
2667                     }
2668 #ifndef AFS_NT40_ENV /* This level missing on Windows */
2669                 }
2670                 closedir(dirp2);
2671             }
2672 #endif
2673         }
2674         closedir(dirp1);
2675     }
2676
2677 #ifdef AFS_SALSRV_ENV
2678     /* effectively a barrier */
2679     code = _namei_listsubdirs_wait(wq, &resultlist);
2680     if (code < 0 || error) {
2681         ret = -1;
2682         goto error;
2683     }
2684     error = 0;
2685     ninodes += code;
2686     wq_up = 0;
2687 #endif
2688
2689     if (!ninodes) {
2690         /* Then why does this directory exist? Blow it away. */
2691         namei_HandleToVolDir(&name, dirIH);
2692         namei_RemoveDataDirectories(&name);
2693     }
2694
2695  error:
2696 #ifdef AFS_SALSRV_ENV
2697     if (wq_up) {
2698         afs_wq_wait_all(wq);
2699     }
2700     _namei_listsubdirs_cleanup_results(&resultlist);
2701 #endif
2702     if (linkHandle.fd_fd != INVALID_FD)
2703         OS_CLOSE(linkHandle.fd_fd);
2704
2705     if (!ret) {
2706         ret = ninodes;
2707     }
2708     return ret;
2709 }
2710
2711 /*@}*/
2712
2713 #ifdef AFS_NT40_ENV
2714 static int
2715 DecodeVolumeName(char *name, VolumeId *vid)
2716 {
2717     /* Name begins with "Vol_" and ends with .data.  See nt_HandleToVolDir() */
2718     char stmp[32];
2719     size_t len;
2720
2721     len = strlen(name);
2722     if (len <= 9)
2723         return -1;
2724     if (strncmp(name, "Vol_", 4))
2725         return -1;
2726     if (strcmp(name + len - 5, ".data"))
2727         return -1;
2728     strcpy(stmp, name);
2729     stmp[len - 5] = '\0';
2730     *vid = base32_to_int(stmp + 4);
2731     return 0;
2732 }
2733 #else
2734 static int
2735 DecodeVolumeName(char *name, VolumeId *vid)
2736 {
2737     if (strlen(name) < 1)
2738         return -1;
2739     *vid = (unsigned int)flipbase64_to_int64(name);
2740     return 0;
2741 }
2742 #endif
2743
2744
2745 /* DecodeInode
2746  *
2747  * Get the inode number from the name.
2748  *
2749  */
2750 #ifdef AFS_NT40_ENV
2751 static int
2752 DecodeInode(char *dpath, char *name, struct ViceInodeInfo *info,
2753             IHandle_t *myIH)
2754 {
2755     char fpath[512];
2756     int tag, vno;
2757     WIN32_FIND_DATA data;
2758     HANDLE dirH;
2759     char *s, *t;
2760     char stmp[16];
2761     FdHandle_t linkHandle;
2762     char dirl;
2763     VolumeId volid = myIH->ih_vid;
2764
2765     snprintf(fpath, sizeof(fpath), "%s" OS_DIRSEP "%s", dpath, name);
2766
2767     dirH = FindFirstFileEx(fpath, FindExInfoStandard, &data,
2768                            FindExSearchNameMatch, NULL,
2769                            FIND_FIRST_EX_CASE_SENSITIVE);
2770     if (dirH == INVALID_HANDLE_VALUE)
2771         return -1;
2772
2773     (void)strcpy(stmp, name);
2774     s = strrchr(stmp, '_');
2775     if (!s)
2776         return -1;
2777     s++;
2778     t = strrchr(s, '.');
2779     if (!t)
2780         return -1;
2781
2782     *t = '\0';
2783     vno = base32_to_int(s);     /* type for special files */
2784     tag = base32_to_int(t+1);
2785     info->inodeNumber = ((Inode) tag) << NAMEI_TAGSHIFT;
2786     info->inodeNumber |= vno;
2787     info->byteCount = data.nFileSizeLow;
2788
2789     dirl = dpath[strlen(dpath)-1];
2790     if (dirl == NAMEI_SPECDIRC) { /* Special inode. */
2791         info->inodeNumber |= NAMEI_INODESPECIAL;
2792         info->u.param[0] = data.ftCreationTime.dwHighDateTime;
2793         info->u.param[1] = data.ftCreationTime.dwLowDateTime;
2794         info->u.param[2] = vno; /* type */
2795         info->u.param[3] = volid;
2796         if (vno != VI_LINKTABLE)
2797             info->linkCount = 1;
2798         else {
2799             /* Open this handle */
2800             char lpath[1024];
2801             (void)sprintf(lpath, "%s" OS_DIRSEP "%s", fpath, data.cFileName);
2802             linkHandle.fd_fd = OS_OPEN(lpath, O_RDONLY, 0666);
2803             info->linkCount =
2804                 namei_GetLinkCount(&linkHandle, (Inode) 0, 0, 0, 0);
2805         }
2806     } else {
2807         info->linkCount =
2808             namei_GetLinkCount(&linkHandle, info->inodeNumber, 0, 0, 0);
2809         if (info->linkCount == 0) {
2810 #ifdef DELETE_ZLC
2811             Log("Found 0 link count file %s" OS_DIRSEP "%s, deleting it.\n",
2812                 fpath, data.cFileName);
2813             AddToZLCDeleteList(dirl, data.cFileName);
2814 #else
2815             Log("Found 0 link count file %s" OS_DIRSEP "%s.\n", path,
2816                 data.cFileName);
2817 #endif
2818         } else {
2819             info->u.param[2] = data.ftCreationTime.dwHighDateTime;
2820             info->u.param[3] = data.ftCreationTime.dwLowDateTime;
2821             info->u.param[1] = vno;
2822             info->u.param[0] = volid;
2823         }
2824     }
2825     return 0;
2826 }
2827 #else
2828 static int
2829 DecodeInode(char *dpath, char *name, struct ViceInodeInfo *info,
2830             IHandle_t *myIH)
2831 {
2832     char fpath[512];
2833     struct afs_stat_st status;
2834     struct afs_stat_st checkstatus;
2835     int parm, tag;
2836     lb64_string_t check;
2837     VolumeId volid = myIH->ih_vid;
2838     IHandle_t tmpih;
2839     namei_t nameiname;
2840
2841     snprintf(fpath, sizeof(fpath), "%s" OS_DIRSEP "%s", dpath, name);
2842
2843     if (afs_stat(fpath, &status) < 0) {
2844         return -1;
2845     }
2846
2847     info->byteCount = status.st_size;
2848     info->inodeNumber = (Inode) flipbase64_to_int64(name);
2849
2850     int64_to_flipbase64(check, info->inodeNumber);
2851     if (strcmp(name, check))
2852         return -1;
2853
2854     /* Check if the _full_ path is correct, to ensure we can actually open this
2855      * file later. Otherwise, the salvager can choke. */
2856     memset(&tmpih, 0, sizeof(tmpih));
2857     tmpih.ih_dev = myIH->ih_dev;
2858     tmpih.ih_vid = myIH->ih_vid;
2859     tmpih.ih_ino = info->inodeNumber;
2860     namei_HandleToName(&nameiname, &tmpih);
2861     if ((afs_stat(nameiname.n_path, &checkstatus) < 0) ||
2862         checkstatus.st_ino != status.st_ino ||
2863         checkstatus.st_size != status.st_size) {
2864         static int logged;
2865         /* log something for this case, since this means the filename looks
2866          * like a valid inode, but it's just in the wrong place. That's pretty
2867          * strange. */
2868         if (!logged) {
2869             logged = 1;
2870             Log("Note:\n");
2871             Log("  Seemingly-misplaced files have been found, which I am\n");
2872             Log("  ignoring for now. If you cannot salvage the relevant volume,\n");
2873             Log("  you may try manually moving them to their correct location.\n");
2874             Log("  If the relevant volume seems fine, and these files do not\n");
2875             Log("  appear to contain important data, you can probably manually\n");
2876             Log("  delete them, or leave them alone. Contact your local OpenAFS\n");
2877             Log("  expert if you are unsure.\n");
2878         }
2879         Log("Ignoring misplaced file in volume group %u: %s (should be %s)\n",
2880             (unsigned)myIH->ih_vid, fpath, nameiname.n_path);
2881         return -1;
2882     }
2883
2884     if ((info->inodeNumber & NAMEI_INODESPECIAL) == NAMEI_INODESPECIAL) {
2885         parm = ((info->inodeNumber >> NAMEI_UNIQSHIFT) & NAMEI_UNIQMASK);
2886         tag = (int)((info->inodeNumber >> NAMEI_TAGSHIFT) & NAMEI_TAGMASK);
2887
2888         /* p1 - vid, p2 - -1, p3 - type, p4 - rwvid */
2889         info->u.param[0] = parm;
2890         info->u.param[1] = -1;
2891         info->u.param[2] = tag;
2892         info->u.param[3] = volid;
2893     } else {
2894         GetOGMFromStat(&status, &parm, &tag);
2895         /* p1 - vid, p2 - vno, p3 - uniq, p4 - dv */
2896         info->u.param[0] = volid;
2897         info->u.param[1] = (int)(info->inodeNumber & NAMEI_VNODEMASK);
2898         info->u.param[2] = (int)((info->inodeNumber >> NAMEI_UNIQSHIFT)
2899                                  & (Inode) NAMEI_UNIQMASK);
2900         info->u.param[3] = parm;
2901     }
2902     return 0;
2903 }
2904 #endif
2905
2906 /*
2907  * Convert the VolumeInfo file from RO to RW
2908  * this routine is called by namei_convertROtoRWvolume()
2909  */
2910
2911 #ifdef FSSYNC_BUILD_CLIENT
2912 static afs_int32
2913 convertVolumeInfo(FD_t fdr, FD_t fdw, VolumeId vid)
2914 {
2915     struct VolumeDiskData vd;
2916     char *p;
2917
2918     if (OS_READ(fdr, &vd, sizeof(struct VolumeDiskData)) !=
2919         sizeof(struct VolumeDiskData)) {
2920         Log("1 convertVolumeInfo: read failed for %" AFS_VOLID_FMT " with code %d\n",
2921             afs_printable_VolumeId_lu(vid),
2922             errno);
2923         return -1;
2924     }
2925     vd.restoredFromId = vd.id;  /* remember the RO volume here */
2926     vd.cloneId = vd.id;
2927     vd.id = vd.parentId;
2928     vd.type = RWVOL;
2929     vd.dontSalvage = 0;
2930     vd.inUse = 0;
2931     vd.uniquifier += 5000;      /* just in case there are still file copies from
2932                                  * the old RW volume around */
2933
2934     /* For ROs, the copyDate contains the time that the RO volume was actually
2935      * created, and the creationDate just contains the last time the RO was
2936      * copied from the RW data. So, make the new RW creationDate more accurate
2937      * by setting it to copyDate, if copyDate is older. Since, we know the
2938      * volume is at least as old as copyDate. */
2939     if (vd.copyDate < vd.creationDate) {
2940         vd.creationDate = vd.copyDate;
2941     } else {
2942         /* If copyDate is newer, just make copyDate and creationDate the same,
2943          * for consistency with other RWs */
2944         vd.copyDate = vd.creationDate;
2945     }
2946
2947     p = strrchr(vd.name, '.');
2948     if (p && !strcmp(p, ".readonly")) {
2949         memset(p, 0, 9);
2950     }
2951     if (OS_WRITE(fdw, &vd, sizeof(struct VolumeDiskData)) !=
2952         sizeof(struct VolumeDiskData)) {
2953         Log("1 convertVolumeInfo: write failed for %lu with code %d\n",
2954             afs_printable_uint32_lu(vid),
2955             errno);
2956         return -1;
2957     }
2958     return 0;
2959 }
2960 #endif
2961
2962 /*
2963  * Convert a RO-volume into a RW-volume
2964  *
2965  * This function allows to recover very fast from the loss of a partition
2966  * from RO-copies if all RO-Copies exist on another partition.
2967  * Then these RO-volumes can be made to the new RW-volumes.
2968  * Backup of RW-volumes then consists in "vos release".
2969  *
2970  * We must make sure in this partition exists only the RO-volume which
2971  * is typical for remote replicas.
2972  *
2973  * Then the linktable is already ok,
2974  *      the vnode files need to be renamed
2975  *      the volinfo file needs to be replaced by another one with
2976  *                      slightly different contents and new name.
2977  * The volume header file of the RO-volume in the /vicep<x> directory
2978  * is destroyed by this call. A new header file for the RW-volume must
2979  * be created after return from this routine.
2980  */
2981
2982 int
2983 namei_ConvertROtoRWvolume(char *pname, VolumeId volumeId)
2984 {
2985     int code = 0;
2986 #ifdef FSSYNC_BUILD_CLIENT
2987     namei_t n;
2988     char dir_name[512], oldpath[512], newpath[512];
2989     char smallName[64];
2990     char largeName[64];
2991     char infoName[64];
2992     IHandle_t t_ih;
2993     IHandle_t *ih;
2994     char infoSeen = 0;
2995     char smallSeen = 0;
2996     char largeSeen = 0;
2997     char linkSeen = 0;
2998     FD_t fd, fd2;
2999     char *p;
3000     DIR *dirp;
3001     Inode ino;
3002     struct dirent *dp;
3003     struct DiskPartition64 *partP;
3004     struct ViceInodeInfo info;
3005     struct VolumeDiskHeader h;
3006     char *rwpart, *rwname;
3007     Error ec;
3008 # ifdef AFS_DEMAND_ATTACH_FS
3009     int locktype = 0;
3010 # endif /* AFS_DEMAND_ATTACH_FS */
3011
3012     for (partP = DiskPartitionList; partP && strcmp(partP->name, pname);
3013          partP = partP->next);
3014     if (!partP) {
3015         Log("1 namei_ConvertROtoRWvolume: Couldn't find DiskPartition for %s\n", pname);
3016         code = EIO;
3017         goto done;
3018     }
3019
3020 # ifdef AFS_DEMAND_ATTACH_FS
3021     locktype = VVolLockType(V_VOLUPD, 1);
3022     code = VLockVolumeByIdNB(volumeId, partP, locktype);
3023     if (code) {
3024         locktype = 0;
3025         code = EIO;
3026         goto done;
3027     }
3028 # endif /* AFS_DEMAND_ATTACH_FS */
3029
3030     if (VReadVolumeDiskHeader(volumeId, partP, &h)) {
3031         Log("1 namei_ConvertROtoRWvolume: Couldn't read header for RO-volume %lu.\n",
3032             afs_printable_uint32_lu(volumeId));
3033         code = EIO;
3034         goto done;
3035     }
3036
3037     /* check for existing RW on any partition on this server; */
3038     /* if found, return EXDEV - invalid cross-device link */
3039     VOL_LOCK;
3040     VGetVolumePath(&ec, h.parent, &rwpart, &rwname);
3041     if (ec == 0) {
3042         Log("1 namei_ConvertROtoRWvolume: RW volume %lu already exists on server partition %s.\n",
3043             afs_printable_uint32_lu(h.parent), rwpart);
3044         code = EXDEV;
3045         VOL_UNLOCK;
3046         goto done;
3047     }
3048     VOL_UNLOCK;
3049
3050     FSYNC_VolOp(volumeId, pname, FSYNC_VOL_BREAKCBKS, 0, NULL);
3051
3052     ino = namei_MakeSpecIno(h.parent, VI_LINKTABLE);
3053     IH_INIT(ih, partP->device, h.parent, ino);
3054
3055     namei_HandleToName(&n, ih);
3056     strlcpy(dir_name, n.n_path, sizeof(dir_name));
3057     p = strrchr(dir_name, OS_DIRSEPC);
3058     *p = 0;
3059     dirp = opendir(dir_name);
3060     if (!dirp) {
3061         Log("1 namei_ConvertROtoRWvolume: Could not opendir(%s)\n", dir_name);
3062         code = EIO;
3063         goto done;
3064     }
3065
3066     while ((dp = readdir(dirp))) {
3067         /* struct ViceInodeInfo info; */
3068 #ifndef AFS_NT40_ENV
3069         if (*dp->d_name == '.')
3070             continue;
3071 #endif
3072         if (DecodeInode(dir_name, dp->d_name, &info, ih) < 0) {
3073             Log("1 namei_ConvertROtoRWvolume: DecodeInode failed for %s" OS_DIRSEP "%s\n",
3074                 dir_name, dp->d_name);
3075             closedir(dirp);
3076             code = -1;
3077             goto done;
3078         }
3079         if (info.u.param[1] != -1) {
3080             Log("1 namei_ConvertROtoRWvolume: found other than volume special file %s" OS_DIRSEP "%s\n", dir_name, dp->d_name);
3081             closedir(dirp);
3082             code = -1;
3083             goto done;
3084         }
3085         if (info.u.param[0] != volumeId) {
3086             if (info.u.param[0] == ih->ih_vid) {
3087                 if (info.u.param[2] == VI_LINKTABLE) {  /* link table */
3088                     linkSeen = 1;
3089                     continue;
3090                 }
3091             }
3092             Log("1 namei_ConvertROtoRWvolume: found special file %s" OS_DIRSEP "%s"
3093                 " for volume %lu\n", dir_name, dp->d_name,
3094                 afs_printable_uint32_lu(info.u.param[0]));
3095             closedir(dirp);
3096             code = VVOLEXISTS;
3097             goto done;
3098         }
3099         if (info.u.param[2] == VI_VOLINFO) {    /* volume info file */
3100             strlcpy(infoName, dp->d_name, sizeof(infoName));
3101             infoSeen = 1;
3102         } else if (info.u.param[2] == VI_SMALLINDEX) {  /* small vnodes file */
3103             strlcpy(smallName, dp->d_name, sizeof(smallName));
3104             smallSeen = 1;
3105         } else if (info.u.param[2] == VI_LARGEINDEX) {  /* large vnodes file */
3106             strlcpy(largeName, dp->d_name, sizeof(largeName));
3107             largeSeen = 1;
3108         } else {
3109             closedir(dirp);
3110             Log("1 namei_ConvertROtoRWvolume: unknown type %u of special file found : %s" OS_DIRSEP "%s\n", info.u.param[2], dir_name, dp->d_name);
3111             code = -1;
3112             goto done;
3113         }
3114     }
3115     closedir(dirp);
3116
3117     if (!infoSeen || !smallSeen || !largeSeen || !linkSeen) {
3118         Log("1 namei_ConvertROtoRWvolume: not all special files found in %s\n", dir_name);
3119         code = -1;
3120         goto done;
3121     }
3122
3123     /*
3124      * If we come here then there was only a RO-volume and we can safely
3125      * proceed.
3126      */
3127
3128     memset(&t_ih, 0, sizeof(t_ih));
3129     t_ih.ih_dev = ih->ih_dev;
3130     t_ih.ih_vid = ih->ih_vid;
3131
3132     snprintf(oldpath, sizeof oldpath, "%s" OS_DIRSEP "%s", dir_name,
3133              infoName);
3134     fd = OS_OPEN(oldpath, O_RDWR, 0);
3135     if (fd == INVALID_FD) {
3136         Log("1 namei_ConvertROtoRWvolume: could not open RO info file: %s\n",
3137             oldpath);
3138         code = -1;
3139         goto done;
3140     }
3141     t_ih.ih_ino = namei_MakeSpecIno(ih->ih_vid, VI_VOLINFO);
3142     namei_HandleToName(&n, &t_ih);
3143     fd2 = OS_OPEN(n.n_path, O_CREAT | O_EXCL | O_RDWR, 0);
3144     if (fd2 == INVALID_FD) {
3145         Log("1 namei_ConvertROtoRWvolume: could not create RW info file: %s\n", n.n_path);
3146         OS_CLOSE(fd);
3147         code = -1;
3148         goto done;
3149     }
3150     code = convertVolumeInfo(fd, fd2, ih->ih_vid);
3151     OS_CLOSE(fd);
3152     if (code) {
3153         OS_CLOSE(fd2);
3154         OS_UNLINK(n.n_path);
3155         code = -1;
3156         goto done;
3157     }
3158     SetOGM(fd2, ih->ih_vid, 1);
3159     OS_CLOSE(fd2);
3160
3161     t_ih.ih_ino = namei_MakeSpecIno(ih->ih_vid, VI_SMALLINDEX);
3162     namei_HandleToName(&n, &t_ih);
3163     snprintf(newpath, sizeof newpath, "%s" OS_DIRSEP "%s", dir_name,
3164              smallName);
3165     fd = OS_OPEN(newpath, O_RDWR, 0);
3166     if (fd == INVALID_FD) {
3167         Log("1 namei_ConvertROtoRWvolume: could not open SmallIndex file: %s\n", newpath);
3168         code = -1;
3169         goto done;
3170     }
3171     SetOGM(fd, ih->ih_vid, 2);
3172     OS_CLOSE(fd);
3173 #ifdef AFS_NT40_ENV
3174     MoveFileEx(n.n_path, newpath, MOVEFILE_WRITE_THROUGH);
3175 #else
3176     link(newpath, n.n_path);
3177     OS_UNLINK(newpath);
3178 #endif
3179
3180     t_ih.ih_ino = namei_MakeSpecIno(ih->ih_vid, VI_LARGEINDEX);
3181     namei_HandleToName(&n, &t_ih);
3182     snprintf(newpath, sizeof newpath, "%s" OS_DIRSEP "%s", dir_name,
3183              largeName);
3184     fd = OS_OPEN(newpath, O_RDWR, 0);
3185     if (fd == INVALID_FD) {
3186         Log("1 namei_ConvertROtoRWvolume: could not open LargeIndex file: %s\n", newpath);
3187         code = -1;
3188         goto done;
3189     }
3190     SetOGM(fd, ih->ih_vid, 3);
3191     OS_CLOSE(fd);
3192 #ifdef AFS_NT40_ENV
3193     MoveFileEx(n.n_path, newpath, MOVEFILE_WRITE_THROUGH);
3194 #else
3195     link(newpath, n.n_path);
3196     OS_UNLINK(newpath);
3197 #endif
3198
3199     OS_UNLINK(oldpath);
3200
3201     h.id = h.parent;
3202     h.volumeInfo_hi = h.id;
3203     h.smallVnodeIndex_hi = h.id;
3204     h.largeVnodeIndex_hi = h.id;
3205     h.linkTable_hi = h.id;
3206
3207     if (VCreateVolumeDiskHeader(&h, partP)) {
3208         Log("1 namei_ConvertROtoRWvolume: Couldn't write header for RW-volume %lu\n",
3209             afs_printable_uint32_lu(h.id));
3210         code = EIO;
3211         goto done;
3212     }
3213
3214     if (VDestroyVolumeDiskHeader(partP, volumeId, h.parent)) {
3215         Log("1 namei_ConvertROtoRWvolume: Couldn't unlink header for RO-volume %lu\n",
3216             afs_printable_uint32_lu(volumeId));
3217     }
3218
3219     FSYNC_VolOp(volumeId, pname, FSYNC_VOL_DONE, 0, NULL);
3220     FSYNC_VolOp(h.id, pname, FSYNC_VOL_ON, 0, NULL);
3221
3222  done:
3223 # ifdef AFS_DEMAND_ATTACH_FS
3224     if (locktype) {
3225         VUnlockVolumeById(volumeId, partP);
3226     }
3227 # endif /* AFS_DEMAND_ATTACH_FS */
3228 #endif
3229
3230     return code;
3231 }
3232
3233 /* PrintInode
3234  *
3235  * returns a static string used to print either 32 or 64 bit inode numbers.
3236  */
3237 char *
3238 PrintInode(char *s, Inode ino)
3239 {
3240     static afs_ino_str_t result;
3241     if (!s)
3242         s = result;
3243
3244     snprintf(s, sizeof(afs_ino_str_t), "%llu", (afs_uintmax_t) ino);
3245
3246     return s;
3247 }
3248
3249
3250 #ifdef DELETE_ZLC
3251 /* Routines to facilitate removing zero link count files. */
3252 #define MAX_ZLC_NAMES 32
3253 #define MAX_ZLC_NAMELEN 16
3254 typedef struct zlcList_s {
3255     struct zlcList_s *zlc_next;
3256     int zlc_n;
3257     char zlc_names[MAX_ZLC_NAMES][MAX_ZLC_NAMELEN];
3258 } zlcList_t;
3259
3260 static zlcList_t *zlcAnchor = NULL;
3261 static zlcList_t *zlcCur = NULL;
3262
3263 static void
3264 AddToZLCDeleteList(char dir, char *name)
3265 {
3266     opr_Assert(strlen(name) <= MAX_ZLC_NAMELEN - 3);
3267
3268     if (!zlcCur || zlcCur->zlc_n >= MAX_ZLC_NAMES) {
3269         if (zlcCur && zlcCur->zlc_next)
3270             zlcCur = zlcCur->zlc_next;
3271         else {
3272             zlcList_t *tmp = malloc(sizeof(zlcList_t));
3273             if (!tmp)
3274                 return;
3275             if (!zlcAnchor) {
3276                 zlcAnchor = tmp;
3277             } else {
3278                 zlcCur->zlc_next = tmp;
3279             }
3280             zlcCur = tmp;
3281             zlcCur->zlc_n = 0;
3282             zlcCur->zlc_next = NULL;
3283         }
3284     }
3285
3286     if (dir)
3287         (void)sprintf(zlcCur->zlc_names[zlcCur->zlc_n], "%c" OS_DIRSEP "%s", dir, name);
3288     else
3289         (void)sprintf(zlcCur->zlc_names[zlcCur->zlc_n], "%s", name);
3290
3291     zlcCur->zlc_n++;
3292 }
3293
3294 static void
3295 DeleteZLCFiles(char *path)
3296 {
3297     zlcList_t *z;
3298     int i;
3299     char fname[1024];
3300
3301     for (z = zlcAnchor; z; z = z->zlc_next) {
3302         for (i = 0; i < z->zlc_n; i++) {
3303             if (path)
3304                 (void)sprintf(fname, "%s" OS_DIRSEP "%s", path, z->zlc_names[i]);
3305             else
3306                 (void)sprintf(fname, "%s", z->zlc_names[i]);
3307             if (namei_unlink(fname) < 0) {
3308                 Log("ZLC: Can't unlink %s, dos error = %d\n", fname,
3309                     GetLastError());
3310             }
3311         }
3312         z->zlc_n = 0;           /* Can reuse space. */
3313     }
3314     zlcCur = zlcAnchor;
3315 }
3316
3317 static void
3318 FreeZLCList(void)
3319 {
3320     zlcList_t *tnext;
3321     zlcList_t *i;
3322
3323     i = zlcAnchor;
3324     while (i) {
3325         tnext = i->zlc_next;
3326         free(i);
3327         i = tnext;
3328     }
3329     zlcCur = zlcAnchor = NULL;
3330 }
3331 #endif
3332
3333 #endif /* AFS_NAMEI_ENV */