?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
btrfs-progs v0.19
[btrfs-progs-unstable/devel.git] / convert.c
blobd2c9efa9db4e541d57552ad6011c9540069b4443
1 /*
2 * Copyright (C) 2007 Oracle. All rights reserved.
3 *
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.
7 *
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.
12 *
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.
17 */
18
19 #define _XOPEN_SOURCE 600
20 #define _GNU_SOURCE 1
21 #ifndef __CHECKER__
22 #include <sys/ioctl.h>
23 #include <sys/mount.h>
24 #endif
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <sys/types.h>
28 #include <sys/stat.h>
29 #include <sys/acl.h>
30 #include <fcntl.h>
31 #include <unistd.h>
32 #include <uuid/uuid.h>
33 #include <linux/fs.h>
34 #include "kerncompat.h"
35 #include "ctree.h"
36 #include "disk-io.h"
37 #include "volumes.h"
38 #include "transaction.h"
39 #include "crc32c.h"
40 #include "utils.h"
41 #include <ext2fs/ext2_fs.h>
42 #include <ext2fs/ext2fs.h>
43 #include <ext2fs/ext2_ext_attr.h>
44
45 #define INO_OFFSET (BTRFS_FIRST_FREE_OBJECTID - EXT2_ROOT_INO)
46 #define STRIPE_LEN (64 * 1024)
47 #define EXT2_IMAGE_SUBVOL_OBJECTID BTRFS_FIRST_FREE_OBJECTID
48
49 /*
50 * Open Ext2fs in readonly mode, read block allocation bitmap and
51 * inode bitmap into memory.
52 */
53 static int open_ext2fs(const char *name, ext2_filsys *ret_fs)
54 {
55 errcode_t ret;
56 ext2_filsys ext2_fs;
57 ext2_ino_t ino;
58 ret = ext2fs_open(name, 0, 0, 0, unix_io_manager, &ext2_fs);
59 if (ret) {
60 fprintf(stderr, "ext2fs_open: %s\n", error_message(ret));
61 goto fail;
62 }
63 ret = ext2fs_read_inode_bitmap(ext2_fs);
64 if (ret) {
65 fprintf(stderr, "ext2fs_read_inode_bitmap: %s\n",
66 error_message(ret));
67 goto fail;
68 }
69 ret = ext2fs_read_block_bitmap(ext2_fs);
70 if (ret) {
71 fprintf(stderr, "ext2fs_read_block_bitmap: %s\n",
72 error_message(ret));
73 goto fail;
74 }
75 /*
76 * search each block group for a free inode. this set up
77 * uninit block/inode bitmaps appropriately.
78 */
79 ino = 1;
80 while (ino <= ext2_fs->super->s_inodes_count) {
81 ext2_ino_t foo;
82 ext2fs_new_inode(ext2_fs, ino, 0, NULL, &foo);
83 ino += EXT2_INODES_PER_GROUP(ext2_fs->super);
84 }
85
86 *ret_fs = ext2_fs;
87 return 0;
88 fail:
89 return -1;
90 }
91
92 static int close_ext2fs(ext2_filsys fs)
93 {
94 ext2fs_close(fs);
95 return 0;
96 }
97
98 static int ext2_alloc_block(ext2_filsys fs, u64 goal, u64 *block_ret)
99 {
100 blk_t block;
101
102 if (!ext2fs_new_block(fs, goal, NULL, &block)) {
103 ext2fs_fast_mark_block_bitmap(fs->block_map, block);
104 *block_ret = block;
105 return 0;
106 }
107 return -ENOSPC;
108 }
109
110 static int ext2_free_block(ext2_filsys fs, u64 block)
111 {
112 BUG_ON(block != (blk_t)block);
113 ext2fs_fast_unmark_block_bitmap(fs->block_map, block);
114 return 0;
115 }
116
117 static int cache_free_extents(struct btrfs_root *root, ext2_filsys ext2_fs)
118
119 {
120 int i, ret = 0;
121 blk_t block;
122 u64 bytenr;
123 u64 blocksize = ext2_fs->blocksize;
124
125 block = ext2_fs->super->s_first_data_block;
126 for (; block < ext2_fs->super->s_blocks_count; block++) {
127 if (ext2fs_fast_test_block_bitmap(ext2_fs->block_map, block))
128 continue;
129 bytenr = block * blocksize;
130 ret = set_extent_dirty(&root->fs_info->free_space_cache,
131 bytenr, bytenr + blocksize - 1, 0);
132 BUG_ON(ret);
133 }
134
135 for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
136 bytenr = btrfs_sb_offset(i);
137 bytenr &= ~((u64)STRIPE_LEN - 1);
138 if (bytenr >= blocksize * ext2_fs->super->s_blocks_count)
139 break;
140 clear_extent_dirty(&root->fs_info->free_space_cache, bytenr,
141 bytenr + STRIPE_LEN - 1, 0);
142 }
143
144 clear_extent_dirty(&root->fs_info->free_space_cache,
145 0, BTRFS_SUPER_INFO_OFFSET - 1, 0);
146
147 return 0;
148 }
149
150 static int custom_alloc_extent(struct btrfs_root *root, u64 num_bytes,
151 u64 hint_byte, struct btrfs_key *ins)
152 {
153 u64 start;
154 u64 end;
155 u64 last = hint_byte;
156 int ret;
157 int wrapped = 0;
158 struct btrfs_block_group_cache *cache;
159
160 while(1) {
161 ret = find_first_extent_bit(&root->fs_info->free_space_cache,
162 last, &start, &end, EXTENT_DIRTY);
163 if (ret) {
164 if (wrapped++ == 0) {
165 last = 0;
166 continue;
167 } else {
168 goto fail;
169 }
170 }
171
172 start = max(last, start);
173 last = end + 1;
174 if (last - start < num_bytes)
175 continue;
176
177 last = start + num_bytes;
178 if (test_range_bit(&root->fs_info->pinned_extents,
179 start, last - 1, EXTENT_DIRTY, 0))
180 continue;
181
182 cache = btrfs_lookup_block_group(root->fs_info, start);
183 BUG_ON(!cache);
184 if (cache->flags & BTRFS_BLOCK_GROUP_SYSTEM ||
185 last > cache->key.objectid + cache->key.offset) {
186 last = cache->key.objectid + cache->key.offset;
187 continue;
188 }
189
190 clear_extent_dirty(&root->fs_info->free_space_cache,
191 start, start + num_bytes - 1, 0);
192
193 ins->objectid = start;
194 ins->offset = num_bytes;
195 ins->type = BTRFS_EXTENT_ITEM_KEY;
196 return 0;
197 }
198 fail:
199 fprintf(stderr, "not enough free space\n");
200 return -ENOSPC;
201 }
202
203 static int intersect_with_sb(u64 bytenr, u64 num_bytes)
204 {
205 int i;
206 u64 offset;
207
208 for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
209 offset = btrfs_sb_offset(i);
210 offset &= ~((u64)STRIPE_LEN - 1);
211
212 if (bytenr < offset + STRIPE_LEN &&
213 bytenr + num_bytes > offset)
214 return 1;
215 }
216 return 0;
217 }
218
219 static int custom_free_extent(struct btrfs_root *root, u64 bytenr,
220 u64 num_bytes)
221 {
222 return intersect_with_sb(bytenr, num_bytes);
223 }
224
225 struct btrfs_extent_ops extent_ops = {
226 .alloc_extent = custom_alloc_extent,
227 .free_extent = custom_free_extent,
228 };
229
230 struct dir_iterate_data {
231 struct btrfs_trans_handle *trans;
232 struct btrfs_root *root;
233 struct btrfs_inode_item *inode;
234 u64 objectid;
235 u64 index_cnt;
236 u64 parent;
237 int errcode;
238 };
239
240 static u8 filetype_conversion_table[EXT2_FT_MAX] = {
241 [EXT2_FT_UNKNOWN] = BTRFS_FT_UNKNOWN,
242 [EXT2_FT_REG_FILE] = BTRFS_FT_REG_FILE,
243 [EXT2_FT_DIR] = BTRFS_FT_DIR,
244 [EXT2_FT_CHRDEV] = BTRFS_FT_CHRDEV,
245 [EXT2_FT_BLKDEV] = BTRFS_FT_BLKDEV,
246 [EXT2_FT_FIFO] = BTRFS_FT_FIFO,
247 [EXT2_FT_SOCK] = BTRFS_FT_SOCK,
248 [EXT2_FT_SYMLINK] = BTRFS_FT_SYMLINK,
249 };
250
251 static int dir_iterate_proc(ext2_ino_t dir, int entry,
252 struct ext2_dir_entry *old,
253 int offset, int blocksize,
254 char *buf,void *priv_data)
255 {
256 int ret;
257 int file_type;
258 u64 objectid;
259 u64 inode_size;
260 char dotdot[] = "..";
261 struct btrfs_key location;
262 struct ext2_dir_entry_2 *dirent = (struct ext2_dir_entry_2 *)old;
263 struct dir_iterate_data *idata = (struct dir_iterate_data *)priv_data;
264
265 objectid = dirent->inode + INO_OFFSET;
266 if (!strncmp(dirent->name, dotdot, dirent->name_len)) {
267 if (dirent->name_len == 2) {
268 BUG_ON(idata->parent != 0);
269 idata->parent = objectid;
270 }
271 return 0;
272 }
273 if (dirent->inode < EXT2_GOOD_OLD_FIRST_INO)
274 return 0;
275
276 location.objectid = objectid;
277 location.offset = 0;
278 btrfs_set_key_type(&location, BTRFS_INODE_ITEM_KEY);
279
280 file_type = dirent->file_type;
281 BUG_ON(file_type > EXT2_FT_SYMLINK);
282 ret = btrfs_insert_dir_item(idata->trans, idata->root,
283 dirent->name, dirent->name_len,
284 idata->objectid, &location,
285 filetype_conversion_table[file_type],
286 idata->index_cnt);
287 if (ret)
288 goto fail;
289 ret = btrfs_insert_inode_ref(idata->trans, idata->root,
290 dirent->name, dirent->name_len,
291 objectid, idata->objectid,
292 idata->index_cnt);
293 if (ret)
294 goto fail;
295 idata->index_cnt++;
296 inode_size = btrfs_stack_inode_size(idata->inode) +
297 dirent->name_len * 2;
298 btrfs_set_stack_inode_size(idata->inode, inode_size);
299 return 0;
300 fail:
301 idata->errcode = ret;
302 return BLOCK_ABORT;
303 }
304
305 static int create_dir_entries(struct btrfs_trans_handle *trans,
306 struct btrfs_root *root, u64 objectid,
307 struct btrfs_inode_item *btrfs_inode,
308 ext2_filsys ext2_fs, ext2_ino_t ext2_ino)
309 {
310 int ret;
311 errcode_t err;
312 struct dir_iterate_data data = {
313 .trans = trans,
314 .root = root,
315 .inode = btrfs_inode,
316 .objectid = objectid,
317 .index_cnt = 2,
318 .parent = 0,
319 .errcode = 0,
320 };
321
322 err = ext2fs_dir_iterate2(ext2_fs, ext2_ino, 0, NULL,
323 dir_iterate_proc, &data);
324 if (err)
325 goto error;
326 ret = data.errcode;
327 if (ret == 0 && data.parent == objectid) {
328 ret = btrfs_insert_inode_ref(trans, root, "..", 2,
329 objectid, objectid, 0);
330 }
331 return ret;
332 error:
333 fprintf(stderr, "ext2fs_dir_iterate2: %s\n", error_message(err));
334 return -1;
335 }
336
337 static int read_disk_extent(struct btrfs_root *root, u64 bytenr,
338 u32 num_bytes, char *buffer)
339 {
340 int ret;
341 struct btrfs_fs_devices *fs_devs = root->fs_info->fs_devices;
342
343 ret = pread(fs_devs->latest_bdev, buffer, num_bytes, bytenr);
344 if (ret != num_bytes)
345 goto fail;
346 ret = 0;
347 fail:
348 if (ret > 0)
349 ret = -1;
350 return ret;
351 }
352 /*
353 * Record a file extent. Do all the required works, such as inserting
354 * file extent item, inserting extent item and backref item into extent
355 * tree and updating block accounting.
356 */
357 static int record_file_extent(struct btrfs_trans_handle *trans,
358 struct btrfs_root *root, u64 objectid,
359 struct btrfs_inode_item *inode,
360 u64 file_pos, u64 disk_bytenr,
361 u64 num_bytes, int checksum)
362 {
363 int ret;
364 struct btrfs_fs_info *info = root->fs_info;
365 struct btrfs_root *extent_root = info->extent_root;
366 struct extent_buffer *leaf;
367 struct btrfs_file_extent_item *fi;
368 struct btrfs_key ins_key;
369 struct btrfs_path path;
370 struct btrfs_extent_item *ei;
371 u32 blocksize = root->sectorsize;
372 u64 nbytes;
373 u64 bytes_used;
374
375 if (disk_bytenr == 0) {
376 ret = btrfs_insert_file_extent(trans, root, objectid,
377 file_pos, disk_bytenr,
378 num_bytes, num_bytes);
379 return ret;
380 }
381
382 btrfs_init_path(&path);
383
384 if (checksum) {
385 u64 offset;
386 char *buffer;
387
388 ret = -ENOMEM;
389 buffer = malloc(blocksize);
390 if (!buffer)
391 goto fail;
392 for (offset = 0; offset < num_bytes; offset += blocksize) {
393 ret = read_disk_extent(root, disk_bytenr + offset,
394 blocksize, buffer);
395 if (ret)
396 break;
397 ret = btrfs_csum_file_block(trans,
398 root->fs_info->csum_root,
399 disk_bytenr + num_bytes,
400 disk_bytenr + offset,
401 buffer, blocksize);
402 if (ret)
403 break;
404 }
405 free(buffer);
406 if (ret)
407 goto fail;
408 }
409
410 ins_key.objectid = objectid;
411 ins_key.offset = file_pos;
412 btrfs_set_key_type(&ins_key, BTRFS_EXTENT_DATA_KEY);
413 ret = btrfs_insert_empty_item(trans, root, &path, &ins_key,
414 sizeof(*fi));
415 if (ret)
416 goto fail;
417 leaf = path.nodes[0];
418 fi = btrfs_item_ptr(leaf, path.slots[0],
419 struct btrfs_file_extent_item);
420 btrfs_set_file_extent_generation(leaf, fi, trans->transid);
421 btrfs_set_file_extent_type(leaf, fi, BTRFS_FILE_EXTENT_REG);
422 btrfs_set_file_extent_disk_bytenr(leaf, fi, disk_bytenr);
423 btrfs_set_file_extent_disk_num_bytes(leaf, fi, num_bytes);
424 btrfs_set_file_extent_offset(leaf, fi, 0);
425 btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
426 btrfs_set_file_extent_ram_bytes(leaf, fi, num_bytes);
427 btrfs_set_file_extent_compression(leaf, fi, 0);
428 btrfs_set_file_extent_encryption(leaf, fi, 0);
429 btrfs_set_file_extent_other_encoding(leaf, fi, 0);
430 btrfs_mark_buffer_dirty(leaf);
431
432 nbytes = btrfs_stack_inode_nbytes(inode) + num_bytes;
433 btrfs_set_stack_inode_nbytes(inode, nbytes);
434
435 bytes_used = btrfs_root_used(&root->root_item);
436 btrfs_set_root_used(&root->root_item, bytes_used + num_bytes);
437
438 btrfs_release_path(root, &path);
439
440 ins_key.objectid = disk_bytenr;
441 ins_key.offset = num_bytes;
442 ins_key.type = BTRFS_EXTENT_ITEM_KEY;
443
444 ret = btrfs_insert_empty_item(trans, extent_root, &path,
445 &ins_key, sizeof(*ei));
446 if (ret == 0) {
447 leaf = path.nodes[0];
448 ei = btrfs_item_ptr(leaf, path.slots[0],
449 struct btrfs_extent_item);
450
451 btrfs_set_extent_refs(leaf, ei, 0);
452 btrfs_set_extent_generation(leaf, ei, 0);
453 btrfs_set_extent_flags(leaf, ei, BTRFS_EXTENT_FLAG_DATA);
454
455 btrfs_mark_buffer_dirty(leaf);
456
457 bytes_used = btrfs_super_bytes_used(&info->super_copy);
458 btrfs_set_super_bytes_used(&info->super_copy, bytes_used +
459 num_bytes);
460 ret = btrfs_update_block_group(trans, root, disk_bytenr,
461 num_bytes, 1, 0);
462 if (ret)
463 goto fail;
464 } else if (ret != -EEXIST) {
465 goto fail;
466 }
467 btrfs_extent_post_op(trans, extent_root);
468
469 ret = btrfs_inc_extent_ref(trans, root, disk_bytenr, num_bytes, 0,
470 root->root_key.objectid,
471 objectid, file_pos);
472 if (ret)
473 goto fail;
474 ret = 0;
475 fail:
476 btrfs_release_path(root, &path);
477 return ret;
478 }
479
480 static int record_file_blocks(struct btrfs_trans_handle *trans,
481 struct btrfs_root *root, u64 objectid,
482 struct btrfs_inode_item *inode,
483 u64 file_block, u64 disk_block,
484 u64 num_blocks, int checksum)
485 {
486 u64 file_pos = file_block * root->sectorsize;
487 u64 disk_bytenr = disk_block * root->sectorsize;
488 u64 num_bytes = num_blocks * root->sectorsize;
489 return record_file_extent(trans, root, objectid, inode, file_pos,
490 disk_bytenr, num_bytes, checksum);
491 }
492
493 struct blk_iterate_data {
494 struct btrfs_trans_handle *trans;
495 struct btrfs_root *root;
496 struct btrfs_inode_item *inode;
497 u64 objectid;
498 u64 first_block;
499 u64 disk_block;
500 u64 num_blocks;
501 u64 boundary;
502 int checksum;
503 int errcode;
504 };
505
506 static int block_iterate_proc(ext2_filsys ext2_fs,
507 u64 disk_block, u64 file_block,
508 struct blk_iterate_data *idata)
509 {
510 int ret;
511 int sb_region;
512 int do_barrier;
513 struct btrfs_root *root = idata->root;
514 struct btrfs_trans_handle *trans = idata->trans;
515 struct btrfs_block_group_cache *cache;
516 u64 bytenr = disk_block * root->sectorsize;
517
518 sb_region = intersect_with_sb(bytenr, root->sectorsize);
519 do_barrier = sb_region || disk_block >= idata->boundary;
520 if ((idata->num_blocks > 0 && do_barrier) ||
521 (file_block > idata->first_block + idata->num_blocks) ||
522 (disk_block != idata->disk_block + idata->num_blocks)) {
523 if (idata->num_blocks > 0) {
524 ret = record_file_blocks(trans, root, idata->objectid,
525 idata->inode, idata->first_block,
526 idata->disk_block, idata->num_blocks,
527 idata->checksum);
528 if (ret)
529 goto fail;
530 idata->first_block += idata->num_blocks;
531 idata->num_blocks = 0;
532 }
533 if (file_block > idata->first_block) {
534 ret = record_file_blocks(trans, root, idata->objectid,
535 idata->inode, idata->first_block,
536 0, file_block - idata->first_block,
537 idata->checksum);
538 if (ret)
539 goto fail;
540 }
541
542 if (sb_region) {
543 bytenr += STRIPE_LEN - 1;
544 bytenr &= ~((u64)STRIPE_LEN - 1);
545 } else {
546 cache = btrfs_lookup_block_group(root->fs_info, bytenr);
547 BUG_ON(!cache);
548 bytenr = cache->key.objectid + cache->key.offset;
549 }
550
551 idata->first_block = file_block;
552 idata->disk_block = disk_block;
553 idata->boundary = bytenr / root->sectorsize;
554 }
555 idata->num_blocks++;
556 return 0;
557 fail:
558 idata->errcode = ret;
559 return BLOCK_ABORT;
560 }
561
562 static int __block_iterate_proc(ext2_filsys fs, blk_t *blocknr,
563 e2_blkcnt_t blockcnt, blk_t ref_block,
564 int ref_offset, void *priv_data)
565 {
566 struct blk_iterate_data *idata;
567 idata = (struct blk_iterate_data *)priv_data;
568 return block_iterate_proc(fs, *blocknr, blockcnt, idata);
569 }
570
571 /*
572 * traverse file's data blocks, record these data blocks as file extents.
573 */
574 static int create_file_extents(struct btrfs_trans_handle *trans,
575 struct btrfs_root *root, u64 objectid,
576 struct btrfs_inode_item *btrfs_inode,
577 ext2_filsys ext2_fs, ext2_ino_t ext2_ino,
578 int datacsum, int packing)
579 {
580 int ret;
581 char *buffer = NULL;
582 errcode_t err;
583 u32 last_block;
584 u32 sectorsize = root->sectorsize;
585 u64 inode_size = btrfs_stack_inode_size(btrfs_inode);
586 struct blk_iterate_data data = {
587 .trans = trans,
588 .root = root,
589 .inode = btrfs_inode,
590 .objectid = objectid,
591 .first_block = 0,
592 .disk_block = 0,
593 .num_blocks = 0,
594 .boundary = (u64)-1,
595 .checksum = datacsum,
596 .errcode = 0,
597 };
598 err = ext2fs_block_iterate2(ext2_fs, ext2_ino, BLOCK_FLAG_DATA_ONLY,
599 NULL, __block_iterate_proc, &data);
600 if (err)
601 goto error;
602 ret = data.errcode;
603 if (ret)
604 goto fail;
605 if (packing && data.first_block == 0 && data.num_blocks > 0 &&
606 inode_size <= BTRFS_MAX_INLINE_DATA_SIZE(root)) {
607 u64 num_bytes = data.num_blocks * sectorsize;
608 u64 disk_bytenr = data.disk_block * sectorsize;
609 u64 nbytes;
610
611 buffer = malloc(num_bytes);
612 if (!buffer)
613 return -ENOMEM;
614 ret = read_disk_extent(root, disk_bytenr, num_bytes, buffer);
615 if (ret)
616 goto fail;
617 if (num_bytes > inode_size)
618 num_bytes = inode_size;
619 ret = btrfs_insert_inline_extent(trans, root, objectid,
620 0, buffer, num_bytes);
621 if (ret)
622 goto fail;
623 nbytes = btrfs_stack_inode_nbytes(btrfs_inode) + num_bytes;
624 btrfs_set_stack_inode_nbytes(btrfs_inode, nbytes);
625 } else if (data.num_blocks > 0) {
626 ret = record_file_blocks(trans, root, objectid, btrfs_inode,
627 data.first_block, data.disk_block,
628 data.num_blocks, data.checksum);
629 if (ret)
630 goto fail;
631 }
632 data.first_block += data.num_blocks;
633 last_block = (inode_size + sectorsize - 1) / sectorsize;
634 if (last_block > data.first_block) {
635 ret = record_file_blocks(trans, root, objectid, btrfs_inode,
636 data.first_block, 0, last_block -
637 data.first_block, data.checksum);
638 }
639 fail:
640 if (buffer)
641 free(buffer);
642 return ret;
643 error:
644 fprintf(stderr, "ext2fs_block_iterate2: %s\n", error_message(err));
645 return -1;
646 }
647
648 static int create_symbol_link(struct btrfs_trans_handle *trans,
649 struct btrfs_root *root, u64 objectid,
650 struct btrfs_inode_item *btrfs_inode,
651 ext2_filsys ext2_fs, ext2_ino_t ext2_ino,
652 struct ext2_inode *ext2_inode)
653 {
654 int ret;
655 char *pathname;
656 u64 inode_size = btrfs_stack_inode_size(btrfs_inode);
657 if (ext2fs_inode_data_blocks(ext2_fs, ext2_inode)) {
658 btrfs_set_stack_inode_size(btrfs_inode, inode_size + 1);
659 ret = create_file_extents(trans, root, objectid, btrfs_inode,
660 ext2_fs, ext2_ino, 1, 1);
661 btrfs_set_stack_inode_size(btrfs_inode, inode_size);
662 return ret;
663 }
664
665 pathname = (char *)&(ext2_inode->i_block[0]);
666 BUG_ON(pathname[inode_size] != 0);
667 ret = btrfs_insert_inline_extent(trans, root, objectid, 0,
668 pathname, inode_size + 1);
669 btrfs_set_stack_inode_nbytes(btrfs_inode, inode_size + 1);
670 return ret;
671 }
672
673 /*
674 * Following xattr/acl related codes are based on codes in
675 * fs/ext3/xattr.c and fs/ext3/acl.c
676 */
677 #define EXT2_XATTR_BHDR(ptr) ((struct ext2_ext_attr_header *)(ptr))
678 #define EXT2_XATTR_BFIRST(ptr) \
679 ((struct ext2_ext_attr_entry *)(EXT2_XATTR_BHDR(ptr) + 1))
680 #define EXT2_XATTR_IHDR(inode) \
681 ((struct ext2_ext_attr_header *) ((void *)(inode) + \
682 EXT2_GOOD_OLD_INODE_SIZE + (inode)->i_extra_isize))
683 #define EXT2_XATTR_IFIRST(inode) \
684 ((struct ext2_ext_attr_entry *) ((void *)EXT2_XATTR_IHDR(inode) + \
685 sizeof(EXT2_XATTR_IHDR(inode)->h_magic)))
686
687 static int ext2_xattr_check_names(struct ext2_ext_attr_entry *entry,
688 const void *end)
689 {
690 struct ext2_ext_attr_entry *next;
691
692 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
693 next = EXT2_EXT_ATTR_NEXT(entry);
694 if ((void *)next >= end)
695 return -EIO;
696 entry = next;
697 }
698 return 0;
699 }
700
701 static int ext2_xattr_check_block(const char *buf, size_t size)
702 {
703 int error;
704 struct ext2_ext_attr_header *header = EXT2_XATTR_BHDR(buf);
705
706 if (header->h_magic != EXT2_EXT_ATTR_MAGIC ||
707 header->h_blocks != 1)
708 return -EIO;
709 error = ext2_xattr_check_names(EXT2_XATTR_BFIRST(buf), buf + size);
710 return error;
711 }
712
713 static int ext2_xattr_check_entry(struct ext2_ext_attr_entry *entry,
714 size_t size)
715 {
716 size_t value_size = entry->e_value_size;
717
718 if (entry->e_value_block != 0 || value_size > size ||
719 entry->e_value_offs + value_size > size)
720 return -EIO;
721 return 0;
722 }
723
724 #define EXT2_ACL_VERSION 0x0001
725
726 typedef struct {
727 __le16 e_tag;
728 __le16 e_perm;
729 __le32 e_id;
730 } ext2_acl_entry;
731
732 typedef struct {
733 __le16 e_tag;
734 __le16 e_perm;
735 } ext2_acl_entry_short;
736
737 typedef struct {
738 __le32 a_version;
739 } ext2_acl_header;
740
741 static inline int ext2_acl_count(size_t size)
742 {
743 ssize_t s;
744 size -= sizeof(ext2_acl_header);
745 s = size - 4 * sizeof(ext2_acl_entry_short);
746 if (s < 0) {
747 if (size % sizeof(ext2_acl_entry_short))
748 return -1;
749 return size / sizeof(ext2_acl_entry_short);
750 } else {
751 if (s % sizeof(ext2_acl_entry))
752 return -1;
753 return s / sizeof(ext2_acl_entry) + 4;
754 }
755 }
756
757 #define ACL_EA_VERSION 0x0002
758
759 typedef struct {
760 __le16 e_tag;
761 __le16 e_perm;
762 __le32 e_id;
763 } acl_ea_entry;
764
765 typedef struct {
766 __le32 a_version;
767 acl_ea_entry a_entries[0];
768 } acl_ea_header;
769
770 static inline size_t acl_ea_size(int count)
771 {
772 return sizeof(acl_ea_header) + count * sizeof(acl_ea_entry);
773 }
774
775 static int ext2_acl_to_xattr(void *dst, const void *src,
776 size_t dst_size, size_t src_size)
777 {
778 int i, count;
779 const void *end = src + src_size;
780 acl_ea_header *ext_acl = (acl_ea_header *)dst;
781 acl_ea_entry *dst_entry = ext_acl->a_entries;
782 ext2_acl_entry *src_entry;
783
784 if (src_size < sizeof(ext2_acl_header))
785 goto fail;
786 if (((ext2_acl_header *)src)->a_version !=
787 cpu_to_le32(EXT2_ACL_VERSION))
788 goto fail;
789 src += sizeof(ext2_acl_header);
790 count = ext2_acl_count(src_size);
791 if (count <= 0)
792 goto fail;
793
794 BUG_ON(dst_size < acl_ea_size(count));
795 ext_acl->a_version = cpu_to_le32(ACL_EA_VERSION);
796 for (i = 0; i < count; i++, dst_entry++) {
797 src_entry = (ext2_acl_entry *)src;
798 if (src + sizeof(ext2_acl_entry_short) > end)
799 goto fail;
800 dst_entry->e_tag = src_entry->e_tag;
801 dst_entry->e_perm = src_entry->e_perm;
802 switch (le16_to_cpu(src_entry->e_tag)) {
803 case ACL_USER_OBJ:
804 case ACL_GROUP_OBJ:
805 case ACL_MASK:
806 case ACL_OTHER:
807 src += sizeof(ext2_acl_entry_short);
808 dst_entry->e_id = cpu_to_le32(ACL_UNDEFINED_ID);
809 break;
810 case ACL_USER:
811 case ACL_GROUP:
812 src += sizeof(ext2_acl_entry);
813 if (src > end)
814 goto fail;
815 dst_entry->e_id = src_entry->e_id;
816 break;
817 default:
818 goto fail;
819 }
820 }
821 if (src != end)
822 goto fail;
823 return 0;
824 fail:
825 return -EINVAL;
826 }
827
828 static char *xattr_prefix_table[] = {
829 [1] = "user.",
830 [2] = "system.posix_acl_access",
831 [3] = "system.posix_acl_default",
832 [4] = "trusted.",
833 [6] = "security.",
834 };
835
836 static int copy_single_xattr(struct btrfs_trans_handle *trans,
837 struct btrfs_root *root, u64 objectid,
838 struct ext2_ext_attr_entry *entry,
839 const void *data, u32 datalen)
840 {
841 int ret = 0;
842 int name_len;
843 int name_index;
844 void *databuf = NULL;
845 char namebuf[XATTR_NAME_MAX + 1];
846
847 name_index = entry->e_name_index;
848 if (name_index >= ARRAY_SIZE(xattr_prefix_table) ||
849 xattr_prefix_table[name_index] == NULL)
850 return -EOPNOTSUPP;
851 name_len = strlen(xattr_prefix_table[name_index]) +
852 entry->e_name_len;
853 if (name_len >= sizeof(namebuf))
854 return -ERANGE;
855
856 if (name_index == 2 || name_index == 3) {
857 size_t bufsize = acl_ea_size(ext2_acl_count(datalen));
858 databuf = malloc(bufsize);
859 if (!databuf)
860 return -ENOMEM;
861 ret = ext2_acl_to_xattr(databuf, data, bufsize, datalen);
862 if (ret)
863 goto out;
864 data = databuf;
865 datalen = bufsize;
866 }
867 strcpy(namebuf, xattr_prefix_table[name_index]);
868 strncat(namebuf, EXT2_EXT_ATTR_NAME(entry), entry->e_name_len);
869 if (name_len + datalen > BTRFS_LEAF_DATA_SIZE(root) -
870 sizeof(struct btrfs_item) - sizeof(struct btrfs_dir_item)) {
871 fprintf(stderr, "skip large xattr on inode %Lu name %.*s\n",
872 objectid - INO_OFFSET, name_len, namebuf);
873 goto out;
874 }
875 ret = btrfs_insert_xattr_item(trans, root, namebuf, name_len,
876 data, datalen, objectid);
877 out:
878 if (databuf)
879 free(databuf);
880 return ret;
881 }
882
883 static int copy_extended_attrs(struct btrfs_trans_handle *trans,
884 struct btrfs_root *root, u64 objectid,
885 struct btrfs_inode_item *btrfs_inode,
886 ext2_filsys ext2_fs, ext2_ino_t ext2_ino)
887 {
888 int ret = 0;
889 int inline_ea = 0;
890 errcode_t err;
891 u32 datalen;
892 u32 block_size = ext2_fs->blocksize;
893 u32 inode_size = EXT2_INODE_SIZE(ext2_fs->super);
894 struct ext2_inode_large *ext2_inode;
895 struct ext2_ext_attr_entry *entry;
896 void *data;
897 char *buffer = NULL;
898 char inode_buf[EXT2_GOOD_OLD_INODE_SIZE];
899
900 if (inode_size <= EXT2_GOOD_OLD_INODE_SIZE) {
901 ext2_inode = (struct ext2_inode_large *)inode_buf;
902 } else {
903 ext2_inode = (struct ext2_inode_large *)malloc(inode_size);
904 if (!ext2_inode)
905 return -ENOMEM;
906 }
907 err = ext2fs_read_inode_full(ext2_fs, ext2_ino, (void *)ext2_inode,
908 inode_size);
909 if (err) {
910 fprintf(stderr, "ext2fs_read_inode_full: %s\n",
911 error_message(err));
912 ret = -1;
913 goto out;
914 }
915
916 if (ext2_ino > ext2_fs->super->s_first_ino &&
917 inode_size > EXT2_GOOD_OLD_INODE_SIZE) {
918 if (EXT2_GOOD_OLD_INODE_SIZE +
919 ext2_inode->i_extra_isize > inode_size) {
920 ret = -EIO;
921 goto out;
922 }
923 if (ext2_inode->i_extra_isize != 0 &&
924 EXT2_XATTR_IHDR(ext2_inode)->h_magic ==
925 EXT2_EXT_ATTR_MAGIC) {
926 inline_ea = 1;
927 }
928 }
929 if (inline_ea) {
930 int total;
931 void *end = (void *)ext2_inode + inode_size;
932 entry = EXT2_XATTR_IFIRST(ext2_inode);
933 total = end - (void *)entry;
934 ret = ext2_xattr_check_names(entry, end);
935 if (ret)
936 goto out;
937 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
938 ret = ext2_xattr_check_entry(entry, total);
939 if (ret)
940 goto out;
941 data = (void *)EXT2_XATTR_IFIRST(ext2_inode) +
942 entry->e_value_offs;
943 datalen = entry->e_value_size;
944 ret = copy_single_xattr(trans, root, objectid,
945 entry, data, datalen);
946 if (ret)
947 goto out;
948 entry = EXT2_EXT_ATTR_NEXT(entry);
949 }
950 }
951
952 if (ext2_inode->i_file_acl == 0)
953 goto out;
954
955 buffer = malloc(block_size);
956 if (!buffer) {
957 ret = -ENOMEM;
958 goto out;
959 }
960 err = ext2fs_read_ext_attr(ext2_fs, ext2_inode->i_file_acl, buffer);
961 if (err) {
962 fprintf(stderr, "ext2fs_read_ext_attr: %s\n",
963 error_message(err));
964 ret = -1;
965 goto out;
966 }
967 ret = ext2_xattr_check_block(buffer, block_size);
968 if (ret)
969 goto out;
970
971 entry = EXT2_XATTR_BFIRST(buffer);
972 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
973 ret = ext2_xattr_check_entry(entry, block_size);
974 if (ret)
975 goto out;
976 data = buffer + entry->e_value_offs;
977 datalen = entry->e_value_size;
978 ret = copy_single_xattr(trans, root, objectid,
979 entry, data, datalen);
980 if (ret)
981 goto out;
982 entry = EXT2_EXT_ATTR_NEXT(entry);
983 }
984 out:
985 if (buffer != NULL)
986 free(buffer);
987 if ((void *)ext2_inode != inode_buf)
988 free(ext2_inode);
989 return ret;
990 }
991 #define MINORBITS 20
992 #define MKDEV(ma, mi) (((ma) << MINORBITS) | (mi))
993
994 static inline dev_t old_decode_dev(u16 val)
995 {
996 return MKDEV((val >> 8) & 255, val & 255);
997 }
998
999 static inline dev_t new_decode_dev(u32 dev)
1000 {
1001 unsigned major = (dev & 0xfff00) >> 8;
1002 unsigned minor = (dev & 0xff) | ((dev >> 12) & 0xfff00);
1003 return MKDEV(major, minor);
1004 }
1005
1006 static int copy_inode_item(struct btrfs_inode_item *dst,
1007 struct ext2_inode *src, u32 blocksize)
1008 {
1009 btrfs_set_stack_inode_generation(dst, 1);
1010 btrfs_set_stack_inode_size(dst, src->i_size);
1011 btrfs_set_stack_inode_nbytes(dst, 0);
1012 btrfs_set_stack_inode_block_group(dst, 0);
1013 btrfs_set_stack_inode_nlink(dst, src->i_links_count);
1014 btrfs_set_stack_inode_uid(dst, src->i_uid | (src->i_uid_high << 16));
1015 btrfs_set_stack_inode_gid(dst, src->i_gid | (src->i_gid_high << 16));
1016 btrfs_set_stack_inode_mode(dst, src->i_mode);
1017 btrfs_set_stack_inode_rdev(dst, 0);
1018 btrfs_set_stack_inode_flags(dst, 0);
1019 btrfs_set_stack_timespec_sec(&dst->atime, src->i_atime);
1020 btrfs_set_stack_timespec_nsec(&dst->atime, 0);
1021 btrfs_set_stack_timespec_sec(&dst->ctime, src->i_ctime);
1022 btrfs_set_stack_timespec_nsec(&dst->ctime, 0);
1023 btrfs_set_stack_timespec_sec(&dst->mtime, src->i_mtime);
1024 btrfs_set_stack_timespec_nsec(&dst->mtime, 0);
1025 btrfs_set_stack_timespec_sec(&dst->otime, 0);
1026 btrfs_set_stack_timespec_nsec(&dst->otime, 0);
1027
1028 if (S_ISDIR(src->i_mode)) {
1029 btrfs_set_stack_inode_size(dst, 0);
1030 btrfs_set_stack_inode_nlink(dst, 1);
1031 }
1032 if (S_ISREG(src->i_mode)) {
1033 btrfs_set_stack_inode_size(dst, (u64)src->i_size_high << 32 |
1034 (u64)src->i_size);
1035 }
1036 if (!S_ISREG(src->i_mode) && !S_ISDIR(src->i_mode) &&
1037 !S_ISLNK(src->i_mode)) {
1038 if (src->i_block[0]) {
1039 btrfs_set_stack_inode_rdev(dst,
1040 old_decode_dev(src->i_block[0]));
1041 } else {
1042 btrfs_set_stack_inode_rdev(dst,
1043 new_decode_dev(src->i_block[1]));
1044 }
1045 }
1046 return 0;
1047 }
1048
1049 /*
1050 * copy a single inode. do all the required works, such as cloning
1051 * inode item, creating file extents and creating directory entries.
1052 */
1053 static int copy_single_inode(struct btrfs_trans_handle *trans,
1054 struct btrfs_root *root, u64 objectid,
1055 ext2_filsys ext2_fs, ext2_ino_t ext2_ino,
1056 struct ext2_inode *ext2_inode,
1057 int datacsum, int packing, int noxattr)
1058 {
1059 int ret;
1060 struct btrfs_key inode_key;
1061 struct btrfs_inode_item btrfs_inode;
1062
1063 if (ext2_inode->i_links_count == 0)
1064 return 0;
1065
1066 copy_inode_item(&btrfs_inode, ext2_inode, ext2_fs->blocksize);
1067 if (!datacsum && S_ISREG(ext2_inode->i_mode)) {
1068 u32 flags = btrfs_stack_inode_flags(&btrfs_inode) |
1069 BTRFS_INODE_NODATASUM;
1070 btrfs_set_stack_inode_flags(&btrfs_inode, flags);
1071 }
1072
1073 switch (ext2_inode->i_mode & S_IFMT) {
1074 case S_IFREG:
1075 ret = create_file_extents(trans, root, objectid, &btrfs_inode,
1076 ext2_fs, ext2_ino, datacsum, packing);
1077 break;
1078 case S_IFDIR:
1079 ret = create_dir_entries(trans, root, objectid, &btrfs_inode,
1080 ext2_fs, ext2_ino);
1081 break;
1082 case S_IFLNK:
1083 ret = create_symbol_link(trans, root, objectid, &btrfs_inode,
1084 ext2_fs, ext2_ino, ext2_inode);
1085 break;
1086 default:
1087 ret = 0;
1088 break;
1089 }
1090 if (ret)
1091 return ret;
1092
1093 if (!noxattr) {
1094 ret = copy_extended_attrs(trans, root, objectid, &btrfs_inode,
1095 ext2_fs, ext2_ino);
1096 if (ret)
1097 return ret;
1098 }
1099 inode_key.objectid = objectid;
1100 inode_key.offset = 0;
1101 btrfs_set_key_type(&inode_key, BTRFS_INODE_ITEM_KEY);
1102 ret = btrfs_insert_inode(trans, root, objectid, &btrfs_inode);
1103 return ret;
1104 }
1105
1106 static int copy_disk_extent(struct btrfs_root *root, u64 dst_bytenr,
1107 u64 src_bytenr, u32 num_bytes)
1108 {
1109 int ret;
1110 char *buffer;
1111 struct btrfs_fs_devices *fs_devs = root->fs_info->fs_devices;
1112
1113 buffer = malloc(num_bytes);
1114 if (!buffer)
1115 return -ENOMEM;
1116 ret = pread(fs_devs->latest_bdev, buffer, num_bytes, src_bytenr);
1117 if (ret != num_bytes)
1118 goto fail;
1119 ret = pwrite(fs_devs->latest_bdev, buffer, num_bytes, dst_bytenr);
1120 if (ret != num_bytes)
1121 goto fail;
1122 ret = 0;
1123 fail:
1124 free(buffer);
1125 if (ret > 0)
1126 ret = -1;
1127 return ret;
1128 }
1129 /*
1130 * scan ext2's inode bitmap and copy all used inode.
1131 */
1132 static int copy_inodes(struct btrfs_root *root, ext2_filsys ext2_fs,
1133 int datacsum, int packing, int noxattr)
1134 {
1135 int ret;
1136 errcode_t err;
1137 ext2_inode_scan ext2_scan;
1138 struct ext2_inode ext2_inode;
1139 ext2_ino_t ext2_ino;
1140 u64 objectid;
1141 struct btrfs_trans_handle *trans;
1142
1143 trans = btrfs_start_transaction(root, 1);
1144 if (!trans)
1145 return -ENOMEM;
1146 err = ext2fs_open_inode_scan(ext2_fs, 0, &ext2_scan);
1147 if (err) {
1148 fprintf(stderr, "ext2fs_open_inode_scan: %s\n", error_message(err));
1149 return -1;
1150 }
1151 while (!(err = ext2fs_get_next_inode(ext2_scan, &ext2_ino,
1152 &ext2_inode))) {
1153 /* no more inodes */
1154 if (ext2_ino == 0)
1155 break;
1156 /* skip special inode in ext2fs */
1157 if (ext2_ino < EXT2_GOOD_OLD_FIRST_INO &&
1158 ext2_ino != EXT2_ROOT_INO)
1159 continue;
1160 objectid = ext2_ino + INO_OFFSET;
1161 ret = copy_single_inode(trans, root,
1162 objectid, ext2_fs, ext2_ino,
1163 &ext2_inode, datacsum, packing,
1164 noxattr);
1165 if (ret)
1166 return ret;
1167 if (trans->blocks_used >= 4096) {
1168 ret = btrfs_commit_transaction(trans, root);
1169 BUG_ON(ret);
1170 trans = btrfs_start_transaction(root, 1);
1171 BUG_ON(!trans);
1172 }
1173 }
1174 if (err) {
1175 fprintf(stderr, "ext2fs_get_next_inode: %s\n", error_message(err));
1176 return -1;
1177 }
1178 ret = btrfs_commit_transaction(trans, root);
1179 BUG_ON(ret);
1180
1181 return ret;
1182 }
1183
1184 /*
1185 * Construct a range of ext2fs image file.
1186 * scan block allocation bitmap, find all blocks used by the ext2fs
1187 * in this range and create file extents that point to these blocks.
1188 *
1189 * Note: Before calling the function, no file extent points to blocks
1190 * in this range
1191 */
1192 static int create_image_file_range(struct btrfs_trans_handle *trans,
1193 struct btrfs_root *root, u64 objectid,
1194 struct btrfs_inode_item *inode,
1195 u64 start_byte, u64 end_byte,
1196 ext2_filsys ext2_fs)
1197 {
1198 u32 blocksize = ext2_fs->blocksize;
1199 u32 block = start_byte / blocksize;
1200 u32 last_block = (end_byte + blocksize - 1) / blocksize;
1201 int ret = 0;
1202 struct blk_iterate_data data = {
1203 .trans = trans,
1204 .root = root,
1205 .inode = inode,
1206 .objectid = objectid,
1207 .first_block = block,
1208 .disk_block = 0,
1209 .num_blocks = 0,
1210 .boundary = (u64)-1,
1211 .checksum = 0,
1212 .errcode = 0,
1213 };
1214 for (; start_byte < end_byte; block++, start_byte += blocksize) {
1215 if (!ext2fs_fast_test_block_bitmap(ext2_fs->block_map, block))
1216 continue;
1217 ret = block_iterate_proc(NULL, block, block, &data);
1218 if (ret & BLOCK_ABORT) {
1219 ret = data.errcode;
1220 goto fail;
1221 }
1222 }
1223 if (data.num_blocks > 0) {
1224 ret = record_file_blocks(trans, root, objectid, inode,
1225 data.first_block, data.disk_block,
1226 data.num_blocks, 0);
1227 if (ret)
1228 goto fail;
1229 data.first_block += data.num_blocks;
1230 }
1231 if (last_block > data.first_block) {
1232 ret = record_file_blocks(trans, root, objectid, inode,
1233 data.first_block, 0, last_block -
1234 data.first_block, 0);
1235 if (ret)
1236 goto fail;
1237 }
1238 fail:
1239 return ret;
1240 }
1241 /*
1242 * Create the ext2fs image file.
1243 */
1244 static int create_ext2_image(struct btrfs_root *root, ext2_filsys ext2_fs,
1245 const char *name)
1246 {
1247 int ret;
1248 struct btrfs_key key;
1249 struct btrfs_key location;
1250 struct btrfs_path path;
1251 struct btrfs_inode_item btrfs_inode;
1252 struct btrfs_inode_item *inode_item;
1253 struct extent_buffer *leaf;
1254 struct btrfs_fs_info *fs_info = root->fs_info;
1255 struct btrfs_root *extent_root = fs_info->extent_root;
1256 struct btrfs_trans_handle *trans;
1257 struct btrfs_extent_item *ei;
1258 struct btrfs_extent_inline_ref *iref;
1259 struct btrfs_extent_data_ref *dref;
1260 u64 bytenr;
1261 u64 num_bytes;
1262 u64 objectid;
1263 u64 last_byte;
1264 u64 first_free;
1265 u64 total_bytes;
1266 u32 sectorsize = root->sectorsize;
1267
1268 total_bytes = btrfs_super_total_bytes(&fs_info->super_copy);
1269 first_free = BTRFS_SUPER_INFO_OFFSET + sectorsize * 2 - 1;
1270 first_free &= ~((u64)sectorsize - 1);
1271
1272 memset(&btrfs_inode, 0, sizeof(btrfs_inode));
1273 btrfs_set_stack_inode_generation(&btrfs_inode, 1);
1274 btrfs_set_stack_inode_size(&btrfs_inode, total_bytes);
1275 btrfs_set_stack_inode_nlink(&btrfs_inode, 1);
1276 btrfs_set_stack_inode_nbytes(&btrfs_inode, 0);
1277 btrfs_set_stack_inode_mode(&btrfs_inode, S_IFREG | 0400);
1278 btrfs_set_stack_inode_flags(&btrfs_inode, BTRFS_INODE_NODATASUM |
1279 BTRFS_INODE_READONLY);
1280 btrfs_init_path(&path);
1281 trans = btrfs_start_transaction(root, 1);
1282 BUG_ON(!trans);
1283
1284 objectid = btrfs_root_dirid(&root->root_item);
1285 ret = btrfs_find_free_objectid(trans, root, objectid, &objectid);
1286 if (ret)
1287 goto fail;
1288
1289 /*
1290 * copy blocks covered by extent #0 to new positions. extent #0 is
1291 * special, we can't rely on relocate_extents_range to relocate it.
1292 */
1293 for (last_byte = 0; last_byte < first_free; last_byte += sectorsize) {
1294 ret = custom_alloc_extent(root, sectorsize, 0, &key);
1295 if (ret)
1296 goto fail;
1297 ret = copy_disk_extent(root, key.objectid, last_byte,
1298 sectorsize);
1299 if (ret)
1300 goto fail;
1301 ret = record_file_extent(trans, root, objectid,
1302 &btrfs_inode, last_byte,
1303 key.objectid, sectorsize, 0);
1304 if (ret)
1305 goto fail;
1306 }
1307
1308 while(1) {
1309 key.objectid = last_byte;
1310 key.offset = 0;
1311 btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
1312 ret = btrfs_search_slot(trans, fs_info->extent_root,
1313 &key, &path, 0, 0);
1314 if (ret < 0)
1315 goto fail;
1316 next:
1317 leaf = path.nodes[0];
1318 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
1319 ret = btrfs_next_leaf(extent_root, &path);
1320 if (ret < 0)
1321 goto fail;
1322 if (ret > 0)
1323 break;
1324 leaf = path.nodes[0];
1325 }
1326 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1327 if (last_byte > key.objectid ||
1328 key.type != BTRFS_EXTENT_ITEM_KEY) {
1329 path.slots[0]++;
1330 goto next;
1331 }
1332
1333 bytenr = key.objectid;
1334 num_bytes = key.offset;
1335 ei = btrfs_item_ptr(leaf, path.slots[0],
1336 struct btrfs_extent_item);
1337 if (!(btrfs_extent_flags(leaf, ei) & BTRFS_EXTENT_FLAG_DATA)) {
1338 path.slots[0]++;
1339 goto next;
1340 }
1341
1342 BUG_ON(btrfs_item_size_nr(leaf, path.slots[0]) != sizeof(*ei) +
1343 btrfs_extent_inline_ref_size(BTRFS_EXTENT_DATA_REF_KEY));
1344
1345 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
1346 key.type = btrfs_extent_inline_ref_type(leaf, iref);
1347 BUG_ON(key.type != BTRFS_EXTENT_DATA_REF_KEY);
1348 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
1349 if (btrfs_extent_data_ref_root(leaf, dref) !=
1350 BTRFS_FS_TREE_OBJECTID) {
1351 path.slots[0]++;
1352 goto next;
1353 }
1354
1355 if (bytenr > last_byte) {
1356 ret = create_image_file_range(trans, root, objectid,
1357 &btrfs_inode, last_byte,
1358 bytenr, ext2_fs);
1359 if (ret)
1360 goto fail;
1361 }
1362 ret = record_file_extent(trans, root, objectid, &btrfs_inode,
1363 bytenr, bytenr, num_bytes, 0);
1364 if (ret)
1365 goto fail;
1366 last_byte = bytenr + num_bytes;
1367 btrfs_release_path(extent_root, &path);
1368
1369 if (trans->blocks_used >= 4096) {
1370 ret = btrfs_commit_transaction(trans, root);
1371 BUG_ON(ret);
1372 trans = btrfs_start_transaction(root, 1);
1373 BUG_ON(!trans);
1374 }
1375 }
1376 btrfs_release_path(root, &path);
1377 if (total_bytes > last_byte) {
1378 ret = create_image_file_range(trans, root, objectid,
1379 &btrfs_inode, last_byte,
1380 total_bytes, ext2_fs);
1381 if (ret)
1382 goto fail;
1383 }
1384
1385 ret = btrfs_insert_inode(trans, root, objectid, &btrfs_inode);
1386 if (ret)
1387 goto fail;
1388
1389 location.objectid = objectid;
1390 location.offset = 0;
1391 btrfs_set_key_type(&location, BTRFS_INODE_ITEM_KEY);
1392 ret = btrfs_insert_dir_item(trans, root, name, strlen(name),
1393 btrfs_root_dirid(&root->root_item),
1394 &location, EXT2_FT_REG_FILE, objectid);
1395 if (ret)
1396 goto fail;
1397 ret = btrfs_insert_inode_ref(trans, root, name, strlen(name),
1398 objectid,
1399 btrfs_root_dirid(&root->root_item),
1400 objectid);
1401 if (ret)
1402 goto fail;
1403 location.objectid = btrfs_root_dirid(&root->root_item);
1404 location.offset = 0;
1405 btrfs_set_key_type(&location, BTRFS_INODE_ITEM_KEY);
1406 ret = btrfs_lookup_inode(trans, root, &path, &location, 1);
1407 if (ret)
1408 goto fail;
1409 leaf = path.nodes[0];
1410 inode_item = btrfs_item_ptr(leaf, path.slots[0],
1411 struct btrfs_inode_item);
1412 btrfs_set_inode_size(leaf, inode_item, strlen(name) * 2 +
1413 btrfs_inode_size(leaf, inode_item));
1414 btrfs_mark_buffer_dirty(leaf);
1415 btrfs_release_path(root, &path);
1416 ret = btrfs_commit_transaction(trans, root);
1417 BUG_ON(ret);
1418 fail:
1419 btrfs_release_path(root, &path);
1420 return ret;
1421 }
1422
1423 struct btrfs_root *link_subvol(struct btrfs_root *root, const char *base,
1424 u64 root_objectid)
1425 {
1426 struct btrfs_trans_handle *trans;
1427 struct btrfs_fs_info *fs_info = root->fs_info;
1428 struct btrfs_root *tree_root = fs_info->tree_root;
1429 struct btrfs_root *new_root = NULL;
1430 struct btrfs_path *path;
1431 struct btrfs_inode_item *inode_item;
1432 struct extent_buffer *leaf;
1433 struct btrfs_key key;
1434 u64 dirid = btrfs_root_dirid(&root->root_item);
1435 u64 index = 2;
1436 char buf[64];
1437 int i;
1438 int ret;
1439
1440 path = btrfs_alloc_path();
1441 BUG_ON(!path);
1442
1443 key.objectid = dirid;
1444 key.type = BTRFS_DIR_INDEX_KEY;
1445 key.offset = (u64)-1;
1446
1447 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1448 BUG_ON(ret <= 0);
1449
1450 if (path->slots[0] > 0) {
1451 path->slots[0]--;
1452 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
1453 if (key.objectid == dirid && key.type == BTRFS_DIR_INDEX_KEY)
1454 index = key.offset + 1;
1455 }
1456 btrfs_release_path(root, path);
1457
1458 trans = btrfs_start_transaction(root, 1);
1459 BUG_ON(!trans);
1460
1461 key.objectid = dirid;
1462 key.offset = 0;
1463 key.type = BTRFS_INODE_ITEM_KEY;
1464
1465 ret = btrfs_lookup_inode(trans, root, path, &key, 1);
1466 BUG_ON(ret);
1467 leaf = path->nodes[0];
1468 inode_item = btrfs_item_ptr(leaf, path->slots[0],
1469 struct btrfs_inode_item);
1470
1471 key.objectid = root_objectid;
1472 key.offset = (u64)-1;
1473 key.type = BTRFS_ROOT_ITEM_KEY;
1474
1475 strcpy(buf, base);
1476 for (i = 0; i < 1024; i++) {
1477 ret = btrfs_insert_dir_item(trans, root, buf, strlen(buf),
1478 dirid, &key, BTRFS_FT_DIR, index);
1479 if (ret != -EEXIST)
1480 break;
1481 sprintf(buf, "%s%d", base, i);
1482 }
1483 if (ret)
1484 goto fail;
1485
1486 btrfs_set_inode_size(leaf, inode_item, strlen(buf) * 2 +
1487 btrfs_inode_size(leaf, inode_item));
1488 btrfs_mark_buffer_dirty(leaf);
1489 btrfs_release_path(root, path);
1490
1491 /* add the backref first */
1492 ret = btrfs_add_root_ref(trans, tree_root, root_objectid,
1493 BTRFS_ROOT_BACKREF_KEY,
1494 root->root_key.objectid,
1495 dirid, index, buf, strlen(buf));
1496 BUG_ON(ret);
1497
1498 /* now add the forward ref */
1499 ret = btrfs_add_root_ref(trans, tree_root, root->root_key.objectid,
1500 BTRFS_ROOT_REF_KEY, root_objectid,
1501 dirid, index, buf, strlen(buf));
1502
1503 ret = btrfs_commit_transaction(trans, root);
1504 BUG_ON(ret);
1505
1506 new_root = btrfs_read_fs_root(fs_info, &key);
1507 if (IS_ERR(new_root))
1508 new_root = NULL;
1509 fail:
1510 btrfs_free_path(path);
1511 return new_root;
1512 }
1513
1514 /*
1515 * Fixup block accounting. The initial block accounting created by
1516 * make_block_groups isn't accuracy in this case.
1517 */
1518 static int fixup_block_accounting(struct btrfs_trans_handle *trans,
1519 struct btrfs_root *root)
1520 {
1521 int ret;
1522 int slot;
1523 u64 start = 0;
1524 u64 bytes_used = 0;
1525 struct btrfs_path path;
1526 struct btrfs_key key;
1527 struct extent_buffer *leaf;
1528 struct btrfs_block_group_cache *cache;
1529 struct btrfs_fs_info *fs_info = root->fs_info;
1530
1531 while(1) {
1532 cache = btrfs_lookup_block_group(fs_info, start);
1533 if (!cache)
1534 break;
1535 start = cache->key.objectid + cache->key.offset;
1536 btrfs_set_block_group_used(&cache->item, 0);
1537 cache->space_info->bytes_used = 0;
1538 }
1539
1540 btrfs_init_path(&path);
1541 key.offset = 0;
1542 key.objectid = 0;
1543 btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
1544 ret = btrfs_search_slot(trans, root->fs_info->extent_root,
1545 &key, &path, 0, 0);
1546 if (ret < 0)
1547 return ret;
1548 while(1) {
1549 leaf = path.nodes[0];
1550 slot = path.slots[0];
1551 if (slot >= btrfs_header_nritems(leaf)) {
1552 ret = btrfs_next_leaf(root, &path);
1553 if (ret < 0)
1554 return ret;
1555 if (ret > 0)
1556 break;
1557 leaf = path.nodes[0];
1558 slot = path.slots[0];
1559 }
1560 btrfs_item_key_to_cpu(leaf, &key, slot);
1561 if (key.type == BTRFS_EXTENT_ITEM_KEY) {
1562 bytes_used += key.offset;
1563 ret = btrfs_update_block_group(trans, root,
1564 key.objectid, key.offset, 1, 0);
1565 BUG_ON(ret);
1566 }
1567 path.slots[0]++;
1568 }
1569 btrfs_set_super_bytes_used(&root->fs_info->super_copy, bytes_used);
1570 btrfs_release_path(root, &path);
1571 return 0;
1572 }
1573
1574 static int create_chunk_mapping(struct btrfs_trans_handle *trans,
1575 struct btrfs_root *root)
1576 {
1577 struct btrfs_fs_info *info = root->fs_info;
1578 struct btrfs_root *chunk_root = info->chunk_root;
1579 struct btrfs_root *extent_root = info->extent_root;
1580 struct btrfs_device *device;
1581 struct btrfs_block_group_cache *cache;
1582 struct btrfs_dev_extent *extent;
1583 struct extent_buffer *leaf;
1584 struct btrfs_chunk chunk;
1585 struct btrfs_key key;
1586 struct btrfs_path path;
1587 u64 cur_start;
1588 u64 total_bytes;
1589 u64 chunk_objectid;
1590 int ret;
1591
1592 btrfs_init_path(&path);
1593
1594 total_bytes = btrfs_super_total_bytes(&root->fs_info->super_copy);
1595 chunk_objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
1596
1597 BUG_ON(list_empty(&info->fs_devices->devices));
1598 device = list_entry(info->fs_devices->devices.next,
1599 struct btrfs_device, dev_list);
1600 BUG_ON(device->devid != info->fs_devices->latest_devid);
1601
1602 /* delete device extent created by make_btrfs */
1603 key.objectid = device->devid;
1604 key.offset = 0;
1605 key.type = BTRFS_DEV_EXTENT_KEY;
1606 ret = btrfs_search_slot(trans, device->dev_root, &key, &path, -1, 1);
1607 if (ret < 0)
1608 goto err;
1609
1610 BUG_ON(ret > 0);
1611 ret = btrfs_del_item(trans, device->dev_root, &path);
1612 if (ret)
1613 goto err;
1614 btrfs_release_path(device->dev_root, &path);
1615
1616 /* delete chunk item created by make_btrfs */
1617 key.objectid = chunk_objectid;
1618 key.offset = 0;
1619 key.type = BTRFS_CHUNK_ITEM_KEY;
1620 ret = btrfs_search_slot(trans, chunk_root, &key, &path, -1, 1);
1621 if (ret < 0)
1622 goto err;
1623
1624 BUG_ON(ret > 0);
1625 ret = btrfs_del_item(trans, chunk_root, &path);
1626 if (ret)
1627 goto err;
1628 btrfs_release_path(chunk_root, &path);
1629
1630 /* for each block group, create device extent and chunk item */
1631 cur_start = 0;
1632 while (cur_start < total_bytes) {
1633 cache = btrfs_lookup_block_group(root->fs_info, cur_start);
1634 BUG_ON(!cache);
1635
1636 /* insert device extent */
1637 key.objectid = device->devid;
1638 key.offset = cache->key.objectid;
1639 key.type = BTRFS_DEV_EXTENT_KEY;
1640 ret = btrfs_insert_empty_item(trans, device->dev_root, &path,
1641 &key, sizeof(*extent));
1642 if (ret)
1643 goto err;
1644
1645 leaf = path.nodes[0];
1646 extent = btrfs_item_ptr(leaf, path.slots[0],
1647 struct btrfs_dev_extent);
1648
1649 btrfs_set_dev_extent_chunk_tree(leaf, extent,
1650 chunk_root->root_key.objectid);
1651 btrfs_set_dev_extent_chunk_objectid(leaf, extent,
1652 chunk_objectid);
1653 btrfs_set_dev_extent_chunk_offset(leaf, extent,
1654 cache->key.objectid);
1655 btrfs_set_dev_extent_length(leaf, extent, cache->key.offset);
1656 write_extent_buffer(leaf, root->fs_info->chunk_tree_uuid,
1657 (unsigned long)btrfs_dev_extent_chunk_tree_uuid(extent),
1658 BTRFS_UUID_SIZE);
1659 btrfs_mark_buffer_dirty(leaf);
1660 btrfs_release_path(device->dev_root, &path);
1661
1662 /* insert chunk item */
1663 btrfs_set_stack_chunk_length(&chunk, cache->key.offset);
1664 btrfs_set_stack_chunk_owner(&chunk,
1665 extent_root->root_key.objectid);
1666 btrfs_set_stack_chunk_stripe_len(&chunk, STRIPE_LEN);
1667 btrfs_set_stack_chunk_type(&chunk, cache->flags);
1668 btrfs_set_stack_chunk_io_align(&chunk, device->io_align);
1669 btrfs_set_stack_chunk_io_width(&chunk, device->io_width);
1670 btrfs_set_stack_chunk_sector_size(&chunk, device->sector_size);
1671 btrfs_set_stack_chunk_num_stripes(&chunk, 1);
1672 btrfs_set_stack_chunk_sub_stripes(&chunk, 0);
1673 btrfs_set_stack_stripe_devid(&chunk.stripe, device->devid);
1674 btrfs_set_stack_stripe_offset(&chunk.stripe,
1675 cache->key.objectid);
1676 memcpy(&chunk.stripe.dev_uuid, device->uuid, BTRFS_UUID_SIZE);
1677
1678 key.objectid = chunk_objectid;
1679 key.offset = cache->key.objectid;
1680 key.type = BTRFS_CHUNK_ITEM_KEY;
1681
1682 ret = btrfs_insert_item(trans, chunk_root, &key, &chunk,
1683 btrfs_chunk_item_size(1));
1684 if (ret)
1685 goto err;
1686
1687 cur_start = cache->key.objectid + cache->key.offset;
1688 }
1689
1690 device->bytes_used = total_bytes;
1691 ret = btrfs_update_device(trans, device);
1692 err:
1693 btrfs_release_path(device->dev_root, &path);
1694 return ret;
1695 }
1696
1697 static int create_subvol(struct btrfs_trans_handle *trans,
1698 struct btrfs_root *root, u64 root_objectid)
1699 {
1700 struct extent_buffer *tmp;
1701 struct btrfs_root *new_root;
1702 struct btrfs_key key;
1703 struct btrfs_root_item root_item;
1704 int ret;
1705
1706 ret = btrfs_copy_root(trans, root, root->node, &tmp,
1707 root_objectid);
1708 BUG_ON(ret);
1709
1710 memcpy(&root_item, &root->root_item, sizeof(root_item));
1711 btrfs_set_root_bytenr(&root_item, tmp->start);
1712 btrfs_set_root_level(&root_item, btrfs_header_level(tmp));
1713 btrfs_set_root_generation(&root_item, trans->transid);
1714 free_extent_buffer(tmp);
1715
1716 key.objectid = root_objectid;
1717 key.type = BTRFS_ROOT_ITEM_KEY;
1718 key.offset = trans->transid;
1719 ret = btrfs_insert_root(trans, root->fs_info->tree_root,
1720 &key, &root_item);
1721
1722 key.offset = (u64)-1;
1723 new_root = btrfs_read_fs_root(root->fs_info, &key);
1724 BUG_ON(!new_root || IS_ERR(new_root));
1725
1726 ret = btrfs_make_root_dir(trans, new_root, BTRFS_FIRST_FREE_OBJECTID);
1727 BUG_ON(ret);
1728
1729 return 0;
1730 }
1731
1732 static int init_btrfs(struct btrfs_root *root)
1733 {
1734 int ret;
1735 struct btrfs_key location;
1736 struct btrfs_trans_handle *trans;
1737 struct btrfs_fs_info *fs_info = root->fs_info;
1738 struct extent_buffer *tmp;
1739
1740 trans = btrfs_start_transaction(root, 1);
1741 BUG_ON(!trans);
1742 ret = btrfs_make_block_groups(trans, root);
1743 if (ret)
1744 goto err;
1745 ret = fixup_block_accounting(trans, root);
1746 if (ret)
1747 goto err;
1748 ret = create_chunk_mapping(trans, root);
1749 if (ret)
1750 goto err;
1751 ret = btrfs_make_root_dir(trans, fs_info->tree_root,
1752 BTRFS_ROOT_TREE_DIR_OBJECTID);
1753 if (ret)
1754 goto err;
1755 memcpy(&location, &root->root_key, sizeof(location));
1756 location.offset = (u64)-1;
1757 ret = btrfs_insert_dir_item(trans, fs_info->tree_root, "default", 7,
1758 btrfs_super_root_dir(&fs_info->super_copy),
1759 &location, BTRFS_FT_DIR, 0);
1760 if (ret)
1761 goto err;
1762 ret = btrfs_insert_inode_ref(trans, fs_info->tree_root, "default", 7,
1763 location.objectid,
1764 btrfs_super_root_dir(&fs_info->super_copy), 0);
1765 if (ret)
1766 goto err;
1767 btrfs_set_root_dirid(&fs_info->fs_root->root_item,
1768 BTRFS_FIRST_FREE_OBJECTID);
1769
1770 /* subvol for ext2 image file */
1771 ret = create_subvol(trans, root, EXT2_IMAGE_SUBVOL_OBJECTID);
1772 BUG_ON(ret);
1773 /* subvol for data relocation */
1774 ret = create_subvol(trans, root, BTRFS_DATA_RELOC_TREE_OBJECTID);
1775 BUG_ON(ret);
1776
1777 ret = __btrfs_cow_block(trans, fs_info->csum_root,
1778 fs_info->csum_root->node, NULL, 0, &tmp, 0, 0);
1779 BUG_ON(ret);
1780 free_extent_buffer(tmp);
1781
1782 ret = btrfs_commit_transaction(trans, root);
1783 BUG_ON(ret);
1784 err:
1785 return ret;
1786 }
1787
1788 /*
1789 * Migrate super block to it's default position and zero 0 ~ 16k
1790 */
1791 static int migrate_super_block(int fd, u64 old_bytenr, u32 sectorsize)
1792 {
1793 int ret;
1794 struct extent_buffer *buf;
1795 struct btrfs_super_block *super;
1796 u32 len;
1797 u32 bytenr;
1798
1799 BUG_ON(sectorsize < sizeof(*super));
1800 buf = malloc(sizeof(*buf) + sectorsize);
1801 if (!buf)
1802 return -ENOMEM;
1803
1804 buf->len = sectorsize;
1805 ret = pread(fd, buf->data, sectorsize, old_bytenr);
1806 if (ret != sectorsize)
1807 goto fail;
1808
1809 super = (struct btrfs_super_block *)buf->data;
1810 BUG_ON(btrfs_super_bytenr(super) != old_bytenr);
1811 btrfs_set_super_bytenr(super, BTRFS_SUPER_INFO_OFFSET);
1812
1813 csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
1814 ret = pwrite(fd, buf->data, sectorsize, BTRFS_SUPER_INFO_OFFSET);
1815 if (ret != sectorsize)
1816 goto fail;
1817
1818 ret = fsync(fd);
1819 if (ret)
1820 goto fail;
1821
1822 memset(buf->data, 0, sectorsize);
1823 for (bytenr = 0; bytenr < BTRFS_SUPER_INFO_OFFSET; ) {
1824 len = BTRFS_SUPER_INFO_OFFSET - bytenr;
1825 if (len > sectorsize)
1826 len = sectorsize;
1827 ret = pwrite(fd, buf->data, len, bytenr);
1828 if (ret != len) {
1829 fprintf(stderr, "unable to zero fill device\n");
1830 break;
1831 }
1832 bytenr += len;
1833 }
1834 ret = 0;
1835 fsync(fd);
1836 fail:
1837 free(buf);
1838 if (ret > 0)
1839 ret = -1;
1840 return ret;
1841 }
1842
1843 static int prepare_system_chunk_sb(struct btrfs_super_block *super)
1844 {
1845 struct btrfs_chunk *chunk;
1846 struct btrfs_disk_key *key;
1847 u32 sectorsize = btrfs_super_sectorsize(super);
1848
1849 key = (struct btrfs_disk_key *)(super->sys_chunk_array);
1850 chunk = (struct btrfs_chunk *)(super->sys_chunk_array +
1851 sizeof(struct btrfs_disk_key));
1852
1853 btrfs_set_disk_key_objectid(key, BTRFS_FIRST_CHUNK_TREE_OBJECTID);
1854 btrfs_set_disk_key_type(key, BTRFS_CHUNK_ITEM_KEY);
1855 btrfs_set_disk_key_offset(key, 0);
1856
1857 btrfs_set_stack_chunk_length(chunk, btrfs_super_total_bytes(super));
1858 btrfs_set_stack_chunk_owner(chunk, BTRFS_EXTENT_TREE_OBJECTID);
1859 btrfs_set_stack_chunk_stripe_len(chunk, 64 * 1024);
1860 btrfs_set_stack_chunk_type(chunk, BTRFS_BLOCK_GROUP_SYSTEM);
1861 btrfs_set_stack_chunk_io_align(chunk, sectorsize);
1862 btrfs_set_stack_chunk_io_width(chunk, sectorsize);
1863 btrfs_set_stack_chunk_sector_size(chunk, sectorsize);
1864 btrfs_set_stack_chunk_num_stripes(chunk, 1);
1865 btrfs_set_stack_chunk_sub_stripes(chunk, 0);
1866 chunk->stripe.devid = super->dev_item.devid;
1867 chunk->stripe.offset = cpu_to_le64(0);
1868 memcpy(chunk->stripe.dev_uuid, super->dev_item.uuid, BTRFS_UUID_SIZE);
1869 btrfs_set_super_sys_array_size(super, sizeof(*key) + sizeof(*chunk));
1870 return 0;
1871 }
1872
1873 static int prepare_system_chunk(int fd, u64 sb_bytenr, u32 sectorsize)
1874 {
1875 int ret;
1876 struct extent_buffer *buf;
1877 struct btrfs_super_block *super;
1878
1879 BUG_ON(sectorsize < sizeof(*super));
1880 buf = malloc(sizeof(*buf) + sectorsize);
1881 if (!buf)
1882 return -ENOMEM;
1883
1884 buf->len = sectorsize;
1885 ret = pread(fd, buf->data, sectorsize, sb_bytenr);
1886 if (ret != sectorsize)
1887 goto fail;
1888
1889 super = (struct btrfs_super_block *)buf->data;
1890 BUG_ON(btrfs_super_bytenr(super) != sb_bytenr);
1891 BUG_ON(btrfs_super_num_devices(super) != 1);
1892
1893 ret = prepare_system_chunk_sb(super);
1894 if (ret)
1895 goto fail;
1896
1897 csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
1898 ret = pwrite(fd, buf->data, sectorsize, sb_bytenr);
1899 if (ret != sectorsize)
1900 goto fail;
1901
1902 ret = 0;
1903 fail:
1904 free(buf);
1905 if (ret > 0)
1906 ret = -1;
1907 return ret;
1908 }
1909
1910 static int relocate_one_reference(struct btrfs_trans_handle *trans,
1911 struct btrfs_root *root,
1912 u64 extent_start, u64 extent_size,
1913 struct btrfs_key *extent_key,
1914 struct extent_io_tree *reloc_tree)
1915 {
1916 struct extent_buffer *leaf;
1917 struct btrfs_file_extent_item *fi;
1918 struct btrfs_key key;
1919 struct btrfs_path path;
1920 struct btrfs_inode_item inode;
1921 struct blk_iterate_data data;
1922 u64 bytenr;
1923 u64 num_bytes;
1924 u64 cur_offset;
1925 u64 new_pos;
1926 u64 nbytes;
1927 u64 sector_end;
1928 u32 sectorsize = root->sectorsize;
1929 unsigned long ptr;
1930 int datacsum;
1931 int fd;
1932 int ret;
1933
1934 btrfs_init_path(&path);
1935 ret = btrfs_search_slot(trans, root, extent_key, &path, -1, 1);
1936 if (ret)
1937 goto fail;
1938
1939 leaf = path.nodes[0];
1940 fi = btrfs_item_ptr(leaf, path.slots[0],
1941 struct btrfs_file_extent_item);
1942 BUG_ON(btrfs_file_extent_offset(leaf, fi) > 0);
1943 if (extent_start != btrfs_file_extent_disk_bytenr(leaf, fi) ||
1944 extent_size != btrfs_file_extent_disk_num_bytes(leaf, fi)) {
1945 ret = 1;
1946 goto fail;
1947 }
1948
1949 bytenr = extent_start + btrfs_file_extent_offset(leaf, fi);
1950 num_bytes = btrfs_file_extent_num_bytes(leaf, fi);
1951
1952 ret = btrfs_del_item(trans, root, &path);
1953 if (ret)
1954 goto fail;
1955
1956 ret = btrfs_free_extent(trans, root, extent_start, extent_size, 0,
1957 root->root_key.objectid,
1958 extent_key->objectid, extent_key->offset);
1959 if (ret)
1960 goto fail;
1961
1962 btrfs_release_path(root, &path);
1963
1964 key.objectid = extent_key->objectid;
1965 key.offset = 0;
1966 key.type = BTRFS_INODE_ITEM_KEY;
1967 ret = btrfs_lookup_inode(trans, root, &path, &key, 0);
1968 if (ret)
1969 goto fail;
1970
1971 leaf = path.nodes[0];
1972 ptr = btrfs_item_ptr_offset(leaf, path.slots[0]);
1973 read_extent_buffer(leaf, &inode, ptr, sizeof(inode));
1974 btrfs_release_path(root, &path);
1975
1976 BUG_ON(num_bytes & (sectorsize - 1));
1977 nbytes = btrfs_stack_inode_nbytes(&inode) - num_bytes;
1978 btrfs_set_stack_inode_nbytes(&inode, nbytes);
1979 datacsum = !(btrfs_stack_inode_flags(&inode) & BTRFS_INODE_NODATASUM);
1980
1981 data = (struct blk_iterate_data) {
1982 .trans = trans,
1983 .root = root,
1984 .inode = &inode,
1985 .objectid = extent_key->objectid,
1986 .first_block = extent_key->offset / sectorsize,
1987 .disk_block = 0,
1988 .num_blocks = 0,
1989 .boundary = (u64)-1,
1990 .checksum = datacsum,
1991 .errcode = 0,
1992 };
1993
1994 cur_offset = extent_key->offset;
1995 while (num_bytes > 0) {
1996 sector_end = bytenr + sectorsize - 1;
1997 if (test_range_bit(reloc_tree, bytenr, sector_end,
1998 EXTENT_LOCKED, 1)) {
1999 ret = get_state_private(reloc_tree, bytenr, &new_pos);
2000 BUG_ON(ret);
2001 } else {
2002 ret = custom_alloc_extent(root, sectorsize, 0, &key);
2003 if (ret)
2004 goto fail;
2005 new_pos = key.objectid;
2006
2007 if (cur_offset == extent_key->offset) {
2008 fd = root->fs_info->fs_devices->latest_bdev;
2009 readahead(fd, bytenr, num_bytes);
2010 }
2011 ret = copy_disk_extent(root, new_pos, bytenr,
2012 sectorsize);
2013 if (ret)
2014 goto fail;
2015 ret = set_extent_bits(reloc_tree, bytenr, sector_end,
2016 EXTENT_LOCKED, GFP_NOFS);
2017 BUG_ON(ret);
2018 ret = set_state_private(reloc_tree, bytenr, new_pos);
2019 BUG_ON(ret);
2020 }
2021
2022 ret = block_iterate_proc(NULL, new_pos / sectorsize,
2023 cur_offset / sectorsize, &data);
2024 if (ret & BLOCK_ABORT) {
2025 ret = data.errcode;
2026 goto fail;
2027 }
2028
2029 cur_offset += sectorsize;
2030 bytenr += sectorsize;
2031 num_bytes -= sectorsize;
2032 }
2033
2034 if (data.num_blocks > 0) {
2035 ret = record_file_blocks(trans, root,
2036 extent_key->objectid, &inode,
2037 data.first_block, data.disk_block,
2038 data.num_blocks, datacsum);
2039 if (ret)
2040 goto fail;
2041 }
2042
2043 key.objectid = extent_key->objectid;
2044 key.offset = 0;
2045 key.type = BTRFS_INODE_ITEM_KEY;
2046 ret = btrfs_lookup_inode(trans, root, &path, &key, 1);
2047 if (ret)
2048 goto fail;
2049
2050 leaf = path.nodes[0];
2051 ptr = btrfs_item_ptr_offset(leaf, path.slots[0]);
2052 write_extent_buffer(leaf, &inode, ptr, sizeof(inode));
2053 btrfs_mark_buffer_dirty(leaf);
2054 btrfs_release_path(root, &path);
2055
2056 fail:
2057 btrfs_release_path(root, &path);
2058 return ret;
2059 }
2060
2061 static int relocate_extents_range(struct btrfs_root *fs_root,
2062 struct btrfs_root *ext2_root,
2063 u64 start_byte, u64 end_byte)
2064 {
2065 struct btrfs_fs_info *info = fs_root->fs_info;
2066 struct btrfs_root *extent_root = info->extent_root;
2067 struct btrfs_root *cur_root = NULL;
2068 struct btrfs_trans_handle *trans;
2069 struct btrfs_extent_data_ref *dref;
2070 struct btrfs_extent_inline_ref *iref;
2071 struct btrfs_extent_item *ei;
2072 struct extent_buffer *leaf;
2073 struct btrfs_key key;
2074 struct btrfs_key extent_key;
2075 struct btrfs_path path;
2076 struct extent_io_tree reloc_tree;
2077 unsigned long ptr;
2078 unsigned long end;
2079 u64 cur_byte;
2080 u64 num_bytes;
2081 u64 ref_root;
2082 u64 num_extents;
2083 int pass = 0;
2084 int ret;
2085
2086 btrfs_init_path(&path);
2087 extent_io_tree_init(&reloc_tree);
2088
2089 key.objectid = start_byte;
2090 key.offset = 0;
2091 key.type = BTRFS_EXTENT_ITEM_KEY;
2092 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
2093 if (ret < 0)
2094 goto fail;
2095 if (ret > 0) {
2096 ret = btrfs_previous_item(extent_root, &path, 0,
2097 BTRFS_EXTENT_ITEM_KEY);
2098 if (ret < 0)
2099 goto fail;
2100 if (ret == 0) {
2101 leaf = path.nodes[0];
2102 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
2103 if (key.objectid + key.offset > start_byte)
2104 start_byte = key.objectid;
2105 }
2106 }
2107 btrfs_release_path(extent_root, &path);
2108 again:
2109 cur_root = (pass % 2 == 0) ? ext2_root : fs_root;
2110 num_extents = 0;
2111
2112 trans = btrfs_start_transaction(cur_root, 1);
2113 BUG_ON(!trans);
2114
2115 cur_byte = start_byte;
2116 while (1) {
2117 key.objectid = cur_byte;
2118 key.offset = 0;
2119 key.type = BTRFS_EXTENT_ITEM_KEY;
2120 ret = btrfs_search_slot(trans, extent_root,
2121 &key, &path, 0, 0);
2122 if (ret < 0)
2123 goto fail;
2124 next:
2125 leaf = path.nodes[0];
2126 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
2127 ret = btrfs_next_leaf(extent_root, &path);
2128 if (ret < 0)
2129 goto fail;
2130 if (ret > 0)
2131 break;
2132 leaf = path.nodes[0];
2133 }
2134
2135 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
2136 if (key.objectid < cur_byte ||
2137 key.type != BTRFS_EXTENT_ITEM_KEY) {
2138 path.slots[0]++;
2139 goto next;
2140 }
2141 if (key.objectid >= end_byte)
2142 break;
2143
2144 num_extents++;
2145
2146 cur_byte = key.objectid;
2147 num_bytes = key.offset;
2148 ei = btrfs_item_ptr(leaf, path.slots[0],
2149 struct btrfs_extent_item);
2150 BUG_ON(!(btrfs_extent_flags(leaf, ei) &
2151 BTRFS_EXTENT_FLAG_DATA));
2152
2153 ptr = btrfs_item_ptr_offset(leaf, path.slots[0]);
2154 end = ptr + btrfs_item_size_nr(leaf, path.slots[0]);
2155
2156 ptr += sizeof(struct btrfs_extent_item);
2157
2158 while (ptr < end) {
2159 iref = (struct btrfs_extent_inline_ref *)ptr;
2160 key.type = btrfs_extent_inline_ref_type(leaf, iref);
2161 BUG_ON(key.type != BTRFS_EXTENT_DATA_REF_KEY);
2162 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
2163 ref_root = btrfs_extent_data_ref_root(leaf, dref);
2164 extent_key.objectid =
2165 btrfs_extent_data_ref_objectid(leaf, dref);
2166 extent_key.offset =
2167 btrfs_extent_data_ref_offset(leaf, dref);
2168 extent_key.type = BTRFS_EXTENT_DATA_KEY;
2169 BUG_ON(btrfs_extent_data_ref_count(leaf, dref) != 1);
2170
2171 if (ref_root == cur_root->root_key.objectid)
2172 break;
2173
2174 ptr += btrfs_extent_inline_ref_size(key.type);
2175 }
2176
2177 if (ptr >= end) {
2178 path.slots[0]++;
2179 goto next;
2180 }
2181
2182 ret = relocate_one_reference(trans, cur_root, cur_byte,
2183 num_bytes, &extent_key,
2184 &reloc_tree);
2185 if (ret < 0)
2186 goto fail;
2187
2188 cur_byte += num_bytes;
2189 btrfs_release_path(extent_root, &path);
2190
2191 if (trans->blocks_used >= 4096) {
2192 ret = btrfs_commit_transaction(trans, cur_root);
2193 BUG_ON(ret);
2194 trans = btrfs_start_transaction(cur_root, 1);
2195 BUG_ON(!trans);
2196 }
2197 }
2198 btrfs_release_path(cur_root, &path);
2199
2200 ret = btrfs_commit_transaction(trans, cur_root);
2201 BUG_ON(ret);
2202
2203 if (num_extents > 0 && pass++ < 16)
2204 goto again;
2205
2206 ret = (num_extents > 0) ? -1 : 0;
2207 fail:
2208 btrfs_release_path(cur_root, &path);
2209 extent_io_tree_cleanup(&reloc_tree);
2210 return ret;
2211 }
2212
2213 /*
2214 * relocate data in system chunk
2215 */
2216 static int cleanup_sys_chunk(struct btrfs_root *fs_root,
2217 struct btrfs_root *ext2_root)
2218 {
2219 struct btrfs_block_group_cache *cache;
2220 int i, ret = 0;
2221 u64 offset = 0;
2222 u64 end_byte;
2223
2224 while(1) {
2225 cache = btrfs_lookup_block_group(fs_root->fs_info, offset);
2226 if (!cache)
2227 break;
2228
2229 end_byte = cache->key.objectid + cache->key.offset;
2230 if (cache->flags & BTRFS_BLOCK_GROUP_SYSTEM) {
2231 ret = relocate_extents_range(fs_root, ext2_root,
2232 cache->key.objectid,
2233 end_byte);
2234 if (ret)
2235 goto fail;
2236 }
2237 offset = end_byte;
2238 }
2239 for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
2240 offset = btrfs_sb_offset(i);
2241 offset &= ~((u64)STRIPE_LEN - 1);
2242
2243 ret = relocate_extents_range(fs_root, ext2_root,
2244 offset, offset + STRIPE_LEN);
2245 if (ret)
2246 goto fail;
2247 }
2248 ret = 0;
2249 fail:
2250 return ret;
2251 }
2252
2253 static int fixup_chunk_mapping(struct btrfs_root *root)
2254 {
2255 struct btrfs_trans_handle *trans;
2256 struct btrfs_fs_info *info = root->fs_info;
2257 struct btrfs_root *chunk_root = info->chunk_root;
2258 struct extent_buffer *leaf;
2259 struct btrfs_key key;
2260 struct btrfs_path path;
2261 struct btrfs_chunk chunk;
2262 unsigned long ptr;
2263 u32 size;
2264 u64 type;
2265 int ret;
2266
2267 btrfs_init_path(&path);
2268
2269 trans = btrfs_start_transaction(root, 1);
2270 BUG_ON(!trans);
2271
2272 /*
2273 * recow the whole chunk tree. this will move all chunk tree blocks
2274 * into system block group.
2275 */
2276 memset(&key, 0, sizeof(key));
2277 while (1) {
2278 ret = btrfs_search_slot(trans, chunk_root, &key, &path, 0, 1);
2279 if (ret < 0)
2280 goto err;
2281
2282 ret = btrfs_next_leaf(chunk_root, &path);
2283 if (ret < 0)
2284 goto err;
2285 if (ret > 0)
2286 break;
2287
2288 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
2289 btrfs_release_path(chunk_root, &path);
2290 }
2291 btrfs_release_path(chunk_root, &path);
2292
2293 /* fixup the system chunk array in super block */
2294 btrfs_set_super_sys_array_size(&info->super_copy, 0);
2295
2296 key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
2297 key.offset = 0;
2298 key.type = BTRFS_CHUNK_ITEM_KEY;
2299
2300 ret = btrfs_search_slot(trans, chunk_root, &key, &path, 0, 0);
2301 if (ret < 0)
2302 goto err;
2303 BUG_ON(ret != 0);
2304 while(1) {
2305 leaf = path.nodes[0];
2306 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
2307 ret = btrfs_next_leaf(chunk_root, &path);
2308 if (ret < 0)
2309 goto err;
2310 if (ret > 0)
2311 break;
2312 leaf = path.nodes[0];
2313 }
2314 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
2315 if (key.type != BTRFS_CHUNK_ITEM_KEY)
2316 goto next;
2317
2318 ptr = btrfs_item_ptr_offset(leaf, path.slots[0]);
2319 size = btrfs_item_size_nr(leaf, path.slots[0]);
2320 BUG_ON(size != sizeof(chunk));
2321 read_extent_buffer(leaf, &chunk, ptr, size);
2322 type = btrfs_stack_chunk_type(&chunk);
2323
2324 if (!(type & BTRFS_BLOCK_GROUP_SYSTEM))
2325 goto next;
2326
2327 ret = btrfs_add_system_chunk(trans, chunk_root, &key,
2328 &chunk, size);
2329 if (ret)
2330 goto err;
2331 next:
2332 path.slots[0]++;
2333 }
2334
2335 ret = btrfs_commit_transaction(trans, root);
2336 BUG_ON(ret);
2337 err:
2338 btrfs_release_path(chunk_root, &path);
2339 return ret;
2340 }
2341
2342 int do_convert(const char *devname, int datacsum, int packing, int noxattr)
2343 {
2344 int i, fd, ret;
2345 u32 blocksize;
2346 u64 blocks[7];
2347 u64 total_bytes;
2348 u64 super_bytenr;
2349 ext2_filsys ext2_fs;
2350 struct btrfs_root *root;
2351 struct btrfs_root *ext2_root;
2352
2353 ret = open_ext2fs(devname, &ext2_fs);
2354 if (ret) {
2355 fprintf(stderr, "unable to open the Ext2fs\n");
2356 goto fail;
2357 }
2358 blocksize = ext2_fs->blocksize;
2359 total_bytes = (u64)ext2_fs->super->s_blocks_count * blocksize;
2360 if (blocksize < 4096) {
2361 fprintf(stderr, "block size is too small\n");
2362 goto fail;
2363 }
2364 if (!(ext2_fs->super->s_feature_incompat &
2365 EXT2_FEATURE_INCOMPAT_FILETYPE)) {
2366 fprintf(stderr, "filetype feature is missing\n");
2367 goto fail;
2368 }
2369 for (i = 0; i < 7; i++) {
2370 ret = ext2_alloc_block(ext2_fs, 0, blocks + i);
2371 if (ret) {
2372 fprintf(stderr, "not enough free space\n");
2373 goto fail;
2374 }
2375 blocks[i] *= blocksize;
2376 }
2377 super_bytenr = blocks[0];
2378 fd = open(devname, O_RDWR);
2379 if (fd < 0) {
2380 fprintf(stderr, "unable to open %s\n", devname);
2381 goto fail;
2382 }
2383 ret = make_btrfs(fd, devname, ext2_fs->super->s_volume_name,
2384 blocks, total_bytes, blocksize, blocksize,
2385 blocksize, blocksize);
2386 if (ret) {
2387 fprintf(stderr, "unable to create initial ctree\n");
2388 goto fail;
2389 }
2390 /* create a system chunk that maps the whole device */
2391 ret = prepare_system_chunk(fd, super_bytenr, blocksize);
2392 if (ret) {
2393 fprintf(stderr, "unable to update system chunk\n");
2394 goto fail;
2395 }
2396 root = open_ctree_fd(fd, devname, super_bytenr, O_RDWR);
2397 if (!root) {
2398 fprintf(stderr, "unable to open ctree\n");
2399 goto fail;
2400 }
2401 ret = cache_free_extents(root, ext2_fs);
2402 if (ret) {
2403 fprintf(stderr, "error during cache_free_extents %d\n", ret);
2404 goto fail;
2405 }
2406 root->fs_info->extent_ops = &extent_ops;
2407 /* recover block allocation bitmap */
2408 for (i = 0; i < 7; i++) {
2409 blocks[i] /= blocksize;
2410 ext2_free_block(ext2_fs, blocks[i]);
2411 }
2412 ret = init_btrfs(root);
2413 if (ret) {
2414 fprintf(stderr, "unable to setup the root tree\n");
2415 goto fail;
2416 }
2417 printf("creating btrfs metadata.\n");
2418 ret = copy_inodes(root, ext2_fs, datacsum, packing, noxattr);
2419 if (ret) {
2420 fprintf(stderr, "error during copy_inodes %d\n", ret);
2421 goto fail;
2422 }
2423 printf("creating ext2fs image file.\n");
2424 ext2_root = link_subvol(root, "ext2_saved", EXT2_IMAGE_SUBVOL_OBJECTID);
2425 if (!ext2_root) {
2426 fprintf(stderr, "unable to create subvol\n");
2427 goto fail;
2428 }
2429 ret = create_ext2_image(ext2_root, ext2_fs, "image");
2430 if (ret) {
2431 fprintf(stderr, "error during create_ext2_image %d\n", ret);
2432 goto fail;
2433 }
2434 printf("cleaning up system chunk.\n");
2435 ret = cleanup_sys_chunk(root, ext2_root);
2436 if (ret) {
2437 fprintf(stderr, "error during cleanup_sys_chunk %d\n", ret);
2438 goto fail;
2439 }
2440 ret = close_ctree(root);
2441 if (ret) {
2442 fprintf(stderr, "error during close_ctree %d\n", ret);
2443 goto fail;
2444 }
2445 close_ext2fs(ext2_fs);
2446
2447 /*
2448 * If this step succeed, we get a mountable btrfs. Otherwise
2449 * the ext2fs is left unchanged.
2450 */
2451 ret = migrate_super_block(fd, super_bytenr, blocksize);
2452 if (ret) {
2453 fprintf(stderr, "unable to migrate super block\n");
2454 goto fail;
2455 }
2456
2457 root = open_ctree_fd(fd, devname, 0, O_RDWR);
2458 if (!root) {
2459 fprintf(stderr, "unable to open ctree\n");
2460 goto fail;
2461 }
2462 /* move chunk tree into system chunk. */
2463 ret = fixup_chunk_mapping(root);
2464 if (ret) {
2465 fprintf(stderr, "error during fixup_chunk_tree\n");
2466 goto fail;
2467 }
2468 ret = close_ctree(root);
2469 close(fd);
2470
2471 printf("conversion complete.\n");
2472 return 0;
2473 fail:
2474 fprintf(stderr, "conversion aborted.\n");
2475 return -1;
2476 }
2477
2478 static int may_rollback(struct btrfs_root *root)
2479 {
2480 struct btrfs_fs_info *info = root->fs_info;
2481 struct btrfs_multi_bio *multi = NULL;
2482 u64 bytenr;
2483 u64 length;
2484 u64 physical;
2485 u64 total_bytes;
2486 int num_stripes;
2487 int ret;
2488
2489 if (btrfs_super_num_devices(&info->super_copy) != 1)
2490 goto fail;
2491
2492 bytenr = BTRFS_SUPER_INFO_OFFSET;
2493 total_bytes = btrfs_super_total_bytes(&root->fs_info->super_copy);
2494
2495 while (1) {
2496 ret = btrfs_map_block(&info->mapping_tree, WRITE, bytenr,
2497 &length, &multi, 0);
2498 if (ret)
2499 goto fail;
2500
2501 num_stripes = multi->num_stripes;
2502 physical = multi->stripes[0].physical;
2503 kfree(multi);
2504
2505 if (num_stripes != 1 || physical != bytenr)
2506 goto fail;
2507
2508 bytenr += length;
2509 if (bytenr >= total_bytes)
2510 break;
2511 }
2512 return 0;
2513 fail:
2514 return -1;
2515 }
2516
2517 int do_rollback(const char *devname, int force)
2518 {
2519 int fd;
2520 int ret;
2521 int i;
2522 struct btrfs_root *root;
2523 struct btrfs_root *ext2_root;
2524 struct btrfs_root *chunk_root;
2525 struct btrfs_dir_item *dir;
2526 struct btrfs_inode_item *inode;
2527 struct btrfs_file_extent_item *fi;
2528 struct btrfs_trans_handle *trans;
2529 struct extent_buffer *leaf;
2530 struct btrfs_block_group_cache *cache1;
2531 struct btrfs_block_group_cache *cache2;
2532 struct btrfs_key key;
2533 struct btrfs_path path;
2534 struct extent_io_tree io_tree;
2535 char *buf;
2536 char *name;
2537 u64 bytenr;
2538 u64 num_bytes;
2539 u64 root_dir;
2540 u64 objectid;
2541 u64 offset;
2542 u64 start;
2543 u64 end;
2544 u64 sb_bytenr;
2545 u64 first_free;
2546 u64 total_bytes;
2547 u32 sectorsize;
2548
2549 extent_io_tree_init(&io_tree);
2550
2551 fd = open(devname, O_RDWR);
2552 if (fd < 0) {
2553 fprintf(stderr, "unable to open %s\n", devname);
2554 goto fail;
2555 }
2556 root = open_ctree_fd(fd, devname, 0, O_RDWR);
2557 if (!root) {
2558 fprintf(stderr, "unable to open ctree\n");
2559 goto fail;
2560 }
2561 ret = may_rollback(root);
2562 if (ret < 0) {
2563 fprintf(stderr, "unable to do rollback\n");
2564 goto fail;
2565 }
2566
2567 sectorsize = root->sectorsize;
2568 buf = malloc(sectorsize);
2569 if (!buf) {
2570 fprintf(stderr, "unable to allocate memory\n");
2571 goto fail;
2572 }
2573
2574 btrfs_init_path(&path);
2575
2576 key.objectid = EXT2_IMAGE_SUBVOL_OBJECTID;
2577 key.type = BTRFS_ROOT_ITEM_KEY;
2578 key.offset = (u64)-1;
2579 ext2_root = btrfs_read_fs_root(root->fs_info, &key);
2580 if (!ext2_root || IS_ERR(ext2_root)) {
2581 fprintf(stderr, "unable to open subvol %llu\n",
2582 key.objectid);
2583 goto fail;
2584 }
2585
2586 name = "image";
2587 root_dir = btrfs_root_dirid(&root->root_item);
2588 dir = btrfs_lookup_dir_item(NULL, ext2_root, &path,
2589 root_dir, name, strlen(name), 0);
2590 if (!dir || IS_ERR(dir)) {
2591 fprintf(stderr, "unable to find file %s\n", name);
2592 goto fail;
2593 }
2594 leaf = path.nodes[0];
2595 btrfs_dir_item_key_to_cpu(leaf, dir, &key);
2596 btrfs_release_path(ext2_root, &path);
2597
2598 objectid = key.objectid;
2599
2600 ret = btrfs_lookup_inode(NULL, ext2_root, &path, &key, 0);
2601 if (ret) {
2602 fprintf(stderr, "unable to find inode item\n");
2603 goto fail;
2604 }
2605 leaf = path.nodes[0];
2606 inode = btrfs_item_ptr(leaf, path.slots[0], struct btrfs_inode_item);
2607 total_bytes = btrfs_inode_size(leaf, inode);
2608 btrfs_release_path(ext2_root, &path);
2609
2610 key.objectid = objectid;
2611 key.offset = 0;
2612 btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
2613 ret = btrfs_search_slot(NULL, ext2_root, &key, &path, 0, 0);
2614 if (ret != 0) {
2615 fprintf(stderr, "unable to find first file extent\n");
2616 btrfs_release_path(ext2_root, &path);
2617 goto fail;
2618 }
2619
2620 /* build mapping tree for the relocated blocks */
2621 for (offset = 0; offset < total_bytes; ) {
2622 leaf = path.nodes[0];
2623 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
2624 ret = btrfs_next_leaf(root, &path);
2625 if (ret != 0)
2626 break;
2627 continue;
2628 }
2629
2630 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
2631 if (key.objectid != objectid || key.offset != offset ||
2632 btrfs_key_type(&key) != BTRFS_EXTENT_DATA_KEY)
2633 break;
2634
2635 fi = btrfs_item_ptr(leaf, path.slots[0],
2636 struct btrfs_file_extent_item);
2637 if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG)
2638 break;
2639 if (btrfs_file_extent_compression(leaf, fi) ||
2640 btrfs_file_extent_encryption(leaf, fi) ||
2641 btrfs_file_extent_other_encoding(leaf, fi))
2642 break;
2643
2644 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
2645 /* skip holes and direct mapped extents */
2646 if (bytenr == 0 || bytenr == offset)
2647 goto next_extent;
2648
2649 bytenr += btrfs_file_extent_offset(leaf, fi);
2650 num_bytes = btrfs_file_extent_num_bytes(leaf, fi);
2651
2652 cache1 = btrfs_lookup_block_group(root->fs_info, offset);
2653 cache2 = btrfs_lookup_block_group(root->fs_info,
2654 offset + num_bytes - 1);
2655 if (!cache1 || cache1 != cache2 ||
2656 (!(cache1->flags & BTRFS_BLOCK_GROUP_SYSTEM) &&
2657 !intersect_with_sb(offset, num_bytes)))
2658 break;
2659
2660 set_extent_bits(&io_tree, offset, offset + num_bytes - 1,
2661 EXTENT_LOCKED, GFP_NOFS);
2662 set_state_private(&io_tree, offset, bytenr);
2663 next_extent:
2664 offset += btrfs_file_extent_num_bytes(leaf, fi);
2665 path.slots[0]++;
2666 }
2667 btrfs_release_path(ext2_root, &path);
2668
2669 if (offset < total_bytes) {
2670 fprintf(stderr, "unable to build extent mapping\n");
2671 goto fail;
2672 }
2673
2674 first_free = BTRFS_SUPER_INFO_OFFSET + 2 * sectorsize - 1;
2675 first_free &= ~((u64)sectorsize - 1);
2676 /* backup for extent #0 should exist */
2677 if(!test_range_bit(&io_tree, 0, first_free - 1, EXTENT_LOCKED, 1)) {
2678 fprintf(stderr, "no backup for the first extent\n");
2679 goto fail;
2680 }
2681 /* force no allocation from system block group */
2682 root->fs_info->system_allocs = -1;
2683 trans = btrfs_start_transaction(root, 1);
2684 BUG_ON(!trans);
2685 /*
2686 * recow the whole chunk tree, this will remove all chunk tree blocks
2687 * from system block group
2688 */
2689 chunk_root = root->fs_info->chunk_root;
2690 memset(&key, 0, sizeof(key));
2691 while (1) {
2692 ret = btrfs_search_slot(trans, chunk_root, &key, &path, 0, 1);
2693 if (ret < 0)
2694 break;
2695
2696 ret = btrfs_next_leaf(chunk_root, &path);
2697 if (ret)
2698 break;
2699
2700 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
2701 btrfs_release_path(chunk_root, &path);
2702 }
2703 btrfs_release_path(chunk_root, &path);
2704
2705 offset = 0;
2706 num_bytes = 0;
2707 while(1) {
2708 cache1 = btrfs_lookup_block_group(root->fs_info, offset);
2709 if (!cache1)
2710 break;
2711
2712 if (cache1->flags & BTRFS_BLOCK_GROUP_SYSTEM)
2713 num_bytes += btrfs_block_group_used(&cache1->item);
2714
2715 offset = cache1->key.objectid + cache1->key.offset;
2716 }
2717 /* only extent #0 left in system block group? */
2718 if (num_bytes > first_free) {
2719 fprintf(stderr, "unable to empty system block group\n");
2720 goto fail;
2721 }
2722 /* create a system chunk that maps the whole device */
2723 ret = prepare_system_chunk_sb(&root->fs_info->super_copy);
2724 if (ret) {
2725 fprintf(stderr, "unable to update system chunk\n");
2726 goto fail;
2727 }
2728
2729 ret = btrfs_commit_transaction(trans, root);
2730 BUG_ON(ret);
2731
2732 ret = close_ctree(root);
2733 if (ret) {
2734 fprintf(stderr, "error during close_ctree %d\n", ret);
2735 goto fail;
2736 }
2737
2738 /* zero btrfs super block mirrors */
2739 memset(buf, 0, sectorsize);
2740 for (i = 1 ; i < BTRFS_SUPER_MIRROR_MAX; i++) {
2741 bytenr = btrfs_sb_offset(i);
2742 if (bytenr >= total_bytes)
2743 break;
2744 ret = pwrite(fd, buf, sectorsize, bytenr);
2745 }
2746
2747 sb_bytenr = (u64)-1;
2748 /* copy all relocated blocks back */
2749 while(1) {
2750 ret = find_first_extent_bit(&io_tree, 0, &start, &end,
2751 EXTENT_LOCKED);
2752 if (ret)
2753 break;
2754
2755 ret = get_state_private(&io_tree, start, &bytenr);
2756 BUG_ON(ret);
2757
2758 clear_extent_bits(&io_tree, start, end, EXTENT_LOCKED,
2759 GFP_NOFS);
2760
2761 while (start <= end) {
2762 if (start == BTRFS_SUPER_INFO_OFFSET) {
2763 sb_bytenr = bytenr;
2764 goto next_sector;
2765 }
2766 ret = pread(fd, buf, sectorsize, bytenr);
2767 if (ret < 0) {
2768 fprintf(stderr, "error during pread %d\n", ret);
2769 goto fail;
2770 }
2771 BUG_ON(ret != sectorsize);
2772 ret = pwrite(fd, buf, sectorsize, start);
2773 if (ret < 0) {
2774 fprintf(stderr, "error during pwrite %d\n", ret);
2775 goto fail;
2776 }
2777 BUG_ON(ret != sectorsize);
2778 next_sector:
2779 start += sectorsize;
2780 bytenr += sectorsize;
2781 }
2782 }
2783
2784 ret = fsync(fd);
2785 if (ret) {
2786 fprintf(stderr, "error during fsync %d\n", ret);
2787 goto fail;
2788 }
2789 /*
2790 * finally, overwrite btrfs super block.
2791 */
2792 ret = pread(fd, buf, sectorsize, sb_bytenr);
2793 if (ret < 0) {
2794 fprintf(stderr, "error during pread %d\n", ret);
2795 goto fail;
2796 }
2797 BUG_ON(ret != sectorsize);
2798 ret = pwrite(fd, buf, sectorsize, BTRFS_SUPER_INFO_OFFSET);
2799 if (ret < 0) {
2800 fprintf(stderr, "error during pwrite %d\n", ret);
2801 goto fail;
2802 }
2803 BUG_ON(ret != sectorsize);
2804 ret = fsync(fd);
2805 if (ret) {
2806 fprintf(stderr, "error during fsync %d\n", ret);
2807 goto fail;
2808 }
2809
2810 close(fd);
2811 free(buf);
2812 extent_io_tree_cleanup(&io_tree);
2813 printf("rollback complete.\n");
2814 return 0;
2815 fail:
2816 fprintf(stderr, "rollback aborted.\n");
2817 return -1;
2818 }
2819
2820 static void print_usage(void)
2821 {
2822 printf("usage: btrfs-convert [-d] [-i] [-n] [-r] device\n");
2823 printf("\t-d disable data checksum\n");
2824 printf("\t-i ignore xattrs and ACLs\n");
2825 printf("\t-n disable packing of small files\n");
2826 printf("\t-r roll back to ext2fs\n");
2827 }
2828
2829 int main(int argc, char *argv[])
2830 {
2831 int ret;
2832 int packing = 1;
2833 int noxattr = 0;
2834 int datacsum = 1;
2835 int rollback = 0;
2836 char *file;
2837 while(1) {
2838 int c = getopt(argc, argv, "dinr");
2839 if (c < 0)
2840 break;
2841 switch(c) {
2842 case 'd':
2843 datacsum = 0;
2844 break;
2845 case 'i':
2846 noxattr = 1;
2847 break;
2848 case 'n':
2849 packing = 0;
2850 break;
2851 case 'r':
2852 rollback = 1;
2853 break;
2854 default:
2855 print_usage();
2856 return 1;
2857 }
2858 }
2859 argc = argc - optind;
2860 if (argc != 1) {
2861 print_usage();
2862 return 1;
2863 }
2864
2865 file = argv[optind];
2866 if (check_mounted(file)) {
2867 fprintf(stderr, "%s is mounted\n", file);
2868 return 1;
2869 }
2870
2871 if (rollback) {
2872 ret = do_rollback(file, 0);
2873 } else {
2874 ret = do_convert(file, datacsum, packing, noxattr);
2875 }
2876 if (ret)
2877 return 1;
2878 return 0;
2879 }
(deprecated) Btrfs progs developments and patch integration