{
struct btrfs_fs_devices *seed_devices;
struct btrfs_device *device;
+ int ret = 0;
again:
if (!fs_devices)
device = list_entry(fs_devices->devices.next,
struct btrfs_device, dev_list);
if (device->fd != -1) {
- fsync(device->fd);
+ if (fsync(device->fd) == -1) {
+ warning("fsync on device %llu failed: %s",
+ device->devid, strerror(errno));
+ ret = -errno;
+ }
if (posix_fadvise(device->fd, 0, 0, POSIX_FADV_DONTNEED))
fprintf(stderr, "Warning, could not drop caches\n");
close(device->fd);
free(fs_devices);
}
- return 0;
+ return ret;
}
void btrfs_close_all_devices(void)
}
/*
+ * find_free_dev_extent_start - find free space in the specified device
+ * @device: the device which we search the free space in
+ * @num_bytes: the size of the free space that we need
+ * @search_start: the position from which to begin the search
+ * @start: store the start of the free space.
+ * @len: the size of the free space. that we find, or the size
+ * of the max free space if we don't find suitable free space
+ *
* this uses a pretty simple search, the expectation is that it is
* called very infrequently and that a given device has a small number
* of extents
+ *
+ * @start is used to store the start of the free space if we find. But if we
+ * don't find suitable free space, it will be used to store the start position
+ * of the max free space.
+ *
+ * @len is used to store the size of the free space that we find.
+ * But if we don't find suitable free space, it is used to store the size of
+ * the max free space.
*/
-static int find_free_dev_extent(struct btrfs_trans_handle *trans,
- struct btrfs_device *device,
- struct btrfs_path *path,
- u64 num_bytes, u64 *start)
+static int find_free_dev_extent_start(struct btrfs_trans_handle *trans,
+ struct btrfs_device *device, u64 num_bytes,
+ u64 search_start, u64 *start, u64 *len)
{
struct btrfs_key key;
struct btrfs_root *root = device->dev_root;
- struct btrfs_dev_extent *dev_extent = NULL;
- u64 hole_size = 0;
- u64 last_byte = 0;
- u64 search_start = root->fs_info->alloc_start;
+ struct btrfs_dev_extent *dev_extent;
+ struct btrfs_path *path;
+ u64 hole_size;
+ u64 max_hole_start;
+ u64 max_hole_size;
+ u64 extent_end;
u64 search_end = device->total_bytes;
int ret;
- int slot = 0;
- int start_found;
+ int slot;
struct extent_buffer *l;
+ u64 min_search_start;
- start_found = 0;
- path->reada = 2;
+ /*
+ * We don't want to overwrite the superblock on the drive nor any area
+ * used by the boot loader (grub for example), so we make sure to start
+ * at an offset of at least 1MB.
+ */
+ min_search_start = max(root->fs_info->alloc_start, (u64)SZ_1M);
+ search_start = max(search_start, min_search_start);
- /* FIXME use last free of some kind */
+ path = btrfs_alloc_path();
+ if (!path)
+ return -ENOMEM;
- /* we don't want to overwrite the superblock on the drive,
- * so we make sure to start at an offset of at least 1MB
- */
- search_start = max(BTRFS_BLOCK_RESERVED_1M_FOR_SUPER, search_start);
+ max_hole_start = search_start;
+ max_hole_size = 0;
if (search_start >= search_end) {
ret = -ENOSPC;
- goto error;
+ goto out;
}
+ path->reada = 2;
+
key.objectid = device->devid;
key.offset = search_start;
key.type = BTRFS_DEV_EXTENT_KEY;
- ret = btrfs_search_slot(trans, root, &key, path, 0, 0);
- if (ret < 0)
- goto error;
- ret = btrfs_previous_item(root, path, 0, key.type);
+
+ ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
if (ret < 0)
- goto error;
- l = path->nodes[0];
- btrfs_item_key_to_cpu(l, &key, path->slots[0]);
+ goto out;
+ if (ret > 0) {
+ ret = btrfs_previous_item(root, path, key.objectid, key.type);
+ if (ret < 0)
+ goto out;
+ }
+
while (1) {
l = path->nodes[0];
slot = path->slots[0];
if (ret == 0)
continue;
if (ret < 0)
- goto error;
-no_more_items:
- if (!start_found) {
- if (search_start >= search_end) {
- ret = -ENOSPC;
- goto error;
- }
- *start = search_start;
- start_found = 1;
- goto check_pending;
- }
- *start = last_byte > search_start ?
- last_byte : search_start;
- if (search_end <= *start) {
- ret = -ENOSPC;
- goto error;
- }
- goto check_pending;
+ goto out;
+
+ break;
}
btrfs_item_key_to_cpu(l, &key, slot);
goto next;
if (key.objectid > device->devid)
- goto no_more_items;
-
- if (key.offset >= search_start && key.offset > last_byte &&
- start_found) {
- if (last_byte < search_start)
- last_byte = search_start;
- hole_size = key.offset - last_byte;
- if (key.offset > last_byte &&
- hole_size >= num_bytes) {
- *start = last_byte;
- goto check_pending;
- }
- }
- if (key.type != BTRFS_DEV_EXTENT_KEY) {
+ break;
+
+ if (key.type != BTRFS_DEV_EXTENT_KEY)
goto next;
+
+ if (key.offset > search_start) {
+ hole_size = key.offset - search_start;
+
+ /*
+ * Have to check before we set max_hole_start, otherwise
+ * we could end up sending back this offset anyway.
+ */
+ if (hole_size > max_hole_size) {
+ max_hole_start = search_start;
+ max_hole_size = hole_size;
+ }
+
+ /*
+ * If this free space is greater than which we need,
+ * it must be the max free space that we have found
+ * until now, so max_hole_start must point to the start
+ * of this free space and the length of this free space
+ * is stored in max_hole_size. Thus, we return
+ * max_hole_start and max_hole_size and go back to the
+ * caller.
+ */
+ if (hole_size >= num_bytes) {
+ ret = 0;
+ goto out;
+ }
}
- start_found = 1;
dev_extent = btrfs_item_ptr(l, slot, struct btrfs_dev_extent);
- last_byte = key.offset + btrfs_dev_extent_length(l, dev_extent);
+ extent_end = key.offset + btrfs_dev_extent_length(l,
+ dev_extent);
+ if (extent_end > search_start)
+ search_start = extent_end;
next:
path->slots[0]++;
cond_resched();
}
-check_pending:
- /* we have to make sure we didn't find an extent that has already
- * been allocated by the map tree or the original allocation
+
+ /*
+ * At this point, search_start should be the end of
+ * allocated dev extents, and when shrinking the device,
+ * search_end may be smaller than search_start.
*/
- btrfs_release_path(path);
- BUG_ON(*start < search_start);
+ if (search_end > search_start) {
+ hole_size = search_end - search_start;
- if (*start + num_bytes > search_end) {
- ret = -ENOSPC;
- goto error;
+ if (hole_size > max_hole_size) {
+ max_hole_start = search_start;
+ max_hole_size = hole_size;
+ }
}
- /* check for pending inserts here */
- return 0;
-error:
- btrfs_release_path(path);
+ /* See above. */
+ if (max_hole_size < num_bytes)
+ ret = -ENOSPC;
+ else
+ ret = 0;
+
+out:
+ btrfs_free_path(path);
+ *start = max_hole_start;
+ if (len)
+ *len = max_hole_size;
return ret;
}
+int find_free_dev_extent(struct btrfs_trans_handle *trans,
+ struct btrfs_device *device, u64 num_bytes,
+ u64 *start)
+{
+ /* FIXME use last free of some kind */
+ return find_free_dev_extent_start(trans, device,
+ num_bytes, 0, start, NULL);
+}
+
static int btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans,
struct btrfs_device *device,
u64 chunk_tree, u64 chunk_objectid,
* is responsible to make sure it's free.
*/
if (!convert) {
- ret = find_free_dev_extent(trans, device, path, num_bytes,
+ ret = find_free_dev_extent(trans, device, num_bytes,
start);
if (ret)
goto err;
return ret;
}
-int btrfs_add_system_chunk(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
+int btrfs_add_system_chunk(struct btrfs_root *root,
struct btrfs_key *key,
struct btrfs_chunk *chunk, int item_size)
{
struct list_head *dev_list = &info->fs_devices->devices;
struct list_head *cur;
struct map_lookup *map;
- int min_stripe_size = 1 * 1024 * 1024;
- u64 calc_size = 8 * 1024 * 1024;
+ int min_stripe_size = SZ_1M;
+ u64 calc_size = SZ_8M;
u64 min_free;
u64 max_chunk_size = 4 * calc_size;
u64 avail = 0;
BTRFS_BLOCK_GROUP_RAID10 |
BTRFS_BLOCK_GROUP_DUP)) {
if (type & BTRFS_BLOCK_GROUP_SYSTEM) {
- calc_size = 8 * 1024 * 1024;
+ calc_size = SZ_8M;
max_chunk_size = calc_size * 2;
- min_stripe_size = 1 * 1024 * 1024;
+ min_stripe_size = SZ_1M;
max_stripes = BTRFS_MAX_DEVS_SYS_CHUNK;
} else if (type & BTRFS_BLOCK_GROUP_DATA) {
- calc_size = 1024 * 1024 * 1024;
+ calc_size = SZ_1G;
max_chunk_size = 10 * calc_size;
- min_stripe_size = 64 * 1024 * 1024;
+ min_stripe_size = SZ_64M;
max_stripes = BTRFS_MAX_DEVS(chunk_root);
} else if (type & BTRFS_BLOCK_GROUP_METADATA) {
- calc_size = 1024 * 1024 * 1024;
+ calc_size = SZ_1G;
max_chunk_size = 4 * calc_size;
- min_stripe_size = 32 * 1024 * 1024;
+ min_stripe_size = SZ_32M;
max_stripes = BTRFS_MAX_DEVS(chunk_root);
}
}
BUG_ON(ret);
if (type & BTRFS_BLOCK_GROUP_SYSTEM) {
- ret = btrfs_add_system_chunk(trans, chunk_root, &key,
+ ret = btrfs_add_system_chunk(chunk_root, &key,
chunk, btrfs_chunk_item_size(num_stripes));
BUG_ON(ret);
}
struct list_head *dev_list = &info->fs_devices->devices;
struct list_head *cur;
struct map_lookup *map;
- u64 calc_size = 8 * 1024 * 1024;
+ u64 calc_size = SZ_8M;
int num_stripes = 1;
int sub_stripes = 0;
int ret;
key.offset = *start;
dev_offset = *start;
} else {
+ u64 tmp;
+
ret = find_next_chunk(chunk_root,
BTRFS_FIRST_CHUNK_TREE_OBJECTID,
- &key.offset);
+ &tmp);
+ key.offset = tmp;
if (ret)
return ret;
}
{
struct extent_buffer **ebs, *p_eb = NULL, *q_eb = NULL;
int i;
- int j;
int ret;
int alloc_size = eb->len;
void **pointers;
ebs = malloc(sizeof(*ebs) * multi->num_stripes);
pointers = malloc(sizeof(*pointers) * multi->num_stripes);
- if (!ebs || !pointers)
+ if (!ebs || !pointers) {
+ free(ebs);
+ free(pointers);
return -ENOMEM;
+ }
if (stripe_len > alloc_size)
alloc_size = stripe_len;
raid6_gen_syndrome(multi->num_stripes, stripe_len, pointers);
} else {
ebs[multi->num_stripes - 1] = p_eb;
- memcpy(p_eb->data, ebs[0]->data, stripe_len);
- for (j = 1; j < multi->num_stripes - 1; j++) {
- for (i = 0; i < stripe_len; i += sizeof(u64)) {
- u64 p_eb_data;
- u64 ebs_data;
-
- p_eb_data = get_unaligned_64(p_eb->data + i);
- ebs_data = get_unaligned_64(ebs[j]->data + i);
- p_eb_data ^= ebs_data;
- put_unaligned_64(p_eb_data, p_eb->data + i);
- }
- }
+ for (i = 0; i < multi->num_stripes; i++)
+ pointers[i] = ebs[i]->data;
+ ret = raid5_gen_result(multi->num_stripes, stripe_len,
+ multi->num_stripes - 1, pointers);
+ if (ret < 0)
+ goto out_free_split;
}
for (i = 0; i < multi->num_stripes; i++) {