buffer_head.h 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326
  1. /*
  2. * include/linux/buffer_head.h
  3. *
  4. * Everything to do with buffer_heads.
  5. */
  6. #ifndef _LINUX_BUFFER_HEAD_H
  7. #define _LINUX_BUFFER_HEAD_H
  8. #include <linux/types.h>
  9. #include <linux/fs.h>
  10. #include <linux/linkage.h>
  11. #include <linux/pagemap.h>
  12. #include <linux/wait.h>
  13. #include <asm/atomic.h>
  14. #ifdef CONFIG_BLOCK
  15. enum bh_state_bits {
  16. BH_Uptodate, /* Contains valid data */
  17. BH_Dirty, /* Is dirty */
  18. BH_Lock, /* Is locked */
  19. BH_Req, /* Has been submitted for I/O */
  20. BH_Uptodate_Lock,/* Used by the first bh in a page, to serialise
  21. * IO completion of other buffers in the page
  22. */
  23. BH_Mapped, /* Has a disk mapping */
  24. BH_New, /* Disk mapping was newly created by get_block */
  25. BH_Async_Read, /* Is under end_buffer_async_read I/O */
  26. BH_Async_Write, /* Is under end_buffer_async_write I/O */
  27. BH_Delay, /* Buffer is not yet allocated on disk */
  28. BH_Boundary, /* Block is followed by a discontiguity */
  29. BH_Write_EIO, /* I/O error on write */
  30. BH_Ordered, /* ordered write */
  31. BH_Eopnotsupp, /* operation not supported (barrier) */
  32. BH_Unwritten, /* Buffer is allocated on disk but not written */
  33. BH_PrivateStart,/* not a state bit, but the first bit available
  34. * for private allocation by other entities
  35. */
  36. };
  37. #define MAX_BUF_PER_PAGE (PAGE_CACHE_SIZE / 512)
  38. struct page;
  39. struct buffer_head;
  40. struct address_space;
  41. typedef void (bh_end_io_t)(struct buffer_head *bh, int uptodate);
  42. /*
  43. * Historically, a buffer_head was used to map a single block
  44. * within a page, and of course as the unit of I/O through the
  45. * filesystem and block layers. Nowadays the basic I/O unit
  46. * is the bio, and buffer_heads are used for extracting block
  47. * mappings (via a get_block_t call), for tracking state within
  48. * a page (via a page_mapping) and for wrapping bio submission
  49. * for backward compatibility reasons (e.g. submit_bh).
  50. */
  51. struct buffer_head {
  52. unsigned long b_state; /* buffer state bitmap (see above) */
  53. struct buffer_head *b_this_page;/* circular list of page's buffers */
  54. struct page *b_page; /* the page this bh is mapped to */
  55. sector_t b_blocknr; /* start block number */
  56. size_t b_size; /* size of mapping */
  57. char *b_data; /* pointer to data within the page */
  58. struct block_device *b_bdev;
  59. bh_end_io_t *b_end_io; /* I/O completion */
  60. void *b_private; /* reserved for b_end_io */
  61. struct list_head b_assoc_buffers; /* associated with another mapping */
  62. struct address_space *b_assoc_map; /* mapping this buffer is
  63. associated with */
  64. atomic_t b_count; /* users using this buffer_head */
  65. };
  66. /*
  67. * macro tricks to expand the set_buffer_foo(), clear_buffer_foo()
  68. * and buffer_foo() functions.
  69. */
  70. #define BUFFER_FNS(bit, name) \
  71. static inline void set_buffer_##name(struct buffer_head *bh) \
  72. { \
  73. set_bit(BH_##bit, &(bh)->b_state); \
  74. } \
  75. static inline void clear_buffer_##name(struct buffer_head *bh) \
  76. { \
  77. clear_bit(BH_##bit, &(bh)->b_state); \
  78. } \
  79. static inline int buffer_##name(const struct buffer_head *bh) \
  80. { \
  81. return test_bit(BH_##bit, &(bh)->b_state); \
  82. }
  83. /*
  84. * test_set_buffer_foo() and test_clear_buffer_foo()
  85. */
  86. #define TAS_BUFFER_FNS(bit, name) \
  87. static inline int test_set_buffer_##name(struct buffer_head *bh) \
  88. { \
  89. return test_and_set_bit(BH_##bit, &(bh)->b_state); \
  90. } \
  91. static inline int test_clear_buffer_##name(struct buffer_head *bh) \
  92. { \
  93. return test_and_clear_bit(BH_##bit, &(bh)->b_state); \
  94. } \
  95. /*
  96. * Emit the buffer bitops functions. Note that there are also functions
  97. * of the form "mark_buffer_foo()". These are higher-level functions which
  98. * do something in addition to setting a b_state bit.
  99. */
  100. BUFFER_FNS(Uptodate, uptodate)
  101. BUFFER_FNS(Dirty, dirty)
  102. TAS_BUFFER_FNS(Dirty, dirty)
  103. BUFFER_FNS(Lock, locked)
  104. TAS_BUFFER_FNS(Lock, locked)
  105. BUFFER_FNS(Req, req)
  106. TAS_BUFFER_FNS(Req, req)
  107. BUFFER_FNS(Mapped, mapped)
  108. BUFFER_FNS(New, new)
  109. BUFFER_FNS(Async_Read, async_read)
  110. BUFFER_FNS(Async_Write, async_write)
  111. BUFFER_FNS(Delay, delay)
  112. BUFFER_FNS(Boundary, boundary)
  113. BUFFER_FNS(Write_EIO, write_io_error)
  114. BUFFER_FNS(Ordered, ordered)
  115. BUFFER_FNS(Eopnotsupp, eopnotsupp)
  116. BUFFER_FNS(Unwritten, unwritten)
  117. #define bh_offset(bh) ((unsigned long)(bh)->b_data & ~PAGE_MASK)
  118. #define touch_buffer(bh) mark_page_accessed(bh->b_page)
  119. /* If we *know* page->private refers to buffer_heads */
  120. #define page_buffers(page) \
  121. ({ \
  122. BUG_ON(!PagePrivate(page)); \
  123. ((struct buffer_head *)page_private(page)); \
  124. })
  125. #define page_has_buffers(page) PagePrivate(page)
  126. /*
  127. * Declarations
  128. */
  129. void FASTCALL(mark_buffer_dirty(struct buffer_head *bh));
  130. void init_buffer(struct buffer_head *, bh_end_io_t *, void *);
  131. void set_bh_page(struct buffer_head *bh,
  132. struct page *page, unsigned long offset);
  133. int try_to_free_buffers(struct page *);
  134. struct buffer_head *alloc_page_buffers(struct page *page, unsigned long size,
  135. int retry);
  136. void create_empty_buffers(struct page *, unsigned long,
  137. unsigned long b_state);
  138. void end_buffer_read_sync(struct buffer_head *bh, int uptodate);
  139. void end_buffer_write_sync(struct buffer_head *bh, int uptodate);
  140. /* Things to do with buffers at mapping->private_list */
  141. void mark_buffer_dirty_inode(struct buffer_head *bh, struct inode *inode);
  142. int inode_has_buffers(struct inode *);
  143. void invalidate_inode_buffers(struct inode *);
  144. int remove_inode_buffers(struct inode *inode);
  145. int sync_mapping_buffers(struct address_space *mapping);
  146. void unmap_underlying_metadata(struct block_device *bdev, sector_t block);
  147. void mark_buffer_async_write(struct buffer_head *bh);
  148. void invalidate_bdev(struct block_device *, int);
  149. int sync_blockdev(struct block_device *bdev);
  150. void __wait_on_buffer(struct buffer_head *);
  151. wait_queue_head_t *bh_waitq_head(struct buffer_head *bh);
  152. int fsync_bdev(struct block_device *);
  153. struct super_block *freeze_bdev(struct block_device *);
  154. void thaw_bdev(struct block_device *, struct super_block *);
  155. int fsync_super(struct super_block *);
  156. int fsync_no_super(struct block_device *);
  157. struct buffer_head *__find_get_block(struct block_device *bdev, sector_t block,
  158. unsigned size);
  159. struct buffer_head *__getblk(struct block_device *bdev, sector_t block,
  160. unsigned size);
  161. void __brelse(struct buffer_head *);
  162. void __bforget(struct buffer_head *);
  163. void __breadahead(struct block_device *, sector_t block, unsigned int size);
  164. struct buffer_head *__bread(struct block_device *, sector_t block, unsigned size);
  165. struct buffer_head *alloc_buffer_head(gfp_t gfp_flags);
  166. void free_buffer_head(struct buffer_head * bh);
  167. void FASTCALL(unlock_buffer(struct buffer_head *bh));
  168. void FASTCALL(__lock_buffer(struct buffer_head *bh));
  169. void ll_rw_block(int, int, struct buffer_head * bh[]);
  170. int sync_dirty_buffer(struct buffer_head *bh);
  171. int submit_bh(int, struct buffer_head *);
  172. void write_boundary_block(struct block_device *bdev,
  173. sector_t bblock, unsigned blocksize);
  174. extern int buffer_heads_over_limit;
  175. /*
  176. * Generic address_space_operations implementations for buffer_head-backed
  177. * address_spaces.
  178. */
  179. void block_invalidatepage(struct page *page, unsigned long offset);
  180. int block_write_full_page(struct page *page, get_block_t *get_block,
  181. struct writeback_control *wbc);
  182. int block_read_full_page(struct page*, get_block_t*);
  183. int block_prepare_write(struct page*, unsigned, unsigned, get_block_t*);
  184. int cont_prepare_write(struct page*, unsigned, unsigned, get_block_t*,
  185. loff_t *);
  186. int generic_cont_expand(struct inode *inode, loff_t size);
  187. int generic_cont_expand_simple(struct inode *inode, loff_t size);
  188. int block_commit_write(struct page *page, unsigned from, unsigned to);
  189. void block_sync_page(struct page *);
  190. sector_t generic_block_bmap(struct address_space *, sector_t, get_block_t *);
  191. int generic_commit_write(struct file *, struct page *, unsigned, unsigned);
  192. int block_truncate_page(struct address_space *, loff_t, get_block_t *);
  193. int file_fsync(struct file *, struct dentry *, int);
  194. int nobh_prepare_write(struct page*, unsigned, unsigned, get_block_t*);
  195. int nobh_commit_write(struct file *, struct page *, unsigned, unsigned);
  196. int nobh_truncate_page(struct address_space *, loff_t);
  197. int nobh_writepage(struct page *page, get_block_t *get_block,
  198. struct writeback_control *wbc);
  199. void buffer_init(void);
  200. /*
  201. * inline definitions
  202. */
  203. static inline void attach_page_buffers(struct page *page,
  204. struct buffer_head *head)
  205. {
  206. page_cache_get(page);
  207. SetPagePrivate(page);
  208. set_page_private(page, (unsigned long)head);
  209. }
  210. static inline void get_bh(struct buffer_head *bh)
  211. {
  212. atomic_inc(&bh->b_count);
  213. }
  214. static inline void put_bh(struct buffer_head *bh)
  215. {
  216. smp_mb__before_atomic_dec();
  217. atomic_dec(&bh->b_count);
  218. }
  219. static inline void brelse(struct buffer_head *bh)
  220. {
  221. if (bh)
  222. __brelse(bh);
  223. }
  224. static inline void bforget(struct buffer_head *bh)
  225. {
  226. if (bh)
  227. __bforget(bh);
  228. }
  229. static inline struct buffer_head *
  230. sb_bread(struct super_block *sb, sector_t block)
  231. {
  232. return __bread(sb->s_bdev, block, sb->s_blocksize);
  233. }
  234. static inline void
  235. sb_breadahead(struct super_block *sb, sector_t block)
  236. {
  237. __breadahead(sb->s_bdev, block, sb->s_blocksize);
  238. }
  239. static inline struct buffer_head *
  240. sb_getblk(struct super_block *sb, sector_t block)
  241. {
  242. return __getblk(sb->s_bdev, block, sb->s_blocksize);
  243. }
  244. static inline struct buffer_head *
  245. sb_find_get_block(struct super_block *sb, sector_t block)
  246. {
  247. return __find_get_block(sb->s_bdev, block, sb->s_blocksize);
  248. }
  249. static inline void
  250. map_bh(struct buffer_head *bh, struct super_block *sb, sector_t block)
  251. {
  252. set_buffer_mapped(bh);
  253. bh->b_bdev = sb->s_bdev;
  254. bh->b_blocknr = block;
  255. bh->b_size = sb->s_blocksize;
  256. }
  257. /*
  258. * Calling wait_on_buffer() for a zero-ref buffer is illegal, so we call into
  259. * __wait_on_buffer() just to trip a debug check. Because debug code in inline
  260. * functions is bloaty.
  261. */
  262. static inline void wait_on_buffer(struct buffer_head *bh)
  263. {
  264. might_sleep();
  265. if (buffer_locked(bh) || atomic_read(&bh->b_count) == 0)
  266. __wait_on_buffer(bh);
  267. }
  268. static inline void lock_buffer(struct buffer_head *bh)
  269. {
  270. might_sleep();
  271. if (test_set_buffer_locked(bh))
  272. __lock_buffer(bh);
  273. }
  274. extern int __set_page_dirty_buffers(struct page *page);
  275. #else /* CONFIG_BLOCK */
  276. static inline void buffer_init(void) {}
  277. static inline int try_to_free_buffers(struct page *page) { return 1; }
  278. static inline int sync_blockdev(struct block_device *bdev) { return 0; }
  279. static inline int inode_has_buffers(struct inode *inode) { return 0; }
  280. static inline void invalidate_inode_buffers(struct inode *inode) {}
  281. static inline int remove_inode_buffers(struct inode *inode) { return 1; }
  282. static inline int sync_mapping_buffers(struct address_space *mapping) { return 0; }
  283. static inline void invalidate_bdev(struct block_device *bdev, int destroy_dirty_buffers) {}
  284. #endif /* CONFIG_BLOCK */
  285. #endif /* _LINUX_BUFFER_HEAD_H */