Since we're moving tons of code, it's a good idea to fix all errors and
warnings from checkpatch.
Note: we don't rely on checkpatch, take its warnings and errors as a
hint and do not blindly fix anything that gets reported. The code
follows some style that should be kept and is not in 100% with
what checkpatch finds. Always apply your common sense and decide
if the change makes sense or if it is really making the code
better.
Additional fixes from dsterba:
- %Lu -> %llu
- lowercase first word or messages
Signed-off-by: Qu Wenruo <wqu@suse.com>
[ added note ]
Signed-off-by: David Sterba <dsterba@suse.com>
need_research = 0;
btrfs_release_path(path);
ret = btrfs_search_slot(NULL, root, ref_key, path, 0, 0);
need_research = 0;
btrfs_release_path(path);
ret = btrfs_search_slot(NULL, root, ref_key, path, 0, 0);
- /* the item was deleted, let path point to the last checked item */
+ /*
+ * The item was deleted, let the path point to the last checked
+ * item.
+ */
if (ret > 0) {
if (path->slots[0] == 0)
btrfs_prev_leaf(root, path);
if (ret > 0) {
if (path->slots[0] == 0)
btrfs_prev_leaf(root, path);
search_start = disk_bytenr;
search_len = disk_num_bytes;
}
search_start = disk_bytenr;
search_len = disk_num_bytes;
}
- ret = count_csum_range(root->fs_info, search_start, search_len, &csum_found);
+ ret = count_csum_range(root->fs_info, search_start, search_len,
+ &csum_found);
if (csum_found > 0 && nodatasum) {
err |= ODD_CSUM_ITEM;
error("root %llu EXTENT_DATA[%llu %llu] nodatasum shouldn't have datasum",
if (csum_found > 0 && nodatasum) {
err |= ODD_CSUM_ITEM;
error("root %llu EXTENT_DATA[%llu %llu] nodatasum shouldn't have datasum",
error("root %llu EXTENT_DATA[%llu %llu] csum missing, have: %llu, expected: %llu",
root->objectid, fkey->objectid, fkey->offset,
csum_found, search_len);
error("root %llu EXTENT_DATA[%llu %llu] csum missing, have: %llu, expected: %llu",
root->objectid, fkey->objectid, fkey->offset,
csum_found, search_len);
- } else if (extent_type == BTRFS_FILE_EXTENT_PREALLOC && csum_found > 0) {
+ } else if (extent_type == BTRFS_FILE_EXTENT_PREALLOC &&
+ csum_found > 0) {
err |= ODD_CSUM_ITEM;
error("root %llu EXTENT_DATA[%llu %llu] prealloc shouldn't have csum, but has: %llu",
root->objectid, fkey->objectid, fkey->offset, csum_found);
err |= ODD_CSUM_ITEM;
error("root %llu EXTENT_DATA[%llu %llu] prealloc shouldn't have csum, but has: %llu",
root->objectid, fkey->objectid, fkey->offset, csum_found);
* Check if the backref points to valid
* referencer
*/
* Check if the backref points to valid
* referencer
*/
- found_ref = !check_tree_block_ref( root, NULL,
- offset, level + 1, owner,
- NULL);
+ found_ref = !check_tree_block_ref(root, NULL,
+ offset, level + 1, owner, NULL);
}
if (type == BTRFS_EXTENT_DATA_REF_KEY) {
ref_root = btrfs_extent_data_ref_root(leaf, dref);
}
if (type == BTRFS_EXTENT_DATA_REF_KEY) {
ref_root = btrfs_extent_data_ref_root(leaf, dref);
- ref_objectid = btrfs_extent_data_ref_objectid(leaf, dref);
+ ref_objectid = btrfs_extent_data_ref_objectid(leaf,
+ dref);
ref_offset = btrfs_extent_data_ref_offset(leaf, dref);
if (ref_objectid == fi_key.objectid &&
ref_offset = btrfs_extent_data_ref_offset(leaf, dref);
if (ref_objectid == fi_key.objectid &&
if (!(bg_flags & BTRFS_BLOCK_GROUP_DATA)) {
error(
"bad extent[%llu, %llu) type mismatch with chunk",
if (!(bg_flags & BTRFS_BLOCK_GROUP_DATA)) {
error(
"bad extent[%llu, %llu) type mismatch with chunk",
- extent_key.objectid,
- extent_key.objectid + extent_key.offset);
+ extent_key.objectid,
+ extent_key.objectid + extent_key.offset);
err |= CHUNK_TYPE_MISMATCH;
}
} else if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
err |= CHUNK_TYPE_MISMATCH;
}
} else if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
btrfs_header_owner(leaf) != root_id)
goto next;
btrfs_item_key_to_cpu(leaf, &key, slot);
btrfs_header_owner(leaf) != root_id)
goto next;
btrfs_item_key_to_cpu(leaf, &key, slot);
- if (key.objectid != objectid || key.type != BTRFS_EXTENT_DATA_KEY)
+ if (key.objectid != objectid ||
+ key.type != BTRFS_EXTENT_DATA_KEY)
break;
fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
/*
break;
fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
/*
if (found_count != count) {
error(
"extent[%llu, %llu] referencer count mismatch (root: %llu, owner: %llu, offset: %llu) wanted: %u, have: %u",
if (found_count != count) {
error(
"extent[%llu, %llu] referencer count mismatch (root: %llu, owner: %llu, offset: %llu) wanted: %u, have: %u",
- bytenr, len, root_id, objectid, offset, count, found_count);
+ bytenr, len, root_id, objectid, offset, count,
+ found_count);
return REFERENCER_MISSING;
}
return 0;
return REFERENCER_MISSING;
}
return 0;
nrefs, account_file_data);
err |= ret;
break;
nrefs, account_file_data);
err |= ret;
break;
- } else {
- if (check || !check_all) {
- ret = btrfs_check_node(root, NULL, cur);
- if (ret != BTRFS_TREE_BLOCK_CLEAN) {
- err |= -EIO;
- break;
- }
+ }
+ if (check || !check_all) {
+ ret = btrfs_check_node(root, NULL, cur);
+ if (ret != BTRFS_TREE_BLOCK_CLEAN) {
+ err |= -EIO;
+ break;
ret = check_child_node(cur, path->slots[*level], next);
err |= ret;
ret = check_child_node(cur, path->slots[*level], next);
err |= ret;
break;
if (btrfs_is_leaf(next))
break;
if (btrfs_is_leaf(next))
path->slots[i]++;
*level = i;
return 0;
path->slots[i]++;
*level = i;
return 0;
- } else {
- free_extent_buffer(path->nodes[*level]);
- path->nodes[*level] = NULL;
- *level = i + 1;
+ free_extent_buffer(path->nodes[*level]);
+ path->nodes[*level] = NULL;
+ *level = i + 1;
path->slots[i]++;
*level = i;
return 0;
path->slots[i]++;
*level = i;
return 0;
- } else {
- free_extent_buffer(path->nodes[*level]);
- path->nodes[*level] = NULL;
- BUG_ON(*level > wc->active_node);
- if (*level == wc->active_node)
- leave_shared_node(root, wc, *level);
- *level = i + 1;
+ free_extent_buffer(path->nodes[*level]);
+ path->nodes[*level] = NULL;
+ BUG_ON(*level > wc->active_node);
+ if (*level == wc->active_node)
+ leave_shared_node(root, wc, *level);
+ *level = i + 1;
btrfs_set_inode_size(path->nodes[0], ei, rec->found_size);
btrfs_mark_buffer_dirty(path->nodes[0]);
rec->errors &= ~I_ERR_DIR_ISIZE_WRONG;
btrfs_set_inode_size(path->nodes[0], ei, rec->found_size);
btrfs_mark_buffer_dirty(path->nodes[0]);
rec->errors &= ~I_ERR_DIR_ISIZE_WRONG;
- printf("reset isize for dir %Lu root %Lu\n", rec->ino,
+ printf("reset isize for dir %llu root %llu\n", rec->ino,
root->root_key.objectid);
out:
btrfs_release_path(path);
root->root_key.objectid);
out:
btrfs_release_path(path);
goto out;
if (back->is_data) {
dback = to_data_backref(back);
goto out;
if (back->is_data) {
dback = to_data_backref(back);
- fprintf(stderr, "Data backref %llu %s %llu"
- " owner %llu offset %llu num_refs %lu"
- " not found in extent tree\n",
+ fprintf(stderr,
+"data backref %llu %s %llu owner %llu offset %llu num_refs %lu not found in extent tree\n",
(unsigned long long)rec->start,
back->full_backref ?
"parent" : "root",
back->full_backref ?
(unsigned long long)rec->start,
back->full_backref ?
"parent" : "root",
back->full_backref ?
- (unsigned long long)dback->parent:
+ (unsigned long long)dback->parent :
(unsigned long long)dback->root,
(unsigned long long)dback->owner,
(unsigned long long)dback->offset,
(unsigned long)dback->num_refs);
} else {
tback = to_tree_backref(back);
(unsigned long long)dback->root,
(unsigned long long)dback->owner,
(unsigned long long)dback->offset,
(unsigned long)dback->num_refs);
} else {
tback = to_tree_backref(back);
- fprintf(stderr, "Tree backref %llu parent %llu"
- " root %llu not found in extent tree\n",
+ fprintf(stderr,
+"tree backref %llu parent %llu root %llu not found in extent tree\n",
(unsigned long long)rec->start,
(unsigned long long)tback->parent,
(unsigned long long)tback->root);
(unsigned long long)rec->start,
(unsigned long long)tback->parent,
(unsigned long long)tback->root);
if (!print_errs)
goto out;
tback = to_tree_backref(back);
if (!print_errs)
goto out;
tback = to_tree_backref(back);
- fprintf(stderr, "Backref %llu %s %llu not referenced back %p\n",
+ fprintf(stderr,
+ "backref %llu %s %llu not referenced back %p\n",
(unsigned long long)rec->start,
back->full_backref ? "parent" : "root",
back->full_backref ?
(unsigned long long)rec->start,
back->full_backref ? "parent" : "root",
back->full_backref ?
err = 1;
if (!print_errs)
goto out;
err = 1;
if (!print_errs)
goto out;
- fprintf(stderr, "Incorrect local backref count"
- " on %llu %s %llu owner %llu"
- " offset %llu found %u wanted %u back %p\n",
+ fprintf(stderr,
+"incorrect local backref count on %llu %s %llu owner %llu offset %llu found %u wanted %u back %p\n",
(unsigned long long)rec->start,
back->full_backref ?
"parent" : "root",
back->full_backref ?
(unsigned long long)rec->start,
back->full_backref ?
"parent" : "root",
back->full_backref ?
- (unsigned long long)dback->parent:
+ (unsigned long long)dback->parent :
(unsigned long long)dback->root,
(unsigned long long)dback->owner,
(unsigned long long)dback->offset,
(unsigned long long)dback->root,
(unsigned long long)dback->owner,
(unsigned long long)dback->offset,
- dback->found_ref, dback->num_refs, back);
+ dback->found_ref, dback->num_refs,
+ back);
}
if (dback->disk_bytenr != rec->start) {
err = 1;
if (!print_errs)
goto out;
}
if (dback->disk_bytenr != rec->start) {
err = 1;
if (!print_errs)
goto out;
- fprintf(stderr, "Backref disk bytenr does not"
- " match extent record, bytenr=%llu, "
- "ref bytenr=%llu\n",
+ fprintf(stderr,
+"backref disk bytenr does not match extent record, bytenr=%llu, ref bytenr=%llu\n",
(unsigned long long)rec->start,
(unsigned long long)dback->disk_bytenr);
}
(unsigned long long)rec->start,
(unsigned long long)dback->disk_bytenr);
}
err = 1;
if (!print_errs)
goto out;
err = 1;
if (!print_errs)
goto out;
- fprintf(stderr, "Backref bytes do not match "
- "extent backref, bytenr=%llu, ref "
- "bytes=%llu, backref bytes=%llu\n",
+ fprintf(stderr,
+"backref bytes do not match extent backref, bytenr=%llu, ref bytes=%llu, backref bytes=%llu\n",
(unsigned long long)rec->start,
(unsigned long long)rec->nr,
(unsigned long long)dback->bytes);
(unsigned long long)rec->start,
(unsigned long long)rec->nr,
(unsigned long long)dback->bytes);
err = 1;
if (!print_errs)
goto out;
err = 1;
if (!print_errs)
goto out;
- fprintf(stderr, "Incorrect global backref count "
- "on %llu found %llu wanted %llu\n",
+ fprintf(stderr,
+ "incorrect global backref count on %llu found %llu wanted %llu\n",
(unsigned long long)rec->start,
(unsigned long long)found,
(unsigned long long)rec->refs);
(unsigned long long)rec->start,
(unsigned long long)found,
(unsigned long long)rec->refs);
sizeof(struct btrfs_key_ptr));
if (slot == 0) {
struct btrfs_disk_key key;
sizeof(struct btrfs_key_ptr));
if (slot == 0) {
struct btrfs_disk_key key;
btrfs_node_key(buf, &key, 0);
btrfs_fixup_low_keys(root, path, &key,
btrfs_header_level(buf) + 1);
btrfs_node_key(buf, &key, 0);
btrfs_fixup_low_keys(root, path, &key,
btrfs_header_level(buf) + 1);
ret = delete_bogus_item(root, path, buf, i);
if (!ret)
goto again;
ret = delete_bogus_item(root, path, buf, i);
if (!ret)
goto again;
- fprintf(stderr, "item is off the end of the "
- "leaf, can't fix\n");
+ fprintf(stderr,
+ "item is off the end of the leaf, can't fix\n");
struct extent_backref *node;
struct tree_backref *back;
struct extent_backref *node;
struct tree_backref *back;
- while(cur != &rec->backrefs) {
+ while (cur != &rec->backrefs) {
node = to_extent_backref(cur);
cur = cur->next;
if (node->is_data)
node = to_extent_backref(cur);
cur = cur->next;
if (node->is_data)
struct extent_backref *node;
struct data_backref *back;
struct extent_backref *node;
struct data_backref *back;
- while(cur != &rec->backrefs) {
+ while (cur != &rec->backrefs) {
node = to_extent_backref(cur);
cur = cur->next;
if (!node->is_data)
node = to_extent_backref(cur);
cur = cur->next;
if (!node->is_data)
if (tmpl->extent_item_refs && !dup) {
if (rec->extent_item_refs) {
if (tmpl->extent_item_refs && !dup) {
if (rec->extent_item_refs) {
- fprintf(stderr, "block %llu rec "
- "extent_item_refs %llu, passed %llu\n",
+ fprintf(stderr,
+ "block %llu rec extent_item_refs %llu, passed %llu\n",
(unsigned long long)tmpl->start,
(unsigned long long)
rec->extent_item_refs,
(unsigned long long)tmpl->start,
(unsigned long long)
rec->extent_item_refs,
- (unsigned long long)tmpl->extent_item_refs);
+ (unsigned long long)
+ tmpl->extent_item_refs);
}
rec->extent_item_refs = tmpl->extent_item_refs;
}
}
rec->extent_item_refs = tmpl->extent_item_refs;
}
if (found_ref) {
if (back->node.found_ref) {
if (found_ref) {
if (back->node.found_ref) {
- fprintf(stderr, "Extent back ref already exists "
- "for %llu parent %llu root %llu \n",
+ fprintf(stderr,
+ "Extent back ref already exists for %llu parent %llu root %llu\n",
(unsigned long long)bytenr,
(unsigned long long)parent,
(unsigned long long)root);
(unsigned long long)bytenr,
(unsigned long long)parent,
(unsigned long long)root);
back->node.found_ref = 1;
} else {
if (back->node.found_extent_tree) {
back->node.found_ref = 1;
} else {
if (back->node.found_extent_tree) {
- fprintf(stderr, "Extent back ref already exists "
- "for %llu parent %llu root %llu \n",
+ fprintf(stderr,
+ "extent back ref already exists for %llu parent %llu root %llu\n",
(unsigned long long)bytenr,
(unsigned long long)parent,
(unsigned long long)root);
(unsigned long long)bytenr,
(unsigned long long)parent,
(unsigned long long)root);
rec->owner_ref_checked = 1;
} else {
if (back->node.found_extent_tree) {
rec->owner_ref_checked = 1;
} else {
if (back->node.found_extent_tree) {
- fprintf(stderr, "Extent back ref already exists "
- "for %llu parent %llu root %llu "
- "owner %llu offset %llu num_refs %lu\n",
+ fprintf(stderr,
+"Extent back ref already exists for %llu parent %llu root %llu owner %llu offset %llu num_refs %lu\n",
(unsigned long long)bytenr,
(unsigned long long)parent,
(unsigned long long)root,
(unsigned long long)bytenr,
(unsigned long long)parent,
(unsigned long long)root,
struct cache_tree *seen, u64 bytenr, u32 size)
{
int ret;
struct cache_tree *seen, u64 bytenr, u32 size)
{
int ret;
ret = add_cache_extent(seen, bytenr, size);
if (ret)
return ret;
ret = add_cache_extent(seen, bytenr, size);
if (ret)
return ret;
cache = search_cache_extent(nodes, 0);
if (!cache) {
cache = search_cache_extent(nodes, 0);
if (!cache) {
- cache = search_cache_extent(pending, 0);
- if (!cache)
- return 0;
- ret = 0;
- do {
- bits[ret].start = cache->start;
- bits[ret].size = cache->size;
- cache = next_cache_extent(cache);
- ret++;
- } while (cache && ret < bits_nr);
- return ret;
+ cache = search_cache_extent(pending, 0);
+ if (!cache)
+ return 0;
+ ret = 0;
+ do {
+ bits[ret].start = cache->start;
+ bits[ret].size = cache->size;
+ cache = next_cache_extent(cache);
+ ret++;
+ } while (cache && ret < bits_nr);
+ return ret;
if (bits_nr - ret > 8) {
u64 lookup = bits[0].start + bits[0].size;
struct cache_extent *next;
if (bits_nr - ret > 8) {
u64 lookup = bits[0].start + bits[0].size;
struct cache_extent *next;
next = search_cache_extent(pending, lookup);
next = search_cache_extent(pending, lookup);
if (next->start - lookup > 32768)
break;
bits[ret].start = next->start;
if (next->start - lookup > 32768)
break;
bits[ret].start = next->start;
if (item_size < sizeof(*ei)) {
#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
struct btrfs_extent_item_v0 *ei0;
if (item_size < sizeof(*ei)) {
#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
struct btrfs_extent_item_v0 *ei0;
if (item_size != sizeof(*ei0)) {
error(
"invalid extent item format: ITEM[%llu %u %llu] leaf: %llu slot: %d",
if (item_size != sizeof(*ei0)) {
error(
"invalid extent item format: ITEM[%llu %u %llu] leaf: %llu slot: %d",
0, num_bytes);
break;
default:
0, num_bytes);
break;
default:
- fprintf(stderr, "corrupt extent record: key %Lu %u %Lu\n",
+ fprintf(stderr,
+ "corrupt extent record: key [%llu,%u,%llu]\n",
key.objectid, key.type, num_bytes);
goto out;
}
key.objectid, key.type, num_bytes);
goto out;
}
entry = btrfs_find_free_space(cache->free_space_ctl, offset, bytes);
if (!entry) {
entry = btrfs_find_free_space(cache->free_space_ctl, offset, bytes);
if (!entry) {
- fprintf(stderr, "There is no free space entry for %Lu-%Lu\n",
+ fprintf(stderr, "there is no free space entry for %llu-%llu\n",
offset, offset+bytes);
return -EINVAL;
}
if (entry->offset != offset) {
offset, offset+bytes);
return -EINVAL;
}
if (entry->offset != offset) {
- fprintf(stderr, "Wanted offset %Lu, found %Lu\n", offset,
+ fprintf(stderr, "wanted offset %llu, found %llu\n", offset,
entry->offset);
return -EINVAL;
}
if (entry->bytes != bytes) {
entry->offset);
return -EINVAL;
}
if (entry->bytes != bytes) {
- fprintf(stderr, "Wanted bytes %Lu, found %Lu for off %Lu\n",
+ fprintf(stderr, "wanted bytes %llu, found %llu for off %llu\n",
bytes, entry->bytes, offset);
return -EINVAL;
}
bytes, entry->bytes, offset);
return -EINVAL;
}
ret = verify_space_cache(root, cache);
if (ret) {
ret = verify_space_cache(root, cache);
if (ret) {
- fprintf(stderr, "cache appears valid but isn't %Lu\n",
+ fprintf(stderr, "cache appears valid but isn't %llu\n",
cache->key.objectid);
error++;
}
cache->key.objectid);
error++;
}
static int check_extent_csums(struct btrfs_root *root, u64 bytenr,
u64 num_bytes, unsigned long leaf_offset,
static int check_extent_csums(struct btrfs_root *root, u64 bytenr,
u64 num_bytes, unsigned long leaf_offset,
- struct extent_buffer *eb) {
-
+ struct extent_buffer *eb)
+{
struct btrfs_fs_info *fs_info = root->fs_info;
u64 offset = 0;
u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);
struct btrfs_fs_info *fs_info = root->fs_info;
u64 offset = 0;
u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);
out:
if (num_bytes && !ret) {
out:
if (num_bytes && !ret) {
- fprintf(stderr, "There are no extents for csum range "
- "%Lu-%Lu\n", bytenr, bytenr+num_bytes);
+ fprintf(stderr,
+ "there are no extents for csum range %llu-%llu\n",
+ bytenr, bytenr+num_bytes);
} else if (key.offset != offset + num_bytes) {
ret = check_extent_exists(root, offset, num_bytes);
if (ret) {
} else if (key.offset != offset + num_bytes) {
ret = check_extent_exists(root, offset, num_bytes);
if (ret) {
- fprintf(stderr, "Csum exists for %Lu-%Lu but "
- "there is no extent record\n",
+ fprintf(stderr,
+ "csum exists for %llu-%llu but there is no extent record\n",
offset, offset+num_bytes);
errors++;
}
offset, offset+num_bytes);
errors++;
}
}
static int is_dropped_key(struct btrfs_key *key,
}
static int is_dropped_key(struct btrfs_key *key,
- struct btrfs_key *drop_key) {
+ struct btrfs_key *drop_key)
+{
if (key->objectid < drop_key->objectid)
return 1;
else if (key->objectid == drop_key->objectid) {
if (key->objectid < drop_key->objectid)
return 1;
else if (key->objectid == drop_key->objectid) {
return 1;
if (!reada_bits) {
return 1;
if (!reada_bits) {
- for(i = 0; i < nritems; i++) {
+ for (i = 0; i < nritems; i++) {
ret = add_cache_extent(reada, bits[i].start,
bits[i].size);
if (ret == -EEXIST)
ret = add_cache_extent(reada, bits[i].start,
bits[i].size);
if (ret == -EEXIST)
btree_space_waste += btrfs_leaf_free_space(root, buf);
for (i = 0; i < nritems; i++) {
struct btrfs_file_extent_item *fi;
btree_space_waste += btrfs_leaf_free_space(root, buf);
for (i = 0; i < nritems; i++) {
struct btrfs_file_extent_item *fi;
btrfs_item_key_to_cpu(buf, &key, i);
/*
* Check key type against the leaf owner.
btrfs_item_key_to_cpu(buf, &key, i);
/*
* Check key type against the leaf owner.
}
if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
struct btrfs_extent_data_ref *ref;
}
if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
struct btrfs_extent_data_ref *ref;
ref = btrfs_item_ptr(buf, i,
struct btrfs_extent_data_ref);
add_data_backref(extent_cache,
ref = btrfs_item_ptr(buf, i,
struct btrfs_extent_data_ref);
add_data_backref(extent_cache,
}
if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
struct btrfs_shared_data_ref *ref;
}
if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
struct btrfs_shared_data_ref *ref;
ref = btrfs_item_ptr(buf, i,
struct btrfs_shared_data_ref);
add_data_backref(extent_cache,
ref = btrfs_item_ptr(buf, i,
struct btrfs_shared_data_ref);
add_data_backref(extent_cache,
data_bytes_allocated +=
btrfs_file_extent_disk_num_bytes(buf, fi);
data_bytes_allocated +=
btrfs_file_extent_disk_num_bytes(buf, fi);
- if (data_bytes_allocated < root->fs_info->sectorsize) {
+ if (data_bytes_allocated < root->fs_info->sectorsize)
data_bytes_referenced +=
btrfs_file_extent_num_bytes(buf, fi);
add_data_backref(extent_cache,
data_bytes_referenced +=
btrfs_file_extent_num_bytes(buf, fi);
add_data_backref(extent_cache,
memset(&tmpl, 0, sizeof(tmpl));
btrfs_cpu_key_to_disk(&tmpl.parent_key, &key);
memset(&tmpl, 0, sizeof(tmpl));
btrfs_cpu_key_to_disk(&tmpl.parent_key, &key);
- tmpl.parent_generation = btrfs_node_ptr_generation(buf, i);
+ tmpl.parent_generation =
+ btrfs_node_ptr_generation(buf, i);
tmpl.start = ptr;
tmpl.nr = size;
tmpl.refs = 1;
tmpl.start = ptr;
tmpl.nr = size;
tmpl.refs = 1;
add_pending(nodes, seen, ptr, size);
add_pending(nodes, seen, ptr, size);
add_pending(pending, seen, ptr, size);
add_pending(pending, seen, ptr, size);
}
btree_space_waste += (BTRFS_NODEPTRS_PER_BLOCK(fs_info) -
nritems) * sizeof(struct btrfs_key_ptr);
}
btree_space_waste += (BTRFS_NODEPTRS_PER_BLOCK(fs_info) -
nritems) * sizeof(struct btrfs_key_ptr);
rec = container_of(cache, struct extent_record, cache);
if (is_data) {
struct data_backref *back;
rec = container_of(cache, struct extent_record, cache);
if (is_data) {
struct data_backref *back;
back = find_data_backref(rec, parent, root_objectid, owner,
offset, 1, bytenr, num_bytes);
if (!back)
back = find_data_backref(rec, parent, root_objectid, owner,
offset, 1, bytenr, num_bytes);
if (!back)
}
} else {
struct tree_backref *back;
}
} else {
struct tree_backref *back;
back = find_tree_backref(rec, parent, root_objectid);
if (!back)
goto out;
back = find_tree_backref(rec, parent, root_objectid);
if (!back)
goto out;
key.type = (u8)-1;
key.offset = (u64)-1;
key.type = (u8)-1;
key.offset = (u64)-1;
ret = btrfs_search_slot(trans, root->fs_info->extent_root,
&key, path, 0, 1);
if (ret < 0)
ret = btrfs_search_slot(trans, root->fs_info->extent_root,
&key, path, 0, 1);
if (ret < 0)
- fprintf(stderr, "repair deleting extent record: key %Lu %u %Lu\n",
+ fprintf(stderr,
+ "repair deleting extent record: key [%llu,%u,%llu]\n",
found_key.objectid, found_key.type, found_key.offset);
ret = btrfs_del_item(trans, root->fs_info->extent_root, path);
found_key.objectid, found_key.type, found_key.offset);
ret = btrfs_del_item(trans, root->fs_info->extent_root, path);
btrfs_set_extent_flags(leaf, ei,
BTRFS_EXTENT_FLAG_DATA);
} else {
btrfs_set_extent_flags(leaf, ei,
BTRFS_EXTENT_FLAG_DATA);
} else {
- struct btrfs_disk_key copy_key;;
+ struct btrfs_disk_key copy_key;
bi = (struct btrfs_tree_block_info *)(ei + 1);
memset_extent_buffer(leaf, 0, (unsigned long)bi,
bi = (struct btrfs_tree_block_info *)(ei + 1);
memset_extent_buffer(leaf, 0, (unsigned long)bi,
btrfs_set_tree_block_key(leaf, bi, ©_key);
btrfs_set_extent_flags(leaf, ei,
btrfs_set_tree_block_key(leaf, bi, ©_key);
btrfs_set_extent_flags(leaf, ei,
- BTRFS_EXTENT_FLAG_TREE_BLOCK | flags);
+ flags | BTRFS_EXTENT_FLAG_TREE_BLOCK);
}
btrfs_mark_buffer_dirty(leaf);
}
btrfs_mark_buffer_dirty(leaf);
- fprintf(stderr, "adding new data backref"
- " on %llu %s %llu owner %llu"
- " offset %llu found %d\n",
- (unsigned long long)rec->start,
- back->full_backref ?
- "parent" : "root",
- back->full_backref ?
- (unsigned long long)parent :
- (unsigned long long)dback->root,
- (unsigned long long)dback->owner,
- (unsigned long long)dback->offset,
- dback->found_ref);
+ fprintf(stderr,
+"adding new data backref on %llu %s %llu owner %llu offset %llu found %d\n",
+ (unsigned long long)rec->start,
+ back->full_backref ? "parent" : "root",
+ back->full_backref ? (unsigned long long)parent :
+ (unsigned long long)dback->root,
+ (unsigned long long)dback->owner,
+ (unsigned long long)dback->offset, dback->found_ref);
} else {
u64 parent;
struct tree_backref *tback;
} else {
u64 parent;
struct tree_backref *tback;
ret = btrfs_inc_extent_ref(trans, info->extent_root,
rec->start, rec->max_size,
parent, tback->root, 0, 0);
ret = btrfs_inc_extent_ref(trans, info->extent_root,
rec->start, rec->max_size,
parent, tback->root, 0, 0);
- fprintf(stderr, "adding new tree backref on "
- "start %llu len %llu parent %llu root %llu\n",
+ fprintf(stderr,
+"adding new tree backref on start %llu len %llu parent %llu root %llu\n",
rec->start, rec->max_size, parent, tback->root);
}
fail:
rec->start, rec->max_size, parent, tback->root);
}
fail:
*/
ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
if (ret < 0) {
*/
ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
if (ret < 0) {
- fprintf(stderr, "Error cowing down to ref [%Lu, %u, %Lu]: %d\n",
+ fprintf(stderr, "error cowing down to ref [%llu,%u,%llu]: %d\n",
key.objectid, key.type, key.offset, ret);
goto out;
}
if (ret > 0) {
key.objectid, key.type, key.offset, ret);
goto out;
}
if (ret > 0) {
- fprintf(stderr, "Well that's odd, we just found this key "
- "[%Lu, %u, %Lu]\n", key.objectid, key.type,
- key.offset);
+ fprintf(stderr,
+ "well that's odd, we just found this key [%llu,%u,%llu]\n",
+ key.objectid, key.type, key.offset);
ret = -EINVAL;
goto out;
}
ret = -EINVAL;
goto out;
}
if (btrfs_file_extent_compression(leaf, fi) &&
dback->disk_bytenr != entry->bytenr) {
if (btrfs_file_extent_compression(leaf, fi) &&
dback->disk_bytenr != entry->bytenr) {
- fprintf(stderr, "Ref doesn't match the record start and is "
- "compressed, please take a btrfs-image of this file "
- "system and send it to a btrfs developer so they can "
- "complete this functionality for bytenr %Lu\n",
+ fprintf(stderr,
+"ref doesn't match the record start and is compressed, please take a btrfs-image of this file system and send it to a btrfs developer so they can complete this functionality for bytenr %llu\n",
dback->disk_bytenr);
ret = -EINVAL;
goto out;
dback->disk_bytenr);
ret = -EINVAL;
goto out;
if (dback->disk_bytenr + offset +
btrfs_file_extent_num_bytes(leaf, fi) >
entry->bytenr + entry->bytes) {
if (dback->disk_bytenr + offset +
btrfs_file_extent_num_bytes(leaf, fi) >
entry->bytenr + entry->bytes) {
- fprintf(stderr, "Ref is past the entry end, please "
- "take a btrfs-image of this file system and "
- "send it to a btrfs developer, ref %Lu\n",
+ fprintf(stderr,
+"ref is past the entry end, please take a btrfs-image of this file system and send it to a btrfs developer, ref %llu\n",
dback->disk_bytenr);
ret = -EINVAL;
goto out;
dback->disk_bytenr);
ret = -EINVAL;
goto out;
offset = btrfs_file_extent_offset(leaf, fi);
if (dback->disk_bytenr + offset < entry->bytenr) {
offset = btrfs_file_extent_offset(leaf, fi);
if (dback->disk_bytenr + offset < entry->bytenr) {
- fprintf(stderr, "Ref is before the entry start, please"
- " take a btrfs-image of this file system and "
- "send it to a btrfs developer, ref %Lu\n",
+ fprintf(stderr,
+"ref is before the entry start, please take a btrfs-image of this file system and send it to a btrfs developer, ref %llu\n",
dback->disk_bytenr);
ret = -EINVAL;
goto out;
dback->disk_bytenr);
ret = -EINVAL;
goto out;
if (nr_entries <= 1 && !mismatch)
goto out;
if (nr_entries <= 1 && !mismatch)
goto out;
- fprintf(stderr, "attempting to repair backref discrepency for bytenr "
- "%Lu\n", rec->start);
+ fprintf(stderr,
+ "attempting to repair backref discrepency for bytenr %llu\n",
+ rec->start);
/*
* First we want to see if the backrefs can agree amongst themselves who
/*
* First we want to see if the backrefs can agree amongst themselves who
if (!best) {
entry = find_entry(&entries, rec->start, rec->nr);
if (!entry && (!broken_entries || !rec->found_rec)) {
if (!best) {
entry = find_entry(&entries, rec->start, rec->nr);
if (!entry && (!broken_entries || !rec->found_rec)) {
- fprintf(stderr, "Backrefs don't agree with each other "
- "and extent record doesn't agree with anybody,"
- " so we can't fix bytenr %Lu bytes %Lu\n",
+ fprintf(stderr,
+"backrefs don't agree with each other and extent record doesn't agree with anybody, so we can't fix bytenr %llu bytes %llu\n",
rec->start, rec->nr);
ret = -EINVAL;
goto out;
rec->start, rec->nr);
ret = -EINVAL;
goto out;
entry->count++;
best = find_most_right_entry(&entries);
if (!best) {
entry->count++;
best = find_most_right_entry(&entries);
if (!best) {
- fprintf(stderr, "Backrefs and extent record evenly "
- "split on who is right, this is going to "
- "require user input to fix bytenr %Lu bytes "
- "%Lu\n", rec->start, rec->nr);
+ fprintf(stderr,
+"backrefs and extent record evenly split on who is right, this is going to require user input to fix bytenr %llu bytes %llu\n",
+ rec->start, rec->nr);
ret = -EINVAL;
goto out;
}
ret = -EINVAL;
goto out;
}
* deal with it properly here yet, so just bail out of that's the case.
*/
if (best->bytenr != rec->start) {
* deal with it properly here yet, so just bail out of that's the case.
*/
if (best->bytenr != rec->start) {
- fprintf(stderr, "Extent start and backref starts don't match, "
- "please use btrfs-image on this file system and send "
- "it to a btrfs developer so they can make fsck fix "
- "this particular case. bytenr is %Lu, bytes is %Lu\n",
+ fprintf(stderr,
+"extent start and backref starts don't match, please use btrfs-image on this file system and send it to a btrfs developer so they can make fsck fix this particular case. bytenr is %llu, bytes is %llu\n",
rec->start, rec->nr);
ret = -EINVAL;
goto out;
rec->start, rec->nr);
ret = -EINVAL;
goto out;
continue;
if (tmp->start + tmp->nr < good->start + good->nr) {
continue;
if (tmp->start + tmp->nr < good->start + good->nr) {
- fprintf(stderr, "Ok we have overlapping extents that "
- "aren't completely covered by each other, this "
- "is going to require more careful thought. "
- "The extents are [%Lu-%Lu] and [%Lu-%Lu]\n",
+ fprintf(stderr,
+"Ok we have overlapping extents that aren't completely covered by each other, this is going to require more careful thought. The extents are [%llu-%llu] and [%llu-%llu]\n",
tmp->start, tmp->nr, good->start, good->nr);
abort();
}
tmp->start, tmp->nr, good->start, good->nr);
abort();
}
/* Shouldn't happen but just in case */
if (tmp->metadata) {
/* Shouldn't happen but just in case */
if (tmp->metadata) {
- fprintf(stderr, "Well this shouldn't happen, extent "
- "record overlaps but is metadata? "
- "[%Lu, %Lu]\n", tmp->start, tmp->nr);
+ fprintf(stderr,
+"well this shouldn't happen, extent record overlaps but is metadata? [%llu, %llu]\n",
+ tmp->start, tmp->nr);
cache = lookup_cache_extent(extent_cache, bytenr, 1);
if (cache) {
struct extent_record *tmp;
cache = lookup_cache_extent(extent_cache, bytenr, 1);
if (cache) {
struct extent_record *tmp;
tmp = container_of(cache, struct extent_record, cache);
/*
tmp = container_of(cache, struct extent_record, cache);
/*
continue;
rec->bad_full_backref = 0;
continue;
rec->bad_full_backref = 0;
- ret = record_extent(trans, info, &path, rec, back, allocated, flags);
+ ret = record_extent(trans, info, &path, rec, back, allocated,
+ flags);
out:
if (trans) {
int err = btrfs_commit_transaction(trans, info->extent_root);
out:
if (trans) {
int err = btrfs_commit_transaction(trans, info->extent_root);
- * we couldn't find the bad block. TODO, search all the nodes for pointers
- * to this block
+ * We couldn't find the bad block.
+ * TODO: search all the nodes for pointers to this block
*/
if (eb == info->extent_root->node) {
ret = -ENOENT;
*/
if (eb == info->extent_root->node) {
ret = -ENOENT;
- printk("deleting pointer to block %Lu\n", corrupt->cache.start);
+ printk("deleting pointer to block %llu\n", corrupt->cache.start);
ret = btrfs_del_ptr(info->extent_root, &path, level, slot);
out:
ret = btrfs_del_ptr(info->extent_root, &path, level, slot);
out:
* extents in the FS
*/
cache = search_cache_extent(extent_cache, 0);
* extents in the FS
*/
cache = search_cache_extent(extent_cache, 0);
rec = container_of(cache, struct extent_record, cache);
set_extent_dirty(root->fs_info->excluded_extents,
rec->start,
rec = container_of(cache, struct extent_record, cache);
set_extent_dirty(root->fs_info->excluded_extents,
rec->start,
/* pin down all the corrupted blocks too */
cache = search_cache_extent(root->fs_info->corrupt_blocks, 0);
/* pin down all the corrupted blocks too */
cache = search_cache_extent(root->fs_info->corrupt_blocks, 0);
set_extent_dirty(root->fs_info->excluded_extents,
cache->start,
cache->start + cache->size - 1);
set_extent_dirty(root->fs_info->excluded_extents,
cache->start,
cache->start + cache->size - 1);
if (had_dups)
return -EAGAIN;
if (had_dups)
return -EAGAIN;
int cur_err = 0;
int fix = 0;
int cur_err = 0;
int fix = 0;
break;
rec = container_of(cache, struct extent_record, cache);
if (rec->num_duplicates) {
break;
rec = container_of(cache, struct extent_record, cache);
if (rec->num_duplicates) {
- fprintf(stderr, "extent item %llu has multiple extent "
- "items\n", (unsigned long long)rec->start);
+ fprintf(stderr,
+ "extent item %llu has multiple extent items\n",
+ (unsigned long long)rec->start);
- ret = fixup_extent_refs(root->fs_info, extent_cache, rec);
+ ret = fixup_extent_refs(root->fs_info, extent_cache,
+ rec);
if (ret)
goto repair_abort;
}
if (ret)
goto repair_abort;
}
u8 level, u8 drop_level,
struct btrfs_key *drop_key)
{
u8 level, u8 drop_level,
struct btrfs_key *drop_key)
{
struct root_item_record *ri_rec;
struct root_item_record *ri_rec;
ri_rec = malloc(sizeof(*ri_rec));
if (!ri_rec)
return -ENOMEM;
ri_rec = malloc(sizeof(*ri_rec));
if (!ri_rec)
return -ENOMEM;
while (!list_empty(list)) {
struct root_item_record *rec;
struct extent_buffer *buf;
while (!list_empty(list)) {
struct root_item_record *rec;
struct extent_buffer *buf;
rec = list_entry(list->next,
struct root_item_record, list);
last = 0;
rec = list_entry(list->next,
struct root_item_record, list);
last = 0;
ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, &path, 0, 0);
if (ret < 0)
goto out;
ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, &path, 0, 0);
if (ret < 0)
goto out;
leaf = path.nodes[0];
slot = path.slots[0];
if (slot >= btrfs_header_nritems(path.nodes[0])) {
leaf = path.nodes[0];
slot = path.slots[0];
if (slot >= btrfs_header_nritems(path.nodes[0])) {