1b2441318SGreg Kroah-Hartman /* SPDX-License-Identifier: GPL-2.0 */
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds * include/linux/buffer_head.h
41da177e4SLinus Torvalds *
51da177e4SLinus Torvalds * Everything to do with buffer_heads.
61da177e4SLinus Torvalds */
71da177e4SLinus Torvalds
81da177e4SLinus Torvalds #ifndef _LINUX_BUFFER_HEAD_H
91da177e4SLinus Torvalds #define _LINUX_BUFFER_HEAD_H
101da177e4SLinus Torvalds
111da177e4SLinus Torvalds #include <linux/types.h>
123ae72869SBart Van Assche #include <linux/blk_types.h>
131da177e4SLinus Torvalds #include <linux/fs.h>
141da177e4SLinus Torvalds #include <linux/linkage.h>
151da177e4SLinus Torvalds #include <linux/pagemap.h>
161da177e4SLinus Torvalds #include <linux/wait.h>
1760063497SArun Sharma #include <linux/atomic.h>
181da177e4SLinus Torvalds
199361401eSDavid Howells enum bh_state_bits {
209361401eSDavid Howells BH_Uptodate, /* Contains valid data */
211da177e4SLinus Torvalds BH_Dirty, /* Is dirty */
221da177e4SLinus Torvalds BH_Lock, /* Is locked */
231da177e4SLinus Torvalds BH_Req, /* Has been submitted for I/O */
241da177e4SLinus Torvalds
251da177e4SLinus Torvalds BH_Mapped, /* Has a disk mapping */
261da177e4SLinus Torvalds BH_New, /* Disk mapping was newly created by get_block */
271da177e4SLinus Torvalds BH_Async_Read, /* Is under end_buffer_async_read I/O */
281da177e4SLinus Torvalds BH_Async_Write, /* Is under end_buffer_async_write I/O */
291da177e4SLinus Torvalds BH_Delay, /* Buffer is not yet allocated on disk */
301da177e4SLinus Torvalds BH_Boundary, /* Block is followed by a discontiguity */
311da177e4SLinus Torvalds BH_Write_EIO, /* I/O error on write */
321da177e4SLinus Torvalds BH_Unwritten, /* Buffer is allocated on disk but not written */
331da177e4SLinus Torvalds BH_Quiet, /* Buffer Error Prinks to be quiet */
3433a266ddSDavid Chinner BH_Meta, /* Buffer contains metadata */
3508bafc03SKeith Mannthey BH_Prio, /* Buffer should be submitted with REQ_PRIO */
36877f962cSTheodore Ts'o BH_Defer_Completion, /* Defer AIO completion to workqueue */
37877f962cSTheodore Ts'o
387b7a8665SChristoph Hellwig BH_PrivateStart,/* not a state bit, but the first bit available
391da177e4SLinus Torvalds * for private allocation by other entities
401da177e4SLinus Torvalds */
411da177e4SLinus Torvalds };
421da177e4SLinus Torvalds
431da177e4SLinus Torvalds #define MAX_BUF_PER_PAGE (PAGE_SIZE / 512)
441da177e4SLinus Torvalds
4509cbfeafSKirill A. Shutemov struct page;
461da177e4SLinus Torvalds struct buffer_head;
471da177e4SLinus Torvalds struct address_space;
481da177e4SLinus Torvalds typedef void (bh_end_io_t)(struct buffer_head *bh, int uptodate);
491da177e4SLinus Torvalds
501da177e4SLinus Torvalds /*
511da177e4SLinus Torvalds * Historically, a buffer_head was used to map a single block
521da177e4SLinus Torvalds * within a page, and of course as the unit of I/O through the
53205f87f6SBadari Pulavarty * filesystem and block layers. Nowadays the basic I/O unit
54205f87f6SBadari Pulavarty * is the bio, and buffer_heads are used for extracting block
55205f87f6SBadari Pulavarty * mappings (via a get_block_t call), for tracking state within
56205f87f6SBadari Pulavarty * a page (via a page_mapping) and for wrapping bio submission
57205f87f6SBadari Pulavarty * for backward compatibility reasons (e.g. submit_bh).
58205f87f6SBadari Pulavarty */
59205f87f6SBadari Pulavarty struct buffer_head {
601da177e4SLinus Torvalds unsigned long b_state; /* buffer state bitmap (see above) */
611da177e4SLinus Torvalds struct buffer_head *b_this_page;/* circular list of page's buffers */
621da177e4SLinus Torvalds union {
631da177e4SLinus Torvalds struct page *b_page; /* the page this bh is mapped to */
64d685c668SMatthew Wilcox (Oracle) struct folio *b_folio; /* the folio this bh is mapped to */
651da177e4SLinus Torvalds };
66d685c668SMatthew Wilcox (Oracle)
67d685c668SMatthew Wilcox (Oracle) sector_t b_blocknr; /* start block number */
681da177e4SLinus Torvalds size_t b_size; /* size of mapping */
69205f87f6SBadari Pulavarty char *b_data; /* pointer to data within the page */
70205f87f6SBadari Pulavarty
71205f87f6SBadari Pulavarty struct block_device *b_bdev;
721da177e4SLinus Torvalds bh_end_io_t *b_end_io; /* I/O completion */
731da177e4SLinus Torvalds void *b_private; /* reserved for b_end_io */
741da177e4SLinus Torvalds struct list_head b_assoc_buffers; /* associated with another mapping */
751da177e4SLinus Torvalds struct address_space *b_assoc_map; /* mapping this buffer is
761da177e4SLinus Torvalds associated with */
7758ff407bSJan Kara atomic_t b_count; /* users using this buffer_head */
7858ff407bSJan Kara spinlock_t b_uptodate_lock; /* Used by the first bh in a page, to
79205f87f6SBadari Pulavarty * serialise IO completion of other
80f1e67e35SThomas Gleixner * buffers in the page */
81f1e67e35SThomas Gleixner };
82f1e67e35SThomas Gleixner
831da177e4SLinus Torvalds /*
841da177e4SLinus Torvalds * macro tricks to expand the set_buffer_foo(), clear_buffer_foo()
851da177e4SLinus Torvalds * and buffer_foo() functions.
861da177e4SLinus Torvalds * To avoid reset buffer flags that are already set, because that causes
871da177e4SLinus Torvalds * a costly cache line transition, check the flag first.
8860f91826SKemi Wang */
8960f91826SKemi Wang #define BUFFER_FNS(bit, name) \
901da177e4SLinus Torvalds static __always_inline void set_buffer_##name(struct buffer_head *bh) \
911da177e4SLinus Torvalds { \
92ee91ef61SDenys Vlasenko if (!test_bit(BH_##bit, &(bh)->b_state)) \
931da177e4SLinus Torvalds set_bit(BH_##bit, &(bh)->b_state); \
9460f91826SKemi Wang } \
951da177e4SLinus Torvalds static __always_inline void clear_buffer_##name(struct buffer_head *bh) \
961da177e4SLinus Torvalds { \
97ee91ef61SDenys Vlasenko clear_bit(BH_##bit, &(bh)->b_state); \
981da177e4SLinus Torvalds } \
991da177e4SLinus Torvalds static __always_inline int buffer_##name(const struct buffer_head *bh) \
1001da177e4SLinus Torvalds { \
101ee91ef61SDenys Vlasenko return test_bit(BH_##bit, &(bh)->b_state); \
1021da177e4SLinus Torvalds }
1031da177e4SLinus Torvalds
1041da177e4SLinus Torvalds /*
1051da177e4SLinus Torvalds * test_set_buffer_foo() and test_clear_buffer_foo()
1061da177e4SLinus Torvalds */
1071da177e4SLinus Torvalds #define TAS_BUFFER_FNS(bit, name) \
1081da177e4SLinus Torvalds static __always_inline int test_set_buffer_##name(struct buffer_head *bh) \
1091da177e4SLinus Torvalds { \
110ee91ef61SDenys Vlasenko return test_and_set_bit(BH_##bit, &(bh)->b_state); \
1111da177e4SLinus Torvalds } \
1121da177e4SLinus Torvalds static __always_inline int test_clear_buffer_##name(struct buffer_head *bh) \
1131da177e4SLinus Torvalds { \
114ee91ef61SDenys Vlasenko return test_and_clear_bit(BH_##bit, &(bh)->b_state); \
1151da177e4SLinus Torvalds } \
1161da177e4SLinus Torvalds
1171da177e4SLinus Torvalds /*
1181da177e4SLinus Torvalds * Emit the buffer bitops functions. Note that there are also functions
1191da177e4SLinus Torvalds * of the form "mark_buffer_foo()". These are higher-level functions which
1201da177e4SLinus Torvalds * do something in addition to setting a b_state bit.
1211da177e4SLinus Torvalds */
BUFFER_FNS(Dirty,dirty)1221da177e4SLinus Torvalds BUFFER_FNS(Dirty, dirty)
1231da177e4SLinus Torvalds TAS_BUFFER_FNS(Dirty, dirty)
1241da177e4SLinus Torvalds BUFFER_FNS(Lock, locked)
1251da177e4SLinus Torvalds BUFFER_FNS(Req, req)
1261da177e4SLinus Torvalds TAS_BUFFER_FNS(Req, req)
1271da177e4SLinus Torvalds BUFFER_FNS(Mapped, mapped)
1281da177e4SLinus Torvalds BUFFER_FNS(New, new)
1291da177e4SLinus Torvalds BUFFER_FNS(Async_Read, async_read)
1301da177e4SLinus Torvalds BUFFER_FNS(Async_Write, async_write)
1311da177e4SLinus Torvalds BUFFER_FNS(Delay, delay)
1321da177e4SLinus Torvalds BUFFER_FNS(Boundary, boundary)
1331da177e4SLinus Torvalds BUFFER_FNS(Write_EIO, write_io_error)
1341da177e4SLinus Torvalds BUFFER_FNS(Unwritten, unwritten)
1351da177e4SLinus Torvalds BUFFER_FNS(Meta, meta)
13633a266ddSDavid Chinner BUFFER_FNS(Prio, prio)
137877f962cSTheodore Ts'o BUFFER_FNS(Defer_Completion, defer_completion)
138877f962cSTheodore Ts'o
1397b7a8665SChristoph Hellwig static __always_inline void set_buffer_uptodate(struct buffer_head *bh)
1401da177e4SLinus Torvalds {
141d4252071SMikulas Patocka /*
142d4252071SMikulas Patocka * If somebody else already set this uptodate, they will
143d4252071SMikulas Patocka * have done the memory barrier, and a reader will thus
1442f79cdfeSLinus Torvalds * see *some* valid buffer state.
1452f79cdfeSLinus Torvalds *
1462f79cdfeSLinus Torvalds * Any other serialization (with IO errors or whatever that
1472f79cdfeSLinus Torvalds * might clear the bit) has to come from other state (eg BH_Lock).
1482f79cdfeSLinus Torvalds */
1492f79cdfeSLinus Torvalds if (test_bit(BH_Uptodate, &bh->b_state))
1502f79cdfeSLinus Torvalds return;
1512f79cdfeSLinus Torvalds
1522f79cdfeSLinus Torvalds /*
1532f79cdfeSLinus Torvalds * make it consistent with folio_mark_uptodate
1542f79cdfeSLinus Torvalds * pairs with smp_load_acquire in buffer_uptodate
155d4252071SMikulas Patocka */
156d4252071SMikulas Patocka smp_mb__before_atomic();
157d4252071SMikulas Patocka set_bit(BH_Uptodate, &bh->b_state);
158d4252071SMikulas Patocka }
159d4252071SMikulas Patocka
clear_buffer_uptodate(struct buffer_head * bh)160d4252071SMikulas Patocka static __always_inline void clear_buffer_uptodate(struct buffer_head *bh)
161d4252071SMikulas Patocka {
162d4252071SMikulas Patocka clear_bit(BH_Uptodate, &bh->b_state);
163d4252071SMikulas Patocka }
164d4252071SMikulas Patocka
buffer_uptodate(const struct buffer_head * bh)165d4252071SMikulas Patocka static __always_inline int buffer_uptodate(const struct buffer_head *bh)
166d4252071SMikulas Patocka {
167d4252071SMikulas Patocka /*
168d4252071SMikulas Patocka * make it consistent with folio_test_uptodate
169d4252071SMikulas Patocka * pairs with smp_mb__before_atomic in set_buffer_uptodate
170d4252071SMikulas Patocka */
171d4252071SMikulas Patocka return test_bit_acquire(BH_Uptodate, &bh->b_state);
172d4252071SMikulas Patocka }
1738238b457SMikulas Patocka
bh_offset(const struct buffer_head * bh)174d4252071SMikulas Patocka static inline unsigned long bh_offset(const struct buffer_head *bh)
175d4252071SMikulas Patocka {
176*f94cf220SMatthew Wilcox (Oracle) return (unsigned long)(bh)->b_data & (page_size(bh->b_page) - 1);
177*f94cf220SMatthew Wilcox (Oracle) }
178*f94cf220SMatthew Wilcox (Oracle)
179*f94cf220SMatthew Wilcox (Oracle) /* If we *know* page->private refers to buffer_heads */
1801da177e4SLinus Torvalds #define page_buffers(page) \
1811da177e4SLinus Torvalds ({ \
1821da177e4SLinus Torvalds BUG_ON(!PagePrivate(page)); \
1831da177e4SLinus Torvalds ((struct buffer_head *)page_private(page)); \
1841da177e4SLinus Torvalds })
1854c21e2f2SHugh Dickins #define page_has_buffers(page) PagePrivate(page)
1861da177e4SLinus Torvalds #define folio_buffers(folio) folio_get_private(folio)
1871da177e4SLinus Torvalds
188cd1067beSMatthew Wilcox (Oracle) void buffer_check_dirty_writeback(struct folio *folio,
1891da177e4SLinus Torvalds bool *dirty, bool *writeback);
190520f301cSMatthew Wilcox (Oracle)
191b4597226SMel Gorman /*
192b4597226SMel Gorman * Declarations
1931da177e4SLinus Torvalds */
1941da177e4SLinus Torvalds
1951da177e4SLinus Torvalds void mark_buffer_dirty(struct buffer_head *bh);
1961da177e4SLinus Torvalds void mark_buffer_write_io_error(struct buffer_head *bh);
197b3c97528SHarvey Harrison void touch_buffer(struct buffer_head *bh);
19887354e5dSJeff Layton void folio_set_bh(struct buffer_head *bh, struct folio *folio,
199f0059afdSTejun Heo unsigned long offset);
2001da177e4SLinus Torvalds struct buffer_head *folio_alloc_buffers(struct folio *folio, unsigned long size,
2011da177e4SLinus Torvalds bool retry);
202465e5e6aSPankaj Raghav struct buffer_head *alloc_page_buffers(struct page *page, unsigned long size,
203465e5e6aSPankaj Raghav bool retry);
20468189fefSMatthew Wilcox (Oracle) void create_empty_buffers(struct page *, unsigned long,
205c71124a8SPankaj Raghav unsigned long b_state);
206c71124a8SPankaj Raghav void folio_create_empty_buffers(struct folio *folio, unsigned long blocksize,
2071da177e4SLinus Torvalds unsigned long b_state);
208640ab98fSJens Axboe void end_buffer_read_sync(struct buffer_head *bh, int uptodate);
2091da177e4SLinus Torvalds void end_buffer_write_sync(struct buffer_head *bh, int uptodate);
2101da177e4SLinus Torvalds void end_buffer_async_write(struct buffer_head *bh, int uptodate);
2118e2e1756SPankaj Raghav
2128e2e1756SPankaj Raghav /* Things to do with buffers at mapping->private_list */
2131da177e4SLinus Torvalds void mark_buffer_dirty_inode(struct buffer_head *bh, struct inode *inode);
2141da177e4SLinus Torvalds int generic_buffers_fsync_noflush(struct file *file, loff_t start, loff_t end,
21535c80d5fSChris Mason bool datasync);
2161da177e4SLinus Torvalds int generic_buffers_fsync(struct file *file, loff_t start, loff_t end,
2171da177e4SLinus Torvalds bool datasync);
2181da177e4SLinus Torvalds void clean_bdev_aliases(struct block_device *bdev, sector_t block,
2191da177e4SLinus Torvalds sector_t len);
clean_bdev_bh_alias(struct buffer_head * bh)2201da177e4SLinus Torvalds static inline void clean_bdev_bh_alias(struct buffer_head *bh)
2211da177e4SLinus Torvalds {
2221da177e4SLinus Torvalds clean_bdev_aliases(bh->b_bdev, bh->b_blocknr, 1);
22331b2ebc0SRitesh Harjani (IBM) }
22431b2ebc0SRitesh Harjani (IBM)
22531b2ebc0SRitesh Harjani (IBM) void mark_buffer_async_write(struct buffer_head *bh);
22631b2ebc0SRitesh Harjani (IBM) void __wait_on_buffer(struct buffer_head *);
22729f3ad7dSJan Kara wait_queue_head_t *bh_waitq_head(struct buffer_head *bh);
22829f3ad7dSJan Kara struct buffer_head *__find_get_block(struct block_device *bdev, sector_t block,
229e64855c6SJan Kara unsigned size);
230e64855c6SJan Kara struct buffer_head *__getblk_gfp(struct block_device *bdev, sector_t block,
231e64855c6SJan Kara unsigned size, gfp_t gfp);
232e64855c6SJan Kara void __brelse(struct buffer_head *);
2331da177e4SLinus Torvalds void __bforget(struct buffer_head *);
2341da177e4SLinus Torvalds void __breadahead(struct block_device *, sector_t block, unsigned int size);
2351da177e4SLinus Torvalds struct buffer_head *__bread_gfp(struct block_device *,
2361da177e4SLinus Torvalds sector_t block, unsigned size, gfp_t gfp);
2373991d3bdSTomasz Kvarsin struct buffer_head *alloc_buffer_head(gfp_t gfp_flags);
2383991d3bdSTomasz Kvarsin void free_buffer_head(struct buffer_head * bh);
2393b5e6454SGioh Kim void unlock_buffer(struct buffer_head *bh);
2403b5e6454SGioh Kim void __lock_buffer(struct buffer_head *bh);
2411da177e4SLinus Torvalds int sync_dirty_buffer(struct buffer_head *bh);
2421da177e4SLinus Torvalds int __sync_dirty_buffer(struct buffer_head *bh, blk_opf_t op_flags);
2433991d3bdSTomasz Kvarsin void write_dirty_buffer(struct buffer_head *bh, blk_opf_t op_flags);
2443b5e6454SGioh Kim void submit_bh(blk_opf_t, struct buffer_head *);
2453b5e6454SGioh Kim void write_boundary_block(struct block_device *bdev,
246f9a14399SPeter Zijlstra sector_t bblock, unsigned blocksize);
247243418e3SMinchan Kim int bh_uptodate_or_lock(struct buffer_head *bh);
2488cc621d2SMinchan Kim int __bh_read(struct buffer_head *bh, blk_opf_t op_flags, bool wait);
249dd0fc66fSAl Viro void __bh_read_batch(int nr, struct buffer_head *bhs[],
2501da177e4SLinus Torvalds blk_opf_t op_flags, bool force_lock);
251b3c97528SHarvey Harrison
252b3c97528SHarvey Harrison /*
2531da177e4SLinus Torvalds * Generic address_space_operations implementations for buffer_head-backed
2543ae72869SBart Van Assche * address_spaces.
2553ae72869SBart Van Assche */
2565bdf402aSRitesh Harjani (IBM) void block_invalidate_folio(struct folio *folio, size_t offset, size_t length);
2571da177e4SLinus Torvalds int block_write_full_page(struct page *page, get_block_t *get_block,
2581da177e4SLinus Torvalds struct writeback_control *wbc);
259389d1b08SAneesh Kumar K.V int __block_write_full_folio(struct inode *inode, struct folio *folio,
260fdee117eSZhang Yi get_block_t *get_block, struct writeback_control *wbc,
261fdee117eSZhang Yi bh_end_io_t *handler);
262fdee117eSZhang Yi int block_read_full_folio(struct folio *, get_block_t *);
2631da177e4SLinus Torvalds bool block_is_partially_uptodate(struct folio *, size_t from, size_t count);
2641da177e4SLinus Torvalds int block_write_begin(struct address_space *mapping, loff_t pos, unsigned len,
2651da177e4SLinus Torvalds struct page **pagep, get_block_t *get_block);
2661da177e4SLinus Torvalds int __block_write_begin(struct page *page, loff_t pos, unsigned len,
2671da177e4SLinus Torvalds get_block_t *get_block);
2681da177e4SLinus Torvalds int block_write_end(struct file *, struct address_space *,
2691da177e4SLinus Torvalds loff_t, unsigned, unsigned,
2707ba13abbSMatthew Wilcox (Oracle) struct page *, void *);
2711da177e4SLinus Torvalds int generic_write_end(struct file *, struct address_space *,
2721da177e4SLinus Torvalds loff_t, unsigned, unsigned,
27353418a18SMatthew Wilcox (Oracle) struct page *, void *);
274b4bba389SBenjamin Marzinski void folio_zero_new_buffers(struct folio *folio, size_t from, size_t to);
275b4bba389SBenjamin Marzinski void clean_page_buffers(struct page *page);
2762c69e205SMatthew Wilcox (Oracle) int cont_write_begin(struct file *, struct address_space *, loff_t,
2772e7e80f7SMatthew Wilcox (Oracle) unsigned, struct page **, void **,
278155130a4SChristoph Hellwig get_block_t *, loff_t *);
279b3992d1eSMatthew Wilcox (Oracle) int generic_cont_expand_simple(struct inode *inode, loff_t size);
2806e1db88dSChristoph Hellwig void block_commit_write(struct page *page, unsigned int from, unsigned int to);
2816e1db88dSChristoph Hellwig int block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf,
282afddba49SNick Piggin get_block_t get_block);
283afddba49SNick Piggin sector_t generic_block_bmap(struct address_space *, sector_t, get_block_t *);
284afddba49SNick Piggin int block_truncate_page(struct address_space *, loff_t, get_block_t *);
285afddba49SNick Piggin
286afddba49SNick Piggin #ifdef CONFIG_MIGRATION
287afddba49SNick Piggin extern int buffer_migrate_folio(struct address_space *,
2884a9622f2SMatthew Wilcox (Oracle) struct folio *dst, struct folio *src, enum migrate_mode);
289f892760aSMatthew Wilcox extern int buffer_migrate_folio_norefs(struct address_space *,
29089e10787SNick Piggin struct folio *dst, struct folio *src, enum migrate_mode);
291be3bbbc5SMatthew Wilcox (Oracle) #else
29289e10787SNick Piggin #define buffer_migrate_folio NULL
29305eb0b51SOGAWA Hirofumi #define buffer_migrate_folio_norefs NULL
2941da177e4SLinus Torvalds #endif
295c2ec175cSNick Piggin
29654171690SDavid Chinner /*
29724da4fabSJan Kara * inline definitions
298401b25aaSSouptick Joarder */
29924da4fabSJan Kara
get_bh(struct buffer_head * bh)30024da4fabSJan Kara static inline void get_bh(struct buffer_head *bh)
30124da4fabSJan Kara {
3020911d004SJan Kara atomic_inc(&bh->b_count);
30324da4fabSJan Kara }
30424da4fabSJan Kara
put_bh(struct buffer_head * bh)30524da4fabSJan Kara static inline void put_bh(struct buffer_head *bh)
30624da4fabSJan Kara {
30724da4fabSJan Kara smp_mb__before_atomic();
30824da4fabSJan Kara atomic_dec(&bh->b_count);
3091da177e4SLinus Torvalds }
3101da177e4SLinus Torvalds
brelse(struct buffer_head * bh)3111da177e4SLinus Torvalds static inline void brelse(struct buffer_head *bh)
31267235182SMatthew Wilcox (Oracle) {
31367235182SMatthew Wilcox (Oracle) if (bh)
31467235182SMatthew Wilcox (Oracle) __brelse(bh);
31567235182SMatthew Wilcox (Oracle) }
31667235182SMatthew Wilcox (Oracle)
bforget(struct buffer_head * bh)31767235182SMatthew Wilcox (Oracle) static inline void bforget(struct buffer_head *bh)
31867235182SMatthew Wilcox (Oracle) {
31967235182SMatthew Wilcox (Oracle) if (bh)
32067235182SMatthew Wilcox (Oracle) __bforget(bh);
3211da177e4SLinus Torvalds }
322b6cd0b77SAdrian Bunk
3231da177e4SLinus Torvalds static inline struct buffer_head *
sb_bread(struct super_block * sb,sector_t block)3241da177e4SLinus Torvalds sb_bread(struct super_block *sb, sector_t block)
3251da177e4SLinus Torvalds {
3261da177e4SLinus Torvalds return __bread_gfp(sb->s_bdev, block, sb->s_blocksize, __GFP_MOVABLE);
3271da177e4SLinus Torvalds }
3281da177e4SLinus Torvalds
3291da177e4SLinus Torvalds static inline struct buffer_head *
sb_bread_unmovable(struct super_block * sb,sector_t block)3301da177e4SLinus Torvalds sb_bread_unmovable(struct super_block *sb, sector_t block)
3311da177e4SLinus Torvalds {
3321da177e4SLinus Torvalds return __bread_gfp(sb->s_bdev, block, sb->s_blocksize, 0);
3331da177e4SLinus Torvalds }
3341da177e4SLinus Torvalds
3354e857c58SPeter Zijlstra static inline void
sb_breadahead(struct super_block * sb,sector_t block)3361da177e4SLinus Torvalds sb_breadahead(struct super_block *sb, sector_t block)
3371da177e4SLinus Torvalds {
3381da177e4SLinus Torvalds __breadahead(sb->s_bdev, block, sb->s_blocksize);
3391da177e4SLinus Torvalds }
3401da177e4SLinus Torvalds
3411da177e4SLinus Torvalds static inline struct buffer_head *
sb_getblk(struct super_block * sb,sector_t block)3421da177e4SLinus Torvalds sb_getblk(struct super_block *sb, sector_t block)
3431da177e4SLinus Torvalds {
3441da177e4SLinus Torvalds return __getblk_gfp(sb->s_bdev, block, sb->s_blocksize, __GFP_MOVABLE);
3451da177e4SLinus Torvalds }
3461da177e4SLinus Torvalds
3471da177e4SLinus Torvalds
3481da177e4SLinus Torvalds static inline struct buffer_head *
sb_getblk_gfp(struct super_block * sb,sector_t block,gfp_t gfp)3491da177e4SLinus Torvalds sb_getblk_gfp(struct super_block *sb, sector_t block, gfp_t gfp)
3501da177e4SLinus Torvalds {
3511da177e4SLinus Torvalds return __getblk_gfp(sb->s_bdev, block, sb->s_blocksize, gfp);
3521da177e4SLinus Torvalds }
3531da177e4SLinus Torvalds
3543b5e6454SGioh Kim static inline struct buffer_head *
sb_find_get_block(struct super_block * sb,sector_t block)3553b5e6454SGioh Kim sb_find_get_block(struct super_block *sb, sector_t block)
3563b5e6454SGioh Kim {
3573b5e6454SGioh Kim return __find_get_block(sb->s_bdev, block, sb->s_blocksize);
3583b5e6454SGioh Kim }
3593b5e6454SGioh Kim
3603b5e6454SGioh Kim static inline void
map_bh(struct buffer_head * bh,struct super_block * sb,sector_t block)3611da177e4SLinus Torvalds map_bh(struct buffer_head *bh, struct super_block *sb, sector_t block)
3621da177e4SLinus Torvalds {
3631da177e4SLinus Torvalds set_buffer_mapped(bh);
3641da177e4SLinus Torvalds bh->b_bdev = sb->s_bdev;
3651da177e4SLinus Torvalds bh->b_blocknr = block;
3661da177e4SLinus Torvalds bh->b_size = sb->s_blocksize;
3671da177e4SLinus Torvalds }
3681da177e4SLinus Torvalds
wait_on_buffer(struct buffer_head * bh)3691da177e4SLinus Torvalds static inline void wait_on_buffer(struct buffer_head *bh)
3701da177e4SLinus Torvalds {
3711da177e4SLinus Torvalds might_sleep();
3723b5e6454SGioh Kim if (buffer_locked(bh))
3731da177e4SLinus Torvalds __wait_on_buffer(bh);
3741da177e4SLinus Torvalds }
375bd7ade3cSNikolay Borisov
trylock_buffer(struct buffer_head * bh)376bd7ade3cSNikolay Borisov static inline int trylock_buffer(struct buffer_head *bh)
377bd7ade3cSNikolay Borisov {
378bd7ade3cSNikolay Borisov return likely(!test_and_set_bit_lock(BH_Lock, &bh->b_state));
379bd7ade3cSNikolay Borisov }
380bd7ade3cSNikolay Borisov
lock_buffer(struct buffer_head * bh)381bd7ade3cSNikolay Borisov static inline void lock_buffer(struct buffer_head *bh)
3821da177e4SLinus Torvalds {
3831da177e4SLinus Torvalds might_sleep();
3841da177e4SLinus Torvalds if (!trylock_buffer(bh))
3851da177e4SLinus Torvalds __lock_buffer(bh);
3861da177e4SLinus Torvalds }
3871da177e4SLinus Torvalds
getblk_unmovable(struct block_device * bdev,sector_t block,unsigned size)3881da177e4SLinus Torvalds static inline struct buffer_head *getblk_unmovable(struct block_device *bdev,
3891da177e4SLinus Torvalds sector_t block,
3901da177e4SLinus Torvalds unsigned size)
3911da177e4SLinus Torvalds {
3921da177e4SLinus Torvalds return __getblk_gfp(bdev, block, size, 0);
3931da177e4SLinus Torvalds }
394b0cf2321SBadari Pulavarty
__getblk(struct block_device * bdev,sector_t block,unsigned size)3951da177e4SLinus Torvalds static inline struct buffer_head *__getblk(struct block_device *bdev,
3961da177e4SLinus Torvalds sector_t block,
3971da177e4SLinus Torvalds unsigned size)
3981da177e4SLinus Torvalds {
3991da177e4SLinus Torvalds return __getblk_gfp(bdev, block, size, __GFP_MOVABLE);
400a9877cc2SRichard Kennedy }
4011da177e4SLinus Torvalds
bh_readahead(struct buffer_head * bh,blk_opf_t op_flags)4021da177e4SLinus Torvalds static inline void bh_readahead(struct buffer_head *bh, blk_opf_t op_flags)
4031da177e4SLinus Torvalds {
404ca5de404SNick Piggin if (!buffer_uptodate(bh) && trylock_buffer(bh)) {
405ca5de404SNick Piggin if (!buffer_uptodate(bh))
40651b07fc3SNick Piggin __bh_read(bh, op_flags, false);
407ca5de404SNick Piggin else
408ca5de404SNick Piggin unlock_buffer(bh);
4091da177e4SLinus Torvalds }
4101da177e4SLinus Torvalds }
4111da177e4SLinus Torvalds
bh_read_nowait(struct buffer_head * bh,blk_opf_t op_flags)412ca5de404SNick Piggin static inline void bh_read_nowait(struct buffer_head *bh, blk_opf_t op_flags)
4131da177e4SLinus Torvalds {
4141da177e4SLinus Torvalds if (!bh_uptodate_or_lock(bh))
4151da177e4SLinus Torvalds __bh_read(bh, op_flags, false);
4163b5e6454SGioh Kim }
4173b5e6454SGioh Kim
4183b5e6454SGioh Kim /* Returns 1 if buffer uptodated, 0 on success, and -EIO on error. */
bh_read(struct buffer_head * bh,blk_opf_t op_flags)4193b5e6454SGioh Kim static inline int bh_read(struct buffer_head *bh, blk_opf_t op_flags)
4203b5e6454SGioh Kim {
4213b5e6454SGioh Kim if (bh_uptodate_or_lock(bh))
4223b5e6454SGioh Kim return 1;
4233b5e6454SGioh Kim return __bh_read(bh, op_flags, true);
4243b5e6454SGioh Kim }
4253b5e6454SGioh Kim
bh_read_batch(int nr,struct buffer_head * bhs[])4263b5e6454SGioh Kim static inline void bh_read_batch(int nr, struct buffer_head *bhs[])
4273b5e6454SGioh Kim {
4283b5e6454SGioh Kim __bh_read_batch(nr, bhs, 0, true);
4293b5e6454SGioh Kim }
430fdee117eSZhang Yi
bh_readahead_batch(int nr,struct buffer_head * bhs[],blk_opf_t op_flags)431fdee117eSZhang Yi static inline void bh_readahead_batch(int nr, struct buffer_head *bhs[],
432fdee117eSZhang Yi blk_opf_t op_flags)
433fdee117eSZhang Yi {
434fdee117eSZhang Yi __bh_read_batch(nr, bhs, op_flags, false);
435fdee117eSZhang Yi }
436fdee117eSZhang Yi
437fdee117eSZhang Yi /**
438fdee117eSZhang Yi * __bread() - reads a specified block and returns the bh
439fdee117eSZhang Yi * @bdev: the block_device to read from
440fdee117eSZhang Yi * @block: number of block
441fdee117eSZhang Yi * @size: size (in bytes) to read
442fdee117eSZhang Yi *
443fdee117eSZhang Yi * Reads a specified block, and returns buffer head that contains it.
444fdee117eSZhang Yi * The page cache is allocated from movable area so that it can be migrated.
445fdee117eSZhang Yi * It returns NULL if the block was unreadable.
446fdee117eSZhang Yi */
447fdee117eSZhang Yi static inline struct buffer_head *
__bread(struct block_device * bdev,sector_t block,unsigned size)448fdee117eSZhang Yi __bread(struct block_device *bdev, sector_t block, unsigned size)
449fdee117eSZhang Yi {
450fdee117eSZhang Yi return __bread_gfp(bdev, block, size, __GFP_MOVABLE);
451fdee117eSZhang Yi }
452fdee117eSZhang Yi
453fdee117eSZhang Yi bool block_dirty_folio(struct address_space *mapping, struct folio *folio);
454fdee117eSZhang Yi
455fdee117eSZhang Yi #ifdef CONFIG_BUFFER_HEAD
456fdee117eSZhang Yi
457fdee117eSZhang Yi void buffer_init(void);
458fdee117eSZhang Yi bool try_to_free_buffers(struct folio *folio);
459fdee117eSZhang Yi int inode_has_buffers(struct inode *inode);
460fdee117eSZhang Yi void invalidate_inode_buffers(struct inode *inode);
461fdee117eSZhang Yi int remove_inode_buffers(struct inode *inode);
462fdee117eSZhang Yi int sync_mapping_buffers(struct address_space *mapping);
463fdee117eSZhang Yi void invalidate_bh_lrus(void);
464fdee117eSZhang Yi void invalidate_bh_lrus_cpu(void);
4653b5e6454SGioh Kim bool has_bh_in_lru(int cpu, void *dummy);
4663b5e6454SGioh Kim extern int buffer_heads_over_limit;
4673b5e6454SGioh Kim
4683b5e6454SGioh Kim #else /* CONFIG_BUFFER_HEAD */
4693b5e6454SGioh Kim
buffer_init(void)4703b5e6454SGioh Kim static inline void buffer_init(void) {}
try_to_free_buffers(struct folio * folio)4713b5e6454SGioh Kim static inline bool try_to_free_buffers(struct folio *folio) { return true; }
inode_has_buffers(struct inode * inode)4723b5e6454SGioh Kim static inline int inode_has_buffers(struct inode *inode) { return 0; }
invalidate_inode_buffers(struct inode * inode)4733b5e6454SGioh Kim static inline void invalidate_inode_buffers(struct inode *inode) {}
remove_inode_buffers(struct inode * inode)4743b5e6454SGioh Kim static inline int remove_inode_buffers(struct inode *inode) { return 1; }
sync_mapping_buffers(struct address_space * mapping)4753b5e6454SGioh Kim static inline int sync_mapping_buffers(struct address_space *mapping) { return 0; }
invalidate_bh_lrus(void)4763b5e6454SGioh Kim static inline void invalidate_bh_lrus(void) {}
invalidate_bh_lrus_cpu(void)4773b5e6454SGioh Kim static inline void invalidate_bh_lrus_cpu(void) {}
has_bh_in_lru(int cpu,void * dummy)4783b5e6454SGioh Kim static inline bool has_bh_in_lru(int cpu, void *dummy) { return false; }
4793b5e6454SGioh Kim #define buffer_heads_over_limit 0
4803b5e6454SGioh Kim
481e621900aSMatthew Wilcox (Oracle) #endif /* CONFIG_BUFFER_HEAD */
4829361401eSDavid Howells #endif /* _LINUX_BUFFER_HEAD_H */
4839361401eSDavid Howells