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