Catch up to FreeBSD non-MPSAFE deorbit
[openafs.git] / src / afs / FBSD / osi_vfsops.c
1 #include <afsconfig.h>
2 #include <afs/param.h>
3
4
5 #include <afs/sysincludes.h>    /* Standard vendor system headers */
6 #include <afsincludes.h>        /* Afs-based standard headers */
7 #include <afs/afs_stats.h>      /* statistics */
8 #include <sys/malloc.h>
9 #include <sys/namei.h>
10 #include <sys/conf.h>
11 #include <sys/module.h>
12 #include <sys/sysproto.h>
13 #include <sys/syscall.h>
14 #include <sys/sysent.h>
15
16 struct vcache *afs_globalVp = NULL;
17 struct mount *afs_globalVFS = NULL;
18 int afs_pbuf_freecnt = -1;
19
20 extern int Afs_xsetgroups();
21 extern int afs_xioctl();
22
23 #if !defined(AFS_FBSD90_ENV) && !defined(AFS_FBSD82_ENV)
24 static sy_call_t *old_handler;
25 #else
26 static struct sysent old_sysent;
27
28 static struct sysent afs_sysent = {
29     5,                  /* int sy_narg */
30     (sy_call_t *) afs3_syscall, /* sy_call_t *sy_call */
31 #ifdef AFS_FBSD60_ENV
32     AUE_NULL,           /* au_event_t sy_auevent */
33 #ifdef AFS_FBSD70_ENV
34     NULL,               /* systrace_args_funt_t sy_systrace_args_func */
35     0,                  /* u_int32_t sy_entry */
36     0,                  /* u_int32_t sy_return */
37 #ifdef AFS_FBSD90_ENV
38     0,                  /* u_int32_t sy_flags */
39     0                   /* u_int32_t sy_thrcnt */
40 #endif
41 #endif
42 #endif /* FBSD60 */
43 };
44 #endif /* FBSD90 */
45
46 int
47 afs_init(struct vfsconf *vfc)
48 {
49     int code;
50     int offset = AFS_SYSCALL;
51 #if defined(AFS_FBSD90_ENV) || defined(AFS_FBSD82_ENV)
52     code = syscall_register(&offset, &afs_sysent, &old_sysent);
53     if (code) {
54         printf("AFS_SYSCALL in use, error %i. aborting\n", code);
55         return code;
56     }
57 #else
58     if (sysent[AFS_SYSCALL].sy_call != (sy_call_t *)nosys
59         && sysent[AFS_SYSCALL].sy_call != (sy_call_t *)lkmnosys) {
60         printf("AFS_SYSCALL in use. aborting\n");
61         return EBUSY;
62     }
63 #endif
64     osi_Init();
65     afs_pbuf_freecnt = nswbuf / 2 + 1;
66 #if !defined(AFS_FBSD90_ENV) && !defined(AFS_FBSD82_ENV)
67     old_handler = sysent[AFS_SYSCALL].sy_call;
68     sysent[AFS_SYSCALL].sy_call = afs3_syscall;
69     sysent[AFS_SYSCALL].sy_narg = 5;
70 #endif
71     return 0;
72 }
73
74 int
75 afs_uninit(struct vfsconf *vfc)
76 {
77 #if defined(AFS_FBSD90_ENV) || defined(AFS_FBSD82_ENV)
78     int offset = AFS_SYSCALL;
79 #endif
80
81     if (afs_globalVFS)
82         return EBUSY;
83 #if defined(AFS_FBSD90_ENV) || defined(AFS_FBSD82_ENV)
84     syscall_deregister(&offset, &old_sysent);
85 #else
86     sysent[AFS_SYSCALL].sy_narg = 0;
87     sysent[AFS_SYSCALL].sy_call = old_handler;
88 #endif
89     return 0;
90 }
91
92 int
93 afs_start(struct mount *mp, int flags, struct thread *p)
94 {
95     return (0);                 /* nothing to do. ? */
96 }
97
98 int
99 #if defined(AFS_FBSD80_ENV)
100 afs_omount(struct mount *mp, char *path, caddr_t data)
101 #elif defined(AFS_FBSD53_ENV)
102 afs_omount(struct mount *mp, char *path, caddr_t data, struct thread *p)
103 #else
104 afs_omount(struct mount *mp, char *path, caddr_t data, struct nameidata *ndp,
105         struct thread *p)
106 #endif
107 {
108     /* ndp contains the mounted-from device.  Just ignore it.
109      * we also don't care about our thread struct. */
110     size_t size;
111
112     if (mp->mnt_flag & MNT_UPDATE)
113         return EINVAL;
114
115     AFS_GLOCK();
116     AFS_STATCNT(afs_mount);
117
118     if (afs_globalVFS) {        /* Don't allow remounts. */
119         AFS_GUNLOCK();
120         return EBUSY;
121     }
122
123     afs_globalVFS = mp;
124     mp->vfs_bsize = 8192;
125     vfs_getnewfsid(mp);
126     /*
127      * This is kind of ugly, as the interlock has grown to encompass
128      * more fields over time and there's not a good way to group the
129      * code without duplication.
130      */
131 #ifdef AFS_FBSD62_ENV
132     MNT_ILOCK(mp);
133 #endif
134     mp->mnt_flag &= ~MNT_LOCAL;
135 #if defined(AFS_FBSD61_ENV) && !defined(AFS_FBSD62_ENV)
136     MNT_ILOCK(mp);
137 #endif
138 #if __FreeBSD_version < 1000021
139     mp->mnt_kern_flag |= MNTK_MPSAFE; /* solid steel */
140 #endif
141 #ifndef AFS_FBSD61_ENV
142     MNT_ILOCK(mp);
143 #endif
144     /*
145      * XXX mnt_stat "is considered stable as long as a ref is held".
146      * We should check that we hold the only ref.
147      */
148     mp->mnt_stat.f_iosize = 8192;
149
150     if (path != NULL)
151         copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN - 1, &size);
152     else
153         bcopy("/afs", mp->mnt_stat.f_mntonname, size = 4);
154     memset(mp->mnt_stat.f_mntonname + size, 0, MNAMELEN - size);
155     memset(mp->mnt_stat.f_mntfromname, 0, MNAMELEN);
156     strcpy(mp->mnt_stat.f_mntfromname, "AFS");
157     /* null terminated string "AFS" will fit, just leave it be. */
158     strcpy(mp->mnt_stat.f_fstypename, "afs");
159     MNT_IUNLOCK(mp);
160     AFS_GUNLOCK();
161 #ifdef AFS_FBSD80_ENV
162     afs_statfs(mp, &mp->mnt_stat);
163 #else
164     afs_statfs(mp, &mp->mnt_stat, p);
165 #endif
166
167     return 0;
168 }
169
170 #ifdef AFS_FBSD53_ENV
171 int
172 #ifdef AFS_FBSD80_ENV
173 afs_mount(struct mount *mp)
174 #else
175 afs_mount(struct mount *mp, struct thread *td)
176 #endif
177 {
178 #ifdef AFS_FBSD80_ENV
179     return afs_omount(mp, NULL, NULL);
180 #else
181     return afs_omount(mp, NULL, NULL, td);
182 #endif
183 }
184 #endif
185
186 #ifdef AFS_FBSD60_ENV
187 static int
188 #ifdef AFS_FBSD80_ENV
189 afs_cmount(struct mntarg *ma, void *data, int flags)
190 #else
191 afs_cmount(struct mntarg *ma, void *data, int flags, struct thread *td)
192 #endif
193 {
194     return kernel_mount(ma, flags);
195 }
196 #endif
197
198 int
199 #ifdef AFS_FBSD80_ENV
200 afs_unmount(struct mount *mp, int flags)
201 #else
202 afs_unmount(struct mount *mp, int flags, struct thread *p)
203 #endif
204 {
205     int error = 0;
206
207     AFS_GLOCK();
208     if (afs_globalVp &&
209         ((flags & MNT_FORCE) || !VREFCOUNT_GT(afs_globalVp, 1))) {
210         /* Put back afs_root's ref */
211         struct vcache *gvp = afs_globalVp;
212         afs_globalVp = NULL;
213         afs_PutVCache(gvp);
214     }
215     if (afs_globalVp)
216         error = EBUSY;
217     AFS_GUNLOCK();
218
219     /*
220      * Release any remaining vnodes on this mount point.
221      * The `1' means that we hold one extra reference on
222      * the root vnode (this is just a guess right now).
223      * This has to be done outside the global lock.
224      */
225     if (!error) {
226 #if defined(AFS_FBSD80_ENV)
227         error = vflush(mp, 1, (flags & MNT_FORCE) ? FORCECLOSE : 0, curthread);
228 #elif defined(AFS_FBSD53_ENV)
229         error = vflush(mp, 1, (flags & MNT_FORCE) ? FORCECLOSE : 0, p);
230 #else
231         error = vflush(mp, 1, (flags & MNT_FORCE) ? FORCECLOSE : 0);
232 #endif
233     }
234     if (error)
235         goto out;
236     AFS_GLOCK();
237     AFS_STATCNT(afs_unmount);
238     afs_globalVFS = 0;
239     afs_shutdown();
240     AFS_GUNLOCK();
241
242 out:
243     return error;
244 }
245
246 int
247 #if defined(AFS_FBSD80_ENV)
248 afs_root(struct mount *mp, int flags, struct vnode **vpp)
249 #elif defined(AFS_FBSD60_ENV)
250 afs_root(struct mount *mp, int flags, struct vnode **vpp, struct thread *td)
251 #elif defined(AFS_FBSD53_ENV)
252 afs_root(struct mount *mp, struct vnode **vpp, struct thread *td)
253 #else
254 afs_root(struct mount *mp, struct vnode **vpp)
255 #endif
256 {
257     int error;
258     struct vrequest treq;
259     struct vcache *tvp = 0;
260     struct vcache *gvp;
261 #if !defined(AFS_FBSD53_ENV) || defined(AFS_FBSD80_ENV)
262     struct thread *td = curthread;
263 #endif
264     struct ucred *cr = osi_curcred();
265
266     AFS_GLOCK();
267     AFS_STATCNT(afs_root);
268     crhold(cr);
269 tryagain:
270     if (afs_globalVp && (afs_globalVp->f.states & CStatd)) {
271         tvp = afs_globalVp;
272         error = 0;
273     } else {
274         if (!(error = afs_InitReq(&treq, cr)) && !(error = afs_CheckInit())) {
275             tvp = afs_GetVCache(&afs_rootFid, &treq, NULL, NULL);
276             /* we really want this to stay around */
277             if (tvp) {
278                 gvp = afs_globalVp;
279                 afs_globalVp = tvp;
280                 if (gvp) {
281                     afs_PutVCache(gvp);
282                     if (tvp != afs_globalVp) {
283                         /* someone raced us and won */
284                         afs_PutVCache(tvp);
285                         goto tryagain;
286                     }
287                 }
288             } else
289                 error = ENOENT;
290         }
291     }
292     if (tvp) {
293         struct vnode *vp = AFSTOV(tvp);
294
295         ASSERT_VI_UNLOCKED(vp, "afs_root");
296         AFS_GUNLOCK();
297         error = vget(vp, LK_EXCLUSIVE | LK_RETRY, td);
298         AFS_GLOCK();
299         /* we dropped the glock, so re-check everything it had serialized */
300         if (!afs_globalVp || !(afs_globalVp->f.states & CStatd) ||
301                 tvp != afs_globalVp) {
302             vput(vp);
303             afs_PutVCache(tvp);
304             goto tryagain;
305         }
306         if (error != 0)
307             goto tryagain;
308         /*
309          * I'm uncomfortable about this.  Shouldn't this happen at a
310          * higher level, and shouldn't we busy the top-level directory
311          * to prevent recycling?
312          */
313         vp->v_vflag |= VV_ROOT;
314
315         afs_globalVFS = mp;
316         *vpp = vp;
317     }
318
319     afs_Trace2(afs_iclSetp, CM_TRACE_VFSROOT, ICL_TYPE_POINTER, tvp ? AFSTOV(tvp) : NULL,
320                ICL_TYPE_INT32, error);
321     AFS_GUNLOCK();
322     crfree(cr);
323     return error;
324 }
325
326 int
327 #ifdef AFS_FBSD80_ENV
328 afs_statfs(struct mount *mp, struct statfs *abp)
329 #else
330 afs_statfs(struct mount *mp, struct statfs *abp, struct thread *p)
331 #endif
332 {
333     AFS_GLOCK();
334     AFS_STATCNT(afs_statfs);
335
336     abp->f_bsize = mp->vfs_bsize;
337     abp->f_iosize = mp->vfs_bsize;
338
339     /* Fake a high number below to satisfy programs that use the statfs call
340      * to make sure that there's enough space in the device partition before
341      * storing something there.
342      */
343     abp->f_blocks = abp->f_bfree = abp->f_bavail = abp->f_files =
344         abp->f_ffree = 2000000;
345
346     abp->f_fsid.val[0] = mp->mnt_stat.f_fsid.val[0];
347     abp->f_fsid.val[1] = mp->mnt_stat.f_fsid.val[1];
348     if (abp != &mp->mnt_stat) {
349         abp->f_type = mp->mnt_vfc->vfc_typenum;
350         memcpy((caddr_t) & abp->f_mntonname[0],
351                (caddr_t) mp->mnt_stat.f_mntonname, MNAMELEN);
352         memcpy((caddr_t) & abp->f_mntfromname[0],
353                (caddr_t) mp->mnt_stat.f_mntfromname, MNAMELEN);
354     }
355
356     AFS_GUNLOCK();
357     return 0;
358 }
359
360 int
361 #if defined(AFS_FBSD80_ENV)
362 afs_sync(struct mount *mp, int waitfor)
363 #elif defined(AFS_FBSD60_ENV)
364 afs_sync(struct mount *mp, int waitfor, struct thread *td)
365 #else
366 afs_sync(struct mount *mp, int waitfor, struct ucred *cred, struct thread *p)
367 #endif
368 {
369     return 0;
370 }
371
372 #ifdef AFS_FBSD60_ENV
373 struct vfsops afs_vfsops = {
374         .vfs_init =             afs_init,
375         .vfs_mount =            afs_mount,
376         .vfs_cmount =           afs_cmount,
377         .vfs_root =             afs_root,
378         .vfs_statfs =           afs_statfs,
379         .vfs_sync =             afs_sync,
380         .vfs_uninit =           afs_uninit,
381         .vfs_unmount =          afs_unmount,
382         .vfs_sysctl =           vfs_stdsysctl,
383 };
384 #else
385 struct vfsops afs_vfsops = {
386 #ifdef AFS_FBSD53_ENV
387     afs_mount,
388 #endif
389     afs_omount,
390     afs_start,
391     afs_unmount,
392     afs_root,
393     vfs_stdquotactl,
394     afs_statfs,
395     afs_sync,
396     vfs_stdvget,
397     vfs_stdfhtovp,
398     vfs_stdcheckexp,
399     vfs_stdvptofh,
400     afs_init,
401     afs_uninit,
402     vfs_stdextattrctl,
403     vfs_stdsysctl,
404 };
405 #endif