Patched btrfsck to allow rebuilding a superblock from an old tree / generation.

.gitignore

@@ -3,12 +3,16 @@
 version.h
 man/*.gz
 btrfs
+btrfs-corrupt-block
 btrfs-debug-tree
+btrfs-dump-super
 btrfs-map-logical
+btrfs-select-super
 btrfs-show
 btrfs-vol
 btrfsck
 btrfsctl
+calc-size
 find-root
 mkfs.btrfs
 repair

Makefile

@@ -1,6 +1,6 @@
 CC = gcc
 AM_CFLAGS = -Wall -D_FILE_OFFSET_BITS=64 -D_FORTIFY_SOURCE=2
-CFLAGS = -g -O0
+CFLAGS = -g -O0 -pthread
 objects = ctree.o disk-io.o radix-tree.o extent-tree.o print-tree.o \
 	  root-tree.o dir-item.o file-item.o inode-item.o \
 	  inode-map.o crc32c.o rbtree.o extent-cache.o extent_io.o \
@@ -14,10 +14,11 @@ INSTALL = install
 prefix ?= /usr/local
 bindir = $(prefix)/bin
 LIBS=-luuid
-RESTORE_LIBS=-lz
+RESTORE_LIBS=-lz -llzo2
 
 progs = btrfsctl mkfs.btrfs btrfs-debug-tree btrfs-show btrfs-vol btrfsck \
-	btrfs btrfs-map-logical restore find-root calc-size btrfs-corrupt-block
+	btrfs btrfs-map-logical restore find-root calc-size btrfs-corrupt-block \
+	btrfs-dump-super
 
 # make C=1 to enable sparse
 ifdef C
@@ -73,6 +74,9 @@ btrfs-zero-log: $(objects) btrfs-zero-log.o
 btrfs-select-super: $(objects) btrfs-select-super.o
 	$(CC) $(CFLAGS) -o btrfs-select-super $(objects) btrfs-select-super.o $(LDFLAGS) $(LIBS)
 
+btrfs-dump-super: $(objects) btrfs-dump-super.o
+	$(CC) $(CFLAGS) -o btrfs-dump-super $(objects) btrfs-dump-super.o $(LDFLAGS) $(LIBS)
+
 btrfstune: $(objects) btrfstune.o
 	$(CC) $(CFLAGS) -o btrfstune $(objects) btrfstune.o $(LDFLAGS) $(LIBS)
 
@@ -105,7 +109,8 @@ install-man:
 
 clean :
 	rm -f $(progs) cscope.out *.o .*.d btrfs-convert btrfs-image btrfs-select-super \
-	      btrfs-zero-log btrfstune dir-test ioctl-test quick-test version.h
+	      btrfs-dump-super btrfs-zero-log btrfstune dir-test ioctl-test quick-test \
+	      version.h
 	cd man; make clean
 
 install: $(progs) install-man

btrfs-dump-super.c

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2011 Google.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+
+#define _XOPEN_SOURCE 500
+#define _GNU_SOURCE 1
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include "kerncompat.h"
+#include "ctree.h"
+#include "disk-io.h"
+#include "version.h"
+
+static void print_usage(void)
+{
+	fprintf(stderr, "usage: btrfs-dump-super dev\n");
+	fprintf(stderr, "%s\n", BTRFS_BUILD_VERSION);
+	exit(1);
+}
+
+static int read_block(const char* filename,  u64 bytenr, struct btrfs_super_block* sb) {
+	int fd = open(filename, O_RDONLY, 0600);
+	int block_size = sizeof(struct btrfs_super_block);
+	int bytes_read = 0;
+
+	if (fd < 0) {
+		fprintf(stderr, "Could not open %s\n", filename);
+		return -1;
+	}
+
+	bytes_read = pread(fd, sb, block_size, bytenr);
+	if (bytes_read < block_size) {
+		fprintf(stderr, "Only read %d bytes of %d.\n", bytes_read, block_size);
+	}
+
+	close(fd);
+	return bytes_read;
+}
+
+int main(int ac, char **av)
+{
+	int i;
+
+	if (ac != 2)
+		print_usage();
+
+	for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
+		u64 bytenr = btrfs_sb_offset(i);
+		int fd;
+		struct btrfs_super_block sb;
+		int block_size = sizeof(struct btrfs_super_block);
+		char filename[1024];
+		int bytes_read = read_block(av[optind], bytenr, &sb);
+		if (bytes_read < block_size)
+			continue;
+
+		sprintf(filename, "/tmp/block.%s.%llu",
+			strrchr(av[optind], '/') + 1, bytenr);
+		fd = open(filename, O_CREAT|O_WRONLY, 0644);
+		if (block_size != pwrite(fd, &sb, block_size, 0)) {
+			fprintf(stderr, "Failed to dump superblock %d", i);
+			continue;
+		}
+		fprintf(stderr, "Dumped superblock %s:%d, gen %llu to %s.\n",
+			av[optind], i, sb.generation, filename);
+		close(fd);
+	}
+
+	return 0;
+}

btrfs-select-super.c

@@ -34,7 +34,9 @@
 
 static void print_usage(void)
 {
-	fprintf(stderr, "usage: btrfs-select-super -s number dev\n");
+	fprintf(stderr, "usage: btrfs-select-super [-c] [-e] -s number dev\n");
+	fprintf(stderr, "       -c Commit changes to disk [IRREVERSIBLE]\n");
+	fprintf(stderr, "       -e Use the earliest super found, may help recover transid verify problems\n");
 	fprintf(stderr, "%s\n", BTRFS_BUILD_VERSION);
 	exit(1);
 }
@@ -45,10 +47,13 @@ int main(int ac, char **av)
 	int ret;
 	int num;
 	u64 bytenr = 0;
+	int commit = 0;
+	int use_earliest_bdev = 0;
+	int fp;
 
 	while(1) {
 		int c;
-		c = getopt(ac, av, "s:");
+		c = getopt(ac, av, "s:ce");
 		if (c < 0)
 			break;
 		switch(c) {
@@ -58,6 +63,12 @@ int main(int ac, char **av)
 				printf("using SB copy %d, bytenr %llu\n", num,
 				       (unsigned long long)bytenr);
 				break;
+			case 'c':
+				commit = 1;
+				break;
+			case 'e':
+				use_earliest_bdev = 1;
+				break;
 			default:
 				print_usage();
 		}
@@ -74,22 +85,33 @@ int main(int ac, char **av)
 
 	radix_tree_init();
 
-	if((ret = check_mounted(av[optind])) < 0) {
+	if ((ret = check_mounted(av[optind])) < 0) {
 		fprintf(stderr, "Could not check mount status: %s\n", strerror(-ret));
 		return ret;
-	} else if(ret) {
+	} else if (ret) {
 		fprintf(stderr, "%s is currently mounted. Aborting.\n", av[optind]);
 		return -EBUSY;
 	}
 
-	root = open_ctree(av[optind], bytenr, 1);
+	fp = open(av[optind], O_CREAT|O_RDWR, 0600);
+	if (fp < 0) {
+		fprintf(stderr, "Could not open %s\n", av[optind]);
+		return 1;
+	}
+	root = open_ctree_fd(fp, av[optind], bytenr, 1, use_earliest_bdev);
 
 	if (root == NULL)
 		return 1;
 
-	/* make the super writing code think we've read the first super */
-	root->fs_info->super_bytenr = BTRFS_SUPER_INFO_OFFSET;
-	ret = write_all_supers(root);
+	fprintf(stderr, "Found superblock with generation %llu.\n", root->fs_info->super_copy.generation);
+
+	if (commit) {
+		fprintf(stderr, "Committing...\n");
+
+		/* make the super writing code think we've read the first super */
+		root->fs_info->super_bytenr = BTRFS_SUPER_INFO_OFFSET;
+		ret = write_all_supers(root);
+	}
 
 	/* we don't close the ctree or anything, because we don't want a real
 	 * transaction commit.  We just want the super copy we pulled off the

btrfs_cmds.c

@@ -613,7 +613,7 @@ int do_scan(int argc, char **argv)
 	if( argc >= 2 && !strcmp(argv[1],"--all-devices")){
 
 		if( argc >2 ){
-			fprintf(stderr, "ERROR: too may arguments\n");
+			fprintf(stderr, "ERROR: too many arguments\n");
                         return 22;
                 }
 

btrfsck.c

@@ -2800,7 +2800,7 @@ static int check_extents(struct btrfs_root *root)
 
 static void print_usage(void)
 {
-	fprintf(stderr, "usage: btrfsck dev\n");
+	fprintf(stderr, "usage: btrfsck [-s superblock] [-t tree root] [-g generation] dev\n");
 	fprintf(stderr, "%s\n", BTRFS_BUILD_VERSION);
 	exit(1);
 }
@@ -2810,12 +2810,15 @@ int main(int ac, char **av)
 	struct cache_tree root_cache;
 	struct btrfs_root *root;
 	u64 bytenr = 0;
+	u64 root_tree_bytenr = 0;
+	u64 root_tree_generation = 0;
 	int ret;
 	int num;
-
+	int writes=0;
+
 	while(1) {
 		int c;
-		c = getopt(ac, av, "s:");
+		c = getopt(ac, av, "s:t:g:c");
 		if (c < 0)
 			break;
 		switch(c) {
@@ -2825,6 +2828,17 @@ int main(int ac, char **av)
 				printf("using SB copy %d, bytenr %llu\n", num,
 				       (unsigned long long)bytenr);
 				break;
+			case 't':
+				root_tree_bytenr = atoll(optarg);
+				printf("Using root tree %llu\n", root_tree_bytenr);
+				break;
+			case 'g':
+				root_tree_generation = atoll(optarg);
+				printf("Using generation %llu\n", root_tree_generation);
+				break;
+			case 'c':
+				writes=1;
+				break;
 			default:
 				print_usage();
 		}
@@ -2845,18 +2859,22 @@ int main(int ac, char **av)
 		return -EBUSY;
 	}
 
-	root = open_ctree(av[optind], bytenr, 0);
+	root = open_ctree_recovery(av[optind], bytenr, root_tree_bytenr, root_tree_generation, writes);
 
 	if (root == NULL)
 		return 1;
 
+	printf("Checking extents...\n");
 	ret = check_extents(root);
 	if (ret)
 		goto out;
+
+	printf("Checking fs roots...\n");
 	ret = check_fs_roots(root, &root_cache);
 	if (ret)
 		goto out;
 
+	printf("Checking root references...\n");
 	ret = check_root_refs(root, &root_cache);
 out:
 	free_root_recs(&root_cache);

convert.c

@@ -2386,7 +2386,7 @@ int do_convert(const char *devname, int datacsum, int packing, int noxattr)
 		fprintf(stderr, "unable to update system chunk\n");
 		goto fail;
 	}
-	root = open_ctree_fd(fd, devname, super_bytenr, O_RDWR);
+	root = open_ctree_fd(fd, devname, super_bytenr, O_RDWR, 0);
 	if (!root) {
 		fprintf(stderr, "unable to open ctree\n");
 		goto fail;
@@ -2447,7 +2447,7 @@ int do_convert(const char *devname, int datacsum, int packing, int noxattr)
 		goto fail;
 	}
 
-	root = open_ctree_fd(fd, devname, 0, O_RDWR);
+	root = open_ctree_fd(fd, devname, 0, O_RDWR, 0);
 	if (!root) {
 		fprintf(stderr, "unable to open ctree\n");
 		goto fail;
@@ -2546,7 +2546,7 @@ int do_rollback(const char *devname, int force)
 		fprintf(stderr, "unable to open %s\n", devname);
 		goto fail;
 	}
-	root = open_ctree_fd(fd, devname, 0, O_RDWR);
+	root = open_ctree_fd(fd, devname, 0, O_RDWR, 0);
 	if (!root) {
 		fprintf(stderr, "unable to open ctree\n");
 		goto fail;