Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
C
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537/* SPDX-License-Identifier: GPL-2.0 *//* * include/linux/buffer_head.h * * Everything to do with buffer_heads. */
#ifndef _LINUX_BUFFER_HEAD_H#define _LINUX_BUFFER_HEAD_H
#include <linux/types.h>#include <linux/blk_types.h>#include <linux/fs.h>#include <linux/linkage.h>#include <linux/pagemap.h>#include <linux/wait.h>#include <linux/atomic.h>
enum bh_state_bits { BH_Uptodate, /* Contains valid data */ BH_Dirty, /* Is dirty */ BH_Lock, /* Is locked */ BH_Req, /* Has been submitted for I/O */
BH_Mapped, /* Has a disk mapping */ BH_New, /* Disk mapping was newly created by get_block */ BH_Async_Read, /* Is under end_buffer_async_read I/O */ BH_Async_Write, /* Is under end_buffer_async_write I/O */ BH_Delay, /* Buffer is not yet allocated on disk */ BH_Boundary, /* Block is followed by a discontiguity */ BH_Write_EIO, /* I/O error on write */ BH_Unwritten, /* Buffer is allocated on disk but not written */ BH_Quiet, /* Buffer Error Prinks to be quiet */ BH_Meta, /* Buffer contains metadata */ BH_Prio, /* Buffer should be submitted with REQ_PRIO */ BH_Defer_Completion, /* Defer AIO completion to workqueue */ BH_Migrate, /* Buffer is being migrated (norefs) */
BH_PrivateStart,/* not a state bit, but the first bit available * for private allocation by other entities */};
#define MAX_BUF_PER_PAGE (PAGE_SIZE / 512)
struct page;struct buffer_head;struct address_space;
/* * Historically, a buffer_head was used to map a single block * within a page, and of course as the unit of I/O through the * filesystem and block layers. Nowadays the basic I/O unit * is the bio, and buffer_heads are used for extracting block * mappings (via a get_block_t call), for tracking state within * a folio (via a folio_mapping) and for wrapping bio submission * for backward compatibility reasons (e.g. bh_submit). */struct buffer_head { unsigned long b_state; /* buffer state bitmap (see above) */ struct buffer_head *b_this_page;/* circular list of page's buffers */ union { struct page *b_page; /* the page this bh is mapped to */ struct folio *b_folio; /* the folio this bh is mapped to */ };
sector_t b_blocknr; /* start block number */ size_t b_size; /* size of mapping */ char *b_data; /* pointer to data within the page */
struct block_device *b_bdev; void *b_private; /* reserved for bio_end_io */ struct list_head b_assoc_buffers; /* associated with another mapping */ struct mapping_metadata_bhs *b_mmb; /* head of the list of metadata bhs * this buffer is associated with */ atomic_t b_count; /* users using this buffer_head */ spinlock_t b_uptodate_lock; /* Used by the first bh in a page, to * serialise IO completion of other * buffers in the page */};
/* * macro tricks to expand the set_buffer_foo(), clear_buffer_foo() * and buffer_foo() functions. * To avoid reset buffer flags that are already set, because that causes * a costly cache line transition, check the flag first. */#define BUFFER_FNS(bit, name) \static __always_inline void set_buffer_##name(struct buffer_head *bh) \{ \ if (!test_bit(BH_##bit, &(bh)->b_state)) \ set_bit(BH_##bit, &(bh)->b_state); \} \static __always_inline void clear_buffer_##name(struct buffer_head *bh) \{ \ clear_bit(BH_##bit, &(bh)->b_state); \} \static __always_inline int buffer_##name(const struct buffer_head *bh) \{ \ return test_bit(BH_##bit, &(bh)->b_state); \}
/* * test_set_buffer_foo() and test_clear_buffer_foo() */#define TAS_BUFFER_FNS(bit, name) \static __always_inline int test_set_buffer_##name(struct buffer_head *bh) \{ \ return test_and_set_bit(BH_##bit, &(bh)->b_state); \} \static __always_inline int test_clear_buffer_##name(struct buffer_head *bh) \{ \ return test_and_clear_bit(BH_##bit, &(bh)->b_state); \} \
/* * Emit the buffer bitops functions. Note that there are also functions * of the form "mark_buffer_foo()". These are higher-level functions which * do something in addition to setting a b_state bit. */BUFFER_FNS(Dirty, dirty)TAS_BUFFER_FNS(Dirty, dirty)BUFFER_FNS(Lock, locked)BUFFER_FNS(Req, req)TAS_BUFFER_FNS(Req, req)BUFFER_FNS(Mapped, mapped)BUFFER_FNS(New, new)BUFFER_FNS(Async_Read, async_read)BUFFER_FNS(Async_Write, async_write)BUFFER_FNS(Delay, delay)BUFFER_FNS(Boundary, boundary)BUFFER_FNS(Write_EIO, write_io_error)BUFFER_FNS(Unwritten, unwritten)BUFFER_FNS(Meta, meta)BUFFER_FNS(Prio, prio)BUFFER_FNS(Defer_Completion, defer_completion)
static __always_inline void set_buffer_uptodate(struct buffer_head *bh){ /* * If somebody else already set this uptodate, they will * have done the memory barrier, and a reader will thus * see *some* valid buffer state. * * Any other serialization (with IO errors or whatever that * might clear the bit) has to come from other state (eg BH_Lock). */ if (test_bit(BH_Uptodate, &bh->b_state)) return;
/* * make it consistent with folio_mark_uptodate * pairs with smp_load_acquire in buffer_uptodate */ smp_mb__before_atomic(); set_bit(BH_Uptodate, &bh->b_state);}
static __always_inline void clear_buffer_uptodate(struct buffer_head *bh){ clear_bit(BH_Uptodate, &bh->b_state);}
static __always_inline int buffer_uptodate(const struct buffer_head *bh){ /* * make it consistent with folio_test_uptodate * pairs with smp_mb__before_atomic in set_buffer_uptodate */ return test_bit_acquire(BH_Uptodate, &bh->b_state);}
static inline unsigned long bh_offset(const struct buffer_head *bh){ return (unsigned long)(bh)->b_data & (page_size(bh->b_page) - 1);}
/* If we *know* page->private refers to buffer_heads */#define page_buffers(page) \ ({ \ BUG_ON(!PagePrivate(page)); \ ((struct buffer_head *)page_private(page)); \ })#define folio_buffers(folio) folio_get_private(folio)
void buffer_check_dirty_writeback(struct folio *folio, bool *dirty, bool *writeback);
/* * Declarations */
void mark_buffer_dirty(struct buffer_head *bh);void mark_buffer_write_io_error(struct buffer_head *bh);void touch_buffer(struct buffer_head *bh);void folio_set_bh(struct buffer_head *bh, struct folio *folio, unsigned long offset);struct buffer_head *folio_alloc_buffers(struct folio *folio, unsigned long size, gfp_t gfp);struct buffer_head *alloc_page_buffers(struct page *page, unsigned long size);struct buffer_head *create_empty_buffers(struct folio *folio, unsigned long blocksize, unsigned long b_state);void end_buffer_read_sync(struct buffer_head *bh, int uptodate);bool bio_endio_bh(struct bio *bio, struct buffer_head **bhp);
/* Completion routines suitable for passing to bh_submit() */void bh_end_read(struct bio *bio);void bh_end_write(struct bio *bio);void bh_end_async_write(struct bio *bio);
/* Things to do with metadata buffers list */void mmb_mark_buffer_dirty(struct buffer_head *bh, struct mapping_metadata_bhs *mmb);void clean_bdev_aliases(struct block_device *bdev, sector_t block, sector_t len);static inline void clean_bdev_bh_alias(struct buffer_head *bh){ clean_bdev_aliases(bh->b_bdev, bh->b_blocknr, 1);}
void __wait_on_buffer(struct buffer_head *);wait_queue_head_t *bh_waitq_head(struct buffer_head *bh);struct buffer_head *__find_get_block(struct block_device *bdev, sector_t block, unsigned size);struct buffer_head *__find_get_block_nonatomic(struct block_device *bdev, sector_t block, unsigned size);struct buffer_head *bdev_getblk(struct block_device *bdev, sector_t block, unsigned size, gfp_t gfp);void __brelse(struct buffer_head *);void __bforget(struct buffer_head *);void __breadahead(struct block_device *, sector_t block, unsigned int size);struct buffer_head *__bread_gfp(struct block_device *, sector_t block, unsigned size, gfp_t gfp);struct buffer_head *alloc_buffer_head(gfp_t gfp_flags);void free_buffer_head(struct buffer_head * bh);void unlock_buffer(struct buffer_head *bh);void __lock_buffer(struct buffer_head *bh);int sync_dirty_buffer(struct buffer_head *bh);int __sync_dirty_buffer(struct buffer_head *bh, blk_opf_t op_flags);void write_dirty_buffer(struct buffer_head *bh, blk_opf_t op_flags);void bh_submit(struct buffer_head *, blk_opf_t, bio_end_io_t);void write_boundary_block(struct block_device *bdev, sector_t bblock, unsigned blocksize);int bh_uptodate_or_lock(struct buffer_head *bh);int __bh_read(struct buffer_head *bh, blk_opf_t op_flags, bool wait);void __bh_read_batch(int nr, struct buffer_head *bhs[], blk_opf_t op_flags, bool force_lock);
/* * Generic address_space_operations implementations for buffer_head-backed * address_spaces. */void block_invalidate_folio(struct folio *folio, size_t offset, size_t length);int block_write_full_folio(struct folio *folio, struct writeback_control *wbc, void *get_block);int __block_write_full_folio(struct inode *inode, struct folio *folio, get_block_t *get_block, struct writeback_control *wbc);int block_read_full_folio(struct folio *, get_block_t *);bool block_is_partially_uptodate(struct folio *, size_t from, size_t count);int block_write_begin(struct address_space *mapping, loff_t pos, unsigned len, struct folio **foliop, get_block_t *get_block);int __block_write_begin(struct folio *folio, loff_t pos, unsigned len, get_block_t *get_block);int block_write_end(loff_t pos, unsigned len, unsigned copied, struct folio *);int generic_write_end(const struct kiocb *, struct address_space *, loff_t, unsigned len, unsigned copied, struct folio *, void *);void folio_zero_new_buffers(struct folio *folio, size_t from, size_t to);int cont_write_begin(const struct kiocb *, struct address_space *, loff_t, unsigned, struct folio **, void **, get_block_t *, loff_t *);int generic_cont_expand_simple(struct inode *inode, loff_t size);void block_commit_write(struct folio *folio, size_t from, size_t to);int block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf, get_block_t get_block);sector_t generic_block_bmap(struct address_space *, sector_t, get_block_t *);int block_truncate_page(struct address_space *, loff_t, get_block_t *);
#ifdef CONFIG_MIGRATIONextern int buffer_migrate_folio(struct address_space *, struct folio *dst, struct folio *src, enum migrate_mode);extern int buffer_migrate_folio_norefs(struct address_space *, struct folio *dst, struct folio *src, enum migrate_mode);#else#define buffer_migrate_folio NULL#define buffer_migrate_folio_norefs NULL#endif
/* * inline definitions */
static inline void get_bh(struct buffer_head *bh){ atomic_inc(&bh->b_count);}
static inline void put_bh(struct buffer_head *bh){ smp_mb__before_atomic(); atomic_dec(&bh->b_count);}
/** * brelse - Release a buffer. * @bh: The buffer to release. * * Decrement a buffer_head's reference count. If @bh is NULL, this * function is a no-op. * * If all buffers on a folio have zero reference count, are clean * and unlocked, and if the folio is unlocked and not under writeback * then try_to_free_buffers() may strip the buffers from the folio in * preparation for freeing it (sometimes, rarely, buffers are removed * from a folio but it ends up not being freed, and buffers may later * be reattached). * * Context: Any context. */static inline void brelse(struct buffer_head *bh){ if (bh) __brelse(bh);}
/** * bforget - Discard any dirty data in a buffer. * @bh: The buffer to forget. * * Call this function instead of brelse() if the data written to a buffer * no longer needs to be written back. It will clear the buffer's dirty * flag so writeback of this buffer will be skipped. * * Context: Any context. */static inline void bforget(struct buffer_head *bh){ if (bh) __bforget(bh);}
static inline struct buffer_head *sb_bread(struct super_block *sb, sector_t block){ return __bread_gfp(sb->s_bdev, block, sb->s_blocksize, __GFP_MOVABLE);}
static inline struct buffer_head *sb_bread_unmovable(struct super_block *sb, sector_t block){ return __bread_gfp(sb->s_bdev, block, sb->s_blocksize, 0);}
static inline voidsb_breadahead(struct super_block *sb, sector_t block){ __breadahead(sb->s_bdev, block, sb->s_blocksize);}
static inline struct buffer_head *getblk_unmovable(struct block_device *bdev, sector_t block, unsigned size){ gfp_t gfp;
gfp = mapping_gfp_constraint(bdev->bd_mapping, ~__GFP_FS); gfp |= __GFP_NOFAIL;
return bdev_getblk(bdev, block, size, gfp);}
static inline struct buffer_head *__getblk(struct block_device *bdev, sector_t block, unsigned size){ gfp_t gfp;
gfp = mapping_gfp_constraint(bdev->bd_mapping, ~__GFP_FS); gfp |= __GFP_MOVABLE | __GFP_NOFAIL;
return bdev_getblk(bdev, block, size, gfp);}
static inline struct buffer_head *sb_getblk(struct super_block *sb, sector_t block){ return __getblk(sb->s_bdev, block, sb->s_blocksize);}
static inline struct buffer_head *sb_getblk_gfp(struct super_block *sb, sector_t block, gfp_t gfp){ return bdev_getblk(sb->s_bdev, block, sb->s_blocksize, gfp);}
static inline struct buffer_head *sb_find_get_block(struct super_block *sb, sector_t block){ return __find_get_block(sb->s_bdev, block, sb->s_blocksize);}
static inline struct buffer_head *sb_find_get_block_nonatomic(struct super_block *sb, sector_t block){ return __find_get_block_nonatomic(sb->s_bdev, block, sb->s_blocksize);}
static inline voidmap_bh(struct buffer_head *bh, struct super_block *sb, sector_t block){ set_buffer_mapped(bh); bh->b_bdev = sb->s_bdev; bh->b_blocknr = block; bh->b_size = sb->s_blocksize;}
static inline void wait_on_buffer(struct buffer_head *bh){ might_sleep(); if (buffer_locked(bh)) __wait_on_buffer(bh);}
static inline int trylock_buffer(struct buffer_head *bh){ return likely(!test_and_set_bit_lock(BH_Lock, &bh->b_state));}
static inline void lock_buffer(struct buffer_head *bh){ might_sleep(); if (!trylock_buffer(bh)) __lock_buffer(bh);}
static inline void bh_readahead(struct buffer_head *bh, blk_opf_t op_flags){ if (!buffer_uptodate(bh) && trylock_buffer(bh)) { if (!buffer_uptodate(bh)) __bh_read(bh, op_flags, false); else unlock_buffer(bh); }}
static inline void bh_read_nowait(struct buffer_head *bh, blk_opf_t op_flags){ if (!bh_uptodate_or_lock(bh)) __bh_read(bh, op_flags, false);}
/* Returns 1 if buffer uptodated, 0 on success, and -EIO on error. */static inline int bh_read(struct buffer_head *bh, blk_opf_t op_flags){ if (bh_uptodate_or_lock(bh)) return 1; return __bh_read(bh, op_flags, true);}
static inline void bh_read_batch(int nr, struct buffer_head *bhs[]){ __bh_read_batch(nr, bhs, 0, true);}
static inline void bh_readahead_batch(int nr, struct buffer_head *bhs[], blk_opf_t op_flags){ __bh_read_batch(nr, bhs, op_flags, false);}
/** * __bread() - Read a block. * @bdev: The block device to read from. * @block: Block number in units of block size. * @size: The block size of this device in bytes. * * Read a specified block, and return the buffer head that refers * to it. The memory is allocated from the movable area so that it can * be migrated. The returned buffer head has its refcount increased. * The caller should call brelse() when it has finished with the buffer. * * Context: May sleep waiting for I/O. * Return: NULL if the block was unreadable. */static inline struct buffer_head *__bread(struct block_device *bdev, sector_t block, unsigned size){ return __bread_gfp(bdev, block, size, __GFP_MOVABLE);}
/** * get_nth_bh - Get a reference on the n'th buffer after this one. * @bh: The buffer to start counting from. * @count: How many buffers to skip. * * This is primarily useful for finding the nth buffer in a folio; in * that case you pass the head buffer and the byte offset in the folio * divided by the block size. It can be used for other purposes, but * it will wrap at the end of the folio rather than returning NULL or * proceeding to the next folio for you. * * Return: The requested buffer with an elevated refcount. */static inline __must_checkstruct buffer_head *get_nth_bh(struct buffer_head *bh, unsigned int count){ while (count--) bh = bh->b_this_page; get_bh(bh); return bh;}
bool block_dirty_folio(struct address_space *mapping, struct folio *folio);
#ifdef CONFIG_BUFFER_HEAD
void buffer_init(void);bool try_to_free_buffers(struct folio *folio);void mmb_init(struct mapping_metadata_bhs *mmb, struct address_space *mapping);bool mmb_has_buffers(struct mapping_metadata_bhs *mmb);void mmb_invalidate(struct mapping_metadata_bhs *mmb);int mmb_sync(struct mapping_metadata_bhs *mmb);void invalidate_bh_lrus(void);void invalidate_bh_lrus_cpu(void);bool has_bh_in_lru(int cpu, void *dummy);extern int buffer_heads_over_limit;
#else /* CONFIG_BUFFER_HEAD */
static inline void buffer_init(void) {}static inline bool try_to_free_buffers(struct folio *folio) { return true; }static inline int mmb_sync(struct mapping_metadata_bhs *mmb) { return 0; }static inline void invalidate_bh_lrus(void) {}static inline void invalidate_bh_lrus_cpu(void) {}static inline bool has_bh_in_lru(int cpu, void *dummy) { return false; }#define buffer_heads_over_limit 0
#endif /* CONFIG_BUFFER_HEAD */#endif /* _LINUX_BUFFER_HEAD_H */