src/core/mount.c

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