staging/lustre: remove fsfilt_ext3.c
authorPeng Tao <bergwolf@gmail.com>
Tue, 19 Nov 2013 14:38:38 +0000 (22:38 +0800)
committerGreg Kroah-Hartman <gregkh@linuxfoundation.org>
Tue, 19 Nov 2013 18:42:07 +0000 (10:42 -0800)
It is only used by server.

Cc: Andreas Dilger <andreas.dilger@intel.com>
Signed-off-by: Peng Tao <bergwolf@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
drivers/staging/lustre/lustre/lvfs/fsfilt_ext3.c [deleted file]

diff --git a/drivers/staging/lustre/lustre/lvfs/fsfilt_ext3.c b/drivers/staging/lustre/lustre/lvfs/fsfilt_ext3.c
deleted file mode 100644 (file)
index ee75994..0000000
+++ /dev/null
@@ -1,760 +0,0 @@
-/*
- * GPL HEADER START
- *
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 only,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License version 2 for more details (a copy is included
- * in the LICENSE file that accompanied this code).
- *
- * You should have received a copy of the GNU General Public License
- * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- *
- * GPL HEADER END
- */
-/*
- * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
- * Use is subject to license terms.
- *
- * Copyright (c) 2011, 2012, Intel Corporation.
- */
-/*
- * This file is part of Lustre, http://www.lustre.org/
- * Lustre is a trademark of Sun Microsystems, Inc.
- *
- * lustre/lvfs/fsfilt_ext3.c
- *
- * Author: Andreas Dilger <adilger@clusterfs.com>
- */
-
-#define DEBUG_SUBSYSTEM S_FILTER
-
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/fs.h>
-#include <linux/slab.h>
-#include <linux/pagemap.h>
-#include <ldiskfs/ldiskfs_config.h>
-#include <ext4/ext4.h>
-#include <ext4/ext4_jbd2.h>
-#include <linux/bitops.h>
-#include <linux/quota.h>
-
-#include <linux/libcfs/libcfs.h>
-#include <lustre_fsfilt.h>
-#include <obd.h>
-#include <linux/lustre_compat25.h>
-#include <linux/lprocfs_status.h>
-
-#include <ext4/ext4_extents.h>
-
-#ifdef HAVE_EXT_PBLOCK /* Name changed to ext4_ext_pblock for kernel 2.6.35 */
-#define ext3_ext_pblock(ex) ext_pblock((ex))
-#endif
-
-/* for kernels 2.6.18 and later */
-#define FSFILT_SINGLEDATA_TRANS_BLOCKS(sb) EXT3_SINGLEDATA_TRANS_BLOCKS(sb)
-
-#define fsfilt_ext3_ext_insert_extent(handle, inode, path, newext, flag) \
-              ext3_ext_insert_extent(handle, inode, path, newext, flag)
-
-#define ext3_mb_discard_inode_preallocations(inode) \
-                ext3_discard_preallocations(inode)
-
-#define fsfilt_log_start_commit(journal, tid) jbd2_log_start_commit(journal, tid)
-#define fsfilt_log_wait_commit(journal, tid) jbd2_log_wait_commit(journal, tid)
-
-static struct kmem_cache *fcb_cache;
-
-struct fsfilt_cb_data {
-       struct ext4_journal_cb_entry cb_jcb; /* private data - MUST BE FIRST */
-       fsfilt_cb_t cb_func;        /* MDS/OBD completion function */
-       struct obd_device *cb_obd;      /* MDS/OBD completion device */
-       __u64 cb_last_rcvd;          /* MDS/OST last committed operation */
-       void *cb_data;            /* MDS/OST completion function data */
-};
-
-static char *fsfilt_ext3_get_label(struct super_block *sb)
-{
-       return EXT3_SB(sb)->s_es->s_volume_name;
-}
-
-/* kernel has ext4_blocks_for_truncate since linux-3.1.1 */
-# include <ext4/truncate.h>
-
-/*
- * We don't currently need any additional blocks for rmdir and
- * unlink transactions because we are storing the OST oa_id inside
- * the inode (which we will be changing anyways as part of this
- * transaction).
- */
-static void *fsfilt_ext3_start(struct inode *inode, int op, void *desc_private,
-                              int logs)
-{
-       /* For updates to the last received file */
-       int nblocks = FSFILT_SINGLEDATA_TRANS_BLOCKS(inode->i_sb);
-       journal_t *journal;
-       void *handle;
-
-       if (current->journal_info) {
-               CDEBUG(D_INODE, "increasing refcount on %p\n",
-                      current->journal_info);
-               goto journal_start;
-       }
-
-       switch(op) {
-       case FSFILT_OP_UNLINK:
-               /* delete one file + create/update logs for each stripe */
-               nblocks += EXT3_DELETE_TRANS_BLOCKS(inode->i_sb);
-               nblocks += (EXT3_INDEX_EXTRA_TRANS_BLOCKS +
-                           FSFILT_SINGLEDATA_TRANS_BLOCKS(inode->i_sb)) * logs;
-               break;
-       case FSFILT_OP_CANCEL_UNLINK:
-               LASSERT(logs == 1);
-
-               /* blocks for log header bitmap update OR
-                * blocks for catalog header bitmap update + unlink of logs +
-                * blocks for delete the inode (include blocks truncating). */
-               nblocks = (LLOG_CHUNK_SIZE >> inode->i_blkbits) +
-                         EXT3_DELETE_TRANS_BLOCKS(inode->i_sb) +
-                         ext4_blocks_for_truncate(inode) + 3;
-               break;
-       default: CERROR("unknown transaction start op %d\n", op);
-               LBUG();
-       }
-
-       LASSERT(current->journal_info == desc_private);
-       journal = EXT3_SB(inode->i_sb)->s_journal;
-       if (nblocks > journal->j_max_transaction_buffers) {
-               CWARN("too many credits %d for op %ux%u using %d instead\n",
-                      nblocks, op, logs, journal->j_max_transaction_buffers);
-               nblocks = journal->j_max_transaction_buffers;
-       }
-
- journal_start:
-       LASSERTF(nblocks > 0, "can't start %d credit transaction\n", nblocks);
-       handle = ext3_journal_start(inode, nblocks);
-
-       if (!IS_ERR(handle))
-               LASSERT(current->journal_info == handle);
-       else
-               CERROR("error starting handle for op %u (%u credits): rc %ld\n",
-                      op, nblocks, PTR_ERR(handle));
-       return handle;
-}
-
-static int fsfilt_ext3_commit(struct inode *inode, void *h, int force_sync)
-{
-       int rc;
-       handle_t *handle = h;
-
-       LASSERT(current->journal_info == handle);
-       if (force_sync)
-               handle->h_sync = 1; /* recovery likes this */
-
-       rc = ext3_journal_stop(handle);
-
-       return rc;
-}
-
-#ifndef EXT3_EXTENTS_FL
-#define EXT3_EXTENTS_FL                 0x00080000 /* Inode uses extents */
-#endif
-
-#ifndef EXT_ASSERT
-#define EXT_ASSERT(cond)  BUG_ON(!(cond))
-#endif
-
-#define EXT_GENERATION(inode)     (EXT4_I(inode)->i_ext_generation)
-#define ext3_ext_base             inode
-#define ext3_ext_base2inode(inode)      (inode)
-#define EXT_DEPTH(inode)               ext_depth(inode)
-#define fsfilt_ext3_ext_walk_space(inode, block, num, cb, cbdata) \
-                       ext3_ext_walk_space(inode, block, num, cb, cbdata);
-
-struct bpointers {
-       unsigned long *blocks;
-       unsigned long start;
-       int num;
-       int init_num;
-       int create;
-};
-
-static long ext3_ext_find_goal(struct inode *inode, struct ext3_ext_path *path,
-                              unsigned long block, int *aflags)
-{
-       struct ext3_inode_info *ei = EXT3_I(inode);
-       unsigned long bg_start;
-       unsigned long colour;
-       int depth;
-
-       if (path) {
-               struct ext3_extent *ex;
-               depth = path->p_depth;
-
-               /* try to predict block placement */
-               if ((ex = path[depth].p_ext))
-                       return ext4_ext_pblock(ex) + (block - le32_to_cpu(ex->ee_block));
-
-               /* it looks index is empty
-                * try to find starting from index itself */
-               if (path[depth].p_bh)
-                       return path[depth].p_bh->b_blocknr;
-       }
-
-       /* OK. use inode's group */
-       bg_start = (ei->i_block_group * EXT3_BLOCKS_PER_GROUP(inode->i_sb)) +
-               le32_to_cpu(EXT3_SB(inode->i_sb)->s_es->s_first_data_block);
-       colour = (current->pid % 16) *
-               (EXT3_BLOCKS_PER_GROUP(inode->i_sb) / 16);
-       return bg_start + colour + block;
-}
-
-#define ll_unmap_underlying_metadata(sb, blocknr) \
-       unmap_underlying_metadata((sb)->s_bdev, blocknr)
-
-#ifndef EXT3_MB_HINT_GROUP_ALLOC
-static unsigned long new_blocks(handle_t *handle, struct ext3_ext_base *base,
-                               struct ext3_ext_path *path, unsigned long block,
-                               unsigned long *count, int *err)
-{
-       unsigned long pblock, goal;
-       int aflags = 0;
-       struct inode *inode = ext3_ext_base2inode(base);
-
-       goal = ext3_ext_find_goal(inode, path, block, &aflags);
-       aflags |= 2; /* block have been already reserved */
-       pblock = ext3_mb_new_blocks(handle, inode, goal, count, aflags, err);
-       return pblock;
-
-}
-#else
-static unsigned long new_blocks(handle_t *handle, struct ext3_ext_base *base,
-                               struct ext3_ext_path *path, unsigned long block,
-                               unsigned long *count, int *err)
-{
-       struct inode *inode = ext3_ext_base2inode(base);
-       struct ext3_allocation_request ar;
-       unsigned long pblock;
-       int aflags;
-
-       /* find neighbour allocated blocks */
-       ar.lleft = block;
-       *err = ext3_ext_search_left(base, path, &ar.lleft, &ar.pleft);
-       if (*err)
-               return 0;
-       ar.lright = block;
-       *err = ext3_ext_search_right(base, path, &ar.lright, &ar.pright);
-       if (*err)
-               return 0;
-
-       /* allocate new block */
-       ar.goal = ext3_ext_find_goal(inode, path, block, &aflags);
-       ar.inode = inode;
-       ar.logical = block;
-       ar.len = *count;
-       ar.flags = EXT3_MB_HINT_DATA;
-       pblock = ext3_mb_new_blocks(handle, &ar, err);
-       *count = ar.len;
-       return pblock;
-}
-#endif
-
-static int ext3_ext_new_extent_cb(struct ext3_ext_base *base,
-                                 struct ext3_ext_path *path,
-                                 struct ext3_ext_cache *cex,
-#ifdef HAVE_EXT_PREPARE_CB_EXTENT
-                                  struct ext3_extent *ex,
-#endif
-                                 void *cbdata)
-{
-       struct bpointers *bp = cbdata;
-       struct inode *inode = ext3_ext_base2inode(base);
-       struct ext3_extent nex;
-       unsigned long pblock;
-       unsigned long tgen;
-       int err, i;
-       unsigned long count;
-       handle_t *handle;
-
-#ifdef EXT3_EXT_CACHE_EXTENT
-       if (cex->ec_type == EXT3_EXT_CACHE_EXTENT)
-#else
-       if ((cex->ec_len != 0) && (cex->ec_start != 0))
-#endif
-                                                  {
-               err = EXT_CONTINUE;
-               goto map;
-       }
-
-       if (bp->create == 0) {
-               i = 0;
-               if (cex->ec_block < bp->start)
-                       i = bp->start - cex->ec_block;
-               if (i >= cex->ec_len)
-                       CERROR("nothing to do?! i = %d, e_num = %u\n",
-                                       i, cex->ec_len);
-               for (; i < cex->ec_len && bp->num; i++) {
-                       *(bp->blocks) = 0;
-                       bp->blocks++;
-                       bp->num--;
-                       bp->start++;
-               }
-
-               return EXT_CONTINUE;
-       }
-
-       tgen = EXT_GENERATION(base);
-       count = ext3_ext_calc_credits_for_insert(base, path);
-
-       handle = ext3_journal_start(inode, count+EXT3_ALLOC_NEEDED+1);
-       if (IS_ERR(handle)) {
-               return PTR_ERR(handle);
-       }
-
-       if (tgen != EXT_GENERATION(base)) {
-               /* the tree has changed. so path can be invalid at moment */
-               ext3_journal_stop(handle);
-               return EXT_REPEAT;
-       }
-
-       /* In 2.6.32 kernel, ext4_ext_walk_space()'s callback func is not
-        * protected by i_data_sem as whole. so we patch it to store
-        * generation to path and now verify the tree hasn't changed */
-       down_write((&EXT4_I(inode)->i_data_sem));
-
-       /* validate extent, make sure the extent tree does not changed */
-       if (EXT_GENERATION(base) != path[0].p_generation) {
-               /* cex is invalid, try again */
-               up_write(&EXT4_I(inode)->i_data_sem);
-               ext3_journal_stop(handle);
-               return EXT_REPEAT;
-       }
-
-       count = cex->ec_len;
-       pblock = new_blocks(handle, base, path, cex->ec_block, &count, &err);
-       if (!pblock)
-               goto out;
-       EXT_ASSERT(count <= cex->ec_len);
-
-       /* insert new extent */
-       nex.ee_block = cpu_to_le32(cex->ec_block);
-       ext3_ext_store_pblock(&nex, pblock);
-       nex.ee_len = cpu_to_le16(count);
-       err = fsfilt_ext3_ext_insert_extent(handle, base, path, &nex, 0);
-       if (err) {
-               /* free data blocks we just allocated */
-               /* not a good idea to call discard here directly,
-                * but otherwise we'd need to call it every free() */
-#ifdef EXT3_MB_HINT_GROUP_ALLOC
-               ext3_mb_discard_inode_preallocations(inode);
-#endif
-#ifdef HAVE_EXT_FREE_BLOCK_WITH_BUFFER_HEAD /* Introduced in 2.6.32-rc7 */
-               ext3_free_blocks(handle, inode, NULL, ext4_ext_pblock(&nex),
-                                cpu_to_le16(nex.ee_len), 0);
-#else
-               ext3_free_blocks(handle, inode, ext4_ext_pblock(&nex),
-                                cpu_to_le16(nex.ee_len), 0);
-#endif
-               goto out;
-       }
-
-       /*
-        * Putting len of the actual extent we just inserted,
-        * we are asking ext3_ext_walk_space() to continue
-        * scaning after that block
-        */
-       cex->ec_len = le16_to_cpu(nex.ee_len);
-       cex->ec_start = ext4_ext_pblock(&nex);
-       BUG_ON(le16_to_cpu(nex.ee_len) == 0);
-       BUG_ON(le32_to_cpu(nex.ee_block) != cex->ec_block);
-
-out:
-       up_write((&EXT4_I(inode)->i_data_sem));
-       ext3_journal_stop(handle);
-map:
-       if (err >= 0) {
-               /* map blocks */
-               if (bp->num == 0) {
-                       CERROR("hmm. why do we find this extent?\n");
-                       CERROR("initial space: %lu:%u\n",
-                               bp->start, bp->init_num);
-#ifdef EXT3_EXT_CACHE_EXTENT
-                       CERROR("current extent: %u/%u/%llu %d\n",
-                               cex->ec_block, cex->ec_len,
-                               (unsigned long long)cex->ec_start,
-                               cex->ec_type);
-#else
-                       CERROR("current extent: %u/%u/%llu\n",
-                               cex->ec_block, cex->ec_len,
-                               (unsigned long long)cex->ec_start);
-#endif
-               }
-               i = 0;
-               if (cex->ec_block < bp->start)
-                       i = bp->start - cex->ec_block;
-               if (i >= cex->ec_len)
-                       CERROR("nothing to do?! i = %d, e_num = %u\n",
-                                       i, cex->ec_len);
-               for (; i < cex->ec_len && bp->num; i++) {
-                       *(bp->blocks) = cex->ec_start + i;
-#ifdef EXT3_EXT_CACHE_EXTENT
-                       if (cex->ec_type != EXT3_EXT_CACHE_EXTENT)
-#else
-                       if ((cex->ec_len == 0) || (cex->ec_start == 0))
-#endif
-                                                                       {
-                               /* unmap any possible underlying metadata from
-                                * the block device mapping.  bug 6998. */
-                               ll_unmap_underlying_metadata(inode->i_sb,
-                                                            *(bp->blocks));
-                       }
-                       bp->blocks++;
-                       bp->num--;
-                       bp->start++;
-               }
-       }
-       return err;
-}
-
-int fsfilt_map_nblocks(struct inode *inode, unsigned long block,
-                      unsigned long num, unsigned long *blocks,
-                      int create)
-{
-       struct ext3_ext_base *base = inode;
-       struct bpointers bp;
-       int err;
-
-       CDEBUG(D_OTHER, "blocks %lu-%lu requested for inode %u\n",
-              block, block + num - 1, (unsigned) inode->i_ino);
-
-       bp.blocks = blocks;
-       bp.start = block;
-       bp.init_num = bp.num = num;
-       bp.create = create;
-
-       err = fsfilt_ext3_ext_walk_space(base, block, num,
-                                        ext3_ext_new_extent_cb, &bp);
-       ext3_ext_invalidate_cache(base);
-
-       return err;
-}
-
-int fsfilt_ext3_map_ext_inode_pages(struct inode *inode, struct page **page,
-                                   int pages, unsigned long *blocks,
-                                   int create)
-{
-       int blocks_per_page = PAGE_CACHE_SIZE >> inode->i_blkbits;
-       int rc = 0, i = 0;
-       struct page *fp = NULL;
-       int clen = 0;
-
-       CDEBUG(D_OTHER, "inode %lu: map %d pages from %lu\n",
-               inode->i_ino, pages, (*page)->index);
-
-       /* pages are sorted already. so, we just have to find
-        * contig. space and process them properly */
-       while (i < pages) {
-               if (fp == NULL) {
-                       /* start new extent */
-                       fp = *page++;
-                       clen = 1;
-                       i++;
-                       continue;
-               } else if (fp->index + clen == (*page)->index) {
-                       /* continue the extent */
-                       page++;
-                       clen++;
-                       i++;
-                       continue;
-               }
-
-               /* process found extent */
-               rc = fsfilt_map_nblocks(inode, fp->index * blocks_per_page,
-                                       clen * blocks_per_page, blocks,
-                                       create);
-               if (rc)
-                       GOTO(cleanup, rc);
-
-               /* look for next extent */
-               fp = NULL;
-               blocks += blocks_per_page * clen;
-       }
-
-       if (fp)
-               rc = fsfilt_map_nblocks(inode, fp->index * blocks_per_page,
-                                       clen * blocks_per_page, blocks,
-                                       create);
-cleanup:
-       return rc;
-}
-
-int fsfilt_ext3_map_bm_inode_pages(struct inode *inode, struct page **page,
-                                  int pages, unsigned long *blocks,
-                                  int create)
-{
-       int blocks_per_page = PAGE_CACHE_SIZE >> inode->i_blkbits;
-       unsigned long *b;
-       int rc = 0, i;
-
-       for (i = 0, b = blocks; i < pages; i++, page++) {
-               rc = ext3_map_inode_page(inode, *page, b, create);
-               if (rc) {
-                       CERROR("ino %lu, blk %lu create %d: rc %d\n",
-                              inode->i_ino, *b, create, rc);
-                       break;
-               }
-
-               b += blocks_per_page;
-       }
-       return rc;
-}
-
-int fsfilt_ext3_map_inode_pages(struct inode *inode, struct page **page,
-                               int pages, unsigned long *blocks,
-                               int create, struct mutex *optional_mutex)
-{
-       int rc;
-
-       if (EXT3_I(inode)->i_flags & EXT3_EXTENTS_FL) {
-               rc = fsfilt_ext3_map_ext_inode_pages(inode, page, pages,
-                                                    blocks, create);
-               return rc;
-       }
-       if (optional_mutex != NULL)
-               mutex_lock(optional_mutex);
-       rc = fsfilt_ext3_map_bm_inode_pages(inode, page, pages, blocks, create);
-       if (optional_mutex != NULL)
-               mutex_unlock(optional_mutex);
-
-       return rc;
-}
-
-int fsfilt_ext3_read(struct inode *inode, void *buf, int size, loff_t *offs)
-{
-       unsigned long block;
-       struct buffer_head *bh;
-       int err, blocksize, csize, boffs, osize = size;
-
-       /* prevent reading after eof */
-       spin_lock(&inode->i_lock);
-       if (i_size_read(inode) < *offs + size) {
-               size = i_size_read(inode) - *offs;
-               spin_unlock(&inode->i_lock);
-               if (size < 0) {
-                       CDEBUG(D_EXT2, "size %llu is too short for read @%llu\n",
-                              i_size_read(inode), *offs);
-                       return -EBADR;
-               } else if (size == 0) {
-                       return 0;
-               }
-       } else {
-               spin_unlock(&inode->i_lock);
-       }
-
-       blocksize = 1 << inode->i_blkbits;
-
-       while (size > 0) {
-               block = *offs >> inode->i_blkbits;
-               boffs = *offs & (blocksize - 1);
-               csize = min(blocksize - boffs, size);
-               bh = ext3_bread(NULL, inode, block, 0, &err);
-               if (!bh) {
-                       CERROR("can't read block: %d\n", err);
-                       return err;
-               }
-
-               memcpy(buf, bh->b_data + boffs, csize);
-               brelse(bh);
-
-               *offs += csize;
-               buf += csize;
-               size -= csize;
-       }
-       return osize;
-}
-EXPORT_SYMBOL(fsfilt_ext3_read);
-
-static int fsfilt_ext3_read_record(struct file * file, void *buf,
-                                  int size, loff_t *offs)
-{
-       int rc;
-       rc = fsfilt_ext3_read(file->f_dentry->d_inode, buf, size, offs);
-       if (rc > 0)
-               rc = 0;
-       return rc;
-}
-
-int fsfilt_ext3_write_handle(struct inode *inode, void *buf, int bufsize,
-                               loff_t *offs, handle_t *handle)
-{
-       struct buffer_head *bh = NULL;
-       loff_t old_size = i_size_read(inode), offset = *offs;
-       loff_t new_size = i_size_read(inode);
-       unsigned long block;
-       int err = 0, blocksize = 1 << inode->i_blkbits, size, boffs;
-
-       while (bufsize > 0) {
-               if (bh != NULL)
-                       brelse(bh);
-
-               block = offset >> inode->i_blkbits;
-               boffs = offset & (blocksize - 1);
-               size = min(blocksize - boffs, bufsize);
-               bh = ext3_bread(handle, inode, block, 1, &err);
-               if (!bh) {
-                       CERROR("can't read/create block: %d\n", err);
-                       break;
-               }
-
-               err = ext3_journal_get_write_access(handle, bh);
-               if (err) {
-                       CERROR("journal_get_write_access() returned error %d\n",
-                              err);
-                       break;
-               }
-               LASSERT(bh->b_data + boffs + size <= bh->b_data + bh->b_size);
-               memcpy(bh->b_data + boffs, buf, size);
-               err = ext3_journal_dirty_metadata(handle, bh);
-               if (err) {
-                       CERROR("journal_dirty_metadata() returned error %d\n",
-                              err);
-                       break;
-               }
-               if (offset + size > new_size)
-                       new_size = offset + size;
-               offset += size;
-               bufsize -= size;
-               buf += size;
-       }
-       if (bh)
-               brelse(bh);
-
-       /* correct in-core and on-disk sizes */
-       if (new_size > i_size_read(inode)) {
-               spin_lock(&inode->i_lock);
-               if (new_size > i_size_read(inode))
-                       i_size_write(inode, new_size);
-               if (i_size_read(inode) > EXT3_I(inode)->i_disksize)
-                       EXT3_I(inode)->i_disksize = i_size_read(inode);
-               if (i_size_read(inode) > old_size) {
-                       spin_unlock(&inode->i_lock);
-                       mark_inode_dirty(inode);
-               } else {
-                       spin_unlock(&inode->i_lock);
-               }
-       }
-
-       if (err == 0)
-               *offs = offset;
-       return err;
-}
-EXPORT_SYMBOL(fsfilt_ext3_write_handle);
-
-static int fsfilt_ext3_write_record(struct file *file, void *buf, int bufsize,
-                                   loff_t *offs, int force_sync)
-{
-       struct inode *inode = file->f_dentry->d_inode;
-       handle_t *handle;
-       int err, block_count = 0, blocksize;
-
-       /* Determine how many transaction credits are needed */
-       blocksize = 1 << inode->i_blkbits;
-       block_count = (*offs & (blocksize - 1)) + bufsize;
-       block_count = (block_count + blocksize - 1) >> inode->i_blkbits;
-
-       handle = ext3_journal_start(inode,
-                       block_count * EXT3_DATA_TRANS_BLOCKS(inode->i_sb) + 2);
-       if (IS_ERR(handle)) {
-               CERROR("can't start transaction for %d blocks (%d bytes)\n",
-                      block_count * EXT3_DATA_TRANS_BLOCKS(inode->i_sb) + 2,
-                      bufsize);
-               return PTR_ERR(handle);
-       }
-
-       err = fsfilt_ext3_write_handle(inode, buf, bufsize, offs, handle);
-
-       if (!err && force_sync)
-               handle->h_sync = 1; /* recovery likes this */
-
-       ext3_journal_stop(handle);
-
-       return err;
-}
-
-static int fsfilt_ext3_setup(struct super_block *sb)
-{
-       if (!EXT3_HAS_COMPAT_FEATURE(sb,
-                               EXT3_FEATURE_COMPAT_HAS_JOURNAL)) {
-               CERROR("ext3 mounted without journal\n");
-               return -EINVAL;
-       }
-
-#ifdef S_PDIROPS
-       CWARN("Enabling PDIROPS\n");
-       set_opt(EXT3_SB(sb)->s_mount_opt, PDIROPS);
-       sb->s_flags |= S_PDIROPS;
-#endif
-       if (!EXT3_HAS_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_DIR_INDEX))
-               CWARN("filesystem doesn't have dir_index feature enabled\n");
-       return 0;
-}
-static struct fsfilt_operations fsfilt_ext3_ops = {
-       .fs_type                = "ext3",
-       .fs_owner              = THIS_MODULE,
-       .fs_getlabel        = fsfilt_ext3_get_label,
-       .fs_start              = fsfilt_ext3_start,
-       .fs_commit            = fsfilt_ext3_commit,
-       .fs_map_inode_pages     = fsfilt_ext3_map_inode_pages,
-       .fs_write_record        = fsfilt_ext3_write_record,
-       .fs_read_record  = fsfilt_ext3_read_record,
-       .fs_setup              = fsfilt_ext3_setup,
-};
-
-static int __init fsfilt_ext3_init(void)
-{
-       int rc;
-
-       fcb_cache = kmem_cache_create("fsfilt_ext3_fcb",
-                                        sizeof(struct fsfilt_cb_data), 0, 0);
-       if (!fcb_cache) {
-               CERROR("error allocating fsfilt journal callback cache\n");
-               GOTO(out, rc = -ENOMEM);
-       }
-
-       rc = fsfilt_register_ops(&fsfilt_ext3_ops);
-
-       if (rc) {
-               int err = kmem_cache_destroy(fcb_cache);
-               LASSERTF(err == 0, "error destroying new cache: rc %d\n", err);
-       }
-out:
-       return rc;
-}
-
-static void __exit fsfilt_ext3_exit(void)
-{
-       int rc;
-
-       fsfilt_unregister_ops(&fsfilt_ext3_ops);
-       rc = kmem_cache_destroy(fcb_cache);
-       LASSERTF(rc == 0, "couldn't destroy fcb_cache slab\n");
-}
-
-module_init(fsfilt_ext3_init);
-module_exit(fsfilt_ext3_exit);
-
-MODULE_AUTHOR("Sun Microsystems, Inc. <http://www.lustre.org/>");
-MODULE_DESCRIPTION("Lustre ext3 Filesystem Helper v0.1");
-MODULE_LICENSE("GPL");