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