SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/ocfs2/file.c

   1 /* -*- mode: c; c-basic-offset: 8; -*-
   2  * vim: noexpandtab sw=8 ts=8 sts=0:
   3  *
   4  * file.c
   5  *
   6  * File open, close, extend, truncate
   7  *
   8  * Copyright (C) 2002, 2004 Oracle.  All rights reserved.
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2 of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public
  21  * License along with this program; if not, write to the
  22  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  23  * Boston, MA 021110-1307, USA.
  24  */
  25
  26 #include <linux/capability.h>
  27 #include <linux/fs.h>
  28 #include <linux/types.h>
  29 #include <linux/slab.h>
  30 #include <linux/highmem.h>
  31 #include <linux/pagemap.h>
  32 #include <linux/uio.h>
  33 #include <linux/sched.h>
  34 #include <linux/splice.h>
  35 #include <linux/mount.h>
  36 #include <linux/writeback.h>
  37 #include <linux/falloc.h>
  38
  39 #define MLOG_MASK_PREFIX ML_INODE
  40 #include <cluster/masklog.h>
  41
  42 #include "ocfs2.h"
  43
  44 #include "alloc.h"
  45 #include "aops.h"
  46 #include "dir.h"
  47 #include "dlmglue.h"
  48 #include "extent_map.h"
  49 #include "file.h"
  50 #include "sysfile.h"
  51 #include "inode.h"
  52 #include "ioctl.h"
  53 #include "journal.h"
  54 #include "locks.h"
  55 #include "mmap.h"
  56 #include "suballoc.h"
  57 #include "super.h"
  58 #include "xattr.h"
  59 #include "acl.h"
  60
  61 #include "buffer_head_io.h"
  62
  63 static int ocfs2_sync_inode(struct inode *inode)
  64 {
  65         filemap_fdatawrite(inode->i_mapping);
  66         return sync_mapping_buffers(inode->i_mapping);
  67 }
  68
  69 static int ocfs2_init_file_private(struct inode *inode, struct file *file)
  70 {
  71         struct ocfs2_file_private *fp;
  72
  73         fp = kzalloc(sizeof(struct ocfs2_file_private), GFP_KERNEL);
  74         if (!fp)
  75                 return -ENOMEM;
  76
  77         fp->fp_file = file;
  78         mutex_init(&fp->fp_mutex);
  79         ocfs2_file_lock_res_init(&fp->fp_flock, fp);
  80         file->private_data = fp;
  81
  82         return 0;
  83 }
  84
  85 static void ocfs2_free_file_private(struct inode *inode, struct file *file)
  86 {
  87         struct ocfs2_file_private *fp = file->private_data;
  88         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
  89
  90         if (fp) {
  91                 ocfs2_simple_drop_lockres(osb, &fp->fp_flock);
  92                 ocfs2_lock_res_free(&fp->fp_flock);
  93                 kfree(fp);
  94                 file->private_data = NULL;
  95         }
  96 }
  97
  98 static int ocfs2_file_open(struct inode *inode, struct file *file)
  99 {
 100         int status;
 101         int mode = file->f_flags;
 102         struct ocfs2_inode_info *oi = OCFS2_I(inode);
 103
 104         mlog_entry("(0x%p, 0x%p, '%.*s')\n", inode, file,
 105                    file->f_path.dentry->d_name.len, file->f_path.dentry->d_name.name);
 106
 107         spin_lock(&oi->ip_lock);
 108
 109         /* Check that the inode hasn't been wiped from disk by another
 110          * node. If it hasn't then we're safe as long as we hold the
 111          * spin lock until our increment of open count. */
 112         if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_DELETED) {
 113                 spin_unlock(&oi->ip_lock);
 114
 115                 status = -ENOENT;
 116                 goto leave;
 117         }
 118
 119         if (mode & O_DIRECT)
 120                 oi->ip_flags |= OCFS2_INODE_OPEN_DIRECT;
 121
 122         oi->ip_open_count++;
 123         spin_unlock(&oi->ip_lock);
 124
 125         status = ocfs2_init_file_private(inode, file);
 126         if (status) {
 127                 /*
 128                  * We want to set open count back if we're failing the
 129                  * open.
 130                  */
 131                 spin_lock(&oi->ip_lock);
 132                 oi->ip_open_count--;
 133                 spin_unlock(&oi->ip_lock);
 134         }
 135
 136 leave:
 137         mlog_exit(status);
 138         return status;
 139 }
 140
 141 static int ocfs2_file_release(struct inode *inode, struct file *file)
 142 {
 143         struct ocfs2_inode_info *oi = OCFS2_I(inode);
 144
 145         mlog_entry("(0x%p, 0x%p, '%.*s')\n", inode, file,
 146                        file->f_path.dentry->d_name.len,
 147                        file->f_path.dentry->d_name.name);
 148
 149         spin_lock(&oi->ip_lock);
 150         if (!--oi->ip_open_count)
 151                 oi->ip_flags &= ~OCFS2_INODE_OPEN_DIRECT;
 152         spin_unlock(&oi->ip_lock);
 153
 154         ocfs2_free_file_private(inode, file);
 155
 156         mlog_exit(0);
 157
 158         return 0;
 159 }
 160
 161 static int ocfs2_dir_open(struct inode *inode, struct file *file)
 162 {
 163         return ocfs2_init_file_private(inode, file);
 164 }
 165
 166 static int ocfs2_dir_release(struct inode *inode, struct file *file)
 167 {
 168         ocfs2_free_file_private(inode, file);
 169         return 0;
 170 }
 171
 172 static int ocfs2_sync_file(struct file *file,
 173                            struct dentry *dentry,
 174                            int datasync)
 175 {
 176         int err = 0;
 177         journal_t *journal;
 178         struct inode *inode = dentry->d_inode;
 179         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
 180
 181         mlog_entry("(0x%p, 0x%p, %d, '%.*s')\n", file, dentry, datasync,
 182                    dentry->d_name.len, dentry->d_name.name);
 183
 184         err = ocfs2_sync_inode(dentry->d_inode);
 185         if (err)
 186                 goto bail;
 187
 188         journal = osb->journal->j_journal;
 189         err = jbd2_journal_force_commit(journal);
 190
 191 bail:
 192         mlog_exit(err);
 193
 194         return (err < 0) ? -EIO : 0;
 195 }
 196
 197 int ocfs2_should_update_atime(struct inode *inode,
 198                               struct vfsmount *vfsmnt)
 199 {
 200         struct timespec now;
 201         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
 202
 203         if (ocfs2_is_hard_readonly(osb) || ocfs2_is_soft_readonly(osb))
 204                 return 0;
 205
 206         if ((inode->i_flags & S_NOATIME) ||
 207             ((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode)))
 208                 return 0;
 209
 210         /*
 211          * We can be called with no vfsmnt structure - NFSD will
 212          * sometimes do this.
 213          *
 214          * Note that our action here is different than touch_atime() -
 215          * if we can't tell whether this is a noatime mount, then we
 216          * don't know whether to trust the value of s_atime_quantum.
 217          */
 218         if (vfsmnt == NULL)
 219                 return 0;
 220
 221         if ((vfsmnt->mnt_flags & MNT_NOATIME) ||
 222             ((vfsmnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
 223                 return 0;
 224
 225         if (vfsmnt->mnt_flags & MNT_RELATIME) {
 226                 if ((timespec_compare(&inode->i_atime, &inode->i_mtime) <= 0) ||
 227                     (timespec_compare(&inode->i_atime, &inode->i_ctime) <= 0))
 228                         return 1;
 229
 230                 return 0;
 231         }
 232
 233         now = CURRENT_TIME;
 234         if ((now.tv_sec - inode->i_atime.tv_sec <= osb->s_atime_quantum))
 235                 return 0;
 236         else
 237                 return 1;
 238 }
 239
 240 int ocfs2_update_inode_atime(struct inode *inode,
 241                              struct buffer_head *bh)
 242 {
 243         int ret;
 244         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
 245         handle_t *handle;
 246         struct ocfs2_dinode *di = (struct ocfs2_dinode *) bh->b_data;
 247
 248         mlog_entry_void();
 249
 250         handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
 251         if (IS_ERR(handle)) {
 252                 ret = PTR_ERR(handle);
 253                 mlog_errno(ret);
 254                 goto out;
 255         }
 256
 257         ret = ocfs2_journal_access(handle, inode, bh,
 258                                    OCFS2_JOURNAL_ACCESS_WRITE);
 259         if (ret) {
 260                 mlog_errno(ret);
 261                 goto out_commit;
 262         }
 263
 264         /*
 265          * Don't use ocfs2_mark_inode_dirty() here as we don't always
 266          * have i_mutex to guard against concurrent changes to other
 267          * inode fields.
 268          */
 269         inode->i_atime = CURRENT_TIME;
 270         di->i_atime = cpu_to_le64(inode->i_atime.tv_sec);
 271         di->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);
 272
 273         ret = ocfs2_journal_dirty(handle, bh);
 274         if (ret < 0)
 275                 mlog_errno(ret);
 276
 277 out_commit:
 278         ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
 279 out:
 280         mlog_exit(ret);
 281         return ret;
 282 }
 283
 284 static int ocfs2_set_inode_size(handle_t *handle,
 285                                 struct inode *inode,
 286                                 struct buffer_head *fe_bh,
 287                                 u64 new_i_size)
 288 {
 289         int status;
 290
 291         mlog_entry_void();
 292         i_size_write(inode, new_i_size);
 293         inode->i_blocks = ocfs2_inode_sector_count(inode);
 294         inode->i_ctime = inode->i_mtime = CURRENT_TIME;
 295
 296         status = ocfs2_mark_inode_dirty(handle, inode, fe_bh);
 297         if (status < 0) {
 298                 mlog_errno(status);
 299                 goto bail;
 300         }
 301
 302 bail:
 303         mlog_exit(status);
 304         return status;
 305 }
 306
 307 static int ocfs2_simple_size_update(struct inode *inode,
 308                                     struct buffer_head *di_bh,
 309                                     u64 new_i_size)
 310 {
 311         int ret;
 312         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
 313         handle_t *handle = NULL;
 314
 315         handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
 316         if (IS_ERR(handle)) {
 317                 ret = PTR_ERR(handle);
 318                 mlog_errno(ret);
 319                 goto out;
 320         }
 321
 322         ret = ocfs2_set_inode_size(handle, inode, di_bh,
 323                                    new_i_size);
 324         if (ret < 0)
 325                 mlog_errno(ret);
 326
 327         ocfs2_commit_trans(osb, handle);
 328 out:
 329         return ret;
 330 }
 331
 332 static int ocfs2_orphan_for_truncate(struct ocfs2_super *osb,
 333                                      struct inode *inode,
 334                                      struct buffer_head *fe_bh,
 335                                      u64 new_i_size)
 336 {
 337         int status;
 338         handle_t *handle;
 339         struct ocfs2_dinode *di;
 340         u64 cluster_bytes;
 341
 342         mlog_entry_void();
 343
 344         /* TODO: This needs to actually orphan the inode in this
 345          * transaction. */
 346
 347         handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
 348         if (IS_ERR(handle)) {
 349                 status = PTR_ERR(handle);
 350                 mlog_errno(status);
 351                 goto out;
 352         }
 353
 354         status = ocfs2_journal_access(handle, inode, fe_bh,
 355                                       OCFS2_JOURNAL_ACCESS_WRITE);
 356         if (status < 0) {
 357                 mlog_errno(status);
 358                 goto out_commit;
 359         }
 360
 361         /*
 362          * Do this before setting i_size.
 363          */
 364         cluster_bytes = ocfs2_align_bytes_to_clusters(inode->i_sb, new_i_size);
 365         status = ocfs2_zero_range_for_truncate(inode, handle, new_i_size,
 366                                                cluster_bytes);
 367         if (status) {
 368                 mlog_errno(status);
 369                 goto out_commit;
 370         }
 371
 372         i_size_write(inode, new_i_size);
 373         inode->i_ctime = inode->i_mtime = CURRENT_TIME;
 374
 375         di = (struct ocfs2_dinode *) fe_bh->b_data;
 376         di->i_size = cpu_to_le64(new_i_size);
 377         di->i_ctime = di->i_mtime = cpu_to_le64(inode->i_ctime.tv_sec);
 378         di->i_ctime_nsec = di->i_mtime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
 379
 380         status = ocfs2_journal_dirty(handle, fe_bh);
 381         if (status < 0)
 382                 mlog_errno(status);
 383
 384 out_commit:
 385         ocfs2_commit_trans(osb, handle);
 386 out:
 387
 388         mlog_exit(status);
 389         return status;
 390 }
 391
 392 static int ocfs2_truncate_file(struct inode *inode,
 393                                struct buffer_head *di_bh,
 394                                u64 new_i_size)
 395 {
 396         int status = 0;
 397         struct ocfs2_dinode *fe = NULL;
 398         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
 399         struct ocfs2_truncate_context *tc = NULL;
 400
 401         mlog_entry("(inode = %llu, new_i_size = %llu\n",
 402                    (unsigned long long)OCFS2_I(inode)->ip_blkno,
 403                    (unsigned long long)new_i_size);
 404
 405         /* We trust di_bh because it comes from ocfs2_inode_lock(), which
 406          * already validated it */
 407         fe = (struct ocfs2_dinode *) di_bh->b_data;
 408
 409         mlog_bug_on_msg(le64_to_cpu(fe->i_size) != i_size_read(inode),
 410                         "Inode %llu, inode i_size = %lld != di "
 411                         "i_size = %llu, i_flags = 0x%x\n",
 412                         (unsigned long long)OCFS2_I(inode)->ip_blkno,
 413                         i_size_read(inode),
 414                         (unsigned long long)le64_to_cpu(fe->i_size),
 415                         le32_to_cpu(fe->i_flags));
 416
 417         if (new_i_size > le64_to_cpu(fe->i_size)) {
 418                 mlog(0, "asked to truncate file with size (%llu) to size (%llu)!\n",
 419                      (unsigned long long)le64_to_cpu(fe->i_size),
 420                      (unsigned long long)new_i_size);
 421                 status = -EINVAL;
 422                 mlog_errno(status);
 423                 goto bail;
 424         }
 425
 426         mlog(0, "inode %llu, i_size = %llu, new_i_size = %llu\n",
 427              (unsigned long long)le64_to_cpu(fe->i_blkno),
 428              (unsigned long long)le64_to_cpu(fe->i_size),
 429              (unsigned long long)new_i_size);
 430
 431         /* lets handle the simple truncate cases before doing any more
 432          * cluster locking. */
 433         if (new_i_size == le64_to_cpu(fe->i_size))
 434                 goto bail;
 435
 436         down_write(&OCFS2_I(inode)->ip_alloc_sem);
 437
 438         /*
 439          * The inode lock forced other nodes to sync and drop their
 440          * pages, which (correctly) happens even if we have a truncate
 441          * without allocation change - ocfs2 cluster sizes can be much
 442          * greater than page size, so we have to truncate them
 443          * anyway.
 444          */
 445         unmap_mapping_range(inode->i_mapping, new_i_size + PAGE_SIZE - 1, 0, 1);
 446         truncate_inode_pages(inode->i_mapping, new_i_size);
 447
 448         if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
 449                 status = ocfs2_truncate_inline(inode, di_bh, new_i_size,
 450                                                i_size_read(inode), 1);
 451                 if (status)
 452                         mlog_errno(status);
 453
 454                 goto bail_unlock_sem;
 455         }
 456
 457         /* alright, we're going to need to do a full blown alloc size
 458          * change. Orphan the inode so that recovery can complete the
 459          * truncate if necessary. This does the task of marking
 460          * i_size. */
 461         status = ocfs2_orphan_for_truncate(osb, inode, di_bh, new_i_size);
 462         if (status < 0) {
 463                 mlog_errno(status);
 464                 goto bail_unlock_sem;
 465         }
 466
 467         status = ocfs2_prepare_truncate(osb, inode, di_bh, &tc);
 468         if (status < 0) {
 469                 mlog_errno(status);
 470                 goto bail_unlock_sem;
 471         }
 472
 473         status = ocfs2_commit_truncate(osb, inode, di_bh, tc);
 474         if (status < 0) {
 475                 mlog_errno(status);
 476                 goto bail_unlock_sem;
 477         }
 478
 479         /* TODO: orphan dir cleanup here. */
 480 bail_unlock_sem:
 481         up_write(&OCFS2_I(inode)->ip_alloc_sem);
 482
 483 bail:
 484
 485         mlog_exit(status);
 486         return status;
 487 }
 488
 489 /*
 490  * extend file allocation only here.
 491  * we'll update all the disk stuff, and oip->alloc_size
 492  *
 493  * expect stuff to be locked, a transaction started and enough data /
 494  * metadata reservations in the contexts.
 495  *
 496  * Will return -EAGAIN, and a reason if a restart is needed.
 497  * If passed in, *reason will always be set, even in error.
 498  */
 499 int ocfs2_add_inode_data(struct ocfs2_super *osb,
 500                          struct inode *inode,
 501                          u32 *logical_offset,
 502                          u32 clusters_to_add,
 503                          int mark_unwritten,
 504                          struct buffer_head *fe_bh,
 505                          handle_t *handle,
 506                          struct ocfs2_alloc_context *data_ac,
 507                          struct ocfs2_alloc_context *meta_ac,
 508                          enum ocfs2_alloc_restarted *reason_ret)
 509 {
 510         int ret;
 511         struct ocfs2_extent_tree et;
 512
 513         ocfs2_init_dinode_extent_tree(&et, inode, fe_bh);
 514         ret = ocfs2_add_clusters_in_btree(osb, inode, logical_offset,
 515                                            clusters_to_add, mark_unwritten,
 516                                            &et, handle,
 517                                            data_ac, meta_ac, reason_ret);
 518
 519         return ret;
 520 }
 521
 522 static int __ocfs2_extend_allocation(struct inode *inode, u32 logical_start,
 523                                      u32 clusters_to_add, int mark_unwritten)
 524 {
 525         int status = 0;
 526         int restart_func = 0;
 527         int credits;
 528         u32 prev_clusters;
 529         struct buffer_head *bh = NULL;
 530         struct ocfs2_dinode *fe = NULL;
 531         handle_t *handle = NULL;
 532         struct ocfs2_alloc_context *data_ac = NULL;
 533         struct ocfs2_alloc_context *meta_ac = NULL;
 534         enum ocfs2_alloc_restarted why;
 535         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
 536         struct ocfs2_extent_tree et;
 537
 538         mlog_entry("(clusters_to_add = %u)\n", clusters_to_add);
 539
 540         /*
 541          * This function only exists for file systems which don't
 542          * support holes.
 543          */
 544         BUG_ON(mark_unwritten && !ocfs2_sparse_alloc(osb));
 545
 546         status = ocfs2_read_inode_block(inode, &bh);
 547         if (status < 0) {
 548                 mlog_errno(status);
 549                 goto leave;
 550         }
 551         fe = (struct ocfs2_dinode *) bh->b_data;
 552
 553 restart_all:
 554         BUG_ON(le32_to_cpu(fe->i_clusters) != OCFS2_I(inode)->ip_clusters);
 555
 556         mlog(0, "extend inode %llu, i_size = %lld, di->i_clusters = %u, "
 557              "clusters_to_add = %u\n",
 558              (unsigned long long)OCFS2_I(inode)->ip_blkno,
 559              (long long)i_size_read(inode), le32_to_cpu(fe->i_clusters),
 560              clusters_to_add);
 561         ocfs2_init_dinode_extent_tree(&et, inode, bh);
 562         status = ocfs2_lock_allocators(inode, &et, clusters_to_add, 0,
 563                                        &data_ac, &meta_ac);
 564         if (status) {
 565                 mlog_errno(status);
 566                 goto leave;
 567         }
 568
 569         credits = ocfs2_calc_extend_credits(osb->sb, &fe->id2.i_list,
 570                                             clusters_to_add);
 571         handle = ocfs2_start_trans(osb, credits);
 572         if (IS_ERR(handle)) {
 573                 status = PTR_ERR(handle);
 574                 handle = NULL;
 575                 mlog_errno(status);
 576                 goto leave;
 577         }
 578
 579 restarted_transaction:
 580         /* reserve a write to the file entry early on - that we if we
 581          * run out of credits in the allocation path, we can still
 582          * update i_size. */
 583         status = ocfs2_journal_access(handle, inode, bh,
 584                                       OCFS2_JOURNAL_ACCESS_WRITE);
 585         if (status < 0) {
 586                 mlog_errno(status);
 587                 goto leave;
 588         }
 589
 590         prev_clusters = OCFS2_I(inode)->ip_clusters;
 591
 592         status = ocfs2_add_inode_data(osb,
 593                                       inode,
 594                                       &logical_start,
 595                                       clusters_to_add,
 596                                       mark_unwritten,
 597                                       bh,
 598                                       handle,
 599                                       data_ac,
 600                                       meta_ac,
 601                                       &why);
 602         if ((status < 0) && (status != -EAGAIN)) {
 603                 if (status != -ENOSPC)
 604                         mlog_errno(status);
 605                 goto leave;
 606         }
 607
 608         status = ocfs2_journal_dirty(handle, bh);
 609         if (status < 0) {
 610                 mlog_errno(status);
 611                 goto leave;
 612         }
 613
 614         spin_lock(&OCFS2_I(inode)->ip_lock);
 615         clusters_to_add -= (OCFS2_I(inode)->ip_clusters - prev_clusters);
 616         spin_unlock(&OCFS2_I(inode)->ip_lock);
 617
 618         if (why != RESTART_NONE && clusters_to_add) {
 619                 if (why == RESTART_META) {
 620                         mlog(0, "restarting function.\n");
 621                         restart_func = 1;
 622                 } else {
 623                         BUG_ON(why != RESTART_TRANS);
 624
 625                         mlog(0, "restarting transaction.\n");
 626                         /* TODO: This can be more intelligent. */
 627                         credits = ocfs2_calc_extend_credits(osb->sb,
 628                                                             &fe->id2.i_list,
 629                                                             clusters_to_add);
 630                         status = ocfs2_extend_trans(handle, credits);
 631                         if (status < 0) {
 632                                 /* handle still has to be committed at
 633                                  * this point. */
 634                                 status = -ENOMEM;
 635                                 mlog_errno(status);
 636                                 goto leave;
 637                         }
 638                         goto restarted_transaction;
 639                 }
 640         }
 641
 642         mlog(0, "fe: i_clusters = %u, i_size=%llu\n",
 643              le32_to_cpu(fe->i_clusters),
 644              (unsigned long long)le64_to_cpu(fe->i_size));
 645         mlog(0, "inode: ip_clusters=%u, i_size=%lld\n",
 646              OCFS2_I(inode)->ip_clusters, (long long)i_size_read(inode));
 647
 648 leave:
 649         if (handle) {
 650                 ocfs2_commit_trans(osb, handle);
 651                 handle = NULL;
 652         }
 653         if (data_ac) {
 654                 ocfs2_free_alloc_context(data_ac);
 655                 data_ac = NULL;
 656         }
 657         if (meta_ac) {
 658                 ocfs2_free_alloc_context(meta_ac);
 659                 meta_ac = NULL;
 660         }
 661         if ((!status) && restart_func) {
 662                 restart_func = 0;
 663                 goto restart_all;
 664         }
 665         brelse(bh);
 666         bh = NULL;
 667
 668         mlog_exit(status);
 669         return status;
 670 }
 671
 672 /* Some parts of this taken from generic_cont_expand, which turned out
 673  * to be too fragile to do exactly what we need without us having to
 674  * worry about recursive locking in ->write_begin() and ->write_end(). */
 675 static int ocfs2_write_zero_page(struct inode *inode,
 676                                  u64 size)
 677 {
 678         struct address_space *mapping = inode->i_mapping;
 679         struct page *page;
 680         unsigned long index;
 681         unsigned int offset;
 682         handle_t *handle = NULL;
 683         int ret;
 684
 685         offset = (size & (PAGE_CACHE_SIZE-1)); /* Within page */
 686         /* ugh.  in prepare/commit_write, if from==to==start of block, we
 687         ** skip the prepare.  make sure we never send an offset for the start
 688         ** of a block
 689         */
 690         if ((offset & (inode->i_sb->s_blocksize - 1)) == 0) {
 691                 offset++;
 692         }
 693         index = size >> PAGE_CACHE_SHIFT;
 694
 695         page = grab_cache_page(mapping, index);
 696         if (!page) {
 697                 ret = -ENOMEM;
 698                 mlog_errno(ret);
 699                 goto out;
 700         }
 701
 702         ret = ocfs2_prepare_write_nolock(inode, page, offset, offset);
 703         if (ret < 0) {
 704                 mlog_errno(ret);
 705                 goto out_unlock;
 706         }
 707
 708         if (ocfs2_should_order_data(inode)) {
 709                 handle = ocfs2_start_walk_page_trans(inode, page, offset,
 710                                                      offset);
 711                 if (IS_ERR(handle)) {
 712                         ret = PTR_ERR(handle);
 713                         handle = NULL;
 714                         goto out_unlock;
 715                 }
 716         }
 717
 718         /* must not update i_size! */
 719         ret = block_commit_write(page, offset, offset);
 720         if (ret < 0)
 721                 mlog_errno(ret);
 722         else
 723                 ret = 0;
 724
 725         if (handle)
 726                 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
 727 out_unlock:
 728         unlock_page(page);
 729         page_cache_release(page);
 730 out:
 731         return ret;
 732 }
 733
 734 static int ocfs2_zero_extend(struct inode *inode,
 735                              u64 zero_to_size)
 736 {
 737         int ret = 0;
 738         u64 start_off;
 739         struct super_block *sb = inode->i_sb;
 740
 741         start_off = ocfs2_align_bytes_to_blocks(sb, i_size_read(inode));
 742         while (start_off < zero_to_size) {
 743                 ret = ocfs2_write_zero_page(inode, start_off);
 744                 if (ret < 0) {
 745                         mlog_errno(ret);
 746                         goto out;
 747                 }
 748
 749                 start_off += sb->s_blocksize;
 750
 751                 /*
 752                  * Very large extends have the potential to lock up
 753                  * the cpu for extended periods of time.
 754                  */
 755                 cond_resched();
 756         }
 757
 758 out:
 759         return ret;
 760 }
 761
 762 int ocfs2_extend_no_holes(struct inode *inode, u64 new_i_size, u64 zero_to)
 763 {
 764         int ret;
 765         u32 clusters_to_add;
 766         struct ocfs2_inode_info *oi = OCFS2_I(inode);
 767
 768         clusters_to_add = ocfs2_clusters_for_bytes(inode->i_sb, new_i_size);
 769         if (clusters_to_add < oi->ip_clusters)
 770                 clusters_to_add = 0;
 771         else
 772                 clusters_to_add -= oi->ip_clusters;
 773
 774         if (clusters_to_add) {
 775                 ret = __ocfs2_extend_allocation(inode, oi->ip_clusters,
 776                                                 clusters_to_add, 0);
 777                 if (ret) {
 778                         mlog_errno(ret);
 779                         goto out;
 780                 }
 781         }
 782
 783         /*
 784          * Call this even if we don't add any clusters to the tree. We
 785          * still need to zero the area between the old i_size and the
 786          * new i_size.
 787          */
 788         ret = ocfs2_zero_extend(inode, zero_to);
 789         if (ret < 0)
 790                 mlog_errno(ret);
 791
 792 out:
 793         return ret;
 794 }
 795
 796 static int ocfs2_extend_file(struct inode *inode,
 797                              struct buffer_head *di_bh,
 798                              u64 new_i_size)
 799 {
 800         int ret = 0;
 801         struct ocfs2_inode_info *oi = OCFS2_I(inode);
 802
 803         BUG_ON(!di_bh);
 804
 805         /* setattr sometimes calls us like this. */
 806         if (new_i_size == 0)
 807                 goto out;
 808
 809         if (i_size_read(inode) == new_i_size)
 810                 goto out;
 811         BUG_ON(new_i_size < i_size_read(inode));
 812
 813         /*
 814          * Fall through for converting inline data, even if the fs
 815          * supports sparse files.
 816          *
 817          * The check for inline data here is legal - nobody can add
 818          * the feature since we have i_mutex. We must check it again
 819          * after acquiring ip_alloc_sem though, as paths like mmap
 820          * might have raced us to converting the inode to extents.
 821          */
 822         if (!(oi->ip_dyn_features & OCFS2_INLINE_DATA_FL)
 823             && ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)))
 824                 goto out_update_size;
 825
 826         /*
 827          * The alloc sem blocks people in read/write from reading our
 828          * allocation until we're done changing it. We depend on
 829          * i_mutex to block other extend/truncate calls while we're
 830          * here.
 831          */
 832         down_write(&oi->ip_alloc_sem);
 833
 834         if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
 835                 /*
 836                  * We can optimize small extends by keeping the inodes
 837                  * inline data.
 838                  */
 839                 if (ocfs2_size_fits_inline_data(di_bh, new_i_size)) {
 840                         up_write(&oi->ip_alloc_sem);
 841                         goto out_update_size;
 842                 }
 843
 844                 ret = ocfs2_convert_inline_data_to_extents(inode, di_bh);
 845                 if (ret) {
 846                         up_write(&oi->ip_alloc_sem);
 847
 848                         mlog_errno(ret);
 849                         goto out;
 850                 }
 851         }
 852
 853         if (!ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)))
 854                 ret = ocfs2_extend_no_holes(inode, new_i_size, new_i_size);
 855
 856         up_write(&oi->ip_alloc_sem);
 857
 858         if (ret < 0) {
 859                 mlog_errno(ret);
 860                 goto out;
 861         }
 862
 863 out_update_size:
 864         ret = ocfs2_simple_size_update(inode, di_bh, new_i_size);
 865         if (ret < 0)
 866                 mlog_errno(ret);
 867
 868 out:
 869         return ret;
 870 }
 871
 872 int ocfs2_setattr(struct dentry *dentry, struct iattr *attr)
 873 {
 874         int status = 0, size_change;
 875         struct inode *inode = dentry->d_inode;
 876         struct super_block *sb = inode->i_sb;
 877         struct ocfs2_super *osb = OCFS2_SB(sb);
 878         struct buffer_head *bh = NULL;
 879         handle_t *handle = NULL;
 880
 881         mlog_entry("(0x%p, '%.*s')\n", dentry,
 882                    dentry->d_name.len, dentry->d_name.name);
 883
 884         /* ensuring we don't even attempt to truncate a symlink */
 885         if (S_ISLNK(inode->i_mode))
 886                 attr->ia_valid &= ~ATTR_SIZE;
 887
 888         if (attr->ia_valid & ATTR_MODE)
 889                 mlog(0, "mode change: %d\n", attr->ia_mode);
 890         if (attr->ia_valid & ATTR_UID)
 891                 mlog(0, "uid change: %d\n", attr->ia_uid);
 892         if (attr->ia_valid & ATTR_GID)
 893                 mlog(0, "gid change: %d\n", attr->ia_gid);
 894         if (attr->ia_valid & ATTR_SIZE)
 895                 mlog(0, "size change...\n");
 896         if (attr->ia_valid & (ATTR_ATIME | ATTR_MTIME | ATTR_CTIME))
 897                 mlog(0, "time change...\n");
 898
 899 #define OCFS2_VALID_ATTRS (ATTR_ATIME | ATTR_MTIME | ATTR_CTIME | ATTR_SIZE \
 900                            | ATTR_GID | ATTR_UID | ATTR_MODE)
 901         if (!(attr->ia_valid & OCFS2_VALID_ATTRS)) {
 902                 mlog(0, "can't handle attrs: 0x%x\n", attr->ia_valid);
 903                 return 0;
 904         }
 905
 906         status = inode_change_ok(inode, attr);
 907         if (status)
 908                 return status;
 909
 910         size_change = S_ISREG(inode->i_mode) && attr->ia_valid & ATTR_SIZE;
 911         if (size_change) {
 912                 status = ocfs2_rw_lock(inode, 1);
 913                 if (status < 0) {
 914                         mlog_errno(status);
 915                         goto bail;
 916                 }
 917         }
 918
 919         status = ocfs2_inode_lock(inode, &bh, 1);
 920         if (status < 0) {
 921                 if (status != -ENOENT)
 922                         mlog_errno(status);
 923                 goto bail_unlock_rw;
 924         }
 925
 926         if (size_change && attr->ia_size != i_size_read(inode)) {
 927                 if (attr->ia_size > sb->s_maxbytes) {
 928                         status = -EFBIG;
 929                         goto bail_unlock;
 930                 }
 931
 932                 if (i_size_read(inode) > attr->ia_size) {
 933                         if (ocfs2_should_order_data(inode)) {
 934                                 status = ocfs2_begin_ordered_truncate(inode,
 935                                                                       attr->ia_size);
 936                                 if (status)
 937                                         goto bail_unlock;
 938                         }
 939                         status = ocfs2_truncate_file(inode, bh, attr->ia_size);
 940                 } else
 941                         status = ocfs2_extend_file(inode, bh, attr->ia_size);
 942                 if (status < 0) {
 943                         if (status != -ENOSPC)
 944                                 mlog_errno(status);
 945                         status = -ENOSPC;
 946                         goto bail_unlock;
 947                 }
 948         }
 949
 950         handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
 951         if (IS_ERR(handle)) {
 952                 status = PTR_ERR(handle);
 953                 mlog_errno(status);
 954                 goto bail_unlock;
 955         }
 956
 957         /*
 958          * This will intentionally not wind up calling vmtruncate(),
 959          * since all the work for a size change has been done above.
 960          * Otherwise, we could get into problems with truncate as
 961          * ip_alloc_sem is used there to protect against i_size
 962          * changes.
 963          */
 964         status = inode_setattr(inode, attr);
 965         if (status < 0) {
 966                 mlog_errno(status);
 967                 goto bail_commit;
 968         }
 969
 970         status = ocfs2_mark_inode_dirty(handle, inode, bh);
 971         if (status < 0)
 972                 mlog_errno(status);
 973
 974 bail_commit:
 975         ocfs2_commit_trans(osb, handle);
 976 bail_unlock:
 977         ocfs2_inode_unlock(inode, 1);
 978 bail_unlock_rw:
 979         if (size_change)
 980                 ocfs2_rw_unlock(inode, 1);
 981 bail:
 982         brelse(bh);
 983
 984         if (!status && attr->ia_valid & ATTR_MODE) {
 985                 status = ocfs2_acl_chmod(inode);
 986                 if (status < 0)
 987                         mlog_errno(status);
 988         }
 989
 990         mlog_exit(status);
 991         return status;
 992 }
 993
 994 int ocfs2_getattr(struct vfsmount *mnt,
 995                   struct dentry *dentry,
 996                   struct kstat *stat)
 997 {
 998         struct inode *inode = dentry->d_inode;
 999         struct super_block *sb = dentry->d_inode->i_sb;
1000         struct ocfs2_super *osb = sb->s_fs_info;
1001         int err;
1002
1003         mlog_entry_void();
1004
1005         err = ocfs2_inode_revalidate(dentry);
1006         if (err) {
1007                 if (err != -ENOENT)
1008                         mlog_errno(err);
1009                 goto bail;
1010         }
1011
1012         generic_fillattr(inode, stat);
1013
1014         /* We set the blksize from the cluster size for performance */
1015         stat->blksize = osb->s_clustersize;
1016
1017 bail:
1018         mlog_exit(err);
1019
1020         return err;
1021 }
1022
1023 int ocfs2_permission(struct inode *inode, int mask)
1024 {
1025         int ret;
1026
1027         mlog_entry_void();
1028
1029         ret = ocfs2_inode_lock(inode, NULL, 0);
1030         if (ret) {
1031                 if (ret != -ENOENT)
1032                         mlog_errno(ret);
1033                 goto out;
1034         }
1035
1036         ret = generic_permission(inode, mask, ocfs2_check_acl);
1037
1038         ocfs2_inode_unlock(inode, 0);
1039 out:
1040         mlog_exit(ret);
1041         return ret;
1042 }
1043
1044 static int __ocfs2_write_remove_suid(struct inode *inode,
1045                                      struct buffer_head *bh)
1046 {
1047         int ret;
1048         handle_t *handle;
1049         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1050         struct ocfs2_dinode *di;
1051
1052         mlog_entry("(Inode %llu, mode 0%o)\n",
1053                    (unsigned long long)OCFS2_I(inode)->ip_blkno, inode->i_mode);
1054
1055         handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
1056         if (IS_ERR(handle)) {
1057                 ret = PTR_ERR(handle);
1058                 mlog_errno(ret);
1059                 goto out;
1060         }
1061
1062         ret = ocfs2_journal_access(handle, inode, bh,
1063                                    OCFS2_JOURNAL_ACCESS_WRITE);
1064         if (ret < 0) {
1065                 mlog_errno(ret);
1066                 goto out_trans;
1067         }
1068
1069         inode->i_mode &= ~S_ISUID;
1070         if ((inode->i_mode & S_ISGID) && (inode->i_mode & S_IXGRP))
1071                 inode->i_mode &= ~S_ISGID;
1072
1073         di = (struct ocfs2_dinode *) bh->b_data;
1074         di->i_mode = cpu_to_le16(inode->i_mode);
1075
1076         ret = ocfs2_journal_dirty(handle, bh);
1077         if (ret < 0)
1078                 mlog_errno(ret);
1079
1080 out_trans:
1081         ocfs2_commit_trans(osb, handle);
1082 out:
1083         mlog_exit(ret);
1084         return ret;
1085 }
1086
1087 /*
1088  * Will look for holes and unwritten extents in the range starting at
1089  * pos for count bytes (inclusive).
1090  */
1091 static int ocfs2_check_range_for_holes(struct inode *inode, loff_t pos,
1092                                        size_t count)
1093 {
1094         int ret = 0;
1095         unsigned int extent_flags;
1096         u32 cpos, clusters, extent_len, phys_cpos;
1097         struct super_block *sb = inode->i_sb;
1098
1099         cpos = pos >> OCFS2_SB(sb)->s_clustersize_bits;
1100         clusters = ocfs2_clusters_for_bytes(sb, pos + count) - cpos;
1101
1102         while (clusters) {
1103                 ret = ocfs2_get_clusters(inode, cpos, &phys_cpos, &extent_len,
1104                                          &extent_flags);
1105                 if (ret < 0) {
1106                         mlog_errno(ret);
1107                         goto out;
1108                 }
1109
1110                 if (phys_cpos == 0 || (extent_flags & OCFS2_EXT_UNWRITTEN)) {
1111                         ret = 1;
1112                         break;
1113                 }
1114
1115                 if (extent_len > clusters)
1116                         extent_len = clusters;
1117
1118                 clusters -= extent_len;
1119                 cpos += extent_len;
1120         }
1121 out:
1122         return ret;
1123 }
1124
1125 static int ocfs2_write_remove_suid(struct inode *inode)
1126 {
1127         int ret;
1128         struct buffer_head *bh = NULL;
1129
1130         ret = ocfs2_read_inode_block(inode, &bh);
1131         if (ret < 0) {
1132                 mlog_errno(ret);
1133                 goto out;
1134         }
1135
1136         ret =  __ocfs2_write_remove_suid(inode, bh);
1137 out:
1138         brelse(bh);
1139         return ret;
1140 }
1141
1142 /*
1143  * Allocate enough extents to cover the region starting at byte offset
1144  * start for len bytes. Existing extents are skipped, any extents
1145  * added are marked as "unwritten".
1146  */
1147 static int ocfs2_allocate_unwritten_extents(struct inode *inode,
1148                                             u64 start, u64 len)
1149 {
1150         int ret;
1151         u32 cpos, phys_cpos, clusters, alloc_size;
1152         u64 end = start + len;
1153         struct buffer_head *di_bh = NULL;
1154
1155         if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
1156                 ret = ocfs2_read_inode_block(inode, &di_bh);
1157                 if (ret) {
1158                         mlog_errno(ret);
1159                         goto out;
1160                 }
1161
1162                 /*
1163                  * Nothing to do if the requested reservation range
1164                  * fits within the inode.
1165                  */
1166                 if (ocfs2_size_fits_inline_data(di_bh, end))
1167                         goto out;
1168
1169                 ret = ocfs2_convert_inline_data_to_extents(inode, di_bh);
1170                 if (ret) {
1171                         mlog_errno(ret);
1172                         goto out;
1173                 }
1174         }
1175
1176         /*
1177          * We consider both start and len to be inclusive.
1178          */
1179         cpos = start >> OCFS2_SB(inode->i_sb)->s_clustersize_bits;
1180         clusters = ocfs2_clusters_for_bytes(inode->i_sb, start + len);
1181         clusters -= cpos;
1182
1183         while (clusters) {
1184                 ret = ocfs2_get_clusters(inode, cpos, &phys_cpos,
1185                                          &alloc_size, NULL);
1186                 if (ret) {
1187                         mlog_errno(ret);
1188                         goto out;
1189                 }
1190
1191                 /*
1192                  * Hole or existing extent len can be arbitrary, so
1193                  * cap it to our own allocation request.
1194                  */
1195                 if (alloc_size > clusters)
1196                         alloc_size = clusters;
1197
1198                 if (phys_cpos) {
1199                         /*
1200                          * We already have an allocation at this
1201                          * region so we can safely skip it.
1202                          */
1203                         goto next;
1204                 }
1205
1206                 ret = __ocfs2_extend_allocation(inode, cpos, alloc_size, 1);
1207                 if (ret) {
1208                         if (ret != -ENOSPC)
1209                                 mlog_errno(ret);
1210                         goto out;
1211                 }
1212
1213 next:
1214                 cpos += alloc_size;
1215                 clusters -= alloc_size;
1216         }
1217
1218         ret = 0;
1219 out:
1220
1221         brelse(di_bh);
1222         return ret;
1223 }
1224
1225 /*
1226  * Truncate a byte range, avoiding pages within partial clusters. This
1227  * preserves those pages for the zeroing code to write to.
1228  */
1229 static void ocfs2_truncate_cluster_pages(struct inode *inode, u64 byte_start,
1230                                          u64 byte_len)
1231 {
1232         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1233         loff_t start, end;
1234         struct address_space *mapping = inode->i_mapping;
1235
1236         start = (loff_t)ocfs2_align_bytes_to_clusters(inode->i_sb, byte_start);
1237         end = byte_start + byte_len;
1238         end = end & ~(osb->s_clustersize - 1);
1239
1240         if (start < end) {
1241                 unmap_mapping_range(mapping, start, end - start, 0);
1242                 truncate_inode_pages_range(mapping, start, end - 1);
1243         }
1244 }
1245
1246 static int ocfs2_zero_partial_clusters(struct inode *inode,
1247                                        u64 start, u64 len)
1248 {
1249         int ret = 0;
1250         u64 tmpend, end = start + len;
1251         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1252         unsigned int csize = osb->s_clustersize;
1253         handle_t *handle;
1254
1255         /*
1256          * The "start" and "end" values are NOT necessarily part of
1257          * the range whose allocation is being deleted. Rather, this
1258          * is what the user passed in with the request. We must zero
1259          * partial clusters here. There's no need to worry about
1260          * physical allocation - the zeroing code knows to skip holes.
1261          */
1262         mlog(0, "byte start: %llu, end: %llu\n",
1263              (unsigned long long)start, (unsigned long long)end);
1264
1265         /*
1266          * If both edges are on a cluster boundary then there's no
1267          * zeroing required as the region is part of the allocation to
1268          * be truncated.
1269          */
1270         if ((start & (csize - 1)) == 0 && (end & (csize - 1)) == 0)
1271                 goto out;
1272
1273         handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
1274         if (IS_ERR(handle)) {
1275                 ret = PTR_ERR(handle);
1276                 mlog_errno(ret);
1277                 goto out;
1278         }
1279
1280         /*
1281          * We want to get the byte offset of the end of the 1st cluster.
1282          */
1283         tmpend = (u64)osb->s_clustersize + (start & ~(osb->s_clustersize - 1));
1284         if (tmpend > end)
1285                 tmpend = end;
1286
1287         mlog(0, "1st range: start: %llu, tmpend: %llu\n",
1288              (unsigned long long)start, (unsigned long long)tmpend);
1289
1290         ret = ocfs2_zero_range_for_truncate(inode, handle, start, tmpend);
1291         if (ret)
1292                 mlog_errno(ret);
1293
1294         if (tmpend < end) {
1295                 /*
1296                  * This may make start and end equal, but the zeroing
1297                  * code will skip any work in that case so there's no
1298                  * need to catch it up here.
1299                  */
1300                 start = end & ~(osb->s_clustersize - 1);
1301
1302                 mlog(0, "2nd range: start: %llu, end: %llu\n",
1303                      (unsigned long long)start, (unsigned long long)end);
1304
1305                 ret = ocfs2_zero_range_for_truncate(inode, handle, start, end);
1306                 if (ret)
1307                         mlog_errno(ret);
1308         }
1309
1310         ocfs2_commit_trans(osb, handle);
1311 out:
1312         return ret;
1313 }
1314
1315 static int ocfs2_remove_inode_range(struct inode *inode,
1316                                     struct buffer_head *di_bh, u64 byte_start,
1317                                     u64 byte_len)
1318 {
1319         int ret = 0;
1320         u32 trunc_start, trunc_len, cpos, phys_cpos, alloc_size;
1321         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1322         struct ocfs2_cached_dealloc_ctxt dealloc;
1323         struct address_space *mapping = inode->i_mapping;
1324         struct ocfs2_extent_tree et;
1325
1326         ocfs2_init_dinode_extent_tree(&et, inode, di_bh);
1327         ocfs2_init_dealloc_ctxt(&dealloc);
1328
1329         if (byte_len == 0)
1330                 return 0;
1331
1332         if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
1333                 ret = ocfs2_truncate_inline(inode, di_bh, byte_start,
1334                                             byte_start + byte_len, 0);
1335                 if (ret) {
1336                         mlog_errno(ret);
1337                         goto out;
1338                 }
1339                 /*
1340                  * There's no need to get fancy with the page cache
1341                  * truncate of an inline-data inode. We're talking
1342                  * about less than a page here, which will be cached
1343                  * in the dinode buffer anyway.
1344                  */
1345                 unmap_mapping_range(mapping, 0, 0, 0);
1346                 truncate_inode_pages(mapping, 0);
1347                 goto out;
1348         }
1349
1350         trunc_start = ocfs2_clusters_for_bytes(osb->sb, byte_start);
1351         trunc_len = (byte_start + byte_len) >> osb->s_clustersize_bits;
1352         if (trunc_len >= trunc_start)
1353                 trunc_len -= trunc_start;
1354         else
1355                 trunc_len = 0;
1356
1357         mlog(0, "Inode: %llu, start: %llu, len: %llu, cstart: %u, clen: %u\n",
1358              (unsigned long long)OCFS2_I(inode)->ip_blkno,
1359              (unsigned long long)byte_start,
1360              (unsigned long long)byte_len, trunc_start, trunc_len);
1361
1362         ret = ocfs2_zero_partial_clusters(inode, byte_start, byte_len);
1363         if (ret) {
1364                 mlog_errno(ret);
1365                 goto out;
1366         }
1367
1368         cpos = trunc_start;
1369         while (trunc_len) {
1370                 ret = ocfs2_get_clusters(inode, cpos, &phys_cpos,
1371                                          &alloc_size, NULL);
1372                 if (ret) {
1373                         mlog_errno(ret);
1374                         goto out;
1375                 }
1376
1377                 if (alloc_size > trunc_len)
1378                         alloc_size = trunc_len;
1379
1380                 /* Only do work for non-holes */
1381                 if (phys_cpos != 0) {
1382                         ret = ocfs2_remove_btree_range(inode, &et, cpos,
1383                                                        phys_cpos, alloc_size,
1384                                                        &dealloc);
1385                         if (ret) {
1386                                 mlog_errno(ret);
1387                                 goto out;
1388                         }
1389                 }
1390
1391                 cpos += alloc_size;
1392                 trunc_len -= alloc_size;
1393         }
1394
1395         ocfs2_truncate_cluster_pages(inode, byte_start, byte_len);
1396
1397 out:
1398         ocfs2_schedule_truncate_log_flush(osb, 1);
1399         ocfs2_run_deallocs(osb, &dealloc);
1400
1401         return ret;
1402 }
1403
1404 /*
1405  * Parts of this function taken from xfs_change_file_space()
1406  */
1407 static int __ocfs2_change_file_space(struct file *file, struct inode *inode,
1408                                      loff_t f_pos, unsigned int cmd,
1409                                      struct ocfs2_space_resv *sr,
1410                                      int change_size)
1411 {
1412         int ret;
1413         s64 llen;
1414         loff_t size;
1415         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1416         struct buffer_head *di_bh = NULL;
1417         handle_t *handle;
1418         unsigned long long max_off = inode->i_sb->s_maxbytes;
1419
1420         if (ocfs2_is_hard_readonly(osb) || ocfs2_is_soft_readonly(osb))
1421                 return -EROFS;
1422
1423         mutex_lock(&inode->i_mutex);
1424
1425         /*
1426          * This prevents concurrent writes on other nodes
1427          */
1428         ret = ocfs2_rw_lock(inode, 1);
1429         if (ret) {
1430                 mlog_errno(ret);
1431                 goto out;
1432         }
1433
1434         ret = ocfs2_inode_lock(inode, &di_bh, 1);
1435         if (ret) {
1436                 mlog_errno(ret);
1437                 goto out_rw_unlock;
1438         }
1439
1440         if (inode->i_flags & (S_IMMUTABLE|S_APPEND)) {
1441                 ret = -EPERM;
1442                 goto out_inode_unlock;
1443         }
1444
1445         switch (sr->l_whence) {
1446         case 0: /*SEEK_SET*/
1447                 break;
1448         case 1: /*SEEK_CUR*/
1449                 sr->l_start += f_pos;
1450                 break;
1451         case 2: /*SEEK_END*/
1452                 sr->l_start += i_size_read(inode);
1453                 break;
1454         default:
1455                 ret = -EINVAL;
1456                 goto out_inode_unlock;
1457         }
1458         sr->l_whence = 0;
1459
1460         llen = sr->l_len > 0 ? sr->l_len - 1 : sr->l_len;
1461
1462         if (sr->l_start < 0
1463             || sr->l_start > max_off
1464             || (sr->l_start + llen) < 0
1465             || (sr->l_start + llen) > max_off) {
1466                 ret = -EINVAL;
1467                 goto out_inode_unlock;
1468         }
1469         size = sr->l_start + sr->l_len;
1470
1471         if (cmd == OCFS2_IOC_RESVSP || cmd == OCFS2_IOC_RESVSP64) {
1472                 if (sr->l_len <= 0) {
1473                         ret = -EINVAL;
1474                         goto out_inode_unlock;
1475                 }
1476         }
1477
1478         if (file && should_remove_suid(file->f_path.dentry)) {
1479                 ret = __ocfs2_write_remove_suid(inode, di_bh);
1480                 if (ret) {
1481                         mlog_errno(ret);
1482                         goto out_inode_unlock;
1483                 }
1484         }
1485
1486         down_write(&OCFS2_I(inode)->ip_alloc_sem);
1487         switch (cmd) {
1488         case OCFS2_IOC_RESVSP:
1489         case OCFS2_IOC_RESVSP64:
1490                 /*
1491                  * This takes unsigned offsets, but the signed ones we
1492                  * pass have been checked against overflow above.
1493                  */
1494                 ret = ocfs2_allocate_unwritten_extents(inode, sr->l_start,
1495                                                        sr->l_len);
1496                 break;
1497         case OCFS2_IOC_UNRESVSP:
1498         case OCFS2_IOC_UNRESVSP64:
1499                 ret = ocfs2_remove_inode_range(inode, di_bh, sr->l_start,
1500                                                sr->l_len);
1501                 break;
1502         default:
1503                 ret = -EINVAL;
1504         }
1505         up_write(&OCFS2_I(inode)->ip_alloc_sem);
1506         if (ret) {
1507                 mlog_errno(ret);
1508                 goto out_inode_unlock;
1509         }
1510
1511         /*
1512          * We update c/mtime for these changes
1513          */
1514         handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
1515         if (IS_ERR(handle)) {
1516                 ret = PTR_ERR(handle);
1517                 mlog_errno(ret);
1518                 goto out_inode_unlock;
1519         }
1520
1521         if (change_size && i_size_read(inode) < size)
1522                 i_size_write(inode, size);
1523
1524         inode->i_ctime = inode->i_mtime = CURRENT_TIME;
1525         ret = ocfs2_mark_inode_dirty(handle, inode, di_bh);
1526         if (ret < 0)
1527                 mlog_errno(ret);
1528
1529         ocfs2_commit_trans(osb, handle);
1530
1531 out_inode_unlock:
1532         brelse(di_bh);
1533         ocfs2_inode_unlock(inode, 1);
1534 out_rw_unlock:
1535         ocfs2_rw_unlock(inode, 1);
1536
1537 out:
1538         mutex_unlock(&inode->i_mutex);
1539         return ret;
1540 }
1541
1542 int ocfs2_change_file_space(struct file *file, unsigned int cmd,
1543                             struct ocfs2_space_resv *sr)
1544 {
1545         struct inode *inode = file->f_path.dentry->d_inode;
1546         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);;
1547
1548         if ((cmd == OCFS2_IOC_RESVSP || cmd == OCFS2_IOC_RESVSP64) &&
1549             !ocfs2_writes_unwritten_extents(osb))
1550                 return -ENOTTY;
1551         else if ((cmd == OCFS2_IOC_UNRESVSP || cmd == OCFS2_IOC_UNRESVSP64) &&
1552                  !ocfs2_sparse_alloc(osb))
1553                 return -ENOTTY;
1554
1555         if (!S_ISREG(inode->i_mode))
1556                 return -EINVAL;
1557
1558         if (!(file->f_mode & FMODE_WRITE))
1559                 return -EBADF;
1560
1561         return __ocfs2_change_file_space(file, inode, file->f_pos, cmd, sr, 0);
1562 }
1563
1564 static long ocfs2_fallocate(struct inode *inode, int mode, loff_t offset,
1565                             loff_t len)
1566 {
1567         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1568         struct ocfs2_space_resv sr;
1569         int change_size = 1;
1570
1571         if (!ocfs2_writes_unwritten_extents(osb))
1572                 return -EOPNOTSUPP;
1573
1574         if (S_ISDIR(inode->i_mode))
1575                 return -ENODEV;
1576
1577         if (mode & FALLOC_FL_KEEP_SIZE)
1578                 change_size = 0;
1579
1580         sr.l_whence = 0;
1581         sr.l_start = (s64)offset;
1582         sr.l_len = (s64)len;
1583
1584         return __ocfs2_change_file_space(NULL, inode, offset,
1585                                          OCFS2_IOC_RESVSP64, &sr, change_size);
1586 }
1587
1588 static int ocfs2_prepare_inode_for_write(struct dentry *dentry,
1589                                          loff_t *ppos,
1590                                          size_t count,
1591                                          int appending,
1592                                          int *direct_io)
1593 {
1594         int ret = 0, meta_level = 0;
1595         struct inode *inode = dentry->d_inode;
1596         loff_t saved_pos, end;
1597
1598         /*
1599          * We start with a read level meta lock and only jump to an ex
1600          * if we need to make modifications here.
1601          */
1602         for(;;) {
1603                 ret = ocfs2_inode_lock(inode, NULL, meta_level);
1604                 if (ret < 0) {
1605                         meta_level = -1;
1606                         mlog_errno(ret);
1607                         goto out;
1608                 }
1609
1610                 /* Clear suid / sgid if necessary. We do this here
1611                  * instead of later in the write path because
1612                  * remove_suid() calls ->setattr without any hint that
1613                  * we may have already done our cluster locking. Since
1614                  * ocfs2_setattr() *must* take cluster locks to
1615                  * proceeed, this will lead us to recursively lock the
1616                  * inode. There's also the dinode i_size state which
1617                  * can be lost via setattr during extending writes (we
1618                  * set inode->i_size at the end of a write. */
1619                 if (should_remove_suid(dentry)) {
1620                         if (meta_level == 0) {
1621                                 ocfs2_inode_unlock(inode, meta_level);
1622                                 meta_level = 1;
1623                                 continue;
1624                         }
1625
1626                         ret = ocfs2_write_remove_suid(inode);
1627                         if (ret < 0) {
1628                                 mlog_errno(ret);
1629                                 goto out_unlock;
1630                         }
1631                 }
1632
1633                 /* work on a copy of ppos until we're sure that we won't have
1634                  * to recalculate it due to relocking. */
1635                 if (appending) {
1636                         saved_pos = i_size_read(inode);
1637                         mlog(0, "O_APPEND: inode->i_size=%llu\n", saved_pos);
1638                 } else {
1639                         saved_pos = *ppos;
1640                 }
1641
1642                 end = saved_pos + count;
1643
1644                 /*
1645                  * Skip the O_DIRECT checks if we don't need
1646                  * them.
1647                  */
1648                 if (!direct_io || !(*direct_io))
1649                         break;
1650
1651                 /*
1652                  * There's no sane way to do direct writes to an inode
1653                  * with inline data.
1654                  */
1655                 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
1656                         *direct_io = 0;
1657                         break;
1658                 }
1659
1660                 /*
1661                  * Allowing concurrent direct writes means
1662                  * i_size changes wouldn't be synchronized, so
1663                  * one node could wind up truncating another
1664                  * nodes writes.
1665                  */
1666                 if (end > i_size_read(inode)) {
1667                         *direct_io = 0;
1668                         break;
1669                 }
1670
1671                 /*
1672                  * We don't fill holes during direct io, so
1673                  * check for them here. If any are found, the
1674                  * caller will have to retake some cluster
1675                  * locks and initiate the io as buffered.
1676                  */
1677                 ret = ocfs2_check_range_for_holes(inode, saved_pos, count);
1678                 if (ret == 1) {
1679                         *direct_io = 0;
1680                         ret = 0;
1681                 } else if (ret < 0)
1682                         mlog_errno(ret);
1683                 break;
1684         }
1685
1686         if (appending)
1687                 *ppos = saved_pos;
1688
1689 out_unlock:
1690         ocfs2_inode_unlock(inode, meta_level);
1691
1692 out:
1693         return ret;
1694 }
1695
1696 static ssize_t ocfs2_file_aio_write(struct kiocb *iocb,
1697                                     const struct iovec *iov,
1698                                     unsigned long nr_segs,
1699                                     loff_t pos)
1700 {
1701         int ret, direct_io, appending, rw_level, have_alloc_sem  = 0;
1702         int can_do_direct;
1703         ssize_t written = 0;
1704         size_t ocount;          /* original count */
1705         size_t count;           /* after file limit checks */
1706         loff_t old_size, *ppos = &iocb->ki_pos;
1707         u32 old_clusters;
1708         struct file *file = iocb->ki_filp;
1709         struct inode *inode = file->f_path.dentry->d_inode;
1710         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1711
1712         mlog_entry("(0x%p, %u, '%.*s')\n", file,
1713                    (unsigned int)nr_segs,
1714                    file->f_path.dentry->d_name.len,
1715                    file->f_path.dentry->d_name.name);
1716
1717         if (iocb->ki_left == 0)
1718                 return 0;
1719
1720         vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);
1721
1722         appending = file->f_flags & O_APPEND ? 1 : 0;
1723         direct_io = file->f_flags & O_DIRECT ? 1 : 0;
1724
1725         mutex_lock(&inode->i_mutex);
1726
1727 relock:
1728         /* to match setattr's i_mutex -> i_alloc_sem -> rw_lock ordering */
1729         if (direct_io) {
1730                 down_read(&inode->i_alloc_sem);
1731                 have_alloc_sem = 1;
1732         }
1733
1734         /* concurrent O_DIRECT writes are allowed */
1735         rw_level = !direct_io;
1736         ret = ocfs2_rw_lock(inode, rw_level);
1737         if (ret < 0) {
1738                 mlog_errno(ret);
1739                 goto out_sems;
1740         }
1741
1742         can_do_direct = direct_io;
1743         ret = ocfs2_prepare_inode_for_write(file->f_path.dentry, ppos,
1744                                             iocb->ki_left, appending,
1745                                             &can_do_direct);
1746         if (ret < 0) {
1747                 mlog_errno(ret);
1748                 goto out;
1749         }
1750
1751         /*
1752          * We can't complete the direct I/O as requested, fall back to
1753          * buffered I/O.
1754          */
1755         if (direct_io && !can_do_direct) {
1756                 ocfs2_rw_unlock(inode, rw_level);
1757                 up_read(&inode->i_alloc_sem);
1758
1759                 have_alloc_sem = 0;
1760                 rw_level = -1;
1761
1762                 direct_io = 0;
1763                 goto relock;
1764         }
1765
1766         /*
1767          * To later detect whether a journal commit for sync writes is
1768          * necessary, we sample i_size, and cluster count here.
1769          */
1770         old_size = i_size_read(inode);
1771         old_clusters = OCFS2_I(inode)->ip_clusters;
1772
1773         /* communicate with ocfs2_dio_end_io */
1774         ocfs2_iocb_set_rw_locked(iocb, rw_level);
1775
1776         if (direct_io) {
1777                 ret = generic_segment_checks(iov, &nr_segs, &ocount,
1778                                              VERIFY_READ);
1779                 if (ret)
1780                         goto out_dio;
1781
1782                 ret = generic_write_checks(file, ppos, &count,
1783                                            S_ISBLK(inode->i_mode));
1784                 if (ret)
1785                         goto out_dio;
1786
1787                 written = generic_file_direct_write(iocb, iov, &nr_segs, *ppos,
1788                                                     ppos, count, ocount);
1789                 if (written < 0) {
1790                         /*
1791                          * direct write may have instantiated a few
1792                          * blocks outside i_size. Trim these off again.
1793                          * Don't need i_size_read because we hold i_mutex.
1794                          */
1795                         if (*ppos + count > inode->i_size)
1796                                 vmtruncate(inode, inode->i_size);
1797                         ret = written;
1798                         goto out_dio;
1799                 }
1800         } else {
1801                 written = generic_file_aio_write_nolock(iocb, iov, nr_segs,
1802                                                         *ppos);
1803         }
1804
1805 out_dio:
1806         /* buffered aio wouldn't have proper lock coverage today */
1807         BUG_ON(ret == -EIOCBQUEUED && !(file->f_flags & O_DIRECT));
1808
1809         if ((file->f_flags & O_SYNC && !direct_io) || IS_SYNC(inode)) {
1810                 /*
1811                  * The generic write paths have handled getting data
1812                  * to disk, but since we don't make use of the dirty
1813                  * inode list, a manual journal commit is necessary
1814                  * here.
1815                  */
1816                 if (old_size != i_size_read(inode) ||
1817                     old_clusters != OCFS2_I(inode)->ip_clusters) {
1818                         ret = jbd2_journal_force_commit(osb->journal->j_journal);
1819                         if (ret < 0)
1820                                 written = ret;
1821                 }
1822         }
1823
1824         /*
1825          * deep in g_f_a_w_n()->ocfs2_direct_IO we pass in a ocfs2_dio_end_io
1826          * function pointer which is called when o_direct io completes so that
1827          * it can unlock our rw lock.  (it's the clustered equivalent of
1828          * i_alloc_sem; protects truncate from racing with pending ios).
1829          * Unfortunately there are error cases which call end_io and others
1830          * that don't.  so we don't have to unlock the rw_lock if either an
1831          * async dio is going to do it in the future or an end_io after an
1832          * error has already done it.
1833          */
1834         if (ret == -EIOCBQUEUED || !ocfs2_iocb_is_rw_locked(iocb)) {
1835                 rw_level = -1;
1836                 have_alloc_sem = 0;
1837         }
1838
1839 out:
1840         if (rw_level != -1)
1841                 ocfs2_rw_unlock(inode, rw_level);
1842
1843 out_sems:
1844         if (have_alloc_sem)
1845                 up_read(&inode->i_alloc_sem);
1846
1847         mutex_unlock(&inode->i_mutex);
1848
1849         mlog_exit(ret);
1850         return written ? written : ret;
1851 }
1852
1853 static ssize_t ocfs2_file_splice_write(struct pipe_inode_info *pipe,
1854                                        struct file *out,
1855                                        loff_t *ppos,
1856                                        size_t len,
1857                                        unsigned int flags)
1858 {
1859         int ret;
1860         struct inode *inode = out->f_path.dentry->d_inode;
1861
1862         mlog_entry("(0x%p, 0x%p, %u, '%.*s')\n", out, pipe,
1863                    (unsigned int)len,
1864                    out->f_path.dentry->d_name.len,
1865                    out->f_path.dentry->d_name.name);
1866
1867         inode_double_lock(inode, pipe->inode);
1868
1869         ret = ocfs2_rw_lock(inode, 1);
1870         if (ret < 0) {
1871                 mlog_errno(ret);
1872                 goto out;
1873         }
1874
1875         ret = ocfs2_prepare_inode_for_write(out->f_path.dentry, ppos, len, 0,
1876                                             NULL);
1877         if (ret < 0) {
1878                 mlog_errno(ret);
1879                 goto out_unlock;
1880         }
1881
1882         ret = generic_file_splice_write_nolock(pipe, out, ppos, len, flags);
1883
1884 out_unlock:
1885         ocfs2_rw_unlock(inode, 1);
1886 out:
1887         inode_double_unlock(inode, pipe->inode);
1888
1889         mlog_exit(ret);
1890         return ret;
1891 }
1892
1893 static ssize_t ocfs2_file_splice_read(struct file *in,
1894                                       loff_t *ppos,
1895                                       struct pipe_inode_info *pipe,
1896                                       size_t len,
1897                                       unsigned int flags)
1898 {
1899         int ret = 0;
1900         struct inode *inode = in->f_path.dentry->d_inode;
1901
1902         mlog_entry("(0x%p, 0x%p, %u, '%.*s')\n", in, pipe,
1903                    (unsigned int)len,
1904                    in->f_path.dentry->d_name.len,
1905                    in->f_path.dentry->d_name.name);
1906
1907         /*
1908          * See the comment in ocfs2_file_aio_read()
1909          */
1910         ret = ocfs2_inode_lock(inode, NULL, 0);
1911         if (ret < 0) {
1912                 mlog_errno(ret);
1913                 goto bail;
1914         }
1915         ocfs2_inode_unlock(inode, 0);
1916
1917         ret = generic_file_splice_read(in, ppos, pipe, len, flags);
1918
1919 bail:
1920         mlog_exit(ret);
1921         return ret;
1922 }
1923
1924 static ssize_t ocfs2_file_aio_read(struct kiocb *iocb,
1925                                    const struct iovec *iov,
1926                                    unsigned long nr_segs,
1927                                    loff_t pos)
1928 {
1929         int ret = 0, rw_level = -1, have_alloc_sem = 0, lock_level = 0;
1930         struct file *filp = iocb->ki_filp;
1931         struct inode *inode = filp->f_path.dentry->d_inode;
1932
1933         mlog_entry("(0x%p, %u, '%.*s')\n", filp,
1934                    (unsigned int)nr_segs,
1935                    filp->f_path.dentry->d_name.len,
1936                    filp->f_path.dentry->d_name.name);
1937
1938         if (!inode) {
1939                 ret = -EINVAL;
1940                 mlog_errno(ret);
1941                 goto bail;
1942         }
1943
1944         /*
1945          * buffered reads protect themselves in ->readpage().  O_DIRECT reads
1946          * need locks to protect pending reads from racing with truncate.
1947          */
1948         if (filp->f_flags & O_DIRECT) {
1949                 down_read(&inode->i_alloc_sem);
1950                 have_alloc_sem = 1;
1951
1952                 ret = ocfs2_rw_lock(inode, 0);
1953                 if (ret < 0) {
1954                         mlog_errno(ret);
1955                         goto bail;
1956                 }
1957                 rw_level = 0;
1958                 /* communicate with ocfs2_dio_end_io */
1959                 ocfs2_iocb_set_rw_locked(iocb, rw_level);
1960         }
1961
1962         /*
1963          * We're fine letting folks race truncates and extending
1964          * writes with read across the cluster, just like they can
1965          * locally. Hence no rw_lock during read.
1966          *
1967          * Take and drop the meta data lock to update inode fields
1968          * like i_size. This allows the checks down below
1969          * generic_file_aio_read() a chance of actually working.
1970          */
1971         ret = ocfs2_inode_lock_atime(inode, filp->f_vfsmnt, &lock_level);
1972         if (ret < 0) {
1973                 mlog_errno(ret);
1974                 goto bail;
1975         }
1976         ocfs2_inode_unlock(inode, lock_level);
1977
1978         ret = generic_file_aio_read(iocb, iov, nr_segs, iocb->ki_pos);
1979         if (ret == -EINVAL)
1980                 mlog(0, "generic_file_aio_read returned -EINVAL\n");
1981
1982         /* buffered aio wouldn't have proper lock coverage today */
1983         BUG_ON(ret == -EIOCBQUEUED && !(filp->f_flags & O_DIRECT));
1984
1985         /* see ocfs2_file_aio_write */
1986         if (ret == -EIOCBQUEUED || !ocfs2_iocb_is_rw_locked(iocb)) {
1987                 rw_level = -1;
1988                 have_alloc_sem = 0;
1989         }
1990
1991 bail:
1992         if (have_alloc_sem)
1993                 up_read(&inode->i_alloc_sem);
1994         if (rw_level != -1)
1995                 ocfs2_rw_unlock(inode, rw_level);
1996         mlog_exit(ret);
1997
1998         return ret;
1999 }
2000
2001 const struct inode_operations ocfs2_file_iops = {
2002         .setattr        = ocfs2_setattr,
2003         .getattr        = ocfs2_getattr,
2004         .permission     = ocfs2_permission,
2005         .setxattr       = generic_setxattr,
2006         .getxattr       = generic_getxattr,
2007         .listxattr      = ocfs2_listxattr,
2008         .removexattr    = generic_removexattr,
2009         .fallocate      = ocfs2_fallocate,
2010         .fiemap         = ocfs2_fiemap,
2011 };
2012
2013 const struct inode_operations ocfs2_special_file_iops = {
2014         .setattr        = ocfs2_setattr,
2015         .getattr        = ocfs2_getattr,
2016         .permission     = ocfs2_permission,
2017 };
2018
2019 /*
2020  * Other than ->lock, keep ocfs2_fops and ocfs2_dops in sync with
2021  * ocfs2_fops_no_plocks and ocfs2_dops_no_plocks!
2022  */
2023 const struct file_operations ocfs2_fops = {
2024         .llseek         = generic_file_llseek,
2025         .read           = do_sync_read,
2026         .write          = do_sync_write,
2027         .mmap           = ocfs2_mmap,
2028         .fsync          = ocfs2_sync_file,
2029         .release        = ocfs2_file_release,
2030         .open           = ocfs2_file_open,
2031         .aio_read       = ocfs2_file_aio_read,
2032         .aio_write      = ocfs2_file_aio_write,
2033         .unlocked_ioctl = ocfs2_ioctl,
2034 #ifdef CONFIG_COMPAT
2035         .compat_ioctl   = ocfs2_compat_ioctl,
2036 #endif
2037         .lock           = ocfs2_lock,
2038         .flock          = ocfs2_flock,
2039         .splice_read    = ocfs2_file_splice_read,
2040         .splice_write   = ocfs2_file_splice_write,
2041 };
2042
2043 const struct file_operations ocfs2_dops = {
2044         .llseek         = generic_file_llseek,
2045         .read           = generic_read_dir,
2046         .readdir        = ocfs2_readdir,
2047         .fsync          = ocfs2_sync_file,
2048         .release        = ocfs2_dir_release,
2049         .open           = ocfs2_dir_open,
2050         .unlocked_ioctl = ocfs2_ioctl,
2051 #ifdef CONFIG_COMPAT
2052         .compat_ioctl   = ocfs2_compat_ioctl,
2053 #endif
2054         .lock           = ocfs2_lock,
2055         .flock          = ocfs2_flock,
2056 };
2057
2058 /*
2059  * POSIX-lockless variants of our file_operations.
2060  *
2061  * These will be used if the underlying cluster stack does not support
2062  * posix file locking, if the user passes the "localflocks" mount
2063  * option, or if we have a local-only fs.
2064  *
2065  * ocfs2_flock is in here because all stacks handle UNIX file locks,
2066  * so we still want it in the case of no stack support for
2067  * plocks. Internally, it will do the right thing when asked to ignore
2068  * the cluster.
2069  */
2070 const struct file_operations ocfs2_fops_no_plocks = {
2071         .llseek         = generic_file_llseek,
2072         .read           = do_sync_read,
2073         .write          = do_sync_write,
2074         .mmap           = ocfs2_mmap,
2075         .fsync          = ocfs2_sync_file,
2076         .release        = ocfs2_file_release,
2077         .open           = ocfs2_file_open,
2078         .aio_read       = ocfs2_file_aio_read,
2079         .aio_write      = ocfs2_file_aio_write,
2080         .unlocked_ioctl = ocfs2_ioctl,
2081 #ifdef CONFIG_COMPAT
2082         .compat_ioctl   = ocfs2_compat_ioctl,
2083 #endif
2084         .flock          = ocfs2_flock,
2085         .splice_read    = ocfs2_file_splice_read,
2086         .splice_write   = ocfs2_file_splice_write,
2087 };
2088
2089 const struct file_operations ocfs2_dops_no_plocks = {
2090         .llseek         = generic_file_llseek,
2091         .read           = generic_read_dir,
2092         .readdir        = ocfs2_readdir,
2093         .fsync          = ocfs2_sync_file,
2094         .release        = ocfs2_dir_release,
2095         .open           = ocfs2_dir_open,
2096         .unlocked_ioctl = ocfs2_ioctl,
2097 #ifdef CONFIG_COMPAT
2098         .compat_ioctl   = ocfs2_compat_ioctl,
2099 #endif
2100         .flock          = ocfs2_flock,
2101 };