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