usr.sbin/autofs/automount.c

   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
  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 *
  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
  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
  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
 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
 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
 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
 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
 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
 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 }