Adding upstream version 2.38.1.upstream/2.38.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1873 insertions, 0 deletions

diff --git a/misc-utils/findmnt.c b/misc-utils/findmnt.c
new file mode 100644
index 0000000..733bbc1
--- /dev/null
+++ b/misc-utils/findmnt.c
@@ -0,0 +1,1873 @@
+/*
+ * findmnt(8)
+ *
+ * Copyright (C) 2010-2015 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.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <string.h>
+#include <termios.h>
+#ifdef HAVE_SYS_IOCTL_H
+# include <sys/ioctl.h>
+#endif
+#include <assert.h>
+#include <poll.h>
+#include <sys/statvfs.h>
+#include <sys/types.h>
+#ifdef HAVE_LIBUDEV
+# include <libudev.h>
+#endif
+#include <blkid.h>
+#include <libmount.h>
+#include <libsmartcols.h>
+
+#include "pathnames.h"
+#include "nls.h"
+#include "closestream.h"
+#include "c.h"
+#include "strutils.h"
+#include "xalloc.h"
+#include "optutils.h"
+#include "mangle.h"
+#include "buffer.h"
+
+#include "findmnt.h"
+
+/* column IDs */
+enum {
+	COL_ACTION,
+	COL_AVAIL,
+	COL_FREQ,
+	COL_FSROOT,
+	COL_FSTYPE,
+	COL_FS_OPTIONS,
+	COL_ID,
+	COL_LABEL,
+	COL_MAJMIN,
+	COL_OLD_OPTIONS,
+	COL_OLD_TARGET,
+	COL_OPTIONS,
+	COL_OPT_FIELDS,
+	COL_PARENT,
+	COL_PARTLABEL,
+	COL_PARTUUID,
+	COL_PASSNO,
+	COL_PROPAGATION,
+	COL_SIZE,
+	COL_SOURCE,
+	COL_SOURCES,
+	COL_TARGET,
+	COL_TID,
+	COL_USED,
+	COL_USEPERC,
+	COL_UUID,
+	COL_VFS_OPTIONS
+};
+
+enum {
+	TABTYPE_FSTAB = 1,
+	TABTYPE_MTAB,
+	TABTYPE_KERNEL
+};
+
+/* column names */
+struct colinfo {
+	const char	*name;		/* header */
+	double		whint;		/* width hint (N < 1 is in percent of termwidth) */
+	int		flags;		/* libsmartcols flags */
+	const char      *help;		/* column description */
+	const char	*match;		/* pattern for match_func() */
+	void		*match_data;	/* match specific data */
+};
+
+/* columns descriptions (don't use const, this is writable) */
+static struct colinfo infos[] = {
+	[COL_ACTION]       = { "ACTION",         10, SCOLS_FL_STRICTWIDTH, N_("action detected by --poll") },
+	[COL_AVAIL]        = { "AVAIL",           5, SCOLS_FL_RIGHT, N_("filesystem size available") },
+	[COL_FREQ]         = { "FREQ",            1, SCOLS_FL_RIGHT, N_("dump(8) period in days [fstab only]") },
+	[COL_FSROOT]       = { "FSROOT",       0.25, SCOLS_FL_NOEXTREMES, N_("filesystem root") },
+	[COL_FSTYPE]       = { "FSTYPE",       0.10, SCOLS_FL_TRUNC, N_("filesystem type") },
+	[COL_FS_OPTIONS]   = { "FS-OPTIONS",   0.10, SCOLS_FL_TRUNC, N_("FS specific mount options") },
+	[COL_ID]           = { "ID",              2, SCOLS_FL_RIGHT, N_("mount ID") },
+	[COL_LABEL]        = { "LABEL",        0.10, 0, N_("filesystem label") },
+	[COL_MAJMIN]       = { "MAJ:MIN",         6, 0, N_("major:minor device number") },
+	[COL_OLD_OPTIONS]  = { "OLD-OPTIONS",  0.10, SCOLS_FL_TRUNC, N_("old mount options saved by --poll") },
+	[COL_OLD_TARGET]   = { "OLD-TARGET",   0.30, 0, N_("old mountpoint saved by --poll") },
+	[COL_OPTIONS]      = { "OPTIONS",      0.10, SCOLS_FL_TRUNC, N_("all mount options") },
+	[COL_OPT_FIELDS]   = { "OPT-FIELDS",   0.10, SCOLS_FL_TRUNC, N_("optional mount fields") },
+	[COL_PARENT]       = { "PARENT",          2, SCOLS_FL_RIGHT, N_("mount parent ID") },
+	[COL_PARTLABEL]    = { "PARTLABEL",    0.10, 0, N_("partition label") },
+	[COL_PARTUUID]     = { "PARTUUID",       36, 0, N_("partition UUID") },
+	[COL_PASSNO]       = { "PASSNO",          1, SCOLS_FL_RIGHT, N_("pass number on parallel fsck(8) [fstab only]") },
+	[COL_PROPAGATION]  = { "PROPAGATION",  0.10, 0, N_("VFS propagation flags") },
+	[COL_SIZE]         = { "SIZE",            5, SCOLS_FL_RIGHT, N_("filesystem size") },
+	[COL_SOURCES]      = { "SOURCES",      0.25, SCOLS_FL_WRAP, N_("all possible source devices") },
+	[COL_SOURCE]       = { "SOURCE",       0.25, SCOLS_FL_NOEXTREMES, N_("source device") },
+	[COL_TARGET]       = { "TARGET",       0.30, SCOLS_FL_TREE| SCOLS_FL_NOEXTREMES, N_("mountpoint") },
+	[COL_TID]          = { "TID",             4, SCOLS_FL_RIGHT, N_("task ID") },
+	[COL_USED]         = { "USED",            5, SCOLS_FL_RIGHT, N_("filesystem size used") },
+	[COL_USEPERC]      = { "USE%",            3, SCOLS_FL_RIGHT, N_("filesystem use percentage") },
+	[COL_UUID]         = { "UUID",           36, 0, N_("filesystem UUID") },
+	[COL_VFS_OPTIONS]  = { "VFS-OPTIONS",  0.20, SCOLS_FL_TRUNC, N_("VFS specific mount options") }
+};
+
+/* columns[] array specifies all currently wanted output column. The columns
+ * are defined by infos[] array and you can specify (on command line) each
+ * column twice. That's enough, dynamically allocated array of the columns is
+ * unnecessary overkill and over-engineering in this case */
+static int columns[ARRAY_SIZE(infos) * 2];
+static size_t ncolumns;
+
+static inline size_t err_columns_index(size_t arysz, size_t idx)
+{
+	if (idx >= arysz)
+		errx(EXIT_FAILURE, _("too many columns specified, "
+				     "the limit is %zu columns"),
+				arysz - 1);
+	return idx;
+}
+
+#define add_column(ary, n, id)	\
+		((ary)[ err_columns_index(ARRAY_SIZE(ary), (n)) ] = (id))
+
+/* poll actions (parsed --poll=<list> */
+#define FINDMNT_NACTIONS	4		/* mount, umount, move, remount */
+static int actions[FINDMNT_NACTIONS];
+static int nactions;
+
+/* global (accessed from findmnt-verify.c too) */
+unsigned int flags;
+int parse_nerrors;
+struct libmnt_cache *cache;
+
+static blkid_cache blk_cache;
+
+#ifdef HAVE_LIBUDEV
+static struct udev *udev;
+#endif
+
+static int match_func(struct libmnt_fs *fs, void *data __attribute__ ((__unused__)));
+
+
+static int get_column_id(int num)
+{
+	assert(num >= 0);
+	assert((size_t) num < ncolumns);
+	assert((size_t) columns[num] < ARRAY_SIZE(infos));
+	return columns[num];
+}
+
+static struct colinfo *get_column_info(int num)
+{
+	return &infos[ get_column_id(num) ];
+}
+
+static const char *column_id_to_name(int id)
+{
+	assert((size_t) id < ARRAY_SIZE(infos));
+	return infos[id].name;
+}
+
+static const char *get_column_name(int num)
+{
+	return get_column_info(num)->name;
+}
+
+static float get_column_whint(int num)
+{
+	return get_column_info(num)->whint;
+}
+
+static int get_column_flags(int num)
+{
+	return get_column_info(num)->flags;
+}
+
+static const char *get_match(int id)
+{
+	assert((size_t) id < ARRAY_SIZE(infos));
+	return infos[id].match;
+}
+
+static void *get_match_data(int id)
+{
+	assert((size_t) id < ARRAY_SIZE(infos));
+	return infos[id].match_data;
+}
+
+static void set_match(int id, const char *match)
+{
+	assert((size_t) id < ARRAY_SIZE(infos));
+	infos[id].match = match;
+}
+
+static void set_match_data(int id, void *data)
+{
+	assert((size_t) id < ARRAY_SIZE(infos));
+	infos[id].match_data = data;
+}
+
+/*
+ * source match means COL_SOURCE *or* COL_MAJMIN, depends on
+ * data format.
+ */
+static void set_source_match(const char *data)
+{
+	int maj, min;
+
+	if (sscanf(data, "%d:%d", &maj, &min) == 2) {
+		dev_t *devno = xmalloc(sizeof(dev_t));
+
+		*devno = makedev(maj, min);
+		set_match(COL_MAJMIN, data);
+		set_match_data(COL_MAJMIN, (void *) devno);
+		flags |= FL_NOSWAPMATCH;
+	} else
+		set_match(COL_SOURCE, data);
+}
+
+/*
+ * Extra functionality for --target <path>. The function mnt_table_find_mountpoint()
+ * also checks parents (path elements in reverse order) to get mountpoint.
+ *
+ * @tb has to be from kernel (so no fstab or so)!
+ */
+static void enable_extra_target_match(struct libmnt_table *tb)
+{
+	char *cn = NULL;
+	const char *tgt = NULL, *mnt = NULL;
+	struct libmnt_fs *fs;
+
+	/*
+	 * Check if match pattern is mountpoint, if not use the
+	 * real mountpoint.
+	 */
+	if (flags & FL_NOCACHE)
+		tgt = get_match(COL_TARGET);
+	else {
+		tgt = cn = mnt_resolve_path(get_match(COL_TARGET), cache);
+		if (!cn)
+			return;
+	}
+
+	fs = mnt_table_find_mountpoint(tb, tgt, MNT_ITER_BACKWARD);
+	if (fs)
+		mnt = mnt_fs_get_target(fs);
+	if (mnt && strcmp(mnt, tgt) != 0)
+		set_match(COL_TARGET, xstrdup(mnt));	/* replace the current setting */
+
+	if (!cache)
+		free(cn);
+}
+
+
+static int is_tabdiff_column(int id)
+{
+	assert((size_t) id < ARRAY_SIZE(infos));
+
+	switch(id) {
+	case COL_ACTION:
+	case COL_OLD_TARGET:
+	case COL_OLD_OPTIONS:
+		return 1;
+	default:
+		break;
+	}
+	return 0;
+}
+
+/*
+ * "findmnt" without any filter
+ */
+int is_listall_mode(void)
+{
+	if ((flags & FL_DF || flags & FL_REAL || flags & FL_PSEUDO) && !(flags & FL_ALL))
+		return 0;
+
+	return (!get_match(COL_SOURCE) &&
+		!get_match(COL_TARGET) &&
+		!get_match(COL_FSTYPE) &&
+		!get_match(COL_OPTIONS) &&
+		!get_match(COL_MAJMIN));
+}
+
+/*
+ * Returns 1 if the @act is in the --poll=<list>
+ */
+static int has_poll_action(int act)
+{
+	int i;
+
+	if (!nactions)
+		return 1;	/* all actions enabled */
+	for (i = 0; i < nactions; i++)
+		if (actions[i] == act)
+			return 1;
+	return 0;
+}
+
+static int poll_action_name_to_id(const char *name, size_t namesz)
+{
+	int id = -1;
+
+	if (strncasecmp(name, "move", namesz) == 0 && namesz == 4)
+		id = MNT_TABDIFF_MOVE;
+	else if (strncasecmp(name, "mount", namesz) == 0 && namesz == 5)
+		id = MNT_TABDIFF_MOUNT;
+	else if (strncasecmp(name, "umount", namesz) == 0 && namesz == 6)
+		id = MNT_TABDIFF_UMOUNT;
+	else if (strncasecmp(name, "remount", namesz) == 0 && namesz == 7)
+		id = MNT_TABDIFF_REMOUNT;
+	else
+		warnx(_("unknown action: %s"), name);
+
+	return id;
+}
+
+/*
+ * findmnt --first-only <devname|TAG=|mountpoint>
+ *
+ * ... it works like "mount <devname|TAG=|mountpoint>"
+ */
+static int is_mount_compatible_mode(void)
+{
+	if (!get_match(COL_SOURCE))
+	       return 0;		/* <devname|TAG=|mountpoint> is required */
+	if (get_match(COL_FSTYPE) || get_match(COL_OPTIONS))
+		return 0;		/* cannot be restricted by -t or -O */
+	if (!(flags & FL_FIRSTONLY))
+		return 0;		/* we have to return the first entry only */
+
+	return 1;			/* ok */
+}
+
+static void disable_columns_truncate(void)
+{
+	size_t i;
+
+	for (i = 0; i < ARRAY_SIZE(infos); i++)
+		infos[i].flags &= ~SCOLS_FL_TRUNC;
+}
+
+/*
+ * converts @name to column ID
+ */
+static int column_name_to_id(const char *name, size_t namesz)
+{
+	size_t i;
+
+	for (i = 0; i < ARRAY_SIZE(infos); i++) {
+		const char *cn = column_id_to_name(i);
+
+		if (!strncasecmp(name, cn, namesz) && !*(cn + namesz))
+			return i;
+	}
+	warnx(_("unknown column: %s"), name);
+	return -1;
+}
+
+
+#ifdef HAVE_LIBUDEV
+static char *get_tag_from_udev(const char *devname, int col)
+{
+	struct udev_device *dev;
+	const char *data = NULL;
+	char *res = NULL, *path;
+
+	if (!udev)
+		udev = udev_new();
+	if (!udev)
+		return NULL;
+
+	/* libudev don't like /dev/mapper/ symlinks */
+	path = realpath(devname, NULL);
+	if (path)
+		devname = path;
+
+	if (strncmp(devname, "/dev/", 5) == 0)
+		devname += 5;
+
+	dev = udev_device_new_from_subsystem_sysname(udev, "block", devname);
+	free(path);
+
+	if (!dev)
+		return NULL;
+
+	switch(col) {
+	case COL_LABEL:
+		data = udev_device_get_property_value(dev, "ID_FS_LABEL_ENC");
+		break;
+	case COL_UUID:
+		data = udev_device_get_property_value(dev, "ID_FS_UUID_ENC");
+		break;
+	case COL_PARTUUID:
+		data = udev_device_get_property_value(dev, "ID_PART_ENTRY_UUID");
+		break;
+	case COL_PARTLABEL:
+		data = udev_device_get_property_value(dev, "ID_PART_ENTRY_NAME");
+		break;
+	default:
+		break;
+	}
+
+	if (data) {
+		res = xstrdup(data);
+		unhexmangle_string(res);
+	}
+
+	udev_device_unref(dev);
+	return res;
+}
+#endif /* HAVE_LIBUDEV */
+
+/* Returns LABEL or UUID */
+static char *get_tag(struct libmnt_fs *fs, const char *tagname, int col
+#ifndef HAVE_LIBUDEV
+		__attribute__((__unused__))
+#endif
+		)
+{
+	const char *t, *v;
+	char *res = NULL;
+
+	if (!mnt_fs_get_tag(fs, &t, &v) && !strcmp(t, tagname))
+		res = xstrdup(v);
+	else {
+		const char *dev = mnt_fs_get_source(fs);
+
+		if (dev && !(flags & FL_NOCACHE))
+			dev = mnt_resolve_spec(dev, cache);
+#ifdef HAVE_LIBUDEV
+		if (dev)
+			res = get_tag_from_udev(dev, col);
+#endif
+		if (!res) {
+			res = mnt_cache_find_tag_value(cache, dev, tagname);
+			if (res && cache)
+				/* don't return pointer to cache */
+				res = xstrdup(res);
+		}
+	}
+
+	return res;
+}
+
+static char *get_vfs_attr(struct libmnt_fs *fs, int sizetype)
+{
+	struct statvfs buf;
+	uint64_t vfs_attr = 0;
+	char *sizestr;
+
+	if (statvfs(mnt_fs_get_target(fs), &buf) != 0)
+		return NULL;
+
+	switch(sizetype) {
+	case COL_SIZE:
+		vfs_attr = buf.f_frsize * buf.f_blocks;
+		break;
+	case COL_AVAIL:
+		vfs_attr = buf.f_frsize * buf.f_bavail;
+		break;
+	case COL_USED:
+		vfs_attr = buf.f_frsize * (buf.f_blocks - buf.f_bfree);
+		break;
+	case COL_USEPERC:
+		if (buf.f_blocks == 0)
+			return xstrdup("-");
+
+		xasprintf(&sizestr, "%.0f%%",
+				(double)(buf.f_blocks - buf.f_bfree) /
+				buf.f_blocks * 100);
+		return sizestr;
+	}
+
+	if (!vfs_attr)
+		sizestr = xstrdup("0");
+	else if (flags & FL_BYTES)
+		xasprintf(&sizestr, "%ju", vfs_attr);
+	else
+		sizestr = size_to_human_string(SIZE_SUFFIX_1LETTER, vfs_attr);
+
+	return sizestr;
+}
+
+/* reads sources from libmount/libblkid
+ */
+static char *get_data_col_sources(struct libmnt_fs *fs, int evaluate)
+{
+	const char *tag = NULL, *p = NULL;
+	int i = 0;
+	const char *device = NULL;
+	char *val = NULL;
+	blkid_dev_iterate iter;
+	blkid_dev dev;
+	struct ul_buffer buf = UL_INIT_BUFFER;
+
+	/* get TAG from libmount if avalable (e.g. fstab) */
+	if (mnt_fs_get_tag(fs, &tag, &p) == 0) {
+
+		/* if device is in the form 'UUID=..' or 'LABEL=..' and evaluate==0
+		 * then it is ok to do not search for multiple devices
+		 */
+		if (!evaluate)
+			goto nothing;
+		val = xstrdup(p);
+	}
+
+	/* or get device name */
+	else if (!(device = mnt_fs_get_srcpath(fs))
+		 || strncmp(device, "/dev/", 5) != 0)
+		goto nothing;
+
+	if (!blk_cache) {
+		if (blkid_get_cache(&blk_cache, NULL) != 0)
+			goto nothing;
+		blkid_probe_all(blk_cache);
+	}
+
+	/* ask libblkid for the UUID */
+	if (!val) {
+		assert(device);
+
+		tag = "UUID";
+		val = blkid_get_tag_value(blk_cache, "UUID", device);	/* returns allocated string */
+		if (!val)
+			goto nothing;
+	}
+
+	assert(val);
+	assert(tag);
+
+	/* scan all devices for the TAG */
+	iter = blkid_dev_iterate_begin(blk_cache);
+	blkid_dev_set_search(iter, tag, val);
+
+	while (blkid_dev_next(iter, &dev) == 0) {
+		dev = blkid_verify(blk_cache, dev);
+		if (!dev)
+			continue;
+		if (i != 0)
+			ul_buffer_append_data(&buf, "\n", 1);
+		ul_buffer_append_string(&buf, blkid_dev_devname(dev));
+		i++;
+	}
+	blkid_dev_iterate_end(iter);
+	free(val);
+
+	return ul_buffer_get_data(&buf, NULL, NULL);
+
+nothing:
+	free(val);
+	return NULL;
+}
+
+/* reads FS data from libmount
+ */
+static char *get_data(struct libmnt_fs *fs, int num)
+{
+	char *str = NULL;
+	int col_id = get_column_id(num);
+
+	switch (col_id) {
+	case COL_SOURCES:
+		/* print all devices with the same tag (LABEL, UUID) */
+		str = get_data_col_sources(fs, flags & FL_EVALUATE);
+		if (str)
+			break;
+
+		/* fallthrough */
+	case COL_SOURCE:
+	{
+		const char *root = mnt_fs_get_root(fs);
+		const char *spec = mnt_fs_get_srcpath(fs);
+		char *cn = NULL;
+
+		if (spec && (flags & FL_CANONICALIZE))
+			spec = cn = mnt_resolve_path(spec, cache);
+		if (!spec) {
+			spec = mnt_fs_get_source(fs);
+
+			if (spec && (flags & FL_EVALUATE))
+				spec = cn = mnt_resolve_spec(spec, cache);
+		}
+		if (root && spec && !(flags & FL_NOFSROOT) && strcmp(root, "/") != 0)
+			xasprintf(&str, "%s[%s]", spec, root);
+		else if (spec)
+			str = xstrdup(spec);
+		if (!cache)
+			free(cn);
+		break;
+	}
+
+	case COL_TARGET:
+		if (mnt_fs_get_target(fs))
+			str = xstrdup(mnt_fs_get_target(fs));
+		break;
+	case COL_FSTYPE:
+		if (mnt_fs_get_fstype(fs))
+			str = xstrdup(mnt_fs_get_fstype(fs));
+		break;
+	case COL_OPTIONS:
+		if (mnt_fs_get_options(fs))
+			str = xstrdup(mnt_fs_get_options(fs));
+		break;
+	case COL_VFS_OPTIONS:
+		if (flags & FL_VFS_ALL)
+			str = mnt_fs_get_vfs_options_all(fs);
+		else if (mnt_fs_get_vfs_options(fs))
+			str = xstrdup(mnt_fs_get_vfs_options(fs));
+		break;
+	case COL_FS_OPTIONS:
+		if (mnt_fs_get_fs_options(fs))
+			str = xstrdup(mnt_fs_get_fs_options(fs));
+		break;
+	case COL_OPT_FIELDS:
+		if (mnt_fs_get_optional_fields(fs))
+			str = xstrdup(mnt_fs_get_optional_fields(fs));
+		break;
+	case COL_UUID:
+		str = get_tag(fs, "UUID", col_id);
+		break;
+	case COL_PARTUUID:
+		str = get_tag(fs, "PARTUUID", col_id);
+		break;
+	case COL_LABEL:
+		str = get_tag(fs, "LABEL", col_id);
+		break;
+	case COL_PARTLABEL:
+		str = get_tag(fs, "PARTLABEL", col_id);
+		break;
+
+	case COL_MAJMIN:
+	{
+		dev_t devno = mnt_fs_get_devno(fs);
+		if (!devno)
+			break;
+
+		if ((flags & FL_RAW) || (flags & FL_EXPORT) || (flags & FL_JSON))
+			xasprintf(&str, "%u:%u", major(devno), minor(devno));
+		else
+			xasprintf(&str, "%3u:%-3u", major(devno), minor(devno));
+		break;
+	}
+	case COL_SIZE:
+	case COL_AVAIL:
+	case COL_USED:
+	case COL_USEPERC:
+		str = get_vfs_attr(fs, col_id);
+		break;
+	case COL_FSROOT:
+		if (mnt_fs_get_root(fs))
+			str = xstrdup(mnt_fs_get_root(fs));
+		break;
+	case COL_TID:
+		if (mnt_fs_get_tid(fs))
+			xasprintf(&str, "%d", mnt_fs_get_tid(fs));
+		break;
+	case COL_ID:
+		if (mnt_fs_get_id(fs))
+			xasprintf(&str, "%d", mnt_fs_get_id(fs));
+		break;
+	case COL_PARENT:
+		if (mnt_fs_get_parent_id(fs))
+			xasprintf(&str, "%d", mnt_fs_get_parent_id(fs));
+		break;
+	case COL_PROPAGATION:
+		if (mnt_fs_is_kernel(fs)) {
+			unsigned long fl = 0;
+			char *n = NULL;
+
+			if (mnt_fs_get_propagation(fs, &fl) != 0)
+				break;
+
+			n = xstrdup((fl & MS_SHARED) ? "shared" : "private");
+
+			if (fl & MS_SLAVE) {
+				xasprintf(&str, "%s,slave", n);
+				free(n);
+				n = str;
+			}
+			if (fl & MS_UNBINDABLE) {
+				xasprintf(&str, "%s,unbindable", n);
+				free(n);
+				n = str;
+			}
+			str = n;
+		}
+		break;
+	case COL_FREQ:
+		if (!mnt_fs_is_kernel(fs))
+			xasprintf(&str, "%d", mnt_fs_get_freq(fs));
+		break;
+	case COL_PASSNO:
+		if (!mnt_fs_is_kernel(fs))
+			xasprintf(&str, "%d", mnt_fs_get_passno(fs));
+		break;
+	default:
+		break;
+	}
+	return str;
+}
+
+static char *get_tabdiff_data(struct libmnt_fs *old_fs,
+				    struct libmnt_fs *new_fs,
+				    int change,
+				    int num)
+{
+	char *str = NULL;
+
+	switch (get_column_id(num)) {
+	case COL_ACTION:
+		switch (change) {
+		case MNT_TABDIFF_MOUNT:
+			str = _("mount");
+			break;
+		case MNT_TABDIFF_UMOUNT:
+			str = _("umount");
+			break;
+		case MNT_TABDIFF_REMOUNT:
+			str = _("remount");
+			break;
+		case MNT_TABDIFF_MOVE:
+			str = _("move");
+			break;
+		default:
+			str = _("unknown");
+			break;
+		}
+		str = xstrdup(str);
+		break;
+	case COL_OLD_OPTIONS:
+		if (old_fs && (change == MNT_TABDIFF_REMOUNT ||
+			       change == MNT_TABDIFF_UMOUNT)
+		           && mnt_fs_get_options(old_fs))
+			str = xstrdup(mnt_fs_get_options(old_fs));
+		break;
+	case COL_OLD_TARGET:
+		if (old_fs && (change == MNT_TABDIFF_MOVE ||
+			       change == MNT_TABDIFF_UMOUNT)
+			   && mnt_fs_get_target(old_fs))
+			str = xstrdup(mnt_fs_get_target(old_fs));
+		break;
+	default:
+		if (new_fs)
+			str = get_data(new_fs, num);
+		else
+			str = get_data(old_fs, num);
+		break;
+	}
+	return str;
+}
+
+/* adds one line to the output @tab */
+static struct libscols_line *add_line(struct libscols_table *table, struct libmnt_fs *fs,
+					struct libscols_line *parent)
+{
+	size_t i;
+	struct libscols_line *line = scols_table_new_line(table, parent);
+
+	if (!line)
+		err(EXIT_FAILURE, _("failed to allocate output line"));
+
+	for (i = 0; i < ncolumns; i++) {
+		if (scols_line_refer_data(line, i, get_data(fs, i)))
+			err(EXIT_FAILURE, _("failed to add output data"));
+	}
+
+	scols_line_set_userdata(line, fs);
+	return line;
+}
+
+static struct libscols_line *add_tabdiff_line(struct libscols_table *table, struct libmnt_fs *new_fs,
+			struct libmnt_fs *old_fs, int change)
+{
+	size_t i;
+	struct libscols_line *line = scols_table_new_line(table, NULL);
+
+	if (!line)
+		err(EXIT_FAILURE, _("failed to allocate output line"));
+
+	for (i = 0; i < ncolumns; i++) {
+		if (scols_line_refer_data(line, i,
+				get_tabdiff_data(old_fs, new_fs, change, i)))
+			err(EXIT_FAILURE, _("failed to add output data"));
+	}
+
+	return line;
+}
+
+static int has_line(struct libscols_table *table, struct libmnt_fs *fs)
+{
+	struct libscols_line *ln;
+	struct libscols_iter *itr;
+	int rc = 0;
+
+	itr = scols_new_iter(SCOLS_ITER_FORWARD);
+	if (!itr)
+		return 0;
+
+	while (scols_table_next_line(table, itr, &ln) == 0) {
+		if ((struct libmnt_fs *) scols_line_get_userdata(ln) == fs) {
+			rc = 1;
+			break;
+		}
+	}
+
+	scols_free_iter(itr);
+	return rc;
+}
+
+/* reads filesystems from @tb (libmount) and fillin @table (output table) */
+static int create_treenode(struct libscols_table *table, struct libmnt_table *tb,
+			   struct libmnt_fs *fs, struct libscols_line *parent_line)
+{
+	struct libmnt_fs *chld = NULL;
+	struct libmnt_iter *itr = NULL;
+	struct libscols_line *line;
+	int rc = -1, first = 0;
+
+	if (!fs) {
+		/* first call, get root FS */
+		if (mnt_table_get_root_fs(tb, &fs))
+			goto leave;
+		parent_line = NULL;
+		first = 1;
+
+	} else if ((flags & FL_SUBMOUNTS) && has_line(table, fs))
+		return 0;
+
+	itr = mnt_new_iter(MNT_ITER_FORWARD);
+	if (!itr)
+		goto leave;
+
+	if ((flags & FL_SUBMOUNTS) || match_func(fs, NULL)) {
+		line = add_line(table, fs, parent_line);
+		if (!line)
+			goto leave;
+	} else
+		line = parent_line;
+
+	/*
+	 * add all children to the output table
+	 */
+	while (mnt_table_next_child_fs(tb, itr, fs, &chld) == 0) {
+		if (create_treenode(table, tb, chld, line))
+			goto leave;
+	}
+	rc = 0;
+
+	/* make sure all entries are in the tree */
+	if (first && (size_t) mnt_table_get_nents(tb) >
+		     (size_t) scols_table_get_nlines(table)) {
+		mnt_reset_iter(itr, MNT_ITER_FORWARD);
+		fs = NULL;
+
+		while (mnt_table_next_fs(tb, itr, &fs) == 0) {
+			if (!has_line(table, fs) && match_func(fs, NULL))
+				create_treenode(table, tb, fs, NULL);
+		}
+	}
+leave:
+	mnt_free_iter(itr);
+	return rc;
+}
+
+/* error callback */
+static int parser_errcb(struct libmnt_table *tb __attribute__ ((__unused__)),
+			const char *filename, int line)
+{
+	warnx(_("%s: parse error at line %d -- ignored"), filename, line);
+	++parse_nerrors;
+	return 1;
+}
+
+static char **append_tabfile(char **files, int *nfiles, char *filename)
+{
+	files = xrealloc(files, sizeof(char *) * (*nfiles + 1));
+	files[(*nfiles)++] = filename;
+	return files;
+}
+
+static char **append_pid_tabfile(char **files, int *nfiles, pid_t pid)
+{
+	char *path = NULL;
+
+	xasprintf(&path, "/proc/%d/mountinfo", (int) pid);
+	return append_tabfile(files, nfiles, path);
+}
+
+/* calls libmount fstab/mtab/mountinfo parser */
+static struct libmnt_table *parse_tabfiles(char **files,
+					   int nfiles,
+					   int tabtype)
+{
+	struct libmnt_table *tb;
+	int rc = 0;
+
+	tb = mnt_new_table();
+	if (!tb) {
+		warn(_("failed to initialize libmount table"));
+		return NULL;
+	}
+	mnt_table_set_parser_errcb(tb, parser_errcb);
+
+	do {
+		/* NULL means that libmount will use default paths */
+		const char *path = nfiles ? *files++ : NULL;
+
+		switch (tabtype) {
+		case TABTYPE_FSTAB:
+			rc = mnt_table_parse_fstab(tb, path);
+			break;
+		case TABTYPE_MTAB:
+			rc = mnt_table_parse_mtab(tb, path);
+			break;
+		case TABTYPE_KERNEL:
+			if (!path)
+				path = access(_PATH_PROC_MOUNTINFO, R_OK) == 0 ?
+					      _PATH_PROC_MOUNTINFO :
+					      _PATH_PROC_MOUNTS;
+
+			rc = mnt_table_parse_file(tb, path);
+			break;
+		}
+		if (rc) {
+			mnt_unref_table(tb);
+			warn(_("can't read %s"), path);
+			return NULL;
+		}
+	} while (--nfiles > 0);
+
+	return tb;
+}
+
+/*
+ * Parses mountinfo and calls mnt_cache_set_targets(cache, mtab). Only
+ * necessary if @tb in main() was read from a non-kernel source.
+ */
+static void cache_set_targets(struct libmnt_cache *tmp)
+{
+	struct libmnt_table *tb;
+	const char *path;
+
+	tb = mnt_new_table();
+	if (!tb)
+		return;
+
+	path = access(_PATH_PROC_MOUNTINFO, R_OK) == 0 ?
+		_PATH_PROC_MOUNTINFO :
+		_PATH_PROC_MOUNTS;
+
+	if (mnt_table_parse_file(tb, path) == 0)
+		mnt_cache_set_targets(tmp, tb);
+
+	mnt_unref_table(tb);
+}
+
+/* checks if @tb contains parent->child relations */
+static int tab_is_tree(struct libmnt_table *tb)
+{
+	struct libmnt_fs *fs = NULL;
+	struct libmnt_iter *itr;
+	int rc = 0;
+
+	itr = mnt_new_iter(MNT_ITER_BACKWARD);
+	if (!itr)
+		return 0;
+
+	rc = (mnt_table_next_fs(tb, itr, &fs) == 0 &&
+	      mnt_fs_is_kernel(fs) &&
+	      mnt_fs_get_root(fs));
+
+	mnt_free_iter(itr);
+	return rc;
+}
+
+/* checks if all fs in @tb are from kernel */
+static int tab_is_kernel(struct libmnt_table *tb)
+{
+	struct libmnt_fs *fs = NULL;
+	struct libmnt_iter *itr;
+
+	itr = mnt_new_iter(MNT_ITER_BACKWARD);
+	if (!itr)
+		return 0;
+
+	while (mnt_table_next_fs(tb, itr, &fs) == 0) {
+		if (!mnt_fs_is_kernel(fs)) {
+			mnt_free_iter(itr);
+			return 0;
+		}
+	}
+
+	mnt_free_iter(itr);
+	return 1;
+}
+
+/* filter function for libmount (mnt_table_find_next_fs()) */
+static int match_func(struct libmnt_fs *fs,
+		      void *data __attribute__ ((__unused__)))
+{
+	int rc = flags & FL_INVERT ? 1 : 0;
+	const char *m;
+	void *md;
+
+	m = get_match(COL_FSTYPE);
+	if (m && !mnt_fs_match_fstype(fs, m))
+		return rc;
+
+	m = get_match(COL_OPTIONS);
+	if (m && !mnt_fs_match_options(fs, m))
+		return rc;
+
+	md = get_match_data(COL_MAJMIN);
+	if (md && mnt_fs_get_devno(fs) != *((dev_t *) md))
+		return rc;
+
+	m = get_match(COL_TARGET);
+	if (m && !mnt_fs_match_target(fs, m, cache))
+		return rc;
+
+	m = get_match(COL_SOURCE);
+	if (m && !mnt_fs_match_source(fs, m, cache))
+		return rc;
+
+	if ((flags & FL_DF) && !(flags & FL_ALL)) {
+		const char *type = mnt_fs_get_fstype(fs);
+
+		if (type && strstr(type, "tmpfs"))	/* tmpfs is wanted */
+			return !rc;
+
+		if (mnt_fs_is_pseudofs(fs))
+			return rc;
+	}
+
+	if ((flags & FL_REAL) && mnt_fs_is_pseudofs(fs))
+	    return rc;
+
+	if ((flags & FL_PSEUDO) && !mnt_fs_is_pseudofs(fs))
+	    return rc;
+
+	if ((flags & FL_SHADOWED)) {
+		struct libmnt_table *tb = NULL;
+
+		mnt_fs_get_table(fs, &tb);
+		if (tb && mnt_table_over_fs(tb, fs, NULL) != 0)
+			return rc;
+	}
+
+	return !rc;
+}
+
+/* iterate over filesystems in @tb */
+struct libmnt_fs *get_next_fs(struct libmnt_table *tb,
+				     struct libmnt_iter *itr)
+{
+	struct libmnt_fs *fs = NULL;
+
+	if (is_listall_mode()) {
+		/*
+		 * Print whole file
+		 */
+		if (mnt_table_next_fs(tb, itr, &fs) != 0)
+			return NULL;
+
+	} else if (is_mount_compatible_mode()) {
+		/*
+		 * Look up for FS in the same way how mount(8) searches in fstab
+		 *
+		 *   findmnt -f <spec>
+		 */
+		fs = mnt_table_find_source(tb, get_match(COL_SOURCE),
+					mnt_iter_get_direction(itr));
+
+		if (!fs && !(flags & FL_NOSWAPMATCH))
+			fs = mnt_table_find_target(tb, get_match(COL_SOURCE),
+					mnt_iter_get_direction(itr));
+	} else {
+		/*
+		 * Look up for all matching entries
+		 *
+		 *    findmnt [-l] <source> <target> [-O <options>] [-t <types>]
+		 *    findmnt [-l] <spec> [-O <options>] [-t <types>]
+		 */
+again:
+		if (mnt_table_find_next_fs(tb, itr, match_func,  NULL, &fs) != 0)
+			fs = NULL;
+
+		if (!fs &&
+		    !(flags & FL_NOSWAPMATCH) &&
+		    !get_match(COL_TARGET) && get_match(COL_SOURCE)) {
+
+			/* swap 'spec' and target. */
+			set_match(COL_TARGET, get_match(COL_SOURCE));
+			set_match(COL_SOURCE, NULL);
+			mnt_reset_iter(itr, -1);
+
+			goto again;
+		}
+	}
+
+	return fs;
+}
+
+/*
+ * Filter out unwanted lines for --list output or top level lines for
+ * --submounts tree output.
+ */
+static int add_matching_lines(struct libmnt_table *tb,
+			      struct libscols_table *table, int direction)
+{
+	struct libmnt_iter *itr;
+	struct libmnt_fs *fs;
+	int nlines = 0, rc = -1;
+
+	itr = mnt_new_iter(direction);
+	if (!itr) {
+		warn(_("failed to initialize libmount iterator"));
+		goto done;
+	}
+
+	while((fs = get_next_fs(tb, itr))) {
+		if ((flags & FL_TREE) || (flags & FL_SUBMOUNTS))
+			rc = create_treenode(table, tb, fs, NULL);
+		else
+			rc = !add_line(table, fs, NULL);
+		if (rc)
+			goto done;
+		nlines++;
+		if (flags & FL_FIRSTONLY)
+			break;
+		flags |= FL_NOSWAPMATCH;
+	}
+
+	if (nlines)
+		rc = 0;
+done:
+	mnt_free_iter(itr);
+	return rc;
+}
+
+static int poll_match(struct libmnt_fs *fs)
+{
+	int rc = match_func(fs, NULL);
+
+	if (rc == 0 && !(flags & FL_NOSWAPMATCH) &&
+	    get_match(COL_SOURCE) && !get_match(COL_TARGET)) {
+		/*
+		 * findmnt --poll /foo
+		 * The '/foo' maybe source as well as target.
+		 */
+		const char *str = get_match(COL_SOURCE);
+
+		set_match(COL_TARGET, str);	/* swap */
+		set_match(COL_SOURCE, NULL);
+
+		rc = match_func(fs, NULL);
+
+		set_match(COL_TARGET, NULL);	/* restore */
+		set_match(COL_SOURCE, str);
+
+	}
+	return rc;
+}
+
+static int poll_table(struct libmnt_table *tb, const char *tabfile,
+		  int timeout, struct libscols_table *table, int direction)
+{
+	FILE *f = NULL;
+	int rc = -1;
+	struct libmnt_iter *itr = NULL;
+	struct libmnt_table *tb_new;
+	struct libmnt_tabdiff *diff = NULL;
+	struct pollfd fds[1];
+
+	tb_new = mnt_new_table();
+	if (!tb_new) {
+		warn(_("failed to initialize libmount table"));
+		goto done;
+	}
+
+	itr = mnt_new_iter(direction);
+	if (!itr) {
+		warn(_("failed to initialize libmount iterator"));
+		goto done;
+	}
+
+	diff = mnt_new_tabdiff();
+	if (!diff) {
+		warn(_("failed to initialize libmount tabdiff"));
+		goto done;
+	}
+
+	/* cache is unnecessary to detect changes */
+	mnt_table_set_cache(tb, NULL);
+	mnt_table_set_cache(tb_new, NULL);
+
+	f = fopen(tabfile, "r");
+	if (!f) {
+		warn(_("cannot open %s"), tabfile);
+		goto done;
+	}
+
+	mnt_table_set_parser_errcb(tb_new, parser_errcb);
+
+	fds[0].fd = fileno(f);
+	fds[0].events = POLLPRI;
+
+	while (1) {
+		struct libmnt_table *tmp;
+		struct libmnt_fs *old, *new;
+		int change, count;
+
+		count = poll(fds, 1, timeout);
+		if (count == 0)
+			break;	/* timeout */
+		if (count < 0) {
+			warn(_("poll() failed"));
+			goto done;
+		}
+
+		rewind(f);
+		rc = mnt_table_parse_stream(tb_new, f, tabfile);
+		if (!rc)
+			rc = mnt_diff_tables(diff, tb, tb_new);
+		if (rc < 0)
+			goto done;
+
+		count = 0;
+		mnt_reset_iter(itr, direction);
+		while(mnt_tabdiff_next_change(
+				diff, itr, &old, &new, &change) == 0) {
+
+			if (!has_poll_action(change))
+				continue;
+			if (!poll_match(new ? new : old))
+				continue;
+			count++;
+			rc = !add_tabdiff_line(table, new, old, change);
+			if (rc)
+				goto done;
+			if (flags & FL_FIRSTONLY)
+				break;
+		}
+
+		if (count) {
+			rc = scols_table_print_range(table, NULL, NULL);
+			if (rc == 0)
+				fputc('\n', scols_table_get_stream(table));
+			fflush(stdout);
+			if (rc)
+				goto done;
+		}
+
+		/* swap tables */
+		tmp = tb;
+		tb = tb_new;
+		tb_new = tmp;
+
+		/* remove already printed lines to reduce memory usage */
+		scols_table_remove_lines(table);
+		mnt_reset_table(tb_new);
+
+		if (count && (flags & FL_FIRSTONLY))
+			break;
+	}
+
+	rc = 0;
+done:
+	mnt_unref_table(tb_new);
+	mnt_free_tabdiff(diff);
+	mnt_free_iter(itr);
+	if (f)
+		fclose(f);
+	return rc;
+}
+
+static int uniq_fs_target_cmp(
+		struct libmnt_table *tb __attribute__((__unused__)),
+		struct libmnt_fs *a,
+		struct libmnt_fs *b)
+{
+	return !mnt_fs_match_target(a, mnt_fs_get_target(b), cache);
+}
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	FILE *out = stdout;
+	size_t i;
+
+	fputs(USAGE_HEADER, out);
+	fprintf(out, _(
+	" %1$s [options]\n"
+	" %1$s [options] <device> | <mountpoint>\n"
+	" %1$s [options] <device> <mountpoint>\n"
+	" %1$s [options] [--source <device>] [--target <path> | --mountpoint <dir>]\n"),
+		program_invocation_short_name);
+
+	fputs(USAGE_SEPARATOR, out);
+	fputs(_("Find a (mounted) filesystem.\n"), out);
+
+	fputs(USAGE_OPTIONS, out);
+	fputs(_(" -s, --fstab            search in static table of filesystems\n"), out);
+	fputs(_(" -m, --mtab             search in table of mounted filesystems\n"
+		"                          (includes user space mount options)\n"), out);
+	fputs(_(" -k, --kernel           search in kernel table of mounted\n"
+		"                          filesystems (default)\n"), out);
+	fputc('\n', out);
+	fputs(_(" -p, --poll[=<list>]    monitor changes in table of mounted filesystems\n"), out);
+	fputs(_(" -w, --timeout <num>    upper limit in milliseconds that --poll will block\n"), out);
+	fputc('\n', out);
+
+	fputs(_(" -A, --all              disable all built-in filters, print all filesystems\n"), out);
+	fputs(_(" -a, --ascii            use ASCII chars for tree formatting\n"), out);
+	fputs(_(" -b, --bytes            print sizes in bytes rather than in human readable format\n"), out);
+	fputs(_(" -C, --nocanonicalize   don't canonicalize when comparing paths\n"), out);
+	fputs(_(" -c, --canonicalize     canonicalize printed paths\n"), out);
+	fputs(_(" -D, --df               imitate the output of df(1)\n"), out);
+	fputs(_(" -d, --direction <word> direction of search, 'forward' or 'backward'\n"), out);
+	fputs(_(" -e, --evaluate         convert tags (LABEL,UUID,PARTUUID,PARTLABEL) \n"
+	        "                          to device names\n"), out);
+	fputs(_(" -F, --tab-file <path>  alternative file for -s, -m or -k options\n"), out);
+	fputs(_(" -f, --first-only       print the first found filesystem only\n"), out);
+	fputs(_(" -i, --invert           invert the sense of matching\n"), out);
+	fputs(_(" -J, --json             use JSON output format\n"), out);
+	fputs(_(" -l, --list             use list format output\n"), out);
+	fputs(_(" -N, --task <tid>       use alternative namespace (/proc/<tid>/mountinfo file)\n"), out);
+	fputs(_(" -n, --noheadings       don't print column headings\n"), out);
+	fputs(_(" -O, --options <list>   limit the set of filesystems by mount options\n"), out);
+	fputs(_(" -o, --output <list>    the output columns to be shown\n"), out);
+	fputs(_("     --output-all       output all available columns\n"), out);
+	fputs(_(" -P, --pairs            use key=\"value\" output format\n"), out);
+	fputs(_("     --pseudo           print only pseudo-filesystems\n"), out);
+	fputs(_("     --shadowed         print only filesystems over-mounted by another filesystem\n"), out);
+	fputs(_(" -R, --submounts        print all submounts for the matching filesystems\n"), out);
+	fputs(_(" -r, --raw              use raw output format\n"), out);
+	fputs(_("     --real             print only real filesystems\n"), out);
+	fputs(_(" -S, --source <string>  the device to mount (by name, maj:min, \n"
+	        "                          LABEL=, UUID=, PARTUUID=, PARTLABEL=)\n"), out);
+	fputs(_(" -T, --target <path>    the path to the filesystem to use\n"), out);
+	fputs(_("     --tree             enable tree format output if possible\n"), out);
+	fputs(_(" -M, --mountpoint <dir> the mountpoint directory\n"), out);
+	fputs(_(" -t, --types <list>     limit the set of filesystems by FS types\n"), out);
+	fputs(_(" -U, --uniq             ignore filesystems with duplicate target\n"), out);
+	fputs(_(" -u, --notruncate       don't truncate text in columns\n"), out);
+	fputs(_(" -v, --nofsroot         don't print [/dir] for bind or btrfs mounts\n"), out);
+	fputs(_(" -y, --shell            use column names to be usable as shell variable identifiers\n"), out);
+
+	fputc('\n', out);
+	fputs(_(" -x, --verify           verify mount table content (default is fstab)\n"), out);
+	fputs(_("     --verbose          print more details\n"), out);
+	fputs(_("     --vfs-all          print all VFS options\n"), out);
+
+	fputs(USAGE_SEPARATOR, out);
+	printf(USAGE_HELP_OPTIONS(24));
+
+	fputs(USAGE_COLUMNS, out);
+	for (i = 0; i < ARRAY_SIZE(infos); i++)
+		fprintf(out, " %11s  %s\n", infos[i].name, _(infos[i].help));
+
+	printf(USAGE_MAN_TAIL("findmnt(8)"));
+
+	exit(EXIT_SUCCESS);
+}
+
+int main(int argc, char *argv[])
+{
+	struct libmnt_table *tb = NULL;
+	char **tabfiles = NULL;
+	int direction = MNT_ITER_FORWARD;
+	int verify = 0;
+	int c, rc = -1, timeout = -1;
+	int ntabfiles = 0, tabtype = 0;
+	char *outarg = NULL;
+	size_t i;
+	int force_tree = 0, istree = 0;
+
+	struct libscols_table *table = NULL;
+
+	enum {
+		FINDMNT_OPT_VERBOSE = CHAR_MAX + 1,
+		FINDMNT_OPT_TREE,
+		FINDMNT_OPT_OUTPUT_ALL,
+		FINDMNT_OPT_PSEUDO,
+		FINDMNT_OPT_REAL,
+		FINDMNT_OPT_VFS_ALL,
+		FINDMNT_OPT_SHADOWED
+	};
+
+	static const struct option longopts[] = {
+		{ "all",	    no_argument,       NULL, 'A'		 },
+		{ "ascii",	    no_argument,       NULL, 'a'		 },
+		{ "bytes",	    no_argument,       NULL, 'b'		 },
+		{ "canonicalize",   no_argument,       NULL, 'c'		 },
+		{ "direction",	    required_argument, NULL, 'd'		 },
+		{ "df",		    no_argument,       NULL, 'D'		 },
+		{ "evaluate",	    no_argument,       NULL, 'e'		 },
+		{ "first-only",	    no_argument,       NULL, 'f'		 },
+		{ "fstab",	    no_argument,       NULL, 's'		 },
+		{ "help",	    no_argument,       NULL, 'h'		 },
+		{ "invert",	    no_argument,       NULL, 'i'		 },
+		{ "json",	    no_argument,       NULL, 'J'		 },
+		{ "kernel",	    no_argument,       NULL, 'k'		 },
+		{ "list",	    no_argument,       NULL, 'l'		 },
+		{ "mountpoint",	    required_argument, NULL, 'M'		 },
+		{ "mtab",	    no_argument,       NULL, 'm'		 },
+		{ "noheadings",	    no_argument,       NULL, 'n'		 },
+		{ "notruncate",	    no_argument,       NULL, 'u'		 },
+		{ "options",	    required_argument, NULL, 'O'		 },
+		{ "output",	    required_argument, NULL, 'o'		 },
+		{ "output-all",	    no_argument,       NULL, FINDMNT_OPT_OUTPUT_ALL },
+		{ "poll",	    optional_argument, NULL, 'p'		 },
+		{ "pairs",	    no_argument,       NULL, 'P'		 },
+		{ "raw",	    no_argument,       NULL, 'r'		 },
+		{ "types",	    required_argument, NULL, 't'		 },
+		{ "nocanonicalize", no_argument,       NULL, 'C'		 },
+		{ "nofsroot",	    no_argument,       NULL, 'v'		 },
+		{ "submounts",	    no_argument,       NULL, 'R'		 },
+		{ "source",	    required_argument, NULL, 'S'		 },
+		{ "tab-file",	    required_argument, NULL, 'F'		 },
+		{ "task",	    required_argument, NULL, 'N'		 },
+		{ "target",	    required_argument, NULL, 'T'		 },
+		{ "timeout",	    required_argument, NULL, 'w'		 },
+		{ "uniq",	    no_argument,       NULL, 'U'		 },
+		{ "verify",	    no_argument,       NULL, 'x'		 },
+		{ "version",	    no_argument,       NULL, 'V'		 },
+		{ "shell",          no_argument,       NULL, 'y'                 },
+		{ "verbose",	    no_argument,       NULL, FINDMNT_OPT_VERBOSE },
+		{ "tree",	    no_argument,       NULL, FINDMNT_OPT_TREE	 },
+		{ "real",	    no_argument,       NULL, FINDMNT_OPT_REAL	 },
+		{ "pseudo",	    no_argument,       NULL, FINDMNT_OPT_PSEUDO	 },
+		{ "vfs-all",	    no_argument,       NULL, FINDMNT_OPT_VFS_ALL },
+		{ "shadowed",       no_argument,       NULL, FINDMNT_OPT_SHADOWED },
+		{ NULL, 0, NULL, 0 }
+	};
+
+	static const ul_excl_t excl[] = {	/* rows and cols in ASCII order */
+		{ 'C', 'c'},			/* [no]canonicalize */
+		{ 'C', 'e' },			/* nocanonicalize, evaluate */
+		{ 'J', 'P', 'r','x' },		/* json,pairs,raw,verify */
+		{ 'M', 'T' },			/* mountpoint, target */
+		{ 'N','k','m','s' },		/* task,kernel,mtab,fstab */
+		{ 'P','l','r','x' },		/* pairs,list,raw,verify */
+		{ 'p','x' },			/* poll,verify */
+		{ 'm','p','s' },		/* mtab,poll,fstab */
+		{ FINDMNT_OPT_PSEUDO, FINDMNT_OPT_REAL },
+		{ 0 }
+	};
+	int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+	/* default output format */
+	flags |= FL_TREE;
+
+	while ((c = getopt_long(argc, argv,
+				"AabCcDd:ehiJfF:o:O:p::PklmM:nN:rst:uvRS:T:Uw:Vxy",
+				longopts, NULL)) != -1) {
+
+		err_exclusive_options(c, longopts, excl, excl_st);
+
+		switch(c) {
+		case 'A':
+			flags |= FL_ALL;
+			break;
+		case 'a':
+			flags |= FL_ASCII;
+			break;
+		case 'b':
+			flags |= FL_BYTES;
+			break;
+		case 'C':
+			flags |= FL_NOCACHE;
+			break;
+		case 'c':
+			flags |= FL_CANONICALIZE;
+			break;
+		case 'D':
+			flags &= ~FL_TREE;
+			flags |= FL_DF;
+			break;
+		case 'd':
+			if (!strcmp(optarg, "forward"))
+				direction = MNT_ITER_FORWARD;
+			else if (!strcmp(optarg, "backward"))
+				direction = MNT_ITER_BACKWARD;
+			else
+				errx(EXIT_FAILURE,
+					_("unknown direction '%s'"), optarg);
+			break;
+		case 'e':
+			flags |= FL_EVALUATE;
+			break;
+		case 'i':
+			flags |= FL_INVERT;
+			break;
+		case 'J':
+			flags |= FL_JSON;
+			break;
+		case 'f':
+			flags |= FL_FIRSTONLY;
+			break;
+		case 'F':
+			tabfiles = append_tabfile(tabfiles, &ntabfiles, optarg);
+			break;
+		case 'u':
+			disable_columns_truncate();
+			break;
+		case 'o':
+			outarg = optarg;
+			break;
+		case FINDMNT_OPT_OUTPUT_ALL:
+			ncolumns = 0;
+			for (i = 0; i < ARRAY_SIZE(infos); i++) {
+				if (is_tabdiff_column(i))
+					continue;
+				columns[ncolumns++] = i;
+			}
+			break;
+		case 'O':
+			set_match(COL_OPTIONS, optarg);
+			break;
+		case 'p':
+			if (optarg) {
+				nactions = string_to_idarray(optarg,
+						actions, ARRAY_SIZE(actions),
+						poll_action_name_to_id);
+				if (nactions < 0)
+					exit(EXIT_FAILURE);
+			}
+			flags |= FL_POLL;
+			flags &= ~FL_TREE;
+			break;
+		case 'P':
+			flags |= FL_EXPORT;
+			flags &= ~FL_TREE;
+			break;
+		case 'm':		/* mtab */
+			tabtype = TABTYPE_MTAB;
+			flags &= ~FL_TREE;
+			break;
+		case 's':		/* fstab */
+			tabtype = TABTYPE_FSTAB;
+			flags &= ~FL_TREE;
+			break;
+		case 'k':		/* kernel (mountinfo) */
+			tabtype = TABTYPE_KERNEL;
+			break;
+		case 't':
+			set_match(COL_FSTYPE, optarg);
+			break;
+		case 'r':
+			flags &= ~FL_TREE;	/* disable the default */
+			flags |= FL_RAW;	/* enable raw */
+			break;
+		case 'l':
+			flags &= ~FL_TREE;	/* disable the default */
+			break;
+		case 'n':
+			flags |= FL_NOHEADINGS;
+			break;
+		case 'N':
+			tabtype = TABTYPE_KERNEL;
+			tabfiles = append_pid_tabfile(tabfiles, &ntabfiles,
+					strtou32_or_err(optarg,
+						_("invalid TID argument")));
+			break;
+		case 'v':
+			flags |= FL_NOFSROOT;
+			break;
+		case 'R':
+			flags |= FL_SUBMOUNTS;
+			break;
+		case 'S':
+			set_source_match(optarg);
+			flags |= FL_NOSWAPMATCH;
+			break;
+		case 'M':
+			flags |= FL_STRICTTARGET;
+			/* fallthrough */
+		case 'T':
+			set_match(COL_TARGET, optarg);
+			flags |= FL_NOSWAPMATCH;
+			break;
+		case 'U':
+			flags |= FL_UNIQ;
+			break;
+		case 'w':
+			timeout = strtos32_or_err(optarg, _("invalid timeout argument"));
+			break;
+		case 'x':
+			verify = 1;
+			break;
+		case 'y':
+			flags |= FL_SHELLVAR;
+			break;
+		case FINDMNT_OPT_VERBOSE:
+			flags |= FL_VERBOSE;
+			break;
+		case FINDMNT_OPT_TREE:
+			force_tree = 1;
+			break;
+		case FINDMNT_OPT_PSEUDO:
+			flags |= FL_PSEUDO;
+			break;
+		case FINDMNT_OPT_REAL:
+			flags |= FL_REAL;
+			break;
+		case FINDMNT_OPT_VFS_ALL:
+			flags |= FL_VFS_ALL;
+			break;
+		case FINDMNT_OPT_SHADOWED:
+			flags |= FL_SHADOWED;
+			break;
+		case 'h':
+			usage();
+		case 'V':
+			print_version(EXIT_SUCCESS);
+		default:
+			errtryhelp(EXIT_FAILURE);
+		}
+	}
+
+	if (!ncolumns && (flags & FL_DF)) {
+		add_column(columns, ncolumns++, COL_SOURCE);
+		add_column(columns, ncolumns++, COL_FSTYPE);
+		add_column(columns, ncolumns++, COL_SIZE);
+		add_column(columns, ncolumns++, COL_USED);
+		add_column(columns, ncolumns++, COL_AVAIL);
+		add_column(columns, ncolumns++, COL_USEPERC);
+		add_column(columns, ncolumns++, COL_TARGET);
+	}
+
+	/* default columns */
+	if (!ncolumns) {
+		if (flags & FL_POLL)
+			add_column(columns, ncolumns++, COL_ACTION);
+
+		add_column(columns, ncolumns++, COL_TARGET);
+		add_column(columns, ncolumns++, COL_SOURCE);
+		add_column(columns, ncolumns++, COL_FSTYPE);
+		add_column(columns, ncolumns++, COL_OPTIONS);
+	}
+
+	if (outarg && string_add_to_idarray(outarg, columns, ARRAY_SIZE(columns),
+					 &ncolumns, column_name_to_id) < 0)
+		return EXIT_FAILURE;
+
+	if (!tabtype)
+		tabtype = verify ? TABTYPE_FSTAB : TABTYPE_KERNEL;
+
+	if ((flags & FL_POLL) && ntabfiles > 1)
+		errx(EXIT_FAILURE, _("--poll accepts only one file, but more specified by --tab-file"));
+
+	if (optind < argc && (get_match(COL_SOURCE) || get_match(COL_TARGET)))
+		errx(EXIT_FAILURE, _(
+			"options --target and --source can't be used together "
+			"with command line element that is not an option"));
+
+	if (optind < argc)
+		set_source_match(argv[optind++]);	/* dev/tag/mountpoint/maj:min */
+	if (optind < argc)
+		set_match(COL_TARGET, argv[optind++]);	/* mountpoint */
+
+	if ((flags & FL_SUBMOUNTS) && is_listall_mode())
+		/* don't care about submounts if list all mounts */
+		flags &= ~FL_SUBMOUNTS;
+
+	if (!(flags & FL_SUBMOUNTS) && ((flags & FL_FIRSTONLY)
+	    || get_match(COL_TARGET)
+	    || get_match(COL_SOURCE)
+	    || get_match(COL_MAJMIN)))
+		flags &= ~FL_TREE;
+
+	if (!(flags & FL_NOSWAPMATCH) &&
+	    !get_match(COL_TARGET) && get_match(COL_SOURCE)) {
+		/*
+		 * Check if we can swap source and target, it's
+		 * not possible if the source is LABEL=/UUID=
+		 */
+		const char *x = get_match(COL_SOURCE);
+
+		if (!strncmp(x, "LABEL=", 6) || !strncmp(x, "UUID=", 5) ||
+		    !strncmp(x, "PARTLABEL=", 10) || !strncmp(x, "PARTUUID=", 9))
+			flags |= FL_NOSWAPMATCH;
+	}
+
+	/*
+	 * initialize libmount
+	 */
+	mnt_init_debug(0);
+
+	tb = parse_tabfiles(tabfiles, ntabfiles, tabtype);
+	if (!tb)
+		goto leave;
+
+	if (tabtype == TABTYPE_MTAB && tab_is_kernel(tb))
+		tabtype = TABTYPE_KERNEL;
+
+	istree = tab_is_tree(tb);
+	if (istree && force_tree)
+		flags |= FL_TREE;
+
+	if ((flags & FL_TREE) && (ntabfiles > 1 || !istree))
+		flags &= ~FL_TREE;
+
+	if (!(flags & FL_NOCACHE)) {
+		cache = mnt_new_cache();
+		if (!cache) {
+			warn(_("failed to initialize libmount cache"));
+			goto leave;
+		}
+		mnt_table_set_cache(tb, cache);
+
+		if (tabtype != TABTYPE_KERNEL)
+			cache_set_targets(cache);
+	}
+
+	if (flags & FL_UNIQ)
+		mnt_table_uniq_fs(tb, MNT_UNIQ_KEEPTREE, uniq_fs_target_cmp);
+
+	if (verify) {
+		rc = verify_table(tb);
+		goto leave;
+	}
+
+	/*
+	 * initialize libsmartcols
+	 */
+	scols_init_debug(0);
+	table = scols_new_table();
+	if (!table) {
+		warn(_("failed to allocate output table"));
+		goto leave;
+	}
+	scols_table_enable_raw(table,        !!(flags & FL_RAW));
+	scols_table_enable_export(table,     !!(flags & FL_EXPORT));
+	scols_table_enable_shellvar(table,   !!(flags & FL_SHELLVAR));
+	scols_table_enable_json(table,       !!(flags & FL_JSON));
+	scols_table_enable_ascii(table,      !!(flags & FL_ASCII));
+	scols_table_enable_noheadings(table, !!(flags & FL_NOHEADINGS));
+
+	if (flags & FL_JSON)
+		scols_table_set_name(table, "filesystems");
+
+	for (i = 0; i < ncolumns; i++) {
+		struct libscols_column *cl;
+		int fl = get_column_flags(i);
+		int id = get_column_id(i);
+
+		if (!(flags & FL_TREE))
+			fl &= ~SCOLS_FL_TREE;
+
+		if (!(flags & FL_POLL) && is_tabdiff_column(id)) {
+			warnx(_("%s column is requested, but --poll "
+			       "is not enabled"), get_column_name(i));
+			goto leave;
+		}
+		cl = scols_table_new_column(table, get_column_name(i),
+					get_column_whint(i), fl);
+		if (!cl)	{
+			warn(_("failed to allocate output column"));
+			goto leave;
+		}
+		/* multi-line cells (now used for SOURCES) */
+		if (fl & SCOLS_FL_WRAP) {
+			scols_column_set_wrapfunc(cl,
+						scols_wrapnl_chunksize,
+						scols_wrapnl_nextchunk,
+						NULL);
+			scols_column_set_safechars(cl, "\n");
+		}
+		if (flags & FL_JSON) {
+			switch (id) {
+			case COL_SIZE:
+			case COL_AVAIL:
+			case COL_USED:
+				if (!(flags & FL_BYTES))
+					break;
+				/* fallthrough */
+			case COL_ID:
+			case COL_PARENT:
+			case COL_FREQ:
+			case COL_PASSNO:
+			case COL_TID:
+				scols_column_set_json_type(cl, SCOLS_JSON_NUMBER);
+				break;
+			default:
+				if (fl & SCOLS_FL_WRAP)
+					scols_column_set_json_type(cl, SCOLS_JSON_ARRAY_STRING);
+				else
+					scols_column_set_json_type(cl, SCOLS_JSON_STRING);
+				break;
+			}
+		}
+	}
+
+	/*
+	 * Fill in data to the output table
+	 */
+	if (flags & FL_POLL) {
+		/* poll mode (accept the first tabfile only) */
+		rc = poll_table(tb, tabfiles ? *tabfiles : _PATH_PROC_MOUNTINFO, timeout, table, direction);
+
+	} else if ((flags & FL_TREE) && !(flags & FL_SUBMOUNTS)) {
+		/* whole tree */
+		rc = create_treenode(table, tb, NULL, NULL);
+	} else {
+		/* whole list of sub-tree */
+		rc = add_matching_lines(tb, table, direction);
+
+		if (rc != 0
+		    && tabtype == TABTYPE_KERNEL
+		    && (flags & FL_NOSWAPMATCH)
+		    && !(flags & FL_STRICTTARGET)
+		    && get_match(COL_TARGET)) {
+			/*
+			 * Found nothing, maybe the --target is regular file,
+			 * try it again with extra functionality for target
+			 * match
+			 */
+			enable_extra_target_match(tb);
+			rc = add_matching_lines(tb, table, direction);
+		}
+	}
+
+	/*
+	 * Print the output table for non-poll modes
+	 */
+	if (!rc && !(flags & FL_POLL))
+		scols_print_table(table);
+leave:
+	scols_unref_table(table);
+
+	mnt_unref_table(tb);
+	mnt_unref_cache(cache);
+
+	free(tabfiles);
+#ifdef HAVE_LIBUDEV
+	udev_unref(udev);
+#endif
+	return rc ? EXIT_FAILURE : EXIT_SUCCESS;
+}