src/core/mount.c

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