* Boston, MA 021110-1307, USA.
*/
-#define _XOPEN_SOURCE 600
-#define _GNU_SOURCE 1
-
#include "kerncompat.h"
-#ifndef __CHECKER__
#include <sys/ioctl.h>
#include <sys/mount.h>
-#endif
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
-#include <sys/acl.h>
#include <fcntl.h>
#include <unistd.h>
#include <uuid/uuid.h>
-#include <linux/fs.h>
+#include <linux/limits.h>
+#include <getopt.h>
#include "ctree.h"
#include "disk-io.h"
#include "transaction.h"
#include "crc32c.h"
#include "utils.h"
+#include "task-utils.h"
#include <ext2fs/ext2_fs.h>
#include <ext2fs/ext2fs.h>
#include <ext2fs/ext2_ext_attr.h>
#define INO_OFFSET (BTRFS_FIRST_FREE_OBJECTID - EXT2_ROOT_INO)
-#define STRIPE_LEN (64 * 1024)
-#define EXT2_IMAGE_SUBVOL_OBJECTID BTRFS_FIRST_FREE_OBJECTID
+#define CONV_IMAGE_SUBVOL_OBJECTID BTRFS_FIRST_FREE_OBJECTID
+
+struct task_ctx {
+ uint32_t max_copy_inodes;
+ uint32_t cur_copy_inodes;
+ struct task_info *info;
+};
+
+static void *print_copied_inodes(void *p)
+{
+ struct task_ctx *priv = p;
+ const char work_indicator[] = { '.', 'o', 'O', 'o' };
+ uint32_t count = 0;
+
+ task_period_start(priv->info, 1000 /* 1s */);
+ while (1) {
+ count++;
+ printf("copy inodes [%c] [%10d/%10d]\r",
+ work_indicator[count % 4], priv->cur_copy_inodes,
+ priv->max_copy_inodes);
+ fflush(stdout);
+ task_period_wait(priv->info);
+ }
+
+ return NULL;
+}
+
+static int after_copied_inodes(void *p)
+{
+ printf("\n");
+ fflush(stdout);
+
+ return 0;
+}
/*
* Open Ext2fs in readonly mode, read block allocation bitmap and
return -ENOSPC;
}
+static int ext2_alloc_block_range(ext2_filsys fs, u64 goal, int num,
+ u64 *block_ret)
+{
+ blk_t block;
+ ext2fs_block_bitmap bitmap = fs->block_map;
+ blk_t start = ext2fs_get_block_bitmap_start(bitmap);
+ blk_t end = ext2fs_get_block_bitmap_end(bitmap);
+
+ for (block = max_t(u64, goal, start); block + num < end; block++) {
+ if (ext2fs_fast_test_block_bitmap_range(bitmap, block, num)) {
+ ext2fs_fast_mark_block_bitmap_range(bitmap, block,
+ num);
+ *block_ret = block;
+ return 0;
+ }
+ }
+ return -ENOSPC;
+}
+
static int ext2_free_block(ext2_filsys fs, u64 block)
{
BUG_ON(block != (blk_t)block);
return 0;
}
+static int ext2_free_block_range(ext2_filsys fs, u64 block, int num)
+{
+ BUG_ON(block != (blk_t)block);
+ ext2fs_fast_unmark_block_bitmap_range(fs->block_map, block, num);
+ return 0;
+}
+
static int cache_free_extents(struct btrfs_root *root, ext2_filsys ext2_fs)
{
for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
bytenr = btrfs_sb_offset(i);
- bytenr &= ~((u64)STRIPE_LEN - 1);
+ bytenr &= ~((u64)BTRFS_STRIPE_LEN - 1);
if (bytenr >= blocksize * ext2_fs->super->s_blocks_count)
break;
clear_extent_dirty(&root->fs_info->free_space_cache, bytenr,
- bytenr + STRIPE_LEN - 1, 0);
+ bytenr + BTRFS_STRIPE_LEN - 1, 0);
}
clear_extent_dirty(&root->fs_info->free_space_cache,
}
static int custom_alloc_extent(struct btrfs_root *root, u64 num_bytes,
- u64 hint_byte, struct btrfs_key *ins)
+ u64 hint_byte, struct btrfs_key *ins,
+ int metadata)
{
u64 start;
u64 end;
continue;
}
+ if (metadata) {
+ BUG_ON(num_bytes != root->nodesize);
+ if (check_crossing_stripes(start, num_bytes)) {
+ last = round_down(start + num_bytes,
+ BTRFS_STRIPE_LEN);
+ continue;
+ }
+ }
clear_extent_dirty(&root->fs_info->free_space_cache,
start, start + num_bytes - 1, 0);
for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
offset = btrfs_sb_offset(i);
- offset &= ~((u64)STRIPE_LEN - 1);
+ offset &= ~((u64)BTRFS_STRIPE_LEN - 1);
- if (bytenr < offset + STRIPE_LEN &&
+ if (bytenr < offset + BTRFS_STRIPE_LEN &&
bytenr + num_bytes > offset)
return 1;
}
return intersect_with_sb(bytenr, num_bytes);
}
-struct btrfs_extent_ops extent_ops = {
+static struct btrfs_extent_ops extent_ops = {
.alloc_extent = custom_alloc_extent,
.free_extent = custom_free_extent,
};
+static int convert_insert_dirent(struct btrfs_trans_handle *trans,
+ struct btrfs_root *root,
+ const char *name, size_t name_len,
+ u64 dir, u64 objectid,
+ u8 file_type, u64 index_cnt,
+ struct btrfs_inode_item *inode)
+{
+ int ret;
+ u64 inode_size;
+ struct btrfs_key location = {
+ .objectid = objectid,
+ .offset = 0,
+ .type = BTRFS_INODE_ITEM_KEY,
+ };
+
+ ret = btrfs_insert_dir_item(trans, root, name, name_len,
+ dir, &location, file_type, index_cnt);
+ if (ret)
+ return ret;
+ ret = btrfs_insert_inode_ref(trans, root, name, name_len,
+ objectid, dir, index_cnt);
+ if (ret)
+ return ret;
+ inode_size = btrfs_stack_inode_size(inode) + name_len * 2;
+ btrfs_set_stack_inode_size(inode, inode_size);
+
+ return 0;
+}
+
struct dir_iterate_data {
struct btrfs_trans_handle *trans;
struct btrfs_root *root;
int ret;
int file_type;
u64 objectid;
- u64 inode_size;
char dotdot[] = "..";
- struct btrfs_key location;
struct dir_iterate_data *idata = (struct dir_iterate_data *)priv_data;
int name_len;
if (dirent->inode < EXT2_GOOD_OLD_FIRST_INO)
return 0;
- location.objectid = objectid;
- location.offset = 0;
- btrfs_set_key_type(&location, BTRFS_INODE_ITEM_KEY);
-
file_type = dirent->name_len >> 8;
BUG_ON(file_type > EXT2_FT_SYMLINK);
- ret = btrfs_insert_dir_item(idata->trans, idata->root,
- dirent->name, name_len,
- idata->objectid, &location,
+
+ ret = convert_insert_dirent(idata->trans, idata->root, dirent->name,
+ name_len, idata->objectid, objectid,
filetype_conversion_table[file_type],
- idata->index_cnt);
- if (ret)
- goto fail;
- ret = btrfs_insert_inode_ref(idata->trans, idata->root,
- dirent->name, name_len,
- objectid, idata->objectid,
- idata->index_cnt);
- if (ret)
- goto fail;
+ idata->index_cnt, idata->inode);
+ if (ret < 0) {
+ idata->errcode = ret;
+ return BLOCK_ABORT;
+ }
+
idata->index_cnt++;
- inode_size = btrfs_stack_inode_size(idata->inode) +
- name_len * 2;
- btrfs_set_stack_inode_size(idata->inode, inode_size);
return 0;
-fail:
- idata->errcode = ret;
- return BLOCK_ABORT;
}
static int create_dir_entries(struct btrfs_trans_handle *trans,
ret = -1;
return ret;
}
-/*
- * Record a file extent. Do all the required works, such as inserting
- * file extent item, inserting extent item and backref item into extent
- * tree and updating block accounting.
- */
-static int record_file_extent(struct btrfs_trans_handle *trans,
- struct btrfs_root *root, u64 objectid,
- struct btrfs_inode_item *inode,
- u64 file_pos, u64 disk_bytenr,
- u64 num_bytes, int checksum)
+
+static int csum_disk_extent(struct btrfs_trans_handle *trans,
+ struct btrfs_root *root,
+ u64 disk_bytenr, u64 num_bytes)
{
- int ret;
- struct btrfs_fs_info *info = root->fs_info;
- struct btrfs_root *extent_root = info->extent_root;
- struct extent_buffer *leaf;
- struct btrfs_file_extent_item *fi;
- struct btrfs_key ins_key;
- struct btrfs_path path;
- struct btrfs_extent_item *ei;
u32 blocksize = root->sectorsize;
- u64 nbytes;
-
- if (disk_bytenr == 0) {
- ret = btrfs_insert_file_extent(trans, root, objectid,
- file_pos, disk_bytenr,
- num_bytes, num_bytes);
- return ret;
- }
-
- btrfs_init_path(&path);
-
- if (checksum) {
- u64 offset;
- char *buffer;
+ u64 offset;
+ char *buffer;
+ int ret = 0;
- ret = -ENOMEM;
- buffer = malloc(blocksize);
- if (!buffer)
- goto fail;
- for (offset = 0; offset < num_bytes; offset += blocksize) {
- ret = read_disk_extent(root, disk_bytenr + offset,
- blocksize, buffer);
- if (ret)
- break;
- ret = btrfs_csum_file_block(trans,
- root->fs_info->csum_root,
- disk_bytenr + num_bytes,
- disk_bytenr + offset,
- buffer, blocksize);
- if (ret)
- break;
- }
- free(buffer);
+ buffer = malloc(blocksize);
+ if (!buffer)
+ return -ENOMEM;
+ for (offset = 0; offset < num_bytes; offset += blocksize) {
+ ret = read_disk_extent(root, disk_bytenr + offset,
+ blocksize, buffer);
if (ret)
- goto fail;
- }
-
- ins_key.objectid = objectid;
- ins_key.offset = file_pos;
- btrfs_set_key_type(&ins_key, BTRFS_EXTENT_DATA_KEY);
- ret = btrfs_insert_empty_item(trans, root, &path, &ins_key,
- sizeof(*fi));
- if (ret)
- goto fail;
- leaf = path.nodes[0];
- fi = btrfs_item_ptr(leaf, path.slots[0],
- struct btrfs_file_extent_item);
- btrfs_set_file_extent_generation(leaf, fi, trans->transid);
- btrfs_set_file_extent_type(leaf, fi, BTRFS_FILE_EXTENT_REG);
- btrfs_set_file_extent_disk_bytenr(leaf, fi, disk_bytenr);
- btrfs_set_file_extent_disk_num_bytes(leaf, fi, num_bytes);
- btrfs_set_file_extent_offset(leaf, fi, 0);
- btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
- btrfs_set_file_extent_ram_bytes(leaf, fi, num_bytes);
- btrfs_set_file_extent_compression(leaf, fi, 0);
- btrfs_set_file_extent_encryption(leaf, fi, 0);
- btrfs_set_file_extent_other_encoding(leaf, fi, 0);
- btrfs_mark_buffer_dirty(leaf);
-
- nbytes = btrfs_stack_inode_nbytes(inode) + num_bytes;
- btrfs_set_stack_inode_nbytes(inode, nbytes);
-
- btrfs_release_path(root, &path);
-
- ins_key.objectid = disk_bytenr;
- ins_key.offset = num_bytes;
- ins_key.type = BTRFS_EXTENT_ITEM_KEY;
-
- ret = btrfs_insert_empty_item(trans, extent_root, &path,
- &ins_key, sizeof(*ei));
- if (ret == 0) {
- leaf = path.nodes[0];
- ei = btrfs_item_ptr(leaf, path.slots[0],
- struct btrfs_extent_item);
-
- btrfs_set_extent_refs(leaf, ei, 0);
- btrfs_set_extent_generation(leaf, ei, 0);
- btrfs_set_extent_flags(leaf, ei, BTRFS_EXTENT_FLAG_DATA);
-
- btrfs_mark_buffer_dirty(leaf);
-
- ret = btrfs_update_block_group(trans, root, disk_bytenr,
- num_bytes, 1, 0);
+ break;
+ ret = btrfs_csum_file_block(trans,
+ root->fs_info->csum_root,
+ disk_bytenr + num_bytes,
+ disk_bytenr + offset,
+ buffer, blocksize);
if (ret)
- goto fail;
- } else if (ret != -EEXIST) {
- goto fail;
+ break;
}
- btrfs_extent_post_op(trans, extent_root);
-
- ret = btrfs_inc_extent_ref(trans, root, disk_bytenr, num_bytes, 0,
- root->root_key.objectid,
- objectid, file_pos);
- if (ret)
- goto fail;
- ret = 0;
-fail:
- btrfs_release_path(root, &path);
+ free(buffer);
return ret;
}
-static int record_file_blocks(struct btrfs_trans_handle *trans,
- struct btrfs_root *root, u64 objectid,
- struct btrfs_inode_item *inode,
- u64 file_block, u64 disk_block,
- u64 num_blocks, int checksum)
-{
- u64 file_pos = file_block * root->sectorsize;
- u64 disk_bytenr = disk_block * root->sectorsize;
- u64 num_bytes = num_blocks * root->sectorsize;
- return record_file_extent(trans, root, objectid, inode, file_pos,
- disk_bytenr, num_bytes, checksum);
-}
-
struct blk_iterate_data {
struct btrfs_trans_handle *trans;
struct btrfs_root *root;
int errcode;
};
-static int block_iterate_proc(ext2_filsys ext2_fs,
- u64 disk_block, u64 file_block,
- struct blk_iterate_data *idata)
+static void init_blk_iterate_data(struct blk_iterate_data *data,
+ struct btrfs_trans_handle *trans,
+ struct btrfs_root *root,
+ struct btrfs_inode_item *inode,
+ u64 objectid, int checksum)
+{
+ data->trans = trans;
+ data->root = root;
+ data->inode = inode;
+ data->objectid = objectid;
+ data->first_block = 0;
+ data->disk_block = 0;
+ data->num_blocks = 0;
+ data->boundary = (u64)-1;
+ data->checksum = checksum;
+ data->errcode = 0;
+}
+
+static int record_file_blocks(struct blk_iterate_data *data,
+ u64 file_block, u64 disk_block, u64 num_blocks)
{
int ret;
+ struct btrfs_root *root = data->root;
+ u64 file_pos = file_block * root->sectorsize;
+ u64 disk_bytenr = disk_block * root->sectorsize;
+ u64 num_bytes = num_blocks * root->sectorsize;
+ ret = btrfs_record_file_extent(data->trans, data->root,
+ data->objectid, data->inode, file_pos,
+ disk_bytenr, num_bytes);
+
+ if (ret || !data->checksum || disk_bytenr == 0)
+ return ret;
+
+ return csum_disk_extent(data->trans, data->root, disk_bytenr,
+ num_bytes);
+}
+
+static int block_iterate_proc(u64 disk_block, u64 file_block,
+ struct blk_iterate_data *idata)
+{
+ int ret = 0;
int sb_region;
int do_barrier;
struct btrfs_root *root = idata->root;
- struct btrfs_trans_handle *trans = idata->trans;
struct btrfs_block_group_cache *cache;
u64 bytenr = disk_block * root->sectorsize;
(file_block > idata->first_block + idata->num_blocks) ||
(disk_block != idata->disk_block + idata->num_blocks)) {
if (idata->num_blocks > 0) {
- ret = record_file_blocks(trans, root, idata->objectid,
- idata->inode, idata->first_block,
- idata->disk_block, idata->num_blocks,
- idata->checksum);
+ ret = record_file_blocks(idata, idata->first_block,
+ idata->disk_block,
+ idata->num_blocks);
if (ret)
goto fail;
idata->first_block += idata->num_blocks;
idata->num_blocks = 0;
}
if (file_block > idata->first_block) {
- ret = record_file_blocks(trans, root, idata->objectid,
- idata->inode, idata->first_block,
- 0, file_block - idata->first_block,
- idata->checksum);
+ ret = record_file_blocks(idata, idata->first_block,
+ 0, file_block - idata->first_block);
if (ret)
goto fail;
}
if (sb_region) {
- bytenr += STRIPE_LEN - 1;
- bytenr &= ~((u64)STRIPE_LEN - 1);
+ bytenr += BTRFS_STRIPE_LEN - 1;
+ bytenr &= ~((u64)BTRFS_STRIPE_LEN - 1);
} else {
cache = btrfs_lookup_block_group(root->fs_info, bytenr);
BUG_ON(!cache);
idata->boundary = bytenr / root->sectorsize;
}
idata->num_blocks++;
- return 0;
fail:
- idata->errcode = ret;
- return BLOCK_ABORT;
+ return ret;
}
static int __block_iterate_proc(ext2_filsys fs, blk_t *blocknr,
e2_blkcnt_t blockcnt, blk_t ref_block,
int ref_offset, void *priv_data)
{
+ int ret;
struct blk_iterate_data *idata;
idata = (struct blk_iterate_data *)priv_data;
- return block_iterate_proc(fs, *blocknr, blockcnt, idata);
+ ret = block_iterate_proc(*blocknr, blockcnt, idata);
+ if (ret) {
+ idata->errcode = ret;
+ return BLOCK_ABORT;
+ }
+ return 0;
}
/*
u32 last_block;
u32 sectorsize = root->sectorsize;
u64 inode_size = btrfs_stack_inode_size(btrfs_inode);
- struct blk_iterate_data data = {
- .trans = trans,
- .root = root,
- .inode = btrfs_inode,
- .objectid = objectid,
- .first_block = 0,
- .disk_block = 0,
- .num_blocks = 0,
- .boundary = (u64)-1,
- .checksum = datacsum,
- .errcode = 0,
- };
+ struct blk_iterate_data data;
+
+ init_blk_iterate_data(&data, trans, root, btrfs_inode, objectid,
+ datacsum);
+
err = ext2fs_block_iterate2(ext2_fs, ext2_ino, BLOCK_FLAG_DATA_ONLY,
NULL, __block_iterate_proc, &data);
if (err)
nbytes = btrfs_stack_inode_nbytes(btrfs_inode) + num_bytes;
btrfs_set_stack_inode_nbytes(btrfs_inode, nbytes);
} else if (data.num_blocks > 0) {
- ret = record_file_blocks(trans, root, objectid, btrfs_inode,
- data.first_block, data.disk_block,
- data.num_blocks, data.checksum);
+ ret = record_file_blocks(&data, data.first_block,
+ data.disk_block, data.num_blocks);
if (ret)
goto fail;
}
data.first_block += data.num_blocks;
last_block = (inode_size + sectorsize - 1) / sectorsize;
if (last_block > data.first_block) {
- ret = record_file_blocks(trans, root, objectid, btrfs_inode,
- data.first_block, 0, last_block -
- data.first_block, data.checksum);
+ ret = record_file_blocks(&data, data.first_block, 0,
+ last_block - data.first_block);
}
fail:
- if (buffer)
- free(buffer);
+ free(buffer);
return ret;
error:
fprintf(stderr, "ext2fs_block_iterate2: %s\n", error_message(err));
#define EXT2_ACL_VERSION 0x0001
+/* 23.2.5 acl_tag_t values */
+
+#define ACL_UNDEFINED_TAG (0x00)
+#define ACL_USER_OBJ (0x01)
+#define ACL_USER (0x02)
+#define ACL_GROUP_OBJ (0x04)
+#define ACL_GROUP (0x08)
+#define ACL_MASK (0x10)
+#define ACL_OTHER (0x20)
+
+/* 23.2.7 ACL qualifier constants */
+
+#define ACL_UNDEFINED_ID ((id_t)-1)
+
typedef struct {
__le16 e_tag;
__le16 e_perm;
ret = btrfs_insert_xattr_item(trans, root, namebuf, name_len,
data, datalen, objectid);
out:
- if (databuf)
- free(databuf);
+ free(databuf);
return ret;
}
entry = EXT2_EXT_ATTR_NEXT(entry);
}
out:
- if (buffer != NULL)
- free(buffer);
+ free(buffer);
if ((void *)ext2_inode != inode_buf)
free(ext2_inode);
return ret;
struct ext2_inode *src, u32 blocksize)
{
btrfs_set_stack_inode_generation(dst, 1);
+ btrfs_set_stack_inode_sequence(dst, 0);
+ btrfs_set_stack_inode_transid(dst, 1);
btrfs_set_stack_inode_size(dst, src->i_size);
btrfs_set_stack_inode_nbytes(dst, 0);
btrfs_set_stack_inode_block_group(dst, 0);
new_decode_dev(src->i_block[1]));
}
}
+ memset(&dst->reserved, 0, sizeof(dst->reserved));
+
return 0;
}
int datacsum, int packing, int noxattr)
{
int ret;
- struct btrfs_key inode_key;
struct btrfs_inode_item btrfs_inode;
if (ext2_inode->i_links_count == 0)
if (ret)
return ret;
}
- inode_key.objectid = objectid;
- inode_key.offset = 0;
- btrfs_set_key_type(&inode_key, BTRFS_INODE_ITEM_KEY);
- ret = btrfs_insert_inode(trans, root, objectid, &btrfs_inode);
- return ret;
+ return btrfs_insert_inode(trans, root, objectid, &btrfs_inode);
}
static int copy_disk_extent(struct btrfs_root *root, u64 dst_bytenr,
* scan ext2's inode bitmap and copy all used inodes.
*/
static int copy_inodes(struct btrfs_root *root, ext2_filsys ext2_fs,
- int datacsum, int packing, int noxattr)
+ int datacsum, int packing, int noxattr, struct task_ctx *p)
{
int ret;
errcode_t err;
objectid, ext2_fs, ext2_ino,
&ext2_inode, datacsum, packing,
noxattr);
+ p->cur_copy_inodes++;
if (ret)
return ret;
if (trans->blocks_used >= 4096) {
}
ret = btrfs_commit_transaction(trans, root);
BUG_ON(ret);
+ ext2fs_close_inode_scan(ext2_scan);
return ret;
}
struct btrfs_root *root, u64 objectid,
struct btrfs_inode_item *inode,
u64 start_byte, u64 end_byte,
- ext2_filsys ext2_fs)
+ ext2_filsys ext2_fs, int datacsum)
{
u32 blocksize = ext2_fs->blocksize;
u32 block = start_byte / blocksize;
u32 last_block = (end_byte + blocksize - 1) / blocksize;
int ret = 0;
- struct blk_iterate_data data = {
- .trans = trans,
- .root = root,
- .inode = inode,
- .objectid = objectid,
- .first_block = block,
- .disk_block = 0,
- .num_blocks = 0,
- .boundary = (u64)-1,
- .checksum = 0,
- .errcode = 0,
- };
+ struct blk_iterate_data data;
+
+ init_blk_iterate_data(&data, trans, root, inode, objectid, datacsum);
+ data.first_block = block;
+
for (; start_byte < end_byte; block++, start_byte += blocksize) {
if (!ext2fs_fast_test_block_bitmap(ext2_fs->block_map, block))
continue;
- ret = block_iterate_proc(NULL, block, block, &data);
- if (ret & BLOCK_ABORT) {
- ret = data.errcode;
+ ret = block_iterate_proc(block, block, &data);
+ if (ret < 0)
goto fail;
- }
}
if (data.num_blocks > 0) {
- ret = record_file_blocks(trans, root, objectid, inode,
- data.first_block, data.disk_block,
- data.num_blocks, 0);
+ ret = record_file_blocks(&data, data.first_block,
+ data.disk_block, data.num_blocks);
if (ret)
goto fail;
data.first_block += data.num_blocks;
}
if (last_block > data.first_block) {
- ret = record_file_blocks(trans, root, objectid, inode,
- data.first_block, 0, last_block -
- data.first_block, 0);
+ ret = record_file_blocks(&data, data.first_block, 0,
+ last_block - data.first_block);
if (ret)
goto fail;
}
* Create the ext2fs image file.
*/
static int create_ext2_image(struct btrfs_root *root, ext2_filsys ext2_fs,
- const char *name)
+ const char *name, int datacsum)
{
int ret;
struct btrfs_key key;
u64 last_byte;
u64 first_free;
u64 total_bytes;
+ u64 flags = BTRFS_INODE_READONLY;
u32 sectorsize = root->sectorsize;
total_bytes = btrfs_super_total_bytes(fs_info->super_copy);
first_free = BTRFS_SUPER_INFO_OFFSET + sectorsize * 2 - 1;
first_free &= ~((u64)sectorsize - 1);
+ if (!datacsum)
+ flags |= BTRFS_INODE_NODATASUM;
memset(&btrfs_inode, 0, sizeof(btrfs_inode));
btrfs_set_stack_inode_generation(&btrfs_inode, 1);
btrfs_set_stack_inode_nlink(&btrfs_inode, 1);
btrfs_set_stack_inode_nbytes(&btrfs_inode, 0);
btrfs_set_stack_inode_mode(&btrfs_inode, S_IFREG | 0400);
- btrfs_set_stack_inode_flags(&btrfs_inode, BTRFS_INODE_NODATASUM |
- BTRFS_INODE_READONLY);
+ btrfs_set_stack_inode_flags(&btrfs_inode, flags);
btrfs_init_path(&path);
trans = btrfs_start_transaction(root, 1);
BUG_ON(!trans);
* special, we can't rely on relocate_extents_range to relocate it.
*/
for (last_byte = 0; last_byte < first_free; last_byte += sectorsize) {
- ret = custom_alloc_extent(root, sectorsize, 0, &key);
+ ret = custom_alloc_extent(root, sectorsize, 0, &key, 0);
if (ret)
goto fail;
ret = copy_disk_extent(root, key.objectid, last_byte,
sectorsize);
if (ret)
goto fail;
- ret = record_file_extent(trans, root, objectid,
- &btrfs_inode, last_byte,
- key.objectid, sectorsize, 0);
+ ret = btrfs_record_file_extent(trans, root, objectid,
+ &btrfs_inode, last_byte,
+ key.objectid, sectorsize);
if (ret)
goto fail;
+ if (datacsum) {
+ ret = csum_disk_extent(trans, root, key.objectid,
+ sectorsize);
+ if (ret)
+ goto fail;
+ }
}
while(1) {
if (bytenr > last_byte) {
ret = create_image_file_range(trans, root, objectid,
&btrfs_inode, last_byte,
- bytenr, ext2_fs);
+ bytenr, ext2_fs,
+ datacsum);
if (ret)
goto fail;
}
- ret = record_file_extent(trans, root, objectid, &btrfs_inode,
- bytenr, bytenr, num_bytes, 0);
+ ret = btrfs_record_file_extent(trans, root, objectid,
+ &btrfs_inode, bytenr, bytenr,
+ num_bytes);
if (ret)
goto fail;
last_byte = bytenr + num_bytes;
- btrfs_release_path(extent_root, &path);
+ btrfs_release_path(&path);
if (trans->blocks_used >= 4096) {
ret = btrfs_commit_transaction(trans, root);
BUG_ON(!trans);
}
}
- btrfs_release_path(root, &path);
+ btrfs_release_path(&path);
if (total_bytes > last_byte) {
ret = create_image_file_range(trans, root, objectid,
&btrfs_inode, last_byte,
- total_bytes, ext2_fs);
+ total_bytes, ext2_fs,
+ datacsum);
if (ret)
goto fail;
}
btrfs_set_key_type(&location, BTRFS_INODE_ITEM_KEY);
ret = btrfs_insert_dir_item(trans, root, name, strlen(name),
btrfs_root_dirid(&root->root_item),
- &location, EXT2_FT_REG_FILE, objectid);
+ &location, BTRFS_FT_REG_FILE, objectid);
if (ret)
goto fail;
ret = btrfs_insert_inode_ref(trans, root, name, strlen(name),
btrfs_set_inode_size(leaf, inode_item, strlen(name) * 2 +
btrfs_inode_size(leaf, inode_item));
btrfs_mark_buffer_dirty(leaf);
- btrfs_release_path(root, &path);
+ btrfs_release_path(&path);
ret = btrfs_commit_transaction(trans, root);
BUG_ON(ret);
fail:
- btrfs_release_path(root, &path);
+ btrfs_release_path(&path);
return ret;
}
-struct btrfs_root *link_subvol(struct btrfs_root *root, const char *base,
- u64 root_objectid)
+static struct btrfs_root * link_subvol(struct btrfs_root *root,
+ const char *base, u64 root_objectid)
{
struct btrfs_trans_handle *trans;
struct btrfs_fs_info *fs_info = root->fs_info;
struct btrfs_key key;
u64 dirid = btrfs_root_dirid(&root->root_item);
u64 index = 2;
- char buf[64];
+ char buf[BTRFS_NAME_LEN + 1]; /* for snprintf null */
+ int len;
int i;
int ret;
+ len = strlen(base);
+ if (len < 1 || len > BTRFS_NAME_LEN)
+ return NULL;
+
path = btrfs_alloc_path();
BUG_ON(!path);
if (key.objectid == dirid && key.type == BTRFS_DIR_INDEX_KEY)
index = key.offset + 1;
}
- btrfs_release_path(root, path);
+ btrfs_release_path(path);
trans = btrfs_start_transaction(root, 1);
BUG_ON(!trans);
key.offset = (u64)-1;
key.type = BTRFS_ROOT_ITEM_KEY;
- strcpy(buf, base);
+ memcpy(buf, base, len);
for (i = 0; i < 1024; i++) {
- ret = btrfs_insert_dir_item(trans, root, buf, strlen(buf),
+ ret = btrfs_insert_dir_item(trans, root, buf, len,
dirid, &key, BTRFS_FT_DIR, index);
if (ret != -EEXIST)
break;
- sprintf(buf, "%s%d", base, i);
+ len = snprintf(buf, ARRAY_SIZE(buf), "%s%d", base, i);
+ if (len < 1 || len > BTRFS_NAME_LEN) {
+ ret = -EINVAL;
+ break;
+ }
}
if (ret)
goto fail;
- btrfs_set_inode_size(leaf, inode_item, strlen(buf) * 2 +
+ btrfs_set_inode_size(leaf, inode_item, len * 2 +
btrfs_inode_size(leaf, inode_item));
btrfs_mark_buffer_dirty(leaf);
- btrfs_release_path(root, path);
+ btrfs_release_path(path);
/* add the backref first */
ret = btrfs_add_root_ref(trans, tree_root, root_objectid,
BTRFS_ROOT_BACKREF_KEY,
root->root_key.objectid,
- dirid, index, buf, strlen(buf));
+ dirid, index, buf, len);
BUG_ON(ret);
/* now add the forward ref */
ret = btrfs_add_root_ref(trans, tree_root, root->root_key.objectid,
BTRFS_ROOT_REF_KEY, root_objectid,
- dirid, index, buf, strlen(buf));
+ dirid, index, buf, len);
ret = btrfs_commit_transaction(trans, root);
BUG_ON(ret);
ret = btrfs_del_item(trans, device->dev_root, &path);
if (ret)
goto err;
- btrfs_release_path(device->dev_root, &path);
+ btrfs_release_path(&path);
/* delete chunk item created by make_btrfs */
key.objectid = chunk_objectid;
ret = btrfs_del_item(trans, chunk_root, &path);
if (ret)
goto err;
- btrfs_release_path(chunk_root, &path);
+ btrfs_release_path(&path);
/* for each block group, create device extent and chunk item */
cur_start = 0;
(unsigned long)btrfs_dev_extent_chunk_tree_uuid(extent),
BTRFS_UUID_SIZE);
btrfs_mark_buffer_dirty(leaf);
- btrfs_release_path(device->dev_root, &path);
+ btrfs_release_path(&path);
/* insert chunk item */
btrfs_set_stack_chunk_length(&chunk, cache->key.offset);
btrfs_set_stack_chunk_owner(&chunk,
extent_root->root_key.objectid);
- btrfs_set_stack_chunk_stripe_len(&chunk, STRIPE_LEN);
+ btrfs_set_stack_chunk_stripe_len(&chunk, BTRFS_STRIPE_LEN);
btrfs_set_stack_chunk_type(&chunk, cache->flags);
btrfs_set_stack_chunk_io_align(&chunk, device->io_align);
btrfs_set_stack_chunk_io_width(&chunk, device->io_width);
device->bytes_used = total_bytes;
ret = btrfs_update_device(trans, device);
err:
- btrfs_release_path(device->dev_root, &path);
+ btrfs_release_path(&path);
return ret;
}
BTRFS_FIRST_FREE_OBJECTID);
/* subvol for ext2 image file */
- ret = create_subvol(trans, root, EXT2_IMAGE_SUBVOL_OBJECTID);
+ ret = create_subvol(trans, root, CONV_IMAGE_SUBVOL_OBJECTID);
BUG_ON(ret);
/* subvol for data relocation */
ret = create_subvol(trans, root, BTRFS_DATA_RELOC_TREE_OBJECTID);
BUG_ON(ret);
+ extent_buffer_get(fs_info->csum_root->node);
ret = __btrfs_cow_block(trans, fs_info->csum_root,
fs_info->csum_root->node, NULL, 0, &tmp, 0, 0);
BUG_ON(ret);
}
/*
- * Migrate super block to it's default position and zero 0 ~ 16k
+ * Migrate super block to its default position and zero 0 ~ 16k
*/
static int migrate_super_block(int fd, u64 old_bytenr, u32 sectorsize)
{
btrfs_set_stack_chunk_length(chunk, btrfs_super_total_bytes(super));
btrfs_set_stack_chunk_owner(chunk, BTRFS_EXTENT_TREE_OBJECTID);
- btrfs_set_stack_chunk_stripe_len(chunk, 64 * 1024);
+ btrfs_set_stack_chunk_stripe_len(chunk, BTRFS_STRIPE_LEN);
btrfs_set_stack_chunk_type(chunk, BTRFS_BLOCK_GROUP_SYSTEM);
btrfs_set_stack_chunk_io_align(chunk, sectorsize);
btrfs_set_stack_chunk_io_width(chunk, sectorsize);
return 0;
}
-static int prepare_system_chunk(int fd, u64 sb_bytenr, u32 sectorsize)
+static int prepare_system_chunk(int fd, u64 sb_bytenr)
{
int ret;
struct extent_buffer *buf;
struct btrfs_super_block *super;
- BUG_ON(sectorsize < sizeof(*super));
- buf = malloc(sizeof(*buf) + sectorsize);
+ BUG_ON(BTRFS_SUPER_INFO_SIZE < sizeof(*super));
+ buf = malloc(sizeof(*buf) + BTRFS_SUPER_INFO_SIZE);
if (!buf)
return -ENOMEM;
- buf->len = sectorsize;
- ret = pread(fd, buf->data, sectorsize, sb_bytenr);
- if (ret != sectorsize)
+ buf->len = BTRFS_SUPER_INFO_SIZE;
+ ret = pread(fd, buf->data, BTRFS_SUPER_INFO_SIZE, sb_bytenr);
+ if (ret != BTRFS_SUPER_INFO_SIZE)
goto fail;
super = (struct btrfs_super_block *)buf->data;
goto fail;
csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
- ret = pwrite(fd, buf->data, sectorsize, sb_bytenr);
- if (ret != sectorsize)
+ ret = pwrite(fd, buf->data, BTRFS_SUPER_INFO_SIZE, sb_bytenr);
+ if (ret != BTRFS_SUPER_INFO_SIZE)
goto fail;
ret = 0;
if (ret)
goto fail;
- btrfs_release_path(root, &path);
+ btrfs_release_path(&path);
key.objectid = extent_key->objectid;
key.offset = 0;
leaf = path.nodes[0];
ptr = btrfs_item_ptr_offset(leaf, path.slots[0]);
read_extent_buffer(leaf, &inode, ptr, sizeof(inode));
- btrfs_release_path(root, &path);
+ btrfs_release_path(&path);
BUG_ON(num_bytes & (sectorsize - 1));
nbytes = btrfs_stack_inode_nbytes(&inode) - num_bytes;
btrfs_set_stack_inode_nbytes(&inode, nbytes);
datacsum = !(btrfs_stack_inode_flags(&inode) & BTRFS_INODE_NODATASUM);
- data = (struct blk_iterate_data) {
- .trans = trans,
- .root = root,
- .inode = &inode,
- .objectid = extent_key->objectid,
- .first_block = extent_key->offset / sectorsize,
- .disk_block = 0,
- .num_blocks = 0,
- .boundary = (u64)-1,
- .checksum = datacsum,
- .errcode = 0,
- };
+ init_blk_iterate_data(&data, trans, root, &inode, extent_key->objectid,
+ datacsum);
+ data.first_block = extent_key->offset;
cur_offset = extent_key->offset;
while (num_bytes > 0) {
ret = get_state_private(reloc_tree, bytenr, &new_pos);
BUG_ON(ret);
} else {
- ret = custom_alloc_extent(root, sectorsize, 0, &key);
+ ret = custom_alloc_extent(root, sectorsize, 0, &key, 0);
if (ret)
goto fail;
new_pos = key.objectid;
BUG_ON(ret);
}
- ret = block_iterate_proc(NULL, new_pos / sectorsize,
+ ret = block_iterate_proc(new_pos / sectorsize,
cur_offset / sectorsize, &data);
- if (ret & BLOCK_ABORT) {
- ret = data.errcode;
+ if (ret < 0)
goto fail;
- }
cur_offset += sectorsize;
bytenr += sectorsize;
}
if (data.num_blocks > 0) {
- ret = record_file_blocks(trans, root,
- extent_key->objectid, &inode,
- data.first_block, data.disk_block,
- data.num_blocks, datacsum);
+ ret = record_file_blocks(&data, data.first_block,
+ data.disk_block, data.num_blocks);
if (ret)
goto fail;
}
ptr = btrfs_item_ptr_offset(leaf, path.slots[0]);
write_extent_buffer(leaf, &inode, ptr, sizeof(inode));
btrfs_mark_buffer_dirty(leaf);
- btrfs_release_path(root, &path);
+ btrfs_release_path(&path);
fail:
- btrfs_release_path(root, &path);
+ btrfs_release_path(&path);
return ret;
}
static int relocate_extents_range(struct btrfs_root *fs_root,
- struct btrfs_root *ext2_root,
+ struct btrfs_root *image_root,
u64 start_byte, u64 end_byte)
{
struct btrfs_fs_info *info = fs_root->fs_info;
start_byte = key.objectid;
}
}
- btrfs_release_path(extent_root, &path);
+ btrfs_release_path(&path);
again:
- cur_root = (pass % 2 == 0) ? ext2_root : fs_root;
+ cur_root = (pass % 2 == 0) ? image_root : fs_root;
num_extents = 0;
trans = btrfs_start_transaction(cur_root, 1);
goto fail;
cur_byte += num_bytes;
- btrfs_release_path(extent_root, &path);
+ btrfs_release_path(&path);
if (trans->blocks_used >= 4096) {
ret = btrfs_commit_transaction(trans, cur_root);
BUG_ON(!trans);
}
}
- btrfs_release_path(cur_root, &path);
+ btrfs_release_path(&path);
ret = btrfs_commit_transaction(trans, cur_root);
BUG_ON(ret);
ret = (num_extents > 0) ? -1 : 0;
fail:
- btrfs_release_path(cur_root, &path);
+ btrfs_release_path(&path);
extent_io_tree_cleanup(&reloc_tree);
return ret;
}
* relocate data in system chunk
*/
static int cleanup_sys_chunk(struct btrfs_root *fs_root,
- struct btrfs_root *ext2_root)
+ struct btrfs_root *image_root)
{
struct btrfs_block_group_cache *cache;
int i, ret = 0;
end_byte = cache->key.objectid + cache->key.offset;
if (cache->flags & BTRFS_BLOCK_GROUP_SYSTEM) {
- ret = relocate_extents_range(fs_root, ext2_root,
+ ret = relocate_extents_range(fs_root, image_root,
cache->key.objectid,
end_byte);
if (ret)
}
for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
offset = btrfs_sb_offset(i);
- offset &= ~((u64)STRIPE_LEN - 1);
+ offset &= ~((u64)BTRFS_STRIPE_LEN - 1);
- ret = relocate_extents_range(fs_root, ext2_root,
- offset, offset + STRIPE_LEN);
+ ret = relocate_extents_range(fs_root, image_root,
+ offset, offset + BTRFS_STRIPE_LEN);
if (ret)
goto fail;
}
break;
btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
- btrfs_release_path(chunk_root, &path);
+ btrfs_release_path(&path);
}
- btrfs_release_path(chunk_root, &path);
+ btrfs_release_path(&path);
/* fixup the system chunk array in super block */
btrfs_set_super_sys_array_size(info->super_copy, 0);
ret = btrfs_commit_transaction(trans, root);
BUG_ON(ret);
err:
- btrfs_release_path(chunk_root, &path);
+ btrfs_release_path(&path);
return ret;
}
-int do_convert(const char *devname, int datacsum, int packing, int noxattr)
+static int do_convert(const char *devname, int datacsum, int packing, int noxattr,
+ u32 nodesize, int copylabel, const char *fslabel, int progress,
+ u64 features)
{
- int i, ret;
+ int i, ret, blocks_per_node;
int fd = -1;
u32 blocksize;
u64 blocks[7];
u64 super_bytenr;
ext2_filsys ext2_fs;
struct btrfs_root *root;
- struct btrfs_root *ext2_root;
+ struct btrfs_root *image_root;
+ struct task_ctx ctx;
+ char features_buf[64];
+ struct btrfs_mkfs_config mkfs_cfg;
ret = open_ext2fs(devname, &ext2_fs);
if (ret) {
fprintf(stderr, "filetype feature is missing\n");
goto fail;
}
+ if (btrfs_check_nodesize(nodesize, blocksize, features))
+ goto fail;
+ blocks_per_node = nodesize / blocksize;
+ ret = -blocks_per_node;
for (i = 0; i < 7; i++) {
- ret = ext2_alloc_block(ext2_fs, 0, blocks + i);
+ if (nodesize == blocksize)
+ ret = ext2_alloc_block(ext2_fs, 0, blocks + i);
+ else
+ ret = ext2_alloc_block_range(ext2_fs,
+ ret + blocks_per_node, blocks_per_node,
+ blocks + i);
if (ret) {
fprintf(stderr, "not enough free space\n");
goto fail;
fprintf(stderr, "unable to open %s\n", devname);
goto fail;
}
- ret = make_btrfs(fd, devname, ext2_fs->super->s_volume_name,
- blocks, total_bytes, blocksize, blocksize,
- blocksize, blocksize);
+ btrfs_parse_features_to_string(features_buf, features);
+ if (features == BTRFS_MKFS_DEFAULT_FEATURES)
+ strcat(features_buf, " (default)");
+
+ printf("create btrfs filesystem:\n");
+ printf("\tblocksize: %u\n", blocksize);
+ printf("\tnodesize: %u\n", nodesize);
+ printf("\tfeatures: %s\n", features_buf);
+
+ mkfs_cfg.label = ext2_fs->super->s_volume_name;
+ mkfs_cfg.fs_uuid = NULL;
+ memcpy(mkfs_cfg.blocks, blocks, sizeof(blocks));
+ mkfs_cfg.num_bytes = total_bytes;
+ mkfs_cfg.nodesize = nodesize;
+ mkfs_cfg.sectorsize = blocksize;
+ mkfs_cfg.stripesize = blocksize;
+ mkfs_cfg.features = features;
+
+ ret = make_btrfs(fd, &mkfs_cfg);
if (ret) {
fprintf(stderr, "unable to create initial ctree: %s\n",
strerror(-ret));
goto fail;
}
/* create a system chunk that maps the whole device */
- ret = prepare_system_chunk(fd, super_bytenr, blocksize);
+ ret = prepare_system_chunk(fd, super_bytenr);
if (ret) {
fprintf(stderr, "unable to update system chunk\n");
goto fail;
}
- root = open_ctree_fd(fd, devname, super_bytenr, O_RDWR);
+ root = open_ctree_fd(fd, devname, super_bytenr, OPEN_CTREE_WRITES);
if (!root) {
fprintf(stderr, "unable to open ctree\n");
goto fail;
/* recover block allocation bitmap */
for (i = 0; i < 7; i++) {
blocks[i] /= blocksize;
- ext2_free_block(ext2_fs, blocks[i]);
+ if (nodesize == blocksize)
+ ext2_free_block(ext2_fs, blocks[i]);
+ else
+ ext2_free_block_range(ext2_fs, blocks[i],
+ blocks_per_node);
}
ret = init_btrfs(root);
if (ret) {
goto fail;
}
printf("creating btrfs metadata.\n");
- ret = copy_inodes(root, ext2_fs, datacsum, packing, noxattr);
+ ctx.max_copy_inodes = (ext2_fs->super->s_inodes_count
+ - ext2_fs->super->s_free_inodes_count);
+ ctx.cur_copy_inodes = 0;
+
+ if (progress) {
+ ctx.info = task_init(print_copied_inodes, after_copied_inodes, &ctx);
+ task_start(ctx.info);
+ }
+ ret = copy_inodes(root, ext2_fs, datacsum, packing, noxattr, &ctx);
if (ret) {
fprintf(stderr, "error during copy_inodes %d\n", ret);
goto fail;
}
+ if (progress) {
+ task_stop(ctx.info);
+ task_deinit(ctx.info);
+ }
printf("creating ext2fs image file.\n");
- ext2_root = link_subvol(root, "ext2_saved", EXT2_IMAGE_SUBVOL_OBJECTID);
- if (!ext2_root) {
+ image_root = link_subvol(root, "ext2_saved", CONV_IMAGE_SUBVOL_OBJECTID);
+ if (!image_root) {
fprintf(stderr, "unable to create subvol\n");
goto fail;
}
- ret = create_ext2_image(ext2_root, ext2_fs, "image");
+ ret = create_ext2_image(image_root, ext2_fs, "image", datacsum);
if (ret) {
fprintf(stderr, "error during create_ext2_image %d\n", ret);
goto fail;
}
+ memset(root->fs_info->super_copy->label, 0, BTRFS_LABEL_SIZE);
+ if (copylabel == 1) {
+ strncpy(root->fs_info->super_copy->label,
+ ext2_fs->super->s_volume_name, 16);
+ fprintf(stderr, "copy label '%s'\n",
+ root->fs_info->super_copy->label);
+ } else if (copylabel == -1) {
+ strcpy(root->fs_info->super_copy->label, fslabel);
+ fprintf(stderr, "set label to '%s'\n", fslabel);
+ }
+
printf("cleaning up system chunk.\n");
- ret = cleanup_sys_chunk(root, ext2_root);
+ ret = cleanup_sys_chunk(root, image_root);
if (ret) {
fprintf(stderr, "error during cleanup_sys_chunk %d\n", ret);
goto fail;
goto fail;
}
- root = open_ctree_fd(fd, devname, 0, O_RDWR);
+ root = open_ctree_fd(fd, devname, 0, OPEN_CTREE_WRITES);
if (!root) {
fprintf(stderr, "unable to open ctree\n");
goto fail;
while (1) {
ret = btrfs_map_block(&info->mapping_tree, WRITE, bytenr,
&length, &multi, 0, NULL);
- if (ret)
+ if (ret) {
+ if (ret == -ENOENT) {
+ /* removed block group at the tail */
+ if (length == (u64)-1)
+ break;
+
+ /* removed block group in the middle */
+ goto next;
+ }
goto fail;
+ }
num_stripes = multi->num_stripes;
physical = multi->stripes[0].physical;
if (num_stripes != 1 || physical != bytenr)
goto fail;
-
+next:
bytenr += length;
if (bytenr >= total_bytes)
break;
return -1;
}
-int do_rollback(const char *devname, int force)
+static int do_rollback(const char *devname)
{
int fd = -1;
int ret;
int i;
struct btrfs_root *root;
- struct btrfs_root *ext2_root;
+ struct btrfs_root *image_root;
struct btrfs_root *chunk_root;
struct btrfs_dir_item *dir;
struct btrfs_inode_item *inode;
fprintf(stderr, "unable to open %s\n", devname);
goto fail;
}
- root = open_ctree_fd(fd, devname, 0, O_RDWR);
+ root = open_ctree_fd(fd, devname, 0, OPEN_CTREE_WRITES);
if (!root) {
fprintf(stderr, "unable to open ctree\n");
goto fail;
btrfs_init_path(&path);
- key.objectid = EXT2_IMAGE_SUBVOL_OBJECTID;
+ key.objectid = CONV_IMAGE_SUBVOL_OBJECTID;
key.type = BTRFS_ROOT_ITEM_KEY;
key.offset = (u64)-1;
- ext2_root = btrfs_read_fs_root(root->fs_info, &key);
- if (!ext2_root || IS_ERR(ext2_root)) {
+ image_root = btrfs_read_fs_root(root->fs_info, &key);
+ if (!image_root || IS_ERR(image_root)) {
fprintf(stderr, "unable to open subvol %llu\n",
- key.objectid);
+ (unsigned long long)key.objectid);
goto fail;
}
name = "image";
root_dir = btrfs_root_dirid(&root->root_item);
- dir = btrfs_lookup_dir_item(NULL, ext2_root, &path,
+ dir = btrfs_lookup_dir_item(NULL, image_root, &path,
root_dir, name, strlen(name), 0);
if (!dir || IS_ERR(dir)) {
fprintf(stderr, "unable to find file %s\n", name);
}
leaf = path.nodes[0];
btrfs_dir_item_key_to_cpu(leaf, dir, &key);
- btrfs_release_path(ext2_root, &path);
+ btrfs_release_path(&path);
objectid = key.objectid;
- ret = btrfs_lookup_inode(NULL, ext2_root, &path, &key, 0);
+ ret = btrfs_lookup_inode(NULL, image_root, &path, &key, 0);
if (ret) {
fprintf(stderr, "unable to find inode item\n");
goto fail;
leaf = path.nodes[0];
inode = btrfs_item_ptr(leaf, path.slots[0], struct btrfs_inode_item);
total_bytes = btrfs_inode_size(leaf, inode);
- btrfs_release_path(ext2_root, &path);
+ btrfs_release_path(&path);
key.objectid = objectid;
key.offset = 0;
btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
- ret = btrfs_search_slot(NULL, ext2_root, &key, &path, 0, 0);
+ ret = btrfs_search_slot(NULL, image_root, &key, &path, 0, 0);
if (ret != 0) {
fprintf(stderr, "unable to find first file extent\n");
- btrfs_release_path(ext2_root, &path);
+ btrfs_release_path(&path);
goto fail;
}
offset += btrfs_file_extent_num_bytes(leaf, fi);
path.slots[0]++;
}
- btrfs_release_path(ext2_root, &path);
+ btrfs_release_path(&path);
if (offset < total_bytes) {
fprintf(stderr, "unable to build extent mapping\n");
break;
btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
- btrfs_release_path(chunk_root, &path);
+ btrfs_release_path(&path);
}
- btrfs_release_path(chunk_root, &path);
+ btrfs_release_path(&path);
offset = 0;
num_bytes = 0;
if (bytenr >= total_bytes)
break;
ret = pwrite(fd, buf, sectorsize, bytenr);
+ if (ret != sectorsize) {
+ fprintf(stderr,
+ "error during zeroing supreblock %d: %d\n",
+ i, ret);
+ goto fail;
+ }
}
sb_bytenr = (u64)-1;
static void print_usage(void)
{
- printf("usage: btrfs-convert [-d] [-i] [-n] [-r] device\n");
- printf("\t-d disable data checksum\n");
- printf("\t-i ignore xattrs and ACLs\n");
- printf("\t-n disable packing of small files\n");
- printf("\t-r roll back to ext2fs\n");
+ printf("usage: btrfs-convert [options] device\n");
+ printf("options:\n");
+ printf("\t-d|--no-datasum disable data checksum, sets NODATASUM\n");
+ printf("\t-i|--no-xattr ignore xattrs and ACLs\n");
+ printf("\t-n|--no-inline disable inlining of small files to metadata\n");
+ printf("\t-N|--nodesize SIZE set filesystem metadata nodesize\n");
+ printf("\t-r|--rollback roll back to ext2fs\n");
+ printf("\t-l|--label LABEL set filesystem label\n");
+ printf("\t-L|--copy-label use label from converted filesystem\n");
+ printf("\t-p|--progress show converting progress (default)\n");
+ printf("\t-O|--features LIST comma separated list of filesystem features\n");
+ printf("\t--no-progress show only overview, not the detailed progress\n");
}
int main(int argc, char *argv[])
int packing = 1;
int noxattr = 0;
int datacsum = 1;
+ u32 nodesize = max_t(u32, sysconf(_SC_PAGESIZE),
+ BTRFS_MKFS_DEFAULT_NODE_SIZE);
int rollback = 0;
+ int copylabel = 0;
+ int usage_error = 0;
+ int progress = 1;
char *file;
+ char fslabel[BTRFS_LABEL_SIZE];
+ u64 features = BTRFS_MKFS_DEFAULT_FEATURES;
+
while(1) {
- int c = getopt(argc, argv, "dinr");
+ enum { GETOPT_VAL_NO_PROGRESS = 256 };
+ static const struct option long_options[] = {
+ { "no-progress", no_argument, NULL,
+ GETOPT_VAL_NO_PROGRESS },
+ { "no-datasum", no_argument, NULL, 'd' },
+ { "no-inline", no_argument, NULL, 'n' },
+ { "no-xattr", no_argument, NULL, 'i' },
+ { "rollback", no_argument, NULL, 'r' },
+ { "features", required_argument, NULL, 'O' },
+ { "progress", no_argument, NULL, 'p' },
+ { "label", required_argument, NULL, 'l' },
+ { "copy-label", no_argument, NULL, 'L' },
+ { "nodesize", required_argument, NULL, 'N' },
+ { "help", no_argument, NULL, GETOPT_VAL_HELP},
+ { NULL, 0, NULL, 0 }
+ };
+ int c = getopt_long(argc, argv, "dinN:rl:LpO:", long_options, NULL);
+
if (c < 0)
break;
switch(c) {
case 'n':
packing = 0;
break;
+ case 'N':
+ nodesize = parse_size(optarg);
+ break;
case 'r':
rollback = 1;
break;
+ case 'l':
+ copylabel = -1;
+ if (strlen(optarg) >= BTRFS_LABEL_SIZE) {
+ fprintf(stderr,
+ "WARNING: label too long, trimmed to %d bytes\n",
+ BTRFS_LABEL_SIZE - 1);
+ }
+ strncpy(fslabel, optarg, BTRFS_LABEL_SIZE - 1);
+ fslabel[BTRFS_LABEL_SIZE - 1] = 0;
+ break;
+ case 'L':
+ copylabel = 1;
+ break;
+ case 'p':
+ progress = 1;
+ break;
+ case 'O': {
+ char *orig = strdup(optarg);
+ char *tmp = orig;
+
+ tmp = btrfs_parse_fs_features(tmp, &features);
+ if (tmp) {
+ fprintf(stderr,
+ "Unrecognized filesystem feature '%s'\n",
+ tmp);
+ free(orig);
+ exit(1);
+ }
+ free(orig);
+ if (features & BTRFS_FEATURE_LIST_ALL) {
+ btrfs_list_all_fs_features(
+ ~BTRFS_CONVERT_ALLOWED_FEATURES);
+ exit(0);
+ }
+ if (features & ~BTRFS_CONVERT_ALLOWED_FEATURES) {
+ char buf[64];
+
+ btrfs_parse_features_to_string(buf,
+ features & ~BTRFS_CONVERT_ALLOWED_FEATURES);
+ fprintf(stderr,
+ "ERROR: features not allowed for convert: %s\n",
+ buf);
+ exit(1);
+ }
+
+ break;
+ }
+ case GETOPT_VAL_NO_PROGRESS:
+ progress = 0;
+ break;
+ case GETOPT_VAL_HELP:
default:
print_usage();
- return 1;
+ return c != GETOPT_VAL_HELP;
}
}
argc = argc - optind;
- if (argc != 1) {
+ set_argv0(argv);
+ if (check_argc_exact(argc, 1)) {
+ print_usage();
+ return 1;
+ }
+
+ if (rollback && (!datacsum || noxattr || !packing)) {
+ fprintf(stderr,
+ "Usage error: -d, -i, -n options do not apply to rollback\n");
+ usage_error++;
+ }
+
+ if (usage_error) {
print_usage();
return 1;
}
file = argv[optind];
- if (check_mounted(file)) {
+ ret = check_mounted(file);
+ if (ret < 0) {
+ fprintf(stderr, "Could not check mount status: %s\n",
+ strerror(-ret));
+ return 1;
+ } else if (ret) {
fprintf(stderr, "%s is mounted\n", file);
return 1;
}
if (rollback) {
- ret = do_rollback(file, 0);
+ ret = do_rollback(file);
} else {
- ret = do_convert(file, datacsum, packing, noxattr);
+ ret = do_convert(file, datacsum, packing, noxattr, nodesize,
+ copylabel, fslabel, progress, features);
}
if (ret)
return 1;
projects / platform / upstream / btrfs-progs.git / blobdiff