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