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_unit_error(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_unit_error(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_unit_error(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_unit_error(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_unit_debug(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         ExecParameters exec_params = {
 695                 .apply_permissions = true,
 696                 .apply_chroot      = true,
 697                 .apply_tty_stdin   = true,
 698         };
 699
 700         assert(m);
 701         assert(c);
 702         assert(_pid);
 703
 704         unit_realize_cgroup(UNIT(m));
 705
 706         r = unit_setup_exec_runtime(UNIT(m));
 707         if (r < 0)
 708                 goto fail;
 709
 710         r = mount_arm_timer(m);
 711         if (r < 0)
 712                 goto fail;
 713
 714         exec_params.environment = UNIT(m)->manager->environment;
 715         exec_params.confirm_spawn = UNIT(m)->manager->confirm_spawn;
 716         exec_params.cgroup_supported = UNIT(m)->manager->cgroup_supported;
 717         exec_params.cgroup_path = UNIT(m)->cgroup_path;
 718         exec_params.cgroup_delegate = m->cgroup_context.delegate;
 719         exec_params.runtime_prefix = manager_get_runtime_prefix(UNIT(m)->manager);
 720         exec_params.unit_id = UNIT(m)->id;
 721
 722         r = exec_spawn(c,
 723                        &m->exec_context,
 724                        &exec_params,
 725                        m->exec_runtime,
 726                        &pid);
 727         if (r < 0)
 728                 goto fail;
 729
 730         r = unit_watch_pid(UNIT(m), pid);
 731         if (r < 0)
 732                 /* FIXME: we need to do something here */
 733                 goto fail;
 734
 735         *_pid = pid;
 736
 737         return 0;
 738
 739 fail:
 740         m->timer_event_source = sd_event_source_unref(m->timer_event_source);
 741
 742         return r;
 743 }
 744
 745 static void mount_enter_dead(Mount *m, MountResult f) {
 746         assert(m);
 747
 748         if (f != MOUNT_SUCCESS)
 749                 m->result = f;
 750
 751         exec_runtime_destroy(m->exec_runtime);
 752         m->exec_runtime = exec_runtime_unref(m->exec_runtime);
 753
 754         exec_context_destroy_runtime_directory(&m->exec_context, manager_get_runtime_prefix(UNIT(m)->manager));
 755
 756         mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
 757 }
 758
 759 static void mount_enter_mounted(Mount *m, MountResult f) {
 760         assert(m);
 761
 762         if (f != MOUNT_SUCCESS)
 763                 m->result = f;
 764
 765         mount_set_state(m, MOUNT_MOUNTED);
 766 }
 767
 768 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
 769         int r;
 770
 771         assert(m);
 772
 773         if (f != MOUNT_SUCCESS)
 774                 m->result = f;
 775
 776         r = unit_kill_context(
 777                         UNIT(m),
 778                         &m->kill_context,
 779                         (state != MOUNT_MOUNTING_SIGTERM && state != MOUNT_UNMOUNTING_SIGTERM && state != MOUNT_REMOUNTING_SIGTERM) ?
 780                         KILL_KILL : KILL_TERMINATE,
 781                         -1,
 782                         m->control_pid,
 783                         false);
 784         if (r < 0)
 785                 goto fail;
 786
 787         if (r > 0) {
 788                 r = mount_arm_timer(m);
 789                 if (r < 0)
 790                         goto fail;
 791
 792                 mount_set_state(m, state);
 793         } else if (state == MOUNT_REMOUNTING_SIGTERM)
 794                 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_SUCCESS);
 795         else if (state == MOUNT_REMOUNTING_SIGKILL)
 796                 mount_enter_mounted(m, MOUNT_SUCCESS);
 797         else if (state == MOUNT_MOUNTING_SIGTERM)
 798                 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_SUCCESS);
 799         else if (state == MOUNT_UNMOUNTING_SIGTERM)
 800                 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_SUCCESS);
 801         else
 802                 mount_enter_dead(m, MOUNT_SUCCESS);
 803
 804         return;
 805
 806 fail:
 807         log_unit_warning(UNIT(m)->id,
 808                          "%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
 809
 810         if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
 811                 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
 812         else
 813                 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
 814 }
 815
 816 void warn_if_dir_nonempty(const char *unit, const char* where) {
 817         int r;
 818
 819         assert(unit);
 820         assert(where);
 821
 822         r = dir_is_empty(where);
 823         if (r > 0)
 824                 return;
 825         else if (r == 0)
 826                 log_unit_struct(LOG_NOTICE,
 827                                 unit,
 828                                 "MESSAGE=%s: Directory %s to mount over is not empty, mounting anyway.",
 829                                 unit, where,
 830                                 "WHERE=%s", where,
 831                                 MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
 832                                 NULL);
 833         else
 834                 log_unit_warning(unit,
 835                                  "MESSAGE=Failed to check directory %s: %s",
 836                                  where, strerror(-r));
 837 }
 838
 839 static int fail_if_symlink(const char *unit, const char* where) {
 840         assert(where);
 841
 842         if (is_symlink(where) > 0) {
 843                 log_unit_struct(LOG_WARNING,
 844                                 unit,
 845                                 "MESSAGE=%s: Mount on symlink %s not allowed.",
 846                                 unit, where,
 847                                 "WHERE=%s", where,
 848                                 MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
 849                                 NULL);
 850
 851                 return -ELOOP;
 852         }
 853         return 0;
 854 }
 855
 856 static void mount_enter_unmounting(Mount *m) {
 857         int r;
 858
 859         assert(m);
 860
 861         m->control_command_id = MOUNT_EXEC_UNMOUNT;
 862         m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
 863
 864         if ((r = exec_command_set(
 865                              m->control_command,
 866                              "/bin/umount",
 867                              "-n",
 868                              m->where,
 869                              NULL)) < 0)
 870                 goto fail;
 871
 872         mount_unwatch_control_pid(m);
 873
 874         if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
 875                 goto fail;
 876
 877         mount_set_state(m, MOUNT_UNMOUNTING);
 878
 879         return;
 880
 881 fail:
 882         log_unit_warning(UNIT(m)->id,
 883                          "%s failed to run 'umount' task: %s",
 884                          UNIT(m)->id, strerror(-r));
 885         mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
 886 }
 887
 888 static void mount_enter_mounting(Mount *m) {
 889         int r;
 890         MountParameters *p;
 891
 892         assert(m);
 893
 894         m->control_command_id = MOUNT_EXEC_MOUNT;
 895         m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
 896
 897         mkdir_p_label(m->where, m->directory_mode);
 898
 899         warn_if_dir_nonempty(m->meta.id, m->where);
 900
 901         /* Create the source directory for bind-mounts if needed */
 902         p = get_mount_parameters_fragment(m);
 903         if (p && mount_is_bind(p))
 904                 mkdir_p_label(p->what, m->directory_mode);
 905
 906         r = fail_if_symlink(m->meta.id, m->where);
 907         if (r < 0)
 908                 goto fail;
 909
 910         if (m->from_fragment)
 911                 r = exec_command_set(
 912                                 m->control_command,
 913                                 "/bin/mount",
 914                                 m->sloppy_options ? "-ns" : "-n",
 915                                 m->parameters_fragment.what,
 916                                 m->where,
 917                                 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
 918                                 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
 919                                 NULL);
 920         else
 921                 r = -ENOENT;
 922
 923         if (r < 0)
 924                 goto fail;
 925
 926         mount_unwatch_control_pid(m);
 927
 928         r = mount_spawn(m, m->control_command, &m->control_pid);
 929         if (r < 0)
 930                 goto fail;
 931
 932         mount_set_state(m, MOUNT_MOUNTING);
 933
 934         return;
 935
 936 fail:
 937         log_unit_warning(UNIT(m)->id,
 938                          "%s failed to run 'mount' task: %s",
 939                          UNIT(m)->id, strerror(-r));
 940         mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
 941 }
 942
 943 static void mount_enter_remounting(Mount *m) {
 944         int r;
 945
 946         assert(m);
 947
 948         m->control_command_id = MOUNT_EXEC_REMOUNT;
 949         m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
 950
 951         if (m->from_fragment) {
 952                 const char *o;
 953
 954                 if (m->parameters_fragment.options)
 955                         o = strappenda("remount,", m->parameters_fragment.options);
 956                 else
 957                         o = "remount";
 958
 959                 r = exec_command_set(
 960                                 m->control_command,
 961                                 "/bin/mount",
 962                                 m->sloppy_options ? "-ns" : "-n",
 963                                 m->parameters_fragment.what,
 964                                 m->where,
 965                                 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
 966                                 "-o", o,
 967                                 NULL);
 968         } else
 969                 r = -ENOENT;
 970
 971         if (r < 0)
 972                 goto fail;
 973
 974         mount_unwatch_control_pid(m);
 975
 976         r = mount_spawn(m, m->control_command, &m->control_pid);
 977         if (r < 0)
 978                 goto fail;
 979
 980         mount_set_state(m, MOUNT_REMOUNTING);
 981
 982         return;
 983
 984 fail:
 985         log_unit_warning(UNIT(m)->id,
 986                          "%s failed to run 'remount' task: %s",
 987                          UNIT(m)->id, strerror(-r));
 988         m->reload_result = MOUNT_FAILURE_RESOURCES;
 989         mount_enter_mounted(m, MOUNT_SUCCESS);
 990 }
 991
 992 static int mount_start(Unit *u) {
 993         Mount *m = MOUNT(u);
 994
 995         assert(m);
 996
 997         /* We cannot fulfill this request right now, try again later
 998          * please! */
 999         if (m->state == MOUNT_UNMOUNTING ||
1000             m->state == MOUNT_UNMOUNTING_SIGTERM ||
1001             m->state == MOUNT_UNMOUNTING_SIGKILL ||
1002             m->state == MOUNT_MOUNTING_SIGTERM ||
1003             m->state == MOUNT_MOUNTING_SIGKILL)
1004                 return -EAGAIN;
1005
1006         /* Already on it! */
1007         if (m->state == MOUNT_MOUNTING)
1008                 return 0;
1009
1010         assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1011
1012         m->result = MOUNT_SUCCESS;
1013         m->reload_result = MOUNT_SUCCESS;
1014
1015         mount_enter_mounting(m);
1016         return 0;
1017 }
1018
1019 static int mount_stop(Unit *u) {
1020         Mount *m = MOUNT(u);
1021
1022         assert(m);
1023
1024         /* Already on it */
1025         if (m->state == MOUNT_UNMOUNTING ||
1026             m->state == MOUNT_UNMOUNTING_SIGKILL ||
1027             m->state == MOUNT_UNMOUNTING_SIGTERM ||
1028             m->state == MOUNT_MOUNTING_SIGTERM ||
1029             m->state == MOUNT_MOUNTING_SIGKILL)
1030                 return 0;
1031
1032         assert(m->state == MOUNT_MOUNTING ||
1033                m->state == MOUNT_MOUNTING_DONE ||
1034                m->state == MOUNT_MOUNTED ||
1035                m->state == MOUNT_REMOUNTING ||
1036                m->state == MOUNT_REMOUNTING_SIGTERM ||
1037                m->state == MOUNT_REMOUNTING_SIGKILL);
1038
1039         mount_enter_unmounting(m);
1040         return 0;
1041 }
1042
1043 static int mount_reload(Unit *u) {
1044         Mount *m = MOUNT(u);
1045
1046         assert(m);
1047
1048         if (m->state == MOUNT_MOUNTING_DONE)
1049                 return -EAGAIN;
1050
1051         assert(m->state == MOUNT_MOUNTED);
1052
1053         mount_enter_remounting(m);
1054         return 0;
1055 }
1056
1057 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1058         Mount *m = MOUNT(u);
1059
1060         assert(m);
1061         assert(f);
1062         assert(fds);
1063
1064         unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1065         unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1066         unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1067
1068         if (m->control_pid > 0)
1069                 unit_serialize_item_format(u, f, "control-pid", PID_FMT, m->control_pid);
1070
1071         if (m->control_command_id >= 0)
1072                 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1073
1074         return 0;
1075 }
1076
1077 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1078         Mount *m = MOUNT(u);
1079
1080         assert(u);
1081         assert(key);
1082         assert(value);
1083         assert(fds);
1084
1085         if (streq(key, "state")) {
1086                 MountState state;
1087
1088                 if ((state = mount_state_from_string(value)) < 0)
1089                         log_unit_debug(u->id, "Failed to parse state value %s", value);
1090                 else
1091                         m->deserialized_state = state;
1092         } else if (streq(key, "result")) {
1093                 MountResult f;
1094
1095                 f = mount_result_from_string(value);
1096                 if (f < 0)
1097                         log_unit_debug(UNIT(m)->id,
1098                                        "Failed to parse result value %s", value);
1099                 else if (f != MOUNT_SUCCESS)
1100                         m->result = f;
1101
1102         } else if (streq(key, "reload-result")) {
1103                 MountResult f;
1104
1105                 f = mount_result_from_string(value);
1106                 if (f < 0)
1107                         log_unit_debug(UNIT(m)->id,
1108                                        "Failed to parse reload result value %s", value);
1109                 else if (f != MOUNT_SUCCESS)
1110                         m->reload_result = f;
1111
1112         } else if (streq(key, "control-pid")) {
1113                 pid_t pid;
1114
1115                 if (parse_pid(value, &pid) < 0)
1116                         log_unit_debug(UNIT(m)->id,
1117                                        "Failed to parse control-pid value %s", value);
1118                 else
1119                         m->control_pid = pid;
1120         } else if (streq(key, "control-command")) {
1121                 MountExecCommand id;
1122
1123                 if ((id = mount_exec_command_from_string(value)) < 0)
1124                         log_unit_debug(UNIT(m)->id,
1125                                        "Failed to parse exec-command value %s", value);
1126                 else {
1127                         m->control_command_id = id;
1128                         m->control_command = m->exec_command + id;
1129                 }
1130         } else
1131                 log_unit_debug(UNIT(m)->id,
1132                                "Unknown serialization key '%s'", key);
1133
1134         return 0;
1135 }
1136
1137 _pure_ static UnitActiveState mount_active_state(Unit *u) {
1138         assert(u);
1139
1140         return state_translation_table[MOUNT(u)->state];
1141 }
1142
1143 _pure_ static const char *mount_sub_state_to_string(Unit *u) {
1144         assert(u);
1145
1146         return mount_state_to_string(MOUNT(u)->state);
1147 }
1148
1149 _pure_ static bool mount_check_gc(Unit *u) {
1150         Mount *m = MOUNT(u);
1151
1152         assert(m);
1153
1154         return m->from_proc_self_mountinfo;
1155 }
1156
1157 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1158         Mount *m = MOUNT(u);
1159         MountResult f;
1160
1161         assert(m);
1162         assert(pid >= 0);
1163
1164         if (pid != m->control_pid)
1165                 return;
1166
1167         m->control_pid = 0;
1168
1169         if (is_clean_exit(code, status, NULL))
1170                 f = MOUNT_SUCCESS;
1171         else if (code == CLD_EXITED)
1172                 f = MOUNT_FAILURE_EXIT_CODE;
1173         else if (code == CLD_KILLED)
1174                 f = MOUNT_FAILURE_SIGNAL;
1175         else if (code == CLD_DUMPED)
1176                 f = MOUNT_FAILURE_CORE_DUMP;
1177         else
1178                 assert_not_reached("Unknown code");
1179
1180         if (f != MOUNT_SUCCESS)
1181                 m->result = f;
1182
1183         if (m->control_command) {
1184                 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1185
1186                 m->control_command = NULL;
1187                 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1188         }
1189
1190         log_unit_full(u->id,
1191                       f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1192                       "%s mount process exited, code=%s status=%i",
1193                       u->id, sigchld_code_to_string(code), status);
1194
1195         /* Note that mount(8) returning and the kernel sending us a
1196          * mount table change event might happen out-of-order. If an
1197          * operation succeed we assume the kernel will follow soon too
1198          * and already change into the resulting state.  If it fails
1199          * we check if the kernel still knows about the mount. and
1200          * change state accordingly. */
1201
1202         switch (m->state) {
1203
1204         case MOUNT_MOUNTING:
1205         case MOUNT_MOUNTING_DONE:
1206         case MOUNT_MOUNTING_SIGKILL:
1207         case MOUNT_MOUNTING_SIGTERM:
1208
1209                 if (f == MOUNT_SUCCESS)
1210                         mount_enter_mounted(m, f);
1211                 else if (m->from_proc_self_mountinfo)
1212                         mount_enter_mounted(m, f);
1213                 else
1214                         mount_enter_dead(m, f);
1215                 break;
1216
1217         case MOUNT_REMOUNTING:
1218         case MOUNT_REMOUNTING_SIGKILL:
1219         case MOUNT_REMOUNTING_SIGTERM:
1220
1221                 m->reload_result = f;
1222                 if (m->from_proc_self_mountinfo)
1223                         mount_enter_mounted(m, MOUNT_SUCCESS);
1224                 else
1225                         mount_enter_dead(m, MOUNT_SUCCESS);
1226
1227                 break;
1228
1229         case MOUNT_UNMOUNTING:
1230         case MOUNT_UNMOUNTING_SIGKILL:
1231         case MOUNT_UNMOUNTING_SIGTERM:
1232
1233                 if (f == MOUNT_SUCCESS)
1234                         mount_enter_dead(m, f);
1235                 else if (m->from_proc_self_mountinfo)
1236                         mount_enter_mounted(m, f);
1237                 else
1238                         mount_enter_dead(m, f);
1239                 break;
1240
1241         default:
1242                 assert_not_reached("Uh, control process died at wrong time.");
1243         }
1244
1245         /* Notify clients about changed exit status */
1246         unit_add_to_dbus_queue(u);
1247 }
1248
1249 static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
1250         Mount *m = MOUNT(userdata);
1251
1252         assert(m);
1253         assert(m->timer_event_source == source);
1254
1255         switch (m->state) {
1256
1257         case MOUNT_MOUNTING:
1258         case MOUNT_MOUNTING_DONE:
1259                 log_unit_warning(UNIT(m)->id,
1260                                  "%s mounting timed out. Stopping.", UNIT(m)->id);
1261                 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1262                 break;
1263
1264         case MOUNT_REMOUNTING:
1265                 log_unit_warning(UNIT(m)->id,
1266                                  "%s remounting timed out. Stopping.", UNIT(m)->id);
1267                 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1268                 mount_enter_mounted(m, MOUNT_SUCCESS);
1269                 break;
1270
1271         case MOUNT_UNMOUNTING:
1272                 log_unit_warning(UNIT(m)->id,
1273                                  "%s unmounting timed out. Stopping.", UNIT(m)->id);
1274                 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1275                 break;
1276
1277         case MOUNT_MOUNTING_SIGTERM:
1278                 if (m->kill_context.send_sigkill) {
1279                         log_unit_warning(UNIT(m)->id,
1280                                          "%s mounting timed out. Killing.", UNIT(m)->id);
1281                         mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1282                 } else {
1283                         log_unit_warning(UNIT(m)->id,
1284                                          "%s mounting timed out. Skipping SIGKILL. Ignoring.",
1285                                          UNIT(m)->id);
1286
1287                         if (m->from_proc_self_mountinfo)
1288                                 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1289                         else
1290                                 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1291                 }
1292                 break;
1293
1294         case MOUNT_REMOUNTING_SIGTERM:
1295                 if (m->kill_context.send_sigkill) {
1296                         log_unit_warning(UNIT(m)->id,
1297                                          "%s remounting timed out. Killing.", UNIT(m)->id);
1298                         mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1299                 } else {
1300                         log_unit_warning(UNIT(m)->id,
1301                                          "%s remounting timed out. Skipping 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                 }
1309                 break;
1310
1311         case MOUNT_UNMOUNTING_SIGTERM:
1312                 if (m->kill_context.send_sigkill) {
1313                         log_unit_warning(UNIT(m)->id,
1314                                          "%s unmounting timed out. Killing.", UNIT(m)->id);
1315                         mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1316                 } else {
1317                         log_unit_warning(UNIT(m)->id,
1318                                          "%s unmounting timed out. Skipping SIGKILL. Ignoring.",
1319                                          UNIT(m)->id);
1320
1321                         if (m->from_proc_self_mountinfo)
1322                                 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1323                         else
1324                                 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1325                 }
1326                 break;
1327
1328         case MOUNT_MOUNTING_SIGKILL:
1329         case MOUNT_REMOUNTING_SIGKILL:
1330         case MOUNT_UNMOUNTING_SIGKILL:
1331                 log_unit_warning(UNIT(m)->id,
1332                                  "%s mount process still around after SIGKILL. Ignoring.",
1333                                  UNIT(m)->id);
1334
1335                 if (m->from_proc_self_mountinfo)
1336                         mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1337                 else
1338                         mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1339                 break;
1340
1341         default:
1342                 assert_not_reached("Timeout at wrong time.");
1343         }
1344
1345         return 0;
1346 }
1347
1348 static int mount_add_one(
1349                 Manager *m,
1350                 const char *what,
1351                 const char *where,
1352                 const char *options,
1353                 const char *fstype,
1354                 bool set_flags) {
1355
1356         _cleanup_free_ char *e = NULL, *w = NULL, *o = NULL, *f = NULL;
1357         bool load_extras = false;
1358         MountParameters *p;
1359         bool delete, changed = false;
1360         Unit *u;
1361         int r;
1362
1363         assert(m);
1364         assert(what);
1365         assert(where);
1366         assert(options);
1367         assert(fstype);
1368
1369         /* Ignore API mount points. They should never be referenced in
1370          * dependencies ever. */
1371         if (mount_point_is_api(where) || mount_point_ignore(where))
1372                 return 0;
1373
1374         if (streq(fstype, "autofs"))
1375                 return 0;
1376
1377         /* probably some kind of swap, ignore */
1378         if (!is_path(where))
1379                 return 0;
1380
1381         e = unit_name_from_path(where, ".mount");
1382         if (!e)
1383                 return -ENOMEM;
1384
1385         u = manager_get_unit(m, e);
1386         if (!u) {
1387                 delete = true;
1388
1389                 u = unit_new(m, sizeof(Mount));
1390                 if (!u)
1391                         return -ENOMEM;
1392
1393                 r = unit_add_name(u, e);
1394                 if (r < 0)
1395                         goto fail;
1396
1397                 MOUNT(u)->where = strdup(where);
1398                 if (!MOUNT(u)->where) {
1399                         r = -ENOMEM;
1400                         goto fail;
1401                 }
1402
1403                 u->source_path = strdup("/proc/self/mountinfo");
1404                 if (!u->source_path) {
1405                         r = -ENOMEM;
1406                         goto fail;
1407                 }
1408
1409
1410                 if (m->running_as == SYSTEMD_SYSTEM) {
1411                         const char* target;
1412
1413                         target = fstype_is_network(fstype) ? SPECIAL_REMOTE_FS_TARGET : SPECIAL_LOCAL_FS_TARGET;
1414
1415                         r = unit_add_dependency_by_name(u, UNIT_BEFORE, target, NULL, true);
1416                         if (r < 0)
1417                                 goto fail;
1418
1419                         if (should_umount(MOUNT(u))) {
1420                                 r = unit_add_dependency_by_name(u, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
1421                                 if (r < 0)
1422                                         goto fail;
1423                         }
1424                 }
1425
1426                 unit_add_to_load_queue(u);
1427                 changed = true;
1428         } else {
1429                 delete = false;
1430
1431                 if (!MOUNT(u)->where) {
1432                         MOUNT(u)->where = strdup(where);
1433                         if (!MOUNT(u)->where) {
1434                                 r = -ENOMEM;
1435                                 goto fail;
1436                         }
1437                 }
1438
1439                 if (u->load_state == UNIT_NOT_FOUND) {
1440                         u->load_state = UNIT_LOADED;
1441                         u->load_error = 0;
1442
1443                         /* Load in the extras later on, after we
1444                          * finished initialization of the unit */
1445                         load_extras = true;
1446                         changed = true;
1447                 }
1448         }
1449
1450         w = strdup(what);
1451         o = strdup(options);
1452         f = strdup(fstype);
1453         if (!w || !o || !f) {
1454                 r = -ENOMEM;
1455                 goto fail;
1456         }
1457
1458         p = &MOUNT(u)->parameters_proc_self_mountinfo;
1459
1460         changed = changed ||
1461                 !streq_ptr(p->options, options) ||
1462                 !streq_ptr(p->what, what) ||
1463                 !streq_ptr(p->fstype, fstype);
1464
1465         if (set_flags) {
1466                 MOUNT(u)->is_mounted = true;
1467                 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1468                 MOUNT(u)->just_changed = changed;
1469         }
1470
1471         MOUNT(u)->from_proc_self_mountinfo = true;
1472
1473         free(p->what);
1474         p->what = w;
1475         w = NULL;
1476
1477         free(p->options);
1478         p->options = o;
1479         o = NULL;
1480
1481         free(p->fstype);
1482         p->fstype = f;
1483         f = NULL;
1484
1485         if (load_extras) {
1486                 r = mount_add_extras(MOUNT(u));
1487                 if (r < 0)
1488                         goto fail;
1489         }
1490
1491         if (changed)
1492                 unit_add_to_dbus_queue(u);
1493
1494         return 0;
1495
1496 fail:
1497         if (delete && u)
1498                 unit_free(u);
1499
1500         return r;
1501 }
1502
1503 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1504         int r = 0;
1505         unsigned i;
1506
1507         assert(m);
1508
1509         rewind(m->proc_self_mountinfo);
1510
1511         for (i = 1;; i++) {
1512                 _cleanup_free_ char *device = NULL, *path = NULL, *options = NULL, *options2 = NULL, *fstype = NULL, *d = NULL, *p = NULL, *o = NULL;
1513                 int k;
1514
1515                 k = fscanf(m->proc_self_mountinfo,
1516                            "%*s "       /* (1) mount id */
1517                            "%*s "       /* (2) parent id */
1518                            "%*s "       /* (3) major:minor */
1519                            "%*s "       /* (4) root */
1520                            "%ms "       /* (5) mount point */
1521                            "%ms"        /* (6) mount options */
1522                            "%*[^-]"     /* (7) optional fields */
1523                            "- "         /* (8) separator */
1524                            "%ms "       /* (9) file system type */
1525                            "%ms"        /* (10) mount source */
1526                            "%ms"        /* (11) mount options 2 */
1527                            "%*[^\n]",   /* some rubbish at the end */
1528                            &path,
1529                            &options,
1530                            &fstype,
1531                            &device,
1532                            &options2);
1533
1534                 if (k == EOF)
1535                         break;
1536
1537                 if (k != 5) {
1538                         log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1539                         continue;
1540                 }
1541
1542                 o = strjoin(options, ",", options2, NULL);
1543                 if (!o)
1544                         return log_oom();
1545
1546                 d = cunescape(device);
1547                 p = cunescape(path);
1548                 if (!d || !p)
1549                         return log_oom();
1550
1551                 k = mount_add_one(m, d, p, o, fstype, set_flags);
1552                 if (k < 0)
1553                         r = k;
1554         }
1555
1556         return r;
1557 }
1558
1559 static void mount_shutdown(Manager *m) {
1560         assert(m);
1561
1562         m->mount_event_source = sd_event_source_unref(m->mount_event_source);
1563
1564         if (m->proc_self_mountinfo) {
1565                 fclose(m->proc_self_mountinfo);
1566                 m->proc_self_mountinfo = NULL;
1567         }
1568 }
1569
1570 static int mount_get_timeout(Unit *u, uint64_t *timeout) {
1571         Mount *m = MOUNT(u);
1572         int r;
1573
1574         if (!m->timer_event_source)
1575                 return 0;
1576
1577         r = sd_event_source_get_time(m->timer_event_source, timeout);
1578         if (r < 0)
1579                 return r;
1580
1581         return 1;
1582 }
1583
1584 static int mount_enumerate(Manager *m) {
1585         int r;
1586         assert(m);
1587
1588         if (!m->proc_self_mountinfo) {
1589                 m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
1590                 if (!m->proc_self_mountinfo)
1591                         return -errno;
1592
1593                 r = sd_event_add_io(m->event, &m->mount_event_source, fileno(m->proc_self_mountinfo), EPOLLPRI, mount_dispatch_io, m);
1594                 if (r < 0)
1595                         goto fail;
1596
1597                 /* Dispatch this before we dispatch SIGCHLD, so that
1598                  * we always get the events from /proc/self/mountinfo
1599                  * before the SIGCHLD of /bin/mount. */
1600                 r = sd_event_source_set_priority(m->mount_event_source, -10);
1601                 if (r < 0)
1602                         goto fail;
1603         }
1604
1605         r = mount_load_proc_self_mountinfo(m, false);
1606         if (r < 0)
1607                 goto fail;
1608
1609         return 0;
1610
1611 fail:
1612         mount_shutdown(m);
1613         return r;
1614 }
1615
1616 static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1617         Manager *m = userdata;
1618         Unit *u;
1619         int r;
1620
1621         assert(m);
1622         assert(revents & EPOLLPRI);
1623
1624         /* The manager calls this for every fd event happening on the
1625          * /proc/self/mountinfo file, which informs us about mounting
1626          * table changes */
1627
1628         r = mount_load_proc_self_mountinfo(m, true);
1629         if (r < 0) {
1630                 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1631
1632                 /* Reset flags, just in case, for later calls */
1633                 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1634                         Mount *mount = MOUNT(u);
1635
1636                         mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1637                 }
1638
1639                 return 0;
1640         }
1641
1642         manager_dispatch_load_queue(m);
1643
1644         LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1645                 Mount *mount = MOUNT(u);
1646
1647                 if (!mount->is_mounted) {
1648
1649                         mount->from_proc_self_mountinfo = false;
1650
1651                         switch (mount->state) {
1652
1653                         case MOUNT_MOUNTED:
1654                                 /* This has just been unmounted by
1655                                  * somebody else, follow the state
1656                                  * change. */
1657                                 mount_enter_dead(mount, MOUNT_SUCCESS);
1658                                 break;
1659
1660                         default:
1661                                 break;
1662                         }
1663
1664                 } else if (mount->just_mounted || mount->just_changed) {
1665
1666                         /* New or changed mount entry */
1667
1668                         switch (mount->state) {
1669
1670                         case MOUNT_DEAD:
1671                         case MOUNT_FAILED:
1672                                 /* This has just been mounted by
1673                                  * somebody else, follow the state
1674                                  * change. */
1675                                 mount_enter_mounted(mount, MOUNT_SUCCESS);
1676                                 break;
1677
1678                         case MOUNT_MOUNTING:
1679                                 mount_set_state(mount, MOUNT_MOUNTING_DONE);
1680                                 break;
1681
1682                         default:
1683                                 /* Nothing really changed, but let's
1684                                  * issue an notification call
1685                                  * nonetheless, in case somebody is
1686                                  * waiting for this. (e.g. file system
1687                                  * ro/rw remounts.) */
1688                                 mount_set_state(mount, mount->state);
1689                                 break;
1690                         }
1691                 }
1692
1693                 /* Reset the flags for later calls */
1694                 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1695         }
1696
1697         return 0;
1698 }
1699
1700 static void mount_reset_failed(Unit *u) {
1701         Mount *m = MOUNT(u);
1702
1703         assert(m);
1704
1705         if (m->state == MOUNT_FAILED)
1706                 mount_set_state(m, MOUNT_DEAD);
1707
1708         m->result = MOUNT_SUCCESS;
1709         m->reload_result = MOUNT_SUCCESS;
1710 }
1711
1712 static int mount_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
1713         return unit_kill_common(u, who, signo, -1, MOUNT(u)->control_pid, error);
1714 }
1715
1716 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1717         [MOUNT_DEAD] = "dead",
1718         [MOUNT_MOUNTING] = "mounting",
1719         [MOUNT_MOUNTING_DONE] = "mounting-done",
1720         [MOUNT_MOUNTED] = "mounted",
1721         [MOUNT_REMOUNTING] = "remounting",
1722         [MOUNT_UNMOUNTING] = "unmounting",
1723         [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1724         [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1725         [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1726         [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1727         [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1728         [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1729         [MOUNT_FAILED] = "failed"
1730 };
1731
1732 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1733
1734 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1735         [MOUNT_EXEC_MOUNT] = "ExecMount",
1736         [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1737         [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1738 };
1739
1740 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1741
1742 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1743         [MOUNT_SUCCESS] = "success",
1744         [MOUNT_FAILURE_RESOURCES] = "resources",
1745         [MOUNT_FAILURE_TIMEOUT] = "timeout",
1746         [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1747         [MOUNT_FAILURE_SIGNAL] = "signal",
1748         [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1749 };
1750
1751 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1752
1753 const UnitVTable mount_vtable = {
1754         .object_size = sizeof(Mount),
1755         .exec_context_offset = offsetof(Mount, exec_context),
1756         .cgroup_context_offset = offsetof(Mount, cgroup_context),
1757         .kill_context_offset = offsetof(Mount, kill_context),
1758         .exec_runtime_offset = offsetof(Mount, exec_runtime),
1759
1760         .sections =
1761                 "Unit\0"
1762                 "Mount\0"
1763                 "Install\0",
1764         .private_section = "Mount",
1765
1766         .no_alias = true,
1767         .no_instances = true,
1768
1769         .init = mount_init,
1770         .load = mount_load,
1771         .done = mount_done,
1772
1773         .coldplug = mount_coldplug,
1774
1775         .dump = mount_dump,
1776
1777         .start = mount_start,
1778         .stop = mount_stop,
1779         .reload = mount_reload,
1780
1781         .kill = mount_kill,
1782
1783         .serialize = mount_serialize,
1784         .deserialize_item = mount_deserialize_item,
1785
1786         .active_state = mount_active_state,
1787         .sub_state_to_string = mount_sub_state_to_string,
1788
1789         .check_gc = mount_check_gc,
1790
1791         .sigchld_event = mount_sigchld_event,
1792
1793         .reset_failed = mount_reset_failed,
1794
1795         .bus_interface = "org.freedesktop.systemd1.Mount",
1796         .bus_vtable = bus_mount_vtable,
1797         .bus_set_property = bus_mount_set_property,
1798         .bus_commit_properties = bus_mount_commit_properties,
1799
1800         .get_timeout = mount_get_timeout,
1801
1802         .can_transient = true,
1803
1804         .enumerate = mount_enumerate,
1805         .shutdown = mount_shutdown,
1806
1807         .status_message_formats = {
1808                 .starting_stopping = {
1809                         [0] = "Mounting %s...",
1810                         [1] = "Unmounting %s...",
1811                 },
1812                 .finished_start_job = {
1813                         [JOB_DONE]       = "Mounted %s.",
1814                         [JOB_FAILED]     = "Failed to mount %s.",
1815                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
1816                         [JOB_TIMEOUT]    = "Timed out mounting %s.",
1817                 },
1818                 .finished_stop_job = {
1819                         [JOB_DONE]       = "Unmounted %s.",
1820                         [JOB_FAILED]     = "Failed unmounting %s.",
1821                         [JOB_TIMEOUT]    = "Timed out unmounting %s.",
1822                 },
1823         },
1824 };