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