static inline int lustre_msg_hdr_size_v2(int count)
{
- return size_round(offsetof(struct lustre_msg_v2, lm_buflens[count]));
+ return cfs_size_round(offsetof(struct lustre_msg_v2,
+ lm_buflens[count]));
}
int lustre_msg_hdr_size(__u32 magic, int count)
size = lustre_msg_hdr_size_v2(count);
for (i = 0; i < count; i++)
- size += size_round(lengths[i]);
+ size += cfs_size_round(lengths[i]);
return size;
}
#if RS_DEBUG
CFS_LIST_HEAD(ptlrpc_rs_debug_lru);
-spinlock_t ptlrpc_rs_debug_lock;
+cfs_spinlock_t ptlrpc_rs_debug_lock;
#define PTLRPC_RS_DEBUG_LRU_ADD(rs) \
do { \
- spin_lock(&ptlrpc_rs_debug_lock); \
- list_add_tail(&(rs)->rs_debug_list, &ptlrpc_rs_debug_lru); \
- spin_unlock(&ptlrpc_rs_debug_lock); \
+ cfs_spin_lock(&ptlrpc_rs_debug_lock); \
+ cfs_list_add_tail(&(rs)->rs_debug_list, &ptlrpc_rs_debug_lru); \
+ cfs_spin_unlock(&ptlrpc_rs_debug_lock); \
} while (0)
#define PTLRPC_RS_DEBUG_LRU_DEL(rs) \
do { \
- spin_lock(&ptlrpc_rs_debug_lock); \
- list_del(&(rs)->rs_debug_list); \
- spin_unlock(&ptlrpc_rs_debug_lock); \
+ cfs_spin_lock(&ptlrpc_rs_debug_lock); \
+ cfs_list_del(&(rs)->rs_debug_list); \
+ cfs_spin_unlock(&ptlrpc_rs_debug_lock); \
} while (0)
#else
# define PTLRPC_RS_DEBUG_LRU_ADD(rs) do {} while(0)
{
struct ptlrpc_reply_state *rs = NULL;
- spin_lock(&svc->srv_lock);
+ cfs_spin_lock(&svc->srv_lock);
/* See if we have anything in a pool, and wait if nothing */
- while (list_empty(&svc->srv_free_rs_list)) {
+ while (cfs_list_empty(&svc->srv_free_rs_list)) {
struct l_wait_info lwi;
int rc;
- spin_unlock(&svc->srv_lock);
+ cfs_spin_unlock(&svc->srv_lock);
/* If we cannot get anything for some long time, we better
bail out instead of waiting infinitely */
lwi = LWI_TIMEOUT(cfs_time_seconds(10), NULL, NULL);
rc = l_wait_event(svc->srv_free_rs_waitq,
- !list_empty(&svc->srv_free_rs_list), &lwi);
+ !cfs_list_empty(&svc->srv_free_rs_list),
+ &lwi);
if (rc)
goto out;
- spin_lock(&svc->srv_lock);
+ cfs_spin_lock(&svc->srv_lock);
}
- rs = list_entry(svc->srv_free_rs_list.next, struct ptlrpc_reply_state,
- rs_list);
- list_del(&rs->rs_list);
- spin_unlock(&svc->srv_lock);
+ rs = cfs_list_entry(svc->srv_free_rs_list.next,
+ struct ptlrpc_reply_state, rs_list);
+ cfs_list_del(&rs->rs_list);
+ cfs_spin_unlock(&svc->srv_lock);
LASSERT(rs);
memset(rs, 0, svc->srv_max_reply_size);
rs->rs_service = svc;
LASSERT(svc);
- spin_lock(&svc->srv_lock);
- list_add(&rs->rs_list, &svc->srv_free_rs_list);
- spin_unlock(&svc->srv_lock);
+ cfs_spin_lock(&svc->srv_lock);
+ cfs_list_add(&rs->rs_list, &svc->srv_free_rs_list);
+ cfs_spin_unlock(&svc->srv_lock);
cfs_waitq_signal(&svc->srv_free_rs_waitq);
}
RETURN(rc);
rs = req->rq_reply_state;
- atomic_set(&rs->rs_refcount, 1); /* 1 ref for rq_reply_state */
+ cfs_atomic_set(&rs->rs_refcount, 1); /* 1 ref for rq_reply_state */
rs->rs_cb_id.cbid_fn = reply_out_callback;
rs->rs_cb_id.cbid_arg = rs;
rs->rs_service = req->rq_rqbd->rqbd_service;
CFS_INIT_LIST_HEAD(&rs->rs_exp_list);
CFS_INIT_LIST_HEAD(&rs->rs_obd_list);
CFS_INIT_LIST_HEAD(&rs->rs_list);
- spin_lock_init(&rs->rs_lock);
+ cfs_spin_lock_init(&rs->rs_lock);
req->rq_replen = msg_len;
req->rq_reply_state = rs;
offset = lustre_msg_hdr_size_v2(bufcount);
for (i = 0; i < n; i++)
- offset += size_round(m->lm_buflens[i]);
+ offset += cfs_size_round(m->lm_buflens[i]);
return (char *)m + offset;
}
if (move_data && msg->lm_bufcount > segment + 1) {
tail = lustre_msg_buf_v2(msg, segment + 1, 0);
for (n = segment + 1; n < msg->lm_bufcount; n++)
- tail_len += size_round(msg->lm_buflens[n]);
+ tail_len += cfs_size_round(msg->lm_buflens[n]);
}
msg->lm_buflens[segment] = newlen;
{
PTLRPC_RS_DEBUG_LRU_DEL(rs);
- LASSERT (atomic_read(&rs->rs_refcount) == 0);
+ LASSERT (cfs_atomic_read(&rs->rs_refcount) == 0);
LASSERT (!rs->rs_difficult || rs->rs_handled);
LASSERT (!rs->rs_on_net);
LASSERT (!rs->rs_scheduled);
LASSERT (rs->rs_export == NULL);
LASSERT (rs->rs_nlocks == 0);
- LASSERT (list_empty(&rs->rs_exp_list));
- LASSERT (list_empty(&rs->rs_obd_list));
+ LASSERT (cfs_list_empty(&rs->rs_exp_list));
+ LASSERT (cfs_list_empty(&rs->rs_obd_list));
sptlrpc_svc_free_rs(rs);
}
for (i = 0; i < m->lm_bufcount; i++) {
if (swabbed)
__swab32s(&m->lm_buflens[i]);
- required_len += size_round(m->lm_buflens[i]);
+ required_len += cfs_size_round(m->lm_buflens[i]);
}
if (len < required_len) {
return ptr;
}
-void *lustre_swab_reqbuf(struct ptlrpc_request *req, int index, int min_size,
- void *swabber)
-{
- if (!ptlrpc_buf_need_swab(req, 1, index))
- return lustre_msg_buf(req->rq_reqmsg, index, min_size);
-
- lustre_set_req_swabbed(req, index);
- return __lustre_swab_buf(req->rq_reqmsg, index, min_size, swabber);
-}
-
-void *lustre_swab_repbuf(struct ptlrpc_request *req, int index,
- int min_size, void *swabber)
-{
- if (!ptlrpc_buf_need_swab(req, 0, index))
- return lustre_msg_buf(req->rq_repmsg, index, min_size);
-
- lustre_set_rep_swabbed(req, index);
- return __lustre_swab_buf(req->rq_repmsg, index, min_size, swabber);
-}
-
static inline struct ptlrpc_body *lustre_msg_ptlrpc_body(struct lustre_msg *msg)
{
return lustre_msg_buf_v2(msg, MSG_PTLRPC_BODY_OFF,
req->rq_reqmsg->lm_repsize = req->rq_replen;
}
+/**
+ * Send a remote set_info_async.
+ *
+ * This may go from client to server or server to client.
+ */
+int do_set_info_async(struct obd_import *imp,
+ int opcode, int version,
+ obd_count keylen, void *key,
+ obd_count vallen, void *val,
+ struct ptlrpc_request_set *set)
+{
+ struct ptlrpc_request *req;
+ char *tmp;
+ int rc;
+ ENTRY;
+
+ req = ptlrpc_request_alloc(imp, &RQF_OBD_SET_INFO);
+ if (req == NULL)
+ RETURN(-ENOMEM);
+
+ req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_KEY,
+ RCL_CLIENT, keylen);
+ req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_VAL,
+ RCL_CLIENT, vallen);
+ rc = ptlrpc_request_pack(req, version, opcode);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
+
+ tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_KEY);
+ memcpy(tmp, key, keylen);
+ tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_VAL);
+ memcpy(tmp, val, vallen);
+
+ ptlrpc_request_set_replen(req);
+
+ if (set) {
+ ptlrpc_set_add_req(set, req);
+ ptlrpc_check_set(NULL, set);
+ } else {
+ rc = ptlrpc_queue_wait(req);
+ ptlrpc_req_finished(req);
+ }
+
+ RETURN(rc);
+}
+EXPORT_SYMBOL(do_set_info_async);
+
/* byte flipping routines for all wire types declared in
* lustre_idl.h implemented here.
*/
__swab32s (&o->o_nlink);
__swab32s (&o->o_generation);
__swab32s (&o->o_misc);
- __swab32s (&o->o_easize);
- __swab32s (&o->o_mds);
+ __swab64s (&o->o_ioepoch);
__swab32s (&o->o_stripe_idx);
__swab32s (&o->o_padding_1);
/* o_inline is opaque */
__swab32s (&b->padding_4);
}
-void lustre_swab_mdt_epoch (struct mdt_epoch *b)
+void lustre_swab_mdt_ioepoch (struct mdt_ioepoch *b)
{
/* handle is opaque */
__swab64s (&b->ioepoch);
__swab32s (&p->rp_access_perm);
};
-void lustre_swab_mds_rec_setattr (struct mds_rec_setattr *sa)
-{
- __swab32s (&sa->sa_opcode);
- __swab32s (&sa->sa_fsuid);
- __swab32s (&sa->sa_fsgid);
- __swab32s (&sa->sa_cap);
- __swab32s (&sa->sa_suppgid);
- __swab32s (&sa->sa_mode);
- lustre_swab_ll_fid (&sa->sa_fid);
- __swab64s (&sa->sa_valid);
- __swab64s (&sa->sa_size);
- __swab64s (&sa->sa_mtime);
- __swab64s (&sa->sa_atime);
- __swab64s (&sa->sa_ctime);
- __swab32s (&sa->sa_uid);
- __swab32s (&sa->sa_gid);
- __swab32s (&sa->sa_attr_flags);
- CLASSERT(offsetof(typeof(*sa), sa_padding) != 0);
-}
-
void lustre_swab_fid2path(struct getinfo_fid2path *gf)
{
lustre_swab_lu_fid(&gf->gf_fid);
}
EXPORT_SYMBOL(lustre_swab_fid2path);
-void lustre_swab_mds_rec_join (struct mds_rec_join *jr)
-{
- __swab64s(&jr->jr_headsize);
- lustre_swab_ll_fid(&jr->jr_fid);
-}
-
-void lustre_swab_mdt_rec_join (struct mdt_rec_join *jr)
-{
- __swab64s(&jr->jr_headsize);
- lustre_swab_lu_fid(&jr->jr_fid);
-}
-
-void lustre_swab_mds_rec_create (struct mds_rec_create *cr)
-{
- __swab32s (&cr->cr_opcode);
- __swab32s (&cr->cr_fsuid);
- __swab32s (&cr->cr_fsgid);
- __swab32s (&cr->cr_cap);
- __swab32s (&cr->cr_flags); /* for use with open */
- __swab32s (&cr->cr_mode);
- lustre_swab_ll_fid (&cr->cr_fid);
- lustre_swab_ll_fid (&cr->cr_replayfid);
- __swab64s (&cr->cr_time);
- __swab64s (&cr->cr_rdev);
- __swab32s (&cr->cr_suppgid);
- CLASSERT(offsetof(typeof(*cr), cr_padding_1) != 0);
- CLASSERT(offsetof(typeof(*cr), cr_padding_2) != 0);
- CLASSERT(offsetof(typeof(*cr), cr_padding_3) != 0);
- CLASSERT(offsetof(typeof(*cr), cr_padding_4) != 0);
- CLASSERT(offsetof(typeof(*cr), cr_padding_5) != 0);
-}
-
-void lustre_swab_mds_rec_link (struct mds_rec_link *lk)
-{
- __swab32s (&lk->lk_opcode);
- __swab32s (&lk->lk_fsuid);
- __swab32s (&lk->lk_fsgid);
- __swab32s (&lk->lk_cap);
- __swab32s (&lk->lk_suppgid1);
- __swab32s (&lk->lk_suppgid2);
- lustre_swab_ll_fid (&lk->lk_fid1);
- lustre_swab_ll_fid (&lk->lk_fid2);
- __swab64s (&lk->lk_time);
- CLASSERT(offsetof(typeof(*lk), lk_padding_1) != 0);
- CLASSERT(offsetof(typeof(*lk), lk_padding_2) != 0);
- CLASSERT(offsetof(typeof(*lk), lk_padding_3) != 0);
- CLASSERT(offsetof(typeof(*lk), lk_padding_4) != 0);
-}
-
-void lustre_swab_mds_rec_unlink (struct mds_rec_unlink *ul)
-{
- __swab32s (&ul->ul_opcode);
- __swab32s (&ul->ul_fsuid);
- __swab32s (&ul->ul_fsgid);
- __swab32s (&ul->ul_cap);
- __swab32s (&ul->ul_suppgid);
- __swab32s (&ul->ul_mode);
- lustre_swab_ll_fid (&ul->ul_fid1);
- lustre_swab_ll_fid (&ul->ul_fid2);
- __swab64s (&ul->ul_time);
- CLASSERT(offsetof(typeof(*ul), ul_padding_1) != 0);
- CLASSERT(offsetof(typeof(*ul), ul_padding_2) != 0);
- CLASSERT(offsetof(typeof(*ul), ul_padding_3) != 0);
- CLASSERT(offsetof(typeof(*ul), ul_padding_4) != 0);
-}
-
void lustre_swab_fiemap_extent(struct ll_fiemap_extent *fm_extent)
{
__swab64s(&fm_extent->fe_logical);
lustre_swab_fiemap_extent(&fiemap->fm_extents[i]);
}
-void lustre_swab_mds_rec_rename (struct mds_rec_rename *rn)
-{
- __swab32s (&rn->rn_opcode);
- __swab32s (&rn->rn_fsuid);
- __swab32s (&rn->rn_fsgid);
- __swab32s (&rn->rn_cap);
- __swab32s (&rn->rn_suppgid1);
- __swab32s (&rn->rn_suppgid2);
- lustre_swab_ll_fid (&rn->rn_fid1);
- lustre_swab_ll_fid (&rn->rn_fid2);
- __swab64s (&rn->rn_time);
- CLASSERT(offsetof(typeof(*rn), rn_padding_1) != 0);
- CLASSERT(offsetof(typeof(*rn), rn_padding_2) != 0);
- CLASSERT(offsetof(typeof(*rn), rn_padding_3) != 0);
- CLASSERT(offsetof(typeof(*rn), rn_padding_4) != 0);
-}
-
void lustre_swab_mdt_rec_reint (struct mdt_rec_reint *rr)
{
__swab32s (&rr->rr_opcode);
EXIT;
}
-static void print_lumj (struct lov_user_md_join *lumj)
-{
- CDEBUG(D_OTHER, "lov_user_md %p:\n", lumj);
- CDEBUG(D_OTHER, "\tlmm_magic: %#x\n", lumj->lmm_magic);
- CDEBUG(D_OTHER, "\tlmm_pattern: %#x\n", lumj->lmm_pattern);
- CDEBUG(D_OTHER, "\tlmm_object_id: "LPU64"\n", lumj->lmm_object_id);
- CDEBUG(D_OTHER, "\tlmm_object_gr: "LPU64"\n", lumj->lmm_object_gr);
- CDEBUG(D_OTHER, "\tlmm_stripe_size: %#x\n", lumj->lmm_stripe_size);
- CDEBUG(D_OTHER, "\tlmm_stripe_count: %#x\n", lumj->lmm_stripe_count);
- CDEBUG(D_OTHER, "\tlmm_extent_count: %#x\n", lumj->lmm_extent_count);
-}
-
void lustre_swab_lov_user_md_v1(struct lov_user_md_v1 *lum)
{
ENTRY;
EXIT;
}
-void lustre_swab_lov_user_md_join(struct lov_user_md_join *lumj)
-{
- ENTRY;
- CDEBUG(D_IOCTL, "swabbing lov_user_md_join\n");
- __swab32s(&lumj->lmm_magic);
- __swab32s(&lumj->lmm_pattern);
- __swab64s(&lumj->lmm_object_id);
- __swab64s(&lumj->lmm_object_gr);
- __swab32s(&lumj->lmm_stripe_size);
- __swab32s(&lumj->lmm_stripe_count);
- __swab32s(&lumj->lmm_extent_count);
- print_lumj(lumj);
- EXIT;
-}
-
void lustre_swab_lov_user_md_objects(struct lov_user_ost_data *lod,
int stripe_count)
{
__swab64s (&d->padding);
}
+/* Dump functions */
+void dump_ioo(struct obd_ioobj *ioo)
+{
+ CDEBUG(D_RPCTRACE,
+ "obd_ioobj: ioo_id="LPD64", ioo_gr="LPD64", ioo_type=%d, "
+ "ioo_bufct=%d\n", ioo->ioo_id, ioo->ioo_gr, ioo->ioo_type,
+ ioo->ioo_bufcnt);
+}
+
+void dump_rniobuf(struct niobuf_remote *nb)
+{
+ CDEBUG(D_RPCTRACE, "niobuf_remote: offset="LPU64", len=%d, flags=%x\n",
+ nb->offset, nb->len, nb->flags);
+}
+
+void dump_obdo(struct obdo *oa)
+{
+ __u32 valid = oa->o_valid;
+
+ CDEBUG(D_RPCTRACE, "obdo: o_valid = %08x\n", valid);
+ if (valid & OBD_MD_FLID)
+ CDEBUG(D_RPCTRACE, "obdo: o_id = "LPD64"\n", oa->o_id);
+ if (valid & OBD_MD_FLGROUP)
+ CDEBUG(D_RPCTRACE, "obdo: o_gr = "LPD64"\n", oa->o_gr);
+ if (valid & OBD_MD_FLFID)
+ CDEBUG(D_RPCTRACE, "obdo: o_fid = "LPD64"\n", oa->o_fid);
+ if (valid & OBD_MD_FLSIZE)
+ CDEBUG(D_RPCTRACE, "obdo: o_size = "LPD64"\n", oa->o_size);
+ if (valid & OBD_MD_FLMTIME)
+ CDEBUG(D_RPCTRACE, "obdo: o_mtime = "LPD64"\n", oa->o_mtime);
+ if (valid & OBD_MD_FLATIME)
+ CDEBUG(D_RPCTRACE, "obdo: o_atime = "LPD64"\n", oa->o_atime);
+ if (valid & OBD_MD_FLCTIME)
+ CDEBUG(D_RPCTRACE, "obdo: o_ctime = "LPD64"\n", oa->o_ctime);
+ if (valid & OBD_MD_FLBLOCKS) /* allocation of space */
+ CDEBUG(D_RPCTRACE, "obdo: o_blocks = "LPD64"\n", oa->o_blocks);
+ if (valid & OBD_MD_FLGRANT)
+ CDEBUG(D_RPCTRACE, "obdo: o_grant = "LPD64"\n", oa->o_grant);
+ if (valid & OBD_MD_FLBLKSZ)
+ CDEBUG(D_RPCTRACE, "obdo: o_blksize = %d\n", oa->o_blksize);
+ if (valid & (OBD_MD_FLTYPE | OBD_MD_FLMODE))
+ CDEBUG(D_RPCTRACE, "obdo: o_mode = %o\n",
+ oa->o_mode & ((valid & OBD_MD_FLTYPE ? S_IFMT : 0) |
+ (valid & OBD_MD_FLMODE ? ~S_IFMT : 0)));
+ if (valid & OBD_MD_FLUID)
+ CDEBUG(D_RPCTRACE, "obdo: o_uid = %u\n", oa->o_uid);
+ if (valid & OBD_MD_FLGID)
+ CDEBUG(D_RPCTRACE, "obdo: o_gid = %u\n", oa->o_gid);
+ if (valid & OBD_MD_FLFLAGS)
+ CDEBUG(D_RPCTRACE, "obdo: o_flags = %x\n", oa->o_flags);
+ if (valid & OBD_MD_FLNLINK)
+ CDEBUG(D_RPCTRACE, "obdo: o_nlink = %u\n", oa->o_nlink);
+ else if (valid & OBD_MD_FLCKSUM)
+ CDEBUG(D_RPCTRACE, "obdo: o_checksum (o_nlink) = %u\n", oa->o_nlink);
+ if (valid & OBD_MD_FLGENER)
+ CDEBUG(D_RPCTRACE, "obdo: o_generation = %u\n",
+ oa->o_generation);
+ else if (valid & OBD_MD_FLEPOCH)
+ CDEBUG(D_RPCTRACE, "obdo: o_ioepoch = "LPD64"\n", oa->o_ioepoch);
+ if (valid & OBD_MD_FLID)
+ CDEBUG(D_RPCTRACE, "obdo: o_stripe_idx = %u\n", oa->o_stripe_idx);
+ if (valid & OBD_MD_FLHANDLE)
+ CDEBUG(D_RPCTRACE, "obdo: o_handle = "LPD64"\n", oa->o_handle.cookie);
+ if (valid & OBD_MD_FLCOOKIE)
+ CDEBUG(D_RPCTRACE, "obdo: o_lcookie = "
+ "(llog_cookie dumping not yet implemented)\n");
+}
+
+void dump_ost_body(struct ost_body *ob)
+{
+ dump_obdo(&ob->oa);
+}
+
+void dump_rcs(__u32 *rc)
+{
+ CDEBUG(D_RPCTRACE, "rmf_rcs: %d\n", *rc);
+}
+
#ifdef __KERNEL__
/**
* got qdata from request(req/rep)
*/
-struct qunit_data *quota_get_qdata(void *request, int is_req, int is_exp)
+struct qunit_data *quota_get_qdata(void *r, int is_req, int is_exp)
{
- struct ptlrpc_request *req = (struct ptlrpc_request *)request;
+ struct ptlrpc_request *req = (struct ptlrpc_request *)r;
struct qunit_data *qdata;
__u64 flags = is_exp ? req->rq_export->exp_connect_flags :
req->rq_import->imp_connect_data.ocd_connect_flags;
LASSERT(flags & OBD_CONNECT_CHANGE_QS);
if (is_req == QUOTA_REQUEST)
- qdata = lustre_swab_reqbuf(req, REQ_REC_OFF,
- sizeof(struct qunit_data),
- lustre_swab_qdata);
+ qdata = req_capsule_client_get(&req->rq_pill, &RMF_QUNIT_DATA);
else
- qdata = lustre_swab_repbuf(req, REPLY_REC_OFF,
- sizeof(struct qunit_data),
- lustre_swab_qdata);
+ qdata = req_capsule_server_get(&req->rq_pill, &RMF_QUNIT_DATA);
if (qdata == NULL)
return ERR_PTR(-EPROTO);
/**
* copy qdata to request(req/rep)
*/
-int quota_copy_qdata(void *request, struct qunit_data *qdata,
- int is_req, int is_exp)
+int quota_copy_qdata(void *r, struct qunit_data *qdata, int is_req,
+ int is_exp)
{
- struct ptlrpc_request *req = (struct ptlrpc_request *)request;
+ struct ptlrpc_request *req = (struct ptlrpc_request *)r;
void *target;
__u64 flags = is_exp ? req->rq_export->exp_connect_flags :
req->rq_import->imp_connect_data.ocd_connect_flags;
LASSERT(flags & OBD_CONNECT_CHANGE_QS);
if (is_req == QUOTA_REQUEST)
- target = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF,
- sizeof(struct qunit_data));
+ target = req_capsule_client_get(&req->rq_pill, &RMF_QUNIT_DATA);
else
- target = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF,
- sizeof(struct qunit_data));
+ target = req_capsule_server_get(&req->rq_pill, &RMF_QUNIT_DATA);
if (target == NULL)
return -EPROTO;
+ LASSERT(target != qdata);
memcpy(target, qdata, sizeof(*qdata));
return 0;
}
(char *)req->rq_export->exp_connection->c_remote_uuid.uuid : "<?>",
req->rq_request_portal, req->rq_reply_portal,
req->rq_reqlen, req->rq_replen,
- req->rq_early_count, req->rq_timedout, req->rq_deadline,
- atomic_read(&req->rq_refcount), DEBUG_REQ_FLAGS(req),
+ req->rq_early_count, req->rq_timedout,
+ req->rq_deadline,
+ cfs_atomic_read(&req->rq_refcount),
+ DEBUG_REQ_FLAGS(req),
req->rq_reqmsg && req_ptlrpc_body_swabbed(req) ?
lustre_msg_get_flags(req->rq_reqmsg) : -1,
req->rq_repmsg && rep_ptlrpc_body_swabbed(req) ?
__swab32s (&k->lk_padding);
}
-void lustre_swab_lnlh(struct lnl_hdr *l)
+void lustre_swab_kuch(struct kuc_hdr *l)
{
- __swab16s(&l->lnl_magic);
- /* __u8 l->lnl_transport */
- __swab16s(&l->lnl_msgtype);
- __swab16s(&l->lnl_msglen);
+ __swab16s(&l->kuc_magic);
+ /* __u8 l->kuc_transport */
+ __swab16s(&l->kuc_msgtype);
+ __swab16s(&l->kuc_msglen);
}
-EXPORT_SYMBOL(lustre_swab_lnlh);
+EXPORT_SYMBOL(lustre_swab_kuch);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff