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