src/core/mount.c

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