Update to the new thread world order for FBSD
[openafs.git] / src / afs / afs_pioctl.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include "afs/param.h"
12
13
14 #include "afs/sysincludes.h"    /* Standard vendor system headers */
15 #ifdef AFS_OBSD_ENV
16 #include "h/syscallargs.h"
17 #endif
18 #ifdef AFS_FBSD50_ENV
19 #include "h/sysproto.h"
20 #endif
21 #include "afsincludes.h"        /* Afs-based standard headers */
22 #include "afs/afs_stats.h"      /* afs statistics */
23 #include "afs/vice.h"
24 #include "afs/afs_bypasscache.h"
25 #include "rx/rx_globals.h"
26
27 struct VenusFid afs_rootFid;
28 afs_int32 afs_waitForever = 0;
29 short afs_waitForeverCount = 0;
30 afs_int32 afs_showflags = GAGUSER | GAGCONSOLE; /* show all messages */
31
32 #ifdef AFS_DISCON_ENV
33 afs_int32 afs_is_disconnected;
34 afs_int32 afs_is_discon_rw;
35 /* On reconnection, turn this knob on until it finishes,
36  * then turn it off.
37  */
38 afs_int32 afs_in_sync = 0;
39 #endif
40
41 struct afs_pdata {
42     char *ptr;
43     size_t remaining;
44 };
45
46 /*
47  * A set of handy little functions for encoding and decoding
48  * pioctls without losing your marbles, or memory integrity
49  */
50
51 static_inline int
52 afs_pd_alloc(struct afs_pdata *apd, size_t size) {
53
54     if (size > AFS_LRALLOCSIZ)
55         apd->ptr = osi_Alloc(size + 1);
56     else
57         apd->ptr = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
58
59     if (apd->ptr == NULL)
60         return ENOMEM;
61
62     apd->remaining = size;
63
64     return 0;
65 }
66
67 static_inline void
68 afs_pd_free(struct afs_pdata *apd) {
69     if (apd->ptr == NULL)
70         return;
71
72     if (apd->remaining > AFS_LRALLOCSIZ)
73         osi_Free(apd->ptr, apd->remaining + 1);
74     else
75         osi_FreeLargeSpace(apd->ptr);
76
77     apd->ptr = NULL;
78     apd->remaining = 0;
79 }
80
81 static_inline char *
82 afs_pd_where(struct afs_pdata *apd) {
83     return apd ? apd->ptr : NULL;
84 }
85
86 static_inline size_t
87 afs_pd_remaining(struct afs_pdata *apd) {
88     return apd ? apd->remaining : 0;
89 }
90
91 static_inline int
92 afs_pd_skip(struct afs_pdata *apd, size_t skip) {
93     if (apd == NULL || apd->remaining < skip)
94         return EINVAL;
95     apd->remaining -= skip;
96     apd->ptr += skip;
97
98     return 0;
99 }
100
101 static_inline int
102 afs_pd_getInt(struct afs_pdata *apd, afs_int32 *val) {
103     if (apd == NULL || apd->remaining < sizeof(afs_int32))
104         return EINVAL;
105     apd->remaining -= sizeof(afs_int32);
106     *val = *(afs_int32 *)apd->ptr;
107     apd->ptr += sizeof(afs_int32);
108     return 0;
109 }
110
111 static_inline int
112 afs_pd_getUint(struct afs_pdata *apd, afs_uint32 *val) {
113     return afs_pd_getInt(apd, (afs_int32 *)val);
114 }
115
116 static_inline int
117 afs_pd_getBytes(struct afs_pdata *apd, void *dest, size_t bytes) {
118     if (apd == NULL || apd->remaining < bytes)
119         return EINVAL;
120     apd->remaining -= bytes;
121     memcpy(dest, apd->ptr, bytes);
122     apd->ptr += bytes;
123     return 0;
124 }
125
126 static_inline void *
127 afs_pd_inline(struct afs_pdata *apd, size_t bytes) {
128     void *ret;
129
130     if (apd == NULL || apd->remaining < bytes)
131         return NULL;
132
133     ret = apd->ptr;
134
135     apd->remaining -= bytes;
136     apd->ptr += bytes;
137
138     return ret;
139 }
140
141 static_inline int
142 afs_pd_getString(struct afs_pdata *apd, char *str, size_t maxLen) {
143     size_t len;
144
145     if (apd == NULL || apd->remaining <= 0)
146         return EINVAL;
147     len = strlen(apd->ptr) + 1;
148     if (len > maxLen)
149         return E2BIG;
150     memcpy(str, apd->ptr, len);
151     apd->ptr += len;
152     apd->remaining -= len;
153     return 0;
154 }
155
156 static_inline int
157 afs_pd_getStringPtr(struct afs_pdata *apd, char **str) {
158     size_t len;
159
160     if (apd == NULL || apd->remaining <= 0)
161         return EINVAL;
162     len = strlen(apd->ptr) + 1;
163     *str = apd->ptr;
164     apd->ptr += len;
165     apd->remaining -= len;
166     return 0;
167 }
168
169 static_inline int
170 afs_pd_putInt(struct afs_pdata *apd, afs_int32 val) {
171     if (apd == NULL || apd->remaining < sizeof(afs_int32))
172         return E2BIG;
173     *(afs_int32 *)apd->ptr = val;
174     apd->ptr += sizeof(afs_int32);
175     apd->remaining -= sizeof(afs_int32);
176
177     return 0;
178 }
179
180 static_inline int
181 afs_pd_putBytes(struct afs_pdata *apd, const void *bytes, size_t len) {
182     if (apd == NULL || apd->remaining < len)
183         return E2BIG;
184     memcpy(apd->ptr, bytes, len);
185     apd->ptr += len;
186     apd->remaining -= len;
187     return 0;
188 }
189
190 static_inline int
191 afs_pd_putString(struct afs_pdata *apd, char *str) {
192
193     /* Add 1 so we copy the NULL too */
194     return afs_pd_putBytes(apd, str, strlen(str) +1);
195 }
196
197 /*!
198  * \defgroup pioctl Path IOCTL functions
199  *
200  * DECL_PIOCTL is a macro defined to contain the following parameters for functions:
201  *
202  * \param[in] avc
203  *      the AFS vcache structure in use by pioctl
204  * \param[in] afun
205  *      not in use
206  * \param[in] areq
207  *      the AFS vrequest structure
208  * \param[in] ain
209  *      an afs_pdata block describing the data received from the caller
210  * \param[in] aout
211  *      an afs_pdata block describing a pre-allocated block for output
212  * \param[in] acred
213  *      UNIX credentials structure underlying the operation
214  */
215
216 #define DECL_PIOCTL(x) \
217         static int x(struct vcache *avc, int afun, struct vrequest *areq, \
218                      struct afs_pdata *ain, struct afs_pdata *aout, \
219                      afs_ucred_t **acred)
220
221 /* Prototypes for pioctl routines */
222 DECL_PIOCTL(PGetFID);
223 DECL_PIOCTL(PSetAcl);
224 DECL_PIOCTL(PStoreBehind);
225 DECL_PIOCTL(PGCPAGs);
226 DECL_PIOCTL(PGetAcl);
227 DECL_PIOCTL(PNoop);
228 DECL_PIOCTL(PBogus);
229 DECL_PIOCTL(PGetFileCell);
230 DECL_PIOCTL(PGetWSCell);
231 DECL_PIOCTL(PGetUserCell);
232 DECL_PIOCTL(PSetTokens);
233 DECL_PIOCTL(PGetVolumeStatus);
234 DECL_PIOCTL(PSetVolumeStatus);
235 DECL_PIOCTL(PFlush);
236 DECL_PIOCTL(PNewStatMount);
237 DECL_PIOCTL(PGetTokens);
238 DECL_PIOCTL(PUnlog);
239 DECL_PIOCTL(PMariner);
240 DECL_PIOCTL(PCheckServers);
241 DECL_PIOCTL(PCheckVolNames);
242 DECL_PIOCTL(PCheckAuth);
243 DECL_PIOCTL(PFindVolume);
244 DECL_PIOCTL(PViceAccess);
245 DECL_PIOCTL(PSetCacheSize);
246 DECL_PIOCTL(PGetCacheSize);
247 DECL_PIOCTL(PRemoveCallBack);
248 DECL_PIOCTL(PNewCell);
249 DECL_PIOCTL(PNewAlias);
250 DECL_PIOCTL(PListCells);
251 DECL_PIOCTL(PListAliases);
252 DECL_PIOCTL(PRemoveMount);
253 DECL_PIOCTL(PGetCellStatus);
254 DECL_PIOCTL(PSetCellStatus);
255 DECL_PIOCTL(PFlushVolumeData);
256 DECL_PIOCTL(PGetVnodeXStatus);
257 DECL_PIOCTL(PGetVnodeXStatus2);
258 DECL_PIOCTL(PSetSysName);
259 DECL_PIOCTL(PSetSPrefs);
260 DECL_PIOCTL(PSetSPrefs33);
261 DECL_PIOCTL(PGetSPrefs);
262 DECL_PIOCTL(PExportAfs);
263 DECL_PIOCTL(PGag);
264 DECL_PIOCTL(PTwiddleRx);
265 DECL_PIOCTL(PGetInitParams);
266 DECL_PIOCTL(PGetRxkcrypt);
267 DECL_PIOCTL(PSetRxkcrypt);
268 DECL_PIOCTL(PGetCPrefs);
269 DECL_PIOCTL(PSetCPrefs);
270 DECL_PIOCTL(PFlushMount);
271 DECL_PIOCTL(PRxStatProc);
272 DECL_PIOCTL(PRxStatPeer);
273 DECL_PIOCTL(PPrefetchFromTape);
274 DECL_PIOCTL(PFsCmd);
275 DECL_PIOCTL(PCallBackAddr);
276 DECL_PIOCTL(PDiscon);
277 DECL_PIOCTL(PNFSNukeCreds);
278 DECL_PIOCTL(PNewUuid);
279 DECL_PIOCTL(PPrecache); 
280 DECL_PIOCTL(PGetPAG);
281 #if defined(AFS_CACHE_BYPASS)
282 DECL_PIOCTL(PSetCachingThreshold);
283 DECL_PIOCTL(PSetCachingBlkSize);
284 #endif
285
286 /*
287  * A macro that says whether we're going to need HandleClientContext().
288  * This is currently used only by the nfs translator.
289  */
290 #if !defined(AFS_NONFSTRANS) || defined(AFS_AIX_IAUTH_ENV)
291 #define AFS_NEED_CLIENTCONTEXT
292 #endif
293
294 /* Prototypes for private routines */
295 #ifdef AFS_NEED_CLIENTCONTEXT
296 static int HandleClientContext(struct afs_ioctl *ablob, int *com,
297                                afs_ucred_t **acred,
298                                afs_ucred_t *credp);
299 #endif
300 int HandleIoctl(register struct vcache *avc, register afs_int32 acom,
301                 struct afs_ioctl *adata);
302 int afs_HandlePioctl(struct vnode *avp, afs_int32 acom,
303                      register struct afs_ioctl *ablob, int afollow,
304                      afs_ucred_t **acred);
305 static int Prefetch(uparmtype apath, struct afs_ioctl *adata, int afollow,
306                     afs_ucred_t *acred);
307
308 typedef int (*pioctlFunction) (struct vcache *, int, struct vrequest *,
309                                struct afs_pdata *, struct afs_pdata *,
310                                afs_ucred_t **);
311
312 static pioctlFunction VpioctlSw[] = {
313     PBogus,                     /* 0 */
314     PSetAcl,                    /* 1 */
315     PGetAcl,                    /* 2 */
316     PSetTokens,                 /* 3 */
317     PGetVolumeStatus,           /* 4 */
318     PSetVolumeStatus,           /* 5 */
319     PFlush,                     /* 6 */
320     PBogus,                     /* 7 */
321     PGetTokens,                 /* 8 */
322     PUnlog,                     /* 9 */
323     PCheckServers,              /* 10 */
324     PCheckVolNames,             /* 11 */
325     PCheckAuth,                 /* 12 */
326     PBogus,                     /* 13 -- used to be quick check time */
327     PFindVolume,                /* 14 */
328     PBogus,                     /* 15 -- prefetch is now special-cased; see pioctl code! */
329     PBogus,                     /* 16 -- used to be testing code */
330     PNoop,                      /* 17 -- used to be enable group */
331     PNoop,                      /* 18 -- used to be disable group */
332     PBogus,                     /* 19 -- used to be list group */
333     PViceAccess,                /* 20 */
334     PUnlog,                     /* 21 -- unlog *is* unpag in this system */
335     PGetFID,                    /* 22 -- get file ID */
336     PBogus,                     /* 23 -- used to be waitforever */
337     PSetCacheSize,              /* 24 */
338     PRemoveCallBack,            /* 25 -- flush only the callback */
339     PNewCell,                   /* 26 */
340     PListCells,                 /* 27 */
341     PRemoveMount,               /* 28 -- delete mount point */
342     PNewStatMount,              /* 29 -- new style mount point stat */
343     PGetFileCell,               /* 30 -- get cell name for input file */
344     PGetWSCell,                 /* 31 -- get cell name for workstation */
345     PMariner,                   /* 32 - set/get mariner host */
346     PGetUserCell,               /* 33 -- get cell name for user */
347     PBogus,                     /* 34 -- Enable/Disable logging */
348     PGetCellStatus,             /* 35 */
349     PSetCellStatus,             /* 36 */
350     PFlushVolumeData,           /* 37 -- flush all data from a volume */
351     PSetSysName,                /* 38 - Set system name */
352     PExportAfs,                 /* 39 - Export Afs to remote nfs clients */
353     PGetCacheSize,              /* 40 - get cache size and usage */
354     PGetVnodeXStatus,           /* 41 - get vcache's special status */
355     PSetSPrefs33,               /* 42 - Set CM Server preferences... */
356     PGetSPrefs,                 /* 43 - Get CM Server preferences... */
357     PGag,                       /* 44 - turn off/on all CM messages */
358     PTwiddleRx,                 /* 45 - adjust some RX params       */
359     PSetSPrefs,                 /* 46 - Set CM Server preferences... */
360     PStoreBehind,               /* 47 - set degree of store behind to be done */
361     PGCPAGs,                    /* 48 - disable automatic pag gc-ing */
362     PGetInitParams,             /* 49 - get initial cm params */
363     PGetCPrefs,                 /* 50 - get client interface addresses */
364     PSetCPrefs,                 /* 51 - set client interface addresses */
365     PFlushMount,                /* 52 - flush mount symlink data */
366     PRxStatProc,                /* 53 - control process RX statistics */
367     PRxStatPeer,                /* 54 - control peer RX statistics */
368     PGetRxkcrypt,               /* 55 -- Get rxkad encryption flag */
369     PSetRxkcrypt,               /* 56 -- Set rxkad encryption flag */
370     PBogus,                     /* 57 -- arla: set file prio */
371     PBogus,                     /* 58 -- arla: fallback getfh */
372     PBogus,                     /* 59 -- arla: fallback fhopen */
373     PBogus,                     /* 60 -- arla: controls xfsdebug */
374     PBogus,                     /* 61 -- arla: controls arla debug */
375     PBogus,                     /* 62 -- arla: debug interface */
376     PBogus,                     /* 63 -- arla: print xfs status */
377     PBogus,                     /* 64 -- arla: force cache check */
378     PBogus,                     /* 65 -- arla: break callback */
379     PPrefetchFromTape,          /* 66 -- MR-AFS: prefetch file from tape */
380     PFsCmd,                     /* 67 -- RXOSD: generic commnd interface */
381     PBogus,                     /* 68 -- arla: fetch stats */
382     PGetVnodeXStatus2,          /* 69 - get caller access and some vcache status */
383 };
384
385 static pioctlFunction CpioctlSw[] = {
386     PBogus,                     /* 0 */
387     PNewAlias,                  /* 1 -- create new cell alias */
388     PListAliases,               /* 2 -- list cell aliases */
389     PCallBackAddr,              /* 3 -- request addr for callback rxcon */
390     PBogus,                     /* 4 */
391     PDiscon,                    /* 5 -- get/set discon mode */
392     PBogus,                     /* 6 */
393     PBogus,                     /* 7 */
394     PBogus,                     /* 8 */
395     PNewUuid,                   /* 9 */
396     PBogus,                     /* 10 */
397     PBogus,                     /* 11 */
398     PPrecache,                  /* 12 */
399     PGetPAG,                    /* 13 */
400 };
401
402 static pioctlFunction OpioctlSw[]  = {
403     PBogus,                     /* 0 */
404     PNFSNukeCreds,              /* 1 -- nuke all creds for NFS client */
405 #if defined(AFS_CACHE_BYPASS)
406     PSetCachingThreshold        /* 2 -- get/set cache-bypass size threshold */
407 #else
408     PNoop                       /* 2 -- get/set cache-bypass size threshold */
409 #endif
410 };
411
412 #define PSetClientContext 99    /*  Special pioctl to setup caller's creds  */
413 int afs_nobody = NFS_NOBODY;
414
415 int
416 HandleIoctl(register struct vcache *avc, register afs_int32 acom,
417             struct afs_ioctl *adata)
418 {
419     register afs_int32 code;
420
421     code = 0;
422     AFS_STATCNT(HandleIoctl);
423
424     switch (acom & 0xff) {
425     case 1:
426         avc->f.states |= CSafeStore;
427         avc->asynchrony = 0;
428         /* SXW - Should we force a MetaData flush for this flag setting */
429         break;
430
431         /* case 2 used to be abort store, but this is no longer provided,
432          * since it is impossible to implement under normal Unix.
433          */
434
435     case 3:{
436             /* return the name of the cell this file is open on */
437             register struct cell *tcell;
438             register afs_int32 i;
439
440             tcell = afs_GetCell(avc->f.fid.Cell, READ_LOCK);
441             if (tcell) {
442                 i = strlen(tcell->cellName) + 1;        /* bytes to copy out */
443
444                 if (i > adata->out_size) {
445                     /* 0 means we're not interested in the output */
446                     if (adata->out_size != 0)
447                         code = EFAULT;
448                 } else {
449                     /* do the copy */
450                     AFS_COPYOUT(tcell->cellName, adata->out, i, code);
451                 }
452                 afs_PutCell(tcell, READ_LOCK);
453             } else
454                 code = ENOTTY;
455         }
456         break;
457
458     case 49:                    /* VIOC_GETINITPARAMS */
459         if (adata->out_size < sizeof(struct cm_initparams)) {
460             code = EFAULT;
461         } else {
462             AFS_COPYOUT(&cm_initParams, adata->out,
463                         sizeof(struct cm_initparams), code);
464         }
465         break;
466
467     default:
468
469         code = EINVAL;
470 #ifdef AFS_AIX51_ENV
471         code = ENOSYS;
472 #endif
473         break;
474     }
475     return code;                /* so far, none implemented */
476 }
477
478 #ifdef AFS_AIX_ENV
479 /* For aix we don't temporarily bypass ioctl(2) but rather do our
480  * thing directly in the vnode layer call, VNOP_IOCTL; thus afs_ioctl
481  * is now called from afs_gn_ioctl.
482  */
483 int
484 afs_ioctl(struct vcache *tvc, int cmd, int arg)
485 {
486     struct afs_ioctl data;
487     int error = 0;
488
489     AFS_STATCNT(afs_ioctl);
490     if (((cmd >> 8) & 0xff) == 'V') {
491         /* This is a VICEIOCTL call */
492         AFS_COPYIN(arg, (caddr_t) & data, sizeof(data), error);
493         if (error)
494             return (error);
495         error = HandleIoctl(tvc, cmd, &data);
496         return (error);
497     } else {
498         /* No-op call; just return. */
499         return (ENOTTY);
500     }
501 }
502 # if defined(AFS_AIX32_ENV)
503 #  if defined(AFS_AIX51_ENV)
504 #   ifdef __64BIT__
505 int
506 kioctl(int fdes, int com, caddr_t arg, caddr_t ext, caddr_t arg2,
507            caddr_t arg3)
508 #   else /* __64BIT__ */
509 int
510 kioctl32(int fdes, int com, caddr_t arg, caddr_t ext, caddr_t arg2,
511              caddr_t arg3)
512 #   endif /* __64BIT__ */
513 #  else
514 int
515 kioctl(int fdes, int com, caddr_t arg, caddr_t ext)
516 #  endif /* AFS_AIX51_ENV */
517 {
518     struct a {
519         int fd, com;
520         caddr_t arg, ext;
521 #  ifdef AFS_AIX51_ENV
522         caddr_t arg2, arg3;
523 #  endif
524     } u_uap, *uap = &u_uap;
525     struct file *fd;
526     register struct vcache *tvc;
527     register int ioctlDone = 0, code = 0;
528
529     AFS_STATCNT(afs_xioctl);
530     uap->fd = fdes;
531     uap->com = com;
532     uap->arg = arg;
533 #  ifdef AFS_AIX51_ENV
534     uap->arg2 = arg2;
535     uap->arg3 = arg3;
536 #  endif
537     if (setuerror(getf(uap->fd, &fd))) {
538         return -1;
539     }
540     if (fd->f_type == DTYPE_VNODE) {
541         /* good, this is a vnode; next see if it is an AFS vnode */
542         tvc = VTOAFS(fd->f_vnode);      /* valid, given a vnode */
543         if (tvc && IsAfsVnode(AFSTOV(tvc))) {
544             /* This is an AFS vnode */
545             if (((uap->com >> 8) & 0xff) == 'V') {
546                 register struct afs_ioctl *datap;
547                 AFS_GLOCK();
548                 datap =
549                     (struct afs_ioctl *)osi_AllocSmallSpace(AFS_SMALLOCSIZ);
550                 code=copyin_afs_ioctl((char *)uap->arg, datap);
551                 if (code) {
552                     osi_FreeSmallSpace(datap);
553                     AFS_GUNLOCK();
554 #  if defined(AFS_AIX41_ENV)
555                     ufdrele(uap->fd);
556 #  endif
557                     return (setuerror(code), code);
558                 }
559                 code = HandleIoctl(tvc, uap->com, datap);
560                 osi_FreeSmallSpace(datap);
561                 AFS_GUNLOCK();
562                 ioctlDone = 1;
563 #  if defined(AFS_AIX41_ENV)
564                 ufdrele(uap->fd);
565 #  endif
566              }
567         }
568     }
569     if (!ioctlDone) {
570 #  if defined(AFS_AIX41_ENV)
571         ufdrele(uap->fd);
572 #   if defined(AFS_AIX51_ENV)
573 #    ifdef __64BIT__
574         code = okioctl(fdes, com, arg, ext, arg2, arg3);
575 #    else /* __64BIT__ */
576         code = okioctl32(fdes, com, arg, ext, arg2, arg3);
577 #    endif /* __64BIT__ */
578 #   else /* !AFS_AIX51_ENV */
579         code = okioctl(fdes, com, arg, ext);
580 #   endif /* AFS_AIX51_ENV */
581         return code;
582 #  elif defined(AFS_AIX32_ENV)
583         okioctl(fdes, com, arg, ext);
584 #  endif
585     }
586 #  if defined(KERNEL_HAVE_UERROR)
587     if (!getuerror())
588         setuerror(code);
589 #   if !defined(AFS_AIX41_ENV)
590     return (getuerror()? -1 : u.u_ioctlrv);
591 #   else
592     return getuerror()? -1 : 0;
593 #   endif
594 #  endif
595     return 0;
596 }
597 # endif
598
599 #elif defined(AFS_SGI_ENV)
600 # if defined(AFS_SGI65_ENV)
601 afs_ioctl(OSI_VN_DECL(tvc), int cmd, void *arg, int flag, cred_t * cr,
602           rval_t * rvalp, struct vopbd * vbds)
603 # else
604 afs_ioctl(OSI_VN_DECL(tvc), int cmd, void *arg, int flag, cred_t * cr,
605           rval_t * rvalp, struct vopbd * vbds)
606 # endif
607 {
608     struct afs_ioctl data;
609     int error = 0;
610     int locked;
611
612     OSI_VN_CONVERT(tvc);
613
614     AFS_STATCNT(afs_ioctl);
615     if (((cmd >> 8) & 0xff) == 'V') {
616         /* This is a VICEIOCTL call */
617         error = copyin_afs_ioctl(arg, &data);
618         if (error)
619             return (error);
620         locked = ISAFS_GLOCK();
621         if (!locked)
622             AFS_GLOCK();
623         error = HandleIoctl(tvc, cmd, &data);
624         if (!locked)
625             AFS_GUNLOCK();
626         return (error);
627     } else {
628         /* No-op call; just return. */
629         return (ENOTTY);
630     }
631 }
632 #elif defined(AFS_SUN5_ENV)
633 struct afs_ioctl_sys {
634     int fd;
635     int com;
636     int arg;
637 };
638
639 int 
640 afs_xioctl(struct afs_ioctl_sys *uap, rval_t *rvp)
641 {
642     struct file *fd;
643     register struct vcache *tvc;
644     register int ioctlDone = 0, code = 0;
645
646     AFS_STATCNT(afs_xioctl);
647 # if defined(AFS_SUN57_ENV)
648     fd = getf(uap->fd);
649     if (!fd)
650         return (EBADF);
651 # elif defined(AFS_SUN54_ENV)
652     fd = GETF(uap->fd);
653     if (!fd)
654         return (EBADF);
655 # else
656     if (code = getf(uap->fd, &fd)) {
657         return (code);
658     }
659 # endif
660     if (fd->f_vnode->v_type == VREG || fd->f_vnode->v_type == VDIR) {
661         tvc = VTOAFS(fd->f_vnode);      /* valid, given a vnode */
662         if (tvc && IsAfsVnode(AFSTOV(tvc))) {
663             /* This is an AFS vnode */
664             if (((uap->com >> 8) & 0xff) == 'V') {
665                 register struct afs_ioctl *datap;
666                 AFS_GLOCK();
667                 datap =
668                     (struct afs_ioctl *)osi_AllocSmallSpace(AFS_SMALLOCSIZ);
669                 code=copyin_afs_ioctl((char *)uap->arg, datap);
670                 if (code) {
671                     osi_FreeSmallSpace(datap);
672                     AFS_GUNLOCK();
673 # if defined(AFS_SUN54_ENV)
674                     releasef(uap->fd);
675 # else
676                     releasef(fd);
677 # endif
678                     return (EFAULT);
679                 }
680                 code = HandleIoctl(tvc, uap->com, datap);
681                 osi_FreeSmallSpace(datap);
682                 AFS_GUNLOCK();
683                 ioctlDone = 1;
684             }
685         }
686     }
687 # if defined(AFS_SUN57_ENV)
688     releasef(uap->fd);
689 # elif defined(AFS_SUN54_ENV)
690     RELEASEF(uap->fd);
691 # else
692     releasef(fd);
693 # endif
694     if (!ioctlDone)
695         code = ioctl(uap, rvp);
696
697     return (code);
698 }
699 #elif defined(AFS_LINUX22_ENV)
700 struct afs_ioctl_sys {
701     unsigned int com;
702     unsigned long arg;
703 };
704 int
705 afs_xioctl(struct inode *ip, struct file *fp, unsigned int com,
706            unsigned long arg)
707 {
708     struct afs_ioctl_sys ua, *uap = &ua;
709     register struct vcache *tvc;
710     register int ioctlDone = 0, code = 0;
711
712     AFS_STATCNT(afs_xioctl);
713     ua.com = com;
714     ua.arg = arg;
715
716     tvc = VTOAFS(ip);
717     if (tvc && IsAfsVnode(AFSTOV(tvc))) {
718         /* This is an AFS vnode */
719         if (((uap->com >> 8) & 0xff) == 'V') {
720             register struct afs_ioctl *datap;
721             AFS_GLOCK();
722             datap = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
723             code = copyin_afs_ioctl((char *)uap->arg, datap);
724             if (code) {
725                 osi_FreeSmallSpace(datap);
726                 AFS_GUNLOCK();
727                 return -code;
728             }
729             code = HandleIoctl(tvc, uap->com, datap);
730             osi_FreeSmallSpace(datap);
731             AFS_GUNLOCK();
732             ioctlDone = 1;
733         }
734         else
735             code = EINVAL;
736     }
737     return -code;
738 }
739 #elif defined(AFS_DARWIN_ENV) && !defined(AFS_DARWIN80_ENV)
740 struct ioctl_args {
741     int fd;
742     u_long com;
743     caddr_t arg;
744 };
745
746 int
747 afs_xioctl(afs_proc_t *p, register struct ioctl_args *uap, register_t *retval)
748 {
749     struct file *fd;
750     register struct vcache *tvc;
751     register int ioctlDone = 0, code = 0;
752
753     AFS_STATCNT(afs_xioctl);
754     if ((code = fdgetf(p, uap->fd, &fd)))
755         return code;
756     if (fd->f_type == DTYPE_VNODE) {
757         tvc = VTOAFS((struct vnode *)fd->f_data);       /* valid, given a vnode */
758         if (tvc && IsAfsVnode(AFSTOV(tvc))) {
759             /* This is an AFS vnode */
760             if (((uap->com >> 8) & 0xff) == 'V') {
761                 register struct afs_ioctl *datap;
762                 AFS_GLOCK();
763                 datap = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
764                 code = copyin_afs_ioctl((char *)uap->arg, datap);
765                 if (code) {
766                     osi_FreeSmallSpace(datap);
767                     AFS_GUNLOCK();
768                     return code;
769                 }
770                 code = HandleIoctl(tvc, uap->com, datap);
771                 osi_FreeSmallSpace(datap);
772                 AFS_GUNLOCK();
773                 ioctlDone = 1;
774             }
775         }
776     }
777
778     if (!ioctlDone)
779         return ioctl(p, uap, retval);
780
781     return (code);
782 }
783 #elif defined(AFS_XBSD_ENV)
784 # if defined(AFS_FBSD50_ENV)
785 #  define arg data
786 int
787 afs_xioctl(struct thread *td, register struct ioctl_args *uap,
788            register_t *retval)
789 {
790     afs_proc_t *p = td->td_proc;
791 # else
792 struct ioctl_args {
793     int fd;
794     u_long com;
795     caddr_t arg;
796 };
797
798 int
799 afs_xioctl(afs_proc_t *p, register struct ioctl_args *uap, register_t *retval)
800 {
801 # endif
802     register struct filedesc *fdp;
803     register struct vcache *tvc;
804     register int ioctlDone = 0, code = 0;
805     struct file *fd;
806
807     AFS_STATCNT(afs_xioctl);
808     fdp = p->p_fd;
809     if ((u_int) uap->fd >= fdp->fd_nfiles
810         || (fd = fdp->fd_ofiles[uap->fd]) == NULL)
811         return EBADF;
812     if ((fd->f_flag & (FREAD | FWRITE)) == 0)
813         return EBADF;
814     /* first determine whether this is any sort of vnode */
815     if (fd->f_type == DTYPE_VNODE) {
816         /* good, this is a vnode; next see if it is an AFS vnode */
817 # if defined(AFS_OBSD_ENV)
818         tvc =
819             IsAfsVnode((struct vnode *)fd->
820                        f_data) ? VTOAFS((struct vnode *)fd->f_data) : NULL;
821 # else
822         tvc = VTOAFS((struct vnode *)fd->f_data);       /* valid, given a vnode */
823 # endif
824         if (tvc && IsAfsVnode(AFSTOV(tvc))) {
825             /* This is an AFS vnode */
826             if (((uap->com >> 8) & 0xff) == 'V') {
827                 register struct afs_ioctl *datap;
828                 AFS_GLOCK();
829                 datap = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
830                 code = copyin_afs_ioctl((char *)uap->arg, datap);
831                 if (code) {
832                     osi_FreeSmallSpace(datap);
833                     AFS_GUNLOCK();
834                     return code;
835                 }
836                 code = HandleIoctl(tvc, uap->com, datap);
837                 osi_FreeSmallSpace(datap);
838                 AFS_GUNLOCK();
839                 ioctlDone = 1;
840             }
841         }
842     }
843
844     if (!ioctlDone) {
845 # if defined(AFS_FBSD50_ENV)
846         return ioctl(td, uap);
847 # elif defined(AFS_FBSD_ENV)
848         return ioctl(p, uap);
849 # elif defined(AFS_OBSD_ENV)
850         code = sys_ioctl(p, uap, retval);
851 # endif
852     }
853
854     return (code);
855 }
856 #elif defined(UKERNEL)
857 int
858 afs_xioctl(void)
859 {
860     register struct a {
861         int fd;
862         int com;
863         caddr_t arg;
864     } *uap = (struct a *)get_user_struct()->u_ap;
865     register struct file *fd;
866     register struct vcache *tvc;
867     register int ioctlDone = 0, code = 0;
868
869     AFS_STATCNT(afs_xioctl);
870
871     fd = getf(uap->fd);
872     if (!fd)
873         return (EBADF);
874     /* first determine whether this is any sort of vnode */
875     if (fd->f_type == DTYPE_VNODE) {
876         /* good, this is a vnode; next see if it is an AFS vnode */
877         tvc = VTOAFS((struct vnode *)fd->f_data);       /* valid, given a vnode */
878         if (tvc && IsAfsVnode(AFSTOV(tvc))) {
879             /* This is an AFS vnode */
880             if (((uap->com >> 8) & 0xff) == 'V') {
881                 register struct afs_ioctl *datap;
882                 AFS_GLOCK();
883                 datap = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
884                 code=copyin_afs_ioctl((char *)uap->arg, datap);
885                 if (code) {
886                     osi_FreeSmallSpace(datap);
887                     AFS_GUNLOCK();
888
889                     return (setuerror(code), code);
890                 }
891                 code = HandleIoctl(tvc, uap->com, datap);
892                 osi_FreeSmallSpace(datap);
893                 AFS_GUNLOCK();
894                 ioctlDone = 1;
895             }
896         }
897     }
898
899     if (!ioctlDone) {
900         ioctl();
901     }
902
903     return 0;
904 }
905 #endif /* AFS_HPUX102_ENV */
906
907 #if defined(AFS_SGI_ENV)
908   /* "pioctl" system call entry point; just pass argument to the parameterized
909    * call below */
910 struct pioctlargs {
911     char *path;
912     sysarg_t cmd;
913     caddr_t cmarg;
914     sysarg_t follow;
915 };
916 int
917 afs_pioctl(struct pioctlargs *uap, rval_t * rvp)
918 {
919     int code;
920
921     AFS_STATCNT(afs_pioctl);
922     AFS_GLOCK();
923     code = afs_syscall_pioctl(uap->path, uap->cmd, uap->cmarg, uap->follow);
924     AFS_GUNLOCK();
925 # ifdef AFS_SGI64_ENV
926     return code;
927 # else
928     return u.u_error;
929 # endif
930 }
931
932 #elif defined(AFS_FBSD50_ENV)
933 int
934 afs_pioctl(struct thread *td, void *args, int *retval)
935 {
936     struct a {
937         char *path;
938         int cmd;
939         caddr_t cmarg;
940         int follow;
941     } *uap = (struct a *)args;
942
943     AFS_STATCNT(afs_pioctl);
944     return (afs_syscall_pioctl
945             (uap->path, uap->cmd, uap->cmarg, uap->follow, td->td_ucred));
946 }
947
948 #elif defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
949 int
950 # if defined(AFS_FBSD_ENV)
951 afs_pioctl(struct thread *td, void *args)
952 # else
953 afs_pioctl(afs_proc_t *p, void *args, int *retval)
954 # endif
955 {
956     struct a {
957         char *path;
958         int cmd;
959         caddr_t cmarg;
960         int follow;
961     } *uap = (struct a *)args;
962
963     AFS_STATCNT(afs_pioctl);
964 # ifdef AFS_DARWIN80_ENV
965     return (afs_syscall_pioctl
966             (uap->path, uap->cmd, uap->cmarg, uap->follow,
967              kauth_cred_get()));
968 # else
969     return (afs_syscall_pioctl
970             (uap->path, uap->cmd, uap->cmarg, uap->follow,
971 #  if defined(AFS_FBSD_ENV)
972              td->td_ucred));
973 #  else
974              p->p_cred->pc_ucred));
975 #  endif
976 # endif
977 }
978
979 #endif
980
981 /* macro to avoid adding any more #ifdef's to pioctl code. */
982 #if defined(AFS_LINUX22_ENV) || defined(AFS_AIX41_ENV)
983 #define PIOCTL_FREE_CRED() crfree(credp)
984 #else
985 #define PIOCTL_FREE_CRED()
986 #endif
987
988 int
989 #ifdef  AFS_SUN5_ENV
990 afs_syscall_pioctl(char *path, unsigned int com, caddr_t cmarg, int follow, 
991                    rval_t *vvp, afs_ucred_t *credp)
992 #else
993 #ifdef AFS_DARWIN100_ENV
994 afs_syscall64_pioctl(user_addr_t path, unsigned int com, user_addr_t cmarg,
995                    int follow, afs_ucred_t *credp)
996 #elif defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
997 afs_syscall_pioctl(char *path, unsigned int com, caddr_t cmarg, int follow, 
998                    afs_ucred_t *credp)
999 #else
1000 afs_syscall_pioctl(char *path, unsigned int com, caddr_t cmarg, int follow)
1001 #endif
1002 #endif
1003 {
1004     struct afs_ioctl data;
1005 #ifdef AFS_NEED_CLIENTCONTEXT
1006     afs_ucred_t *tmpcred = NULL;
1007 #endif
1008 #if defined(AFS_NEED_CLIENTCONTEXT) || defined(AFS_SUN5_ENV) || defined(AFS_AIX41_ENV) || defined(AFS_LINUX22_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
1009     afs_ucred_t *foreigncreds = NULL;
1010 #endif
1011     register afs_int32 code = 0;
1012     struct vnode *vp = NULL;
1013 #ifdef  AFS_AIX41_ENV
1014     struct ucred *credp = crref();      /* don't free until done! */
1015 #endif
1016 #ifdef AFS_LINUX22_ENV
1017     cred_t *credp = crref();    /* don't free until done! */
1018     struct dentry *dp;
1019 #endif
1020
1021     AFS_STATCNT(afs_syscall_pioctl);
1022     if (follow)
1023         follow = 1;             /* compat. with old venus */
1024     code = copyin_afs_ioctl(cmarg, &data);
1025     if (code) {
1026         PIOCTL_FREE_CRED();
1027 #if defined(KERNEL_HAVE_UERROR)
1028         setuerror(code);
1029 #endif
1030         return (code);
1031     }
1032     if ((com & 0xff) == PSetClientContext) {
1033 #ifdef AFS_NEED_CLIENTCONTEXT
1034 #if defined(AFS_SUN5_ENV) || defined(AFS_AIX41_ENV) || defined(AFS_LINUX22_ENV)
1035         code = HandleClientContext(&data, &com, &foreigncreds, credp);
1036 #else
1037         code = HandleClientContext(&data, &com, &foreigncreds, osi_curcred());
1038 #endif
1039         if (code) {
1040             if (foreigncreds) {
1041                 crfree(foreigncreds);
1042             }
1043             PIOCTL_FREE_CRED();
1044 #if defined(KERNEL_HAVE_UERROR)
1045             return (setuerror(code), code);
1046 #else
1047             return (code);
1048 #endif
1049         }
1050 #else /* AFS_NEED_CLIENTCONTEXT */
1051         return EINVAL;
1052 #endif /* AFS_NEED_CLIENTCONTEXT */
1053     }
1054 #ifdef AFS_NEED_CLIENTCONTEXT
1055     if (foreigncreds) {
1056         /*
1057          * We could have done without temporary setting the u.u_cred below
1058          * (foreigncreds could be passed as param the pioctl modules)
1059          * but calls such as afs_osi_suser() doesn't allow that since it
1060          * references u.u_cred directly.  We could, of course, do something
1061          * like afs_osi_suser(cred) which, I think, is better since it
1062          * generalizes and supports multi cred environments...
1063          */
1064 #if defined(AFS_SUN5_ENV) || defined(AFS_LINUX22_ENV)
1065         tmpcred = credp;
1066         credp = foreigncreds;
1067 #elif defined(AFS_AIX41_ENV)
1068         tmpcred = crref();      /* XXX */
1069         crset(foreigncreds);
1070 #elif defined(AFS_HPUX101_ENV)
1071         tmpcred = p_cred(u.u_procp);
1072         set_p_cred(u.u_procp, foreigncreds);
1073 #elif defined(AFS_SGI_ENV)
1074         tmpcred = OSI_GET_CURRENT_CRED();
1075         OSI_SET_CURRENT_CRED(foreigncreds);
1076 #else
1077         tmpcred = u.u_cred;
1078         u.u_cred = foreigncreds;
1079 #endif
1080     }
1081 #endif /* AFS_NEED_CLIENTCONTEXT */
1082     if ((com & 0xff) == 15) {
1083         /* special case prefetch so entire pathname eval occurs in helper process.
1084          * otherwise, the pioctl call is essentially useless */
1085 #if     defined(AFS_SUN5_ENV) || defined(AFS_AIX41_ENV) || defined(AFS_LINUX22_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
1086         code =
1087             Prefetch(path, &data, follow,
1088                      foreigncreds ? foreigncreds : credp);
1089 #else
1090         code = Prefetch(path, &data, follow, osi_curcred());
1091 #endif
1092         vp = NULL;
1093 #if defined(KERNEL_HAVE_UERROR)
1094         setuerror(code);
1095 #endif
1096         goto rescred;
1097     }
1098     if (path) {
1099         AFS_GUNLOCK();
1100 #ifdef  AFS_AIX41_ENV
1101         code =
1102             lookupname(path, USR, follow, NULL, &vp,
1103                        foreigncreds ? foreigncreds : credp);
1104 #else
1105 #ifdef AFS_LINUX22_ENV
1106         code = gop_lookupname_user(path, AFS_UIOUSER, follow, &dp);
1107         if (!code)
1108             vp = (struct vnode *)dp->d_inode;
1109 #else
1110         code = gop_lookupname_user(path, AFS_UIOUSER, follow, &vp);
1111 #if defined(AFS_FBSD80_ENV) /* XXX check on 7x */
1112         VN_HOLD(vp);
1113 #endif /* AFS_FBSD80_ENV */
1114 #endif /* AFS_LINUX22_ENV */
1115 #endif /* AFS_AIX41_ENV */
1116         AFS_GLOCK();
1117         if (code) {
1118             vp = NULL;
1119 #if defined(KERNEL_HAVE_UERROR)
1120             setuerror(code);
1121 #endif
1122             goto rescred;
1123         }
1124     } else
1125         vp = NULL;
1126
1127 #if defined(AFS_SUN510_ENV)
1128     if (vp && !IsAfsVnode(vp)) {
1129         struct vnode *realvp;
1130         if
1131 #ifdef AFS_SUN511_ENV
1132           (VOP_REALVP(vp, &realvp, NULL) == 0) 
1133 #else
1134           (VOP_REALVP(vp, &realvp) == 0) 
1135 #endif
1136 {
1137             struct vnode *oldvp = vp;
1138             
1139             VN_HOLD(realvp);
1140             vp = realvp;
1141             AFS_RELE(oldvp);
1142         }
1143     }
1144 #endif
1145     /* now make the call if we were passed no file, or were passed an AFS file */
1146     if (!vp || IsAfsVnode(vp)) {
1147 #if defined(AFS_SUN5_ENV)
1148         code = afs_HandlePioctl(vp, com, &data, follow, &credp);
1149 #elif defined(AFS_AIX41_ENV)
1150         {
1151             struct ucred *cred1, *cred2;
1152
1153             if (foreigncreds) {
1154                 cred1 = cred2 = foreigncreds;
1155             } else {
1156                 cred1 = cred2 = credp;
1157             }
1158             code = afs_HandlePioctl(vp, com, &data, follow, &cred1);
1159             if (cred1 != cred2) {
1160                 /* something changed the creds */
1161                 crset(cred1);
1162             }
1163         }
1164 #elif defined(AFS_HPUX101_ENV)
1165         {
1166             struct ucred *cred = p_cred(u.u_procp);
1167             code = afs_HandlePioctl(vp, com, &data, follow, &cred);
1168         }
1169 #elif defined(AFS_SGI_ENV)
1170         {
1171             struct cred *credp;
1172             credp = OSI_GET_CURRENT_CRED();
1173             code = afs_HandlePioctl(vp, com, &data, follow, &credp);
1174         }
1175 #elif defined(AFS_LINUX22_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
1176         code = afs_HandlePioctl(vp, com, &data, follow, &credp);
1177 #elif defined(UKERNEL)
1178         code = afs_HandlePioctl(vp, com, &data, follow,
1179                                 &(get_user_struct()->u_cred));
1180 #else
1181         code = afs_HandlePioctl(vp, com, &data, follow, &u.u_cred);
1182 #endif
1183     } else {
1184 #if defined(KERNEL_HAVE_UERROR)
1185         setuerror(EINVAL);
1186 #else
1187         code = EINVAL;          /* not in /afs */
1188 #endif
1189     }
1190
1191   rescred:
1192 #if defined(AFS_NEED_CLIENTCONTEXT)
1193     if (foreigncreds) {
1194 #ifdef  AFS_AIX41_ENV
1195         crset(tmpcred);         /* restore original credentials */
1196 #else
1197 #if     defined(AFS_HPUX101_ENV)
1198         set_p_cred(u.u_procp, tmpcred); /* restore original credentials */
1199 #elif   defined(AFS_SGI_ENV)
1200         OSI_SET_CURRENT_CRED(tmpcred);  /* restore original credentials */
1201 #elif   defined(AFS_SUN5_ENV) || defined(AFS_LINUX22_ENV)
1202         credp = tmpcred;                /* restore original credentials */
1203 #else
1204         osi_curcred() = tmpcred;        /* restore original credentials */
1205 #endif /* AFS_HPUX101_ENV */
1206         crfree(foreigncreds);
1207 #endif /* AIX41 */
1208     }
1209 #endif /* AFS_NEED_CLIENTCONTEXT */
1210     if (vp) {
1211 #ifdef AFS_LINUX22_ENV
1212         dput(dp);
1213 #else
1214 #if defined(AFS_FBSD80_ENV)
1215     if (VOP_ISLOCKED(vp))
1216         VOP_UNLOCK(vp, 0);
1217 #endif /* AFS_FBSD80_ENV */
1218         AFS_RELE(vp);           /* put vnode back */
1219 #endif
1220     }
1221     PIOCTL_FREE_CRED();
1222 #if defined(KERNEL_HAVE_UERROR)
1223     if (!getuerror())
1224         setuerror(code);
1225     return (getuerror());
1226 #else
1227     return (code);
1228 #endif
1229 }
1230
1231 #ifdef AFS_DARWIN100_ENV
1232 int
1233 afs_syscall_pioctl(char * path, unsigned int com, caddr_t cmarg,
1234                    int follow, afs_ucred_t *credp)
1235 {
1236     return afs_syscall64_pioctl(CAST_USER_ADDR_T(path), com,
1237                                 CAST_USER_ADDR_T((unsigned int)cmarg), follow,
1238                                 credp);
1239 }
1240 #endif
1241
1242 #define MAXPIOCTLTOKENLEN \
1243 (3*sizeof(afs_int32)+MAXKTCTICKETLEN+sizeof(struct ClearToken)+MAXKTCREALMLEN)
1244
1245 int
1246 afs_HandlePioctl(struct vnode *avp, afs_int32 acom,
1247                  register struct afs_ioctl *ablob, int afollow,
1248                  afs_ucred_t **acred)
1249 {
1250     struct vcache *avc;
1251     struct vrequest treq;
1252     register afs_int32 code;
1253     register afs_int32 function, device;
1254     struct afs_pdata input, output;
1255     struct afs_pdata copyInput, copyOutput;
1256     size_t outSize;
1257     pioctlFunction *pioctlSw;
1258     int pioctlSwSize;
1259     struct afs_fakestat_state fakestate;
1260
1261     memset(&input, 0, sizeof(input));
1262     memset(&output, 0, sizeof(output));
1263
1264     avc = avp ? VTOAFS(avp) : NULL;
1265     afs_Trace3(afs_iclSetp, CM_TRACE_PIOCTL, ICL_TYPE_INT32, acom & 0xff,
1266                ICL_TYPE_POINTER, avc, ICL_TYPE_INT32, afollow);
1267     AFS_STATCNT(HandlePioctl);
1268
1269     code = afs_InitReq(&treq, *acred);
1270     if (code)
1271         return code;
1272
1273     afs_InitFakeStat(&fakestate);
1274     if (avc) {
1275         code = afs_EvalFakeStat(&avc, &fakestate, &treq);
1276         if (code)
1277             goto out;
1278     }
1279     device = (acom & 0xff00) >> 8;
1280     switch (device) {
1281     case 'V':                   /* Original pioctls */
1282         pioctlSw = VpioctlSw;
1283         pioctlSwSize = sizeof(VpioctlSw);
1284         break;
1285     case 'C':                   /* Coordinated/common pioctls */
1286         pioctlSw = CpioctlSw;
1287         pioctlSwSize = sizeof(CpioctlSw);
1288         break;
1289     case 'O':                   /* Coordinated/common pioctls */
1290         pioctlSw = OpioctlSw;
1291         pioctlSwSize = sizeof(OpioctlSw);
1292         break;
1293     default:
1294         code = EINVAL;
1295         goto out;
1296     }
1297     function = acom & 0xff;
1298     if (function >= (pioctlSwSize / sizeof(char *))) {
1299         code = EINVAL;
1300         goto out;
1301     }
1302
1303     /* Do all range checking before continuing */
1304     if (ablob->in_size > MAXPIOCTLTOKENLEN ||
1305         ablob->in_size < 0 || ablob->out_size < 0) {
1306         code = EINVAL;
1307         goto out;
1308     }
1309
1310     code = afs_pd_alloc(&input, ablob->in_size);
1311     if (code)
1312         goto out;
1313
1314     if (ablob->in_size > 0) {
1315         AFS_COPYIN(ablob->in, input.ptr, ablob->in_size, code);
1316         input.ptr[input.remaining] = '\0';
1317     }
1318     if (code)
1319         goto out;
1320
1321     if (function == 8 && device == 'V') {       /* PGetTokens */
1322         code = afs_pd_alloc(&output, MAXPIOCTLTOKENLEN);
1323     } else {
1324         code = afs_pd_alloc(&output, AFS_LRALLOCSIZ);
1325     }
1326     if (code)
1327         goto out;
1328
1329     copyInput = input;
1330     copyOutput = output;
1331
1332     code =
1333         (*pioctlSw[function]) (avc, function, &treq, &copyInput,
1334                                &copyOutput, acred);
1335
1336     outSize = copyOutput.ptr - output.ptr;
1337
1338     if (code == 0 && ablob->out_size > 0) {
1339         if (outSize > ablob->out_size) {
1340             code = E2BIG;       /* data wont fit in user buffer */
1341         } else if (outSize) {
1342             AFS_COPYOUT(output.ptr, ablob->out, outSize, code);
1343         }
1344     }
1345
1346 out:
1347     afs_pd_free(&input);
1348     afs_pd_free(&output);
1349
1350     afs_PutFakeStat(&fakestate);
1351     return afs_CheckCode(code, &treq, 41);
1352 }
1353
1354 /*!
1355  * VIOCGETFID (22) - Get file ID quickly
1356  *
1357  * \ingroup pioctl
1358  *
1359  * \param[in] ain       not in use
1360  * \param[out] aout     fid of requested file
1361  *
1362  * \retval EINVAL       Error if some of the initial arguments aren't set
1363  *
1364  * \post get the file id of some file
1365  */
1366 DECL_PIOCTL(PGetFID)
1367 {
1368     AFS_STATCNT(PGetFID);
1369     if (!avc)
1370         return EINVAL;
1371     if (afs_pd_putBytes(aout, &avc->f.fid, sizeof(struct VenusFid)) != 0)
1372         return EINVAL;
1373     return 0;
1374 }
1375
1376 /*!
1377  * VIOCSETAL (1) - Set access control list
1378  *
1379  * \ingroup pioctl
1380  *
1381  * \param[in] ain       the ACL being set
1382  * \param[out] aout     the ACL being set returned
1383  *
1384  * \retval EINVAL       Error if some of the standard args aren't set
1385  *
1386  * \post Changed ACL, via direct writing to the wire
1387  */
1388 int dummy_PSetAcl(char *ain, char *aout)
1389 {
1390     return 0;
1391 }
1392
1393 DECL_PIOCTL(PSetAcl)
1394 {
1395     register afs_int32 code;
1396     struct afs_conn *tconn;
1397     struct AFSOpaque acl;
1398     struct AFSVolSync tsync;
1399     struct AFSFetchStatus OutStatus;
1400     XSTATS_DECLS;
1401
1402     AFS_STATCNT(PSetAcl);
1403     if (!avc)
1404         return EINVAL;
1405
1406     if (afs_pd_getStringPtr(ain, &acl.AFSOpaque_val) != 0)
1407         return EINVAL;
1408     acl.AFSOpaque_len = strlen(acl.AFSOpaque_val) + 1;
1409     if (acl.AFSOpaque_len > 1024)
1410         return EINVAL;
1411
1412     do {
1413         tconn = afs_Conn(&avc->f.fid, areq, SHARED_LOCK);
1414         if (tconn) {
1415             XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_STOREACL);
1416             RX_AFS_GUNLOCK();
1417             code =
1418                 RXAFS_StoreACL(tconn->id, (struct AFSFid *)&avc->f.fid.Fid,
1419                                &acl, &OutStatus, &tsync);
1420             RX_AFS_GLOCK();
1421             XSTATS_END_TIME;
1422         } else
1423             code = -1;
1424     } while (afs_Analyze
1425              (tconn, code, &avc->f.fid, areq, AFS_STATS_FS_RPCIDX_STOREACL,
1426               SHARED_LOCK, NULL));
1427
1428     /* now we've forgotten all of the access info */
1429     ObtainWriteLock(&afs_xcbhash, 455);
1430     avc->callback = 0;
1431     afs_DequeueCallback(avc);
1432     avc->f.states &= ~(CStatd | CUnique);
1433     ReleaseWriteLock(&afs_xcbhash);
1434     if (avc->f.fid.Fid.Vnode & 1 || (vType(avc) == VDIR))
1435         osi_dnlc_purgedp(avc);
1436
1437     /* SXW - Should we flush metadata here? */
1438     return code;
1439 }
1440
1441 int afs_defaultAsynchrony = 0;
1442
1443 /*!
1444  * VIOC_STOREBEHIND (47) Adjust store asynchrony
1445  *
1446  * \ingroup pioctl
1447  *
1448  * \param[in] ain       sbstruct (store behind structure) input
1449  * \param[out] aout     resulting sbstruct
1450  *
1451  * \retval EPERM
1452  *      Error if the user doesn't have super-user credentials
1453  * \retval EACCES
1454  *      Error if there isn't enough access to not check the mode bits
1455  *
1456  * \post
1457  *      Changes either the default asynchrony (the amount of data that
1458  *      can remain to be written when the cache manager returns control
1459  *      to the user), or the asyncrony for the specified file.
1460  */
1461 DECL_PIOCTL(PStoreBehind)
1462 {
1463     struct sbstruct sbr;
1464
1465     if (afs_pd_getBytes(ain, &sbr, sizeof(struct sbstruct)) != 0)
1466         return EINVAL;
1467
1468     if (sbr.sb_default != -1) {
1469         if (afs_osi_suser(*acred))
1470             afs_defaultAsynchrony = sbr.sb_default;
1471         else
1472             return EPERM;
1473     }
1474
1475     if (avc && (sbr.sb_thisfile != -1)) {
1476         if (afs_AccessOK
1477             (avc, PRSFS_WRITE | PRSFS_ADMINISTER, areq, DONT_CHECK_MODE_BITS))
1478             avc->asynchrony = sbr.sb_thisfile;
1479         else
1480             return EACCES;
1481     }
1482
1483     memset(&sbr, 0, sizeof(sbr));
1484     sbr.sb_default = afs_defaultAsynchrony;
1485     if (avc) {
1486         sbr.sb_thisfile = avc->asynchrony;
1487     }
1488
1489     return afs_pd_putBytes(aout, &sbr, sizeof(sbr));
1490 }
1491
1492 /*!
1493  * VIOC_GCPAGS (48) - Disable automatic PAG gc'ing
1494  *
1495  * \ingroup pioctl
1496  *
1497  * \param[in] ain       not in use
1498  * \param[out] aout     not in use
1499  *
1500  * \retval EACCES       Error if the user doesn't have super-user credentials
1501  *
1502  * \post set the gcpags to GCPAGS_USERDISABLED
1503  */
1504 DECL_PIOCTL(PGCPAGs)
1505 {
1506     if (!afs_osi_suser(*acred)) {
1507         return EACCES;
1508     }
1509     afs_gcpags = AFS_GCPAGS_USERDISABLED;
1510     return 0;
1511 }
1512
1513 /*!
1514  * VIOCGETAL (2) - Get access control list
1515  *
1516  * \ingroup pioctl
1517  *
1518  * \param[in] ain       not in use
1519  * \param[out] aout     the ACL
1520  *
1521  * \retval EINVAL       Error if some of the standard args aren't set
1522  * \retval ERANGE       Error if the vnode of the file id is too large
1523  * \retval -1           Error if getting the ACL failed
1524  *
1525  * \post Obtain the ACL, based on file ID
1526  *
1527  * \notes
1528  *      There is a hack to tell which type of ACL is being returned, checks
1529  *      the top 2-bytes of the input size to judge what type of ACL it is,
1530  *      only for dfs xlator ACLs
1531  */
1532 DECL_PIOCTL(PGetAcl)
1533 {
1534     struct AFSOpaque acl;
1535     struct AFSVolSync tsync;
1536     struct AFSFetchStatus OutStatus;
1537     afs_int32 code;
1538     struct afs_conn *tconn;
1539     struct AFSFid Fid;
1540     XSTATS_DECLS;
1541
1542     AFS_STATCNT(PGetAcl);
1543     if (!avc)
1544         return EINVAL;
1545     Fid.Volume = avc->f.fid.Fid.Volume;
1546     Fid.Vnode = avc->f.fid.Fid.Vnode;
1547     Fid.Unique = avc->f.fid.Fid.Unique;
1548     if (avc->f.states & CForeign) {
1549         /*
1550          * For a dfs xlator acl we have a special hack so that the
1551          * xlator will distinguish which type of acl will return. So
1552          * we currently use the top 2-bytes (vals 0-4) to tell which
1553          * type of acl to bring back. Horrible hack but this will
1554          * cause the least number of changes to code size and interfaces.
1555          */
1556         if (Fid.Vnode & 0xc0000000)
1557             return ERANGE;
1558         Fid.Vnode |= (ain->remaining << 30);
1559     }
1560     acl.AFSOpaque_val = aout->ptr;
1561     do {
1562         tconn = afs_Conn(&avc->f.fid, areq, SHARED_LOCK);
1563         if (tconn) {
1564             acl.AFSOpaque_val[0] = '\0';
1565             XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_FETCHACL);
1566             RX_AFS_GUNLOCK();
1567             code = RXAFS_FetchACL(tconn->id, &Fid, &acl, &OutStatus, &tsync);
1568             RX_AFS_GLOCK();
1569             XSTATS_END_TIME;
1570         } else
1571             code = -1;
1572     } while (afs_Analyze
1573              (tconn, code, &avc->f.fid, areq, AFS_STATS_FS_RPCIDX_FETCHACL,
1574               SHARED_LOCK, NULL));
1575
1576     if (code == 0) {
1577         if (acl.AFSOpaque_len == 0)
1578             afs_pd_skip(aout, 1); /* leave the NULL */
1579         else
1580             afs_pd_skip(aout, acl.AFSOpaque_len); /* Length of the ACL */
1581     }
1582     return code;
1583 }
1584
1585 /*!
1586  * PNoop returns success.  Used for functions which are not implemented
1587  * or are no longer in use.
1588  *
1589  * \ingroup pioctl
1590  *
1591  * \retval Always returns success
1592  *
1593  * \notes
1594  *      Functions involved in this:
1595  *      17 (VIOCENGROUP) -- used to be enable group;
1596  *      18 (VIOCDISGROUP) -- used to be disable group;
1597  *      2 (?) -- get/set cache-bypass size threshold
1598  */
1599 DECL_PIOCTL(PNoop)
1600 {
1601     AFS_STATCNT(PNoop);
1602     return 0;
1603 }
1604
1605 /*!
1606  * PBogus returns fail.  Used for functions which are not implemented or
1607  * are no longer in use.
1608  *
1609  * \ingroup pioctl
1610  *
1611  * \retval EINVAL       Always returns this value
1612  *
1613  * \notes
1614  *      Functions involved in this:
1615  *      0 (?);
1616  *      4 (?);
1617  *      6 (?);
1618  *      7 (VIOCSTAT);
1619  *      8 (?);
1620  *      13 (VIOCGETTIME) -- used to be quick check time;
1621  *      15 (VIOCPREFETCH) -- prefetch is now special-cased; see pioctl code!;
1622  *      16 (VIOCNOP) -- used to be testing code;
1623  *      19 (VIOCLISTGROUPS) -- used to be list group;
1624  *      23 (VIOCWAITFOREVER) -- used to be waitforever;
1625  *      57 (VIOC_FPRIOSTATUS) -- arla: set file prio;
1626  *      58 (VIOC_FHGET) -- arla: fallback getfh;
1627  *      59 (VIOC_FHOPEN) -- arla: fallback fhopen;
1628  *      60 (VIOC_XFSDEBUG) -- arla: controls xfsdebug;
1629  *      61 (VIOC_ARLADEBUG) -- arla: controls arla debug;
1630  *      62 (VIOC_AVIATOR) -- arla: debug interface;
1631  *      63 (VIOC_XFSDEBUG_PRINT) -- arla: print xfs status;
1632  *      64 (VIOC_CALCULATE_CACHE) -- arla: force cache check;
1633  *      65 (VIOC_BREAKCELLBACK) -- arla: break callback;
1634  *      68 (?) -- arla: fetch stats;
1635  */
1636 DECL_PIOCTL(PBogus)
1637 {
1638     AFS_STATCNT(PBogus);
1639     return EINVAL;
1640 }
1641
1642 /*!
1643  * VIOC_FILE_CELL_NAME (30) - Get cell in which file lives
1644  *
1645  * \ingroup pioctl
1646  *
1647  * \param[in] ain       not in use (avc used to pass in file id)
1648  * \param[out] aout     cell name
1649  *
1650  * \retval EINVAL       Error if some of the standard args aren't set
1651  * \retval ESRCH        Error if the file isn't part of a cell
1652  *
1653  * \post Get a cell based on a passed in file id
1654  */
1655 DECL_PIOCTL(PGetFileCell)
1656 {
1657     register struct cell *tcell;
1658
1659     AFS_STATCNT(PGetFileCell);
1660     if (!avc)
1661         return EINVAL;
1662     tcell = afs_GetCell(avc->f.fid.Cell, READ_LOCK);
1663     if (!tcell)
1664         return ESRCH;
1665
1666     if (afs_pd_putString(aout, tcell->cellName) != 0)
1667         return EINVAL;
1668
1669     afs_PutCell(tcell, READ_LOCK);
1670     return 0;
1671 }
1672
1673 /*!
1674  * VIOC_GET_WS_CELL (31) - Get cell in which workstation lives
1675  *
1676  * \ingroup pioctl
1677  *
1678  * \param[in] ain       not in use
1679  * \param[out] aout     cell name
1680  *
1681  * \retval EIO
1682  *      Error if the afs daemon hasn't started yet
1683  * \retval ESRCH
1684  *      Error if the machine isn't part of a cell, for whatever reason
1685  *
1686  * \post Get the primary cell that the machine is a part of.
1687  */
1688 DECL_PIOCTL(PGetWSCell)
1689 {
1690     struct cell *tcell = NULL;
1691
1692     AFS_STATCNT(PGetWSCell);
1693     if (!afs_resourceinit_flag) /* afs daemons haven't started yet */
1694         return EIO;             /* Inappropriate ioctl for device */
1695
1696     tcell = afs_GetPrimaryCell(READ_LOCK);
1697     if (!tcell)                 /* no primary cell? */
1698         return ESRCH;
1699
1700     if (afs_pd_putString(aout, tcell->cellName) != 0)
1701         return EINVAL;
1702     afs_PutCell(tcell, READ_LOCK);
1703     return 0;
1704 }
1705
1706 /*!
1707  * VIOC_GET_PRIMARY_CELL (33) - Get primary cell for caller
1708  *
1709  * \ingroup pioctl
1710  *
1711  * \param[in] ain       not in use (user id found via areq)
1712  * \param[out] aout     cell name
1713  *
1714  * \retval ESRCH
1715  *      Error if the user id doesn't have a primary cell specified
1716  *
1717  * \post Get the primary cell for a certain user, based on the user's uid
1718  */
1719 DECL_PIOCTL(PGetUserCell)
1720 {
1721     register afs_int32 i;
1722     register struct unixuser *tu;
1723     register struct cell *tcell;
1724
1725     AFS_STATCNT(PGetUserCell);
1726     if (!afs_resourceinit_flag) /* afs daemons haven't started yet */
1727         return EIO;             /* Inappropriate ioctl for device */
1728
1729     /* return the cell name of the primary cell for this user */
1730     i = UHash(areq->uid);
1731     ObtainWriteLock(&afs_xuser, 224);
1732     for (tu = afs_users[i]; tu; tu = tu->next) {
1733         if (tu->uid == areq->uid && (tu->states & UPrimary)) {
1734             tu->refCount++;
1735             ReleaseWriteLock(&afs_xuser);
1736             break;
1737         }
1738     }
1739     if (tu) {
1740         tcell = afs_GetCell(tu->cell, READ_LOCK);
1741         afs_PutUser(tu, WRITE_LOCK);
1742         if (!tcell)
1743             return ESRCH;
1744         else {
1745             if (afs_pd_putString(aout, tcell->cellName) != 0)
1746                 return E2BIG;
1747             afs_PutCell(tcell, READ_LOCK);
1748         }
1749     } else {
1750         ReleaseWriteLock(&afs_xuser);
1751     }
1752     return 0;
1753 }
1754
1755 /*!
1756  * VIOCSETTOK (3) - Set authentication tokens
1757  *
1758  * \ingroup pioctl
1759  *
1760  * \param[in] ain       the krb tickets from which to set the afs tokens
1761  * \param[out] aout     not in use
1762  *
1763  * \retval EINVAL
1764  *      Error if the ticket is either too long or too short
1765  * \retval EIO
1766  *      Error if the AFS initState is below 101
1767  * \retval ESRCH
1768  *      Error if the cell for which the Token is being set can't be found
1769  *
1770  * \post
1771  *      Set the Tokens for a specific cell name, unless there is none set,
1772  *      then default to primary
1773  *
1774  */
1775 DECL_PIOCTL(PSetTokens)
1776 {
1777     afs_int32 i;
1778     register struct unixuser *tu;
1779     struct ClearToken clear;
1780     register struct cell *tcell;
1781     char *stp;
1782     char *cellName;
1783     int stLen;
1784     struct vrequest treq;
1785     afs_int32 flag, set_parent_pag = 0;
1786
1787     AFS_STATCNT(PSetTokens);
1788     if (!afs_resourceinit_flag) {
1789         return EIO;
1790     }
1791
1792     if (afs_pd_getInt(ain, &stLen) != 0)
1793         return EINVAL;
1794
1795     stp = afs_pd_where(ain);    /* remember where the ticket is */
1796     if (stLen < 0 || stLen > MAXKTCTICKETLEN)
1797         return EINVAL;          /* malloc may fail */
1798     if (afs_pd_skip(ain, stLen) != 0)
1799         return EINVAL;
1800
1801     if (afs_pd_getInt(ain, &i) != 0)
1802         return EINVAL;
1803     if (i != sizeof(struct ClearToken))
1804         return EINVAL;
1805
1806     if (afs_pd_getBytes(ain, &clear, sizeof(struct ClearToken)) !=0)
1807         return EINVAL;
1808
1809     if (clear.AuthHandle == -1)
1810         clear.AuthHandle = 999; /* more rxvab compat stuff */
1811
1812     if (afs_pd_remaining(ain) != 0) {
1813         /* still stuff left?  we've got primary flag and cell name.
1814          * Set these */
1815
1816         if (afs_pd_getInt(ain, &flag) != 0)
1817             return EINVAL;
1818
1819         /* some versions of gcc appear to need != 0 in order to get this
1820          * right */
1821         if ((flag & 0x8000) != 0) {     /* XXX Use Constant XXX */
1822             flag &= ~0x8000;
1823             set_parent_pag = 1;
1824         }
1825
1826         if (afs_pd_getStringPtr(ain, &cellName) != 0)
1827             return EINVAL;
1828
1829         /* rest is cell name, look it up */
1830         tcell = afs_GetCellByName(cellName, READ_LOCK);
1831         if (!tcell)
1832             goto nocell;
1833     } else {
1834         /* default to primary cell, primary id */
1835         flag = 1;               /* primary id */
1836         tcell = afs_GetPrimaryCell(READ_LOCK);
1837         if (!tcell)
1838             goto nocell;
1839     }
1840     i = tcell->cellNum;
1841     afs_PutCell(tcell, READ_LOCK);
1842     if (set_parent_pag) {
1843         afs_uint32 pag;
1844 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
1845 # if defined(AFS_DARWIN_ENV)
1846         afs_proc_t *p = current_proc(); /* XXX */
1847         char procname[256];
1848         proc_selfname(procname, 256);
1849 # elif defined(AFS_FBSD_ENV)
1850         struct thread *p = curthread;
1851         char *procname = p->td_proc->p_comm;
1852 # else
1853         afs_proc_t *p = curproc;        /* XXX */
1854         char *procname = p->p_comm;
1855 # endif
1856         afs_warnuser("Process %d (%s) tried to change pags in PSetTokens\n",
1857                      MyPidxx2Pid(MyPidxx), procname);
1858         if (!setpag(p, acred, -1, &pag, 1)) {
1859 #else
1860         if (!setpag(acred, -1, &pag, 1)) {
1861 #endif
1862             afs_InitReq(&treq, *acred);
1863             areq = &treq;
1864         }
1865     }
1866     /* now we just set the tokens */
1867     tu = afs_GetUser(areq->uid, i, WRITE_LOCK); /* i has the cell # */
1868     tu->vid = clear.ViceId;
1869     if (tu->stp != NULL) {
1870         afs_osi_Free(tu->stp, tu->stLen);
1871     }
1872     tu->stp = (char *)afs_osi_Alloc(stLen);
1873     if (tu->stp == NULL) {
1874         return ENOMEM;
1875     }
1876     tu->stLen = stLen;
1877     memcpy(tu->stp, stp, stLen);
1878     tu->ct = clear;
1879 #ifndef AFS_NOSTATS
1880     afs_stats_cmfullperf.authent.TicketUpdates++;
1881     afs_ComputePAGStats();
1882 #endif /* AFS_NOSTATS */
1883     tu->states |= UHasTokens;
1884     tu->states &= ~UTokensBad;
1885     afs_SetPrimary(tu, flag);
1886     tu->tokenTime = osi_Time();
1887     afs_ResetUserConns(tu);
1888     afs_NotifyUser(tu, UTokensObtained);
1889     afs_PutUser(tu, WRITE_LOCK);
1890
1891     return 0;
1892
1893   nocell:
1894     {
1895         int t1;
1896         t1 = afs_initState;
1897         if (t1 < 101)
1898             return EIO;
1899         else
1900             return ESRCH;
1901     }
1902 }
1903
1904 /*!
1905  * VIOCGETVOLSTAT (4) - Get volume status
1906  *
1907  * \ingroup pioctl
1908  *
1909  * \param[in] ain       not in use
1910  * \param[out] aout     status of the volume
1911  *
1912  * \retval EINVAL       Error if some of the standard args aren't set
1913  *
1914  * \post
1915  *      The status of a volume (based on the FID of the volume), or an
1916  *      offline message /motd
1917  */
1918 DECL_PIOCTL(PGetVolumeStatus)
1919 {
1920     char volName[32];
1921     char *offLineMsg = afs_osi_Alloc(256);
1922     char *motd = afs_osi_Alloc(256);
1923     register struct afs_conn *tc;
1924     register afs_int32 code = 0;
1925     struct AFSFetchVolumeStatus volstat;
1926     char *Name;
1927     XSTATS_DECLS;
1928
1929     AFS_STATCNT(PGetVolumeStatus);
1930     if (!avc) {
1931         code = EINVAL;
1932         goto out;
1933     }
1934     Name = volName;
1935     do {
1936         tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK);
1937         if (tc) {
1938             XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_GETVOLUMESTATUS);
1939             RX_AFS_GUNLOCK();
1940             code =
1941                 RXAFS_GetVolumeStatus(tc->id, avc->f.fid.Fid.Volume, &volstat,
1942                                       &Name, &offLineMsg, &motd);
1943             RX_AFS_GLOCK();
1944             XSTATS_END_TIME;
1945         } else
1946             code = -1;
1947     } while (afs_Analyze
1948              (tc, code, &avc->f.fid, areq, AFS_STATS_FS_RPCIDX_GETVOLUMESTATUS,
1949               SHARED_LOCK, NULL));
1950
1951     if (code)
1952         goto out;
1953     /* Copy all this junk into msg->im_data, keeping track of the lengths. */
1954     if (afs_pd_putBytes(aout, &volstat, sizeof(VolumeStatus)) != 0)
1955         return E2BIG;
1956     if (afs_pd_putString(aout, volName) != 0)
1957         return E2BIG;
1958     if (afs_pd_putString(aout, offLineMsg) != 0)
1959         return E2BIG;
1960     if (afs_pd_putString(aout, motd) != 0)
1961         return E2BIG;
1962   out:
1963     afs_osi_Free(offLineMsg, 256);
1964     afs_osi_Free(motd, 256);
1965     return code;
1966 }
1967
1968 /*!
1969  * VIOCSETVOLSTAT (5) - Set volume status
1970  *
1971  * \ingroup pioctl
1972  *
1973  * \param[in] ain
1974  *      values to set the status at, offline message, message of the day,
1975  *      volume name, minimum quota, maximum quota
1976  * \param[out] aout
1977  *      status of a volume, offlines messages, minimum quota, maximumm quota
1978  *
1979  * \retval EINVAL
1980  *      Error if some of the standard args aren't set
1981  * \retval EROFS
1982  *      Error if the volume is read only, or a backup volume
1983  * \retval ENODEV
1984  *      Error if the volume can't be accessed
1985  * \retval E2BIG
1986  *      Error if the volume name, offline message, and motd are too big
1987  *
1988  * \post
1989  *      Set the status of a volume, including any offline messages,
1990  *      a minimum quota, and a maximum quota
1991  */
1992 DECL_PIOCTL(PSetVolumeStatus)
1993 {
1994     char *volName;
1995     char *offLineMsg;
1996     char *motd;
1997     register struct afs_conn *tc;
1998     register afs_int32 code = 0;
1999     struct AFSFetchVolumeStatus volstat;
2000     struct AFSStoreVolumeStatus storeStat;
2001     register struct volume *tvp;
2002     XSTATS_DECLS;
2003
2004     AFS_STATCNT(PSetVolumeStatus);
2005     if (!avc)
2006         return EINVAL;
2007
2008     tvp = afs_GetVolume(&avc->f.fid, areq, READ_LOCK);
2009     if (tvp) {
2010         if (tvp->states & (VRO | VBackup)) {
2011             afs_PutVolume(tvp, READ_LOCK);
2012             return EROFS;
2013         }
2014         afs_PutVolume(tvp, READ_LOCK);
2015     } else
2016         return ENODEV;
2017
2018
2019     if (afs_pd_getBytes(ain, &volstat, sizeof(AFSFetchVolumeStatus)) != 0)
2020         return EINVAL;
2021
2022     if (afs_pd_getStringPtr(ain, &volName) != 0)
2023         return EINVAL;
2024     if (strlen(volName) > 32)
2025         return E2BIG;
2026
2027     if (afs_pd_getStringPtr(ain, &offLineMsg) != 0)
2028         return EINVAL;
2029     if (strlen(offLineMsg) > 256)
2030         return E2BIG;
2031
2032     if (afs_pd_getStringPtr(ain, &motd) != 0)
2033         return EINVAL;
2034     if (strlen(motd) > 256)
2035         return E2BIG;
2036
2037     /* Done reading ... */
2038
2039     storeStat.Mask = 0;
2040     if (volstat.MinQuota != -1) {
2041         storeStat.MinQuota = volstat.MinQuota;
2042         storeStat.Mask |= AFS_SETMINQUOTA;
2043     }
2044     if (volstat.MaxQuota != -1) {
2045         storeStat.MaxQuota = volstat.MaxQuota;
2046         storeStat.Mask |= AFS_SETMAXQUOTA;
2047     }
2048     do {
2049         tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK);
2050         if (tc) {
2051             XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_SETVOLUMESTATUS);
2052             RX_AFS_GUNLOCK();
2053             code =
2054                 RXAFS_SetVolumeStatus(tc->id, avc->f.fid.Fid.Volume, &storeStat,
2055                                       volName, offLineMsg, motd);
2056             RX_AFS_GLOCK();
2057             XSTATS_END_TIME;
2058         } else
2059             code = -1;
2060     } while (afs_Analyze
2061              (tc, code, &avc->f.fid, areq, AFS_STATS_FS_RPCIDX_SETVOLUMESTATUS,
2062               SHARED_LOCK, NULL));
2063
2064     if (code)
2065         return code;
2066     /* we are sending parms back to make compat. with prev system.  should
2067      * change interface later to not ask for current status, just set new
2068      * status */
2069
2070     if (afs_pd_putBytes(aout, &volstat, sizeof(VolumeStatus)) != 0)
2071         return EINVAL;
2072     if (afs_pd_putString(aout, volName) != 0)
2073         return EINVAL;
2074     if (afs_pd_putString(aout, offLineMsg) != 0)
2075         return EINVAL;
2076     if (afs_pd_putString(aout, motd) != 0)
2077         return EINVAL;
2078
2079     return code;
2080 }
2081
2082 /*!
2083  * VIOCFLUSH (6) - Invalidate cache entry
2084  *
2085  * \ingroup pioctl
2086  *
2087  * \param[in] ain       not in use
2088  * \param[out] aout     not in use
2089  *
2090  * \retval EINVAL       Error if some of the standard args aren't set
2091  *
2092  * \post Flush any information the cache manager has on an entry
2093  */
2094 DECL_PIOCTL(PFlush)
2095 {
2096     AFS_STATCNT(PFlush);
2097     if (!avc)
2098         return EINVAL;
2099 #ifdef AFS_BOZONLOCK_ENV
2100     afs_BozonLock(&avc->pvnLock, avc);  /* Since afs_TryToSmush will do a pvn_vptrunc */
2101 #endif
2102     ObtainWriteLock(&avc->lock, 225);
2103     afs_ResetVCache(avc, *acred);
2104     ReleaseWriteLock(&avc->lock);
2105 #ifdef AFS_BOZONLOCK_ENV
2106     afs_BozonUnlock(&avc->pvnLock, avc);
2107 #endif
2108     return 0;
2109 }
2110
2111 /*!
2112  * VIOC_AFS_STAT_MT_PT (29) - Stat mount point
2113  *
2114  * \ingroup pioctl
2115  *
2116  * \param[in] ain
2117  *      the last component in a path, related to mountpoint that we're
2118  *      looking for information about
2119  * \param[out] aout
2120  *      volume, cell, link data
2121  *
2122  * \retval EINVAL       Error if some of the standard args aren't set
2123  * \retval ENOTDIR      Error if the 'mount point' argument isn't a directory
2124  * \retval EIO          Error if the link data can't be accessed
2125  *
2126  * \post Get the volume, and cell, as well as the link data for a mount point
2127  */
2128 DECL_PIOCTL(PNewStatMount)
2129 {
2130     register afs_int32 code;
2131     register struct vcache *tvc;
2132     register struct dcache *tdc;
2133     struct VenusFid tfid;
2134     char *bufp;
2135     char *name;
2136     struct sysname_info sysState;
2137     afs_size_t offset, len;
2138
2139     AFS_STATCNT(PNewStatMount);
2140     if (!avc)
2141         return EINVAL;
2142
2143     if (afs_pd_getStringPtr(ain, &name) != 0)
2144         return EINVAL;
2145
2146     code = afs_VerifyVCache(avc, areq);
2147     if (code)
2148         return code;
2149     if (vType(avc) != VDIR) {
2150         return ENOTDIR;
2151     }
2152     tdc = afs_GetDCache(avc, (afs_size_t) 0, areq, &offset, &len, 1);
2153     if (!tdc)
2154         return ENOENT;
2155     Check_AtSys(avc, name, &sysState, areq);
2156     ObtainReadLock(&tdc->lock);
2157     do {
2158         code = afs_dir_Lookup(tdc, sysState.name, &tfid.Fid);
2159     } while (code == ENOENT && Next_AtSys(avc, areq, &sysState));
2160     ReleaseReadLock(&tdc->lock);
2161     afs_PutDCache(tdc);         /* we're done with the data */
2162     bufp = sysState.name;
2163     if (code) {
2164         goto out;
2165     }
2166     tfid.Cell = avc->f.fid.Cell;
2167     tfid.Fid.Volume = avc->f.fid.Fid.Volume;
2168     if (!tfid.Fid.Unique && (avc->f.states & CForeign)) {
2169         tvc = afs_LookupVCache(&tfid, areq, NULL, avc, bufp);
2170     } else {
2171         tvc = afs_GetVCache(&tfid, areq, NULL, NULL);
2172     }
2173     if (!tvc) {
2174         code = ENOENT;
2175         goto out;
2176     }
2177     if (tvc->mvstat != 1) {
2178         afs_PutVCache(tvc);
2179         code = EINVAL;
2180         goto out;
2181     }
2182     ObtainWriteLock(&tvc->lock, 226);
2183     code = afs_HandleLink(tvc, areq);
2184     if (code == 0) {
2185         if (tvc->linkData) {
2186             if ((tvc->linkData[0] != '#') && (tvc->linkData[0] != '%'))
2187                 code = EINVAL;
2188             else {
2189                 /* we have the data */
2190                 if (afs_pd_putString(aout, tvc->linkData) != 0)
2191                     code = EINVAL;
2192             }
2193         } else
2194             code = EIO;
2195     }
2196     ReleaseWriteLock(&tvc->lock);
2197     afs_PutVCache(tvc);
2198   out:
2199     if (sysState.allocked)
2200         osi_FreeLargeSpace(bufp);
2201     return code;
2202 }
2203
2204 /*!
2205  * VIOCGETTOK (8) - Get authentication tokens
2206  *  
2207  * \ingroup pioctl
2208  *      
2209  * \param[in] ain       cellid to return tokens for
2210  * \param[out] aout     token
2211  * 
2212  * \retval EIO
2213  *      Error if the afs daemon hasn't started yet
2214  * \retval EDOM
2215  *      Error if the input parameter is out of the bounds of the available
2216  *      tokens
2217  * \retval ENOTCONN
2218  *      Error if there aren't tokens for this cell
2219  *  
2220  * \post
2221  *      If the input paramater exists, get the token that corresponds to
2222  *      the parameter value, if there is no token at this value, get the
2223  *      token for the first cell
2224  *
2225  * \notes "it's a weird interface (from comments in the code)"
2226  */
2227
2228 DECL_PIOCTL(PGetTokens)
2229 {
2230     register struct cell *tcell;
2231     register afs_int32 i;
2232     register struct unixuser *tu;
2233     afs_int32 iterator = 0;
2234     int newStyle;
2235     int code = E2BIG;
2236
2237     AFS_STATCNT(PGetTokens);
2238     if (!afs_resourceinit_flag) /* afs daemons haven't started yet */
2239         return EIO;             /* Inappropriate ioctl for device */
2240
2241     /* weird interface.  If input parameter is present, it is an integer and
2242      * we're supposed to return the parm'th tokens for this unix uid.
2243      * If not present, we just return tokens for cell 1.
2244      * If counter out of bounds, return EDOM.
2245      * If no tokens for the particular cell, return ENOTCONN.
2246      * Also, if this mysterious parm is present, we return, along with the
2247      * tokens, the primary cell indicator (an afs_int32 0) and the cell name
2248      * at the end, in that order.
2249      */
2250     newStyle = (afs_pd_remaining(ain) > 0);
2251     if (newStyle) {
2252         if (afs_pd_getInt(ain, &iterator) != 0)
2253             return EINVAL;
2254     }
2255     i = UHash(areq->uid);
2256     ObtainReadLock(&afs_xuser);
2257     for (tu = afs_users[i]; tu; tu = tu->next) {
2258         if (newStyle) {
2259             if (tu->uid == areq->uid && (tu->states & UHasTokens)) {
2260                 if (iterator-- == 0)
2261                     break;      /* are we done yet? */
2262             }
2263         } else {
2264             if (tu->uid == areq->uid && afs_IsPrimaryCellNum(tu->cell))
2265                 break;
2266         }
2267     }
2268     if (tu) {
2269         /*
2270          * No need to hold a read lock on each user entry
2271          */
2272         tu->refCount++;
2273     }
2274     ReleaseReadLock(&afs_xuser);
2275
2276     if (!tu) {
2277         return EDOM;
2278     }
2279     if (((tu->states & UHasTokens) == 0)
2280         || (tu->ct.EndTimestamp < osi_Time())) {
2281         tu->states |= (UTokensBad | UNeedsReset);
2282         afs_NotifyUser(tu, UTokensDropped);
2283         afs_PutUser(tu, READ_LOCK);
2284         return ENOTCONN;
2285     }
2286     iterator = tu->stLen;       /* for compat, we try to return 56 byte tix if they fit */
2287     if (iterator < 56)
2288         iterator = 56;          /* # of bytes we're returning */
2289
2290     if (afs_pd_putInt(aout, iterator) != 0)
2291         goto out;
2292     if (afs_pd_putBytes(aout, tu->stp, tu->stLen) != 0)
2293         goto out;
2294     if (tu->stLen < 56) {
2295         /* Tokens are always 56 bytes or larger */
2296         if (afs_pd_skip(aout, iterator - tu->stLen) != 0) {
2297             goto out;
2298         }
2299     }
2300
2301     if (afs_pd_putInt(aout, sizeof(struct ClearToken)) != 0)
2302         goto out;
2303     if (afs_pd_putBytes(aout, &tu->ct, sizeof(struct ClearToken)) != 0)
2304         goto out;
2305
2306     if (newStyle) {
2307         /* put out primary id and cell name, too */
2308         iterator = (tu->states & UPrimary ? 1 : 0);
2309         if (afs_pd_putInt(aout, iterator) != 0)
2310             goto out;
2311         tcell = afs_GetCell(tu->cell, READ_LOCK);
2312         if (tcell) {
2313             if (afs_pd_putString(aout, tcell->cellName) != 0)
2314                 goto out;
2315             afs_PutCell(tcell, READ_LOCK);
2316         } else
2317             if (afs_pd_putString(aout, "") != 0)
2318                 goto out;
2319     }
2320     /* Got here, all is good */
2321     code = 0;
2322 out:
2323     afs_PutUser(tu, READ_LOCK);
2324     return code;
2325 }
2326
2327 /*!
2328  * VIOCUNLOG (9) - Invalidate tokens
2329  *
2330  * \ingroup pioctl
2331  *
2332  * \param[in] ain       not in use
2333  * \param[out] aout     not in use
2334  *
2335  * \retval EIO  Error if the afs daemon hasn't been started yet
2336  *
2337  * \post remove tokens from a user, specified by the user id
2338  *
2339  * \notes sets the token's time to 0, which then causes it to be removed
2340  * \notes Unlog is the same as un-pag in OpenAFS
2341  */
2342 DECL_PIOCTL(PUnlog)
2343 {
2344     register afs_int32 i;
2345     register struct unixuser *tu;
2346
2347     AFS_STATCNT(PUnlog);
2348     if (!afs_resourceinit_flag) /* afs daemons haven't started yet */
2349         return EIO;             /* Inappropriate ioctl for device */
2350
2351     i = UHash(areq->uid);
2352     ObtainWriteLock(&afs_xuser, 227);
2353     for (tu = afs_users[i]; tu; tu = tu->next) {
2354         if (tu->uid == areq->uid) {
2355             tu->vid = UNDEFVID;
2356             tu->states &= ~UHasTokens;
2357             /* security is not having to say you're sorry */
2358             memset(&tu->ct, 0, sizeof(struct ClearToken));
2359             tu->refCount++;
2360             ReleaseWriteLock(&afs_xuser);
2361             afs_NotifyUser(tu, UTokensDropped);
2362             /* We have to drop the lock over the call to afs_ResetUserConns,
2363              * since it obtains the afs_xvcache lock.  We could also keep
2364              * the lock, and modify ResetUserConns to take parm saying we
2365              * obtained the lock already, but that is overkill.  By keeping
2366              * the "tu" pointer held over the released lock, we guarantee
2367              * that we won't lose our place, and that we'll pass over
2368              * every user conn that existed when we began this call.
2369              */
2370             afs_ResetUserConns(tu);
2371             tu->refCount--;
2372             ObtainWriteLock(&afs_xuser, 228);
2373 #ifdef UKERNEL
2374             /* set the expire times to 0, causes
2375              * afs_GCUserData to remove this entry
2376              */
2377             tu->ct.EndTimestamp = 0;
2378             tu->tokenTime = 0;
2379 #endif /* UKERNEL */
2380         }
2381     }
2382     ReleaseWriteLock(&afs_xuser);
2383     return 0;
2384 }
2385
2386 /*!
2387  * VIOC_AFS_MARINER_HOST (32) - Get/set mariner (cache manager monitor) host
2388  *
2389  * \ingroup pioctl
2390  *
2391  * \param[in] ain       host address to be set
2392  * \param[out] aout     old host address
2393  *
2394  * \post
2395  *      depending on whether or not a variable is set, either get the host
2396  *      for the cache manager monitor, or set the old address and give it
2397  *      a new address
2398  *
2399  * \notes Errors turn off mariner
2400  */
2401 DECL_PIOCTL(PMariner)
2402 {
2403     afs_int32 newHostAddr;
2404     afs_int32 oldHostAddr;
2405
2406     AFS_STATCNT(PMariner);
2407     if (afs_mariner)
2408         memcpy((char *)&oldHostAddr, (char *)&afs_marinerHost,
2409                sizeof(afs_int32));
2410     else
2411         oldHostAddr = 0xffffffff;       /* disabled */
2412
2413     if (afs_pd_getInt(ain, &newHostAddr) != 0)
2414         return EINVAL;
2415
2416     if (newHostAddr == 0xffffffff) {
2417         /* disable mariner operations */
2418         afs_mariner = 0;
2419     } else if (newHostAddr) {
2420         afs_mariner = 1;
2421         afs_marinerHost = newHostAddr;
2422     }
2423
2424     if (afs_pd_putInt(aout, oldHostAddr) != 0)
2425         return E2BIG;
2426
2427     return 0;
2428 }
2429
2430 /*!
2431  * VIOCCKSERV (10) - Check that servers are up
2432  *
2433  * \ingroup pioctl
2434  *
2435  * \param[in] ain       name of the cell
2436  * \param[out] aout     current down server list
2437  *
2438  * \retval EIO          Error if the afs daemon hasn't started yet
2439  * \retval EACCES       Error if the user doesn't have super-user credentials
2440  * \retval ENOENT       Error if we are unable to obtain the cell
2441  *
2442  * \post
2443  *      Either a fast check (where it doesn't contact servers) or a
2444  *      local check (checks local cell only)
2445  */
2446 DECL_PIOCTL(PCheckServers)
2447 {
2448     register int i;
2449     register struct server *ts;
2450     afs_int32 temp;
2451     char *cellName = NULL;
2452     struct cell *cellp;
2453     struct chservinfo *pcheck;
2454
2455     AFS_STATCNT(PCheckServers);
2456
2457     if (!afs_resourceinit_flag) /* afs daemons haven't started yet */
2458         return EIO;             /* Inappropriate ioctl for device */
2459
2460     /* This is tricky, because we need to peak at the datastream to see
2461      * what we're getting. For now, let's cheat. */
2462
2463     /* ain contains either an int32 or a string */
2464     if (ain->remaining == 0)
2465         return EINVAL;
2466
2467     if (*(afs_int32 *)ain->ptr == 0x12345678) { /* For afs3.3 version */
2468         pcheck = afs_pd_inline(ain, sizeof(*pcheck));
2469         if (pcheck == NULL)
2470             return EINVAL;
2471
2472         if (pcheck->tinterval >= 0) {
2473             if (afs_pd_putInt(aout, afs_probe_interval) != 0)
2474                 return E2BIG;
2475             if (pcheck->tinterval > 0) {
2476                 if (!afs_osi_suser(*acred))
2477                     return EACCES;
2478                 afs_probe_interval = pcheck->tinterval;
2479             }
2480             return 0;
2481         }
2482         temp = pcheck->tflags;
2483         if (pcheck->tsize)
2484             cellName = pcheck->tbuffer;
2485     } else {                    /* For pre afs3.3 versions */
2486         if (afs_pd_getInt(ain, &temp) != 0)
2487             return EINVAL;
2488         if (afs_pd_remaining(ain) > 0) {
2489             if (afs_pd_getStringPtr(ain, &cellName) != 0)
2490                 return EINVAL;
2491         }
2492     }
2493
2494     /*
2495      * 1: fast check, don't contact servers.
2496      * 2: local cell only.
2497      */
2498     if (cellName) {
2499         /* have cell name, too */
2500         cellp = afs_GetCellByName(cellName, READ_LOCK);
2501         if (!cellp)
2502             return ENOENT;
2503     } else
2504         cellp = NULL;
2505     if (!cellp && (temp & 2)) {
2506         /* use local cell */
2507         cellp = afs_GetPrimaryCell(READ_LOCK);
2508     }
2509     if (!(temp & 1)) {          /* if not fast, call server checker routine */
2510         afs_CheckServers(1, cellp);     /* check down servers */
2511         afs_CheckServers(0, cellp);     /* check up servers */
2512     }
2513     /* now return the current down server list */
2514     ObtainReadLock(&afs_xserver);
2515     for (i = 0; i < NSERVERS; i++) {
2516         for (ts = afs_servers[i]; ts; ts = ts->next) {
2517             if (cellp && ts->cell != cellp)
2518                 continue;       /* cell spec'd and wrong */
2519             if ((ts->flags & SRVR_ISDOWN)
2520                 && ts->addr->sa_portal != ts->cell->vlport) {
2521                 afs_pd_putInt(aout, ts->addr->sa_ip);
2522             }
2523         }
2524     }
2525     ReleaseReadLock(&afs_xserver);
2526     if (cellp)
2527         afs_PutCell(cellp, READ_LOCK);
2528     return 0;
2529 }
2530
2531 /*!
2532  * VIOCCKBACK (11) - Check backup volume mappings
2533  *
2534  * \ingroup pioctl
2535  *
2536  * \param[in] ain       not in use
2537  * \param[out] aout     not in use
2538  *
2539  * \retval EIO          Error if the afs daemon hasn't started yet
2540  *
2541  * \post
2542  *      Check the root volume, and then check the names if the volume
2543  *      check variable is set to force, has expired, is busy, or if
2544  *      the mount points variable is set
2545  */
2546 DECL_PIOCTL(PCheckVolNames)
2547 {
2548     AFS_STATCNT(PCheckVolNames);
2549     if (!afs_resourceinit_flag) /* afs daemons haven't started yet */
2550         return EIO;             /* Inappropriate ioctl for device */
2551
2552     afs_CheckRootVolume();
2553     afs_CheckVolumeNames(AFS_VOLCHECK_FORCE | AFS_VOLCHECK_EXPIRED |
2554                          AFS_VOLCHECK_BUSY | AFS_VOLCHECK_MTPTS);
2555     return 0;
2556 }
2557
2558 /*!
2559  * VIOCCKCONN (12) - Check connections for a user
2560  *
2561  * \ingroup pioctl
2562  *
2563  * \param[in] ain       not in use
2564  * \param[out] aout     not in use
2565  *
2566  * \retval EACCESS
2567  *      Error if no user is specififed, the user has no tokens set,
2568  *      or if the user's tokens are bad
2569  *
2570  * \post
2571  *      check to see if a user has the correct authentication.
2572  *      If so, allow access.
2573  *
2574  * \notes Check the connections to all the servers specified
2575  */
2576 DECL_PIOCTL(PCheckAuth)
2577 {
2578     int i;
2579     struct srvAddr *sa;
2580     struct afs_conn *tc;
2581     struct unixuser *tu;
2582     afs_int32 retValue;
2583
2584     AFS_STATCNT(PCheckAuth);
2585     if (!afs_resourceinit_flag) /* afs daemons haven't started yet */
2586         return EIO;             /* Inappropriate ioctl for device */
2587
2588     retValue = 0;
2589     tu = afs_GetUser(areq->uid, 1, READ_LOCK);  /* check local cell authentication */
2590     if (!tu)
2591         retValue = EACCES;
2592     else {
2593         /* we have a user */
2594         ObtainReadLock(&afs_xsrvAddr);
2595         ObtainReadLock(&afs_xconn);
2596
2597         /* any tokens set? */
2598         if ((tu->states & UHasTokens) == 0)
2599             retValue = EACCES;
2600         /* all connections in cell 1 working? */
2601         for (i = 0; i < NSERVERS; i++) {
2602             for (sa = afs_srvAddrs[i]; sa; sa = sa->next_bkt) {
2603                 for (tc = sa->conns; tc; tc = tc->next) {
2604                     if (tc->user == tu && (tu->states & UTokensBad))
2605                         retValue = EACCES;
2606                 }
2607             }
2608         }
2609         ReleaseReadLock(&afs_xsrvAddr);
2610         ReleaseReadLock(&afs_xconn);
2611         afs_PutUser(tu, READ_LOCK);
2612     }
2613     if (afs_pd_putInt(aout, retValue) != 0)
2614         return E2BIG;
2615     return 0;
2616 }
2617
2618 static int
2619 Prefetch(uparmtype apath, struct afs_ioctl *adata, int afollow,
2620          afs_ucred_t *acred)
2621 {
2622     register char *tp;
2623     register afs_int32 code;
2624 #if defined(AFS_SGI61_ENV) || defined(AFS_SUN57_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
2625     size_t bufferSize;
2626 #else
2627     u_int bufferSize;
2628 #endif
2629
2630     AFS_STATCNT(Prefetch);
2631     if (!apath)
2632         return EINVAL;
2633     tp = osi_AllocLargeSpace(1024);
2634     AFS_COPYINSTR(apath, tp, 1024, &bufferSize, code);
2635     if (code) {
2636         osi_FreeLargeSpace(tp);
2637         return code;
2638     }
2639     if (afs_BBusy()) {          /* do this as late as possible */
2640         osi_FreeLargeSpace(tp);
2641         return EWOULDBLOCK;     /* pretty close */
2642     }
2643     afs_BQueue(BOP_PATH, (struct vcache *)0, 0, 0, acred, (afs_size_t) 0,
2644                (afs_size_t) 0, tp, (void *)0, (void *)0);
2645     return 0;
2646 }
2647
2648 /*!
2649  * VIOCWHEREIS (14) - Find out where a volume is located
2650  *
2651  * \ingroup pioctl
2652  *
2653  * \param[in] ain       not in use
2654  * \param[out] aout     volume location
2655  *
2656  * \retval EINVAL       Error if some of the default arguments don't exist
2657  * \retval ENODEV       Error if there is no such volume
2658  *
2659  * \post fine a volume, based on a volume file id
2660  *
2661  * \notes check each of the servers specified
2662  */
2663 DECL_PIOCTL(PFindVolume)
2664 {
2665     register struct volume *tvp;
2666     register struct server *ts;
2667     register afs_int32 i;
2668     int code = 0;
2669
2670     AFS_STATCNT(PFindVolume);
2671     if (!avc)
2672         return EINVAL;
2673     tvp = afs_GetVolume(&avc->f.fid, areq, READ_LOCK);
2674     if (!tvp)
2675         return ENODEV;
2676
2677     for (i = 0; i < AFS_MAXHOSTS; i++) {
2678         ts = tvp->serverHost[i];
2679         if (!ts)
2680             break;
2681         if (afs_pd_putInt(aout, ts->addr->sa_ip) != 0) {
2682             code = E2BIG;
2683             goto out;
2684         }
2685     }
2686     if (i < AFS_MAXHOSTS) {
2687         /* still room for terminating NULL, add it on */
2688         if (afs_pd_putInt(aout, 0) != 0) {
2689             code = E2BIG;
2690             goto out;
2691         }
2692     }
2693 out:
2694     afs_PutVolume(tvp, READ_LOCK);
2695     return code;
2696 }
2697
2698 /*!
2699  * VIOCACCESS (20) - Access using PRS_FS bits
2700  *
2701  * \ingroup pioctl
2702  *
2703  * \param[in] ain       PRS_FS bits
2704  * \param[out] aout     not in use
2705  *
2706  * \retval EINVAL       Error if some of the initial arguments aren't set
2707  * \retval EACCES       Error if access is denied
2708  *
2709  * \post check to make sure access is allowed
2710  */
2711 DECL_PIOCTL(PViceAccess)
2712 {
2713     register afs_int32 code;
2714     afs_int32 temp;
2715
2716     AFS_STATCNT(PViceAccess);
2717     if (!avc)
2718         return EINVAL;
2719
2720     code = afs_VerifyVCache(avc, areq);
2721     if (code)
2722         return code;
2723
2724     if (afs_pd_getInt(ain, &temp) != 0)
2725         return EINVAL;
2726
2727     code = afs_AccessOK(avc, temp, areq, CHECK_MODE_BITS);
2728     if (code)
2729         return 0;
2730     else
2731         return EACCES;
2732 }
2733
2734 /*!
2735  * VIOC_GETPAG (13) - Get PAG value
2736  *
2737  * \ingroup pioctl
2738  *
2739  * \param[in] ain       not in use
2740  * \param[out] aout     PAG value or NOPAG
2741  *
2742  * \post get PAG value for the caller's cred
2743  */
2744 DECL_PIOCTL(PGetPAG)
2745 {
2746     afs_int32 pag;
2747
2748     pag = PagInCred(*acred);
2749
2750     return afs_pd_putInt(aout, pag);
2751 }
2752
2753 DECL_PIOCTL(PPrecache)
2754 {
2755     afs_int32 newValue;
2756
2757     /*AFS_STATCNT(PPrecache);*/
2758     if (!afs_osi_suser(*acred))
2759         return EACCES;
2760
2761     if (afs_pd_getInt(ain, &newValue) != 0)
2762         return EINVAL;
2763
2764     afs_preCache = newValue*1024;
2765     return 0;
2766 }
2767
2768 /*!
2769  * VIOCSETCACHESIZE (24) - Set venus cache size in 1000 units
2770  *
2771  * \ingroup pioctl
2772  *
2773  * \param[in] ain       the size the venus cache should be set to
2774  * \param[out] aout     not in use
2775  *
2776  * \retval EACCES       Error if the user doesn't have super-user credentials
2777  * \retval EROFS        Error if the cache is set to be in memory
2778  *
2779  * \post
2780  *      Set the cache size based on user input.  If no size is given,
2781  *      set it to the default OpenAFS cache size.
2782  *
2783  * \notes
2784  *      recompute the general cache parameters for every single block allocated
2785  */
2786 DECL_PIOCTL(PSetCacheSize)
2787 {
2788     afs_int32 newValue;
2789     int waitcnt = 0;
2790
2791     AFS_STATCNT(PSetCacheSize);
2792
2793     if (!afs_osi_suser(*acred))
2794         return EACCES;
2795     /* too many things are setup initially in mem cache version */
2796     if (cacheDiskType == AFS_FCACHE_TYPE_MEM)
2797         return EROFS;
2798     if (afs_pd_getInt(ain, &newValue) != 0)
2799         return EINVAL;
2800     if (newValue == 0)
2801         afs_cacheBlocks = afs_stats_cmperf.cacheBlocksOrig;
2802     else {
2803         if (newValue < afs_min_cache)
2804             afs_cacheBlocks = afs_min_cache;
2805         else
2806             afs_cacheBlocks = newValue;
2807     }
2808     afs_stats_cmperf.cacheBlocksTotal = afs_cacheBlocks;
2809     afs_ComputeCacheParms();    /* recompute basic cache parameters */
2810     afs_MaybeWakeupTruncateDaemon();
2811     while (waitcnt++ < 100 && afs_cacheBlocks < afs_blocksUsed) {
2812         afs_osi_Wait(1000, 0, 0);
2813         afs_MaybeWakeupTruncateDaemon();
2814     }
2815     return 0;
2816 }
2817
2818 #define MAXGCSTATS      16
2819 /*!
2820  * VIOCGETCACHEPARMS (40) - Get cache stats
2821  *
2822  * \ingroup pioctl
2823  *
2824  * \param[in] ain       afs index flags
2825  * \param[out] aout     cache blocks, blocks used, blocks files (in an array)
2826  *
2827  * \post Get the cache blocks, and how many of the cache blocks there are
2828  */
2829 DECL_PIOCTL(PGetCacheSize)
2830 {
2831     afs_int32 results[MAXGCSTATS];
2832     afs_int32 flags;
2833     register struct dcache * tdc;
2834     int i, size;
2835     
2836     AFS_STATCNT(PGetCacheSize);
2837
2838     if (afs_pd_remaining(ain) == sizeof(afs_int32)) {
2839         afs_pd_getInt(ain, &flags); /* can't error, we just checked size */
2840     } else if (afs_pd_remaining(ain) == 0) {
2841         flags = 0;
2842     } else {
2843         return EINVAL;
2844     }
2845     
2846     memset(results, 0, sizeof(results));
2847     results[0] = afs_cacheBlocks;
2848     results[1] = afs_blocksUsed;
2849     results[2] = afs_cacheFiles;
2850     
2851     if (1 == flags){
2852         for (i = 0; i < afs_cacheFiles; i++) {
2853             if (afs_indexFlags[i] & IFFree) results[3]++;
2854         }
2855     } else if (2 == flags){
2856         for (i = 0; i < afs_cacheFiles; i++) {
2857             if (afs_indexFlags[i] & IFFree) results[3]++;
2858             if (afs_indexFlags[i] & IFEverUsed) results[4]++;
2859             if (afs_indexFlags[i] & IFDataMod) results[5]++;
2860             if (afs_indexFlags[i] & IFDirtyPages) results[6]++;
2861             if (afs_indexFlags[i] & IFAnyPages) results[7]++;
2862             if (afs_indexFlags[i] & IFDiscarded) results[8]++;
2863
2864             tdc = afs_indexTable[i];
2865             if (tdc){
2866                 results[9]++;
2867                 size = tdc->validPos;
2868                 if ( 0 < size && size < (1<<12) ) results[10]++;
2869                 else if (size < (1<<14) ) results[11]++;
2870                 else if (size < (1<<16) ) results[12]++;
2871                 else if (size < (1<<18) ) results[13]++;
2872                 else if (size < (1<<20) ) results[14]++;
2873                 else if (size >= (1<<20) ) results[15]++;
2874             }
2875         }
2876     }
2877     return afs_pd_putBytes(aout, results, sizeof(results));
2878 }
2879
2880 /*!
2881  * VIOCFLUSHCB (25) - Flush callback only
2882  *
2883  * \ingroup pioctl
2884  *
2885  * \param[in] ain       not in use
2886  * \param[out] aout     not in use
2887  *
2888  * \retval EINVAL       Error if some of the standard args aren't set
2889  * \retval 0            0 returned if the volume is set to read-only
2890  *
2891  * \post
2892  *      Flushes callbacks, by setting the length of callbacks to one,
2893  *      setting the next callback to be sent to the CB_DROPPED value,
2894  *      and then dequeues everything else.
2895  */
2896 DECL_PIOCTL(PRemoveCallBack)
2897 {
2898     register struct afs_conn *tc;
2899     register afs_int32 code = 0;
2900     struct AFSCallBack CallBacks_Array[1];
2901     struct AFSCBFids theFids;
2902     struct AFSCBs theCBs;
2903     XSTATS_DECLS;
2904
2905     AFS_STATCNT(PRemoveCallBack);
2906     if (!avc)
2907         return EINVAL;
2908     if (avc->f.states & CRO)
2909         return 0;               /* read-only-ness can't change */
2910     ObtainWriteLock(&avc->lock, 229);
2911     theFids.AFSCBFids_len = 1;
2912     theCBs.AFSCBs_len = 1;
2913     theFids.AFSCBFids_val = (struct AFSFid *)&avc->f.fid.Fid;
2914     theCBs.AFSCBs_val = CallBacks_Array;
2915     CallBacks_Array[0].CallBackType = CB_DROPPED;
2916     if (avc->callback) {
2917         do {
2918             tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK);
2919             if (tc) {
2920                 XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_GIVEUPCALLBACKS);
2921                 RX_AFS_GUNLOCK();
2922                 code = RXAFS_GiveUpCallBacks(tc->id, &theFids, &theCBs);
2923                 RX_AFS_GLOCK();
2924                 XSTATS_END_TIME;
2925             }
2926             /* don't set code on failure since we wouldn't use it */
2927         } while (afs_Analyze
2928                  (tc, code, &avc->f.fid, areq,
2929                   AFS_STATS_FS_RPCIDX_GIVEUPCALLBACKS, SHARED_LOCK, NULL));
2930
2931         ObtainWriteLock(&afs_xcbhash, 457);
2932         afs_DequeueCallback(avc);
2933         avc->callback = 0;
2934         avc->f.states &= ~(CStatd | CUnique);
2935         ReleaseWriteLock(&afs_xcbhash);
2936         if (avc->f.fid.Fid.Vnode & 1 || (vType(avc) == VDIR))
2937             osi_dnlc_purgedp(avc);
2938     }
2939     ReleaseWriteLock(&avc->lock);
2940     return 0;
2941 }
2942
2943 /*!
2944  * VIOCNEWCELL (26) - Configure new cell
2945  *
2946  * \ingroup pioctl
2947  *
2948  * \param[in] ain
2949  *      the name of the cell, the hosts that will be a part of the cell,
2950  *      whether or not it's linked with another cell, the other cell it's
2951  *      linked with, the file server port, and the volume server port
2952  * \param[out] aout
2953  *      not in use
2954  *
2955  * \retval EIO          Error if the afs daemon hasn't started yet
2956  * \retval EACCES       Error if the user doesn't have super-user cedentials
2957  * \retval EINVAL       Error if some 'magic' var doesn't have a certain bit set
2958  *
2959  * \post creates a new cell
2960  */
2961 DECL_PIOCTL(PNewCell)
2962 {
2963     afs_int32 cellHosts[AFS_MAXCELLHOSTS], magic = 0;
2964     char *newcell = NULL;
2965     char *linkedcell = NULL;
2966     afs_int32 code, ls;
2967     afs_int32 linkedstate = 0;
2968     afs_int32 fsport = 0, vlport = 0;
2969     int skip;
2970
2971     AFS_STATCNT(PNewCell);
2972     if (!afs_resourceinit_flag) /* afs daemons haven't started yet */
2973         return EIO;             /* Inappropriate ioctl for device */
2974
2975     if (!afs_osi_suser(*acred))
2976         return EACCES;
2977
2978     if (afs_pd_getInt(ain, &magic) != 0)
2979         return EINVAL;
2980     if (magic != 0x12345678)
2981         return EINVAL;
2982
2983     /* A 3.4 fs newcell command will pass an array of AFS_MAXCELLHOSTS
2984      * server addresses while the 3.5 fs newcell command passes
2985      * AFS_MAXHOSTS. To figure out which is which, check if the cellname
2986      * is good.
2987      *
2988      * This whole logic is bogus, because it relies on the newer command
2989      * sending its 12th address as 0.
2990      */
2991     if ((afs_pd_remaining(ain) < AFS_MAXCELLHOSTS +3) * sizeof(afs_int32))
2992         return EINVAL;
2993
2994     newcell = afs_pd_where(ain) + (AFS_MAXCELLHOSTS + 3) * sizeof(afs_int32);
2995     if (newcell[0] != '\0') {
2996         skip = 0;
2997     } else {
2998         skip = AFS_MAXHOSTS - AFS_MAXCELLHOSTS;
2999     }
3000
3001     /* AFS_MAXCELLHOSTS (=8) is less than AFS_MAXHOSTS (=13) */
3002     if (afs_pd_getBytes(ain, &cellHosts,
3003                         AFS_MAXCELLHOSTS * sizeof(afs_int32)) != 0)
3004         return EINVAL;
3005     if (afs_pd_skip(ain, skip * sizeof(afs_int32)) !=0)
3006         return EINVAL;
3007
3008     if (afs_pd_getInt(ain, &fsport) != 0)
3009         return EINVAL;
3010     if (fsport < 1024)
3011         fsport = 0;             /* Privileged ports not allowed */
3012
3013     if (afs_pd_getInt(ain, &vlport) != 0)
3014         return EINVAL;
3015     if (vlport < 1024)
3016         vlport = 0;             /* Privileged ports not allowed */
3017
3018     if (afs_pd_getInt(ain, &ls) != 0)
3019         return EINVAL;
3020
3021     if (afs_pd_getStringPtr(ain, &newcell) != 0)
3022         return EINVAL;
3023
3024     if (ls & 1) {
3025         if (afs_pd_getStringPtr(ain, &linkedcell) != 0)
3026             return EINVAL;
3027         linkedstate |= CLinkedCell;
3028     }
3029
3030     linkedstate |= CNoSUID;     /* setuid is disabled by default for fs newcell */
3031     code =
3032         afs_NewCell(newcell, cellHosts, linkedstate, linkedcell, fsport,
3033                     vlport, (int)0);
3034     return code;
3035 }
3036
3037 DECL_PIOCTL(PNewAlias)
3038 {
3039     /* create a new cell alias */
3040     char *realName, *aliasName;
3041
3042     if (!afs_resourceinit_flag) /* afs daemons haven't started yet */
3043         return EIO;             /* Inappropriate ioctl for device */
3044
3045     if (!afs_osi_suser(*acred))
3046         return EACCES;
3047
3048     if (afs_pd_getStringPtr(ain, &aliasName) != 0)
3049         return EINVAL;
3050     if (afs_pd_getStringPtr(ain, &realName) != 0)
3051         return EINVAL;
3052
3053     return afs_NewCellAlias(aliasName, realName);
3054 }
3055
3056 /*!
3057  * VIOCGETCELL (27) - Get cell info
3058  *
3059  * \ingroup pioctl
3060  *
3061  * \param[in] ain       The cell index of a specific cell
3062  * \param[out] aout     list of servers in the cell
3063  *
3064  * \retval EIO          Error if the afs daemon hasn't started yet
3065  * \retval EDOM         Error if there is no cell asked about
3066  *
3067  * \post Lists the cell's server names and and addresses
3068  */
3069 DECL_PIOCTL(PListCells)
3070 {
3071     afs_int32 whichCell;
3072     register struct cell *tcell = 0;
3073     register afs_int32 i;
3074     int code;
3075
3076     AFS_STATCNT(PListCells);
3077     if (!afs_resourceinit_flag) /* afs daemons haven't started yet */
3078         return EIO;             /* Inappropriate ioctl for device */
3079
3080     if (afs_pd_getInt(ain, &whichCell) != 0)
3081         return EINVAL;
3082
3083     tcell = afs_GetCellByIndex(whichCell, READ_LOCK);
3084     if (!tcell)
3085         return EDOM;
3086
3087     code = E2BIG;
3088
3089     for (i = 0; i < AFS_MAXCELLHOSTS; i++) {
3090         if (tcell->cellHosts[i] == 0)
3091             break;
3092         if (afs_pd_putInt(aout, tcell->cellHosts[i]->addr->sa_ip) != 0)
3093             goto out;
3094     }
3095     for (;i < AFS_MAXCELLHOSTS; i++) {
3096         if (afs_pd_putInt(aout, 0) != 0)
3097             goto out;
3098     }
3099     if (afs_pd_putString(aout, tcell->cellName) != 0)
3100         goto out;
3101     code = 0;
3102
3103 out:
3104     afs_PutCell(tcell, READ_LOCK);
3105     return code;
3106 }
3107
3108 DECL_PIOCTL(PListAliases)
3109 {
3110     afs_int32 whichAlias;
3111     register struct cell_alias *tcalias = 0;
3112     int code;
3113
3114     if (!afs_resourceinit_flag) /* afs daemons haven't started yet */
3115         return EIO;             /* Inappropriate ioctl for device */
3116
3117     if (afs_pd_getInt(ain, &whichAlias) != 0)
3118         return EINVAL;
3119
3120     tcalias = afs_GetCellAlias(whichAlias);
3121     if (tcalias == NULL)
3122         return EDOM;
3123
3124     code = E2BIG;
3125     if (afs_pd_putString(aout, tcalias->alias) != 0)
3126         goto out;
3127     if (afs_pd_putString(aout, tcalias->cell) != 0)
3128         goto out;
3129
3130     code = 0;
3131 out:
3132     afs_PutCellAlias(tcalias);
3133     return code;
3134 }
3135
3136 /*!
3137  * VIOC_AFS_DELETE_MT_PT (28) - Delete mount point
3138  *
3139  * \ingroup pioctl
3140  *
3141  * \param[in] ain       the name of the file in this dir to remove
3142  * \param[out] aout     not in use
3143  *
3144  * \retval EINVAL
3145  *      Error if some of the standard args aren't set
3146  * \retval ENOTDIR
3147  *      Error if the argument to remove is not a directory
3148  * \retval ENOENT
3149  *      Error if there is no cache to remove the mount point from or
3150  *      if a vcache doesn't exist
3151  *
3152  * \post
3153  *      Ensure that everything is OK before deleting the mountpoint.
3154  *      If not, don't delete.  Delete a mount point based on a file id.
3155  */
3156 DECL_PIOCTL(PRemoveMount)
3157 {
3158     register afs_int32 code;
3159     char *bufp;
3160     char *name;
3161     struct sysname_info sysState;
3162     afs_size_t offset, len;
3163     register struct afs_conn *tc;
3164     register struct dcache *tdc;
3165     register struct vcache *tvc;
3166     struct AFSFetchStatus OutDirStatus;
3167     struct VenusFid tfid;
3168     struct AFSVolSync tsync;
3169     XSTATS_DECLS;
3170
3171     /* "ain" is the name of the file in this dir to remove */
3172
3173     AFS_STATCNT(PRemoveMount);
3174     if (!avc)
3175         return EINVAL;
3176     if (afs_pd_getStringPtr(ain, &name) != 0)
3177         return EINVAL;
3178
3179     code = afs_VerifyVCache(avc, areq);
3180     if (code)
3181         return code;
3182     if (vType(avc) != VDIR)
3183         return ENOTDIR;
3184
3185     tdc = afs_GetDCache(avc, (afs_size_t) 0, areq, &offset, &len, 1);   /* test for error below */
3186     if (!tdc)
3187         return ENOENT;
3188     Check_AtSys(avc, name, &sysState, areq);
3189     ObtainReadLock(&tdc->lock);
3190     do {
3191         code = afs_dir_Lookup(tdc, sysState.name, &tfid.Fid);
3192     } while (code == ENOENT && Next_AtSys(avc, areq, &sysState));
3193     ReleaseReadLock(&tdc->lock);
3194     bufp = sysState.name;
3195     if (code) {
3196         afs_PutDCache(tdc);
3197         goto out;
3198     }
3199     tfid.Cell = avc->f.fid.Cell;
3200     tfid.Fid.Volume = avc->f.fid.Fid.Volume;
3201     if (!tfid.Fid.Unique && (avc->f.states & CForeign)) {
3202         tvc = afs_LookupVCache(&tfid, areq, NULL, avc, bufp);
3203     } else {
3204         tvc = afs_GetVCache(&tfid, areq, NULL, NULL);
3205     }
3206     if (!tvc) {
3207         code = ENOENT;
3208         afs_PutDCache(tdc);
3209         goto out;
3210     }
3211     if (tvc->mvstat != 1) {
3212         afs_PutDCache(tdc);
3213         afs_PutVCache(tvc);
3214         code = EINVAL;
3215         goto out;
3216     }
3217     ObtainWriteLock(&tvc->lock, 230);
3218     code = afs_HandleLink(tvc, areq);
3219     if (!code) {
3220         if (tvc->linkData) {
3221             if ((tvc->linkData[0] != '#') && (tvc->linkData[0] != '%'))
3222                 code = EINVAL;
3223         } else
3224             code = EIO;
3225     }
3226     ReleaseWriteLock(&tvc->lock);
3227     osi_dnlc_purgedp(tvc);
3228     afs_PutVCache(tvc);
3229     if (code) {
3230         afs_PutDCache(tdc);
3231         goto out;
3232     }
3233     ObtainWriteLock(&avc->lock, 231);
3234     osi_dnlc_remove(avc, bufp, tvc);
3235     do {
3236         tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK);
3237         if (tc) {
3238             XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_REMOVEFILE);
3239             RX_AFS_GUNLOCK();
3240             code =
3241                 RXAFS_RemoveFile(tc->id, (struct AFSFid *)&avc->f.fid.Fid, bufp,
3242                                  &OutDirStatus, &tsync);
3243             RX_AFS_GLOCK();
3244             XSTATS_END_TIME;
3245         } else
3246             code = -1;
3247     } while (afs_Analyze
3248              (tc, code, &avc->f.fid, areq, AFS_STATS_FS_RPCIDX_REMOVEFILE,
3249               SHARED_LOCK, NULL));
3250
3251     if (code) {
3252         if (tdc)
3253             afs_PutDCache(tdc);
3254         ReleaseWriteLock(&avc->lock);
3255         goto out;
3256     }
3257     if (tdc) {
3258         /* we have the thing in the cache */
3259         ObtainWriteLock(&tdc->lock, 661);
3260         if (afs_LocalHero(avc, tdc, &OutDirStatus, 1)) {
3261             /* we can do it locally */
3262             code = afs_dir_Delete(tdc, bufp);
3263             if (code) {
3264                 ZapDCE(tdc);    /* surprise error -- invalid value */
3265                 DZap(tdc);
3266             }
3267         }
3268         ReleaseWriteLock(&tdc->lock);
3269         afs_PutDCache(tdc);     /* drop ref count */
3270     }
3271     avc->f.states &= ~CUnique;  /* For the dfs xlator */
3272     ReleaseWriteLock(&avc->lock);
3273     code = 0;
3274   out:
3275     if (sysState.allocked)
3276         osi_FreeLargeSpace(bufp);
3277     return code;
3278 }
3279
3280 /*!
3281  * VIOC_GETCELLSTATUS (35) - Get cell status info
3282  *
3283  * \ingroup pioctl
3284  *
3285  * \param[in] ain       The cell you want status information on
3286  * \param[out] aout     cell state (as a struct)
3287  *
3288  * \retval EIO          Error if the afs daemon hasn't started yet
3289  * \retval ENOENT       Error if the cell doesn't exist
3290  *
3291  * \post Returns the state of the cell as defined in a struct cell
3292  */
3293 DECL_PIOCTL(PGetCellStatus)
3294 {
3295     register struct cell *tcell;
3296     char *cellName;
3297     afs_int32 temp;
3298
3299     AFS_STATCNT(PGetCellStatus);
3300     if (!afs_resourceinit_flag) /* afs daemons haven't started yet */
3301         return EIO;             /* Inappropriate ioctl for device */
3302
3303     if (afs_pd_getStringPtr(ain, &cellName) != 0)
3304         return EINVAL;
3305
3306     tcell = afs_GetCellByName(cellName, READ_LOCK);
3307     if (!tcell)
3308         return ENOENT;
3309     temp = tcell->states;
3310     afs_PutCell(tcell, READ_LOCK);
3311
3312     return afs_pd_putInt(aout, temp);
3313 }
3314
3315 /*!
3316  * VIOC_SETCELLSTATUS (36) - Set corresponding info
3317  *
3318  * \ingroup pioctl
3319  *
3320  * \param[in] ain
3321  *      The cell you want to set information about, and the values you
3322  *      want to set
3323  * \param[out] aout
3324  *      not in use
3325  *
3326  * \retval EIO          Error if the afs daemon hasn't started yet
3327  * \retval EACCES       Error if the user doesn't have super-user credentials
3328  *
3329  * \post
3330  *      Set the state of the cell in a defined struct cell, based on
3331  *      whether or not SetUID is allowed
3332  */
3333 DECL_PIOCTL(PSetCellStatus)
3334 {
3335     register struct cell *tcell;
3336     char *cellName;
3337     afs_int32 flags0, flags1;
3338
3339     if (!afs_osi_suser(*acred))
3340         return EACCES;
3341     if (!afs_resourceinit_flag) /* afs daemons haven't started yet */
3342         return EIO;             /* Inappropriate ioctl for device */
3343
3344     if (afs_pd_getInt(ain, &flags0) != 0)
3345         return EINVAL;
3346     if (afs_pd_getInt(ain, &flags1) != 0)
3347         return EINVAL;
3348     if (afs_pd_getStringPtr(ain, &cellName) != 0)
3349         return EINVAL;
3350
3351     tcell = afs_GetCellByName(cellName, WRITE_LOCK);
3352     if (!tcell)
3353         return ENOENT;
3354     if (flags0 & CNoSUID)
3355         tcell->states |= CNoSUID;
3356     else
3357         tcell->states &= ~CNoSUID;
3358     afs_PutCell(tcell, WRITE_LOCK);
3359     return 0;
3360 }
3361
3362 /*!
3363  * VIOC_FLUSHVOLUME (37) - Flush whole volume's data
3364  *
3365  * \ingroup pioctl
3366  *
3367  * \param[in] ain       not in use (args in avc)
3368  * \param[out] aout     not in use
3369  *
3370  * \retval EINVAL       Error if some of the standard args aren't set
3371  * \retval EIO          Error if the afs daemon hasn't started yet
3372  *
3373  * \post
3374  *      Flush all cached contents of a volume.  Exactly what stays and what
3375  *      goes depends on the platform.
3376  *
3377  * \notes
3378  *      Does not flush a file that a user has open and is using, because
3379  *      it will be re-created on next write.  Also purges the dnlc,
3380  *      because things are screwed up.
3381  */
3382 DECL_PIOCTL(PFlushVolumeData)
3383 {
3384     register afs_int32 i;
3385     register struct dcache *tdc;
3386     register struct vcache *tvc;
3387     register struct volume *tv;
3388     afs_int32 cell, volume;
3389     struct afs_q *tq, *uq;
3390 #ifdef AFS_DARWIN80_ENV
3391     vnode_t vp;
3392 #endif
3393
3394     AFS_STATCNT(PFlushVolumeData);
3395     if (!avc)
3396         return EINVAL;
3397     if (!afs_resourceinit_flag) /* afs daemons haven't started yet */
3398         return EIO;             /* Inappropriate ioctl for device */
3399
3400     volume = avc->f.fid.Fid.Volume;     /* who to zap */
3401     cell = avc->f.fid.Cell;
3402
3403     /*
3404      * Clear stat'd flag from all vnodes from this volume; this will
3405      * invalidate all the vcaches associated with the volume.
3406      */
3407  loop:
3408     ObtainReadLock(&afs_xvcache);
3409     i = VCHashV(&avc->f.fid);
3410     for (tq = afs_vhashTV[i].prev; tq != &afs_vhashTV[i]; tq = uq) {
3411             uq = QPrev(tq);
3412             tvc = QTOVH(tq);
3413             if (tvc->f.fid.Fid.Volume == volume && tvc->f.fid.Cell == cell) {
3414                 if (tvc->f.states & CVInit) {
3415                     ReleaseReadLock(&afs_xvcache);
3416                     afs_osi_Sleep(&tvc->f.states);
3417                     goto loop;
3418                 }
3419 #ifdef AFS_DARWIN80_ENV
3420             if (tvc->f.states & CDeadVnode) {
3421                 if (!(tvc->f.states & CBulkFetching)) {
3422                     ReleaseReadLock(&afs_xvcache);
3423                     afs_osi_Sleep(&tvc->f.states);
3424                     goto loop;
3425                 }
3426             }
3427 #endif
3428 #if     defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV)  || defined(AFS_HPUX_ENV) || defined(AFS_LINUX20_ENV)
3429                 VN_HOLD(AFSTOV(tvc));
3430 #elif defined(AFS_DARWIN80_ENV)
3431                 vp = AFSTOV(tvc);
3432                 if (vnode_get(vp))
3433                     continue;
3434                 if (vnode_ref(vp)) {
3435                     AFS_GUNLOCK();
3436                     vnode_put(vp);
3437                     AFS_GLOCK();
3438                     continue;
3439                 }
3440                 if (tvc->f.states & (CBulkFetching|CDeadVnode)) {
3441                     AFS_GUNLOCK();
3442                     vnode_recycle(AFSTOV(tvc));
3443                     AFS_GLOCK();
3444                 }
3445 #else
3446                 AFS_FAST_HOLD(tvc);
3447 #endif
3448                 ReleaseReadLock(&afs_xvcache);
3449 #ifdef AFS_BOZONLOCK_ENV
3450                 afs_BozonLock(&tvc->pvnLock, tvc);      /* Since afs_TryToSmush will do a pvn_vptrunc */
3451 #endif
3452                 ObtainWriteLock(&tvc->lock, 232);
3453
3454                 ObtainWriteLock(&afs_xcbhash, 458);
3455                 afs_DequeueCallback(tvc);
3456                 tvc->f.states &= ~(CStatd | CDirty);
3457                 ReleaseWriteLock(&afs_xcbhash);
3458                 if (tvc->f.fid.Fid.Vnode & 1 || (vType(tvc) == VDIR))
3459                     osi_dnlc_purgedp(tvc);
3460                 afs_TryToSmush(tvc, *acred, 1);
3461                 ReleaseWriteLock(&tvc->lock);
3462 #ifdef AFS_BOZONLOCK_ENV
3463                 afs_BozonUnlock(&tvc->pvnLock, tvc);
3464 #endif
3465 #ifdef AFS_DARWIN80_ENV
3466                 vnode_put(AFSTOV(tvc));
3467 #endif
3468                 ObtainReadLock(&afs_xvcache);
3469                 uq = QPrev(tq);
3470                 /* our tvc ptr is still good until now */
3471                 AFS_FAST_RELE(tvc);
3472             }
3473         }
3474     ReleaseReadLock(&afs_xvcache);
3475
3476
3477     ObtainWriteLock(&afs_xdcache, 328); /* needed to flush any stuff */
3478     for (i = 0; i < afs_cacheFiles; i++) {
3479         if (!(afs_indexFlags[i] & IFEverUsed))
3480             continue;           /* never had any data */
3481         tdc = afs_GetDSlot(i, NULL);
3482         if (tdc->refCount <= 1) {    /* too high, in use by running sys call */
3483             ReleaseReadLock(&tdc->tlock);
3484             if (tdc->f.fid.Fid.Volume == volume && tdc->f.fid.Cell == cell) {
3485                 if (!(afs_indexFlags[i] & IFDataMod)) {
3486                     /* if the file is modified, but has a ref cnt of only 1,
3487                      * then someone probably has the file open and is writing
3488                      * into it. Better to skip flushing such a file, it will be
3489                      * brought back immediately on the next write anyway.
3490                      * 
3491                      * If we *must* flush, then this code has to be rearranged
3492                      * to call afs_storeAllSegments() first */
3493                     afs_FlushDCache(tdc);
3494                 }
3495             }
3496         } else {
3497             ReleaseReadLock(&tdc->tlock);
3498         }
3499         afs_PutDCache(tdc);     /* bumped by getdslot */
3500     }
3501     ReleaseWriteLock(&afs_xdcache);
3502
3503     ObtainReadLock(&afs_xvolume);
3504     for (i = 0; i < NVOLS; i++) {
3505         for (tv = afs_volumes[i]; tv; tv = tv->next) {
3506             if (tv->volume == volume) {
3507                 afs_ResetVolumeInfo(tv);
3508                 break;
3509             }
3510         }
3511     }
3512     ReleaseReadLock(&afs_xvolume);
3513
3514     /* probably, a user is doing this, probably, because things are screwed up.
3515      * maybe it's the dnlc's fault? */
3516     osi_dnlc_purge();
3517     return 0;
3518 }
3519
3520
3521 /*!
3522  * VIOCGETVCXSTATUS (41) - gets vnode x status
3523  *
3524  * \ingroup pioctl
3525  *
3526  * \param[in] ain
3527  *      not in use (avc used)
3528  * \param[out] aout
3529  *      vcxstat: the file id, the data version, any lock, the parent vnode,
3530  *      the parent unique id, the trunc position, the callback, cbExpires,
3531  *      what access is being made, what files are open,
3532  *      any users executing/writing, the flock count, the states,
3533  *      the move stat
3534  *
3535  * \retval EINVAL
3536  *      Error if some of the initial default arguments aren't set
3537  * \retval EACCES
3538  *      Error if access to check the mode bits is denied
3539  *
3540  * \post
3541  *      gets stats for the vnode, a struct listed in vcxstat
3542  */
3543 DECL_PIOCTL(PGetVnodeXStatus)
3544 {
3545     register afs_int32 code;
3546     struct vcxstat stat;
3547     afs_int32 mode, i;
3548
3549 /*  AFS_STATCNT(PGetVnodeXStatus); */
3550     if (!avc)
3551         return EINVAL;
3552     code = afs_VerifyVCache(avc, areq);
3553     if (code)
3554         return code;
3555     if (vType(avc) == VDIR)
3556         mode = PRSFS_LOOKUP;
3557     else
3558         mode = PRSFS_READ;
3559     if (!afs_AccessOK(avc, mode, areq, CHECK_MODE_BITS))
3560         return EACCES;
3561
3562     memset(&stat, 0, sizeof(struct vcxstat));
3563     stat.fid = avc->f.fid;
3564     hset32(stat.DataVersion, hgetlo(avc->f.m.DataVersion));
3565     stat.lock = avc->lock;
3566     stat.parentVnode = avc->f.parent.vnode;
3567     stat.parentUnique = avc->f.parent.unique;
3568     hset(stat.flushDV, avc->flushDV);
3569     hset(stat.mapDV, avc->mapDV);
3570     stat.truncPos = avc->f.truncPos;
3571     {                   /* just grab the first two - won't break anything... */
3572         struct axscache *ac;
3573
3574         for (i = 0, ac = avc->Access; ac && i < CPSIZE; i++, ac = ac->next) {
3575             stat.randomUid[i] = ac->uid;
3576             stat.randomAccess[i] = ac->axess;
3577         }
3578     }
3579     stat.callback = afs_data_pointer_to_int32(avc->callback);
3580     stat.cbExpires = avc->cbExpires;
3581     stat.anyAccess = avc->f.anyAccess;
3582     stat.opens = avc->opens;
3583     stat.execsOrWriters = avc->execsOrWriters;
3584     stat.flockCount = avc->flockCount;
3585     stat.mvstat = avc->mvstat;
3586     stat.states = avc->f.states;
3587     return afs_pd_putBytes(aout, &stat, sizeof(struct vcxstat));
3588 }
3589
3590
3591 DECL_PIOCTL(PGetVnodeXStatus2)
3592 {
3593     register afs_int32 code;
3594     struct vcxstat2 stat;
3595     afs_int32 mode;
3596
3597     if (!avc)
3598         return EINVAL;
3599     code = afs_VerifyVCache(avc, areq);
3600     if (code)
3601         return code;
3602     if (vType(avc) == VDIR)
3603         mode = PRSFS_LOOKUP;
3604     else
3605         mode = PRSFS_READ;
3606     if (!afs_AccessOK(avc, mode, areq, CHECK_MODE_BITS))
3607         return EACCES;
3608
3609     memset(&stat, 0, sizeof(struct vcxstat2));
3610
3611     stat.cbExpires = avc->cbExpires;
3612     stat.anyAccess = avc->f.anyAccess;
3613     stat.mvstat = avc->mvstat;
3614     stat.callerAccess = afs_GetAccessBits(avc, ~0, areq);
3615
3616     return afs_pd_putBytes(aout, &stat, sizeof(struct vcxstat2));
3617 }
3618
3619
3620 /*!
3621  * VIOC_AFS_SYSNAME (38) - Change @sys value
3622  *
3623  * \ingroup pioctl
3624  *
3625  * \param[in] ain       new value for @sys
3626  * \param[out] aout     count, entry, list (debug values?)
3627  *
3628  * \retval EINVAL
3629  *      Error if afsd isn't running, the new sysname is too large,
3630  *      the new sysname causes issues (starts with a . or ..),
3631  *      there is no PAG set in the credentials, or the user of a PAG
3632  *      can't be found
3633  * \retval EACCES
3634  *      Error if the user doesn't have super-user credentials
3635  *
3636  * \post
3637  *      Set the value of @sys if these things work: if the input isn't
3638  *      too long or if input doesn't start with . or ..
3639  *
3640  * \notes
3641  *      We require root for local sysname changes, but not for remote
3642  *      (since we don't really believe remote uids anyway)
3643  *      outname[] shouldn't really be needed- this is left as an
3644  *      exercise for the reader.
3645  */
3646 DECL_PIOCTL(PSetSysName)
3647 {
3648     char *inname = NULL;
3649     char outname[MAXSYSNAME];
3650     afs_int32 setsysname;
3651     int foundname = 0;
3652     register struct afs_exporter *exporter;
3653     register struct unixuser *au;
3654     register afs_int32 pag, error;
3655     int t, count, num = 0, allpags = 0;
3656     char **sysnamelist;
3657     struct afs_pdata validate;
3658
3659     AFS_STATCNT(PSetSysName);
3660     if (!afs_globalVFS) {
3661         /* Afsd is NOT running; disable it */
3662 #if defined(KERNEL_HAVE_UERROR)
3663         return (setuerror(EINVAL), EINVAL);
3664 #else
3665         return (EINVAL);
3666 #endif
3667     }
3668     if (afs_pd_getInt(ain, &setsysname) != 0)
3669         return EINVAL;
3670     if (setsysname & 0x8000) {
3671         allpags = 1;
3672         setsysname &= ~0x8000;
3673     }
3674     if (setsysname) {
3675
3676         /* Check my args */
3677         if (setsysname < 0 || setsysname > MAXNUMSYSNAMES)
3678             return EINVAL;
3679         validate = *ain;
3680         for (count = 0; count < setsysname; count++) {
3681             if (afs_pd_getStringPtr(&validate, &inname) != 0)
3682                 return EINVAL;
3683             t = strlen(inname);
3684             if (t >= MAXSYSNAME || t <= 0)
3685                 return EINVAL;
3686             /* check for names that can shoot us in the foot */
3687             if (inname[0] == '.' && (inname[1] == 0
3688                 || (inname[1] == '.' && inname[2] == 0)))
3689                 return EINVAL;
3690         }
3691         /* args ok, so go back to the beginning of that section */
3692
3693         if (afs_pd_getStringPtr(ain, &inname) != 0)
3694             return EINVAL;
3695         num = count;
3696     }
3697     if (afs_cr_gid(*acred) == RMTUSER_REQ ||
3698         afs_cr_gid(*acred) == RMTUSER_REQ_PRIV) {   /* Handles all exporters */
3699         if (allpags && afs_cr_gid(*acred) != RMTUSER_REQ_PRIV) {
3700             return EPERM;
3701         }
3702         pag = PagInCred(*acred);
3703         if (pag == NOPAG) {
3704             return EINVAL;      /* Better than panicing */
3705         }
3706         if (!(au = afs_FindUser(pag, -1, READ_LOCK))) {
3707             return EINVAL;      /* Better than panicing */
3708         }
3709         if (!(exporter = au->exporter)) {
3710             afs_PutUser(au, READ_LOCK);
3711             return EINVAL;      /* Better than panicing */
3712         }
3713         error = EXP_SYSNAME(exporter, inname, &sysnamelist,
3714                             &num, allpags);
3715         if (error) {
3716             if (error == ENODEV)
3717                 foundname = 0;  /* sysname not set yet! */
3718             else {
3719                 afs_PutUser(au, READ_LOCK);
3720                 return error;
3721             }
3722         } else {
3723             foundname = num;
3724             strcpy(outname, sysnamelist[0]);
3725         }
3726         afs_PutUser(au, READ_LOCK);
3727         if (setsysname)
3728             afs_sysnamegen++;
3729     } else {
3730         /* Not xlating, so local case */
3731         if (!afs_sysname)
3732             osi_Panic("PSetSysName: !afs_sysname\n");
3733         if (!setsysname) {      /* user just wants the info */
3734             strcpy(outname, afs_sysname);
3735             foundname = afs_sysnamecount;
3736             sysnamelist = afs_sysnamelist;
3737         } else {                /* Local guy; only root can change sysname */
3738             if (!afs_osi_suser(*acred))
3739                 return EACCES;
3740
3741             /* allpags makes no sense for local use */
3742             if (allpags)
3743                 return EINVAL;
3744
3745             /* clear @sys entries from the dnlc, once afs_lookup can
3746              * do lookups of @sys entries and thinks it can trust them */
3747             /* privs ok, store the entry, ... */
3748
3749             if (strlen(inname) >= MAXSYSNAME-1)
3750                 return EINVAL;
3751             strcpy(afs_sysname, inname);
3752
3753             if (setsysname > 1) {       /* ... or list */
3754                 for (count = 1; count < setsysname; ++count) {
3755                     if (!afs_sysnamelist[count])
3756                         osi_Panic
3757                            ("PSetSysName: no afs_sysnamelist entry to write\n");
3758                     if (afs_pd_getString(ain, afs_sysnamelist[count],
3759                                          MAXSYSNAME) != 0)
3760                         return EINVAL;
3761                 }
3762             }
3763             afs_sysnamecount = setsysname;
3764             afs_sysnamegen++;
3765         }
3766     }
3767     if (!setsysname) {