src/afs/DARWIN/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  * MACOS inode operations
  11  *
  12  * Implements:
  13  *
  14  */
  15 #include "../afs/param.h"       /* Should be always first */
  16 #include "../afs/sysincludes.h" /* Standard vendor system headers */
  17 #include "../afs/afsincludes.h" /* Afs-based standard headers */
  18 #include "../afs/osi_inode.h"
  19 #include "../afs/afs_stats.h" /* statistics stuff */
  20 #include <ufs/ufs/ufsmount.h>
  21 extern struct ucred afs_osi_cred;
  22
  23 getinode(fs, dev, inode, vpp, perror)
  24      struct mount *fs;
  25      struct vnode **vpp;
  26      dev_t dev;
  27      ino_t inode;
  28      int *perror;
  29 {
  30     struct vnode *vp;
  31     int code;
  32
  33     *vpp = 0;
  34     *perror = 0;
  35     if (!fs) {
  36         register struct ufsmount *ump;
  37 #ifdef VFSTOHFS
  38         register struct hfsmount *hmp;
  39 #endif
  40         register struct vnode *vp;
  41         register struct mount *mp;
  42         extern struct mount *rootfs;
  43         if (mp = rootfs) do {
  44             /*
  45              * XXX Also do the test for MFS
  46              */
  47             if (!strcmp(mp->mnt_vfc->vfc_name, "ufs")) {
  48                 ump = VFSTOUFS(mp);
  49                 if (ump->um_fs == NULL)
  50                     break;
  51                 if (ump->um_dev == dev) {
  52                     fs = ump->um_mountp;
  53                 }
  54             }
  55 #ifdef VFSTOHFS
  56             if (!strcmp(mp->mnt_vfc->vfc_name, "hfs")) {
  57                 hmp = VFSTOHFS(mp);
  58 #if 0
  59                 if (hmp->hfs_mp == NULL)
  60                     break;
  61 #endif
  62                 if (hmp->hfs_raw_dev == dev) {
  63                     fs = hmp->hfs_mp;
  64                 }
  65             }
  66 #endif
  67
  68             mp = CIRCLEQ_NEXT(mp, mnt_list);
  69         } while (mp != rootfs);
  70         if (!fs)
  71             return(ENXIO);
  72     }
  73     code=VFS_VGET(fs, (void *)inode, &vp);
  74     if (code) {
  75         *perror = BAD_IGET;
  76         return code;
  77     } else {
  78         *vpp = vp;
  79         return(0);
  80     }
  81 }
  82 extern int afs_CacheFSType;
  83 igetinode(vfsp, dev, inode, vpp, va, perror)
  84      struct vnode **vpp;
  85      struct mount *vfsp;
  86      dev_t dev;
  87      ino_t inode;
  88      struct vattr *va;
  89      int *perror;
  90 {
  91     struct vnode *pvp, *vp;
  92     extern struct osi_dev cacheDev;
  93     register int code = 0;
  94
  95     *perror = 0;
  96
  97     AFS_STATCNT(igetinode);
  98     if ((code = getinode(vfsp, dev, inode, &vp, perror)) != 0) {
  99         return(code);
 100     }
 101     if (vp->v_type != VREG && vp->v_type != VDIR && vp->v_type != VLNK) {
 102         printf("igetinode: bad type %d\n", vp->v_type);
 103         iforget(vp);
 104         return(ENOENT);
 105     }
 106     VOP_GETATTR(vp, va, &afs_osi_cred, current_proc());
 107     if (va->va_mode == 0) {
 108         /* Not an allocated inode */
 109         iforget(vp);
 110         return(ENOENT);
 111     }
 112     if (vfsp && afs_CacheFSType == AFS_APPL_HFS_CACHE && va->va_nlink == 0) {
 113         printf("igetinode: hfs nlink 0\n");
 114     }
 115     if (va->va_nlink == 0) {
 116         vput(vp);
 117         return(ENOENT);
 118     }
 119
 120     VOP_UNLOCK(vp, 0, current_proc());
 121     *vpp = vp;
 122     return(0);
 123 }
 124
 125 iforget(vp)
 126 struct vnode *vp;
 127 {
 128
 129     AFS_STATCNT(iforget);
 130     /* XXX could sleep */
 131     vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, current_proc());
 132     /* this whole thing is too wierd.  Why??? XXX */
 133     if (vp->v_usecount == 1) {
 134         vp->v_usecount=0;
 135         VOP_UNLOCK(vp,0, current_proc());
 136 #if 0
 137         simple_lock(&vnode_free_list_slock);
 138         TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
 139         freevnodes++;
 140         simple_unlock(&vnode_free_list_slock);
 141 #else
 142         printf("iforget: leaking vnode\n");
 143 #endif
 144     } else {
 145         vput(vp);
 146     }
 147 }
 148
 149 #if 0
 150 /*
 151  * icreate system call -- create an inode
 152  */
 153 afs_syscall_icreate(dev, near_inode, param1, param2, param3, param4, retval)
 154      long *retval;
 155      long dev, near_inode, param1, param2, param3, param4;
 156 {
 157     int dummy, err=0;
 158     struct inode *ip, *newip;
 159     register int code;
 160     struct vnode *vp;
 161
 162     AFS_STATCNT(afs_syscall_icreate);
 163
 164     if (!afs_suser())
 165         return(EPERM);
 166
 167     code = getinode(0, (dev_t)dev, 2, &ip, &dummy);
 168     if (code) {
 169         return(ENOENT);
 170     }
 171     code = ialloc(ip, (ino_t)near_inode, 0, &newip);
 172     iput(ip);
 173     if (code) {
 174         return(code);
 175     }
 176     IN_LOCK(newip);
 177     newip->i_flag |= IACC|IUPD|ICHG;
 178
 179     newip->i_nlink = 1;
 180
 181     newip->i_mode = IFREG;
 182
 183     IN_UNLOCK(newip);
 184     vp = ITOV(newip);
 185     VN_LOCK(vp);
 186     vp->v_type = VREG;
 187     VN_UNLOCK(vp);
 188
 189     if ( !vp->v_object)
 190         {
 191             extern struct vfs_ubcops ufs_ubcops;
 192             extern struct vm_ubc_object* ubc_object_allocate();
 193             struct vm_ubc_object* vop;
 194             vop = ubc_object_allocate(&vp, &ufs_ubcops,
 195                                       vp->v_mount->m_funnel);
 196             VN_LOCK(vp);
 197             vp->v_object = vop;
 198             VN_UNLOCK(vp);
 199         }
 200
 201
 202     IN_LOCK(newip);
 203     newip->i_flags |= IC_XUID|IC_XGID;
 204     newip->i_flags &= ~IC_PROPLIST;
 205     newip->i_vicep1 = param1;
 206     if (param2 == 0x1fffffff/*INODESPECIAL*/)   {
 207         newip->i_vicep2 = ((0x1fffffff << 3) + (param4 & 0x3));
 208         newip->i_vicep3a = (u_short)(param3 >> 16);
 209         newip->i_vicep3b = (u_short)param3;
 210     } else {
 211         newip->i_vicep2 = (((param2 >> 16) & 0x1f) << 27) +
 212             (((param4 >> 16) & 0x1f) << 22) +
 213                 (param3 & 0x3fffff);
 214         newip->i_vicep3a = (u_short)param4;
 215         newip->i_vicep3b = (u_short)param2;
 216     }
 217     newip->i_vicemagic = VICEMAGIC;
 218
 219     *retval = newip->i_number;
 220     IN_UNLOCK(newip);
 221     iput(newip);
 222     return(code);
 223 }
 224
 225
 226 afs_syscall_iopen(dev, inode, usrmod, retval)
 227      long *retval;
 228      int dev, inode, usrmod;
 229 {
 230     struct file *fp;
 231     struct inode *ip;
 232     struct vnode *vp = (struct vnode *)0;
 233     int dummy;
 234     int fd;
 235     extern struct fileops vnops;
 236     register int code;
 237
 238     AFS_STATCNT(afs_syscall_iopen);
 239
 240     if (!afs_suser())
 241         return(EPERM);
 242
 243     code = igetinode(0, (dev_t)dev, (ino_t)inode, &ip, &dummy);
 244     if (code) {
 245         return(code);
 246     }
 247     if ((code = falloc(&fp, &fd)) != 0) {
 248         iput(ip);
 249         return(code);
 250     }
 251     IN_UNLOCK(ip);
 252
 253     FP_LOCK(fp);
 254     fp->f_flag = (usrmod-FOPEN) & FMASK;
 255     fp->f_type = DTYPE_VNODE;
 256     fp->f_ops = &vnops;
 257     fp->f_data = (caddr_t)ITOV(ip);
 258
 259     FP_UNLOCK(fp);
 260     U_FD_SET(fd, fp, &u.u_file_state);
 261     *retval = fd;
 262     return(0);
 263 }
 264
 265
 266 /*
 267  * Support for iinc() and idec() system calls--increment or decrement
 268  * count on inode.
 269  * Restricted to super user.
 270  * Only VICEMAGIC type inodes.
 271  */
 272 afs_syscall_iincdec(dev, inode, inode_p1, amount)
 273      int dev, inode, inode_p1, amount;
 274 {
 275     int dummy;
 276     struct inode *ip;
 277     register int code;
 278
 279     if (!afs_suser())
 280         return(EPERM);
 281
 282     code = igetinode(0, (dev_t)dev, (ino_t)inode, &ip, &dummy);
 283     if (code) {
 284         return(code);
 285     }
 286     if (!IS_VICEMAGIC(ip)) {
 287         return(EPERM);
 288     } else if (ip->i_vicep1 != inode_p1) {
 289         return(ENXIO);
 290     }
 291     ip->i_nlink += amount;
 292     if (ip->i_nlink == 0) {
 293         CLEAR_VICEMAGIC(ip);
 294     }
 295     ip->i_flag |= ICHG;
 296     iput(ip);
 297     return(0);
 298 }
 299 #else
 300 afs_syscall_icreate(dev, near_inode, param1, param2, param3, param4, retval)
 301      long *retval;
 302      long dev, near_inode, param1, param2, param3, param4;
 303 {
 304      return EOPNOTSUPP;
 305 }
 306 afs_syscall_iopen(dev, inode, usrmod, retval)
 307      long *retval;
 308      int dev, inode, usrmod;
 309 {
 310      return EOPNOTSUPP;
 311 }
 312 afs_syscall_iincdec(dev, inode, inode_p1, amount)
 313      int dev, inode, inode_p1, amount;
 314 {
 315      return EOPNOTSUPP;
 316 }
 317 #endif