X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fptlrpc%2Fsec.c;h=c4aa034c9f7804ff70dec755d2fbfd788cc15863;hb=0ee03999a24c3e5e2652155237809671414630b9;hp=bf7db85c7b6694d2f559fc6bad7195ffeeac7136;hpb=1f0e2723f37eb86f3a88807d1200e78c10ab9565;p=fs%2Flustre-release.git diff --git a/lustre/ptlrpc/sec.c b/lustre/ptlrpc/sec.c index bf7db85..c4aa034 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, 2012, Whamcloud, Inc. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -38,9 +38,6 @@ * Author: Eric Mei */ -#ifndef EXPORT_SYMTAB -#define EXPORT_SYMTAB -#endif #define DEBUG_SUBSYSTEM S_SEC #include @@ -120,7 +117,7 @@ EXPORT_SYMBOL(sptlrpc_unregister_policy); static struct ptlrpc_sec_policy * sptlrpc_wireflavor2policy(__u32 flavor) { - static CFS_DECLARE_MUTEX(load_mutex); + static CFS_DEFINE_MUTEX(load_mutex); static cfs_atomic_t loaded = CFS_ATOMIC_INIT(0); struct ptlrpc_sec_policy *policy; __u16 number = SPTLRPC_FLVR_POLICY(flavor); @@ -143,16 +140,17 @@ struct ptlrpc_sec_policy * sptlrpc_wireflavor2policy(__u32 flavor) break; /* try to load gss module, once */ - cfs_mutex_down(&load_mutex); + cfs_mutex_lock(&load_mutex); if (cfs_atomic_read(&loaded) == 0) { if (cfs_request_module("ptlrpc_gss") == 0) - CWARN("module ptlrpc_gss loaded on demand\n"); + CDEBUG(D_SEC, + "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); + cfs_mutex_unlock(&load_mutex); } return policy; @@ -237,21 +235,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); @@ -287,7 +284,6 @@ struct ptlrpc_cli_ctx *get_my_ctx(struct ptlrpc_sec *sec) struct ptlrpc_cli_ctx *sptlrpc_cli_ctx_get(struct ptlrpc_cli_ctx *ctx) { - LASSERT(cfs_atomic_read(&ctx->cc_refcount) > 0); cfs_atomic_inc(&ctx->cc_refcount); return ctx; } @@ -298,7 +294,7 @@ void sptlrpc_cli_ctx_put(struct ptlrpc_cli_ctx *ctx, int sync) struct ptlrpc_sec *sec = ctx->cc_sec; LASSERT(sec); - LASSERT(cfs_atomic_read(&ctx->cc_refcount)); + LASSERT_ATOMIC_POS(&ctx->cc_refcount); if (!cfs_atomic_dec_and_test(&ctx->cc_refcount)) return; @@ -462,30 +458,32 @@ int sptlrpc_req_ctx_switch(struct ptlrpc_request *req, struct ptlrpc_cli_ctx *newctx) { struct sptlrpc_flavor old_flvr; - char *reqmsg; + char *reqmsg = NULL; /* to workaround old gcc */ int reqmsg_size; - int rc; + int rc = 0; LASSERT(req->rq_reqmsg); 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; /* save request message */ reqmsg_size = req->rq_reqlen; - OBD_ALLOC(reqmsg, reqmsg_size); - if (reqmsg == NULL) - return -ENOMEM; - memcpy(reqmsg, req->rq_reqmsg, reqmsg_size); + if (reqmsg_size != 0) { + OBD_ALLOC_LARGE(reqmsg, reqmsg_size); + if (reqmsg == NULL) + return -ENOMEM; + memcpy(reqmsg, req->rq_reqmsg, reqmsg_size); + } /* release old req/rep buf */ req->rq_cli_ctx = oldctx; @@ -498,18 +496,19 @@ int sptlrpc_req_ctx_switch(struct ptlrpc_request *req, /* alloc new request buffer * we don't need to alloc reply buffer here, leave it to the - * rest procedure of ptlrpc - */ - rc = sptlrpc_cli_alloc_reqbuf(req, reqmsg_size); - if (!rc) { - LASSERT(req->rq_reqmsg); - memcpy(req->rq_reqmsg, reqmsg, reqmsg_size); - } else { - CWARN("failed to alloc reqbuf: %d\n", rc); - req->rq_flvr = old_flvr; - } + * rest procedure of ptlrpc */ + if (reqmsg_size != 0) { + rc = sptlrpc_cli_alloc_reqbuf(req, reqmsg_size); + if (!rc) { + LASSERT(req->rq_reqmsg); + memcpy(req->rq_reqmsg, reqmsg, reqmsg_size); + } else { + CWARN("failed to alloc reqbuf: %d\n", rc); + req->rq_flvr = old_flvr; + } - OBD_FREE(reqmsg, reqmsg_size); + OBD_FREE_LARGE(reqmsg, reqmsg_size); + } return rc; } @@ -550,8 +549,9 @@ int sptlrpc_req_replace_dead_ctx(struct ptlrpc_request *req) /* * 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); + CDEBUG(D_SEC, + "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); @@ -820,6 +820,8 @@ void sptlrpc_req_set_flavor(struct ptlrpc_request *req, int 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: @@ -1107,7 +1109,7 @@ int sptlrpc_cli_unwrap_early_reply(struct ptlrpc_request *req, early_size = req->rq_nob_received; early_bufsz = size_roundup_power2(early_size); - OBD_ALLOC(early_buf, early_bufsz); + OBD_ALLOC_LARGE(early_buf, early_bufsz); if (early_buf == NULL) GOTO(err_req, rc = -ENOMEM); @@ -1171,7 +1173,7 @@ int sptlrpc_cli_unwrap_early_reply(struct ptlrpc_request *req, err_ctx: sptlrpc_cli_ctx_put(early_req->rq_cli_ctx, 1); err_buf: - OBD_FREE(early_buf, early_bufsz); + OBD_FREE_LARGE(early_buf, early_bufsz); err_req: OBD_FREE_PTR(early_req); RETURN(rc); @@ -1189,7 +1191,7 @@ void sptlrpc_cli_finish_early_reply(struct ptlrpc_request *early_req) LASSERT(early_req->rq_repmsg); sptlrpc_cli_ctx_put(early_req->rq_cli_ctx, 1); - OBD_FREE(early_req->rq_repbuf, early_req->rq_repbuf_len); + OBD_FREE_LARGE(early_req->rq_repbuf, early_req->rq_repbuf_len); OBD_FREE_PTR(early_req); } @@ -1227,8 +1229,8 @@ static void sec_cop_destroy_sec(struct ptlrpc_sec *sec) { struct ptlrpc_sec_policy *policy = sec->ps_policy; - LASSERT(cfs_atomic_read(&sec->ps_refcount) == 0); - LASSERT(cfs_atomic_read(&sec->ps_nctx) == 0); + LASSERT_ATOMIC_ZERO(&sec->ps_refcount); + LASSERT_ATOMIC_ZERO(&sec->ps_nctx); LASSERT(policy->sp_cops->destroy_sec); CDEBUG(D_SEC, "%s@%p: being destroied\n", sec->ps_policy->sp_name, sec); @@ -1245,7 +1247,7 @@ EXPORT_SYMBOL(sptlrpc_sec_destroy); static void sptlrpc_sec_kill(struct ptlrpc_sec *sec) { - LASSERT(cfs_atomic_read(&sec->ps_refcount) > 0); + LASSERT_ATOMIC_POS(&sec->ps_refcount); if (sec->ps_policy->sp_cops->kill_sec) { sec->ps_policy->sp_cops->kill_sec(sec); @@ -1256,10 +1258,8 @@ static void sptlrpc_sec_kill(struct ptlrpc_sec *sec) struct ptlrpc_sec *sptlrpc_sec_get(struct ptlrpc_sec *sec) { - if (sec) { - LASSERT(cfs_atomic_read(&sec->ps_refcount) > 0); + if (sec) cfs_atomic_inc(&sec->ps_refcount); - } return sec; } @@ -1268,11 +1268,9 @@ EXPORT_SYMBOL(sptlrpc_sec_get); void sptlrpc_sec_put(struct ptlrpc_sec *sec) { if (sec) { - LASSERT(cfs_atomic_read(&sec->ps_refcount) > 0); + LASSERT_ATOMIC_POS(&sec->ps_refcount); if (cfs_atomic_dec_and_test(&sec->ps_refcount)) { - LASSERT(cfs_atomic_read(&sec->ps_nctx) == 0); - sptlrpc_gc_del_sec(sec); sec_cop_destroy_sec(sec); } @@ -1351,7 +1349,7 @@ static void sptlrpc_import_sec_install(struct obd_import *imp, { struct ptlrpc_sec *old_sec; - LASSERT(cfs_atomic_read(&sec->ps_refcount) > 0); + LASSERT_ATOMIC_POS(&sec->ps_refcount); cfs_spin_lock(&imp->imp_lock); old_sec = imp->imp_sec; @@ -1385,11 +1383,11 @@ static void sptlrpc_import_sec_adapt_inplace(struct obd_import *imp, 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))); + CDEBUG(D_SEC, "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); @@ -1455,11 +1453,11 @@ 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))); + 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))); if (SPTLRPC_FLVR_POLICY(sf.sf_rpc) == SPTLRPC_FLVR_POLICY(sec->ps_flvr.sf_rpc) && @@ -1468,15 +1466,16 @@ int sptlrpc_import_sec_adapt(struct obd_import *imp, sptlrpc_import_sec_adapt_inplace(imp, sec, &sf); GOTO(out, rc); } - } else { - CWARN("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))); + } else if (SPTLRPC_FLVR_BASE(sf.sf_rpc) != + SPTLRPC_FLVR_BASE(SPTLRPC_FLVR_NULL)) { + 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); + cfs_mutex_lock(&imp->imp_sec_mutex); newsec = sptlrpc_sec_create(imp, svc_ctx, &sf, sp); if (newsec) { @@ -1488,7 +1487,7 @@ int sptlrpc_import_sec_adapt(struct obd_import *imp, rc = -EPERM; } - cfs_mutex_up(&imp->imp_sec_mutex); + cfs_mutex_unlock(&imp->imp_sec_mutex); out: sptlrpc_sec_put(sec); RETURN(rc); @@ -1550,10 +1549,10 @@ int sptlrpc_cli_alloc_reqbuf(struct ptlrpc_request *req, int msgsize) int rc; LASSERT(ctx); - LASSERT(cfs_atomic_read(&ctx->cc_refcount)); LASSERT(ctx->cc_sec); LASSERT(ctx->cc_sec->ps_policy); LASSERT(req->rq_reqmsg == NULL); + LASSERT_ATOMIC_POS(&ctx->cc_refcount); policy = ctx->cc_sec->ps_policy; rc = policy->sp_cops->alloc_reqbuf(ctx->cc_sec, req, msgsize); @@ -1579,9 +1578,9 @@ void sptlrpc_cli_free_reqbuf(struct ptlrpc_request *req) struct ptlrpc_sec_policy *policy; LASSERT(ctx); - LASSERT(cfs_atomic_read(&ctx->cc_refcount)); LASSERT(ctx->cc_sec); LASSERT(ctx->cc_sec->ps_policy); + LASSERT_ATOMIC_POS(&ctx->cc_refcount); if (req->rq_reqbuf == NULL && req->rq_clrbuf == NULL) return; @@ -1677,7 +1676,6 @@ int sptlrpc_cli_alloc_repbuf(struct ptlrpc_request *req, int msgsize) ENTRY; LASSERT(ctx); - LASSERT(cfs_atomic_read(&ctx->cc_refcount)); LASSERT(ctx->cc_sec); LASSERT(ctx->cc_sec->ps_policy); @@ -1699,9 +1697,9 @@ void sptlrpc_cli_free_repbuf(struct ptlrpc_request *req) ENTRY; LASSERT(ctx); - LASSERT(cfs_atomic_read(&ctx->cc_refcount)); LASSERT(ctx->cc_sec); LASSERT(ctx->cc_sec->ps_policy); + LASSERT_ATOMIC_POS(&ctx->cc_refcount); if (req->rq_repbuf == NULL) return; @@ -1805,12 +1803,14 @@ int sptlrpc_target_export_check(struct obd_export *exp, /* if it's gss, we only interested in root ctx init */ if (req->rq_auth_gss && - !(req->rq_ctx_init && (req->rq_auth_usr_root || - req->rq_auth_usr_mdt))) { + !(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)\n", + 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_root, req->rq_auth_usr_mdt, + req->rq_auth_usr_ost); return 0; } @@ -1827,7 +1827,8 @@ int sptlrpc_target_export_check(struct obd_export *exp, /* most cases should return here, we only interested in * gss root ctx init */ if (!req->rq_auth_gss || !req->rq_ctx_init || - (!req->rq_auth_usr_root && !req->rq_auth_usr_mdt)) { + (!req->rq_auth_usr_root && !req->rq_auth_usr_mdt && + !req->rq_auth_usr_ost)) { cfs_spin_unlock(&exp->exp_lock); return 0; } @@ -1919,11 +1920,12 @@ int sptlrpc_target_export_check(struct obd_export *exp, cfs_spin_unlock(&exp->exp_lock); - CWARN("exp %p(%s): req %p (%u|%u|%u|%u|%u) with " + CWARN("exp %p(%s): req %p (%u|%u|%u|%u|%u|%u) with " "unauthorized flavor %x, expect %x|%x(%+ld)|%x(%+ld)\n", exp, exp->exp_obd->obd_name, req, req->rq_auth_gss, req->rq_ctx_init, req->rq_ctx_fini, - req->rq_auth_usr_root, req->rq_auth_usr_mdt, req->rq_flvr.sf_rpc, + req->rq_auth_usr_root, req->rq_auth_usr_mdt, req->rq_auth_usr_ost, + req->rq_flvr.sf_rpc, exp->exp_flvr.sf_rpc, exp->exp_flvr_old[0].sf_rpc, exp->exp_flvr_expire[0] ? @@ -1979,43 +1981,41 @@ EXPORT_SYMBOL(sptlrpc_target_update_exp_flavor); static int sptlrpc_svc_check_from(struct ptlrpc_request *req, int svc_rc) { - if (svc_rc == SECSVC_DROP) - return SECSVC_DROP; + /* peer's claim is unreliable unless gss is being used */ + if (!req->rq_auth_gss || svc_rc == SECSVC_DROP) + return svc_rc; switch (req->rq_sp_from) { case LUSTRE_SP_CLI: + if (req->rq_auth_usr_mdt || req->rq_auth_usr_ost) { + DEBUG_REQ(D_ERROR, req, "faked source CLI"); + svc_rc = SECSVC_DROP; + } + break; case LUSTRE_SP_MDT: + if (!req->rq_auth_usr_mdt) { + DEBUG_REQ(D_ERROR, req, "faked source MDT"); + svc_rc = SECSVC_DROP; + } + break; case LUSTRE_SP_OST: - case LUSTRE_SP_MGC: + if (!req->rq_auth_usr_ost) { + DEBUG_REQ(D_ERROR, req, "faked source OST"); + svc_rc = SECSVC_DROP; + } + break; case LUSTRE_SP_MGS: - case LUSTRE_SP_ANY: + case LUSTRE_SP_MGC: + if (!req->rq_auth_usr_root && !req->rq_auth_usr_mdt && + !req->rq_auth_usr_ost) { + DEBUG_REQ(D_ERROR, req, "faked source MGC/MGS"); + svc_rc = SECSVC_DROP; + } break; + case LUSTRE_SP_ANY: default: DEBUG_REQ(D_ERROR, req, "invalid source %u", req->rq_sp_from); - return SECSVC_DROP; - } - - if (!req->rq_auth_gss) - return svc_rc; - - if (unlikely(req->rq_sp_from == LUSTRE_SP_ANY)) { - CERROR("not specific part\n"); - return SECSVC_DROP; - } - - /* from MDT, must be authenticated as MDT */ - if (unlikely(req->rq_sp_from == LUSTRE_SP_MDT && - !req->rq_auth_usr_mdt)) { - DEBUG_REQ(D_ERROR, req, "fake source MDT"); - return SECSVC_DROP; - } - - /* from OST, must be callback to MDT and CLI, the reverse sec - * was from mdt/root keytab, so it should be MDT or root FIXME */ - if (unlikely(req->rq_sp_from == LUSTRE_SP_OST && - !req->rq_auth_usr_mdt && !req->rq_auth_usr_root)) { - DEBUG_REQ(D_ERROR, req, "fake source OST"); - return SECSVC_DROP; + svc_rc = SECSVC_DROP; } return svc_rc; @@ -2108,7 +2108,7 @@ int sptlrpc_svc_alloc_rs(struct ptlrpc_request *req, int msglen) rc = policy->sp_sops->alloc_rs(req, msglen); if (unlikely(rc == -ENOMEM)) { /* failed alloc, try emergency pool */ - rs = lustre_get_emerg_rs(req->rq_rqbd->rqbd_service); + rs = lustre_get_emerg_rs(req->rq_rqbd->rqbd_svcpt); if (rs == NULL) RETURN(-ENOMEM); @@ -2177,11 +2177,8 @@ void sptlrpc_svc_ctx_addref(struct ptlrpc_request *req) { struct ptlrpc_svc_ctx *ctx = req->rq_svc_ctx; - if (ctx == NULL) - return; - - LASSERT(cfs_atomic_read(&ctx->sc_refcount) > 0); - cfs_atomic_inc(&ctx->sc_refcount); + if (ctx != NULL) + cfs_atomic_inc(&ctx->sc_refcount); } void sptlrpc_svc_ctx_decref(struct ptlrpc_request *req) @@ -2191,7 +2188,7 @@ void sptlrpc_svc_ctx_decref(struct ptlrpc_request *req) if (ctx == NULL) return; - LASSERT(cfs_atomic_read(&ctx->sc_refcount) > 0); + 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); @@ -2206,7 +2203,7 @@ void sptlrpc_svc_ctx_invalidate(struct ptlrpc_request *req) if (ctx == NULL) return; - LASSERT(cfs_atomic_read(&ctx->sc_refcount) > 0); + LASSERT_ATOMIC_POS(&ctx->sc_refcount); if (ctx->sc_policy->sp_sops->invalidate_ctx) ctx->sc_policy->sp_sops->invalidate_ctx(ctx); } @@ -2299,6 +2296,7 @@ int sptlrpc_cli_unwrap_bulk_write(struct ptlrpc_request *req, } EXPORT_SYMBOL(sptlrpc_cli_unwrap_bulk_write); +#ifdef HAVE_SERVER_SUPPORT /** * Performe transformation upon outgoing bulk read. */ @@ -2380,6 +2378,8 @@ int sptlrpc_svc_prep_bulk(struct ptlrpc_request *req, } EXPORT_SYMBOL(sptlrpc_svc_prep_bulk); +#endif /* HAVE_SERVER_SUPPORT */ + /**************************************** * user descriptor helpers * ****************************************/ @@ -2502,7 +2502,7 @@ EXPORT_SYMBOL(sptlrpc_flavor_has_bulk); * initialize/finalize * ****************************************/ -int __init sptlrpc_init(void) +int sptlrpc_init(void) { int rc; @@ -2548,7 +2548,7 @@ out: return rc; } -void __exit sptlrpc_fini(void) +void sptlrpc_fini(void) { sptlrpc_lproc_fini(); sptlrpc_plain_fini();