HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/shared/discover-image.c

95,819 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: da1f55c7ddd81787d9a22d44703d5ef5a7c4cf54

Lines 2001–2569 of 2,569

                return 0;
        }
 
        /* Prohibit taking exclusive locks on the host image. We can't allow this, since we ourselves are
         * running off it after all, and we don't want any images to manipulate the host image. We make an
         * exception for shared locks however: we allow those (and make them NOPs since there's no point in
         * taking them if there can't be exclusive locks). Strictly speaking these are questionable as well,
         * since it means changes made to the host might propagate to the container as they happen (and a
         * shared lock kinda suggests that no changes happen at all while it is in place), but it's too
         * useful not to allow read-only containers off the host root, hence let's support this, and trust
         * the user to do the right thing with this. */
        if (path_equal(path, "/")) {
                if (exclusive)
                        return -EBUSY;
 
                *ret_local = LOCK_FILE_INIT;
                if (ret_global)
                        *ret_global = LOCK_FILE_INIT;
                return 0;
        }
 
        if (ret_global) {
                if (stat(path, &st) < 0)
                        log_debug_errno(errno, "Failed to stat() image '%s', not locking image: %m", path);
                else {
                        r = runtime_directory_generic(scope, "systemd/nspawn/locks/", &p);
                        if (r < 0)
                                return r;
 
                        if (S_ISBLK(st.st_mode))
                                r = strextendf(&p, "block-" DEVNUM_FORMAT_STR, DEVNUM_FORMAT_VAL(st.st_rdev));
                        else if (S_ISDIR(st.st_mode) || S_ISREG(st.st_mode))
                                r = strextendf(&p, "inode-%" PRIu64 ":%" PRIu64, (uint64_t) st.st_dev, (uint64_t) st.st_ino);
                        else
                                return -ENOTTY;
                        if (r < 0)
                                return r;
                }
        }
 
        /* For block devices we don't need the "local" lock, as the major/minor lock above should be
         * sufficient, since block devices are host local anyway. */
        if (!path_startswith(path, "/dev/")) {
                r = make_lock_file_for(path, operation, &t);
                if (r < 0) {
                        if (exclusive || r != -EROFS)
                                return r;
 
                        log_debug_errno(r, "Failed to create shared lock for '%s', ignoring: %m", path);
                }
        }
 
        if (p) {
                (void) make_lock_dir(scope);
 
                r = make_lock_file(p, operation, ret_global);
                if (r < 0) {
                        release_lock_file(&t);
                        return r;
                }
        } else if (ret_global)
                *ret_global = LOCK_FILE_INIT;
 
        *ret_local = t;
        return 0;
}
 
int image_set_limit(Image *i, uint64_t referenced_max) {
        int r;
 
        assert(i);
 
        if (image_is_vendor(i) || image_is_host(i))
                return -EROFS;
 
        if (i->type != IMAGE_SUBVOLUME)
                return -EOPNOTSUPP;
 
        /* We set the quota both for the subvolume as well as for the
         * subtree. The latter is mostly for historical reasons, since
         * we didn't use to have a concept of subtree quota, and hence
         * only modified the subvolume quota. */
 
        (void) btrfs_qgroup_set_limit(i->path, 0, referenced_max);
        (void) btrfs_subvol_auto_qgroup(i->path, 0, true);
        r = btrfs_subvol_set_subtree_quota_limit(i->path, 0, referenced_max);
        if (r < 0)
                return r;
 
        (void) image_update_quota(i, -EBADF);
        return 0;
}
 
int image_set_pool_limit(RuntimeScope scope, ImageClass class, uint64_t referenced_max) {
        int r;
 
        assert(scope >= 0 && scope < _RUNTIME_SCOPE_MAX);
        assert(class >= 0 && class < _IMAGE_CLASS_MAX);
 
        _cleanup_free_ char *pool = NULL;
        r = get_pool_directory(scope, class, /* fname= */ NULL, /* suffix= */ NULL, &pool);
        if (r < 0)
                return r;
 
        r = btrfs_qgroup_set_limit(pool, /* qgroupid= */ 0, referenced_max);
        if (ERRNO_IS_NEG_NOT_SUPPORTED(r))
                return r;
        if (r < 0)
                log_debug_errno(r, "Failed to set limit on btrfs quota group for '%s', ignoring: %m", pool);
 
        r = btrfs_subvol_set_subtree_quota_limit(pool, /* subvol_id= */ 0, referenced_max);
        if (ERRNO_IS_NEG_NOT_SUPPORTED(r))
                return r;
        if (r < 0)
                return log_debug_errno(r, "Failed to set subtree quota limit for '%s': %m", pool);
 
        return 0;
}
 
int image_get_pool_path(RuntimeScope scope, ImageClass class, char **ret) {
        assert(scope >= 0 && scope < _RUNTIME_SCOPE_MAX);
        assert(class >= 0 && class < _IMAGE_CLASS_MAX);
        assert(ret);
 
        return get_pool_directory(scope, class, /* fname= */ NULL, /* suffix= */ NULL, ret);
}
 
int image_get_pool_usage(RuntimeScope scope, ImageClass class, uint64_t *ret) {
        int r;
 
        assert(scope >= 0 && scope < _RUNTIME_SCOPE_MAX);
        assert(class >= 0 && class < _IMAGE_CLASS_MAX);
        assert(ret);
 
        _cleanup_free_ char *pool = NULL;
        r = get_pool_directory(scope, class, /* fname= */ NULL, /* suffix= */ NULL, &pool);
        if (r < 0)
                return r;
 
        _cleanup_close_ int fd = open(pool, O_RDONLY|O_CLOEXEC|O_DIRECTORY);
        if (fd < 0)
                return -errno;
 
        BtrfsQuotaInfo q;
        r = btrfs_subvol_get_subtree_quota_fd(fd, /* subvol_id= */ 0, &q);
        if (r < 0)
                return r;
 
        *ret = q.referenced;
        return 0;
}
 
int image_get_pool_limit(RuntimeScope scope, ImageClass class, uint64_t *ret) {
        int r;
 
        assert(scope >= 0 && scope < _RUNTIME_SCOPE_MAX);
        assert(class >= 0 && class < _IMAGE_CLASS_MAX);
        assert(ret);
 
        _cleanup_free_ char *pool = NULL;
        r = get_pool_directory(scope, class, /* fname= */ NULL, /* suffix= */ NULL, &pool);
        if (r < 0)
                return r;
 
        _cleanup_close_ int fd = open(pool, O_RDONLY|O_CLOEXEC|O_DIRECTORY);
        if (fd < 0)
                return -errno;
 
        BtrfsQuotaInfo q;
        r = btrfs_subvol_get_subtree_quota_fd(fd, /* subvol_id= */ 0, &q);
        if (r < 0)
                return r;
 
        *ret = q.referenced_max;
        return 0;
}
 
static int check_btrfs(const char *path) {
        struct statfs sfs;
        int r;
 
        if (statfs(path, &sfs) < 0) {
                if (errno != ENOENT)
                        return -errno;
 
                _cleanup_free_ char *parent = NULL;
                r = path_extract_directory(path, &parent);
                if (r < 0)
                        return r;
 
                if (statfs(parent, &sfs) < 0)
                        return -errno;
        }
 
        return F_TYPE_EQUAL(sfs.f_type, BTRFS_SUPER_MAGIC);
}
 
int image_setup_pool(RuntimeScope scope, ImageClass class, bool use_btrfs_subvol, bool use_btrfs_quota) {
        int r;
 
        assert(class >= 0 && class < _IMAGE_CLASS_MAX);
 
        _cleanup_free_ char *pool = NULL;
        r = image_get_pool_path(scope, class, &pool);
        if (r < 0)
                return r;
 
        r = check_btrfs(pool);
        if (r <= 0)
                return r;
 
        if (!use_btrfs_subvol)
                return 0;
 
        (void) btrfs_subvol_make_label(pool, /* label_context= */ NULL);
 
        if (!use_btrfs_quota)
                return 0;
 
        r = btrfs_quota_enable(pool, /* b= */ true);
        if (r < 0)
                log_warning_errno(r, "Failed to enable quota for %s, ignoring: %m", pool);
 
        r = btrfs_subvol_auto_qgroup(pool, /* subvol_id= */ 0, /* create_intermediary_qgroup= */ true);
        if (r < 0)
                log_warning_errno(r, "Failed to set up default quota hierarchy for %s, ignoring: %m", pool);
 
        return 0;
}
 
int image_read_metadata(Image *i, const char *root, const ImagePolicy *image_policy, RuntimeScope scope) {
        _cleanup_(release_lock_file) LockFile global_lock = LOCK_FILE_INIT, local_lock = LOCK_FILE_INIT;
        int r;
 
        assert(i);
 
        r = image_path_lock(scope, i->path, LOCK_SH|LOCK_NB, &global_lock, &local_lock);
        if (r < 0)
                return r;
 
        switch (i->type) {
 
        case IMAGE_SUBVOLUME:
        case IMAGE_DIRECTORY: {
                _cleanup_strv_free_ char **machine_info = NULL, **os_release = NULL, **sysext_release = NULL, **confext_release = NULL;
                _cleanup_free_ char *hostname = NULL, *path = NULL;
                sd_id128_t machine_id = SD_ID128_NULL;
 
                if (i->class == IMAGE_SYSEXT) {
                        r = extension_has_forbidden_content(i->path);
                        if (r < 0)
                                return r;
                        if (r > 0)
                                return log_debug_errno(SYNTHETIC_ERRNO(ENOMEDIUM),
                                                       "Conflicting content found in image %s, refusing.",
                                                       i->name);
                }
 
                r = chase("/etc/hostname", i->path, CHASE_PREFIX_ROOT|CHASE_TRAIL_SLASH, &path, NULL);
                if (r < 0 && r != -ENOENT)
                        log_debug_errno(r, "Failed to chase /etc/hostname in image %s: %m", i->name);
                else if (r >= 0) {
                        r = read_etc_hostname(path, /* substitute_wildcards= */ false, &hostname);
                        if (r < 0)
                                log_debug_errno(r, "Failed to read /etc/hostname of image %s: %m", i->name);
                }
 
                path = mfree(path);
 
                r = id128_get_machine(i->path, &machine_id);
                if (r < 0)
                        log_debug_errno(r, "Failed to read machine ID in image %s, ignoring: %m", i->name);
 
                r = chase("/etc/machine-info", i->path, CHASE_PREFIX_ROOT|CHASE_TRAIL_SLASH, &path, NULL);
                if (r < 0 && r != -ENOENT)
                        log_debug_errno(r, "Failed to chase /etc/machine-info in image %s: %m", i->name);
                else if (r >= 0) {
                        r = load_env_file_pairs(NULL, path, &machine_info);
                        if (r < 0)
                                log_debug_errno(r, "Failed to parse machine-info data of %s: %m", i->name);
                }
 
                r = load_os_release_pairs(i->path, &os_release);
                if (r < 0)
                        log_debug_errno(r, "Failed to read os-release in image, ignoring: %m");
 
                r = load_extension_release_pairs(i->path, IMAGE_SYSEXT, i->name, /* relax_extension_release_check= */ false, &sysext_release);
                if (r < 0)
                        log_debug_errno(r, "Failed to read sysext-release in image, ignoring: %m");
 
                r = load_extension_release_pairs(i->path, IMAGE_CONFEXT, i->name, /* relax_extension_release_check= */ false, &confext_release);
                if (r < 0)
                        log_debug_errno(r, "Failed to read confext-release in image, ignoring: %m");
 
                free_and_replace(i->hostname, hostname);
                i->machine_id = machine_id;
                strv_free_and_replace(i->machine_info, machine_info);
                strv_free_and_replace(i->os_release, os_release);
                strv_free_and_replace(i->sysext_release, sysext_release);
                strv_free_and_replace(i->confext_release, confext_release);
                break;
        }
 
        case IMAGE_RAW:
        case IMAGE_BLOCK: {
                _cleanup_(verity_settings_done) VeritySettings verity = VERITY_SETTINGS_DEFAULT;
                _cleanup_(loop_device_unrefp) LoopDevice *d = NULL;
                _cleanup_(dissected_image_unrefp) DissectedImage *m = NULL;
                DissectImageFlags flags =
                        DISSECT_IMAGE_GENERIC_ROOT |
                        DISSECT_IMAGE_REQUIRE_ROOT |
                        DISSECT_IMAGE_RELAX_VAR_CHECK |
                        DISSECT_IMAGE_READ_ONLY |
                        DISSECT_IMAGE_USR_NO_ROOT |
                        DISSECT_IMAGE_ADD_PARTITION_DEVICES |
                        DISSECT_IMAGE_PIN_PARTITION_DEVICES |
                        DISSECT_IMAGE_VALIDATE_OS |
                        DISSECT_IMAGE_VALIDATE_OS_EXT |
                        DISSECT_IMAGE_ALLOW_USERSPACE_VERITY;
 
                r = loop_device_make_by_path(
                                i->path,
                                O_RDONLY,
                                /* sector_size= */ UINT32_MAX,
                                LO_FLAGS_PARTSCAN,
                                LOCK_SH,
                                &d);
                if (r < 0)
                        return log_debug_errno(r, "Failed to create loopback device of '%s': %m", i->path);
 
                r = dissect_loop_device(
                                d,
                                &verity,
                                /* mount_options= */ NULL,
                                image_policy,
                                /* image_filter= */ NULL,
                                flags,
                                &m);
                if (r < 0)
                        return log_debug_errno(r, "Failed to dissect image '%s': %m", i->path);
 
                r = dissected_image_load_verity_sig_partition(
                                m,
                                d->fd,
                                &verity);
                if (r < 0)
                        return log_debug_errno(r, "Failed to load Verity signature partition of '%s': %m", i->path);
 
                r = dissected_image_guess_verity_roothash(
                                m,
                                &verity);
                if (r < 0)
                        return log_debug_errno(r, "Failed to guess Verity root hash of '%s': %m", i->path);
 
                r = dissected_image_decrypt(
                                m,
                                root,
                                /* passphrase= */ NULL,
                                &verity,
                                image_policy,
                                flags);
                if (r < 0)
                        return log_debug_errno(r, "Failed to decrypt image '%s': %m", i->path);
 
                /* Do not use the image name derived from the backing file of the loop device */
                r = free_and_strdup(&m->image_name, i->name);
                if (r < 0)
                        return r;
 
                r = dissected_image_acquire_metadata(
                                m,
                                /* userns_fd= */ -EBADF,
                                flags);
                if (r < 0)
                        return log_debug_errno(r, "Failed to acquire metadata from image '%s': %m", i->path);
 
                free_and_replace(i->hostname, m->hostname);
                i->machine_id = m->machine_id;
                strv_free_and_replace(i->machine_info, m->machine_info);
                strv_free_and_replace(i->os_release, m->os_release);
                strv_free_and_replace(i->sysext_release, m->sysext_release);
                strv_free_and_replace(i->confext_release, m->confext_release);
                break;
        }
 
        default:
                return -EOPNOTSUPP;
        }
 
        i->metadata_valid = true;
 
        return 0;
}
 
int image_name_lock(
                RuntimeScope scope,
                const char *name,
                int operation,
                LockFile *ret) {
 
        int r;
 
        assert(name);
        assert(ret);
 
        /* Locks an image name, regardless of the precise path used. */
 
        if (streq(name, ".host"))
                return -EBUSY;
 
        if (!image_name_is_valid(name))
                return -EINVAL;
 
        if (getenv_bool("SYSTEMD_NSPAWN_LOCK") == 0) {
                *ret = (LockFile) LOCK_FILE_INIT;
                return 0;
        }
 
        (void) make_lock_dir(scope);
 
        _cleanup_free_ char *p = NULL;
        r = runtime_directory_generic(scope, "systemd/nspawn/locks/name-", &p);
        if (r < 0)
                return r;
 
        if (!strextend(&p, name))
                return -ENOMEM;
 
        return make_lock_file(p, operation, ret);
}
 
bool image_in_search_path(
                RuntimeScope scope,
                ImageClass class,
                const char *root,
                const char *image) {
 
        int r;
 
        assert(scope < _RUNTIME_SCOPE_MAX && scope != RUNTIME_SCOPE_GLOBAL);
        assert(class >= 0);
        assert(class < _IMAGE_CLASS_MAX);
        assert(image);
 
        _cleanup_strv_free_ char **search = NULL;
        r = pick_image_search_path(scope, class, root, &search);
        if (r < 0)
                return r;
 
        STRV_FOREACH(path, search) {
                const char *p, *q;
                size_t k;
 
                if (!empty_or_root(root)) {
                        q = path_startswith(*path, root);
                        if (!q)
                                continue;
                } else
                        q = *path;
 
                p = path_startswith(q, *path);
                if (!p)
                        continue;
 
                /* Make sure there's a filename following */
                k = strcspn(p, "/");
                if (k == 0)
                        continue;
 
                p += k;
 
                /* Accept trailing slashes */
                if (p[strspn(p, "/")] == 0)
                        return true;
        }
 
        return false;
}
 
bool image_is_vendor(const struct Image *i) {
        assert(i);
 
        return i->path && path_startswith(i->path, "/usr");
}
 
bool image_is_host(const struct Image *i) {
        assert(i);
 
        if (i->name && streq(i->name, ".host"))
                return true;
 
        if (i->path && path_equal(i->path, "/"))
                return true;
 
        return false;
}
 
int image_to_json(const struct Image *img, sd_json_variant **ret) {
        assert(img);
 
        return sd_json_buildo(
                        ret,
                        SD_JSON_BUILD_PAIR_STRING("Type", image_type_to_string(img->type)),
                        SD_JSON_BUILD_PAIR_STRING("Class", image_class_to_string(img->class)),
                        SD_JSON_BUILD_PAIR_STRING("Name", img->name),
                        SD_JSON_BUILD_PAIR_CONDITION(!!img->path, "Path", SD_JSON_BUILD_STRING(img->path)),
                        SD_JSON_BUILD_PAIR_BOOLEAN("ReadOnly", image_is_read_only(img)),
                        SD_JSON_BUILD_PAIR_CONDITION(img->crtime != 0, "CreationTimestamp", SD_JSON_BUILD_UNSIGNED(img->crtime)),
                        SD_JSON_BUILD_PAIR_CONDITION(img->mtime != 0, "ModificationTimestamp", SD_JSON_BUILD_UNSIGNED(img->mtime)),
                        SD_JSON_BUILD_PAIR_CONDITION(img->usage != UINT64_MAX, "Usage", SD_JSON_BUILD_UNSIGNED(img->usage)),
                        SD_JSON_BUILD_PAIR_CONDITION(img->usage_exclusive != UINT64_MAX, "UsageExclusive", SD_JSON_BUILD_UNSIGNED(img->usage_exclusive)),
                        SD_JSON_BUILD_PAIR_CONDITION(img->limit != UINT64_MAX, "Limit", SD_JSON_BUILD_UNSIGNED(img->limit)),
                        SD_JSON_BUILD_PAIR_CONDITION(img->limit_exclusive != UINT64_MAX, "LimitExclusive", SD_JSON_BUILD_UNSIGNED(img->limit_exclusive)));
}
 
static const char* const image_type_table[_IMAGE_TYPE_MAX] = {
        [IMAGE_DIRECTORY] = "directory",
        [IMAGE_SUBVOLUME] = "subvolume",
        [IMAGE_RAW]       = "raw",
        [IMAGE_BLOCK]     = "block",
        [IMAGE_MSTACK]    = "mstack",
};
 
DEFINE_STRING_TABLE_LOOKUP(image_type, ImageType);
 
int image_root_pick(
                RuntimeScope scope,
                ImageClass c,
                bool runtime,
                char **ret) {
 
        int r;
 
        assert(scope >= 0);
        assert(scope < _RUNTIME_SCOPE_MAX);
        assert(c >= 0);
        assert(c < _IMAGE_CLASS_MAX);
        assert(ret);
 
        /* Picks the primary target directory for downloads, depending on invocation contexts */
 
        _cleanup_free_ char *s = NULL;
        switch (scope) {
 
        case RUNTIME_SCOPE_SYSTEM: {
                s = strdup(runtime ? image_root_runtime_to_string(c) : image_root_to_string(c));
                if (!s)
                        return -ENOMEM;
 
                break;
        }
 
        case RUNTIME_SCOPE_USER:
                r = sd_path_lookup(runtime ? SD_PATH_USER_RUNTIME : SD_PATH_USER_STATE_PRIVATE, "machines", &s);
                if (r < 0)
                        return r;
 
                break;
 
        default:
                return -EOPNOTSUPP;
        }
 
        *ret = TAKE_PTR(s);
        return 0;
}
 
BUS_DEFINE_PROPERTY_GET(bus_property_get_image_is_read_only, "b", Image, (int) image_is_read_only);