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