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