--- /dev/null
+/*
+ * findmnt(8)
+ *
+ * Copyright (C) 2010 Red Hat, Inc. All rights reserved.
+ * Written by Karel Zak <kzak@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <err.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <string.h>
+
+#include <mount.h>
+
+#include "pathnames.h"
+#include "nls.h"
+
+/*
+ * Column IDs
+ */
+enum {
+ COL_SOURCE,
+ COL_TARGET,
+ COL_FSTYPE,
+ COL_OPTIONS,
+ COL_ISMOUNTED,
+ COL_LABEL,
+ COL_UUID,
+
+ __NCOLUMNS
+};
+
+/*
+ * Column names
+ */
+const char *colnames[] = {
+ [COL_SOURCE] = "source",
+ [COL_TARGET] = "target",
+ [COL_FSTYPE] = "fstype",
+ [COL_OPTIONS] = "options",
+ [COL_ISMOUNTED] = "mounted",
+ [COL_LABEL] = "label",
+ [COL_UUID] = "uuid"
+};
+
+enum {
+ FL_EVALUATE = (1 << 1),
+ FL_CANONICALIZE = (1 << 2),
+ FL_FIRSTONLY = (1 << 3),
+ FL_INVERT = (1 << 4)
+};
+
+struct match_data {
+ const char *source;
+ const char *target;
+ const char *fstypes;
+ const char *options;
+};
+
+int flags;
+int columns[ __NCOLUMNS ];
+int ncolumns;
+mnt_cache *cache;
+
+/*
+ * converts @name to column ID
+ */
+static int get_column_id(const char *name, size_t namesz)
+{
+ int i;
+
+ for (i = 0; i < __NCOLUMNS; i++) {
+ const char *cn = colnames[i];
+
+ if (!strncmp(name, cn, namesz) && !*(cn + namesz))
+ return i;
+ }
+
+ errx(EXIT_FAILURE, _("unknown column: %*s"), (int) namesz, name);
+ return -1;
+}
+
+/*
+ * parses list of columns from @str and set column IDs to columns[]
+ */
+static int ctl_set_columns(const char *str)
+{
+ const char *begin = NULL, *end = NULL, *p;
+
+ ncolumns = 0;
+
+ if (!str || !*str)
+ return -1;
+
+ p = str;
+ for (; p && *p; p++) {
+ if (!begin)
+ begin = p; /* begin of the column name */
+ if (*p == ',')
+ end = p; /* terminate the name */
+ if (*(p + 1) == '\0')
+ end = p + 1; /* end of string */
+ if (!begin || !end)
+ continue;
+ if (end <= begin)
+ return -1;
+
+ columns[ ncolumns++ ] = get_column_id(begin, end - begin);
+ }
+ return 0;
+}
+
+static int print_column(mnt_fs *fs, int id)
+{
+ const char *str = NULL;
+
+ if (!fs)
+ return -1;
+
+ switch(id) {
+ case COL_SOURCE:
+ /* dir or dev */
+ str = mnt_fs_get_source(fs);
+
+ if (str && ((flags & FL_EVALUATE) || (flags & FL_CANONICALIZE)))
+ str = mnt_resolve_spec(str, cache);
+ break;
+ case COL_TARGET:
+ str = mnt_fs_get_target(fs);
+ break;
+ case COL_FSTYPE:
+ str = mnt_fs_get_fstype(fs);
+ break;
+ case COL_OPTIONS:
+ str = mnt_fs_get_optstr(fs);
+ break;
+ default:
+ return -1;
+ }
+
+ if (str)
+ printf("%s", str);
+ return 0;
+}
+
+static int print_fs(mnt_fs *fs)
+{
+ int i;
+
+ for (i = 0; i < ncolumns; i++) {
+ print_column(fs, i);
+ printf("\t");
+ }
+ printf("\n");
+ return 0;
+}
+
+static mnt_tab *parse_tabfile(const char *path)
+{
+ mnt_tab *tb = mnt_new_tab(path);
+ if (!tb)
+ return NULL;
+
+ if (mnt_tab_parse_file(tb) != 0)
+ goto err;
+
+ if (mnt_tab_get_nerrs(tb)) {
+ char buf[BUFSIZ];
+ mnt_tab_strerror(tb, buf, sizeof(buf));
+ warnx(_("%s: parse error: %s"), path, buf);
+ }
+ return tb;
+err:
+ mnt_free_tab(tb);
+ err(EXIT_FAILURE, _("can't read: %s"), path);
+
+ return NULL;
+}
+
+static int match_func(mnt_fs *fs, void *data)
+{
+ struct match_data *m = (struct match_data *) data;
+ int rc = flags & FL_INVERT ? 1 : 0;
+
+ /*fprintf(stderr, "source: %s : %s\n", m->source, mnt_fs_get_source(fs));*/
+
+ if (m->target && !mnt_fs_match_target(fs, m->target, cache))
+ return rc;
+ if (m->source && !mnt_fs_match_source(fs, m->source, cache))
+ return rc;
+ if (m->fstypes && !mnt_fs_match_fstype(fs, m->fstypes))
+ return rc;
+ if (m->options && !mnt_fs_match_options(fs, m->options))
+ return rc;
+
+ return !rc;
+}
+
+static inline int is_list_mode(struct match_data *m)
+{
+ return (!m->source && !m->target && !m->fstypes && !m->options);
+}
+
+static inline int is_mount_mode(struct match_data *m, int fl)
+{
+ if (!m->source)
+ return 0; /* <devname|TAG=|mountpoint> is required */
+ if (m->fstypes || m->options)
+ return 0; /* cannot be restricted by -t or -O */
+ if (!(fl & FL_FIRSTONLY))
+ return 0; /* we have to return the first entry only */
+
+ return 1; /* ok */
+}
+
+static void __attribute__((__noreturn__)) usage(FILE *out)
+{
+ fprintf(out, _("Usage: %s [options] <spec> [<target>]\n\nOptions:\n"),
+ program_invocation_short_name);
+
+ fprintf(out, _(
+ " -s, --fstab search in static table of filesystems\n"
+ " -m, --mtab search in table of mounted filesystems (default)\n"
+ " -k, --kernel search in kernel (mountinfo) file\n\n"
+
+ " -c, --canonicalize canonicalize printed paths\n"
+ " -d, --direction <word> search direction - 'forward' or 'backward'\n"
+ " -e, --evaluate print all TAGs (LABEL/UUID) evaluated\n"
+ " -h, --help print this help\n"
+ " -i, --invert invert sense of matching\n"
+ " -l, --first-only print the first found filesystem only\n"
+ " -o, --output <list> output columns\n"
+ " -O, --options <list> limit the set of filesystems by mount options\n"
+ " -t, --types <list> limit the set of filesystem by FS types\n"));
+
+ fprintf(out, _("\nFor more information see findmnt(1).\n"));
+
+ exit(out == stderr ? EXIT_FAILURE : EXIT_SUCCESS);
+}
+
+int main(int argc, char *argv[])
+{
+ char *tabfile = NULL;
+ int direction = MNT_ITER_FORWARD, ct = 0;
+ mnt_tab *tb;
+ mnt_iter *itr;
+ mnt_fs *fs = NULL;
+ int c;
+ struct match_data mdata_buf, *mdata = &mdata_buf;
+
+ struct option longopts[] = {
+ { "fstab", 0, 0, 's' },
+ { "mtab", 0, 0, 'm' },
+ { "kernel", 0, 0, 'k' },
+ { "canonicalize", 0, 0, 'c' },
+ { "direction", 1, 0, 'd' },
+ { "evaluate", 0, 0, 'e' },
+ { "help", 0, 0, 'h' },
+ { "invert", 0, 0, 'i' },
+ { "first-only", 0, 0, 'l' },
+ { "output", 0, 0, 'o' },
+ { "options", 1, 0, 'O' },
+ { "types", 1, 0, 't' },
+ { NULL, 0, 0, 0 }
+ };
+
+ setlocale(LC_ALL, "");
+ bindtextdomain(PACKAGE, LOCALEDIR);
+ textdomain(PACKAGE);
+
+ /* default */
+ columns[ncolumns++] = COL_SOURCE;
+ columns[ncolumns++] = COL_TARGET;
+ columns[ncolumns++] = COL_FSTYPE;
+ columns[ncolumns++] = COL_OPTIONS;
+
+ memset(mdata, 0, sizeof(*mdata));
+
+ while ((c = getopt_long(argc, argv, "cd:ehiloO:kmst:", longopts, NULL)) != -1) {
+ switch(c) {
+ case 'c':
+ flags |= FL_CANONICALIZE;
+ break;
+ case 'd':
+ if (!strcmp(optarg, _("forward")))
+ direction = MNT_ITER_FORWARD;
+ else if (!strcmp(optarg, _("backward")))
+ direction = MNT_ITER_BACKWARD;
+ else
+ errx(EXIT_FAILURE,
+ _("uknown direction '%s')"), optarg);
+ break;
+ case 'e':
+ flags |= FL_EVALUATE;
+ break;
+ case 'h':
+ usage(stdout);
+ break;
+ case 'i':
+ flags |= FL_INVERT;
+ break;
+ case 'l':
+ flags |= FL_FIRSTONLY;
+ break;
+ case 'o':
+ ctl_set_columns(optarg);
+ break;
+ case 'O':
+ mdata->options = optarg;
+ break;
+ case 'm':
+ if (tabfile)
+ errx(EXIT_FAILURE, _("--{fstab,mtab,kernel} "
+ "options are mutually exclusive"));
+ tabfile = _PATH_MOUNTED;
+ break;
+ case 's':
+ if (tabfile)
+ errx(EXIT_FAILURE, _("--{fstab,mtab,kernel} "
+ "options are mutually exclusive"));
+ tabfile = _PATH_MNTTAB;
+ break;
+ case 'k':
+ if (tabfile)
+ errx(EXIT_FAILURE, _("--{fstab,mtab,kernel} "
+ "options are mutually exclusive"));
+ tabfile = _PATH_PROC_MOUNTINFO;
+ break;
+ case 't':
+ mdata->fstypes = optarg;
+ break;
+ default:
+ usage(stderr);
+ break;
+ }
+ }
+
+ if (!tabfile)
+ tabfile = _PATH_MOUNTED;
+ if (optind < argc)
+ /* dev, tag or mountpoint */
+ mdata->source = argv[optind++];
+ if (optind < argc)
+ /* mountpoint */
+ mdata->target = argv[optind++];
+
+ tb = parse_tabfile(tabfile);
+ if (!tb)
+ return EXIT_FAILURE;
+
+ itr = mnt_new_iter(direction);
+ if (!itr)
+ err(EXIT_FAILURE, _("failed to initialize libmount iterator"));
+
+ cache = mnt_new_cache();
+ if (!cache)
+ err(EXIT_FAILURE, _("failed to initialize libmount cache"));
+
+ mnt_tab_set_cache(tb, cache);
+
+ if (is_list_mode(mdata)) {
+ /*
+ * Print whole file
+ */
+ while(mnt_tab_next_fs(tb, itr, &fs) == 0) {
+ print_fs(fs);
+ ct++;
+ if (flags & FL_FIRSTONLY)
+ break;
+ }
+ } else if (is_mount_mode(mdata, flags)) {
+
+ /*
+ * Look up for FS in the same way how mount(8) searchs in fstab
+ *
+ * findmnt -l <spec>
+ */
+ fs = mnt_tab_find_source(tb, mdata->source, direction);
+ if (!fs)
+ fs = mnt_tab_find_target(tb, mdata->source, direction);
+ if (fs) {
+ print_fs(fs);
+ ct++;
+ }
+ } else {
+ /*
+ * Look up for all matching entries
+ *
+ * findmnt [-l] <source> <target> [-O <options>] [-t <types>]
+ * findmnt [-l] <spec> [-O <options>] [-t <types>]
+ */
+again:
+ while (!mnt_tab_find_next_fs(tb, itr,
+ match_func, (void *) mdata, &fs)) {
+ print_fs(fs);
+ ct++;
+ if (flags & FL_FIRSTONLY)
+ break;
+ }
+ if (!ct && !mdata->target && mdata->source) {
+ /* swap 'spec' and target. */
+ mdata->target = mdata->source;
+ mdata->source = NULL;
+ mnt_reset_iter(itr, direction);
+ goto again;
+ }
+ }
+
+ mnt_free_tab(tb);
+ mnt_free_cache(cache);
+ mnt_free_iter(itr);
+
+ return ct ? EXIT_SUCCESS : 2;
+}
projects / util-linux / commitdiff