1 /*-
2 * Copyright (c) 2006-2007 Pawel Jakub Dawidek <pjd@FreeBSD.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29
30 #include <sys/param.h>
31 #include <sys/kernel.h>
32 #include <sys/systm.h>
33 #include <sys/malloc.h>
34 #include <sys/mount.h>
35 #include <sys/cred.h>
36 #include <sys/vfs.h>
37 #include <sys/priv.h>
38 #include <sys/libkern.h>
39
40 MALLOC_DECLARE(M_MOUNT);
41
42 void
vfs_setmntopt(vfs_t * vfsp,const char * name,const char * arg,int flags __unused)43 vfs_setmntopt(vfs_t *vfsp, const char *name, const char *arg,
44 int flags __unused)
45 {
46 struct vfsopt *opt;
47 size_t namesize;
48 int locked;
49
50 if (!(locked = mtx_owned(MNT_MTX(vfsp))))
51 MNT_ILOCK(vfsp);
52
53 if (vfsp->mnt_opt == NULL) {
54 void *opts;
55
56 MNT_IUNLOCK(vfsp);
57 opts = malloc(sizeof(*vfsp->mnt_opt), M_MOUNT, M_WAITOK);
58 MNT_ILOCK(vfsp);
59 if (vfsp->mnt_opt == NULL) {
60 vfsp->mnt_opt = opts;
61 TAILQ_INIT(vfsp->mnt_opt);
62 } else {
63 free(opts, M_MOUNT);
64 }
65 }
66
67 MNT_IUNLOCK(vfsp);
68
69 opt = malloc(sizeof(*opt), M_MOUNT, M_WAITOK);
70 namesize = strlen(name) + 1;
71 opt->name = malloc(namesize, M_MOUNT, M_WAITOK);
72 strlcpy(opt->name, name, namesize);
73 opt->pos = -1;
74 opt->seen = 1;
75 if (arg == NULL) {
76 opt->value = NULL;
77 opt->len = 0;
78 } else {
79 opt->len = strlen(arg) + 1;
80 opt->value = malloc(opt->len, M_MOUNT, M_WAITOK);
81 bcopy(arg, opt->value, opt->len);
82 }
83
84 MNT_ILOCK(vfsp);
85 TAILQ_INSERT_TAIL(vfsp->mnt_opt, opt, link);
86 if (!locked)
87 MNT_IUNLOCK(vfsp);
88 }
89
90 void
vfs_clearmntopt(vfs_t * vfsp,const char * name)91 vfs_clearmntopt(vfs_t *vfsp, const char *name)
92 {
93 int locked;
94
95 if (!(locked = mtx_owned(MNT_MTX(vfsp))))
96 MNT_ILOCK(vfsp);
97 vfs_deleteopt(vfsp->mnt_opt, name);
98 if (!locked)
99 MNT_IUNLOCK(vfsp);
100 }
101
102 int
vfs_optionisset(const vfs_t * vfsp,const char * opt,char ** argp)103 vfs_optionisset(const vfs_t *vfsp, const char *opt, char **argp)
104 {
105 struct vfsoptlist *opts = vfsp->mnt_optnew;
106 int error;
107
108 if (opts == NULL)
109 return (0);
110 error = vfs_getopt(opts, opt, (void **)argp, NULL);
111 return (error != 0 ? 0 : 1);
112 }
113
114 int
mount_snapshot(kthread_t * td,vnode_t ** vpp,const char * fstype,char * fspath,char * fspec,int fsflags)115 mount_snapshot(kthread_t *td, vnode_t **vpp, const char *fstype, char *fspath,
116 char *fspec, int fsflags)
117 {
118 struct vfsconf *vfsp;
119 struct mount *mp;
120 vnode_t *vp, *mvp;
121 struct ucred *cr;
122 int error;
123
124 /*
125 * Be ultra-paranoid about making sure the type and fspath
126 * variables will fit in our mp buffers, including the
127 * terminating NUL.
128 */
129 if (strlen(fstype) >= MFSNAMELEN || strlen(fspath) >= MNAMELEN)
130 return (ENAMETOOLONG);
131
132 vfsp = vfs_byname_kld(fstype, td, &error);
133 if (vfsp == NULL)
134 return (ENODEV);
135
136 vp = *vpp;
137 if (vp->v_type != VDIR)
138 return (ENOTDIR);
139 /*
140 * We need vnode lock to protect v_mountedhere and vnode interlock
141 * to protect v_iflag.
142 */
143 vn_lock(vp, LK_SHARED | LK_RETRY);
144 VI_LOCK(vp);
145 if ((vp->v_iflag & VI_MOUNT) != 0 || vp->v_mountedhere != NULL) {
146 VI_UNLOCK(vp);
147 VOP_UNLOCK(vp, 0);
148 return (EBUSY);
149 }
150 vp->v_iflag |= VI_MOUNT;
151 VI_UNLOCK(vp);
152 VOP_UNLOCK(vp, 0);
153
154 /*
155 * Allocate and initialize the filesystem.
156 * We don't want regular user that triggered snapshot mount to be able
157 * to unmount it, so pass credentials of the parent mount.
158 */
159 mp = vfs_mount_alloc(vp, vfsp, fspath, vp->v_mount->mnt_cred);
160
161 mp->mnt_optnew = NULL;
162 vfs_setmntopt(mp, "from", fspec, 0);
163 mp->mnt_optnew = mp->mnt_opt;
164 mp->mnt_opt = NULL;
165
166 /*
167 * Set the mount level flags.
168 */
169 mp->mnt_flag = fsflags & MNT_UPDATEMASK;
170 /*
171 * Snapshots are always read-only.
172 */
173 mp->mnt_flag |= MNT_RDONLY;
174 /*
175 * We don't want snapshots to allow access to vulnerable setuid
176 * programs, so we turn off setuid when mounting snapshots.
177 */
178 mp->mnt_flag |= MNT_NOSUID;
179 /*
180 * We don't want snapshots to be visible in regular
181 * mount(8) and df(1) output.
182 */
183 mp->mnt_flag |= MNT_IGNORE;
184 /*
185 * XXX: This is evil, but we can't mount a snapshot as a regular user.
186 * XXX: Is is safe when snapshot is mounted from within a jail?
187 */
188 cr = td->td_ucred;
189 td->td_ucred = kcred;
190 error = VFS_MOUNT(mp);
191 td->td_ucred = cr;
192
193 if (error != 0) {
194 VI_LOCK(vp);
195 vp->v_iflag &= ~VI_MOUNT;
196 VI_UNLOCK(vp);
197 vrele(vp);
198 vfs_unbusy(mp);
199 vfs_mount_destroy(mp);
200 *vpp = NULL;
201 return (error);
202 }
203
204 if (mp->mnt_opt != NULL)
205 vfs_freeopts(mp->mnt_opt);
206 mp->mnt_opt = mp->mnt_optnew;
207 (void)VFS_STATFS(mp, &mp->mnt_stat);
208
209 /*
210 * Prevent external consumers of mount options from reading
211 * mnt_optnew.
212 */
213 mp->mnt_optnew = NULL;
214
215 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
216 #ifdef FREEBSD_NAMECACHE
217 cache_purge(vp);
218 #endif
219 VI_LOCK(vp);
220 vp->v_iflag &= ~VI_MOUNT;
221 VI_UNLOCK(vp);
222
223 vp->v_mountedhere = mp;
224 /* Put the new filesystem on the mount list. */
225 mtx_lock(&mountlist_mtx);
226 TAILQ_INSERT_TAIL(&mountlist, mp, mnt_list);
227 mtx_unlock(&mountlist_mtx);
228 vfs_event_signal(NULL, VQ_MOUNT, 0);
229 if (VFS_ROOT(mp, LK_EXCLUSIVE, &mvp))
230 panic("mount: lost mount");
231 vput(vp);
232 vfs_unbusy(mp);
233 *vpp = mvp;
234 return (0);
235 }
236