Bug Summary

File:afs/UKERNEL/afs_usrops.c
Location:line 3463, column 34
Description:The right operand to '+' is always 0

Annotated Source Code

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