Merge branch 'for-chris' of git://github.com/idryomov/btrfs-progs into 0.20
[platform/upstream/btrfs-progs.git] / btrfs-map-logical.c
1 /*
2  * Copyright (C) 2009 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 #define _GNU_SOURCE 1
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <fcntl.h>
24 #include <unistd.h>
25 #include <getopt.h>
26 #include "kerncompat.h"
27 #include "ctree.h"
28 #include "volumes.h"
29 #include "disk-io.h"
30 #include "print-tree.h"
31 #include "transaction.h"
32 #include "list.h"
33 #include "version.h"
34
35 /* we write the mirror info to stdout unless they are dumping the data
36  * to stdout
37  * */
38 static FILE *info_file;
39
40 struct extent_buffer *debug_read_block(struct btrfs_root *root, u64 bytenr,
41                                      u32 blocksize, int copy)
42 {
43         int ret;
44         struct extent_buffer *eb;
45         u64 length;
46         struct btrfs_multi_bio *multi = NULL;
47         struct btrfs_device *device;
48         int num_copies;
49         int mirror_num = 1;
50
51         eb = btrfs_find_create_tree_block(root, bytenr, blocksize);
52         if (!eb)
53                 return NULL;
54
55         length = blocksize;
56         while (1) {
57                 ret = btrfs_map_block(&root->fs_info->mapping_tree, READ,
58                                       eb->start, &length, &multi, mirror_num);
59                 BUG_ON(ret);
60                 device = multi->stripes[0].dev;
61                 eb->fd = device->fd;
62                 device->total_ios++;
63                 eb->dev_bytenr = multi->stripes[0].physical;
64
65                 fprintf(info_file, "mirror %d logical %Lu physical %Lu "
66                         "device %s\n", mirror_num, (unsigned long long)bytenr,
67                         (unsigned long long)eb->dev_bytenr, device->name);
68                 kfree(multi);
69
70                 if (!copy || mirror_num == copy)
71                         ret = read_extent_from_disk(eb);
72
73                 num_copies = btrfs_num_copies(&root->fs_info->mapping_tree,
74                                               eb->start, eb->len);
75                 if (num_copies == 1)
76                         break;
77
78                 mirror_num++;
79                 if (mirror_num > num_copies)
80                         break;
81         }
82         return eb;
83 }
84
85 static void print_usage(void)
86 {
87         fprintf(stderr, "usage: btrfs-map-logical [options] device\n");
88         fprintf(stderr, "\t-l Logical extent to map\n");
89         fprintf(stderr, "\t-c Copy of the extent to read (usually 1 or 2)\n");
90         fprintf(stderr, "\t-o Output file to hold the extent\n");
91         fprintf(stderr, "\t-b Number of bytes to read\n");
92         exit(1);
93 }
94
95 static struct option long_options[] = {
96         /* { "byte-count", 1, NULL, 'b' }, */
97         { "logical", 1, NULL, 'l' },
98         { "copy", 1, NULL, 'c' },
99         { "output", 1, NULL, 'o' },
100         { "bytes", 1, NULL, 'b' },
101         { 0, 0, 0, 0}
102 };
103
104 int main(int ac, char **av)
105 {
106         struct cache_tree root_cache;
107         struct btrfs_root *root;
108         struct extent_buffer *eb;
109         char *dev;
110         char *output_file = NULL;
111         u64 logical = 0;
112         int ret = 0;
113         int option_index = 0;
114         int copy = 0;
115         u64 bytes = 0;
116         int out_fd = 0;
117         int err;
118
119         while(1) {
120                 int c;
121                 c = getopt_long(ac, av, "l:c:o:b:", long_options,
122                                 &option_index);
123                 if (c < 0)
124                         break;
125                 switch(c) {
126                         case 'l':
127                                 logical = atoll(optarg);
128                                 if (logical == 0) {
129                                         fprintf(stderr,
130                                                 "invalid extent number\n");
131                                         print_usage();
132                                 }
133                                 break;
134                         case 'c':
135                                 copy = atoi(optarg);
136                                 if (copy == 0) {
137                                         fprintf(stderr,
138                                                 "invalid copy number\n");
139                                         print_usage();
140                                 }
141                                 break;
142                         case 'b':
143                                 bytes = atoll(optarg);
144                                 if (bytes == 0) {
145                                         fprintf(stderr,
146                                                 "invalid byte count\n");
147                                         print_usage();
148                                 }
149                                 break;
150                         case 'o':
151                                 output_file = strdup(optarg);
152                                 break;
153                         default:
154                                 print_usage();
155                 }
156         }
157         ac = ac - optind;
158         if (ac == 0)
159                 print_usage();
160         if (logical == 0)
161                 print_usage();
162         if (copy < 0)
163                 print_usage();
164
165         dev = av[optind];
166
167         radix_tree_init();
168         cache_tree_init(&root_cache);
169
170         root = open_ctree(dev, 0, 0);
171         if (!root) {
172                 fprintf(stderr, "Open ctree failed\n");
173                 exit(1);
174         }
175
176         info_file = stdout;
177         if (output_file) {
178                 if (strcmp(output_file, "-") == 0) {
179                         out_fd = 1;
180                         info_file = stderr;
181                 } else {
182                         out_fd = open(output_file, O_RDWR | O_CREAT, 0600);
183                         if (out_fd < 0)
184                                 goto close;
185                         err = ftruncate(out_fd, 0);
186                         if (err) {
187                                 close(out_fd);
188                                 goto close;
189                         }
190                         info_file = stdout;
191                 }
192         }
193
194         if (bytes == 0)
195                 bytes = root->sectorsize;
196
197         bytes = (bytes + root->sectorsize - 1) / root->sectorsize;
198         bytes *= root->sectorsize;
199
200         while (bytes > 0) {
201                 eb = debug_read_block(root, logical, root->sectorsize, copy);
202                 if (eb && output_file) {
203                         err = write(out_fd, eb->data, eb->len);
204                         if (err < 0 || err != eb->len) {
205                                 fprintf(stderr, "output file write failed\n");
206                                 goto out_close_fd;
207                         }
208                 }
209                 free_extent_buffer(eb);
210                 logical += root->sectorsize;
211                 bytes -= root->sectorsize;
212         }
213
214 out_close_fd:
215         if (output_file && out_fd != 1)
216                 close(out_fd);
217 close:
218         close_ctree(root);
219         return ret;
220 }