fix-missattributed-loff-t-ifdef-20010207
[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  * afsdptoip
15  * afsiptodp
16  * afsidestroy
17  * getinode
18  * igetinode
19  * xfs_getinode
20  * xfs_igetinode
21  * icreate
22  * afs_syscall_icreate
23  * xfs_icreatename64
24  * afs_syscall_icreatename64
25  * iopenargs64
26  * afs_syscall_iopen
27  * iopen
28  * iopen64
29  * efs_iincdec
30  * xfs_iincdec64
31  * iincdec64
32  * afs_syscall_idec64
33  * afs_syscall_iinc64
34  * iincdec
35  * iinc
36  * idec
37  * afs_syscall_iincdec
38  * afs_syscall_ilistinode64
39  *
40  */
41
42 #include "../afs/param.h"       /* Should be always first */
43 #include "../afs/sysincludes.h" /* Standard vendor system headers */
44 #include "../afs/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  * copy disk inode to incore inode and vice-versa
61  */
62 void
63 afsdptoip(struct efs_dinode *dp, struct inode *ip)
64 {
65         struct afsparms *ap;
66
67         ip->i_afs = kmem_alloc(sizeof(struct afsparms), KM_SLEEP);
68         osi_Assert(ip->i_version == EFS_IVER_AFSSPEC
69                || ip->i_version == EFS_IVER_AFSINO); 
70         ap = (struct afsparms *)ip->i_afs;
71         /* vicep1 is VOLid */
72         ap->vicep1 = dmag(dp, 0) << 24 | dmag(dp, 1) << 16 |
73                                           dmag(dp, 2) << 8 | dmag(dp, 3) << 0;
74                                            
75         if (ip->i_version == EFS_IVER_AFSSPEC) {
76                 ap->vicep3 = dmag(dp, 8);       /* Type */
77                 ap->vicep4 = dmag(dp, 4) << 24 | dmag(dp, 5) << 16 |
78                                           dmag(dp, 6) << 8 | dmag(dp, 7) << 0;
79
80         } else {
81                 /* vnode number */
82                 ap->vicep2 = dmag(dp, 4) << 16 |
83                                           dmag(dp, 5) << 8 | dmag(dp, 6) << 0;
84                 /* disk uniqifier */
85                 ap->vicep3 = dmag(dp, 7) << 16 |
86                                           dmag(dp, 8) << 8 | dmag(dp, 9) << 0;
87                 /* data version */
88                 ap->vicep4 = dmag(dp, 10) << 16 |
89                                           dmag(dp, 11) << 8 | (dp)->di_spare;
90         }
91 }
92
93 void
94 afsiptodp(struct inode *ip, struct efs_dinode *dp)
95 {
96         struct afsparms *ap;
97
98         if (ip->i_afs == NULL)
99                 return;
100
101         osi_Assert(ip->i_version == EFS_IVER_AFSSPEC
102                || ip->i_version == EFS_IVER_AFSINO); 
103         ap = (struct afsparms *)ip->i_afs;
104         /* vicep1 is VOLid */
105         dmag(dp, 0) = ap->vicep1 >> 24;
106         dmag(dp, 1) = ap->vicep1 >> 16;
107         dmag(dp, 2) = ap->vicep1 >> 8;
108         dmag(dp, 3) = ap->vicep1 >> 0;
109                                            
110         if (ip->i_version == EFS_IVER_AFSSPEC) {
111                 /* Type */
112                 dmag(dp, 8) = ap->vicep3;
113                 /* ParentId */
114                 dmag(dp, 4) = ap->vicep4 >> 24;
115                 dmag(dp, 5) = ap->vicep4 >> 16;
116                 dmag(dp, 6) = ap->vicep4 >> 8;
117                 dmag(dp, 7) = ap->vicep4 >> 0;
118         } else {
119                 /* vnode number */
120                 dmag(dp, 4) = ap->vicep2 >> 16;
121                 dmag(dp, 5) = ap->vicep2 >> 8;
122                 dmag(dp, 6) = ap->vicep2 >> 0;
123                 /* disk uniqifier */
124                 dmag(dp, 7) = ap->vicep3 >> 16;
125                 dmag(dp, 8) = ap->vicep3 >> 8;
126                 dmag(dp, 9) = ap->vicep3 >> 0;
127                 /* data version */
128                 dmag(dp, 10) = ap->vicep4 >> 16;
129                 dmag(dp, 11) = ap->vicep4 >> 8;
130                 dp->di_spare = ap->vicep4 >> 0;
131         }
132 }
133
134 void
135 afsidestroy(struct inode *ip)
136 {
137         if (ip->i_afs) {
138                 kmem_free(ip->i_afs, sizeof(struct afsparms));
139                 ip->i_afs = NULL;
140         }
141 }
142
143 extern int efs_fstype;
144 #ifdef AFS_SGI_XFS_IOPS_ENV
145 extern int xfs_fstype;
146 #endif
147
148 int
149 getinode(struct vfs *vfsp, dev_t dev, ino_t inode, struct inode **ipp)
150 {
151     struct inode *ip;
152     int error;
153
154     if (!vfsp) {
155 #ifdef AFS_SGI65_ENV
156         vfsp = vfs_devsearch(dev, efs_fstype);
157 #else
158         vfsp = vfs_devsearch(dev);
159 #endif
160         if (!vfsp) {
161             return ENXIO;
162         }
163     }
164 #ifndef AFS_SGI65_ENV
165     if (vfsp->vfs_fstype != efs_fstype)
166         return ENOSYS;
167 #endif
168
169     if (error = iget((((struct mount *)((vfsp)->vfs_bh.bh_first)->bd_pdata)), 
170                      (unsigned int)(inode&0xffffffff), &ip)) {
171         return error;
172     }
173     *ipp = ip;
174     return 0;
175 }
176
177 int
178 igetinode(struct vfs *vfsp, dev_t dev, ino_t inode, struct inode **ipp)
179 {
180     struct inode *ip;
181     int error;
182
183     AFS_STATCNT(igetinode);
184     if (error = getinode(vfsp, dev, inode, &ip))
185         return error;
186     *ipp = ip;
187     return 0;
188 }
189
190 int XFS_IGET_EPOS;
191 ino_t XFS_IGET_INO;
192 dev_t XFS_IGET_DEV;
193 #define SET_XFS_ERROR(POS, DEV, INO) \
194         XFS_IGET_EPOS = (POS), XFS_IGET_DEV = (DEV), XFS_IGET_INO = (INO)
195
196 int xfs_getinode(struct vfs *vfsp, dev_t dev, ino_t inode,
197                  struct xfs_inode **ipp)
198 {
199     struct xfs_inode *ip;
200     int error;
201
202     if (!vfsp) {
203 #ifdef AFS_SGI65_ENV
204         vfsp = vfs_devsearch(dev, xfs_fstype);
205 #else
206         vfsp = vfs_devsearch(dev);
207 #endif
208         if (!vfsp) {
209             SET_XFS_ERROR(1, dev, inode);
210             return ENXIO;
211         }
212     }
213 #ifndef AFS_SGI65_ENV
214     if (vfsp->vfs_fstype != xfs_fstype) {
215         SET_XFS_ERROR(2, vfsp->vfs_dev, inode);
216         return ENOSYS;
217     }
218 #endif
219
220     if (error = xfs_iget((((struct mount *)
221                            ((vfsp)->vfs_bh.bh_first)->bd_pdata)),
222                          (void*)0, (xfs_ino_t)inode, 
223                          XFS_ILOCK_SHARED, &ip, (daddr_t)0)) {
224         SET_XFS_ERROR(3, vfsp->vfs_dev, inode);
225         return error;
226     }
227
228     *ipp = ip;
229     return 0;
230 }
231
232 /* xfs_igetinode now returns an unlocked inode. This is fine, since we
233  * have a refcount on the holding vnode.
234  */
235 int xfs_igetinode(struct vfs *vfsp, dev_t dev, ino_t inode,
236                   struct xfs_inode **ipp)
237 {
238     struct xfs_inode *ip;
239     vnode_t *vp;
240     vattr_t vattr;
241     int error;
242
243     AFS_STATCNT(igetinode);
244
245     *ipp = NULL;
246     if (error = xfs_getinode(vfsp, dev, inode, &ip)) {
247         return error;
248     }
249
250     xfs_iunlock(ip, XFS_ILOCK_SHARED);
251     vp = XFS_ITOV(ip);
252     vattr.va_mask = AT_STAT;
253     AFS_VOP_GETATTR(vp, &vattr, 0, OSI_GET_CURRENT_CRED(), error);
254     if (error) {
255         SET_XFS_ERROR(4, vp->v_vfsp->vfs_dev, inode);
256         VN_RELE(vp);
257         return error;
258     }
259     if (vattr.va_nlink == 0 || vattr.va_type != VREG) {
260         SET_XFS_ERROR(5, vp->v_vfsp->vfs_dev, inode);
261         VN_RELE(vp);
262         return ENOENT;
263     }
264
265     *ipp = ip;
266     return 0;
267 }
268
269 /**************************************************************************
270  * inode creation routines.
271  *
272  ***************************************************************************/
273 struct icreateargs {
274         sysarg_t        dev;
275         sysarg_t        near_inode;
276         sysarg_t        param1;
277         sysarg_t        param2;
278         sysarg_t        param3;
279         sysarg_t        param4;
280 };
281
282 /* EFS only fs suite uses this entry point - icreate in afssyscalls.c. */
283 #ifdef AFS_SGI_EFS_IOPS_ENV
284 int
285 icreate(struct icreateargs *uap, rval_t *rvp)
286 {
287     AFS_STATCNT(icreate);
288     return(afs_syscall_icreate(uap->dev, uap->near_inode, uap->param1,
289                                uap->param2, uap->param3, uap->param4, rvp));
290 }
291
292 int
293 afs_syscall_icreate(dev, near_inode, param1, param2, param3, param4, rvp)
294 afs_uint32 dev, near_inode, param1, param2, param3, param4;
295 rval_t *rvp;
296 {
297         struct inode *ip, *newip;
298         struct afsparms *ap;
299         struct cred cr;
300         int error;
301
302         AFS_STATCNT(afs_syscall_icreate);
303         if (!afs_suser())
304                 return EPERM;
305
306         if (error = getinode(0, (dev_t)dev, 2, &ip))
307                 return error;
308
309         cr.cr_uid = 0;
310         cr.cr_gid = -2;
311         if (error = efs_ialloc(ip, IFREG, 1, NODEV, &newip, &cr)) {     
312             iput(ip);
313             return error;
314         }
315         iput(ip);
316         osi_Assert(newip);
317         newip->i_flags |= IACC|IUPD|ICHG;
318
319         osi_Assert(newip->i_afs == NULL);
320         newip->i_afs = kmem_alloc(sizeof(struct afsparms), KM_SLEEP);
321         if (param2 == INODESPECIAL)
322                 newip->i_version = EFS_IVER_AFSSPEC;
323         else
324                 newip->i_version = EFS_IVER_AFSINO;
325         ap = (struct afsparms *)newip->i_afs;
326         ap->vicep1 = param1;    /* VOLid */
327         ap->vicep2 = param2;    /* Vnode # */
328         ap->vicep3 = param3;    /* SPEC:type INO:vnode uniq */
329         ap->vicep4 = param4;    /* SPEC:parentId INO:data version */
330         rvp->r_val1 = newip->i_number;
331         iput(newip);
332         return 0;
333 }
334 #endif /* AFS_SGI_EFS_IOPS_ENV */
335
336 #ifdef AFS_SGI_XFS_IOPS_ENV
337 /* inode creation routines for icreatename64 entry point. Use for EFS/XFS
338  * fileserver suite.  For XFS, create a name in the namespace as well as the
339  * inode. For EFS, just call the original routine.
340  */
341
342 #include <afs/xfsattrs.h>
343 #include <sys/attributes.h>
344
345 extern char *int_to_base64(char *, int);
346
347 /* Lock against races creating/removing directory - vos zap RO, vos create RW*/
348 kmutex_t afs_vol_create_lock;
349 int afs_vol_create_lock_inited = 0;
350 #define AFS_LOCK_VOL_CREATE() { \
351         if (!afs_vol_create_lock_inited) { \
352             mutex_init(&afs_vol_create_lock, MUTEX_DEFAULT, \
353                        "afs_vol_create_lock"); \
354             afs_vol_create_lock_inited = 1; \
355         } \
356         mutex_enter(&afs_vol_create_lock); \
357                                  }
358 #define AFS_UNLOCK_VOL_CREATE() mutex_exit(&afs_vol_create_lock)
359
360
361 /* xfs_icreatename64
362  * Create an AFS inode in the XFS name space. If required create the proper
363  * containing directory. See sys/xfsattrs.h for the details on the naming
364  * conventions and the usage of file and directory attributes.
365  *
366  * The inode parameters are stored in an XFS attribute called "AFS". In
367  * addition gid is set to XFS_VICEMAGIC and uid is set to the low 31 bits
368  * of the RW volume id. This is so inode verification in iinc and idec
369  * don't need to get the attribute. Note that only the low 31 bits are set.
370  * This is because chmod only accepts up to MAX_UID and chmod is used
371  * to correct these values in xfs_ListViceInodes.
372  */
373 int
374 xfs_icreatename64(struct vfs *vfsp, int datap, int datalen,
375                   afs_inode_params_t params, ino_t *inop)
376 {
377 #define AFS_PNAME_SIZE 16
378     char path[64];
379     char name[64];
380     b64_string_t stmp1, stmp2;
381     afs_xfs_attr_t attrs;
382     struct vattr vattr;
383     int name_version = AFS_XFS_NAME_VERS;
384     int code = 0, unused;
385     struct vnode *vp;
386     struct vnode *dvp;
387     int rw_vno;         /* volume ID of parent volume */
388     int i;
389     int createdDir = 0;
390     size_t junk;
391     char *s;
392
393
394     /* Get vnode for directory which will contain new inode. */
395     if (datalen >= AFS_PNAME_SIZE)
396         return E2BIG;
397
398     AFS_COPYINSTR((char*)datap, path, AFS_PNAME_SIZE-1, &junk, unused);
399     if (*path != '/') {
400         return EINVAL;
401     }
402
403     rw_vno = (params[1] == INODESPECIAL) ? params[3] : params[0];
404
405     /* directory name */
406     strcat(path, "/");
407     strcat(path, AFS_INODE_DIR_NAME);
408     strcat(path, int_to_base64(stmp1, rw_vno));
409
410     if (params[1] == INODESPECIAL)
411         AFS_LOCK_VOL_CREATE();
412
413     code = gop_lookupname(path, AFS_UIOSYS, FOLLOW, (struct vnode **) 0, &dvp);
414     if (code == ENOENT) {
415         /* Maybe it's an old directory name format. */
416         AFS_COPYINSTR((char*)datap, name, AFS_PNAME_SIZE-1, &junk, unused);
417         strcat(name, "/.");
418         strcat(name, int_to_base64(stmp1, rw_vno));
419         code = gop_lookupname(name, AFS_UIOSYS, FOLLOW, (struct vnode **) 0,
420                               &dvp);
421         if (!code) {
422             /* Use old name format. */
423             strcpy(path, name);
424             name_version = AFS_XFS_NAME_VERS1;
425         }
426     }
427
428     if (code == ENOENT) {
429         afs_xfs_dattr_t dattr;
430         /* make directory. */
431         
432         code = AFS_VN_OPEN(path, UIO_SYSSPACE, FCREAT|FEXCL, 0700, &dvp,
433                            CRMKDIR);
434         if (code) {
435             if (code == EEXIST) {
436                 /* someone beat us to it? */
437                 code = gop_lookupname(path, AFS_UIOSYS, 0, (struct vnode **) 0,
438                                       &dvp);
439             }
440             if (code) {
441                 AFS_UNLOCK_VOL_CREATE();
442                 return code;
443             }
444         }
445         else
446             createdDir = 1;
447         bzero((char*)&dattr, sizeof(dattr));
448         dattr.atd_version = AFS_XFS_ATD_VERS;
449         dattr.atd_volume = rw_vno;
450         AFS_VOP_ATTR_SET(dvp, AFS_XFS_DATTR, (char*)&dattr,
451                          SIZEOF_XFS_DATTR_T,
452                          ATTR_ROOT|ATTR_CREATE, OSI_GET_CURRENT_CRED(), code);
453         if (code) {
454             VN_RELE(dvp);
455             if (createdDir)
456                 (void) vn_remove(path, UIO_SYSSPACE, RMDIRECTORY);
457             AFS_UNLOCK_VOL_CREATE();
458             return code;
459         }
460     }
461
462     vattr.va_mask = AT_FSID|AT_NODEID; /* gets a guick return using FSID*/
463     AFS_VOP_GETATTR(dvp, &vattr, 0, OSI_GET_CURRENT_CRED(), code);
464     if (code) {
465         VN_RELE(dvp);
466         return code;
467     }
468
469     bzero((char*)&attrs, sizeof(attrs));
470     attrs.at_pino = vattr.va_nodeid;
471     VN_RELE(dvp);
472         
473     /* Create the desired file. Use up to ten tries to create a unique name. */
474     (void) strcpy(name, path);
475     (void) strcat(name, "/.");
476     (void) strcat(name, int_to_base64(stmp2, params[2]));
477     s = &name[strlen(name)];
478
479     attrs.at_tag = 0;    /* Initial guess at a unique tag. */
480     for (i=0; i<10; i++) {
481             *s = '\0';
482             strcat(s, ".");
483             strcat(s, int_to_base64(stmp1, attrs.at_tag));
484         code = AFS_VN_OPEN(name, UIO_SYSSPACE, FCREAT|FEXCL, 0600, &vp,
485                            CRCREAT);
486         if (!code || code != EEXIST)
487             break;
488
489         attrs.at_tag ++ ;
490     }
491     /* Unlock the creation process since the directory now has a file in it.*/
492     if (params[1] == INODESPECIAL)
493         AFS_UNLOCK_VOL_CREATE();
494         
495     if (!code) {
496         /* Set attributes. */
497         bcopy((char*)params, (char*)attrs.at_param,
498               sizeof(afs_inode_params_t));
499         attrs.at_attr_version = AFS_XFS_ATTR_VERS;
500         attrs.at_name_version = name_version;
501         AFS_VOP_ATTR_SET(vp, AFS_XFS_ATTR, (char*)&attrs,
502                          SIZEOF_XFS_ATTR_T,
503                          ATTR_ROOT|ATTR_CREATE, OSI_GET_CURRENT_CRED(),
504                          code);
505         if (!code) {
506             vattr.va_mode = 1;
507             vattr.va_uid = AFS_XFS_VNO_CLIP(params[0]);
508             vattr.va_gid = XFS_VICEMAGIC;
509             vattr.va_mask = AT_MODE | AT_UID | AT_GID;
510             AFS_VOP_SETATTR(vp, &vattr, 0, OSI_GET_CURRENT_CRED(), code);
511         }
512         if (!code) {
513             vattr.va_mask = AT_NODEID;
514             AFS_VOP_GETATTR(vp, &vattr, 0, OSI_GET_CURRENT_CRED(), code);
515         }
516         if (!code)
517             *inop = vattr.va_nodeid;
518         VN_RELE(vp);
519     }
520
521     if (code) {
522         /* remove partially created file. */
523         (void) vn_remove(name, UIO_SYSSPACE, RMFILE);
524         
525         /* and directory if volume special file. */
526         if (createdDir) {
527             AFS_LOCK_VOL_CREATE();
528             (void) vn_remove(path, UIO_SYSSPACE, RMDIRECTORY);
529             AFS_UNLOCK_VOL_CREATE();
530         }
531     }
532     return code;
533 }
534
535 /* afs_syscall_icreatename64
536  * This is the icreatename64 entry point used by the combined EFS/XFS
537  * fileserver suite. The datap and datalen do not need to be set for EFS.
538  */
539 int
540 afs_syscall_icreatename64(int dev, int datap, int datalen, int paramp,
541                           int inop)
542 {
543     struct vfs *vfsp;
544     afs_inode_params_t param;
545     int code;
546     rval_t rval;
547     ino_t ino;
548
549
550     if (!afs_suser())
551         return EPERM;
552
553 #ifdef AFS_SGI65_ENV
554     vfsp = vfs_devsearch(dev, VFS_FSTYPE_ANY);
555 #else
556     vfsp = vfs_devsearch(dev);
557 #endif
558     if (vfsp == NULL) {
559         return ENXIO;
560     }
561
562     AFS_COPYIN((char*)paramp, (char*)param, sizeof(afs_inode_params_t), code);
563     if (vfsp->vfs_fstype == xfs_fstype) {
564         code =  xfs_icreatename64(vfsp, datap, datalen, param, &ino);
565         if (code)
566             return code;
567         else {
568             AFS_COPYOUT((char*)&ino, (char*)inop, sizeof(ino_t), code);
569             return code;
570         }
571     }
572     else if (vfsp->vfs_fstype == efs_fstype) {
573         code = afs_syscall_icreate(dev, 0, param[0], param[1], param[2],
574                                    param[3], &rval);
575         if (code)
576             return code;
577         else {
578             ino = (ino_t)rval.r_val1;
579             AFS_COPYOUT((char*)&ino, (char*)inop, sizeof(ino_t), code);
580             return code;
581         }
582     }
583     return ENXIO;
584 }
585 #endif /* AFS_SGI_XFS_IOPS_ENV */
586
587 /*
588  * iopen system calls -- open an inode for reading/writing
589  * Restricted to super user.
590  * Any IFREG files.
591  * The original EFS only system calls are still present in the kernel for
592  * in case a kernel upgrade is done for a fix, but the EFS fileserver is
593  * still in use.
594  */
595 struct iopenargs {
596         sysarg_t        dev;
597         sysarg_t        inode;
598         sysarg_t        usrmod;
599 };
600
601 #ifdef AFS_SGI_XFS_IOPS_ENV
602 struct iopenargs64 {
603         sysarg_t        dev;
604         sysarg_t        inode_hi;
605         sysarg_t        inode_lo;
606         sysarg_t        usrmod;
607 };
608
609 #ifdef AFS_SGI65_ENV
610 int
611 afs_syscall_iopen(int dev, ino_t inode, int usrmod, rval_t *rvp)
612 {
613         struct file *fp;
614         int fd;
615         int error;
616         struct vfs* vfsp;
617         struct vnode *vp;
618
619         AFS_STATCNT(afs_syscall_iopen);
620         if (!afs_suser())
621                 return EPERM;
622         vfsp = vfs_devsearch(dev, xfs_fstype);
623         if (!vfsp)
624             vfsp = vfs_devsearch(dev, efs_fstype);
625         if (!vfsp)
626             return ENXIO;
627
628 #ifdef AFS_SGI_EFS_IOPS_ENV
629         if (vfsp->vfs_fstype == efs_fstype) {
630             struct inode *ip;
631             if (error = igetinode(vfsp, (dev_t)dev, inode, &ip))
632                 return error;
633             vp = EFS_ITOV(ip);
634             if (error = vfile_alloc((usrmod+1) & (FMASK), &fp, &fd)) {
635                 iput(ip);
636                 return error;
637             }
638             iunlock(ip);
639         }
640         else 
641 #endif /* AFS_SGI_EFS_IOPS_ENV */
642           if (vfsp->vfs_fstype == xfs_fstype) {
643               struct xfs_inode *xip;
644               if (error = xfs_igetinode(vfsp, (dev_t)dev, inode, &xip))
645                   return error;
646               vp = XFS_ITOV(xip);
647               if (error = vfile_alloc((usrmod+1) & (FMASK), &fp, &fd)) {
648                   VN_RELE(vp);
649                   return error;
650               }
651           }
652           else {
653               osi_Panic("afs_syscall_iopen: bad fstype = %d\n",
654                         vfsp->vfs_fstype);
655           }
656         vfile_ready(fp, vp);
657         rvp->r_val1 = fd;
658         return 0;
659 }
660 #else
661 /* afs_syscall_iopen
662  * EFS/XFS version vectors to correct code based vfs_fstype. Expects a
663  * 64 bit inode number.
664  */
665 int
666 afs_syscall_iopen(int dev, ino_t inode, int usrmod, rval_t *rvp)
667 {
668         struct file *fp;
669         int fd;
670         int error;
671         struct vfs* vfsp;
672
673         AFS_STATCNT(afs_syscall_iopen);
674         if (!afs_suser())
675                 return EPERM;
676         vfsp = vfs_devsearch(dev);
677         if (!vfsp) {
678             return ENXIO;
679         }
680
681         if (vfsp->vfs_fstype == xfs_fstype) {
682             struct xfs_inode *xip;
683             struct vnode *vp;
684             if (error = xfs_igetinode(vfsp, (dev_t)dev, inode, &xip))
685                 return error;
686             vp = XFS_ITOV(xip);
687             if (error = falloc(vp, (usrmod+1) & (FMASK), &fp, &fd)) {
688                 VN_RELE(vp);
689                 return error;
690             }
691         }
692         else if (vfsp->vfs_fstype == efs_fstype) {
693             struct inode *ip;
694             if (error = igetinode(vfsp, (dev_t)dev, inode, &ip))
695                 return error;
696             if (error = falloc(EFS_ITOV(ip), (usrmod+1) & (FMASK), &fp, &fd)) {
697                 iput(ip);
698                 return error;
699             }
700             iunlock(ip);
701         }
702         else {
703             osi_Panic("afs_syscall_iopen: bad fstype = %d\n",
704                       vfsp->vfs_fstype);
705         }
706         fready(fp);
707         rvp->r_val1 = fd;
708         return 0;
709 }
710 #endif /* AFS_SGI65_ENV */
711
712 int
713 iopen(struct iopenargs *uap, rval_t *rvp)
714 {
715      AFS_STATCNT(iopen);
716      return (afs_syscall_iopen(uap->dev, (ino_t)uap->inode, uap->usrmod,
717                                rvp));
718 }
719
720 int
721 iopen64(struct iopenargs64 *uap, rval_t *rvp)
722 {
723      AFS_STATCNT(iopen);
724      return (afs_syscall_iopen(uap->dev,
725                                (ino_t)((uap->inode_hi<<32) | uap->inode_lo),
726                                uap->usrmod, rvp));
727 }
728
729 #else /* AFS_SGI_XFS_IOPS_ENV */
730 /* iopen/afs_syscall_iopen
731  *
732  * Original EFS only 32 bit iopen call.
733  */
734 int
735 iopen(struct iopenargs *uap, rval_t *rvp)
736 {
737      AFS_STATCNT(iopen);
738      return (afs_syscall_iopen(uap->dev, uap->inode, uap->usrmod, rvp));
739 }
740
741 int
742 afs_syscall_iopen(dev, inode, usrmod, rvp)
743 int dev, inode, usrmod;
744 rval_t *rvp;
745 {
746         struct file *fp;
747         struct inode *ip;
748         int fd;
749         int error;
750
751         AFS_STATCNT(afs_syscall_iopen);
752         if (!afs_suser())
753                 return EPERM;
754         if (error = igetinode(0, (dev_t)dev, inode, &ip))
755                 return error;
756         if (error = falloc(EFS_ITOV(ip), (usrmod+1) & (FMASK), &fp, &fd)) {
757                 iput(ip);
758                 return error;
759         }
760         iunlock(ip);
761         rvp->r_val1 = fd;
762 #ifdef  AFS_SGI53_ENV
763         fready(fp);
764 #endif
765         return 0;
766 }
767 #endif /* AFS_SGI_XFS_IOPS_ENV */
768
769 /*
770  * Support for iinc() and idec() system calls--increment or decrement
771  * count on inode.
772  * Restricted to super user.
773  * Only VICEMAGIC type inodes.
774  */
775 #ifdef AFS_SGI_XFS_IOPS_ENV
776 #ifdef AFS_SGI_EFS_IOPS_ENV
777 /* efs_iincdec
778  *
779  * XFS/EFS iinc/idec code for EFS. Uses 32 bit inode numbers. 
780  */
781 static int efs_iincdec(vfsp, inode, inode_p1, amount)
782 struct vfs *vfsp;
783 int inode, inode_p1, amount;
784 {
785     struct inode *ip;
786     int error;
787
788     if (error = igetinode(vfsp, NULL, inode, &ip))
789         return error;
790     
791     if (!IS_VICEMAGIC(ip))
792         error = EPERM;
793     else if (((struct afsparms *)ip->i_afs)->vicep1 != inode_p1)
794         error = ENXIO;
795     else {
796         ip->i_nlink += amount;
797         osi_Assert(ip->i_nlink >= 0);
798         if (ip->i_nlink == 0) {
799             CLEAR_VICEMAGIC(ip);
800             afsidestroy(ip);
801         }
802         ip->i_flags |= ICHG;
803     }
804     /* XXX sync write?? */
805     iput(ip);
806     return error;
807 }
808 #endif /* AFS_SGI_EFS_IOPS_ENV */
809
810 /* xfs_iincdec
811  *
812  * XFS/EFS iinc/idec code for EFS. Uses 64 bit inode numbers. 
813  */
814 static int xfs_iincdec64(struct vfs *vfsp, ino_t inode, int inode_p1,
815                          int amount)
816 {
817     vnode_t *vp;
818     xfs_inode_t *ip;
819     int code = 0;
820     afs_xfs_attr_t attrs;
821     int length = SIZEOF_XFS_ATTR_T;
822     afs_xfs_dattr_t dattr;
823     struct vattr vattr;
824     int nlink;
825     int vol;
826     
827     code = xfs_iget((((struct mount *)((vfsp)->vfs_bh.bh_first)->bd_pdata)),
828                     (void*)0, (xfs_ino_t)inode, XFS_ILOCK_SHARED, &ip, 
829                     (daddr_t)0);
830     if (code)
831         return code;
832
833     vp = XFS_ITOV(ip);
834     xfs_iunlock(ip, XFS_ILOCK_SHARED);
835     
836     vattr.va_mask = AT_GID | AT_UID | AT_MODE;
837     AFS_VOP_GETATTR(vp, &vattr, 0, OSI_GET_CURRENT_CRED(), code);
838     if (code) 
839         code = EPERM;
840
841     if (!code && (vattr.va_gid != XFS_VICEMAGIC))
842         code = EPERM;
843         
844     if (!code && (AFS_XFS_VNO_CLIP(inode_p1) != vattr.va_uid))
845         code = ENXIO;
846
847     if (code) {
848         VN_RELE(vp);
849         return code;
850     }
851
852     nlink = vattr.va_mode & AFS_XFS_MODE_LINK_MASK;
853     nlink += amount;
854     if (nlink > 07) {
855         code = EOVERFLOW;
856     }
857     if (nlink > 0) {
858         vattr.va_mode &= ~AFS_XFS_MODE_LINK_MASK;
859         vattr.va_mode |= nlink;
860         vattr.va_mask = AT_MODE;
861         AFS_VOP_SETATTR(vp, &vattr, 0, OSI_GET_CURRENT_CRED(), code);
862         VN_RELE(vp);
863         return code;
864     }
865     else {
866         char path[64];
867         b64_string_t stmp1, stmp2;
868         vnode_t *dvp;
869         xfs_inode_t *ip;
870             
871         length = SIZEOF_XFS_ATTR_T;
872         AFS_VOP_ATTR_GET(vp, AFS_XFS_ATTR, (char*)&attrs, &length,
873                                 ATTR_ROOT, OSI_GET_CURRENT_CRED(), code);
874         VN_RELE(vp);
875         if (!code) {
876             if (length != SIZEOF_XFS_ATTR_T
877                 || attrs.at_attr_version != AFS_XFS_ATTR_VERS)
878                 return EINVAL;
879         }
880         /* Get the vnode for the directory this file is in. */
881         if (!attrs.at_pino)
882             return ENOENT;
883
884         code = xfs_getinode(vp->v_vfsp, NULL, attrs.at_pino, &ip);
885         if (code)
886             return code;
887
888         dvp = XFS_ITOV(ip);
889         xfs_iunlock(ip, XFS_ILOCK_SHARED);
890
891         /* Verify directory attributes. */
892         length = SIZEOF_XFS_DATTR_T;
893         AFS_VOP_ATTR_GET(dvp, AFS_XFS_DATTR , (char*)&dattr, &length,
894                          ATTR_ROOT, OSI_GET_CURRENT_CRED(), code);
895         if (!code) {
896             if (length != SIZEOF_XFS_DATTR_T
897                 || dattr.atd_version != AFS_XFS_ATD_VERS)
898                 code = ENXIO;
899         }
900         if (code) {
901             VN_RELE(dvp);
902             return code;
903         }
904
905         strcpy(path, ".");
906         strcat(path, int_to_base64(stmp1, attrs.at_param[2]));
907         strcat(path, ".");
908         strcat(path, int_to_base64(stmp1, attrs.at_tag));
909             
910         AFS_VOP_REMOVE(dvp, path, OSI_GET_CURRENT_CRED(), code);
911                 
912         if (!code) {
913             int code2;
914             vattr.va_mask = AT_NLINK;
915             AFS_VOP_GETATTR(dvp, &vattr, 0, OSI_GET_CURRENT_CRED(),
916                             code2);
917             if (!code2) {
918                 if (vattr.va_nlink == 2) {
919                     vnode_t *ddvp; /* parent of volume directory. */
920                     /* Try to remove the directory if this is a volume
921                      * special file. It's ok to fail.
922                      */
923                     AFS_VOP_LOOKUP(dvp, "..", &ddvp,
924                                    (struct pathname *)NULL,
925                                    0, OSI_GET_CURRENT_RDIR(),
926                                    OSI_GET_CURRENT_CRED(), code2);
927                     if (!code2) {
928                         VN_RELE(dvp);
929                         dvp = (vnode_t*)0;
930                         strcpy(path, ".");
931                         if (attrs.at_name_version == AFS_XFS_NAME_VERS2)
932                             strcpy(path, AFS_INODE_DIR_NAME);
933                         else 
934                             strcpy(path, ".");
935                         int_to_base64(stmp1,
936                                       (attrs.at_param[1] == INODESPECIAL) ?
937                                       attrs.at_param[3] : attrs.at_param[0]);
938                         strcat(path, stmp1);
939                         AFS_LOCK_VOL_CREATE();
940                         AFS_VOP_RMDIR(ddvp, path, OSI_GET_CURRENT_CDIR(),
941                                       OSI_GET_CURRENT_CRED(), code2);
942                         AFS_UNLOCK_VOL_CREATE();
943                         VN_RELE(ddvp);
944                     }
945                 }
946             }
947         }
948         if (dvp)
949             VN_RELE(dvp);
950     }
951     return code;
952 }
953
954 int
955 iincdec64(int dev, int inode_hi, int inode_lo, int inode_p1, int amount)
956 {
957     struct vfs *vfsp;
958
959     if (!afs_suser())
960         return EPERM;
961 #ifdef AFS_SGI65_ENV
962     vfsp = vfs_devsearch(dev, VFS_FSTYPE_ANY);
963 #else
964     vfsp = vfs_devsearch(dev);
965 #endif
966     if (!vfsp) {
967         return ENXIO;
968     }
969
970     if (vfsp->vfs_fstype == xfs_fstype) {
971         ino_t inode;
972         inode = inode_hi;
973         inode <<= 32;
974         inode |= inode_lo;
975         return xfs_iincdec64(vfsp, inode, inode_p1, amount);
976     }
977 #ifdef AFS_SGI_EFS_IOPS_ENV
978     else if (vfsp->vfs_fstype == efs_fstype) {
979         return efs_iincdec(vfsp, inode_lo, inode_p1, amount);
980     }
981 #endif /* AFS_SGI_EFS_IOPS_ENV */
982     return ENXIO;
983 }
984
985 int
986 afs_syscall_idec64(int dev, int inode_hi, int inode_lo, int inode_p1)
987 {
988     return iincdec64(dev, inode_hi, inode_lo, inode_p1, -1);
989 }
990
991 int
992 afs_syscall_iinc64(int dev, int inode_hi, int inode_lo, int inode_p1)
993 {
994     return iincdec64(dev, inode_hi, inode_lo, inode_p1, 1);
995 }
996
997
998
999
1000 struct iincargs {
1001         sysarg_t        dev;
1002         sysarg_t        inode;
1003         sysarg_t        inode_p1;
1004 };
1005
1006 #ifdef AFS_SGI65_ENV
1007 int iinc(struct iincargs *uap, rval_t *rvp) {
1008     AFS_STATCNT(iinc);
1009     return ENOTSUP;
1010 }
1011 int idec(struct iincargs *uap, rval_t *rvp) {
1012     AFS_STATCNT(idec);
1013     return ENOTSUP;
1014 }
1015 #else
1016 /* iincdec
1017  *
1018  * XFS/EFS iinc/idec entry points for EFS only fileservers.
1019  *
1020  */
1021 int
1022 iincdec(dev, inode, inode_p1, amount)
1023 int dev, inode, inode_p1, amount;
1024 {
1025     struct vfs *vfsp;
1026     
1027     if (!afs_suser())
1028         return EPERM;
1029     vfsp = vfs_devsearch(dev);
1030     if (!vfsp) {
1031         return ENXIO;
1032     }
1033     if (vfsp->vfs_fstype != efs_fstype)
1034         return ENOSYS;
1035
1036     return efs_iincdec(vfsp, inode, inode_p1, amount);
1037 }
1038 int
1039 iinc(struct iincargs *uap, rval_t *rvp) {
1040     AFS_STATCNT(iinc);
1041     return (iincdec(uap->dev, uap->inode, uap->inode_p1, 1));
1042 }
1043
1044 int
1045 idec(struct iincargs *uap, rval_t *rvp) {
1046     AFS_STATCNT(idec);
1047     return (iincdec(uap->dev, uap->inode, uap->inode_p1, -1));
1048 }
1049 #endif /* AFS_SGI65_ENV */
1050
1051 #else /* AFS_SGI_XFS_IOPS_ENV */
1052 /* afs_syscall_iincdec iinc idec
1053  *
1054  * These are the original EFS only entry points.
1055  */
1056 int
1057 afs_syscall_iincdec(dev, inode, inode_p1, amount)
1058 int dev, inode, inode_p1, amount;
1059 {
1060         struct inode *ip;
1061         int error = 0;
1062
1063         if (!afs_suser())
1064                 return EPERM;
1065         if (error = igetinode(0, (dev_t)dev, inode, &ip))
1066                 return error;
1067
1068         if (!IS_VICEMAGIC(ip))
1069             error = EPERM;
1070         else if (((struct afsparms *)ip->i_afs)->vicep1 != inode_p1)
1071             error = ENXIO;
1072         else {
1073                 ip->i_nlink += amount;
1074                 osi_Assert(ip->i_nlink >= 0);
1075                 if (ip->i_nlink == 0) {
1076                     CLEAR_VICEMAGIC(ip);
1077                     afsidestroy(ip);
1078                 }
1079                 ip->i_flags |= ICHG;
1080         }
1081         /* XXX sync write?? */
1082         iput(ip);
1083         return error;
1084 }
1085
1086 struct iincargs {
1087         sysarg_t        dev;
1088         sysarg_t        inode;
1089         sysarg_t        inode_p1;
1090 };
1091
1092 int
1093 iinc(struct iincargs *uap, rval_t *rvp) {
1094     AFS_STATCNT(iinc);
1095     return (afs_syscall_iincdec(uap->dev, uap->inode, uap->inode_p1, 1));
1096 }
1097
1098 int
1099 idec(struct iincargs *uap, rval_t *rvp) {
1100     AFS_STATCNT(idec);
1101     return (afs_syscall_iincdec(uap->dev, uap->inode, uap->inode_p1, -1));
1102 }
1103 #endif /* AFS_SGI_XFS_IOPS_ENV */
1104
1105 #ifdef AFS_SGI_XFS_IOPS_ENV
1106 /* afs_syscall_ilistinode64
1107  * Gathers up all required info for ListViceInodes in one system call.
1108  */
1109 int
1110 afs_syscall_ilistinode64(int dev, int inode_hi, int inode_lo,
1111                          int datap, int datalenp)
1112 {
1113     int code = 0;
1114     ino_t inode;
1115     xfs_inode_t *ip;
1116     vfs_t *vfsp;
1117     vnode_t *vp;
1118     struct vattr vattr;
1119     afs_xfs_attr_t attrs;
1120     int length;
1121     i_list_inode_t data;
1122     int idatalen;
1123
1124     if (!afs_suser())
1125         return EPERM;
1126 #ifdef AFS_SGI65_ENV
1127     vfsp = vfs_devsearch(dev, xfs_fstype);
1128 #else
1129     vfsp = vfs_devsearch(dev);
1130 #endif
1131     if (!vfsp) {
1132         return ENXIO;
1133     }
1134 #ifndef AFS_SGI65_ENV
1135     if (vfsp->vfs_fstype != xfs_fstype)
1136         return ENOSYS;
1137 #endif
1138
1139     AFS_COPYIN((char*)datalenp, &idatalen, sizeof(int), code);
1140     if (idatalen < sizeof(i_list_inode_t)) {
1141         idatalen = sizeof(i_list_inode_t);
1142         AFS_COPYOUT((char*)datalenp, (char*)&idatalen, sizeof(int), code);
1143         return E2BIG;
1144     }
1145     idatalen = sizeof(i_list_inode_t);
1146     AFS_COPYOUT((char*)datalenp, (char*)&idatalen, sizeof(int), code);
1147
1148     AFS_COPYIN((char*)datap, (char*)&data, sizeof(i_list_inode_t), code);
1149     if (data.ili_version != AFS_XFS_ILI_VERSION) {
1150         data.ili_version = AFS_XFS_ILI_VERSION;
1151         AFS_COPYOUT((char*)&data, (char*)datap, sizeof(i_list_inode_t), code);
1152         return EINVAL;
1153     }
1154     
1155     
1156     inode = inode_hi;
1157     inode <<= 32;
1158     inode |= inode_lo;
1159     code = xfs_iget((((struct mount *)((vfsp)->vfs_bh.bh_first)->bd_pdata)), 
1160                     (void*)0, (xfs_ino_t)inode,
1161                     XFS_ILOCK_SHARED, &ip, (daddr_t)0);
1162     if (code)
1163         return code;
1164     
1165     vp = XFS_ITOV(ip);
1166     xfs_iunlock(ip, XFS_ILOCK_SHARED);
1167     
1168     length = SIZEOF_XFS_ATTR_T;
1169
1170     AFS_VOP_ATTR_GET(vp, AFS_XFS_ATTR, (char*)&attrs, &length,
1171                             ATTR_ROOT, OSI_GET_CURRENT_CRED(), code);
1172     if (code) { 
1173         code = EPERM;
1174     }
1175
1176     if (!code) {
1177         if (attrs.at_attr_version != AFS_XFS_ATTR_VERS)
1178             code = EINVAL;
1179     }
1180     
1181     if (!code) {
1182         vattr.va_mask = AT_STAT;
1183         AFS_VOP_GETATTR(vp, &vattr, 0, OSI_GET_CURRENT_CRED(), code);
1184     }
1185     
1186     if (!code) {
1187         bzero((char*)&data, sizeof(data));
1188         data.ili_info.inodeNumber = inode;
1189         data.ili_info.byteCount = vattr.va_size;
1190         data.ili_info.linkCount = (vattr.va_mode & AFS_XFS_MODE_LINK_MASK);
1191         bcopy((char*)attrs.at_param, (char*)data.ili_info.param,
1192               sizeof(data.ili_info.param));
1193         data.ili_attr_version = attrs.at_attr_version;
1194         data.ili_name_version = attrs.at_name_version;
1195         data.ili_tag = attrs.at_tag;
1196         data.ili_pino = attrs.at_pino;
1197         data.ili_vno = vattr.va_uid;
1198         data.ili_magic = vattr.va_gid;
1199         AFS_COPYOUT((char*)&data, (char*)datap, sizeof(data), code);
1200     }
1201     VN_RELE(vp);
1202     return code;
1203 }
1204 #endif /* AFS_SGI_XFS_IOPS_ENV */