ccf4661fc462b313db93ced4dd03af9229656f52
[openafs.git] / 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()) {
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()) {
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()) {
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 }