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 #else /* !AFS_SGI_EFS_IOPS_ENV */
 335 int
 336 afs_syscall_icreate(dev, near_inode, param1, param2, param3, param4, rvp)
 337 afs_uint32 dev, near_inode, param1, param2, param3, param4;
 338 rval_t *rvp;
 339 {
 340     return ENOSYS;
 341 }
 342 #endif /* AFS_SGI_EFS_IOPS_ENV */
 343
 344 #ifdef AFS_SGI_XFS_IOPS_ENV
 345 /* inode creation routines for icreatename64 entry point. Use for EFS/XFS
 346  * fileserver suite.  For XFS, create a name in the namespace as well as the
 347  * inode. For EFS, just call the original routine.
 348  */
 349
 350 #include <afs/xfsattrs.h>
 351 #include <sys/attributes.h>
 352
 353 extern char *int_to_base64(char *, int);
 354
 355 /* Lock against races creating/removing directory - vos zap RO, vos create RW*/
 356 kmutex_t afs_vol_create_lock;
 357 int afs_vol_create_lock_inited = 0;
 358 #define AFS_LOCK_VOL_CREATE() { \
 359         if (!afs_vol_create_lock_inited) { \
 360             mutex_init(&afs_vol_create_lock, MUTEX_DEFAULT, \
 361                        "afs_vol_create_lock"); \
 362             afs_vol_create_lock_inited = 1; \
 363         } \
 364         mutex_enter(&afs_vol_create_lock); \
 365                                  }
 366 #define AFS_UNLOCK_VOL_CREATE() mutex_exit(&afs_vol_create_lock)
 367
 368
 369 /* xfs_icreatename64
 370  * Create an AFS inode in the XFS name space. If required create the proper
 371  * containing directory. See sys/xfsattrs.h for the details on the naming
 372  * conventions and the usage of file and directory attributes.
 373  *
 374  * The inode parameters are stored in an XFS attribute called "AFS". In
 375  * addition gid is set to XFS_VICEMAGIC and uid is set to the low 31 bits
 376  * of the RW volume id. This is so inode verification in iinc and idec
 377  * don't need to get the attribute. Note that only the low 31 bits are set.
 378  * This is because chmod only accepts up to MAX_UID and chmod is used
 379  * to correct these values in xfs_ListViceInodes.
 380  */
 381 int
 382 xfs_icreatename64(struct vfs *vfsp, int datap, int datalen,
 383                   afs_inode_params_t params, ino_t *inop)
 384 {
 385 #define AFS_PNAME_SIZE 16
 386     char path[64];
 387     char name[64];
 388     b64_string_t stmp1, stmp2;
 389     afs_xfs_attr_t attrs;
 390     struct vattr vattr;
 391     int name_version = AFS_XFS_NAME_VERS;
 392     int code = 0, unused;
 393     struct vnode *vp;
 394     struct vnode *dvp;
 395     int rw_vno;         /* volume ID of parent volume */
 396     int i;
 397     int createdDir = 0;
 398     size_t junk;
 399     char *s;
 400
 401
 402     /* Get vnode for directory which will contain new inode. */
 403     if (datalen >= AFS_PNAME_SIZE)
 404         return E2BIG;
 405
 406     AFS_COPYINSTR((char*)datap, path, AFS_PNAME_SIZE-1, &junk, unused);
 407     if (*path != '/') {
 408         return EINVAL;
 409     }
 410
 411     rw_vno = (params[1] == INODESPECIAL) ? params[3] : params[0];
 412
 413     /* directory name */
 414     strcat(path, "/");
 415     strcat(path, AFS_INODE_DIR_NAME);
 416     strcat(path, int_to_base64(stmp1, rw_vno));
 417
 418     if (params[1] == INODESPECIAL)
 419         AFS_LOCK_VOL_CREATE();
 420
 421     code = gop_lookupname(path, AFS_UIOSYS, FOLLOW, (struct vnode **) 0, &dvp);
 422     if (code == ENOENT) {
 423         /* Maybe it's an old directory name format. */
 424         AFS_COPYINSTR((char*)datap, name, AFS_PNAME_SIZE-1, &junk, unused);
 425         strcat(name, "/.");
 426         strcat(name, int_to_base64(stmp1, rw_vno));
 427         code = gop_lookupname(name, AFS_UIOSYS, FOLLOW, (struct vnode **) 0,
 428                               &dvp);
 429         if (!code) {
 430             /* Use old name format. */
 431             strcpy(path, name);
 432             name_version = AFS_XFS_NAME_VERS1;
 433         }
 434     }
 435
 436     if (code == ENOENT) {
 437         afs_xfs_dattr_t dattr;
 438         /* make directory. */
 439
 440         code = AFS_VN_OPEN(path, UIO_SYSSPACE, FCREAT|FEXCL, 0700, &dvp,
 441                            CRMKDIR);
 442         if (code) {
 443             if (code == EEXIST) {
 444                 /* someone beat us to it? */
 445                 code = gop_lookupname(path, AFS_UIOSYS, 0, (struct vnode **) 0,
 446                                       &dvp);
 447             }
 448             if (code) {
 449                 AFS_UNLOCK_VOL_CREATE();
 450                 return code;
 451             }
 452         }
 453         else
 454             createdDir = 1;
 455         bzero((char*)&dattr, sizeof(dattr));
 456         dattr.atd_version = AFS_XFS_ATD_VERS;
 457         dattr.atd_volume = rw_vno;
 458         AFS_VOP_ATTR_SET(dvp, AFS_XFS_DATTR, (char*)&dattr,
 459                          SIZEOF_XFS_DATTR_T,
 460                          ATTR_ROOT|ATTR_CREATE, OSI_GET_CURRENT_CRED(), code);
 461         if (code) {
 462             VN_RELE(dvp);
 463             if (createdDir)
 464                 (void) vn_remove(path, UIO_SYSSPACE, RMDIRECTORY);
 465             AFS_UNLOCK_VOL_CREATE();
 466             return code;
 467         }
 468     }
 469
 470     vattr.va_mask = AT_FSID|AT_NODEID; /* gets a guick return using FSID*/
 471     AFS_VOP_GETATTR(dvp, &vattr, 0, OSI_GET_CURRENT_CRED(), code);
 472     if (code) {
 473         VN_RELE(dvp);
 474         return code;
 475     }
 476
 477     bzero((char*)&attrs, sizeof(attrs));
 478     attrs.at_pino = vattr.va_nodeid;
 479     VN_RELE(dvp);
 480
 481     /* Create the desired file. Use up to ten tries to create a unique name. */
 482     (void) strcpy(name, path);
 483     (void) strcat(name, "/.");
 484     (void) strcat(name, int_to_base64(stmp2, params[2]));
 485     s = &name[strlen(name)];
 486
 487     attrs.at_tag = 0;    /* Initial guess at a unique tag. */
 488     for (i=0; i<10; i++) {
 489             *s = '\0';
 490             strcat(s, ".");
 491             strcat(s, int_to_base64(stmp1, attrs.at_tag));
 492         code = AFS_VN_OPEN(name, UIO_SYSSPACE, FCREAT|FEXCL, 0600, &vp,
 493                            CRCREAT);
 494         if (!code || code != EEXIST)
 495             break;
 496
 497         attrs.at_tag ++ ;
 498     }
 499     /* Unlock the creation process since the directory now has a file in it.*/
 500     if (params[1] == INODESPECIAL)
 501         AFS_UNLOCK_VOL_CREATE();
 502
 503     if (!code) {
 504         /* Set attributes. */
 505         bcopy((char*)params, (char*)attrs.at_param,
 506               sizeof(afs_inode_params_t));
 507         attrs.at_attr_version = AFS_XFS_ATTR_VERS;
 508         attrs.at_name_version = name_version;
 509         AFS_VOP_ATTR_SET(vp, AFS_XFS_ATTR, (char*)&attrs,
 510                          SIZEOF_XFS_ATTR_T,
 511                          ATTR_ROOT|ATTR_CREATE, OSI_GET_CURRENT_CRED(),
 512                          code);
 513         if (!code) {
 514             vattr.va_mode = 1;
 515             vattr.va_uid = AFS_XFS_VNO_CLIP(params[0]);
 516             vattr.va_gid = XFS_VICEMAGIC;
 517             vattr.va_mask = AT_MODE | AT_UID | AT_GID;
 518             AFS_VOP_SETATTR(vp, &vattr, 0, OSI_GET_CURRENT_CRED(), code);
 519         }
 520         if (!code) {
 521             vattr.va_mask = AT_NODEID;
 522             AFS_VOP_GETATTR(vp, &vattr, 0, OSI_GET_CURRENT_CRED(), code);
 523         }
 524         if (!code)
 525             *inop = vattr.va_nodeid;
 526         VN_RELE(vp);
 527     }
 528
 529     if (code) {
 530         /* remove partially created file. */
 531         (void) vn_remove(name, UIO_SYSSPACE, RMFILE);
 532
 533         /* and directory if volume special file. */
 534         if (createdDir) {
 535             AFS_LOCK_VOL_CREATE();
 536             (void) vn_remove(path, UIO_SYSSPACE, RMDIRECTORY);
 537             AFS_UNLOCK_VOL_CREATE();
 538         }
 539     }
 540     return code;
 541 }
 542
 543 /* afs_syscall_icreatename64
 544  * This is the icreatename64 entry point used by the combined EFS/XFS
 545  * fileserver suite. The datap and datalen do not need to be set for EFS.
 546  */
 547 int
 548 afs_syscall_icreatename64(int dev, int datap, int datalen, int paramp,
 549                           int inop)
 550 {
 551     struct vfs *vfsp;
 552     afs_inode_params_t param;
 553     int code;
 554     rval_t rval;
 555     ino_t ino;
 556
 557
 558     if (!afs_suser())
 559         return EPERM;
 560
 561 #ifdef AFS_SGI65_ENV
 562     vfsp = vfs_devsearch(dev, VFS_FSTYPE_ANY);
 563 #else
 564     vfsp = vfs_devsearch(dev);
 565 #endif
 566     if (vfsp == NULL) {
 567         return ENXIO;
 568     }
 569
 570     AFS_COPYIN((char*)paramp, (char*)param, sizeof(afs_inode_params_t), code);
 571     if (vfsp->vfs_fstype == xfs_fstype) {
 572         code =  xfs_icreatename64(vfsp, datap, datalen, param, &ino);
 573         if (code)
 574             return code;
 575         else {
 576             AFS_COPYOUT((char*)&ino, (char*)inop, sizeof(ino_t), code);
 577             return code;
 578         }
 579     }
 580     else if (vfsp->vfs_fstype == efs_fstype) {
 581         code = afs_syscall_icreate(dev, 0, param[0], param[1], param[2],
 582                                    param[3], &rval);
 583         if (code)
 584             return code;
 585         else {
 586             ino = (ino_t)rval.r_val1;
 587             AFS_COPYOUT((char*)&ino, (char*)inop, sizeof(ino_t), code);
 588             return code;
 589         }
 590     }
 591     return ENXIO;
 592 }
 593 #endif /* AFS_SGI_XFS_IOPS_ENV */
 594
 595 /*
 596  * iopen system calls -- open an inode for reading/writing
 597  * Restricted to super user.
 598  * Any IFREG files.
 599  * The original EFS only system calls are still present in the kernel for
 600  * in case a kernel upgrade is done for a fix, but the EFS fileserver is
 601  * still in use.
 602  */
 603 struct iopenargs {
 604         sysarg_t        dev;
 605         sysarg_t        inode;
 606         sysarg_t        usrmod;
 607 };
 608
 609 #ifdef AFS_SGI_XFS_IOPS_ENV
 610 struct iopenargs64 {
 611         sysarg_t        dev;
 612         sysarg_t        inode_hi;
 613         sysarg_t        inode_lo;
 614         sysarg_t        usrmod;
 615 };
 616
 617 #ifdef AFS_SGI65_ENV
 618 int
 619 afs_syscall_iopen(int dev, ino_t inode, int usrmod, rval_t *rvp)
 620 {
 621         struct file *fp;
 622         int fd;
 623         int error;
 624         struct vfs* vfsp;
 625         struct vnode *vp;
 626
 627         AFS_STATCNT(afs_syscall_iopen);
 628         if (!afs_suser())
 629                 return EPERM;
 630         vfsp = vfs_devsearch(dev, xfs_fstype);
 631         if (!vfsp)
 632             vfsp = vfs_devsearch(dev, efs_fstype);
 633         if (!vfsp)
 634             return ENXIO;
 635
 636 #ifdef AFS_SGI_EFS_IOPS_ENV
 637         if (vfsp->vfs_fstype == efs_fstype) {
 638             struct inode *ip;
 639             if (error = igetinode(vfsp, (dev_t)dev, inode, &ip))
 640                 return error;
 641             vp = EFS_ITOV(ip);
 642             if (error = vfile_alloc((usrmod+1) & (FMASK), &fp, &fd)) {
 643                 iput(ip);
 644                 return error;
 645             }
 646             iunlock(ip);
 647         }
 648         else
 649 #endif /* AFS_SGI_EFS_IOPS_ENV */
 650           if (vfsp->vfs_fstype == xfs_fstype) {
 651               struct xfs_inode *xip;
 652               if (error = xfs_igetinode(vfsp, (dev_t)dev, inode, &xip))
 653                   return error;
 654               vp = XFS_ITOV(xip);
 655               if (error = vfile_alloc((usrmod+1) & (FMASK), &fp, &fd)) {
 656                   VN_RELE(vp);
 657                   return error;
 658               }
 659           }
 660           else {
 661               osi_Panic("afs_syscall_iopen: bad fstype = %d\n",
 662                         vfsp->vfs_fstype);
 663           }
 664         vfile_ready(fp, vp);
 665         rvp->r_val1 = fd;
 666         return 0;
 667 }
 668 #else
 669 /* afs_syscall_iopen
 670  * EFS/XFS version vectors to correct code based vfs_fstype. Expects a
 671  * 64 bit inode number.
 672  */
 673 int
 674 afs_syscall_iopen(int dev, ino_t inode, int usrmod, rval_t *rvp)
 675 {
 676         struct file *fp;
 677         int fd;
 678         int error;
 679         struct vfs* vfsp;
 680
 681         AFS_STATCNT(afs_syscall_iopen);
 682         if (!afs_suser())
 683                 return EPERM;
 684         vfsp = vfs_devsearch(dev);
 685         if (!vfsp) {
 686             return ENXIO;
 687         }
 688
 689         if (vfsp->vfs_fstype == xfs_fstype) {
 690             struct xfs_inode *xip;
 691             struct vnode *vp;
 692             if (error = xfs_igetinode(vfsp, (dev_t)dev, inode, &xip))
 693                 return error;
 694             vp = XFS_ITOV(xip);
 695             if (error = falloc(vp, (usrmod+1) & (FMASK), &fp, &fd)) {
 696                 VN_RELE(vp);
 697                 return error;
 698             }
 699         }
 700         else if (vfsp->vfs_fstype == efs_fstype) {
 701             struct inode *ip;
 702             if (error = igetinode(vfsp, (dev_t)dev, inode, &ip))
 703                 return error;
 704             if (error = falloc(EFS_ITOV(ip), (usrmod+1) & (FMASK), &fp, &fd)) {
 705                 iput(ip);
 706                 return error;
 707             }
 708             iunlock(ip);
 709         }
 710         else {
 711             osi_Panic("afs_syscall_iopen: bad fstype = %d\n",
 712                       vfsp->vfs_fstype);
 713         }
 714         fready(fp);
 715         rvp->r_val1 = fd;
 716         return 0;
 717 }
 718 #endif /* AFS_SGI65_ENV */
 719
 720 int
 721 iopen(struct iopenargs *uap, rval_t *rvp)
 722 {
 723      AFS_STATCNT(iopen);
 724      return (afs_syscall_iopen(uap->dev, (ino_t)uap->inode, uap->usrmod,
 725                                rvp));
 726 }
 727
 728 int
 729 iopen64(struct iopenargs64 *uap, rval_t *rvp)
 730 {
 731      AFS_STATCNT(iopen);
 732      return (afs_syscall_iopen(uap->dev,
 733                                (ino_t)((uap->inode_hi<<32) | uap->inode_lo),
 734                                uap->usrmod, rvp));
 735 }
 736
 737 #else /* AFS_SGI_XFS_IOPS_ENV */
 738 /* iopen/afs_syscall_iopen
 739  *
 740  * Original EFS only 32 bit iopen call.
 741  */
 742 int
 743 iopen(struct iopenargs *uap, rval_t *rvp)
 744 {
 745      AFS_STATCNT(iopen);
 746      return (afs_syscall_iopen(uap->dev, uap->inode, uap->usrmod, rvp));
 747 }
 748
 749 int
 750 afs_syscall_iopen(dev, inode, usrmod, rvp)
 751 int dev, inode, usrmod;
 752 rval_t *rvp;
 753 {
 754         struct file *fp;
 755         struct inode *ip;
 756         int fd;
 757         int error;
 758
 759         AFS_STATCNT(afs_syscall_iopen);
 760         if (!afs_suser())
 761                 return EPERM;
 762         if (error = igetinode(0, (dev_t)dev, inode, &ip))
 763                 return error;
 764         if (error = falloc(EFS_ITOV(ip), (usrmod+1) & (FMASK), &fp, &fd)) {
 765                 iput(ip);
 766                 return error;
 767         }
 768         iunlock(ip);
 769         rvp->r_val1 = fd;
 770 #ifdef  AFS_SGI53_ENV
 771         fready(fp);
 772 #endif
 773         return 0;
 774 }
 775 #endif /* AFS_SGI_XFS_IOPS_ENV */
 776
 777 /*
 778  * Support for iinc() and idec() system calls--increment or decrement
 779  * count on inode.
 780  * Restricted to super user.
 781  * Only VICEMAGIC type inodes.
 782  */
 783 #ifdef AFS_SGI_XFS_IOPS_ENV
 784 #ifdef AFS_SGI_EFS_IOPS_ENV
 785 /* efs_iincdec
 786  *
 787  * XFS/EFS iinc/idec code for EFS. Uses 32 bit inode numbers.
 788  */
 789 static int efs_iincdec(vfsp, inode, inode_p1, amount)
 790 struct vfs *vfsp;
 791 int inode, inode_p1, amount;
 792 {
 793     struct inode *ip;
 794     int error;
 795
 796     if (error = igetinode(vfsp, NULL, inode, &ip))
 797         return error;
 798
 799     if (!IS_VICEMAGIC(ip))
 800         error = EPERM;
 801     else if (((struct afsparms *)ip->i_afs)->vicep1 != inode_p1)
 802         error = ENXIO;
 803     else {
 804         ip->i_nlink += amount;
 805         osi_Assert(ip->i_nlink >= 0);
 806         if (ip->i_nlink == 0) {
 807             CLEAR_VICEMAGIC(ip);
 808             afsidestroy(ip);
 809         }
 810         ip->i_flags |= ICHG;
 811     }
 812     /* XXX sync write?? */
 813     iput(ip);
 814     return error;
 815 }
 816 #endif /* AFS_SGI_EFS_IOPS_ENV */
 817
 818 /* xfs_iincdec
 819  *
 820  * XFS/EFS iinc/idec code for EFS. Uses 64 bit inode numbers.
 821  */
 822 static int xfs_iincdec64(struct vfs *vfsp, ino_t inode, int inode_p1,
 823                          int amount)
 824 {
 825     vnode_t *vp;
 826     xfs_inode_t *ip;
 827     int code = 0;
 828     afs_xfs_attr_t attrs;
 829     int length = SIZEOF_XFS_ATTR_T;
 830     afs_xfs_dattr_t dattr;
 831     struct vattr vattr;
 832     int nlink;
 833     int vol;
 834
 835     code = xfs_iget((((struct mount *)((vfsp)->vfs_bh.bh_first)->bd_pdata)),
 836                     (void*)0, (xfs_ino_t)inode, XFS_ILOCK_SHARED, &ip,
 837                     (daddr_t)0);
 838     if (code)
 839         return code;
 840
 841     vp = XFS_ITOV(ip);
 842     xfs_iunlock(ip, XFS_ILOCK_SHARED);
 843
 844     vattr.va_mask = AT_GID | AT_UID | AT_MODE;
 845     AFS_VOP_GETATTR(vp, &vattr, 0, OSI_GET_CURRENT_CRED(), code);
 846     if (code)
 847         code = EPERM;
 848
 849     if (!code && (vattr.va_gid != XFS_VICEMAGIC))
 850         code = EPERM;
 851
 852     if (!code && (AFS_XFS_VNO_CLIP(inode_p1) != vattr.va_uid))
 853         code = ENXIO;
 854
 855     if (code) {
 856         VN_RELE(vp);
 857         return code;
 858     }
 859
 860     nlink = vattr.va_mode & AFS_XFS_MODE_LINK_MASK;
 861     nlink += amount;
 862     if (nlink > 07) {
 863         code = EOVERFLOW;
 864     }
 865     if (nlink > 0) {
 866         vattr.va_mode &= ~AFS_XFS_MODE_LINK_MASK;
 867         vattr.va_mode |= nlink;
 868         vattr.va_mask = AT_MODE;
 869         AFS_VOP_SETATTR(vp, &vattr, 0, OSI_GET_CURRENT_CRED(), code);
 870         VN_RELE(vp);
 871         return code;
 872     }
 873     else {
 874         char path[64];
 875         b64_string_t stmp1, stmp2;
 876         vnode_t *dvp;
 877         xfs_inode_t *ip;
 878
 879         length = SIZEOF_XFS_ATTR_T;
 880         AFS_VOP_ATTR_GET(vp, AFS_XFS_ATTR, (char*)&attrs, &length,
 881                                 ATTR_ROOT, OSI_GET_CURRENT_CRED(), code);
 882         VN_RELE(vp);
 883         if (!code) {
 884             if (length != SIZEOF_XFS_ATTR_T
 885                 || attrs.at_attr_version != AFS_XFS_ATTR_VERS)
 886                 return EINVAL;
 887         }
 888         /* Get the vnode for the directory this file is in. */
 889         if (!attrs.at_pino)
 890             return ENOENT;
 891
 892         code = xfs_getinode(vp->v_vfsp, NULL, attrs.at_pino, &ip);
 893         if (code)
 894             return code;
 895
 896         dvp = XFS_ITOV(ip);
 897         xfs_iunlock(ip, XFS_ILOCK_SHARED);
 898
 899         /* Verify directory attributes. */
 900         length = SIZEOF_XFS_DATTR_T;
 901         AFS_VOP_ATTR_GET(dvp, AFS_XFS_DATTR , (char*)&dattr, &length,
 902                          ATTR_ROOT, OSI_GET_CURRENT_CRED(), code);
 903         if (!code) {
 904             if (length != SIZEOF_XFS_DATTR_T
 905                 || dattr.atd_version != AFS_XFS_ATD_VERS)
 906                 code = ENXIO;
 907         }
 908         if (code) {
 909             VN_RELE(dvp);
 910             return code;
 911         }
 912
 913         strcpy(path, ".");
 914         strcat(path, int_to_base64(stmp1, attrs.at_param[2]));
 915         strcat(path, ".");
 916         strcat(path, int_to_base64(stmp1, attrs.at_tag));
 917
 918         AFS_VOP_REMOVE(dvp, path, OSI_GET_CURRENT_CRED(), code);
 919
 920         if (!code) {
 921             int code2;
 922             vattr.va_mask = AT_NLINK;
 923             AFS_VOP_GETATTR(dvp, &vattr, 0, OSI_GET_CURRENT_CRED(),
 924                             code2);
 925             if (!code2) {
 926                 if (vattr.va_nlink == 2) {
 927                     vnode_t *ddvp; /* parent of volume directory. */
 928                     /* Try to remove the directory if this is a volume
 929                      * special file. It's ok to fail.
 930                      */
 931                     AFS_VOP_LOOKUP(dvp, "..", &ddvp,
 932                                    (struct pathname *)NULL,
 933                                    0, OSI_GET_CURRENT_RDIR(),
 934                                    OSI_GET_CURRENT_CRED(), code2);
 935                     if (!code2) {
 936                         VN_RELE(dvp);
 937                         dvp = (vnode_t*)0;
 938                         strcpy(path, ".");
 939                         if (attrs.at_name_version == AFS_XFS_NAME_VERS2)
 940                             strcpy(path, AFS_INODE_DIR_NAME);
 941                         else
 942                             strcpy(path, ".");
 943                         int_to_base64(stmp1,
 944                                       (attrs.at_param[1] == INODESPECIAL) ?
 945                                       attrs.at_param[3] : attrs.at_param[0]);
 946                         strcat(path, stmp1);
 947                         AFS_LOCK_VOL_CREATE();
 948                         AFS_VOP_RMDIR(ddvp, path, OSI_GET_CURRENT_CDIR(),
 949                                       OSI_GET_CURRENT_CRED(), code2);
 950                         AFS_UNLOCK_VOL_CREATE();
 951                         VN_RELE(ddvp);
 952                     }
 953                 }
 954             }
 955         }
 956         if (dvp)
 957             VN_RELE(dvp);
 958     }
 959     return code;
 960 }
 961
 962 int
 963 iincdec64(int dev, int inode_hi, int inode_lo, int inode_p1, int amount)
 964 {
 965     struct vfs *vfsp;
 966
 967     if (!afs_suser())
 968         return EPERM;
 969 #ifdef AFS_SGI65_ENV
 970     vfsp = vfs_devsearch(dev, VFS_FSTYPE_ANY);
 971 #else
 972     vfsp = vfs_devsearch(dev);
 973 #endif
 974     if (!vfsp) {
 975         return ENXIO;
 976     }
 977
 978     if (vfsp->vfs_fstype == xfs_fstype) {
 979         ino_t inode;
 980         inode = inode_hi;
 981         inode <<= 32;
 982         inode |= inode_lo;
 983         return xfs_iincdec64(vfsp, inode, inode_p1, amount);
 984     }
 985 #ifdef AFS_SGI_EFS_IOPS_ENV
 986     else if (vfsp->vfs_fstype == efs_fstype) {
 987         return efs_iincdec(vfsp, inode_lo, inode_p1, amount);
 988     }
 989 #endif /* AFS_SGI_EFS_IOPS_ENV */
 990     return ENXIO;
 991 }
 992
 993 int
 994 afs_syscall_idec64(int dev, int inode_hi, int inode_lo, int inode_p1)
 995 {
 996     return iincdec64(dev, inode_hi, inode_lo, inode_p1, -1);
 997 }
 998
 999 int
1000 afs_syscall_iinc64(int dev, int inode_hi, int inode_lo, int inode_p1)
1001 {
1002     return iincdec64(dev, inode_hi, inode_lo, inode_p1, 1);
1003 }
1004
1005
1006
1007
1008 struct iincargs {
1009         sysarg_t        dev;
1010         sysarg_t        inode;
1011         sysarg_t        inode_p1;
1012 };
1013
1014 #ifdef AFS_SGI65_ENV
1015 int iinc(struct iincargs *uap, rval_t *rvp) {
1016     AFS_STATCNT(iinc);
1017     return ENOTSUP;
1018 }
1019 int idec(struct iincargs *uap, rval_t *rvp) {
1020     AFS_STATCNT(idec);
1021     return ENOTSUP;
1022 }
1023 #else
1024 /* iincdec
1025  *
1026  * XFS/EFS iinc/idec entry points for EFS only fileservers.
1027  *
1028  */
1029 int
1030 iincdec(dev, inode, inode_p1, amount)
1031 int dev, inode, inode_p1, amount;
1032 {
1033     struct vfs *vfsp;
1034
1035     if (!afs_suser())
1036         return EPERM;
1037     vfsp = vfs_devsearch(dev);
1038     if (!vfsp) {
1039         return ENXIO;
1040     }
1041     if (vfsp->vfs_fstype != efs_fstype)
1042         return ENOSYS;
1043
1044     return efs_iincdec(vfsp, inode, inode_p1, amount);
1045 }
1046 int
1047 iinc(struct iincargs *uap, rval_t *rvp) {
1048     AFS_STATCNT(iinc);
1049     return (iincdec(uap->dev, uap->inode, uap->inode_p1, 1));
1050 }
1051
1052 int
1053 idec(struct iincargs *uap, rval_t *rvp) {
1054     AFS_STATCNT(idec);
1055     return (iincdec(uap->dev, uap->inode, uap->inode_p1, -1));
1056 }
1057 #endif /* AFS_SGI65_ENV */
1058
1059 #else /* AFS_SGI_XFS_IOPS_ENV */
1060 /* afs_syscall_iincdec iinc idec
1061  *
1062  * These are the original EFS only entry points.
1063  */
1064 int
1065 afs_syscall_iincdec(dev, inode, inode_p1, amount)
1066 int dev, inode, inode_p1, amount;
1067 {
1068         struct inode *ip;
1069         int error = 0;
1070
1071         if (!afs_suser())
1072                 return EPERM;
1073         if (error = igetinode(0, (dev_t)dev, inode, &ip))
1074                 return error;
1075
1076         if (!IS_VICEMAGIC(ip))
1077             error = EPERM;
1078         else if (((struct afsparms *)ip->i_afs)->vicep1 != inode_p1)
1079             error = ENXIO;
1080         else {
1081                 ip->i_nlink += amount;
1082                 osi_Assert(ip->i_nlink >= 0);
1083                 if (ip->i_nlink == 0) {
1084                     CLEAR_VICEMAGIC(ip);
1085                     afsidestroy(ip);
1086                 }
1087                 ip->i_flags |= ICHG;
1088         }
1089         /* XXX sync write?? */
1090         iput(ip);
1091         return error;
1092 }
1093
1094 struct iincargs {
1095         sysarg_t        dev;
1096         sysarg_t        inode;
1097         sysarg_t        inode_p1;
1098 };
1099
1100 int
1101 iinc(struct iincargs *uap, rval_t *rvp) {
1102     AFS_STATCNT(iinc);
1103     return (afs_syscall_iincdec(uap->dev, uap->inode, uap->inode_p1, 1));
1104 }
1105
1106 int
1107 idec(struct iincargs *uap, rval_t *rvp) {
1108     AFS_STATCNT(idec);
1109     return (afs_syscall_iincdec(uap->dev, uap->inode, uap->inode_p1, -1));
1110 }
1111 #endif /* AFS_SGI_XFS_IOPS_ENV */
1112
1113 #ifdef AFS_SGI_XFS_IOPS_ENV
1114 /* afs_syscall_ilistinode64
1115  * Gathers up all required info for ListViceInodes in one system call.
1116  */
1117 int
1118 afs_syscall_ilistinode64(int dev, int inode_hi, int inode_lo,
1119                          int datap, int datalenp)
1120 {
1121     int code = 0;
1122     ino_t inode;
1123     xfs_inode_t *ip;
1124     vfs_t *vfsp;
1125     vnode_t *vp;
1126     struct vattr vattr;
1127     afs_xfs_attr_t attrs;
1128     int length;
1129     i_list_inode_t data;
1130     int idatalen;
1131
1132     if (!afs_suser())
1133         return EPERM;
1134 #ifdef AFS_SGI65_ENV
1135     vfsp = vfs_devsearch(dev, xfs_fstype);
1136 #else
1137     vfsp = vfs_devsearch(dev);
1138 #endif
1139     if (!vfsp) {
1140         return ENXIO;
1141     }
1142 #ifndef AFS_SGI65_ENV
1143     if (vfsp->vfs_fstype != xfs_fstype)
1144         return ENOSYS;
1145 #endif
1146
1147     AFS_COPYIN((char*)datalenp, &idatalen, sizeof(int), code);
1148     if (idatalen < sizeof(i_list_inode_t)) {
1149         idatalen = sizeof(i_list_inode_t);
1150         AFS_COPYOUT((char*)datalenp, (char*)&idatalen, sizeof(int), code);
1151         return E2BIG;
1152     }
1153     idatalen = sizeof(i_list_inode_t);
1154     AFS_COPYOUT((char*)datalenp, (char*)&idatalen, sizeof(int), code);
1155
1156     AFS_COPYIN((char*)datap, (char*)&data, sizeof(i_list_inode_t), code);
1157     if (data.ili_version != AFS_XFS_ILI_VERSION) {
1158         data.ili_version = AFS_XFS_ILI_VERSION;
1159         AFS_COPYOUT((char*)&data, (char*)datap, sizeof(i_list_inode_t), code);
1160         return EINVAL;
1161     }
1162
1163
1164     inode = inode_hi;
1165     inode <<= 32;
1166     inode |= inode_lo;
1167     code = xfs_iget((((struct mount *)((vfsp)->vfs_bh.bh_first)->bd_pdata)),
1168                     (void*)0, (xfs_ino_t)inode,
1169                     XFS_ILOCK_SHARED, &ip, (daddr_t)0);
1170     if (code)
1171         return code;
1172
1173     vp = XFS_ITOV(ip);
1174     xfs_iunlock(ip, XFS_ILOCK_SHARED);
1175
1176     length = SIZEOF_XFS_ATTR_T;
1177
1178     AFS_VOP_ATTR_GET(vp, AFS_XFS_ATTR, (char*)&attrs, &length,
1179                             ATTR_ROOT, OSI_GET_CURRENT_CRED(), code);
1180     if (code) {
1181         code = EPERM;
1182     }
1183
1184     if (!code) {
1185         if (attrs.at_attr_version != AFS_XFS_ATTR_VERS)
1186             code = EINVAL;
1187     }
1188
1189     if (!code) {
1190         vattr.va_mask = AT_STAT;
1191         AFS_VOP_GETATTR(vp, &vattr, 0, OSI_GET_CURRENT_CRED(), code);
1192     }
1193
1194     if (!code) {
1195         bzero((char*)&data, sizeof(data));
1196         data.ili_info.inodeNumber = inode;
1197         data.ili_info.byteCount = vattr.va_size;
1198         data.ili_info.linkCount = (vattr.va_mode & AFS_XFS_MODE_LINK_MASK);
1199         bcopy((char*)attrs.at_param, (char*)data.ili_info.param,
1200               sizeof(data.ili_info.param));
1201         data.ili_attr_version = attrs.at_attr_version;
1202         data.ili_name_version = attrs.at_name_version;
1203         data.ili_tag = attrs.at_tag;
1204         data.ili_pino = attrs.at_pino;
1205         data.ili_vno = vattr.va_uid;
1206         data.ili_magic = vattr.va_gid;
1207         AFS_COPYOUT((char*)&data, (char*)datap, sizeof(data), code);
1208     }
1209     VN_RELE(vp);
1210     return code;
1211 }
1212 #endif /* AFS_SGI_XFS_IOPS_ENV */