LU-1201 checksum: add libcfs crypto hash

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

diff --git a/lustre/ptlrpc/sec_plain.c b/lustre/ptlrpc/sec_plain.c
index 6bfa013..10f88fa 100644 (file)
--- 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.
@@ -26,8 +24,10 @@
  * GPL HEADER END
  */
 /*
- * Copyright  2008 Sun Microsystems, Inc. All rights reserved
+ * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
+ *
+ * Copyright (c) 2011, Whamcloud, Inc.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -38,9 +38,6 @@
  * Author: Eric Mei <ericm@clusterfs.com>
  */
 
-#ifndef EXPORT_SYMTAB
-# define EXPORT_SYMTAB
-#endif
 #define DEBUG_SUBSYSTEM S_SEC
 
 #ifndef __KERNEL__
@@ -273,14 +270,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) {
-                        CWARN("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 */
@@ -351,8 +352,8 @@ int plain_cli_unwrap_bulk(struct ptlrpc_cli_ctx *ctx,
                           struct ptlrpc_request *req,
                           struct ptlrpc_bulk_desc *desc)
 {
-        struct ptlrpc_bulk_sec_desc *bsdr, *bsdv;
-        struct plain_bulk_token     *tokenr, *tokenv;
+        struct ptlrpc_bulk_sec_desc *bsdv;
+        struct plain_bulk_token     *tokenv;
         int                          rc;
 #ifdef __KERNEL__
         int                          i, nob;
@@ -362,8 +363,6 @@ int plain_cli_unwrap_bulk(struct ptlrpc_cli_ctx *ctx,
         LASSERT(req->rq_reqbuf->lm_bufcount == PLAIN_PACK_SEGMENTS);
         LASSERT(req->rq_repdata->lm_bufcount == PLAIN_PACK_SEGMENTS);
 
-        bsdr = lustre_msg_buf(req->rq_reqbuf, PLAIN_PACK_BULK_OFF, 0);
-        tokenr = (struct plain_bulk_token *) bsdr->bsd_data;
         bsdv = lustre_msg_buf(req->rq_repdata, PLAIN_PACK_BULK_OFF, 0);
         tokenv = (struct plain_bulk_token *) bsdv->bsd_data;
 
@@ -591,7 +590,7 @@ int plain_alloc_reqbuf(struct ptlrpc_sec *sec,
                 LASSERT(!req->rq_pool);
 
                 alloc_len = size_roundup_power2(alloc_len);
-                OBD_ALLOC(req->rq_reqbuf, alloc_len);
+                OBD_ALLOC_LARGE(req->rq_reqbuf, alloc_len);
                 if (!req->rq_reqbuf)
                         RETURN(-ENOMEM);
 
@@ -617,12 +616,10 @@ void plain_free_reqbuf(struct ptlrpc_sec *sec,
 {
         ENTRY;
         if (!req->rq_pool) {
-                OBD_FREE(req->rq_reqbuf, req->rq_reqbuf_len);
+                OBD_FREE_LARGE(req->rq_reqbuf, req->rq_reqbuf_len);
                 req->rq_reqbuf = NULL;
                 req->rq_reqbuf_len = 0;
         }
-
-        req->rq_reqmsg = NULL;
         EXIT;
 }
 
@@ -650,7 +647,7 @@ int plain_alloc_repbuf(struct ptlrpc_sec *sec,
 
         alloc_len = size_roundup_power2(alloc_len);
 
-        OBD_ALLOC(req->rq_repbuf, alloc_len);
+        OBD_ALLOC_LARGE(req->rq_repbuf, alloc_len);
         if (!req->rq_repbuf)
                 RETURN(-ENOMEM);
 
@@ -663,11 +660,9 @@ void plain_free_repbuf(struct ptlrpc_sec *sec,
                        struct ptlrpc_request *req)
 {
         ENTRY;
-        OBD_FREE(req->rq_repbuf, req->rq_repbuf_len);
+        OBD_FREE_LARGE(req->rq_repbuf, req->rq_repbuf_len);
         req->rq_repbuf = NULL;
         req->rq_repbuf_len = 0;
-
-        req->rq_repmsg = NULL;
         EXIT;
 }
 
@@ -706,13 +701,13 @@ int plain_enlarge_reqbuf(struct ptlrpc_sec *sec,
         if (req->rq_reqbuf_len < newbuf_size) {
                 newbuf_size = size_roundup_power2(newbuf_size);
 
-                OBD_ALLOC(newbuf, newbuf_size);
+                OBD_ALLOC_LARGE(newbuf, newbuf_size);
                 if (newbuf == NULL)
                         RETURN(-ENOMEM);
 
                 memcpy(newbuf, req->rq_reqbuf, req->rq_reqbuf_len);
 
-                OBD_FREE(req->rq_reqbuf, req->rq_reqbuf_len);
+                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,
@@ -832,7 +827,7 @@ int plain_alloc_rs(struct ptlrpc_request *req, int msgsize)
                 /* pre-allocated */
                 LASSERT(rs->rs_size >= rs_size);
         } else {
-                OBD_ALLOC(rs, rs_size);
+                OBD_ALLOC_LARGE(rs, rs_size);
                 if (rs == NULL)
                         RETURN(-ENOMEM);
 
@@ -860,7 +855,7 @@ void plain_free_rs(struct ptlrpc_reply_state *rs)
         cfs_atomic_dec(&rs->rs_svc_ctx->sc_refcount);
 
         if (!rs->rs_prealloc)
-                OBD_FREE(rs, rs->rs_size);
+                OBD_FREE_LARGE(rs, rs->rs_size);
         EXIT;
 }
 
@@ -900,10 +895,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);
@@ -915,7 +913,7 @@ int plain_svc_unwrap_bulk(struct ptlrpc_request *req,
 {
         struct ptlrpc_reply_state   *rs = req->rq_reply_state;
         struct ptlrpc_bulk_sec_desc *bsdr, *bsdv;
-        struct plain_bulk_token     *tokenr, *tokenv;
+        struct plain_bulk_token     *tokenr;
         int                          rc;
 
         LASSERT(req->rq_bulk_write);
@@ -924,7 +922,6 @@ int plain_svc_unwrap_bulk(struct ptlrpc_request *req,
         bsdr = lustre_msg_buf(req->rq_reqbuf, PLAIN_PACK_BULK_OFF, 0);
         tokenr = (struct plain_bulk_token *) bsdr->bsd_data;
         bsdv = lustre_msg_buf(rs->rs_repbuf, PLAIN_PACK_BULK_OFF, 0);
-        tokenv = (struct plain_bulk_token *) bsdv->bsd_data;
 
         bsdv->bsd_version = 0;
         bsdv->bsd_type = SPTLRPC_BULK_DEFAULT;
@@ -950,14 +947,13 @@ int plain_svc_wrap_bulk(struct ptlrpc_request *req,
 {
         struct ptlrpc_reply_state   *rs = req->rq_reply_state;
         struct ptlrpc_bulk_sec_desc *bsdr, *bsdv;
-        struct plain_bulk_token     *tokenr, *tokenv;
+        struct plain_bulk_token     *tokenv;
         int                          rc;
 
         LASSERT(req->rq_bulk_read);
         LASSERT(req->rq_pack_bulk);
 
         bsdr = lustre_msg_buf(req->rq_reqbuf, PLAIN_PACK_BULK_OFF, 0);
-        tokenr = (struct plain_bulk_token *) bsdr->bsd_data;
         bsdv = lustre_msg_buf(rs->rs_repbuf, PLAIN_PACK_BULK_OFF, 0);
         tokenv = (struct plain_bulk_token *) bsdv->bsd_data;