sys-utils/mountpoint.c

   1 /*
   2  * mountpoint(1) - see if a directory is a mountpoint
   3  *
   4  * This is libmount based reimplementation of the mountpoint(1)
   5  * from sysvinit project.
   6  *
   7  *
   8  * Copyright (C) 2011 Red Hat, Inc. All rights reserved.
   9  * Written by Karel Zak <kzak@redhat.com>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it would be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License along
  22  * with this program; if not, write to the Free Software Foundation, Inc.,
  23  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  24  */
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <errno.h>
  29 #include <string.h>
  30 #include <getopt.h>
  31 #include <unistd.h>
  32 #include <sys/types.h>
  33 #include <sys/stat.h>
  34
  35 #include <libmount.h>
  36
  37 #include "nls.h"
  38 #include "xalloc.h"
  39 #include "c.h"
  40 #include "closestream.h"
  41 #include "pathnames.h"
  42
  43 struct mountpoint_control {
  44         char *path;
  45         dev_t dev;
  46         struct stat st;
  47         unsigned int
  48                 dev_devno:1,
  49                 fs_devno:1,
  50                 quiet:1;
  51 };
  52
  53 static int dir_to_device(struct mountpoint_control *ctl)
  54 {
  55         struct libmnt_table *tb = mnt_new_table_from_file(_PATH_PROC_MOUNTINFO);
  56         struct libmnt_fs *fs;
  57         struct libmnt_cache *cache;
  58         int rc = -1;
  59
  60         if (!tb) {
  61                 /*
  62                  * Fallback. Traditional way to detect mountpoints. This way
  63                  * is independent on /proc, but not able to detect bind mounts.
  64                  */
  65                 struct stat pst;
  66                 char buf[PATH_MAX], *cn;
  67                 int len;
  68
  69                 cn = mnt_resolve_path(ctl->path, NULL); /* canonicalize */
  70
  71                 len = snprintf(buf, sizeof(buf), "%s/..", cn ? cn : ctl->path);
  72                 free(cn);
  73
  74                 if (len < 0 || (size_t) len >= sizeof(buf))
  75                         return -1;
  76                 if (stat(buf, &pst) !=0)
  77                         return -1;
  78
  79                 if (ctl->st.st_dev != pst.st_dev || ctl->st.st_ino == pst.st_ino) {
  80                         ctl->dev = ctl->st.st_dev;
  81                         return 0;
  82                 }
  83
  84                 return -1;
  85         }
  86
  87         /* to canonicalize all necessary paths */
  88         cache = mnt_new_cache();
  89         mnt_table_set_cache(tb, cache);
  90         mnt_unref_cache(cache);
  91
  92         fs = mnt_table_find_target(tb, ctl->path, MNT_ITER_BACKWARD);
  93         if (fs && mnt_fs_get_target(fs)) {
  94                 ctl->dev = mnt_fs_get_devno(fs);
  95                 rc = 0;
  96         }
  97
  98         mnt_unref_table(tb);
  99         return rc;
 100 }
 101
 102 static int print_devno(const struct mountpoint_control *ctl)
 103 {
 104         if (!S_ISBLK(ctl->st.st_mode)) {
 105                 if (!ctl->quiet)
 106                         warnx(_("%s: not a block device"), ctl->path);
 107                 return -1;
 108         }
 109         printf("%u:%u\n", major(ctl->st.st_rdev), minor(ctl->st.st_rdev));
 110         return 0;
 111 }
 112
 113 static void __attribute__((__noreturn__)) usage(void)
 114 {
 115         FILE *out = stdout;
 116         fputs(USAGE_HEADER, out);
 117         fprintf(out,
 118               _(" %1$s [-qd] /path/to/directory\n"
 119                 " %1$s -x /dev/device\n"), program_invocation_short_name);
 120
 121         fputs(USAGE_SEPARATOR, out);
 122         fputs(_("Check whether a directory or file is a mountpoint.\n"), out);
 123
 124         fputs(USAGE_OPTIONS, out);
 125         fputs(_(" -q, --quiet        quiet mode - don't print anything\n"
 126                 " -d, --fs-devno     print maj:min device number of the filesystem\n"
 127                 " -x, --devno        print maj:min device number of the block device\n"), out);
 128         fputs(USAGE_SEPARATOR, out);
 129         printf(USAGE_HELP_OPTIONS(20));
 130         printf(USAGE_MAN_TAIL("mountpoint(1)"));
 131
 132         exit(EXIT_SUCCESS);
 133 }
 134
 135 int main(int argc, char **argv)
 136 {
 137         int c;
 138         struct mountpoint_control ctl = { NULL };
 139
 140         static const struct option longopts[] = {
 141                 { "quiet",    no_argument, NULL, 'q' },
 142                 { "fs-devno", no_argument, NULL, 'd' },
 143                 { "devno",    no_argument, NULL, 'x' },
 144                 { "help",     no_argument, NULL, 'h' },
 145                 { "version",  no_argument, NULL, 'V' },
 146                 { NULL, 0, NULL, 0 }
 147         };
 148
 149         setlocale(LC_ALL, "");
 150         bindtextdomain(PACKAGE, LOCALEDIR);
 151         textdomain(PACKAGE);
 152         atexit(close_stdout);
 153
 154         mnt_init_debug(0);
 155
 156         while ((c = getopt_long(argc, argv, "qdxhV", longopts, NULL)) != -1) {
 157
 158                 switch(c) {
 159                 case 'q':
 160                         ctl.quiet = 1;
 161                         break;
 162                 case 'd':
 163                         ctl.fs_devno = 1;
 164                         break;
 165                 case 'x':
 166                         ctl.dev_devno = 1;
 167                         break;
 168                 case 'h':
 169                         usage();
 170                         break;
 171                 case 'V':
 172                         printf(UTIL_LINUX_VERSION);
 173                         return EXIT_SUCCESS;
 174                 default:
 175                         errtryhelp(EXIT_FAILURE);
 176                 }
 177         }
 178
 179         if (optind + 1 != argc) {
 180                 warnx(_("bad usage"));
 181                 errtryhelp(EXIT_FAILURE);
 182         }
 183
 184         ctl.path = argv[optind];
 185
 186         if (stat(ctl.path, &ctl.st)) {
 187                 if (!ctl.quiet)
 188                         err(EXIT_FAILURE, "%s", ctl.path);
 189                 return EXIT_FAILURE;
 190         }
 191         if (ctl.dev_devno)
 192                 return print_devno(&ctl) ? EXIT_FAILURE : EXIT_SUCCESS;
 193         if (dir_to_device(&ctl)) {
 194                 if (!ctl.quiet)
 195                         printf(_("%s is not a mountpoint\n"), ctl.path);
 196                 return EXIT_FAILURE;
 197         }
 198         if (ctl.fs_devno)
 199                 printf("%u:%u\n", major(ctl.dev), minor(ctl.dev));
 200         else if (!ctl.quiet)
 201                 printf(_("%s is a mountpoint\n"), ctl.path);
 202         return EXIT_SUCCESS;
 203 }