aops.c 61.5 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
/* -*- mode: c; c-basic-offset: 8; -*-
 * vim: noexpandtab sw=8 ts=8 sts=0:
 *
 * Copyright (C) 2002, 2004 Oracle.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 021110-1307, USA.
 */

#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/highmem.h>
#include <linux/pagemap.h>
#include <asm/byteorder.h>
27
#include <linux/swap.h>
28
#include <linux/pipe_fs_i.h>
Mark Fasheh's avatar
Mark Fasheh committed
29
#include <linux/mpage.h>
30
#include <linux/quotaops.h>
31
#include <linux/blkdev.h>
32
#include <linux/uio.h>
33 34 35 36 37 38 39 40 41 42 43 44

#include <cluster/masklog.h>

#include "ocfs2.h"

#include "alloc.h"
#include "aops.h"
#include "dlmglue.h"
#include "extent_map.h"
#include "file.h"
#include "inode.h"
#include "journal.h"
45
#include "suballoc.h"
46 47
#include "super.h"
#include "symlink.h"
Tao Ma's avatar
Tao Ma committed
48
#include "refcounttree.h"
49
#include "ocfs2_trace.h"
50 51

#include "buffer_head_io.h"
52 53 54
#include "dir.h"
#include "namei.h"
#include "sysfile.h"
55 56 57 58 59 60 61 62 63 64 65 66

static int ocfs2_symlink_get_block(struct inode *inode, sector_t iblock,
				   struct buffer_head *bh_result, int create)
{
	int err = -EIO;
	int status;
	struct ocfs2_dinode *fe = NULL;
	struct buffer_head *bh = NULL;
	struct buffer_head *buffer_cache_bh = NULL;
	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
	void *kaddr;

67 68 69
	trace_ocfs2_symlink_get_block(
			(unsigned long long)OCFS2_I(inode)->ip_blkno,
			(unsigned long long)iblock, bh_result, create);
70 71 72 73 74 75 76 77 78

	BUG_ON(ocfs2_inode_is_fast_symlink(inode));

	if ((iblock << inode->i_sb->s_blocksize_bits) > PATH_MAX + 1) {
		mlog(ML_ERROR, "block offset > PATH_MAX: %llu",
		     (unsigned long long)iblock);
		goto bail;
	}

79
	status = ocfs2_read_inode_block(inode, &bh);
80 81 82 83 84 85 86 87
	if (status < 0) {
		mlog_errno(status);
		goto bail;
	}
	fe = (struct ocfs2_dinode *) bh->b_data;

	if ((u64)iblock >= ocfs2_clusters_to_blocks(inode->i_sb,
						    le32_to_cpu(fe->i_clusters))) {
88
		err = -ENOMEM;
89 90 91 92 93 94 95 96 97 98 99 100
		mlog(ML_ERROR, "block offset is outside the allocated size: "
		     "%llu\n", (unsigned long long)iblock);
		goto bail;
	}

	/* We don't use the page cache to create symlink data, so if
	 * need be, copy it over from the buffer cache. */
	if (!buffer_uptodate(bh_result) && ocfs2_inode_is_new(inode)) {
		u64 blkno = le64_to_cpu(fe->id2.i_list.l_recs[0].e_blkno) +
			    iblock;
		buffer_cache_bh = sb_getblk(osb->sb, blkno);
		if (!buffer_cache_bh) {
101
			err = -ENOMEM;
102 103 104 105 106 107 108 109 110 111
			mlog(ML_ERROR, "couldn't getblock for symlink!\n");
			goto bail;
		}

		/* we haven't locked out transactions, so a commit
		 * could've happened. Since we've got a reference on
		 * the bh, even if it commits while we're doing the
		 * copy, the data is still good. */
		if (buffer_jbd(buffer_cache_bh)
		    && ocfs2_inode_is_new(inode)) {
112
			kaddr = kmap_atomic(bh_result->b_page);
113 114 115 116 117 118 119
			if (!kaddr) {
				mlog(ML_ERROR, "couldn't kmap!\n");
				goto bail;
			}
			memcpy(kaddr + (bh_result->b_size * iblock),
			       buffer_cache_bh->b_data,
			       bh_result->b_size);
120
			kunmap_atomic(kaddr);
121 122 123 124 125 126 127 128 129 130 131
			set_buffer_uptodate(bh_result);
		}
		brelse(buffer_cache_bh);
	}

	map_bh(bh_result, inode->i_sb,
	       le64_to_cpu(fe->id2.i_list.l_recs[0].e_blkno) + iblock);

	err = 0;

bail:
132
	brelse(bh);
133 134 135 136

	return err;
}

Tao Ma's avatar
Tao Ma committed
137 138
int ocfs2_get_block(struct inode *inode, sector_t iblock,
		    struct buffer_head *bh_result, int create)
139 140
{
	int err = 0;
141
	unsigned int ext_flags;
Mark Fasheh's avatar
Mark Fasheh committed
142 143
	u64 max_blocks = bh_result->b_size >> inode->i_blkbits;
	u64 p_blkno, count, past_eof;
144
	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
145

146 147
	trace_ocfs2_get_block((unsigned long long)OCFS2_I(inode)->ip_blkno,
			      (unsigned long long)iblock, bh_result, create);
148 149 150 151 152 153 154 155 156 157 158

	if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_SYSTEM_FILE)
		mlog(ML_NOTICE, "get_block on system inode 0x%p (%lu)\n",
		     inode, inode->i_ino);

	if (S_ISLNK(inode->i_mode)) {
		/* this always does I/O for some reason. */
		err = ocfs2_symlink_get_block(inode, iblock, bh_result, create);
		goto bail;
	}

Mark Fasheh's avatar
Mark Fasheh committed
159
	err = ocfs2_extent_map_get_blocks(inode, iblock, &p_blkno, &count,
160
					  &ext_flags);
161 162
	if (err) {
		mlog(ML_ERROR, "Error %d from get_blocks(0x%p, %llu, 1, "
163 164
		     "%llu, NULL)\n", err, inode, (unsigned long long)iblock,
		     (unsigned long long)p_blkno);
165 166 167
		goto bail;
	}

Mark Fasheh's avatar
Mark Fasheh committed
168 169 170
	if (max_blocks < count)
		count = max_blocks;

171 172 173 174
	/*
	 * ocfs2 never allocates in this function - the only time we
	 * need to use BH_New is when we're extending i_size on a file
	 * system which doesn't support holes, in which case BH_New
175
	 * allows __block_write_begin() to zero.
176 177 178 179 180
	 *
	 * If we see this on a sparse file system, then a truncate has
	 * raced us and removed the cluster. In this case, we clear
	 * the buffers dirty and uptodate bits and let the buffer code
	 * ignore it as a hole.
181
	 */
182 183 184 185 186
	if (create && p_blkno == 0 && ocfs2_sparse_alloc(osb)) {
		clear_buffer_dirty(bh_result);
		clear_buffer_uptodate(bh_result);
		goto bail;
	}
187

188 189
	/* Treat the unwritten extent as a hole for zeroing purposes. */
	if (p_blkno && !(ext_flags & OCFS2_EXT_UNWRITTEN))
190 191
		map_bh(bh_result, inode->i_sb, p_blkno);

Mark Fasheh's avatar
Mark Fasheh committed
192 193
	bh_result->b_size = count << inode->i_blkbits;

194 195 196 197 198 199 200 201 202 203
	if (!ocfs2_sparse_alloc(osb)) {
		if (p_blkno == 0) {
			err = -EIO;
			mlog(ML_ERROR,
			     "iblock = %llu p_blkno = %llu blkno=(%llu)\n",
			     (unsigned long long)iblock,
			     (unsigned long long)p_blkno,
			     (unsigned long long)OCFS2_I(inode)->ip_blkno);
			mlog(ML_ERROR, "Size %llu, clusters %u\n", (unsigned long long)i_size_read(inode), OCFS2_I(inode)->ip_clusters);
			dump_stack();
204
			goto bail;
205 206
		}
	}
207

208
	past_eof = ocfs2_blocks_for_bytes(inode->i_sb, i_size_read(inode));
209 210 211

	trace_ocfs2_get_block_end((unsigned long long)OCFS2_I(inode)->ip_blkno,
				  (unsigned long long)past_eof);
212 213 214
	if (create && (iblock >= past_eof))
		set_buffer_new(bh_result);

215 216 217 218 219 220 221
bail:
	if (err < 0)
		err = -EIO;

	return err;
}

222 223
int ocfs2_read_inline_data(struct inode *inode, struct page *page,
			   struct buffer_head *di_bh)
224 225
{
	void *kaddr;
Jan Kara's avatar
Jan Kara committed
226
	loff_t size;
227 228 229
	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;

	if (!(le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_DATA_FL)) {
230
		ocfs2_error(inode->i_sb, "Inode %llu lost inline data flag\n",
231 232 233 234 235 236 237
			    (unsigned long long)OCFS2_I(inode)->ip_blkno);
		return -EROFS;
	}

	size = i_size_read(inode);

	if (size > PAGE_CACHE_SIZE ||
238
	    size > ocfs2_max_inline_data_with_xattr(inode->i_sb, di)) {
239
		ocfs2_error(inode->i_sb,
240
			    "Inode %llu has with inline data has bad size: %Lu\n",
Jan Kara's avatar
Jan Kara committed
241 242
			    (unsigned long long)OCFS2_I(inode)->ip_blkno,
			    (unsigned long long)size);
243 244 245
		return -EROFS;
	}

246
	kaddr = kmap_atomic(page);
247 248 249 250 251
	if (size)
		memcpy(kaddr, di->id2.i_data.id_data, size);
	/* Clear the remaining part of the page */
	memset(kaddr + size, 0, PAGE_CACHE_SIZE - size);
	flush_dcache_page(page);
252
	kunmap_atomic(kaddr);
253 254 255 256 257 258 259 260 261 262 263 264

	SetPageUptodate(page);

	return 0;
}

static int ocfs2_readpage_inline(struct inode *inode, struct page *page)
{
	int ret;
	struct buffer_head *di_bh = NULL;

	BUG_ON(!PageLocked(page));
265
	BUG_ON(!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL));
266

267
	ret = ocfs2_read_inode_block(inode, &di_bh);
268 269 270 271 272 273 274 275 276 277 278 279 280
	if (ret) {
		mlog_errno(ret);
		goto out;
	}

	ret = ocfs2_read_inline_data(inode, page, di_bh);
out:
	unlock_page(page);

	brelse(di_bh);
	return ret;
}

281 282 283
static int ocfs2_readpage(struct file *file, struct page *page)
{
	struct inode *inode = page->mapping->host;
284
	struct ocfs2_inode_info *oi = OCFS2_I(inode);
285 286 287
	loff_t start = (loff_t)page->index << PAGE_CACHE_SHIFT;
	int ret, unlock = 1;

288 289
	trace_ocfs2_readpage((unsigned long long)oi->ip_blkno,
			     (page ? page->index : 0));
290

291
	ret = ocfs2_inode_lock_with_page(inode, NULL, 0, page);
292 293 294 295 296 297 298
	if (ret != 0) {
		if (ret == AOP_TRUNCATED_PAGE)
			unlock = 0;
		mlog_errno(ret);
		goto out;
	}

299
	if (down_read_trylock(&oi->ip_alloc_sem) == 0) {
300 301 302 303
		/*
		 * Unlock the page and cycle ip_alloc_sem so that we don't
		 * busyloop waiting for ip_alloc_sem to unlock
		 */
304
		ret = AOP_TRUNCATED_PAGE;
305 306 307 308
		unlock_page(page);
		unlock = 0;
		down_read(&oi->ip_alloc_sem);
		up_read(&oi->ip_alloc_sem);
309
		goto out_inode_unlock;
310
	}
311 312 313 314 315 316

	/*
	 * i_size might have just been updated as we grabed the meta lock.  We
	 * might now be discovering a truncate that hit on another node.
	 * block_read_full_page->get_block freaks out if it is asked to read
	 * beyond the end of a file, so we check here.  Callers
317
	 * (generic_file_read, vm_ops->fault) are clever enough to check i_size
318 319 320 321 322
	 * and notice that the page they just read isn't needed.
	 *
	 * XXX sys_readahead() seems to get that wrong?
	 */
	if (start >= i_size_read(inode)) {
323
		zero_user(page, 0, PAGE_SIZE);
324 325 326 327 328
		SetPageUptodate(page);
		ret = 0;
		goto out_alloc;
	}

329 330 331 332
	if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL)
		ret = ocfs2_readpage_inline(inode, page);
	else
		ret = block_read_full_page(page, ocfs2_get_block);
333 334 335 336
	unlock = 0;

out_alloc:
	up_read(&OCFS2_I(inode)->ip_alloc_sem);
337 338
out_inode_unlock:
	ocfs2_inode_unlock(inode, 0);
339 340 341 342 343 344
out:
	if (unlock)
		unlock_page(page);
	return ret;
}

Mark Fasheh's avatar
Mark Fasheh committed
345 346 347 348 349 350 351 352 353 354 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
/*
 * This is used only for read-ahead. Failures or difficult to handle
 * situations are safe to ignore.
 *
 * Right now, we don't bother with BH_Boundary - in-inode extent lists
 * are quite large (243 extents on 4k blocks), so most inodes don't
 * grow out to a tree. If need be, detecting boundary extents could
 * trivially be added in a future version of ocfs2_get_block().
 */
static int ocfs2_readpages(struct file *filp, struct address_space *mapping,
			   struct list_head *pages, unsigned nr_pages)
{
	int ret, err = -EIO;
	struct inode *inode = mapping->host;
	struct ocfs2_inode_info *oi = OCFS2_I(inode);
	loff_t start;
	struct page *last;

	/*
	 * Use the nonblocking flag for the dlm code to avoid page
	 * lock inversion, but don't bother with retrying.
	 */
	ret = ocfs2_inode_lock_full(inode, NULL, 0, OCFS2_LOCK_NONBLOCK);
	if (ret)
		return err;

	if (down_read_trylock(&oi->ip_alloc_sem) == 0) {
		ocfs2_inode_unlock(inode, 0);
		return err;
	}

	/*
	 * Don't bother with inline-data. There isn't anything
	 * to read-ahead in that case anyway...
	 */
	if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL)
		goto out_unlock;

	/*
	 * Check whether a remote node truncated this file - we just
	 * drop out in that case as it's not worth handling here.
	 */
	last = list_entry(pages->prev, struct page, lru);
	start = (loff_t)last->index << PAGE_CACHE_SHIFT;
	if (start >= i_size_read(inode))
		goto out_unlock;

	err = mpage_readpages(mapping, pages, nr_pages, ocfs2_get_block);

out_unlock:
	up_read(&oi->ip_alloc_sem);
	ocfs2_inode_unlock(inode, 0);

	return err;
}

401 402 403 404 405 406 407 408 409 410 411 412 413
/* Note: Because we don't support holes, our allocation has
 * already happened (allocation writes zeros to the file data)
 * so we don't have to worry about ordered writes in
 * ocfs2_writepage.
 *
 * ->writepage is called during the process of invalidating the page cache
 * during blocked lock processing.  It can't block on any cluster locks
 * to during block mapping.  It's relying on the fact that the block
 * mapping can't have disappeared under the dirty pages that it is
 * being asked to write back.
 */
static int ocfs2_writepage(struct page *page, struct writeback_control *wbc)
{
414 415 416
	trace_ocfs2_writepage(
		(unsigned long long)OCFS2_I(page->mapping->host)->ip_blkno,
		page->index);
417

418
	return block_write_full_page(page, ocfs2_get_block, wbc);
419 420 421 422 423 424
}

/* Taken from ext3. We don't necessarily need the full blown
 * functionality yet, but IMHO it's better to cut and paste the whole
 * thing so we can avoid introducing our own bugs (and easily pick up
 * their fixes when they happen) --Mark */
425 426 427 428 429 430 431
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))
432 433 434 435 436 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
{
	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);
	    	block_start = block_end, bh = next)
	{
		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;
}

static sector_t ocfs2_bmap(struct address_space *mapping, sector_t block)
{
	sector_t status;
	u64 p_blkno = 0;
	int err = 0;
	struct inode *inode = mapping->host;

464 465
	trace_ocfs2_bmap((unsigned long long)OCFS2_I(inode)->ip_blkno,
			 (unsigned long long)block);
466 467 468 469 470

	/* We don't need to lock journal system files, since they aren't
	 * accessed concurrently from multiple nodes.
	 */
	if (!INODE_JOURNAL(inode)) {
471
		err = ocfs2_inode_lock(inode, NULL, 0);
472 473 474 475 476 477 478 479
		if (err) {
			if (err != -ENOENT)
				mlog_errno(err);
			goto bail;
		}
		down_read(&OCFS2_I(inode)->ip_alloc_sem);
	}

480 481 482
	if (!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL))
		err = ocfs2_extent_map_get_blocks(inode, block, &p_blkno, NULL,
						  NULL);
483 484 485

	if (!INODE_JOURNAL(inode)) {
		up_read(&OCFS2_I(inode)->ip_alloc_sem);
486
		ocfs2_inode_unlock(inode, 0);
487 488 489 490 491 492 493 494 495 496 497 498 499 500 501
	}

	if (err) {
		mlog(ML_ERROR, "get_blocks() failed, block = %llu\n",
		     (unsigned long long)block);
		mlog_errno(err);
		goto bail;
	}

bail:
	status = err ? 0 : p_blkno;

	return status;
}

502 503 504 505
static int ocfs2_releasepage(struct page *page, gfp_t wait)
{
	if (!page_has_buffers(page))
		return 0;
506
	return try_to_free_buffers(page);
507 508
}

509 510 511 512 513 514 515 516 517 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 544 545 546 547 548 549 550 551 552
static void ocfs2_figure_cluster_boundaries(struct ocfs2_super *osb,
					    u32 cpos,
					    unsigned int *start,
					    unsigned int *end)
{
	unsigned int cluster_start = 0, cluster_end = PAGE_CACHE_SIZE;

	if (unlikely(PAGE_CACHE_SHIFT > osb->s_clustersize_bits)) {
		unsigned int cpp;

		cpp = 1 << (PAGE_CACHE_SHIFT - osb->s_clustersize_bits);

		cluster_start = cpos % cpp;
		cluster_start = cluster_start << osb->s_clustersize_bits;

		cluster_end = cluster_start + osb->s_clustersize;
	}

	BUG_ON(cluster_start > PAGE_SIZE);
	BUG_ON(cluster_end > PAGE_SIZE);

	if (start)
		*start = cluster_start;
	if (end)
		*end = cluster_end;
}

/*
 * 'from' and 'to' are the region in the page to avoid zeroing.
 *
 * If pagesize > clustersize, this function will avoid zeroing outside
 * of the cluster boundary.
 *
 * from == to == 0 is code for "zero the entire cluster region"
 */
static void ocfs2_clear_page_regions(struct page *page,
				     struct ocfs2_super *osb, u32 cpos,
				     unsigned from, unsigned to)
{
	void *kaddr;
	unsigned int cluster_start, cluster_end;

	ocfs2_figure_cluster_boundaries(osb, cpos, &cluster_start, &cluster_end);

553
	kaddr = kmap_atomic(page);
554 555 556 557 558 559 560 561 562 563

	if (from || to) {
		if (from > cluster_start)
			memset(kaddr + cluster_start, 0, from - cluster_start);
		if (to < cluster_end)
			memset(kaddr + to, 0, cluster_end - to);
	} else {
		memset(kaddr + cluster_start, 0, cluster_end - cluster_start);
	}

564
	kunmap_atomic(kaddr);
565 566
}

567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587
/*
 * Nonsparse file systems fully allocate before we get to the write
 * code. This prevents ocfs2_write() from tagging the write as an
 * allocating one, which means ocfs2_map_page_blocks() might try to
 * read-in the blocks at the tail of our file. Avoid reading them by
 * testing i_size against each block offset.
 */
static int ocfs2_should_read_blk(struct inode *inode, struct page *page,
				 unsigned int block_start)
{
	u64 offset = page_offset(page) + block_start;

	if (ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)))
		return 1;

	if (i_size_read(inode) > offset)
		return 1;

	return 0;
}

588
/*
589
 * Some of this taken from __block_write_begin(). We already have our
590 591 592 593 594
 * mapping by now though, and the entire write will be allocating or
 * it won't, so not much need to use BH_New.
 *
 * This will also skip zeroing, which is handled externally.
 */
595 596 597
int ocfs2_map_page_blocks(struct page *page, u64 *p_blkno,
			  struct inode *inode, unsigned int from,
			  unsigned int to, int new)
598 599 600 601 602 603 604 605 606 607 608 609 610 611
{
	int ret = 0;
	struct buffer_head *head, *bh, *wait[2], **wait_bh = wait;
	unsigned int block_end, block_start;
	unsigned int bsize = 1 << inode->i_blkbits;

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

	head = page_buffers(page);
	for (bh = head, block_start = 0; bh != head || !block_start;
	     bh = bh->b_this_page, block_start += bsize) {
		block_end = block_start + bsize;

612 613
		clear_buffer_new(bh);

614 615 616 617
		/*
		 * Ignore blocks outside of our i/o range -
		 * they may belong to unallocated clusters.
		 */
618
		if (block_start >= to || block_end <= from) {
619 620 621 622 623 624 625 626 627
			if (PageUptodate(page))
				set_buffer_uptodate(bh);
			continue;
		}

		/*
		 * For an allocating write with cluster size >= page
		 * size, we always write the entire page.
		 */
628 629
		if (new)
			set_buffer_new(bh);
630 631 632 633 634 635 636 637 638 639

		if (!buffer_mapped(bh)) {
			map_bh(bh, inode->i_sb, *p_blkno);
			unmap_underlying_metadata(bh->b_bdev, bh->b_blocknr);
		}

		if (PageUptodate(page)) {
			if (!buffer_uptodate(bh))
				set_buffer_uptodate(bh);
		} else if (!buffer_uptodate(bh) && !buffer_delay(bh) &&
640
			   !buffer_new(bh) &&
641
			   ocfs2_should_read_blk(inode, page, block_start) &&
642
			   (block_start < from || block_end > to)) {
643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674
			ll_rw_block(READ, 1, &bh);
			*wait_bh++=bh;
		}

		*p_blkno = *p_blkno + 1;
	}

	/*
	 * If we issued read requests - let them complete.
	 */
	while(wait_bh > wait) {
		wait_on_buffer(*--wait_bh);
		if (!buffer_uptodate(*wait_bh))
			ret = -EIO;
	}

	if (ret == 0 || !new)
		return ret;

	/*
	 * If we get -EIO above, zero out any newly allocated blocks
	 * to avoid exposing stale data.
	 */
	bh = head;
	block_start = 0;
	do {
		block_end = block_start + bsize;
		if (block_end <= from)
			goto next_bh;
		if (block_start >= to)
			break;

675
		zero_user(page, block_start, bh->b_size);
676 677 678 679 680 681 682 683 684 685 686
		set_buffer_uptodate(bh);
		mark_buffer_dirty(bh);

next_bh:
		block_start = block_end;
		bh = bh->b_this_page;
	} while (bh != head);

	return ret;
}

687 688 689 690 691 692 693 694
#if (PAGE_CACHE_SIZE >= OCFS2_MAX_CLUSTERSIZE)
#define OCFS2_MAX_CTXT_PAGES	1
#else
#define OCFS2_MAX_CTXT_PAGES	(OCFS2_MAX_CLUSTERSIZE / PAGE_CACHE_SIZE)
#endif

#define OCFS2_MAX_CLUSTERS_PER_PAGE	(PAGE_CACHE_SIZE / OCFS2_MIN_CLUSTERSIZE)

695 696 697 698 699 700 701
struct ocfs2_unwritten_extent {
	struct list_head	ue_node;
	struct list_head	ue_ip_node;
	u32			ue_cpos;
	u32			ue_phys;
};

702
/*
703
 * Describe the state of a single cluster to be written to.
704
 */
705 706 707 708 709 710 711 712
struct ocfs2_write_cluster_desc {
	u32		c_cpos;
	u32		c_phys;
	/*
	 * Give this a unique field because c_phys eventually gets
	 * filled.
	 */
	unsigned	c_new;
713
	unsigned	c_clear_unwritten;
714
	unsigned	c_needs_zero;
715
};
716

717 718 719 720
struct ocfs2_write_ctxt {
	/* Logical cluster position / len of write */
	u32				w_cpos;
	u32				w_clen;
721

722 723 724
	/* First cluster allocated in a nonsparse extend */
	u32				w_first_new_cpos;

725 726 727
	/* Type of caller. Must be one of buffer, mmap, direct.  */
	ocfs2_write_type_t		w_type;

728
	struct ocfs2_write_cluster_desc	w_desc[OCFS2_MAX_CLUSTERS_PER_PAGE];
729

730 731 732 733 734 735 736
	/*
	 * This is true if page_size > cluster_size.
	 *
	 * It triggers a set of special cases during write which might
	 * have to deal with allocating writes to partial pages.
	 */
	unsigned int			w_large_pages;
737

738 739 740 741 742 743 744 745 746 747 748 749 750
	/*
	 * Pages involved in this write.
	 *
	 * w_target_page is the page being written to by the user.
	 *
	 * w_pages is an array of pages which always contains
	 * w_target_page, and in the case of an allocating write with
	 * page_size < cluster size, it will contain zero'd and mapped
	 * pages adjacent to w_target_page which need to be written
	 * out in so that future reads from that region will get
	 * zero's.
	 */
	unsigned int			w_num_pages;
751
	struct page			*w_pages[OCFS2_MAX_CTXT_PAGES];
752
	struct page			*w_target_page;
753

Wengang Wang's avatar
Wengang Wang committed
754 755 756 757 758 759
	/*
	 * w_target_locked is used for page_mkwrite path indicating no unlocking
	 * against w_target_page in ocfs2_write_end_nolock.
	 */
	unsigned int			w_target_locked:1;

760 761 762 763 764 765 766 767 768 769 770 771 772 773
	/*
	 * ocfs2_write_end() uses this to know what the real range to
	 * write in the target should be.
	 */
	unsigned int			w_target_from;
	unsigned int			w_target_to;

	/*
	 * We could use journal_current_handle() but this is cleaner,
	 * IMHO -Mark
	 */
	handle_t			*w_handle;

	struct buffer_head		*w_di_bh;
774 775

	struct ocfs2_cached_dealloc_ctxt w_dealloc;
776 777

	struct list_head		w_unwritten_list;
778 779
};

780
void ocfs2_unlock_and_free_pages(struct page **pages, int num_pages)
781 782 783
{
	int i;

784 785 786 787 788 789
	for(i = 0; i < num_pages; i++) {
		if (pages[i]) {
			unlock_page(pages[i]);
			mark_page_accessed(pages[i]);
			page_cache_release(pages[i]);
		}
790
	}
791 792
}

793
static void ocfs2_unlock_pages(struct ocfs2_write_ctxt *wc)
794
{
Wengang Wang's avatar
Wengang Wang committed
795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812
	int i;

	/*
	 * w_target_locked is only set to true in the page_mkwrite() case.
	 * The intent is to allow us to lock the target page from write_begin()
	 * to write_end(). The caller must hold a ref on w_target_page.
	 */
	if (wc->w_target_locked) {
		BUG_ON(!wc->w_target_page);
		for (i = 0; i < wc->w_num_pages; i++) {
			if (wc->w_target_page == wc->w_pages[i]) {
				wc->w_pages[i] = NULL;
				break;
			}
		}
		mark_page_accessed(wc->w_target_page);
		page_cache_release(wc->w_target_page);
	}
813
	ocfs2_unlock_and_free_pages(wc->w_pages, wc->w_num_pages);
814
}
815

816 817 818 819
static void ocfs2_free_unwritten_list(struct inode *inode,
				 struct list_head *head)
{
	struct ocfs2_inode_info *oi = OCFS2_I(inode);
820
	struct ocfs2_unwritten_extent *ue = NULL, *tmp = NULL;
821

822 823
	list_for_each_entry_safe(ue, tmp, head, ue_node) {
		list_del(&ue->ue_node);
824
		spin_lock(&oi->ip_lock);
825
		list_del(&ue->ue_ip_node);
826
		spin_unlock(&oi->ip_lock);
827
		kfree(ue);
828 829 830 831 832
	}
}

static void ocfs2_free_write_ctxt(struct inode *inode,
				  struct ocfs2_write_ctxt *wc)
833
{
834
	ocfs2_free_unwritten_list(inode, &wc->w_unwritten_list);
835
	ocfs2_unlock_pages(wc);
836 837 838 839 840 841
	brelse(wc->w_di_bh);
	kfree(wc);
}

static int ocfs2_alloc_write_ctxt(struct ocfs2_write_ctxt **wcp,
				  struct ocfs2_super *osb, loff_t pos,
842 843
				  unsigned len, ocfs2_write_type_t type,
				  struct buffer_head *di_bh)
844
{
845
	u32 cend;
846 847 848 849 850
	struct ocfs2_write_ctxt *wc;

	wc = kzalloc(sizeof(struct ocfs2_write_ctxt), GFP_NOFS);
	if (!wc)
		return -ENOMEM;
851

852
	wc->w_cpos = pos >> osb->s_clustersize_bits;
853
	wc->w_first_new_cpos = UINT_MAX;
854 855
	cend = (pos + len - 1) >> osb->s_clustersize_bits;
	wc->w_clen = cend - wc->w_cpos + 1;
856 857
	get_bh(di_bh);
	wc->w_di_bh = di_bh;
858
	wc->w_type = type;
859

860 861 862 863 864
	if (unlikely(PAGE_CACHE_SHIFT > osb->s_clustersize_bits))
		wc->w_large_pages = 1;
	else
		wc->w_large_pages = 0;

865
	ocfs2_init_dealloc_ctxt(&wc->w_dealloc);
866
	INIT_LIST_HEAD(&wc->w_unwritten_list);
867

868
	*wcp = wc;
869

870
	return 0;
871 872
}

873
/*
874 875 876
 * If a page has any new buffers, zero them out here, and mark them uptodate
 * and dirty so they'll be written out (in order to prevent uninitialised
 * block data from leaking). And clear the new bit.
877
 */
878
static void ocfs2_zero_new_buffers(struct page *page, unsigned from, unsigned to)
879
{
880 881
	unsigned int block_start, block_end;
	struct buffer_head *head, *bh;
882

883 884 885
	BUG_ON(!PageLocked(page));
	if (!page_has_buffers(page))
		return;
886

887 888 889 890 891 892 893 894 895 896 897 898 899
	bh = head = page_buffers(page);
	block_start = 0;
	do {
		block_end = block_start + bh->b_size;

		if (buffer_new(bh)) {
			if (block_end > from && block_start < to) {
				if (!PageUptodate(page)) {
					unsigned start, end;

					start = max(from, block_start);
					end = min(to, block_end);

900
					zero_user_segment(page, start, end);
901 902 903 904 905 906 907
					set_buffer_uptodate(bh);
				}

				clear_buffer_new(bh);
				mark_buffer_dirty(bh);
			}
		}
908

909 910 911 912 913 914 915 916 917 918 919 920 921 922
		block_start = block_end;
		bh = bh->b_this_page;
	} while (bh != head);
}

/*
 * Only called when we have a failure during allocating write to write
 * zero's to the newly allocated region.
 */
static void ocfs2_write_failure(struct inode *inode,
				struct ocfs2_write_ctxt *wc,
				loff_t user_pos, unsigned user_len)
{
	int i;
923 924
	unsigned from = user_pos & (PAGE_CACHE_SIZE - 1),
		to = user_pos + user_len;
925 926
	struct page *tmppage;

927 928
	if (wc->w_target_page)
		ocfs2_zero_new_buffers(wc->w_target_page, from, to);
929

930 931
	for(i = 0; i < wc->w_num_pages; i++) {
		tmppage = wc->w_pages[i];
932

933
		if (tmppage && page_has_buffers(tmppage)) {
934
			if (ocfs2_should_order_data(inode))
Joel Becker's avatar
Joel Becker committed
935
				ocfs2_jbd2_file_inode(wc->w_handle, inode);
936 937 938

			block_commit_write(tmppage, from, to);
		}
939 940 941
	}
}

942 943 944 945 946
static int ocfs2_prepare_page_for_write(struct inode *inode, u64 *p_blkno,
					struct ocfs2_write_ctxt *wc,
					struct page *page, u32 cpos,
					loff_t user_pos, unsigned user_len,
					int new)
947
{
948 949
	int ret;
	unsigned int map_from = 0, map_to = 0;
950
	unsigned int cluster_start, cluster_end;
951
	unsigned int user_data_from = 0, user_data_to = 0;
952

953
	ocfs2_figure_cluster_boundaries(OCFS2_SB(inode->i_sb), cpos,
954 955
					&cluster_start, &cluster_end);

956 957 958 959 960 961
	/* treat the write as new if the a hole/lseek spanned across
	 * the page boundary.
	 */
	new = new | ((i_size_read(inode) <= page_offset(page)) &&
			(page_offset(page) <= user_pos));

962 963 964 965 966 967 968 969 970 971 972 973
	if (page == wc->w_target_page) {
		map_from = user_pos & (PAGE_CACHE_SIZE - 1);
		map_to = map_from + user_len;

		if (new)
			ret = ocfs2_map_page_blocks(page, p_blkno, inode,
						    cluster_start, cluster_end,
						    new);
		else
			ret = ocfs2_map_page_blocks(page, p_blkno, inode,
						    map_from, map_to, new);
		if (ret) {
974 975 976 977
			mlog_errno(ret);
			goto out;
		}

978 979
		user_data_from = map_from;
		user_data_to = map_to;
980
		if (new) {
981 982
			map_from = cluster_start;
			map_to = cluster_end;
983 984 985 986 987 988 989 990 991
		}
	} else {
		/*
		 * If we haven't allocated the new page yet, we
		 * shouldn't be writing it out without copying user
		 * data. This is likely a math error from the caller.
		 */
		BUG_ON(!new);

992 993
		map_from = cluster_start;
		map_to = cluster_end;
994 995

		ret = ocfs2_map_page_blocks(page, p_blkno, inode,
996
					    cluster_start, cluster_end, new);
997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014
		if (ret) {
			mlog_errno(ret);
			goto out;
		}
	}

	/*
	 * Parts of newly allocated pages need to be zero'd.
	 *
	 * Above, we have also rewritten 'to' and 'from' - as far as
	 * the rest of the function is concerned, the entire cluster
	 * range inside of a page needs to be written.
	 *
	 * We can skip this if the page is up to date - it's already
	 * been zero'd from being read in as a hole.
	 */
	if (new && !PageUptodate(page))
		ocfs2_clear_page_regions(page, OCFS2_SB(inode->i_sb),
1015
					 cpos, user_data_from, user_data_to);
1016 1017 1018 1019

	flush_dcache_page(page);

out:
1020
	return ret;
1021 1022 1023
}

/*
1024
 * This function will only grab one clusters worth of pages.
1025
 */
1026 1027
static int ocfs2_grab_pages_for_write(struct address_space *mapping,
				      struct ocfs2_write_ctxt *wc,
1028 1029
				      u32 cpos, loff_t user_pos,
				      unsigned user_len, int new,
Mark Fasheh's avatar
Mark Fasheh committed
1030
				      struct page *mmap_page)
1031
{
1032
	int ret = 0, i;
1033
	unsigned long start, target_index, end_index, index;
1034
	struct inode *inode = mapping->host;
1035
	loff_t last_byte;
1036

1037
	target_index = user_pos >> PAGE_CACHE_SHIFT;
1038 1039 1040

	/*
	 * Figure out how many pages we'll be manipulating here. For
1041
	 * non allocating write, we just change the one
1042 1043 1044
	 * page. Otherwise, we'll need a whole clusters worth.  If we're
	 * writing past i_size, we only need enough pages to cover the
	 * last page of the write.
1045 1046
	 */
	if (new) {
1047 1048
		wc->w_num_pages = ocfs2_pages_per_cluster(inode->i_sb);
		start = ocfs2_align_clusters_to_page_index(inode->i_sb, cpos);
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
		/*
		 * We need the index *past* the last page we could possibly
		 * touch.  This is the page past the end of the write or
		 * i_size, whichever is greater.
		 */
		last_byte = max(user_pos + user_len, i_size_read(inode));
		BUG_ON(last_byte < 1);
		end_index = ((last_byte - 1) >> PAGE_CACHE_SHIFT) + 1;
		if ((start + wc->w_num_pages) > end_index)
			wc->w_num_pages = end_index - start;
1059
	} else {
1060 1061
		wc->w_num_pages = 1;
		start = target_index;
1062
	}
1063
	end_index = (user_pos + user_len - 1) >> PAGE_CACHE_SHIFT;
1064

1065
	for(i = 0; i < wc->w_num_pages; i++) {
1066 1067
		index = start + i;

1068 1069
		if (index >= target_index && index <= end_index &&
		    wc->w_type == OCFS2_WRITE_MMAP) {
Mark Fasheh's avatar
Mark Fasheh committed
1070 1071 1072 1073 1074 1075 1076
			/*
			 * ocfs2_pagemkwrite() is a little different
			 * and wants us to directly use the page
			 * passed in.
			 */
			lock_page(mmap_page);

Wengang Wang's avatar
Wengang Wang committed
1077
			/* Exit and let the caller retry */
Mark Fasheh's avatar
Mark Fasheh committed
1078
			if (mmap_page->mapping != mapping) {
Wengang Wang's avatar
Wengang Wang committed
1079
				WARN_ON(mmap_page->mapping);
Mark Fasheh's avatar
Mark Fasheh committed
1080
				unlock_page(mmap_page);
Wengang Wang's avatar
Wengang Wang committed
1081
				ret = -EAGAIN;
Mark Fasheh's avatar
Mark Fasheh committed
1082 1083 1084 1085 1086
				goto out;
			}

			page_cache_get(mmap_page);
			wc->w_pages[i] = mmap_page;
Wengang Wang's avatar
Wengang Wang committed
1087
			wc->w_target_locked = true;
1088 1089 1090 1091 1092
		} else if (index >= target_index && index <= end_index &&
			   wc->w_type == OCFS2_WRITE_DIRECT) {
			/* Direct write has no mapping page. */
			wc->w_pages[i] = NULL;
			continue;
Mark Fasheh's avatar
Mark Fasheh committed
1093 1094 1095 1096 1097 1098 1099 1100
		} else {
			wc->w_pages[i] = find_or_create_page(mapping, index,
							     GFP_NOFS);
			if (!wc->w_pages[i]) {
				ret = -ENOMEM;
				mlog_errno(ret);
				goto out;
			}
1101
		}
1102
		wait_for_stable_page(wc->w_pages[i]);
1103 1104 1105

		if (index == target_index)
			wc->w_target_page = wc->w_pages[i];
1106
	}
1107
out:
Wengang Wang's avatar
Wengang Wang committed
1108 1109
	if (ret)
		wc->w_target_locked = false;
1110 1111 1112 1113 1114 1115 1116
	return ret;
}

/*
 * Prepare a single cluster for write one cluster into the file.
 */
static int ocfs2_write_cluster(struct address_space *mapping,
1117
			       u32 *phys, unsigned int new,
1118
			       unsigned int clear_unwritten,
1119
			       unsigned int should_zero,
1120
			       struct ocfs2_alloc_context *data_ac,
1121 1122 1123 1124
			       struct ocfs2_alloc_context *meta_ac,
			       struct ocfs2_write_ctxt *wc, u32 cpos,
			       loff_t user_pos, unsigned user_len)
{
1125
	int ret, i;
1126
	u64 p_blkno;
1127
	struct inode *inode = mapping->host;
1128
	struct ocfs2_extent_tree et;
1129
	int bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
1130

1131
	if (new) {
1132 1133
		u32 tmp_pos;

1134 1135 1136