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