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