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