b=20748

[fs/lustre-release.git] / lustre / ptlrpc / sec_null.c

diff --git a/lustre/ptlrpc/sec_null.c b/lustre/ptlrpc/sec_null.c
index 813adf0..041217e 100644 (file)
--- a/lustre/ptlrpc/sec_null.c
+++ b/lustre/ptlrpc/sec_null.c
@@ -59,26 +59,19 @@ static struct ptlrpc_cli_ctx    null_cli_ctx;
 static struct ptlrpc_svc_ctx    null_svc_ctx;
 
 /*
- * null sec temporarily use the third byte of lm_secflvr to identify
+ * we can temporarily use the topmost 8-bits of lm_secflvr to identify
  * the source sec part.
  */
 static inline
 void null_encode_sec_part(struct lustre_msg *msg, enum lustre_sec_part sp)
 {
-        msg->lm_secflvr |= (((__u32) sp) & 0xFF) << 16;
+        msg->lm_secflvr |= (((__u32) sp) & 0xFF) << 24;
 }
 
 static inline
 enum lustre_sec_part null_decode_sec_part(struct lustre_msg *msg)
 {
-        switch (msg->lm_magic) {
-        case LUSTRE_MSG_MAGIC_V2:
-                return (msg->lm_secflvr >> 16) & 0xFF;
-        case LUSTRE_MSG_MAGIC_V2_SWABBED:
-                return (msg->lm_secflvr >> 8) & 0xFF;
-        default:
-                return LUSTRE_SP_ANY;
-        }
+        return (msg->lm_secflvr >> 24) & 0xFF;
 }
 
 static int null_ctx_refresh(struct ptlrpc_cli_ctx *ctx)
@@ -96,7 +89,7 @@ int null_ctx_sign(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req)
         if (!req->rq_import->imp_dlm_fake) {
                 struct obd_device *obd = req->rq_import->imp_obd;
                 null_encode_sec_part(req->rq_reqbuf,
-                                     obd->u.cli.cl_sec_part);
+                                     obd->u.cli.cl_sp_me);
         }
         req->rq_reqdata_len = req->rq_reqlen;
         return 0;
@@ -109,18 +102,12 @@ int null_ctx_verify(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req)
 
         LASSERT(req->rq_repdata);
 
-        /* real reply rq_repdata point inside of rq_reqbuf; early reply
-         * rq_repdata point to a separate allocated space */
-        if ((char *) req->rq_repdata < req->rq_repbuf ||
-            (char *) req->rq_repdata >= req->rq_repbuf + req->rq_repbuf_len) {
-                cksums = req->rq_repdata->lm_cksum;
-                req->rq_repdata->lm_cksum = 0;
-
-                if (req->rq_repdata->lm_magic == LUSTRE_MSG_MAGIC_V2_SWABBED)
-                        __swab32s(&cksums);
+        req->rq_repmsg = req->rq_repdata;
+        req->rq_replen = req->rq_repdata_len;
 
-                cksumc = crc32_le(!(__u32) 0, (unsigned char *)req->rq_repdata,
-                                  req->rq_repdata_len);
+        if (req->rq_early) {
+                cksums = lustre_msg_get_cksum(req->rq_repdata);
+                cksumc = lustre_msg_calc_cksum(req->rq_repmsg);
                 if (cksumc != cksums) {
                         CWARN("early reply checksum mismatch: %08x != %08x\n",
                               cksumc, cksums);
@@ -128,8 +115,6 @@ int null_ctx_verify(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req)
                 }
         }
 
-        req->rq_repmsg = req->rq_repdata;
-        req->rq_replen = req->rq_repdata_len;
         return 0;
 }
 
@@ -138,14 +123,7 @@ struct ptlrpc_sec *null_create_sec(struct obd_import *imp,
                                    struct ptlrpc_svc_ctx *svc_ctx,
                                    struct sptlrpc_flavor *sf)
 {
-        LASSERT(RPC_FLVR_POLICY(sf->sf_rpc) == SPTLRPC_POLICY_NULL);
-
-        if (sf->sf_bulk_ciph != BULK_CIPH_ALG_NULL ||
-            sf->sf_bulk_hash != BULK_HASH_ALG_NULL) {
-                CERROR("null sec don't support bulk algorithm: %u/%u\n",
-                       sf->sf_bulk_ciph, sf->sf_bulk_hash);
-                return NULL;
-        }
+        LASSERT(SPTLRPC_FLVR_POLICY(sf->sf_rpc) == SPTLRPC_POLICY_NULL);
 
         /* general layer has take a module reference for us, because we never
          * really destroy the sec, simply release the reference here.
@@ -303,7 +281,8 @@ static struct ptlrpc_svc_ctx null_svc_ctx = {
 static
 int null_accept(struct ptlrpc_request *req)
 {
-        LASSERT(RPC_FLVR_POLICY(req->rq_flvr.sf_rpc) == SPTLRPC_POLICY_NULL);
+        LASSERT(SPTLRPC_FLVR_POLICY(req->rq_flvr.sf_rpc) ==
+                SPTLRPC_POLICY_NULL);
 
         if (req->rq_flvr.sf_rpc != SPTLRPC_FLVR_NULL) {
                 CERROR("Invalid rpc flavor 0x%x\n", req->rq_flvr.sf_rpc);
@@ -374,12 +353,13 @@ int null_authorize(struct ptlrpc_request *req)
         rs->rs_repdata_len = req->rq_replen;
 
         if (likely(req->rq_packed_final)) {
-                req->rq_reply_off = lustre_msg_early_size();
+                if (lustre_msghdr_get_flags(req->rq_reqmsg) & MSGHDR_AT_SUPPORT)
+                        req->rq_reply_off = lustre_msg_early_size();
+                else
+                        req->rq_reply_off = 0;
         } else {
-                rs->rs_repbuf->lm_cksum =
-                                crc32_le(!(__u32) 0,
-                                         (unsigned char *)rs->rs_repbuf,
-                                         rs->rs_repdata_len);
+                lustre_msg_set_cksum(rs->rs_repbuf,
+                                     lustre_msg_calc_cksum(rs->rs_repbuf));
                 req->rq_reply_off = 0;
         }
 
@@ -428,8 +408,6 @@ static void null_init_internal(void)
         null_sec.ps_id = -1;
         null_sec.ps_import = NULL;
         null_sec.ps_flvr.sf_rpc = SPTLRPC_FLVR_NULL;
-        null_sec.ps_flvr.sf_bulk_ciph = BULK_CIPH_ALG_NULL;
-        null_sec.ps_flvr.sf_bulk_hash = BULK_HASH_ALG_NULL;
         null_sec.ps_flvr.sf_flags = 0;
         null_sec.ps_part = LUSTRE_SP_ANY;
         null_sec.ps_dying = 0;