X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fptlrpc%2Fsec_null.c;h=a54a9d85f9a59388b18b15b008fb0814f98e0fb2;hb=9560e011ef7b8d1538ec48d297813b8d55d2f09b;hp=c62ab831b3891513d4121bec2279e36f0151b5ff;hpb=294e507d34de0d7990ec507334f71ff1d1a7db01;p=fs%2Flustre-release.git diff --git a/lustre/ptlrpc/sec_null.c b/lustre/ptlrpc/sec_null.c index c62ab83..a54a9d8 100644 --- a/lustre/ptlrpc/sec_null.c +++ b/lustre/ptlrpc/sec_null.c @@ -27,7 +27,7 @@ * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2012, Intel Corporation. + * Copyright (c) 2011, 2014, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -40,9 +40,6 @@ #define DEBUG_SUBSYSTEM S_SEC -#ifndef __KERNEL__ -#include -#endif #include #include @@ -50,6 +47,8 @@ #include #include +#include "ptlrpc_internal.h" + static struct ptlrpc_sec_policy null_policy; static struct ptlrpc_sec null_sec; static struct ptlrpc_cli_ctx null_cli_ctx; @@ -104,16 +103,8 @@ 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, 7, 50, 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 + cksumc = lustre_msg_calc_cksum(req->rq_repmsg); + if (cksumc != cksums) { CDEBUG(D_SEC, "early reply checksum mismatch: %08x != %08x\n", @@ -167,23 +158,23 @@ int null_alloc_reqbuf(struct ptlrpc_sec *sec, struct ptlrpc_request *req, int msgsize) { - if (!req->rq_reqbuf) { - int alloc_size = size_roundup_power2(msgsize); - - LASSERT(!req->rq_pool); - OBD_ALLOC_LARGE(req->rq_reqbuf, alloc_size); - if (!req->rq_reqbuf) - return -ENOMEM; - - req->rq_reqbuf_len = alloc_size; - } else { - LASSERT(req->rq_pool); - LASSERT(req->rq_reqbuf_len >= msgsize); - memset(req->rq_reqbuf, 0, msgsize); - } + if (!req->rq_reqbuf) { + int alloc_size = size_roundup_power2(msgsize); + + LASSERT(!req->rq_pool); + OBD_ALLOC_LARGE(req->rq_reqbuf, alloc_size); + if (!req->rq_reqbuf) + return -ENOMEM; + + req->rq_reqbuf_len = alloc_size; + } else { + LASSERT(req->rq_pool); + LASSERT(req->rq_reqbuf_len >= msgsize); + memset(req->rq_reqbuf, 0, msgsize); + } - req->rq_reqmsg = req->rq_reqbuf; - return 0; + req->rq_reqmsg = req->rq_reqbuf; + return 0; } static @@ -209,17 +200,17 @@ int null_alloc_repbuf(struct ptlrpc_sec *sec, struct ptlrpc_request *req, int msgsize) { - /* add space for early replied */ - msgsize += lustre_msg_early_size(); + /* add space for early replied */ + msgsize += lustre_msg_early_size(); - msgsize = size_roundup_power2(msgsize); + msgsize = size_roundup_power2(msgsize); - OBD_ALLOC_LARGE(req->rq_repbuf, msgsize); - if (!req->rq_repbuf) - return -ENOMEM; + OBD_ALLOC_LARGE(req->rq_repbuf, msgsize); + if (!req->rq_repbuf) + return -ENOMEM; - req->rq_repbuf_len = msgsize; - return 0; + req->rq_repbuf_len = msgsize; + return 0; } static @@ -256,18 +247,29 @@ int null_enlarge_reqbuf(struct ptlrpc_sec *sec, /* request from pool should always have enough buffer */ LASSERT(!req->rq_pool || req->rq_reqbuf_len >= newmsg_size); - if (req->rq_reqbuf_len < newmsg_size) { - alloc_size = size_roundup_power2(newmsg_size); - - OBD_ALLOC_LARGE(newbuf, alloc_size); - if (newbuf == NULL) - return -ENOMEM; - - memcpy(newbuf, req->rq_reqbuf, req->rq_reqlen); - - OBD_FREE_LARGE(req->rq_reqbuf, req->rq_reqbuf_len); - req->rq_reqbuf = req->rq_reqmsg = newbuf; - req->rq_reqbuf_len = alloc_size; + if (req->rq_reqbuf_len < newmsg_size) { + alloc_size = size_roundup_power2(newmsg_size); + + OBD_ALLOC_LARGE(newbuf, alloc_size); + if (newbuf == NULL) + return -ENOMEM; + + /* 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); + memcpy(newbuf, req->rq_reqbuf, req->rq_reqlen); + + OBD_FREE_LARGE(req->rq_reqbuf, req->rq_reqbuf_len); + req->rq_reqbuf = req->rq_reqmsg = newbuf; + req->rq_reqbuf_len = alloc_size; + + if (req->rq_import) + spin_unlock(&req->rq_import->imp_lock); } _sptlrpc_enlarge_msg_inplace(req->rq_reqmsg, segment, newsize); @@ -317,12 +319,12 @@ int null_alloc_rs(struct ptlrpc_request *req, int msgsize) /* pre-allocated */ LASSERT(rs->rs_size >= rs_size); } else { - OBD_ALLOC_LARGE(rs, rs_size); - if (rs == NULL) - return -ENOMEM; + 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; atomic_inc(&req->rq_svc_ctx->sc_refcount); @@ -363,21 +365,12 @@ int null_authorize(struct ptlrpc_request *req) } else { __u32 cksum; -#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 7, 50, 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; - } + cksum = lustre_msg_calc_cksum(rs->rs_repbuf); + lustre_msg_set_cksum(rs->rs_repbuf, cksum); + req->rq_reply_off = 0; + } - return 0; + return 0; } static struct ptlrpc_ctx_ops null_ctx_ops = { @@ -415,7 +408,7 @@ static struct ptlrpc_sec_policy null_policy = { static void null_init_internal(void) { - static CFS_HLIST_HEAD(__list); + static HLIST_HEAD(__list); null_sec.ps_policy = &null_policy; atomic_set(&null_sec.ps_refcount, 1); /* always busy */ @@ -427,11 +420,11 @@ static void null_init_internal(void) null_sec.ps_dying = 0; spin_lock_init(&null_sec.ps_lock); atomic_set(&null_sec.ps_nctx, 1); /* for "null_cli_ctx" */ - CFS_INIT_LIST_HEAD(&null_sec.ps_gc_list); + INIT_LIST_HEAD(&null_sec.ps_gc_list); null_sec.ps_gc_interval = 0; null_sec.ps_gc_next = 0; - cfs_hlist_add_head(&null_cli_ctx.cc_cache, &__list); + hlist_add_head(&null_cli_ctx.cc_cache, &__list); 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; @@ -440,8 +433,8 @@ static void null_init_internal(void) PTLRPC_CTX_UPTODATE; null_cli_ctx.cc_vcred.vc_uid = 0; 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); + INIT_LIST_HEAD(&null_cli_ctx.cc_req_list); + INIT_LIST_HEAD(&null_cli_ctx.cc_gc_chain); } int sptlrpc_null_init(void)