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