buffer_head.h 11.6 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/*
 * include/linux/buffer_head.h
 *
 * Everything to do with buffer_heads.
 */

#ifndef _LINUX_BUFFER_HEAD_H
#define _LINUX_BUFFER_HEAD_H

#include <linux/types.h>
#include <linux/fs.h>
#include <linux/linkage.h>
#include <linux/pagemap.h>
#include <linux/wait.h>
#include <asm/atomic.h>

17 18
#ifdef CONFIG_BLOCK

Linus Torvalds's avatar
Linus Torvalds committed
19 20 21 22 23
enum bh_state_bits {
	BH_Uptodate,	/* Contains valid data */
	BH_Dirty,	/* Is dirty */
	BH_Lock,	/* Is locked */
	BH_Req,		/* Has been submitted for I/O */
24 25 26
	BH_Uptodate_Lock,/* Used by the first bh in a page, to serialise
			  * IO completion of other buffers in the page
			  */
Linus Torvalds's avatar
Linus Torvalds committed
27 28 29 30 31 32 33 34 35 36

	BH_Mapped,	/* Has a disk mapping */
	BH_New,		/* Disk mapping was newly created by get_block */
	BH_Async_Read,	/* Is under end_buffer_async_read I/O */
	BH_Async_Write,	/* Is under end_buffer_async_write I/O */
	BH_Delay,	/* Buffer is not yet allocated on disk */
	BH_Boundary,	/* Block is followed by a discontiguity */
	BH_Write_EIO,	/* I/O error on write */
	BH_Ordered,	/* ordered write */
	BH_Eopnotsupp,	/* operation not supported (barrier) */
37
	BH_Unwritten,	/* Buffer is allocated on disk but not written */
38
	BH_Quiet,	/* Buffer Error Prinks to be quiet */
Linus Torvalds's avatar
Linus Torvalds committed
39 40 41 42 43 44 45 46 47 48 49 50 51 52

	BH_PrivateStart,/* not a state bit, but the first bit available
			 * for private allocation by other entities
			 */
};

#define MAX_BUF_PER_PAGE (PAGE_CACHE_SIZE / 512)

struct page;
struct buffer_head;
struct address_space;
typedef void (bh_end_io_t)(struct buffer_head *bh, int uptodate);

/*
53 54 55 56 57 58 59
 * Historically, a buffer_head was used to map a single block
 * within a page, and of course as the unit of I/O through the
 * filesystem and block layers.  Nowadays the basic I/O unit
 * is the bio, and buffer_heads are used for extracting block
 * mappings (via a get_block_t call), for tracking state within
 * a page (via a page_mapping) and for wrapping bio submission
 * for backward compatibility reasons (e.g. submit_bh).
Linus Torvalds's avatar
Linus Torvalds committed
60 61 62 63 64 65
 */
struct buffer_head {
	unsigned long b_state;		/* buffer state bitmap (see above) */
	struct buffer_head *b_this_page;/* circular list of page's buffers */
	struct page *b_page;		/* the page this bh is mapped to */

66 67 68
	sector_t b_blocknr;		/* start block number */
	size_t b_size;			/* size of mapping */
	char *b_data;			/* pointer to data within the page */
Linus Torvalds's avatar
Linus Torvalds committed
69 70 71 72 73

	struct block_device *b_bdev;
	bh_end_io_t *b_end_io;		/* I/O completion */
 	void *b_private;		/* reserved for b_end_io */
	struct list_head b_assoc_buffers; /* associated with another mapping */
74 75
	struct address_space *b_assoc_map;	/* mapping this buffer is
						   associated with */
76
	atomic_t b_count;		/* users using this buffer_head */
Linus Torvalds's avatar
Linus Torvalds committed
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129
};

/*
 * macro tricks to expand the set_buffer_foo(), clear_buffer_foo()
 * and buffer_foo() functions.
 */
#define BUFFER_FNS(bit, name)						\
static inline void set_buffer_##name(struct buffer_head *bh)		\
{									\
	set_bit(BH_##bit, &(bh)->b_state);				\
}									\
static inline void clear_buffer_##name(struct buffer_head *bh)		\
{									\
	clear_bit(BH_##bit, &(bh)->b_state);				\
}									\
static inline int buffer_##name(const struct buffer_head *bh)		\
{									\
	return test_bit(BH_##bit, &(bh)->b_state);			\
}

/*
 * test_set_buffer_foo() and test_clear_buffer_foo()
 */
#define TAS_BUFFER_FNS(bit, name)					\
static inline int test_set_buffer_##name(struct buffer_head *bh)	\
{									\
	return test_and_set_bit(BH_##bit, &(bh)->b_state);		\
}									\
static inline int test_clear_buffer_##name(struct buffer_head *bh)	\
{									\
	return test_and_clear_bit(BH_##bit, &(bh)->b_state);		\
}									\

/*
 * Emit the buffer bitops functions.   Note that there are also functions
 * of the form "mark_buffer_foo()".  These are higher-level functions which
 * do something in addition to setting a b_state bit.
 */
BUFFER_FNS(Uptodate, uptodate)
BUFFER_FNS(Dirty, dirty)
TAS_BUFFER_FNS(Dirty, dirty)
BUFFER_FNS(Lock, locked)
BUFFER_FNS(Req, req)
TAS_BUFFER_FNS(Req, req)
BUFFER_FNS(Mapped, mapped)
BUFFER_FNS(New, new)
BUFFER_FNS(Async_Read, async_read)
BUFFER_FNS(Async_Write, async_write)
BUFFER_FNS(Delay, delay)
BUFFER_FNS(Boundary, boundary)
BUFFER_FNS(Write_EIO, write_io_error)
BUFFER_FNS(Ordered, ordered)
BUFFER_FNS(Eopnotsupp, eopnotsupp)
130
BUFFER_FNS(Unwritten, unwritten)
Linus Torvalds's avatar
Linus Torvalds committed
131 132 133 134 135 136 137

#define bh_offset(bh)		((unsigned long)(bh)->b_data & ~PAGE_MASK)
#define touch_buffer(bh)	mark_page_accessed(bh->b_page)

/* If we *know* page->private refers to buffer_heads */
#define page_buffers(page)					\
	({							\
138 139
		BUG_ON(!PagePrivate(page));			\
		((struct buffer_head *)page_private(page));	\
Linus Torvalds's avatar
Linus Torvalds committed
140 141 142 143 144 145 146
	})
#define page_has_buffers(page)	PagePrivate(page)

/*
 * Declarations
 */

147
void mark_buffer_dirty(struct buffer_head *bh);
Linus Torvalds's avatar
Linus Torvalds committed
148 149 150 151 152 153 154 155 156 157
void init_buffer(struct buffer_head *, bh_end_io_t *, void *);
void set_bh_page(struct buffer_head *bh,
		struct page *page, unsigned long offset);
int try_to_free_buffers(struct page *);
struct buffer_head *alloc_page_buffers(struct page *page, unsigned long size,
		int retry);
void create_empty_buffers(struct page *, unsigned long,
			unsigned long b_state);
void end_buffer_read_sync(struct buffer_head *bh, int uptodate);
void end_buffer_write_sync(struct buffer_head *bh, int uptodate);
158
void end_buffer_async_write(struct buffer_head *bh, int uptodate);
Linus Torvalds's avatar
Linus Torvalds committed
159 160 161 162 163 164 165 166 167 168 169 170

/* Things to do with buffers at mapping->private_list */
void mark_buffer_dirty_inode(struct buffer_head *bh, struct inode *inode);
int inode_has_buffers(struct inode *);
void invalidate_inode_buffers(struct inode *);
int remove_inode_buffers(struct inode *inode);
int sync_mapping_buffers(struct address_space *mapping);
void unmap_underlying_metadata(struct block_device *bdev, sector_t block);

void mark_buffer_async_write(struct buffer_head *bh);
void __wait_on_buffer(struct buffer_head *);
wait_queue_head_t *bh_waitq_head(struct buffer_head *bh);
171 172 173 174
struct buffer_head *__find_get_block(struct block_device *bdev, sector_t block,
			unsigned size);
struct buffer_head *__getblk(struct block_device *bdev, sector_t block,
			unsigned size);
Linus Torvalds's avatar
Linus Torvalds committed
175 176
void __brelse(struct buffer_head *);
void __bforget(struct buffer_head *);
177 178
void __breadahead(struct block_device *, sector_t block, unsigned int size);
struct buffer_head *__bread(struct block_device *, sector_t block, unsigned size);
Peter Zijlstra's avatar
Peter Zijlstra committed
179
void invalidate_bh_lrus(void);
180
struct buffer_head *alloc_buffer_head(gfp_t gfp_flags);
Linus Torvalds's avatar
Linus Torvalds committed
181
void free_buffer_head(struct buffer_head * bh);
182 183
void unlock_buffer(struct buffer_head *bh);
void __lock_buffer(struct buffer_head *bh);
Linus Torvalds's avatar
Linus Torvalds committed
184 185 186 187 188
void ll_rw_block(int, int, struct buffer_head * bh[]);
int sync_dirty_buffer(struct buffer_head *bh);
int submit_bh(int, struct buffer_head *);
void write_boundary_block(struct block_device *bdev,
			sector_t bblock, unsigned blocksize);
189 190
int bh_uptodate_or_lock(struct buffer_head *bh);
int bh_submit_read(struct buffer_head *bh);
Linus Torvalds's avatar
Linus Torvalds committed
191 192 193 194 195 196 197

extern int buffer_heads_over_limit;

/*
 * Generic address_space_operations implementations for buffer_head-backed
 * address_spaces.
 */
198
void block_invalidatepage(struct page *page, unsigned long offset);
Linus Torvalds's avatar
Linus Torvalds committed
199 200
int block_write_full_page(struct page *page, get_block_t *get_block,
				struct writeback_control *wbc);
201 202
int block_write_full_page_endio(struct page *page, get_block_t *get_block,
			struct writeback_control *wbc, bh_end_io_t *handler);
Linus Torvalds's avatar
Linus Torvalds committed
203
int block_read_full_page(struct page*, get_block_t*);
204 205
int block_is_partially_uptodate(struct page *page, read_descriptor_t *desc,
				unsigned long from);
206 207 208
int block_write_begin_newtrunc(struct file *, struct address_space *,
				loff_t, unsigned, unsigned,
				struct page **, void **, get_block_t*);
209 210 211 212 213 214 215 216 217 218
int block_write_begin(struct file *, struct address_space *,
				loff_t, unsigned, unsigned,
				struct page **, void **, get_block_t*);
int block_write_end(struct file *, struct address_space *,
				loff_t, unsigned, unsigned,
				struct page *, void *);
int generic_write_end(struct file *, struct address_space *,
				loff_t, unsigned, unsigned,
				struct page *, void *);
void page_zero_new_buffers(struct page *page, unsigned from, unsigned to);
Linus Torvalds's avatar
Linus Torvalds committed
219
int block_prepare_write(struct page*, unsigned, unsigned, get_block_t*);
220 221 222
int cont_write_begin_newtrunc(struct file *, struct address_space *, loff_t,
			unsigned, unsigned, struct page **, void **,
			get_block_t *, loff_t *);
Nick Piggin's avatar
Nick Piggin committed
223 224 225
int cont_write_begin(struct file *, struct address_space *, loff_t,
			unsigned, unsigned, struct page **, void **,
			get_block_t *, loff_t *);
226
int generic_cont_expand_simple(struct inode *inode, loff_t size);
Linus Torvalds's avatar
Linus Torvalds committed
227
int block_commit_write(struct page *page, unsigned from, unsigned to);
228
int block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf,
229
				get_block_t get_block);
230
void block_sync_page(struct page *);
Linus Torvalds's avatar
Linus Torvalds committed
231 232
sector_t generic_block_bmap(struct address_space *, sector_t, get_block_t *);
int block_truncate_page(struct address_space *, loff_t, get_block_t *);
233
int file_fsync(struct file *, int);
234 235 236
int nobh_write_begin_newtrunc(struct file *, struct address_space *,
				loff_t, unsigned, unsigned,
				struct page **, void **, get_block_t*);
Nick Piggin's avatar
Nick Piggin committed
237 238 239 240 241 242 243
int nobh_write_begin(struct file *, struct address_space *,
				loff_t, unsigned, unsigned,
				struct page **, void **, get_block_t*);
int nobh_write_end(struct file *, struct address_space *,
				loff_t, unsigned, unsigned,
				struct page *, void *);
int nobh_truncate_page(struct address_space *, loff_t, get_block_t *);
Linus Torvalds's avatar
Linus Torvalds committed
244 245 246
int nobh_writepage(struct page *page, get_block_t *get_block,
                        struct writeback_control *wbc);

Adrian Bunk's avatar
Adrian Bunk committed
247
void buffer_init(void);
Linus Torvalds's avatar
Linus Torvalds committed
248 249 250 251 252 253 254 255 256 257

/*
 * inline definitions
 */

static inline void attach_page_buffers(struct page *page,
		struct buffer_head *head)
{
	page_cache_get(page);
	SetPagePrivate(page);
258
	set_page_private(page, (unsigned long)head);
Linus Torvalds's avatar
Linus Torvalds committed
259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
}

static inline void get_bh(struct buffer_head *bh)
{
        atomic_inc(&bh->b_count);
}

static inline void put_bh(struct buffer_head *bh)
{
        smp_mb__before_atomic_dec();
        atomic_dec(&bh->b_count);
}

static inline void brelse(struct buffer_head *bh)
{
	if (bh)
		__brelse(bh);
}

static inline void bforget(struct buffer_head *bh)
{
	if (bh)
		__bforget(bh);
}

static inline struct buffer_head *
sb_bread(struct super_block *sb, sector_t block)
{
	return __bread(sb->s_bdev, block, sb->s_blocksize);
}

static inline void
sb_breadahead(struct super_block *sb, sector_t block)
{
	__breadahead(sb->s_bdev, block, sb->s_blocksize);
}

static inline struct buffer_head *
sb_getblk(struct super_block *sb, sector_t block)
{
	return __getblk(sb->s_bdev, block, sb->s_blocksize);
}

static inline struct buffer_head *
sb_find_get_block(struct super_block *sb, sector_t block)
{
	return __find_get_block(sb->s_bdev, block, sb->s_blocksize);
}

static inline void
map_bh(struct buffer_head *bh, struct super_block *sb, sector_t block)
{
	set_buffer_mapped(bh);
	bh->b_bdev = sb->s_bdev;
	bh->b_blocknr = block;
314
	bh->b_size = sb->s_blocksize;
Linus Torvalds's avatar
Linus Torvalds committed
315 316 317 318 319 320 321 322 323 324 325 326 327 328
}

/*
 * Calling wait_on_buffer() for a zero-ref buffer is illegal, so we call into
 * __wait_on_buffer() just to trip a debug check.  Because debug code in inline
 * functions is bloaty.
 */
static inline void wait_on_buffer(struct buffer_head *bh)
{
	might_sleep();
	if (buffer_locked(bh) || atomic_read(&bh->b_count) == 0)
		__wait_on_buffer(bh);
}

Nick Piggin's avatar
Nick Piggin committed
329 330
static inline int trylock_buffer(struct buffer_head *bh)
{
Nick Piggin's avatar
Nick Piggin committed
331
	return likely(!test_and_set_bit_lock(BH_Lock, &bh->b_state));
Nick Piggin's avatar
Nick Piggin committed
332 333
}

Linus Torvalds's avatar
Linus Torvalds committed
334 335 336
static inline void lock_buffer(struct buffer_head *bh)
{
	might_sleep();
Nick Piggin's avatar
Nick Piggin committed
337
	if (!trylock_buffer(bh))
Linus Torvalds's avatar
Linus Torvalds committed
338 339 340
		__lock_buffer(bh);
}

341
extern int __set_page_dirty_buffers(struct page *page);
342 343 344 345 346 347 348 349 350 351 352

#else /* CONFIG_BLOCK */

static inline void buffer_init(void) {}
static inline int try_to_free_buffers(struct page *page) { return 1; }
static inline int inode_has_buffers(struct inode *inode) { return 0; }
static inline void invalidate_inode_buffers(struct inode *inode) {}
static inline int remove_inode_buffers(struct inode *inode) { return 1; }
static inline int sync_mapping_buffers(struct address_space *mapping) { return 0; }

#endif /* CONFIG_BLOCK */
Linus Torvalds's avatar
Linus Torvalds committed
353
#endif /* _LINUX_BUFFER_HEAD_H */