static
int null_authorize(struct ptlrpc_request *req)
{
struct ptlrpc_reply_state *rs = req->rq_reply_state;
LASSERT(rs);
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 {
__u32 cksum;
#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 9, 0, 0)
if (lustre_msghdr_get_flags(req->rq_reqmsg) &
MSGHDR_CKSUM_INCOMPAT18)
cksum = lustre_msg_calc_cksum(rs->rs_repbuf, 0);
else
cksum = lustre_msg_calc_cksum(rs->rs_repbuf, 1);
#else
# warning "remove checksum compatibility support for b1_8"
cksum = lustre_msg_calc_cksum(rs->rs_repbuf);
#endif
lustre_msg_set_cksum(rs->rs_repbuf, cksum);
req->rq_reply_off = 0;
}
return 0;
}
static
int null_ctx_verify(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req)
{
__u32 cksums, cksumc;
LASSERT(req->rq_repdata);
req->rq_repmsg = req->rq_repdata;
req->rq_replen = req->rq_repdata_len;
if (req->rq_early) {
cksums = lustre_msg_get_cksum(req->rq_repdata);
#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 9, 0, 0)
if (lustre_msghdr_get_flags(req->rq_reqmsg) &
MSGHDR_CKSUM_INCOMPAT18)
cksumc = lustre_msg_calc_cksum(req->rq_repmsg, 0);
else
cksumc = lustre_msg_calc_cksum(req->rq_repmsg, 1);
#else
# warning "remove checksum compatibility support for b1_8"
cksumc = lustre_msg_calc_cksum(req->rq_repmsg);
#endif
if (cksumc != cksums) {
CWARN("early reply checksum mismatch: %08x != %08x\n",
cksumc, cksums);
return -EINVAL;
}
}
return 0;
}
static
int null_authorize(struct ptlrpc_request *req)
{
struct ptlrpc_reply_state *rs = req->rq_reply_state;
LASSERT(rs);
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 {
__u32 cksum;
cksum = lustre_msg_calc_cksum(rs->rs_repbuf);
lustre_msg_set_cksum(rs->rs_repbuf, cksum);
req->rq_reply_off = 0;
}
return 0;
}
static void ptlrpc_at_set_reply(struct ptlrpc_request *req, int flags)
{
struct ptlrpc_service_part *svcpt = req->rq_rqbd->rqbd_svcpt;
struct ptlrpc_service *svc = svcpt->scp_service;
int service_time = max_t(int, cfs_time_current_sec() -
req->rq_arrival_time.tv_sec, 1);
if (!(flags & PTLRPC_REPLY_EARLY) &&
(req->rq_type != PTL_RPC_MSG_ERR) &&
(req->rq_reqmsg != NULL) &&
!(lustre_msg_get_flags(req->rq_reqmsg) &
(MSG_RESENT | MSG_REPLAY |
MSG_REQ_REPLAY_DONE | MSG_LOCK_REPLAY_DONE))) {
/* early replies, errors and recovery requests don't count
* toward our service time estimate */
int oldse = at_measured(&svcpt->scp_at_estimate, service_time);
if (oldse != 0) {
DEBUG_REQ(D_ADAPTTO, req,
"svc %s changed estimate from %d to %d",
svc->srv_name, oldse,
at_get(&svcpt->scp_at_estimate));
}
}
/* Report actual service time for client latency calc */
lustre_msg_set_service_time(req->rq_repmsg, service_time);
/* Report service time estimate for future client reqs, but report 0
* (to be ignored by client) if it's a error reply during recovery.
* (bz15815) */
if (req->rq_type == PTL_RPC_MSG_ERR &&
(req->rq_export == NULL || req->rq_export->exp_obd->obd_recovering))
lustre_msg_set_timeout(req->rq_repmsg, 0);
else
lustre_msg_set_timeout(req->rq_repmsg,
at_get(&svcpt->scp_at_estimate));
if (req->rq_reqmsg &&
!(lustre_msghdr_get_flags(req->rq_reqmsg) & MSGHDR_AT_SUPPORT)) {
CDEBUG(D_ADAPTTO, "No early reply support: flags=%#x "
"req_flags=%#x magic=%d:%x/%x len=%d\n",
flags, lustre_msg_get_flags(req->rq_reqmsg),
lustre_msg_is_v1(req->rq_reqmsg),
lustre_msg_get_magic(req->rq_reqmsg),
lustre_msg_get_magic(req->rq_repmsg), req->rq_replen);
}
}
/*
* Client's incoming reply callback
*/
void reply_in_callback(lnet_event_t *ev)
{
struct ptlrpc_cb_id *cbid = ev->md.user_ptr;
struct ptlrpc_request *req = cbid->cbid_arg;
DEBUG_REQ(D_NET, req, "type %d, status %d", ev->type, ev->status);
LASSERT(ev->type == LNET_EVENT_PUT || ev->type == LNET_EVENT_UNLINK);
LASSERT(ev->md.start == req->rq_repbuf);
LASSERT(ev->offset + ev->mlength <= req->rq_repbuf_len);
/* We've set LNET_MD_MANAGE_REMOTE for all outgoing requests
for adaptive timeouts' early reply. */
LASSERT((ev->md.options & LNET_MD_MANAGE_REMOTE) != 0);
spin_lock(&req->rq_lock);
req->rq_receiving_reply = 0;
req->rq_early = 0;
if (ev->unlinked)
req->rq_must_unlink = 0;
if (ev->status)
goto out_wake;
if (ev->type == LNET_EVENT_UNLINK) {
LASSERT(ev->unlinked);
DEBUG_REQ(D_NET, req, "unlink");
goto out_wake;
}
if (ev->mlength < ev->rlength) {
CDEBUG(D_RPCTRACE, "truncate req %p rpc %d - %d+%d\n", req,
req->rq_replen, ev->rlength, ev->offset);
req->rq_reply_truncate = 1;
req->rq_replied = 1;
req->rq_status = -EOVERFLOW;
req->rq_nob_received = ev->rlength + ev->offset;
goto out_wake;
}
if ((ev->offset == 0) &&
((lustre_msghdr_get_flags(req->rq_reqmsg) & MSGHDR_AT_SUPPORT))) {
/* Early reply */
DEBUG_REQ(D_ADAPTTO, req,
"Early reply received: mlen=%u offset=%d replen=%d "
"replied=%d unlinked=%d", ev->mlength, ev->offset,
req->rq_replen, req->rq_replied, ev->unlinked);
req->rq_early_count++; /* number received, client side */
if (req->rq_replied) /* already got the real reply */
goto out_wake;
req->rq_early = 1;
req->rq_reply_off = ev->offset;
req->rq_nob_received = ev->mlength;
/* And we're still receiving */
req->rq_receiving_reply = 1;
} else {
/* Real reply */
req->rq_rep_swab_mask = 0;
req->rq_replied = 1;
req->rq_reply_off = ev->offset;
req->rq_nob_received = ev->mlength;
/* LNetMDUnlink can't be called under the LNET_LOCK,
so we must unlink in ptlrpc_unregister_reply */
DEBUG_REQ(D_INFO, req,
"reply in flags=%x mlen=%u offset=%d replen=%d",
lustre_msg_get_flags(req->rq_reqmsg),
ev->mlength, ev->offset, req->rq_replen);
}
req->rq_import->imp_last_reply_time = cfs_time_current_sec();
out_wake:
/* NB don't unlock till after wakeup; req can disappear under us
* since we don't have our own ref */
ptlrpc_client_wake_req(req);
spin_unlock(&req->rq_lock);
}
