src/core/mount.c

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