1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2016 The DragonFly Project
5 * Copyright (c) 2014 The FreeBSD Foundation
6 * All rights reserved.
7 *
8 * This software was developed by Edward Tomasz Napierala under sponsorship
9 * from the FreeBSD Foundation.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 *
32 */
33
34 #include <sys/types.h>
35 #include <sys/mount.h>
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <unistd.h>
40 #include <vfs/autofs/autofs_mount.h>
41
42 #include "common.h"
43
44 static int
unmount_by_statfs(const struct statfs * sb,bool force)45 unmount_by_statfs(const struct statfs *sb, bool force)
46 {
47 int error, flags;
48
49 log_debugx("unmounting %s", sb->f_mntonname);
50
51 flags = 0;
52 if (force)
53 flags |= MNT_FORCE;
54 error = unmount(sb->f_mntonname, flags);
55 if (error != 0)
56 log_warn("cannot unmount %s", sb->f_mntonname);
57 else
58 rpc_umntall();
59
60 return (error);
61 }
62
63 static const struct statfs *
find_statfs(const struct statfs * mntbuf,int nitems,const char * mountpoint)64 find_statfs(const struct statfs *mntbuf, int nitems, const char *mountpoint)
65 {
66 int i;
67
68 for (i = 0; i < nitems; i++) {
69 if (strcmp(mntbuf[i].f_mntonname, mountpoint) == 0)
70 return (mntbuf + i);
71 }
72
73 return (NULL);
74 }
75
76 static void
mount_autofs(const char * from,const char * fspath,const char * options,const char * prefix)77 mount_autofs(const char *from, const char *fspath, const char *options,
78 const char *prefix)
79 {
80 struct autofs_mount_info info;
81 int error;
82
83 create_directory(fspath);
84
85 log_debugx("mounting %s on %s, prefix \"%s\", options \"%s\"",
86 from, fspath, prefix, options);
87
88 memset(&info, 0, sizeof(info));
89 info.from = from;
90 info.master_options = options;
91 info.master_prefix = prefix;
92
93 error = mount("autofs", fspath, 0, &info);
94 if (error != 0)
95 log_err(1, "cannot mount %s on %s", from, fspath);
96 }
97
98 static void
mount_if_not_already(const struct node * n,const char * map,const char * options,const char * prefix,const struct statfs * mntbuf,int nitems)99 mount_if_not_already(const struct node *n, const char *map, const char *options,
100 const char *prefix, const struct statfs *mntbuf, int nitems)
101 {
102 const struct statfs *sb;
103 char *mountpoint;
104 char *from;
105 int ret;
106
107 ret = asprintf(&from, "map %s", map);
108 if (ret < 0)
109 log_err(1, "asprintf");
110
111 mountpoint = node_path(n);
112 sb = find_statfs(mntbuf, nitems, mountpoint);
113 if (sb != NULL) {
114 if (strcmp(sb->f_fstypename, "autofs") != 0) {
115 log_debugx("unknown filesystem mounted "
116 "on %s; mounting", mountpoint);
117 /*
118 * XXX: Compare options and 'from',
119 * and update the mount if necessary.
120 */
121 } else {
122 log_debugx("autofs already mounted "
123 "on %s", mountpoint);
124 free(from);
125 free(mountpoint);
126 return;
127 }
128 } else {
129 log_debugx("nothing mounted on %s; mounting",
130 mountpoint);
131 }
132
133 mount_autofs(from, mountpoint, options, prefix);
134 free(from);
135 free(mountpoint);
136 }
137
138 static void
mount_unmount(struct node * root)139 mount_unmount(struct node *root)
140 {
141 struct statfs *mntbuf;
142 struct node *n, *n2;
143 int i, nitems;
144
145 nitems = getmntinfo(&mntbuf, MNT_WAIT);
146 if (nitems <= 0)
147 log_err(1, "getmntinfo");
148
149 log_debugx("unmounting stale autofs mounts");
150
151 for (i = 0; i < nitems; i++) {
152 if (strcmp(mntbuf[i].f_fstypename, "autofs") != 0) {
153 log_debugx("skipping %s, filesystem type is not autofs",
154 mntbuf[i].f_mntonname);
155 continue;
156 }
157
158 n = node_find(root, mntbuf[i].f_mntonname);
159 if (n != NULL) {
160 log_debugx("leaving autofs mounted on %s",
161 mntbuf[i].f_mntonname);
162 continue;
163 }
164
165 log_debugx("autofs mounted on %s not found "
166 "in new configuration; unmounting", mntbuf[i].f_mntonname);
167 unmount_by_statfs(&(mntbuf[i]), false);
168 }
169
170 log_debugx("mounting new autofs mounts");
171
172 TAILQ_FOREACH(n, &root->n_children, n_next) {
173 if (!node_is_direct_map(n)) {
174 mount_if_not_already(n, n->n_map, n->n_options,
175 n->n_key, mntbuf, nitems);
176 continue;
177 }
178
179 TAILQ_FOREACH(n2, &n->n_children, n_next) {
180 mount_if_not_already(n2, n->n_map, n->n_options,
181 "/", mntbuf, nitems);
182 }
183 }
184 }
185
186 static void
flush_autofs(const char * fspath)187 flush_autofs(const char *fspath)
188 {
189 int error;
190
191 log_debugx("flushing %s", fspath);
192
193 error = mount("autofs", fspath, MNT_UPDATE, NULL);
194 if (error != 0)
195 log_err(1, "cannot flush %s", fspath);
196 }
197
198 static void
flush_caches(void)199 flush_caches(void)
200 {
201 struct statfs *mntbuf;
202 int i, nitems;
203
204 nitems = getmntinfo(&mntbuf, MNT_WAIT);
205 if (nitems <= 0)
206 log_err(1, "getmntinfo");
207
208 log_debugx("flushing autofs caches");
209
210 for (i = 0; i < nitems; i++) {
211 if (strcmp(mntbuf[i].f_fstypename, "autofs") != 0) {
212 log_debugx("skipping %s, filesystem type is not autofs",
213 mntbuf[i].f_mntonname);
214 continue;
215 }
216
217 flush_autofs(mntbuf[i].f_mntonname);
218 }
219 }
220
221 static void
unmount_automounted(bool force)222 unmount_automounted(bool force)
223 {
224 struct statfs *mntbuf;
225 int i, nitems;
226
227 nitems = getmntinfo(&mntbuf, MNT_WAIT);
228 if (nitems <= 0)
229 log_err(1, "getmntinfo");
230
231 log_debugx("unmounting automounted filesystems");
232
233 for (i = 0; i < nitems; i++) {
234 if (strcmp(mntbuf[i].f_fstypename, "autofs") == 0) {
235 log_debugx("skipping %s, filesystem type is autofs",
236 mntbuf[i].f_mntonname);
237 continue;
238 }
239
240 if ((mntbuf[i].f_flags & MNT_AUTOMOUNTED) == 0) {
241 log_debugx("skipping %s, not automounted",
242 mntbuf[i].f_mntonname);
243 continue;
244 }
245
246 unmount_by_statfs(&(mntbuf[i]), force);
247 }
248 }
249
250 static void
usage_automount(void)251 usage_automount(void)
252 {
253
254 fprintf(stderr, "usage: automount [-D name=value][-o opts][-Lcfuv]\n");
255 exit(1);
256 }
257
258 int
main_automount(int argc,char ** argv)259 main_automount(int argc, char **argv)
260 {
261 struct node *root;
262 int ch, debug = 0, show_maps = 0;
263 char *options = NULL;
264 bool do_unmount = false, force_unmount = false, flush = false;
265
266 /*
267 * Note that in automount(8), the only purpose of variable
268 * handling is to aid in debugging maps (automount -L).
269 */
270 defined_init();
271
272 while ((ch = getopt(argc, argv, "D:Lfco:uv")) != -1) {
273 switch (ch) {
274 case 'D':
275 defined_parse_and_add(optarg);
276 break;
277 case 'L':
278 show_maps++;
279 break;
280 case 'c':
281 flush = true;
282 break;
283 case 'f':
284 force_unmount = true;
285 break;
286 case 'o':
287 options = concat(options, ',', optarg);
288 break;
289 case 'u':
290 do_unmount = true;
291 break;
292 case 'v':
293 debug++;
294 break;
295 case '?':
296 default:
297 usage_automount();
298 }
299 }
300 argc -= optind;
301 if (argc != 0)
302 usage_automount();
303
304 if (force_unmount && !do_unmount)
305 usage_automount();
306
307 log_init(debug);
308
309 if (flush) {
310 flush_caches();
311 return (0);
312 }
313
314 if (do_unmount) {
315 unmount_automounted(force_unmount);
316 return (0);
317 }
318
319 root = node_new_root();
320 parse_master(root, AUTO_MASTER_PATH);
321
322 if (show_maps) {
323 if (show_maps > 1) {
324 node_expand_indirect_maps(root);
325 node_expand_ampersand(root, NULL);
326 }
327 node_expand_defined(root);
328 node_print(root, options);
329 return (0);
330 }
331
332 mount_unmount(root);
333
334 return (0);
335 }
336