X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fptlrpc%2Fsec_plain.c;h=510b3fdc77ac7871b232685b3852c0eb1b21f2cc;hb=f28cc25929c4e8a111e96b2205a0433542b35e84;hp=10f88fab20521789e4cb5ed8358d338f215e5de1;hpb=84a3fd67356c8073a917ea6abd63928055e38156;p=fs%2Flustre-release.git diff --git a/lustre/ptlrpc/sec_plain.c b/lustre/ptlrpc/sec_plain.c index 10f88fa..510b3fd 100644 --- a/lustre/ptlrpc/sec_plain.c +++ b/lustre/ptlrpc/sec_plain.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, Whamcloud, Inc. + * Copyright (c) 2011, 2015, 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,9 +47,11 @@ #include #include +#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; }; @@ -155,37 +154,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 * @@ -355,10 +341,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); @@ -372,16 +357,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); @@ -398,59 +382,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); + + plsec->pls_ctx = ctx; + atomic_inc(&plsec->pls_base.ps_nctx); + atomic_inc(&plsec->pls_base.ps_refcount); - cfs_write_unlock(&plsec->pls_lock); + atomic_inc(&ctx->cc_refcount); /* for caller */ + } - return ctx; + 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 @@ -478,18 +462,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; @@ -511,35 +495,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 @@ -554,10 +538,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); @@ -586,15 +570,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); @@ -614,13 +598,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 @@ -647,12 +631,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 @@ -698,28 +682,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); } /**************************************** @@ -727,7 +723,7 @@ 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, }; @@ -794,13 +790,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 @@ -823,40 +819,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 @@ -901,7 +897,7 @@ int plain_authorize(struct ptlrpc_request *req) 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; + req->rq_reply_off = 0; } RETURN(0);