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                             &pid)) < 0)
 805                 goto fail;
 806
 807         if ((r = unit_watch_pid(UNIT(m), pid)) < 0)
 808                 /* FIXME: we need to do something here */
 809                 goto fail;
 810
 811         *_pid = pid;
 812
 813         return 0;
 814
 815 fail:
 816         unit_unwatch_timer(UNIT(m), &m->timer_watch);
 817
 818         return r;
 819 }
 820
 821 static void mount_enter_dead(Mount *m, MountResult f) {
 822         assert(m);
 823
 824         if (f != MOUNT_SUCCESS)
 825                 m->result = f;
 826
 827         mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
 828 }
 829
 830 static void mount_enter_mounted(Mount *m, MountResult f) {
 831         assert(m);
 832
 833         if (f != MOUNT_SUCCESS)
 834                 m->result = f;
 835
 836         mount_set_state(m, MOUNT_MOUNTED);
 837 }
 838
 839 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
 840         int r;
 841         Set *pid_set = NULL;
 842         bool wait_for_exit = false;
 843
 844         assert(m);
 845
 846         if (f != MOUNT_SUCCESS)
 847                 m->result = f;
 848
 849         if (m->exec_context.kill_mode != KILL_NONE) {
 850                 int sig = (state == MOUNT_MOUNTING_SIGTERM ||
 851                            state == MOUNT_UNMOUNTING_SIGTERM ||
 852                            state == MOUNT_REMOUNTING_SIGTERM) ? m->exec_context.kill_signal : SIGKILL;
 853
 854                 if (m->control_pid > 0) {
 855                         if (kill_and_sigcont(m->control_pid, sig) < 0 && errno != ESRCH)
 856
 857                                 log_warning("Failed to kill control process %li: %m", (long) m->control_pid);
 858                         else
 859                                 wait_for_exit = true;
 860                 }
 861
 862                 if (m->exec_context.kill_mode == KILL_CONTROL_GROUP) {
 863
 864                         if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
 865                                 r = -ENOMEM;
 866                                 goto fail;
 867                         }
 868
 869                         /* Exclude the control pid from being killed via the cgroup */
 870                         if (m->control_pid > 0)
 871                                 if ((r = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0)
 872                                         goto fail;
 873
 874                         r = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, sig, true, pid_set, NULL);
 875                         if (r < 0) {
 876                                 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
 877                                         log_warning("Failed to kill control group: %s", strerror(-r));
 878                         } else if (r > 0)
 879                                 wait_for_exit = true;
 880
 881                         set_free(pid_set);
 882                         pid_set = NULL;
 883                 }
 884         }
 885
 886         if (wait_for_exit) {
 887                 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
 888                         goto fail;
 889
 890                 mount_set_state(m, state);
 891         } else if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
 892                 mount_enter_mounted(m, MOUNT_SUCCESS);
 893         else
 894                 mount_enter_dead(m, MOUNT_SUCCESS);
 895
 896         return;
 897
 898 fail:
 899         log_warning("%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
 900
 901         if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
 902                 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
 903         else
 904                 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
 905
 906         if (pid_set)
 907                 set_free(pid_set);
 908 }
 909
 910 static void mount_enter_unmounting(Mount *m) {
 911         int r;
 912
 913         assert(m);
 914
 915         m->control_command_id = MOUNT_EXEC_UNMOUNT;
 916         m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
 917
 918         if ((r = exec_command_set(
 919                              m->control_command,
 920                              "/bin/umount",
 921                              m->where,
 922                              NULL)) < 0)
 923                 goto fail;
 924
 925         mount_unwatch_control_pid(m);
 926
 927         if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
 928                 goto fail;
 929
 930         mount_set_state(m, MOUNT_UNMOUNTING);
 931
 932         return;
 933
 934 fail:
 935         log_warning("%s failed to run 'umount' task: %s", UNIT(m)->id, strerror(-r));
 936         mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
 937 }
 938
 939 static void mount_enter_mounting(Mount *m) {
 940         int r;
 941         MountParameters *p;
 942
 943         assert(m);
 944
 945         m->control_command_id = MOUNT_EXEC_MOUNT;
 946         m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
 947
 948         mkdir_p(m->where, m->directory_mode);
 949
 950         /* Create the source directory for bind-mounts if needed */
 951         p = get_mount_parameters_configured(m);
 952         if (p && mount_is_bind(p))
 953                 mkdir_p(p->what, m->directory_mode);
 954
 955         if (m->from_fragment)
 956                 r = exec_command_set(
 957                                 m->control_command,
 958                                 "/bin/mount",
 959                                 m->parameters_fragment.what,
 960                                 m->where,
 961                                 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
 962                                 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
 963                                 NULL);
 964         else if (m->from_etc_fstab)
 965                 r = exec_command_set(
 966                                 m->control_command,
 967                                 "/bin/mount",
 968                                 m->where,
 969                                 NULL);
 970         else
 971                 r = -ENOENT;
 972
 973         if (r < 0)
 974                 goto fail;
 975
 976         mount_unwatch_control_pid(m);
 977
 978         if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
 979                 goto fail;
 980
 981         mount_set_state(m, MOUNT_MOUNTING);
 982
 983         return;
 984
 985 fail:
 986         log_warning("%s failed to run 'mount' task: %s", UNIT(m)->id, strerror(-r));
 987         mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
 988 }
 989
 990 static void mount_enter_mounting_done(Mount *m) {
 991         assert(m);
 992
 993         mount_set_state(m, MOUNT_MOUNTING_DONE);
 994 }
 995
 996 static void mount_enter_remounting(Mount *m) {
 997         int r;
 998
 999         assert(m);
1000
1001         m->control_command_id = MOUNT_EXEC_REMOUNT;
1002         m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
1003
1004         if (m->from_fragment) {
1005                 char *buf = NULL;
1006                 const char *o;
1007
1008                 if (m->parameters_fragment.options) {
1009                         if (!(buf = strappend("remount,", m->parameters_fragment.options))) {
1010                                 r = -ENOMEM;
1011                                 goto fail;
1012                         }
1013
1014                         o = buf;
1015                 } else
1016                         o = "remount";
1017
1018                 r = exec_command_set(
1019                                 m->control_command,
1020                                 "/bin/mount",
1021                                 m->parameters_fragment.what,
1022                                 m->where,
1023                                 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
1024                                 "-o", o,
1025                                 NULL);
1026
1027                 free(buf);
1028         } else if (m->from_etc_fstab)
1029                 r = exec_command_set(
1030                                 m->control_command,
1031                                 "/bin/mount",
1032                                 m->where,
1033                                 "-o", "remount",
1034                                 NULL);
1035         else
1036                 r = -ENOENT;
1037
1038         if (r < 0)
1039                 goto fail;
1040
1041         mount_unwatch_control_pid(m);
1042
1043         if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
1044                 goto fail;
1045
1046         mount_set_state(m, MOUNT_REMOUNTING);
1047
1048         return;
1049
1050 fail:
1051         log_warning("%s failed to run 'remount' task: %s", UNIT(m)->id, strerror(-r));
1052         m->reload_result = MOUNT_FAILURE_RESOURCES;
1053         mount_enter_mounted(m, MOUNT_SUCCESS);
1054 }
1055
1056 static int mount_start(Unit *u) {
1057         Mount *m = MOUNT(u);
1058
1059         assert(m);
1060
1061         /* We cannot fulfill this request right now, try again later
1062          * please! */
1063         if (m->state == MOUNT_UNMOUNTING ||
1064             m->state == MOUNT_UNMOUNTING_SIGTERM ||
1065             m->state == MOUNT_UNMOUNTING_SIGKILL ||
1066             m->state == MOUNT_MOUNTING_SIGTERM ||
1067             m->state == MOUNT_MOUNTING_SIGKILL)
1068                 return -EAGAIN;
1069
1070         /* Already on it! */
1071         if (m->state == MOUNT_MOUNTING)
1072                 return 0;
1073
1074         assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1075
1076         m->result = MOUNT_SUCCESS;
1077         m->reload_result = MOUNT_SUCCESS;
1078
1079         mount_enter_mounting(m);
1080         return 0;
1081 }
1082
1083 static int mount_stop(Unit *u) {
1084         Mount *m = MOUNT(u);
1085
1086         assert(m);
1087
1088         /* Already on it */
1089         if (m->state == MOUNT_UNMOUNTING ||
1090             m->state == MOUNT_UNMOUNTING_SIGKILL ||
1091             m->state == MOUNT_UNMOUNTING_SIGTERM ||
1092             m->state == MOUNT_MOUNTING_SIGTERM ||
1093             m->state == MOUNT_MOUNTING_SIGKILL)
1094                 return 0;
1095
1096         assert(m->state == MOUNT_MOUNTING ||
1097                m->state == MOUNT_MOUNTING_DONE ||
1098                m->state == MOUNT_MOUNTED ||
1099                m->state == MOUNT_REMOUNTING ||
1100                m->state == MOUNT_REMOUNTING_SIGTERM ||
1101                m->state == MOUNT_REMOUNTING_SIGKILL);
1102
1103         mount_enter_unmounting(m);
1104         return 0;
1105 }
1106
1107 static int mount_reload(Unit *u) {
1108         Mount *m = MOUNT(u);
1109
1110         assert(m);
1111
1112         if (m->state == MOUNT_MOUNTING_DONE)
1113                 return -EAGAIN;
1114
1115         assert(m->state == MOUNT_MOUNTED);
1116
1117         mount_enter_remounting(m);
1118         return 0;
1119 }
1120
1121 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1122         Mount *m = MOUNT(u);
1123
1124         assert(m);
1125         assert(f);
1126         assert(fds);
1127
1128         unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1129         unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1130         unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1131
1132         if (m->control_pid > 0)
1133                 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) m->control_pid);
1134
1135         if (m->control_command_id >= 0)
1136                 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1137
1138         return 0;
1139 }
1140
1141 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1142         Mount *m = MOUNT(u);
1143
1144         assert(u);
1145         assert(key);
1146         assert(value);
1147         assert(fds);
1148
1149         if (streq(key, "state")) {
1150                 MountState state;
1151
1152                 if ((state = mount_state_from_string(value)) < 0)
1153                         log_debug("Failed to parse state value %s", value);
1154                 else
1155                         m->deserialized_state = state;
1156         } else if (streq(key, "result")) {
1157                 MountResult f;
1158
1159                 f = mount_result_from_string(value);
1160                 if (f < 0)
1161                         log_debug("Failed to parse result value %s", value);
1162                 else if (f != MOUNT_SUCCESS)
1163                         m->result = f;
1164
1165         } else if (streq(key, "reload-result")) {
1166                 MountResult f;
1167
1168                 f = mount_result_from_string(value);
1169                 if (f < 0)
1170                         log_debug("Failed to parse reload result value %s", value);
1171                 else if (f != MOUNT_SUCCESS)
1172                         m->reload_result = f;
1173
1174         } else if (streq(key, "control-pid")) {
1175                 pid_t pid;
1176
1177                 if (parse_pid(value, &pid) < 0)
1178                         log_debug("Failed to parse control-pid value %s", value);
1179                 else
1180                         m->control_pid = pid;
1181         } else if (streq(key, "control-command")) {
1182                 MountExecCommand id;
1183
1184                 if ((id = mount_exec_command_from_string(value)) < 0)
1185                         log_debug("Failed to parse exec-command value %s", value);
1186                 else {
1187                         m->control_command_id = id;
1188                         m->control_command = m->exec_command + id;
1189                 }
1190
1191         } else
1192                 log_debug("Unknown serialization key '%s'", key);
1193
1194         return 0;
1195 }
1196
1197 static UnitActiveState mount_active_state(Unit *u) {
1198         assert(u);
1199
1200         return state_translation_table[MOUNT(u)->state];
1201 }
1202
1203 static const char *mount_sub_state_to_string(Unit *u) {
1204         assert(u);
1205
1206         return mount_state_to_string(MOUNT(u)->state);
1207 }
1208
1209 static bool mount_check_gc(Unit *u) {
1210         Mount *m = MOUNT(u);
1211
1212         assert(m);
1213
1214         return m->from_etc_fstab || m->from_proc_self_mountinfo;
1215 }
1216
1217 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1218         Mount *m = MOUNT(u);
1219         MountResult f;
1220
1221         assert(m);
1222         assert(pid >= 0);
1223
1224         if (pid != m->control_pid)
1225                 return;
1226
1227         m->control_pid = 0;
1228
1229         if (is_clean_exit(code, status))
1230                 f = MOUNT_SUCCESS;
1231         else if (code == CLD_EXITED)
1232                 f = MOUNT_FAILURE_EXIT_CODE;
1233         else if (code == CLD_KILLED)
1234                 f = MOUNT_FAILURE_SIGNAL;
1235         else if (code == CLD_DUMPED)
1236                 f = MOUNT_FAILURE_CORE_DUMP;
1237         else
1238                 assert_not_reached("Unknown code");
1239
1240         if (f != MOUNT_SUCCESS)
1241                 m->result = f;
1242
1243         if (m->control_command) {
1244                 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1245
1246                 m->control_command = NULL;
1247                 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1248         }
1249
1250         log_full(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1251                  "%s mount process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1252
1253         /* Note that mount(8) returning and the kernel sending us a
1254          * mount table change event might happen out-of-order. If an
1255          * operation succeed we assume the kernel will follow soon too
1256          * and already change into the resulting state.  If it fails
1257          * we check if the kernel still knows about the mount. and
1258          * change state accordingly. */
1259
1260         switch (m->state) {
1261
1262         case MOUNT_MOUNTING:
1263         case MOUNT_MOUNTING_DONE:
1264         case MOUNT_MOUNTING_SIGKILL:
1265         case MOUNT_MOUNTING_SIGTERM:
1266
1267                 if (f == MOUNT_SUCCESS)
1268                         mount_enter_mounted(m, f);
1269                 else if (m->from_proc_self_mountinfo)
1270                         mount_enter_mounted(m, f);
1271                 else
1272                         mount_enter_dead(m, f);
1273                 break;
1274
1275         case MOUNT_REMOUNTING:
1276         case MOUNT_REMOUNTING_SIGKILL:
1277         case MOUNT_REMOUNTING_SIGTERM:
1278
1279                 m->reload_result = f;
1280                 if (m->from_proc_self_mountinfo)
1281                         mount_enter_mounted(m, MOUNT_SUCCESS);
1282                 else
1283                         mount_enter_dead(m, MOUNT_SUCCESS);
1284
1285                 break;
1286
1287         case MOUNT_UNMOUNTING:
1288         case MOUNT_UNMOUNTING_SIGKILL:
1289         case MOUNT_UNMOUNTING_SIGTERM:
1290
1291                 if (f == MOUNT_SUCCESS)
1292                         mount_enter_dead(m, f);
1293                 else if (m->from_proc_self_mountinfo)
1294                         mount_enter_mounted(m, f);
1295                 else
1296                         mount_enter_dead(m, f);
1297                 break;
1298
1299         default:
1300                 assert_not_reached("Uh, control process died at wrong time.");
1301         }
1302
1303         /* Notify clients about changed exit status */
1304         unit_add_to_dbus_queue(u);
1305 }
1306
1307 static void mount_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1308         Mount *m = MOUNT(u);
1309
1310         assert(m);
1311         assert(elapsed == 1);
1312         assert(w == &m->timer_watch);
1313
1314         switch (m->state) {
1315
1316         case MOUNT_MOUNTING:
1317         case MOUNT_MOUNTING_DONE:
1318                 log_warning("%s mounting timed out. Stopping.", u->id);
1319                 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1320                 break;
1321
1322         case MOUNT_REMOUNTING:
1323                 log_warning("%s remounting timed out. Stopping.", u->id);
1324                 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1325                 mount_enter_mounted(m, MOUNT_SUCCESS);
1326                 break;
1327
1328         case MOUNT_UNMOUNTING:
1329                 log_warning("%s unmounting timed out. Stopping.", u->id);
1330                 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1331                 break;
1332
1333         case MOUNT_MOUNTING_SIGTERM:
1334                 if (m->exec_context.send_sigkill) {
1335                         log_warning("%s mounting timed out. Killing.", u->id);
1336                         mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1337                 } else {
1338                         log_warning("%s mounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1339
1340                         if (m->from_proc_self_mountinfo)
1341                                 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1342                         else
1343                                 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1344                 }
1345                 break;
1346
1347         case MOUNT_REMOUNTING_SIGTERM:
1348                 if (m->exec_context.send_sigkill) {
1349                         log_warning("%s remounting timed out. Killing.", u->id);
1350                         mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1351                 } else {
1352                         log_warning("%s remounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1353
1354                         if (m->from_proc_self_mountinfo)
1355                                 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1356                         else
1357                                 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1358                 }
1359                 break;
1360
1361         case MOUNT_UNMOUNTING_SIGTERM:
1362                 if (m->exec_context.send_sigkill) {
1363                         log_warning("%s unmounting timed out. Killing.", u->id);
1364                         mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1365                 } else {
1366                         log_warning("%s unmounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1367
1368                         if (m->from_proc_self_mountinfo)
1369                                 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1370                         else
1371                                 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1372                 }
1373                 break;
1374
1375         case MOUNT_MOUNTING_SIGKILL:
1376         case MOUNT_REMOUNTING_SIGKILL:
1377         case MOUNT_UNMOUNTING_SIGKILL:
1378                 log_warning("%s mount process still around after SIGKILL. Ignoring.", u->id);
1379
1380                 if (m->from_proc_self_mountinfo)
1381                         mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1382                 else
1383                         mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1384                 break;
1385
1386         default:
1387                 assert_not_reached("Timeout at wrong time.");
1388         }
1389 }
1390
1391 static int mount_add_one(
1392                 Manager *m,
1393                 const char *what,
1394                 const char *where,
1395                 const char *options,
1396                 const char *fstype,
1397                 int passno,
1398                 bool from_proc_self_mountinfo,
1399                 bool set_flags) {
1400         int r;
1401         Unit *u;
1402         bool delete;
1403         char *e, *w = NULL, *o = NULL, *f = NULL;
1404         MountParameters *p;
1405
1406         assert(m);
1407         assert(what);
1408         assert(where);
1409         assert(options);
1410         assert(fstype);
1411
1412         assert(!set_flags || from_proc_self_mountinfo);
1413
1414         /* Ignore API mount points. They should never be referenced in
1415          * dependencies ever. */
1416         if (mount_point_is_api(where) || mount_point_ignore(where))
1417                 return 0;
1418
1419         if (streq(fstype, "autofs"))
1420                 return 0;
1421
1422         /* probably some kind of swap, ignore */
1423         if (!is_path(where))
1424                 return 0;
1425
1426         e = unit_name_from_path(where, ".mount");
1427         if (!e)
1428                 return -ENOMEM;
1429
1430         u = manager_get_unit(m, e);
1431         if (!u) {
1432                 delete = true;
1433
1434                 u = unit_new(m, sizeof(Mount));
1435                 if (!u) {
1436                         free(e);
1437                         return -ENOMEM;
1438                 }
1439
1440                 r = unit_add_name(u, e);
1441                 free(e);
1442
1443                 if (r < 0)
1444                         goto fail;
1445
1446                 MOUNT(u)->where = strdup(where);
1447                 if (!MOUNT(u)->where) {
1448                         r = -ENOMEM;
1449                         goto fail;
1450                 }
1451
1452                 unit_add_to_load_queue(u);
1453         } else {
1454                 delete = false;
1455                 free(e);
1456         }
1457
1458         if (!(w = strdup(what)) ||
1459             !(o = strdup(options)) ||
1460             !(f = strdup(fstype))) {
1461                 r = -ENOMEM;
1462                 goto fail;
1463         }
1464
1465         if (from_proc_self_mountinfo) {
1466                 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1467
1468                 if (set_flags) {
1469                         MOUNT(u)->is_mounted = true;
1470                         MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1471                         MOUNT(u)->just_changed = !streq_ptr(p->options, o);
1472                 }
1473
1474                 MOUNT(u)->from_proc_self_mountinfo = true;
1475         } else {
1476                 p = &MOUNT(u)->parameters_etc_fstab;
1477                 MOUNT(u)->from_etc_fstab = true;
1478         }
1479
1480         free(p->what);
1481         p->what = w;
1482
1483         free(p->options);
1484         p->options = o;
1485
1486         free(p->fstype);
1487         p->fstype = f;
1488
1489         p->passno = passno;
1490
1491         unit_add_to_dbus_queue(u);
1492
1493         return 0;
1494
1495 fail:
1496         free(w);
1497         free(o);
1498         free(f);
1499
1500         if (delete && u)
1501                 unit_free(u);
1502
1503         return r;
1504 }
1505
1506 static int mount_find_pri(char *options) {
1507         char *end, *pri;
1508         unsigned long r;
1509
1510         if (!(pri = mount_test_option(options, "pri")))
1511                 return 0;
1512
1513         pri += 4;
1514
1515         errno = 0;
1516         r = strtoul(pri, &end, 10);
1517
1518         if (errno != 0)
1519                 return -errno;
1520
1521         if (end == pri || (*end != ',' && *end != 0))
1522                 return -EINVAL;
1523
1524         return (int) r;
1525 }
1526
1527 static int mount_load_etc_fstab(Manager *m) {
1528         FILE *f;
1529         int r = 0;
1530         struct mntent* me;
1531
1532         assert(m);
1533
1534         errno = 0;
1535         f = setmntent("/etc/fstab", "r");
1536         if (!f)
1537                 return errno == ENOENT ? 0 : -errno;
1538
1539         while ((me = getmntent(f))) {
1540                 char *where, *what;
1541                 int k;
1542
1543                 if (!(what = fstab_node_to_udev_node(me->mnt_fsname))) {
1544                         r = -ENOMEM;
1545                         goto finish;
1546                 }
1547
1548                 if (!(where = strdup(me->mnt_dir))) {
1549                         free(what);
1550                         r = -ENOMEM;
1551                         goto finish;
1552                 }
1553
1554                 if (what[0] == '/')
1555                         path_kill_slashes(what);
1556
1557                 if (where[0] == '/')
1558                         path_kill_slashes(where);
1559
1560                 if (streq(me->mnt_type, "swap")) {
1561                         int pri;
1562
1563                         if ((pri = mount_find_pri(me->mnt_opts)) < 0)
1564                                 k = pri;
1565                         else
1566                                 k = swap_add_one(m,
1567                                                  what,
1568                                                  NULL,
1569                                                  pri,
1570                                                  !!mount_test_option(me->mnt_opts, "noauto"),
1571                                                  !!mount_test_option(me->mnt_opts, "nofail"),
1572                                                  false);
1573                 } else
1574                         k = mount_add_one(m, what, where, me->mnt_opts, me->mnt_type, me->mnt_passno, false, false);
1575
1576                 free(what);
1577                 free(where);
1578
1579                 if (k < 0)
1580                         r = k;
1581         }
1582
1583 finish:
1584
1585         endmntent(f);
1586         return r;
1587 }
1588
1589 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1590         int r = 0;
1591         unsigned i;
1592         char *device, *path, *options, *options2, *fstype, *d, *p, *o;
1593
1594         assert(m);
1595
1596         rewind(m->proc_self_mountinfo);
1597
1598         for (i = 1;; i++) {
1599                 int k;
1600
1601                 device = path = options = options2 = fstype = d = p = o = NULL;
1602
1603                 if ((k = fscanf(m->proc_self_mountinfo,
1604                                 "%*s "       /* (1) mount id */
1605                                 "%*s "       /* (2) parent id */
1606                                 "%*s "       /* (3) major:minor */
1607                                 "%*s "       /* (4) root */
1608                                 "%ms "       /* (5) mount point */
1609                                 "%ms"        /* (6) mount options */
1610                                 "%*[^-]"     /* (7) optional fields */
1611                                 "- "         /* (8) separator */
1612                                 "%ms "       /* (9) file system type */
1613                                 "%ms"        /* (10) mount source */
1614                                 "%ms"        /* (11) mount options 2 */
1615                                 "%*[^\n]",   /* some rubbish at the end */
1616                                 &path,
1617                                 &options,
1618                                 &fstype,
1619                                 &device,
1620                                 &options2)) != 5) {
1621
1622                         if (k == EOF)
1623                                 break;
1624
1625                         log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1626                         goto clean_up;
1627                 }
1628
1629                 if (asprintf(&o, "%s,%s", options, options2) < 0) {
1630                         r = -ENOMEM;
1631                         goto finish;
1632                 }
1633
1634                 if (!(d = cunescape(device)) ||
1635                     !(p = cunescape(path))) {
1636                         r = -ENOMEM;
1637                         goto finish;
1638                 }
1639
1640                 if ((k = mount_add_one(m, d, p, o, fstype, 0, true, set_flags)) < 0)
1641                         r = k;
1642
1643 clean_up:
1644                 free(device);
1645                 free(path);
1646                 free(options);
1647                 free(options2);
1648                 free(fstype);
1649                 free(d);
1650                 free(p);
1651                 free(o);
1652         }
1653
1654 finish:
1655         free(device);
1656         free(path);
1657         free(options);
1658         free(options2);
1659         free(fstype);
1660         free(d);
1661         free(p);
1662         free(o);
1663
1664         return r;
1665 }
1666
1667 static void mount_shutdown(Manager *m) {
1668         assert(m);
1669
1670         if (m->proc_self_mountinfo) {
1671                 fclose(m->proc_self_mountinfo);
1672                 m->proc_self_mountinfo = NULL;
1673         }
1674 }
1675
1676 static int mount_enumerate(Manager *m) {
1677         int r;
1678         struct epoll_event ev;
1679         assert(m);
1680
1681         if (!m->proc_self_mountinfo) {
1682                 if (!(m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re")))
1683                         return -errno;
1684
1685                 m->mount_watch.type = WATCH_MOUNT;
1686                 m->mount_watch.fd = fileno(m->proc_self_mountinfo);
1687
1688                 zero(ev);
1689                 ev.events = EPOLLPRI;
1690                 ev.data.ptr = &m->mount_watch;
1691
1692                 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->mount_watch.fd, &ev) < 0)
1693                         return -errno;
1694         }
1695
1696         if ((r = mount_load_etc_fstab(m)) < 0)
1697                 goto fail;
1698
1699         if ((r = mount_load_proc_self_mountinfo(m, false)) < 0)
1700                 goto fail;
1701
1702         return 0;
1703
1704 fail:
1705         mount_shutdown(m);
1706         return r;
1707 }
1708
1709 void mount_fd_event(Manager *m, int events) {
1710         Unit *u;
1711         int r;
1712
1713         assert(m);
1714         assert(events & EPOLLPRI);
1715
1716         /* The manager calls this for every fd event happening on the
1717          * /proc/self/mountinfo file, which informs us about mounting
1718          * table changes */
1719
1720         if ((r = mount_load_proc_self_mountinfo(m, true)) < 0) {
1721                 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1722
1723                 /* Reset flags, just in case, for later calls */
1724                 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1725                         Mount *mount = MOUNT(u);
1726
1727                         mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1728                 }
1729
1730                 return;
1731         }
1732
1733         manager_dispatch_load_queue(m);
1734
1735         LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1736                 Mount *mount = MOUNT(u);
1737
1738                 if (!mount->is_mounted) {
1739                         /* This has just been unmounted. */
1740
1741                         mount->from_proc_self_mountinfo = false;
1742
1743                         switch (mount->state) {
1744
1745                         case MOUNT_MOUNTED:
1746                                 mount_enter_dead(mount, MOUNT_SUCCESS);
1747                                 break;
1748
1749                         default:
1750                                 mount_set_state(mount, mount->state);
1751                                 break;
1752
1753                         }
1754
1755                 } else if (mount->just_mounted || mount->just_changed) {
1756
1757                         /* New or changed mount entry */
1758
1759                         switch (mount->state) {
1760
1761                         case MOUNT_DEAD:
1762                         case MOUNT_FAILED:
1763                                 mount_enter_mounted(mount, MOUNT_SUCCESS);
1764                                 break;
1765
1766                         case MOUNT_MOUNTING:
1767                                 mount_enter_mounting_done(mount);
1768                                 break;
1769
1770                         default:
1771                                 /* Nothing really changed, but let's
1772                                  * issue an notification call
1773                                  * nonetheless, in case somebody is
1774                                  * waiting for this. (e.g. file system
1775                                  * ro/rw remounts.) */
1776                                 mount_set_state(mount, mount->state);
1777                                 break;
1778                         }
1779                 }
1780
1781                 /* Reset the flags for later calls */
1782                 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1783         }
1784 }
1785
1786 static void mount_reset_failed(Unit *u) {
1787         Mount *m = MOUNT(u);
1788
1789         assert(m);
1790
1791         if (m->state == MOUNT_FAILED)
1792                 mount_set_state(m, MOUNT_DEAD);
1793
1794         m->result = MOUNT_SUCCESS;
1795         m->reload_result = MOUNT_SUCCESS;
1796 }
1797
1798 static int mount_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
1799         Mount *m = MOUNT(u);
1800         int r = 0;
1801         Set *pid_set = NULL;
1802
1803         assert(m);
1804
1805         if (who == KILL_MAIN) {
1806                 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Mount units have no main processes");
1807                 return -ESRCH;
1808         }
1809
1810         if (m->control_pid <= 0 && who == KILL_CONTROL) {
1811                 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
1812                 return -ESRCH;
1813         }
1814
1815         if (who == KILL_CONTROL || who == KILL_ALL)
1816                 if (m->control_pid > 0)
1817                         if (kill(m->control_pid, signo) < 0)
1818                                 r = -errno;
1819
1820         if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
1821                 int q;
1822
1823                 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
1824                         return -ENOMEM;
1825
1826                 /* Exclude the control pid from being killed via the cgroup */
1827                 if (m->control_pid > 0)
1828                         if ((q = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0) {
1829                                 r = q;
1830                                 goto finish;
1831                         }
1832
1833                 q = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, signo, false, pid_set, NULL);
1834                 if (q < 0)
1835                         if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
1836                                 r = q;
1837         }
1838
1839 finish:
1840         if (pid_set)
1841                 set_free(pid_set);
1842
1843         return r;
1844 }
1845
1846 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1847         [MOUNT_DEAD] = "dead",
1848         [MOUNT_MOUNTING] = "mounting",
1849         [MOUNT_MOUNTING_DONE] = "mounting-done",
1850         [MOUNT_MOUNTED] = "mounted",
1851         [MOUNT_REMOUNTING] = "remounting",
1852         [MOUNT_UNMOUNTING] = "unmounting",
1853         [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1854         [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1855         [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1856         [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1857         [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1858         [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1859         [MOUNT_FAILED] = "failed"
1860 };
1861
1862 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1863
1864 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1865         [MOUNT_EXEC_MOUNT] = "ExecMount",
1866         [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1867         [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1868 };
1869
1870 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1871
1872 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1873         [MOUNT_SUCCESS] = "success",
1874         [MOUNT_FAILURE_RESOURCES] = "resources",
1875         [MOUNT_FAILURE_TIMEOUT] = "timeout",
1876         [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1877         [MOUNT_FAILURE_SIGNAL] = "signal",
1878         [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1879 };
1880
1881 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1882
1883 const UnitVTable mount_vtable = {
1884         .suffix = ".mount",
1885         .object_size = sizeof(Mount),
1886         .sections =
1887                 "Unit\0"
1888                 "Mount\0"
1889                 "Install\0",
1890
1891         .no_alias = true,
1892         .no_instances = true,
1893         .show_status = true,
1894
1895         .init = mount_init,
1896         .load = mount_load,
1897         .done = mount_done,
1898
1899         .coldplug = mount_coldplug,
1900
1901         .dump = mount_dump,
1902
1903         .start = mount_start,
1904         .stop = mount_stop,
1905         .reload = mount_reload,
1906
1907         .kill = mount_kill,
1908
1909         .serialize = mount_serialize,
1910         .deserialize_item = mount_deserialize_item,
1911
1912         .active_state = mount_active_state,
1913         .sub_state_to_string = mount_sub_state_to_string,
1914
1915         .check_gc = mount_check_gc,
1916
1917         .sigchld_event = mount_sigchld_event,
1918         .timer_event = mount_timer_event,
1919
1920         .reset_failed = mount_reset_failed,
1921
1922         .bus_interface = "org.freedesktop.systemd1.Mount",
1923         .bus_message_handler = bus_mount_message_handler,
1924         .bus_invalidating_properties =  bus_mount_invalidating_properties,
1925
1926         .enumerate = mount_enumerate,
1927         .shutdown = mount_shutdown
1928 };