2 * Copyright (C) 2007 Oracle. All rights reserved.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
19 #include "kerncompat.h"
21 #include <sys/ioctl.h>
22 #include <sys/mount.h>
25 #include <sys/types.h>
30 #include <uuid/uuid.h>
31 #include <linux/limits.h>
36 #include "transaction.h"
39 #include "task-utils.h"
40 #include <ext2fs/ext2_fs.h>
41 #include <ext2fs/ext2fs.h>
42 #include <ext2fs/ext2_ext_attr.h>
44 #define INO_OFFSET (BTRFS_FIRST_FREE_OBJECTID - EXT2_ROOT_INO)
45 #define EXT2_IMAGE_SUBVOL_OBJECTID BTRFS_FIRST_FREE_OBJECTID
48 uint32_t max_copy_inodes
;
49 uint32_t cur_copy_inodes
;
50 struct task_info
*info
;
53 static void *print_copied_inodes(void *p
)
55 struct task_ctx
*priv
= p
;
56 const char work_indicator
[] = { '.', 'o', 'O', 'o' };
59 task_period_start(priv
->info
, 1000 /* 1s */);
62 printf("copy inodes [%c] [%10d/%10d]\r",
63 work_indicator
[count
% 4], priv
->cur_copy_inodes
,
64 priv
->max_copy_inodes
);
66 task_period_wait(priv
->info
);
72 static int after_copied_inodes(void *p
)
74 struct task_ctx
*priv
= p
;
77 task_period_stop(priv
->info
);
83 * Open Ext2fs in readonly mode, read block allocation bitmap and
84 * inode bitmap into memory.
86 static int open_ext2fs(const char *name
, ext2_filsys
*ret_fs
)
91 ret
= ext2fs_open(name
, 0, 0, 0, unix_io_manager
, &ext2_fs
);
93 fprintf(stderr
, "ext2fs_open: %s\n", error_message(ret
));
96 ret
= ext2fs_read_inode_bitmap(ext2_fs
);
98 fprintf(stderr
, "ext2fs_read_inode_bitmap: %s\n",
102 ret
= ext2fs_read_block_bitmap(ext2_fs
);
104 fprintf(stderr
, "ext2fs_read_block_bitmap: %s\n",
109 * search each block group for a free inode. this set up
110 * uninit block/inode bitmaps appropriately.
113 while (ino
<= ext2_fs
->super
->s_inodes_count
) {
115 ext2fs_new_inode(ext2_fs
, ino
, 0, NULL
, &foo
);
116 ino
+= EXT2_INODES_PER_GROUP(ext2_fs
->super
);
125 static int close_ext2fs(ext2_filsys fs
)
131 static int ext2_alloc_block(ext2_filsys fs
, u64 goal
, u64
*block_ret
)
135 if (!ext2fs_new_block(fs
, goal
, NULL
, &block
)) {
136 ext2fs_fast_mark_block_bitmap(fs
->block_map
, block
);
143 static int ext2_free_block(ext2_filsys fs
, u64 block
)
145 BUG_ON(block
!= (blk_t
)block
);
146 ext2fs_fast_unmark_block_bitmap(fs
->block_map
, block
);
150 static int cache_free_extents(struct btrfs_root
*root
, ext2_filsys ext2_fs
)
156 u64 blocksize
= ext2_fs
->blocksize
;
158 block
= ext2_fs
->super
->s_first_data_block
;
159 for (; block
< ext2_fs
->super
->s_blocks_count
; block
++) {
160 if (ext2fs_fast_test_block_bitmap(ext2_fs
->block_map
, block
))
162 bytenr
= block
* blocksize
;
163 ret
= set_extent_dirty(&root
->fs_info
->free_space_cache
,
164 bytenr
, bytenr
+ blocksize
- 1, 0);
168 for (i
= 0; i
< BTRFS_SUPER_MIRROR_MAX
; i
++) {
169 bytenr
= btrfs_sb_offset(i
);
170 bytenr
&= ~((u64
)BTRFS_STRIPE_LEN
- 1);
171 if (bytenr
>= blocksize
* ext2_fs
->super
->s_blocks_count
)
173 clear_extent_dirty(&root
->fs_info
->free_space_cache
, bytenr
,
174 bytenr
+ BTRFS_STRIPE_LEN
- 1, 0);
177 clear_extent_dirty(&root
->fs_info
->free_space_cache
,
178 0, BTRFS_SUPER_INFO_OFFSET
- 1, 0);
183 static int custom_alloc_extent(struct btrfs_root
*root
, u64 num_bytes
,
184 u64 hint_byte
, struct btrfs_key
*ins
)
188 u64 last
= hint_byte
;
191 struct btrfs_block_group_cache
*cache
;
194 ret
= find_first_extent_bit(&root
->fs_info
->free_space_cache
,
195 last
, &start
, &end
, EXTENT_DIRTY
);
197 if (wrapped
++ == 0) {
205 start
= max(last
, start
);
207 if (last
- start
< num_bytes
)
210 last
= start
+ num_bytes
;
211 if (test_range_bit(&root
->fs_info
->pinned_extents
,
212 start
, last
- 1, EXTENT_DIRTY
, 0))
215 cache
= btrfs_lookup_block_group(root
->fs_info
, start
);
217 if (cache
->flags
& BTRFS_BLOCK_GROUP_SYSTEM
||
218 last
> cache
->key
.objectid
+ cache
->key
.offset
) {
219 last
= cache
->key
.objectid
+ cache
->key
.offset
;
223 clear_extent_dirty(&root
->fs_info
->free_space_cache
,
224 start
, start
+ num_bytes
- 1, 0);
226 ins
->objectid
= start
;
227 ins
->offset
= num_bytes
;
228 ins
->type
= BTRFS_EXTENT_ITEM_KEY
;
232 fprintf(stderr
, "not enough free space\n");
236 static int intersect_with_sb(u64 bytenr
, u64 num_bytes
)
241 for (i
= 0; i
< BTRFS_SUPER_MIRROR_MAX
; i
++) {
242 offset
= btrfs_sb_offset(i
);
243 offset
&= ~((u64
)BTRFS_STRIPE_LEN
- 1);
245 if (bytenr
< offset
+ BTRFS_STRIPE_LEN
&&
246 bytenr
+ num_bytes
> offset
)
252 static int custom_free_extent(struct btrfs_root
*root
, u64 bytenr
,
255 return intersect_with_sb(bytenr
, num_bytes
);
258 static struct btrfs_extent_ops extent_ops
= {
259 .alloc_extent
= custom_alloc_extent
,
260 .free_extent
= custom_free_extent
,
263 struct dir_iterate_data
{
264 struct btrfs_trans_handle
*trans
;
265 struct btrfs_root
*root
;
266 struct btrfs_inode_item
*inode
;
273 static u8 filetype_conversion_table
[EXT2_FT_MAX
] = {
274 [EXT2_FT_UNKNOWN
] = BTRFS_FT_UNKNOWN
,
275 [EXT2_FT_REG_FILE
] = BTRFS_FT_REG_FILE
,
276 [EXT2_FT_DIR
] = BTRFS_FT_DIR
,
277 [EXT2_FT_CHRDEV
] = BTRFS_FT_CHRDEV
,
278 [EXT2_FT_BLKDEV
] = BTRFS_FT_BLKDEV
,
279 [EXT2_FT_FIFO
] = BTRFS_FT_FIFO
,
280 [EXT2_FT_SOCK
] = BTRFS_FT_SOCK
,
281 [EXT2_FT_SYMLINK
] = BTRFS_FT_SYMLINK
,
284 static int dir_iterate_proc(ext2_ino_t dir
, int entry
,
285 struct ext2_dir_entry
*dirent
,
286 int offset
, int blocksize
,
287 char *buf
,void *priv_data
)
293 char dotdot
[] = "..";
294 struct btrfs_key location
;
295 struct dir_iterate_data
*idata
= (struct dir_iterate_data
*)priv_data
;
298 name_len
= dirent
->name_len
& 0xFF;
300 objectid
= dirent
->inode
+ INO_OFFSET
;
301 if (!strncmp(dirent
->name
, dotdot
, name_len
)) {
303 BUG_ON(idata
->parent
!= 0);
304 idata
->parent
= objectid
;
308 if (dirent
->inode
< EXT2_GOOD_OLD_FIRST_INO
)
311 location
.objectid
= objectid
;
313 btrfs_set_key_type(&location
, BTRFS_INODE_ITEM_KEY
);
315 file_type
= dirent
->name_len
>> 8;
316 BUG_ON(file_type
> EXT2_FT_SYMLINK
);
317 ret
= btrfs_insert_dir_item(idata
->trans
, idata
->root
,
318 dirent
->name
, name_len
,
319 idata
->objectid
, &location
,
320 filetype_conversion_table
[file_type
],
324 ret
= btrfs_insert_inode_ref(idata
->trans
, idata
->root
,
325 dirent
->name
, name_len
,
326 objectid
, idata
->objectid
,
331 inode_size
= btrfs_stack_inode_size(idata
->inode
) +
333 btrfs_set_stack_inode_size(idata
->inode
, inode_size
);
336 idata
->errcode
= ret
;
340 static int create_dir_entries(struct btrfs_trans_handle
*trans
,
341 struct btrfs_root
*root
, u64 objectid
,
342 struct btrfs_inode_item
*btrfs_inode
,
343 ext2_filsys ext2_fs
, ext2_ino_t ext2_ino
)
347 struct dir_iterate_data data
= {
350 .inode
= btrfs_inode
,
351 .objectid
= objectid
,
357 err
= ext2fs_dir_iterate2(ext2_fs
, ext2_ino
, 0, NULL
,
358 dir_iterate_proc
, &data
);
362 if (ret
== 0 && data
.parent
== objectid
) {
363 ret
= btrfs_insert_inode_ref(trans
, root
, "..", 2,
364 objectid
, objectid
, 0);
368 fprintf(stderr
, "ext2fs_dir_iterate2: %s\n", error_message(err
));
372 static int read_disk_extent(struct btrfs_root
*root
, u64 bytenr
,
373 u32 num_bytes
, char *buffer
)
376 struct btrfs_fs_devices
*fs_devs
= root
->fs_info
->fs_devices
;
378 ret
= pread(fs_devs
->latest_bdev
, buffer
, num_bytes
, bytenr
);
379 if (ret
!= num_bytes
)
388 static int csum_disk_extent(struct btrfs_trans_handle
*trans
,
389 struct btrfs_root
*root
,
390 u64 disk_bytenr
, u64 num_bytes
)
392 u32 blocksize
= root
->sectorsize
;
397 buffer
= malloc(blocksize
);
400 for (offset
= 0; offset
< num_bytes
; offset
+= blocksize
) {
401 ret
= read_disk_extent(root
, disk_bytenr
+ offset
,
405 ret
= btrfs_csum_file_block(trans
,
406 root
->fs_info
->csum_root
,
407 disk_bytenr
+ num_bytes
,
408 disk_bytenr
+ offset
,
417 static int record_file_blocks(struct btrfs_trans_handle
*trans
,
418 struct btrfs_root
*root
, u64 objectid
,
419 struct btrfs_inode_item
*inode
,
420 u64 file_block
, u64 disk_block
,
421 u64 num_blocks
, int checksum
)
424 u64 file_pos
= file_block
* root
->sectorsize
;
425 u64 disk_bytenr
= disk_block
* root
->sectorsize
;
426 u64 num_bytes
= num_blocks
* root
->sectorsize
;
427 ret
= btrfs_record_file_extent(trans
, root
, objectid
, inode
, file_pos
,
428 disk_bytenr
, num_bytes
);
430 if (ret
|| !checksum
|| disk_bytenr
== 0)
433 return csum_disk_extent(trans
, root
, disk_bytenr
, num_bytes
);
436 struct blk_iterate_data
{
437 struct btrfs_trans_handle
*trans
;
438 struct btrfs_root
*root
;
439 struct btrfs_inode_item
*inode
;
449 static int block_iterate_proc(ext2_filsys ext2_fs
,
450 u64 disk_block
, u64 file_block
,
451 struct blk_iterate_data
*idata
)
456 struct btrfs_root
*root
= idata
->root
;
457 struct btrfs_trans_handle
*trans
= idata
->trans
;
458 struct btrfs_block_group_cache
*cache
;
459 u64 bytenr
= disk_block
* root
->sectorsize
;
461 sb_region
= intersect_with_sb(bytenr
, root
->sectorsize
);
462 do_barrier
= sb_region
|| disk_block
>= idata
->boundary
;
463 if ((idata
->num_blocks
> 0 && do_barrier
) ||
464 (file_block
> idata
->first_block
+ idata
->num_blocks
) ||
465 (disk_block
!= idata
->disk_block
+ idata
->num_blocks
)) {
466 if (idata
->num_blocks
> 0) {
467 ret
= record_file_blocks(trans
, root
, idata
->objectid
,
468 idata
->inode
, idata
->first_block
,
469 idata
->disk_block
, idata
->num_blocks
,
473 idata
->first_block
+= idata
->num_blocks
;
474 idata
->num_blocks
= 0;
476 if (file_block
> idata
->first_block
) {
477 ret
= record_file_blocks(trans
, root
, idata
->objectid
,
478 idata
->inode
, idata
->first_block
,
479 0, file_block
- idata
->first_block
,
486 bytenr
+= BTRFS_STRIPE_LEN
- 1;
487 bytenr
&= ~((u64
)BTRFS_STRIPE_LEN
- 1);
489 cache
= btrfs_lookup_block_group(root
->fs_info
, bytenr
);
491 bytenr
= cache
->key
.objectid
+ cache
->key
.offset
;
494 idata
->first_block
= file_block
;
495 idata
->disk_block
= disk_block
;
496 idata
->boundary
= bytenr
/ root
->sectorsize
;
501 idata
->errcode
= ret
;
505 static int __block_iterate_proc(ext2_filsys fs
, blk_t
*blocknr
,
506 e2_blkcnt_t blockcnt
, blk_t ref_block
,
507 int ref_offset
, void *priv_data
)
509 struct blk_iterate_data
*idata
;
510 idata
= (struct blk_iterate_data
*)priv_data
;
511 return block_iterate_proc(fs
, *blocknr
, blockcnt
, idata
);
515 * traverse file's data blocks, record these data blocks as file extents.
517 static int create_file_extents(struct btrfs_trans_handle
*trans
,
518 struct btrfs_root
*root
, u64 objectid
,
519 struct btrfs_inode_item
*btrfs_inode
,
520 ext2_filsys ext2_fs
, ext2_ino_t ext2_ino
,
521 int datacsum
, int packing
)
527 u32 sectorsize
= root
->sectorsize
;
528 u64 inode_size
= btrfs_stack_inode_size(btrfs_inode
);
529 struct blk_iterate_data data
= {
532 .inode
= btrfs_inode
,
533 .objectid
= objectid
,
538 .checksum
= datacsum
,
541 err
= ext2fs_block_iterate2(ext2_fs
, ext2_ino
, BLOCK_FLAG_DATA_ONLY
,
542 NULL
, __block_iterate_proc
, &data
);
548 if (packing
&& data
.first_block
== 0 && data
.num_blocks
> 0 &&
549 inode_size
<= BTRFS_MAX_INLINE_DATA_SIZE(root
)) {
550 u64 num_bytes
= data
.num_blocks
* sectorsize
;
551 u64 disk_bytenr
= data
.disk_block
* sectorsize
;
554 buffer
= malloc(num_bytes
);
557 ret
= read_disk_extent(root
, disk_bytenr
, num_bytes
, buffer
);
560 if (num_bytes
> inode_size
)
561 num_bytes
= inode_size
;
562 ret
= btrfs_insert_inline_extent(trans
, root
, objectid
,
563 0, buffer
, num_bytes
);
566 nbytes
= btrfs_stack_inode_nbytes(btrfs_inode
) + num_bytes
;
567 btrfs_set_stack_inode_nbytes(btrfs_inode
, nbytes
);
568 } else if (data
.num_blocks
> 0) {
569 ret
= record_file_blocks(trans
, root
, objectid
, btrfs_inode
,
570 data
.first_block
, data
.disk_block
,
571 data
.num_blocks
, data
.checksum
);
575 data
.first_block
+= data
.num_blocks
;
576 last_block
= (inode_size
+ sectorsize
- 1) / sectorsize
;
577 if (last_block
> data
.first_block
) {
578 ret
= record_file_blocks(trans
, root
, objectid
, btrfs_inode
,
579 data
.first_block
, 0, last_block
-
580 data
.first_block
, data
.checksum
);
586 fprintf(stderr
, "ext2fs_block_iterate2: %s\n", error_message(err
));
590 static int create_symbol_link(struct btrfs_trans_handle
*trans
,
591 struct btrfs_root
*root
, u64 objectid
,
592 struct btrfs_inode_item
*btrfs_inode
,
593 ext2_filsys ext2_fs
, ext2_ino_t ext2_ino
,
594 struct ext2_inode
*ext2_inode
)
598 u64 inode_size
= btrfs_stack_inode_size(btrfs_inode
);
599 if (ext2fs_inode_data_blocks(ext2_fs
, ext2_inode
)) {
600 btrfs_set_stack_inode_size(btrfs_inode
, inode_size
+ 1);
601 ret
= create_file_extents(trans
, root
, objectid
, btrfs_inode
,
602 ext2_fs
, ext2_ino
, 1, 1);
603 btrfs_set_stack_inode_size(btrfs_inode
, inode_size
);
607 pathname
= (char *)&(ext2_inode
->i_block
[0]);
608 BUG_ON(pathname
[inode_size
] != 0);
609 ret
= btrfs_insert_inline_extent(trans
, root
, objectid
, 0,
610 pathname
, inode_size
+ 1);
611 btrfs_set_stack_inode_nbytes(btrfs_inode
, inode_size
+ 1);
616 * Following xattr/acl related codes are based on codes in
617 * fs/ext3/xattr.c and fs/ext3/acl.c
619 #define EXT2_XATTR_BHDR(ptr) ((struct ext2_ext_attr_header *)(ptr))
620 #define EXT2_XATTR_BFIRST(ptr) \
621 ((struct ext2_ext_attr_entry *)(EXT2_XATTR_BHDR(ptr) + 1))
622 #define EXT2_XATTR_IHDR(inode) \
623 ((struct ext2_ext_attr_header *) ((void *)(inode) + \
624 EXT2_GOOD_OLD_INODE_SIZE + (inode)->i_extra_isize))
625 #define EXT2_XATTR_IFIRST(inode) \
626 ((struct ext2_ext_attr_entry *) ((void *)EXT2_XATTR_IHDR(inode) + \
627 sizeof(EXT2_XATTR_IHDR(inode)->h_magic)))
629 static int ext2_xattr_check_names(struct ext2_ext_attr_entry
*entry
,
632 struct ext2_ext_attr_entry
*next
;
634 while (!EXT2_EXT_IS_LAST_ENTRY(entry
)) {
635 next
= EXT2_EXT_ATTR_NEXT(entry
);
636 if ((void *)next
>= end
)
643 static int ext2_xattr_check_block(const char *buf
, size_t size
)
646 struct ext2_ext_attr_header
*header
= EXT2_XATTR_BHDR(buf
);
648 if (header
->h_magic
!= EXT2_EXT_ATTR_MAGIC
||
649 header
->h_blocks
!= 1)
651 error
= ext2_xattr_check_names(EXT2_XATTR_BFIRST(buf
), buf
+ size
);
655 static int ext2_xattr_check_entry(struct ext2_ext_attr_entry
*entry
,
658 size_t value_size
= entry
->e_value_size
;
660 if (entry
->e_value_block
!= 0 || value_size
> size
||
661 entry
->e_value_offs
+ value_size
> size
)
666 #define EXT2_ACL_VERSION 0x0001
677 } ext2_acl_entry_short
;
683 static inline int ext2_acl_count(size_t size
)
686 size
-= sizeof(ext2_acl_header
);
687 s
= size
- 4 * sizeof(ext2_acl_entry_short
);
689 if (size
% sizeof(ext2_acl_entry_short
))
691 return size
/ sizeof(ext2_acl_entry_short
);
693 if (s
% sizeof(ext2_acl_entry
))
695 return s
/ sizeof(ext2_acl_entry
) + 4;
699 #define ACL_EA_VERSION 0x0002
709 acl_ea_entry a_entries
[0];
712 static inline size_t acl_ea_size(int count
)
714 return sizeof(acl_ea_header
) + count
* sizeof(acl_ea_entry
);
717 static int ext2_acl_to_xattr(void *dst
, const void *src
,
718 size_t dst_size
, size_t src_size
)
721 const void *end
= src
+ src_size
;
722 acl_ea_header
*ext_acl
= (acl_ea_header
*)dst
;
723 acl_ea_entry
*dst_entry
= ext_acl
->a_entries
;
724 ext2_acl_entry
*src_entry
;
726 if (src_size
< sizeof(ext2_acl_header
))
728 if (((ext2_acl_header
*)src
)->a_version
!=
729 cpu_to_le32(EXT2_ACL_VERSION
))
731 src
+= sizeof(ext2_acl_header
);
732 count
= ext2_acl_count(src_size
);
736 BUG_ON(dst_size
< acl_ea_size(count
));
737 ext_acl
->a_version
= cpu_to_le32(ACL_EA_VERSION
);
738 for (i
= 0; i
< count
; i
++, dst_entry
++) {
739 src_entry
= (ext2_acl_entry
*)src
;
740 if (src
+ sizeof(ext2_acl_entry_short
) > end
)
742 dst_entry
->e_tag
= src_entry
->e_tag
;
743 dst_entry
->e_perm
= src_entry
->e_perm
;
744 switch (le16_to_cpu(src_entry
->e_tag
)) {
749 src
+= sizeof(ext2_acl_entry_short
);
750 dst_entry
->e_id
= cpu_to_le32(ACL_UNDEFINED_ID
);
754 src
+= sizeof(ext2_acl_entry
);
757 dst_entry
->e_id
= src_entry
->e_id
;
770 static char *xattr_prefix_table
[] = {
772 [2] = "system.posix_acl_access",
773 [3] = "system.posix_acl_default",
778 static int copy_single_xattr(struct btrfs_trans_handle
*trans
,
779 struct btrfs_root
*root
, u64 objectid
,
780 struct ext2_ext_attr_entry
*entry
,
781 const void *data
, u32 datalen
)
786 void *databuf
= NULL
;
787 char namebuf
[XATTR_NAME_MAX
+ 1];
789 name_index
= entry
->e_name_index
;
790 if (name_index
>= ARRAY_SIZE(xattr_prefix_table
) ||
791 xattr_prefix_table
[name_index
] == NULL
)
793 name_len
= strlen(xattr_prefix_table
[name_index
]) +
795 if (name_len
>= sizeof(namebuf
))
798 if (name_index
== 2 || name_index
== 3) {
799 size_t bufsize
= acl_ea_size(ext2_acl_count(datalen
));
800 databuf
= malloc(bufsize
);
803 ret
= ext2_acl_to_xattr(databuf
, data
, bufsize
, datalen
);
809 strncpy(namebuf
, xattr_prefix_table
[name_index
], XATTR_NAME_MAX
);
810 strncat(namebuf
, EXT2_EXT_ATTR_NAME(entry
), entry
->e_name_len
);
811 if (name_len
+ datalen
> BTRFS_LEAF_DATA_SIZE(root
) -
812 sizeof(struct btrfs_item
) - sizeof(struct btrfs_dir_item
)) {
813 fprintf(stderr
, "skip large xattr on inode %Lu name %.*s\n",
814 objectid
- INO_OFFSET
, name_len
, namebuf
);
817 ret
= btrfs_insert_xattr_item(trans
, root
, namebuf
, name_len
,
818 data
, datalen
, objectid
);
824 static int copy_extended_attrs(struct btrfs_trans_handle
*trans
,
825 struct btrfs_root
*root
, u64 objectid
,
826 struct btrfs_inode_item
*btrfs_inode
,
827 ext2_filsys ext2_fs
, ext2_ino_t ext2_ino
)
833 u32 block_size
= ext2_fs
->blocksize
;
834 u32 inode_size
= EXT2_INODE_SIZE(ext2_fs
->super
);
835 struct ext2_inode_large
*ext2_inode
;
836 struct ext2_ext_attr_entry
*entry
;
839 char inode_buf
[EXT2_GOOD_OLD_INODE_SIZE
];
841 if (inode_size
<= EXT2_GOOD_OLD_INODE_SIZE
) {
842 ext2_inode
= (struct ext2_inode_large
*)inode_buf
;
844 ext2_inode
= (struct ext2_inode_large
*)malloc(inode_size
);
848 err
= ext2fs_read_inode_full(ext2_fs
, ext2_ino
, (void *)ext2_inode
,
851 fprintf(stderr
, "ext2fs_read_inode_full: %s\n",
857 if (ext2_ino
> ext2_fs
->super
->s_first_ino
&&
858 inode_size
> EXT2_GOOD_OLD_INODE_SIZE
) {
859 if (EXT2_GOOD_OLD_INODE_SIZE
+
860 ext2_inode
->i_extra_isize
> inode_size
) {
864 if (ext2_inode
->i_extra_isize
!= 0 &&
865 EXT2_XATTR_IHDR(ext2_inode
)->h_magic
==
866 EXT2_EXT_ATTR_MAGIC
) {
872 void *end
= (void *)ext2_inode
+ inode_size
;
873 entry
= EXT2_XATTR_IFIRST(ext2_inode
);
874 total
= end
- (void *)entry
;
875 ret
= ext2_xattr_check_names(entry
, end
);
878 while (!EXT2_EXT_IS_LAST_ENTRY(entry
)) {
879 ret
= ext2_xattr_check_entry(entry
, total
);
882 data
= (void *)EXT2_XATTR_IFIRST(ext2_inode
) +
884 datalen
= entry
->e_value_size
;
885 ret
= copy_single_xattr(trans
, root
, objectid
,
886 entry
, data
, datalen
);
889 entry
= EXT2_EXT_ATTR_NEXT(entry
);
893 if (ext2_inode
->i_file_acl
== 0)
896 buffer
= malloc(block_size
);
901 err
= ext2fs_read_ext_attr(ext2_fs
, ext2_inode
->i_file_acl
, buffer
);
903 fprintf(stderr
, "ext2fs_read_ext_attr: %s\n",
908 ret
= ext2_xattr_check_block(buffer
, block_size
);
912 entry
= EXT2_XATTR_BFIRST(buffer
);
913 while (!EXT2_EXT_IS_LAST_ENTRY(entry
)) {
914 ret
= ext2_xattr_check_entry(entry
, block_size
);
917 data
= buffer
+ entry
->e_value_offs
;
918 datalen
= entry
->e_value_size
;
919 ret
= copy_single_xattr(trans
, root
, objectid
,
920 entry
, data
, datalen
);
923 entry
= EXT2_EXT_ATTR_NEXT(entry
);
927 if ((void *)ext2_inode
!= inode_buf
)
932 #define MKDEV(ma, mi) (((ma) << MINORBITS) | (mi))
934 static inline dev_t
old_decode_dev(u16 val
)
936 return MKDEV((val
>> 8) & 255, val
& 255);
939 static inline dev_t
new_decode_dev(u32 dev
)
941 unsigned major
= (dev
& 0xfff00) >> 8;
942 unsigned minor
= (dev
& 0xff) | ((dev
>> 12) & 0xfff00);
943 return MKDEV(major
, minor
);
946 static int copy_inode_item(struct btrfs_inode_item
*dst
,
947 struct ext2_inode
*src
, u32 blocksize
)
949 btrfs_set_stack_inode_generation(dst
, 1);
950 btrfs_set_stack_inode_size(dst
, src
->i_size
);
951 btrfs_set_stack_inode_nbytes(dst
, 0);
952 btrfs_set_stack_inode_block_group(dst
, 0);
953 btrfs_set_stack_inode_nlink(dst
, src
->i_links_count
);
954 btrfs_set_stack_inode_uid(dst
, src
->i_uid
| (src
->i_uid_high
<< 16));
955 btrfs_set_stack_inode_gid(dst
, src
->i_gid
| (src
->i_gid_high
<< 16));
956 btrfs_set_stack_inode_mode(dst
, src
->i_mode
);
957 btrfs_set_stack_inode_rdev(dst
, 0);
958 btrfs_set_stack_inode_flags(dst
, 0);
959 btrfs_set_stack_timespec_sec(&dst
->atime
, src
->i_atime
);
960 btrfs_set_stack_timespec_nsec(&dst
->atime
, 0);
961 btrfs_set_stack_timespec_sec(&dst
->ctime
, src
->i_ctime
);
962 btrfs_set_stack_timespec_nsec(&dst
->ctime
, 0);
963 btrfs_set_stack_timespec_sec(&dst
->mtime
, src
->i_mtime
);
964 btrfs_set_stack_timespec_nsec(&dst
->mtime
, 0);
965 btrfs_set_stack_timespec_sec(&dst
->otime
, 0);
966 btrfs_set_stack_timespec_nsec(&dst
->otime
, 0);
968 if (S_ISDIR(src
->i_mode
)) {
969 btrfs_set_stack_inode_size(dst
, 0);
970 btrfs_set_stack_inode_nlink(dst
, 1);
972 if (S_ISREG(src
->i_mode
)) {
973 btrfs_set_stack_inode_size(dst
, (u64
)src
->i_size_high
<< 32 |
976 if (!S_ISREG(src
->i_mode
) && !S_ISDIR(src
->i_mode
) &&
977 !S_ISLNK(src
->i_mode
)) {
978 if (src
->i_block
[0]) {
979 btrfs_set_stack_inode_rdev(dst
,
980 old_decode_dev(src
->i_block
[0]));
982 btrfs_set_stack_inode_rdev(dst
,
983 new_decode_dev(src
->i_block
[1]));
990 * copy a single inode. do all the required works, such as cloning
991 * inode item, creating file extents and creating directory entries.
993 static int copy_single_inode(struct btrfs_trans_handle
*trans
,
994 struct btrfs_root
*root
, u64 objectid
,
995 ext2_filsys ext2_fs
, ext2_ino_t ext2_ino
,
996 struct ext2_inode
*ext2_inode
,
997 int datacsum
, int packing
, int noxattr
)
1000 struct btrfs_key inode_key
;
1001 struct btrfs_inode_item btrfs_inode
;
1003 if (ext2_inode
->i_links_count
== 0)
1006 copy_inode_item(&btrfs_inode
, ext2_inode
, ext2_fs
->blocksize
);
1007 if (!datacsum
&& S_ISREG(ext2_inode
->i_mode
)) {
1008 u32 flags
= btrfs_stack_inode_flags(&btrfs_inode
) |
1009 BTRFS_INODE_NODATASUM
;
1010 btrfs_set_stack_inode_flags(&btrfs_inode
, flags
);
1013 switch (ext2_inode
->i_mode
& S_IFMT
) {
1015 ret
= create_file_extents(trans
, root
, objectid
, &btrfs_inode
,
1016 ext2_fs
, ext2_ino
, datacsum
, packing
);
1019 ret
= create_dir_entries(trans
, root
, objectid
, &btrfs_inode
,
1023 ret
= create_symbol_link(trans
, root
, objectid
, &btrfs_inode
,
1024 ext2_fs
, ext2_ino
, ext2_inode
);
1034 ret
= copy_extended_attrs(trans
, root
, objectid
, &btrfs_inode
,
1039 inode_key
.objectid
= objectid
;
1040 inode_key
.offset
= 0;
1041 btrfs_set_key_type(&inode_key
, BTRFS_INODE_ITEM_KEY
);
1042 ret
= btrfs_insert_inode(trans
, root
, objectid
, &btrfs_inode
);
1046 static int copy_disk_extent(struct btrfs_root
*root
, u64 dst_bytenr
,
1047 u64 src_bytenr
, u32 num_bytes
)
1051 struct btrfs_fs_devices
*fs_devs
= root
->fs_info
->fs_devices
;
1053 buffer
= malloc(num_bytes
);
1056 ret
= pread(fs_devs
->latest_bdev
, buffer
, num_bytes
, src_bytenr
);
1057 if (ret
!= num_bytes
)
1059 ret
= pwrite(fs_devs
->latest_bdev
, buffer
, num_bytes
, dst_bytenr
);
1060 if (ret
!= num_bytes
)
1070 * scan ext2's inode bitmap and copy all used inodes.
1072 static int copy_inodes(struct btrfs_root
*root
, ext2_filsys ext2_fs
,
1073 int datacsum
, int packing
, int noxattr
, struct task_ctx
*p
)
1077 ext2_inode_scan ext2_scan
;
1078 struct ext2_inode ext2_inode
;
1079 ext2_ino_t ext2_ino
;
1081 struct btrfs_trans_handle
*trans
;
1083 trans
= btrfs_start_transaction(root
, 1);
1086 err
= ext2fs_open_inode_scan(ext2_fs
, 0, &ext2_scan
);
1088 fprintf(stderr
, "ext2fs_open_inode_scan: %s\n", error_message(err
));
1091 while (!(err
= ext2fs_get_next_inode(ext2_scan
, &ext2_ino
,
1093 /* no more inodes */
1096 /* skip special inode in ext2fs */
1097 if (ext2_ino
< EXT2_GOOD_OLD_FIRST_INO
&&
1098 ext2_ino
!= EXT2_ROOT_INO
)
1100 objectid
= ext2_ino
+ INO_OFFSET
;
1101 ret
= copy_single_inode(trans
, root
,
1102 objectid
, ext2_fs
, ext2_ino
,
1103 &ext2_inode
, datacsum
, packing
,
1105 p
->cur_copy_inodes
++;
1108 if (trans
->blocks_used
>= 4096) {
1109 ret
= btrfs_commit_transaction(trans
, root
);
1111 trans
= btrfs_start_transaction(root
, 1);
1116 fprintf(stderr
, "ext2fs_get_next_inode: %s\n", error_message(err
));
1119 ret
= btrfs_commit_transaction(trans
, root
);
1126 * Construct a range of ext2fs image file.
1127 * scan block allocation bitmap, find all blocks used by the ext2fs
1128 * in this range and create file extents that point to these blocks.
1130 * Note: Before calling the function, no file extent points to blocks
1133 static int create_image_file_range(struct btrfs_trans_handle
*trans
,
1134 struct btrfs_root
*root
, u64 objectid
,
1135 struct btrfs_inode_item
*inode
,
1136 u64 start_byte
, u64 end_byte
,
1137 ext2_filsys ext2_fs
)
1139 u32 blocksize
= ext2_fs
->blocksize
;
1140 u32 block
= start_byte
/ blocksize
;
1141 u32 last_block
= (end_byte
+ blocksize
- 1) / blocksize
;
1143 struct blk_iterate_data data
= {
1147 .objectid
= objectid
,
1148 .first_block
= block
,
1151 .boundary
= (u64
)-1,
1155 for (; start_byte
< end_byte
; block
++, start_byte
+= blocksize
) {
1156 if (!ext2fs_fast_test_block_bitmap(ext2_fs
->block_map
, block
))
1158 ret
= block_iterate_proc(NULL
, block
, block
, &data
);
1159 if (ret
& BLOCK_ABORT
) {
1164 if (data
.num_blocks
> 0) {
1165 ret
= record_file_blocks(trans
, root
, objectid
, inode
,
1166 data
.first_block
, data
.disk_block
,
1167 data
.num_blocks
, 0);
1170 data
.first_block
+= data
.num_blocks
;
1172 if (last_block
> data
.first_block
) {
1173 ret
= record_file_blocks(trans
, root
, objectid
, inode
,
1174 data
.first_block
, 0, last_block
-
1175 data
.first_block
, 0);
1183 * Create the ext2fs image file.
1185 static int create_ext2_image(struct btrfs_root
*root
, ext2_filsys ext2_fs
,
1189 struct btrfs_key key
;
1190 struct btrfs_key location
;
1191 struct btrfs_path path
;
1192 struct btrfs_inode_item btrfs_inode
;
1193 struct btrfs_inode_item
*inode_item
;
1194 struct extent_buffer
*leaf
;
1195 struct btrfs_fs_info
*fs_info
= root
->fs_info
;
1196 struct btrfs_root
*extent_root
= fs_info
->extent_root
;
1197 struct btrfs_trans_handle
*trans
;
1198 struct btrfs_extent_item
*ei
;
1199 struct btrfs_extent_inline_ref
*iref
;
1200 struct btrfs_extent_data_ref
*dref
;
1207 u32 sectorsize
= root
->sectorsize
;
1209 total_bytes
= btrfs_super_total_bytes(fs_info
->super_copy
);
1210 first_free
= BTRFS_SUPER_INFO_OFFSET
+ sectorsize
* 2 - 1;
1211 first_free
&= ~((u64
)sectorsize
- 1);
1213 memset(&btrfs_inode
, 0, sizeof(btrfs_inode
));
1214 btrfs_set_stack_inode_generation(&btrfs_inode
, 1);
1215 btrfs_set_stack_inode_size(&btrfs_inode
, total_bytes
);
1216 btrfs_set_stack_inode_nlink(&btrfs_inode
, 1);
1217 btrfs_set_stack_inode_nbytes(&btrfs_inode
, 0);
1218 btrfs_set_stack_inode_mode(&btrfs_inode
, S_IFREG
| 0400);
1219 btrfs_set_stack_inode_flags(&btrfs_inode
, BTRFS_INODE_NODATASUM
|
1220 BTRFS_INODE_READONLY
);
1221 btrfs_init_path(&path
);
1222 trans
= btrfs_start_transaction(root
, 1);
1225 objectid
= btrfs_root_dirid(&root
->root_item
);
1226 ret
= btrfs_find_free_objectid(trans
, root
, objectid
, &objectid
);
1231 * copy blocks covered by extent #0 to new positions. extent #0 is
1232 * special, we can't rely on relocate_extents_range to relocate it.
1234 for (last_byte
= 0; last_byte
< first_free
; last_byte
+= sectorsize
) {
1235 ret
= custom_alloc_extent(root
, sectorsize
, 0, &key
);
1238 ret
= copy_disk_extent(root
, key
.objectid
, last_byte
,
1242 ret
= btrfs_record_file_extent(trans
, root
, objectid
,
1243 &btrfs_inode
, last_byte
,
1244 key
.objectid
, sectorsize
);
1250 key
.objectid
= last_byte
;
1252 btrfs_set_key_type(&key
, BTRFS_EXTENT_ITEM_KEY
);
1253 ret
= btrfs_search_slot(trans
, fs_info
->extent_root
,
1258 leaf
= path
.nodes
[0];
1259 if (path
.slots
[0] >= btrfs_header_nritems(leaf
)) {
1260 ret
= btrfs_next_leaf(extent_root
, &path
);
1265 leaf
= path
.nodes
[0];
1267 btrfs_item_key_to_cpu(leaf
, &key
, path
.slots
[0]);
1268 if (last_byte
> key
.objectid
||
1269 key
.type
!= BTRFS_EXTENT_ITEM_KEY
) {
1274 bytenr
= key
.objectid
;
1275 num_bytes
= key
.offset
;
1276 ei
= btrfs_item_ptr(leaf
, path
.slots
[0],
1277 struct btrfs_extent_item
);
1278 if (!(btrfs_extent_flags(leaf
, ei
) & BTRFS_EXTENT_FLAG_DATA
)) {
1283 BUG_ON(btrfs_item_size_nr(leaf
, path
.slots
[0]) != sizeof(*ei
) +
1284 btrfs_extent_inline_ref_size(BTRFS_EXTENT_DATA_REF_KEY
));
1286 iref
= (struct btrfs_extent_inline_ref
*)(ei
+ 1);
1287 key
.type
= btrfs_extent_inline_ref_type(leaf
, iref
);
1288 BUG_ON(key
.type
!= BTRFS_EXTENT_DATA_REF_KEY
);
1289 dref
= (struct btrfs_extent_data_ref
*)(&iref
->offset
);
1290 if (btrfs_extent_data_ref_root(leaf
, dref
) !=
1291 BTRFS_FS_TREE_OBJECTID
) {
1296 if (bytenr
> last_byte
) {
1297 ret
= create_image_file_range(trans
, root
, objectid
,
1298 &btrfs_inode
, last_byte
,
1303 ret
= btrfs_record_file_extent(trans
, root
, objectid
,
1304 &btrfs_inode
, bytenr
, bytenr
,
1308 last_byte
= bytenr
+ num_bytes
;
1309 btrfs_release_path(&path
);
1311 if (trans
->blocks_used
>= 4096) {
1312 ret
= btrfs_commit_transaction(trans
, root
);
1314 trans
= btrfs_start_transaction(root
, 1);
1318 btrfs_release_path(&path
);
1319 if (total_bytes
> last_byte
) {
1320 ret
= create_image_file_range(trans
, root
, objectid
,
1321 &btrfs_inode
, last_byte
,
1322 total_bytes
, ext2_fs
);
1327 ret
= btrfs_insert_inode(trans
, root
, objectid
, &btrfs_inode
);
1331 location
.objectid
= objectid
;
1332 location
.offset
= 0;
1333 btrfs_set_key_type(&location
, BTRFS_INODE_ITEM_KEY
);
1334 ret
= btrfs_insert_dir_item(trans
, root
, name
, strlen(name
),
1335 btrfs_root_dirid(&root
->root_item
),
1336 &location
, EXT2_FT_REG_FILE
, objectid
);
1339 ret
= btrfs_insert_inode_ref(trans
, root
, name
, strlen(name
),
1341 btrfs_root_dirid(&root
->root_item
),
1345 location
.objectid
= btrfs_root_dirid(&root
->root_item
);
1346 location
.offset
= 0;
1347 btrfs_set_key_type(&location
, BTRFS_INODE_ITEM_KEY
);
1348 ret
= btrfs_lookup_inode(trans
, root
, &path
, &location
, 1);
1351 leaf
= path
.nodes
[0];
1352 inode_item
= btrfs_item_ptr(leaf
, path
.slots
[0],
1353 struct btrfs_inode_item
);
1354 btrfs_set_inode_size(leaf
, inode_item
, strlen(name
) * 2 +
1355 btrfs_inode_size(leaf
, inode_item
));
1356 btrfs_mark_buffer_dirty(leaf
);
1357 btrfs_release_path(&path
);
1358 ret
= btrfs_commit_transaction(trans
, root
);
1361 btrfs_release_path(&path
);
1365 static struct btrfs_root
* link_subvol(struct btrfs_root
*root
,
1366 const char *base
, u64 root_objectid
)
1368 struct btrfs_trans_handle
*trans
;
1369 struct btrfs_fs_info
*fs_info
= root
->fs_info
;
1370 struct btrfs_root
*tree_root
= fs_info
->tree_root
;
1371 struct btrfs_root
*new_root
= NULL
;
1372 struct btrfs_path
*path
;
1373 struct btrfs_inode_item
*inode_item
;
1374 struct extent_buffer
*leaf
;
1375 struct btrfs_key key
;
1376 u64 dirid
= btrfs_root_dirid(&root
->root_item
);
1378 char buf
[BTRFS_NAME_LEN
+ 1]; /* for snprintf null */
1384 if (len
< 1 || len
> BTRFS_NAME_LEN
)
1387 path
= btrfs_alloc_path();
1390 key
.objectid
= dirid
;
1391 key
.type
= BTRFS_DIR_INDEX_KEY
;
1392 key
.offset
= (u64
)-1;
1394 ret
= btrfs_search_slot(NULL
, root
, &key
, path
, 0, 0);
1397 if (path
->slots
[0] > 0) {
1399 btrfs_item_key_to_cpu(path
->nodes
[0], &key
, path
->slots
[0]);
1400 if (key
.objectid
== dirid
&& key
.type
== BTRFS_DIR_INDEX_KEY
)
1401 index
= key
.offset
+ 1;
1403 btrfs_release_path(path
);
1405 trans
= btrfs_start_transaction(root
, 1);
1408 key
.objectid
= dirid
;
1410 key
.type
= BTRFS_INODE_ITEM_KEY
;
1412 ret
= btrfs_lookup_inode(trans
, root
, path
, &key
, 1);
1414 leaf
= path
->nodes
[0];
1415 inode_item
= btrfs_item_ptr(leaf
, path
->slots
[0],
1416 struct btrfs_inode_item
);
1418 key
.objectid
= root_objectid
;
1419 key
.offset
= (u64
)-1;
1420 key
.type
= BTRFS_ROOT_ITEM_KEY
;
1422 memcpy(buf
, base
, len
);
1423 for (i
= 0; i
< 1024; i
++) {
1424 ret
= btrfs_insert_dir_item(trans
, root
, buf
, len
,
1425 dirid
, &key
, BTRFS_FT_DIR
, index
);
1428 len
= snprintf(buf
, ARRAY_SIZE(buf
), "%s%d", base
, i
);
1429 if (len
< 1 || len
> BTRFS_NAME_LEN
) {
1437 btrfs_set_inode_size(leaf
, inode_item
, len
* 2 +
1438 btrfs_inode_size(leaf
, inode_item
));
1439 btrfs_mark_buffer_dirty(leaf
);
1440 btrfs_release_path(path
);
1442 /* add the backref first */
1443 ret
= btrfs_add_root_ref(trans
, tree_root
, root_objectid
,
1444 BTRFS_ROOT_BACKREF_KEY
,
1445 root
->root_key
.objectid
,
1446 dirid
, index
, buf
, len
);
1449 /* now add the forward ref */
1450 ret
= btrfs_add_root_ref(trans
, tree_root
, root
->root_key
.objectid
,
1451 BTRFS_ROOT_REF_KEY
, root_objectid
,
1452 dirid
, index
, buf
, len
);
1454 ret
= btrfs_commit_transaction(trans
, root
);
1457 new_root
= btrfs_read_fs_root(fs_info
, &key
);
1458 if (IS_ERR(new_root
))
1461 btrfs_free_path(path
);
1465 static int create_chunk_mapping(struct btrfs_trans_handle
*trans
,
1466 struct btrfs_root
*root
)
1468 struct btrfs_fs_info
*info
= root
->fs_info
;
1469 struct btrfs_root
*chunk_root
= info
->chunk_root
;
1470 struct btrfs_root
*extent_root
= info
->extent_root
;
1471 struct btrfs_device
*device
;
1472 struct btrfs_block_group_cache
*cache
;
1473 struct btrfs_dev_extent
*extent
;
1474 struct extent_buffer
*leaf
;
1475 struct btrfs_chunk chunk
;
1476 struct btrfs_key key
;
1477 struct btrfs_path path
;
1483 btrfs_init_path(&path
);
1485 total_bytes
= btrfs_super_total_bytes(root
->fs_info
->super_copy
);
1486 chunk_objectid
= BTRFS_FIRST_CHUNK_TREE_OBJECTID
;
1488 BUG_ON(list_empty(&info
->fs_devices
->devices
));
1489 device
= list_entry(info
->fs_devices
->devices
.next
,
1490 struct btrfs_device
, dev_list
);
1491 BUG_ON(device
->devid
!= info
->fs_devices
->latest_devid
);
1493 /* delete device extent created by make_btrfs */
1494 key
.objectid
= device
->devid
;
1496 key
.type
= BTRFS_DEV_EXTENT_KEY
;
1497 ret
= btrfs_search_slot(trans
, device
->dev_root
, &key
, &path
, -1, 1);
1502 ret
= btrfs_del_item(trans
, device
->dev_root
, &path
);
1505 btrfs_release_path(&path
);
1507 /* delete chunk item created by make_btrfs */
1508 key
.objectid
= chunk_objectid
;
1510 key
.type
= BTRFS_CHUNK_ITEM_KEY
;
1511 ret
= btrfs_search_slot(trans
, chunk_root
, &key
, &path
, -1, 1);
1516 ret
= btrfs_del_item(trans
, chunk_root
, &path
);
1519 btrfs_release_path(&path
);
1521 /* for each block group, create device extent and chunk item */
1523 while (cur_start
< total_bytes
) {
1524 cache
= btrfs_lookup_block_group(root
->fs_info
, cur_start
);
1527 /* insert device extent */
1528 key
.objectid
= device
->devid
;
1529 key
.offset
= cache
->key
.objectid
;
1530 key
.type
= BTRFS_DEV_EXTENT_KEY
;
1531 ret
= btrfs_insert_empty_item(trans
, device
->dev_root
, &path
,
1532 &key
, sizeof(*extent
));
1536 leaf
= path
.nodes
[0];
1537 extent
= btrfs_item_ptr(leaf
, path
.slots
[0],
1538 struct btrfs_dev_extent
);
1540 btrfs_set_dev_extent_chunk_tree(leaf
, extent
,
1541 chunk_root
->root_key
.objectid
);
1542 btrfs_set_dev_extent_chunk_objectid(leaf
, extent
,
1544 btrfs_set_dev_extent_chunk_offset(leaf
, extent
,
1545 cache
->key
.objectid
);
1546 btrfs_set_dev_extent_length(leaf
, extent
, cache
->key
.offset
);
1547 write_extent_buffer(leaf
, root
->fs_info
->chunk_tree_uuid
,
1548 (unsigned long)btrfs_dev_extent_chunk_tree_uuid(extent
),
1550 btrfs_mark_buffer_dirty(leaf
);
1551 btrfs_release_path(&path
);
1553 /* insert chunk item */
1554 btrfs_set_stack_chunk_length(&chunk
, cache
->key
.offset
);
1555 btrfs_set_stack_chunk_owner(&chunk
,
1556 extent_root
->root_key
.objectid
);
1557 btrfs_set_stack_chunk_stripe_len(&chunk
, BTRFS_STRIPE_LEN
);
1558 btrfs_set_stack_chunk_type(&chunk
, cache
->flags
);
1559 btrfs_set_stack_chunk_io_align(&chunk
, device
->io_align
);
1560 btrfs_set_stack_chunk_io_width(&chunk
, device
->io_width
);
1561 btrfs_set_stack_chunk_sector_size(&chunk
, device
->sector_size
);
1562 btrfs_set_stack_chunk_num_stripes(&chunk
, 1);
1563 btrfs_set_stack_chunk_sub_stripes(&chunk
, 0);
1564 btrfs_set_stack_stripe_devid(&chunk
.stripe
, device
->devid
);
1565 btrfs_set_stack_stripe_offset(&chunk
.stripe
,
1566 cache
->key
.objectid
);
1567 memcpy(&chunk
.stripe
.dev_uuid
, device
->uuid
, BTRFS_UUID_SIZE
);
1569 key
.objectid
= chunk_objectid
;
1570 key
.offset
= cache
->key
.objectid
;
1571 key
.type
= BTRFS_CHUNK_ITEM_KEY
;
1573 ret
= btrfs_insert_item(trans
, chunk_root
, &key
, &chunk
,
1574 btrfs_chunk_item_size(1));
1578 cur_start
= cache
->key
.objectid
+ cache
->key
.offset
;
1581 device
->bytes_used
= total_bytes
;
1582 ret
= btrfs_update_device(trans
, device
);
1584 btrfs_release_path(&path
);
1588 static int create_subvol(struct btrfs_trans_handle
*trans
,
1589 struct btrfs_root
*root
, u64 root_objectid
)
1591 struct extent_buffer
*tmp
;
1592 struct btrfs_root
*new_root
;
1593 struct btrfs_key key
;
1594 struct btrfs_root_item root_item
;
1597 ret
= btrfs_copy_root(trans
, root
, root
->node
, &tmp
,
1601 memcpy(&root_item
, &root
->root_item
, sizeof(root_item
));
1602 btrfs_set_root_bytenr(&root_item
, tmp
->start
);
1603 btrfs_set_root_level(&root_item
, btrfs_header_level(tmp
));
1604 btrfs_set_root_generation(&root_item
, trans
->transid
);
1605 free_extent_buffer(tmp
);
1607 key
.objectid
= root_objectid
;
1608 key
.type
= BTRFS_ROOT_ITEM_KEY
;
1609 key
.offset
= trans
->transid
;
1610 ret
= btrfs_insert_root(trans
, root
->fs_info
->tree_root
,
1613 key
.offset
= (u64
)-1;
1614 new_root
= btrfs_read_fs_root(root
->fs_info
, &key
);
1615 BUG_ON(!new_root
|| IS_ERR(new_root
));
1617 ret
= btrfs_make_root_dir(trans
, new_root
, BTRFS_FIRST_FREE_OBJECTID
);
1623 static int init_btrfs(struct btrfs_root
*root
)
1626 struct btrfs_key location
;
1627 struct btrfs_trans_handle
*trans
;
1628 struct btrfs_fs_info
*fs_info
= root
->fs_info
;
1629 struct extent_buffer
*tmp
;
1631 trans
= btrfs_start_transaction(root
, 1);
1633 ret
= btrfs_make_block_groups(trans
, root
);
1636 ret
= btrfs_fix_block_accounting(trans
, root
);
1639 ret
= create_chunk_mapping(trans
, root
);
1642 ret
= btrfs_make_root_dir(trans
, fs_info
->tree_root
,
1643 BTRFS_ROOT_TREE_DIR_OBJECTID
);
1646 memcpy(&location
, &root
->root_key
, sizeof(location
));
1647 location
.offset
= (u64
)-1;
1648 ret
= btrfs_insert_dir_item(trans
, fs_info
->tree_root
, "default", 7,
1649 btrfs_super_root_dir(fs_info
->super_copy
),
1650 &location
, BTRFS_FT_DIR
, 0);
1653 ret
= btrfs_insert_inode_ref(trans
, fs_info
->tree_root
, "default", 7,
1655 btrfs_super_root_dir(fs_info
->super_copy
), 0);
1658 btrfs_set_root_dirid(&fs_info
->fs_root
->root_item
,
1659 BTRFS_FIRST_FREE_OBJECTID
);
1661 /* subvol for ext2 image file */
1662 ret
= create_subvol(trans
, root
, EXT2_IMAGE_SUBVOL_OBJECTID
);
1664 /* subvol for data relocation */
1665 ret
= create_subvol(trans
, root
, BTRFS_DATA_RELOC_TREE_OBJECTID
);
1668 extent_buffer_get(fs_info
->csum_root
->node
);
1669 ret
= __btrfs_cow_block(trans
, fs_info
->csum_root
,
1670 fs_info
->csum_root
->node
, NULL
, 0, &tmp
, 0, 0);
1672 free_extent_buffer(tmp
);
1674 ret
= btrfs_commit_transaction(trans
, root
);
1681 * Migrate super block to its default position and zero 0 ~ 16k
1683 static int migrate_super_block(int fd
, u64 old_bytenr
, u32 sectorsize
)
1686 struct extent_buffer
*buf
;
1687 struct btrfs_super_block
*super
;
1691 BUG_ON(sectorsize
< sizeof(*super
));
1692 buf
= malloc(sizeof(*buf
) + sectorsize
);
1696 buf
->len
= sectorsize
;
1697 ret
= pread(fd
, buf
->data
, sectorsize
, old_bytenr
);
1698 if (ret
!= sectorsize
)
1701 super
= (struct btrfs_super_block
*)buf
->data
;
1702 BUG_ON(btrfs_super_bytenr(super
) != old_bytenr
);
1703 btrfs_set_super_bytenr(super
, BTRFS_SUPER_INFO_OFFSET
);
1705 csum_tree_block_size(buf
, BTRFS_CRC32_SIZE
, 0);
1706 ret
= pwrite(fd
, buf
->data
, sectorsize
, BTRFS_SUPER_INFO_OFFSET
);
1707 if (ret
!= sectorsize
)
1714 memset(buf
->data
, 0, sectorsize
);
1715 for (bytenr
= 0; bytenr
< BTRFS_SUPER_INFO_OFFSET
; ) {
1716 len
= BTRFS_SUPER_INFO_OFFSET
- bytenr
;
1717 if (len
> sectorsize
)
1719 ret
= pwrite(fd
, buf
->data
, len
, bytenr
);
1721 fprintf(stderr
, "unable to zero fill device\n");
1735 static int prepare_system_chunk_sb(struct btrfs_super_block
*super
)
1737 struct btrfs_chunk
*chunk
;
1738 struct btrfs_disk_key
*key
;
1739 u32 sectorsize
= btrfs_super_sectorsize(super
);
1741 key
= (struct btrfs_disk_key
*)(super
->sys_chunk_array
);
1742 chunk
= (struct btrfs_chunk
*)(super
->sys_chunk_array
+
1743 sizeof(struct btrfs_disk_key
));
1745 btrfs_set_disk_key_objectid(key
, BTRFS_FIRST_CHUNK_TREE_OBJECTID
);
1746 btrfs_set_disk_key_type(key
, BTRFS_CHUNK_ITEM_KEY
);
1747 btrfs_set_disk_key_offset(key
, 0);
1749 btrfs_set_stack_chunk_length(chunk
, btrfs_super_total_bytes(super
));
1750 btrfs_set_stack_chunk_owner(chunk
, BTRFS_EXTENT_TREE_OBJECTID
);
1751 btrfs_set_stack_chunk_stripe_len(chunk
, BTRFS_STRIPE_LEN
);
1752 btrfs_set_stack_chunk_type(chunk
, BTRFS_BLOCK_GROUP_SYSTEM
);
1753 btrfs_set_stack_chunk_io_align(chunk
, sectorsize
);
1754 btrfs_set_stack_chunk_io_width(chunk
, sectorsize
);
1755 btrfs_set_stack_chunk_sector_size(chunk
, sectorsize
);
1756 btrfs_set_stack_chunk_num_stripes(chunk
, 1);
1757 btrfs_set_stack_chunk_sub_stripes(chunk
, 0);
1758 chunk
->stripe
.devid
= super
->dev_item
.devid
;
1759 btrfs_set_stack_stripe_offset(&chunk
->stripe
, 0);
1760 memcpy(chunk
->stripe
.dev_uuid
, super
->dev_item
.uuid
, BTRFS_UUID_SIZE
);
1761 btrfs_set_super_sys_array_size(super
, sizeof(*key
) + sizeof(*chunk
));
1765 static int prepare_system_chunk(int fd
, u64 sb_bytenr
, u32 sectorsize
)
1768 struct extent_buffer
*buf
;
1769 struct btrfs_super_block
*super
;
1771 BUG_ON(sectorsize
< sizeof(*super
));
1772 buf
= malloc(sizeof(*buf
) + sectorsize
);
1776 buf
->len
= sectorsize
;
1777 ret
= pread(fd
, buf
->data
, sectorsize
, sb_bytenr
);
1778 if (ret
!= sectorsize
)
1781 super
= (struct btrfs_super_block
*)buf
->data
;
1782 BUG_ON(btrfs_super_bytenr(super
) != sb_bytenr
);
1783 BUG_ON(btrfs_super_num_devices(super
) != 1);
1785 ret
= prepare_system_chunk_sb(super
);
1789 csum_tree_block_size(buf
, BTRFS_CRC32_SIZE
, 0);
1790 ret
= pwrite(fd
, buf
->data
, sectorsize
, sb_bytenr
);
1791 if (ret
!= sectorsize
)
1802 static int relocate_one_reference(struct btrfs_trans_handle
*trans
,
1803 struct btrfs_root
*root
,
1804 u64 extent_start
, u64 extent_size
,
1805 struct btrfs_key
*extent_key
,
1806 struct extent_io_tree
*reloc_tree
)
1808 struct extent_buffer
*leaf
;
1809 struct btrfs_file_extent_item
*fi
;
1810 struct btrfs_key key
;
1811 struct btrfs_path path
;
1812 struct btrfs_inode_item inode
;
1813 struct blk_iterate_data data
;
1820 u32 sectorsize
= root
->sectorsize
;
1826 btrfs_init_path(&path
);
1827 ret
= btrfs_search_slot(trans
, root
, extent_key
, &path
, -1, 1);
1831 leaf
= path
.nodes
[0];
1832 fi
= btrfs_item_ptr(leaf
, path
.slots
[0],
1833 struct btrfs_file_extent_item
);
1834 BUG_ON(btrfs_file_extent_offset(leaf
, fi
) > 0);
1835 if (extent_start
!= btrfs_file_extent_disk_bytenr(leaf
, fi
) ||
1836 extent_size
!= btrfs_file_extent_disk_num_bytes(leaf
, fi
)) {
1841 bytenr
= extent_start
+ btrfs_file_extent_offset(leaf
, fi
);
1842 num_bytes
= btrfs_file_extent_num_bytes(leaf
, fi
);
1844 ret
= btrfs_del_item(trans
, root
, &path
);
1848 ret
= btrfs_free_extent(trans
, root
, extent_start
, extent_size
, 0,
1849 root
->root_key
.objectid
,
1850 extent_key
->objectid
, extent_key
->offset
);
1854 btrfs_release_path(&path
);
1856 key
.objectid
= extent_key
->objectid
;
1858 key
.type
= BTRFS_INODE_ITEM_KEY
;
1859 ret
= btrfs_lookup_inode(trans
, root
, &path
, &key
, 0);
1863 leaf
= path
.nodes
[0];
1864 ptr
= btrfs_item_ptr_offset(leaf
, path
.slots
[0]);
1865 read_extent_buffer(leaf
, &inode
, ptr
, sizeof(inode
));
1866 btrfs_release_path(&path
);
1868 BUG_ON(num_bytes
& (sectorsize
- 1));
1869 nbytes
= btrfs_stack_inode_nbytes(&inode
) - num_bytes
;
1870 btrfs_set_stack_inode_nbytes(&inode
, nbytes
);
1871 datacsum
= !(btrfs_stack_inode_flags(&inode
) & BTRFS_INODE_NODATASUM
);
1873 data
= (struct blk_iterate_data
) {
1877 .objectid
= extent_key
->objectid
,
1878 .first_block
= extent_key
->offset
/ sectorsize
,
1881 .boundary
= (u64
)-1,
1882 .checksum
= datacsum
,
1886 cur_offset
= extent_key
->offset
;
1887 while (num_bytes
> 0) {
1888 sector_end
= bytenr
+ sectorsize
- 1;
1889 if (test_range_bit(reloc_tree
, bytenr
, sector_end
,
1890 EXTENT_LOCKED
, 1)) {
1891 ret
= get_state_private(reloc_tree
, bytenr
, &new_pos
);
1894 ret
= custom_alloc_extent(root
, sectorsize
, 0, &key
);
1897 new_pos
= key
.objectid
;
1899 if (cur_offset
== extent_key
->offset
) {
1900 fd
= root
->fs_info
->fs_devices
->latest_bdev
;
1901 readahead(fd
, bytenr
, num_bytes
);
1903 ret
= copy_disk_extent(root
, new_pos
, bytenr
,
1907 ret
= set_extent_bits(reloc_tree
, bytenr
, sector_end
,
1908 EXTENT_LOCKED
, GFP_NOFS
);
1910 ret
= set_state_private(reloc_tree
, bytenr
, new_pos
);
1914 ret
= block_iterate_proc(NULL
, new_pos
/ sectorsize
,
1915 cur_offset
/ sectorsize
, &data
);
1916 if (ret
& BLOCK_ABORT
) {
1921 cur_offset
+= sectorsize
;
1922 bytenr
+= sectorsize
;
1923 num_bytes
-= sectorsize
;
1926 if (data
.num_blocks
> 0) {
1927 ret
= record_file_blocks(trans
, root
,
1928 extent_key
->objectid
, &inode
,
1929 data
.first_block
, data
.disk_block
,
1930 data
.num_blocks
, datacsum
);
1935 key
.objectid
= extent_key
->objectid
;
1937 key
.type
= BTRFS_INODE_ITEM_KEY
;
1938 ret
= btrfs_lookup_inode(trans
, root
, &path
, &key
, 1);
1942 leaf
= path
.nodes
[0];
1943 ptr
= btrfs_item_ptr_offset(leaf
, path
.slots
[0]);
1944 write_extent_buffer(leaf
, &inode
, ptr
, sizeof(inode
));
1945 btrfs_mark_buffer_dirty(leaf
);
1946 btrfs_release_path(&path
);
1949 btrfs_release_path(&path
);
1953 static int relocate_extents_range(struct btrfs_root
*fs_root
,
1954 struct btrfs_root
*ext2_root
,
1955 u64 start_byte
, u64 end_byte
)
1957 struct btrfs_fs_info
*info
= fs_root
->fs_info
;
1958 struct btrfs_root
*extent_root
= info
->extent_root
;
1959 struct btrfs_root
*cur_root
= NULL
;
1960 struct btrfs_trans_handle
*trans
;
1961 struct btrfs_extent_data_ref
*dref
;
1962 struct btrfs_extent_inline_ref
*iref
;
1963 struct btrfs_extent_item
*ei
;
1964 struct extent_buffer
*leaf
;
1965 struct btrfs_key key
;
1966 struct btrfs_key extent_key
;
1967 struct btrfs_path path
;
1968 struct extent_io_tree reloc_tree
;
1978 btrfs_init_path(&path
);
1979 extent_io_tree_init(&reloc_tree
);
1981 key
.objectid
= start_byte
;
1983 key
.type
= BTRFS_EXTENT_ITEM_KEY
;
1984 ret
= btrfs_search_slot(NULL
, extent_root
, &key
, &path
, 0, 0);
1988 ret
= btrfs_previous_item(extent_root
, &path
, 0,
1989 BTRFS_EXTENT_ITEM_KEY
);
1993 leaf
= path
.nodes
[0];
1994 btrfs_item_key_to_cpu(leaf
, &key
, path
.slots
[0]);
1995 if (key
.objectid
+ key
.offset
> start_byte
)
1996 start_byte
= key
.objectid
;
1999 btrfs_release_path(&path
);
2001 cur_root
= (pass
% 2 == 0) ? ext2_root
: fs_root
;
2004 trans
= btrfs_start_transaction(cur_root
, 1);
2007 cur_byte
= start_byte
;
2009 key
.objectid
= cur_byte
;
2011 key
.type
= BTRFS_EXTENT_ITEM_KEY
;
2012 ret
= btrfs_search_slot(trans
, extent_root
,
2017 leaf
= path
.nodes
[0];
2018 if (path
.slots
[0] >= btrfs_header_nritems(leaf
)) {
2019 ret
= btrfs_next_leaf(extent_root
, &path
);
2024 leaf
= path
.nodes
[0];
2027 btrfs_item_key_to_cpu(leaf
, &key
, path
.slots
[0]);
2028 if (key
.objectid
< cur_byte
||
2029 key
.type
!= BTRFS_EXTENT_ITEM_KEY
) {
2033 if (key
.objectid
>= end_byte
)
2038 cur_byte
= key
.objectid
;
2039 num_bytes
= key
.offset
;
2040 ei
= btrfs_item_ptr(leaf
, path
.slots
[0],
2041 struct btrfs_extent_item
);
2042 BUG_ON(!(btrfs_extent_flags(leaf
, ei
) &
2043 BTRFS_EXTENT_FLAG_DATA
));
2045 ptr
= btrfs_item_ptr_offset(leaf
, path
.slots
[0]);
2046 end
= ptr
+ btrfs_item_size_nr(leaf
, path
.slots
[0]);
2048 ptr
+= sizeof(struct btrfs_extent_item
);
2051 iref
= (struct btrfs_extent_inline_ref
*)ptr
;
2052 key
.type
= btrfs_extent_inline_ref_type(leaf
, iref
);
2053 BUG_ON(key
.type
!= BTRFS_EXTENT_DATA_REF_KEY
);
2054 dref
= (struct btrfs_extent_data_ref
*)(&iref
->offset
);
2055 ref_root
= btrfs_extent_data_ref_root(leaf
, dref
);
2056 extent_key
.objectid
=
2057 btrfs_extent_data_ref_objectid(leaf
, dref
);
2059 btrfs_extent_data_ref_offset(leaf
, dref
);
2060 extent_key
.type
= BTRFS_EXTENT_DATA_KEY
;
2061 BUG_ON(btrfs_extent_data_ref_count(leaf
, dref
) != 1);
2063 if (ref_root
== cur_root
->root_key
.objectid
)
2066 ptr
+= btrfs_extent_inline_ref_size(key
.type
);
2074 ret
= relocate_one_reference(trans
, cur_root
, cur_byte
,
2075 num_bytes
, &extent_key
,
2080 cur_byte
+= num_bytes
;
2081 btrfs_release_path(&path
);
2083 if (trans
->blocks_used
>= 4096) {
2084 ret
= btrfs_commit_transaction(trans
, cur_root
);
2086 trans
= btrfs_start_transaction(cur_root
, 1);
2090 btrfs_release_path(&path
);
2092 ret
= btrfs_commit_transaction(trans
, cur_root
);
2095 if (num_extents
> 0 && pass
++ < 16)
2098 ret
= (num_extents
> 0) ? -1 : 0;
2100 btrfs_release_path(&path
);
2101 extent_io_tree_cleanup(&reloc_tree
);
2106 * relocate data in system chunk
2108 static int cleanup_sys_chunk(struct btrfs_root
*fs_root
,
2109 struct btrfs_root
*ext2_root
)
2111 struct btrfs_block_group_cache
*cache
;
2117 cache
= btrfs_lookup_block_group(fs_root
->fs_info
, offset
);
2121 end_byte
= cache
->key
.objectid
+ cache
->key
.offset
;
2122 if (cache
->flags
& BTRFS_BLOCK_GROUP_SYSTEM
) {
2123 ret
= relocate_extents_range(fs_root
, ext2_root
,
2124 cache
->key
.objectid
,
2131 for (i
= 0; i
< BTRFS_SUPER_MIRROR_MAX
; i
++) {
2132 offset
= btrfs_sb_offset(i
);
2133 offset
&= ~((u64
)BTRFS_STRIPE_LEN
- 1);
2135 ret
= relocate_extents_range(fs_root
, ext2_root
,
2136 offset
, offset
+ BTRFS_STRIPE_LEN
);
2145 static int fixup_chunk_mapping(struct btrfs_root
*root
)
2147 struct btrfs_trans_handle
*trans
;
2148 struct btrfs_fs_info
*info
= root
->fs_info
;
2149 struct btrfs_root
*chunk_root
= info
->chunk_root
;
2150 struct extent_buffer
*leaf
;
2151 struct btrfs_key key
;
2152 struct btrfs_path path
;
2153 struct btrfs_chunk chunk
;
2159 btrfs_init_path(&path
);
2161 trans
= btrfs_start_transaction(root
, 1);
2165 * recow the whole chunk tree. this will move all chunk tree blocks
2166 * into system block group.
2168 memset(&key
, 0, sizeof(key
));
2170 ret
= btrfs_search_slot(trans
, chunk_root
, &key
, &path
, 0, 1);
2174 ret
= btrfs_next_leaf(chunk_root
, &path
);
2180 btrfs_item_key_to_cpu(path
.nodes
[0], &key
, path
.slots
[0]);
2181 btrfs_release_path(&path
);
2183 btrfs_release_path(&path
);
2185 /* fixup the system chunk array in super block */
2186 btrfs_set_super_sys_array_size(info
->super_copy
, 0);
2188 key
.objectid
= BTRFS_FIRST_CHUNK_TREE_OBJECTID
;
2190 key
.type
= BTRFS_CHUNK_ITEM_KEY
;
2192 ret
= btrfs_search_slot(trans
, chunk_root
, &key
, &path
, 0, 0);
2197 leaf
= path
.nodes
[0];
2198 if (path
.slots
[0] >= btrfs_header_nritems(leaf
)) {
2199 ret
= btrfs_next_leaf(chunk_root
, &path
);
2204 leaf
= path
.nodes
[0];
2206 btrfs_item_key_to_cpu(leaf
, &key
, path
.slots
[0]);
2207 if (key
.type
!= BTRFS_CHUNK_ITEM_KEY
)
2210 ptr
= btrfs_item_ptr_offset(leaf
, path
.slots
[0]);
2211 size
= btrfs_item_size_nr(leaf
, path
.slots
[0]);
2212 BUG_ON(size
!= sizeof(chunk
));
2213 read_extent_buffer(leaf
, &chunk
, ptr
, size
);
2214 type
= btrfs_stack_chunk_type(&chunk
);
2216 if (!(type
& BTRFS_BLOCK_GROUP_SYSTEM
))
2219 ret
= btrfs_add_system_chunk(trans
, chunk_root
, &key
,
2227 ret
= btrfs_commit_transaction(trans
, root
);
2230 btrfs_release_path(&path
);
2234 static int do_convert(const char *devname
, int datacsum
, int packing
, int noxattr
,
2235 int copylabel
, const char *fslabel
, int progress
)
2243 ext2_filsys ext2_fs
;
2244 struct btrfs_root
*root
;
2245 struct btrfs_root
*ext2_root
;
2246 struct task_ctx ctx
;
2248 ret
= open_ext2fs(devname
, &ext2_fs
);
2250 fprintf(stderr
, "unable to open the Ext2fs\n");
2253 blocksize
= ext2_fs
->blocksize
;
2254 total_bytes
= (u64
)ext2_fs
->super
->s_blocks_count
* blocksize
;
2255 if (blocksize
< 4096) {
2256 fprintf(stderr
, "block size is too small\n");
2259 if (!(ext2_fs
->super
->s_feature_incompat
&
2260 EXT2_FEATURE_INCOMPAT_FILETYPE
)) {
2261 fprintf(stderr
, "filetype feature is missing\n");
2264 for (i
= 0; i
< 7; i
++) {
2265 ret
= ext2_alloc_block(ext2_fs
, 0, blocks
+ i
);
2267 fprintf(stderr
, "not enough free space\n");
2270 blocks
[i
] *= blocksize
;
2272 super_bytenr
= blocks
[0];
2273 fd
= open(devname
, O_RDWR
);
2275 fprintf(stderr
, "unable to open %s\n", devname
);
2278 ret
= make_btrfs(fd
, devname
, ext2_fs
->super
->s_volume_name
,
2279 NULL
, blocks
, total_bytes
, blocksize
, blocksize
,
2280 blocksize
, blocksize
, 0);
2282 fprintf(stderr
, "unable to create initial ctree: %s\n",
2286 /* create a system chunk that maps the whole device */
2287 ret
= prepare_system_chunk(fd
, super_bytenr
, blocksize
);
2289 fprintf(stderr
, "unable to update system chunk\n");
2292 root
= open_ctree_fd(fd
, devname
, super_bytenr
, OPEN_CTREE_WRITES
);
2294 fprintf(stderr
, "unable to open ctree\n");
2297 ret
= cache_free_extents(root
, ext2_fs
);
2299 fprintf(stderr
, "error during cache_free_extents %d\n", ret
);
2302 root
->fs_info
->extent_ops
= &extent_ops
;
2303 /* recover block allocation bitmap */
2304 for (i
= 0; i
< 7; i
++) {
2305 blocks
[i
] /= blocksize
;
2306 ext2_free_block(ext2_fs
, blocks
[i
]);
2308 ret
= init_btrfs(root
);
2310 fprintf(stderr
, "unable to setup the root tree\n");
2313 printf("creating btrfs metadata.\n");
2314 ctx
.max_copy_inodes
= (ext2_fs
->super
->s_inodes_count
2315 - ext2_fs
->super
->s_free_inodes_count
);
2316 ctx
.cur_copy_inodes
= 0;
2319 ctx
.info
= task_init(print_copied_inodes
, after_copied_inodes
, &ctx
);
2320 task_start(ctx
.info
);
2322 ret
= copy_inodes(root
, ext2_fs
, datacsum
, packing
, noxattr
, &ctx
);
2324 fprintf(stderr
, "error during copy_inodes %d\n", ret
);
2328 task_stop(ctx
.info
);
2329 task_deinit(ctx
.info
);
2331 printf("creating ext2fs image file.\n");
2332 ext2_root
= link_subvol(root
, "ext2_saved", EXT2_IMAGE_SUBVOL_OBJECTID
);
2334 fprintf(stderr
, "unable to create subvol\n");
2337 ret
= create_ext2_image(ext2_root
, ext2_fs
, "image");
2339 fprintf(stderr
, "error during create_ext2_image %d\n", ret
);
2342 memset(root
->fs_info
->super_copy
->label
, 0, BTRFS_LABEL_SIZE
);
2343 if (copylabel
== 1) {
2344 strncpy(root
->fs_info
->super_copy
->label
,
2345 ext2_fs
->super
->s_volume_name
, 16);
2346 fprintf(stderr
, "copy label '%s'\n",
2347 root
->fs_info
->super_copy
->label
);
2348 } else if (copylabel
== -1) {
2349 strncpy(root
->fs_info
->super_copy
->label
, fslabel
, BTRFS_LABEL_SIZE
);
2350 fprintf(stderr
, "set label to '%s'\n", fslabel
);
2353 printf("cleaning up system chunk.\n");
2354 ret
= cleanup_sys_chunk(root
, ext2_root
);
2356 fprintf(stderr
, "error during cleanup_sys_chunk %d\n", ret
);
2359 ret
= close_ctree(root
);
2361 fprintf(stderr
, "error during close_ctree %d\n", ret
);
2364 close_ext2fs(ext2_fs
);
2367 * If this step succeed, we get a mountable btrfs. Otherwise
2368 * the ext2fs is left unchanged.
2370 ret
= migrate_super_block(fd
, super_bytenr
, blocksize
);
2372 fprintf(stderr
, "unable to migrate super block\n");
2376 root
= open_ctree_fd(fd
, devname
, 0, OPEN_CTREE_WRITES
);
2378 fprintf(stderr
, "unable to open ctree\n");
2381 /* move chunk tree into system chunk. */
2382 ret
= fixup_chunk_mapping(root
);
2384 fprintf(stderr
, "error during fixup_chunk_tree\n");
2387 ret
= close_ctree(root
);
2390 printf("conversion complete.\n");
2395 fprintf(stderr
, "conversion aborted.\n");
2399 static int may_rollback(struct btrfs_root
*root
)
2401 struct btrfs_fs_info
*info
= root
->fs_info
;
2402 struct btrfs_multi_bio
*multi
= NULL
;
2410 if (btrfs_super_num_devices(info
->super_copy
) != 1)
2413 bytenr
= BTRFS_SUPER_INFO_OFFSET
;
2414 total_bytes
= btrfs_super_total_bytes(root
->fs_info
->super_copy
);
2417 ret
= btrfs_map_block(&info
->mapping_tree
, WRITE
, bytenr
,
2418 &length
, &multi
, 0, NULL
);
2420 if (ret
== -ENOENT
) {
2421 /* removed block group at the tail */
2422 if (length
== (u64
)-1)
2425 /* removed block group in the middle */
2431 num_stripes
= multi
->num_stripes
;
2432 physical
= multi
->stripes
[0].physical
;
2435 if (num_stripes
!= 1 || physical
!= bytenr
)
2439 if (bytenr
>= total_bytes
)
2447 static int do_rollback(const char *devname
)
2452 struct btrfs_root
*root
;
2453 struct btrfs_root
*ext2_root
;
2454 struct btrfs_root
*chunk_root
;
2455 struct btrfs_dir_item
*dir
;
2456 struct btrfs_inode_item
*inode
;
2457 struct btrfs_file_extent_item
*fi
;
2458 struct btrfs_trans_handle
*trans
;
2459 struct extent_buffer
*leaf
;
2460 struct btrfs_block_group_cache
*cache1
;
2461 struct btrfs_block_group_cache
*cache2
;
2462 struct btrfs_key key
;
2463 struct btrfs_path path
;
2464 struct extent_io_tree io_tree
;
2479 extent_io_tree_init(&io_tree
);
2481 fd
= open(devname
, O_RDWR
);
2483 fprintf(stderr
, "unable to open %s\n", devname
);
2486 root
= open_ctree_fd(fd
, devname
, 0, OPEN_CTREE_WRITES
);
2488 fprintf(stderr
, "unable to open ctree\n");
2491 ret
= may_rollback(root
);
2493 fprintf(stderr
, "unable to do rollback\n");
2497 sectorsize
= root
->sectorsize
;
2498 buf
= malloc(sectorsize
);
2500 fprintf(stderr
, "unable to allocate memory\n");
2504 btrfs_init_path(&path
);
2506 key
.objectid
= EXT2_IMAGE_SUBVOL_OBJECTID
;
2507 key
.type
= BTRFS_ROOT_ITEM_KEY
;
2508 key
.offset
= (u64
)-1;
2509 ext2_root
= btrfs_read_fs_root(root
->fs_info
, &key
);
2510 if (!ext2_root
|| IS_ERR(ext2_root
)) {
2511 fprintf(stderr
, "unable to open subvol %llu\n",
2512 (unsigned long long)key
.objectid
);
2517 root_dir
= btrfs_root_dirid(&root
->root_item
);
2518 dir
= btrfs_lookup_dir_item(NULL
, ext2_root
, &path
,
2519 root_dir
, name
, strlen(name
), 0);
2520 if (!dir
|| IS_ERR(dir
)) {
2521 fprintf(stderr
, "unable to find file %s\n", name
);
2524 leaf
= path
.nodes
[0];
2525 btrfs_dir_item_key_to_cpu(leaf
, dir
, &key
);
2526 btrfs_release_path(&path
);
2528 objectid
= key
.objectid
;
2530 ret
= btrfs_lookup_inode(NULL
, ext2_root
, &path
, &key
, 0);
2532 fprintf(stderr
, "unable to find inode item\n");
2535 leaf
= path
.nodes
[0];
2536 inode
= btrfs_item_ptr(leaf
, path
.slots
[0], struct btrfs_inode_item
);
2537 total_bytes
= btrfs_inode_size(leaf
, inode
);
2538 btrfs_release_path(&path
);
2540 key
.objectid
= objectid
;
2542 btrfs_set_key_type(&key
, BTRFS_EXTENT_DATA_KEY
);
2543 ret
= btrfs_search_slot(NULL
, ext2_root
, &key
, &path
, 0, 0);
2545 fprintf(stderr
, "unable to find first file extent\n");
2546 btrfs_release_path(&path
);
2550 /* build mapping tree for the relocated blocks */
2551 for (offset
= 0; offset
< total_bytes
; ) {
2552 leaf
= path
.nodes
[0];
2553 if (path
.slots
[0] >= btrfs_header_nritems(leaf
)) {
2554 ret
= btrfs_next_leaf(root
, &path
);
2560 btrfs_item_key_to_cpu(leaf
, &key
, path
.slots
[0]);
2561 if (key
.objectid
!= objectid
|| key
.offset
!= offset
||
2562 btrfs_key_type(&key
) != BTRFS_EXTENT_DATA_KEY
)
2565 fi
= btrfs_item_ptr(leaf
, path
.slots
[0],
2566 struct btrfs_file_extent_item
);
2567 if (btrfs_file_extent_type(leaf
, fi
) != BTRFS_FILE_EXTENT_REG
)
2569 if (btrfs_file_extent_compression(leaf
, fi
) ||
2570 btrfs_file_extent_encryption(leaf
, fi
) ||
2571 btrfs_file_extent_other_encoding(leaf
, fi
))
2574 bytenr
= btrfs_file_extent_disk_bytenr(leaf
, fi
);
2575 /* skip holes and direct mapped extents */
2576 if (bytenr
== 0 || bytenr
== offset
)
2579 bytenr
+= btrfs_file_extent_offset(leaf
, fi
);
2580 num_bytes
= btrfs_file_extent_num_bytes(leaf
, fi
);
2582 cache1
= btrfs_lookup_block_group(root
->fs_info
, offset
);
2583 cache2
= btrfs_lookup_block_group(root
->fs_info
,
2584 offset
+ num_bytes
- 1);
2585 if (!cache1
|| cache1
!= cache2
||
2586 (!(cache1
->flags
& BTRFS_BLOCK_GROUP_SYSTEM
) &&
2587 !intersect_with_sb(offset
, num_bytes
)))
2590 set_extent_bits(&io_tree
, offset
, offset
+ num_bytes
- 1,
2591 EXTENT_LOCKED
, GFP_NOFS
);
2592 set_state_private(&io_tree
, offset
, bytenr
);
2594 offset
+= btrfs_file_extent_num_bytes(leaf
, fi
);
2597 btrfs_release_path(&path
);
2599 if (offset
< total_bytes
) {
2600 fprintf(stderr
, "unable to build extent mapping\n");
2604 first_free
= BTRFS_SUPER_INFO_OFFSET
+ 2 * sectorsize
- 1;
2605 first_free
&= ~((u64
)sectorsize
- 1);
2606 /* backup for extent #0 should exist */
2607 if(!test_range_bit(&io_tree
, 0, first_free
- 1, EXTENT_LOCKED
, 1)) {
2608 fprintf(stderr
, "no backup for the first extent\n");
2611 /* force no allocation from system block group */
2612 root
->fs_info
->system_allocs
= -1;
2613 trans
= btrfs_start_transaction(root
, 1);
2616 * recow the whole chunk tree, this will remove all chunk tree blocks
2617 * from system block group
2619 chunk_root
= root
->fs_info
->chunk_root
;
2620 memset(&key
, 0, sizeof(key
));
2622 ret
= btrfs_search_slot(trans
, chunk_root
, &key
, &path
, 0, 1);
2626 ret
= btrfs_next_leaf(chunk_root
, &path
);
2630 btrfs_item_key_to_cpu(path
.nodes
[0], &key
, path
.slots
[0]);
2631 btrfs_release_path(&path
);
2633 btrfs_release_path(&path
);
2638 cache1
= btrfs_lookup_block_group(root
->fs_info
, offset
);
2642 if (cache1
->flags
& BTRFS_BLOCK_GROUP_SYSTEM
)
2643 num_bytes
+= btrfs_block_group_used(&cache1
->item
);
2645 offset
= cache1
->key
.objectid
+ cache1
->key
.offset
;
2647 /* only extent #0 left in system block group? */
2648 if (num_bytes
> first_free
) {
2649 fprintf(stderr
, "unable to empty system block group\n");
2652 /* create a system chunk that maps the whole device */
2653 ret
= prepare_system_chunk_sb(root
->fs_info
->super_copy
);
2655 fprintf(stderr
, "unable to update system chunk\n");
2659 ret
= btrfs_commit_transaction(trans
, root
);
2662 ret
= close_ctree(root
);
2664 fprintf(stderr
, "error during close_ctree %d\n", ret
);
2668 /* zero btrfs super block mirrors */
2669 memset(buf
, 0, sectorsize
);
2670 for (i
= 1 ; i
< BTRFS_SUPER_MIRROR_MAX
; i
++) {
2671 bytenr
= btrfs_sb_offset(i
);
2672 if (bytenr
>= total_bytes
)
2674 ret
= pwrite(fd
, buf
, sectorsize
, bytenr
);
2675 if (ret
!= sectorsize
) {
2677 "error during zeroing supreblock %d: %d\n",
2683 sb_bytenr
= (u64
)-1;
2684 /* copy all relocated blocks back */
2686 ret
= find_first_extent_bit(&io_tree
, 0, &start
, &end
,
2691 ret
= get_state_private(&io_tree
, start
, &bytenr
);
2694 clear_extent_bits(&io_tree
, start
, end
, EXTENT_LOCKED
,
2697 while (start
<= end
) {
2698 if (start
== BTRFS_SUPER_INFO_OFFSET
) {
2702 ret
= pread(fd
, buf
, sectorsize
, bytenr
);
2704 fprintf(stderr
, "error during pread %d\n", ret
);
2707 BUG_ON(ret
!= sectorsize
);
2708 ret
= pwrite(fd
, buf
, sectorsize
, start
);
2710 fprintf(stderr
, "error during pwrite %d\n", ret
);
2713 BUG_ON(ret
!= sectorsize
);
2715 start
+= sectorsize
;
2716 bytenr
+= sectorsize
;
2722 fprintf(stderr
, "error during fsync %d\n", ret
);
2726 * finally, overwrite btrfs super block.
2728 ret
= pread(fd
, buf
, sectorsize
, sb_bytenr
);
2730 fprintf(stderr
, "error during pread %d\n", ret
);
2733 BUG_ON(ret
!= sectorsize
);
2734 ret
= pwrite(fd
, buf
, sectorsize
, BTRFS_SUPER_INFO_OFFSET
);
2736 fprintf(stderr
, "error during pwrite %d\n", ret
);
2739 BUG_ON(ret
!= sectorsize
);
2742 fprintf(stderr
, "error during fsync %d\n", ret
);
2748 extent_io_tree_cleanup(&io_tree
);
2749 printf("rollback complete.\n");
2756 fprintf(stderr
, "rollback aborted.\n");
2760 static void print_usage(void)
2762 printf("usage: btrfs-convert [-d] [-i] [-n] [-r] [-l label] [-L] device\n");
2763 printf("\t-d disable data checksum\n");
2764 printf("\t-i ignore xattrs and ACLs\n");
2765 printf("\t-n disable packing of small files\n");
2766 printf("\t-r roll back to ext2fs\n");
2767 printf("\t-l LABEL set filesystem label\n");
2768 printf("\t-L use label from converted fs\n");
2769 printf("\t-p show converting progress\n");
2772 int main(int argc
, char *argv
[])
2780 int usage_error
= 0;
2783 char *fslabel
= NULL
;
2786 int c
= getopt(argc
, argv
, "dinrl:Lp");
2804 fslabel
= strdup(optarg
);
2805 if (strlen(fslabel
) > BTRFS_LABEL_SIZE
) {
2807 "warning: label too long, trimmed to %d bytes\n",
2809 fslabel
[BTRFS_LABEL_SIZE
] = 0;
2823 argc
= argc
- optind
;
2825 if (check_argc_exact(argc
, 1)) {
2830 if (rollback
&& (!datacsum
|| noxattr
|| !packing
)) {
2832 "Usage error: -d, -i, -n options do not apply to rollback\n");
2841 file
= argv
[optind
];
2842 ret
= check_mounted(file
);
2844 fprintf(stderr
, "Could not check mount status: %s\n",
2848 fprintf(stderr
, "%s is mounted\n", file
);
2853 ret
= do_rollback(file
);
2855 ret
= do_convert(file
, datacsum
, packing
, noxattr
, copylabel
, fslabel
, progress
);