1 /*
2 * Copyright (c) 2009 The DragonFly Project. All rights reserved.
3 *
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
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
15 * the documentation and/or other materials provided with the
16 * distribution.
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34 /*
35 * Implement mp->mnt_ops function call wrappers.
36 *
37 * These wrappers are responsible for handling all MPSAFE issues related to
38 * a mount.
39 */
40
41 #include <sys/param.h>
42 #include <sys/systm.h>
43 #include <sys/buf.h>
44 #include <sys/conf.h>
45 #include <sys/dirent.h>
46 #include <sys/domain.h>
47 #include <sys/eventhandler.h>
48 #include <sys/fcntl.h>
49 #include <sys/kernel.h>
50 #include <sys/kthread.h>
51 #include <sys/malloc.h>
52 #include <sys/mbuf.h>
53 #include <sys/mount.h>
54 #include <sys/proc.h>
55 #include <sys/reboot.h>
56 #include <sys/socket.h>
57 #include <sys/stat.h>
58 #include <sys/sysctl.h>
59 #include <sys/syslog.h>
60 #include <sys/vmmeter.h>
61 #include <sys/vnode.h>
62 #include <sys/vfsops.h>
63 #include <sys/sysmsg.h>
64
65 #include <machine/limits.h>
66
67 #include <vm/vm.h>
68 #include <vm/vm_object.h>
69 #include <vm/vm_extern.h>
70 #include <vm/vm_kern.h>
71 #include <vm/pmap.h>
72 #include <vm/vm_map.h>
73 #include <vm/vm_page.h>
74 #include <vm/vm_pager.h>
75 #include <vm/vnode_pager.h>
76 #include <vm/vm_zone.h>
77
78 #include <sys/buf2.h>
79
80 /*
81 * MPSAFE
82 */
83 int
vfs_mount(struct mount * mp,char * path,caddr_t data,struct ucred * cred)84 vfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
85 {
86 VFS_MPLOCK_DECLARE;
87 int error;
88
89 VFS_MPLOCK(mp);
90 if (!mp->mnt_cred)
91 mp->mnt_cred = crhold(cred); /* For cr_prison */
92 error = (mp->mnt_op->vfs_mount)(mp, path, data, cred);
93 VFS_MPUNLOCK();
94
95 return (error);
96 }
97
98 /*
99 * MPSAFE
100 */
101 int
vfs_start(struct mount * mp,int flags)102 vfs_start(struct mount *mp, int flags)
103 {
104 VFS_MPLOCK_DECLARE;
105 int error;
106
107 VFS_MPLOCK_FLAG(mp, MNTK_ST_MPSAFE);
108 error = (mp->mnt_op->vfs_start)(mp, flags);
109 if (error == 0) {
110 /* do not call vfs_acinit on mount updates */
111 if ((mp->mnt_flag & MNT_UPDATE) == 0)
112 VFS_ACINIT(mp,error);
113 }
114 VFS_MPUNLOCK();
115 if (error == EMOUNTEXIT)
116 error = 0;
117 return (error);
118 }
119
120 /*
121 * MPSAFE
122 */
123 int
vfs_unmount(struct mount * mp,int mntflags)124 vfs_unmount(struct mount *mp, int mntflags)
125 {
126 VFS_MPLOCK_DECLARE;
127 int error;
128 int flags;
129
130 VFS_MPLOCK(mp);
131 VFS_ACDONE(mp);
132 flags = mp->mnt_kern_flag;
133 error = (mp->mnt_op->vfs_unmount)(mp, mntflags);
134 if (error == 0)
135 vn_syncer_thr_stop(mp);
136 VFS_MPUNLOCK();
137 return (error);
138 }
139
140 /*
141 * MPSAFE
142 */
143 int
vfs_root(struct mount * mp,struct vnode ** vpp)144 vfs_root(struct mount *mp, struct vnode **vpp)
145 {
146 VFS_MPLOCK_DECLARE;
147 int error;
148
149 VFS_MPLOCK(mp);
150 error = (mp->mnt_op->vfs_root)(mp, vpp);
151 VFS_MPUNLOCK();
152 return (error);
153 }
154
155 /*
156 * MPSAFE
157 */
158 int
vfs_quotactl(struct mount * mp,int cmds,uid_t uid,caddr_t arg,struct ucred * cred)159 vfs_quotactl(struct mount *mp, int cmds, uid_t uid, caddr_t arg,
160 struct ucred *cred)
161 {
162 VFS_MPLOCK_DECLARE;
163 int error;
164
165 VFS_MPLOCK(mp);
166 error = (mp->mnt_op->vfs_quotactl)(mp, cmds, uid, arg, cred);
167 VFS_MPUNLOCK();
168 return (error);
169 }
170
171 /*
172 * MPSAFE
173 */
174 int
vfs_statfs(struct mount * mp,struct statfs * sbp,struct ucred * cred)175 vfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
176 {
177 VFS_MPLOCK_DECLARE;
178 int error;
179
180 VFS_MPLOCK(mp);
181 error = (mp->mnt_op->vfs_statfs)(mp, sbp, cred);
182 VFS_MPUNLOCK();
183 return (error);
184 }
185
186 /*
187 * MPSAFE
188 */
189 int
vfs_statvfs(struct mount * mp,struct statvfs * sbp,struct ucred * cred)190 vfs_statvfs(struct mount *mp, struct statvfs *sbp, struct ucred *cred)
191 {
192 VFS_MPLOCK_DECLARE;
193 int error;
194
195 VFS_MPLOCK(mp);
196 error = (mp->mnt_op->vfs_statvfs)(mp, sbp, cred);
197 VFS_MPUNLOCK();
198 return (error);
199 }
200
201 /*
202 * MPSAFE
203 */
204 int
vfs_sync(struct mount * mp,int waitfor)205 vfs_sync(struct mount *mp, int waitfor)
206 {
207 VFS_MPLOCK_DECLARE;
208 int error;
209
210 VFS_MPLOCK(mp);
211 error = (mp->mnt_op->vfs_sync)(mp, waitfor);
212 VFS_MPUNLOCK();
213 return (error);
214 }
215
216 /*
217 * MPSAFE
218 */
219 int
vfs_vget(struct mount * mp,struct vnode * dvp,ino_t ino,struct vnode ** vpp)220 vfs_vget(struct mount *mp, struct vnode *dvp, ino_t ino, struct vnode **vpp)
221 {
222 VFS_MPLOCK_DECLARE;
223 int error;
224
225 VFS_MPLOCK(mp);
226 error = (mp->mnt_op->vfs_vget)(mp, dvp, ino, vpp);
227 VFS_MPUNLOCK();
228 return (error);
229 }
230
231 /*
232 * MPSAFE
233 */
234 int
vfs_fhtovp(struct mount * mp,struct vnode * rootvp,struct fid * fhp,struct vnode ** vpp)235 vfs_fhtovp(struct mount *mp, struct vnode *rootvp,
236 struct fid *fhp, struct vnode **vpp)
237 {
238 VFS_MPLOCK_DECLARE;
239 int error;
240
241 VFS_MPLOCK(mp);
242 error = (mp->mnt_op->vfs_fhtovp)(mp, rootvp, fhp, vpp);
243 VFS_MPUNLOCK();
244 return (error);
245 }
246
247 /*
248 * MPSAFE
249 */
250 int
vfs_checkexp(struct mount * mp,struct sockaddr * nam,int * extflagsp,struct ucred ** credanonp)251 vfs_checkexp(struct mount *mp, struct sockaddr *nam,
252 int *extflagsp, struct ucred **credanonp)
253 {
254 VFS_MPLOCK_DECLARE;
255 int error;
256
257 VFS_MPLOCK(mp);
258 error = (mp->mnt_op->vfs_checkexp)(mp, nam, extflagsp, credanonp);
259 VFS_MPUNLOCK();
260 return (error);
261 }
262
263 /*
264 * MPSAFE
265 */
266 int
vfs_vptofh(struct vnode * vp,struct fid * fhp)267 vfs_vptofh(struct vnode *vp, struct fid *fhp)
268 {
269 VFS_MPLOCK_DECLARE;
270 int error;
271
272 VFS_MPLOCK(vp->v_mount);
273 error = (vp->v_mount->mnt_op->vfs_vptofh)(vp, fhp);
274 VFS_MPUNLOCK();
275 return (error);
276 }
277
278 /*
279 * MPSAFE
280 */
281 int
vfs_init(struct vfsconf * vfc)282 vfs_init(struct vfsconf *vfc)
283 {
284 int error;
285
286 error = (vfc->vfc_vfsops->vfs_init)(vfc);
287
288 return (error);
289 }
290
291 /*
292 * MPSAFE
293 */
294 int
vfs_uninit(struct vfsconf * vfc,struct vfsconf * vfsp)295 vfs_uninit(struct vfsconf *vfc, struct vfsconf *vfsp)
296 {
297 int error;
298
299 error = (vfc->vfc_vfsops->vfs_uninit)(vfsp);
300
301 return (error);
302 }
303
304 /*
305 * MPSAFE
306 */
307 int
vfs_extattrctl(struct mount * mp,int cmd,struct vnode * vp,int attrnamespace,const char * attrname,struct ucred * cred)308 vfs_extattrctl(struct mount *mp, int cmd, struct vnode *vp,
309 int attrnamespace, const char *attrname,
310 struct ucred *cred)
311 {
312 VFS_MPLOCK_DECLARE;
313 int error;
314
315 VFS_MPLOCK(mp);
316 error = (mp->mnt_op->vfs_extattrctl)(mp, cmd, vp,
317 attrnamespace, attrname,
318 cred);
319 VFS_MPUNLOCK();
320 return (error);
321 }
322