X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fptlrpc%2Fsec.c;h=a4289d3b57d8537d9c793803de01686bfba800e3;hp=360c7456f0945af9739b743c6542d0f616a82d15;hb=7dd6c394161a62b229ba65f50044a1d8f2da2d03;hpb=d510b34d4a90b25d0816787c5f8eb9a85893f172 diff --git a/lustre/ptlrpc/sec.c b/lustre/ptlrpc/sec.c index 360c745..a4289d3 100644 --- a/lustre/ptlrpc/sec.c +++ b/lustre/ptlrpc/sec.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. @@ -28,6 +26,8 @@ /* * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. + * + * Copyright (c) 2011, 2014, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -38,20 +38,16 @@ * Author: Eric Mei */ -#ifndef EXPORT_SYMTAB -#define EXPORT_SYMTAB -#endif #define DEBUG_SUBSYSTEM S_SEC -#include -#ifndef __KERNEL__ -#include -#include -#else +#include +#ifdef HAVE_UIDGID_HEADER +# include +#endif #include #include -#endif +#include #include #include #include @@ -66,7 +62,7 @@ * policy registers * ***********************************************/ -static cfs_rwlock_t policy_lock; +static rwlock_t policy_lock; static struct ptlrpc_sec_policy *policies[SPTLRPC_POLICY_MAX] = { NULL, }; @@ -82,13 +78,13 @@ int sptlrpc_register_policy(struct ptlrpc_sec_policy *policy) if (number >= SPTLRPC_POLICY_MAX) return -EINVAL; - cfs_write_lock(&policy_lock); + write_lock(&policy_lock); if (unlikely(policies[number])) { - cfs_write_unlock(&policy_lock); + write_unlock(&policy_lock); return -EALREADY; } policies[number] = policy; - cfs_write_unlock(&policy_lock); + write_unlock(&policy_lock); CDEBUG(D_SEC, "%s: registered\n", policy->sp_name); return 0; @@ -101,16 +97,16 @@ int sptlrpc_unregister_policy(struct ptlrpc_sec_policy *policy) LASSERT(number < SPTLRPC_POLICY_MAX); - cfs_write_lock(&policy_lock); + write_lock(&policy_lock); if (unlikely(policies[number] == NULL)) { - cfs_write_unlock(&policy_lock); + write_unlock(&policy_lock); CERROR("%s: already unregistered\n", policy->sp_name); return -EINVAL; } LASSERT(policies[number] == policy); policies[number] = NULL; - cfs_write_unlock(&policy_lock); + write_unlock(&policy_lock); CDEBUG(D_SEC, "%s: unregistered\n", policy->sp_name); return 0; @@ -120,50 +116,53 @@ EXPORT_SYMBOL(sptlrpc_unregister_policy); static struct ptlrpc_sec_policy * sptlrpc_wireflavor2policy(__u32 flavor) { - static CFS_DECLARE_MUTEX(load_mutex); - static cfs_atomic_t loaded = CFS_ATOMIC_INIT(0); - struct ptlrpc_sec_policy *policy; - __u16 number = SPTLRPC_FLVR_POLICY(flavor); - __u16 flag = 0; - - if (number >= SPTLRPC_POLICY_MAX) - return NULL; - - while (1) { - cfs_read_lock(&policy_lock); - policy = policies[number]; - if (policy && !cfs_try_module_get(policy->sp_owner)) - policy = NULL; - if (policy == NULL) - flag = cfs_atomic_read(&loaded); - cfs_read_unlock(&policy_lock); - - if (policy != NULL || flag != 0 || - number != SPTLRPC_POLICY_GSS) - break; - - /* try to load gss module, once */ - cfs_mutex_down(&load_mutex); - if (cfs_atomic_read(&loaded) == 0) { - if (cfs_request_module("ptlrpc_gss") == 0) - CWARN("module ptlrpc_gss loaded on demand\n"); - else - CERROR("Unable to load module ptlrpc_gss\n"); - - cfs_atomic_set(&loaded, 1); - } - cfs_mutex_up(&load_mutex); - } - - return policy; + static DEFINE_MUTEX(load_mutex); + static atomic_t loaded = ATOMIC_INIT(0); + struct ptlrpc_sec_policy *policy; + __u16 number = SPTLRPC_FLVR_POLICY(flavor); + __u16 flag = 0; + + if (number >= SPTLRPC_POLICY_MAX) + return NULL; + + while (1) { + read_lock(&policy_lock); + policy = policies[number]; + if (policy && !try_module_get(policy->sp_owner)) + policy = NULL; + if (policy == NULL) + flag = atomic_read(&loaded); + read_unlock(&policy_lock); + + if (policy != NULL || flag != 0 || + number != SPTLRPC_POLICY_GSS) + break; + + /* try to load gss module, once */ + mutex_lock(&load_mutex); + if (atomic_read(&loaded) == 0) { + if (request_module("ptlrpc_gss") == 0) + CDEBUG(D_SEC, + "module ptlrpc_gss loaded on demand\n"); + else + CERROR("Unable to load module ptlrpc_gss\n"); + + atomic_set(&loaded, 1); + } + mutex_unlock(&load_mutex); + } + + return policy; } __u32 sptlrpc_name2flavor_base(const char *name) { - if (!strcmp(name, "null")) - return SPTLRPC_FLVR_NULL; - if (!strcmp(name, "plain")) - return SPTLRPC_FLVR_PLAIN; + if (!strcmp(name, "null")) + return SPTLRPC_FLVR_NULL; + if (!strcmp(name, "plain")) + return SPTLRPC_FLVR_PLAIN; + if (!strcmp(name, "gssnull")) + return SPTLRPC_FLVR_GSSNULL; if (!strcmp(name, "krb5n")) return SPTLRPC_FLVR_KRB5N; if (!strcmp(name, "krb5a")) @@ -172,8 +171,16 @@ __u32 sptlrpc_name2flavor_base(const char *name) return SPTLRPC_FLVR_KRB5I; if (!strcmp(name, "krb5p")) return SPTLRPC_FLVR_KRB5P; + if (!strcmp(name, "skn")) + return SPTLRPC_FLVR_SKN; + if (!strcmp(name, "ska")) + return SPTLRPC_FLVR_SKA; + if (!strcmp(name, "ski")) + return SPTLRPC_FLVR_SKI; + if (!strcmp(name, "skpi")) + return SPTLRPC_FLVR_SKPI; - return SPTLRPC_FLVR_INVALID; + return SPTLRPC_FLVR_INVALID; } EXPORT_SYMBOL(sptlrpc_name2flavor_base); @@ -185,6 +192,8 @@ const char *sptlrpc_flavor2name_base(__u32 flvr) return "null"; else if (base == SPTLRPC_FLVR_BASE(SPTLRPC_FLVR_PLAIN)) return "plain"; + else if (base == SPTLRPC_FLVR_BASE(SPTLRPC_FLVR_GSSNULL)) + return "gssnull"; else if (base == SPTLRPC_FLVR_BASE(SPTLRPC_FLVR_KRB5N)) return "krb5n"; else if (base == SPTLRPC_FLVR_BASE(SPTLRPC_FLVR_KRB5A)) @@ -193,9 +202,17 @@ const char *sptlrpc_flavor2name_base(__u32 flvr) return "krb5i"; else if (base == SPTLRPC_FLVR_BASE(SPTLRPC_FLVR_KRB5P)) return "krb5p"; - - CERROR("invalid wire flavor 0x%x\n", flvr); - return "invalid"; + else if (base == SPTLRPC_FLVR_BASE(SPTLRPC_FLVR_SKN)) + return "skn"; + else if (base == SPTLRPC_FLVR_BASE(SPTLRPC_FLVR_SKA)) + return "ska"; + else if (base == SPTLRPC_FLVR_BASE(SPTLRPC_FLVR_SKI)) + return "ski"; + else if (base == SPTLRPC_FLVR_BASE(SPTLRPC_FLVR_SKPI)) + return "skpi"; + + CERROR("invalid wire flavor 0x%x\n", flvr); + return "invalid"; } EXPORT_SYMBOL(sptlrpc_flavor2name_base); @@ -237,21 +254,20 @@ EXPORT_SYMBOL(sptlrpc_flavor2name); char *sptlrpc_secflags2str(__u32 flags, char *buf, int bufsize) { - buf[0] = '\0'; + buf[0] = '\0'; - if (flags & PTLRPC_SEC_FL_REVERSE) - strncat(buf, "reverse,", bufsize); - if (flags & PTLRPC_SEC_FL_ROOTONLY) - strncat(buf, "rootonly,", bufsize); - if (flags & PTLRPC_SEC_FL_UDESC) - strncat(buf, "udesc,", bufsize); - if (flags & PTLRPC_SEC_FL_BULK) - strncat(buf, "bulk,", bufsize); - if (buf[0] == '\0') - strncat(buf, "-,", bufsize); + if (flags & PTLRPC_SEC_FL_REVERSE) + strlcat(buf, "reverse,", bufsize); + if (flags & PTLRPC_SEC_FL_ROOTONLY) + strlcat(buf, "rootonly,", bufsize); + if (flags & PTLRPC_SEC_FL_UDESC) + strlcat(buf, "udesc,", bufsize); + if (flags & PTLRPC_SEC_FL_BULK) + strlcat(buf, "bulk,", bufsize); + if (buf[0] == '\0') + strlcat(buf, "-,", bufsize); - buf[bufsize - 1] = '\0'; - return buf; + return buf; } EXPORT_SYMBOL(sptlrpc_secflags2str); @@ -276,33 +292,33 @@ struct ptlrpc_cli_ctx *get_my_ctx(struct ptlrpc_sec *sec) create = 0; remove_dead = 0; } - } else { - vcred.vc_uid = cfs_curproc_uid(); - vcred.vc_gid = cfs_curproc_gid(); - } + } else { + vcred.vc_uid = from_kuid(&init_user_ns, current_uid()); + vcred.vc_gid = from_kgid(&init_user_ns, current_gid()); + } - return sec->ps_policy->sp_cops->lookup_ctx(sec, &vcred, - create, remove_dead); + return sec->ps_policy->sp_cops->lookup_ctx(sec, &vcred, create, + remove_dead); } struct ptlrpc_cli_ctx *sptlrpc_cli_ctx_get(struct ptlrpc_cli_ctx *ctx) { - cfs_atomic_inc(&ctx->cc_refcount); - return ctx; + atomic_inc(&ctx->cc_refcount); + return ctx; } EXPORT_SYMBOL(sptlrpc_cli_ctx_get); void sptlrpc_cli_ctx_put(struct ptlrpc_cli_ctx *ctx, int sync) { - struct ptlrpc_sec *sec = ctx->cc_sec; + struct ptlrpc_sec *sec = ctx->cc_sec; - LASSERT(sec); - LASSERT_ATOMIC_POS(&ctx->cc_refcount); + LASSERT(sec); + LASSERT_ATOMIC_POS(&ctx->cc_refcount); - if (!cfs_atomic_dec_and_test(&ctx->cc_refcount)) - return; + if (!atomic_dec_and_test(&ctx->cc_refcount)) + return; - sec->ps_policy->sp_cops->release_ctx(sec, ctx, sync); + sec->ps_policy->sp_cops->release_ctx(sec, ctx, sync); } EXPORT_SYMBOL(sptlrpc_cli_ctx_put); @@ -324,15 +340,15 @@ EXPORT_SYMBOL(sptlrpc_cli_ctx_expire); */ void sptlrpc_cli_ctx_wakeup(struct ptlrpc_cli_ctx *ctx) { - struct ptlrpc_request *req, *next; + struct ptlrpc_request *req, *next; - cfs_spin_lock(&ctx->cc_lock); - cfs_list_for_each_entry_safe(req, next, &ctx->cc_req_list, - rq_ctx_chain) { - cfs_list_del_init(&req->rq_ctx_chain); - ptlrpc_client_wake_req(req); - } - cfs_spin_unlock(&ctx->cc_lock); + spin_lock(&ctx->cc_lock); + list_for_each_entry_safe(req, next, &ctx->cc_req_list, + rq_ctx_chain) { + list_del_init(&req->rq_ctx_chain); + ptlrpc_client_wake_req(req); + } + spin_unlock(&ctx->cc_lock); } EXPORT_SYMBOL(sptlrpc_cli_ctx_wakeup); @@ -348,52 +364,67 @@ int sptlrpc_cli_ctx_display(struct ptlrpc_cli_ctx *ctx, char *buf, int bufsize) static int import_sec_check_expire(struct obd_import *imp) { - int adapt = 0; + int adapt = 0; - cfs_spin_lock(&imp->imp_lock); - if (imp->imp_sec_expire && - imp->imp_sec_expire < cfs_time_current_sec()) { - adapt = 1; - imp->imp_sec_expire = 0; - } - cfs_spin_unlock(&imp->imp_lock); + spin_lock(&imp->imp_lock); + if (imp->imp_sec_expire && + imp->imp_sec_expire < cfs_time_current_sec()) { + adapt = 1; + imp->imp_sec_expire = 0; + } + spin_unlock(&imp->imp_lock); if (!adapt) return 0; CDEBUG(D_SEC, "found delayed sec adapt expired, do it now\n"); - return sptlrpc_import_sec_adapt(imp, NULL, 0); + return sptlrpc_import_sec_adapt(imp, NULL, NULL); } +/** + * Get and validate the client side ptlrpc security facilities from + * \a imp. There is a race condition on client reconnect when the import is + * being destroyed while there are outstanding client bound requests. In + * this case do not output any error messages if import secuity is not + * found. + * + * \param[in] imp obd import associated with client + * \param[out] sec client side ptlrpc security + * + * \retval 0 if security retrieved successfully + * \retval -ve errno if there was a problem + */ static int import_sec_validate_get(struct obd_import *imp, - struct ptlrpc_sec **sec) + struct ptlrpc_sec **sec) { - int rc; + int rc; - if (unlikely(imp->imp_sec_expire)) { - rc = import_sec_check_expire(imp); - if (rc) - return rc; - } + if (unlikely(imp->imp_sec_expire)) { + rc = import_sec_check_expire(imp); + if (rc) + return rc; + } - *sec = sptlrpc_import_sec_ref(imp); - if (*sec == NULL) { - CERROR("import %p (%s) with no sec\n", - imp, ptlrpc_import_state_name(imp->imp_state)); - return -EACCES; - } + *sec = sptlrpc_import_sec_ref(imp); + /* Only output an error when the import is still active */ + if (*sec == NULL) { + if (list_empty(&imp->imp_zombie_chain)) + CERROR("import %p (%s) with no sec\n", + imp, ptlrpc_import_state_name(imp->imp_state)); + return -EACCES; + } - if (unlikely((*sec)->ps_dying)) { - CERROR("attempt to use dying sec %p\n", sec); - sptlrpc_sec_put(*sec); - return -EACCES; - } + if (unlikely((*sec)->ps_dying)) { + CERROR("attempt to use dying sec %p\n", sec); + sptlrpc_sec_put(*sec); + return -EACCES; + } - return 0; + return 0; } /** - * Given a \a req, find or allocate a appropriate context for it. + * Given a \a req, find or allocate an appropriate context for it. * \pre req->rq_cli_ctx == NULL. * * \retval 0 succeed, and req->rq_cli_ctx is set. @@ -417,10 +448,10 @@ int sptlrpc_req_get_ctx(struct ptlrpc_request *req) sptlrpc_sec_put(sec); - if (!req->rq_cli_ctx) { - CERROR("req %p: fail to get context\n", req); - RETURN(-ENOMEM); - } + if (!req->rq_cli_ctx) { + CERROR("req %p: fail to get context\n", req); + RETURN(-ECONNREFUSED); + } RETURN(0); } @@ -444,10 +475,10 @@ void sptlrpc_req_put_ctx(struct ptlrpc_request *req, int sync) /* request might be asked to release earlier while still * in the context waiting list. */ - if (!cfs_list_empty(&req->rq_ctx_chain)) { - cfs_spin_lock(&req->rq_cli_ctx->cc_lock); - cfs_list_del_init(&req->rq_ctx_chain); - cfs_spin_unlock(&req->rq_cli_ctx->cc_lock); + if (!list_empty(&req->rq_ctx_chain)) { + spin_lock(&req->rq_cli_ctx->cc_lock); + list_del_init(&req->rq_ctx_chain); + spin_unlock(&req->rq_cli_ctx->cc_lock); } sptlrpc_cli_ctx_put(req->rq_cli_ctx, sync); @@ -469,12 +500,12 @@ int sptlrpc_req_ctx_switch(struct ptlrpc_request *req, LASSERT(req->rq_reqlen); LASSERT(req->rq_replen); - CWARN("req %p: switch ctx %p(%u->%s) -> %p(%u->%s), " - "switch sec %p(%s) -> %p(%s)\n", req, - oldctx, oldctx->cc_vcred.vc_uid, sec2target_str(oldctx->cc_sec), - newctx, newctx->cc_vcred.vc_uid, sec2target_str(newctx->cc_sec), - oldctx->cc_sec, oldctx->cc_sec->ps_policy->sp_name, - newctx->cc_sec, newctx->cc_sec->ps_policy->sp_name); + CDEBUG(D_SEC, "req %p: switch ctx %p(%u->%s) -> %p(%u->%s), " + "switch sec %p(%s) -> %p(%s)\n", req, + oldctx, oldctx->cc_vcred.vc_uid, sec2target_str(oldctx->cc_sec), + newctx, newctx->cc_vcred.vc_uid, sec2target_str(newctx->cc_sec), + oldctx->cc_sec, oldctx->cc_sec->ps_policy->sp_name, + newctx->cc_sec, newctx->cc_sec->ps_policy->sp_name); /* save flavor */ old_flvr = req->rq_flvr; @@ -547,17 +578,26 @@ int sptlrpc_req_replace_dead_ctx(struct ptlrpc_request *req) newctx = req->rq_cli_ctx; LASSERT(newctx); - if (unlikely(newctx == oldctx && - cfs_test_bit(PTLRPC_CTX_DEAD_BIT, &oldctx->cc_flags))) { + if (unlikely(newctx == oldctx && + test_bit(PTLRPC_CTX_DEAD_BIT, &oldctx->cc_flags))) { /* * still get the old dead ctx, usually means system too busy */ - CWARN("ctx (%p, fl %lx) doesn't switch, relax a little bit\n", - newctx, newctx->cc_flags); - - cfs_schedule_timeout_and_set_state(CFS_TASK_INTERRUPTIBLE, - CFS_HZ); - } else { + CDEBUG(D_SEC, + "ctx (%p, fl %lx) doesn't switch, relax a little bit\n", + newctx, newctx->cc_flags); + + set_current_state(TASK_INTERRUPTIBLE); + schedule_timeout(msecs_to_jiffies(MSEC_PER_SEC)); + } else if (unlikely(test_bit(PTLRPC_CTX_UPTODATE_BIT, &newctx->cc_flags) + == 0)) { + /* + * new ctx not up to date yet + */ + CDEBUG(D_SEC, + "ctx (%p, fl %lx) doesn't switch, not up to date yet\n", + newctx, newctx->cc_flags); + } else { /* * it's possible newctx == oldctx if we're switching * subflavor with the same sec. @@ -610,20 +650,20 @@ int ctx_refresh_timeout(void *data) static void ctx_refresh_interrupt(void *data) { - struct ptlrpc_request *req = data; + struct ptlrpc_request *req = data; - cfs_spin_lock(&req->rq_lock); - req->rq_intr = 1; - cfs_spin_unlock(&req->rq_lock); + spin_lock(&req->rq_lock); + req->rq_intr = 1; + spin_unlock(&req->rq_lock); } static void req_off_ctx_list(struct ptlrpc_request *req, struct ptlrpc_cli_ctx *ctx) { - cfs_spin_lock(&ctx->cc_lock); - if (!cfs_list_empty(&req->rq_ctx_chain)) - cfs_list_del_init(&req->rq_ctx_chain); - cfs_spin_unlock(&ctx->cc_lock); + spin_lock(&ctx->cc_lock); + if (!list_empty(&req->rq_ctx_chain)) + list_del_init(&req->rq_ctx_chain); + spin_unlock(&ctx->cc_lock); } /** @@ -675,11 +715,11 @@ again: if (cli_ctx_is_eternal(ctx)) RETURN(0); - if (unlikely(cfs_test_bit(PTLRPC_CTX_NEW_BIT, &ctx->cc_flags))) { + if (unlikely(test_bit(PTLRPC_CTX_NEW_BIT, &ctx->cc_flags))) { LASSERT(ctx->cc_ops->refresh); ctx->cc_ops->refresh(ctx); } - LASSERT(cfs_test_bit(PTLRPC_CTX_NEW_BIT, &ctx->cc_flags) == 0); + LASSERT(test_bit(PTLRPC_CTX_NEW_BIT, &ctx->cc_flags) == 0); LASSERT(ctx->cc_ops->validate); if (ctx->cc_ops->validate(ctx) == 0) { @@ -687,10 +727,10 @@ again: RETURN(0); } - if (unlikely(cfs_test_bit(PTLRPC_CTX_ERROR_BIT, &ctx->cc_flags))) { - cfs_spin_lock(&req->rq_lock); - req->rq_err = 1; - cfs_spin_unlock(&req->rq_lock); + if (unlikely(test_bit(PTLRPC_CTX_ERROR_BIT, &ctx->cc_flags))) { + spin_lock(&req->rq_lock); + req->rq_err = 1; + spin_unlock(&req->rq_lock); req_off_ctx_list(req, ctx); RETURN(-EPERM); } @@ -712,43 +752,43 @@ again: * it for reply reconstruction. * * Commonly the original context should be uptodate because we - * have a expiry nice time; server will keep its context because + * have an expiry nice time; server will keep its context because * we at least hold a ref of old context which prevent context - * destroying RPC being sent. So server still can accept the request - * and finish the RPC. But if that's not the case: + * from destroying RPC being sent. So server still can accept the + * request and finish the RPC. But if that's not the case: * 1. If server side context has been trimmed, a NO_CONTEXT will * be returned, gss_cli_ctx_verify/unseal will switch to new * context by force. * 2. Current context never be refreshed, then we are fine: we * never really send request with old context before. */ - if (cfs_test_bit(PTLRPC_CTX_UPTODATE_BIT, &ctx->cc_flags) && - unlikely(req->rq_reqmsg) && - lustre_msg_get_flags(req->rq_reqmsg) & MSG_RESENT) { - req_off_ctx_list(req, ctx); - RETURN(0); - } - - if (unlikely(cfs_test_bit(PTLRPC_CTX_DEAD_BIT, &ctx->cc_flags))) { - req_off_ctx_list(req, ctx); - /* - * don't switch ctx if import was deactivated - */ - if (req->rq_import->imp_deactive) { - cfs_spin_lock(&req->rq_lock); - req->rq_err = 1; - cfs_spin_unlock(&req->rq_lock); - RETURN(-EINTR); - } - - rc = sptlrpc_req_replace_dead_ctx(req); - if (rc) { - LASSERT(ctx == req->rq_cli_ctx); - CERROR("req %p: failed to replace dead ctx %p: %d\n", - req, ctx, rc); - cfs_spin_lock(&req->rq_lock); - req->rq_err = 1; - cfs_spin_unlock(&req->rq_lock); + if (test_bit(PTLRPC_CTX_UPTODATE_BIT, &ctx->cc_flags) && + unlikely(req->rq_reqmsg) && + lustre_msg_get_flags(req->rq_reqmsg) & MSG_RESENT) { + req_off_ctx_list(req, ctx); + RETURN(0); + } + + if (unlikely(test_bit(PTLRPC_CTX_DEAD_BIT, &ctx->cc_flags))) { + req_off_ctx_list(req, ctx); + /* + * don't switch ctx if import was deactivated + */ + if (req->rq_import->imp_deactive) { + spin_lock(&req->rq_lock); + req->rq_err = 1; + spin_unlock(&req->rq_lock); + RETURN(-EINTR); + } + + rc = sptlrpc_req_replace_dead_ctx(req); + if (rc) { + LASSERT(ctx == req->rq_cli_ctx); + CERROR("req %p: failed to replace dead ctx %p: %d\n", + req, ctx, rc); + spin_lock(&req->rq_lock); + req->rq_err = 1; + spin_unlock(&req->rq_lock); RETURN(rc); } @@ -760,26 +800,27 @@ again: * Now we're sure this context is during upcall, add myself into * waiting list */ - cfs_spin_lock(&ctx->cc_lock); - if (cfs_list_empty(&req->rq_ctx_chain)) - cfs_list_add(&req->rq_ctx_chain, &ctx->cc_req_list); - cfs_spin_unlock(&ctx->cc_lock); - - if (timeout < 0) - RETURN(-EWOULDBLOCK); - - /* Clear any flags that may be present from previous sends */ - LASSERT(req->rq_receiving_reply == 0); - cfs_spin_lock(&req->rq_lock); - req->rq_err = 0; - req->rq_timedout = 0; - req->rq_resend = 0; - req->rq_restart = 0; - cfs_spin_unlock(&req->rq_lock); - - lwi = LWI_TIMEOUT_INTR(timeout * CFS_HZ, ctx_refresh_timeout, - ctx_refresh_interrupt, req); - rc = l_wait_event(req->rq_reply_waitq, ctx_check_refresh(ctx), &lwi); + spin_lock(&ctx->cc_lock); + if (list_empty(&req->rq_ctx_chain)) + list_add(&req->rq_ctx_chain, &ctx->cc_req_list); + spin_unlock(&ctx->cc_lock); + + if (timeout < 0) + RETURN(-EWOULDBLOCK); + + /* Clear any flags that may be present from previous sends */ + LASSERT(req->rq_receiving_reply == 0); + spin_lock(&req->rq_lock); + req->rq_err = 0; + req->rq_timedout = 0; + req->rq_resend = 0; + req->rq_restart = 0; + spin_unlock(&req->rq_lock); + + lwi = LWI_TIMEOUT_INTR(msecs_to_jiffies(timeout * MSEC_PER_SEC), + ctx_refresh_timeout, + ctx_refresh_interrupt, req); + rc = l_wait_event(req->rq_reply_waitq, ctx_check_refresh(ctx), &lwi); /* * following cases could lead us here: @@ -818,11 +859,12 @@ void sptlrpc_req_set_flavor(struct ptlrpc_request *req, int opcode) LASSERT(req->rq_cli_ctx->cc_sec); LASSERT(req->rq_bulk_read == 0 || req->rq_bulk_write == 0); - /* special security flags accoding to opcode */ + /* special security flags according to opcode */ switch (opcode) { case OST_READ: case MDS_READPAGE: case MGS_CONFIG_READ: + case OBD_IDX_READ: req->rq_bulk_read = 1; break; case OST_WRITE: @@ -848,9 +890,9 @@ void sptlrpc_req_set_flavor(struct ptlrpc_request *req, int opcode) sec = req->rq_cli_ctx->cc_sec; - cfs_spin_lock(&sec->ps_lock); - req->rq_flvr = sec->ps_flvr; - cfs_spin_unlock(&sec->ps_lock); + spin_lock(&sec->ps_lock); + req->rq_flvr = sec->ps_flvr; + spin_unlock(&sec->ps_lock); /* force SVC_NULL for context initiation rpc, SVC_INTG for context * destruction rpc */ @@ -891,17 +933,17 @@ void sptlrpc_request_out_callback(struct ptlrpc_request *req) */ int sptlrpc_import_check_ctx(struct obd_import *imp) { - struct ptlrpc_sec *sec; - struct ptlrpc_cli_ctx *ctx; - struct ptlrpc_request *req = NULL; - int rc; - ENTRY; + struct ptlrpc_sec *sec; + struct ptlrpc_cli_ctx *ctx; + struct ptlrpc_request *req = NULL; + int rc; + ENTRY; - cfs_might_sleep(); + might_sleep(); - sec = sptlrpc_import_sec_ref(imp); - ctx = get_my_ctx(sec); - sptlrpc_sec_put(sec); + sec = sptlrpc_import_sec_ref(imp); + ctx = get_my_ctx(sec); + sptlrpc_sec_put(sec); if (!ctx) RETURN(-ENOMEM); @@ -917,25 +959,23 @@ int sptlrpc_import_check_ctx(struct obd_import *imp) RETURN(-EACCES); } - OBD_ALLOC_PTR(req); - if (!req) - RETURN(-ENOMEM); + req = ptlrpc_request_cache_alloc(GFP_NOFS); + if (!req) + RETURN(-ENOMEM); - cfs_spin_lock_init(&req->rq_lock); - cfs_atomic_set(&req->rq_refcount, 10000); - CFS_INIT_LIST_HEAD(&req->rq_ctx_chain); - cfs_waitq_init(&req->rq_reply_waitq); - cfs_waitq_init(&req->rq_set_waitq); - req->rq_import = imp; - req->rq_flvr = sec->ps_flvr; - req->rq_cli_ctx = ctx; + ptlrpc_cli_req_init(req); + atomic_set(&req->rq_refcount, 10000); + + req->rq_import = imp; + req->rq_flvr = sec->ps_flvr; + req->rq_cli_ctx = ctx; rc = sptlrpc_req_refresh_ctx(req, 0); - LASSERT(cfs_list_empty(&req->rq_ctx_chain)); + LASSERT(list_empty(&req->rq_ctx_chain)); sptlrpc_cli_ctx_put(req->rq_cli_ctx, 1); - OBD_FREE_PTR(req); + ptlrpc_request_cache_free(req); - RETURN(rc); + RETURN(rc); } /** @@ -1089,68 +1129,69 @@ int sptlrpc_cli_unwrap_reply(struct ptlrpc_request *req) * changed at any time, no matter we're holding rq_lock or not. For this reason * we allocate a separate ptlrpc_request and reply buffer for early reply * processing. - * + * * \retval 0 success, \a req_ret is filled with a duplicated ptlrpc_request. * Later the caller must call sptlrpc_cli_finish_early_reply() on the returned * \a *req_ret to release it. * \retval -ev error number, and \a req_ret will not be set. */ int sptlrpc_cli_unwrap_early_reply(struct ptlrpc_request *req, - struct ptlrpc_request **req_ret) -{ - struct ptlrpc_request *early_req; - char *early_buf; - int early_bufsz, early_size; - int rc; - ENTRY; - - OBD_ALLOC_PTR(early_req); - if (early_req == NULL) - RETURN(-ENOMEM); - - early_size = req->rq_nob_received; - early_bufsz = size_roundup_power2(early_size); - OBD_ALLOC_LARGE(early_buf, early_bufsz); - if (early_buf == NULL) - GOTO(err_req, rc = -ENOMEM); + struct ptlrpc_request **req_ret) +{ + struct ptlrpc_request *early_req; + char *early_buf; + int early_bufsz, early_size; + int rc; + ENTRY; + + early_req = ptlrpc_request_cache_alloc(GFP_NOFS); + if (early_req == NULL) + RETURN(-ENOMEM); + + ptlrpc_cli_req_init(early_req); + + early_size = req->rq_nob_received; + early_bufsz = size_roundup_power2(early_size); + OBD_ALLOC_LARGE(early_buf, early_bufsz); + if (early_buf == NULL) + GOTO(err_req, rc = -ENOMEM); + + /* sanity checkings and copy data out, do it inside spinlock */ + spin_lock(&req->rq_lock); + + if (req->rq_replied) { + spin_unlock(&req->rq_lock); + GOTO(err_buf, rc = -EALREADY); + } + + LASSERT(req->rq_repbuf); + LASSERT(req->rq_repdata == NULL); + LASSERT(req->rq_repmsg == NULL); + + if (req->rq_reply_off != 0) { + CERROR("early reply with offset %u\n", req->rq_reply_off); + spin_unlock(&req->rq_lock); + GOTO(err_buf, rc = -EPROTO); + } + + if (req->rq_nob_received != early_size) { + /* even another early arrived the size should be the same */ + CERROR("data size has changed from %u to %u\n", + early_size, req->rq_nob_received); + spin_unlock(&req->rq_lock); + GOTO(err_buf, rc = -EINVAL); + } + + if (req->rq_nob_received < sizeof(struct lustre_msg)) { + CERROR("early reply length %d too small\n", + req->rq_nob_received); + spin_unlock(&req->rq_lock); + GOTO(err_buf, rc = -EALREADY); + } + + memcpy(early_buf, req->rq_repbuf, early_size); + spin_unlock(&req->rq_lock); - /* sanity checkings and copy data out, do it inside spinlock */ - cfs_spin_lock(&req->rq_lock); - - if (req->rq_replied) { - cfs_spin_unlock(&req->rq_lock); - GOTO(err_buf, rc = -EALREADY); - } - - LASSERT(req->rq_repbuf); - LASSERT(req->rq_repdata == NULL); - LASSERT(req->rq_repmsg == NULL); - - if (req->rq_reply_off != 0) { - CERROR("early reply with offset %u\n", req->rq_reply_off); - cfs_spin_unlock(&req->rq_lock); - GOTO(err_buf, rc = -EPROTO); - } - - if (req->rq_nob_received != early_size) { - /* even another early arrived the size should be the same */ - CERROR("data size has changed from %u to %u\n", - early_size, req->rq_nob_received); - cfs_spin_unlock(&req->rq_lock); - GOTO(err_buf, rc = -EINVAL); - } - - if (req->rq_nob_received < sizeof(struct lustre_msg)) { - CERROR("early reply length %d too small\n", - req->rq_nob_received); - cfs_spin_unlock(&req->rq_lock); - GOTO(err_buf, rc = -EALREADY); - } - - memcpy(early_buf, req->rq_repbuf, early_size); - cfs_spin_unlock(&req->rq_lock); - - cfs_spin_lock_init(&early_req->rq_lock); early_req->rq_cli_ctx = sptlrpc_cli_ctx_get(req->rq_cli_ctx); early_req->rq_flvr = req->rq_flvr; early_req->rq_repbuf = early_buf; @@ -1176,8 +1217,8 @@ err_ctx: err_buf: OBD_FREE_LARGE(early_buf, early_bufsz); err_req: - OBD_FREE_PTR(early_req); - RETURN(rc); + ptlrpc_request_cache_free(early_req); + RETURN(rc); } /** @@ -1187,13 +1228,13 @@ err_req: */ void sptlrpc_cli_finish_early_reply(struct ptlrpc_request *early_req) { - LASSERT(early_req->rq_repbuf); - LASSERT(early_req->rq_repdata); - LASSERT(early_req->rq_repmsg); + LASSERT(early_req->rq_repbuf); + LASSERT(early_req->rq_repdata); + LASSERT(early_req->rq_repmsg); - sptlrpc_cli_ctx_put(early_req->rq_cli_ctx, 1); - OBD_FREE_LARGE(early_req->rq_repbuf, early_req->rq_repbuf_len); - OBD_FREE_PTR(early_req); + sptlrpc_cli_ctx_put(early_req->rq_cli_ctx, 1); + OBD_FREE_LARGE(early_req->rq_repbuf, early_req->rq_repbuf_len); + ptlrpc_request_cache_free(early_req); } /************************************************** @@ -1203,11 +1244,11 @@ void sptlrpc_cli_finish_early_reply(struct ptlrpc_request *early_req) /* * "fixed" sec (e.g. null) use sec_id < 0 */ -static cfs_atomic_t sptlrpc_sec_id = CFS_ATOMIC_INIT(1); +static atomic_t sptlrpc_sec_id = ATOMIC_INIT(1); int sptlrpc_get_next_secid(void) { - return cfs_atomic_inc_return(&sptlrpc_sec_id); + return atomic_inc_return(&sptlrpc_sec_id); } EXPORT_SYMBOL(sptlrpc_get_next_secid); @@ -1259,23 +1300,23 @@ static void sptlrpc_sec_kill(struct ptlrpc_sec *sec) struct ptlrpc_sec *sptlrpc_sec_get(struct ptlrpc_sec *sec) { - if (sec) - cfs_atomic_inc(&sec->ps_refcount); + if (sec) + atomic_inc(&sec->ps_refcount); - return sec; + return sec; } EXPORT_SYMBOL(sptlrpc_sec_get); void sptlrpc_sec_put(struct ptlrpc_sec *sec) { - if (sec) { - LASSERT_ATOMIC_POS(&sec->ps_refcount); + if (sec) { + LASSERT_ATOMIC_POS(&sec->ps_refcount); - if (cfs_atomic_dec_and_test(&sec->ps_refcount)) { - sptlrpc_gc_del_sec(sec); - sec_cop_destroy_sec(sec); - } - } + if (atomic_dec_and_test(&sec->ps_refcount)) { + sptlrpc_gc_del_sec(sec); + sec_cop_destroy_sec(sec); + } + } } EXPORT_SYMBOL(sptlrpc_sec_put); @@ -1318,44 +1359,44 @@ struct ptlrpc_sec * sptlrpc_sec_create(struct obd_import *imp, } } - sec = policy->sp_cops->create_sec(imp, svc_ctx, sf); - if (sec) { - cfs_atomic_inc(&sec->ps_refcount); + sec = policy->sp_cops->create_sec(imp, svc_ctx, sf); + if (sec) { + atomic_inc(&sec->ps_refcount); - sec->ps_part = sp; + sec->ps_part = sp; - if (sec->ps_gc_interval && policy->sp_cops->gc_ctx) - sptlrpc_gc_add_sec(sec); - } else { - sptlrpc_policy_put(policy); - } + if (sec->ps_gc_interval && policy->sp_cops->gc_ctx) + sptlrpc_gc_add_sec(sec); + } else { + sptlrpc_policy_put(policy); + } - RETURN(sec); + RETURN(sec); } struct ptlrpc_sec *sptlrpc_import_sec_ref(struct obd_import *imp) { - struct ptlrpc_sec *sec; + struct ptlrpc_sec *sec; - cfs_spin_lock(&imp->imp_lock); - sec = sptlrpc_sec_get(imp->imp_sec); - cfs_spin_unlock(&imp->imp_lock); + spin_lock(&imp->imp_lock); + sec = sptlrpc_sec_get(imp->imp_sec); + spin_unlock(&imp->imp_lock); - return sec; + return sec; } EXPORT_SYMBOL(sptlrpc_import_sec_ref); static void sptlrpc_import_sec_install(struct obd_import *imp, struct ptlrpc_sec *sec) { - struct ptlrpc_sec *old_sec; + struct ptlrpc_sec *old_sec; - LASSERT_ATOMIC_POS(&sec->ps_refcount); + LASSERT_ATOMIC_POS(&sec->ps_refcount); - cfs_spin_lock(&imp->imp_lock); - old_sec = imp->imp_sec; - imp->imp_sec = sec; - cfs_spin_unlock(&imp->imp_lock); + spin_lock(&imp->imp_lock); + old_sec = imp->imp_sec; + imp->imp_sec = sec; + spin_unlock(&imp->imp_lock); if (old_sec) { sptlrpc_sec_kill(old_sec); @@ -1377,24 +1418,6 @@ void flavor_copy(struct sptlrpc_flavor *dst, struct sptlrpc_flavor *src) *dst = *src; } -static void sptlrpc_import_sec_adapt_inplace(struct obd_import *imp, - struct ptlrpc_sec *sec, - struct sptlrpc_flavor *sf) -{ - char str1[32], str2[32]; - - if (sec->ps_flvr.sf_flags != sf->sf_flags) - CWARN("changing sec flags: %s -> %s\n", - sptlrpc_secflags2str(sec->ps_flvr.sf_flags, - str1, sizeof(str1)), - sptlrpc_secflags2str(sf->sf_flags, - str2, sizeof(str2))); - - cfs_spin_lock(&sec->ps_lock); - flavor_copy(&sec->ps_flvr, sf); - cfs_spin_unlock(&sec->ps_lock); -} - /** * To get an appropriate ptlrpc_sec for the \a imp, according to the current * configuration. Upon called, imp->imp_sec may or may not be NULL. @@ -1406,20 +1429,20 @@ int sptlrpc_import_sec_adapt(struct obd_import *imp, struct ptlrpc_svc_ctx *svc_ctx, struct sptlrpc_flavor *flvr) { - struct ptlrpc_connection *conn; - struct sptlrpc_flavor sf; - struct ptlrpc_sec *sec, *newsec; - enum lustre_sec_part sp; - char str[24]; - int rc = 0; - ENTRY; + struct ptlrpc_connection *conn; + struct sptlrpc_flavor sf; + struct ptlrpc_sec *sec, *newsec; + enum lustre_sec_part sp; + char str[24]; + int rc = 0; + ENTRY; - cfs_might_sleep(); + might_sleep(); - if (imp == NULL) - RETURN(0); + if (imp == NULL) + RETURN(0); - conn = imp->imp_connection; + conn = imp->imp_connection; if (svc_ctx == NULL) { struct client_obd *cliobd = &imp->imp_obd->u.cli; @@ -1454,29 +1477,21 @@ int sptlrpc_import_sec_adapt(struct obd_import *imp, if (flavor_equal(&sf, &sec->ps_flvr)) GOTO(out, rc); - CWARN("import %s->%s: changing flavor %s -> %s\n", - imp->imp_obd->obd_name, - obd_uuid2str(&conn->c_remote_uuid), - sptlrpc_flavor2name(&sec->ps_flvr, str, sizeof(str)), - sptlrpc_flavor2name(&sf, str2, sizeof(str2))); - - if (SPTLRPC_FLVR_POLICY(sf.sf_rpc) == - SPTLRPC_FLVR_POLICY(sec->ps_flvr.sf_rpc) && - SPTLRPC_FLVR_MECH(sf.sf_rpc) == - SPTLRPC_FLVR_MECH(sec->ps_flvr.sf_rpc)) { - sptlrpc_import_sec_adapt_inplace(imp, sec, &sf); - GOTO(out, rc); - } + CDEBUG(D_SEC, "import %s->%s: changing flavor %s -> %s\n", + imp->imp_obd->obd_name, + obd_uuid2str(&conn->c_remote_uuid), + sptlrpc_flavor2name(&sec->ps_flvr, str, sizeof(str)), + sptlrpc_flavor2name(&sf, str2, sizeof(str2))); } else if (SPTLRPC_FLVR_BASE(sf.sf_rpc) != SPTLRPC_FLVR_BASE(SPTLRPC_FLVR_NULL)) { - LCONSOLE_INFO("import %s->%s netid %x: select flavor %s\n", - imp->imp_obd->obd_name, - obd_uuid2str(&conn->c_remote_uuid), - LNET_NIDNET(conn->c_self), - sptlrpc_flavor2name(&sf, str, sizeof(str))); + CDEBUG(D_SEC, "import %s->%s netid %x: select flavor %s\n", + imp->imp_obd->obd_name, + obd_uuid2str(&conn->c_remote_uuid), + LNET_NIDNET(conn->c_self), + sptlrpc_flavor2name(&sf, str, sizeof(str))); } - cfs_mutex_down(&imp->imp_sec_mutex); + mutex_lock(&imp->imp_sec_mutex); newsec = sptlrpc_sec_create(imp, svc_ctx, &sf, sp); if (newsec) { @@ -1488,7 +1503,7 @@ int sptlrpc_import_sec_adapt(struct obd_import *imp, rc = -EPERM; } - cfs_mutex_up(&imp->imp_sec_mutex); + mutex_unlock(&imp->imp_sec_mutex); out: sptlrpc_sec_put(sec); RETURN(rc); @@ -1529,7 +1544,8 @@ void sptlrpc_import_flush_root_ctx(struct obd_import *imp) void sptlrpc_import_flush_my_ctx(struct obd_import *imp) { - import_flush_ctx_common(imp, cfs_curproc_uid(), 1, 1); + import_flush_ctx_common(imp, from_kuid(&init_user_ns, current_uid()), + 1, 1); } EXPORT_SYMBOL(sptlrpc_import_flush_my_ctx); @@ -1777,7 +1793,7 @@ int sptlrpc_target_export_check(struct obd_export *exp, if (req->rq_ctx_fini) return 0; - cfs_spin_lock(&exp->exp_lock); + spin_lock(&exp->exp_lock); /* if flavor just changed (exp->exp_flvr_changed != 0), we wait for * the first req with the new flavor, then treat it as current flavor, @@ -1807,16 +1823,16 @@ int sptlrpc_target_export_check(struct obd_export *exp, !(req->rq_ctx_init && (req->rq_auth_usr_root || req->rq_auth_usr_mdt || req->rq_auth_usr_ost))) { - cfs_spin_unlock(&exp->exp_lock); - CDEBUG(D_SEC, "is good but not root(%d:%d:%d:%d:%d)\n", - req->rq_auth_gss, req->rq_ctx_init, - req->rq_auth_usr_root, req->rq_auth_usr_mdt, - req->rq_auth_usr_ost); - return 0; - } + spin_unlock(&exp->exp_lock); + CDEBUG(D_SEC, "is good but not root(%d:%d:%d:%d:%d)\n", + req->rq_auth_gss, req->rq_ctx_init, + req->rq_auth_usr_root, req->rq_auth_usr_mdt, + req->rq_auth_usr_ost); + return 0; + } - exp->exp_flvr_adapt = 0; - cfs_spin_unlock(&exp->exp_lock); + exp->exp_flvr_adapt = 0; + spin_unlock(&exp->exp_lock); return sptlrpc_import_sec_adapt(exp->exp_imp_reverse, req->rq_svc_ctx, &flavor); @@ -1830,37 +1846,37 @@ int sptlrpc_target_export_check(struct obd_export *exp, if (!req->rq_auth_gss || !req->rq_ctx_init || (!req->rq_auth_usr_root && !req->rq_auth_usr_mdt && !req->rq_auth_usr_ost)) { - cfs_spin_unlock(&exp->exp_lock); - return 0; - } - - /* if flavor just changed, we should not proceed, just leave - * it and current flavor will be discovered and replaced - * shortly, and let _this_ rpc pass through */ - if (exp->exp_flvr_changed) { - LASSERT(exp->exp_flvr_adapt); - cfs_spin_unlock(&exp->exp_lock); - return 0; - } - - if (exp->exp_flvr_adapt) { - exp->exp_flvr_adapt = 0; - CDEBUG(D_SEC, "exp %p (%x|%x|%x): do delayed adapt\n", - exp, exp->exp_flvr.sf_rpc, - exp->exp_flvr_old[0].sf_rpc, - exp->exp_flvr_old[1].sf_rpc); - flavor = exp->exp_flvr; - cfs_spin_unlock(&exp->exp_lock); - - return sptlrpc_import_sec_adapt(exp->exp_imp_reverse, - req->rq_svc_ctx, - &flavor); - } else { - CDEBUG(D_SEC, "exp %p (%x|%x|%x): is current flavor, " - "install rvs ctx\n", exp, exp->exp_flvr.sf_rpc, - exp->exp_flvr_old[0].sf_rpc, - exp->exp_flvr_old[1].sf_rpc); - cfs_spin_unlock(&exp->exp_lock); + spin_unlock(&exp->exp_lock); + return 0; + } + + /* if flavor just changed, we should not proceed, just leave + * it and current flavor will be discovered and replaced + * shortly, and let _this_ rpc pass through */ + if (exp->exp_flvr_changed) { + LASSERT(exp->exp_flvr_adapt); + spin_unlock(&exp->exp_lock); + return 0; + } + + if (exp->exp_flvr_adapt) { + exp->exp_flvr_adapt = 0; + CDEBUG(D_SEC, "exp %p (%x|%x|%x): do delayed adapt\n", + exp, exp->exp_flvr.sf_rpc, + exp->exp_flvr_old[0].sf_rpc, + exp->exp_flvr_old[1].sf_rpc); + flavor = exp->exp_flvr; + spin_unlock(&exp->exp_lock); + + return sptlrpc_import_sec_adapt(exp->exp_imp_reverse, + req->rq_svc_ctx, + &flavor); + } else { + CDEBUG(D_SEC, "exp %p (%x|%x|%x): is current flavor, " + "install rvs ctx\n", exp, exp->exp_flvr.sf_rpc, + exp->exp_flvr_old[0].sf_rpc, + exp->exp_flvr_old[1].sf_rpc); + spin_unlock(&exp->exp_lock); return sptlrpc_svc_install_rvs_ctx(exp->exp_imp_reverse, req->rq_svc_ctx); @@ -1877,7 +1893,7 @@ int sptlrpc_target_export_check(struct obd_export *exp, exp->exp_flvr_old[1].sf_rpc, exp->exp_flvr_expire[0] - cfs_time_current_sec()); - cfs_spin_unlock(&exp->exp_lock); + spin_unlock(&exp->exp_lock); return 0; } } else { @@ -1902,7 +1918,7 @@ int sptlrpc_target_export_check(struct obd_export *exp, exp->exp_flvr_old[1].sf_rpc, exp->exp_flvr_expire[1] - cfs_time_current_sec()); - cfs_spin_unlock(&exp->exp_lock); + spin_unlock(&exp->exp_lock); return 0; } } else { @@ -1919,7 +1935,7 @@ int sptlrpc_target_export_check(struct obd_export *exp, exp->exp_flvr_old[1].sf_rpc); } - cfs_spin_unlock(&exp->exp_lock); + spin_unlock(&exp->exp_lock); CWARN("exp %p(%s): req %p (%u|%u|%u|%u|%u|%u) with " "unauthorized flavor %x, expect %x|%x(%+ld)|%x(%+ld)\n", @@ -1948,16 +1964,16 @@ void sptlrpc_target_update_exp_flavor(struct obd_device *obd, LASSERT(obd); - cfs_spin_lock(&obd->obd_dev_lock); + spin_lock(&obd->obd_dev_lock); - cfs_list_for_each_entry(exp, &obd->obd_exports, exp_obd_chain) { - if (exp->exp_connection == NULL) - continue; + list_for_each_entry(exp, &obd->obd_exports, exp_obd_chain) { + if (exp->exp_connection == NULL) + continue; - /* note if this export had just been updated flavor - * (exp_flvr_changed == 1), this will override the - * previous one. */ - cfs_spin_lock(&exp->exp_lock); + /* note if this export had just been updated flavor + * (exp_flvr_changed == 1), this will override the + * previous one. */ + spin_lock(&exp->exp_lock); sptlrpc_target_choose_flavor(rset, exp->exp_sp_peer, exp->exp_connection->c_peer.nid, &new_flvr); @@ -1973,10 +1989,10 @@ void sptlrpc_target_update_exp_flavor(struct obd_device *obd, exp->exp_flvr.sf_rpc, exp->exp_flvr_old[1].sf_rpc); } - cfs_spin_unlock(&exp->exp_lock); - } + spin_unlock(&exp->exp_lock); + } - cfs_spin_unlock(&obd->obd_dev_lock); + spin_unlock(&obd->obd_dev_lock); } EXPORT_SYMBOL(sptlrpc_target_update_exp_flavor); @@ -2024,7 +2040,7 @@ static int sptlrpc_svc_check_from(struct ptlrpc_request *req, int svc_rc) /** * Used by ptlrpc server, to perform transformation upon request message of - * incoming \a req. This must be the first thing to do with a incoming + * incoming \a req. This must be the first thing to do with an incoming * request in ptlrpc layer. * * \retval SECSVC_OK success, and req->rq_reqmsg point to request message in @@ -2061,8 +2077,8 @@ int sptlrpc_svc_unwrap_request(struct ptlrpc_request *req) req->rq_flvr.sf_rpc = WIRE_FLVR(msg->lm_secflvr); req->rq_sp_from = LUSTRE_SP_ANY; - req->rq_auth_uid = INVALID_UID; - req->rq_auth_mapped_uid = INVALID_UID; + req->rq_auth_uid = -1; /* set to INVALID_UID */ + req->rq_auth_mapped_uid = -1; policy = sptlrpc_wireflavor2policy(req->rq_flvr.sf_rpc); if (!policy) { @@ -2108,8 +2124,18 @@ int sptlrpc_svc_alloc_rs(struct ptlrpc_request *req, int msglen) rc = policy->sp_sops->alloc_rs(req, msglen); if (unlikely(rc == -ENOMEM)) { + struct ptlrpc_service_part *svcpt = req->rq_rqbd->rqbd_svcpt; + if (svcpt->scp_service->srv_max_reply_size < + msglen + sizeof(struct ptlrpc_reply_state)) { + /* Just return failure if the size is too big */ + CERROR("size of message is too big (%zd), %d allowed\n", + msglen + sizeof(struct ptlrpc_reply_state), + svcpt->scp_service->srv_max_reply_size); + RETURN(-ENOMEM); + } + /* failed alloc, try emergency pool */ - rs = lustre_get_emerg_rs(req->rq_rqbd->rqbd_service); + rs = lustre_get_emerg_rs(svcpt); if (rs == NULL) RETURN(-ENOMEM); @@ -2176,25 +2202,25 @@ void sptlrpc_svc_free_rs(struct ptlrpc_reply_state *rs) void sptlrpc_svc_ctx_addref(struct ptlrpc_request *req) { - struct ptlrpc_svc_ctx *ctx = req->rq_svc_ctx; + struct ptlrpc_svc_ctx *ctx = req->rq_svc_ctx; - if (ctx != NULL) - cfs_atomic_inc(&ctx->sc_refcount); + if (ctx != NULL) + atomic_inc(&ctx->sc_refcount); } void sptlrpc_svc_ctx_decref(struct ptlrpc_request *req) { - struct ptlrpc_svc_ctx *ctx = req->rq_svc_ctx; + struct ptlrpc_svc_ctx *ctx = req->rq_svc_ctx; - if (ctx == NULL) - return; + if (ctx == NULL) + return; - LASSERT_ATOMIC_POS(&ctx->sc_refcount); - if (cfs_atomic_dec_and_test(&ctx->sc_refcount)) { - if (ctx->sc_policy->sp_sops->free_ctx) - ctx->sc_policy->sp_sops->free_ctx(ctx); - } - req->rq_svc_ctx = NULL; + LASSERT_ATOMIC_POS(&ctx->sc_refcount); + if (atomic_dec_and_test(&ctx->sc_refcount)) { + if (ctx->sc_policy->sp_sops->free_ctx) + ctx->sc_policy->sp_sops->free_ctx(ctx); + } + req->rq_svc_ctx = NULL; } void sptlrpc_svc_ctx_invalidate(struct ptlrpc_request *req) @@ -2288,15 +2314,16 @@ int sptlrpc_cli_unwrap_bulk_write(struct ptlrpc_request *req, * in case of privacy mode, nob_transferred needs to be adjusted. */ if (desc->bd_nob != desc->bd_nob_transferred) { - CERROR("nob %d doesn't match transferred nob %d", - desc->bd_nob, desc->bd_nob_transferred); - return -EPROTO; - } + CERROR("nob %d doesn't match transferred nob %d\n", + desc->bd_nob, desc->bd_nob_transferred); + return -EPROTO; + } - return 0; + return 0; } EXPORT_SYMBOL(sptlrpc_cli_unwrap_bulk_write); +#ifdef HAVE_SERVER_SUPPORT /** * Performe transformation upon outgoing bulk read. */ @@ -2378,6 +2405,8 @@ int sptlrpc_svc_prep_bulk(struct ptlrpc_request *req, } EXPORT_SYMBOL(sptlrpc_svc_prep_bulk); +#endif /* HAVE_SERVER_SUPPORT */ + /**************************************** * user descriptor helpers * ****************************************/ @@ -2386,41 +2415,35 @@ int sptlrpc_current_user_desc_size(void) { int ngroups; -#ifdef __KERNEL__ ngroups = current_ngroups; if (ngroups > LUSTRE_MAX_GROUPS) ngroups = LUSTRE_MAX_GROUPS; -#else - ngroups = 0; -#endif return sptlrpc_user_desc_size(ngroups); } EXPORT_SYMBOL(sptlrpc_current_user_desc_size); int sptlrpc_pack_user_desc(struct lustre_msg *msg, int offset) { - struct ptlrpc_user_desc *pud; + struct ptlrpc_user_desc *pud; - pud = lustre_msg_buf(msg, offset, 0); - - pud->pud_uid = cfs_curproc_uid(); - pud->pud_gid = cfs_curproc_gid(); - pud->pud_fsuid = cfs_curproc_fsuid(); - pud->pud_fsgid = cfs_curproc_fsgid(); - pud->pud_cap = cfs_curproc_cap_pack(); - pud->pud_ngroups = (msg->lm_buflens[offset] - sizeof(*pud)) / 4; - -#ifdef __KERNEL__ - task_lock(current); - if (pud->pud_ngroups > current_ngroups) - pud->pud_ngroups = current_ngroups; - memcpy(pud->pud_groups, current_cred()->group_info->blocks[0], - pud->pud_ngroups * sizeof(__u32)); - task_unlock(current); -#endif + pud = lustre_msg_buf(msg, offset, 0); - return 0; + pud->pud_uid = from_kuid(&init_user_ns, current_uid()); + pud->pud_gid = from_kgid(&init_user_ns, current_gid()); + pud->pud_fsuid = from_kuid(&init_user_ns, current_fsuid()); + pud->pud_fsgid = from_kgid(&init_user_ns, current_fsgid()); + pud->pud_cap = cfs_curproc_cap_pack(); + pud->pud_ngroups = (msg->lm_buflens[offset] - sizeof(*pud)) / 4; + + task_lock(current); + if (pud->pud_ngroups > current_ngroups) + pud->pud_ngroups = current_ngroups; + memcpy(pud->pud_groups, current_cred()->group_info->blocks[0], + pud->pud_ngroups * sizeof(__u32)); + task_unlock(current); + + return 0; } EXPORT_SYMBOL(sptlrpc_pack_user_desc); @@ -2504,7 +2527,7 @@ int sptlrpc_init(void) { int rc; - cfs_rwlock_init(&policy_lock); + rwlock_init(&policy_lock); rc = sptlrpc_gc_init(); if (rc)