1 /*-
2 * Copyright (c) 2017 The NetBSD Foundation, Inc.
3 * Copyright (c) 2016 The DragonFly Project
4 * Copyright (c) 2014 The FreeBSD Foundation
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Tomohiro Kusumi <kusumi.tomohiro@gmail.com>.
9 *
10 * This software was developed by Edward Tomasz Napierala under sponsorship
11 * from the FreeBSD Foundation.
12 *
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
15 * are met:
16 * 1. Redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright
19 * notice, this list of conditions and the following disclaimer in the
20 * documentation and/or other materials provided with the distribution.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 *
34 */
35 #include <sys/cdefs.h>
36 __KERNEL_RCSID(0, "$NetBSD: autofs_vfsops.c,v 1.12 2022/03/28 12:33:22 riastradh Exp $");
37
38
39 #include "autofs.h"
40 #include "autofs_mount.h"
41
42 #include <sys/stat.h>
43 #include <sys/sysctl.h>
44 #include <miscfs/genfs/genfs.h>
45
46 MODULE(MODULE_CLASS_VFS, autofs, NULL);
47
48 static int autofs_statvfs(struct mount *, struct statvfs *);
49
50 static void
autofs_init(void)51 autofs_init(void)
52 {
53
54 KASSERT(!autofs_softc);
55
56 autofs_softc = kmem_zalloc(sizeof(*autofs_softc), KM_SLEEP);
57
58 pool_init(&autofs_request_pool, sizeof(struct autofs_request), 0, 0, 0,
59 "autofs_request", &pool_allocator_nointr, IPL_NONE);
60 pool_init(&autofs_node_pool, sizeof(struct autofs_node), 0, 0, 0,
61 "autofs_node", &pool_allocator_nointr, IPL_NONE);
62
63 TAILQ_INIT(&autofs_softc->sc_requests);
64 cv_init(&autofs_softc->sc_cv, "autofscv");
65 mutex_init(&autofs_softc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
66 autofs_softc->sc_dev_opened = false;
67
68 workqueue_create(&autofs_tmo_wq, "autofstmo",
69 autofs_timeout_wq, NULL, 0, 0, WQ_MPSAFE);
70 }
71
72 static void
autofs_done(void)73 autofs_done(void)
74 {
75
76 KASSERT(autofs_softc);
77 KASSERT(!autofs_softc->sc_dev_opened);
78
79 workqueue_destroy(autofs_tmo_wq);
80
81 struct autofs_softc *sc = autofs_softc;
82 autofs_softc = NULL;
83
84 cv_destroy(&sc->sc_cv);
85 mutex_destroy(&sc->sc_lock);
86
87 pool_destroy(&autofs_request_pool);
88 pool_destroy(&autofs_node_pool);
89
90 kmem_free(sc, sizeof(*sc));
91 }
92
93 static int
autofs_mount(struct mount * mp,const char * path,void * data,size_t * data_len)94 autofs_mount(struct mount *mp, const char *path, void *data, size_t *data_len)
95 {
96 struct autofs_args *args = data;
97 struct autofs_mount *amp = VFSTOAUTOFS(mp);
98 struct statvfs *sbp = &mp->mnt_stat;
99 int error;
100
101 if (mp->mnt_flag & MNT_UPDATE) {
102 if (amp == NULL)
103 return EIO;
104 autofs_flush(amp);
105 return 0;
106 }
107
108 if (!args)
109 return EINVAL;
110
111 if (mp->mnt_flag & MNT_GETARGS) {
112 if (amp == NULL)
113 return EIO;
114 error = copyoutstr(amp->am_from, args->from,
115 sizeof(amp->am_from), NULL);
116 if (error)
117 return error;
118 error = copyoutstr(amp->am_options, args->master_options,
119 sizeof(amp->am_options), NULL);
120 if (error)
121 return error;
122 error = copyoutstr(amp->am_prefix, args->master_prefix,
123 sizeof(amp->am_prefix), NULL);
124 return error;
125 }
126
127 if (amp != NULL)
128 return EBUSY;
129
130 /*
131 * Allocate the autofs mount.
132 */
133 amp = kmem_zalloc(sizeof(*amp), KM_SLEEP);
134 mp->mnt_data = amp;
135 amp->am_mp = mp;
136
137 /*
138 * Copy-in master_options string.
139 */
140 error = copyinstr(args->master_options, amp->am_options,
141 sizeof(amp->am_options), NULL);
142 if (error)
143 goto fail;
144
145 /*
146 * Copy-in master_prefix string.
147 */
148 error = copyinstr(args->master_prefix, amp->am_prefix,
149 sizeof(amp->am_prefix), NULL);
150 if (error)
151 goto fail;
152
153 /*
154 * Initialize the autofs mount.
155 */
156 mutex_init(&->am_lock, MUTEX_DEFAULT, IPL_NONE);
157 amp->am_last_ino = AUTOFS_ROOTINO;
158
159 mutex_enter(&->am_lock);
160 error = autofs_node_new(NULL, amp, ".", -1, &->am_root);
161 mutex_exit(&->am_lock);
162 if (error)
163 goto fail1;
164 KASSERT(amp->am_root->an_ino == AUTOFS_ROOTINO);
165
166 autofs_statvfs(mp, sbp);
167 vfs_getnewfsid(mp);
168
169 error = set_statvfs_info(path, UIO_USERSPACE, args->from, UIO_USERSPACE,
170 mp->mnt_op->vfs_name, mp, curlwp);
171 if (error)
172 goto fail1;
173 strlcpy(amp->am_from, sbp->f_mntfromname, sizeof(amp->am_from));
174 strlcpy(amp->am_on, sbp->f_mntonname, sizeof(amp->am_on));
175
176 return 0;
177
178 fail1:
179 mutex_destroy(&->am_lock);
180 fail:
181 mp->mnt_data = NULL;
182 kmem_free(amp, sizeof(*amp));
183 return error;
184 }
185
186 static int
autofs_unmount(struct mount * mp,int mntflags)187 autofs_unmount(struct mount *mp, int mntflags)
188 {
189 struct autofs_mount *amp = VFSTOAUTOFS(mp);
190 int error, flags;
191
192 flags = 0;
193 if (mntflags & MNT_FORCE)
194 flags |= FORCECLOSE;
195 error = vflush(mp, NULL, flags);
196 if (error) {
197 AUTOFS_DEBUG("vflush failed with error %d", error);
198 return error;
199 }
200
201 /*
202 * All vnodes are gone, and new one will not appear - so,
203 * no new triggerings.
204 */
205 for (;;) {
206 struct autofs_request *ar;
207 int dummy;
208 bool found;
209
210 found = false;
211 mutex_enter(&autofs_softc->sc_lock);
212 TAILQ_FOREACH(ar, &autofs_softc->sc_requests, ar_next) {
213 if (ar->ar_mount != amp)
214 continue;
215 ar->ar_error = ENXIO;
216 ar->ar_done = true;
217 ar->ar_in_progress = false;
218 found = true;
219 }
220 if (found == false) {
221 mutex_exit(&autofs_softc->sc_lock);
222 break;
223 }
224
225 cv_broadcast(&autofs_softc->sc_cv);
226 mutex_exit(&autofs_softc->sc_lock);
227
228 tsleep(&dummy, 0, "autofs_umount", hz);
229 }
230
231 mutex_enter(&->am_lock);
232 while (!RB_EMPTY(&->am_root->an_children)) {
233 struct autofs_node *anp;
234 /*
235 * Force delete all nodes when more than one level of
236 * directories are created via indirect map. Autofs doesn't
237 * support rmdir(2), thus this is the only way to get out.
238 */
239 anp = RB_MIN(autofs_node_tree, &->am_root->an_children);
240 while (!RB_EMPTY(&anp->an_children))
241 anp = RB_MIN(autofs_node_tree, &anp->an_children);
242 autofs_node_delete(anp);
243 }
244 autofs_node_delete(amp->am_root);
245 mp->mnt_data = NULL;
246 mutex_exit(&->am_lock);
247
248 mutex_destroy(&->am_lock);
249
250 kmem_free(amp, sizeof(*amp));
251
252 return 0;
253 }
254
255 static int
autofs_start(struct mount * mp,int flags)256 autofs_start(struct mount *mp, int flags)
257 {
258
259 return 0;
260 }
261
262 static int
autofs_root(struct mount * mp,int lktype,struct vnode ** vpp)263 autofs_root(struct mount *mp, int lktype, struct vnode **vpp)
264 {
265 struct autofs_node *anp = VFSTOAUTOFS(mp)->am_root;
266 int error;
267
268 error = vcache_get(mp, &anp, sizeof(anp), vpp);
269 if (error)
270 return error;
271 error = vn_lock(*vpp, lktype);
272 if (error) {
273 vrele(*vpp);
274 *vpp = NULLVP;
275 return error;
276 }
277
278 return 0;
279 }
280
281 static int
autofs_statvfs(struct mount * mp,struct statvfs * sbp)282 autofs_statvfs(struct mount *mp, struct statvfs *sbp)
283 {
284
285 sbp->f_bsize = S_BLKSIZE;
286 sbp->f_frsize = S_BLKSIZE;
287 sbp->f_iosize = 0;
288 sbp->f_blocks = 0;
289 sbp->f_bfree = 0;
290 sbp->f_bavail = 0;
291 sbp->f_bresvd = 0;
292 sbp->f_files = 0;
293 sbp->f_ffree = 0;
294 sbp->f_favail = 0;
295 sbp->f_fresvd = 0;
296
297 copy_statvfs_info(sbp, mp);
298
299 return 0;
300 }
301
302 static int
autofs_sync(struct mount * mp,int waitfor,kauth_cred_t uc)303 autofs_sync(struct mount *mp, int waitfor, kauth_cred_t uc)
304 {
305
306 return 0;
307 }
308
309 static int
autofs_loadvnode(struct mount * mp,struct vnode * vp,const void * key,size_t key_len,const void ** new_key)310 autofs_loadvnode(struct mount *mp, struct vnode *vp,
311 const void *key, size_t key_len, const void **new_key)
312 {
313 struct autofs_node *anp;
314
315 KASSERT(key_len == sizeof(anp));
316 memcpy(&anp, key, key_len);
317 KASSERT(!anp->an_vnode);
318
319 vp->v_tag = VT_AUTOFS;
320 vp->v_type = VDIR;
321 vp->v_op = autofs_vnodeop_p;
322 vp->v_data = anp;
323
324 if (anp->an_ino == AUTOFS_ROOTINO)
325 vp->v_vflag |= VV_ROOT;
326
327 anp->an_vnode = vp;
328 uvm_vnp_setsize(vp, 0);
329
330 *new_key = &vp->v_data;
331
332 return 0;
333 }
334
335 static const struct vnodeopv_desc * const autofs_vnodeopv_descs[] = {
336 &autofs_vnodeop_opv_desc,
337 NULL,
338 };
339
340 static struct vfsops autofs_vfsops = {
341 .vfs_name = MOUNT_AUTOFS,
342 .vfs_min_mount_data = sizeof(struct autofs_args),
343 .vfs_mount = autofs_mount,
344 .vfs_start = autofs_start,
345 .vfs_unmount = autofs_unmount,
346 .vfs_root = autofs_root,
347 .vfs_quotactl = (void *)eopnotsupp,
348 .vfs_statvfs = autofs_statvfs,
349 .vfs_sync = autofs_sync,
350 .vfs_vget = (void *)eopnotsupp,
351 .vfs_loadvnode = (void *)autofs_loadvnode,
352 .vfs_newvnode = (void *)eopnotsupp,
353 .vfs_fhtovp = (void *)eopnotsupp,
354 .vfs_vptofh = (void *)eopnotsupp,
355 .vfs_init = autofs_init,
356 .vfs_reinit = (void *)eopnotsupp,
357 .vfs_done = autofs_done,
358 .vfs_mountroot = (void *)eopnotsupp,
359 .vfs_snapshot = (void *)eopnotsupp,
360 .vfs_extattrctl = (void *)eopnotsupp,
361 .vfs_suspendctl = (void *)genfs_suspendctl,
362 .vfs_renamelock_enter = (void *)eopnotsupp,
363 .vfs_renamelock_exit = (void *)eopnotsupp,
364 .vfs_fsync = (void *)eopnotsupp,
365 .vfs_opv_descs = autofs_vnodeopv_descs
366 };
367
368 #define AUTOFS_SYSCTL_DEBUG 1
369 #define AUTOFS_SYSCTL_MOUNT_ON_STAT 2
370 #define AUTOFS_SYSCTL_TIMEOUT 3
371 #define AUTOFS_SYSCTL_CACHE 4
372 #define AUTOFS_SYSCTL_RETRY_ATTEMPTS 5
373 #define AUTOFS_SYSCTL_RETRY_DELAY 6
374 #define AUTOFS_SYSCTL_INTERRUPTIBLE 7
375
376 SYSCTL_SETUP(autofs_sysctl_create, "autofs sysctl")
377 {
378 int error;
379
380 /*
381 * XXX the "33" below could be dynamic, thereby eliminating one
382 * more instance of the "number to vfs" mapping problem, but
383 * "33" is the order as taken from sys/mount.h
384 */
385 error = sysctl_createv(clog, 0, NULL, NULL,
386 CTLFLAG_PERMANENT,
387 CTLTYPE_NODE, "autofs",
388 SYSCTL_DESCR("Automounter filesystem"),
389 NULL, 0, NULL, 0,
390 CTL_VFS, 33, CTL_EOL);
391 if (error)
392 goto fail;
393
394 error = sysctl_createv(clog, 0, NULL, NULL,
395 CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
396 CTLTYPE_INT, "autofs_debug",
397 SYSCTL_DESCR("Enable debug messages"),
398 NULL, 0, &autofs_debug, 0,
399 CTL_VFS, 33, AUTOFS_SYSCTL_DEBUG, CTL_EOL);
400 if (error)
401 goto fail;
402
403 error = sysctl_createv(clog, 0, NULL, NULL,
404 CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
405 CTLTYPE_INT, "autofs_mount_on_stat",
406 SYSCTL_DESCR("Trigger mount on stat(2) on mountpoint"),
407 NULL, 0, &autofs_mount_on_stat, 0,
408 CTL_VFS, 33, AUTOFS_SYSCTL_MOUNT_ON_STAT, CTL_EOL);
409 if (error)
410 goto fail;
411
412 error = sysctl_createv(clog, 0, NULL, NULL,
413 CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
414 CTLTYPE_INT, "autofs_timeout",
415 SYSCTL_DESCR("Number of seconds to wait for automountd(8)"),
416 NULL, 0, &autofs_timeout, 0,
417 CTL_VFS, 33, AUTOFS_SYSCTL_TIMEOUT, CTL_EOL);
418 if (error)
419 goto fail;
420
421 error = sysctl_createv(clog, 0, NULL, NULL,
422 CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
423 CTLTYPE_INT, "autofs_cache",
424 SYSCTL_DESCR("Number of seconds to wait before reinvoking"),
425 NULL, 0, &autofs_cache, 0,
426 CTL_VFS, 33, AUTOFS_SYSCTL_CACHE, CTL_EOL);
427 if (error)
428 goto fail;
429
430 error = sysctl_createv(clog, 0, NULL, NULL,
431 CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
432 CTLTYPE_INT, "autofs_retry_attempts",
433 SYSCTL_DESCR("Number of attempts before failing mount"),
434 NULL, 0, &autofs_retry_attempts, 0,
435 CTL_VFS, 33, AUTOFS_SYSCTL_RETRY_ATTEMPTS, CTL_EOL);
436 if (error)
437 goto fail;
438
439 error = sysctl_createv(clog, 0, NULL, NULL,
440 CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
441 CTLTYPE_INT, "autofs_retry_delay",
442 SYSCTL_DESCR("Number of seconds before retrying"),
443 NULL, 0, &autofs_retry_delay, 0,
444 CTL_VFS, 33, AUTOFS_SYSCTL_RETRY_DELAY, CTL_EOL);
445 if (error)
446 goto fail;
447
448 error = sysctl_createv(clog, 0, NULL, NULL,
449 CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
450 CTLTYPE_INT, "autofs_interruptible",
451 SYSCTL_DESCR("Allow requests to be interrupted by signal"),
452 NULL, 0, &autofs_interruptible, 0,
453 CTL_VFS, 33, AUTOFS_SYSCTL_INTERRUPTIBLE, CTL_EOL);
454 if (error)
455 goto fail;
456
457 return;
458 fail:
459 AUTOFS_WARN("sysctl_createv failed with error %d", error);
460
461 return;
462 }
463
464 extern const struct cdevsw autofs_cdevsw;
465
466 static int
autofs_modcmd(modcmd_t cmd,void * arg)467 autofs_modcmd(modcmd_t cmd, void *arg)
468 {
469 #ifdef _MODULE
470 devmajor_t bmajor = NODEVMAJOR, cmajor = NODEVMAJOR;
471 #endif
472 int error = 0;
473
474 switch (cmd) {
475 case MODULE_CMD_INIT:
476 error = vfs_attach(&autofs_vfsops);
477 if (error)
478 break;
479 #ifdef _MODULE
480 error = devsw_attach("autofs", NULL, &bmajor, &autofs_cdevsw,
481 &cmajor);
482 if (error) {
483 vfs_detach(&autofs_vfsops);
484 break;
485 }
486 #endif
487 break;
488 case MODULE_CMD_FINI:
489 #ifdef _MODULE
490 KASSERT(autofs_softc);
491 mutex_enter(&autofs_softc->sc_lock);
492 if (autofs_softc->sc_dev_opened) {
493 mutex_exit(&autofs_softc->sc_lock);
494 error = EBUSY;
495 break;
496 }
497 mutex_exit(&autofs_softc->sc_lock);
498
499 devsw_detach(NULL, &autofs_cdevsw);
500 #endif
501 error = vfs_detach(&autofs_vfsops);
502 if (error)
503 break;
504 break;
505 default:
506 error = ENOTTY;
507 break;
508 }
509
510 return error;
511 }
512