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