src/core/mount.c

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