HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/machine/machine.c

56,395 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 9f77840f3967a18e0b110d08777f4b7f8a40b580

Lines 1001–1671 of 1,671

 
        container_bus = allocated_bus ?: m->manager->system_bus;
        r = bus_message_new_method_call(container_bus, &tm, bus_systemd_mgr, "StartTransientUnit");
        if (r < 0)
                return r;
 
        /* Name and mode */
        unit = strjoina("container-shell@", p, ".service");
        r = sd_bus_message_append(tm, "ss", unit, "fail");
        if (r < 0)
                return r;
 
        /* Properties */
        r = sd_bus_message_open_container(tm, 'a', "(sv)");
        if (r < 0)
                return r;
 
        description = strjoina("Shell for User ", user);
        r = sd_bus_message_append(tm,
                                  "(sv)(sv)(sv)(sv)(sv)(sv)(sv)(sv)(sv)(sv)(sv)(sv)(sv)",
                                  "Description", "s", description,
                                  "StandardInputFileDescriptor", "h", pty_fd,
                                  "StandardOutputFileDescriptor", "h", pty_fd,
                                  "StandardErrorFileDescriptor", "h", pty_fd,
                                  "SendSIGHUP", "b", true,
                                  "IgnoreSIGPIPE", "b", false,
                                  "KillMode", "s", "mixed",
                                  "TTYPath", "s", ptmx_name,
                                  "TTYReset", "b", true,
                                  "UtmpIdentifier", "s", utmp_id,
                                  "UtmpMode", "s", "user",
                                  "PAMName", "s", "login",
                                  "WorkingDirectory", "s", "-~");
        if (r < 0)
                return r;
 
        r = sd_bus_message_append(tm, "(sv)", "User", "s", user);
        if (r < 0)
                return r;
 
        if (!strv_isempty(env)) {
                r = sd_bus_message_open_container(tm, 'r', "sv");
                if (r < 0)
                        return r;
 
                r = sd_bus_message_append(tm, "s", "Environment");
                if (r < 0)
                        return r;
 
                r = sd_bus_message_open_container(tm, 'v', "as");
                if (r < 0)
                        return r;
 
                r = sd_bus_message_append_strv(tm, env);
                if (r < 0)
                        return r;
 
                r = sd_bus_message_close_container(tm);
                if (r < 0)
                        return r;
 
                r = sd_bus_message_close_container(tm);
                if (r < 0)
                        return r;
        }
 
        /* Exec container */
        r = sd_bus_message_open_container(tm, 'r', "sv");
        if (r < 0)
                return r;
 
        r = sd_bus_message_append(tm, "s", "ExecStart");
        if (r < 0)
                return r;
 
        r = sd_bus_message_open_container(tm, 'v', "a(sasb)");
        if (r < 0)
                return r;
 
        r = sd_bus_message_open_container(tm, 'a', "(sasb)");
        if (r < 0)
                return r;
 
        r = sd_bus_message_open_container(tm, 'r', "sasb");
        if (r < 0)
                return r;
 
        r = sd_bus_message_append(tm, "s", path);
        if (r < 0)
                return r;
 
        r = sd_bus_message_append_strv(tm, args);
        if (r < 0)
                return r;
 
        r = sd_bus_message_append(tm, "b", true);
        if (r < 0)
                return r;
 
        r = sd_bus_message_close_container(tm);
        if (r < 0)
                return r;
 
        r = sd_bus_message_close_container(tm);
        if (r < 0)
                return r;
 
        r = sd_bus_message_close_container(tm);
        if (r < 0)
                return r;
 
        r = sd_bus_message_close_container(tm);
        if (r < 0)
                return r;
 
        r = sd_bus_message_close_container(tm);
        if (r < 0)
                return r;
 
        /* Auxiliary units */
        r = sd_bus_message_append(tm, "a(sa(sv))", 0);
        if (r < 0)
                return r;
 
        r = sd_bus_call(container_bus, tm, 0, error, NULL);
        if (r < 0)
                return r;
 
        return 0;
}
 
char** machine_default_shell_args(const char *user) {
        _cleanup_strv_free_ char **args = NULL;
 
        assert(user);
 
        args = new0(char*, 5 + 1);
        if (!args)
                return NULL;
 
        args[0] = strdup("sh");
        if (!args[0])
                return NULL;
 
        args[1] = strdup("-c");
        if (!args[1])
                return NULL;
 
        args[2] = strdup(
                     "shell=$(getent passwd \"$1\" 2>/dev/null | { IFS=: read _ _ _ _ _ _ x; echo \"$x\"; })\n"
                     "exec \"${shell:-/bin/sh}\" -l"); /* -l means --login */
        if (!args[2])
                return NULL;
 
        args[3] = strdup("sh"); /* $0 placeholder for sh -c */
        if (!args[3])
                return NULL;
 
        args[4] = strdup(user); /* becomes $1 in the script */
        if (!args[4])
                return NULL;
 
        return TAKE_PTR(args);
}
 
int machine_copy_from_to_operation(
                Manager *manager,
                Machine *machine,
                const char *host_path,
                const char *container_path,
                bool copy_from_container,
                CopyFlags copy_flags,
                Operation **ret) {
 
        _cleanup_close_ int host_fd = -EBADF, target_mntns_fd = -EBADF, source_mntns_fd = -EBADF;
        _cleanup_(pidref_done_sigkill_wait) PidRef child = PIDREF_NULL;
        _cleanup_close_pair_ int errno_pipe_fd[2] = EBADF_PAIR;
        _cleanup_free_ char *host_basename = NULL, *container_basename = NULL;
        uid_t uid_shift;
        int r;
 
        assert(manager);
        assert(machine);
        assert(ret);
 
        if (isempty(host_path) || isempty(container_path))
                return -EINVAL;
 
        r = path_extract_filename(host_path, &host_basename);
        if (r < 0)
                return log_debug_errno(r, "Failed to extract file name of '%s' path: %m", host_path);
 
        r = path_extract_filename(container_path, &container_basename);
        if (r < 0)
                return log_debug_errno(r, "Failed to extract file name of '%s' path: %m", container_path);
 
        host_fd = open_parent(host_path, O_CLOEXEC, 0);
        if (host_fd < 0)
                return log_debug_errno(host_fd, "Failed to open host directory '%s': %m", host_path);
 
        r = machine_get_uid_shift(machine, &uid_shift);
        if (r < 0)
                return log_debug_errno(r, "Failed to get UID shift of machine '%s': %m", machine->name);
 
        target_mntns_fd = pidref_namespace_open_by_type(&machine->leader, NAMESPACE_MOUNT);
        if (target_mntns_fd < 0)
                return log_debug_errno(target_mntns_fd, "Failed to open mount namespace of machine '%s': %m", machine->name);
 
        source_mntns_fd = namespace_open_by_type(NAMESPACE_MOUNT);
        if (source_mntns_fd < 0)
                return log_debug_errno(source_mntns_fd, "Failed to open our own mount namespace: %m");
 
        if (pipe2(errno_pipe_fd, O_CLOEXEC|O_NONBLOCK) < 0)
                return log_debug_errno(errno, "Failed to create pipe: %m");
 
        r = namespace_fork("(sd-copyns)",
                           "(sd-copy)",
                           FORK_RESET_SIGNALS|FORK_DEATHSIG_SIGKILL,
                           /* pidns_fd= */ -EBADF,
                           target_mntns_fd,
                           /* netns_fd= */ -EBADF,
                           /* userns_fd= */ -EBADF,
                           /* root_fd= */ -EBADF,
                           &child);
        if (r < 0)
                return log_debug_errno(r, "Failed to fork into mount namespace of machine '%s': %m", machine->name);
        if (r == 0) {
                errno_pipe_fd[0] = safe_close(errno_pipe_fd[0]);
 
                _cleanup_close_ int container_fd = -EBADF;
                container_fd = open_parent(container_path, O_CLOEXEC, 0);
                if (container_fd < 0) {
                        log_debug_errno(container_fd, "Failed to open container directory: %m");
                        report_errno_and_exit(errno_pipe_fd[1], container_fd);
                }
 
                /* Rejoin the host namespace, so that /proc/self/fd/… works, which copy_tree_at() relies on
                 * in some cases (by means of fd_reopen()) */
                if (setns(source_mntns_fd, CLONE_NEWNS) < 0) {
                        r = log_debug_errno(errno, "Failed to rejoin namespace of host: %m");
                        report_errno_and_exit(errno_pipe_fd[1], r);
                }
 
                /* Run the actual copy operation. Note that when a UID shift is set we'll either clamp the UID/GID to
                 * 0 or to the actual UID shift depending on the direction we copy. If no UID shift is set we'll copy
                 * the UID/GIDs as they are. */
                if (copy_from_container)
                        r = copy_tree_at(
                                        container_fd,
                                        container_basename,
                                        host_fd,
                                        host_basename,
                                        uid_shift == 0 ? UID_INVALID : 0,
                                        uid_shift == 0 ? GID_INVALID : 0,
                                        copy_flags,
                                        /* denylist= */ NULL,
                                        /* subvolumes= */ NULL);
                else
                        r = copy_tree_at(
                                        host_fd,
                                        host_basename,
                                        container_fd,
                                        container_basename,
                                        uid_shift == 0 ? UID_INVALID : uid_shift,
                                        uid_shift == 0 ? GID_INVALID : uid_shift,
                                        copy_flags,
                                        /* denylist= */ NULL,
                                        /* subvolumes= */ NULL);
                if (r < 0)
                        log_debug_errno(r, "Failed to copy tree: %m");
 
                report_errno_and_exit(errno_pipe_fd[1], r);
        }
 
        errno_pipe_fd[1] = safe_close(errno_pipe_fd[1]);
 
        Operation *operation;
        r = operation_new(manager, machine, &child, errno_pipe_fd[0], &operation);
        if (r < 0)
                return r;
 
        TAKE_FD(errno_pipe_fd[0]);
        TAKE_PIDREF(child);
 
        *ret = operation;
        return 0;
}
 
void machine_release_unit(Machine *m) {
        assert(m);
 
        if (!m->unit)
                return;
 
        assert(m->manager);
 
        if (m->referenced) {
                _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
                int r;
 
                r = manager_unref_unit(m->manager, m->unit, &error);
                if (r < 0)
                        log_full_errno(ERRNO_IS_DISCONNECT(r) ? LOG_DEBUG : LOG_WARNING, r,
                                       "Failed to drop reference to machine scope, ignoring: %s",
                                       bus_error_message(&error, r));
 
                m->referenced = false;
        }
 
        if (!m->subgroup)
                (void) hashmap_remove_value(m->manager->machines_by_unit, m->unit, m);
 
        m->unit = mfree(m->unit);
 
        /* Also free the subgroup, because it only makes sense in the context of the unit */
        m->subgroup = mfree(m->subgroup);
}
 
int machine_get_uid_shift(Machine *m, uid_t *ret) {
        char p[STRLEN("/proc//uid_map") + DECIMAL_STR_MAX(pid_t) + 1];
        uid_t uid_base, uid_shift, uid_range;
        gid_t gid_base, gid_shift, gid_range;
        _cleanup_fclose_ FILE *f = NULL;
        int r;
 
        assert(m);
        assert(ret);
 
        /* Return the base UID/GID of the specified machine. Note that this only works for containers with simple
         * mappings. In most cases setups should be simple like this, and administrators should only care about the
         * basic offset a container has relative to the host. This is what this function exposes.
         *
         * If we encounter any more complex mappings we politely refuse this with ENXIO. */
 
        if (m->class == MACHINE_HOST) {
                *ret = 0;
                return 0;
        }
 
        if (m->class != MACHINE_CONTAINER)
                return -EOPNOTSUPP;
 
        xsprintf(p, "/proc/" PID_FMT "/uid_map", m->leader.pid);
        f = fopen(p, "re");
        if (!f) {
                if (errno == ENOENT) {
                        /* If the file doesn't exist, user namespacing is off in the kernel, return a zero mapping hence. */
                        *ret = 0;
                        return 0;
                }
 
                return -errno;
        }
 
        /* Read the first line. There's at least one. */
        r = uid_map_read_one(f, &uid_base, &uid_shift, &uid_range);
        if (r < 0)
                return r;
 
        /* Not a mapping starting at 0? Then it's a complex mapping we can't expose here. */
        if (uid_base != 0)
                return -ENXIO;
        /* Insist that at least the nobody user is mapped, everything else is weird, and hence complex, and we don't support it */
        if (uid_range < UID_NOBODY)
                return -ENXIO;
 
        /* If there's more than one line, then we don't support this mapping. */
        r = safe_fgetc(f, NULL);
        if (r < 0)
                return r;
        if (r != 0) /* Insist on EOF */
                return -ENXIO;
 
        fclose(f);
 
        xsprintf(p, "/proc/" PID_FMT "/gid_map", m->leader.pid);
        f = fopen(p, "re");
        if (!f)
                return -errno;
 
        /* Read the first line. There's at least one. */
        errno = 0;
        r = fscanf(f, GID_FMT " " GID_FMT " " GID_FMT "\n", &gid_base, &gid_shift, &gid_range);
        if (r == EOF)
                return errno_or_else(ENOMSG);
        assert(r >= 0);
        if (r != 3)
                return -EBADMSG;
 
        /* If there's more than one line, then we don't support this file. */
        r = safe_fgetc(f, NULL);
        if (r < 0)
                return r;
        if (r != 0) /* Insist on EOF */
                return -ENXIO;
 
        /* If the UID and GID mapping doesn't match, we don't support this mapping. */
        if (uid_base != (uid_t) gid_base)
                return -ENXIO;
        if (uid_shift != (uid_t) gid_shift)
                return -ENXIO;
        if (uid_range != (uid_t) gid_range)
                return -ENXIO;
 
        r = pidref_verify(&m->leader);
        if (r < 0)
                return r;
 
        *ret = uid_shift;
        return 0;
}
 
static int machine_owns_uid_internal(
                Machine *machine,
                const char *map_file, /* "uid_map" or "gid_map" */
                uid_t uid,
                uid_t *ret_internal_uid) {
 
        _cleanup_fclose_ FILE *f = NULL;
        const char *p;
        int r;
 
        /* This is a generic implementation for both uids and gids, under the assumptions they have the same types and semantics. */
        assert_cc(sizeof(uid_t) == sizeof(gid_t));
 
        assert(machine);
 
        /* Checks if the specified host UID is owned by the machine, and returns the UID it maps to
         * internally in the machine */
 
        if (machine->class != MACHINE_CONTAINER)
                goto negative;
 
        p = procfs_file_alloca(machine->leader.pid, map_file);
        f = fopen(p, "re");
        if (!f) {
                log_debug_errno(errno, "Failed to open %s, ignoring.", p);
                goto negative;
        }
 
        for (;;) {
                uid_t uid_base, uid_shift, uid_range, converted;
 
                r = uid_map_read_one(f, &uid_base, &uid_shift, &uid_range);
                if (r == -ENOMSG)
                        break;
                if (r < 0)
                        return r;
 
                /* The private user namespace is disabled, ignoring. */
                if (uid_shift == 0)
                        continue;
 
                if (uid < uid_shift || uid >= uid_shift + uid_range)
                        continue;
 
                converted = (uid - uid_shift + uid_base);
                if (!uid_is_valid(converted))
                        return -EINVAL;
 
                r = pidref_verify(&machine->leader);
                if (r < 0)
                        return r;
 
                if (ret_internal_uid)
                        *ret_internal_uid = converted;
 
                return true;
        }
 
negative:
        if (ret_internal_uid)
                *ret_internal_uid = UID_INVALID;
 
        return false;
}
 
int machine_owns_uid(Machine *machine, uid_t uid, uid_t *ret_internal_uid) {
        return machine_owns_uid_internal(machine, "uid_map", uid, ret_internal_uid);
}
 
int machine_owns_gid(Machine *machine, gid_t gid, gid_t *ret_internal_gid) {
        return machine_owns_uid_internal(machine, "gid_map", (uid_t) gid, (uid_t*) ret_internal_gid);
}
 
static int machine_translate_uid_internal(
                Machine *machine,
                const char *map_file, /* "uid_map" or "gid_map" */
                uid_t uid,
                uid_t *ret_host_uid) {
 
        _cleanup_fclose_ FILE *f = NULL;
        const char *p;
        int r;
 
        /* This is a generic implementation for both uids and gids, under the assumptions they have the same types and semantics. */
        assert_cc(sizeof(uid_t) == sizeof(gid_t));
 
        assert(machine);
        assert(uid_is_valid(uid));
 
        if (machine->class != MACHINE_CONTAINER)
                return -ESRCH;
 
        /* Translates a machine UID into a host UID */
 
        p = procfs_file_alloca(machine->leader.pid, map_file);
        f = fopen(p, "re");
        if (!f)
                return -errno;
 
        for (;;) {
                uid_t uid_base, uid_shift, uid_range, converted;
 
                r = uid_map_read_one(f, &uid_base, &uid_shift, &uid_range);
                if (r == -ENOMSG)
                        break;
                if (r < 0)
                        return r;
 
                if (uid < uid_base || uid >= uid_base + uid_range)
                        continue;
 
                converted = uid - uid_base + uid_shift;
                if (!uid_is_valid(converted))
                        return -EINVAL;
 
                r = pidref_verify(&machine->leader);
                if (r < 0)
                        return r;
 
                if (ret_host_uid)
                        *ret_host_uid = converted;
 
                return 0;
        }
 
        return -ESRCH;
}
 
int machine_translate_uid(Machine *machine, gid_t uid, gid_t *ret_host_uid) {
        return machine_translate_uid_internal(machine, "uid_map", uid, ret_host_uid);
}
 
int machine_translate_gid(Machine *machine, gid_t gid, gid_t *ret_host_gid) {
        return machine_translate_uid_internal(machine, "gid_map", (uid_t) gid, (uid_t*) ret_host_gid);
}
 
int machine_open_root_directory(Machine *machine) {
        int r;
 
        assert(machine);
 
        switch (machine->class) {
        case MACHINE_HOST: {
                int fd = open("/", O_RDONLY|O_CLOEXEC|O_DIRECTORY);
                if (fd < 0)
                        return log_debug_errno(errno, "Failed to open host root directory: %m");
 
                return fd;
        }
 
        case MACHINE_CONTAINER: {
                _cleanup_close_ int mntns_fd = -EBADF, root_fd = -EBADF;
                _cleanup_(pidref_done) PidRef child = PIDREF_NULL;
                _cleanup_close_pair_ int errno_pipe_fd[2] = EBADF_PAIR, fd_pass_socket[2] = EBADF_PAIR;
 
                r = pidref_namespace_open(&machine->leader,
                                          /* ret_pidns_fd= */ NULL,
                                          &mntns_fd,
                                          /* ret_netns_fd= */ NULL,
                                          /* ret_userns_fd= */ NULL,
                                          &root_fd);
                if (r < 0)
                        return log_debug_errno(r, "Failed to open mount namespace of machine '%s': %m", machine->name);
 
                if (pipe2(errno_pipe_fd, O_CLOEXEC|O_NONBLOCK) < 0)
                        return log_debug_errno(errno, "Failed to open pipe: %m");
 
                if (socketpair(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0, fd_pass_socket) < 0)
                        return log_debug_errno(errno, "Failed to create socket pair: %m");
 
                r = namespace_fork(
                                "(sd-openrootns)",
                                "(sd-openroot)",
                                FORK_RESET_SIGNALS|FORK_DEATHSIG_SIGKILL,
                                /* pidns_fd= */  -EBADF,
                                mntns_fd,
                                /* netns_fd= */  -EBADF,
                                /* userns_fd= */ -EBADF,
                                root_fd,
                                &child);
                if (r < 0)
                        return log_debug_errno(r, "Failed to fork into mount namespace of machine '%s': %m", machine->name);
                if (r == 0) {
                        _cleanup_close_ int dfd = -EBADF;
 
                        errno_pipe_fd[0] = safe_close(errno_pipe_fd[0]);
                        fd_pass_socket[0] = safe_close(fd_pass_socket[0]);
 
                        dfd = open("/", O_RDONLY|O_CLOEXEC|O_DIRECTORY);
                        if (dfd < 0) {
                                log_debug_errno(errno, "Failed to open root directory of machine '%s': %m", machine->name);
                                report_errno_and_exit(errno_pipe_fd[1], -errno);
                        }
 
                        r = send_one_fd(fd_pass_socket[1], dfd, /* flags= */ 0);
                        dfd = safe_close(dfd);
                        if (r < 0) {
                                log_debug_errno(r, "Failed to send FD over socket: %m");
                                report_errno_and_exit(errno_pipe_fd[1], r);
                        }
 
                        _exit(EXIT_SUCCESS);
                }
 
                errno_pipe_fd[1] = safe_close(errno_pipe_fd[1]);
                fd_pass_socket[1] = safe_close(fd_pass_socket[1]);
 
                r = pidref_wait_for_terminate_and_check("(sd-openrootns)", &child, /* flags= */ 0);
                if (r < 0)
                        return log_debug_errno(r, "Failed to wait for child: %m");
 
                r = read_errno(errno_pipe_fd[0]); /* the function does debug reporting */
                if (r < 0)
                        return r;
 
                int fd = receive_one_fd(fd_pass_socket[0], MSG_DONTWAIT);
                if (fd < 0)
                        return log_debug_errno(fd, "Failed to receive FD from child: %m");
 
                return fd;
        }
 
        default:
                return -EOPNOTSUPP;
        }
}
 
static const char* const machine_class_table[_MACHINE_CLASS_MAX] = {
        [MACHINE_CONTAINER] = "container",
        [MACHINE_VM]        = "vm",
        [MACHINE_HOST]      = "host",
};
 
DEFINE_STRING_TABLE_LOOKUP(machine_class, MachineClass);
 
static const char* const machine_state_table[_MACHINE_STATE_MAX] = {
        [MACHINE_OPENING] = "opening",
        [MACHINE_RUNNING] = "running",
        [MACHINE_CLOSING] = "closing"
};
 
DEFINE_STRING_TABLE_LOOKUP(machine_state, MachineState);
 
static const char* const kill_whom_table[_KILL_WHOM_MAX] = {
        [KILL_LEADER]     = "leader",
        [KILL_SUPERVISOR] = "supervisor",
        [KILL_ALL]        = "all",
};
 
DEFINE_STRING_TABLE_LOOKUP(kill_whom, KillWhom);
 
static const char* const acquire_metadata_table[_ACQUIRE_METADATA_MAX] = {
        [ACQUIRE_METADATA_NO]       = "no",
        [ACQUIRE_METADATA_YES]      = "yes",
        [ACQUIRE_METADATA_GRACEFUL] = "graceful"
};
 
DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(acquire_metadata, AcquireMetadata, ACQUIRE_METADATA_YES);