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