?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add readonly inode flag
[btrfs-progs-unstable/devel.git] / convert.c
blob86c41b0881a9872f77b2403651b2036adad428a1
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 500
20 #ifndef __CHECKER__
21 #include <sys/ioctl.h>
22 #include <sys/mount.h>
23 #endif
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <sys/types.h>
27 #include <sys/stat.h>
28 #include <sys/acl.h>
29 #include <fcntl.h>
30 #include <unistd.h>
31 #include <uuid/uuid.h>
32 #include <linux/fs.h>
33 #include "kerncompat.h"
34 #include "ctree.h"
35 #include "disk-io.h"
36 #include "transaction.h"
37 #include "crc32c.h"
38 #include "utils.h"
39 #include <ext2fs/ext2_fs.h>
40 #include <ext2fs/ext2fs.h>
41 #include <ext2fs/ext2_ext_attr.h>
42 #define INO_OFFSET (BTRFS_FIRST_FREE_OBJECTID - EXT2_ROOT_INO)
43 /*
44 * Open Ext2fs in readonly mode, read block allocation bitmap and
45 * inode bitmap into memory.
46 */
47 static int open_ext2fs(const char *name, ext2_filsys *ret_fs)
48 {
49 int mnt_flags;
50 errcode_t ret;
51 ext2_filsys ext2_fs;
52
53 ret = ext2fs_check_if_mounted(name, &mnt_flags);
54 if (ret) {
55 fprintf(stderr, "ext2fs_check_if_mounted: %s\n",
56 error_message(ret));
57 return -1;
58 }
59 if (mnt_flags & EXT2_MF_MOUNTED) {
60 fprintf(stderr, "%s is mounted\n", name);
61 return -1;
62 }
63 ret = ext2fs_open(name, 0, 0, 0, unix_io_manager, &ext2_fs);
64 if (ret) {
65 fprintf(stderr, "ext2fs_open: %s\n", error_message(ret));
66 goto fail;
67 }
68 ret = ext2fs_read_inode_bitmap(ext2_fs);
69 if (ret) {
70 fprintf(stderr, "ext2fs_read_inode_bitmap: %s\n",
71 error_message(ret));
72 goto fail;
73 }
74 ret = ext2fs_read_block_bitmap(ext2_fs);
75 if (ret) {
76 fprintf(stderr, "ext2fs_read_block_bitmap: %s\n",
77 error_message(ret));
78 goto fail;
79 }
80 *ret_fs = ext2_fs;
81 return 0;
82 fail:
83 return -1;
84 }
85
86 static int close_ext2fs(ext2_filsys fs)
87 {
88 ext2fs_close(fs);
89 return 0;
90 }
91 static int ext2_alloc_block(ext2_filsys fs, u64 goal, u64 *block_ret)
92 {
93 blk_t block;
94
95 if (!ext2fs_new_block(fs, goal, NULL, &block)) {
96 ext2fs_fast_mark_block_bitmap(fs->block_map, block);
97 *block_ret = block;
98 return 0;
99 }
100 return -ENOSPC;
101 }
102
103 static int ext2_free_block(ext2_filsys fs, u64 block)
104 {
105 BUG_ON(block != (blk_t)block);
106 ext2fs_fast_unmark_block_bitmap(fs->block_map, block);
107 return 0;
108 }
109
110 static int custom_alloc_extent(struct btrfs_root *root, u64 num_bytes,
111 u64 hint_byte, struct btrfs_key *ins)
112 {
113 ext2_filsys fs = (ext2_filsys)root->fs_info->priv_data;
114 u32 blocksize = fs->blocksize;
115 u64 first = 0;
116 u64 block;
117 u64 bytenr;
118 int ret;
119
120 block = hint_byte / blocksize;
121 BUG_ON(block != (blk_t)block);
122 BUG_ON(num_bytes != blocksize);
123 while (1) {
124 ret = ext2_alloc_block(fs, block, &block);
125 if (ret)
126 return ret;
127 /* all free blocks are pinned */
128 if (first == block)
129 return -ENOSPC;
130 if (first == 0)
131 first = block;
132
133 bytenr = block * blocksize;
134 if (!test_range_bit(&root->fs_info->pinned_extents, bytenr,
135 bytenr + blocksize - 1, EXTENT_DIRTY, 0))
136 break;
137
138 ext2_free_block(fs, block);
139 block++;
140 }
141 ins->objectid = bytenr;
142 ins->offset = blocksize;
143 btrfs_set_key_type(ins, BTRFS_EXTENT_ITEM_KEY);
144 return 0;
145 }
146
147 static int custom_free_extent(struct btrfs_root *root, u64 bytenr,
148 u64 num_bytes)
149 {
150 u64 block;
151 ext2_filsys fs = (ext2_filsys)root->fs_info->priv_data;
152
153 BUG_ON(bytenr & (fs->blocksize - 1));
154 block = bytenr / fs->blocksize;
155 while (num_bytes > 0) {
156 ext2_free_block(fs, block);
157 block++;
158 num_bytes -= fs->blocksize;
159 }
160 return 0;
161 }
162
163 struct btrfs_extent_ops extent_ops = {
164 .alloc_extent = custom_alloc_extent,
165 .free_extent = custom_free_extent,
166 };
167
168 struct dir_iterate_data {
169 struct btrfs_trans_handle *trans;
170 struct btrfs_root *root;
171 struct btrfs_inode_item *inode;
172 u64 objectid;
173 u64 parent;
174 int errcode;
175 };
176 static u8 filetype_conversion_table[EXT2_FT_MAX] = {
177 [EXT2_FT_UNKNOWN] = BTRFS_FT_UNKNOWN,
178 [EXT2_FT_REG_FILE] = BTRFS_FT_REG_FILE,
179 [EXT2_FT_DIR] = BTRFS_FT_DIR,
180 [EXT2_FT_CHRDEV] = BTRFS_FT_CHRDEV,
181 [EXT2_FT_BLKDEV] = BTRFS_FT_BLKDEV,
182 [EXT2_FT_FIFO] = BTRFS_FT_FIFO,
183 [EXT2_FT_SOCK] = BTRFS_FT_SOCK,
184 [EXT2_FT_SYMLINK] = BTRFS_FT_SYMLINK,
185 };
186
187 static int dir_iterate_proc(ext2_ino_t dir, int entry,
188 struct ext2_dir_entry *old,
189 int offset, int blocksize,
190 char *buf,void *priv_data)
191 {
192 int ret;
193 int file_type;
194 u64 objectid;
195 u64 inode_size;
196 char dotdot[] = "..";
197 struct btrfs_key location;
198 struct ext2_dir_entry_2 *dirent = (struct ext2_dir_entry_2 *)old;
199 struct dir_iterate_data *idata = (struct dir_iterate_data *)priv_data;
200
201 objectid = dirent->inode + INO_OFFSET;
202 if (!strncmp(dirent->name, dotdot, dirent->name_len)) {
203 if (dirent->name_len == 2) {
204 BUG_ON(idata->parent != 0);
205 idata->parent = objectid;
206 }
207 return 0;
208 }
209 if (dirent->inode < EXT2_GOOD_OLD_FIRST_INO)
210 return 0;
211
212 location.objectid = objectid;
213 location.offset = 0;
214 btrfs_set_key_type(&location, BTRFS_INODE_ITEM_KEY);
215
216 file_type = dirent->file_type;
217 BUG_ON(file_type > EXT2_FT_SYMLINK);
218 ret = btrfs_insert_dir_item(idata->trans, idata->root,
219 dirent->name, dirent->name_len,
220 idata->objectid, &location,
221 filetype_conversion_table[file_type]);
222 if (ret)
223 goto fail;
224 ret = btrfs_insert_inode_ref(idata->trans, idata->root,
225 dirent->name, dirent->name_len,
226 objectid, idata->objectid);
227 if (ret)
228 goto fail;
229 inode_size = btrfs_stack_inode_size(idata->inode) +
230 dirent->name_len * 2;
231 btrfs_set_stack_inode_size(idata->inode, inode_size);
232 return 0;
233 fail:
234 idata->errcode = ret;
235 return BLOCK_ABORT;
236 }
237
238 static int create_dir_entries(struct btrfs_trans_handle *trans,
239 struct btrfs_root *root, u64 objectid,
240 struct btrfs_inode_item *btrfs_inode,
241 ext2_filsys ext2_fs, ext2_ino_t ext2_ino)
242 {
243 int ret;
244 errcode_t err;
245 struct dir_iterate_data data = {
246 .trans = trans,
247 .root = root,
248 .inode = btrfs_inode,
249 .objectid = objectid,
250 .parent = 0,
251 .errcode = 0,
252 };
253
254 err = ext2fs_dir_iterate2(ext2_fs, ext2_ino, 0, NULL,
255 dir_iterate_proc, &data);
256 if (err)
257 goto error;
258 ret = data.errcode;
259 if (ret == 0 && data.parent == objectid) {
260 ret = btrfs_insert_inode_ref(trans, root, "..", 2,
261 objectid, objectid);
262 }
263 return ret;
264 error:
265 fprintf(stderr, "ext2fs_dir_iterate2: %s\n", error_message(err));
266 return -1;
267 }
268
269 static int read_disk_extent(struct btrfs_root *root, u64 bytenr,
270 u32 num_bytes, char *buffer)
271 {
272 int ret;
273 struct btrfs_fs_info *fs_info = root->fs_info;
274
275 ret = pread(fs_info->fp, buffer, num_bytes, bytenr);
276 if (ret != num_bytes)
277 goto fail;
278 ret = 0;
279 fail:
280 if (ret > 0)
281 ret = -1;
282 return ret;
283 }
284 /*
285 * Record a file extent. Do all the required works, such as inserting
286 * file extent item, inserting extent item and backref item into extent
287 * tree and updating block accounting.
288 */
289 static int record_file_extent(struct btrfs_trans_handle *trans,
290 struct btrfs_root *root, u64 objectid,
291 struct btrfs_inode_item *inode,
292 u64 file_pos, u64 disk_bytenr,
293 u64 num_bytes, int checksum)
294 {
295 int ret;
296 struct btrfs_fs_info *info = root->fs_info;
297 struct btrfs_root *extent_root = info->extent_root;
298 struct btrfs_key ins_key;
299 struct btrfs_path path;
300 struct btrfs_extent_item extent_item;
301 u32 blocksize = root->sectorsize;
302 u64 nblocks;
303 u64 bytes_used;
304
305 ret = btrfs_insert_file_extent(trans, root, objectid, file_pos,
306 disk_bytenr, num_bytes, num_bytes);
307 if (ret || disk_bytenr == 0)
308 return ret;
309
310 nblocks = btrfs_stack_inode_nblocks(inode) + num_bytes / 512;
311 btrfs_set_stack_inode_nblocks(inode, nblocks);
312 if (checksum) {
313 u64 offset;
314 char *buffer;
315
316 ret = -ENOMEM;
317 buffer = malloc(blocksize);
318 if (!buffer)
319 goto fail;
320 for (offset = 0; offset < num_bytes; offset += blocksize) {
321 ret = read_disk_extent(root, disk_bytenr + offset,
322 blocksize, buffer);
323 if (ret)
324 break;
325 ret = btrfs_csum_file_block(trans, root, inode,
326 objectid, file_pos + offset,
327 buffer, blocksize);
328 if (ret)
329 break;
330 }
331 free(buffer);
332 if (ret)
333 goto fail;
334 }
335
336 bytes_used = btrfs_root_used(&root->root_item);
337 btrfs_set_root_used(&root->root_item, bytes_used + num_bytes);
338 ins_key.objectid = disk_bytenr;
339 ins_key.offset = num_bytes;
340 btrfs_set_key_type(&ins_key, BTRFS_EXTENT_ITEM_KEY);
341 btrfs_set_stack_extent_refs(&extent_item, 1);
342 ret = btrfs_insert_item(trans, extent_root, &ins_key,
343 &extent_item, sizeof(extent_item));
344 if (ret == 0) {
345 bytes_used = btrfs_super_bytes_used(&info->super_copy);
346 btrfs_set_super_bytes_used(&info->super_copy, bytes_used +
347 num_bytes);
348 btrfs_init_path(&path);
349 ret = btrfs_insert_extent_backref(trans, extent_root, &path,
350 disk_bytenr, root->root_key.objectid,
351 trans->transid, objectid, file_pos);
352 if (ret)
353 goto fail;
354 ret = btrfs_update_block_group(trans, root, disk_bytenr,
355 num_bytes, 1, 0, 1);
356 } else if (ret == -EEXIST) {
357 ret = btrfs_inc_extent_ref(trans, root, disk_bytenr, num_bytes,
358 root->root_key.objectid,
359 trans->transid, objectid, file_pos);
360 }
361 if (ret)
362 goto fail;
363 btrfs_extent_post_op(trans, extent_root);
364 return 0;
365 fail:
366 return ret;
367 }
368
369 static int record_file_blocks(struct btrfs_trans_handle *trans,
370 struct btrfs_root *root, u64 objectid,
371 struct btrfs_inode_item *inode,
372 u64 file_block, u64 disk_block,
373 u64 num_blocks, int checksum)
374 {
375 u64 file_pos = file_block * root->sectorsize;
376 u64 disk_bytenr = disk_block * root->sectorsize;
377 u64 num_bytes = num_blocks * root->sectorsize;
378 return record_file_extent(trans, root, objectid, inode, file_pos,
379 disk_bytenr, num_bytes, checksum);
380 }
381
382 struct blk_iterate_data {
383 struct btrfs_trans_handle *trans;
384 struct btrfs_root *root;
385 struct btrfs_inode_item *inode;
386 u64 objectid;
387 u64 first_block;
388 u64 disk_block;
389 u64 num_blocks;
390 int checksum;
391 int errcode;
392 };
393
394 static int block_iterate_proc(ext2_filsys ext2_fs,
395 u64 disk_block, u64 file_block,
396 struct blk_iterate_data *idata)
397 {
398 int ret;
399 u32 blocksize = ext2_fs->blocksize;
400 struct btrfs_root *root = idata->root;
401 struct btrfs_trans_handle *trans = idata->trans;
402
403 if ((file_block > idata->first_block + idata->num_blocks) ||
404 (disk_block != idata->disk_block + idata->num_blocks) ||
405 (idata->num_blocks >= BTRFS_BLOCK_GROUP_SIZE / blocksize)) {
406 if (idata->num_blocks > 0) {
407 ret = record_file_blocks(trans, root, idata->objectid,
408 idata->inode, idata->first_block,
409 idata->disk_block, idata->num_blocks,
410 idata->checksum);
411 if (ret)
412 goto fail;
413 idata->first_block += idata->num_blocks;
414 idata->num_blocks = 0;
415 }
416 if (file_block > idata->first_block) {
417 ret = record_file_blocks(trans, root, idata->objectid,
418 idata->inode, idata->first_block,
419 0, file_block - idata->first_block,
420 idata->checksum);
421 if (ret)
422 goto fail;
423 }
424 idata->first_block = file_block;
425 idata->disk_block = disk_block;
426 }
427 idata->num_blocks++;
428 return 0;
429 fail:
430 idata->errcode = ret;
431 return BLOCK_ABORT;
432 }
433
434 static int __block_iterate_proc(ext2_filsys fs, blk_t *blocknr,
435 e2_blkcnt_t blockcnt, blk_t ref_block,
436 int ref_offset, void *priv_data)
437 {
438 struct blk_iterate_data *idata;
439 idata = (struct blk_iterate_data *)priv_data;
440 return block_iterate_proc(fs, *blocknr, blockcnt, idata);
441 }
442
443 /*
444 * traverse file's data blocks, record these data blocks as file extents.
445 */
446 static int create_file_extents(struct btrfs_trans_handle *trans,
447 struct btrfs_root *root, u64 objectid,
448 struct btrfs_inode_item *btrfs_inode,
449 ext2_filsys ext2_fs, ext2_ino_t ext2_ino,
450 int datacsum, int packing)
451 {
452 int ret;
453 char *buffer = NULL;
454 errcode_t err;
455 u32 last_block;
456 u32 sectorsize = root->sectorsize;
457 u64 inode_size = btrfs_stack_inode_size(btrfs_inode);
458 struct blk_iterate_data data = {
459 .trans = trans,
460 .root = root,
461 .inode = btrfs_inode,
462 .objectid = objectid,
463 .first_block = 0,
464 .disk_block = 0,
465 .num_blocks = 0,
466 .checksum = datacsum,
467 .errcode = 0,
468 };
469 err = ext2fs_block_iterate2(ext2_fs, ext2_ino, BLOCK_FLAG_DATA_ONLY,
470 NULL, __block_iterate_proc, &data);
471 if (err)
472 goto error;
473 ret = data.errcode;
474 if (ret)
475 goto fail;
476 if (packing && data.first_block == 0 && data.num_blocks > 0 &&
477 inode_size <= BTRFS_MAX_INLINE_DATA_SIZE(root)) {
478 u64 num_bytes = data.num_blocks * sectorsize;
479 u64 disk_bytenr = data.disk_block * sectorsize;
480
481 buffer = malloc(num_bytes);
482 if (!buffer)
483 return -ENOMEM;
484 ret = read_disk_extent(root, disk_bytenr, num_bytes, buffer);
485 if (ret)
486 goto fail;
487 if (num_bytes > inode_size)
488 num_bytes = inode_size;
489 ret = btrfs_insert_inline_extent(trans, root, objectid,
490 0, buffer, num_bytes);
491 if (ret)
492 goto fail;
493 } else if (data.num_blocks > 0) {
494 ret = record_file_blocks(trans, root, objectid, btrfs_inode,
495 data.first_block, data.disk_block,
496 data.num_blocks, data.checksum);
497 if (ret)
498 goto fail;
499 }
500 data.first_block += data.num_blocks;
501 last_block = (inode_size + sectorsize - 1) / sectorsize;
502 if (last_block > data.first_block) {
503 ret = record_file_blocks(trans, root, objectid, btrfs_inode,
504 data.first_block, 0, last_block -
505 data.first_block, data.checksum);
506 }
507 fail:
508 if (buffer)
509 free(buffer);
510 return ret;
511 error:
512 fprintf(stderr, "ext2fs_block_iterate2: %s\n", error_message(err));
513 return -1;
514 }
515
516 static int create_symbol_link(struct btrfs_trans_handle *trans,
517 struct btrfs_root *root, u64 objectid,
518 struct btrfs_inode_item *btrfs_inode,
519 ext2_filsys ext2_fs, ext2_ino_t ext2_ino,
520 struct ext2_inode *ext2_inode)
521 {
522 int ret;
523 char *pathname;
524 u64 inode_size = btrfs_stack_inode_size(btrfs_inode);
525 if (ext2fs_inode_data_blocks(ext2_fs, ext2_inode)) {
526 btrfs_set_stack_inode_size(btrfs_inode, inode_size + 1);
527 ret = create_file_extents(trans, root, objectid, btrfs_inode,
528 ext2_fs, ext2_ino, 1, 1);
529 btrfs_set_stack_inode_size(btrfs_inode, inode_size);
530 return ret;
531 }
532
533 pathname = (char *)&(ext2_inode->i_block[0]);
534 BUG_ON(pathname[inode_size] != 0);
535 ret = btrfs_insert_inline_extent(trans, root, objectid, 0,
536 pathname, inode_size + 1);
537 return ret;
538 }
539
540 /*
541 * Following xattr/acl related codes are based on codes in
542 * fs/ext3/xattr.c and fs/ext3/acl.c
543 */
544 #define EXT2_XATTR_BHDR(ptr) ((struct ext2_ext_attr_header *)(ptr))
545 #define EXT2_XATTR_BFIRST(ptr) \
546 ((struct ext2_ext_attr_entry *)(EXT2_XATTR_BHDR(ptr) + 1))
547 #define EXT2_XATTR_IHDR(inode) \
548 ((struct ext2_ext_attr_header *) ((void *)(inode) + \
549 EXT2_GOOD_OLD_INODE_SIZE + (inode)->i_extra_isize))
550 #define EXT2_XATTR_IFIRST(inode) \
551 ((struct ext2_ext_attr_entry *) ((void *)EXT2_XATTR_IHDR(inode) + \
552 sizeof(EXT2_XATTR_IHDR(inode)->h_magic)))
553
554 static int ext2_xattr_check_names(struct ext2_ext_attr_entry *entry,
555 const void *end)
556 {
557 struct ext2_ext_attr_entry *next;
558
559 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
560 next = EXT2_EXT_ATTR_NEXT(entry);
561 if ((void *)next >= end)
562 return -EIO;
563 entry = next;
564 }
565 return 0;
566 }
567
568 static int ext2_xattr_check_block(const char *buf, size_t size)
569 {
570 int error;
571 struct ext2_ext_attr_header *header = EXT2_XATTR_BHDR(buf);
572
573 if (header->h_magic != EXT2_EXT_ATTR_MAGIC ||
574 header->h_blocks != 1)
575 return -EIO;
576 error = ext2_xattr_check_names(EXT2_XATTR_BFIRST(buf), buf + size);
577 return error;
578 }
579
580 static int ext2_xattr_check_entry(struct ext2_ext_attr_entry *entry,
581 size_t size)
582 {
583 size_t value_size = entry->e_value_size;
584
585 if (entry->e_value_block != 0 || value_size > size ||
586 entry->e_value_offs + value_size > size)
587 return -EIO;
588 return 0;
589 }
590
591 #define EXT2_ACL_VERSION 0x0001
592
593 typedef struct {
594 __le16 e_tag;
595 __le16 e_perm;
596 __le32 e_id;
597 } ext2_acl_entry;
598
599 typedef struct {
600 __le16 e_tag;
601 __le16 e_perm;
602 } ext2_acl_entry_short;
603
604 typedef struct {
605 __le32 a_version;
606 } ext2_acl_header;
607
608 static inline int ext2_acl_count(size_t size)
609 {
610 ssize_t s;
611 size -= sizeof(ext2_acl_header);
612 s = size - 4 * sizeof(ext2_acl_entry_short);
613 if (s < 0) {
614 if (size % sizeof(ext2_acl_entry_short))
615 return -1;
616 return size / sizeof(ext2_acl_entry_short);
617 } else {
618 if (s % sizeof(ext2_acl_entry))
619 return -1;
620 return s / sizeof(ext2_acl_entry) + 4;
621 }
622 }
623
624 #define ACL_EA_VERSION 0x0002
625
626 typedef struct {
627 __le16 e_tag;
628 __le16 e_perm;
629 __le32 e_id;
630 } acl_ea_entry;
631
632 typedef struct {
633 __le32 a_version;
634 acl_ea_entry a_entries[0];
635 } acl_ea_header;
636
637 static inline size_t acl_ea_size(int count)
638 {
639 return sizeof(acl_ea_header) + count * sizeof(acl_ea_entry);
640 }
641
642 static int ext2_acl_to_xattr(void *dst, const void *src,
643 size_t dst_size, size_t src_size)
644 {
645 int i, count;
646 const void *end = src + src_size;
647 acl_ea_header *ext_acl = (acl_ea_header *)dst;
648 acl_ea_entry *dst_entry = ext_acl->a_entries;
649 ext2_acl_entry *src_entry;
650
651 if (src_size < sizeof(ext2_acl_header))
652 goto fail;
653 if (((ext2_acl_header *)src)->a_version !=
654 cpu_to_le32(EXT2_ACL_VERSION))
655 goto fail;
656 src += sizeof(ext2_acl_header);
657 count = ext2_acl_count(src_size);
658 if (count <= 0)
659 goto fail;
660
661 BUG_ON(dst_size < acl_ea_size(count));
662 ext_acl->a_version = cpu_to_le32(ACL_EA_VERSION);
663 for (i = 0; i < count; i++, dst_entry++) {
664 src_entry = (ext2_acl_entry *)src;
665 if (src + sizeof(ext2_acl_entry_short) > end)
666 goto fail;
667 dst_entry->e_tag = src_entry->e_tag;
668 dst_entry->e_perm = src_entry->e_perm;
669 switch (le16_to_cpu(src_entry->e_tag)) {
670 case ACL_USER_OBJ:
671 case ACL_GROUP_OBJ:
672 case ACL_MASK:
673 case ACL_OTHER:
674 src += sizeof(ext2_acl_entry_short);
675 dst_entry->e_id = cpu_to_le32(ACL_UNDEFINED_ID);
676 break;
677 case ACL_USER:
678 case ACL_GROUP:
679 src += sizeof(ext2_acl_entry);
680 if (src > end)
681 goto fail;
682 dst_entry->e_id = src_entry->e_id;
683 break;
684 default:
685 goto fail;
686 }
687 }
688 if (src != end)
689 goto fail;
690 return 0;
691 fail:
692 return -EINVAL;
693 }
694
695 static char *xattr_prefix_table[] = {
696 [1] = "user.",
697 [2] = "system.posix_acl_access",
698 [3] = "system.posix_acl_default",
699 [4] = "trusted.",
700 [6] = "security.",
701 };
702
703 static int copy_single_xattr(struct btrfs_trans_handle *trans,
704 struct btrfs_root *root, u64 objectid,
705 struct ext2_ext_attr_entry *entry,
706 const void *data, u32 datalen)
707 {
708 int ret = 0;
709 int name_len;
710 int name_index;
711 void *databuf = NULL;
712 char namebuf[XATTR_NAME_MAX + 1];
713
714 name_index = entry->e_name_index;
715 if (name_index >= ARRAY_SIZE(xattr_prefix_table) ||
716 xattr_prefix_table[name_index] == NULL)
717 return -EOPNOTSUPP;
718 name_len = strlen(xattr_prefix_table[name_index]) +
719 entry->e_name_len;
720 if (name_len >= sizeof(namebuf))
721 return -ERANGE;
722
723 if (name_index == 2 || name_index == 3) {
724 size_t bufsize = acl_ea_size(ext2_acl_count(datalen));
725 databuf = malloc(bufsize);
726 if (!databuf)
727 return -ENOMEM;
728 ret = ext2_acl_to_xattr(databuf, data, bufsize, datalen);
729 if (ret)
730 goto out;
731 data = databuf;
732 datalen = bufsize;
733 }
734 if (name_len + datalen > BTRFS_LEAF_DATA_SIZE(root) -
735 sizeof(struct btrfs_item) - sizeof(struct btrfs_dir_item)) {
736 fprintf(stderr, "skip large xattr on inode %Lu name %.*s\n",
737 objectid - INO_OFFSET, name_len, namebuf);
738 goto out;
739 }
740 strcpy(namebuf, xattr_prefix_table[name_index]);
741 strncat(namebuf, EXT2_EXT_ATTR_NAME(entry), entry->e_name_len);
742 ret = btrfs_insert_xattr_item(trans, root, namebuf, name_len,
743 data, datalen, objectid);
744 out:
745 if (databuf)
746 free(databuf);
747 return ret;
748 }
749
750 static int copy_extended_attrs(struct btrfs_trans_handle *trans,
751 struct btrfs_root *root, u64 objectid,
752 struct btrfs_inode_item *btrfs_inode,
753 ext2_filsys ext2_fs, ext2_ino_t ext2_ino)
754 {
755 int ret = 0;
756 int inline_ea = 0;
757 errcode_t err;
758 u32 datalen;
759 u32 block_size = ext2_fs->blocksize;
760 u32 inode_size = EXT2_INODE_SIZE(ext2_fs->super);
761 struct ext2_inode_large *ext2_inode;
762 struct ext2_ext_attr_entry *entry;
763 void *data;
764 char *buffer = NULL;
765 char inode_buf[EXT2_GOOD_OLD_INODE_SIZE];
766
767 if (inode_size <= EXT2_GOOD_OLD_INODE_SIZE) {
768 ext2_inode = (struct ext2_inode_large *)inode_buf;
769 } else {
770 ext2_inode = (struct ext2_inode_large *)malloc(inode_size);
771 if (!ext2_inode)
772 return -ENOMEM;
773 }
774 err = ext2fs_read_inode_full(ext2_fs, ext2_ino, (void *)ext2_inode,
775 inode_size);
776 if (err) {
777 fprintf(stderr, "ext2fs_read_inode_full: %s\n",
778 error_message(err));
779 ret = -1;
780 goto out;
781 }
782
783 if (ext2_ino > ext2_fs->super->s_first_ino &&
784 inode_size > EXT2_GOOD_OLD_INODE_SIZE) {
785 if (EXT2_GOOD_OLD_INODE_SIZE +
786 ext2_inode->i_extra_isize > inode_size) {
787 ret = -EIO;
788 goto out;
789 }
790 if (ext2_inode->i_extra_isize != 0 &&
791 EXT2_XATTR_IHDR(ext2_inode)->h_magic ==
792 EXT2_EXT_ATTR_MAGIC) {
793 inline_ea = 1;
794 }
795 }
796 if (inline_ea) {
797 int total;
798 void *end = (void *)ext2_inode + inode_size;
799 entry = EXT2_XATTR_IFIRST(ext2_inode);
800 total = end - (void *)entry;
801 ret = ext2_xattr_check_names(entry, end);
802 if (ret)
803 goto out;
804 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
805 ret = ext2_xattr_check_entry(entry, total);
806 if (ret)
807 goto out;
808 data = (void *)EXT2_XATTR_IFIRST(ext2_inode) +
809 entry->e_value_offs;
810 datalen = entry->e_value_size;
811 ret = copy_single_xattr(trans, root, objectid,
812 entry, data, datalen);
813 if (ret)
814 goto out;
815 entry = EXT2_EXT_ATTR_NEXT(entry);
816 }
817 }
818
819 if (ext2_inode->i_file_acl == 0)
820 goto out;
821
822 buffer = malloc(block_size);
823 if (!buffer) {
824 ret = -ENOMEM;
825 goto out;
826 }
827 err = ext2fs_read_ext_attr(ext2_fs, ext2_inode->i_file_acl, buffer);
828 if (err) {
829 fprintf(stderr, "ext2fs_read_ext_attr: %s\n",
830 error_message(err));
831 ret = -1;
832 goto out;
833 }
834 ret = ext2_xattr_check_block(buffer, block_size);
835 if (ret)
836 goto out;
837
838 entry = EXT2_XATTR_BFIRST(buffer);
839 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
840 ret = ext2_xattr_check_entry(entry, block_size);
841 if (ret)
842 goto out;
843 data = buffer + entry->e_value_offs;
844 datalen = entry->e_value_size;
845 ret = copy_single_xattr(trans, root, objectid,
846 entry, data, datalen);
847 if (ret)
848 goto out;
849 entry = EXT2_EXT_ATTR_NEXT(entry);
850 }
851 out:
852 if (buffer != NULL)
853 free(buffer);
854 if ((void *)ext2_inode != inode_buf)
855 free(ext2_inode);
856 return ret;
857 }
858 #define MINORBITS 20
859 #define MKDEV(ma, mi) (((ma) << MINORBITS) | (mi))
860
861 static inline dev_t old_decode_dev(u16 val)
862 {
863 return MKDEV((val >> 8) & 255, val & 255);
864 }
865
866 static inline dev_t new_decode_dev(u32 dev)
867 {
868 unsigned major = (dev & 0xfff00) >> 8;
869 unsigned minor = (dev & 0xff) | ((dev >> 12) & 0xfff00);
870 return MKDEV(major, minor);
871 }
872
873 static int copy_inode_item(struct btrfs_inode_item *dst,
874 struct ext2_inode *src)
875 {
876 btrfs_set_stack_inode_generation(dst, 1);
877 btrfs_set_stack_inode_size(dst, src->i_size);
878 btrfs_set_stack_inode_nblocks(dst, src->i_blocks);
879 btrfs_set_stack_inode_block_group(dst, 0);
880 btrfs_set_stack_inode_nblocks(dst, 0);
881 btrfs_set_stack_inode_nlink(dst, src->i_links_count);
882 btrfs_set_stack_inode_uid(dst, src->i_uid | (src->i_uid_high << 16));
883 btrfs_set_stack_inode_gid(dst, src->i_gid | (src->i_gid_high << 16));
884 btrfs_set_stack_inode_mode(dst, src->i_mode);
885 btrfs_set_stack_inode_rdev(dst, 0);
886 btrfs_set_stack_inode_flags(dst, 0);
887 btrfs_set_stack_inode_compat_flags(dst, 0);
888 btrfs_set_stack_timespec_sec(&dst->atime, src->i_atime);
889 btrfs_set_stack_timespec_nsec(&dst->atime, 0);
890 btrfs_set_stack_timespec_sec(&dst->ctime, src->i_ctime);
891 btrfs_set_stack_timespec_nsec(&dst->ctime, 0);
892 btrfs_set_stack_timespec_sec(&dst->mtime, src->i_mtime);
893 btrfs_set_stack_timespec_nsec(&dst->mtime, 0);
894 btrfs_set_stack_timespec_sec(&dst->otime, 0);
895 btrfs_set_stack_timespec_nsec(&dst->otime, 0);
896
897 if (S_ISDIR(src->i_mode)) {
898 btrfs_set_stack_inode_size(dst, 0);
899 btrfs_set_stack_inode_nlink(dst, 1);
900 }
901 if (!S_ISREG(src->i_mode) && !S_ISDIR(src->i_mode) &&
902 !S_ISLNK(src->i_mode)) {
903 if (src->i_block[0]) {
904 btrfs_set_stack_inode_rdev(dst,
905 old_decode_dev(src->i_block[0]));
906 } else {
907 btrfs_set_stack_inode_rdev(dst,
908 new_decode_dev(src->i_block[1]));
909 }
910 }
911 return 0;
912 }
913
914 /*
915 * copy a single inode. do all the required works, such as cloning
916 * inode item, creating file extents and creating directory entries.
917 */
918 static int copy_single_inode(struct btrfs_trans_handle *trans,
919 struct btrfs_root *root, u64 objectid,
920 ext2_filsys ext2_fs, ext2_ino_t ext2_ino,
921 int datacsum, int packing, int noxattr)
922 {
923 int ret;
924 errcode_t err;
925 struct ext2_inode ext2_inode;
926 struct btrfs_key inode_key;
927 struct btrfs_inode_item btrfs_inode;
928
929 err = ext2fs_read_inode(ext2_fs, ext2_ino, &ext2_inode);
930 if (err)
931 goto error;
932
933 if (!ext2_inode.i_links_count &&
934 (!ext2_inode.i_mode || ext2_inode.i_dtime)) {
935 printf("skip inode %u\n", ext2_ino);
936 return 0;
937 }
938 copy_inode_item(&btrfs_inode, &ext2_inode);
939 if (!datacsum && S_ISREG(ext2_inode.i_mode)) {
940 u32 flags = btrfs_stack_inode_flags(&btrfs_inode) |
941 BTRFS_INODE_NODATASUM;
942 btrfs_set_stack_inode_flags(&btrfs_inode, flags);
943 }
944
945 switch (ext2_inode.i_mode & S_IFMT) {
946 case S_IFREG:
947 ret = create_file_extents(trans, root, objectid, &btrfs_inode,
948 ext2_fs, ext2_ino, datacsum, packing);
949 break;
950 case S_IFDIR:
951 ret = create_dir_entries(trans, root, objectid, &btrfs_inode,
952 ext2_fs, ext2_ino);
953 break;
954 case S_IFLNK:
955 ret = create_symbol_link(trans, root, objectid, &btrfs_inode,
956 ext2_fs, ext2_ino, &ext2_inode);
957 break;
958 default:
959 ret = 0;
960 break;
961 }
962 if (ret)
963 return ret;
964
965 if (!noxattr) {
966 ret = copy_extended_attrs(trans, root, objectid, &btrfs_inode,
967 ext2_fs, ext2_ino);
968 if (ret)
969 return ret;
970 }
971 inode_key.objectid = objectid;
972 inode_key.offset = 0;
973 btrfs_set_key_type(&inode_key, BTRFS_INODE_ITEM_KEY);
974 ret = btrfs_insert_inode(trans, root, objectid, &btrfs_inode);
975 return ret;
976 error:
977 fprintf(stderr, "ext2fs_read_inode: %s\n", error_message(err));
978 return -1;
979 }
980
981 static int copy_disk_extent(struct btrfs_root *root, u64 dst_bytenr,
982 u64 src_bytenr, u32 num_bytes)
983 {
984 int ret;
985 char *buffer;
986 struct btrfs_fs_info *fs_info = root->fs_info;
987
988 buffer = malloc(num_bytes);
989 if (!buffer)
990 return -ENOMEM;
991 ret = pread(fs_info->fp, buffer, num_bytes, src_bytenr);
992 if (ret != num_bytes)
993 goto fail;
994 ret = pwrite(fs_info->fp, buffer, num_bytes, dst_bytenr);
995 if (ret != num_bytes)
996 goto fail;
997 ret = 0;
998 fail:
999 free(buffer);
1000 if (ret > 0)
1001 ret = -1;
1002 return ret;
1003 }
1004 /*
1005 * scan ext2's inode bitmap and copy all used inode.
1006 */
1007 static int copy_inodes(struct btrfs_root *root, ext2_filsys ext2_fs,
1008 int datacsum, int packing, int noxattr)
1009 {
1010 int ret;
1011 ext2_ino_t ext2_ino;
1012 u64 objectid;
1013 struct btrfs_trans_handle *trans;
1014
1015 trans = btrfs_start_transaction(root, 1);
1016 if (!trans)
1017 return -ENOMEM;
1018 ext2_ino = ext2_fs->inode_map->start;
1019 for (; ext2_ino <= ext2_fs->inode_map->end; ext2_ino++) {
1020 if (ext2fs_fast_test_inode_bitmap(ext2_fs->inode_map,
1021 ext2_ino)) {
1022 /* skip special inode in ext2fs */
1023 if (ext2_ino < EXT2_GOOD_OLD_FIRST_INO &&
1024 ext2_ino != EXT2_ROOT_INO)
1025 continue;
1026 objectid = ext2_ino + INO_OFFSET;
1027 ret = copy_single_inode(trans, root,
1028 objectid, ext2_fs, ext2_ino,
1029 datacsum, packing, noxattr);
1030 if (ret)
1031 return ret;
1032 }
1033 if (trans->blocks_used >= 8192) {
1034 ret = btrfs_commit_transaction(trans, root);
1035 BUG_ON(ret);
1036 trans = btrfs_start_transaction(root, 1);
1037 BUG_ON(!trans);
1038 }
1039 }
1040 ret = btrfs_commit_transaction(trans, root);
1041 BUG_ON(ret);
1042
1043 return ret;
1044 }
1045 static int lookup_extent_item(struct btrfs_trans_handle *trans,
1046 struct btrfs_root *root,
1047 u64 bytenr, u64 num_bytes)
1048 {
1049 int ret;
1050 struct btrfs_key key;
1051 struct btrfs_path path;
1052 btrfs_init_path(&path);
1053 key.objectid = bytenr;
1054 key.offset = num_bytes;
1055 btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
1056 ret = btrfs_search_slot(trans, root->fs_info->extent_root,
1057 &key, &path, 0, 0);
1058 btrfs_release_path(root, &path);
1059 return ret;
1060 }
1061 /*
1062 * Construct a range of ext2fs image file.
1063 * scan block allocation bitmap, find all blocks used by the ext2fs
1064 * in this range and create file extents that point to these blocks.
1065 *
1066 * Note: Before calling the function, no file extent points to blocks
1067 * in this range
1068 */
1069 static int create_image_file_range(struct btrfs_trans_handle *trans,
1070 struct btrfs_root *root, u64 objectid,
1071 struct btrfs_inode_item *inode,
1072 u64 start_byte, u64 end_byte,
1073 ext2_filsys ext2_fs)
1074 {
1075 u64 bytenr;
1076 u32 blocksize = ext2_fs->blocksize;
1077 u32 block = start_byte / blocksize;
1078 u32 last_block = (end_byte + blocksize - 1) / blocksize;
1079 int ret;
1080 struct blk_iterate_data data = {
1081 .trans = trans,
1082 .root = root,
1083 .inode = inode,
1084 .objectid = objectid,
1085 .first_block = block,
1086 .disk_block = block,
1087 .num_blocks = 0,
1088 .checksum = 0,
1089 .errcode = 0,
1090 };
1091 for (; start_byte < end_byte; block++, start_byte += blocksize) {
1092 if (!ext2fs_fast_test_block_bitmap(ext2_fs->block_map, block))
1093 continue;
1094 /* the bit may be set by us, check extent tree */
1095 bytenr = (u64)block * blocksize;
1096 ret = lookup_extent_item(trans, root, bytenr, blocksize);
1097 if (ret < 0)
1098 goto fail;
1099 if (ret == 0)
1100 continue;
1101
1102 ret = block_iterate_proc(ext2_fs, block, block, &data);
1103 if (ret & BLOCK_ABORT)
1104 break;
1105 }
1106 ret = data.errcode;
1107 if (ret)
1108 return ret;
1109 if (data.num_blocks > 0) {
1110 ret = record_file_blocks(trans, root, objectid, inode,
1111 data.first_block, data.disk_block,
1112 data.num_blocks, 0);
1113 if (ret)
1114 return ret;
1115 data.first_block += data.num_blocks;
1116 }
1117 if (last_block > data.first_block) {
1118 ret = record_file_blocks(trans, root, objectid, inode,
1119 data.first_block, 0, last_block -
1120 data.first_block, 0);
1121 if (ret)
1122 return ret;
1123 }
1124 fail:
1125 return 0;
1126 }
1127 /*
1128 * Create the ext2fs image file.
1129 */
1130 static int create_ext2_image(struct btrfs_root *root, ext2_filsys ext2_fs,
1131 const char *name)
1132 {
1133 int ret;
1134 struct btrfs_key key;
1135 struct btrfs_key location;
1136 struct btrfs_path path;
1137 struct btrfs_inode_item btrfs_inode;
1138 struct extent_buffer *leaf;
1139 struct btrfs_fs_info *fs_info = root->fs_info;
1140 struct btrfs_root *extent_root = fs_info->extent_root;
1141 struct btrfs_trans_handle *trans;
1142 struct btrfs_extent_ref *ref_item;
1143 u64 bytenr;
1144 u64 num_bytes;
1145 u64 ref_root;
1146 u64 ref_owner;
1147 u64 objectid;
1148 u64 new_block;
1149 u64 last_byte;
1150 u64 first_free;
1151 u64 total_bytes;
1152 u32 sectorsize = root->sectorsize;
1153 int slot;
1154 int file_extent;
1155
1156 total_bytes = btrfs_super_total_bytes(&fs_info->super_copy);
1157 first_free = BTRFS_SUPER_INFO_OFFSET + sectorsize * 2 - 1;
1158 first_free &= ~((u64)sectorsize - 1);
1159
1160 memset(&btrfs_inode, 0, sizeof(btrfs_inode));
1161 btrfs_set_stack_inode_generation(&btrfs_inode, 1);
1162 btrfs_set_stack_inode_size(&btrfs_inode, total_bytes);
1163 btrfs_set_stack_inode_nlink(&btrfs_inode, 1);
1164 btrfs_set_stack_inode_nblocks(&btrfs_inode, 0);
1165 btrfs_set_stack_inode_mode(&btrfs_inode, S_IFREG | 0400);
1166 btrfs_set_stack_inode_flags(&btrfs_inode, BTRFS_INODE_NODATASUM |
1167 BTRFS_INODE_READONLY);
1168 btrfs_init_path(&path);
1169 trans = btrfs_start_transaction(root, 1);
1170 BUG_ON(!trans);
1171
1172 objectid = btrfs_root_dirid(&root->root_item);
1173 ret = btrfs_find_free_objectid(trans, root, objectid, &objectid);
1174 if (ret)
1175 goto fail;
1176
1177 /*
1178 * copy the first a few blocks to new positions. the relocation is
1179 * reuqired for block 0 and default btrfs super block.
1180 */
1181 for (last_byte = 0; last_byte < first_free; last_byte += sectorsize) {
1182 ret = ext2_alloc_block(ext2_fs, 0, &new_block);
1183 if (ret)
1184 goto fail;
1185 new_block *= sectorsize;
1186 ret = copy_disk_extent(root, new_block, last_byte, sectorsize);
1187 if (ret)
1188 goto fail;
1189 ret = record_file_extent(trans, root, objectid,
1190 &btrfs_inode, last_byte,
1191 new_block, sectorsize, 0);
1192 if (ret)
1193 goto fail;
1194 }
1195 again:
1196 if (trans->blocks_used >= 8192) {
1197 ret = btrfs_commit_transaction(trans, root);
1198 BUG_ON(ret);
1199 trans = btrfs_start_transaction(root, 1);
1200 BUG_ON(!trans);
1201 }
1202
1203 key.objectid = last_byte;
1204 key.offset = 0;
1205 btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
1206 btrfs_release_path(extent_root, &path);
1207 ret = btrfs_search_slot(trans, fs_info->extent_root,
1208 &key, &path, 0, 0);
1209 if (ret < 0)
1210 goto fail;
1211
1212 leaf = path.nodes[0];
1213 slot = path.slots[0];
1214 while(1) {
1215 if (slot >= btrfs_header_nritems(leaf)) {
1216 ret = btrfs_next_leaf(extent_root, &path);
1217 if (ret < 0)
1218 goto fail;
1219 if (ret > 0)
1220 break;
1221 leaf = path.nodes[0];
1222 slot = path.slots[0];
1223 }
1224 btrfs_item_key_to_cpu(leaf, &key, slot);
1225 if (last_byte > key.objectid ||
1226 key.type != BTRFS_EXTENT_ITEM_KEY) {
1227 slot++;
1228 continue;
1229 }
1230 /*
1231 * Check backref to distinguish extent items for normal
1232 * files (files that correspond to files in Ext2fs) from
1233 * extent items for ctree blocks.
1234 */
1235 bytenr = key.objectid;
1236 num_bytes = key.offset;
1237 file_extent = 0;
1238 while (1) {
1239 if (slot >= btrfs_header_nritems(leaf)) {
1240 ret = btrfs_next_leaf(extent_root, &path);
1241 if (ret > 0)
1242 break;
1243 if (ret < 0)
1244 goto fail;
1245 leaf = path.nodes[0];
1246 slot = path.slots[0];
1247 }
1248 btrfs_item_key_to_cpu(leaf, &key, slot);
1249 if (key.objectid != bytenr)
1250 break;
1251 if (key.type != BTRFS_EXTENT_REF_KEY) {
1252 slot++;
1253 continue;
1254 }
1255 ref_item = btrfs_item_ptr(leaf, slot,
1256 struct btrfs_extent_ref);
1257 ref_root = btrfs_ref_root(leaf, ref_item);
1258 ref_owner = btrfs_ref_objectid(leaf, ref_item);
1259 if ((ref_root == BTRFS_FS_TREE_OBJECTID) &&
1260 (ref_owner >= BTRFS_FIRST_FREE_OBJECTID)) {
1261 file_extent = 1;
1262 break;
1263 }
1264 slot++;
1265 }
1266 if (!file_extent)
1267 continue;
1268
1269 if (bytenr > last_byte) {
1270 ret = create_image_file_range(trans, root, objectid,
1271 &btrfs_inode, last_byte,
1272 bytenr, ext2_fs);
1273 if (ret)
1274 goto fail;
1275 }
1276 ret = record_file_extent(trans, root, objectid, &btrfs_inode,
1277 bytenr, bytenr, num_bytes, 0);
1278 if (ret)
1279 goto fail;
1280 last_byte = bytenr + num_bytes;
1281 goto again;
1282 }
1283 if (total_bytes > last_byte) {
1284 ret = create_image_file_range(trans, root, objectid,
1285 &btrfs_inode, last_byte,
1286 total_bytes, ext2_fs);
1287 if (ret)
1288 goto fail;
1289 }
1290 /*
1291 * otime isn't used currently, so we can store some data in it.
1292 * These data are used by do_rollback to check whether the image
1293 * file has been modified.
1294 */
1295 btrfs_set_stack_timespec_sec(&btrfs_inode.otime, trans->transid);
1296 btrfs_set_stack_timespec_nsec(&btrfs_inode.otime,
1297 total_bytes / sectorsize);
1298 ret = btrfs_insert_inode(trans, root, objectid, &btrfs_inode);
1299 if (ret)
1300 goto fail;
1301
1302 location.objectid = objectid;
1303 location.offset = 0;
1304 btrfs_set_key_type(&location, BTRFS_INODE_ITEM_KEY);
1305 ret = btrfs_insert_dir_item(trans, root, name, strlen(name),
1306 btrfs_root_dirid(&root->root_item),
1307 &location, EXT2_FT_REG_FILE);
1308 if (ret)
1309 goto fail;
1310 ret = btrfs_insert_inode_ref(trans, root, name, strlen(name),
1311 objectid,
1312 btrfs_root_dirid(&root->root_item));
1313 if (ret)
1314 goto fail;
1315 ret = btrfs_commit_transaction(trans, root);
1316 BUG_ON(ret);
1317 fail:
1318 btrfs_release_path(root, &path);
1319 return ret;
1320 }
1321 struct btrfs_root *create_subvol(struct btrfs_root *root, const char *name)
1322 {
1323 int ret;
1324 u64 objectid;
1325 struct btrfs_key location;
1326 struct btrfs_root_item root_item;
1327 struct btrfs_trans_handle *trans;
1328 struct btrfs_fs_info *fs_info = root->fs_info;
1329 struct btrfs_root *tree_root = fs_info->tree_root;
1330 struct btrfs_root *new_root;
1331 struct extent_buffer *tmp;
1332
1333 trans = btrfs_start_transaction(root, 1);
1334 BUG_ON(!trans);
1335
1336 objectid = btrfs_super_root_dir(&fs_info->super_copy);
1337 ret = btrfs_find_free_objectid(trans, root, objectid, &objectid);
1338 if (ret)
1339 goto fail;
1340 ret = btrfs_copy_root(trans, root, root->node, &tmp, objectid);
1341 if (ret)
1342 goto fail;
1343 memcpy(&root_item, &root->root_item, sizeof(root_item));
1344 btrfs_set_root_bytenr(&root_item, tmp->start);
1345 btrfs_set_root_level(&root_item, btrfs_header_level(tmp));
1346 free_extent_buffer(tmp);
1347
1348 location.objectid = objectid;
1349 location.offset = 1;
1350 btrfs_set_key_type(&location, BTRFS_ROOT_ITEM_KEY);
1351 ret = btrfs_insert_root(trans, root->fs_info->tree_root,
1352 &location, &root_item);
1353 if (ret)
1354 goto fail;
1355 location.offset = (u64)-1;
1356 ret = btrfs_insert_dir_item(trans, tree_root, name, strlen(name),
1357 btrfs_super_root_dir(&fs_info->super_copy),
1358 &location, BTRFS_FT_DIR);
1359 if (ret)
1360 goto fail;
1361 ret = btrfs_insert_inode_ref(trans, tree_root, name, strlen(name),
1362 objectid,
1363 btrfs_super_root_dir(&fs_info->super_copy));
1364 if (ret)
1365 goto fail;
1366 ret = btrfs_commit_transaction(trans, root);
1367 BUG_ON(ret);
1368 new_root = btrfs_read_fs_root(fs_info, &location);
1369 if (!new_root || IS_ERR(new_root))
1370 goto fail;
1371 trans = btrfs_start_transaction(new_root, 1);
1372 BUG_ON(!trans);
1373 ret = btrfs_make_root_dir(trans, new_root, BTRFS_FIRST_FREE_OBJECTID);
1374 if (ret)
1375 goto fail;
1376 ret = btrfs_commit_transaction(trans, new_root);
1377 BUG_ON(ret);
1378 return new_root;
1379 fail:
1380 return NULL;
1381 }
1382 /*
1383 * Fixup block accounting. The initial block accounting created by
1384 * make_block_groups isn't accuracy in this case.
1385 */
1386 static int fixup_block_accounting(struct btrfs_trans_handle *trans,
1387 struct btrfs_root *root)
1388 {
1389 int ret;
1390 int slot;
1391 u64 start = 0;
1392 u64 bytes_used = 0;
1393 struct btrfs_path path;
1394 struct btrfs_key key;
1395 struct extent_buffer *leaf;
1396 struct btrfs_block_group_cache *cache;
1397 struct btrfs_fs_info *fs_info = root->fs_info;
1398
1399 while(1) {
1400 cache = btrfs_lookup_block_group(fs_info, start);
1401 if (!cache)
1402 break;
1403 start = cache->key.objectid + cache->key.offset;
1404 btrfs_set_block_group_used(&cache->item, 0);
1405 }
1406
1407 btrfs_init_path(&path);
1408 key.offset = 0;
1409 key.objectid = 0;
1410 btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
1411 ret = btrfs_search_slot(trans, root->fs_info->extent_root,
1412 &key, &path, 0, 0);
1413 if (ret < 0)
1414 return ret;
1415 while(1) {
1416 leaf = path.nodes[0];
1417 slot = path.slots[0];
1418 if (slot >= btrfs_header_nritems(leaf)) {
1419 ret = btrfs_next_leaf(root, &path);
1420 if (ret < 0)
1421 return ret;
1422 if (ret > 0)
1423 break;
1424 leaf = path.nodes[0];
1425 slot = path.slots[0];
1426 }
1427 btrfs_item_key_to_cpu(leaf, &key, slot);
1428 if (key.type == BTRFS_EXTENT_ITEM_KEY) {
1429 bytes_used += key.offset;
1430 ret = btrfs_update_block_group(trans, root,
1431 key.objectid, key.offset, 1, 0, 1);
1432 BUG_ON(ret);
1433 }
1434 path.slots[0]++;
1435 }
1436 btrfs_set_super_bytes_used(&root->fs_info->super_copy, bytes_used);
1437 btrfs_release_path(root, &path);
1438 return 0;
1439 }
1440
1441 static int init_btrfs(struct btrfs_root *root)
1442 {
1443 int ret;
1444 struct btrfs_key location;
1445 struct btrfs_trans_handle *trans;
1446 struct btrfs_fs_info *fs_info = root->fs_info;
1447
1448 trans = btrfs_start_transaction(root, 1);
1449 BUG_ON(!trans);
1450 ret = btrfs_make_block_groups(trans, root);
1451 if (ret)
1452 goto err;
1453 ret = fixup_block_accounting(trans, root);
1454 if (ret)
1455 goto err;
1456 ret = btrfs_make_root_dir(trans, fs_info->tree_root,
1457 BTRFS_ROOT_TREE_DIR_OBJECTID);
1458 if (ret)
1459 goto err;
1460 memcpy(&location, &root->root_key, sizeof(location));
1461 location.offset = (u64)-1;
1462 ret = btrfs_insert_dir_item(trans, fs_info->tree_root, "default", 7,
1463 btrfs_super_root_dir(&fs_info->super_copy),
1464 &location, BTRFS_FT_DIR);
1465 if (ret)
1466 goto err;
1467 ret = btrfs_insert_inode_ref(trans, fs_info->tree_root, "default", 7,
1468 location.objectid,
1469 btrfs_super_root_dir(&fs_info->super_copy));
1470 if (ret)
1471 goto err;
1472 btrfs_set_root_dirid(&fs_info->fs_root->root_item,
1473 BTRFS_FIRST_FREE_OBJECTID);
1474 ret = btrfs_commit_transaction(trans, root);
1475 BUG_ON(ret);
1476 err:
1477 return ret;
1478 }
1479 /*
1480 * Migrate super block to it's default position and zero 0 ~ 16k
1481 */
1482 static int migrate_super_block(int fd, u64 old_bytenr, u32 sectorsize)
1483 {
1484 int ret;
1485 char *buf;
1486 u64 bytenr;
1487 u32 crc = ~(u32)0;
1488 u32 len = 512 - BTRFS_CSUM_SIZE;
1489 struct btrfs_super_block *super;
1490
1491 ret = fsync(fd);
1492 if (ret)
1493 goto fail;
1494
1495 BUG_ON(sectorsize < sizeof(super));
1496 buf = malloc(sectorsize);
1497 if (!buf)
1498 return -ENOMEM;
1499 ret = pread(fd, buf, sectorsize, old_bytenr);
1500 if (ret != sectorsize)
1501 goto fail;
1502
1503 super = (struct btrfs_super_block *)buf;
1504 BUG_ON(btrfs_super_bytenr(super) != old_bytenr);
1505 btrfs_set_super_bytenr(super, BTRFS_SUPER_INFO_OFFSET);
1506
1507 crc = crc32c(crc, buf + BTRFS_CSUM_SIZE, len);
1508 crc = ~cpu_to_le32(crc);
1509 memcpy(super->csum, &crc, BTRFS_CRC32_SIZE);
1510
1511 ret = pwrite(fd, buf, sectorsize, BTRFS_SUPER_INFO_OFFSET);
1512 if (ret < 0)
1513 goto fail;
1514 /* How to handle this case? */
1515 BUG_ON(ret != sectorsize);
1516
1517 ret = fsync(fd);
1518 if (ret)
1519 goto fail;
1520
1521 memset(buf, 0, sectorsize);
1522 for (bytenr = 0; bytenr < BTRFS_SUPER_INFO_OFFSET; ) {
1523 len = BTRFS_SUPER_INFO_OFFSET - bytenr;
1524 if (len > sectorsize)
1525 len = sectorsize;
1526 ret = pwrite(fd, buf, len, bytenr);
1527 if (ret != len) {
1528 fprintf(stderr, "unable to zero fill device\n");
1529 break;
1530 }
1531 bytenr += len;
1532 }
1533 ret = 0;
1534 fsync(fd);
1535 fail:
1536 free(buf);
1537 if (ret > 0)
1538 ret = -1;
1539 return ret;
1540 }
1541
1542 int do_convert(const char *devname, int datacsum, int packing, int noxattr)
1543 {
1544 int i, fd, ret;
1545 u32 blocksize;
1546 u64 blocks[4];
1547 u64 total_bytes;
1548 u64 super_bytenr;
1549 ext2_filsys ext2_fs;
1550 struct btrfs_root *root;
1551 struct btrfs_root *ext2_root;
1552
1553 ret = open_ext2fs(devname, &ext2_fs);
1554 if (ret) {
1555 fprintf(stderr, "unable to open the Ext2fs\n");
1556 goto fail;
1557 }
1558 blocksize = ext2_fs->blocksize;
1559 total_bytes = (u64)ext2_fs->super->s_blocks_count * blocksize;
1560 if (blocksize < 4096) {
1561 fprintf(stderr, "block size is too small\n");
1562 goto fail;
1563 }
1564 if (!(ext2_fs->super->s_feature_incompat &
1565 EXT2_FEATURE_INCOMPAT_FILETYPE)) {
1566 fprintf(stderr, "filetype feature is missing\n");
1567 goto fail;
1568 }
1569 for (i = 0; i < 4; i++) {
1570 ret = ext2_alloc_block(ext2_fs, 0, blocks + i);
1571 if (ret) {
1572 fprintf(stderr, "free space isn't enough\n");
1573 goto fail;
1574 }
1575 blocks[i] *= blocksize;
1576 }
1577 super_bytenr = blocks[0];
1578 fd = open(devname, O_RDWR);
1579 if (fd < 0) {
1580 fprintf(stderr, "unable to open %s\n", devname);
1581 goto fail;
1582 }
1583 ret = make_btrfs(fd, blocks, total_bytes, blocksize,
1584 blocksize, blocksize, blocksize);
1585 if (ret) {
1586 fprintf(stderr, "unable to create initial ctree\n");
1587 goto fail;
1588 }
1589 root = open_ctree_fd(fd, super_bytenr);
1590 if (!root) {
1591 fprintf(stderr, "unable to open ctree\n");
1592 goto fail;
1593 }
1594 fd = dup(fd);
1595 if (fd < 0) {
1596 fprintf(stderr, "unable to duplicate file descriptor\n");
1597 goto fail;
1598 }
1599 root->fs_info->priv_data = ext2_fs;
1600 root->fs_info->extent_ops = &extent_ops;
1601 ret = init_btrfs(root);
1602 if (ret) {
1603 fprintf(stderr, "unable to setup the root tree\n");
1604 goto fail;
1605 }
1606 ext2_root = create_subvol(root, "ext2_saved");
1607 if (!ext2_root) {
1608 fprintf(stderr, "unable to create subvol\n");
1609 goto fail;
1610 }
1611 printf("creating btrfs metadata.\n");
1612 ret = copy_inodes(root, ext2_fs, datacsum, packing, noxattr);
1613 if (ret) {
1614 fprintf(stderr, "error during copy_inodes %d\n", ret);
1615 goto fail;
1616 }
1617 printf("creating ext2fs image file.\n");
1618 ret = create_ext2_image(ext2_root, ext2_fs, "image");
1619 if (ret) {
1620 fprintf(stderr, "error during create_ext2_image %d\n", ret);
1621 goto fail;
1622 }
1623 btrfs_free_fs_root(ext2_root->fs_info, ext2_root);
1624 ret = close_ctree(root);
1625 if (ret) {
1626 fprintf(stderr, "error during close_ctree %d\n", ret);
1627 goto fail;
1628 }
1629 close_ext2fs(ext2_fs);
1630
1631 /* finally migrate super block to its default postion */
1632 ret = migrate_super_block(fd, super_bytenr, blocksize);
1633 if (ret) {
1634 fprintf(stderr, "unable to migrate super block\n");
1635 goto fail;
1636 }
1637 close(fd);
1638 printf("conversion complete.\n");
1639 return 0;
1640 fail:
1641 fprintf(stderr, "conversion aborted.\n");
1642 return -1;
1643 }
1644
1645 int do_rollback(const char *devname, int force)
1646 {
1647 int fd;
1648 int ret;
1649 int modified = 0;
1650 struct btrfs_root *root;
1651 struct btrfs_root *ext2_root;
1652 struct btrfs_dir_item *dir;
1653 struct btrfs_inode_item *inode;
1654 struct btrfs_file_extent_item *fi;
1655 struct btrfs_inode_timespec *tspec;
1656 struct extent_buffer *leaf;
1657 struct btrfs_key key;
1658 struct btrfs_path path;
1659 char *buf;
1660 char *name;
1661 u64 bytenr;
1662 u64 num_bytes;
1663 u64 root_dir;
1664 u64 objectid;
1665 u64 offset;
1666 u64 first_free;
1667 u64 last_trans;
1668 u64 total_bytes;
1669
1670 fd = open(devname, O_RDWR);
1671 if (fd < 0) {
1672 fprintf(stderr, "unable to open %s\n", devname);
1673 goto fail;
1674 }
1675 root = open_ctree_fd(fd, 0);
1676 if (!root) {
1677 fprintf(stderr, "unable to open ctree\n");
1678 goto fail;
1679 }
1680 fd = dup(fd);
1681 if (fd < 0) {
1682 fprintf(stderr, "unable to duplicate file descriptor\n");
1683 goto fail;
1684 }
1685
1686 first_free = BTRFS_SUPER_INFO_OFFSET + root->sectorsize * 2 - 1;
1687 first_free &= ~((u64)root->sectorsize - 1);
1688 buf = malloc(first_free);
1689 if (!buf) {
1690 fprintf(stderr, "unable to allocate memory\n");
1691 goto fail;
1692 }
1693
1694 btrfs_init_path(&path);
1695 name = "ext2_saved";
1696 root_dir = btrfs_super_root_dir(&root->fs_info->super_copy);
1697 dir = btrfs_lookup_dir_item(NULL, root->fs_info->tree_root, &path,
1698 root_dir, name, strlen(name), 0);
1699 if (!dir || IS_ERR(dir)) {
1700 fprintf(stderr, "unable to find subvol %s\n", name);
1701 goto fail;
1702 }
1703 leaf = path.nodes[0];
1704 btrfs_dir_item_key_to_cpu(leaf, dir, &key);
1705 btrfs_release_path(root->fs_info->tree_root, &path);
1706
1707 ext2_root = btrfs_read_fs_root(root->fs_info, &key);
1708 if (!ext2_root || IS_ERR(ext2_root)) {
1709 fprintf(stderr, "unable to open subvol %s\n", name);
1710 goto fail;
1711 }
1712
1713 name = "image";
1714 root_dir = btrfs_root_dirid(&root->root_item);
1715 dir = btrfs_lookup_dir_item(NULL, ext2_root, &path,
1716 root_dir, name, strlen(name), 0);
1717 if (!dir || IS_ERR(dir)) {
1718 fprintf(stderr, "unable to find file %s\n", name);
1719 goto fail;
1720 }
1721 leaf = path.nodes[0];
1722 btrfs_dir_item_key_to_cpu(leaf, dir, &key);
1723 btrfs_release_path(ext2_root, &path);
1724
1725 objectid = key.objectid;
1726
1727 ret = btrfs_lookup_inode(NULL, ext2_root, &path, &key, 0);
1728 if (ret) {
1729 fprintf(stderr, "unable to find inode item\n");
1730 goto fail;
1731 }
1732 leaf = path.nodes[0];
1733 inode = btrfs_item_ptr(leaf, path.slots[0], struct btrfs_inode_item);
1734 tspec = btrfs_inode_otime(inode);
1735 /*
1736 * get image file size and transaction id stored in 'otime' field.
1737 * see comments in create_ext2_image.
1738 */
1739 last_trans = btrfs_timespec_sec(leaf, tspec);
1740 total_bytes = btrfs_timespec_nsec(leaf, tspec);
1741 total_bytes *= root->sectorsize;
1742 btrfs_release_path(ext2_root, &path);
1743 if (total_bytes < first_free ||
1744 total_bytes != btrfs_inode_size(leaf, inode)) {
1745 fprintf(stderr, "image file size mismatch\n");
1746 goto fail;
1747 }
1748
1749 key.objectid = objectid;
1750 key.offset = 0;
1751 btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
1752 ret = btrfs_search_slot(NULL, ext2_root, &key, &path, 0, 0);
1753 if (ret != 0) {
1754 fprintf(stderr, "unable to find first file extent\n");
1755 btrfs_release_path(ext2_root, &path);
1756 goto fail;
1757 }
1758 for (offset = 0; offset < total_bytes; ) {
1759 leaf = path.nodes[0];
1760 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
1761 ret = btrfs_next_leaf(root, &path);
1762 if (ret != 0)
1763 break;
1764 continue;
1765 }
1766
1767 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1768 if (key.objectid != objectid || key.offset != offset ||
1769 btrfs_key_type(&key) != BTRFS_EXTENT_DATA_KEY)
1770 break;
1771
1772 fi = btrfs_item_ptr(leaf, path.slots[0],
1773 struct btrfs_file_extent_item);
1774 if (btrfs_file_extent_generation(leaf, fi) > last_trans) {
1775 modified = 1;
1776 break;
1777 }
1778 if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG)
1779 break;
1780
1781 if (offset >= first_free)
1782 goto next;
1783
1784 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
1785 if (bytenr == 0)
1786 break;
1787 bytenr += btrfs_file_extent_offset(leaf, fi);
1788 num_bytes = btrfs_file_extent_num_bytes(leaf, fi);
1789 if (num_bytes > first_free - offset)
1790 num_bytes = first_free - offset;
1791
1792 ret = pread(fd, buf + offset, num_bytes, bytenr);
1793 if (ret != num_bytes) {
1794 fprintf(stderr, "unable to read required data\n");
1795 btrfs_release_path(ext2_root, &path);
1796 goto fail;
1797 }
1798 next:
1799 offset += btrfs_file_extent_num_bytes(leaf, fi);
1800 path.slots[0]++;
1801 }
1802 btrfs_release_path(ext2_root, &path);
1803
1804 if (modified) {
1805 fprintf(stderr, "image file has been modified\n");
1806 goto fail;
1807 }
1808 if (offset < total_bytes) {
1809 fprintf(stderr, "unable to check all file extents\n");
1810 goto fail;
1811 }
1812
1813 btrfs_free_fs_root(ext2_root->fs_info, ext2_root);
1814 ret = close_ctree(root);
1815 if (ret) {
1816 fprintf(stderr, "error during close_ctree %d\n", ret);
1817 goto fail;
1818 }
1819
1820 ret = pwrite(fd, buf, first_free, 0);
1821 if (ret < 0) {
1822 fprintf(stderr, "error during pwrite %d\n", ret);
1823 goto fail;
1824 }
1825 /* How to handle this case? */
1826 BUG_ON(ret != first_free);
1827 ret = fsync(fd);
1828 if (ret) {
1829 fprintf(stderr, "error during fsync %d\n", ret);
1830 goto fail;
1831 }
1832 close(fd);
1833 free(buf);
1834 printf("rollback complete.\n");
1835 return 0;
1836 fail:
1837 fprintf(stderr, "rollback aborted.\n");
1838 return -1;
1839 }
1840 static void print_usage(void)
1841 {
1842 printf("usage: btrfs-convert [-d] [-i] [-n] [-r] device\n");
1843 printf("\t-d disable data checksum\n");
1844 printf("\t-i ignore xattrs and ACLs\n");
1845 printf("\t-n disable packing of small files\n");
1846 printf("\t-r roll back to ext2fs\n");
1847 exit(1);
1848 }
1849
1850 int main(int argc, char *argv[])
1851 {
1852 int ret;
1853 int packing = 1;
1854 int noxattr = 0;
1855 int datacsum = 1;
1856 int rollback = 0;
1857 char *file;
1858 while(1) {
1859 int c = getopt(argc, argv, "dinr");
1860 if (c < 0)
1861 break;
1862 switch(c) {
1863 case 'd':
1864 datacsum = 0;
1865 break;
1866 case 'i':
1867 noxattr = 1;
1868 break;
1869 case 'n':
1870 packing = 0;
1871 break;
1872 case 'r':
1873 rollback = 1;
1874 break;
1875 default:
1876 print_usage();
1877 }
1878 }
1879 argc = argc - optind;
1880 if (argc == 1) {
1881 file = argv[optind];
1882 } else {
1883 print_usage();
1884 }
1885 if (rollback) {
1886 ret = do_rollback(file, 0);
1887 } else {
1888 ret = do_convert(file, datacsum, packing, noxattr);
1889 }
1890 return ret;
1891 }
(deprecated) Btrfs progs developments and patch integration