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