1/* -*- mode: c; c-basic-offset: 8; -*-
   2 * vim: noexpandtab sw=8 ts=8 sts=0:
   3 *
   4 * Copyright (C) 2002, 2004 Oracle.  All rights reserved.
   5 *
   6 * This program is free software; you can redistribute it and/or
   7 * modify it under the terms of the GNU General Public
   8 * License as published by the Free Software Foundation; either
   9 * version 2 of the License, or (at your option) any later version.
  10 *
  11 * This program is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 * General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU General Public
  17 * License along with this program; if not, write to the
  18 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19 * Boston, MA 021110-1307, USA.
  20 */
  21
  22#include <linux/fs.h>
  23#include <linux/slab.h>
  24#include <linux/highmem.h>
  25#include <linux/pagemap.h>
  26#include <asm/byteorder.h>
  27#include <linux/swap.h>
  28#include <linux/pipe_fs_i.h>
  29#include <linux/mpage.h>
  30#include <linux/quotaops.h>
 
 
 
  31
  32#include <cluster/masklog.h>
  33
  34#include "ocfs2.h"
  35
  36#include "alloc.h"
  37#include "aops.h"
  38#include "dlmglue.h"
  39#include "extent_map.h"
  40#include "file.h"
  41#include "inode.h"
  42#include "journal.h"
  43#include "suballoc.h"
  44#include "super.h"
  45#include "symlink.h"
  46#include "refcounttree.h"
  47#include "ocfs2_trace.h"
  48
  49#include "buffer_head_io.h"
 
 
 
  50
  51static int ocfs2_symlink_get_block(struct inode *inode, sector_t iblock,
  52				   struct buffer_head *bh_result, int create)
  53{
  54	int err = -EIO;
  55	int status;
  56	struct ocfs2_dinode *fe = NULL;
  57	struct buffer_head *bh = NULL;
  58	struct buffer_head *buffer_cache_bh = NULL;
  59	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
  60	void *kaddr;
  61
  62	trace_ocfs2_symlink_get_block(
  63			(unsigned long long)OCFS2_I(inode)->ip_blkno,
  64			(unsigned long long)iblock, bh_result, create);
  65
  66	BUG_ON(ocfs2_inode_is_fast_symlink(inode));
  67
  68	if ((iblock << inode->i_sb->s_blocksize_bits) > PATH_MAX + 1) {
  69		mlog(ML_ERROR, "block offset > PATH_MAX: %llu",
  70		     (unsigned long long)iblock);
  71		goto bail;
  72	}
  73
  74	status = ocfs2_read_inode_block(inode, &bh);
  75	if (status < 0) {
  76		mlog_errno(status);
  77		goto bail;
  78	}
  79	fe = (struct ocfs2_dinode *) bh->b_data;
  80
  81	if ((u64)iblock >= ocfs2_clusters_to_blocks(inode->i_sb,
  82						    le32_to_cpu(fe->i_clusters))) {
  83		err = -ENOMEM;
  84		mlog(ML_ERROR, "block offset is outside the allocated size: "
  85		     "%llu\n", (unsigned long long)iblock);
  86		goto bail;
  87	}
  88
  89	/* We don't use the page cache to create symlink data, so if
  90	 * need be, copy it over from the buffer cache. */
  91	if (!buffer_uptodate(bh_result) && ocfs2_inode_is_new(inode)) {
  92		u64 blkno = le64_to_cpu(fe->id2.i_list.l_recs[0].e_blkno) +
  93			    iblock;
  94		buffer_cache_bh = sb_getblk(osb->sb, blkno);
  95		if (!buffer_cache_bh) {
  96			err = -ENOMEM;
  97			mlog(ML_ERROR, "couldn't getblock for symlink!\n");
  98			goto bail;
  99		}
 100
 101		/* we haven't locked out transactions, so a commit
 102		 * could've happened. Since we've got a reference on
 103		 * the bh, even if it commits while we're doing the
 104		 * copy, the data is still good. */
 105		if (buffer_jbd(buffer_cache_bh)
 106		    && ocfs2_inode_is_new(inode)) {
 107			kaddr = kmap_atomic(bh_result->b_page);
 108			if (!kaddr) {
 109				mlog(ML_ERROR, "couldn't kmap!\n");
 110				goto bail;
 111			}
 112			memcpy(kaddr + (bh_result->b_size * iblock),
 113			       buffer_cache_bh->b_data,
 114			       bh_result->b_size);
 115			kunmap_atomic(kaddr);
 116			set_buffer_uptodate(bh_result);
 117		}
 118		brelse(buffer_cache_bh);
 119	}
 120
 121	map_bh(bh_result, inode->i_sb,
 122	       le64_to_cpu(fe->id2.i_list.l_recs[0].e_blkno) + iblock);
 123
 124	err = 0;
 125
 126bail:
 127	brelse(bh);
 128
 129	return err;
 130}
 131
 
 
 
 
 
 
 
 
 
 
 
 
 
 132int ocfs2_get_block(struct inode *inode, sector_t iblock,
 133		    struct buffer_head *bh_result, int create)
 134{
 135	int err = 0;
 136	unsigned int ext_flags;
 137	u64 max_blocks = bh_result->b_size >> inode->i_blkbits;
 138	u64 p_blkno, count, past_eof;
 139	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
 140
 141	trace_ocfs2_get_block((unsigned long long)OCFS2_I(inode)->ip_blkno,
 142			      (unsigned long long)iblock, bh_result, create);
 143
 144	if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_SYSTEM_FILE)
 145		mlog(ML_NOTICE, "get_block on system inode 0x%p (%lu)\n",
 146		     inode, inode->i_ino);
 147
 148	if (S_ISLNK(inode->i_mode)) {
 149		/* this always does I/O for some reason. */
 150		err = ocfs2_symlink_get_block(inode, iblock, bh_result, create);
 151		goto bail;
 152	}
 153
 154	err = ocfs2_extent_map_get_blocks(inode, iblock, &p_blkno, &count,
 155					  &ext_flags);
 156	if (err) {
 157		mlog(ML_ERROR, "Error %d from get_blocks(0x%p, %llu, 1, "
 158		     "%llu, NULL)\n", err, inode, (unsigned long long)iblock,
 159		     (unsigned long long)p_blkno);
 160		goto bail;
 161	}
 162
 163	if (max_blocks < count)
 164		count = max_blocks;
 165
 166	/*
 167	 * ocfs2 never allocates in this function - the only time we
 168	 * need to use BH_New is when we're extending i_size on a file
 169	 * system which doesn't support holes, in which case BH_New
 170	 * allows __block_write_begin() to zero.
 171	 *
 172	 * If we see this on a sparse file system, then a truncate has
 173	 * raced us and removed the cluster. In this case, we clear
 174	 * the buffers dirty and uptodate bits and let the buffer code
 175	 * ignore it as a hole.
 176	 */
 177	if (create && p_blkno == 0 && ocfs2_sparse_alloc(osb)) {
 178		clear_buffer_dirty(bh_result);
 179		clear_buffer_uptodate(bh_result);
 180		goto bail;
 181	}
 182
 183	/* Treat the unwritten extent as a hole for zeroing purposes. */
 184	if (p_blkno && !(ext_flags & OCFS2_EXT_UNWRITTEN))
 185		map_bh(bh_result, inode->i_sb, p_blkno);
 186
 187	bh_result->b_size = count << inode->i_blkbits;
 188
 189	if (!ocfs2_sparse_alloc(osb)) {
 190		if (p_blkno == 0) {
 191			err = -EIO;
 192			mlog(ML_ERROR,
 193			     "iblock = %llu p_blkno = %llu blkno=(%llu)\n",
 194			     (unsigned long long)iblock,
 195			     (unsigned long long)p_blkno,
 196			     (unsigned long long)OCFS2_I(inode)->ip_blkno);
 197			mlog(ML_ERROR, "Size %llu, clusters %u\n", (unsigned long long)i_size_read(inode), OCFS2_I(inode)->ip_clusters);
 198			dump_stack();
 199			goto bail;
 200		}
 201	}
 202
 203	past_eof = ocfs2_blocks_for_bytes(inode->i_sb, i_size_read(inode));
 204
 205	trace_ocfs2_get_block_end((unsigned long long)OCFS2_I(inode)->ip_blkno,
 206				  (unsigned long long)past_eof);
 207	if (create && (iblock >= past_eof))
 208		set_buffer_new(bh_result);
 209
 210bail:
 211	if (err < 0)
 212		err = -EIO;
 213
 214	return err;
 215}
 216
 217int ocfs2_read_inline_data(struct inode *inode, struct page *page,
 218			   struct buffer_head *di_bh)
 219{
 220	void *kaddr;
 221	loff_t size;
 222	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
 223
 224	if (!(le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_DATA_FL)) {
 225		ocfs2_error(inode->i_sb, "Inode %llu lost inline data flag",
 226			    (unsigned long long)OCFS2_I(inode)->ip_blkno);
 227		return -EROFS;
 228	}
 229
 230	size = i_size_read(inode);
 231
 232	if (size > PAGE_CACHE_SIZE ||
 233	    size > ocfs2_max_inline_data_with_xattr(inode->i_sb, di)) {
 234		ocfs2_error(inode->i_sb,
 235			    "Inode %llu has with inline data has bad size: %Lu",
 236			    (unsigned long long)OCFS2_I(inode)->ip_blkno,
 237			    (unsigned long long)size);
 238		return -EROFS;
 239	}
 240
 241	kaddr = kmap_atomic(page);
 242	if (size)
 243		memcpy(kaddr, di->id2.i_data.id_data, size);
 244	/* Clear the remaining part of the page */
 245	memset(kaddr + size, 0, PAGE_CACHE_SIZE - size);
 246	flush_dcache_page(page);
 247	kunmap_atomic(kaddr);
 248
 249	SetPageUptodate(page);
 250
 251	return 0;
 252}
 253
 254static int ocfs2_readpage_inline(struct inode *inode, struct page *page)
 255{
 256	int ret;
 257	struct buffer_head *di_bh = NULL;
 258
 259	BUG_ON(!PageLocked(page));
 260	BUG_ON(!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL));
 261
 262	ret = ocfs2_read_inode_block(inode, &di_bh);
 263	if (ret) {
 264		mlog_errno(ret);
 265		goto out;
 266	}
 267
 268	ret = ocfs2_read_inline_data(inode, page, di_bh);
 269out:
 270	unlock_page(page);
 271
 272	brelse(di_bh);
 273	return ret;
 274}
 275
 276static int ocfs2_readpage(struct file *file, struct page *page)
 277{
 278	struct inode *inode = page->mapping->host;
 279	struct ocfs2_inode_info *oi = OCFS2_I(inode);
 280	loff_t start = (loff_t)page->index << PAGE_CACHE_SHIFT;
 281	int ret, unlock = 1;
 282
 283	trace_ocfs2_readpage((unsigned long long)oi->ip_blkno,
 284			     (page ? page->index : 0));
 285
 286	ret = ocfs2_inode_lock_with_page(inode, NULL, 0, page);
 287	if (ret != 0) {
 288		if (ret == AOP_TRUNCATED_PAGE)
 289			unlock = 0;
 290		mlog_errno(ret);
 291		goto out;
 292	}
 293
 294	if (down_read_trylock(&oi->ip_alloc_sem) == 0) {
 295		/*
 296		 * Unlock the page and cycle ip_alloc_sem so that we don't
 297		 * busyloop waiting for ip_alloc_sem to unlock
 298		 */
 299		ret = AOP_TRUNCATED_PAGE;
 300		unlock_page(page);
 301		unlock = 0;
 302		down_read(&oi->ip_alloc_sem);
 303		up_read(&oi->ip_alloc_sem);
 304		goto out_inode_unlock;
 305	}
 306
 307	/*
 308	 * i_size might have just been updated as we grabed the meta lock.  We
 309	 * might now be discovering a truncate that hit on another node.
 310	 * block_read_full_page->get_block freaks out if it is asked to read
 311	 * beyond the end of a file, so we check here.  Callers
 312	 * (generic_file_read, vm_ops->fault) are clever enough to check i_size
 313	 * and notice that the page they just read isn't needed.
 314	 *
 315	 * XXX sys_readahead() seems to get that wrong?
 316	 */
 317	if (start >= i_size_read(inode)) {
 318		zero_user(page, 0, PAGE_SIZE);
 319		SetPageUptodate(page);
 320		ret = 0;
 321		goto out_alloc;
 322	}
 323
 324	if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL)
 325		ret = ocfs2_readpage_inline(inode, page);
 326	else
 327		ret = block_read_full_page(page, ocfs2_get_block);
 328	unlock = 0;
 329
 330out_alloc:
 331	up_read(&OCFS2_I(inode)->ip_alloc_sem);
 332out_inode_unlock:
 333	ocfs2_inode_unlock(inode, 0);
 334out:
 335	if (unlock)
 336		unlock_page(page);
 337	return ret;
 338}
 339
 340/*
 341 * This is used only for read-ahead. Failures or difficult to handle
 342 * situations are safe to ignore.
 343 *
 344 * Right now, we don't bother with BH_Boundary - in-inode extent lists
 345 * are quite large (243 extents on 4k blocks), so most inodes don't
 346 * grow out to a tree. If need be, detecting boundary extents could
 347 * trivially be added in a future version of ocfs2_get_block().
 348 */
 349static int ocfs2_readpages(struct file *filp, struct address_space *mapping,
 350			   struct list_head *pages, unsigned nr_pages)
 351{
 352	int ret, err = -EIO;
 353	struct inode *inode = mapping->host;
 354	struct ocfs2_inode_info *oi = OCFS2_I(inode);
 355	loff_t start;
 356	struct page *last;
 357
 358	/*
 359	 * Use the nonblocking flag for the dlm code to avoid page
 360	 * lock inversion, but don't bother with retrying.
 361	 */
 362	ret = ocfs2_inode_lock_full(inode, NULL, 0, OCFS2_LOCK_NONBLOCK);
 363	if (ret)
 364		return err;
 365
 366	if (down_read_trylock(&oi->ip_alloc_sem) == 0) {
 367		ocfs2_inode_unlock(inode, 0);
 368		return err;
 369	}
 370
 371	/*
 372	 * Don't bother with inline-data. There isn't anything
 373	 * to read-ahead in that case anyway...
 374	 */
 375	if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL)
 376		goto out_unlock;
 377
 378	/*
 379	 * Check whether a remote node truncated this file - we just
 380	 * drop out in that case as it's not worth handling here.
 381	 */
 382	last = list_entry(pages->prev, struct page, lru);
 383	start = (loff_t)last->index << PAGE_CACHE_SHIFT;
 384	if (start >= i_size_read(inode))
 385		goto out_unlock;
 386
 387	err = mpage_readpages(mapping, pages, nr_pages, ocfs2_get_block);
 388
 389out_unlock:
 390	up_read(&oi->ip_alloc_sem);
 
 391	ocfs2_inode_unlock(inode, 0);
 392
 393	return err;
 394}
 395
 396/* Note: Because we don't support holes, our allocation has
 397 * already happened (allocation writes zeros to the file data)
 398 * so we don't have to worry about ordered writes in
 399 * ocfs2_writepage.
 400 *
 401 * ->writepage is called during the process of invalidating the page cache
 402 * during blocked lock processing.  It can't block on any cluster locks
 403 * to during block mapping.  It's relying on the fact that the block
 404 * mapping can't have disappeared under the dirty pages that it is
 405 * being asked to write back.
 406 */
 407static int ocfs2_writepage(struct page *page, struct writeback_control *wbc)
 
 408{
 409	trace_ocfs2_writepage(
 410		(unsigned long long)OCFS2_I(page->mapping->host)->ip_blkno,
 411		page->index);
 412
 413	return block_write_full_page(page, ocfs2_get_block, wbc);
 414}
 415
 416/* Taken from ext3. We don't necessarily need the full blown
 417 * functionality yet, but IMHO it's better to cut and paste the whole
 418 * thing so we can avoid introducing our own bugs (and easily pick up
 419 * their fixes when they happen) --Mark */
 420int walk_page_buffers(	handle_t *handle,
 421			struct buffer_head *head,
 422			unsigned from,
 423			unsigned to,
 424			int *partial,
 425			int (*fn)(	handle_t *handle,
 426					struct buffer_head *bh))
 427{
 428	struct buffer_head *bh;
 429	unsigned block_start, block_end;
 430	unsigned blocksize = head->b_size;
 431	int err, ret = 0;
 432	struct buffer_head *next;
 433
 434	for (	bh = head, block_start = 0;
 435		ret == 0 && (bh != head || !block_start);
 436	    	block_start = block_end, bh = next)
 437	{
 438		next = bh->b_this_page;
 439		block_end = block_start + blocksize;
 440		if (block_end <= from || block_start >= to) {
 441			if (partial && !buffer_uptodate(bh))
 442				*partial = 1;
 443			continue;
 444		}
 445		err = (*fn)(handle, bh);
 446		if (!ret)
 447			ret = err;
 448	}
 449	return ret;
 450}
 451
 452static sector_t ocfs2_bmap(struct address_space *mapping, sector_t block)
 453{
 454	sector_t status;
 455	u64 p_blkno = 0;
 456	int err = 0;
 457	struct inode *inode = mapping->host;
 458
 459	trace_ocfs2_bmap((unsigned long long)OCFS2_I(inode)->ip_blkno,
 460			 (unsigned long long)block);
 461
 
 
 
 
 
 
 
 
 
 462	/* We don't need to lock journal system files, since they aren't
 463	 * accessed concurrently from multiple nodes.
 464	 */
 465	if (!INODE_JOURNAL(inode)) {
 466		err = ocfs2_inode_lock(inode, NULL, 0);
 467		if (err) {
 468			if (err != -ENOENT)
 469				mlog_errno(err);
 470			goto bail;
 471		}
 472		down_read(&OCFS2_I(inode)->ip_alloc_sem);
 473	}
 474
 475	if (!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL))
 476		err = ocfs2_extent_map_get_blocks(inode, block, &p_blkno, NULL,
 477						  NULL);
 478
 479	if (!INODE_JOURNAL(inode)) {
 480		up_read(&OCFS2_I(inode)->ip_alloc_sem);
 481		ocfs2_inode_unlock(inode, 0);
 482	}
 483
 484	if (err) {
 485		mlog(ML_ERROR, "get_blocks() failed, block = %llu\n",
 486		     (unsigned long long)block);
 487		mlog_errno(err);
 488		goto bail;
 489	}
 490
 491bail:
 492	status = err ? 0 : p_blkno;
 493
 494	return status;
 495}
 496
 497/*
 498 * TODO: Make this into a generic get_blocks function.
 499 *
 500 * From do_direct_io in direct-io.c:
 501 *  "So what we do is to permit the ->get_blocks function to populate
 502 *   bh.b_size with the size of IO which is permitted at this offset and
 503 *   this i_blkbits."
 504 *
 505 * This function is called directly from get_more_blocks in direct-io.c.
 506 *
 507 * called like this: dio->get_blocks(dio->inode, fs_startblk,
 508 * 					fs_count, map_bh, dio->rw == WRITE);
 509 *
 510 * Note that we never bother to allocate blocks here, and thus ignore the
 511 * create argument.
 512 */
 513static int ocfs2_direct_IO_get_blocks(struct inode *inode, sector_t iblock,
 514				     struct buffer_head *bh_result, int create)
 515{
 516	int ret;
 517	u64 p_blkno, inode_blocks, contig_blocks;
 518	unsigned int ext_flags;
 519	unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
 520	unsigned long max_blocks = bh_result->b_size >> inode->i_blkbits;
 521
 522	/* This function won't even be called if the request isn't all
 523	 * nicely aligned and of the right size, so there's no need
 524	 * for us to check any of that. */
 525
 526	inode_blocks = ocfs2_blocks_for_bytes(inode->i_sb, i_size_read(inode));
 527
 528	/* This figures out the size of the next contiguous block, and
 529	 * our logical offset */
 530	ret = ocfs2_extent_map_get_blocks(inode, iblock, &p_blkno,
 531					  &contig_blocks, &ext_flags);
 532	if (ret) {
 533		mlog(ML_ERROR, "get_blocks() failed iblock=%llu\n",
 534		     (unsigned long long)iblock);
 535		ret = -EIO;
 536		goto bail;
 537	}
 538
 539	/* We should already CoW the refcounted extent in case of create. */
 540	BUG_ON(create && (ext_flags & OCFS2_EXT_REFCOUNTED));
 541
 542	/*
 543	 * get_more_blocks() expects us to describe a hole by clearing
 544	 * the mapped bit on bh_result().
 545	 *
 546	 * Consider an unwritten extent as a hole.
 547	 */
 548	if (p_blkno && !(ext_flags & OCFS2_EXT_UNWRITTEN))
 549		map_bh(bh_result, inode->i_sb, p_blkno);
 550	else
 551		clear_buffer_mapped(bh_result);
 552
 553	/* make sure we don't map more than max_blocks blocks here as
 554	   that's all the kernel will handle at this point. */
 555	if (max_blocks < contig_blocks)
 556		contig_blocks = max_blocks;
 557	bh_result->b_size = contig_blocks << blocksize_bits;
 558bail:
 559	return ret;
 560}
 561
 562/*
 563 * ocfs2_dio_end_io is called by the dio core when a dio is finished.  We're
 564 * particularly interested in the aio/dio case.  We use the rw_lock DLM lock
 565 * to protect io on one node from truncation on another.
 566 */
 567static void ocfs2_dio_end_io(struct kiocb *iocb,
 568			     loff_t offset,
 569			     ssize_t bytes,
 570			     void *private)
 571{
 572	struct inode *inode = file_inode(iocb->ki_filp);
 573	int level;
 574
 575	/* this io's submitter should not have unlocked this before we could */
 576	BUG_ON(!ocfs2_iocb_is_rw_locked(iocb));
 577
 578	if (ocfs2_iocb_is_sem_locked(iocb))
 579		ocfs2_iocb_clear_sem_locked(iocb);
 580
 581	if (ocfs2_iocb_is_unaligned_aio(iocb)) {
 582		ocfs2_iocb_clear_unaligned_aio(iocb);
 583
 584		mutex_unlock(&OCFS2_I(inode)->ip_unaligned_aio);
 585	}
 586
 587	ocfs2_iocb_clear_rw_locked(iocb);
 588
 589	level = ocfs2_iocb_rw_locked_level(iocb);
 590	ocfs2_rw_unlock(inode, level);
 591}
 592
 593static int ocfs2_releasepage(struct page *page, gfp_t wait)
 594{
 595	if (!page_has_buffers(page))
 596		return 0;
 597	return try_to_free_buffers(page);
 598}
 599
 600static ssize_t ocfs2_direct_IO(int rw,
 601			       struct kiocb *iocb,
 602			       const struct iovec *iov,
 603			       loff_t offset,
 604			       unsigned long nr_segs)
 605{
 606	struct file *file = iocb->ki_filp;
 607	struct inode *inode = file_inode(file)->i_mapping->host;
 608
 609	/*
 610	 * Fallback to buffered I/O if we see an inode without
 611	 * extents.
 612	 */
 613	if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
 614		return 0;
 615
 616	/* Fallback to buffered I/O if we are appending. */
 617	if (i_size_read(inode) <= offset)
 618		return 0;
 619
 620	return __blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev,
 621				    iov, offset, nr_segs,
 622				    ocfs2_direct_IO_get_blocks,
 623				    ocfs2_dio_end_io, NULL, 0);
 624}
 625
 626static void ocfs2_figure_cluster_boundaries(struct ocfs2_super *osb,
 627					    u32 cpos,
 628					    unsigned int *start,
 629					    unsigned int *end)
 630{
 631	unsigned int cluster_start = 0, cluster_end = PAGE_CACHE_SIZE;
 632
 633	if (unlikely(PAGE_CACHE_SHIFT > osb->s_clustersize_bits)) {
 634		unsigned int cpp;
 635
 636		cpp = 1 << (PAGE_CACHE_SHIFT - osb->s_clustersize_bits);
 637
 638		cluster_start = cpos % cpp;
 639		cluster_start = cluster_start << osb->s_clustersize_bits;
 640
 641		cluster_end = cluster_start + osb->s_clustersize;
 642	}
 643
 644	BUG_ON(cluster_start > PAGE_SIZE);
 645	BUG_ON(cluster_end > PAGE_SIZE);
 646
 647	if (start)
 648		*start = cluster_start;
 649	if (end)
 650		*end = cluster_end;
 651}
 652
 653/*
 654 * 'from' and 'to' are the region in the page to avoid zeroing.
 655 *
 656 * If pagesize > clustersize, this function will avoid zeroing outside
 657 * of the cluster boundary.
 658 *
 659 * from == to == 0 is code for "zero the entire cluster region"
 660 */
 661static void ocfs2_clear_page_regions(struct page *page,
 662				     struct ocfs2_super *osb, u32 cpos,
 663				     unsigned from, unsigned to)
 664{
 665	void *kaddr;
 666	unsigned int cluster_start, cluster_end;
 667
 668	ocfs2_figure_cluster_boundaries(osb, cpos, &cluster_start, &cluster_end);
 669
 670	kaddr = kmap_atomic(page);
 671
 672	if (from || to) {
 673		if (from > cluster_start)
 674			memset(kaddr + cluster_start, 0, from - cluster_start);
 675		if (to < cluster_end)
 676			memset(kaddr + to, 0, cluster_end - to);
 677	} else {
 678		memset(kaddr + cluster_start, 0, cluster_end - cluster_start);
 679	}
 680
 681	kunmap_atomic(kaddr);
 682}
 683
 684/*
 685 * Nonsparse file systems fully allocate before we get to the write
 686 * code. This prevents ocfs2_write() from tagging the write as an
 687 * allocating one, which means ocfs2_map_page_blocks() might try to
 688 * read-in the blocks at the tail of our file. Avoid reading them by
 689 * testing i_size against each block offset.
 690 */
 691static int ocfs2_should_read_blk(struct inode *inode, struct page *page,
 692				 unsigned int block_start)
 693{
 694	u64 offset = page_offset(page) + block_start;
 695
 696	if (ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)))
 697		return 1;
 698
 699	if (i_size_read(inode) > offset)
 700		return 1;
 701
 702	return 0;
 703}
 704
 705/*
 706 * Some of this taken from __block_write_begin(). We already have our
 707 * mapping by now though, and the entire write will be allocating or
 708 * it won't, so not much need to use BH_New.
 709 *
 710 * This will also skip zeroing, which is handled externally.
 711 */
 712int ocfs2_map_page_blocks(struct page *page, u64 *p_blkno,
 713			  struct inode *inode, unsigned int from,
 714			  unsigned int to, int new)
 715{
 
 716	int ret = 0;
 717	struct buffer_head *head, *bh, *wait[2], **wait_bh = wait;
 718	unsigned int block_end, block_start;
 719	unsigned int bsize = 1 << inode->i_blkbits;
 720
 721	if (!page_has_buffers(page))
 722		create_empty_buffers(page, bsize, 0);
 
 723
 724	head = page_buffers(page);
 725	for (bh = head, block_start = 0; bh != head || !block_start;
 726	     bh = bh->b_this_page, block_start += bsize) {
 727		block_end = block_start + bsize;
 728
 729		clear_buffer_new(bh);
 730
 731		/*
 732		 * Ignore blocks outside of our i/o range -
 733		 * they may belong to unallocated clusters.
 734		 */
 735		if (block_start >= to || block_end <= from) {
 736			if (PageUptodate(page))
 737				set_buffer_uptodate(bh);
 738			continue;
 739		}
 740
 741		/*
 742		 * For an allocating write with cluster size >= page
 743		 * size, we always write the entire page.
 744		 */
 745		if (new)
 746			set_buffer_new(bh);
 747
 748		if (!buffer_mapped(bh)) {
 749			map_bh(bh, inode->i_sb, *p_blkno);
 750			unmap_underlying_metadata(bh->b_bdev, bh->b_blocknr);
 751		}
 752
 753		if (PageUptodate(page)) {
 754			if (!buffer_uptodate(bh))
 755				set_buffer_uptodate(bh);
 756		} else if (!buffer_uptodate(bh) && !buffer_delay(bh) &&
 757			   !buffer_new(bh) &&
 758			   ocfs2_should_read_blk(inode, page, block_start) &&
 759			   (block_start < from || block_end > to)) {
 760			ll_rw_block(READ, 1, &bh);
 761			*wait_bh++=bh;
 762		}
 763
 764		*p_blkno = *p_blkno + 1;
 765	}
 766
 767	/*
 768	 * If we issued read requests - let them complete.
 769	 */
 770	while(wait_bh > wait) {
 771		wait_on_buffer(*--wait_bh);
 772		if (!buffer_uptodate(*wait_bh))
 773			ret = -EIO;
 774	}
 775
 776	if (ret == 0 || !new)
 777		return ret;
 778
 779	/*
 780	 * If we get -EIO above, zero out any newly allocated blocks
 781	 * to avoid exposing stale data.
 782	 */
 783	bh = head;
 784	block_start = 0;
 785	do {
 786		block_end = block_start + bsize;
 787		if (block_end <= from)
 788			goto next_bh;
 789		if (block_start >= to)
 790			break;
 791
 792		zero_user(page, block_start, bh->b_size);
 793		set_buffer_uptodate(bh);
 794		mark_buffer_dirty(bh);
 795
 796next_bh:
 797		block_start = block_end;
 798		bh = bh->b_this_page;
 799	} while (bh != head);
 800
 801	return ret;
 802}
 803
 804#if (PAGE_CACHE_SIZE >= OCFS2_MAX_CLUSTERSIZE)
 805#define OCFS2_MAX_CTXT_PAGES	1
 806#else
 807#define OCFS2_MAX_CTXT_PAGES	(OCFS2_MAX_CLUSTERSIZE / PAGE_CACHE_SIZE)
 808#endif
 809
 810#define OCFS2_MAX_CLUSTERS_PER_PAGE	(PAGE_CACHE_SIZE / OCFS2_MIN_CLUSTERSIZE)
 
 
 
 
 
 
 
 811
 812/*
 813 * Describe the state of a single cluster to be written to.
 814 */
 815struct ocfs2_write_cluster_desc {
 816	u32		c_cpos;
 817	u32		c_phys;
 818	/*
 819	 * Give this a unique field because c_phys eventually gets
 820	 * filled.
 821	 */
 822	unsigned	c_new;
 823	unsigned	c_unwritten;
 824	unsigned	c_needs_zero;
 825};
 826
 827struct ocfs2_write_ctxt {
 828	/* Logical cluster position / len of write */
 829	u32				w_cpos;
 830	u32				w_clen;
 831
 832	/* First cluster allocated in a nonsparse extend */
 833	u32				w_first_new_cpos;
 834
 
 
 
 835	struct ocfs2_write_cluster_desc	w_desc[OCFS2_MAX_CLUSTERS_PER_PAGE];
 836
 837	/*
 838	 * This is true if page_size > cluster_size.
 839	 *
 840	 * It triggers a set of special cases during write which might
 841	 * have to deal with allocating writes to partial pages.
 842	 */
 843	unsigned int			w_large_pages;
 844
 845	/*
 846	 * Pages involved in this write.
 847	 *
 848	 * w_target_page is the page being written to by the user.
 849	 *
 850	 * w_pages is an array of pages which always contains
 851	 * w_target_page, and in the case of an allocating write with
 852	 * page_size < cluster size, it will contain zero'd and mapped
 853	 * pages adjacent to w_target_page which need to be written
 854	 * out in so that future reads from that region will get
 855	 * zero's.
 856	 */
 857	unsigned int			w_num_pages;
 858	struct page			*w_pages[OCFS2_MAX_CTXT_PAGES];
 859	struct page			*w_target_page;
 860
 861	/*
 862	 * w_target_locked is used for page_mkwrite path indicating no unlocking
 863	 * against w_target_page in ocfs2_write_end_nolock.
 864	 */
 865	unsigned int			w_target_locked:1;
 866
 867	/*
 868	 * ocfs2_write_end() uses this to know what the real range to
 869	 * write in the target should be.
 870	 */
 871	unsigned int			w_target_from;
 872	unsigned int			w_target_to;
 873
 874	/*
 875	 * We could use journal_current_handle() but this is cleaner,
 876	 * IMHO -Mark
 877	 */
 878	handle_t			*w_handle;
 879
 880	struct buffer_head		*w_di_bh;
 881
 882	struct ocfs2_cached_dealloc_ctxt w_dealloc;
 
 
 
 883};
 884
 885void ocfs2_unlock_and_free_pages(struct page **pages, int num_pages)
 886{
 887	int i;
 888
 889	for(i = 0; i < num_pages; i++) {
 890		if (pages[i]) {
 891			unlock_page(pages[i]);
 892			mark_page_accessed(pages[i]);
 893			page_cache_release(pages[i]);
 894		}
 895	}
 896}
 897
 898static void ocfs2_free_write_ctxt(struct ocfs2_write_ctxt *wc)
 899{
 900	int i;
 901
 902	/*
 903	 * w_target_locked is only set to true in the page_mkwrite() case.
 904	 * The intent is to allow us to lock the target page from write_begin()
 905	 * to write_end(). The caller must hold a ref on w_target_page.
 906	 */
 907	if (wc->w_target_locked) {
 908		BUG_ON(!wc->w_target_page);
 909		for (i = 0; i < wc->w_num_pages; i++) {
 910			if (wc->w_target_page == wc->w_pages[i]) {
 911				wc->w_pages[i] = NULL;
 912				break;
 913			}
 914		}
 915		mark_page_accessed(wc->w_target_page);
 916		page_cache_release(wc->w_target_page);
 917	}
 918	ocfs2_unlock_and_free_pages(wc->w_pages, wc->w_num_pages);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 919
 
 
 
 
 
 920	brelse(wc->w_di_bh);
 921	kfree(wc);
 922}
 923
 924static int ocfs2_alloc_write_ctxt(struct ocfs2_write_ctxt **wcp,
 925				  struct ocfs2_super *osb, loff_t pos,
 926				  unsigned len, struct buffer_head *di_bh)
 
 927{
 928	u32 cend;
 929	struct ocfs2_write_ctxt *wc;
 930
 931	wc = kzalloc(sizeof(struct ocfs2_write_ctxt), GFP_NOFS);
 932	if (!wc)
 933		return -ENOMEM;
 934
 935	wc->w_cpos = pos >> osb->s_clustersize_bits;
 936	wc->w_first_new_cpos = UINT_MAX;
 937	cend = (pos + len - 1) >> osb->s_clustersize_bits;
 938	wc->w_clen = cend - wc->w_cpos + 1;
 939	get_bh(di_bh);
 940	wc->w_di_bh = di_bh;
 
 941
 942	if (unlikely(PAGE_CACHE_SHIFT > osb->s_clustersize_bits))
 943		wc->w_large_pages = 1;
 944	else
 945		wc->w_large_pages = 0;
 946
 947	ocfs2_init_dealloc_ctxt(&wc->w_dealloc);
 
 948
 949	*wcp = wc;
 950
 951	return 0;
 952}
 953
 954/*
 955 * If a page has any new buffers, zero them out here, and mark them uptodate
 956 * and dirty so they'll be written out (in order to prevent uninitialised
 957 * block data from leaking). And clear the new bit.
 958 */
 959static void ocfs2_zero_new_buffers(struct page *page, unsigned from, unsigned to)
 960{
 961	unsigned int block_start, block_end;
 962	struct buffer_head *head, *bh;
 963
 964	BUG_ON(!PageLocked(page));
 965	if (!page_has_buffers(page))
 966		return;
 967
 968	bh = head = page_buffers(page);
 969	block_start = 0;
 970	do {
 971		block_end = block_start + bh->b_size;
 972
 973		if (buffer_new(bh)) {
 974			if (block_end > from && block_start < to) {
 975				if (!PageUptodate(page)) {
 976					unsigned start, end;
 977
 978					start = max(from, block_start);
 979					end = min(to, block_end);
 980
 981					zero_user_segment(page, start, end);
 982					set_buffer_uptodate(bh);
 983				}
 984
 985				clear_buffer_new(bh);
 986				mark_buffer_dirty(bh);
 987			}
 988		}
 989
 990		block_start = block_end;
 991		bh = bh->b_this_page;
 992	} while (bh != head);
 993}
 994
 995/*
 996 * Only called when we have a failure during allocating write to write
 997 * zero's to the newly allocated region.
 998 */
 999static void ocfs2_write_failure(struct inode *inode,
1000				struct ocfs2_write_ctxt *wc,
1001				loff_t user_pos, unsigned user_len)
1002{
1003	int i;
1004	unsigned from = user_pos & (PAGE_CACHE_SIZE - 1),
1005		to = user_pos + user_len;
1006	struct page *tmppage;
1007
1008	ocfs2_zero_new_buffers(wc->w_target_page, from, to);
 
1009
1010	for(i = 0; i < wc->w_num_pages; i++) {
1011		tmppage = wc->w_pages[i];
1012
1013		if (page_has_buffers(tmppage)) {
1014			if (ocfs2_should_order_data(inode))
1015				ocfs2_jbd2_file_inode(wc->w_handle, inode);
 
1016
1017			block_commit_write(tmppage, from, to);
1018		}
1019	}
1020}
1021
1022static int ocfs2_prepare_page_for_write(struct inode *inode, u64 *p_blkno,
1023					struct ocfs2_write_ctxt *wc,
1024					struct page *page, u32 cpos,
1025					loff_t user_pos, unsigned user_len,
1026					int new)
1027{
1028	int ret;
1029	unsigned int map_from = 0, map_to = 0;
1030	unsigned int cluster_start, cluster_end;
1031	unsigned int user_data_from = 0, user_data_to = 0;
1032
1033	ocfs2_figure_cluster_boundaries(OCFS2_SB(inode->i_sb), cpos,
1034					&cluster_start, &cluster_end);
1035
1036	/* treat the write as new if the a hole/lseek spanned across
1037	 * the page boundary.
1038	 */
1039	new = new | ((i_size_read(inode) <= page_offset(page)) &&
1040			(page_offset(page) <= user_pos));
1041
1042	if (page == wc->w_target_page) {
1043		map_from = user_pos & (PAGE_CACHE_SIZE - 1);
1044		map_to = map_from + user_len;
1045
1046		if (new)
1047			ret = ocfs2_map_page_blocks(page, p_blkno, inode,
1048						    cluster_start, cluster_end,
1049						    new);
1050		else
1051			ret = ocfs2_map_page_blocks(page, p_blkno, inode,
1052						    map_from, map_to, new);
1053		if (ret) {
1054			mlog_errno(ret);
1055			goto out;
1056		}
1057
1058		user_data_from = map_from;
1059		user_data_to = map_to;
1060		if (new) {
1061			map_from = cluster_start;
1062			map_to = cluster_end;
1063		}
1064	} else {
1065		/*
1066		 * If we haven't allocated the new page yet, we
1067		 * shouldn't be writing it out without copying user
1068		 * data. This is likely a math error from the caller.
1069		 */
1070		BUG_ON(!new);
1071
1072		map_from = cluster_start;
1073		map_to = cluster_end;
1074
1075		ret = ocfs2_map_page_blocks(page, p_blkno, inode,
1076					    cluster_start, cluster_end, new);
1077		if (ret) {
1078			mlog_errno(ret);
1079			goto out;
1080		}
1081	}
1082
1083	/*
1084	 * Parts of newly allocated pages need to be zero'd.
1085	 *
1086	 * Above, we have also rewritten 'to' and 'from' - as far as
1087	 * the rest of the function is concerned, the entire cluster
1088	 * range inside of a page needs to be written.
1089	 *
1090	 * We can skip this if the page is up to date - it's already
1091	 * been zero'd from being read in as a hole.
1092	 */
1093	if (new && !PageUptodate(page))
1094		ocfs2_clear_page_regions(page, OCFS2_SB(inode->i_sb),
1095					 cpos, user_data_from, user_data_to);
1096
1097	flush_dcache_page(page);
1098
1099out:
1100	return ret;
1101}
1102
1103/*
1104 * This function will only grab one clusters worth of pages.
1105 */
1106static int ocfs2_grab_pages_for_write(struct address_space *mapping,
1107				      struct ocfs2_write_ctxt *wc,
1108				      u32 cpos, loff_t user_pos,
1109				      unsigned user_len, int new,
1110				      struct page *mmap_page)
1111{
1112	int ret = 0, i;
1113	unsigned long start, target_index, end_index, index;
1114	struct inode *inode = mapping->host;
1115	loff_t last_byte;
1116
1117	target_index = user_pos >> PAGE_CACHE_SHIFT;
1118
1119	/*
1120	 * Figure out how many pages we'll be manipulating here. For
1121	 * non allocating write, we just change the one
1122	 * page. Otherwise, we'll need a whole clusters worth.  If we're
1123	 * writing past i_size, we only need enough pages to cover the
1124	 * last page of the write.
1125	 */
1126	if (new) {
1127		wc->w_num_pages = ocfs2_pages_per_cluster(inode->i_sb);
1128		start = ocfs2_align_clusters_to_page_index(inode->i_sb, cpos);
1129		/*
1130		 * We need the index *past* the last page we could possibly
1131		 * touch.  This is the page past the end of the write or
1132		 * i_size, whichever is greater.
1133		 */
1134		last_byte = max(user_pos + user_len, i_size_read(inode));
1135		BUG_ON(last_byte < 1);
1136		end_index = ((last_byte - 1) >> PAGE_CACHE_SHIFT) + 1;
1137		if ((start + wc->w_num_pages) > end_index)
1138			wc->w_num_pages = end_index - start;
1139	} else {
1140		wc->w_num_pages = 1;
1141		start = target_index;
1142	}
 
1143
1144	for(i = 0; i < wc->w_num_pages; i++) {
1145		index = start + i;
1146
1147		if (index == target_index && mmap_page) {
 
1148			/*
1149			 * ocfs2_pagemkwrite() is a little different
1150			 * and wants us to directly use the page
1151			 * passed in.
1152			 */
1153			lock_page(mmap_page);
1154
1155			/* Exit and let the caller retry */
1156			if (mmap_page->mapping != mapping) {
1157				WARN_ON(mmap_page->mapping);
1158				unlock_page(mmap_page);
1159				ret = -EAGAIN;
1160				goto out;
1161			}
1162
1163			page_cache_get(mmap_page);
1164			wc->w_pages[i] = mmap_page;
1165			wc->w_target_locked = true;
 
 
 
 
 
1166		} else {
1167			wc->w_pages[i] = find_or_create_page(mapping, index,
1168							     GFP_NOFS);
1169			if (!wc->w_pages[i]) {
1170				ret = -ENOMEM;
1171				mlog_errno(ret);
1172				goto out;
1173			}
1174		}
1175		wait_for_stable_page(wc->w_pages[i]);
1176
1177		if (index == target_index)
1178			wc->w_target_page = wc->w_pages[i];
1179	}
1180out:
1181	if (ret)
1182		wc->w_target_locked = false;
1183	return ret;
1184}
1185
1186/*
1187 * Prepare a single cluster for write one cluster into the file.
1188 */
1189static int ocfs2_write_cluster(struct address_space *mapping,
1190			       u32 phys, unsigned int unwritten,
 
1191			       unsigned int should_zero,
1192			       struct ocfs2_alloc_context *data_ac,
1193			       struct ocfs2_alloc_context *meta_ac,
1194			       struct ocfs2_write_ctxt *wc, u32 cpos,
1195			       loff_t user_pos, unsigned user_len)
1196{
1197	int ret, i, new;
1198	u64 v_blkno, p_blkno;
1199	struct inode *inode = mapping->host;
1200	struct ocfs2_extent_tree et;
 
1201
1202	new = phys == 0 ? 1 : 0;
1203	if (new) {
1204		u32 tmp_pos;
1205
1206		/*
1207		 * This is safe to call with the page locks - it won't take
1208		 * any additional semaphores or cluster locks.
1209		 */
1210		tmp_pos = cpos;
1211		ret = ocfs2_add_inode_data(OCFS2_SB(inode->i_sb), inode,
1212					   &tmp_pos, 1, 0, wc->w_di_bh,
1213					   wc->w_handle, data_ac,
1214					   meta_ac, NULL);
1215		/*
1216		 * This shouldn't happen because we must have already
1217		 * calculated the correct meta data allocation required. The
1218		 * internal tree allocation code should know how to increase
1219		 * transaction credits itself.
1220		 *
1221		 * If need be, we could handle -EAGAIN for a
1222		 * RESTART_TRANS here.
1223		 */
1224		mlog_bug_on_msg(ret == -EAGAIN,
1225				"Inode %llu: EAGAIN return during allocation.\n",
1226				(unsigned long long)OCFS2_I(inode)->ip_blkno);
1227		if (ret < 0) {
1228			mlog_errno(ret);
1229			goto out;
1230		}
1231	} else if (unwritten) {
1232		ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(inode),
1233					      wc->w_di_bh);
1234		ret = ocfs2_mark_extent_written(inode, &et,
1235						wc->w_handle, cpos, 1, phys,
1236						meta_ac, &wc->w_dealloc);
1237		if (ret < 0) {
1238			mlog_errno(ret);
1239			goto out;
1240		}
1241	}
1242
1243	if (should_zero)
1244		v_blkno = ocfs2_clusters_to_blocks(inode->i_sb, cpos);
1245	else
1246		v_blkno = user_pos >> inode->i_sb->s_blocksize_bits;
1247
1248	/*
1249	 * The only reason this should fail is due to an inability to
1250	 * find the extent added.
1251	 */
1252	ret = ocfs2_extent_map_get_blocks(inode, v_blkno, &p_blkno, NULL,
1253					  NULL);
1254	if (ret < 0) {
1255		ocfs2_error(inode->i_sb, "Corrupting extend for inode %llu, "
1256			    "at logical block %llu",
1257			    (unsigned long long)OCFS2_I(inode)->ip_blkno,
1258			    (unsigned long long)v_blkno);
1259		goto out;
1260	}
1261
1262	BUG_ON(p_blkno == 0);
 
 
 
 
1263
1264	for(i = 0; i < wc->w_num_pages; i++) {
1265		int tmpret;
1266
 
 
 
 
 
 
1267		tmpret = ocfs2_prepare_page_for_write(inode, &p_blkno, wc,
1268						      wc->w_pages[i], cpos,
1269						      user_pos, user_len,
1270						      should_zero);
1271		if (tmpret) {
1272			mlog_errno(tmpret);
1273			if (ret == 0)
1274				ret = tmpret;
1275		}
1276	}
1277
1278	/*
1279	 * We only have cleanup to do in case of allocating write.
1280	 */
1281	if (ret && new)
1282		ocfs2_write_failure(inode, wc, user_pos, user_len);
1283
1284out:
1285
1286	return ret;
1287}
1288
1289static int ocfs2_write_cluster_by_desc(struct address_space *mapping,
1290				       struct ocfs2_alloc_context *data_ac,
1291				       struct ocfs2_alloc_context *meta_ac,
1292				       struct ocfs2_write_ctxt *wc,
1293				       loff_t pos, unsigned len)
1294{
1295	int ret, i;
1296	loff_t cluster_off;
1297	unsigned int local_len = len;
1298	struct ocfs2_write_cluster_desc *desc;
1299	struct ocfs2_super *osb = OCFS2_SB(mapping->host->i_sb);
1300
1301	for (i = 0; i < wc->w_clen; i++) {
1302		desc = &wc->w_desc[i];
1303
1304		/*
1305		 * We have to make sure that the total write passed in
1306		 * doesn't extend past a single cluster.
1307		 */
1308		local_len = len;
1309		cluster_off = pos & (osb->s_clustersize - 1);
1310		if ((cluster_off + local_len) > osb->s_clustersize)
1311			local_len = osb->s_clustersize - cluster_off;
1312
1313		ret = ocfs2_write_cluster(mapping, desc->c_phys,
1314					  desc->c_unwritten,
 
1315					  desc->c_needs_zero,
1316					  data_ac, meta_ac,
1317					  wc, desc->c_cpos, pos, local_len);
1318		if (ret) {
1319			mlog_errno(ret);
1320			goto out;
1321		}
1322
1323		len -= local_len;
1324		pos += local_len;
1325	}
1326
1327	ret = 0;
1328out:
1329	return ret;
1330}
1331
1332/*
1333 * ocfs2_write_end() wants to know which parts of the target page it
1334 * should complete the write on. It's easiest to compute them ahead of
1335 * time when a more complete view of the write is available.
1336 */
1337static void ocfs2_set_target_boundaries(struct ocfs2_super *osb,
1338					struct ocfs2_write_ctxt *wc,
1339					loff_t pos, unsigned len, int alloc)
1340{
1341	struct ocfs2_write_cluster_desc *desc;
1342
1343	wc->w_target_from = pos & (PAGE_CACHE_SIZE - 1);
1344	wc->w_target_to = wc->w_target_from + len;
1345
1346	if (alloc == 0)
1347		return;
1348
1349	/*
1350	 * Allocating write - we may have different boundaries based
1351	 * on page size and cluster size.
1352	 *
1353	 * NOTE: We can no longer compute one value from the other as
1354	 * the actual write length and user provided length may be
1355	 * different.
1356	 */
1357
1358	if (wc->w_large_pages) {
1359		/*
1360		 * We only care about the 1st and last cluster within
1361		 * our range and whether they should be zero'd or not. Either
1362		 * value may be extended out to the start/end of a
1363		 * newly allocated cluster.
1364		 */
1365		desc = &wc->w_desc[0];
1366		if (desc->c_needs_zero)
1367			ocfs2_figure_cluster_boundaries(osb,
1368							desc->c_cpos,
1369							&wc->w_target_from,
1370							NULL);
1371
1372		desc = &wc->w_desc[wc->w_clen - 1];
1373		if (desc->c_needs_zero)
1374			ocfs2_figure_cluster_boundaries(osb,
1375							desc->c_cpos,
1376							NULL,
1377							&wc->w_target_to);
1378	} else {
1379		wc->w_target_from = 0;
1380		wc->w_target_to = PAGE_CACHE_SIZE;
1381	}
1382}
1383
1384/*
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1385 * Populate each single-cluster write descriptor in the write context
1386 * with information about the i/o to be done.
1387 *
1388 * Returns the number of clusters that will have to be allocated, as
1389 * well as a worst case estimate of the number of extent records that
1390 * would have to be created during a write to an unwritten region.
1391 */
1392static int ocfs2_populate_write_desc(struct inode *inode,
1393				     struct ocfs2_write_ctxt *wc,
1394				     unsigned int *clusters_to_alloc,
1395				     unsigned int *extents_to_split)
1396{
1397	int ret;
1398	struct ocfs2_write_cluster_desc *desc;
1399	unsigned int num_clusters = 0;
1400	unsigned int ext_flags = 0;
1401	u32 phys = 0;
1402	int i;
1403
1404	*clusters_to_alloc = 0;
1405	*extents_to_split = 0;
1406
1407	for (i = 0; i < wc->w_clen; i++) {
1408		desc = &wc->w_desc[i];
1409		desc->c_cpos = wc->w_cpos + i;
1410
1411		if (num_clusters == 0) {
1412			/*
1413			 * Need to look up the next extent record.
1414			 */
1415			ret = ocfs2_get_clusters(inode, desc->c_cpos, &phys,
1416						 &num_clusters, &ext_flags);
1417			if (ret) {
1418				mlog_errno(ret);
1419				goto out;
1420			}
1421
1422			/* We should already CoW the refcountd extent. */
1423			BUG_ON(ext_flags & OCFS2_EXT_REFCOUNTED);
1424
1425			/*
1426			 * Assume worst case - that we're writing in
1427			 * the middle of the extent.
1428			 *
1429			 * We can assume that the write proceeds from
1430			 * left to right, in which case the extent
1431			 * insert code is smart enough to coalesce the
1432			 * next splits into the previous records created.
1433			 */
1434			if (ext_flags & OCFS2_EXT_UNWRITTEN)
1435				*extents_to_split = *extents_to_split + 2;
1436		} else if (phys) {
1437			/*
1438			 * Only increment phys if it doesn't describe
1439			 * a hole.
1440			 */
1441			phys++;
1442		}
1443
1444		/*
1445		 * If w_first_new_cpos is < UINT_MAX, we have a non-sparse
1446		 * file that got extended.  w_first_new_cpos tells us
1447		 * where the newly allocated clusters are so we can
1448		 * zero them.
1449		 */
1450		if (desc->c_cpos >= wc->w_first_new_cpos) {
1451			BUG_ON(phys == 0);
1452			desc->c_needs_zero = 1;
1453		}
1454
1455		desc->c_phys = phys;
1456		if (phys == 0) {
1457			desc->c_new = 1;
1458			desc->c_needs_zero = 1;
 
1459			*clusters_to_alloc = *clusters_to_alloc + 1;
1460		}
1461
1462		if (ext_flags & OCFS2_EXT_UNWRITTEN) {
1463			desc->c_unwritten = 1;
1464			desc->c_needs_zero = 1;
1465		}
1466
 
 
 
 
 
 
1467		num_clusters--;
1468	}
1469
1470	ret = 0;
1471out:
1472	return ret;
1473}
1474
1475static int ocfs2_write_begin_inline(struct address_space *mapping,
1476				    struct inode *inode,
1477				    struct ocfs2_write_ctxt *wc)
1478{
1479	int ret;
1480	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1481	struct page *page;
1482	handle_t *handle;
1483	struct ocfs2_dinode *di = (struct ocfs2_dinode *)wc->w_di_bh->b_data;
1484
 
 
 
 
 
 
 
1485	page = find_or_create_page(mapping, 0, GFP_NOFS);
1486	if (!page) {
 
1487		ret = -ENOMEM;
1488		mlog_errno(ret);
1489		goto out;
1490	}
1491	/*
1492	 * If we don't set w_num_pages then this page won't get unlocked
1493	 * and freed on cleanup of the write context.
1494	 */
1495	wc->w_pages[0] = wc->w_target_page = page;
1496	wc->w_num_pages = 1;
1497
1498	handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
1499	if (IS_ERR(handle)) {
1500		ret = PTR_ERR(handle);
1501		mlog_errno(ret);
1502		goto out;
1503	}
1504
1505	ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), wc->w_di_bh,
1506				      OCFS2_JOURNAL_ACCESS_WRITE);
1507	if (ret) {
1508		ocfs2_commit_trans(osb, handle);
1509
1510		mlog_errno(ret);
1511		goto out;
1512	}
1513
1514	if (!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL))
1515		ocfs2_set_inode_data_inline(inode, di);
1516
1517	if (!PageUptodate(page)) {
1518		ret = ocfs2_read_inline_data(inode, page, wc->w_di_bh);
1519		if (ret) {
1520			ocfs2_commit_trans(osb, handle);
1521
1522			goto out;
1523		}
1524	}
1525
1526	wc->w_handle = handle;
1527out:
1528	return ret;
1529}
1530
1531int ocfs2_size_fits_inline_data(struct buffer_head *di_bh, u64 new_size)
1532{
1533	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
1534
1535	if (new_size <= le16_to_cpu(di->id2.i_data.id_count))
1536		return 1;
1537	return 0;
1538}
1539
1540static int ocfs2_try_to_write_inline_data(struct address_space *mapping,
1541					  struct inode *inode, loff_t pos,
1542					  unsigned len, struct page *mmap_page,
1543					  struct ocfs2_write_ctxt *wc)
1544{
1545	int ret, written = 0;
1546	loff_t end = pos + len;
1547	struct ocfs2_inode_info *oi = OCFS2_I(inode);
1548	struct ocfs2_dinode *di = NULL;
1549
1550	trace_ocfs2_try_to_write_inline_data((unsigned long long)oi->ip_blkno,
1551					     len, (unsigned long long)pos,
1552					     oi->ip_dyn_features);
1553
1554	/*
1555	 * Handle inodes which already have inline data 1st.
1556	 */
1557	if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
1558		if (mmap_page == NULL &&
1559		    ocfs2_size_fits_inline_data(wc->w_di_bh, end))
1560			goto do_inline_write;
1561
1562		/*
1563		 * The write won't fit - we have to give this inode an
1564		 * inline extent list now.
1565		 */
1566		ret = ocfs2_convert_inline_data_to_extents(inode, wc->w_di_bh);
1567		if (ret)
1568			mlog_errno(ret);
1569		goto out;
1570	}
1571
1572	/*
1573	 * Check whether the inode can accept inline data.
1574	 */
1575	if (oi->ip_clusters != 0 || i_size_read(inode) != 0)
1576		return 0;
1577
1578	/*
1579	 * Check whether the write can fit.
1580	 */
1581	di = (struct ocfs2_dinode *)wc->w_di_bh->b_data;
1582	if (mmap_page ||
1583	    end > ocfs2_max_inline_data_with_xattr(inode->i_sb, di))
1584		return 0;
1585
1586do_inline_write:
1587	ret = ocfs2_write_begin_inline(mapping, inode, wc);
1588	if (ret) {
1589		mlog_errno(ret);
1590		goto out;
1591	}
1592
1593	/*
1594	 * This signals to the caller that the data can be written
1595	 * inline.
1596	 */
1597	written = 1;
1598out:
1599	return written ? written : ret;
1600}
1601
1602/*
1603 * This function only does anything for file systems which can't
1604 * handle sparse files.
1605 *
1606 * What we want to do here is fill in any hole between the current end
1607 * of allocation and the end of our write. That way the rest of the
1608 * write path can treat it as an non-allocating write, which has no
1609 * special case code for sparse/nonsparse files.
1610 */
1611static int ocfs2_expand_nonsparse_inode(struct inode *inode,
1612					struct buffer_head *di_bh,
1613					loff_t pos, unsigned len,
1614					struct ocfs2_write_ctxt *wc)
1615{
1616	int ret;
1617	loff_t newsize = pos + len;
1618
1619	BUG_ON(ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)));
1620
1621	if (newsize <= i_size_read(inode))
1622		return 0;
1623
1624	ret = ocfs2_extend_no_holes(inode, di_bh, newsize, pos);
1625	if (ret)
1626		mlog_errno(ret);
1627
1628	wc->w_first_new_cpos =
1629		ocfs2_clusters_for_bytes(inode->i_sb, i_size_read(inode));
 
 
1630
1631	return ret;
1632}
1633
1634static int ocfs2_zero_tail(struct inode *inode, struct buffer_head *di_bh,
1635			   loff_t pos)
1636{
1637	int ret = 0;
1638
1639	BUG_ON(!ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)));
1640	if (pos > i_size_read(inode))
1641		ret = ocfs2_zero_extend(inode, di_bh, pos);
1642
1643	return ret;
1644}
1645
1646/*
1647 * Try to flush truncate logs if we can free enough clusters from it.
1648 * As for return value, "< 0" means error, "0" no space and "1" means
1649 * we have freed enough spaces and let the caller try to allocate again.
1650 */
1651static int ocfs2_try_to_free_truncate_log(struct ocfs2_super *osb,
1652					  unsigned int needed)
1653{
1654	tid_t target;
1655	int ret = 0;
1656	unsigned int truncated_clusters;
1657
1658	mutex_lock(&osb->osb_tl_inode->i_mutex);
1659	truncated_clusters = osb->truncated_clusters;
1660	mutex_unlock(&osb->osb_tl_inode->i_mutex);
1661
1662	/*
1663	 * Check whether we can succeed in allocating if we free
1664	 * the truncate log.
1665	 */
1666	if (truncated_clusters < needed)
1667		goto out;
1668
1669	ret = ocfs2_flush_truncate_log(osb);
1670	if (ret) {
1671		mlog_errno(ret);
1672		goto out;
1673	}
1674
1675	if (jbd2_journal_start_commit(osb->journal->j_journal, &target)) {
1676		jbd2_log_wait_commit(osb->journal->j_journal, target);
1677		ret = 1;
1678	}
1679out:
1680	return ret;
1681}
1682
1683int ocfs2_write_begin_nolock(struct file *filp,
1684			     struct address_space *mapping,
1685			     loff_t pos, unsigned len, unsigned flags,
1686			     struct page **pagep, void **fsdata,
1687			     struct buffer_head *di_bh, struct page *mmap_page)
1688{
1689	int ret, cluster_of_pages, credits = OCFS2_INODE_UPDATE_CREDITS;
1690	unsigned int clusters_to_alloc, extents_to_split, clusters_need = 0;
1691	struct ocfs2_write_ctxt *wc;
1692	struct inode *inode = mapping->host;
1693	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1694	struct ocfs2_dinode *di;
1695	struct ocfs2_alloc_context *data_ac = NULL;
1696	struct ocfs2_alloc_context *meta_ac = NULL;
1697	handle_t *handle;
1698	struct ocfs2_extent_tree et;
1699	int try_free = 1, ret1;
1700
1701try_again:
1702	ret = ocfs2_alloc_write_ctxt(&wc, osb, pos, len, di_bh);
1703	if (ret) {
1704		mlog_errno(ret);
1705		return ret;
1706	}
1707
1708	if (ocfs2_supports_inline_data(osb)) {
1709		ret = ocfs2_try_to_write_inline_data(mapping, inode, pos, len,
1710						     mmap_page, wc);
1711		if (ret == 1) {
1712			ret = 0;
1713			goto success;
1714		}
1715		if (ret < 0) {
1716			mlog_errno(ret);
1717			goto out;
1718		}
1719	}
1720
1721	if (ocfs2_sparse_alloc(osb))
1722		ret = ocfs2_zero_tail(inode, di_bh, pos);
1723	else
1724		ret = ocfs2_expand_nonsparse_inode(inode, di_bh, pos, len,
1725						   wc);
1726	if (ret) {
1727		mlog_errno(ret);
1728		goto out;
 
 
 
1729	}
1730
1731	ret = ocfs2_check_range_for_refcount(inode, pos, len);
1732	if (ret < 0) {
1733		mlog_errno(ret);
1734		goto out;
1735	} else if (ret == 1) {
1736		clusters_need = wc->w_clen;
1737		ret = ocfs2_refcount_cow(inode, di_bh,
1738					 wc->w_cpos, wc->w_clen, UINT_MAX);
1739		if (ret) {
1740			mlog_errno(ret);
1741			goto out;
1742		}
1743	}
1744
1745	ret = ocfs2_populate_write_desc(inode, wc, &clusters_to_alloc,
1746					&extents_to_split);
1747	if (ret) {
1748		mlog_errno(ret);
1749		goto out;
1750	}
1751	clusters_need += clusters_to_alloc;
1752
1753	di = (struct ocfs2_dinode *)wc->w_di_bh->b_data;
1754
1755	trace_ocfs2_write_begin_nolock(
1756			(unsigned long long)OCFS2_I(inode)->ip_blkno,
1757			(long long)i_size_read(inode),
1758			le32_to_cpu(di->i_clusters),
1759			pos, len, flags, mmap_page,
1760			clusters_to_alloc, extents_to_split);
1761
1762	/*
1763	 * We set w_target_from, w_target_to here so that
1764	 * ocfs2_write_end() knows which range in the target page to
1765	 * write out. An allocation requires that we write the entire
1766	 * cluster range.
1767	 */
1768	if (clusters_to_alloc || extents_to_split) {
1769		/*
1770		 * XXX: We are stretching the limits of
1771		 * ocfs2_lock_allocators(). It greatly over-estimates
1772		 * the work to be done.
1773		 */
1774		ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(inode),
1775					      wc->w_di_bh);
1776		ret = ocfs2_lock_allocators(inode, &et,
1777					    clusters_to_alloc, extents_to_split,
1778					    &data_ac, &meta_ac);
1779		if (ret) {
1780			mlog_errno(ret);
1781			goto out;
1782		}
1783
1784		if (data_ac)
1785			data_ac->ac_resv = &OCFS2_I(inode)->ip_la_data_resv;
1786
1787		credits = ocfs2_calc_extend_credits(inode->i_sb,
1788						    &di->id2.i_list);
1789
1790	}
 
1791
1792	/*
1793	 * We have to zero sparse allocated clusters, unwritten extent clusters,
1794	 * and non-sparse clusters we just extended.  For non-sparse writes,
1795	 * we know zeros will only be needed in the first and/or last cluster.
1796	 */
1797	if (clusters_to_alloc || extents_to_split ||
1798	    (wc->w_clen && (wc->w_desc[0].c_needs_zero ||
1799			    wc->w_desc[wc->w_clen - 1].c_needs_zero)))
1800		cluster_of_pages = 1;
1801	else
1802		cluster_of_pages = 0;
1803
1804	ocfs2_set_target_boundaries(osb, wc, pos, len, cluster_of_pages);
1805
1806	handle = ocfs2_start_trans(osb, credits);
1807	if (IS_ERR(handle)) {
1808		ret = PTR_ERR(handle);
1809		mlog_errno(ret);
1810		goto out;
1811	}
1812
1813	wc->w_handle = handle;
1814
1815	if (clusters_to_alloc) {
1816		ret = dquot_alloc_space_nodirty(inode,
1817			ocfs2_clusters_to_bytes(osb->sb, clusters_to_alloc));
1818		if (ret)
1819			goto out_commit;
1820	}
1821	/*
1822	 * We don't want this to fail in ocfs2_write_end(), so do it
1823	 * here.
1824	 */
1825	ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), wc->w_di_bh,
1826				      OCFS2_JOURNAL_ACCESS_WRITE);
1827	if (ret) {
1828		mlog_errno(ret);
1829		goto out_quota;
1830	}
1831
1832	/*
1833	 * Fill our page array first. That way we've grabbed enough so
1834	 * that we can zero and flush if we error after adding the
1835	 * extent.
1836	 */
1837	ret = ocfs2_grab_pages_for_write(mapping, wc, wc->w_cpos, pos, len,
1838					 cluster_of_pages, mmap_page);
1839	if (ret && ret != -EAGAIN) {
1840		mlog_errno(ret);
1841		goto out_quota;
1842	}
 
 
 
 
 
 
 
 
1843
1844	/*
1845	 * ocfs2_grab_pages_for_write() returns -EAGAIN if it could not lock
1846	 * the target page. In this case, we exit with no error and no target
1847	 * page. This will trigger the caller, page_mkwrite(), to re-try
1848	 * the operation.
1849	 */
1850	if (ret == -EAGAIN) {
1851		BUG_ON(wc->w_target_page);
1852		ret = 0;
1853		goto out_quota;
1854	}
1855
1856	ret = ocfs2_write_cluster_by_desc(mapping, data_ac, meta_ac, wc, pos,
1857					  len);
1858	if (ret) {
1859		mlog_errno(ret);
1860		goto out_quota;
1861	}
1862
1863	if (data_ac)
1864		ocfs2_free_alloc_context(data_ac);
1865	if (meta_ac)
1866		ocfs2_free_alloc_context(meta_ac);
1867
1868success:
1869	*pagep = wc->w_target_page;
 
1870	*fsdata = wc;
1871	return 0;
1872out_quota:
1873	if (clusters_to_alloc)
1874		dquot_free_space(inode,
1875			  ocfs2_clusters_to_bytes(osb->sb, clusters_to_alloc));
1876out_commit:
1877	ocfs2_commit_trans(osb, handle);
1878
1879out:
1880	ocfs2_free_write_ctxt(wc);
 
 
 
 
 
 
 
 
 
 
1881
1882	if (data_ac) {
1883		ocfs2_free_alloc_context(data_ac);
1884		data_ac = NULL;
1885	}
1886	if (meta_ac) {
1887		ocfs2_free_alloc_context(meta_ac);
1888		meta_ac = NULL;
1889	}
1890
1891	if (ret == -ENOSPC && try_free) {
1892		/*
1893		 * Try to free some truncate log so that we can have enough
1894		 * clusters to allocate.
1895		 */
1896		try_free = 0;
1897
1898		ret1 = ocfs2_try_to_free_truncate_log(osb, clusters_need);
1899		if (ret1 == 1)
1900			goto try_again;
1901
1902		if (ret1 < 0)
1903			mlog_errno(ret1);
1904	}
1905
1906	return ret;
1907}
1908
1909static int ocfs2_write_begin(struct file *file, struct address_space *mapping,
1910			     loff_t pos, unsigned len, unsigned flags,
1911			     struct page **pagep, void **fsdata)
1912{
1913	int ret;
1914	struct buffer_head *di_bh = NULL;
1915	struct inode *inode = mapping->host;
1916
1917	ret = ocfs2_inode_lock(inode, &di_bh, 1);
1918	if (ret) {
1919		mlog_errno(ret);
1920		return ret;
1921	}
1922
1923	/*
1924	 * Take alloc sem here to prevent concurrent lookups. That way
1925	 * the mapping, zeroing and tree manipulation within
1926	 * ocfs2_write() will be safe against ->readpage(). This
1927	 * should also serve to lock out allocation from a shared
1928	 * writeable region.
1929	 */
1930	down_write(&OCFS2_I(inode)->ip_alloc_sem);
1931
1932	ret = ocfs2_write_begin_nolock(file, mapping, pos, len, flags, pagep,
1933				       fsdata, di_bh, NULL);
1934	if (ret) {
1935		mlog_errno(ret);
1936		goto out_fail;
1937	}
1938
1939	brelse(di_bh);
1940
1941	return 0;
1942
1943out_fail:
1944	up_write(&OCFS2_I(inode)->ip_alloc_sem);
1945
1946	brelse(di_bh);
1947	ocfs2_inode_unlock(inode, 1);
1948
1949	return ret;
1950}
1951
1952static void ocfs2_write_end_inline(struct inode *inode, loff_t pos,
1953				   unsigned len, unsigned *copied,
1954				   struct ocfs2_dinode *di,
1955				   struct ocfs2_write_ctxt *wc)
1956{
1957	void *kaddr;
1958
1959	if (unlikely(*copied < len)) {
1960		if (!PageUptodate(wc->w_target_page)) {
1961			*copied = 0;
1962			return;
1963		}
1964	}
1965
1966	kaddr = kmap_atomic(wc->w_target_page);
1967	memcpy(di->id2.i_data.id_data + pos, kaddr + pos, *copied);
1968	kunmap_atomic(kaddr);
1969
1970	trace_ocfs2_write_end_inline(
1971	     (unsigned long long)OCFS2_I(inode)->ip_blkno,
1972	     (unsigned long long)pos, *copied,
1973	     le16_to_cpu(di->id2.i_data.id_count),
1974	     le16_to_cpu(di->i_dyn_features));
1975}
1976
1977int ocfs2_write_end_nolock(struct address_space *mapping,
1978			   loff_t pos, unsigned len, unsigned copied,
1979			   struct page *page, void *fsdata)
1980{
1981	int i;
1982	unsigned from, to, start = pos & (PAGE_CACHE_SIZE - 1);
1983	struct inode *inode = mapping->host;
1984	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1985	struct ocfs2_write_ctxt *wc = fsdata;
1986	struct ocfs2_dinode *di = (struct ocfs2_dinode *)wc->w_di_bh->b_data;
1987	handle_t *handle = wc->w_handle;
1988	struct page *tmppage;
1989
 
 
 
 
 
 
 
 
 
 
 
 
1990	if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
1991		ocfs2_write_end_inline(inode, pos, len, &copied, di, wc);
1992		goto out_write_size;
1993	}
1994
1995	if (unlikely(copied < len)) {
 
 
1996		if (!PageUptodate(wc->w_target_page))
1997			copied = 0;
1998
1999		ocfs2_zero_new_buffers(wc->w_target_page, start+copied,
2000				       start+len);
 
 
 
 
 
 
 
 
 
 
 
 
 
2001	}
2002	flush_dcache_page(wc->w_target_page);
 
2003
2004	for(i = 0; i < wc->w_num_pages; i++) {
2005		tmppage = wc->w_pages[i];
2006
 
 
 
 
2007		if (tmppage == wc->w_target_page) {
2008			from = wc->w_target_from;
2009			to = wc->w_target_to;
2010
2011			BUG_ON(from > PAGE_CACHE_SIZE ||
2012			       to > PAGE_CACHE_SIZE ||
2013			       to < from);
2014		} else {
2015			/*
2016			 * Pages adjacent to the target (if any) imply
2017			 * a hole-filling write in which case we want
2018			 * to flush their entire range.
2019			 */
2020			from = 0;
2021			to = PAGE_CACHE_SIZE;
2022		}
2023
2024		if (page_has_buffers(tmppage)) {
2025			if (ocfs2_should_order_data(inode))
2026				ocfs2_jbd2_file_inode(wc->w_handle, inode);
 
 
 
 
 
 
2027			block_commit_write(tmppage, from, to);
2028		}
2029	}
2030
2031out_write_size:
2032	pos += copied;
2033	if (pos > i_size_read(inode)) {
2034		i_size_write(inode, pos);
2035		mark_inode_dirty(inode);
2036	}
2037	inode->i_blocks = ocfs2_inode_sector_count(inode);
2038	di->i_size = cpu_to_le64((u64)i_size_read(inode));
2039	inode->i_mtime = inode->i_ctime = CURRENT_TIME;
2040	di->i_mtime = di->i_ctime = cpu_to_le64(inode->i_mtime.tv_sec);
2041	di->i_mtime_nsec = di->i_ctime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
2042	ocfs2_update_inode_fsync_trans(handle, inode, 1);
2043	ocfs2_journal_dirty(handle, wc->w_di_bh);
 
 
 
 
 
2044
2045	ocfs2_commit_trans(osb, handle);
 
 
 
 
 
 
 
 
 
2046
2047	ocfs2_run_deallocs(osb, &wc->w_dealloc);
2048
2049	ocfs2_free_write_ctxt(wc);
 
2050
2051	return copied;
2052}
2053
2054static int ocfs2_write_end(struct file *file, struct address_space *mapping,
2055			   loff_t pos, unsigned len, unsigned copied,
2056			   struct page *page, void *fsdata)
2057{
2058	int ret;
2059	struct inode *inode = mapping->host;
2060
2061	ret = ocfs2_write_end_nolock(mapping, pos, len, copied, page, fsdata);
2062
2063	up_write(&OCFS2_I(inode)->ip_alloc_sem);
2064	ocfs2_inode_unlock(inode, 1);
2065
2066	return ret;
2067}
2068
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2069const struct address_space_operations ocfs2_aops = {
2070	.readpage		= ocfs2_readpage,
2071	.readpages		= ocfs2_readpages,
2072	.writepage		= ocfs2_writepage,
 
2073	.write_begin		= ocfs2_write_begin,
2074	.write_end		= ocfs2_write_end,
2075	.bmap			= ocfs2_bmap,
2076	.direct_IO		= ocfs2_direct_IO,
2077	.invalidatepage		= block_invalidatepage,
2078	.releasepage		= ocfs2_releasepage,
2079	.migratepage		= buffer_migrate_page,
2080	.is_partially_uptodate	= block_is_partially_uptodate,
2081	.error_remove_page	= generic_error_remove_page,
2082};