2 * Copyright (C) 2008 Oracle. All rights reserved.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
19 #define _XOPEN_SOURCE 500
24 #include <sys/types.h>
30 #include "kerncompat.h"
34 #include "transaction.h"
39 #define HEADER_MAGIC 0xbd5c25e27295668bULL
40 #define MAX_PENDING_SIZE (256 * 1024)
41 #define BLOCK_SIZE 1024
42 #define BLOCK_MASK (BLOCK_SIZE - 1)
44 #define COMPRESS_NONE 0
45 #define COMPRESS_ZLIB 1
47 struct meta_cluster_item
{
50 } __attribute__ ((__packed__
));
52 struct meta_cluster_header
{
57 } __attribute__ ((__packed__
));
59 /* cluster header + index items + buffers */
61 struct meta_cluster_header header
;
62 struct meta_cluster_item items
[];
63 } __attribute__ ((__packed__
));
65 #define ITEMS_PER_CLUSTER ((BLOCK_SIZE - sizeof(struct meta_cluster)) / \
66 sizeof(struct meta_cluster_item))
69 struct list_head list
;
70 struct list_head ordered
;
77 struct metadump_struct
{
78 struct btrfs_root
*root
;
81 struct meta_cluster
*cluster
;
85 pthread_mutex_t mutex
;
88 struct list_head list
;
89 struct list_head ordered
;
100 struct mdrestore_struct
{
106 pthread_mutex_t mutex
;
109 struct list_head list
;
116 static void csum_block(u8
*buf
, size_t len
)
118 char result
[BTRFS_CRC32_SIZE
];
120 crc
= crc32c(crc
, buf
+ BTRFS_CSUM_SIZE
, len
- BTRFS_CSUM_SIZE
);
121 btrfs_csum_final(crc
, result
);
122 memcpy(buf
, result
, BTRFS_CRC32_SIZE
);
126 * zero inline extents and csum items
128 static void zero_items(u8
*dst
, struct extent_buffer
*src
)
130 struct btrfs_file_extent_item
*fi
;
131 struct btrfs_item
*item
;
132 struct btrfs_key key
;
133 u32 nritems
= btrfs_header_nritems(src
);
138 for (i
= 0; i
< nritems
; i
++) {
139 item
= btrfs_item_nr(src
, i
);
140 btrfs_item_key_to_cpu(src
, &key
, i
);
141 if (key
.type
== BTRFS_CSUM_ITEM_KEY
) {
142 size
= btrfs_item_size_nr(src
, i
);
143 memset(dst
+ btrfs_leaf_data(src
) +
144 btrfs_item_offset_nr(src
, i
), 0, size
);
147 if (key
.type
!= BTRFS_EXTENT_DATA_KEY
)
150 fi
= btrfs_item_ptr(src
, i
, struct btrfs_file_extent_item
);
151 extent_type
= btrfs_file_extent_type(src
, fi
);
152 if (extent_type
!= BTRFS_FILE_EXTENT_INLINE
)
155 ptr
= btrfs_file_extent_inline_start(fi
);
156 size
= btrfs_file_extent_inline_item_len(src
, item
);
157 memset(dst
+ ptr
, 0, size
);
162 * copy buffer and zero useless data in the buffer
164 static void copy_buffer(u8
*dst
, struct extent_buffer
*src
)
170 memcpy(dst
, src
->data
, src
->len
);
171 if (src
->start
== BTRFS_SUPER_INFO_OFFSET
)
174 level
= btrfs_header_level(src
);
175 nritems
= btrfs_header_nritems(src
);
178 size
= sizeof(struct btrfs_header
);
179 memset(dst
+ size
, 0, src
->len
- size
);
180 } else if (level
== 0) {
181 size
= btrfs_leaf_data(src
) +
182 btrfs_item_offset_nr(src
, nritems
- 1) -
183 btrfs_item_nr_offset(nritems
);
184 memset(dst
+ btrfs_item_nr_offset(nritems
), 0, size
);
185 zero_items(dst
, src
);
187 size
= offsetof(struct btrfs_node
, ptrs
) +
188 sizeof(struct btrfs_key_ptr
) * nritems
;
189 memset(dst
+ size
, 0, src
->len
- size
);
191 csum_block(dst
, src
->len
);
194 static void *dump_worker(void *data
)
196 struct metadump_struct
*md
= (struct metadump_struct
*)data
;
197 struct async_work
*async
;
201 pthread_mutex_lock(&md
->mutex
);
202 while (list_empty(&md
->list
)) {
204 pthread_mutex_unlock(&md
->mutex
);
207 pthread_cond_wait(&md
->cond
, &md
->mutex
);
209 async
= list_entry(md
->list
.next
, struct async_work
, list
);
210 list_del_init(&async
->list
);
211 pthread_mutex_unlock(&md
->mutex
);
213 if (md
->compress_level
> 0) {
214 u8
*orig
= async
->buffer
;
216 async
->bufsize
= compressBound(async
->size
);
217 async
->buffer
= malloc(async
->bufsize
);
219 ret
= compress2(async
->buffer
,
220 (unsigned long *)&async
->bufsize
,
221 orig
, async
->size
, md
->compress_level
);
227 pthread_mutex_lock(&md
->mutex
);
229 pthread_mutex_unlock(&md
->mutex
);
235 static void meta_cluster_init(struct metadump_struct
*md
, u64 start
)
237 struct meta_cluster_header
*header
;
241 header
= &md
->cluster
->header
;
242 header
->magic
= cpu_to_le64(HEADER_MAGIC
);
243 header
->bytenr
= cpu_to_le64(start
);
244 header
->nritems
= cpu_to_le32(0);
245 header
->compress
= md
->compress_level
> 0 ?
246 COMPRESS_ZLIB
: COMPRESS_NONE
;
249 static int metadump_init(struct metadump_struct
*md
, struct btrfs_root
*root
,
250 FILE *out
, int num_threads
, int compress_level
)
254 memset(md
, 0, sizeof(*md
));
255 pthread_cond_init(&md
->cond
, NULL
);
256 pthread_mutex_init(&md
->mutex
, NULL
);
257 INIT_LIST_HEAD(&md
->list
);
258 INIT_LIST_HEAD(&md
->ordered
);
261 md
->pending_start
= (u64
)-1;
262 md
->compress_level
= compress_level
;
263 md
->cluster
= calloc(1, BLOCK_SIZE
);
267 meta_cluster_init(md
, 0);
271 md
->num_threads
= num_threads
;
272 md
->threads
= calloc(num_threads
, sizeof(pthread_t
));
275 for (i
= 0; i
< num_threads
; i
++) {
276 ret
= pthread_create(md
->threads
+ i
, NULL
, dump_worker
, md
);
283 static void metadump_destroy(struct metadump_struct
*md
)
286 pthread_mutex_lock(&md
->mutex
);
288 pthread_cond_broadcast(&md
->cond
);
289 pthread_mutex_unlock(&md
->mutex
);
291 for (i
= 0; i
< md
->num_threads
; i
++)
292 pthread_join(md
->threads
[i
], NULL
);
294 pthread_cond_destroy(&md
->cond
);
295 pthread_mutex_destroy(&md
->mutex
);
300 static int write_zero(FILE *out
, size_t size
)
302 static char zero
[BLOCK_SIZE
];
303 return fwrite(zero
, size
, 1, out
);
306 static int write_buffers(struct metadump_struct
*md
, u64
*next
)
308 struct meta_cluster_header
*header
= &md
->cluster
->header
;
309 struct meta_cluster_item
*item
;
310 struct async_work
*async
;
315 if (list_empty(&md
->ordered
))
318 /* wait until all buffers are compressed */
319 while (md
->num_items
> md
->num_ready
) {
320 struct timespec ts
= {
324 pthread_mutex_unlock(&md
->mutex
);
325 nanosleep(&ts
, NULL
);
326 pthread_mutex_lock(&md
->mutex
);
329 /* setup and write index block */
330 list_for_each_entry(async
, &md
->ordered
, ordered
) {
331 item
= md
->cluster
->items
+ nritems
;
332 item
->bytenr
= cpu_to_le64(async
->start
);
333 item
->size
= cpu_to_le32(async
->bufsize
);
336 header
->nritems
= cpu_to_le32(nritems
);
338 ret
= fwrite(md
->cluster
, BLOCK_SIZE
, 1, md
->out
);
342 bytenr
+= le64_to_cpu(header
->bytenr
) + BLOCK_SIZE
;
343 while (!list_empty(&md
->ordered
)) {
344 async
= list_entry(md
->ordered
.next
, struct async_work
,
346 list_del_init(&async
->ordered
);
348 bytenr
+= async
->bufsize
;
349 ret
= fwrite(async
->buffer
, async
->bufsize
, 1, md
->out
);
356 /* zero unused space in the last block */
357 if (bytenr
& BLOCK_MASK
) {
358 size_t size
= BLOCK_SIZE
- (bytenr
& BLOCK_MASK
);
361 ret
= write_zero(md
->out
, size
);
369 static int flush_pending(struct metadump_struct
*md
, int done
)
371 struct async_work
*async
= NULL
;
372 struct extent_buffer
*eb
;
373 u64 blocksize
= md
->root
->nodesize
;
379 if (md
->pending_size
) {
380 async
= calloc(1, sizeof(*async
));
384 async
->start
= md
->pending_start
;
385 async
->size
= md
->pending_size
;
386 async
->bufsize
= async
->size
;
387 async
->buffer
= malloc(async
->bufsize
);
390 start
= async
->start
;
393 eb
= read_tree_block(md
->root
, start
, blocksize
, 0);
395 copy_buffer(async
->buffer
+ offset
, eb
);
396 free_extent_buffer(eb
);
402 md
->pending_start
= (u64
)-1;
403 md
->pending_size
= 0;
408 pthread_mutex_lock(&md
->mutex
);
410 list_add_tail(&async
->ordered
, &md
->ordered
);
412 if (md
->compress_level
> 0) {
413 list_add_tail(&async
->list
, &md
->list
);
414 pthread_cond_signal(&md
->cond
);
419 if (md
->num_items
>= ITEMS_PER_CLUSTER
|| done
) {
420 ret
= write_buffers(md
, &start
);
422 meta_cluster_init(md
, start
);
424 pthread_mutex_unlock(&md
->mutex
);
428 static int add_metadata(u64 start
, u64 size
, struct metadump_struct
*md
)
431 if (md
->pending_size
+ size
> MAX_PENDING_SIZE
||
432 md
->pending_start
+ md
->pending_size
!= start
) {
433 ret
= flush_pending(md
, 0);
436 md
->pending_start
= start
;
438 readahead_tree_block(md
->root
, start
, size
, 0);
439 md
->pending_size
+= size
;
443 static int create_metadump(const char *input
, FILE *out
, int num_threads
,
446 struct btrfs_root
*root
;
447 struct btrfs_root
*extent_root
;
448 struct btrfs_path
*path
;
449 struct extent_buffer
*leaf
;
450 struct btrfs_extent_ref
*ref_item
;
451 struct btrfs_key key
;
452 struct metadump_struct metadump
;
458 root
= open_ctree(input
, 0, 0);
459 BUG_ON(root
->nodesize
!= root
->leafsize
);
461 ret
= metadump_init(&metadump
, root
, out
, num_threads
,
465 ret
= add_metadata(BTRFS_SUPER_INFO_OFFSET
, 4096, &metadump
);
468 extent_root
= root
->fs_info
->extent_root
;
469 path
= btrfs_alloc_path();
471 bytenr
= BTRFS_SUPER_INFO_OFFSET
+ 4096;
472 key
.objectid
= bytenr
;
473 key
.type
= BTRFS_EXTENT_ITEM_KEY
;
476 ret
= btrfs_search_slot(NULL
, extent_root
, &key
, path
, 0, 0);
480 leaf
= path
->nodes
[0];
481 if (path
->slots
[0] >= btrfs_header_nritems(leaf
)) {
482 ret
= btrfs_next_leaf(extent_root
, path
);
486 leaf
= path
->nodes
[0];
489 btrfs_item_key_to_cpu(leaf
, &key
, path
->slots
[0]);
490 if (key
.objectid
< bytenr
||
491 key
.type
!= BTRFS_EXTENT_ITEM_KEY
) {
496 bytenr
= key
.objectid
;
497 num_bytes
= key
.offset
;
500 if (path
->slots
[0] >= btrfs_header_nritems(leaf
)) {
501 ret
= btrfs_next_leaf(extent_root
, path
);
505 leaf
= path
->nodes
[0];
507 btrfs_item_key_to_cpu(leaf
, &key
, path
->slots
[0]);
508 if (key
.objectid
!= bytenr
)
510 if (key
.type
!= BTRFS_EXTENT_REF_KEY
)
512 ref_item
= btrfs_item_ptr(leaf
, path
->slots
[0],
513 struct btrfs_extent_ref
);
514 ref_objectid
= btrfs_ref_objectid(leaf
, ref_item
);
515 if (ref_objectid
< BTRFS_FIRST_FREE_OBJECTID
) {
516 ret
= add_metadata(bytenr
, num_bytes
,
525 ret
= flush_pending(&metadump
, 1);
528 metadump_destroy(&metadump
);
530 btrfs_free_path(path
);
531 ret
= close_ctree(root
);
535 static void update_super(u8
*buffer
)
537 struct btrfs_super_block
*super
= (struct btrfs_super_block
*)buffer
;
538 struct btrfs_chunk
*chunk
;
539 struct btrfs_disk_key
*key
;
540 u32 sectorsize
= btrfs_super_sectorsize(super
);
541 u64 flags
= btrfs_super_flags(super
);
543 flags
|= BTRFS_SUPER_FLAG_METADUMP
;
544 btrfs_set_super_flags(super
, flags
);
546 key
= (struct btrfs_disk_key
*)(super
->sys_chunk_array
);
547 chunk
= (struct btrfs_chunk
*)(super
->sys_chunk_array
+
548 sizeof(struct btrfs_disk_key
));
550 btrfs_set_disk_key_objectid(key
, BTRFS_FIRST_CHUNK_TREE_OBJECTID
);
551 btrfs_set_disk_key_type(key
, BTRFS_CHUNK_ITEM_KEY
);
552 btrfs_set_disk_key_offset(key
, 0);
554 btrfs_set_stack_chunk_length(chunk
, (u64
)-1);
555 btrfs_set_stack_chunk_owner(chunk
, BTRFS_EXTENT_TREE_OBJECTID
);
556 btrfs_set_stack_chunk_stripe_len(chunk
, 64 * 1024);
557 btrfs_set_stack_chunk_type(chunk
, BTRFS_BLOCK_GROUP_SYSTEM
);
558 btrfs_set_stack_chunk_io_align(chunk
, sectorsize
);
559 btrfs_set_stack_chunk_io_width(chunk
, sectorsize
);
560 btrfs_set_stack_chunk_sector_size(chunk
, sectorsize
);
561 btrfs_set_stack_chunk_num_stripes(chunk
, 1);
562 btrfs_set_stack_chunk_sub_stripes(chunk
, 0);
563 chunk
->stripe
.devid
= super
->dev_item
.devid
;
564 chunk
->stripe
.offset
= cpu_to_le64(0);
565 memcpy(chunk
->stripe
.dev_uuid
, super
->dev_item
.uuid
, BTRFS_UUID_SIZE
);
566 btrfs_set_super_sys_array_size(super
, sizeof(*key
) + sizeof(*chunk
));
567 csum_block(buffer
, 4096);
570 static void *restore_worker(void *data
)
572 struct mdrestore_struct
*mdres
= (struct mdrestore_struct
*)data
;
573 struct async_work
*async
;
580 outfd
= fileno(mdres
->out
);
581 buffer
= malloc(MAX_PENDING_SIZE
* 2);
585 pthread_mutex_lock(&mdres
->mutex
);
586 while (list_empty(&mdres
->list
)) {
588 pthread_mutex_unlock(&mdres
->mutex
);
591 pthread_cond_wait(&mdres
->cond
, &mdres
->mutex
);
593 async
= list_entry(mdres
->list
.next
, struct async_work
, list
);
594 list_del_init(&async
->list
);
595 pthread_mutex_unlock(&mdres
->mutex
);
597 if (mdres
->compress_method
== COMPRESS_ZLIB
) {
598 size
= MAX_PENDING_SIZE
* 2;
599 ret
= uncompress(buffer
, (unsigned long *)&size
,
600 async
->buffer
, async
->bufsize
);
604 outbuf
= async
->buffer
;
605 size
= async
->bufsize
;
608 if (async
->start
== BTRFS_SUPER_INFO_OFFSET
)
609 update_super(outbuf
);
611 ret
= pwrite64(outfd
, outbuf
, size
, async
->start
);
614 pthread_mutex_lock(&mdres
->mutex
);
616 pthread_mutex_unlock(&mdres
->mutex
);
626 static int mdresotre_init(struct mdrestore_struct
*mdres
,
627 FILE *in
, FILE *out
, int num_threads
)
631 memset(mdres
, 0, sizeof(*mdres
));
632 pthread_cond_init(&mdres
->cond
, NULL
);
633 pthread_mutex_init(&mdres
->mutex
, NULL
);
634 INIT_LIST_HEAD(&mdres
->list
);
641 mdres
->num_threads
= num_threads
;
642 mdres
->threads
= calloc(num_threads
, sizeof(pthread_t
));
645 for (i
= 0; i
< num_threads
; i
++) {
646 ret
= pthread_create(mdres
->threads
+ i
, NULL
, restore_worker
,
654 static void mdresotre_destroy(struct mdrestore_struct
*mdres
)
657 pthread_mutex_lock(&mdres
->mutex
);
659 pthread_cond_broadcast(&mdres
->cond
);
660 pthread_mutex_unlock(&mdres
->mutex
);
662 for (i
= 0; i
< mdres
->num_threads
; i
++)
663 pthread_join(mdres
->threads
[i
], NULL
);
665 pthread_cond_destroy(&mdres
->cond
);
666 pthread_mutex_destroy(&mdres
->mutex
);
667 free(mdres
->threads
);
670 static int add_cluster(struct meta_cluster
*cluster
,
671 struct mdrestore_struct
*mdres
, u64
*next
)
673 struct meta_cluster_item
*item
;
674 struct meta_cluster_header
*header
= &cluster
->header
;
675 struct async_work
*async
;
680 BUG_ON(mdres
->num_items
);
681 mdres
->compress_method
= header
->compress
;
683 bytenr
= le64_to_cpu(header
->bytenr
) + BLOCK_SIZE
;
684 nritems
= le32_to_cpu(header
->nritems
);
685 for (i
= 0; i
< nritems
; i
++) {
686 item
= &cluster
->items
[i
];
687 async
= calloc(1, sizeof(*async
));
688 async
->start
= le64_to_cpu(item
->bytenr
);
689 async
->bufsize
= le32_to_cpu(item
->size
);
690 async
->buffer
= malloc(async
->bufsize
);
691 ret
= fread(async
->buffer
, async
->bufsize
, 1, mdres
->in
);
693 bytenr
+= async
->bufsize
;
695 pthread_mutex_lock(&mdres
->mutex
);
696 list_add_tail(&async
->list
, &mdres
->list
);
698 pthread_cond_signal(&mdres
->cond
);
699 pthread_mutex_unlock(&mdres
->mutex
);
701 if (bytenr
& BLOCK_MASK
) {
702 char buffer
[BLOCK_MASK
];
703 size_t size
= BLOCK_SIZE
- (bytenr
& BLOCK_MASK
);
706 ret
= fread(buffer
, size
, 1, mdres
->in
);
713 static int wait_for_worker(struct mdrestore_struct
*mdres
)
715 pthread_mutex_lock(&mdres
->mutex
);
716 while (mdres
->num_items
> 0) {
717 struct timespec ts
= {
721 pthread_mutex_unlock(&mdres
->mutex
);
722 nanosleep(&ts
, NULL
);
723 pthread_mutex_lock(&mdres
->mutex
);
725 pthread_mutex_unlock(&mdres
->mutex
);
729 static int restore_metadump(const char *input
, FILE *out
, int num_threads
)
731 struct meta_cluster
*cluster
;
732 struct meta_cluster_header
*header
;
733 struct mdrestore_struct mdrestore
;
738 if (!strcmp(input
, "-")) {
741 in
= fopen(input
, "r");
743 perror("unable to open metadump image");
748 cluster
= malloc(BLOCK_SIZE
);
751 ret
= mdresotre_init(&mdrestore
, in
, out
, num_threads
);
755 ret
= fread(cluster
, BLOCK_SIZE
, 1, in
);
759 header
= &cluster
->header
;
760 if (le64_to_cpu(header
->magic
) != HEADER_MAGIC
||
761 le64_to_cpu(header
->bytenr
) != bytenr
) {
762 fprintf(stderr
, "bad header in metadump image\n");
765 ret
= add_cluster(cluster
, &mdrestore
, &bytenr
);
768 wait_for_worker(&mdrestore
);
771 mdresotre_destroy(&mdrestore
);
778 static void print_usage(void)
780 fprintf(stderr
, "usage: btrfs-image [options] source target\n");
781 fprintf(stderr
, "\t-r \trestore metadump image\n");
782 fprintf(stderr
, "\t-c value\tcompression level (0 ~ 9)\n");
783 fprintf(stderr
, "\t-t value\tnumber of threads (1 ~ 32)\n");
787 int main(int argc
, char *argv
[])
792 int compress_level
= 0;
798 int c
= getopt(argc
, argv
, "rc:t:");
806 num_threads
= atoi(optarg
);
807 if (num_threads
<= 0 || num_threads
> 32)
811 compress_level
= atoi(optarg
);
812 if (compress_level
< 0 || compress_level
> 9)
820 argc
= argc
- optind
;
823 source
= argv
[optind
];
824 target
= argv
[optind
+ 1];
826 if (create
&& !strcmp(target
, "-")) {
829 out
= fopen(target
, "w+");
831 perror("unable to create target file");
836 if (num_threads
== 0 && compress_level
> 0) {
837 num_threads
= sysconf(_SC_NPROCESSORS_ONLN
);
838 if (num_threads
<= 0)
843 ret
= create_metadump(source
, out
, num_threads
,
846 ret
= restore_metadump(source
, out
, 1);