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                 return 0;
 385
 386         if (mount_is_network(p)) {
 387                 after = SPECIAL_REMOTE_FS_PRE_TARGET;
 388                 after2 = SPECIAL_NETWORK_TARGET;
 389                 online = SPECIAL_NETWORK_ONLINE_TARGET;
 390         } else {
 391                 after = SPECIAL_LOCAL_FS_PRE_TARGET;
 392                 after2 = NULL;
 393                 online = NULL;
 394         }
 395
 396         r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after, NULL, true);
 397         if (r < 0)
 398                 return r;
 399
 400         if (after2) {
 401                 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after2, NULL, true);
 402                 if (r < 0)
 403                         return r;
 404         }
 405
 406         if (online) {
 407                 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_WANTS, UNIT_AFTER, online, NULL, true);
 408                 if (r < 0)
 409                         return r;
 410         }
 411
 412         if (should_umount(m)) {
 413                 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
 414                 if (r < 0)
 415                         return r;
 416         }
 417
 418         return 0;
 419 }
 420
 421 static int mount_fix_timeouts(Mount *m) {
 422         MountParameters *p;
 423         const char *timeout = NULL;
 424         Unit *other;
 425         Iterator i;
 426         usec_t u;
 427         char *t;
 428         int r;
 429
 430         assert(m);
 431
 432         p = get_mount_parameters_fragment(m);
 433         if (!p)
 434                 return 0;
 435
 436         /* Allow configuration how long we wait for a device that
 437          * backs a mount point to show up. This is useful to support
 438          * endless device timeouts for devices that show up only after
 439          * user input, like crypto devices. */
 440
 441         if ((timeout = mount_test_option(p->options, "comment=systemd.device-timeout")))
 442                 timeout += 31;
 443         else if ((timeout = mount_test_option(p->options, "x-systemd.device-timeout")))
 444                 timeout += 25;
 445         else
 446                 return 0;
 447
 448         t = strndup(timeout, strcspn(timeout, ",;" WHITESPACE));
 449         if (!t)
 450                 return -ENOMEM;
 451
 452         r = parse_sec(t, &u);
 453         free(t);
 454
 455         if (r < 0) {
 456                 log_warning_unit(UNIT(m)->id,
 457                                  "Failed to parse timeout for %s, ignoring: %s",
 458                                  m->where, timeout);
 459                 return r;
 460         }
 461
 462         SET_FOREACH(other, UNIT(m)->dependencies[UNIT_AFTER], i) {
 463                 if (other->type != UNIT_DEVICE)
 464                         continue;
 465
 466                 other->job_timeout = u;
 467         }
 468
 469         return 0;
 470 }
 471
 472 static int mount_verify(Mount *m) {
 473         _cleanup_free_ char *e = NULL;
 474         bool b;
 475
 476         assert(m);
 477
 478         if (UNIT(m)->load_state != UNIT_LOADED)
 479                 return 0;
 480
 481         if (!m->from_fragment && !m->from_proc_self_mountinfo)
 482                 return -ENOENT;
 483
 484         e = unit_name_from_path(m->where, ".mount");
 485         if (!e)
 486                 return -ENOMEM;
 487
 488         b = unit_has_name(UNIT(m), e);
 489         if (!b) {
 490                 log_error_unit(UNIT(m)->id, "%s's Where= setting doesn't match unit name. Refusing.", UNIT(m)->id);
 491                 return -EINVAL;
 492         }
 493
 494         if (mount_point_is_api(m->where) || mount_point_ignore(m->where)) {
 495                 log_error_unit(UNIT(m)->id, "Cannot create mount unit for API file system %s. Refusing.", m->where);
 496                 return -EINVAL;
 497         }
 498
 499         if (UNIT(m)->fragment_path && !m->parameters_fragment.what) {
 500                 log_error_unit(UNIT(m)->id, "%s's What setting is missing. Refusing.", UNIT(m)->id);
 501                 return -EBADMSG;
 502         }
 503
 504         if (m->exec_context.pam_name && m->kill_context.kill_mode != KILL_CONTROL_GROUP) {
 505                 log_error_unit(UNIT(m)->id, "%s has PAM enabled. Kill mode must be set to control-group'. Refusing.",UNIT(m)->id);
 506                 return -EINVAL;
 507         }
 508
 509         return 0;
 510 }
 511
 512 static int mount_add_extras(Mount *m) {
 513         Unit *u = UNIT(m);
 514         int r;
 515
 516         assert(m);
 517
 518         if (u->fragment_path)
 519                 m->from_fragment = true;
 520
 521         if (!m->where) {
 522                 m->where = unit_name_to_path(u->id);
 523                 if (!m->where)
 524                         return -ENOMEM;
 525         }
 526
 527         path_kill_slashes(m->where);
 528
 529         if (!u->description) {
 530                 r = unit_set_description(u, m->where);
 531                 if (r < 0)
 532                         return r;
 533         }
 534
 535         r = mount_add_device_links(m);
 536         if (r < 0)
 537                 return r;
 538
 539         r = mount_add_mount_links(m);
 540         if (r < 0)
 541                 return r;
 542
 543         r = mount_add_quota_links(m);
 544         if (r < 0)
 545                 return r;
 546
 547         r = unit_patch_contexts(u);
 548         if (r < 0)
 549                 return r;
 550
 551         r = unit_add_exec_dependencies(u, &m->exec_context);
 552         if (r < 0)
 553                 return r;
 554
 555         r = unit_add_default_slice(u, &m->cgroup_context);
 556         if (r < 0)
 557                 return r;
 558
 559         r = mount_fix_timeouts(m);
 560         if (r < 0)
 561                 return r;
 562
 563         if (u->default_dependencies) {
 564                 r = mount_add_default_dependencies(m);
 565                 if (r < 0)
 566                         return r;
 567         }
 568
 569         return 0;
 570 }
 571
 572 static int mount_load(Unit *u) {
 573         Mount *m = MOUNT(u);
 574         int r;
 575
 576         assert(u);
 577         assert(u->load_state == UNIT_STUB);
 578
 579         if (m->from_proc_self_mountinfo)
 580                 r = unit_load_fragment_and_dropin_optional(u);
 581         else
 582                 r = unit_load_fragment_and_dropin(u);
 583
 584         if (r < 0)
 585                 return r;
 586
 587         /* This is a new unit? Then let's add in some extras */
 588         if (u->load_state == UNIT_LOADED) {
 589                 r = mount_add_extras(m);
 590                 if (r < 0)
 591                         return r;
 592         }
 593
 594         return mount_verify(m);
 595 }
 596
 597 static int mount_notify_automount(Mount *m, int status) {
 598         Unit *p;
 599         int r;
 600         Iterator i;
 601
 602         assert(m);
 603
 604         SET_FOREACH(p, UNIT(m)->dependencies[UNIT_TRIGGERED_BY], i)
 605                 if (p->type == UNIT_AUTOMOUNT) {
 606                          r = automount_send_ready(AUTOMOUNT(p), status);
 607                          if (r < 0)
 608                                  return r;
 609                 }
 610
 611         return 0;
 612 }
 613
 614 static void mount_set_state(Mount *m, MountState state) {
 615         MountState old_state;
 616         assert(m);
 617
 618         old_state = m->state;
 619         m->state = state;
 620
 621         if (state != MOUNT_MOUNTING &&
 622             state != MOUNT_MOUNTING_DONE &&
 623             state != MOUNT_REMOUNTING &&
 624             state != MOUNT_UNMOUNTING &&
 625             state != MOUNT_MOUNTING_SIGTERM &&
 626             state != MOUNT_MOUNTING_SIGKILL &&
 627             state != MOUNT_UNMOUNTING_SIGTERM &&
 628             state != MOUNT_UNMOUNTING_SIGKILL &&
 629             state != MOUNT_REMOUNTING_SIGTERM &&
 630             state != MOUNT_REMOUNTING_SIGKILL) {
 631                 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
 632                 mount_unwatch_control_pid(m);
 633                 m->control_command = NULL;
 634                 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
 635         }
 636
 637         if (state == MOUNT_MOUNTED ||
 638             state == MOUNT_REMOUNTING)
 639                 mount_notify_automount(m, 0);
 640         else if (state == MOUNT_DEAD ||
 641                  state == MOUNT_UNMOUNTING ||
 642                  state == MOUNT_MOUNTING_SIGTERM ||
 643                  state == MOUNT_MOUNTING_SIGKILL ||
 644                  state == MOUNT_REMOUNTING_SIGTERM ||
 645                  state == MOUNT_REMOUNTING_SIGKILL ||
 646                  state == MOUNT_UNMOUNTING_SIGTERM ||
 647                  state == MOUNT_UNMOUNTING_SIGKILL ||
 648                  state == MOUNT_FAILED) {
 649                 if (state != old_state)
 650                         mount_notify_automount(m, -ENODEV);
 651         }
 652
 653         if (state != old_state)
 654                 log_debug_unit(UNIT(m)->id,
 655                                "%s changed %s -> %s",
 656                                UNIT(m)->id,
 657                                mount_state_to_string(old_state),
 658                                mount_state_to_string(state));
 659
 660         unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
 661         m->reload_result = MOUNT_SUCCESS;
 662 }
 663
 664 static int mount_coldplug(Unit *u) {
 665         Mount *m = MOUNT(u);
 666         MountState new_state = MOUNT_DEAD;
 667         int r;
 668
 669         assert(m);
 670         assert(m->state == MOUNT_DEAD);
 671
 672         if (m->deserialized_state != m->state)
 673                 new_state = m->deserialized_state;
 674         else if (m->from_proc_self_mountinfo)
 675                 new_state = MOUNT_MOUNTED;
 676
 677         if (new_state == m->state)
 678                 return 0;
 679
 680         if (new_state == MOUNT_MOUNTING ||
 681             new_state == MOUNT_MOUNTING_DONE ||
 682             new_state == MOUNT_REMOUNTING ||
 683             new_state == MOUNT_UNMOUNTING ||
 684             new_state == MOUNT_MOUNTING_SIGTERM ||
 685             new_state == MOUNT_MOUNTING_SIGKILL ||
 686             new_state == MOUNT_UNMOUNTING_SIGTERM ||
 687             new_state == MOUNT_UNMOUNTING_SIGKILL ||
 688             new_state == MOUNT_REMOUNTING_SIGTERM ||
 689             new_state == MOUNT_REMOUNTING_SIGKILL) {
 690
 691                 if (m->control_pid <= 0)
 692                         return -EBADMSG;
 693
 694                 r = unit_watch_pid(UNIT(m), m->control_pid);
 695                 if (r < 0)
 696                         return r;
 697
 698                 r = mount_arm_timer(m);
 699                 if (r < 0)
 700                         return r;
 701         }
 702
 703         mount_set_state(m, new_state);
 704         return 0;
 705 }
 706
 707 static void mount_dump(Unit *u, FILE *f, const char *prefix) {
 708         Mount *m = MOUNT(u);
 709         MountParameters *p;
 710
 711         assert(m);
 712         assert(f);
 713
 714         p = get_mount_parameters(m);
 715
 716         fprintf(f,
 717                 "%sMount State: %s\n"
 718                 "%sResult: %s\n"
 719                 "%sWhere: %s\n"
 720                 "%sWhat: %s\n"
 721                 "%sFile System Type: %s\n"
 722                 "%sOptions: %s\n"
 723                 "%sFrom /proc/self/mountinfo: %s\n"
 724                 "%sFrom fragment: %s\n"
 725                 "%sDirectoryMode: %04o\n",
 726                 prefix, mount_state_to_string(m->state),
 727                 prefix, mount_result_to_string(m->result),
 728                 prefix, m->where,
 729                 prefix, p ? strna(p->what) : "n/a",
 730                 prefix, p ? strna(p->fstype) : "n/a",
 731                 prefix, p ? strna(p->options) : "n/a",
 732                 prefix, yes_no(m->from_proc_self_mountinfo),
 733                 prefix, yes_no(m->from_fragment),
 734                 prefix, m->directory_mode);
 735
 736         if (m->control_pid > 0)
 737                 fprintf(f,
 738                         "%sControl PID: "PID_FMT"\n",
 739                         prefix, m->control_pid);
 740
 741         exec_context_dump(&m->exec_context, f, prefix);
 742         kill_context_dump(&m->kill_context, f, prefix);
 743 }
 744
 745 static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
 746         pid_t pid;
 747         int r;
 748
 749         assert(m);
 750         assert(c);
 751         assert(_pid);
 752
 753         unit_realize_cgroup(UNIT(m));
 754
 755         r = unit_setup_exec_runtime(UNIT(m));
 756         if (r < 0)
 757                 goto fail;
 758
 759         r = mount_arm_timer(m);
 760         if (r < 0)
 761                 goto fail;
 762
 763         r = exec_spawn(c,
 764                        NULL,
 765                        &m->exec_context,
 766                        NULL, 0,
 767                        UNIT(m)->manager->environment,
 768                        true,
 769                        true,
 770                        true,
 771                        UNIT(m)->manager->confirm_spawn,
 772                        UNIT(m)->manager->cgroup_supported,
 773                        UNIT(m)->cgroup_path,
 774                        manager_get_runtime_prefix(UNIT(m)->manager),
 775                        UNIT(m)->id,
 776                        0,
 777                        NULL,
 778                        m->exec_runtime,
 779                        &pid);
 780         if (r < 0)
 781                 goto fail;
 782
 783         r = unit_watch_pid(UNIT(m), pid);
 784         if (r < 0)
 785                 /* FIXME: we need to do something here */
 786                 goto fail;
 787
 788         *_pid = pid;
 789
 790         return 0;
 791
 792 fail:
 793         m->timer_event_source = sd_event_source_unref(m->timer_event_source);
 794
 795         return r;
 796 }
 797
 798 static void mount_enter_dead(Mount *m, MountResult f) {
 799         assert(m);
 800
 801         if (f != MOUNT_SUCCESS)
 802                 m->result = f;
 803
 804         exec_runtime_destroy(m->exec_runtime);
 805         m->exec_runtime = exec_runtime_unref(m->exec_runtime);
 806
 807         exec_context_destroy_runtime_directory(&m->exec_context, manager_get_runtime_prefix(UNIT(m)->manager));
 808
 809         mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
 810 }
 811
 812 static void mount_enter_mounted(Mount *m, MountResult f) {
 813         assert(m);
 814
 815         if (f != MOUNT_SUCCESS)
 816                 m->result = f;
 817
 818         mount_set_state(m, MOUNT_MOUNTED);
 819 }
 820
 821 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
 822         int r;
 823
 824         assert(m);
 825
 826         if (f != MOUNT_SUCCESS)
 827                 m->result = f;
 828
 829         r = unit_kill_context(
 830                         UNIT(m),
 831                         &m->kill_context,
 832                         state != MOUNT_MOUNTING_SIGTERM && state != MOUNT_UNMOUNTING_SIGTERM && state != MOUNT_REMOUNTING_SIGTERM,
 833                         -1,
 834                         m->control_pid,
 835                         false);
 836         if (r < 0)
 837                 goto fail;
 838
 839         if (r > 0) {
 840                 r = mount_arm_timer(m);
 841                 if (r < 0)
 842                         goto fail;
 843
 844                 mount_set_state(m, state);
 845         } else if (state == MOUNT_REMOUNTING_SIGTERM)
 846                 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_SUCCESS);
 847         else if (state == MOUNT_REMOUNTING_SIGKILL)
 848                 mount_enter_mounted(m, MOUNT_SUCCESS);
 849         else if (state == MOUNT_MOUNTING_SIGTERM)
 850                 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_SUCCESS);
 851         else if (state == MOUNT_UNMOUNTING_SIGTERM)
 852                 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_SUCCESS);
 853         else
 854                 mount_enter_dead(m, MOUNT_SUCCESS);
 855
 856         return;
 857
 858 fail:
 859         log_warning_unit(UNIT(m)->id,
 860                          "%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
 861
 862         if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
 863                 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
 864         else
 865                 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
 866 }
 867
 868 void warn_if_dir_nonempty(const char *unit, const char* where) {
 869         assert(unit);
 870         assert(where);
 871
 872         if (dir_is_empty(where) > 0)
 873                 return;
 874
 875         log_struct_unit(LOG_NOTICE,
 876                    unit,
 877                    "MESSAGE=%s: Directory %s to mount over is not empty, mounting anyway.",
 878                    unit, where,
 879                    "WHERE=%s", where,
 880                    MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
 881                    NULL);
 882 }
 883
 884 static void mount_enter_unmounting(Mount *m) {
 885         int r;
 886
 887         assert(m);
 888
 889         m->control_command_id = MOUNT_EXEC_UNMOUNT;
 890         m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
 891
 892         if ((r = exec_command_set(
 893                              m->control_command,
 894                              "/bin/umount",
 895                              m->where,
 896                              NULL)) < 0)
 897                 goto fail;
 898
 899         mount_unwatch_control_pid(m);
 900
 901         if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
 902                 goto fail;
 903
 904         mount_set_state(m, MOUNT_UNMOUNTING);
 905
 906         return;
 907
 908 fail:
 909         log_warning_unit(UNIT(m)->id,
 910                          "%s failed to run 'umount' task: %s",
 911                          UNIT(m)->id, strerror(-r));
 912         mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
 913 }
 914
 915 static void mount_enter_mounting(Mount *m) {
 916         int r;
 917         MountParameters *p;
 918
 919         assert(m);
 920
 921         m->control_command_id = MOUNT_EXEC_MOUNT;
 922         m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
 923
 924         mkdir_p_label(m->where, m->directory_mode);
 925
 926         warn_if_dir_nonempty(m->meta.id, m->where);
 927
 928         /* Create the source directory for bind-mounts if needed */
 929         p = get_mount_parameters_fragment(m);
 930         if (p && mount_is_bind(p))
 931                 mkdir_p_label(p->what, m->directory_mode);
 932
 933         if (m->from_fragment)
 934                 r = exec_command_set(
 935                                 m->control_command,
 936                                 "/bin/mount",
 937                                 m->parameters_fragment.what,
 938                                 m->where,
 939                                 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
 940                                 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
 941                                 NULL);
 942         else
 943                 r = -ENOENT;
 944
 945         if (r < 0)
 946                 goto fail;
 947
 948         mount_unwatch_control_pid(m);
 949
 950         r = mount_spawn(m, m->control_command, &m->control_pid);
 951         if (r < 0)
 952                 goto fail;
 953
 954         mount_set_state(m, MOUNT_MOUNTING);
 955
 956         return;
 957
 958 fail:
 959         log_warning_unit(UNIT(m)->id,
 960                          "%s failed to run 'mount' task: %s",
 961                          UNIT(m)->id, strerror(-r));
 962         mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
 963 }
 964
 965 static void mount_enter_remounting(Mount *m) {
 966         int r;
 967
 968         assert(m);
 969
 970         m->control_command_id = MOUNT_EXEC_REMOUNT;
 971         m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
 972
 973         if (m->from_fragment) {
 974                 const char *o;
 975
 976                 if (m->parameters_fragment.options)
 977                         o = strappenda("remount,", m->parameters_fragment.options);
 978                 else
 979                         o = "remount";
 980
 981                 r = exec_command_set(
 982                                 m->control_command,
 983                                 "/bin/mount",
 984                                 m->parameters_fragment.what,
 985                                 m->where,
 986                                 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
 987                                 "-o", o,
 988                                 NULL);
 989         } else
 990                 r = -ENOENT;
 991
 992         if (r < 0)
 993                 goto fail;
 994
 995         mount_unwatch_control_pid(m);
 996
 997         r = mount_spawn(m, m->control_command, &m->control_pid);
 998         if (r < 0)
 999                 goto fail;
1000
1001         mount_set_state(m, MOUNT_REMOUNTING);
1002
1003         return;
1004
1005 fail:
1006         log_warning_unit(UNIT(m)->id,
1007                          "%s failed to run 'remount' task: %s",
1008                          UNIT(m)->id, strerror(-r));
1009         m->reload_result = MOUNT_FAILURE_RESOURCES;
1010         mount_enter_mounted(m, MOUNT_SUCCESS);
1011 }
1012
1013 static int mount_start(Unit *u) {
1014         Mount *m = MOUNT(u);
1015
1016         assert(m);
1017
1018         /* We cannot fulfill this request right now, try again later
1019          * please! */
1020         if (m->state == MOUNT_UNMOUNTING ||
1021             m->state == MOUNT_UNMOUNTING_SIGTERM ||
1022             m->state == MOUNT_UNMOUNTING_SIGKILL ||
1023             m->state == MOUNT_MOUNTING_SIGTERM ||
1024             m->state == MOUNT_MOUNTING_SIGKILL)
1025                 return -EAGAIN;
1026
1027         /* Already on it! */
1028         if (m->state == MOUNT_MOUNTING)
1029                 return 0;
1030
1031         assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1032
1033         m->result = MOUNT_SUCCESS;
1034         m->reload_result = MOUNT_SUCCESS;
1035
1036         mount_enter_mounting(m);
1037         return 0;
1038 }
1039
1040 static int mount_stop(Unit *u) {
1041         Mount *m = MOUNT(u);
1042
1043         assert(m);
1044
1045         /* Already on it */
1046         if (m->state == MOUNT_UNMOUNTING ||
1047             m->state == MOUNT_UNMOUNTING_SIGKILL ||
1048             m->state == MOUNT_UNMOUNTING_SIGTERM ||
1049             m->state == MOUNT_MOUNTING_SIGTERM ||
1050             m->state == MOUNT_MOUNTING_SIGKILL)
1051                 return 0;
1052
1053         assert(m->state == MOUNT_MOUNTING ||
1054                m->state == MOUNT_MOUNTING_DONE ||
1055                m->state == MOUNT_MOUNTED ||
1056                m->state == MOUNT_REMOUNTING ||
1057                m->state == MOUNT_REMOUNTING_SIGTERM ||
1058                m->state == MOUNT_REMOUNTING_SIGKILL);
1059
1060         mount_enter_unmounting(m);
1061         return 0;
1062 }
1063
1064 static int mount_reload(Unit *u) {
1065         Mount *m = MOUNT(u);
1066
1067         assert(m);
1068
1069         if (m->state == MOUNT_MOUNTING_DONE)
1070                 return -EAGAIN;
1071
1072         assert(m->state == MOUNT_MOUNTED);
1073
1074         mount_enter_remounting(m);
1075         return 0;
1076 }
1077
1078 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1079         Mount *m = MOUNT(u);
1080
1081         assert(m);
1082         assert(f);
1083         assert(fds);
1084
1085         unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1086         unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1087         unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1088
1089         if (m->control_pid > 0)
1090                 unit_serialize_item_format(u, f, "control-pid", PID_FMT, m->control_pid);
1091
1092         if (m->control_command_id >= 0)
1093                 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1094
1095         return 0;
1096 }
1097
1098 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1099         Mount *m = MOUNT(u);
1100
1101         assert(u);
1102         assert(key);
1103         assert(value);
1104         assert(fds);
1105
1106         if (streq(key, "state")) {
1107                 MountState state;
1108
1109                 if ((state = mount_state_from_string(value)) < 0)
1110                         log_debug_unit(u->id, "Failed to parse state value %s", value);
1111                 else
1112                         m->deserialized_state = state;
1113         } else if (streq(key, "result")) {
1114                 MountResult f;
1115
1116                 f = mount_result_from_string(value);
1117                 if (f < 0)
1118                         log_debug_unit(UNIT(m)->id,
1119                                        "Failed to parse result value %s", value);
1120                 else if (f != MOUNT_SUCCESS)
1121                         m->result = f;
1122
1123         } else if (streq(key, "reload-result")) {
1124                 MountResult f;
1125
1126                 f = mount_result_from_string(value);
1127                 if (f < 0)
1128                         log_debug_unit(UNIT(m)->id,
1129                                        "Failed to parse reload result value %s", value);
1130                 else if (f != MOUNT_SUCCESS)
1131                         m->reload_result = f;
1132
1133         } else if (streq(key, "control-pid")) {
1134                 pid_t pid;
1135
1136                 if (parse_pid(value, &pid) < 0)
1137                         log_debug_unit(UNIT(m)->id,
1138                                        "Failed to parse control-pid value %s", value);
1139                 else
1140                         m->control_pid = pid;
1141         } else if (streq(key, "control-command")) {
1142                 MountExecCommand id;
1143
1144                 if ((id = mount_exec_command_from_string(value)) < 0)
1145                         log_debug_unit(UNIT(m)->id,
1146                                        "Failed to parse exec-command value %s", value);
1147                 else {
1148                         m->control_command_id = id;
1149                         m->control_command = m->exec_command + id;
1150                 }
1151         } else
1152                 log_debug_unit(UNIT(m)->id,
1153                                "Unknown serialization key '%s'", key);
1154
1155         return 0;
1156 }
1157
1158 _pure_ static UnitActiveState mount_active_state(Unit *u) {
1159         assert(u);
1160
1161         return state_translation_table[MOUNT(u)->state];
1162 }
1163
1164 _pure_ static const char *mount_sub_state_to_string(Unit *u) {
1165         assert(u);
1166
1167         return mount_state_to_string(MOUNT(u)->state);
1168 }
1169
1170 _pure_ static bool mount_check_gc(Unit *u) {
1171         Mount *m = MOUNT(u);
1172
1173         assert(m);
1174
1175         return m->from_proc_self_mountinfo;
1176 }
1177
1178 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1179         Mount *m = MOUNT(u);
1180         MountResult f;
1181
1182         assert(m);
1183         assert(pid >= 0);
1184
1185         if (pid != m->control_pid)
1186                 return;
1187
1188         m->control_pid = 0;
1189
1190         if (is_clean_exit(code, status, NULL))
1191                 f = MOUNT_SUCCESS;
1192         else if (code == CLD_EXITED)
1193                 f = MOUNT_FAILURE_EXIT_CODE;
1194         else if (code == CLD_KILLED)
1195                 f = MOUNT_FAILURE_SIGNAL;
1196         else if (code == CLD_DUMPED)
1197                 f = MOUNT_FAILURE_CORE_DUMP;
1198         else
1199                 assert_not_reached("Unknown code");
1200
1201         if (f != MOUNT_SUCCESS)
1202                 m->result = f;
1203
1204         if (m->control_command) {
1205                 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1206
1207                 m->control_command = NULL;
1208                 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1209         }
1210
1211         log_full_unit(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
1212                       "%s mount process exited, code=%s status=%i",
1213                       u->id, sigchld_code_to_string(code), status);
1214
1215         /* Note that mount(8) returning and the kernel sending us a
1216          * mount table change event might happen out-of-order. If an
1217          * operation succeed we assume the kernel will follow soon too
1218          * and already change into the resulting state.  If it fails
1219          * we check if the kernel still knows about the mount. and
1220          * change state accordingly. */
1221
1222         switch (m->state) {
1223
1224         case MOUNT_MOUNTING:
1225         case MOUNT_MOUNTING_DONE:
1226         case MOUNT_MOUNTING_SIGKILL:
1227         case MOUNT_MOUNTING_SIGTERM:
1228
1229                 if (f == MOUNT_SUCCESS)
1230                         mount_enter_mounted(m, f);
1231                 else if (m->from_proc_self_mountinfo)
1232                         mount_enter_mounted(m, f);
1233                 else
1234                         mount_enter_dead(m, f);
1235                 break;
1236
1237         case MOUNT_REMOUNTING:
1238         case MOUNT_REMOUNTING_SIGKILL:
1239         case MOUNT_REMOUNTING_SIGTERM:
1240
1241                 m->reload_result = f;
1242                 if (m->from_proc_self_mountinfo)
1243                         mount_enter_mounted(m, MOUNT_SUCCESS);
1244                 else
1245                         mount_enter_dead(m, MOUNT_SUCCESS);
1246
1247                 break;
1248
1249         case MOUNT_UNMOUNTING:
1250         case MOUNT_UNMOUNTING_SIGKILL:
1251         case MOUNT_UNMOUNTING_SIGTERM:
1252
1253                 if (f == MOUNT_SUCCESS)
1254                         mount_enter_dead(m, f);
1255                 else if (m->from_proc_self_mountinfo)
1256                         mount_enter_mounted(m, f);
1257                 else
1258                         mount_enter_dead(m, f);
1259                 break;
1260
1261         default:
1262                 assert_not_reached("Uh, control process died at wrong time.");
1263         }
1264
1265         /* Notify clients about changed exit status */
1266         unit_add_to_dbus_queue(u);
1267 }
1268
1269 static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
1270         Mount *m = MOUNT(userdata);
1271
1272         assert(m);
1273         assert(m->timer_event_source == source);
1274
1275         switch (m->state) {
1276
1277         case MOUNT_MOUNTING:
1278         case MOUNT_MOUNTING_DONE:
1279                 log_warning_unit(UNIT(m)->id,
1280                                  "%s mounting timed out. Stopping.", UNIT(m)->id);
1281                 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1282                 break;
1283
1284         case MOUNT_REMOUNTING:
1285                 log_warning_unit(UNIT(m)->id,
1286                                  "%s remounting timed out. Stopping.", UNIT(m)->id);
1287                 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1288                 mount_enter_mounted(m, MOUNT_SUCCESS);
1289                 break;
1290
1291         case MOUNT_UNMOUNTING:
1292                 log_warning_unit(UNIT(m)->id,
1293                                  "%s unmounting timed out. Stopping.", UNIT(m)->id);
1294                 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1295                 break;
1296
1297         case MOUNT_MOUNTING_SIGTERM:
1298                 if (m->kill_context.send_sigkill) {
1299                         log_warning_unit(UNIT(m)->id,
1300                                          "%s mounting timed out. Killing.", UNIT(m)->id);
1301                         mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1302                 } else {
1303                         log_warning_unit(UNIT(m)->id,
1304                                          "%s mounting timed out. Skipping SIGKILL. Ignoring.",
1305                                          UNIT(m)->id);
1306
1307                         if (m->from_proc_self_mountinfo)
1308                                 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1309                         else
1310                                 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1311                 }
1312                 break;
1313
1314         case MOUNT_REMOUNTING_SIGTERM:
1315                 if (m->kill_context.send_sigkill) {
1316                         log_warning_unit(UNIT(m)->id,
1317                                          "%s remounting timed out. Killing.", UNIT(m)->id);
1318                         mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1319                 } else {
1320                         log_warning_unit(UNIT(m)->id,
1321                                          "%s remounting timed out. Skipping SIGKILL. Ignoring.",
1322                                          UNIT(m)->id);
1323
1324                         if (m->from_proc_self_mountinfo)
1325                                 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1326                         else
1327                                 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1328                 }
1329                 break;
1330
1331         case MOUNT_UNMOUNTING_SIGTERM:
1332                 if (m->kill_context.send_sigkill) {
1333                         log_warning_unit(UNIT(m)->id,
1334                                          "%s unmounting timed out. Killing.", UNIT(m)->id);
1335                         mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1336                 } else {
1337                         log_warning_unit(UNIT(m)->id,
1338                                          "%s unmounting timed out. Skipping SIGKILL. Ignoring.",
1339                                          UNIT(m)->id);
1340
1341                         if (m->from_proc_self_mountinfo)
1342                                 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1343                         else
1344                                 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1345                 }
1346                 break;
1347
1348         case MOUNT_MOUNTING_SIGKILL:
1349         case MOUNT_REMOUNTING_SIGKILL:
1350         case MOUNT_UNMOUNTING_SIGKILL:
1351                 log_warning_unit(UNIT(m)->id,
1352                                  "%s mount process still around after SIGKILL. Ignoring.",
1353                                  UNIT(m)->id);
1354
1355                 if (m->from_proc_self_mountinfo)
1356                         mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1357                 else
1358                         mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1359                 break;
1360
1361         default:
1362                 assert_not_reached("Timeout at wrong time.");
1363         }
1364
1365         return 0;
1366 }
1367
1368 static int mount_add_one(
1369                 Manager *m,
1370                 const char *what,
1371                 const char *where,
1372                 const char *options,
1373                 const char *fstype,
1374                 bool set_flags) {
1375
1376         _cleanup_free_ char *e = NULL, *w = NULL, *o = NULL, *f = NULL;
1377         bool load_extras = false;
1378         MountParameters *p;
1379         bool delete, changed = false;
1380         Unit *u;
1381         int r;
1382
1383         assert(m);
1384         assert(what);
1385         assert(where);
1386         assert(options);
1387         assert(fstype);
1388
1389         /* Ignore API mount points. They should never be referenced in
1390          * dependencies ever. */
1391         if (mount_point_is_api(where) || mount_point_ignore(where))
1392                 return 0;
1393
1394         if (streq(fstype, "autofs"))
1395                 return 0;
1396
1397         /* probably some kind of swap, ignore */
1398         if (!is_path(where))
1399                 return 0;
1400
1401         e = unit_name_from_path(where, ".mount");
1402         if (!e)
1403                 return -ENOMEM;
1404
1405         u = manager_get_unit(m, e);
1406         if (!u) {
1407                 delete = true;
1408
1409                 u = unit_new(m, sizeof(Mount));
1410                 if (!u)
1411                         return -ENOMEM;
1412
1413                 r = unit_add_name(u, e);
1414                 if (r < 0)
1415                         goto fail;
1416
1417                 MOUNT(u)->where = strdup(where);
1418                 if (!MOUNT(u)->where) {
1419                         r = -ENOMEM;
1420                         goto fail;
1421                 }
1422
1423                 u->source_path = strdup("/proc/self/mountinfo");
1424                 if (!u->source_path) {
1425                         r = -ENOMEM;
1426                         goto fail;
1427                 }
1428
1429
1430                 if (m->running_as == SYSTEMD_SYSTEM) {
1431                         const char* target;
1432
1433                         target = fstype_is_network(fstype) ? SPECIAL_REMOTE_FS_TARGET : SPECIAL_LOCAL_FS_TARGET;
1434
1435                         r = unit_add_dependency_by_name(u, UNIT_BEFORE, target, NULL, true);
1436                         if (r < 0)
1437                                 goto fail;
1438
1439                         if (should_umount(MOUNT(u))) {
1440                                 r = unit_add_dependency_by_name(u, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
1441                                 if (r < 0)
1442                                         goto fail;
1443                         }
1444                 }
1445
1446                 unit_add_to_load_queue(u);
1447                 changed = true;
1448         } else {
1449                 delete = false;
1450
1451                 if (!MOUNT(u)->where) {
1452                         MOUNT(u)->where = strdup(where);
1453                         if (!MOUNT(u)->where) {
1454                                 r = -ENOMEM;
1455                                 goto fail;
1456                         }
1457                 }
1458
1459                 if (u->load_state == UNIT_NOT_FOUND) {
1460                         u->load_state = UNIT_LOADED;
1461                         u->load_error = 0;
1462
1463                         /* Load in the extras later on, after we
1464                          * finished initialization of the unit */
1465                         load_extras = true;
1466                         changed = true;
1467                 }
1468         }
1469
1470         w = strdup(what);
1471         o = strdup(options);
1472         f = strdup(fstype);
1473         if (!w || !o || !f) {
1474                 r = -ENOMEM;
1475                 goto fail;
1476         }
1477
1478         p = &MOUNT(u)->parameters_proc_self_mountinfo;
1479
1480         changed = changed ||
1481                 !streq_ptr(p->options, options) ||
1482                 !streq_ptr(p->what, what) ||
1483                 !streq_ptr(p->fstype, fstype);
1484
1485         if (set_flags) {
1486                 MOUNT(u)->is_mounted = true;
1487                 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1488                 MOUNT(u)->just_changed = changed;
1489         }
1490
1491         MOUNT(u)->from_proc_self_mountinfo = true;
1492
1493         free(p->what);
1494         p->what = w;
1495         w = NULL;
1496
1497         free(p->options);
1498         p->options = o;
1499         o = NULL;
1500
1501         free(p->fstype);
1502         p->fstype = f;
1503         f = NULL;
1504
1505         if (load_extras) {
1506                 r = mount_add_extras(MOUNT(u));
1507                 if (r < 0)
1508                         goto fail;
1509         }
1510
1511         if (changed)
1512                 unit_add_to_dbus_queue(u);
1513
1514         return 0;
1515
1516 fail:
1517         if (delete && u)
1518                 unit_free(u);
1519
1520         return r;
1521 }
1522
1523 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1524         int r = 0;
1525         unsigned i;
1526
1527         assert(m);
1528
1529         rewind(m->proc_self_mountinfo);
1530
1531         for (i = 1;; i++) {
1532                 _cleanup_free_ char *device = NULL, *path = NULL, *options = NULL, *options2 = NULL, *fstype = NULL, *d = NULL, *p = NULL, *o = NULL;
1533                 int k;
1534
1535                 k = fscanf(m->proc_self_mountinfo,
1536                            "%*s "       /* (1) mount id */
1537                            "%*s "       /* (2) parent id */
1538                            "%*s "       /* (3) major:minor */
1539                            "%*s "       /* (4) root */
1540                            "%ms "       /* (5) mount point */
1541                            "%ms"        /* (6) mount options */
1542                            "%*[^-]"     /* (7) optional fields */
1543                            "- "         /* (8) separator */
1544                            "%ms "       /* (9) file system type */
1545                            "%ms"        /* (10) mount source */
1546                            "%ms"        /* (11) mount options 2 */
1547                            "%*[^\n]",   /* some rubbish at the end */
1548                            &path,
1549                            &options,
1550                            &fstype,
1551                            &device,
1552                            &options2);
1553
1554                 if (k == EOF)
1555                         break;
1556
1557                 if (k != 5) {
1558                         log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1559                         continue;
1560                 }
1561
1562                 o = strjoin(options, ",", options2, NULL);
1563                 if (!o)
1564                         return log_oom();
1565
1566                 d = cunescape(device);
1567                 p = cunescape(path);
1568                 if (!d || !p)
1569                         return log_oom();
1570
1571                 k = mount_add_one(m, d, p, o, fstype, set_flags);
1572                 if (k < 0)
1573                         r = k;
1574         }
1575
1576         return r;
1577 }
1578
1579 static void mount_shutdown(Manager *m) {
1580         assert(m);
1581
1582         m->mount_event_source = sd_event_source_unref(m->mount_event_source);
1583
1584         if (m->proc_self_mountinfo) {
1585                 fclose(m->proc_self_mountinfo);
1586                 m->proc_self_mountinfo = NULL;
1587         }
1588 }
1589
1590 static int mount_get_timeout(Unit *u, uint64_t *timeout) {
1591         Mount *m = MOUNT(u);
1592         int r;
1593
1594         if (!m->timer_event_source)
1595                 return 0;
1596
1597         r = sd_event_source_get_time(m->timer_event_source, timeout);
1598         if (r < 0)
1599                 return r;
1600
1601         return 1;
1602 }
1603
1604 static int mount_enumerate(Manager *m) {
1605         int r;
1606         assert(m);
1607
1608         if (!m->proc_self_mountinfo) {
1609                 m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
1610                 if (!m->proc_self_mountinfo)
1611                         return -errno;
1612
1613                 r = sd_event_add_io(m->event, &m->mount_event_source, fileno(m->proc_self_mountinfo), EPOLLPRI, mount_dispatch_io, m);
1614                 if (r < 0)
1615                         goto fail;
1616
1617                 /* Dispatch this before we dispatch SIGCHLD, so that
1618                  * we always get the events from /proc/self/mountinfo
1619                  * before the SIGCHLD of /bin/mount. */
1620                 r = sd_event_source_set_priority(m->mount_event_source, -10);
1621                 if (r < 0)
1622                         goto fail;
1623         }
1624
1625         r = mount_load_proc_self_mountinfo(m, false);
1626         if (r < 0)
1627                 goto fail;
1628
1629         return 0;
1630
1631 fail:
1632         mount_shutdown(m);
1633         return r;
1634 }
1635
1636 static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1637         Manager *m = userdata;
1638         Unit *u;
1639         int r;
1640
1641         assert(m);
1642         assert(revents & EPOLLPRI);
1643
1644         /* The manager calls this for every fd event happening on the
1645          * /proc/self/mountinfo file, which informs us about mounting
1646          * table changes */
1647
1648         r = mount_load_proc_self_mountinfo(m, true);
1649         if (r < 0) {
1650                 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1651
1652                 /* Reset flags, just in case, for later calls */
1653                 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1654                         Mount *mount = MOUNT(u);
1655
1656                         mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1657                 }
1658
1659                 return 0;
1660         }
1661
1662         manager_dispatch_load_queue(m);
1663
1664         LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1665                 Mount *mount = MOUNT(u);
1666
1667                 if (!mount->is_mounted) {
1668
1669                         mount->from_proc_self_mountinfo = false;
1670
1671                         switch (mount->state) {
1672
1673                         case MOUNT_MOUNTED:
1674                                 /* This has just been unmounted by
1675                                  * somebody else, follow the state
1676                                  * change. */
1677                                 mount_enter_dead(mount, MOUNT_SUCCESS);
1678                                 break;
1679
1680                         default:
1681                                 break;
1682                         }
1683
1684                 } else if (mount->just_mounted || mount->just_changed) {
1685
1686                         /* New or changed mount entry */
1687
1688                         switch (mount->state) {
1689
1690                         case MOUNT_DEAD:
1691                         case MOUNT_FAILED:
1692                                 /* This has just been mounted by
1693                                  * somebody else, follow the state
1694                                  * change. */
1695                                 mount_enter_mounted(mount, MOUNT_SUCCESS);
1696                                 break;
1697
1698                         case MOUNT_MOUNTING:
1699                                 mount_set_state(mount, MOUNT_MOUNTING_DONE);
1700                                 break;
1701
1702                         default:
1703                                 /* Nothing really changed, but let's
1704                                  * issue an notification call
1705                                  * nonetheless, in case somebody is
1706                                  * waiting for this. (e.g. file system
1707                                  * ro/rw remounts.) */
1708                                 mount_set_state(mount, mount->state);
1709                                 break;
1710                         }
1711                 }
1712
1713                 /* Reset the flags for later calls */
1714                 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1715         }
1716
1717         return 0;
1718 }
1719
1720 static void mount_reset_failed(Unit *u) {
1721         Mount *m = MOUNT(u);
1722
1723         assert(m);
1724
1725         if (m->state == MOUNT_FAILED)
1726                 mount_set_state(m, MOUNT_DEAD);
1727
1728         m->result = MOUNT_SUCCESS;
1729         m->reload_result = MOUNT_SUCCESS;
1730 }
1731
1732 static int mount_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
1733         return unit_kill_common(u, who, signo, -1, MOUNT(u)->control_pid, error);
1734 }
1735
1736 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1737         [MOUNT_DEAD] = "dead",
1738         [MOUNT_MOUNTING] = "mounting",
1739         [MOUNT_MOUNTING_DONE] = "mounting-done",
1740         [MOUNT_MOUNTED] = "mounted",
1741         [MOUNT_REMOUNTING] = "remounting",
1742         [MOUNT_UNMOUNTING] = "unmounting",
1743         [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1744         [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1745         [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1746         [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1747         [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1748         [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1749         [MOUNT_FAILED] = "failed"
1750 };
1751
1752 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1753
1754 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1755         [MOUNT_EXEC_MOUNT] = "ExecMount",
1756         [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1757         [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1758 };
1759
1760 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1761
1762 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1763         [MOUNT_SUCCESS] = "success",
1764         [MOUNT_FAILURE_RESOURCES] = "resources",
1765         [MOUNT_FAILURE_TIMEOUT] = "timeout",
1766         [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1767         [MOUNT_FAILURE_SIGNAL] = "signal",
1768         [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1769 };
1770
1771 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1772
1773 const UnitVTable mount_vtable = {
1774         .object_size = sizeof(Mount),
1775         .exec_context_offset = offsetof(Mount, exec_context),
1776         .cgroup_context_offset = offsetof(Mount, cgroup_context),
1777         .kill_context_offset = offsetof(Mount, kill_context),
1778         .exec_runtime_offset = offsetof(Mount, exec_runtime),
1779
1780         .sections =
1781                 "Unit\0"
1782                 "Mount\0"
1783                 "Install\0",
1784         .private_section = "Mount",
1785
1786         .no_alias = true,
1787         .no_instances = true,
1788
1789         .init = mount_init,
1790         .load = mount_load,
1791         .done = mount_done,
1792
1793         .coldplug = mount_coldplug,
1794
1795         .dump = mount_dump,
1796
1797         .start = mount_start,
1798         .stop = mount_stop,
1799         .reload = mount_reload,
1800
1801         .kill = mount_kill,
1802
1803         .serialize = mount_serialize,
1804         .deserialize_item = mount_deserialize_item,
1805
1806         .active_state = mount_active_state,
1807         .sub_state_to_string = mount_sub_state_to_string,
1808
1809         .check_gc = mount_check_gc,
1810
1811         .sigchld_event = mount_sigchld_event,
1812
1813         .reset_failed = mount_reset_failed,
1814
1815         .bus_interface = "org.freedesktop.systemd1.Mount",
1816         .bus_vtable = bus_mount_vtable,
1817         .bus_set_property = bus_mount_set_property,
1818         .bus_commit_properties = bus_mount_commit_properties,
1819
1820         .get_timeout = mount_get_timeout,
1821
1822         .enumerate = mount_enumerate,
1823         .shutdown = mount_shutdown,
1824
1825         .status_message_formats = {
1826                 .starting_stopping = {
1827                         [0] = "Mounting %s...",
1828                         [1] = "Unmounting %s...",
1829                 },
1830                 .finished_start_job = {
1831                         [JOB_DONE]       = "Mounted %s.",
1832                         [JOB_FAILED]     = "Failed to mount %s.",
1833                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
1834                         [JOB_TIMEOUT]    = "Timed out mounting %s.",
1835                 },
1836                 .finished_stop_job = {
1837                         [JOB_DONE]       = "Unmounted %s.",
1838                         [JOB_FAILED]     = "Failed unmounting %s.",
1839                         [JOB_TIMEOUT]    = "Timed out unmounting %s.",
1840                 },
1841         },
1842 };