return 0;
}
}
-EXPORT_SYMBOL(lustre_msg_hdr_size);
void ptlrpc_buf_set_swabbed(struct ptlrpc_request *req, const int inout,
__u32 index)
else
lustre_set_rep_swabbed(req, index);
}
-EXPORT_SYMBOL(ptlrpc_buf_set_swabbed);
int ptlrpc_buf_need_swab(struct ptlrpc_request *req, const int inout,
__u32 index)
return (ptlrpc_rep_need_swab(req) &&
!lustre_rep_swabbed(req, index));
}
-EXPORT_SYMBOL(ptlrpc_buf_need_swab);
static inline int lustre_msg_check_version_v2(struct lustre_msg_v2 *msg,
__u32 version)
return 0;
}
}
-EXPORT_SYMBOL(lustre_msg_check_version);
/* early reply size */
__u32 lustre_msg_early_size()
return 0;
}
}
-EXPORT_SYMBOL(lustre_msg_size);
/* This is used to determine the size of a buffer that was already packed
* and will correctly handle the different message formats. */
return 0;
}
}
-EXPORT_SYMBOL(lustre_packed_msg_size);
void lustre_init_msg_v2(struct lustre_msg_v2 *msg, int count, __u32 *lens,
char **bufs)
return -EINVAL;
}
}
-EXPORT_SYMBOL(lustre_pack_request);
#if RS_DEBUG
struct list_head ptlrpc_rs_debug_lru =
lustre_msg_size(req->rq_reqmsg->lm_magic, count, lens));
return rc;
}
-EXPORT_SYMBOL(lustre_pack_reply_flags);
int lustre_pack_reply(struct ptlrpc_request *req, int count, __u32 *lens,
char **bufs)
sptlrpc_svc_free_rs(rs);
}
-EXPORT_SYMBOL(lustre_free_reply_state);
static int lustre_unpack_msg_v2(struct lustre_msg_v2 *m, int len)
{
}
return rc;
}
-EXPORT_SYMBOL(ptlrpc_unpack_req_msg);
int ptlrpc_unpack_rep_msg(struct ptlrpc_request *req, int len)
{
}
return rc;
}
-EXPORT_SYMBOL(ptlrpc_unpack_rep_msg);
static inline int lustre_unpack_ptlrpc_body_v2(struct ptlrpc_request *req,
const int inout, int offset)
}
}
-EXPORT_SYMBOL(lustre_msg_set_buflen);
-
/* NB return the bufcount for lustre_msg_v2 format, so if message is packed
* in V1 format, the result is one bigger. (add struct ptlrpc_body). */
__u32 lustre_msg_bufcount(struct lustre_msg *m)
return 0;
}
}
-EXPORT_SYMBOL(lustre_msg_bufcount);
char *lustre_msg_string(struct lustre_msg *m, __u32 index, __u32 max_len)
{
return str;
}
-EXPORT_SYMBOL(lustre_msg_string);
/* Wrap up the normal fixed length cases */
static inline void *__lustre_swab_buf(struct lustre_msg *msg, __u32 index,
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
-EXPORT_SYMBOL(lustre_msg_set_flags);
void lustre_msg_clear_flags(struct lustre_msg *msg, __u32 flags)
{
return 0;
}
}
-EXPORT_SYMBOL(lustre_msg_get_op_flags);
void lustre_msg_add_op_flags(struct lustre_msg *msg, __u32 flags)
{
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
-EXPORT_SYMBOL(lustre_msg_set_op_flags);
struct lustre_handle *lustre_msg_get_handle(struct lustre_msg *msg)
{
return NULL;
}
}
-EXPORT_SYMBOL(lustre_msg_get_handle);
__u32 lustre_msg_get_type(struct lustre_msg *msg)
{
return 0;
}
}
-EXPORT_SYMBOL(lustre_msg_get_version);
void lustre_msg_add_version(struct lustre_msg *msg, __u32 version)
{
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
-EXPORT_SYMBOL(lustre_msg_add_version);
__u32 lustre_msg_get_opc(struct lustre_msg *msg)
{
}
EXPORT_SYMBOL(lustre_msg_get_last_xid);
+__u16 lustre_msg_get_tag(struct lustre_msg *msg)
+{
+ switch (msg->lm_magic) {
+ case LUSTRE_MSG_MAGIC_V2: {
+ struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
+ if (!pb) {
+ CERROR("invalid msg %p: no ptlrpc body!\n", msg);
+ return 0;
+ }
+ return pb->pb_tag;
+ }
+ default:
+ CERROR("incorrect message magic: %08x\n", msg->lm_magic);
+ return 0;
+ }
+}
+EXPORT_SYMBOL(lustre_msg_get_tag);
+
__u64 lustre_msg_get_last_committed(struct lustre_msg *msg)
{
switch (msg->lm_magic) {
return -EINVAL;
}
}
-EXPORT_SYMBOL(lustre_msg_get_slv);
void lustre_msg_set_slv(struct lustre_msg *msg, __u64 slv)
return;
}
}
-EXPORT_SYMBOL(lustre_msg_set_slv);
__u32 lustre_msg_get_limit(struct lustre_msg *msg)
{
return -EINVAL;
}
}
-EXPORT_SYMBOL(lustre_msg_get_limit);
void lustre_msg_set_limit(struct lustre_msg *msg, __u64 limit)
return;
}
}
-EXPORT_SYMBOL(lustre_msg_set_limit);
__u32 lustre_msg_get_conn_cnt(struct lustre_msg *msg)
{
return 0;
}
}
-EXPORT_SYMBOL(lustre_msg_is_v1);
__u32 lustre_msg_get_magic(struct lustre_msg *msg)
{
return 0;
}
}
-EXPORT_SYMBOL(lustre_msg_get_magic);
__u32 lustre_msg_get_timeout(struct lustre_msg *msg)
{
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
-EXPORT_SYMBOL(lustre_msg_set_handle);
void lustre_msg_set_type(struct lustre_msg *msg, __u32 type)
{
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
-EXPORT_SYMBOL(lustre_msg_set_type);
void lustre_msg_set_opc(struct lustre_msg *msg, __u32 opc)
{
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
-EXPORT_SYMBOL(lustre_msg_set_opc);
void lustre_msg_set_last_xid(struct lustre_msg *msg, __u64 last_xid)
{
}
EXPORT_SYMBOL(lustre_msg_set_last_xid);
+void lustre_msg_set_tag(struct lustre_msg *msg, __u16 tag)
+{
+ switch (msg->lm_magic) {
+ case LUSTRE_MSG_MAGIC_V2: {
+ struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
+ LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
+ pb->pb_tag = tag;
+ return;
+ }
+ default:
+ LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
+ }
+}
+EXPORT_SYMBOL(lustre_msg_set_tag);
+
void lustre_msg_set_last_committed(struct lustre_msg *msg, __u64 last_committed)
{
switch (msg->lm_magic) {
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
-EXPORT_SYMBOL(lustre_msg_set_last_committed);
void lustre_msg_set_versions(struct lustre_msg *msg, __u64 *versions)
{
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
-EXPORT_SYMBOL(lustre_msg_set_conn_cnt);
void lustre_msg_set_timeout(struct lustre_msg *msg, __u32 timeout)
{
if (req->rq_reqmsg->lm_magic == LUSTRE_MSG_MAGIC_V2)
req->rq_reqmsg->lm_repsize = req->rq_replen;
}
-EXPORT_SYMBOL(ptlrpc_req_set_repsize);
/**
* Send a remote set_info_async.
__swab32s (&b->pb_opc);
__swab32s (&b->pb_status);
__swab64s (&b->pb_last_xid);
- __swab64s (&b->pb_last_seen);
+ __swab16s (&b->pb_tag);
__swab64s (&b->pb_last_committed);
__swab64s (&b->pb_transno);
__swab32s (&b->pb_flags);
__swab64s (&b->pb_pre_versions[1]);
__swab64s (&b->pb_pre_versions[2]);
__swab64s (&b->pb_pre_versions[3]);
- CLASSERT(offsetof(typeof(*b), pb_padding) != 0);
+ CLASSERT(offsetof(typeof(*b), pb_padding0) != 0);
+ CLASSERT(offsetof(typeof(*b), pb_padding1) != 0);
+ CLASSERT(offsetof(typeof(*b), pb_padding) != 0);
/* While we need to maintain compatibility between
* clients and servers without ptlrpc_body_v2 (< 2.3)
* do not swab any fields beyond pb_jobid, as we are
* and ptlrpc_body_v2. */
CLASSERT(offsetof(typeof(*b), pb_jobid) != 0);
}
-EXPORT_SYMBOL(lustre_swab_ptlrpc_body);
void lustre_swab_connect(struct obd_connect_data *ocd)
{
__swab32s(&ocd->ocd_max_easize);
if (ocd->ocd_connect_flags & OBD_CONNECT_MAXBYTES)
__swab64s(&ocd->ocd_maxbytes);
+ if (ocd->ocd_connect_flags & OBD_CONNECT_MULTIMODRPCS)
+ __swab16s(&ocd->ocd_maxmodrpcs);
+ CLASSERT(offsetof(typeof(*ocd), padding0) != 0);
CLASSERT(offsetof(typeof(*ocd), padding1) != 0);
CLASSERT(offsetof(typeof(*ocd), padding2) != 0);
CLASSERT(offsetof(typeof(*ocd), padding3) != 0);
CLASSERT(offsetof(typeof(*os), os_spare8) != 0);
CLASSERT(offsetof(typeof(*os), os_spare9) != 0);
}
-EXPORT_SYMBOL(lustre_swab_obd_statfs);
void lustre_swab_obd_ioobj(struct obd_ioobj *ioo)
{
__swab32s(&ioo->ioo_max_brw);
__swab32s(&ioo->ioo_bufcnt);
}
-EXPORT_SYMBOL(lustre_swab_obd_ioobj);
void lustre_swab_niobuf_remote(struct niobuf_remote *nbr)
{
__swab32s(&nbr->rnb_len);
__swab32s(&nbr->rnb_flags);
}
-EXPORT_SYMBOL(lustre_swab_niobuf_remote);
void lustre_swab_ost_body (struct ost_body *b)
{
lustre_swab_obdo (&b->oa);
}
-EXPORT_SYMBOL(lustre_swab_ost_body);
void lustre_swab_ost_last_id(u64 *id)
{
__swab64s(id);
}
-EXPORT_SYMBOL(lustre_swab_ost_last_id);
void lustre_swab_generic_32s(__u32 *val)
{
__swab32s(val);
}
-EXPORT_SYMBOL(lustre_swab_generic_32s);
void lustre_swab_gl_desc(union ldlm_gl_desc *desc)
{
__swab32s(&b->mbo_gid_h);
CLASSERT(offsetof(typeof(*b), mbo_padding_5) != 0);
}
-EXPORT_SYMBOL(lustre_swab_mdt_body);
void lustre_swab_mdt_ioepoch (struct mdt_ioepoch *b)
{
__swab32s (&b->flags);
CLASSERT(offsetof(typeof(*b), padding) != 0);
}
-EXPORT_SYMBOL(lustre_swab_mdt_ioepoch);
void lustre_swab_mgs_target_info(struct mgs_target_info *mti)
{
for (i = 0; i < MTI_NIDS_MAX; i++)
__swab64s(&mti->mti_nids[i]);
}
-EXPORT_SYMBOL(lustre_swab_mgs_target_info);
void lustre_swab_mgs_nidtbl_entry(struct mgs_nidtbl_entry *entry)
{
__swab32s(&body->mcb_units);
__swab16s(&body->mcb_type);
}
-EXPORT_SYMBOL(lustre_swab_mgs_config_body);
void lustre_swab_mgs_config_res(struct mgs_config_res *body)
{
__swab64s(&body->mcr_offset);
__swab64s(&body->mcr_size);
}
-EXPORT_SYMBOL(lustre_swab_mgs_config_res);
static void lustre_swab_obd_dqinfo (struct obd_dqinfo *i)
{
lustre_swab_obd_dqinfo (&q->qc_dqinfo);
lustre_swab_obd_dqblk (&q->qc_dqblk);
}
-EXPORT_SYMBOL(lustre_swab_obd_quotactl);
void lustre_swab_mdt_remote_perm (struct mdt_remote_perm *p)
{
for (i = 0; i < fiemap->fm_mapped_extents; i++)
lustre_swab_fiemap_extent(&fiemap->fm_extents[i]);
}
-EXPORT_SYMBOL(lustre_swab_fiemap);
void lustre_swab_idx_info(struct idx_info *ii)
{
CLASSERT(offsetof(typeof(*rr), rr_padding_4) != 0);
};
-EXPORT_SYMBOL(lustre_swab_mdt_rec_reint);
void lustre_swab_lov_desc (struct lov_desc *ld)
{
break;
}
}
-EXPORT_SYMBOL(lustre_swab_lmv_mds_md);
void lustre_swab_lmv_user_md(struct lmv_user_md *lum)
{
for (i = 0; i < RES_NAME_SIZE; i++)
__swab64s (&id->name[i]);
}
-EXPORT_SYMBOL(lustre_swab_ldlm_res_id);
void lustre_swab_ldlm_policy_data (ldlm_wire_policy_data_t *d)
{
__swab64s(&d->l_flock.lfw_owner);
__swab32s(&d->l_flock.lfw_pid);
}
-EXPORT_SYMBOL(lustre_swab_ldlm_policy_data);
void lustre_swab_ldlm_intent (struct ldlm_intent *i)
{
__swab64s (&i->opc);
}
-EXPORT_SYMBOL(lustre_swab_ldlm_intent);
void lustre_swab_ldlm_resource_desc (struct ldlm_resource_desc *r)
{
CLASSERT(offsetof(typeof(*r), lr_padding) != 0);
lustre_swab_ldlm_res_id (&r->lr_name);
}
-EXPORT_SYMBOL(lustre_swab_ldlm_resource_desc);
void lustre_swab_ldlm_lock_desc (struct ldlm_lock_desc *l)
{
__swab32s (&l->l_granted_mode);
lustre_swab_ldlm_policy_data (&l->l_policy_data);
}
-EXPORT_SYMBOL(lustre_swab_ldlm_lock_desc);
void lustre_swab_ldlm_request (struct ldlm_request *rq)
{
__swab32s (&rq->lock_count);
/* lock_handle[] opaque */
}
-EXPORT_SYMBOL(lustre_swab_ldlm_request);
void lustre_swab_ldlm_reply (struct ldlm_reply *r)
{
__swab64s (&r->lock_policy_res1);
__swab64s (&r->lock_policy_res2);
}
-EXPORT_SYMBOL(lustre_swab_ldlm_reply);
void lustre_swab_quota_body(struct quota_body *b)
{
"ioo_bufct=%d\n", POSTID(&ioo->ioo_oid), ioo->ioo_max_brw,
ioo->ioo_bufcnt);
}
-EXPORT_SYMBOL(dump_ioo);
void dump_rniobuf(struct niobuf_remote *nb)
{
CDEBUG(D_RPCTRACE, "niobuf_remote: offset="LPU64", len=%d, flags=%x\n",
nb->rnb_offset, nb->rnb_len, nb->rnb_flags);
}
-EXPORT_SYMBOL(dump_rniobuf);
void dump_obdo(struct obdo *oa)
{
- __u32 valid = oa->o_valid;
+ u64 valid = oa->o_valid;
- CDEBUG(D_RPCTRACE, "obdo: o_valid = %08x\n", valid);
+ CDEBUG(D_RPCTRACE, "obdo: o_valid = "LPX64"\n", valid);
if (valid & OBD_MD_FLID)
CDEBUG(D_RPCTRACE, "obdo: id = "DOSTID"\n", POSTID(&oa->o_oi));
if (valid & OBD_MD_FLFID)
CDEBUG(D_RPCTRACE, "obdo: o_lcookie = "
"(llog_cookie dumping not yet implemented)\n");
}
-EXPORT_SYMBOL(dump_obdo);
void dump_ost_body(struct ost_body *ob)
{
dump_obdo(&ob->oa);
}
-EXPORT_SYMBOL(dump_ost_body);
void dump_rcs(__u32 *rc)
{
CDEBUG(D_RPCTRACE, "rmf_rcs: %d\n", *rc);
}
-EXPORT_SYMBOL(dump_rcs);
static inline int req_ptlrpc_body_swabbed(struct ptlrpc_request *req)
{
__swab32s (&c->lc_timeout);
__swab32s (&c->lc_expiry);
}
-EXPORT_SYMBOL(lustre_swab_lustre_capa);
void lustre_swab_lustre_capa_key(struct lustre_capa_key *k)
{
__swab32s (&k->lk_keyid);
CLASSERT(offsetof(typeof(*k), lk_padding) != 0);
}
-EXPORT_SYMBOL(lustre_swab_lustre_capa_key);
void lustre_swab_hsm_user_state(struct hsm_user_state *state)
{
__swab32s(&state->hus_states);
__swab32s(&state->hus_archive_id);
}
-EXPORT_SYMBOL(lustre_swab_hsm_user_state);
void lustre_swab_hsm_state_set(struct hsm_state_set *hss)
{
__swab64s(&hss->hss_clearmask);
__swab32s(&hss->hss_archive_id);
}
-EXPORT_SYMBOL(lustre_swab_hsm_state_set);
static void lustre_swab_hsm_extent(struct hsm_extent *extent)
{
__swab32s(&action->hca_action);
lustre_swab_hsm_extent(&action->hca_location);
}
-EXPORT_SYMBOL(lustre_swab_hsm_current_action);
void lustre_swab_hsm_user_item(struct hsm_user_item *hui)
{
lustre_swab_lu_fid(&hui->hui_fid);
lustre_swab_hsm_extent(&hui->hui_extent);
}
-EXPORT_SYMBOL(lustre_swab_hsm_user_item);
void lustre_swab_layout_intent(struct layout_intent *li)
{
__swab64s(&li->li_start);
__swab64s(&li->li_end);
}
-EXPORT_SYMBOL(lustre_swab_layout_intent);
void lustre_swab_hsm_progress_kernel(struct hsm_progress_kernel *hpk)
{
__swab16s(&hpk->hpk_flags);
__swab16s(&hpk->hpk_errval);
}
-EXPORT_SYMBOL(lustre_swab_hsm_progress_kernel);
void lustre_swab_hsm_request(struct hsm_request *hr)
{
__swab32s(&hr->hr_itemcount);
__swab32s(&hr->hr_data_len);
}
-EXPORT_SYMBOL(lustre_swab_hsm_request);
void lustre_swab_object_update(struct object_update *ou)
{
object_update_param_size(param));
}
}
-EXPORT_SYMBOL(lustre_swab_object_update);
void lustre_swab_object_update_request(struct object_update_request *our)
{
lustre_swab_object_update(ou);
}
}
-EXPORT_SYMBOL(lustre_swab_object_update_request);
void lustre_swab_object_update_result(struct object_update_result *our)
{
__swab16s(&our->our_datalen);
__swab16s(&our->our_padding);
}
-EXPORT_SYMBOL(lustre_swab_object_update_result);
void lustre_swab_object_update_reply(struct object_update_reply *our)
{
lustre_swab_object_update_result(ourp);
}
}
-EXPORT_SYMBOL(lustre_swab_object_update_reply);
void lustre_swab_swap_layouts(struct mdc_swap_layouts *msl)
{
__swab64s(&msl->msl_flags);
}
-EXPORT_SYMBOL(lustre_swab_swap_layouts);
void lustre_swab_close_data(struct close_data *cd)
{
lustre_swab_lu_fid(&cd->cd_fid);
__swab64s(&cd->cd_data_version);
}
-EXPORT_SYMBOL(lustre_swab_close_data);
void lustre_swab_lfsck_request(struct lfsck_request *lr)
{
lustre_swab_lu_fid(&lr->lr_fid);
lustre_swab_lu_fid(&lr->lr_fid2);
lustre_swab_lu_fid(&lr->lr_fid3);
- __swab32s(&lr->lr_stripe_count);
- __swab32s(&lr->lr_hash_type);
- CLASSERT(offsetof(typeof(*lr), lr_padding_3) != 0);
+ CLASSERT(offsetof(typeof(*lr), lr_padding_1) != 0);
+ CLASSERT(offsetof(typeof(*lr), lr_padding_2) != 0);
}
-EXPORT_SYMBOL(lustre_swab_lfsck_request);
void lustre_swab_lfsck_reply(struct lfsck_reply *lr)
{
CLASSERT(offsetof(typeof(*lr), lr_padding_1) != 0);
CLASSERT(offsetof(typeof(*lr), lr_padding_2) != 0);
}
-EXPORT_SYMBOL(lustre_swab_lfsck_reply);
void lustre_swab_orphan_ent(struct lu_orphan_ent *ent)
{
git://git.whamcloud.com / fs / lustre-release.git / blobdiff