2008-01-24 22:13:08 +01:00
|
|
|
#include <linux/bitops.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/bio.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/gfp.h>
|
|
|
|
#include <linux/pagemap.h>
|
|
|
|
#include <linux/page-flags.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/swap.h>
|
|
|
|
#include <linux/writeback.h>
|
|
|
|
#include <linux/pagevec.h>
|
|
|
|
#include "extent_io.h"
|
|
|
|
#include "extent_map.h"
|
2008-08-07 17:19:43 +02:00
|
|
|
#include "compat.h"
|
2008-08-20 14:51:49 +02:00
|
|
|
#include "ctree.h"
|
|
|
|
#include "btrfs_inode.h"
|
2008-01-24 22:13:08 +01:00
|
|
|
|
|
|
|
static struct kmem_cache *extent_state_cache;
|
|
|
|
static struct kmem_cache *extent_buffer_cache;
|
|
|
|
|
|
|
|
static LIST_HEAD(buffers);
|
|
|
|
static LIST_HEAD(states);
|
2008-09-08 17:18:08 +02:00
|
|
|
|
2008-11-10 18:34:40 +01:00
|
|
|
#define LEAK_DEBUG 0
|
2009-02-04 15:24:05 +01:00
|
|
|
#if LEAK_DEBUG
|
2009-01-06 03:25:51 +01:00
|
|
|
static DEFINE_SPINLOCK(leak_lock);
|
2008-09-08 17:18:08 +02:00
|
|
|
#endif
|
2008-01-24 22:13:08 +01:00
|
|
|
|
|
|
|
#define BUFFER_LRU_MAX 64
|
|
|
|
|
|
|
|
struct tree_entry {
|
|
|
|
u64 start;
|
|
|
|
u64 end;
|
|
|
|
struct rb_node rb_node;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct extent_page_data {
|
|
|
|
struct bio *bio;
|
|
|
|
struct extent_io_tree *tree;
|
|
|
|
get_extent_t *get_extent;
|
2008-11-07 04:02:51 +01:00
|
|
|
|
|
|
|
/* tells writepage not to lock the state bits for this range
|
|
|
|
* it still does the unlocking
|
|
|
|
*/
|
2009-04-20 21:50:09 +02:00
|
|
|
unsigned int extent_locked:1;
|
|
|
|
|
|
|
|
/* tells the submit_bio code to use a WRITE_SYNC */
|
|
|
|
unsigned int sync_io:1;
|
2008-01-24 22:13:08 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
int __init extent_io_init(void)
|
|
|
|
{
|
2009-04-13 15:33:09 +02:00
|
|
|
extent_state_cache = kmem_cache_create("extent_state",
|
|
|
|
sizeof(struct extent_state), 0,
|
|
|
|
SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
|
2008-01-24 22:13:08 +01:00
|
|
|
if (!extent_state_cache)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2009-04-13 15:33:09 +02:00
|
|
|
extent_buffer_cache = kmem_cache_create("extent_buffers",
|
|
|
|
sizeof(struct extent_buffer), 0,
|
|
|
|
SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
|
2008-01-24 22:13:08 +01:00
|
|
|
if (!extent_buffer_cache)
|
|
|
|
goto free_state_cache;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
free_state_cache:
|
|
|
|
kmem_cache_destroy(extent_state_cache);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
void extent_io_exit(void)
|
|
|
|
{
|
|
|
|
struct extent_state *state;
|
2008-03-26 21:24:23 +01:00
|
|
|
struct extent_buffer *eb;
|
2008-01-24 22:13:08 +01:00
|
|
|
|
|
|
|
while (!list_empty(&states)) {
|
2008-03-26 21:24:23 +01:00
|
|
|
state = list_entry(states.next, struct extent_state, leak_list);
|
2009-01-06 03:25:51 +01:00
|
|
|
printk(KERN_ERR "btrfs state leak: start %llu end %llu "
|
|
|
|
"state %lu in tree %p refs %d\n",
|
|
|
|
(unsigned long long)state->start,
|
|
|
|
(unsigned long long)state->end,
|
|
|
|
state->state, state->tree, atomic_read(&state->refs));
|
2008-03-26 21:24:23 +01:00
|
|
|
list_del(&state->leak_list);
|
2008-01-24 22:13:08 +01:00
|
|
|
kmem_cache_free(extent_state_cache, state);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2008-03-26 21:24:23 +01:00
|
|
|
while (!list_empty(&buffers)) {
|
|
|
|
eb = list_entry(buffers.next, struct extent_buffer, leak_list);
|
2009-01-06 03:25:51 +01:00
|
|
|
printk(KERN_ERR "btrfs buffer leak start %llu len %lu "
|
|
|
|
"refs %d\n", (unsigned long long)eb->start,
|
|
|
|
eb->len, atomic_read(&eb->refs));
|
2008-03-26 21:24:23 +01:00
|
|
|
list_del(&eb->leak_list);
|
|
|
|
kmem_cache_free(extent_buffer_cache, eb);
|
|
|
|
}
|
2008-01-24 22:13:08 +01:00
|
|
|
if (extent_state_cache)
|
|
|
|
kmem_cache_destroy(extent_state_cache);
|
|
|
|
if (extent_buffer_cache)
|
|
|
|
kmem_cache_destroy(extent_buffer_cache);
|
|
|
|
}
|
|
|
|
|
|
|
|
void extent_io_tree_init(struct extent_io_tree *tree,
|
|
|
|
struct address_space *mapping, gfp_t mask)
|
|
|
|
{
|
|
|
|
tree->state.rb_node = NULL;
|
2008-07-22 17:18:07 +02:00
|
|
|
tree->buffer.rb_node = NULL;
|
2008-01-24 22:13:08 +01:00
|
|
|
tree->ops = NULL;
|
|
|
|
tree->dirty_bytes = 0;
|
2008-01-29 15:59:12 +01:00
|
|
|
spin_lock_init(&tree->lock);
|
2008-07-22 17:18:07 +02:00
|
|
|
spin_lock_init(&tree->buffer_lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
tree->mapping = mapping;
|
|
|
|
}
|
|
|
|
|
2008-12-02 15:54:17 +01:00
|
|
|
static struct extent_state *alloc_extent_state(gfp_t mask)
|
2008-01-24 22:13:08 +01:00
|
|
|
{
|
|
|
|
struct extent_state *state;
|
2009-02-04 15:24:05 +01:00
|
|
|
#if LEAK_DEBUG
|
2008-03-26 21:24:23 +01:00
|
|
|
unsigned long flags;
|
2008-09-08 17:18:08 +02:00
|
|
|
#endif
|
2008-01-24 22:13:08 +01:00
|
|
|
|
|
|
|
state = kmem_cache_alloc(extent_state_cache, mask);
|
2008-04-01 17:21:40 +02:00
|
|
|
if (!state)
|
2008-01-24 22:13:08 +01:00
|
|
|
return state;
|
|
|
|
state->state = 0;
|
|
|
|
state->private = 0;
|
2008-01-29 15:59:12 +01:00
|
|
|
state->tree = NULL;
|
2009-02-04 15:24:05 +01:00
|
|
|
#if LEAK_DEBUG
|
2008-03-26 21:24:23 +01:00
|
|
|
spin_lock_irqsave(&leak_lock, flags);
|
|
|
|
list_add(&state->leak_list, &states);
|
|
|
|
spin_unlock_irqrestore(&leak_lock, flags);
|
2008-09-08 17:18:08 +02:00
|
|
|
#endif
|
2008-01-24 22:13:08 +01:00
|
|
|
atomic_set(&state->refs, 1);
|
|
|
|
init_waitqueue_head(&state->wq);
|
|
|
|
return state;
|
|
|
|
}
|
|
|
|
|
2008-12-02 15:54:17 +01:00
|
|
|
static void free_extent_state(struct extent_state *state)
|
2008-01-24 22:13:08 +01:00
|
|
|
{
|
|
|
|
if (!state)
|
|
|
|
return;
|
|
|
|
if (atomic_dec_and_test(&state->refs)) {
|
2009-02-04 15:24:05 +01:00
|
|
|
#if LEAK_DEBUG
|
2008-03-26 21:24:23 +01:00
|
|
|
unsigned long flags;
|
2008-09-08 17:18:08 +02:00
|
|
|
#endif
|
2008-01-29 15:59:12 +01:00
|
|
|
WARN_ON(state->tree);
|
2009-02-04 15:24:05 +01:00
|
|
|
#if LEAK_DEBUG
|
2008-03-26 21:24:23 +01:00
|
|
|
spin_lock_irqsave(&leak_lock, flags);
|
|
|
|
list_del(&state->leak_list);
|
|
|
|
spin_unlock_irqrestore(&leak_lock, flags);
|
2008-09-08 17:18:08 +02:00
|
|
|
#endif
|
2008-01-24 22:13:08 +01:00
|
|
|
kmem_cache_free(extent_state_cache, state);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct rb_node *tree_insert(struct rb_root *root, u64 offset,
|
|
|
|
struct rb_node *node)
|
|
|
|
{
|
2009-01-06 03:25:51 +01:00
|
|
|
struct rb_node **p = &root->rb_node;
|
|
|
|
struct rb_node *parent = NULL;
|
2008-01-24 22:13:08 +01:00
|
|
|
struct tree_entry *entry;
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (*p) {
|
2008-01-24 22:13:08 +01:00
|
|
|
parent = *p;
|
|
|
|
entry = rb_entry(parent, struct tree_entry, rb_node);
|
|
|
|
|
|
|
|
if (offset < entry->start)
|
|
|
|
p = &(*p)->rb_left;
|
|
|
|
else if (offset > entry->end)
|
|
|
|
p = &(*p)->rb_right;
|
|
|
|
else
|
|
|
|
return parent;
|
|
|
|
}
|
|
|
|
|
|
|
|
entry = rb_entry(node, struct tree_entry, rb_node);
|
|
|
|
rb_link_node(node, parent, p);
|
|
|
|
rb_insert_color(node, root);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-02-01 20:51:59 +01:00
|
|
|
static struct rb_node *__etree_search(struct extent_io_tree *tree, u64 offset,
|
2008-01-24 22:13:08 +01:00
|
|
|
struct rb_node **prev_ret,
|
|
|
|
struct rb_node **next_ret)
|
|
|
|
{
|
2008-02-01 20:51:59 +01:00
|
|
|
struct rb_root *root = &tree->state;
|
2009-01-06 03:25:51 +01:00
|
|
|
struct rb_node *n = root->rb_node;
|
2008-01-24 22:13:08 +01:00
|
|
|
struct rb_node *prev = NULL;
|
|
|
|
struct rb_node *orig_prev = NULL;
|
|
|
|
struct tree_entry *entry;
|
|
|
|
struct tree_entry *prev_entry = NULL;
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (n) {
|
2008-01-24 22:13:08 +01:00
|
|
|
entry = rb_entry(n, struct tree_entry, rb_node);
|
|
|
|
prev = n;
|
|
|
|
prev_entry = entry;
|
|
|
|
|
|
|
|
if (offset < entry->start)
|
|
|
|
n = n->rb_left;
|
|
|
|
else if (offset > entry->end)
|
|
|
|
n = n->rb_right;
|
2009-01-06 03:25:51 +01:00
|
|
|
else
|
2008-01-24 22:13:08 +01:00
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (prev_ret) {
|
|
|
|
orig_prev = prev;
|
2009-01-06 03:25:51 +01:00
|
|
|
while (prev && offset > prev_entry->end) {
|
2008-01-24 22:13:08 +01:00
|
|
|
prev = rb_next(prev);
|
|
|
|
prev_entry = rb_entry(prev, struct tree_entry, rb_node);
|
|
|
|
}
|
|
|
|
*prev_ret = prev;
|
|
|
|
prev = orig_prev;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (next_ret) {
|
|
|
|
prev_entry = rb_entry(prev, struct tree_entry, rb_node);
|
2009-01-06 03:25:51 +01:00
|
|
|
while (prev && offset < prev_entry->start) {
|
2008-01-24 22:13:08 +01:00
|
|
|
prev = rb_prev(prev);
|
|
|
|
prev_entry = rb_entry(prev, struct tree_entry, rb_node);
|
|
|
|
}
|
|
|
|
*next_ret = prev;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-02-01 20:51:59 +01:00
|
|
|
static inline struct rb_node *tree_search(struct extent_io_tree *tree,
|
|
|
|
u64 offset)
|
2008-01-24 22:13:08 +01:00
|
|
|
{
|
2008-01-29 15:59:12 +01:00
|
|
|
struct rb_node *prev = NULL;
|
2008-01-24 22:13:08 +01:00
|
|
|
struct rb_node *ret;
|
2008-01-29 15:59:12 +01:00
|
|
|
|
2008-02-01 20:51:59 +01:00
|
|
|
ret = __etree_search(tree, offset, &prev, NULL);
|
2009-01-06 03:25:51 +01:00
|
|
|
if (!ret)
|
2008-01-24 22:13:08 +01:00
|
|
|
return prev;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-07-22 17:18:07 +02:00
|
|
|
static struct extent_buffer *buffer_tree_insert(struct extent_io_tree *tree,
|
|
|
|
u64 offset, struct rb_node *node)
|
|
|
|
{
|
|
|
|
struct rb_root *root = &tree->buffer;
|
2009-01-06 03:25:51 +01:00
|
|
|
struct rb_node **p = &root->rb_node;
|
|
|
|
struct rb_node *parent = NULL;
|
2008-07-22 17:18:07 +02:00
|
|
|
struct extent_buffer *eb;
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (*p) {
|
2008-07-22 17:18:07 +02:00
|
|
|
parent = *p;
|
|
|
|
eb = rb_entry(parent, struct extent_buffer, rb_node);
|
|
|
|
|
|
|
|
if (offset < eb->start)
|
|
|
|
p = &(*p)->rb_left;
|
|
|
|
else if (offset > eb->start)
|
|
|
|
p = &(*p)->rb_right;
|
|
|
|
else
|
|
|
|
return eb;
|
|
|
|
}
|
|
|
|
|
|
|
|
rb_link_node(node, parent, p);
|
|
|
|
rb_insert_color(node, root);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct extent_buffer *buffer_search(struct extent_io_tree *tree,
|
|
|
|
u64 offset)
|
|
|
|
{
|
|
|
|
struct rb_root *root = &tree->buffer;
|
2009-01-06 03:25:51 +01:00
|
|
|
struct rb_node *n = root->rb_node;
|
2008-07-22 17:18:07 +02:00
|
|
|
struct extent_buffer *eb;
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (n) {
|
2008-07-22 17:18:07 +02:00
|
|
|
eb = rb_entry(n, struct extent_buffer, rb_node);
|
|
|
|
if (offset < eb->start)
|
|
|
|
n = n->rb_left;
|
|
|
|
else if (offset > eb->start)
|
|
|
|
n = n->rb_right;
|
|
|
|
else
|
|
|
|
return eb;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
/*
|
|
|
|
* utility function to look for merge candidates inside a given range.
|
|
|
|
* Any extents with matching state are merged together into a single
|
|
|
|
* extent in the tree. Extents with EXTENT_IO in their state field
|
|
|
|
* are not merged because the end_io handlers need to be able to do
|
|
|
|
* operations on them without sleeping (or doing allocations/splits).
|
|
|
|
*
|
|
|
|
* This should be called with the tree lock held.
|
|
|
|
*/
|
|
|
|
static int merge_state(struct extent_io_tree *tree,
|
|
|
|
struct extent_state *state)
|
|
|
|
{
|
|
|
|
struct extent_state *other;
|
|
|
|
struct rb_node *other_node;
|
|
|
|
|
2008-09-26 16:05:38 +02:00
|
|
|
if (state->state & (EXTENT_IOBITS | EXTENT_BOUNDARY))
|
2008-01-24 22:13:08 +01:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
other_node = rb_prev(&state->rb_node);
|
|
|
|
if (other_node) {
|
|
|
|
other = rb_entry(other_node, struct extent_state, rb_node);
|
|
|
|
if (other->end == state->start - 1 &&
|
|
|
|
other->state == state->state) {
|
|
|
|
state->start = other->start;
|
2008-01-29 15:59:12 +01:00
|
|
|
other->tree = NULL;
|
2008-01-24 22:13:08 +01:00
|
|
|
rb_erase(&other->rb_node, &tree->state);
|
|
|
|
free_extent_state(other);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
other_node = rb_next(&state->rb_node);
|
|
|
|
if (other_node) {
|
|
|
|
other = rb_entry(other_node, struct extent_state, rb_node);
|
|
|
|
if (other->start == state->end + 1 &&
|
|
|
|
other->state == state->state) {
|
|
|
|
other->start = state->start;
|
2008-01-29 15:59:12 +01:00
|
|
|
state->tree = NULL;
|
2008-01-24 22:13:08 +01:00
|
|
|
rb_erase(&state->rb_node, &tree->state);
|
|
|
|
free_extent_state(state);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-01-29 21:55:23 +01:00
|
|
|
static void set_state_cb(struct extent_io_tree *tree,
|
|
|
|
struct extent_state *state,
|
|
|
|
unsigned long bits)
|
|
|
|
{
|
|
|
|
if (tree->ops && tree->ops->set_bit_hook) {
|
|
|
|
tree->ops->set_bit_hook(tree->mapping->host, state->start,
|
2008-01-31 17:05:37 +01:00
|
|
|
state->end, state->state, bits);
|
2008-01-29 21:55:23 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void clear_state_cb(struct extent_io_tree *tree,
|
|
|
|
struct extent_state *state,
|
|
|
|
unsigned long bits)
|
|
|
|
{
|
2009-01-05 21:49:55 +01:00
|
|
|
if (tree->ops && tree->ops->clear_bit_hook) {
|
2008-01-29 21:55:23 +01:00
|
|
|
tree->ops->clear_bit_hook(tree->mapping->host, state->start,
|
2008-01-31 17:05:37 +01:00
|
|
|
state->end, state->state, bits);
|
2008-01-29 21:55:23 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
/*
|
|
|
|
* insert an extent_state struct into the tree. 'bits' are set on the
|
|
|
|
* struct before it is inserted.
|
|
|
|
*
|
|
|
|
* This may return -EEXIST if the extent is already there, in which case the
|
|
|
|
* state struct is freed.
|
|
|
|
*
|
|
|
|
* The tree lock is not taken internally. This is a utility function and
|
|
|
|
* probably isn't what you want to call (see set/clear_extent_bit).
|
|
|
|
*/
|
|
|
|
static int insert_state(struct extent_io_tree *tree,
|
|
|
|
struct extent_state *state, u64 start, u64 end,
|
|
|
|
int bits)
|
|
|
|
{
|
|
|
|
struct rb_node *node;
|
|
|
|
|
|
|
|
if (end < start) {
|
2009-01-06 03:25:51 +01:00
|
|
|
printk(KERN_ERR "btrfs end < start %llu %llu\n",
|
|
|
|
(unsigned long long)end,
|
|
|
|
(unsigned long long)start);
|
2008-01-24 22:13:08 +01:00
|
|
|
WARN_ON(1);
|
|
|
|
}
|
|
|
|
if (bits & EXTENT_DIRTY)
|
|
|
|
tree->dirty_bytes += end - start + 1;
|
|
|
|
state->start = start;
|
|
|
|
state->end = end;
|
2009-09-11 17:25:02 +02:00
|
|
|
set_state_cb(tree, state, bits);
|
|
|
|
state->state |= bits;
|
2008-01-24 22:13:08 +01:00
|
|
|
node = tree_insert(&tree->state, end, &state->rb_node);
|
|
|
|
if (node) {
|
|
|
|
struct extent_state *found;
|
|
|
|
found = rb_entry(node, struct extent_state, rb_node);
|
2009-01-06 03:25:51 +01:00
|
|
|
printk(KERN_ERR "btrfs found node %llu %llu on insert of "
|
|
|
|
"%llu %llu\n", (unsigned long long)found->start,
|
|
|
|
(unsigned long long)found->end,
|
|
|
|
(unsigned long long)start, (unsigned long long)end);
|
2008-01-24 22:13:08 +01:00
|
|
|
free_extent_state(state);
|
|
|
|
return -EEXIST;
|
|
|
|
}
|
2008-01-29 15:59:12 +01:00
|
|
|
state->tree = tree;
|
2008-01-24 22:13:08 +01:00
|
|
|
merge_state(tree, state);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* split a given extent state struct in two, inserting the preallocated
|
|
|
|
* struct 'prealloc' as the newly created second half. 'split' indicates an
|
|
|
|
* offset inside 'orig' where it should be split.
|
|
|
|
*
|
|
|
|
* Before calling,
|
|
|
|
* the tree has 'orig' at [orig->start, orig->end]. After calling, there
|
|
|
|
* are two extent state structs in the tree:
|
|
|
|
* prealloc: [orig->start, split - 1]
|
|
|
|
* orig: [ split, orig->end ]
|
|
|
|
*
|
|
|
|
* The tree locks are not taken by this function. They need to be held
|
|
|
|
* by the caller.
|
|
|
|
*/
|
|
|
|
static int split_state(struct extent_io_tree *tree, struct extent_state *orig,
|
|
|
|
struct extent_state *prealloc, u64 split)
|
|
|
|
{
|
|
|
|
struct rb_node *node;
|
|
|
|
prealloc->start = orig->start;
|
|
|
|
prealloc->end = split - 1;
|
|
|
|
prealloc->state = orig->state;
|
|
|
|
orig->start = split;
|
|
|
|
|
|
|
|
node = tree_insert(&tree->state, prealloc->end, &prealloc->rb_node);
|
|
|
|
if (node) {
|
|
|
|
free_extent_state(prealloc);
|
|
|
|
return -EEXIST;
|
|
|
|
}
|
2008-01-29 15:59:12 +01:00
|
|
|
prealloc->tree = tree;
|
2008-01-24 22:13:08 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* utility function to clear some bits in an extent state struct.
|
|
|
|
* it will optionally wake up any one waiting on this state (wake == 1), or
|
|
|
|
* forcibly remove the state from the tree (delete == 1).
|
|
|
|
*
|
|
|
|
* If no bits are set on the state struct after clearing things, the
|
|
|
|
* struct is freed and removed from the tree
|
|
|
|
*/
|
|
|
|
static int clear_state_bit(struct extent_io_tree *tree,
|
|
|
|
struct extent_state *state, int bits, int wake,
|
|
|
|
int delete)
|
|
|
|
{
|
|
|
|
int ret = state->state & bits;
|
|
|
|
|
|
|
|
if ((bits & EXTENT_DIRTY) && (state->state & EXTENT_DIRTY)) {
|
|
|
|
u64 range = state->end - state->start + 1;
|
|
|
|
WARN_ON(range > tree->dirty_bytes);
|
|
|
|
tree->dirty_bytes -= range;
|
|
|
|
}
|
2008-01-29 21:55:23 +01:00
|
|
|
clear_state_cb(tree, state, bits);
|
2008-01-31 17:05:37 +01:00
|
|
|
state->state &= ~bits;
|
2008-01-24 22:13:08 +01:00
|
|
|
if (wake)
|
|
|
|
wake_up(&state->wq);
|
|
|
|
if (delete || state->state == 0) {
|
2008-01-29 15:59:12 +01:00
|
|
|
if (state->tree) {
|
2008-02-01 21:42:15 +01:00
|
|
|
clear_state_cb(tree, state, state->state);
|
2008-01-24 22:13:08 +01:00
|
|
|
rb_erase(&state->rb_node, &tree->state);
|
2008-01-29 15:59:12 +01:00
|
|
|
state->tree = NULL;
|
2008-01-24 22:13:08 +01:00
|
|
|
free_extent_state(state);
|
|
|
|
} else {
|
|
|
|
WARN_ON(1);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
merge_state(tree, state);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* clear some bits on a range in the tree. This may require splitting
|
|
|
|
* or inserting elements in the tree, so the gfp mask is used to
|
|
|
|
* indicate which allocations or sleeping are allowed.
|
|
|
|
*
|
|
|
|
* pass 'wake' == 1 to kick any sleepers, and 'delete' == 1 to remove
|
|
|
|
* the given range from the tree regardless of state (ie for truncate).
|
|
|
|
*
|
|
|
|
* the range [start, end] is inclusive.
|
|
|
|
*
|
|
|
|
* This takes the tree lock, and returns < 0 on error, > 0 if any of the
|
|
|
|
* bits were already set, or zero if none of the bits were already set.
|
|
|
|
*/
|
|
|
|
int clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end,
|
2009-09-02 21:04:12 +02:00
|
|
|
int bits, int wake, int delete,
|
|
|
|
struct extent_state **cached_state,
|
|
|
|
gfp_t mask)
|
2008-01-24 22:13:08 +01:00
|
|
|
{
|
|
|
|
struct extent_state *state;
|
2009-09-02 21:04:12 +02:00
|
|
|
struct extent_state *cached;
|
2008-01-24 22:13:08 +01:00
|
|
|
struct extent_state *prealloc = NULL;
|
2009-09-02 21:04:12 +02:00
|
|
|
struct rb_node *next_node;
|
2008-01-24 22:13:08 +01:00
|
|
|
struct rb_node *node;
|
2009-05-27 15:16:03 +02:00
|
|
|
u64 last_end;
|
2008-01-24 22:13:08 +01:00
|
|
|
int err;
|
|
|
|
int set = 0;
|
|
|
|
|
|
|
|
again:
|
|
|
|
if (!prealloc && (mask & __GFP_WAIT)) {
|
|
|
|
prealloc = alloc_extent_state(mask);
|
|
|
|
if (!prealloc)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_lock(&tree->lock);
|
2009-09-02 21:04:12 +02:00
|
|
|
if (cached_state) {
|
|
|
|
cached = *cached_state;
|
|
|
|
*cached_state = NULL;
|
|
|
|
if (cached->tree && cached->start == start) {
|
|
|
|
atomic_dec(&cached->refs);
|
|
|
|
state = cached;
|
|
|
|
last_end = state->end;
|
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
free_extent_state(cached);
|
|
|
|
}
|
2008-01-24 22:13:08 +01:00
|
|
|
/*
|
|
|
|
* this search will find the extents that end after
|
|
|
|
* our range starts
|
|
|
|
*/
|
2008-02-01 20:51:59 +01:00
|
|
|
node = tree_search(tree, start);
|
2008-01-24 22:13:08 +01:00
|
|
|
if (!node)
|
|
|
|
goto out;
|
|
|
|
state = rb_entry(node, struct extent_state, rb_node);
|
2009-09-02 21:04:12 +02:00
|
|
|
hit_next:
|
2008-01-24 22:13:08 +01:00
|
|
|
if (state->start > end)
|
|
|
|
goto out;
|
|
|
|
WARN_ON(state->end < start);
|
2009-05-27 15:16:03 +02:00
|
|
|
last_end = state->end;
|
2008-01-24 22:13:08 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* | ---- desired range ---- |
|
|
|
|
* | state | or
|
|
|
|
* | ------------- state -------------- |
|
|
|
|
*
|
|
|
|
* We need to split the extent we found, and may flip
|
|
|
|
* bits on second half.
|
|
|
|
*
|
|
|
|
* If the extent we found extends past our range, we
|
|
|
|
* just split and search again. It'll get split again
|
|
|
|
* the next time though.
|
|
|
|
*
|
|
|
|
* If the extent we found is inside our range, we clear
|
|
|
|
* the desired bit on it.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (state->start < start) {
|
2008-01-29 15:59:12 +01:00
|
|
|
if (!prealloc)
|
|
|
|
prealloc = alloc_extent_state(GFP_ATOMIC);
|
2008-01-24 22:13:08 +01:00
|
|
|
err = split_state(tree, state, prealloc, start);
|
|
|
|
BUG_ON(err == -EEXIST);
|
|
|
|
prealloc = NULL;
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
if (state->end <= end) {
|
|
|
|
set |= clear_state_bit(tree, state, bits,
|
|
|
|
wake, delete);
|
2009-05-27 15:16:03 +02:00
|
|
|
if (last_end == (u64)-1)
|
|
|
|
goto out;
|
|
|
|
start = last_end + 1;
|
2008-01-24 22:13:08 +01:00
|
|
|
} else {
|
|
|
|
start = state->start;
|
|
|
|
}
|
|
|
|
goto search_again;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* | ---- desired range ---- |
|
|
|
|
* | state |
|
|
|
|
* We need to split the extent, and clear the bit
|
|
|
|
* on the first half
|
|
|
|
*/
|
|
|
|
if (state->start <= end && state->end > end) {
|
2008-01-29 15:59:12 +01:00
|
|
|
if (!prealloc)
|
|
|
|
prealloc = alloc_extent_state(GFP_ATOMIC);
|
2008-01-24 22:13:08 +01:00
|
|
|
err = split_state(tree, state, prealloc, end + 1);
|
|
|
|
BUG_ON(err == -EEXIST);
|
|
|
|
|
|
|
|
if (wake)
|
|
|
|
wake_up(&state->wq);
|
|
|
|
set |= clear_state_bit(tree, prealloc, bits,
|
|
|
|
wake, delete);
|
|
|
|
prealloc = NULL;
|
|
|
|
goto out;
|
|
|
|
}
|
2009-09-02 21:04:12 +02:00
|
|
|
found:
|
|
|
|
if (state->end < end && prealloc && !need_resched())
|
|
|
|
next_node = rb_next(&state->rb_node);
|
|
|
|
else
|
|
|
|
next_node = NULL;
|
2008-01-24 22:13:08 +01:00
|
|
|
set |= clear_state_bit(tree, state, bits, wake, delete);
|
2009-05-27 15:16:03 +02:00
|
|
|
if (last_end == (u64)-1)
|
|
|
|
goto out;
|
|
|
|
start = last_end + 1;
|
2009-09-02 21:04:12 +02:00
|
|
|
if (start <= end && next_node) {
|
|
|
|
state = rb_entry(next_node, struct extent_state,
|
|
|
|
rb_node);
|
|
|
|
if (state->start == start)
|
|
|
|
goto hit_next;
|
|
|
|
}
|
2008-01-24 22:13:08 +01:00
|
|
|
goto search_again;
|
|
|
|
|
|
|
|
out:
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_unlock(&tree->lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
if (prealloc)
|
|
|
|
free_extent_state(prealloc);
|
|
|
|
|
|
|
|
return set;
|
|
|
|
|
|
|
|
search_again:
|
|
|
|
if (start > end)
|
|
|
|
goto out;
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_unlock(&tree->lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
if (mask & __GFP_WAIT)
|
|
|
|
cond_resched();
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int wait_on_state(struct extent_io_tree *tree,
|
|
|
|
struct extent_state *state)
|
2008-12-02 12:36:10 +01:00
|
|
|
__releases(tree->lock)
|
|
|
|
__acquires(tree->lock)
|
2008-01-24 22:13:08 +01:00
|
|
|
{
|
|
|
|
DEFINE_WAIT(wait);
|
|
|
|
prepare_to_wait(&state->wq, &wait, TASK_UNINTERRUPTIBLE);
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_unlock(&tree->lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
schedule();
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_lock(&tree->lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
finish_wait(&state->wq, &wait);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* waits for one or more bits to clear on a range in the state tree.
|
|
|
|
* The range [start, end] is inclusive.
|
|
|
|
* The tree lock is taken by this function
|
|
|
|
*/
|
|
|
|
int wait_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, int bits)
|
|
|
|
{
|
|
|
|
struct extent_state *state;
|
|
|
|
struct rb_node *node;
|
|
|
|
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_lock(&tree->lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
again:
|
|
|
|
while (1) {
|
|
|
|
/*
|
|
|
|
* this search will find all the extents that end after
|
|
|
|
* our range starts
|
|
|
|
*/
|
2008-02-01 20:51:59 +01:00
|
|
|
node = tree_search(tree, start);
|
2008-01-24 22:13:08 +01:00
|
|
|
if (!node)
|
|
|
|
break;
|
|
|
|
|
|
|
|
state = rb_entry(node, struct extent_state, rb_node);
|
|
|
|
|
|
|
|
if (state->start > end)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (state->state & bits) {
|
|
|
|
start = state->start;
|
|
|
|
atomic_inc(&state->refs);
|
|
|
|
wait_on_state(tree, state);
|
|
|
|
free_extent_state(state);
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
start = state->end + 1;
|
|
|
|
|
|
|
|
if (start > end)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (need_resched()) {
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_unlock(&tree->lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
cond_resched();
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_lock(&tree->lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
out:
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_unlock(&tree->lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void set_state_bits(struct extent_io_tree *tree,
|
|
|
|
struct extent_state *state,
|
|
|
|
int bits)
|
|
|
|
{
|
|
|
|
if ((bits & EXTENT_DIRTY) && !(state->state & EXTENT_DIRTY)) {
|
|
|
|
u64 range = state->end - state->start + 1;
|
|
|
|
tree->dirty_bytes += range;
|
|
|
|
}
|
2008-01-29 21:55:23 +01:00
|
|
|
set_state_cb(tree, state, bits);
|
2008-01-31 17:05:37 +01:00
|
|
|
state->state |= bits;
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
|
2009-09-02 21:04:12 +02:00
|
|
|
static void cache_state(struct extent_state *state,
|
|
|
|
struct extent_state **cached_ptr)
|
|
|
|
{
|
|
|
|
if (cached_ptr && !(*cached_ptr)) {
|
|
|
|
if (state->state & (EXTENT_IOBITS | EXTENT_BOUNDARY)) {
|
|
|
|
*cached_ptr = state;
|
|
|
|
atomic_inc(&state->refs);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
/*
|
2009-09-02 19:24:36 +02:00
|
|
|
* set some bits on a range in the tree. This may require allocations or
|
|
|
|
* sleeping, so the gfp mask is used to indicate what is allowed.
|
2008-01-24 22:13:08 +01:00
|
|
|
*
|
2009-09-02 19:24:36 +02:00
|
|
|
* If any of the exclusive bits are set, this will fail with -EEXIST if some
|
|
|
|
* part of the range already has the desired bits set. The start of the
|
|
|
|
* existing range is returned in failed_start in this case.
|
2008-01-24 22:13:08 +01:00
|
|
|
*
|
2009-09-02 19:24:36 +02:00
|
|
|
* [start, end] is inclusive This takes the tree lock.
|
2008-01-24 22:13:08 +01:00
|
|
|
*/
|
2009-09-02 19:24:36 +02:00
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
static int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end,
|
2009-09-02 19:24:36 +02:00
|
|
|
int bits, int exclusive_bits, u64 *failed_start,
|
2009-09-02 21:04:12 +02:00
|
|
|
struct extent_state **cached_state,
|
2009-01-06 03:25:51 +01:00
|
|
|
gfp_t mask)
|
2008-01-24 22:13:08 +01:00
|
|
|
{
|
|
|
|
struct extent_state *state;
|
|
|
|
struct extent_state *prealloc = NULL;
|
|
|
|
struct rb_node *node;
|
|
|
|
int err = 0;
|
|
|
|
u64 last_start;
|
|
|
|
u64 last_end;
|
|
|
|
again:
|
|
|
|
if (!prealloc && (mask & __GFP_WAIT)) {
|
|
|
|
prealloc = alloc_extent_state(mask);
|
|
|
|
if (!prealloc)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_lock(&tree->lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
/*
|
|
|
|
* this search will find all the extents that end after
|
|
|
|
* our range starts.
|
|
|
|
*/
|
2008-02-01 20:51:59 +01:00
|
|
|
node = tree_search(tree, start);
|
2008-01-24 22:13:08 +01:00
|
|
|
if (!node) {
|
|
|
|
err = insert_state(tree, prealloc, start, end, bits);
|
|
|
|
prealloc = NULL;
|
|
|
|
BUG_ON(err == -EEXIST);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
state = rb_entry(node, struct extent_state, rb_node);
|
2009-08-05 18:57:59 +02:00
|
|
|
hit_next:
|
2008-01-24 22:13:08 +01:00
|
|
|
last_start = state->start;
|
|
|
|
last_end = state->end;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* | ---- desired range ---- |
|
|
|
|
* | state |
|
|
|
|
*
|
|
|
|
* Just lock what we found and keep going
|
|
|
|
*/
|
|
|
|
if (state->start == start && state->end <= end) {
|
2009-08-05 18:57:59 +02:00
|
|
|
struct rb_node *next_node;
|
2009-09-02 19:24:36 +02:00
|
|
|
if (state->state & exclusive_bits) {
|
2008-01-24 22:13:08 +01:00
|
|
|
*failed_start = state->start;
|
|
|
|
err = -EEXIST;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
set_state_bits(tree, state, bits);
|
2009-09-02 21:04:12 +02:00
|
|
|
cache_state(state, cached_state);
|
2008-01-24 22:13:08 +01:00
|
|
|
merge_state(tree, state);
|
2009-05-27 15:16:03 +02:00
|
|
|
if (last_end == (u64)-1)
|
|
|
|
goto out;
|
2009-08-05 18:57:59 +02:00
|
|
|
|
2009-05-27 15:16:03 +02:00
|
|
|
start = last_end + 1;
|
2009-08-05 18:57:59 +02:00
|
|
|
if (start < end && prealloc && !need_resched()) {
|
|
|
|
next_node = rb_next(node);
|
|
|
|
if (next_node) {
|
|
|
|
state = rb_entry(next_node, struct extent_state,
|
|
|
|
rb_node);
|
|
|
|
if (state->start == start)
|
|
|
|
goto hit_next;
|
|
|
|
}
|
|
|
|
}
|
2008-01-24 22:13:08 +01:00
|
|
|
goto search_again;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* | ---- desired range ---- |
|
|
|
|
* | state |
|
|
|
|
* or
|
|
|
|
* | ------------- state -------------- |
|
|
|
|
*
|
|
|
|
* We need to split the extent we found, and may flip bits on
|
|
|
|
* second half.
|
|
|
|
*
|
|
|
|
* If the extent we found extends past our
|
|
|
|
* range, we just split and search again. It'll get split
|
|
|
|
* again the next time though.
|
|
|
|
*
|
|
|
|
* If the extent we found is inside our range, we set the
|
|
|
|
* desired bit on it.
|
|
|
|
*/
|
|
|
|
if (state->start < start) {
|
2009-09-02 19:24:36 +02:00
|
|
|
if (state->state & exclusive_bits) {
|
2008-01-24 22:13:08 +01:00
|
|
|
*failed_start = start;
|
|
|
|
err = -EEXIST;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
err = split_state(tree, state, prealloc, start);
|
|
|
|
BUG_ON(err == -EEXIST);
|
|
|
|
prealloc = NULL;
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
if (state->end <= end) {
|
|
|
|
set_state_bits(tree, state, bits);
|
2009-09-02 21:04:12 +02:00
|
|
|
cache_state(state, cached_state);
|
2008-01-24 22:13:08 +01:00
|
|
|
merge_state(tree, state);
|
2009-05-27 15:16:03 +02:00
|
|
|
if (last_end == (u64)-1)
|
|
|
|
goto out;
|
|
|
|
start = last_end + 1;
|
2008-01-24 22:13:08 +01:00
|
|
|
} else {
|
|
|
|
start = state->start;
|
|
|
|
}
|
|
|
|
goto search_again;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* | ---- desired range ---- |
|
|
|
|
* | state | or | state |
|
|
|
|
*
|
|
|
|
* There's a hole, we need to insert something in it and
|
|
|
|
* ignore the extent we found.
|
|
|
|
*/
|
|
|
|
if (state->start > start) {
|
|
|
|
u64 this_end;
|
|
|
|
if (end < last_start)
|
|
|
|
this_end = end;
|
|
|
|
else
|
2009-01-06 03:25:51 +01:00
|
|
|
this_end = last_start - 1;
|
2008-01-24 22:13:08 +01:00
|
|
|
err = insert_state(tree, prealloc, start, this_end,
|
|
|
|
bits);
|
2009-09-02 21:04:12 +02:00
|
|
|
cache_state(prealloc, cached_state);
|
2008-01-24 22:13:08 +01:00
|
|
|
prealloc = NULL;
|
|
|
|
BUG_ON(err == -EEXIST);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
start = this_end + 1;
|
|
|
|
goto search_again;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* | ---- desired range ---- |
|
|
|
|
* | state |
|
|
|
|
* We need to split the extent, and set the bit
|
|
|
|
* on the first half
|
|
|
|
*/
|
|
|
|
if (state->start <= end && state->end > end) {
|
2009-09-02 19:24:36 +02:00
|
|
|
if (state->state & exclusive_bits) {
|
2008-01-24 22:13:08 +01:00
|
|
|
*failed_start = start;
|
|
|
|
err = -EEXIST;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
err = split_state(tree, state, prealloc, end + 1);
|
|
|
|
BUG_ON(err == -EEXIST);
|
|
|
|
|
|
|
|
set_state_bits(tree, prealloc, bits);
|
2009-09-02 21:04:12 +02:00
|
|
|
cache_state(prealloc, cached_state);
|
2008-01-24 22:13:08 +01:00
|
|
|
merge_state(tree, prealloc);
|
|
|
|
prealloc = NULL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
goto search_again;
|
|
|
|
|
|
|
|
out:
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_unlock(&tree->lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
if (prealloc)
|
|
|
|
free_extent_state(prealloc);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
search_again:
|
|
|
|
if (start > end)
|
|
|
|
goto out;
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_unlock(&tree->lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
if (mask & __GFP_WAIT)
|
|
|
|
cond_resched();
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* wrappers around set/clear extent bit */
|
|
|
|
int set_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
gfp_t mask)
|
|
|
|
{
|
|
|
|
return set_extent_bit(tree, start, end, EXTENT_DIRTY, 0, NULL,
|
2009-09-02 21:04:12 +02:00
|
|
|
NULL, mask);
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
|
2008-07-17 18:53:50 +02:00
|
|
|
int set_extent_ordered(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
gfp_t mask)
|
|
|
|
{
|
2009-09-02 21:04:12 +02:00
|
|
|
return set_extent_bit(tree, start, end, EXTENT_ORDERED, 0, NULL, NULL,
|
|
|
|
mask);
|
2008-07-17 18:53:50 +02:00
|
|
|
}
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
int set_extent_bits(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
int bits, gfp_t mask)
|
|
|
|
{
|
|
|
|
return set_extent_bit(tree, start, end, bits, 0, NULL,
|
2009-09-02 21:04:12 +02:00
|
|
|
NULL, mask);
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int clear_extent_bits(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
int bits, gfp_t mask)
|
|
|
|
{
|
2009-09-02 21:04:12 +02:00
|
|
|
return clear_extent_bit(tree, start, end, bits, 0, 0, NULL, mask);
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int set_extent_delalloc(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
gfp_t mask)
|
|
|
|
{
|
|
|
|
return set_extent_bit(tree, start, end,
|
2009-08-05 18:57:59 +02:00
|
|
|
EXTENT_DELALLOC | EXTENT_DIRTY | EXTENT_UPTODATE,
|
2009-09-02 21:04:12 +02:00
|
|
|
0, NULL, NULL, mask);
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int clear_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
gfp_t mask)
|
|
|
|
{
|
|
|
|
return clear_extent_bit(tree, start, end,
|
2009-09-02 21:04:12 +02:00
|
|
|
EXTENT_DIRTY | EXTENT_DELALLOC, 0, 0,
|
|
|
|
NULL, mask);
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
|
2008-07-17 18:53:50 +02:00
|
|
|
int clear_extent_ordered(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
gfp_t mask)
|
|
|
|
{
|
2009-09-02 21:04:12 +02:00
|
|
|
return clear_extent_bit(tree, start, end, EXTENT_ORDERED, 1, 0,
|
|
|
|
NULL, mask);
|
2008-07-17 18:53:50 +02:00
|
|
|
}
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
int set_extent_new(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
gfp_t mask)
|
|
|
|
{
|
|
|
|
return set_extent_bit(tree, start, end, EXTENT_NEW, 0, NULL,
|
2009-09-02 21:04:12 +02:00
|
|
|
NULL, mask);
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
|
2008-12-02 15:54:17 +01:00
|
|
|
static int clear_extent_new(struct extent_io_tree *tree, u64 start, u64 end,
|
2008-01-24 22:13:08 +01:00
|
|
|
gfp_t mask)
|
|
|
|
{
|
2009-09-02 21:04:12 +02:00
|
|
|
return clear_extent_bit(tree, start, end, EXTENT_NEW, 0, 0,
|
|
|
|
NULL, mask);
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int set_extent_uptodate(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
gfp_t mask)
|
|
|
|
{
|
|
|
|
return set_extent_bit(tree, start, end, EXTENT_UPTODATE, 0, NULL,
|
2009-09-02 21:04:12 +02:00
|
|
|
NULL, mask);
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
static int clear_extent_uptodate(struct extent_io_tree *tree, u64 start,
|
|
|
|
u64 end, gfp_t mask)
|
2008-01-24 22:13:08 +01:00
|
|
|
{
|
2009-09-02 21:04:12 +02:00
|
|
|
return clear_extent_bit(tree, start, end, EXTENT_UPTODATE, 0, 0,
|
|
|
|
NULL, mask);
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int wait_on_extent_writeback(struct extent_io_tree *tree, u64 start, u64 end)
|
|
|
|
{
|
|
|
|
return wait_extent_bit(tree, start, end, EXTENT_WRITEBACK);
|
|
|
|
}
|
|
|
|
|
2008-09-29 21:18:18 +02:00
|
|
|
/*
|
|
|
|
* either insert or lock state struct between start and end use mask to tell
|
|
|
|
* us if waiting is desired.
|
|
|
|
*/
|
2009-09-02 19:24:36 +02:00
|
|
|
int lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end,
|
2009-09-02 21:04:12 +02:00
|
|
|
int bits, struct extent_state **cached_state, gfp_t mask)
|
2008-01-24 22:13:08 +01:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
u64 failed_start;
|
|
|
|
while (1) {
|
2009-09-02 19:24:36 +02:00
|
|
|
err = set_extent_bit(tree, start, end, EXTENT_LOCKED | bits,
|
2009-09-02 21:04:12 +02:00
|
|
|
EXTENT_LOCKED, &failed_start,
|
|
|
|
cached_state, mask);
|
2008-01-24 22:13:08 +01:00
|
|
|
if (err == -EEXIST && (mask & __GFP_WAIT)) {
|
|
|
|
wait_extent_bit(tree, failed_start, end, EXTENT_LOCKED);
|
|
|
|
start = failed_start;
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
WARN_ON(start > end);
|
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2009-09-02 19:24:36 +02:00
|
|
|
int lock_extent(struct extent_io_tree *tree, u64 start, u64 end, gfp_t mask)
|
|
|
|
{
|
2009-09-02 21:04:12 +02:00
|
|
|
return lock_extent_bits(tree, start, end, 0, NULL, mask);
|
2009-09-02 19:24:36 +02:00
|
|
|
}
|
|
|
|
|
Btrfs: nuke fs wide allocation mutex V2
This patch removes the giant fs_info->alloc_mutex and replaces it with a bunch
of little locks.
There is now a pinned_mutex, which is used when messing with the pinned_extents
extent io tree, and the extent_ins_mutex which is used with the pending_del and
extent_ins extent io trees.
The locking for the extent tree stuff was inspired by a patch that Yan Zheng
wrote to fix a race condition, I cleaned it up some and changed the locking
around a little bit, but the idea remains the same. Basically instead of
holding the extent_ins_mutex throughout the processing of an extent on the
extent_ins or pending_del trees, we just hold it while we're searching and when
we clear the bits on those trees, and lock the extent for the duration of the
operations on the extent.
Also to keep from getting hung up waiting to lock an extent, I've added a
try_lock_extent so if we cannot lock the extent, move on to the next one in the
tree and we'll come back to that one. I have tested this heavily and it does
not appear to break anything. This has to be applied on top of my
find_free_extent redo patch.
I tested this patch on top of Yan's space reblancing code and it worked fine.
The only thing that has changed since the last version is I pulled out all my
debugging stuff, apparently I forgot to run guilt refresh before I sent the
last patch out. Thank you,
Signed-off-by: Josef Bacik <jbacik@redhat.com>
2008-10-29 19:49:05 +01:00
|
|
|
int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
gfp_t mask)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
u64 failed_start;
|
|
|
|
|
2009-09-02 21:04:12 +02:00
|
|
|
err = set_extent_bit(tree, start, end, EXTENT_LOCKED, EXTENT_LOCKED,
|
|
|
|
&failed_start, NULL, mask);
|
2008-10-30 19:19:50 +01:00
|
|
|
if (err == -EEXIST) {
|
|
|
|
if (failed_start > start)
|
|
|
|
clear_extent_bit(tree, start, failed_start - 1,
|
2009-09-02 21:04:12 +02:00
|
|
|
EXTENT_LOCKED, 1, 0, NULL, mask);
|
Btrfs: nuke fs wide allocation mutex V2
This patch removes the giant fs_info->alloc_mutex and replaces it with a bunch
of little locks.
There is now a pinned_mutex, which is used when messing with the pinned_extents
extent io tree, and the extent_ins_mutex which is used with the pending_del and
extent_ins extent io trees.
The locking for the extent tree stuff was inspired by a patch that Yan Zheng
wrote to fix a race condition, I cleaned it up some and changed the locking
around a little bit, but the idea remains the same. Basically instead of
holding the extent_ins_mutex throughout the processing of an extent on the
extent_ins or pending_del trees, we just hold it while we're searching and when
we clear the bits on those trees, and lock the extent for the duration of the
operations on the extent.
Also to keep from getting hung up waiting to lock an extent, I've added a
try_lock_extent so if we cannot lock the extent, move on to the next one in the
tree and we'll come back to that one. I have tested this heavily and it does
not appear to break anything. This has to be applied on top of my
find_free_extent redo patch.
I tested this patch on top of Yan's space reblancing code and it worked fine.
The only thing that has changed since the last version is I pulled out all my
debugging stuff, apparently I forgot to run guilt refresh before I sent the
last patch out. Thank you,
Signed-off-by: Josef Bacik <jbacik@redhat.com>
2008-10-29 19:49:05 +01:00
|
|
|
return 0;
|
2008-10-30 19:19:50 +01:00
|
|
|
}
|
Btrfs: nuke fs wide allocation mutex V2
This patch removes the giant fs_info->alloc_mutex and replaces it with a bunch
of little locks.
There is now a pinned_mutex, which is used when messing with the pinned_extents
extent io tree, and the extent_ins_mutex which is used with the pending_del and
extent_ins extent io trees.
The locking for the extent tree stuff was inspired by a patch that Yan Zheng
wrote to fix a race condition, I cleaned it up some and changed the locking
around a little bit, but the idea remains the same. Basically instead of
holding the extent_ins_mutex throughout the processing of an extent on the
extent_ins or pending_del trees, we just hold it while we're searching and when
we clear the bits on those trees, and lock the extent for the duration of the
operations on the extent.
Also to keep from getting hung up waiting to lock an extent, I've added a
try_lock_extent so if we cannot lock the extent, move on to the next one in the
tree and we'll come back to that one. I have tested this heavily and it does
not appear to break anything. This has to be applied on top of my
find_free_extent redo patch.
I tested this patch on top of Yan's space reblancing code and it worked fine.
The only thing that has changed since the last version is I pulled out all my
debugging stuff, apparently I forgot to run guilt refresh before I sent the
last patch out. Thank you,
Signed-off-by: Josef Bacik <jbacik@redhat.com>
2008-10-29 19:49:05 +01:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-09-02 21:04:12 +02:00
|
|
|
int unlock_extent_cached(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
struct extent_state **cached, gfp_t mask)
|
|
|
|
{
|
|
|
|
return clear_extent_bit(tree, start, end, EXTENT_LOCKED, 1, 0, cached,
|
|
|
|
mask);
|
|
|
|
}
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
int unlock_extent(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
gfp_t mask)
|
|
|
|
{
|
2009-09-02 21:04:12 +02:00
|
|
|
return clear_extent_bit(tree, start, end, EXTENT_LOCKED, 1, 0, NULL,
|
|
|
|
mask);
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* helper function to set pages and extents in the tree dirty
|
|
|
|
*/
|
|
|
|
int set_range_dirty(struct extent_io_tree *tree, u64 start, u64 end)
|
|
|
|
{
|
|
|
|
unsigned long index = start >> PAGE_CACHE_SHIFT;
|
|
|
|
unsigned long end_index = end >> PAGE_CACHE_SHIFT;
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
while (index <= end_index) {
|
|
|
|
page = find_get_page(tree->mapping, index);
|
|
|
|
BUG_ON(!page);
|
|
|
|
__set_page_dirty_nobuffers(page);
|
|
|
|
page_cache_release(page);
|
|
|
|
index++;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* helper function to set both pages and extents in the tree writeback
|
|
|
|
*/
|
2008-12-02 15:54:17 +01:00
|
|
|
static int set_range_writeback(struct extent_io_tree *tree, u64 start, u64 end)
|
2008-01-24 22:13:08 +01:00
|
|
|
{
|
|
|
|
unsigned long index = start >> PAGE_CACHE_SHIFT;
|
|
|
|
unsigned long end_index = end >> PAGE_CACHE_SHIFT;
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
while (index <= end_index) {
|
|
|
|
page = find_get_page(tree->mapping, index);
|
|
|
|
BUG_ON(!page);
|
|
|
|
set_page_writeback(page);
|
|
|
|
page_cache_release(page);
|
|
|
|
index++;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-29 21:18:18 +02:00
|
|
|
/*
|
|
|
|
* find the first offset in the io tree with 'bits' set. zero is
|
|
|
|
* returned if we find something, and *start_ret and *end_ret are
|
|
|
|
* set to reflect the state struct that was found.
|
|
|
|
*
|
|
|
|
* If nothing was found, 1 is returned, < 0 on error
|
|
|
|
*/
|
2008-01-24 22:13:08 +01:00
|
|
|
int find_first_extent_bit(struct extent_io_tree *tree, u64 start,
|
|
|
|
u64 *start_ret, u64 *end_ret, int bits)
|
|
|
|
{
|
|
|
|
struct rb_node *node;
|
|
|
|
struct extent_state *state;
|
|
|
|
int ret = 1;
|
|
|
|
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_lock(&tree->lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
/*
|
|
|
|
* this search will find all the extents that end after
|
|
|
|
* our range starts.
|
|
|
|
*/
|
2008-02-01 20:51:59 +01:00
|
|
|
node = tree_search(tree, start);
|
2009-01-06 03:25:51 +01:00
|
|
|
if (!node)
|
2008-01-24 22:13:08 +01:00
|
|
|
goto out;
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (1) {
|
2008-01-24 22:13:08 +01:00
|
|
|
state = rb_entry(node, struct extent_state, rb_node);
|
|
|
|
if (state->end >= start && (state->state & bits)) {
|
|
|
|
*start_ret = state->start;
|
|
|
|
*end_ret = state->end;
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
node = rb_next(node);
|
|
|
|
if (!node)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
out:
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_unlock(&tree->lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-09-29 21:18:18 +02:00
|
|
|
/* find the first state struct with 'bits' set after 'start', and
|
|
|
|
* return it. tree->lock must be held. NULL will returned if
|
|
|
|
* nothing was found after 'start'
|
|
|
|
*/
|
2008-02-18 18:12:38 +01:00
|
|
|
struct extent_state *find_first_extent_bit_state(struct extent_io_tree *tree,
|
|
|
|
u64 start, int bits)
|
|
|
|
{
|
|
|
|
struct rb_node *node;
|
|
|
|
struct extent_state *state;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* this search will find all the extents that end after
|
|
|
|
* our range starts.
|
|
|
|
*/
|
|
|
|
node = tree_search(tree, start);
|
2009-01-06 03:25:51 +01:00
|
|
|
if (!node)
|
2008-02-18 18:12:38 +01:00
|
|
|
goto out;
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (1) {
|
2008-02-18 18:12:38 +01:00
|
|
|
state = rb_entry(node, struct extent_state, rb_node);
|
2009-01-06 03:25:51 +01:00
|
|
|
if (state->end >= start && (state->state & bits))
|
2008-02-18 18:12:38 +01:00
|
|
|
return state;
|
2009-01-06 03:25:51 +01:00
|
|
|
|
2008-02-18 18:12:38 +01:00
|
|
|
node = rb_next(node);
|
|
|
|
if (!node)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-09-29 21:18:18 +02:00
|
|
|
/*
|
|
|
|
* find a contiguous range of bytes in the file marked as delalloc, not
|
|
|
|
* more than 'max_bytes'. start and end are used to return the range,
|
|
|
|
*
|
|
|
|
* 1 is returned if we find something, 0 if nothing was in the tree
|
|
|
|
*/
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
static noinline u64 find_delalloc_range(struct extent_io_tree *tree,
|
|
|
|
u64 *start, u64 *end, u64 max_bytes)
|
2008-01-24 22:13:08 +01:00
|
|
|
{
|
|
|
|
struct rb_node *node;
|
|
|
|
struct extent_state *state;
|
|
|
|
u64 cur_start = *start;
|
|
|
|
u64 found = 0;
|
|
|
|
u64 total_bytes = 0;
|
|
|
|
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_lock(&tree->lock);
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
/*
|
|
|
|
* this search will find all the extents that end after
|
|
|
|
* our range starts.
|
|
|
|
*/
|
2008-02-01 20:51:59 +01:00
|
|
|
node = tree_search(tree, cur_start);
|
2008-04-01 17:21:40 +02:00
|
|
|
if (!node) {
|
2008-04-17 17:29:12 +02:00
|
|
|
if (!found)
|
|
|
|
*end = (u64)-1;
|
2008-01-24 22:13:08 +01:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (1) {
|
2008-01-24 22:13:08 +01:00
|
|
|
state = rb_entry(node, struct extent_state, rb_node);
|
2008-09-26 16:05:38 +02:00
|
|
|
if (found && (state->start != cur_start ||
|
|
|
|
(state->state & EXTENT_BOUNDARY))) {
|
2008-01-24 22:13:08 +01:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (!(state->state & EXTENT_DELALLOC)) {
|
|
|
|
if (!found)
|
|
|
|
*end = state->end;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (!found)
|
|
|
|
*start = state->start;
|
|
|
|
found++;
|
|
|
|
*end = state->end;
|
|
|
|
cur_start = state->end + 1;
|
|
|
|
node = rb_next(node);
|
|
|
|
if (!node)
|
|
|
|
break;
|
|
|
|
total_bytes += state->end - state->start + 1;
|
|
|
|
if (total_bytes >= max_bytes)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
out:
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_unlock(&tree->lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
static noinline int __unlock_for_delalloc(struct inode *inode,
|
|
|
|
struct page *locked_page,
|
|
|
|
u64 start, u64 end)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct page *pages[16];
|
|
|
|
unsigned long index = start >> PAGE_CACHE_SHIFT;
|
|
|
|
unsigned long end_index = end >> PAGE_CACHE_SHIFT;
|
|
|
|
unsigned long nr_pages = end_index - index + 1;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (index == locked_page->index && end_index == index)
|
|
|
|
return 0;
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (nr_pages > 0) {
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
ret = find_get_pages_contig(inode->i_mapping, index,
|
2008-11-11 15:34:41 +01:00
|
|
|
min_t(unsigned long, nr_pages,
|
|
|
|
ARRAY_SIZE(pages)), pages);
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
for (i = 0; i < ret; i++) {
|
|
|
|
if (pages[i] != locked_page)
|
|
|
|
unlock_page(pages[i]);
|
|
|
|
page_cache_release(pages[i]);
|
|
|
|
}
|
|
|
|
nr_pages -= ret;
|
|
|
|
index += ret;
|
|
|
|
cond_resched();
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static noinline int lock_delalloc_pages(struct inode *inode,
|
|
|
|
struct page *locked_page,
|
|
|
|
u64 delalloc_start,
|
|
|
|
u64 delalloc_end)
|
|
|
|
{
|
|
|
|
unsigned long index = delalloc_start >> PAGE_CACHE_SHIFT;
|
|
|
|
unsigned long start_index = index;
|
|
|
|
unsigned long end_index = delalloc_end >> PAGE_CACHE_SHIFT;
|
|
|
|
unsigned long pages_locked = 0;
|
|
|
|
struct page *pages[16];
|
|
|
|
unsigned long nrpages;
|
|
|
|
int ret;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* the caller is responsible for locking the start index */
|
|
|
|
if (index == locked_page->index && index == end_index)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* skip the page at the start index */
|
|
|
|
nrpages = end_index - index + 1;
|
2009-01-06 03:25:51 +01:00
|
|
|
while (nrpages > 0) {
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
ret = find_get_pages_contig(inode->i_mapping, index,
|
2008-11-11 15:34:41 +01:00
|
|
|
min_t(unsigned long,
|
|
|
|
nrpages, ARRAY_SIZE(pages)), pages);
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
if (ret == 0) {
|
|
|
|
ret = -EAGAIN;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
/* now we have an array of pages, lock them all */
|
|
|
|
for (i = 0; i < ret; i++) {
|
|
|
|
/*
|
|
|
|
* the caller is taking responsibility for
|
|
|
|
* locked_page
|
|
|
|
*/
|
2008-11-07 04:02:51 +01:00
|
|
|
if (pages[i] != locked_page) {
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
lock_page(pages[i]);
|
2008-11-10 13:31:30 +01:00
|
|
|
if (!PageDirty(pages[i]) ||
|
|
|
|
pages[i]->mapping != inode->i_mapping) {
|
2008-11-07 04:02:51 +01:00
|
|
|
ret = -EAGAIN;
|
|
|
|
unlock_page(pages[i]);
|
|
|
|
page_cache_release(pages[i]);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
page_cache_release(pages[i]);
|
2008-11-07 04:02:51 +01:00
|
|
|
pages_locked++;
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
}
|
|
|
|
nrpages -= ret;
|
|
|
|
index += ret;
|
|
|
|
cond_resched();
|
|
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
done:
|
|
|
|
if (ret && pages_locked) {
|
|
|
|
__unlock_for_delalloc(inode, locked_page,
|
|
|
|
delalloc_start,
|
|
|
|
((u64)(start_index + pages_locked - 1)) <<
|
|
|
|
PAGE_CACHE_SHIFT);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* find a contiguous range of bytes in the file marked as delalloc, not
|
|
|
|
* more than 'max_bytes'. start and end are used to return the range,
|
|
|
|
*
|
|
|
|
* 1 is returned if we find something, 0 if nothing was in the tree
|
|
|
|
*/
|
|
|
|
static noinline u64 find_lock_delalloc_range(struct inode *inode,
|
|
|
|
struct extent_io_tree *tree,
|
|
|
|
struct page *locked_page,
|
|
|
|
u64 *start, u64 *end,
|
|
|
|
u64 max_bytes)
|
|
|
|
{
|
|
|
|
u64 delalloc_start;
|
|
|
|
u64 delalloc_end;
|
|
|
|
u64 found;
|
|
|
|
int ret;
|
|
|
|
int loops = 0;
|
|
|
|
|
|
|
|
again:
|
|
|
|
/* step one, find a bunch of delalloc bytes starting at start */
|
|
|
|
delalloc_start = *start;
|
|
|
|
delalloc_end = 0;
|
|
|
|
found = find_delalloc_range(tree, &delalloc_start, &delalloc_end,
|
|
|
|
max_bytes);
|
2008-10-31 17:46:39 +01:00
|
|
|
if (!found || delalloc_end <= *start) {
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
*start = delalloc_start;
|
|
|
|
*end = delalloc_end;
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
2008-10-31 17:46:39 +01:00
|
|
|
/*
|
|
|
|
* start comes from the offset of locked_page. We have to lock
|
|
|
|
* pages in order, so we can't process delalloc bytes before
|
|
|
|
* locked_page
|
|
|
|
*/
|
2009-01-06 03:25:51 +01:00
|
|
|
if (delalloc_start < *start)
|
2008-10-31 17:46:39 +01:00
|
|
|
delalloc_start = *start;
|
|
|
|
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
/*
|
|
|
|
* make sure to limit the number of pages we try to lock down
|
|
|
|
* if we're looping.
|
|
|
|
*/
|
2009-01-06 03:25:51 +01:00
|
|
|
if (delalloc_end + 1 - delalloc_start > max_bytes && loops)
|
2008-11-07 04:02:51 +01:00
|
|
|
delalloc_end = delalloc_start + PAGE_CACHE_SIZE - 1;
|
2009-01-06 03:25:51 +01:00
|
|
|
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
/* step two, lock all the pages after the page that has start */
|
|
|
|
ret = lock_delalloc_pages(inode, locked_page,
|
|
|
|
delalloc_start, delalloc_end);
|
|
|
|
if (ret == -EAGAIN) {
|
|
|
|
/* some of the pages are gone, lets avoid looping by
|
|
|
|
* shortening the size of the delalloc range we're searching
|
|
|
|
*/
|
|
|
|
if (!loops) {
|
|
|
|
unsigned long offset = (*start) & (PAGE_CACHE_SIZE - 1);
|
|
|
|
max_bytes = PAGE_CACHE_SIZE - offset;
|
|
|
|
loops = 1;
|
|
|
|
goto again;
|
|
|
|
} else {
|
|
|
|
found = 0;
|
|
|
|
goto out_failed;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
|
|
|
/* step three, lock the state bits for the whole range */
|
|
|
|
lock_extent(tree, delalloc_start, delalloc_end, GFP_NOFS);
|
|
|
|
|
|
|
|
/* then test to make sure it is all still delalloc */
|
|
|
|
ret = test_range_bit(tree, delalloc_start, delalloc_end,
|
|
|
|
EXTENT_DELALLOC, 1);
|
|
|
|
if (!ret) {
|
|
|
|
unlock_extent(tree, delalloc_start, delalloc_end, GFP_NOFS);
|
|
|
|
__unlock_for_delalloc(inode, locked_page,
|
|
|
|
delalloc_start, delalloc_end);
|
|
|
|
cond_resched();
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
*start = delalloc_start;
|
|
|
|
*end = delalloc_end;
|
|
|
|
out_failed:
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
|
|
|
int extent_clear_unlock_delalloc(struct inode *inode,
|
|
|
|
struct extent_io_tree *tree,
|
|
|
|
u64 start, u64 end, struct page *locked_page,
|
2008-11-07 04:02:51 +01:00
|
|
|
int unlock_pages,
|
|
|
|
int clear_unlock,
|
|
|
|
int clear_delalloc, int clear_dirty,
|
|
|
|
int set_writeback,
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
int end_writeback)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct page *pages[16];
|
|
|
|
unsigned long index = start >> PAGE_CACHE_SHIFT;
|
|
|
|
unsigned long end_index = end >> PAGE_CACHE_SHIFT;
|
|
|
|
unsigned long nr_pages = end_index - index + 1;
|
|
|
|
int i;
|
2008-11-07 04:02:51 +01:00
|
|
|
int clear_bits = 0;
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
|
2008-11-07 04:02:51 +01:00
|
|
|
if (clear_unlock)
|
|
|
|
clear_bits |= EXTENT_LOCKED;
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
if (clear_dirty)
|
|
|
|
clear_bits |= EXTENT_DIRTY;
|
|
|
|
|
2008-11-07 04:02:51 +01:00
|
|
|
if (clear_delalloc)
|
|
|
|
clear_bits |= EXTENT_DELALLOC;
|
|
|
|
|
2009-09-02 21:04:12 +02:00
|
|
|
clear_extent_bit(tree, start, end, clear_bits, 1, 0, NULL, GFP_NOFS);
|
2008-11-07 04:02:51 +01:00
|
|
|
if (!(unlock_pages || clear_dirty || set_writeback || end_writeback))
|
|
|
|
return 0;
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (nr_pages > 0) {
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
ret = find_get_pages_contig(inode->i_mapping, index,
|
2008-11-11 15:34:41 +01:00
|
|
|
min_t(unsigned long,
|
|
|
|
nr_pages, ARRAY_SIZE(pages)), pages);
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
for (i = 0; i < ret; i++) {
|
|
|
|
if (pages[i] == locked_page) {
|
|
|
|
page_cache_release(pages[i]);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (clear_dirty)
|
|
|
|
clear_page_dirty_for_io(pages[i]);
|
|
|
|
if (set_writeback)
|
|
|
|
set_page_writeback(pages[i]);
|
|
|
|
if (end_writeback)
|
|
|
|
end_page_writeback(pages[i]);
|
2008-11-07 04:02:51 +01:00
|
|
|
if (unlock_pages)
|
|
|
|
unlock_page(pages[i]);
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
page_cache_release(pages[i]);
|
|
|
|
}
|
|
|
|
nr_pages -= ret;
|
|
|
|
index += ret;
|
|
|
|
cond_resched();
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-29 21:18:18 +02:00
|
|
|
/*
|
|
|
|
* count the number of bytes in the tree that have a given bit(s)
|
|
|
|
* set. This can be fairly slow, except for EXTENT_DIRTY which is
|
|
|
|
* cached. The total number found is returned.
|
|
|
|
*/
|
2008-01-24 22:13:08 +01:00
|
|
|
u64 count_range_bits(struct extent_io_tree *tree,
|
|
|
|
u64 *start, u64 search_end, u64 max_bytes,
|
|
|
|
unsigned long bits)
|
|
|
|
{
|
|
|
|
struct rb_node *node;
|
|
|
|
struct extent_state *state;
|
|
|
|
u64 cur_start = *start;
|
|
|
|
u64 total_bytes = 0;
|
|
|
|
int found = 0;
|
|
|
|
|
|
|
|
if (search_end <= cur_start) {
|
|
|
|
WARN_ON(1);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_lock(&tree->lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
if (cur_start == 0 && bits == EXTENT_DIRTY) {
|
|
|
|
total_bytes = tree->dirty_bytes;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* this search will find all the extents that end after
|
|
|
|
* our range starts.
|
|
|
|
*/
|
2008-02-01 20:51:59 +01:00
|
|
|
node = tree_search(tree, cur_start);
|
2009-01-06 03:25:51 +01:00
|
|
|
if (!node)
|
2008-01-24 22:13:08 +01:00
|
|
|
goto out;
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (1) {
|
2008-01-24 22:13:08 +01:00
|
|
|
state = rb_entry(node, struct extent_state, rb_node);
|
|
|
|
if (state->start > search_end)
|
|
|
|
break;
|
|
|
|
if (state->end >= cur_start && (state->state & bits)) {
|
|
|
|
total_bytes += min(search_end, state->end) + 1 -
|
|
|
|
max(cur_start, state->start);
|
|
|
|
if (total_bytes >= max_bytes)
|
|
|
|
break;
|
|
|
|
if (!found) {
|
|
|
|
*start = state->start;
|
|
|
|
found = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
node = rb_next(node);
|
|
|
|
if (!node)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
out:
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_unlock(&tree->lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
return total_bytes;
|
|
|
|
}
|
2008-12-02 15:54:17 +01:00
|
|
|
|
2008-09-29 21:18:18 +02:00
|
|
|
/*
|
|
|
|
* set the private field for a given byte offset in the tree. If there isn't
|
|
|
|
* an extent_state there already, this does nothing.
|
|
|
|
*/
|
2008-01-24 22:13:08 +01:00
|
|
|
int set_state_private(struct extent_io_tree *tree, u64 start, u64 private)
|
|
|
|
{
|
|
|
|
struct rb_node *node;
|
|
|
|
struct extent_state *state;
|
|
|
|
int ret = 0;
|
|
|
|
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_lock(&tree->lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
/*
|
|
|
|
* this search will find all the extents that end after
|
|
|
|
* our range starts.
|
|
|
|
*/
|
2008-02-01 20:51:59 +01:00
|
|
|
node = tree_search(tree, start);
|
2008-04-01 17:21:40 +02:00
|
|
|
if (!node) {
|
2008-01-24 22:13:08 +01:00
|
|
|
ret = -ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
state = rb_entry(node, struct extent_state, rb_node);
|
|
|
|
if (state->start != start) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
state->private = private;
|
|
|
|
out:
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_unlock(&tree->lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int get_state_private(struct extent_io_tree *tree, u64 start, u64 *private)
|
|
|
|
{
|
|
|
|
struct rb_node *node;
|
|
|
|
struct extent_state *state;
|
|
|
|
int ret = 0;
|
|
|
|
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_lock(&tree->lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
/*
|
|
|
|
* this search will find all the extents that end after
|
|
|
|
* our range starts.
|
|
|
|
*/
|
2008-02-01 20:51:59 +01:00
|
|
|
node = tree_search(tree, start);
|
2008-04-01 17:21:40 +02:00
|
|
|
if (!node) {
|
2008-01-24 22:13:08 +01:00
|
|
|
ret = -ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
state = rb_entry(node, struct extent_state, rb_node);
|
|
|
|
if (state->start != start) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
*private = state->private;
|
|
|
|
out:
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_unlock(&tree->lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* searches a range in the state tree for a given mask.
|
2008-01-29 15:59:12 +01:00
|
|
|
* If 'filled' == 1, this returns 1 only if every extent in the tree
|
2008-01-24 22:13:08 +01:00
|
|
|
* has the bits set. Otherwise, 1 is returned if any bit in the
|
|
|
|
* range is found set.
|
|
|
|
*/
|
|
|
|
int test_range_bit(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
int bits, int filled)
|
|
|
|
{
|
|
|
|
struct extent_state *state = NULL;
|
|
|
|
struct rb_node *node;
|
|
|
|
int bitset = 0;
|
|
|
|
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_lock(&tree->lock);
|
2008-02-01 20:51:59 +01:00
|
|
|
node = tree_search(tree, start);
|
2008-01-24 22:13:08 +01:00
|
|
|
while (node && start <= end) {
|
|
|
|
state = rb_entry(node, struct extent_state, rb_node);
|
|
|
|
|
|
|
|
if (filled && state->start > start) {
|
|
|
|
bitset = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (state->start > end)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (state->state & bits) {
|
|
|
|
bitset = 1;
|
|
|
|
if (!filled)
|
|
|
|
break;
|
|
|
|
} else if (filled) {
|
|
|
|
bitset = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
start = state->end + 1;
|
|
|
|
if (start > end)
|
|
|
|
break;
|
|
|
|
node = rb_next(node);
|
|
|
|
if (!node) {
|
|
|
|
if (filled)
|
|
|
|
bitset = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2008-12-17 20:51:42 +01:00
|
|
|
spin_unlock(&tree->lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
return bitset;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* helper function to set a given page up to date if all the
|
|
|
|
* extents in the tree for that page are up to date
|
|
|
|
*/
|
|
|
|
static int check_page_uptodate(struct extent_io_tree *tree,
|
|
|
|
struct page *page)
|
|
|
|
{
|
|
|
|
u64 start = (u64)page->index << PAGE_CACHE_SHIFT;
|
|
|
|
u64 end = start + PAGE_CACHE_SIZE - 1;
|
|
|
|
if (test_range_bit(tree, start, end, EXTENT_UPTODATE, 1))
|
|
|
|
SetPageUptodate(page);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* helper function to unlock a page if all the extents in the tree
|
|
|
|
* for that page are unlocked
|
|
|
|
*/
|
|
|
|
static int check_page_locked(struct extent_io_tree *tree,
|
|
|
|
struct page *page)
|
|
|
|
{
|
|
|
|
u64 start = (u64)page->index << PAGE_CACHE_SHIFT;
|
|
|
|
u64 end = start + PAGE_CACHE_SIZE - 1;
|
|
|
|
if (!test_range_bit(tree, start, end, EXTENT_LOCKED, 0))
|
|
|
|
unlock_page(page);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* helper function to end page writeback if all the extents
|
|
|
|
* in the tree for that page are done with writeback
|
|
|
|
*/
|
|
|
|
static int check_page_writeback(struct extent_io_tree *tree,
|
|
|
|
struct page *page)
|
|
|
|
{
|
2009-09-02 19:24:36 +02:00
|
|
|
end_page_writeback(page);
|
2008-01-24 22:13:08 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* lots and lots of room for performance fixes in the end_bio funcs */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* after a writepage IO is done, we need to:
|
|
|
|
* clear the uptodate bits on error
|
|
|
|
* clear the writeback bits in the extent tree for this IO
|
|
|
|
* end_page_writeback if the page has no more pending IO
|
|
|
|
*
|
|
|
|
* Scheduling is not allowed, so the extent state tree is expected
|
|
|
|
* to have one and only one object corresponding to this IO.
|
|
|
|
*/
|
|
|
|
static void end_bio_extent_writepage(struct bio *bio, int err)
|
|
|
|
{
|
2008-05-12 19:39:03 +02:00
|
|
|
int uptodate = err == 0;
|
2008-01-24 22:13:08 +01:00
|
|
|
struct bio_vec *bvec = bio->bi_io_vec + bio->bi_vcnt - 1;
|
2008-08-20 14:51:49 +02:00
|
|
|
struct extent_io_tree *tree;
|
2008-01-24 22:13:08 +01:00
|
|
|
u64 start;
|
|
|
|
u64 end;
|
|
|
|
int whole_page;
|
2008-05-12 19:39:03 +02:00
|
|
|
int ret;
|
2008-01-24 22:13:08 +01:00
|
|
|
|
|
|
|
do {
|
|
|
|
struct page *page = bvec->bv_page;
|
2008-08-20 14:51:49 +02:00
|
|
|
tree = &BTRFS_I(page->mapping->host)->io_tree;
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
start = ((u64)page->index << PAGE_CACHE_SHIFT) +
|
|
|
|
bvec->bv_offset;
|
|
|
|
end = start + bvec->bv_len - 1;
|
|
|
|
|
|
|
|
if (bvec->bv_offset == 0 && bvec->bv_len == PAGE_CACHE_SIZE)
|
|
|
|
whole_page = 1;
|
|
|
|
else
|
|
|
|
whole_page = 0;
|
|
|
|
|
|
|
|
if (--bvec >= bio->bi_io_vec)
|
|
|
|
prefetchw(&bvec->bv_page->flags);
|
2008-05-12 19:39:03 +02:00
|
|
|
if (tree->ops && tree->ops->writepage_end_io_hook) {
|
|
|
|
ret = tree->ops->writepage_end_io_hook(page, start,
|
2008-08-20 14:51:49 +02:00
|
|
|
end, NULL, uptodate);
|
2008-05-12 19:39:03 +02:00
|
|
|
if (ret)
|
|
|
|
uptodate = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!uptodate && tree->ops &&
|
|
|
|
tree->ops->writepage_io_failed_hook) {
|
|
|
|
ret = tree->ops->writepage_io_failed_hook(bio, page,
|
2008-08-20 14:51:49 +02:00
|
|
|
start, end, NULL);
|
2008-05-12 19:39:03 +02:00
|
|
|
if (ret == 0) {
|
|
|
|
uptodate = (err == 0);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
if (!uptodate) {
|
2009-09-02 19:24:36 +02:00
|
|
|
clear_extent_uptodate(tree, start, end, GFP_NOFS);
|
2008-01-24 22:13:08 +01:00
|
|
|
ClearPageUptodate(page);
|
|
|
|
SetPageError(page);
|
|
|
|
}
|
2008-01-29 15:59:12 +01:00
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
if (whole_page)
|
|
|
|
end_page_writeback(page);
|
|
|
|
else
|
|
|
|
check_page_writeback(tree, page);
|
|
|
|
} while (bvec >= bio->bi_io_vec);
|
2008-09-24 17:48:04 +02:00
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
bio_put(bio);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* after a readpage IO is done, we need to:
|
|
|
|
* clear the uptodate bits on error
|
|
|
|
* set the uptodate bits if things worked
|
|
|
|
* set the page up to date if all extents in the tree are uptodate
|
|
|
|
* clear the lock bit in the extent tree
|
|
|
|
* unlock the page if there are no other extents locked for it
|
|
|
|
*
|
|
|
|
* Scheduling is not allowed, so the extent state tree is expected
|
|
|
|
* to have one and only one object corresponding to this IO.
|
|
|
|
*/
|
|
|
|
static void end_bio_extent_readpage(struct bio *bio, int err)
|
|
|
|
{
|
|
|
|
int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
|
|
|
|
struct bio_vec *bvec = bio->bi_io_vec + bio->bi_vcnt - 1;
|
2008-08-20 14:51:49 +02:00
|
|
|
struct extent_io_tree *tree;
|
2008-01-24 22:13:08 +01:00
|
|
|
u64 start;
|
|
|
|
u64 end;
|
|
|
|
int whole_page;
|
|
|
|
int ret;
|
|
|
|
|
Btrfs: move data checksumming into a dedicated tree
Btrfs stores checksums for each data block. Until now, they have
been stored in the subvolume trees, indexed by the inode that is
referencing the data block. This means that when we read the inode,
we've probably read in at least some checksums as well.
But, this has a few problems:
* The checksums are indexed by logical offset in the file. When
compression is on, this means we have to do the expensive checksumming
on the uncompressed data. It would be faster if we could checksum
the compressed data instead.
* If we implement encryption, we'll be checksumming the plain text and
storing that on disk. This is significantly less secure.
* For either compression or encryption, we have to get the plain text
back before we can verify the checksum as correct. This makes the raid
layer balancing and extent moving much more expensive.
* It makes the front end caching code more complex, as we have touch
the subvolume and inodes as we cache extents.
* There is potentitally one copy of the checksum in each subvolume
referencing an extent.
The solution used here is to store the extent checksums in a dedicated
tree. This allows us to index the checksums by phyiscal extent
start and length. It means:
* The checksum is against the data stored on disk, after any compression
or encryption is done.
* The checksum is stored in a central location, and can be verified without
following back references, or reading inodes.
This makes compression significantly faster by reducing the amount of
data that needs to be checksummed. It will also allow much faster
raid management code in general.
The checksums are indexed by a key with a fixed objectid (a magic value
in ctree.h) and offset set to the starting byte of the extent. This
allows us to copy the checksum items into the fsync log tree directly (or
any other tree), without having to invent a second format for them.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-12-08 22:58:54 +01:00
|
|
|
if (err)
|
|
|
|
uptodate = 0;
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
do {
|
|
|
|
struct page *page = bvec->bv_page;
|
2008-08-20 14:51:49 +02:00
|
|
|
tree = &BTRFS_I(page->mapping->host)->io_tree;
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
start = ((u64)page->index << PAGE_CACHE_SHIFT) +
|
|
|
|
bvec->bv_offset;
|
|
|
|
end = start + bvec->bv_len - 1;
|
|
|
|
|
|
|
|
if (bvec->bv_offset == 0 && bvec->bv_len == PAGE_CACHE_SIZE)
|
|
|
|
whole_page = 1;
|
|
|
|
else
|
|
|
|
whole_page = 0;
|
|
|
|
|
|
|
|
if (--bvec >= bio->bi_io_vec)
|
|
|
|
prefetchw(&bvec->bv_page->flags);
|
|
|
|
|
|
|
|
if (uptodate && tree->ops && tree->ops->readpage_end_io_hook) {
|
2008-01-29 15:59:12 +01:00
|
|
|
ret = tree->ops->readpage_end_io_hook(page, start, end,
|
2008-08-20 14:51:49 +02:00
|
|
|
NULL);
|
2008-01-24 22:13:08 +01:00
|
|
|
if (ret)
|
|
|
|
uptodate = 0;
|
|
|
|
}
|
2008-04-09 22:28:12 +02:00
|
|
|
if (!uptodate && tree->ops &&
|
|
|
|
tree->ops->readpage_io_failed_hook) {
|
|
|
|
ret = tree->ops->readpage_io_failed_hook(bio, page,
|
2008-08-20 14:51:49 +02:00
|
|
|
start, end, NULL);
|
2008-04-09 22:28:12 +02:00
|
|
|
if (ret == 0) {
|
2008-04-17 17:29:12 +02:00
|
|
|
uptodate =
|
|
|
|
test_bit(BIO_UPTODATE, &bio->bi_flags);
|
Btrfs: move data checksumming into a dedicated tree
Btrfs stores checksums for each data block. Until now, they have
been stored in the subvolume trees, indexed by the inode that is
referencing the data block. This means that when we read the inode,
we've probably read in at least some checksums as well.
But, this has a few problems:
* The checksums are indexed by logical offset in the file. When
compression is on, this means we have to do the expensive checksumming
on the uncompressed data. It would be faster if we could checksum
the compressed data instead.
* If we implement encryption, we'll be checksumming the plain text and
storing that on disk. This is significantly less secure.
* For either compression or encryption, we have to get the plain text
back before we can verify the checksum as correct. This makes the raid
layer balancing and extent moving much more expensive.
* It makes the front end caching code more complex, as we have touch
the subvolume and inodes as we cache extents.
* There is potentitally one copy of the checksum in each subvolume
referencing an extent.
The solution used here is to store the extent checksums in a dedicated
tree. This allows us to index the checksums by phyiscal extent
start and length. It means:
* The checksum is against the data stored on disk, after any compression
or encryption is done.
* The checksum is stored in a central location, and can be verified without
following back references, or reading inodes.
This makes compression significantly faster by reducing the amount of
data that needs to be checksummed. It will also allow much faster
raid management code in general.
The checksums are indexed by a key with a fixed objectid (a magic value
in ctree.h) and offset set to the starting byte of the extent. This
allows us to copy the checksum items into the fsync log tree directly (or
any other tree), without having to invent a second format for them.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-12-08 22:58:54 +01:00
|
|
|
if (err)
|
|
|
|
uptodate = 0;
|
2008-04-09 22:28:12 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2008-01-24 22:13:08 +01:00
|
|
|
|
2008-11-07 04:02:51 +01:00
|
|
|
if (uptodate) {
|
2008-08-20 14:51:49 +02:00
|
|
|
set_extent_uptodate(tree, start, end,
|
|
|
|
GFP_ATOMIC);
|
2008-11-07 04:02:51 +01:00
|
|
|
}
|
2008-08-20 14:51:49 +02:00
|
|
|
unlock_extent(tree, start, end, GFP_ATOMIC);
|
2008-01-24 22:13:08 +01:00
|
|
|
|
2008-01-29 15:59:12 +01:00
|
|
|
if (whole_page) {
|
|
|
|
if (uptodate) {
|
|
|
|
SetPageUptodate(page);
|
|
|
|
} else {
|
|
|
|
ClearPageUptodate(page);
|
|
|
|
SetPageError(page);
|
|
|
|
}
|
2008-01-24 22:13:08 +01:00
|
|
|
unlock_page(page);
|
2008-01-29 15:59:12 +01:00
|
|
|
} else {
|
|
|
|
if (uptodate) {
|
|
|
|
check_page_uptodate(tree, page);
|
|
|
|
} else {
|
|
|
|
ClearPageUptodate(page);
|
|
|
|
SetPageError(page);
|
|
|
|
}
|
2008-01-24 22:13:08 +01:00
|
|
|
check_page_locked(tree, page);
|
2008-01-29 15:59:12 +01:00
|
|
|
}
|
2008-01-24 22:13:08 +01:00
|
|
|
} while (bvec >= bio->bi_io_vec);
|
|
|
|
|
|
|
|
bio_put(bio);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* IO done from prepare_write is pretty simple, we just unlock
|
|
|
|
* the structs in the extent tree when done, and set the uptodate bits
|
|
|
|
* as appropriate.
|
|
|
|
*/
|
|
|
|
static void end_bio_extent_preparewrite(struct bio *bio, int err)
|
|
|
|
{
|
|
|
|
const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
|
|
|
|
struct bio_vec *bvec = bio->bi_io_vec + bio->bi_vcnt - 1;
|
2008-08-20 14:51:49 +02:00
|
|
|
struct extent_io_tree *tree;
|
2008-01-24 22:13:08 +01:00
|
|
|
u64 start;
|
|
|
|
u64 end;
|
|
|
|
|
|
|
|
do {
|
|
|
|
struct page *page = bvec->bv_page;
|
2008-08-20 14:51:49 +02:00
|
|
|
tree = &BTRFS_I(page->mapping->host)->io_tree;
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
start = ((u64)page->index << PAGE_CACHE_SHIFT) +
|
|
|
|
bvec->bv_offset;
|
|
|
|
end = start + bvec->bv_len - 1;
|
|
|
|
|
|
|
|
if (--bvec >= bio->bi_io_vec)
|
|
|
|
prefetchw(&bvec->bv_page->flags);
|
|
|
|
|
|
|
|
if (uptodate) {
|
|
|
|
set_extent_uptodate(tree, start, end, GFP_ATOMIC);
|
|
|
|
} else {
|
|
|
|
ClearPageUptodate(page);
|
|
|
|
SetPageError(page);
|
|
|
|
}
|
|
|
|
|
|
|
|
unlock_extent(tree, start, end, GFP_ATOMIC);
|
|
|
|
|
|
|
|
} while (bvec >= bio->bi_io_vec);
|
|
|
|
|
|
|
|
bio_put(bio);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct bio *
|
|
|
|
extent_bio_alloc(struct block_device *bdev, u64 first_sector, int nr_vecs,
|
|
|
|
gfp_t gfp_flags)
|
|
|
|
{
|
|
|
|
struct bio *bio;
|
|
|
|
|
|
|
|
bio = bio_alloc(gfp_flags, nr_vecs);
|
|
|
|
|
|
|
|
if (bio == NULL && (current->flags & PF_MEMALLOC)) {
|
|
|
|
while (!bio && (nr_vecs /= 2))
|
|
|
|
bio = bio_alloc(gfp_flags, nr_vecs);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bio) {
|
2008-04-22 19:26:46 +02:00
|
|
|
bio->bi_size = 0;
|
2008-01-24 22:13:08 +01:00
|
|
|
bio->bi_bdev = bdev;
|
|
|
|
bio->bi_sector = first_sector;
|
|
|
|
}
|
|
|
|
return bio;
|
|
|
|
}
|
|
|
|
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
static int submit_one_bio(int rw, struct bio *bio, int mirror_num,
|
|
|
|
unsigned long bio_flags)
|
2008-01-24 22:13:08 +01:00
|
|
|
{
|
|
|
|
int ret = 0;
|
2008-01-29 15:59:12 +01:00
|
|
|
struct bio_vec *bvec = bio->bi_io_vec + bio->bi_vcnt - 1;
|
|
|
|
struct page *page = bvec->bv_page;
|
|
|
|
struct extent_io_tree *tree = bio->bi_private;
|
|
|
|
u64 start;
|
|
|
|
u64 end;
|
|
|
|
|
|
|
|
start = ((u64)page->index << PAGE_CACHE_SHIFT) + bvec->bv_offset;
|
|
|
|
end = start + bvec->bv_len - 1;
|
|
|
|
|
2008-08-20 14:51:49 +02:00
|
|
|
bio->bi_private = NULL;
|
2008-01-24 22:13:08 +01:00
|
|
|
|
|
|
|
bio_get(bio);
|
|
|
|
|
2008-02-20 18:07:25 +01:00
|
|
|
if (tree->ops && tree->ops->submit_bio_hook)
|
2008-04-09 22:28:12 +02:00
|
|
|
tree->ops->submit_bio_hook(page->mapping->host, rw, bio,
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
mirror_num, bio_flags);
|
2008-03-24 20:01:56 +01:00
|
|
|
else
|
|
|
|
submit_bio(rw, bio);
|
2008-01-24 22:13:08 +01:00
|
|
|
if (bio_flagged(bio, BIO_EOPNOTSUPP))
|
|
|
|
ret = -EOPNOTSUPP;
|
|
|
|
bio_put(bio);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int submit_extent_page(int rw, struct extent_io_tree *tree,
|
|
|
|
struct page *page, sector_t sector,
|
|
|
|
size_t size, unsigned long offset,
|
|
|
|
struct block_device *bdev,
|
|
|
|
struct bio **bio_ret,
|
|
|
|
unsigned long max_pages,
|
2008-04-09 22:28:12 +02:00
|
|
|
bio_end_io_t end_io_func,
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
int mirror_num,
|
|
|
|
unsigned long prev_bio_flags,
|
|
|
|
unsigned long bio_flags)
|
2008-01-24 22:13:08 +01:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct bio *bio;
|
|
|
|
int nr;
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
int contig = 0;
|
|
|
|
int this_compressed = bio_flags & EXTENT_BIO_COMPRESSED;
|
|
|
|
int old_compressed = prev_bio_flags & EXTENT_BIO_COMPRESSED;
|
2008-11-11 15:34:41 +01:00
|
|
|
size_t page_size = min_t(size_t, size, PAGE_CACHE_SIZE);
|
2008-01-24 22:13:08 +01:00
|
|
|
|
|
|
|
if (bio_ret && *bio_ret) {
|
|
|
|
bio = *bio_ret;
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
if (old_compressed)
|
|
|
|
contig = bio->bi_sector == sector;
|
|
|
|
else
|
|
|
|
contig = bio->bi_sector + (bio->bi_size >> 9) ==
|
|
|
|
sector;
|
|
|
|
|
|
|
|
if (prev_bio_flags != bio_flags || !contig ||
|
2008-03-24 20:02:07 +01:00
|
|
|
(tree->ops && tree->ops->merge_bio_hook &&
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
tree->ops->merge_bio_hook(page, offset, page_size, bio,
|
|
|
|
bio_flags)) ||
|
|
|
|
bio_add_page(bio, page, page_size, offset) < page_size) {
|
|
|
|
ret = submit_one_bio(rw, bio, mirror_num,
|
|
|
|
prev_bio_flags);
|
2008-01-24 22:13:08 +01:00
|
|
|
bio = NULL;
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
if (this_compressed)
|
|
|
|
nr = BIO_MAX_PAGES;
|
|
|
|
else
|
|
|
|
nr = bio_get_nr_vecs(bdev);
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
bio = extent_bio_alloc(bdev, sector, nr, GFP_NOFS | __GFP_HIGH);
|
2008-01-29 15:59:12 +01:00
|
|
|
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
bio_add_page(bio, page, page_size, offset);
|
2008-01-24 22:13:08 +01:00
|
|
|
bio->bi_end_io = end_io_func;
|
|
|
|
bio->bi_private = tree;
|
2008-01-29 15:59:12 +01:00
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
if (bio_ret)
|
2008-01-24 22:13:08 +01:00
|
|
|
*bio_ret = bio;
|
2009-01-06 03:25:51 +01:00
|
|
|
else
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
ret = submit_one_bio(rw, bio, mirror_num, bio_flags);
|
2008-01-24 22:13:08 +01:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void set_page_extent_mapped(struct page *page)
|
|
|
|
{
|
|
|
|
if (!PagePrivate(page)) {
|
|
|
|
SetPagePrivate(page);
|
|
|
|
page_cache_get(page);
|
2008-07-22 17:18:07 +02:00
|
|
|
set_page_private(page, EXTENT_PAGE_PRIVATE);
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-02 15:54:17 +01:00
|
|
|
static void set_page_extent_head(struct page *page, unsigned long len)
|
2008-01-24 22:13:08 +01:00
|
|
|
{
|
|
|
|
set_page_private(page, EXTENT_PAGE_PRIVATE_FIRST_PAGE | len << 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* basic readpage implementation. Locked extent state structs are inserted
|
|
|
|
* into the tree that are removed when the IO is done (by the end_io
|
|
|
|
* handlers)
|
|
|
|
*/
|
|
|
|
static int __extent_read_full_page(struct extent_io_tree *tree,
|
|
|
|
struct page *page,
|
|
|
|
get_extent_t *get_extent,
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
struct bio **bio, int mirror_num,
|
|
|
|
unsigned long *bio_flags)
|
2008-01-24 22:13:08 +01:00
|
|
|
{
|
|
|
|
struct inode *inode = page->mapping->host;
|
|
|
|
u64 start = (u64)page->index << PAGE_CACHE_SHIFT;
|
|
|
|
u64 page_end = start + PAGE_CACHE_SIZE - 1;
|
|
|
|
u64 end;
|
|
|
|
u64 cur = start;
|
|
|
|
u64 extent_offset;
|
|
|
|
u64 last_byte = i_size_read(inode);
|
|
|
|
u64 block_start;
|
|
|
|
u64 cur_end;
|
|
|
|
sector_t sector;
|
|
|
|
struct extent_map *em;
|
|
|
|
struct block_device *bdev;
|
|
|
|
int ret;
|
|
|
|
int nr = 0;
|
|
|
|
size_t page_offset = 0;
|
|
|
|
size_t iosize;
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
size_t disk_io_size;
|
2008-01-24 22:13:08 +01:00
|
|
|
size_t blocksize = inode->i_sb->s_blocksize;
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
unsigned long this_bio_flag = 0;
|
2008-01-24 22:13:08 +01:00
|
|
|
|
|
|
|
set_page_extent_mapped(page);
|
|
|
|
|
|
|
|
end = page_end;
|
|
|
|
lock_extent(tree, start, end, GFP_NOFS);
|
|
|
|
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
if (page->index == last_byte >> PAGE_CACHE_SHIFT) {
|
|
|
|
char *userpage;
|
|
|
|
size_t zero_offset = last_byte & (PAGE_CACHE_SIZE - 1);
|
|
|
|
|
|
|
|
if (zero_offset) {
|
|
|
|
iosize = PAGE_CACHE_SIZE - zero_offset;
|
|
|
|
userpage = kmap_atomic(page, KM_USER0);
|
|
|
|
memset(userpage + zero_offset, 0, iosize);
|
|
|
|
flush_dcache_page(page);
|
|
|
|
kunmap_atomic(userpage, KM_USER0);
|
|
|
|
}
|
|
|
|
}
|
2008-01-24 22:13:08 +01:00
|
|
|
while (cur <= end) {
|
|
|
|
if (cur >= last_byte) {
|
|
|
|
char *userpage;
|
|
|
|
iosize = PAGE_CACHE_SIZE - page_offset;
|
|
|
|
userpage = kmap_atomic(page, KM_USER0);
|
|
|
|
memset(userpage + page_offset, 0, iosize);
|
|
|
|
flush_dcache_page(page);
|
|
|
|
kunmap_atomic(userpage, KM_USER0);
|
|
|
|
set_extent_uptodate(tree, cur, cur + iosize - 1,
|
|
|
|
GFP_NOFS);
|
|
|
|
unlock_extent(tree, cur, cur + iosize - 1, GFP_NOFS);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
em = get_extent(inode, page, page_offset, cur,
|
|
|
|
end - cur + 1, 0);
|
|
|
|
if (IS_ERR(em) || !em) {
|
|
|
|
SetPageError(page);
|
|
|
|
unlock_extent(tree, cur, end, GFP_NOFS);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
extent_offset = cur - em->start;
|
|
|
|
BUG_ON(extent_map_end(em) <= cur);
|
|
|
|
BUG_ON(end < cur);
|
|
|
|
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags))
|
|
|
|
this_bio_flag = EXTENT_BIO_COMPRESSED;
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
iosize = min(extent_map_end(em) - cur, end - cur + 1);
|
|
|
|
cur_end = min(extent_map_end(em) - 1, end);
|
|
|
|
iosize = (iosize + blocksize - 1) & ~((u64)blocksize - 1);
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
if (this_bio_flag & EXTENT_BIO_COMPRESSED) {
|
|
|
|
disk_io_size = em->block_len;
|
|
|
|
sector = em->block_start >> 9;
|
|
|
|
} else {
|
|
|
|
sector = (em->block_start + extent_offset) >> 9;
|
|
|
|
disk_io_size = iosize;
|
|
|
|
}
|
2008-01-24 22:13:08 +01:00
|
|
|
bdev = em->bdev;
|
|
|
|
block_start = em->block_start;
|
2008-10-30 19:25:28 +01:00
|
|
|
if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
|
|
|
|
block_start = EXTENT_MAP_HOLE;
|
2008-01-24 22:13:08 +01:00
|
|
|
free_extent_map(em);
|
|
|
|
em = NULL;
|
|
|
|
|
|
|
|
/* we've found a hole, just zero and go on */
|
|
|
|
if (block_start == EXTENT_MAP_HOLE) {
|
|
|
|
char *userpage;
|
|
|
|
userpage = kmap_atomic(page, KM_USER0);
|
|
|
|
memset(userpage + page_offset, 0, iosize);
|
|
|
|
flush_dcache_page(page);
|
|
|
|
kunmap_atomic(userpage, KM_USER0);
|
|
|
|
|
|
|
|
set_extent_uptodate(tree, cur, cur + iosize - 1,
|
|
|
|
GFP_NOFS);
|
|
|
|
unlock_extent(tree, cur, cur + iosize - 1, GFP_NOFS);
|
|
|
|
cur = cur + iosize;
|
|
|
|
page_offset += iosize;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
/* the get_extent function already copied into the page */
|
|
|
|
if (test_range_bit(tree, cur, cur_end, EXTENT_UPTODATE, 1)) {
|
2008-09-05 22:09:51 +02:00
|
|
|
check_page_uptodate(tree, page);
|
2008-01-24 22:13:08 +01:00
|
|
|
unlock_extent(tree, cur, cur + iosize - 1, GFP_NOFS);
|
|
|
|
cur = cur + iosize;
|
|
|
|
page_offset += iosize;
|
|
|
|
continue;
|
|
|
|
}
|
2008-01-29 15:59:12 +01:00
|
|
|
/* we have an inline extent but it didn't get marked up
|
|
|
|
* to date. Error out
|
|
|
|
*/
|
|
|
|
if (block_start == EXTENT_MAP_INLINE) {
|
|
|
|
SetPageError(page);
|
|
|
|
unlock_extent(tree, cur, cur + iosize - 1, GFP_NOFS);
|
|
|
|
cur = cur + iosize;
|
|
|
|
page_offset += iosize;
|
|
|
|
continue;
|
|
|
|
}
|
2008-01-24 22:13:08 +01:00
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
if (tree->ops && tree->ops->readpage_io_hook) {
|
|
|
|
ret = tree->ops->readpage_io_hook(page, cur,
|
|
|
|
cur + iosize - 1);
|
|
|
|
}
|
|
|
|
if (!ret) {
|
2008-07-24 15:41:53 +02:00
|
|
|
unsigned long pnr = (last_byte >> PAGE_CACHE_SHIFT) + 1;
|
|
|
|
pnr -= page->index;
|
2008-01-24 22:13:08 +01:00
|
|
|
ret = submit_extent_page(READ, tree, page,
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
sector, disk_io_size, page_offset,
|
2008-07-24 15:41:53 +02:00
|
|
|
bdev, bio, pnr,
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
end_bio_extent_readpage, mirror_num,
|
|
|
|
*bio_flags,
|
|
|
|
this_bio_flag);
|
2008-07-24 15:41:53 +02:00
|
|
|
nr++;
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
*bio_flags = this_bio_flag;
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
if (ret)
|
|
|
|
SetPageError(page);
|
|
|
|
cur = cur + iosize;
|
|
|
|
page_offset += iosize;
|
|
|
|
}
|
|
|
|
if (!nr) {
|
|
|
|
if (!PageError(page))
|
|
|
|
SetPageUptodate(page);
|
|
|
|
unlock_page(page);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int extent_read_full_page(struct extent_io_tree *tree, struct page *page,
|
|
|
|
get_extent_t *get_extent)
|
|
|
|
{
|
|
|
|
struct bio *bio = NULL;
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
unsigned long bio_flags = 0;
|
2008-01-24 22:13:08 +01:00
|
|
|
int ret;
|
|
|
|
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
ret = __extent_read_full_page(tree, page, get_extent, &bio, 0,
|
|
|
|
&bio_flags);
|
2008-01-24 22:13:08 +01:00
|
|
|
if (bio)
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
submit_one_bio(READ, bio, 0, bio_flags);
|
2008-01-24 22:13:08 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-04-20 21:50:09 +02:00
|
|
|
static noinline void update_nr_written(struct page *page,
|
|
|
|
struct writeback_control *wbc,
|
|
|
|
unsigned long nr_written)
|
|
|
|
{
|
|
|
|
wbc->nr_to_write -= nr_written;
|
|
|
|
if (wbc->range_cyclic || (wbc->nr_to_write > 0 &&
|
|
|
|
wbc->range_start == 0 && wbc->range_end == LLONG_MAX))
|
|
|
|
page->mapping->writeback_index = page->index + nr_written;
|
|
|
|
}
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
/*
|
|
|
|
* the writepage semantics are similar to regular writepage. extent
|
|
|
|
* records are inserted to lock ranges in the tree, and as dirty areas
|
|
|
|
* are found, they are marked writeback. Then the lock bits are removed
|
|
|
|
* and the end_io handler clears the writeback ranges
|
|
|
|
*/
|
|
|
|
static int __extent_writepage(struct page *page, struct writeback_control *wbc,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct inode *inode = page->mapping->host;
|
|
|
|
struct extent_page_data *epd = data;
|
|
|
|
struct extent_io_tree *tree = epd->tree;
|
|
|
|
u64 start = (u64)page->index << PAGE_CACHE_SHIFT;
|
|
|
|
u64 delalloc_start;
|
|
|
|
u64 page_end = start + PAGE_CACHE_SIZE - 1;
|
|
|
|
u64 end;
|
|
|
|
u64 cur = start;
|
|
|
|
u64 extent_offset;
|
|
|
|
u64 last_byte = i_size_read(inode);
|
|
|
|
u64 block_start;
|
|
|
|
u64 iosize;
|
2008-07-17 18:53:50 +02:00
|
|
|
u64 unlock_start;
|
2008-01-24 22:13:08 +01:00
|
|
|
sector_t sector;
|
2009-09-02 21:04:12 +02:00
|
|
|
struct extent_state *cached_state = NULL;
|
2008-01-24 22:13:08 +01:00
|
|
|
struct extent_map *em;
|
|
|
|
struct block_device *bdev;
|
|
|
|
int ret;
|
|
|
|
int nr = 0;
|
2008-07-18 18:01:11 +02:00
|
|
|
size_t pg_offset = 0;
|
2008-01-24 22:13:08 +01:00
|
|
|
size_t blocksize;
|
|
|
|
loff_t i_size = i_size_read(inode);
|
|
|
|
unsigned long end_index = i_size >> PAGE_CACHE_SHIFT;
|
|
|
|
u64 nr_delalloc;
|
|
|
|
u64 delalloc_end;
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
int page_started;
|
|
|
|
int compressed;
|
2009-04-20 21:50:09 +02:00
|
|
|
int write_flags;
|
2008-11-07 04:02:51 +01:00
|
|
|
unsigned long nr_written = 0;
|
2008-01-24 22:13:08 +01:00
|
|
|
|
2009-04-20 21:50:09 +02:00
|
|
|
if (wbc->sync_mode == WB_SYNC_ALL)
|
|
|
|
write_flags = WRITE_SYNC_PLUG;
|
|
|
|
else
|
|
|
|
write_flags = WRITE;
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
WARN_ON(!PageLocked(page));
|
2008-07-18 18:01:11 +02:00
|
|
|
pg_offset = i_size & (PAGE_CACHE_SIZE - 1);
|
2008-05-15 15:13:45 +02:00
|
|
|
if (page->index > end_index ||
|
2008-07-18 18:01:11 +02:00
|
|
|
(page->index == end_index && !pg_offset)) {
|
2008-11-10 17:50:50 +01:00
|
|
|
page->mapping->a_ops->invalidatepage(page, 0);
|
2008-01-24 22:13:08 +01:00
|
|
|
unlock_page(page);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (page->index == end_index) {
|
|
|
|
char *userpage;
|
|
|
|
|
|
|
|
userpage = kmap_atomic(page, KM_USER0);
|
2008-07-18 18:01:11 +02:00
|
|
|
memset(userpage + pg_offset, 0,
|
|
|
|
PAGE_CACHE_SIZE - pg_offset);
|
2008-01-24 22:13:08 +01:00
|
|
|
kunmap_atomic(userpage, KM_USER0);
|
2008-05-15 15:13:45 +02:00
|
|
|
flush_dcache_page(page);
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
2008-07-18 18:01:11 +02:00
|
|
|
pg_offset = 0;
|
2008-01-24 22:13:08 +01:00
|
|
|
|
|
|
|
set_page_extent_mapped(page);
|
|
|
|
|
|
|
|
delalloc_start = start;
|
|
|
|
delalloc_end = 0;
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
page_started = 0;
|
2008-11-07 04:02:51 +01:00
|
|
|
if (!epd->extent_locked) {
|
2009-08-07 15:28:20 +02:00
|
|
|
u64 delalloc_to_write;
|
2009-04-20 21:50:09 +02:00
|
|
|
/*
|
|
|
|
* make sure the wbc mapping index is at least updated
|
|
|
|
* to this page.
|
|
|
|
*/
|
|
|
|
update_nr_written(page, wbc, 0);
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (delalloc_end < page_end) {
|
2008-11-07 04:02:51 +01:00
|
|
|
nr_delalloc = find_lock_delalloc_range(inode, tree,
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
page,
|
|
|
|
&delalloc_start,
|
2008-01-24 22:13:08 +01:00
|
|
|
&delalloc_end,
|
|
|
|
128 * 1024 * 1024);
|
2008-11-07 04:02:51 +01:00
|
|
|
if (nr_delalloc == 0) {
|
|
|
|
delalloc_start = delalloc_end + 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
tree->ops->fill_delalloc(inode, page, delalloc_start,
|
|
|
|
delalloc_end, &page_started,
|
|
|
|
&nr_written);
|
2009-08-07 15:28:20 +02:00
|
|
|
delalloc_to_write = (delalloc_end -
|
|
|
|
max_t(u64, page_offset(page),
|
|
|
|
delalloc_start) + 1) >>
|
|
|
|
PAGE_CACHE_SHIFT;
|
|
|
|
if (wbc->nr_to_write < delalloc_to_write) {
|
|
|
|
wbc->nr_to_write = min_t(long, 8192,
|
|
|
|
delalloc_to_write);
|
|
|
|
}
|
2008-01-24 22:13:08 +01:00
|
|
|
delalloc_start = delalloc_end + 1;
|
|
|
|
}
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
|
2008-11-07 04:02:51 +01:00
|
|
|
/* did the fill delalloc function already unlock and start
|
|
|
|
* the IO?
|
|
|
|
*/
|
|
|
|
if (page_started) {
|
|
|
|
ret = 0;
|
2009-04-20 21:50:09 +02:00
|
|
|
/*
|
|
|
|
* we've unlocked the page, so we can't update
|
|
|
|
* the mapping's writeback index, just update
|
|
|
|
* nr_to_write.
|
|
|
|
*/
|
|
|
|
wbc->nr_to_write -= nr_written;
|
|
|
|
goto done_unlocked;
|
2008-11-07 04:02:51 +01:00
|
|
|
}
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
}
|
2008-07-17 18:53:51 +02:00
|
|
|
if (tree->ops && tree->ops->writepage_start_hook) {
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
ret = tree->ops->writepage_start_hook(page, start,
|
|
|
|
page_end);
|
2008-07-17 18:53:51 +02:00
|
|
|
if (ret == -EAGAIN) {
|
|
|
|
redirty_page_for_writepage(wbc, page);
|
2009-04-20 21:50:09 +02:00
|
|
|
update_nr_written(page, wbc, nr_written);
|
2008-07-17 18:53:51 +02:00
|
|
|
unlock_page(page);
|
2008-11-07 04:02:51 +01:00
|
|
|
ret = 0;
|
2009-04-20 21:50:09 +02:00
|
|
|
goto done_unlocked;
|
2008-07-17 18:53:51 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-20 21:50:09 +02:00
|
|
|
/*
|
|
|
|
* we don't want to touch the inode after unlocking the page,
|
|
|
|
* so we update the mapping writeback index now
|
|
|
|
*/
|
|
|
|
update_nr_written(page, wbc, nr_written + 1);
|
2008-11-07 04:02:51 +01:00
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
end = page_end;
|
|
|
|
if (last_byte <= start) {
|
2008-07-17 18:53:50 +02:00
|
|
|
if (tree->ops && tree->ops->writepage_end_io_hook)
|
|
|
|
tree->ops->writepage_end_io_hook(page, start,
|
|
|
|
page_end, NULL, 1);
|
|
|
|
unlock_start = page_end + 1;
|
2008-01-24 22:13:08 +01:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
blocksize = inode->i_sb->s_blocksize;
|
|
|
|
|
|
|
|
while (cur <= end) {
|
|
|
|
if (cur >= last_byte) {
|
2008-07-17 18:53:50 +02:00
|
|
|
if (tree->ops && tree->ops->writepage_end_io_hook)
|
|
|
|
tree->ops->writepage_end_io_hook(page, cur,
|
|
|
|
page_end, NULL, 1);
|
|
|
|
unlock_start = page_end + 1;
|
2008-01-24 22:13:08 +01:00
|
|
|
break;
|
|
|
|
}
|
2008-07-18 18:01:11 +02:00
|
|
|
em = epd->get_extent(inode, page, pg_offset, cur,
|
2008-01-24 22:13:08 +01:00
|
|
|
end - cur + 1, 1);
|
|
|
|
if (IS_ERR(em) || !em) {
|
|
|
|
SetPageError(page);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
extent_offset = cur - em->start;
|
|
|
|
BUG_ON(extent_map_end(em) <= cur);
|
|
|
|
BUG_ON(end < cur);
|
|
|
|
iosize = min(extent_map_end(em) - cur, end - cur + 1);
|
|
|
|
iosize = (iosize + blocksize - 1) & ~((u64)blocksize - 1);
|
|
|
|
sector = (em->block_start + extent_offset) >> 9;
|
|
|
|
bdev = em->bdev;
|
|
|
|
block_start = em->block_start;
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
compressed = test_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
|
2008-01-24 22:13:08 +01:00
|
|
|
free_extent_map(em);
|
|
|
|
em = NULL;
|
|
|
|
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
/*
|
|
|
|
* compressed and inline extents are written through other
|
|
|
|
* paths in the FS
|
|
|
|
*/
|
|
|
|
if (compressed || block_start == EXTENT_MAP_HOLE ||
|
2008-01-24 22:13:08 +01:00
|
|
|
block_start == EXTENT_MAP_INLINE) {
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
/*
|
|
|
|
* end_io notification does not happen here for
|
|
|
|
* compressed extents
|
|
|
|
*/
|
|
|
|
if (!compressed && tree->ops &&
|
|
|
|
tree->ops->writepage_end_io_hook)
|
2008-07-17 18:53:50 +02:00
|
|
|
tree->ops->writepage_end_io_hook(page, cur,
|
|
|
|
cur + iosize - 1,
|
|
|
|
NULL, 1);
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
else if (compressed) {
|
|
|
|
/* we don't want to end_page_writeback on
|
|
|
|
* a compressed extent. this happens
|
|
|
|
* elsewhere
|
|
|
|
*/
|
|
|
|
nr++;
|
|
|
|
}
|
|
|
|
|
|
|
|
cur += iosize;
|
2008-07-18 18:01:11 +02:00
|
|
|
pg_offset += iosize;
|
2008-07-17 18:53:50 +02:00
|
|
|
unlock_start = cur;
|
2008-01-24 22:13:08 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
/* leave this out until we have a page_mkwrite call */
|
|
|
|
if (0 && !test_range_bit(tree, cur, cur + iosize - 1,
|
|
|
|
EXTENT_DIRTY, 0)) {
|
|
|
|
cur = cur + iosize;
|
2008-07-18 18:01:11 +02:00
|
|
|
pg_offset += iosize;
|
2008-01-24 22:13:08 +01:00
|
|
|
continue;
|
|
|
|
}
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
if (tree->ops && tree->ops->writepage_io_hook) {
|
|
|
|
ret = tree->ops->writepage_io_hook(page, cur,
|
|
|
|
cur + iosize - 1);
|
|
|
|
} else {
|
|
|
|
ret = 0;
|
|
|
|
}
|
2008-05-12 19:39:03 +02:00
|
|
|
if (ret) {
|
2008-01-24 22:13:08 +01:00
|
|
|
SetPageError(page);
|
2008-05-12 19:39:03 +02:00
|
|
|
} else {
|
2008-01-24 22:13:08 +01:00
|
|
|
unsigned long max_nr = end_index + 1;
|
2008-07-18 18:01:11 +02:00
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
set_range_writeback(tree, cur, cur + iosize - 1);
|
|
|
|
if (!PageWriteback(page)) {
|
2009-01-06 03:25:51 +01:00
|
|
|
printk(KERN_ERR "btrfs warning page %lu not "
|
|
|
|
"writeback, cur %llu end %llu\n",
|
|
|
|
page->index, (unsigned long long)cur,
|
2008-01-24 22:13:08 +01:00
|
|
|
(unsigned long long)end);
|
|
|
|
}
|
|
|
|
|
2009-04-20 21:50:09 +02:00
|
|
|
ret = submit_extent_page(write_flags, tree, page,
|
|
|
|
sector, iosize, pg_offset,
|
|
|
|
bdev, &epd->bio, max_nr,
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
end_bio_extent_writepage,
|
|
|
|
0, 0, 0);
|
2008-01-24 22:13:08 +01:00
|
|
|
if (ret)
|
|
|
|
SetPageError(page);
|
|
|
|
}
|
|
|
|
cur = cur + iosize;
|
2008-07-18 18:01:11 +02:00
|
|
|
pg_offset += iosize;
|
2008-01-24 22:13:08 +01:00
|
|
|
nr++;
|
|
|
|
}
|
|
|
|
done:
|
|
|
|
if (nr == 0) {
|
|
|
|
/* make sure the mapping tag for page dirty gets cleared */
|
|
|
|
set_page_writeback(page);
|
|
|
|
end_page_writeback(page);
|
|
|
|
}
|
|
|
|
unlock_page(page);
|
2008-11-07 04:02:51 +01:00
|
|
|
|
2009-04-20 21:50:09 +02:00
|
|
|
done_unlocked:
|
|
|
|
|
2009-09-02 21:04:12 +02:00
|
|
|
/* drop our reference on any cached states */
|
|
|
|
free_extent_state(cached_state);
|
2008-01-24 22:13:08 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-09-08 17:18:08 +02:00
|
|
|
* write_cache_pages - walk the list of dirty pages of the given address space and write all of them.
|
2008-01-24 22:13:08 +01:00
|
|
|
* @mapping: address space structure to write
|
|
|
|
* @wbc: subtract the number of written pages from *@wbc->nr_to_write
|
|
|
|
* @writepage: function called for each page
|
|
|
|
* @data: data passed to writepage function
|
|
|
|
*
|
|
|
|
* If a page is already under I/O, write_cache_pages() skips it, even
|
|
|
|
* if it's dirty. This is desirable behaviour for memory-cleaning writeback,
|
|
|
|
* but it is INCORRECT for data-integrity system calls such as fsync(). fsync()
|
|
|
|
* and msync() need to guarantee that all the data which was dirty at the time
|
|
|
|
* the call was made get new I/O started against them. If wbc->sync_mode is
|
|
|
|
* WB_SYNC_ALL then we were called for data integrity and we must wait for
|
|
|
|
* existing IO to complete.
|
|
|
|
*/
|
2008-12-02 15:54:17 +01:00
|
|
|
static int extent_write_cache_pages(struct extent_io_tree *tree,
|
2008-09-08 17:18:08 +02:00
|
|
|
struct address_space *mapping,
|
|
|
|
struct writeback_control *wbc,
|
2008-11-19 18:44:22 +01:00
|
|
|
writepage_t writepage, void *data,
|
|
|
|
void (*flush_fn)(void *))
|
2008-01-24 22:13:08 +01:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
int done = 0;
|
|
|
|
struct pagevec pvec;
|
|
|
|
int nr_pages;
|
|
|
|
pgoff_t index;
|
|
|
|
pgoff_t end; /* Inclusive */
|
|
|
|
int scanned = 0;
|
|
|
|
int range_whole = 0;
|
|
|
|
|
|
|
|
pagevec_init(&pvec, 0);
|
|
|
|
if (wbc->range_cyclic) {
|
|
|
|
index = mapping->writeback_index; /* Start from prev offset */
|
|
|
|
end = -1;
|
|
|
|
} else {
|
|
|
|
index = wbc->range_start >> PAGE_CACHE_SHIFT;
|
|
|
|
end = wbc->range_end >> PAGE_CACHE_SHIFT;
|
|
|
|
if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
|
|
|
|
range_whole = 1;
|
|
|
|
scanned = 1;
|
|
|
|
}
|
|
|
|
retry:
|
|
|
|
while (!done && (index <= end) &&
|
|
|
|
(nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
|
2009-01-06 03:25:51 +01:00
|
|
|
PAGECACHE_TAG_DIRTY, min(end - index,
|
|
|
|
(pgoff_t)PAGEVEC_SIZE-1) + 1))) {
|
2008-01-24 22:13:08 +01:00
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
scanned = 1;
|
|
|
|
for (i = 0; i < nr_pages; i++) {
|
|
|
|
struct page *page = pvec.pages[i];
|
|
|
|
|
|
|
|
/*
|
|
|
|
* At this point we hold neither mapping->tree_lock nor
|
|
|
|
* lock on the page itself: the page may be truncated or
|
|
|
|
* invalidated (changing page->mapping to NULL), or even
|
|
|
|
* swizzled back from swapper_space to tmpfs file
|
|
|
|
* mapping
|
|
|
|
*/
|
2008-09-08 17:18:08 +02:00
|
|
|
if (tree->ops && tree->ops->write_cache_pages_lock_hook)
|
|
|
|
tree->ops->write_cache_pages_lock_hook(page);
|
|
|
|
else
|
|
|
|
lock_page(page);
|
2008-01-24 22:13:08 +01:00
|
|
|
|
|
|
|
if (unlikely(page->mapping != mapping)) {
|
|
|
|
unlock_page(page);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!wbc->range_cyclic && page->index > end) {
|
|
|
|
done = 1;
|
|
|
|
unlock_page(page);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2008-11-19 18:44:22 +01:00
|
|
|
if (wbc->sync_mode != WB_SYNC_NONE) {
|
2008-11-20 16:46:35 +01:00
|
|
|
if (PageWriteback(page))
|
|
|
|
flush_fn(data);
|
2008-01-24 22:13:08 +01:00
|
|
|
wait_on_page_writeback(page);
|
2008-11-19 18:44:22 +01:00
|
|
|
}
|
2008-01-24 22:13:08 +01:00
|
|
|
|
|
|
|
if (PageWriteback(page) ||
|
|
|
|
!clear_page_dirty_for_io(page)) {
|
|
|
|
unlock_page(page);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = (*writepage)(page, wbc, data);
|
|
|
|
|
|
|
|
if (unlikely(ret == AOP_WRITEPAGE_ACTIVATE)) {
|
|
|
|
unlock_page(page);
|
|
|
|
ret = 0;
|
|
|
|
}
|
2008-11-07 04:02:51 +01:00
|
|
|
if (ret || wbc->nr_to_write <= 0)
|
2008-01-24 22:13:08 +01:00
|
|
|
done = 1;
|
|
|
|
}
|
|
|
|
pagevec_release(&pvec);
|
|
|
|
cond_resched();
|
|
|
|
}
|
|
|
|
if (!scanned && !done) {
|
|
|
|
/*
|
|
|
|
* We hit the last page and there is more work to be done: wrap
|
|
|
|
* back to the start of the file
|
|
|
|
*/
|
|
|
|
scanned = 1;
|
|
|
|
index = 0;
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-04-20 21:50:09 +02:00
|
|
|
static void flush_epd_write_bio(struct extent_page_data *epd)
|
2008-11-19 18:44:22 +01:00
|
|
|
{
|
|
|
|
if (epd->bio) {
|
2009-04-20 21:50:09 +02:00
|
|
|
if (epd->sync_io)
|
|
|
|
submit_one_bio(WRITE_SYNC, epd->bio, 0, 0);
|
|
|
|
else
|
|
|
|
submit_one_bio(WRITE, epd->bio, 0, 0);
|
2008-11-19 18:44:22 +01:00
|
|
|
epd->bio = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-20 21:50:09 +02:00
|
|
|
static noinline void flush_write_bio(void *data)
|
|
|
|
{
|
|
|
|
struct extent_page_data *epd = data;
|
|
|
|
flush_epd_write_bio(epd);
|
|
|
|
}
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
int extent_write_full_page(struct extent_io_tree *tree, struct page *page,
|
|
|
|
get_extent_t *get_extent,
|
|
|
|
struct writeback_control *wbc)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct address_space *mapping = page->mapping;
|
|
|
|
struct extent_page_data epd = {
|
|
|
|
.bio = NULL,
|
|
|
|
.tree = tree,
|
|
|
|
.get_extent = get_extent,
|
2008-11-07 04:02:51 +01:00
|
|
|
.extent_locked = 0,
|
2009-04-20 21:50:09 +02:00
|
|
|
.sync_io = wbc->sync_mode == WB_SYNC_ALL,
|
2008-01-24 22:13:08 +01:00
|
|
|
};
|
|
|
|
struct writeback_control wbc_writepages = {
|
|
|
|
.bdi = wbc->bdi,
|
2009-04-20 21:50:09 +02:00
|
|
|
.sync_mode = wbc->sync_mode,
|
2008-01-24 22:13:08 +01:00
|
|
|
.older_than_this = NULL,
|
|
|
|
.nr_to_write = 64,
|
|
|
|
.range_start = page_offset(page) + PAGE_CACHE_SIZE,
|
|
|
|
.range_end = (loff_t)-1,
|
|
|
|
};
|
|
|
|
|
|
|
|
ret = __extent_writepage(page, wbc, &epd);
|
|
|
|
|
2008-09-08 17:18:08 +02:00
|
|
|
extent_write_cache_pages(tree, mapping, &wbc_writepages,
|
2008-11-19 18:44:22 +01:00
|
|
|
__extent_writepage, &epd, flush_write_bio);
|
2009-04-20 21:50:09 +02:00
|
|
|
flush_epd_write_bio(&epd);
|
2008-01-24 22:13:08 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-11-07 04:02:51 +01:00
|
|
|
int extent_write_locked_range(struct extent_io_tree *tree, struct inode *inode,
|
|
|
|
u64 start, u64 end, get_extent_t *get_extent,
|
|
|
|
int mode)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct address_space *mapping = inode->i_mapping;
|
|
|
|
struct page *page;
|
|
|
|
unsigned long nr_pages = (end - start + PAGE_CACHE_SIZE) >>
|
|
|
|
PAGE_CACHE_SHIFT;
|
|
|
|
|
|
|
|
struct extent_page_data epd = {
|
|
|
|
.bio = NULL,
|
|
|
|
.tree = tree,
|
|
|
|
.get_extent = get_extent,
|
|
|
|
.extent_locked = 1,
|
2009-04-20 21:50:09 +02:00
|
|
|
.sync_io = mode == WB_SYNC_ALL,
|
2008-11-07 04:02:51 +01:00
|
|
|
};
|
|
|
|
struct writeback_control wbc_writepages = {
|
|
|
|
.bdi = inode->i_mapping->backing_dev_info,
|
|
|
|
.sync_mode = mode,
|
|
|
|
.older_than_this = NULL,
|
|
|
|
.nr_to_write = nr_pages * 2,
|
|
|
|
.range_start = start,
|
|
|
|
.range_end = end + 1,
|
|
|
|
};
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (start <= end) {
|
2008-11-07 04:02:51 +01:00
|
|
|
page = find_get_page(mapping, start >> PAGE_CACHE_SHIFT);
|
|
|
|
if (clear_page_dirty_for_io(page))
|
|
|
|
ret = __extent_writepage(page, &wbc_writepages, &epd);
|
|
|
|
else {
|
|
|
|
if (tree->ops && tree->ops->writepage_end_io_hook)
|
|
|
|
tree->ops->writepage_end_io_hook(page, start,
|
|
|
|
start + PAGE_CACHE_SIZE - 1,
|
|
|
|
NULL, 1);
|
|
|
|
unlock_page(page);
|
|
|
|
}
|
|
|
|
page_cache_release(page);
|
|
|
|
start += PAGE_CACHE_SIZE;
|
|
|
|
}
|
|
|
|
|
2009-04-20 21:50:09 +02:00
|
|
|
flush_epd_write_bio(&epd);
|
2008-11-07 04:02:51 +01:00
|
|
|
return ret;
|
|
|
|
}
|
2008-01-24 22:13:08 +01:00
|
|
|
|
|
|
|
int extent_writepages(struct extent_io_tree *tree,
|
|
|
|
struct address_space *mapping,
|
|
|
|
get_extent_t *get_extent,
|
|
|
|
struct writeback_control *wbc)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct extent_page_data epd = {
|
|
|
|
.bio = NULL,
|
|
|
|
.tree = tree,
|
|
|
|
.get_extent = get_extent,
|
2008-11-07 04:02:51 +01:00
|
|
|
.extent_locked = 0,
|
2009-04-20 21:50:09 +02:00
|
|
|
.sync_io = wbc->sync_mode == WB_SYNC_ALL,
|
2008-01-24 22:13:08 +01:00
|
|
|
};
|
|
|
|
|
2008-09-08 17:18:08 +02:00
|
|
|
ret = extent_write_cache_pages(tree, mapping, wbc,
|
2008-11-19 18:44:22 +01:00
|
|
|
__extent_writepage, &epd,
|
|
|
|
flush_write_bio);
|
2009-04-20 21:50:09 +02:00
|
|
|
flush_epd_write_bio(&epd);
|
2008-01-24 22:13:08 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int extent_readpages(struct extent_io_tree *tree,
|
|
|
|
struct address_space *mapping,
|
|
|
|
struct list_head *pages, unsigned nr_pages,
|
|
|
|
get_extent_t get_extent)
|
|
|
|
{
|
|
|
|
struct bio *bio = NULL;
|
|
|
|
unsigned page_idx;
|
|
|
|
struct pagevec pvec;
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
unsigned long bio_flags = 0;
|
2008-01-24 22:13:08 +01:00
|
|
|
|
|
|
|
pagevec_init(&pvec, 0);
|
|
|
|
for (page_idx = 0; page_idx < nr_pages; page_idx++) {
|
|
|
|
struct page *page = list_entry(pages->prev, struct page, lru);
|
|
|
|
|
|
|
|
prefetchw(&page->flags);
|
|
|
|
list_del(&page->lru);
|
|
|
|
/*
|
|
|
|
* what we want to do here is call add_to_page_cache_lru,
|
|
|
|
* but that isn't exported, so we reproduce it here
|
|
|
|
*/
|
|
|
|
if (!add_to_page_cache(page, mapping,
|
|
|
|
page->index, GFP_KERNEL)) {
|
|
|
|
|
|
|
|
/* open coding of lru_cache_add, also not exported */
|
|
|
|
page_cache_get(page);
|
|
|
|
if (!pagevec_add(&pvec, page))
|
2008-11-20 03:17:22 +01:00
|
|
|
__pagevec_lru_add_file(&pvec);
|
2008-04-09 22:28:12 +02:00
|
|
|
__extent_read_full_page(tree, page, get_extent,
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
&bio, 0, &bio_flags);
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
page_cache_release(page);
|
|
|
|
}
|
|
|
|
if (pagevec_count(&pvec))
|
2008-11-20 03:17:22 +01:00
|
|
|
__pagevec_lru_add_file(&pvec);
|
2008-01-24 22:13:08 +01:00
|
|
|
BUG_ON(!list_empty(pages));
|
|
|
|
if (bio)
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
submit_one_bio(READ, bio, 0, bio_flags);
|
2008-01-24 22:13:08 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* basic invalidatepage code, this waits on any locked or writeback
|
|
|
|
* ranges corresponding to the page, and then deletes any extent state
|
|
|
|
* records from the tree
|
|
|
|
*/
|
|
|
|
int extent_invalidatepage(struct extent_io_tree *tree,
|
|
|
|
struct page *page, unsigned long offset)
|
|
|
|
{
|
|
|
|
u64 start = ((u64)page->index << PAGE_CACHE_SHIFT);
|
|
|
|
u64 end = start + PAGE_CACHE_SIZE - 1;
|
|
|
|
size_t blocksize = page->mapping->host->i_sb->s_blocksize;
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
start += (offset + blocksize - 1) & ~(blocksize - 1);
|
2008-01-24 22:13:08 +01:00
|
|
|
if (start > end)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
lock_extent(tree, start, end, GFP_NOFS);
|
2009-09-02 19:24:36 +02:00
|
|
|
wait_on_page_writeback(page);
|
2008-01-24 22:13:08 +01:00
|
|
|
clear_extent_bit(tree, start, end,
|
|
|
|
EXTENT_LOCKED | EXTENT_DIRTY | EXTENT_DELALLOC,
|
2009-09-02 21:04:12 +02:00
|
|
|
1, 1, NULL, GFP_NOFS);
|
2008-01-24 22:13:08 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* simple commit_write call, set_range_dirty is used to mark both
|
|
|
|
* the pages and the extent records as dirty
|
|
|
|
*/
|
|
|
|
int extent_commit_write(struct extent_io_tree *tree,
|
|
|
|
struct inode *inode, struct page *page,
|
|
|
|
unsigned from, unsigned to)
|
|
|
|
{
|
|
|
|
loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
|
|
|
|
|
|
|
|
set_page_extent_mapped(page);
|
|
|
|
set_page_dirty(page);
|
|
|
|
|
|
|
|
if (pos > inode->i_size) {
|
|
|
|
i_size_write(inode, pos);
|
|
|
|
mark_inode_dirty(inode);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int extent_prepare_write(struct extent_io_tree *tree,
|
|
|
|
struct inode *inode, struct page *page,
|
|
|
|
unsigned from, unsigned to, get_extent_t *get_extent)
|
|
|
|
{
|
|
|
|
u64 page_start = (u64)page->index << PAGE_CACHE_SHIFT;
|
|
|
|
u64 page_end = page_start + PAGE_CACHE_SIZE - 1;
|
|
|
|
u64 block_start;
|
|
|
|
u64 orig_block_start;
|
|
|
|
u64 block_end;
|
|
|
|
u64 cur_end;
|
|
|
|
struct extent_map *em;
|
|
|
|
unsigned blocksize = 1 << inode->i_blkbits;
|
|
|
|
size_t page_offset = 0;
|
|
|
|
size_t block_off_start;
|
|
|
|
size_t block_off_end;
|
|
|
|
int err = 0;
|
|
|
|
int iocount = 0;
|
|
|
|
int ret = 0;
|
|
|
|
int isnew;
|
|
|
|
|
|
|
|
set_page_extent_mapped(page);
|
|
|
|
|
|
|
|
block_start = (page_start + from) & ~((u64)blocksize - 1);
|
|
|
|
block_end = (page_start + to - 1) | (blocksize - 1);
|
|
|
|
orig_block_start = block_start;
|
|
|
|
|
|
|
|
lock_extent(tree, page_start, page_end, GFP_NOFS);
|
2009-01-06 03:25:51 +01:00
|
|
|
while (block_start <= block_end) {
|
2008-01-24 22:13:08 +01:00
|
|
|
em = get_extent(inode, page, page_offset, block_start,
|
|
|
|
block_end - block_start + 1, 1);
|
2009-01-06 03:25:51 +01:00
|
|
|
if (IS_ERR(em) || !em)
|
2008-01-24 22:13:08 +01:00
|
|
|
goto err;
|
2009-01-06 03:25:51 +01:00
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
cur_end = min(block_end, extent_map_end(em) - 1);
|
|
|
|
block_off_start = block_start & (PAGE_CACHE_SIZE - 1);
|
|
|
|
block_off_end = block_off_start + blocksize;
|
|
|
|
isnew = clear_extent_new(tree, block_start, cur_end, GFP_NOFS);
|
|
|
|
|
|
|
|
if (!PageUptodate(page) && isnew &&
|
|
|
|
(block_off_end > to || block_off_start < from)) {
|
|
|
|
void *kaddr;
|
|
|
|
|
|
|
|
kaddr = kmap_atomic(page, KM_USER0);
|
|
|
|
if (block_off_end > to)
|
|
|
|
memset(kaddr + to, 0, block_off_end - to);
|
|
|
|
if (block_off_start < from)
|
|
|
|
memset(kaddr + block_off_start, 0,
|
|
|
|
from - block_off_start);
|
|
|
|
flush_dcache_page(page);
|
|
|
|
kunmap_atomic(kaddr, KM_USER0);
|
|
|
|
}
|
|
|
|
if ((em->block_start != EXTENT_MAP_HOLE &&
|
|
|
|
em->block_start != EXTENT_MAP_INLINE) &&
|
|
|
|
!isnew && !PageUptodate(page) &&
|
|
|
|
(block_off_end > to || block_off_start < from) &&
|
|
|
|
!test_range_bit(tree, block_start, cur_end,
|
|
|
|
EXTENT_UPTODATE, 1)) {
|
|
|
|
u64 sector;
|
|
|
|
u64 extent_offset = block_start - em->start;
|
|
|
|
size_t iosize;
|
|
|
|
sector = (em->block_start + extent_offset) >> 9;
|
|
|
|
iosize = (cur_end - block_start + blocksize) &
|
|
|
|
~((u64)blocksize - 1);
|
|
|
|
/*
|
|
|
|
* we've already got the extent locked, but we
|
|
|
|
* need to split the state such that our end_bio
|
|
|
|
* handler can clear the lock.
|
|
|
|
*/
|
|
|
|
set_extent_bit(tree, block_start,
|
|
|
|
block_start + iosize - 1,
|
2009-09-02 21:04:12 +02:00
|
|
|
EXTENT_LOCKED, 0, NULL, NULL, GFP_NOFS);
|
2008-01-24 22:13:08 +01:00
|
|
|
ret = submit_extent_page(READ, tree, page,
|
|
|
|
sector, iosize, page_offset, em->bdev,
|
|
|
|
NULL, 1,
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
end_bio_extent_preparewrite, 0,
|
|
|
|
0, 0);
|
2008-01-24 22:13:08 +01:00
|
|
|
iocount++;
|
|
|
|
block_start = block_start + iosize;
|
|
|
|
} else {
|
|
|
|
set_extent_uptodate(tree, block_start, cur_end,
|
|
|
|
GFP_NOFS);
|
|
|
|
unlock_extent(tree, block_start, cur_end, GFP_NOFS);
|
|
|
|
block_start = cur_end + 1;
|
|
|
|
}
|
|
|
|
page_offset = block_start & (PAGE_CACHE_SIZE - 1);
|
|
|
|
free_extent_map(em);
|
|
|
|
}
|
|
|
|
if (iocount) {
|
|
|
|
wait_extent_bit(tree, orig_block_start,
|
|
|
|
block_end, EXTENT_LOCKED);
|
|
|
|
}
|
|
|
|
check_page_uptodate(tree, page);
|
|
|
|
err:
|
|
|
|
/* FIXME, zero out newly allocated blocks on error */
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2008-04-18 16:29:50 +02:00
|
|
|
/*
|
|
|
|
* a helper for releasepage, this tests for areas of the page that
|
|
|
|
* are locked or under IO and drops the related state bits if it is safe
|
|
|
|
* to drop the page.
|
|
|
|
*/
|
|
|
|
int try_release_extent_state(struct extent_map_tree *map,
|
|
|
|
struct extent_io_tree *tree, struct page *page,
|
|
|
|
gfp_t mask)
|
|
|
|
{
|
|
|
|
u64 start = (u64)page->index << PAGE_CACHE_SHIFT;
|
|
|
|
u64 end = start + PAGE_CACHE_SIZE - 1;
|
|
|
|
int ret = 1;
|
|
|
|
|
2008-07-18 17:56:15 +02:00
|
|
|
if (test_range_bit(tree, start, end,
|
|
|
|
EXTENT_IOBITS | EXTENT_ORDERED, 0))
|
2008-04-18 16:29:50 +02:00
|
|
|
ret = 0;
|
|
|
|
else {
|
|
|
|
if ((mask & GFP_NOFS) == GFP_NOFS)
|
|
|
|
mask = GFP_NOFS;
|
|
|
|
clear_extent_bit(tree, start, end, EXTENT_UPTODATE,
|
2009-09-02 21:04:12 +02:00
|
|
|
1, 1, NULL, mask);
|
2008-04-18 16:29:50 +02:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
/*
|
|
|
|
* a helper for releasepage. As long as there are no locked extents
|
|
|
|
* in the range corresponding to the page, both state records and extent
|
|
|
|
* map records are removed
|
|
|
|
*/
|
|
|
|
int try_release_extent_mapping(struct extent_map_tree *map,
|
2008-01-29 15:59:12 +01:00
|
|
|
struct extent_io_tree *tree, struct page *page,
|
|
|
|
gfp_t mask)
|
2008-01-24 22:13:08 +01:00
|
|
|
{
|
|
|
|
struct extent_map *em;
|
|
|
|
u64 start = (u64)page->index << PAGE_CACHE_SHIFT;
|
|
|
|
u64 end = start + PAGE_CACHE_SIZE - 1;
|
2008-04-18 16:29:50 +02:00
|
|
|
|
2008-01-29 15:59:12 +01:00
|
|
|
if ((mask & __GFP_WAIT) &&
|
|
|
|
page->mapping->host->i_size > 16 * 1024 * 1024) {
|
2008-02-15 16:40:50 +01:00
|
|
|
u64 len;
|
2008-01-29 15:59:12 +01:00
|
|
|
while (start <= end) {
|
2008-02-15 16:40:50 +01:00
|
|
|
len = end - start + 1;
|
2009-09-02 22:24:52 +02:00
|
|
|
write_lock(&map->lock);
|
2008-02-15 16:40:50 +01:00
|
|
|
em = lookup_extent_mapping(map, start, len);
|
2008-01-29 15:59:12 +01:00
|
|
|
if (!em || IS_ERR(em)) {
|
2009-09-02 22:24:52 +02:00
|
|
|
write_unlock(&map->lock);
|
2008-01-29 15:59:12 +01:00
|
|
|
break;
|
|
|
|
}
|
2008-07-18 18:01:11 +02:00
|
|
|
if (test_bit(EXTENT_FLAG_PINNED, &em->flags) ||
|
|
|
|
em->start != start) {
|
2009-09-02 22:24:52 +02:00
|
|
|
write_unlock(&map->lock);
|
2008-01-29 15:59:12 +01:00
|
|
|
free_extent_map(em);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!test_range_bit(tree, em->start,
|
|
|
|
extent_map_end(em) - 1,
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
EXTENT_LOCKED | EXTENT_WRITEBACK |
|
|
|
|
EXTENT_ORDERED,
|
|
|
|
0)) {
|
2008-01-29 15:59:12 +01:00
|
|
|
remove_extent_mapping(map, em);
|
|
|
|
/* once for the rb tree */
|
|
|
|
free_extent_map(em);
|
|
|
|
}
|
|
|
|
start = extent_map_end(em);
|
2009-09-02 22:24:52 +02:00
|
|
|
write_unlock(&map->lock);
|
2008-01-29 15:59:12 +01:00
|
|
|
|
|
|
|
/* once for us */
|
2008-01-24 22:13:08 +01:00
|
|
|
free_extent_map(em);
|
|
|
|
}
|
|
|
|
}
|
2008-04-18 16:29:50 +02:00
|
|
|
return try_release_extent_state(map, tree, page, mask);
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
sector_t extent_bmap(struct address_space *mapping, sector_t iblock,
|
|
|
|
get_extent_t *get_extent)
|
|
|
|
{
|
|
|
|
struct inode *inode = mapping->host;
|
|
|
|
u64 start = iblock << inode->i_blkbits;
|
|
|
|
sector_t sector = 0;
|
2008-10-30 19:25:28 +01:00
|
|
|
size_t blksize = (1 << inode->i_blkbits);
|
2008-01-24 22:13:08 +01:00
|
|
|
struct extent_map *em;
|
|
|
|
|
2008-10-30 19:25:28 +01:00
|
|
|
lock_extent(&BTRFS_I(inode)->io_tree, start, start + blksize - 1,
|
|
|
|
GFP_NOFS);
|
|
|
|
em = get_extent(inode, NULL, 0, start, blksize, 0);
|
|
|
|
unlock_extent(&BTRFS_I(inode)->io_tree, start, start + blksize - 1,
|
|
|
|
GFP_NOFS);
|
2008-01-24 22:13:08 +01:00
|
|
|
if (!em || IS_ERR(em))
|
|
|
|
return 0;
|
|
|
|
|
2008-10-30 19:25:28 +01:00
|
|
|
if (em->block_start > EXTENT_MAP_LAST_BYTE)
|
2008-01-24 22:13:08 +01:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
sector = (em->block_start + start - em->start) >> inode->i_blkbits;
|
|
|
|
out:
|
|
|
|
free_extent_map(em);
|
|
|
|
return sector;
|
|
|
|
}
|
|
|
|
|
2009-01-21 20:39:14 +01:00
|
|
|
int extent_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
|
|
|
|
__u64 start, __u64 len, get_extent_t *get_extent)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u64 off = start;
|
|
|
|
u64 max = start + len;
|
|
|
|
u32 flags = 0;
|
|
|
|
u64 disko = 0;
|
|
|
|
struct extent_map *em = NULL;
|
|
|
|
int end = 0;
|
|
|
|
u64 em_start = 0, em_len = 0;
|
|
|
|
unsigned long emflags;
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
if (len == 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
lock_extent(&BTRFS_I(inode)->io_tree, start, start + len,
|
|
|
|
GFP_NOFS);
|
|
|
|
em = get_extent(inode, NULL, 0, off, max - off, 0);
|
|
|
|
if (!em)
|
|
|
|
goto out;
|
|
|
|
if (IS_ERR(em)) {
|
|
|
|
ret = PTR_ERR(em);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
while (!end) {
|
|
|
|
off = em->start + em->len;
|
|
|
|
if (off >= max)
|
|
|
|
end = 1;
|
|
|
|
|
|
|
|
em_start = em->start;
|
|
|
|
em_len = em->len;
|
|
|
|
|
|
|
|
disko = 0;
|
|
|
|
flags = 0;
|
|
|
|
|
2009-04-03 16:33:45 +02:00
|
|
|
if (em->block_start == EXTENT_MAP_LAST_BYTE) {
|
2009-01-21 20:39:14 +01:00
|
|
|
end = 1;
|
|
|
|
flags |= FIEMAP_EXTENT_LAST;
|
2009-04-03 16:33:45 +02:00
|
|
|
} else if (em->block_start == EXTENT_MAP_HOLE) {
|
2009-01-21 20:39:14 +01:00
|
|
|
flags |= FIEMAP_EXTENT_UNWRITTEN;
|
2009-04-03 16:33:45 +02:00
|
|
|
} else if (em->block_start == EXTENT_MAP_INLINE) {
|
2009-01-21 20:39:14 +01:00
|
|
|
flags |= (FIEMAP_EXTENT_DATA_INLINE |
|
|
|
|
FIEMAP_EXTENT_NOT_ALIGNED);
|
2009-04-03 16:33:45 +02:00
|
|
|
} else if (em->block_start == EXTENT_MAP_DELALLOC) {
|
2009-01-21 20:39:14 +01:00
|
|
|
flags |= (FIEMAP_EXTENT_DELALLOC |
|
|
|
|
FIEMAP_EXTENT_UNKNOWN);
|
2009-04-03 16:33:45 +02:00
|
|
|
} else {
|
2009-01-21 20:39:14 +01:00
|
|
|
disko = em->block_start;
|
|
|
|
}
|
|
|
|
if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags))
|
|
|
|
flags |= FIEMAP_EXTENT_ENCODED;
|
|
|
|
|
|
|
|
emflags = em->flags;
|
|
|
|
free_extent_map(em);
|
|
|
|
em = NULL;
|
|
|
|
|
|
|
|
if (!end) {
|
|
|
|
em = get_extent(inode, NULL, 0, off, max - off, 0);
|
|
|
|
if (!em)
|
|
|
|
goto out;
|
|
|
|
if (IS_ERR(em)) {
|
|
|
|
ret = PTR_ERR(em);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
emflags = em->flags;
|
|
|
|
}
|
|
|
|
if (test_bit(EXTENT_FLAG_VACANCY, &emflags)) {
|
|
|
|
flags |= FIEMAP_EXTENT_LAST;
|
|
|
|
end = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = fiemap_fill_next_extent(fieinfo, em_start, disko,
|
|
|
|
em_len, flags);
|
|
|
|
if (ret)
|
|
|
|
goto out_free;
|
|
|
|
}
|
|
|
|
out_free:
|
|
|
|
free_extent_map(em);
|
|
|
|
out:
|
|
|
|
unlock_extent(&BTRFS_I(inode)->io_tree, start, start + len,
|
|
|
|
GFP_NOFS);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
static inline struct page *extent_buffer_page(struct extent_buffer *eb,
|
|
|
|
unsigned long i)
|
|
|
|
{
|
|
|
|
struct page *p;
|
|
|
|
struct address_space *mapping;
|
|
|
|
|
|
|
|
if (i == 0)
|
|
|
|
return eb->first_page;
|
|
|
|
i += eb->start >> PAGE_CACHE_SHIFT;
|
|
|
|
mapping = eb->first_page->mapping;
|
2008-07-30 16:29:12 +02:00
|
|
|
if (!mapping)
|
|
|
|
return NULL;
|
2008-07-30 22:54:26 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* extent_buffer_page is only called after pinning the page
|
|
|
|
* by increasing the reference count. So we know the page must
|
|
|
|
* be in the radix tree.
|
|
|
|
*/
|
|
|
|
rcu_read_lock();
|
2008-01-24 22:13:08 +01:00
|
|
|
p = radix_tree_lookup(&mapping->page_tree, i);
|
2008-07-30 22:54:26 +02:00
|
|
|
rcu_read_unlock();
|
2008-09-24 17:48:04 +02:00
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2008-07-22 17:18:07 +02:00
|
|
|
static inline unsigned long num_extent_pages(u64 start, u64 len)
|
2008-04-09 22:28:12 +02:00
|
|
|
{
|
2008-07-22 17:18:07 +02:00
|
|
|
return ((start + len + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT) -
|
|
|
|
(start >> PAGE_CACHE_SHIFT);
|
2008-04-09 22:28:12 +02:00
|
|
|
}
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
static struct extent_buffer *__alloc_extent_buffer(struct extent_io_tree *tree,
|
|
|
|
u64 start,
|
|
|
|
unsigned long len,
|
|
|
|
gfp_t mask)
|
|
|
|
{
|
|
|
|
struct extent_buffer *eb = NULL;
|
2009-02-04 15:24:05 +01:00
|
|
|
#if LEAK_DEBUG
|
2008-03-26 21:24:23 +01:00
|
|
|
unsigned long flags;
|
2008-09-08 17:18:08 +02:00
|
|
|
#endif
|
2008-01-24 22:13:08 +01:00
|
|
|
|
|
|
|
eb = kmem_cache_zalloc(extent_buffer_cache, mask);
|
|
|
|
eb->start = start;
|
|
|
|
eb->len = len;
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 15:25:08 +01:00
|
|
|
spin_lock_init(&eb->lock);
|
|
|
|
init_waitqueue_head(&eb->lock_wq);
|
|
|
|
|
2009-02-04 15:24:05 +01:00
|
|
|
#if LEAK_DEBUG
|
2008-03-26 21:24:23 +01:00
|
|
|
spin_lock_irqsave(&leak_lock, flags);
|
|
|
|
list_add(&eb->leak_list, &buffers);
|
|
|
|
spin_unlock_irqrestore(&leak_lock, flags);
|
2008-09-08 17:18:08 +02:00
|
|
|
#endif
|
2008-01-24 22:13:08 +01:00
|
|
|
atomic_set(&eb->refs, 1);
|
|
|
|
|
|
|
|
return eb;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __free_extent_buffer(struct extent_buffer *eb)
|
|
|
|
{
|
2009-02-04 15:24:05 +01:00
|
|
|
#if LEAK_DEBUG
|
2008-03-26 21:24:23 +01:00
|
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&leak_lock, flags);
|
|
|
|
list_del(&eb->leak_list);
|
|
|
|
spin_unlock_irqrestore(&leak_lock, flags);
|
2008-09-08 17:18:08 +02:00
|
|
|
#endif
|
2008-01-24 22:13:08 +01:00
|
|
|
kmem_cache_free(extent_buffer_cache, eb);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct extent_buffer *alloc_extent_buffer(struct extent_io_tree *tree,
|
|
|
|
u64 start, unsigned long len,
|
|
|
|
struct page *page0,
|
|
|
|
gfp_t mask)
|
|
|
|
{
|
|
|
|
unsigned long num_pages = num_extent_pages(start, len);
|
|
|
|
unsigned long i;
|
|
|
|
unsigned long index = start >> PAGE_CACHE_SHIFT;
|
|
|
|
struct extent_buffer *eb;
|
2008-07-22 17:18:07 +02:00
|
|
|
struct extent_buffer *exists = NULL;
|
2008-01-24 22:13:08 +01:00
|
|
|
struct page *p;
|
|
|
|
struct address_space *mapping = tree->mapping;
|
|
|
|
int uptodate = 1;
|
|
|
|
|
2008-07-22 17:18:07 +02:00
|
|
|
spin_lock(&tree->buffer_lock);
|
|
|
|
eb = buffer_search(tree, start);
|
|
|
|
if (eb) {
|
|
|
|
atomic_inc(&eb->refs);
|
|
|
|
spin_unlock(&tree->buffer_lock);
|
Btrfs: free space accounting redo
1) replace the per fs_info extent_io_tree that tracked free space with two
rb-trees per block group to track free space areas via offset and size. The
reason to do this is because most allocations come with a hint byte where to
start, so we can usually find a chunk of free space at that hint byte to satisfy
the allocation and get good space packing. If we cannot find free space at or
after the given offset we fall back on looking for a chunk of the given size as
close to that given offset as possible. When we fall back on the size search we
also try to find a slot as close to the size we want as possible, to avoid
breaking small chunks off of huge areas if possible.
2) remove the extent_io_tree that tracked the block group cache from fs_info and
replaced it with an rb-tree thats tracks block group cache via offset. also
added a per space_info list that tracks the block group cache for the particular
space so we can lookup related block groups easily.
3) cleaned up the allocation code to make it a little easier to read and a
little less complicated. Basically there are 3 steps, first look from our
provided hint. If we couldn't find from that given hint, start back at our
original search start and look for space from there. If that fails try to
allocate space if we can and start looking again. If not we're screwed and need
to start over again.
4) small fixes. there were some issues in volumes.c where we wouldn't allocate
the rest of the disk. fixed cow_file_range to actually pass the alloc_hint,
which has helped a good bit in making the fs_mark test I run have semi-normal
results as we run out of space. Generally with data allocations we don't track
where we last allocated from, so everytime we did a data allocation we'd search
through every block group that we have looking for free space. Now searching a
block group with no free space isn't terribly time consuming, it was causing a
slight degradation as we got more data block groups. The alloc_hint has fixed
this slight degredation and made things semi-normal.
There is still one nagging problem I'm working on where we will get ENOSPC when
there is definitely plenty of space. This only happens with metadata
allocations, and only when we are almost full. So you generally hit the 85%
mark first, but sometimes you'll hit the BUG before you hit the 85% wall. I'm
still tracking it down, but until then this seems to be pretty stable and make a
significant performance gain.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-09-23 19:14:11 +02:00
|
|
|
mark_page_accessed(eb->first_page);
|
2008-07-22 17:18:07 +02:00
|
|
|
return eb;
|
|
|
|
}
|
|
|
|
spin_unlock(&tree->buffer_lock);
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
eb = __alloc_extent_buffer(tree, start, len, mask);
|
2008-04-01 17:21:40 +02:00
|
|
|
if (!eb)
|
2008-01-24 22:13:08 +01:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (page0) {
|
|
|
|
eb->first_page = page0;
|
|
|
|
i = 1;
|
|
|
|
index++;
|
|
|
|
page_cache_get(page0);
|
|
|
|
mark_page_accessed(page0);
|
|
|
|
set_page_extent_mapped(page0);
|
|
|
|
set_page_extent_head(page0, len);
|
2008-04-09 22:28:12 +02:00
|
|
|
uptodate = PageUptodate(page0);
|
2008-01-24 22:13:08 +01:00
|
|
|
} else {
|
|
|
|
i = 0;
|
|
|
|
}
|
|
|
|
for (; i < num_pages; i++, index++) {
|
|
|
|
p = find_or_create_page(mapping, index, mask | __GFP_HIGHMEM);
|
|
|
|
if (!p) {
|
|
|
|
WARN_ON(1);
|
2008-07-22 17:18:07 +02:00
|
|
|
goto free_eb;
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
set_page_extent_mapped(p);
|
|
|
|
mark_page_accessed(p);
|
|
|
|
if (i == 0) {
|
|
|
|
eb->first_page = p;
|
|
|
|
set_page_extent_head(p, len);
|
|
|
|
} else {
|
|
|
|
set_page_private(p, EXTENT_PAGE_PRIVATE);
|
|
|
|
}
|
|
|
|
if (!PageUptodate(p))
|
|
|
|
uptodate = 0;
|
|
|
|
unlock_page(p);
|
|
|
|
}
|
|
|
|
if (uptodate)
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 15:25:08 +01:00
|
|
|
set_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags);
|
2008-01-24 22:13:08 +01:00
|
|
|
|
2008-07-22 17:18:07 +02:00
|
|
|
spin_lock(&tree->buffer_lock);
|
|
|
|
exists = buffer_tree_insert(tree, start, &eb->rb_node);
|
|
|
|
if (exists) {
|
|
|
|
/* add one reference for the caller */
|
|
|
|
atomic_inc(&exists->refs);
|
|
|
|
spin_unlock(&tree->buffer_lock);
|
|
|
|
goto free_eb;
|
|
|
|
}
|
|
|
|
spin_unlock(&tree->buffer_lock);
|
|
|
|
|
|
|
|
/* add one reference for the tree */
|
|
|
|
atomic_inc(&eb->refs);
|
2008-01-24 22:13:08 +01:00
|
|
|
return eb;
|
|
|
|
|
2008-07-22 17:18:07 +02:00
|
|
|
free_eb:
|
2008-01-24 22:13:08 +01:00
|
|
|
if (!atomic_dec_and_test(&eb->refs))
|
2008-07-22 17:18:07 +02:00
|
|
|
return exists;
|
|
|
|
for (index = 1; index < i; index++)
|
2008-01-24 22:13:08 +01:00
|
|
|
page_cache_release(extent_buffer_page(eb, index));
|
2008-07-22 17:18:07 +02:00
|
|
|
page_cache_release(extent_buffer_page(eb, 0));
|
2008-01-24 22:13:08 +01:00
|
|
|
__free_extent_buffer(eb);
|
2008-07-22 17:18:07 +02:00
|
|
|
return exists;
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
struct extent_buffer *find_extent_buffer(struct extent_io_tree *tree,
|
|
|
|
u64 start, unsigned long len,
|
|
|
|
gfp_t mask)
|
|
|
|
{
|
|
|
|
struct extent_buffer *eb;
|
|
|
|
|
2008-07-22 17:18:07 +02:00
|
|
|
spin_lock(&tree->buffer_lock);
|
|
|
|
eb = buffer_search(tree, start);
|
|
|
|
if (eb)
|
|
|
|
atomic_inc(&eb->refs);
|
|
|
|
spin_unlock(&tree->buffer_lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
|
Btrfs: free space accounting redo
1) replace the per fs_info extent_io_tree that tracked free space with two
rb-trees per block group to track free space areas via offset and size. The
reason to do this is because most allocations come with a hint byte where to
start, so we can usually find a chunk of free space at that hint byte to satisfy
the allocation and get good space packing. If we cannot find free space at or
after the given offset we fall back on looking for a chunk of the given size as
close to that given offset as possible. When we fall back on the size search we
also try to find a slot as close to the size we want as possible, to avoid
breaking small chunks off of huge areas if possible.
2) remove the extent_io_tree that tracked the block group cache from fs_info and
replaced it with an rb-tree thats tracks block group cache via offset. also
added a per space_info list that tracks the block group cache for the particular
space so we can lookup related block groups easily.
3) cleaned up the allocation code to make it a little easier to read and a
little less complicated. Basically there are 3 steps, first look from our
provided hint. If we couldn't find from that given hint, start back at our
original search start and look for space from there. If that fails try to
allocate space if we can and start looking again. If not we're screwed and need
to start over again.
4) small fixes. there were some issues in volumes.c where we wouldn't allocate
the rest of the disk. fixed cow_file_range to actually pass the alloc_hint,
which has helped a good bit in making the fs_mark test I run have semi-normal
results as we run out of space. Generally with data allocations we don't track
where we last allocated from, so everytime we did a data allocation we'd search
through every block group that we have looking for free space. Now searching a
block group with no free space isn't terribly time consuming, it was causing a
slight degradation as we got more data block groups. The alloc_hint has fixed
this slight degredation and made things semi-normal.
There is still one nagging problem I'm working on where we will get ENOSPC when
there is definitely plenty of space. This only happens with metadata
allocations, and only when we are almost full. So you generally hit the 85%
mark first, but sometimes you'll hit the BUG before you hit the 85% wall. I'm
still tracking it down, but until then this seems to be pretty stable and make a
significant performance gain.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-09-23 19:14:11 +02:00
|
|
|
if (eb)
|
|
|
|
mark_page_accessed(eb->first_page);
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
return eb;
|
|
|
|
}
|
|
|
|
|
|
|
|
void free_extent_buffer(struct extent_buffer *eb)
|
|
|
|
{
|
|
|
|
if (!eb)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!atomic_dec_and_test(&eb->refs))
|
|
|
|
return;
|
|
|
|
|
2008-07-22 17:18:07 +02:00
|
|
|
WARN_ON(1);
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int clear_extent_buffer_dirty(struct extent_io_tree *tree,
|
|
|
|
struct extent_buffer *eb)
|
|
|
|
{
|
|
|
|
unsigned long i;
|
|
|
|
unsigned long num_pages;
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
num_pages = num_extent_pages(eb->start, eb->len);
|
|
|
|
|
|
|
|
for (i = 0; i < num_pages; i++) {
|
|
|
|
page = extent_buffer_page(eb, i);
|
2009-03-13 16:00:37 +01:00
|
|
|
if (!PageDirty(page))
|
2008-11-19 18:44:22 +01:00
|
|
|
continue;
|
|
|
|
|
2008-07-22 17:18:08 +02:00
|
|
|
lock_page(page);
|
2008-01-24 22:13:08 +01:00
|
|
|
if (i == 0)
|
|
|
|
set_page_extent_head(page, eb->len);
|
|
|
|
else
|
|
|
|
set_page_private(page, EXTENT_PAGE_PRIVATE);
|
|
|
|
|
|
|
|
clear_page_dirty_for_io(page);
|
2008-07-30 22:54:26 +02:00
|
|
|
spin_lock_irq(&page->mapping->tree_lock);
|
2008-01-24 22:13:08 +01:00
|
|
|
if (!PageDirty(page)) {
|
|
|
|
radix_tree_tag_clear(&page->mapping->page_tree,
|
|
|
|
page_index(page),
|
|
|
|
PAGECACHE_TAG_DIRTY);
|
|
|
|
}
|
2008-07-30 22:54:26 +02:00
|
|
|
spin_unlock_irq(&page->mapping->tree_lock);
|
2008-07-22 17:18:08 +02:00
|
|
|
unlock_page(page);
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int wait_on_extent_buffer_writeback(struct extent_io_tree *tree,
|
|
|
|
struct extent_buffer *eb)
|
|
|
|
{
|
|
|
|
return wait_on_extent_writeback(tree, eb->start,
|
|
|
|
eb->start + eb->len - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
int set_extent_buffer_dirty(struct extent_io_tree *tree,
|
|
|
|
struct extent_buffer *eb)
|
|
|
|
{
|
|
|
|
unsigned long i;
|
|
|
|
unsigned long num_pages;
|
2009-03-13 16:00:37 +01:00
|
|
|
int was_dirty = 0;
|
2008-01-24 22:13:08 +01:00
|
|
|
|
2009-03-13 16:00:37 +01:00
|
|
|
was_dirty = test_and_set_bit(EXTENT_BUFFER_DIRTY, &eb->bflags);
|
2008-01-24 22:13:08 +01:00
|
|
|
num_pages = num_extent_pages(eb->start, eb->len);
|
2009-03-13 16:00:37 +01:00
|
|
|
for (i = 0; i < num_pages; i++)
|
2008-01-24 22:13:08 +01:00
|
|
|
__set_page_dirty_nobuffers(extent_buffer_page(eb, i));
|
2009-03-13 16:00:37 +01:00
|
|
|
return was_dirty;
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
|
2008-05-12 19:39:03 +02:00
|
|
|
int clear_extent_buffer_uptodate(struct extent_io_tree *tree,
|
|
|
|
struct extent_buffer *eb)
|
|
|
|
{
|
|
|
|
unsigned long i;
|
|
|
|
struct page *page;
|
|
|
|
unsigned long num_pages;
|
|
|
|
|
|
|
|
num_pages = num_extent_pages(eb->start, eb->len);
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 15:25:08 +01:00
|
|
|
clear_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags);
|
2008-05-12 19:39:03 +02:00
|
|
|
|
|
|
|
clear_extent_uptodate(tree, eb->start, eb->start + eb->len - 1,
|
|
|
|
GFP_NOFS);
|
|
|
|
for (i = 0; i < num_pages; i++) {
|
|
|
|
page = extent_buffer_page(eb, i);
|
2008-07-30 16:29:12 +02:00
|
|
|
if (page)
|
|
|
|
ClearPageUptodate(page);
|
2008-05-12 19:39:03 +02:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
int set_extent_buffer_uptodate(struct extent_io_tree *tree,
|
|
|
|
struct extent_buffer *eb)
|
|
|
|
{
|
|
|
|
unsigned long i;
|
|
|
|
struct page *page;
|
|
|
|
unsigned long num_pages;
|
|
|
|
|
|
|
|
num_pages = num_extent_pages(eb->start, eb->len);
|
|
|
|
|
|
|
|
set_extent_uptodate(tree, eb->start, eb->start + eb->len - 1,
|
|
|
|
GFP_NOFS);
|
|
|
|
for (i = 0; i < num_pages; i++) {
|
|
|
|
page = extent_buffer_page(eb, i);
|
|
|
|
if ((i == 0 && (eb->start & (PAGE_CACHE_SIZE - 1))) ||
|
|
|
|
((i == num_pages - 1) &&
|
|
|
|
((eb->start + eb->len) & (PAGE_CACHE_SIZE - 1)))) {
|
|
|
|
check_page_uptodate(tree, page);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
SetPageUptodate(page);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-09 22:28:12 +02:00
|
|
|
int extent_range_uptodate(struct extent_io_tree *tree,
|
|
|
|
u64 start, u64 end)
|
|
|
|
{
|
|
|
|
struct page *page;
|
|
|
|
int ret;
|
|
|
|
int pg_uptodate = 1;
|
|
|
|
int uptodate;
|
|
|
|
unsigned long index;
|
|
|
|
|
|
|
|
ret = test_range_bit(tree, start, end, EXTENT_UPTODATE, 1);
|
|
|
|
if (ret)
|
|
|
|
return 1;
|
2009-01-06 03:25:51 +01:00
|
|
|
while (start <= end) {
|
2008-04-09 22:28:12 +02:00
|
|
|
index = start >> PAGE_CACHE_SHIFT;
|
|
|
|
page = find_get_page(tree->mapping, index);
|
|
|
|
uptodate = PageUptodate(page);
|
|
|
|
page_cache_release(page);
|
|
|
|
if (!uptodate) {
|
|
|
|
pg_uptodate = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
start += PAGE_CACHE_SIZE;
|
|
|
|
}
|
|
|
|
return pg_uptodate;
|
|
|
|
}
|
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
int extent_buffer_uptodate(struct extent_io_tree *tree,
|
2008-04-09 22:28:12 +02:00
|
|
|
struct extent_buffer *eb)
|
2008-01-24 22:13:08 +01:00
|
|
|
{
|
2008-04-09 22:28:12 +02:00
|
|
|
int ret = 0;
|
2008-04-09 22:28:12 +02:00
|
|
|
unsigned long num_pages;
|
|
|
|
unsigned long i;
|
2008-04-09 22:28:12 +02:00
|
|
|
struct page *page;
|
|
|
|
int pg_uptodate = 1;
|
|
|
|
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 15:25:08 +01:00
|
|
|
if (test_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags))
|
2008-04-28 22:40:52 +02:00
|
|
|
return 1;
|
2008-04-09 22:28:12 +02:00
|
|
|
|
2008-04-28 22:40:52 +02:00
|
|
|
ret = test_range_bit(tree, eb->start, eb->start + eb->len - 1,
|
2008-01-24 22:13:08 +01:00
|
|
|
EXTENT_UPTODATE, 1);
|
2008-04-28 22:40:52 +02:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2008-04-09 22:28:12 +02:00
|
|
|
|
|
|
|
num_pages = num_extent_pages(eb->start, eb->len);
|
|
|
|
for (i = 0; i < num_pages; i++) {
|
|
|
|
page = extent_buffer_page(eb, i);
|
|
|
|
if (!PageUptodate(page)) {
|
|
|
|
pg_uptodate = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2008-04-28 22:40:52 +02:00
|
|
|
return pg_uptodate;
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int read_extent_buffer_pages(struct extent_io_tree *tree,
|
|
|
|
struct extent_buffer *eb,
|
2008-02-07 16:50:54 +01:00
|
|
|
u64 start, int wait,
|
2008-04-09 22:28:12 +02:00
|
|
|
get_extent_t *get_extent, int mirror_num)
|
2008-01-24 22:13:08 +01:00
|
|
|
{
|
|
|
|
unsigned long i;
|
|
|
|
unsigned long start_i;
|
|
|
|
struct page *page;
|
|
|
|
int err;
|
|
|
|
int ret = 0;
|
2008-04-09 22:28:12 +02:00
|
|
|
int locked_pages = 0;
|
|
|
|
int all_uptodate = 1;
|
|
|
|
int inc_all_pages = 0;
|
2008-01-24 22:13:08 +01:00
|
|
|
unsigned long num_pages;
|
2008-02-07 16:50:54 +01:00
|
|
|
struct bio *bio = NULL;
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
unsigned long bio_flags = 0;
|
2008-02-07 16:50:54 +01:00
|
|
|
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 15:25:08 +01:00
|
|
|
if (test_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags))
|
2008-01-24 22:13:08 +01:00
|
|
|
return 0;
|
|
|
|
|
2008-04-09 22:28:12 +02:00
|
|
|
if (test_range_bit(tree, eb->start, eb->start + eb->len - 1,
|
2008-01-24 22:13:08 +01:00
|
|
|
EXTENT_UPTODATE, 1)) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (start) {
|
|
|
|
WARN_ON(start < eb->start);
|
|
|
|
start_i = (start >> PAGE_CACHE_SHIFT) -
|
|
|
|
(eb->start >> PAGE_CACHE_SHIFT);
|
|
|
|
} else {
|
|
|
|
start_i = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
num_pages = num_extent_pages(eb->start, eb->len);
|
|
|
|
for (i = start_i; i < num_pages; i++) {
|
|
|
|
page = extent_buffer_page(eb, i);
|
|
|
|
if (!wait) {
|
2008-08-07 17:19:43 +02:00
|
|
|
if (!trylock_page(page))
|
2008-04-09 22:28:12 +02:00
|
|
|
goto unlock_exit;
|
2008-01-24 22:13:08 +01:00
|
|
|
} else {
|
|
|
|
lock_page(page);
|
|
|
|
}
|
2008-04-09 22:28:12 +02:00
|
|
|
locked_pages++;
|
2009-01-06 03:25:51 +01:00
|
|
|
if (!PageUptodate(page))
|
2008-04-09 22:28:12 +02:00
|
|
|
all_uptodate = 0;
|
|
|
|
}
|
|
|
|
if (all_uptodate) {
|
|
|
|
if (start_i == 0)
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 15:25:08 +01:00
|
|
|
set_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags);
|
2008-04-09 22:28:12 +02:00
|
|
|
goto unlock_exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = start_i; i < num_pages; i++) {
|
|
|
|
page = extent_buffer_page(eb, i);
|
|
|
|
if (inc_all_pages)
|
|
|
|
page_cache_get(page);
|
|
|
|
if (!PageUptodate(page)) {
|
|
|
|
if (start_i == 0)
|
|
|
|
inc_all_pages = 1;
|
2008-04-09 22:28:12 +02:00
|
|
|
ClearPageError(page);
|
2008-02-07 16:50:54 +01:00
|
|
|
err = __extent_read_full_page(tree, page,
|
2008-04-09 22:28:12 +02:00
|
|
|
get_extent, &bio,
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
mirror_num, &bio_flags);
|
2009-01-06 03:25:51 +01:00
|
|
|
if (err)
|
2008-01-24 22:13:08 +01:00
|
|
|
ret = err;
|
|
|
|
} else {
|
|
|
|
unlock_page(page);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-07 16:50:54 +01:00
|
|
|
if (bio)
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 19:49:59 +01:00
|
|
|
submit_one_bio(READ, bio, mirror_num, bio_flags);
|
2008-02-07 16:50:54 +01:00
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
if (ret || !wait)
|
2008-01-24 22:13:08 +01:00
|
|
|
return ret;
|
2009-01-06 03:25:51 +01:00
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
for (i = start_i; i < num_pages; i++) {
|
|
|
|
page = extent_buffer_page(eb, i);
|
|
|
|
wait_on_page_locked(page);
|
2009-01-06 03:25:51 +01:00
|
|
|
if (!PageUptodate(page))
|
2008-01-24 22:13:08 +01:00
|
|
|
ret = -EIO;
|
|
|
|
}
|
2009-01-06 03:25:51 +01:00
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
if (!ret)
|
Btrfs: Change btree locking to use explicit blocking points
Most of the btrfs metadata operations can be protected by a spinlock,
but some operations still need to schedule.
So far, btrfs has been using a mutex along with a trylock loop,
most of the time it is able to avoid going for the full mutex, so
the trylock loop is a big performance gain.
This commit is step one for getting rid of the blocking locks entirely.
btrfs_tree_lock takes a spinlock, and the code explicitly switches
to a blocking lock when it starts an operation that can schedule.
We'll be able get rid of the blocking locks in smaller pieces over time.
Tracing allows us to find the most common cause of blocking, so we
can start with the hot spots first.
The basic idea is:
btrfs_tree_lock() returns with the spin lock held
btrfs_set_lock_blocking() sets the EXTENT_BUFFER_BLOCKING bit in
the extent buffer flags, and then drops the spin lock. The buffer is
still considered locked by all of the btrfs code.
If btrfs_tree_lock gets the spinlock but finds the blocking bit set, it drops
the spin lock and waits on a wait queue for the blocking bit to go away.
Much of the code that needs to set the blocking bit finishes without actually
blocking a good percentage of the time. So, an adaptive spin is still
used against the blocking bit to avoid very high context switch rates.
btrfs_clear_lock_blocking() clears the blocking bit and returns
with the spinlock held again.
btrfs_tree_unlock() can be called on either blocking or spinning locks,
it does the right thing based on the blocking bit.
ctree.c has a helper function to set/clear all the locked buffers in a
path as blocking.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-02-04 15:25:08 +01:00
|
|
|
set_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags);
|
2008-01-24 22:13:08 +01:00
|
|
|
return ret;
|
2008-04-09 22:28:12 +02:00
|
|
|
|
|
|
|
unlock_exit:
|
|
|
|
i = start_i;
|
2009-01-06 03:25:51 +01:00
|
|
|
while (locked_pages > 0) {
|
2008-04-09 22:28:12 +02:00
|
|
|
page = extent_buffer_page(eb, i);
|
|
|
|
i++;
|
|
|
|
unlock_page(page);
|
|
|
|
locked_pages--;
|
|
|
|
}
|
|
|
|
return ret;
|
2008-01-24 22:13:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void read_extent_buffer(struct extent_buffer *eb, void *dstv,
|
|
|
|
unsigned long start,
|
|
|
|
unsigned long len)
|
|
|
|
{
|
|
|
|
size_t cur;
|
|
|
|
size_t offset;
|
|
|
|
struct page *page;
|
|
|
|
char *kaddr;
|
|
|
|
char *dst = (char *)dstv;
|
|
|
|
size_t start_offset = eb->start & ((u64)PAGE_CACHE_SIZE - 1);
|
|
|
|
unsigned long i = (start_offset + start) >> PAGE_CACHE_SHIFT;
|
|
|
|
|
|
|
|
WARN_ON(start > eb->len);
|
|
|
|
WARN_ON(start + len > eb->start + eb->len);
|
|
|
|
|
|
|
|
offset = (start_offset + start) & ((unsigned long)PAGE_CACHE_SIZE - 1);
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (len > 0) {
|
2008-01-24 22:13:08 +01:00
|
|
|
page = extent_buffer_page(eb, i);
|
|
|
|
|
|
|
|
cur = min(len, (PAGE_CACHE_SIZE - offset));
|
|
|
|
kaddr = kmap_atomic(page, KM_USER1);
|
|
|
|
memcpy(dst, kaddr + offset, cur);
|
|
|
|
kunmap_atomic(kaddr, KM_USER1);
|
|
|
|
|
|
|
|
dst += cur;
|
|
|
|
len -= cur;
|
|
|
|
offset = 0;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int map_private_extent_buffer(struct extent_buffer *eb, unsigned long start,
|
|
|
|
unsigned long min_len, char **token, char **map,
|
|
|
|
unsigned long *map_start,
|
|
|
|
unsigned long *map_len, int km)
|
|
|
|
{
|
|
|
|
size_t offset = start & (PAGE_CACHE_SIZE - 1);
|
|
|
|
char *kaddr;
|
|
|
|
struct page *p;
|
|
|
|
size_t start_offset = eb->start & ((u64)PAGE_CACHE_SIZE - 1);
|
|
|
|
unsigned long i = (start_offset + start) >> PAGE_CACHE_SHIFT;
|
|
|
|
unsigned long end_i = (start_offset + start + min_len - 1) >>
|
|
|
|
PAGE_CACHE_SHIFT;
|
|
|
|
|
|
|
|
if (i != end_i)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (i == 0) {
|
|
|
|
offset = start_offset;
|
|
|
|
*map_start = 0;
|
|
|
|
} else {
|
|
|
|
offset = 0;
|
|
|
|
*map_start = ((u64)i << PAGE_CACHE_SHIFT) - start_offset;
|
|
|
|
}
|
2009-01-06 03:25:51 +01:00
|
|
|
|
2008-01-24 22:13:08 +01:00
|
|
|
if (start + min_len > eb->len) {
|
2009-01-06 03:25:51 +01:00
|
|
|
printk(KERN_ERR "btrfs bad mapping eb start %llu len %lu, "
|
|
|
|
"wanted %lu %lu\n", (unsigned long long)eb->start,
|
|
|
|
eb->len, start, min_len);
|
2008-01-24 22:13:08 +01:00
|
|
|
WARN_ON(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
p = extent_buffer_page(eb, i);
|
|
|
|
kaddr = kmap_atomic(p, km);
|
|
|
|
*token = kaddr;
|
|
|
|
*map = kaddr + offset;
|
|
|
|
*map_len = PAGE_CACHE_SIZE - offset;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int map_extent_buffer(struct extent_buffer *eb, unsigned long start,
|
|
|
|
unsigned long min_len,
|
|
|
|
char **token, char **map,
|
|
|
|
unsigned long *map_start,
|
|
|
|
unsigned long *map_len, int km)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
int save = 0;
|
|
|
|
if (eb->map_token) {
|
|
|
|
unmap_extent_buffer(eb, eb->map_token, km);
|
|
|
|
eb->map_token = NULL;
|
|
|
|
save = 1;
|
|
|
|
}
|
|
|
|
err = map_private_extent_buffer(eb, start, min_len, token, map,
|
|
|
|
map_start, map_len, km);
|
|
|
|
if (!err && save) {
|
|
|
|
eb->map_token = *token;
|
|
|
|
eb->kaddr = *map;
|
|
|
|
eb->map_start = *map_start;
|
|
|
|
eb->map_len = *map_len;
|
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
void unmap_extent_buffer(struct extent_buffer *eb, char *token, int km)
|
|
|
|
{
|
|
|
|
kunmap_atomic(token, km);
|
|
|
|
}
|
|
|
|
|
|
|
|
int memcmp_extent_buffer(struct extent_buffer *eb, const void *ptrv,
|
|
|
|
unsigned long start,
|
|
|
|
unsigned long len)
|
|
|
|
{
|
|
|
|
size_t cur;
|
|
|
|
size_t offset;
|
|
|
|
struct page *page;
|
|
|
|
char *kaddr;
|
|
|
|
char *ptr = (char *)ptrv;
|
|
|
|
size_t start_offset = eb->start & ((u64)PAGE_CACHE_SIZE - 1);
|
|
|
|
unsigned long i = (start_offset + start) >> PAGE_CACHE_SHIFT;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
WARN_ON(start > eb->len);
|
|
|
|
WARN_ON(start + len > eb->start + eb->len);
|
|
|
|
|
|
|
|
offset = (start_offset + start) & ((unsigned long)PAGE_CACHE_SIZE - 1);
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (len > 0) {
|
2008-01-24 22:13:08 +01:00
|
|
|
page = extent_buffer_page(eb, i);
|
|
|
|
|
|
|
|
cur = min(len, (PAGE_CACHE_SIZE - offset));
|
|
|
|
|
|
|
|
kaddr = kmap_atomic(page, KM_USER0);
|
|
|
|
ret = memcmp(ptr, kaddr + offset, cur);
|
|
|
|
kunmap_atomic(kaddr, KM_USER0);
|
|
|
|
if (ret)
|
|
|
|
break;
|
|
|
|
|
|
|
|
ptr += cur;
|
|
|
|
len -= cur;
|
|
|
|
offset = 0;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void write_extent_buffer(struct extent_buffer *eb, const void *srcv,
|
|
|
|
unsigned long start, unsigned long len)
|
|
|
|
{
|
|
|
|
size_t cur;
|
|
|
|
size_t offset;
|
|
|
|
struct page *page;
|
|
|
|
char *kaddr;
|
|
|
|
char *src = (char *)srcv;
|
|
|
|
size_t start_offset = eb->start & ((u64)PAGE_CACHE_SIZE - 1);
|
|
|
|
unsigned long i = (start_offset + start) >> PAGE_CACHE_SHIFT;
|
|
|
|
|
|
|
|
WARN_ON(start > eb->len);
|
|
|
|
WARN_ON(start + len > eb->start + eb->len);
|
|
|
|
|
|
|
|
offset = (start_offset + start) & ((unsigned long)PAGE_CACHE_SIZE - 1);
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (len > 0) {
|
2008-01-24 22:13:08 +01:00
|
|
|
page = extent_buffer_page(eb, i);
|
|
|
|
WARN_ON(!PageUptodate(page));
|
|
|
|
|
|
|
|
cur = min(len, PAGE_CACHE_SIZE - offset);
|
|
|
|
kaddr = kmap_atomic(page, KM_USER1);
|
|
|
|
memcpy(kaddr + offset, src, cur);
|
|
|
|
kunmap_atomic(kaddr, KM_USER1);
|
|
|
|
|
|
|
|
src += cur;
|
|
|
|
len -= cur;
|
|
|
|
offset = 0;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void memset_extent_buffer(struct extent_buffer *eb, char c,
|
|
|
|
unsigned long start, unsigned long len)
|
|
|
|
{
|
|
|
|
size_t cur;
|
|
|
|
size_t offset;
|
|
|
|
struct page *page;
|
|
|
|
char *kaddr;
|
|
|
|
size_t start_offset = eb->start & ((u64)PAGE_CACHE_SIZE - 1);
|
|
|
|
unsigned long i = (start_offset + start) >> PAGE_CACHE_SHIFT;
|
|
|
|
|
|
|
|
WARN_ON(start > eb->len);
|
|
|
|
WARN_ON(start + len > eb->start + eb->len);
|
|
|
|
|
|
|
|
offset = (start_offset + start) & ((unsigned long)PAGE_CACHE_SIZE - 1);
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (len > 0) {
|
2008-01-24 22:13:08 +01:00
|
|
|
page = extent_buffer_page(eb, i);
|
|
|
|
WARN_ON(!PageUptodate(page));
|
|
|
|
|
|
|
|
cur = min(len, PAGE_CACHE_SIZE - offset);
|
|
|
|
kaddr = kmap_atomic(page, KM_USER0);
|
|
|
|
memset(kaddr + offset, c, cur);
|
|
|
|
kunmap_atomic(kaddr, KM_USER0);
|
|
|
|
|
|
|
|
len -= cur;
|
|
|
|
offset = 0;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void copy_extent_buffer(struct extent_buffer *dst, struct extent_buffer *src,
|
|
|
|
unsigned long dst_offset, unsigned long src_offset,
|
|
|
|
unsigned long len)
|
|
|
|
{
|
|
|
|
u64 dst_len = dst->len;
|
|
|
|
size_t cur;
|
|
|
|
size_t offset;
|
|
|
|
struct page *page;
|
|
|
|
char *kaddr;
|
|
|
|
size_t start_offset = dst->start & ((u64)PAGE_CACHE_SIZE - 1);
|
|
|
|
unsigned long i = (start_offset + dst_offset) >> PAGE_CACHE_SHIFT;
|
|
|
|
|
|
|
|
WARN_ON(src->len != dst_len);
|
|
|
|
|
|
|
|
offset = (start_offset + dst_offset) &
|
|
|
|
((unsigned long)PAGE_CACHE_SIZE - 1);
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (len > 0) {
|
2008-01-24 22:13:08 +01:00
|
|
|
page = extent_buffer_page(dst, i);
|
|
|
|
WARN_ON(!PageUptodate(page));
|
|
|
|
|
|
|
|
cur = min(len, (unsigned long)(PAGE_CACHE_SIZE - offset));
|
|
|
|
|
|
|
|
kaddr = kmap_atomic(page, KM_USER0);
|
|
|
|
read_extent_buffer(src, kaddr + offset, src_offset, cur);
|
|
|
|
kunmap_atomic(kaddr, KM_USER0);
|
|
|
|
|
|
|
|
src_offset += cur;
|
|
|
|
len -= cur;
|
|
|
|
offset = 0;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void move_pages(struct page *dst_page, struct page *src_page,
|
|
|
|
unsigned long dst_off, unsigned long src_off,
|
|
|
|
unsigned long len)
|
|
|
|
{
|
|
|
|
char *dst_kaddr = kmap_atomic(dst_page, KM_USER0);
|
|
|
|
if (dst_page == src_page) {
|
|
|
|
memmove(dst_kaddr + dst_off, dst_kaddr + src_off, len);
|
|
|
|
} else {
|
|
|
|
char *src_kaddr = kmap_atomic(src_page, KM_USER1);
|
|
|
|
char *p = dst_kaddr + dst_off + len;
|
|
|
|
char *s = src_kaddr + src_off + len;
|
|
|
|
|
|
|
|
while (len--)
|
|
|
|
*--p = *--s;
|
|
|
|
|
|
|
|
kunmap_atomic(src_kaddr, KM_USER1);
|
|
|
|
}
|
|
|
|
kunmap_atomic(dst_kaddr, KM_USER0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void copy_pages(struct page *dst_page, struct page *src_page,
|
|
|
|
unsigned long dst_off, unsigned long src_off,
|
|
|
|
unsigned long len)
|
|
|
|
{
|
|
|
|
char *dst_kaddr = kmap_atomic(dst_page, KM_USER0);
|
|
|
|
char *src_kaddr;
|
|
|
|
|
|
|
|
if (dst_page != src_page)
|
|
|
|
src_kaddr = kmap_atomic(src_page, KM_USER1);
|
|
|
|
else
|
|
|
|
src_kaddr = dst_kaddr;
|
|
|
|
|
|
|
|
memcpy(dst_kaddr + dst_off, src_kaddr + src_off, len);
|
|
|
|
kunmap_atomic(dst_kaddr, KM_USER0);
|
|
|
|
if (dst_page != src_page)
|
|
|
|
kunmap_atomic(src_kaddr, KM_USER1);
|
|
|
|
}
|
|
|
|
|
|
|
|
void memcpy_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset,
|
|
|
|
unsigned long src_offset, unsigned long len)
|
|
|
|
{
|
|
|
|
size_t cur;
|
|
|
|
size_t dst_off_in_page;
|
|
|
|
size_t src_off_in_page;
|
|
|
|
size_t start_offset = dst->start & ((u64)PAGE_CACHE_SIZE - 1);
|
|
|
|
unsigned long dst_i;
|
|
|
|
unsigned long src_i;
|
|
|
|
|
|
|
|
if (src_offset + len > dst->len) {
|
2009-01-06 03:25:51 +01:00
|
|
|
printk(KERN_ERR "btrfs memmove bogus src_offset %lu move "
|
|
|
|
"len %lu dst len %lu\n", src_offset, len, dst->len);
|
2008-01-24 22:13:08 +01:00
|
|
|
BUG_ON(1);
|
|
|
|
}
|
|
|
|
if (dst_offset + len > dst->len) {
|
2009-01-06 03:25:51 +01:00
|
|
|
printk(KERN_ERR "btrfs memmove bogus dst_offset %lu move "
|
|
|
|
"len %lu dst len %lu\n", dst_offset, len, dst->len);
|
2008-01-24 22:13:08 +01:00
|
|
|
BUG_ON(1);
|
|
|
|
}
|
|
|
|
|
2009-01-06 03:25:51 +01:00
|
|
|
while (len > 0) {
|
2008-01-24 22:13:08 +01:00
|
|
|
dst_off_in_page = (start_offset + dst_offset) &
|
|
|
|
((unsigned long)PAGE_CACHE_SIZE - 1);
|
|
|
|
src_off_in_page = (start_offset + src_offset) &
|
|
|
|
((unsigned long)PAGE_CACHE_SIZE - 1);
|
|
|
|
|
|
|
|
dst_i = (start_offset + dst_offset) >> PAGE_CACHE_SHIFT;
|
|
|
|
src_i = (start_offset + src_offset) >> PAGE_CACHE_SHIFT;
|
|
|
|
|
|
|
|
cur = min(len, (unsigned long)(PAGE_CACHE_SIZE -
|
|
|
|
src_off_in_page));
|
|
|
|
cur = min_t(unsigned long, cur,
|
|
|
|
(unsigned long)(PAGE_CACHE_SIZE - dst_off_in_page));
|
|
|
|
|
|
|
|
copy_pages(extent_buffer_page(dst, dst_i),
|
|
|
|
extent_buffer_page(dst, src_i),
|
|
|
|
dst_off_in_page, src_off_in_page, cur);
|
|
|
|
|
|
|
|
src_offset += cur;
|
|
|
|
dst_offset += cur;
|
|
|
|
len -= cur;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void memmove_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset,
|
|
|
|
unsigned long src_offset, unsigned long len)
|
|
|
|
{
|
|
|
|
size_t cur;
|
|
|
|
size_t dst_off_in_page;
|
|
|
|
size_t src_off_in_page;
|
|
|
|
unsigned long dst_end = dst_offset + len - 1;
|
|
|
|
unsigned long src_end = src_offset + len - 1;
|
|
|
|
size_t start_offset = dst->start & ((u64)PAGE_CACHE_SIZE - 1);
|
|
|
|
unsigned long dst_i;
|
|
|
|
unsigned long src_i;
|
|
|
|
|
|
|
|
if (src_offset + len > dst->len) {
|
2009-01-06 03:25:51 +01:00
|
|
|
printk(KERN_ERR "btrfs memmove bogus src_offset %lu move "
|
|
|
|
"len %lu len %lu\n", src_offset, len, dst->len);
|
2008-01-24 22:13:08 +01:00
|
|
|
BUG_ON(1);
|
|
|
|
}
|
|
|
|
if (dst_offset + len > dst->len) {
|
2009-01-06 03:25:51 +01:00
|
|
|
printk(KERN_ERR "btrfs memmove bogus dst_offset %lu move "
|
|
|
|
"len %lu len %lu\n", dst_offset, len, dst->len);
|
2008-01-24 22:13:08 +01:00
|
|
|
BUG_ON(1);
|
|
|
|
}
|
|
|
|
if (dst_offset < src_offset) {
|
|
|
|
memcpy_extent_buffer(dst, dst_offset, src_offset, len);
|
|
|
|
return;
|
|
|
|
}
|
2009-01-06 03:25:51 +01:00
|
|
|
while (len > 0) {
|
2008-01-24 22:13:08 +01:00
|
|
|
dst_i = (start_offset + dst_end) >> PAGE_CACHE_SHIFT;
|
|
|
|
src_i = (start_offset + src_end) >> PAGE_CACHE_SHIFT;
|
|
|
|
|
|
|
|
dst_off_in_page = (start_offset + dst_end) &
|
|
|
|
((unsigned long)PAGE_CACHE_SIZE - 1);
|
|
|
|
src_off_in_page = (start_offset + src_end) &
|
|
|
|
((unsigned long)PAGE_CACHE_SIZE - 1);
|
|
|
|
|
|
|
|
cur = min_t(unsigned long, len, src_off_in_page + 1);
|
|
|
|
cur = min(cur, dst_off_in_page + 1);
|
|
|
|
move_pages(extent_buffer_page(dst, dst_i),
|
|
|
|
extent_buffer_page(dst, src_i),
|
|
|
|
dst_off_in_page - cur + 1,
|
|
|
|
src_off_in_page - cur + 1, cur);
|
|
|
|
|
|
|
|
dst_end -= cur;
|
|
|
|
src_end -= cur;
|
|
|
|
len -= cur;
|
|
|
|
}
|
|
|
|
}
|
2008-07-22 17:18:07 +02:00
|
|
|
|
|
|
|
int try_release_extent_buffer(struct extent_io_tree *tree, struct page *page)
|
|
|
|
{
|
|
|
|
u64 start = page_offset(page);
|
|
|
|
struct extent_buffer *eb;
|
|
|
|
int ret = 1;
|
|
|
|
unsigned long i;
|
|
|
|
unsigned long num_pages;
|
|
|
|
|
|
|
|
spin_lock(&tree->buffer_lock);
|
|
|
|
eb = buffer_search(tree, start);
|
|
|
|
if (!eb)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (atomic_read(&eb->refs) > 1) {
|
|
|
|
ret = 0;
|
|
|
|
goto out;
|
|
|
|
}
|
2009-03-13 16:00:37 +01:00
|
|
|
if (test_bit(EXTENT_BUFFER_DIRTY, &eb->bflags)) {
|
|
|
|
ret = 0;
|
|
|
|
goto out;
|
|
|
|
}
|
2008-07-22 17:18:07 +02:00
|
|
|
/* at this point we can safely release the extent buffer */
|
|
|
|
num_pages = num_extent_pages(eb->start, eb->len);
|
2008-09-05 22:43:31 +02:00
|
|
|
for (i = 0; i < num_pages; i++)
|
|
|
|
page_cache_release(extent_buffer_page(eb, i));
|
2008-07-22 17:18:07 +02:00
|
|
|
rb_erase(&eb->rb_node, &tree->buffer);
|
|
|
|
__free_extent_buffer(eb);
|
|
|
|
out:
|
|
|
|
spin_unlock(&tree->buffer_lock);
|
|
|
|
return ret;
|
|
|
|
}
|