btrfs-progs: docs: update dump-tree
[btrfs-progs-unstable/devel.git] / btrfs-fragments.c
blob9be3dd3351d417f6c0da9055a8638ae764eeed04
1 /*
2 * This program is free software; you can redistribute it and/or
3 * modify it under the terms of the GNU General Public
4 * License v2 as published by the Free Software Foundation.
6 * This program is distributed in the hope that it will be useful,
7 * but WITHOUT ANY WARRANTY; without even the implied warranty of
8 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
9 * General Public License for more details.
11 * You should have received a copy of the GNU General Public
12 * License along with this program; if not, write to the
13 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
14 * Boston, MA 021110-1307, USA.
17 #include <stdio.h>
18 #include <stdlib.h>
19 #include <string.h>
20 #include <sys/ioctl.h>
21 #include <sys/types.h>
22 #include <dirent.h>
23 #include <sys/stat.h>
24 #include <unistd.h>
25 #include <fcntl.h>
26 #include <libgen.h>
27 #include <limits.h>
28 #include <uuid/uuid.h>
29 #include <ctype.h>
31 #include <gd.h>
33 #undef ULONG_MAX
35 #include "kerncompat.h"
36 #include "ctree.h"
37 #include "ioctl.h"
38 #include "utils.h"
40 static int use_color;
41 static void
42 push_im(gdImagePtr im, char *name, char *dir)
44 char fullname[2000];
45 FILE *pngout;
47 if (!im)
48 return;
50 snprintf(fullname, sizeof(fullname), "%s/%s", dir, name);
51 pngout = fopen(fullname, "w");
52 if (!pngout) {
53 printf("unable to create file %s\n", fullname);
54 exit(1);
57 gdImagePng(im, pngout);
59 fclose(pngout);
60 gdImageDestroy(im);
63 static char *
64 chunk_type(u64 flags)
66 switch (flags & (BTRFS_BLOCK_GROUP_SYSTEM | BTRFS_BLOCK_GROUP_DATA |
67 BTRFS_BLOCK_GROUP_METADATA)) {
68 case BTRFS_BLOCK_GROUP_SYSTEM:
69 return "system";
70 case BTRFS_BLOCK_GROUP_DATA:
71 return "data";
72 case BTRFS_BLOCK_GROUP_METADATA:
73 return "metadata";
74 case BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA:
75 return "mixed";
76 default:
77 return "invalid";
81 static void
82 print_bg(FILE *html, char *name, u64 start, u64 len, u64 used, u64 flags,
83 u64 areas)
85 double frag = (double)areas / (len / 4096) * 2;
87 fprintf(html, "<p>%s chunk starts at %lld, size is %s, %.2f%% used, "
88 "%.2f%% fragmented</p>\n", chunk_type(flags), start,
89 pretty_size(len), 100.0 * used / len, 100.0 * frag);
90 fprintf(html, "<img src=\"%s\" border=\"1\" />\n", name);
93 enum tree_colors {
94 COLOR_ROOT = 0,
95 COLOR_EXTENT,
96 COLOR_CHUNK,
97 COLOR_DEV,
98 COLOR_FS,
99 COLOR_CSUM,
100 COLOR_RELOC,
101 COLOR_DATA,
102 COLOR_UNKNOWN,
103 COLOR_MAX
106 static int
107 get_color(struct btrfs_extent_item *item, int len)
109 u64 refs;
110 u64 flags;
111 u8 type;
112 u64 offset;
113 struct btrfs_extent_inline_ref *ref;
115 refs = btrfs_stack_extent_refs(item);
116 flags = btrfs_stack_extent_flags(item);
118 if (flags & BTRFS_EXTENT_FLAG_DATA)
119 return COLOR_DATA;
120 if (refs > 1) {
121 /* this must be an fs tree */
122 return COLOR_FS;
125 ref = (void *)item + sizeof(struct btrfs_extent_item) +
126 sizeof(struct btrfs_tree_block_info);
127 type = btrfs_stack_extent_inline_ref_type(ref);
128 offset = btrfs_stack_extent_inline_ref_offset(ref);
130 switch (type) {
131 case BTRFS_EXTENT_DATA_REF_KEY:
132 return COLOR_DATA;
133 case BTRFS_SHARED_BLOCK_REF_KEY:
134 case BTRFS_SHARED_DATA_REF_KEY:
135 return COLOR_FS;
136 case BTRFS_TREE_BLOCK_REF_KEY:
137 break;
138 default:
139 return COLOR_UNKNOWN;
142 switch (offset) {
143 case BTRFS_ROOT_TREE_OBJECTID:
144 return COLOR_ROOT;
145 case BTRFS_EXTENT_TREE_OBJECTID:
146 return COLOR_EXTENT;
147 case BTRFS_CHUNK_TREE_OBJECTID:
148 return COLOR_CHUNK;
149 case BTRFS_DEV_TREE_OBJECTID:
150 return COLOR_DEV;
151 case BTRFS_FS_TREE_OBJECTID:
152 return COLOR_FS;
153 case BTRFS_CSUM_TREE_OBJECTID:
154 return COLOR_CSUM;
155 case BTRFS_DATA_RELOC_TREE_OBJECTID:
156 return COLOR_RELOC;
159 return COLOR_UNKNOWN;
162 static void
163 init_colors(gdImagePtr im, int *colors)
165 colors[COLOR_ROOT] = gdImageColorAllocate(im, 255, 0, 0);
166 colors[COLOR_EXTENT] = gdImageColorAllocate(im, 0, 255, 0);
167 colors[COLOR_CHUNK] = gdImageColorAllocate(im, 255, 0, 0);
168 colors[COLOR_DEV] = gdImageColorAllocate(im, 255, 0, 0);
169 colors[COLOR_FS] = gdImageColorAllocate(im, 0, 0, 0);
170 colors[COLOR_CSUM] = gdImageColorAllocate(im, 0, 0, 255);
171 colors[COLOR_RELOC] = gdImageColorAllocate(im, 128, 128, 128);
172 colors[COLOR_DATA] = gdImageColorAllocate(im, 100, 0, 0);
173 colors[COLOR_UNKNOWN] = gdImageColorAllocate(im, 50, 50, 50);
177 list_fragments(int fd, u64 flags, char *dir)
179 int ret;
180 struct btrfs_ioctl_search_args args;
181 struct btrfs_ioctl_search_key *sk = &args.key;
182 int i;
183 struct btrfs_ioctl_search_header *sh;
184 unsigned long off = 0;
185 int bgnum = 0;
186 u64 bgstart = 0;
187 u64 bglen = 0;
188 u64 bgend = 0;
189 u64 bgflags = 0;
190 u64 bgused = 0;
191 u64 saved_extent = 0;
192 u64 saved_len = 0;
193 int saved_color = 0;
194 u64 last_end = 0;
195 u64 areas = 0;
196 long px;
197 char name[1000];
198 FILE *html;
199 int colors[COLOR_MAX];
201 gdImagePtr im = NULL;
202 int black = 0;
203 int width = 800;
205 snprintf(name, sizeof(name), "%s/index.html", dir);
206 html = fopen(name, "w");
207 if (!html) {
208 printf("unable to create %s\n", name);
209 exit(1);
212 fprintf(html, "<html><header>\n");
213 fprintf(html, "<title>Btrfs Block Group Allocation Map</title>\n");
214 fprintf(html, "<style type=\"text/css\">\n");
215 fprintf(html, "img {margin-left: 1em; margin-bottom: 2em;}\n");
216 fprintf(html, "</style>\n");
217 fprintf(html, "</header><body>\n");
219 memset(&args, 0, sizeof(args));
221 sk->tree_id = 2;
222 sk->max_type = -1;
223 sk->min_type = 0;
224 sk->max_objectid = (u64)-1;
225 sk->max_offset = (u64)-1;
226 sk->max_transid = (u64)-1;
228 /* just a big number, doesn't matter much */
229 sk->nr_items = 4096;
231 while(1) {
232 ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
233 if (ret < 0) {
234 fprintf(stderr, "ERROR: can't perform the search\n");
235 goto out_close;
237 /* the ioctl returns the number of item it found in nr_items */
238 if (sk->nr_items == 0)
239 break;
241 off = 0;
242 for (i = 0; i < sk->nr_items; i++) {
243 int j;
245 sh = (struct btrfs_ioctl_search_header *)(args.buf +
246 off);
247 off += sizeof(*sh);
248 if (sh->type == BTRFS_BLOCK_GROUP_ITEM_KEY) {
249 struct btrfs_block_group_item *bg;
251 if (im) {
252 push_im(im, name, dir);
253 im = NULL;
255 print_bg(html, name, bgstart, bglen,
256 bgused, bgflags, areas);
259 ++bgnum;
261 bg = (struct btrfs_block_group_item *)
262 (args.buf + off);
263 bgflags = btrfs_block_group_flags(bg);
264 bgused = btrfs_block_group_used(bg);
266 printf("found block group %lld len %lld "
267 "flags %lld\n", sh->objectid,
268 sh->offset, bgflags);
269 if (!(bgflags & flags)) {
270 /* skip this block group */
271 sk->min_objectid = sh->objectid +
272 sh->offset;
273 sk->min_type = 0;
274 sk->min_offset = 0;
275 break;
277 im = gdImageCreate(width,
278 (sh->offset / 4096 + 799) / width);
280 black = gdImageColorAllocate(im, 0, 0, 0);
282 for (j = 0; j < ARRAY_SIZE(colors); ++j)
283 colors[j] = black;
285 init_colors(im, colors);
286 bgstart = sh->objectid;
287 bglen = sh->offset;
288 bgend = bgstart + bglen;
290 snprintf(name, sizeof(name), "bg%d.png", bgnum);
292 last_end = bgstart;
293 if (saved_len) {
294 px = (saved_extent - bgstart) / 4096;
295 for (j = 0; j < saved_len / 4096; ++j) {
296 int x = (px + j) % width;
297 int y = (px + j) / width;
298 gdImageSetPixel(im, x, y,
299 saved_color);
301 last_end += saved_len;
303 areas = 0;
304 saved_len = 0;
306 if (im && sh->type == BTRFS_EXTENT_ITEM_KEY) {
307 int c;
308 struct btrfs_extent_item *item;
310 item = (struct btrfs_extent_item *)
311 (args.buf + off);
313 if (use_color)
314 c = colors[get_color(item, sh->len)];
315 else
316 c = black;
317 if (sh->objectid > bgend) {
318 printf("WARN: extent %lld is without "
319 "block group\n", sh->objectid);
320 goto skip;
322 if (sh->objectid == bgend) {
323 saved_extent = sh->objectid;
324 saved_len = sh->offset;
325 saved_color = c;
326 goto skip;
328 px = (sh->objectid - bgstart) / 4096;
329 for (j = 0; j < sh->offset / 4096; ++j) {
330 int x = (px + j) % width;
331 int y = (px + j) / width;
332 gdImageSetPixel(im, x, y, c);
334 if (sh->objectid != last_end)
335 ++areas;
336 last_end = sh->objectid + sh->offset;
337 skip:;
339 off += sh->len;
342 * record the mins in sk so we can make sure the
343 * next search doesn't repeat this root
345 sk->min_objectid = sh->objectid;
346 sk->min_type = sh->type;
347 sk->min_offset = sh->offset;
349 sk->nr_items = 4096;
351 /* increment by one */
352 if (++sk->min_offset == 0)
353 if (++sk->min_type == 0)
354 if (++sk->min_objectid == 0)
355 break;
358 if (im) {
359 push_im(im, name, dir);
360 print_bg(html, name, bgstart, bglen, bgused, bgflags, areas);
363 if (use_color) {
364 fprintf(html, "<p>");
365 fprintf(html, "data - dark red, ");
366 fprintf(html, "fs tree - black, ");
367 fprintf(html, "extent tree - green, ");
368 fprintf(html, "csum tree - blue, ");
369 fprintf(html, "reloc tree - grey, ");
370 fprintf(html, "other trees - red, ");
371 fprintf(html, "unknown tree - dark grey");
372 fprintf(html, "</p>");
374 fprintf(html, "</body></html>\n");
376 out_close:
377 fclose(html);
379 return ret;
382 void
383 usage(void)
385 printf("usage: btrfs-fragments [options] <path>\n");
386 printf(" -c use color\n");
387 printf(" -d print data chunks\n");
388 printf(" -m print metadata chunks\n");
389 printf(" -s print system chunks\n");
390 printf(" (default is data+metadata)\n");
391 printf(" -o <dir> output directory, default is html\n");
392 exit(1);
395 int main(int argc, char **argv)
397 char *path;
398 int fd;
399 int ret;
400 u64 flags = 0;
401 char *dir = "html";
402 DIR *dirstream = NULL;
404 while (1) {
405 int c = getopt(argc, argv, "cmso:h");
406 if (c < 0)
407 break;
408 switch (c) {
409 case 'c':
410 use_color = 1;
411 break;
412 case 'd':
413 flags |= BTRFS_BLOCK_GROUP_DATA;
414 break;
415 case 'm':
416 flags |= BTRFS_BLOCK_GROUP_METADATA;
417 break;
418 case 's':
419 flags |= BTRFS_BLOCK_GROUP_SYSTEM;
420 break;
421 case 'o':
422 dir = optarg;
423 break;
424 case 'h':
425 default:
426 usage();
430 set_argv0(argv);
431 if (check_argc_min(argc - optind, 1)) {
432 usage();
433 exit(1);
436 path = argv[optind++];
438 fd = btrfs_open_dir(path, &dirstream, 1);
439 if (fd < 0)
440 exit(1);
442 if (flags == 0)
443 flags = BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA;
445 ret = list_fragments(fd, flags, dir);
446 close_file_or_dir(fd, dirstream);
447 if (ret)
448 exit(1);
450 exit(0);