X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fmdt%2Fmdt_handler.c;h=3040be6eb57463bfb441fb82a17a4eb2ee4f0539;hb=a3b3d91b740466feea54d0fe9a397ba79c001aa7;hp=a54cef4b9cda64df42893ce6ef6d3c8b8dcbf558;hpb=0a6beb2a50f7a4f953a258b63c2ea1fbfd373092;p=fs%2Flustre-release.git

diff --git a/lustre/mdt/mdt_handler.c b/lustre/mdt/mdt_handler.c
index a54cef4..3040be6 100644
--- a/lustre/mdt/mdt_handler.c
+++ b/lustre/mdt/mdt_handler.c
@@ -63,6 +63,7 @@
 #include <lustre_barrier.h>
 #include <obd_cksum.h>
 #include <llog_swab.h>
+#include <lustre_crypto.h>
 
 #include "mdt_internal.h"
 
@@ -830,7 +831,7 @@ void mdt_pack_attr2body(struct mdt_thread_info *info, struct mdt_body *b,
 		b->mbo_nlink = attr->la_nlink;
 		b->mbo_valid |= OBD_MD_FLNLINK;
 	}
-	if (attr->la_valid & (LA_UID|LA_GID)) {
+	if (attr->la_valid & (LA_UID|LA_GID|LA_PROJID)) {
 		nodemap = nodemap_get_from_exp(exp);
 		if (IS_ERR(nodemap))
 			goto out;
@@ -849,8 +850,9 @@ void mdt_pack_attr2body(struct mdt_thread_info *info, struct mdt_body *b,
 	}
 
 	if (attr->la_valid & LA_PROJID) {
-		/* TODO, nodemap for project id */
-		b->mbo_projid = attr->la_projid;
+		b->mbo_projid = nodemap_map_id(nodemap, NODEMAP_PROJID,
+					       NODEMAP_FS_TO_CLIENT,
+					       attr->la_projid);
 		b->mbo_valid |= OBD_MD_FLPROJID;
 	}
 
@@ -1902,6 +1904,97 @@ lookup:
 	RETURN(rc);
 }
 
+/**
+ * Find name matching hash
+ *
+ * We search \a child LinkEA for a name whose hash matches \a lname
+ * (it contains an encoded hash).
+ *
+ * \param info mdt thread info
+ * \param lname encoded hash to find
+ * \param parent parent object
+ * \param child object to search with LinkEA
+ * \param force_check true to check hash even if LinkEA has only one entry
+ *
+ * \retval 1 match found
+ * \retval 0 no match found
+ * \retval -ev negative errno upon error
+ */
+int find_name_matching_hash(struct mdt_thread_info *info, struct lu_name *lname,
+			    struct mdt_object *parent, struct mdt_object *child,
+			    bool force_check)
+{
+	/* Here, lname is an encoded hash of on-disk name, and
+	 * client is doing access without encryption key.
+	 * So we need to get LinkEA, check parent fid is correct and
+	 * compare name hash with the one in the request.
+	 */
+	struct lu_buf *buf = &info->mti_big_buf;
+	struct lu_name name;
+	struct lu_fid pfid;
+	struct linkea_data ldata = { NULL };
+	struct link_ea_header *leh;
+	struct link_ea_entry *lee;
+	struct lu_buf link = { 0 };
+	char *hash = NULL;
+	int reclen, count, rc;
+
+	ENTRY;
+
+	if (lname->ln_namelen < LLCRYPT_FNAME_DIGEST_SIZE)
+		RETURN(-EINVAL);
+
+	buf = lu_buf_check_and_alloc(buf, PATH_MAX);
+	if (!buf->lb_buf)
+		RETURN(-ENOMEM);
+
+	ldata.ld_buf = buf;
+	rc = mdt_links_read(info, child, &ldata);
+	if (rc < 0)
+		RETURN(rc);
+
+	leh = buf->lb_buf;
+	if (force_check || leh->leh_reccount > 1) {
+		hash = kmalloc(lname->ln_namelen, GFP_NOFS);
+		if (!hash)
+			RETURN(-ENOMEM);
+		rc = critical_decode(lname->ln_name, lname->ln_namelen, hash);
+	}
+	lee = (struct link_ea_entry *)(leh + 1);
+	for (count = 0; count < leh->leh_reccount; count++) {
+		linkea_entry_unpack(lee, &reclen, &name, &pfid);
+		if (!force_check && leh->leh_reccount == 1) {
+			/* if there is only one rec, it has to be it */
+			*lname = name;
+			break;
+		}
+		if (!parent || lu_fid_eq(&pfid, mdt_object_fid(parent))) {
+			lu_buf_check_and_alloc(&link, name.ln_namelen);
+			if (!link.lb_buf)
+				GOTO(out_match, rc = -ENOMEM);
+			rc = critical_decode(name.ln_name, name.ln_namelen,
+					     link.lb_buf);
+
+			if (memcmp(LLCRYPT_FNAME_DIGEST(link.lb_buf, rc),
+				   hash, LLCRYPT_FNAME_DIGEST_SIZE) == 0) {
+				*lname = name;
+				break;
+			}
+		}
+		lee = (struct link_ea_entry *) ((char *)lee + reclen);
+	}
+	if (count == leh->leh_reccount)
+		rc = 0;
+	else
+		rc = 1;
+
+out_match:
+	lu_buf_free(&link);
+	kfree(hash);
+
+	RETURN(rc);
+}
+
 /*
  * UPDATE lock should be taken against parent, and be released before exit;
  * child_bits lock should be taken against child, and be returned back:
@@ -1998,7 +2091,30 @@ static int mdt_getattr_name_lock(struct mdt_thread_info *info,
 	lname = &info->mti_name;
 	mdt_name_unpack(pill, &RMF_NAME, lname, MNF_FIX_ANON);
 
-	if (lu_name_is_valid(lname)) {
+	if (info->mti_body->mbo_valid & OBD_MD_NAMEHASH) {
+		reqbody = req_capsule_client_get(pill, &RMF_MDT_BODY);
+		if (unlikely(reqbody == NULL))
+			RETURN(err_serious(-EPROTO));
+
+		*child_fid = reqbody->mbo_fid2;
+		if (unlikely(!fid_is_sane(child_fid)))
+			RETURN(err_serious(-EINVAL));
+
+		if (lu_fid_eq(mdt_object_fid(parent), child_fid)) {
+			mdt_object_get(info->mti_env, parent);
+			child = parent;
+		} else {
+			child = mdt_object_find(info->mti_env, info->mti_mdt,
+						child_fid);
+			if (IS_ERR(child))
+				RETURN(PTR_ERR(child));
+		}
+
+		CDEBUG(D_INODE, "getattr with lock for "DFID"/"DFID", "
+		       "ldlm_rep = %p\n",
+		       PFID(mdt_object_fid(parent)),
+		       PFID(&reqbody->mbo_fid2), ldlm_rep);
+	} else if (lu_name_is_valid(lname)) {
 		if (mdt_object_remote(parent)) {
 			CERROR("%s: parent "DFID" is on remote target\n",
 			       mdt_obd_name(info->mti_mdt),
@@ -2050,14 +2166,35 @@ static int mdt_getattr_name_lock(struct mdt_thread_info *info,
 
 	mdt_set_disposition(info, ldlm_rep, DISP_LOOKUP_EXECD);
 
-	if (unlikely(!mdt_object_exists(parent)) && lu_name_is_valid(lname)) {
+	if (unlikely(!mdt_object_exists(parent)) &&
+	    !(info->mti_body->mbo_valid & OBD_MD_NAMEHASH) &&
+	    lu_name_is_valid(lname)) {
 		LU_OBJECT_DEBUG(D_INODE, info->mti_env,
 				&parent->mot_obj,
 				"Parent doesn't exist!");
 		GOTO(out_child, rc = -ESTALE);
 	}
 
-	if (lu_name_is_valid(lname)) {
+	if (!child && is_resent) {
+		lock = ldlm_handle2lock(&lhc->mlh_reg_lh);
+		if (lock == NULL) {
+			/* Lock is pinned by ldlm_handle_enqueue0() as it is
+			 * a resend case, however, it could be already destroyed
+			 * due to client eviction or a raced cancel RPC.
+			 */
+			LDLM_DEBUG_NOLOCK("Invalid lock handle %#llx",
+					  lhc->mlh_reg_lh.cookie);
+			RETURN(-ESTALE);
+		}
+		fid_extract_from_res_name(child_fid,
+					  &lock->l_resource->lr_name);
+		LDLM_LOCK_PUT(lock);
+		child = mdt_object_find(info->mti_env, info->mti_mdt,
+					child_fid);
+		if (IS_ERR(child))
+			RETURN(PTR_ERR(child));
+	} else if (!(info->mti_body->mbo_valid & OBD_MD_NAMEHASH) &&
+	    lu_name_is_valid(lname)) {
 		if (info->mti_body->mbo_valid == OBD_MD_FLID) {
 			rc = mdt_raw_lookup(info, parent, lname);
 
@@ -2095,6 +2232,19 @@ static int mdt_getattr_name_lock(struct mdt_thread_info *info,
 	/* step 3: lock child regardless if it is local or remote. */
 	LASSERT(child);
 
+	if (info->mti_body->mbo_valid & OBD_MD_NAMEHASH) {
+		/* Here, lname is an encoded hash of on-disk name, and
+		 * client is doing access without encryption key.
+		 * So we need to compare name hash with the one in the request.
+		 */
+		if (!find_name_matching_hash(info, lname, parent,
+					     child, true)) {
+			mdt_set_disposition(info, ldlm_rep, DISP_LOOKUP_NEG);
+			mdt_clear_disposition(info, ldlm_rep, DISP_LOOKUP_POS);
+			GOTO(out_child, rc = -ENOENT);
+		}
+	}
+
 	OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_RESEND, obd_timeout * 2);
 	if (!mdt_object_exists(child)) {
 		LU_OBJECT_DEBUG(D_INODE, info->mti_env,
@@ -2168,19 +2318,22 @@ static int mdt_getattr_name_lock(struct mdt_thread_info *info,
 	/* finally, we can get attr for child. */
 	rc = mdt_getattr_internal(info, child, ma_need);
 	if (unlikely(rc != 0)) {
-		mdt_object_unlock(info, child, lhc, 1);
+		if (!is_resent)
+			mdt_object_unlock(info, child, lhc, 1);
 		GOTO(out_child, rc);
 	}
 
 	rc = mdt_pack_secctx_in_reply(info, child);
 	if (unlikely(rc)) {
-		mdt_object_unlock(info, child, lhc, 1);
+		if (!is_resent)
+			mdt_object_unlock(info, child, lhc, 1);
 		GOTO(out_child, rc);
 	}
 
 	rc = mdt_pack_encctx_in_reply(info, child);
 	if (unlikely(rc)) {
-		mdt_object_unlock(info, child, lhc, 1);
+		if (!is_resent)
+			mdt_object_unlock(info, child, lhc, 1);
 		GOTO(out_child, rc);
 	}
 
@@ -2489,6 +2642,61 @@ out:
 static int mdt_iocontrol(unsigned int cmd, struct obd_export *exp, int len,
 			 void *karg, void __user *uarg);
 
+int mdt_io_set_info(struct tgt_session_info *tsi)
+{
+	struct ptlrpc_request	*req = tgt_ses_req(tsi);
+	struct ost_body		*body = NULL, *repbody;
+	void			*key, *val = NULL;
+	int			 keylen, vallen, rc = 0;
+	bool			 is_grant_shrink;
+
+	ENTRY;
+
+	key = req_capsule_client_get(tsi->tsi_pill, &RMF_SETINFO_KEY);
+	if (key == NULL) {
+		DEBUG_REQ(D_HA, req, "no set_info key");
+		RETURN(err_serious(-EFAULT));
+	}
+	keylen = req_capsule_get_size(tsi->tsi_pill, &RMF_SETINFO_KEY,
+				      RCL_CLIENT);
+
+	val = req_capsule_client_get(tsi->tsi_pill, &RMF_SETINFO_VAL);
+	if (val == NULL) {
+		DEBUG_REQ(D_HA, req, "no set_info val");
+		RETURN(err_serious(-EFAULT));
+	}
+	vallen = req_capsule_get_size(tsi->tsi_pill, &RMF_SETINFO_VAL,
+				      RCL_CLIENT);
+
+	is_grant_shrink = KEY_IS(KEY_GRANT_SHRINK);
+	if (is_grant_shrink)
+		/* In this case the value is actually an RMF_OST_BODY, so we
+		 * transmutate the type of this PTLRPC */
+		req_capsule_extend(tsi->tsi_pill, &RQF_OST_SET_GRANT_INFO);
+
+	rc = req_capsule_server_pack(tsi->tsi_pill);
+	if (rc < 0)
+		RETURN(rc);
+
+	if (is_grant_shrink) {
+		body = req_capsule_client_get(tsi->tsi_pill, &RMF_OST_BODY);
+
+		repbody = req_capsule_server_get(tsi->tsi_pill, &RMF_OST_BODY);
+		*repbody = *body;
+
+		/** handle grant shrink, similar to a read request */
+		tgt_grant_prepare_read(tsi->tsi_env, tsi->tsi_exp,
+				       &repbody->oa);
+	} else {
+		CERROR("%s: Unsupported key %s\n",
+		       tgt_name(tsi->tsi_tgt), (char *)key);
+		rc = -EOPNOTSUPP;
+	}
+
+	RETURN(rc);
+}
+
+
 static int mdt_set_info(struct tgt_session_info *tsi)
 {
 	struct ptlrpc_request	*req = tgt_ses_req(tsi);
@@ -3012,7 +3220,8 @@ static int mdt_quotactl(struct tgt_session_info *tsi)
 	case LUSTRE_Q_SETQUOTAPOOL:
 	case LUSTRE_Q_SETINFOPOOL:
 	case LUSTRE_Q_SETDEFAULT_POOL:
-		if (!nodemap_can_setquota(nodemap))
+		if (!nodemap_can_setquota(nodemap, oqctl->qc_type,
+					  oqctl->qc_id))
 			GOTO(out_nodemap, rc = -EPERM);
 		/* fallthrough */
 	case Q_GETINFO:
@@ -3046,8 +3255,8 @@ static int mdt_quotactl(struct tgt_session_info *tsi)
 				    NODEMAP_CLIENT_TO_FS, id);
 		break;
 	case PRJQUOTA:
-		/* todo: check/map project id */
-		id = oqctl->qc_id;
+		id = nodemap_map_id(nodemap, NODEMAP_PROJID,
+				    NODEMAP_CLIENT_TO_FS, id);
 		break;
 	default:
 		GOTO(out_nodemap, rc = -EOPNOTSUPP);
@@ -4123,25 +4332,29 @@ int mdt_intent_lock_replace(struct mdt_thread_info *info,
 	/* If possible resent found a lock, @lh is set to its handle */
 	new_lock = ldlm_handle2lock_long(&lh->mlh_reg_lh, 0);
 
-        if (new_lock == NULL && (flags & LDLM_FL_INTENT_ONLY)) {
-                lh->mlh_reg_lh.cookie = 0;
-                RETURN(0);
-        }
-
-	if (new_lock == NULL && (flags & LDLM_FL_RESENT)) {
-		/* Lock is pinned by ldlm_handle_enqueue0() as it is
-		 * a resend case, however, it could be already destroyed
-		 * due to client eviction or a raced cancel RPC. */
-		LDLM_DEBUG_NOLOCK("Invalid lock handle %#llx\n",
-				  lh->mlh_reg_lh.cookie);
+	if (new_lock == NULL) {
+		if (flags & LDLM_FL_INTENT_ONLY) {
+			result = 0;
+		} else if (flags & LDLM_FL_RESENT) {
+			/* Lock is pinned by ldlm_handle_enqueue0() as it is a
+			 * resend case, however, it could be already destroyed
+			 * due to client eviction or a raced cancel RPC.
+			 */
+			LDLM_DEBUG_NOLOCK("Invalid lock handle %#llx\n",
+					  lh->mlh_reg_lh.cookie);
+			result = -ESTALE;
+		} else {
+			CERROR("%s: Invalid lockh=%#llx flags=%#llx fid1="DFID" fid2="DFID": rc = %d\n",
+			       mdt_obd_name(info->mti_mdt),
+			       lh->mlh_reg_lh.cookie, flags,
+			       PFID(&info->mti_tmp_fid1),
+			       PFID(&info->mti_tmp_fid2), result);
+			result = -ESTALE;
+		}
 		lh->mlh_reg_lh.cookie = 0;
-		RETURN(-ESTALE);
+		RETURN(result);
 	}
 
-	LASSERTF(new_lock != NULL,
-		 "lockh %#llx flags %#llx : rc = %d\n",
-		 lh->mlh_reg_lh.cookie, flags, result);
-
         /*
          * If we've already given this lock to a client once, then we should
          * have no readers or writers.  Otherwise, we should have one reader
@@ -5528,6 +5741,9 @@ TGT_OST_HDL(HAS_BODY | HAS_REPLY, OST_SYNC,	mdt_data_sync),
 TGT_OST_HDL(HAS_BODY | HAS_REPLY | IS_MUTABLE, OST_FALLOCATE,
 							mdt_fallocate_hdl),
 TGT_OST_HDL(HAS_BODY | HAS_REPLY, OST_SEEK, tgt_lseek),
+TGT_RPC_HANDLER(OST_FIRST_OPC,
+		0,			OST_SET_INFO,	mdt_io_set_info,
+		&RQF_OBD_SET_INFO, LUSTRE_OST_VERSION),
 };
 
 static struct tgt_handler mdt_sec_ctx_ops[] = {
@@ -6518,7 +6734,8 @@ static int mdt_export_cleanup(struct obd_export *exp)
 				rc = mdt_ctxt_add_dirty_flag(&env, info, mfd);
 
 			/* Don't unlink orphan on failover umount, LU-184 */
-			if (exp->exp_flags & OBD_OPT_FAILOVER) {
+			if (exp->exp_flags & OBD_OPT_FAILOVER ||
+			    exp->exp_obd->obd_stopping) {
 				ma->ma_valid = MA_FLAGS;
 				ma->ma_attr_flags |= MDS_KEEP_ORPHAN;
 			}
@@ -7001,12 +7218,24 @@ static int mdt_fid2path(struct mdt_thread_info *info,
 		RETURN(rc);
 	}
 
-	if (mdt_object_remote(obj))
+	if (mdt_object_remote(obj)) {
 		rc = -EREMOTE;
-	else if (!mdt_object_exists(obj))
+	} else if (!mdt_object_exists(obj)) {
 		rc = -ENOENT;
-	else
-		rc = 0;
+	} else {
+		struct lu_attr la = { 0 };
+		struct dt_object *dt = mdt_obj2dt(obj);
+
+		if (dt && dt->do_ops && dt->do_ops->do_attr_get)
+			dt_attr_get(info->mti_env, mdt_obj2dt(obj), &la);
+		if (la.la_valid & LA_FLAGS && la.la_flags & LUSTRE_ENCRYPT_FL)
+			/* path resolution cannot be carried out on server
+			 * side for encrypted files
+			 */
+			rc = -ENODATA;
+		else
+			rc = 0;
+	}
 
 	if (rc < 0) {
 		mdt_object_put(info->mti_env, obj);
@@ -7183,13 +7412,14 @@ static int mdt_iocontrol(unsigned int cmd, struct obd_export *exp, int len,
 		struct obd_ioctl_data *data = karg;
 
 		CERROR("%s: Aborting recovery for device\n", mdt_obd_name(mdt));
-		if (data->ioc_type & OBD_FLG_ABORT_RECOV_MDT)
+		if (data->ioc_type & OBD_FLG_ABORT_RECOV_MDT) {
 			obd->obd_abort_recov_mdt = 1;
-		else /* if (data->ioc_type & OBD_FLG_ABORT_RECOV_OST) */
+			wake_up(&obd->obd_next_transno_waitq);
+		} else { /* if (data->ioc_type & OBD_FLG_ABORT_RECOV_OST) */
 			/* lctl didn't set OBD_FLG_ABORT_RECOV_OST < 2.13.57 */
 			obd->obd_abort_recovery = 1;
-
-		target_stop_recovery_thread(obd);
+			target_stop_recovery_thread(obd);
+		}
 		rc = 0;
 		break;
 	}