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;
}
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;
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);
/* 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;
/* 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;
}
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);
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);
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);
}
{
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);
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);
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;
}
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);
}
{
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;
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);
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;
ENTRY;
LASSERT(ctx);
- LASSERT(cfs_atomic_read(&ctx->cc_refcount));
LASSERT(ctx->cc_sec);
LASSERT(ctx->cc_sec->ps_policy);
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;
/* 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;
}
/* 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;
}
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] ?
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;
{
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)
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);
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);
}