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