misc-utils/findmnt.c

   1 /*
   2  * findmnt(8)
   3  *
   4  * Copyright (C) 2010-2015 Red Hat, Inc. All rights reserved.
   5  * Written by Karel Zak <kzak@redhat.com>
   6  *
   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.
  11  *
  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.
  16  *
  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.
  20  */
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <errno.h>
  24 #include <unistd.h>
  25 #include <getopt.h>
  26 #include <string.h>
  27 #include <termios.h>
  28 #ifdef HAVE_SYS_IOCTL_H
  29 # include <sys/ioctl.h>
  30 #endif
  31 #include <assert.h>
  32 #include <poll.h>
  33 #include <sys/statvfs.h>
  34 #include <sys/types.h>
  35 #ifdef HAVE_LIBUDEV
  36 # include <libudev.h>
  37 #endif
  38 #include <libmount.h>
  39 #include <libsmartcols.h>
  40
  41 #include "pathnames.h"
  42 #include "nls.h"
  43 #include "closestream.h"
  44 #include "c.h"
  45 #include "strutils.h"
  46 #include "xalloc.h"
  47 #include "optutils.h"
  48 #include "mangle.h"
  49
  50 #include "findmnt.h"
  51
  52 /* column IDs */
  53 enum {
  54         COL_SOURCE,
  55         COL_TARGET,
  56         COL_FSTYPE,
  57         COL_OPTIONS,
  58         COL_VFS_OPTIONS,
  59         COL_FS_OPTIONS,
  60         COL_LABEL,
  61         COL_UUID,
  62         COL_PARTLABEL,
  63         COL_PARTUUID,
  64         COL_MAJMIN,
  65         COL_ACTION,
  66         COL_OLD_TARGET,
  67         COL_OLD_OPTIONS,
  68         COL_SIZE,
  69         COL_AVAIL,
  70         COL_USED,
  71         COL_USEPERC,
  72         COL_FSROOT,
  73         COL_TID,
  74         COL_ID,
  75         COL_OPT_FIELDS,
  76         COL_PROPAGATION,
  77         COL_FREQ,
  78         COL_PASSNO
  79 };
  80
  81 enum {
  82         TABTYPE_FSTAB = 1,
  83         TABTYPE_MTAB,
  84         TABTYPE_KERNEL
  85 };
  86
  87 /* column names */
  88 struct colinfo {
  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 */
  95 };
  96
  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]") }
 124 };
 125
 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;
 132
 133 static inline size_t err_columns_index(size_t arysz, size_t idx)
 134 {
 135         if (idx >= arysz)
 136                 errx(EXIT_FAILURE, _("too many columns specified, "
 137                                      "the limit is %zu columns"),
 138                                 arysz - 1);
 139         return idx;
 140 }
 141
 142 #define add_column(ary, n, id)  \
 143                 ((ary)[ err_columns_index(ARRAY_SIZE(ary), (n)) ] = (id))
 144
 145 /* poll actions (parsed --poll=<list> */
 146 #define FINDMNT_NACTIONS        4               /* mount, umount, move, remount */
 147 static int actions[FINDMNT_NACTIONS];
 148 static int nactions;
 149
 150 /* global (accessed from findmnt-verify.c too) */
 151 int flags;
 152 int parse_nerrors;
 153 struct libmnt_cache *cache;
 154
 155
 156 #ifdef HAVE_LIBUDEV
 157 static struct udev *udev;
 158 #endif
 159
 160 static int match_func(struct libmnt_fs *fs, void *data __attribute__ ((__unused__)));
 161
 162
 163 static int get_column_id(int num)
 164 {
 165         assert(num >= 0);
 166         assert((size_t) num < ncolumns);
 167         assert((size_t) columns[num] < ARRAY_SIZE(infos));
 168         return columns[num];
 169 }
 170
 171 static struct colinfo *get_column_info(int num)
 172 {
 173         return &infos[ get_column_id(num) ];
 174 }
 175
 176 static const char *column_id_to_name(int id)
 177 {
 178         assert((size_t) id < ARRAY_SIZE(infos));
 179         return infos[id].name;
 180 }
 181
 182 static const char *get_column_name(int num)
 183 {
 184         return get_column_info(num)->name;
 185 }
 186
 187 static float get_column_whint(int num)
 188 {
 189         return get_column_info(num)->whint;
 190 }
 191
 192 static int get_column_flags(int num)
 193 {
 194         return get_column_info(num)->flags;
 195 }
 196
 197 static const char *get_match(int id)
 198 {
 199         assert((size_t) id < ARRAY_SIZE(infos));
 200         return infos[id].match;
 201 }
 202
 203 static void *get_match_data(int id)
 204 {
 205         assert((size_t) id < ARRAY_SIZE(infos));
 206         return infos[id].match_data;
 207 }
 208
 209 static void set_match(int id, const char *match)
 210 {
 211         assert((size_t) id < ARRAY_SIZE(infos));
 212         infos[id].match = match;
 213 }
 214
 215 static void set_match_data(int id, void *data)
 216 {
 217         assert((size_t) id < ARRAY_SIZE(infos));
 218         infos[id].match_data = data;
 219 }
 220
 221 /*
 222  * source match means COL_SOURCE *or* COL_MAJMIN, depends on
 223  * data format.
 224  */
 225 static void set_source_match(const char *data)
 226 {
 227         int maj, min;
 228
 229         if (sscanf(data, "%d:%d", &maj, &min) == 2) {
 230                 dev_t *devno = xmalloc(sizeof(dev_t));
 231
 232                 *devno = makedev(maj, min);
 233                 set_match(COL_MAJMIN, data);
 234                 set_match_data(COL_MAJMIN, (void *) devno);
 235                 flags |= FL_NOSWAPMATCH;
 236         } else
 237                 set_match(COL_SOURCE, data);
 238 }
 239
 240 /*
 241  * Extra functionality for --target <path>. The function mnt_table_find_mountpoint()
 242  * also checks parents (path elements in reverse order) to get mountpoint.
 243  *
 244  * @tb has to be from kernel (so no fstab or so)!
 245  */
 246 static void enable_extra_target_match(struct libmnt_table *tb)
 247 {
 248         char *cn = NULL;
 249         const char *tgt = NULL, *mnt = NULL;
 250         struct libmnt_fs *fs;
 251
 252         /*
 253          * Check if match pattern is mountpoint, if not use the
 254          * real mountpoint.
 255          */
 256         if (flags & FL_NOCACHE)
 257                 tgt = get_match(COL_TARGET);
 258         else {
 259                 tgt = cn = mnt_resolve_path(get_match(COL_TARGET), cache);
 260                 if (!cn)
 261                         return;
 262         }
 263
 264         fs = mnt_table_find_mountpoint(tb, tgt, MNT_ITER_BACKWARD);
 265         if (fs)
 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 */
 269
 270         if (!cache)
 271                 free(cn);
 272 }
 273
 274
 275 static int is_tabdiff_column(int id)
 276 {
 277         assert((size_t) id < ARRAY_SIZE(infos));
 278
 279         switch(id) {
 280         case COL_ACTION:
 281         case COL_OLD_TARGET:
 282         case COL_OLD_OPTIONS:
 283                 return 1;
 284         default:
 285                 break;
 286         }
 287         return 0;
 288 }
 289
 290 /*
 291  * "findmnt" without any filter
 292  */
 293 int is_listall_mode(void)
 294 {
 295         if ((flags & FL_DF) && !(flags & FL_ALL))
 296                 return 0;
 297
 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));
 303 }
 304
 305 /*
 306  * Returns 1 if the @act is in the --poll=<list>
 307  */
 308 static int has_poll_action(int act)
 309 {
 310         int i;
 311
 312         if (!nactions)
 313                 return 1;       /* all actions enabled */
 314         for (i = 0; i < nactions; i++)
 315                 if (actions[i] == act)
 316                         return 1;
 317         return 0;
 318 }
 319
 320 static int poll_action_name_to_id(const char *name, size_t namesz)
 321 {
 322         int id = -1;
 323
 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;
 332         else
 333                 warnx(_("unknown action: %s"), name);
 334
 335         return id;
 336 }
 337
 338 /*
 339  * findmnt --first-only <devname|TAG=|mountpoint>
 340  *
 341  * ... it works like "mount <devname|TAG=|mountpoint>"
 342  */
 343 static int is_mount_compatible_mode(void)
 344 {
 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 */
 351
 352         return 1;                       /* ok */
 353 }
 354
 355 static void disable_columns_truncate(void)
 356 {
 357         size_t i;
 358
 359         for (i = 0; i < ARRAY_SIZE(infos); i++)
 360                 infos[i].flags &= ~SCOLS_FL_TRUNC;
 361 }
 362
 363 /*
 364  * converts @name to column ID
 365  */
 366 static int column_name_to_id(const char *name, size_t namesz)
 367 {
 368         size_t i;
 369
 370         for (i = 0; i < ARRAY_SIZE(infos); i++) {
 371                 const char *cn = column_id_to_name(i);
 372
 373                 if (!strncasecmp(name, cn, namesz) && !*(cn + namesz))
 374                         return i;
 375         }
 376         warnx(_("unknown column: %s"), name);
 377         return -1;
 378 }
 379
 380
 381 #ifdef HAVE_LIBUDEV
 382 static char *get_tag_from_udev(const char *devname, int col)
 383 {
 384         struct udev_device *dev;
 385         const char *data = NULL;
 386         char *res = NULL, *path;
 387
 388         if (!udev)
 389                 udev = udev_new();
 390         if (!udev)
 391                 return NULL;
 392
 393         /* libudev don't like /dev/mapper/ symlinks */
 394         path = realpath(devname, NULL);
 395         if (path)
 396                 devname = path;
 397
 398         if (strncmp(devname, "/dev/", 5) == 0)
 399                 devname += 5;
 400
 401         dev = udev_device_new_from_subsystem_sysname(udev, "block", devname);
 402         free(path);
 403
 404         if (!dev)
 405                 return NULL;
 406
 407         switch(col) {
 408         case COL_LABEL:
 409                 data = udev_device_get_property_value(dev, "ID_FS_LABEL_ENC");
 410                 break;
 411         case COL_UUID:
 412                 data = udev_device_get_property_value(dev, "ID_FS_UUID_ENC");
 413                 break;
 414         case COL_PARTUUID:
 415                 data = udev_device_get_property_value(dev, "ID_PART_ENTRY_UUID");
 416                 break;
 417         case COL_PARTLABEL:
 418                 data = udev_device_get_property_value(dev, "ID_PART_ENTRY_NAME");
 419                 break;
 420         default:
 421                 break;
 422         }
 423
 424         if (data) {
 425                 res = xstrdup(data);
 426                 unhexmangle_string(res);
 427         }
 428
 429         udev_device_unref(dev);
 430         return res;
 431 }
 432 #endif /* HAVE_LIBUDEV */
 433
 434 /* Returns LABEL or UUID */
 435 static char *get_tag(struct libmnt_fs *fs, const char *tagname, int col
 436 #ifndef HAVE_LIBUDEV
 437                 __attribute__((__unused__))
 438 #endif
 439                 )
 440 {
 441         const char *t, *v;
 442         char *res = NULL;
 443
 444         if (!mnt_fs_get_tag(fs, &t, &v) && !strcmp(t, tagname))
 445                 res = xstrdup(v);
 446         else {
 447                 const char *dev = mnt_fs_get_source(fs);
 448
 449                 if (dev && !(flags & FL_NOCACHE))
 450                         dev = mnt_resolve_spec(dev, cache);
 451 #ifdef HAVE_LIBUDEV
 452                 if (dev)
 453                         res = get_tag_from_udev(dev, col);
 454 #endif
 455                 if (!res) {
 456                         res = mnt_cache_find_tag_value(cache, dev, tagname);
 457                         if (res && cache)
 458                                 /* don't return pointer to cache */
 459                                 res = xstrdup(res);
 460                 }
 461         }
 462
 463         return res;
 464 }
 465
 466 static char *get_vfs_attr(struct libmnt_fs *fs, int sizetype)
 467 {
 468         struct statvfs buf;
 469         uint64_t vfs_attr = 0;
 470         char *sizestr;
 471
 472         if (statvfs(mnt_fs_get_target(fs), &buf) != 0)
 473                 return NULL;
 474
 475         switch(sizetype) {
 476         case COL_SIZE:
 477                 vfs_attr = buf.f_frsize * buf.f_blocks;
 478                 break;
 479         case COL_AVAIL:
 480                 vfs_attr = buf.f_frsize * buf.f_bavail;
 481                 break;
 482         case COL_USED:
 483                 vfs_attr = buf.f_frsize * (buf.f_blocks - buf.f_bfree);
 484                 break;
 485         case COL_USEPERC:
 486                 if (buf.f_blocks == 0)
 487                         return xstrdup("-");
 488
 489                 xasprintf(&sizestr, "%.0f%%",
 490                                 (double)(buf.f_blocks - buf.f_bfree) /
 491                                 buf.f_blocks * 100);
 492                 return sizestr;
 493         }
 494
 495         if (!vfs_attr)
 496                 sizestr = xstrdup("0");
 497         else if (flags & FL_BYTES)
 498                 xasprintf(&sizestr, "%ju", vfs_attr);
 499         else
 500                 sizestr = size_to_human_string(SIZE_SUFFIX_1LETTER, vfs_attr);
 501
 502         return sizestr;
 503 }
 504
 505 /* reads FS data from libmount
 506  */
 507 static char *get_data(struct libmnt_fs *fs, int num)
 508 {
 509         char *str = NULL;
 510         int col_id = get_column_id(num);
 511
 512         switch (col_id) {
 513         case COL_SOURCE:
 514         {
 515                 const char *root = mnt_fs_get_root(fs);
 516                 const char *spec = mnt_fs_get_srcpath(fs);
 517                 char *cn = NULL;
 518
 519                 if (spec && (flags & FL_CANONICALIZE))
 520                         spec = cn = mnt_resolve_path(spec, cache);
 521                 if (!spec) {
 522                         spec = mnt_fs_get_source(fs);
 523
 524                         if (spec && (flags & FL_EVALUATE))
 525                                 spec = cn = mnt_resolve_spec(spec, cache);
 526                 }
 527                 if (root && spec && !(flags & FL_NOFSROOT) && strcmp(root, "/"))
 528                         xasprintf(&str, "%s[%s]", spec, root);
 529                 else if (spec)
 530                         str = xstrdup(spec);
 531                 if (!cache)
 532                         free(cn);
 533                 break;
 534         }
 535         case COL_TARGET:
 536                 str = xstrdup(mnt_fs_get_target(fs));
 537                 break;
 538         case COL_FSTYPE:
 539                 str = xstrdup(mnt_fs_get_fstype(fs));
 540                 break;
 541         case COL_OPTIONS:
 542                 str = xstrdup(mnt_fs_get_options(fs));
 543                 break;
 544         case COL_VFS_OPTIONS:
 545                 str = xstrdup(mnt_fs_get_vfs_options(fs));
 546                 break;
 547         case COL_FS_OPTIONS:
 548                 str = xstrdup(mnt_fs_get_fs_options(fs));
 549                 break;
 550         case COL_OPT_FIELDS:
 551                 str = xstrdup(mnt_fs_get_optional_fields(fs));
 552                 break;
 553         case COL_UUID:
 554                 str = get_tag(fs, "UUID", col_id);
 555                 break;
 556         case COL_PARTUUID:
 557                 str = get_tag(fs, "PARTUUID", col_id);
 558                 break;
 559         case COL_LABEL:
 560                 str = get_tag(fs, "LABEL", col_id);
 561                 break;
 562         case COL_PARTLABEL:
 563                 str = get_tag(fs, "PARTLABEL", col_id);
 564                 break;
 565
 566         case COL_MAJMIN:
 567         {
 568                 dev_t devno = mnt_fs_get_devno(fs);
 569                 if (!devno)
 570                         break;
 571
 572                 if ((flags & FL_RAW) || (flags & FL_EXPORT) || (flags & FL_JSON))
 573                         xasprintf(&str, "%u:%u", major(devno), minor(devno));
 574                 else
 575                         xasprintf(&str, "%3u:%-3u", major(devno), minor(devno));
 576                 break;
 577         }
 578         case COL_SIZE:
 579         case COL_AVAIL:
 580         case COL_USED:
 581         case COL_USEPERC:
 582                 str = get_vfs_attr(fs, col_id);
 583                 break;
 584         case COL_FSROOT:
 585                 str = xstrdup(mnt_fs_get_root(fs));
 586                 break;
 587         case COL_TID:
 588                 if (mnt_fs_get_tid(fs))
 589                         xasprintf(&str, "%d", mnt_fs_get_tid(fs));
 590                 break;
 591         case COL_ID:
 592                 if (mnt_fs_get_id(fs))
 593                         xasprintf(&str, "%d", mnt_fs_get_id(fs));
 594                 break;
 595         case COL_PROPAGATION:
 596                 if (mnt_fs_is_kernel(fs)) {
 597                         unsigned long fl = 0;
 598                         char *n = NULL;
 599
 600                         if (mnt_fs_get_propagation(fs, &fl) != 0)
 601                                 break;
 602
 603                         n = xstrdup((fl & MS_SHARED) ? "shared" : "private");
 604
 605                         if (fl & MS_SLAVE) {
 606                                 xasprintf(&str, "%s,slave", n);
 607                                 free(n);
 608                                 n = str;
 609                         }
 610                         if (fl & MS_UNBINDABLE) {
 611                                 xasprintf(&str, "%s,unbindable", n);
 612                                 free(n);
 613                                 n = str;
 614                         }
 615                         str = n;
 616                 }
 617                 break;
 618         case COL_FREQ:
 619                 if (!mnt_fs_is_kernel(fs))
 620                         xasprintf(&str, "%d", mnt_fs_get_freq(fs));
 621                 break;
 622         case COL_PASSNO:
 623                 if (!mnt_fs_is_kernel(fs))
 624                         xasprintf(&str, "%d", mnt_fs_get_passno(fs));
 625                 break;
 626         default:
 627                 break;
 628         }
 629         return str;
 630 }
 631
 632 static char *get_tabdiff_data(struct libmnt_fs *old_fs,
 633                                     struct libmnt_fs *new_fs,
 634                                     int change,
 635                                     int num)
 636 {
 637         char *str = NULL;
 638
 639         switch (get_column_id(num)) {
 640         case COL_ACTION:
 641                 switch (change) {
 642                 case MNT_TABDIFF_MOUNT:
 643                         str = _("mount");
 644                         break;
 645                 case MNT_TABDIFF_UMOUNT:
 646                         str = _("umount");
 647                         break;
 648                 case MNT_TABDIFF_REMOUNT:
 649                         str = _("remount");
 650                         break;
 651                 case MNT_TABDIFF_MOVE:
 652                         str = _("move");
 653                         break;
 654                 default:
 655                         str = _("unknown");
 656                         break;
 657                 }
 658                 str = xstrdup(str);
 659                 break;
 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));
 664                 break;
 665         case COL_OLD_TARGET:
 666                 if (old_fs && (change == MNT_TABDIFF_MOVE ||
 667                                change == MNT_TABDIFF_UMOUNT))
 668                         str = xstrdup(mnt_fs_get_target(old_fs));
 669                 break;
 670         default:
 671                 if (new_fs)
 672                         str = get_data(new_fs, num);
 673                 else
 674                         str = get_data(old_fs, num);
 675                 break;
 676         }
 677         return str;
 678 }
 679
 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)
 683 {
 684         size_t i;
 685         struct libscols_line *line = scols_table_new_line(table, parent);
 686
 687         if (!line)
 688                 err(EXIT_FAILURE, _("failed to allocate output line"));
 689
 690         for (i = 0; i < ncolumns; i++) {
 691                 if (scols_line_refer_data(line, i, get_data(fs, i)))
 692                         err(EXIT_FAILURE, _("failed to add output data"));
 693         }
 694
 695         scols_line_set_userdata(line, fs);
 696         return line;
 697 }
 698
 699 static struct libscols_line *add_tabdiff_line(struct libscols_table *table, struct libmnt_fs *new_fs,
 700                         struct libmnt_fs *old_fs, int change)
 701 {
 702         size_t i;
 703         struct libscols_line *line = scols_table_new_line(table, NULL);
 704
 705         if (!line)
 706                 err(EXIT_FAILURE, _("failed to allocate output line"));
 707
 708         for (i = 0; i < ncolumns; i++) {
 709                 if (scols_line_refer_data(line, i,
 710                                 get_tabdiff_data(old_fs, new_fs, change, i)))
 711                         err(EXIT_FAILURE, _("failed to add output data"));
 712         }
 713
 714         return line;
 715 }
 716
 717 static int has_line(struct libscols_table *table, struct libmnt_fs *fs)
 718 {
 719         struct libscols_line *ln;
 720         struct libscols_iter *itr;
 721         int rc = 0;
 722
 723         itr = scols_new_iter(SCOLS_ITER_FORWARD);
 724         if (!itr)
 725                 return 0;
 726
 727         while (scols_table_next_line(table, itr, &ln) == 0) {
 728                 if ((struct libmnt_fs *) scols_line_get_userdata(ln) == fs) {
 729                         rc = 1;
 730                         break;
 731                 }
 732         }
 733
 734         scols_free_iter(itr);
 735         return rc;
 736 }
 737
 738 /* reads filesystems from @tb (libmount) and fillin @table (output table) */
 739 static int create_treenode(struct libscols_table *table, struct libmnt_table *tb,
 740                            struct libmnt_fs *fs, struct libscols_line *parent_line)
 741 {
 742         struct libmnt_fs *chld = NULL;
 743         struct libmnt_iter *itr = NULL;
 744         struct libscols_line *line;
 745         int rc = -1;
 746
 747         if (!fs) {
 748                 /* first call, get root FS */
 749                 if (mnt_table_get_root_fs(tb, &fs))
 750                         goto leave;
 751                 parent_line = NULL;
 752
 753         } else if ((flags & FL_SUBMOUNTS) && has_line(table, fs))
 754                 return 0;
 755
 756         itr = mnt_new_iter(MNT_ITER_FORWARD);
 757         if (!itr)
 758                 goto leave;
 759
 760         if ((flags & FL_SUBMOUNTS) || match_func(fs, NULL)) {
 761                 line = add_line(table, fs, parent_line);
 762                 if (!line)
 763                         goto leave;
 764         } else
 765                 line = parent_line;
 766
 767         /*
 768          * add all children to the output table
 769          */
 770         while(mnt_table_next_child_fs(tb, itr, fs, &chld) == 0) {
 771                 if (create_treenode(table, tb, chld, line))
 772                         goto leave;
 773         }
 774         rc = 0;
 775 leave:
 776         mnt_free_iter(itr);
 777         return rc;
 778 }
 779
 780 /* error callback */
 781 static int parser_errcb(struct libmnt_table *tb __attribute__ ((__unused__)),
 782                         const char *filename, int line)
 783 {
 784         warnx(_("%s: parse error at line %d -- ignored"), filename, line);
 785         ++parse_nerrors;
 786         return 1;
 787 }
 788
 789 static char **append_tabfile(char **files, int *nfiles, char *filename)
 790 {
 791         files = xrealloc(files, sizeof(char *) * (*nfiles + 1));
 792         files[(*nfiles)++] = filename;
 793         return files;
 794 }
 795
 796 static char **append_pid_tabfile(char **files, int *nfiles, pid_t pid)
 797 {
 798         char *path = NULL;
 799
 800         xasprintf(&path, "/proc/%d/mountinfo", (int) pid);
 801         return append_tabfile(files, nfiles, path);
 802 }
 803
 804 /* calls libmount fstab/mtab/mountinfo parser */
 805 static struct libmnt_table *parse_tabfiles(char **files,
 806                                            int nfiles,
 807                                            int tabtype)
 808 {
 809         struct libmnt_table *tb;
 810         int rc = 0;
 811
 812         tb = mnt_new_table();
 813         if (!tb) {
 814                 warn(_("failed to initialize libmount table"));
 815                 return NULL;
 816         }
 817         mnt_table_set_parser_errcb(tb, parser_errcb);
 818
 819         do {
 820                 /* NULL means that libmount will use default paths */
 821                 const char *path = nfiles ? *files++ : NULL;
 822
 823                 switch (tabtype) {
 824                 case TABTYPE_FSTAB:
 825                         rc = mnt_table_parse_fstab(tb, path);
 826                         break;
 827                 case TABTYPE_MTAB:
 828                         rc = mnt_table_parse_mtab(tb, path);
 829                         break;
 830                 case TABTYPE_KERNEL:
 831                         if (!path)
 832                                 path = access(_PATH_PROC_MOUNTINFO, R_OK) == 0 ?
 833                                               _PATH_PROC_MOUNTINFO :
 834                                               _PATH_PROC_MOUNTS;
 835
 836                         rc = mnt_table_parse_file(tb, path);
 837                         break;
 838                 }
 839                 if (rc) {
 840                         mnt_unref_table(tb);
 841                         warn(_("can't read %s"), path);
 842                         return NULL;
 843                 }
 844         } while (--nfiles > 0);
 845
 846         return tb;
 847 }
 848
 849 /*
 850  * Parses mountinfo and calls mnt_cache_set_targets(cache, mtab). Only
 851  * necessary if @tb in main() was read from a non-kernel source.
 852  */
 853 static void cache_set_targets(struct libmnt_cache *tmp)
 854 {
 855         struct libmnt_table *tb;
 856         const char *path;
 857
 858         tb = mnt_new_table();
 859         if (!tb)
 860                 return;
 861
 862         path = access(_PATH_PROC_MOUNTINFO, R_OK) == 0 ?
 863                 _PATH_PROC_MOUNTINFO :
 864                 _PATH_PROC_MOUNTS;
 865
 866         if (mnt_table_parse_file(tb, path) == 0)
 867                 mnt_cache_set_targets(tmp, tb);
 868
 869         mnt_unref_table(tb);
 870 }
 871
 872 /* checks if @tb contains parent->child relations */
 873 static int tab_is_tree(struct libmnt_table *tb)
 874 {
 875         struct libmnt_fs *fs = NULL;
 876         struct libmnt_iter *itr;
 877         int rc = 0;
 878
 879         itr = mnt_new_iter(MNT_ITER_BACKWARD);
 880         if (!itr)
 881                 return 0;
 882
 883         rc = (mnt_table_next_fs(tb, itr, &fs) == 0 &&
 884               mnt_fs_is_kernel(fs) &&
 885               mnt_fs_get_root(fs));
 886
 887         mnt_free_iter(itr);
 888         return rc;
 889 }
 890
 891 /* checks if all fs in @tb are from kernel */
 892 static int tab_is_kernel(struct libmnt_table *tb)
 893 {
 894         struct libmnt_fs *fs = NULL;
 895         struct libmnt_iter *itr;
 896
 897         itr = mnt_new_iter(MNT_ITER_BACKWARD);
 898         if (!itr)
 899                 return 0;
 900
 901         while (mnt_table_next_fs(tb, itr, &fs) == 0) {
 902                 if (!mnt_fs_is_kernel(fs)) {
 903                         mnt_free_iter(itr);
 904                         return 0;
 905                 }
 906         }
 907
 908         mnt_free_iter(itr);
 909         return 1;
 910 }
 911
 912 /* filter function for libmount (mnt_table_find_next_fs()) */
 913 static int match_func(struct libmnt_fs *fs,
 914                       void *data __attribute__ ((__unused__)))
 915 {
 916         int rc = flags & FL_INVERT ? 1 : 0;
 917         const char *m;
 918         void *md;
 919
 920         m = get_match(COL_FSTYPE);
 921         if (m && !mnt_fs_match_fstype(fs, m))
 922                 return rc;
 923
 924         m = get_match(COL_OPTIONS);
 925         if (m && !mnt_fs_match_options(fs, m))
 926                 return rc;
 927
 928         md = get_match_data(COL_MAJMIN);
 929         if (md && mnt_fs_get_devno(fs) != *((dev_t *) md))
 930                 return rc;
 931
 932         m = get_match(COL_TARGET);
 933         if (m && !mnt_fs_match_target(fs, m, cache))
 934                 return rc;
 935
 936         m = get_match(COL_SOURCE);
 937         if (m && !mnt_fs_match_source(fs, m, cache))
 938                 return rc;
 939
 940         if ((flags & FL_DF) && !(flags & FL_ALL)) {
 941                 const char *type = mnt_fs_get_fstype(fs);
 942
 943                 if (type && strstr(type, "tmpfs"))      /* tmpfs is wanted */
 944                         return !rc;
 945
 946                 if (mnt_fs_is_pseudofs(fs))
 947                         return rc;
 948         }
 949
 950         return !rc;
 951 }
 952
 953 /* iterate over filesystems in @tb */
 954 struct libmnt_fs *get_next_fs(struct libmnt_table *tb,
 955                                      struct libmnt_iter *itr)
 956 {
 957         struct libmnt_fs *fs = NULL;
 958
 959         if (is_listall_mode()) {
 960                 /*
 961                  * Print whole file
 962                  */
 963                 if (mnt_table_next_fs(tb, itr, &fs) != 0)
 964                         return NULL;
 965
 966         } else if (is_mount_compatible_mode()) {
 967                 /*
 968                  * Look up for FS in the same way how mount(8) searches in fstab
 969                  *
 970                  *   findmnt -f <spec>
 971                  */
 972                 fs = mnt_table_find_source(tb, get_match(COL_SOURCE),
 973                                         mnt_iter_get_direction(itr));
 974
 975                 if (!fs && !(flags & FL_NOSWAPMATCH))
 976                         fs = mnt_table_find_target(tb, get_match(COL_SOURCE),
 977                                         mnt_iter_get_direction(itr));
 978         } else {
 979                 /*
 980                  * Look up for all matching entries
 981                  *
 982                  *    findmnt [-l] <source> <target> [-O <options>] [-t <types>]
 983                  *    findmnt [-l] <spec> [-O <options>] [-t <types>]
 984                  */
 985 again:
 986                 mnt_table_find_next_fs(tb, itr, match_func,  NULL, &fs);
 987
 988                 if (!fs &&
 989                     !(flags & FL_NOSWAPMATCH) &&
 990                     !get_match(COL_TARGET) && get_match(COL_SOURCE)) {
 991
 992                         /* swap 'spec' and target. */
 993                         set_match(COL_TARGET, get_match(COL_SOURCE));
 994                         set_match(COL_SOURCE, NULL);
 995                         mnt_reset_iter(itr, -1);
 996
 997                         goto again;
 998                 }
 999         }
1000
1001         return fs;
1002 }
1003
1004 /*
1005  * Filter out unwanted lines for --list output or top level lines for
1006  * --submounts tree output.
1007  */
1008 static int add_matching_lines(struct libmnt_table *tb,
1009                               struct libscols_table *table, int direction)
1010 {
1011         struct libmnt_iter *itr;
1012         struct libmnt_fs *fs;
1013         int nlines = 0, rc = -1;
1014
1015         itr = mnt_new_iter(direction);
1016         if (!itr) {
1017                 warn(_("failed to initialize libmount iterator"));
1018                 goto done;
1019         }
1020
1021         while((fs = get_next_fs(tb, itr))) {
1022                 if ((flags & FL_TREE) || (flags & FL_SUBMOUNTS))
1023                         rc = create_treenode(table, tb, fs, NULL);
1024                 else
1025                         rc = !add_line(table, fs, NULL);
1026                 if (rc)
1027                         goto done;
1028                 nlines++;
1029                 if (flags & FL_FIRSTONLY)
1030                         break;
1031                 flags |= FL_NOSWAPMATCH;
1032         }
1033
1034         if (nlines)
1035                 rc = 0;
1036 done:
1037         mnt_free_iter(itr);
1038         return rc;
1039 }
1040
1041 static int poll_match(struct libmnt_fs *fs)
1042 {
1043         int rc = match_func(fs, NULL);
1044
1045         if (rc == 0 && !(flags & FL_NOSWAPMATCH) &&
1046             get_match(COL_SOURCE) && !get_match(COL_TARGET)) {
1047                 /*
1048                  * findmnt --poll /foo
1049                  * The '/foo' maybe source as well as target.
1050                  */
1051                 const char *str = get_match(COL_SOURCE);
1052
1053                 set_match(COL_TARGET, str);     /* swap */
1054                 set_match(COL_SOURCE, NULL);
1055
1056                 rc = match_func(fs, NULL);
1057
1058                 set_match(COL_TARGET, NULL);    /* restore */
1059                 set_match(COL_SOURCE, str);
1060
1061         }
1062         return rc;
1063 }
1064
1065 static int poll_table(struct libmnt_table *tb, const char *tabfile,
1066                   int timeout, struct libscols_table *table, int direction)
1067 {
1068         FILE *f = NULL;
1069         int rc = -1;
1070         struct libmnt_iter *itr = NULL;
1071         struct libmnt_table *tb_new;
1072         struct libmnt_tabdiff *diff = NULL;
1073         struct pollfd fds[1];
1074
1075         tb_new = mnt_new_table();
1076         if (!tb_new) {
1077                 warn(_("failed to initialize libmount table"));
1078                 goto done;
1079         }
1080
1081         itr = mnt_new_iter(direction);
1082         if (!itr) {
1083                 warn(_("failed to initialize libmount iterator"));
1084                 goto done;
1085         }
1086
1087         diff = mnt_new_tabdiff();
1088         if (!diff) {
1089                 warn(_("failed to initialize libmount tabdiff"));
1090                 goto done;
1091         }
1092
1093         /* cache is unnecessary to detect changes */
1094         mnt_table_set_cache(tb, NULL);
1095         mnt_table_set_cache(tb_new, NULL);
1096
1097         f = fopen(tabfile, "r");
1098         if (!f) {
1099                 warn(_("cannot open %s"), tabfile);
1100                 goto done;
1101         }
1102
1103         mnt_table_set_parser_errcb(tb_new, parser_errcb);
1104
1105         fds[0].fd = fileno(f);
1106         fds[0].events = POLLPRI;
1107
1108         while (1) {
1109                 struct libmnt_table *tmp;
1110                 struct libmnt_fs *old, *new;
1111                 int change, count;
1112
1113                 count = poll(fds, 1, timeout);
1114                 if (count == 0)
1115                         break;  /* timeout */
1116                 if (count < 0) {
1117                         warn(_("poll() failed"));
1118                         goto done;
1119                 }
1120
1121                 rewind(f);
1122                 rc = mnt_table_parse_stream(tb_new, f, tabfile);
1123                 if (!rc)
1124                         rc = mnt_diff_tables(diff, tb, tb_new);
1125                 if (rc < 0)
1126                         goto done;
1127
1128                 count = 0;
1129                 mnt_reset_iter(itr, direction);
1130                 while(mnt_tabdiff_next_change(
1131                                 diff, itr, &old, &new, &change) == 0) {
1132
1133                         if (!has_poll_action(change))
1134                                 continue;
1135                         if (!poll_match(new ? new : old))
1136                                 continue;
1137                         count++;
1138                         rc = !add_tabdiff_line(table, new, old, change);
1139                         if (rc)
1140                                 goto done;
1141                         if (flags & FL_FIRSTONLY)
1142                                 break;
1143                 }
1144
1145                 if (count) {
1146                         rc = scols_table_print_range(table, NULL, NULL);
1147                         if (rc == 0)
1148                                 fputc('\n', scols_table_get_stream(table));
1149                         fflush(stdout);
1150                         if (rc)
1151                                 goto done;
1152                 }
1153
1154                 /* swap tables */
1155                 tmp = tb;
1156                 tb = tb_new;
1157                 tb_new = tmp;
1158
1159                 /* remove already printed lines to reduce memory usage */
1160                 scols_table_remove_lines(table);
1161                 mnt_reset_table(tb_new);
1162
1163                 if (count && (flags & FL_FIRSTONLY))
1164                         break;
1165         }
1166
1167         rc = 0;
1168 done:
1169         mnt_unref_table(tb_new);
1170         mnt_free_tabdiff(diff);
1171         mnt_free_iter(itr);
1172         if (f)
1173                 fclose(f);
1174         return rc;
1175 }
1176
1177 static int uniq_fs_target_cmp(
1178                 struct libmnt_table *tb __attribute__((__unused__)),
1179                 struct libmnt_fs *a,
1180                 struct libmnt_fs *b)
1181 {
1182         return !mnt_fs_match_target(a, mnt_fs_get_target(b), cache);
1183 }
1184
1185 static void __attribute__((__noreturn__)) usage(void)
1186 {
1187         FILE *out = stdout;
1188         size_t i;
1189
1190         fputs(USAGE_HEADER, out);
1191         fprintf(out, _(
1192         " %1$s [options]\n"
1193         " %1$s [options] <device> | <mountpoint>\n"
1194         " %1$s [options] <device> <mountpoint>\n"
1195         " %1$s [options] [--source <device>] [--target <path> | --mountpoint <dir>]\n"),
1196                 program_invocation_short_name);
1197
1198         fputs(USAGE_SEPARATOR, out);
1199         fputs(_("Find a (mounted) filesystem.\n"), out);
1200
1201         fputs(USAGE_OPTIONS, out);
1202         fputs(_(" -s, --fstab            search in static table of filesystems\n"), out);
1203         fputs(_(" -m, --mtab             search in table of mounted filesystems\n"
1204                 "                          (includes user space mount options)\n"), out);
1205         fputs(_(" -k, --kernel           search in kernel table of mounted\n"
1206                 "                          filesystems (default)\n"), out);
1207         fputc('\n', out);
1208         fputs(_(" -p, --poll[=<list>]    monitor changes in table of mounted filesystems\n"), out);
1209         fputs(_(" -w, --timeout <num>    upper limit in milliseconds that --poll will block\n"), out);
1210         fputc('\n', out);
1211
1212         fputs(_(" -A, --all              disable all built-in filters, print all filesystems\n"), out);
1213         fputs(_(" -a, --ascii            use ASCII chars for tree formatting\n"), out);
1214         fputs(_(" -b, --bytes            print sizes in bytes rather than in human readable format\n"), out);
1215         fputs(_(" -C, --nocanonicalize   don't canonicalize when comparing paths\n"), out);
1216         fputs(_(" -c, --canonicalize     canonicalize printed paths\n"), out);
1217         fputs(_(" -D, --df               imitate the output of df(1)\n"), out);
1218         fputs(_(" -d, --direction <word> direction of search, 'forward' or 'backward'\n"), out);
1219         fputs(_(" -e, --evaluate         convert tags (LABEL,UUID,PARTUUID,PARTLABEL) \n"
1220                 "                          to device names\n"), out);
1221         fputs(_(" -F, --tab-file <path>  alternative file for -s, -m or -k options\n"), out);
1222         fputs(_(" -f, --first-only       print the first found filesystem only\n"), out);
1223         fputs(_(" -i, --invert           invert the sense of matching\n"), out);
1224         fputs(_(" -J, --json             use JSON output format\n"), out);
1225         fputs(_(" -l, --list             use list format output\n"), out);
1226         fputs(_(" -N, --task <tid>       use alternative namespace (/proc/<tid>/mountinfo file)\n"), out);
1227         fputs(_(" -n, --noheadings       don't print column headings\n"), out);
1228         fputs(_(" -O, --options <list>   limit the set of filesystems by mount options\n"), out);
1229         fputs(_(" -o, --output <list>    the output columns to be shown\n"), out);
1230         fputs(_(" -P, --pairs            use key=\"value\" output format\n"), out);
1231         fputs(_(" -R, --submounts        print all submounts for the matching filesystems\n"), out);
1232         fputs(_(" -r, --raw              use raw output format\n"), out);
1233         fputs(_(" -S, --source <string>  the device to mount (by name, maj:min, \n"
1234                 "                          LABEL=, UUID=, PARTUUID=, PARTLABEL=)\n"), out);
1235         fputs(_(" -T, --target <path>    the path to the filesystem to use\n"), out);
1236         fputs(_("     --tree             enable tree format output is possible\n"), out);
1237         fputs(_(" -M, --mountpoint <dir> the mountpoint directory\n"), out);
1238         fputs(_(" -t, --types <list>     limit the set of filesystems by FS types\n"), out);
1239         fputs(_(" -U, --uniq             ignore filesystems with duplicate target\n"), out);
1240         fputs(_(" -u, --notruncate       don't truncate text in columns\n"), out);
1241         fputs(_(" -v, --nofsroot         don't print [/dir] for bind or btrfs mounts\n"), out);
1242
1243         fputc('\n', out);
1244         fputs(_(" -x, --verify           verify mount table content (default is fstab)\n"), out);
1245         fputs(_("     --verbose          print more details\n"), out);
1246         fputc('\n', out);
1247
1248         fputs(USAGE_SEPARATOR, out);
1249         fputs(USAGE_HELP, out);
1250         fputs(USAGE_VERSION, out);
1251
1252         fputs(USAGE_COLUMNS, out);
1253         for (i = 0; i < ARRAY_SIZE(infos); i++)
1254                 fprintf(out, " %11s  %s\n", infos[i].name, _(infos[i].help));
1255
1256         fprintf(out, USAGE_MAN_TAIL("findmnt(8)"));
1257
1258         exit(EXIT_SUCCESS);
1259 }
1260
1261 int main(int argc, char *argv[])
1262 {
1263         struct libmnt_table *tb = NULL;
1264         char **tabfiles = NULL;
1265         int direction = MNT_ITER_FORWARD;
1266         int verify = 0;
1267         int c, rc = -1, timeout = -1;
1268         int ntabfiles = 0, tabtype = 0;
1269         char *outarg = NULL;
1270         size_t i;
1271         int force_tree = 0, istree = 0;
1272
1273         struct libscols_table *table = NULL;
1274
1275         enum {
1276                 FINDMNT_OPT_VERBOSE = CHAR_MAX + 1,
1277                 FINDMNT_OPT_TREE
1278         };
1279
1280         static const struct option longopts[] = {
1281                 { "all",            no_argument,       NULL, 'A'                 },
1282                 { "ascii",          no_argument,       NULL, 'a'                 },
1283                 { "bytes",          no_argument,       NULL, 'b'                 },
1284                 { "canonicalize",   no_argument,       NULL, 'c'                 },
1285                 { "direction",      required_argument, NULL, 'd'                 },
1286                 { "df",             no_argument,       NULL, 'D'                 },
1287                 { "evaluate",       no_argument,       NULL, 'e'                 },
1288                 { "first-only",     no_argument,       NULL, 'f'                 },
1289                 { "fstab",          no_argument,       NULL, 's'                 },
1290                 { "help",           no_argument,       NULL, 'h'                 },
1291                 { "invert",         no_argument,       NULL, 'i'                 },
1292                 { "json",           no_argument,       NULL, 'J'                 },
1293                 { "kernel",         no_argument,       NULL, 'k'                 },
1294                 { "list",           no_argument,       NULL, 'l'                 },
1295                 { "mountpoint",     required_argument, NULL, 'M'                 },
1296                 { "mtab",           no_argument,       NULL, 'm'                 },
1297                 { "noheadings",     no_argument,       NULL, 'n'                 },
1298                 { "notruncate",     no_argument,       NULL, 'u'                 },
1299                 { "options",        required_argument, NULL, 'O'                 },
1300                 { "output",         required_argument, NULL, 'o'                 },
1301                 { "poll",           optional_argument, NULL, 'p'                 },
1302                 { "pairs",          no_argument,       NULL, 'P'                 },
1303                 { "raw",            no_argument,       NULL, 'r'                 },
1304                 { "types",          required_argument, NULL, 't'                 },
1305                 { "nocanonicalize", no_argument,       NULL, 'C'                 },
1306                 { "nofsroot",       no_argument,       NULL, 'v'                 },
1307                 { "submounts",      no_argument,       NULL, 'R'                 },
1308                 { "source",         required_argument, NULL, 'S'                 },
1309                 { "tab-file",       required_argument, NULL, 'F'                 },
1310                 { "task",           required_argument, NULL, 'N'                 },
1311                 { "target",         required_argument, NULL, 'T'                 },
1312                 { "timeout",        required_argument, NULL, 'w'                 },
1313                 { "uniq",           no_argument,       NULL, 'U'                 },
1314                 { "verify",         no_argument,       NULL, 'x'                 },
1315                 { "version",        no_argument,       NULL, 'V'                 },
1316                 { "verbose",        no_argument,       NULL, FINDMNT_OPT_VERBOSE },
1317                 { "tree",           no_argument,       NULL, FINDMNT_OPT_TREE    },
1318                 { NULL, 0, NULL, 0 }
1319         };
1320
1321         static const ul_excl_t excl[] = {       /* rows and cols in ASCII order */
1322                 { 'C', 'c'},                    /* [no]canonicalize */
1323                 { 'C', 'e' },                   /* nocanonicalize, evaluate */
1324                 { 'J', 'P', 'r','x' },          /* json,pairs,raw,verify */
1325                 { 'M', 'T' },                   /* mountpoint, target */
1326                 { 'N','k','m','s' },            /* task,kernel,mtab,fstab */
1327                 { 'P','l','r','x' },            /* pairs,list,raw,verify */
1328                 { 'p','x' },                    /* poll,verify */
1329                 { 'm','p','s' },                /* mtab,poll,fstab */
1330                 { 0 }
1331         };
1332         int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
1333
1334         setlocale(LC_ALL, "");
1335         bindtextdomain(PACKAGE, LOCALEDIR);
1336         textdomain(PACKAGE);
1337         atexit(close_stdout);
1338
1339         /* default output format */
1340         flags |= FL_TREE;
1341
1342         while ((c = getopt_long(argc, argv,
1343                                 "AabCcDd:ehiJfF:o:O:p::PklmM:nN:rst:uvRS:T:Uw:Vx",
1344                                 longopts, NULL)) != -1) {
1345
1346                 err_exclusive_options(c, longopts, excl, excl_st);
1347
1348                 switch(c) {
1349                 case 'A':
1350                         flags |= FL_ALL;
1351                         break;
1352                 case 'a':
1353                         flags |= FL_ASCII;
1354                         break;
1355                 case 'b':
1356                         flags |= FL_BYTES;
1357                         break;
1358                 case 'C':
1359                         flags |= FL_NOCACHE;
1360                         break;
1361                 case 'c':
1362                         flags |= FL_CANONICALIZE;
1363                         break;
1364                 case 'D':
1365                         flags &= ~FL_TREE;
1366                         flags |= FL_DF;
1367                         break;
1368                 case 'd':
1369                         if (!strcmp(optarg, "forward"))
1370                                 direction = MNT_ITER_FORWARD;
1371                         else if (!strcmp(optarg, "backward"))
1372                                 direction = MNT_ITER_BACKWARD;
1373                         else
1374                                 errx(EXIT_FAILURE,
1375                                         _("unknown direction '%s'"), optarg);
1376                         break;
1377                 case 'e':
1378                         flags |= FL_EVALUATE;
1379                         break;
1380                 case 'h':
1381                         usage();
1382                         break;
1383                 case 'i':
1384                         flags |= FL_INVERT;
1385                         break;
1386                 case 'J':
1387                         flags |= FL_JSON;
1388                         break;
1389                 case 'f':
1390                         flags |= FL_FIRSTONLY;
1391                         break;
1392                 case 'F':
1393                         tabfiles = append_tabfile(tabfiles, &ntabfiles, optarg);
1394                         break;
1395                 case 'u':
1396                         disable_columns_truncate();
1397                         break;
1398                 case 'o':
1399                         outarg = optarg;
1400                         break;
1401                 case 'O':
1402                         set_match(COL_OPTIONS, optarg);
1403                         break;
1404                 case 'p':
1405                         if (optarg) {
1406                                 nactions = string_to_idarray(optarg,
1407                                                 actions, ARRAY_SIZE(actions),
1408                                                 poll_action_name_to_id);
1409                                 if (nactions < 0)
1410                                         exit(EXIT_FAILURE);
1411                         }
1412                         flags |= FL_POLL;
1413                         flags &= ~FL_TREE;
1414                         break;
1415                 case 'P':
1416                         flags |= FL_EXPORT;
1417                         flags &= ~FL_TREE;
1418                         break;
1419                 case 'm':               /* mtab */
1420                         tabtype = TABTYPE_MTAB;
1421                         flags &= ~FL_TREE;
1422                         break;
1423                 case 's':               /* fstab */
1424                         tabtype = TABTYPE_FSTAB;
1425                         flags &= ~FL_TREE;
1426                         break;
1427                 case 'k':               /* kernel (mountinfo) */
1428                         tabtype = TABTYPE_KERNEL;
1429                         break;
1430                 case 't':
1431                         set_match(COL_FSTYPE, optarg);
1432                         break;
1433                 case 'r':
1434                         flags &= ~FL_TREE;      /* disable the default */
1435                         flags |= FL_RAW;        /* enable raw */
1436                         break;
1437                 case 'l':
1438                         flags &= ~FL_TREE;      /* disable the default */
1439                         break;
1440                 case 'n':
1441                         flags |= FL_NOHEADINGS;
1442                         break;
1443                 case 'N':
1444                         tabtype = TABTYPE_KERNEL;
1445                         tabfiles = append_pid_tabfile(tabfiles, &ntabfiles,
1446                                         strtou32_or_err(optarg,
1447                                                 _("invalid TID argument")));
1448                         break;
1449                 case 'v':
1450                         flags |= FL_NOFSROOT;
1451                         break;
1452                 case 'R':
1453                         flags |= FL_SUBMOUNTS;
1454                         break;
1455                 case 'S':
1456                         set_source_match(optarg);
1457                         flags |= FL_NOSWAPMATCH;
1458                         break;
1459                 case 'M':
1460                         flags |= FL_STRICTTARGET;
1461                         /* fallthrough */
1462                 case 'T':
1463                         set_match(COL_TARGET, optarg);
1464                         flags |= FL_NOSWAPMATCH;
1465                         break;
1466                 case 'U':
1467                         flags |= FL_UNIQ;
1468                         break;
1469                 case 'w':
1470                         timeout = strtos32_or_err(optarg, _("invalid timeout argument"));
1471                         break;
1472                 case 'V':
1473                         printf(UTIL_LINUX_VERSION);
1474                         return EXIT_SUCCESS;
1475                 case 'x':
1476                         verify = 1;
1477                         break;
1478                 case FINDMNT_OPT_VERBOSE:
1479                         flags |= FL_VERBOSE;
1480                         break;
1481                 case FINDMNT_OPT_TREE:
1482                         force_tree = 1;
1483                         break;
1484                 default:
1485                         errtryhelp(EXIT_FAILURE);
1486                 }
1487         }
1488
1489         if (!ncolumns && (flags & FL_DF)) {
1490                 add_column(columns, ncolumns++, COL_SOURCE);
1491                 add_column(columns, ncolumns++, COL_FSTYPE);
1492                 add_column(columns, ncolumns++, COL_SIZE);
1493                 add_column(columns, ncolumns++, COL_USED);
1494                 add_column(columns, ncolumns++, COL_AVAIL);
1495                 add_column(columns, ncolumns++, COL_USEPERC);
1496                 add_column(columns, ncolumns++, COL_TARGET);
1497         }
1498
1499         /* default columns */
1500         if (!ncolumns) {
1501                 if (flags & FL_POLL)
1502                         add_column(columns, ncolumns++, COL_ACTION);
1503
1504                 add_column(columns, ncolumns++, COL_TARGET);
1505                 add_column(columns, ncolumns++, COL_SOURCE);
1506                 add_column(columns, ncolumns++, COL_FSTYPE);
1507                 add_column(columns, ncolumns++, COL_OPTIONS);
1508         }
1509
1510         if (outarg && string_add_to_idarray(outarg, columns, ARRAY_SIZE(columns),
1511                                          &ncolumns, column_name_to_id) < 0)
1512                 return EXIT_FAILURE;
1513
1514         if (!tabtype)
1515                 tabtype = verify ? TABTYPE_FSTAB : TABTYPE_KERNEL;
1516
1517         if ((flags & FL_POLL) && ntabfiles > 1)
1518                 errx(EXIT_FAILURE, _("--poll accepts only one file, but more specified by --tab-file"));
1519
1520         if (optind < argc && (get_match(COL_SOURCE) || get_match(COL_TARGET)))
1521                 errx(EXIT_FAILURE, _(
1522                         "options --target and --source can't be used together "
1523                         "with command line element that is not an option"));
1524
1525         if (optind < argc)
1526                 set_source_match(argv[optind++]);       /* dev/tag/mountpoint/maj:min */
1527         if (optind < argc)
1528                 set_match(COL_TARGET, argv[optind++]);  /* mountpoint */
1529
1530         if ((flags & FL_SUBMOUNTS) && is_listall_mode())
1531                 /* don't care about submounts if list all mounts */
1532                 flags &= ~FL_SUBMOUNTS;
1533
1534         if (!(flags & FL_SUBMOUNTS) && ((flags & FL_FIRSTONLY)
1535             || get_match(COL_TARGET)
1536             || get_match(COL_SOURCE)
1537             || get_match(COL_MAJMIN)))
1538                 flags &= ~FL_TREE;
1539
1540         if (!(flags & FL_NOSWAPMATCH) &&
1541             !get_match(COL_TARGET) && get_match(COL_SOURCE)) {
1542                 /*
1543                  * Check if we can swap source and target, it's
1544                  * not possible if the source is LABEL=/UUID=
1545                  */
1546                 const char *x = get_match(COL_SOURCE);
1547
1548                 if (!strncmp(x, "LABEL=", 6) || !strncmp(x, "UUID=", 5) ||
1549                     !strncmp(x, "PARTLABEL=", 10) || !strncmp(x, "PARTUUID=", 9))
1550                         flags |= FL_NOSWAPMATCH;
1551         }
1552
1553         /*
1554          * initialize libmount
1555          */
1556         mnt_init_debug(0);
1557
1558         tb = parse_tabfiles(tabfiles, ntabfiles, tabtype);
1559         if (!tb)
1560                 goto leave;
1561
1562         if (tabtype == TABTYPE_MTAB && tab_is_kernel(tb))
1563                 tabtype = TABTYPE_KERNEL;
1564
1565         istree = tab_is_tree(tb);
1566         if (istree && force_tree)
1567                 flags |= FL_TREE;
1568
1569         if ((flags & FL_TREE) && (ntabfiles > 1 || !istree))
1570                 flags &= ~FL_TREE;
1571
1572         if (!(flags & FL_NOCACHE)) {
1573                 cache = mnt_new_cache();
1574                 if (!cache) {
1575                         warn(_("failed to initialize libmount cache"));
1576                         goto leave;
1577                 }
1578                 mnt_table_set_cache(tb, cache);
1579
1580                 if (tabtype != TABTYPE_KERNEL)
1581                         cache_set_targets(cache);
1582         }
1583
1584         if (flags & FL_UNIQ)
1585                 mnt_table_uniq_fs(tb, MNT_UNIQ_KEEPTREE, uniq_fs_target_cmp);
1586
1587         if (verify) {
1588                 rc = verify_table(tb);
1589                 goto leave;
1590         }
1591
1592         /*
1593          * initialize libsmartcols
1594          */
1595         scols_init_debug(0);
1596         table = scols_new_table();
1597         if (!table) {
1598                 warn(_("failed to allocate output table"));
1599                 goto leave;
1600         }
1601         scols_table_enable_raw(table,        !!(flags & FL_RAW));
1602         scols_table_enable_export(table,     !!(flags & FL_EXPORT));
1603         scols_table_enable_json(table,       !!(flags & FL_JSON));
1604         scols_table_enable_ascii(table,      !!(flags & FL_ASCII));
1605         scols_table_enable_noheadings(table, !!(flags & FL_NOHEADINGS));
1606
1607         if (flags & FL_JSON)
1608                 scols_table_set_name(table, "filesystems");
1609
1610         for (i = 0; i < ncolumns; i++) {
1611                 int fl = get_column_flags(i);
1612                 int id = get_column_id(i);
1613
1614                 if (!(flags & FL_TREE))
1615                         fl &= ~SCOLS_FL_TREE;
1616
1617                 if (!(flags & FL_POLL) && is_tabdiff_column(id)) {
1618                         warnx(_("%s column is requested, but --poll "
1619                                "is not enabled"), get_column_name(i));
1620                         goto leave;
1621                 }
1622                 if (!scols_table_new_column(table, get_column_name(i),
1623                                         get_column_whint(i), fl)) {
1624                         warn(_("failed to allocate output column"));
1625                         goto leave;
1626                 }
1627         }
1628
1629         /*
1630          * Fill in data to the output table
1631          */
1632         if (flags & FL_POLL) {
1633                 /* poll mode (accept the first tabfile only) */
1634                 rc = poll_table(tb, tabfiles ? *tabfiles : _PATH_PROC_MOUNTINFO, timeout, table, direction);
1635
1636         } else if ((flags & FL_TREE) && !(flags & FL_SUBMOUNTS)) {
1637                 /* whole tree */
1638                 rc = create_treenode(table, tb, NULL, NULL);
1639         } else {
1640                 /* whole list of sub-tree */
1641                 rc = add_matching_lines(tb, table, direction);
1642
1643                 if (rc != 0
1644                     && tabtype == TABTYPE_KERNEL
1645                     && (flags & FL_NOSWAPMATCH)
1646                     && !(flags & FL_STRICTTARGET)
1647                     && get_match(COL_TARGET)) {
1648                         /*
1649                          * Found nothing, maybe the --target is regular file,
1650                          * try it again with extra functionality for target
1651                          * match
1652                          */
1653                         enable_extra_target_match(tb);
1654                         rc = add_matching_lines(tb, table, direction);
1655                 }
1656         }
1657
1658         /*
1659          * Print the output table for non-poll modes
1660          */
1661         if (!rc && !(flags & FL_POLL))
1662                 scols_print_table(table);
1663 leave:
1664         scols_unref_table(table);
1665
1666         mnt_unref_table(tb);
1667         mnt_unref_cache(cache);
1668
1669         free(tabfiles);
1670 #ifdef HAVE_LIBUDEV
1671         udev_unref(udev);
1672 #endif
1673         return rc ? EXIT_FAILURE : EXIT_SUCCESS;
1674 }