[GFS2] Clean up the glock core
[linux-2.6.git] / fs / gfs2 / meta_io.c
1 /*
2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3  * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
4  *
5  * This copyrighted material is made available to anyone wishing to use,
6  * modify, copy, or redistribute it subject to the terms and conditions
7  * of the GNU General Public License version 2.
8  */
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>
20 #include <linux/bio.h>
21 #include <linux/gfs2_ondisk.h>
22 #include <linux/lm_interface.h>
23
24 #include "gfs2.h"
25 #include "incore.h"
26 #include "glock.h"
27 #include "glops.h"
28 #include "inode.h"
29 #include "log.h"
30 #include "lops.h"
31 #include "meta_io.h"
32 #include "rgrp.h"
33 #include "trans.h"
34 #include "util.h"
35 #include "ops_address.h"
36
37 static int aspace_get_block(struct inode *inode, sector_t lblock,
38                             struct buffer_head *bh_result, int create)
39 {
40         gfs2_assert_warn(inode->i_sb->s_fs_info, 0);
41         return -EOPNOTSUPP;
42 }
43
44 static int gfs2_aspace_writepage(struct page *page,
45                                  struct writeback_control *wbc)
46 {
47         return block_write_full_page(page, aspace_get_block, wbc);
48 }
49
50 static const struct address_space_operations aspace_aops = {
51         .writepage = gfs2_aspace_writepage,
52         .releasepage = gfs2_releasepage,
53         .sync_page = block_sync_page,
54 };
55
56 /**
57  * gfs2_aspace_get - Create and initialize a struct inode structure
58  * @sdp: the filesystem the aspace is in
59  *
60  * Right now a struct inode is just a struct inode.  Maybe Linux
61  * will supply a more lightweight address space construct (that works)
62  * in the future.
63  *
64  * Make sure pages/buffers in this aspace aren't in high memory.
65  *
66  * Returns: the aspace
67  */
68
69 struct inode *gfs2_aspace_get(struct gfs2_sbd *sdp)
70 {
71         struct inode *aspace;
72         struct gfs2_inode *ip;
73
74         aspace = new_inode(sdp->sd_vfs);
75         if (aspace) {
76                 mapping_set_gfp_mask(aspace->i_mapping, GFP_NOFS);
77                 aspace->i_mapping->a_ops = &aspace_aops;
78                 aspace->i_size = ~0ULL;
79                 ip = GFS2_I(aspace);
80                 clear_bit(GIF_USER, &ip->i_flags);
81                 insert_inode_hash(aspace);
82         }
83         return aspace;
84 }
85
86 void gfs2_aspace_put(struct inode *aspace)
87 {
88         remove_inode_hash(aspace);
89         iput(aspace);
90 }
91
92 /**
93  * gfs2_meta_inval - Invalidate all buffers associated with a glock
94  * @gl: the glock
95  *
96  */
97
98 void gfs2_meta_inval(struct gfs2_glock *gl)
99 {
100         struct gfs2_sbd *sdp = gl->gl_sbd;
101         struct inode *aspace = gl->gl_aspace;
102         struct address_space *mapping = gl->gl_aspace->i_mapping;
103
104         gfs2_assert_withdraw(sdp, !atomic_read(&gl->gl_ail_count));
105
106         atomic_inc(&aspace->i_writecount);
107         truncate_inode_pages(mapping, 0);
108         atomic_dec(&aspace->i_writecount);
109
110         gfs2_assert_withdraw(sdp, !mapping->nrpages);
111 }
112
113 /**
114  * gfs2_meta_sync - Sync all buffers associated with a glock
115  * @gl: The glock
116  *
117  */
118
119 void gfs2_meta_sync(struct gfs2_glock *gl)
120 {
121         struct address_space *mapping = gl->gl_aspace->i_mapping;
122         int error;
123
124         filemap_fdatawrite(mapping);
125         error = filemap_fdatawait(mapping);
126
127         if (error)
128                 gfs2_io_error(gl->gl_sbd);
129 }
130
131 /**
132  * gfs2_getbuf - Get a buffer with a given address space
133  * @gl: the glock
134  * @blkno: the block number (filesystem scope)
135  * @create: 1 if the buffer should be created
136  *
137  * Returns: the buffer
138  */
139
140 struct buffer_head *gfs2_getbuf(struct gfs2_glock *gl, u64 blkno, int create)
141 {
142         struct address_space *mapping = gl->gl_aspace->i_mapping;
143         struct gfs2_sbd *sdp = gl->gl_sbd;
144         struct page *page;
145         struct buffer_head *bh;
146         unsigned int shift;
147         unsigned long index;
148         unsigned int bufnum;
149
150         shift = PAGE_CACHE_SHIFT - sdp->sd_sb.sb_bsize_shift;
151         index = blkno >> shift;             /* convert block to page */
152         bufnum = blkno - (index << shift);  /* block buf index within page */
153
154         if (create) {
155                 for (;;) {
156                         page = grab_cache_page(mapping, index);
157                         if (page)
158                                 break;
159                         yield();
160                 }
161         } else {
162                 page = find_lock_page(mapping, index);
163                 if (!page)
164                         return NULL;
165         }
166
167         if (!page_has_buffers(page))
168                 create_empty_buffers(page, sdp->sd_sb.sb_bsize, 0);
169
170         /* Locate header for our buffer within our page */
171         for (bh = page_buffers(page); bufnum--; bh = bh->b_this_page)
172                 /* Do nothing */;
173         get_bh(bh);
174
175         if (!buffer_mapped(bh))
176                 map_bh(bh, sdp->sd_vfs, blkno);
177
178         unlock_page(page);
179         mark_page_accessed(page);
180         page_cache_release(page);
181
182         return bh;
183 }
184
185 static void meta_prep_new(struct buffer_head *bh)
186 {
187         struct gfs2_meta_header *mh = (struct gfs2_meta_header *)bh->b_data;
188
189         lock_buffer(bh);
190         clear_buffer_dirty(bh);
191         set_buffer_uptodate(bh);
192         unlock_buffer(bh);
193
194         mh->mh_magic = cpu_to_be32(GFS2_MAGIC);
195 }
196
197 /**
198  * gfs2_meta_new - Get a block
199  * @gl: The glock associated with this block
200  * @blkno: The block number
201  *
202  * Returns: The buffer
203  */
204
205 struct buffer_head *gfs2_meta_new(struct gfs2_glock *gl, u64 blkno)
206 {
207         struct buffer_head *bh;
208         bh = gfs2_getbuf(gl, blkno, CREATE);
209         meta_prep_new(bh);
210         return bh;
211 }
212
213 /**
214  * gfs2_meta_read - Read a block from disk
215  * @gl: The glock covering the block
216  * @blkno: The block number
217  * @flags: flags
218  * @bhp: the place where the buffer is returned (NULL on failure)
219  *
220  * Returns: errno
221  */
222
223 int gfs2_meta_read(struct gfs2_glock *gl, u64 blkno, int flags,
224                    struct buffer_head **bhp)
225 {
226         *bhp = gfs2_getbuf(gl, blkno, CREATE);
227         if (!buffer_uptodate(*bhp)) {
228                 ll_rw_block(READ_META, 1, bhp);
229                 if (flags & DIO_WAIT) {
230                         int error = gfs2_meta_wait(gl->gl_sbd, *bhp);
231                         if (error) {
232                                 brelse(*bhp);
233                                 return error;
234                         }
235                 }
236         }
237
238         return 0;
239 }
240
241 /**
242  * gfs2_meta_wait - Reread a block from disk
243  * @sdp: the filesystem
244  * @bh: The block to wait for
245  *
246  * Returns: errno
247  */
248
249 int gfs2_meta_wait(struct gfs2_sbd *sdp, struct buffer_head *bh)
250 {
251         if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
252                 return -EIO;
253
254         wait_on_buffer(bh);
255
256         if (!buffer_uptodate(bh)) {
257                 struct gfs2_trans *tr = current->journal_info;
258                 if (tr && tr->tr_touched)
259                         gfs2_io_error_bh(sdp, bh);
260                 return -EIO;
261         }
262         if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
263                 return -EIO;
264
265         return 0;
266 }
267
268 /**
269  * gfs2_attach_bufdata - attach a struct gfs2_bufdata structure to a buffer
270  * @gl: the glock the buffer belongs to
271  * @bh: The buffer to be attached to
272  * @meta: Flag to indicate whether its metadata or not
273  */
274
275 void gfs2_attach_bufdata(struct gfs2_glock *gl, struct buffer_head *bh,
276                          int meta)
277 {
278         struct gfs2_bufdata *bd;
279
280         if (meta)
281                 lock_page(bh->b_page);
282
283         if (bh->b_private) {
284                 if (meta)
285                         unlock_page(bh->b_page);
286                 return;
287         }
288
289         bd = kmem_cache_zalloc(gfs2_bufdata_cachep, GFP_NOFS | __GFP_NOFAIL);
290         bd->bd_bh = bh;
291         bd->bd_gl = gl;
292
293         INIT_LIST_HEAD(&bd->bd_list_tr);
294         if (meta)
295                 lops_init_le(&bd->bd_le, &gfs2_buf_lops);
296         else
297                 lops_init_le(&bd->bd_le, &gfs2_databuf_lops);
298         bh->b_private = bd;
299
300         if (meta)
301                 unlock_page(bh->b_page);
302 }
303
304 void gfs2_remove_from_journal(struct buffer_head *bh, struct gfs2_trans *tr, int meta)
305 {
306         struct gfs2_sbd *sdp = GFS2_SB(bh->b_page->mapping->host);
307         struct gfs2_bufdata *bd = bh->b_private;
308         if (test_clear_buffer_pinned(bh)) {
309                 list_del_init(&bd->bd_le.le_list);
310                 if (meta) {
311                         gfs2_assert_warn(sdp, sdp->sd_log_num_buf);
312                         sdp->sd_log_num_buf--;
313                         tr->tr_num_buf_rm++;
314                 } else {
315                         gfs2_assert_warn(sdp, sdp->sd_log_num_databuf);
316                         sdp->sd_log_num_databuf--;
317                         tr->tr_num_databuf_rm++;
318                 }
319                 tr->tr_touched = 1;
320                 brelse(bh);
321         }
322         if (bd) {
323                 if (bd->bd_ail) {
324                         gfs2_remove_from_ail(bd);
325                         bh->b_private = NULL;
326                         bd->bd_bh = NULL;
327                         bd->bd_blkno = bh->b_blocknr;
328                         gfs2_trans_add_revoke(sdp, bd);
329                 }
330         }
331         clear_buffer_dirty(bh);
332         clear_buffer_uptodate(bh);
333 }
334
335 /**
336  * gfs2_meta_wipe - make inode's buffers so they aren't dirty/pinned anymore
337  * @ip: the inode who owns the buffers
338  * @bstart: the first buffer in the run
339  * @blen: the number of buffers in the run
340  *
341  */
342
343 void gfs2_meta_wipe(struct gfs2_inode *ip, u64 bstart, u32 blen)
344 {
345         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
346         struct buffer_head *bh;
347
348         while (blen) {
349                 bh = gfs2_getbuf(ip->i_gl, bstart, NO_CREATE);
350                 if (bh) {
351                         lock_buffer(bh);
352                         gfs2_log_lock(sdp);
353                         gfs2_remove_from_journal(bh, current->journal_info, 1);
354                         gfs2_log_unlock(sdp);
355                         unlock_buffer(bh);
356                         brelse(bh);
357                 }
358
359                 bstart++;
360                 blen--;
361         }
362 }
363
364 /**
365  * gfs2_meta_indirect_buffer - Get a metadata buffer
366  * @ip: The GFS2 inode
367  * @height: The level of this buf in the metadata (indir addr) tree (if any)
368  * @num: The block number (device relative) of the buffer
369  * @new: Non-zero if we may create a new buffer
370  * @bhp: the buffer is returned here
371  *
372  * Returns: errno
373  */
374
375 int gfs2_meta_indirect_buffer(struct gfs2_inode *ip, int height, u64 num,
376                               int new, struct buffer_head **bhp)
377 {
378         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
379         struct gfs2_glock *gl = ip->i_gl;
380         struct buffer_head *bh;
381         int ret = 0;
382
383         if (new) {
384                 BUG_ON(height == 0);
385                 bh = gfs2_meta_new(gl, num);
386                 gfs2_trans_add_bh(ip->i_gl, bh, 1);
387                 gfs2_metatype_set(bh, GFS2_METATYPE_IN, GFS2_FORMAT_IN);
388                 gfs2_buffer_clear_tail(bh, sizeof(struct gfs2_meta_header));
389         } else {
390                 u32 mtype = height ? GFS2_METATYPE_IN : GFS2_METATYPE_DI;
391                 ret = gfs2_meta_read(gl, num, DIO_WAIT, &bh);
392                 if (ret == 0 && gfs2_metatype_check(sdp, bh, mtype)) {
393                         brelse(bh);
394                         ret = -EIO;
395                 }
396         }
397         *bhp = bh;
398         return ret;
399 }
400
401 /**
402  * gfs2_meta_ra - start readahead on an extent of a file
403  * @gl: the glock the blocks belong to
404  * @dblock: the starting disk block
405  * @extlen: the number of blocks in the extent
406  *
407  * returns: the first buffer in the extent
408  */
409
410 struct buffer_head *gfs2_meta_ra(struct gfs2_glock *gl, u64 dblock, u32 extlen)
411 {
412         struct gfs2_sbd *sdp = gl->gl_sbd;
413         struct buffer_head *first_bh, *bh;
414         u32 max_ra = gfs2_tune_get(sdp, gt_max_readahead) >>
415                           sdp->sd_sb.sb_bsize_shift;
416
417         BUG_ON(!extlen);
418
419         if (max_ra < 1)
420                 max_ra = 1;
421         if (extlen > max_ra)
422                 extlen = max_ra;
423
424         first_bh = gfs2_getbuf(gl, dblock, CREATE);
425
426         if (buffer_uptodate(first_bh))
427                 goto out;
428         if (!buffer_locked(first_bh))
429                 ll_rw_block(READ_META, 1, &first_bh);
430
431         dblock++;
432         extlen--;
433
434         while (extlen) {
435                 bh = gfs2_getbuf(gl, dblock, CREATE);
436
437                 if (!buffer_uptodate(bh) && !buffer_locked(bh))
438                         ll_rw_block(READA, 1, &bh);
439                 brelse(bh);
440                 dblock++;
441                 extlen--;
442                 if (!buffer_locked(first_bh) && buffer_uptodate(first_bh))
443                         goto out;
444         }
445
446         wait_on_buffer(first_bh);
447 out:
448         return first_bh;
449 }
450