1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
4 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
7 #include <linux/sched.h>
8 #include <linux/slab.h>
9 #include <linux/spinlock.h>
10 #include <linux/completion.h>
11 #include <linux/buffer_head.h>
13 #include <linux/pagemap.h>
14 #include <linux/writeback.h>
15 #include <linux/swap.h>
16 #include <linux/delay.h>
17 #include <linux/bio.h>
18 #include <linux/gfs2_ondisk.h>
31 #include "trace_gfs2.h"
33 static int gfs2_aspace_writepage(struct page
*page
, struct writeback_control
*wbc
)
35 struct buffer_head
*bh
, *head
;
37 int write_flags
= REQ_META
| REQ_PRIO
| wbc_to_write_flags(wbc
);
39 BUG_ON(!PageLocked(page
));
40 BUG_ON(!page_has_buffers(page
));
42 head
= page_buffers(page
);
46 if (!buffer_mapped(bh
))
49 * If it's a fully non-blocking write attempt and we cannot
50 * lock the buffer then redirty the page. Note that this can
51 * potentially cause a busy-wait loop from flusher thread and kswapd
52 * activity, but those code paths have their own higher-level
55 if (wbc
->sync_mode
!= WB_SYNC_NONE
) {
57 } else if (!trylock_buffer(bh
)) {
58 redirty_page_for_writepage(wbc
, page
);
61 if (test_clear_buffer_dirty(bh
)) {
62 mark_buffer_async_write(bh
);
66 } while ((bh
= bh
->b_this_page
) != head
);
69 * The page and its buffers are protected by PageWriteback(), so we can
70 * drop the bh refcounts early.
72 BUG_ON(PageWriteback(page
));
73 set_page_writeback(page
);
76 struct buffer_head
*next
= bh
->b_this_page
;
77 if (buffer_async_write(bh
)) {
78 submit_bh(REQ_OP_WRITE
, write_flags
, bh
);
86 end_page_writeback(page
);
91 const struct address_space_operations gfs2_meta_aops
= {
92 .set_page_dirty
= __set_page_dirty_buffers
,
93 .writepage
= gfs2_aspace_writepage
,
94 .releasepage
= gfs2_releasepage
,
97 const struct address_space_operations gfs2_rgrp_aops
= {
98 .set_page_dirty
= __set_page_dirty_buffers
,
99 .writepage
= gfs2_aspace_writepage
,
100 .releasepage
= gfs2_releasepage
,
104 * gfs2_getbuf - Get a buffer with a given address space
106 * @blkno: the block number (filesystem scope)
107 * @create: 1 if the buffer should be created
109 * Returns: the buffer
112 struct buffer_head
*gfs2_getbuf(struct gfs2_glock
*gl
, u64 blkno
, int create
)
114 struct address_space
*mapping
= gfs2_glock2aspace(gl
);
115 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
117 struct buffer_head
*bh
;
123 mapping
= &sdp
->sd_aspace
;
125 shift
= PAGE_SHIFT
- sdp
->sd_sb
.sb_bsize_shift
;
126 index
= blkno
>> shift
; /* convert block to page */
127 bufnum
= blkno
- (index
<< shift
); /* block buf index within page */
131 page
= grab_cache_page(mapping
, index
);
136 if (!page_has_buffers(page
))
137 create_empty_buffers(page
, sdp
->sd_sb
.sb_bsize
, 0);
139 page
= find_get_page_flags(mapping
, index
,
140 FGP_LOCK
|FGP_ACCESSED
);
143 if (!page_has_buffers(page
)) {
149 /* Locate header for our buffer within our page */
150 for (bh
= page_buffers(page
); bufnum
--; bh
= bh
->b_this_page
)
154 if (!buffer_mapped(bh
))
155 map_bh(bh
, sdp
->sd_vfs
, blkno
);
164 static void meta_prep_new(struct buffer_head
*bh
)
166 struct gfs2_meta_header
*mh
= (struct gfs2_meta_header
*)bh
->b_data
;
169 clear_buffer_dirty(bh
);
170 set_buffer_uptodate(bh
);
173 mh
->mh_magic
= cpu_to_be32(GFS2_MAGIC
);
177 * gfs2_meta_new - Get a block
178 * @gl: The glock associated with this block
179 * @blkno: The block number
181 * Returns: The buffer
184 struct buffer_head
*gfs2_meta_new(struct gfs2_glock
*gl
, u64 blkno
)
186 struct buffer_head
*bh
;
187 bh
= gfs2_getbuf(gl
, blkno
, CREATE
);
192 static void gfs2_meta_read_endio(struct bio
*bio
)
194 struct bio_vec
*bvec
;
195 struct bvec_iter_all iter_all
;
197 bio_for_each_segment_all(bvec
, bio
, iter_all
) {
198 struct page
*page
= bvec
->bv_page
;
199 struct buffer_head
*bh
= page_buffers(page
);
200 unsigned int len
= bvec
->bv_len
;
202 while (bh_offset(bh
) < bvec
->bv_offset
)
203 bh
= bh
->b_this_page
;
205 struct buffer_head
*next
= bh
->b_this_page
;
207 bh
->b_end_io(bh
, !bio
->bi_status
);
215 * Submit several consecutive buffer head I/O requests as a single bio I/O
216 * request. (See submit_bh_wbc.)
218 static void gfs2_submit_bhs(int op
, int op_flags
, struct buffer_head
*bhs
[],
222 struct buffer_head
*bh
= *bhs
;
225 bio
= bio_alloc(GFP_NOIO
, num
);
226 bio
->bi_iter
.bi_sector
= bh
->b_blocknr
* (bh
->b_size
>> 9);
227 bio_set_dev(bio
, bh
->b_bdev
);
230 if (!bio_add_page(bio
, bh
->b_page
, bh
->b_size
, bh_offset(bh
))) {
231 BUG_ON(bio
->bi_iter
.bi_size
== 0);
237 bio
->bi_end_io
= gfs2_meta_read_endio
;
238 bio_set_op_attrs(bio
, op
, op_flags
);
244 * gfs2_meta_read - Read a block from disk
245 * @gl: The glock covering the block
246 * @blkno: The block number
248 * @rahead: Do read-ahead
249 * @bhp: the place where the buffer is returned (NULL on failure)
254 int gfs2_meta_read(struct gfs2_glock
*gl
, u64 blkno
, int flags
,
255 int rahead
, struct buffer_head
**bhp
)
257 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
258 struct buffer_head
*bh
, *bhs
[2];
261 if (unlikely(gfs2_withdrawn(sdp
)) && !gfs2_withdraw_in_prog(sdp
)) {
266 *bhp
= bh
= gfs2_getbuf(gl
, blkno
, CREATE
);
269 if (buffer_uptodate(bh
)) {
273 bh
->b_end_io
= end_buffer_read_sync
;
279 bh
= gfs2_getbuf(gl
, blkno
+ 1, CREATE
);
282 if (buffer_uptodate(bh
)) {
286 bh
->b_end_io
= end_buffer_read_sync
;
291 gfs2_submit_bhs(REQ_OP_READ
, REQ_META
| REQ_PRIO
, bhs
, num
);
292 if (!(flags
& DIO_WAIT
))
297 if (unlikely(!buffer_uptodate(bh
))) {
298 struct gfs2_trans
*tr
= current
->journal_info
;
299 if (tr
&& test_bit(TR_TOUCHED
, &tr
->tr_flags
))
300 gfs2_io_error_bh_wd(sdp
, bh
);
310 * gfs2_meta_wait - Reread a block from disk
311 * @sdp: the filesystem
312 * @bh: The block to wait for
317 int gfs2_meta_wait(struct gfs2_sbd
*sdp
, struct buffer_head
*bh
)
319 if (unlikely(gfs2_withdrawn(sdp
)) && !gfs2_withdraw_in_prog(sdp
))
324 if (!buffer_uptodate(bh
)) {
325 struct gfs2_trans
*tr
= current
->journal_info
;
326 if (tr
&& test_bit(TR_TOUCHED
, &tr
->tr_flags
))
327 gfs2_io_error_bh_wd(sdp
, bh
);
330 if (unlikely(gfs2_withdrawn(sdp
)) && !gfs2_withdraw_in_prog(sdp
))
336 void gfs2_remove_from_journal(struct buffer_head
*bh
, int meta
)
338 struct address_space
*mapping
= bh
->b_page
->mapping
;
339 struct gfs2_sbd
*sdp
= gfs2_mapping2sbd(mapping
);
340 struct gfs2_bufdata
*bd
= bh
->b_private
;
341 struct gfs2_trans
*tr
= current
->journal_info
;
344 if (test_clear_buffer_pinned(bh
)) {
345 trace_gfs2_pin(bd
, 0);
346 atomic_dec(&sdp
->sd_log_pinned
);
347 list_del_init(&bd
->bd_list
);
348 if (meta
== REMOVE_META
)
351 tr
->tr_num_databuf_rm
++;
352 set_bit(TR_TOUCHED
, &tr
->tr_flags
);
358 gfs2_trans_add_revoke(sdp
, bd
);
359 } else if (was_pinned
) {
360 bh
->b_private
= NULL
;
361 kmem_cache_free(gfs2_bufdata_cachep
, bd
);
362 } else if (!list_empty(&bd
->bd_ail_st_list
) &&
363 !list_empty(&bd
->bd_ail_gl_list
)) {
364 gfs2_remove_from_ail(bd
);
367 clear_buffer_dirty(bh
);
368 clear_buffer_uptodate(bh
);
372 * gfs2_ail1_wipe - remove deleted/freed buffers from the ail1 list
374 * @bstart: starting block address of buffers to remove
375 * @blen: length of buffers to be removed
377 * This function is called from gfs2_journal wipe, whose job is to remove
378 * buffers, corresponding to deleted blocks, from the journal. If we find any
379 * bufdata elements on the system ail1 list, they haven't been written to
380 * the journal yet. So we remove them.
382 static void gfs2_ail1_wipe(struct gfs2_sbd
*sdp
, u64 bstart
, u32 blen
)
384 struct gfs2_trans
*tr
, *s
;
385 struct gfs2_bufdata
*bd
, *bs
;
386 struct buffer_head
*bh
;
387 u64 end
= bstart
+ blen
;
390 spin_lock(&sdp
->sd_ail_lock
);
391 list_for_each_entry_safe(tr
, s
, &sdp
->sd_ail1_list
, tr_list
) {
392 list_for_each_entry_safe(bd
, bs
, &tr
->tr_ail1_list
,
395 if (bh
->b_blocknr
< bstart
|| bh
->b_blocknr
>= end
)
398 gfs2_remove_from_journal(bh
, REMOVE_JDATA
);
401 spin_unlock(&sdp
->sd_ail_lock
);
402 gfs2_log_unlock(sdp
);
405 static struct buffer_head
*gfs2_getjdatabuf(struct gfs2_inode
*ip
, u64 blkno
)
407 struct address_space
*mapping
= ip
->i_inode
.i_mapping
;
408 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
410 struct buffer_head
*bh
;
411 unsigned int shift
= PAGE_SHIFT
- sdp
->sd_sb
.sb_bsize_shift
;
412 unsigned long index
= blkno
>> shift
; /* convert block to page */
413 unsigned int bufnum
= blkno
- (index
<< shift
);
415 page
= find_get_page_flags(mapping
, index
, FGP_LOCK
|FGP_ACCESSED
);
418 if (!page_has_buffers(page
)) {
423 /* Locate header for our buffer within our page */
424 for (bh
= page_buffers(page
); bufnum
--; bh
= bh
->b_this_page
)
433 * gfs2_journal_wipe - make inode's buffers so they aren't dirty/pinned anymore
434 * @ip: the inode who owns the buffers
435 * @bstart: the first buffer in the run
436 * @blen: the number of buffers in the run
440 void gfs2_journal_wipe(struct gfs2_inode
*ip
, u64 bstart
, u32 blen
)
442 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
443 struct buffer_head
*bh
;
446 gfs2_ail1_wipe(sdp
, bstart
, blen
);
449 bh
= gfs2_getbuf(ip
->i_gl
, bstart
, NO_CREATE
);
450 if (!bh
&& gfs2_is_jdata(ip
)) {
451 bh
= gfs2_getjdatabuf(ip
, bstart
);
457 spin_lock(&sdp
->sd_ail_lock
);
458 gfs2_remove_from_journal(bh
, ty
);
459 spin_unlock(&sdp
->sd_ail_lock
);
460 gfs2_log_unlock(sdp
);
471 * gfs2_meta_buffer - Get a metadata buffer
472 * @ip: The GFS2 inode
473 * @mtype: The block type (GFS2_METATYPE_*)
474 * @num: The block number (device relative) of the buffer
475 * @bhp: the buffer is returned here
480 int gfs2_meta_buffer(struct gfs2_inode
*ip
, u32 mtype
, u64 num
,
481 struct buffer_head
**bhp
)
483 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
484 struct gfs2_glock
*gl
= ip
->i_gl
;
485 struct buffer_head
*bh
;
489 if (num
== ip
->i_no_addr
)
490 rahead
= ip
->i_rahead
;
492 ret
= gfs2_meta_read(gl
, num
, DIO_WAIT
, rahead
, &bh
);
493 if (ret
== 0 && gfs2_metatype_check(sdp
, bh
, mtype
)) {
503 * gfs2_meta_ra - start readahead on an extent of a file
504 * @gl: the glock the blocks belong to
505 * @dblock: the starting disk block
506 * @extlen: the number of blocks in the extent
508 * returns: the first buffer in the extent
511 struct buffer_head
*gfs2_meta_ra(struct gfs2_glock
*gl
, u64 dblock
, u32 extlen
)
513 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
514 struct buffer_head
*first_bh
, *bh
;
515 u32 max_ra
= gfs2_tune_get(sdp
, gt_max_readahead
) >>
516 sdp
->sd_sb
.sb_bsize_shift
;
525 first_bh
= gfs2_getbuf(gl
, dblock
, CREATE
);
527 if (buffer_uptodate(first_bh
))
529 if (!buffer_locked(first_bh
))
530 ll_rw_block(REQ_OP_READ
, REQ_META
| REQ_PRIO
, 1, &first_bh
);
536 bh
= gfs2_getbuf(gl
, dblock
, CREATE
);
538 if (!buffer_uptodate(bh
) && !buffer_locked(bh
))
539 ll_rw_block(REQ_OP_READ
,
540 REQ_RAHEAD
| REQ_META
| REQ_PRIO
,
545 if (!buffer_locked(first_bh
) && buffer_uptodate(first_bh
))
549 wait_on_buffer(first_bh
);