diff --git a/btrfs-progs-upstream.patch b/btrfs-progs-upstream.patch
new file mode 100644
index 0000000..3186e28
--- /dev/null
+++ b/btrfs-progs-upstream.patch
@@ -0,0 +1,767 @@
+diff --git a/btrfsck.c b/btrfsck.c
+index 40c90f8..73f1836 100644
+--- a/btrfsck.c
++++ b/btrfsck.c
+@@ -36,7 +36,7 @@ static u64 total_fs_tree_bytes = 0;
+ static u64 btree_space_waste = 0;
+ static u64 data_bytes_allocated = 0;
+ static u64 data_bytes_referenced = 0;
+-int found_old_backref = 0;
++static int found_old_backref = 0;
+ 
+ struct extent_backref {
+ 	struct list_head list;
+@@ -100,7 +100,11 @@ struct inode_backref {
+ #define REF_ERR_DUP_INODE_REF		(1 << 5)
+ #define REF_ERR_INDEX_UNMATCH		(1 << 6)
+ #define REF_ERR_FILETYPE_UNMATCH	(1 << 7)
+-#define REF_ERR_NAME_TOO_LONG		(1 << 8)
++#define REF_ERR_NAME_TOO_LONG		(1 << 8) // 100
++#define REF_ERR_NO_ROOT_REF		(1 << 9)
++#define REF_ERR_NO_ROOT_BACKREF		(1 << 10)
++#define REF_ERR_DUP_ROOT_REF		(1 << 11)
++#define REF_ERR_DUP_ROOT_BACKREF	(1 << 12)
+ 
+ struct inode_record {
+ 	struct list_head backrefs;
+@@ -144,6 +148,29 @@ struct inode_record {
+ #define I_ERR_SOME_CSUM_MISSING		(1 << 12)
+ #define I_ERR_LINK_COUNT_WRONG		(1 << 13)
+ 
++struct root_backref {
++	struct list_head list;
++	unsigned int found_dir_item:1;
++	unsigned int found_dir_index:1;
++	unsigned int found_back_ref:1;
++	unsigned int found_forward_ref:1;
++	unsigned int reachable:1;
++	int errors;
++	u64 ref_root;
++	u64 dir;
++	u64 index;
++	u16 namelen;
++	char name[0];
++};
++
++struct root_record {
++	struct list_head backrefs;
++	struct cache_extent cache;
++	unsigned int found_root_item:1;
++	u64 objectid;
++	u32 found_ref;
++};
++
+ struct ptr_node {
+ 	struct cache_extent cache;
+ 	void *data;
+@@ -151,6 +178,7 @@ struct ptr_node {
+ 
+ struct shared_node {
+ 	struct cache_extent cache;
++	struct cache_tree root_cache;
+ 	struct cache_tree inode_cache;
+ 	struct inode_record *current;
+ 	u32 refs;
+@@ -258,6 +286,14 @@ static void free_inode_rec(struct inode_record *rec)
+ 	free(rec);
+ }
+ 
++static int can_free_inode_rec(struct inode_record *rec)
++{
++	if (!rec->errors && rec->checked && rec->found_inode_item &&
++	    rec->nlink == rec->found_link && list_empty(&rec->backrefs))
++		return 1;
++	return 0;
++}
++
+ static void maybe_free_inode_rec(struct cache_tree *inode_cache,
+ 				 struct inode_record *rec)
+ {
+@@ -309,8 +345,7 @@ static void maybe_free_inode_rec(struct cache_tree *inode_cache,
+ 	}
+ 
+ 	BUG_ON(rec->refs != 1);
+-	if (!rec->errors && rec->nlink == rec->found_link &&
+-	    list_empty(&rec->backrefs)) {
++	if (can_free_inode_rec(rec)) {
+ 		cache = find_cache_extent(inode_cache, rec->ino, 1);
+ 		node = container_of(cache, struct ptr_node, cache);
+ 		BUG_ON(node->data != rec);
+@@ -338,14 +373,12 @@ static int check_orphan_item(struct btrfs_root *root, u64 ino)
+ 	return ret;
+ }
+ 
+-static int process_inode_item(struct btrfs_root *root,
+-			      struct extent_buffer *eb,
++static int process_inode_item(struct extent_buffer *eb,
+ 			      int slot, struct btrfs_key *key,
+ 			      struct shared_node *active_node)
+ {
+ 	struct inode_record *rec;
+ 	struct btrfs_inode_item *item;
+-	int ret;
+ 
+ 	rec = active_node->current;
+ 	BUG_ON(rec->ino != key->objectid || rec->refs > 1);
+@@ -361,11 +394,8 @@ static int process_inode_item(struct btrfs_root *root,
+ 	if (btrfs_inode_flags(eb, item) & BTRFS_INODE_NODATASUM)
+ 		rec->nodatasum = 1;
+ 	rec->found_inode_item = 1;
+-	if (rec->nlink == 0) {
+-		ret = check_orphan_item(root, rec->ino);
+-		if (ret == -ENOENT)
+-			rec->errors |= I_ERR_NO_ORPHAN_ITEM;
+-	}
++	if (rec->nlink == 0)
++		rec->errors |= I_ERR_NO_ORPHAN_ITEM;
+ 	maybe_free_inode_rec(&active_node->inode_cache, rec);
+ 	return 0;
+ }
+@@ -443,10 +473,9 @@ static int add_inode_backref(struct cache_tree *inode_cache,
+ }
+ 
+ static int merge_inode_recs(struct inode_record *src, struct inode_record *dst,
+-			    struct shared_node *dst_node)
++			    struct cache_tree *dst_cache)
+ {
+ 	struct inode_backref *backref;
+-	struct cache_tree *dst_cache = &dst_node->inode_cache;
+ 
+ 	dst->merging = 1;
+ 	list_for_each_entry(backref, &src->backrefs, list) {
+@@ -510,14 +539,8 @@ static int merge_inode_recs(struct inode_record *src, struct inode_record *dst,
+ 			dst->errors |= I_ERR_DUP_INODE_ITEM;
+ 		}
+ 	}
+-
+-	if (src->checked) {
+-		dst->checked = 1;
+-		if (dst_node->current == dst)
+-			dst_node->current = NULL;
+-	}
+ 	dst->merging = 0;
+-	maybe_free_inode_rec(dst_cache, dst);
++
+ 	return 0;
+ }
+ 
+@@ -537,8 +560,9 @@ static int splice_shared_node(struct shared_node *src_node,
+ 	if (src_node->current)
+ 		current_ino = src_node->current->ino;
+ 
+-	src = &src_node->inode_cache;
+-	dst = &dst_node->inode_cache;
++	src = &src_node->root_cache;
++	dst = &dst_node->root_cache;
++again:
+ 	cache = find_first_cache_extent(src, 0);
+ 	while (cache) {
+ 		node = container_of(cache, struct ptr_node, cache);
+@@ -557,14 +581,28 @@ static int splice_shared_node(struct shared_node *src_node,
+ 		}
+ 		ret = insert_existing_cache_extent(dst, &ins->cache);
+ 		if (ret == -EEXIST) {
++			WARN_ON(src == &src_node->root_cache);
+ 			conflict = get_inode_rec(dst, rec->ino, 1);
+-			merge_inode_recs(rec, conflict, dst_node);
++			merge_inode_recs(rec, conflict, dst);
++			if (rec->checked) {
++				conflict->checked = 1;
++				if (dst_node->current == conflict)
++					dst_node->current = NULL;
++			}
++			maybe_free_inode_rec(dst, conflict);
+ 			free_inode_rec(rec);
+ 			free(ins);
+ 		} else {
+ 			BUG_ON(ret);
+ 		}
+ 	}
++
++	if (src == &src_node->root_cache) {
++		src = &src_node->inode_cache;
++		dst = &dst_node->inode_cache;
++		goto again;
++	}
++
+ 	if (current_ino > 0 && (!dst_node->current ||
+ 	    current_ino > dst_node->current->ino)) {
+ 		if (dst_node->current) {
+@@ -616,6 +654,7 @@ static int add_shared_node(struct cache_tree *shared, u64 bytenr, u32 refs)
+ 	node = calloc(1, sizeof(*node));
+ 	node->cache.start = bytenr;
+ 	node->cache.size = 1;
++	cache_tree_init(&node->root_cache);
+ 	cache_tree_init(&node->inode_cache);
+ 	node->refs = refs;
+ 
+@@ -646,6 +685,7 @@ static int enter_shared_node(struct btrfs_root *root, u64 bytenr, u32 refs,
+ 	if (wc->root_level == wc->active_node &&
+ 	    btrfs_root_refs(&root->root_item) == 0) {
+ 		if (--node->refs == 0) {
++			free_inode_recs(&node->root_cache);
+ 			free_inode_recs(&node->inode_cache);
+ 			remove_cache_extent(&wc->shared, &node->cache);
+ 			free(node);
+@@ -708,10 +748,12 @@ static int process_dir_item(struct extent_buffer *eb,
+ 	int filetype;
+ 	struct btrfs_dir_item *di;
+ 	struct inode_record *rec;
++	struct cache_tree *root_cache;
+ 	struct cache_tree *inode_cache;
+ 	struct btrfs_key location;
+ 	char namebuf[BTRFS_NAME_LEN];
+ 
++	root_cache = &active_node->root_cache;
+ 	inode_cache = &active_node->inode_cache;
+ 	rec = active_node->current;
+ 	rec->found_dir_item = 1;
+@@ -740,7 +782,9 @@ static int process_dir_item(struct extent_buffer *eb,
+ 					  key->objectid, key->offset, namebuf,
+ 					  len, filetype, key->type, error);
+ 		} else if (location.type == BTRFS_ROOT_ITEM_KEY) {
+-			/* fixme: check root back & forward references */
++			add_inode_backref(root_cache, location.objectid,
++					  key->objectid, key->offset, namebuf,
++					  len, filetype, key->type, error);
+ 		} else {
+ 			fprintf(stderr, "warning line %d\n", __LINE__);
+ 		}
+@@ -977,8 +1021,7 @@ static int process_one_leaf(struct btrfs_root *root, struct extent_buffer *eb,
+ 			ret = process_inode_ref(eb, i, &key, active_node);
+ 			break;
+ 		case BTRFS_INODE_ITEM_KEY:
+-			ret = process_inode_item(root, eb, i, &key,
+-						 active_node);
++			ret = process_inode_item(eb, i, &key, active_node);
+ 			break;
+ 		case BTRFS_EXTENT_DATA_KEY:
+ 			ret = process_file_extent(root, eb, i, &key,
+@@ -1176,13 +1219,23 @@ static int check_inode_recs(struct btrfs_root *root,
+ 		node = container_of(cache, struct ptr_node, cache);
+ 		rec = node->data;
+ 		remove_cache_extent(inode_cache, &node->cache);
++		free(node);
+ 		if (rec->ino == root_dirid ||
+ 		    rec->ino == BTRFS_ORPHAN_OBJECTID) {
+-			free(node);
+ 			free_inode_rec(rec);
+ 			continue;
+ 		}
+ 
++		if (rec->errors & I_ERR_NO_ORPHAN_ITEM) {
++			ret = check_orphan_item(root, rec->ino);
++			if (ret == 0)
++				rec->errors &= ~I_ERR_NO_ORPHAN_ITEM;
++			if (can_free_inode_rec(rec)) {
++				free_inode_rec(rec);
++				continue;
++			}
++		}
++
+ 		error++;
+ 		if (!rec->found_inode_item)
+ 			rec->errors |= I_ERR_NO_INODE_ITEM;
+@@ -1205,13 +1258,314 @@ static int check_inode_recs(struct btrfs_root *root,
+ 				backref->namelen, backref->name,
+ 				backref->filetype, backref->errors);
+ 		}
+-		free(node);
+ 		free_inode_rec(rec);
+ 	}
+ 	return (error > 0) ? -1 : 0;
+ }
+ 
++static struct root_record *get_root_rec(struct cache_tree *root_cache,
++					u64 objectid)
++{
++	struct cache_extent *cache;
++	struct root_record *rec = NULL;
++	int ret;
++
++	cache = find_cache_extent(root_cache, objectid, 1);
++	if (cache) {
++		rec = container_of(cache, struct root_record, cache);
++	} else {
++		rec = calloc(1, sizeof(*rec));
++		rec->objectid = objectid;
++		INIT_LIST_HEAD(&rec->backrefs);
++		rec->cache.start = objectid;
++		rec->cache.size = 1;
++
++		ret = insert_existing_cache_extent(root_cache, &rec->cache);
++		BUG_ON(ret);
++	}
++	return rec;
++}
++
++static struct root_backref *get_root_backref(struct root_record *rec,
++					     u64 ref_root, u64 dir, u64 index,
++					     const char *name, int namelen)
++{
++	struct root_backref *backref;
++
++	list_for_each_entry(backref, &rec->backrefs, list) {
++		if (backref->ref_root != ref_root || backref->dir != dir ||
++		    backref->namelen != namelen)
++			continue;
++		if (memcmp(name, backref->name, namelen))
++			continue;
++		return backref;
++	}
++
++	backref = malloc(sizeof(*backref) + namelen + 1);
++	memset(backref, 0, sizeof(*backref));
++	backref->ref_root = ref_root;
++	backref->dir = dir;
++	backref->index = index;
++	backref->namelen = namelen;
++	memcpy(backref->name, name, namelen);
++	backref->name[namelen] = '\0';
++	list_add_tail(&backref->list, &rec->backrefs);
++	return backref;
++}
++
++static void free_root_recs(struct cache_tree *root_cache)
++{
++	struct cache_extent *cache;
++	struct root_record *rec;
++	struct root_backref *backref;
++
++	while (1) {
++		cache = find_first_cache_extent(root_cache, 0);
++		if (!cache)
++			break;
++		rec = container_of(cache, struct root_record, cache);
++		remove_cache_extent(root_cache, &rec->cache);
++
++		while (!list_empty(&rec->backrefs)) {
++			backref = list_entry(rec->backrefs.next,
++					     struct root_backref, list);
++			list_del(&backref->list);
++			free(backref);
++		}
++		kfree(rec);
++	}
++}
++
++static int add_root_backref(struct cache_tree *root_cache,
++			    u64 root_id, u64 ref_root, u64 dir, u64 index,
++			    const char *name, int namelen,
++			    int item_type, int errors)
++{
++	struct root_record *rec;
++	struct root_backref *backref;
++
++	rec = get_root_rec(root_cache, root_id);
++	backref = get_root_backref(rec, ref_root, dir, index, name, namelen);
++
++	backref->errors |= errors;
++
++	if (item_type != BTRFS_DIR_ITEM_KEY) {
++		if (backref->found_dir_index || backref->found_back_ref ||
++		    backref->found_forward_ref) {
++			if (backref->index != index)
++				backref->errors |= REF_ERR_INDEX_UNMATCH;
++		} else {
++			backref->index = index;
++		}
++	}
++
++	if (item_type == BTRFS_DIR_ITEM_KEY) {
++		backref->found_dir_item = 1;
++		backref->reachable = 1;
++		rec->found_ref++;
++	} else if (item_type == BTRFS_DIR_INDEX_KEY) {
++		backref->found_dir_index = 1;
++	} else if (item_type == BTRFS_ROOT_REF_KEY) {
++		if (backref->found_forward_ref)
++			backref->errors |= REF_ERR_DUP_ROOT_REF;
++		backref->found_forward_ref = 1;
++	} else if (item_type == BTRFS_ROOT_BACKREF_KEY) {
++		if (backref->found_back_ref)
++			backref->errors |= REF_ERR_DUP_ROOT_BACKREF;
++		backref->found_back_ref = 1;
++	} else {
++		BUG_ON(1);
++	}
++
++	return 0;
++}
++
++static int merge_root_recs(struct btrfs_root *root,
++			   struct cache_tree *src_cache,
++			   struct cache_tree *dst_cache)
++{
++	struct cache_extent *cache;
++	struct ptr_node *node;
++	struct inode_record *rec;
++	struct inode_backref *backref;
++
++	if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
++		free_inode_recs(src_cache);
++		return 0;
++	}
++
++	while (1) {
++		cache = find_first_cache_extent(src_cache, 0);
++		if (!cache)
++			break;
++		node = container_of(cache, struct ptr_node, cache);
++		rec = node->data;
++		remove_cache_extent(src_cache, &node->cache);
++		free(node);
++
++		list_for_each_entry(backref, &rec->backrefs, list) {
++			BUG_ON(backref->found_inode_ref);
++			if (backref->found_dir_item)
++				add_root_backref(dst_cache, rec->ino,
++					root->root_key.objectid, backref->dir,
++					backref->index, backref->name,
++					backref->namelen, BTRFS_DIR_ITEM_KEY,
++					backref->errors);
++			if (backref->found_dir_index)
++				add_root_backref(dst_cache, rec->ino,
++					root->root_key.objectid, backref->dir,
++					backref->index, backref->name,
++					backref->namelen, BTRFS_DIR_INDEX_KEY,
++					backref->errors);
++		}
++		free_inode_rec(rec);
++	}
++	return 0;
++}
++
++static int check_root_refs(struct btrfs_root *root,
++			   struct cache_tree *root_cache)
++{
++	struct root_record *rec;
++	struct root_record *ref_root;
++	struct root_backref *backref;
++	struct cache_extent *cache;
++	int loop = 1;
++	int ret;
++	int error;
++	int errors = 0;
++
++	rec = get_root_rec(root_cache, BTRFS_FS_TREE_OBJECTID);
++	rec->found_ref = 1;
++
++	/* fixme: this can not detect circular references */
++	while (loop) {
++		loop = 0;
++		cache = find_first_cache_extent(root_cache, 0);
++		while (1) {
++			if (!cache)
++				break;
++			rec = container_of(cache, struct root_record, cache);
++			cache = next_cache_extent(cache);
++
++			if (rec->found_ref == 0)
++				continue;
++
++			list_for_each_entry(backref, &rec->backrefs, list) {
++				if (!backref->reachable)
++					continue;
++
++				ref_root = get_root_rec(root_cache,
++							backref->ref_root);
++				if (ref_root->found_ref > 0)
++					continue;
++
++				backref->reachable = 0;
++				rec->found_ref--;
++				if (rec->found_ref == 0)
++					loop = 1;
++			}
++		}
++	}
++
++	cache = find_first_cache_extent(root_cache, 0);
++	while (1) {
++		if (!cache)
++			break;
++		rec = container_of(cache, struct root_record, cache);
++		cache = next_cache_extent(cache);
++
++		if (rec->found_ref == 0 &&
++		    rec->objectid >= BTRFS_FIRST_FREE_OBJECTID &&
++		    rec->objectid <= BTRFS_LAST_FREE_OBJECTID) {
++			ret = check_orphan_item(root->fs_info->tree_root,
++						rec->objectid);
++			if (ret == 0)
++				continue;
++			errors++;
++			fprintf(stderr, "fs tree %llu not referenced\n",
++				(unsigned long long)rec->objectid);
++		}
++
++		error = 0;
++		if (rec->found_ref > 0 && !rec->found_root_item)
++			error = 1;
++		list_for_each_entry(backref, &rec->backrefs, list) {
++			if (!backref->found_dir_item)
++				backref->errors |= REF_ERR_NO_DIR_ITEM;
++			if (!backref->found_dir_index)
++				backref->errors |= REF_ERR_NO_DIR_INDEX;
++			if (!backref->found_back_ref)
++				backref->errors |= REF_ERR_NO_ROOT_BACKREF;
++			if (!backref->found_forward_ref)
++				backref->errors |= REF_ERR_NO_ROOT_REF;
++			if (backref->reachable && backref->errors)
++				error = 1;
++		}
++		if (!error)
++			continue;
++
++		errors++;
++		fprintf(stderr, "fs tree %llu refs %u %s\n",
++			(unsigned long long)rec->objectid, rec->found_ref,
++			 rec->found_root_item ? "" : "not found");
++
++		list_for_each_entry(backref, &rec->backrefs, list) {
++			if (!backref->reachable)
++				continue;
++			if (!backref->errors && rec->found_root_item)
++				continue;
++			fprintf(stderr, "\tunresolved ref root %llu dir %llu"
++				" index %llu namelen %u name %s error %x\n",
++				(unsigned long long)backref->ref_root,
++				(unsigned long long)backref->dir,
++				(unsigned long long)backref->index,
++				backref->namelen, backref->name,
++				backref->errors);
++		}
++	}
++	return errors > 0 ? 1 : 0;
++}
++
++static int process_root_ref(struct extent_buffer *eb, int slot,
++			    struct btrfs_key *key,
++			    struct cache_tree *root_cache)
++{
++	u64 dirid;
++	u64 index;
++	u32 len;
++	u32 name_len;
++	struct btrfs_root_ref *ref;
++	char namebuf[BTRFS_NAME_LEN];
++	int error;
++
++	ref = btrfs_item_ptr(eb, slot, struct btrfs_root_ref);
++
++	dirid = btrfs_root_ref_dirid(eb, ref);
++	index = btrfs_root_ref_sequence(eb, ref);
++	name_len = btrfs_root_ref_name_len(eb, ref);
++
++	if (name_len <= BTRFS_NAME_LEN) {
++		len = name_len;
++		error = 0;
++	} else {
++		len = BTRFS_NAME_LEN;
++		error = REF_ERR_NAME_TOO_LONG;
++	}
++	read_extent_buffer(eb, namebuf, (unsigned long)(ref + 1), len);
++
++	if (key->type == BTRFS_ROOT_REF_KEY) {
++		add_root_backref(root_cache, key->offset, key->objectid, dirid,
++				 index, namebuf, len, key->type, error);
++	} else {
++		add_root_backref(root_cache, key->objectid, key->offset, dirid,
++				 index, namebuf, len, key->type, error);
++	}
++	return 0;
++}
++
+ static int check_fs_root(struct btrfs_root *root,
++			 struct cache_tree *root_cache,
+ 			 struct walk_control *wc)
+ {
+ 	int ret = 0;
+@@ -1219,10 +1573,18 @@ static int check_fs_root(struct btrfs_root *root,
+ 	int level;
+ 	struct btrfs_path path;
+ 	struct shared_node root_node;
++	struct root_record *rec;
+ 	struct btrfs_root_item *root_item = &root->root_item;
+ 
++	if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
++		rec = get_root_rec(root_cache, root->root_key.objectid);
++		if (btrfs_root_refs(root_item) > 0)
++			rec->found_root_item = 1;
++	}
++
+ 	btrfs_init_path(&path);
+ 	memset(&root_node, 0, sizeof(root_node));
++	cache_tree_init(&root_node.root_cache);
+ 	cache_tree_init(&root_node.inode_cache);
+ 
+ 	level = btrfs_header_level(root->node);
+@@ -1266,6 +1628,8 @@ static int check_fs_root(struct btrfs_root *root,
+ 	}
+ 	btrfs_release_path(root, &path);
+ 
++	merge_root_recs(root, &root_node.root_cache, root_cache);
++
+ 	if (root_node.current) {
+ 		root_node.current->checked = 1;
+ 		maybe_free_inode_rec(&root_node.inode_cache,
+@@ -1280,13 +1644,15 @@ static int fs_root_objectid(u64 objectid)
+ {
+ 	if (objectid == BTRFS_FS_TREE_OBJECTID ||
+ 	    objectid == BTRFS_TREE_RELOC_OBJECTID ||
++	    objectid == BTRFS_DATA_RELOC_TREE_OBJECTID ||
+ 	    (objectid >= BTRFS_FIRST_FREE_OBJECTID &&
+-	     objectid < BTRFS_LAST_FREE_OBJECTID))
++	     objectid <= BTRFS_LAST_FREE_OBJECTID))
+ 		return 1;
+ 	return 0;
+ }
+ 
+-static int check_fs_roots(struct btrfs_root *root)
++static int check_fs_roots(struct btrfs_root *root,
++			  struct cache_tree *root_cache)
+ {
+ 	struct btrfs_path path;
+ 	struct btrfs_key key;
+@@ -1319,10 +1685,14 @@ static int check_fs_roots(struct btrfs_root *root)
+ 		    fs_root_objectid(key.objectid)) {
+ 			tmp_root = btrfs_read_fs_root_no_cache(root->fs_info,
+ 							       &key);
+-			ret = check_fs_root(tmp_root, &wc);
++			ret = check_fs_root(tmp_root, root_cache, &wc);
+ 			if (ret)
+ 				err = 1;
+ 			btrfs_free_fs_root(root->fs_info, tmp_root);
++		} else if (key.type == BTRFS_ROOT_REF_KEY ||
++			   key.type == BTRFS_ROOT_BACKREF_KEY) {
++			process_root_ref(leaf, path.slots[0], &key,
++					 root_cache);
+ 		}
+ 		path.slots[0]++;
+ 	}
+@@ -1895,7 +2265,6 @@ static int add_data_backref(struct cache_tree *extent_cache, u64 bytenr,
+ 	return 0;
+ }
+ 
+-
+ static int add_pending(struct cache_tree *pending,
+ 		       struct cache_tree *seen, u64 bytenr, u32 size)
+ {
+@@ -2443,6 +2812,7 @@ static void print_usage(void)
+ 
+ int main(int ac, char **av)
+ {
++	struct cache_tree root_cache;
+ 	struct btrfs_root *root;
+ 	int ret;
+ 
+@@ -2450,6 +2820,7 @@ int main(int ac, char **av)
+ 		print_usage();
+ 
+ 	radix_tree_init();
++	cache_tree_init(&root_cache);
+ 	root = open_ctree(av[1], 0, 0);
+ 
+ 	if (root == NULL)
+@@ -2458,10 +2829,15 @@ int main(int ac, char **av)
+ 	ret = check_extents(root);
+ 	if (ret)
+ 		goto out;
+-	ret = check_fs_roots(root);
++	ret = check_fs_roots(root, &root_cache);
++	if (ret)
++		goto out;
+ 
++	ret = check_root_refs(root, &root_cache);
+ out:
++	free_root_recs(&root_cache);
+ 	close_ctree(root);
++
+ 	if (found_old_backref) {
+ 		/*
+ 		 * there was a disk format change when mixed
+diff --git a/btrfsctl.c b/btrfsctl.c
+index b323818..66c4e89 100644
+--- a/btrfsctl.c
++++ b/btrfsctl.c
+@@ -46,7 +46,7 @@ static inline int ioctl(int fd, int define, void *arg) { return 0; }
+ static void print_usage(void)
+ {
+ 	printf("usage: btrfsctl [ -d file|dir] [ -s snap_name subvol|tree ]\n");
+-	printf("                [-r size] [-A device] [-a] [-c]\n");
++	printf("                [-r size] [-A device] [-a] [-c] [-D dir .]\n");
+ 	printf("\t-d filename: defragments one file\n");
+ 	printf("\t-d directory: defragments the entire Btree\n");
+ 	printf("\t-s snap_name dir: creates a new snapshot of dir\n");
+@@ -55,6 +55,7 @@ static void print_usage(void)
+ 	printf("\t-A device: scans the device file for a Btrfs filesystem\n");
+ 	printf("\t-a: scans all devices for Btrfs filesystems\n");
+ 	printf("\t-c: forces a single FS sync\n");
++	printf("\t-D: delete snapshot\n");
+ 	printf("%s\n", BTRFS_BUILD_VERSION);
+ 	exit(1);
+ }
+@@ -158,6 +159,18 @@ int main(int ac, char **av)
+ 				print_usage();
+ 			}
+ 			command = BTRFS_IOC_DEFRAG;
++		} else if (strcmp(av[i], "-D") == 0) {
++			if (i >= ac - 1) {
++				fprintf(stderr, "-D requires an arg\n");
++				print_usage();
++			}
++			command = BTRFS_IOC_SNAP_DESTROY;
++			name = av[i + 1];
++			len = strlen(name);
++			if (len == 0 || len >= BTRFS_VOL_NAME_MAX) {
++				fprintf(stderr, "-D size too long\n");
++				exit(1);
++			}
+ 		} else if (strcmp(av[i], "-A") == 0) {
+ 			if (i >= ac - 1) {
+ 				fprintf(stderr, "-A requires an arg\n");
+diff --git a/convert.c b/convert.c
+index d2c9efa..d037c98 100644
+--- a/convert.c
++++ b/convert.c
+@@ -370,7 +370,6 @@ static int record_file_extent(struct btrfs_trans_handle *trans,
+ 	struct btrfs_extent_item *ei;
+ 	u32 blocksize = root->sectorsize;
+ 	u64 nbytes;
+-	u64 bytes_used;
+ 
+ 	if (disk_bytenr == 0) {
+ 		ret = btrfs_insert_file_extent(trans, root, objectid,
+@@ -432,9 +431,6 @@ static int record_file_extent(struct btrfs_trans_handle *trans,
+ 	nbytes = btrfs_stack_inode_nbytes(inode) + num_bytes;
+ 	btrfs_set_stack_inode_nbytes(inode, nbytes);
+ 
+-	bytes_used = btrfs_root_used(&root->root_item);
+-	btrfs_set_root_used(&root->root_item, bytes_used + num_bytes);
+-
+ 	btrfs_release_path(root, &path);
+ 
+ 	ins_key.objectid = disk_bytenr;
+@@ -454,9 +450,6 @@ static int record_file_extent(struct btrfs_trans_handle *trans,
+ 
+ 		btrfs_mark_buffer_dirty(leaf);
+ 
+-		bytes_used = btrfs_super_bytes_used(&info->super_copy);
+-		btrfs_set_super_bytes_used(&info->super_copy, bytes_used +
+-					   num_bytes);
+ 		ret = btrfs_update_block_group(trans, root, disk_bytenr,
+ 					       num_bytes, 1, 0);
+ 		if (ret)
+diff --git a/ioctl.h b/ioctl.h
+index a084f33..4410ac0 100644
+--- a/ioctl.h
++++ b/ioctl.h
+@@ -56,4 +56,7 @@ struct btrfs_ioctl_vol_args {
+ /* 13 is for CLONE_RANGE */
+ #define BTRFS_IOC_SUBVOL_CREATE _IOW(BTRFS_IOCTL_MAGIC, 14, \
+ 				   struct btrfs_ioctl_vol_args)
++
++#define BTRFS_IOC_SNAP_DESTROY _IOW(BTRFS_IOCTL_MAGIC, 15, \
++				   struct btrfs_ioctl_vol_args)
+ #endif
diff --git a/btrfs-progs.spec b/btrfs-progs.spec
index 5af6729..5b2286b 100644
--- a/btrfs-progs.spec
+++ b/btrfs-progs.spec
@@ -1,6 +1,6 @@
 Name:           btrfs-progs
 Version:        0.19
-Release:        9%{?dist}
+Release:        10%{?dist}
 Summary:        Userspace programs for btrfs
 
 Group:          System Environment/Base
@@ -12,6 +12,7 @@ Patch1: btrfs-progs-build-everything.patch
 Patch2: btrfs-progs-valgrind.patch
 Patch3: btrfs-progs-fix-return-value.patch
 Patch4: btrfs-progs-build-fixes.patch
+Patch5: btrfs-progs-upstream.patch
 BuildRoot:      %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)
 
 BuildRequires:  e2fsprogs-devel, libuuid-devel, zlib-devel, libacl-devel
@@ -29,10 +30,11 @@ check, modify and correct any inconsistencies in the btrfs filesystem.
 %patch2 -p1
 %patch3 -p1
 %patch4 -p1
+%patch5 -p1
 
 %build
 make CFLAGS="$RPM_OPT_FLAGS" %{?_smp_mflags}
-make CFLAGS="$RPM_OPT_FLAGS" %{?_smp_mflags} convert
+make CFLAGS="$RPM_OPT_FLAGS" %{?_smp_mflags} LDFLAGS="-lcom_err" convert
 
 %install
 rm -rf $RPM_BUILD_ROOT
@@ -60,6 +62,9 @@ rm -rf $RPM_BUILD_ROOT
 %{_mandir}/man8/mkfs.btrfs.8.gz
 
 %changelog
+* Thu Mar 11 2010 Josef Bacik <josef@toxicpanda.com> 0.19-10
+- fix dso linking issue and bring btrfs-progs uptodate with upstream
+
 * Tue Feb 2 2010 Josef Bacik <josef@toxicpanda.com> 0.19-9
 - fix btrfsck so it builds on newer glibcs