HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/shared/btrfs-util.c

78,989 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: f03eab91fd4a4eab4a3201a372335ae0090364e8

Lines 2001–2215 of 2,215

        size_t min_index, max_index;
 
        assert(tree);
        assert(tree->chunks || tree->n_chunks == 0);
 
        if (tree->n_chunks == 0)
                return NULL;
 
        /* bisection */
        min_index = 0;
        max_index = tree->n_chunks - 1;
 
        while (min_index <= max_index) {
                size_t mid = (min_index + max_index) / 2;
 
                if (logical < tree->chunks[mid]->offset) {
                        if (mid < 1)
                                return NULL;
 
                        max_index = mid - 1;
                } else if (logical >= tree->chunks[mid]->offset + tree->chunks[mid]->length)
                        min_index = mid + 1;
                else
                        return tree->chunks[mid];
        }
 
        return NULL;
}
 
static int btrfs_is_nocow_fd(int fd) {
        unsigned flags;
        int r;
 
        assert(fd >= 0);
 
        r = fd_is_fs_type(fd, BTRFS_SUPER_MAGIC);
        if (r < 0)
                return r;
        if (r == 0)
                return -ENOTTY;
 
        r = read_attr_fd(fd, &flags);
        if (r < 0)
                return r;
 
        return FLAGS_SET(flags, FS_NOCOW_FL) && !FLAGS_SET(flags, FS_COMPR_FL);
}
 
int btrfs_get_file_physical_offset_fd(int fd, uint64_t *ret) {
 
        struct btrfs_ioctl_search_args search_args = {
                .key.min_type = BTRFS_EXTENT_DATA_KEY,
                .key.max_type = BTRFS_EXTENT_DATA_KEY,
 
                .key.min_offset = 0,
                .key.max_offset = UINT64_MAX,
 
                .key.min_transid = 0,
                .key.max_transid = UINT64_MAX,
        };
 
        _cleanup_(btrfs_chunk_tree_done) BtrfsChunkTree tree = {};
        uint64_t subvol_id;
        struct stat st;
        int r;
 
        assert(fd >= 0);
        assert(ret);
 
        if (fstat(fd, &st) < 0)
                return -errno;
 
        r = stat_verify_regular(&st);
        if (r < 0)
                return r;
 
        r = btrfs_is_nocow_fd(fd);
        if (r < 0)
                return r;
        if (r == 0)
                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
                                       "Cannot get physical address for btrfs extent: CoW enabled");
 
        r = btrfs_subvol_get_id_fd(fd, &subvol_id);
        if (r < 0)
                return r;
 
        r = btrfs_read_chunk_tree_fd(fd, &tree);
        if (r < 0)
                return r;
 
        search_args.key.tree_id = subvol_id;
        search_args.key.min_objectid = search_args.key.max_objectid = st.st_ino;
 
        while (btrfs_ioctl_search_args_compare(&search_args) <= 0) {
                struct btrfs_ioctl_search_header sh;
                const void *body;
 
                search_args.key.nr_items = 256;
 
                if (ioctl(fd, BTRFS_IOC_TREE_SEARCH, &search_args) < 0)
                        return -errno;
 
                if (search_args.key.nr_items == 0)
                        break;
 
                FOREACH_BTRFS_IOCTL_SEARCH_HEADER(sh, body, search_args) {
                        uint64_t logical_offset;
                        BtrfsChunk *chunk;
 
                        btrfs_ioctl_search_args_set(&search_args, &sh);
 
                        if (sh.type != BTRFS_EXTENT_DATA_KEY)
                                continue;
 
                        if (sh.objectid != st.st_ino)
                                continue;
 
                        const struct btrfs_file_extent_item *item = body;
                        if (!IN_SET(item->type, BTRFS_FILE_EXTENT_REG, BTRFS_FILE_EXTENT_PREALLOC))
                                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Cannot get physical address for btrfs extent: invalid type %" PRIu8,
                                                       item->type);
 
                        if (item->compression != 0 || item->encryption != 0 || item->other_encoding != 0)
                                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Cannot get physical address for btrfs extent: has incompatible property");
 
                        logical_offset = le64toh(item->disk_bytenr);
                        if (logical_offset == 0)
                                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Cannot get physical address for btrfs extent: failed to get logical offset");
 
                        chunk = btrfs_find_chunk_from_logical_address(&tree, logical_offset);
                        if (!chunk)
                                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Cannot get physical address for btrfs extent: no matching chunk found");
 
                        if ((chunk->type & BTRFS_BLOCK_GROUP_PROFILE_MASK) != 0)
                                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Cannot get physical address for btrfs extent: unsupported profile");
 
                        uint64_t relative_chunk, relative_stripe, stripe_nr;
                        uint16_t stripe_index;
 
                        assert(logical_offset >= chunk->offset);
                        assert(chunk->n_stripes > 0);
                        assert(chunk->stripe_len > 0);
 
                        relative_chunk = logical_offset - chunk->offset;
                        stripe_nr = relative_chunk / chunk->stripe_len;
                        relative_stripe = relative_chunk - stripe_nr * chunk->stripe_len;
                        stripe_index = stripe_nr % chunk->n_stripes;
 
                        *ret = chunk->stripes[stripe_index].offset +
                                stripe_nr / chunk->n_stripes * chunk->stripe_len +
                                relative_stripe;
 
                        return 0;
                }
 
                if (!btrfs_ioctl_search_args_inc(&search_args))
                        break;
        }
 
        return -ENODATA;
}
 
int btrfs_replace(int fdmntpnt, uint64_t device_id, const char *target) {
        struct btrfs_ioctl_dev_replace_args replace = {
                .cmd = BTRFS_IOCTL_DEV_REPLACE_CMD_START,
                .result = UINT64_MAX,
                .start = {
                        .srcdevid = device_id,
                        .cont_reading_from_srcdev_mode = BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_ALWAYS,
                },
        };
 
        assert(fdmntpnt >= 0);
        assert(target);
 
        if (strlen(target) >= sizeof(replace.start.tgtdev_name))
                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Path to the btrfs replace target is too long");
        strncpy((char *)replace.start.tgtdev_name, target, sizeof(replace.start.tgtdev_name));
 
        if (ioctl(fdmntpnt, BTRFS_IOC_DEV_REPLACE, &replace) < 0)
                return -errno;
 
        switch (replace.result) {
        case BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR:
                break;
        case BTRFS_IOCTL_DEV_REPLACE_RESULT_NOT_STARTED:
                return log_debug_errno(SYNTHETIC_ERRNO(ECANCELED), "btrfs replace was not started");
        case BTRFS_IOCTL_DEV_REPLACE_RESULT_ALREADY_STARTED:
                return log_debug_errno(SYNTHETIC_ERRNO(EALREADY), "btrfs replace was already started on this device");
        case BTRFS_IOCTL_DEV_REPLACE_RESULT_SCRUB_INPROGRESS:
                return log_debug_errno(SYNTHETIC_ERRNO(EBUSY), "btrfs scrub is in progress");
        default:
                return log_debug_errno(SYNTHETIC_ERRNO(EIO), "An unknown btrfs error status occurred");
        }
 
        return 0;
}
 
int btrfs_resize_max(int fdmntpnt, uint64_t devid) {
        struct btrfs_ioctl_vol_args args = {};
 
        assert(fdmntpnt >= 0);
 
        assert_cc(STRLEN(":max") + DECIMAL_STR_MAX(uint64_t) + 1 <= sizeof(args.name));
        xsprintf(args.name, "%" PRIu64 ":max", devid);
 
        return RET_NERRNO(ioctl(fdmntpnt, BTRFS_IOC_RESIZE, &args));
}