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