linux/include/linux/buffer_head.h
<<
>>
Prefs
   1/*
   2 * include/linux/buffer_head.h
   3 *
   4 * Everything to do with buffer_heads.
   5 */
   6
   7#ifndef _LINUX_BUFFER_HEAD_H
   8#define _LINUX_BUFFER_HEAD_H
   9
  10#include <linux/types.h>
  11#include <linux/fs.h>
  12#include <linux/linkage.h>
  13#include <linux/pagemap.h>
  14#include <linux/wait.h>
  15#include <linux/atomic.h>
  16
  17#ifdef CONFIG_BLOCK
  18
  19enum bh_state_bits {
  20        BH_Uptodate,    /* Contains valid data */
  21        BH_Dirty,       /* Is dirty */
  22        BH_Lock,        /* Is locked */
  23        BH_Req,         /* Has been submitted for I/O */
  24        BH_Uptodate_Lock,/* Used by the first bh in a page, to serialise
  25                          * IO completion of other buffers in the page
  26                          */
  27
  28        BH_Mapped,      /* Has a disk mapping */
  29        BH_New,         /* Disk mapping was newly created by get_block */
  30        BH_Async_Read,  /* Is under end_buffer_async_read I/O */
  31        BH_Async_Write, /* Is under end_buffer_async_write I/O */
  32        BH_Delay,       /* Buffer is not yet allocated on disk */
  33        BH_Boundary,    /* Block is followed by a discontiguity */
  34        BH_Write_EIO,   /* I/O error on write */
  35        BH_Unwritten,   /* Buffer is allocated on disk but not written */
  36        BH_Quiet,       /* Buffer Error Prinks to be quiet */
  37
  38        BH_PrivateStart,/* not a state bit, but the first bit available
  39                         * for private allocation by other entities
  40                         */
  41};
  42
  43#define MAX_BUF_PER_PAGE (PAGE_CACHE_SIZE / 512)
  44
  45struct page;
  46struct buffer_head;
  47struct address_space;
  48typedef void (bh_end_io_t)(struct buffer_head *bh, int uptodate);
  49
  50/*
  51 * Historically, a buffer_head was used to map a single block
  52 * within a page, and of course as the unit of I/O through the
  53 * filesystem and block layers.  Nowadays the basic I/O unit
  54 * is the bio, and buffer_heads are used for extracting block
  55 * mappings (via a get_block_t call), for tracking state within
  56 * a page (via a page_mapping) and for wrapping bio submission
  57 * for backward compatibility reasons (e.g. submit_bh).
  58 */
  59struct buffer_head {
  60        unsigned long b_state;          /* buffer state bitmap (see above) */
  61        struct buffer_head *b_this_page;/* circular list of page's buffers */
  62        struct page *b_page;            /* the page this bh is mapped to */
  63
  64        sector_t b_blocknr;             /* start block number */
  65        size_t b_size;                  /* size of mapping */
  66        char *b_data;                   /* pointer to data within the page */
  67
  68        struct block_device *b_bdev;
  69        bh_end_io_t *b_end_io;          /* I/O completion */
  70        void *b_private;                /* reserved for b_end_io */
  71        struct list_head b_assoc_buffers; /* associated with another mapping */
  72        struct address_space *b_assoc_map;      /* mapping this buffer is
  73                                                   associated with */
  74        atomic_t b_count;               /* users using this buffer_head */
  75};
  76
  77/*
  78 * macro tricks to expand the set_buffer_foo(), clear_buffer_foo()
  79 * and buffer_foo() functions.
  80 */
  81#define BUFFER_FNS(bit, name)                                           \
  82static inline void set_buffer_##name(struct buffer_head *bh)            \
  83{                                                                       \
  84        set_bit(BH_##bit, &(bh)->b_state);                              \
  85}                                                                       \
  86static inline void clear_buffer_##name(struct buffer_head *bh)          \
  87{                                                                       \
  88        clear_bit(BH_##bit, &(bh)->b_state);                            \
  89}                                                                       \
  90static inline int buffer_##name(const struct buffer_head *bh)           \
  91{                                                                       \
  92        return test_bit(BH_##bit, &(bh)->b_state);                      \
  93}
  94
  95/*
  96 * test_set_buffer_foo() and test_clear_buffer_foo()
  97 */
  98#define TAS_BUFFER_FNS(bit, name)                                       \
  99static inline int test_set_buffer_##name(struct buffer_head *bh)        \
 100{                                                                       \
 101        return test_and_set_bit(BH_##bit, &(bh)->b_state);              \
 102}                                                                       \
 103static inline int test_clear_buffer_##name(struct buffer_head *bh)      \
 104{                                                                       \
 105        return test_and_clear_bit(BH_##bit, &(bh)->b_state);            \
 106}                                                                       \
 107
 108/*
 109 * Emit the buffer bitops functions.   Note that there are also functions
 110 * of the form "mark_buffer_foo()".  These are higher-level functions which
 111 * do something in addition to setting a b_state bit.
 112 */
 113BUFFER_FNS(Uptodate, uptodate)
 114BUFFER_FNS(Dirty, dirty)
 115TAS_BUFFER_FNS(Dirty, dirty)
 116BUFFER_FNS(Lock, locked)
 117BUFFER_FNS(Req, req)
 118TAS_BUFFER_FNS(Req, req)
 119BUFFER_FNS(Mapped, mapped)
 120BUFFER_FNS(New, new)
 121BUFFER_FNS(Async_Read, async_read)
 122BUFFER_FNS(Async_Write, async_write)
 123BUFFER_FNS(Delay, delay)
 124BUFFER_FNS(Boundary, boundary)
 125BUFFER_FNS(Write_EIO, write_io_error)
 126BUFFER_FNS(Unwritten, unwritten)
 127
 128#define bh_offset(bh)           ((unsigned long)(bh)->b_data & ~PAGE_MASK)
 129#define touch_buffer(bh)        mark_page_accessed(bh->b_page)
 130
 131/* If we *know* page->private refers to buffer_heads */
 132#define page_buffers(page)                                      \
 133        ({                                                      \
 134                BUG_ON(!PagePrivate(page));                     \
 135                ((struct buffer_head *)page_private(page));     \
 136        })
 137#define page_has_buffers(page)  PagePrivate(page)
 138
 139/*
 140 * Declarations
 141 */
 142
 143void mark_buffer_dirty(struct buffer_head *bh);
 144void init_buffer(struct buffer_head *, bh_end_io_t *, void *);
 145void set_bh_page(struct buffer_head *bh,
 146                struct page *page, unsigned long offset);
 147int try_to_free_buffers(struct page *);
 148struct buffer_head *alloc_page_buffers(struct page *page, unsigned long size,
 149                int retry);
 150void create_empty_buffers(struct page *, unsigned long,
 151                        unsigned long b_state);
 152void end_buffer_read_sync(struct buffer_head *bh, int uptodate);
 153void end_buffer_write_sync(struct buffer_head *bh, int uptodate);
 154void end_buffer_async_write(struct buffer_head *bh, int uptodate);
 155
 156/* Things to do with buffers at mapping->private_list */
 157void mark_buffer_dirty_inode(struct buffer_head *bh, struct inode *inode);
 158int inode_has_buffers(struct inode *);
 159void invalidate_inode_buffers(struct inode *);
 160int remove_inode_buffers(struct inode *inode);
 161int sync_mapping_buffers(struct address_space *mapping);
 162void unmap_underlying_metadata(struct block_device *bdev, sector_t block);
 163
 164void mark_buffer_async_write(struct buffer_head *bh);
 165void __wait_on_buffer(struct buffer_head *);
 166wait_queue_head_t *bh_waitq_head(struct buffer_head *bh);
 167struct buffer_head *__find_get_block(struct block_device *bdev, sector_t block,
 168                        unsigned size);
 169struct buffer_head *__getblk(struct block_device *bdev, sector_t block,
 170                        unsigned size);
 171void __brelse(struct buffer_head *);
 172void __bforget(struct buffer_head *);
 173void __breadahead(struct block_device *, sector_t block, unsigned int size);
 174struct buffer_head *__bread(struct block_device *, sector_t block, unsigned size);
 175void invalidate_bh_lrus(void);
 176struct buffer_head *alloc_buffer_head(gfp_t gfp_flags);
 177void free_buffer_head(struct buffer_head * bh);
 178void unlock_buffer(struct buffer_head *bh);
 179void __lock_buffer(struct buffer_head *bh);
 180void ll_rw_block(int, int, struct buffer_head * bh[]);
 181int sync_dirty_buffer(struct buffer_head *bh);
 182int __sync_dirty_buffer(struct buffer_head *bh, int rw);
 183void write_dirty_buffer(struct buffer_head *bh, int rw);
 184int submit_bh(int, struct buffer_head *);
 185void write_boundary_block(struct block_device *bdev,
 186                        sector_t bblock, unsigned blocksize);
 187int bh_uptodate_or_lock(struct buffer_head *bh);
 188int bh_submit_read(struct buffer_head *bh);
 189
 190extern int buffer_heads_over_limit;
 191
 192/*
 193 * Generic address_space_operations implementations for buffer_head-backed
 194 * address_spaces.
 195 */
 196void block_invalidatepage(struct page *page, unsigned long offset);
 197int block_write_full_page(struct page *page, get_block_t *get_block,
 198                                struct writeback_control *wbc);
 199int block_write_full_page_endio(struct page *page, get_block_t *get_block,
 200                        struct writeback_control *wbc, bh_end_io_t *handler);
 201int block_read_full_page(struct page*, get_block_t*);
 202int block_is_partially_uptodate(struct page *page, read_descriptor_t *desc,
 203                                unsigned long from);
 204int block_write_begin(struct address_space *mapping, loff_t pos, unsigned len,
 205                unsigned flags, struct page **pagep, get_block_t *get_block);
 206int __block_write_begin(struct page *page, loff_t pos, unsigned len,
 207                get_block_t *get_block);
 208int block_write_end(struct file *, struct address_space *,
 209                                loff_t, unsigned, unsigned,
 210                                struct page *, void *);
 211int generic_write_end(struct file *, struct address_space *,
 212                                loff_t, unsigned, unsigned,
 213                                struct page *, void *);
 214void page_zero_new_buffers(struct page *page, unsigned from, unsigned to);
 215int cont_write_begin(struct file *, struct address_space *, loff_t,
 216                        unsigned, unsigned, struct page **, void **,
 217                        get_block_t *, loff_t *);
 218int generic_cont_expand_simple(struct inode *inode, loff_t size);
 219int block_commit_write(struct page *page, unsigned from, unsigned to);
 220int __block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf,
 221                                get_block_t get_block);
 222int block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf,
 223                                get_block_t get_block);
 224/* Convert errno to return value from ->page_mkwrite() call */
 225static inline int block_page_mkwrite_return(int err)
 226{
 227        if (err == 0)
 228                return VM_FAULT_LOCKED;
 229        if (err == -EFAULT)
 230                return VM_FAULT_NOPAGE;
 231        if (err == -ENOMEM)
 232                return VM_FAULT_OOM;
 233        if (err == -EAGAIN)
 234                return VM_FAULT_RETRY;
 235        /* -ENOSPC, -EDQUOT, -EIO ... */
 236        return VM_FAULT_SIGBUS;
 237}
 238sector_t generic_block_bmap(struct address_space *, sector_t, get_block_t *);
 239int block_truncate_page(struct address_space *, loff_t, get_block_t *);
 240int nobh_write_begin(struct address_space *, loff_t, unsigned, unsigned,
 241                                struct page **, void **, get_block_t*);
 242int nobh_write_end(struct file *, struct address_space *,
 243                                loff_t, unsigned, unsigned,
 244                                struct page *, void *);
 245int nobh_truncate_page(struct address_space *, loff_t, get_block_t *);
 246int nobh_writepage(struct page *page, get_block_t *get_block,
 247                        struct writeback_control *wbc);
 248
 249void buffer_init(void);
 250
 251/*
 252 * inline definitions
 253 */
 254
 255static inline void attach_page_buffers(struct page *page,
 256                struct buffer_head *head)
 257{
 258        page_cache_get(page);
 259        SetPagePrivate(page);
 260        set_page_private(page, (unsigned long)head);
 261}
 262
 263static inline void get_bh(struct buffer_head *bh)
 264{
 265        atomic_inc(&bh->b_count);
 266}
 267
 268static inline void put_bh(struct buffer_head *bh)
 269{
 270        smp_mb__before_atomic_dec();
 271        atomic_dec(&bh->b_count);
 272}
 273
 274static inline void brelse(struct buffer_head *bh)
 275{
 276        if (bh)
 277                __brelse(bh);
 278}
 279
 280static inline void bforget(struct buffer_head *bh)
 281{
 282        if (bh)
 283                __bforget(bh);
 284}
 285
 286static inline struct buffer_head *
 287sb_bread(struct super_block *sb, sector_t block)
 288{
 289        return __bread(sb->s_bdev, block, sb->s_blocksize);
 290}
 291
 292static inline void
 293sb_breadahead(struct super_block *sb, sector_t block)
 294{
 295        __breadahead(sb->s_bdev, block, sb->s_blocksize);
 296}
 297
 298static inline struct buffer_head *
 299sb_getblk(struct super_block *sb, sector_t block)
 300{
 301        return __getblk(sb->s_bdev, block, sb->s_blocksize);
 302}
 303
 304static inline struct buffer_head *
 305sb_find_get_block(struct super_block *sb, sector_t block)
 306{
 307        return __find_get_block(sb->s_bdev, block, sb->s_blocksize);
 308}
 309
 310static inline void
 311map_bh(struct buffer_head *bh, struct super_block *sb, sector_t block)
 312{
 313        set_buffer_mapped(bh);
 314        bh->b_bdev = sb->s_bdev;
 315        bh->b_blocknr = block;
 316        bh->b_size = sb->s_blocksize;
 317}
 318
 319static inline void wait_on_buffer(struct buffer_head *bh)
 320{
 321        might_sleep();
 322        if (buffer_locked(bh))
 323                __wait_on_buffer(bh);
 324}
 325
 326static inline int trylock_buffer(struct buffer_head *bh)
 327{
 328        return likely(!test_and_set_bit_lock(BH_Lock, &bh->b_state));
 329}
 330
 331static inline void lock_buffer(struct buffer_head *bh)
 332{
 333        might_sleep();
 334        if (!trylock_buffer(bh))
 335                __lock_buffer(bh);
 336}
 337
 338extern int __set_page_dirty_buffers(struct page *page);
 339
 340#else /* CONFIG_BLOCK */
 341
 342static inline void buffer_init(void) {}
 343static inline int try_to_free_buffers(struct page *page) { return 1; }
 344static inline int inode_has_buffers(struct inode *inode) { return 0; }
 345static inline void invalidate_inode_buffers(struct inode *inode) {}
 346static inline int remove_inode_buffers(struct inode *inode) { return 1; }
 347static inline int sync_mapping_buffers(struct address_space *mapping) { return 0; }
 348
 349#endif /* CONFIG_BLOCK */
 350#endif /* _LINUX_BUFFER_HEAD_H */
 351
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.