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