X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;ds=sidebyside;f=lustre%2Fptlrpc%2Fsec_plain.c;h=dea70d160b54efd9ec6aa4d7c6d8c2fd668a7e64;hb=553d93361d2db4ff39bf19ac66dc2d79f6e3e324;hp=56a53a80206e5f985c1f548ff587fa513e1e1287;hpb=65701b4a30efdb695776bcf690a2b3cabc928da1;p=fs%2Flustre-release.git

diff --git a/lustre/ptlrpc/sec_plain.c b/lustre/ptlrpc/sec_plain.c
index 56a53a8..dea70d1 100644
--- a/lustre/ptlrpc/sec_plain.c
+++ b/lustre/ptlrpc/sec_plain.c
@@ -1,6 +1,4 @@
-/* -*- 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.
@@ -17,11 +15,7 @@
  *
  * 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.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -29,7 +23,7 @@
  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  *
- * Copyright (c) 2011, Whamcloud, Inc.
+ * Copyright (c) 2011, 2015, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -40,14 +34,8 @@
  * Author: Eric Mei <ericm@clusterfs.com>
  */
 
-#ifndef EXPORT_SYMTAB
-# define EXPORT_SYMTAB
-#endif
 #define DEBUG_SUBSYSTEM S_SEC
 
-#ifndef __KERNEL__
-#include <liblustre.h>
-#endif
 
 #include <obd_support.h>
 #include <obd_cksum.h>
@@ -55,9 +43,11 @@
 #include <lustre_net.h>
 #include <lustre_sec.h>
 
+#include "ptlrpc_internal.h"
+
 struct plain_sec {
         struct ptlrpc_sec       pls_base;
-        cfs_rwlock_t            pls_lock;
+	rwlock_t            pls_lock;
         struct ptlrpc_cli_ctx  *pls_ctx;
 };
 
@@ -160,37 +150,24 @@ static int plain_verify_bulk_csum(struct ptlrpc_bulk_desc *desc,
         return 0;
 }
 
-#ifdef __KERNEL__
 static void corrupt_bulk_data(struct ptlrpc_bulk_desc *desc)
 {
-        char           *ptr;
-        unsigned int    off, i;
-
-        for (i = 0; i < desc->bd_iov_count; i++) {
-                if (desc->bd_iov[i].kiov_len == 0)
-                        continue;
-
-                ptr = cfs_kmap(desc->bd_iov[i].kiov_page);
-                off = desc->bd_iov[i].kiov_offset & ~CFS_PAGE_MASK;
-                ptr[off] ^= 0x1;
-                cfs_kunmap(desc->bd_iov[i].kiov_page);
-                return;
-        }
-}
-#else
-static void corrupt_bulk_data(struct ptlrpc_bulk_desc *desc)
-{
-        unsigned int    i;
+	char           *ptr;
+	unsigned int    off, i;
 
-        for (i = 0; i < desc->bd_iov_count; i++) {
-                if (desc->bd_iov[i].iov_len == 0)
-                        continue;
+	LASSERT(ptlrpc_is_bulk_desc_kiov(desc->bd_type));
 
-                ((char *)desc->bd_iov[i].iov_base)[i] ^= 0x1;
-                return;
-        }
+	for (i = 0; i < desc->bd_iov_count; i++) {
+		if (BD_GET_KIOV(desc, i).kiov_len == 0)
+			continue;
+
+		ptr = kmap(BD_GET_KIOV(desc, i).kiov_page);
+		off = BD_GET_KIOV(desc, i).kiov_offset & ~PAGE_MASK;
+		ptr[off] ^= 0x1;
+		kunmap(BD_GET_KIOV(desc, i).kiov_page);
+		return;
+	}
 }
-#endif /* __KERNEL__ */
 
 /****************************************
  * cli_ctx apis                         *
@@ -238,12 +215,12 @@ int plain_ctx_sign(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req)
 static
 int plain_ctx_verify(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req)
 {
-        struct lustre_msg   *msg = req->rq_repdata;
-        struct plain_header *phdr;
-        __u32                cksum;
-        int                  swabbed;
-        ENTRY;
+	struct lustre_msg *msg = req->rq_repdata;
+	struct plain_header *phdr;
+	__u32 cksum;
+	bool swabbed;
 
+	ENTRY;
         if (msg->lm_bufcount != PLAIN_PACK_SEGMENTS) {
                 CERROR("unexpected reply buf count %u\n", msg->lm_bufcount);
                 RETURN(-EPROTO);
@@ -275,15 +252,18 @@ int plain_ctx_verify(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req)
         }
 
         if (unlikely(req->rq_early)) {
-                cksum = crc32_le(!(__u32) 0,
-                                 lustre_msg_buf(msg, PLAIN_PACK_MSG_OFF, 0),
-                                 lustre_msg_buflen(msg, PLAIN_PACK_MSG_OFF));
-                if (cksum != msg->lm_cksum) {
-                        CDEBUG(D_SEC,
-                               "early reply checksum mismatch: %08x != %08x\n",
-                               cpu_to_le32(cksum), msg->lm_cksum);
-                        RETURN(-EINVAL);
-                }
+		unsigned int hsize = 4;
+
+		cfs_crypto_hash_digest(CFS_HASH_ALG_CRC32,
+				lustre_msg_buf(msg, PLAIN_PACK_MSG_OFF, 0),
+				lustre_msg_buflen(msg, PLAIN_PACK_MSG_OFF),
+				NULL, 0, (unsigned char *)&cksum, &hsize);
+		if (cksum != msg->lm_cksum) {
+			CDEBUG(D_SEC,
+			       "early reply checksum mismatch: %08x != %08x\n",
+			       cpu_to_le32(cksum), msg->lm_cksum);
+			RETURN(-EINVAL);
+		}
         } else {
                 /* whether we sent with bulk or not, we expect the same
                  * in reply, except for early reply */
@@ -357,10 +337,9 @@ int plain_cli_unwrap_bulk(struct ptlrpc_cli_ctx *ctx,
         struct ptlrpc_bulk_sec_desc *bsdv;
         struct plain_bulk_token     *tokenv;
         int                          rc;
-#ifdef __KERNEL__
         int                          i, nob;
-#endif
 
+	LASSERT(ptlrpc_is_bulk_desc_kiov(desc->bd_type));
         LASSERT(req->rq_pack_bulk);
         LASSERT(req->rq_reqbuf->lm_bufcount == PLAIN_PACK_SEGMENTS);
         LASSERT(req->rq_repdata->lm_bufcount == PLAIN_PACK_SEGMENTS);
@@ -374,16 +353,15 @@ int plain_cli_unwrap_bulk(struct ptlrpc_cli_ctx *ctx,
                 return 0;
         }
 
-#ifdef __KERNEL__
-        /* fix the actual data size */
-        for (i = 0, nob = 0; i < desc->bd_iov_count; i++) {
-                if (desc->bd_iov[i].kiov_len + nob > desc->bd_nob_transferred) {
-                        desc->bd_iov[i].kiov_len =
-                                desc->bd_nob_transferred - nob;
-                }
-                nob += desc->bd_iov[i].kiov_len;
-        }
-#endif
+	/* fix the actual data size */
+	for (i = 0, nob = 0; i < desc->bd_iov_count; i++) {
+		if (BD_GET_KIOV(desc, i).kiov_len +
+		    nob > desc->bd_nob_transferred) {
+			BD_GET_KIOV(desc, i).kiov_len =
+				desc->bd_nob_transferred - nob;
+		}
+		nob += BD_GET_KIOV(desc, i).kiov_len;
+	}
 
         rc = plain_verify_bulk_csum(desc, req->rq_flvr.u_bulk.hash.hash_alg,
                                     tokenv);
@@ -400,59 +378,59 @@ int plain_cli_unwrap_bulk(struct ptlrpc_cli_ctx *ctx,
 static
 struct ptlrpc_cli_ctx *plain_sec_install_ctx(struct plain_sec *plsec)
 {
-        struct ptlrpc_cli_ctx  *ctx, *ctx_new;
+	struct ptlrpc_cli_ctx  *ctx, *ctx_new;
 
-        OBD_ALLOC_PTR(ctx_new);
+	OBD_ALLOC_PTR(ctx_new);
 
-        cfs_write_lock(&plsec->pls_lock);
+	write_lock(&plsec->pls_lock);
 
-        ctx = plsec->pls_ctx;
-        if (ctx) {
-                cfs_atomic_inc(&ctx->cc_refcount);
-
-                if (ctx_new)
-                        OBD_FREE_PTR(ctx_new);
-        } else if (ctx_new) {
-                ctx = ctx_new;
-
-                cfs_atomic_set(&ctx->cc_refcount, 1); /* for cache */
-                ctx->cc_sec = &plsec->pls_base;
-                ctx->cc_ops = &plain_ctx_ops;
-                ctx->cc_expire = 0;
-                ctx->cc_flags = PTLRPC_CTX_CACHED | PTLRPC_CTX_UPTODATE;
-                ctx->cc_vcred.vc_uid = 0;
-                cfs_spin_lock_init(&ctx->cc_lock);
-                CFS_INIT_LIST_HEAD(&ctx->cc_req_list);
-                CFS_INIT_LIST_HEAD(&ctx->cc_gc_chain);
-
-                plsec->pls_ctx = ctx;
-                cfs_atomic_inc(&plsec->pls_base.ps_nctx);
-                cfs_atomic_inc(&plsec->pls_base.ps_refcount);
-
-                cfs_atomic_inc(&ctx->cc_refcount); /* for caller */
-        }
+	ctx = plsec->pls_ctx;
+	if (ctx) {
+		atomic_inc(&ctx->cc_refcount);
+
+		if (ctx_new)
+			OBD_FREE_PTR(ctx_new);
+	} else if (ctx_new) {
+		ctx = ctx_new;
+
+		atomic_set(&ctx->cc_refcount, 1);	/* for cache */
+		ctx->cc_sec = &plsec->pls_base;
+		ctx->cc_ops = &plain_ctx_ops;
+		ctx->cc_expire = 0;
+		ctx->cc_flags = PTLRPC_CTX_CACHED | PTLRPC_CTX_UPTODATE;
+		ctx->cc_vcred.vc_uid = 0;
+		spin_lock_init(&ctx->cc_lock);
+		INIT_LIST_HEAD(&ctx->cc_req_list);
+		INIT_LIST_HEAD(&ctx->cc_gc_chain);
 
-        cfs_write_unlock(&plsec->pls_lock);
+		plsec->pls_ctx = ctx;
+		atomic_inc(&plsec->pls_base.ps_nctx);
+		atomic_inc(&plsec->pls_base.ps_refcount);
 
-        return ctx;
+		atomic_inc(&ctx->cc_refcount);	/* for caller */
+	}
+
+	write_unlock(&plsec->pls_lock);
+
+	return ctx;
 }
 
 static
 void plain_destroy_sec(struct ptlrpc_sec *sec)
 {
-        struct plain_sec       *plsec = sec2plsec(sec);
-        ENTRY;
+	struct plain_sec *plsec = sec2plsec(sec);
+	ENTRY;
 
-        LASSERT(sec->ps_policy == &plain_policy);
-        LASSERT(sec->ps_import);
-        LASSERT(cfs_atomic_read(&sec->ps_refcount) == 0);
-        LASSERT(cfs_atomic_read(&sec->ps_nctx) == 0);
-        LASSERT(plsec->pls_ctx == NULL);
+	LASSERT(sec->ps_policy == &plain_policy);
+	LASSERT(sec->ps_import);
+	LASSERT(atomic_read(&sec->ps_refcount) == 0);
+	LASSERT(atomic_read(&sec->ps_nctx) == 0);
+	LASSERT(plsec->pls_ctx == NULL);
 
-        class_import_put(sec->ps_import);
+	class_import_put(sec->ps_import);
 
-        OBD_FREE_PTR(plsec);
-        EXIT;
+	OBD_FREE_PTR(plsec);
+	EXIT;
 }
 
 static
@@ -480,18 +458,18 @@ struct ptlrpc_sec *plain_create_sec(struct obd_import *imp,
         /*
          * initialize plain_sec
          */
-        cfs_rwlock_init(&plsec->pls_lock);
-        plsec->pls_ctx = NULL;
-
-        sec = &plsec->pls_base;
-        sec->ps_policy = &plain_policy;
-        cfs_atomic_set(&sec->ps_refcount, 0);
-        cfs_atomic_set(&sec->ps_nctx, 0);
-        sec->ps_id = sptlrpc_get_next_secid();
-        sec->ps_import = class_import_get(imp);
-        sec->ps_flvr = *sf;
-        cfs_spin_lock_init(&sec->ps_lock);
-        CFS_INIT_LIST_HEAD(&sec->ps_gc_list);
+	rwlock_init(&plsec->pls_lock);
+	plsec->pls_ctx = NULL;
+
+	sec = &plsec->pls_base;
+	sec->ps_policy = &plain_policy;
+	atomic_set(&sec->ps_refcount, 0);
+	atomic_set(&sec->ps_nctx, 0);
+	sec->ps_id = sptlrpc_get_next_secid();
+	sec->ps_import = class_import_get(imp);
+	sec->ps_flvr = *sf;
+	spin_lock_init(&sec->ps_lock);
+	INIT_LIST_HEAD(&sec->ps_gc_list);
         sec->ps_gc_interval = 0;
         sec->ps_gc_next = 0;
 
@@ -513,35 +491,35 @@ struct ptlrpc_cli_ctx *plain_lookup_ctx(struct ptlrpc_sec *sec,
                                         struct vfs_cred *vcred,
                                         int create, int remove_dead)
 {
-        struct plain_sec       *plsec = sec2plsec(sec);
-        struct ptlrpc_cli_ctx  *ctx;
-        ENTRY;
+	struct plain_sec       *plsec = sec2plsec(sec);
+	struct ptlrpc_cli_ctx  *ctx;
+	ENTRY;
 
-        cfs_read_lock(&plsec->pls_lock);
-        ctx = plsec->pls_ctx;
-        if (ctx)
-                cfs_atomic_inc(&ctx->cc_refcount);
-        cfs_read_unlock(&plsec->pls_lock);
+	read_lock(&plsec->pls_lock);
+	ctx = plsec->pls_ctx;
+	if (ctx)
+		atomic_inc(&ctx->cc_refcount);
+	read_unlock(&plsec->pls_lock);
 
-        if (unlikely(ctx == NULL))
-                ctx = plain_sec_install_ctx(plsec);
+	if (unlikely(ctx == NULL))
+		ctx = plain_sec_install_ctx(plsec);
 
-        RETURN(ctx);
+	RETURN(ctx);
 }
 
 static
 void plain_release_ctx(struct ptlrpc_sec *sec,
                        struct ptlrpc_cli_ctx *ctx, int sync)
 {
-        LASSERT(cfs_atomic_read(&sec->ps_refcount) > 0);
-        LASSERT(cfs_atomic_read(&sec->ps_nctx) > 0);
-        LASSERT(cfs_atomic_read(&ctx->cc_refcount) == 0);
-        LASSERT(ctx->cc_sec == sec);
+	LASSERT(atomic_read(&sec->ps_refcount) > 0);
+	LASSERT(atomic_read(&sec->ps_nctx) > 0);
+	LASSERT(atomic_read(&ctx->cc_refcount) == 0);
+	LASSERT(ctx->cc_sec == sec);
 
-        OBD_FREE_PTR(ctx);
+	OBD_FREE_PTR(ctx);
 
-        cfs_atomic_dec(&sec->ps_nctx);
-        sptlrpc_sec_put(sec);
+	atomic_dec(&sec->ps_nctx);
+	sptlrpc_sec_put(sec);
 }
 
 static
@@ -556,10 +534,10 @@ int plain_flush_ctx_cache(struct ptlrpc_sec *sec,
         if (uid != -1)
                 RETURN(0);
 
-        cfs_write_lock(&plsec->pls_lock);
+	write_lock(&plsec->pls_lock);
         ctx = plsec->pls_ctx;
         plsec->pls_ctx = NULL;
-        cfs_write_unlock(&plsec->pls_lock);
+	write_unlock(&plsec->pls_lock);
 
         if (ctx)
                 sptlrpc_cli_ctx_put(ctx, 1);
@@ -588,15 +566,15 @@ int plain_alloc_reqbuf(struct ptlrpc_sec *sec,
 
         alloc_len = lustre_msg_size_v2(PLAIN_PACK_SEGMENTS, buflens);
 
-        if (!req->rq_reqbuf) {
-                LASSERT(!req->rq_pool);
+	if (!req->rq_reqbuf) {
+		LASSERT(!req->rq_pool);
 
-                alloc_len = size_roundup_power2(alloc_len);
-                OBD_ALLOC_LARGE(req->rq_reqbuf, alloc_len);
-                if (!req->rq_reqbuf)
-                        RETURN(-ENOMEM);
+		alloc_len = size_roundup_power2(alloc_len);
+		OBD_ALLOC_LARGE(req->rq_reqbuf, alloc_len);
+		if (!req->rq_reqbuf)
+			RETURN(-ENOMEM);
 
-                req->rq_reqbuf_len = alloc_len;
+		req->rq_reqbuf_len = alloc_len;
         } else {
                 LASSERT(req->rq_pool);
                 LASSERT(req->rq_reqbuf_len >= alloc_len);
@@ -616,13 +594,13 @@ static
 void plain_free_reqbuf(struct ptlrpc_sec *sec,
                        struct ptlrpc_request *req)
 {
-        ENTRY;
-        if (!req->rq_pool) {
-                OBD_FREE_LARGE(req->rq_reqbuf, req->rq_reqbuf_len);
-                req->rq_reqbuf = NULL;
-                req->rq_reqbuf_len = 0;
-        }
-        EXIT;
+	ENTRY;
+	if (!req->rq_pool) {
+		OBD_FREE_LARGE(req->rq_reqbuf, req->rq_reqbuf_len);
+		req->rq_reqbuf = NULL;
+		req->rq_reqbuf_len = 0;
+	}
+	EXIT;
 }
 
 static
@@ -649,12 +627,12 @@ int plain_alloc_repbuf(struct ptlrpc_sec *sec,
 
         alloc_len = size_roundup_power2(alloc_len);
 
-        OBD_ALLOC_LARGE(req->rq_repbuf, alloc_len);
-        if (!req->rq_repbuf)
-                RETURN(-ENOMEM);
+	OBD_ALLOC_LARGE(req->rq_repbuf, alloc_len);
+	if (!req->rq_repbuf)
+		RETURN(-ENOMEM);
 
-        req->rq_repbuf_len = alloc_len;
-        RETURN(0);
+	req->rq_repbuf_len = alloc_len;
+	RETURN(0);
 }
 
 static
@@ -700,28 +678,40 @@ int plain_enlarge_reqbuf(struct ptlrpc_sec *sec,
         /* request from pool should always have enough buffer */
         LASSERT(!req->rq_pool || req->rq_reqbuf_len >= newbuf_size);
 
-        if (req->rq_reqbuf_len < newbuf_size) {
-                newbuf_size = size_roundup_power2(newbuf_size);
+	if (req->rq_reqbuf_len < newbuf_size) {
+		newbuf_size = size_roundup_power2(newbuf_size);
 
-                OBD_ALLOC_LARGE(newbuf, newbuf_size);
-                if (newbuf == NULL)
-                        RETURN(-ENOMEM);
+		OBD_ALLOC_LARGE(newbuf, newbuf_size);
+		if (newbuf == NULL)
+			RETURN(-ENOMEM);
 
-                memcpy(newbuf, req->rq_reqbuf, req->rq_reqbuf_len);
+		/* Must lock this, so that otherwise unprotected change of
+		 * rq_reqmsg is not racing with parallel processing of
+		 * imp_replay_list traversing threads. See LU-3333
+		 * This is a bandaid at best, we really need to deal with this
+		 * in request enlarging code before unpacking that's already
+		 * there */
+		if (req->rq_import)
+			spin_lock(&req->rq_import->imp_lock);
 
-                OBD_FREE_LARGE(req->rq_reqbuf, req->rq_reqbuf_len);
-                req->rq_reqbuf = newbuf;
-                req->rq_reqbuf_len = newbuf_size;
-                req->rq_reqmsg = lustre_msg_buf(req->rq_reqbuf,
-                                                PLAIN_PACK_MSG_OFF, 0);
-        }
+		memcpy(newbuf, req->rq_reqbuf, req->rq_reqbuf_len);
 
-        _sptlrpc_enlarge_msg_inplace(req->rq_reqbuf, PLAIN_PACK_MSG_OFF,
-                                     newmsg_size);
-        _sptlrpc_enlarge_msg_inplace(req->rq_reqmsg, segment, newsize);
+		OBD_FREE_LARGE(req->rq_reqbuf, req->rq_reqbuf_len);
+		req->rq_reqbuf = newbuf;
+		req->rq_reqbuf_len = newbuf_size;
+		req->rq_reqmsg = lustre_msg_buf(req->rq_reqbuf,
+						PLAIN_PACK_MSG_OFF, 0);
 
-        req->rq_reqlen = newmsg_size;
-        RETURN(0);
+		if (req->rq_import)
+			spin_unlock(&req->rq_import->imp_lock);
+	}
+
+	_sptlrpc_enlarge_msg_inplace(req->rq_reqbuf, PLAIN_PACK_MSG_OFF,
+				     newmsg_size);
+	_sptlrpc_enlarge_msg_inplace(req->rq_reqmsg, segment, newsize);
+
+	req->rq_reqlen = newmsg_size;
+	RETURN(0);
 }
 
 /****************************************
@@ -729,20 +719,19 @@ int plain_enlarge_reqbuf(struct ptlrpc_sec *sec,
  ****************************************/
 
 static struct ptlrpc_svc_ctx plain_svc_ctx = {
-        .sc_refcount    = CFS_ATOMIC_INIT(1),
+	.sc_refcount    = ATOMIC_INIT(1),
         .sc_policy      = &plain_policy,
 };
 
-static
-int plain_accept(struct ptlrpc_request *req)
+static int plain_accept(struct ptlrpc_request *req)
 {
-        struct lustre_msg   *msg = req->rq_reqbuf;
-        struct plain_header *phdr;
-        int                  swabbed;
-        ENTRY;
+	struct lustre_msg *msg = req->rq_reqbuf;
+	struct plain_header *phdr;
+	bool swabbed;
 
-        LASSERT(SPTLRPC_FLVR_POLICY(req->rq_flvr.sf_rpc) ==
-                SPTLRPC_POLICY_PLAIN);
+	ENTRY;
+	LASSERT(SPTLRPC_FLVR_POLICY(req->rq_flvr.sf_rpc) ==
+		SPTLRPC_POLICY_PLAIN);
 
         if (SPTLRPC_FLVR_BASE(req->rq_flvr.sf_rpc) !=
             SPTLRPC_FLVR_BASE(SPTLRPC_FLVR_PLAIN) ||
@@ -796,13 +785,13 @@ int plain_accept(struct ptlrpc_request *req)
                 req->rq_pack_bulk = 1;
         }
 
-        req->rq_reqmsg = lustre_msg_buf(msg, PLAIN_PACK_MSG_OFF, 0);
-        req->rq_reqlen = msg->lm_buflens[PLAIN_PACK_MSG_OFF];
+	req->rq_reqmsg = lustre_msg_buf(msg, PLAIN_PACK_MSG_OFF, 0);
+	req->rq_reqlen = msg->lm_buflens[PLAIN_PACK_MSG_OFF];
 
-        req->rq_svc_ctx = &plain_svc_ctx;
-        cfs_atomic_inc(&req->rq_svc_ctx->sc_refcount);
+	req->rq_svc_ctx = &plain_svc_ctx;
+	atomic_inc(&req->rq_svc_ctx->sc_refcount);
 
-        RETURN(SECSVC_OK);
+	RETURN(SECSVC_OK);
 }
 
 static
@@ -825,40 +814,40 @@ int plain_alloc_rs(struct ptlrpc_request *req, int msgsize)
 
         rs = req->rq_reply_state;
 
-        if (rs) {
-                /* pre-allocated */
-                LASSERT(rs->rs_size >= rs_size);
-        } else {
-                OBD_ALLOC_LARGE(rs, rs_size);
-                if (rs == NULL)
-                        RETURN(-ENOMEM);
+	if (rs) {
+		/* pre-allocated */
+		LASSERT(rs->rs_size >= rs_size);
+	} else {
+		OBD_ALLOC_LARGE(rs, rs_size);
+		if (rs == NULL)
+			RETURN(-ENOMEM);
 
-                rs->rs_size = rs_size;
-        }
+		rs->rs_size = rs_size;
+	}
 
-        rs->rs_svc_ctx = req->rq_svc_ctx;
-        cfs_atomic_inc(&req->rq_svc_ctx->sc_refcount);
-        rs->rs_repbuf = (struct lustre_msg *) (rs + 1);
-        rs->rs_repbuf_len = rs_size - sizeof(*rs);
+	rs->rs_svc_ctx = req->rq_svc_ctx;
+	atomic_inc(&req->rq_svc_ctx->sc_refcount);
+	rs->rs_repbuf = (struct lustre_msg *) (rs + 1);
+	rs->rs_repbuf_len = rs_size - sizeof(*rs);
 
-        lustre_init_msg_v2(rs->rs_repbuf, PLAIN_PACK_SEGMENTS, buflens, NULL);
-        rs->rs_msg = lustre_msg_buf_v2(rs->rs_repbuf, PLAIN_PACK_MSG_OFF, 0);
+	lustre_init_msg_v2(rs->rs_repbuf, PLAIN_PACK_SEGMENTS, buflens, NULL);
+	rs->rs_msg = lustre_msg_buf_v2(rs->rs_repbuf, PLAIN_PACK_MSG_OFF, 0);
 
-        req->rq_reply_state = rs;
-        RETURN(0);
+	req->rq_reply_state = rs;
+	RETURN(0);
 }
 
 static
 void plain_free_rs(struct ptlrpc_reply_state *rs)
 {
-        ENTRY;
+	ENTRY;
 
-        LASSERT(cfs_atomic_read(&rs->rs_svc_ctx->sc_refcount) > 1);
-        cfs_atomic_dec(&rs->rs_svc_ctx->sc_refcount);
+	LASSERT(atomic_read(&rs->rs_svc_ctx->sc_refcount) > 1);
+	atomic_dec(&rs->rs_svc_ctx->sc_refcount);
 
-        if (!rs->rs_prealloc)
-                OBD_FREE_LARGE(rs, rs->rs_size);
-        EXIT;
+	if (!rs->rs_prealloc)
+		OBD_FREE_LARGE(rs, rs->rs_size);
+	EXIT;
 }
 
 static
@@ -897,10 +886,13 @@ int plain_authorize(struct ptlrpc_request *req)
                 else
                         req->rq_reply_off = 0;
         } else {
-                msg->lm_cksum = crc32_le(!(__u32) 0,
-                                lustre_msg_buf(msg, PLAIN_PACK_MSG_OFF, 0),
-                                lustre_msg_buflen(msg, PLAIN_PACK_MSG_OFF));
-                req->rq_reply_off = 0;
+		unsigned int hsize = 4;
+
+		cfs_crypto_hash_digest(CFS_HASH_ALG_CRC32,
+			lustre_msg_buf(msg, PLAIN_PACK_MSG_OFF, 0),
+			lustre_msg_buflen(msg, PLAIN_PACK_MSG_OFF),
+			NULL, 0, (unsigned char *)&msg->lm_cksum, &hsize);
+		req->rq_reply_off = 0;
         }
 
         RETURN(0);