4 * Copyright (C) 2010-2015 Red Hat, Inc. All rights reserved.
5 * Written by Karel Zak <kzak@redhat.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it would be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
28 #ifdef HAVE_SYS_IOCTL_H
29 # include <sys/ioctl.h>
33 #include <sys/statvfs.h>
34 #include <sys/types.h>
39 #include <libsmartcols.h>
41 #include "pathnames.h"
43 #include "closestream.h"
89 const char *name
; /* header */
90 double whint
; /* width hint (N < 1 is in percent of termwidth) */
91 int flags
; /* libsmartcols flags */
92 const char *help
; /* column description */
93 const char *match
; /* pattern for match_func() */
94 void *match_data
; /* match specific data */
97 /* columns descriptions (don't use const, this is writable) */
98 static struct colinfo infos
[] = {
99 [COL_SOURCE
] = { "SOURCE", 0.25, SCOLS_FL_NOEXTREMES
, N_("source device") },
100 [COL_TARGET
] = { "TARGET", 0.30, SCOLS_FL_TREE
| SCOLS_FL_NOEXTREMES
, N_("mountpoint") },
101 [COL_FSTYPE
] = { "FSTYPE", 0.10, SCOLS_FL_TRUNC
, N_("filesystem type") },
102 [COL_OPTIONS
] = { "OPTIONS", 0.10, SCOLS_FL_TRUNC
, N_("all mount options") },
103 [COL_VFS_OPTIONS
] = { "VFS-OPTIONS", 0.20, SCOLS_FL_TRUNC
, N_("VFS specific mount options") },
104 [COL_FS_OPTIONS
] = { "FS-OPTIONS", 0.10, SCOLS_FL_TRUNC
, N_("FS specific mount options") },
105 [COL_LABEL
] = { "LABEL", 0.10, 0, N_("filesystem label") },
106 [COL_UUID
] = { "UUID", 36, 0, N_("filesystem UUID") },
107 [COL_PARTLABEL
] = { "PARTLABEL", 0.10, 0, N_("partition label") },
108 [COL_PARTUUID
] = { "PARTUUID", 36, 0, N_("partition UUID") },
109 [COL_MAJMIN
] = { "MAJ:MIN", 6, 0, N_("major:minor device number") },
110 [COL_ACTION
] = { "ACTION", 10, SCOLS_FL_STRICTWIDTH
, N_("action detected by --poll") },
111 [COL_OLD_OPTIONS
] = { "OLD-OPTIONS", 0.10, SCOLS_FL_TRUNC
, N_("old mount options saved by --poll") },
112 [COL_OLD_TARGET
] = { "OLD-TARGET", 0.30, 0, N_("old mountpoint saved by --poll") },
113 [COL_SIZE
] = { "SIZE", 5, SCOLS_FL_RIGHT
, N_("filesystem size") },
114 [COL_AVAIL
] = { "AVAIL", 5, SCOLS_FL_RIGHT
, N_("filesystem size available") },
115 [COL_USED
] = { "USED", 5, SCOLS_FL_RIGHT
, N_("filesystem size used") },
116 [COL_USEPERC
] = { "USE%", 3, SCOLS_FL_RIGHT
, N_("filesystem use percentage") },
117 [COL_FSROOT
] = { "FSROOT", 0.25, SCOLS_FL_NOEXTREMES
, N_("filesystem root") },
118 [COL_TID
] = { "TID", 4, SCOLS_FL_RIGHT
, N_("task ID") },
119 [COL_ID
] = { "ID", 2, SCOLS_FL_RIGHT
, N_("mount ID") },
120 [COL_OPT_FIELDS
] = { "OPT-FIELDS", 0.10, SCOLS_FL_TRUNC
, N_("optional mount fields") },
121 [COL_PROPAGATION
] = { "PROPAGATION", 0.10, 0, N_("VFS propagation flags") },
122 [COL_FREQ
] = { "FREQ", 1, SCOLS_FL_RIGHT
, N_("dump(8) period in days [fstab only]") },
123 [COL_PASSNO
] = { "PASSNO", 1, SCOLS_FL_RIGHT
, N_("pass number on parallel fsck(8) [fstab only]") }
126 /* columns[] array specifies all currently wanted output column. The columns
127 * are defined by infos[] array and you can specify (on command line) each
128 * column twice. That's enough, dynamically allocated array of the columns is
129 * unnecessary overkill and over-engineering in this case */
130 static int columns
[ARRAY_SIZE(infos
) * 2];
131 static size_t ncolumns
;
133 static inline size_t err_columns_index(size_t arysz
, size_t idx
)
136 errx(EXIT_FAILURE
, _("too many columns specified, "
137 "the limit is %zu columns"),
142 #define add_column(ary, n, id) \
143 ((ary)[ err_columns_index(ARRAY_SIZE(ary), (n)) ] = (id))
145 /* poll actions (parsed --poll=<list> */
146 #define FINDMNT_NACTIONS 4 /* mount, umount, move, remount */
147 static int actions
[FINDMNT_NACTIONS
];
150 /* global (accessed from findmnt-verify.c too) */
153 struct libmnt_cache
*cache
;
160 static int match_func(struct libmnt_fs
*fs
, void *data
__attribute__ ((__unused__
)));
163 static int get_column_id(int num
)
166 assert((size_t) num
< ncolumns
);
167 assert((size_t) columns
[num
] < ARRAY_SIZE(infos
));
171 static struct colinfo
*get_column_info(int num
)
173 return &infos
[ get_column_id(num
) ];
176 static const char *column_id_to_name(int id
)
178 assert((size_t) id
< ARRAY_SIZE(infos
));
179 return infos
[id
].name
;
182 static const char *get_column_name(int num
)
184 return get_column_info(num
)->name
;
187 static float get_column_whint(int num
)
189 return get_column_info(num
)->whint
;
192 static int get_column_flags(int num
)
194 return get_column_info(num
)->flags
;
197 static const char *get_match(int id
)
199 assert((size_t) id
< ARRAY_SIZE(infos
));
200 return infos
[id
].match
;
203 static void *get_match_data(int id
)
205 assert((size_t) id
< ARRAY_SIZE(infos
));
206 return infos
[id
].match_data
;
209 static void set_match(int id
, const char *match
)
211 assert((size_t) id
< ARRAY_SIZE(infos
));
212 infos
[id
].match
= match
;
215 static void set_match_data(int id
, void *data
)
217 assert((size_t) id
< ARRAY_SIZE(infos
));
218 infos
[id
].match_data
= data
;
222 * source match means COL_SOURCE *or* COL_MAJMIN, depends on
225 static void set_source_match(const char *data
)
229 if (sscanf(data
, "%d:%d", &maj
, &min
) == 2) {
230 dev_t
*devno
= xmalloc(sizeof(dev_t
));
232 *devno
= makedev(maj
, min
);
233 set_match(COL_MAJMIN
, data
);
234 set_match_data(COL_MAJMIN
, (void *) devno
);
235 flags
|= FL_NOSWAPMATCH
;
237 set_match(COL_SOURCE
, data
);
241 * Extra functionality for --target <path>. The function mnt_table_find_mountpoint()
242 * also checks parents (path elements in reverse order) to get mountpoint.
244 * @tb has to be from kernel (so no fstab or so)!
246 static void enable_extra_target_match(struct libmnt_table
*tb
)
249 const char *tgt
= NULL
, *mnt
= NULL
;
250 struct libmnt_fs
*fs
;
253 * Check if match pattern is mountpoint, if not use the
256 if (flags
& FL_NOCACHE
)
257 tgt
= get_match(COL_TARGET
);
259 tgt
= cn
= mnt_resolve_path(get_match(COL_TARGET
), cache
);
264 fs
= mnt_table_find_mountpoint(tb
, tgt
, MNT_ITER_BACKWARD
);
266 mnt
= mnt_fs_get_target(fs
);
267 if (mnt
&& strcmp(mnt
, tgt
) != 0)
268 set_match(COL_TARGET
, xstrdup(mnt
)); /* replace the current setting */
275 static int is_tabdiff_column(int id
)
277 assert((size_t) id
< ARRAY_SIZE(infos
));
282 case COL_OLD_OPTIONS
:
291 * "findmnt" without any filter
293 int is_listall_mode(void)
295 if ((flags
& FL_DF
) && !(flags
& FL_ALL
))
298 return (!get_match(COL_SOURCE
) &&
299 !get_match(COL_TARGET
) &&
300 !get_match(COL_FSTYPE
) &&
301 !get_match(COL_OPTIONS
) &&
302 !get_match(COL_MAJMIN
));
306 * Returns 1 if the @act is in the --poll=<list>
308 static int has_poll_action(int act
)
313 return 1; /* all actions enabled */
314 for (i
= 0; i
< nactions
; i
++)
315 if (actions
[i
] == act
)
320 static int poll_action_name_to_id(const char *name
, size_t namesz
)
324 if (strncasecmp(name
, "move", namesz
) == 0 && namesz
== 4)
325 id
= MNT_TABDIFF_MOVE
;
326 else if (strncasecmp(name
, "mount", namesz
) == 0 && namesz
== 5)
327 id
= MNT_TABDIFF_MOUNT
;
328 else if (strncasecmp(name
, "umount", namesz
) == 0 && namesz
== 6)
329 id
= MNT_TABDIFF_UMOUNT
;
330 else if (strncasecmp(name
, "remount", namesz
) == 0 && namesz
== 7)
331 id
= MNT_TABDIFF_REMOUNT
;
333 warnx(_("unknown action: %s"), name
);
339 * findmnt --first-only <devname|TAG=|mountpoint>
341 * ... it works like "mount <devname|TAG=|mountpoint>"
343 static int is_mount_compatible_mode(void)
345 if (!get_match(COL_SOURCE
))
346 return 0; /* <devname|TAG=|mountpoint> is required */
347 if (get_match(COL_FSTYPE
) || get_match(COL_OPTIONS
))
348 return 0; /* cannot be restricted by -t or -O */
349 if (!(flags
& FL_FIRSTONLY
))
350 return 0; /* we have to return the first entry only */
355 static void disable_columns_truncate(void)
359 for (i
= 0; i
< ARRAY_SIZE(infos
); i
++)
360 infos
[i
].flags
&= ~SCOLS_FL_TRUNC
;
364 * converts @name to column ID
366 static int column_name_to_id(const char *name
, size_t namesz
)
370 for (i
= 0; i
< ARRAY_SIZE(infos
); i
++) {
371 const char *cn
= column_id_to_name(i
);
373 if (!strncasecmp(name
, cn
, namesz
) && !*(cn
+ namesz
))
376 warnx(_("unknown column: %s"), name
);
382 static char *get_tag_from_udev(const char *devname
, int col
)
384 struct udev_device
*dev
;
385 const char *data
= NULL
;
386 char *res
= NULL
, *path
;
393 /* libudev don't like /dev/mapper/ symlinks */
394 path
= realpath(devname
, NULL
);
398 if (strncmp(devname
, "/dev/", 5) == 0)
401 dev
= udev_device_new_from_subsystem_sysname(udev
, "block", devname
);
409 data
= udev_device_get_property_value(dev
, "ID_FS_LABEL_ENC");
412 data
= udev_device_get_property_value(dev
, "ID_FS_UUID_ENC");
415 data
= udev_device_get_property_value(dev
, "ID_PART_ENTRY_UUID");
418 data
= udev_device_get_property_value(dev
, "ID_PART_ENTRY_NAME");
426 unhexmangle_string(res
);
429 udev_device_unref(dev
);
432 #endif /* HAVE_LIBUDEV */
434 /* Returns LABEL or UUID */
435 static char *get_tag(struct libmnt_fs
*fs
, const char *tagname
, int col
437 __attribute__((__unused__
))
444 if (!mnt_fs_get_tag(fs
, &t
, &v
) && !strcmp(t
, tagname
))
447 const char *dev
= mnt_fs_get_source(fs
);
449 if (dev
&& !(flags
& FL_NOCACHE
))
450 dev
= mnt_resolve_spec(dev
, cache
);
453 res
= get_tag_from_udev(dev
, col
);
456 res
= mnt_cache_find_tag_value(cache
, dev
, tagname
);
458 /* don't return pointer to cache */
466 static char *get_vfs_attr(struct libmnt_fs
*fs
, int sizetype
)
469 uint64_t vfs_attr
= 0;
472 if (statvfs(mnt_fs_get_target(fs
), &buf
) != 0)
477 vfs_attr
= buf
.f_frsize
* buf
.f_blocks
;
480 vfs_attr
= buf
.f_frsize
* buf
.f_bavail
;
483 vfs_attr
= buf
.f_frsize
* (buf
.f_blocks
- buf
.f_bfree
);
486 if (buf
.f_blocks
== 0)
489 xasprintf(&sizestr
, "%.0f%%",
490 (double)(buf
.f_blocks
- buf
.f_bfree
) /
496 sizestr
= xstrdup("0");
497 else if (flags
& FL_BYTES
)
498 xasprintf(&sizestr
, "%ju", vfs_attr
);
500 sizestr
= size_to_human_string(SIZE_SUFFIX_1LETTER
, vfs_attr
);
505 /* reads FS data from libmount
507 static char *get_data(struct libmnt_fs
*fs
, int num
)
510 int col_id
= get_column_id(num
);
515 const char *root
= mnt_fs_get_root(fs
);
516 const char *spec
= mnt_fs_get_srcpath(fs
);
519 if (spec
&& (flags
& FL_CANONICALIZE
))
520 spec
= cn
= mnt_resolve_path(spec
, cache
);
522 spec
= mnt_fs_get_source(fs
);
524 if (spec
&& (flags
& FL_EVALUATE
))
525 spec
= cn
= mnt_resolve_spec(spec
, cache
);
527 if (root
&& spec
&& !(flags
& FL_NOFSROOT
) && strcmp(root
, "/"))
528 xasprintf(&str
, "%s[%s]", spec
, root
);
536 str
= xstrdup(mnt_fs_get_target(fs
));
539 str
= xstrdup(mnt_fs_get_fstype(fs
));
542 str
= xstrdup(mnt_fs_get_options(fs
));
544 case COL_VFS_OPTIONS
:
545 str
= xstrdup(mnt_fs_get_vfs_options(fs
));
548 str
= xstrdup(mnt_fs_get_fs_options(fs
));
551 str
= xstrdup(mnt_fs_get_optional_fields(fs
));
554 str
= get_tag(fs
, "UUID", col_id
);
557 str
= get_tag(fs
, "PARTUUID", col_id
);
560 str
= get_tag(fs
, "LABEL", col_id
);
563 str
= get_tag(fs
, "PARTLABEL", col_id
);
568 dev_t devno
= mnt_fs_get_devno(fs
);
572 if ((flags
& FL_RAW
) || (flags
& FL_EXPORT
) || (flags
& FL_JSON
))
573 xasprintf(&str
, "%u:%u", major(devno
), minor(devno
));
575 xasprintf(&str
, "%3u:%-3u", major(devno
), minor(devno
));
582 str
= get_vfs_attr(fs
, col_id
);
585 str
= xstrdup(mnt_fs_get_root(fs
));
588 if (mnt_fs_get_tid(fs
))
589 xasprintf(&str
, "%d", mnt_fs_get_tid(fs
));
592 if (mnt_fs_get_id(fs
))
593 xasprintf(&str
, "%d", mnt_fs_get_id(fs
));
595 case COL_PROPAGATION
:
596 if (mnt_fs_is_kernel(fs
)) {
597 unsigned long fl
= 0;
600 if (mnt_fs_get_propagation(fs
, &fl
) != 0)
603 n
= xstrdup((fl
& MS_SHARED
) ? "shared" : "private");
606 xasprintf(&str
, "%s,slave", n
);
610 if (fl
& MS_UNBINDABLE
) {
611 xasprintf(&str
, "%s,unbindable", n
);
619 if (!mnt_fs_is_kernel(fs
))
620 xasprintf(&str
, "%d", mnt_fs_get_freq(fs
));
623 if (!mnt_fs_is_kernel(fs
))
624 xasprintf(&str
, "%d", mnt_fs_get_passno(fs
));
632 static char *get_tabdiff_data(struct libmnt_fs
*old_fs
,
633 struct libmnt_fs
*new_fs
,
639 switch (get_column_id(num
)) {
642 case MNT_TABDIFF_MOUNT
:
645 case MNT_TABDIFF_UMOUNT
:
648 case MNT_TABDIFF_REMOUNT
:
651 case MNT_TABDIFF_MOVE
:
660 case COL_OLD_OPTIONS
:
661 if (old_fs
&& (change
== MNT_TABDIFF_REMOUNT
||
662 change
== MNT_TABDIFF_UMOUNT
))
663 str
= xstrdup(mnt_fs_get_options(old_fs
));
666 if (old_fs
&& (change
== MNT_TABDIFF_MOVE
||
667 change
== MNT_TABDIFF_UMOUNT
))
668 str
= xstrdup(mnt_fs_get_target(old_fs
));
672 str
= get_data(new_fs
, num
);
674 str
= get_data(old_fs
, num
);
680 /* adds one line to the output @tab */
681 static struct libscols_line
*add_line(struct libscols_table
*table
, struct libmnt_fs
*fs
,
682 struct libscols_line
*parent
)
685 struct libscols_line
*line
= scols_table_new_line(table
, parent
);
688 warn(_("failed to add line to output"));
691 for (i
= 0; i
< ncolumns
; i
++)
692 scols_line_refer_data(line
, i
, get_data(fs
, i
));
694 scols_line_set_userdata(line
, fs
);
698 static struct libscols_line
*add_tabdiff_line(struct libscols_table
*table
, struct libmnt_fs
*new_fs
,
699 struct libmnt_fs
*old_fs
, int change
)
702 struct libscols_line
*line
= scols_table_new_line(table
, NULL
);
705 warn(_("failed to add line to output"));
708 for (i
= 0; i
< ncolumns
; i
++)
709 scols_line_refer_data(line
, i
,
710 get_tabdiff_data(old_fs
, new_fs
, change
, i
));
715 static int has_line(struct libscols_table
*table
, struct libmnt_fs
*fs
)
717 struct libscols_line
*ln
;
718 struct libscols_iter
*itr
;
721 itr
= scols_new_iter(SCOLS_ITER_FORWARD
);
725 while (scols_table_next_line(table
, itr
, &ln
) == 0) {
726 if ((struct libmnt_fs
*) scols_line_get_userdata(ln
) == fs
) {
732 scols_free_iter(itr
);
736 /* reads filesystems from @tb (libmount) and fillin @table (output table) */
737 static int create_treenode(struct libscols_table
*table
, struct libmnt_table
*tb
,
738 struct libmnt_fs
*fs
, struct libscols_line
*parent_line
)
740 struct libmnt_fs
*chld
= NULL
;
741 struct libmnt_iter
*itr
= NULL
;
742 struct libscols_line
*line
;
746 /* first call, get root FS */
747 if (mnt_table_get_root_fs(tb
, &fs
))
751 } else if ((flags
& FL_SUBMOUNTS
) && has_line(table
, fs
))
754 itr
= mnt_new_iter(MNT_ITER_FORWARD
);
758 if ((flags
& FL_SUBMOUNTS
) || match_func(fs
, NULL
)) {
759 line
= add_line(table
, fs
, parent_line
);
766 * add all children to the output table
768 while(mnt_table_next_child_fs(tb
, itr
, fs
, &chld
) == 0) {
769 if (create_treenode(table
, tb
, chld
, line
))
779 static int parser_errcb(struct libmnt_table
*tb
__attribute__ ((__unused__
)),
780 const char *filename
, int line
)
782 warnx(_("%s: parse error at line %d -- ignored"), filename
, line
);
787 static char **append_tabfile(char **files
, int *nfiles
, char *filename
)
789 files
= xrealloc(files
, sizeof(char *) * (*nfiles
+ 1));
790 files
[(*nfiles
)++] = filename
;
794 static char **append_pid_tabfile(char **files
, int *nfiles
, pid_t pid
)
798 xasprintf(&path
, "/proc/%d/mountinfo", (int) pid
);
799 return append_tabfile(files
, nfiles
, path
);
802 /* calls libmount fstab/mtab/mountinfo parser */
803 static struct libmnt_table
*parse_tabfiles(char **files
,
807 struct libmnt_table
*tb
;
810 tb
= mnt_new_table();
812 warn(_("failed to initialize libmount table"));
815 mnt_table_set_parser_errcb(tb
, parser_errcb
);
818 /* NULL means that libmount will use default paths */
819 const char *path
= nfiles
? *files
++ : NULL
;
823 rc
= mnt_table_parse_fstab(tb
, path
);
826 rc
= mnt_table_parse_mtab(tb
, path
);
830 path
= access(_PATH_PROC_MOUNTINFO
, R_OK
) == 0 ?
831 _PATH_PROC_MOUNTINFO
:
834 rc
= mnt_table_parse_file(tb
, path
);
839 warn(_("can't read %s"), path
);
842 } while (--nfiles
> 0);
848 * Parses mountinfo and calls mnt_cache_set_targets(cache, mtab). Only
849 * necessary if @tb in main() was read from a non-kernel source.
851 static void cache_set_targets(struct libmnt_cache
*tmp
)
853 struct libmnt_table
*tb
;
856 tb
= mnt_new_table();
860 path
= access(_PATH_PROC_MOUNTINFO
, R_OK
) == 0 ?
861 _PATH_PROC_MOUNTINFO
:
864 if (mnt_table_parse_file(tb
, path
) == 0)
865 mnt_cache_set_targets(tmp
, tb
);
870 /* checks if @tb contains parent->child relations */
871 static int tab_is_tree(struct libmnt_table
*tb
)
873 struct libmnt_fs
*fs
= NULL
;
874 struct libmnt_iter
*itr
= NULL
;
877 itr
= mnt_new_iter(MNT_ITER_BACKWARD
);
881 rc
= (mnt_table_next_fs(tb
, itr
, &fs
) == 0 &&
882 mnt_fs_is_kernel(fs
) &&
883 mnt_fs_get_root(fs
));
889 /* checks if all fs in @tb are from kernel */
890 static int tab_is_kernel(struct libmnt_table
*tb
)
892 struct libmnt_fs
*fs
= NULL
;
893 struct libmnt_iter
*itr
= NULL
;
895 itr
= mnt_new_iter(MNT_ITER_BACKWARD
);
899 while (mnt_table_next_fs(tb
, itr
, &fs
) == 0) {
900 if (!mnt_fs_is_kernel(fs
)) {
910 /* filter function for libmount (mnt_table_find_next_fs()) */
911 static int match_func(struct libmnt_fs
*fs
,
912 void *data
__attribute__ ((__unused__
)))
914 int rc
= flags
& FL_INVERT
? 1 : 0;
918 m
= get_match(COL_FSTYPE
);
919 if (m
&& !mnt_fs_match_fstype(fs
, m
))
922 m
= get_match(COL_OPTIONS
);
923 if (m
&& !mnt_fs_match_options(fs
, m
))
926 md
= get_match_data(COL_MAJMIN
);
927 if (md
&& mnt_fs_get_devno(fs
) != *((dev_t
*) md
))
930 m
= get_match(COL_TARGET
);
931 if (m
&& !mnt_fs_match_target(fs
, m
, cache
))
934 m
= get_match(COL_SOURCE
);
935 if (m
&& !mnt_fs_match_source(fs
, m
, cache
))
938 if ((flags
& FL_DF
) && !(flags
& FL_ALL
)) {
939 const char *type
= mnt_fs_get_fstype(fs
);
941 if (type
&& strstr(type
, "tmpfs")) /* tmpfs is wanted */
944 if (mnt_fs_is_pseudofs(fs
))
951 /* iterate over filesystems in @tb */
952 struct libmnt_fs
*get_next_fs(struct libmnt_table
*tb
,
953 struct libmnt_iter
*itr
)
955 struct libmnt_fs
*fs
= NULL
;
957 if (is_listall_mode()) {
961 if (mnt_table_next_fs(tb
, itr
, &fs
) != 0)
964 } else if (is_mount_compatible_mode()) {
966 * Look up for FS in the same way how mount(8) searches in fstab
970 fs
= mnt_table_find_source(tb
, get_match(COL_SOURCE
),
971 mnt_iter_get_direction(itr
));
973 if (!fs
&& !(flags
& FL_NOSWAPMATCH
))
974 fs
= mnt_table_find_target(tb
, get_match(COL_SOURCE
),
975 mnt_iter_get_direction(itr
));
978 * Look up for all matching entries
980 * findmnt [-l] <source> <target> [-O <options>] [-t <types>]
981 * findmnt [-l] <spec> [-O <options>] [-t <types>]
984 mnt_table_find_next_fs(tb
, itr
, match_func
, NULL
, &fs
);
987 !(flags
& FL_NOSWAPMATCH
) &&
988 !get_match(COL_TARGET
) && get_match(COL_SOURCE
)) {
990 /* swap 'spec' and target. */
991 set_match(COL_TARGET
, get_match(COL_SOURCE
));
992 set_match(COL_SOURCE
, NULL
);
993 mnt_reset_iter(itr
, -1);
1003 * Filter out unwanted lines for --list output or top level lines for
1004 * --submounts tree output.
1006 static int add_matching_lines(struct libmnt_table
*tb
,
1007 struct libscols_table
*table
, int direction
)
1009 struct libmnt_iter
*itr
= NULL
;
1010 struct libmnt_fs
*fs
;
1011 int nlines
= 0, rc
= -1;
1013 itr
= mnt_new_iter(direction
);
1015 warn(_("failed to initialize libmount iterator"));
1019 while((fs
= get_next_fs(tb
, itr
))) {
1020 if ((flags
& FL_TREE
) || (flags
& FL_SUBMOUNTS
))
1021 rc
= create_treenode(table
, tb
, fs
, NULL
);
1023 rc
= !add_line(table
, fs
, NULL
);
1027 if (flags
& FL_FIRSTONLY
)
1029 flags
|= FL_NOSWAPMATCH
;
1039 static int poll_match(struct libmnt_fs
*fs
)
1041 int rc
= match_func(fs
, NULL
);
1043 if (rc
== 0 && !(flags
& FL_NOSWAPMATCH
) &&
1044 get_match(COL_SOURCE
) && !get_match(COL_TARGET
)) {
1046 * findmnt --poll /foo
1047 * The '/foo' maybe source as well as target.
1049 const char *str
= get_match(COL_SOURCE
);
1051 set_match(COL_TARGET
, str
); /* swap */
1052 set_match(COL_SOURCE
, NULL
);
1054 rc
= match_func(fs
, NULL
);
1056 set_match(COL_TARGET
, NULL
); /* restore */
1057 set_match(COL_SOURCE
, str
);
1063 static int poll_table(struct libmnt_table
*tb
, const char *tabfile
,
1064 int timeout
, struct libscols_table
*table
, int direction
)
1068 struct libmnt_iter
*itr
= NULL
;
1069 struct libmnt_table
*tb_new
= NULL
;
1070 struct libmnt_tabdiff
*diff
= NULL
;
1071 struct pollfd fds
[1];
1073 tb_new
= mnt_new_table();
1075 warn(_("failed to initialize libmount table"));
1079 itr
= mnt_new_iter(direction
);
1081 warn(_("failed to initialize libmount iterator"));
1085 diff
= mnt_new_tabdiff();
1087 warn(_("failed to initialize libmount tabdiff"));
1091 /* cache is unnecessary to detect changes */
1092 mnt_table_set_cache(tb
, NULL
);
1093 mnt_table_set_cache(tb_new
, NULL
);
1095 f
= fopen(tabfile
, "r");
1097 warn(_("cannot open %s"), tabfile
);
1101 mnt_table_set_parser_errcb(tb_new
, parser_errcb
);
1103 fds
[0].fd
= fileno(f
);
1104 fds
[0].events
= POLLPRI
;
1107 struct libmnt_table
*tmp
;
1108 struct libmnt_fs
*old
, *new;
1111 count
= poll(fds
, 1, timeout
);
1113 break; /* timeout */
1115 warn(_("poll() failed"));
1120 rc
= mnt_table_parse_stream(tb_new
, f
, tabfile
);
1122 rc
= mnt_diff_tables(diff
, tb
, tb_new
);
1127 mnt_reset_iter(itr
, direction
);
1128 while(mnt_tabdiff_next_change(
1129 diff
, itr
, &old
, &new, &change
) == 0) {
1131 if (!has_poll_action(change
))
1133 if (!poll_match(new ? new : old
))
1136 rc
= !add_tabdiff_line(table
, new, old
, change
);
1139 if (flags
& FL_FIRSTONLY
)
1144 rc
= scols_table_print_range(table
, NULL
, NULL
);
1146 fputc('\n', scols_table_get_stream(table
));
1157 /* remove already printed lines to reduce memory usage */
1158 scols_table_remove_lines(table
);
1159 mnt_reset_table(tb_new
);
1161 if (count
&& (flags
& FL_FIRSTONLY
))
1167 mnt_unref_table(tb_new
);
1168 mnt_free_tabdiff(diff
);
1175 static int uniq_fs_target_cmp(
1176 struct libmnt_table
*tb
__attribute__((__unused__
)),
1177 struct libmnt_fs
*a
,
1178 struct libmnt_fs
*b
)
1180 return !mnt_fs_match_target(a
, mnt_fs_get_target(b
), cache
);
1183 static void __attribute__((__noreturn__
)) usage(FILE *out
)
1187 fputs(USAGE_HEADER
, out
);
1190 " %1$s [options] <device> | <mountpoint>\n"
1191 " %1$s [options] <device> <mountpoint>\n"
1192 " %1$s [options] [--source <device>] [--target <path> | --mountpoint <dir>]\n"),
1193 program_invocation_short_name
);
1195 fputs(USAGE_SEPARATOR
, out
);
1196 fputs(_("Find a (mounted) filesystem.\n"), out
);
1198 fputs(USAGE_OPTIONS
, out
);
1199 fputs(_(" -s, --fstab search in static table of filesystems\n"), out
);
1200 fputs(_(" -m, --mtab search in table of mounted filesystems\n"
1201 " (includes user space mount options)\n"), out
);
1202 fputs(_(" -k, --kernel search in kernel table of mounted\n"
1203 " filesystems (default)\n"), out
);
1205 fputs(_(" -p, --poll[=<list>] monitor changes in table of mounted filesystems\n"), out
);
1206 fputs(_(" -w, --timeout <num> upper limit in milliseconds that --poll will block\n"), out
);
1209 fputs(_(" -A, --all disable all built-in filters, print all filesystems\n"), out
);
1210 fputs(_(" -a, --ascii use ASCII chars for tree formatting\n"), out
);
1211 fputs(_(" -b, --bytes print sizes in bytes rather than in human readable format\n"), out
);
1212 fputs(_(" -C, --nocanonicalize don't canonicalize when comparing paths\n"), out
);
1213 fputs(_(" -c, --canonicalize canonicalize printed paths\n"), out
);
1214 fputs(_(" -D, --df imitate the output of df(1)\n"), out
);
1215 fputs(_(" -d, --direction <word> direction of search, 'forward' or 'backward'\n"), out
);
1216 fputs(_(" -e, --evaluate convert tags (LABEL,UUID,PARTUUID,PARTLABEL) \n"
1217 " to device names\n"), out
);
1218 fputs(_(" -F, --tab-file <path> alternative file for -s, -m or -k options\n"), out
);
1219 fputs(_(" -f, --first-only print the first found filesystem only\n"), out
);
1220 fputs(_(" -i, --invert invert the sense of matching\n"), out
);
1221 fputs(_(" -J, --json use JSON output format\n"), out
);
1222 fputs(_(" -l, --list use list format output\n"), out
);
1223 fputs(_(" -N, --task <tid> use alternative namespace (/proc/<tid>/mountinfo file)\n"), out
);
1224 fputs(_(" -n, --noheadings don't print column headings\n"), out
);
1225 fputs(_(" -O, --options <list> limit the set of filesystems by mount options\n"), out
);
1226 fputs(_(" -o, --output <list> the output columns to be shown\n"), out
);
1227 fputs(_(" -P, --pairs use key=\"value\" output format\n"), out
);
1228 fputs(_(" -R, --submounts print all submounts for the matching filesystems\n"), out
);
1229 fputs(_(" -r, --raw use raw output format\n"), out
);
1230 fputs(_(" -S, --source <string> the device to mount (by name, maj:min, \n"
1231 " LABEL=, UUID=, PARTUUID=, PARTLABEL=)\n"), out
);
1232 fputs(_(" -T, --target <path> the path to the filesystem to use\n"), out
);
1233 fputs(_(" --tree enable tree format output is possible\n"), out
);
1234 fputs(_(" -M, --mountpoint <dir> the mountpoint directory\n"), out
);
1235 fputs(_(" -t, --types <list> limit the set of filesystems by FS types\n"), out
);
1236 fputs(_(" -U, --uniq ignore filesystems with duplicate target\n"), out
);
1237 fputs(_(" -u, --notruncate don't truncate text in columns\n"), out
);
1238 fputs(_(" -v, --nofsroot don't print [/dir] for bind or btrfs mounts\n"), out
);
1241 fputs(_(" -x, --verify verify mount table content (default is fstab)\n"), out
);
1242 fputs(_(" --verbose print more details\n"), out
);
1245 fputs(USAGE_SEPARATOR
, out
);
1246 fputs(USAGE_HELP
, out
);
1247 fputs(USAGE_VERSION
, out
);
1249 fprintf(out
, _("\nAvailable columns:\n"));
1251 for (i
= 0; i
< ARRAY_SIZE(infos
); i
++)
1252 fprintf(out
, " %11s %s\n", infos
[i
].name
, _(infos
[i
].help
));
1254 fprintf(out
, USAGE_MAN_TAIL("findmnt(8)"));
1256 exit(out
== stderr
? EXIT_FAILURE
: EXIT_SUCCESS
);
1259 int main(int argc
, char *argv
[])
1261 struct libmnt_table
*tb
= NULL
;
1262 char **tabfiles
= NULL
;
1263 int direction
= MNT_ITER_FORWARD
;
1265 int c
, rc
= -1, timeout
= -1;
1266 int ntabfiles
= 0, tabtype
= 0;
1267 char *outarg
= NULL
;
1269 int force_tree
= 0, istree
= 0;
1271 struct libscols_table
*table
= NULL
;
1274 FINDMNT_OPT_VERBOSE
= CHAR_MAX
+ 1,
1278 static const struct option longopts
[] = {
1279 { "all", 0, 0, 'A' },
1280 { "ascii", 0, 0, 'a' },
1281 { "bytes", 0, 0, 'b' },
1282 { "canonicalize", 0, 0, 'c' },
1283 { "direction", 1, 0, 'd' },
1284 { "df", 0, 0, 'D' },
1285 { "evaluate", 0, 0, 'e' },
1286 { "first-only", 0, 0, 'f' },
1287 { "fstab", 0, 0, 's' },
1288 { "help", 0, 0, 'h' },
1289 { "invert", 0, 0, 'i' },
1290 { "json", 0, 0, 'J' },
1291 { "kernel", 0, 0, 'k' },
1292 { "list", 0, 0, 'l' },
1293 { "mountpoint", 1, 0, 'M' },
1294 { "mtab", 0, 0, 'm' },
1295 { "noheadings", 0, 0, 'n' },
1296 { "notruncate", 0, 0, 'u' },
1297 { "options", 1, 0, 'O' },
1298 { "output", 1, 0, 'o' },
1299 { "poll", 2, 0, 'p' },
1300 { "pairs", 0, 0, 'P' },
1301 { "raw", 0, 0, 'r' },
1302 { "types", 1, 0, 't' },
1303 { "nocanonicalize", 0, 0, 'C' },
1304 { "nofsroot", 0, 0, 'v' },
1305 { "submounts", 0, 0, 'R' },
1306 { "source", 1, 0, 'S' },
1307 { "tab-file", 1, 0, 'F' },
1308 { "task", 1, 0, 'N' },
1309 { "target", 1, 0, 'T' },
1310 { "timeout", 1, 0, 'w' },
1311 { "uniq", 0, 0, 'U' },
1312 { "verify", 0, 0, 'x' },
1313 { "version", 0, 0, 'V' },
1314 { "verbose", 0, 0, FINDMNT_OPT_VERBOSE
},
1315 { "tree", 0, 0, FINDMNT_OPT_TREE
},
1319 static const ul_excl_t excl
[] = { /* rows and cols in ASCII order */
1320 { 'C', 'c'}, /* [no]canonicalize */
1321 { 'C', 'e' }, /* nocanonicalize, evaluate */
1322 { 'J', 'P', 'r','x' }, /* json,pairs,raw,verify */
1323 { 'M', 'T' }, /* mountpoint, target */
1324 { 'N','k','m','s' }, /* task,kernel,mtab,fstab */
1325 { 'P','l','r','x' }, /* pairs,list,raw,verify */
1326 { 'p','x' }, /* poll,verify */
1327 { 'm','p','s' }, /* mtab,poll,fstab */
1330 int excl_st
[ARRAY_SIZE(excl
)] = UL_EXCL_STATUS_INIT
;
1332 setlocale(LC_ALL
, "");
1333 bindtextdomain(PACKAGE
, LOCALEDIR
);
1334 textdomain(PACKAGE
);
1335 atexit(close_stdout
);
1337 /* default output format */
1340 while ((c
= getopt_long(argc
, argv
,
1341 "AabCcDd:ehiJfF:o:O:p::PklmM:nN:rst:uvRS:T:Uw:Vx",
1342 longopts
, NULL
)) != -1) {
1344 err_exclusive_options(c
, longopts
, excl
, excl_st
);
1357 flags
|= FL_NOCACHE
;
1360 flags
|= FL_CANONICALIZE
;
1367 if (!strcmp(optarg
, "forward"))
1368 direction
= MNT_ITER_FORWARD
;
1369 else if (!strcmp(optarg
, "backward"))
1370 direction
= MNT_ITER_BACKWARD
;
1373 _("unknown direction '%s'"), optarg
);
1376 flags
|= FL_EVALUATE
;
1388 flags
|= FL_FIRSTONLY
;
1391 tabfiles
= append_tabfile(tabfiles
, &ntabfiles
, optarg
);
1394 disable_columns_truncate();
1400 set_match(COL_OPTIONS
, optarg
);
1404 nactions
= string_to_idarray(optarg
,
1405 actions
, ARRAY_SIZE(actions
),
1406 poll_action_name_to_id
);
1417 case 'm': /* mtab */
1418 tabtype
= TABTYPE_MTAB
;
1421 case 's': /* fstab */
1422 tabtype
= TABTYPE_FSTAB
;
1425 case 'k': /* kernel (mountinfo) */
1426 tabtype
= TABTYPE_KERNEL
;
1429 set_match(COL_FSTYPE
, optarg
);
1432 flags
&= ~FL_TREE
; /* disable the default */
1433 flags
|= FL_RAW
; /* enable raw */
1436 flags
&= ~FL_TREE
; /* disable the default */
1439 flags
|= FL_NOHEADINGS
;
1442 tabtype
= TABTYPE_KERNEL
;
1443 tabfiles
= append_pid_tabfile(tabfiles
, &ntabfiles
,
1444 strtou32_or_err(optarg
,
1445 _("invalid TID argument")));
1448 flags
|= FL_NOFSROOT
;
1451 flags
|= FL_SUBMOUNTS
;
1454 set_source_match(optarg
);
1455 flags
|= FL_NOSWAPMATCH
;
1458 flags
|= FL_STRICTTARGET
;
1461 set_match(COL_TARGET
, optarg
);
1462 flags
|= FL_NOSWAPMATCH
;
1468 timeout
= strtos32_or_err(optarg
, _("invalid timeout argument"));
1471 printf(UTIL_LINUX_VERSION
);
1472 return EXIT_SUCCESS
;
1476 case FINDMNT_OPT_VERBOSE
:
1477 flags
|= FL_VERBOSE
;
1479 case FINDMNT_OPT_TREE
:
1483 errtryhelp(EXIT_FAILURE
);
1487 if (!ncolumns
&& (flags
& FL_DF
)) {
1488 add_column(columns
, ncolumns
++, COL_SOURCE
);
1489 add_column(columns
, ncolumns
++, COL_FSTYPE
);
1490 add_column(columns
, ncolumns
++, COL_SIZE
);
1491 add_column(columns
, ncolumns
++, COL_USED
);
1492 add_column(columns
, ncolumns
++, COL_AVAIL
);
1493 add_column(columns
, ncolumns
++, COL_USEPERC
);
1494 add_column(columns
, ncolumns
++, COL_TARGET
);
1497 /* default columns */
1499 if (flags
& FL_POLL
)
1500 add_column(columns
, ncolumns
++, COL_ACTION
);
1502 add_column(columns
, ncolumns
++, COL_TARGET
);
1503 add_column(columns
, ncolumns
++, COL_SOURCE
);
1504 add_column(columns
, ncolumns
++, COL_FSTYPE
);
1505 add_column(columns
, ncolumns
++, COL_OPTIONS
);
1508 if (outarg
&& string_add_to_idarray(outarg
, columns
, ARRAY_SIZE(columns
),
1509 &ncolumns
, column_name_to_id
) < 0)
1510 return EXIT_FAILURE
;
1513 tabtype
= verify
? TABTYPE_FSTAB
: TABTYPE_KERNEL
;
1515 if ((flags
& FL_POLL
) && ntabfiles
> 1)
1516 errx(EXIT_FAILURE
, _("--poll accepts only one file, but more specified by --tab-file"));
1518 if (optind
< argc
&& (get_match(COL_SOURCE
) || get_match(COL_TARGET
)))
1519 errx(EXIT_FAILURE
, _(
1520 "options --target and --source can't be used together "
1521 "with command line element that is not an option"));
1524 set_source_match(argv
[optind
++]); /* dev/tag/mountpoint/maj:min */
1526 set_match(COL_TARGET
, argv
[optind
++]); /* mountpoint */
1528 if ((flags
& FL_SUBMOUNTS
) && is_listall_mode())
1529 /* don't care about submounts if list all mounts */
1530 flags
&= ~FL_SUBMOUNTS
;
1532 if (!(flags
& FL_SUBMOUNTS
) && ((flags
& FL_FIRSTONLY
)
1533 || get_match(COL_TARGET
)
1534 || get_match(COL_SOURCE
)
1535 || get_match(COL_MAJMIN
)))
1538 if (!(flags
& FL_NOSWAPMATCH
) &&
1539 !get_match(COL_TARGET
) && get_match(COL_SOURCE
)) {
1541 * Check if we can swap source and target, it's
1542 * not possible if the source is LABEL=/UUID=
1544 const char *x
= get_match(COL_SOURCE
);
1546 if (!strncmp(x
, "LABEL=", 6) || !strncmp(x
, "UUID=", 5) ||
1547 !strncmp(x
, "PARTLABEL=", 10) || !strncmp(x
, "PARTUUID=", 9))
1548 flags
|= FL_NOSWAPMATCH
;
1552 * initialize libmount
1556 tb
= parse_tabfiles(tabfiles
, ntabfiles
, tabtype
);
1560 if (tabtype
== TABTYPE_MTAB
&& tab_is_kernel(tb
))
1561 tabtype
= TABTYPE_KERNEL
;
1563 istree
= tab_is_tree(tb
);
1564 if (istree
&& force_tree
)
1567 if ((flags
& FL_TREE
) && (ntabfiles
> 1 || !istree
))
1570 if (!(flags
& FL_NOCACHE
)) {
1571 cache
= mnt_new_cache();
1573 warn(_("failed to initialize libmount cache"));
1576 mnt_table_set_cache(tb
, cache
);
1578 if (tabtype
!= TABTYPE_KERNEL
)
1579 cache_set_targets(cache
);
1582 if (flags
& FL_UNIQ
)
1583 mnt_table_uniq_fs(tb
, MNT_UNIQ_KEEPTREE
, uniq_fs_target_cmp
);
1586 rc
= verify_table(tb
);
1591 * initialize libsmartcols
1593 scols_init_debug(0);
1594 table
= scols_new_table();
1596 warn(_("failed to initialize output table"));
1599 scols_table_enable_raw(table
, !!(flags
& FL_RAW
));
1600 scols_table_enable_export(table
, !!(flags
& FL_EXPORT
));
1601 scols_table_enable_json(table
, !!(flags
& FL_JSON
));
1602 scols_table_enable_ascii(table
, !!(flags
& FL_ASCII
));
1603 scols_table_enable_noheadings(table
, !!(flags
& FL_NOHEADINGS
));
1605 if (flags
& FL_JSON
)
1606 scols_table_set_name(table
, "filesystems");
1608 for (i
= 0; i
< ncolumns
; i
++) {
1609 int fl
= get_column_flags(i
);
1610 int id
= get_column_id(i
);
1612 if (!(flags
& FL_TREE
))
1613 fl
&= ~SCOLS_FL_TREE
;
1615 if (!(flags
& FL_POLL
) && is_tabdiff_column(id
)) {
1616 warnx(_("%s column is requested, but --poll "
1617 "is not enabled"), get_column_name(i
));
1620 if (!scols_table_new_column(table
, get_column_name(i
),
1621 get_column_whint(i
), fl
)) {
1622 warn(_("failed to initialize output column"));
1628 * Fill in data to the output table
1630 if (flags
& FL_POLL
) {
1631 /* poll mode (accept the first tabfile only) */
1632 rc
= poll_table(tb
, tabfiles
? *tabfiles
: _PATH_PROC_MOUNTINFO
, timeout
, table
, direction
);
1634 } else if ((flags
& FL_TREE
) && !(flags
& FL_SUBMOUNTS
)) {
1636 rc
= create_treenode(table
, tb
, NULL
, NULL
);
1638 /* whole list of sub-tree */
1639 rc
= add_matching_lines(tb
, table
, direction
);
1642 && tabtype
== TABTYPE_KERNEL
1643 && (flags
& FL_NOSWAPMATCH
)
1644 && !(flags
& FL_STRICTTARGET
)
1645 && get_match(COL_TARGET
)) {
1647 * Found nothing, maybe the --target is regular file,
1648 * try it again with extra functionality for target
1651 enable_extra_target_match(tb
);
1652 rc
= add_matching_lines(tb
, table
, direction
);
1657 * Print the output table for non-poll modes
1659 if (!rc
&& !(flags
& FL_POLL
))
1660 scols_print_table(table
);
1662 scols_unref_table(table
);
1664 mnt_unref_table(tb
);
1665 mnt_unref_cache(cache
);
1671 return rc
? EXIT_FAILURE
: EXIT_SUCCESS
;