bmap.c 31.4 KB
Newer Older
D
David Teigland 已提交
1 2
/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3
 * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
D
David Teigland 已提交
4 5 6
 *
 * This copyrighted material is made available to anyone wishing to use,
 * modify, copy, or redistribute it subject to the terms and conditions
7
 * of the GNU General Public License version 2.
D
David Teigland 已提交
8 9 10 11 12
 */

#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
13
#include <linux/gfs2_ondisk.h>
14
#include <linux/crc32.h>
D
David Teigland 已提交
15 16

#include "gfs2.h"
17
#include "incore.h"
D
David Teigland 已提交
18 19 20 21 22 23 24
#include "bmap.h"
#include "glock.h"
#include "inode.h"
#include "meta_io.h"
#include "quota.h"
#include "rgrp.h"
#include "trans.h"
25
#include "dir.h"
26
#include "util.h"
S
Steven Whitehouse 已提交
27
#include "trace_gfs2.h"
D
David Teigland 已提交
28 29 30 31 32 33

/* This doesn't need to be that large as max 64 bit pointers in a 4k
 * block is 512, so __u16 is fine for that. It saves stack space to
 * keep it small.
 */
struct metapath {
34
	struct buffer_head *mp_bh[GFS2_MAX_META_HEIGHT];
D
David Teigland 已提交
35 36 37 38
	__u16 mp_list[GFS2_MAX_META_HEIGHT];
};

typedef int (*block_call_t) (struct gfs2_inode *ip, struct buffer_head *dibh,
A
Al Viro 已提交
39 40
			     struct buffer_head *bh, __be64 *top,
			     __be64 *bottom, unsigned int height,
D
David Teigland 已提交
41 42 43 44 45 46 47
			     void *data);

struct strip_mine {
	int sm_first;
	unsigned int sm_height;
};

48 49 50 51 52
/**
 * gfs2_unstuffer_page - unstuff a stuffed inode into a block cached by a page
 * @ip: the inode
 * @dibh: the dinode buffer
 * @block: the block number that was allocated
S
Steven Whitehouse 已提交
53
 * @page: The (optional) page. This is looked up if @page is NULL
54 55 56 57 58
 *
 * Returns: errno
 */

static int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh,
59
			       u64 block, struct page *page)
60 61 62 63 64 65 66 67 68 69 70 71 72 73
{
	struct inode *inode = &ip->i_inode;
	struct buffer_head *bh;
	int release = 0;

	if (!page || page->index) {
		page = grab_cache_page(inode->i_mapping, 0);
		if (!page)
			return -ENOMEM;
		release = 1;
	}

	if (!PageUptodate(page)) {
		void *kaddr = kmap(page);
74 75 76 77
		u64 dsize = i_size_read(inode);
 
		if (dsize > (dibh->b_size - sizeof(struct gfs2_dinode)))
			dsize = dibh->b_size - sizeof(struct gfs2_dinode);
78

79 80
		memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode), dsize);
		memset(kaddr + dsize, 0, PAGE_CACHE_SIZE - dsize);
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
		kunmap(page);

		SetPageUptodate(page);
	}

	if (!page_has_buffers(page))
		create_empty_buffers(page, 1 << inode->i_blkbits,
				     (1 << BH_Uptodate));

	bh = page_buffers(page);

	if (!buffer_mapped(bh))
		map_bh(bh, inode->i_sb, block);

	set_buffer_uptodate(bh);
96 97
	if (!gfs2_is_jdata(ip))
		mark_buffer_dirty(bh);
98
	if (!gfs2_is_writeback(ip))
99
		gfs2_trans_add_bh(ip->i_gl, bh, 0);
100 101 102 103 104 105 106 107 108

	if (release) {
		unlock_page(page);
		page_cache_release(page);
	}

	return 0;
}

D
David Teigland 已提交
109 110 111
/**
 * gfs2_unstuff_dinode - Unstuff a dinode when the data has grown too big
 * @ip: The GFS2 inode to unstuff
S
Steven Whitehouse 已提交
112
 * @page: The (optional) page. This is looked up if the @page is NULL
D
David Teigland 已提交
113 114 115 116 117 118 119
 *
 * This routine unstuffs a dinode and returns it to a "normal" state such
 * that the height can be grown in the traditional way.
 *
 * Returns: errno
 */

120
int gfs2_unstuff_dinode(struct gfs2_inode *ip, struct page *page)
D
David Teigland 已提交
121 122
{
	struct buffer_head *bh, *dibh;
123
	struct gfs2_dinode *di;
124
	u64 block = 0;
125
	int isdir = gfs2_is_dir(ip);
D
David Teigland 已提交
126 127 128 129 130 131 132
	int error;

	down_write(&ip->i_rw_mutex);

	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (error)
		goto out;
133

S
Steven Whitehouse 已提交
134
	if (i_size_read(&ip->i_inode)) {
D
David Teigland 已提交
135 136 137
		/* Get a free block, fill it with the stuffed data,
		   and write it out to disk */

138
		unsigned int n = 1;
139 140 141
		error = gfs2_alloc_block(ip, &block, &n);
		if (error)
			goto out_brelse;
142
		if (isdir) {
143
			gfs2_trans_add_unrevoke(GFS2_SB(&ip->i_inode), block, 1);
144
			error = gfs2_dir_get_new_buffer(ip, block, &bh);
D
David Teigland 已提交
145 146
			if (error)
				goto out_brelse;
147
			gfs2_buffer_copy_tail(bh, sizeof(struct gfs2_meta_header),
D
David Teigland 已提交
148 149 150
					      dibh, sizeof(struct gfs2_dinode));
			brelse(bh);
		} else {
151
			error = gfs2_unstuffer_page(ip, dibh, block, page);
D
David Teigland 已提交
152 153 154 155 156 157 158
			if (error)
				goto out_brelse;
		}
	}

	/*  Set up the pointer to the new block  */

159
	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
160
	di = (struct gfs2_dinode *)dibh->b_data;
D
David Teigland 已提交
161 162
	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));

S
Steven Whitehouse 已提交
163
	if (i_size_read(&ip->i_inode)) {
164
		*(__be64 *)(di + 1) = cpu_to_be64(block);
165 166
		gfs2_add_inode_blocks(&ip->i_inode, 1);
		di->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(&ip->i_inode));
D
David Teigland 已提交
167 168
	}

169
	ip->i_height = 1;
170
	di->di_height = cpu_to_be16(1);
D
David Teigland 已提交
171

172
out_brelse:
D
David Teigland 已提交
173
	brelse(dibh);
174
out:
D
David Teigland 已提交
175 176 177 178 179 180 181
	up_write(&ip->i_rw_mutex);
	return error;
}


/**
 * find_metapath - Find path through the metadata tree
182
 * @sdp: The superblock
D
David Teigland 已提交
183 184
 * @mp: The metapath to return the result in
 * @block: The disk block to look up
185
 * @height: The pre-calculated height of the metadata tree
D
David Teigland 已提交
186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
 *
 *   This routine returns a struct metapath structure that defines a path
 *   through the metadata of inode "ip" to get to block "block".
 *
 *   Example:
 *   Given:  "ip" is a height 3 file, "offset" is 101342453, and this is a
 *   filesystem with a blocksize of 4096.
 *
 *   find_metapath() would return a struct metapath structure set to:
 *   mp_offset = 101342453, mp_height = 3, mp_list[0] = 0, mp_list[1] = 48,
 *   and mp_list[2] = 165.
 *
 *   That means that in order to get to the block containing the byte at
 *   offset 101342453, we would load the indirect block pointed to by pointer
 *   0 in the dinode.  We would then load the indirect block pointed to by
 *   pointer 48 in that indirect block.  We would then load the data block
 *   pointed to by pointer 165 in that indirect block.
 *
 *             ----------------------------------------
 *             | Dinode |                             |
 *             |        |                            4|
 *             |        |0 1 2 3 4 5                 9|
 *             |        |                            6|
 *             ----------------------------------------
 *                       |
 *                       |
 *                       V
 *             ----------------------------------------
 *             | Indirect Block                       |
 *             |                                     5|
 *             |            4 4 4 4 4 5 5            1|
 *             |0           5 6 7 8 9 0 1            2|
 *             ----------------------------------------
 *                                |
 *                                |
 *                                V
 *             ----------------------------------------
 *             | Indirect Block                       |
 *             |                         1 1 1 1 1   5|
 *             |                         6 6 6 6 6   1|
 *             |0                        3 4 5 6 7   2|
 *             ----------------------------------------
 *                                           |
 *                                           |
 *                                           V
 *             ----------------------------------------
 *             | Data block containing offset         |
 *             |            101342453                 |
 *             |                                      |
 *             |                                      |
 *             ----------------------------------------
 *
 */

240 241
static void find_metapath(const struct gfs2_sbd *sdp, u64 block,
			  struct metapath *mp, unsigned int height)
D
David Teigland 已提交
242 243 244
{
	unsigned int i;

245
	for (i = height; i--;)
B
Bob Peterson 已提交
246
		mp->mp_list[i] = do_div(block, sdp->sd_inptrs);
D
David Teigland 已提交
247 248 249

}

250
static inline unsigned int metapath_branch_start(const struct metapath *mp)
251
{
252 253 254
	if (mp->mp_list[0] == 0)
		return 2;
	return 1;
255 256
}

D
David Teigland 已提交
257 258 259 260 261 262 263 264 265 266
/**
 * metapointer - Return pointer to start of metadata in a buffer
 * @height: The metadata height (0 = dinode)
 * @mp: The metapath
 *
 * Return a pointer to the block number of the next height of the metadata
 * tree given a buffer containing the pointer to the current height of the
 * metadata tree.
 */

267
static inline __be64 *metapointer(unsigned int height, const struct metapath *mp)
D
David Teigland 已提交
268
{
269
	struct buffer_head *bh = mp->mp_bh[height];
D
David Teigland 已提交
270 271
	unsigned int head_size = (height > 0) ?
		sizeof(struct gfs2_meta_header) : sizeof(struct gfs2_dinode);
272
	return ((__be64 *)(bh->b_data + head_size)) + mp->mp_list[height];
D
David Teigland 已提交
273 274 275
}

/**
276 277
 * lookup_metapath - Walk the metadata tree to a specific point
 * @ip: The inode
D
David Teigland 已提交
278 279
 * @mp: The metapath
 *
280 281 282 283 284 285 286 287
 * Assumes that the inode's buffer has already been looked up and
 * hooked onto mp->mp_bh[0] and that the metapath has been initialised
 * by find_metapath().
 *
 * If this function encounters part of the tree which has not been
 * allocated, it returns the current height of the tree at the point
 * at which it found the unallocated block. Blocks which are found are
 * added to the mp->mp_bh[] list.
D
David Teigland 已提交
288
 *
289
 * Returns: error or height of metadata tree
D
David Teigland 已提交
290 291
 */

292
static int lookup_metapath(struct gfs2_inode *ip, struct metapath *mp)
293 294 295
{
	unsigned int end_of_metadata = ip->i_height - 1;
	unsigned int x;
296 297
	__be64 *ptr;
	u64 dblock;
298
	int ret;
299 300

	for (x = 0; x < end_of_metadata; x++) {
301 302 303 304
		ptr = metapointer(x, mp);
		dblock = be64_to_cpu(*ptr);
		if (!dblock)
			return x + 1;
305

306
		ret = gfs2_meta_indirect_buffer(ip, x+1, dblock, 0, &mp->mp_bh[x+1]);
307 308 309 310
		if (ret)
			return ret;
	}

311
	return ip->i_height;
312 313
}

314
static inline void release_metapath(struct metapath *mp)
315 316 317
{
	int i;

318 319 320 321 322
	for (i = 0; i < GFS2_MAX_META_HEIGHT; i++) {
		if (mp->mp_bh[i] == NULL)
			break;
		brelse(mp->mp_bh[i]);
	}
323 324
}

325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360
/**
 * gfs2_extent_length - Returns length of an extent of blocks
 * @start: Start of the buffer
 * @len: Length of the buffer in bytes
 * @ptr: Current position in the buffer
 * @limit: Max extent length to return (0 = unlimited)
 * @eob: Set to 1 if we hit "end of block"
 *
 * If the first block is zero (unallocated) it will return the number of
 * unallocated blocks in the extent, otherwise it will return the number
 * of contiguous blocks in the extent.
 *
 * Returns: The length of the extent (minimum of one block)
 */

static inline unsigned int gfs2_extent_length(void *start, unsigned int len, __be64 *ptr, unsigned limit, int *eob)
{
	const __be64 *end = (start + len);
	const __be64 *first = ptr;
	u64 d = be64_to_cpu(*ptr);

	*eob = 0;
	do {
		ptr++;
		if (ptr >= end)
			break;
		if (limit && --limit == 0)
			break;
		if (d)
			d++;
	} while(be64_to_cpu(*ptr) == d);
	if (ptr >= end)
		*eob = 1;
	return (ptr - first);
}

361
static inline void bmap_lock(struct gfs2_inode *ip, int create)
362 363 364 365 366 367 368
{
	if (create)
		down_write(&ip->i_rw_mutex);
	else
		down_read(&ip->i_rw_mutex);
}

369
static inline void bmap_unlock(struct gfs2_inode *ip, int create)
370 371 372 373 374 375 376
{
	if (create)
		up_write(&ip->i_rw_mutex);
	else
		up_read(&ip->i_rw_mutex);
}

377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
static inline __be64 *gfs2_indirect_init(struct metapath *mp,
					 struct gfs2_glock *gl, unsigned int i,
					 unsigned offset, u64 bn)
{
	__be64 *ptr = (__be64 *)(mp->mp_bh[i - 1]->b_data +
		       ((i > 1) ? sizeof(struct gfs2_meta_header) :
				 sizeof(struct gfs2_dinode)));
	BUG_ON(i < 1);
	BUG_ON(mp->mp_bh[i] != NULL);
	mp->mp_bh[i] = gfs2_meta_new(gl, bn);
	gfs2_trans_add_bh(gl, mp->mp_bh[i], 1);
	gfs2_metatype_set(mp->mp_bh[i], GFS2_METATYPE_IN, GFS2_FORMAT_IN);
	gfs2_buffer_clear_tail(mp->mp_bh[i], sizeof(struct gfs2_meta_header));
	ptr += offset;
	*ptr = cpu_to_be64(bn);
	return ptr;
}

enum alloc_state {
	ALLOC_DATA = 0,
	ALLOC_GROW_DEPTH = 1,
	ALLOC_GROW_HEIGHT = 2,
	/* ALLOC_UNSTUFF = 3,   TBD and rather complicated */
};

/**
 * gfs2_bmap_alloc - Build a metadata tree of the requested height
 * @inode: The GFS2 inode
 * @lblock: The logical starting block of the extent
 * @bh_map: This is used to return the mapping details
 * @mp: The metapath
 * @sheight: The starting height (i.e. whats already mapped)
 * @height: The height to build to
 * @maxlen: The max number of data blocks to alloc
 *
 * In this routine we may have to alloc:
 *   i) Indirect blocks to grow the metadata tree height
 *  ii) Indirect blocks to fill in lower part of the metadata tree
 * iii) Data blocks
 *
 * The function is in two parts. The first part works out the total
 * number of blocks which we need. The second part does the actual
 * allocation asking for an extent at a time (if enough contiguous free
 * blocks are available, there will only be one request per bmap call)
 * and uses the state machine to initialise the blocks in order.
 *
 * Returns: errno on error
 */

static int gfs2_bmap_alloc(struct inode *inode, const sector_t lblock,
			   struct buffer_head *bh_map, struct metapath *mp,
			   const unsigned int sheight,
			   const unsigned int height,
			   const unsigned int maxlen)
{
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
	struct buffer_head *dibh = mp->mp_bh[0];
	u64 bn, dblock = 0;
436
	unsigned n, i, blks, alloced = 0, iblks = 0, branch_start = 0;
437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470
	unsigned dblks = 0;
	unsigned ptrs_per_blk;
	const unsigned end_of_metadata = height - 1;
	int eob = 0;
	enum alloc_state state;
	__be64 *ptr;
	__be64 zero_bn = 0;

	BUG_ON(sheight < 1);
	BUG_ON(dibh == NULL);

	gfs2_trans_add_bh(ip->i_gl, dibh, 1);

	if (height == sheight) {
		struct buffer_head *bh;
		/* Bottom indirect block exists, find unalloced extent size */
		ptr = metapointer(end_of_metadata, mp);
		bh = mp->mp_bh[end_of_metadata];
		dblks = gfs2_extent_length(bh->b_data, bh->b_size, ptr, maxlen,
					   &eob);
		BUG_ON(dblks < 1);
		state = ALLOC_DATA;
	} else {
		/* Need to allocate indirect blocks */
		ptrs_per_blk = height > 1 ? sdp->sd_inptrs : sdp->sd_diptrs;
		dblks = min(maxlen, ptrs_per_blk - mp->mp_list[end_of_metadata]);
		if (height == ip->i_height) {
			/* Writing into existing tree, extend tree down */
			iblks = height - sheight;
			state = ALLOC_GROW_DEPTH;
		} else {
			/* Building up tree height */
			state = ALLOC_GROW_HEIGHT;
			iblks = height - ip->i_height;
471 472
			branch_start = metapath_branch_start(mp);
			iblks += (height - branch_start);
473 474 475 476 477 478 479 480
		}
	}

	/* start of the second part of the function (state machine) */

	blks = dblks + iblks;
	i = sheight;
	do {
481
		int error;
482
		n = blks - alloced;
483 484 485
		error = gfs2_alloc_block(ip, &bn, &n);
		if (error)
			return error;
486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510
		alloced += n;
		if (state != ALLOC_DATA || gfs2_is_jdata(ip))
			gfs2_trans_add_unrevoke(sdp, bn, n);
		switch (state) {
		/* Growing height of tree */
		case ALLOC_GROW_HEIGHT:
			if (i == 1) {
				ptr = (__be64 *)(dibh->b_data +
						 sizeof(struct gfs2_dinode));
				zero_bn = *ptr;
			}
			for (; i - 1 < height - ip->i_height && n > 0; i++, n--)
				gfs2_indirect_init(mp, ip->i_gl, i, 0, bn++);
			if (i - 1 == height - ip->i_height) {
				i--;
				gfs2_buffer_copy_tail(mp->mp_bh[i],
						sizeof(struct gfs2_meta_header),
						dibh, sizeof(struct gfs2_dinode));
				gfs2_buffer_clear_tail(dibh,
						sizeof(struct gfs2_dinode) +
						sizeof(__be64));
				ptr = (__be64 *)(mp->mp_bh[i]->b_data +
					sizeof(struct gfs2_meta_header));
				*ptr = zero_bn;
				state = ALLOC_GROW_DEPTH;
511
				for(i = branch_start; i < height; i++) {
512 513 514 515 516
					if (mp->mp_bh[i] == NULL)
						break;
					brelse(mp->mp_bh[i]);
					mp->mp_bh[i] = NULL;
				}
517
				i = branch_start;
518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543
			}
			if (n == 0)
				break;
		/* Branching from existing tree */
		case ALLOC_GROW_DEPTH:
			if (i > 1 && i < height)
				gfs2_trans_add_bh(ip->i_gl, mp->mp_bh[i-1], 1);
			for (; i < height && n > 0; i++, n--)
				gfs2_indirect_init(mp, ip->i_gl, i,
						   mp->mp_list[i-1], bn++);
			if (i == height)
				state = ALLOC_DATA;
			if (n == 0)
				break;
		/* Tree complete, adding data blocks */
		case ALLOC_DATA:
			BUG_ON(n > dblks);
			BUG_ON(mp->mp_bh[end_of_metadata] == NULL);
			gfs2_trans_add_bh(ip->i_gl, mp->mp_bh[end_of_metadata], 1);
			dblks = n;
			ptr = metapointer(end_of_metadata, mp);
			dblock = bn;
			while (n-- > 0)
				*ptr++ = cpu_to_be64(bn++);
			break;
		}
544
	} while ((state != ALLOC_DATA) || !dblock);
545 546 547 548 549 550 551 552 553 554

	ip->i_height = height;
	gfs2_add_inode_blocks(&ip->i_inode, alloced);
	gfs2_dinode_out(ip, mp->mp_bh[0]->b_data);
	map_bh(bh_map, inode->i_sb, dblock);
	bh_map->b_size = dblks << inode->i_blkbits;
	set_buffer_new(bh_map);
	return 0;
}

D
David Teigland 已提交
555
/**
556
 * gfs2_block_map - Map a block from an inode to a disk block
S
Steven Whitehouse 已提交
557
 * @inode: The inode
D
David Teigland 已提交
558
 * @lblock: The logical block number
559
 * @bh_map: The bh to be mapped
560
 * @create: True if its ok to alloc blocks to satify the request
D
David Teigland 已提交
561
 *
562 563 564
 * Sets buffer_mapped() if successful, sets buffer_boundary() if a
 * read of metadata will be required before the next block can be
 * mapped. Sets buffer_new() if new blocks were allocated.
D
David Teigland 已提交
565 566 567 568
 *
 * Returns: errno
 */

569 570
int gfs2_block_map(struct inode *inode, sector_t lblock,
		   struct buffer_head *bh_map, int create)
D
David Teigland 已提交
571
{
572 573
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
574
	unsigned int bsize = sdp->sd_sb.sb_bsize;
575
	const unsigned int maxlen = bh_map->b_size >> inode->i_blkbits;
576
	const u64 *arr = sdp->sd_heightsize;
577 578 579 580 581 582 583 584
	__be64 *ptr;
	u64 size;
	struct metapath mp;
	int ret;
	int eob;
	unsigned int len;
	struct buffer_head *bh;
	u8 height;
S
Steven Whitehouse 已提交
585

586
	BUG_ON(maxlen == 0);
D
David Teigland 已提交
587

588
	memset(mp.mp_bh, 0, sizeof(mp.mp_bh));
589
	bmap_lock(ip, create);
590 591 592
	clear_buffer_mapped(bh_map);
	clear_buffer_new(bh_map);
	clear_buffer_boundary(bh_map);
S
Steven Whitehouse 已提交
593
	trace_gfs2_bmap(ip, bh_map, lblock, create, 1);
594 595 596 597
	if (gfs2_is_dir(ip)) {
		bsize = sdp->sd_jbsize;
		arr = sdp->sd_jheightsize;
	}
598

599 600 601
	ret = gfs2_meta_inode_buffer(ip, &mp.mp_bh[0]);
	if (ret)
		goto out;
D
David Teigland 已提交
602

603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627
	height = ip->i_height;
	size = (lblock + 1) * bsize;
	while (size > arr[height])
		height++;
	find_metapath(sdp, lblock, &mp, height);
	ret = 1;
	if (height > ip->i_height || gfs2_is_stuffed(ip))
		goto do_alloc;
	ret = lookup_metapath(ip, &mp);
	if (ret < 0)
		goto out;
	if (ret != ip->i_height)
		goto do_alloc;
	ptr = metapointer(ip->i_height - 1, &mp);
	if (*ptr == 0)
		goto do_alloc;
	map_bh(bh_map, inode->i_sb, be64_to_cpu(*ptr));
	bh = mp.mp_bh[ip->i_height - 1];
	len = gfs2_extent_length(bh->b_data, bh->b_size, ptr, maxlen, &eob);
	bh_map->b_size = (len << inode->i_blkbits);
	if (eob)
		set_buffer_boundary(bh_map);
	ret = 0;
out:
	release_metapath(&mp);
S
Steven Whitehouse 已提交
628
	trace_gfs2_bmap(ip, bh_map, lblock, create, ret);
629 630
	bmap_unlock(ip, create);
	return ret;
631

632 633 634 635 636 637
do_alloc:
	/* All allocations are done here, firstly check create flag */
	if (!create) {
		BUG_ON(gfs2_is_stuffed(ip));
		ret = 0;
		goto out;
D
David Teigland 已提交
638
	}
639 640 641 642

	/* At this point ret is the tree depth of already allocated blocks */
	ret = gfs2_bmap_alloc(inode, lblock, bh_map, &mp, ret, height, maxlen);
	goto out;
S
Steven Whitehouse 已提交
643 644
}

645 646 647
/*
 * Deprecated: do not use in new code
 */
S
Steven Whitehouse 已提交
648 649
int gfs2_extent_map(struct inode *inode, u64 lblock, int *new, u64 *dblock, unsigned *extlen)
{
650
	struct buffer_head bh = { .b_state = 0, .b_blocknr = 0 };
651
	int ret;
S
Steven Whitehouse 已提交
652 653 654 655 656 657
	int create = *new;

	BUG_ON(!extlen);
	BUG_ON(!dblock);
	BUG_ON(!new);

658
	bh.b_size = 1 << (inode->i_blkbits + (create ? 0 : 5));
659
	ret = gfs2_block_map(inode, lblock, &bh, create);
660 661 662 663 664 665 666
	*extlen = bh.b_size >> inode->i_blkbits;
	*dblock = bh.b_blocknr;
	if (buffer_new(&bh))
		*new = 1;
	else
		*new = 0;
	return ret;
D
David Teigland 已提交
667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687
}

/**
 * recursive_scan - recursively scan through the end of a file
 * @ip: the inode
 * @dibh: the dinode buffer
 * @mp: the path through the metadata to the point to start
 * @height: the height the recursion is at
 * @block: the indirect block to look at
 * @first: 1 if this is the first block
 * @bc: the call to make for each piece of metadata
 * @data: data opaque to this function to pass to @bc
 *
 * When this is first called @height and @block should be zero and
 * @first should be 1.
 *
 * Returns: errno
 */

static int recursive_scan(struct gfs2_inode *ip, struct buffer_head *dibh,
			  struct metapath *mp, unsigned int height,
688
			  u64 block, int first, block_call_t bc,
D
David Teigland 已提交
689 690
			  void *data)
{
691
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
D
David Teigland 已提交
692
	struct buffer_head *bh = NULL;
A
Al Viro 已提交
693
	__be64 *top, *bottom;
694
	u64 bn;
D
David Teigland 已提交
695 696 697 698 699 700 701 702 703
	int error;
	int mh_size = sizeof(struct gfs2_meta_header);

	if (!height) {
		error = gfs2_meta_inode_buffer(ip, &bh);
		if (error)
			return error;
		dibh = bh;

A
Al Viro 已提交
704 705
		top = (__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)) + mp->mp_list[0];
		bottom = (__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)) + sdp->sd_diptrs;
D
David Teigland 已提交
706 707 708 709 710
	} else {
		error = gfs2_meta_indirect_buffer(ip, height, block, 0, &bh);
		if (error)
			return error;

A
Al Viro 已提交
711
		top = (__be64 *)(bh->b_data + mh_size) +
J
Jan Engelhardt 已提交
712
				  (first ? mp->mp_list[height] : 0);
D
David Teigland 已提交
713

A
Al Viro 已提交
714
		bottom = (__be64 *)(bh->b_data + mh_size) + sdp->sd_inptrs;
D
David Teigland 已提交
715 716 717 718 719 720
	}

	error = bc(ip, dibh, bh, top, bottom, height, data);
	if (error)
		goto out;

721
	if (height < ip->i_height - 1)
D
David Teigland 已提交
722 723 724 725 726 727 728 729 730 731 732 733
		for (; top < bottom; top++, first = 0) {
			if (!*top)
				continue;

			bn = be64_to_cpu(*top);

			error = recursive_scan(ip, dibh, mp, height + 1, bn,
					       first, bc, data);
			if (error)
				break;
		}

734
out:
D
David Teigland 已提交
735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752
	brelse(bh);
	return error;
}

/**
 * do_strip - Look for a layer a particular layer of the file and strip it off
 * @ip: the inode
 * @dibh: the dinode buffer
 * @bh: A buffer of pointers
 * @top: The first pointer in the buffer
 * @bottom: One more than the last pointer
 * @height: the height this buffer is at
 * @data: a pointer to a struct strip_mine
 *
 * Returns: errno
 */

static int do_strip(struct gfs2_inode *ip, struct buffer_head *dibh,
A
Al Viro 已提交
753
		    struct buffer_head *bh, __be64 *top, __be64 *bottom,
D
David Teigland 已提交
754 755
		    unsigned int height, void *data)
{
756 757
	struct strip_mine *sm = data;
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
D
David Teigland 已提交
758
	struct gfs2_rgrp_list rlist;
759 760
	u64 bn, bstart;
	u32 blen;
A
Al Viro 已提交
761
	__be64 *p;
D
David Teigland 已提交
762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778
	unsigned int rg_blocks = 0;
	int metadata;
	unsigned int revokes = 0;
	int x;
	int error;

	if (!*top)
		sm->sm_first = 0;

	if (height != sm->sm_height)
		return 0;

	if (sm->sm_first) {
		top++;
		sm->sm_first = 0;
	}

779
	metadata = (height != ip->i_height - 1);
D
David Teigland 已提交
780 781 782
	if (metadata)
		revokes = (height) ? sdp->sd_inptrs : sdp->sd_diptrs;

783
	error = gfs2_rindex_hold(sdp, &ip->i_alloc->al_ri_gh);
D
David Teigland 已提交
784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812
	if (error)
		return error;

	memset(&rlist, 0, sizeof(struct gfs2_rgrp_list));
	bstart = 0;
	blen = 0;

	for (p = top; p < bottom; p++) {
		if (!*p)
			continue;

		bn = be64_to_cpu(*p);

		if (bstart + blen == bn)
			blen++;
		else {
			if (bstart)
				gfs2_rlist_add(sdp, &rlist, bstart);

			bstart = bn;
			blen = 1;
		}
	}

	if (bstart)
		gfs2_rlist_add(sdp, &rlist, bstart);
	else
		goto out; /* Nothing to do */

813
	gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE);
D
David Teigland 已提交
814 815 816

	for (x = 0; x < rlist.rl_rgrps; x++) {
		struct gfs2_rgrpd *rgd;
817
		rgd = rlist.rl_ghs[x].gh_gl->gl_object;
818
		rg_blocks += rgd->rd_length;
D
David Teigland 已提交
819 820 821 822 823 824 825 826 827 828 829 830 831 832
	}

	error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);
	if (error)
		goto out_rlist;

	error = gfs2_trans_begin(sdp, rg_blocks + RES_DINODE +
				 RES_INDIRECT + RES_STATFS + RES_QUOTA,
				 revokes);
	if (error)
		goto out_rg_gunlock;

	down_write(&ip->i_rw_mutex);

833 834
	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
	gfs2_trans_add_bh(ip->i_gl, bh, 1);
D
David Teigland 已提交
835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859

	bstart = 0;
	blen = 0;

	for (p = top; p < bottom; p++) {
		if (!*p)
			continue;

		bn = be64_to_cpu(*p);

		if (bstart + blen == bn)
			blen++;
		else {
			if (bstart) {
				if (metadata)
					gfs2_free_meta(ip, bstart, blen);
				else
					gfs2_free_data(ip, bstart, blen);
			}

			bstart = bn;
			blen = 1;
		}

		*p = 0;
860
		gfs2_add_inode_blocks(&ip->i_inode, -1);
D
David Teigland 已提交
861 862 863 864 865 866 867 868
	}
	if (bstart) {
		if (metadata)
			gfs2_free_meta(ip, bstart, blen);
		else
			gfs2_free_data(ip, bstart, blen);
	}

869
	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
D
David Teigland 已提交
870

871
	gfs2_dinode_out(ip, dibh->b_data);
D
David Teigland 已提交
872 873 874 875 876

	up_write(&ip->i_rw_mutex);

	gfs2_trans_end(sdp);

877
out_rg_gunlock:
D
David Teigland 已提交
878
	gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);
879
out_rlist:
D
David Teigland 已提交
880
	gfs2_rlist_free(&rlist);
881
out:
882
	gfs2_glock_dq_uninit(&ip->i_alloc->al_ri_gh);
D
David Teigland 已提交
883 884 885
	return error;
}

S
Steven Whitehouse 已提交
886 887 888 889 890
/**
 * gfs2_block_truncate_page - Deal with zeroing out data for truncate
 *
 * This is partly borrowed from ext3.
 */
S
Steven Whitehouse 已提交
891
static int gfs2_block_truncate_page(struct address_space *mapping, loff_t from)
S
Steven Whitehouse 已提交
892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924
{
	struct inode *inode = mapping->host;
	struct gfs2_inode *ip = GFS2_I(inode);
	unsigned long index = from >> PAGE_CACHE_SHIFT;
	unsigned offset = from & (PAGE_CACHE_SIZE-1);
	unsigned blocksize, iblock, length, pos;
	struct buffer_head *bh;
	struct page *page;
	int err;

	page = grab_cache_page(mapping, index);
	if (!page)
		return 0;

	blocksize = inode->i_sb->s_blocksize;
	length = blocksize - (offset & (blocksize - 1));
	iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);

	if (!page_has_buffers(page))
		create_empty_buffers(page, blocksize, 0);

	/* Find the buffer that contains "offset" */
	bh = page_buffers(page);
	pos = blocksize;
	while (offset >= pos) {
		bh = bh->b_this_page;
		iblock++;
		pos += blocksize;
	}

	err = 0;

	if (!buffer_mapped(bh)) {
925
		gfs2_block_map(inode, iblock, bh, 0);
S
Steven Whitehouse 已提交
926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941
		/* unmapped? It's a hole - nothing to do */
		if (!buffer_mapped(bh))
			goto unlock;
	}

	/* Ok, it's mapped. Make sure it's up-to-date */
	if (PageUptodate(page))
		set_buffer_uptodate(bh);

	if (!buffer_uptodate(bh)) {
		err = -EIO;
		ll_rw_block(READ, 1, &bh);
		wait_on_buffer(bh);
		/* Uhhuh. Read error. Complain and punt. */
		if (!buffer_uptodate(bh))
			goto unlock;
942
		err = 0;
S
Steven Whitehouse 已提交
943 944
	}

945
	if (!gfs2_is_writeback(ip))
S
Steven Whitehouse 已提交
946 947
		gfs2_trans_add_bh(ip->i_gl, bh, 0);

948
	zero_user(page, offset, length);
949
	mark_buffer_dirty(bh);
S
Steven Whitehouse 已提交
950 951 952 953 954 955
unlock:
	unlock_page(page);
	page_cache_release(page);
	return err;
}

S
Steven Whitehouse 已提交
956
static int trunc_start(struct inode *inode, u64 oldsize, u64 newsize)
D
David Teigland 已提交
957
{
S
Steven Whitehouse 已提交
958 959 960
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
	struct address_space *mapping = inode->i_mapping;
D
David Teigland 已提交
961 962 963 964 965
	struct buffer_head *dibh;
	int journaled = gfs2_is_jdata(ip);
	int error;

	error = gfs2_trans_begin(sdp,
J
Jan Engelhardt 已提交
966
				 RES_DINODE + (journaled ? RES_JDATA : 0), 0);
D
David Teigland 已提交
967 968 969 970 971 972 973
	if (error)
		return error;

	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (error)
		goto out;

S
Steven Whitehouse 已提交
974 975
	gfs2_trans_add_bh(ip->i_gl, dibh, 1);

D
David Teigland 已提交
976
	if (gfs2_is_stuffed(ip)) {
S
Steven Whitehouse 已提交
977
		gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode) + newsize);
D
David Teigland 已提交
978
	} else {
S
Steven Whitehouse 已提交
979 980 981 982
		if (newsize & (u64)(sdp->sd_sb.sb_bsize - 1)) {
			error = gfs2_block_truncate_page(mapping, newsize);
			if (error)
				goto out_brelse;
D
David Teigland 已提交
983
		}
S
Steven Whitehouse 已提交
984
		ip->i_diskflags |= GFS2_DIF_TRUNC_IN_PROG;
D
David Teigland 已提交
985 986
	}

S
Steven Whitehouse 已提交
987 988 989
	i_size_write(inode, newsize);
	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
	gfs2_dinode_out(ip, dibh->b_data);
D
David Teigland 已提交
990

S
Steven Whitehouse 已提交
991 992 993
	truncate_pagecache(inode, oldsize, newsize);
out_brelse:
	brelse(dibh);
994
out:
D
David Teigland 已提交
995 996 997 998
	gfs2_trans_end(sdp);
	return error;
}

999
static int trunc_dealloc(struct gfs2_inode *ip, u64 size)
D
David Teigland 已提交
1000
{
1001
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1002
	unsigned int height = ip->i_height;
1003
	u64 lblock;
D
David Teigland 已提交
1004 1005 1006 1007 1008
	struct metapath mp;
	int error;

	if (!size)
		lblock = 0;
1009
	else
1010
		lblock = (size - 1) >> sdp->sd_sb.sb_bsize_shift;
D
David Teigland 已提交
1011

1012
	find_metapath(sdp, lblock, &mp, ip->i_height);
1013 1014
	if (!gfs2_alloc_get(ip))
		return -ENOMEM;
D
David Teigland 已提交
1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031

	error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
	if (error)
		goto out;

	while (height--) {
		struct strip_mine sm;
		sm.sm_first = !!size;
		sm.sm_height = height;

		error = recursive_scan(ip, NULL, &mp, 0, 0, 1, do_strip, &sm);
		if (error)
			break;
	}

	gfs2_quota_unhold(ip);

1032
out:
D
David Teigland 已提交
1033 1034 1035 1036 1037 1038
	gfs2_alloc_put(ip);
	return error;
}

static int trunc_end(struct gfs2_inode *ip)
{
1039
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
D
David Teigland 已提交
1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
	struct buffer_head *dibh;
	int error;

	error = gfs2_trans_begin(sdp, RES_DINODE, 0);
	if (error)
		return error;

	down_write(&ip->i_rw_mutex);

	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (error)
		goto out;

S
Steven Whitehouse 已提交
1053
	if (!i_size_read(&ip->i_inode)) {
1054
		ip->i_height = 0;
1055
		ip->i_goal = ip->i_no_addr;
D
David Teigland 已提交
1056 1057
		gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
	}
1058
	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
1059
	ip->i_diskflags &= ~GFS2_DIF_TRUNC_IN_PROG;
D
David Teigland 已提交
1060

1061
	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1062
	gfs2_dinode_out(ip, dibh->b_data);
D
David Teigland 已提交
1063 1064
	brelse(dibh);

1065
out:
D
David Teigland 已提交
1066 1067 1068 1069 1070 1071 1072
	up_write(&ip->i_rw_mutex);
	gfs2_trans_end(sdp);
	return error;
}

/**
 * do_shrink - make a file smaller
S
Steven Whitehouse 已提交
1073 1074 1075
 * @inode: the inode
 * @oldsize: the current inode size
 * @newsize: the size to make the file
D
David Teigland 已提交
1076
 *
S
Steven Whitehouse 已提交
1077 1078
 * Called with an exclusive lock on @inode. The @size must
 * be equal to or smaller than the current inode size.
D
David Teigland 已提交
1079 1080 1081 1082
 *
 * Returns: errno
 */

S
Steven Whitehouse 已提交
1083
static int do_shrink(struct inode *inode, u64 oldsize, u64 newsize)
D
David Teigland 已提交
1084
{
S
Steven Whitehouse 已提交
1085
	struct gfs2_inode *ip = GFS2_I(inode);
D
David Teigland 已提交
1086 1087
	int error;

S
Steven Whitehouse 已提交
1088
	error = trunc_start(inode, oldsize, newsize);
D
David Teigland 已提交
1089 1090
	if (error < 0)
		return error;
S
Steven Whitehouse 已提交
1091
	if (gfs2_is_stuffed(ip))
D
David Teigland 已提交
1092 1093
		return 0;

S
Steven Whitehouse 已提交
1094 1095
	error = trunc_dealloc(ip, newsize);
	if (error == 0)
D
David Teigland 已提交
1096 1097 1098 1099 1100
		error = trunc_end(ip);

	return error;
}

S
Steven Whitehouse 已提交
1101
void gfs2_trim_blocks(struct inode *inode)
W
Wendy Cheng 已提交
1102
{
S
Steven Whitehouse 已提交
1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133
	u64 size = inode->i_size;
	int ret;

	ret = do_shrink(inode, size, size);
	WARN_ON(ret != 0);
}

/**
 * do_grow - Touch and update inode size
 * @inode: The inode
 * @size: The new size
 *
 * This function updates the timestamps on the inode and
 * may also increase the size of the inode. This function
 * must not be called with @size any smaller than the current
 * inode size.
 *
 * Although it is not strictly required to unstuff files here,
 * earlier versions of GFS2 have a bug in the stuffed file reading
 * code which will result in a buffer overrun if the size is larger
 * than the max stuffed file size. In order to prevent this from
 * occuring, such files are unstuffed, but in other cases we can
 * just update the inode size directly.
 *
 * Returns: 0 on success, or -ve on error
 */

static int do_grow(struct inode *inode, u64 size)
{
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
W
Wendy Cheng 已提交
1134
	struct buffer_head *dibh;
S
Steven Whitehouse 已提交
1135
	struct gfs2_alloc *al = NULL;
W
Wendy Cheng 已提交
1136 1137
	int error;

S
Steven Whitehouse 已提交
1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153
	if (gfs2_is_stuffed(ip) &&
	    (size > (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)))) {
		al = gfs2_alloc_get(ip);
		if (al == NULL)
			return -ENOMEM;

		error = gfs2_quota_lock_check(ip);
		if (error)
			goto do_grow_alloc_put;

		al->al_requested = 1;
		error = gfs2_inplace_reserve(ip);
		if (error)
			goto do_grow_qunlock;
	}

1154
	error = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS + RES_RG_BIT, 0);
W
Wendy Cheng 已提交
1155
	if (error)
S
Steven Whitehouse 已提交
1156
		goto do_grow_release;
W
Wendy Cheng 已提交
1157

S
Steven Whitehouse 已提交
1158 1159 1160 1161 1162
	if (al) {
		error = gfs2_unstuff_dinode(ip, NULL);
		if (error)
			goto do_end_trans;
	}
W
Wendy Cheng 已提交
1163 1164 1165

	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (error)
S
Steven Whitehouse 已提交
1166
		goto do_end_trans;
W
Wendy Cheng 已提交
1167

S
Steven Whitehouse 已提交
1168
	i_size_write(inode, size);
W
Wendy Cheng 已提交
1169 1170 1171 1172 1173
	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
	gfs2_dinode_out(ip, dibh->b_data);
	brelse(dibh);

S
Steven Whitehouse 已提交
1174
do_end_trans:
W
Wendy Cheng 已提交
1175
	gfs2_trans_end(sdp);
S
Steven Whitehouse 已提交
1176 1177 1178 1179 1180 1181 1182 1183
do_grow_release:
	if (al) {
		gfs2_inplace_release(ip);
do_grow_qunlock:
		gfs2_quota_unlock(ip);
do_grow_alloc_put:
		gfs2_alloc_put(ip);
	}
W
Wendy Cheng 已提交
1184 1185 1186
	return error;
}

D
David Teigland 已提交
1187
/**
S
Steven Whitehouse 已提交
1188 1189 1190
 * gfs2_setattr_size - make a file a given size
 * @inode: the inode
 * @newsize: the size to make the file
D
David Teigland 已提交
1191
 *
S
Steven Whitehouse 已提交
1192 1193 1194
 * The file size can grow, shrink, or stay the same size. This
 * is called holding i_mutex and an exclusive glock on the inode
 * in question.
D
David Teigland 已提交
1195 1196 1197 1198
 *
 * Returns: errno
 */

S
Steven Whitehouse 已提交
1199
int gfs2_setattr_size(struct inode *inode, u64 newsize)
D
David Teigland 已提交
1200
{
S
Steven Whitehouse 已提交
1201 1202
	int ret;
	u64 oldsize;
D
David Teigland 已提交
1203

S
Steven Whitehouse 已提交
1204
	BUG_ON(!S_ISREG(inode->i_mode));
D
David Teigland 已提交
1205

S
Steven Whitehouse 已提交
1206 1207 1208
	ret = inode_newsize_ok(inode, newsize);
	if (ret)
		return ret;
D
David Teigland 已提交
1209

S
Steven Whitehouse 已提交
1210 1211 1212 1213 1214
	oldsize = inode->i_size;
	if (newsize >= oldsize)
		return do_grow(inode, newsize);

	return do_shrink(inode, oldsize, newsize);
D
David Teigland 已提交
1215 1216 1217 1218 1219
}

int gfs2_truncatei_resume(struct gfs2_inode *ip)
{
	int error;
S
Steven Whitehouse 已提交
1220
	error = trunc_dealloc(ip, i_size_read(&ip->i_inode));
D
David Teigland 已提交
1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236
	if (!error)
		error = trunc_end(ip);
	return error;
}

int gfs2_file_dealloc(struct gfs2_inode *ip)
{
	return trunc_dealloc(ip, 0);
}

/**
 * gfs2_write_alloc_required - figure out if a write will require an allocation
 * @ip: the file being written to
 * @offset: the offset to write to
 * @len: the number of bytes being written
 *
1237
 * Returns: 1 if an alloc is required, 0 otherwise
D
David Teigland 已提交
1238 1239
 */

1240
int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset,
1241
			      unsigned int len)
D
David Teigland 已提交
1242
{
1243
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1244 1245 1246
	struct buffer_head bh;
	unsigned int shift;
	u64 lblock, lblock_stop, size;
1247
	u64 end_of_file;
D
David Teigland 已提交
1248 1249 1250 1251 1252 1253 1254

	if (!len)
		return 0;

	if (gfs2_is_stuffed(ip)) {
		if (offset + len >
		    sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode))
1255
			return 1;
D
David Teigland 已提交
1256 1257 1258
		return 0;
	}

1259
	shift = sdp->sd_sb.sb_bsize_shift;
1260
	BUG_ON(gfs2_is_dir(ip));
S
Steven Whitehouse 已提交
1261
	end_of_file = (i_size_read(&ip->i_inode) + sdp->sd_sb.sb_bsize - 1) >> shift;
1262 1263 1264
	lblock = offset >> shift;
	lblock_stop = (offset + len + sdp->sd_sb.sb_bsize - 1) >> shift;
	if (lblock_stop > end_of_file)
1265
		return 1;
D
David Teigland 已提交
1266

1267 1268 1269 1270 1271 1272
	size = (lblock_stop - lblock) << shift;
	do {
		bh.b_state = 0;
		bh.b_size = size;
		gfs2_block_map(&ip->i_inode, lblock, &bh, 0);
		if (!buffer_mapped(&bh))
1273
			return 1;
1274 1275 1276
		size -= bh.b_size;
		lblock += (bh.b_size >> ip->i_inode.i_blkbits);
	} while(size > 0);
D
David Teigland 已提交
1277 1278 1279 1280

	return 0;
}