irix kill efs and start pruning pre-65
[openafs.git] / src / afs / IRIX / osi_inode.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 /*
11  * IRIX inode operations
12  *
13  * Implements:
14  * afsidestroy
15  * getinode
16  * igetinode
17  * xfs_getinode
18  * xfs_igetinode
19  * icreate
20  * afs_syscall_icreate
21  * xfs_icreatename64
22  * afs_syscall_icreatename64
23  * iopenargs64
24  * afs_syscall_iopen
25  * iopen
26  * iopen64
27  * xfs_iincdec64
28  * iincdec64
29  * afs_syscall_idec64
30  * afs_syscall_iinc64
31  * iincdec
32  * iinc
33  * idec
34  * afs_syscall_iincdec
35  * afs_syscall_ilistinode64
36  *
37  */
38
39 #include <afsconfig.h>
40 #include "afs/param.h"
41
42
43 #include "afs/sysincludes.h"    /* Standard vendor system headers */
44 #include "afsincludes.h"        /* Afs-based standard headers */
45 #include "afs/osi_inode.h"
46 #include "afs/afs_stats.h"      /* statistics stuff */
47
48 #define BAD_IGET        -1000
49
50 /*
51  * SGI dependent system calls
52  */
53 #ifndef INODESPECIAL
54 /*
55  * `INODESPECIAL' type inodes are ones that describe volumes.
56  */
57 #define INODESPECIAL    0xffffffff      /* ... from ../vol/viceinode.h  */
58 #endif
59
60 void
61 afsidestroy(struct inode *ip)
62 {
63     if (ip->i_afs) {
64         kmem_free(ip->i_afs, sizeof(struct afsparms));
65         ip->i_afs = NULL;
66     }
67 }
68
69 extern int xfs_fstype;
70
71 int
72 getinode(struct vfs *vfsp, dev_t dev, ino_t inode, struct inode **ipp)
73 {
74     return ENOSYS;
75 }
76
77 int
78 igetinode(struct vfs *vfsp, dev_t dev, ino_t inode, struct inode **ipp)
79 {
80     return ENOSYS;
81 }
82
83 int XFS_IGET_EPOS;
84 ino_t XFS_IGET_INO;
85 dev_t XFS_IGET_DEV;
86 #define SET_XFS_ERROR(POS, DEV, INO) \
87         XFS_IGET_EPOS = (POS), XFS_IGET_DEV = (DEV), XFS_IGET_INO = (INO)
88
89 int
90 xfs_getinode(struct vfs *vfsp, dev_t dev, ino_t inode, struct xfs_inode **ipp)
91 {
92     struct xfs_inode *ip;
93     int error;
94
95     if (!vfsp) {
96         vfsp = vfs_devsearch(dev, xfs_fstype);
97         if (!vfsp) {
98             SET_XFS_ERROR(1, dev, inode);
99             return ENXIO;
100         }
101     }
102
103     if (error = xfs_iget((((struct mount *)
104                            ((vfsp)->vfs_bh.bh_first)->bd_pdata)), (void *)0,
105                          (xfs_ino_t) inode, XFS_ILOCK_SHARED, &ip,
106                          (daddr_t) 0)) {
107         SET_XFS_ERROR(3, vfsp->vfs_dev, inode);
108         return error;
109     }
110
111     *ipp = ip;
112     return 0;
113 }
114
115 /* xfs_igetinode now returns an unlocked inode. This is fine, since we
116  * have a refcount on the holding vnode.
117  */
118 int
119 xfs_igetinode(struct vfs *vfsp, dev_t dev, ino_t inode,
120               struct xfs_inode **ipp)
121 {
122     struct xfs_inode *ip;
123     vnode_t *vp;
124     vattr_t vattr;
125     int error;
126
127     AFS_STATCNT(igetinode);
128
129     *ipp = NULL;
130     if (error = xfs_getinode(vfsp, dev, inode, &ip)) {
131         return error;
132     }
133
134     xfs_iunlock(ip, XFS_ILOCK_SHARED);
135     vp = XFS_ITOV(ip);
136     vattr.va_mask = AT_STAT;
137     AFS_VOP_GETATTR(vp, &vattr, 0, OSI_GET_CURRENT_CRED(), error);
138     if (error) {
139         SET_XFS_ERROR(4, vp->v_vfsp->vfs_dev, inode);
140         VN_RELE(vp);
141         return error;
142     }
143     if (vattr.va_nlink == 0 || vattr.va_type != VREG) {
144         SET_XFS_ERROR(5, vp->v_vfsp->vfs_dev, inode);
145         VN_RELE(vp);
146         return ENOENT;
147     }
148
149     *ipp = ip;
150     return 0;
151 }
152
153 /**************************************************************************
154  * inode creation routines.
155  *
156  ***************************************************************************/
157 struct icreateargs {
158     sysarg_t dev;
159     sysarg_t near_inode;
160     sysarg_t param1;
161     sysarg_t param2;
162     sysarg_t param3;
163     sysarg_t param4;
164 };
165
166 int
167 icreate(struct icreateargs *uap, rval_t * rvp)
168 {
169     return ENOSYS;
170 }
171
172 int
173 afs_syscall_icreate(dev, near_inode, param1, param2, param3, param4, rvp)
174      afs_uint32 dev, near_inode, param1, param2, param3, param4;
175      rval_t *rvp;
176 {
177     return ENOSYS;
178 }
179
180 /* inode creation routines for icreatename64 entry point. 
181  * Create a name in the namespace as well as the inode.
182  */
183
184 #include <afs/xfsattrs.h>
185 #include <sys/attributes.h>
186
187 extern char *int_to_base64(char *, int);
188
189 /* Lock against races creating/removing directory - vos zap RO, vos create RW*/
190 kmutex_t afs_vol_create_lock;
191 int afs_vol_create_lock_inited = 0;
192 #define AFS_LOCK_VOL_CREATE() { \
193         if (!afs_vol_create_lock_inited) { \
194             mutex_init(&afs_vol_create_lock, MUTEX_DEFAULT, \
195                        "afs_vol_create_lock"); \
196             afs_vol_create_lock_inited = 1; \
197         } \
198         mutex_enter(&afs_vol_create_lock); \
199                                  }
200 #define AFS_UNLOCK_VOL_CREATE() mutex_exit(&afs_vol_create_lock)
201
202
203 /* xfs_icreatename64
204  * Create an AFS inode in the XFS name space. If required create the proper
205  * containing directory. See sys/xfsattrs.h for the details on the naming
206  * conventions and the usage of file and directory attributes.
207  *
208  * The inode parameters are stored in an XFS attribute called "AFS". In
209  * addition gid is set to XFS_VICEMAGIC and uid is set to the low 31 bits
210  * of the RW volume id. This is so inode verification in iinc and idec
211  * don't need to get the attribute. Note that only the low 31 bits are set.
212  * This is because chmod only accepts up to MAX_UID and chmod is used
213  * to correct these values in xfs_ListViceInodes.
214  */
215 int
216 xfs_icreatename64(struct vfs *vfsp, int datap, int datalen,
217                   afs_inode_params_t params, ino_t * inop)
218 {
219 #define AFS_PNAME_SIZE 16
220     char path[64];
221     char name[64];
222     b64_string_t stmp1, stmp2;
223     afs_xfs_attr_t attrs;
224     struct vattr vattr;
225     int name_version = AFS_XFS_NAME_VERS;
226     int code = 0, unused;
227     struct vnode *vp;
228     struct vnode *dvp;
229     int rw_vno;                 /* volume ID of parent volume */
230     int i;
231     int createdDir = 0;
232     size_t junk;
233     char *s;
234
235
236     /* Get vnode for directory which will contain new inode. */
237     if (datalen >= AFS_PNAME_SIZE)
238         return E2BIG;
239
240     AFS_COPYINSTR((char *)datap, path, AFS_PNAME_SIZE - 1, &junk, unused);
241     if (*path != '/') {
242         return EINVAL;
243     }
244
245     rw_vno = (params[1] == INODESPECIAL) ? params[3] : params[0];
246
247     /* directory name */
248     strcat(path, "/");
249     strcat(path, AFS_INODE_DIR_NAME);
250     strcat(path, int_to_base64(stmp1, rw_vno));
251
252     if (params[1] == INODESPECIAL)
253         AFS_LOCK_VOL_CREATE();
254
255     code = gop_lookupname(path, AFS_UIOSYS, FOLLOW, &dvp);
256     if (code == ENOENT) {
257         /* Maybe it's an old directory name format. */
258         AFS_COPYINSTR((char *)datap, name, AFS_PNAME_SIZE - 1, &junk, unused);
259         strcat(name, "/.");
260         strcat(name, int_to_base64(stmp1, rw_vno));
261         code = gop_lookupname(name, AFS_UIOSYS, FOLLOW, &dvp);
262         if (!code) {
263             /* Use old name format. */
264             strcpy(path, name);
265             name_version = AFS_XFS_NAME_VERS1;
266         }
267     }
268
269     if (code == ENOENT) {
270         afs_xfs_dattr_t dattr;
271         /* make directory. */
272
273         code =
274             AFS_VN_OPEN(path, UIO_SYSSPACE, FCREAT | FEXCL, 0700, &dvp,
275                         CRMKDIR);
276         if (code) {
277             if (code == EEXIST) {
278                 /* someone beat us to it? */
279                 code = gop_lookupname(path, AFS_UIOSYS, NO_FOLLOW, &dvp);
280             }
281             if (code) {
282                 AFS_UNLOCK_VOL_CREATE();
283                 return code;
284             }
285         } else
286             createdDir = 1;
287         memset(&dattr, 0, sizeof(dattr));
288         dattr.atd_version = AFS_XFS_ATD_VERS;
289         dattr.atd_volume = rw_vno;
290         AFS_VOP_ATTR_SET(dvp, AFS_XFS_DATTR, (char *)&dattr,
291                          SIZEOF_XFS_DATTR_T, ATTR_ROOT | ATTR_CREATE,
292                          OSI_GET_CURRENT_CRED(), code);
293         if (code) {
294             VN_RELE(dvp);
295             if (createdDir)
296                 (void)vn_remove(path, UIO_SYSSPACE, RMDIRECTORY);
297             AFS_UNLOCK_VOL_CREATE();
298             return code;
299         }
300     }
301
302     vattr.va_mask = AT_FSID | AT_NODEID;        /* gets a guick return using FSID */
303     AFS_VOP_GETATTR(dvp, &vattr, 0, OSI_GET_CURRENT_CRED(), code);
304     if (code) {
305         VN_RELE(dvp);
306         return code;
307     }
308
309     memset(&attrs, 0, sizeof(attrs));
310     attrs.at_pino = vattr.va_nodeid;
311     VN_RELE(dvp);
312
313     /* Create the desired file. Use up to ten tries to create a unique name. */
314     (void)strcpy(name, path);
315     (void)strcat(name, "/.");
316     (void)strcat(name, int_to_base64(stmp2, params[2]));
317     s = &name[strlen(name)];
318
319     attrs.at_tag = 0;           /* Initial guess at a unique tag. */
320     for (i = 0; i < 10; i++) {
321         *s = '\0';
322         strcat(s, ".");
323         strcat(s, int_to_base64(stmp1, attrs.at_tag));
324         code =
325             AFS_VN_OPEN(name, UIO_SYSSPACE, FCREAT | FEXCL, 0600, &vp,
326                         CRCREAT);
327         if (!code || code != EEXIST)
328             break;
329
330         attrs.at_tag++;
331     }
332     /* Unlock the creation process since the directory now has a file in it. */
333     if (params[1] == INODESPECIAL)
334         AFS_UNLOCK_VOL_CREATE();
335
336     if (!code) {
337         /* Set attributes. */
338         memcpy((char *)attrs.at_param, (char *)params,
339                sizeof(afs_inode_params_t));
340         attrs.at_attr_version = AFS_XFS_ATTR_VERS;
341         attrs.at_name_version = name_version;
342         AFS_VOP_ATTR_SET(vp, AFS_XFS_ATTR, (char *)&attrs, SIZEOF_XFS_ATTR_T,
343                          ATTR_ROOT | ATTR_CREATE, OSI_GET_CURRENT_CRED(),
344                          code);
345         if (!code) {
346             vattr.va_mode = 1;
347             vattr.va_uid = AFS_XFS_VNO_CLIP(params[0]);
348             vattr.va_gid = XFS_VICEMAGIC;
349             vattr.va_mask = AT_MODE | AT_UID | AT_GID;
350             AFS_VOP_SETATTR(vp, &vattr, 0, OSI_GET_CURRENT_CRED(), code);
351         }
352         if (!code) {
353             vattr.va_mask = AT_NODEID;
354             AFS_VOP_GETATTR(vp, &vattr, 0, OSI_GET_CURRENT_CRED(), code);
355         }
356         if (!code)
357             *inop = vattr.va_nodeid;
358         VN_RELE(vp);
359     }
360
361     if (code) {
362         /* remove partially created file. */
363         (void)vn_remove(name, UIO_SYSSPACE, RMFILE);
364
365         /* and directory if volume special file. */
366         if (createdDir) {
367             AFS_LOCK_VOL_CREATE();
368             (void)vn_remove(path, UIO_SYSSPACE, RMDIRECTORY);
369             AFS_UNLOCK_VOL_CREATE();
370         }
371     }
372     return code;
373 }
374
375 /* afs_syscall_icreatename64
376  * This is the icreatename64 entry point used by the XFS
377  * fileserver suite.
378  */
379 int
380 afs_syscall_icreatename64(int dev, int datap, int datalen, int paramp,
381                           int inop)
382 {
383     struct vfs *vfsp;
384     afs_inode_params_t param;
385     int code;
386     rval_t rval;
387     ino_t ino;
388
389
390     if (!afs_suser(NULL))
391         return EPERM;
392
393     vfsp = vfs_devsearch(dev, VFS_FSTYPE_ANY);
394     if (vfsp == NULL) {
395         return ENXIO;
396     }
397
398     AFS_COPYIN((char *)paramp, (char *)param, sizeof(afs_inode_params_t),
399                code);
400     if (vfsp->vfs_fstype == xfs_fstype) {
401         code = xfs_icreatename64(vfsp, datap, datalen, param, &ino);
402         if (code)
403             return code;
404         else {
405             AFS_COPYOUT((char *)&ino, (char *)inop, sizeof(ino_t), code);
406             return code;
407         }
408     }
409     return ENXIO;
410 }
411
412 /*
413  * iopen system calls -- open an inode for reading/writing
414  * Restricted to super user.
415  * Any IFREG files.
416  */
417 struct iopenargs {
418     sysarg_t dev;
419     sysarg_t inode;
420     sysarg_t usrmod;
421 };
422
423 struct iopenargs64 {
424     sysarg_t dev;
425     sysarg_t inode_hi;
426     sysarg_t inode_lo;
427     sysarg_t usrmod;
428 };
429
430 int
431 afs_syscall_iopen(int dev, ino_t inode, int usrmod, rval_t * rvp)
432 {
433     struct file *fp;
434     int fd;
435     int error;
436     struct vfs *vfsp;
437     struct vnode *vp;
438
439     AFS_STATCNT(afs_syscall_iopen);
440     if (!afs_suser(NULL))
441         return EPERM;
442     vfsp = vfs_devsearch(dev, xfs_fstype);
443     if (!vfsp)
444         return ENXIO;
445
446     if (vfsp->vfs_fstype == xfs_fstype) {
447         struct xfs_inode *xip;
448         if (error = xfs_igetinode(vfsp, (dev_t) dev, inode, &xip))
449             return error;
450         vp = XFS_ITOV(xip);
451         if (error = vfile_alloc((usrmod + 1) & (FMASK), &fp, &fd)) {
452             VN_RELE(vp);
453             return error;
454         }
455     } else {
456         osi_Panic("afs_syscall_iopen: bad fstype = %d\n", vfsp->vfs_fstype);
457     }
458     vfile_ready(fp, vp);
459     rvp->r_val1 = fd;
460     return 0;
461 }
462
463 int
464 iopen(struct iopenargs *uap, rval_t * rvp)
465 {
466     AFS_STATCNT(iopen);
467     return (afs_syscall_iopen
468             (uap->dev, (ino_t) uap->inode, uap->usrmod, rvp));
469 }
470
471 int
472 iopen64(struct iopenargs64 *uap, rval_t * rvp)
473 {
474     AFS_STATCNT(iopen);
475     return (afs_syscall_iopen
476             (uap->dev, (ino_t) ((uap->inode_hi << 32) | uap->inode_lo),
477              uap->usrmod, rvp));
478 }
479
480 /*
481  * Support for iinc() and idec() system calls--increment or decrement
482  * count on inode.
483  * Restricted to super user.
484  * Only VICEMAGIC type inodes.
485  */
486
487 /* xfs_iincdec
488  *
489  * XFS iinc/idec code. Uses 64 bit inode numbers. 
490  */
491 static int
492 xfs_iincdec64(struct vfs *vfsp, ino_t inode, int inode_p1, int amount)
493 {
494     vnode_t *vp;
495     xfs_inode_t *ip;
496     int code = 0;
497     afs_xfs_attr_t attrs;
498     int length = SIZEOF_XFS_ATTR_T;
499     afs_xfs_dattr_t dattr;
500     struct vattr vattr;
501     int nlink;
502     int vol;
503
504     code =
505         xfs_iget((((struct mount *)((vfsp)->vfs_bh.bh_first)->bd_pdata)),
506                  (void *)0, (xfs_ino_t) inode, XFS_ILOCK_SHARED, &ip,
507                  (daddr_t) 0);
508     if (code)
509         return code;
510
511     vp = XFS_ITOV(ip);
512     xfs_iunlock(ip, XFS_ILOCK_SHARED);
513
514     vattr.va_mask = AT_GID | AT_UID | AT_MODE;
515     AFS_VOP_GETATTR(vp, &vattr, 0, OSI_GET_CURRENT_CRED(), code);
516     if (code)
517         code = EPERM;
518
519     if (!code && (vattr.va_gid != XFS_VICEMAGIC))
520         code = EPERM;
521
522     if (!code && (AFS_XFS_VNO_CLIP(inode_p1) != vattr.va_uid))
523         code = ENXIO;
524
525     if (code) {
526         VN_RELE(vp);
527         return code;
528     }
529
530     nlink = vattr.va_mode & AFS_XFS_MODE_LINK_MASK;
531     nlink += amount;
532     if (nlink > 07) {
533         code = EOVERFLOW;
534     }
535     if (nlink > 0) {
536         vattr.va_mode &= ~AFS_XFS_MODE_LINK_MASK;
537         vattr.va_mode |= nlink;
538         vattr.va_mask = AT_MODE;
539         AFS_VOP_SETATTR(vp, &vattr, 0, OSI_GET_CURRENT_CRED(), code);
540         VN_RELE(vp);
541         return code;
542     } else {
543         char path[64];
544         b64_string_t stmp1, stmp2;
545         vnode_t *dvp;
546         xfs_inode_t *ip;
547
548         length = SIZEOF_XFS_ATTR_T;
549         AFS_VOP_ATTR_GET(vp, AFS_XFS_ATTR, (char *)&attrs, &length, ATTR_ROOT,
550                          OSI_GET_CURRENT_CRED(), code);
551         VN_RELE(vp);
552         if (!code) {
553             if (length != SIZEOF_XFS_ATTR_T
554                 || attrs.at_attr_version != AFS_XFS_ATTR_VERS)
555                 return EINVAL;
556         }
557         /* Get the vnode for the directory this file is in. */
558         if (!attrs.at_pino)
559             return ENOENT;
560
561         code = xfs_getinode(vp->v_vfsp, NULL, attrs.at_pino, &ip);
562         if (code)
563             return code;
564
565         dvp = XFS_ITOV(ip);
566         xfs_iunlock(ip, XFS_ILOCK_SHARED);
567
568         /* Verify directory attributes. */
569         length = SIZEOF_XFS_DATTR_T;
570         AFS_VOP_ATTR_GET(dvp, AFS_XFS_DATTR, (char *)&dattr, &length,
571                          ATTR_ROOT, OSI_GET_CURRENT_CRED(), code);
572         if (!code) {
573             if (length != SIZEOF_XFS_DATTR_T
574                 || dattr.atd_version != AFS_XFS_ATD_VERS)
575                 code = ENXIO;
576         }
577         if (code) {
578             VN_RELE(dvp);
579             return code;
580         }
581
582         strcpy(path, ".");
583         strcat(path, int_to_base64(stmp1, attrs.at_param[2]));
584         strcat(path, ".");
585         strcat(path, int_to_base64(stmp1, attrs.at_tag));
586
587         AFS_VOP_REMOVE(dvp, path, OSI_GET_CURRENT_CRED(), code);
588
589         if (!code) {
590             int code2;
591             vattr.va_mask = AT_NLINK;
592             AFS_VOP_GETATTR(dvp, &vattr, 0, OSI_GET_CURRENT_CRED(), code2);
593             if (!code2) {
594                 if (vattr.va_nlink == 2) {
595                     vnode_t *ddvp;      /* parent of volume directory. */
596                     /* Try to remove the directory if this is a volume
597                      * special file. It's ok to fail.
598                      */
599                     AFS_VOP_LOOKUP(dvp, "..", &ddvp, (struct pathname *)NULL,
600                                    0, OSI_GET_CURRENT_RDIR(),
601                                    OSI_GET_CURRENT_CRED(), code2);
602                     if (!code2) {
603                         VN_RELE(dvp);
604                         dvp = (vnode_t *) 0;
605                         strcpy(path, ".");
606                         if (attrs.at_name_version == AFS_XFS_NAME_VERS2)
607                             strcpy(path, AFS_INODE_DIR_NAME);
608                         else
609                             strcpy(path, ".");
610                         int_to_base64(stmp1,
611                                       (attrs.at_param[1] ==
612                                        INODESPECIAL) ? attrs.
613                                       at_param[3] : attrs.at_param[0]);
614                         strcat(path, stmp1);
615                         AFS_LOCK_VOL_CREATE();
616                         AFS_VOP_RMDIR(ddvp, path, OSI_GET_CURRENT_CDIR(),
617                                       OSI_GET_CURRENT_CRED(), code2);
618                         AFS_UNLOCK_VOL_CREATE();
619                         VN_RELE(ddvp);
620                     }
621                 }
622             }
623         }
624         if (dvp)
625             VN_RELE(dvp);
626     }
627     return code;
628 }
629
630 int
631 iincdec64(int dev, int inode_hi, int inode_lo, int inode_p1, int amount)
632 {
633     struct vfs *vfsp;
634
635     if (!afs_suser(NULL))
636         return EPERM;
637     vfsp = vfs_devsearch(dev, VFS_FSTYPE_ANY);
638     if (!vfsp) {
639         return ENXIO;
640     }
641
642     if (vfsp->vfs_fstype == xfs_fstype) {
643         ino_t inode;
644         inode = inode_hi;
645         inode <<= 32;
646         inode |= inode_lo;
647         return xfs_iincdec64(vfsp, inode, inode_p1, amount);
648     }
649     return ENXIO;
650 }
651
652 int
653 afs_syscall_idec64(int dev, int inode_hi, int inode_lo, int inode_p1)
654 {
655     return iincdec64(dev, inode_hi, inode_lo, inode_p1, -1);
656 }
657
658 int
659 afs_syscall_iinc64(int dev, int inode_hi, int inode_lo, int inode_p1)
660 {
661     return iincdec64(dev, inode_hi, inode_lo, inode_p1, 1);
662 }
663
664 struct iincargs {
665     sysarg_t dev;
666     sysarg_t inode;
667     sysarg_t inode_p1;
668 };
669
670 int
671 iinc(struct iincargs *uap, rval_t * rvp)
672 {
673     AFS_STATCNT(iinc);
674     return ENOTSUP;
675 }
676
677 int
678 idec(struct iincargs *uap, rval_t * rvp)
679 {
680     AFS_STATCNT(idec);
681     return ENOTSUP;
682 }
683
684 /* afs_syscall_ilistinode64
685  * Gathers up all required info for ListViceInodes in one system call.
686  */
687 int
688 afs_syscall_ilistinode64(int dev, int inode_hi, int inode_lo, int datap,
689                          int datalenp)
690 {
691     int code = 0;
692     ino_t inode;
693     xfs_inode_t *ip;
694     vfs_t *vfsp;
695     vnode_t *vp;
696     struct vattr vattr;
697     afs_xfs_attr_t attrs;
698     int length;
699     i_list_inode_t data;
700     int idatalen;
701
702     if (!afs_suser(NULL))
703         return EPERM;
704     vfsp = vfs_devsearch(dev, xfs_fstype);
705     if (!vfsp) {
706         return ENXIO;
707     }
708
709     AFS_COPYIN((char *)datalenp, &idatalen, sizeof(int), code);
710     if (idatalen < sizeof(i_list_inode_t)) {
711         idatalen = sizeof(i_list_inode_t);
712         AFS_COPYOUT((char *)datalenp, (char *)&idatalen, sizeof(int), code);
713         return E2BIG;
714     }
715     idatalen = sizeof(i_list_inode_t);
716     AFS_COPYOUT((char *)datalenp, (char *)&idatalen, sizeof(int), code);
717
718     AFS_COPYIN((char *)datap, (char *)&data, sizeof(i_list_inode_t), code);
719     if (data.ili_version != AFS_XFS_ILI_VERSION) {
720         data.ili_version = AFS_XFS_ILI_VERSION;
721         AFS_COPYOUT((char *)&data, (char *)datap, sizeof(i_list_inode_t),
722                     code);
723         return EINVAL;
724     }
725
726
727     inode = inode_hi;
728     inode <<= 32;
729     inode |= inode_lo;
730     code =
731         xfs_iget((((struct mount *)((vfsp)->vfs_bh.bh_first)->bd_pdata)),
732                  (void *)0, (xfs_ino_t) inode, XFS_ILOCK_SHARED, &ip,
733                  (daddr_t) 0);
734     if (code)
735         return code;
736
737     vp = XFS_ITOV(ip);
738     xfs_iunlock(ip, XFS_ILOCK_SHARED);
739
740     length = SIZEOF_XFS_ATTR_T;
741
742     AFS_VOP_ATTR_GET(vp, AFS_XFS_ATTR, (char *)&attrs, &length, ATTR_ROOT,
743                      OSI_GET_CURRENT_CRED(), code);
744     if (code) {
745         code = EPERM;
746     }
747
748     if (!code) {
749         if (attrs.at_attr_version != AFS_XFS_ATTR_VERS)
750             code = EINVAL;
751     }
752
753     if (!code) {
754         vattr.va_mask = AT_STAT;
755         AFS_VOP_GETATTR(vp, &vattr, 0, OSI_GET_CURRENT_CRED(), code);
756     }
757
758     if (!code) {
759         memset(&data, 0, sizeof(data));
760         data.ili_info.inodeNumber = inode;
761         data.ili_info.byteCount = vattr.va_size;
762         data.ili_info.linkCount = (vattr.va_mode & AFS_XFS_MODE_LINK_MASK);
763         memcpy((char *)data.ili_info.param, (char *)attrs.at_param,
764                sizeof(data.ili_info.param));
765         data.ili_attr_version = attrs.at_attr_version;
766         data.ili_name_version = attrs.at_name_version;
767         data.ili_tag = attrs.at_tag;
768         data.ili_pino = attrs.at_pino;
769         data.ili_vno = vattr.va_uid;
770         data.ili_magic = vattr.va_gid;
771         AFS_COPYOUT((char *)&data, (char *)datap, sizeof(data), code);
772     }
773     VN_RELE(vp);
774     return code;
775 }