Revert "osi_UFSOpen returns struct osi_file *"
[openafs.git] / src / afs / UKERNEL / afs_usrops.c
1
2 /*
3  * Copyright 2000, International Business Machines Corporation and others.
4  * All Rights Reserved.
5  * 
6  * This software has been released under the terms of the IBM Public
7  * License.  For details, see the LICENSE file in the top-level source
8  * directory or online at http://www.openafs.org/dl/license10.html
9  */
10
11 /*
12  * User space client specific interface glue
13  */
14
15 #include <afsconfig.h>
16 #include "afs/param.h"
17
18 #ifdef  UKERNEL
19
20 #include "afs/sysincludes.h"    /* Standard vendor system headers */
21 #include <net/if.h>
22
23 #include "afsincludes.h"        /* Afs-based standard headers */
24 #include "afs_usrops.h"
25 #include "afs/afs_stats.h"
26 #include "afs/auth.h"
27 #include "afs/cellconfig.h"
28 #include "afs/vice.h"
29 #include "afs/kauth.h"
30 #include "afs/kautils.h"
31 #include "afs/afsutil.h"
32 #include "rx/rx_globals.h"
33
34 #define VFS 1
35 #undef  VIRTUE
36 #undef  VICE
37
38 #define CACHEINFOFILE   "cacheinfo"
39 #define AFSLOGFILE      "AFSLog"
40 #define DCACHEFILE      "CacheItems"
41 #define VOLINFOFILE     "VolumeItems"
42 #define CELLINFOFILE    "CellItems"
43 #define MAXIPADDRS 64
44
45 #ifndef MIN
46 #define MIN(A,B)        ((A)<(B)?(A):(B))
47 #endif
48 #ifndef MAX
49 #define MAX(A,B)        ((A)>(B)?(A):(B))
50 #endif
51
52 extern int cacheDiskType;
53
54 char afs_LclCellName[64];
55
56 struct usr_vnode *afs_FileTable[MAX_OSI_FILES];
57 int afs_FileFlags[MAX_OSI_FILES];
58 off_t afs_FileOffsets[MAX_OSI_FILES];
59
60 #define MAX_CACHE_LOOPS 4
61
62 struct usr_vfs afs_RootVfs;
63 struct usr_vnode *afs_RootVnode = NULL;
64 struct usr_vnode *afs_CurrentDir = NULL;
65
66 afs_int32 cacheBlocks;          /* Num blocks in cache */
67 afs_int32 cacheFiles = 1000;    /* Num files in workstation cache */
68 afs_int32 cacheStatEntries = 300;       /* Num of stat cache entries */
69 char cacheBaseDir[1024];        /* AFS cache directory */
70 char confDir[1024];             /* AFS configuration directory */
71 char afs_mountDir[1024];        /* AFS mount point */
72 int afs_mountDirLen;            /* strlen of AFS mount point */
73 char fullpn_DCacheFile[1024];   /* Full pathname of DCACHEFILE */
74 char fullpn_VolInfoFile[1024];  /* Full pathname of VOLINFOFILE */
75 char fullpn_CellInfoFile[1024]; /* Full pathname of CELLINFOFILE */
76 char fullpn_AFSLogFile[1024];   /* Full pathname of AFSLOGFILE */
77 char fullpn_CacheInfo[1024];    /* Full pathname of CACHEINFO */
78 char fullpn_VFile[1024];        /* Full pathname of data cache files */
79 char *vFileNumber;              /* Ptr to number in file pathname */
80 char rootVolume[64] = "root.afs";       /* AFS root volume name */
81 afs_int32 isHomeCell;           /* Is current cell info for home cell */
82 int createAndTrunc = O_CREAT | O_TRUNC; /* Create & truncate on open */
83 int ownerRWmode = 0600;         /* Read/write OK by owner */
84 static int nDaemons = 2;        /* Number of background daemons */
85 static int chunkSize = 0;       /* 2^chunkSize bytes per chunk */
86 static int dCacheSize = 300;    /* # of dcache entries */
87 static int vCacheSize = 50;     /* # of volume cache entries */
88 static int cacheFlags = 0;      /* Flags to cache manager */
89 static int preallocs = 400;     /* Def # of allocated memory blocks */
90 int afsd_verbose = 0;           /* Are we being chatty? */
91 int afsd_debug = 0;             /* Are we printing debugging info? */
92 int afsd_CloseSynch = 0;        /* Are closes synchronous or not? */
93
94 #define AFSD_INO_T afs_uint32
95 char **pathname_for_V;          /* Array of cache file pathnames */
96 int missing_DCacheFile = 1;     /* Is the DCACHEFILE missing? */
97 int missing_VolInfoFile = 1;    /* Is the VOLINFOFILE missing? */
98 int missing_CellInfoFile = 1;
99 struct afs_cacheParams cparams; /* params passed to cache manager */
100 struct afsconf_dir *afs_cdir;   /* config dir */
101
102 int afs_bufferpages = 100;
103 int usr_udpcksum = 0;
104
105 usr_key_t afs_global_u_key;
106
107 struct usr_proc *afs_global_procp = NULL;
108 struct usr_ucred *afs_global_ucredp = NULL;
109 struct usr_sysent usr_sysent[200];
110
111 #ifdef AFS_USR_OSF_ENV
112 char V = 'V';
113 #else /* AFS_USR_OSF_ENV */
114 long V = 'V';
115 #endif /* AFS_USR_OSF_ENV */
116
117 struct usr_ucred afs_osi_cred, *afs_osi_credp;
118 usr_mutex_t afs_global_lock;
119 usr_thread_t afs_global_owner;
120 usr_mutex_t rx_global_lock;
121 usr_thread_t rx_global_owner;
122 usr_mutex_t osi_inode_lock;
123 usr_mutex_t osi_waitq_lock;
124 usr_mutex_t osi_authenticate_lock;
125 afs_lock_t afs_ftf;
126 afs_lock_t osi_flplock;
127 afs_lock_t osi_fsplock;
128 void *vnodefops;
129
130 #ifndef NETSCAPE_NSAPI
131
132 /*
133  * Mutex and condition variable used to implement sleep
134  */
135 pthread_mutex_t usr_sleep_mutex;
136 pthread_cond_t usr_sleep_cond;
137
138 #endif /* !NETSCAPE_NSAPI */
139
140 int call_syscall(long, long, long, long, long, long);
141 int fork_syscall(long, long, long, long, long, long);
142
143
144 /*
145  * Hash table mapping addresses onto wait structures for
146  * osi_Sleep/osi_Wakeup and osi_Wait/osi_Wakeup
147  */
148 typedef struct osi_wait {
149     caddr_t addr;
150     usr_cond_t cond;
151     int flag;
152     struct osi_wait *next;
153     struct osi_wait *prev;
154     time_t expiration;
155     struct osi_wait *timedNext;
156     struct osi_wait *timedPrev;
157 } osi_wait_t;
158
159 /*
160  * Head of the linked list of available waitq structures.
161  */
162 osi_wait_t *osi_waithash_avail;
163
164 /*
165  * List of timed waits, NSAPI does not provide a cond_timed
166  * wait, so we need to keep track of the timed waits ourselves and
167  * periodically check for expirations
168  */
169 osi_wait_t *osi_timedwait_head;
170 osi_wait_t *osi_timedwait_tail;
171
172 struct {
173     osi_wait_t *head;
174     osi_wait_t *tail;
175 } osi_waithash_table[OSI_WAITHASH_SIZE];
176
177 /*
178  * Never call afs_brelse
179  */
180 int
181 ufs_brelse(struct usr_vnode *vp, struct usr_buf *bp)
182 {
183     usr_assert(0);
184     return 0;
185 }
186
187 /*
188  * I am not sure what to do with these, they assert for now
189  */
190 int
191 iodone(struct usr_buf *bp)
192 {
193     usr_assert(0);
194     return 0;
195 }
196
197 struct usr_file *
198 getf(int fd)
199 {
200     usr_assert(0);
201     return 0;
202 }
203
204 /*
205  * Every user is a super user
206  */
207 int
208 afs_osi_suser(void *credp)
209 {
210     return 1;
211 }
212
213 int
214 afs_suser(void *credp)
215 {
216     return 1;
217 }
218
219 /*
220  * These are no-ops in user space
221  */
222
223 void
224 afs_osi_SetTime(osi_timeval_t * atv)
225 {
226     return;
227 }
228
229 /*
230  * xflock should never fall through, the only files we know
231  * about are AFS files
232  */
233 int
234 usr_flock(void)
235 {
236     usr_assert(0);
237     return 0;
238 }
239
240 /*
241  * ioctl should never fall through, the only files we know
242  * about are AFS files
243  */
244 int
245 usr_ioctl(void)
246 {
247     usr_assert(0);
248     return 0;
249 }
250
251 /*
252  * We do not support the inode related system calls
253  */
254 int
255 afs_syscall_icreate(long a, long b, long c, long d, long e, long f)
256 {
257     usr_assert(0);
258     return 0;
259 }
260
261 int
262 afs_syscall_iincdec(int dev, int inode, int inode_p1, int amount)
263 {
264     usr_assert(0);
265     return 0;
266 }
267
268 int
269 afs_syscall_iopen(int dev, int inode, int usrmod)
270 {
271     usr_assert(0);
272     return 0;
273 }
274
275 int
276 afs_syscall_ireadwrite(void)
277 {
278     usr_assert(0);
279     return 0;
280 }
281
282 /*
283  * these routines are referenced in the vfsops structure, but
284  * should never get called
285  */
286 int
287 vno_close(void)
288 {
289     usr_assert(0);
290     return 0;
291 }
292
293 int
294 vno_ioctl(void)
295 {
296     usr_assert(0);
297     return 0;
298 }
299
300 int
301 vno_rw(void)
302 {
303     usr_assert(0);
304     return 0;
305 }
306
307 int
308 vno_select(void)
309 {
310     usr_assert(0);
311     return 0;
312 }
313
314 /*
315  * uiomove copies data between kernel buffers and uio buffers
316  */
317 int
318 usr_uiomove(char *kbuf, int n, int rw, struct usr_uio *uio)
319 {
320     int nio;
321     int len;
322     char *ptr;
323     struct iovec *iovp;
324
325     nio = uio->uio_iovcnt;
326     iovp = uio->uio_iov;
327
328     if (nio <= 0)
329         return EFAULT;
330
331     /*
332      * copy the data
333      */
334     ptr = kbuf;
335     while (nio > 0 && n > 0) {
336         len = MIN(n, iovp->iov_len);
337         if (rw == UIO_READ) {
338             memcpy(iovp->iov_base, ptr, len);
339         } else {
340             memcpy(ptr, iovp->iov_base, len);
341         }
342         n -= len;
343         ptr += len;
344         uio->uio_resid -= len;
345         uio->uio_offset += len;
346         iovp->iov_base = (char *)(iovp->iov_base) + len;
347         iovp->iov_len -= len;
348         iovp++;
349         nio--;
350     }
351
352     if (n > 0)
353         return EFAULT;
354     return 0;
355 }
356
357 /*
358  * routines to manage user credentials
359  */
360 struct usr_ucred *
361 usr_crcopy(struct usr_ucred *credp)
362 {
363     struct usr_ucred *newcredp;
364
365     newcredp = (struct usr_ucred *)afs_osi_Alloc(sizeof(struct usr_ucred));
366     *newcredp = *credp;
367     newcredp->cr_ref = 1;
368     return newcredp;
369 }
370
371 struct usr_ucred *
372 usr_crget(void)
373 {
374     struct usr_ucred *newcredp;
375
376     newcredp = (struct usr_ucred *)afs_osi_Alloc(sizeof(struct usr_ucred));
377     newcredp->cr_ref = 1;
378     return newcredp;
379 }
380
381 int
382 usr_crfree(struct usr_ucred *credp)
383 {
384     credp->cr_ref--;
385     if (credp->cr_ref == 0) {
386         afs_osi_Free((char *)credp, sizeof(struct usr_ucred));
387     }
388     return 0;
389 }
390
391 int
392 usr_crhold(struct usr_ucred *credp)
393 {
394     credp->cr_ref++;
395     return 0;
396 }
397
398 void
399 usr_vattr_null(struct usr_vattr *vap)
400 {
401     int n;
402     char *cp;
403
404     n = sizeof(struct usr_vattr);
405     cp = (char *)vap;
406     while (n--) {
407         *cp++ = -1;
408     }
409 }
410
411 /*
412  * Initialize the thread specific data used to simulate the
413  * kernel environment for each thread. The user structure
414  * is stored in the thread specific data.
415  */
416 void
417 uafs_InitThread(void)
418 {
419     int st;
420     struct usr_user *uptr;
421
422     /*
423      * initialize the thread specific user structure. Use malloc to
424      * allocate the data block, so pthread_finish can free the buffer
425      * when this thread terminates.
426      */
427     uptr =
428         (struct usr_user *)malloc(sizeof(struct usr_user) +
429                                   sizeof(struct usr_ucred));
430     usr_assert(uptr != NULL);
431     uptr->u_error = 0;
432     uptr->u_prio = 0;
433     uptr->u_procp = afs_global_procp;
434     uptr->u_cred = (struct usr_ucred *)(uptr + 1);
435     *uptr->u_cred = *afs_global_ucredp;
436     st = usr_setspecific(afs_global_u_key, (void *)uptr);
437     usr_assert(st == 0);
438 }
439
440 /*
441  * routine to get the user structure from the thread specific data.
442  * this routine is used to implement the global 'u' structure. Initializes
443  * the thread if needed.
444  */
445 struct usr_user *
446 get_user_struct(void)
447 {
448     struct usr_user *uptr;
449     int st;
450     st = usr_getspecific(afs_global_u_key, (void **)&uptr);
451     usr_assert(st == 0);
452     if (uptr == NULL) {
453         uafs_InitThread();
454         st = usr_getspecific(afs_global_u_key, (void **)&uptr);
455         usr_assert(st == 0);
456         usr_assert(uptr != NULL);
457     }
458     return uptr;
459 }
460
461 /*
462  * Hash an address for the waithash table
463  */
464 #define WAITHASH(X)     \
465         (((long)(X)^((long)(X)>>4)^((long)(X)<<4))&(OSI_WAITHASH_SIZE-1))
466
467 /*
468  * Sleep on an event
469  */
470 void
471 afs_osi_Sleep(void *x)
472 {
473     int index;
474     osi_wait_t *waitp;
475     int glockOwner = ISAFS_GLOCK();
476
477     usr_mutex_lock(&osi_waitq_lock);
478     if (glockOwner) {
479         AFS_GUNLOCK();
480     }
481     index = WAITHASH(x);
482     if (osi_waithash_avail == NULL) {
483         waitp = (osi_wait_t *) afs_osi_Alloc(sizeof(osi_wait_t));
484         usr_cond_init(&waitp->cond);
485     } else {
486         waitp = osi_waithash_avail;
487         osi_waithash_avail = osi_waithash_avail->next;
488     }
489     waitp->addr = x;
490     waitp->flag = 0;
491     DLL_INSERT_TAIL(waitp, osi_waithash_table[index].head,
492                     osi_waithash_table[index].tail, next, prev);
493     waitp->expiration = 0;
494     waitp->timedNext = NULL;
495     waitp->timedPrev = NULL;
496     while (waitp->flag == 0) {
497         usr_cond_wait(&waitp->cond, &osi_waitq_lock);
498     }
499     DLL_DELETE(waitp, osi_waithash_table[index].head,
500                osi_waithash_table[index].tail, next, prev);
501     waitp->next = osi_waithash_avail;
502     osi_waithash_avail = waitp;
503     usr_mutex_unlock(&osi_waitq_lock);
504     if (glockOwner) {
505         AFS_GLOCK();
506     }
507 }
508
509 int
510 afs_osi_SleepSig(void *x)
511 {
512     afs_osi_Sleep(x);
513     return 0;
514 }
515
516 int
517 afs_osi_Wakeup(void *x)
518 {
519     int index;
520     osi_wait_t *waitp;
521
522     index = WAITHASH(x);
523     usr_mutex_lock(&osi_waitq_lock);
524     waitp = osi_waithash_table[index].head;
525     while (waitp) {
526         if (waitp->addr == x && waitp->flag == 0) {
527             waitp->flag = 1;
528             usr_cond_signal(&waitp->cond);
529         }
530         waitp = waitp->next;
531     }
532     usr_mutex_unlock(&osi_waitq_lock);
533     return 0;
534 }
535
536 int
537 afs_osi_Wait(afs_int32 msec, struct afs_osi_WaitHandle *handle, int intok)
538 {
539     int index;
540     osi_wait_t *waitp;
541     struct timespec tv;
542     int ret;
543     int glockOwner = ISAFS_GLOCK();
544
545     tv.tv_sec = msec / 1000;
546     tv.tv_nsec = (msec % 1000) * 1000000;
547     if (handle == NULL) {
548         if (glockOwner) {
549             AFS_GUNLOCK();
550         }
551         usr_thread_sleep(&tv);
552         ret = 0;
553         if (glockOwner) {
554             AFS_GLOCK();
555         }
556     } else {
557         usr_mutex_lock(&osi_waitq_lock);
558         if (glockOwner) {
559             AFS_GUNLOCK();
560         }
561         index = WAITHASH((caddr_t) handle);
562         if (osi_waithash_avail == NULL) {
563             waitp = (osi_wait_t *) afs_osi_Alloc(sizeof(osi_wait_t));
564             usr_cond_init(&waitp->cond);
565         } else {
566             waitp = osi_waithash_avail;
567             osi_waithash_avail = osi_waithash_avail->next;
568         }
569         waitp->addr = (caddr_t) handle;
570         waitp->flag = 0;
571         DLL_INSERT_TAIL(waitp, osi_waithash_table[index].head,
572                         osi_waithash_table[index].tail, next, prev);
573         tv.tv_sec += time(NULL);
574         waitp->expiration = tv.tv_sec + ((tv.tv_nsec == 0) ? 0 : 1);
575         DLL_INSERT_TAIL(waitp, osi_timedwait_head, osi_timedwait_tail,
576                         timedNext, timedPrev);
577         usr_cond_wait(&waitp->cond, &osi_waitq_lock);
578         if (waitp->flag) {
579             ret = 2;
580         } else {
581             ret = 0;
582         }
583         DLL_DELETE(waitp, osi_waithash_table[index].head,
584                    osi_waithash_table[index].tail, next, prev);
585         DLL_DELETE(waitp, osi_timedwait_head, osi_timedwait_tail, timedNext,
586                    timedPrev);
587         waitp->next = osi_waithash_avail;
588         osi_waithash_avail = waitp;
589         usr_mutex_unlock(&osi_waitq_lock);
590         if (glockOwner) {
591             AFS_GLOCK();
592         }
593     }
594     return ret;
595 }
596
597 void
598 afs_osi_CancelWait(struct afs_osi_WaitHandle *handle)
599 {
600     afs_osi_Wakeup(handle);
601 }
602
603 /*
604  * Netscape NSAPI doesn't have a cond_timed_wait, so we need
605  * to explicitly signal cond_timed_waits when their timers expire
606  */
607 int
608 afs_osi_CheckTimedWaits(void)
609 {
610     time_t curTime;
611     osi_wait_t *waitp;
612
613     curTime = time(NULL);
614     usr_mutex_lock(&osi_waitq_lock);
615     waitp = osi_timedwait_head;
616     while (waitp != NULL) {
617         usr_assert(waitp->expiration != 0);
618         if (waitp->expiration <= curTime) {
619             waitp->flag = 1;
620             usr_cond_signal(&waitp->cond);
621         }
622         waitp = waitp->timedNext;
623     }
624     usr_mutex_unlock(&osi_waitq_lock);
625     return 0;
626 }
627
628 /*
629  * I-node numbers are indeces into a table containing a filename
630  * i-node structure and a vnode structure. When we create an i-node,
631  * we copy the name into the array and initialize enough of the fields
632  * in the inode and vnode structures to get the client to work.
633  */
634 typedef struct {
635     struct usr_inode i_node;
636     char *name;
637 } osi_file_table_t;
638 osi_file_table_t *osi_file_table;
639 int n_osi_files = 0;
640 int max_osi_files = 0;
641
642 /*
643  * Allocate a slot in the file table if there is not one there already,
644  * copy in the file name and kludge up the vnode and inode structures
645  */
646 int
647 lookupname(char *fnamep, int segflg, int followlink,
648            struct usr_vnode **compvpp)
649 {
650     int i;
651     int code;
652     struct usr_inode *ip;
653     struct usr_vnode *vp;
654
655     /*usr_assert(followlink == 0); */
656
657     /*
658      * Assume relative pathnames refer to files in AFS
659      */
660     if (*fnamep != '/' || uafs_afsPathName(fnamep) != NULL) {
661         AFS_GLOCK();
662         code = uafs_LookupName(fnamep, afs_CurrentDir, compvpp, 0, 0);
663         AFS_GUNLOCK();
664         return code;
665     }
666
667     usr_mutex_lock(&osi_inode_lock);
668
669     for (i = 0; i < n_osi_files; i++) {
670         if (strcmp(fnamep, osi_file_table[i].name) == 0) {
671             *compvpp = &osi_file_table[i].i_node.i_vnode;
672             (*compvpp)->v_count++;
673             usr_mutex_unlock(&osi_inode_lock);
674             return 0;
675         }
676     }
677
678     if (n_osi_files == max_osi_files) {
679         usr_mutex_unlock(&osi_inode_lock);
680         return ENOSPC;
681     }
682
683     osi_file_table[n_osi_files].name = afs_osi_Alloc(strlen(fnamep) + 1);
684     usr_assert(osi_file_table[n_osi_files].name != NULL);
685     strcpy(osi_file_table[n_osi_files].name, fnamep);
686     ip = &osi_file_table[i].i_node;
687     vp = &ip->i_vnode;
688     vp->v_data = (caddr_t) ip;
689     ip->i_dev = -1;
690     n_osi_files++;
691     ip->i_number = n_osi_files;
692     vp->v_count = 2;
693     usr_mutex_unlock(&osi_inode_lock);
694     *compvpp = vp;
695     return 0;
696 }
697
698 /*
699  * open a file given its i-node number
700  */
701 void *
702 osi_UFSOpen(afs_dcache_id_t *ino)
703 {
704     int rc;
705     struct osi_file *fp;
706     struct stat st;
707
708     AFS_ASSERT_GLOCK();
709
710     if (ino->ufs > n_osi_files) {
711         u.u_error = ENOENT;
712         return NULL;
713     }
714
715     AFS_GUNLOCK();
716     fp = (struct osi_file *)afs_osi_Alloc(sizeof(struct osi_file));
717     usr_assert(fp != NULL);
718     fp->fd = open(osi_file_table[ino->ufs - 1].name, O_RDWR | O_CREAT, 0);
719     if (fp->fd < 0) {
720         u.u_error = errno;
721         afs_osi_Free((char *)fp, sizeof(struct osi_file));
722         AFS_GLOCK();
723         return NULL;
724     }
725     rc = fstat(fp->fd, &st);
726     if (rc < 0) {
727         u.u_error = errno;
728         afs_osi_Free((void *)fp, sizeof(struct osi_file));
729         AFS_GLOCK();
730         return NULL;
731     }
732     fp->size = st.st_size;
733     fp->offset = 0;
734     fp->vnode = (struct usr_vnode *)fp;
735
736     AFS_GLOCK();
737     return fp;
738 }
739
740 int
741 osi_UFSClose(struct osi_file *fp)
742 {
743     int rc;
744
745     AFS_ASSERT_GLOCK();
746
747     AFS_GUNLOCK();
748     rc = close(fp->fd);
749     if (rc < 0) {
750         u.u_error = errno;
751         afs_osi_Free((void *)fp, sizeof(struct osi_file));
752         AFS_GLOCK();
753         return -1;
754     }
755     afs_osi_Free((void *)fp, sizeof(struct osi_file));
756     AFS_GLOCK();
757     return 0;
758 }
759
760 int
761 osi_UFSTruncate(struct osi_file *fp, afs_int32 len)
762 {
763     int rc;
764
765     AFS_ASSERT_GLOCK();
766
767     AFS_GUNLOCK();
768     rc = ftruncate(fp->fd, len);
769     if (rc < 0) {
770         u.u_error = errno;
771         AFS_GLOCK();
772         return -1;
773     }
774     fp->size = len;
775     AFS_GLOCK();
776     return 0;
777 }
778
779 int
780 afs_osi_Read(struct osi_file *fp, int offset, void *buf, afs_int32 len)
781 {
782     int rc, ret;
783     struct stat st;
784
785     AFS_ASSERT_GLOCK();
786
787     AFS_GUNLOCK();
788     if (offset >= 0) {
789         rc = lseek(fp->fd, offset, SEEK_SET);
790     } else {
791         rc = lseek(fp->fd, fp->offset, SEEK_SET);
792     }
793     if (rc < 0) {
794         u.u_error = errno;
795         AFS_GLOCK();
796         return -1;
797     }
798     fp->offset = rc;
799     ret = read(fp->fd, buf, len);
800     if (ret < 0) {
801         u.u_error = errno;
802         AFS_GLOCK();
803         return -1;
804     }
805     fp->offset += ret;
806     rc = fstat(fp->fd, &st);
807     if (rc < 0) {
808         u.u_error = errno;
809         AFS_GLOCK();
810         return -1;
811     }
812     fp->size = st.st_size;
813     AFS_GLOCK();
814     return ret;
815 }
816
817 int
818 afs_osi_Write(struct osi_file *fp, afs_int32 offset, void *buf, afs_int32 len)
819 {
820     int rc, ret;
821     struct stat st;
822
823     AFS_ASSERT_GLOCK();
824
825     AFS_GUNLOCK();
826     if (offset >= 0) {
827         rc = lseek(fp->fd, offset, SEEK_SET);
828     } else {
829         rc = lseek(fp->fd, fp->offset, SEEK_SET);
830     }
831     if (rc < 0) {
832         u.u_error = errno;
833         AFS_GLOCK();
834         return -1;
835     }
836     fp->offset = rc;
837     ret = write(fp->fd, buf, len);
838     if (ret < 0) {
839         u.u_error = errno;
840         AFS_GLOCK();
841         return -1;
842     }
843     fp->offset += ret;
844     rc = fstat(fp->fd, &st);
845     if (rc < 0) {
846         u.u_error = errno;
847         AFS_GLOCK();
848         return -1;
849     }
850     fp->size = st.st_size;
851     AFS_GLOCK();
852     return ret;
853 }
854
855 int
856 afs_osi_Stat(struct osi_file *fp, struct osi_stat *stp)
857 {
858     int rc;
859     struct stat st;
860
861     AFS_GUNLOCK();
862     rc = fstat(fp->fd, &st);
863     if (rc < 0) {
864         u.u_error = errno;
865         AFS_GLOCK();
866         return -1;
867     }
868     stp->size = st.st_size;
869     stp->mtime = st.st_mtime;
870     stp->atime = st.st_atime;
871     AFS_GLOCK();
872     return 0;
873 }
874
875 /*
876  * VOP_RDWR routine
877  */
878 int
879 afs_osi_VOP_RDWR(struct usr_vnode *vnodeP, struct usr_uio *uioP, int rw,
880                  int flags, struct usr_ucred *credP)
881 {
882     int rc;
883     struct osi_file *fp = (struct osi_file *)vnodeP;
884
885     /*
886      * We don't support readv/writev.
887      */
888     usr_assert(uioP->uio_iovcnt == 1);
889     usr_assert(uioP->uio_resid == uioP->uio_iov[0].iov_len);
890
891     if (rw == UIO_WRITE) {
892         usr_assert(uioP->uio_fmode == FWRITE);
893         rc = afs_osi_Write(fp, uioP->uio_offset, uioP->uio_iov[0].iov_base,
894                            uioP->uio_iov[0].iov_len);
895     } else {
896         usr_assert(uioP->uio_fmode == FREAD);
897         rc = afs_osi_Read(fp, uioP->uio_offset, uioP->uio_iov[0].iov_base,
898                           uioP->uio_iov[0].iov_len);
899     }
900     if (rc < 0) {
901         return u.u_error;
902     }
903
904     uioP->uio_resid -= rc;
905     uioP->uio_offset += rc;
906     uioP->uio_iov[0].iov_base = (char *)(uioP->uio_iov[0].iov_base) + rc;
907     uioP->uio_iov[0].iov_len -= rc;
908     return 0;
909 }
910
911 void *
912 afs_osi_Alloc(size_t size)
913 {
914     return malloc(size);
915 }
916
917 void
918 afs_osi_Free(void *ptr, size_t size)
919 {
920     free(ptr);
921 }
922
923 void
924 afs_osi_FreeStr(char *ptr)
925 {
926     free(ptr);
927 }
928
929 void *
930 osi_AllocLargeSpace(size_t size)
931 {
932     AFS_STATCNT(osi_AllocLargeSpace);
933     return afs_osi_Alloc(size);
934 }
935
936 void
937 osi_FreeLargeSpace(void *ptr)
938 {
939     AFS_STATCNT(osi_FreeLargeSpace);
940     afs_osi_Free(ptr, 0);
941 }
942
943 void *
944 osi_AllocSmallSpace(size_t size)
945 {
946     AFS_STATCNT(osi_AllocSmallSpace);
947     return afs_osi_Alloc(size);
948 }
949
950 void
951 osi_FreeSmallSpace(void *ptr)
952 {
953     AFS_STATCNT(osi_FreeSmallSpace);
954     afs_osi_Free(ptr, 0);
955 }
956
957 void
958 shutdown_osi(void)
959 {
960     AFS_STATCNT(shutdown_osi);
961     return;
962 }
963
964 void
965 shutdown_osinet(void)
966 {
967     AFS_STATCNT(shutdown_osinet);
968     return;
969 }
970
971 void
972 shutdown_osifile(void)
973 {
974     AFS_STATCNT(shutdown_osifile);
975     return;
976 }
977
978 void
979 afs_nfsclient_init(void)
980 {
981 }
982
983 void
984 shutdown_nfsclnt(void)
985 {
986     return;
987 }
988
989 void
990 afs_osi_Invisible(void)
991 {
992     return;
993 }
994
995 void
996 afs_osi_Visible(void)
997 {
998     return;
999 }
1000
1001 int
1002 osi_GetTime(struct timeval *tv)
1003 {
1004     gettimeofday(tv, NULL);
1005     return 0;
1006 }
1007
1008 int
1009 osi_SetTime(struct timeval *tv)
1010 {
1011     return 0;
1012 }
1013
1014 int
1015 osi_Active(struct vcache *avc)
1016 {
1017     AFS_STATCNT(osi_Active);
1018     if (avc->opens > 0)
1019         return (1);
1020     return 0;
1021 }
1022
1023 int
1024 afs_osi_MapStrategy(int (*aproc) (struct usr_buf *), struct usr_buf *bp)
1025 {
1026     afs_int32 returnCode;
1027     returnCode = (*aproc) (bp);
1028     return returnCode;
1029 }
1030
1031 void
1032 osi_FlushPages(register struct vcache *avc, afs_ucred_t *credp)
1033 {
1034     ObtainSharedLock(&avc->lock, 555);
1035     if ((hcmp((avc->f.m.DataVersion), (avc->mapDV)) <= 0)
1036         || ((avc->execsOrWriters > 0) && afs_DirtyPages(avc))) {
1037         ReleaseSharedLock(&avc->lock);
1038         return;
1039     }
1040     UpgradeSToWLock(&avc->lock, 565);
1041     hset(avc->mapDV, avc->f.m.DataVersion);
1042     ReleaseWriteLock(&avc->lock);
1043     return;
1044 }
1045
1046 void
1047 osi_FlushText_really(register struct vcache *vp)
1048 {
1049     if (hcmp(vp->f.m.DataVersion, vp->flushDV) > 0) {
1050         hset(vp->flushDV, vp->f.m.DataVersion);
1051     }
1052     return;
1053 }
1054
1055 int
1056 osi_SyncVM(struct vcache *avc)
1057 {
1058     return 0;
1059 }
1060
1061 void
1062 osi_ReleaseVM(struct vcache *avc, int len, struct usr_ucred *credp)
1063 {
1064     return;
1065 }
1066
1067 void
1068 osi_Init(void)
1069 {
1070     int i;
1071
1072     /*
1073      * Allocate the table used to implement psuedo-inodes.
1074      */
1075     max_osi_files = cacheFiles + 100;
1076     osi_file_table = (osi_file_table_t *)
1077         afs_osi_Alloc(max_osi_files * sizeof(osi_file_table_t));
1078     usr_assert(osi_file_table != NULL);
1079
1080 #ifndef NETSCAPE_NSAPI
1081     /*
1082      * Initialize the mutex and condition variable used to implement
1083      * time sleeps.
1084      */
1085     pthread_mutex_init(&usr_sleep_mutex, NULL);
1086     pthread_cond_init(&usr_sleep_cond, NULL);
1087 #endif /* !NETSCAPE_NSAPI */
1088
1089     /*
1090      * Initialize the hash table used for sleep/wakeup
1091      */
1092     for (i = 0; i < OSI_WAITHASH_SIZE; i++) {
1093         DLL_INIT_LIST(osi_waithash_table[i].head, osi_waithash_table[i].tail);
1094     }
1095     DLL_INIT_LIST(osi_timedwait_head, osi_timedwait_tail);
1096     osi_waithash_avail = NULL;
1097
1098     /*
1099      * Initialize the AFS file table
1100      */
1101     for (i = 0; i < MAX_OSI_FILES; i++) {
1102         afs_FileTable[i] = NULL;
1103     }
1104
1105     /*
1106      * Initialize the global locks
1107      */
1108     usr_mutex_init(&afs_global_lock);
1109     usr_mutex_init(&rx_global_lock);
1110     usr_mutex_init(&osi_inode_lock);
1111     usr_mutex_init(&osi_waitq_lock);
1112     usr_mutex_init(&osi_authenticate_lock);
1113
1114     /*
1115      * Initialize the AFS OSI credentials
1116      */
1117     afs_osi_cred = *afs_global_ucredp;
1118     afs_osi_credp = &afs_osi_cred;
1119 }
1120
1121 /* ParseArgs is now obsolete, being handled by cmd */
1122
1123 /*---------------------------------------------------------------------
1124   * GetVFileNumber
1125   *
1126   * Description:
1127   *     Given the final component of a filename expected to be a data cache file,
1128   *     return the integer corresponding to the file.  Note: we reject names that
1129   *     are not a ``V'' followed by an integer.  We also reject those names having
1130   *     the right format but lying outside the range [0..cacheFiles-1].
1131   *
1132   * Arguments:
1133   *     fname : Char ptr to the filename to parse.
1134   *
1135   * Returns:
1136   *     >= 0 iff the file is really a data cache file numbered from 0 to cacheFiles-1, or
1137   *     -1      otherwise.
1138   *
1139   * Environment:
1140   *     Nothing interesting.
1141   *
1142   * Side Effects:
1143   *     None.
1144   *------------------------------------------------------------------------*/
1145
1146 int
1147 GetVFileNumber(char *fname)
1148 {
1149     int computedVNumber;        /*The computed file number we return */
1150     int filenameLen;            /*Number of chars in filename */
1151     int currDigit;              /*Current digit being processed */
1152
1153     /*
1154      * The filename must have at least two characters, the first of which must be a ``V''
1155      * and the second of which cannot be a zero unless the file is exactly two chars long.
1156      */
1157     filenameLen = strlen(fname);
1158     if (filenameLen < 2)
1159         return (-1);
1160     if (fname[0] != 'V')
1161         return (-1);
1162     if ((filenameLen > 2) && (fname[1] == '0'))
1163         return (-1);
1164
1165     /*
1166      * Scan through the characters in the given filename, failing immediately if a non-digit
1167      * is found.
1168      */
1169     for (currDigit = 1; currDigit < filenameLen; currDigit++)
1170         if (isdigit(fname[currDigit]) == 0)
1171             return (-1);
1172
1173     /*
1174      * All relevant characters are digits.  Pull out the decimal number they represent.
1175      * Reject it if it's out of range, otherwise return it.
1176      */
1177     computedVNumber = atoi(++fname);
1178     if (computedVNumber < cacheFiles)
1179         return (computedVNumber);
1180     else
1181         return (-1);
1182 }
1183
1184 /*---------------------------------------------------------------------
1185   * CreateCacheFile
1186   *
1187   * Description:
1188   *     Given a full pathname for a file we need to create for the workstation AFS
1189   *     cache, go ahead and create the file.
1190   *
1191   * Arguments:
1192   *     fname : Full pathname of file to create.
1193   *
1194   * Returns:
1195   *     0   iff the file was created,
1196   *     -1  otherwise.
1197   *
1198   * Environment:
1199   *     The given cache file has been found to be missing.
1200   *
1201   * Side Effects:
1202   *     As described.
1203   *------------------------------------------------------------------------*/
1204
1205 int
1206 CreateCacheFile(char *fname)
1207 {
1208     static char rn[] = "CreateCacheFile";       /*Routine name */
1209     int cfd;                    /*File descriptor to AFS cache file */
1210     int closeResult;            /*Result of close() */
1211
1212     if (afsd_verbose)
1213         printf("%s: Creating cache file '%s'\n", rn, fname);
1214     cfd = open(fname, createAndTrunc, ownerRWmode);
1215     if (cfd <= 0) {
1216         printf("%s: Can't create '%s', error return is %d (%d)\n", rn, fname,
1217                cfd, errno);
1218         return (-1);
1219     }
1220     closeResult = close(cfd);
1221     if (closeResult) {
1222         printf
1223             ("%s: Can't close newly-created AFS cache file '%s' (code %d)\n",
1224              rn, fname, errno);
1225         return (-1);
1226     }
1227
1228     return (0);
1229 }
1230
1231 /*---------------------------------------------------------------------
1232   * SweepAFSCache
1233   *
1234   * Description:
1235   *     Sweep through the AFS cache directory, recording the inode number for
1236   *     each valid data cache file there.  Also, delete any file that doesn't beint32
1237   *     in the cache directory during this sweep, and remember which of the other
1238   *     residents of this directory were seen.  After the sweep, we create any data
1239   *     cache files that were missing.
1240   *
1241   * Arguments:
1242   *     vFilesFound : Set to the number of data cache files found.
1243   *
1244   * Returns:
1245   *     0   if everything went well,
1246   *     -1 otherwise.
1247   *
1248   * Environment:
1249   *     This routine may be called several times.  If the number of data cache files
1250   *     found is less than the global cacheFiles, then the caller will need to call it
1251   *     again to record the inodes of the missing zero-length data cache files created
1252   *     in the previous call.
1253   *
1254   * Side Effects:
1255   *     Fills up the global pathname_for_V array, may create and/or
1256   *     delete files as explained above.
1257   *------------------------------------------------------------------------*/
1258
1259 int
1260 SweepAFSCache(int *vFilesFound)
1261 {
1262     static char rn[] = "SweepAFSCache"; /*Routine name */
1263     char fullpn_FileToDelete[1024];     /*File to be deleted from cache */
1264     char *fileToDelete;         /*Ptr to last component of above */
1265     DIR *cdirp;                 /*Ptr to cache directory structure */
1266 #undef dirent
1267     struct dirent *currp;       /*Current directory entry */
1268     int vFileNum;               /*Data cache file's associated number */
1269
1270     if (cacheFlags & AFSCALL_INIT_MEMCACHE) {
1271         if (afsd_debug)
1272             printf("%s: Memory Cache, no cache sweep done\n", rn);
1273         *vFilesFound = 0;
1274         return 0;
1275     }
1276
1277     if (afsd_debug)
1278         printf("%s: Opening cache directory '%s'\n", rn, cacheBaseDir);
1279
1280     if (chmod(cacheBaseDir, 0700)) {    /* force it to be 700 */
1281         printf("%s: Can't 'chmod 0700' the cache dir, '%s'.\n", rn,
1282                cacheBaseDir);
1283         return (-1);
1284     }
1285     cdirp = opendir(cacheBaseDir);
1286     if (cdirp == (DIR *) 0) {
1287         printf("%s: Can't open AFS cache directory, '%s'.\n", rn,
1288                cacheBaseDir);
1289         return (-1);
1290     }
1291
1292     /*
1293      * Scan the directory entries, remembering data cache file inodes and the existance
1294      * of other important residents.  Delete all files that don't belong here.
1295      */
1296     *vFilesFound = 0;
1297     sprintf(fullpn_FileToDelete, "%s/", cacheBaseDir);
1298     fileToDelete = fullpn_FileToDelete + strlen(fullpn_FileToDelete);
1299
1300     for (currp = readdir(cdirp); currp; currp = readdir(cdirp)) {
1301         if (afsd_debug) {
1302             printf("%s: Current directory entry:\n", rn);
1303 #if defined(AFS_SGI62_ENV) || defined(AFS_USR_DARWIN100_ENV)
1304             printf("\tinode=%" AFS_INT64_FMT ", reclen=%d, name='%s'\n",
1305                    currp->d_ino, currp->d_reclen, currp->d_name);
1306 #elif defined(AFS_USR_DFBSD_ENV)
1307             printf("\tinode=%d, name='%s'\n", currp->d_ino,
1308                    currp->d_name);
1309 #else
1310             printf("\tinode=%d, reclen=%d, name='%s'\n", currp->d_ino,
1311                    currp->d_reclen, currp->d_name);
1312 #endif
1313         }
1314
1315         /*
1316          * Guess current entry is for a data cache file.
1317          */
1318         vFileNum = GetVFileNumber(currp->d_name);
1319         if (vFileNum >= 0) {
1320             /*
1321              * Found a valid data cache filename.  Remember this file's name
1322              * and bump the number of files found.
1323              */
1324             pathname_for_V[vFileNum] =
1325                 afs_osi_Alloc(strlen(currp->d_name) + strlen(cacheBaseDir) +
1326                               2);
1327             usr_assert(pathname_for_V[vFileNum] != NULL);
1328             sprintf(pathname_for_V[vFileNum], "%s/%s", cacheBaseDir,
1329                     currp->d_name);
1330             (*vFilesFound)++;
1331         } else if (strcmp(currp->d_name, DCACHEFILE) == 0) {
1332             /*
1333              * Found the file holding the dcache entries.
1334              */
1335             missing_DCacheFile = 0;
1336         } else if (strcmp(currp->d_name, VOLINFOFILE) == 0) {
1337             /*
1338              * Found the file holding the volume info.
1339              */
1340             missing_VolInfoFile = 0;
1341         } else if (strcmp(currp->d_name, CELLINFOFILE) == 0) {
1342             missing_CellInfoFile = 0;
1343         } else if ((strcmp(currp->d_name, ".") == 0)
1344                    || (strcmp(currp->d_name, "..") == 0)
1345                    || (strcmp(currp->d_name, "lost+found") == 0)) {
1346             /*
1347              * Don't do anything - this file is legit, and is to be left alone.
1348              */
1349         } else {
1350             /*
1351              * This file doesn't belong in the cache.  Nuke it.
1352              */
1353             sprintf(fileToDelete, "%s", currp->d_name);
1354             if (afsd_verbose)
1355                 printf("%s: Deleting '%s'\n", rn, fullpn_FileToDelete);
1356             if (unlink(fullpn_FileToDelete)) {
1357                 printf("%s: Can't unlink '%s', errno is %d\n", rn,
1358                        fullpn_FileToDelete, errno);
1359             }
1360         }
1361     }
1362
1363     /*
1364      * Create all the cache files that are missing.
1365      */
1366     if (missing_DCacheFile) {
1367         if (afsd_verbose)
1368             printf("%s: Creating '%s'\n", rn, fullpn_DCacheFile);
1369         if (CreateCacheFile(fullpn_DCacheFile))
1370             printf("%s: Can't create '%s'\n", rn, fullpn_DCacheFile);
1371     }
1372     if (missing_VolInfoFile) {
1373         if (afsd_verbose)
1374             printf("%s: Creating '%s'\n", rn, fullpn_VolInfoFile);
1375         if (CreateCacheFile(fullpn_VolInfoFile))
1376             printf("%s: Can't create '%s'\n", rn, fullpn_VolInfoFile);
1377     }
1378     if (missing_CellInfoFile) {
1379         if (afsd_verbose)
1380             printf("%s: Creating '%s'\n", rn, fullpn_CellInfoFile);
1381         if (CreateCacheFile(fullpn_CellInfoFile))
1382             printf("%s: Can't create '%s'\n", rn, fullpn_CellInfoFile);
1383     }
1384
1385     if (*vFilesFound < cacheFiles) {
1386         /*
1387          * We came up short on the number of data cache files found.  Scan through the inode
1388          * list and create all missing files.
1389          */
1390         for (vFileNum = 0; vFileNum < cacheFiles; vFileNum++)
1391             if (pathname_for_V[vFileNum] == (AFSD_INO_T) 0) {
1392                 sprintf(vFileNumber, "%d", vFileNum);
1393                 if (afsd_verbose)
1394                     printf("%s: Creating '%s'\n", rn, fullpn_VFile);
1395                 if (CreateCacheFile(fullpn_VFile))
1396                     printf("%s: Can't create '%s'\n", rn, fullpn_VFile);
1397             }
1398     }
1399
1400     /*
1401      * Close the directory, return success.
1402      */
1403     if (afsd_debug)
1404         printf("%s: Closing cache directory.\n", rn);
1405     closedir(cdirp);
1406     return (0);
1407 }
1408
1409 static int
1410 ConfigCell(register struct afsconf_cell *aci, void *arock,
1411            struct afsconf_dir *adir)
1412 {
1413     register int isHomeCell;
1414     register int i;
1415     afs_int32 cellFlags = 0;
1416     afs_int32 hosts[MAXHOSTSPERCELL];
1417
1418     /* figure out if this is the home cell */
1419     isHomeCell = (strcmp(aci->name, afs_LclCellName) == 0);
1420     if (!isHomeCell)
1421         cellFlags = 2;          /* not home, suid is forbidden */
1422
1423     /* build address list */
1424     for (i = 0; i < MAXHOSTSPERCELL; i++)
1425         memcpy(&hosts[i], &aci->hostAddr[i].sin_addr, sizeof(afs_int32));
1426
1427     if (aci->linkedCell)
1428         cellFlags |= 4;         /* Flag that linkedCell arg exists,
1429                                  * for upwards compatibility */
1430
1431     /* configure one cell */
1432     call_syscall(AFSCALL_CALL, AFSOP_ADDCELL2, (long)hosts,     /* server addresses */
1433                  (long)aci->name,       /* cell name */
1434                  (long)cellFlags,       /* is this the home cell? */
1435                  (long)aci->linkedCell);        /* Linked cell, if any */
1436     return 0;
1437 }
1438
1439 static int
1440 ConfigCellAlias(struct afsconf_cellalias *aca, void *arock, struct afsconf_dir *adir)
1441 {
1442         call_syscall(AFSOP_ADDCELLALIAS, (long)aca->aliasName, 
1443                      (long)aca->realName, 0, 0, 0);
1444         return 0;
1445 }
1446
1447 /*
1448  * Set the UDP port number RX uses for UDP datagrams
1449  */
1450 void
1451 uafs_SetRxPort(int port)
1452 {
1453     usr_assert(usr_rx_port == 0);
1454     usr_rx_port = port;
1455 }
1456
1457
1458 /*
1459  * Initialize the user space client.
1460  */
1461 void
1462 uafs_Init(char *rn, char *mountDirParam, char *confDirParam,
1463           char *cacheBaseDirParam, int cacheBlocksParam, int cacheFilesParam,
1464           int cacheStatEntriesParam, int dCacheSizeParam, int vCacheSizeParam,
1465           int chunkSizeParam, int closeSynchParam, int debugParam,
1466           int nDaemonsParam, int cacheFlagsParam, char *logFile)
1467 {
1468     int st;
1469     int i;
1470     int rc;
1471     int currVFile;              /* Current AFS cache file number */
1472     int lookupResult;           /* Result of GetLocalCellName() */
1473     int cacheIteration;         /* cache verification loop counter */
1474     int vFilesFound;            /* Num data cache files found in sweep */
1475     FILE *logfd;
1476     char tbuffer[1024];
1477     char *p;
1478     char lastchar;
1479     afs_int32 buffer[MAXIPADDRS];
1480     afs_int32 maskbuffer[MAXIPADDRS];
1481     afs_int32 mtubuffer[MAXIPADDRS];
1482
1483     /*
1484      * Use the thread specific data to implement the user structure
1485      */
1486     usr_keycreate(&afs_global_u_key, free);
1487
1488     /*
1489      * Initialize the global ucred structure
1490      */
1491     afs_global_ucredp = (struct usr_ucred *)
1492         afs_osi_Alloc(sizeof(struct usr_ucred));
1493     usr_assert(afs_global_ucredp != NULL);
1494     afs_global_ucredp->cr_ref = 1;
1495     afs_set_cr_uid(afs_global_ucredp, geteuid());
1496     afs_set_cr_gid(afs_global_ucredp, getegid());
1497     afs_set_cr_ruid(afs_global_ucredp, getuid());
1498     afs_set_cr_rgid(afs_global_ucredp, getgid());
1499     afs_global_ucredp->cr_suid = afs_cr_ruid(afs_global_ucredp);
1500     afs_global_ucredp->cr_sgid = afs_cr_rgid(afs_global_ucredp);
1501     st = getgroups(NGROUPS, &afs_global_ucredp->cr_groups[0]);
1502     usr_assert(st >= 0);
1503     afs_global_ucredp->cr_ngroups = (unsigned long)st;
1504     for (i = st; i < NGROUPS; i++) {
1505         afs_global_ucredp->cr_groups[i] = NOGROUP;
1506     }
1507
1508     /*
1509      * Initialize the global process structure
1510      */
1511     afs_global_procp = (struct usr_proc *)
1512         afs_osi_Alloc(sizeof(struct usr_proc));
1513     usr_assert(afs_global_procp != NULL);
1514     afs_global_procp->p_pid = osi_getpid();
1515     afs_global_procp->p_ppid = (pid_t) 1;
1516     afs_global_procp->p_ucred = afs_global_ucredp;
1517
1518     /*
1519      * Initialize the AFS mount point, default is '/afs'.
1520      * Strip duplicate/trailing slashes from mount point string.
1521      * afs_mountDirLen is set to strlen(afs_mountDir).
1522      */
1523     if (mountDirParam) {
1524         sprintf(tbuffer, "%s", mountDirParam);
1525     } else {
1526         sprintf(tbuffer, "afs");
1527     }
1528     afs_mountDir[0] = '/';
1529     afs_mountDirLen = 1;
1530     for (lastchar = '/', p = &tbuffer[0]; *p != '\0'; p++) {
1531         if (lastchar != '/' || *p != '/') {
1532             afs_mountDir[afs_mountDirLen++] = lastchar = *p;
1533         }
1534     }
1535     if (lastchar == '/' && afs_mountDirLen > 1)
1536         afs_mountDirLen--;
1537     afs_mountDir[afs_mountDirLen] = '\0';
1538     usr_assert(afs_mountDirLen > 1);
1539
1540     /*
1541      * Initialize cache parameters using the input arguments
1542      */
1543
1544     cacheBlocks = cacheBlocksParam;
1545     if (cacheFilesParam != 0) {
1546         cacheFiles = cacheFilesParam;
1547     } else {
1548         cacheFiles = cacheBlocks / 10;
1549     }
1550     if (cacheStatEntriesParam != 0) {
1551         cacheStatEntries = cacheStatEntriesParam;
1552     }
1553     strcpy(cacheBaseDir, cacheBaseDirParam);
1554     if (nDaemonsParam != 0) {
1555         nDaemons = nDaemonsParam;
1556     } else {
1557         nDaemons = 3;
1558     }
1559     afsd_verbose = debugParam;
1560     afsd_debug = debugParam;
1561     chunkSize = chunkSizeParam;
1562     if (dCacheSizeParam != 0) {
1563         dCacheSize = dCacheSizeParam;
1564     } else {
1565         dCacheSize = cacheFiles / 2;
1566     }
1567     if (vCacheSizeParam != 0) {
1568         vCacheSize = vCacheSizeParam;
1569     }
1570     strcpy(confDir, confDirParam);
1571     afsd_CloseSynch = closeSynchParam;
1572     if (cacheFlagsParam >= 0) {
1573         cacheFlags = cacheFlagsParam;
1574     }
1575     if (cacheFlags & AFSCALL_INIT_MEMCACHE) {
1576         cacheFiles = dCacheSize;
1577     }
1578
1579     sprintf(fullpn_CacheInfo, "%s/%s", confDir, CACHEINFOFILE);
1580     if (logFile == NULL) {
1581         sprintf(fullpn_AFSLogFile, "%s/%s", confDir, AFSLOGFILE);
1582     } else {
1583         strcpy(fullpn_AFSLogFile, logFile);
1584     }
1585
1586     printf("\n%s: Initializing user space AFS client\n\n", rn);
1587     printf("    mountDir:           %s\n", afs_mountDir);
1588     printf("    confDir:            %s\n", confDir);
1589     printf("    cacheBaseDir:       %s\n", cacheBaseDir);
1590     printf("    cacheBlocks:        %d\n", cacheBlocks);
1591     printf("    cacheFiles:         %d\n", cacheFiles);
1592     printf("    cacheStatEntries:   %d\n", cacheStatEntries);
1593     printf("    dCacheSize:         %d\n", dCacheSize);
1594     printf("    vCacheSize:         %d\n", vCacheSize);
1595     printf("    chunkSize:          %d\n", chunkSize);
1596     printf("    afsd_CloseSynch:    %d\n", afsd_CloseSynch);
1597     printf("    afsd_debug/verbose: %d/%d\n", afsd_debug, afsd_verbose);
1598     printf("    nDaemons:           %d\n", nDaemons);
1599     printf("    cacheFlags:         %d\n", cacheFlags);
1600     printf("    logFile:            %s\n", fullpn_AFSLogFile);
1601     printf("\n");
1602     fflush(stdout);
1603
1604     /*
1605      * Initialize the AFS client
1606      */
1607     osi_Init();
1608
1609     /*
1610      * Pull out all the configuration info for the workstation's AFS cache and
1611      * the cellular community we're willing to let our users see.
1612      */
1613     afs_cdir = afsconf_Open(confDir);
1614     if (!afs_cdir) {
1615         printf("afsd: some file missing or bad in %s\n", confDir);
1616         exit(1);
1617     }
1618
1619     lookupResult =
1620         afsconf_GetLocalCell(afs_cdir, afs_LclCellName,
1621                              sizeof(afs_LclCellName));
1622     if (lookupResult) {
1623         printf("%s: Can't get my home cell name!  [Error is %d]\n", rn,
1624                lookupResult);
1625     } else {
1626         if (afsd_verbose)
1627             printf("%s: My home cell is '%s'\n", rn, afs_LclCellName);
1628     }
1629
1630     if ((logfd = fopen(fullpn_AFSLogFile, "r+")) == 0) {
1631         if (afsd_verbose)
1632             printf("%s: Creating '%s'\n", rn, fullpn_AFSLogFile);
1633         if (CreateCacheFile(fullpn_AFSLogFile)) {
1634             printf
1635                 ("%s: Can't create '%s' (You may want to use the -logfile option)\n",
1636                  rn, fullpn_AFSLogFile);
1637             exit(1);
1638         }
1639     } else
1640         fclose(logfd);
1641
1642     /*
1643      * Create and zero the pathname table for the desired cache files.
1644      */
1645     pathname_for_V = (char **)afs_osi_Alloc(cacheFiles * sizeof(char *));
1646     if (pathname_for_V == NULL) {
1647         printf("%s: malloc() failed for cache file table with %d entries.\n",
1648                rn, cacheFiles);
1649         exit(1);
1650     }
1651     memset(pathname_for_V, 0, (cacheFiles * sizeof(char *)));
1652     if (afsd_debug)
1653         printf("%s: %d pathname_for_V entries at %" AFS_PTR_FMT
1654                ", %lud bytes\n", rn, cacheFiles, pathname_for_V,
1655                afs_printable_uint32_lu(cacheFiles * sizeof(AFSD_INO_T)));
1656
1657     /*
1658      * Set up all the pathnames we'll need for later.
1659      */
1660     sprintf(fullpn_DCacheFile, "%s/%s", cacheBaseDir, DCACHEFILE);
1661     sprintf(fullpn_VolInfoFile, "%s/%s", cacheBaseDir, VOLINFOFILE);
1662     sprintf(fullpn_CellInfoFile, "%s/%s", cacheBaseDir, CELLINFOFILE);
1663     sprintf(fullpn_VFile, "%s/V", cacheBaseDir);
1664     vFileNumber = fullpn_VFile + strlen(fullpn_VFile);
1665
1666     /* initialize AFS callback interface */
1667     {
1668         /* parse multihomed address files */
1669         char reason[1024];
1670         st = parseNetFiles((afs_uint32*)buffer,(afs_uint32*) maskbuffer, (afs_uint32*)mtubuffer, MAXIPADDRS, reason,
1671                            AFSDIR_CLIENT_NETINFO_FILEPATH,
1672                            AFSDIR_CLIENT_NETRESTRICT_FILEPATH);
1673         if (st > 0)
1674             call_syscall(AFSCALL_CALL, AFSOP_ADVISEADDR, st,
1675                          (long)(&buffer[0]), (long)(&maskbuffer[0]),
1676                          (long)(&mtubuffer[0]));
1677         else {
1678             printf("ADVISEADDR: Error in specifying interface addresses:%s\n",
1679                    reason);
1680             exit(1);
1681         }
1682     }
1683
1684     /*
1685      * Start the RX listener.
1686      */
1687     if (afsd_debug)
1688         printf("%s: Calling AFSOP_RXLISTENER_DAEMON\n", rn);
1689     fork_syscall(AFSCALL_CALL, AFSOP_RXLISTENER_DAEMON, FALSE, FALSE, FALSE, 0);
1690
1691     if (afsd_verbose)
1692         printf("%s: Forking rx callback listener.\n", rn);
1693     /* Child */
1694     if (preallocs < cacheStatEntries + 50)
1695         preallocs = cacheStatEntries + 50;
1696     fork_syscall(AFSCALL_CALL, AFSOP_START_RXCALLBACK, preallocs, 0, 0, 0);
1697
1698     /*
1699      * Start the RX event handler.
1700      */
1701     if (afsd_debug)
1702         printf("%s: Calling AFSOP_RXEVENT_DAEMON\n", rn);
1703     fork_syscall(AFSCALL_CALL, AFSOP_RXEVENT_DAEMON, FALSE, 0, 0, 0);
1704
1705     /*
1706      * Set up all the kernel processes needed for AFS.
1707      */
1708
1709     if (afsd_verbose)
1710         printf("%s: Initializing AFS daemon.\n", rn);
1711     call_syscall(AFSCALL_CALL, AFSOP_BASIC_INIT, 1, 0, 0, 0);
1712
1713     /*
1714      * Tell the kernel some basic information about the workstation's cache.
1715      */
1716     if (afsd_verbose)
1717         printf("%s: Calling AFSOP_CACHEINIT: %d stat cache entries,"
1718                " %d optimum cache files, %d blocks in the cache,"
1719                " flags = 0x%x, dcache entries %d\n", rn, cacheStatEntries,
1720                cacheFiles, cacheBlocks, cacheFlags, dCacheSize);
1721     memset(&cparams, 0, sizeof(cparams));
1722     cparams.cacheScaches = cacheStatEntries;
1723     cparams.cacheFiles = cacheFiles;
1724     cparams.cacheBlocks = cacheBlocks;
1725     cparams.cacheDcaches = dCacheSize;
1726     cparams.cacheVolumes = vCacheSize;
1727     cparams.chunkSize = chunkSize;
1728     cparams.setTimeFlag = FALSE;
1729     cparams.memCacheFlag = cacheFlags;
1730     call_syscall(AFSCALL_CALL, AFSOP_CACHEINIT, (long)&cparams, 0, 0, 0);
1731     if (afsd_CloseSynch)
1732         call_syscall(AFSCALL_CALL, AFSOP_CLOSEWAIT, 0, 0, 0, 0);
1733
1734     /*
1735      * Sweep the workstation AFS cache directory, remembering the inodes of
1736      * valid files and deleting extraneous files.  Keep sweeping until we
1737      * have the right number of data cache files or we've swept too many
1738      * times.
1739      */
1740     if (afsd_verbose)
1741         printf("%s: Sweeping workstation's AFS cache directory.\n", rn);
1742     cacheIteration = 0;
1743     /* Memory-cache based system doesn't need any of this */
1744     if (!(cacheFlags & AFSCALL_INIT_MEMCACHE)) {
1745         do {
1746             cacheIteration++;
1747             if (SweepAFSCache(&vFilesFound)) {
1748                 printf("%s: Error on sweep %d of workstation AFS cache \
1749                        directory.\n", rn, cacheIteration);
1750                 exit(1);
1751             }
1752             if (afsd_verbose)
1753                 printf
1754                     ("%s: %d out of %d data cache files found in sweep %d.\n",
1755                      rn, vFilesFound, cacheFiles, cacheIteration);
1756         } while ((vFilesFound < cacheFiles)
1757                  && (cacheIteration < MAX_CACHE_LOOPS));
1758     } else if (afsd_verbose)
1759         printf("%s: Using memory cache, not swept\n", rn);
1760
1761     /*
1762      * Pass the kernel the name of the workstation cache file holding the 
1763      * dcache entries.
1764      */
1765     if (afsd_debug)
1766         printf("%s: Calling AFSOP_CACHEINFO: dcache file is '%s'\n", rn,
1767                fullpn_DCacheFile);
1768     /* once again, meaningless for a memory-based cache. */
1769     if (!(cacheFlags & AFSCALL_INIT_MEMCACHE))
1770         call_syscall(AFSCALL_CALL, AFSOP_CACHEINFO, (long)fullpn_DCacheFile,
1771                      0, 0, 0);
1772
1773     call_syscall(AFSCALL_CALL, AFSOP_CELLINFO, (long)fullpn_CellInfoFile, 0,
1774                  0, 0);
1775
1776     /*
1777      * Pass the kernel the name of the workstation cache file holding the
1778      * volume information.
1779      */
1780     if (afsd_debug)
1781         printf("%s: Calling AFSOP_VOLUMEINFO: volume info file is '%s'\n", rn,
1782                fullpn_VolInfoFile);
1783     call_syscall(AFSCALL_CALL, AFSOP_VOLUMEINFO, (long)fullpn_VolInfoFile, 0,
1784                  0, 0);
1785
1786     /*
1787      * Pass the kernel the name of the afs logging file holding the volume
1788      * information.
1789      */
1790     if (afsd_debug)
1791         printf("%s: Calling AFSOP_AFSLOG: volume info file is '%s'\n", rn,
1792                fullpn_AFSLogFile);
1793     if (!(cacheFlags & AFSCALL_INIT_MEMCACHE))  /* ... nor this ... */
1794         call_syscall(AFSCALL_CALL, AFSOP_AFSLOG, (long)fullpn_AFSLogFile, 0,
1795                      0, 0);
1796
1797     /*
1798      * Tell the kernel about each cell in the configuration.
1799      */
1800     afsconf_CellApply(afs_cdir, ConfigCell, NULL);
1801     afsconf_CellAliasApply(afs_cdir, ConfigCellAlias, NULL);
1802
1803     /*
1804      * Set the primary cell name.
1805      */
1806     call_syscall(AFSCALL_CALL, AFSOP_SET_THISCELL, (long)afs_LclCellName, 0, 0, 0);
1807
1808     if (afsd_verbose)
1809         printf("%s: Forking AFS daemon.\n", rn);
1810     fork_syscall(AFSCALL_CALL, AFSOP_START_AFS, 0, 0, 0, 0);
1811
1812     if (afsd_verbose)
1813         printf("%s: Forking check server daemon.\n", rn);
1814     fork_syscall(AFSCALL_CALL, AFSOP_START_CS, 0, 0, 0, 0);
1815
1816     if (afsd_verbose)
1817         printf("%s: Forking %d background daemons.\n", rn, nDaemons);
1818     for (i = 0; i < nDaemons; i++) {
1819         fork_syscall(AFSCALL_CALL, AFSOP_START_BKG, 0, 0, 0, 0);
1820     }
1821
1822     if (afsd_verbose)
1823         printf("%s: Calling AFSOP_ROOTVOLUME with '%s'\n", rn, rootVolume);
1824     call_syscall(AFSCALL_CALL, AFSOP_ROOTVOLUME, (long)rootVolume, 0, 0, 0);
1825
1826     /*
1827      * Give the kernel the names of the AFS files cached on the workstation's
1828      * disk.
1829      */
1830     if (afsd_debug)
1831         printf
1832             ("%s: Calling AFSOP_CACHEFILES for each of the %d files in '%s'\n",
1833              rn, cacheFiles, cacheBaseDir);
1834     if (!(cacheFlags & AFSCALL_INIT_MEMCACHE))  /* ... and again ... */
1835         for (currVFile = 0; currVFile < cacheFiles; currVFile++) {
1836             call_syscall(AFSCALL_CALL, AFSOP_CACHEFILE,
1837                          (long)pathname_for_V[currVFile], 0, 0, 0);
1838         }
1839     /*end for */
1840 /*#ifndef NETSCAPE_NSAPI*/
1841 #if 0
1842 /* this breaks solaris if the kernel-mode client has never been installed,
1843  * and it doesn't seem to work now anyway, so just disable it */
1844
1845     /*
1846      * Copy our tokens from the kernel to the user space client
1847      */
1848     for (i = 0; i < 200; i++) {
1849         /*
1850          * Get the i'th token from the kernel
1851          */
1852         memset((void *)&tbuffer[0], 0, sizeof(tbuffer));
1853         memcpy((void *)&tbuffer[0], (void *)&i, sizeof(int));
1854         iob.in = tbuffer;
1855         iob.in_size = sizeof(int);
1856         iob.out = tbuffer;
1857         iob.out_size = sizeof(tbuffer);
1858
1859 #if defined(AFS_USR_SUN5_ENV) || defined(AFS_USR_OSF_ENV) || defined(AFS_USR_HPUX_ENV) || defined(AFS_USR_LINUX22_ENV) || defined(AFS_USR_DARWIN_ENV) || defined(AFS_USR_FBSD_ENV)
1860         rc = syscall(AFS_SYSCALL, AFSCALL_PIOCTL, 0, _VICEIOCTL(8), &iob, 0);
1861 #elif defined(AFS_USR_SGI_ENV)
1862         rc = syscall(AFS_PIOCTL, 0, _VICEIOCTL(8), &iob, 0);
1863 #else /* AFS_USR_AIX_ENV */
1864         rc = lpioctl(0, _VICEIOCTL(8), &iob, 0);
1865 #endif
1866         if (rc < 0) {
1867             usr_assert(errno == EDOM || errno == ENOSYS || errno == ERANGE);
1868             break;
1869         }
1870
1871         /*
1872          * Now pass the token into the user space kernel
1873          */
1874         rc = uafs_SetTokens(tbuffer, iob.out_size);
1875         usr_assert(rc == 0);
1876     }
1877 #endif /* !NETSCAPE_NSAPI */
1878
1879     /*
1880      * All the necessary info has been passed into the kernel to run an AFS
1881      * system.  Give the kernel our go-ahead.
1882      */
1883     if (afsd_debug)
1884         printf("%s: Calling AFSOP_GO\n", rn);
1885     call_syscall(AFSCALL_CALL, AFSOP_GO, FALSE, 0, 0, 0);
1886
1887     /*
1888      * At this point, we have finished passing the kernel all the info 
1889      * it needs to set up the AFS.  Mount the AFS root.
1890      */
1891     printf("%s: All AFS daemons started.\n", rn);
1892
1893     if (afsd_verbose)
1894         printf("%s: Forking trunc-cache daemon.\n", rn);
1895     fork_syscall(AFSCALL_CALL, AFSOP_START_TRUNCDAEMON, 0, 0, 0, 0);
1896
1897     /*
1898      * Mount the AFS filesystem
1899      */
1900     AFS_GLOCK();
1901     rc = afs_mount(&afs_RootVfs, NULL, NULL);
1902     usr_assert(rc == 0);
1903     rc = afs_root(&afs_RootVfs, &afs_RootVnode);
1904     usr_assert(rc == 0);
1905     AFS_GUNLOCK();
1906
1907     /*
1908      * initialize the current directory to the AFS root
1909      */
1910     afs_CurrentDir = afs_RootVnode;
1911     VN_HOLD(afs_CurrentDir);
1912
1913     return;
1914 }
1915
1916 void
1917 uafs_Shutdown(void)
1918 {
1919     int rc;
1920
1921     printf("\n");
1922
1923     AFS_GLOCK();
1924     VN_RELE(afs_CurrentDir);
1925     rc = afs_unmount(&afs_RootVfs);
1926     usr_assert(rc == 0);
1927     AFS_GUNLOCK();
1928
1929     printf("\n");
1930 }
1931
1932 /*
1933  * Donate the current thread to the RX server pool.
1934  */
1935 void
1936 uafs_RxServerProc(void)
1937 {
1938     osi_socket sock;
1939     int threadID;
1940     struct rx_call *newcall = NULL;
1941
1942     rxi_MorePackets(2);         /* alloc more packets */
1943     threadID = rxi_availProcs++;
1944
1945     while (1) {
1946         sock = OSI_NULLSOCKET;
1947         rxi_ServerProc(threadID, newcall, &sock);
1948         if (sock == OSI_NULLSOCKET) {
1949             break;
1950         }
1951         newcall = NULL;
1952         threadID = -1;
1953         rxi_ListenerProc(sock, &threadID, &newcall);
1954         /* assert(threadID != -1); */
1955         /* assert(newcall != NULL); */
1956     }
1957 }
1958
1959 struct syscallThreadArgs {
1960     long syscall;
1961     long afscall;
1962     long param1;
1963     long param2;
1964     long param3;
1965     long param4;
1966 };
1967
1968 #ifdef NETSCAPE_NSAPI
1969 void
1970 syscallThread(void *argp)
1971 #else /* NETSCAPE_NSAPI */
1972 void *
1973 syscallThread(void *argp)
1974 #endif                          /* NETSCAPE_NSAPI */
1975 {
1976     int i;
1977     struct usr_ucred *crp;
1978     struct syscallThreadArgs *sysArgsP = (struct syscallThreadArgs *)argp;
1979
1980     /*
1981      * AFS daemons run authenticated
1982      */
1983     u.u_viceid = getuid();
1984     crp = u.u_cred;
1985     afs_set_cr_uid(crp, getuid());
1986     afs_set_cr_ruid(crp, getuid());
1987     crp->cr_suid = getuid();
1988     crp->cr_groups[0] = getgid();
1989     crp->cr_ngroups = 1;
1990     for (i = 1; i < NGROUPS; i++) {
1991         crp->cr_groups[i] = NOGROUP;
1992     }
1993
1994     call_syscall(sysArgsP->syscall, sysArgsP->afscall, sysArgsP->param1,
1995                  sysArgsP->param2, sysArgsP->param3, sysArgsP->param4);
1996
1997     afs_osi_Free(argp, -1);
1998     return 0;
1999 }
2000
2001 int
2002 fork_syscall(long syscall, long afscall, long param1, long param2,
2003              long param3, long param4)
2004 {
2005     usr_thread_t tid;
2006     struct syscallThreadArgs *sysArgsP;
2007
2008     sysArgsP = (struct syscallThreadArgs *)
2009         afs_osi_Alloc(sizeof(struct syscallThreadArgs));
2010     usr_assert(sysArgsP != NULL);
2011     sysArgsP->syscall = syscall;
2012     sysArgsP->afscall = afscall;
2013     sysArgsP->param1 = param1;
2014     sysArgsP->param2 = param2;
2015     sysArgsP->param3 = param3;
2016     sysArgsP->param4 = param4;
2017
2018     usr_thread_create(&tid, syscallThread, sysArgsP);
2019     usr_thread_detach(tid);
2020     return 0;
2021 }
2022
2023 int
2024 call_syscall(long syscall, long afscall, long param1, long param2,
2025              long param3, long param4)
2026 {
2027     int code = 0;
2028     struct a {
2029         long syscall;
2030         long afscall;
2031         long parm1;
2032         long parm2;
2033         long parm3;
2034         long parm4;
2035     } a;
2036
2037     a.syscall = syscall;
2038     a.afscall = afscall;
2039     a.parm1 = param1;
2040     a.parm2 = param2;
2041     a.parm3 = param3;
2042     a.parm4 = param4;
2043
2044     u.u_error = 0;
2045     u.u_ap = (char *)&a;
2046
2047     code = Afs_syscall();
2048     return code;
2049 }
2050
2051 int
2052 uafs_SetTokens(char *tbuffer, int tlen)
2053 {
2054     int rc;
2055     struct afs_ioctl iob;
2056     char outbuf[1024];
2057
2058     iob.in = tbuffer;
2059     iob.in_size = tlen;
2060     iob.out = &outbuf[0];
2061     iob.out_size = sizeof(outbuf);
2062
2063     rc = call_syscall(AFSCALL_PIOCTL, 0, _VICEIOCTL(3), (long)&iob, 0, 0);
2064     if (rc != 0) {
2065         errno = rc;
2066         return -1;
2067     }
2068     return 0;
2069 }
2070
2071 int
2072 uafs_RPCStatsEnableProc(void)
2073 {
2074     int rc;
2075     struct afs_ioctl iob;
2076     afs_int32 flag;
2077
2078     flag = AFSCALL_RXSTATS_ENABLE;
2079     iob.in = (char *)&flag;
2080     iob.in_size = sizeof(afs_int32);
2081     iob.out = NULL;
2082     iob.out_size = 0;
2083     rc = call_syscall(AFSCALL_PIOCTL, 0, _VICEIOCTL(53), (long)&iob, 0, 0);
2084     if (rc != 0) {
2085         errno = rc;
2086         return -1;
2087     }
2088     return rc;
2089 }
2090
2091 int
2092 uafs_RPCStatsDisableProc(void)
2093 {
2094     int rc;
2095     struct afs_ioctl iob;
2096     afs_int32 flag;
2097
2098     flag = AFSCALL_RXSTATS_DISABLE;
2099     iob.in = (char *)&flag;
2100     iob.in_size = sizeof(afs_int32);
2101     iob.out = NULL;
2102     iob.out_size = 0;
2103     rc = call_syscall(AFSCALL_PIOCTL, 0, _VICEIOCTL(53), (long)&iob, 0, 0);
2104     if (rc != 0) {
2105         errno = rc;
2106         return -1;
2107     }
2108     return rc;
2109 }
2110
2111 int
2112 uafs_RPCStatsClearProc(void)
2113 {
2114     int rc;
2115     struct afs_ioctl iob;
2116     afs_int32 flag;
2117
2118     flag = AFSCALL_RXSTATS_CLEAR;
2119     iob.in = (char *)&flag;
2120     iob.in_size = sizeof(afs_int32);
2121     iob.out = NULL;
2122     iob.out_size = 0;
2123     rc = call_syscall(AFSCALL_PIOCTL, 0, _VICEIOCTL(53), (long)&iob, 0, 0);
2124     if (rc != 0) {
2125         errno = rc;
2126         return -1;
2127     }
2128     return rc;
2129 }
2130
2131 int
2132 uafs_RPCStatsEnablePeer(void)
2133 {
2134     int rc;
2135     struct afs_ioctl iob;
2136     afs_int32 flag;
2137
2138     flag = AFSCALL_RXSTATS_ENABLE;
2139     iob.in = (char *)&flag;
2140     iob.in_size = sizeof(afs_int32);
2141     iob.out = NULL;
2142     iob.out_size = 0;
2143     rc = call_syscall(AFSCALL_PIOCTL, 0, _VICEIOCTL(54), (long)&iob, 0, 0);
2144     if (rc != 0) {
2145         errno = rc;
2146         return -1;
2147     }
2148     return rc;
2149 }
2150
2151 int
2152 uafs_RPCStatsDisablePeer(void)
2153 {
2154     int rc;
2155     struct afs_ioctl iob;
2156     afs_int32 flag;
2157
2158     flag = AFSCALL_RXSTATS_DISABLE;
2159     iob.in = (char *)&flag;
2160     iob.in_size = sizeof(afs_int32);
2161     iob.out = NULL;
2162     iob.out_size = 0;
2163     rc = call_syscall(AFSCALL_PIOCTL, 0, _VICEIOCTL(54), (long)&iob, 0, 0);
2164     if (rc != 0) {
2165         errno = rc;
2166         return -1;
2167     }
2168     return rc;
2169 }
2170
2171 int
2172 uafs_RPCStatsClearPeer(void)
2173 {
2174     int rc;
2175     struct afs_ioctl iob;
2176     afs_int32 flag;
2177
2178     flag = AFSCALL_RXSTATS_CLEAR;
2179     iob.in = (char *)&flag;
2180     iob.in_size = sizeof(afs_int32);
2181     iob.out = NULL;
2182     iob.out_size = 0;
2183     rc = call_syscall(AFSCALL_PIOCTL, 0, _VICEIOCTL(54), (long)&iob, 0, 0);
2184     if (rc != 0) {
2185         errno = rc;
2186         return -1;
2187     }
2188     return rc;
2189 }
2190
2191 /*
2192  * Lookup a file or directory given its path.
2193  * Call VN_HOLD on the output vnode if successful.
2194  * Returns zero on success, error code on failure.
2195  *
2196  * Note: Caller must hold the AFS global lock.
2197  */
2198 int
2199 uafs_LookupName(char *path, struct usr_vnode *parentVp,
2200                 struct usr_vnode **vpp, int follow, int no_eval_mtpt)
2201 {
2202     int code = 0;
2203     int linkCount;
2204     struct usr_vnode *vp;
2205     struct usr_vnode *nextVp;
2206     struct usr_vnode *linkVp;
2207     struct vcache *nextVc;
2208     char *tmpPath;
2209     char *pathP;
2210     char *nextPathP = NULL;
2211
2212     AFS_ASSERT_GLOCK();
2213
2214     /*
2215      * Absolute paths must start with the AFS mount point.
2216      */
2217     if (path[0] != '/') {
2218         vp = parentVp;
2219     } else {
2220         path = uafs_afsPathName(path);
2221         if (path == NULL) {
2222             return ENOENT;
2223         }
2224         vp = afs_RootVnode;
2225     }
2226
2227     /*
2228      * Loop through the path looking for the new directory
2229      */
2230     tmpPath = afs_osi_Alloc(strlen(path) + 1);
2231     usr_assert(tmpPath != NULL);
2232     strcpy(tmpPath, path);
2233     VN_HOLD(vp);
2234     pathP = tmpPath;
2235     while (pathP != NULL && *pathP != '\0') {
2236         usr_assert(*pathP != '/');
2237
2238         /*
2239          * terminate the current component and skip over slashes
2240          */
2241         nextPathP = afs_strchr(pathP, '/');
2242         if (nextPathP != NULL) {
2243             while (*nextPathP == '/') {
2244                 *(nextPathP++) = '\0';
2245             }
2246         }
2247
2248         /*
2249          * Don't call afs_lookup on non-directories
2250          */
2251         if (vp->v_type != VDIR) {
2252             VN_RELE(vp);
2253             afs_osi_Free(tmpPath, strlen(path) + 1);
2254             return ENOTDIR;
2255         }
2256
2257         if (vp == afs_RootVnode && strcmp(pathP, "..") == 0) {
2258             /*
2259              * The AFS root is its own parent
2260              */
2261             nextVp = afs_RootVnode;
2262         } else {
2263             /*
2264              * We need execute permission to search a directory
2265              */
2266             code = afs_access(VTOAFS(vp), VEXEC, u.u_cred);
2267             if (code != 0) {
2268                 VN_RELE(vp);
2269                 afs_osi_Free(tmpPath, strlen(path) + 1);
2270                 return code;
2271             }
2272
2273             /*
2274              * lookup the next component in the path, we can release the
2275              * subdirectory since we hold the global lock
2276              */
2277             nextVc = NULL;
2278             nextVp = NULL;
2279 #ifdef AFS_WEB_ENHANCEMENTS
2280             if ((nextPathP != NULL && *nextPathP != '\0') || !no_eval_mtpt)
2281                 code = afs_lookup(VTOAFS(vp), pathP, &nextVc, u.u_cred, 0);
2282             else
2283                 code =
2284                     afs_lookup(VTOAFS(vp), pathP, &nextVc, u.u_cred,
2285                                AFS_LOOKUP_NOEVAL);
2286 #else
2287             code = afs_lookup(VTOAFS(vp), pathP, &nextVc, u.u_cred, 0);
2288 #endif /* AFS_WEB_ENHANCEMENTS */
2289             if (nextVc)
2290                 nextVp=AFSTOV(nextVc);
2291             if (code != 0) {
2292                 VN_RELE(vp);
2293                 afs_osi_Free(tmpPath, strlen(path) + 1);
2294                 return code;
2295             }
2296         }
2297
2298         /*
2299          * Follow symbolic links for parent directories and
2300          * for leaves when the follow flag is set.
2301          */
2302         if ((nextPathP != NULL && *nextPathP != '\0') || follow) {
2303             linkCount = 0;
2304             while (nextVp->v_type == VLNK) {
2305                 if (++linkCount > MAX_OSI_LINKS) {
2306                     VN_RELE(vp);
2307                     VN_RELE(nextVp);
2308                     afs_osi_Free(tmpPath, strlen(path) + 1);
2309                     return code;
2310                 }
2311                 code = uafs_LookupLink(nextVp, vp, &linkVp);
2312                 if (code) {
2313                     VN_RELE(vp);
2314                     VN_RELE(nextVp);
2315                     afs_osi_Free(tmpPath, strlen(path) + 1);
2316                     return code;
2317                 }
2318                 VN_RELE(nextVp);
2319                 nextVp = linkVp;
2320             }
2321         }
2322
2323         VN_RELE(vp);
2324         vp = nextVp;
2325         pathP = nextPathP;
2326     }
2327
2328     /*
2329      * Special case, nextPathP is non-null if pathname ends in slash
2330      */
2331     if (nextPathP != NULL && vp->v_type != VDIR) {
2332         VN_RELE(vp);
2333         afs_osi_Free(tmpPath, strlen(path) + 1);
2334         return ENOTDIR;
2335     }
2336
2337     afs_osi_Free(tmpPath, strlen(path) + 1);
2338     *vpp = vp;
2339     return 0;
2340 }
2341
2342 /*
2343  * Lookup the target of a symbolic link
2344  * Call VN_HOLD on the output vnode if successful.
2345  * Returns zero on success, error code on failure.
2346  *
2347  * Note: Caller must hold the AFS global lock.
2348  */
2349 int
2350 uafs_LookupLink(struct usr_vnode *vp, struct usr_vnode *parentVp,
2351                 struct usr_vnode **vpp)
2352 {
2353     int code;
2354     int len;
2355     char *pathP;
2356     struct usr_vnode *linkVp;
2357     struct usr_uio uio;
2358     struct iovec iov[1];
2359
2360     AFS_ASSERT_GLOCK();
2361
2362     pathP = afs_osi_Alloc(MAX_OSI_PATH + 1);
2363     usr_assert(pathP != NULL);
2364
2365     /*
2366      * set up the uio buffer
2367      */
2368     iov[0].iov_base = pathP;
2369     iov[0].iov_len = MAX_OSI_PATH + 1;
2370     uio.uio_iov = &iov[0];
2371     uio.uio_iovcnt = 1;
2372     uio.uio_offset = 0;
2373     uio.uio_segflg = 0;
2374     uio.uio_fmode = FREAD;
2375     uio.uio_resid = MAX_OSI_PATH + 1;
2376
2377     /*
2378      * Read the link data
2379      */
2380     code = afs_readlink(VTOAFS(vp), &uio, u.u_cred);
2381     if (code) {
2382         afs_osi_Free(pathP, MAX_OSI_PATH + 1);
2383         return code;
2384     }
2385     len = MAX_OSI_PATH + 1 - uio.uio_resid;
2386     pathP[len] = '\0';
2387
2388     /*
2389      * Find the target of the symbolic link
2390      */
2391     code = uafs_LookupName(pathP, parentVp, &linkVp, 1, 0);
2392     if (code) {
2393         afs_osi_Free(pathP, MAX_OSI_PATH + 1);
2394         return code;
2395     }
2396
2397     afs_osi_Free(pathP, MAX_OSI_PATH + 1);
2398     *vpp = linkVp;
2399     return 0;
2400 }
2401
2402 /*
2403  * Lookup the parent of a file or directory given its path
2404  * Call VN_HOLD on the output vnode if successful.
2405  * Returns zero on success, error code on failure.
2406  *
2407  * Note: Caller must hold the AFS global lock.
2408  */
2409 int
2410 uafs_LookupParent(char *path, struct usr_vnode **vpp)
2411 {
2412     int len;
2413     int code;
2414     char *pathP;
2415     struct usr_vnode *parentP;
2416
2417     AFS_ASSERT_GLOCK();
2418
2419     /*
2420      * Absolute path names must start with the AFS mount point.
2421      */
2422     if (*path == '/') {
2423         pathP = uafs_afsPathName(path);
2424         if (pathP == NULL) {
2425             return ENOENT;
2426         }
2427     }
2428
2429     /*
2430      * Find the length of the parent path
2431      */
2432     len = strlen(path);
2433     while (len > 0 && path[len - 1] == '/') {
2434         len--;
2435     }
2436     if (len == 0) {
2437         return EINVAL;
2438     }
2439     while (len > 0 && path[len - 1] != '/') {
2440         len--;
2441     }
2442     if (len == 0) {
2443         return EINVAL;
2444     }
2445
2446     pathP = afs_osi_Alloc(len);
2447     usr_assert(pathP != NULL);
2448     memcpy(pathP, path, len - 1);
2449     pathP[len - 1] = '\0';
2450
2451     /*
2452      * look up the parent
2453      */
2454     code = uafs_LookupName(pathP, afs_CurrentDir, &parentP, 1, 0);
2455     afs_osi_Free(pathP, len);
2456     if (code != 0) {
2457         return code;
2458     }
2459     if (parentP->v_type != VDIR) {
2460         VN_RELE(parentP);
2461         return ENOTDIR;
2462     }
2463
2464     *vpp = parentP;
2465     return 0;
2466 }
2467
2468 /*
2469  * Return a pointer to the first character in the last component
2470  * of a pathname
2471  */
2472 char *
2473 uafs_LastPath(char *path)
2474 {
2475     int len;
2476
2477     len = strlen(path);
2478     while (len > 0 && path[len - 1] == '/') {
2479         len--;
2480     }
2481     while (len > 0 && path[len - 1] != '/') {
2482         len--;
2483     }
2484     if (len == 0) {
2485         return NULL;
2486     }
2487     return path + len;
2488 }
2489
2490 /*
2491  * Set the working directory.
2492  */
2493 int
2494 uafs_chdir(char *path)
2495 {
2496     int retval;
2497     AFS_GLOCK();
2498     retval = uafs_chdir_r(path);
2499     AFS_GUNLOCK();
2500     return retval;
2501 }
2502
2503 int
2504 uafs_chdir_r(char *path)
2505 {
2506     int code;
2507     struct vnode *dirP;
2508
2509     code = uafs_LookupName(path, afs_CurrentDir, &dirP, 1, 0);
2510     if (code != 0) {
2511         errno = code;
2512         return -1;
2513     }
2514     if (dirP->v_type != VDIR) {
2515         VN_RELE(dirP);
2516         errno = ENOTDIR;
2517         return -1;
2518     }
2519     VN_RELE(afs_CurrentDir);
2520     afs_CurrentDir = dirP;
2521     return 0;
2522 }
2523
2524 /*
2525  * Create a directory.
2526  */
2527 int
2528 uafs_mkdir(char *path, int mode)
2529 {
2530     int retval;
2531     AFS_GLOCK();
2532     retval = uafs_mkdir_r(path, mode);
2533     AFS_GUNLOCK();
2534     return retval;
2535 }
2536
2537 int
2538 uafs_mkdir_r(char *path, int mode)
2539 {
2540     int code;
2541     char *nameP;
2542     struct vnode *parentP;
2543     struct vcache *dirP;
2544     struct usr_vattr attrs;
2545
2546     if (uafs_IsRoot(path)) {
2547         return EACCES;
2548     }
2549
2550     /*
2551      * Look up the parent directory.
2552      */
2553     nameP = uafs_LastPath(path);
2554     if (nameP != NULL) {
2555         code = uafs_LookupParent(path, &parentP);
2556         if (code != 0) {
2557             errno = code;
2558             return -1;
2559         }
2560     } else {
2561         parentP = afs_CurrentDir;
2562         nameP = path;
2563         VN_HOLD(parentP);
2564     }
2565
2566     /*
2567      * Make sure the directory has at least one character
2568      */
2569     if (*nameP == '\0') {
2570         VN_RELE(parentP);
2571         errno = EINVAL;
2572         return -1;
2573     }
2574
2575     /*
2576      * Create the directory
2577      */
2578     usr_vattr_null(&attrs);
2579     attrs.va_type = VREG;
2580     attrs.va_mode = mode;
2581     attrs.va_uid = afs_cr_uid(u.u_cred);
2582     attrs.va_gid = afs_cr_gid(u.u_cred);
2583     dirP = NULL;
2584     code = afs_mkdir(VTOAFS(parentP), nameP, &attrs, &dirP, u.u_cred);
2585     VN_RELE(parentP);
2586     if (code != 0) {
2587         errno = code;
2588         return -1;
2589     }
2590     VN_RELE(AFSTOV(dirP));
2591     return 0;
2592 }
2593
2594 /*
2595  * Return 1 if path is the AFS root, otherwise return 0
2596  */
2597 int
2598 uafs_IsRoot(char *path)
2599 {
2600     while (*path == '/' && *(path + 1) == '/') {
2601         path++;
2602     }
2603     if (strncmp(path, afs_mountDir, afs_mountDirLen) != 0) {
2604         return 0;
2605     }
2606     path += afs_mountDirLen;
2607     while (*path == '/') {
2608         path++;
2609     }
2610     if (*path != '\0') {
2611         return 0;
2612     }
2613     return 1;
2614 }
2615
2616 /*
2617  * Open a file
2618  * Note: file name may not end in a slash.
2619  */
2620 int
2621 uafs_open(char *path, int flags, int mode)
2622 {
2623     int retval;
2624     AFS_GLOCK();
2625     retval = uafs_open_r(path, flags, mode);
2626     AFS_GUNLOCK();
2627     return retval;
2628 }
2629
2630 int
2631 uafs_open_r(char *path, int flags, int mode)
2632 {
2633     int fd;
2634     int code;
2635     int openFlags;
2636     int fileMode;
2637     struct usr_vnode *fileP;
2638     struct usr_vnode *dirP;
2639     struct usr_vattr attrs;
2640     char *nameP;
2641
2642     struct vcache* vc;
2643
2644     if (uafs_IsRoot(path)) {
2645         fileP = afs_RootVnode;
2646         VN_HOLD(fileP);
2647     } else {
2648         /*
2649          * Look up the parent directory.
2650          */
2651         nameP = uafs_LastPath(path);
2652         if (nameP != NULL) {
2653             code = uafs_LookupParent(path, &dirP);
2654             if (code != 0) {
2655                 errno = code;
2656                 return -1;
2657             }
2658         } else {
2659             dirP = afs_CurrentDir;
2660             nameP = path;
2661             VN_HOLD(dirP);
2662         }
2663
2664         /*
2665          * Make sure the filename has at least one character
2666          */
2667         if (*nameP == '\0') {
2668             VN_RELE(dirP);
2669             errno = EINVAL;
2670             return -1;
2671         }
2672
2673         /*
2674          * Get the VNODE for this file
2675          */
2676         if (flags & O_CREAT) {
2677             usr_vattr_null(&attrs);
2678             attrs.va_type = VREG;
2679             attrs.va_mode = mode;
2680             attrs.va_uid = afs_cr_uid(u.u_cred);
2681             attrs.va_gid = afs_cr_gid(u.u_cred);
2682             if (flags & O_TRUNC) {
2683                 attrs.va_size = 0;
2684             }
2685             fileP = NULL;
2686             vc=VTOAFS(fileP);
2687             code =
2688                 afs_create(VTOAFS(dirP), nameP, &attrs,
2689                            (flags & O_EXCL) ? usr_EXCL : usr_NONEXCL, mode,
2690                            &vc, u.u_cred);
2691             VN_RELE(dirP);
2692             if (code != 0) {
2693                 errno = code;
2694                 return -1;
2695             }
2696             fileP = AFSTOV(vc);
2697         } else {
2698             fileP = NULL;
2699             code = uafs_LookupName(nameP, dirP, &fileP, 1, 0);
2700             VN_RELE(dirP);
2701             if (code != 0) {
2702                 errno = code;
2703                 return -1;
2704             }
2705
2706             /*
2707              * Check whether we have access to this file
2708              */
2709             fileMode = 0;
2710             if (flags & (O_RDONLY | O_RDWR)) {
2711                 fileMode |= VREAD;
2712             }
2713             if (flags & (O_WRONLY | O_RDWR)) {
2714                 fileMode |= VWRITE;
2715             }
2716             if (!fileMode)
2717                 fileMode = VREAD;       /* since O_RDONLY is 0 */
2718             code = afs_access(VTOAFS(fileP), fileMode, u.u_cred);
2719             if (code != 0) {
2720                 VN_RELE(fileP);
2721                 errno = code;
2722                 return -1;
2723             }
2724
2725             /*
2726              * Get the file attributes, all we need is the size
2727              */
2728             code = afs_getattr(VTOAFS(fileP), &attrs, u.u_cred);
2729             if (code != 0) {
2730                 VN_RELE(fileP);
2731                 errno = code;
2732                 return -1;
2733             }
2734         }
2735     }
2736
2737     /*
2738      * Setup the open flags
2739      */
2740     openFlags = 0;
2741     if (flags & O_TRUNC) {
2742         openFlags |= FTRUNC;
2743     }
2744     if (flags & O_APPEND) {
2745         openFlags |= FAPPEND;
2746     }
2747     if (flags & O_SYNC) {
2748         openFlags |= FSYNC;
2749     }
2750     if (flags & O_SYNC) {
2751         openFlags |= FSYNC;
2752     }
2753     if (flags & (O_RDONLY | O_RDWR)) {
2754         openFlags |= FREAD;
2755     }
2756     if (flags & (O_WRONLY | O_RDWR)) {
2757         openFlags |= FWRITE;
2758     }
2759     if ((openFlags & (FREAD | FWRITE)) == 0) {
2760         /* O_RDONLY is 0, so ... */
2761         openFlags |= FREAD;
2762     }
2763
2764     /*
2765      * Truncate if necessary
2766      */
2767     if ((flags & O_TRUNC) && (attrs.va_size != 0)) {
2768         usr_vattr_null(&attrs);
2769         attrs.va_mask = ATTR_SIZE;
2770         attrs.va_size = 0;
2771         code = afs_setattr(VTOAFS(fileP), &attrs, u.u_cred);
2772         if (code != 0) {
2773             VN_RELE(fileP);
2774             errno = code;
2775             return -1;
2776         }
2777     }
2778
2779     vc=VTOAFS(fileP);   
2780     /*
2781      * do the open
2782      */
2783     code = afs_open(&vc, openFlags, u.u_cred);
2784     if (code != 0) {
2785         VN_RELE(fileP);
2786         errno = code;
2787         return -1;
2788     }
2789
2790     /*
2791      * Put the vnode pointer into the file table
2792      */
2793     for (fd = 0; fd < MAX_OSI_FILES; fd++) {
2794         if (afs_FileTable[fd] == NULL) {
2795             afs_FileTable[fd] = fileP;
2796             afs_FileFlags[fd] = openFlags;
2797             if (flags & O_APPEND) {
2798                 afs_FileOffsets[fd] = attrs.va_size;
2799             } else {
2800                 afs_FileOffsets[fd] = 0;
2801             }
2802             break;
2803         }
2804     }
2805     if (fd == MAX_OSI_FILES) {
2806         VN_RELE(fileP);
2807         errno = ENFILE;
2808         return -1;
2809     }
2810
2811     return fd;
2812 }
2813
2814 /*
2815  * Create a file
2816  */
2817 int
2818 uafs_creat(char *path, int mode)
2819 {
2820     int rc;
2821     rc = uafs_open(path, O_CREAT | O_WRONLY | O_TRUNC, mode);
2822     return rc;
2823 }
2824
2825 int
2826 uafs_creat_r(char *path, int mode)
2827 {
2828     int rc;
2829     rc = uafs_open_r(path, O_CREAT | O_WRONLY | O_TRUNC, mode);
2830     return rc;
2831 }
2832
2833 /*
2834  * Write to a file
2835  */
2836 int
2837 uafs_write(int fd, char *buf, int len)
2838 {
2839     int retval;
2840     AFS_GLOCK();
2841     retval = uafs_pwrite_r(fd, buf, len, afs_FileOffsets[fd]);
2842     AFS_GUNLOCK();
2843     return retval;
2844 }
2845
2846 int
2847 uafs_pwrite(int fd, char *buf, int len, off_t offset)
2848 {
2849     int retval;
2850     AFS_GLOCK();
2851     retval = uafs_pwrite_r(fd, buf, len, offset);
2852     AFS_GUNLOCK();
2853     return retval;
2854 }
2855
2856 int
2857 uafs_pwrite_r(int fd, char *buf, int len, off_t offset)
2858 {
2859     int code;
2860     struct usr_uio uio;
2861     struct iovec iov[1];
2862     struct usr_vnode *fileP;
2863
2864     /*
2865      * Make sure this is an open file
2866      */
2867     fileP = afs_FileTable[fd];
2868     if (fileP == NULL) {
2869         errno = EBADF;
2870         return -1;
2871     }
2872
2873     /*
2874      * set up the uio buffer
2875      */
2876     iov[0].iov_base = buf;
2877     iov[0].iov_len = len;
2878     uio.uio_iov = &iov[0];
2879     uio.uio_iovcnt = 1;
2880     uio.uio_offset = offset;
2881     uio.uio_segflg = 0;
2882     uio.uio_fmode = FWRITE;
2883     uio.uio_resid = len;
2884
2885     /*
2886      * do the write
2887      */
2888
2889     code = afs_write(VTOAFS(fileP), &uio, afs_FileFlags[fd], u.u_cred, 0);
2890     if (code) {
2891         errno = code;
2892         return -1;
2893     }
2894
2895     afs_FileOffsets[fd] = uio.uio_offset;
2896     return (len - uio.uio_resid);
2897 }
2898
2899 /*
2900  * Read from a file
2901  */
2902 int
2903 uafs_read(int fd, char *buf, int len)
2904 {
2905     int retval;
2906     AFS_GLOCK();
2907     retval = uafs_pread_r(fd, buf, len, afs_FileOffsets[fd]);
2908     AFS_GUNLOCK();
2909     return retval;
2910 }
2911
2912 int
2913 uafs_pread(int fd, char *buf, int len, off_t offset)
2914 {
2915     int retval;
2916     AFS_GLOCK();
2917     retval = uafs_pread_r(fd, buf, len, offset);
2918     AFS_GUNLOCK();
2919     return retval;
2920 }
2921
2922 int
2923 uafs_pread_r(int fd, char *buf, int len, off_t offset)
2924 {
2925     int code;
2926     struct usr_uio uio;
2927     struct iovec iov[1];
2928     struct usr_vnode *fileP;
2929     struct usr_buf *bufP;
2930
2931     /*
2932      * Make sure this is an open file
2933      */
2934     fileP = afs_FileTable[fd];
2935     if (fileP == NULL) {
2936         errno = EBADF;
2937         return -1;
2938     }
2939
2940     /*
2941      * set up the uio buffer
2942      */
2943     iov[0].iov_base = buf;
2944     iov[0].iov_len = len;
2945     uio.uio_iov = &iov[0];
2946     uio.uio_iovcnt = 1;
2947     uio.uio_offset = offset;
2948     uio.uio_segflg = 0;
2949     uio.uio_fmode = FREAD;
2950     uio.uio_resid = len;
2951
2952     /*
2953      * do the read
2954      */
2955     code = afs_read(VTOAFS(fileP), &uio, u.u_cred, 0, &bufP, 0);
2956     if (code) {
2957         errno = code;
2958         return -1;
2959     }
2960
2961     afs_FileOffsets[fd] = uio.uio_offset;
2962     return (len - uio.uio_resid);
2963 }
2964
2965 /*
2966  * Copy the attributes of a file into a stat structure.
2967  *
2968  * NOTE: Caller must hold the global AFS lock.
2969  */
2970 int
2971 uafs_GetAttr(struct usr_vnode *vp, struct stat *stats)
2972 {
2973     int code;
2974     struct usr_vattr attrs;
2975
2976     AFS_ASSERT_GLOCK();
2977
2978     /*
2979      * Get the attributes
2980      */
2981     code = afs_getattr(VTOAFS(vp), &attrs, u.u_cred);
2982     if (code != 0) {
2983         return code;
2984     }
2985
2986     /*
2987      * Copy the attributes, zero fields that aren't set
2988      */
2989     memset((void *)stats, 0, sizeof(struct stat));
2990     stats->st_dev = -1;
2991     stats->st_ino = attrs.va_nodeid;
2992     stats->st_mode = attrs.va_mode;
2993     stats->st_nlink = attrs.va_nlink;
2994     stats->st_uid = attrs.va_uid;
2995     stats->st_gid = attrs.va_gid;
2996     stats->st_rdev = attrs.va_rdev;
2997     stats->st_size = attrs.va_size;
2998     stats->st_atime = attrs.va_atime.tv_sec;
2999     stats->st_mtime = attrs.va_mtime.tv_sec;
3000     stats->st_ctime = attrs.va_ctime.tv_sec;
3001     stats->st_blksize = attrs.va_blocksize;
3002     stats->st_blocks = attrs.va_blocks;
3003
3004     return 0;
3005 }
3006
3007 /*
3008  * Get the attributes of a file, do follow links
3009  */
3010 int
3011 uafs_stat(char *path, struct stat *buf)
3012 {
3013     int retval;
3014     AFS_GLOCK();
3015     retval = uafs_stat_r(path, buf);
3016     AFS_GUNLOCK();
3017     return retval;
3018 }
3019
3020 int
3021 uafs_stat_r(char *path, struct stat *buf)
3022 {
3023     int code;
3024     struct vnode *vp;
3025
3026     code = uafs_LookupName(path, afs_CurrentDir, &vp, 1, 0);
3027     if (code != 0) {
3028         errno = code;
3029         return -1;
3030     }
3031     code = uafs_GetAttr(vp, buf);
3032     VN_RELE(vp);
3033     if (code) {
3034         errno = code;
3035         return -1;
3036     }
3037     return 0;
3038 }
3039
3040 /*
3041  * Get the attributes of a file, don't follow links
3042  */
3043 int
3044 uafs_lstat(char *path, struct stat *buf)
3045 {
3046     int retval;
3047     AFS_GLOCK();
3048     retval = uafs_lstat_r(path, buf);
3049     AFS_GUNLOCK();
3050     return retval;
3051 }
3052
3053 int
3054 uafs_lstat_r(char *path, struct stat *buf)
3055 {
3056     int code;
3057     struct vnode *vp;
3058
3059     code = uafs_LookupName(path, afs_CurrentDir, &vp, 0, 0);
3060     if (code != 0) {
3061         errno = code;
3062         return -1;
3063     }
3064     code = uafs_GetAttr(vp, buf);
3065     VN_RELE(vp);
3066     if (code) {
3067         errno = code;
3068         return -1;
3069     }
3070     return 0;
3071 }
3072
3073 /*
3074  * Get the attributes of an open file
3075  */
3076 int
3077 uafs_fstat(int fd, struct stat *buf)
3078 {
3079     int retval;
3080     AFS_GLOCK();
3081     retval = uafs_fstat_r(fd, buf);
3082     AFS_GUNLOCK();
3083     return retval;
3084 }
3085
3086 int
3087 uafs_fstat_r(int fd, struct stat *buf)
3088 {
3089     int code;
3090     struct vnode *vp;
3091
3092     vp = afs_FileTable[fd];
3093     if (vp == NULL) {
3094         errno = EBADF;
3095         return -1;
3096     }
3097     code = uafs_GetAttr(vp, buf);
3098     if (code) {
3099         errno = code;
3100         return -1;
3101     }
3102     return 0;
3103 }
3104
3105 /*
3106  * change the permissions on a file
3107  */
3108 int
3109 uafs_chmod(char *path, int mode)
3110 {
3111     int retval;
3112     AFS_GLOCK();
3113     retval = uafs_chmod_r(path, mode);
3114     AFS_GUNLOCK();
3115     return retval;
3116 }
3117
3118 int
3119 uafs_chmod_r(char *path, int mode)
3120 {
3121     int code;
3122     struct vnode *vp;
3123     struct usr_vattr attrs;
3124
3125     code = uafs_LookupName(path, afs_CurrentDir, &vp, 1, 0);
3126     if (code != 0) {
3127         errno = code;
3128         return -1;
3129     }
3130     usr_vattr_null(&attrs);
3131     attrs.va_mask = ATTR_MODE;
3132     attrs.va_mode = mode;
3133     code = afs_setattr(VTOAFS(vp), &attrs, u.u_cred);
3134     VN_RELE(vp);
3135     if (code != 0) {
3136         errno = code;
3137         return -1;
3138     }
3139     return 0;
3140 }
3141
3142 /*
3143  * change the permissions on an open file
3144  */
3145 int
3146 uafs_fchmod(int fd, int mode)
3147 {
3148     int retval;
3149     AFS_GLOCK();
3150     retval = uafs_fchmod_r(fd, mode);
3151     AFS_GUNLOCK();
3152     return retval;
3153 }
3154
3155 int
3156 uafs_fchmod_r(int fd, int mode)
3157 {
3158     int code;
3159     struct vnode *vp;
3160     struct usr_vattr attrs;
3161
3162     vp = afs_FileTable[fd];
3163     if (vp == NULL) {
3164         errno = EBADF;
3165         return -1;
3166     }
3167     usr_vattr_null(&attrs);
3168     attrs.va_mask = ATTR_MODE;
3169     attrs.va_mode = mode;
3170     code = afs_setattr(VTOAFS(vp), &attrs, u.u_cred);
3171     if (code != 0) {
3172         errno = code;
3173         return -1;
3174     }
3175     return 0;
3176 }
3177
3178 /*
3179  * truncate a file
3180  */
3181 int
3182 uafs_truncate(char *path, int length)
3183 {
3184     int retval;
3185     AFS_GLOCK();
3186     retval = uafs_truncate_r(path, length);
3187     AFS_GUNLOCK();
3188     return retval;
3189 }
3190
3191 int
3192 uafs_truncate_r(char *path, int length)
3193 {
3194     int code;
3195     struct vnode *vp;
3196     struct usr_vattr attrs;
3197
3198     code = uafs_LookupName(path, afs_CurrentDir, &vp, 1, 0);
3199     if (code != 0) {
3200         errno = code;
3201         return -1;
3202     }
3203     usr_vattr_null(&attrs);
3204     attrs.va_mask = ATTR_SIZE;
3205     attrs.va_size = length;
3206     code = afs_setattr(VTOAFS(vp), &attrs, u.u_cred);
3207     VN_RELE(vp);
3208     if (code != 0) {
3209         errno = code;
3210         return -1;
3211     }
3212     return 0;
3213 }
3214
3215 /*
3216  * truncate an open file
3217  */
3218 int
3219 uafs_ftruncate(int fd, int length)
3220 {
3221     int retval;
3222     AFS_GLOCK();
3223     retval = uafs_ftruncate_r(fd, length);
3224     AFS_GUNLOCK();
3225     return retval;
3226 }
3227
3228 int
3229 uafs_ftruncate_r(int fd, int length)
3230 {
3231     int code;
3232     struct vnode *vp;
3233     struct usr_vattr attrs;
3234
3235     vp = afs_FileTable[fd];
3236     if (vp == NULL) {
3237         errno = EBADF;
3238         return -1;
3239     }
3240     usr_vattr_null(&attrs);
3241     attrs.va_mask = ATTR_SIZE;
3242     attrs.va_size = length;
3243     code = afs_setattr(VTOAFS(vp), &attrs, u.u_cred);
3244     if (code != 0) {
3245         errno = code;
3246         return -1;
3247     }
3248     return 0;
3249 }
3250
3251 /*
3252  * set the read/write file pointer of an open file
3253  */
3254 int
3255 uafs_lseek(int fd, int offset, int whence)
3256 {
3257     int retval;
3258     AFS_GLOCK();
3259     retval = uafs_lseek_r(fd, offset, whence);
3260     AFS_GUNLOCK();
3261     return retval;
3262 }
3263
3264 int
3265 uafs_lseek_r(int fd, int offset, int whence)
3266 {
3267     int code;
3268     int newpos;
3269     struct usr_vattr attrs;
3270     struct usr_vnode *vp;
3271
3272     vp = afs_FileTable[fd];
3273     if (vp == NULL) {
3274         errno = EBADF;
3275         return -1;
3276     }
3277     switch (whence) {
3278     case SEEK_CUR:
3279         newpos = afs_FileOffsets[fd] + offset;
3280         break;
3281     case SEEK_SET:
3282         newpos = offset;
3283         break;
3284     case SEEK_END:
3285         code = afs_getattr(VTOAFS(vp), &attrs, u.u_cred);
3286         if (code != 0) {
3287             errno = code;
3288             return -1;
3289         }
3290         newpos = attrs.va_size + offset;
3291         break;
3292     default:
3293         errno = EINVAL;
3294         return -1;
3295     }
3296     if (newpos < 0) {
3297         errno = EINVAL;
3298         return -1;
3299     }
3300     afs_FileOffsets[fd] = newpos;
3301     return newpos;
3302 }
3303
3304 /*
3305  * sync a file
3306  */
3307 int
3308 uafs_fsync(int fd)
3309 {
3310     int retval;
3311     AFS_GLOCK();
3312     retval = uafs_fsync_r(fd);
3313     AFS_GUNLOCK();
3314     return retval;
3315 }
3316
3317 int
3318 uafs_fsync_r(int fd)
3319 {
3320     int code;
3321     struct usr_vnode *fileP;
3322
3323
3324     fileP = afs_FileTable[fd];
3325     if (fileP == NULL) {
3326         errno = EBADF;
3327         return -1;
3328     }
3329
3330     code = afs_fsync(VTOAFS(fileP), u.u_cred);
3331     if (code != 0) {
3332         errno = code;
3333         return -1;
3334     }
3335
3336     return 0;
3337 }
3338
3339 /*
3340  * Close a file
3341  */
3342 int
3343 uafs_close(int fd)
3344 {
3345     int retval;
3346     AFS_GLOCK();
3347     retval = uafs_close_r(fd);
3348     AFS_GUNLOCK();
3349     return retval;
3350 }
3351
3352 int
3353 uafs_close_r(int fd)
3354 {
3355     int code;
3356     struct usr_vnode *fileP;
3357
3358     fileP = afs_FileTable[fd];
3359     if (fileP == NULL) {
3360         errno = EBADF;
3361         return -1;
3362     }
3363     afs_FileTable[fd] = NULL;
3364
3365     code = afs_close(VTOAFS(fileP), afs_FileFlags[fd], u.u_cred);
3366     VN_RELE(fileP);
3367     if (code != 0) {
3368         errno = code;
3369         return -1;
3370     }
3371
3372     return 0;
3373 }
3374
3375 /*
3376  * Create a hard link from the source to the target
3377  * Note: file names may not end in a slash.
3378  */
3379 int
3380 uafs_link(char *existing, char *new)
3381 {
3382     int retval;
3383     AFS_GLOCK();
3384     retval = uafs_link_r(existing, new);
3385     AFS_GUNLOCK();
3386     return retval;
3387 }
3388
3389 int
3390 uafs_link_r(char *existing, char *new)
3391 {
3392     int code;
3393     struct usr_vnode *existP;
3394     struct usr_vnode *dirP;
3395     char *nameP;
3396
3397     if (uafs_IsRoot(new)) {
3398         return EACCES;
3399     }
3400
3401     /*
3402      * Look up the existing node.
3403      */
3404     code = uafs_LookupName(existing, afs_CurrentDir, &existP, 1, 0);
3405     if (code != 0) {
3406         errno = code;
3407         return -1;
3408     }
3409
3410     /*
3411      * Look up the parent directory.
3412      */
3413     nameP = uafs_LastPath(new);
3414     if (nameP != NULL) {
3415         code = uafs_LookupParent(new, &dirP);
3416         if (code != 0) {
3417             VN_RELE(existP);
3418             errno = code;
3419             return -1;
3420         }
3421     } else {
3422         dirP = afs_CurrentDir;
3423         nameP = new;
3424         VN_HOLD(dirP);
3425     }
3426
3427     /*
3428      * Make sure the filename has at least one character
3429      */
3430     if (*nameP == '\0') {
3431         VN_RELE(existP);
3432         VN_RELE(dirP);
3433         errno = EINVAL;
3434         return -1;
3435     }
3436
3437     /*
3438      * Create the link
3439      */
3440     code = afs_link(VTOAFS(existP), VTOAFS(dirP), nameP, u.u_cred);
3441     VN_RELE(existP);
3442     VN_RELE(dirP);
3443     if (code != 0) {
3444         errno = code;
3445         return -1;
3446     }
3447     return 0;
3448 }
3449
3450 /*
3451  * Create a symbolic link from the source to the target
3452  * Note: file names may not end in a slash.
3453  */
3454 int
3455 uafs_symlink(char *target, char *source)
3456 {
3457     int retval;
3458     AFS_GLOCK();
3459     retval = uafs_symlink_r(target, source);
3460     AFS_GUNLOCK();
3461     return retval;
3462 }
3463
3464 int
3465 uafs_symlink_r(char *target, char *source)
3466 {
3467     int code;
3468     struct usr_vnode *dirP;
3469     struct usr_vattr attrs;
3470     char *nameP;
3471
3472     if (uafs_IsRoot(source)) {
3473         return EACCES;
3474     }
3475
3476     /*
3477      * Look up the parent directory.
3478      */
3479     nameP = uafs_LastPath(source);
3480     if (nameP != NULL) {
3481         code = uafs_LookupParent(source, &dirP);
3482         if (code != 0) {
3483             errno = code;
3484             return -1;
3485         }
3486     } else {
3487         dirP = afs_CurrentDir;
3488         nameP = source;
3489         VN_HOLD(dirP);
3490     }
3491
3492     /*
3493      * Make sure the filename has at least one character
3494      */
3495     if (*nameP == '\0') {
3496         VN_RELE(dirP);
3497         errno = EINVAL;
3498         return -1;
3499     }
3500
3501     /*
3502      * Create the link
3503      */
3504     usr_vattr_null(&attrs);
3505     attrs.va_type = VLNK;
3506     attrs.va_mode = 0777;
3507     attrs.va_uid = afs_cr_uid(u.u_cred);
3508     attrs.va_gid = afs_cr_gid(u.u_cred);
3509     code = afs_symlink(VTOAFS(dirP), nameP, &attrs, target, u.u_cred);
3510     VN_RELE(dirP);
3511     if (code != 0) {
3512         errno = code;
3513         return -1;
3514     }
3515     return 0;
3516 }
3517
3518 /*
3519  * Read a symbolic link into the buffer
3520  */
3521 int
3522 uafs_readlink(char *path, char *buf, int len)
3523 {
3524     int retval;
3525     AFS_GLOCK();
3526     retval = uafs_readlink_r(path, buf, len);
3527     AFS_GUNLOCK();
3528     return retval;
3529 }
3530
3531 int
3532 uafs_readlink_r(char *path, char *buf, int len)
3533 {
3534     int code;
3535     struct usr_vnode *vp;
3536     struct usr_uio uio;
3537     struct iovec iov[1];
3538
3539     code = uafs_LookupName(path, afs_CurrentDir, &vp, 0, 0);
3540     if (code != 0) {
3541         errno = code;
3542         return -1;
3543     }
3544
3545     if (vp->v_type != VLNK) {
3546         VN_RELE(vp);
3547         errno = EINVAL;
3548         return -1;
3549     }
3550
3551     /*
3552      * set up the uio buffer
3553      */
3554     iov[0].iov_base = buf;
3555     iov[0].iov_len = len;
3556     uio.uio_iov = &iov[0];
3557     uio.uio_iovcnt = 1;
3558     uio.uio_offset = 0;
3559     uio.uio_segflg = 0;
3560     uio.uio_fmode = FREAD;
3561     uio.uio_resid = len;
3562
3563     /*
3564      * Read the the link
3565      */
3566     code = afs_readlink(VTOAFS(vp), &uio, u.u_cred);
3567     VN_RELE(vp);
3568     if (code) {
3569         errno = code;
3570         return -1;
3571     }
3572
3573     /*
3574      * return the number of bytes read
3575      */
3576     return (len - uio.uio_resid);
3577 }
3578
3579 /*
3580  * Remove a file (or directory)
3581  * Note: file name may not end in a slash.
3582  */
3583 int
3584 uafs_unlink(char *path)
3585 {
3586     int retval;
3587     AFS_GLOCK();
3588     retval = uafs_unlink_r(path);
3589     AFS_GUNLOCK();
3590     return retval;
3591 }
3592
3593 int
3594 uafs_unlink_r(char *path)
3595 {
3596     int code;
3597     struct usr_vnode *dirP;
3598     char *nameP;
3599
3600     if (uafs_IsRoot(path)) {
3601         return EACCES;
3602     }
3603
3604     /*
3605      * Look up the parent directory.
3606      */
3607     nameP = uafs_LastPath(path);
3608     if (nameP != NULL) {
3609         code = uafs_LookupParent(path, &dirP);
3610         if (code != 0) {
3611             errno = code;
3612             return -1;
3613         }
3614     } else {
3615         dirP = afs_CurrentDir;
3616         nameP = path;
3617         VN_HOLD(dirP);
3618     }
3619
3620     /*
3621      * Make sure the filename has at least one character
3622      */
3623     if (*nameP == '\0') {
3624         VN_RELE(dirP);
3625         errno = EINVAL;
3626         return -1;
3627     }
3628
3629     /*
3630      * Remove the file
3631      */
3632     code = afs_remove(VTOAFS(dirP), nameP, u.u_cred);
3633     VN_RELE(dirP);
3634     if (code != 0) {
3635         errno = code;
3636         return -1;
3637     }
3638
3639     return 0;
3640 }
3641
3642 /*
3643  * Rename a file (or directory)
3644  */
3645 int
3646 uafs_rename(char *old, char *new)
3647 {
3648     int retval;
3649     AFS_GLOCK();
3650     retval = uafs_rename_r(old, new);
3651     AFS_GUNLOCK();
3652     return retval;
3653 }
3654
3655 int
3656 uafs_rename_r(char *old, char *new)
3657 {
3658     int code;
3659     char *onameP;
3660     char *nnameP;
3661     struct usr_vnode *odirP;
3662     struct usr_vnode *ndirP;
3663
3664     if (uafs_IsRoot(new)) {
3665         return EACCES;
3666     }
3667
3668     /*
3669      * Look up the parent directories.
3670      */
3671     onameP = uafs_LastPath(old);
3672     if (onameP != NULL) {
3673         code = uafs_LookupParent(old, &odirP);
3674         if (code != 0) {
3675             errno = code;
3676             return -1;
3677         }
3678     } else {
3679         odirP = afs_CurrentDir;
3680         onameP = old;
3681         VN_HOLD(odirP);
3682     }
3683     nnameP = uafs_LastPath(new);
3684     if (nnameP != NULL) {
3685         code = uafs_LookupParent(new, &ndirP);
3686         if (code != 0) {
3687             errno = code;
3688             return -1;
3689         }
3690     } else {
3691         ndirP = afs_CurrentDir;
3692         nnameP = new;
3693         VN_HOLD(ndirP);
3694     }
3695
3696     /*
3697      * Make sure the filename has at least one character
3698      */
3699     if (*onameP == '\0' || *nnameP == '\0') {
3700         VN_RELE(odirP);
3701         VN_RELE(ndirP);
3702         errno = EINVAL;
3703         return -1;
3704     }
3705
3706     /*
3707      * Rename the file
3708      */
3709     code = afs_rename(VTOAFS(odirP), onameP, VTOAFS(ndirP), nnameP, u.u_cred);
3710     VN_RELE(odirP);
3711     VN_RELE(ndirP);
3712     if (code != 0) {
3713         errno = code;
3714         return -1;
3715     }
3716
3717     return 0;
3718 }
3719
3720 /*
3721  * Remove a or directory
3722  * Note: file name may not end in a slash.
3723  */
3724 int
3725 uafs_rmdir(char *path)
3726 {
3727     int retval;
3728     AFS_GLOCK();
3729     retval = uafs_rmdir_r(path);
3730     AFS_GUNLOCK();
3731     return retval;
3732 }
3733
3734 int
3735 uafs_rmdir_r(char *path)
3736 {
3737     int code;
3738     struct usr_vnode *dirP;
3739     char *nameP;
3740
3741     if (uafs_IsRoot(path)) {
3742         return EACCES;
3743     }
3744
3745     /*
3746      * Look up the parent directory.
3747      */
3748     nameP = uafs_LastPath(path);
3749     if (nameP != NULL) {
3750         code = uafs_LookupParent(path, &dirP);
3751         if (code != 0) {
3752             errno = code;
3753             return -1;
3754         }
3755     } else {
3756         dirP = afs_CurrentDir;
3757         nameP = path;
3758         VN_HOLD(dirP);
3759     }
3760
3761     /*
3762      * Make sure the directory name has at least one character
3763      */
3764     if (*nameP == '\0') {
3765         VN_RELE(dirP);
3766         errno = EINVAL;
3767         return -1;
3768     }
3769
3770     /*
3771      * Remove the directory
3772      */
3773     code = afs_rmdir(VTOAFS(dirP), nameP, u.u_cred);
3774     VN_RELE(dirP);
3775     if (code != 0) {
3776         errno = code;
3777         return -1;
3778     }
3779
3780     return 0;
3781 }
3782
3783 /*
3784  * Flush a file from the AFS cache
3785  */
3786 int
3787 uafs_FlushFile(char *path)
3788 {
3789     int code;
3790     struct afs_ioctl iob;
3791
3792     iob.in = NULL;
3793     iob.in_size = 0;
3794     iob.out = NULL;
3795     iob.out_size = 0;
3796
3797     code =
3798         call_syscall(AFSCALL_PIOCTL, (long)path, _VICEIOCTL(6), (long)&iob, 0,
3799                      0);
3800     if (code != 0) {
3801         errno = code;
3802         return -1;
3803     }
3804
3805     return 0;
3806 }
3807
3808 int
3809 uafs_FlushFile_r(char *path)
3810 {
3811     int retval;
3812     AFS_GUNLOCK();
3813     retval = uafs_FlushFile(path);
3814     AFS_GLOCK();
3815     return retval;
3816 }
3817
3818 /*
3819  * open a directory
3820  */
3821 usr_DIR *
3822 uafs_opendir(char *path)
3823 {
3824     usr_DIR *retval;
3825     AFS_GLOCK();
3826     retval = uafs_opendir_r(path);
3827     AFS_GUNLOCK();
3828     return retval;
3829 }
3830
3831 usr_DIR *
3832 uafs_opendir_r(char *path)
3833 {
3834     usr_DIR *dirp;
3835     struct usr_vnode *fileP;
3836     int fd;
3837
3838     /*
3839      * Open the directory for reading
3840      */
3841     fd = uafs_open_r(path, O_RDONLY, 0);
3842     if (fd < 0) {
3843         return NULL;
3844     }
3845
3846     fileP = afs_FileTable[fd];
3847     if (fileP == NULL) {
3848         return NULL;
3849     }
3850
3851     if (fileP->v_type != VDIR) {
3852         uafs_close_r(fd);
3853         errno = ENOTDIR;
3854         return NULL;
3855     }
3856
3857     /*
3858      * Set up the directory structures
3859      */
3860     dirp =
3861         (usr_DIR *) afs_osi_Alloc(sizeof(usr_DIR) + USR_DIRSIZE +
3862                                   sizeof(struct usr_dirent));
3863     usr_assert(dirp != NULL);
3864     dirp->dd_buf = (char *)(dirp + 1);
3865     dirp->dd_fd = fd;
3866     dirp->dd_loc = 0;
3867     dirp->dd_size = 0;
3868
3869     errno = 0;
3870     return dirp;
3871 }
3872
3873 /*
3874  * Read directory entries into a file system independent format.
3875  * This routine was developed&n