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