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 0.19-10 +- fix dso linking issue and bring btrfs-progs uptodate with upstream + * Tue Feb 2 2010 Josef Bacik 0.19-9 - fix btrfsck so it builds on newer glibcs