2008-01-25 00:13:08 +03:00
|
|
|
#ifndef __EXTENTIO__
|
|
|
|
|
#define __EXTENTIO__
|
|
|
|
|
|
|
|
|
|
#include <linux/rbtree.h>
|
|
|
|
|
|
|
|
|
|
/* bits for the extent state */
|
|
|
|
|
#define EXTENT_DIRTY 1
|
|
|
|
|
#define EXTENT_WRITEBACK (1 << 1)
|
|
|
|
|
#define EXTENT_UPTODATE (1 << 2)
|
|
|
|
|
#define EXTENT_LOCKED (1 << 3)
|
|
|
|
|
#define EXTENT_NEW (1 << 4)
|
|
|
|
|
#define EXTENT_DELALLOC (1 << 5)
|
|
|
|
|
#define EXTENT_DEFRAG (1 << 6)
|
|
|
|
|
#define EXTENT_DEFRAG_DONE (1 << 7)
|
|
|
|
|
#define EXTENT_BUFFER_FILLED (1 << 8)
|
2008-07-17 20:53:50 +04:00
|
|
|
#define EXTENT_ORDERED (1 << 9)
|
|
|
|
|
#define EXTENT_ORDERED_METADATA (1 << 10)
|
2008-09-26 18:05:38 +04:00
|
|
|
#define EXTENT_BOUNDARY (1 << 11)
|
2008-12-12 18:03:38 +03:00
|
|
|
#define EXTENT_NODATASUM (1 << 12)
|
2008-01-25 00:13:08 +03:00
|
|
|
#define EXTENT_IOBITS (EXTENT_LOCKED | EXTENT_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 21:49:59 +03:00
|
|
|
/* flags for bio submission */
|
|
|
|
|
#define EXTENT_BIO_COMPRESSED 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 17:25:08 +03:00
|
|
|
/* these are bit numbers for test/set bit */
|
|
|
|
|
#define EXTENT_BUFFER_UPTODATE 0
|
|
|
|
|
#define EXTENT_BUFFER_BLOCKING 1
|
|
|
|
|
|
2008-01-25 00:13:08 +03:00
|
|
|
/*
|
|
|
|
|
* page->private values. Every page that is controlled by the extent
|
|
|
|
|
* map has page->private set to one.
|
|
|
|
|
*/
|
|
|
|
|
#define EXTENT_PAGE_PRIVATE 1
|
|
|
|
|
#define EXTENT_PAGE_PRIVATE_FIRST_PAGE 3
|
|
|
|
|
|
2008-01-29 17:59:12 +03:00
|
|
|
struct extent_state;
|
|
|
|
|
|
2008-04-16 19:14:51 +04:00
|
|
|
typedef int (extent_submit_bio_hook_t)(struct inode *inode, int rw,
|
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 21:49:59 +03:00
|
|
|
struct bio *bio, int mirror_num,
|
|
|
|
|
unsigned long bio_flags);
|
2008-01-25 00:13:08 +03:00
|
|
|
struct extent_io_ops {
|
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 21:49:59 +03:00
|
|
|
int (*fill_delalloc)(struct inode *inode, struct page *locked_page,
|
2008-11-07 06:02:51 +03:00
|
|
|
u64 start, u64 end, int *page_started,
|
|
|
|
|
unsigned long *nr_written);
|
2008-07-17 20:53:51 +04:00
|
|
|
int (*writepage_start_hook)(struct page *page, u64 start, u64 end);
|
2008-01-25 00:13:08 +03:00
|
|
|
int (*writepage_io_hook)(struct page *page, u64 start, u64 end);
|
2008-04-16 19:14:51 +04:00
|
|
|
extent_submit_bio_hook_t *submit_bio_hook;
|
2008-03-24 22:02:07 +03:00
|
|
|
int (*merge_bio_hook)(struct page *page, unsigned long offset,
|
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 21:49:59 +03:00
|
|
|
size_t size, struct bio *bio,
|
|
|
|
|
unsigned long bio_flags);
|
2008-01-25 00:13:08 +03:00
|
|
|
int (*readpage_io_hook)(struct page *page, u64 start, u64 end);
|
2008-04-10 00:28:12 +04:00
|
|
|
int (*readpage_io_failed_hook)(struct bio *bio, struct page *page,
|
|
|
|
|
u64 start, u64 end,
|
|
|
|
|
struct extent_state *state);
|
2008-05-12 21:39:03 +04:00
|
|
|
int (*writepage_io_failed_hook)(struct bio *bio, struct page *page,
|
|
|
|
|
u64 start, u64 end,
|
|
|
|
|
struct extent_state *state);
|
2008-01-29 17:59:12 +03:00
|
|
|
int (*readpage_end_io_hook)(struct page *page, u64 start, u64 end,
|
|
|
|
|
struct extent_state *state);
|
2008-05-12 21:39:03 +04:00
|
|
|
int (*writepage_end_io_hook)(struct page *page, u64 start, u64 end,
|
2008-07-17 20:53:50 +04:00
|
|
|
struct extent_state *state, int uptodate);
|
2008-01-29 23:55:23 +03:00
|
|
|
int (*set_bit_hook)(struct inode *inode, u64 start, u64 end,
|
2008-01-31 19:05:37 +03:00
|
|
|
unsigned long old, unsigned long bits);
|
2008-01-29 23:55:23 +03:00
|
|
|
int (*clear_bit_hook)(struct inode *inode, u64 start, u64 end,
|
2008-01-31 19:05:37 +03:00
|
|
|
unsigned long old, unsigned long bits);
|
2008-09-08 19:18:08 +04:00
|
|
|
int (*write_cache_pages_lock_hook)(struct page *page);
|
2008-01-25 00:13:08 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct extent_io_tree {
|
|
|
|
|
struct rb_root state;
|
2008-07-22 19:18:07 +04:00
|
|
|
struct rb_root buffer;
|
2008-01-25 00:13:08 +03:00
|
|
|
struct address_space *mapping;
|
|
|
|
|
u64 dirty_bytes;
|
2008-01-29 17:59:12 +03:00
|
|
|
spinlock_t lock;
|
2008-07-22 19:18:07 +04:00
|
|
|
spinlock_t buffer_lock;
|
2008-01-25 00:13:08 +03:00
|
|
|
struct extent_io_ops *ops;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct extent_state {
|
|
|
|
|
u64 start;
|
|
|
|
|
u64 end; /* inclusive */
|
|
|
|
|
struct rb_node rb_node;
|
2008-01-29 17:59:12 +03:00
|
|
|
struct extent_io_tree *tree;
|
2008-01-25 00:13:08 +03:00
|
|
|
wait_queue_head_t wq;
|
|
|
|
|
atomic_t refs;
|
|
|
|
|
unsigned long state;
|
|
|
|
|
|
|
|
|
|
/* for use by the FS */
|
|
|
|
|
u64 private;
|
|
|
|
|
|
2008-03-26 23:24:23 +03:00
|
|
|
struct list_head leak_list;
|
2008-01-25 00:13:08 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct extent_buffer {
|
|
|
|
|
u64 start;
|
|
|
|
|
unsigned long len;
|
|
|
|
|
char *map_token;
|
|
|
|
|
char *kaddr;
|
|
|
|
|
unsigned long map_start;
|
|
|
|
|
unsigned long map_len;
|
|
|
|
|
struct page *first_page;
|
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 17:25:08 +03:00
|
|
|
unsigned long bflags;
|
2008-01-25 00:13:08 +03:00
|
|
|
atomic_t refs;
|
2008-03-26 23:24:23 +03:00
|
|
|
struct list_head leak_list;
|
2008-07-22 19:18:07 +04:00
|
|
|
struct rb_node rb_node;
|
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 17:25:08 +03:00
|
|
|
|
|
|
|
|
/* the spinlock is used to protect most operations */
|
|
|
|
|
spinlock_t lock;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* when we keep the lock held while blocking, waiters go onto
|
|
|
|
|
* the wq
|
|
|
|
|
*/
|
|
|
|
|
wait_queue_head_t lock_wq;
|
2008-01-25 00:13:08 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct extent_map_tree;
|
|
|
|
|
|
2008-02-18 20:12:38 +03:00
|
|
|
static inline struct extent_state *extent_state_next(struct extent_state *state)
|
|
|
|
|
{
|
|
|
|
|
struct rb_node *node;
|
|
|
|
|
node = rb_next(&state->rb_node);
|
|
|
|
|
if (!node)
|
|
|
|
|
return NULL;
|
|
|
|
|
return rb_entry(node, struct extent_state, rb_node);
|
|
|
|
|
}
|
|
|
|
|
|
2008-01-25 00:13:08 +03:00
|
|
|
typedef struct extent_map *(get_extent_t)(struct inode *inode,
|
|
|
|
|
struct page *page,
|
|
|
|
|
size_t page_offset,
|
|
|
|
|
u64 start, u64 len,
|
|
|
|
|
int create);
|
|
|
|
|
|
|
|
|
|
void extent_io_tree_init(struct extent_io_tree *tree,
|
|
|
|
|
struct address_space *mapping, gfp_t mask);
|
|
|
|
|
int try_release_extent_mapping(struct extent_map_tree *map,
|
2008-01-29 17:59:12 +03:00
|
|
|
struct extent_io_tree *tree, struct page *page,
|
|
|
|
|
gfp_t mask);
|
2008-07-22 19:18:07 +04:00
|
|
|
int try_release_extent_buffer(struct extent_io_tree *tree, struct page *page);
|
2008-04-18 18:29:50 +04:00
|
|
|
int try_release_extent_state(struct extent_map_tree *map,
|
|
|
|
|
struct extent_io_tree *tree, struct page *page,
|
|
|
|
|
gfp_t mask);
|
2008-01-25 00:13:08 +03:00
|
|
|
int lock_extent(struct extent_io_tree *tree, u64 start, u64 end, gfp_t mask);
|
|
|
|
|
int unlock_extent(struct extent_io_tree *tree, u64 start, u64 end, gfp_t 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 21:49:05 +03:00
|
|
|
int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
|
gfp_t mask);
|
2008-01-25 00:13:08 +03:00
|
|
|
int extent_read_full_page(struct extent_io_tree *tree, struct page *page,
|
|
|
|
|
get_extent_t *get_extent);
|
|
|
|
|
int __init extent_io_init(void);
|
|
|
|
|
void extent_io_exit(void);
|
|
|
|
|
|
|
|
|
|
u64 count_range_bits(struct extent_io_tree *tree,
|
|
|
|
|
u64 *start, u64 search_end,
|
|
|
|
|
u64 max_bytes, unsigned long bits);
|
|
|
|
|
|
|
|
|
|
int test_range_bit(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
|
int bits, int filled);
|
|
|
|
|
int clear_extent_bits(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
|
int bits, gfp_t mask);
|
2008-07-17 20:53:50 +04:00
|
|
|
int clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
|
int bits, int wake, int delete, gfp_t mask);
|
2008-01-25 00:13:08 +03:00
|
|
|
int set_extent_bits(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
|
int bits, gfp_t mask);
|
|
|
|
|
int set_extent_uptodate(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
|
gfp_t mask);
|
|
|
|
|
int set_extent_new(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
|
gfp_t mask);
|
|
|
|
|
int set_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
|
gfp_t mask);
|
|
|
|
|
int clear_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
|
gfp_t mask);
|
2008-07-17 20:53:50 +04:00
|
|
|
int clear_extent_ordered(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
|
gfp_t mask);
|
|
|
|
|
int clear_extent_ordered_metadata(struct extent_io_tree *tree, u64 start,
|
|
|
|
|
u64 end, gfp_t mask);
|
2008-01-25 00:13:08 +03:00
|
|
|
int set_extent_delalloc(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
|
gfp_t mask);
|
2008-07-17 20:53:50 +04:00
|
|
|
int set_extent_ordered(struct extent_io_tree *tree, u64 start, u64 end,
|
|
|
|
|
gfp_t mask);
|
2008-01-25 00:13:08 +03:00
|
|
|
int find_first_extent_bit(struct extent_io_tree *tree, u64 start,
|
|
|
|
|
u64 *start_ret, u64 *end_ret, int bits);
|
2008-02-18 20:12:38 +03:00
|
|
|
struct extent_state *find_first_extent_bit_state(struct extent_io_tree *tree,
|
|
|
|
|
u64 start, int bits);
|
2008-01-25 00:13:08 +03:00
|
|
|
int extent_invalidatepage(struct extent_io_tree *tree,
|
|
|
|
|
struct page *page, unsigned long offset);
|
|
|
|
|
int extent_write_full_page(struct extent_io_tree *tree, struct page *page,
|
|
|
|
|
get_extent_t *get_extent,
|
|
|
|
|
struct writeback_control *wbc);
|
2008-11-07 06:02:51 +03: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);
|
2008-01-25 00:13:08 +03:00
|
|
|
int extent_writepages(struct extent_io_tree *tree,
|
|
|
|
|
struct address_space *mapping,
|
|
|
|
|
get_extent_t *get_extent,
|
|
|
|
|
struct writeback_control *wbc);
|
|
|
|
|
int extent_readpages(struct extent_io_tree *tree,
|
|
|
|
|
struct address_space *mapping,
|
|
|
|
|
struct list_head *pages, unsigned nr_pages,
|
|
|
|
|
get_extent_t get_extent);
|
|
|
|
|
int extent_prepare_write(struct extent_io_tree *tree,
|
|
|
|
|
struct inode *inode, struct page *page,
|
|
|
|
|
unsigned from, unsigned to, get_extent_t *get_extent);
|
|
|
|
|
int extent_commit_write(struct extent_io_tree *tree,
|
|
|
|
|
struct inode *inode, struct page *page,
|
|
|
|
|
unsigned from, unsigned to);
|
|
|
|
|
sector_t extent_bmap(struct address_space *mapping, sector_t iblock,
|
|
|
|
|
get_extent_t *get_extent);
|
2009-01-21 22:39:14 +03:00
|
|
|
int extent_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
|
|
|
|
|
__u64 start, __u64 len, get_extent_t *get_extent);
|
2008-01-25 00:13:08 +03:00
|
|
|
int set_range_dirty(struct extent_io_tree *tree, u64 start, u64 end);
|
|
|
|
|
int set_state_private(struct extent_io_tree *tree, u64 start, u64 private);
|
|
|
|
|
int get_state_private(struct extent_io_tree *tree, u64 start, u64 *private);
|
|
|
|
|
void set_page_extent_mapped(struct page *page);
|
|
|
|
|
|
|
|
|
|
struct extent_buffer *alloc_extent_buffer(struct extent_io_tree *tree,
|
|
|
|
|
u64 start, unsigned long len,
|
|
|
|
|
struct page *page0,
|
|
|
|
|
gfp_t mask);
|
|
|
|
|
struct extent_buffer *find_extent_buffer(struct extent_io_tree *tree,
|
|
|
|
|
u64 start, unsigned long len,
|
|
|
|
|
gfp_t mask);
|
|
|
|
|
void free_extent_buffer(struct extent_buffer *eb);
|
|
|
|
|
int read_extent_buffer_pages(struct extent_io_tree *tree,
|
2008-02-07 18:50:54 +03:00
|
|
|
struct extent_buffer *eb, u64 start, int wait,
|
2008-04-10 00:28:12 +04:00
|
|
|
get_extent_t *get_extent, int mirror_num);
|
2008-01-25 00:13:08 +03:00
|
|
|
|
|
|
|
|
static inline void extent_buffer_get(struct extent_buffer *eb)
|
|
|
|
|
{
|
|
|
|
|
atomic_inc(&eb->refs);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int memcmp_extent_buffer(struct extent_buffer *eb, const void *ptrv,
|
|
|
|
|
unsigned long start,
|
|
|
|
|
unsigned long len);
|
|
|
|
|
void read_extent_buffer(struct extent_buffer *eb, void *dst,
|
|
|
|
|
unsigned long start,
|
|
|
|
|
unsigned long len);
|
|
|
|
|
void write_extent_buffer(struct extent_buffer *eb, const void *src,
|
|
|
|
|
unsigned long start, unsigned long len);
|
|
|
|
|
void copy_extent_buffer(struct extent_buffer *dst, struct extent_buffer *src,
|
|
|
|
|
unsigned long dst_offset, unsigned long src_offset,
|
|
|
|
|
unsigned long len);
|
|
|
|
|
void memcpy_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset,
|
|
|
|
|
unsigned long src_offset, unsigned long len);
|
|
|
|
|
void memmove_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset,
|
|
|
|
|
unsigned long src_offset, unsigned long len);
|
|
|
|
|
void memset_extent_buffer(struct extent_buffer *eb, char c,
|
|
|
|
|
unsigned long start, unsigned long len);
|
|
|
|
|
int wait_on_extent_buffer_writeback(struct extent_io_tree *tree,
|
|
|
|
|
struct extent_buffer *eb);
|
2008-07-17 20:53:50 +04:00
|
|
|
int wait_on_extent_writeback(struct extent_io_tree *tree, u64 start, u64 end);
|
|
|
|
|
int wait_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, int bits);
|
2008-01-25 00:13:08 +03:00
|
|
|
int clear_extent_buffer_dirty(struct extent_io_tree *tree,
|
|
|
|
|
struct extent_buffer *eb);
|
|
|
|
|
int set_extent_buffer_dirty(struct extent_io_tree *tree,
|
|
|
|
|
struct extent_buffer *eb);
|
|
|
|
|
int set_extent_buffer_uptodate(struct extent_io_tree *tree,
|
|
|
|
|
struct extent_buffer *eb);
|
2008-05-12 21:39:03 +04:00
|
|
|
int clear_extent_buffer_uptodate(struct extent_io_tree *tree,
|
|
|
|
|
struct extent_buffer *eb);
|
2008-01-25 00:13:08 +03:00
|
|
|
int extent_buffer_uptodate(struct extent_io_tree *tree,
|
|
|
|
|
struct extent_buffer *eb);
|
|
|
|
|
int map_extent_buffer(struct extent_buffer *eb, unsigned long offset,
|
|
|
|
|
unsigned long min_len, char **token, char **map,
|
|
|
|
|
unsigned long *map_start,
|
|
|
|
|
unsigned long *map_len, int km);
|
|
|
|
|
int map_private_extent_buffer(struct extent_buffer *eb, unsigned long offset,
|
|
|
|
|
unsigned long min_len, char **token, char **map,
|
|
|
|
|
unsigned long *map_start,
|
|
|
|
|
unsigned long *map_len, int km);
|
|
|
|
|
void unmap_extent_buffer(struct extent_buffer *eb, char *token, int km);
|
2008-04-10 00:28:12 +04:00
|
|
|
int release_extent_buffer_tail_pages(struct extent_buffer *eb);
|
|
|
|
|
int extent_range_uptodate(struct extent_io_tree *tree,
|
|
|
|
|
u64 start, u64 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 21:49:59 +03:00
|
|
|
int extent_clear_unlock_delalloc(struct inode *inode,
|
|
|
|
|
struct extent_io_tree *tree,
|
|
|
|
|
u64 start, u64 end, struct page *locked_page,
|
2008-11-07 06:02:51 +03:00
|
|
|
int unlock_page,
|
|
|
|
|
int clear_unlock,
|
|
|
|
|
int clear_delalloc, int clear_dirty,
|
|
|
|
|
int set_writeback,
|
|
|
|
|
int end_writeback);
|
2008-01-25 00:13:08 +03:00
|
|
|
#endif
|
