src/mount/mount-tool.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <getopt.h>
   4
   5 #include "sd-bus.h"
   6 #include "sd-device.h"
   7
   8 #include "build.h"
   9 #include "bus-error.h"
  10 #include "bus-locator.h"
  11 #include "bus-unit-util.h"
  12 #include "bus-wait-for-jobs.h"
  13 #include "chase.h"
  14 #include "device-util.h"
  15 #include "dirent-util.h"
  16 #include "escape.h"
  17 #include "fd-util.h"
  18 #include "fileio.h"
  19 #include "format-table.h"
  20 #include "format-util.h"
  21 #include "fs-util.h"
  22 #include "fstab-util.h"
  23 #include "libmount-util.h"
  24 #include "main-func.h"
  25 #include "mount-util.h"
  26 #include "mountpoint-util.h"
  27 #include "pager.h"
  28 #include "parse-argument.h"
  29 #include "parse-util.h"
  30 #include "path-util.h"
  31 #include "pretty-print.h"
  32 #include "process-util.h"
  33 #include "sort-util.h"
  34 #include "spawn-polkit-agent.h"
  35 #include "stat-util.h"
  36 #include "strv.h"
  37 #include "terminal-util.h"
  38 #include "unit-def.h"
  39 #include "unit-name.h"
  40 #include "user-util.h"
  41
  42 enum {
  43         ACTION_DEFAULT,
  44         ACTION_MOUNT,
  45         ACTION_AUTOMOUNT,
  46         ACTION_UMOUNT,
  47         ACTION_LIST,
  48 } arg_action = ACTION_DEFAULT;
  49
  50 static bool arg_no_block = false;
  51 static PagerFlags arg_pager_flags = 0;
  52 static bool arg_legend = true;
  53 static bool arg_full = false;
  54 static bool arg_ask_password = true;
  55 static bool arg_quiet = false;
  56 static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
  57 static RuntimeScope arg_runtime_scope = RUNTIME_SCOPE_SYSTEM;
  58 static const char *arg_host = NULL;
  59 static bool arg_discover = false;
  60 static char *arg_mount_what = NULL;
  61 static char *arg_mount_where = NULL;
  62 static char *arg_mount_type = NULL;
  63 static char *arg_mount_options = NULL;
  64 static char *arg_description = NULL;
  65 static char **arg_property = NULL;
  66 static usec_t arg_timeout_idle = USEC_INFINITY;
  67 static bool arg_timeout_idle_set = false;
  68 static char **arg_automount_property = NULL;
  69 static int arg_bind_device = -1;
  70 static uid_t arg_uid = UID_INVALID;
  71 static gid_t arg_gid = GID_INVALID;
  72 static bool arg_fsck = true;
  73 static bool arg_aggressive_gc = false;
  74
  75 STATIC_DESTRUCTOR_REGISTER(arg_mount_what, freep);
  76 STATIC_DESTRUCTOR_REGISTER(arg_mount_where, freep);
  77 STATIC_DESTRUCTOR_REGISTER(arg_mount_type, freep);
  78 STATIC_DESTRUCTOR_REGISTER(arg_mount_options, freep);
  79 STATIC_DESTRUCTOR_REGISTER(arg_description, freep);
  80 STATIC_DESTRUCTOR_REGISTER(arg_property, strv_freep);
  81 STATIC_DESTRUCTOR_REGISTER(arg_automount_property, strv_freep);
  82
  83 static int help(void) {
  84         _cleanup_free_ char *link = NULL;
  85         int r;
  86
  87         r = terminal_urlify_man("systemd-mount", "1", &link);
  88         if (r < 0)
  89                 return log_oom();
  90
  91         printf("systemd-mount [OPTIONS...] WHAT [WHERE]\n"
  92                "systemd-mount [OPTIONS...] --list\n"
  93                "%s [OPTIONS...] %sWHAT|WHERE...\n\n"
  94                "Establish a mount or auto-mount point transiently.\n\n"
  95                "  -h --help                       Show this help\n"
  96                "     --version                    Show package version\n"
  97                "     --no-block                   Do not wait until operation finished\n"
  98                "     --no-pager                   Do not pipe output into a pager\n"
  99                "     --no-legend                  Do not show the headers\n"
 100                "  -l --full                       Do not ellipsize output\n"
 101                "     --no-ask-password            Do not prompt for password\n"
 102                "  -q --quiet                      Suppress information messages during runtime\n"
 103                "     --user                       Run as user unit\n"
 104                "  -H --host=[USER@]HOST           Operate on remote host\n"
 105                "  -M --machine=CONTAINER          Operate on local container\n"
 106                "     --discover                   Discover mount device metadata\n"
 107                "  -t --type=TYPE                  File system type\n"
 108                "  -o --options=OPTIONS            Mount options\n"
 109                "     --owner=USER                 Add uid= and gid= options for USER\n"
 110                "     --fsck=no                    Don't run file system check before mount\n"
 111                "     --description=TEXT           Description for unit\n"
 112                "  -p --property=NAME=VALUE        Set mount unit property\n"
 113                "  -A --automount=BOOL             Create an auto-mount point\n"
 114                "     --timeout-idle-sec=SEC       Specify automount idle timeout\n"
 115                "     --automount-property=NAME=VALUE\n"
 116                "                                  Set automount unit property\n"
 117                "     --bind-device                Bind automount unit to device\n"
 118                "     --list                       List mountable block devices\n"
 119                "  -u --umount                     Unmount mount points\n"
 120                "  -G --collect                    Unload unit after it stopped, even when failed\n"
 121                "\nSee the %s for details.\n",
 122                program_invocation_short_name,
 123                streq(program_invocation_short_name, "systemd-umount") ? "" : "--umount ",
 124                link);
 125
 126         return 0;
 127 }
 128
 129 static int parse_argv(int argc, char *argv[]) {
 130
 131         enum {
 132                 ARG_VERSION = 0x100,
 133                 ARG_NO_BLOCK,
 134                 ARG_NO_PAGER,
 135                 ARG_NO_LEGEND,
 136                 ARG_NO_ASK_PASSWORD,
 137                 ARG_USER,
 138                 ARG_SYSTEM,
 139                 ARG_DISCOVER,
 140                 ARG_MOUNT_TYPE,
 141                 ARG_MOUNT_OPTIONS,
 142                 ARG_OWNER,
 143                 ARG_FSCK,
 144                 ARG_DESCRIPTION,
 145                 ARG_TIMEOUT_IDLE,
 146                 ARG_AUTOMOUNT,
 147                 ARG_AUTOMOUNT_PROPERTY,
 148                 ARG_BIND_DEVICE,
 149                 ARG_LIST,
 150         };
 151
 152         static const struct option options[] = {
 153                 { "help",               no_argument,       NULL, 'h'                    },
 154                 { "version",            no_argument,       NULL, ARG_VERSION            },
 155                 { "no-block",           no_argument,       NULL, ARG_NO_BLOCK           },
 156                 { "no-pager",           no_argument,       NULL, ARG_NO_PAGER           },
 157                 { "no-legend",          no_argument,       NULL, ARG_NO_LEGEND          },
 158                 { "full",               no_argument,       NULL, 'l'                    },
 159                 { "no-ask-password",    no_argument,       NULL, ARG_NO_ASK_PASSWORD    },
 160                 { "quiet",              no_argument,       NULL, 'q'                    },
 161                 { "user",               no_argument,       NULL, ARG_USER               },
 162                 { "system",             no_argument,       NULL, ARG_SYSTEM             },
 163                 { "host",               required_argument, NULL, 'H'                    },
 164                 { "machine",            required_argument, NULL, 'M'                    },
 165                 { "discover",           no_argument,       NULL, ARG_DISCOVER           },
 166                 { "type",               required_argument, NULL, 't'                    },
 167                 { "options",            required_argument, NULL, 'o'                    },
 168                 { "owner",              required_argument, NULL, ARG_OWNER              },
 169                 { "fsck",               required_argument, NULL, ARG_FSCK               },
 170                 { "description",        required_argument, NULL, ARG_DESCRIPTION        },
 171                 { "property",           required_argument, NULL, 'p'                    },
 172                 { "automount",          required_argument, NULL, ARG_AUTOMOUNT          },
 173                 { "timeout-idle-sec",   required_argument, NULL, ARG_TIMEOUT_IDLE       },
 174                 { "automount-property", required_argument, NULL, ARG_AUTOMOUNT_PROPERTY },
 175                 { "bind-device",        no_argument,       NULL, ARG_BIND_DEVICE        },
 176                 { "list",               no_argument,       NULL, ARG_LIST               },
 177                 { "umount",             no_argument,       NULL, 'u'                    },
 178                 { "unmount",            no_argument,       NULL, 'u'                    },
 179                 { "collect",            no_argument,       NULL, 'G'                    },
 180                 {},
 181         };
 182
 183         int r, c;
 184
 185         assert(argc >= 0);
 186         assert(argv);
 187
 188         if (invoked_as(argv, "systemd-umount"))
 189                 arg_action = ACTION_UMOUNT;
 190
 191         while ((c = getopt_long(argc, argv, "hqH:M:t:o:p:AuGl", options, NULL)) >= 0)
 192
 193                 switch (c) {
 194
 195                 case 'h':
 196                         return help();
 197
 198                 case ARG_VERSION:
 199                         return version();
 200
 201                 case ARG_NO_BLOCK:
 202                         arg_no_block = true;
 203                         break;
 204
 205                 case ARG_NO_PAGER:
 206                         arg_pager_flags |= PAGER_DISABLE;
 207                         break;
 208
 209                 case ARG_NO_LEGEND:
 210                         arg_legend = false;
 211                         break;
 212
 213                 case 'l':
 214                         arg_full = true;
 215                         break;
 216
 217                 case ARG_NO_ASK_PASSWORD:
 218                         arg_ask_password = false;
 219                         break;
 220
 221                 case 'q':
 222                         arg_quiet = true;
 223                         break;
 224
 225                 case ARG_USER:
 226                         arg_runtime_scope = RUNTIME_SCOPE_USER;
 227                         break;
 228
 229                 case ARG_SYSTEM:
 230                         arg_runtime_scope = RUNTIME_SCOPE_SYSTEM;
 231                         break;
 232
 233                 case 'H':
 234                         arg_transport = BUS_TRANSPORT_REMOTE;
 235                         arg_host = optarg;
 236                         break;
 237
 238                 case 'M':
 239                         arg_transport = BUS_TRANSPORT_MACHINE;
 240                         arg_host = optarg;
 241                         break;
 242
 243                 case ARG_DISCOVER:
 244                         arg_discover = true;
 245                         break;
 246
 247                 case 't':
 248                         r = free_and_strdup_warn(&arg_mount_type, optarg);
 249                         if (r < 0)
 250                                 return r;
 251                         break;
 252
 253                 case 'o':
 254                         r = free_and_strdup_warn(&arg_mount_options, optarg);
 255                         if (r < 0)
 256                                 return r;
 257                         break;
 258
 259                 case ARG_OWNER: {
 260                         const char *user = optarg;
 261
 262                         r = get_user_creds(&user, &arg_uid, &arg_gid, NULL, NULL, 0);
 263                         if (r < 0)
 264                                 return log_error_errno(r,
 265                                                        r == -EBADMSG ? "UID or GID of user %s are invalid."
 266                                                                      : "Cannot use \"%s\" as owner: %m",
 267                                                        optarg);
 268                         break;
 269                 }
 270
 271                 case ARG_FSCK:
 272                         r = parse_boolean_argument("--fsck=", optarg, &arg_fsck);
 273                         if (r < 0)
 274                                 return r;
 275                         break;
 276
 277                 case ARG_DESCRIPTION:
 278                         r = free_and_strdup_warn(&arg_description, optarg);
 279                         if (r < 0)
 280                                 return r;
 281                         break;
 282
 283                 case 'p':
 284                         if (strv_extend(&arg_property, optarg) < 0)
 285                                 return log_oom();
 286
 287                         break;
 288
 289                 case 'A':
 290                         arg_action = ACTION_AUTOMOUNT;
 291                         break;
 292
 293                 case ARG_AUTOMOUNT:
 294                         r = parse_boolean_argument("--automount=", optarg, NULL);
 295                         if (r < 0)
 296                                 return r;
 297
 298                         arg_action = r ? ACTION_AUTOMOUNT : ACTION_MOUNT;
 299                         break;
 300
 301                 case ARG_TIMEOUT_IDLE:
 302                         r = parse_sec(optarg, &arg_timeout_idle);
 303                         if (r < 0)
 304                                 return log_error_errno(r, "Failed to parse timeout: %s", optarg);
 305
 306                         break;
 307
 308                 case ARG_AUTOMOUNT_PROPERTY:
 309                         if (strv_extend(&arg_automount_property, optarg) < 0)
 310                                 return log_oom();
 311
 312                         break;
 313
 314                 case ARG_BIND_DEVICE:
 315                         arg_bind_device = true;
 316                         break;
 317
 318                 case ARG_LIST:
 319                         arg_action = ACTION_LIST;
 320                         break;
 321
 322                 case 'u':
 323                         arg_action = ACTION_UMOUNT;
 324                         break;
 325
 326                 case 'G':
 327                         arg_aggressive_gc = true;
 328                         break;
 329
 330                 case '?':
 331                         return -EINVAL;
 332
 333                 default:
 334                         assert_not_reached();
 335                 }
 336
 337         if (arg_runtime_scope == RUNTIME_SCOPE_USER) {
 338                 arg_ask_password = false;
 339
 340                 if (arg_transport != BUS_TRANSPORT_LOCAL)
 341                         return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 342                                                "Execution in user context is not supported on non-local systems.");
 343         }
 344
 345         if (arg_action == ACTION_LIST) {
 346                 if (optind < argc)
 347                         return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 348                                                "Too many arguments.");
 349
 350                 if (arg_transport != BUS_TRANSPORT_LOCAL)
 351                         return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
 352                                                "Listing devices only supported locally.");
 353         } else if (arg_action == ACTION_UMOUNT) {
 354                 if (optind >= argc)
 355                         return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 356                                                "At least one argument required.");
 357
 358                 if (arg_transport != BUS_TRANSPORT_LOCAL) {
 359                         int i;
 360
 361                         for (i = optind; i < argc; i++)
 362                                 if (!path_is_absolute(argv[i]) )
 363                                         return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 364                                                                "Only absolute path is supported: %s", argv[i]);
 365                 }
 366         } else {
 367                 if (optind >= argc)
 368                         return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 369                                                "At least one argument required.");
 370
 371                 if (argc > optind+2)
 372                         return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 373                                                "At most two arguments required.");
 374
 375                 if (arg_mount_type && !fstype_is_blockdev_backed(arg_mount_type)) {
 376                         arg_mount_what = strdup(argv[optind]);
 377                         if (!arg_mount_what)
 378                                 return log_oom();
 379
 380                 } else if (arg_transport == BUS_TRANSPORT_LOCAL) {
 381                         _cleanup_free_ char *u = NULL;
 382
 383                         u = fstab_node_to_udev_node(argv[optind]);
 384                         if (!u)
 385                                 return log_oom();
 386
 387                         r = chase(u, NULL, 0, &arg_mount_what, NULL);
 388                         if (r < 0)
 389                                 return log_error_errno(r, "Failed to make path %s absolute: %m", u);
 390                 } else {
 391                         arg_mount_what = strdup(argv[optind]);
 392                         if (!arg_mount_what)
 393                                 return log_oom();
 394
 395                         path_simplify(arg_mount_what);
 396
 397                         if (!path_is_absolute(arg_mount_what))
 398                                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 399                                                        "Only absolute path is supported: %s", arg_mount_what);
 400                 }
 401
 402                 if (argc > optind+1) {
 403                         if (arg_transport == BUS_TRANSPORT_LOCAL) {
 404                                 r = chase(argv[optind+1], NULL, CHASE_NONEXISTENT, &arg_mount_where, NULL);
 405                                 if (r < 0)
 406                                         return log_error_errno(r, "Failed to make path %s absolute: %m", argv[optind+1]);
 407                         } else {
 408                                 arg_mount_where = strdup(argv[optind+1]);
 409                                 if (!arg_mount_where)
 410                                         return log_oom();
 411
 412                                 path_simplify(arg_mount_where);
 413
 414                                 if (!path_is_absolute(arg_mount_where))
 415                                         return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 416                                                                "Only absolute path is supported: %s", arg_mount_where);
 417                         }
 418                 } else
 419                         arg_discover = true;
 420
 421                 if (arg_discover && arg_transport != BUS_TRANSPORT_LOCAL)
 422                         return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
 423                                                "Automatic mount location discovery is only supported locally.");
 424         }
 425
 426         return 1;
 427 }
 428
 429 static int transient_unit_set_properties(sd_bus_message *m, UnitType t, char **properties) {
 430         int r;
 431
 432         if (!isempty(arg_description)) {
 433                 r = sd_bus_message_append(m, "(sv)", "Description", "s", arg_description);
 434                 if (r < 0)
 435                         return r;
 436         }
 437
 438         if (arg_bind_device && is_device_path(arg_mount_what)) {
 439                 _cleanup_free_ char *device_unit = NULL;
 440
 441                 r = unit_name_from_path(arg_mount_what, ".device", &device_unit);
 442                 if (r < 0)
 443                         return r;
 444
 445                 r = sd_bus_message_append(m, "(sv)(sv)",
 446                                           "After", "as", 1, device_unit,
 447                                           "BindsTo", "as", 1, device_unit);
 448                 if (r < 0)
 449                         return r;
 450         }
 451
 452         if (arg_aggressive_gc) {
 453                 r = sd_bus_message_append(m, "(sv)", "CollectMode", "s", "inactive-or-failed");
 454                 if (r < 0)
 455                         return r;
 456         }
 457
 458         r = bus_append_unit_property_assignment_many(m, t, properties);
 459         if (r < 0)
 460                 return r;
 461
 462         return 0;
 463 }
 464
 465 static int transient_mount_set_properties(sd_bus_message *m) {
 466         _cleanup_free_ char *options = NULL;
 467         int r;
 468
 469         assert(m);
 470
 471         r = transient_unit_set_properties(m, UNIT_MOUNT, arg_property);
 472         if (r < 0)
 473                 return r;
 474
 475         if (arg_mount_what) {
 476                 r = sd_bus_message_append(m, "(sv)", "What", "s", arg_mount_what);
 477                 if (r < 0)
 478                         return r;
 479         }
 480
 481         if (arg_mount_type) {
 482                 r = sd_bus_message_append(m, "(sv)", "Type", "s", arg_mount_type);
 483                 if (r < 0)
 484                         return r;
 485         }
 486
 487         /* Prepend uid=…,gid=… if arg_uid is set */
 488         if (arg_uid != UID_INVALID) {
 489                 r = asprintf(&options,
 490                              "uid=" UID_FMT ",gid=" GID_FMT "%s%s",
 491                              arg_uid, arg_gid,
 492                              arg_mount_options ? "," : "", strempty(arg_mount_options));
 493                 if (r < 0)
 494                         return -ENOMEM;
 495         }
 496
 497         if (options || arg_mount_options) {
 498                 log_debug("Using mount options: %s", options ?: arg_mount_options);
 499
 500                 r = sd_bus_message_append(m, "(sv)", "Options", "s", options ?: arg_mount_options);
 501                 if (r < 0)
 502                         return r;
 503         } else
 504                 log_debug("Not using any mount options");
 505
 506         if (arg_fsck) {
 507                 _cleanup_free_ char *fsck = NULL;
 508
 509                 r = unit_name_from_path_instance("systemd-fsck", arg_mount_what, ".service", &fsck);
 510                 if (r < 0)
 511                         return r;
 512
 513                 r = sd_bus_message_append(m,
 514                                           "(sv)(sv)",
 515                                           "Requires", "as", 1, fsck,
 516                                           "After", "as", 1, fsck);
 517                 if (r < 0)
 518                         return r;
 519         }
 520
 521         return 0;
 522 }
 523
 524 static int transient_automount_set_properties(sd_bus_message *m) {
 525         int r;
 526
 527         assert(m);
 528
 529         r = transient_unit_set_properties(m, UNIT_AUTOMOUNT, arg_automount_property);
 530         if (r < 0)
 531                 return r;
 532
 533         if (arg_timeout_idle != USEC_INFINITY) {
 534                 r = sd_bus_message_append(m, "(sv)", "TimeoutIdleUSec", "t", arg_timeout_idle);
 535                 if (r < 0)
 536                         return r;
 537         }
 538
 539         return 0;
 540 }
 541
 542 static int start_transient_mount(
 543                 sd_bus *bus,
 544                 char **argv) {
 545
 546         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
 547         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 548         _cleanup_(bus_wait_for_jobs_freep) BusWaitForJobs *w = NULL;
 549         _cleanup_free_ char *mount_unit = NULL;
 550         int r;
 551
 552         if (!arg_no_block) {
 553                 r = bus_wait_for_jobs_new(bus, &w);
 554                 if (r < 0)
 555                         return log_error_errno(r, "Could not watch jobs: %m");
 556         }
 557
 558         r = unit_name_from_path(arg_mount_where, ".mount", &mount_unit);
 559         if (r < 0)
 560                 return log_error_errno(r, "Failed to make mount unit name: %m");
 561
 562         r = bus_message_new_method_call(bus, &m, bus_systemd_mgr, "StartTransientUnit");
 563         if (r < 0)
 564                 return bus_log_create_error(r);
 565
 566         r = sd_bus_message_set_allow_interactive_authorization(m, arg_ask_password);
 567         if (r < 0)
 568                 return bus_log_create_error(r);
 569
 570         /* Name and mode */
 571         r = sd_bus_message_append(m, "ss", mount_unit, "fail");
 572         if (r < 0)
 573                 return bus_log_create_error(r);
 574
 575         /* Properties */
 576         r = sd_bus_message_open_container(m, 'a', "(sv)");
 577         if (r < 0)
 578                 return bus_log_create_error(r);
 579
 580         r = transient_mount_set_properties(m);
 581         if (r < 0)
 582                 return bus_log_create_error(r);
 583
 584         r = sd_bus_message_close_container(m);
 585         if (r < 0)
 586                 return bus_log_create_error(r);
 587
 588         /* Auxiliary units */
 589         r = sd_bus_message_append(m, "a(sa(sv))", 0);
 590         if (r < 0)
 591                 return bus_log_create_error(r);
 592
 593         polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
 594
 595         r = sd_bus_call(bus, m, 0, &error, &reply);
 596         if (r < 0)
 597                 return log_error_errno(r, "Failed to start transient mount unit: %s", bus_error_message(&error, r));
 598
 599         if (w) {
 600                 const char *object;
 601
 602                 r = sd_bus_message_read(reply, "o", &object);
 603                 if (r < 0)
 604                         return bus_log_parse_error(r);
 605
 606                 r = bus_wait_for_jobs_one(w, object, arg_quiet, NULL);
 607                 if (r < 0)
 608                         return r;
 609         }
 610
 611         if (!arg_quiet)
 612                 log_info("Started unit %s%s%s for mount point: %s%s%s",
 613                          ansi_highlight(), mount_unit, ansi_normal(),
 614                          ansi_highlight(), arg_mount_where, ansi_normal());
 615
 616         return 0;
 617 }
 618
 619 static int start_transient_automount(
 620                 sd_bus *bus,
 621                 char **argv) {
 622
 623         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
 624         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 625         _cleanup_(bus_wait_for_jobs_freep) BusWaitForJobs *w = NULL;
 626         _cleanup_free_ char *automount_unit = NULL, *mount_unit = NULL;
 627         int r;
 628
 629         if (!arg_no_block) {
 630                 r = bus_wait_for_jobs_new(bus, &w);
 631                 if (r < 0)
 632                         return log_error_errno(r, "Could not watch jobs: %m");
 633         }
 634
 635         r = unit_name_from_path(arg_mount_where, ".automount", &automount_unit);
 636         if (r < 0)
 637                 return log_error_errno(r, "Failed to make automount unit name: %m");
 638
 639         r = unit_name_from_path(arg_mount_where, ".mount", &mount_unit);
 640         if (r < 0)
 641                 return log_error_errno(r, "Failed to make mount unit name: %m");
 642
 643         r = bus_message_new_method_call(bus, &m, bus_systemd_mgr, "StartTransientUnit");
 644         if (r < 0)
 645                 return bus_log_create_error(r);
 646
 647         r = sd_bus_message_set_allow_interactive_authorization(m, arg_ask_password);
 648         if (r < 0)
 649                 return bus_log_create_error(r);
 650
 651         /* Name and mode */
 652         r = sd_bus_message_append(m, "ss", automount_unit, "fail");
 653         if (r < 0)
 654                 return bus_log_create_error(r);
 655
 656         /* Properties */
 657         r = sd_bus_message_open_container(m, 'a', "(sv)");
 658         if (r < 0)
 659                 return bus_log_create_error(r);
 660
 661         r = transient_automount_set_properties(m);
 662         if (r < 0)
 663                 return bus_log_create_error(r);
 664
 665         r = sd_bus_message_close_container(m);
 666         if (r < 0)
 667                 return bus_log_create_error(r);
 668
 669         /* Auxiliary units */
 670         r = sd_bus_message_open_container(m, 'a', "(sa(sv))");
 671         if (r < 0)
 672                 return bus_log_create_error(r);
 673
 674         r = sd_bus_message_open_container(m, 'r', "sa(sv)");
 675         if (r < 0)
 676                 return bus_log_create_error(r);
 677
 678         r = sd_bus_message_append(m, "s", mount_unit);
 679         if (r < 0)
 680                 return bus_log_create_error(r);
 681
 682         r = sd_bus_message_open_container(m, 'a', "(sv)");
 683         if (r < 0)
 684                 return bus_log_create_error(r);
 685
 686         r = transient_mount_set_properties(m);
 687         if (r < 0)
 688                 return bus_log_create_error(r);
 689
 690         r = sd_bus_message_close_container(m);
 691         if (r < 0)
 692                 return bus_log_create_error(r);
 693
 694         r = sd_bus_message_close_container(m);
 695         if (r < 0)
 696                 return bus_log_create_error(r);
 697
 698         r = sd_bus_message_close_container(m);
 699         if (r < 0)
 700                 return bus_log_create_error(r);
 701
 702         polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
 703
 704         r = sd_bus_call(bus, m, 0, &error, &reply);
 705         if (r < 0)
 706                 return log_error_errno(r, "Failed to start transient automount unit: %s", bus_error_message(&error, r));
 707
 708         if (w) {
 709                 const char *object;
 710
 711                 r = sd_bus_message_read(reply, "o", &object);
 712                 if (r < 0)
 713                         return bus_log_parse_error(r);
 714
 715                 r = bus_wait_for_jobs_one(w, object, arg_quiet, NULL);
 716                 if (r < 0)
 717                         return r;
 718         }
 719
 720         if (!arg_quiet)
 721                 log_info("Started unit %s%s%s for mount point: %s%s%s",
 722                          ansi_highlight(), automount_unit, ansi_normal(),
 723                          ansi_highlight(), arg_mount_where, ansi_normal());
 724
 725         return 0;
 726 }
 727
 728 static int find_mount_points(const char *what, char ***list) {
 729         _cleanup_(mnt_free_tablep) struct libmnt_table *table = NULL;
 730         _cleanup_(mnt_free_iterp) struct libmnt_iter *iter = NULL;
 731         _cleanup_strv_free_ char **l = NULL;
 732         size_t n = 0;
 733         int r;
 734
 735         assert(what);
 736         assert(list);
 737
 738         /* Returns all mount points obtained from /proc/self/mountinfo in *list,
 739          * and the number of mount points as return value. */
 740
 741         r = libmount_parse(NULL, NULL, &table, &iter);
 742         if (r < 0)
 743                 return log_error_errno(r, "Failed to parse /proc/self/mountinfo: %m");
 744
 745         for (;;) {
 746                 struct libmnt_fs *fs;
 747                 const char *source, *target;
 748
 749                 r = mnt_table_next_fs(table, iter, &fs);
 750                 if (r == 1)
 751                         break;
 752                 if (r < 0)
 753                         return log_error_errno(r, "Failed to get next entry from /proc/self/mountinfo: %m");
 754
 755                 source = mnt_fs_get_source(fs);
 756                 target = mnt_fs_get_target(fs);
 757                 if (!source || !target)
 758                         continue;
 759
 760                 if (!path_equal(source, what))
 761                         continue;
 762
 763                 /* one extra slot is needed for the terminating NULL */
 764                 if (!GREEDY_REALLOC0(l, n + 2))
 765                         return log_oom();
 766
 767                 l[n] = strdup(target);
 768                 if (!l[n])
 769                         return log_oom();
 770                 n++;
 771         }
 772
 773         if (!GREEDY_REALLOC0(l, n + 1))
 774                 return log_oom();
 775
 776         *list = TAKE_PTR(l);
 777         return n;
 778 }
 779
 780 static int find_loop_device(const char *backing_file, sd_device **ret) {
 781         _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
 782         int r;
 783
 784         assert(backing_file);
 785         assert(ret);
 786
 787         r = sd_device_enumerator_new(&e);
 788         if (r < 0)
 789                 return log_oom();
 790
 791         r = sd_device_enumerator_add_match_subsystem(e, "block", /* match = */ true);
 792         if (r < 0)
 793                 return log_error_errno(r, "Failed to add subsystem match: %m");
 794
 795         r = sd_device_enumerator_add_match_property(e, "ID_FS_USAGE", "filesystem");
 796         if (r < 0)
 797                 return log_error_errno(r, "Failed to add property match: %m");
 798
 799         r = sd_device_enumerator_add_match_sysname(e, "loop*");
 800         if (r < 0)
 801                 return log_error_errno(r, "Failed to add sysname match: %m");
 802
 803         r = sd_device_enumerator_add_match_sysattr(e, "loop/backing_file", /* value = */ NULL, /* match = */ true);
 804         if (r < 0)
 805                 return log_error_errno(r, "Failed to add sysattr match: %m");
 806
 807         FOREACH_DEVICE(e, dev) {
 808                 const char *s;
 809
 810                 r = sd_device_get_sysattr_value(dev, "loop/backing_file", &s);
 811                 if (r < 0) {
 812                         log_device_debug_errno(dev, r, "Failed to read \"loop/backing_file\" sysattr, ignoring: %m");
 813                         continue;
 814                 }
 815
 816                 if (inode_same(s, backing_file, 0) <= 0)
 817                         continue;
 818
 819                 *ret = sd_device_ref(dev);
 820                 return 0;
 821         }
 822
 823         return -ENXIO;
 824 }
 825
 826 static int stop_mount(
 827                 sd_bus *bus,
 828                 const char *where,
 829                 const char *suffix) {
 830
 831         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
 832         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 833         _cleanup_(bus_wait_for_jobs_freep) BusWaitForJobs *w = NULL;
 834         _cleanup_free_ char *mount_unit = NULL;
 835         int r;
 836
 837         if (!arg_no_block) {
 838                 r = bus_wait_for_jobs_new(bus, &w);
 839                 if (r < 0)
 840                         return log_error_errno(r, "Could not watch jobs: %m");
 841         }
 842
 843         r = unit_name_from_path(where, suffix, &mount_unit);
 844         if (r < 0)
 845                 return log_error_errno(r, "Failed to make %s unit name from path %s: %m", suffix + 1, where);
 846
 847         r = bus_message_new_method_call(bus, &m, bus_systemd_mgr, "StopUnit");
 848         if (r < 0)
 849                 return bus_log_create_error(r);
 850
 851         r = sd_bus_message_set_allow_interactive_authorization(m, arg_ask_password);
 852         if (r < 0)
 853                 return bus_log_create_error(r);
 854
 855         /* Name and mode */
 856         r = sd_bus_message_append(m, "ss", mount_unit, "fail");
 857         if (r < 0)
 858                 return bus_log_create_error(r);
 859
 860         polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
 861
 862         r = sd_bus_call(bus, m, 0, &error, &reply);
 863         if (r < 0) {
 864                 if (streq(suffix, ".automount") &&
 865                     sd_bus_error_has_name(&error, "org.freedesktop.systemd1.NoSuchUnit"))
 866                         return 0;
 867                 return log_error_errno(r, "Failed to stop %s unit: %s", suffix + 1, bus_error_message(&error, r));
 868         }
 869
 870         if (w) {
 871                 const char *object;
 872
 873                 r = sd_bus_message_read(reply, "o", &object);
 874                 if (r < 0)
 875                         return bus_log_parse_error(r);
 876
 877                 r = bus_wait_for_jobs_one(w, object, arg_quiet, NULL);
 878                 if (r < 0)
 879                         return r;
 880         }
 881
 882         if (!arg_quiet)
 883                 log_info("Stopped unit %s%s%s for mount point: %s%s%s",
 884                          ansi_highlight(), mount_unit, ansi_normal(),
 885                          ansi_highlight(), where, ansi_normal());
 886
 887         return 0;
 888 }
 889
 890 static int stop_mounts(
 891                 sd_bus *bus,
 892                 const char *where) {
 893
 894         int r;
 895
 896         if (path_equal(where, "/"))
 897                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 898                                        "Refusing to operate on root directory: %s", where);
 899
 900         if (!path_is_normalized(where))
 901                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 902                                        "Path contains non-normalized components: %s", where);
 903
 904         r = stop_mount(bus, where, ".mount");
 905         if (r < 0)
 906                 return r;
 907
 908         r = stop_mount(bus, where, ".automount");
 909         if (r < 0)
 910                 return r;
 911
 912         return 0;
 913 }
 914
 915 static int umount_by_device(sd_bus *bus, sd_device *dev) {
 916         _cleanup_(sd_device_unrefp) sd_device *d = NULL;
 917         _cleanup_strv_free_ char **list = NULL;
 918         const char *v;
 919         int r, ret = 0;
 920
 921         assert(bus);
 922         assert(dev);
 923
 924         if (sd_device_get_property_value(d, "SYSTEMD_MOUNT_WHERE", &v) >= 0)
 925                 ret = stop_mounts(bus, v);
 926
 927         r = sd_device_get_devname(dev, &v);
 928         if (r < 0)
 929                 return r;
 930
 931         r = find_mount_points(v, &list);
 932         if (r < 0)
 933                 return r;
 934
 935         STRV_FOREACH(l, list) {
 936                 r = stop_mounts(bus, *l);
 937                 if (r < 0)
 938                         ret = r;
 939         }
 940
 941         return ret;
 942 }
 943
 944 static int umount_by_device_node(sd_bus *bus, const char *node) {
 945         _cleanup_(sd_device_unrefp) sd_device *dev = NULL;
 946         const char *v;
 947         int r;
 948
 949         assert(bus);
 950         assert(node);
 951
 952         r = sd_device_new_from_devname(&dev, node);
 953         if (r < 0)
 954                 return log_error_errno(r, "Failed to get device from %s: %m", node);
 955
 956         r = sd_device_get_property_value(dev, "ID_FS_USAGE", &v);
 957         if (r < 0)
 958                 return log_device_error_errno(dev, r, "Failed to get \"ID_FS_USAGE\" device property: %m");
 959
 960         if (!streq(v, "filesystem"))
 961                 return log_device_error_errno(dev, SYNTHETIC_ERRNO(EINVAL),
 962                                               "%s does not contain a known file system.", node);
 963
 964         return umount_by_device(bus, dev);
 965 }
 966
 967 static int umount_loop(sd_bus *bus, const char *backing_file) {
 968         _cleanup_(sd_device_unrefp) sd_device *dev = NULL;
 969         int r;
 970
 971         assert(backing_file);
 972
 973         r = find_loop_device(backing_file, &dev);
 974         if (r < 0)
 975                 return log_error_errno(r, r == -ENXIO ? "File %s is not mounted." : "Can't get loop device for %s: %m", backing_file);
 976
 977         return umount_by_device(bus, dev);
 978 }
 979
 980 static int action_umount(
 981                 sd_bus *bus,
 982                 int argc,
 983                 char **argv) {
 984
 985         int i, r, r2 = 0;
 986
 987         if (arg_transport != BUS_TRANSPORT_LOCAL) {
 988                 for (i = optind; i < argc; i++) {
 989                         _cleanup_free_ char *p = NULL;
 990
 991                         p = strdup(argv[i]);
 992                         if (!p)
 993                                 return log_oom();
 994
 995                         path_simplify(p);
 996
 997                         r = stop_mounts(bus, p);
 998                         if (r < 0)
 999                                 r2 = r;
1000                 }
1001                 return r2;
1002         }
1003
1004         for (i = optind; i < argc; i++) {
1005                 _cleanup_free_ char *u = NULL, *p = NULL;
1006                 struct stat st;
1007
1008                 u = fstab_node_to_udev_node(argv[i]);
1009                 if (!u)
1010                         return log_oom();
1011
1012                 r = chase(u, NULL, 0, &p, NULL);
1013                 if (r < 0) {
1014                         r2 = log_error_errno(r, "Failed to make path %s absolute: %m", argv[i]);
1015                         continue;
1016                 }
1017
1018                 if (stat(p, &st) < 0)
1019                         return log_error_errno(errno, "Can't stat %s (from %s): %m", p, argv[i]);
1020
1021                 if (S_ISBLK(st.st_mode))
1022                         r = umount_by_device_node(bus, p);
1023                 else if (S_ISREG(st.st_mode))
1024                         r = umount_loop(bus, p);
1025                 else if (S_ISDIR(st.st_mode))
1026                         r = stop_mounts(bus, p);
1027                 else {
1028                         log_error("Invalid file type: %s (from %s)", p, argv[i]);
1029                         r = -EINVAL;
1030                 }
1031
1032                 if (r < 0)
1033                         r2 = r;
1034         }
1035
1036         return r2;
1037 }
1038
1039 static int acquire_mount_type(sd_device *d) {
1040         const char *v;
1041
1042         assert(d);
1043
1044         if (arg_mount_type)
1045                 return 0;
1046
1047         if (sd_device_get_property_value(d, "ID_FS_TYPE", &v) < 0)
1048                 return 0;
1049
1050         arg_mount_type = strdup(v);
1051         if (!arg_mount_type)
1052                 return log_oom();
1053
1054         log_debug("Discovered type=%s", arg_mount_type);
1055         return 1;
1056 }
1057
1058 static int acquire_mount_options(sd_device *d) {
1059         const char *v;
1060
1061         assert(d);
1062
1063         if (arg_mount_options)
1064                 return 0;
1065
1066         if (sd_device_get_property_value(d, "SYSTEMD_MOUNT_OPTIONS", &v) < 0)
1067                 return 0;
1068
1069         arg_mount_options = strdup(v);
1070         if (!arg_mount_options)
1071                 return log_oom();
1072
1073         log_debug("Discovered options=%s", arg_mount_options);
1074         return 1;
1075 }
1076
1077 static const char *get_model(sd_device *d) {
1078         const char *model;
1079
1080         assert(d);
1081
1082         if (sd_device_get_property_value(d, "ID_MODEL_FROM_DATABASE", &model) >= 0)
1083                 return model;
1084
1085         if (sd_device_get_property_value(d, "ID_MODEL", &model) >= 0)
1086                 return model;
1087
1088         return NULL;
1089 }
1090
1091 static const char* get_label(sd_device *d) {
1092         const char *label;
1093
1094         assert(d);
1095
1096         if (sd_device_get_property_value(d, "ID_FS_LABEL", &label) >= 0)
1097                 return label;
1098
1099         if (sd_device_get_property_value(d, "ID_PART_ENTRY_NAME", &label) >= 0)
1100                 return label;
1101
1102         return NULL;
1103 }
1104
1105 static int acquire_mount_where(sd_device *d) {
1106         const char *v;
1107         int r;
1108
1109         if (arg_mount_where)
1110                 return 0;
1111
1112         if (sd_device_get_property_value(d, "SYSTEMD_MOUNT_WHERE", &v) < 0) {
1113                 _cleanup_free_ char *escaped = NULL, *devname_bn = NULL;
1114                 const char *name;
1115
1116                 name = get_label(d);
1117                 if (!name)
1118                         name = get_model(d);
1119                 if (!name) {
1120                         const char *dn;
1121
1122                         if (sd_device_get_devname(d, &dn) < 0)
1123                                 return 0;
1124
1125                         r = path_extract_filename(dn, &devname_bn);
1126                         if (r < 0)
1127                                 return log_error_errno(r, "Failed to extract file name from '%s': %m", dn);
1128
1129                         name = devname_bn;
1130                 }
1131
1132                 escaped = xescape(name, "\\");
1133                 if (!escaped)
1134                         return log_oom();
1135                 if (!filename_is_valid(escaped))
1136                         return 0;
1137
1138                 arg_mount_where = path_join("/run/media/system", escaped);
1139         } else
1140                 arg_mount_where = strdup(v);
1141
1142         if (!arg_mount_where)
1143                 return log_oom();
1144
1145         log_debug("Discovered where=%s", arg_mount_where);
1146         return 1;
1147 }
1148
1149 static int acquire_mount_where_for_loop_dev(sd_device *dev) {
1150         _cleanup_strv_free_ char **list = NULL;
1151         const char *node;
1152         int r;
1153
1154         assert(dev);
1155
1156         if (arg_mount_where)
1157                 return 0;
1158
1159         r = sd_device_get_devname(dev, &node);
1160         if (r < 0)
1161                 return r;
1162
1163         r = find_mount_points(node, &list);
1164         if (r < 0)
1165                 return r;
1166         if (r == 0)
1167                 return log_device_error_errno(dev, SYNTHETIC_ERRNO(EINVAL),
1168                                               "Can't find mount point of %s. It is expected that %s is already mounted on a place.",
1169                                               node, node);
1170         if (r >= 2)
1171                 return log_device_error_errno(dev, SYNTHETIC_ERRNO(EINVAL),
1172                                               "%s is mounted on %d places. It is expected that %s is mounted on a place.",
1173                                               node, r, node);
1174
1175         arg_mount_where = strdup(list[0]);
1176         if (!arg_mount_where)
1177                 return log_oom();
1178
1179         log_debug("Discovered where=%s", arg_mount_where);
1180         return 1;
1181 }
1182
1183 static int acquire_description(sd_device *d) {
1184         const char *model, *label;
1185
1186         if (arg_description)
1187                 return 0;
1188
1189         model = get_model(d);
1190
1191         label = get_label(d);
1192         if (!label)
1193                 (void) sd_device_get_property_value(d, "ID_PART_ENTRY_NUMBER", &label);
1194
1195         if (model && label)
1196                 arg_description = strjoin(model, " ", label);
1197         else if (label)
1198                 arg_description = strdup(label);
1199         else if (model)
1200                 arg_description = strdup(model);
1201         else
1202                 return 0;
1203
1204         if (!arg_description)
1205                 return log_oom();
1206
1207         log_debug("Discovered description=%s", arg_description);
1208         return 1;
1209 }
1210
1211 static int acquire_removable(sd_device *d) {
1212         const char *v;
1213
1214         /* Shortcut this if there's no reason to check it */
1215         if (arg_action != ACTION_DEFAULT && arg_timeout_idle_set && arg_bind_device >= 0)
1216                 return 0;
1217
1218         for (;;) {
1219                 if (sd_device_get_sysattr_value(d, "removable", &v) >= 0)
1220                         break;
1221
1222                 if (sd_device_get_parent(d, &d) < 0)
1223                         return 0;
1224
1225                 if (sd_device_get_subsystem(d, &v) < 0 || !streq(v, "block"))
1226                         return 0;
1227         }
1228
1229         if (parse_boolean(v) <= 0)
1230                 return 0;
1231
1232         log_debug("Discovered removable device.");
1233
1234         if (arg_action == ACTION_DEFAULT) {
1235                 log_debug("Automatically turning on automount.");
1236                 arg_action = ACTION_AUTOMOUNT;
1237         }
1238
1239         if (!arg_timeout_idle_set) {
1240                 log_debug("Setting idle timeout to 1s.");
1241                 arg_timeout_idle = USEC_PER_SEC;
1242         }
1243
1244         if (arg_bind_device < 0) {
1245                 log_debug("Binding automount unit to device.");
1246                 arg_bind_device = true;
1247         }
1248
1249         return 1;
1250 }
1251
1252 static int discover_loop_backing_file(void) {
1253         _cleanup_(sd_device_unrefp) sd_device *d = NULL;
1254         int r;
1255
1256         r = find_loop_device(arg_mount_what, &d);
1257         if (r < 0 && r != -ENXIO)
1258                 return log_error_errno(errno, "Can't get loop device for %s: %m", arg_mount_what);
1259
1260         if (r == -ENXIO) {
1261                 _cleanup_free_ char *escaped = NULL, *bn = NULL;
1262
1263                 if (arg_mount_where)
1264                         return 0;
1265
1266                 r = path_extract_filename(arg_mount_what, &bn);
1267                 if (r < 0)
1268                         return log_error_errno(r, "Failed to extract file name from backing file path '%s': %m", arg_mount_what);
1269
1270                 escaped = xescape(bn, "\\");
1271                 if (!escaped)
1272                         return log_oom();
1273                 if (!filename_is_valid(escaped))
1274                         return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1275                                                "Escaped name %s is not a valid filename.",
1276                                                escaped);
1277
1278                 arg_mount_where = path_join("/run/media/system", escaped);
1279                 if (!arg_mount_where)
1280                         return log_oom();
1281
1282                 log_debug("Discovered where=%s", arg_mount_where);
1283                 return 0;
1284         }
1285
1286         r = acquire_mount_type(d);
1287         if (r < 0)
1288                 return r;
1289
1290         r = acquire_mount_options(d);
1291         if (r < 0)
1292                 return r;
1293
1294         r = acquire_mount_where_for_loop_dev(d);
1295         if (r < 0)
1296                 return r;
1297
1298         r = acquire_description(d);
1299         if (r < 0)
1300                 return r;
1301
1302         return 0;
1303 }
1304
1305 static int discover_device(void) {
1306         _cleanup_(sd_device_unrefp) sd_device *d = NULL;
1307         struct stat st;
1308         const char *v;
1309         int r;
1310
1311         if (stat(arg_mount_what, &st) < 0)
1312                 return log_error_errno(errno, "Can't stat %s: %m", arg_mount_what);
1313
1314         if (S_ISREG(st.st_mode))
1315                 return discover_loop_backing_file();
1316
1317         if (!S_ISBLK(st.st_mode))
1318                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1319                                        "Invalid file type: %s",
1320                                        arg_mount_what);
1321
1322         r = sd_device_new_from_stat_rdev(&d, &st);
1323         if (r < 0)
1324                 return log_error_errno(r, "Failed to get device from device number: %m");
1325
1326         if (sd_device_get_property_value(d, "ID_FS_USAGE", &v) < 0 || !streq(v, "filesystem"))
1327                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1328                                        "%s does not contain a known file system.",
1329                                        arg_mount_what);
1330
1331         r = acquire_mount_type(d);
1332         if (r < 0)
1333                 return r;
1334
1335         r = acquire_mount_options(d);
1336         if (r < 0)
1337                 return r;
1338
1339         r = acquire_mount_where(d);
1340         if (r < 0)
1341                 return r;
1342
1343         r = acquire_description(d);
1344         if (r < 0)
1345                 return r;
1346
1347         r = acquire_removable(d);
1348         if (r < 0)
1349                 return r;
1350
1351         return 0;
1352 }
1353
1354 enum {
1355         COLUMN_NODE,
1356         COLUMN_PATH,
1357         COLUMN_MODEL,
1358         COLUMN_WWN,
1359         COLUMN_FSTYPE,
1360         COLUMN_LABEL,
1361         COLUMN_UUID,
1362         _COLUMN_MAX,
1363 };
1364
1365 static int list_devices(void) {
1366         _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
1367         _cleanup_(table_unrefp) Table *table = NULL;
1368         unsigned c;
1369         int r;
1370
1371         r = sd_device_enumerator_new(&e);
1372         if (r < 0)
1373                 return log_oom();
1374
1375         r = sd_device_enumerator_add_match_subsystem(e, "block", true);
1376         if (r < 0)
1377                 return log_error_errno(r, "Failed to add block match: %m");
1378
1379         r = sd_device_enumerator_add_match_property(e, "ID_FS_USAGE", "filesystem");
1380         if (r < 0)
1381                 return log_error_errno(r, "Failed to add property match: %m");
1382
1383         table = table_new("NODE", "PATH", "MODEL", "WWN", "TYPE", "LABEL", "UUID");
1384         if (!table)
1385                 return log_oom();
1386
1387         if (arg_full)
1388                 table_set_width(table, 0);
1389
1390         r = table_set_sort(table, (size_t) 0);
1391         if (r < 0)
1392                 return log_error_errno(r, "Failed to set sort index: %m");
1393
1394         table_set_header(table, arg_legend);
1395
1396         FOREACH_DEVICE(e, d) {
1397                 for (c = 0; c < _COLUMN_MAX; c++) {
1398                         const char *x = NULL;
1399
1400                         switch (c) {
1401
1402                         case COLUMN_NODE:
1403                                 (void) sd_device_get_devname(d, &x);
1404                                 break;
1405
1406                         case COLUMN_PATH:
1407                                 (void) sd_device_get_property_value(d, "ID_PATH", &x);
1408                                 break;
1409
1410                         case COLUMN_MODEL:
1411                                 x = get_model(d);
1412                                 break;
1413
1414                         case COLUMN_WWN:
1415                                 (void) sd_device_get_property_value(d, "ID_WWN", &x);
1416                                 break;
1417
1418                         case COLUMN_FSTYPE:
1419                                 (void) sd_device_get_property_value(d, "ID_FS_TYPE", &x);
1420                                 break;
1421
1422                         case COLUMN_LABEL:
1423                                 x = get_label(d);
1424                                 break;
1425
1426                         case COLUMN_UUID:
1427                                 (void) sd_device_get_property_value(d, "ID_FS_UUID", &x);
1428                                 break;
1429                         }
1430
1431                         r = table_add_cell(table, NULL, c == COLUMN_NODE ? TABLE_PATH : TABLE_STRING, strna(x));
1432                         if (r < 0)
1433                                 return table_log_add_error(r);
1434                 }
1435         }
1436
1437         pager_open(arg_pager_flags);
1438
1439         r = table_print(table, NULL);
1440         if (r < 0)
1441                 return table_log_print_error(r);
1442
1443         return 0;
1444 }
1445
1446 static int run(int argc, char* argv[]) {
1447         _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1448         int r;
1449
1450         log_show_color(true);
1451         log_parse_environment();
1452         log_open();
1453
1454         r = parse_argv(argc, argv);
1455         if (r <= 0)
1456                 return r;
1457
1458         if (arg_action == ACTION_LIST)
1459                 return list_devices();
1460
1461         r = bus_connect_transport_systemd(arg_transport, arg_host, arg_runtime_scope, &bus);
1462         if (r < 0)
1463                 return bus_log_connect_error(r, arg_transport);
1464
1465         if (arg_action == ACTION_UMOUNT)
1466                 return action_umount(bus, argc, argv);
1467
1468         if ((!arg_mount_type || fstype_is_blockdev_backed(arg_mount_type))
1469             && !path_is_normalized(arg_mount_what))
1470                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1471                                        "Path contains non-normalized components: %s",
1472                                        arg_mount_what);
1473
1474         if (arg_discover) {
1475                 r = discover_device();
1476                 if (r < 0)
1477                         return r;
1478         }
1479
1480         if (!arg_mount_where)
1481                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1482                                        "Can't figure out where to mount %s.",
1483                                        arg_mount_what);
1484
1485         if (path_equal(arg_mount_where, "/"))
1486                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1487                                        "Refusing to operate on root directory.");
1488
1489         if (!path_is_normalized(arg_mount_where))
1490                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1491                                        "Path contains non-normalized components: %s",
1492                                        arg_mount_where);
1493
1494         if (streq_ptr(arg_mount_type, "auto"))
1495                 arg_mount_type = mfree(arg_mount_type);
1496         if (streq_ptr(arg_mount_options, "defaults"))
1497                 arg_mount_options = mfree(arg_mount_options);
1498
1499         if (!is_device_path(arg_mount_what))
1500                 arg_fsck = false;
1501
1502         if (arg_fsck && arg_mount_type && arg_transport == BUS_TRANSPORT_LOCAL) {
1503                 r = fsck_exists_for_fstype(arg_mount_type);
1504                 if (r < 0)
1505                         log_warning_errno(r, "Couldn't determine whether fsck for %s exists, proceeding anyway.", arg_mount_type);
1506                 else if (r == 0) {
1507                         log_debug("Disabling file system check as fsck for %s doesn't exist.", arg_mount_type);
1508                         arg_fsck = false; /* fsck doesn't exist, let's not attempt it */
1509                 }
1510         }
1511
1512         /* The kernel (properly) refuses mounting file systems with unknown uid=,gid= options,
1513          * but not for all filesystem types. Let's try to catch the cases where the option
1514          * would be used if the file system does not support it. It is also possible to
1515          * autodetect the file system, but that's only possible with disk-based file systems
1516          * which incidentally seem to be implemented more carefully and reject unknown options,
1517          * so it's probably OK that we do the check only when the type is specified.
1518          */
1519         if (arg_mount_type &&
1520             !streq(arg_mount_type, "auto") &&
1521             arg_uid != UID_INVALID &&
1522             !fstype_can_uid_gid(arg_mount_type))
1523                 return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
1524                                        "File system type %s is not known to support uid=/gid=, refusing.",
1525                                        arg_mount_type);
1526
1527         switch (arg_action) {
1528
1529         case ACTION_MOUNT:
1530         case ACTION_DEFAULT:
1531                 r = start_transient_mount(bus, argv + optind);
1532                 break;
1533
1534         case ACTION_AUTOMOUNT:
1535                 r = start_transient_automount(bus, argv + optind);
1536                 break;
1537
1538         default:
1539                 assert_not_reached();
1540         }
1541
1542         return r;
1543 }
1544
1545 DEFINE_MAIN_FUNCTION(run);