blob: 78a5f43126677d6d3d0567b7fc67348fdbe22e0a [file] [log] [blame]
David Teiglandb3b94fa2006-01-16 16:50:04 +00001/*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
Bob Peterson091806ed2008-04-29 12:35:48 -05003 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
David Teiglandb3b94fa2006-01-16 16:50:04 +00004 *
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -04007 * of the GNU General Public License version 2.
David Teiglandb3b94fa2006-01-16 16:50:04 +00008 */
9
10#include <linux/sched.h>
11#include <linux/slab.h>
12#include <linux/spinlock.h>
13#include <linux/completion.h>
14#include <linux/buffer_head.h>
15#include <linux/mm.h>
16#include <linux/pagemap.h>
17#include <linux/writeback.h>
18#include <linux/swap.h>
19#include <linux/delay.h>
Steven Whitehouse2e565bb2006-10-02 11:38:25 -040020#include <linux/bio.h>
Steven Whitehouse5c676f62006-02-27 17:23:27 -050021#include <linux/gfs2_ondisk.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000022
23#include "gfs2.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050024#include "incore.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000025#include "glock.h"
26#include "glops.h"
27#include "inode.h"
28#include "log.h"
29#include "lops.h"
30#include "meta_io.h"
31#include "rgrp.h"
32#include "trans.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050033#include "util.h"
Steven Whitehouse4340fe62006-07-11 09:46:33 -040034#include "ops_address.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000035
Steven Whitehouse4a0f9a32009-04-20 08:16:26 +010036static int gfs2_aspace_writepage(struct page *page, struct writeback_control *wbc)
David Teiglandb3b94fa2006-01-16 16:50:04 +000037{
Steven Whitehouse4a0f9a32009-04-20 08:16:26 +010038 int err;
39 struct buffer_head *bh, *head;
40 int nr_underway = 0;
41 int write_op = (1 << BIO_RW_META) | ((wbc->sync_mode == WB_SYNC_ALL ?
42 WRITE_SYNC_PLUG : WRITE));
David Teiglandb3b94fa2006-01-16 16:50:04 +000043
Steven Whitehouse4a0f9a32009-04-20 08:16:26 +010044 BUG_ON(!PageLocked(page));
45 BUG_ON(!page_has_buffers(page));
46
47 head = page_buffers(page);
48 bh = head;
49
50 do {
51 if (!buffer_mapped(bh))
52 continue;
53 /*
54 * If it's a fully non-blocking write attempt and we cannot
55 * lock the buffer then redirty the page. Note that this can
56 * potentially cause a busy-wait loop from pdflush and kswapd
57 * activity, but those code paths have their own higher-level
58 * throttling.
59 */
60 if (wbc->sync_mode != WB_SYNC_NONE || !wbc->nonblocking) {
61 lock_buffer(bh);
62 } else if (!trylock_buffer(bh)) {
63 redirty_page_for_writepage(wbc, page);
64 continue;
65 }
66 if (test_clear_buffer_dirty(bh)) {
67 mark_buffer_async_write(bh);
68 } else {
69 unlock_buffer(bh);
70 }
71 } while ((bh = bh->b_this_page) != head);
72
73 /*
74 * The page and its buffers are protected by PageWriteback(), so we can
75 * drop the bh refcounts early.
76 */
77 BUG_ON(PageWriteback(page));
78 set_page_writeback(page);
79
80 do {
81 struct buffer_head *next = bh->b_this_page;
82 if (buffer_async_write(bh)) {
83 submit_bh(write_op, bh);
84 nr_underway++;
85 }
86 bh = next;
87 } while (bh != head);
88 unlock_page(page);
89
90 err = 0;
91 if (nr_underway == 0)
92 end_page_writeback(page);
93
94 return err;
David Teiglandb3b94fa2006-01-16 16:50:04 +000095}
96
Steven Whitehouse66de0452006-07-03 13:37:30 -040097static const struct address_space_operations aspace_aops = {
David Teiglandb3b94fa2006-01-16 16:50:04 +000098 .writepage = gfs2_aspace_writepage,
Steven Whitehouse4340fe62006-07-11 09:46:33 -040099 .releasepage = gfs2_releasepage,
Steven Whitehouse52d4c742007-11-01 09:34:14 +0000100 .sync_page = block_sync_page,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000101};
102
103/**
104 * gfs2_aspace_get - Create and initialize a struct inode structure
105 * @sdp: the filesystem the aspace is in
106 *
107 * Right now a struct inode is just a struct inode. Maybe Linux
108 * will supply a more lightweight address space construct (that works)
109 * in the future.
110 *
111 * Make sure pages/buffers in this aspace aren't in high memory.
112 *
113 * Returns: the aspace
114 */
115
116struct inode *gfs2_aspace_get(struct gfs2_sbd *sdp)
117{
118 struct inode *aspace;
Bob Peterson091806ed2008-04-29 12:35:48 -0500119 struct gfs2_inode *ip;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000120
121 aspace = new_inode(sdp->sd_vfs);
122 if (aspace) {
Steven Whitehousef3bba032006-07-11 09:50:54 -0400123 mapping_set_gfp_mask(aspace->i_mapping, GFP_NOFS);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000124 aspace->i_mapping->a_ops = &aspace_aops;
125 aspace->i_size = ~0ULL;
Bob Peterson091806ed2008-04-29 12:35:48 -0500126 ip = GFS2_I(aspace);
127 clear_bit(GIF_USER, &ip->i_flags);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000128 insert_inode_hash(aspace);
129 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000130 return aspace;
131}
132
133void gfs2_aspace_put(struct inode *aspace)
134{
135 remove_inode_hash(aspace);
136 iput(aspace);
137}
138
139/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000140 * gfs2_meta_sync - Sync all buffers associated with a glock
141 * @gl: The glock
David Teiglandb3b94fa2006-01-16 16:50:04 +0000142 *
143 */
144
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400145void gfs2_meta_sync(struct gfs2_glock *gl)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000146{
147 struct address_space *mapping = gl->gl_aspace->i_mapping;
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400148 int error;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000149
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400150 filemap_fdatawrite(mapping);
151 error = filemap_fdatawait(mapping);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000152
153 if (error)
154 gfs2_io_error(gl->gl_sbd);
155}
156
157/**
Steven Whitehouse6802e342008-05-21 17:03:22 +0100158 * gfs2_getbuf - Get a buffer with a given address space
Steven Whitehousecb4c0312006-11-23 11:16:32 -0500159 * @gl: the glock
David Teiglandb3b94fa2006-01-16 16:50:04 +0000160 * @blkno: the block number (filesystem scope)
161 * @create: 1 if the buffer should be created
162 *
163 * Returns: the buffer
164 */
165
Steven Whitehouse6802e342008-05-21 17:03:22 +0100166struct buffer_head *gfs2_getbuf(struct gfs2_glock *gl, u64 blkno, int create)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000167{
Steven Whitehousecb4c0312006-11-23 11:16:32 -0500168 struct address_space *mapping = gl->gl_aspace->i_mapping;
169 struct gfs2_sbd *sdp = gl->gl_sbd;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000170 struct page *page;
171 struct buffer_head *bh;
172 unsigned int shift;
173 unsigned long index;
174 unsigned int bufnum;
175
176 shift = PAGE_CACHE_SHIFT - sdp->sd_sb.sb_bsize_shift;
177 index = blkno >> shift; /* convert block to page */
178 bufnum = blkno - (index << shift); /* block buf index within page */
179
180 if (create) {
181 for (;;) {
Steven Whitehousecb4c0312006-11-23 11:16:32 -0500182 page = grab_cache_page(mapping, index);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000183 if (page)
184 break;
185 yield();
186 }
187 } else {
Steven Whitehousecb4c0312006-11-23 11:16:32 -0500188 page = find_lock_page(mapping, index);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000189 if (!page)
190 return NULL;
191 }
192
193 if (!page_has_buffers(page))
194 create_empty_buffers(page, sdp->sd_sb.sb_bsize, 0);
195
196 /* Locate header for our buffer within our page */
197 for (bh = page_buffers(page); bufnum--; bh = bh->b_this_page)
198 /* Do nothing */;
199 get_bh(bh);
200
201 if (!buffer_mapped(bh))
202 map_bh(bh, sdp->sd_vfs, blkno);
203
204 unlock_page(page);
205 mark_page_accessed(page);
206 page_cache_release(page);
207
208 return bh;
209}
210
211static void meta_prep_new(struct buffer_head *bh)
212{
213 struct gfs2_meta_header *mh = (struct gfs2_meta_header *)bh->b_data;
214
215 lock_buffer(bh);
216 clear_buffer_dirty(bh);
217 set_buffer_uptodate(bh);
218 unlock_buffer(bh);
219
220 mh->mh_magic = cpu_to_be32(GFS2_MAGIC);
221}
222
223/**
224 * gfs2_meta_new - Get a block
225 * @gl: The glock associated with this block
226 * @blkno: The block number
227 *
228 * Returns: The buffer
229 */
230
Steven Whitehousecd915492006-09-04 12:49:07 -0400231struct buffer_head *gfs2_meta_new(struct gfs2_glock *gl, u64 blkno)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000232{
233 struct buffer_head *bh;
Steven Whitehouse6802e342008-05-21 17:03:22 +0100234 bh = gfs2_getbuf(gl, blkno, CREATE);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000235 meta_prep_new(bh);
236 return bh;
237}
238
239/**
240 * gfs2_meta_read - Read a block from disk
241 * @gl: The glock covering the block
242 * @blkno: The block number
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400243 * @flags: flags
David Teiglandb3b94fa2006-01-16 16:50:04 +0000244 * @bhp: the place where the buffer is returned (NULL on failure)
245 *
246 * Returns: errno
247 */
248
Steven Whitehousecd915492006-09-04 12:49:07 -0400249int gfs2_meta_read(struct gfs2_glock *gl, u64 blkno, int flags,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000250 struct buffer_head **bhp)
251{
Steven Whitehousec969f582009-04-07 14:13:01 +0100252 struct gfs2_sbd *sdp = gl->gl_sbd;
253 struct buffer_head *bh;
254
255 if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
256 return -EIO;
257
258 *bhp = bh = gfs2_getbuf(gl, blkno, CREATE);
259
260 lock_buffer(bh);
261 if (buffer_uptodate(bh)) {
262 unlock_buffer(bh);
263 return 0;
264 }
265 bh->b_end_io = end_buffer_read_sync;
266 get_bh(bh);
267 submit_bh(READ_SYNC | (1 << BIO_RW_META), bh);
268 if (!(flags & DIO_WAIT))
269 return 0;
270
271 wait_on_buffer(bh);
272 if (unlikely(!buffer_uptodate(bh))) {
273 struct gfs2_trans *tr = current->journal_info;
274 if (tr && tr->tr_touched)
275 gfs2_io_error_bh(sdp, bh);
276 brelse(bh);
277 return -EIO;
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400278 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000279
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400280 return 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000281}
282
283/**
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400284 * gfs2_meta_wait - Reread a block from disk
David Teiglandb3b94fa2006-01-16 16:50:04 +0000285 * @sdp: the filesystem
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400286 * @bh: The block to wait for
David Teiglandb3b94fa2006-01-16 16:50:04 +0000287 *
288 * Returns: errno
289 */
290
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400291int gfs2_meta_wait(struct gfs2_sbd *sdp, struct buffer_head *bh)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000292{
293 if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
294 return -EIO;
295
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400296 wait_on_buffer(bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000297
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400298 if (!buffer_uptodate(bh)) {
299 struct gfs2_trans *tr = current->journal_info;
300 if (tr && tr->tr_touched)
301 gfs2_io_error_bh(sdp, bh);
302 return -EIO;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000303 }
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400304 if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
305 return -EIO;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000306
307 return 0;
308}
309
310/**
Steven Whitehouse586dfda2006-01-18 11:32:00 +0000311 * gfs2_attach_bufdata - attach a struct gfs2_bufdata structure to a buffer
David Teiglandb3b94fa2006-01-16 16:50:04 +0000312 * @gl: the glock the buffer belongs to
313 * @bh: The buffer to be attached to
Steven Whitehouse586dfda2006-01-18 11:32:00 +0000314 * @meta: Flag to indicate whether its metadata or not
David Teiglandb3b94fa2006-01-16 16:50:04 +0000315 */
316
Steven Whitehouse568f4c92006-02-27 12:00:42 -0500317void gfs2_attach_bufdata(struct gfs2_glock *gl, struct buffer_head *bh,
318 int meta)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000319{
320 struct gfs2_bufdata *bd;
321
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000322 if (meta)
323 lock_page(bh->b_page);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000324
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500325 if (bh->b_private) {
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000326 if (meta)
327 unlock_page(bh->b_page);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000328 return;
329 }
330
Bob Peterson3e5cd082008-01-16 08:45:39 -0600331 bd = kmem_cache_zalloc(gfs2_bufdata_cachep, GFP_NOFS | __GFP_NOFAIL);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000332 bd->bd_bh = bh;
333 bd->bd_gl = gl;
334
335 INIT_LIST_HEAD(&bd->bd_list_tr);
Steven Whitehouse82ffa512006-09-04 14:47:06 -0400336 if (meta)
Steven Whitehouse586dfda2006-01-18 11:32:00 +0000337 lops_init_le(&bd->bd_le, &gfs2_buf_lops);
Steven Whitehouse82ffa512006-09-04 14:47:06 -0400338 else
Steven Whitehouse586dfda2006-01-18 11:32:00 +0000339 lops_init_le(&bd->bd_le, &gfs2_databuf_lops);
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500340 bh->b_private = bd;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000341
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000342 if (meta)
343 unlock_page(bh->b_page);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000344}
345
Steven Whitehouse16615be2007-09-17 10:59:52 +0100346void gfs2_remove_from_journal(struct buffer_head *bh, struct gfs2_trans *tr, int meta)
347{
348 struct gfs2_sbd *sdp = GFS2_SB(bh->b_page->mapping->host);
349 struct gfs2_bufdata *bd = bh->b_private;
350 if (test_clear_buffer_pinned(bh)) {
351 list_del_init(&bd->bd_le.le_list);
352 if (meta) {
353 gfs2_assert_warn(sdp, sdp->sd_log_num_buf);
354 sdp->sd_log_num_buf--;
355 tr->tr_num_buf_rm++;
356 } else {
357 gfs2_assert_warn(sdp, sdp->sd_log_num_databuf);
358 sdp->sd_log_num_databuf--;
359 tr->tr_num_databuf_rm++;
360 }
361 tr->tr_touched = 1;
362 brelse(bh);
363 }
364 if (bd) {
365 if (bd->bd_ail) {
Steven Whitehousef91a0d32007-10-15 16:29:05 +0100366 gfs2_remove_from_ail(bd);
Steven Whitehouse16615be2007-09-17 10:59:52 +0100367 bh->b_private = NULL;
368 bd->bd_bh = NULL;
369 bd->bd_blkno = bh->b_blocknr;
370 gfs2_trans_add_revoke(sdp, bd);
371 }
372 }
373 clear_buffer_dirty(bh);
374 clear_buffer_uptodate(bh);
375}
376
David Teiglandb3b94fa2006-01-16 16:50:04 +0000377/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000378 * gfs2_meta_wipe - make inode's buffers so they aren't dirty/pinned anymore
379 * @ip: the inode who owns the buffers
380 * @bstart: the first buffer in the run
381 * @blen: the number of buffers in the run
382 *
383 */
384
Steven Whitehousecd915492006-09-04 12:49:07 -0400385void gfs2_meta_wipe(struct gfs2_inode *ip, u64 bstart, u32 blen)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000386{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400387 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000388 struct buffer_head *bh;
389
390 while (blen) {
Steven Whitehouse6802e342008-05-21 17:03:22 +0100391 bh = gfs2_getbuf(ip->i_gl, bstart, NO_CREATE);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000392 if (bh) {
Steven Whitehouse1ad38c42007-09-03 11:01:33 +0100393 lock_buffer(bh);
394 gfs2_log_lock(sdp);
Steven Whitehouse16615be2007-09-17 10:59:52 +0100395 gfs2_remove_from_journal(bh, current->journal_info, 1);
Steven Whitehouse1ad38c42007-09-03 11:01:33 +0100396 gfs2_log_unlock(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000397 unlock_buffer(bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000398 brelse(bh);
399 }
400
401 bstart++;
402 blen--;
403 }
404}
405
406/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000407 * gfs2_meta_indirect_buffer - Get a metadata buffer
408 * @ip: The GFS2 inode
409 * @height: The level of this buf in the metadata (indir addr) tree (if any)
410 * @num: The block number (device relative) of the buffer
411 * @new: Non-zero if we may create a new buffer
412 * @bhp: the buffer is returned here
413 *
David Teiglandb3b94fa2006-01-16 16:50:04 +0000414 * Returns: errno
415 */
416
Steven Whitehousecd915492006-09-04 12:49:07 -0400417int gfs2_meta_indirect_buffer(struct gfs2_inode *ip, int height, u64 num,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000418 int new, struct buffer_head **bhp)
419{
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400420 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
421 struct gfs2_glock *gl = ip->i_gl;
Steven Whitehousef91a0d32007-10-15 16:29:05 +0100422 struct buffer_head *bh;
423 int ret = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000424
425 if (new) {
Steven Whitehousef91a0d32007-10-15 16:29:05 +0100426 BUG_ON(height == 0);
427 bh = gfs2_meta_new(gl, num);
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000428 gfs2_trans_add_bh(ip->i_gl, bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000429 gfs2_metatype_set(bh, GFS2_METATYPE_IN, GFS2_FORMAT_IN);
430 gfs2_buffer_clear_tail(bh, sizeof(struct gfs2_meta_header));
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400431 } else {
432 u32 mtype = height ? GFS2_METATYPE_IN : GFS2_METATYPE_DI;
Steven Whitehousef91a0d32007-10-15 16:29:05 +0100433 ret = gfs2_meta_read(gl, num, DIO_WAIT, &bh);
434 if (ret == 0 && gfs2_metatype_check(sdp, bh, mtype)) {
435 brelse(bh);
436 ret = -EIO;
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400437 }
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400438 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000439 *bhp = bh;
Steven Whitehousef91a0d32007-10-15 16:29:05 +0100440 return ret;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000441}
442
443/**
444 * gfs2_meta_ra - start readahead on an extent of a file
445 * @gl: the glock the blocks belong to
446 * @dblock: the starting disk block
447 * @extlen: the number of blocks in the extent
448 *
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400449 * returns: the first buffer in the extent
David Teiglandb3b94fa2006-01-16 16:50:04 +0000450 */
451
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400452struct buffer_head *gfs2_meta_ra(struct gfs2_glock *gl, u64 dblock, u32 extlen)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000453{
454 struct gfs2_sbd *sdp = gl->gl_sbd;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000455 struct buffer_head *first_bh, *bh;
Steven Whitehousecd915492006-09-04 12:49:07 -0400456 u32 max_ra = gfs2_tune_get(sdp, gt_max_readahead) >>
Steven Whitehouse568f4c92006-02-27 12:00:42 -0500457 sdp->sd_sb.sb_bsize_shift;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000458
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400459 BUG_ON(!extlen);
460
461 if (max_ra < 1)
462 max_ra = 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000463 if (extlen > max_ra)
464 extlen = max_ra;
465
Steven Whitehouse6802e342008-05-21 17:03:22 +0100466 first_bh = gfs2_getbuf(gl, dblock, CREATE);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000467
468 if (buffer_uptodate(first_bh))
469 goto out;
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400470 if (!buffer_locked(first_bh))
Steven Whitehousec969f582009-04-07 14:13:01 +0100471 ll_rw_block(READ_SYNC | (1 << BIO_RW_META), 1, &first_bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000472
473 dblock++;
474 extlen--;
475
476 while (extlen) {
Steven Whitehouse6802e342008-05-21 17:03:22 +0100477 bh = gfs2_getbuf(gl, dblock, CREATE);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000478
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400479 if (!buffer_uptodate(bh) && !buffer_locked(bh))
480 ll_rw_block(READA, 1, &bh);
481 brelse(bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000482 dblock++;
483 extlen--;
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400484 if (!buffer_locked(first_bh) && buffer_uptodate(first_bh))
485 goto out;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000486 }
487
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400488 wait_on_buffer(first_bh);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400489out:
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400490 return first_bh;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000491}
492