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