blob: cb8d7a93d5ec257204c93aac033c95146fdd1a07 [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"
David Teiglandb3b94fa2006-01-16 16:50:04 +000034
Steven Whitehouse4a0f9a32009-04-20 08:16:26 +010035static int gfs2_aspace_writepage(struct page *page, struct writeback_control *wbc)
David Teiglandb3b94fa2006-01-16 16:50:04 +000036{
Steven Whitehouse4a0f9a32009-04-20 08:16:26 +010037 int err;
38 struct buffer_head *bh, *head;
39 int nr_underway = 0;
40 int write_op = (1 << BIO_RW_META) | ((wbc->sync_mode == WB_SYNC_ALL ?
41 WRITE_SYNC_PLUG : WRITE));
David Teiglandb3b94fa2006-01-16 16:50:04 +000042
Steven Whitehouse4a0f9a32009-04-20 08:16:26 +010043 BUG_ON(!PageLocked(page));
44 BUG_ON(!page_has_buffers(page));
45
46 head = page_buffers(page);
47 bh = head;
48
49 do {
50 if (!buffer_mapped(bh))
51 continue;
52 /*
53 * If it's a fully non-blocking write attempt and we cannot
54 * lock the buffer then redirty the page. Note that this can
55 * potentially cause a busy-wait loop from pdflush and kswapd
56 * activity, but those code paths have their own higher-level
57 * throttling.
58 */
59 if (wbc->sync_mode != WB_SYNC_NONE || !wbc->nonblocking) {
60 lock_buffer(bh);
61 } else if (!trylock_buffer(bh)) {
62 redirty_page_for_writepage(wbc, page);
63 continue;
64 }
65 if (test_clear_buffer_dirty(bh)) {
66 mark_buffer_async_write(bh);
67 } else {
68 unlock_buffer(bh);
69 }
70 } while ((bh = bh->b_this_page) != head);
71
72 /*
73 * The page and its buffers are protected by PageWriteback(), so we can
74 * drop the bh refcounts early.
75 */
76 BUG_ON(PageWriteback(page));
77 set_page_writeback(page);
78
79 do {
80 struct buffer_head *next = bh->b_this_page;
81 if (buffer_async_write(bh)) {
82 submit_bh(write_op, bh);
83 nr_underway++;
84 }
85 bh = next;
86 } while (bh != head);
87 unlock_page(page);
88
89 err = 0;
90 if (nr_underway == 0)
91 end_page_writeback(page);
92
93 return err;
David Teiglandb3b94fa2006-01-16 16:50:04 +000094}
95
Steven Whitehouse66de0452006-07-03 13:37:30 -040096static const struct address_space_operations aspace_aops = {
David Teiglandb3b94fa2006-01-16 16:50:04 +000097 .writepage = gfs2_aspace_writepage,
Steven Whitehouse4340fe62006-07-11 09:46:33 -040098 .releasepage = gfs2_releasepage,
Steven Whitehouse52d4c742007-11-01 09:34:14 +000099 .sync_page = block_sync_page,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000100};
101
102/**
103 * gfs2_aspace_get - Create and initialize a struct inode structure
104 * @sdp: the filesystem the aspace is in
105 *
106 * Right now a struct inode is just a struct inode. Maybe Linux
107 * will supply a more lightweight address space construct (that works)
108 * in the future.
109 *
110 * Make sure pages/buffers in this aspace aren't in high memory.
111 *
112 * Returns: the aspace
113 */
114
115struct inode *gfs2_aspace_get(struct gfs2_sbd *sdp)
116{
117 struct inode *aspace;
Bob Peterson091806ed2008-04-29 12:35:48 -0500118 struct gfs2_inode *ip;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000119
120 aspace = new_inode(sdp->sd_vfs);
121 if (aspace) {
Steven Whitehousef3bba032006-07-11 09:50:54 -0400122 mapping_set_gfp_mask(aspace->i_mapping, GFP_NOFS);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000123 aspace->i_mapping->a_ops = &aspace_aops;
124 aspace->i_size = ~0ULL;
Bob Peterson091806ed2008-04-29 12:35:48 -0500125 ip = GFS2_I(aspace);
126 clear_bit(GIF_USER, &ip->i_flags);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000127 insert_inode_hash(aspace);
128 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000129 return aspace;
130}
131
132void gfs2_aspace_put(struct inode *aspace)
133{
134 remove_inode_hash(aspace);
135 iput(aspace);
136}
137
138/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000139 * gfs2_meta_sync - Sync all buffers associated with a glock
140 * @gl: The glock
David Teiglandb3b94fa2006-01-16 16:50:04 +0000141 *
142 */
143
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400144void gfs2_meta_sync(struct gfs2_glock *gl)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000145{
146 struct address_space *mapping = gl->gl_aspace->i_mapping;
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400147 int error;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000148
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400149 filemap_fdatawrite(mapping);
150 error = filemap_fdatawait(mapping);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000151
152 if (error)
153 gfs2_io_error(gl->gl_sbd);
154}
155
156/**
Steven Whitehouse6802e342008-05-21 17:03:22 +0100157 * gfs2_getbuf - Get a buffer with a given address space
Steven Whitehousecb4c0312006-11-23 11:16:32 -0500158 * @gl: the glock
David Teiglandb3b94fa2006-01-16 16:50:04 +0000159 * @blkno: the block number (filesystem scope)
160 * @create: 1 if the buffer should be created
161 *
162 * Returns: the buffer
163 */
164
Steven Whitehouse6802e342008-05-21 17:03:22 +0100165struct buffer_head *gfs2_getbuf(struct gfs2_glock *gl, u64 blkno, int create)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000166{
Steven Whitehousecb4c0312006-11-23 11:16:32 -0500167 struct address_space *mapping = gl->gl_aspace->i_mapping;
168 struct gfs2_sbd *sdp = gl->gl_sbd;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000169 struct page *page;
170 struct buffer_head *bh;
171 unsigned int shift;
172 unsigned long index;
173 unsigned int bufnum;
174
175 shift = PAGE_CACHE_SHIFT - sdp->sd_sb.sb_bsize_shift;
176 index = blkno >> shift; /* convert block to page */
177 bufnum = blkno - (index << shift); /* block buf index within page */
178
179 if (create) {
180 for (;;) {
Steven Whitehousecb4c0312006-11-23 11:16:32 -0500181 page = grab_cache_page(mapping, index);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000182 if (page)
183 break;
184 yield();
185 }
186 } else {
Steven Whitehousecb4c0312006-11-23 11:16:32 -0500187 page = find_lock_page(mapping, index);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000188 if (!page)
189 return NULL;
190 }
191
192 if (!page_has_buffers(page))
193 create_empty_buffers(page, sdp->sd_sb.sb_bsize, 0);
194
195 /* Locate header for our buffer within our page */
196 for (bh = page_buffers(page); bufnum--; bh = bh->b_this_page)
197 /* Do nothing */;
198 get_bh(bh);
199
200 if (!buffer_mapped(bh))
201 map_bh(bh, sdp->sd_vfs, blkno);
202
203 unlock_page(page);
204 mark_page_accessed(page);
205 page_cache_release(page);
206
207 return bh;
208}
209
210static void meta_prep_new(struct buffer_head *bh)
211{
212 struct gfs2_meta_header *mh = (struct gfs2_meta_header *)bh->b_data;
213
214 lock_buffer(bh);
215 clear_buffer_dirty(bh);
216 set_buffer_uptodate(bh);
217 unlock_buffer(bh);
218
219 mh->mh_magic = cpu_to_be32(GFS2_MAGIC);
220}
221
222/**
223 * gfs2_meta_new - Get a block
224 * @gl: The glock associated with this block
225 * @blkno: The block number
226 *
227 * Returns: The buffer
228 */
229
Steven Whitehousecd915492006-09-04 12:49:07 -0400230struct buffer_head *gfs2_meta_new(struct gfs2_glock *gl, u64 blkno)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000231{
232 struct buffer_head *bh;
Steven Whitehouse6802e342008-05-21 17:03:22 +0100233 bh = gfs2_getbuf(gl, blkno, CREATE);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000234 meta_prep_new(bh);
235 return bh;
236}
237
238/**
239 * gfs2_meta_read - Read a block from disk
240 * @gl: The glock covering the block
241 * @blkno: The block number
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400242 * @flags: flags
David Teiglandb3b94fa2006-01-16 16:50:04 +0000243 * @bhp: the place where the buffer is returned (NULL on failure)
244 *
245 * Returns: errno
246 */
247
Steven Whitehousecd915492006-09-04 12:49:07 -0400248int gfs2_meta_read(struct gfs2_glock *gl, u64 blkno, int flags,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000249 struct buffer_head **bhp)
250{
Steven Whitehousec969f58c2009-04-07 14:13:01 +0100251 struct gfs2_sbd *sdp = gl->gl_sbd;
252 struct buffer_head *bh;
253
254 if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
255 return -EIO;
256
257 *bhp = bh = gfs2_getbuf(gl, blkno, CREATE);
258
259 lock_buffer(bh);
260 if (buffer_uptodate(bh)) {
261 unlock_buffer(bh);
262 return 0;
263 }
264 bh->b_end_io = end_buffer_read_sync;
265 get_bh(bh);
266 submit_bh(READ_SYNC | (1 << BIO_RW_META), bh);
267 if (!(flags & DIO_WAIT))
268 return 0;
269
270 wait_on_buffer(bh);
271 if (unlikely(!buffer_uptodate(bh))) {
272 struct gfs2_trans *tr = current->journal_info;
273 if (tr && tr->tr_touched)
274 gfs2_io_error_bh(sdp, bh);
275 brelse(bh);
276 return -EIO;
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400277 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000278
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400279 return 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000280}
281
282/**
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400283 * gfs2_meta_wait - Reread a block from disk
David Teiglandb3b94fa2006-01-16 16:50:04 +0000284 * @sdp: the filesystem
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400285 * @bh: The block to wait for
David Teiglandb3b94fa2006-01-16 16:50:04 +0000286 *
287 * Returns: errno
288 */
289
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400290int gfs2_meta_wait(struct gfs2_sbd *sdp, struct buffer_head *bh)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000291{
292 if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
293 return -EIO;
294
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400295 wait_on_buffer(bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000296
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400297 if (!buffer_uptodate(bh)) {
298 struct gfs2_trans *tr = current->journal_info;
299 if (tr && tr->tr_touched)
300 gfs2_io_error_bh(sdp, bh);
301 return -EIO;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000302 }
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400303 if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
304 return -EIO;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000305
306 return 0;
307}
308
309/**
Steven Whitehouse586dfda2006-01-18 11:32:00 +0000310 * gfs2_attach_bufdata - attach a struct gfs2_bufdata structure to a buffer
David Teiglandb3b94fa2006-01-16 16:50:04 +0000311 * @gl: the glock the buffer belongs to
312 * @bh: The buffer to be attached to
Steven Whitehouse586dfda2006-01-18 11:32:00 +0000313 * @meta: Flag to indicate whether its metadata or not
David Teiglandb3b94fa2006-01-16 16:50:04 +0000314 */
315
Steven Whitehouse568f4c92006-02-27 12:00:42 -0500316void gfs2_attach_bufdata(struct gfs2_glock *gl, struct buffer_head *bh,
317 int meta)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000318{
319 struct gfs2_bufdata *bd;
320
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000321 if (meta)
322 lock_page(bh->b_page);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000323
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500324 if (bh->b_private) {
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000325 if (meta)
326 unlock_page(bh->b_page);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000327 return;
328 }
329
Bob Peterson3e5cd082008-01-16 08:45:39 -0600330 bd = kmem_cache_zalloc(gfs2_bufdata_cachep, GFP_NOFS | __GFP_NOFAIL);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000331 bd->bd_bh = bh;
332 bd->bd_gl = gl;
333
334 INIT_LIST_HEAD(&bd->bd_list_tr);
Steven Whitehouse82ffa512006-09-04 14:47:06 -0400335 if (meta)
Steven Whitehouse586dfda2006-01-18 11:32:00 +0000336 lops_init_le(&bd->bd_le, &gfs2_buf_lops);
Steven Whitehouse82ffa512006-09-04 14:47:06 -0400337 else
Steven Whitehouse586dfda2006-01-18 11:32:00 +0000338 lops_init_le(&bd->bd_le, &gfs2_databuf_lops);
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500339 bh->b_private = bd;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000340
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000341 if (meta)
342 unlock_page(bh->b_page);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000343}
344
Steven Whitehouse16615be2007-09-17 10:59:52 +0100345void gfs2_remove_from_journal(struct buffer_head *bh, struct gfs2_trans *tr, int meta)
346{
347 struct gfs2_sbd *sdp = GFS2_SB(bh->b_page->mapping->host);
348 struct gfs2_bufdata *bd = bh->b_private;
349 if (test_clear_buffer_pinned(bh)) {
350 list_del_init(&bd->bd_le.le_list);
351 if (meta) {
352 gfs2_assert_warn(sdp, sdp->sd_log_num_buf);
353 sdp->sd_log_num_buf--;
354 tr->tr_num_buf_rm++;
355 } else {
356 gfs2_assert_warn(sdp, sdp->sd_log_num_databuf);
357 sdp->sd_log_num_databuf--;
358 tr->tr_num_databuf_rm++;
359 }
360 tr->tr_touched = 1;
361 brelse(bh);
362 }
363 if (bd) {
364 if (bd->bd_ail) {
Steven Whitehousef91a0d32007-10-15 16:29:05 +0100365 gfs2_remove_from_ail(bd);
Steven Whitehouse16615be2007-09-17 10:59:52 +0100366 bh->b_private = NULL;
367 bd->bd_bh = NULL;
368 bd->bd_blkno = bh->b_blocknr;
369 gfs2_trans_add_revoke(sdp, bd);
370 }
371 }
372 clear_buffer_dirty(bh);
373 clear_buffer_uptodate(bh);
374}
375
David Teiglandb3b94fa2006-01-16 16:50:04 +0000376/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000377 * gfs2_meta_wipe - make inode's buffers so they aren't dirty/pinned anymore
378 * @ip: the inode who owns the buffers
379 * @bstart: the first buffer in the run
380 * @blen: the number of buffers in the run
381 *
382 */
383
Steven Whitehousecd915492006-09-04 12:49:07 -0400384void gfs2_meta_wipe(struct gfs2_inode *ip, u64 bstart, u32 blen)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000385{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400386 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000387 struct buffer_head *bh;
388
389 while (blen) {
Steven Whitehouse6802e342008-05-21 17:03:22 +0100390 bh = gfs2_getbuf(ip->i_gl, bstart, NO_CREATE);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000391 if (bh) {
Steven Whitehouse1ad38c42007-09-03 11:01:33 +0100392 lock_buffer(bh);
393 gfs2_log_lock(sdp);
Steven Whitehouse16615be2007-09-17 10:59:52 +0100394 gfs2_remove_from_journal(bh, current->journal_info, 1);
Steven Whitehouse1ad38c42007-09-03 11:01:33 +0100395 gfs2_log_unlock(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000396 unlock_buffer(bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000397 brelse(bh);
398 }
399
400 bstart++;
401 blen--;
402 }
403}
404
405/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000406 * gfs2_meta_indirect_buffer - Get a metadata buffer
407 * @ip: The GFS2 inode
408 * @height: The level of this buf in the metadata (indir addr) tree (if any)
409 * @num: The block number (device relative) of the buffer
410 * @new: Non-zero if we may create a new buffer
411 * @bhp: the buffer is returned here
412 *
David Teiglandb3b94fa2006-01-16 16:50:04 +0000413 * Returns: errno
414 */
415
Steven Whitehousecd915492006-09-04 12:49:07 -0400416int gfs2_meta_indirect_buffer(struct gfs2_inode *ip, int height, u64 num,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000417 int new, struct buffer_head **bhp)
418{
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400419 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
420 struct gfs2_glock *gl = ip->i_gl;
Steven Whitehousef91a0d32007-10-15 16:29:05 +0100421 struct buffer_head *bh;
422 int ret = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000423
424 if (new) {
Steven Whitehousef91a0d32007-10-15 16:29:05 +0100425 BUG_ON(height == 0);
426 bh = gfs2_meta_new(gl, num);
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000427 gfs2_trans_add_bh(ip->i_gl, bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000428 gfs2_metatype_set(bh, GFS2_METATYPE_IN, GFS2_FORMAT_IN);
429 gfs2_buffer_clear_tail(bh, sizeof(struct gfs2_meta_header));
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400430 } else {
431 u32 mtype = height ? GFS2_METATYPE_IN : GFS2_METATYPE_DI;
Steven Whitehousef91a0d32007-10-15 16:29:05 +0100432 ret = gfs2_meta_read(gl, num, DIO_WAIT, &bh);
433 if (ret == 0 && gfs2_metatype_check(sdp, bh, mtype)) {
434 brelse(bh);
435 ret = -EIO;
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400436 }
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400437 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000438 *bhp = bh;
Steven Whitehousef91a0d32007-10-15 16:29:05 +0100439 return ret;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000440}
441
442/**
443 * gfs2_meta_ra - start readahead on an extent of a file
444 * @gl: the glock the blocks belong to
445 * @dblock: the starting disk block
446 * @extlen: the number of blocks in the extent
447 *
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400448 * returns: the first buffer in the extent
David Teiglandb3b94fa2006-01-16 16:50:04 +0000449 */
450
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400451struct buffer_head *gfs2_meta_ra(struct gfs2_glock *gl, u64 dblock, u32 extlen)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000452{
453 struct gfs2_sbd *sdp = gl->gl_sbd;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000454 struct buffer_head *first_bh, *bh;
Steven Whitehousecd915492006-09-04 12:49:07 -0400455 u32 max_ra = gfs2_tune_get(sdp, gt_max_readahead) >>
Steven Whitehouse568f4c92006-02-27 12:00:42 -0500456 sdp->sd_sb.sb_bsize_shift;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000457
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400458 BUG_ON(!extlen);
459
460 if (max_ra < 1)
461 max_ra = 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000462 if (extlen > max_ra)
463 extlen = max_ra;
464
Steven Whitehouse6802e342008-05-21 17:03:22 +0100465 first_bh = gfs2_getbuf(gl, dblock, CREATE);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000466
467 if (buffer_uptodate(first_bh))
468 goto out;
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400469 if (!buffer_locked(first_bh))
Steven Whitehousec969f58c2009-04-07 14:13:01 +0100470 ll_rw_block(READ_SYNC | (1 << BIO_RW_META), 1, &first_bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000471
472 dblock++;
473 extlen--;
474
475 while (extlen) {
Steven Whitehouse6802e342008-05-21 17:03:22 +0100476 bh = gfs2_getbuf(gl, dblock, CREATE);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000477
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400478 if (!buffer_uptodate(bh) && !buffer_locked(bh))
479 ll_rw_block(READA, 1, &bh);
480 brelse(bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000481 dblock++;
482 extlen--;
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400483 if (!buffer_locked(first_bh) && buffer_uptodate(first_bh))
484 goto out;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000485 }
486
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400487 wait_on_buffer(first_bh);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400488out:
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400489 return first_bh;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000490}
491