* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 021110-1307, USA.
*/
-#define _XOPEN_SOURCE 600
-#define __USE_XOPEN2K
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
+#include <stdbool.h>
#include "kerncompat.h"
#include "extent_io.h"
#include "list.h"
#include "ctree.h"
#include "volumes.h"
+#include "utils.h"
+#include "internal.h"
void extent_io_tree_init(struct extent_io_tree *tree)
{
cache_tree_init(&tree->cache);
INIT_LIST_HEAD(&tree->lru);
tree->cache_size = 0;
+ tree->max_cache_size = (u64)total_memory() / 4;
+}
+
+void extent_io_tree_init_cache_max(struct extent_io_tree *tree,
+ u64 max_cache_size)
+{
+ extent_io_tree_init(tree);
+ tree->max_cache_size = max_cache_size;
}
static struct extent_state *alloc_extent_state(void)
btrfs_free_extent_state(es);
}
+static void free_extent_buffer_final(struct extent_buffer *eb);
void extent_io_tree_cleanup(struct extent_io_tree *tree)
{
struct extent_buffer *eb;
while(!list_empty(&tree->lru)) {
eb = list_entry(tree->lru.next, struct extent_buffer, lru);
- fprintf(stderr, "extent buffer leak: "
- "start %llu len %u\n",
- (unsigned long long)eb->start, eb->len);
- free_extent_buffer(eb);
+ if (eb->refs) {
+ fprintf(stderr,
+ "extent buffer leak: start %llu len %u\n",
+ (unsigned long long)eb->start, eb->len);
+ free_extent_buffer_nocache(eb);
+ } else {
+ free_extent_buffer_final(eb);
+ }
}
cache_tree_free_extents(&tree->state, free_extent_state_func);
/*
* clear some bits on a range in the tree.
*/
-int clear_extent_bits(struct extent_io_tree *tree, u64 start,
- u64 end, int bits, gfp_t mask)
+int clear_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, int bits)
{
struct extent_state *state;
struct extent_state *prealloc = NULL;
/*
* set some bits on a range in the tree.
*/
-int set_extent_bits(struct extent_io_tree *tree, u64 start,
- u64 end, int bits, gfp_t mask)
+int set_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, int bits)
{
struct extent_state *state;
struct extent_state *prealloc = NULL;
goto again;
}
-int set_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end,
- gfp_t mask)
+int set_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end)
{
- return set_extent_bits(tree, start, end, EXTENT_DIRTY, mask);
+ return set_extent_bits(tree, start, end, EXTENT_DIRTY);
}
-int clear_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end,
- gfp_t mask)
+int clear_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end)
{
- return clear_extent_bits(tree, start, end, EXTENT_DIRTY, mask);
+ return clear_extent_bits(tree, start, end, EXTENT_DIRTY);
}
int find_first_extent_bit(struct extent_io_tree *tree, u64 start,
u64 bytenr, u32 blocksize)
{
struct extent_buffer *eb;
- int ret;
- eb = malloc(sizeof(struct extent_buffer) + blocksize);
- if (!eb) {
- BUG();
+ eb = calloc(1, sizeof(struct extent_buffer) + blocksize);
+ if (!eb)
return NULL;
- }
- memset(eb, 0, sizeof(struct extent_buffer) + blocksize);
eb->start = bytenr;
eb->len = blocksize;
eb->cache_node.size = blocksize;
INIT_LIST_HEAD(&eb->recow);
- ret = insert_cache_extent(&tree->cache, &eb->cache_node);
- if (ret) {
- free(eb);
+ return eb;
+}
+
+struct extent_buffer *btrfs_clone_extent_buffer(struct extent_buffer *src)
+{
+ struct extent_buffer *new;
+
+ new = __alloc_extent_buffer(NULL, src->start, src->len);
+ if (!new)
return NULL;
+
+ copy_extent_buffer(new, src, 0, 0, src->len);
+ new->flags |= EXTENT_BUFFER_DUMMY;
+
+ return new;
+}
+
+static void free_extent_buffer_final(struct extent_buffer *eb)
+{
+ struct extent_io_tree *tree = eb->tree;
+
+ BUG_ON(eb->refs);
+ BUG_ON(tree->cache_size < eb->len);
+ list_del_init(&eb->lru);
+ if (!(eb->flags & EXTENT_BUFFER_DUMMY)) {
+ remove_cache_extent(&tree->cache, &eb->cache_node);
+ tree->cache_size -= eb->len;
}
- list_add_tail(&eb->lru, &tree->lru);
- tree->cache_size += blocksize;
- return eb;
+ free(eb);
}
-void free_extent_buffer(struct extent_buffer *eb)
+static void free_extent_buffer_internal(struct extent_buffer *eb, bool free_now)
{
- if (!eb)
+ if (!eb || IS_ERR(eb))
return;
eb->refs--;
BUG_ON(eb->refs < 0);
if (eb->refs == 0) {
- struct extent_io_tree *tree = eb->tree;
BUG_ON(eb->flags & EXTENT_DIRTY);
- list_del_init(&eb->lru);
list_del_init(&eb->recow);
- remove_cache_extent(&tree->cache, &eb->cache_node);
- BUG_ON(tree->cache_size < eb->len);
- tree->cache_size -= eb->len;
- free(eb);
+ if (eb->flags & EXTENT_BUFFER_DUMMY || free_now)
+ free_extent_buffer_final(eb);
}
}
+void free_extent_buffer(struct extent_buffer *eb)
+{
+ free_extent_buffer_internal(eb, 0);
+}
+
+void free_extent_buffer_nocache(struct extent_buffer *eb)
+{
+ free_extent_buffer_internal(eb, 1);
+}
+
struct extent_buffer *find_extent_buffer(struct extent_io_tree *tree,
u64 bytenr, u32 blocksize)
{
return eb;
}
+static void trim_extent_buffer_cache(struct extent_io_tree *tree)
+{
+ struct extent_buffer *eb, *tmp;
+
+ list_for_each_entry_safe(eb, tmp, &tree->lru, lru) {
+ if (eb->refs == 0)
+ free_extent_buffer_final(eb);
+ if (tree->cache_size <= ((tree->max_cache_size * 9) / 10))
+ break;
+ }
+}
+
struct extent_buffer *alloc_extent_buffer(struct extent_io_tree *tree,
u64 bytenr, u32 blocksize)
{
list_move_tail(&eb->lru, &tree->lru);
eb->refs++;
} else {
+ int ret;
+
if (cache) {
eb = container_of(cache, struct extent_buffer,
cache_node);
free_extent_buffer(eb);
}
eb = __alloc_extent_buffer(tree, bytenr, blocksize);
+ if (!eb)
+ return NULL;
+ ret = insert_cache_extent(&tree->cache, &eb->cache_node);
+ if (ret) {
+ free(eb);
+ return NULL;
+ }
+ list_add_tail(&eb->lru, &tree->lru);
+ tree->cache_size += blocksize;
+ if (tree->cache_size >= tree->max_cache_size)
+ trim_extent_buffer_cache(tree);
}
return eb;
}
{
int ret;
ret = pread(eb->fd, eb->data + offset, len, eb->dev_bytenr);
- if (ret < 0)
+ if (ret < 0) {
+ ret = -errno;
goto out;
+ }
if (ret != len) {
ret = -EIO;
goto out;
while (bytes_left) {
read_len = bytes_left;
- ret = btrfs_map_block(&info->mapping_tree, READ, offset,
- &read_len, &multi, mirror, NULL);
+ ret = btrfs_map_block(info, READ, offset, &read_len, &multi,
+ mirror, NULL);
if (ret) {
fprintf(stderr, "Couldn't map the block %Lu\n",
offset);
device = multi->stripes[0].dev;
read_len = min(bytes_left, read_len);
- if (device->fd == 0) {
+ if (device->fd <= 0) {
kfree(multi);
return -EIO;
}
this_len = bytes_left;
dev_nr = 0;
- ret = btrfs_map_block(&info->mapping_tree, WRITE, offset,
- &this_len, &multi, mirror, &raid_map);
+ ret = btrfs_map_block(info, WRITE, offset, &this_len, &multi,
+ mirror, &raid_map);
if (ret) {
fprintf(stderr, "Couldn't map the block %Lu\n",
offset);
u64 stripe_len = this_len;
this_len = min(this_len, bytes_left);
- this_len = min(this_len, (u64)info->tree_root->leafsize);
+ this_len = min(this_len, (u64)info->nodesize);
eb = malloc(sizeof(struct extent_buffer) + this_len);
- BUG_ON(!eb);
+ if (!eb) {
+ fprintf(stderr, "cannot allocate memory for eb\n");
+ ret = -ENOMEM;
+ goto out;
+ }
memset(eb, 0, sizeof(struct extent_buffer) + this_len);
eb->start = offset;
raid_map = NULL;
} else while (dev_nr < multi->num_stripes) {
device = multi->stripes[dev_nr].dev;
- if (device->fd == 0) {
+ if (device->fd <= 0) {
kfree(multi);
return -EIO;
}
multi = NULL;
}
return 0;
-}
-
-
-int set_extent_buffer_uptodate(struct extent_buffer *eb)
-{
- eb->flags |= EXTENT_UPTODATE;
- return 0;
-}
-int clear_extent_buffer_uptodate(struct extent_io_tree *tree,
- struct extent_buffer *eb)
-{
- eb->flags &= ~EXTENT_UPTODATE;
- return 0;
-}
-
-int extent_buffer_uptodate(struct extent_buffer *eb)
-{
- if (!eb)
- return 0;
-
- if (eb->flags & EXTENT_UPTODATE)
- return 1;
- return 0;
+out:
+ kfree(raid_map);
+ return ret;
}
int set_extent_buffer_dirty(struct extent_buffer *eb)
struct extent_io_tree *tree = eb->tree;
if (!(eb->flags & EXTENT_DIRTY)) {
eb->flags |= EXTENT_DIRTY;
- set_extent_dirty(tree, eb->start, eb->start + eb->len - 1, 0);
+ set_extent_dirty(tree, eb->start, eb->start + eb->len - 1);
extent_buffer_get(eb);
}
return 0;
struct extent_io_tree *tree = eb->tree;
if (eb->flags & EXTENT_DIRTY) {
eb->flags &= ~EXTENT_DIRTY;
- clear_extent_dirty(tree, eb->start, eb->start + eb->len - 1, 0);
+ clear_extent_dirty(tree, eb->start, eb->start + eb->len - 1);
free_extent_buffer(eb);
}
return 0;
{
memset(eb->data + start, c, len);
}
+
+int extent_buffer_test_bit(struct extent_buffer *eb, unsigned long start,
+ unsigned long nr)
+{
+ return le_test_bit(nr, (u8 *)eb->data + start);
+}
projects / platform / upstream / btrfs-progs.git / blobdiff