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