src/afs/HPUX/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  * HPUX inode operations
  12  *
  13  * Implements:
  14  *
  15  */
  16 #include <afsconfig.h>
  17 #include "afs/param.h"
  18
  19 RCSID
  20     ("$Header$");
  21
  22 #include "afs/sysincludes.h"    /* Standard vendor system headers */
  23 #include "afsincludes.h"        /* Afs-based standard headers */
  24 #include "afs/osi_inode.h"
  25 #include "afs/afs_stats.h"      /* statistics stuff */
  26 #include <sys/mount.h>
  27
  28
  29 static struct inode *
  30 getinode(struct vfs *vfsp, dev_t dev, ino_t inode, int *perror)
  31 {
  32     struct mount *mp = (vfsp ? VFSTOM(vfsp) : 0);
  33     struct inode *pip;
  34     *perror = 0;
  35
  36     if (!mp && !(mp = getmp(dev))) {
  37         u.u_error = ENXIO;
  38         return (NULL);
  39     }
  40     pip = iget(dev, mp, inode);
  41     if (!pip)
  42         *perror = BAD_IGET;
  43     return (pip);
  44 }
  45
  46 struct inode *
  47 igetinode(struct vfs *vfsp, dev_t dev, ino_t inode, int *perror)
  48 {
  49     struct inode *pip, *ip;
  50     extern struct osi_dev cacheDev;
  51     register int code = 0;
  52
  53     *perror = 0;
  54     AFS_STATCNT(igetinode);
  55     ip = getinode(vfsp, dev, inode, perror);
  56     if (ip == NULL) {
  57         *perror = BAD_IGET;
  58         u.u_error = ENOENT;     /* Well... */
  59         return;
  60     }
  61     if (ip->i_mode == 0) {
  62         /* Not an allocated inode */
  63         iforget(ip);
  64         u.u_error = ENOENT;
  65         return;
  66     }
  67     if (ip->i_nlink == 0 || (ip->i_mode & IFMT) != IFREG) {
  68         iput(ip);
  69         u.u_error = ENOENT;
  70         return;
  71     }
  72     return ip;
  73 }
  74
  75 iforget(ip)
  76      struct inode *ip;
  77 {
  78     idrop(ip);
  79 }
  80
  81 afs_syscall_icreate(dev, near_inode, param1, param2, param3, param4)
  82      long dev, near_inode, param1, param2, param3, param4;
  83 {
  84     int dummy, err = 0;
  85     struct inode *ip, *newip;
  86
  87     AFS_STATCNT(afs_syscall_icreate);
  88
  89     if (!afs_suser(NULL)) {
  90         u.u_error = EPERM;
  91         goto out;
  92     }
  93
  94     ip = getinode(0, (dev_t) dev, 2, &dummy);
  95     if (ip == NULL) {
  96         u.u_error = ENOENT;     /* Well... */
  97         goto out;
  98     }
  99
 100     newip = (struct inode *)ialloc(ip, near_inode, 0);
 101     iput(ip);
 102     if (newip == NULL)
 103         goto out;
 104
 105     newip->i_flag |= IACC | IUPD | ICHG;
 106     newip->i_nlink = 1;
 107     newip->i_mode = IFREG;
 108     newip->i_vnode.v_type = VREG;
 109     newip->i_vicemagic = VICEMAGIC;
 110     newip->i_vicep1 = param1;
 111     newip->i_vicep2 = param2;
 112     I_VICE3(newip) = param3;
 113     newip->i_vicep4 = param4;
 114     u.u_r.r_val1 = newip->i_number;
 115
 116     iput(newip);
 117
 118   out:
 119     return err;
 120 }
 121
 122 afs_syscall_iopen(dev, inode, usrmod)
 123      int dev, inode, usrmod;
 124 {
 125     struct file *fp;
 126     struct inode *ip;
 127     struct vnode *vp = NULL;
 128     int dummy;
 129     extern struct fileops vnodefops;
 130     register int code;
 131
 132     AFS_STATCNT(afs_syscall_iopen);
 133
 134     if (!afs_suser(NULL)) {
 135         u.u_error = EPERM;
 136         goto out;
 137     }
 138
 139     ip = igetinode(0, (dev_t) dev, (ino_t) inode, &dummy);
 140     if (u.u_error)
 141         goto out;
 142     fp = falloc();
 143     if (!fp) {
 144         iput(ip);
 145         goto out;
 146     }
 147     iunlock(ip);
 148
 149     fp->f_ops = &vnodefops;
 150     vp = ITOV(ip);
 151     fp->f_data = (char *)vp;
 152     fp->f_type = DTYPE_VNODE;
 153     fp->f_flag = (usrmod + 1) & (FMASK);
 154
 155     /* Obtained from hp kernel sys/vfs_scalls.c: copen().
 156      * Otherwise we panic because the v_writecount
 157      * goes less than 0 during close.
 158      */
 159     if ((vp->v_type == VREG) && (fp->f_flag & FWRITE)) {
 160         VN_INC_WRITECOUNT(vp);
 161     }
 162
 163     /* fp->f_count, f_msgcount are set by falloc */
 164     /* fp->f_offset zeroed by falloc */
 165     /* f_cred set by falloc */
 166
 167     /*
 168      * Obtained from hp kernel sys/vfs_scalls.c: copen() does
 169      * a PUTF() (defined earlier in the file) before returning,
 170      * so we parrot what it does.  If this is not done, then
 171      * threaded processes will get EBADF errors when they try
 172      * to use the resulting file descriptor (e.g. with lseek()).
 173      *
 174      * Note: u.u_r.r_val1 is set by ufalloc(), which is
 175      * called by falloc(), which is called above.
 176      */
 177     if (is_multithreaded(u.u_procp)) {
 178         int fd = (int)u.u_r.r_val1;
 179         putf(fd);
 180     }
 181
 182   out:
 183     return;
 184 }
 185
 186 afs_syscall_iincdec(dev, inode, inode_p1, amount)
 187      int dev, inode, inode_p1, amount;
 188 {
 189     int dummy;
 190     struct inode *ip;
 191     register afs_int32 code;
 192
 193     if (!afs_suser(NULL)) {
 194         u.u_error = EPERM;
 195         goto out;
 196     }
 197
 198     ip = igetinode(0, (dev_t) dev, (ino_t) inode, &dummy);
 199     if (u.u_error) {
 200         goto out;
 201     }
 202
 203     if (!IS_VICEMAGIC(ip))
 204         u.u_error = EPERM;
 205     else if (ip->i_vicep1 != inode_p1)
 206         u.u_error = ENXIO;
 207     else {
 208         ip->i_nlink += amount;
 209         if (ip->i_nlink == 0) {
 210             CLEAR_VICEMAGIC(ip);
 211         }
 212         ip->i_flag |= ICHG;
 213     }
 214
 215     iput(ip);
 216
 217   out:
 218     return;
 219 }