b=23728 Doxygen style comment - sptlrpc api.

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

diff --git a/lustre/ptlrpc/sec_null.c b/lustre/ptlrpc/sec_null.c
index 041217e..dd4332b 100644 (file)
--- a/lustre/ptlrpc/sec_null.c
+++ b/lustre/ptlrpc/sec_null.c
@@ -26,7 +26,7 @@
  * 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.
  */
 /*
@@ -107,7 +107,16 @@ int null_ctx_verify(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req)
 
         if (req->rq_early) {
                 cksums = lustre_msg_get_cksum(req->rq_repdata);
+#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 9, 0, 0)
+                if (lustre_msghdr_get_flags(req->rq_reqmsg) &
+                    MSGHDR_CKSUM_INCOMPAT18)
+                        cksumc = lustre_msg_calc_cksum(req->rq_repmsg, 0);
+                else
+                        cksumc = lustre_msg_calc_cksum(req->rq_repmsg, 1);
+#else
+# warning "remove checksum compatibility support for b1_8"
                 cksumc = lustre_msg_calc_cksum(req->rq_repmsg);
+#endif
                 if (cksumc != cksums) {
                         CWARN("early reply checksum mismatch: %08x != %08x\n",
                               cksumc, cksums);
@@ -143,7 +152,7 @@ struct ptlrpc_cli_ctx *null_lookup_ctx(struct ptlrpc_sec *sec,
                                        struct vfs_cred *vcred,
                                        int create, int remove_dead)
 {
-        atomic_inc(&null_cli_ctx.cc_refcount);
+        cfs_atomic_inc(&null_cli_ctx.cc_refcount);
         return &null_cli_ctx;
 }
 
@@ -192,11 +201,9 @@ void null_free_reqbuf(struct ptlrpc_sec *sec,
                          req, req->rq_reqlen, req->rq_reqbuf_len);
 
                 OBD_FREE(req->rq_reqbuf, req->rq_reqbuf_len);
-                req->rq_reqmsg = req->rq_reqbuf = NULL;
+                req->rq_reqbuf = NULL;
                 req->rq_reqbuf_len = 0;
         }
-
-        req->rq_reqmsg = NULL;
 }
 
 static
@@ -226,8 +233,6 @@ void null_free_repbuf(struct ptlrpc_sec *sec,
         OBD_FREE(req->rq_repbuf, req->rq_repbuf_len);
         req->rq_repbuf = NULL;
         req->rq_repbuf_len = 0;
-
-        req->rq_repmsg = NULL;
 }
 
 static
@@ -274,7 +279,7 @@ int null_enlarge_reqbuf(struct ptlrpc_sec *sec,
 }
 
 static struct ptlrpc_svc_ctx null_svc_ctx = {
-        .sc_refcount    = ATOMIC_INIT(1),
+        .sc_refcount    = CFS_ATOMIC_INIT(1),
         .sc_policy      = &null_policy,
 };
 
@@ -295,7 +300,7 @@ int null_accept(struct ptlrpc_request *req)
         req->rq_reqlen = req->rq_reqdata_len;
 
         req->rq_svc_ctx = &null_svc_ctx;
-        atomic_inc(&req->rq_svc_ctx->sc_refcount);
+        cfs_atomic_inc(&req->rq_svc_ctx->sc_refcount);
 
         return SECSVC_OK;
 }
@@ -322,7 +327,7 @@ int null_alloc_rs(struct ptlrpc_request *req, int msgsize)
         }
 
         rs->rs_svc_ctx = req->rq_svc_ctx;
-        atomic_inc(&req->rq_svc_ctx->sc_refcount);
+        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);
@@ -335,8 +340,8 @@ int null_alloc_rs(struct ptlrpc_request *req, int msgsize)
 static
 void null_free_rs(struct ptlrpc_reply_state *rs)
 {
-        LASSERT(atomic_read(&rs->rs_svc_ctx->sc_refcount) > 1);
-        atomic_dec(&rs->rs_svc_ctx->sc_refcount);
+        LASSERT(cfs_atomic_read(&rs->rs_svc_ctx->sc_refcount) > 1);
+        cfs_atomic_dec(&rs->rs_svc_ctx->sc_refcount);
 
         if (!rs->rs_prealloc)
                 OBD_FREE(rs, rs->rs_size);
@@ -358,8 +363,19 @@ int null_authorize(struct ptlrpc_request *req)
                 else
                         req->rq_reply_off = 0;
         } else {
-                lustre_msg_set_cksum(rs->rs_repbuf,
-                                     lustre_msg_calc_cksum(rs->rs_repbuf));
+                __u32 cksum;
+
+#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 9, 0, 0)
+                if (lustre_msghdr_get_flags(req->rq_reqmsg) &
+                    MSGHDR_CKSUM_INCOMPAT18)
+                        cksum = lustre_msg_calc_cksum(rs->rs_repbuf, 0);
+                else
+                        cksum = lustre_msg_calc_cksum(rs->rs_repbuf, 1);
+#else
+# warning "remove checksum compatibility support for b1_8"
+                cksum = lustre_msg_calc_cksum(rs->rs_repbuf);
+#endif
+                lustre_msg_set_cksum(rs->rs_repbuf, cksum);
                 req->rq_reply_off = 0;
         }
 
@@ -401,31 +417,31 @@ static struct ptlrpc_sec_policy null_policy = {
 
 static void null_init_internal(void)
 {
-        static HLIST_HEAD(__list);
+        static CFS_HLIST_HEAD(__list);
 
         null_sec.ps_policy = &null_policy;
-        atomic_set(&null_sec.ps_refcount, 1);     /* always busy */
+        cfs_atomic_set(&null_sec.ps_refcount, 1);     /* always busy */
         null_sec.ps_id = -1;
         null_sec.ps_import = NULL;
         null_sec.ps_flvr.sf_rpc = SPTLRPC_FLVR_NULL;
         null_sec.ps_flvr.sf_flags = 0;
         null_sec.ps_part = LUSTRE_SP_ANY;
         null_sec.ps_dying = 0;
-        spin_lock_init(&null_sec.ps_lock);
-        atomic_set(&null_sec.ps_nctx, 1);         /* for "null_cli_ctx" */
+        cfs_spin_lock_init(&null_sec.ps_lock);
+        cfs_atomic_set(&null_sec.ps_nctx, 1);         /* for "null_cli_ctx" */
         CFS_INIT_LIST_HEAD(&null_sec.ps_gc_list);
         null_sec.ps_gc_interval = 0;
         null_sec.ps_gc_next = 0;
 
-        hlist_add_head(&null_cli_ctx.cc_cache, &__list);
-        atomic_set(&null_cli_ctx.cc_refcount, 1);    /* for hash */
+        cfs_hlist_add_head(&null_cli_ctx.cc_cache, &__list);
+        cfs_atomic_set(&null_cli_ctx.cc_refcount, 1);    /* for hash */
         null_cli_ctx.cc_sec = &null_sec;
         null_cli_ctx.cc_ops = &null_ctx_ops;
         null_cli_ctx.cc_expire = 0;
         null_cli_ctx.cc_flags = PTLRPC_CTX_CACHED | PTLRPC_CTX_ETERNAL |
                                 PTLRPC_CTX_UPTODATE;
         null_cli_ctx.cc_vcred.vc_uid = 0;
-        spin_lock_init(&null_cli_ctx.cc_lock);
+        cfs_spin_lock_init(&null_cli_ctx.cc_lock);
         CFS_INIT_LIST_HEAD(&null_cli_ctx.cc_req_list);
         CFS_INIT_LIST_HEAD(&null_cli_ctx.cc_gc_chain);
 }