?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
btrfs-progs: recieve: add missing short option E to getopt
[btrfs-progs-unstable/devel.git] / cmds-restore.c
blobc174bdd5fad57b6493f36ebfed83c6bdd53949e6
1 /*
2 * Copyright (C) 2011 Red Hat. 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
20 #include "kerncompat.h"
21
22 #include <ctype.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <unistd.h>
26 #include <fcntl.h>
27 #include <sys/stat.h>
28 #include <sys/types.h>
29 #include <lzo/lzoconf.h>
30 #include <lzo/lzo1x.h>
31 #include <zlib.h>
32 #include <regex.h>
33 #include <getopt.h>
34 #include <sys/types.h>
35 #include <sys/xattr.h>
36
37 #include "ctree.h"
38 #include "disk-io.h"
39 #include "print-tree.h"
40 #include "transaction.h"
41 #include "list.h"
42 #include "volumes.h"
43 #include "utils.h"
44 #include "commands.h"
45 #include "help.h"
46
47 static char fs_name[PATH_MAX];
48 static char path_name[PATH_MAX];
49 static char symlink_target[PATH_MAX];
50 static int get_snaps = 0;
51 static int verbose = 0;
52 static int restore_metadata = 0;
53 static int restore_symlinks = 0;
54 static int ignore_errors = 0;
55 static int overwrite = 0;
56 static int get_xattrs = 0;
57 static int dry_run = 0;
58
59 #define LZO_LEN 4
60 #define lzo1x_worst_compress(x) ((x) + ((x) / 16) + 64 + 3)
61
62 static int decompress_zlib(char *inbuf, char *outbuf, u64 compress_len,
63 u64 decompress_len)
64 {
65 z_stream strm;
66 int ret;
67
68 memset(&strm, 0, sizeof(strm));
69 ret = inflateInit(&strm);
70 if (ret != Z_OK) {
71 error("zlib init returned %d", ret);
72 return -1;
73 }
74
75 strm.avail_in = compress_len;
76 strm.next_in = (unsigned char *)inbuf;
77 strm.avail_out = decompress_len;
78 strm.next_out = (unsigned char *)outbuf;
79 ret = inflate(&strm, Z_NO_FLUSH);
80 if (ret != Z_STREAM_END) {
81 (void)inflateEnd(&strm);
82 error("zlib inflate failed: %d", ret);
83 return -1;
84 }
85
86 (void)inflateEnd(&strm);
87 return 0;
88 }
89 static inline size_t read_compress_length(unsigned char *buf)
90 {
91 __le32 dlen;
92 memcpy(&dlen, buf, LZO_LEN);
93 return le32_to_cpu(dlen);
94 }
95
96 static int decompress_lzo(struct btrfs_root *root, unsigned char *inbuf,
97 char *outbuf, u64 compress_len, u64 *decompress_len)
98 {
99 size_t new_len;
100 size_t in_len;
101 size_t out_len = 0;
102 size_t tot_len;
103 size_t tot_in;
104 int ret;
105
106 ret = lzo_init();
107 if (ret != LZO_E_OK) {
108 error("lzo init returned %d", ret);
109 return -1;
110 }
111
112 tot_len = read_compress_length(inbuf);
113 inbuf += LZO_LEN;
114 tot_in = LZO_LEN;
115
116 while (tot_in < tot_len) {
117 size_t mod_page;
118 size_t rem_page;
119 in_len = read_compress_length(inbuf);
120
121 if ((tot_in + LZO_LEN + in_len) > tot_len) {
122 error("bad compress length %lu",
123 (unsigned long)in_len);
124 return -1;
125 }
126
127 inbuf += LZO_LEN;
128 tot_in += LZO_LEN;
129 new_len = lzo1x_worst_compress(root->fs_info->sectorsize);
130 ret = lzo1x_decompress_safe((const unsigned char *)inbuf, in_len,
131 (unsigned char *)outbuf,
132 (void *)&new_len, NULL);
133 if (ret != LZO_E_OK) {
134 error("lzo decompress failed: %d", ret);
135 return -1;
136 }
137 out_len += new_len;
138 outbuf += new_len;
139 inbuf += in_len;
140 tot_in += in_len;
141
142 /*
143 * If the 4 byte header does not fit to the rest of the page we
144 * have to move to the next one, unless we read some garbage
145 */
146 mod_page = tot_in % root->fs_info->sectorsize;
147 rem_page = root->fs_info->sectorsize - mod_page;
148 if (rem_page < LZO_LEN) {
149 inbuf += rem_page;
150 tot_in += rem_page;
151 }
152 }
153
154 *decompress_len = out_len;
155
156 return 0;
157 }
158
159 static int decompress(struct btrfs_root *root, char *inbuf, char *outbuf,
160 u64 compress_len, u64 *decompress_len, int compress)
161 {
162 switch (compress) {
163 case BTRFS_COMPRESS_ZLIB:
164 return decompress_zlib(inbuf, outbuf, compress_len,
165 *decompress_len);
166 case BTRFS_COMPRESS_LZO:
167 return decompress_lzo(root, (unsigned char *)inbuf, outbuf,
168 compress_len, decompress_len);
169 default:
170 break;
171 }
172
173 error("invalid compression type: %d", compress);
174 return -1;
175 }
176
177 static int next_leaf(struct btrfs_root *root, struct btrfs_path *path)
178 {
179 int slot;
180 int level = 1;
181 int offset = 1;
182 struct extent_buffer *c;
183 struct extent_buffer *next = NULL;
184 struct btrfs_fs_info *fs_info = root->fs_info;
185
186 again:
187 for (; level < BTRFS_MAX_LEVEL; level++) {
188 if (path->nodes[level])
189 break;
190 }
191
192 if (level >= BTRFS_MAX_LEVEL)
193 return 1;
194
195 slot = path->slots[level] + 1;
196
197 while(level < BTRFS_MAX_LEVEL) {
198 if (!path->nodes[level])
199 return 1;
200
201 slot = path->slots[level] + offset;
202 c = path->nodes[level];
203 if (slot >= btrfs_header_nritems(c)) {
204 level++;
205 if (level == BTRFS_MAX_LEVEL)
206 return 1;
207 offset = 1;
208 continue;
209 }
210
211 if (path->reada)
212 reada_for_search(root, path, level, slot, 0);
213
214 next = read_node_slot(fs_info, c, slot);
215 if (extent_buffer_uptodate(next))
216 break;
217 offset++;
218 }
219 path->slots[level] = slot;
220 while(1) {
221 level--;
222 c = path->nodes[level];
223 free_extent_buffer(c);
224 path->nodes[level] = next;
225 path->slots[level] = 0;
226 if (!level)
227 break;
228 if (path->reada)
229 reada_for_search(root, path, level, 0, 0);
230 next = read_node_slot(fs_info, next, 0);
231 if (!extent_buffer_uptodate(next))
232 goto again;
233 }
234 return 0;
235 }
236
237 static int copy_one_inline(struct btrfs_root *root, int fd,
238 struct btrfs_path *path, u64 pos)
239 {
240 struct extent_buffer *leaf = path->nodes[0];
241 struct btrfs_file_extent_item *fi;
242 char buf[4096];
243 char *outbuf;
244 u64 ram_size;
245 ssize_t done;
246 unsigned long ptr;
247 int ret;
248 int len;
249 int inline_item_len;
250 int compress;
251
252 fi = btrfs_item_ptr(leaf, path->slots[0],
253 struct btrfs_file_extent_item);
254 ptr = btrfs_file_extent_inline_start(fi);
255 len = btrfs_file_extent_inline_len(leaf, path->slots[0], fi);
256 inline_item_len = btrfs_file_extent_inline_item_len(leaf, btrfs_item_nr(path->slots[0]));
257 read_extent_buffer(leaf, buf, ptr, inline_item_len);
258
259 compress = btrfs_file_extent_compression(leaf, fi);
260 if (compress == BTRFS_COMPRESS_NONE) {
261 done = pwrite(fd, buf, len, pos);
262 if (done < len) {
263 fprintf(stderr, "Short inline write, wanted %d, did "
264 "%zd: %d\n", len, done, errno);
265 return -1;
266 }
267 return 0;
268 }
269
270 ram_size = btrfs_file_extent_ram_bytes(leaf, fi);
271 outbuf = calloc(1, ram_size);
272 if (!outbuf) {
273 error("not enough memory");
274 return -ENOMEM;
275 }
276
277 ret = decompress(root, buf, outbuf, len, &ram_size, compress);
278 if (ret) {
279 free(outbuf);
280 return ret;
281 }
282
283 done = pwrite(fd, outbuf, ram_size, pos);
284 free(outbuf);
285 if (done < ram_size) {
286 fprintf(stderr, "Short compressed inline write, wanted %Lu, "
287 "did %zd: %d\n", ram_size, done, errno);
288 return -1;
289 }
290
291 return 0;
292 }
293
294 static int copy_one_extent(struct btrfs_root *root, int fd,
295 struct extent_buffer *leaf,
296 struct btrfs_file_extent_item *fi, u64 pos)
297 {
298 struct btrfs_multi_bio *multi = NULL;
299 struct btrfs_device *device;
300 char *inbuf, *outbuf = NULL;
301 ssize_t done, total = 0;
302 u64 bytenr;
303 u64 ram_size;
304 u64 disk_size;
305 u64 num_bytes;
306 u64 length;
307 u64 size_left;
308 u64 dev_bytenr;
309 u64 offset;
310 u64 count = 0;
311 int compress;
312 int ret;
313 int dev_fd;
314 int mirror_num = 1;
315 int num_copies;
316
317 compress = btrfs_file_extent_compression(leaf, fi);
318 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
319 disk_size = btrfs_file_extent_disk_num_bytes(leaf, fi);
320 ram_size = btrfs_file_extent_ram_bytes(leaf, fi);
321 offset = btrfs_file_extent_offset(leaf, fi);
322 num_bytes = btrfs_file_extent_num_bytes(leaf, fi);
323 size_left = disk_size;
324 if (compress == BTRFS_COMPRESS_NONE)
325 bytenr += offset;
326
327 if (verbose && offset)
328 printf("offset is %Lu\n", offset);
329 /* we found a hole */
330 if (disk_size == 0)
331 return 0;
332
333 inbuf = malloc(size_left);
334 if (!inbuf) {
335 error("not enough memory");
336 return -ENOMEM;
337 }
338
339 if (compress != BTRFS_COMPRESS_NONE) {
340 outbuf = calloc(1, ram_size);
341 if (!outbuf) {
342 error("not enough memory");
343 free(inbuf);
344 return -ENOMEM;
345 }
346 }
347 again:
348 length = size_left;
349 ret = btrfs_map_block(root->fs_info, READ, bytenr, &length, &multi,
350 mirror_num, NULL);
351 if (ret) {
352 error("cannot map block logical %llu length %llu: %d",
353 (unsigned long long)bytenr,
354 (unsigned long long)length, ret);
355 goto out;
356 }
357 device = multi->stripes[0].dev;
358 dev_fd = device->fd;
359 device->total_ios++;
360 dev_bytenr = multi->stripes[0].physical;
361 free(multi);
362
363 if (size_left < length)
364 length = size_left;
365
366 done = pread(dev_fd, inbuf+count, length, dev_bytenr);
367 /* Need both checks, or we miss negative values due to u64 conversion */
368 if (done < 0 || done < length) {
369 num_copies = btrfs_num_copies(root->fs_info, bytenr, length);
370 mirror_num++;
371 /* mirror_num is 1-indexed, so num_copies is a valid mirror. */
372 if (mirror_num > num_copies) {
373 ret = -1;
374 error("exhausted mirrors trying to read (%d > %d)",
375 mirror_num, num_copies);
376 goto out;
377 }
378 fprintf(stderr, "Trying another mirror\n");
379 goto again;
380 }
381
382 mirror_num = 1;
383 size_left -= length;
384 count += length;
385 bytenr += length;
386 if (size_left)
387 goto again;
388
389 if (compress == BTRFS_COMPRESS_NONE) {
390 while (total < num_bytes) {
391 done = pwrite(fd, inbuf+total, num_bytes-total,
392 pos+total);
393 if (done < 0) {
394 ret = -1;
395 error("cannot write data: %d %s", errno, strerror(errno));
396 goto out;
397 }
398 total += done;
399 }
400 ret = 0;
401 goto out;
402 }
403
404 ret = decompress(root, inbuf, outbuf, disk_size, &ram_size, compress);
405 if (ret) {
406 num_copies = btrfs_num_copies(root->fs_info, bytenr, length);
407 mirror_num++;
408 if (mirror_num >= num_copies) {
409 ret = -1;
410 goto out;
411 }
412 fprintf(stderr, "Trying another mirror\n");
413 goto again;
414 }
415
416 while (total < num_bytes) {
417 done = pwrite(fd, outbuf + offset + total,
418 num_bytes - total,
419 pos + total);
420 if (done < 0) {
421 ret = -1;
422 goto out;
423 }
424 total += done;
425 }
426 out:
427 free(inbuf);
428 free(outbuf);
429 return ret;
430 }
431
432 enum loop_response {
433 LOOP_STOP,
434 LOOP_CONTINUE,
435 LOOP_DONTASK
436 };
437
438 static enum loop_response ask_to_continue(const char *file)
439 {
440 char buf[2];
441 char *ret;
442
443 printf("We seem to be looping a lot on %s, do you want to keep going "
444 "on ? (y/N/a): ", file);
445 again:
446 ret = fgets(buf, 2, stdin);
447 if (*ret == '\n' || tolower(*ret) == 'n')
448 return LOOP_STOP;
449 if (tolower(*ret) == 'a')
450 return LOOP_DONTASK;
451 if (tolower(*ret) != 'y') {
452 printf("Please enter one of 'y', 'n', or 'a': ");
453 goto again;
454 }
455
456 return LOOP_CONTINUE;
457 }
458
459
460 static int set_file_xattrs(struct btrfs_root *root, u64 inode,
461 int fd, const char *file_name)
462 {
463 struct btrfs_key key;
464 struct btrfs_path path;
465 struct extent_buffer *leaf;
466 struct btrfs_dir_item *di;
467 u32 name_len = 0;
468 u32 data_len = 0;
469 u32 len = 0;
470 u32 cur, total_len;
471 char *name = NULL;
472 char *data = NULL;
473 int ret = 0;
474
475 btrfs_init_path(&path);
476 key.objectid = inode;
477 key.type = BTRFS_XATTR_ITEM_KEY;
478 key.offset = 0;
479 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
480 if (ret < 0)
481 goto out;
482
483 leaf = path.nodes[0];
484 while (1) {
485 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
486 do {
487 ret = next_leaf(root, &path);
488 if (ret < 0) {
489 error("searching for extended attributes: %d",
490 ret);
491 goto out;
492 } else if (ret) {
493 /* No more leaves to search */
494 ret = 0;
495 goto out;
496 }
497 leaf = path.nodes[0];
498 } while (!leaf);
499 continue;
500 }
501
502 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
503 if (key.type != BTRFS_XATTR_ITEM_KEY || key.objectid != inode)
504 break;
505 cur = 0;
506 total_len = btrfs_item_size_nr(leaf, path.slots[0]);
507 di = btrfs_item_ptr(leaf, path.slots[0],
508 struct btrfs_dir_item);
509
510 while (cur < total_len) {
511 len = btrfs_dir_name_len(leaf, di);
512 if (len > name_len) {
513 free(name);
514 name = (char *) malloc(len + 1);
515 if (!name) {
516 ret = -ENOMEM;
517 goto out;
518 }
519 }
520 read_extent_buffer(leaf, name,
521 (unsigned long)(di + 1), len);
522 name[len] = '\0';
523 name_len = len;
524
525 len = btrfs_dir_data_len(leaf, di);
526 if (len > data_len) {
527 free(data);
528 data = (char *) malloc(len);
529 if (!data) {
530 ret = -ENOMEM;
531 goto out;
532 }
533 }
534 read_extent_buffer(leaf, data,
535 (unsigned long)(di + 1) + name_len,
536 len);
537 data_len = len;
538
539 if (fsetxattr(fd, name, data, data_len, 0))
540 error("setting extended attribute %s on file %s: %s",
541 name, file_name, strerror(errno));
542
543 len = sizeof(*di) + name_len + data_len;
544 cur += len;
545 di = (struct btrfs_dir_item *)((char *)di + len);
546 }
547 path.slots[0]++;
548 }
549 ret = 0;
550 out:
551 btrfs_release_path(&path);
552 free(name);
553 free(data);
554
555 return ret;
556 }
557
558 static int copy_metadata(struct btrfs_root *root, int fd,
559 struct btrfs_key *key)
560 {
561 struct btrfs_path path;
562 struct btrfs_inode_item *inode_item;
563 int ret;
564
565 btrfs_init_path(&path);
566 ret = btrfs_lookup_inode(NULL, root, &path, key, 0);
567 if (ret == 0) {
568 struct btrfs_timespec *bts;
569 struct timespec times[2];
570
571 inode_item = btrfs_item_ptr(path.nodes[0], path.slots[0],
572 struct btrfs_inode_item);
573
574 ret = fchown(fd, btrfs_inode_uid(path.nodes[0], inode_item),
575 btrfs_inode_gid(path.nodes[0], inode_item));
576 if (ret) {
577 error("failed to change owner: %s", strerror(errno));
578 goto out;
579 }
580
581 ret = fchmod(fd, btrfs_inode_mode(path.nodes[0], inode_item));
582 if (ret) {
583 error("failed to change mode: %s", strerror(errno));
584 goto out;
585 }
586
587 bts = btrfs_inode_atime(inode_item);
588 times[0].tv_sec = btrfs_timespec_sec(path.nodes[0], bts);
589 times[0].tv_nsec = btrfs_timespec_nsec(path.nodes[0], bts);
590
591 bts = btrfs_inode_mtime(inode_item);
592 times[1].tv_sec = btrfs_timespec_sec(path.nodes[0], bts);
593 times[1].tv_nsec = btrfs_timespec_nsec(path.nodes[0], bts);
594
595 ret = futimens(fd, times);
596 if (ret) {
597 error("failed to set times: %s", strerror(errno));
598 goto out;
599 }
600 }
601 out:
602 btrfs_release_path(&path);
603 return ret;
604 }
605
606 static int copy_file(struct btrfs_root *root, int fd, struct btrfs_key *key,
607 const char *file)
608 {
609 struct extent_buffer *leaf;
610 struct btrfs_path path;
611 struct btrfs_file_extent_item *fi;
612 struct btrfs_inode_item *inode_item;
613 struct btrfs_timespec *bts;
614 struct btrfs_key found_key;
615 int ret;
616 int extent_type;
617 int compression;
618 int loops = 0;
619 u64 found_size = 0;
620 struct timespec times[2];
621 int times_ok = 0;
622
623 btrfs_init_path(&path);
624 ret = btrfs_lookup_inode(NULL, root, &path, key, 0);
625 if (ret == 0) {
626 inode_item = btrfs_item_ptr(path.nodes[0], path.slots[0],
627 struct btrfs_inode_item);
628 found_size = btrfs_inode_size(path.nodes[0], inode_item);
629
630 if (restore_metadata) {
631 /*
632 * Change the ownership and mode now, set times when
633 * copyout is finished.
634 */
635
636 ret = fchown(fd, btrfs_inode_uid(path.nodes[0], inode_item),
637 btrfs_inode_gid(path.nodes[0], inode_item));
638 if (ret && !ignore_errors)
639 goto out;
640
641 ret = fchmod(fd, btrfs_inode_mode(path.nodes[0], inode_item));
642 if (ret && !ignore_errors)
643 goto out;
644
645 bts = btrfs_inode_atime(inode_item);
646 times[0].tv_sec = btrfs_timespec_sec(path.nodes[0], bts);
647 times[0].tv_nsec = btrfs_timespec_nsec(path.nodes[0], bts);
648
649 bts = btrfs_inode_mtime(inode_item);
650 times[1].tv_sec = btrfs_timespec_sec(path.nodes[0], bts);
651 times[1].tv_nsec = btrfs_timespec_nsec(path.nodes[0], bts);
652 times_ok = 1;
653 }
654 }
655 btrfs_release_path(&path);
656
657 key->offset = 0;
658 key->type = BTRFS_EXTENT_DATA_KEY;
659
660 ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
661 if (ret < 0) {
662 error("searching extent data returned %d", ret);
663 goto out;
664 }
665
666 leaf = path.nodes[0];
667 while (!leaf) {
668 ret = next_leaf(root, &path);
669 if (ret < 0) {
670 error("cannot get next leaf: %d", ret);
671 goto out;
672 } else if (ret > 0) {
673 /* No more leaves to search */
674 ret = 0;
675 goto out;
676 }
677 leaf = path.nodes[0];
678 }
679
680 while (1) {
681 if (loops >= 0 && loops++ >= 1024) {
682 enum loop_response resp;
683
684 resp = ask_to_continue(file);
685 if (resp == LOOP_STOP)
686 break;
687 else if (resp == LOOP_CONTINUE)
688 loops = 0;
689 else if (resp == LOOP_DONTASK)
690 loops = -1;
691 }
692 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
693 do {
694 ret = next_leaf(root, &path);
695 if (ret < 0) {
696 fprintf(stderr, "Error searching %d\n", ret);
697 goto out;
698 } else if (ret) {
699 /* No more leaves to search */
700 btrfs_release_path(&path);
701 goto set_size;
702 }
703 leaf = path.nodes[0];
704 } while (!leaf);
705 continue;
706 }
707 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
708 if (found_key.objectid != key->objectid)
709 break;
710 if (found_key.type != key->type)
711 break;
712 fi = btrfs_item_ptr(leaf, path.slots[0],
713 struct btrfs_file_extent_item);
714 extent_type = btrfs_file_extent_type(leaf, fi);
715 compression = btrfs_file_extent_compression(leaf, fi);
716 if (compression >= BTRFS_COMPRESS_LAST) {
717 warning("compression type %d not supported",
718 compression);
719 ret = -1;
720 goto out;
721 }
722
723 if (extent_type == BTRFS_FILE_EXTENT_PREALLOC)
724 goto next;
725 if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
726 ret = copy_one_inline(root, fd, &path, found_key.offset);
727 if (ret)
728 goto out;
729 } else if (extent_type == BTRFS_FILE_EXTENT_REG) {
730 ret = copy_one_extent(root, fd, leaf, fi,
731 found_key.offset);
732 if (ret)
733 goto out;
734 } else {
735 warning("weird extent type %d", extent_type);
736 }
737 next:
738 path.slots[0]++;
739 }
740
741 btrfs_release_path(&path);
742 set_size:
743 if (found_size) {
744 ret = ftruncate(fd, (loff_t)found_size);
745 if (ret)
746 return ret;
747 }
748 if (get_xattrs) {
749 ret = set_file_xattrs(root, key->objectid, fd, file);
750 if (ret)
751 return ret;
752 }
753 if (restore_metadata && times_ok) {
754 ret = futimens(fd, times);
755 if (ret)
756 return ret;
757 }
758 return 0;
759
760 out:
761 btrfs_release_path(&path);
762 return ret;
763 }
764
765 /*
766 * returns:
767 * 0 if the file exists and should be skipped.
768 * 1 if the file does NOT exist
769 * 2 if the file exists but is OK to overwrite
770 */
771 static int overwrite_ok(const char * path)
772 {
773 static int warn = 0;
774 struct stat st;
775 int ret;
776
777 /* don't be fooled by symlinks */
778 ret = fstatat(-1, path_name, &st, AT_SYMLINK_NOFOLLOW);
779
780 if (!ret) {
781 if (overwrite)
782 return 2;
783
784 if (verbose || !warn)
785 printf("Skipping existing file"
786 " %s\n", path);
787 if (!warn)
788 printf("If you wish to overwrite use -o\n");
789 warn = 1;
790 return 0;
791 }
792 return 1;
793 }
794
795 static int copy_symlink(struct btrfs_root *root, struct btrfs_key *key,
796 const char *file)
797 {
798 struct btrfs_path path;
799 struct extent_buffer *leaf;
800 struct btrfs_file_extent_item *extent_item;
801 struct btrfs_inode_item *inode_item;
802 u32 len;
803 u32 name_offset;
804 int ret;
805 struct btrfs_timespec *bts;
806 struct timespec times[2];
807
808 ret = overwrite_ok(path_name);
809 if (ret == 0)
810 return 0; /* skip this file */
811
812 /* symlink() can't overwrite, so unlink first */
813 if (ret == 2) {
814 ret = unlink(path_name);
815 if (ret) {
816 fprintf(stderr, "failed to unlink '%s' for overwrite\n",
817 path_name);
818 return ret;
819 }
820 }
821
822 btrfs_init_path(&path);
823 key->type = BTRFS_EXTENT_DATA_KEY;
824 key->offset = 0;
825 ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
826 if (ret < 0)
827 goto out;
828
829 leaf = path.nodes[0];
830 if (!leaf) {
831 fprintf(stderr, "Error getting leaf for symlink '%s'\n", file);
832 ret = -1;
833 goto out;
834 }
835
836 extent_item = btrfs_item_ptr(leaf, path.slots[0],
837 struct btrfs_file_extent_item);
838
839 len = btrfs_file_extent_inline_item_len(leaf,
840 btrfs_item_nr(path.slots[0]));
841 if (len >= PATH_MAX) {
842 fprintf(stderr, "Symlink '%s' target length %d is longer than PATH_MAX\n",
843 fs_name, len);
844 ret = -1;
845 goto out;
846 }
847
848 name_offset = (unsigned long) extent_item
849 + offsetof(struct btrfs_file_extent_item, disk_bytenr);
850 read_extent_buffer(leaf, symlink_target, name_offset, len);
851
852 symlink_target[len] = 0;
853
854 if (!dry_run) {
855 ret = symlink(symlink_target, path_name);
856 if (ret < 0) {
857 fprintf(stderr, "Failed to restore symlink '%s': %s\n",
858 path_name, strerror(errno));
859 goto out;
860 }
861 }
862 printf("SYMLINK: '%s' => '%s'\n", path_name, symlink_target);
863
864 ret = 0;
865 if (!restore_metadata)
866 goto out;
867
868 /*
869 * Symlink metadata operates differently than files/directories, so do
870 * our own work here.
871 */
872 key->type = BTRFS_INODE_ITEM_KEY;
873 key->offset = 0;
874
875 btrfs_release_path(&path);
876
877 ret = btrfs_lookup_inode(NULL, root, &path, key, 0);
878 if (ret) {
879 fprintf(stderr, "Failed to lookup inode for '%s'\n", file);
880 goto out;
881 }
882
883 inode_item = btrfs_item_ptr(path.nodes[0], path.slots[0],
884 struct btrfs_inode_item);
885
886 ret = fchownat(-1, file, btrfs_inode_uid(path.nodes[0], inode_item),
887 btrfs_inode_gid(path.nodes[0], inode_item),
888 AT_SYMLINK_NOFOLLOW);
889 if (ret) {
890 fprintf(stderr, "Failed to change owner: %s\n",
891 strerror(errno));
892 goto out;
893 }
894
895 bts = btrfs_inode_atime(inode_item);
896 times[0].tv_sec = btrfs_timespec_sec(path.nodes[0], bts);
897 times[0].tv_nsec = btrfs_timespec_nsec(path.nodes[0], bts);
898
899 bts = btrfs_inode_mtime(inode_item);
900 times[1].tv_sec = btrfs_timespec_sec(path.nodes[0], bts);
901 times[1].tv_nsec = btrfs_timespec_nsec(path.nodes[0], bts);
902
903 ret = utimensat(-1, file, times, AT_SYMLINK_NOFOLLOW);
904 if (ret)
905 fprintf(stderr, "Failed to set times: %s\n", strerror(errno));
906 out:
907 btrfs_release_path(&path);
908 return ret;
909 }
910
911 static int search_dir(struct btrfs_root *root, struct btrfs_key *key,
912 const char *output_rootdir, const char *in_dir,
913 const regex_t *mreg)
914 {
915 struct btrfs_path path;
916 struct extent_buffer *leaf;
917 struct btrfs_dir_item *dir_item;
918 struct btrfs_key found_key, location;
919 char filename[BTRFS_NAME_LEN + 1];
920 unsigned long name_ptr;
921 int name_len;
922 int ret = 0;
923 int fd;
924 int loops = 0;
925 u8 type;
926
927 btrfs_init_path(&path);
928 key->offset = 0;
929 key->type = BTRFS_DIR_INDEX_KEY;
930 ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
931 if (ret < 0) {
932 fprintf(stderr, "Error searching %d\n", ret);
933 goto out;
934 }
935
936 ret = 0;
937
938 leaf = path.nodes[0];
939 while (!leaf) {
940 if (verbose > 1)
941 printf("No leaf after search, looking for the next "
942 "leaf\n");
943 ret = next_leaf(root, &path);
944 if (ret < 0) {
945 fprintf(stderr, "Error getting next leaf %d\n",
946 ret);
947 goto out;
948 } else if (ret > 0) {
949 /* No more leaves to search */
950 if (verbose)
951 printf("Reached the end of the tree looking "
952 "for the directory\n");
953 ret = 0;
954 goto out;
955 }
956 leaf = path.nodes[0];
957 }
958
959 while (leaf) {
960 if (loops++ >= 1024) {
961 printf("We have looped trying to restore files in %s "
962 "too many times to be making progress, "
963 "stopping\n", in_dir);
964 break;
965 }
966
967 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
968 do {
969 ret = next_leaf(root, &path);
970 if (ret < 0) {
971 fprintf(stderr, "Error searching %d\n",
972 ret);
973 goto out;
974 } else if (ret > 0) {
975 /* No more leaves to search */
976 if (verbose)
977 printf("Reached the end of "
978 "the tree searching the"
979 " directory\n");
980 ret = 0;
981 goto out;
982 }
983 leaf = path.nodes[0];
984 } while (!leaf);
985 continue;
986 }
987 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
988 if (found_key.objectid != key->objectid) {
989 if (verbose > 1)
990 printf("Found objectid=%Lu, key=%Lu\n",
991 found_key.objectid, key->objectid);
992 break;
993 }
994 if (found_key.type != key->type) {
995 if (verbose > 1)
996 printf("Found type=%u, want=%u\n",
997 found_key.type, key->type);
998 break;
999 }
1000 dir_item = btrfs_item_ptr(leaf, path.slots[0],
1001 struct btrfs_dir_item);
1002 name_ptr = (unsigned long)(dir_item + 1);
1003 name_len = btrfs_dir_name_len(leaf, dir_item);
1004 read_extent_buffer(leaf, filename, name_ptr, name_len);
1005 filename[name_len] = '\0';
1006 type = btrfs_dir_type(leaf, dir_item);
1007 btrfs_dir_item_key_to_cpu(leaf, dir_item, &location);
1008
1009 /* full path from root of btrfs being restored */
1010 snprintf(fs_name, PATH_MAX, "%s/%s", in_dir, filename);
1011
1012 if (mreg && REG_NOMATCH == regexec(mreg, fs_name, 0, NULL, 0))
1013 goto next;
1014
1015 /* full path from system root */
1016 snprintf(path_name, PATH_MAX, "%s%s", output_rootdir, fs_name);
1017
1018 /*
1019 * Restore directories, files, symlinks and metadata.
1020 */
1021 if (type == BTRFS_FT_REG_FILE) {
1022 if (!overwrite_ok(path_name))
1023 goto next;
1024
1025 if (verbose)
1026 printf("Restoring %s\n", path_name);
1027 if (dry_run)
1028 goto next;
1029 fd = open(path_name, O_CREAT|O_WRONLY, 0644);
1030 if (fd < 0) {
1031 fprintf(stderr, "Error creating %s: %d\n",
1032 path_name, errno);
1033 if (ignore_errors)
1034 goto next;
1035 ret = -1;
1036 goto out;
1037 }
1038 loops = 0;
1039 ret = copy_file(root, fd, &location, path_name);
1040 close(fd);
1041 if (ret) {
1042 fprintf(stderr, "Error copying data for %s\n",
1043 path_name);
1044 if (ignore_errors)
1045 goto next;
1046 goto out;
1047 }
1048 } else if (type == BTRFS_FT_DIR) {
1049 struct btrfs_root *search_root = root;
1050 char *dir = strdup(fs_name);
1051
1052 if (!dir) {
1053 fprintf(stderr, "Ran out of memory\n");
1054 ret = -ENOMEM;
1055 goto out;
1056 }
1057
1058 if (location.type == BTRFS_ROOT_ITEM_KEY) {
1059 /*
1060 * If we are a snapshot and this is the index
1061 * object to ourselves just skip it.
1062 */
1063 if (location.objectid ==
1064 root->root_key.objectid) {
1065 free(dir);
1066 goto next;
1067 }
1068
1069 location.offset = (u64)-1;
1070 search_root = btrfs_read_fs_root(root->fs_info,
1071 &location);
1072 if (IS_ERR(search_root)) {
1073 free(dir);
1074 fprintf(stderr, "Error reading "
1075 "subvolume %s: %lu\n",
1076 path_name,
1077 PTR_ERR(search_root));
1078 if (ignore_errors)
1079 goto next;
1080 ret = PTR_ERR(search_root);
1081 goto out;
1082 }
1083
1084 /*
1085 * A subvolume will have a key.offset of 0, a
1086 * snapshot will have key.offset of a transid.
1087 */
1088 if (search_root->root_key.offset != 0 &&
1089 get_snaps == 0) {
1090 free(dir);
1091 printf("Skipping snapshot %s\n",
1092 filename);
1093 goto next;
1094 }
1095 location.objectid = BTRFS_FIRST_FREE_OBJECTID;
1096 }
1097
1098 if (verbose)
1099 printf("Restoring %s\n", path_name);
1100
1101 errno = 0;
1102 if (dry_run)
1103 ret = 0;
1104 else
1105 ret = mkdir(path_name, 0755);
1106 if (ret && errno != EEXIST) {
1107 free(dir);
1108 fprintf(stderr, "Error mkdiring %s: %d\n",
1109 path_name, errno);
1110 if (ignore_errors)
1111 goto next;
1112 ret = -1;
1113 goto out;
1114 }
1115 loops = 0;
1116 ret = search_dir(search_root, &location,
1117 output_rootdir, dir, mreg);
1118 free(dir);
1119 if (ret) {
1120 fprintf(stderr, "Error searching %s\n",
1121 path_name);
1122 if (ignore_errors)
1123 goto next;
1124 goto out;
1125 }
1126 } else if (type == BTRFS_FT_SYMLINK) {
1127 if (restore_symlinks)
1128 ret = copy_symlink(root, &location, path_name);
1129 if (ret < 0) {
1130 if (ignore_errors)
1131 goto next;
1132 btrfs_release_path(&path);
1133 return ret;
1134 }
1135 }
1136 next:
1137 path.slots[0]++;
1138 }
1139
1140 if (restore_metadata) {
1141 snprintf(path_name, PATH_MAX, "%s%s", output_rootdir, in_dir);
1142 fd = open(path_name, O_RDONLY);
1143 if (fd < 0) {
1144 fprintf(stderr, "ERROR: Failed to access %s to restore metadata\n",
1145 path_name);
1146 if (!ignore_errors) {
1147 ret = -1;
1148 goto out;
1149 }
1150 } else {
1151 /*
1152 * Set owner/mode/time on the directory as well
1153 */
1154 key->type = BTRFS_INODE_ITEM_KEY;
1155 ret = copy_metadata(root, fd, key);
1156 close(fd);
1157 if (ret && !ignore_errors)
1158 goto out;
1159 }
1160 }
1161
1162 if (verbose)
1163 printf("Done searching %s\n", in_dir);
1164 out:
1165 btrfs_release_path(&path);
1166 return ret;
1167 }
1168
1169 static int do_list_roots(struct btrfs_root *root)
1170 {
1171 struct btrfs_key key;
1172 struct btrfs_key found_key;
1173 struct btrfs_disk_key disk_key;
1174 struct btrfs_path path;
1175 struct extent_buffer *leaf;
1176 struct btrfs_root_item ri;
1177 unsigned long offset;
1178 int slot;
1179 int ret;
1180
1181 root = root->fs_info->tree_root;
1182
1183 btrfs_init_path(&path);
1184 key.offset = 0;
1185 key.objectid = 0;
1186 key.type = BTRFS_ROOT_ITEM_KEY;
1187 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
1188 if (ret < 0) {
1189 fprintf(stderr, "Failed to do search %d\n", ret);
1190 btrfs_release_path(&path);
1191 return -1;
1192 }
1193
1194 leaf = path.nodes[0];
1195
1196 while (1) {
1197 slot = path.slots[0];
1198 if (slot >= btrfs_header_nritems(leaf)) {
1199 ret = btrfs_next_leaf(root, &path);
1200 if (ret)
1201 break;
1202 leaf = path.nodes[0];
1203 slot = path.slots[0];
1204 }
1205 btrfs_item_key(leaf, &disk_key, slot);
1206 btrfs_disk_key_to_cpu(&found_key, &disk_key);
1207 if (found_key.type != BTRFS_ROOT_ITEM_KEY) {
1208 path.slots[0]++;
1209 continue;
1210 }
1211
1212 offset = btrfs_item_ptr_offset(leaf, slot);
1213 read_extent_buffer(leaf, &ri, offset, sizeof(ri));
1214 printf(" tree ");
1215 btrfs_print_key(&disk_key);
1216 printf(" %Lu level %d\n", btrfs_root_bytenr(&ri),
1217 btrfs_root_level(&ri));
1218 path.slots[0]++;
1219 }
1220 btrfs_release_path(&path);
1221
1222 return 0;
1223 }
1224
1225 static struct btrfs_root *open_fs(const char *dev, u64 root_location,
1226 int super_mirror, int list_roots)
1227 {
1228 struct btrfs_fs_info *fs_info = NULL;
1229 struct btrfs_root *root = NULL;
1230 u64 bytenr;
1231 int i;
1232
1233 for (i = super_mirror; i < BTRFS_SUPER_MIRROR_MAX; i++) {
1234 bytenr = btrfs_sb_offset(i);
1235 fs_info = open_ctree_fs_info(dev, bytenr, root_location, 0,
1236 OPEN_CTREE_PARTIAL);
1237 if (fs_info)
1238 break;
1239 fprintf(stderr, "Could not open root, trying backup super\n");
1240 }
1241
1242 if (!fs_info)
1243 return NULL;
1244
1245 /*
1246 * All we really need to succeed is reading the chunk tree, everything
1247 * else we can do by hand, since we only need to read the tree root and
1248 * the fs_root.
1249 */
1250 if (!extent_buffer_uptodate(fs_info->tree_root->node)) {
1251 u64 generation;
1252
1253 root = fs_info->tree_root;
1254 if (!root_location)
1255 root_location = btrfs_super_root(fs_info->super_copy);
1256 generation = btrfs_super_generation(fs_info->super_copy);
1257 root->node = read_tree_block(fs_info, root_location,
1258 fs_info->nodesize, generation);
1259 if (!extent_buffer_uptodate(root->node)) {
1260 fprintf(stderr, "Error opening tree root\n");
1261 close_ctree(root);
1262 return NULL;
1263 }
1264 }
1265
1266 if (!list_roots && !fs_info->fs_root) {
1267 struct btrfs_key key;
1268
1269 key.objectid = BTRFS_FS_TREE_OBJECTID;
1270 key.type = BTRFS_ROOT_ITEM_KEY;
1271 key.offset = (u64)-1;
1272 fs_info->fs_root = btrfs_read_fs_root_no_cache(fs_info, &key);
1273 if (IS_ERR(fs_info->fs_root)) {
1274 fprintf(stderr, "Couldn't read fs root: %ld\n",
1275 PTR_ERR(fs_info->fs_root));
1276 close_ctree(fs_info->tree_root);
1277 return NULL;
1278 }
1279 }
1280
1281 if (list_roots && do_list_roots(fs_info->tree_root)) {
1282 close_ctree(fs_info->tree_root);
1283 return NULL;
1284 }
1285
1286 return fs_info->fs_root;
1287 }
1288
1289 static int find_first_dir(struct btrfs_root *root, u64 *objectid)
1290 {
1291 struct btrfs_path path;
1292 struct btrfs_key found_key;
1293 struct btrfs_key key;
1294 int ret = -1;
1295 int i;
1296
1297 btrfs_init_path(&path);
1298 key.objectid = 0;
1299 key.type = BTRFS_DIR_INDEX_KEY;
1300 key.offset = 0;
1301 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
1302 if (ret < 0) {
1303 fprintf(stderr, "Error searching %d\n", ret);
1304 goto out;
1305 }
1306
1307 if (!path.nodes[0]) {
1308 fprintf(stderr, "No leaf!\n");
1309 goto out;
1310 }
1311 again:
1312 for (i = path.slots[0];
1313 i < btrfs_header_nritems(path.nodes[0]); i++) {
1314 btrfs_item_key_to_cpu(path.nodes[0], &found_key, i);
1315 if (found_key.type != key.type)
1316 continue;
1317
1318 printf("Using objectid %Lu for first dir\n",
1319 found_key.objectid);
1320 *objectid = found_key.objectid;
1321 ret = 0;
1322 goto out;
1323 }
1324 do {
1325 ret = next_leaf(root, &path);
1326 if (ret < 0) {
1327 fprintf(stderr, "Error getting next leaf %d\n",
1328 ret);
1329 goto out;
1330 } else if (ret > 0) {
1331 fprintf(stderr, "No more leaves\n");
1332 goto out;
1333 }
1334 } while (!path.nodes[0]);
1335 if (path.nodes[0])
1336 goto again;
1337 printf("Couldn't find a dir index item\n");
1338 out:
1339 btrfs_release_path(&path);
1340 return ret;
1341 }
1342
1343 const char * const cmd_restore_usage[] = {
1344 "btrfs restore [options] <device> <path> | -l <device>",
1345 "Try to restore files from a damaged filesystem (unmounted)",
1346 "",
1347 "-s|--snapshots get snapshots",
1348 "-x|--xattr restore extended attributes",
1349 "-m|--metadata restore owner, mode and times",
1350 "-S|--symlink restore symbolic links",
1351 "-v|--verbose verbose",
1352 "-i|--ignore-errors ignore errors",
1353 "-o|--overwrite overwrite",
1354 "-t <bytenr> tree location",
1355 "-f <bytenr> filesystem location",
1356 "-u|--super <mirror> super mirror",
1357 "-r|--root <rootid> root objectid",
1358 "-d find dir",
1359 "-l|--list-roots list tree roots",
1360 "-D|--dry-run dry run (only list files that would be recovered)",
1361 "--path-regex <regex>",
1362 " restore only filenames matching regex,",
1363 " you have to use following syntax (possibly quoted):",
1364 " ^/(|home(|/username(|/Desktop(|/.*))))$",
1365 "-c ignore case (--path-regex only)",
1366 NULL
1367 };
1368
1369 int cmd_restore(int argc, char **argv)
1370 {
1371 struct btrfs_root *root;
1372 struct btrfs_key key;
1373 char dir_name[PATH_MAX];
1374 u64 tree_location = 0;
1375 u64 fs_location = 0;
1376 u64 root_objectid = 0;
1377 int len;
1378 int ret;
1379 int super_mirror = 0;
1380 int find_dir = 0;
1381 int list_roots = 0;
1382 const char *match_regstr = NULL;
1383 int match_cflags = REG_EXTENDED | REG_NOSUB | REG_NEWLINE;
1384 regex_t match_reg, *mreg = NULL;
1385 char reg_err[256];
1386
1387 while (1) {
1388 int opt;
1389 enum { GETOPT_VAL_PATH_REGEX = 256 };
1390 static const struct option long_options[] = {
1391 { "path-regex", required_argument, NULL,
1392 GETOPT_VAL_PATH_REGEX },
1393 { "dry-run", no_argument, NULL, 'D'},
1394 { "metadata", no_argument, NULL, 'm'},
1395 { "symlinks", no_argument, NULL, 'S'},
1396 { "snapshots", no_argument, NULL, 's'},
1397 { "xattr", no_argument, NULL, 'x'},
1398 { "verbose", no_argument, NULL, 'v'},
1399 { "ignore-errors", no_argument, NULL, 'i'},
1400 { "overwrite", no_argument, NULL, 'o'},
1401 { "super", required_argument, NULL, 'u'},
1402 { "root", required_argument, NULL, 'r'},
1403 { "list-roots", no_argument, NULL, 'l'},
1404 { NULL, 0, NULL, 0}
1405 };
1406
1407 opt = getopt_long(argc, argv, "sSxviot:u:dmf:r:lDc", long_options,
1408 NULL);
1409 if (opt < 0)
1410 break;
1411
1412 switch (opt) {
1413 case 's':
1414 get_snaps = 1;
1415 break;
1416 case 'v':
1417 verbose++;
1418 break;
1419 case 'i':
1420 ignore_errors = 1;
1421 break;
1422 case 'o':
1423 overwrite = 1;
1424 break;
1425 case 't':
1426 tree_location = arg_strtou64(optarg);
1427 break;
1428 case 'f':
1429 fs_location = arg_strtou64(optarg);
1430 break;
1431 case 'u':
1432 super_mirror = arg_strtou64(optarg);
1433 if (super_mirror >= BTRFS_SUPER_MIRROR_MAX) {
1434 fprintf(stderr, "Super mirror not "
1435 "valid\n");
1436 exit(1);
1437 }
1438 break;
1439 case 'd':
1440 find_dir = 1;
1441 break;
1442 case 'r':
1443 root_objectid = arg_strtou64(optarg);
1444 if (!is_fstree(root_objectid)) {
1445 fprintf(stderr, "objectid %llu is not a valid fs/file tree\n",
1446 root_objectid);
1447 exit(1);
1448 }
1449 break;
1450 case 'l':
1451 list_roots = 1;
1452 break;
1453 case 'm':
1454 restore_metadata = 1;
1455 break;
1456 case 'S':
1457 restore_symlinks = 1;
1458 break;
1459 case 'D':
1460 dry_run = 1;
1461 break;
1462 case 'c':
1463 match_cflags |= REG_ICASE;
1464 break;
1465 case GETOPT_VAL_PATH_REGEX:
1466 match_regstr = optarg;
1467 break;
1468 case 'x':
1469 get_xattrs = 1;
1470 break;
1471 default:
1472 usage(cmd_restore_usage);
1473 }
1474 }
1475
1476 if (!list_roots && check_argc_min(argc - optind, 2))
1477 usage(cmd_restore_usage);
1478 else if (list_roots && check_argc_min(argc - optind, 1))
1479 usage(cmd_restore_usage);
1480
1481 if (fs_location && root_objectid) {
1482 fprintf(stderr, "don't use -f and -r at the same time.\n");
1483 return 1;
1484 }
1485
1486 if ((ret = check_mounted(argv[optind])) < 0) {
1487 fprintf(stderr, "Could not check mount status: %s\n",
1488 strerror(-ret));
1489 return 1;
1490 } else if (ret) {
1491 fprintf(stderr, "%s is currently mounted. Aborting.\n", argv[optind]);
1492 return 1;
1493 }
1494
1495 root = open_fs(argv[optind], tree_location, super_mirror, list_roots);
1496 if (root == NULL)
1497 return 1;
1498
1499 if (list_roots)
1500 goto out;
1501
1502 if (fs_location != 0) {
1503 free_extent_buffer(root->node);
1504 root->node = read_tree_block(root->fs_info, fs_location,
1505 root->fs_info->nodesize, 0);
1506 if (!extent_buffer_uptodate(root->node)) {
1507 fprintf(stderr, "Failed to read fs location\n");
1508 ret = 1;
1509 goto out;
1510 }
1511 }
1512
1513 memset(path_name, 0, PATH_MAX);
1514
1515 if (strlen(argv[optind + 1]) >= PATH_MAX) {
1516 fprintf(stderr, "ERROR: path too long\n");
1517 ret = 1;
1518 goto out;
1519 }
1520 strncpy(dir_name, argv[optind + 1], sizeof dir_name);
1521 dir_name[sizeof dir_name - 1] = 0;
1522
1523 /* Strip the trailing / on the dir name */
1524 len = strlen(dir_name);
1525 while (len && dir_name[--len] == '/') {
1526 dir_name[len] = '\0';
1527 }
1528
1529 if (root_objectid != 0) {
1530 struct btrfs_root *orig_root = root;
1531
1532 key.objectid = root_objectid;
1533 key.type = BTRFS_ROOT_ITEM_KEY;
1534 key.offset = (u64)-1;
1535 root = btrfs_read_fs_root(orig_root->fs_info, &key);
1536 if (IS_ERR(root)) {
1537 fprintf(stderr, "fail to read root %llu: %s\n",
1538 root_objectid, strerror(-PTR_ERR(root)));
1539 root = orig_root;
1540 ret = 1;
1541 goto out;
1542 }
1543 key.type = 0;
1544 key.offset = 0;
1545 }
1546
1547 if (find_dir) {
1548 ret = find_first_dir(root, &key.objectid);
1549 if (ret)
1550 goto out;
1551 } else {
1552 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
1553 }
1554
1555 if (match_regstr) {
1556 ret = regcomp(&match_reg, match_regstr, match_cflags);
1557 if (ret) {
1558 regerror(ret, &match_reg, reg_err, sizeof(reg_err));
1559 fprintf(stderr, "Regex compile failed: %s\n", reg_err);
1560 goto out;
1561 }
1562 mreg = &match_reg;
1563 }
1564
1565 if (dry_run)
1566 printf("This is a dry-run, no files are going to be restored\n");
1567
1568 ret = search_dir(root, &key, dir_name, "", mreg);
1569
1570 out:
1571 if (mreg)
1572 regfree(mreg);
1573 close_ctree(root);
1574 return !!ret;
1575 }
(deprecated) Btrfs progs developments and patch integration