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