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