home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / buffer_head.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  11.4 KB  |  351 lines
  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 <asm/atomic.h>
  16.  
  17. #ifdef CONFIG_BLOCK
  18.  
  19. enum 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_Ordered,    /* ordered write */
  36.     BH_Eopnotsupp,    /* operation not supported (barrier) */
  37.     BH_Unwritten,    /* Buffer is allocated on disk but not written */
  38.  
  39.     BH_PrivateStart,/* not a state bit, but the first bit available
  40.              * for private allocation by other entities
  41.              */
  42. };
  43.  
  44. #define MAX_BUF_PER_PAGE (PAGE_CACHE_SIZE / 512)
  45.  
  46. struct page;
  47. struct buffer_head;
  48. struct address_space;
  49. typedef void (bh_end_io_t)(struct buffer_head *bh, int uptodate);
  50.  
  51. /*
  52.  * Historically, a buffer_head was used to map a single block
  53.  * within a page, and of course as the unit of I/O through the
  54.  * filesystem and block layers.  Nowadays the basic I/O unit
  55.  * is the bio, and buffer_heads are used for extracting block
  56.  * mappings (via a get_block_t call), for tracking state within
  57.  * a page (via a page_mapping) and for wrapping bio submission
  58.  * for backward compatibility reasons (e.g. submit_bh).
  59.  */
  60. struct buffer_head {
  61.     unsigned long b_state;        /* buffer state bitmap (see above) */
  62.     struct buffer_head *b_this_page;/* circular list of page's buffers */
  63.     struct page *b_page;        /* the page this bh is mapped to */
  64.  
  65.     sector_t b_blocknr;        /* start block number */
  66.     size_t b_size;            /* size of mapping */
  67.     char *b_data;            /* pointer to data within the page */
  68.  
  69.     struct block_device *b_bdev;
  70.     bh_end_io_t *b_end_io;        /* I/O completion */
  71.      void *b_private;        /* reserved for b_end_io */
  72.     struct list_head b_assoc_buffers; /* associated with another mapping */
  73.     struct address_space *b_assoc_map;    /* mapping this buffer is
  74.                            associated with */
  75.     atomic_t b_count;        /* users using this buffer_head */
  76. };
  77.  
  78. /*
  79.  * macro tricks to expand the set_buffer_foo(), clear_buffer_foo()
  80.  * and buffer_foo() functions.
  81.  */
  82. #define BUFFER_FNS(bit, name)                        \
  83. static inline void set_buffer_##name(struct buffer_head *bh)        \
  84. {                                    \
  85.     set_bit(BH_##bit, &(bh)->b_state);                \
  86. }                                    \
  87. static inline void clear_buffer_##name(struct buffer_head *bh)        \
  88. {                                    \
  89.     clear_bit(BH_##bit, &(bh)->b_state);                \
  90. }                                    \
  91. static inline int buffer_##name(const struct buffer_head *bh)        \
  92. {                                    \
  93.     return test_bit(BH_##bit, &(bh)->b_state);            \
  94. }
  95.  
  96. /*
  97.  * test_set_buffer_foo() and test_clear_buffer_foo()
  98.  */
  99. #define TAS_BUFFER_FNS(bit, name)                    \
  100. static inline int test_set_buffer_##name(struct buffer_head *bh)    \
  101. {                                    \
  102.     return test_and_set_bit(BH_##bit, &(bh)->b_state);        \
  103. }                                    \
  104. static inline int test_clear_buffer_##name(struct buffer_head *bh)    \
  105. {                                    \
  106.     return test_and_clear_bit(BH_##bit, &(bh)->b_state);        \
  107. }                                    \
  108.  
  109. /*
  110.  * Emit the buffer bitops functions.   Note that there are also functions
  111.  * of the form "mark_buffer_foo()".  These are higher-level functions which
  112.  * do something in addition to setting a b_state bit.
  113.  */
  114. BUFFER_FNS(Uptodate, uptodate)
  115. BUFFER_FNS(Dirty, dirty)
  116. TAS_BUFFER_FNS(Dirty, dirty)
  117. BUFFER_FNS(Lock, locked)
  118. BUFFER_FNS(Req, req)
  119. TAS_BUFFER_FNS(Req, req)
  120. BUFFER_FNS(Mapped, mapped)
  121. BUFFER_FNS(New, new)
  122. BUFFER_FNS(Async_Read, async_read)
  123. BUFFER_FNS(Async_Write, async_write)
  124. BUFFER_FNS(Delay, delay)
  125. BUFFER_FNS(Boundary, boundary)
  126. BUFFER_FNS(Write_EIO, write_io_error)
  127. BUFFER_FNS(Ordered, ordered)
  128. BUFFER_FNS(Eopnotsupp, eopnotsupp)
  129. BUFFER_FNS(Unwritten, unwritten)
  130.  
  131. #define bh_offset(bh)        ((unsigned long)(bh)->b_data & ~PAGE_MASK)
  132. #define touch_buffer(bh)    mark_page_accessed(bh->b_page)
  133.  
  134. /* If we *know* page->private refers to buffer_heads */
  135. #define page_buffers(page)                    \
  136.     ({                            \
  137.         BUG_ON(!PagePrivate(page));            \
  138.         ((struct buffer_head *)page_private(page));    \
  139.     })
  140. #define page_has_buffers(page)    PagePrivate(page)
  141.  
  142. /*
  143.  * Declarations
  144.  */
  145.  
  146. void mark_buffer_dirty(struct buffer_head *bh);
  147. void init_buffer(struct buffer_head *, bh_end_io_t *, void *);
  148. void set_bh_page(struct buffer_head *bh,
  149.         struct page *page, unsigned long offset);
  150. int try_to_free_buffers(struct page *);
  151. struct buffer_head *alloc_page_buffers(struct page *page, unsigned long size,
  152.         int retry);
  153. void create_empty_buffers(struct page *, unsigned long,
  154.             unsigned long b_state);
  155. void end_buffer_read_sync(struct buffer_head *bh, int uptodate);
  156. void end_buffer_write_sync(struct buffer_head *bh, int uptodate);
  157.  
  158. /* Things to do with buffers at mapping->private_list */
  159. void mark_buffer_dirty_inode(struct buffer_head *bh, struct inode *inode);
  160. int inode_has_buffers(struct inode *);
  161. void invalidate_inode_buffers(struct inode *);
  162. int remove_inode_buffers(struct inode *inode);
  163. int sync_mapping_buffers(struct address_space *mapping);
  164. void unmap_underlying_metadata(struct block_device *bdev, sector_t block);
  165.  
  166. void mark_buffer_async_write(struct buffer_head *bh);
  167. void invalidate_bdev(struct block_device *);
  168. int sync_blockdev(struct block_device *bdev);
  169. void __wait_on_buffer(struct buffer_head *);
  170. wait_queue_head_t *bh_waitq_head(struct buffer_head *bh);
  171. int fsync_bdev(struct block_device *);
  172. struct super_block *freeze_bdev(struct block_device *);
  173. void thaw_bdev(struct block_device *, struct super_block *);
  174. int fsync_super(struct super_block *);
  175. int fsync_no_super(struct block_device *);
  176. struct buffer_head *__find_get_block(struct block_device *bdev, sector_t block,
  177.             unsigned size);
  178. struct buffer_head *__getblk(struct block_device *bdev, sector_t block,
  179.             unsigned size);
  180. void __brelse(struct buffer_head *);
  181. void __bforget(struct buffer_head *);
  182. void __breadahead(struct block_device *, sector_t block, unsigned int size);
  183. struct buffer_head *__bread(struct block_device *, sector_t block, unsigned size);
  184. void invalidate_bh_lrus(void);
  185. struct buffer_head *alloc_buffer_head(gfp_t gfp_flags);
  186. void free_buffer_head(struct buffer_head * bh);
  187. void unlock_buffer(struct buffer_head *bh);
  188. void __lock_buffer(struct buffer_head *bh);
  189. void ll_rw_block(int, int, struct buffer_head * bh[]);
  190. int sync_dirty_buffer(struct buffer_head *bh);
  191. int submit_bh(int, struct buffer_head *);
  192. void write_boundary_block(struct block_device *bdev,
  193.             sector_t bblock, unsigned blocksize);
  194. int bh_uptodate_or_lock(struct buffer_head *bh);
  195. int bh_submit_read(struct buffer_head *bh);
  196.  
  197. extern int buffer_heads_over_limit;
  198.  
  199. /*
  200.  * Generic address_space_operations implementations for buffer_head-backed
  201.  * address_spaces.
  202.  */
  203. void block_invalidatepage(struct page *page, unsigned long offset);
  204. int block_write_full_page(struct page *page, get_block_t *get_block,
  205.                 struct writeback_control *wbc);
  206. int block_read_full_page(struct page*, get_block_t*);
  207. int block_is_partially_uptodate(struct page *page, read_descriptor_t *desc,
  208.                 unsigned long from);
  209. int block_write_begin(struct file *, struct address_space *,
  210.                 loff_t, unsigned, unsigned,
  211.                 struct page **, void **, get_block_t*);
  212. int block_write_end(struct file *, struct address_space *,
  213.                 loff_t, unsigned, unsigned,
  214.                 struct page *, void *);
  215. int generic_write_end(struct file *, struct address_space *,
  216.                 loff_t, unsigned, unsigned,
  217.                 struct page *, void *);
  218. void page_zero_new_buffers(struct page *page, unsigned from, unsigned to);
  219. int block_prepare_write(struct page*, unsigned, unsigned, get_block_t*);
  220. int cont_write_begin(struct file *, struct address_space *, loff_t,
  221.             unsigned, unsigned, struct page **, void **,
  222.             get_block_t *, loff_t *);
  223. int generic_cont_expand_simple(struct inode *inode, loff_t size);
  224. int block_commit_write(struct page *page, unsigned from, unsigned to);
  225. int block_page_mkwrite(struct vm_area_struct *vma, struct page *page,
  226.                 get_block_t get_block);
  227. void block_sync_page(struct page *);
  228. sector_t generic_block_bmap(struct address_space *, sector_t, get_block_t *);
  229. int block_truncate_page(struct address_space *, loff_t, get_block_t *);
  230. int file_fsync(struct file *, struct dentry *, int);
  231. int nobh_write_begin(struct file *, struct address_space *,
  232.                 loff_t, unsigned, unsigned,
  233.                 struct page **, void **, get_block_t*);
  234. int nobh_write_end(struct file *, struct address_space *,
  235.                 loff_t, unsigned, unsigned,
  236.                 struct page *, void *);
  237. int nobh_truncate_page(struct address_space *, loff_t, get_block_t *);
  238. int nobh_writepage(struct page *page, get_block_t *get_block,
  239.                         struct writeback_control *wbc);
  240.  
  241. void buffer_init(void);
  242.  
  243. /*
  244.  * inline definitions
  245.  */
  246.  
  247. static inline void attach_page_buffers(struct page *page,
  248.         struct buffer_head *head)
  249. {
  250.     page_cache_get(page);
  251.     SetPagePrivate(page);
  252.     set_page_private(page, (unsigned long)head);
  253. }
  254.  
  255. static inline void get_bh(struct buffer_head *bh)
  256. {
  257.         atomic_inc(&bh->b_count);
  258. }
  259.  
  260. static inline void put_bh(struct buffer_head *bh)
  261. {
  262.         smp_mb__before_atomic_dec();
  263.         atomic_dec(&bh->b_count);
  264. }
  265.  
  266. static inline void brelse(struct buffer_head *bh)
  267. {
  268.     if (bh)
  269.         __brelse(bh);
  270. }
  271.  
  272. static inline void bforget(struct buffer_head *bh)
  273. {
  274.     if (bh)
  275.         __bforget(bh);
  276. }
  277.  
  278. static inline struct buffer_head *
  279. sb_bread(struct super_block *sb, sector_t block)
  280. {
  281.     return __bread(sb->s_bdev, block, sb->s_blocksize);
  282. }
  283.  
  284. static inline void
  285. sb_breadahead(struct super_block *sb, sector_t block)
  286. {
  287.     __breadahead(sb->s_bdev, block, sb->s_blocksize);
  288. }
  289.  
  290. static inline struct buffer_head *
  291. sb_getblk(struct super_block *sb, sector_t block)
  292. {
  293.     return __getblk(sb->s_bdev, block, sb->s_blocksize);
  294. }
  295.  
  296. static inline struct buffer_head *
  297. sb_find_get_block(struct super_block *sb, sector_t block)
  298. {
  299.     return __find_get_block(sb->s_bdev, block, sb->s_blocksize);
  300. }
  301.  
  302. static inline void
  303. map_bh(struct buffer_head *bh, struct super_block *sb, sector_t block)
  304. {
  305.     set_buffer_mapped(bh);
  306.     bh->b_bdev = sb->s_bdev;
  307.     bh->b_blocknr = block;
  308.     bh->b_size = sb->s_blocksize;
  309. }
  310.  
  311. /*
  312.  * Calling wait_on_buffer() for a zero-ref buffer is illegal, so we call into
  313.  * __wait_on_buffer() just to trip a debug check.  Because debug code in inline
  314.  * functions is bloaty.
  315.  */
  316. static inline void wait_on_buffer(struct buffer_head *bh)
  317. {
  318.     might_sleep();
  319.     if (buffer_locked(bh) || atomic_read(&bh->b_count) == 0)
  320.         __wait_on_buffer(bh);
  321. }
  322.  
  323. static inline int trylock_buffer(struct buffer_head *bh)
  324. {
  325.     return likely(!test_and_set_bit_lock(BH_Lock, &bh->b_state));
  326. }
  327.  
  328. static inline void lock_buffer(struct buffer_head *bh)
  329. {
  330.     might_sleep();
  331.     if (!trylock_buffer(bh))
  332.         __lock_buffer(bh);
  333. }
  334.  
  335. extern int __set_page_dirty_buffers(struct page *page);
  336.  
  337. #else /* CONFIG_BLOCK */
  338.  
  339. static inline void buffer_init(void) {}
  340. static inline int try_to_free_buffers(struct page *page) { return 1; }
  341. static inline int sync_blockdev(struct block_device *bdev) { return 0; }
  342. static inline int inode_has_buffers(struct inode *inode) { return 0; }
  343. static inline void invalidate_inode_buffers(struct inode *inode) {}
  344. static inline int remove_inode_buffers(struct inode *inode) { return 1; }
  345. static inline int sync_mapping_buffers(struct address_space *mapping) { return 0; }
  346. static inline void invalidate_bdev(struct block_device *bdev) {}
  347.  
  348.  
  349. #endif /* CONFIG_BLOCK */
  350. #endif /* _LINUX_BUFFER_HEAD_H */
  351.