initial-freebsd-port-work-20010414
[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 "../afs/param.h"       /* Should be always first */
17 #include "../afs/sysincludes.h" /* Standard vendor system headers */
18 #include "../afs/afsincludes.h" /* Afs-based standard headers */
19 #include "../afs/osi_inode.h"
20 #include "../afs/afs_stats.h" /* statistics stuff */
21 #include <sys/queue.h>
22 #include <sys/lock.h>
23 #include <ufs/ufsmount.h>
24 #include <ufs/ufs/dinode.h>
25
26 getinode(fs, dev, inode, ipp, perror)
27      struct mount *fs;
28      struct inode **ipp;
29      dev_t dev;
30      ino_t inode;
31      int *perror;
32 {
33     register struct vnode *vp;
34     char fake_vnode[FAKE_INODE_SIZE];
35     struct inode *ip;
36     int code;
37
38     *ipp = 0;
39     *perror = 0;
40     if (!fs) {
41         register struct ufsmount *ump;
42         register struct vnode *vp;
43         register struct mount *mp;
44         
45         MOUNTLIST_LOCK();
46         if (mp = TAILQ_FIRST(&mountlist)) do {
47             /*
48              * XXX Also do the test for MFS 
49              */
50 #undef m_data
51 #undef m_next
52             if (mp->mnt_stat.f_type == MOUNT_UFS) {     
53                 MOUNTLIST_UNLOCK();
54                 ump = VFSTOUFS(mp);
55                 if (ump->um_fs == NULL)
56                     break;
57                 if (ump->um_dev == dev) {
58                     fs = ump->um_mountp;
59                 }
60                 MOUNTLIST_LOCK();
61             }
62             mp = TAILQ_NEXT(mp, mnt_list);
63         } while (mp != TAILQ_FIRST(&mountlist));
64         MOUNTLIST_UNLOCK();
65         if (!fs)
66             return(ENXIO);
67     }
68     vp = (struct vnode *) fake_vnode;
69     fake_inode_init(vp, fs);
70     code = iget(VTOI(vp), inode, &ip, 0);
71     if (code != 0) {
72         *perror = BAD_IGET;
73         return code;
74     } else {
75         *ipp = ip;
76         return(0);
77     }
78 }
79
80 igetinode(vfsp, dev, inode, ipp, perror)
81      struct inode **ipp;
82      struct mount *vfsp;
83      dev_t dev;
84      ino_t inode;
85      int *perror;
86 {
87     struct inode *pip, *ip;
88     extern struct osi_dev cacheDev;
89     register int code = 0;
90
91     *perror = 0;
92
93     AFS_STATCNT(igetinode);
94
95     if ((code = getinode(vfsp, dev, inode, &ip, perror)) != 0) {
96         return(code);
97     }
98
99     if (ip->i_mode == 0) {
100         /* Not an allocated inode */
101         iforget(ip);        
102         return(ENOENT);
103     }
104
105     if (ip->i_nlink == 0 || (ip->i_mode&IFMT) != IFREG) {
106         iput(ip);
107         return(ENOENT);
108     }
109
110     *ipp = ip;
111     return(0);
112 }
113
114 iforget(ip)
115 struct inode *ip;
116 {
117     struct vnode *vp = ITOV(ip);
118
119     AFS_STATCNT(iforget);
120
121     VN_LOCK(vp);
122     /* this whole thing is too wierd.  Why??? XXX */
123     if (vp->v_usecount == 1) {
124         VN_UNLOCK(vp);
125         idrop(ip);
126     } else {
127         VN_UNLOCK(vp);
128     }
129 }
130
131 /*
132  * icreate system call -- create an inode
133  */
134 afs_syscall_icreate(dev, near_inode, param1, param2, param3, param4, retval)
135      long *retval;
136      long dev, near_inode, param1, param2, param3, param4;
137 {
138     int dummy, err=0;
139     struct inode *ip, *newip;
140     register int code;
141     struct vnode *vp;
142     
143     AFS_STATCNT(afs_syscall_icreate);
144     
145     if (!afs_suser())
146         return(EPERM);
147
148     code = getinode(0, (dev_t)dev, 2, &ip, &dummy);
149     if (code) {
150         return(ENOENT);
151     }
152     code = ialloc(ip, (ino_t)near_inode, 0, &newip);
153     iput(ip);
154     if (code) {
155         return(code);
156     }
157     IN_LOCK(newip);
158     newip->i_flag |= IACC|IUPD|ICHG;
159     
160     newip->i_nlink = 1;
161
162     newip->i_mode = IFREG;
163     
164     IN_UNLOCK(newip);
165     vp = ITOV(newip);
166     VN_LOCK(vp);
167     vp->v_type = VREG;
168     VN_UNLOCK(vp);
169     
170     /*
171     if ( !vp->v_object)
172         {
173             extern struct vfs_ubcops ufs_ubcops;
174             extern struct vm_ubc_object* ubc_object_allocate();
175             struct vm_ubc_object* vop;
176             vop = ubc_object_allocate(&vp, &ufs_ubcops,
177                                       vp->v_mount->m_funnel);
178             VN_LOCK(vp);
179             vp->v_object = vop;
180             VN_UNLOCK(vp);
181         }
182     */
183     
184     IN_LOCK(newip);
185     /*    newip->i_flags |= IC_XUID|IC_XGID; */
186     /*    newip->i_flags &= ~IC_PROPLIST; */
187     newip->i_vicep1 = param1;
188     if (param2 == 0x1fffffff/*INODESPECIAL*/)   {
189         newip->i_vicep2 = ((0x1fffffff << 3) + (param4 & 0x3));
190         newip->i_vicep3a = (u_short)(param3 >> 16);
191         newip->i_vicep3b = (u_short)param3;
192     } else {
193         newip->i_vicep2 = (((param2 >> 16) & 0x1f) << 27) +
194             (((param4 >> 16) & 0x1f) << 22) + 
195                 (param3 & 0x3fffff);        
196         newip->i_vicep3a = (u_short)param4;
197         newip->i_vicep3b = (u_short)param2;
198     }
199     newip->i_vicemagic = VICEMAGIC;
200     
201     *retval = newip->i_number;
202     IN_UNLOCK(newip);
203     iput(newip);
204     return(code);
205 }
206
207
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 = (struct vnode *)0;
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 afs_syscall_iincdec(dev, inode, inode_p1, amount)
254      int dev, inode, inode_p1, amount;
255 {
256     int dummy;
257     struct inode *ip;
258     register int code;
259     
260     if (!afs_suser())
261         return(EPERM);
262
263     code = igetinode(0, (dev_t)dev, (ino_t)inode, &ip, &dummy);
264     if (code) {
265         return(code);
266     }
267     if (!IS_VICEMAGIC(ip)) {
268         return(EPERM);
269     } else if (ip->i_vicep1 != inode_p1) {
270         return(ENXIO);
271     }
272     ip->i_nlink += amount;
273     if (ip->i_nlink == 0) {
274         CLEAR_VICEMAGIC(ip);
275     }
276     ip->i_flag |= ICHG;
277     iput(ip);
278     return(0);
279 }