inode.c 102 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 *  linux/fs/ext3/inode.c
 *
 * Copyright (C) 1992, 1993, 1994, 1995
 * Remy Card (card@masi.ibp.fr)
 * Laboratoire MASI - Institut Blaise Pascal
 * Universite Pierre et Marie Curie (Paris VI)
 *
 *  from
 *
 *  linux/fs/minix/inode.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  Goal-directed block allocation by Stephen Tweedie
16
 *	(sct@redhat.com), 1993, 1998
Linus Torvalds's avatar
Linus Torvalds committed
17 18 19
 *  Big-endian to little-endian byte-swapping/bitmaps by
 *        David S. Miller (davem@caip.rutgers.edu), 1995
 *  64-bit file support on 64-bit platforms by Jakub Jelinek
20
 *	(jj@sunsite.ms.mff.cuni.cz)
Linus Torvalds's avatar
Linus Torvalds committed
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
 *
 *  Assorted race fixes, rewrite of ext3_get_block() by Al Viro, 2000
 */

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/time.h>
#include <linux/ext3_jbd.h>
#include <linux/jbd.h>
#include <linux/highuid.h>
#include <linux/pagemap.h>
#include <linux/quotaops.h>
#include <linux/string.h>
#include <linux/buffer_head.h>
#include <linux/writeback.h>
#include <linux/mpage.h>
#include <linux/uio.h>
38
#include <linux/bio.h>
39
#include <linux/fiemap.h>
40
#include <linux/namei.h>
Linus Torvalds's avatar
Linus Torvalds committed
41 42 43 44 45 46 47 48
#include "xattr.h"
#include "acl.h"

static int ext3_writepage_trans_blocks(struct inode *inode);

/*
 * Test whether an inode is a fast symlink.
 */
49
static int ext3_inode_is_fast_symlink(struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
50 51 52 53
{
	int ea_blocks = EXT3_I(inode)->i_file_acl ?
		(inode->i_sb->s_blocksize >> 9) : 0;

54
	return (S_ISLNK(inode->i_mode) && inode->i_blocks - ea_blocks == 0);
Linus Torvalds's avatar
Linus Torvalds committed
55 56
}

57 58
/*
 * The ext3 forget function must perform a revoke if we are freeing data
Linus Torvalds's avatar
Linus Torvalds committed
59
 * which has been journaled.  Metadata (eg. indirect blocks) must be
60
 * revoked in all cases.
Linus Torvalds's avatar
Linus Torvalds committed
61 62 63 64 65
 *
 * "bh" may be NULL: a metadata block may have been freed from memory
 * but there may still be a record of it in the journal, and that record
 * still needs to be revoked.
 */
66
int ext3_forget(handle_t *handle, int is_metadata, struct inode *inode,
67
			struct buffer_head *bh, ext3_fsblk_t blocknr)
Linus Torvalds's avatar
Linus Torvalds committed
68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
{
	int err;

	might_sleep();

	BUFFER_TRACE(bh, "enter");

	jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, "
		  "data mode %lx\n",
		  bh, is_metadata, inode->i_mode,
		  test_opt(inode->i_sb, DATA_FLAGS));

	/* Never use the revoke function if we are doing full data
	 * journaling: there is no need to, and a V1 superblock won't
	 * support it.  Otherwise, only skip the revoke on un-journaled
	 * data blocks. */

	if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3_MOUNT_JOURNAL_DATA ||
	    (!is_metadata && !ext3_should_journal_data(inode))) {
		if (bh) {
			BUFFER_TRACE(bh, "call journal_forget");
			return ext3_journal_forget(handle, bh);
		}
		return 0;
	}

	/*
	 * data!=journal && (is_metadata || should_journal_data(inode))
	 */
	BUFFER_TRACE(bh, "call ext3_journal_revoke");
	err = ext3_journal_revoke(handle, blocknr, bh);
	if (err)
100
		ext3_abort(inode->i_sb, __func__,
Linus Torvalds's avatar
Linus Torvalds committed
101 102 103 104 105 106
			   "error %d when attempting revoke", err);
	BUFFER_TRACE(bh, "exit");
	return err;
}

/*
107
 * Work out how many blocks we need to proceed with the next chunk of a
Linus Torvalds's avatar
Linus Torvalds committed
108 109
 * truncate transaction.
 */
110
static unsigned long blocks_for_truncate(struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
{
	unsigned long needed;

	needed = inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9);

	/* Give ourselves just enough room to cope with inodes in which
	 * i_blocks is corrupt: we've seen disk corruptions in the past
	 * which resulted in random data in an inode which looked enough
	 * like a regular file for ext3 to try to delete it.  Things
	 * will go a bit crazy if that happens, but at least we should
	 * try not to panic the whole kernel. */
	if (needed < 2)
		needed = 2;

	/* But we need to bound the transaction so we don't overflow the
	 * journal. */
127
	if (needed > EXT3_MAX_TRANS_DATA)
Linus Torvalds's avatar
Linus Torvalds committed
128 129
		needed = EXT3_MAX_TRANS_DATA;

130
	return EXT3_DATA_TRANS_BLOCKS(inode->i_sb) + needed;
Linus Torvalds's avatar
Linus Torvalds committed
131 132
}

133
/*
Linus Torvalds's avatar
Linus Torvalds committed
134 135 136 137 138 139 140
 * Truncate transactions can be complex and absolutely huge.  So we need to
 * be able to restart the transaction at a conventient checkpoint to make
 * sure we don't overflow the journal.
 *
 * start_transaction gets us a new handle for a truncate transaction,
 * and extend_transaction tries to extend the existing one a bit.  If
 * extend fails, we need to propagate the failure up and restart the
141
 * transaction in the top-level truncate loop. --sct
Linus Torvalds's avatar
Linus Torvalds committed
142
 */
143
static handle_t *start_transaction(struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
{
	handle_t *result;

	result = ext3_journal_start(inode, blocks_for_truncate(inode));
	if (!IS_ERR(result))
		return result;

	ext3_std_error(inode->i_sb, PTR_ERR(result));
	return result;
}

/*
 * Try to extend this transaction for the purposes of truncation.
 *
 * Returns 0 if we managed to create more room.  If we can't create more
 * room, and the transaction must be restarted we return 1.
 */
static int try_to_extend_transaction(handle_t *handle, struct inode *inode)
{
	if (handle->h_buffer_credits > EXT3_RESERVE_TRANS_BLOCKS)
		return 0;
	if (!ext3_journal_extend(handle, blocks_for_truncate(inode)))
		return 0;
	return 1;
}

/*
 * Restart the transaction associated with *handle.  This does a commit,
 * so before we call here everything must be consistently dirtied against
 * this transaction.
 */
175
static int truncate_restart_transaction(handle_t *handle, struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
176
{
177 178
	int ret;

Linus Torvalds's avatar
Linus Torvalds committed
179
	jbd_debug(2, "restarting handle %p\n", handle);
180 181 182 183 184 185 186 187 188 189
	/*
	 * Drop truncate_mutex to avoid deadlock with ext3_get_blocks_handle
	 * At this moment, get_block can be called only for blocks inside
	 * i_size since page cache has been already dropped and writes are
	 * blocked by i_mutex. So we can safely drop the truncate_mutex.
	 */
	mutex_unlock(&EXT3_I(inode)->truncate_mutex);
	ret = ext3_journal_restart(handle, blocks_for_truncate(inode));
	mutex_lock(&EXT3_I(inode)->truncate_mutex);
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
190 191 192
}

/*
Al Viro's avatar
Al Viro committed
193
 * Called at inode eviction from icache
Linus Torvalds's avatar
Linus Torvalds committed
194
 */
Al Viro's avatar
Al Viro committed
195
void ext3_evict_inode (struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
196
{
Al Viro's avatar
Al Viro committed
197
	struct ext3_block_alloc_info *rsv;
Linus Torvalds's avatar
Linus Torvalds committed
198
	handle_t *handle;
Al Viro's avatar
Al Viro committed
199
	int want_delete = 0;
Linus Torvalds's avatar
Linus Torvalds committed
200

Al Viro's avatar
Al Viro committed
201
	if (!inode->i_nlink && !is_bad_inode(inode)) {
202
		dquot_initialize(inode);
Al Viro's avatar
Al Viro committed
203 204
		want_delete = 1;
	}
205

206 207
	truncate_inode_pages(&inode->i_data, 0);

Al Viro's avatar
Al Viro committed
208 209 210 211 212 213 214
	ext3_discard_reservation(inode);
	rsv = EXT3_I(inode)->i_block_alloc_info;
	EXT3_I(inode)->i_block_alloc_info = NULL;
	if (unlikely(rsv))
		kfree(rsv);

	if (!want_delete)
Linus Torvalds's avatar
Linus Torvalds committed
215 216 217 218
		goto no_delete;

	handle = start_transaction(inode);
	if (IS_ERR(handle)) {
219 220 221 222 223
		/*
		 * If we're going to skip the normal cleanup, we still need to
		 * make sure that the in-core orphan linked list is properly
		 * cleaned up.
		 */
Linus Torvalds's avatar
Linus Torvalds committed
224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243
		ext3_orphan_del(NULL, inode);
		goto no_delete;
	}

	if (IS_SYNC(inode))
		handle->h_sync = 1;
	inode->i_size = 0;
	if (inode->i_blocks)
		ext3_truncate(inode);
	/*
	 * Kill off the orphan record which ext3_truncate created.
	 * AKPM: I think this can be inside the above `if'.
	 * Note that ext3_orphan_del() has to be able to cope with the
	 * deletion of a non-existent orphan - this is because we don't
	 * know if ext3_truncate() actually created an orphan record.
	 * (Well, we could do this if we need to, but heck - it works)
	 */
	ext3_orphan_del(handle, inode);
	EXT3_I(inode)->i_dtime	= get_seconds();

244
	/*
Linus Torvalds's avatar
Linus Torvalds committed
245 246 247 248
	 * One subtle ordering requirement: if anything has gone wrong
	 * (transaction abort, IO errors, whatever), then we can still
	 * do these next steps (the fs will already have been marked as
	 * having errors), but we can't free the inode if the mark_dirty
249
	 * fails.
Linus Torvalds's avatar
Linus Torvalds committed
250
	 */
Al Viro's avatar
Al Viro committed
251 252 253 254 255 256 257 258 259
	if (ext3_mark_inode_dirty(handle, inode)) {
		/* If that failed, just dquot_drop() and be done with that */
		dquot_drop(inode);
		end_writeback(inode);
	} else {
		ext3_xattr_delete_inode(handle, inode);
		dquot_free_inode(inode);
		dquot_drop(inode);
		end_writeback(inode);
Linus Torvalds's avatar
Linus Torvalds committed
260
		ext3_free_inode(handle, inode);
Al Viro's avatar
Al Viro committed
261
	}
Linus Torvalds's avatar
Linus Torvalds committed
262 263 264
	ext3_journal_stop(handle);
	return;
no_delete:
Al Viro's avatar
Al Viro committed
265 266
	end_writeback(inode);
	dquot_drop(inode);
Linus Torvalds's avatar
Linus Torvalds committed
267 268 269 270 271 272 273 274 275 276 277 278 279 280
}

typedef struct {
	__le32	*p;
	__le32	key;
	struct buffer_head *bh;
} Indirect;

static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v)
{
	p->key = *(p->p = v);
	p->bh = bh;
}

281
static int verify_chain(Indirect *from, Indirect *to)
Linus Torvalds's avatar
Linus Torvalds committed
282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 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
{
	while (from <= to && from->key == *from->p)
		from++;
	return (from > to);
}

/**
 *	ext3_block_to_path - parse the block number into array of offsets
 *	@inode: inode in question (we are only interested in its superblock)
 *	@i_block: block number to be parsed
 *	@offsets: array to store the offsets in
 *      @boundary: set this non-zero if the referred-to block is likely to be
 *             followed (on disk) by an indirect block.
 *
 *	To store the locations of file's data ext3 uses a data structure common
 *	for UNIX filesystems - tree of pointers anchored in the inode, with
 *	data blocks at leaves and indirect blocks in intermediate nodes.
 *	This function translates the block number into path in that tree -
 *	return value is the path length and @offsets[n] is the offset of
 *	pointer to (n+1)th node in the nth one. If @block is out of range
 *	(negative or too large) warning is printed and zero returned.
 *
 *	Note: function doesn't find node addresses, so no IO is needed. All
 *	we need to know is the capacity of indirect blocks (taken from the
 *	inode->i_sb).
 */

/*
 * Portability note: the last comparison (check that we fit into triple
 * indirect block) is spelled differently, because otherwise on an
 * architecture with 32-bit longs and 8Kb pages we might get into trouble
 * if our filesystem had 8Kb blocks. We might use long long, but that would
 * kill us on x86. Oh, well, at least the sign propagation does not matter -
 * i_block would have to be negative in the very beginning, so we would not
 * get there at all.
 */

static int ext3_block_to_path(struct inode *inode,
			long i_block, int offsets[4], int *boundary)
{
	int ptrs = EXT3_ADDR_PER_BLOCK(inode->i_sb);
	int ptrs_bits = EXT3_ADDR_PER_BLOCK_BITS(inode->i_sb);
	const long direct_blocks = EXT3_NDIR_BLOCKS,
		indirect_blocks = ptrs,
		double_blocks = (1 << (ptrs_bits * 2));
	int n = 0;
	int final = 0;

	if (i_block < 0) {
		ext3_warning (inode->i_sb, "ext3_block_to_path", "block < 0");
	} else if (i_block < direct_blocks) {
		offsets[n++] = i_block;
		final = direct_blocks;
	} else if ( (i_block -= direct_blocks) < indirect_blocks) {
		offsets[n++] = EXT3_IND_BLOCK;
		offsets[n++] = i_block;
		final = ptrs;
	} else if ((i_block -= indirect_blocks) < double_blocks) {
		offsets[n++] = EXT3_DIND_BLOCK;
		offsets[n++] = i_block >> ptrs_bits;
		offsets[n++] = i_block & (ptrs - 1);
		final = ptrs;
	} else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) {
		offsets[n++] = EXT3_TIND_BLOCK;
		offsets[n++] = i_block >> (ptrs_bits * 2);
		offsets[n++] = (i_block >> ptrs_bits) & (ptrs - 1);
		offsets[n++] = i_block & (ptrs - 1);
		final = ptrs;
	} else {
351
		ext3_warning(inode->i_sb, "ext3_block_to_path", "block > big");
Linus Torvalds's avatar
Linus Torvalds committed
352 353
	}
	if (boundary)
354
		*boundary = final - 1 - (i_block & (ptrs - 1));
Linus Torvalds's avatar
Linus Torvalds committed
355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 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
	return n;
}

/**
 *	ext3_get_branch - read the chain of indirect blocks leading to data
 *	@inode: inode in question
 *	@depth: depth of the chain (1 - direct pointer, etc.)
 *	@offsets: offsets of pointers in inode/indirect blocks
 *	@chain: place to store the result
 *	@err: here we store the error value
 *
 *	Function fills the array of triples <key, p, bh> and returns %NULL
 *	if everything went OK or the pointer to the last filled triple
 *	(incomplete one) otherwise. Upon the return chain[i].key contains
 *	the number of (i+1)-th block in the chain (as it is stored in memory,
 *	i.e. little-endian 32-bit), chain[i].p contains the address of that
 *	number (it points into struct inode for i==0 and into the bh->b_data
 *	for i>0) and chain[i].bh points to the buffer_head of i-th indirect
 *	block for i>0 and NULL for i==0. In other words, it holds the block
 *	numbers of the chain, addresses they were taken from (and where we can
 *	verify that chain did not change) and buffer_heads hosting these
 *	numbers.
 *
 *	Function stops when it stumbles upon zero pointer (absent block)
 *		(pointer to last triple returned, *@err == 0)
 *	or when it gets an IO error reading an indirect block
 *		(ditto, *@err == -EIO)
 *	or when it notices that chain had been changed while it was reading
 *		(ditto, *@err == -EAGAIN)
 *	or when it reads all @depth-1 indirect blocks successfully and finds
 *	the whole chain, all way to the data (returns %NULL, *err == 0).
 */
static Indirect *ext3_get_branch(struct inode *inode, int depth, int *offsets,
				 Indirect chain[4], int *err)
{
	struct super_block *sb = inode->i_sb;
	Indirect *p = chain;
	struct buffer_head *bh;

	*err = 0;
	/* i_data is not going away, no lock needed */
	add_chain (chain, NULL, EXT3_I(inode)->i_data + *offsets);
	if (!p->key)
		goto no_block;
	while (--depth) {
		bh = sb_bread(sb, le32_to_cpu(p->key));
		if (!bh)
			goto failure;
		/* Reader: pointers */
		if (!verify_chain(chain, p))
			goto changed;
		add_chain(++p, bh, (__le32*)bh->b_data + *++offsets);
		/* Reader: end */
		if (!p->key)
			goto no_block;
	}
	return NULL;

changed:
	brelse(bh);
	*err = -EAGAIN;
	goto no_block;
failure:
	*err = -EIO;
no_block:
	return p;
}

/**
 *	ext3_find_near - find a place for allocation with sufficient locality
 *	@inode: owner
 *	@ind: descriptor of indirect block.
 *
428
 *	This function returns the preferred place for block allocation.
Linus Torvalds's avatar
Linus Torvalds committed
429 430 431 432 433
 *	It is used when heuristic for sequential allocation fails.
 *	Rules are:
 *	  + if there is a block to the left of our position - allocate near it.
 *	  + if pointer will live in indirect block - allocate near that block.
 *	  + if pointer will live in inode - allocate in the same
434
 *	    cylinder group.
Linus Torvalds's avatar
Linus Torvalds committed
435 436 437 438 439 440 441 442
 *
 * In the latter case we colour the starting block by the callers PID to
 * prevent it from clashing with concurrent allocations for a different inode
 * in the same block group.   The PID is used here so that functionally related
 * files will be close-by on-disk.
 *
 *	Caller must make sure that @ind is valid and will stay that way.
 */
443
static ext3_fsblk_t ext3_find_near(struct inode *inode, Indirect *ind)
Linus Torvalds's avatar
Linus Torvalds committed
444 445 446 447
{
	struct ext3_inode_info *ei = EXT3_I(inode);
	__le32 *start = ind->bh ? (__le32*) ind->bh->b_data : ei->i_data;
	__le32 *p;
448 449
	ext3_fsblk_t bg_start;
	ext3_grpblk_t colour;
Linus Torvalds's avatar
Linus Torvalds committed
450 451

	/* Try to find previous block */
452
	for (p = ind->p - 1; p >= start; p--) {
Linus Torvalds's avatar
Linus Torvalds committed
453 454
		if (*p)
			return le32_to_cpu(*p);
455
	}
Linus Torvalds's avatar
Linus Torvalds committed
456 457 458 459 460 461

	/* No such thing, so let's try location of indirect block */
	if (ind->bh)
		return ind->bh->b_blocknr;

	/*
462 463
	 * It is going to be referred to from the inode itself? OK, just put it
	 * into the same cylinder group then.
Linus Torvalds's avatar
Linus Torvalds committed
464
	 */
465
	bg_start = ext3_group_first_block_no(inode->i_sb, ei->i_block_group);
Linus Torvalds's avatar
Linus Torvalds committed
466 467 468 469 470 471
	colour = (current->pid % 16) *
			(EXT3_BLOCKS_PER_GROUP(inode->i_sb) / 16);
	return bg_start + colour;
}

/**
472
 *	ext3_find_goal - find a preferred place for allocation.
Linus Torvalds's avatar
Linus Torvalds committed
473 474 475 476
 *	@inode: owner
 *	@block:  block we want
 *	@partial: pointer to the last triple within a chain
 *
477
 *	Normally this function find the preferred place for block allocation,
478
 *	returns it.
Linus Torvalds's avatar
Linus Torvalds committed
479 480
 */

481
static ext3_fsblk_t ext3_find_goal(struct inode *inode, long block,
482
				   Indirect *partial)
Linus Torvalds's avatar
Linus Torvalds committed
483
{
484 485 486
	struct ext3_block_alloc_info *block_i;

	block_i =  EXT3_I(inode)->i_block_alloc_info;
Linus Torvalds's avatar
Linus Torvalds committed
487 488 489 490 491 492 493

	/*
	 * try the heuristic for sequential allocation,
	 * failing that at least try to get decent locality.
	 */
	if (block_i && (block == block_i->last_alloc_logical_block + 1)
		&& (block_i->last_alloc_physical_block != 0)) {
494
		return block_i->last_alloc_physical_block + 1;
Linus Torvalds's avatar
Linus Torvalds committed
495 496
	}

497
	return ext3_find_near(inode, partial);
Linus Torvalds's avatar
Linus Torvalds committed
498
}
499

500
/**
501
 *	ext3_blks_to_allocate - Look up the block map and count the number
502 503
 *	of direct blocks need to be allocated for the given branch.
 *
504
 *	@branch: chain of indirect blocks
505 506 507 508 509 510 511
 *	@k: number of blocks need for indirect blocks
 *	@blks: number of data blocks to be mapped.
 *	@blocks_to_boundary:  the offset in the indirect block
 *
 *	return the total number of blocks to be allocate, including the
 *	direct and indirect blocks.
 */
512
static int ext3_blks_to_allocate(Indirect *branch, int k, unsigned long blks,
513 514 515 516 517 518 519 520 521
		int blocks_to_boundary)
{
	unsigned long count = 0;

	/*
	 * Simple case, [t,d]Indirect block(s) has not allocated yet
	 * then it's clear blocks on that path have not allocated
	 */
	if (k > 0) {
522
		/* right now we don't handle cross boundary allocation */
523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538
		if (blks < blocks_to_boundary + 1)
			count += blks;
		else
			count += blocks_to_boundary + 1;
		return count;
	}

	count++;
	while (count < blks && count <= blocks_to_boundary &&
		le32_to_cpu(*(branch[0].p + count)) == 0) {
		count++;
	}
	return count;
}

/**
539 540 541 542
 *	ext3_alloc_blocks - multiple allocate blocks needed for a branch
 *	@handle: handle for this transaction
 *	@inode: owner
 *	@goal: preferred place for allocation
543 544
 *	@indirect_blks: the number of blocks need to allocate for indirect
 *			blocks
545
 *	@blks:	number of blocks need to allocated for direct blocks
546 547
 *	@new_blocks: on return it will store the new block numbers for
 *	the indirect blocks(if needed) and the first direct block,
548 549 550
 *	@err: here we store the error value
 *
 *	return the number of direct blocks allocated
551 552
 */
static int ext3_alloc_blocks(handle_t *handle, struct inode *inode,
553 554
			ext3_fsblk_t goal, int indirect_blks, int blks,
			ext3_fsblk_t new_blocks[4], int *err)
555 556 557 558
{
	int target, i;
	unsigned long count = 0;
	int index = 0;
559
	ext3_fsblk_t current_block = 0;
560 561 562 563 564 565 566 567 568 569 570 571 572 573 574
	int ret = 0;

	/*
	 * Here we try to allocate the requested multiple blocks at once,
	 * on a best-effort basis.
	 * To build a branch, we should allocate blocks for
	 * the indirect blocks(if not allocated yet), and at least
	 * the first direct block of this branch.  That's the
	 * minimum number of blocks need to allocate(required)
	 */
	target = blks + indirect_blks;

	while (1) {
		count = target;
		/* allocating blocks for indirect blocks and direct blocks */
575
		current_block = ext3_new_blocks(handle,inode,goal,&count,err);
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601
		if (*err)
			goto failed_out;

		target -= count;
		/* allocate blocks for indirect blocks */
		while (index < indirect_blks && count) {
			new_blocks[index++] = current_block++;
			count--;
		}

		if (count > 0)
			break;
	}

	/* save the new block number for the first direct block */
	new_blocks[index] = current_block;

	/* total number of blocks allocated for direct blocks */
	ret = count;
	*err = 0;
	return ret;
failed_out:
	for (i = 0; i <index; i++)
		ext3_free_blocks(handle, inode, new_blocks[i], 1);
	return ret;
}
Linus Torvalds's avatar
Linus Torvalds committed
602 603 604

/**
 *	ext3_alloc_branch - allocate and set up a chain of blocks.
605
 *	@handle: handle for this transaction
Linus Torvalds's avatar
Linus Torvalds committed
606
 *	@inode: owner
607 608
 *	@indirect_blks: number of allocated indirect blocks
 *	@blks: number of allocated direct blocks
609
 *	@goal: preferred place for allocation
Linus Torvalds's avatar
Linus Torvalds committed
610 611 612
 *	@offsets: offsets (in the blocks) to store the pointers to next.
 *	@branch: place to store the chain in.
 *
613
 *	This function allocates blocks, zeroes out all but the last one,
Linus Torvalds's avatar
Linus Torvalds committed
614 615 616 617 618 619
 *	links them into chain and (if we are synchronous) writes them to disk.
 *	In other words, it prepares a branch that can be spliced onto the
 *	inode. It stores the information about that chain in the branch[], in
 *	the same format as ext3_get_branch() would do. We are calling it after
 *	we had read the existing part of chain and partial points to the last
 *	triple of that (one with zero ->key). Upon the exit we have the same
620
 *	picture as after the successful ext3_get_block(), except that in one
Linus Torvalds's avatar
Linus Torvalds committed
621 622 623 624 625 626 627 628 629 630
 *	place chain is disconnected - *branch->p is still zero (we did not
 *	set the last link), but branch->key contains the number that should
 *	be placed into *branch->p to fill that gap.
 *
 *	If allocation fails we free all blocks we've allocated (and forget
 *	their buffer_heads) and return the error value the from failed
 *	ext3_alloc_block() (normally -ENOSPC). Otherwise we set the chain
 *	as described above and return 0.
 */
static int ext3_alloc_branch(handle_t *handle, struct inode *inode,
631
			int indirect_blks, int *blks, ext3_fsblk_t goal,
632
			int *offsets, Indirect *branch)
Linus Torvalds's avatar
Linus Torvalds committed
633 634
{
	int blocksize = inode->i_sb->s_blocksize;
635
	int i, n = 0;
Linus Torvalds's avatar
Linus Torvalds committed
636
	int err = 0;
637 638
	struct buffer_head *bh;
	int num;
639 640
	ext3_fsblk_t new_blocks[4];
	ext3_fsblk_t current_block;
Linus Torvalds's avatar
Linus Torvalds committed
641

642 643 644 645
	num = ext3_alloc_blocks(handle, inode, goal, indirect_blks,
				*blks, new_blocks, &err);
	if (err)
		return err;
Linus Torvalds's avatar
Linus Torvalds committed
646

647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
	branch[0].key = cpu_to_le32(new_blocks[0]);
	/*
	 * metadata blocks and data blocks are allocated.
	 */
	for (n = 1; n <= indirect_blks;  n++) {
		/*
		 * Get buffer_head for parent block, zero it out
		 * and set the pointer to new one, then send
		 * parent to disk.
		 */
		bh = sb_getblk(inode->i_sb, new_blocks[n-1]);
		branch[n].bh = bh;
		lock_buffer(bh);
		BUFFER_TRACE(bh, "call get_create_access");
		err = ext3_journal_get_create_access(handle, bh);
		if (err) {
Linus Torvalds's avatar
Linus Torvalds committed
663
			unlock_buffer(bh);
664 665 666
			brelse(bh);
			goto failed;
		}
Linus Torvalds's avatar
Linus Torvalds committed
667

668 669 670 671 672 673 674 675 676 677 678 679 680
		memset(bh->b_data, 0, blocksize);
		branch[n].p = (__le32 *) bh->b_data + offsets[n];
		branch[n].key = cpu_to_le32(new_blocks[n]);
		*branch[n].p = branch[n].key;
		if ( n == indirect_blks) {
			current_block = new_blocks[n];
			/*
			 * End of chain, update the last new metablock of
			 * the chain to point to the new allocated
			 * data blocks numbers
			 */
			for (i=1; i < num; i++)
				*(branch[n].p + i) = cpu_to_le32(++current_block);
Linus Torvalds's avatar
Linus Torvalds committed
681
		}
682 683 684
		BUFFER_TRACE(bh, "marking uptodate");
		set_buffer_uptodate(bh);
		unlock_buffer(bh);
Linus Torvalds's avatar
Linus Torvalds committed
685

686 687 688 689 690 691 692 693
		BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
		err = ext3_journal_dirty_metadata(handle, bh);
		if (err)
			goto failed;
	}
	*blks = num;
	return err;
failed:
Linus Torvalds's avatar
Linus Torvalds committed
694
	/* Allocation failed, free what we already allocated */
695
	for (i = 1; i <= n ; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
696 697 698
		BUFFER_TRACE(branch[i].bh, "call journal_forget");
		ext3_journal_forget(handle, branch[i].bh);
	}
699 700 701 702 703
	for (i = 0; i <indirect_blks; i++)
		ext3_free_blocks(handle, inode, new_blocks[i], 1);

	ext3_free_blocks(handle, inode, new_blocks[i], num);

Linus Torvalds's avatar
Linus Torvalds committed
704 705 706 707
	return err;
}

/**
708
 * ext3_splice_branch - splice the allocated branch onto inode.
709
 * @handle: handle for this transaction
710 711 712 713 714 715 716 717 718
 * @inode: owner
 * @block: (logical) number of block we are adding
 * @where: location of missing link
 * @num:   number of indirect blocks we are adding
 * @blks:  number of direct blocks we are adding
 *
 * This function fills the missing link and does all housekeeping needed in
 * inode (->i_blocks, etc.). In case of success we end up with the full
 * chain to new block and return 0.
Linus Torvalds's avatar
Linus Torvalds committed
719
 */
720 721
static int ext3_splice_branch(handle_t *handle, struct inode *inode,
			long block, Indirect *where, int num, int blks)
Linus Torvalds's avatar
Linus Torvalds committed
722 723 724
{
	int i;
	int err = 0;
725
	struct ext3_block_alloc_info *block_i;
726
	ext3_fsblk_t current_block;
727
	struct ext3_inode_info *ei = EXT3_I(inode);
728

729
	block_i = ei->i_block_alloc_info;
Linus Torvalds's avatar
Linus Torvalds committed
730 731 732 733 734 735 736 737 738 739 740 741 742 743
	/*
	 * If we're splicing into a [td]indirect block (as opposed to the
	 * inode) then we need to get write access to the [td]indirect block
	 * before the splice.
	 */
	if (where->bh) {
		BUFFER_TRACE(where->bh, "get_write_access");
		err = ext3_journal_get_write_access(handle, where->bh);
		if (err)
			goto err_out;
	}
	/* That's it */

	*where->p = where->key;
744 745 746 747 748

	/*
	 * Update the host buffer_head or inode to point to more just allocated
	 * direct blocks blocks
	 */
749
	if (num == 0 && blks > 1) {
750
		current_block = le32_to_cpu(where->key) + 1;
751 752 753
		for (i = 1; i < blks; i++)
			*(where->p + i ) = cpu_to_le32(current_block++);
	}
Linus Torvalds's avatar
Linus Torvalds committed
754 755 756 757 758 759 760

	/*
	 * update the most recently allocated logical & physical block
	 * in i_block_alloc_info, to assist find the proper goal block for next
	 * allocation
	 */
	if (block_i) {
761
		block_i->last_alloc_logical_block = block + blks - 1;
762
		block_i->last_alloc_physical_block =
763
				le32_to_cpu(where[num].key) + blks - 1;
Linus Torvalds's avatar
Linus Torvalds committed
764 765 766 767 768 769
	}

	/* We are done with atomic stuff, now do the rest of housekeeping */

	inode->i_ctime = CURRENT_TIME_SEC;
	ext3_mark_inode_dirty(handle, inode);
770 771
	/* ext3_mark_inode_dirty already updated i_sync_tid */
	atomic_set(&ei->i_datasync_tid, handle->h_transaction->t_tid);
Linus Torvalds's avatar
Linus Torvalds committed
772 773 774 775

	/* had we spliced it onto indirect block? */
	if (where->bh) {
		/*
776
		 * If we spliced it onto an indirect block, we haven't
Linus Torvalds's avatar
Linus Torvalds committed
777 778 779 780 781 782 783 784 785
		 * altered the inode.  Note however that if it is being spliced
		 * onto an indirect block at the very end of the file (the
		 * file is growing) then we *will* alter the inode to reflect
		 * the new i_size.  But that is not done here - it is done in
		 * generic_commit_write->__mark_inode_dirty->ext3_dirty_inode.
		 */
		jbd_debug(5, "splicing indirect only\n");
		BUFFER_TRACE(where->bh, "call ext3_journal_dirty_metadata");
		err = ext3_journal_dirty_metadata(handle, where->bh);
786
		if (err)
Linus Torvalds's avatar
Linus Torvalds committed
787 788 789 790 791 792 793 794 795 796 797
			goto err_out;
	} else {
		/*
		 * OK, we spliced it into the inode itself on a direct block.
		 * Inode was dirtied above.
		 */
		jbd_debug(5, "splicing direct\n");
	}
	return err;

err_out:
798
	for (i = 1; i <= num; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
799 800
		BUFFER_TRACE(where[i].bh, "call journal_forget");
		ext3_journal_forget(handle, where[i].bh);
801
		ext3_free_blocks(handle,inode,le32_to_cpu(where[i-1].key),1);
Linus Torvalds's avatar
Linus Torvalds committed
802
	}
803 804
	ext3_free_blocks(handle, inode, le32_to_cpu(where[num].key), blks);

Linus Torvalds's avatar
Linus Torvalds committed
805 806 807 808 809 810 811 812 813 814 815 816 817 818 819
	return err;
}

/*
 * Allocation strategy is simple: if we have to allocate something, we will
 * have to go the whole way to leaf. So let's do it before attaching anything
 * to tree, set linkage between the newborn blocks, write them if sync is
 * required, recheck the path, free and repeat if check fails, otherwise
 * set the last missing link (that will protect us from any truncate-generated
 * removals - all blocks on the path are immune now) and possibly force the
 * write on the parent block.
 * That has a nice additional property: no special recovery from the failed
 * allocations is needed - we simply release blocks and do not touch anything
 * reachable from inode.
 *
820
 * `handle' can be NULL if create == 0.
Linus Torvalds's avatar
Linus Torvalds committed
821 822
 *
 * The BKL may not be held on entry here.  Be sure to take it early.
823 824 825
 * return > 0, # of blocks mapped or allocated.
 * return = 0, if plain lookup failed.
 * return < 0, error case.
Linus Torvalds's avatar
Linus Torvalds committed
826
 */
827 828 829
int ext3_get_blocks_handle(handle_t *handle, struct inode *inode,
		sector_t iblock, unsigned long maxblocks,
		struct buffer_head *bh_result,
830
		int create)
Linus Torvalds's avatar
Linus Torvalds committed
831 832 833 834 835
{
	int err = -EIO;
	int offsets[4];
	Indirect chain[4];
	Indirect *partial;
836
	ext3_fsblk_t goal;
837
	int indirect_blks;
838 839
	int blocks_to_boundary = 0;
	int depth;
Linus Torvalds's avatar
Linus Torvalds committed
840
	struct ext3_inode_info *ei = EXT3_I(inode);
841
	int count = 0;
842
	ext3_fsblk_t first_block = 0;
843

Linus Torvalds's avatar
Linus Torvalds committed
844 845

	J_ASSERT(handle != NULL || create == 0);
846
	depth = ext3_block_to_path(inode,iblock,offsets,&blocks_to_boundary);
Linus Torvalds's avatar
Linus Torvalds committed
847 848 849 850 851 852 853 854

	if (depth == 0)
		goto out;

	partial = ext3_get_branch(inode, depth, offsets, chain, &err);

	/* Simplest case - block found, no allocation needed */
	if (!partial) {
855
		first_block = le32_to_cpu(chain[depth - 1].key);
Linus Torvalds's avatar
Linus Torvalds committed
856
		clear_buffer_new(bh_result);
857 858 859
		count++;
		/*map more blocks*/
		while (count < maxblocks && count <= blocks_to_boundary) {
860
			ext3_fsblk_t blk;
861

862
			if (!verify_chain(chain, chain + depth - 1)) {
863 864 865 866 867 868 869 870 871 872 873
				/*
				 * Indirect block might be removed by
				 * truncate while we were reading it.
				 * Handling of that case: forget what we've
				 * got now. Flag the err as EAGAIN, so it
				 * will reread.
				 */
				err = -EAGAIN;
				count = 0;
				break;
			}
874 875 876
			blk = le32_to_cpu(*(chain[depth-1].p + count));

			if (blk == first_block + count)
877 878 879 880 881 882
				count++;
			else
				break;
		}
		if (err != -EAGAIN)
			goto got_it;
Linus Torvalds's avatar
Linus Torvalds committed
883 884 885
	}

	/* Next simple case - plain lookup or failed read of indirect block */
886 887 888
	if (!create || err == -EIO)
		goto cleanup;

889
	mutex_lock(&ei->truncate_mutex);
890 891 892 893 894 895 896 897 898 899 900 901 902 903

	/*
	 * If the indirect block is missing while we are reading
	 * the chain(ext3_get_branch() returns -EAGAIN err), or
	 * if the chain has been changed after we grab the semaphore,
	 * (either because another process truncated this branch, or
	 * another get_block allocated this branch) re-grab the chain to see if
	 * the request block has been allocated or not.
	 *
	 * Since we already block the truncate/other get_block
	 * at this point, we will have the current copy of the chain when we
	 * splice the branch into the tree.
	 */
	if (err == -EAGAIN || !verify_chain(chain, partial)) {
Linus Torvalds's avatar
Linus Torvalds committed
904 905 906 907
		while (partial > chain) {
			brelse(partial->bh);
			partial--;
		}
908 909
		partial = ext3_get_branch(inode, depth, offsets, chain, &err);
		if (!partial) {
910
			count++;
911
			mutex_unlock(&ei->truncate_mutex);
912 913 914 915 916
			if (err)
				goto cleanup;
			clear_buffer_new(bh_result);
			goto got_it;
		}
Linus Torvalds's avatar
Linus Torvalds committed
917 918 919
	}

	/*
920 921 922 923
	 * Okay, we need to do block allocation.  Lazily initialize the block
	 * allocation info here if necessary
	*/
	if (S_ISREG(inode->i_mode) && (!ei->i_block_alloc_info))
Linus Torvalds's avatar
Linus Torvalds committed
924 925
		ext3_init_block_alloc_info(inode);

926
	goal = ext3_find_goal(inode, iblock, partial);
Linus Torvalds's avatar
Linus Torvalds committed
927

928 929
	/* the number of blocks need to allocate for [d,t]indirect blocks */
	indirect_blks = (chain + depth) - partial - 1;
Linus Torvalds's avatar
Linus Torvalds committed
930

931 932 933 934 935 936
	/*
	 * Next look up the indirect map to count the totoal number of
	 * direct blocks to allocate for this branch.
	 */
	count = ext3_blks_to_allocate(partial, indirect_blks,
					maxblocks, blocks_to_boundary);
Linus Torvalds's avatar
Linus Torvalds committed
937 938 939
	/*
	 * Block out ext3_truncate while we alter the tree
	 */
940
	err = ext3_alloc_branch(handle, inode, indirect_blks, &count, goal,
941
				offsets + (partial - chain), partial);
Linus Torvalds's avatar
Linus Torvalds committed
942

943 944
	/*
	 * The ext3_splice_branch call will free and forget any buffers
Linus Torvalds's avatar
Linus Torvalds committed
945 946 947
	 * on the new chain if there is a failure, but that risks using
	 * up transaction credits, especially for bitmaps where the
	 * credits cannot be returned.  Can we handle this somehow?  We
948 949
	 * may need to return -EAGAIN upwards in the worst case.  --sct
	 */
Linus Torvalds's avatar
Linus Torvalds committed
950
	if (!err)
951 952
		err = ext3_splice_branch(handle, inode, iblock,
					partial, indirect_blks, count);
953
	mutex_unlock(&ei->truncate_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
954 955 956 957
	if (err)
		goto cleanup;

	set_buffer_new(bh_result);
958 959
got_it:
	map_bh(bh_result, inode->i_sb, le32_to_cpu(chain[depth-1].key));
960
	if (count > blocks_to_boundary)
961
		set_buffer_boundary(bh_result);
962
	err = count;
963 964 965
	/* Clean up and exit */
	partial = chain + depth - 1;	/* the whole chain */
cleanup:
Linus Torvalds's avatar
Linus Torvalds committed
966
	while (partial > chain) {
967
		BUFFER_TRACE(partial->bh, "call brelse");
Linus Torvalds's avatar
Linus Torvalds committed
968 969 970
		brelse(partial->bh);
		partial--;
	}
971 972 973
	BUFFER_TRACE(bh_result, "returned");
out:
	return err;
Linus Torvalds's avatar
Linus Torvalds committed
974 975
}

976 977 978 979 980 981 982 983 984 985
/* Maximum number of blocks we map for direct IO at once. */
#define DIO_MAX_BLOCKS 4096
/*
 * Number of credits we need for writing DIO_MAX_BLOCKS:
 * We need sb + group descriptor + bitmap + inode -> 4
 * For B blocks with A block pointers per block we need:
 * 1 (triple ind.) + (B/A/A + 2) (doubly ind.) + (B/A + 2) (indirect).
 * If we plug in 4096 for B and 256 for A (for 1KB block size), we get 25.
 */
#define DIO_CREDITS 25
Linus Torvalds's avatar
Linus Torvalds committed
986

987 988
static int ext3_get_block(struct inode *inode, sector_t iblock,
			struct buffer_head *bh_result, int create)
Linus Torvalds's avatar
Linus Torvalds committed
989
{
990
	handle_t *handle = ext3_journal_current_handle();
991
	int ret = 0, started = 0;
992
	unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
Linus Torvalds's avatar
Linus Torvalds committed
993

994 995 996 997
	if (create && !handle) {	/* Direct IO write... */
		if (max_blocks > DIO_MAX_BLOCKS)
			max_blocks = DIO_MAX_BLOCKS;
		handle = ext3_journal_start(inode, DIO_CREDITS +
998
				EXT3_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb));
999
		if (IS_ERR(handle)) {
Linus Torvalds's avatar
Linus Torvalds committed
1000
			ret = PTR_ERR(handle);
1001
			goto out;
Linus Torvalds's avatar
Linus Torvalds committed
1002
		}
1003
		started = 1;
Linus Torvalds's avatar
Linus Torvalds committed
1004 1005
	}

1006
	ret = ext3_get_blocks_handle(handle, inode, iblock,
1007
					max_blocks, bh_result, create);
1008 1009 1010
	if (ret > 0) {
		bh_result->b_size = (ret << inode->i_blkbits);
		ret = 0;
1011
	}
1012 1013 1014
	if (started)
		ext3_journal_stop(handle);
out:
Linus Torvalds's avatar
Linus Torvalds committed
1015 1016 1017
	return ret;
}

1018 1019 1020 1021 1022 1023 1024
int ext3_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
		u64 start, u64 len)
{
	return generic_block_fiemap(inode, fieinfo, start, len,
				    ext3_get_block);
}

Linus Torvalds's avatar
Linus Torvalds committed
1025 1026 1027
/*
 * `handle' can be NULL if create is zero
 */
1028 1029
struct buffer_head *ext3_getblk(handle_t *handle, struct inode *inode,
				long block, int create, int *errp)
Linus Torvalds's avatar
Linus Torvalds committed
1030 1031 1032 1033 1034 1035 1036 1037 1038
{
	struct buffer_head dummy;
	int fatal = 0, err;

	J_ASSERT(handle != NULL || create == 0);

	dummy.b_state = 0;
	dummy.b_blocknr = -1000;
	buffer_trace_init(&dummy.b_history);
1039
	err = ext3_get_blocks_handle(handle, inode, block, 1,
1040
					&dummy, create);
1041 1042 1043 1044 1045 1046 1047
	/*
	 * ext3_get_blocks_handle() returns number of blocks
	 * mapped. 0 in case of a HOLE.
	 */
	if (err > 0) {
		if (err > 1)
			WARN_ON(1);
1048 1049 1050 1051
		err = 0;
	}
	*errp = err;
	if (!err && buffer_mapped(&dummy)) {
Linus Torvalds's avatar
Linus Torvalds committed
1052 1053
		struct buffer_head *bh;
		bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
1054 1055 1056 1057
		if (!bh) {
			*errp = -EIO;
			goto err;
		}
Linus Torvalds's avatar
Linus Torvalds committed
1058 1059
		if (buffer_new(&dummy)) {
			J_ASSERT(create != 0);
1060
			J_ASSERT(handle != NULL);
Linus Torvalds's avatar
Linus Torvalds committed
1061

1062 1063 1064 1065 1066 1067 1068
			/*
			 * Now that we do not always journal data, we should
			 * keep in mind whether this should always journal the
			 * new buffer as metadata.  For now, regular file
			 * writes use ext3_get_block instead, so it's not a
			 * problem.
			 */
Linus Torvalds's avatar
Linus Torvalds committed
1069 1070 1071 1072
			lock_buffer(bh);
			BUFFER_TRACE(bh, "call get_create_access");
			fatal = ext3_journal_get_create_access(handle, bh);
			if (!fatal && !buffer_uptodate(bh)) {
1073
				memset(bh->b_data,0,inode->i_sb->s_blocksize);
Linus Torvalds's avatar
Linus Torvalds committed
1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090
				set_buffer_uptodate(bh);
			}
			unlock_buffer(bh);
			BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
			err = ext3_journal_dirty_metadata(handle, bh);
			if (!fatal)
				fatal = err;
		} else {
			BUFFER_TRACE(bh, "not a new buffer");
		}
		if (fatal) {
			*errp = fatal;
			brelse(bh);
			bh = NULL;
		}
		return bh;
	}
1091
err:
Linus Torvalds's avatar
Linus Torvalds committed
1092 1093 1094
	return NULL;
}

1095
struct buffer_head *ext3_bread(handle_t *handle, struct inode *inode,
Linus Torvalds's avatar
Linus Torvalds committed
1096 1097 1098 1099 1100 1101 1102 1103 1104
			       int block, int create, int *err)
{
	struct buffer_head * bh;

	bh = ext3_getblk(handle, inode, block, create, err);
	if (!bh)
		return bh;
	if (buffer_uptodate(bh))
		return bh;
1105
	ll_rw_block(READ_META, 1, &bh);
Linus Torvalds's avatar
Linus Torvalds committed
1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129
	wait_on_buffer(bh);
	if (buffer_uptodate(bh))
		return bh;
	put_bh(bh);
	*err = -EIO;
	return NULL;
}

static int walk_page_buffers(	handle_t *handle,
				struct buffer_head *head,
				unsigned from,
				unsigned to,
				int *partial,
				int (*fn)(	handle_t *handle,
						struct buffer_head *bh))
{
	struct buffer_head *bh;
	unsigned block_start, block_end;
	unsigned blocksize = head->b_size;
	int err, ret = 0;
	struct buffer_head *next;

	for (	bh = head, block_start = 0;
		ret == 0 && (bh != head || !block_start);
1130
		block_start = block_end, bh = next)
Linus Torvalds's avatar
Linus Torvalds committed
1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168
	{
		next = bh->b_this_page;
		block_end = block_start + blocksize;
		if (block_end <= from || block_start >= to) {
			if (partial && !buffer_uptodate(bh))
				*partial = 1;
			continue;
		}
		err = (*fn)(handle, bh);
		if (!ret)
			ret = err;
	}
	return ret;
}

/*
 * To preserve ordering, it is essential that the hole instantiation and
 * the data write be encapsulated in a single transaction.  We cannot
 * close off a transaction and start a new one between the ext3_get_block()
 * and the commit_write().  So doing the journal_start at the start of
 * prepare_write() is the right place.
 *
 * Also, this function can nest inside ext3_writepage() ->
 * block_write_full_page(). In that case, we *know* that ext3_writepage()
 * has generated enough buffer credits to do the whole page.  So we won't
 * block on the journal in that case, which is good, because the caller may
 * be PF_MEMALLOC.
 *
 * By accident, ext3 can be reentered when a transaction is open via
 * quota file writes.  If we were to commit the transaction while thus
 * reentered, there can be a deadlock - we would be holding a quota
 * lock, and the commit would never complete if another thread had a
 * transaction open and was blocking on the quota lock - a ranking
 * violation.
 *
 * So what we do is to rely on the fact that journal_stop/journal_start
 * will _not_ run commit under these circumstances because handle->h_ref
 * is elevated.  We'll still have enough credits for the tiny quotafile
1169
 * write.
Linus Torvalds's avatar
Linus Torvalds committed
1170
 */
1171 1172
static int do_journal_get_write_access(handle_t *handle,
					struct buffer_head *bh)
Linus Torvalds's avatar
Linus Torvalds committed
1173
{
1174 1175 1176
	int dirty = buffer_dirty(bh);
	int ret;

Linus Torvalds's avatar
Linus Torvalds committed
1177 1178
	if (!buffer_mapped(bh) || buffer_freed(bh))
		return 0;
1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192
	/*
	 * __block_prepare_write() could have dirtied some buffers. Clean
	 * the dirty bit as jbd2_journal_get_write_access() could complain
	 * otherwise about fs integrity issues. Setting of the dirty bit
	 * by __block_prepare_write() isn't a real problem here as we clear
	 * the bit before releasing a page lock and thus writeback cannot
	 * ever write the buffer.
	 */
	if (dirty)
		clear_buffer_dirty(bh);
	ret = ext3_journal_get_write_access(handle, bh);
	if (!ret && dirty)
		ret = ext3_journal_dirty_metadata(handle, bh);
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
1193 1194
}

1195 1196 1197 1198 1199 1200 1201 1202 1203 1204
/*
 * Truncate blocks that were not used by write. We have to truncate the
 * pagecache as well so that corresponding buffers get properly unmapped.
 */
static void ext3_truncate_failed_write(struct inode *inode)
{
	truncate_inode_pages(inode->i_mapping, inode->i_size);
	ext3_truncate(inode);
}

Nick Piggin's avatar
Nick Piggin committed
1205 1206 1207
static int ext3_write_begin(struct file *file, struct address_space *mapping,
				loff_t pos, unsigned len, unsigned flags,
				struct page **pagep, void **fsdata)
Linus Torvalds's avatar
Linus Torvalds committed
1208
{
Nick Piggin's avatar
Nick Piggin committed
1209
	struct inode *inode = mapping->host;
Jan Kara's avatar
Jan Kara committed
1210
	int ret;
Linus Torvalds's avatar
Linus Torvalds committed
1211 1212
	handle_t *handle;
	int retries = 0;
Nick Piggin's avatar
Nick Piggin committed
1213 1214 1215
	struct page *page;
	pgoff_t index;
	unsigned from, to;
Jan Kara's avatar
Jan Kara committed
1216 1217 1218
	/* Reserve one block more for addition to orphan list in case
	 * we allocate blocks but write fails for some reason */
	int needed_blocks = ext3_writepage_trans_blocks(inode) + 1;
Nick Piggin's avatar
Nick Piggin committed
1219 1220 1221 1222

	index = pos >> PAGE_CACHE_SHIFT;
	from = pos & (PAGE_CACHE_SIZE - 1);
	to = from + len;
Linus Torvalds's avatar
Linus Torvalds committed
1223 1224

retry:
1225
	page = grab_cache_page_write_begin(mapping, index, flags);
Nick Piggin's avatar
Nick Piggin committed
1226 1227 1228 1229
	if (!page)
		return -ENOMEM;
	*pagep = page;

Linus Torvalds's avatar
Linus Torvalds committed
1230
	handle = ext3_journal_start(inode, needed_blocks);
1231
	if (IS_ERR(handle)) {
Nick Piggin's avatar
Nick Piggin committed
1232 1233
		unlock_page(page);
		page_cache_release(page);