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