src/core/mount.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <errno.h>
  23 #include <stdio.h>
  24 #include <mntent.h>
  25 #include <sys/epoll.h>
  26 #include <signal.h>
  27
  28 #include "manager.h"
  29 #include "unit.h"
  30 #include "mount.h"
  31 #include "load-fragment.h"
  32 #include "load-dropin.h"
  33 #include "log.h"
  34 #include "sd-messages.h"
  35 #include "strv.h"
  36 #include "mkdir.h"
  37 #include "path-util.h"
  38 #include "mount-setup.h"
  39 #include "unit-name.h"
  40 #include "dbus-mount.h"
  41 #include "special.h"
  42 #include "bus-errors.h"
  43 #include "exit-status.h"
  44 #include "def.h"
  45
  46 static const UnitActiveState state_translation_table[_MOUNT_STATE_MAX] = {
  47         [MOUNT_DEAD] = UNIT_INACTIVE,
  48         [MOUNT_MOUNTING] = UNIT_ACTIVATING,
  49         [MOUNT_MOUNTING_DONE] = UNIT_ACTIVE,
  50         [MOUNT_MOUNTED] = UNIT_ACTIVE,
  51         [MOUNT_REMOUNTING] = UNIT_RELOADING,
  52         [MOUNT_UNMOUNTING] = UNIT_DEACTIVATING,
  53         [MOUNT_MOUNTING_SIGTERM] = UNIT_DEACTIVATING,
  54         [MOUNT_MOUNTING_SIGKILL] = UNIT_DEACTIVATING,
  55         [MOUNT_REMOUNTING_SIGTERM] = UNIT_RELOADING,
  56         [MOUNT_REMOUNTING_SIGKILL] = UNIT_RELOADING,
  57         [MOUNT_UNMOUNTING_SIGTERM] = UNIT_DEACTIVATING,
  58         [MOUNT_UNMOUNTING_SIGKILL] = UNIT_DEACTIVATING,
  59         [MOUNT_FAILED] = UNIT_FAILED
  60 };
  61
  62 static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
  63 static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
  64
  65 static char* mount_test_option(const char *haystack, const char *needle) {
  66         struct mntent me = { .mnt_opts = (char*) haystack };
  67
  68         assert(needle);
  69
  70         /* Like glibc's hasmntopt(), but works on a string, not a
  71          * struct mntent */
  72
  73         if (!haystack)
  74                 return NULL;
  75
  76         return hasmntopt(&me, needle);
  77 }
  78
  79 static bool mount_is_network(MountParameters *p) {
  80         assert(p);
  81
  82         if (mount_test_option(p->options, "_netdev"))
  83                 return true;
  84
  85         if (p->fstype && fstype_is_network(p->fstype))
  86                 return true;
  87
  88         return false;
  89 }
  90
  91 static bool mount_is_bind(MountParameters *p) {
  92         assert(p);
  93
  94         if (mount_test_option(p->options, "bind"))
  95                 return true;
  96
  97         if (p->fstype && streq(p->fstype, "bind"))
  98                 return true;
  99
 100         if (mount_test_option(p->options, "rbind"))
 101                 return true;
 102
 103         if (p->fstype && streq(p->fstype, "rbind"))
 104                 return true;
 105
 106         return false;
 107 }
 108
 109 static bool mount_is_auto(MountParameters *p) {
 110         assert(p);
 111
 112         return !mount_test_option(p->options, "noauto");
 113 }
 114
 115 static bool needs_quota(MountParameters *p) {
 116         assert(p);
 117
 118         if (mount_is_network(p))
 119                 return false;
 120
 121         if (mount_is_bind(p))
 122                 return false;
 123
 124         return mount_test_option(p->options, "usrquota") ||
 125                 mount_test_option(p->options, "grpquota") ||
 126                 mount_test_option(p->options, "quota") ||
 127                 mount_test_option(p->options, "usrjquota") ||
 128                 mount_test_option(p->options, "grpjquota");
 129 }
 130
 131 static void mount_init(Unit *u) {
 132         Mount *m = MOUNT(u);
 133
 134         assert(u);
 135         assert(u->load_state == UNIT_STUB);
 136
 137         m->timeout_usec = u->manager->default_timeout_start_usec;
 138         m->directory_mode = 0755;
 139
 140         exec_context_init(&m->exec_context);
 141         kill_context_init(&m->kill_context);
 142         cgroup_context_init(&m->cgroup_context);
 143
 144         if (unit_has_name(u, "-.mount")) {
 145                 /* Don't allow start/stop for root directory */
 146                 u->refuse_manual_start = true;
 147                 u->refuse_manual_stop = true;
 148         } else {
 149                 /* The stdio/kmsg bridge socket is on /, in order to avoid a
 150                  * dep loop, don't use kmsg logging for -.mount */
 151                 m->exec_context.std_output = u->manager->default_std_output;
 152                 m->exec_context.std_error = u->manager->default_std_error;
 153         }
 154
 155         /* We need to make sure that /bin/mount is always called in
 156          * the same process group as us, so that the autofs kernel
 157          * side doesn't send us another mount request while we are
 158          * already trying to comply its last one. */
 159         m->exec_context.same_pgrp = true;
 160
 161         m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
 162
 163         u->ignore_on_isolate = true;
 164 }
 165
 166 static int mount_arm_timer(Mount *m) {
 167         int r;
 168
 169         assert(m);
 170
 171         if (m->timeout_usec <= 0) {
 172                 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
 173                 return 0;
 174         }
 175
 176         if (m->timer_event_source) {
 177                 r = sd_event_source_set_time(m->timer_event_source, now(CLOCK_MONOTONIC) + m->timeout_usec);
 178                 if (r < 0)
 179                         return r;
 180
 181                 return sd_event_source_set_enabled(m->timer_event_source, SD_EVENT_ONESHOT);
 182         }
 183
 184         return sd_event_add_monotonic(UNIT(m)->manager->event, now(CLOCK_MONOTONIC) + m->timeout_usec, 0, mount_dispatch_timer, m, &m->timer_event_source);
 185 }
 186
 187 static void mount_unwatch_control_pid(Mount *m) {
 188         assert(m);
 189
 190         if (m->control_pid <= 0)
 191                 return;
 192
 193         unit_unwatch_pid(UNIT(m), m->control_pid);
 194         m->control_pid = 0;
 195 }
 196
 197 static void mount_parameters_done(MountParameters *p) {
 198         assert(p);
 199
 200         free(p->what);
 201         free(p->options);
 202         free(p->fstype);
 203
 204         p->what = p->options = p->fstype = NULL;
 205 }
 206
 207 static void mount_done(Unit *u) {
 208         Mount *m = MOUNT(u);
 209
 210         assert(m);
 211
 212         free(m->where);
 213         m->where = NULL;
 214
 215         mount_parameters_done(&m->parameters_proc_self_mountinfo);
 216         mount_parameters_done(&m->parameters_fragment);
 217
 218         cgroup_context_done(&m->cgroup_context);
 219         exec_context_done(&m->exec_context);
 220         m->exec_runtime = exec_runtime_unref(m->exec_runtime);
 221         exec_command_done_array(m->exec_command, _MOUNT_EXEC_COMMAND_MAX);
 222         m->control_command = NULL;
 223
 224         mount_unwatch_control_pid(m);
 225
 226         m->timer_event_source = sd_event_source_unref(m->timer_event_source);
 227 }
 228
 229 _pure_ static MountParameters* get_mount_parameters_fragment(Mount *m) {
 230         assert(m);
 231
 232         if (m->from_fragment)
 233                 return &m->parameters_fragment;
 234
 235         return NULL;
 236 }
 237
 238 _pure_ static MountParameters* get_mount_parameters(Mount *m) {
 239         assert(m);
 240
 241         if (m->from_proc_self_mountinfo)
 242                 return &m->parameters_proc_self_mountinfo;
 243
 244         return get_mount_parameters_fragment(m);
 245 }
 246
 247 static int mount_add_mount_links(Mount *m) {
 248         _cleanup_free_ char *parent = NULL;
 249         MountParameters *pm;
 250         Unit *other;
 251         Iterator i;
 252         Set *s;
 253         int r;
 254
 255         assert(m);
 256
 257         if (!path_equal(m->where, "/")) {
 258                 /* Adds in links to other mount points that might lie further
 259                  * up in the hierarchy */
 260                 r = path_get_parent(m->where, &parent);
 261                 if (r < 0)
 262                         return r;
 263
 264                 r = unit_require_mounts_for(UNIT(m), parent);
 265                 if (r < 0)
 266                         return r;
 267         }
 268
 269         /* Adds in links to other mount points that might be needed
 270          * for the source path (if this is a bind mount) to be
 271          * available. */
 272         pm = get_mount_parameters_fragment(m);
 273         if (pm && pm->what &&
 274             path_is_absolute(pm->what) &&
 275             !mount_is_network(pm)) {
 276
 277                 r = unit_require_mounts_for(UNIT(m), pm->what);
 278                 if (r < 0)
 279                         return r;
 280         }
 281
 282         /* Adds in links to other units that use this path or paths
 283          * further down in the hierarchy */
 284         s = manager_get_units_requiring_mounts_for(UNIT(m)->manager, m->where);
 285         SET_FOREACH(other, s, i) {
 286
 287                 if (other->load_state != UNIT_LOADED)
 288                         continue;
 289
 290                 if (other == UNIT(m))
 291                         continue;
 292
 293                 r = unit_add_dependency(other, UNIT_AFTER, UNIT(m), true);
 294                 if (r < 0)
 295                         return r;
 296
 297                 if (UNIT(m)->fragment_path) {
 298                         /* If we have fragment configuration, then make this dependency required */
 299                         r = unit_add_dependency(other, UNIT_REQUIRES, UNIT(m), true);
 300                         if (r < 0)
 301                                 return r;
 302                 }
 303         }
 304
 305         return 0;
 306 }
 307
 308 static int mount_add_device_links(Mount *m) {
 309         MountParameters *p;
 310         bool device_wants_mount = false;
 311         int r;
 312
 313         assert(m);
 314
 315         p = get_mount_parameters_fragment(m);
 316         if (!p)
 317                 return 0;
 318
 319         if (!p->what)
 320                 return 0;
 321
 322         if (mount_is_bind(p))
 323                 return 0;
 324
 325         if (!is_device_path(p->what))
 326                 return 0;
 327
 328         if (path_equal(m->where, "/"))
 329                 return 0;
 330
 331         if (mount_is_auto(p) && UNIT(m)->manager->running_as == SYSTEMD_SYSTEM)
 332                 device_wants_mount = true;
 333
 334         r = unit_add_node_link(UNIT(m), p->what, device_wants_mount);
 335         if (r < 0)
 336                 return r;
 337
 338         return 0;
 339 }
 340
 341 static int mount_add_quota_links(Mount *m) {
 342         int r;
 343         MountParameters *p;
 344
 345         assert(m);
 346
 347         if (UNIT(m)->manager->running_as != SYSTEMD_SYSTEM)
 348                 return 0;
 349
 350         p = get_mount_parameters_fragment(m);
 351         if (!p)
 352                 return 0;
 353
 354         if (!needs_quota(p))
 355                 return 0;
 356
 357         r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTACHECK_SERVICE, NULL, true);
 358         if (r < 0)
 359                 return r;
 360
 361         r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTAON_SERVICE, NULL, true);
 362         if (r < 0)
 363                 return r;
 364
 365         return 0;
 366 }
 367
 368 static bool should_umount(Mount *m) {
 369         MountParameters *p;
 370
 371         if (path_equal(m->where, "/") ||
 372             path_equal(m->where, "/usr"))
 373                 return false;
 374
 375         p = get_mount_parameters(m);
 376         if (p && mount_test_option(p->options, "x-initrd.mount") &&
 377             !in_initrd())
 378                 return false;
 379
 380         return true;
 381 }
 382
 383 static int mount_add_default_dependencies(Mount *m) {
 384         const char *after, *after2, *online;
 385         MountParameters *p;
 386         int r;
 387
 388         assert(m);
 389
 390         if (UNIT(m)->manager->running_as != SYSTEMD_SYSTEM)
 391                 return 0;
 392
 393         p = get_mount_parameters(m);
 394
 395         if (!p)
 396                 return 0;
 397
 398         if (path_equal(m->where, "/"))
 399                 return 0;
 400
 401         if (mount_is_network(p)) {
 402                 after = SPECIAL_REMOTE_FS_PRE_TARGET;
 403                 after2 = SPECIAL_NETWORK_TARGET;
 404                 online = SPECIAL_NETWORK_ONLINE_TARGET;
 405         } else {
 406                 after = SPECIAL_LOCAL_FS_PRE_TARGET;
 407                 after2 = NULL;
 408                 online = NULL;
 409         }
 410
 411         r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after, NULL, true);
 412         if (r < 0)
 413                 return r;
 414
 415         if (after2) {
 416                 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after2, NULL, true);
 417                 if (r < 0)
 418                         return r;
 419         }
 420
 421         if (online) {
 422                 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_WANTS, UNIT_AFTER, online, NULL, true);
 423                 if (r < 0)
 424                         return r;
 425         }
 426
 427         if (should_umount(m)) {
 428                 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
 429                 if (r < 0)
 430                         return r;
 431         }
 432
 433         return 0;
 434 }
 435
 436 static int mount_fix_timeouts(Mount *m) {
 437         MountParameters *p;
 438         const char *timeout = NULL;
 439         Unit *other;
 440         Iterator i;
 441         usec_t u;
 442         char *t;
 443         int r;
 444
 445         assert(m);
 446
 447         p = get_mount_parameters_fragment(m);
 448         if (!p)
 449                 return 0;
 450
 451         /* Allow configuration how long we wait for a device that
 452          * backs a mount point to show up. This is useful to support
 453          * endless device timeouts for devices that show up only after
 454          * user input, like crypto devices. */
 455
 456         if ((timeout = mount_test_option(p->options, "comment=systemd.device-timeout")))
 457                 timeout += 31;
 458         else if ((timeout = mount_test_option(p->options, "x-systemd.device-timeout")))
 459                 timeout += 25;
 460         else
 461                 return 0;
 462
 463         t = strndup(timeout, strcspn(timeout, ",;" WHITESPACE));
 464         if (!t)
 465                 return -ENOMEM;
 466
 467         r = parse_sec(t, &u);
 468         free(t);
 469
 470         if (r < 0) {
 471                 log_warning_unit(UNIT(m)->id,
 472                                  "Failed to parse timeout for %s, ignoring: %s",
 473                                  m->where, timeout);
 474                 return r;
 475         }
 476
 477         SET_FOREACH(other, UNIT(m)->dependencies[UNIT_AFTER], i) {
 478                 if (other->type != UNIT_DEVICE)
 479                         continue;
 480
 481                 other->job_timeout = u;
 482         }
 483
 484         return 0;
 485 }
 486
 487 static int mount_verify(Mount *m) {
 488         _cleanup_free_ char *e = NULL;
 489         bool b;
 490
 491         assert(m);
 492
 493         if (UNIT(m)->load_state != UNIT_LOADED)
 494                 return 0;
 495
 496         if (!m->from_fragment && !m->from_proc_self_mountinfo)
 497                 return -ENOENT;
 498
 499         e = unit_name_from_path(m->where, ".mount");
 500         if (!e)
 501                 return -ENOMEM;
 502
 503         b = unit_has_name(UNIT(m), e);
 504         if (!b) {
 505                 log_error_unit(UNIT(m)->id, "%s's Where= setting doesn't match unit name. Refusing.", UNIT(m)->id);
 506                 return -EINVAL;
 507         }
 508
 509         if (mount_point_is_api(m->where) || mount_point_ignore(m->where)) {
 510                 log_error_unit(UNIT(m)->id, "Cannot create mount unit for API file system %s. Refusing.", m->where);
 511                 return -EINVAL;
 512         }
 513
 514         if (UNIT(m)->fragment_path && !m->parameters_fragment.what) {
 515                 log_error_unit(UNIT(m)->id, "%s's What setting is missing. Refusing.", UNIT(m)->id);
 516                 return -EBADMSG;
 517         }
 518
 519         if (m->exec_context.pam_name && m->kill_context.kill_mode != KILL_CONTROL_GROUP) {
 520                 log_error_unit(UNIT(m)->id, "%s has PAM enabled. Kill mode must be set to control-group'. Refusing.",UNIT(m)->id);
 521                 return -EINVAL;
 522         }
 523
 524         return 0;
 525 }
 526
 527 static int mount_add_extras(Mount *m) {
 528         Unit *u = UNIT(m);
 529         int r;
 530
 531         assert(m);
 532
 533         if (u->fragment_path)
 534                 m->from_fragment = true;
 535
 536         if (!m->where) {
 537                 m->where = unit_name_to_path(u->id);
 538                 if (!m->where)
 539                         return -ENOMEM;
 540         }
 541
 542         path_kill_slashes(m->where);
 543
 544         r = unit_add_exec_dependencies(u, &m->exec_context);
 545         if (r < 0)
 546                 return r;
 547
 548         if (!u->description) {
 549                 r = unit_set_description(u, m->where);
 550                 if (r < 0)
 551                         return r;
 552         }
 553
 554         r = mount_add_device_links(m);
 555         if (r < 0)
 556                 return r;
 557
 558         r = mount_add_mount_links(m);
 559         if (r < 0)
 560                 return r;
 561
 562         r = mount_add_quota_links(m);
 563         if (r < 0)
 564                 return r;
 565
 566         if (u->default_dependencies) {
 567                 r = mount_add_default_dependencies(m);
 568                 if (r < 0)
 569                         return r;
 570         }
 571
 572         r = unit_add_default_slice(u);
 573         if (r < 0)
 574                 return r;
 575
 576         r = mount_fix_timeouts(m);
 577         if (r < 0)
 578                 return r;
 579
 580         r = unit_exec_context_defaults(u, &m->exec_context);
 581         if (r < 0)
 582                 return r;
 583
 584         return 0;
 585 }
 586
 587 static int mount_load(Unit *u) {
 588         Mount *m = MOUNT(u);
 589         int r;
 590
 591         assert(u);
 592         assert(u->load_state == UNIT_STUB);
 593
 594         if (m->from_proc_self_mountinfo)
 595                 r = unit_load_fragment_and_dropin_optional(u);
 596         else
 597                 r = unit_load_fragment_and_dropin(u);
 598
 599         if (r < 0)
 600                 return r;
 601
 602         /* This is a new unit? Then let's add in some extras */
 603         if (u->load_state == UNIT_LOADED) {
 604                 r = mount_add_extras(m);
 605                 if (r < 0)
 606                         return r;
 607         }
 608
 609         return mount_verify(m);
 610 }
 611
 612 static int mount_notify_automount(Mount *m, int status) {
 613         Unit *p;
 614         int r;
 615         Iterator i;
 616
 617         assert(m);
 618
 619         SET_FOREACH(p, UNIT(m)->dependencies[UNIT_TRIGGERED_BY], i)
 620                 if (p->type == UNIT_AUTOMOUNT) {
 621                          r = automount_send_ready(AUTOMOUNT(p), status);
 622                          if (r < 0)
 623                                  return r;
 624                 }
 625
 626         return 0;
 627 }
 628
 629 static void mount_set_state(Mount *m, MountState state) {
 630         MountState old_state;
 631         assert(m);
 632
 633         old_state = m->state;
 634         m->state = state;
 635
 636         if (state != MOUNT_MOUNTING &&
 637             state != MOUNT_MOUNTING_DONE &&
 638             state != MOUNT_REMOUNTING &&
 639             state != MOUNT_UNMOUNTING &&
 640             state != MOUNT_MOUNTING_SIGTERM &&
 641             state != MOUNT_MOUNTING_SIGKILL &&
 642             state != MOUNT_UNMOUNTING_SIGTERM &&
 643             state != MOUNT_UNMOUNTING_SIGKILL &&
 644             state != MOUNT_REMOUNTING_SIGTERM &&
 645             state != MOUNT_REMOUNTING_SIGKILL) {
 646                 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
 647                 mount_unwatch_control_pid(m);
 648                 m->control_command = NULL;
 649                 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
 650         }
 651
 652         if (state == MOUNT_MOUNTED ||
 653             state == MOUNT_REMOUNTING)
 654                 mount_notify_automount(m, 0);
 655         else if (state == MOUNT_DEAD ||
 656                  state == MOUNT_UNMOUNTING ||
 657                  state == MOUNT_MOUNTING_SIGTERM ||
 658                  state == MOUNT_MOUNTING_SIGKILL ||
 659                  state == MOUNT_REMOUNTING_SIGTERM ||
 660                  state == MOUNT_REMOUNTING_SIGKILL ||
 661                  state == MOUNT_UNMOUNTING_SIGTERM ||
 662                  state == MOUNT_UNMOUNTING_SIGKILL ||
 663                  state == MOUNT_FAILED) {
 664                 if (state != old_state)
 665                         mount_notify_automount(m, -ENODEV);
 666         }
 667
 668         if (state != old_state)
 669                 log_debug_unit(UNIT(m)->id,
 670                                "%s changed %s -> %s",
 671                                UNIT(m)->id,
 672                                mount_state_to_string(old_state),
 673                                mount_state_to_string(state));
 674
 675         unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
 676         m->reload_result = MOUNT_SUCCESS;
 677 }
 678
 679 static int mount_coldplug(Unit *u) {
 680         Mount *m = MOUNT(u);
 681         MountState new_state = MOUNT_DEAD;
 682         int r;
 683
 684         assert(m);
 685         assert(m->state == MOUNT_DEAD);
 686
 687         if (m->deserialized_state != m->state)
 688                 new_state = m->deserialized_state;
 689         else if (m->from_proc_self_mountinfo)
 690                 new_state = MOUNT_MOUNTED;
 691
 692         if (new_state == m->state)
 693                 return 0;
 694
 695         if (new_state == MOUNT_MOUNTING ||
 696             new_state == MOUNT_MOUNTING_DONE ||
 697             new_state == MOUNT_REMOUNTING ||
 698             new_state == MOUNT_UNMOUNTING ||
 699             new_state == MOUNT_MOUNTING_SIGTERM ||
 700             new_state == MOUNT_MOUNTING_SIGKILL ||
 701             new_state == MOUNT_UNMOUNTING_SIGTERM ||
 702             new_state == MOUNT_UNMOUNTING_SIGKILL ||
 703             new_state == MOUNT_REMOUNTING_SIGTERM ||
 704             new_state == MOUNT_REMOUNTING_SIGKILL) {
 705
 706                 if (m->control_pid <= 0)
 707                         return -EBADMSG;
 708
 709                 r = unit_watch_pid(UNIT(m), m->control_pid);
 710                 if (r < 0)
 711                         return r;
 712
 713                 r = mount_arm_timer(m);
 714                 if (r < 0)
 715                         return r;
 716         }
 717
 718         mount_set_state(m, new_state);
 719         return 0;
 720 }
 721
 722 static void mount_dump(Unit *u, FILE *f, const char *prefix) {
 723         Mount *m = MOUNT(u);
 724         MountParameters *p;
 725
 726         assert(m);
 727         assert(f);
 728
 729         p = get_mount_parameters(m);
 730
 731         fprintf(f,
 732                 "%sMount State: %s\n"
 733                 "%sResult: %s\n"
 734                 "%sWhere: %s\n"
 735                 "%sWhat: %s\n"
 736                 "%sFile System Type: %s\n"
 737                 "%sOptions: %s\n"
 738                 "%sFrom /proc/self/mountinfo: %s\n"
 739                 "%sFrom fragment: %s\n"
 740                 "%sDirectoryMode: %04o\n",
 741                 prefix, mount_state_to_string(m->state),
 742                 prefix, mount_result_to_string(m->result),
 743                 prefix, m->where,
 744                 prefix, p ? strna(p->what) : "n/a",
 745                 prefix, p ? strna(p->fstype) : "n/a",
 746                 prefix, p ? strna(p->options) : "n/a",
 747                 prefix, yes_no(m->from_proc_self_mountinfo),
 748                 prefix, yes_no(m->from_fragment),
 749                 prefix, m->directory_mode);
 750
 751         if (m->control_pid > 0)
 752                 fprintf(f,
 753                         "%sControl PID: "PID_FMT"\n",
 754                         prefix, m->control_pid);
 755
 756         exec_context_dump(&m->exec_context, f, prefix);
 757         kill_context_dump(&m->kill_context, f, prefix);
 758 }
 759
 760 static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
 761         pid_t pid;
 762         int r;
 763
 764         assert(m);
 765         assert(c);
 766         assert(_pid);
 767
 768         unit_realize_cgroup(UNIT(m));
 769
 770         r = unit_setup_exec_runtime(UNIT(m));
 771         if (r < 0)
 772                 goto fail;
 773
 774         r = mount_arm_timer(m);
 775         if (r < 0)
 776                 goto fail;
 777
 778         r = exec_spawn(c,
 779                        NULL,
 780                        &m->exec_context,
 781                        NULL, 0,
 782                        UNIT(m)->manager->environment,
 783                        true,
 784                        true,
 785                        true,
 786                        UNIT(m)->manager->confirm_spawn,
 787                        UNIT(m)->manager->cgroup_supported,
 788                        UNIT(m)->cgroup_path,
 789                        UNIT(m)->id,
 790                        0,
 791                        NULL,
 792                        m->exec_runtime,
 793                        &pid);
 794         if (r < 0)
 795                 goto fail;
 796
 797         r = unit_watch_pid(UNIT(m), pid);
 798         if (r < 0)
 799                 /* FIXME: we need to do something here */
 800                 goto fail;
 801
 802         *_pid = pid;
 803
 804         return 0;
 805
 806 fail:
 807         m->timer_event_source = sd_event_source_unref(m->timer_event_source);
 808
 809         return r;
 810 }
 811
 812 static void mount_enter_dead(Mount *m, MountResult f) {
 813         assert(m);
 814
 815         if (f != MOUNT_SUCCESS)
 816                 m->result = f;
 817
 818         exec_runtime_destroy(m->exec_runtime);
 819         m->exec_runtime = exec_runtime_unref(m->exec_runtime);
 820
 821         mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
 822 }
 823
 824 static void mount_enter_mounted(Mount *m, MountResult f) {
 825         assert(m);
 826
 827         if (f != MOUNT_SUCCESS)
 828                 m->result = f;
 829
 830         mount_set_state(m, MOUNT_MOUNTED);
 831 }
 832
 833 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
 834         int r;
 835
 836         assert(m);
 837
 838         if (f != MOUNT_SUCCESS)
 839                 m->result = f;
 840
 841         r = unit_kill_context(
 842                         UNIT(m),
 843                         &m->kill_context,
 844                         state != MOUNT_MOUNTING_SIGTERM && state != MOUNT_UNMOUNTING_SIGTERM && state != MOUNT_REMOUNTING_SIGTERM,
 845                         -1,
 846                         m->control_pid,
 847                         false);
 848         if (r < 0)
 849                 goto fail;
 850
 851         if (r > 0) {
 852                 r = mount_arm_timer(m);
 853                 if (r < 0)
 854                         goto fail;
 855
 856                 mount_set_state(m, state);
 857         } else if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
 858                 mount_enter_mounted(m, MOUNT_SUCCESS);
 859         else
 860                 mount_enter_dead(m, MOUNT_SUCCESS);
 861
 862         return;
 863
 864 fail:
 865         log_warning_unit(UNIT(m)->id,
 866                          "%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
 867
 868         if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
 869                 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
 870         else
 871                 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
 872 }
 873
 874 void warn_if_dir_nonempty(const char *unit, const char* where) {
 875         assert(unit);
 876         assert(where);
 877
 878         if (dir_is_empty(where) > 0)
 879                 return;
 880
 881         log_struct_unit(LOG_NOTICE,
 882                    unit,
 883                    "MESSAGE=%s: Directory %s to mount over is not empty, mounting anyway.",
 884                    unit, where,
 885                    "WHERE=%s", where,
 886                    MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
 887                    NULL);
 888 }
 889
 890 static void mount_enter_unmounting(Mount *m) {
 891         int r;
 892
 893         assert(m);
 894
 895         m->control_command_id = MOUNT_EXEC_UNMOUNT;
 896         m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
 897
 898         if ((r = exec_command_set(
 899                              m->control_command,
 900                              "/bin/umount",
 901                              m->where,
 902                              NULL)) < 0)
 903                 goto fail;
 904
 905         mount_unwatch_control_pid(m);
 906
 907         if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
 908                 goto fail;
 909
 910         mount_set_state(m, MOUNT_UNMOUNTING);
 911
 912         return;
 913
 914 fail:
 915         log_warning_unit(UNIT(m)->id,
 916                          "%s failed to run 'umount' task: %s",
 917                          UNIT(m)->id, strerror(-r));
 918         mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
 919 }
 920
 921 static void mount_enter_mounting(Mount *m) {
 922         int r;
 923         MountParameters *p;
 924
 925         assert(m);
 926
 927         m->control_command_id = MOUNT_EXEC_MOUNT;
 928         m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
 929
 930         mkdir_p_label(m->where, m->directory_mode);
 931
 932         warn_if_dir_nonempty(m->meta.id, m->where);
 933
 934         /* Create the source directory for bind-mounts if needed */
 935         p = get_mount_parameters_fragment(m);
 936         if (p && mount_is_bind(p))
 937                 mkdir_p_label(p->what, m->directory_mode);
 938
 939         if (m->from_fragment)
 940                 r = exec_command_set(
 941                                 m->control_command,
 942                                 "/bin/mount",
 943                                 m->parameters_fragment.what,
 944                                 m->where,
 945                                 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
 946                                 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
 947                                 NULL);
 948         else
 949                 r = -ENOENT;
 950
 951         if (r < 0)
 952                 goto fail;
 953
 954         mount_unwatch_control_pid(m);
 955
 956         r = mount_spawn(m, m->control_command, &m->control_pid);
 957         if (r < 0)
 958                 goto fail;
 959
 960         mount_set_state(m, MOUNT_MOUNTING);
 961
 962         return;
 963
 964 fail:
 965         log_warning_unit(UNIT(m)->id,
 966                          "%s failed to run 'mount' task: %s",
 967                          UNIT(m)->id, strerror(-r));
 968         mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
 969 }
 970
 971 static void mount_enter_remounting(Mount *m) {
 972         int r;
 973
 974         assert(m);
 975
 976         m->control_command_id = MOUNT_EXEC_REMOUNT;
 977         m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
 978
 979         if (m->from_fragment) {
 980                 const char *o;
 981
 982                 if (m->parameters_fragment.options)
 983                         o = strappenda("remount,", m->parameters_fragment.options);
 984                 else
 985                         o = "remount";
 986
 987                 r = exec_command_set(
 988                                 m->control_command,
 989                                 "/bin/mount",
 990                                 m->parameters_fragment.what,
 991                                 m->where,
 992                                 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
 993                                 "-o", o,
 994                                 NULL);
 995         } else
 996                 r = -ENOENT;
 997
 998         if (r < 0)
 999                 goto fail;
1000
1001         mount_unwatch_control_pid(m);
1002
1003         r = mount_spawn(m, m->control_command, &m->control_pid);
1004         if (r < 0)
1005                 goto fail;
1006
1007         mount_set_state(m, MOUNT_REMOUNTING);
1008
1009         return;
1010
1011 fail:
1012         log_warning_unit(UNIT(m)->id,
1013                          "%s failed to run 'remount' task: %s",
1014                          UNIT(m)->id, strerror(-r));
1015         m->reload_result = MOUNT_FAILURE_RESOURCES;
1016         mount_enter_mounted(m, MOUNT_SUCCESS);
1017 }
1018
1019 static int mount_start(Unit *u) {
1020         Mount *m = MOUNT(u);
1021
1022         assert(m);
1023
1024         /* We cannot fulfill this request right now, try again later
1025          * please! */
1026         if (m->state == MOUNT_UNMOUNTING ||
1027             m->state == MOUNT_UNMOUNTING_SIGTERM ||
1028             m->state == MOUNT_UNMOUNTING_SIGKILL ||
1029             m->state == MOUNT_MOUNTING_SIGTERM ||
1030             m->state == MOUNT_MOUNTING_SIGKILL)
1031                 return -EAGAIN;
1032
1033         /* Already on it! */
1034         if (m->state == MOUNT_MOUNTING)
1035                 return 0;
1036
1037         assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1038
1039         m->result = MOUNT_SUCCESS;
1040         m->reload_result = MOUNT_SUCCESS;
1041
1042         mount_enter_mounting(m);
1043         return 0;
1044 }
1045
1046 static int mount_stop(Unit *u) {
1047         Mount *m = MOUNT(u);
1048
1049         assert(m);
1050
1051         /* Already on it */
1052         if (m->state == MOUNT_UNMOUNTING ||
1053             m->state == MOUNT_UNMOUNTING_SIGKILL ||
1054             m->state == MOUNT_UNMOUNTING_SIGTERM ||
1055             m->state == MOUNT_MOUNTING_SIGTERM ||
1056             m->state == MOUNT_MOUNTING_SIGKILL)
1057                 return 0;
1058
1059         assert(m->state == MOUNT_MOUNTING ||
1060                m->state == MOUNT_MOUNTING_DONE ||
1061                m->state == MOUNT_MOUNTED ||
1062                m->state == MOUNT_REMOUNTING ||
1063                m->state == MOUNT_REMOUNTING_SIGTERM ||
1064                m->state == MOUNT_REMOUNTING_SIGKILL);
1065
1066         mount_enter_unmounting(m);
1067         return 0;
1068 }
1069
1070 static int mount_reload(Unit *u) {
1071         Mount *m = MOUNT(u);
1072
1073         assert(m);
1074
1075         if (m->state == MOUNT_MOUNTING_DONE)
1076                 return -EAGAIN;
1077
1078         assert(m->state == MOUNT_MOUNTED);
1079
1080         mount_enter_remounting(m);
1081         return 0;
1082 }
1083
1084 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1085         Mount *m = MOUNT(u);
1086
1087         assert(m);
1088         assert(f);
1089         assert(fds);
1090
1091         unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1092         unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1093         unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1094
1095         if (m->control_pid > 0)
1096                 unit_serialize_item_format(u, f, "control-pid", PID_FMT, m->control_pid);
1097
1098         if (m->control_command_id >= 0)
1099                 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1100
1101         return 0;
1102 }
1103
1104 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1105         Mount *m = MOUNT(u);
1106
1107         assert(u);
1108         assert(key);
1109         assert(value);
1110         assert(fds);
1111
1112         if (streq(key, "state")) {
1113                 MountState state;
1114
1115                 if ((state = mount_state_from_string(value)) < 0)
1116                         log_debug_unit(u->id, "Failed to parse state value %s", value);
1117                 else
1118                         m->deserialized_state = state;
1119         } else if (streq(key, "result")) {
1120                 MountResult f;
1121
1122                 f = mount_result_from_string(value);
1123                 if (f < 0)
1124                         log_debug_unit(UNIT(m)->id,
1125                                        "Failed to parse result value %s", value);
1126                 else if (f != MOUNT_SUCCESS)
1127                         m->result = f;
1128
1129         } else if (streq(key, "reload-result")) {
1130                 MountResult f;
1131
1132                 f = mount_result_from_string(value);
1133                 if (f < 0)
1134                         log_debug_unit(UNIT(m)->id,
1135                                        "Failed to parse reload result value %s", value);
1136                 else if (f != MOUNT_SUCCESS)
1137                         m->reload_result = f;
1138
1139         } else if (streq(key, "control-pid")) {
1140                 pid_t pid;
1141
1142                 if (parse_pid(value, &pid) < 0)
1143                         log_debug_unit(UNIT(m)->id,
1144                                        "Failed to parse control-pid value %s", value);
1145                 else
1146                         m->control_pid = pid;
1147         } else if (streq(key, "control-command")) {
1148                 MountExecCommand id;
1149
1150                 if ((id = mount_exec_command_from_string(value)) < 0)
1151                         log_debug_unit(UNIT(m)->id,
1152                                        "Failed to parse exec-command value %s", value);
1153                 else {
1154                         m->control_command_id = id;
1155                         m->control_command = m->exec_command + id;
1156                 }
1157         } else
1158                 log_debug_unit(UNIT(m)->id,
1159                                "Unknown serialization key '%s'", key);
1160
1161         return 0;
1162 }
1163
1164 _pure_ static UnitActiveState mount_active_state(Unit *u) {
1165         assert(u);
1166
1167         return state_translation_table[MOUNT(u)->state];
1168 }
1169
1170 _pure_ static const char *mount_sub_state_to_string(Unit *u) {
1171         assert(u);
1172
1173         return mount_state_to_string(MOUNT(u)->state);
1174 }
1175
1176 _pure_ static bool mount_check_gc(Unit *u) {
1177         Mount *m = MOUNT(u);
1178
1179         assert(m);
1180
1181         return m->from_proc_self_mountinfo;
1182 }
1183
1184 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1185         Mount *m = MOUNT(u);
1186         MountResult f;
1187
1188         assert(m);
1189         assert(pid >= 0);
1190
1191         if (pid != m->control_pid)
1192                 return;
1193
1194         m->control_pid = 0;
1195
1196         if (is_clean_exit(code, status, NULL))
1197                 f = MOUNT_SUCCESS;
1198         else if (code == CLD_EXITED)
1199                 f = MOUNT_FAILURE_EXIT_CODE;
1200         else if (code == CLD_KILLED)
1201                 f = MOUNT_FAILURE_SIGNAL;
1202         else if (code == CLD_DUMPED)
1203                 f = MOUNT_FAILURE_CORE_DUMP;
1204         else
1205                 assert_not_reached("Unknown code");
1206
1207         if (f != MOUNT_SUCCESS)
1208                 m->result = f;
1209
1210         if (m->control_command) {
1211                 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1212
1213                 m->control_command = NULL;
1214                 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1215         }
1216
1217         log_full_unit(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
1218                       "%s mount process exited, code=%s status=%i",
1219                       u->id, sigchld_code_to_string(code), status);
1220
1221         /* Note that mount(8) returning and the kernel sending us a
1222          * mount table change event might happen out-of-order. If an
1223          * operation succeed we assume the kernel will follow soon too
1224          * and already change into the resulting state.  If it fails
1225          * we check if the kernel still knows about the mount. and
1226          * change state accordingly. */
1227
1228         switch (m->state) {
1229
1230         case MOUNT_MOUNTING:
1231         case MOUNT_MOUNTING_DONE:
1232         case MOUNT_MOUNTING_SIGKILL:
1233         case MOUNT_MOUNTING_SIGTERM:
1234
1235                 if (f == MOUNT_SUCCESS)
1236                         mount_enter_mounted(m, f);
1237                 else if (m->from_proc_self_mountinfo)
1238                         mount_enter_mounted(m, f);
1239                 else
1240                         mount_enter_dead(m, f);
1241                 break;
1242
1243         case MOUNT_REMOUNTING:
1244         case MOUNT_REMOUNTING_SIGKILL:
1245         case MOUNT_REMOUNTING_SIGTERM:
1246
1247                 m->reload_result = f;
1248                 if (m->from_proc_self_mountinfo)
1249                         mount_enter_mounted(m, MOUNT_SUCCESS);
1250                 else
1251                         mount_enter_dead(m, MOUNT_SUCCESS);
1252
1253                 break;
1254
1255         case MOUNT_UNMOUNTING:
1256         case MOUNT_UNMOUNTING_SIGKILL:
1257         case MOUNT_UNMOUNTING_SIGTERM:
1258
1259                 if (f == MOUNT_SUCCESS)
1260                         mount_enter_dead(m, f);
1261                 else if (m->from_proc_self_mountinfo)
1262                         mount_enter_mounted(m, f);
1263                 else
1264                         mount_enter_dead(m, f);
1265                 break;
1266
1267         default:
1268                 assert_not_reached("Uh, control process died at wrong time.");
1269         }
1270
1271         /* Notify clients about changed exit status */
1272         unit_add_to_dbus_queue(u);
1273 }
1274
1275 static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
1276         Mount *m = MOUNT(userdata);
1277
1278         assert(m);
1279         assert(m->timer_event_source == source);
1280
1281         switch (m->state) {
1282
1283         case MOUNT_MOUNTING:
1284         case MOUNT_MOUNTING_DONE:
1285                 log_warning_unit(UNIT(m)->id,
1286                                  "%s mounting timed out. Stopping.", UNIT(m)->id);
1287                 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1288                 break;
1289
1290         case MOUNT_REMOUNTING:
1291                 log_warning_unit(UNIT(m)->id,
1292                                  "%s remounting timed out. Stopping.", UNIT(m)->id);
1293                 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1294                 mount_enter_mounted(m, MOUNT_SUCCESS);
1295                 break;
1296
1297         case MOUNT_UNMOUNTING:
1298                 log_warning_unit(UNIT(m)->id,
1299                                  "%s unmounting timed out. Stopping.", UNIT(m)->id);
1300                 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1301                 break;
1302
1303         case MOUNT_MOUNTING_SIGTERM:
1304                 if (m->kill_context.send_sigkill) {
1305                         log_warning_unit(UNIT(m)->id,
1306                                          "%s mounting timed out. Killing.", UNIT(m)->id);
1307                         mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1308                 } else {
1309                         log_warning_unit(UNIT(m)->id,
1310                                          "%s mounting timed out. Skipping SIGKILL. Ignoring.",
1311                                          UNIT(m)->id);
1312
1313                         if (m->from_proc_self_mountinfo)
1314                                 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1315                         else
1316                                 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1317                 }
1318                 break;
1319
1320         case MOUNT_REMOUNTING_SIGTERM:
1321                 if (m->kill_context.send_sigkill) {
1322                         log_warning_unit(UNIT(m)->id,
1323                                          "%s remounting timed out. Killing.", UNIT(m)->id);
1324                         mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1325                 } else {
1326                         log_warning_unit(UNIT(m)->id,
1327                                          "%s remounting timed out. Skipping SIGKILL. Ignoring.",
1328                                          UNIT(m)->id);
1329
1330                         if (m->from_proc_self_mountinfo)
1331                                 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1332                         else
1333                                 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1334                 }
1335                 break;
1336
1337         case MOUNT_UNMOUNTING_SIGTERM:
1338                 if (m->kill_context.send_sigkill) {
1339                         log_warning_unit(UNIT(m)->id,
1340                                          "%s unmounting timed out. Killing.", UNIT(m)->id);
1341                         mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1342                 } else {
1343                         log_warning_unit(UNIT(m)->id,
1344                                          "%s unmounting timed out. Skipping SIGKILL. Ignoring.",
1345                                          UNIT(m)->id);
1346
1347                         if (m->from_proc_self_mountinfo)
1348                                 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1349                         else
1350                                 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1351                 }
1352                 break;
1353
1354         case MOUNT_MOUNTING_SIGKILL:
1355         case MOUNT_REMOUNTING_SIGKILL:
1356         case MOUNT_UNMOUNTING_SIGKILL:
1357                 log_warning_unit(UNIT(m)->id,
1358                                  "%s mount process still around after SIGKILL. Ignoring.",
1359                                  UNIT(m)->id);
1360
1361                 if (m->from_proc_self_mountinfo)
1362                         mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1363                 else
1364                         mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1365                 break;
1366
1367         default:
1368                 assert_not_reached("Timeout at wrong time.");
1369         }
1370
1371         return 0;
1372 }
1373
1374 static int mount_add_one(
1375                 Manager *m,
1376                 const char *what,
1377                 const char *where,
1378                 const char *options,
1379                 const char *fstype,
1380                 bool set_flags) {
1381
1382         _cleanup_free_ char *e = NULL, *w = NULL, *o = NULL, *f = NULL;
1383         bool load_extras = false;
1384         MountParameters *p;
1385         bool delete;
1386         Unit *u;
1387         int r;
1388
1389         assert(m);
1390         assert(what);
1391         assert(where);
1392         assert(options);
1393         assert(fstype);
1394
1395         /* Ignore API mount points. They should never be referenced in
1396          * dependencies ever. */
1397         if (mount_point_is_api(where) || mount_point_ignore(where))
1398                 return 0;
1399
1400         if (streq(fstype, "autofs"))
1401                 return 0;
1402
1403         /* probably some kind of swap, ignore */
1404         if (!is_path(where))
1405                 return 0;
1406
1407         e = unit_name_from_path(where, ".mount");
1408         if (!e)
1409                 return -ENOMEM;
1410
1411         u = manager_get_unit(m, e);
1412         if (!u) {
1413                 delete = true;
1414
1415                 u = unit_new(m, sizeof(Mount));
1416                 if (!u)
1417                         return -ENOMEM;
1418
1419                 r = unit_add_name(u, e);
1420                 if (r < 0)
1421                         goto fail;
1422
1423                 MOUNT(u)->where = strdup(where);
1424                 if (!MOUNT(u)->where) {
1425                         r = -ENOMEM;
1426                         goto fail;
1427                 }
1428
1429                 u->source_path = strdup("/proc/self/mountinfo");
1430                 if (!u->source_path) {
1431                         r = -ENOMEM;
1432                         goto fail;
1433                 }
1434
1435
1436                 if (m->running_as == SYSTEMD_SYSTEM) {
1437                         const char* target;
1438
1439                         target = fstype_is_network(fstype) ? SPECIAL_REMOTE_FS_TARGET : SPECIAL_LOCAL_FS_TARGET;
1440
1441                         r = unit_add_dependency_by_name(u, UNIT_BEFORE, target, NULL, true);
1442                         if (r < 0)
1443                                 goto fail;
1444
1445                         if (should_umount(MOUNT(u))) {
1446                                 r = unit_add_dependency_by_name(u, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
1447                                 if (r < 0)
1448                                         goto fail;
1449                         }
1450                 }
1451
1452                 unit_add_to_load_queue(u);
1453         } else {
1454                 delete = false;
1455
1456                 if (!MOUNT(u)->where) {
1457                         MOUNT(u)->where = strdup(where);
1458                         if (!MOUNT(u)->where) {
1459                                 r = -ENOMEM;
1460                                 goto fail;
1461                         }
1462                 }
1463
1464                 if (u->load_state == UNIT_NOT_FOUND) {
1465                         u->load_state = UNIT_LOADED;
1466                         u->load_error = 0;
1467
1468                         /* Load in the extras later on, after we
1469                          * finished initialization of the unit */
1470                         load_extras = true;
1471                 }
1472         }
1473
1474         if (!(w = strdup(what)) ||
1475             !(o = strdup(options)) ||
1476             !(f = strdup(fstype))) {
1477                 r = -ENOMEM;
1478                 goto fail;
1479         }
1480
1481         p = &MOUNT(u)->parameters_proc_self_mountinfo;
1482         if (set_flags) {
1483                 MOUNT(u)->is_mounted = true;
1484                 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1485                 MOUNT(u)->just_changed = !streq_ptr(p->options, o);
1486         }
1487
1488         MOUNT(u)->from_proc_self_mountinfo = true;
1489
1490         free(p->what);
1491         p->what = w;
1492         w = NULL;
1493
1494         free(p->options);
1495         p->options = o;
1496         o = NULL;
1497
1498         free(p->fstype);
1499         p->fstype = f;
1500         f = NULL;
1501
1502         if (load_extras) {
1503                 r = mount_add_extras(MOUNT(u));
1504                 if (r < 0)
1505                         goto fail;
1506         }
1507
1508         unit_add_to_dbus_queue(u);
1509
1510         return 0;
1511
1512 fail:
1513         if (delete && u)
1514                 unit_free(u);
1515
1516         return r;
1517 }
1518
1519 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1520         int r = 0;
1521         unsigned i;
1522
1523         assert(m);
1524
1525         rewind(m->proc_self_mountinfo);
1526
1527         for (i = 1;; i++) {
1528                 _cleanup_free_ char *device = NULL, *path = NULL, *options = NULL, *options2 = NULL, *fstype = NULL, *d = NULL, *p = NULL, *o = NULL;
1529                 int k;
1530
1531                 k = fscanf(m->proc_self_mountinfo,
1532                            "%*s "       /* (1) mount id */
1533                            "%*s "       /* (2) parent id */
1534                            "%*s "       /* (3) major:minor */
1535                            "%*s "       /* (4) root */
1536                            "%ms "       /* (5) mount point */
1537                            "%ms"        /* (6) mount options */
1538                            "%*[^-]"     /* (7) optional fields */
1539                            "- "         /* (8) separator */
1540                            "%ms "       /* (9) file system type */
1541                            "%ms"        /* (10) mount source */
1542                            "%ms"        /* (11) mount options 2 */
1543                            "%*[^\n]",   /* some rubbish at the end */
1544                            &path,
1545                            &options,
1546                            &fstype,
1547                            &device,
1548                            &options2);
1549
1550                 if (k == EOF)
1551                         break;
1552
1553                 if (k != 5) {
1554                         log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1555                         continue;
1556                 }
1557
1558                 o = strjoin(options, ",", options2, NULL);
1559                 if (!o)
1560                         return log_oom();
1561
1562                 d = cunescape(device);
1563                 p = cunescape(path);
1564                 if (!d || !p)
1565                         return log_oom();
1566
1567                 k = mount_add_one(m, d, p, o, fstype, set_flags);
1568                 if (k < 0)
1569                         r = k;
1570         }
1571
1572         return r;
1573 }
1574
1575 static void mount_shutdown(Manager *m) {
1576         assert(m);
1577
1578         m->mount_event_source = sd_event_source_unref(m->mount_event_source);
1579
1580         if (m->proc_self_mountinfo) {
1581                 fclose(m->proc_self_mountinfo);
1582                 m->proc_self_mountinfo = NULL;
1583         }
1584 }
1585
1586 static int mount_get_timeout(Unit *u, uint64_t *timeout) {
1587         Mount *m = MOUNT(u);
1588         int r;
1589
1590         if (!m->timer_event_source)
1591                 return 0;
1592
1593         r = sd_event_source_get_time(m->timer_event_source, timeout);
1594         if (r < 0)
1595                 return r;
1596
1597         return 1;
1598 }
1599
1600 static int mount_enumerate(Manager *m) {
1601         int r;
1602         assert(m);
1603
1604         if (!m->proc_self_mountinfo) {
1605                 m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
1606                 if (!m->proc_self_mountinfo)
1607                         return -errno;
1608
1609                 r = sd_event_add_io(m->event, fileno(m->proc_self_mountinfo), EPOLLPRI, mount_dispatch_io, m, &m->mount_event_source);
1610                 if (r < 0)
1611                         goto fail;
1612
1613                 /* Dispatch this before we dispatch SIGCHLD, so that
1614                  * we always get the events from /proc/self/mountinfo
1615                  * before the SIGCHLD of /bin/mount. */
1616                 r = sd_event_source_set_priority(m->mount_event_source, -10);
1617                 if (r < 0)
1618                         goto fail;
1619         }
1620
1621         r = mount_load_proc_self_mountinfo(m, false);
1622         if (r < 0)
1623                 goto fail;
1624
1625         return 0;
1626
1627 fail:
1628         mount_shutdown(m);
1629         return r;
1630 }
1631
1632 static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1633         Manager *m = userdata;
1634         Unit *u;
1635         int r;
1636
1637         assert(m);
1638         assert(revents & EPOLLPRI);
1639
1640         /* The manager calls this for every fd event happening on the
1641          * /proc/self/mountinfo file, which informs us about mounting
1642          * table changes */
1643
1644         r = mount_load_proc_self_mountinfo(m, true);
1645         if (r < 0) {
1646                 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1647
1648                 /* Reset flags, just in case, for later calls */
1649                 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1650                         Mount *mount = MOUNT(u);
1651
1652                         mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1653                 }
1654
1655                 return 0;
1656         }
1657
1658         manager_dispatch_load_queue(m);
1659
1660         LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1661                 Mount *mount = MOUNT(u);
1662
1663                 if (!mount->is_mounted) {
1664                         /* This has just been unmounted. */
1665
1666                         mount->from_proc_self_mountinfo = false;
1667
1668                         switch (mount->state) {
1669
1670                         case MOUNT_MOUNTED:
1671                                 mount_enter_dead(mount, MOUNT_SUCCESS);
1672                                 break;
1673
1674                         default:
1675                                 mount_set_state(mount, mount->state);
1676                                 break;
1677
1678                         }
1679
1680                 } else if (mount->just_mounted || mount->just_changed) {
1681
1682                         /* New or changed mount entry */
1683
1684                         switch (mount->state) {
1685
1686                         case MOUNT_DEAD:
1687                         case MOUNT_FAILED:
1688                                 mount_enter_mounted(mount, MOUNT_SUCCESS);
1689                                 break;
1690
1691                         case MOUNT_MOUNTING:
1692                                 mount_set_state(mount, MOUNT_MOUNTING_DONE);
1693                                 break;
1694
1695                         default:
1696                                 /* Nothing really changed, but let's
1697                                  * issue an notification call
1698                                  * nonetheless, in case somebody is
1699                                  * waiting for this. (e.g. file system
1700                                  * ro/rw remounts.) */
1701                                 mount_set_state(mount, mount->state);
1702                                 break;
1703                         }
1704                 }
1705
1706                 /* Reset the flags for later calls */
1707                 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1708         }
1709
1710         return 0;
1711 }
1712
1713 static void mount_reset_failed(Unit *u) {
1714         Mount *m = MOUNT(u);
1715
1716         assert(m);
1717
1718         if (m->state == MOUNT_FAILED)
1719                 mount_set_state(m, MOUNT_DEAD);
1720
1721         m->result = MOUNT_SUCCESS;
1722         m->reload_result = MOUNT_SUCCESS;
1723 }
1724
1725 static int mount_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
1726         return unit_kill_common(u, who, signo, -1, MOUNT(u)->control_pid, error);
1727 }
1728
1729 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1730         [MOUNT_DEAD] = "dead",
1731         [MOUNT_MOUNTING] = "mounting",
1732         [MOUNT_MOUNTING_DONE] = "mounting-done",
1733         [MOUNT_MOUNTED] = "mounted",
1734         [MOUNT_REMOUNTING] = "remounting",
1735         [MOUNT_UNMOUNTING] = "unmounting",
1736         [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1737         [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1738         [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1739         [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1740         [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1741         [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1742         [MOUNT_FAILED] = "failed"
1743 };
1744
1745 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1746
1747 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1748         [MOUNT_EXEC_MOUNT] = "ExecMount",
1749         [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1750         [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1751 };
1752
1753 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1754
1755 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1756         [MOUNT_SUCCESS] = "success",
1757         [MOUNT_FAILURE_RESOURCES] = "resources",
1758         [MOUNT_FAILURE_TIMEOUT] = "timeout",
1759         [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1760         [MOUNT_FAILURE_SIGNAL] = "signal",
1761         [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1762 };
1763
1764 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1765
1766 const UnitVTable mount_vtable = {
1767         .object_size = sizeof(Mount),
1768         .exec_context_offset = offsetof(Mount, exec_context),
1769         .cgroup_context_offset = offsetof(Mount, cgroup_context),
1770         .kill_context_offset = offsetof(Mount, kill_context),
1771         .exec_runtime_offset = offsetof(Mount, exec_runtime),
1772
1773         .sections =
1774                 "Unit\0"
1775                 "Mount\0"
1776                 "Install\0",
1777         .private_section = "Mount",
1778
1779         .no_alias = true,
1780         .no_instances = true,
1781
1782         .init = mount_init,
1783         .load = mount_load,
1784         .done = mount_done,
1785
1786         .coldplug = mount_coldplug,
1787
1788         .dump = mount_dump,
1789
1790         .start = mount_start,
1791         .stop = mount_stop,
1792         .reload = mount_reload,
1793
1794         .kill = mount_kill,
1795
1796         .serialize = mount_serialize,
1797         .deserialize_item = mount_deserialize_item,
1798
1799         .active_state = mount_active_state,
1800         .sub_state_to_string = mount_sub_state_to_string,
1801
1802         .check_gc = mount_check_gc,
1803
1804         .sigchld_event = mount_sigchld_event,
1805
1806         .reset_failed = mount_reset_failed,
1807
1808         .bus_interface = "org.freedesktop.systemd1.Mount",
1809         .bus_vtable = bus_mount_vtable,
1810         .bus_set_property = bus_mount_set_property,
1811         .bus_commit_properties = bus_mount_commit_properties,
1812
1813         .get_timeout = mount_get_timeout,
1814
1815         .enumerate = mount_enumerate,
1816         .shutdown = mount_shutdown,
1817
1818         .status_message_formats = {
1819                 .starting_stopping = {
1820                         [0] = "Mounting %s...",
1821                         [1] = "Unmounting %s...",
1822                 },
1823                 .finished_start_job = {
1824                         [JOB_DONE]       = "Mounted %s.",
1825                         [JOB_FAILED]     = "Failed to mount %s.",
1826                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
1827                         [JOB_TIMEOUT]    = "Timed out mounting %s.",
1828                 },
1829                 .finished_stop_job = {
1830                         [JOB_DONE]       = "Unmounted %s.",
1831                         [JOB_FAILED]     = "Failed unmounting %s.",
1832                         [JOB_TIMEOUT]    = "Timed out unmounting %s.",
1833                 },
1834         },
1835 };