X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fptlrpc%2Fsec_null.c;h=041217eb1a98533c46b3a97b960500a115b64adb;hp=dddf7e2bd8f5fcf142d9d31d99fc8445718e42dd;hb=0a714ba01bbcdb43fa2d07e88652be2b8fb1c52f;hpb=3192e52a89946f12fd36d28a686c169d01d36e64 diff --git a/lustre/ptlrpc/sec_null.c b/lustre/ptlrpc/sec_null.c index dddf7e2..041217e 100644 --- a/lustre/ptlrpc/sec_null.c +++ b/lustre/ptlrpc/sec_null.c @@ -1,23 +1,41 @@ /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- * vim:expandtab:shiftwidth=8:tabstop=8: * - * Copyright (C) 2004-2006 Cluster File Systems, Inc. - * Author: Eric Mei + * GPL HEADER START * - * This file is part of Lustre, http://www.lustre.org. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * Lustre is free software; you can redistribute it and/or - * modify it under the terms of version 2 of the GNU General Public - * License as published by the Free Software Foundation. + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 only, + * as published by the Free Software Foundation. * - * Lustre is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License version 2 for more details (a copy is included + * in the LICENSE file that accompanied this code). * - * You should have received a copy of the GNU General Public License - * along with Lustre; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * 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. + * + * GPL HEADER END + */ +/* + * Copyright 2008 Sun Microsystems, Inc. All rights reserved + * Use is subject to license terms. + */ +/* + * This file is part of Lustre, http://www.lustre.org/ + * Lustre is a trademark of Sun Microsystems, Inc. + * + * lustre/ptlrpc/sec_null.c + * + * Author: Eric Mei */ #ifndef EXPORT_SYMTAB @@ -30,6 +48,7 @@ #endif #include +#include #include #include #include @@ -40,30 +59,22 @@ static struct ptlrpc_cli_ctx null_cli_ctx; static struct ptlrpc_svc_ctx null_svc_ctx; /* - * null sec temporarily use the third byte of lm_secflvr to identify + * we can temporarily use the topmost 8-bits of lm_secflvr to identify * the source sec part. */ static inline void null_encode_sec_part(struct lustre_msg *msg, enum lustre_sec_part sp) { - msg->lm_secflvr |= (((__u32) sp) & 0xFF) << 16; + msg->lm_secflvr |= (((__u32) sp) & 0xFF) << 24; } static inline enum lustre_sec_part null_decode_sec_part(struct lustre_msg *msg) { - switch (msg->lm_magic) { - case LUSTRE_MSG_MAGIC_V2: - return (msg->lm_secflvr >> 16) & 0xFF; - case LUSTRE_MSG_MAGIC_V2_SWABBED: - return (msg->lm_secflvr >> 8) & 0xFF; - default: - return LUSTRE_SP_ANY; - } + return (msg->lm_secflvr >> 24) & 0xFF; } -static -int null_ctx_refresh(struct ptlrpc_cli_ctx *ctx) +static int null_ctx_refresh(struct ptlrpc_cli_ctx *ctx) { /* should never reach here */ LBUG(); @@ -73,14 +84,12 @@ int null_ctx_refresh(struct ptlrpc_cli_ctx *ctx) static int null_ctx_sign(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req) { - if (req->rq_reqbuf->lm_magic != LUSTRE_MSG_MAGIC_V1) { - req->rq_reqbuf->lm_secflvr = SPTLRPC_FLVR_NULL; + req->rq_reqbuf->lm_secflvr = SPTLRPC_FLVR_NULL; - if (!req->rq_import->imp_dlm_fake) { - struct obd_device *obd = req->rq_import->imp_obd; - null_encode_sec_part(req->rq_reqbuf, - obd->u.cli.cl_sec_part); - } + if (!req->rq_import->imp_dlm_fake) { + struct obd_device *obd = req->rq_import->imp_obd; + null_encode_sec_part(req->rq_reqbuf, + obd->u.cli.cl_sp_me); } req->rq_reqdata_len = req->rq_reqlen; return 0; @@ -89,35 +98,32 @@ int null_ctx_sign(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req) static int null_ctx_verify(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req) { - req->rq_repmsg = req->rq_repbuf; + __u32 cksums, cksumc; + + LASSERT(req->rq_repdata); + + req->rq_repmsg = req->rq_repdata; req->rq_replen = req->rq_repdata_len; - return 0; -} -static struct ptlrpc_ctx_ops null_ctx_ops = { - .refresh = null_ctx_refresh, - .sign = null_ctx_sign, - .verify = null_ctx_verify, -}; + if (req->rq_early) { + cksums = lustre_msg_get_cksum(req->rq_repdata); + cksumc = lustre_msg_calc_cksum(req->rq_repmsg); + if (cksumc != cksums) { + CWARN("early reply checksum mismatch: %08x != %08x\n", + cksumc, cksums); + return -EINVAL; + } + } -static struct ptlrpc_svc_ctx null_svc_ctx = { - .sc_refcount = ATOMIC_INIT(1), - .sc_policy = &null_policy, -}; + return 0; +} static struct ptlrpc_sec *null_create_sec(struct obd_import *imp, struct ptlrpc_svc_ctx *svc_ctx, struct sptlrpc_flavor *sf) { - LASSERT(RPC_FLVR_POLICY(sf->sf_rpc) == SPTLRPC_POLICY_NULL); - - if (sf->sf_bulk_priv != BULK_PRIV_ALG_NULL || - sf->sf_bulk_csum != BULK_CSUM_ALG_NULL) { - CERROR("null sec don't support bulk algorithm: %u/%u\n", - sf->sf_bulk_priv, sf->sf_bulk_csum); - return NULL; - } + LASSERT(SPTLRPC_FLVR_POLICY(sf->sf_rpc) == SPTLRPC_POLICY_NULL); /* general layer has take a module reference for us, because we never * really destroy the sec, simply release the reference here. @@ -198,6 +204,9 @@ int null_alloc_repbuf(struct ptlrpc_sec *sec, struct ptlrpc_request *req, int msgsize) { + /* add space for early replied */ + msgsize += lustre_msg_early_size(); + msgsize = size_roundup_power2(msgsize); OBD_ALLOC(req->rq_repbuf, msgsize); @@ -212,6 +221,8 @@ static void null_free_repbuf(struct ptlrpc_sec *sec, struct ptlrpc_request *req) { + LASSERT(req->rq_repbuf); + OBD_FREE(req->rq_repbuf, req->rq_repbuf_len); req->rq_repbuf = NULL; req->rq_repbuf_len = 0; @@ -262,10 +273,16 @@ int null_enlarge_reqbuf(struct ptlrpc_sec *sec, return 0; } +static struct ptlrpc_svc_ctx null_svc_ctx = { + .sc_refcount = ATOMIC_INIT(1), + .sc_policy = &null_policy, +}; + static int null_accept(struct ptlrpc_request *req) { - LASSERT(RPC_FLVR_POLICY(req->rq_flvr.sf_rpc) == SPTLRPC_POLICY_NULL); + LASSERT(SPTLRPC_FLVR_POLICY(req->rq_flvr.sf_rpc) == + SPTLRPC_POLICY_NULL); if (req->rq_flvr.sf_rpc != SPTLRPC_FLVR_NULL) { CERROR("Invalid rpc flavor 0x%x\n", req->rq_flvr.sf_rpc); @@ -331,12 +348,30 @@ int null_authorize(struct ptlrpc_request *req) struct ptlrpc_reply_state *rs = req->rq_reply_state; LASSERT(rs); - if (rs->rs_repbuf->lm_magic != LUSTRE_MSG_MAGIC_V1) - rs->rs_repbuf->lm_secflvr = SPTLRPC_FLVR_NULL; + + rs->rs_repbuf->lm_secflvr = SPTLRPC_FLVR_NULL; rs->rs_repdata_len = req->rq_replen; + + if (likely(req->rq_packed_final)) { + if (lustre_msghdr_get_flags(req->rq_reqmsg) & MSGHDR_AT_SUPPORT) + req->rq_reply_off = lustre_msg_early_size(); + else + req->rq_reply_off = 0; + } else { + lustre_msg_set_cksum(rs->rs_repbuf, + lustre_msg_calc_cksum(rs->rs_repbuf)); + req->rq_reply_off = 0; + } + return 0; } +static struct ptlrpc_ctx_ops null_ctx_ops = { + .refresh = null_ctx_refresh, + .sign = null_ctx_sign, + .verify = null_ctx_verify, +}; + static struct ptlrpc_sec_cops null_sec_cops = { .create_sec = null_create_sec, .destroy_sec = null_destroy_sec, @@ -364,8 +399,7 @@ static struct ptlrpc_sec_policy null_policy = { .sp_sops = &null_sec_sops, }; -static -void null_init_internal(void) +static void null_init_internal(void) { static HLIST_HEAD(__list); @@ -374,14 +408,12 @@ void null_init_internal(void) null_sec.ps_id = -1; null_sec.ps_import = NULL; null_sec.ps_flvr.sf_rpc = SPTLRPC_FLVR_NULL; - null_sec.ps_flvr.sf_bulk_priv = BULK_PRIV_ALG_NULL; - null_sec.ps_flvr.sf_bulk_csum = BULK_CSUM_ALG_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" */ - INIT_LIST_HEAD(&null_sec.ps_gc_list); + CFS_INIT_LIST_HEAD(&null_sec.ps_gc_list); null_sec.ps_gc_interval = 0; null_sec.ps_gc_next = 0; @@ -394,8 +426,8 @@ void null_init_internal(void) PTLRPC_CTX_UPTODATE; null_cli_ctx.cc_vcred.vc_uid = 0; spin_lock_init(&null_cli_ctx.cc_lock); - INIT_LIST_HEAD(&null_cli_ctx.cc_req_list); - INIT_LIST_HEAD(&null_cli_ctx.cc_gc_chain); + CFS_INIT_LIST_HEAD(&null_cli_ctx.cc_req_list); + CFS_INIT_LIST_HEAD(&null_cli_ctx.cc_gc_chain); } int sptlrpc_null_init(void)