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_load(Unit *u) {
 541         Mount *m = MOUNT(u);
 542         int r;
 543
 544         assert(u);
 545         assert(u->load_state == UNIT_STUB);
 546
 547         if ((r = unit_load_fragment_and_dropin_optional(u)) < 0)
 548                 return r;
 549
 550         /* This is a new unit? Then let's add in some extras */
 551         if (u->load_state == UNIT_LOADED) {
 552                 if ((r = unit_add_exec_dependencies(u, &m->exec_context)) < 0)
 553                         return r;
 554
 555                 if (UNIT(m)->fragment_path)
 556                         m->from_fragment = true;
 557
 558                 if (!m->where)
 559                         if (!(m->where = unit_name_to_path(u->id)))
 560                                 return -ENOMEM;
 561
 562                 path_kill_slashes(m->where);
 563
 564                 if (!UNIT(m)->description)
 565                         if ((r = unit_set_description(u, m->where)) < 0)
 566                                 return r;
 567
 568                 if ((r = mount_add_device_links(m)) < 0)
 569                         return r;
 570
 571                 if ((r = mount_add_mount_links(m)) < 0)
 572                         return r;
 573
 574                 if ((r = mount_add_socket_links(m)) < 0)
 575                         return r;
 576
 577                 if ((r = mount_add_swap_links(m)) < 0)
 578                         return r;
 579
 580                 if ((r = mount_add_path_links(m)) < 0)
 581                         return r;
 582
 583                 r = mount_add_requires_mounts_links(m);
 584                 if (r < 0)
 585                         return r;
 586
 587                 if ((r = mount_add_automount_links(m)) < 0)
 588                         return r;
 589
 590                 r = mount_add_quota_links(m);
 591                 if (r < 0)
 592                         return r;
 593
 594                 if (UNIT(m)->default_dependencies)
 595                         if ((r = mount_add_default_dependencies(m)) < 0)
 596                                 return r;
 597
 598                 if ((r = unit_add_default_cgroups(u)) < 0)
 599                         return r;
 600
 601                 mount_fix_timeouts(m);
 602         }
 603
 604         return mount_verify(m);
 605 }
 606
 607 static int mount_notify_automount(Mount *m, int status) {
 608         Unit *p;
 609         int r;
 610         Iterator i;
 611
 612         assert(m);
 613
 614         SET_FOREACH(p, UNIT(m)->dependencies[UNIT_TRIGGERED_BY], i)
 615                 if (p->type == UNIT_AUTOMOUNT) {
 616                          r = automount_send_ready(AUTOMOUNT(p), status);
 617                          if (r < 0)
 618                                  return r;
 619                 }
 620
 621         return 0;
 622 }
 623
 624 static void mount_set_state(Mount *m, MountState state) {
 625         MountState old_state;
 626         assert(m);
 627
 628         old_state = m->state;
 629         m->state = state;
 630
 631         if (state != MOUNT_MOUNTING &&
 632             state != MOUNT_MOUNTING_DONE &&
 633             state != MOUNT_REMOUNTING &&
 634             state != MOUNT_UNMOUNTING &&
 635             state != MOUNT_MOUNTING_SIGTERM &&
 636             state != MOUNT_MOUNTING_SIGKILL &&
 637             state != MOUNT_UNMOUNTING_SIGTERM &&
 638             state != MOUNT_UNMOUNTING_SIGKILL &&
 639             state != MOUNT_REMOUNTING_SIGTERM &&
 640             state != MOUNT_REMOUNTING_SIGKILL) {
 641                 unit_unwatch_timer(UNIT(m), &m->timer_watch);
 642                 mount_unwatch_control_pid(m);
 643                 m->control_command = NULL;
 644                 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
 645         }
 646
 647         if (state == MOUNT_MOUNTED ||
 648             state == MOUNT_REMOUNTING)
 649                 mount_notify_automount(m, 0);
 650         else if (state == MOUNT_DEAD ||
 651                  state == MOUNT_UNMOUNTING ||
 652                  state == MOUNT_MOUNTING_SIGTERM ||
 653                  state == MOUNT_MOUNTING_SIGKILL ||
 654                  state == MOUNT_REMOUNTING_SIGTERM ||
 655                  state == MOUNT_REMOUNTING_SIGKILL ||
 656                  state == MOUNT_UNMOUNTING_SIGTERM ||
 657                  state == MOUNT_UNMOUNTING_SIGKILL ||
 658                  state == MOUNT_FAILED)
 659                 mount_notify_automount(m, -ENODEV);
 660
 661         if (state != old_state)
 662                 log_debug("%s changed %s -> %s",
 663                           UNIT(m)->id,
 664                           mount_state_to_string(old_state),
 665                           mount_state_to_string(state));
 666
 667         unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
 668         m->reload_result = MOUNT_SUCCESS;
 669 }
 670
 671 static int mount_coldplug(Unit *u) {
 672         Mount *m = MOUNT(u);
 673         MountState new_state = MOUNT_DEAD;
 674         int r;
 675
 676         assert(m);
 677         assert(m->state == MOUNT_DEAD);
 678
 679         if (m->deserialized_state != m->state)
 680                 new_state = m->deserialized_state;
 681         else if (m->from_proc_self_mountinfo)
 682                 new_state = MOUNT_MOUNTED;
 683
 684         if (new_state != m->state) {
 685
 686                 if (new_state == MOUNT_MOUNTING ||
 687                     new_state == MOUNT_MOUNTING_DONE ||
 688                     new_state == MOUNT_REMOUNTING ||
 689                     new_state == MOUNT_UNMOUNTING ||
 690                     new_state == MOUNT_MOUNTING_SIGTERM ||
 691                     new_state == MOUNT_MOUNTING_SIGKILL ||
 692                     new_state == MOUNT_UNMOUNTING_SIGTERM ||
 693                     new_state == MOUNT_UNMOUNTING_SIGKILL ||
 694                     new_state == MOUNT_REMOUNTING_SIGTERM ||
 695                     new_state == MOUNT_REMOUNTING_SIGKILL) {
 696
 697                         if (m->control_pid <= 0)
 698                                 return -EBADMSG;
 699
 700                         if ((r = unit_watch_pid(UNIT(m), m->control_pid)) < 0)
 701                                 return r;
 702
 703                         if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
 704                                 return r;
 705                 }
 706
 707                 mount_set_state(m, new_state);
 708         }
 709
 710         return 0;
 711 }
 712
 713 static void mount_dump(Unit *u, FILE *f, const char *prefix) {
 714         Mount *m = MOUNT(u);
 715         MountParameters *p;
 716
 717         assert(m);
 718         assert(f);
 719
 720         p = get_mount_parameters(m);
 721
 722         fprintf(f,
 723                 "%sMount State: %s\n"
 724                 "%sResult: %s\n"
 725                 "%sWhere: %s\n"
 726                 "%sWhat: %s\n"
 727                 "%sFile System Type: %s\n"
 728                 "%sOptions: %s\n"
 729                 "%sFrom /proc/self/mountinfo: %s\n"
 730                 "%sFrom fragment: %s\n"
 731                 "%sDirectoryMode: %04o\n",
 732                 prefix, mount_state_to_string(m->state),
 733                 prefix, mount_result_to_string(m->result),
 734                 prefix, m->where,
 735                 prefix, strna(p->what),
 736                 prefix, strna(p->fstype),
 737                 prefix, strna(p->options),
 738                 prefix, yes_no(m->from_proc_self_mountinfo),
 739                 prefix, yes_no(m->from_fragment),
 740                 prefix, m->directory_mode);
 741
 742         if (m->control_pid > 0)
 743                 fprintf(f,
 744                         "%sControl PID: %lu\n",
 745                         prefix, (unsigned long) m->control_pid);
 746
 747         exec_context_dump(&m->exec_context, f, prefix);
 748 }
 749
 750 static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
 751         pid_t pid;
 752         int r;
 753
 754         assert(m);
 755         assert(c);
 756         assert(_pid);
 757
 758         if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
 759                 goto fail;
 760
 761         if ((r = exec_spawn(c,
 762                             NULL,
 763                             &m->exec_context,
 764                             NULL, 0,
 765                             UNIT(m)->manager->environment,
 766                             true,
 767                             true,
 768                             true,
 769                             UNIT(m)->manager->confirm_spawn,
 770                             UNIT(m)->cgroup_bondings,
 771                             UNIT(m)->cgroup_attributes,
 772                             NULL,
 773                             UNIT(m)->id,
 774                             NULL,
 775                             &pid)) < 0)
 776                 goto fail;
 777
 778         if ((r = unit_watch_pid(UNIT(m), pid)) < 0)
 779                 /* FIXME: we need to do something here */
 780                 goto fail;
 781
 782         *_pid = pid;
 783
 784         return 0;
 785
 786 fail:
 787         unit_unwatch_timer(UNIT(m), &m->timer_watch);
 788
 789         return r;
 790 }
 791
 792 static void mount_enter_dead(Mount *m, MountResult f) {
 793         assert(m);
 794
 795         if (f != MOUNT_SUCCESS)
 796                 m->result = f;
 797
 798         mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
 799 }
 800
 801 static void mount_enter_mounted(Mount *m, MountResult f) {
 802         assert(m);
 803
 804         if (f != MOUNT_SUCCESS)
 805                 m->result = f;
 806
 807         mount_set_state(m, MOUNT_MOUNTED);
 808 }
 809
 810 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
 811         int r;
 812         Set *pid_set = NULL;
 813         bool wait_for_exit = false;
 814
 815         assert(m);
 816
 817         if (f != MOUNT_SUCCESS)
 818                 m->result = f;
 819
 820         if (m->exec_context.kill_mode != KILL_NONE) {
 821                 int sig = (state == MOUNT_MOUNTING_SIGTERM ||
 822                            state == MOUNT_UNMOUNTING_SIGTERM ||
 823                            state == MOUNT_REMOUNTING_SIGTERM) ? m->exec_context.kill_signal : SIGKILL;
 824
 825                 if (m->control_pid > 0) {
 826                         if (kill_and_sigcont(m->control_pid, sig) < 0 && errno != ESRCH)
 827
 828                                 log_warning("Failed to kill control process %li: %m", (long) m->control_pid);
 829                         else
 830                                 wait_for_exit = true;
 831                 }
 832
 833                 if (m->exec_context.kill_mode == KILL_CONTROL_GROUP) {
 834
 835                         if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
 836                                 r = -ENOMEM;
 837                                 goto fail;
 838                         }
 839
 840                         /* Exclude the control pid from being killed via the cgroup */
 841                         if (m->control_pid > 0)
 842                                 if ((r = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0)
 843                                         goto fail;
 844
 845                         r = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, sig, true, false, pid_set, NULL);
 846                         if (r < 0) {
 847                                 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
 848                                         log_warning("Failed to kill control group: %s", strerror(-r));
 849                         } else if (r > 0)
 850                                 wait_for_exit = true;
 851
 852                         set_free(pid_set);
 853                         pid_set = NULL;
 854                 }
 855         }
 856
 857         if (wait_for_exit) {
 858                 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
 859                         goto fail;
 860
 861                 mount_set_state(m, state);
 862         } else if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
 863                 mount_enter_mounted(m, MOUNT_SUCCESS);
 864         else
 865                 mount_enter_dead(m, MOUNT_SUCCESS);
 866
 867         return;
 868
 869 fail:
 870         log_warning("%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
 871
 872         if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
 873                 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
 874         else
 875                 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
 876
 877         if (pid_set)
 878                 set_free(pid_set);
 879 }
 880
 881 static void mount_enter_unmounting(Mount *m) {
 882         int r;
 883
 884         assert(m);
 885
 886         m->control_command_id = MOUNT_EXEC_UNMOUNT;
 887         m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
 888
 889         if ((r = exec_command_set(
 890                              m->control_command,
 891                              "/bin/umount",
 892                              m->where,
 893                              NULL)) < 0)
 894                 goto fail;
 895
 896         mount_unwatch_control_pid(m);
 897
 898         if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
 899                 goto fail;
 900
 901         mount_set_state(m, MOUNT_UNMOUNTING);
 902
 903         return;
 904
 905 fail:
 906         log_warning("%s failed to run 'umount' task: %s", UNIT(m)->id, strerror(-r));
 907         mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
 908 }
 909
 910 static void mount_enter_mounting(Mount *m) {
 911         int r;
 912         MountParameters *p;
 913
 914         assert(m);
 915
 916         m->control_command_id = MOUNT_EXEC_MOUNT;
 917         m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
 918
 919         mkdir_p_label(m->where, m->directory_mode);
 920
 921         /* Create the source directory for bind-mounts if needed */
 922         p = get_mount_parameters_fragment(m);
 923         if (p && mount_is_bind(p))
 924                 mkdir_p_label(p->what, m->directory_mode);
 925
 926         if (m->from_fragment)
 927                 r = exec_command_set(
 928                                 m->control_command,
 929                                 "/bin/mount",
 930                                 m->parameters_fragment.what,
 931                                 m->where,
 932                                 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
 933                                 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
 934                                 NULL);
 935         else
 936                 r = -ENOENT;
 937
 938         if (r < 0)
 939                 goto fail;
 940
 941         mount_unwatch_control_pid(m);
 942
 943         if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
 944                 goto fail;
 945
 946         mount_set_state(m, MOUNT_MOUNTING);
 947
 948         return;
 949
 950 fail:
 951         log_warning("%s failed to run 'mount' task: %s", UNIT(m)->id, strerror(-r));
 952         mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
 953 }
 954
 955 static void mount_enter_mounting_done(Mount *m) {
 956         assert(m);
 957
 958         mount_set_state(m, MOUNT_MOUNTING_DONE);
 959 }
 960
 961 static void mount_enter_remounting(Mount *m) {
 962         int r;
 963
 964         assert(m);
 965
 966         m->control_command_id = MOUNT_EXEC_REMOUNT;
 967         m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
 968
 969         if (m->from_fragment) {
 970                 char *buf = NULL;
 971                 const char *o;
 972
 973                 if (m->parameters_fragment.options) {
 974                         if (!(buf = strappend("remount,", m->parameters_fragment.options))) {
 975                                 r = -ENOMEM;
 976                                 goto fail;
 977                         }
 978
 979                         o = buf;
 980                 } else
 981                         o = "remount";
 982
 983                 r = exec_command_set(
 984                                 m->control_command,
 985                                 "/bin/mount",
 986                                 m->parameters_fragment.what,
 987                                 m->where,
 988                                 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
 989                                 "-o", o,
 990                                 NULL);
 991
 992                 free(buf);
 993         } else
 994                 r = -ENOENT;
 995
 996         if (r < 0)
 997                 goto fail;
 998
 999         mount_unwatch_control_pid(m);
1000
1001         if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
1002                 goto fail;
1003
1004         mount_set_state(m, MOUNT_REMOUNTING);
1005
1006         return;
1007
1008 fail:
1009         log_warning("%s failed to run 'remount' task: %s", UNIT(m)->id, strerror(-r));
1010         m->reload_result = MOUNT_FAILURE_RESOURCES;
1011         mount_enter_mounted(m, MOUNT_SUCCESS);
1012 }
1013
1014 static int mount_start(Unit *u) {
1015         Mount *m = MOUNT(u);
1016
1017         assert(m);
1018
1019         /* We cannot fulfill this request right now, try again later
1020          * please! */
1021         if (m->state == MOUNT_UNMOUNTING ||
1022             m->state == MOUNT_UNMOUNTING_SIGTERM ||
1023             m->state == MOUNT_UNMOUNTING_SIGKILL ||
1024             m->state == MOUNT_MOUNTING_SIGTERM ||
1025             m->state == MOUNT_MOUNTING_SIGKILL)
1026                 return -EAGAIN;
1027
1028         /* Already on it! */
1029         if (m->state == MOUNT_MOUNTING)
1030                 return 0;
1031
1032         assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1033
1034         m->result = MOUNT_SUCCESS;
1035         m->reload_result = MOUNT_SUCCESS;
1036
1037         mount_enter_mounting(m);
1038         return 0;
1039 }
1040
1041 static int mount_stop(Unit *u) {
1042         Mount *m = MOUNT(u);
1043
1044         assert(m);
1045
1046         /* Already on it */
1047         if (m->state == MOUNT_UNMOUNTING ||
1048             m->state == MOUNT_UNMOUNTING_SIGKILL ||
1049             m->state == MOUNT_UNMOUNTING_SIGTERM ||
1050             m->state == MOUNT_MOUNTING_SIGTERM ||
1051             m->state == MOUNT_MOUNTING_SIGKILL)
1052                 return 0;
1053
1054         assert(m->state == MOUNT_MOUNTING ||
1055                m->state == MOUNT_MOUNTING_DONE ||
1056                m->state == MOUNT_MOUNTED ||
1057                m->state == MOUNT_REMOUNTING ||
1058                m->state == MOUNT_REMOUNTING_SIGTERM ||
1059                m->state == MOUNT_REMOUNTING_SIGKILL);
1060
1061         mount_enter_unmounting(m);
1062         return 0;
1063 }
1064
1065 static int mount_reload(Unit *u) {
1066         Mount *m = MOUNT(u);
1067
1068         assert(m);
1069
1070         if (m->state == MOUNT_MOUNTING_DONE)
1071                 return -EAGAIN;
1072
1073         assert(m->state == MOUNT_MOUNTED);
1074
1075         mount_enter_remounting(m);
1076         return 0;
1077 }
1078
1079 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1080         Mount *m = MOUNT(u);
1081
1082         assert(m);
1083         assert(f);
1084         assert(fds);
1085
1086         unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1087         unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1088         unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1089
1090         if (m->control_pid > 0)
1091                 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) m->control_pid);
1092
1093         if (m->control_command_id >= 0)
1094                 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1095
1096         return 0;
1097 }
1098
1099 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1100         Mount *m = MOUNT(u);
1101
1102         assert(u);
1103         assert(key);
1104         assert(value);
1105         assert(fds);
1106
1107         if (streq(key, "state")) {
1108                 MountState state;
1109
1110                 if ((state = mount_state_from_string(value)) < 0)
1111                         log_debug("Failed to parse state value %s", value);
1112                 else
1113                         m->deserialized_state = state;
1114         } else if (streq(key, "result")) {
1115                 MountResult f;
1116
1117                 f = mount_result_from_string(value);
1118                 if (f < 0)
1119                         log_debug("Failed to parse result value %s", value);
1120                 else if (f != MOUNT_SUCCESS)
1121                         m->result = f;
1122
1123         } else if (streq(key, "reload-result")) {
1124                 MountResult f;
1125
1126                 f = mount_result_from_string(value);
1127                 if (f < 0)
1128                         log_debug("Failed to parse reload result value %s", value);
1129                 else if (f != MOUNT_SUCCESS)
1130                         m->reload_result = f;
1131
1132         } else if (streq(key, "control-pid")) {
1133                 pid_t pid;
1134
1135                 if (parse_pid(value, &pid) < 0)
1136                         log_debug("Failed to parse control-pid value %s", value);
1137                 else
1138                         m->control_pid = pid;
1139         } else if (streq(key, "control-command")) {
1140                 MountExecCommand id;
1141
1142                 if ((id = mount_exec_command_from_string(value)) < 0)
1143                         log_debug("Failed to parse exec-command value %s", value);
1144                 else {
1145                         m->control_command_id = id;
1146                         m->control_command = m->exec_command + id;
1147                 }
1148
1149         } else
1150                 log_debug("Unknown serialization key '%s'", key);
1151
1152         return 0;
1153 }
1154
1155 static UnitActiveState mount_active_state(Unit *u) {
1156         assert(u);
1157
1158         return state_translation_table[MOUNT(u)->state];
1159 }
1160
1161 static const char *mount_sub_state_to_string(Unit *u) {
1162         assert(u);
1163
1164         return mount_state_to_string(MOUNT(u)->state);
1165 }
1166
1167 static bool mount_check_gc(Unit *u) {
1168         Mount *m = MOUNT(u);
1169
1170         assert(m);
1171
1172         return m->from_proc_self_mountinfo;
1173 }
1174
1175 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1176         Mount *m = MOUNT(u);
1177         MountResult f;
1178
1179         assert(m);
1180         assert(pid >= 0);
1181
1182         if (pid != m->control_pid)
1183                 return;
1184
1185         m->control_pid = 0;
1186
1187         if (is_clean_exit(code, status))
1188                 f = MOUNT_SUCCESS;
1189         else if (code == CLD_EXITED)
1190                 f = MOUNT_FAILURE_EXIT_CODE;
1191         else if (code == CLD_KILLED)
1192                 f = MOUNT_FAILURE_SIGNAL;
1193         else if (code == CLD_DUMPED)
1194                 f = MOUNT_FAILURE_CORE_DUMP;
1195         else
1196                 assert_not_reached("Unknown code");
1197
1198         if (f != MOUNT_SUCCESS)
1199                 m->result = f;
1200
1201         if (m->control_command) {
1202                 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1203
1204                 m->control_command = NULL;
1205                 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1206         }
1207
1208         log_full(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1209                  "%s mount process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1210
1211         /* Note that mount(8) returning and the kernel sending us a
1212          * mount table change event might happen out-of-order. If an
1213          * operation succeed we assume the kernel will follow soon too
1214          * and already change into the resulting state.  If it fails
1215          * we check if the kernel still knows about the mount. and
1216          * change state accordingly. */
1217
1218         switch (m->state) {
1219
1220         case MOUNT_MOUNTING:
1221         case MOUNT_MOUNTING_DONE:
1222         case MOUNT_MOUNTING_SIGKILL:
1223         case MOUNT_MOUNTING_SIGTERM:
1224
1225                 if (f == MOUNT_SUCCESS)
1226                         mount_enter_mounted(m, f);
1227                 else if (m->from_proc_self_mountinfo)
1228                         mount_enter_mounted(m, f);
1229                 else
1230                         mount_enter_dead(m, f);
1231                 break;
1232
1233         case MOUNT_REMOUNTING:
1234         case MOUNT_REMOUNTING_SIGKILL:
1235         case MOUNT_REMOUNTING_SIGTERM:
1236
1237                 m->reload_result = f;
1238                 if (m->from_proc_self_mountinfo)
1239                         mount_enter_mounted(m, MOUNT_SUCCESS);
1240                 else
1241                         mount_enter_dead(m, MOUNT_SUCCESS);
1242
1243                 break;
1244
1245         case MOUNT_UNMOUNTING:
1246         case MOUNT_UNMOUNTING_SIGKILL:
1247         case MOUNT_UNMOUNTING_SIGTERM:
1248
1249                 if (f == MOUNT_SUCCESS)
1250                         mount_enter_dead(m, f);
1251                 else if (m->from_proc_self_mountinfo)
1252                         mount_enter_mounted(m, f);
1253                 else
1254                         mount_enter_dead(m, f);
1255                 break;
1256
1257         default:
1258                 assert_not_reached("Uh, control process died at wrong time.");
1259         }
1260
1261         /* Notify clients about changed exit status */
1262         unit_add_to_dbus_queue(u);
1263 }
1264
1265 static void mount_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1266         Mount *m = MOUNT(u);
1267
1268         assert(m);
1269         assert(elapsed == 1);
1270         assert(w == &m->timer_watch);
1271
1272         switch (m->state) {
1273
1274         case MOUNT_MOUNTING:
1275         case MOUNT_MOUNTING_DONE:
1276                 log_warning("%s mounting timed out. Stopping.", u->id);
1277                 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1278                 break;
1279
1280         case MOUNT_REMOUNTING:
1281                 log_warning("%s remounting timed out. Stopping.", u->id);
1282                 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1283                 mount_enter_mounted(m, MOUNT_SUCCESS);
1284                 break;
1285
1286         case MOUNT_UNMOUNTING:
1287                 log_warning("%s unmounting timed out. Stopping.", u->id);
1288                 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1289                 break;
1290
1291         case MOUNT_MOUNTING_SIGTERM:
1292                 if (m->exec_context.send_sigkill) {
1293                         log_warning("%s mounting timed out. Killing.", u->id);
1294                         mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1295                 } else {
1296                         log_warning("%s mounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1297
1298                         if (m->from_proc_self_mountinfo)
1299                                 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1300                         else
1301                                 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1302                 }
1303                 break;
1304
1305         case MOUNT_REMOUNTING_SIGTERM:
1306                 if (m->exec_context.send_sigkill) {
1307                         log_warning("%s remounting timed out. Killing.", u->id);
1308                         mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1309                 } else {
1310                         log_warning("%s remounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1311
1312                         if (m->from_proc_self_mountinfo)
1313                                 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1314                         else
1315                                 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1316                 }
1317                 break;
1318
1319         case MOUNT_UNMOUNTING_SIGTERM:
1320                 if (m->exec_context.send_sigkill) {
1321                         log_warning("%s unmounting timed out. Killing.", u->id);
1322                         mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1323                 } else {
1324                         log_warning("%s unmounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1325
1326                         if (m->from_proc_self_mountinfo)
1327                                 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1328                         else
1329                                 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1330                 }
1331                 break;
1332
1333         case MOUNT_MOUNTING_SIGKILL:
1334         case MOUNT_REMOUNTING_SIGKILL:
1335         case MOUNT_UNMOUNTING_SIGKILL:
1336                 log_warning("%s mount process still around after SIGKILL. Ignoring.", u->id);
1337
1338                 if (m->from_proc_self_mountinfo)
1339                         mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1340                 else
1341                         mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1342                 break;
1343
1344         default:
1345                 assert_not_reached("Timeout at wrong time.");
1346         }
1347 }
1348
1349 static int mount_add_one(
1350                 Manager *m,
1351                 const char *what,
1352                 const char *where,
1353                 const char *options,
1354                 const char *fstype,
1355                 int passno,
1356                 bool set_flags) {
1357         int r;
1358         Unit *u;
1359         bool delete;
1360         char *e, *w = NULL, *o = NULL, *f = NULL;
1361         MountParameters *p;
1362
1363         assert(m);
1364         assert(what);
1365         assert(where);
1366         assert(options);
1367         assert(fstype);
1368
1369         /* Ignore API mount points. They should never be referenced in
1370          * dependencies ever. */
1371         if (mount_point_is_api(where) || mount_point_ignore(where))
1372                 return 0;
1373
1374         if (streq(fstype, "autofs"))
1375                 return 0;
1376
1377         /* probably some kind of swap, ignore */
1378         if (!is_path(where))
1379                 return 0;
1380
1381         e = unit_name_from_path(where, ".mount");
1382         if (!e)
1383                 return -ENOMEM;
1384
1385         u = manager_get_unit(m, e);
1386         if (!u) {
1387                 delete = true;
1388
1389                 u = unit_new(m, sizeof(Mount));
1390                 if (!u) {
1391                         free(e);
1392                         return -ENOMEM;
1393                 }
1394
1395                 r = unit_add_name(u, e);
1396                 free(e);
1397
1398                 if (r < 0)
1399                         goto fail;
1400
1401                 MOUNT(u)->where = strdup(where);
1402                 if (!MOUNT(u)->where) {
1403                         r = -ENOMEM;
1404                         goto fail;
1405                 }
1406
1407                 unit_add_to_load_queue(u);
1408         } else {
1409                 delete = false;
1410                 free(e);
1411         }
1412
1413         if (!(w = strdup(what)) ||
1414             !(o = strdup(options)) ||
1415             !(f = strdup(fstype))) {
1416                 r = -ENOMEM;
1417                 goto fail;
1418         }
1419
1420         p = &MOUNT(u)->parameters_proc_self_mountinfo;
1421         if (set_flags) {
1422                 MOUNT(u)->is_mounted = true;
1423                 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1424                 MOUNT(u)->just_changed = !streq_ptr(p->options, o);
1425         }
1426
1427         MOUNT(u)->from_proc_self_mountinfo = true;
1428
1429         free(p->what);
1430         p->what = w;
1431
1432         free(p->options);
1433         p->options = o;
1434
1435         free(p->fstype);
1436         p->fstype = f;
1437
1438         p->passno = passno;
1439
1440         unit_add_to_dbus_queue(u);
1441
1442         return 0;
1443
1444 fail:
1445         free(w);
1446         free(o);
1447         free(f);
1448
1449         if (delete && u)
1450                 unit_free(u);
1451
1452         return r;
1453 }
1454
1455 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1456         int r = 0;
1457         unsigned i;
1458         char *device, *path, *options, *options2, *fstype, *d, *p, *o;
1459
1460         assert(m);
1461
1462         rewind(m->proc_self_mountinfo);
1463
1464         for (i = 1;; i++) {
1465                 int k;
1466
1467                 device = path = options = options2 = fstype = d = p = o = NULL;
1468
1469                 if ((k = fscanf(m->proc_self_mountinfo,
1470                                 "%*s "       /* (1) mount id */
1471                                 "%*s "       /* (2) parent id */
1472                                 "%*s "       /* (3) major:minor */
1473                                 "%*s "       /* (4) root */
1474                                 "%ms "       /* (5) mount point */
1475                                 "%ms"        /* (6) mount options */
1476                                 "%*[^-]"     /* (7) optional fields */
1477                                 "- "         /* (8) separator */
1478                                 "%ms "       /* (9) file system type */
1479                                 "%ms"        /* (10) mount source */
1480                                 "%ms"        /* (11) mount options 2 */
1481                                 "%*[^\n]",   /* some rubbish at the end */
1482                                 &path,
1483                                 &options,
1484                                 &fstype,
1485                                 &device,
1486                                 &options2)) != 5) {
1487
1488                         if (k == EOF)
1489                                 break;
1490
1491                         log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1492                         goto clean_up;
1493                 }
1494
1495                 o = join(options, ",", options2, NULL);
1496                 if (!o) {
1497                         r = -ENOMEM;
1498                         goto finish;
1499                 }
1500
1501                 if (!(d = cunescape(device)) ||
1502                     !(p = cunescape(path))) {
1503                         r = -ENOMEM;
1504                         goto finish;
1505                 }
1506
1507                 if ((k = mount_add_one(m, d, p, o, fstype, 0, set_flags)) < 0)
1508                         r = k;
1509
1510 clean_up:
1511                 free(device);
1512                 free(path);
1513                 free(options);
1514                 free(options2);
1515                 free(fstype);
1516                 free(d);
1517                 free(p);
1518                 free(o);
1519         }
1520
1521 finish:
1522         free(device);
1523         free(path);
1524         free(options);
1525         free(options2);
1526         free(fstype);
1527         free(d);
1528         free(p);
1529         free(o);
1530
1531         return r;
1532 }
1533
1534 static void mount_shutdown(Manager *m) {
1535         assert(m);
1536
1537         if (m->proc_self_mountinfo) {
1538                 fclose(m->proc_self_mountinfo);
1539                 m->proc_self_mountinfo = NULL;
1540         }
1541 }
1542
1543 static int mount_enumerate(Manager *m) {
1544         int r;
1545         struct epoll_event ev;
1546         assert(m);
1547
1548         if (!m->proc_self_mountinfo) {
1549                 if (!(m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re")))
1550                         return -errno;
1551
1552                 m->mount_watch.type = WATCH_MOUNT;
1553                 m->mount_watch.fd = fileno(m->proc_self_mountinfo);
1554
1555                 zero(ev);
1556                 ev.events = EPOLLPRI;
1557                 ev.data.ptr = &m->mount_watch;
1558
1559                 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->mount_watch.fd, &ev) < 0)
1560                         return -errno;
1561         }
1562
1563         if ((r = mount_load_proc_self_mountinfo(m, false)) < 0)
1564                 goto fail;
1565
1566         return 0;
1567
1568 fail:
1569         mount_shutdown(m);
1570         return r;
1571 }
1572
1573 void mount_fd_event(Manager *m, int events) {
1574         Unit *u;
1575         int r;
1576
1577         assert(m);
1578         assert(events & EPOLLPRI);
1579
1580         /* The manager calls this for every fd event happening on the
1581          * /proc/self/mountinfo file, which informs us about mounting
1582          * table changes */
1583
1584         if ((r = mount_load_proc_self_mountinfo(m, true)) < 0) {
1585                 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1586
1587                 /* Reset flags, just in case, for later calls */
1588                 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1589                         Mount *mount = MOUNT(u);
1590
1591                         mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1592                 }
1593
1594                 return;
1595         }
1596
1597         manager_dispatch_load_queue(m);
1598
1599         LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1600                 Mount *mount = MOUNT(u);
1601
1602                 if (!mount->is_mounted) {
1603                         /* This has just been unmounted. */
1604
1605                         mount->from_proc_self_mountinfo = false;
1606
1607                         switch (mount->state) {
1608
1609                         case MOUNT_MOUNTED:
1610                                 mount_enter_dead(mount, MOUNT_SUCCESS);
1611                                 break;
1612
1613                         default:
1614                                 mount_set_state(mount, mount->state);
1615                                 break;
1616
1617                         }
1618
1619                 } else if (mount->just_mounted || mount->just_changed) {
1620
1621                         /* New or changed mount entry */
1622
1623                         switch (mount->state) {
1624
1625                         case MOUNT_DEAD:
1626                         case MOUNT_FAILED:
1627                                 mount_enter_mounted(mount, MOUNT_SUCCESS);
1628                                 break;
1629
1630                         case MOUNT_MOUNTING:
1631                                 mount_enter_mounting_done(mount);
1632                                 break;
1633
1634                         default:
1635                                 /* Nothing really changed, but let's
1636                                  * issue an notification call
1637                                  * nonetheless, in case somebody is
1638                                  * waiting for this. (e.g. file system
1639                                  * ro/rw remounts.) */
1640                                 mount_set_state(mount, mount->state);
1641                                 break;
1642                         }
1643                 }
1644
1645                 /* Reset the flags for later calls */
1646                 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1647         }
1648 }
1649
1650 static void mount_reset_failed(Unit *u) {
1651         Mount *m = MOUNT(u);
1652
1653         assert(m);
1654
1655         if (m->state == MOUNT_FAILED)
1656                 mount_set_state(m, MOUNT_DEAD);
1657
1658         m->result = MOUNT_SUCCESS;
1659         m->reload_result = MOUNT_SUCCESS;
1660 }
1661
1662 static int mount_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
1663         Mount *m = MOUNT(u);
1664         int r = 0;
1665         Set *pid_set = NULL;
1666
1667         assert(m);
1668
1669         if (who == KILL_MAIN) {
1670                 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Mount units have no main processes");
1671                 return -ESRCH;
1672         }
1673
1674         if (m->control_pid <= 0 && who == KILL_CONTROL) {
1675                 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
1676                 return -ESRCH;
1677         }
1678
1679         if (who == KILL_CONTROL || who == KILL_ALL)
1680                 if (m->control_pid > 0)
1681                         if (kill(m->control_pid, signo) < 0)
1682                                 r = -errno;
1683
1684         if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
1685                 int q;
1686
1687                 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
1688                         return -ENOMEM;
1689
1690                 /* Exclude the control pid from being killed via the cgroup */
1691                 if (m->control_pid > 0)
1692                         if ((q = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0) {
1693                                 r = q;
1694                                 goto finish;
1695                         }
1696
1697                 q = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, signo, false, false, pid_set, NULL);
1698                 if (q < 0)
1699                         if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
1700                                 r = q;
1701         }
1702
1703 finish:
1704         if (pid_set)
1705                 set_free(pid_set);
1706
1707         return r;
1708 }
1709
1710 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1711         [MOUNT_DEAD] = "dead",
1712         [MOUNT_MOUNTING] = "mounting",
1713         [MOUNT_MOUNTING_DONE] = "mounting-done",
1714         [MOUNT_MOUNTED] = "mounted",
1715         [MOUNT_REMOUNTING] = "remounting",
1716         [MOUNT_UNMOUNTING] = "unmounting",
1717         [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1718         [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1719         [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1720         [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1721         [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1722         [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1723         [MOUNT_FAILED] = "failed"
1724 };
1725
1726 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1727
1728 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1729         [MOUNT_EXEC_MOUNT] = "ExecMount",
1730         [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1731         [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1732 };
1733
1734 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1735
1736 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1737         [MOUNT_SUCCESS] = "success",
1738         [MOUNT_FAILURE_RESOURCES] = "resources",
1739         [MOUNT_FAILURE_TIMEOUT] = "timeout",
1740         [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1741         [MOUNT_FAILURE_SIGNAL] = "signal",
1742         [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1743 };
1744
1745 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1746
1747 const UnitVTable mount_vtable = {
1748         .suffix = ".mount",
1749         .object_size = sizeof(Mount),
1750         .sections =
1751                 "Unit\0"
1752                 "Mount\0"
1753                 "Install\0",
1754
1755         .no_alias = true,
1756         .no_instances = true,
1757
1758         .init = mount_init,
1759         .load = mount_load,
1760         .done = mount_done,
1761
1762         .coldplug = mount_coldplug,
1763
1764         .dump = mount_dump,
1765
1766         .start = mount_start,
1767         .stop = mount_stop,
1768         .reload = mount_reload,
1769
1770         .kill = mount_kill,
1771
1772         .serialize = mount_serialize,
1773         .deserialize_item = mount_deserialize_item,
1774
1775         .active_state = mount_active_state,
1776         .sub_state_to_string = mount_sub_state_to_string,
1777
1778         .check_gc = mount_check_gc,
1779
1780         .sigchld_event = mount_sigchld_event,
1781         .timer_event = mount_timer_event,
1782
1783         .reset_failed = mount_reset_failed,
1784
1785         .bus_interface = "org.freedesktop.systemd1.Mount",
1786         .bus_message_handler = bus_mount_message_handler,
1787         .bus_invalidating_properties =  bus_mount_invalidating_properties,
1788
1789         .enumerate = mount_enumerate,
1790         .shutdown = mount_shutdown,
1791
1792         .status_message_formats = {
1793                 .starting_stopping = {
1794                         [0] = "Mounting %s...",
1795                         [1] = "Unmounting %s...",
1796                 },
1797                 .finished_start_job = {
1798                         [JOB_DONE]       = "Mounted %s.",
1799                         [JOB_FAILED]     = "Failed to mount %s.",
1800                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
1801                         [JOB_TIMEOUT]    = "Timed out mounting %s.",
1802                 },
1803                 .finished_stop_job = {
1804                         [JOB_DONE]       = "Unmounted %s.",
1805                         [JOB_FAILED]     = "Failed unmounting %s.",
1806                         [JOB_TIMEOUT]    = "Timed out unmounting %s.",
1807                 },
1808         },
1809 };