blob: 8c19e705b9c33f5603dc8799e385bfdc235a59cb [file] [log] [blame]
Thomas Gleixner457c8992019-05-19 13:08:55 +01001// SPDX-License-Identifier: GPL-2.0-only
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
3 * linux/fs/buffer.c
4 *
5 * Copyright (C) 1991, 1992, 2002 Linus Torvalds
6 */
7
8/*
9 * Start bdflush() with kernel_thread not syscall - Paul Gortmaker, 12/95
10 *
11 * Removed a lot of unnecessary code and simplified things now that
12 * the buffer cache isn't our primary cache - Andrew Tridgell 12/96
13 *
14 * Speed up hash, lru, and free list operations. Use gfp() for allocating
15 * hash table, use SLAB cache for buffer heads. SMP threading. -DaveM
16 *
17 * Added 32k buffer block sizes - these are required older ARM systems. - RMK
18 *
19 * async buffer flushing, 1999 Andrea Arcangeli <andrea@suse.de>
20 */
21
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/kernel.h>
Ingo Molnarf361bf42017-02-03 23:47:37 +010023#include <linux/sched/signal.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/syscalls.h>
25#include <linux/fs.h>
Christoph Hellwigae259a92016-06-21 09:23:11 +100026#include <linux/iomap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/mm.h>
28#include <linux/percpu.h>
29#include <linux/slab.h>
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080030#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <linux/blkdev.h>
32#include <linux/file.h>
33#include <linux/quotaops.h>
34#include <linux/highmem.h>
Paul Gortmaker630d9c42011-11-16 23:57:37 -050035#include <linux/export.h>
Tejun Heobafc0db2015-06-02 08:37:23 -060036#include <linux/backing-dev.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <linux/writeback.h>
38#include <linux/hash.h>
39#include <linux/suspend.h>
40#include <linux/buffer_head.h>
Andrew Morton55e829a2006-12-10 02:19:27 -080041#include <linux/task_io_accounting_ops.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <linux/bio.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <linux/cpu.h>
44#include <linux/bitops.h>
45#include <linux/mpage.h>
Ingo Molnarfb1c8f92005-09-10 00:25:56 -070046#include <linux/bit_spinlock.h>
Jan Kara29f3ad72016-11-04 18:08:11 +010047#include <linux/pagevec.h>
Shakeel Buttf745c6f2018-08-17 15:46:44 -070048#include <linux/sched/mm.h>
Tejun Heo5305cb82013-01-11 13:06:36 -080049#include <trace/events/block.h>
Eric Biggers31fb9922019-10-22 20:33:11 -070050#include <linux/fscrypt.h>
Eric Biggers4fa512c2022-12-23 12:36:37 -080051#include <linux/fsverity.h>
Marcelo Tosatti8a237ad2023-06-27 17:08:15 -030052#include <linux/sched/isolation.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
Ben Dooks2b211dc2019-11-30 17:49:18 -080054#include "internal.h"
55
Linus Torvalds1da177e2005-04-16 15:20:36 -070056static int fsync_buffers_list(spinlock_t *lock, struct list_head *list);
Ritesh Harjani (IBM)5bdf4022022-08-18 10:34:40 +053057static void submit_bh_wbc(blk_opf_t opf, struct buffer_head *bh,
Bart Van Assche44981352024-02-02 12:39:25 -080058 enum rw_hint hint, struct writeback_control *wbc);
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
60#define BH_ENTRY(list) list_entry((list), struct buffer_head, b_assoc_buffers)
61
Tejun Heof0059af2013-01-11 13:06:35 -080062inline void touch_buffer(struct buffer_head *bh)
63{
Tejun Heo5305cb82013-01-11 13:06:36 -080064 trace_block_touch_buffer(bh);
Matthew Wilcox (Oracle)03c5f332022-12-15 21:43:53 +000065 folio_mark_accessed(bh->b_folio);
Tejun Heof0059af2013-01-11 13:06:35 -080066}
67EXPORT_SYMBOL(touch_buffer);
68
Harvey Harrisonfc9b52c2008-02-08 04:19:52 -080069void __lock_buffer(struct buffer_head *bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -070070{
NeilBrown74316202014-07-07 15:16:04 +100071 wait_on_bit_lock_io(&bh->b_state, BH_Lock, TASK_UNINTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -070072}
73EXPORT_SYMBOL(__lock_buffer);
74
Harvey Harrisonfc9b52c2008-02-08 04:19:52 -080075void unlock_buffer(struct buffer_head *bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -070076{
Nick Piggin51b07fc2008-10-18 20:27:00 -070077 clear_bit_unlock(BH_Lock, &bh->b_state);
Peter Zijlstra4e857c52014-03-17 18:06:10 +010078 smp_mb__after_atomic();
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 wake_up_bit(&bh->b_state, BH_Lock);
80}
H Hartley Sweeten1fe72ea2009-09-22 16:43:51 -070081EXPORT_SYMBOL(unlock_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
83/*
Matthew Wilcox (Oracle)520f3012022-01-17 14:35:22 -050084 * Returns if the folio has dirty or writeback buffers. If all the buffers
85 * are unlocked and clean then the folio_test_dirty information is stale. If
86 * any of the buffers are locked, it is assumed they are locked for IO.
Mel Gormanb4597222013-07-03 15:02:05 -070087 */
Matthew Wilcox (Oracle)520f3012022-01-17 14:35:22 -050088void buffer_check_dirty_writeback(struct folio *folio,
Mel Gormanb4597222013-07-03 15:02:05 -070089 bool *dirty, bool *writeback)
90{
91 struct buffer_head *head, *bh;
92 *dirty = false;
93 *writeback = false;
94
Matthew Wilcox (Oracle)520f3012022-01-17 14:35:22 -050095 BUG_ON(!folio_test_locked(folio));
Mel Gormanb4597222013-07-03 15:02:05 -070096
Matthew Wilcox (Oracle)520f3012022-01-17 14:35:22 -050097 head = folio_buffers(folio);
98 if (!head)
Mel Gormanb4597222013-07-03 15:02:05 -070099 return;
100
Matthew Wilcox (Oracle)520f3012022-01-17 14:35:22 -0500101 if (folio_test_writeback(folio))
Mel Gormanb4597222013-07-03 15:02:05 -0700102 *writeback = true;
103
Mel Gormanb4597222013-07-03 15:02:05 -0700104 bh = head;
105 do {
106 if (buffer_locked(bh))
107 *writeback = true;
108
109 if (buffer_dirty(bh))
110 *dirty = true;
111
112 bh = bh->b_this_page;
113 } while (bh != head);
114}
Mel Gormanb4597222013-07-03 15:02:05 -0700115
116/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 * Block until a buffer comes unlocked. This doesn't stop it
118 * from becoming locked again - you have to lock it yourself
119 * if you want to preserve its state.
120 */
121void __wait_on_buffer(struct buffer_head * bh)
122{
NeilBrown74316202014-07-07 15:16:04 +1000123 wait_on_bit_io(&bh->b_state, BH_Lock, TASK_UNINTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124}
H Hartley Sweeten1fe72ea2009-09-22 16:43:51 -0700125EXPORT_SYMBOL(__wait_on_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126
Robert Elliottb744c2a2014-10-21 13:55:09 -0600127static void buffer_io_error(struct buffer_head *bh, char *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128{
Robert Elliott432f16e2014-10-21 13:55:11 -0600129 if (!test_bit(BH_Quiet, &bh->b_state))
130 printk_ratelimited(KERN_ERR
Dmitry Monakhova1c6f0572015-04-13 16:31:37 +0400131 "Buffer I/O error on dev %pg, logical block %llu%s\n",
132 bh->b_bdev, (unsigned long long)bh->b_blocknr, msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133}
134
135/*
Dmitry Monakhov68671f32007-10-16 01:24:47 -0700136 * End-of-IO handler helper function which does not touch the bh after
137 * unlocking it.
138 * Note: unlock_buffer() sort-of does touch the bh after unlocking it, but
139 * a race there is benign: unlock_buffer() only use the bh's address for
140 * hashing after unlocking the buffer, so it doesn't actually touch the bh
141 * itself.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 */
Dmitry Monakhov68671f32007-10-16 01:24:47 -0700143static void __end_buffer_read_notouch(struct buffer_head *bh, int uptodate)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144{
145 if (uptodate) {
146 set_buffer_uptodate(bh);
147 } else {
Christoph Hellwig70246282016-07-19 11:28:41 +0200148 /* This happens, due to failed read-ahead attempts. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 clear_buffer_uptodate(bh);
150 }
151 unlock_buffer(bh);
Dmitry Monakhov68671f32007-10-16 01:24:47 -0700152}
153
154/*
155 * Default synchronous end-of-IO handler.. Just mark it up-to-date and
Zhang Yi79f59782022-09-01 21:35:03 +0800156 * unlock the buffer.
Dmitry Monakhov68671f32007-10-16 01:24:47 -0700157 */
158void end_buffer_read_sync(struct buffer_head *bh, int uptodate)
159{
160 __end_buffer_read_notouch(bh, uptodate);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 put_bh(bh);
162}
H Hartley Sweeten1fe72ea2009-09-22 16:43:51 -0700163EXPORT_SYMBOL(end_buffer_read_sync);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164
165void end_buffer_write_sync(struct buffer_head *bh, int uptodate)
166{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 if (uptodate) {
168 set_buffer_uptodate(bh);
169 } else {
Robert Elliott432f16e2014-10-21 13:55:11 -0600170 buffer_io_error(bh, ", lost sync page write");
Jeff Layton87354e52017-07-06 07:02:21 -0400171 mark_buffer_write_io_error(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 clear_buffer_uptodate(bh);
173 }
174 unlock_buffer(bh);
175 put_bh(bh);
176}
H Hartley Sweeten1fe72ea2009-09-22 16:43:51 -0700177EXPORT_SYMBOL(end_buffer_write_sync);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
179/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 * Various filesystems appear to want __find_get_block to be non-blocking.
181 * But it's the page lock which protects the buffers. To get around this,
182 * we get exclusion from try_to_free_buffers with the blockdev mapping's
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000183 * i_private_lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 *
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000185 * Hack idea: for the blockdev mapping, i_private_lock contention
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 * may be quite high. This code could TryLock the page, and if that
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000187 * succeeds, there is no need to take i_private_lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 */
189static struct buffer_head *
Coywolf Qi Hunt385fd4c2005-11-07 00:59:39 -0800190__find_get_block_slow(struct block_device *bdev, sector_t block)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191{
Al Viro53cd4cd2024-04-28 19:41:13 -0400192 struct address_space *bd_mapping = bdev->bd_mapping;
193 const int blkbits = bd_mapping->host->i_blkbits;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 struct buffer_head *ret = NULL;
195 pgoff_t index;
196 struct buffer_head *bh;
197 struct buffer_head *head;
Matthew Wilcox (Oracle)eee251822023-06-12 22:01:40 +0100198 struct folio *folio;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 int all_mapped = 1;
Tetsuo Handa43636c82019-01-21 22:49:37 +0900200 static DEFINE_RATELIMIT_STATE(last_warned, HZ, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201
Al Viro53cd4cd2024-04-28 19:41:13 -0400202 index = ((loff_t)block << blkbits) / PAGE_SIZE;
Matthew Wilcox (Oracle)eee251822023-06-12 22:01:40 +0100203 folio = __filemap_get_folio(bd_mapping, index, FGP_ACCESSED, 0);
204 if (IS_ERR(folio))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 goto out;
206
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000207 spin_lock(&bd_mapping->i_private_lock);
Matthew Wilcox (Oracle)eee251822023-06-12 22:01:40 +0100208 head = folio_buffers(folio);
209 if (!head)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 bh = head;
212 do {
Nikanth Karthikesan97f76d32009-04-02 16:56:46 -0700213 if (!buffer_mapped(bh))
214 all_mapped = 0;
215 else if (bh->b_blocknr == block) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 ret = bh;
217 get_bh(bh);
218 goto out_unlock;
219 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 bh = bh->b_this_page;
221 } while (bh != head);
222
223 /* we might be here because some of the buffers on this page are
224 * not mapped. This is due to various races between
225 * file io on the block device and getblk. It gets dealt with
226 * elsewhere, don't buffer_error if we had some unmapped buffers
227 */
Tetsuo Handa43636c82019-01-21 22:49:37 +0900228 ratelimit_set_flags(&last_warned, RATELIMIT_MSG_ON_RELEASE);
229 if (all_mapped && __ratelimit(&last_warned)) {
230 printk("__find_get_block_slow() failed. block=%llu, "
231 "b_blocknr=%llu, b_state=0x%08lx, b_size=%zu, "
232 "device %pg blocksize: %d\n",
233 (unsigned long long)block,
234 (unsigned long long)bh->b_blocknr,
235 bh->b_state, bh->b_size, bdev,
Al Viro53cd4cd2024-04-28 19:41:13 -0400236 1 << blkbits);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 }
238out_unlock:
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000239 spin_unlock(&bd_mapping->i_private_lock);
Matthew Wilcox (Oracle)eee251822023-06-12 22:01:40 +0100240 folio_put(folio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241out:
242 return ret;
243}
244
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245static void end_buffer_async_read(struct buffer_head *bh, int uptodate)
246{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 unsigned long flags;
Nick Piggina3972202005-07-07 17:56:56 -0700248 struct buffer_head *first;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 struct buffer_head *tmp;
Matthew Wilcox (Oracle)2e2dba12022-12-15 21:43:54 +0000250 struct folio *folio;
251 int folio_uptodate = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
253 BUG_ON(!buffer_async_read(bh));
254
Matthew Wilcox (Oracle)2e2dba12022-12-15 21:43:54 +0000255 folio = bh->b_folio;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 if (uptodate) {
257 set_buffer_uptodate(bh);
258 } else {
259 clear_buffer_uptodate(bh);
Robert Elliott432f16e2014-10-21 13:55:11 -0600260 buffer_io_error(bh, ", async page read");
Matthew Wilcox (Oracle)2e2dba12022-12-15 21:43:54 +0000261 folio_set_error(folio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 }
263
264 /*
265 * Be _very_ careful from here on. Bad things can happen if
266 * two buffer heads end IO at almost the same time and both
267 * decide that the page is now completely done.
268 */
Matthew Wilcox (Oracle)2e2dba12022-12-15 21:43:54 +0000269 first = folio_buffers(folio);
Thomas Gleixnerf1e67e32019-11-18 14:28:24 +0100270 spin_lock_irqsave(&first->b_uptodate_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 clear_buffer_async_read(bh);
272 unlock_buffer(bh);
273 tmp = bh;
274 do {
275 if (!buffer_uptodate(tmp))
Matthew Wilcox (Oracle)2e2dba12022-12-15 21:43:54 +0000276 folio_uptodate = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 if (buffer_async_read(tmp)) {
278 BUG_ON(!buffer_locked(tmp));
279 goto still_busy;
280 }
281 tmp = tmp->b_this_page;
282 } while (tmp != bh);
Thomas Gleixnerf1e67e32019-11-18 14:28:24 +0100283 spin_unlock_irqrestore(&first->b_uptodate_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
Matthew Wilcox (Oracle)6ba924d2023-10-04 17:53:05 +0100285 folio_end_read(folio, folio_uptodate);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 return;
287
288still_busy:
Thomas Gleixnerf1e67e32019-11-18 14:28:24 +0100289 spin_unlock_irqrestore(&first->b_uptodate_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 return;
291}
292
Eric Biggers4fa512c2022-12-23 12:36:37 -0800293struct postprocess_bh_ctx {
Eric Biggers31fb9922019-10-22 20:33:11 -0700294 struct work_struct work;
295 struct buffer_head *bh;
296};
297
Eric Biggers4fa512c2022-12-23 12:36:37 -0800298static void verify_bh(struct work_struct *work)
299{
300 struct postprocess_bh_ctx *ctx =
301 container_of(work, struct postprocess_bh_ctx, work);
302 struct buffer_head *bh = ctx->bh;
303 bool valid;
304
Eric Biggers8b7d3fe2023-02-24 15:25:30 -0800305 valid = fsverity_verify_blocks(bh->b_folio, bh->b_size, bh_offset(bh));
Eric Biggers4fa512c2022-12-23 12:36:37 -0800306 end_buffer_async_read(bh, valid);
307 kfree(ctx);
308}
309
310static bool need_fsverity(struct buffer_head *bh)
311{
Eric Biggers8b7d3fe2023-02-24 15:25:30 -0800312 struct folio *folio = bh->b_folio;
313 struct inode *inode = folio->mapping->host;
Eric Biggers4fa512c2022-12-23 12:36:37 -0800314
315 return fsverity_active(inode) &&
316 /* needed by ext4 */
Eric Biggers8b7d3fe2023-02-24 15:25:30 -0800317 folio->index < DIV_ROUND_UP(inode->i_size, PAGE_SIZE);
Eric Biggers4fa512c2022-12-23 12:36:37 -0800318}
319
Eric Biggers31fb9922019-10-22 20:33:11 -0700320static void decrypt_bh(struct work_struct *work)
321{
Eric Biggers4fa512c2022-12-23 12:36:37 -0800322 struct postprocess_bh_ctx *ctx =
323 container_of(work, struct postprocess_bh_ctx, work);
Eric Biggers31fb9922019-10-22 20:33:11 -0700324 struct buffer_head *bh = ctx->bh;
325 int err;
326
Eric Biggers9c7fb7f2023-02-24 15:25:03 -0800327 err = fscrypt_decrypt_pagecache_blocks(bh->b_folio, bh->b_size,
328 bh_offset(bh));
Eric Biggers4fa512c2022-12-23 12:36:37 -0800329 if (err == 0 && need_fsverity(bh)) {
330 /*
331 * We use different work queues for decryption and for verity
332 * because verity may require reading metadata pages that need
333 * decryption, and we shouldn't recurse to the same workqueue.
334 */
335 INIT_WORK(&ctx->work, verify_bh);
336 fsverity_enqueue_verify_work(&ctx->work);
337 return;
338 }
Eric Biggers31fb9922019-10-22 20:33:11 -0700339 end_buffer_async_read(bh, err == 0);
340 kfree(ctx);
341}
342
343/*
Matthew Wilcox (Oracle)2c69e202022-04-29 10:40:40 -0400344 * I/O completion handler for block_read_full_folio() - pages
Eric Biggers31fb9922019-10-22 20:33:11 -0700345 * which come unlocked at the end of I/O.
346 */
347static void end_buffer_async_read_io(struct buffer_head *bh, int uptodate)
348{
Linus Torvalds3822a7c2023-02-23 17:09:35 -0800349 struct inode *inode = bh->b_folio->mapping->host;
Eric Biggers4fa512c2022-12-23 12:36:37 -0800350 bool decrypt = fscrypt_inode_uses_fs_layer_crypto(inode);
351 bool verify = need_fsverity(bh);
352
353 /* Decrypt (with fscrypt) and/or verify (with fsverity) if needed. */
354 if (uptodate && (decrypt || verify)) {
355 struct postprocess_bh_ctx *ctx =
356 kmalloc(sizeof(*ctx), GFP_ATOMIC);
Eric Biggers31fb9922019-10-22 20:33:11 -0700357
358 if (ctx) {
Eric Biggers31fb9922019-10-22 20:33:11 -0700359 ctx->bh = bh;
Eric Biggers4fa512c2022-12-23 12:36:37 -0800360 if (decrypt) {
361 INIT_WORK(&ctx->work, decrypt_bh);
362 fscrypt_enqueue_decrypt_work(&ctx->work);
363 } else {
364 INIT_WORK(&ctx->work, verify_bh);
365 fsverity_enqueue_verify_work(&ctx->work);
366 }
Eric Biggers31fb9922019-10-22 20:33:11 -0700367 return;
368 }
369 uptodate = 0;
370 }
371 end_buffer_async_read(bh, uptodate);
372}
373
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374/*
Matthew Wilcox (Oracle)14059f62023-12-15 20:02:45 +0000375 * Completion handler for block_write_full_folio() - folios which are unlocked
376 * during I/O, and which have the writeback flag cleared upon I/O completion.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 */
Matthew Wilcox (Oracle)14059f62023-12-15 20:02:45 +0000378static void end_buffer_async_write(struct buffer_head *bh, int uptodate)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 unsigned long flags;
Nick Piggina3972202005-07-07 17:56:56 -0700381 struct buffer_head *first;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 struct buffer_head *tmp;
Matthew Wilcox (Oracle)743ed812022-12-15 21:43:55 +0000383 struct folio *folio;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
385 BUG_ON(!buffer_async_write(bh));
386
Matthew Wilcox (Oracle)743ed812022-12-15 21:43:55 +0000387 folio = bh->b_folio;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 if (uptodate) {
389 set_buffer_uptodate(bh);
390 } else {
Robert Elliott432f16e2014-10-21 13:55:11 -0600391 buffer_io_error(bh, ", lost async page write");
Jeff Layton87354e52017-07-06 07:02:21 -0400392 mark_buffer_write_io_error(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 clear_buffer_uptodate(bh);
Matthew Wilcox (Oracle)743ed812022-12-15 21:43:55 +0000394 folio_set_error(folio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 }
396
Matthew Wilcox (Oracle)743ed812022-12-15 21:43:55 +0000397 first = folio_buffers(folio);
Thomas Gleixnerf1e67e32019-11-18 14:28:24 +0100398 spin_lock_irqsave(&first->b_uptodate_lock, flags);
Nick Piggina3972202005-07-07 17:56:56 -0700399
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 clear_buffer_async_write(bh);
401 unlock_buffer(bh);
402 tmp = bh->b_this_page;
403 while (tmp != bh) {
404 if (buffer_async_write(tmp)) {
405 BUG_ON(!buffer_locked(tmp));
406 goto still_busy;
407 }
408 tmp = tmp->b_this_page;
409 }
Thomas Gleixnerf1e67e32019-11-18 14:28:24 +0100410 spin_unlock_irqrestore(&first->b_uptodate_lock, flags);
Matthew Wilcox (Oracle)743ed812022-12-15 21:43:55 +0000411 folio_end_writeback(folio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 return;
413
414still_busy:
Thomas Gleixnerf1e67e32019-11-18 14:28:24 +0100415 spin_unlock_irqrestore(&first->b_uptodate_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 return;
417}
418
419/*
420 * If a page's buffers are under async readin (end_buffer_async_read
421 * completion) then there is a possibility that another thread of
422 * control could lock one of the buffers after it has completed
423 * but while some of the other buffers have not completed. This
424 * locked buffer would confuse end_buffer_async_read() into not unlocking
425 * the page. So the absence of BH_Async_Read tells end_buffer_async_read()
426 * that this buffer is not under async I/O.
427 *
428 * The page comes unlocked when it has no locked buffer_async buffers
429 * left.
430 *
431 * PageLocked prevents anyone starting new async I/O reads any of
432 * the buffers.
433 *
434 * PageWriteback is used to prevent simultaneous writeout of the same
435 * page.
436 *
437 * PageLocked prevents anyone from starting writeback of a page which is
438 * under read I/O (PageWriteback is only ever set against a locked page).
439 */
440static void mark_buffer_async_read(struct buffer_head *bh)
441{
Eric Biggers31fb9922019-10-22 20:33:11 -0700442 bh->b_end_io = end_buffer_async_read_io;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 set_buffer_async_read(bh);
444}
445
H Hartley Sweeten1fe72ea2009-09-22 16:43:51 -0700446static void mark_buffer_async_write_endio(struct buffer_head *bh,
447 bh_end_io_t *handler)
Chris Mason35c80d52009-04-15 13:22:38 -0400448{
449 bh->b_end_io = handler;
450 set_buffer_async_write(bh);
451}
452
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453void mark_buffer_async_write(struct buffer_head *bh)
454{
Chris Mason35c80d52009-04-15 13:22:38 -0400455 mark_buffer_async_write_endio(bh, end_buffer_async_write);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456}
457EXPORT_SYMBOL(mark_buffer_async_write);
458
459
460/*
461 * fs/buffer.c contains helper functions for buffer-backed address space's
462 * fsync functions. A common requirement for buffer-based filesystems is
463 * that certain data from the backing blockdev needs to be written out for
464 * a successful fsync(). For example, ext2 indirect blocks need to be
465 * written back and waited upon before fsync() returns.
466 *
Andreas Gruenbacher73f65b82024-01-08 18:20:40 +0100467 * The functions mark_buffer_dirty_inode(), fsync_inode_buffers(),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 * inode_has_buffers() and invalidate_inode_buffers() are provided for the
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000469 * management of a list of dependent buffers at ->i_mapping->i_private_list.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 *
471 * Locking is a little subtle: try_to_free_buffers() will remove buffers
472 * from their controlling inode's queue when they are being freed. But
473 * try_to_free_buffers() will be operating against the *blockdev* mapping
474 * at the time, not against the S_ISREG file which depends on those buffers.
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000475 * So the locking for i_private_list is via the i_private_lock in the address_space
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 * which backs the buffers. Which is different from the address_space
477 * against which the buffers are listed. So for a particular address_space,
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000478 * mapping->i_private_lock does *not* protect mapping->i_private_list! In fact,
479 * mapping->i_private_list will always be protected by the backing blockdev's
480 * ->i_private_lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 *
482 * Which introduces a requirement: all buffers on an address_space's
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000483 * ->i_private_list must be from the same address_space: the blockdev's.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 *
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000485 * address_spaces which do not place buffers at ->i_private_list via these
486 * utility functions are free to use i_private_lock and i_private_list for
487 * whatever they want. The only requirement is that list_empty(i_private_list)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 * be true at clear_inode() time.
489 *
490 * FIXME: clear_inode should not call invalidate_inode_buffers(). The
491 * filesystems should do that. invalidate_inode_buffers() should just go
492 * BUG_ON(!list_empty).
493 *
494 * FIXME: mark_buffer_dirty_inode() is a data-plane operation. It should
495 * take an address_space, not an inode. And it should be called
496 * mark_buffer_dirty_fsync() to clearly define why those buffers are being
497 * queued up.
498 *
499 * FIXME: mark_buffer_dirty_inode() doesn't need to add the buffer to the
500 * list if it is already on a list. Because if the buffer is on a list,
501 * it *must* already be on the right one. If not, the filesystem is being
502 * silly. This will save a ton of locking. But first we have to ensure
503 * that buffers are taken *off* the old inode's list when they are freed
504 * (presumably in truncate). That requires careful auditing of all
505 * filesystems (do it inside bforget()). It could also be done by bringing
506 * b_inode back.
507 */
508
509/*
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000510 * The buffer's backing address_space's i_private_lock must be held
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 */
Thomas Petazzonidbacefc2008-07-29 22:33:47 -0700512static void __remove_assoc_queue(struct buffer_head *bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513{
514 list_del_init(&bh->b_assoc_buffers);
Jan Kara58ff407b2006-10-17 00:10:19 -0700515 WARN_ON(!bh->b_assoc_map);
Jan Kara58ff407b2006-10-17 00:10:19 -0700516 bh->b_assoc_map = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517}
518
519int inode_has_buffers(struct inode *inode)
520{
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000521 return !list_empty(&inode->i_data.i_private_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522}
523
524/*
525 * osync is designed to support O_SYNC io. It waits synchronously for
526 * all already-submitted IO to complete, but does not queue any new
527 * writes to the disk.
528 *
Zhang Yi79f59782022-09-01 21:35:03 +0800529 * To do O_SYNC writes, just queue the buffer writes with write_dirty_buffer
530 * as you dirty the buffers, and then use osync_inode_buffers to wait for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 * completion. Any other dirty buffers which are not yet queued for
532 * write will not be flushed to disk by the osync.
533 */
534static int osync_buffers_list(spinlock_t *lock, struct list_head *list)
535{
536 struct buffer_head *bh;
537 struct list_head *p;
538 int err = 0;
539
540 spin_lock(lock);
541repeat:
542 list_for_each_prev(p, list) {
543 bh = BH_ENTRY(p);
544 if (buffer_locked(bh)) {
545 get_bh(bh);
546 spin_unlock(lock);
547 wait_on_buffer(bh);
548 if (!buffer_uptodate(bh))
549 err = -EIO;
550 brelse(bh);
551 spin_lock(lock);
552 goto repeat;
553 }
554 }
555 spin_unlock(lock);
556 return err;
557}
558
559/**
Randy Dunlap78a4a502008-02-29 22:02:31 -0800560 * sync_mapping_buffers - write out & wait upon a mapping's "associated" buffers
Martin Waitz67be2dd2005-05-01 08:59:26 -0700561 * @mapping: the mapping which wants those buffers written
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 *
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000563 * Starts I/O against the buffers at mapping->i_private_list, and waits upon
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 * that I/O.
565 *
Martin Waitz67be2dd2005-05-01 08:59:26 -0700566 * Basically, this is a convenience function for fsync().
567 * @mapping is a file or directory which needs those buffers to be written for
568 * a successful fsync().
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 */
570int sync_mapping_buffers(struct address_space *mapping)
571{
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000572 struct address_space *buffer_mapping = mapping->i_private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000574 if (buffer_mapping == NULL || list_empty(&mapping->i_private_list))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 return 0;
576
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000577 return fsync_buffers_list(&buffer_mapping->i_private_lock,
578 &mapping->i_private_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579}
580EXPORT_SYMBOL(sync_mapping_buffers);
581
Ritesh Harjani (IBM)31b2ebc2023-04-21 15:16:12 +0530582/**
583 * generic_buffers_fsync_noflush - generic buffer fsync implementation
584 * for simple filesystems with no inode lock
585 *
586 * @file: file to synchronize
587 * @start: start offset in bytes
588 * @end: end offset in bytes (inclusive)
589 * @datasync: only synchronize essential metadata if true
590 *
591 * This is a generic implementation of the fsync method for simple
592 * filesystems which track all non-inode metadata in the buffers list
593 * hanging off the address_space structure.
594 */
595int generic_buffers_fsync_noflush(struct file *file, loff_t start, loff_t end,
596 bool datasync)
597{
598 struct inode *inode = file->f_mapping->host;
599 int err;
600 int ret;
601
602 err = file_write_and_wait_range(file, start, end);
603 if (err)
604 return err;
605
606 ret = sync_mapping_buffers(inode->i_mapping);
607 if (!(inode->i_state & I_DIRTY_ALL))
608 goto out;
609 if (datasync && !(inode->i_state & I_DIRTY_DATASYNC))
610 goto out;
611
612 err = sync_inode_metadata(inode, 1);
613 if (ret == 0)
614 ret = err;
615
616out:
617 /* check and advance again to catch errors after syncing out buffers */
618 err = file_check_and_advance_wb_err(file);
619 if (ret == 0)
620 ret = err;
621 return ret;
622}
623EXPORT_SYMBOL(generic_buffers_fsync_noflush);
624
625/**
626 * generic_buffers_fsync - generic buffer fsync implementation
627 * for simple filesystems with no inode lock
628 *
629 * @file: file to synchronize
630 * @start: start offset in bytes
631 * @end: end offset in bytes (inclusive)
632 * @datasync: only synchronize essential metadata if true
633 *
634 * This is a generic implementation of the fsync method for simple
635 * filesystems which track all non-inode metadata in the buffers list
636 * hanging off the address_space structure. This also makes sure that
637 * a device cache flush operation is called at the end.
638 */
639int generic_buffers_fsync(struct file *file, loff_t start, loff_t end,
640 bool datasync)
641{
642 struct inode *inode = file->f_mapping->host;
643 int ret;
644
645 ret = generic_buffers_fsync_noflush(file, start, end, datasync);
646 if (!ret)
647 ret = blkdev_issue_flush(inode->i_sb->s_bdev);
648 return ret;
649}
650EXPORT_SYMBOL(generic_buffers_fsync);
651
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652/*
653 * Called when we've recently written block `bblock', and it is known that
654 * `bblock' was for a buffer_boundary() buffer. This means that the block at
655 * `bblock + 1' is probably a dirty indirect block. Hunt it down and, if it's
656 * dirty, schedule it for IO. So that indirects merge nicely with their data.
657 */
658void write_boundary_block(struct block_device *bdev,
659 sector_t bblock, unsigned blocksize)
660{
661 struct buffer_head *bh = __find_get_block(bdev, bblock + 1, blocksize);
662 if (bh) {
663 if (buffer_dirty(bh))
Zhang Yie7ea1122022-09-01 21:34:54 +0800664 write_dirty_buffer(bh, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 put_bh(bh);
666 }
667}
668
669void mark_buffer_dirty_inode(struct buffer_head *bh, struct inode *inode)
670{
671 struct address_space *mapping = inode->i_mapping;
Matthew Wilcox (Oracle)abc8a8a2022-12-15 21:43:52 +0000672 struct address_space *buffer_mapping = bh->b_folio->mapping;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673
674 mark_buffer_dirty(bh);
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000675 if (!mapping->i_private_data) {
676 mapping->i_private_data = buffer_mapping;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 } else {
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000678 BUG_ON(mapping->i_private_data != buffer_mapping);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 }
Jan Kara535ee2f2008-02-08 04:21:59 -0800680 if (!bh->b_assoc_map) {
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000681 spin_lock(&buffer_mapping->i_private_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 list_move_tail(&bh->b_assoc_buffers,
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000683 &mapping->i_private_list);
Jan Kara58ff407b2006-10-17 00:10:19 -0700684 bh->b_assoc_map = mapping;
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000685 spin_unlock(&buffer_mapping->i_private_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 }
687}
688EXPORT_SYMBOL(mark_buffer_dirty_inode);
689
Matthew Wilcox (Oracle)3814ec82024-04-16 04:17:46 +0100690/**
691 * block_dirty_folio - Mark a folio as dirty.
692 * @mapping: The address space containing this folio.
693 * @folio: The folio to mark dirty.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 *
Matthew Wilcox (Oracle)3814ec82024-04-16 04:17:46 +0100695 * Filesystems which use buffer_heads can use this function as their
696 * ->dirty_folio implementation. Some filesystems need to do a little
697 * work before calling this function. Filesystems which do not use
698 * buffer_heads should call filemap_dirty_folio() instead.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 *
Matthew Wilcox (Oracle)3814ec82024-04-16 04:17:46 +0100700 * If the folio has buffers, the uptodate buffers are set dirty, to
701 * preserve dirty-state coherency between the folio and the buffers.
702 * Buffers added to a dirty folio are created dirty.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 *
Matthew Wilcox (Oracle)3814ec82024-04-16 04:17:46 +0100704 * The buffers are dirtied before the folio is dirtied. There's a small
705 * race window in which writeback may see the folio cleanness but not the
706 * buffer dirtiness. That's fine. If this code were to set the folio
707 * dirty before the buffers, writeback could clear the folio dirty flag,
708 * see a bunch of clean buffers and we'd end up with dirty buffers/clean
709 * folio on the dirty folio list.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 *
Matthew Wilcox (Oracle)3814ec82024-04-16 04:17:46 +0100711 * We use i_private_lock to lock against try_to_free_buffers() while
712 * using the folio's buffer list. This also prevents clean buffers
713 * being added to the folio after it was set dirty.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 *
Matthew Wilcox (Oracle)3814ec82024-04-16 04:17:46 +0100715 * Context: May only be called from process context. Does not sleep.
716 * Caller must ensure that @folio cannot be truncated during this call,
717 * typically by holding the folio lock or having a page in the folio
718 * mapped and holding the page table lock.
719 *
720 * Return: True if the folio was dirtied; false if it was already dirtied.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 */
Matthew Wilcox (Oracle)e6219002022-02-09 20:22:12 +0000722bool block_dirty_folio(struct address_space *mapping, struct folio *folio)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723{
Matthew Wilcox (Oracle)e6219002022-02-09 20:22:12 +0000724 struct buffer_head *head;
725 bool newly_dirty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000727 spin_lock(&mapping->i_private_lock);
Matthew Wilcox (Oracle)e6219002022-02-09 20:22:12 +0000728 head = folio_buffers(folio);
729 if (head) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 struct buffer_head *bh = head;
731
732 do {
733 set_buffer_dirty(bh);
734 bh = bh->b_this_page;
735 } while (bh != head);
736 }
Greg Thelenc4843a72015-05-22 17:13:16 -0400737 /*
Roman Gushchinbcfe06b2020-12-01 13:58:27 -0800738 * Lock out page's memcg migration to keep PageDirty
Johannes Weiner81f8c3a2016-03-15 14:57:04 -0700739 * synchronized with per-memcg dirty page counters.
Greg Thelenc4843a72015-05-22 17:13:16 -0400740 */
Matthew Wilcox (Oracle)e6219002022-02-09 20:22:12 +0000741 folio_memcg_lock(folio);
742 newly_dirty = !folio_test_set_dirty(folio);
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000743 spin_unlock(&mapping->i_private_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744
Linus Torvaldsa8e7d492009-03-19 11:32:05 -0700745 if (newly_dirty)
Matthew Wilcox (Oracle)e6219002022-02-09 20:22:12 +0000746 __folio_mark_dirty(folio, mapping, 1);
Greg Thelenc4843a72015-05-22 17:13:16 -0400747
Matthew Wilcox (Oracle)e6219002022-02-09 20:22:12 +0000748 folio_memcg_unlock(folio);
Greg Thelenc4843a72015-05-22 17:13:16 -0400749
750 if (newly_dirty)
751 __mark_inode_dirty(mapping->host, I_DIRTY_PAGES);
752
Linus Torvaldsa8e7d492009-03-19 11:32:05 -0700753 return newly_dirty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754}
Matthew Wilcox (Oracle)e6219002022-02-09 20:22:12 +0000755EXPORT_SYMBOL(block_dirty_folio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
757/*
758 * Write out and wait upon a list of buffers.
759 *
760 * We have conflicting pressures: we want to make sure that all
761 * initially dirty buffers get waited on, but that any subsequently
762 * dirtied buffers don't. After all, we don't want fsync to last
763 * forever if somebody is actively writing to the file.
764 *
765 * Do this in two main stages: first we copy dirty buffers to a
766 * temporary inode list, queueing the writes as we go. Then we clean
767 * up, waiting for those writes to complete.
768 *
769 * During this second stage, any subsequent updates to the file may end
770 * up refiling the buffer on the original inode's dirty list again, so
771 * there is a chance we will end up with a buffer queued for write but
772 * not yet completed on that list. So, as a final cleanup we go through
773 * the osync code to catch these locked, dirty buffers without requeuing
774 * any newly dirty buffers for write.
775 */
776static int fsync_buffers_list(spinlock_t *lock, struct list_head *list)
777{
778 struct buffer_head *bh;
779 struct list_head tmp;
Jens Axboe7eaceac2011-03-10 08:52:07 +0100780 struct address_space *mapping;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 int err = 0, err2;
Jens Axboe4ee24912011-03-17 10:51:40 +0100782 struct blk_plug plug;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783
784 INIT_LIST_HEAD(&tmp);
Jens Axboe4ee24912011-03-17 10:51:40 +0100785 blk_start_plug(&plug);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786
787 spin_lock(lock);
788 while (!list_empty(list)) {
789 bh = BH_ENTRY(list->next);
Jan Kara535ee2f2008-02-08 04:21:59 -0800790 mapping = bh->b_assoc_map;
Jan Kara58ff407b2006-10-17 00:10:19 -0700791 __remove_assoc_queue(bh);
Jan Kara535ee2f2008-02-08 04:21:59 -0800792 /* Avoid race with mark_buffer_dirty_inode() which does
793 * a lockless check and we rely on seeing the dirty bit */
794 smp_mb();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 if (buffer_dirty(bh) || buffer_locked(bh)) {
796 list_add(&bh->b_assoc_buffers, &tmp);
Jan Kara535ee2f2008-02-08 04:21:59 -0800797 bh->b_assoc_map = mapping;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 if (buffer_dirty(bh)) {
799 get_bh(bh);
800 spin_unlock(lock);
801 /*
802 * Ensure any pending I/O completes so that
Christoph Hellwig9cb569d2010-08-11 17:06:24 +0200803 * write_dirty_buffer() actually writes the
804 * current contents - it is a noop if I/O is
805 * still in flight on potentially older
806 * contents.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 */
Christoph Hellwig70fd7612016-11-01 07:40:10 -0600808 write_dirty_buffer(bh, REQ_SYNC);
Jens Axboe9cf6b722009-04-06 14:48:03 +0200809
810 /*
811 * Kick off IO for the previous mapping. Note
812 * that we will not run the very last mapping,
813 * wait_on_buffer() will do that for us
814 * through sync_buffer().
815 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 brelse(bh);
817 spin_lock(lock);
818 }
819 }
820 }
821
Jens Axboe4ee24912011-03-17 10:51:40 +0100822 spin_unlock(lock);
823 blk_finish_plug(&plug);
824 spin_lock(lock);
825
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 while (!list_empty(&tmp)) {
827 bh = BH_ENTRY(tmp.prev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 get_bh(bh);
Jan Kara535ee2f2008-02-08 04:21:59 -0800829 mapping = bh->b_assoc_map;
830 __remove_assoc_queue(bh);
831 /* Avoid race with mark_buffer_dirty_inode() which does
832 * a lockless check and we rely on seeing the dirty bit */
833 smp_mb();
834 if (buffer_dirty(bh)) {
835 list_add(&bh->b_assoc_buffers,
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000836 &mapping->i_private_list);
Jan Kara535ee2f2008-02-08 04:21:59 -0800837 bh->b_assoc_map = mapping;
838 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 spin_unlock(lock);
840 wait_on_buffer(bh);
841 if (!buffer_uptodate(bh))
842 err = -EIO;
843 brelse(bh);
844 spin_lock(lock);
845 }
846
847 spin_unlock(lock);
848 err2 = osync_buffers_list(lock, list);
849 if (err)
850 return err;
851 else
852 return err2;
853}
854
855/*
856 * Invalidate any and all dirty buffers on a given inode. We are
857 * probably unmounting the fs, but that doesn't mean we have already
858 * done a sync(). Just drop the buffers from the inode list.
859 *
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000860 * NOTE: we take the inode's blockdev's mapping's i_private_lock. Which
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 * assumes that all the buffers are against the blockdev. Not true
862 * for reiserfs.
863 */
864void invalidate_inode_buffers(struct inode *inode)
865{
866 if (inode_has_buffers(inode)) {
867 struct address_space *mapping = &inode->i_data;
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000868 struct list_head *list = &mapping->i_private_list;
869 struct address_space *buffer_mapping = mapping->i_private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000871 spin_lock(&buffer_mapping->i_private_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 while (!list_empty(list))
873 __remove_assoc_queue(BH_ENTRY(list->next));
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000874 spin_unlock(&buffer_mapping->i_private_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 }
876}
Jan Kara52b19ac2008-09-23 18:24:08 +0200877EXPORT_SYMBOL(invalidate_inode_buffers);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878
879/*
880 * Remove any clean buffers from the inode's buffer list. This is called
881 * when we're trying to free the inode itself. Those buffers can pin it.
882 *
883 * Returns true if all buffers were removed.
884 */
885int remove_inode_buffers(struct inode *inode)
886{
887 int ret = 1;
888
889 if (inode_has_buffers(inode)) {
890 struct address_space *mapping = &inode->i_data;
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000891 struct list_head *list = &mapping->i_private_list;
892 struct address_space *buffer_mapping = mapping->i_private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000894 spin_lock(&buffer_mapping->i_private_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 while (!list_empty(list)) {
896 struct buffer_head *bh = BH_ENTRY(list->next);
897 if (buffer_dirty(bh)) {
898 ret = 0;
899 break;
900 }
901 __remove_assoc_queue(bh);
902 }
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +0000903 spin_unlock(&buffer_mapping->i_private_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 }
905 return ret;
906}
907
908/*
Pankaj Raghavc71124a2023-04-17 14:36:16 +0200909 * Create the appropriate buffers when given a folio for data area and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 * the size of each buffer.. Use the bh->b_this_page linked list to
911 * follow the buffers created. Return NULL if unable to create more
912 * buffers.
913 *
914 * The retry flag is used to differentiate async IO (paging, swapping)
915 * which may not fail from ordinary buffer allocations.
916 */
Pankaj Raghavc71124a2023-04-17 14:36:16 +0200917struct buffer_head *folio_alloc_buffers(struct folio *folio, unsigned long size,
Matthew Wilcox (Oracle)2a418152023-09-14 16:00:04 +0100918 gfp_t gfp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919{
920 struct buffer_head *bh, *head;
921 long offset;
Roman Gushchinb87d8ce2020-10-17 16:13:40 -0700922 struct mem_cgroup *memcg, *old_memcg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923
Pankaj Raghavc71124a2023-04-17 14:36:16 +0200924 /* The folio lock pins the memcg */
925 memcg = folio_memcg(folio);
Roman Gushchinb87d8ce2020-10-17 16:13:40 -0700926 old_memcg = set_active_memcg(memcg);
Shakeel Buttf745c6f2018-08-17 15:46:44 -0700927
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 head = NULL;
Pankaj Raghavc71124a2023-04-17 14:36:16 +0200929 offset = folio_size(folio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 while ((offset -= size) >= 0) {
Jens Axboe640ab982017-09-27 05:40:16 -0600931 bh = alloc_buffer_head(gfp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 if (!bh)
933 goto no_grow;
934
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 bh->b_this_page = head;
936 bh->b_blocknr = -1;
937 head = bh;
938
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 bh->b_size = size;
940
Pankaj Raghavc71124a2023-04-17 14:36:16 +0200941 /* Link the buffer to its folio */
942 folio_set_bh(bh, folio, offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 }
Shakeel Buttf745c6f2018-08-17 15:46:44 -0700944out:
Roman Gushchinb87d8ce2020-10-17 16:13:40 -0700945 set_active_memcg(old_memcg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 return head;
947/*
948 * In case anything failed, we just free everything we got.
949 */
950no_grow:
951 if (head) {
952 do {
953 bh = head;
954 head = head->b_this_page;
955 free_buffer_head(bh);
956 } while (head);
957 }
958
Shakeel Buttf745c6f2018-08-17 15:46:44 -0700959 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960}
Pankaj Raghavc71124a2023-04-17 14:36:16 +0200961EXPORT_SYMBOL_GPL(folio_alloc_buffers);
962
963struct buffer_head *alloc_page_buffers(struct page *page, unsigned long size,
964 bool retry)
965{
Matthew Wilcox (Oracle)2a418152023-09-14 16:00:04 +0100966 gfp_t gfp = GFP_NOFS | __GFP_ACCOUNT;
967 if (retry)
968 gfp |= __GFP_NOFAIL;
969
970 return folio_alloc_buffers(page_folio(page), size, gfp);
Pankaj Raghavc71124a2023-04-17 14:36:16 +0200971}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972EXPORT_SYMBOL_GPL(alloc_page_buffers);
973
Matthew Wilcox (Oracle)08d84ad2023-06-12 22:01:39 +0100974static inline void link_dev_buffers(struct folio *folio,
975 struct buffer_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976{
977 struct buffer_head *bh, *tail;
978
979 bh = head;
980 do {
981 tail = bh;
982 bh = bh->b_this_page;
983 } while (bh);
984 tail->b_this_page = head;
Matthew Wilcox (Oracle)08d84ad2023-06-12 22:01:39 +0100985 folio_attach_private(folio, head);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986}
987
Linus Torvaldsbbec02702012-11-29 12:31:52 -0800988static sector_t blkdev_max_block(struct block_device *bdev, unsigned int size)
989{
990 sector_t retval = ~((sector_t)0);
Christoph Hellwigb86058f2021-10-18 12:11:09 +0200991 loff_t sz = bdev_nr_bytes(bdev);
Linus Torvaldsbbec02702012-11-29 12:31:52 -0800992
993 if (sz) {
994 unsigned int sizebits = blksize_bits(size);
995 retval = (sz >> sizebits);
996 }
997 return retval;
998}
999
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000/*
Matthew Wilcox (Oracle)6f24ce62023-06-12 22:01:38 +01001001 * Initialise the state of a blockdev folio's buffers.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 */
Matthew Wilcox (Oracle)6f24ce62023-06-12 22:01:38 +01001003static sector_t folio_init_buffers(struct folio *folio,
Matthew Wilcox (Oracle)382497a2023-11-09 21:06:03 +00001004 struct block_device *bdev, unsigned size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005{
Matthew Wilcox (Oracle)6f24ce62023-06-12 22:01:38 +01001006 struct buffer_head *head = folio_buffers(folio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 struct buffer_head *bh = head;
Matthew Wilcox (Oracle)6f24ce62023-06-12 22:01:38 +01001008 bool uptodate = folio_test_uptodate(folio);
Matthew Wilcox (Oracle)382497a2023-11-09 21:06:03 +00001009 sector_t block = div_u64(folio_pos(folio), size);
Christoph Hellwigbcd1d062021-10-18 12:11:10 +02001010 sector_t end_block = blkdev_max_block(bdev, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011
1012 do {
1013 if (!buffer_mapped(bh)) {
Eric Biggers01950a32018-01-16 22:25:12 -08001014 bh->b_end_io = NULL;
1015 bh->b_private = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 bh->b_bdev = bdev;
1017 bh->b_blocknr = block;
1018 if (uptodate)
1019 set_buffer_uptodate(bh);
Jeff Moyer080399a2012-05-11 16:34:10 +02001020 if (block < end_block)
1021 set_buffer_mapped(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 }
1023 block++;
1024 bh = bh->b_this_page;
1025 } while (bh != head);
Hugh Dickins676ce6d2012-08-23 12:17:36 +02001026
1027 /*
1028 * Caller needs to validate requested block against end of device.
1029 */
1030 return end_block;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031}
1032
1033/*
Matthew Wilcox (Oracle)6d840a12023-11-09 21:06:02 +00001034 * Create the page-cache folio that contains the requested block.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 *
Hugh Dickins676ce6d2012-08-23 12:17:36 +02001036 * This is used purely for blockdev mappings.
Matthew Wilcox (Oracle)6d840a12023-11-09 21:06:02 +00001037 *
Matthew Wilcox (Oracle)bcd30d42024-01-01 09:38:48 +00001038 * Returns false if we have a failure which cannot be cured by retrying
1039 * without sleeping. Returns true if we succeeded, or the caller should retry.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 */
Matthew Wilcox (Oracle)6d840a12023-11-09 21:06:02 +00001041static bool grow_dev_folio(struct block_device *bdev, sector_t block,
Matthew Wilcox (Oracle)382497a2023-11-09 21:06:03 +00001042 pgoff_t index, unsigned size, gfp_t gfp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043{
Al Viro22f89a42024-04-11 15:53:38 +01001044 struct address_space *mapping = bdev->bd_mapping;
Matthew Wilcox (Oracle)3c98a412023-06-12 22:01:37 +01001045 struct folio *folio;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 struct buffer_head *bh;
Matthew Wilcox (Oracle)6d840a12023-11-09 21:06:02 +00001047 sector_t end_block = 0;
Johannes Weiner84235de2013-10-16 13:47:00 -07001048
Al Viro22f89a42024-04-11 15:53:38 +01001049 folio = __filemap_get_folio(mapping, index,
Matthew Wilcox (Oracle)3ed65f02023-09-14 16:00:05 +01001050 FGP_LOCK | FGP_ACCESSED | FGP_CREAT, gfp);
1051 if (IS_ERR(folio))
Matthew Wilcox (Oracle)6d840a12023-11-09 21:06:02 +00001052 return false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053
Matthew Wilcox (Oracle)3c98a412023-06-12 22:01:37 +01001054 bh = folio_buffers(folio);
1055 if (bh) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 if (bh->b_size == size) {
Matthew Wilcox (Oracle)382497a2023-11-09 21:06:03 +00001057 end_block = folio_init_buffers(folio, bdev, size);
Matthew Wilcox (Oracle)6d840a12023-11-09 21:06:02 +00001058 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 }
Matthew Wilcox (Oracle)6d840a12023-11-09 21:06:02 +00001060
Matthew Wilcox (Oracle)bcd30d42024-01-01 09:38:48 +00001061 /*
1062 * Retrying may succeed; for example the folio may finish
1063 * writeback, or buffers may be cleaned. This should not
1064 * happen very often; maybe we have old buffers attached to
1065 * this blockdev's page cache and we're trying to change
1066 * the block size?
1067 */
1068 if (!try_to_free_buffers(folio)) {
1069 end_block = ~0ULL;
Matthew Wilcox (Oracle)6d840a12023-11-09 21:06:02 +00001070 goto unlock;
Matthew Wilcox (Oracle)bcd30d42024-01-01 09:38:48 +00001071 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 }
1073
Matthew Wilcox (Oracle)3ed65f02023-09-14 16:00:05 +01001074 bh = folio_alloc_buffers(folio, size, gfp | __GFP_ACCOUNT);
1075 if (!bh)
Matthew Wilcox (Oracle)6d840a12023-11-09 21:06:02 +00001076 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077
1078 /*
Matthew Wilcox (Oracle)3c98a412023-06-12 22:01:37 +01001079 * Link the folio to the buffers and initialise them. Take the
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 * lock to be atomic wrt __find_get_block(), which does not
Matthew Wilcox (Oracle)3c98a412023-06-12 22:01:37 +01001081 * run under the folio lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 */
Al Viro22f89a42024-04-11 15:53:38 +01001083 spin_lock(&mapping->i_private_lock);
Matthew Wilcox (Oracle)08d84ad2023-06-12 22:01:39 +01001084 link_dev_buffers(folio, bh);
Matthew Wilcox (Oracle)382497a2023-11-09 21:06:03 +00001085 end_block = folio_init_buffers(folio, bdev, size);
Al Viro22f89a42024-04-11 15:53:38 +01001086 spin_unlock(&mapping->i_private_lock);
Matthew Wilcox (Oracle)6d840a12023-11-09 21:06:02 +00001087unlock:
Matthew Wilcox (Oracle)3c98a412023-06-12 22:01:37 +01001088 folio_unlock(folio);
1089 folio_put(folio);
Matthew Wilcox (Oracle)6d840a12023-11-09 21:06:02 +00001090 return block < end_block;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091}
1092
1093/*
Matthew Wilcox (Oracle)6d840a12023-11-09 21:06:02 +00001094 * Create buffers for the specified block device block's folio. If
1095 * that folio was dirty, the buffers are set dirty also. Returns false
1096 * if we've hit a permanent error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 */
Matthew Wilcox (Oracle)6d840a12023-11-09 21:06:02 +00001098static bool grow_buffers(struct block_device *bdev, sector_t block,
1099 unsigned size, gfp_t gfp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100{
Matthew Wilcox (Oracle)5f3bd902023-11-09 21:06:04 +00001101 loff_t pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102
Andrew Mortone5657932006-10-11 01:21:46 -07001103 /*
Matthew Wilcox (Oracle)5f3bd902023-11-09 21:06:04 +00001104 * Check for a block which lies outside our maximum possible
1105 * pagecache index.
Andrew Mortone5657932006-10-11 01:21:46 -07001106 */
Matthew Wilcox (Oracle)5f3bd902023-11-09 21:06:04 +00001107 if (check_mul_overflow(block, (sector_t)size, &pos) || pos > MAX_LFS_FILESIZE) {
1108 printk(KERN_ERR "%s: requested out-of-range block %llu for device %pg\n",
Harvey Harrison8e24eea2008-04-30 00:55:09 -07001109 __func__, (unsigned long long)block,
Dmitry Monakhova1c6f0572015-04-13 16:31:37 +04001110 bdev);
Matthew Wilcox (Oracle)6d840a12023-11-09 21:06:02 +00001111 return false;
Andrew Mortone5657932006-10-11 01:21:46 -07001112 }
Hugh Dickins676ce6d2012-08-23 12:17:36 +02001113
Matthew Wilcox (Oracle)6d840a12023-11-09 21:06:02 +00001114 /* Create a folio with the proper size buffers */
Matthew Wilcox (Oracle)5f3bd902023-11-09 21:06:04 +00001115 return grow_dev_folio(bdev, block, pos / PAGE_SIZE, size, gfp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116}
1117
Eric Biggers0026ba42016-09-12 13:30:41 -07001118static struct buffer_head *
Gioh Kim3b5e6452014-09-04 22:04:42 -04001119__getblk_slow(struct block_device *bdev, sector_t block,
1120 unsigned size, gfp_t gfp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121{
1122 /* Size must be multiple of hard sectorsize */
Martin K. Petersene1defc42009-05-22 17:17:49 -04001123 if (unlikely(size & (bdev_logical_block_size(bdev)-1) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 (size < 512 || size > PAGE_SIZE))) {
1125 printk(KERN_ERR "getblk(): invalid block size %d requested\n",
1126 size);
Martin K. Petersene1defc42009-05-22 17:17:49 -04001127 printk(KERN_ERR "logical block size: %d\n",
1128 bdev_logical_block_size(bdev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129
1130 dump_stack();
1131 return NULL;
1132 }
1133
Hugh Dickins676ce6d2012-08-23 12:17:36 +02001134 for (;;) {
1135 struct buffer_head *bh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136
1137 bh = __find_get_block(bdev, block, size);
1138 if (bh)
1139 return bh;
Hugh Dickins676ce6d2012-08-23 12:17:36 +02001140
Matthew Wilcox (Oracle)6d840a12023-11-09 21:06:02 +00001141 if (!grow_buffers(bdev, block, size, gfp))
Hugh Dickins676ce6d2012-08-23 12:17:36 +02001142 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 }
1144}
1145
1146/*
1147 * The relationship between dirty buffers and dirty pages:
1148 *
1149 * Whenever a page has any dirty buffers, the page's dirty bit is set, and
Matthew Wilcoxec82e1c2017-12-04 10:40:41 -05001150 * the page is tagged dirty in the page cache.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 *
1152 * At all times, the dirtiness of the buffers represents the dirtiness of
1153 * subsections of the page. If the page has buffers, the page dirty bit is
1154 * merely a hint about the true dirty state.
1155 *
1156 * When a page is set dirty in its entirety, all its buffers are marked dirty
1157 * (if the page has buffers).
1158 *
1159 * When a buffer is marked dirty, its page is dirtied, but the page's other
1160 * buffers are not.
1161 *
1162 * Also. When blockdev buffers are explicitly read with bread(), they
1163 * individually become uptodate. But their backing page remains not
1164 * uptodate - even if all of its buffers are uptodate. A subsequent
Matthew Wilcox (Oracle)2c69e202022-04-29 10:40:40 -04001165 * block_read_full_folio() against that folio will discover all the uptodate
1166 * buffers, will set the folio uptodate and will perform no I/O.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 */
1168
1169/**
1170 * mark_buffer_dirty - mark a buffer_head as needing writeout
Martin Waitz67be2dd2005-05-01 08:59:26 -07001171 * @bh: the buffer_head to mark dirty
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172 *
Matthew Wilcoxec82e1c2017-12-04 10:40:41 -05001173 * mark_buffer_dirty() will set the dirty bit against the buffer, then set
1174 * its backing page dirty, then tag the page as dirty in the page cache
1175 * and then attach the address_space's inode to its superblock's dirty
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 * inode list.
1177 *
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +00001178 * mark_buffer_dirty() is atomic. It takes bh->b_folio->mapping->i_private_lock,
Matthew Wilcoxb93b0162018-04-10 16:36:56 -07001179 * i_pages lock and mapping->host->i_lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 */
Harvey Harrisonfc9b52c2008-02-08 04:19:52 -08001181void mark_buffer_dirty(struct buffer_head *bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182{
Nick Piggin787d22142007-07-17 04:03:34 -07001183 WARN_ON_ONCE(!buffer_uptodate(bh));
Linus Torvalds1be62dc2008-04-04 14:38:17 -07001184
Tejun Heo5305cb82013-01-11 13:06:36 -08001185 trace_block_dirty_buffer(bh);
1186
Linus Torvalds1be62dc2008-04-04 14:38:17 -07001187 /*
1188 * Very *carefully* optimize the it-is-already-dirty case.
1189 *
1190 * Don't let the final "is it dirty" escape to before we
1191 * perhaps modified the buffer.
1192 */
1193 if (buffer_dirty(bh)) {
1194 smp_mb();
1195 if (buffer_dirty(bh))
1196 return;
1197 }
1198
Linus Torvaldsa8e7d492009-03-19 11:32:05 -07001199 if (!test_set_buffer_dirty(bh)) {
Matthew Wilcox (Oracle)cf1d3412022-12-15 21:43:57 +00001200 struct folio *folio = bh->b_folio;
Greg Thelenc4843a72015-05-22 17:13:16 -04001201 struct address_space *mapping = NULL;
Greg Thelenc4843a72015-05-22 17:13:16 -04001202
Matthew Wilcox (Oracle)cf1d3412022-12-15 21:43:57 +00001203 folio_memcg_lock(folio);
1204 if (!folio_test_set_dirty(folio)) {
1205 mapping = folio->mapping;
Linus Torvalds8e9d78e2009-08-21 17:40:08 -07001206 if (mapping)
Matthew Wilcox (Oracle)cf1d3412022-12-15 21:43:57 +00001207 __folio_mark_dirty(folio, mapping, 0);
Linus Torvalds8e9d78e2009-08-21 17:40:08 -07001208 }
Matthew Wilcox (Oracle)cf1d3412022-12-15 21:43:57 +00001209 folio_memcg_unlock(folio);
Greg Thelenc4843a72015-05-22 17:13:16 -04001210 if (mapping)
1211 __mark_inode_dirty(mapping->host, I_DIRTY_PAGES);
Linus Torvaldsa8e7d492009-03-19 11:32:05 -07001212 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213}
H Hartley Sweeten1fe72ea2009-09-22 16:43:51 -07001214EXPORT_SYMBOL(mark_buffer_dirty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215
Jeff Layton87354e52017-07-06 07:02:21 -04001216void mark_buffer_write_io_error(struct buffer_head *bh)
1217{
1218 set_buffer_write_io_error(bh);
1219 /* FIXME: do we need to set this in both places? */
Matthew Wilcox (Oracle)abc8a8a2022-12-15 21:43:52 +00001220 if (bh->b_folio && bh->b_folio->mapping)
1221 mapping_set_error(bh->b_folio->mapping, -EIO);
Christoph Hellwig4b2201d2023-08-07 12:26:22 +01001222 if (bh->b_assoc_map) {
Jeff Layton87354e52017-07-06 07:02:21 -04001223 mapping_set_error(bh->b_assoc_map, -EIO);
Christoph Hellwig4b2201d2023-08-07 12:26:22 +01001224 errseq_set(&bh->b_assoc_map->host->i_sb->s_wb_err, -EIO);
1225 }
Jeff Layton87354e52017-07-06 07:02:21 -04001226}
1227EXPORT_SYMBOL(mark_buffer_write_io_error);
1228
Matthew Wilcox (Oracle)66924fd2024-04-16 04:17:49 +01001229/**
1230 * __brelse - Release a buffer.
1231 * @bh: The buffer to release.
1232 *
1233 * This variant of brelse() can be called if @bh is guaranteed to not be NULL.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 */
Matthew Wilcox (Oracle)66924fd2024-04-16 04:17:49 +01001235void __brelse(struct buffer_head *bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236{
Matthew Wilcox (Oracle)66924fd2024-04-16 04:17:49 +01001237 if (atomic_read(&bh->b_count)) {
1238 put_bh(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 return;
1240 }
Arjan van de Ven5c752ad2008-07-25 19:45:40 -07001241 WARN(1, KERN_ERR "VFS: brelse: Trying to free free buffer\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242}
H Hartley Sweeten1fe72ea2009-09-22 16:43:51 -07001243EXPORT_SYMBOL(__brelse);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244
Matthew Wilcox (Oracle)b73a9362024-04-16 04:17:50 +01001245/**
1246 * __bforget - Discard any dirty data in a buffer.
1247 * @bh: The buffer to forget.
1248 *
1249 * This variant of bforget() can be called if @bh is guaranteed to not
1250 * be NULL.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251 */
1252void __bforget(struct buffer_head *bh)
1253{
1254 clear_buffer_dirty(bh);
Jan Kara535ee2f2008-02-08 04:21:59 -08001255 if (bh->b_assoc_map) {
Matthew Wilcox (Oracle)abc8a8a2022-12-15 21:43:52 +00001256 struct address_space *buffer_mapping = bh->b_folio->mapping;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +00001258 spin_lock(&buffer_mapping->i_private_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 list_del_init(&bh->b_assoc_buffers);
Jan Kara58ff407b2006-10-17 00:10:19 -07001260 bh->b_assoc_map = NULL;
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +00001261 spin_unlock(&buffer_mapping->i_private_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 }
1263 __brelse(bh);
1264}
H Hartley Sweeten1fe72ea2009-09-22 16:43:51 -07001265EXPORT_SYMBOL(__bforget);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266
1267static struct buffer_head *__bread_slow(struct buffer_head *bh)
1268{
1269 lock_buffer(bh);
1270 if (buffer_uptodate(bh)) {
1271 unlock_buffer(bh);
1272 return bh;
1273 } else {
1274 get_bh(bh);
1275 bh->b_end_io = end_buffer_read_sync;
Bart Van Assche1420c4a52022-07-14 11:07:13 -07001276 submit_bh(REQ_OP_READ, bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 wait_on_buffer(bh);
1278 if (buffer_uptodate(bh))
1279 return bh;
1280 }
1281 brelse(bh);
1282 return NULL;
1283}
1284
1285/*
1286 * Per-cpu buffer LRU implementation. To reduce the cost of __find_get_block().
1287 * The bhs[] array is sorted - newest buffer is at bhs[0]. Buffers have their
1288 * refcount elevated by one when they're in an LRU. A buffer can only appear
1289 * once in a particular CPU's LRU. A single buffer can be present in multiple
1290 * CPU's LRUs at the same time.
1291 *
1292 * This is a transparent caching front-end to sb_bread(), sb_getblk() and
1293 * sb_find_get_block().
1294 *
1295 * The LRUs themselves only need locking against invalidate_bh_lrus. We use
1296 * a local interrupt disable for that.
1297 */
1298
Sebastien Buisson86cf78d2014-10-09 15:29:38 -07001299#define BH_LRU_SIZE 16
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300
1301struct bh_lru {
1302 struct buffer_head *bhs[BH_LRU_SIZE];
1303};
1304
1305static DEFINE_PER_CPU(struct bh_lru, bh_lrus) = {{ NULL }};
1306
1307#ifdef CONFIG_SMP
1308#define bh_lru_lock() local_irq_disable()
1309#define bh_lru_unlock() local_irq_enable()
1310#else
1311#define bh_lru_lock() preempt_disable()
1312#define bh_lru_unlock() preempt_enable()
1313#endif
1314
1315static inline void check_irqs_on(void)
1316{
1317#ifdef irqs_disabled
1318 BUG_ON(irqs_disabled());
1319#endif
1320}
1321
1322/*
Eric Biggers241f01f2017-07-10 15:47:29 -07001323 * Install a buffer_head into this cpu's LRU. If not already in the LRU, it is
1324 * inserted at the front, and the buffer_head at the back if any is evicted.
1325 * Or, if already in the LRU it is moved to the front.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 */
1327static void bh_lru_install(struct buffer_head *bh)
1328{
Eric Biggers241f01f2017-07-10 15:47:29 -07001329 struct buffer_head *evictee = bh;
1330 struct bh_lru *b;
1331 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332
1333 check_irqs_on();
Minchan Kimc0226eb2022-03-22 14:39:34 -07001334 bh_lru_lock();
1335
Minchan Kim8cc621d2021-05-04 18:37:00 -07001336 /*
1337 * the refcount of buffer_head in bh_lru prevents dropping the
1338 * attached page(i.e., try_to_free_buffers) so it could cause
1339 * failing page migration.
1340 * Skip putting upcoming bh into bh_lru until migration is done.
1341 */
Marcelo Tosatti8a237ad2023-06-27 17:08:15 -03001342 if (lru_cache_disabled() || cpu_is_isolated(smp_processor_id())) {
Minchan Kimc0226eb2022-03-22 14:39:34 -07001343 bh_lru_unlock();
Minchan Kim8cc621d2021-05-04 18:37:00 -07001344 return;
Minchan Kimc0226eb2022-03-22 14:39:34 -07001345 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346
Eric Biggers241f01f2017-07-10 15:47:29 -07001347 b = this_cpu_ptr(&bh_lrus);
1348 for (i = 0; i < BH_LRU_SIZE; i++) {
1349 swap(evictee, b->bhs[i]);
1350 if (evictee == bh) {
1351 bh_lru_unlock();
1352 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355
Eric Biggers241f01f2017-07-10 15:47:29 -07001356 get_bh(bh);
1357 bh_lru_unlock();
1358 brelse(evictee);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359}
1360
1361/*
1362 * Look up the bh in this cpu's LRU. If it's there, move it to the head.
1363 */
Arjan van de Ven858119e2006-01-14 13:20:43 -08001364static struct buffer_head *
Tomasz Kvarsin3991d3b2007-02-12 00:52:14 -08001365lookup_bh_lru(struct block_device *bdev, sector_t block, unsigned size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366{
1367 struct buffer_head *ret = NULL;
Tomasz Kvarsin3991d3b2007-02-12 00:52:14 -08001368 unsigned int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369
1370 check_irqs_on();
1371 bh_lru_lock();
Marcelo Tosatti8a237ad2023-06-27 17:08:15 -03001372 if (cpu_is_isolated(smp_processor_id())) {
1373 bh_lru_unlock();
1374 return NULL;
1375 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 for (i = 0; i < BH_LRU_SIZE; i++) {
Christoph Lameterc7b92512010-12-06 11:16:28 -06001377 struct buffer_head *bh = __this_cpu_read(bh_lrus.bhs[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378
Zach Brown9470dd52014-10-13 15:55:05 -07001379 if (bh && bh->b_blocknr == block && bh->b_bdev == bdev &&
1380 bh->b_size == size) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 if (i) {
1382 while (i) {
Christoph Lameterc7b92512010-12-06 11:16:28 -06001383 __this_cpu_write(bh_lrus.bhs[i],
1384 __this_cpu_read(bh_lrus.bhs[i - 1]));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 i--;
1386 }
Christoph Lameterc7b92512010-12-06 11:16:28 -06001387 __this_cpu_write(bh_lrus.bhs[0], bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 }
1389 get_bh(bh);
1390 ret = bh;
1391 break;
1392 }
1393 }
1394 bh_lru_unlock();
1395 return ret;
1396}
1397
1398/*
1399 * Perform a pagecache lookup for the matching buffer. If it's there, refresh
1400 * it in the LRU and mark it as accessed. If it is not present then return
1401 * NULL
1402 */
1403struct buffer_head *
Tomasz Kvarsin3991d3b2007-02-12 00:52:14 -08001404__find_get_block(struct block_device *bdev, sector_t block, unsigned size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405{
1406 struct buffer_head *bh = lookup_bh_lru(bdev, block, size);
1407
1408 if (bh == NULL) {
Mel Gorman2457aec2014-06-04 16:10:31 -07001409 /* __find_get_block_slow will mark the page accessed */
Coywolf Qi Hunt385fd4c2005-11-07 00:59:39 -08001410 bh = __find_get_block_slow(bdev, block);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 if (bh)
1412 bh_lru_install(bh);
Mel Gorman2457aec2014-06-04 16:10:31 -07001413 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 touch_buffer(bh);
Mel Gorman2457aec2014-06-04 16:10:31 -07001415
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 return bh;
1417}
1418EXPORT_SYMBOL(__find_get_block);
1419
Matthew Wilcox (Oracle)3ed65f02023-09-14 16:00:05 +01001420/**
1421 * bdev_getblk - Get a buffer_head in a block device's buffer cache.
1422 * @bdev: The block device.
1423 * @block: The block number.
1424 * @size: The size of buffer_heads for this @bdev.
1425 * @gfp: The memory allocation flags to use.
1426 *
Matthew Wilcox (Oracle)0b116ff2024-04-16 04:17:51 +01001427 * The returned buffer head has its reference count incremented, but is
1428 * not locked. The caller should call brelse() when it has finished
1429 * with the buffer. The buffer may not be uptodate. If needed, the
1430 * caller can bring it uptodate either by reading it or overwriting it.
1431 *
Matthew Wilcox (Oracle)3ed65f02023-09-14 16:00:05 +01001432 * Return: The buffer head, or NULL if memory could not be allocated.
1433 */
1434struct buffer_head *bdev_getblk(struct block_device *bdev, sector_t block,
1435 unsigned size, gfp_t gfp)
1436{
1437 struct buffer_head *bh = __find_get_block(bdev, block, size);
1438
1439 might_alloc(gfp);
1440 if (bh)
1441 return bh;
1442
1443 return __getblk_slow(bdev, block, size, gfp);
1444}
1445EXPORT_SYMBOL(bdev_getblk);
1446
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 * Do async read-ahead on a buffer..
1449 */
Tomasz Kvarsin3991d3b2007-02-12 00:52:14 -08001450void __breadahead(struct block_device *bdev, sector_t block, unsigned size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451{
Matthew Wilcox (Oracle)775d9b12023-09-14 16:00:07 +01001452 struct buffer_head *bh = bdev_getblk(bdev, block, size,
1453 GFP_NOWAIT | __GFP_MOVABLE);
1454
Andrew Mortona3e713b2005-10-30 15:03:15 -08001455 if (likely(bh)) {
Zhang Yie7ea1122022-09-01 21:34:54 +08001456 bh_readahead(bh, REQ_RAHEAD);
Andrew Mortona3e713b2005-10-30 15:03:15 -08001457 brelse(bh);
1458 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459}
1460EXPORT_SYMBOL(__breadahead);
1461
1462/**
Matthew Wilcox (Oracle)324ecae2024-04-16 04:17:48 +01001463 * __bread_gfp() - Read a block.
1464 * @bdev: The block device to read from.
1465 * @block: Block number in units of block size.
1466 * @size: The block size of this device in bytes.
1467 * @gfp: Not page allocation flags; see below.
Gioh Kim3b5e6452014-09-04 22:04:42 -04001468 *
Matthew Wilcox (Oracle)324ecae2024-04-16 04:17:48 +01001469 * You are not expected to call this function. You should use one of
1470 * sb_bread(), sb_bread_unmovable() or __bread().
1471 *
1472 * Read a specified block, and return the buffer head that refers to it.
1473 * If @gfp is 0, the memory will be allocated using the block device's
1474 * default GFP flags. If @gfp is __GFP_MOVABLE, the memory may be
1475 * allocated from a movable area. Do not pass in a complete set of
1476 * GFP flags.
1477 *
1478 * The returned buffer head has its refcount increased. The caller should
1479 * call brelse() when it has finished with the buffer.
1480 *
1481 * Context: May sleep waiting for I/O.
1482 * Return: NULL if the block was unreadable.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483 */
Matthew Wilcox (Oracle)324ecae2024-04-16 04:17:48 +01001484struct buffer_head *__bread_gfp(struct block_device *bdev, sector_t block,
1485 unsigned size, gfp_t gfp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486{
Matthew Wilcox (Oracle)93b13ec2023-09-14 16:00:11 +01001487 struct buffer_head *bh;
1488
Al Viro224941e2024-04-11 15:53:37 +01001489 gfp |= mapping_gfp_constraint(bdev->bd_mapping, ~__GFP_FS);
Matthew Wilcox (Oracle)93b13ec2023-09-14 16:00:11 +01001490
1491 /*
1492 * Prefer looping in the allocator rather than here, at least that
1493 * code knows what it's doing.
1494 */
1495 gfp |= __GFP_NOFAIL;
1496
1497 bh = bdev_getblk(bdev, block, size, gfp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498
Andrew Mortona3e713b2005-10-30 15:03:15 -08001499 if (likely(bh) && !buffer_uptodate(bh))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500 bh = __bread_slow(bh);
1501 return bh;
1502}
Gioh Kim3b5e6452014-09-04 22:04:42 -04001503EXPORT_SYMBOL(__bread_gfp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504
Minchan Kim8cc621d2021-05-04 18:37:00 -07001505static void __invalidate_bh_lrus(struct bh_lru *b)
1506{
1507 int i;
1508
1509 for (i = 0; i < BH_LRU_SIZE; i++) {
1510 brelse(b->bhs[i]);
1511 b->bhs[i] = NULL;
1512 }
1513}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514/*
1515 * invalidate_bh_lrus() is called rarely - but not only at unmount.
1516 * This doesn't race because it runs in each cpu either in irq
1517 * or with preempt disabled.
1518 */
1519static void invalidate_bh_lru(void *arg)
1520{
1521 struct bh_lru *b = &get_cpu_var(bh_lrus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522
Minchan Kim8cc621d2021-05-04 18:37:00 -07001523 __invalidate_bh_lrus(b);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524 put_cpu_var(bh_lrus);
1525}
Gilad Ben-Yossef42be35d2012-03-28 14:42:45 -07001526
Minchan Kim8cc621d2021-05-04 18:37:00 -07001527bool has_bh_in_lru(int cpu, void *dummy)
Gilad Ben-Yossef42be35d2012-03-28 14:42:45 -07001528{
1529 struct bh_lru *b = per_cpu_ptr(&bh_lrus, cpu);
1530 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531
Gilad Ben-Yossef42be35d2012-03-28 14:42:45 -07001532 for (i = 0; i < BH_LRU_SIZE; i++) {
1533 if (b->bhs[i])
Saurav Girepunje1d706672019-11-30 17:49:15 -08001534 return true;
Gilad Ben-Yossef42be35d2012-03-28 14:42:45 -07001535 }
1536
Saurav Girepunje1d706672019-11-30 17:49:15 -08001537 return false;
Gilad Ben-Yossef42be35d2012-03-28 14:42:45 -07001538}
1539
Peter Zijlstraf9a14392007-05-06 14:49:55 -07001540void invalidate_bh_lrus(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541{
Sebastian Andrzej Siewiorcb923152020-01-17 10:01:37 +01001542 on_each_cpu_cond(has_bh_in_lru, invalidate_bh_lru, NULL, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543}
Nick Piggin9db55792008-02-08 04:19:49 -08001544EXPORT_SYMBOL_GPL(invalidate_bh_lrus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545
Minchan Kim243418e2021-09-24 15:43:47 -07001546/*
1547 * It's called from workqueue context so we need a bh_lru_lock to close
1548 * the race with preemption/irq.
1549 */
1550void invalidate_bh_lrus_cpu(void)
Minchan Kim8cc621d2021-05-04 18:37:00 -07001551{
1552 struct bh_lru *b;
1553
1554 bh_lru_lock();
Minchan Kim243418e2021-09-24 15:43:47 -07001555 b = this_cpu_ptr(&bh_lrus);
Minchan Kim8cc621d2021-05-04 18:37:00 -07001556 __invalidate_bh_lrus(b);
1557 bh_lru_unlock();
1558}
1559
Pankaj Raghav465e5e62023-04-17 14:36:15 +02001560void folio_set_bh(struct buffer_head *bh, struct folio *folio,
1561 unsigned long offset)
1562{
1563 bh->b_folio = folio;
1564 BUG_ON(offset >= folio_size(folio));
1565 if (folio_test_highmem(folio))
1566 /*
1567 * This catches illegal uses and preserves the offset:
1568 */
1569 bh->b_data = (char *)(0 + offset);
1570 else
1571 bh->b_data = folio_address(folio) + offset;
1572}
1573EXPORT_SYMBOL(folio_set_bh);
1574
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575/*
1576 * Called when truncating a buffer on a page completely.
1577 */
Mel Gormane7470ee2014-06-04 16:10:29 -07001578
1579/* Bits that are cleared during an invalidate */
1580#define BUFFER_FLAGS_DISCARD \
1581 (1 << BH_Mapped | 1 << BH_New | 1 << BH_Req | \
1582 1 << BH_Delay | 1 << BH_Unwritten)
1583
Arjan van de Ven858119e2006-01-14 13:20:43 -08001584static void discard_buffer(struct buffer_head * bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585{
Uros Bizjakb0192292022-07-14 19:16:53 +02001586 unsigned long b_state;
Mel Gormane7470ee2014-06-04 16:10:29 -07001587
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588 lock_buffer(bh);
1589 clear_buffer_dirty(bh);
1590 bh->b_bdev = NULL;
Uros Bizjakb0192292022-07-14 19:16:53 +02001591 b_state = READ_ONCE(bh->b_state);
1592 do {
1593 } while (!try_cmpxchg(&bh->b_state, &b_state,
1594 b_state & ~BUFFER_FLAGS_DISCARD));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595 unlock_buffer(bh);
1596}
1597
1598/**
Matthew Wilcox (Oracle)7ba13ab2022-02-09 20:21:34 +00001599 * block_invalidate_folio - Invalidate part or all of a buffer-backed folio.
1600 * @folio: The folio which is affected.
Lukas Czernerd47992f2013-05-21 23:17:23 -04001601 * @offset: start of the range to invalidate
1602 * @length: length of the range to invalidate
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603 *
Matthew Wilcox (Oracle)7ba13ab2022-02-09 20:21:34 +00001604 * block_invalidate_folio() is called when all or part of the folio has been
Wang Sheng-Hui814e1d22011-09-01 08:22:57 +08001605 * invalidated by a truncate operation.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 *
Matthew Wilcox (Oracle)7ba13ab2022-02-09 20:21:34 +00001607 * block_invalidate_folio() does not have to release all buffers, but it must
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608 * ensure that no dirty buffer is left outside @offset and that no I/O
1609 * is underway against any of the blocks which are outside the truncation
1610 * point. Because the caller is about to free (and possibly reuse) those
1611 * blocks on-disk.
1612 */
Matthew Wilcox (Oracle)7ba13ab2022-02-09 20:21:34 +00001613void block_invalidate_folio(struct folio *folio, size_t offset, size_t length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614{
1615 struct buffer_head *head, *bh, *next;
Matthew Wilcox (Oracle)7ba13ab2022-02-09 20:21:34 +00001616 size_t curr_off = 0;
1617 size_t stop = length + offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618
Matthew Wilcox (Oracle)7ba13ab2022-02-09 20:21:34 +00001619 BUG_ON(!folio_test_locked(folio));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620
Lukas Czernerd47992f2013-05-21 23:17:23 -04001621 /*
1622 * Check for overflow
1623 */
Matthew Wilcox (Oracle)7ba13ab2022-02-09 20:21:34 +00001624 BUG_ON(stop > folio_size(folio) || stop < length);
Lukas Czernerd47992f2013-05-21 23:17:23 -04001625
Matthew Wilcox (Oracle)7ba13ab2022-02-09 20:21:34 +00001626 head = folio_buffers(folio);
1627 if (!head)
1628 return;
1629
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 bh = head;
1631 do {
Matthew Wilcox (Oracle)7ba13ab2022-02-09 20:21:34 +00001632 size_t next_off = curr_off + bh->b_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 next = bh->b_this_page;
1634
1635 /*
Lukas Czernerd47992f2013-05-21 23:17:23 -04001636 * Are we still fully in range ?
1637 */
1638 if (next_off > stop)
1639 goto out;
1640
1641 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 * is this block fully invalidated?
1643 */
1644 if (offset <= curr_off)
1645 discard_buffer(bh);
1646 curr_off = next_off;
1647 bh = next;
1648 } while (bh != head);
1649
1650 /*
Matthew Wilcox (Oracle)7ba13ab2022-02-09 20:21:34 +00001651 * We release buffers only if the entire folio is being invalidated.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 * The get_block cached value has been unconditionally invalidated,
1653 * so real IO is not possible anymore.
1654 */
Matthew Wilcox (Oracle)7ba13ab2022-02-09 20:21:34 +00001655 if (length == folio_size(folio))
1656 filemap_release_folio(folio, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657out:
NeilBrown2ff28e22006-03-26 01:37:18 -08001658 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659}
Matthew Wilcox (Oracle)7ba13ab2022-02-09 20:21:34 +00001660EXPORT_SYMBOL(block_invalidate_folio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661
1662/*
1663 * We attach and possibly dirty the buffers atomically wrt
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +00001664 * block_dirty_folio() via i_private_lock. try_to_free_buffers
Pankaj Raghav8e2e1752023-04-17 14:36:17 +02001665 * is already excluded via the folio lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 */
Matthew Wilcox (Oracle)0a888102023-10-16 21:11:14 +01001667struct buffer_head *create_empty_buffers(struct folio *folio,
Matthew Wilcox (Oracle)3decb852023-10-16 21:10:49 +01001668 unsigned long blocksize, unsigned long b_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669{
1670 struct buffer_head *bh, *head, *tail;
Matthew Wilcox (Oracle)2a418152023-09-14 16:00:04 +01001671 gfp_t gfp = GFP_NOFS | __GFP_ACCOUNT | __GFP_NOFAIL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672
Matthew Wilcox (Oracle)2a418152023-09-14 16:00:04 +01001673 head = folio_alloc_buffers(folio, blocksize, gfp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 bh = head;
1675 do {
1676 bh->b_state |= b_state;
1677 tail = bh;
1678 bh = bh->b_this_page;
1679 } while (bh);
1680 tail->b_this_page = head;
1681
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +00001682 spin_lock(&folio->mapping->i_private_lock);
Pankaj Raghav8e2e1752023-04-17 14:36:17 +02001683 if (folio_test_uptodate(folio) || folio_test_dirty(folio)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684 bh = head;
1685 do {
Pankaj Raghav8e2e1752023-04-17 14:36:17 +02001686 if (folio_test_dirty(folio))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687 set_buffer_dirty(bh);
Pankaj Raghav8e2e1752023-04-17 14:36:17 +02001688 if (folio_test_uptodate(folio))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 set_buffer_uptodate(bh);
1690 bh = bh->b_this_page;
1691 } while (bh != head);
1692 }
Pankaj Raghav8e2e1752023-04-17 14:36:17 +02001693 folio_attach_private(folio, head);
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +00001694 spin_unlock(&folio->mapping->i_private_lock);
Matthew Wilcox (Oracle)3decb852023-10-16 21:10:49 +01001695
1696 return head;
Pankaj Raghav8e2e1752023-04-17 14:36:17 +02001697}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698EXPORT_SYMBOL(create_empty_buffers);
1699
Jan Kara29f3ad72016-11-04 18:08:11 +01001700/**
1701 * clean_bdev_aliases: clean a range of buffers in block device
1702 * @bdev: Block device to clean buffers in
1703 * @block: Start of a range of blocks to clean
1704 * @len: Number of blocks to clean
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705 *
Jan Kara29f3ad72016-11-04 18:08:11 +01001706 * We are taking a range of blocks for data and we don't want writeback of any
1707 * buffer-cache aliases starting from return from this function and until the
1708 * moment when something will explicitly mark the buffer dirty (hopefully that
1709 * will not happen until we will free that block ;-) We don't even need to mark
1710 * it not-uptodate - nobody can expect anything from a newly allocated buffer
1711 * anyway. We used to use unmap_buffer() for such invalidation, but that was
1712 * wrong. We definitely don't want to mark the alias unmapped, for example - it
1713 * would confuse anyone who might pick it with bread() afterwards...
1714 *
1715 * Also.. Note that bforget() doesn't lock the buffer. So there can be
1716 * writeout I/O going on against recently-freed buffers. We don't wait on that
1717 * I/O in bforget() - it's more efficient to wait on the I/O only if we really
1718 * need to. That happens here.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 */
Jan Kara29f3ad72016-11-04 18:08:11 +01001720void clean_bdev_aliases(struct block_device *bdev, sector_t block, sector_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721{
Al Viro53cd4cd2024-04-28 19:41:13 -04001722 struct address_space *bd_mapping = bdev->bd_mapping;
1723 const int blkbits = bd_mapping->host->i_blkbits;
Matthew Wilcox (Oracle)9e0b6f32022-06-04 16:24:22 -04001724 struct folio_batch fbatch;
Al Viro53cd4cd2024-04-28 19:41:13 -04001725 pgoff_t index = ((loff_t)block << blkbits) / PAGE_SIZE;
Jan Kara29f3ad72016-11-04 18:08:11 +01001726 pgoff_t end;
Jan Karac10f7782017-09-06 16:21:24 -07001727 int i, count;
Jan Kara29f3ad72016-11-04 18:08:11 +01001728 struct buffer_head *bh;
1729 struct buffer_head *head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730
Al Viro53cd4cd2024-04-28 19:41:13 -04001731 end = ((loff_t)(block + len - 1) << blkbits) / PAGE_SIZE;
Matthew Wilcox (Oracle)9e0b6f32022-06-04 16:24:22 -04001732 folio_batch_init(&fbatch);
1733 while (filemap_get_folios(bd_mapping, &index, end, &fbatch)) {
1734 count = folio_batch_count(&fbatch);
Jan Karac10f7782017-09-06 16:21:24 -07001735 for (i = 0; i < count; i++) {
Matthew Wilcox (Oracle)9e0b6f32022-06-04 16:24:22 -04001736 struct folio *folio = fbatch.folios[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737
Matthew Wilcox (Oracle)9e0b6f32022-06-04 16:24:22 -04001738 if (!folio_buffers(folio))
Jan Kara29f3ad72016-11-04 18:08:11 +01001739 continue;
1740 /*
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +00001741 * We use folio lock instead of bd_mapping->i_private_lock
Jan Kara29f3ad72016-11-04 18:08:11 +01001742 * to pin buffers here since we can afford to sleep and
1743 * it scales better than a global spinlock lock.
1744 */
Matthew Wilcox (Oracle)9e0b6f32022-06-04 16:24:22 -04001745 folio_lock(folio);
1746 /* Recheck when the folio is locked which pins bhs */
1747 head = folio_buffers(folio);
1748 if (!head)
Jan Kara29f3ad72016-11-04 18:08:11 +01001749 goto unlock_page;
Jan Kara29f3ad72016-11-04 18:08:11 +01001750 bh = head;
1751 do {
Chandan Rajendra6c006a92016-12-25 19:01:03 +05301752 if (!buffer_mapped(bh) || (bh->b_blocknr < block))
Jan Kara29f3ad72016-11-04 18:08:11 +01001753 goto next;
1754 if (bh->b_blocknr >= block + len)
1755 break;
1756 clear_buffer_dirty(bh);
1757 wait_on_buffer(bh);
1758 clear_buffer_req(bh);
1759next:
1760 bh = bh->b_this_page;
1761 } while (bh != head);
1762unlock_page:
Matthew Wilcox (Oracle)9e0b6f32022-06-04 16:24:22 -04001763 folio_unlock(folio);
Jan Kara29f3ad72016-11-04 18:08:11 +01001764 }
Matthew Wilcox (Oracle)9e0b6f32022-06-04 16:24:22 -04001765 folio_batch_release(&fbatch);
Jan Kara29f3ad72016-11-04 18:08:11 +01001766 cond_resched();
Jan Karac10f7782017-09-06 16:21:24 -07001767 /* End of range already reached? */
1768 if (index > end || !index)
1769 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770 }
1771}
Jan Kara29f3ad72016-11-04 18:08:11 +01001772EXPORT_SYMBOL(clean_bdev_aliases);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773
Pankaj Raghavc6c8c3e2023-04-17 14:36:18 +02001774static struct buffer_head *folio_create_buffers(struct folio *folio,
1775 struct inode *inode,
1776 unsigned int b_state)
Linus Torvalds45bce8f2012-11-29 10:21:43 -08001777{
Matthew Wilcox (Oracle)3decb852023-10-16 21:10:49 +01001778 struct buffer_head *bh;
1779
Pankaj Raghavc6c8c3e2023-04-17 14:36:18 +02001780 BUG_ON(!folio_test_locked(folio));
Linus Torvalds45bce8f2012-11-29 10:21:43 -08001781
Matthew Wilcox (Oracle)3decb852023-10-16 21:10:49 +01001782 bh = folio_buffers(folio);
1783 if (!bh)
Matthew Wilcox (Oracle)0a888102023-10-16 21:11:14 +01001784 bh = create_empty_buffers(folio,
Matthew Wilcox (Oracle)3decb852023-10-16 21:10:49 +01001785 1 << READ_ONCE(inode->i_blkbits), b_state);
1786 return bh;
Linus Torvalds45bce8f2012-11-29 10:21:43 -08001787}
1788
1789/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 * NOTE! All mapped/uptodate combinations are valid:
1791 *
1792 * Mapped Uptodate Meaning
1793 *
1794 * No No "unknown" - must do get_block()
1795 * No Yes "hole" - zero-filled
1796 * Yes No "allocated" - allocated on disk, not read in
1797 * Yes Yes "valid" - allocated and up-to-date in memory.
1798 *
1799 * "Dirty" is valid only with the last case (mapped+uptodate).
1800 */
1801
1802/*
Matthew Wilcox (Oracle)17bf23a2023-12-15 20:02:44 +00001803 * While block_write_full_folio is writing back the dirty buffers under
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804 * the page lock, whoever dirtied the buffers may decide to clean them
1805 * again at any time. We handle that by only looking at the buffer
1806 * state inside lock_buffer().
1807 *
Matthew Wilcox (Oracle)17bf23a2023-12-15 20:02:44 +00001808 * If block_write_full_folio() is called for regular writeback
Linus Torvalds1da177e2005-04-16 15:20:36 -07001809 * (wbc->sync_mode == WB_SYNC_NONE) then it will redirty a page which has a
1810 * locked buffer. This only can happen if someone has written the buffer
1811 * directly, with submit_bh(). At the address_space level PageWriteback
1812 * prevents this contention from occurring.
Theodore Ts'o6e34eedd2009-04-07 18:12:43 -04001813 *
Matthew Wilcox (Oracle)17bf23a2023-12-15 20:02:44 +00001814 * If block_write_full_folio() is called with wbc->sync_mode ==
Christoph Hellwig70fd7612016-11-01 07:40:10 -06001815 * WB_SYNC_ALL, the writes are posted using REQ_SYNC; this
Jens Axboe721a9602011-03-09 11:56:30 +01001816 * causes the writes to be flagged as synchronous writes.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 */
Matthew Wilcox (Oracle)53418a12023-06-12 22:01:31 +01001818int __block_write_full_folio(struct inode *inode, struct folio *folio,
Matthew Wilcox (Oracle)14059f62023-12-15 20:02:45 +00001819 get_block_t *get_block, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820{
1821 int err;
1822 sector_t block;
1823 sector_t last_block;
Andrew Mortonf0fbd5f2005-05-05 16:15:48 -07001824 struct buffer_head *bh, *head;
Matthew Wilcox (Oracle)fa399c32023-11-09 21:06:08 +00001825 size_t blocksize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 int nr_underway = 0;
Bart Van Assche3ae72862022-07-14 11:07:12 -07001827 blk_opf_t write_flags = wbc_to_write_flags(wbc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828
Matthew Wilcox (Oracle)53418a12023-06-12 22:01:31 +01001829 head = folio_create_buffers(folio, inode,
Pankaj Raghavc6c8c3e2023-04-17 14:36:18 +02001830 (1 << BH_Dirty) | (1 << BH_Uptodate));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831
1832 /*
Matthew Wilcox (Oracle)e6219002022-02-09 20:22:12 +00001833 * Be very careful. We have no exclusion from block_dirty_folio
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834 * here, and the (potentially unmapped) buffers may become dirty at
1835 * any time. If a buffer becomes dirty here after we've inspected it
Matthew Wilcox (Oracle)53418a12023-06-12 22:01:31 +01001836 * then we just miss that fact, and the folio stays dirty.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837 *
Matthew Wilcox (Oracle)e6219002022-02-09 20:22:12 +00001838 * Buffers outside i_size may be dirtied by block_dirty_folio;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 * handle that here by just cleaning them.
1840 */
1841
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842 bh = head;
Linus Torvalds45bce8f2012-11-29 10:21:43 -08001843 blocksize = bh->b_size;
Linus Torvalds45bce8f2012-11-29 10:21:43 -08001844
Matthew Wilcox (Oracle)fa399c32023-11-09 21:06:08 +00001845 block = div_u64(folio_pos(folio), blocksize);
1846 last_block = div_u64(i_size_read(inode) - 1, blocksize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847
1848 /*
1849 * Get all the dirty buffers mapped to disk addresses and
1850 * handle any aliases from the underlying blockdev's mapping.
1851 */
1852 do {
1853 if (block > last_block) {
1854 /*
1855 * mapped buffers outside i_size will occur, because
Matthew Wilcox (Oracle)53418a12023-06-12 22:01:31 +01001856 * this folio can be outside i_size when there is a
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857 * truncate in progress.
1858 */
1859 /*
Matthew Wilcox (Oracle)17bf23a2023-12-15 20:02:44 +00001860 * The buffer was zeroed by block_write_full_folio()
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861 */
1862 clear_buffer_dirty(bh);
1863 set_buffer_uptodate(bh);
Alex Tomas29a814d2008-07-11 19:27:31 -04001864 } else if ((!buffer_mapped(bh) || buffer_delay(bh)) &&
1865 buffer_dirty(bh)) {
Badari Pulavartyb0cf2322006-03-26 01:38:00 -08001866 WARN_ON(bh->b_size != blocksize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 err = get_block(inode, block, bh, 1);
1868 if (err)
1869 goto recover;
Alex Tomas29a814d2008-07-11 19:27:31 -04001870 clear_buffer_delay(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871 if (buffer_new(bh)) {
1872 /* blockdev mappings never come here */
1873 clear_buffer_new(bh);
Jan Karae64855c2016-11-04 18:08:15 +01001874 clean_bdev_bh_alias(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 }
1876 }
1877 bh = bh->b_this_page;
1878 block++;
1879 } while (bh != head);
1880
1881 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882 if (!buffer_mapped(bh))
1883 continue;
1884 /*
1885 * If it's a fully non-blocking write attempt and we cannot
Matthew Wilcox (Oracle)53418a12023-06-12 22:01:31 +01001886 * lock the buffer then redirty the folio. Note that this can
Jens Axboe5b0830c2009-09-23 19:37:09 +02001887 * potentially cause a busy-wait loop from writeback threads
1888 * and kswapd activity, but those code paths have their own
1889 * higher-level throttling.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 */
Wu Fengguang1b430be2010-10-26 14:21:26 -07001891 if (wbc->sync_mode != WB_SYNC_NONE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 lock_buffer(bh);
Nick Pigginca5de402008-08-02 12:02:13 +02001893 } else if (!trylock_buffer(bh)) {
Matthew Wilcox (Oracle)53418a12023-06-12 22:01:31 +01001894 folio_redirty_for_writepage(wbc, folio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895 continue;
1896 }
1897 if (test_clear_buffer_dirty(bh)) {
Matthew Wilcox (Oracle)14059f62023-12-15 20:02:45 +00001898 mark_buffer_async_write_endio(bh,
1899 end_buffer_async_write);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 } else {
1901 unlock_buffer(bh);
1902 }
1903 } while ((bh = bh->b_this_page) != head);
1904
1905 /*
Matthew Wilcox (Oracle)53418a12023-06-12 22:01:31 +01001906 * The folio and its buffers are protected by the writeback flag,
1907 * so we can drop the bh refcounts early.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908 */
Matthew Wilcox (Oracle)53418a12023-06-12 22:01:31 +01001909 BUG_ON(folio_test_writeback(folio));
1910 folio_start_writeback(folio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911
1912 do {
1913 struct buffer_head *next = bh->b_this_page;
1914 if (buffer_async_write(bh)) {
Bart Van Assche44981352024-02-02 12:39:25 -08001915 submit_bh_wbc(REQ_OP_WRITE | write_flags, bh,
1916 inode->i_write_hint, wbc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917 nr_underway++;
1918 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919 bh = next;
1920 } while (bh != head);
Matthew Wilcox (Oracle)53418a12023-06-12 22:01:31 +01001921 folio_unlock(folio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922
1923 err = 0;
1924done:
1925 if (nr_underway == 0) {
1926 /*
Matthew Wilcox (Oracle)53418a12023-06-12 22:01:31 +01001927 * The folio was marked dirty, but the buffers were
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 * clean. Someone wrote them back by hand with
Zhang Yi79f59782022-09-01 21:35:03 +08001929 * write_dirty_buffer/submit_bh. A rare case.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 */
Matthew Wilcox (Oracle)53418a12023-06-12 22:01:31 +01001931 folio_end_writeback(folio);
Nick Piggin3d67f2d2007-05-06 14:49:05 -07001932
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933 /*
Matthew Wilcox (Oracle)53418a12023-06-12 22:01:31 +01001934 * The folio and buffer_heads can be released at any time from
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 * here on.
1936 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 }
1938 return err;
1939
1940recover:
1941 /*
1942 * ENOSPC, or some other error. We may already have added some
1943 * blocks to the file, so we need to write these out to avoid
1944 * exposing stale data.
Matthew Wilcox (Oracle)53418a12023-06-12 22:01:31 +01001945 * The folio is currently locked and not marked for writeback
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946 */
1947 bh = head;
1948 /* Recovery: lock and submit the mapped buffers */
1949 do {
Alex Tomas29a814d2008-07-11 19:27:31 -04001950 if (buffer_mapped(bh) && buffer_dirty(bh) &&
1951 !buffer_delay(bh)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952 lock_buffer(bh);
Matthew Wilcox (Oracle)14059f62023-12-15 20:02:45 +00001953 mark_buffer_async_write_endio(bh,
1954 end_buffer_async_write);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955 } else {
1956 /*
1957 * The buffer may have been set dirty during
Matthew Wilcox (Oracle)53418a12023-06-12 22:01:31 +01001958 * attachment to a dirty folio.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959 */
1960 clear_buffer_dirty(bh);
1961 }
1962 } while ((bh = bh->b_this_page) != head);
Matthew Wilcox (Oracle)53418a12023-06-12 22:01:31 +01001963 folio_set_error(folio);
1964 BUG_ON(folio_test_writeback(folio));
1965 mapping_set_error(folio->mapping, err);
1966 folio_start_writeback(folio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967 do {
1968 struct buffer_head *next = bh->b_this_page;
1969 if (buffer_async_write(bh)) {
1970 clear_buffer_dirty(bh);
Bart Van Assche44981352024-02-02 12:39:25 -08001971 submit_bh_wbc(REQ_OP_WRITE | write_flags, bh,
1972 inode->i_write_hint, wbc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973 nr_underway++;
1974 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975 bh = next;
1976 } while (bh != head);
Matthew Wilcox (Oracle)53418a12023-06-12 22:01:31 +01001977 folio_unlock(folio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978 goto done;
1979}
Matthew Wilcox (Oracle)53418a12023-06-12 22:01:31 +01001980EXPORT_SYMBOL(__block_write_full_folio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981
Nick Pigginafddba42007-10-16 01:25:01 -07001982/*
Matthew Wilcox (Oracle)4a9622f2023-06-12 22:01:36 +01001983 * If a folio has any new buffers, zero them out here, and mark them uptodate
Nick Pigginafddba42007-10-16 01:25:01 -07001984 * and dirty so they'll be written out (in order to prevent uninitialised
1985 * block data from leaking). And clear the new bit.
1986 */
Matthew Wilcox (Oracle)4a9622f2023-06-12 22:01:36 +01001987void folio_zero_new_buffers(struct folio *folio, size_t from, size_t to)
Nick Pigginafddba42007-10-16 01:25:01 -07001988{
Matthew Wilcox (Oracle)4a9622f2023-06-12 22:01:36 +01001989 size_t block_start, block_end;
Nick Pigginafddba42007-10-16 01:25:01 -07001990 struct buffer_head *head, *bh;
1991
Matthew Wilcox (Oracle)4a9622f2023-06-12 22:01:36 +01001992 BUG_ON(!folio_test_locked(folio));
1993 head = folio_buffers(folio);
1994 if (!head)
Nick Pigginafddba42007-10-16 01:25:01 -07001995 return;
1996
Matthew Wilcox (Oracle)4a9622f2023-06-12 22:01:36 +01001997 bh = head;
Nick Pigginafddba42007-10-16 01:25:01 -07001998 block_start = 0;
1999 do {
2000 block_end = block_start + bh->b_size;
2001
2002 if (buffer_new(bh)) {
2003 if (block_end > from && block_start < to) {
Matthew Wilcox (Oracle)4a9622f2023-06-12 22:01:36 +01002004 if (!folio_test_uptodate(folio)) {
2005 size_t start, xend;
Nick Pigginafddba42007-10-16 01:25:01 -07002006
2007 start = max(from, block_start);
Matthew Wilcox (Oracle)4a9622f2023-06-12 22:01:36 +01002008 xend = min(to, block_end);
Nick Pigginafddba42007-10-16 01:25:01 -07002009
Matthew Wilcox (Oracle)4a9622f2023-06-12 22:01:36 +01002010 folio_zero_segment(folio, start, xend);
Nick Pigginafddba42007-10-16 01:25:01 -07002011 set_buffer_uptodate(bh);
2012 }
2013
2014 clear_buffer_new(bh);
2015 mark_buffer_dirty(bh);
2016 }
2017 }
2018
2019 block_start = block_end;
2020 bh = bh->b_this_page;
2021 } while (bh != head);
2022}
Matthew Wilcox (Oracle)4a9622f2023-06-12 22:01:36 +01002023EXPORT_SYMBOL(folio_zero_new_buffers);
Nick Pigginafddba42007-10-16 01:25:01 -07002024
Christoph Hellwig4aa8cdd2023-09-12 10:05:48 -07002025static int
Christoph Hellwigae259a92016-06-21 09:23:11 +10002026iomap_to_bh(struct inode *inode, sector_t block, struct buffer_head *bh,
Christoph Hellwig6d49cc82021-08-10 18:33:05 -07002027 const struct iomap *iomap)
Christoph Hellwigae259a92016-06-21 09:23:11 +10002028{
Matthew Wilcox (Oracle)80844192023-11-09 21:06:05 +00002029 loff_t offset = (loff_t)block << inode->i_blkbits;
Christoph Hellwigae259a92016-06-21 09:23:11 +10002030
2031 bh->b_bdev = iomap->bdev;
2032
2033 /*
2034 * Block points to offset in file we need to map, iomap contains
2035 * the offset at which the map starts. If the map ends before the
2036 * current block, then do not map the buffer and let the caller
2037 * handle it.
2038 */
Christoph Hellwig4aa8cdd2023-09-12 10:05:48 -07002039 if (offset >= iomap->offset + iomap->length)
2040 return -EIO;
Christoph Hellwigae259a92016-06-21 09:23:11 +10002041
2042 switch (iomap->type) {
2043 case IOMAP_HOLE:
2044 /*
2045 * If the buffer is not up to date or beyond the current EOF,
2046 * we need to mark it as new to ensure sub-block zeroing is
2047 * executed if necessary.
2048 */
2049 if (!buffer_uptodate(bh) ||
2050 (offset >= i_size_read(inode)))
2051 set_buffer_new(bh);
Christoph Hellwig4aa8cdd2023-09-12 10:05:48 -07002052 return 0;
Christoph Hellwigae259a92016-06-21 09:23:11 +10002053 case IOMAP_DELALLOC:
2054 if (!buffer_uptodate(bh) ||
2055 (offset >= i_size_read(inode)))
2056 set_buffer_new(bh);
2057 set_buffer_uptodate(bh);
2058 set_buffer_mapped(bh);
2059 set_buffer_delay(bh);
Christoph Hellwig4aa8cdd2023-09-12 10:05:48 -07002060 return 0;
Christoph Hellwigae259a92016-06-21 09:23:11 +10002061 case IOMAP_UNWRITTEN:
2062 /*
Andreas Gruenbacher3d7b6b212018-06-19 15:10:55 -07002063 * For unwritten regions, we always need to ensure that regions
2064 * in the block we are not writing to are zeroed. Mark the
2065 * buffer as new to ensure this.
Christoph Hellwigae259a92016-06-21 09:23:11 +10002066 */
2067 set_buffer_new(bh);
2068 set_buffer_unwritten(bh);
Gustavo A. R. Silvadf561f662020-08-23 17:36:59 -05002069 fallthrough;
Christoph Hellwigae259a92016-06-21 09:23:11 +10002070 case IOMAP_MAPPED:
Andreas Gruenbacher3d7b6b212018-06-19 15:10:55 -07002071 if ((iomap->flags & IOMAP_F_NEW) ||
Christoph Hellwig381c0432023-09-25 08:54:45 -07002072 offset >= i_size_read(inode)) {
2073 /*
2074 * This can happen if truncating the block device races
2075 * with the check in the caller as i_size updates on
2076 * block devices aren't synchronized by i_rwsem for
2077 * block devices.
2078 */
2079 if (S_ISBLK(inode->i_mode))
2080 return -EIO;
Christoph Hellwigae259a92016-06-21 09:23:11 +10002081 set_buffer_new(bh);
Christoph Hellwig381c0432023-09-25 08:54:45 -07002082 }
Andreas Gruenbacher19fe5f62017-10-01 17:55:54 -04002083 bh->b_blocknr = (iomap->addr + offset - iomap->offset) >>
2084 inode->i_blkbits;
Christoph Hellwigae259a92016-06-21 09:23:11 +10002085 set_buffer_mapped(bh);
Christoph Hellwig4aa8cdd2023-09-12 10:05:48 -07002086 return 0;
2087 default:
2088 WARN_ON_ONCE(1);
2089 return -EIO;
Christoph Hellwigae259a92016-06-21 09:23:11 +10002090 }
2091}
2092
Matthew Wilcox (Oracle)d1bd0b42021-11-03 14:05:47 -04002093int __block_write_begin_int(struct folio *folio, loff_t pos, unsigned len,
Christoph Hellwig6d49cc82021-08-10 18:33:05 -07002094 get_block_t *get_block, const struct iomap *iomap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095{
Matthew Wilcox (Oracle)b0619402023-11-09 21:06:07 +00002096 size_t from = offset_in_folio(folio, pos);
2097 size_t to = from + len;
Matthew Wilcox (Oracle)d1bd0b42021-11-03 14:05:47 -04002098 struct inode *inode = folio->mapping->host;
Matthew Wilcox (Oracle)b0619402023-11-09 21:06:07 +00002099 size_t block_start, block_end;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002100 sector_t block;
2101 int err = 0;
Matthew Wilcox (Oracle)b0619402023-11-09 21:06:07 +00002102 size_t blocksize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103 struct buffer_head *bh, *head, *wait[2], **wait_bh=wait;
2104
Matthew Wilcox (Oracle)d1bd0b42021-11-03 14:05:47 -04002105 BUG_ON(!folio_test_locked(folio));
Matthew Wilcox (Oracle)b0619402023-11-09 21:06:07 +00002106 BUG_ON(to > folio_size(folio));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107 BUG_ON(from > to);
2108
Pankaj Raghavc6c8c3e2023-04-17 14:36:18 +02002109 head = folio_create_buffers(folio, inode, 0);
Linus Torvalds45bce8f2012-11-29 10:21:43 -08002110 blocksize = head->b_size;
Matthew Wilcox (Oracle)b0619402023-11-09 21:06:07 +00002111 block = div_u64(folio_pos(folio), blocksize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112
Matthew Wilcox (Oracle)b0619402023-11-09 21:06:07 +00002113 for (bh = head, block_start = 0; bh != head || !block_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114 block++, block_start=block_end, bh = bh->b_this_page) {
2115 block_end = block_start + blocksize;
2116 if (block_end <= from || block_start >= to) {
Matthew Wilcox (Oracle)d1bd0b42021-11-03 14:05:47 -04002117 if (folio_test_uptodate(folio)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118 if (!buffer_uptodate(bh))
2119 set_buffer_uptodate(bh);
2120 }
2121 continue;
2122 }
2123 if (buffer_new(bh))
2124 clear_buffer_new(bh);
2125 if (!buffer_mapped(bh)) {
Badari Pulavartyb0cf2322006-03-26 01:38:00 -08002126 WARN_ON(bh->b_size != blocksize);
Christoph Hellwig4aa8cdd2023-09-12 10:05:48 -07002127 if (get_block)
Christoph Hellwigae259a92016-06-21 09:23:11 +10002128 err = get_block(inode, block, bh, 1);
Christoph Hellwig4aa8cdd2023-09-12 10:05:48 -07002129 else
2130 err = iomap_to_bh(inode, block, bh, iomap);
2131 if (err)
2132 break;
Christoph Hellwigae259a92016-06-21 09:23:11 +10002133
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134 if (buffer_new(bh)) {
Jan Karae64855c2016-11-04 18:08:15 +01002135 clean_bdev_bh_alias(bh);
Matthew Wilcox (Oracle)d1bd0b42021-11-03 14:05:47 -04002136 if (folio_test_uptodate(folio)) {
Nick Piggin637aff42007-10-16 01:25:00 -07002137 clear_buffer_new(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138 set_buffer_uptodate(bh);
Nick Piggin637aff42007-10-16 01:25:00 -07002139 mark_buffer_dirty(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140 continue;
2141 }
Christoph Lametereebd2aa2008-02-04 22:28:29 -08002142 if (block_end > to || block_start < from)
Matthew Wilcox (Oracle)d1bd0b42021-11-03 14:05:47 -04002143 folio_zero_segments(folio,
Christoph Lametereebd2aa2008-02-04 22:28:29 -08002144 to, block_end,
2145 block_start, from);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002146 continue;
2147 }
2148 }
Matthew Wilcox (Oracle)d1bd0b42021-11-03 14:05:47 -04002149 if (folio_test_uptodate(folio)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150 if (!buffer_uptodate(bh))
2151 set_buffer_uptodate(bh);
2152 continue;
2153 }
2154 if (!buffer_uptodate(bh) && !buffer_delay(bh) &&
David Chinner33a266d2007-02-12 00:51:41 -08002155 !buffer_unwritten(bh) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156 (block_start < from || block_end > to)) {
Zhang Yie7ea1122022-09-01 21:34:54 +08002157 bh_read_nowait(bh, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158 *wait_bh++=bh;
2159 }
2160 }
2161 /*
2162 * If we issued read requests - let them complete.
2163 */
2164 while(wait_bh > wait) {
2165 wait_on_buffer(*--wait_bh);
2166 if (!buffer_uptodate(*wait_bh))
Nick Pigginf3ddbdc2005-05-05 16:15:45 -07002167 err = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168 }
Jan Karaf9f07b62011-06-14 00:58:27 +02002169 if (unlikely(err))
Matthew Wilcox (Oracle)4a9622f2023-06-12 22:01:36 +01002170 folio_zero_new_buffers(folio, from, to);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002171 return err;
2172}
Christoph Hellwigae259a92016-06-21 09:23:11 +10002173
2174int __block_write_begin(struct page *page, loff_t pos, unsigned len,
2175 get_block_t *get_block)
2176{
Matthew Wilcox (Oracle)d1bd0b42021-11-03 14:05:47 -04002177 return __block_write_begin_int(page_folio(page), pos, len, get_block,
2178 NULL);
Christoph Hellwigae259a92016-06-21 09:23:11 +10002179}
Christoph Hellwigebdec242010-10-06 10:47:23 +02002180EXPORT_SYMBOL(__block_write_begin);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002181
Bean Huoa524fcf2023-06-26 07:55:18 +02002182static void __block_commit_write(struct folio *folio, size_t from, size_t to)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183{
Matthew Wilcox (Oracle)8c6cb3e2023-06-12 22:01:35 +01002184 size_t block_start, block_end;
2185 bool partial = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002186 unsigned blocksize;
2187 struct buffer_head *bh, *head;
2188
Matthew Wilcox (Oracle)8c6cb3e2023-06-12 22:01:35 +01002189 bh = head = folio_buffers(folio);
Linus Torvalds45bce8f2012-11-29 10:21:43 -08002190 blocksize = bh->b_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191
Linus Torvalds45bce8f2012-11-29 10:21:43 -08002192 block_start = 0;
2193 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002194 block_end = block_start + blocksize;
2195 if (block_end <= from || block_start >= to) {
2196 if (!buffer_uptodate(bh))
Matthew Wilcox (Oracle)8c6cb3e2023-06-12 22:01:35 +01002197 partial = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002198 } else {
2199 set_buffer_uptodate(bh);
2200 mark_buffer_dirty(bh);
2201 }
Yang Guo4ebd3ae2021-02-24 12:02:48 -08002202 if (buffer_new(bh))
2203 clear_buffer_new(bh);
Linus Torvalds45bce8f2012-11-29 10:21:43 -08002204
2205 block_start = block_end;
2206 bh = bh->b_this_page;
2207 } while (bh != head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208
2209 /*
2210 * If this is a partial write which happened to make all buffers
Matthew Wilcox (Oracle)2c69e202022-04-29 10:40:40 -04002211 * uptodate then we can optimize away a bogus read_folio() for
Matthew Wilcox (Oracle)8c6cb3e2023-06-12 22:01:35 +01002212 * the next read(). Here we 'discover' whether the folio went
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213 * uptodate as a result of this (potentially partial) write.
2214 */
2215 if (!partial)
Matthew Wilcox (Oracle)8c6cb3e2023-06-12 22:01:35 +01002216 folio_mark_uptodate(folio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217}
2218
2219/*
Christoph Hellwig155130a2010-06-04 11:29:58 +02002220 * block_write_begin takes care of the basic task of block allocation and
2221 * bringing partial write blocks uptodate first.
2222 *
npiggin@suse.de7bb46a62010-05-27 01:05:33 +10002223 * The filesystem needs to handle block truncation upon failure.
Nick Pigginafddba42007-10-16 01:25:01 -07002224 */
Christoph Hellwig155130a2010-06-04 11:29:58 +02002225int block_write_begin(struct address_space *mapping, loff_t pos, unsigned len,
Matthew Wilcox (Oracle)b3992d12022-02-22 11:25:12 -05002226 struct page **pagep, get_block_t *get_block)
Nick Pigginafddba42007-10-16 01:25:01 -07002227{
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002228 pgoff_t index = pos >> PAGE_SHIFT;
Nick Pigginafddba42007-10-16 01:25:01 -07002229 struct page *page;
Christoph Hellwig6e1db882010-06-04 11:29:57 +02002230 int status;
Nick Pigginafddba42007-10-16 01:25:01 -07002231
Matthew Wilcox (Oracle)b7446e72022-02-22 11:25:12 -05002232 page = grab_cache_page_write_begin(mapping, index);
Christoph Hellwig6e1db882010-06-04 11:29:57 +02002233 if (!page)
2234 return -ENOMEM;
Nick Pigginafddba42007-10-16 01:25:01 -07002235
Christoph Hellwig6e1db882010-06-04 11:29:57 +02002236 status = __block_write_begin(page, pos, len, get_block);
Nick Pigginafddba42007-10-16 01:25:01 -07002237 if (unlikely(status)) {
Christoph Hellwig6e1db882010-06-04 11:29:57 +02002238 unlock_page(page);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002239 put_page(page);
Christoph Hellwig6e1db882010-06-04 11:29:57 +02002240 page = NULL;
Nick Pigginafddba42007-10-16 01:25:01 -07002241 }
2242
Christoph Hellwig6e1db882010-06-04 11:29:57 +02002243 *pagep = page;
Nick Pigginafddba42007-10-16 01:25:01 -07002244 return status;
2245}
2246EXPORT_SYMBOL(block_write_begin);
2247
2248int block_write_end(struct file *file, struct address_space *mapping,
2249 loff_t pos, unsigned len, unsigned copied,
2250 struct page *page, void *fsdata)
2251{
Matthew Wilcox (Oracle)8c6cb3e2023-06-12 22:01:35 +01002252 struct folio *folio = page_folio(page);
Matthew Wilcox (Oracle)8c6cb3e2023-06-12 22:01:35 +01002253 size_t start = pos - folio_pos(folio);
Nick Pigginafddba42007-10-16 01:25:01 -07002254
2255 if (unlikely(copied < len)) {
2256 /*
Matthew Wilcox (Oracle)2c69e202022-04-29 10:40:40 -04002257 * The buffers that were written will now be uptodate, so
2258 * we don't have to worry about a read_folio reading them
2259 * and overwriting a partial write. However if we have
2260 * encountered a short write and only partially written
2261 * into a buffer, it will not be marked uptodate, so a
2262 * read_folio might come in and destroy our partial write.
Nick Pigginafddba42007-10-16 01:25:01 -07002263 *
2264 * Do the simplest thing, and just treat any short write to a
Matthew Wilcox (Oracle)8c6cb3e2023-06-12 22:01:35 +01002265 * non uptodate folio as a zero-length write, and force the
Nick Pigginafddba42007-10-16 01:25:01 -07002266 * caller to redo the whole thing.
2267 */
Matthew Wilcox (Oracle)8c6cb3e2023-06-12 22:01:35 +01002268 if (!folio_test_uptodate(folio))
Nick Pigginafddba42007-10-16 01:25:01 -07002269 copied = 0;
2270
Matthew Wilcox (Oracle)4a9622f2023-06-12 22:01:36 +01002271 folio_zero_new_buffers(folio, start+copied, start+len);
Nick Pigginafddba42007-10-16 01:25:01 -07002272 }
Matthew Wilcox (Oracle)8c6cb3e2023-06-12 22:01:35 +01002273 flush_dcache_folio(folio);
Nick Pigginafddba42007-10-16 01:25:01 -07002274
2275 /* This could be a short (even 0-length) commit */
Bean Huo489b7e72023-06-26 07:55:17 +02002276 __block_commit_write(folio, start, start + copied);
Nick Pigginafddba42007-10-16 01:25:01 -07002277
2278 return copied;
2279}
2280EXPORT_SYMBOL(block_write_end);
2281
2282int generic_write_end(struct file *file, struct address_space *mapping,
2283 loff_t pos, unsigned len, unsigned copied,
2284 struct page *page, void *fsdata)
2285{
Christoph Hellwig8af54f22019-06-27 17:28:40 -07002286 struct inode *inode = mapping->host;
2287 loff_t old_size = inode->i_size;
2288 bool i_size_changed = false;
2289
Nick Pigginafddba42007-10-16 01:25:01 -07002290 copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);
Christoph Hellwig8af54f22019-06-27 17:28:40 -07002291
2292 /*
2293 * No need to use i_size_read() here, the i_size cannot change under us
2294 * because we hold i_rwsem.
2295 *
2296 * But it's important to update i_size while still holding page lock:
2297 * page writeout could otherwise come in and zero beyond i_size.
2298 */
2299 if (pos + copied > inode->i_size) {
2300 i_size_write(inode, pos + copied);
2301 i_size_changed = true;
2302 }
2303
2304 unlock_page(page);
Andreas Gruenbacher7a77dad2019-04-30 08:45:34 -07002305 put_page(page);
Christoph Hellwig8af54f22019-06-27 17:28:40 -07002306
2307 if (old_size < pos)
2308 pagecache_isize_extended(inode, old_size, pos);
2309 /*
2310 * Don't mark the inode dirty under page lock. First, it unnecessarily
2311 * makes the holding time of page lock longer. Second, it forces lock
2312 * ordering of page lock and transaction start for journaling
2313 * filesystems.
2314 */
2315 if (i_size_changed)
2316 mark_inode_dirty(inode);
Andreas Gruenbacher26ddb1f2019-04-30 08:45:33 -07002317 return copied;
Nick Pigginafddba42007-10-16 01:25:01 -07002318}
2319EXPORT_SYMBOL(generic_write_end);
2320
2321/*
Matthew Wilcox (Oracle)2e7e80f2022-02-09 20:21:27 +00002322 * block_is_partially_uptodate checks whether buffers within a folio are
Hisashi Hifumi8ab22b92008-07-28 15:46:36 -07002323 * uptodate or not.
2324 *
Matthew Wilcox (Oracle)2e7e80f2022-02-09 20:21:27 +00002325 * Returns true if all buffers which correspond to the specified part
2326 * of the folio are uptodate.
Hisashi Hifumi8ab22b92008-07-28 15:46:36 -07002327 */
Matthew Wilcox (Oracle)2e7e80f2022-02-09 20:21:27 +00002328bool block_is_partially_uptodate(struct folio *folio, size_t from, size_t count)
Hisashi Hifumi8ab22b92008-07-28 15:46:36 -07002329{
Hisashi Hifumi8ab22b92008-07-28 15:46:36 -07002330 unsigned block_start, block_end, blocksize;
2331 unsigned to;
2332 struct buffer_head *bh, *head;
Matthew Wilcox (Oracle)2e7e80f2022-02-09 20:21:27 +00002333 bool ret = true;
Hisashi Hifumi8ab22b92008-07-28 15:46:36 -07002334
Matthew Wilcox (Oracle)2e7e80f2022-02-09 20:21:27 +00002335 head = folio_buffers(folio);
2336 if (!head)
2337 return false;
Linus Torvalds45bce8f2012-11-29 10:21:43 -08002338 blocksize = head->b_size;
Matthew Wilcox (Oracle)2e7e80f2022-02-09 20:21:27 +00002339 to = min_t(unsigned, folio_size(folio) - from, count);
Hisashi Hifumi8ab22b92008-07-28 15:46:36 -07002340 to = from + to;
Matthew Wilcox (Oracle)2e7e80f2022-02-09 20:21:27 +00002341 if (from < blocksize && to > folio_size(folio) - blocksize)
2342 return false;
Hisashi Hifumi8ab22b92008-07-28 15:46:36 -07002343
Hisashi Hifumi8ab22b92008-07-28 15:46:36 -07002344 bh = head;
2345 block_start = 0;
2346 do {
2347 block_end = block_start + blocksize;
2348 if (block_end > from && block_start < to) {
2349 if (!buffer_uptodate(bh)) {
Matthew Wilcox (Oracle)2e7e80f2022-02-09 20:21:27 +00002350 ret = false;
Hisashi Hifumi8ab22b92008-07-28 15:46:36 -07002351 break;
2352 }
2353 if (block_end >= to)
2354 break;
2355 }
2356 block_start = block_end;
2357 bh = bh->b_this_page;
2358 } while (bh != head);
2359
2360 return ret;
2361}
2362EXPORT_SYMBOL(block_is_partially_uptodate);
2363
2364/*
Matthew Wilcox (Oracle)2c69e202022-04-29 10:40:40 -04002365 * Generic "read_folio" function for block devices that have the normal
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366 * get_block functionality. This is most of the block device filesystems.
Matthew Wilcox (Oracle)2c69e202022-04-29 10:40:40 -04002367 * Reads the folio asynchronously --- the unlock_buffer() and
Linus Torvalds1da177e2005-04-16 15:20:36 -07002368 * set/clear_buffer_uptodate() functions propagate buffer state into the
Matthew Wilcox (Oracle)2c69e202022-04-29 10:40:40 -04002369 * folio once IO has completed.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002370 */
Matthew Wilcox (Oracle)2c69e202022-04-29 10:40:40 -04002371int block_read_full_folio(struct folio *folio, get_block_t *get_block)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002372{
Matthew Wilcox (Oracle)2c69e202022-04-29 10:40:40 -04002373 struct inode *inode = folio->mapping->host;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374 sector_t iblock, lblock;
2375 struct buffer_head *bh, *head, *arr[MAX_BUF_PER_PAGE];
Matthew Wilcox (Oracle)fa399c32023-11-09 21:06:08 +00002376 size_t blocksize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377 int nr, i;
2378 int fully_mapped = 1;
Matthew Wilcox (Oracle)b7a6eb22022-05-26 23:19:49 -04002379 bool page_error = false;
Eric Biggers4fa512c2022-12-23 12:36:37 -08002380 loff_t limit = i_size_read(inode);
2381
2382 /* This is needed for ext4. */
2383 if (IS_ENABLED(CONFIG_FS_VERITY) && IS_VERITY(inode))
2384 limit = inode->i_sb->s_maxbytes;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002385
Matthew Wilcox (Oracle)2c69e202022-04-29 10:40:40 -04002386 VM_BUG_ON_FOLIO(folio_test_large(folio), folio);
2387
Pankaj Raghavc6c8c3e2023-04-17 14:36:18 +02002388 head = folio_create_buffers(folio, inode, 0);
Linus Torvalds45bce8f2012-11-29 10:21:43 -08002389 blocksize = head->b_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002390
Matthew Wilcox (Oracle)fa399c32023-11-09 21:06:08 +00002391 iblock = div_u64(folio_pos(folio), blocksize);
2392 lblock = div_u64(limit + blocksize - 1, blocksize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002393 bh = head;
2394 nr = 0;
2395 i = 0;
2396
2397 do {
2398 if (buffer_uptodate(bh))
2399 continue;
2400
2401 if (!buffer_mapped(bh)) {
Andrew Mortonc64610b2005-05-16 21:53:49 -07002402 int err = 0;
2403
Linus Torvalds1da177e2005-04-16 15:20:36 -07002404 fully_mapped = 0;
2405 if (iblock < lblock) {
Badari Pulavartyb0cf2322006-03-26 01:38:00 -08002406 WARN_ON(bh->b_size != blocksize);
Andrew Mortonc64610b2005-05-16 21:53:49 -07002407 err = get_block(inode, iblock, bh, 0);
Matthew Wilcox (Oracle)b7a6eb22022-05-26 23:19:49 -04002408 if (err) {
Matthew Wilcox (Oracle)2c69e202022-04-29 10:40:40 -04002409 folio_set_error(folio);
Matthew Wilcox (Oracle)b7a6eb22022-05-26 23:19:49 -04002410 page_error = true;
2411 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002412 }
2413 if (!buffer_mapped(bh)) {
Matthew Wilcox (Oracle)2c69e202022-04-29 10:40:40 -04002414 folio_zero_range(folio, i * blocksize,
2415 blocksize);
Andrew Mortonc64610b2005-05-16 21:53:49 -07002416 if (!err)
2417 set_buffer_uptodate(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002418 continue;
2419 }
2420 /*
2421 * get_block() might have updated the buffer
2422 * synchronously
2423 */
2424 if (buffer_uptodate(bh))
2425 continue;
2426 }
2427 arr[nr++] = bh;
2428 } while (i++, iblock++, (bh = bh->b_this_page) != head);
2429
2430 if (fully_mapped)
Matthew Wilcox (Oracle)2c69e202022-04-29 10:40:40 -04002431 folio_set_mappedtodisk(folio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002432
2433 if (!nr) {
2434 /*
Matthew Wilcox (Oracle)6ba924d2023-10-04 17:53:05 +01002435 * All buffers are uptodate or get_block() returned an
2436 * error when trying to map them - we can finish the read.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002437 */
Matthew Wilcox (Oracle)6ba924d2023-10-04 17:53:05 +01002438 folio_end_read(folio, !page_error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002439 return 0;
2440 }
2441
2442 /* Stage two: lock the buffers */
2443 for (i = 0; i < nr; i++) {
2444 bh = arr[i];
2445 lock_buffer(bh);
2446 mark_buffer_async_read(bh);
2447 }
2448
2449 /*
2450 * Stage 3: start the IO. Check for uptodateness
2451 * inside the buffer lock in case another process reading
2452 * the underlying blockdev brought it uptodate (the sct fix).
2453 */
2454 for (i = 0; i < nr; i++) {
2455 bh = arr[i];
2456 if (buffer_uptodate(bh))
2457 end_buffer_async_read(bh, 1);
2458 else
Bart Van Assche1420c4a52022-07-14 11:07:13 -07002459 submit_bh(REQ_OP_READ, bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002460 }
2461 return 0;
2462}
Matthew Wilcox (Oracle)2c69e202022-04-29 10:40:40 -04002463EXPORT_SYMBOL(block_read_full_folio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002464
2465/* utility function for filesystems that need to do work on expanding
Nick Piggin89e10782007-10-16 01:25:07 -07002466 * truncates. Uses filesystem pagecache writes to allow the filesystem to
Linus Torvalds1da177e2005-04-16 15:20:36 -07002467 * deal with the hole.
2468 */
Nick Piggin89e10782007-10-16 01:25:07 -07002469int generic_cont_expand_simple(struct inode *inode, loff_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002470{
2471 struct address_space *mapping = inode->i_mapping;
Matthew Wilcox (Oracle)53b524b2022-03-03 13:35:20 -05002472 const struct address_space_operations *aops = mapping->a_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002473 struct page *page;
Alexander Potapenko1468c6f2022-09-15 17:04:16 +02002474 void *fsdata = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475 int err;
2476
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10002477 err = inode_newsize_ok(inode, size);
2478 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002479 goto out;
2480
Matthew Wilcox (Oracle)53b524b2022-03-03 13:35:20 -05002481 err = aops->write_begin(NULL, mapping, size, 0, &page, &fsdata);
Nick Piggin89e10782007-10-16 01:25:07 -07002482 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002483 goto out;
OGAWA Hirofumi05eb0b52006-01-08 01:02:13 -08002484
Matthew Wilcox (Oracle)53b524b2022-03-03 13:35:20 -05002485 err = aops->write_end(NULL, mapping, size, 0, 0, page, fsdata);
Nick Piggin89e10782007-10-16 01:25:07 -07002486 BUG_ON(err > 0);
OGAWA Hirofumi05eb0b52006-01-08 01:02:13 -08002487
Linus Torvalds1da177e2005-04-16 15:20:36 -07002488out:
2489 return err;
2490}
H Hartley Sweeten1fe72ea2009-09-22 16:43:51 -07002491EXPORT_SYMBOL(generic_cont_expand_simple);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002492
Adrian Bunkf1e3af72008-04-29 00:59:01 -07002493static int cont_expand_zero(struct file *file, struct address_space *mapping,
2494 loff_t pos, loff_t *bytes)
OGAWA Hirofumi05eb0b52006-01-08 01:02:13 -08002495{
Nick Piggin89e10782007-10-16 01:25:07 -07002496 struct inode *inode = mapping->host;
Matthew Wilcox (Oracle)53b524b2022-03-03 13:35:20 -05002497 const struct address_space_operations *aops = mapping->a_ops;
Fabian Frederick93407472017-02-27 14:28:32 -08002498 unsigned int blocksize = i_blocksize(inode);
Nick Piggin89e10782007-10-16 01:25:07 -07002499 struct page *page;
Alexander Potapenko1468c6f2022-09-15 17:04:16 +02002500 void *fsdata = NULL;
Nick Piggin89e10782007-10-16 01:25:07 -07002501 pgoff_t index, curidx;
2502 loff_t curpos;
2503 unsigned zerofrom, offset, len;
2504 int err = 0;
OGAWA Hirofumi05eb0b52006-01-08 01:02:13 -08002505
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002506 index = pos >> PAGE_SHIFT;
2507 offset = pos & ~PAGE_MASK;
Nick Piggin89e10782007-10-16 01:25:07 -07002508
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002509 while (index > (curidx = (curpos = *bytes)>>PAGE_SHIFT)) {
2510 zerofrom = curpos & ~PAGE_MASK;
Nick Piggin89e10782007-10-16 01:25:07 -07002511 if (zerofrom & (blocksize-1)) {
2512 *bytes |= (blocksize-1);
2513 (*bytes)++;
2514 }
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002515 len = PAGE_SIZE - zerofrom;
Nick Piggin89e10782007-10-16 01:25:07 -07002516
Matthew Wilcox (Oracle)53b524b2022-03-03 13:35:20 -05002517 err = aops->write_begin(file, mapping, curpos, len,
Tetsuo Handac718a972017-05-08 15:58:59 -07002518 &page, &fsdata);
Nick Piggin89e10782007-10-16 01:25:07 -07002519 if (err)
2520 goto out;
Christoph Lametereebd2aa2008-02-04 22:28:29 -08002521 zero_user(page, zerofrom, len);
Matthew Wilcox (Oracle)53b524b2022-03-03 13:35:20 -05002522 err = aops->write_end(file, mapping, curpos, len, len,
Nick Piggin89e10782007-10-16 01:25:07 -07002523 page, fsdata);
2524 if (err < 0)
2525 goto out;
2526 BUG_ON(err != len);
2527 err = 0;
OGAWA Hirofumi061e9742008-04-28 02:16:28 -07002528
2529 balance_dirty_pages_ratelimited(mapping);
Mikulas Patockac2ca0fc2014-07-27 13:00:41 -04002530
Davidlohr Bueso08d405c2019-01-03 15:28:58 -08002531 if (fatal_signal_pending(current)) {
Mikulas Patockac2ca0fc2014-07-27 13:00:41 -04002532 err = -EINTR;
2533 goto out;
2534 }
Nick Piggin89e10782007-10-16 01:25:07 -07002535 }
2536
2537 /* page covers the boundary, find the boundary offset */
2538 if (index == curidx) {
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002539 zerofrom = curpos & ~PAGE_MASK;
Nick Piggin89e10782007-10-16 01:25:07 -07002540 /* if we will expand the thing last block will be filled */
2541 if (offset <= zerofrom) {
2542 goto out;
2543 }
2544 if (zerofrom & (blocksize-1)) {
2545 *bytes |= (blocksize-1);
2546 (*bytes)++;
2547 }
2548 len = offset - zerofrom;
2549
Matthew Wilcox (Oracle)53b524b2022-03-03 13:35:20 -05002550 err = aops->write_begin(file, mapping, curpos, len,
Tetsuo Handac718a972017-05-08 15:58:59 -07002551 &page, &fsdata);
Nick Piggin89e10782007-10-16 01:25:07 -07002552 if (err)
2553 goto out;
Christoph Lametereebd2aa2008-02-04 22:28:29 -08002554 zero_user(page, zerofrom, len);
Matthew Wilcox (Oracle)53b524b2022-03-03 13:35:20 -05002555 err = aops->write_end(file, mapping, curpos, len, len,
Nick Piggin89e10782007-10-16 01:25:07 -07002556 page, fsdata);
2557 if (err < 0)
2558 goto out;
2559 BUG_ON(err != len);
2560 err = 0;
2561 }
2562out:
2563 return err;
OGAWA Hirofumi05eb0b52006-01-08 01:02:13 -08002564}
2565
Linus Torvalds1da177e2005-04-16 15:20:36 -07002566/*
2567 * For moronic filesystems that do not allow holes in file.
2568 * We may have to extend the file.
2569 */
Christoph Hellwig282dc172010-06-04 11:29:55 +02002570int cont_write_begin(struct file *file, struct address_space *mapping,
Matthew Wilcox (Oracle)be3bbbc2022-02-22 11:25:12 -05002571 loff_t pos, unsigned len,
Nick Piggin89e10782007-10-16 01:25:07 -07002572 struct page **pagep, void **fsdata,
2573 get_block_t *get_block, loff_t *bytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002574{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002575 struct inode *inode = mapping->host;
Fabian Frederick93407472017-02-27 14:28:32 -08002576 unsigned int blocksize = i_blocksize(inode);
2577 unsigned int zerofrom;
Nick Piggin89e10782007-10-16 01:25:07 -07002578 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002579
Nick Piggin89e10782007-10-16 01:25:07 -07002580 err = cont_expand_zero(file, mapping, pos, bytes);
2581 if (err)
Christoph Hellwig155130a2010-06-04 11:29:58 +02002582 return err;
Nick Piggin89e10782007-10-16 01:25:07 -07002583
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002584 zerofrom = *bytes & ~PAGE_MASK;
Nick Piggin89e10782007-10-16 01:25:07 -07002585 if (pos+len > *bytes && zerofrom & (blocksize-1)) {
2586 *bytes |= (blocksize-1);
2587 (*bytes)++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002588 }
2589
Matthew Wilcox (Oracle)b3992d12022-02-22 11:25:12 -05002590 return block_write_begin(mapping, pos, len, pagep, get_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002591}
H Hartley Sweeten1fe72ea2009-09-22 16:43:51 -07002592EXPORT_SYMBOL(cont_write_begin);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002593
Bean Huoa524fcf2023-06-26 07:55:18 +02002594void block_commit_write(struct page *page, unsigned from, unsigned to)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002595{
Matthew Wilcox (Oracle)8c6cb3e2023-06-12 22:01:35 +01002596 struct folio *folio = page_folio(page);
Bean Huo489b7e72023-06-26 07:55:17 +02002597 __block_commit_write(folio, from, to);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002598}
H Hartley Sweeten1fe72ea2009-09-22 16:43:51 -07002599EXPORT_SYMBOL(block_commit_write);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002600
David Chinner54171692007-07-19 17:39:55 +10002601/*
2602 * block_page_mkwrite() is not allowed to change the file size as it gets
2603 * called from a page fault handler when a page is first dirtied. Hence we must
2604 * be careful to check for EOF conditions here. We set the page up correctly
2605 * for a written page which means we get ENOSPC checking when writing into
2606 * holes and correct delalloc and unwritten extent mapping on filesystems that
2607 * support these features.
2608 *
2609 * We are not allowed to take the i_mutex here so we have to play games to
2610 * protect against truncate races as the page could now be beyond EOF. Because
npiggin@suse.de7bb46a62010-05-27 01:05:33 +10002611 * truncate writes the inode size before removing pages, once we have the
David Chinner54171692007-07-19 17:39:55 +10002612 * page lock we can determine safely if the page is beyond EOF. If it is not
2613 * beyond EOF, then the page is guaranteed safe against truncation until we
2614 * unlock the page.
Jan Karaea13a862011-05-24 00:23:35 +02002615 *
Jan Kara14da9202012-06-12 16:20:37 +02002616 * Direct callers of this function should protect against filesystem freezing
Ross Zwisler5c500022015-10-13 16:51:02 -06002617 * using sb_start_pagefault() - sb_end_pagefault() functions.
David Chinner54171692007-07-19 17:39:55 +10002618 */
Ross Zwisler5c500022015-10-13 16:51:02 -06002619int block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf,
Jan Kara24da4fa2011-05-24 00:23:34 +02002620 get_block_t get_block)
David Chinner54171692007-07-19 17:39:55 +10002621{
Matthew Wilcox (Oracle)fe181372023-06-12 22:01:34 +01002622 struct folio *folio = page_folio(vmf->page);
Al Viro496ad9a2013-01-23 17:07:38 -05002623 struct inode *inode = file_inode(vma->vm_file);
David Chinner54171692007-07-19 17:39:55 +10002624 unsigned long end;
2625 loff_t size;
Jan Kara24da4fa2011-05-24 00:23:34 +02002626 int ret;
David Chinner54171692007-07-19 17:39:55 +10002627
Matthew Wilcox (Oracle)fe181372023-06-12 22:01:34 +01002628 folio_lock(folio);
David Chinner54171692007-07-19 17:39:55 +10002629 size = i_size_read(inode);
Matthew Wilcox (Oracle)fe181372023-06-12 22:01:34 +01002630 if ((folio->mapping != inode->i_mapping) ||
2631 (folio_pos(folio) >= size)) {
Jan Kara24da4fa2011-05-24 00:23:34 +02002632 /* We overload EFAULT to mean page got truncated */
2633 ret = -EFAULT;
2634 goto out_unlock;
David Chinner54171692007-07-19 17:39:55 +10002635 }
2636
Matthew Wilcox (Oracle)fe181372023-06-12 22:01:34 +01002637 end = folio_size(folio);
2638 /* folio is wholly or partially inside EOF */
2639 if (folio_pos(folio) + end > size)
2640 end = size - folio_pos(folio);
David Chinner54171692007-07-19 17:39:55 +10002641
Matthew Wilcox (Oracle)fe181372023-06-12 22:01:34 +01002642 ret = __block_write_begin_int(folio, 0, end, get_block, NULL);
Bean Huoa524fcf2023-06-26 07:55:18 +02002643 if (unlikely(ret))
Jan Kara24da4fa2011-05-24 00:23:34 +02002644 goto out_unlock;
Bean Huoa524fcf2023-06-26 07:55:18 +02002645
2646 __block_commit_write(folio, 0, end);
2647
Matthew Wilcox (Oracle)fe181372023-06-12 22:01:34 +01002648 folio_mark_dirty(folio);
2649 folio_wait_stable(folio);
Jan Kara24da4fa2011-05-24 00:23:34 +02002650 return 0;
2651out_unlock:
Matthew Wilcox (Oracle)fe181372023-06-12 22:01:34 +01002652 folio_unlock(folio);
David Chinner54171692007-07-19 17:39:55 +10002653 return ret;
2654}
H Hartley Sweeten1fe72ea2009-09-22 16:43:51 -07002655EXPORT_SYMBOL(block_page_mkwrite);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002656
Linus Torvalds1da177e2005-04-16 15:20:36 -07002657int block_truncate_page(struct address_space *mapping,
2658 loff_t from, get_block_t *get_block)
2659{
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002660 pgoff_t index = from >> PAGE_SHIFT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002661 unsigned blocksize;
Andrew Morton54b21a72006-01-08 01:03:05 -08002662 sector_t iblock;
Matthew Wilcox (Oracle)6d68f642023-06-12 22:01:41 +01002663 size_t offset, length, pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002664 struct inode *inode = mapping->host;
Matthew Wilcox (Oracle)6d68f642023-06-12 22:01:41 +01002665 struct folio *folio;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002666 struct buffer_head *bh;
Jiapeng Chongdc7cb2d2023-03-23 10:32:59 +08002667 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002668
Fabian Frederick93407472017-02-27 14:28:32 -08002669 blocksize = i_blocksize(inode);
Matthew Wilcox (Oracle)6d68f642023-06-12 22:01:41 +01002670 length = from & (blocksize - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002671
2672 /* Block boundary? Nothing to do */
2673 if (!length)
2674 return 0;
2675
2676 length = blocksize - length;
Matthew Wilcox (Oracle)4b046462023-11-09 21:06:06 +00002677 iblock = ((loff_t)index * PAGE_SIZE) >> inode->i_blkbits;
2678
Matthew Wilcox (Oracle)6d68f642023-06-12 22:01:41 +01002679 folio = filemap_grab_folio(mapping, index);
2680 if (IS_ERR(folio))
2681 return PTR_ERR(folio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002682
Matthew Wilcox (Oracle)6d68f642023-06-12 22:01:41 +01002683 bh = folio_buffers(folio);
Matthew Wilcox (Oracle)3decb852023-10-16 21:10:49 +01002684 if (!bh)
Matthew Wilcox (Oracle)0a888102023-10-16 21:11:14 +01002685 bh = create_empty_buffers(folio, blocksize, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002686
2687 /* Find the buffer that contains "offset" */
Matthew Wilcox (Oracle)6d68f642023-06-12 22:01:41 +01002688 offset = offset_in_folio(folio, from);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002689 pos = blocksize;
2690 while (offset >= pos) {
2691 bh = bh->b_this_page;
2692 iblock++;
2693 pos += blocksize;
2694 }
2695
Linus Torvalds1da177e2005-04-16 15:20:36 -07002696 if (!buffer_mapped(bh)) {
Badari Pulavartyb0cf2322006-03-26 01:38:00 -08002697 WARN_ON(bh->b_size != blocksize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002698 err = get_block(inode, iblock, bh, 0);
2699 if (err)
2700 goto unlock;
2701 /* unmapped? It's a hole - nothing to do */
2702 if (!buffer_mapped(bh))
2703 goto unlock;
2704 }
2705
2706 /* Ok, it's mapped. Make sure it's up-to-date */
Matthew Wilcox (Oracle)6d68f642023-06-12 22:01:41 +01002707 if (folio_test_uptodate(folio))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002708 set_buffer_uptodate(bh);
2709
David Chinner33a266d2007-02-12 00:51:41 -08002710 if (!buffer_uptodate(bh) && !buffer_delay(bh) && !buffer_unwritten(bh)) {
Zhang Yie7ea1122022-09-01 21:34:54 +08002711 err = bh_read(bh, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002712 /* Uhhuh. Read error. Complain and punt. */
Zhang Yie7ea1122022-09-01 21:34:54 +08002713 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002714 goto unlock;
2715 }
2716
Matthew Wilcox (Oracle)6d68f642023-06-12 22:01:41 +01002717 folio_zero_range(folio, offset, length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002718 mark_buffer_dirty(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002719
2720unlock:
Matthew Wilcox (Oracle)6d68f642023-06-12 22:01:41 +01002721 folio_unlock(folio);
2722 folio_put(folio);
Jiapeng Chongdc7cb2d2023-03-23 10:32:59 +08002723
Linus Torvalds1da177e2005-04-16 15:20:36 -07002724 return err;
2725}
H Hartley Sweeten1fe72ea2009-09-22 16:43:51 -07002726EXPORT_SYMBOL(block_truncate_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002727
2728/*
2729 * The generic ->writepage function for buffer-backed address_spaces
2730 */
Matthew Wilcox (Oracle)17bf23a2023-12-15 20:02:44 +00002731int block_write_full_folio(struct folio *folio, struct writeback_control *wbc,
2732 void *get_block)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002733{
Matthew Wilcox (Oracle)bb0ea592023-06-12 22:01:33 +01002734 struct inode * const inode = folio->mapping->host;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002735 loff_t i_size = i_size_read(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002736
Matthew Wilcox (Oracle)bb0ea592023-06-12 22:01:33 +01002737 /* Is the folio fully inside i_size? */
2738 if (folio_pos(folio) + folio_size(folio) <= i_size)
Matthew Wilcox (Oracle)14059f62023-12-15 20:02:45 +00002739 return __block_write_full_folio(inode, folio, get_block, wbc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002740
Matthew Wilcox (Oracle)bb0ea592023-06-12 22:01:33 +01002741 /* Is the folio fully outside i_size? (truncate in progress) */
2742 if (folio_pos(folio) >= i_size) {
Matthew Wilcox (Oracle)53418a12023-06-12 22:01:31 +01002743 folio_unlock(folio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002744 return 0; /* don't care */
2745 }
2746
2747 /*
Matthew Wilcox (Oracle)bb0ea592023-06-12 22:01:33 +01002748 * The folio straddles i_size. It must be zeroed out on each and every
Adam Buchbinder2a61aa42009-12-11 16:35:40 -05002749 * writepage invocation because it may be mmapped. "A file is mapped
Linus Torvalds1da177e2005-04-16 15:20:36 -07002750 * in multiples of the page size. For a file that is not a multiple of
Matthew Wilcox (Oracle)bb0ea592023-06-12 22:01:33 +01002751 * the page size, the remaining memory is zeroed when mapped, and
Linus Torvalds1da177e2005-04-16 15:20:36 -07002752 * writes to that region are not written out to the file."
2753 */
Matthew Wilcox (Oracle)bb0ea592023-06-12 22:01:33 +01002754 folio_zero_segment(folio, offset_in_folio(folio, i_size),
2755 folio_size(folio));
Matthew Wilcox (Oracle)14059f62023-12-15 20:02:45 +00002756 return __block_write_full_folio(inode, folio, get_block, wbc);
Chris Mason35c80d52009-04-15 13:22:38 -04002757}
Chris Mason35c80d52009-04-15 13:22:38 -04002758
Linus Torvalds1da177e2005-04-16 15:20:36 -07002759sector_t generic_block_bmap(struct address_space *mapping, sector_t block,
2760 get_block_t *get_block)
2761{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762 struct inode *inode = mapping->host;
Alexander Potapenko2a527d62017-07-05 00:56:21 -04002763 struct buffer_head tmp = {
2764 .b_size = i_blocksize(inode),
2765 };
2766
Linus Torvalds1da177e2005-04-16 15:20:36 -07002767 get_block(inode, block, &tmp, 0);
2768 return tmp.b_blocknr;
2769}
H Hartley Sweeten1fe72ea2009-09-22 16:43:51 -07002770EXPORT_SYMBOL(generic_block_bmap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002771
Christoph Hellwig4246a0b2015-07-20 15:29:37 +02002772static void end_bio_bh_io_sync(struct bio *bio)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002773{
2774 struct buffer_head *bh = bio->bi_private;
2775
Jens Axboeb7c44ed2015-07-24 12:37:59 -06002776 if (unlikely(bio_flagged(bio, BIO_QUIET)))
Keith Mannthey08bafc02008-11-25 10:24:35 +01002777 set_bit(BH_Quiet, &bh->b_state);
2778
Christoph Hellwig4e4cbee2017-06-03 09:38:06 +02002779 bh->b_end_io(bh, !bio->bi_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780 bio_put(bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002781}
2782
Ritesh Harjani (IBM)5bdf4022022-08-18 10:34:40 +05302783static void submit_bh_wbc(blk_opf_t opf, struct buffer_head *bh,
Bart Van Assche44981352024-02-02 12:39:25 -08002784 enum rw_hint write_hint,
Ritesh Harjani (IBM)5bdf4022022-08-18 10:34:40 +05302785 struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002786{
Bart Van Assche1420c4a52022-07-14 11:07:13 -07002787 const enum req_op op = opf & REQ_OP_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002788 struct bio *bio;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002789
2790 BUG_ON(!buffer_locked(bh));
2791 BUG_ON(!buffer_mapped(bh));
2792 BUG_ON(!bh->b_end_io);
Aneesh Kumar K.V8fb0e342009-05-12 16:22:37 -04002793 BUG_ON(buffer_delay(bh));
2794 BUG_ON(buffer_unwritten(bh));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002795
Jens Axboe48fd4f92008-08-22 10:00:36 +02002796 /*
Jens Axboe48fd4f92008-08-22 10:00:36 +02002797 * Only clear out a write error when rewriting
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798 */
Mike Christie2a222ca2016-06-05 14:31:43 -05002799 if (test_set_buffer_req(bh) && (op == REQ_OP_WRITE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002800 clear_buffer_write_io_error(bh);
2801
Christoph Hellwig07888c662022-01-24 10:11:05 +01002802 if (buffer_meta(bh))
Bart Van Assche1420c4a52022-07-14 11:07:13 -07002803 opf |= REQ_META;
Christoph Hellwig07888c662022-01-24 10:11:05 +01002804 if (buffer_prio(bh))
Bart Van Assche1420c4a52022-07-14 11:07:13 -07002805 opf |= REQ_PRIO;
Christoph Hellwig07888c662022-01-24 10:11:05 +01002806
Bart Van Assche1420c4a52022-07-14 11:07:13 -07002807 bio = bio_alloc(bh->b_bdev, 1, opf, GFP_NOIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002808
Eric Biggers4f74d152020-07-02 01:56:07 +00002809 fscrypt_set_bio_crypt_ctx_bh(bio, bh, GFP_NOIO);
2810
Kent Overstreet4f024f32013-10-11 15:44:27 -07002811 bio->bi_iter.bi_sector = bh->b_blocknr * (bh->b_size >> 9);
Bart Van Assche44981352024-02-02 12:39:25 -08002812 bio->bi_write_hint = write_hint;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002813
Johannes Thumshirn741af752023-05-31 04:50:27 -07002814 __bio_add_page(bio, bh->b_page, bh->b_size, bh_offset(bh));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002815
2816 bio->bi_end_io = end_bio_bh_io_sync;
2817 bio->bi_private = bh;
2818
Ming Lei83c9c542020-01-05 09:41:14 +08002819 /* Take care of bh's that straddle the end of the device */
2820 guard_bio_eod(bio);
2821
Dennis Zhoufd42df32018-12-05 12:10:34 -05002822 if (wbc) {
2823 wbc_init_bio(wbc, bio);
Tejun Heo34e51a52019-06-27 13:39:49 -07002824 wbc_account_cgroup_owner(wbc, bh->b_page, bh->b_size);
Dennis Zhoufd42df32018-12-05 12:10:34 -05002825 }
2826
Mike Christie4e49ea42016-06-05 14:31:41 -05002827 submit_bio(bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002828}
Tejun Heobafc0db2015-06-02 08:37:23 -06002829
Ritesh Harjani (IBM)5bdf4022022-08-18 10:34:40 +05302830void submit_bh(blk_opf_t opf, struct buffer_head *bh)
Tejun Heobafc0db2015-06-02 08:37:23 -06002831{
Bart Van Assche44981352024-02-02 12:39:25 -08002832 submit_bh_wbc(opf, bh, WRITE_LIFE_NOT_SET, NULL);
Darrick J. Wong7136851112013-04-29 15:07:25 -07002833}
H Hartley Sweeten1fe72ea2009-09-22 16:43:51 -07002834EXPORT_SYMBOL(submit_bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002835
Bart Van Assche3ae72862022-07-14 11:07:12 -07002836void write_dirty_buffer(struct buffer_head *bh, blk_opf_t op_flags)
Christoph Hellwig9cb569d2010-08-11 17:06:24 +02002837{
2838 lock_buffer(bh);
2839 if (!test_clear_buffer_dirty(bh)) {
2840 unlock_buffer(bh);
2841 return;
2842 }
2843 bh->b_end_io = end_buffer_write_sync;
2844 get_bh(bh);
Bart Van Assche1420c4a52022-07-14 11:07:13 -07002845 submit_bh(REQ_OP_WRITE | op_flags, bh);
Christoph Hellwig9cb569d2010-08-11 17:06:24 +02002846}
2847EXPORT_SYMBOL(write_dirty_buffer);
2848
Linus Torvalds1da177e2005-04-16 15:20:36 -07002849/*
2850 * For a data-integrity writeout, we need to wait upon any in-progress I/O
2851 * and then start new I/O and then wait upon it. The caller must have a ref on
2852 * the buffer_head.
2853 */
Bart Van Assche3ae72862022-07-14 11:07:12 -07002854int __sync_dirty_buffer(struct buffer_head *bh, blk_opf_t op_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002856 WARN_ON(atomic_read(&bh->b_count) < 1);
2857 lock_buffer(bh);
2858 if (test_clear_buffer_dirty(bh)) {
Xianting Tian377254b2020-07-31 12:10:25 -04002859 /*
2860 * The bh should be mapped, but it might not be if the
2861 * device was hot-removed. Not much we can do but fail the I/O.
2862 */
2863 if (!buffer_mapped(bh)) {
2864 unlock_buffer(bh);
2865 return -EIO;
2866 }
2867
Linus Torvalds1da177e2005-04-16 15:20:36 -07002868 get_bh(bh);
2869 bh->b_end_io = end_buffer_write_sync;
Ritesh Harjani (IBM)ab620622022-08-18 10:34:39 +05302870 submit_bh(REQ_OP_WRITE | op_flags, bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002871 wait_on_buffer(bh);
Ritesh Harjani (IBM)ab620622022-08-18 10:34:39 +05302872 if (!buffer_uptodate(bh))
2873 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002874 } else {
2875 unlock_buffer(bh);
2876 }
Ritesh Harjani (IBM)ab620622022-08-18 10:34:39 +05302877 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002878}
Christoph Hellwig87e99512010-08-11 17:05:45 +02002879EXPORT_SYMBOL(__sync_dirty_buffer);
2880
2881int sync_dirty_buffer(struct buffer_head *bh)
2882{
Christoph Hellwig70fd7612016-11-01 07:40:10 -06002883 return __sync_dirty_buffer(bh, REQ_SYNC);
Christoph Hellwig87e99512010-08-11 17:05:45 +02002884}
H Hartley Sweeten1fe72ea2009-09-22 16:43:51 -07002885EXPORT_SYMBOL(sync_dirty_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002886
Linus Torvalds1da177e2005-04-16 15:20:36 -07002887static inline int buffer_busy(struct buffer_head *bh)
2888{
2889 return atomic_read(&bh->b_count) |
2890 (bh->b_state & ((1 << BH_Dirty) | (1 << BH_Lock)));
2891}
2892
Matthew Wilcox (Oracle)64394762022-05-01 06:39:50 -04002893static bool
2894drop_buffers(struct folio *folio, struct buffer_head **buffers_to_free)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002895{
Matthew Wilcox (Oracle)64394762022-05-01 06:39:50 -04002896 struct buffer_head *head = folio_buffers(folio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002897 struct buffer_head *bh;
2898
2899 bh = head;
2900 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002901 if (buffer_busy(bh))
2902 goto failed;
2903 bh = bh->b_this_page;
2904 } while (bh != head);
2905
2906 do {
2907 struct buffer_head *next = bh->b_this_page;
2908
Jan Kara535ee2f2008-02-08 04:21:59 -08002909 if (bh->b_assoc_map)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002910 __remove_assoc_queue(bh);
2911 bh = next;
2912 } while (bh != head);
2913 *buffers_to_free = head;
Matthew Wilcox (Oracle)64394762022-05-01 06:39:50 -04002914 folio_detach_private(folio);
2915 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002916failed:
Matthew Wilcox (Oracle)64394762022-05-01 06:39:50 -04002917 return false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002918}
2919
Matthew Wilcox (Oracle)b1888d12024-04-16 04:17:47 +01002920/**
2921 * try_to_free_buffers - Release buffers attached to this folio.
2922 * @folio: The folio.
2923 *
2924 * If any buffers are in use (dirty, under writeback, elevated refcount),
2925 * no buffers will be freed.
2926 *
2927 * If the folio is dirty but all the buffers are clean then we need to
2928 * be sure to mark the folio clean as well. This is because the folio
2929 * may be against a block device, and a later reattachment of buffers
2930 * to a dirty folio will set *all* buffers dirty. Which would corrupt
2931 * filesystem data on the same device.
2932 *
2933 * The same applies to regular filesystem folios: if all the buffers are
2934 * clean then we set the folio clean and proceed. To do that, we require
2935 * total exclusion from block_dirty_folio(). That is obtained with
2936 * i_private_lock.
2937 *
2938 * Exclusion against try_to_free_buffers may be obtained by either
2939 * locking the folio or by holding its mapping's i_private_lock.
2940 *
2941 * Context: Process context. @folio must be locked. Will not sleep.
2942 * Return: true if all buffers attached to this folio were freed.
2943 */
Matthew Wilcox (Oracle)68189fe2022-05-01 01:08:08 -04002944bool try_to_free_buffers(struct folio *folio)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002945{
Matthew Wilcox (Oracle)68189fe2022-05-01 01:08:08 -04002946 struct address_space * const mapping = folio->mapping;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002947 struct buffer_head *buffers_to_free = NULL;
Matthew Wilcox (Oracle)68189fe2022-05-01 01:08:08 -04002948 bool ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002949
Matthew Wilcox (Oracle)68189fe2022-05-01 01:08:08 -04002950 BUG_ON(!folio_test_locked(folio));
2951 if (folio_test_writeback(folio))
2952 return false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002953
2954 if (mapping == NULL) { /* can this still happen? */
Matthew Wilcox (Oracle)64394762022-05-01 06:39:50 -04002955 ret = drop_buffers(folio, &buffers_to_free);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002956 goto out;
2957 }
2958
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +00002959 spin_lock(&mapping->i_private_lock);
Matthew Wilcox (Oracle)64394762022-05-01 06:39:50 -04002960 ret = drop_buffers(folio, &buffers_to_free);
Linus Torvaldsecdfc972007-01-26 12:47:06 -08002961
2962 /*
2963 * If the filesystem writes its buffers by hand (eg ext3)
Matthew Wilcox (Oracle)68189fe2022-05-01 01:08:08 -04002964 * then we can have clean buffers against a dirty folio. We
2965 * clean the folio here; otherwise the VM will never notice
Linus Torvaldsecdfc972007-01-26 12:47:06 -08002966 * that the filesystem did any IO at all.
2967 *
2968 * Also, during truncate, discard_buffer will have marked all
Matthew Wilcox (Oracle)68189fe2022-05-01 01:08:08 -04002969 * the folio's buffers clean. We discover that here and clean
2970 * the folio also.
Nick Piggin87df7242007-01-30 14:36:27 +11002971 *
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +00002972 * i_private_lock must be held over this entire operation in order
Matthew Wilcox (Oracle)e6219002022-02-09 20:22:12 +00002973 * to synchronise against block_dirty_folio and prevent the
Nick Piggin87df7242007-01-30 14:36:27 +11002974 * dirty bit from being lost.
Linus Torvaldsecdfc972007-01-26 12:47:06 -08002975 */
Tejun Heo11f81be2015-05-22 17:13:15 -04002976 if (ret)
Matthew Wilcox (Oracle)68189fe2022-05-01 01:08:08 -04002977 folio_cancel_dirty(folio);
Matthew Wilcox (Oracle)600f1112023-11-17 21:58:23 +00002978 spin_unlock(&mapping->i_private_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002979out:
2980 if (buffers_to_free) {
2981 struct buffer_head *bh = buffers_to_free;
2982
2983 do {
2984 struct buffer_head *next = bh->b_this_page;
2985 free_buffer_head(bh);
2986 bh = next;
2987 } while (bh != buffers_to_free);
2988 }
2989 return ret;
2990}
2991EXPORT_SYMBOL(try_to_free_buffers);
2992
Linus Torvalds1da177e2005-04-16 15:20:36 -07002993/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002994 * Buffer-head allocation
2995 */
Alexey Dobriyan68279f92023-10-11 19:55:00 +03002996static struct kmem_cache *bh_cachep __ro_after_init;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002997
2998/*
2999 * Once the number of bh's in the machine exceeds this level, we start
3000 * stripping them in writeback.
3001 */
Alexey Dobriyan68279f92023-10-11 19:55:00 +03003002static unsigned long max_buffer_heads __ro_after_init;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003003
3004int buffer_heads_over_limit;
3005
3006struct bh_accounting {
3007 int nr; /* Number of live bh's */
3008 int ratelimit; /* Limit cacheline bouncing */
3009};
3010
3011static DEFINE_PER_CPU(struct bh_accounting, bh_accounting) = {0, 0};
3012
3013static void recalc_bh_state(void)
3014{
3015 int i;
3016 int tot = 0;
3017
Christoph Lameteree1be862010-12-06 11:40:05 -06003018 if (__this_cpu_inc_return(bh_accounting.ratelimit) - 1 < 4096)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003019 return;
Christoph Lameterc7b92512010-12-06 11:16:28 -06003020 __this_cpu_write(bh_accounting.ratelimit, 0);
Eric Dumazet8a143422006-03-24 03:18:10 -08003021 for_each_online_cpu(i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003022 tot += per_cpu(bh_accounting, i).nr;
3023 buffer_heads_over_limit = (tot > max_buffer_heads);
3024}
Christoph Lameterc7b92512010-12-06 11:16:28 -06003025
Al Virodd0fc662005-10-07 07:46:04 +01003026struct buffer_head *alloc_buffer_head(gfp_t gfp_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003027{
Richard Kennedy019b4d12010-03-10 15:20:33 -08003028 struct buffer_head *ret = kmem_cache_zalloc(bh_cachep, gfp_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003029 if (ret) {
Christoph Lametera35afb82007-05-16 22:10:57 -07003030 INIT_LIST_HEAD(&ret->b_assoc_buffers);
Thomas Gleixnerf1e67e32019-11-18 14:28:24 +01003031 spin_lock_init(&ret->b_uptodate_lock);
Christoph Lameterc7b92512010-12-06 11:16:28 -06003032 preempt_disable();
3033 __this_cpu_inc(bh_accounting.nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003034 recalc_bh_state();
Christoph Lameterc7b92512010-12-06 11:16:28 -06003035 preempt_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003036 }
3037 return ret;
3038}
3039EXPORT_SYMBOL(alloc_buffer_head);
3040
3041void free_buffer_head(struct buffer_head *bh)
3042{
3043 BUG_ON(!list_empty(&bh->b_assoc_buffers));
3044 kmem_cache_free(bh_cachep, bh);
Christoph Lameterc7b92512010-12-06 11:16:28 -06003045 preempt_disable();
3046 __this_cpu_dec(bh_accounting.nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003047 recalc_bh_state();
Christoph Lameterc7b92512010-12-06 11:16:28 -06003048 preempt_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003049}
3050EXPORT_SYMBOL(free_buffer_head);
3051
Sebastian Andrzej Siewiorfc4d24c2016-11-03 15:49:57 +01003052static int buffer_exit_cpu_dead(unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003053{
3054 int i;
3055 struct bh_lru *b = &per_cpu(bh_lrus, cpu);
3056
3057 for (i = 0; i < BH_LRU_SIZE; i++) {
3058 brelse(b->bhs[i]);
3059 b->bhs[i] = NULL;
3060 }
Christoph Lameterc7b92512010-12-06 11:16:28 -06003061 this_cpu_add(bh_accounting.nr, per_cpu(bh_accounting, cpu).nr);
Eric Dumazet8a143422006-03-24 03:18:10 -08003062 per_cpu(bh_accounting, cpu).nr = 0;
Sebastian Andrzej Siewiorfc4d24c2016-11-03 15:49:57 +01003063 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003064}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003065
Aneesh Kumar K.V389d1b02008-01-28 23:58:26 -05003066/**
Randy Dunlapa6b91912008-03-19 17:01:00 -07003067 * bh_uptodate_or_lock - Test whether the buffer is uptodate
Aneesh Kumar K.V389d1b02008-01-28 23:58:26 -05003068 * @bh: struct buffer_head
3069 *
3070 * Return true if the buffer is up-to-date and false,
3071 * with the buffer locked, if not.
3072 */
3073int bh_uptodate_or_lock(struct buffer_head *bh)
3074{
3075 if (!buffer_uptodate(bh)) {
3076 lock_buffer(bh);
3077 if (!buffer_uptodate(bh))
3078 return 0;
3079 unlock_buffer(bh);
3080 }
3081 return 1;
3082}
3083EXPORT_SYMBOL(bh_uptodate_or_lock);
3084
3085/**
Zhang Yifdee1172022-09-01 21:34:53 +08003086 * __bh_read - Submit read for a locked buffer
Aneesh Kumar K.V389d1b02008-01-28 23:58:26 -05003087 * @bh: struct buffer_head
Zhang Yifdee1172022-09-01 21:34:53 +08003088 * @op_flags: appending REQ_OP_* flags besides REQ_OP_READ
3089 * @wait: wait until reading finish
Aneesh Kumar K.V389d1b02008-01-28 23:58:26 -05003090 *
Zhang Yifdee1172022-09-01 21:34:53 +08003091 * Returns zero on success or don't wait, and -EIO on error.
Aneesh Kumar K.V389d1b02008-01-28 23:58:26 -05003092 */
Zhang Yifdee1172022-09-01 21:34:53 +08003093int __bh_read(struct buffer_head *bh, blk_opf_t op_flags, bool wait)
Aneesh Kumar K.V389d1b02008-01-28 23:58:26 -05003094{
Zhang Yifdee1172022-09-01 21:34:53 +08003095 int ret = 0;
Aneesh Kumar K.V389d1b02008-01-28 23:58:26 -05003096
Zhang Yifdee1172022-09-01 21:34:53 +08003097 BUG_ON(!buffer_locked(bh));
Aneesh Kumar K.V389d1b02008-01-28 23:58:26 -05003098
3099 get_bh(bh);
3100 bh->b_end_io = end_buffer_read_sync;
Zhang Yifdee1172022-09-01 21:34:53 +08003101 submit_bh(REQ_OP_READ | op_flags, bh);
3102 if (wait) {
3103 wait_on_buffer(bh);
3104 if (!buffer_uptodate(bh))
3105 ret = -EIO;
3106 }
3107 return ret;
Aneesh Kumar K.V389d1b02008-01-28 23:58:26 -05003108}
Zhang Yifdee1172022-09-01 21:34:53 +08003109EXPORT_SYMBOL(__bh_read);
3110
3111/**
3112 * __bh_read_batch - Submit read for a batch of unlocked buffers
3113 * @nr: entry number of the buffer batch
3114 * @bhs: a batch of struct buffer_head
3115 * @op_flags: appending REQ_OP_* flags besides REQ_OP_READ
3116 * @force_lock: force to get a lock on the buffer if set, otherwise drops any
3117 * buffer that cannot lock.
3118 *
3119 * Returns zero on success or don't wait, and -EIO on error.
3120 */
3121void __bh_read_batch(int nr, struct buffer_head *bhs[],
3122 blk_opf_t op_flags, bool force_lock)
3123{
3124 int i;
3125
3126 for (i = 0; i < nr; i++) {
3127 struct buffer_head *bh = bhs[i];
3128
3129 if (buffer_uptodate(bh))
3130 continue;
3131
3132 if (force_lock)
3133 lock_buffer(bh);
3134 else
3135 if (!trylock_buffer(bh))
3136 continue;
3137
3138 if (buffer_uptodate(bh)) {
3139 unlock_buffer(bh);
3140 continue;
3141 }
3142
3143 bh->b_end_io = end_buffer_read_sync;
3144 get_bh(bh);
3145 submit_bh(REQ_OP_READ | op_flags, bh);
3146 }
3147}
3148EXPORT_SYMBOL(__bh_read_batch);
Aneesh Kumar K.V389d1b02008-01-28 23:58:26 -05003149
Linus Torvalds1da177e2005-04-16 15:20:36 -07003150void __init buffer_init(void)
3151{
Zhang Yanfei43be5942013-02-22 16:35:46 -08003152 unsigned long nrpages;
Sebastian Andrzej Siewiorfc4d24c2016-11-03 15:49:57 +01003153 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003154
Kunwu Chande8a3202024-01-16 17:11:37 +08003155 bh_cachep = KMEM_CACHE(buffer_head,
Chengming Zhouc997d682024-02-24 13:53:15 +00003156 SLAB_RECLAIM_ACCOUNT|SLAB_PANIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003157 /*
3158 * Limit the bh occupancy to 10% of ZONE_NORMAL
3159 */
3160 nrpages = (nr_free_buffer_pages() * 10) / 100;
3161 max_buffer_heads = nrpages * (PAGE_SIZE / sizeof(struct buffer_head));
Sebastian Andrzej Siewiorfc4d24c2016-11-03 15:49:57 +01003162 ret = cpuhp_setup_state_nocalls(CPUHP_FS_BUFF_DEAD, "fs/buffer:dead",
3163 NULL, buffer_exit_cpu_dead);
3164 WARN_ON(ret < 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003165}