919fd3717bc2d3029ae1642de811f73fffa21200
[dragonfly.git] / sys / vfs / nullfs / null_vfsops.c
1 /*
2  * Copyright (c) 1992, 1993, 1995
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software donated to Berkeley by
6  * Jan-Simon Pendry.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *      This product includes software developed by the University of
19  *      California, Berkeley and its contributors.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  *
36  *      @(#)null_vfsops.c       8.2 (Berkeley) 1/21/94
37  *
38  * @(#)lofs_vfsops.c    1.2 (Berkeley) 6/18/92
39  * $FreeBSD: src/sys/miscfs/nullfs/null_vfsops.c,v 1.35.2.3 2001/07/26 20:37:11 iedowse Exp $
40  * $DragonFly: src/sys/vfs/nullfs/null_vfsops.c,v 1.31 2008/09/17 21:44:25 dillon Exp $
41  */
42
43 /*
44  * Null Layer
45  * (See null_vnops.c for a description of what this does.)
46  */
47
48 #include <sys/param.h>
49 #include <sys/systm.h>
50 #include <sys/kernel.h>
51 #include <sys/proc.h>
52 #include <sys/malloc.h>
53 #include <sys/vnode.h>
54 #include <sys/mount.h>
55 #include <sys/nlookup.h>
56 #include <sys/mountctl.h>
57 #include "null.h"
58
59 extern struct vop_ops null_vnode_vops;
60
61 static MALLOC_DEFINE(M_NULLFSMNT, "NULLFS mount", "NULLFS mount structure");
62
63 static int      nullfs_root(struct mount *mp, struct vnode **vpp);
64 static int      nullfs_statfs(struct mount *mp, struct statfs *sbp,
65                                 struct ucred *cred);
66
67 /*
68  * Mount null layer
69  */
70 static int
71 nullfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
72 {
73         int error = 0;
74         struct null_args args;
75         struct vnode *rootvp;
76         struct null_mount *xmp;
77         u_int size;
78         struct nlookupdata nd;
79         fhandle_t fh;
80
81         NULLFSDEBUG("nullfs_mount(mp = %p)\n", (void *)mp);
82
83         /*
84          * Update is a no-op
85          */
86         if (mp->mnt_flag & MNT_UPDATE) {
87                 return (EOPNOTSUPP);
88         }
89
90         /*
91          * Get argument
92          */
93         error = copyin(data, (caddr_t)&args, sizeof(struct null_args));
94         if (error)
95                 return (error);
96
97         /*
98          * Find lower node
99          */
100         rootvp = NULL;
101         error = nlookup_init(&nd, args.target, UIO_USERSPACE, NLC_FOLLOW);
102         if (error)
103                 goto fail1;
104         error = nlookup(&nd);
105         if (error)
106                 goto fail2;
107         error = cache_vget(&nd.nl_nch, nd.nl_cred, LK_EXCLUSIVE, &rootvp);
108         if (error)
109                 goto fail2;
110
111         xmp = (struct null_mount *) kmalloc(sizeof(struct null_mount),
112                                 M_NULLFSMNT, M_WAITOK | M_ZERO);
113
114         /*
115          * Save reference to underlying FS
116          *
117          * As lite stacking enters the scene, the old way of doing this
118          * -- via the vnode -- is not good enough anymore.  Use the
119          * underlying filesystem's namecache handle as our mount point
120          * root, adjusting the mount to point to us. 
121          *
122          * NCF_ISMOUNTPT is normally set on the mount point, but we also
123          * want to set it on the base directory being mounted to prevent
124          * that directory from being destroyed out from under the nullfs
125          * mount. 
126          *
127          * The forwarding mount pointer (xmp->nullm_vfs) must be set to
128          * the actual target filesystem.  If the target filesystem was
129          * resolved via a nullfs mount nd.nl_nch.mount will be pointing
130          * to the nullfs mount structure instead of the target filesystem,
131          * which would otherwise cause the mount VOPS and VFSOPS to recurse
132          * endlessly.  If we are mounting via a nullfs mount we inherit
133          * its read-only state, if set.
134          */
135         xmp->nullm_vfs = nd.nl_nch.mount;
136         if (xmp->nullm_vfs != rootvp->v_mount) {
137                 if (xmp->nullm_vfs->mnt_flag & MNT_RDONLY)
138                         mp->mnt_flag |= MNT_RDONLY;
139                 xmp->nullm_vfs = rootvp->v_mount;
140         }
141
142         /*
143          * ncmountpt is the parent glue.  When mounting a nullfs via a nullfs
144          * we retain the parent nullfs to create a unique chain tuple.
145          */
146         mp->mnt_ncmountpt = nd.nl_nch;
147         cache_changemount(&mp->mnt_ncmountpt, mp);
148         mp->mnt_ncmountpt.ncp->nc_flag |= NCF_ISMOUNTPT;
149         cache_unlock(&mp->mnt_ncmountpt);
150         cache_zero(&nd.nl_nch);
151         nlookup_done(&nd);
152
153         vfs_add_vnodeops(mp, &null_vnode_vops, &mp->mnt_vn_norm_ops);
154
155         vn_unlock(rootvp);              /* leave reference intact */
156
157         /*
158          * Keep a held reference to the root vnode.
159          * It is vrele'd in nullfs_unmount.
160          */
161         xmp->nullm_rootvp = rootvp;
162         /*
163          * XXX What's the proper safety condition for querying
164          * the underlying mount? Is this flag tuning necessary
165          * at all?
166          */
167         if (xmp->nullm_vfs->mnt_flag & MNT_LOCAL)
168                 mp->mnt_flag |= MNT_LOCAL;
169         mp->mnt_data = (qaddr_t) xmp;
170
171         /*
172          * Try to create a unique but non-random fsid for the nullfs to
173          * allow it to be exported via NFS.
174          */
175         bzero(&fh, sizeof(fh));
176         fh.fh_fsid = rootvp->v_mount->mnt_stat.f_fsid;
177         if (VFS_VPTOFH(rootvp, &fh.fh_fid) == 0) {
178                 fh.fh_fsid.val[1] ^= crc32(&fh.fh_fid, sizeof(fh.fh_fid));
179                 vfs_setfsid(mp, &fh.fh_fsid);
180         } else {
181                 vfs_getnewfsid(mp);
182         }
183
184         (void) copyinstr(args.target, mp->mnt_stat.f_mntfromname, MNAMELEN - 1,
185             &size);
186         bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
187         (void)nullfs_statfs(mp, &mp->mnt_stat, cred);
188         NULLFSDEBUG("nullfs_mount: lower %s, alias at %s\n",
189                 mp->mnt_stat.f_mntfromname, mp->mnt_stat.f_mntfromname);
190
191         /*
192          * So unmount won't complain about namecache refs still existing
193          */
194         mp->mnt_kern_flag |= MNTK_NCALIASED;
195         return (0);
196 fail2:
197         nlookup_done(&nd);
198 fail1:
199         return (error);
200 }
201
202 /*
203  * Free reference to null layer
204  */
205 static int
206 nullfs_unmount(struct mount *mp, int mntflags)
207 {
208         struct null_mount *xmp;
209         int flags = 0;
210
211         NULLFSDEBUG("nullfs_unmount: mp = %p\n", (void *)mp);
212
213         if (mntflags & MNT_FORCE)
214                 flags |= FORCECLOSE;
215
216         /*
217          * Finally, throw away the null_mount structure
218          */
219         xmp = (void *)mp->mnt_data;
220         mp->mnt_data = 0;
221         if (xmp->nullm_rootvp) {
222                 vrele(xmp->nullm_rootvp);
223                 xmp->nullm_rootvp = NULL;
224         }
225         kfree(xmp, M_NULLFSMNT);
226         return 0;
227 }
228
229 static int
230 nullfs_root(struct mount *mp, struct vnode **vpp)
231 {
232         struct vnode *vp;
233         int error;
234
235         NULLFSDEBUG("nullfs_root(mp = %p, vp = %p)\n", (void *)mp,
236             (void *)MOUNTTONULLMOUNT(mp)->nullm_rootvp);
237
238         /*
239          * Return locked reference to root.
240          */
241         vp = MOUNTTONULLMOUNT(mp)->nullm_rootvp;
242         error = vget(vp, LK_EXCLUSIVE | LK_RETRY);
243         if (error == 0)
244                 *vpp = vp;
245         return (error);
246 }
247
248 static int
249 nullfs_quotactl(struct mount *mp, int cmd, uid_t uid, caddr_t arg,
250                 struct ucred *cred)
251 {
252         return VFS_QUOTACTL(MOUNTTONULLMOUNT(mp)->nullm_vfs, cmd, uid, arg, cred);
253 }
254
255 static int
256 nullfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
257 {
258         int error;
259         struct statfs mstat;
260
261         NULLFSDEBUG("nullfs_statfs(mp = %p, vp = %p)\n", (void *)mp,
262             (void *)MOUNTTONULLMOUNT(mp)->nullm_rootvp);
263
264         bzero(&mstat, sizeof(mstat));
265
266         error = VFS_STATFS(MOUNTTONULLMOUNT(mp)->nullm_vfs, &mstat, cred);
267         if (error)
268                 return (error);
269
270         /* now copy across the "interesting" information and fake the rest */
271         sbp->f_type = mstat.f_type;
272         sbp->f_flags = mstat.f_flags;
273         sbp->f_bsize = mstat.f_bsize;
274         sbp->f_iosize = mstat.f_iosize;
275         sbp->f_blocks = mstat.f_blocks;
276         sbp->f_bfree = mstat.f_bfree;
277         sbp->f_bavail = mstat.f_bavail;
278         sbp->f_files = mstat.f_files;
279         sbp->f_ffree = mstat.f_ffree;
280         if (sbp != &mp->mnt_stat) {
281                 bcopy(&mp->mnt_stat.f_fsid, &sbp->f_fsid, sizeof(sbp->f_fsid));
282                 bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
283         }
284         return (0);
285 }
286
287 /*
288  * Implement NFS export tracking
289  */
290 static int
291 nullfs_checkexp(struct mount *mp, struct sockaddr *nam, int *extflagsp,
292                 struct ucred **credanonp)
293 {
294         struct null_mount *xmp = (void *)mp->mnt_data;
295         struct netcred *np;
296         int error;
297
298         np = vfs_export_lookup(mp, &xmp->export, nam);
299         if (np) {
300                 *extflagsp = np->netc_exflags;
301                 *credanonp = &np->netc_anon;
302                 error = 0;
303         } else {
304                 error = EACCES;
305         }
306         return(error);
307 #if 0
308         return VFS_CHECKEXP(MOUNTTONULLMOUNT(mp)->nullm_vfs, nam, 
309                 extflagsp, credanonp);
310 #endif
311 }
312
313 int
314 nullfs_export(struct mount *mp, int op, const struct export_args *export)
315 {
316         struct null_mount *xmp = (void *)mp->mnt_data;
317         int error;
318
319         switch(op) {
320         case MOUNTCTL_SET_EXPORT:
321                 error = vfs_export(mp, &xmp->export, export);
322                 break;
323         default:
324                 error = EOPNOTSUPP;
325                 break;
326         }
327         return(error);
328 }
329
330 /*
331  * Pass through file handle conversion functions.
332  */
333 static int
334 nullfs_vptofh(struct vnode *vp, struct fid *fhp)
335 {
336         return VFS_VPTOFH(vp, fhp);
337 }
338
339 /*
340  * Pass through file handle conversion functions.
341  *
342  * NOTE: currently only HAMMER uses rootvp.  HAMMER uses rootvp only
343  * to enforce PFS isolation.
344  */
345 static int
346 nullfs_fhtovp(struct mount *mp, struct vnode *rootvp,
347               struct fid *fhp, struct vnode **vpp)
348 {
349         struct null_mount *xmp = MOUNTTONULLMOUNT(mp);
350
351         return VFS_FHTOVP(xmp->nullm_vfs, xmp->nullm_rootvp, fhp, vpp);
352 }
353
354 static int                        
355 nullfs_extattrctl(struct mount *mp, int cmd, const char *attrname, caddr_t arg,
356                   struct ucred *cred)
357 {
358         return VFS_EXTATTRCTL(MOUNTTONULLMOUNT(mp)->nullm_vfs, cmd, attrname,
359             arg, cred);
360 }
361
362
363 static struct vfsops null_vfsops = {
364         .vfs_mount =            nullfs_mount,
365         .vfs_unmount =          nullfs_unmount,
366         .vfs_root =             nullfs_root,
367         .vfs_quotactl =         nullfs_quotactl,
368         .vfs_statfs =           nullfs_statfs,
369         .vfs_sync =             vfs_stdsync,
370         .vfs_extattrctl =       nullfs_extattrctl,
371         .vfs_fhtovp =           nullfs_fhtovp,
372         .vfs_vptofh =           nullfs_vptofh,
373         .vfs_checkexp =         nullfs_checkexp
374 };
375
376 VFS_SET(null_vfsops, null, VFCF_LOOPBACK);