X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fllite%2Fnamei.c;h=f5288a98eceb7ce32c2206fa9a2388a3295b6673;hp=4df002156f7e30b67e088dc248ae8b756be5c6fb;hb=d2b203692e24cde8e39266f91e9a150c5a287111;hpb=a2877f1f6c0fd0ec5ece836a216f42af3ef913da

diff --git a/lustre/llite/namei.c b/lustre/llite/namei.c
index 4df0021..f5288a9 100644
--- a/lustre/llite/namei.c
+++ b/lustre/llite/namei.c
@@ -27,7 +27,7 @@
  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  *
- * Copyright (c) 2011, 2013, Intel Corporation.
+ * Copyright (c) 2011, 2014, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -46,119 +46,104 @@
 
 #include <obd_support.h>
 #include <lustre_fid.h>
-#include <lustre_lite.h>
 #include <lustre_dlm.h>
 #include <lustre_ver.h>
 #include "llite_internal.h"
 
-static int ll_create_it(struct inode *, struct dentry *,
-			int, struct lookup_intent *);
-
-/*
- * Check if we have something mounted at the named dchild.
- * In such a case there would always be dentry present.
- */
-static int ll_d_mountpoint(struct dentry *dparent, struct dentry *dchild,
-			   struct qstr *name)
-{
-        int mounted = 0;
-
-        if (unlikely(dchild)) {
-                mounted = d_mountpoint(dchild);
-        } else if (dparent) {
-                dchild = d_lookup(dparent, name);
-                if (dchild) {
-                        mounted = d_mountpoint(dchild);
-                        dput(dchild);
-                }
-        }
-        return mounted;
-}
+static int ll_create_it(struct inode *dir, struct dentry *dentry,
+			struct lookup_intent *it);
 
 /* called from iget5_locked->find_inode() under inode_lock spinlock */
 static int ll_test_inode(struct inode *inode, void *opaque)
 {
-        struct ll_inode_info *lli = ll_i2info(inode);
-        struct lustre_md     *md = opaque;
+	struct ll_inode_info	*lli = ll_i2info(inode);
+	struct lustre_md	*md = opaque;
 
-        if (unlikely(!(md->body->valid & OBD_MD_FLID))) {
-                CERROR("MDS body missing FID\n");
-                return 0;
-        }
+	if (unlikely(!(md->body->mbo_valid & OBD_MD_FLID))) {
+		CERROR("MDS body missing FID\n");
+		return 0;
+	}
 
-        if (!lu_fid_eq(&lli->lli_fid, &md->body->fid1))
-                return 0;
+	if (!lu_fid_eq(&lli->lli_fid, &md->body->mbo_fid1))
+		return 0;
 
-        return 1;
+	return 1;
 }
 
 static int ll_set_inode(struct inode *inode, void *opaque)
 {
-        struct ll_inode_info *lli = ll_i2info(inode);
-        struct mdt_body *body = ((struct lustre_md *)opaque)->body;
+	struct ll_inode_info *lli = ll_i2info(inode);
+	struct mdt_body *body = ((struct lustre_md *)opaque)->body;
 
-        if (unlikely(!(body->valid & OBD_MD_FLID))) {
-                CERROR("MDS body missing FID\n");
-                return -EINVAL;
-        }
+	if (unlikely(!(body->mbo_valid & OBD_MD_FLID))) {
+		CERROR("MDS body missing FID\n");
+		return -EINVAL;
+	}
 
-        lli->lli_fid = body->fid1;
-        if (unlikely(!(body->valid & OBD_MD_FLTYPE))) {
-                CERROR("Can not initialize inode "DFID" without object type: "
-                       "valid = "LPX64"\n", PFID(&lli->lli_fid), body->valid);
-                return -EINVAL;
-        }
+	lli->lli_fid = body->mbo_fid1;
+	if (unlikely(!(body->mbo_valid & OBD_MD_FLTYPE))) {
+		CERROR("Can not initialize inode "DFID" without object type: "
+		       "valid = "LPX64"\n",
+		       PFID(&lli->lli_fid), body->mbo_valid);
+		return -EINVAL;
+	}
 
-        inode->i_mode = (inode->i_mode & ~S_IFMT) | (body->mode & S_IFMT);
-        if (unlikely(inode->i_mode == 0)) {
-                CERROR("Invalid inode "DFID" type\n", PFID(&lli->lli_fid));
-                return -EINVAL;
-        }
+	inode->i_mode = (inode->i_mode & ~S_IFMT) | (body->mbo_mode & S_IFMT);
+	if (unlikely(inode->i_mode == 0)) {
+		CERROR("Invalid inode "DFID" type\n", PFID(&lli->lli_fid));
+		return -EINVAL;
+	}
 
-        ll_lli_init(lli);
+	ll_lli_init(lli);
 
-        return 0;
+	return 0;
 }
 
 
-/*
- * Get an inode by inode number (already instantiated by the intent lookup).
- * Returns inode or NULL
+/**
+ * Get an inode by inode number(@hash), which is already instantiated by
+ * the intent lookup).
  */
 struct inode *ll_iget(struct super_block *sb, ino_t hash,
                       struct lustre_md *md)
 {
-        struct inode         *inode;
-        ENTRY;
+	struct inode	*inode;
+	int		rc = 0;
+
+	ENTRY;
 
         LASSERT(hash != 0);
         inode = iget5_locked(sb, hash, ll_test_inode, ll_set_inode, md);
+	if (inode == NULL)
+		RETURN(ERR_PTR(-ENOMEM));
+
+	if (inode->i_state & I_NEW) {
+		rc = ll_read_inode2(inode, md);
+		if (rc == 0 && S_ISREG(inode->i_mode) &&
+		    ll_i2info(inode)->lli_clob == NULL) {
+			CDEBUG(D_INODE, "%s: apply lsm %p to inode "DFID"\n",
+				ll_get_fsname(sb, NULL, 0), md->lsm,
+				PFID(ll_inode2fid(inode)));
+			rc = cl_file_inode_init(inode, md);
+		}
+		if (rc != 0) {
+			make_bad_inode(inode);
+			unlock_new_inode(inode);
+			iput(inode);
+			inode = ERR_PTR(rc);
+		} else {
+			unlock_new_inode(inode);
+		}
+	} else if (!(inode->i_state & (I_FREEING | I_CLEAR))) {
+		rc = ll_update_inode(inode, md);
+		CDEBUG(D_VFSTRACE, "got inode: "DFID"(%p): rc = %d\n",
+		       PFID(&md->body->mbo_fid1), inode, rc);
+		if (rc != 0) {
+			iput(inode);
+			inode = ERR_PTR(rc);
+		}
+	}
 
-        if (inode) {
-                if (inode->i_state & I_NEW) {
-                        int rc = 0;
-
-                        ll_read_inode2(inode, md);
-                        if (S_ISREG(inode->i_mode) &&
-                            ll_i2info(inode)->lli_clob == NULL) {
-				CDEBUG(D_INODE,
-					"%s: apply lsm %p to inode "DFID".\n",
-					ll_get_fsname(sb, NULL, 0), md->lsm,
-					PFID(ll_inode2fid(inode)));
-                                rc = cl_file_inode_init(inode, md);
-			}
-                        if (rc != 0) {
-                                make_bad_inode(inode);
-                                unlock_new_inode(inode);
-                                iput(inode);
-                                inode = ERR_PTR(rc);
-                        } else
-                                unlock_new_inode(inode);
-                } else if (!(inode->i_state & (I_FREEING | I_CLEAR)))
-                        ll_update_inode(inode, md);
-			CDEBUG(D_VFSTRACE, "got inode: "DFID"(%p)\n",
-			       PFID(&md->body->fid1), inode);
-        }
         RETURN(inode);
 }
 
@@ -228,6 +213,8 @@ int ll_md_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
 		}
 
 		if (bits & MDS_INODELOCK_XATTR) {
+			if (S_ISDIR(inode->i_mode))
+				ll_i2info(inode)->lli_def_stripe_offset = -1;
 			ll_xattr_cache_destroy(inode);
 			bits &= ~MDS_INODELOCK_XATTR;
 		}
@@ -431,7 +418,7 @@ struct dentry *ll_splice_alias(struct inode *inode, struct dentry *de)
 			iput(inode);
 			CDEBUG(D_DENTRY,
 			       "Reuse dentry %p inode %p refc %d flags %#x\n",
-			      new, new->d_inode, d_count(new), new->d_flags);
+			      new, new->d_inode, ll_d_count(new), new->d_flags);
 			return new;
 		}
 	}
@@ -440,7 +427,7 @@ struct dentry *ll_splice_alias(struct inode *inode, struct dentry *de)
 		return ERR_PTR(rc);
 	d_add(de, inode);
 	CDEBUG(D_DENTRY, "Add dentry %p inode %p refc %d flags %#x\n",
-	       de, de->d_inode, d_count(de), de->d_flags);
+	       de, de->d_inode, ll_d_count(de), de->d_flags);
         return de;
 }
 
@@ -482,7 +469,8 @@ static int ll_lookup_it_finish(struct ptlrpc_request *request,
 
 		alias = ll_splice_alias(inode, *de);
 		if (IS_ERR(alias))
-			RETURN(PTR_ERR(alias));
+			GOTO(out, rc = PTR_ERR(alias));
+
 		*de = alias;
 	} else if (!it_disposition(it, DISP_LOOKUP_NEG)  &&
 		   !it_disposition(it, DISP_OPEN_CREATE)) {
@@ -505,24 +493,41 @@ static int ll_lookup_it_finish(struct ptlrpc_request *request,
 		struct lookup_intent parent_it = {
 					.it_op = IT_GETATTR,
 					.d.lustre.it_lock_handle = 0 };
+		struct lu_fid	fid = ll_i2info(parent)->lli_fid;
+
+		/* If it is striped directory, get the real stripe parent */
+		if (unlikely(ll_i2info(parent)->lli_lsm_md != NULL)) {
+			rc = md_get_fid_from_lsm(ll_i2mdexp(parent),
+						 ll_i2info(parent)->lli_lsm_md,
+						 (*de)->d_name.name,
+						 (*de)->d_name.len, &fid);
+			if (rc != 0)
+				GOTO(out, rc);
+		}
 
-		if (md_revalidate_lock(ll_i2mdexp(parent), &parent_it,
-				       &ll_i2info(parent)->lli_fid, NULL)) {
+		if (md_revalidate_lock(ll_i2mdexp(parent), &parent_it, &fid,
+				       NULL)) {
 			d_lustre_revalidate(*de);
 			ll_intent_release(&parent_it);
 		}
-        }
+	}
+
+	GOTO(out, rc = 0);
+
+out:
+	if (rc != 0 && it->it_op & IT_OPEN)
+		ll_open_cleanup((*de)->d_sb, request);
 
-        RETURN(0);
+	return rc;
 }
 
 static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
-                                   struct lookup_intent *it, int lookup_flags)
+				   struct lookup_intent *it)
 {
-        struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
-        struct dentry *save = dentry, *retval;
-        struct ptlrpc_request *req = NULL;
-        struct md_op_data *op_data;
+	struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
+	struct dentry *save = dentry, *retval;
+	struct ptlrpc_request *req = NULL;
+	struct md_op_data *op_data = NULL;
         __u32 opc;
         int rc;
         ENTRY;
@@ -540,35 +545,56 @@ static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
 	if (it == NULL || it->it_op == IT_GETXATTR)
 		it = &lookup_it;
 
-        if (it->it_op == IT_GETATTR) {
-                rc = ll_statahead_enter(parent, &dentry, 0);
-                if (rc == 1) {
-                        if (dentry == save)
-                                GOTO(out, retval = NULL);
-                        GOTO(out, retval = dentry);
-                }
-        }
+	if (it->it_op == IT_GETATTR && dentry_may_statahead(parent, dentry)) {
+		rc = ll_statahead(parent, &dentry, 0);
+		if (rc == 1)
+			RETURN(dentry == save ? NULL : dentry);
+	}
 
 	if (it->it_op & IT_CREAT)
 		opc = LUSTRE_OPC_CREATE;
 	else
 		opc = LUSTRE_OPC_ANY;
 
-        op_data = ll_prep_md_op_data(NULL, parent, NULL, dentry->d_name.name,
-                                     dentry->d_name.len, lookup_flags, opc,
-                                     NULL);
-        if (IS_ERR(op_data))
-                RETURN((void *)op_data);
+	op_data = ll_prep_md_op_data(NULL, parent, NULL, dentry->d_name.name,
+				     dentry->d_name.len, 0, opc, NULL);
+	if (IS_ERR(op_data))
+		RETURN((void *)op_data);
 
-        /* enforce umask if acl disabled or MDS doesn't support umask */
-        if (!IS_POSIXACL(parent) || !exp_connect_umask(ll_i2mdexp(parent)))
+	/* enforce umask if acl disabled or MDS doesn't support umask */
+	if (!IS_POSIXACL(parent) || !exp_connect_umask(ll_i2mdexp(parent)))
 		it->it_create_mode &= ~current_umask();
 
 	rc = md_intent_lock(ll_i2mdexp(parent), op_data, it, &req,
 			    &ll_md_blocking_ast, 0);
-        ll_finish_md_op_data(op_data);
-        if (rc < 0)
-                GOTO(out, retval = ERR_PTR(rc));
+	/* If the MDS allows the client to chgrp (CFS_SETGRP_PERM), but the
+	 * client does not know which suppgid should be sent to the MDS, or
+	 * some other(s) changed the target file's GID after this RPC sent
+	 * to the MDS with the suppgid as the original GID, then we should
+	 * try again with right suppgid. */
+	if (rc == -EACCES && it->it_op & IT_OPEN &&
+	    it_disposition(it, DISP_OPEN_DENY)) {
+		struct mdt_body *body;
+
+		LASSERT(req != NULL);
+
+		body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
+		if (op_data->op_suppgids[0] == body->mbo_gid ||
+		    op_data->op_suppgids[1] == body->mbo_gid ||
+		    !in_group_p(make_kgid(&init_user_ns, body->mbo_gid)))
+			GOTO(out, retval = ERR_PTR(-EACCES));
+
+		fid_zero(&op_data->op_fid2);
+		op_data->op_suppgids[1] = body->mbo_gid;
+		ptlrpc_req_finished(req);
+		req = NULL;
+		ll_intent_release(it);
+		rc = md_intent_lock(ll_i2mdexp(parent), op_data, it, &req,
+				    &ll_md_blocking_ast, 0);
+	}
+
+	if (rc < 0)
+		GOTO(out, retval = ERR_PTR(rc));
 
 	rc = ll_lookup_it_finish(req, it, parent, &dentry);
         if (rc != 0) {
@@ -583,16 +609,14 @@ static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
         }
         ll_lookup_finish_locks(it, dentry);
 
-        if (dentry == save)
-                GOTO(out, retval = NULL);
-        else
-                GOTO(out, retval = dentry);
- out:
-        if (req)
-                ptlrpc_req_finished(req);
-        if (it->it_op == IT_GETATTR && (retval == NULL || retval == dentry))
-                ll_statahead_mark(parent, dentry);
-        return retval;
+	GOTO(out, retval = (dentry == save) ? NULL : dentry);
+
+out:
+	if (op_data != NULL && !IS_ERR(op_data))
+		ll_finish_md_op_data(op_data);
+
+	ptlrpc_req_finished(req);
+	return retval;
 }
 
 #ifdef HAVE_IOP_ATOMIC_OPEN
@@ -614,7 +638,7 @@ static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
 		itp = NULL;
 	else
 		itp = &it;
-	de = ll_lookup_it(parent, dentry, itp, 0);
+	de = ll_lookup_it(parent, dentry, itp);
 
 	if (itp != NULL)
 		ll_intent_release(itp);
@@ -652,9 +676,10 @@ static int ll_atomic_open(struct inode *dir, struct dentry *dentry,
 	}
 	it->it_create_mode = (mode & S_IALLUGO) | S_IFREG;
 	it->it_flags = (open_flags & ~O_ACCMODE) | OPEN_FMODE(open_flags);
+	it->it_flags &= ~MDS_OPEN_FL_INTERNAL;
 
 	/* Dentry added to dcache tree in ll_lookup_it */
-	de = ll_lookup_it(dir, dentry, it, lookup_flags);
+	de = ll_lookup_it(dir, dentry, it);
 	if (IS_ERR(de))
 		rc = PTR_ERR(de);
 	else if (de != NULL)
@@ -663,7 +688,7 @@ static int ll_atomic_open(struct inode *dir, struct dentry *dentry,
 	if (!rc) {
 		if (it_disposition(it, DISP_OPEN_CREATE)) {
 			/* Dentry instantiated in ll_create_it. */
-			rc = ll_create_it(dir, dentry, mode, it);
+			rc = ll_create_it(dir, dentry, it);
 			if (rc) {
 				/* We dget in ll_splice_alias. */
 				if (de != NULL)
@@ -711,7 +736,7 @@ ll_convert_intent(struct open_intent *oit, int lookup_flags)
 {
 	struct lookup_intent *it;
 
-	OBD_ALLOC(it, sizeof(*it));
+	OBD_ALLOC_PTR(it);
 	if (!it)
 		return ERR_PTR(-ENOMEM);
 
@@ -721,6 +746,7 @@ ll_convert_intent(struct open_intent *oit, int lookup_flags)
 			it->it_op |= IT_CREAT;
 		it->it_create_mode = (oit->create_mode & S_IALLUGO) | S_IFREG;
 		it->it_flags = ll_namei_to_lookup_intent_flag(oit->flags);
+		it->it_flags &= ~MDS_OPEN_FL_INTERNAL;
 	} else {
 		it->it_op = IT_GETATTR;
 	}
@@ -750,7 +776,7 @@ static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
                                 RETURN((struct dentry *)it);
                 }
 
-                de = ll_lookup_it(parent, dentry, it, nd->flags);
+		de = ll_lookup_it(parent, dentry, it);
                 if (de)
                         dentry = de;
                 if ((nd->flags & LOOKUP_OPEN) && !IS_ERR(dentry)) { /* Open */
@@ -791,10 +817,10 @@ static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
                         OBD_FREE(it, sizeof(*it));
                 }
         } else {
-                de = ll_lookup_it(parent, dentry, NULL, 0);
-        }
+		de = ll_lookup_it(parent, dentry, NULL);
+	}
 
-        RETURN(de);
+	RETURN(de);
 }
 #endif /* HAVE_IOP_ATOMIC_OPEN */
 
@@ -844,7 +870,7 @@ static struct inode *ll_create_node(struct inode *dir, struct lookup_intent *it)
  * If the create succeeds, we fill in the inode information
  * with d_instantiate().
  */
-static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode,
+static int ll_create_it(struct inode *dir, struct dentry *dentry,
 			struct lookup_intent *it)
 {
 	struct inode *inode;
@@ -869,26 +895,27 @@ static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode,
 
 void ll_update_times(struct ptlrpc_request *request, struct inode *inode)
 {
-        struct mdt_body *body = req_capsule_server_get(&request->rq_pill,
-                                                       &RMF_MDT_BODY);
+	struct mdt_body *body = req_capsule_server_get(&request->rq_pill,
+						       &RMF_MDT_BODY);
 
-        LASSERT(body);
-        if (body->valid & OBD_MD_FLMTIME &&
-            body->mtime > LTIME_S(inode->i_mtime)) {
+	LASSERT(body);
+	if (body->mbo_valid & OBD_MD_FLMTIME &&
+	    body->mbo_mtime > LTIME_S(inode->i_mtime)) {
 		CDEBUG(D_INODE, "setting fid "DFID" mtime from %lu to "LPU64
-				"\n", PFID(ll_inode2fid(inode)),
-				LTIME_S(inode->i_mtime), body->mtime);
-                LTIME_S(inode->i_mtime) = body->mtime;
-        }
-        if (body->valid & OBD_MD_FLCTIME &&
-            body->ctime > LTIME_S(inode->i_ctime))
-                LTIME_S(inode->i_ctime) = body->ctime;
+		       "\n", PFID(ll_inode2fid(inode)),
+		       LTIME_S(inode->i_mtime), body->mbo_mtime);
+		LTIME_S(inode->i_mtime) = body->mbo_mtime;
+	}
+
+	if (body->mbo_valid & OBD_MD_FLCTIME &&
+	    body->mbo_ctime > LTIME_S(inode->i_ctime))
+		LTIME_S(inode->i_ctime) = body->mbo_ctime;
 }
 
-static int ll_new_node(struct inode *dir, struct qstr *name,
-                       const char *tgt, int mode, int rdev,
-                       struct dentry *dchild, __u32 opc)
+static int ll_new_node(struct inode *dir, struct dentry *dchild,
+		       const char *tgt, umode_t mode, int rdev, __u32 opc)
 {
+	struct qstr *name = &dchild->d_name;
         struct ptlrpc_request *request = NULL;
         struct md_op_data *op_data;
         struct inode *inode = NULL;
@@ -900,6 +927,7 @@ static int ll_new_node(struct inode *dir, struct qstr *name,
         if (unlikely(tgt != NULL))
                 tgt_len = strlen(tgt) + 1;
 
+again:
         op_data = ll_prep_md_op_data(NULL, dir, NULL, name->name,
                                      name->len, 0, opc, NULL);
         if (IS_ERR(op_data))
@@ -910,29 +938,63 @@ static int ll_new_node(struct inode *dir, struct qstr *name,
 			from_kgid(&init_user_ns, current_fsgid()),
 			cfs_curproc_cap_pack(), rdev, &request);
 	ll_finish_md_op_data(op_data);
-        if (err)
-                GOTO(err_exit, err);
+	if (err) {
+		/* If the client doesn't know where to create a subdirectory (or
+		 * in case of a race that sends the RPC to the wrong MDS), the
+		 * MDS will return -EREMOTE and the client will fetch the layout
+		 * for the directory, either from the local xattr cache or the
+		 * MDS, then create the directory on the right MDT. */
+		if (err == -EREMOTE) {
+			struct lmv_user_md *lum;
+			int rc;
+
+			ptlrpc_req_finished(request);
+			request = NULL;
+
+			OBD_ALLOC_PTR(lum);
+			if (lum == NULL)
+				GOTO(err_exit, err = -ENOMEM);
+
+			rc = ll_getxattr_common(dir, XATTR_NAME_DEFAULT_LMV,
+						lum, sizeof(*lum),
+						OBD_MD_FLXATTR);
+			if (rc < 0) {
+				OBD_FREE_PTR(lum);
+				if (rc == -ENODATA)
+					GOTO(err_exit, err);
+				else
+					GOTO(err_exit, rc);
+			}
+
+			ll_i2info(dir)->lli_def_stripe_offset =
+				le32_to_cpu(lum->lum_stripe_offset);
+			OBD_FREE_PTR(lum);
+			goto again;
+		}
+		GOTO(err_exit, err);
+	}
 
         ll_update_times(request, dir);
 
-        if (dchild) {
-                err = ll_prep_inode(&inode, request, dchild->d_sb, NULL);
-                if (err)
-                     GOTO(err_exit, err);
+	err = ll_prep_inode(&inode, request, dchild->d_sb, NULL);
+	if (err)
+		GOTO(err_exit, err);
+
+	d_instantiate(dchild, inode);
 
-                d_instantiate(dchild, inode);
-        }
         EXIT;
 err_exit:
-        ptlrpc_req_finished(request);
+	if (request != NULL)
+		ptlrpc_req_finished(request);
 
         return err;
 }
 
-static int ll_mknod_generic(struct inode *dir, struct qstr *name, int mode,
-                            unsigned rdev, struct dentry *dchild)
+static int ll_mknod(struct inode *dir, struct dentry *dchild, ll_umode_t mode,
+		    dev_t rdev)
 {
-        int err;
+	struct qstr *name = &dchild->d_name;
+	int err;
         ENTRY;
 
 	CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p) mode %o dev %x\n",
@@ -950,8 +1012,8 @@ static int ll_mknod_generic(struct inode *dir, struct qstr *name, int mode,
         case S_IFBLK:
         case S_IFIFO:
         case S_IFSOCK:
-                err = ll_new_node(dir, name, NULL, mode, rdev, dchild,
-                                  LUSTRE_OPC_MKNOD);
+		err = ll_new_node(dir, dchild, NULL, mode, old_encode_dev(rdev),
+				  LUSTRE_OPC_MKNOD);
                 break;
         case S_IFDIR:
                 err = -EPERM;
@@ -980,7 +1042,7 @@ static int ll_create_nd(struct inode *dir, struct dentry *dentry,
 	       dentry->d_name.name, PFID(ll_inode2fid(dir)),
 	       dir, mode, want_excl);
 
-	rc = ll_mknod_generic(dir, &dentry->d_name, mode, 0, dentry);
+	rc = ll_mknod(dir, dentry, mode, 0);
 
 	ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_CREATE, 1);
 
@@ -1001,7 +1063,7 @@ static int ll_create_nd(struct inode *dir, struct dentry *dentry,
 		it = lld->lld_it;
 
         if (!it)
-                return ll_mknod_generic(dir, &dentry->d_name, mode, 0, dentry);
+		return ll_mknod(dir, dentry, mode, 0);
 
 	lld->lld_it = NULL;
 
@@ -1011,7 +1073,7 @@ static int ll_create_nd(struct inode *dir, struct dentry *dentry,
                 goto out;
         }
 
-        rc = ll_create_it(dir, dentry, mode, it);
+	rc = ll_create_it(dir, dentry, it);
         if (nd && (nd->flags & LOOKUP_OPEN) && dentry->d_inode) { /* Open */
 		struct file *filp;
 
@@ -1032,18 +1094,19 @@ out:
 }
 #endif /* HAVE_IOP_ATOMIC_OPEN */
 
-static int ll_symlink_generic(struct inode *dir, struct qstr *name,
-                              const char *tgt, struct dentry *dchild)
+static int ll_symlink(struct inode *dir, struct dentry *dchild,
+		      const char *oldpath)
 {
-        int err;
-        ENTRY;
+	struct qstr *name = &dchild->d_name;
+	int err;
+	ENTRY;
 
 	CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p), target=%.*s\n",
 	       name->len, name->name, PFID(ll_inode2fid(dir)),
-	       dir, 3000, tgt);
+	       dir, 3000, oldpath);
 
-        err = ll_new_node(dir, name, (char *)tgt, S_IFLNK | S_IRWXUGO,
-                          0, dchild, LUSTRE_OPC_SYMLINK);
+	err = ll_new_node(dir, dchild, oldpath, S_IFLNK | S_IRWXUGO, 0,
+			  LUSTRE_OPC_SYMLINK);
 
         if (!err)
                 ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_SYMLINK, 1);
@@ -1051,17 +1114,19 @@ static int ll_symlink_generic(struct inode *dir, struct qstr *name,
         RETURN(err);
 }
 
-static int ll_link_generic(struct inode *src,  struct inode *dir,
-                           struct qstr *name, struct dentry *dchild)
+static int ll_link(struct dentry *old_dentry, struct inode *dir,
+		   struct dentry *new_dentry)
 {
-        struct ll_sb_info *sbi = ll_i2sbi(dir);
-        struct ptlrpc_request *request = NULL;
-        struct md_op_data *op_data;
-        int err;
+	struct inode *src = old_dentry->d_inode;
+	struct qstr *name = &new_dentry->d_name;
+	struct ll_sb_info *sbi = ll_i2sbi(dir);
+	struct ptlrpc_request *request = NULL;
+	struct md_op_data *op_data;
+	int err;
 
-        ENTRY;
-	CDEBUG(D_VFSTRACE, "VFS Op: inode="DFID"(%p), dir="DFID
-	       "(%p), target=%.*s\n", PFID(ll_inode2fid(src)), src,
+	ENTRY;
+	CDEBUG(D_VFSTRACE, "VFS Op: inode="DFID"(%p), dir="DFID"(%p), "
+	       "target=%.*s\n", PFID(ll_inode2fid(src)), src,
 	       PFID(ll_inode2fid(dir)), dir, name->len, name->name);
 
         op_data = ll_prep_md_op_data(NULL, src, dir, name->name, name->len,
@@ -1082,10 +1147,9 @@ out:
         RETURN(err);
 }
 
-static int ll_mkdir_generic(struct inode *dir, struct qstr *name,
-                            int mode, struct dentry *dchild)
-
+static int ll_mkdir(struct inode *dir, struct dentry *dchild, ll_umode_t mode)
 {
+	struct qstr *name = &dchild->d_name;
         int err;
         ENTRY;
 
@@ -1094,18 +1158,19 @@ static int ll_mkdir_generic(struct inode *dir, struct qstr *name,
 
 	if (!IS_POSIXACL(dir) || !exp_connect_umask(ll_i2mdexp(dir)))
 		mode &= ~current_umask();
+
 	mode = (mode & (S_IRWXUGO|S_ISVTX)) | S_IFDIR;
-	err = ll_new_node(dir, name, NULL, mode, 0, dchild, LUSTRE_OPC_MKDIR);
 
-        if (!err)
-                ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_MKDIR, 1);
+	err = ll_new_node(dir, dchild, NULL, mode, 0, LUSTRE_OPC_MKDIR);
+	if (err == 0)
+		ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_MKDIR, 1);
 
-        RETURN(err);
+	RETURN(err);
 }
 
-static int ll_rmdir_generic(struct inode *dir, struct dentry *dparent,
-                            struct dentry *dchild, struct qstr *name)
+static int ll_rmdir(struct inode *dir, struct dentry *dchild)
 {
+	struct qstr *name = &dchild->d_name;
         struct ptlrpc_request *request = NULL;
         struct md_op_data *op_data;
         int rc;
@@ -1114,7 +1179,7 @@ static int ll_rmdir_generic(struct inode *dir, struct dentry *dparent,
 	CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p)\n",
 	       name->len, name->name, PFID(ll_inode2fid(dir)), dir);
 
-        if (unlikely(ll_d_mountpoint(dparent, dchild, name)))
+	if (unlikely(d_mountpoint(dchild)))
                 RETURN(-EBUSY);
 
         op_data = ll_prep_md_op_data(NULL, dir, NULL, name->name, name->len,
@@ -1122,8 +1187,9 @@ static int ll_rmdir_generic(struct inode *dir, struct dentry *dparent,
         if (IS_ERR(op_data))
                 RETURN(PTR_ERR(op_data));
 
-	if (dchild != NULL && dchild->d_inode != NULL)
+	if (dchild->d_inode != NULL)
 		op_data->op_fid3 = *ll_inode2fid(dchild->d_inode);
+
 	op_data->op_fid2 = op_data->op_fid3;
         rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request);
         ll_finish_md_op_data(op_data);
@@ -1165,89 +1231,13 @@ int ll_rmdir_entry(struct inode *dir, char *name, int namelen)
 	RETURN(rc);
 }
 
-int ll_objects_destroy(struct ptlrpc_request *request, struct inode *dir)
-{
-        struct mdt_body *body;
-        struct lov_mds_md *eadata;
-        struct lov_stripe_md *lsm = NULL;
-        struct obd_trans_info oti = { 0 };
-        struct obdo *oa;
-        struct obd_capa *oc = NULL;
-        int rc;
-        ENTRY;
-
-        /* req is swabbed so this is safe */
-        body = req_capsule_server_get(&request->rq_pill, &RMF_MDT_BODY);
-        if (!(body->valid & OBD_MD_FLEASIZE))
-                RETURN(0);
-
-        if (body->eadatasize == 0) {
-                CERROR("OBD_MD_FLEASIZE set but eadatasize zero\n");
-                GOTO(out, rc = -EPROTO);
-        }
-
-        /* The MDS sent back the EA because we unlinked the last reference
-         * to this file. Use this EA to unlink the objects on the OST.
-         * It's opaque so we don't swab here; we leave it to obd_unpackmd() to
-         * check it is complete and sensible. */
-        eadata = req_capsule_server_sized_get(&request->rq_pill, &RMF_MDT_MD,
-                                              body->eadatasize);
-        LASSERT(eadata != NULL);
-
-        rc = obd_unpackmd(ll_i2dtexp(dir), &lsm, eadata, body->eadatasize);
-        if (rc < 0) {
-                CERROR("obd_unpackmd: %d\n", rc);
-                GOTO(out, rc);
-        }
-        LASSERT(rc >= sizeof(*lsm));
-
-        OBDO_ALLOC(oa);
-        if (oa == NULL)
-                GOTO(out_free_memmd, rc = -ENOMEM);
-
-	oa->o_oi = lsm->lsm_oi;
-        oa->o_mode = body->mode & S_IFMT;
-        oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLGROUP;
-
-        if (body->valid & OBD_MD_FLCOOKIE) {
-                oa->o_valid |= OBD_MD_FLCOOKIE;
-                oti.oti_logcookies =
-                        req_capsule_server_sized_get(&request->rq_pill,
-                                                     &RMF_LOGCOOKIES,
-                                                   sizeof(struct llog_cookie) *
-                                                     lsm->lsm_stripe_count);
-                if (oti.oti_logcookies == NULL) {
-                        oa->o_valid &= ~OBD_MD_FLCOOKIE;
-                        body->valid &= ~OBD_MD_FLCOOKIE;
-                }
-        }
-
-        if (body->valid & OBD_MD_FLOSSCAPA) {
-                rc = md_unpack_capa(ll_i2mdexp(dir), request, &RMF_CAPA2, &oc);
-                if (rc)
-                        GOTO(out_free_memmd, rc);
-        }
-
-	rc = obd_destroy(NULL, ll_i2dtexp(dir), oa, lsm, &oti,
-			 ll_i2mdexp(dir), oc);
-	capa_put(oc);
-	if (rc)
-		CERROR("obd destroy objid "DOSTID" error %d\n",
-		       POSTID(&lsm->lsm_oi), rc);
-out_free_memmd:
-	obd_free_memmd(ll_i2dtexp(dir), &lsm);
-	OBDO_FREE(oa);
-out:
-	return rc;
-}
-
-/* ll_unlink_generic() doesn't update the inode with the new link count.
- * Instead, ll_ddelete() and ll_d_iput() will update it based upon if there
- * is any lock existing. They will recycle dentries and inodes based upon locks
- * too. b=20433 */
-static int ll_unlink_generic(struct inode *dir, struct dentry *dparent,
-                             struct dentry *dchild, struct qstr *name)
+/* ll_unlink() doesn't update the inode with the new link count.
+ * Instead, ll_ddelete() and ll_d_iput() will update it based upon if
+ * there is any lock existing. They will recycle dentries and inodes
+ * based upon locks too. b=20433 */
+static int ll_unlink(struct inode *dir, struct dentry *dchild)
 {
+	struct qstr *name = &dchild->d_name;
         struct ptlrpc_request *request = NULL;
         struct md_op_data *op_data;
         int rc;
@@ -1259,15 +1249,15 @@ static int ll_unlink_generic(struct inode *dir, struct dentry *dparent,
          * XXX: unlink bind mountpoint maybe call to here,
          * just check it as vfs_unlink does.
          */
-        if (unlikely(ll_d_mountpoint(dparent, dchild, name)))
-                RETURN(-EBUSY);
+	if (unlikely(d_mountpoint(dchild)))
+		RETURN(-EBUSY);
 
-        op_data = ll_prep_md_op_data(NULL, dir, NULL, name->name,
-                                     name->len, 0, LUSTRE_OPC_ANY, NULL);
-        if (IS_ERR(op_data))
-                RETURN(PTR_ERR(op_data));
+	op_data = ll_prep_md_op_data(NULL, dir, NULL, name->name, name->len, 0,
+				     LUSTRE_OPC_ANY, NULL);
+	if (IS_ERR(op_data))
+		RETURN(PTR_ERR(op_data));
 
-	if (dchild != NULL && dchild->d_inode != NULL)
+	if (dchild->d_inode != NULL)
 		op_data->op_fid3 = *ll_inode2fid(dchild->d_inode);
 
 	op_data->op_fid2 = op_data->op_fid3;
@@ -1279,17 +1269,16 @@ static int ll_unlink_generic(struct inode *dir, struct dentry *dparent,
         ll_update_times(request, dir);
         ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_UNLINK, 1);
 
-        rc = ll_objects_destroy(request, dir);
  out:
         ptlrpc_req_finished(request);
         RETURN(rc);
 }
 
-static int ll_rename_generic(struct inode *src, struct dentry *src_dparent,
-                             struct dentry *src_dchild, struct qstr *src_name,
-                             struct inode *tgt, struct dentry *tgt_dparent,
-                             struct dentry *tgt_dchild, struct qstr *tgt_name)
+static int ll_rename(struct inode *src, struct dentry *src_dchild,
+		     struct inode *tgt, struct dentry *tgt_dchild)
 {
+	struct qstr *src_name = &src_dchild->d_name;
+	struct qstr *tgt_name = &tgt_dchild->d_name;
         struct ptlrpc_request *request = NULL;
         struct ll_sb_info *sbi = ll_i2sbi(src);
         struct md_op_data *op_data;
@@ -1301,18 +1290,18 @@ static int ll_rename_generic(struct inode *src, struct dentry *src_dparent,
 	       PFID(ll_inode2fid(src)), src, tgt_name->len,
 	       tgt_name->name, PFID(ll_inode2fid(tgt)), tgt);
 
-        if (unlikely(ll_d_mountpoint(src_dparent, src_dchild, src_name) ||
-            ll_d_mountpoint(tgt_dparent, tgt_dchild, tgt_name)))
-                RETURN(-EBUSY);
+	if (unlikely(d_mountpoint(src_dchild) || d_mountpoint(tgt_dchild)))
+		RETURN(-EBUSY);
 
-        op_data = ll_prep_md_op_data(NULL, src, tgt, NULL, 0, 0,
-                                     LUSTRE_OPC_ANY, NULL);
-        if (IS_ERR(op_data))
-                RETURN(PTR_ERR(op_data));
+	op_data = ll_prep_md_op_data(NULL, src, tgt, NULL, 0, 0,
+				     LUSTRE_OPC_ANY, NULL);
+	if (IS_ERR(op_data))
+		RETURN(PTR_ERR(op_data));
 
-	if (src_dchild != NULL && src_dchild->d_inode != NULL)
+	if (src_dchild->d_inode != NULL)
 		op_data->op_fid3 = *ll_inode2fid(src_dchild->d_inode);
-	if (tgt_dchild != NULL && tgt_dchild->d_inode != NULL)
+
+	if (tgt_dchild->d_inode != NULL)
 		op_data->op_fid4 = *ll_inode2fid(tgt_dchild->d_inode);
 
         err = md_rename(sbi->ll_md_exp, op_data,
@@ -1323,60 +1312,14 @@ static int ll_rename_generic(struct inode *src, struct dentry *src_dparent,
                 ll_update_times(request, src);
                 ll_update_times(request, tgt);
                 ll_stats_ops_tally(sbi, LPROC_LL_RENAME, 1);
-                err = ll_objects_destroy(request, src);
         }
 
         ptlrpc_req_finished(request);
 
-        RETURN(err);
-}
-
-static int ll_mknod(struct inode *dir, struct dentry *dchild, ll_umode_t mode,
-		    dev_t rdev)
-{
-	return ll_mknod_generic(dir, &dchild->d_name, mode,
-				old_encode_dev(rdev), dchild);
-}
-
-static int ll_unlink(struct inode * dir, struct dentry *dentry)
-{
-        return ll_unlink_generic(dir, NULL, dentry, &dentry->d_name);
-}
-
-static int ll_mkdir(struct inode *dir, struct dentry *dentry, ll_umode_t mode)
-{
-        return ll_mkdir_generic(dir, &dentry->d_name, mode, dentry);
-}
-
-static int ll_rmdir(struct inode *dir, struct dentry *dentry)
-{
-        return ll_rmdir_generic(dir, NULL, dentry, &dentry->d_name);
-}
-
-static int ll_symlink(struct inode *dir, struct dentry *dentry,
-                      const char *oldname)
-{
-        return ll_symlink_generic(dir, &dentry->d_name, oldname, dentry);
-}
+	if (err == 0)
+		d_move(src_dchild, tgt_dchild);
 
-static int ll_link(struct dentry *old_dentry, struct inode *dir,
-                   struct dentry *new_dentry)
-{
-        return ll_link_generic(old_dentry->d_inode, dir, &new_dentry->d_name,
-                               new_dentry);
-}
-
-static int ll_rename(struct inode *old_dir, struct dentry *old_dentry,
-                     struct inode *new_dir, struct dentry *new_dentry)
-{
-        int err;
-        err = ll_rename_generic(old_dir, NULL,
-                                 old_dentry, &old_dentry->d_name,
-                                 new_dir, NULL, new_dentry,
-                                 &new_dentry->d_name);
-	if (!err)
-                        d_move(old_dentry, new_dentry);
-        return err;
+	RETURN(err);
 }
 
 const struct inode_operations ll_dir_inode_operations = {