1/*
   2 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
   3 * Copyright (C) 2004-2006 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/spinlock.h>
  11#include <linux/completion.h>
  12#include <linux/buffer_head.h>
  13#include <linux/blkdev.h>
  14#include <linux/gfs2_ondisk.h>
  15#include <linux/crc32.h>
  16
  17#include "gfs2.h"
  18#include "incore.h"
  19#include "bmap.h"
  20#include "glock.h"
  21#include "inode.h"
  22#include "meta_io.h"
  23#include "quota.h"
  24#include "rgrp.h"
  25#include "log.h"
  26#include "super.h"
  27#include "trans.h"
  28#include "dir.h"
  29#include "util.h"
  30#include "trace_gfs2.h"
  31
  32/* This doesn't need to be that large as max 64 bit pointers in a 4k
  33 * block is 512, so __u16 is fine for that. It saves stack space to
  34 * keep it small.
  35 */
  36struct metapath {
  37	struct buffer_head *mp_bh[GFS2_MAX_META_HEIGHT];
  38	__u16 mp_list[GFS2_MAX_META_HEIGHT];
  39};
  40
  41struct strip_mine {
  42	int sm_first;
  43	unsigned int sm_height;
  44};
  45
  46/**
  47 * gfs2_unstuffer_page - unstuff a stuffed inode into a block cached by a page
  48 * @ip: the inode
  49 * @dibh: the dinode buffer
  50 * @block: the block number that was allocated
  51 * @page: The (optional) page. This is looked up if @page is NULL
  52 *
  53 * Returns: errno
  54 */
  55
  56static int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh,
  57			       u64 block, struct page *page)
  58{
  59	struct inode *inode = &ip->i_inode;
  60	struct buffer_head *bh;
  61	int release = 0;
  62
  63	if (!page || page->index) {
  64		page = find_or_create_page(inode->i_mapping, 0, GFP_NOFS);
  65		if (!page)
  66			return -ENOMEM;
  67		release = 1;
  68	}
  69
  70	if (!PageUptodate(page)) {
  71		void *kaddr = kmap(page);
  72		u64 dsize = i_size_read(inode);
  73 
  74		if (dsize > (dibh->b_size - sizeof(struct gfs2_dinode)))
  75			dsize = dibh->b_size - sizeof(struct gfs2_dinode);
  76
  77		memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode), dsize);
  78		memset(kaddr + dsize, 0, PAGE_SIZE - dsize);
  79		kunmap(page);
  80
  81		SetPageUptodate(page);
  82	}
  83
  84	if (!page_has_buffers(page))
  85		create_empty_buffers(page, 1 << inode->i_blkbits,
  86				     (1 << BH_Uptodate));
  87
  88	bh = page_buffers(page);
  89
  90	if (!buffer_mapped(bh))
  91		map_bh(bh, inode->i_sb, block);
  92
  93	set_buffer_uptodate(bh);
  94	if (!gfs2_is_jdata(ip))
  95		mark_buffer_dirty(bh);
  96	if (!gfs2_is_writeback(ip))
  97		gfs2_trans_add_data(ip->i_gl, bh);
  98
  99	if (release) {
 100		unlock_page(page);
 101		put_page(page);
 102	}
 103
 104	return 0;
 105}
 106
 107/**
 108 * gfs2_unstuff_dinode - Unstuff a dinode when the data has grown too big
 109 * @ip: The GFS2 inode to unstuff
 110 * @page: The (optional) page. This is looked up if the @page is NULL
 111 *
 112 * This routine unstuffs a dinode and returns it to a "normal" state such
 113 * that the height can be grown in the traditional way.
 114 *
 115 * Returns: errno
 116 */
 117
 118int gfs2_unstuff_dinode(struct gfs2_inode *ip, struct page *page)
 119{
 120	struct buffer_head *bh, *dibh;
 121	struct gfs2_dinode *di;
 122	u64 block = 0;
 123	int isdir = gfs2_is_dir(ip);
 124	int error;
 125
 126	down_write(&ip->i_rw_mutex);
 127
 128	error = gfs2_meta_inode_buffer(ip, &dibh);
 129	if (error)
 130		goto out;
 131
 132	if (i_size_read(&ip->i_inode)) {
 133		/* Get a free block, fill it with the stuffed data,
 134		   and write it out to disk */
 135
 136		unsigned int n = 1;
 137		error = gfs2_alloc_blocks(ip, &block, &n, 0, NULL);
 138		if (error)
 139			goto out_brelse;
 140		if (isdir) {
 141			gfs2_trans_add_unrevoke(GFS2_SB(&ip->i_inode), block, 1);
 142			error = gfs2_dir_get_new_buffer(ip, block, &bh);
 143			if (error)
 144				goto out_brelse;
 145			gfs2_buffer_copy_tail(bh, sizeof(struct gfs2_meta_header),
 146					      dibh, sizeof(struct gfs2_dinode));
 147			brelse(bh);
 148		} else {
 149			error = gfs2_unstuffer_page(ip, dibh, block, page);
 150			if (error)
 151				goto out_brelse;
 152		}
 153	}
 154
 155	/*  Set up the pointer to the new block  */
 156
 157	gfs2_trans_add_meta(ip->i_gl, dibh);
 158	di = (struct gfs2_dinode *)dibh->b_data;
 159	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
 160
 161	if (i_size_read(&ip->i_inode)) {
 162		*(__be64 *)(di + 1) = cpu_to_be64(block);
 163		gfs2_add_inode_blocks(&ip->i_inode, 1);
 164		di->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(&ip->i_inode));
 165	}
 166
 167	ip->i_height = 1;
 168	di->di_height = cpu_to_be16(1);
 169
 170out_brelse:
 171	brelse(dibh);
 172out:
 173	up_write(&ip->i_rw_mutex);
 174	return error;
 175}
 176
 177
 178/**
 179 * find_metapath - Find path through the metadata tree
 180 * @sdp: The superblock
 181 * @mp: The metapath to return the result in
 182 * @block: The disk block to look up
 183 * @height: The pre-calculated height of the metadata tree
 184 *
 185 *   This routine returns a struct metapath structure that defines a path
 186 *   through the metadata of inode "ip" to get to block "block".
 187 *
 188 *   Example:
 189 *   Given:  "ip" is a height 3 file, "offset" is 101342453, and this is a
 190 *   filesystem with a blocksize of 4096.
 191 *
 192 *   find_metapath() would return a struct metapath structure set to:
 193 *   mp_offset = 101342453, mp_height = 3, mp_list[0] = 0, mp_list[1] = 48,
 194 *   and mp_list[2] = 165.
 195 *
 196 *   That means that in order to get to the block containing the byte at
 197 *   offset 101342453, we would load the indirect block pointed to by pointer
 198 *   0 in the dinode.  We would then load the indirect block pointed to by
 199 *   pointer 48 in that indirect block.  We would then load the data block
 200 *   pointed to by pointer 165 in that indirect block.
 201 *
 202 *             ----------------------------------------
 203 *             | Dinode |                             |
 204 *             |        |                            4|
 205 *             |        |0 1 2 3 4 5                 9|
 206 *             |        |                            6|
 207 *             ----------------------------------------
 208 *                       |
 209 *                       |
 210 *                       V
 211 *             ----------------------------------------
 212 *             | Indirect Block                       |
 213 *             |                                     5|
 214 *             |            4 4 4 4 4 5 5            1|
 215 *             |0           5 6 7 8 9 0 1            2|
 216 *             ----------------------------------------
 217 *                                |
 218 *                                |
 219 *                                V
 220 *             ----------------------------------------
 221 *             | Indirect Block                       |
 222 *             |                         1 1 1 1 1   5|
 223 *             |                         6 6 6 6 6   1|
 224 *             |0                        3 4 5 6 7   2|
 225 *             ----------------------------------------
 226 *                                           |
 227 *                                           |
 228 *                                           V
 229 *             ----------------------------------------
 230 *             | Data block containing offset         |
 231 *             |            101342453                 |
 232 *             |                                      |
 233 *             |                                      |
 234 *             ----------------------------------------
 235 *
 236 */
 237
 238static void find_metapath(const struct gfs2_sbd *sdp, u64 block,
 239			  struct metapath *mp, unsigned int height)
 240{
 241	unsigned int i;
 242
 243	for (i = height; i--;)
 244		mp->mp_list[i] = do_div(block, sdp->sd_inptrs);
 245
 246}
 247
 248static inline unsigned int metapath_branch_start(const struct metapath *mp)
 249{
 250	if (mp->mp_list[0] == 0)
 251		return 2;
 252	return 1;
 253}
 254
 255/**
 256 * metapointer - Return pointer to start of metadata in a buffer
 257 * @height: The metadata height (0 = dinode)
 258 * @mp: The metapath
 259 *
 260 * Return a pointer to the block number of the next height of the metadata
 261 * tree given a buffer containing the pointer to the current height of the
 262 * metadata tree.
 263 */
 264
 265static inline __be64 *metapointer(unsigned int height, const struct metapath *mp)
 266{
 267	struct buffer_head *bh = mp->mp_bh[height];
 268	unsigned int head_size = (height > 0) ?
 269		sizeof(struct gfs2_meta_header) : sizeof(struct gfs2_dinode);
 270	return ((__be64 *)(bh->b_data + head_size)) + mp->mp_list[height];
 271}
 272
 273static void gfs2_metapath_ra(struct gfs2_glock *gl,
 274			     const struct buffer_head *bh, const __be64 *pos)
 275{
 276	struct buffer_head *rabh;
 277	const __be64 *endp = (const __be64 *)(bh->b_data + bh->b_size);
 278	const __be64 *t;
 279
 280	for (t = pos; t < endp; t++) {
 281		if (!*t)
 282			continue;
 283
 284		rabh = gfs2_getbuf(gl, be64_to_cpu(*t), CREATE);
 285		if (trylock_buffer(rabh)) {
 286			if (!buffer_uptodate(rabh)) {
 287				rabh->b_end_io = end_buffer_read_sync;
 288				submit_bh(READA | REQ_META, rabh);
 289				continue;
 290			}
 291			unlock_buffer(rabh);
 292		}
 293		brelse(rabh);
 294	}
 295}
 296
 297/**
 298 * lookup_metapath - Walk the metadata tree to a specific point
 299 * @ip: The inode
 300 * @mp: The metapath
 301 *
 302 * Assumes that the inode's buffer has already been looked up and
 303 * hooked onto mp->mp_bh[0] and that the metapath has been initialised
 304 * by find_metapath().
 305 *
 306 * If this function encounters part of the tree which has not been
 307 * allocated, it returns the current height of the tree at the point
 308 * at which it found the unallocated block. Blocks which are found are
 309 * added to the mp->mp_bh[] list.
 310 *
 311 * Returns: error or height of metadata tree
 312 */
 313
 314static int lookup_metapath(struct gfs2_inode *ip, struct metapath *mp)
 315{
 316	unsigned int end_of_metadata = ip->i_height - 1;
 317	unsigned int x;
 318	__be64 *ptr;
 319	u64 dblock;
 320	int ret;
 321
 322	for (x = 0; x < end_of_metadata; x++) {
 323		ptr = metapointer(x, mp);
 324		dblock = be64_to_cpu(*ptr);
 325		if (!dblock)
 326			return x + 1;
 327
 328		ret = gfs2_meta_indirect_buffer(ip, x+1, dblock, &mp->mp_bh[x+1]);
 329		if (ret)
 330			return ret;
 331	}
 332
 333	return ip->i_height;
 334}
 335
 336static inline void release_metapath(struct metapath *mp)
 337{
 338	int i;
 339
 340	for (i = 0; i < GFS2_MAX_META_HEIGHT; i++) {
 341		if (mp->mp_bh[i] == NULL)
 342			break;
 343		brelse(mp->mp_bh[i]);
 344	}
 345}
 346
 347/**
 348 * gfs2_extent_length - Returns length of an extent of blocks
 349 * @start: Start of the buffer
 350 * @len: Length of the buffer in bytes
 351 * @ptr: Current position in the buffer
 352 * @limit: Max extent length to return (0 = unlimited)
 353 * @eob: Set to 1 if we hit "end of block"
 354 *
 355 * If the first block is zero (unallocated) it will return the number of
 356 * unallocated blocks in the extent, otherwise it will return the number
 357 * of contiguous blocks in the extent.
 358 *
 359 * Returns: The length of the extent (minimum of one block)
 360 */
 361
 362static inline unsigned int gfs2_extent_length(void *start, unsigned int len, __be64 *ptr, size_t limit, int *eob)
 363{
 364	const __be64 *end = (start + len);
 365	const __be64 *first = ptr;
 366	u64 d = be64_to_cpu(*ptr);
 367
 368	*eob = 0;
 369	do {
 370		ptr++;
 371		if (ptr >= end)
 372			break;
 373		if (limit && --limit == 0)
 374			break;
 375		if (d)
 376			d++;
 377	} while(be64_to_cpu(*ptr) == d);
 378	if (ptr >= end)
 379		*eob = 1;
 380	return (ptr - first);
 381}
 382
 383static inline void bmap_lock(struct gfs2_inode *ip, int create)
 384{
 385	if (create)
 386		down_write(&ip->i_rw_mutex);
 387	else
 388		down_read(&ip->i_rw_mutex);
 389}
 390
 391static inline void bmap_unlock(struct gfs2_inode *ip, int create)
 392{
 393	if (create)
 394		up_write(&ip->i_rw_mutex);
 395	else
 396		up_read(&ip->i_rw_mutex);
 397}
 398
 399static inline __be64 *gfs2_indirect_init(struct metapath *mp,
 400					 struct gfs2_glock *gl, unsigned int i,
 401					 unsigned offset, u64 bn)
 402{
 403	__be64 *ptr = (__be64 *)(mp->mp_bh[i - 1]->b_data +
 404		       ((i > 1) ? sizeof(struct gfs2_meta_header) :
 405				 sizeof(struct gfs2_dinode)));
 406	BUG_ON(i < 1);
 407	BUG_ON(mp->mp_bh[i] != NULL);
 408	mp->mp_bh[i] = gfs2_meta_new(gl, bn);
 409	gfs2_trans_add_meta(gl, mp->mp_bh[i]);
 410	gfs2_metatype_set(mp->mp_bh[i], GFS2_METATYPE_IN, GFS2_FORMAT_IN);
 411	gfs2_buffer_clear_tail(mp->mp_bh[i], sizeof(struct gfs2_meta_header));
 412	ptr += offset;
 413	*ptr = cpu_to_be64(bn);
 414	return ptr;
 415}
 416
 417enum alloc_state {
 418	ALLOC_DATA = 0,
 419	ALLOC_GROW_DEPTH = 1,
 420	ALLOC_GROW_HEIGHT = 2,
 421	/* ALLOC_UNSTUFF = 3,   TBD and rather complicated */
 422};
 423
 424/**
 425 * gfs2_bmap_alloc - Build a metadata tree of the requested height
 426 * @inode: The GFS2 inode
 427 * @lblock: The logical starting block of the extent
 428 * @bh_map: This is used to return the mapping details
 429 * @mp: The metapath
 430 * @sheight: The starting height (i.e. whats already mapped)
 431 * @height: The height to build to
 432 * @maxlen: The max number of data blocks to alloc
 433 *
 434 * In this routine we may have to alloc:
 435 *   i) Indirect blocks to grow the metadata tree height
 436 *  ii) Indirect blocks to fill in lower part of the metadata tree
 437 * iii) Data blocks
 438 *
 439 * The function is in two parts. The first part works out the total
 440 * number of blocks which we need. The second part does the actual
 441 * allocation asking for an extent at a time (if enough contiguous free
 442 * blocks are available, there will only be one request per bmap call)
 443 * and uses the state machine to initialise the blocks in order.
 444 *
 445 * Returns: errno on error
 446 */
 447
 448static int gfs2_bmap_alloc(struct inode *inode, const sector_t lblock,
 449			   struct buffer_head *bh_map, struct metapath *mp,
 450			   const unsigned int sheight,
 451			   const unsigned int height,
 452			   const size_t maxlen)
 453{
 454	struct gfs2_inode *ip = GFS2_I(inode);
 455	struct gfs2_sbd *sdp = GFS2_SB(inode);
 456	struct super_block *sb = sdp->sd_vfs;
 457	struct buffer_head *dibh = mp->mp_bh[0];
 458	u64 bn, dblock = 0;
 459	unsigned n, i, blks, alloced = 0, iblks = 0, branch_start = 0;
 460	unsigned dblks = 0;
 461	unsigned ptrs_per_blk;
 462	const unsigned end_of_metadata = height - 1;
 463	int ret;
 464	int eob = 0;
 465	enum alloc_state state;
 466	__be64 *ptr;
 467	__be64 zero_bn = 0;
 468
 469	BUG_ON(sheight < 1);
 470	BUG_ON(dibh == NULL);
 471
 472	gfs2_trans_add_meta(ip->i_gl, dibh);
 473
 474	if (height == sheight) {
 475		struct buffer_head *bh;
 476		/* Bottom indirect block exists, find unalloced extent size */
 477		ptr = metapointer(end_of_metadata, mp);
 478		bh = mp->mp_bh[end_of_metadata];
 479		dblks = gfs2_extent_length(bh->b_data, bh->b_size, ptr, maxlen,
 480					   &eob);
 481		BUG_ON(dblks < 1);
 482		state = ALLOC_DATA;
 483	} else {
 484		/* Need to allocate indirect blocks */
 485		ptrs_per_blk = height > 1 ? sdp->sd_inptrs : sdp->sd_diptrs;
 486		dblks = min(maxlen, (size_t)(ptrs_per_blk -
 487					     mp->mp_list[end_of_metadata]));
 488		if (height == ip->i_height) {
 489			/* Writing into existing tree, extend tree down */
 490			iblks = height - sheight;
 491			state = ALLOC_GROW_DEPTH;
 492		} else {
 493			/* Building up tree height */
 494			state = ALLOC_GROW_HEIGHT;
 495			iblks = height - ip->i_height;
 496			branch_start = metapath_branch_start(mp);
 497			iblks += (height - branch_start);
 498		}
 499	}
 500
 501	/* start of the second part of the function (state machine) */
 502
 503	blks = dblks + iblks;
 504	i = sheight;
 505	do {
 506		int error;
 507		n = blks - alloced;
 508		error = gfs2_alloc_blocks(ip, &bn, &n, 0, NULL);
 509		if (error)
 510			return error;
 511		alloced += n;
 512		if (state != ALLOC_DATA || gfs2_is_jdata(ip))
 513			gfs2_trans_add_unrevoke(sdp, bn, n);
 514		switch (state) {
 515		/* Growing height of tree */
 516		case ALLOC_GROW_HEIGHT:
 517			if (i == 1) {
 518				ptr = (__be64 *)(dibh->b_data +
 519						 sizeof(struct gfs2_dinode));
 520				zero_bn = *ptr;
 521			}
 522			for (; i - 1 < height - ip->i_height && n > 0; i++, n--)
 523				gfs2_indirect_init(mp, ip->i_gl, i, 0, bn++);
 524			if (i - 1 == height - ip->i_height) {
 525				i--;
 526				gfs2_buffer_copy_tail(mp->mp_bh[i],
 527						sizeof(struct gfs2_meta_header),
 528						dibh, sizeof(struct gfs2_dinode));
 529				gfs2_buffer_clear_tail(dibh,
 530						sizeof(struct gfs2_dinode) +
 531						sizeof(__be64));
 532				ptr = (__be64 *)(mp->mp_bh[i]->b_data +
 533					sizeof(struct gfs2_meta_header));
 534				*ptr = zero_bn;
 535				state = ALLOC_GROW_DEPTH;
 536				for(i = branch_start; i < height; i++) {
 537					if (mp->mp_bh[i] == NULL)
 538						break;
 539					brelse(mp->mp_bh[i]);
 540					mp->mp_bh[i] = NULL;
 541				}
 542				i = branch_start;
 543			}
 544			if (n == 0)
 545				break;
 546		/* Branching from existing tree */
 547		case ALLOC_GROW_DEPTH:
 548			if (i > 1 && i < height)
 549				gfs2_trans_add_meta(ip->i_gl, mp->mp_bh[i-1]);
 550			for (; i < height && n > 0; i++, n--)
 551				gfs2_indirect_init(mp, ip->i_gl, i,
 552						   mp->mp_list[i-1], bn++);
 553			if (i == height)
 554				state = ALLOC_DATA;
 555			if (n == 0)
 556				break;
 557		/* Tree complete, adding data blocks */
 558		case ALLOC_DATA:
 559			BUG_ON(n > dblks);
 560			BUG_ON(mp->mp_bh[end_of_metadata] == NULL);
 561			gfs2_trans_add_meta(ip->i_gl, mp->mp_bh[end_of_metadata]);
 562			dblks = n;
 563			ptr = metapointer(end_of_metadata, mp);
 564			dblock = bn;
 565			while (n-- > 0)
 566				*ptr++ = cpu_to_be64(bn++);
 567			if (buffer_zeronew(bh_map)) {
 568				ret = sb_issue_zeroout(sb, dblock, dblks,
 569						       GFP_NOFS);
 570				if (ret) {
 571					fs_err(sdp,
 572					       "Failed to zero data buffers\n");
 573					clear_buffer_zeronew(bh_map);
 574				}
 575			}
 576			break;
 577		}
 578	} while ((state != ALLOC_DATA) || !dblock);
 579
 580	ip->i_height = height;
 581	gfs2_add_inode_blocks(&ip->i_inode, alloced);
 582	gfs2_dinode_out(ip, mp->mp_bh[0]->b_data);
 583	map_bh(bh_map, inode->i_sb, dblock);
 584	bh_map->b_size = dblks << inode->i_blkbits;
 585	set_buffer_new(bh_map);
 586	return 0;
 587}
 588
 589/**
 590 * gfs2_block_map - Map a block from an inode to a disk block
 591 * @inode: The inode
 592 * @lblock: The logical block number
 593 * @bh_map: The bh to be mapped
 594 * @create: True if its ok to alloc blocks to satify the request
 595 *
 596 * Sets buffer_mapped() if successful, sets buffer_boundary() if a
 597 * read of metadata will be required before the next block can be
 598 * mapped. Sets buffer_new() if new blocks were allocated.
 599 *
 600 * Returns: errno
 601 */
 602
 603int gfs2_block_map(struct inode *inode, sector_t lblock,
 604		   struct buffer_head *bh_map, int create)
 605{
 606	struct gfs2_inode *ip = GFS2_I(inode);
 607	struct gfs2_sbd *sdp = GFS2_SB(inode);
 608	unsigned int bsize = sdp->sd_sb.sb_bsize;
 609	const size_t maxlen = bh_map->b_size >> inode->i_blkbits;
 610	const u64 *arr = sdp->sd_heightsize;
 611	__be64 *ptr;
 612	u64 size;
 613	struct metapath mp;
 614	int ret;
 615	int eob;
 616	unsigned int len;
 617	struct buffer_head *bh;
 618	u8 height;
 619
 620	BUG_ON(maxlen == 0);
 621
 622	memset(mp.mp_bh, 0, sizeof(mp.mp_bh));
 623	bmap_lock(ip, create);
 624	clear_buffer_mapped(bh_map);
 625	clear_buffer_new(bh_map);
 626	clear_buffer_boundary(bh_map);
 627	trace_gfs2_bmap(ip, bh_map, lblock, create, 1);
 628	if (gfs2_is_dir(ip)) {
 629		bsize = sdp->sd_jbsize;
 630		arr = sdp->sd_jheightsize;
 631	}
 632
 633	ret = gfs2_meta_inode_buffer(ip, &mp.mp_bh[0]);
 634	if (ret)
 635		goto out;
 636
 637	height = ip->i_height;
 638	size = (lblock + 1) * bsize;
 639	while (size > arr[height])
 640		height++;
 641	find_metapath(sdp, lblock, &mp, height);
 642	ret = 1;
 643	if (height > ip->i_height || gfs2_is_stuffed(ip))
 644		goto do_alloc;
 645	ret = lookup_metapath(ip, &mp);
 646	if (ret < 0)
 647		goto out;
 648	if (ret != ip->i_height)
 649		goto do_alloc;
 650	ptr = metapointer(ip->i_height - 1, &mp);
 651	if (*ptr == 0)
 652		goto do_alloc;
 653	map_bh(bh_map, inode->i_sb, be64_to_cpu(*ptr));
 654	bh = mp.mp_bh[ip->i_height - 1];
 655	len = gfs2_extent_length(bh->b_data, bh->b_size, ptr, maxlen, &eob);
 656	bh_map->b_size = (len << inode->i_blkbits);
 657	if (eob)
 658		set_buffer_boundary(bh_map);
 659	ret = 0;
 660out:
 661	release_metapath(&mp);
 662	trace_gfs2_bmap(ip, bh_map, lblock, create, ret);
 663	bmap_unlock(ip, create);
 664	return ret;
 665
 666do_alloc:
 667	/* All allocations are done here, firstly check create flag */
 668	if (!create) {
 669		BUG_ON(gfs2_is_stuffed(ip));
 670		ret = 0;
 671		goto out;
 672	}
 673
 674	/* At this point ret is the tree depth of already allocated blocks */
 675	ret = gfs2_bmap_alloc(inode, lblock, bh_map, &mp, ret, height, maxlen);
 676	goto out;
 677}
 678
 679/*
 680 * Deprecated: do not use in new code
 681 */
 682int gfs2_extent_map(struct inode *inode, u64 lblock, int *new, u64 *dblock, unsigned *extlen)
 683{
 684	struct buffer_head bh = { .b_state = 0, .b_blocknr = 0 };
 685	int ret;
 686	int create = *new;
 687
 688	BUG_ON(!extlen);
 689	BUG_ON(!dblock);
 690	BUG_ON(!new);
 691
 692	bh.b_size = 1 << (inode->i_blkbits + (create ? 0 : 5));
 693	ret = gfs2_block_map(inode, lblock, &bh, create);
 694	*extlen = bh.b_size >> inode->i_blkbits;
 695	*dblock = bh.b_blocknr;
 696	if (buffer_new(&bh))
 697		*new = 1;
 698	else
 699		*new = 0;
 700	return ret;
 701}
 702
 703/**
 704 * do_strip - Look for a layer a particular layer of the file and strip it off
 705 * @ip: the inode
 706 * @dibh: the dinode buffer
 707 * @bh: A buffer of pointers
 708 * @top: The first pointer in the buffer
 709 * @bottom: One more than the last pointer
 710 * @height: the height this buffer is at
 711 * @sm: a pointer to a struct strip_mine
 712 *
 713 * Returns: errno
 714 */
 715
 716static int do_strip(struct gfs2_inode *ip, struct buffer_head *dibh,
 717		    struct buffer_head *bh, __be64 *top, __be64 *bottom,
 718		    unsigned int height, struct strip_mine *sm)
 719{
 720	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 721	struct gfs2_rgrp_list rlist;
 722	u64 bn, bstart;
 723	u32 blen, btotal;
 724	__be64 *p;
 725	unsigned int rg_blocks = 0;
 726	int metadata;
 727	unsigned int revokes = 0;
 728	int x;
 729	int error;
 730
 731	error = gfs2_rindex_update(sdp);
 732	if (error)
 733		return error;
 734
 735	if (!*top)
 736		sm->sm_first = 0;
 737
 738	if (height != sm->sm_height)
 739		return 0;
 740
 741	if (sm->sm_first) {
 742		top++;
 743		sm->sm_first = 0;
 744	}
 745
 746	metadata = (height != ip->i_height - 1);
 747	if (metadata)
 748		revokes = (height) ? sdp->sd_inptrs : sdp->sd_diptrs;
 749	else if (ip->i_depth)
 750		revokes = sdp->sd_inptrs;
 751
 752	memset(&rlist, 0, sizeof(struct gfs2_rgrp_list));
 753	bstart = 0;
 754	blen = 0;
 755
 756	for (p = top; p < bottom; p++) {
 757		if (!*p)
 758			continue;
 759
 760		bn = be64_to_cpu(*p);
 761
 762		if (bstart + blen == bn)
 763			blen++;
 764		else {
 765			if (bstart)
 766				gfs2_rlist_add(ip, &rlist, bstart);
 767
 768			bstart = bn;
 769			blen = 1;
 770		}
 771	}
 772
 773	if (bstart)
 774		gfs2_rlist_add(ip, &rlist, bstart);
 775	else
 776		goto out; /* Nothing to do */
 777
 778	gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE);
 779
 780	for (x = 0; x < rlist.rl_rgrps; x++) {
 781		struct gfs2_rgrpd *rgd;
 782		rgd = rlist.rl_ghs[x].gh_gl->gl_object;
 783		rg_blocks += rgd->rd_length;
 784	}
 785
 786	error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);
 787	if (error)
 788		goto out_rlist;
 789
 790	if (gfs2_rs_active(&ip->i_res)) /* needs to be done with the rgrp glock held */
 791		gfs2_rs_deltree(&ip->i_res);
 792
 793	error = gfs2_trans_begin(sdp, rg_blocks + RES_DINODE +
 794				 RES_INDIRECT + RES_STATFS + RES_QUOTA,
 795				 revokes);
 796	if (error)
 797		goto out_rg_gunlock;
 798
 799	down_write(&ip->i_rw_mutex);
 800
 801	gfs2_trans_add_meta(ip->i_gl, dibh);
 802	gfs2_trans_add_meta(ip->i_gl, bh);
 803
 804	bstart = 0;
 805	blen = 0;
 806	btotal = 0;
 807
 808	for (p = top; p < bottom; p++) {
 809		if (!*p)
 810			continue;
 811
 812		bn = be64_to_cpu(*p);
 813
 814		if (bstart + blen == bn)
 815			blen++;
 816		else {
 817			if (bstart) {
 818				__gfs2_free_blocks(ip, bstart, blen, metadata);
 819				btotal += blen;
 820			}
 821
 822			bstart = bn;
 823			blen = 1;
 824		}
 825
 826		*p = 0;
 827		gfs2_add_inode_blocks(&ip->i_inode, -1);
 828	}
 829	if (bstart) {
 830		__gfs2_free_blocks(ip, bstart, blen, metadata);
 831		btotal += blen;
 832	}
 833
 834	gfs2_statfs_change(sdp, 0, +btotal, 0);
 835	gfs2_quota_change(ip, -(s64)btotal, ip->i_inode.i_uid,
 836			  ip->i_inode.i_gid);
 837
 838	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
 839
 840	gfs2_dinode_out(ip, dibh->b_data);
 841
 842	up_write(&ip->i_rw_mutex);
 843
 844	gfs2_trans_end(sdp);
 845
 846out_rg_gunlock:
 847	gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);
 848out_rlist:
 849	gfs2_rlist_free(&rlist);
 850out:
 851	return error;
 852}
 853
 854/**
 855 * recursive_scan - recursively scan through the end of a file
 856 * @ip: the inode
 857 * @dibh: the dinode buffer
 858 * @mp: the path through the metadata to the point to start
 859 * @height: the height the recursion is at
 860 * @block: the indirect block to look at
 861 * @first: 1 if this is the first block
 862 * @sm: data opaque to this function to pass to @bc
 863 *
 864 * When this is first called @height and @block should be zero and
 865 * @first should be 1.
 866 *
 867 * Returns: errno
 868 */
 869
 870static int recursive_scan(struct gfs2_inode *ip, struct buffer_head *dibh,
 871			  struct metapath *mp, unsigned int height,
 872			  u64 block, int first, struct strip_mine *sm)
 873{
 874	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 875	struct buffer_head *bh = NULL;
 876	__be64 *top, *bottom;
 877	u64 bn;
 878	int error;
 879	int mh_size = sizeof(struct gfs2_meta_header);
 880
 881	if (!height) {
 882		error = gfs2_meta_inode_buffer(ip, &bh);
 883		if (error)
 884			return error;
 885		dibh = bh;
 886
 887		top = (__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)) + mp->mp_list[0];
 888		bottom = (__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)) + sdp->sd_diptrs;
 889	} else {
 890		error = gfs2_meta_indirect_buffer(ip, height, block, &bh);
 891		if (error)
 892			return error;
 893
 894		top = (__be64 *)(bh->b_data + mh_size) +
 895				  (first ? mp->mp_list[height] : 0);
 896
 897		bottom = (__be64 *)(bh->b_data + mh_size) + sdp->sd_inptrs;
 898	}
 899
 900	error = do_strip(ip, dibh, bh, top, bottom, height, sm);
 901	if (error)
 902		goto out;
 903
 904	if (height < ip->i_height - 1) {
 905
 906		gfs2_metapath_ra(ip->i_gl, bh, top);
 907
 908		for (; top < bottom; top++, first = 0) {
 909			if (!*top)
 910				continue;
 911
 912			bn = be64_to_cpu(*top);
 913
 914			error = recursive_scan(ip, dibh, mp, height + 1, bn,
 915					       first, sm);
 916			if (error)
 917				break;
 918		}
 919	}
 920out:
 921	brelse(bh);
 922	return error;
 923}
 924
 925
 926/**
 927 * gfs2_block_truncate_page - Deal with zeroing out data for truncate
 928 *
 929 * This is partly borrowed from ext3.
 930 */
 931static int gfs2_block_truncate_page(struct address_space *mapping, loff_t from)
 932{
 933	struct inode *inode = mapping->host;
 934	struct gfs2_inode *ip = GFS2_I(inode);
 935	unsigned long index = from >> PAGE_SHIFT;
 936	unsigned offset = from & (PAGE_SIZE-1);
 937	unsigned blocksize, iblock, length, pos;
 938	struct buffer_head *bh;
 939	struct page *page;
 940	int err;
 941
 942	page = find_or_create_page(mapping, index, GFP_NOFS);
 943	if (!page)
 944		return 0;
 945
 946	blocksize = inode->i_sb->s_blocksize;
 947	length = blocksize - (offset & (blocksize - 1));
 948	iblock = index << (PAGE_SHIFT - inode->i_sb->s_blocksize_bits);
 949
 950	if (!page_has_buffers(page))
 951		create_empty_buffers(page, blocksize, 0);
 952
 953	/* Find the buffer that contains "offset" */
 954	bh = page_buffers(page);
 955	pos = blocksize;
 956	while (offset >= pos) {
 957		bh = bh->b_this_page;
 958		iblock++;
 959		pos += blocksize;
 960	}
 961
 962	err = 0;
 963
 964	if (!buffer_mapped(bh)) {
 965		gfs2_block_map(inode, iblock, bh, 0);
 966		/* unmapped? It's a hole - nothing to do */
 967		if (!buffer_mapped(bh))
 968			goto unlock;
 969	}
 970
 971	/* Ok, it's mapped. Make sure it's up-to-date */
 972	if (PageUptodate(page))
 973		set_buffer_uptodate(bh);
 974
 975	if (!buffer_uptodate(bh)) {
 976		err = -EIO;
 977		ll_rw_block(READ, 1, &bh);
 978		wait_on_buffer(bh);
 979		/* Uhhuh. Read error. Complain and punt. */
 980		if (!buffer_uptodate(bh))
 981			goto unlock;
 982		err = 0;
 983	}
 984
 985	if (!gfs2_is_writeback(ip))
 986		gfs2_trans_add_data(ip->i_gl, bh);
 987
 988	zero_user(page, offset, length);
 989	mark_buffer_dirty(bh);
 990unlock:
 991	unlock_page(page);
 992	put_page(page);
 993	return err;
 994}
 995
 996#define GFS2_JTRUNC_REVOKES 8192
 997
 998/**
 999 * gfs2_journaled_truncate - Wrapper for truncate_pagecache for jdata files
1000 * @inode: The inode being truncated
1001 * @oldsize: The original (larger) size
1002 * @newsize: The new smaller size
1003 *
1004 * With jdata files, we have to journal a revoke for each block which is
1005 * truncated. As a result, we need to split this into separate transactions
1006 * if the number of pages being truncated gets too large.
1007 */
1008
 
 
1009static int gfs2_journaled_truncate(struct inode *inode, u64 oldsize, u64 newsize)
1010{
1011	struct gfs2_sbd *sdp = GFS2_SB(inode);
1012	u64 max_chunk = GFS2_JTRUNC_REVOKES * sdp->sd_vfs->s_blocksize;
1013	u64 chunk;
1014	int error;
1015
1016	while (oldsize != newsize) {
1017		chunk = oldsize - newsize;
1018		if (chunk > max_chunk)
1019			chunk = max_chunk;
1020		truncate_pagecache(inode, oldsize - chunk);
1021		oldsize -= chunk;
1022		gfs2_trans_end(sdp);
1023		error = gfs2_trans_begin(sdp, RES_DINODE, GFS2_JTRUNC_REVOKES);
1024		if (error)
1025			return error;
1026	}
1027
1028	return 0;
1029}
1030
1031static int trunc_start(struct inode *inode, u64 oldsize, u64 newsize)
1032{
1033	struct gfs2_inode *ip = GFS2_I(inode);
1034	struct gfs2_sbd *sdp = GFS2_SB(inode);
1035	struct address_space *mapping = inode->i_mapping;
1036	struct buffer_head *dibh;
1037	int journaled = gfs2_is_jdata(ip);
1038	int error;
1039
1040	if (journaled)
1041		error = gfs2_trans_begin(sdp, RES_DINODE + RES_JDATA, GFS2_JTRUNC_REVOKES);
1042	else
1043		error = gfs2_trans_begin(sdp, RES_DINODE, 0);
1044	if (error)
1045		return error;
1046
1047	error = gfs2_meta_inode_buffer(ip, &dibh);
1048	if (error)
1049		goto out;
1050
1051	gfs2_trans_add_meta(ip->i_gl, dibh);
1052
1053	if (gfs2_is_stuffed(ip)) {
1054		gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode) + newsize);
1055	} else {
1056		if (newsize & (u64)(sdp->sd_sb.sb_bsize - 1)) {
1057			error = gfs2_block_truncate_page(mapping, newsize);
1058			if (error)
1059				goto out_brelse;
1060		}
1061		ip->i_diskflags |= GFS2_DIF_TRUNC_IN_PROG;
1062	}
1063
1064	i_size_write(inode, newsize);
1065	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
1066	gfs2_dinode_out(ip, dibh->b_data);
1067
1068	if (journaled)
1069		error = gfs2_journaled_truncate(inode, oldsize, newsize);
1070	else
1071		truncate_pagecache(inode, newsize);
1072
1073	if (error) {
1074		brelse(dibh);
1075		return error;
1076	}
1077
1078out_brelse:
1079	brelse(dibh);
1080out:
1081	gfs2_trans_end(sdp);
1082	return error;
1083}
1084
1085static int trunc_dealloc(struct gfs2_inode *ip, u64 size)
1086{
1087	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1088	unsigned int height = ip->i_height;
1089	u64 lblock;
1090	struct metapath mp;
1091	int error;
1092
1093	if (!size)
1094		lblock = 0;
1095	else
1096		lblock = (size - 1) >> sdp->sd_sb.sb_bsize_shift;
1097
1098	find_metapath(sdp, lblock, &mp, ip->i_height);
1099	error = gfs2_rindex_update(sdp);
1100	if (error)
1101		return error;
1102
1103	error = gfs2_quota_hold(ip, NO_UID_QUOTA_CHANGE, NO_GID_QUOTA_CHANGE);
1104	if (error)
1105		return error;
1106
1107	while (height--) {
1108		struct strip_mine sm;
1109		sm.sm_first = !!size;
1110		sm.sm_height = height;
1111
1112		error = recursive_scan(ip, NULL, &mp, 0, 0, 1, &sm);
1113		if (error)
1114			break;
1115	}
1116
1117	gfs2_quota_unhold(ip);
1118
1119	return error;
1120}
1121
1122static int trunc_end(struct gfs2_inode *ip)
1123{
1124	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1125	struct buffer_head *dibh;
1126	int error;
1127
1128	error = gfs2_trans_begin(sdp, RES_DINODE, 0);
1129	if (error)
1130		return error;
1131
1132	down_write(&ip->i_rw_mutex);
1133
1134	error = gfs2_meta_inode_buffer(ip, &dibh);
1135	if (error)
1136		goto out;
1137
1138	if (!i_size_read(&ip->i_inode)) {
1139		ip->i_height = 0;
1140		ip->i_goal = ip->i_no_addr;
1141		gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
1142		gfs2_ordered_del_inode(ip);
1143	}
1144	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
1145	ip->i_diskflags &= ~GFS2_DIF_TRUNC_IN_PROG;
1146
1147	gfs2_trans_add_meta(ip->i_gl, dibh);
1148	gfs2_dinode_out(ip, dibh->b_data);
1149	brelse(dibh);
1150
1151out:
1152	up_write(&ip->i_rw_mutex);
1153	gfs2_trans_end(sdp);
1154	return error;
1155}
1156
1157/**
1158 * do_shrink - make a file smaller
1159 * @inode: the inode
1160 * @oldsize: the current inode size
1161 * @newsize: the size to make the file
1162 *
1163 * Called with an exclusive lock on @inode. The @size must
1164 * be equal to or smaller than the current inode size.
1165 *
1166 * Returns: errno
1167 */
1168
1169static int do_shrink(struct inode *inode, u64 oldsize, u64 newsize)
1170{
1171	struct gfs2_inode *ip = GFS2_I(inode);
1172	int error;
1173
1174	error = trunc_start(inode, oldsize, newsize);
1175	if (error < 0)
1176		return error;
1177	if (gfs2_is_stuffed(ip))
1178		return 0;
1179
1180	error = trunc_dealloc(ip, newsize);
1181	if (error == 0)
1182		error = trunc_end(ip);
1183
1184	return error;
1185}
1186
1187void gfs2_trim_blocks(struct inode *inode)
1188{
1189	u64 size = inode->i_size;
1190	int ret;
1191
1192	ret = do_shrink(inode, size, size);
1193	WARN_ON(ret != 0);
1194}
1195
1196/**
1197 * do_grow - Touch and update inode size
1198 * @inode: The inode
1199 * @size: The new size
1200 *
1201 * This function updates the timestamps on the inode and
1202 * may also increase the size of the inode. This function
1203 * must not be called with @size any smaller than the current
1204 * inode size.
1205 *
1206 * Although it is not strictly required to unstuff files here,
1207 * earlier versions of GFS2 have a bug in the stuffed file reading
1208 * code which will result in a buffer overrun if the size is larger
1209 * than the max stuffed file size. In order to prevent this from
1210 * occurring, such files are unstuffed, but in other cases we can
1211 * just update the inode size directly.
1212 *
1213 * Returns: 0 on success, or -ve on error
1214 */
1215
1216static int do_grow(struct inode *inode, u64 size)
1217{
1218	struct gfs2_inode *ip = GFS2_I(inode);
1219	struct gfs2_sbd *sdp = GFS2_SB(inode);
1220	struct gfs2_alloc_parms ap = { .target = 1, };
1221	struct buffer_head *dibh;
1222	int error;
1223	int unstuff = 0;
1224
1225	if (gfs2_is_stuffed(ip) &&
1226	    (size > (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)))) {
1227		error = gfs2_quota_lock_check(ip, &ap);
1228		if (error)
1229			return error;
1230
1231		error = gfs2_inplace_reserve(ip, &ap);
1232		if (error)
1233			goto do_grow_qunlock;
1234		unstuff = 1;
1235	}
1236
1237	error = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS + RES_RG_BIT +
1238				 (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF ?
1239				  0 : RES_QUOTA), 0);
1240	if (error)
1241		goto do_grow_release;
1242
1243	if (unstuff) {
1244		error = gfs2_unstuff_dinode(ip, NULL);
1245		if (error)
1246			goto do_end_trans;
1247	}
1248
1249	error = gfs2_meta_inode_buffer(ip, &dibh);
1250	if (error)
1251		goto do_end_trans;
1252
1253	i_size_write(inode, size);
1254	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
1255	gfs2_trans_add_meta(ip->i_gl, dibh);
1256	gfs2_dinode_out(ip, dibh->b_data);
1257	brelse(dibh);
1258
1259do_end_trans:
1260	gfs2_trans_end(sdp);
1261do_grow_release:
1262	if (unstuff) {
1263		gfs2_inplace_release(ip);
1264do_grow_qunlock:
1265		gfs2_quota_unlock(ip);
1266	}
1267	return error;
1268}
1269
1270/**
1271 * gfs2_setattr_size - make a file a given size
1272 * @inode: the inode
1273 * @newsize: the size to make the file
1274 *
1275 * The file size can grow, shrink, or stay the same size. This
1276 * is called holding i_mutex and an exclusive glock on the inode
1277 * in question.
1278 *
1279 * Returns: errno
1280 */
1281
1282int gfs2_setattr_size(struct inode *inode, u64 newsize)
1283{
1284	struct gfs2_inode *ip = GFS2_I(inode);
1285	int ret;
1286	u64 oldsize;
1287
1288	BUG_ON(!S_ISREG(inode->i_mode));
1289
1290	ret = inode_newsize_ok(inode, newsize);
1291	if (ret)
1292		return ret;
1293
 
 
 
 
1294	inode_dio_wait(inode);
1295
1296	ret = gfs2_rsqa_alloc(ip);
1297	if (ret)
1298		goto out;
1299
1300	oldsize = inode->i_size;
1301	if (newsize >= oldsize) {
1302		ret = do_grow(inode, newsize);
1303		goto out;
1304	}
1305
 
1306	ret = do_shrink(inode, oldsize, newsize);
1307out:
1308	gfs2_rsqa_delete(ip, NULL);
1309	return ret;
1310}
1311
1312int gfs2_truncatei_resume(struct gfs2_inode *ip)
1313{
1314	int error;
1315	error = trunc_dealloc(ip, i_size_read(&ip->i_inode));
1316	if (!error)
1317		error = trunc_end(ip);
1318	return error;
1319}
1320
1321int gfs2_file_dealloc(struct gfs2_inode *ip)
1322{
1323	return trunc_dealloc(ip, 0);
1324}
1325
1326/**
1327 * gfs2_free_journal_extents - Free cached journal bmap info
1328 * @jd: The journal
1329 *
1330 */
1331
1332void gfs2_free_journal_extents(struct gfs2_jdesc *jd)
1333{
1334	struct gfs2_journal_extent *jext;
1335
1336	while(!list_empty(&jd->extent_list)) {
1337		jext = list_entry(jd->extent_list.next, struct gfs2_journal_extent, list);
1338		list_del(&jext->list);
1339		kfree(jext);
1340	}
1341}
1342
1343/**
1344 * gfs2_add_jextent - Add or merge a new extent to extent cache
1345 * @jd: The journal descriptor
1346 * @lblock: The logical block at start of new extent
1347 * @dblock: The physical block at start of new extent
1348 * @blocks: Size of extent in fs blocks
1349 *
1350 * Returns: 0 on success or -ENOMEM
1351 */
1352
1353static int gfs2_add_jextent(struct gfs2_jdesc *jd, u64 lblock, u64 dblock, u64 blocks)
1354{
1355	struct gfs2_journal_extent *jext;
1356
1357	if (!list_empty(&jd->extent_list)) {
1358		jext = list_entry(jd->extent_list.prev, struct gfs2_journal_extent, list);
1359		if ((jext->dblock + jext->blocks) == dblock) {
1360			jext->blocks += blocks;
1361			return 0;
1362		}
1363	}
1364
1365	jext = kzalloc(sizeof(struct gfs2_journal_extent), GFP_NOFS);
1366	if (jext == NULL)
1367		return -ENOMEM;
1368	jext->dblock = dblock;
1369	jext->lblock = lblock;
1370	jext->blocks = blocks;
1371	list_add_tail(&jext->list, &jd->extent_list);
1372	jd->nr_extents++;
1373	return 0;
1374}
1375
1376/**
1377 * gfs2_map_journal_extents - Cache journal bmap info
1378 * @sdp: The super block
1379 * @jd: The journal to map
1380 *
1381 * Create a reusable "extent" mapping from all logical
1382 * blocks to all physical blocks for the given journal.  This will save
1383 * us time when writing journal blocks.  Most journals will have only one
1384 * extent that maps all their logical blocks.  That's because gfs2.mkfs
1385 * arranges the journal blocks sequentially to maximize performance.
1386 * So the extent would map the first block for the entire file length.
1387 * However, gfs2_jadd can happen while file activity is happening, so
1388 * those journals may not be sequential.  Less likely is the case where
1389 * the users created their own journals by mounting the metafs and
1390 * laying it out.  But it's still possible.  These journals might have
1391 * several extents.
1392 *
1393 * Returns: 0 on success, or error on failure
1394 */
1395
1396int gfs2_map_journal_extents(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd)
1397{
1398	u64 lblock = 0;
1399	u64 lblock_stop;
1400	struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
1401	struct buffer_head bh;
1402	unsigned int shift = sdp->sd_sb.sb_bsize_shift;
1403	u64 size;
1404	int rc;
1405
1406	lblock_stop = i_size_read(jd->jd_inode) >> shift;
1407	size = (lblock_stop - lblock) << shift;
1408	jd->nr_extents = 0;
1409	WARN_ON(!list_empty(&jd->extent_list));
1410
1411	do {
1412		bh.b_state = 0;
1413		bh.b_blocknr = 0;
1414		bh.b_size = size;
1415		rc = gfs2_block_map(jd->jd_inode, lblock, &bh, 0);
1416		if (rc || !buffer_mapped(&bh))
1417			goto fail;
1418		rc = gfs2_add_jextent(jd, lblock, bh.b_blocknr, bh.b_size >> shift);
1419		if (rc)
1420			goto fail;
1421		size -= bh.b_size;
1422		lblock += (bh.b_size >> ip->i_inode.i_blkbits);
1423	} while(size > 0);
1424
1425	fs_info(sdp, "journal %d mapped with %u extents\n", jd->jd_jid,
1426		jd->nr_extents);
1427	return 0;
1428
1429fail:
1430	fs_warn(sdp, "error %d mapping journal %u at offset %llu (extent %u)\n",
1431		rc, jd->jd_jid,
1432		(unsigned long long)(i_size_read(jd->jd_inode) - size),
1433		jd->nr_extents);
1434	fs_warn(sdp, "bmap=%d lblock=%llu block=%llu, state=0x%08lx, size=%llu\n",
1435		rc, (unsigned long long)lblock, (unsigned long long)bh.b_blocknr,
1436		bh.b_state, (unsigned long long)bh.b_size);
1437	gfs2_free_journal_extents(jd);
1438	return rc;
1439}
1440
1441/**
1442 * gfs2_write_alloc_required - figure out if a write will require an allocation
1443 * @ip: the file being written to
1444 * @offset: the offset to write to
1445 * @len: the number of bytes being written
1446 *
1447 * Returns: 1 if an alloc is required, 0 otherwise
1448 */
1449
1450int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset,
1451			      unsigned int len)
1452{
1453	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1454	struct buffer_head bh;
1455	unsigned int shift;
1456	u64 lblock, lblock_stop, size;
1457	u64 end_of_file;
1458
1459	if (!len)
1460		return 0;
1461
1462	if (gfs2_is_stuffed(ip)) {
1463		if (offset + len >
1464		    sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode))
1465			return 1;
1466		return 0;
1467	}
1468
1469	shift = sdp->sd_sb.sb_bsize_shift;
1470	BUG_ON(gfs2_is_dir(ip));
1471	end_of_file = (i_size_read(&ip->i_inode) + sdp->sd_sb.sb_bsize - 1) >> shift;
1472	lblock = offset >> shift;
1473	lblock_stop = (offset + len + sdp->sd_sb.sb_bsize - 1) >> shift;
1474	if (lblock_stop > end_of_file)
1475		return 1;
1476
1477	size = (lblock_stop - lblock) << shift;
1478	do {
1479		bh.b_state = 0;
1480		bh.b_size = size;
1481		gfs2_block_map(&ip->i_inode, lblock, &bh, 0);
1482		if (!buffer_mapped(&bh))
1483			return 1;
1484		size -= bh.b_size;
1485		lblock += (bh.b_size >> ip->i_inode.i_blkbits);
1486	} while(size > 0);
1487
1488	return 0;
1489}
1490