1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * io.c
4 *
5 * Buffer cache handling
6 *
7 * Copyright (C) 2002, 2004 Oracle.  All rights reserved.
8 */
9
10#include <linux/fs.h>
11#include <linux/types.h>
12#include <linux/highmem.h>
13#include <linux/bio.h>
14
15#include <cluster/masklog.h>
16
17#include "ocfs2.h"
18
19#include "alloc.h"
20#include "inode.h"
21#include "journal.h"
22#include "uptodate.h"
23#include "buffer_head_io.h"
24#include "ocfs2_trace.h"
25
26/*
27 * Bits on bh->b_state used by ocfs2.
28 *
29 * These MUST be after the JBD2 bits.  Hence, we use BH_JBDPrivateStart.
30 */
31enum ocfs2_state_bits {
32	BH_NeedsValidate = BH_JBDPrivateStart,
33};
34
35/* Expand the magic b_state functions */
36BUFFER_FNS(NeedsValidate, needs_validate);
37
38int ocfs2_write_block(struct ocfs2_super *osb, struct buffer_head *bh,
39		      struct ocfs2_caching_info *ci)
40{
41	int ret = 0;
42
43	trace_ocfs2_write_block((unsigned long long)bh->b_blocknr, ci);
44
45	BUG_ON(bh->b_blocknr < OCFS2_SUPER_BLOCK_BLKNO);
46	BUG_ON(buffer_jbd(bh));
47
48	/* No need to check for a soft readonly file system here. non
49	 * journalled writes are only ever done on system files which
50	 * can get modified during recovery even if read-only. */
51	if (ocfs2_is_hard_readonly(osb)) {
52		ret = -EROFS;
53		mlog_errno(ret);
54		goto out;
55	}
56
57	ocfs2_metadata_cache_io_lock(ci);
58
59	lock_buffer(bh);
60	set_buffer_uptodate(bh);
61
62	/* remove from dirty list before I/O. */
63	clear_buffer_dirty(bh);
64
65	get_bh(bh); /* for end_buffer_write_sync() */
66	bh->b_end_io = end_buffer_write_sync;
67	submit_bh(REQ_OP_WRITE, bh);
68
69	wait_on_buffer(bh);
70
71	if (buffer_uptodate(bh)) {
72		ocfs2_set_buffer_uptodate(ci, bh);
73	} else {
74		/* We don't need to remove the clustered uptodate
75		 * information for this bh as it's not marked locally
76		 * uptodate. */
77		ret = -EIO;
78		mlog_errno(ret);
79	}
80
81	ocfs2_metadata_cache_io_unlock(ci);
82out:
83	return ret;
84}
85
86/* Caller must provide a bhs[] with all NULL or non-NULL entries, so it
87 * will be easier to handle read failure.
88 */
89int ocfs2_read_blocks_sync(struct ocfs2_super *osb, u64 block,
90			   unsigned int nr, struct buffer_head *bhs[])
91{
92	int status = 0;
93	unsigned int i;
94	struct buffer_head *bh;
95	int new_bh = 0;
96
97	trace_ocfs2_read_blocks_sync((unsigned long long)block, nr);
98
99	if (!nr)
100		goto bail;
101
102	/* Don't put buffer head and re-assign it to NULL if it is allocated
103	 * outside since the caller can't be aware of this alternation!
104	 */
105	new_bh = (bhs[0] == NULL);
106
107	for (i = 0 ; i < nr ; i++) {
108		if (bhs[i] == NULL) {
109			bhs[i] = sb_getblk(osb->sb, block++);
110			if (bhs[i] == NULL) {
111				status = -ENOMEM;
112				mlog_errno(status);
113				break;
114			}
115		}
116		bh = bhs[i];
117
118		if (buffer_jbd(bh)) {
119			trace_ocfs2_read_blocks_sync_jbd(
120					(unsigned long long)bh->b_blocknr);
121			continue;
122		}
123
124		if (buffer_dirty(bh)) {
125			/* This should probably be a BUG, or
126			 * at least return an error. */
127			mlog(ML_ERROR,
128			     "trying to sync read a dirty "
129			     "buffer! (blocknr = %llu), skipping\n",
130			     (unsigned long long)bh->b_blocknr);
131			continue;
132		}
133
134		lock_buffer(bh);
135		if (buffer_jbd(bh)) {
136#ifdef CATCH_BH_JBD_RACES
137			mlog(ML_ERROR,
138			     "block %llu had the JBD bit set "
139			     "while I was in lock_buffer!",
140			     (unsigned long long)bh->b_blocknr);
141			BUG();
142#else
143			unlock_buffer(bh);
144			continue;
145#endif
146		}
147
148		get_bh(bh); /* for end_buffer_read_sync() */
149		bh->b_end_io = end_buffer_read_sync;
150		submit_bh(REQ_OP_READ, bh);
151	}
152
153read_failure:
154	for (i = nr; i > 0; i--) {
155		bh = bhs[i - 1];
156
157		if (unlikely(status)) {
158			if (new_bh && bh) {
159				/* If middle bh fails, let previous bh
160				 * finish its read and then put it to
161				 * avoid bh leak
162				 */
163				if (!buffer_jbd(bh))
164					wait_on_buffer(bh);
165				put_bh(bh);
166				bhs[i - 1] = NULL;
167			} else if (bh && buffer_uptodate(bh)) {
168				clear_buffer_uptodate(bh);
169			}
170			continue;
171		}
172
173		/* No need to wait on the buffer if it's managed by JBD. */
174		if (!buffer_jbd(bh))
175			wait_on_buffer(bh);
176
177		if (!buffer_uptodate(bh)) {
178			/* Status won't be cleared from here on out,
179			 * so we can safely record this and loop back
180			 * to cleanup the other buffers. */
181			status = -EIO;
182			goto read_failure;
183		}
184	}
185
186bail:
187	return status;
188}
189
190/* Caller must provide a bhs[] with all NULL or non-NULL entries, so it
191 * will be easier to handle read failure.
192 */
193int ocfs2_read_blocks(struct ocfs2_caching_info *ci, u64 block, int nr,
194		      struct buffer_head *bhs[], int flags,
195		      int (*validate)(struct super_block *sb,
196				      struct buffer_head *bh))
197{
198	int status = 0;
199	int i, ignore_cache = 0;
200	struct buffer_head *bh;
201	struct super_block *sb = ocfs2_metadata_cache_get_super(ci);
202	int new_bh = 0;
203
204	trace_ocfs2_read_blocks_begin(ci, (unsigned long long)block, nr, flags);
205
206	BUG_ON(!ci);
207	BUG_ON((flags & OCFS2_BH_READAHEAD) &&
208	       (flags & OCFS2_BH_IGNORE_CACHE));
209
210	if (bhs == NULL) {
211		status = -EINVAL;
212		mlog_errno(status);
213		goto bail;
214	}
215
216	if (nr < 0) {
217		mlog(ML_ERROR, "asked to read %d blocks!\n", nr);
218		status = -EINVAL;
219		mlog_errno(status);
220		goto bail;
221	}
222
223	if (nr == 0) {
224		status = 0;
225		goto bail;
226	}
227
228	/* Don't put buffer head and re-assign it to NULL if it is allocated
229	 * outside since the caller can't be aware of this alternation!
230	 */
231	new_bh = (bhs[0] == NULL);
232
233	ocfs2_metadata_cache_io_lock(ci);
234	for (i = 0 ; i < nr ; i++) {
235		if (bhs[i] == NULL) {
236			bhs[i] = sb_getblk(sb, block++);
237			if (bhs[i] == NULL) {
238				ocfs2_metadata_cache_io_unlock(ci);
239				status = -ENOMEM;
240				mlog_errno(status);
241				/* Don't forget to put previous bh! */
242				break;
243			}
244		}
245		bh = bhs[i];
246		ignore_cache = (flags & OCFS2_BH_IGNORE_CACHE);
247
248		/* There are three read-ahead cases here which we need to
249		 * be concerned with. All three assume a buffer has
250		 * previously been submitted with OCFS2_BH_READAHEAD
251		 * and it hasn't yet completed I/O.
252		 *
253		 * 1) The current request is sync to disk. This rarely
254		 *    happens these days, and never when performance
255		 *    matters - the code can just wait on the buffer
256		 *    lock and re-submit.
257		 *
258		 * 2) The current request is cached, but not
259		 *    readahead. ocfs2_buffer_uptodate() will return
260		 *    false anyway, so we'll wind up waiting on the
261		 *    buffer lock to do I/O. We re-check the request
262		 *    with after getting the lock to avoid a re-submit.
263		 *
264		 * 3) The current request is readahead (and so must
265		 *    also be a caching one). We short circuit if the
266		 *    buffer is locked (under I/O) and if it's in the
267		 *    uptodate cache. The re-check from #2 catches the
268		 *    case that the previous read-ahead completes just
269		 *    before our is-it-in-flight check.
270		 */
271
272		if (!ignore_cache && !ocfs2_buffer_uptodate(ci, bh)) {
273			trace_ocfs2_read_blocks_from_disk(
274			     (unsigned long long)bh->b_blocknr,
275			     (unsigned long long)ocfs2_metadata_cache_owner(ci));
276			/* We're using ignore_cache here to say
277			 * "go to disk" */
278			ignore_cache = 1;
279		}
280
281		trace_ocfs2_read_blocks_bh((unsigned long long)bh->b_blocknr,
282			ignore_cache, buffer_jbd(bh), buffer_dirty(bh));
283
284		if (buffer_jbd(bh)) {
285			continue;
286		}
287
288		if (ignore_cache) {
289			if (buffer_dirty(bh)) {
290				/* This should probably be a BUG, or
291				 * at least return an error. */
292				continue;
293			}
294
295			/* A read-ahead request was made - if the
296			 * buffer is already under read-ahead from a
297			 * previously submitted request than we are
298			 * done here. */
299			if ((flags & OCFS2_BH_READAHEAD)
300			    && ocfs2_buffer_read_ahead(ci, bh))
301				continue;
302
303			lock_buffer(bh);
304			if (buffer_jbd(bh)) {
305#ifdef CATCH_BH_JBD_RACES
306				mlog(ML_ERROR, "block %llu had the JBD bit set "
307					       "while I was in lock_buffer!",
308				     (unsigned long long)bh->b_blocknr);
309				BUG();
310#else
311				unlock_buffer(bh);
312				continue;
313#endif
314			}
315
316			/* Re-check ocfs2_buffer_uptodate() as a
317			 * previously read-ahead buffer may have
318			 * completed I/O while we were waiting for the
319			 * buffer lock. */
320			if (!(flags & OCFS2_BH_IGNORE_CACHE)
321			    && !(flags & OCFS2_BH_READAHEAD)
322			    && ocfs2_buffer_uptodate(ci, bh)) {
323				unlock_buffer(bh);
324				continue;
325			}
326
327			get_bh(bh); /* for end_buffer_read_sync() */
328			if (validate)
329				set_buffer_needs_validate(bh);
330			bh->b_end_io = end_buffer_read_sync;
331			submit_bh(REQ_OP_READ, bh);
332			continue;
333		}
334	}
335
336read_failure:
337	for (i = (nr - 1); i >= 0; i--) {
338		bh = bhs[i];
339
340		if (!(flags & OCFS2_BH_READAHEAD)) {
341			if (unlikely(status)) {
342				/* Clear the buffers on error including those
343				 * ever succeeded in reading
344				 */
345				if (new_bh && bh) {
346					/* If middle bh fails, let previous bh
347					 * finish its read and then put it to
348					 * avoid bh leak
349					 */
350					if (!buffer_jbd(bh))
351						wait_on_buffer(bh);
352					put_bh(bh);
353					bhs[i] = NULL;
354				} else if (bh && buffer_uptodate(bh)) {
355					clear_buffer_uptodate(bh);
356				}
357				continue;
358			}
359			/* We know this can't have changed as we hold the
360			 * owner sem. Avoid doing any work on the bh if the
361			 * journal has it. */
362			if (!buffer_jbd(bh))
363				wait_on_buffer(bh);
364
365			if (!buffer_uptodate(bh)) {
366				/* Status won't be cleared from here on out,
367				 * so we can safely record this and loop back
368				 * to cleanup the other buffers. Don't need to
369				 * remove the clustered uptodate information
370				 * for this bh as it's not marked locally
371				 * uptodate. */
372				status = -EIO;
373				clear_buffer_needs_validate(bh);
374				goto read_failure;
375			}
376
377			if (buffer_needs_validate(bh)) {
378				/* We never set NeedsValidate if the
379				 * buffer was held by the journal, so
380				 * that better not have changed */
381				BUG_ON(buffer_jbd(bh));
382				clear_buffer_needs_validate(bh);
383				status = validate(sb, bh);
384				if (status)
385					goto read_failure;
386			}
387		}
388
389		/* Always set the buffer in the cache, even if it was
390		 * a forced read, or read-ahead which hasn't yet
391		 * completed. */
392		ocfs2_set_buffer_uptodate(ci, bh);
393	}
394	ocfs2_metadata_cache_io_unlock(ci);
395
396	trace_ocfs2_read_blocks_end((unsigned long long)block, nr,
397				    flags, ignore_cache);
398
399bail:
400
401	return status;
402}
403
404/* Check whether the blkno is the super block or one of the backups. */
405static void ocfs2_check_super_or_backup(struct super_block *sb,
406					sector_t blkno)
407{
408	int i;
409	u64 backup_blkno;
410
411	if (blkno == OCFS2_SUPER_BLOCK_BLKNO)
412		return;
413
414	for (i = 0; i < OCFS2_MAX_BACKUP_SUPERBLOCKS; i++) {
415		backup_blkno = ocfs2_backup_super_blkno(sb, i);
416		if (backup_blkno == blkno)
417			return;
418	}
419
420	BUG();
421}
422
423/*
424 * Write super block and backups doesn't need to collaborate with journal,
425 * so we don't need to lock ip_io_mutex and ci doesn't need to bea passed
426 * into this function.
427 */
428int ocfs2_write_super_or_backup(struct ocfs2_super *osb,
429				struct buffer_head *bh)
430{
431	int ret = 0;
432	struct ocfs2_dinode *di = (struct ocfs2_dinode *)bh->b_data;
433
434	BUG_ON(buffer_jbd(bh));
435	ocfs2_check_super_or_backup(osb->sb, bh->b_blocknr);
436
437	if (ocfs2_is_hard_readonly(osb) || ocfs2_is_soft_readonly(osb)) {
438		ret = -EROFS;
439		mlog_errno(ret);
440		goto out;
441	}
442
443	lock_buffer(bh);
444	set_buffer_uptodate(bh);
445
446	/* remove from dirty list before I/O. */
447	clear_buffer_dirty(bh);
448
449	get_bh(bh); /* for end_buffer_write_sync() */
450	bh->b_end_io = end_buffer_write_sync;
451	ocfs2_compute_meta_ecc(osb->sb, bh->b_data, &di->i_check);
452	submit_bh(REQ_OP_WRITE, bh);
453
454	wait_on_buffer(bh);
455
456	if (!buffer_uptodate(bh)) {
457		ret = -EIO;
458		mlog_errno(ret);
459	}
460
461out:
462	return ret;
463}
464