* in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU General Public License
- * version 2 along with this program; If not, see [sun.com URL with a
- * copy of GPLv2].
+ * 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
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)
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);
+ obd->u.cli.cl_sp_me);
}
req->rq_reqdata_len = req->rq_reqlen;
return 0;
LASSERT(req->rq_repdata);
- /* real reply rq_repdata point inside of rq_reqbuf; early reply
- * rq_repdata point to a separate allocated space */
- if ((char *) req->rq_repdata < req->rq_repbuf ||
- (char *) req->rq_repdata >= req->rq_repbuf + req->rq_repbuf_len) {
- cksums = req->rq_repdata->lm_cksum;
- req->rq_repdata->lm_cksum = 0;
-
- if (req->rq_repdata->lm_magic == LUSTRE_MSG_MAGIC_V2_SWABBED)
- __swab32s(&cksums);
+ req->rq_repmsg = req->rq_repdata;
+ req->rq_replen = req->rq_repdata_len;
- cksumc = crc32_le(!(__u32) 0, (unsigned char *)req->rq_repdata,
- req->rq_repdata_len);
+ 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);
}
}
- req->rq_repmsg = req->rq_repdata;
- req->rq_replen = req->rq_repdata_len;
return 0;
}
struct ptlrpc_svc_ctx *svc_ctx,
struct sptlrpc_flavor *sf)
{
- LASSERT(RPC_FLVR_POLICY(sf->sf_rpc) == SPTLRPC_POLICY_NULL);
-
- if (sf->sf_bulk_ciph != BULK_CIPH_ALG_NULL ||
- sf->sf_bulk_hash != BULK_HASH_ALG_NULL) {
- CERROR("null sec don't support bulk algorithm: %u/%u\n",
- sf->sf_bulk_ciph, sf->sf_bulk_hash);
- 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.
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);
rs->rs_repdata_len = req->rq_replen;
if (likely(req->rq_packed_final)) {
- req->rq_reply_off = lustre_msg_early_size();
+ 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 {
- rs->rs_repbuf->lm_cksum =
- crc32_le(!(__u32) 0,
- (unsigned char *)rs->rs_repbuf,
- rs->rs_repdata_len);
+ lustre_msg_set_cksum(rs->rs_repbuf,
+ lustre_msg_calc_cksum(rs->rs_repbuf));
req->rq_reply_off = 0;
}
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_ciph = BULK_CIPH_ALG_NULL;
- null_sec.ps_flvr.sf_bulk_hash = BULK_HASH_ALG_NULL;
null_sec.ps_flvr.sf_flags = 0;
null_sec.ps_part = LUSTRE_SP_ANY;
null_sec.ps_dying = 0;