updated: [258b84e] Fix just another compiling error: error: implicit declaration of function ‘generic_file_sendfile’
Patrick Winnertz
winnie at debian.org
Fri Jun 5 13:57:56 UTC 2009
The following commit has been merged in the master branch:
commit 258b84ec95be78ffd440052bb8096f3c98821040
Author: Patrick Winnertz <winnie at debian.org>
Date: Fri Jun 5 10:33:02 2009 +0200
Fix just another compiling error: error: implicit declaration of function ‘generic_file_sendfile’
Commented this function out on if kernel has no sendfile
Signed-off-by: Patrick Winnertz <winnie at debian.org>
diff --git a/debian/patches/bio_errors.dpatch b/debian/patches/bio_errors.dpatch
index 4bba9cd..86e0a31 100755
--- a/debian/patches/bio_errors.dpatch
+++ b/debian/patches/bio_errors.dpatch
@@ -2,12 +2,12 @@
## bio_errors.dpatch by Patrick Winnertz <winnie at debian.org>
##
## All lines beginning with `## DP:' are a description of the patch.
-## DP: No description.
+## DP: fix various errors when compiling the kernel module on 2.6.24.
@DPATCH@
diff -urNad lustre~/lustre/autoconf/lustre-core.m4 lustre/lustre/autoconf/lustre-core.m4
---- lustre~/lustre/autoconf/lustre-core.m4 2009-06-05 10:12:07.000000000 +0200
-+++ lustre/lustre/autoconf/lustre-core.m4 2009-06-05 10:18:54.000000000 +0200
+--- lustre~/lustre/autoconf/lustre-core.m4 2009-06-05 10:43:07.000000000 +0200
++++ lustre/lustre/autoconf/lustre-core.m4 2009-06-05 10:43:08.000000000 +0200
@@ -1390,6 +1390,41 @@
])
])
@@ -61,8 +61,8 @@ diff -urNad lustre~/lustre/autoconf/lustre-core.m4 lustre/lustre/autoconf/lustre
#
diff -urNad lustre~/lustre/include/linux/lustre_compat25.h lustre/lustre/include/linux/lustre_compat25.h
---- lustre~/lustre/include/linux/lustre_compat25.h 2009-06-05 10:12:07.000000000 +0200
-+++ lustre/lustre/include/linux/lustre_compat25.h 2009-06-05 10:12:08.000000000 +0200
+--- lustre~/lustre/include/linux/lustre_compat25.h 2009-06-05 10:43:07.000000000 +0200
++++ lustre/lustre/include/linux/lustre_compat25.h 2009-06-05 10:43:08.000000000 +0200
@@ -472,5 +472,13 @@
#define sysctl_vfs_cache_pressure 100
#endif
@@ -78,9 +78,27 @@ diff -urNad lustre~/lustre/include/linux/lustre_compat25.h lustre/lustre/include
#endif /* __KERNEL__ */
#endif /* _COMPAT25_H */
diff -urNad lustre~/lustre/llite/file.c lustre/lustre/llite/file.c
---- lustre~/lustre/llite/file.c 2009-06-05 10:12:07.000000000 +0200
-+++ lustre/lustre/llite/file.c 2009-06-05 10:15:12.000000000 +0200
-@@ -3262,7 +3262,9 @@
+--- lustre~/lustre/llite/file.c 2009-06-05 10:43:07.000000000 +0200
++++ lustre/lustre/llite/file.c 2009-06-05 10:43:08.000000000 +0200
+@@ -1858,6 +1858,9 @@
+ #endif
+ }
+
++
++
++#ifdef HAVE_KERNEL_SENDFILE
+ /*
+ * Send file content (through pagecache) somewhere with helper
+ */
+@@ -1953,6 +1956,7 @@
+ ll_tree_unlock(&tree);
+ RETURN(retval);
+ }
++#endif
+
+ static int ll_lov_recreate_obj(struct inode *inode, struct file *file,
+ unsigned long arg)
+@@ -3262,7 +3266,9 @@
.release = ll_file_release,
.mmap = ll_file_mmap,
.llseek = ll_file_seek,
@@ -90,7 +108,7 @@ diff -urNad lustre~/lustre/llite/file.c lustre/lustre/llite/file.c
.fsync = ll_fsync,
};
-@@ -3284,7 +3286,9 @@
+@@ -3284,7 +3290,9 @@
.release = ll_file_release,
.mmap = ll_file_mmap,
.llseek = ll_file_seek,
@@ -100,7 +118,7 @@ diff -urNad lustre~/lustre/llite/file.c lustre/lustre/llite/file.c
.fsync = ll_fsync,
#ifdef HAVE_F_OP_FLOCK
.flock = ll_file_flock,
-@@ -3311,7 +3315,9 @@
+@@ -3311,7 +3319,9 @@
.release = ll_file_release,
.mmap = ll_file_mmap,
.llseek = ll_file_seek,
@@ -110,3451 +128,9 @@ diff -urNad lustre~/lustre/llite/file.c lustre/lustre/llite/file.c
.fsync = ll_fsync,
#ifdef HAVE_F_OP_FLOCK
.flock = ll_file_noflock,
-diff -urNad lustre~/lustre/llite/file.c~ lustre/lustre/llite/file.c~
---- lustre~/lustre/llite/file.c~ 1970-01-01 01:00:00.000000000 +0100
-+++ lustre/lustre/llite/file.c~ 2009-06-05 10:13:34.000000000 +0200
-@@ -0,0 +1,3438 @@
-+/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-+ * vim:expandtab:shiftwidth=8:tabstop=8:
-+ *
-+ * 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 2008 Sun Microsystems, Inc. All rights reserved
-+ * Use is subject to license terms.
-+ */
-+/*
-+ * This file is part of Lustre, http://www.lustre.org/
-+ * Lustre is a trademark of Sun Microsystems, Inc.
-+ *
-+ * lustre/llite/file.c
-+ *
-+ * Author: Peter Braam <braam at clusterfs.com>
-+ * Author: Phil Schwan <phil at clusterfs.com>
-+ * Author: Andreas Dilger <adilger at clusterfs.com>
-+ */
-+
-+#define DEBUG_SUBSYSTEM S_LLITE
-+#include <lustre_dlm.h>
-+#include <lustre_lite.h>
-+#include <linux/pagemap.h>
-+#include <linux/file.h>
-+#include <linux/posix_acl.h>
-+#include "llite_internal.h"
-+#include <lustre/ll_fiemap.h>
-+
-+/* also used by llite/special.c:ll_special_open() */
-+struct ll_file_data *ll_file_data_get(void)
-+{
-+ struct ll_file_data *fd;
-+
-+ OBD_SLAB_ALLOC_PTR(fd, ll_file_data_slab);
-+ return fd;
-+}
-+
-+static void ll_file_data_put(struct ll_file_data *fd)
-+{
-+ if (fd != NULL)
-+ OBD_SLAB_FREE_PTR(fd, ll_file_data_slab);
-+}
-+
-+static int ll_close_inode_openhandle(struct inode *inode,
-+ struct obd_client_handle *och)
-+{
-+ struct ptlrpc_request *req = NULL;
-+ struct obd_device *obd;
-+ struct obdo *oa;
-+ struct mdc_op_data data = { { 0 } };
-+ int rc;
-+ ENTRY;
-+
-+ obd = class_exp2obd(ll_i2mdcexp(inode));
-+ if (obd == NULL) {
-+ CERROR("Invalid MDC connection handle "LPX64"\n",
-+ ll_i2mdcexp(inode)->exp_handle.h_cookie);
-+ GOTO(out, rc = 0);
-+ }
-+
-+ /*
-+ * here we check if this is forced umount. If so this is called on
-+ * canceling "open lock" and we do not call mdc_close() in this case, as
-+ * it will not be successful, as import is already deactivated.
-+ */
-+ if (obd->obd_force)
-+ GOTO(out, rc = 0);
-+
-+ OBDO_ALLOC(oa);
-+ if (!oa)
-+ RETURN(-ENOMEM); // XXX We leak openhandle and request here.
-+
-+ oa->o_id = inode->i_ino;
-+ oa->o_valid = OBD_MD_FLID;
-+ obdo_from_inode(oa, inode, OBD_MD_FLTYPE | OBD_MD_FLMODE |
-+ OBD_MD_FLSIZE | OBD_MD_FLBLOCKS |
-+ OBD_MD_FLATIME | OBD_MD_FLMTIME |
-+ OBD_MD_FLCTIME);
-+ if (ll_is_inode_dirty(inode)) {
-+ oa->o_flags = MDS_BFLAG_UNCOMMITTED_WRITES;
-+ oa->o_valid |= OBD_MD_FLFLAGS;
-+ }
-+ ll_inode2fid(&data.fid1, inode);
-+ rc = mdc_close(ll_i2mdcexp(inode), &data, oa, och, &req);
-+ if (rc == EAGAIN) {
-+ /* We are the last writer, so the MDS has instructed us to get
-+ * the file size and any write cookies, then close again. */
-+ ll_queue_done_writing(inode);
-+ rc = 0;
-+ } else if (rc) {
-+ CERROR("inode %lu mdc close failed: rc = %d\n",
-+ inode->i_ino, rc);
-+ }
-+
-+ OBDO_FREE(oa);
-+
-+ if (rc == 0) {
-+ rc = ll_objects_destroy(req, inode);
-+ if (rc)
-+ CERROR("inode %lu ll_objects destroy: rc = %d\n",
-+ inode->i_ino, rc);
-+ }
-+
-+ ptlrpc_req_finished(req); /* This is close request */
-+ EXIT;
-+out:
-+ mdc_clear_open_replay_data(och);
-+
-+ return rc;
-+}
-+
-+int ll_mdc_real_close(struct inode *inode, int flags)
-+{
-+ struct ll_inode_info *lli = ll_i2info(inode);
-+ int rc = 0;
-+ struct obd_client_handle **och_p;
-+ struct obd_client_handle *och;
-+ __u64 *och_usecount;
-+
-+ ENTRY;
-+
-+ if (flags & FMODE_WRITE) {
-+ och_p = &lli->lli_mds_write_och;
-+ och_usecount = &lli->lli_open_fd_write_count;
-+ } else if (flags & FMODE_EXEC) {
-+ och_p = &lli->lli_mds_exec_och;
-+ och_usecount = &lli->lli_open_fd_exec_count;
-+ } else {
-+ LASSERT(flags & FMODE_READ);
-+ och_p = &lli->lli_mds_read_och;
-+ och_usecount = &lli->lli_open_fd_read_count;
-+ }
-+
-+ down(&lli->lli_och_sem);
-+ if (*och_usecount) { /* There are still users of this handle, so
-+ skip freeing it. */
-+ up(&lli->lli_och_sem);
-+ RETURN(0);
-+ }
-+ och=*och_p;
-+ *och_p = NULL;
-+ up(&lli->lli_och_sem);
-+
-+ if (och) { /* There might be a race and somebody have freed this och
-+ already */
-+ rc = ll_close_inode_openhandle(inode, och);
-+ och->och_fh.cookie = DEAD_HANDLE_MAGIC;
-+ OBD_FREE(och, sizeof *och);
-+ }
-+
-+ RETURN(rc);
-+}
-+
-+int ll_mdc_close(struct obd_export *mdc_exp, struct inode *inode,
-+ struct file *file)
-+{
-+ struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
-+ struct ll_inode_info *lli = ll_i2info(inode);
-+ int rc = 0;
-+ ENTRY;
-+
-+ /* clear group lock, if present */
-+ if (unlikely(fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
-+ struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
-+ fd->fd_flags &= ~(LL_FILE_GROUP_LOCKED|LL_FILE_IGNORE_LOCK);
-+ rc = ll_extent_unlock(fd, inode, lsm, LCK_GROUP,
-+ &fd->fd_cwlockh);
-+ }
-+
-+ /* Let's see if we have good enough OPEN lock on the file and if
-+ we can skip talking to MDS */
-+ if (file->f_dentry->d_inode) { /* Can this ever be false? */
-+ int lockmode;
-+ int flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_TEST_LOCK;
-+ struct lustre_handle lockh;
-+ struct inode *inode = file->f_dentry->d_inode;
-+ struct ldlm_res_id file_res_id;
-+
-+ ldlm_policy_data_t policy = {.l_inodebits={MDS_INODELOCK_OPEN}};
-+ fid_build_reg_res_name(ll_inode_lu_fid(inode), &file_res_id);
-+
-+ down(&lli->lli_och_sem);
-+ if (fd->fd_omode & FMODE_WRITE) {
-+ lockmode = LCK_CW;
-+ LASSERT(lli->lli_open_fd_write_count);
-+ lli->lli_open_fd_write_count--;
-+ } else if (fd->fd_omode & FMODE_EXEC) {
-+ lockmode = LCK_PR;
-+ LASSERT(lli->lli_open_fd_exec_count);
-+ lli->lli_open_fd_exec_count--;
-+ } else {
-+ lockmode = LCK_CR;
-+ LASSERT(lli->lli_open_fd_read_count);
-+ lli->lli_open_fd_read_count--;
-+ }
-+ up(&lli->lli_och_sem);
-+
-+ if (!ldlm_lock_match(mdc_exp->exp_obd->obd_namespace, flags,
-+ &file_res_id, LDLM_IBITS, &policy,lockmode,
-+ &lockh)) {
-+ rc = ll_mdc_real_close(file->f_dentry->d_inode,
-+ fd->fd_omode);
-+ }
-+ } else {
-+ CERROR("Releasing a file %p with negative dentry %p. Name %s",
-+ file, file->f_dentry, file->f_dentry->d_name.name);
-+ }
-+
-+ LUSTRE_FPRIVATE(file) = NULL;
-+ ll_file_data_put(fd);
-+
-+ RETURN(rc);
-+}
-+
-+int lov_test_and_clear_async_rc(struct lov_stripe_md *lsm);
-+
-+/* While this returns an error code, fput() the caller does not, so we need
-+ * to make every effort to clean up all of our state here. Also, applications
-+ * rarely check close errors and even if an error is returned they will not
-+ * re-try the close call.
-+ */
-+int ll_file_release(struct inode *inode, struct file *file)
-+{
-+ struct ll_file_data *fd;
-+ struct ll_sb_info *sbi = ll_i2sbi(inode);
-+ struct ll_inode_info *lli = ll_i2info(inode);
-+ struct lov_stripe_md *lsm = lli->lli_smd;
-+ int rc;
-+ ENTRY;
-+
-+ CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p)\n", inode->i_ino,
-+ inode->i_generation, inode);
-+
-+
-+ if (inode->i_sb->s_root != file->f_dentry)
-+ ll_stats_ops_tally(sbi, LPROC_LL_RELEASE, 1);
-+ fd = LUSTRE_FPRIVATE(file);
-+ LASSERT(fd != NULL);
-+
-+ /* The last ref on @file, maybe not the the owner pid of statahead.
-+ * Different processes can open the same dir, "ll_opendir_key" means:
-+ * it is me that should stop the statahead thread. */
-+ if (lli->lli_opendir_key == fd && lli->lli_opendir_pid != 0)
-+ ll_stop_statahead(inode, lli->lli_opendir_key);
-+
-+ if (inode->i_sb->s_root == file->f_dentry) {
-+ LUSTRE_FPRIVATE(file) = NULL;
-+ ll_file_data_put(fd);
-+ RETURN(0);
-+ }
-+
-+ if (lsm)
-+ lov_test_and_clear_async_rc(lsm);
-+ lli->lli_async_rc = 0;
-+
-+ /* Ensure that dirty pages are flushed out with the right creds */
-+ if (file->f_mode & FMODE_WRITE)
-+ filemap_fdatawrite(file->f_mapping);
-+
-+ rc = ll_mdc_close(sbi->ll_mdc_exp, inode, file);
-+ RETURN(rc);
-+}
-+
-+static int ll_intent_file_open(struct file *file, void *lmm,
-+ int lmmsize, struct lookup_intent *itp)
-+{
-+ struct ll_sb_info *sbi = ll_i2sbi(file->f_dentry->d_inode);
-+ struct mdc_op_data data = { { 0 } };
-+ struct dentry *parent = file->f_dentry->d_parent;
-+ const char *name = file->f_dentry->d_name.name;
-+ const int len = file->f_dentry->d_name.len;
-+ struct inode *inode = file->f_dentry->d_inode;
-+ struct ptlrpc_request *req;
-+ int rc;
-+ ENTRY;
-+
-+ if (!parent)
-+ RETURN(-ENOENT);
-+
-+ ll_prepare_mdc_op_data(&data, parent->d_inode, inode,
-+ name, len, O_RDWR, NULL);
-+
-+ /* Usually we come here only for NFSD, and we want open lock.
-+ But we can also get here with pre 2.6.15 patchless kernels, and in
-+ that case that lock is also ok */
-+ /* We can also get here if there was cached open handle in revalidate_it
-+ * but it disappeared while we were getting from there to ll_file_open.
-+ * But this means this file was closed and immediatelly opened which
-+ * makes a good candidate for using OPEN lock */
-+ /* If lmmsize & lmm are not 0, we are just setting stripe info
-+ * parameters. No need for the open lock */
-+ if (!lmm && !lmmsize)
-+ itp->it_flags |= MDS_OPEN_LOCK;
-+
-+ rc = mdc_intent_lock(sbi->ll_mdc_exp, &data, lmm, lmmsize, itp,
-+ 0 /*unused */, &req, ll_mdc_blocking_ast, 0);
-+ if (rc == -ESTALE) {
-+ /* reason for keep own exit path - don`t flood log
-+ * with messages with -ESTALE errors.
-+ */
-+ if (!it_disposition(itp, DISP_OPEN_OPEN) ||
-+ it_open_error(DISP_OPEN_OPEN, itp))
-+ GOTO(out, rc);
-+ ll_release_openhandle(file->f_dentry, itp);
-+ GOTO(out, rc);
-+ }
-+
-+ if (rc != 0 || it_open_error(DISP_OPEN_OPEN, itp)) {
-+ rc = rc ? rc : it_open_error(DISP_OPEN_OPEN, itp);
-+ CDEBUG(D_VFSTRACE, "lock enqueue: err: %d\n", rc);
-+ GOTO(out, rc);
-+ }
-+
-+ if (itp->d.lustre.it_lock_mode)
-+ mdc_set_lock_data(&itp->d.lustre.it_lock_handle,
-+ inode);
-+
-+ rc = ll_prep_inode(sbi->ll_osc_exp, &file->f_dentry->d_inode,
-+ req, DLM_REPLY_REC_OFF, NULL);
-+out:
-+ ptlrpc_req_finished(itp->d.lustre.it_data);
-+ it_clear_disposition(itp, DISP_ENQ_COMPLETE);
-+ ll_intent_drop_lock(itp);
-+
-+ RETURN(rc);
-+}
-+
-+
-+static void ll_och_fill(struct ll_inode_info *lli, struct lookup_intent *it,
-+ struct obd_client_handle *och)
-+{
-+ struct ptlrpc_request *req = it->d.lustre.it_data;
-+ struct mds_body *body;
-+
-+ LASSERT(och);
-+
-+ body = lustre_msg_buf(req->rq_repmsg, DLM_REPLY_REC_OFF, sizeof(*body));
-+ LASSERT(body != NULL); /* reply already checked out */
-+ /* and swabbed in mdc_enqueue */
-+ LASSERT(lustre_rep_swabbed(req, DLM_REPLY_REC_OFF));
-+
-+ memcpy(&och->och_fh, &body->handle, sizeof(body->handle));
-+ och->och_magic = OBD_CLIENT_HANDLE_MAGIC;
-+ lli->lli_io_epoch = body->io_epoch;
-+
-+ mdc_set_open_replay_data(och, it->d.lustre.it_data);
-+}
-+
-+int ll_local_open(struct file *file, struct lookup_intent *it,
-+ struct ll_file_data *fd, struct obd_client_handle *och)
-+{
-+ ENTRY;
-+
-+ LASSERT(!LUSTRE_FPRIVATE(file));
-+
-+ LASSERT(fd != NULL);
-+
-+ if (och)
-+ ll_och_fill(ll_i2info(file->f_dentry->d_inode), it, och);
-+ LUSTRE_FPRIVATE(file) = fd;
-+ ll_readahead_init(file->f_dentry->d_inode, &fd->fd_ras);
-+ fd->fd_omode = it->it_flags;
-+
-+ RETURN(0);
-+}
-+
-+/* Open a file, and (for the very first open) create objects on the OSTs at
-+ * this time. If opened with O_LOV_DELAY_CREATE, then we don't do the object
-+ * creation or open until ll_lov_setstripe() ioctl is called. We grab
-+ * lli_open_sem to ensure no other process will create objects, send the
-+ * stripe MD to the MDS, or try to destroy the objects if that fails.
-+ *
-+ * If we already have the stripe MD locally then we don't request it in
-+ * mdc_open(), by passing a lmm_size = 0.
-+ *
-+ * It is up to the application to ensure no other processes open this file
-+ * in the O_LOV_DELAY_CREATE case, or the default striping pattern will be
-+ * used. We might be able to avoid races of that sort by getting lli_open_sem
-+ * before returning in the O_LOV_DELAY_CREATE case and dropping it here
-+ * or in ll_file_release(), but I'm not sure that is desirable/necessary.
-+ */
-+int ll_file_open(struct inode *inode, struct file *file)
-+{
-+ struct ll_inode_info *lli = ll_i2info(inode);
-+ struct lookup_intent *it, oit = { .it_op = IT_OPEN,
-+ .it_flags = file->f_flags };
-+ struct lov_stripe_md *lsm;
-+ struct ptlrpc_request *req = NULL;
-+ struct obd_client_handle **och_p;
-+ __u64 *och_usecount;
-+ struct ll_file_data *fd;
-+ int rc = 0, opendir_set = 0;
-+ ENTRY;
-+
-+ CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), flags %o\n", inode->i_ino,
-+ inode->i_generation, inode, file->f_flags);
-+
-+#ifdef HAVE_VFS_INTENT_PATCHES
-+ it = file->f_it;
-+#else
-+ it = file->private_data; /* XXX: compat macro */
-+ file->private_data = NULL; /* prevent ll_local_open assertion */
-+#endif
-+
-+ fd = ll_file_data_get();
-+ if (fd == NULL)
-+ RETURN(-ENOMEM);
-+
-+ if (S_ISDIR(inode->i_mode)) {
-+again:
-+ spin_lock(&lli->lli_lock);
-+ if (lli->lli_opendir_key == NULL && lli->lli_opendir_pid == 0) {
-+ LASSERT(lli->lli_sai == NULL);
-+ lli->lli_opendir_key = fd;
-+ lli->lli_opendir_pid = cfs_curproc_pid();
-+ opendir_set = 1;
-+ } else if (unlikely(lli->lli_opendir_pid == cfs_curproc_pid() &&
-+ lli->lli_opendir_key != NULL)) {
-+ /* Two cases for this:
-+ * (1) The same process open such directory many times.
-+ * (2) The old process opened the directory, and exited
-+ * before its children processes. Then new process
-+ * with the same pid opens such directory before the
-+ * old process's children processes exit.
-+ * reset stat ahead for such cases. */
-+ spin_unlock(&lli->lli_lock);
-+ CDEBUG(D_INFO, "Conflict statahead for %.*s %lu/%u"
-+ " reset it.\n", file->f_dentry->d_name.len,
-+ file->f_dentry->d_name.name,
-+ inode->i_ino, inode->i_generation);
-+ ll_stop_statahead(inode, lli->lli_opendir_key);
-+ goto again;
-+ }
-+ spin_unlock(&lli->lli_lock);
-+ }
-+
-+ if (inode->i_sb->s_root == file->f_dentry) {
-+ LUSTRE_FPRIVATE(file) = fd;
-+ RETURN(0);
-+ }
-+
-+ if (!it || !it->d.lustre.it_disposition) {
-+ /* Convert f_flags into access mode. We cannot use file->f_mode,
-+ * because everything but O_ACCMODE mask was stripped from it */
-+ if ((oit.it_flags + 1) & O_ACCMODE)
-+ oit.it_flags++;
-+ if (file->f_flags & O_TRUNC)
-+ oit.it_flags |= FMODE_WRITE;
-+
-+ /* kernel only call f_op->open in dentry_open. filp_open calls
-+ * dentry_open after call to open_namei that checks permissions.
-+ * Only nfsd_open call dentry_open directly without checking
-+ * permissions and because of that this code below is safe. */
-+ if (oit.it_flags & FMODE_WRITE)
-+ oit.it_flags |= MDS_OPEN_OWNEROVERRIDE;
-+
-+ /* We do not want O_EXCL here, presumably we opened the file
-+ * already? XXX - NFS implications? */
-+ oit.it_flags &= ~O_EXCL;
-+
-+ it = &oit;
-+ }
-+
-+restart:
-+ /* Let's see if we have file open on MDS already. */
-+ if (it->it_flags & FMODE_WRITE) {
-+ och_p = &lli->lli_mds_write_och;
-+ och_usecount = &lli->lli_open_fd_write_count;
-+ } else if (it->it_flags & FMODE_EXEC) {
-+ och_p = &lli->lli_mds_exec_och;
-+ och_usecount = &lli->lli_open_fd_exec_count;
-+ } else {
-+ och_p = &lli->lli_mds_read_och;
-+ och_usecount = &lli->lli_open_fd_read_count;
-+ }
-+
-+ LASSERTF(it->it_flags != 0, "it %p dist %d \n", it,
-+ it->d.lustre.it_disposition);
-+
-+ down(&lli->lli_och_sem);
-+ if (*och_p) { /* Open handle is present */
-+ if (it_disposition(it, DISP_OPEN_OPEN)) {
-+ /* Well, there's extra open request that we do not need,
-+ let's close it somehow. This will decref request. */
-+ rc = it_open_error(DISP_OPEN_OPEN, it);
-+ if (rc) {
-+ up(&lli->lli_och_sem);
-+ ll_file_data_put(fd);
-+ GOTO(out_openerr, rc);
-+ }
-+ ll_release_openhandle(file->f_dentry, it);
-+ lprocfs_counter_incr(ll_i2sbi(inode)->ll_stats,
-+ LPROC_LL_OPEN);
-+ }
-+ (*och_usecount)++;
-+
-+ rc = ll_local_open(file, it, fd, NULL);
-+
-+ LASSERTF(rc == 0, "rc = %d\n", rc);
-+ } else {
-+ LASSERT(*och_usecount == 0);
-+ if (!it->d.lustre.it_disposition) {
-+ /* We cannot just request lock handle now, new ELC code
-+ means that one of other OPEN locks for this file
-+ could be cancelled, and since blocking ast handler
-+ would attempt to grab och_sem as well, that would
-+ result in a deadlock */
-+ up(&lli->lli_och_sem);
-+ it->it_flags |= O_CHECK_STALE;
-+ rc = ll_intent_file_open(file, NULL, 0, it);
-+ it->it_flags &= ~O_CHECK_STALE;
-+ if (rc) {
-+ ll_file_data_put(fd);
-+ GOTO(out_openerr, rc);
-+ }
-+
-+ mdc_set_lock_data(&it->d.lustre.it_lock_handle,
-+ file->f_dentry->d_inode);
-+ goto restart;
-+ }
-+
-+ OBD_ALLOC(*och_p, sizeof (struct obd_client_handle));
-+ if (!*och_p) {
-+ ll_file_data_put(fd);
-+ GOTO(out_och_free, rc = -ENOMEM);
-+ }
-+ (*och_usecount)++;
-+ req = it->d.lustre.it_data;
-+
-+ /* mdc_intent_lock() didn't get a request ref if there was an
-+ * open error, so don't do cleanup on the request here
-+ * (bug 3430) */
-+ /* XXX (green): Should not we bail out on any error here, not
-+ * just open error? */
-+ rc = it_open_error(DISP_OPEN_OPEN, it);
-+ if (rc) {
-+ ll_file_data_put(fd);
-+ GOTO(out_och_free, rc);
-+ }
-+
-+ ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_OPEN, 1);
-+ rc = ll_local_open(file, it, fd, *och_p);
-+ LASSERTF(rc == 0, "rc = %d\n", rc);
-+ }
-+ up(&lli->lli_och_sem);
-+
-+ /* Must do this outside lli_och_sem lock to prevent deadlock where
-+ different kind of OPEN lock for this same inode gets cancelled
-+ by ldlm_cancel_lru */
-+ if (!S_ISREG(inode->i_mode))
-+ GOTO(out, rc);
-+
-+ lsm = lli->lli_smd;
-+ if (lsm == NULL) {
-+ if (file->f_flags & O_LOV_DELAY_CREATE ||
-+ !(file->f_mode & FMODE_WRITE)) {
-+ CDEBUG(D_INODE, "object creation was delayed\n");
-+ GOTO(out, rc);
-+ }
-+ }
-+ file->f_flags &= ~O_LOV_DELAY_CREATE;
-+ GOTO(out, rc);
-+ out:
-+ ptlrpc_req_finished(req);
-+ if (req)
-+ it_clear_disposition(it, DISP_ENQ_OPEN_REF);
-+ if (rc == 0) {
-+ ll_open_complete(inode);
-+ } else {
-+out_och_free:
-+ if (*och_p) {
-+ OBD_FREE(*och_p, sizeof (struct obd_client_handle));
-+ *och_p = NULL; /* OBD_FREE writes some magic there */
-+ (*och_usecount)--;
-+ }
-+ up(&lli->lli_och_sem);
-+out_openerr:
-+ if (opendir_set != 0)
-+ ll_stop_statahead(inode, lli->lli_opendir_key);
-+ }
-+
-+ return rc;
-+}
-+
-+/* Fills the obdo with the attributes for the inode defined by lsm */
-+int ll_lsm_getattr(struct obd_export *exp, struct lov_stripe_md *lsm,
-+ struct obdo *oa)
-+{
-+ struct ptlrpc_request_set *set;
-+ struct obd_info oinfo = { { { 0 } } };
-+ int rc;
-+ ENTRY;
-+
-+ LASSERT(lsm != NULL);
-+
-+ memset(oa, 0, sizeof *oa);
-+ oinfo.oi_md = lsm;
-+ oinfo.oi_oa = oa;
-+ oa->o_id = lsm->lsm_object_id;
-+ oa->o_gr = lsm->lsm_object_gr;
-+ oa->o_mode = S_IFREG;
-+ oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLSIZE |
-+ OBD_MD_FLBLOCKS | OBD_MD_FLBLKSZ | OBD_MD_FLMTIME |
-+ OBD_MD_FLCTIME | OBD_MD_FLGROUP;
-+
-+ set = ptlrpc_prep_set();
-+ if (set == NULL) {
-+ rc = -ENOMEM;
-+ } else {
-+ rc = obd_getattr_async(exp, &oinfo, set);
-+ if (rc == 0)
-+ rc = ptlrpc_set_wait(set);
-+ ptlrpc_set_destroy(set);
-+ }
-+ if (rc)
-+ RETURN(rc);
-+
-+ oa->o_valid &= (OBD_MD_FLBLOCKS | OBD_MD_FLBLKSZ | OBD_MD_FLMTIME |
-+ OBD_MD_FLCTIME | OBD_MD_FLSIZE);
-+ RETURN(0);
-+}
-+
-+static int ll_lock_to_stripe_offset(struct inode *inode, struct ldlm_lock *lock)
-+{
-+ struct ll_inode_info *lli = ll_i2info(inode);
-+ struct lov_stripe_md *lsm = lli->lli_smd;
-+ struct obd_export *exp = ll_i2obdexp(inode);
-+ struct {
-+ char name[16];
-+ struct ldlm_lock *lock;
-+ } key = { .name = KEY_LOCK_TO_STRIPE, .lock = lock };
-+ __u32 stripe, vallen = sizeof(stripe);
-+ struct lov_oinfo *loinfo;
-+ int rc;
-+ ENTRY;
-+
-+ if (lsm->lsm_stripe_count == 1)
-+ GOTO(check, stripe = 0);
-+
-+ /* get our offset in the lov */
-+ rc = obd_get_info(exp, sizeof(key), &key, &vallen, &stripe, lsm);
-+ if (rc != 0) {
-+ CERROR("obd_get_info: rc = %d\n", rc);
-+ RETURN(rc);
-+ }
-+ LASSERT(stripe < lsm->lsm_stripe_count);
-+
-+check:
-+ loinfo = lsm->lsm_oinfo[stripe];
-+ if (!osc_res_name_eq(loinfo->loi_id, loinfo->loi_gr,
-+ &lock->l_resource->lr_name)) {
-+ LDLM_ERROR(lock, "resource doesn't match object "LPU64"/"LPU64,
-+ loinfo->loi_id, loinfo->loi_gr);
-+ RETURN(-ELDLM_NO_LOCK_DATA);
-+ }
-+
-+ RETURN(stripe);
-+}
-+
-+/* Get extra page reference to ensure it is not going away */
-+void ll_pin_extent_cb(void *data)
-+{
-+ struct page *page = data;
-+
-+ page_cache_get(page);
-+
-+ return;
-+}
-+/* Flush the page from page cache for an extent as its canceled.
-+ * Page to remove is delivered as @data.
-+ *
-+ * No one can dirty the extent until we've finished our work and they cannot
-+ * enqueue another lock. The DLM protects us from ll_file_read/write here,
-+ * but other kernel actors could have pages locked.
-+ *
-+ * If @discard is set, there is no need to write the page if it is dirty.
-+ *
-+ * Called with the DLM lock held. */
-+int ll_page_removal_cb(void *data, int discard)
-+{
-+ int rc;
-+ struct page *page = data;
-+ struct address_space *mapping;
-+
-+ ENTRY;
-+
-+ /* We have page reference already from ll_pin_page */
-+ lock_page(page);
-+
-+ /* Already truncated by somebody */
-+ if (!page->mapping)
-+ GOTO(out, rc = 0);
-+
-+ mapping = page->mapping;
-+
-+ ll_teardown_mmaps(mapping,
-+ (__u64)page->index << PAGE_CACHE_SHIFT,
-+ ((__u64)page->index<<PAGE_CACHE_SHIFT)|
-+ ~PAGE_CACHE_MASK);
-+ LL_CDEBUG_PAGE(D_PAGE, page, "removing page\n");
-+ if (!discard && PageWriteback(page))
-+ wait_on_page_writeback(page);
-+
-+ if (!discard && clear_page_dirty_for_io(page)) {
-+ rc = ll_call_writepage(page->mapping->host, page);
-+ /* either waiting for io to complete or reacquiring
-+ * the lock that the failed writepage released */
-+ lock_page(page);
-+ wait_on_page_writeback(page);
-+ if (rc < 0) {
-+ CERROR("writepage inode %lu(%p) of page %p "
-+ "failed: %d\n", mapping->host->i_ino,
-+ mapping->host, page, rc);
-+ if (rc == -ENOSPC)
-+ set_bit(AS_ENOSPC, &mapping->flags);
-+ else
-+ set_bit(AS_EIO, &mapping->flags);
-+ }
-+ }
-+ if (page->mapping != NULL) {
-+ struct ll_async_page *llap = llap_cast_private(page);
-+ // checking again to account for writeback's lock_page()
-+ LL_CDEBUG_PAGE(D_PAGE, page, "truncating\n");
-+ if (llap)
-+ ll_ra_accounting(llap, page->mapping);
-+ ll_truncate_complete_page(page);
-+ }
-+ EXIT;
-+out:
-+ LASSERT(!PageWriteback(page));
-+ unlock_page(page);
-+ page_cache_release(page);
-+
-+ return 0;
-+}
-+
-+int ll_extent_lock_cancel_cb(struct ldlm_lock *lock, struct ldlm_lock_desc *new,
-+ void *data, int flag)
-+{
-+ struct inode *inode;
-+ struct ll_inode_info *lli;
-+ struct lov_stripe_md *lsm;
-+ int stripe;
-+ __u64 kms;
-+
-+ ENTRY;
-+
-+ if ((unsigned long)data > 0 && (unsigned long)data < 0x1000) {
-+ LDLM_ERROR(lock, "cancelling lock with bad data %p", data);
-+ LBUG();
-+ }
-+
-+ inode = ll_inode_from_lock(lock);
-+ if (inode == NULL)
-+ RETURN(0);
-+ lli = ll_i2info(inode);
-+ if (lli == NULL)
-+ GOTO(iput, 0);
-+ if (lli->lli_smd == NULL)
-+ GOTO(iput, 0);
-+ lsm = lli->lli_smd;
-+
-+ stripe = ll_lock_to_stripe_offset(inode, lock);
-+ if (stripe < 0)
-+ GOTO(iput, 0);
-+
-+ lov_stripe_lock(lsm);
-+ lock_res_and_lock(lock);
-+ kms = ldlm_extent_shift_kms(lock,
-+ lsm->lsm_oinfo[stripe]->loi_kms);
-+
-+ if (lsm->lsm_oinfo[stripe]->loi_kms != kms)
-+ LDLM_DEBUG(lock, "updating kms from "LPU64" to "LPU64,
-+ lsm->lsm_oinfo[stripe]->loi_kms, kms);
-+ lsm->lsm_oinfo[stripe]->loi_kms = kms;
-+ unlock_res_and_lock(lock);
-+ lov_stripe_unlock(lsm);
-+ ll_try_done_writing(inode);
-+ EXIT;
-+iput:
-+ iput(inode);
-+
-+ return 0;
-+}
-+
-+#if 0
-+int ll_async_completion_ast(struct ldlm_lock *lock, int flags, void *data)
-+{
-+ /* XXX ALLOCATE - 160 bytes */
-+ struct inode *inode = ll_inode_from_lock(lock);
-+ struct ll_inode_info *lli = ll_i2info(inode);
-+ struct lustre_handle lockh = { 0 };
-+ struct ost_lvb *lvb;
-+ int stripe;
-+ ENTRY;
-+
-+ if (flags & (LDLM_FL_BLOCK_WAIT | LDLM_FL_BLOCK_GRANTED |
-+ LDLM_FL_BLOCK_CONV)) {
-+ LBUG(); /* not expecting any blocked async locks yet */
-+ LDLM_DEBUG(lock, "client-side async enqueue returned a blocked "
-+ "lock, returning");
-+ ldlm_lock_dump(D_OTHER, lock, 0);
-+ ldlm_reprocess_all(lock->l_resource);
-+ RETURN(0);
-+ }
-+
-+ LDLM_DEBUG(lock, "client-side async enqueue: granted/glimpsed");
-+
-+ stripe = ll_lock_to_stripe_offset(inode, lock);
-+ if (stripe < 0)
-+ goto iput;
-+
-+ if (lock->l_lvb_len) {
-+ struct lov_stripe_md *lsm = lli->lli_smd;
-+ __u64 kms;
-+ lvb = lock->l_lvb_data;
-+ lsm->lsm_oinfo[stripe].loi_rss = lvb->lvb_size;
-+
-+ lock_res_and_lock(lock);
-+ ll_inode_size_lock(inode, 1);
-+ kms = MAX(lsm->lsm_oinfo[stripe].loi_kms, lvb->lvb_size);
-+ kms = ldlm_extent_shift_kms(NULL, kms);
-+ if (lsm->lsm_oinfo[stripe].loi_kms != kms)
-+ LDLM_DEBUG(lock, "updating kms from "LPU64" to "LPU64,
-+ lsm->lsm_oinfo[stripe].loi_kms, kms);
-+ lsm->lsm_oinfo[stripe].loi_kms = kms;
-+ ll_inode_size_unlock(inode, 1);
-+ unlock_res_and_lock(lock);
-+ }
-+
-+iput:
-+ iput(inode);
-+ wake_up(&lock->l_waitq);
-+
-+ ldlm_lock2handle(lock, &lockh);
-+ ldlm_lock_decref(&lockh, LCK_PR);
-+ RETURN(0);
-+}
-+#endif
-+
-+static int ll_glimpse_callback(struct ldlm_lock *lock, void *reqp)
-+{
-+ struct ptlrpc_request *req = reqp;
-+ struct inode *inode = ll_inode_from_lock(lock);
-+ struct ll_inode_info *lli;
-+ struct lov_stripe_md *lsm;
-+ struct ost_lvb *lvb;
-+ int rc, stripe;
-+ int size[2] = { sizeof(struct ptlrpc_body), sizeof(*lvb) };
-+ ENTRY;
-+
-+ if (inode == NULL)
-+ GOTO(out, rc = -ELDLM_NO_LOCK_DATA);
-+ lli = ll_i2info(inode);
-+ if (lli == NULL)
-+ GOTO(iput, rc = -ELDLM_NO_LOCK_DATA);
-+ lsm = lli->lli_smd;
-+ if (lsm == NULL)
-+ GOTO(iput, rc = -ELDLM_NO_LOCK_DATA);
-+
-+ /* First, find out which stripe index this lock corresponds to. */
-+ stripe = ll_lock_to_stripe_offset(inode, lock);
-+ if (stripe < 0)
-+ GOTO(iput, rc = -ELDLM_NO_LOCK_DATA);
-+
-+ rc = lustre_pack_reply(req, 2, size, NULL);
-+ if (rc)
-+ GOTO(iput, rc);
-+
-+ lvb = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(*lvb));
-+ lvb->lvb_size = lli->lli_smd->lsm_oinfo[stripe]->loi_kms;
-+ lvb->lvb_mtime = LTIME_S(inode->i_mtime);
-+ lvb->lvb_atime = LTIME_S(inode->i_atime);
-+ lvb->lvb_ctime = LTIME_S(inode->i_ctime);
-+
-+ LDLM_DEBUG(lock, "i_size: %llu -> stripe number %u -> kms "LPU64
-+ " atime "LPU64", mtime "LPU64", ctime "LPU64,
-+ i_size_read(inode), stripe, lvb->lvb_size, lvb->lvb_atime,
-+ lvb->lvb_mtime, lvb->lvb_ctime);
-+ iput:
-+ iput(inode);
-+
-+ out:
-+ /* These errors are normal races, so we don't want to fill the console
-+ * with messages by calling ptlrpc_error() */
-+ if (rc == -ELDLM_NO_LOCK_DATA)
-+ lustre_pack_reply(req, 1, NULL, NULL);
-+
-+ req->rq_status = rc;
-+ return rc;
-+}
-+
-+int ll_glimpse_ioctl(struct ll_sb_info *sbi, struct lov_stripe_md *lsm,
-+ lstat_t *st)
-+{
-+ struct lustre_handle lockh = { 0 };
-+ struct ldlm_enqueue_info einfo = { 0 };
-+ struct obd_info oinfo = { { { 0 } } };
-+ struct ost_lvb lvb;
-+ int rc;
-+
-+ ENTRY;
-+
-+ einfo.ei_type = LDLM_EXTENT;
-+ einfo.ei_mode = LCK_PR;
-+ einfo.ei_cb_bl = osc_extent_blocking_cb;
-+ einfo.ei_cb_cp = ldlm_completion_ast;
-+ einfo.ei_cb_gl = ll_glimpse_callback;
-+ einfo.ei_cbdata = NULL;
-+
-+ oinfo.oi_policy.l_extent.end = OBD_OBJECT_EOF;
-+ oinfo.oi_lockh = &lockh;
-+ oinfo.oi_md = lsm;
-+ oinfo.oi_flags = LDLM_FL_HAS_INTENT;
-+
-+ rc = obd_enqueue_rqset(sbi->ll_osc_exp, &oinfo, &einfo);
-+ if (rc == -ENOENT)
-+ RETURN(rc);
-+ if (rc != 0) {
-+ CERROR("obd_enqueue returned rc %d, "
-+ "returning -EIO\n", rc);
-+ RETURN(rc > 0 ? -EIO : rc);
-+ }
-+
-+ lov_stripe_lock(lsm);
-+ memset(&lvb, 0, sizeof(lvb));
-+ obd_merge_lvb(sbi->ll_osc_exp, lsm, &lvb, 0);
-+ st->st_size = lvb.lvb_size;
-+ st->st_blocks = lvb.lvb_blocks;
-+ st->st_mtime = lvb.lvb_mtime;
-+ st->st_atime = lvb.lvb_atime;
-+ st->st_ctime = lvb.lvb_ctime;
-+ lov_stripe_unlock(lsm);
-+
-+ RETURN(rc);
-+}
-+
-+/* NB: obd_merge_lvb will prefer locally cached writes if they extend the
-+ * file (because it prefers KMS over RSS when larger) */
-+int ll_glimpse_size(struct inode *inode, int ast_flags)
-+{
-+ struct ll_inode_info *lli = ll_i2info(inode);
-+ struct ll_sb_info *sbi = ll_i2sbi(inode);
-+ struct lustre_handle lockh = { 0 };
-+ struct ldlm_enqueue_info einfo = { 0 };
-+ struct obd_info oinfo = { { { 0 } } };
-+ struct ost_lvb lvb;
-+ int rc;
-+ ENTRY;
-+
-+ CDEBUG(D_DLMTRACE, "Glimpsing inode %lu\n", inode->i_ino);
-+
-+ if (!lli->lli_smd) {
-+ CDEBUG(D_DLMTRACE, "No objects for inode %lu\n", inode->i_ino);
-+ RETURN(0);
-+ }
-+
-+ /* NOTE: this looks like DLM lock request, but it may not be one. Due
-+ * to LDLM_FL_HAS_INTENT flag, this is glimpse request, that
-+ * won't revoke any conflicting DLM locks held. Instead,
-+ * ll_glimpse_callback() will be called on each client
-+ * holding a DLM lock against this file, and resulting size
-+ * will be returned for each stripe. DLM lock on [0, EOF] is
-+ * acquired only if there were no conflicting locks. */
-+ einfo.ei_type = LDLM_EXTENT;
-+ einfo.ei_mode = LCK_PR;
-+ einfo.ei_cb_bl = osc_extent_blocking_cb;
-+ einfo.ei_cb_cp = ldlm_completion_ast;
-+ einfo.ei_cb_gl = ll_glimpse_callback;
-+ einfo.ei_cbdata = inode;
-+
-+ oinfo.oi_policy.l_extent.end = OBD_OBJECT_EOF;
-+ oinfo.oi_lockh = &lockh;
-+ oinfo.oi_md = lli->lli_smd;
-+ oinfo.oi_flags = ast_flags | LDLM_FL_HAS_INTENT;
-+
-+ rc = obd_enqueue_rqset(sbi->ll_osc_exp, &oinfo, &einfo);
-+ if (rc == -ENOENT)
-+ RETURN(rc);
-+ if (rc != 0) {
-+ CERROR("obd_enqueue returned rc %d, returning -EIO\n", rc);
-+ RETURN(rc > 0 ? -EIO : rc);
-+ }
-+
-+ ll_inode_size_lock(inode, 1);
-+ inode_init_lvb(inode, &lvb);
-+ /* merge timestamps the most resently obtained from mds with
-+ timestamps obtained from osts */
-+ lvb.lvb_atime = lli->lli_lvb.lvb_atime;
-+ lvb.lvb_mtime = lli->lli_lvb.lvb_mtime;
-+ lvb.lvb_ctime = lli->lli_lvb.lvb_ctime;
-+ rc = obd_merge_lvb(sbi->ll_osc_exp, lli->lli_smd, &lvb, 0);
-+ i_size_write(inode, lvb.lvb_size);
-+ inode->i_blocks = lvb.lvb_blocks;
-+ LTIME_S(inode->i_mtime) = lvb.lvb_mtime;
-+ LTIME_S(inode->i_atime) = lvb.lvb_atime;
-+ LTIME_S(inode->i_ctime) = lvb.lvb_ctime;
-+ ll_inode_size_unlock(inode, 1);
-+
-+ CDEBUG(D_DLMTRACE, "glimpse: size: %llu, blocks: %llu\n",
-+ i_size_read(inode), (long long)inode->i_blocks);
-+
-+ RETURN(rc);
-+}
-+
-+int ll_extent_lock(struct ll_file_data *fd, struct inode *inode,
-+ struct lov_stripe_md *lsm, int mode,
-+ ldlm_policy_data_t *policy, struct lustre_handle *lockh,
-+ int ast_flags)
-+{
-+ struct ll_sb_info *sbi = ll_i2sbi(inode);
-+ struct ost_lvb lvb;
-+ struct ldlm_enqueue_info einfo = { 0 };
-+ struct obd_info oinfo = { { { 0 } } };
-+ int rc;
-+ ENTRY;
-+
-+ LASSERT(!lustre_handle_is_used(lockh));
-+ LASSERT(lsm != NULL);
-+
-+ /* don't drop the mmapped file to LRU */
-+ if (mapping_mapped(inode->i_mapping))
-+ ast_flags |= LDLM_FL_NO_LRU;
-+
-+ /* XXX phil: can we do this? won't it screw the file size up? */
-+ if ((fd && (fd->fd_flags & LL_FILE_IGNORE_LOCK)) ||
-+ (sbi->ll_flags & LL_SBI_NOLCK))
-+ RETURN(0);
-+
-+ CDEBUG(D_DLMTRACE, "Locking inode %lu, start "LPU64" end "LPU64"\n",
-+ inode->i_ino, policy->l_extent.start, policy->l_extent.end);
-+
-+ einfo.ei_type = LDLM_EXTENT;
-+ einfo.ei_mode = mode;
-+ einfo.ei_cb_bl = osc_extent_blocking_cb;
-+ einfo.ei_cb_cp = ldlm_completion_ast;
-+ einfo.ei_cb_gl = ll_glimpse_callback;
-+ einfo.ei_cbdata = inode;
-+
-+ oinfo.oi_policy = *policy;
-+ oinfo.oi_lockh = lockh;
-+ oinfo.oi_md = lsm;
-+ oinfo.oi_flags = ast_flags;
-+
-+ rc = obd_enqueue(sbi->ll_osc_exp, &oinfo, &einfo, NULL);
-+ *policy = oinfo.oi_policy;
-+ if (rc > 0)
-+ rc = -EIO;
-+
-+ ll_inode_size_lock(inode, 1);
-+ inode_init_lvb(inode, &lvb);
-+ obd_merge_lvb(sbi->ll_osc_exp, lsm, &lvb, 1);
-+
-+ if (policy->l_extent.start == 0 &&
-+ policy->l_extent.end == OBD_OBJECT_EOF) {
-+ /* vmtruncate()->ll_truncate() first sets the i_size and then
-+ * the kms under both a DLM lock and the
-+ * ll_inode_size_lock(). If we don't get the
-+ * ll_inode_size_lock() here we can match the DLM lock and
-+ * reset i_size from the kms before the truncating path has
-+ * updated the kms. generic_file_write can then trust the
-+ * stale i_size when doing appending writes and effectively
-+ * cancel the result of the truncate. Getting the
-+ * ll_inode_size_lock() after the enqueue maintains the DLM
-+ * -> ll_inode_size_lock() acquiring order. */
-+ i_size_write(inode, lvb.lvb_size);
-+ CDEBUG(D_INODE, "inode=%lu, updating i_size %llu\n",
-+ inode->i_ino, i_size_read(inode));
-+ }
-+
-+ if (rc == 0) {
-+ LTIME_S(inode->i_mtime) = lvb.lvb_mtime;
-+ LTIME_S(inode->i_atime) = lvb.lvb_atime;
-+ LTIME_S(inode->i_ctime) = lvb.lvb_ctime;
-+ }
-+ ll_inode_size_unlock(inode, 1);
-+
-+ RETURN(rc);
-+}
-+
-+int ll_extent_unlock(struct ll_file_data *fd, struct inode *inode,
-+ struct lov_stripe_md *lsm, int mode,
-+ struct lustre_handle *lockh)
-+{
-+ struct ll_sb_info *sbi = ll_i2sbi(inode);
-+ int rc;
-+ ENTRY;
-+
-+ /* XXX phil: can we do this? won't it screw the file size up? */
-+ if ((fd && (fd->fd_flags & LL_FILE_IGNORE_LOCK)) ||
-+ (sbi->ll_flags & LL_SBI_NOLCK))
-+ RETURN(0);
-+
-+ rc = obd_cancel(sbi->ll_osc_exp, lsm, mode, lockh);
-+
-+ RETURN(rc);
-+}
-+
-+static void ll_set_file_contended(struct inode *inode)
-+{
-+ struct ll_inode_info *lli = ll_i2info(inode);
-+
-+ lli->lli_contention_time = cfs_time_current();
-+ set_bit(LLI_F_CONTENDED, &lli->lli_flags);
-+}
-+
-+void ll_clear_file_contended(struct inode *inode)
-+{
-+ struct ll_inode_info *lli = ll_i2info(inode);
-+
-+ clear_bit(LLI_F_CONTENDED, &lli->lli_flags);
-+}
-+
-+static int ll_is_file_contended(struct file *file)
-+{
-+ struct inode *inode = file->f_dentry->d_inode;
-+ struct ll_inode_info *lli = ll_i2info(inode);
-+ struct ll_sb_info *sbi = ll_i2sbi(inode);
-+ struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
-+ ENTRY;
-+
-+ if (!(sbi->ll_lco.lco_flags & OBD_CONNECT_SRVLOCK)) {
-+ CDEBUG(D_INFO, "the server does not support SRVLOCK feature,"
-+ " osc connect flags = 0x"LPX64"\n",
-+ sbi->ll_lco.lco_flags);
-+ RETURN(0);
-+ }
-+ if (fd && (fd->fd_flags & LL_FILE_IGNORE_LOCK))
-+ RETURN(0);
-+ if (test_bit(LLI_F_CONTENDED, &lli->lli_flags)) {
-+ cfs_time_t cur_time = cfs_time_current();
-+ cfs_time_t retry_time;
-+
-+ retry_time = cfs_time_add(
-+ lli->lli_contention_time,
-+ cfs_time_seconds(sbi->ll_contention_time));
-+ if (cfs_time_after(cur_time, retry_time)) {
-+ ll_clear_file_contended(inode);
-+ RETURN(0);
-+ }
-+ RETURN(1);
-+ }
-+ RETURN(0);
-+}
-+
-+static int ll_file_get_tree_lock_iov(struct ll_lock_tree *tree,
-+ struct file *file, const struct iovec *iov,
-+ unsigned long nr_segs,
-+ obd_off start, obd_off end, int rw)
-+{
-+ int append;
-+ int tree_locked = 0;
-+ int rc;
-+ struct inode * inode = file->f_dentry->d_inode;
-+ ENTRY;
-+
-+ append = (rw == OBD_BRW_WRITE) && (file->f_flags & O_APPEND);
-+
-+ if (append || !ll_is_file_contended(file)) {
-+ struct ll_lock_tree_node *node;
-+ int ast_flags;
-+
-+ ast_flags = append ? 0 : LDLM_FL_DENY_ON_CONTENTION;
-+ if (file->f_flags & O_NONBLOCK)
-+ ast_flags |= LDLM_FL_BLOCK_NOWAIT;
-+ node = ll_node_from_inode(inode, start, end,
-+ (rw == OBD_BRW_WRITE) ? LCK_PW : LCK_PR);
-+ if (IS_ERR(node)) {
-+ rc = PTR_ERR(node);
-+ GOTO(out, rc);
-+ }
-+ tree->lt_fd = LUSTRE_FPRIVATE(file);
-+ rc = ll_tree_lock_iov(tree, node, iov, nr_segs, ast_flags);
-+ if (rc == 0)
-+ tree_locked = 1;
-+ else if (rc == -EUSERS)
-+ ll_set_file_contended(inode);
-+ else
-+ GOTO(out, rc);
-+ }
-+ RETURN(tree_locked);
-+out:
-+ return rc;
-+}
-+
-+/* XXX: exact copy from kernel code (__generic_file_aio_write_nolock from rhel4)
-+ */
-+static size_t ll_file_get_iov_count(const struct iovec *iov,
-+ unsigned long *nr_segs)
-+{
-+ size_t count = 0;
-+ unsigned long seg;
-+
-+ for (seg = 0; seg < *nr_segs; seg++) {
-+ const struct iovec *iv = &iov[seg];
-+
-+ /*
-+ * If any segment has a negative length, or the cumulative
-+ * length ever wraps negative then return -EINVAL.
-+ */
-+ count += iv->iov_len;
-+ if (unlikely((ssize_t)(count|iv->iov_len) < 0))
-+ return -EINVAL;
-+ if (access_ok(VERIFY_WRITE, iv->iov_base, iv->iov_len))
-+ continue;
-+ if (seg == 0)
-+ return -EFAULT;
-+ *nr_segs = seg;
-+ count -= iv->iov_len; /* This segment is no good */
-+ break;
-+ }
-+ return count;
-+}
-+
-+static int iov_copy_update(unsigned long *nr_segs, const struct iovec **iov_out,
-+ unsigned long *nrsegs_copy,
-+ struct iovec *iov_copy, size_t *offset,
-+ size_t size)
-+{
-+ int i;
-+ const struct iovec *iov = *iov_out;
-+ for (i = 0; i < *nr_segs;
-+ i++) {
-+ const struct iovec *iv = &iov[i];
-+ struct iovec *ivc = &iov_copy[i];
-+ *ivc = *iv;
-+ if (i == 0) {
-+ ivc->iov_len -= *offset;
-+ ivc->iov_base += *offset;
-+ }
-+ if (ivc->iov_len >= size) {
-+ ivc->iov_len = size;
-+ if (i == 0)
-+ *offset += size;
-+ else
-+ *offset = size;
-+ break;
-+ }
-+ size -= ivc->iov_len;
-+ }
-+ *iov_out += i;
-+ *nr_segs -= i;
-+ *nrsegs_copy = i + 1;
-+
-+ return 0;
-+}
-+
-+static int ll_reget_short_lock(struct page *page, int rw,
-+ obd_off start, obd_off end,
-+ void **cookie)
-+{
-+ struct ll_async_page *llap;
-+ struct obd_export *exp;
-+ struct inode *inode = page->mapping->host;
-+
-+ ENTRY;
-+
-+ exp = ll_i2obdexp(inode);
-+ if (exp == NULL)
-+ RETURN(0);
-+
-+ llap = llap_cast_private(page);
-+ if (llap == NULL)
-+ RETURN(0);
-+
-+ RETURN(obd_reget_short_lock(exp, ll_i2info(inode)->lli_smd,
-+ &llap->llap_cookie, rw, start, end,
-+ cookie));
-+}
-+
-+static void ll_release_short_lock(struct inode *inode, obd_off end,
-+ void *cookie, int rw)
-+{
-+ struct obd_export *exp;
-+ int rc;
-+
-+ exp = ll_i2obdexp(inode);
-+ if (exp == NULL)
-+ return;
-+
-+ rc = obd_release_short_lock(exp, ll_i2info(inode)->lli_smd, end,
-+ cookie, rw);
-+ if (rc < 0)
-+ CERROR("unlock failed (%d)\n", rc);
-+}
-+
-+static inline int ll_file_get_fast_lock(struct file *file,
-+ obd_off ppos, obd_off end,
-+ const struct iovec *iov,
-+ unsigned long nr_segs,
-+ void **cookie, int rw)
-+{
-+ int rc = 0, seg;
-+ struct page *page;
-+
-+ ENTRY;
-+
-+ /* we would like this read request to be lockfree */
-+ for (seg = 0; seg < nr_segs; seg++) {
-+ const struct iovec *iv = &iov[seg];
-+ if (ll_region_mapped((unsigned long)iv->iov_base, iv->iov_len))
-+ GOTO(out, rc);
-+ }
-+
-+ page = find_lock_page(file->f_dentry->d_inode->i_mapping,
-+ ppos >> CFS_PAGE_SHIFT);
-+ if (page) {
-+ if (ll_reget_short_lock(page, rw, ppos, end, cookie))
-+ rc = 1;
-+
-+ unlock_page(page);
-+ page_cache_release(page);
-+ }
-+
-+out:
-+ RETURN(rc);
-+}
-+
-+static inline void ll_file_put_fast_lock(struct inode *inode, obd_off end,
-+ void *cookie, int rw)
-+{
-+ ll_release_short_lock(inode, end, cookie, rw);
-+}
-+
-+enum ll_lock_style {
-+ LL_LOCK_STYLE_NOLOCK = 0,
-+ LL_LOCK_STYLE_FASTLOCK = 1,
-+ LL_LOCK_STYLE_TREELOCK = 2
-+};
-+
-+static inline int ll_file_get_lock(struct file *file, obd_off ppos,
-+ obd_off end, const struct iovec *iov,
-+ unsigned long nr_segs, void **cookie,
-+ struct ll_lock_tree *tree, int rw)
-+{
-+ int rc;
-+
-+ ENTRY;
-+
-+ if (ll_file_get_fast_lock(file, ppos, end, iov, nr_segs, cookie, rw))
-+ RETURN(LL_LOCK_STYLE_FASTLOCK);
-+
-+ rc = ll_file_get_tree_lock_iov(tree, file, iov, nr_segs,
-+ ppos, end, rw);
-+ /* rc: 1 for tree lock, 0 for no lock, <0 for error */
-+ switch (rc) {
-+ case 1:
-+ RETURN(LL_LOCK_STYLE_TREELOCK);
-+ case 0:
-+ RETURN(LL_LOCK_STYLE_NOLOCK);
-+ }
-+
-+ /* an error happened if we reached this point, rc = -errno here */
-+ RETURN(rc);
-+}
-+
-+static inline void ll_file_put_lock(struct inode *inode, obd_off end,
-+ enum ll_lock_style lock_style,
-+ void *cookie, struct ll_lock_tree *tree,
-+ int rw)
-+
-+{
-+ switch (lock_style) {
-+ case LL_LOCK_STYLE_TREELOCK:
-+ ll_tree_unlock(tree);
-+ break;
-+ case LL_LOCK_STYLE_FASTLOCK:
-+ ll_file_put_fast_lock(inode, end, cookie, rw);
-+ break;
-+ default:
-+ CERROR("invalid locking style (%d)\n", lock_style);
-+ }
-+}
-+
-+#ifdef HAVE_FILE_READV
-+static ssize_t ll_file_readv(struct file *file, const struct iovec *iov,
-+ unsigned long nr_segs, loff_t *ppos)
-+{
-+#else
-+static ssize_t ll_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
-+ unsigned long nr_segs, loff_t pos)
-+{
-+ struct file *file = iocb->ki_filp;
-+ loff_t *ppos = &iocb->ki_pos;
-+#endif
-+ struct inode *inode = file->f_dentry->d_inode;
-+ struct ll_inode_info *lli = ll_i2info(inode);
-+ struct lov_stripe_md *lsm = lli->lli_smd;
-+ struct ll_sb_info *sbi = ll_i2sbi(inode);
-+ struct ll_lock_tree tree;
-+ struct ost_lvb lvb;
-+ struct ll_ra_read bead;
-+ int ra = 0;
-+ obd_off end;
-+ ssize_t retval, chunk, sum = 0;
-+ int lock_style;
-+ struct iovec *iov_copy = NULL;
-+ unsigned long nrsegs_copy, nrsegs_orig = 0;
-+ size_t count, iov_offset = 0;
-+ __u64 kms;
-+ void *cookie;
-+ ENTRY;
-+
-+ count = ll_file_get_iov_count(iov, &nr_segs);
-+ CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),size="LPSZ",offset=%Ld\n",
-+ inode->i_ino, inode->i_generation, inode, count, *ppos);
-+ /* "If nbyte is 0, read() will return 0 and have no other results."
-+ * -- Single Unix Spec */
-+ if (count == 0)
-+ RETURN(0);
-+
-+ ll_stats_ops_tally(sbi, LPROC_LL_READ_BYTES, count);
-+
-+ if (!lsm) {
-+ /* Read on file with no objects should return zero-filled
-+ * buffers up to file size (we can get non-zero sizes with
-+ * mknod + truncate, then opening file for read. This is a
-+ * common pattern in NFS case, it seems). Bug 6243 */
-+ int notzeroed;
-+ /* Since there are no objects on OSTs, we have nothing to get
-+ * lock on and so we are forced to access inode->i_size
-+ * unguarded */
-+
-+ /* Read beyond end of file */
-+ if (*ppos >= i_size_read(inode))
-+ RETURN(0);
-+
-+ if (count > i_size_read(inode) - *ppos)
-+ count = i_size_read(inode) - *ppos;
-+ /* Make sure to correctly adjust the file pos pointer for
-+ * EFAULT case */
-+ for (nrsegs_copy = 0; nrsegs_copy < nr_segs; nrsegs_copy++) {
-+ const struct iovec *iv = &iov[nrsegs_copy];
-+
-+ if (count < iv->iov_len)
-+ chunk = count;
-+ else
-+ chunk = iv->iov_len;
-+ notzeroed = clear_user(iv->iov_base, chunk);
-+ sum += (chunk - notzeroed);
-+ count -= (chunk - notzeroed);
-+ if (notzeroed || !count)
-+ break;
-+ }
-+ *ppos += sum;
-+ if (!sum)
-+ RETURN(-EFAULT);
-+ RETURN(sum);
-+ }
-+
-+repeat:
-+ if (sbi->ll_max_rw_chunk != 0) {
-+ /* first, let's know the end of the current stripe */
-+ end = *ppos;
-+ obd_extent_calc(sbi->ll_osc_exp, lsm, OBD_CALC_STRIPE_END,&end);
-+
-+ /* correct, the end is beyond the request */
-+ if (end > *ppos + count - 1)
-+ end = *ppos + count - 1;
-+
-+ /* and chunk shouldn't be too large even if striping is wide */
-+ if (end - *ppos > sbi->ll_max_rw_chunk)
-+ end = *ppos + sbi->ll_max_rw_chunk - 1;
-+
-+ chunk = end - *ppos + 1;
-+ if ((count == chunk) && (iov_offset == 0)) {
-+ if (iov_copy)
-+ OBD_FREE(iov_copy, sizeof(*iov) * nrsegs_orig);
-+
-+ iov_copy = (struct iovec *)iov;
-+ nrsegs_copy = nr_segs;
-+ } else {
-+ if (!iov_copy) {
-+ nrsegs_orig = nr_segs;
-+ OBD_ALLOC(iov_copy, sizeof(*iov) * nr_segs);
-+ if (!iov_copy)
-+ GOTO(out, retval = -ENOMEM);
-+ }
-+
-+ iov_copy_update(&nr_segs, &iov, &nrsegs_copy, iov_copy,
-+ &iov_offset, chunk);
-+ }
-+ } else {
-+ end = *ppos + count - 1;
-+ iov_copy = (struct iovec *)iov;
-+ nrsegs_copy = nr_segs;
-+ }
-+
-+ lock_style = ll_file_get_lock(file, (obd_off)(*ppos), end,
-+ iov_copy, nrsegs_copy, &cookie, &tree,
-+ OBD_BRW_READ);
-+ if (lock_style < 0)
-+ GOTO(out, retval = lock_style);
-+
-+ ll_inode_size_lock(inode, 1);
-+ /*
-+ * Consistency guarantees: following possibilities exist for the
-+ * relation between region being read and real file size at this
-+ * moment:
-+ *
-+ * (A): the region is completely inside of the file;
-+ *
-+ * (B-x): x bytes of region are inside of the file, the rest is
-+ * outside;
-+ *
-+ * (C): the region is completely outside of the file.
-+ *
-+ * This classification is stable under DLM lock acquired by
-+ * ll_tree_lock() above, because to change class, other client has to
-+ * take DLM lock conflicting with our lock. Also, any updates to
-+ * ->i_size by other threads on this client are serialized by
-+ * ll_inode_size_lock(). This guarantees that short reads are handled
-+ * correctly in the face of concurrent writes and truncates.
-+ */
-+ inode_init_lvb(inode, &lvb);
-+ obd_merge_lvb(ll_i2sbi(inode)->ll_osc_exp, lsm, &lvb, 1);
-+ kms = lvb.lvb_size;
-+ if (*ppos + count - 1 > kms) {
-+ /* A glimpse is necessary to determine whether we return a
-+ * short read (B) or some zeroes at the end of the buffer (C) */
-+ ll_inode_size_unlock(inode, 1);
-+ retval = ll_glimpse_size(inode, LDLM_FL_BLOCK_GRANTED);
-+ if (retval) {
-+ if (lock_style != LL_LOCK_STYLE_NOLOCK)
-+ ll_file_put_lock(inode, end, lock_style,
-+ cookie, &tree, OBD_BRW_READ);
-+ goto out;
-+ }
-+ } else {
-+ /* region is within kms and, hence, within real file size (A).
-+ * We need to increase i_size to cover the read region so that
-+ * generic_file_read() will do its job, but that doesn't mean
-+ * the kms size is _correct_, it is only the _minimum_ size.
-+ * If someone does a stat they will get the correct size which
-+ * will always be >= the kms value here. b=11081 */
-+ if (i_size_read(inode) < kms)
-+ i_size_write(inode, kms);
-+ ll_inode_size_unlock(inode, 1);
-+ }
-+
-+ chunk = end - *ppos + 1;
-+ CDEBUG(D_INODE,"Read ino %lu, "LPSZ" bytes, offset %lld, i_size %llu\n",
-+ inode->i_ino, chunk, *ppos, i_size_read(inode));
-+
-+ /* turn off the kernel's read-ahead */
-+ if (lock_style != LL_LOCK_STYLE_NOLOCK) {
-+ /* read under locks
-+ *
-+ * 1. update inode's atime as long as concurrent stat
-+ * (via ll_glimpse_size) might bring out-of-date ones
-+ *
-+ * 2. update lsm so that next stat (via
-+ * ll_glimpse_size) could get correct values in lsm */
-+ struct ost_lvb xtimes;
-+
-+ lov_stripe_lock(lsm);
-+ LTIME_S(inode->i_atime) = LTIME_S(CURRENT_TIME);
-+ xtimes.lvb_atime = LTIME_S(inode->i_atime);
-+ obd_update_lvb(sbi->ll_osc_exp, lsm, &xtimes,
-+ OBD_MD_FLATIME);
-+ lov_stripe_unlock(lsm);
-+
-+ file->f_ra.ra_pages = 0;
-+ /* initialize read-ahead window once per syscall */
-+ if (ra == 0) {
-+ ra = 1;
-+ bead.lrr_start = *ppos >> CFS_PAGE_SHIFT;
-+ bead.lrr_count = (count + CFS_PAGE_SIZE - 1) >> CFS_PAGE_SHIFT;
-+ ll_ra_read_in(file, &bead);
-+ }
-+
-+ /* BUG: 5972 */
-+ file_accessed(file);
-+#ifdef HAVE_FILE_READV
-+ retval = generic_file_readv(file, iov_copy, nrsegs_copy, ppos);
-+#else
-+ retval = generic_file_aio_read(iocb, iov_copy, nrsegs_copy,
-+ *ppos);
-+#endif
-+ ll_file_put_lock(inode, end, lock_style, cookie,
-+ &tree, OBD_BRW_READ);
-+ } else {
-+ /* lockless read
-+ *
-+ * current time will get into request as atime
-+ * (lustre/osc/osc_request.c:osc_build_request())
-+ */
-+ retval = ll_file_lockless_io(file, iov_copy, nrsegs_copy, ppos,
-+ READ, chunk);
-+ }
-+ ll_rw_stats_tally(sbi, current->pid, file, count, 0);
-+ if (retval > 0) {
-+ count -= retval;
-+ sum += retval;
-+ if (retval == chunk && count > 0)
-+ goto repeat;
-+ }
-+
-+ out:
-+ if (ra != 0)
-+ ll_ra_read_ex(file, &bead);
-+ retval = (sum > 0) ? sum : retval;
-+
-+ if (iov_copy && iov_copy != iov)
-+ OBD_FREE(iov_copy, sizeof(*iov) * nrsegs_orig);
-+
-+ RETURN(retval);
-+}
-+
-+static ssize_t ll_file_read(struct file *file, char *buf, size_t count,
-+ loff_t *ppos)
-+{
-+ struct iovec local_iov = { .iov_base = (void __user *)buf,
-+ .iov_len = count };
-+#ifdef HAVE_FILE_READV
-+ return ll_file_readv(file, &local_iov, 1, ppos);
-+#else
-+ struct kiocb kiocb;
-+ ssize_t ret;
-+
-+ init_sync_kiocb(&kiocb, file);
-+ kiocb.ki_pos = *ppos;
-+ kiocb.ki_left = count;
-+
-+ ret = ll_file_aio_read(&kiocb, &local_iov, 1, kiocb.ki_pos);
-+ *ppos = kiocb.ki_pos;
-+ return ret;
-+#endif
-+}
-+
-+/*
-+ * Write to a file (through the page cache).
-+ */
-+#ifdef HAVE_FILE_WRITEV
-+static ssize_t ll_file_writev(struct file *file, const struct iovec *iov,
-+ unsigned long nr_segs, loff_t *ppos)
-+{
-+#else /* AIO stuff */
-+static ssize_t ll_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
-+ unsigned long nr_segs, loff_t pos)
-+{
-+ struct file *file = iocb->ki_filp;
-+ loff_t *ppos = &iocb->ki_pos;
-+#endif
-+ struct inode *inode = file->f_dentry->d_inode;
-+ struct ll_sb_info *sbi = ll_i2sbi(inode);
-+ struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
-+ struct ll_lock_tree tree;
-+ loff_t maxbytes = ll_file_maxbytes(inode);
-+ loff_t lock_start, lock_end, end;
-+ ssize_t retval, chunk, sum = 0;
-+ int tree_locked;
-+ struct iovec *iov_copy = NULL;
-+ unsigned long nrsegs_copy, nrsegs_orig = 0;
-+ size_t count, iov_offset = 0;
-+ ENTRY;
-+
-+ count = ll_file_get_iov_count(iov, &nr_segs);
-+
-+ CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),size="LPSZ",offset=%Ld\n",
-+ inode->i_ino, inode->i_generation, inode, count, *ppos);
-+
-+ SIGNAL_MASK_ASSERT(); /* XXX BUG 1511 */
-+
-+ /* POSIX, but surprised the VFS doesn't check this already */
-+ if (count == 0)
-+ RETURN(0);
-+
-+ /* If file was opened for LL_IOC_LOV_SETSTRIPE but the ioctl wasn't
-+ * called on the file, don't fail the below assertion (bug 2388). */
-+ if (file->f_flags & O_LOV_DELAY_CREATE &&
-+ ll_i2info(inode)->lli_smd == NULL)
-+ RETURN(-EBADF);
-+
-+ LASSERT(ll_i2info(inode)->lli_smd != NULL);
-+
-+ down(&ll_i2info(inode)->lli_write_sem);
-+
-+repeat:
-+ chunk = 0; /* just to fix gcc's warning */
-+ end = *ppos + count - 1;
-+
-+ if (file->f_flags & O_APPEND) {
-+ lock_start = 0;
-+ lock_end = OBD_OBJECT_EOF;
-+ iov_copy = (struct iovec *)iov;
-+ nrsegs_copy = nr_segs;
-+ } else if (sbi->ll_max_rw_chunk != 0) {
-+ /* first, let's know the end of the current stripe */
-+ end = *ppos;
-+ obd_extent_calc(sbi->ll_osc_exp, lsm, OBD_CALC_STRIPE_END,
-+ (obd_off *)&end);
-+
-+ /* correct, the end is beyond the request */
-+ if (end > *ppos + count - 1)
-+ end = *ppos + count - 1;
-+
-+ /* and chunk shouldn't be too large even if striping is wide */
-+ if (end - *ppos > sbi->ll_max_rw_chunk)
-+ end = *ppos + sbi->ll_max_rw_chunk - 1;
-+ lock_start = *ppos;
-+ lock_end = end;
-+ chunk = end - *ppos + 1;
-+ if ((count == chunk) && (iov_offset == 0)) {
-+ if (iov_copy)
-+ OBD_FREE(iov_copy, sizeof(*iov) * nrsegs_orig);
-+
-+ iov_copy = (struct iovec *)iov;
-+ nrsegs_copy = nr_segs;
-+ } else {
-+ if (!iov_copy) {
-+ nrsegs_orig = nr_segs;
-+ OBD_ALLOC(iov_copy, sizeof(*iov) * nr_segs);
-+ if (!iov_copy)
-+ GOTO(out, retval = -ENOMEM);
-+ }
-+ iov_copy_update(&nr_segs, &iov, &nrsegs_copy, iov_copy,
-+ &iov_offset, chunk);
-+ }
-+ } else {
-+ lock_start = *ppos;
-+ lock_end = end;
-+ iov_copy = (struct iovec *)iov;
-+ nrsegs_copy = nr_segs;
-+ }
-+
-+ tree_locked = ll_file_get_tree_lock_iov(&tree, file, iov_copy,
-+ nrsegs_copy,
-+ (obd_off)lock_start,
-+ (obd_off)lock_end,
-+ OBD_BRW_WRITE);
-+ if (tree_locked < 0)
-+ GOTO(out, retval = tree_locked);
-+
-+ /* This is ok, g_f_w will overwrite this under i_sem if it races
-+ * with a local truncate, it just makes our maxbyte checking easier.
-+ * The i_size value gets updated in ll_extent_lock() as a consequence
-+ * of the [0,EOF] extent lock we requested above. */
-+ if (file->f_flags & O_APPEND) {
-+ *ppos = i_size_read(inode);
-+ end = *ppos + count - 1;
-+ }
-+
-+ if (*ppos >= maxbytes) {
-+ send_sig(SIGXFSZ, current, 0);
-+ GOTO(out_unlock, retval = -EFBIG);
-+ }
-+ if (end > maxbytes - 1)
-+ end = maxbytes - 1;
-+
-+ /* generic_file_write handles O_APPEND after getting i_mutex */
-+ chunk = end - *ppos + 1;
-+ CDEBUG(D_INFO, "Writing inode %lu, "LPSZ" bytes, offset %Lu\n",
-+ inode->i_ino, chunk, *ppos);
-+ if (tree_locked) {
-+ /* write under locks
-+ *
-+ * 1. update inode's mtime and ctime as long as
-+ * concurrent stat (via ll_glimpse_size) might bring
-+ * out-of-date ones
-+ *
-+ * 2. update lsm so that next stat (via
-+ * ll_glimpse_size) could get correct values in lsm */
-+ struct ost_lvb xtimes;
-+
-+ lov_stripe_lock(lsm);
-+ LTIME_S(inode->i_mtime) = LTIME_S(CURRENT_TIME);
-+ LTIME_S(inode->i_ctime) = LTIME_S(CURRENT_TIME);
-+ xtimes.lvb_mtime = LTIME_S(inode->i_mtime);
-+ xtimes.lvb_ctime = LTIME_S(inode->i_ctime);
-+ obd_update_lvb(sbi->ll_osc_exp, lsm, &xtimes,
-+ OBD_MD_FLMTIME | OBD_MD_FLCTIME);
-+ lov_stripe_unlock(lsm);
-+
-+#ifdef HAVE_FILE_WRITEV
-+ retval = generic_file_writev(file, iov_copy, nrsegs_copy, ppos);
-+#else
-+ retval = generic_file_aio_write(iocb, iov_copy, nrsegs_copy,
-+ *ppos);
-+#endif
-+ } else {
-+ /* lockless write
-+ *
-+ * current time will get into request as mtime and
-+ * ctime (lustre/osc/osc_request.c:osc_build_request())
-+ */
-+ retval = ll_file_lockless_io(file, iov_copy, nrsegs_copy,
-+ ppos, WRITE, chunk);
-+ }
-+ ll_rw_stats_tally(ll_i2sbi(inode), current->pid, file, chunk, 1);
-+
-+out_unlock:
-+ if (tree_locked)
-+ ll_tree_unlock(&tree);
-+
-+out:
-+ if (retval > 0) {
-+ count -= retval;
-+ sum += retval;
-+ if (retval == chunk && count > 0)
-+ goto repeat;
-+ }
-+
-+ up(&ll_i2info(inode)->lli_write_sem);
-+
-+ if (iov_copy && iov_copy != iov)
-+ OBD_FREE(iov_copy, sizeof(*iov) * nrsegs_orig);
-+
-+ retval = (sum > 0) ? sum : retval;
-+ ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_WRITE_BYTES,
-+ retval > 0 ? retval : 0);
-+ RETURN(retval);
-+}
-+
-+static ssize_t ll_file_write(struct file *file, const char *buf, size_t count,
-+ loff_t *ppos)
-+{
-+ struct iovec local_iov = { .iov_base = (void __user *)buf,
-+ .iov_len = count };
-+
-+#ifdef HAVE_FILE_WRITEV
-+ return ll_file_writev(file, &local_iov, 1, ppos);
-+#else
-+ struct kiocb kiocb;
-+ ssize_t ret;
-+
-+ init_sync_kiocb(&kiocb, file);
-+ kiocb.ki_pos = *ppos;
-+ kiocb.ki_left = count;
-+
-+ ret = ll_file_aio_write(&kiocb, &local_iov, 1, kiocb.ki_pos);
-+ *ppos = kiocb.ki_pos;
-+
-+ return ret;
-+#endif
-+}
-+
-+/*
-+ * Send file content (through pagecache) somewhere with helper
-+ */
-+static ssize_t ll_file_sendfile(struct file *in_file, loff_t *ppos,size_t count,
-+ read_actor_t actor, void *target)
-+{
-+ struct inode *inode = in_file->f_dentry->d_inode;
-+ struct ll_inode_info *lli = ll_i2info(inode);
-+ struct lov_stripe_md *lsm = lli->lli_smd;
-+ struct ll_lock_tree tree;
-+ struct ll_lock_tree_node *node;
-+ struct ost_lvb lvb;
-+ struct ll_ra_read bead;
-+ int rc;
-+ ssize_t retval;
-+ __u64 kms;
-+ ENTRY;
-+ CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),size="LPSZ",offset=%Ld\n",
-+ inode->i_ino, inode->i_generation, inode, count, *ppos);
-+
-+ /* "If nbyte is 0, read() will return 0 and have no other results."
-+ * -- Single Unix Spec */
-+ if (count == 0)
-+ RETURN(0);
-+
-+ ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_READ_BYTES, count);
-+ /* turn off the kernel's read-ahead */
-+ in_file->f_ra.ra_pages = 0;
-+
-+ /* File with no objects, nothing to lock */
-+ if (!lsm)
-+ RETURN(generic_file_sendfile(in_file, ppos, count, actor, target));
-+
-+ node = ll_node_from_inode(inode, *ppos, *ppos + count - 1, LCK_PR);
-+ if (IS_ERR(node))
-+ RETURN(PTR_ERR(node));
-+
-+ tree.lt_fd = LUSTRE_FPRIVATE(in_file);
-+ rc = ll_tree_lock(&tree, node, NULL, count,
-+ in_file->f_flags & O_NONBLOCK?LDLM_FL_BLOCK_NOWAIT:0);
-+ if (rc != 0)
-+ RETURN(rc);
-+
-+ ll_clear_file_contended(inode);
-+ ll_inode_size_lock(inode, 1);
-+ /*
-+ * Consistency guarantees: following possibilities exist for the
-+ * relation between region being read and real file size at this
-+ * moment:
-+ *
-+ * (A): the region is completely inside of the file;
-+ *
-+ * (B-x): x bytes of region are inside of the file, the rest is
-+ * outside;
-+ *
-+ * (C): the region is completely outside of the file.
-+ *
-+ * This classification is stable under DLM lock acquired by
-+ * ll_tree_lock() above, because to change class, other client has to
-+ * take DLM lock conflicting with our lock. Also, any updates to
-+ * ->i_size by other threads on this client are serialized by
-+ * ll_inode_size_lock(). This guarantees that short reads are handled
-+ * correctly in the face of concurrent writes and truncates.
-+ */
-+ inode_init_lvb(inode, &lvb);
-+ obd_merge_lvb(ll_i2sbi(inode)->ll_osc_exp, lsm, &lvb, 1);
-+ kms = lvb.lvb_size;
-+ if (*ppos + count - 1 > kms) {
-+ /* A glimpse is necessary to determine whether we return a
-+ * short read (B) or some zeroes at the end of the buffer (C) */
-+ ll_inode_size_unlock(inode, 1);
-+ retval = ll_glimpse_size(inode, LDLM_FL_BLOCK_GRANTED);
-+ if (retval)
-+ goto out;
-+ } else {
-+ /* region is within kms and, hence, within real file size (A) */
-+ i_size_write(inode, kms);
-+ ll_inode_size_unlock(inode, 1);
-+ }
-+
-+ CDEBUG(D_INFO, "Send ino %lu, "LPSZ" bytes, offset %lld, i_size %llu\n",
-+ inode->i_ino, count, *ppos, i_size_read(inode));
-+
-+ bead.lrr_start = *ppos >> CFS_PAGE_SHIFT;
-+ bead.lrr_count = (count + CFS_PAGE_SIZE - 1) >> CFS_PAGE_SHIFT;
-+ ll_ra_read_in(in_file, &bead);
-+ /* BUG: 5972 */
-+ file_accessed(in_file);
-+ retval = generic_file_sendfile(in_file, ppos, count, actor, target);
-+ ll_ra_read_ex(in_file, &bead);
-+
-+ out:
-+ ll_tree_unlock(&tree);
-+ RETURN(retval);
-+}
-+
-+static int ll_lov_recreate_obj(struct inode *inode, struct file *file,
-+ unsigned long arg)
-+{
-+ struct ll_inode_info *lli = ll_i2info(inode);
-+ struct obd_export *exp = ll_i2obdexp(inode);
-+ struct ll_recreate_obj ucreatp;
-+ struct obd_trans_info oti = { 0 };
-+ struct obdo *oa = NULL;
-+ int lsm_size;
-+ int rc = 0;
-+ struct lov_stripe_md *lsm, *lsm2;
-+ ENTRY;
-+
-+ if (!cfs_capable(CFS_CAP_SYS_ADMIN))
-+ RETURN(-EPERM);
-+
-+ rc = copy_from_user(&ucreatp, (struct ll_recreate_obj *)arg,
-+ sizeof(struct ll_recreate_obj));
-+ if (rc) {
-+ RETURN(-EFAULT);
-+ }
-+ OBDO_ALLOC(oa);
-+ if (oa == NULL)
-+ RETURN(-ENOMEM);
-+
-+ down(&lli->lli_size_sem);
-+ lsm = lli->lli_smd;
-+ if (lsm == NULL)
-+ GOTO(out, rc = -ENOENT);
-+ lsm_size = sizeof(*lsm) + (sizeof(struct lov_oinfo) *
-+ (lsm->lsm_stripe_count));
-+
-+ OBD_ALLOC(lsm2, lsm_size);
-+ if (lsm2 == NULL)
-+ GOTO(out, rc = -ENOMEM);
-+
-+ oa->o_id = ucreatp.lrc_id;
-+ oa->o_nlink = ucreatp.lrc_ost_idx;
-+ oa->o_flags |= OBD_FL_RECREATE_OBJS;
-+ oa->o_valid = OBD_MD_FLID | OBD_MD_FLFLAGS;
-+ obdo_from_inode(oa, inode, OBD_MD_FLTYPE | OBD_MD_FLATIME |
-+ OBD_MD_FLMTIME | OBD_MD_FLCTIME);
-+
-+ memcpy(lsm2, lsm, lsm_size);
-+ rc = obd_create(exp, oa, &lsm2, &oti);
-+
-+ OBD_FREE(lsm2, lsm_size);
-+ GOTO(out, rc);
-+out:
-+ up(&lli->lli_size_sem);
-+ OBDO_FREE(oa);
-+ return rc;
-+}
-+
-+int ll_lov_setstripe_ea_info(struct inode *inode, struct file *file,
-+ int flags, struct lov_user_md *lum,
-+ int lum_size)
-+{
-+ struct ll_inode_info *lli = ll_i2info(inode);
-+ struct lov_stripe_md *lsm;
-+ struct lookup_intent oit = {.it_op = IT_OPEN, .it_flags = flags};
-+ int rc = 0;
-+ ENTRY;
-+
-+ down(&lli->lli_size_sem);
-+ lsm = lli->lli_smd;
-+ if (lsm) {
-+ up(&lli->lli_size_sem);
-+ CDEBUG(D_IOCTL, "stripe already exists for ino %lu\n",
-+ inode->i_ino);
-+ RETURN(-EEXIST);
-+ }
-+
-+ rc = ll_intent_file_open(file, lum, lum_size, &oit);
-+ if (rc)
-+ GOTO(out, rc);
-+ if (it_disposition(&oit, DISP_LOOKUP_NEG))
-+ GOTO(out_req_free, rc = -ENOENT);
-+ rc = oit.d.lustre.it_status;
-+ if (rc < 0)
-+ GOTO(out_req_free, rc);
-+
-+ ll_release_openhandle(file->f_dentry, &oit);
-+
-+ out:
-+ up(&lli->lli_size_sem);
-+ ll_intent_release(&oit);
-+ RETURN(rc);
-+out_req_free:
-+ ptlrpc_req_finished((struct ptlrpc_request *) oit.d.lustre.it_data);
-+ goto out;
-+}
-+
-+int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename,
-+ struct lov_mds_md **lmmp, int *lmm_size,
-+ struct ptlrpc_request **request)
-+{
-+ struct ll_sb_info *sbi = ll_i2sbi(inode);
-+ struct ll_fid fid;
-+ struct mds_body *body;
-+ struct lov_mds_md *lmm = NULL;
-+ struct ptlrpc_request *req = NULL;
-+ int rc, lmmsize;
-+
-+ ll_inode2fid(&fid, inode);
-+
-+ rc = ll_get_max_mdsize(sbi, &lmmsize);
-+ if (rc)
-+ RETURN(rc);
-+
-+ rc = mdc_getattr_name(sbi->ll_mdc_exp, &fid,
-+ filename, strlen(filename) + 1,
-+ OBD_MD_FLEASIZE | OBD_MD_FLDIREA,
-+ lmmsize, &req);
-+ if (rc < 0) {
-+ CDEBUG(D_INFO, "mdc_getattr_name failed "
-+ "on %s: rc %d\n", filename, rc);
-+ GOTO(out, rc);
-+ }
-+
-+ body = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF,
-+ sizeof(*body));
-+ LASSERT(body != NULL); /* checked by mdc_getattr_name */
-+ /* swabbed by mdc_getattr_name */
-+ LASSERT(lustre_rep_swabbed(req, REPLY_REC_OFF));
-+
-+ lmmsize = body->eadatasize;
-+
-+ if (!(body->valid & (OBD_MD_FLEASIZE | OBD_MD_FLDIREA)) ||
-+ lmmsize == 0) {
-+ GOTO(out, rc = -ENODATA);
-+ }
-+
-+ lmm = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF + 1,
-+ lmmsize);
-+ LASSERT(lmm != NULL);
-+ LASSERT(lustre_rep_swabbed(req, REPLY_REC_OFF + 1));
-+
-+ if ((lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V1)) &&
-+ (lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V3)) &&
-+ (lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_JOIN))) {
-+ GOTO(out, rc = -EPROTO);
-+ }
-+ /*
-+ * This is coming from the MDS, so is probably in
-+ * little endian. We convert it to host endian before
-+ * passing it to userspace.
-+ */
-+ if (LOV_MAGIC != cpu_to_le32(LOV_MAGIC)) {
-+ /* if function called for directory - we should
-+ * avoid swab not existent lsm objects */
-+ if ((lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V1)) ||
-+ (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V3))) {
-+ lustre_swab_lov_user_md((struct lov_user_md*)lmm);
-+ if (S_ISREG(body->mode))
-+ lustre_swab_lov_user_md_objects(
-+ (struct lov_user_md*)lmm);
-+ } else if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_JOIN)) {
-+ lustre_swab_lov_user_md_join((struct lov_user_md_join *)lmm);
-+ }
-+ }
-+
-+ if (lmm->lmm_magic == LOV_MAGIC_JOIN) {
-+ struct lov_stripe_md *lsm;
-+ struct lov_user_md_join *lmj;
-+ int lmj_size, i, aindex = 0;
-+
-+ rc = obd_unpackmd(sbi->ll_osc_exp, &lsm, lmm, lmmsize);
-+ if (rc < 0)
-+ GOTO(out, rc = -ENOMEM);
-+ rc = obd_checkmd(sbi->ll_osc_exp, sbi->ll_mdc_exp, lsm);
-+ if (rc)
-+ GOTO(out_free_memmd, rc);
-+
-+ lmj_size = sizeof(struct lov_user_md_join) +
-+ lsm->lsm_stripe_count *
-+ sizeof(struct lov_user_ost_data_join);
-+ OBD_ALLOC(lmj, lmj_size);
-+ if (!lmj)
-+ GOTO(out_free_memmd, rc = -ENOMEM);
-+
-+ memcpy(lmj, lmm, sizeof(struct lov_user_md_join));
-+ for (i = 0; i < lsm->lsm_stripe_count; i++) {
-+ struct lov_extent *lex =
-+ &lsm->lsm_array->lai_ext_array[aindex];
-+
-+ if (lex->le_loi_idx + lex->le_stripe_count <= i)
-+ aindex ++;
-+ CDEBUG(D_INFO, "aindex %d i %d l_extent_start "
-+ LPU64" len %d\n", aindex, i,
-+ lex->le_start, (int)lex->le_len);
-+ lmj->lmm_objects[i].l_extent_start =
-+ lex->le_start;
-+
-+ if ((int)lex->le_len == -1)
-+ lmj->lmm_objects[i].l_extent_end = -1;
-+ else
-+ lmj->lmm_objects[i].l_extent_end =
-+ lex->le_start + lex->le_len;
-+ lmj->lmm_objects[i].l_object_id =
-+ lsm->lsm_oinfo[i]->loi_id;
-+ lmj->lmm_objects[i].l_object_gr =
-+ lsm->lsm_oinfo[i]->loi_gr;
-+ lmj->lmm_objects[i].l_ost_gen =
-+ lsm->lsm_oinfo[i]->loi_ost_gen;
-+ lmj->lmm_objects[i].l_ost_idx =
-+ lsm->lsm_oinfo[i]->loi_ost_idx;
-+ }
-+ lmm = (struct lov_mds_md *)lmj;
-+ lmmsize = lmj_size;
-+out_free_memmd:
-+ obd_free_memmd(sbi->ll_osc_exp, &lsm);
-+ }
-+out:
-+ *lmmp = lmm;
-+ *lmm_size = lmmsize;
-+ *request = req;
-+ return rc;
-+}
-+static int ll_lov_setea(struct inode *inode, struct file *file,
-+ unsigned long arg)
-+{
-+ int flags = MDS_OPEN_HAS_OBJS | FMODE_WRITE;
-+ struct lov_user_md *lump;
-+ int lum_size = sizeof(struct lov_user_md) +
-+ sizeof(struct lov_user_ost_data);
-+ int rc;
-+ ENTRY;
-+
-+ if (!cfs_capable(CFS_CAP_SYS_ADMIN))
-+ RETURN(-EPERM);
-+
-+ OBD_ALLOC(lump, lum_size);
-+ if (lump == NULL) {
-+ RETURN(-ENOMEM);
-+ }
-+ rc = copy_from_user(lump, (struct lov_user_md *)arg, lum_size);
-+ if (rc) {
-+ OBD_FREE(lump, lum_size);
-+ RETURN(-EFAULT);
-+ }
-+
-+ rc = ll_lov_setstripe_ea_info(inode, file, flags, lump, lum_size);
-+
-+ OBD_FREE(lump, lum_size);
-+ RETURN(rc);
-+}
-+
-+static int ll_lov_setstripe(struct inode *inode, struct file *file,
-+ unsigned long arg)
-+{
-+ struct lov_user_md_v3 lumv3;
-+ struct lov_user_md_v1 *lumv1 = (struct lov_user_md_v1 *)&lumv3;
-+ struct lov_user_md_v1 *lumv1p = (struct lov_user_md_v1 *)arg;
-+ struct lov_user_md_v3 *lumv3p = (struct lov_user_md_v3 *)arg;
-+ int lum_size;
-+ int rc;
-+ int flags = FMODE_WRITE;
-+ ENTRY;
-+
-+ /* first try with v1 which is smaller than v3 */
-+ lum_size = sizeof(struct lov_user_md_v1);
-+ rc = copy_from_user(lumv1, lumv1p, lum_size);
-+ if (rc)
-+ RETURN(-EFAULT);
-+
-+ if (lumv1->lmm_magic == LOV_USER_MAGIC_V3) {
-+ lum_size = sizeof(struct lov_user_md_v3);
-+ rc = copy_from_user(&lumv3, lumv3p, lum_size);
-+ if (rc)
-+ RETURN(-EFAULT);
-+ }
-+
-+ rc = ll_lov_setstripe_ea_info(inode, file, flags, lumv1, lum_size);
-+ if (rc == 0) {
-+ put_user(0, &lumv1p->lmm_stripe_count);
-+ rc = obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2obdexp(inode),
-+ 0, ll_i2info(inode)->lli_smd,
-+ (void *)arg);
-+ }
-+ RETURN(rc);
-+}
-+
-+static int ll_lov_getstripe(struct inode *inode, unsigned long arg)
-+{
-+ struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
-+
-+ if (!lsm)
-+ RETURN(-ENODATA);
-+
-+ return obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2obdexp(inode), 0, lsm,
-+ (void *)arg);
-+}
-+
-+static int ll_get_grouplock(struct inode *inode, struct file *file,
-+ unsigned long arg)
-+{
-+ struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
-+ ldlm_policy_data_t policy = { .l_extent = { .start = 0,
-+ .end = OBD_OBJECT_EOF}};
-+ struct lustre_handle lockh = { 0 };
-+ struct ll_inode_info *lli = ll_i2info(inode);
-+ struct lov_stripe_md *lsm = lli->lli_smd;
-+ int flags = 0, rc;
-+ ENTRY;
-+
-+ if (fd->fd_flags & LL_FILE_GROUP_LOCKED) {
-+ RETURN(-EINVAL);
-+ }
-+
-+ policy.l_extent.gid = arg;
-+ if (file->f_flags & O_NONBLOCK)
-+ flags = LDLM_FL_BLOCK_NOWAIT;
-+
-+ rc = ll_extent_lock(fd, inode, lsm, LCK_GROUP, &policy, &lockh, flags);
-+ if (rc)
-+ RETURN(rc);
-+
-+ fd->fd_flags |= LL_FILE_GROUP_LOCKED|LL_FILE_IGNORE_LOCK;
-+ fd->fd_gid = arg;
-+ memcpy(&fd->fd_cwlockh, &lockh, sizeof(lockh));
-+
-+ RETURN(0);
-+}
-+
-+static int ll_put_grouplock(struct inode *inode, struct file *file,
-+ unsigned long arg)
-+{
-+ struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
-+ struct ll_inode_info *lli = ll_i2info(inode);
-+ struct lov_stripe_md *lsm = lli->lli_smd;
-+ int rc;
-+ ENTRY;
-+
-+ if (!(fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
-+ /* Ugh, it's already unlocked. */
-+ RETURN(-EINVAL);
-+ }
-+
-+ if (fd->fd_gid != arg) /* Ugh? Unlocking with different gid? */
-+ RETURN(-EINVAL);
-+
-+ fd->fd_flags &= ~(LL_FILE_GROUP_LOCKED|LL_FILE_IGNORE_LOCK);
-+
-+ rc = ll_extent_unlock(fd, inode, lsm, LCK_GROUP, &fd->fd_cwlockh);
-+ if (rc)
-+ RETURN(rc);
-+
-+ fd->fd_gid = 0;
-+ memset(&fd->fd_cwlockh, 0, sizeof(fd->fd_cwlockh));
-+
-+ RETURN(0);
-+}
-+
-+#if LUSTRE_FIX >= 50
-+static int join_sanity_check(struct inode *head, struct inode *tail)
-+{
-+ ENTRY;
-+ if ((ll_i2sbi(head)->ll_flags & LL_SBI_JOIN) == 0) {
-+ CERROR("server do not support join \n");
-+ RETURN(-EINVAL);
-+ }
-+ if (!S_ISREG(tail->i_mode) || !S_ISREG(head->i_mode)) {
-+ CERROR("tail ino %lu and ino head %lu must be regular\n",
-+ head->i_ino, tail->i_ino);
-+ RETURN(-EINVAL);
-+ }
-+ if (head->i_ino == tail->i_ino) {
-+ CERROR("file %lu can not be joined to itself \n", head->i_ino);
-+ RETURN(-EINVAL);
-+ }
-+ if (i_size_read(head) % JOIN_FILE_ALIGN) {
-+ CERROR("hsize %llu must be times of 64K\n", i_size_read(head));
-+ RETURN(-EINVAL);
-+ }
-+ RETURN(0);
-+}
-+
-+static int join_file(struct inode *head_inode, struct file *head_filp,
-+ struct file *tail_filp)
-+{
-+ struct dentry *tail_dentry = tail_filp->f_dentry;
-+ struct lookup_intent oit = {.it_op = IT_OPEN,
-+ .it_flags = head_filp->f_flags|O_JOIN_FILE};
-+ struct ldlm_enqueue_info einfo = { LDLM_IBITS, LCK_PW,
-+ ll_mdc_blocking_ast, ldlm_completion_ast, NULL, NULL };
-+
-+ struct lustre_handle lockh;
-+ struct mdc_op_data *op_data;
-+ int rc;
-+ loff_t data;
-+ ENTRY;
-+
-+ tail_dentry = tail_filp->f_dentry;
-+
-+ OBD_ALLOC_PTR(op_data);
-+ if (op_data == NULL) {
-+ RETURN(-ENOMEM);
-+ }
-+
-+ data = i_size_read(head_inode);
-+ ll_prepare_mdc_op_data(op_data, head_inode,
-+ tail_dentry->d_parent->d_inode,
-+ tail_dentry->d_name.name,
-+ tail_dentry->d_name.len, 0, &data);
-+ rc = mdc_enqueue(ll_i2mdcexp(head_inode), &einfo, &oit,
-+ op_data, &lockh, NULL, 0, 0);
-+
-+ if (rc < 0)
-+ GOTO(out, rc);
-+
-+ rc = oit.d.lustre.it_status;
-+
-+ if (rc < 0 || it_open_error(DISP_OPEN_OPEN, &oit)) {
-+ rc = rc ? rc : it_open_error(DISP_OPEN_OPEN, &oit);
-+ ptlrpc_req_finished((struct ptlrpc_request *)
-+ oit.d.lustre.it_data);
-+ GOTO(out, rc);
-+ }
-+
-+ if (oit.d.lustre.it_lock_mode) { /* If we got lock - release it right
-+ * away */
-+ ldlm_lock_decref(&lockh, oit.d.lustre.it_lock_mode);
-+ oit.d.lustre.it_lock_mode = 0;
-+ }
-+ ptlrpc_req_finished((struct ptlrpc_request *) oit.d.lustre.it_data);
-+ it_clear_disposition(&oit, DISP_ENQ_COMPLETE);
-+ ll_release_openhandle(head_filp->f_dentry, &oit);
-+out:
-+ if (op_data)
-+ OBD_FREE_PTR(op_data);
-+ ll_intent_release(&oit);
-+ RETURN(rc);
-+}
-+
-+static int ll_file_join(struct inode *head, struct file *filp,
-+ char *filename_tail)
-+{
-+ struct inode *tail = NULL, *first = NULL, *second = NULL;
-+ struct dentry *tail_dentry;
-+ struct file *tail_filp, *first_filp, *second_filp;
-+ struct ll_lock_tree first_tree, second_tree;
-+ struct ll_lock_tree_node *first_node, *second_node;
-+ struct ll_inode_info *hlli = ll_i2info(head), *tlli;
-+ int rc = 0, cleanup_phase = 0;
-+ ENTRY;
-+
-+ CDEBUG(D_VFSTRACE, "VFS Op:head=%lu/%u(%p) tail %s\n",
-+ head->i_ino, head->i_generation, head, filename_tail);
-+
-+ tail_filp = filp_open(filename_tail, O_WRONLY, 0644);
-+ if (IS_ERR(tail_filp)) {
-+ CERROR("Can not open tail file %s", filename_tail);
-+ rc = PTR_ERR(tail_filp);
-+ GOTO(cleanup, rc);
-+ }
-+ tail = igrab(tail_filp->f_dentry->d_inode);
-+
-+ tlli = ll_i2info(tail);
-+ tail_dentry = tail_filp->f_dentry;
-+ LASSERT(tail_dentry);
-+ cleanup_phase = 1;
-+
-+ /*reorder the inode for lock sequence*/
-+ first = head->i_ino > tail->i_ino ? head : tail;
-+ second = head->i_ino > tail->i_ino ? tail : head;
-+ first_filp = head->i_ino > tail->i_ino ? filp : tail_filp;
-+ second_filp = head->i_ino > tail->i_ino ? tail_filp : filp;
-+
-+ CDEBUG(D_INFO, "reorder object from %lu:%lu to %lu:%lu \n",
-+ head->i_ino, tail->i_ino, first->i_ino, second->i_ino);
-+ first_node = ll_node_from_inode(first, 0, OBD_OBJECT_EOF, LCK_EX);
-+ if (IS_ERR(first_node)){
-+ rc = PTR_ERR(first_node);
-+ GOTO(cleanup, rc);
-+ }
-+ first_tree.lt_fd = first_filp->private_data;
-+ rc = ll_tree_lock(&first_tree, first_node, NULL, 0, 0);
-+ if (rc != 0)
-+ GOTO(cleanup, rc);
-+ cleanup_phase = 2;
-+
-+ second_node = ll_node_from_inode(second, 0, OBD_OBJECT_EOF, LCK_EX);
-+ if (IS_ERR(second_node)){
-+ rc = PTR_ERR(second_node);
-+ GOTO(cleanup, rc);
-+ }
-+ second_tree.lt_fd = second_filp->private_data;
-+ rc = ll_tree_lock(&second_tree, second_node, NULL, 0, 0);
-+ if (rc != 0)
-+ GOTO(cleanup, rc);
-+ cleanup_phase = 3;
-+
-+ rc = join_sanity_check(head, tail);
-+ if (rc)
-+ GOTO(cleanup, rc);
-+
-+ rc = join_file(head, filp, tail_filp);
-+ if (rc)
-+ GOTO(cleanup, rc);
-+cleanup:
-+ switch (cleanup_phase) {
-+ case 3:
-+ ll_tree_unlock(&second_tree);
-+ obd_cancel_unused(ll_i2obdexp(second),
-+ ll_i2info(second)->lli_smd, 0, NULL);
-+ case 2:
-+ ll_tree_unlock(&first_tree);
-+ obd_cancel_unused(ll_i2obdexp(first),
-+ ll_i2info(first)->lli_smd, 0, NULL);
-+ case 1:
-+ filp_close(tail_filp, 0);
-+ if (tail)
-+ iput(tail);
-+ if (head && rc == 0) {
-+ obd_free_memmd(ll_i2sbi(head)->ll_osc_exp,
-+ &hlli->lli_smd);
-+ hlli->lli_smd = NULL;
-+ }
-+ case 0:
-+ break;
-+ default:
-+ CERROR("invalid cleanup_phase %d\n", cleanup_phase);
-+ LBUG();
-+ }
-+ RETURN(rc);
-+}
-+#endif /* LUSTRE_FIX >= 50 */
-+
-+/**
-+ * Close inode open handle
-+ *
-+ * \param dentry [in] dentry which contains the inode
-+ * \param it [in,out] intent which contains open info and result
-+ *
-+ * \retval 0 success
-+ * \retval <0 failure
-+ */
-+int ll_release_openhandle(struct dentry *dentry, struct lookup_intent *it)
-+{
-+ struct inode *inode = dentry->d_inode;
-+ struct obd_client_handle *och;
-+ int rc;
-+ ENTRY;
-+
-+ LASSERT(inode);
-+
-+ /* Root ? Do nothing. */
-+ if (dentry->d_inode->i_sb->s_root == dentry)
-+ RETURN(0);
-+
-+ /* No open handle to close? Move away */
-+ if (!it_disposition(it, DISP_OPEN_OPEN))
-+ RETURN(0);
-+
-+ LASSERT(it_open_error(DISP_OPEN_OPEN, it) == 0);
-+
-+ OBD_ALLOC(och, sizeof(*och));
-+ if (!och)
-+ GOTO(out, rc = -ENOMEM);
-+
-+ ll_och_fill(ll_i2info(inode), it, och);
-+
-+ rc = ll_close_inode_openhandle(inode, och);
-+
-+ OBD_FREE(och, sizeof(*och));
-+ out:
-+ /* this one is in place of ll_file_open */
-+ if (it_disposition(it, DISP_ENQ_OPEN_REF))
-+ ptlrpc_req_finished(it->d.lustre.it_data);
-+ it_clear_disposition(it, DISP_ENQ_OPEN_REF);
-+ RETURN(rc);
-+}
-+
-+int ll_fiemap(struct inode *inode, struct ll_user_fiemap *fiemap,
-+ int num_bytes)
-+{
-+ struct obd_export *exp = ll_i2obdexp(inode);
-+ struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
-+ struct ll_fiemap_info_key fm_key = { .name = KEY_FIEMAP, };
-+ int vallen = num_bytes;
-+ int rc;
-+ ENTRY;
-+
-+ /* If the stripe_count > 1 and the application does not understand
-+ * DEVICE_ORDER flag, then it cannot interpret the extents correctly.
-+ */
-+ if (lsm->lsm_stripe_count > 1 &&
-+ !(fiemap->fm_flags & FIEMAP_FLAG_DEVICE_ORDER))
-+ return -EOPNOTSUPP;
-+
-+ fm_key.oa.o_id = lsm->lsm_object_id;
-+ fm_key.oa.o_valid = OBD_MD_FLID;
-+
-+ obdo_from_inode(&fm_key.oa, inode, OBD_MD_FLFID | OBD_MD_FLSIZE);
-+
-+ /* If filesize is 0, then there would be no objects for mapping */
-+ if (fm_key.oa.o_size == 0) {
-+ fiemap->fm_mapped_extents = 0;
-+ RETURN(0);
-+ }
-+
-+ memcpy(&fm_key.fiemap, fiemap, sizeof(*fiemap));
-+
-+ rc = obd_get_info(exp, sizeof(fm_key), &fm_key, &vallen, fiemap, lsm);
-+ if (rc)
-+ CERROR("obd_get_info failed: rc = %d\n", rc);
-+
-+ RETURN(rc);
-+}
-+
-+int ll_file_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-+ unsigned long arg)
-+{
-+ struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
-+ int flags;
-+ ENTRY;
-+
-+ CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),cmd=%x\n", inode->i_ino,
-+ inode->i_generation, inode, cmd);
-+ ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_IOCTL, 1);
-+
-+ /* asm-ppc{,64} declares TCGETS, et. al. as type 't' not 'T' */
-+ if (_IOC_TYPE(cmd) == 'T' || _IOC_TYPE(cmd) == 't') /* tty ioctls */
-+ RETURN(-ENOTTY);
-+
-+ switch(cmd) {
-+ case LL_IOC_GETFLAGS:
-+ /* Get the current value of the file flags */
-+ return put_user(fd->fd_flags, (int *)arg);
-+ case LL_IOC_SETFLAGS:
-+ case LL_IOC_CLRFLAGS:
-+ /* Set or clear specific file flags */
-+ /* XXX This probably needs checks to ensure the flags are
-+ * not abused, and to handle any flag side effects.
-+ */
-+ if (get_user(flags, (int *) arg))
-+ RETURN(-EFAULT);
-+
-+ if (cmd == LL_IOC_SETFLAGS) {
-+ if ((flags & LL_FILE_IGNORE_LOCK) &&
-+ !(file->f_flags & O_DIRECT)) {
-+ CERROR("%s: unable to disable locking on "
-+ "non-O_DIRECT file\n", current->comm);
-+ RETURN(-EINVAL);
-+ }
-+
-+ fd->fd_flags |= flags;
-+ } else {
-+ fd->fd_flags &= ~flags;
-+ }
-+ RETURN(0);
-+ case LL_IOC_LOV_SETSTRIPE:
-+ RETURN(ll_lov_setstripe(inode, file, arg));
-+ case LL_IOC_LOV_SETEA:
-+ RETURN(ll_lov_setea(inode, file, arg));
-+ case LL_IOC_LOV_GETSTRIPE:
-+ RETURN(ll_lov_getstripe(inode, arg));
-+ case LL_IOC_RECREATE_OBJ:
-+ RETURN(ll_lov_recreate_obj(inode, file, arg));
-+ case EXT3_IOC_FIEMAP: {
-+ struct ll_user_fiemap *fiemap_s;
-+ size_t num_bytes, ret_bytes;
-+ unsigned int extent_count;
-+ int rc = 0;
-+
-+ /* Get the extent count so we can calculate the size of
-+ * required fiemap buffer */
-+ if (get_user(extent_count,
-+ &((struct ll_user_fiemap __user *)arg)->fm_extent_count))
-+ RETURN(-EFAULT);
-+ num_bytes = sizeof(*fiemap_s) + (extent_count *
-+ sizeof(struct ll_fiemap_extent));
-+ OBD_VMALLOC(fiemap_s, num_bytes);
-+ if (fiemap_s == NULL)
-+ RETURN(-ENOMEM);
-+
-+ if (copy_from_user(fiemap_s,(struct ll_user_fiemap __user *)arg,
-+ sizeof(*fiemap_s)))
-+ GOTO(error, rc = -EFAULT);
-+
-+ if (fiemap_s->fm_flags & ~LUSTRE_FIEMAP_FLAGS_COMPAT) {
-+ fiemap_s->fm_flags = fiemap_s->fm_flags &
-+ ~LUSTRE_FIEMAP_FLAGS_COMPAT;
-+ if (copy_to_user((char *)arg, fiemap_s,
-+ sizeof(*fiemap_s)))
-+ GOTO(error, rc = -EFAULT);
-+
-+ GOTO(error, rc = -EBADR);
-+ }
-+
-+ /* If fm_extent_count is non-zero, read the first extent since
-+ * it is used to calculate end_offset and device from previous
-+ * fiemap call. */
-+ if (extent_count) {
-+ if (copy_from_user(&fiemap_s->fm_extents[0],
-+ (char __user *)arg + sizeof(*fiemap_s),
-+ sizeof(struct ll_fiemap_extent)))
-+ GOTO(error, rc = -EFAULT);
-+ }
-+
-+ if (fiemap_s->fm_flags & FIEMAP_FLAG_SYNC) {
-+ int rc;
-+
-+ rc = filemap_fdatawrite(inode->i_mapping);
-+ if (rc)
-+ GOTO(error, rc);
-+ }
-+
-+ rc = ll_fiemap(inode, fiemap_s, num_bytes);
-+ if (rc)
-+ GOTO(error, rc);
-+
-+ ret_bytes = sizeof(struct ll_user_fiemap);
-+
-+ if (extent_count != 0)
-+ ret_bytes += (fiemap_s->fm_mapped_extents *
-+ sizeof(struct ll_fiemap_extent));
-+
-+ if (copy_to_user((void *)arg, fiemap_s, ret_bytes))
-+ rc = -EFAULT;
-+
-+error:
-+ OBD_VFREE(fiemap_s, num_bytes);
-+ RETURN(rc);
-+ }
-+ case EXT3_IOC_GETFLAGS:
-+ case EXT3_IOC_SETFLAGS:
-+ RETURN(ll_iocontrol(inode, file, cmd, arg));
-+ case EXT3_IOC_GETVERSION_OLD:
-+ case EXT3_IOC_GETVERSION:
-+ RETURN(put_user(inode->i_generation, (int *)arg));
-+ case LL_IOC_JOIN: {
-+#if LUSTRE_FIX >= 50
-+ /* Allow file join in beta builds to allow debuggging */
-+ char *ftail;
-+ int rc;
-+
-+ ftail = getname((const char *)arg);
-+ if (IS_ERR(ftail))
-+ RETURN(PTR_ERR(ftail));
-+ rc = ll_file_join(inode, file, ftail);
-+ putname(ftail);
-+ RETURN(rc);
-+#else
-+ CWARN("file join is not supported in this version of Lustre\n");
-+ RETURN(-ENOTTY);
-+#endif
-+ }
-+ case LL_IOC_GROUP_LOCK:
-+ RETURN(ll_get_grouplock(inode, file, arg));
-+ case LL_IOC_GROUP_UNLOCK:
-+ RETURN(ll_put_grouplock(inode, file, arg));
-+ case IOC_OBD_STATFS:
-+ RETURN(ll_obd_statfs(inode, (void *)arg));
-+ case OBD_IOC_GETNAME_OLD:
-+ case OBD_IOC_GETNAME: {
-+ struct obd_device *obd =
-+ class_exp2obd(ll_i2sbi(inode)->ll_osc_exp);
-+ if (!obd)
-+ RETURN(-EFAULT);
-+ if (copy_to_user((void *)arg, obd->obd_name,
-+ strlen(obd->obd_name) + 1))
-+ RETURN (-EFAULT);
-+ RETURN(0);
-+ }
-+
-+ /* We need to special case any other ioctls we want to handle,
-+ * to send them to the MDS/OST as appropriate and to properly
-+ * network encode the arg field.
-+ case EXT3_IOC_SETVERSION_OLD:
-+ case EXT3_IOC_SETVERSION:
-+ */
-+ default: {
-+ int err;
-+
-+ if (LLIOC_STOP ==
-+ ll_iocontrol_call(inode, file, cmd, arg, &err))
-+ RETURN(err);
-+
-+ RETURN(obd_iocontrol(cmd, ll_i2obdexp(inode), 0, NULL,
-+ (void *)arg));
-+ }
-+ }
-+}
-+
-+loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
-+{
-+ struct inode *inode = file->f_dentry->d_inode;
-+ struct ll_inode_info *lli = ll_i2info(inode);
-+ struct lov_stripe_md *lsm = lli->lli_smd;
-+ loff_t retval;
-+ ENTRY;
-+ retval = offset + ((origin == 2) ? i_size_read(inode) :
-+ (origin == 1) ? file->f_pos : 0);
-+ CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), to=%Lu=%#Lx(%s)\n",
-+ inode->i_ino, inode->i_generation, inode, retval, retval,
-+ origin == 2 ? "SEEK_END": origin == 1 ? "SEEK_CUR" : "SEEK_SET");
-+ ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_LLSEEK, 1);
-+
-+ if (origin == 2) { /* SEEK_END */
-+ int nonblock = 0, rc;
-+
-+ if (file->f_flags & O_NONBLOCK)
-+ nonblock = LDLM_FL_BLOCK_NOWAIT;
-+
-+ if (lsm != NULL) {
-+ rc = ll_glimpse_size(inode, nonblock);
-+ if (rc != 0)
-+ RETURN(rc);
-+ }
-+
-+ ll_inode_size_lock(inode, 0);
-+ offset += i_size_read(inode);
-+ ll_inode_size_unlock(inode, 0);
-+ } else if (origin == 1) { /* SEEK_CUR */
-+ offset += file->f_pos;
-+ }
-+
-+ retval = -EINVAL;
-+ if (offset >= 0 && offset <= ll_file_maxbytes(inode)) {
-+ if (offset != file->f_pos) {
-+ file->f_pos = offset;
-+ file->f_version = 0;
-+ }
-+ retval = offset;
-+ }
-+
-+ RETURN(retval);
-+}
-+
-+int ll_fsync(struct file *file, struct dentry *dentry, int data)
-+{
-+ struct inode *inode = dentry->d_inode;
-+ struct ll_inode_info *lli = ll_i2info(inode);
-+ struct lov_stripe_md *lsm = lli->lli_smd;
-+ struct ll_fid fid;
-+ struct ptlrpc_request *req;
-+ int rc, err;
-+ ENTRY;
-+ CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p)\n", inode->i_ino,
-+ inode->i_generation, inode);
-+ ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FSYNC, 1);
-+
-+ /* fsync's caller has already called _fdata{sync,write}, we want
-+ * that IO to finish before calling the osc and mdc sync methods */
-+ rc = filemap_fdatawait(inode->i_mapping);
-+
-+ /* catch async errors that were recorded back when async writeback
-+ * failed for pages in this mapping. */
-+ err = lli->lli_async_rc;
-+ lli->lli_async_rc = 0;
-+ if (rc == 0)
-+ rc = err;
-+ if (lsm) {
-+ err = lov_test_and_clear_async_rc(lsm);
-+ if (rc == 0)
-+ rc = err;
-+ }
-+
-+ ll_inode2fid(&fid, inode);
-+ err = mdc_sync(ll_i2sbi(inode)->ll_mdc_exp, &fid, &req);
-+ if (!rc)
-+ rc = err;
-+ if (!err)
-+ ptlrpc_req_finished(req);
-+
-+ if (data && lsm) {
-+ struct obd_info *oinfo;
-+
-+ OBD_ALLOC_PTR(oinfo);
-+ if (!oinfo)
-+ RETURN(rc ? rc : -ENOMEM);
-+ OBDO_ALLOC(oinfo->oi_oa);
-+ if (!oinfo->oi_oa) {
-+ OBD_FREE_PTR(oinfo);
-+ RETURN(rc ? rc : -ENOMEM);
-+ }
-+ oinfo->oi_oa->o_id = lsm->lsm_object_id;
-+ oinfo->oi_oa->o_gr = lsm->lsm_object_gr;
-+ oinfo->oi_oa->o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
-+ obdo_from_inode(oinfo->oi_oa, inode,
-+ OBD_MD_FLTYPE | OBD_MD_FLATIME |
-+ OBD_MD_FLMTIME | OBD_MD_FLCTIME);
-+ oinfo->oi_md = lsm;
-+ err = obd_sync_rqset(ll_i2sbi(inode)->ll_osc_exp, oinfo,
-+ 0, OBD_OBJECT_EOF);
-+ if (!rc)
-+ rc = err;
-+ OBDO_FREE(oinfo->oi_oa);
-+ OBD_FREE_PTR(oinfo);
-+ }
-+
-+ RETURN(rc);
-+}
-+
-+int ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock)
-+{
-+ struct inode *inode = file->f_dentry->d_inode;
-+ struct ll_sb_info *sbi = ll_i2sbi(inode);
-+ struct lu_fid *fid = ll_inode_lu_fid(inode);
-+ struct ldlm_res_id res_id =
-+ { .name = { fid_seq(fid),
-+ fid_oid(fid),
-+ fid_ver(fid),
-+ LDLM_FLOCK} };
-+ struct ldlm_enqueue_info einfo = { LDLM_FLOCK, 0, NULL,
-+ ldlm_flock_completion_ast, NULL, file_lock };
-+ struct lustre_handle lockh = {0};
-+ ldlm_policy_data_t flock;
-+ int flags = 0;
-+ int rc;
-+ ENTRY;
-+
-+ CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu file_lock=%p\n",
-+ inode->i_ino, file_lock);
-+ ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FLOCK, 1);
-+
-+ if (fid_is_igif(fid)) {
-+ /* If this is an IGIF inode, we need to keep the 1.6-style
-+ * flock mapping for compatibility. If it is a proper FID
-+ * then we know any other client accessing it must also be
-+ * accessing it as a FID and can use the CMD-style flock. */
-+ res_id.name[2] = LDLM_FLOCK;
-+ res_id.name[3] = 0;
-+ }
-+
-+ if (file_lock->fl_flags & FL_FLOCK) {
-+ LASSERT((cmd == F_SETLKW) || (cmd == F_SETLK));
-+ /* set missing params for flock() calls */
-+ file_lock->fl_end = OFFSET_MAX;
-+ file_lock->fl_pid = current->tgid;
-+ }
-+ flock.l_flock.pid = file_lock->fl_pid;
-+ flock.l_flock.start = file_lock->fl_start;
-+ flock.l_flock.end = file_lock->fl_end;
-+
-+ switch (file_lock->fl_type) {
-+ case F_RDLCK:
-+ einfo.ei_mode = LCK_PR;
-+ break;
-+ case F_UNLCK:
-+ /* An unlock request may or may not have any relation to
-+ * existing locks so we may not be able to pass a lock handle
-+ * via a normal ldlm_lock_cancel() request. The request may even
-+ * unlock a byte range in the middle of an existing lock. In
-+ * order to process an unlock request we need all of the same
-+ * information that is given with a normal read or write record
-+ * lock request. To avoid creating another ldlm unlock (cancel)
-+ * message we'll treat a LCK_NL flock request as an unlock. */
-+ einfo.ei_mode = LCK_NL;
-+ break;
-+ case F_WRLCK:
-+ einfo.ei_mode = LCK_PW;
-+ break;
-+ default:
-+ CERROR("unknown fcntl lock type: %d\n", file_lock->fl_type);
-+ RETURN (-EINVAL);
-+ }
-+
-+ switch (cmd) {
-+ case F_SETLKW:
-+#ifdef F_SETLKW64
-+ case F_SETLKW64:
-+#endif
-+ flags = 0;
-+ break;
-+ case F_SETLK:
-+#ifdef F_SETLK64
-+ case F_SETLK64:
-+#endif
-+ flags = LDLM_FL_BLOCK_NOWAIT;
-+ break;
-+ case F_GETLK:
-+#ifdef F_GETLK64
-+ case F_GETLK64:
-+#endif
-+ flags = LDLM_FL_TEST_LOCK;
-+ /* Save the old mode so that if the mode in the lock changes we
-+ * can decrement the appropriate reader or writer refcount. */
-+ file_lock->fl_type = einfo.ei_mode;
-+ break;
-+ default:
-+ CERROR("unknown fcntl lock command: %d\n", cmd);
-+ RETURN (-EINVAL);
-+ }
-+
-+ CDEBUG(D_DLMTRACE, "inode=%lu, pid=%u, flags=%#x, mode=%u, "
-+ "start="LPU64", end="LPU64"\n", inode->i_ino, flock.l_flock.pid,
-+ flags, einfo.ei_mode, flock.l_flock.start, flock.l_flock.end);
-+
-+ rc = ldlm_cli_enqueue(sbi->ll_mdc_exp, NULL, &einfo, res_id,
-+ &flock, &flags, NULL, 0, NULL, &lockh, 0);
-+ if ((file_lock->fl_flags & FL_FLOCK) &&
-+ (rc == 0 || file_lock->fl_type == F_UNLCK))
-+ ll_flock_lock_file_wait(file, file_lock, (cmd == F_SETLKW));
-+#ifdef HAVE_F_OP_FLOCK
-+ if ((file_lock->fl_flags & FL_POSIX) &&
-+ (rc == 0 || file_lock->fl_type == F_UNLCK) &&
-+ !(flags & LDLM_FL_TEST_LOCK))
-+ posix_lock_file_wait(file, file_lock);
-+#endif
-+
-+ RETURN(rc);
-+}
-+
-+int ll_file_noflock(struct file *file, int cmd, struct file_lock *file_lock)
-+{
-+ ENTRY;
-+
-+ RETURN(-ENOSYS);
-+}
-+
-+int ll_have_md_lock(struct inode *inode, __u64 bits)
-+{
-+ struct lustre_handle lockh;
-+ struct ldlm_res_id res_id;
-+ struct obd_device *obddev;
-+ ldlm_policy_data_t policy = { .l_inodebits = {bits}};
-+ int flags;
-+ ENTRY;
-+
-+ if (!inode)
-+ RETURN(0);
-+
-+ obddev = ll_i2mdcexp(inode)->exp_obd;
-+ fid_build_reg_res_name(ll_inode_lu_fid(inode), &res_id);
-+
-+ CDEBUG(D_INFO, "trying to match res "LPU64":"LPU64":"LPU64"\n",
-+ res_id.name[0],
-+ res_id.name[1],
-+ res_id.name[2]);
-+
-+ flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING | LDLM_FL_TEST_LOCK;
-+ if (ldlm_lock_match(obddev->obd_namespace, flags, &res_id, LDLM_IBITS,
-+ &policy, LCK_CR|LCK_CW|LCK_PR|LCK_PW, &lockh)) {
-+ RETURN(1);
-+ }
-+
-+ RETURN(0);
-+}
-+
-+static int ll_inode_revalidate_fini(struct inode *inode, int rc) {
-+ if (rc == -ENOENT) { /* Already unlinked. Just update nlink
-+ * and return success */
-+ inode->i_nlink = 0;
-+ /* This path cannot be hit for regular files unless in
-+ * case of obscure races, so no need to to validate
-+ * size. */
-+ if (!S_ISREG(inode->i_mode) &&
-+ !S_ISDIR(inode->i_mode))
-+ return 0;
-+ }
-+
-+ if (rc) {
-+ CERROR("failure %d inode %lu\n", rc, inode->i_ino);
-+ return -abs(rc);
-+
-+ }
-+
-+ return 0;
-+}
-+
-+int ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it)
-+{
-+ struct inode *inode = dentry->d_inode;
-+ struct ptlrpc_request *req = NULL;
-+ struct obd_export *exp;
-+ int rc;
-+ ENTRY;
-+
-+ if (!inode) {
-+ CERROR("REPORT THIS LINE TO PETER\n");
-+ RETURN(0);
-+ }
-+ CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),name=%s\n",
-+ inode->i_ino, inode->i_generation, inode, dentry->d_name.name);
-+
-+ exp = ll_i2mdcexp(inode);
-+
-+ if (exp->exp_connect_flags & OBD_CONNECT_ATTRFID) {
-+ struct lookup_intent oit = { .it_op = IT_GETATTR };
-+ struct mdc_op_data op_data = { { 0 } };
-+
-+ /* Call getattr by fid, so do not provide name at all. */
-+ ll_prepare_mdc_op_data(&op_data, dentry->d_parent->d_inode,
-+ dentry->d_inode, NULL, 0, 0, NULL);
-+ oit.it_flags |= O_CHECK_STALE;
-+ rc = mdc_intent_lock(exp, &op_data, NULL, 0,
-+ /* we are not interested in name
-+ based lookup */
-+ &oit, 0, &req,
-+ ll_mdc_blocking_ast, 0);
-+ oit.it_flags &= ~O_CHECK_STALE;
-+ if (rc < 0) {
-+ rc = ll_inode_revalidate_fini(inode, rc);
-+ GOTO (out, rc);
-+ }
-+
-+ rc = revalidate_it_finish(req, DLM_REPLY_REC_OFF, &oit, dentry);
-+ if (rc != 0) {
-+ ll_intent_release(&oit);
-+ GOTO(out, rc);
-+ }
-+
-+ /* Unlinked? Unhash dentry, so it is not picked up later by
-+ do_lookup() -> ll_revalidate_it(). We cannot use d_drop
-+ here to preserve get_cwd functionality on 2.6.
-+ Bug 10503 */
-+ if (!dentry->d_inode->i_nlink) {
-+ spin_lock(&ll_lookup_lock);
-+ spin_lock(&dcache_lock);
-+ ll_drop_dentry(dentry);
-+ spin_unlock(&dcache_lock);
-+ spin_unlock(&ll_lookup_lock);
-+ }
-+
-+ ll_lookup_finish_locks(&oit, dentry);
-+ } else if (!ll_have_md_lock(dentry->d_inode,
-+ MDS_INODELOCK_UPDATE|MDS_INODELOCK_LOOKUP)) {
-+ struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
-+ struct ll_fid fid;
-+ obd_valid valid = OBD_MD_FLGETATTR;
-+ int ealen = 0;
-+
-+ if (S_ISREG(inode->i_mode)) {
-+ rc = ll_get_max_mdsize(sbi, &ealen);
-+ if (rc)
-+ RETURN(rc);
-+ valid |= OBD_MD_FLEASIZE | OBD_MD_FLMODEASIZE;
-+ }
-+ ll_inode2fid(&fid, inode);
-+ rc = mdc_getattr(sbi->ll_mdc_exp, &fid, valid, ealen, &req);
-+ if (rc) {
-+ rc = ll_inode_revalidate_fini(inode, rc);
-+ RETURN(rc);
-+ }
-+
-+ rc = ll_prep_inode(sbi->ll_osc_exp, &inode, req, REPLY_REC_OFF,
-+ NULL);
-+ if (rc)
-+ GOTO(out, rc);
-+ }
-+
-+ /* if object not yet allocated, don't validate size */
-+ if (ll_i2info(inode)->lli_smd == NULL) {
-+ LTIME_S(inode->i_atime) = ll_i2info(inode)->lli_lvb.lvb_atime;
-+ LTIME_S(inode->i_mtime) = ll_i2info(inode)->lli_lvb.lvb_mtime;
-+ LTIME_S(inode->i_ctime) = ll_i2info(inode)->lli_lvb.lvb_ctime;
-+ GOTO(out, rc = 0);
-+ }
-+
-+ /* ll_glimpse_size will prefer locally cached writes if they extend
-+ * the file */
-+ rc = ll_glimpse_size(inode, 0);
-+
-+out:
-+ ptlrpc_req_finished(req);
-+ RETURN(rc);
-+}
-+
-+int ll_getattr_it(struct vfsmount *mnt, struct dentry *de,
-+ struct lookup_intent *it, struct kstat *stat)
-+{
-+ struct inode *inode = de->d_inode;
-+ int res = 0;
-+
-+ res = ll_inode_revalidate_it(de, it);
-+ ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_GETATTR, 1);
-+
-+ if (res)
-+ return res;
-+
-+ stat->dev = inode->i_sb->s_dev;
-+ stat->ino = inode->i_ino;
-+ stat->mode = inode->i_mode;
-+ stat->nlink = inode->i_nlink;
-+ stat->uid = inode->i_uid;
-+ stat->gid = inode->i_gid;
-+ stat->rdev = kdev_t_to_nr(inode->i_rdev);
-+ stat->atime = inode->i_atime;
-+ stat->mtime = inode->i_mtime;
-+ stat->ctime = inode->i_ctime;
-+#ifdef HAVE_INODE_BLKSIZE
-+ stat->blksize = inode->i_blksize;
-+#else
-+ stat->blksize = 1<<inode->i_blkbits;
-+#endif
-+
-+ ll_inode_size_lock(inode, 0);
-+ stat->size = i_size_read(inode);
-+ stat->blocks = inode->i_blocks;
-+ ll_inode_size_unlock(inode, 0);
-+
-+ return 0;
-+}
-+int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat)
-+{
-+ struct lookup_intent it = { .it_op = IT_GETATTR };
-+
-+ return ll_getattr_it(mnt, de, &it, stat);
-+}
-+
-+static
-+int lustre_check_acl(struct inode *inode, int mask)
-+{
-+#ifdef CONFIG_FS_POSIX_ACL
-+ struct ll_inode_info *lli = ll_i2info(inode);
-+ struct posix_acl *acl;
-+ int rc;
-+ ENTRY;
-+
-+ spin_lock(&lli->lli_lock);
-+ acl = posix_acl_dup(lli->lli_posix_acl);
-+ spin_unlock(&lli->lli_lock);
-+
-+ if (!acl)
-+ RETURN(-EAGAIN);
-+
-+ rc = posix_acl_permission(inode, acl, mask);
-+ posix_acl_release(acl);
-+
-+ RETURN(rc);
-+#else
-+ return -EAGAIN;
-+#endif
-+}
-+
-+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10))
-+int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
-+{
-+ CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), mask %o\n",
-+ inode->i_ino, inode->i_generation, inode, mask);
-+
-+ ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_INODE_PERM, 1);
-+ return generic_permission(inode, mask, lustre_check_acl);
-+}
-+#else
-+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
-+int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
-+#else
-+int ll_inode_permission(struct inode *inode, int mask)
-+#endif
-+{
-+ int mode = inode->i_mode;
-+ int rc;
-+
-+ CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), mask %o\n",
-+ inode->i_ino, inode->i_generation, inode, mask);
-+ ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_INODE_PERM, 1);
-+
-+ if ((mask & MAY_WRITE) && IS_RDONLY(inode) &&
-+ (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
-+ return -EROFS;
-+ if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
-+ return -EACCES;
-+ if (current->fsuid == inode->i_uid) {
-+ mode >>= 6;
-+ } else if (1) {
-+ if (((mode >> 3) & mask & S_IRWXO) != mask)
-+ goto check_groups;
-+ rc = lustre_check_acl(inode, mask);
-+ if (rc == -EAGAIN)
-+ goto check_groups;
-+ if (rc == -EACCES)
-+ goto check_capabilities;
-+ return rc;
-+ } else {
-+check_groups:
-+ if (in_group_p(inode->i_gid))
-+ mode >>= 3;
-+ }
-+ if ((mode & mask & S_IRWXO) == mask)
-+ return 0;
-+
-+check_capabilities:
-+ if (!(mask & MAY_EXEC) ||
-+ (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode))
-+ if (cfs_capable(CFS_CAP_DAC_OVERRIDE))
-+ return 0;
-+
-+ if (cfs_capable(CFS_CAP_DAC_READ_SEARCH) && ((mask == MAY_READ) ||
-+ (S_ISDIR(inode->i_mode) && !(mask & MAY_WRITE))))
-+ return 0;
-+
-+ return -EACCES;
-+}
-+#endif
-+
-+/* -o localflock - only provides locally consistent flock locks */
-+struct file_operations ll_file_operations = {
-+ .read = ll_file_read,
-+#ifdef HAVE_FILE_READV
-+ .readv = ll_file_readv,
-+#else
-+ .aio_read = ll_file_aio_read,
-+#endif
-+ .write = ll_file_write,
-+#ifdef HAVE_FILE_WRITEV
-+ .writev = ll_file_writev,
-+#else
-+ .aio_write = ll_file_aio_write,
-+#endif
-+ .ioctl = ll_file_ioctl,
-+ .open = ll_file_open,
-+ .release = ll_file_release,
-+ .mmap = ll_file_mmap,
-+ .llseek = ll_file_seek,
-+#ifdef HAVE_KERNEL_SENDFILE
-+ .sendfile = ll_file_sendfile,
-+#endif
-+ .fsync = ll_fsync,
-+};
-+
-+struct file_operations ll_file_operations_flock = {
-+ .read = ll_file_read,
-+#ifdef HAVE_FILE_READV
-+ .readv = ll_file_readv,
-+#else
-+ .aio_read = ll_file_aio_read,
-+#endif
-+ .write = ll_file_write,
-+#ifdef HAVE_FILE_WRITEV
-+ .writev = ll_file_writev,
-+#else
-+ .aio_write = ll_file_aio_write,
-+#endif
-+ .ioctl = ll_file_ioctl,
-+ .open = ll_file_open,
-+ .release = ll_file_release,
-+ .mmap = ll_file_mmap,
-+ .llseek = ll_file_seek,
-+#ifdef HAVE_KERNEL_SENDFILE
-+ .sendfile = ll_file_sendfile,
-+#endif
-+ .fsync = ll_fsync,
-+#ifdef HAVE_F_OP_FLOCK
-+ .flock = ll_file_flock,
-+#endif
-+ .lock = ll_file_flock
-+};
-+
-+/* These are for -o noflock - to return ENOSYS on flock calls */
-+struct file_operations ll_file_operations_noflock = {
-+ .read = ll_file_read,
-+#ifdef HAVE_FILE_READV
-+ .readv = ll_file_readv,
-+#else
-+ .aio_read = ll_file_aio_read,
-+#endif
-+ .write = ll_file_write,
-+#ifdef HAVE_FILE_WRITEV
-+ .writev = ll_file_writev,
-+#else
-+ .aio_write = ll_file_aio_write,
-+#endif
-+ .ioctl = ll_file_ioctl,
-+ .open = ll_file_open,
-+ .release = ll_file_release,
-+ .mmap = ll_file_mmap,
-+ .llseek = ll_file_seek,
-+ .sendfile = ll_file_sendfile,
-+ .fsync = ll_fsync,
-+#ifdef HAVE_F_OP_FLOCK
-+ .flock = ll_file_noflock,
-+#endif
-+ .lock = ll_file_noflock
-+};
-+
-+struct inode_operations ll_file_inode_operations = {
-+#ifdef HAVE_VFS_INTENT_PATCHES
-+ .setattr_raw = ll_setattr_raw,
-+#endif
-+ .setattr = ll_setattr,
-+ .truncate = ll_truncate,
-+ .getattr = ll_getattr,
-+ .permission = ll_inode_permission,
-+ .setxattr = ll_setxattr,
-+ .getxattr = ll_getxattr,
-+ .listxattr = ll_listxattr,
-+ .removexattr = ll_removexattr,
-+};
-+
-+/* dynamic ioctl number support routins */
-+static struct llioc_ctl_data {
-+ struct rw_semaphore ioc_sem;
-+ struct list_head ioc_head;
-+} llioc = {
-+ __RWSEM_INITIALIZER(llioc.ioc_sem),
-+ CFS_LIST_HEAD_INIT(llioc.ioc_head)
-+};
-+
-+
-+struct llioc_data {
-+ struct list_head iocd_list;
-+ unsigned int iocd_size;
-+ llioc_callback_t iocd_cb;
-+ unsigned int iocd_count;
-+ unsigned int iocd_cmd[0];
-+};
-+
-+void *ll_iocontrol_register(llioc_callback_t cb, int count, unsigned int *cmd)
-+{
-+ unsigned int size;
-+ struct llioc_data *in_data = NULL;
-+ ENTRY;
-+
-+ if (cb == NULL || cmd == NULL ||
-+ count > LLIOC_MAX_CMD || count < 0)
-+ RETURN(NULL);
-+
-+ size = sizeof(*in_data) + count * sizeof(unsigned int);
-+ OBD_ALLOC(in_data, size);
-+ if (in_data == NULL)
-+ RETURN(NULL);
-+
-+ memset(in_data, 0, sizeof(*in_data));
-+ in_data->iocd_size = size;
-+ in_data->iocd_cb = cb;
-+ in_data->iocd_count = count;
-+ memcpy(in_data->iocd_cmd, cmd, sizeof(unsigned int) * count);
-+
-+ down_write(&llioc.ioc_sem);
-+ list_add_tail(&in_data->iocd_list, &llioc.ioc_head);
-+ up_write(&llioc.ioc_sem);
-+
-+ RETURN(in_data);
-+}
-+
-+void ll_iocontrol_unregister(void *magic)
-+{
-+ struct llioc_data *tmp;
-+
-+ if (magic == NULL)
-+ return;
-+
-+ down_write(&llioc.ioc_sem);
-+ list_for_each_entry(tmp, &llioc.ioc_head, iocd_list) {
-+ if (tmp == magic) {
-+ unsigned int size = tmp->iocd_size;
-+
-+ list_del(&tmp->iocd_list);
-+ up_write(&llioc.ioc_sem);
-+
-+ OBD_FREE(tmp, size);
-+ return;
-+ }
-+ }
-+ up_write(&llioc.ioc_sem);
-+
-+ CWARN("didn't find iocontrol register block with magic: %p\n", magic);
-+}
-+
-+EXPORT_SYMBOL(ll_iocontrol_register);
-+EXPORT_SYMBOL(ll_iocontrol_unregister);
-+
-+enum llioc_iter ll_iocontrol_call(struct inode *inode, struct file *file,
-+ unsigned int cmd, unsigned long arg, int *rcp)
-+{
-+ enum llioc_iter ret = LLIOC_CONT;
-+ struct llioc_data *data;
-+ int rc = -EINVAL, i;
-+
-+ down_read(&llioc.ioc_sem);
-+ list_for_each_entry(data, &llioc.ioc_head, iocd_list) {
-+ for (i = 0; i < data->iocd_count; i++) {
-+ if (cmd != data->iocd_cmd[i])
-+ continue;
-+
-+ ret = data->iocd_cb(inode, file, cmd, arg, data, &rc);
-+ break;
-+ }
-+
-+ if (ret == LLIOC_STOP)
-+ break;
-+ }
-+ up_read(&llioc.ioc_sem);
-+
-+ if (rcp)
-+ *rcp = rc;
-+ return ret;
-+}
diff -urNad lustre~/lustre/llite/lloop.c lustre/lustre/llite/lloop.c
--- lustre~/lustre/llite/lloop.c 2009-06-02 11:38:20.000000000 +0200
-+++ lustre/lustre/llite/lloop.c 2009-06-05 10:12:08.000000000 +0200
++++ lustre/lustre/llite/lloop.c 2009-06-05 10:43:08.000000000 +0200
@@ -347,7 +347,7 @@
loop_add_bio(lo, old_bio);
return 0;
--
Lustre Debian Packaging
More information about the Pkg-lustre-svn-commit
mailing list