fs/ocfs2/aops.c

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

DEFINITIONS
