src/afs/FBSD/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  * FreeBSD inode operations
  12  *
  13  * Implements:
  14  *
  15  */
  16 #include <afsconfig.h>
  17 #include "afs/param.h"
  18
  19
  20 #include "afs/sysincludes.h"    /* Standard vendor system headers */
  21 #include "afsincludes.h"        /* Afs-based standard headers */
  22 #include "afs/osi_inode.h"
  23 #include "afs/afs_stats.h"      /* statistics stuff */
  24 #include <sys/queue.h>
  25 #include <sys/lock.h>
  26 #include <ufs/ufs/dinode.h>
  27 #include <ufs/ufs/extattr.h>
  28 #include <ufs/ufs/ufsmount.h>
  29
  30 int
  31 getinode(fs, dev, inode, ipp, perror)
  32      struct mount *fs;
  33      struct inode **ipp;
  34 #ifdef AFS_FBSD53_ENV
  35      struct cdev *dev;
  36 #else
  37      dev_t dev;
  38 #endif
  39      ino_t inode;
  40      int *perror;
  41 {
  42     struct vnode *vp;
  43     int code;
  44
  45     *ipp = 0;
  46     *perror = 0;
  47     if (!fs) {
  48         struct ufsmount *ump;
  49         struct mount *mp;
  50
  51         mtx_lock(&mountlist_mtx);
  52         if ((mp = TAILQ_FIRST(&mountlist)) != NULL)
  53             do {
  54                 /*
  55                  * XXX Also do the test for MFS
  56                  */
  57 #undef m_data
  58 #undef m_next
  59                 if (!strcmp(mp->mnt_stat.f_fstypename, MOUNT_UFS)) {
  60                     ump = VFSTOUFS(mp);
  61                     if (ump->um_fs == NULL)
  62                         break;
  63                     if (ump->um_dev == dev) {
  64                         fs = ump->um_mountp;
  65                     }
  66                 }
  67                 mp = TAILQ_NEXT(mp, mnt_list);
  68             } while (mp != TAILQ_FIRST(&mountlist));
  69         mtx_unlock(&mountlist_mtx);
  70         if (!fs)
  71             return (ENXIO);
  72     }
  73     code = VFS_VGET(fs, inode, 0, &vp);
  74     if (code != 0) {
  75         *perror = BAD_IGET;
  76         return code;
  77     } else {
  78         *ipp = VTOI(vp);
  79         return (0);
  80     }
  81 }
  82
  83 int
  84 igetinode(vfsp, dev, inode, ipp, perror)
  85      struct inode **ipp;
  86      struct mount *vfsp;
  87 #ifdef AFS_FBSD53_ENV
  88      struct cdev *dev;
  89 #else
  90      dev_t dev;
  91 #endif
  92      ino_t inode;
  93      int *perror;
  94 {
  95     struct inode *ip;
  96     int code = 0;
  97
  98     *perror = 0;
  99
 100     AFS_STATCNT(igetinode);
 101
 102     if ((code = getinode(vfsp, dev, inode, &ip, perror)) != 0) {
 103         return (code);
 104     }
 105
 106     if (ip->i_mode == 0) {
 107         /* Not an allocated inode */
 108         vput(ITOV(ip));
 109         return (ENOENT);
 110     }
 111
 112     if (ip->i_nlink == 0 || (ip->i_mode & IFMT) != IFREG) {
 113         vput(ITOV(ip));
 114         return (ENOENT);
 115     }
 116
 117     *ipp = ip;
 118     return (0);
 119 }
 120
 121 #if 0
 122 /*
 123  * icreate system call -- create an inode
 124  */
 125 afs_syscall_icreate(dev, near_inode, param1, param2, param3, param4, retval)
 126      long *retval;
 127      long dev, near_inode, param1, param2, param3, param4;
 128 {
 129     int dummy, err = 0;
 130     struct inode *ip, *newip;
 131     int code;
 132     struct vnode *vp;
 133
 134     AFS_STATCNT(afs_syscall_icreate);
 135
 136     if (!afs_suser(NULL))
 137         return (EPERM);
 138
 139     code = getinode(0, (dev_t) dev, 2, &ip, &dummy);
 140     if (code) {
 141         return (ENOENT);
 142     }
 143     code = ialloc(ip, (ino_t) near_inode, 0, &newip);
 144     iput(ip);
 145     if (code) {
 146         return (code);
 147     }
 148     IN_LOCK(newip);
 149     newip->i_flag |= IACC | IUPD | ICHG;
 150
 151     newip->i_nlink = 1;
 152
 153     newip->i_mode = IFREG;
 154
 155     IN_UNLOCK(newip);
 156     vp = ITOV(newip);
 157     VN_LOCK(vp);
 158     vp->v_type = VREG;
 159     VN_UNLOCK(vp);
 160
 161     /*
 162      * if ( !vp->v_object)
 163      * {
 164      * extern struct vfs_ubcops ufs_ubcops;
 165      * extern struct vm_ubc_object* ubc_object_allocate();
 166      * struct vm_ubc_object* vop;
 167      * vop = ubc_object_allocate(&vp, &ufs_ubcops,
 168      * vp->v_mount->m_funnel);
 169      * VN_LOCK(vp);
 170      * vp->v_object = vop;
 171      * VN_UNLOCK(vp);
 172      * }
 173      */
 174
 175     IN_LOCK(newip);
 176     /*    newip->i_flags |= IC_XUID|IC_XGID; */
 177     /*    newip->i_flags &= ~IC_PROPLIST; */
 178     newip->i_vicep1 = param1;
 179     if (param2 == 0x1fffffff /*INODESPECIAL*/) {
 180         newip->i_vicep2 = ((0x1fffffff << 3) + (param4 & 0x3));
 181         newip->i_vicep3a = (u_short) (param3 >> 16);
 182         newip->i_vicep3b = (u_short) param3;
 183     } else {
 184         newip->i_vicep2 =
 185             (((param2 >> 16) & 0x1f) << 27) +
 186             (((param4 >> 16) & 0x1f) << 22) + (param3 & 0x3fffff);
 187         newip->i_vicep3a = (u_short) param4;
 188         newip->i_vicep3b = (u_short) param2;
 189     }
 190     newip->i_vicemagic = VICEMAGIC;
 191
 192     *retval = newip->i_number;
 193     IN_UNLOCK(newip);
 194     iput(newip);
 195     return (code);
 196 }
 197
 198
 199 int
 200 afs_syscall_iopen(dev, inode, usrmod, retval)
 201      long *retval;
 202      int dev, inode, usrmod;
 203 {
 204     struct file *fp;
 205     struct inode *ip;
 206     struct vnode *vp = NULL;
 207     int dummy;
 208     int fd;
 209     extern struct fileops vnops;
 210     int code;
 211
 212     AFS_STATCNT(afs_syscall_iopen);
 213
 214     if (!afs_suser(NULL))
 215         return (EPERM);
 216
 217     code = igetinode(0, (dev_t) dev, (ino_t) inode, &ip, &dummy);
 218     if (code) {
 219         return (code);
 220     }
 221     if ((code = falloc(curproc, &fp, &fd)) != 0) {
 222         iput(ip);
 223         return (code);
 224     }
 225     IN_UNLOCK(ip);
 226
 227     /* FreeBSD doesn't do much mp stuff yet :( */
 228     /* FP_LOCK(fp); */
 229     fp->f_flag = (usrmod) & FMASK;
 230     fp->f_type = DTYPE_VNODE;
 231     fp->f_ops = &vnops;
 232     fp->f_data = (caddr_t) ITOV(ip);
 233
 234     /* FP_UNLOCK(fp); */
 235     return (0);
 236 }
 237
 238
 239 /*
 240  * Support for iinc() and idec() system calls--increment or decrement
 241  * count on inode.
 242  * Restricted to super user.
 243  * Only VICEMAGIC type inodes.
 244  */
 245 int
 246 afs_syscall_iincdec(dev, inode, inode_p1, amount)
 247      int dev, inode, inode_p1, amount;
 248 {
 249     int dummy;
 250     struct inode *ip;
 251     int code;
 252
 253     if (!afs_suser(NULL))
 254         return (EPERM);
 255
 256     code = igetinode(0, (dev_t) dev, (ino_t) inode, &ip, &dummy);
 257     if (code) {
 258         return (code);
 259     }
 260     if (!IS_VICEMAGIC(ip)) {
 261         return (EPERM);
 262     } else if (ip->i_vicep1 != inode_p1) {
 263         return (ENXIO);
 264     }
 265     ip->i_nlink += amount;
 266     if (ip->i_nlink == 0) {
 267         CLEAR_VICEMAGIC(ip);
 268     }
 269     ip->i_flag |= ICHG;
 270     iput(ip);
 271     return (0);
 272 }
 273 #else
 274 int
 275 afs_syscall_icreate(dev, near_inode, param1, param2, param3, param4, retval)
 276      long *retval;
 277      long dev, near_inode, param1, param2, param3, param4;
 278 {
 279     return EOPNOTSUPP;
 280 }
 281
 282 int
 283 afs_syscall_iopen(dev, inode, usrmod, retval)
 284      long *retval;
 285      int dev, inode, usrmod;
 286 {
 287     return EOPNOTSUPP;
 288 }
 289
 290 int
 291 afs_syscall_iincdec(dev, inode, inode_p1, amount)
 292      int dev, inode, inode_p1, amount;
 293 {
 294     return EOPNOTSUPP;
 295 }
 296 #endif