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