1 /* SPDX-License-Identifier: GPL-2.0 */
3 * include/linux/buffer_head.h
5 * Everything to do with buffer_heads.
8 #ifndef _LINUX_BUFFER_HEAD_H
9 #define _LINUX_BUFFER_HEAD_H
11 #include <linux/types.h>
12 #include <linux/blk_types.h>
14 #include <linux/linkage.h>
15 #include <linux/pagemap.h>
16 #include <linux/wait.h>
17 #include <linux/atomic.h>
22 BH_Uptodate
, /* Contains valid data */
23 BH_Dirty
, /* Is dirty */
24 BH_Lock
, /* Is locked */
25 BH_Req
, /* Has been submitted for I/O */
27 BH_Mapped
, /* Has a disk mapping */
28 BH_New
, /* Disk mapping was newly created by get_block */
29 BH_Async_Read
, /* Is under end_buffer_async_read I/O */
30 BH_Async_Write
, /* Is under end_buffer_async_write I/O */
31 BH_Delay
, /* Buffer is not yet allocated on disk */
32 BH_Boundary
, /* Block is followed by a discontiguity */
33 BH_Write_EIO
, /* I/O error on write */
34 BH_Unwritten
, /* Buffer is allocated on disk but not written */
35 BH_Quiet
, /* Buffer Error Prinks to be quiet */
36 BH_Meta
, /* Buffer contains metadata */
37 BH_Prio
, /* Buffer should be submitted with REQ_PRIO */
38 BH_Defer_Completion
, /* Defer AIO completion to workqueue */
40 BH_PrivateStart
,/* not a state bit, but the first bit available
41 * for private allocation by other entities
45 #define MAX_BUF_PER_PAGE (PAGE_SIZE / 512)
50 typedef void (bh_end_io_t
)(struct buffer_head
*bh
, int uptodate
);
53 * Historically, a buffer_head was used to map a single block
54 * within a page, and of course as the unit of I/O through the
55 * filesystem and block layers. Nowadays the basic I/O unit
56 * is the bio, and buffer_heads are used for extracting block
57 * mappings (via a get_block_t call), for tracking state within
58 * a page (via a page_mapping) and for wrapping bio submission
59 * for backward compatibility reasons (e.g. submit_bh).
62 unsigned long b_state
; /* buffer state bitmap (see above) */
63 struct buffer_head
*b_this_page
;/* circular list of page's buffers */
64 struct page
*b_page
; /* the page this bh is mapped to */
66 sector_t b_blocknr
; /* start block number */
67 size_t b_size
; /* size of mapping */
68 char *b_data
; /* pointer to data within the page */
70 struct block_device
*b_bdev
;
71 bh_end_io_t
*b_end_io
; /* I/O completion */
72 void *b_private
; /* reserved for b_end_io */
73 struct list_head b_assoc_buffers
; /* associated with another mapping */
74 struct address_space
*b_assoc_map
; /* mapping this buffer is
76 atomic_t b_count
; /* users using this buffer_head */
77 spinlock_t b_uptodate_lock
; /* Used by the first bh in a page, to
78 * serialise IO completion of other
79 * buffers in the page */
83 * macro tricks to expand the set_buffer_foo(), clear_buffer_foo()
84 * and buffer_foo() functions.
85 * To avoid reset buffer flags that are already set, because that causes
86 * a costly cache line transition, check the flag first.
88 #define BUFFER_FNS(bit, name) \
89 static __always_inline void set_buffer_##name(struct buffer_head *bh) \
91 if (!test_bit(BH_##bit, &(bh)->b_state)) \
92 set_bit(BH_##bit, &(bh)->b_state); \
94 static __always_inline void clear_buffer_##name(struct buffer_head *bh) \
96 clear_bit(BH_##bit, &(bh)->b_state); \
98 static __always_inline int buffer_##name(const struct buffer_head *bh) \
100 return test_bit(BH_##bit, &(bh)->b_state); \
104 * test_set_buffer_foo() and test_clear_buffer_foo()
106 #define TAS_BUFFER_FNS(bit, name) \
107 static __always_inline int test_set_buffer_##name(struct buffer_head *bh) \
109 return test_and_set_bit(BH_##bit, &(bh)->b_state); \
111 static __always_inline int test_clear_buffer_##name(struct buffer_head *bh) \
113 return test_and_clear_bit(BH_##bit, &(bh)->b_state); \
117 * Emit the buffer bitops functions. Note that there are also functions
118 * of the form "mark_buffer_foo()". These are higher-level functions which
119 * do something in addition to setting a b_state bit.
121 BUFFER_FNS(Uptodate
, uptodate
)
122 BUFFER_FNS(Dirty
, dirty
)
123 TAS_BUFFER_FNS(Dirty
, dirty
)
124 BUFFER_FNS(Lock
, locked
)
126 TAS_BUFFER_FNS(Req
, req
)
127 BUFFER_FNS(Mapped
, mapped
)
129 BUFFER_FNS(Async_Read
, async_read
)
130 BUFFER_FNS(Async_Write
, async_write
)
131 BUFFER_FNS(Delay
, delay
)
132 BUFFER_FNS(Boundary
, boundary
)
133 BUFFER_FNS(Write_EIO
, write_io_error
)
134 BUFFER_FNS(Unwritten
, unwritten
)
135 BUFFER_FNS(Meta
, meta
)
136 BUFFER_FNS(Prio
, prio
)
137 BUFFER_FNS(Defer_Completion
, defer_completion
)
139 #define bh_offset(bh) ((unsigned long)(bh)->b_data & ~PAGE_MASK)
141 /* If we *know* page->private refers to buffer_heads */
142 #define page_buffers(page) \
144 BUG_ON(!PagePrivate(page)); \
145 ((struct buffer_head *)page_private(page)); \
147 #define page_has_buffers(page) PagePrivate(page)
148 #define folio_buffers(folio) folio_get_private(folio)
150 void buffer_check_dirty_writeback(struct folio
*folio
,
151 bool *dirty
, bool *writeback
);
157 void mark_buffer_dirty(struct buffer_head
*bh
);
158 void mark_buffer_write_io_error(struct buffer_head
*bh
);
159 void touch_buffer(struct buffer_head
*bh
);
160 void set_bh_page(struct buffer_head
*bh
,
161 struct page
*page
, unsigned long offset
);
162 bool try_to_free_buffers(struct folio
*);
163 struct buffer_head
*alloc_page_buffers(struct page
*page
, unsigned long size
,
165 void create_empty_buffers(struct page
*, unsigned long,
166 unsigned long b_state
);
167 void end_buffer_read_sync(struct buffer_head
*bh
, int uptodate
);
168 void end_buffer_write_sync(struct buffer_head
*bh
, int uptodate
);
169 void end_buffer_async_write(struct buffer_head
*bh
, int uptodate
);
171 /* Things to do with buffers at mapping->private_list */
172 void mark_buffer_dirty_inode(struct buffer_head
*bh
, struct inode
*inode
);
173 int inode_has_buffers(struct inode
*);
174 void invalidate_inode_buffers(struct inode
*);
175 int remove_inode_buffers(struct inode
*inode
);
176 int sync_mapping_buffers(struct address_space
*mapping
);
177 void clean_bdev_aliases(struct block_device
*bdev
, sector_t block
,
179 static inline void clean_bdev_bh_alias(struct buffer_head
*bh
)
181 clean_bdev_aliases(bh
->b_bdev
, bh
->b_blocknr
, 1);
184 void mark_buffer_async_write(struct buffer_head
*bh
);
185 void __wait_on_buffer(struct buffer_head
*);
186 wait_queue_head_t
*bh_waitq_head(struct buffer_head
*bh
);
187 struct buffer_head
*__find_get_block(struct block_device
*bdev
, sector_t block
,
189 struct buffer_head
*__getblk_gfp(struct block_device
*bdev
, sector_t block
,
190 unsigned size
, gfp_t gfp
);
191 void __brelse(struct buffer_head
*);
192 void __bforget(struct buffer_head
*);
193 void __breadahead(struct block_device
*, sector_t block
, unsigned int size
);
194 void __breadahead_gfp(struct block_device
*, sector_t block
, unsigned int size
,
196 struct buffer_head
*__bread_gfp(struct block_device
*,
197 sector_t block
, unsigned size
, gfp_t gfp
);
198 void invalidate_bh_lrus(void);
199 void invalidate_bh_lrus_cpu(void);
200 bool has_bh_in_lru(int cpu
, void *dummy
);
201 struct buffer_head
*alloc_buffer_head(gfp_t gfp_flags
);
202 void free_buffer_head(struct buffer_head
* bh
);
203 void unlock_buffer(struct buffer_head
*bh
);
204 void __lock_buffer(struct buffer_head
*bh
);
205 void ll_rw_block(blk_opf_t
, int, struct buffer_head
* bh
[]);
206 int sync_dirty_buffer(struct buffer_head
*bh
);
207 int __sync_dirty_buffer(struct buffer_head
*bh
, blk_opf_t op_flags
);
208 void write_dirty_buffer(struct buffer_head
*bh
, blk_opf_t op_flags
);
209 int submit_bh(blk_opf_t
, struct buffer_head
*);
210 void write_boundary_block(struct block_device
*bdev
,
211 sector_t bblock
, unsigned blocksize
);
212 int bh_uptodate_or_lock(struct buffer_head
*bh
);
213 int bh_submit_read(struct buffer_head
*bh
);
215 extern int buffer_heads_over_limit
;
218 * Generic address_space_operations implementations for buffer_head-backed
221 void block_invalidate_folio(struct folio
*folio
, size_t offset
, size_t length
);
222 int block_write_full_page(struct page
*page
, get_block_t
*get_block
,
223 struct writeback_control
*wbc
);
224 int __block_write_full_page(struct inode
*inode
, struct page
*page
,
225 get_block_t
*get_block
, struct writeback_control
*wbc
,
226 bh_end_io_t
*handler
);
227 int block_read_full_folio(struct folio
*, get_block_t
*);
228 bool block_is_partially_uptodate(struct folio
*, size_t from
, size_t count
);
229 int block_write_begin(struct address_space
*mapping
, loff_t pos
, unsigned len
,
230 struct page
**pagep
, get_block_t
*get_block
);
231 int __block_write_begin(struct page
*page
, loff_t pos
, unsigned len
,
232 get_block_t
*get_block
);
233 int block_write_end(struct file
*, struct address_space
*,
234 loff_t
, unsigned, unsigned,
235 struct page
*, void *);
236 int generic_write_end(struct file
*, struct address_space
*,
237 loff_t
, unsigned, unsigned,
238 struct page
*, void *);
239 void page_zero_new_buffers(struct page
*page
, unsigned from
, unsigned to
);
240 void clean_page_buffers(struct page
*page
);
241 int cont_write_begin(struct file
*, struct address_space
*, loff_t
,
242 unsigned, struct page
**, void **,
243 get_block_t
*, loff_t
*);
244 int generic_cont_expand_simple(struct inode
*inode
, loff_t size
);
245 int block_commit_write(struct page
*page
, unsigned from
, unsigned to
);
246 int block_page_mkwrite(struct vm_area_struct
*vma
, struct vm_fault
*vmf
,
247 get_block_t get_block
);
248 /* Convert errno to return value from ->page_mkwrite() call */
249 static inline vm_fault_t
block_page_mkwrite_return(int err
)
252 return VM_FAULT_LOCKED
;
253 if (err
== -EFAULT
|| err
== -EAGAIN
)
254 return VM_FAULT_NOPAGE
;
257 /* -ENOSPC, -EDQUOT, -EIO ... */
258 return VM_FAULT_SIGBUS
;
260 sector_t
generic_block_bmap(struct address_space
*, sector_t
, get_block_t
*);
261 int block_truncate_page(struct address_space
*, loff_t
, get_block_t
*);
263 #ifdef CONFIG_MIGRATION
264 extern int buffer_migrate_folio(struct address_space
*,
265 struct folio
*dst
, struct folio
*src
, enum migrate_mode
);
266 extern int buffer_migrate_folio_norefs(struct address_space
*,
267 struct folio
*dst
, struct folio
*src
, enum migrate_mode
);
269 #define buffer_migrate_folio NULL
270 #define buffer_migrate_folio_norefs NULL
273 void buffer_init(void);
279 static inline void get_bh(struct buffer_head
*bh
)
281 atomic_inc(&bh
->b_count
);
284 static inline void put_bh(struct buffer_head
*bh
)
286 smp_mb__before_atomic();
287 atomic_dec(&bh
->b_count
);
290 static inline void brelse(struct buffer_head
*bh
)
296 static inline void bforget(struct buffer_head
*bh
)
302 static inline struct buffer_head
*
303 sb_bread(struct super_block
*sb
, sector_t block
)
305 return __bread_gfp(sb
->s_bdev
, block
, sb
->s_blocksize
, __GFP_MOVABLE
);
308 static inline struct buffer_head
*
309 sb_bread_unmovable(struct super_block
*sb
, sector_t block
)
311 return __bread_gfp(sb
->s_bdev
, block
, sb
->s_blocksize
, 0);
315 sb_breadahead(struct super_block
*sb
, sector_t block
)
317 __breadahead(sb
->s_bdev
, block
, sb
->s_blocksize
);
321 sb_breadahead_unmovable(struct super_block
*sb
, sector_t block
)
323 __breadahead_gfp(sb
->s_bdev
, block
, sb
->s_blocksize
, 0);
326 static inline struct buffer_head
*
327 sb_getblk(struct super_block
*sb
, sector_t block
)
329 return __getblk_gfp(sb
->s_bdev
, block
, sb
->s_blocksize
, __GFP_MOVABLE
);
333 static inline struct buffer_head
*
334 sb_getblk_gfp(struct super_block
*sb
, sector_t block
, gfp_t gfp
)
336 return __getblk_gfp(sb
->s_bdev
, block
, sb
->s_blocksize
, gfp
);
339 static inline struct buffer_head
*
340 sb_find_get_block(struct super_block
*sb
, sector_t block
)
342 return __find_get_block(sb
->s_bdev
, block
, sb
->s_blocksize
);
346 map_bh(struct buffer_head
*bh
, struct super_block
*sb
, sector_t block
)
348 set_buffer_mapped(bh
);
349 bh
->b_bdev
= sb
->s_bdev
;
350 bh
->b_blocknr
= block
;
351 bh
->b_size
= sb
->s_blocksize
;
354 static inline void wait_on_buffer(struct buffer_head
*bh
)
357 if (buffer_locked(bh
))
358 __wait_on_buffer(bh
);
361 static inline int trylock_buffer(struct buffer_head
*bh
)
363 return likely(!test_and_set_bit_lock(BH_Lock
, &bh
->b_state
));
366 static inline void lock_buffer(struct buffer_head
*bh
)
369 if (!trylock_buffer(bh
))
373 static inline struct buffer_head
*getblk_unmovable(struct block_device
*bdev
,
377 return __getblk_gfp(bdev
, block
, size
, 0);
380 static inline struct buffer_head
*__getblk(struct block_device
*bdev
,
384 return __getblk_gfp(bdev
, block
, size
, __GFP_MOVABLE
);
388 * __bread() - reads a specified block and returns the bh
389 * @bdev: the block_device to read from
390 * @block: number of block
391 * @size: size (in bytes) to read
393 * Reads a specified block, and returns buffer head that contains it.
394 * The page cache is allocated from movable area so that it can be migrated.
395 * It returns NULL if the block was unreadable.
397 static inline struct buffer_head
*
398 __bread(struct block_device
*bdev
, sector_t block
, unsigned size
)
400 return __bread_gfp(bdev
, block
, size
, __GFP_MOVABLE
);
403 bool block_dirty_folio(struct address_space
*mapping
, struct folio
*folio
);
405 #else /* CONFIG_BLOCK */
407 static inline void buffer_init(void) {}
408 static inline bool try_to_free_buffers(struct folio
*folio
) { return true; }
409 static inline int inode_has_buffers(struct inode
*inode
) { return 0; }
410 static inline void invalidate_inode_buffers(struct inode
*inode
) {}
411 static inline int remove_inode_buffers(struct inode
*inode
) { return 1; }
412 static inline int sync_mapping_buffers(struct address_space
*mapping
) { return 0; }
413 static inline void invalidate_bh_lrus_cpu(void) {}
414 static inline bool has_bh_in_lru(int cpu
, void *dummy
) { return false; }
415 #define buffer_heads_over_limit 0
417 #endif /* CONFIG_BLOCK */
418 #endif /* _LINUX_BUFFER_HEAD_H */