+ "%sWhere: %s\n"
+ "%sWhat: %s\n"
+ "%sFile System Type: %s\n"
+ "%sOptions: %s\n"
+ "%sFrom /etc/fstab: %s\n"
+ "%sFrom /proc/self/mountinfo: %s\n"
+ "%sFrom fragment: %s\n"
+ "%sKillMode: %s\n",
+ prefix, state_string_table[m->state],
+ prefix, m->where,
+ prefix, strna(p->what),
+ prefix, strna(p->fstype),
+ prefix, strna(p->options),
+ prefix, yes_no(m->from_etc_fstab),
+ prefix, yes_no(m->from_proc_self_mountinfo),
+ prefix, yes_no(m->from_fragment),
+ prefix, kill_mode_to_string(m->kill_mode));
+
+ if (m->control_pid > 0)
+ fprintf(f,
+ "%sControl PID: %llu\n",
+ prefix, (unsigned long long) m->control_pid);
+
+ exec_context_dump(&m->exec_context, f, prefix);
+}
+
+static void mount_enter_dead(Mount *m, bool success) {
+ assert(m);
+
+ if (!success)
+ m->failure = true;
+
+ mount_set_state(m, m->failure ? MOUNT_MAINTAINANCE : MOUNT_DEAD);
+}
+
+static void mount_enter_signal(Mount *m, MountState state, bool success) {
+ int r;
+
+ assert(m);
+
+ if (!success)
+ m->failure = true;
+
+ if (m->control_pid > 0) {
+ int sig;
+ bool sent = false;
+
+ sig = (state == MOUNT_MOUNTING_SIGTERM ||
+ state == MOUNT_UNMOUNTING_SIGTERM ||
+ state == MOUNT_REMOUNTING_SIGTERM) ? SIGTERM : SIGKILL;
+
+ if (m->kill_mode == KILL_CONTROL_GROUP) {
+
+ if ((r = cgroup_bonding_kill_list(UNIT(m)->meta.cgroup_bondings, sig)) < 0) {
+ if (r != -EAGAIN && r != -ESRCH)
+ goto fail;
+ } else
+ sent = true;
+ }
+
+ if (!sent)
+ if (kill(m->kill_mode == KILL_PROCESS ? m->control_pid : -m->control_pid, sig) < 0 && errno != ESRCH) {
+ r = -errno;
+ goto fail;
+ }
+ }
+
+ mount_set_state(m, state);
+
+ if (m->control_pid <= 0)
+ mount_enter_dead(m, true);
+
+ return;
+
+fail:
+ log_warning("%s failed to kill processes: %s", unit_id(UNIT(m)), strerror(-r));
+ mount_enter_dead(m, false);
+}
+
+static void mount_enter_mounted(Mount *m, bool success) {
+ assert(m);
+
+ if (!success)
+ m->failure = true;
+
+ mount_set_state(m, MOUNT_MOUNTED);
+}
+
+static void mount_enter_unmounting(Mount *m, bool success) {
+ ExecCommand *c;
+ int r;
+
+ assert(m);
+
+ if (!success)
+ m->failure = true;
+
+ m->control_command = c = m->exec_command + MOUNT_EXEC_UNMOUNT;
+
+ if ((r = exec_command_set(
+ c,
+ "/bin/umount",
+ m->where,
+ NULL)) < 0)
+ goto fail;
+
+ service_unwatch_control_pid(m);
+
+ if ((r = mount_spawn(m, c, &m->control_pid)) < 0)
+ goto fail;
+
+ mount_set_state(m, MOUNT_UNMOUNTING);
+
+ return;
+
+fail:
+ log_warning("%s failed to run umount exectuable: %s", unit_id(UNIT(m)), strerror(-r));
+ mount_enter_mounted(m, false);
+}
+
+static void mount_enter_mounting(Mount *m, bool success) {
+ ExecCommand *c;
+ int r;
+
+ assert(m);
+
+ if (!success)
+ m->failure = true;
+
+ m->control_command = c = m->exec_command + MOUNT_EXEC_MOUNT;
+
+ if (m->from_fragment)
+ r = exec_command_set(
+ c,
+ "/bin/mount",
+ m->parameters_fragment.what,
+ m->where,
+ "-t", m->parameters_fragment.fstype,
+ "-o", m->parameters_fragment.options,
+ NULL);
+ else if (m->from_etc_fstab)
+ r = exec_command_set(
+ c,
+ "/bin/mount",
+ m->where,
+ NULL);
+ else
+ r = -ENOENT;
+
+ if (r < 0)
+ goto fail;
+
+ service_unwatch_control_pid(m);
+
+ if ((r = mount_spawn(m, c, &m->control_pid)) < 0)
+ goto fail;
+
+ mount_set_state(m, MOUNT_MOUNTING);
+
+ return;
+
+fail:
+ log_warning("%s failed to run mount exectuable: %s", unit_id(UNIT(m)), strerror(-r));
+ mount_enter_dead(m, false);
+}
+
+static void mount_enter_mounting_done(Mount *m, bool success) {
+ assert(m);
+
+ if (!success)
+ m->failure = true;
+
+ mount_set_state(m, MOUNT_MOUNTING_DONE);
+}
+
+static void mount_enter_remounting(Mount *m, bool success) {
+ ExecCommand *c;
+ int r;
+
+ assert(m);
+
+ if (!success)
+ m->failure = true;
+
+ m->control_command = c = m->exec_command + MOUNT_EXEC_REMOUNT;
+
+ if (m->from_fragment) {
+ char *buf = NULL;
+ const char *o;
+
+ if (m->parameters_fragment.options) {
+ if (!(buf = strappend("remount,", m->parameters_fragment.options))) {
+ r = -ENOMEM;
+ goto fail;
+ }
+
+ o = buf;
+ } else
+ o = "remount";
+
+ r = exec_command_set(
+ c,
+ "/bin/mount",
+ m->parameters_fragment.what,
+ m->where,
+ "-t", m->parameters_fragment.fstype,
+ "-o", o,
+ NULL);
+
+ free(buf);
+ } else if (m->from_etc_fstab)
+ r = exec_command_set(
+ c,
+ "/bin/mount",
+ m->where,
+ "-o", "remount",
+ NULL);
+ else
+ r = -ENOENT;
+
+ if (r < 0) {
+ r = -ENOMEM;
+ goto fail;
+ }
+
+ service_unwatch_control_pid(m);
+
+ if ((r = mount_spawn(m, c, &m->control_pid)) < 0)
+ goto fail;
+
+ mount_set_state(m, MOUNT_REMOUNTING);
+
+ return;
+
+fail:
+ mount_enter_mounted(m, false);
+}
+
+static int mount_start(Unit *u) {
+ Mount *m = MOUNT(u);
+
+ assert(m);
+
+ /* We cannot fulfill this request right now, try again later
+ * please! */
+ if (m->state == MOUNT_UNMOUNTING ||
+ m->state == MOUNT_UNMOUNTING_SIGTERM ||
+ m->state == MOUNT_UNMOUNTING_SIGKILL)
+ return -EAGAIN;
+
+ /* Already on it! */
+ if (m->state == MOUNT_MOUNTING ||
+ m->state == MOUNT_MOUNTING_SIGTERM ||
+ m->state == MOUNT_MOUNTING_SIGKILL)
+ return 0;
+
+ assert(m->state == MOUNT_DEAD || m->state == MOUNT_MAINTAINANCE);
+
+ m->failure = false;
+
+ mount_enter_mounting(m, true);
+ return 0;
+}
+
+static int mount_stop(Unit *u) {
+ Mount *m = MOUNT(u);
+
+ assert(m);
+
+ /* Cann't do this right now. */
+ if (m->state == MOUNT_MOUNTING ||
+ m->state == MOUNT_MOUNTING_DONE ||
+ m->state == MOUNT_MOUNTING_SIGTERM ||
+ m->state == MOUNT_MOUNTING_SIGKILL ||
+ m->state == MOUNT_REMOUNTING ||
+ m->state == MOUNT_REMOUNTING_SIGTERM ||
+ m->state == MOUNT_REMOUNTING_SIGKILL)
+ return -EAGAIN;
+
+ /* Already on it */
+ if (m->state == MOUNT_UNMOUNTING ||
+ m->state == MOUNT_UNMOUNTING_SIGKILL ||
+ m->state == MOUNT_UNMOUNTING_SIGTERM)
+ return 0;
+
+ assert(m->state == MOUNT_MOUNTED);
+
+ mount_enter_unmounting(m, true);
+ return 0;
+}
+
+static int mount_reload(Unit *u) {
+ Mount *m = MOUNT(u);
+
+ assert(m);
+
+ if (m->state == MOUNT_MOUNTING_DONE)
+ return -EAGAIN;
+
+ assert(m->state == MOUNT_MOUNTED);
+
+ mount_enter_remounting(m, true);
+ return 0;
+}
+
+static UnitActiveState mount_active_state(Unit *u) {
+ assert(u);
+
+ return state_translation_table[MOUNT(u)->state];
+}
+
+static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
+ Mount *m = MOUNT(u);
+ bool success;
+
+ assert(m);
+ assert(pid >= 0);
+
+ success = code == CLD_EXITED && status == 0;
+ m->failure = m->failure || !success;
+
+ assert(m->control_pid == pid);
+ assert(m->control_command);
+
+ exec_status_fill(&m->control_command->exec_status, pid, code, status);
+ m->control_pid = 0;
+
+ log_debug("%s control process exited, code=%s status=%i", unit_id(u), sigchld_code_to_string(code), status);
+
+ /* Note that mount(8) returning and the kernel sending us a
+ * mount table change event might happen out-of-order. If an
+ * operation succeed we assume the kernel will follow soon too
+ * and already change into the resulting state. If it fails
+ * we check if the kernel still knows about the mount. and
+ * change state accordingly. */
+
+ switch (m->state) {
+
+ case MOUNT_MOUNTING:
+ case MOUNT_MOUNTING_DONE:
+ case MOUNT_MOUNTING_SIGKILL:
+ case MOUNT_MOUNTING_SIGTERM:
+ case MOUNT_REMOUNTING:
+ case MOUNT_REMOUNTING_SIGKILL:
+ case MOUNT_REMOUNTING_SIGTERM:
+
+ if (success && m->from_proc_self_mountinfo)
+ mount_enter_mounted(m, true);
+ else if (m->from_proc_self_mountinfo)
+ mount_enter_mounted(m, false);
+ else
+ mount_enter_dead(m, false);
+ break;
+
+ case MOUNT_UNMOUNTING:
+ case MOUNT_UNMOUNTING_SIGKILL:
+ case MOUNT_UNMOUNTING_SIGTERM:
+
+ if (success)
+ mount_enter_dead(m, true);
+ else if (m->from_proc_self_mountinfo)
+ mount_enter_mounted(m, false);
+ else
+ mount_enter_dead(m, false);
+ break;
+
+ default:
+ assert_not_reached("Uh, control process died at wrong time.");
+ }
+}
+
+static void mount_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
+ Mount *m = MOUNT(u);
+
+ assert(m);
+ assert(elapsed == 1);
+ assert(w == &m->timer_watch);
+
+ switch (m->state) {
+
+ case MOUNT_MOUNTING:
+ case MOUNT_MOUNTING_DONE:
+ log_warning("%s mounting timed out. Stopping.", unit_id(u));
+ mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, false);
+ break;
+
+ case MOUNT_REMOUNTING:
+ log_warning("%s remounting timed out. Stopping.", unit_id(u));
+ mount_enter_signal(m, MOUNT_REMOUNTING_SIGTERM, false);
+ break;
+
+ case MOUNT_UNMOUNTING:
+ log_warning("%s unmounting timed out. Stopping.", unit_id(u));
+ mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, false);
+ break;
+
+ case MOUNT_MOUNTING_SIGTERM:
+ log_warning("%s mounting timed out. Killing.", unit_id(u));
+ mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, false);
+ break;
+
+ case MOUNT_REMOUNTING_SIGTERM:
+ log_warning("%s remounting timed out. Killing.", unit_id(u));
+ mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, false);
+ break;
+
+ case MOUNT_UNMOUNTING_SIGTERM:
+ log_warning("%s unmounting timed out. Killing.", unit_id(u));
+ mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, false);
+ break;
+
+ case MOUNT_MOUNTING_SIGKILL:
+ case MOUNT_REMOUNTING_SIGKILL:
+ case MOUNT_UNMOUNTING_SIGKILL:
+ log_warning("%s mount process still around after SIGKILL. Ignoring.", unit_id(u));
+
+ if (m->from_proc_self_mountinfo)
+ mount_enter_mounted(m, false);
+ else
+ mount_enter_dead(m, false);
+ break;
+
+ default:
+ assert_not_reached("Timeout at wrong time.");
+ }
+}
+
+static int mount_add_one(
+ Manager *m,
+ const char *what,
+ const char *where,
+ const char *options,
+ const char *fstype,
+ bool from_proc_self_mountinfo,
+ bool set_flags) {
+ int r;
+ Unit *u;
+ bool delete;
+ char *e, *w = NULL, *o = NULL, *f = NULL;
+ MountParameters *mp;
+
+ assert(m);
+ assert(what);
+ assert(where);
+ assert(options);
+ assert(fstype);
+
+ assert(!set_flags || from_proc_self_mountinfo);
+
+ /* Ignore API mount points. They should never be referenced in
+ * dependencies ever. */
+ if (mount_point_is_api(where))
+ return 0;
+
+ /* probably some kind of swap, which we don't cover for now */
+ if (where[0] != '/')
+ return 0;
+
+ if (streq(where, "/"))
+ e = strdup("-.mount");
+ else
+ e = unit_name_escape_path(where+1, ".mount");
+
+ if (!e)
+ return -ENOMEM;
+
+ if (!(u = manager_get_unit(m, e))) {
+ delete = true;
+
+ if (!(u = unit_new(m))) {
+ free(e);
+ return -ENOMEM;
+ }
+
+ r = unit_add_name(u, e);
+ free(e);
+
+ if (r < 0)
+ goto fail;
+
+ if (!(MOUNT(u)->where = strdup(where))) {
+ r = -ENOMEM;
+ goto fail;
+ }
+
+ if ((r = unit_set_description(u, where)) < 0)
+ goto fail;
+
+ unit_add_to_load_queue(u);
+ } else {
+ delete = false;
+ free(e);
+ }
+
+ if (!(w = strdup(what)) ||
+ !(o = strdup(options)) ||
+ !(f = strdup(fstype))) {
+ r = -ENOMEM;
+ goto fail;
+ }
+
+ if (from_proc_self_mountinfo) {
+ mp = &MOUNT(u)->parameters_proc_self_mountinfo;
+
+ if (set_flags) {
+ MOUNT(u)->is_mounted = true;
+ MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
+ MOUNT(u)->just_changed = !streq_ptr(MOUNT(u)->parameters_proc_self_mountinfo.options, o);
+ }
+
+ MOUNT(u)->from_proc_self_mountinfo = true;
+
+ } else {
+ mp = &MOUNT(u)->parameters_etc_fstab;
+
+ MOUNT(u)->from_etc_fstab = true;
+ }
+
+ free(mp->what);
+ mp->what = w;
+
+ free(mp->options);
+ mp->options = o;
+
+ free(mp->fstype);
+ mp->fstype = f;
+
+ unit_add_to_dbus_queue(u);
+
+ return 0;
+
+fail:
+ free(w);
+ free(o);
+ free(f);
+
+ if (delete && u)
+ unit_free(u);
+
+ return 0;
+}
+
+static char *fstab_node_to_udev_node(char *p) {
+ char *dn, *t;
+ int r;
+
+ /* FIXME: to follow udev's logic 100% we need to leave valid
+ * UTF8 chars unescaped */
+
+ if (startswith(p, "LABEL=")) {
+
+ if (!(t = xescape(p+6, "/ ")))
+ return NULL;
+
+ r = asprintf(&dn, "/dev/disk/by-label/%s", t);
+ free(t);
+
+ if (r < 0)
+ return NULL;
+
+ return dn;
+ }
+
+ if (startswith(p, "UUID=")) {
+
+ if (!(t = xescape(p+5, "/ ")))
+ return NULL;
+
+ r = asprintf(&dn, "/dev/disk/by-uuid/%s", ascii_strlower(t));
+ free(t);
+
+ if (r < 0)
+ return NULL;
+
+ return dn;
+ }
+
+ return strdup(p);
+}
+
+static int mount_load_etc_fstab(Manager *m) {
+ FILE *f;
+ int r;
+ struct mntent* me;
+
+ assert(m);
+
+ errno = 0;
+ if (!(f = setmntent("/etc/fstab", "r")))
+ return -errno;
+
+ while ((me = getmntent(f))) {
+ char *where, *what;
+
+ if (!(what = fstab_node_to_udev_node(me->mnt_fsname))) {
+ r = -ENOMEM;
+ goto finish;
+ }
+
+ if (!(where = strdup(me->mnt_dir))) {
+ free(what);
+ r = -ENOMEM;
+ goto finish;
+ }
+
+ if (what[0] == '/')
+ path_kill_slashes(what);
+
+ if (where[0] == '/')
+ path_kill_slashes(where);
+
+ r = mount_add_one(m, what, where, me->mnt_opts, me->mnt_type, false, false);
+ free(what);
+ free(where);
+
+ if (r < 0)
+ goto finish;
+ }
+
+ r = 0;
+finish:
+
+ endmntent(f);
+ return r;
+}
+
+static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
+ int r;
+ char *device, *path, *options, *fstype, *d, *p;
+
+ assert(m);
+
+ rewind(m->proc_self_mountinfo);
+
+ for (;;) {
+ int k;
+
+ device = path = options = fstype = d = p = NULL;
+
+ if ((k = fscanf(m->proc_self_mountinfo,
+ "%*s " /* (1) mount id */
+ "%*s " /* (2) parent id */
+ "%*s " /* (3) major:minor */
+ "%*s " /* (4) root */
+ "%ms " /* (5) mount point */
+ "%ms" /* (6) mount options */
+ "%*[^-]" /* (7) optional fields */
+ "- " /* (8) seperator */
+ "%ms " /* (9) file system type */
+ "%ms" /* (10) mount source */
+ "%*[^\n]", /* some rubbish at the end */
+ &path,
+ &options,
+ &fstype,
+ &device)) != 4) {
+
+ if (k == EOF)
+ break;
+
+ r = -EBADMSG;
+ goto finish;
+ }
+
+ if (!(d = cunescape(device)) ||
+ !(p = cunescape(path))) {
+ r = -ENOMEM;
+ goto finish;
+ }
+
+ if ((r = mount_add_one(m, d, p, options, fstype, true, set_flags)) < 0)
+ goto finish;
+
+ free(device);
+ free(path);
+ free(options);
+ free(fstype);
+ free(d);
+ free(p);
+ }
+
+ r = 0;
+
+finish:
+ free(device);
+ free(path);
+ free(options);
+ free(fstype);
+ free(d);
+ free(p);
+
+ return r;
+}
+
+static void mount_shutdown(Manager *m) {
+ assert(m);
+
+ if (m->proc_self_mountinfo)
+ fclose(m->proc_self_mountinfo);
+}
+
+static int mount_enumerate(Manager *m) {
+ int r;
+ struct epoll_event ev;
+ assert(m);
+
+ if (!(m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "r")))
+ return -errno;
+
+ m->mount_watch.type = WATCH_MOUNT;
+ m->mount_watch.fd = fileno(m->proc_self_mountinfo);
+
+ zero(ev);
+ ev.events = EPOLLERR;
+ ev.data.ptr = &m->mount_watch;
+
+ if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->mount_watch.fd, &ev) < 0)
+ return -errno;
+
+ if ((r = mount_load_etc_fstab(m)) < 0)
+ goto fail;
+
+ if ((r = mount_load_proc_self_mountinfo(m, false)) < 0)
+ goto fail;
+
+ return 0;
+
+fail:
+ mount_shutdown(m);
+ return r;