X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fptlrpc%2Fpack_generic.c;h=03515ca79929d7822a0777a3990a7158ae59bc0f;hb=1ae726743b5a051bb4daa731d93496a3e7f7a93c;hp=6de2ad30dde7a8bd0f615dae4ca4720f61e3a847;hpb=f4547f0569774eb794fb143362e201f658415f4c;p=fs%2Flustre-release.git diff --git a/lustre/ptlrpc/pack_generic.c b/lustre/ptlrpc/pack_generic.c index 6de2ad3..03515ca 100644 --- a/lustre/ptlrpc/pack_generic.c +++ b/lustre/ptlrpc/pack_generic.c @@ -27,7 +27,7 @@ * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2012, Intel Corporation. + * Copyright (c) 2011, 2013, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -54,6 +54,7 @@ #include #include #include +#include static inline int lustre_msg_hdr_size_v2(int count) { @@ -260,20 +261,21 @@ int lustre_pack_request(struct ptlrpc_request *req, __u32 magic, int count, EXPORT_SYMBOL(lustre_pack_request); #if RS_DEBUG -CFS_LIST_HEAD(ptlrpc_rs_debug_lru); +struct list_head ptlrpc_rs_debug_lru = + LIST_HEAD_INIT(ptlrpc_rs_debug_lru); spinlock_t ptlrpc_rs_debug_lock; #define PTLRPC_RS_DEBUG_LRU_ADD(rs) \ do { \ spin_lock(&ptlrpc_rs_debug_lock); \ - cfs_list_add_tail(&(rs)->rs_debug_list, &ptlrpc_rs_debug_lru); \ + list_add_tail(&(rs)->rs_debug_list, &ptlrpc_rs_debug_lru); \ spin_unlock(&ptlrpc_rs_debug_lock); \ } while (0) #define PTLRPC_RS_DEBUG_LRU_DEL(rs) \ do { \ spin_lock(&ptlrpc_rs_debug_lock); \ - cfs_list_del(&(rs)->rs_debug_list); \ + list_del(&(rs)->rs_debug_list); \ spin_unlock(&ptlrpc_rs_debug_lock); \ } while (0) #else @@ -289,7 +291,7 @@ lustre_get_emerg_rs(struct ptlrpc_service_part *svcpt) spin_lock(&svcpt->scp_rep_lock); /* See if we have anything in a pool, and wait if nothing */ - while (cfs_list_empty(&svcpt->scp_rep_idle)) { + while (list_empty(&svcpt->scp_rep_idle)) { struct l_wait_info lwi; int rc; @@ -298,19 +300,20 @@ lustre_get_emerg_rs(struct ptlrpc_service_part *svcpt) * bail out instead of waiting infinitely */ lwi = LWI_TIMEOUT(cfs_time_seconds(10), NULL, NULL); rc = l_wait_event(svcpt->scp_rep_waitq, - !cfs_list_empty(&svcpt->scp_rep_idle), &lwi); + !list_empty(&svcpt->scp_rep_idle), &lwi); if (rc != 0) goto out; spin_lock(&svcpt->scp_rep_lock); } - rs = cfs_list_entry(svcpt->scp_rep_idle.next, + rs = list_entry(svcpt->scp_rep_idle.next, struct ptlrpc_reply_state, rs_list); - cfs_list_del(&rs->rs_list); + list_del(&rs->rs_list); spin_unlock(&svcpt->scp_rep_lock); memset(rs, 0, svcpt->scp_service->srv_max_reply_size); + rs->rs_size = svcpt->scp_service->srv_max_reply_size; rs->rs_svcpt = svcpt; rs->rs_prealloc = 1; out: @@ -322,9 +325,9 @@ void lustre_put_emerg_rs(struct ptlrpc_reply_state *rs) struct ptlrpc_service_part *svcpt = rs->rs_svcpt; spin_lock(&svcpt->scp_rep_lock); - cfs_list_add(&rs->rs_list, &svcpt->scp_rep_idle); + list_add(&rs->rs_list, &svcpt->scp_rep_idle); spin_unlock(&svcpt->scp_rep_lock); - cfs_waitq_signal(&svcpt->scp_rep_waitq); + wake_up(&svcpt->scp_rep_waitq); } int lustre_pack_reply_v2(struct ptlrpc_request *req, int count, @@ -347,14 +350,14 @@ int lustre_pack_reply_v2(struct ptlrpc_request *req, int count, if (rc) RETURN(rc); - rs = req->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 = req->rq_reply_state; + 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_svcpt = req->rq_rqbd->rqbd_svcpt; - CFS_INIT_LIST_HEAD(&rs->rs_exp_list); - CFS_INIT_LIST_HEAD(&rs->rs_obd_list); - CFS_INIT_LIST_HEAD(&rs->rs_list); + INIT_LIST_HEAD(&rs->rs_exp_list); + INIT_LIST_HEAD(&rs->rs_obd_list); + INIT_LIST_HEAD(&rs->rs_list); spin_lock_init(&rs->rs_lock); req->rq_replen = msg_len; @@ -509,18 +512,18 @@ EXPORT_SYMBOL(lustre_shrink_msg); void lustre_free_reply_state(struct ptlrpc_reply_state *rs) { - PTLRPC_RS_DEBUG_LRU_DEL(rs); + PTLRPC_RS_DEBUG_LRU_DEL(rs); - 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 (cfs_list_empty(&rs->rs_exp_list)); - LASSERT (cfs_list_empty(&rs->rs_obd_list)); + LASSERT(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)); - sptlrpc_svc_free_rs(rs); + sptlrpc_svc_free_rs(rs); } EXPORT_SYMBOL(lustre_free_reply_state); @@ -645,6 +648,9 @@ static inline int lustre_unpack_ptlrpc_body_v2(struct ptlrpc_request *req, return -EINVAL; } + if (!inout) + pb->pb_status = ptlrpc_status_ntoh(pb->pb_status); + return 0; } @@ -1729,8 +1735,7 @@ void lustre_swab_connect(struct obd_connect_data *ocd) void lustre_swab_obdo (struct obdo *o) { __swab64s (&o->o_valid); - __swab64s (&o->o_id); - __swab64s (&o->o_seq); + lustre_swab_ost_id(&o->o_oi); __swab64s (&o->o_parent_seq); __swab64s (&o->o_size); __swab64s (&o->o_mtime); @@ -1786,20 +1791,19 @@ void lustre_swab_obd_statfs (struct obd_statfs *os) } EXPORT_SYMBOL(lustre_swab_obd_statfs); -void lustre_swab_obd_ioobj (struct obd_ioobj *ioo) +void lustre_swab_obd_ioobj(struct obd_ioobj *ioo) { - __swab64s (&ioo->ioo_id); - __swab64s (&ioo->ioo_seq); - __swab32s (&ioo->ioo_type); - __swab32s (&ioo->ioo_bufcnt); + lustre_swab_ost_id(&ioo->ioo_oid); + __swab32s(&ioo->ioo_max_brw); + __swab32s(&ioo->ioo_bufcnt); } EXPORT_SYMBOL(lustre_swab_obd_ioobj); -void lustre_swab_niobuf_remote (struct niobuf_remote *nbr) +void lustre_swab_niobuf_remote(struct niobuf_remote *nbr) { - __swab64s (&nbr->offset); - __swab32s (&nbr->len); - __swab32s (&nbr->flags); + __swab64s(&nbr->rnb_offset); + __swab32s(&nbr->rnb_len); + __swab32s(&nbr->rnb_flags); } EXPORT_SYMBOL(lustre_swab_niobuf_remote); @@ -1868,35 +1872,35 @@ EXPORT_SYMBOL(lustre_swab_lquota_lvb); void lustre_swab_mdt_body (struct mdt_body *b) { - lustre_swab_lu_fid (&b->fid1); - lustre_swab_lu_fid (&b->fid2); - /* handle is opaque */ - __swab64s (&b->valid); - __swab64s (&b->size); - __swab64s (&b->mtime); - __swab64s (&b->atime); - __swab64s (&b->ctime); - __swab64s (&b->blocks); - __swab64s (&b->ioepoch); - CLASSERT(offsetof(typeof(*b), unused1) != 0); - __swab32s (&b->fsuid); - __swab32s (&b->fsgid); - __swab32s (&b->capability); - __swab32s (&b->mode); - __swab32s (&b->uid); - __swab32s (&b->gid); - __swab32s (&b->flags); - __swab32s (&b->rdev); - __swab32s (&b->nlink); - CLASSERT(offsetof(typeof(*b), unused2) != 0); - __swab32s (&b->suppgid); - __swab32s (&b->eadatasize); - __swab32s (&b->aclsize); - __swab32s (&b->max_mdsize); - __swab32s (&b->max_cookiesize); - __swab32s (&b->uid_h); - __swab32s (&b->gid_h); - CLASSERT(offsetof(typeof(*b), padding_5) != 0); + lustre_swab_lu_fid(&b->mbo_fid1); + lustre_swab_lu_fid(&b->mbo_fid2); + /* handle is opaque */ + __swab64s(&b->mbo_valid); + __swab64s(&b->mbo_size); + __swab64s(&b->mbo_mtime); + __swab64s(&b->mbo_atime); + __swab64s(&b->mbo_ctime); + __swab64s(&b->mbo_blocks); + __swab64s(&b->mbo_ioepoch); + __swab64s(&b->mbo_t_state); + __swab32s(&b->mbo_fsuid); + __swab32s(&b->mbo_fsgid); + __swab32s(&b->mbo_capability); + __swab32s(&b->mbo_mode); + __swab32s(&b->mbo_uid); + __swab32s(&b->mbo_gid); + __swab32s(&b->mbo_flags); + __swab32s(&b->mbo_rdev); + __swab32s(&b->mbo_nlink); + CLASSERT(offsetof(typeof(*b), mbo_unused2) != 0); + __swab32s(&b->mbo_suppgid); + __swab32s(&b->mbo_eadatasize); + __swab32s(&b->mbo_aclsize); + __swab32s(&b->mbo_max_mdsize); + __swab32s(&b->mbo_max_cookiesize); + __swab32s(&b->mbo_uid_h); + __swab32s(&b->mbo_gid_h); + CLASSERT(offsetof(typeof(*b), mbo_padding_5) != 0); } EXPORT_SYMBOL(lustre_swab_mdt_body); @@ -2067,30 +2071,30 @@ EXPORT_SYMBOL(lustre_swab_lip_header); void lustre_swab_mdt_rec_reint (struct mdt_rec_reint *rr) { - __swab32s (&rr->rr_opcode); - __swab32s (&rr->rr_cap); - __swab32s (&rr->rr_fsuid); - /* rr_fsuid_h is unused */ - __swab32s (&rr->rr_fsgid); - /* rr_fsgid_h is unused */ - __swab32s (&rr->rr_suppgid1); - /* rr_suppgid1_h is unused */ - __swab32s (&rr->rr_suppgid2); - /* rr_suppgid2_h is unused */ - lustre_swab_lu_fid (&rr->rr_fid1); - lustre_swab_lu_fid (&rr->rr_fid2); - __swab64s (&rr->rr_mtime); - __swab64s (&rr->rr_atime); - __swab64s (&rr->rr_ctime); - __swab64s (&rr->rr_size); - __swab64s (&rr->rr_blocks); - __swab32s (&rr->rr_bias); - __swab32s (&rr->rr_mode); - __swab32s (&rr->rr_flags); - - CLASSERT(offsetof(typeof(*rr), rr_padding_2) != 0); - CLASSERT(offsetof(typeof(*rr), rr_padding_3) != 0); - CLASSERT(offsetof(typeof(*rr), rr_padding_4) != 0); + __swab32s(&rr->rr_opcode); + __swab32s(&rr->rr_cap); + __swab32s(&rr->rr_fsuid); + /* rr_fsuid_h is unused */ + __swab32s(&rr->rr_fsgid); + /* rr_fsgid_h is unused */ + __swab32s(&rr->rr_suppgid1); + /* rr_suppgid1_h is unused */ + __swab32s(&rr->rr_suppgid2); + /* rr_suppgid2_h is unused */ + lustre_swab_lu_fid(&rr->rr_fid1); + lustre_swab_lu_fid(&rr->rr_fid2); + __swab64s(&rr->rr_mtime); + __swab64s(&rr->rr_atime); + __swab64s(&rr->rr_ctime); + __swab64s(&rr->rr_size); + __swab64s(&rr->rr_blocks); + __swab32s(&rr->rr_bias); + __swab32s(&rr->rr_mode); + __swab32s(&rr->rr_flags); + __swab32s(&rr->rr_flags_h); + __swab32s(&rr->rr_umask); + + CLASSERT(offsetof(typeof(*rr), rr_padding_4) != 0); }; EXPORT_SYMBOL(lustre_swab_mdt_rec_reint); @@ -2118,40 +2122,73 @@ void lustre_swab_lmv_desc (struct lmv_desc *ld) /* uuid endian insensitive */ } -void lustre_swab_lmv_stripe_md (struct lmv_stripe_md *mea) +/* This structure is always in little-endian */ +static void lustre_swab_lmv_mds_md_v1(struct lmv_mds_md_v1 *lmm1) { - __swab32s(&mea->mea_magic); - __swab32s(&mea->mea_count); - __swab32s(&mea->mea_master); - CLASSERT(offsetof(typeof(*mea), mea_padding) != 0); + int i; + + __swab32s(&lmm1->lmv_magic); + __swab32s(&lmm1->lmv_stripe_count); + __swab32s(&lmm1->lmv_master_mdt_index); + __swab32s(&lmm1->lmv_hash_type); + __swab32s(&lmm1->lmv_layout_version); + for (i = 0; i < lmm1->lmv_stripe_count; i++) + lustre_swab_lu_fid(&lmm1->lmv_stripe_fids[i]); } +void lustre_swab_lmv_mds_md(union lmv_mds_md *lmm) +{ + switch (lmm->lmv_magic) { + case LMV_MAGIC_V1: + lustre_swab_lmv_mds_md_v1(&lmm->lmv_md_v1); + break; + default: + break; + } +} +EXPORT_SYMBOL(lustre_swab_lmv_mds_md); + +void lustre_swab_lmv_user_md(struct lmv_user_md *lum) +{ + __swab32s(&lum->lum_magic); + __swab32s(&lum->lum_stripe_count); + __swab32s(&lum->lum_stripe_offset); + __swab32s(&lum->lum_hash_type); + __swab32s(&lum->lum_type); + CLASSERT(offsetof(typeof(*lum), lum_padding1) != 0); +} +EXPORT_SYMBOL(lustre_swab_lmv_user_md); static void print_lum (struct lov_user_md *lum) { - CDEBUG(D_OTHER, "lov_user_md %p:\n", lum); - CDEBUG(D_OTHER, "\tlmm_magic: %#x\n", lum->lmm_magic); - CDEBUG(D_OTHER, "\tlmm_pattern: %#x\n", lum->lmm_pattern); - CDEBUG(D_OTHER, "\tlmm_object_id: "LPU64"\n", lum->lmm_object_id); - CDEBUG(D_OTHER, "\tlmm_object_gr: "LPU64"\n", lum->lmm_object_seq); - CDEBUG(D_OTHER, "\tlmm_stripe_size: %#x\n", lum->lmm_stripe_size); - CDEBUG(D_OTHER, "\tlmm_stripe_count: %#x\n", lum->lmm_stripe_count); - CDEBUG(D_OTHER, "\tlmm_stripe_offset/lmm_layout_gen: %#x\n", - lum->u.lum_stripe_offset); + CDEBUG(D_OTHER, "lov_user_md %p:\n", lum); + CDEBUG(D_OTHER, "\tlmm_magic: %#x\n", lum->lmm_magic); + CDEBUG(D_OTHER, "\tlmm_pattern: %#x\n", lum->lmm_pattern); + CDEBUG(D_OTHER, "\tlmm_object_id: "LPU64"\n", lmm_oi_id(&lum->lmm_oi)); + CDEBUG(D_OTHER, "\tlmm_object_gr: "LPU64"\n", lmm_oi_seq(&lum->lmm_oi)); + CDEBUG(D_OTHER, "\tlmm_stripe_size: %#x\n", lum->lmm_stripe_size); + CDEBUG(D_OTHER, "\tlmm_stripe_count: %#x\n", lum->lmm_stripe_count); + CDEBUG(D_OTHER, "\tlmm_stripe_offset/lmm_layout_gen: %#x\n", + lum->lmm_stripe_offset); +} + +static void lustre_swab_lmm_oi(struct ost_id *oi) +{ + __swab64s(&oi->oi.oi_id); + __swab64s(&oi->oi.oi_seq); } static void lustre_swab_lov_user_md_common(struct lov_user_md_v1 *lum) { - ENTRY; - __swab32s(&lum->lmm_magic); - __swab32s(&lum->lmm_pattern); - __swab64s(&lum->lmm_object_id); - __swab64s(&lum->lmm_object_seq); - __swab32s(&lum->lmm_stripe_size); - __swab16s(&lum->lmm_stripe_count); - __swab16s(&lum->u.lum_stripe_offset); - print_lum(lum); - EXIT; + ENTRY; + __swab32s(&lum->lmm_magic); + __swab32s(&lum->lmm_pattern); + lustre_swab_lmm_oi(&lum->lmm_oi); + __swab32s(&lum->lmm_stripe_size); + __swab16s(&lum->lmm_stripe_count); + __swab16s(&lum->lmm_stripe_offset); + print_lum(lum); + EXIT; } void lustre_swab_lov_user_md_v1(struct lov_user_md_v1 *lum) @@ -2175,16 +2212,15 @@ EXPORT_SYMBOL(lustre_swab_lov_user_md_v3); void lustre_swab_lov_mds_md(struct lov_mds_md *lmm) { - ENTRY; - CDEBUG(D_IOCTL, "swabbing lov_mds_md\n"); - __swab32s(&lmm->lmm_magic); - __swab32s(&lmm->lmm_pattern); - __swab64s(&lmm->lmm_object_id); - __swab64s(&lmm->lmm_object_seq); - __swab32s(&lmm->lmm_stripe_size); - __swab16s(&lmm->lmm_stripe_count); - __swab16s(&lmm->lmm_layout_gen); - EXIT; + ENTRY; + CDEBUG(D_IOCTL, "swabbing lov_mds_md\n"); + __swab32s(&lmm->lmm_magic); + __swab32s(&lmm->lmm_pattern); + lustre_swab_lmm_oi(&lmm->lmm_oi); + __swab32s(&lmm->lmm_stripe_size); + __swab16s(&lmm->lmm_stripe_count); + __swab16s(&lmm->lmm_layout_gen); + EXIT; } EXPORT_SYMBOL(lustre_swab_lov_mds_md); @@ -2194,8 +2230,7 @@ void lustre_swab_lov_user_md_objects(struct lov_user_ost_data *lod, int i; ENTRY; for (i = 0; i < stripe_count; i++) { - __swab64s(&(lod[i].l_object_id)); - __swab64s(&(lod[i].l_object_seq)); + lustre_swab_ost_id(&(lod[i].l_ost_oi)); __swab32s(&(lod[i].l_ost_gen)); __swab32s(&(lod[i].l_ost_idx)); } @@ -2268,16 +2303,6 @@ void lustre_swab_ldlm_reply (struct ldlm_reply *r) } EXPORT_SYMBOL(lustre_swab_ldlm_reply); -/* no one calls this */ -int llog_log_swabbed(struct llog_log_hdr *hdr) -{ - if (hdr->llh_hdr.lrh_type == __swab32(LLOG_HDR_MAGIC)) - return 1; - if (hdr->llh_hdr.lrh_type == LLOG_HDR_MAGIC) - return 0; - return -1; -} - void lustre_swab_quota_body(struct quota_body *b) { lustre_swab_lu_fid(&b->qb_fid); @@ -2291,32 +2316,30 @@ void lustre_swab_quota_body(struct quota_body *b) /* Dump functions */ void dump_ioo(struct obd_ioobj *ioo) { - CDEBUG(D_RPCTRACE, - "obd_ioobj: ioo_id="LPD64", ioo_seq="LPD64", ioo_type=%d, " - "ioo_bufct=%d\n", ioo->ioo_id, ioo->ioo_seq, ioo->ioo_type, - ioo->ioo_bufcnt); + CDEBUG(D_RPCTRACE, + "obd_ioobj: ioo_oid="DOSTID", ioo_max_brw=%#x, " + "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->offset, nb->len, nb->flags); + 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; + __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_seq = "LPD64"\n", oa->o_seq); - if (valid & OBD_MD_FLFID) - CDEBUG(D_RPCTRACE, "obdo: o_parent_seq = "LPX64"\n", - oa->o_parent_seq); + CDEBUG(D_RPCTRACE, "obdo: o_valid = %08x\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_parent_seq = "LPX64"\n", + oa->o_parent_seq); if (valid & OBD_MD_FLSIZE) CDEBUG(D_RPCTRACE, "obdo: o_size = "LPD64"\n", oa->o_size); if (valid & OBD_MD_FLMTIME) @@ -2429,30 +2452,31 @@ void _debug_req(struct ptlrpc_request *req, else if (req->rq_export && req->rq_export->exp_connection) nid = req->rq_export->exp_connection->c_peer.nid; - va_start(args, fmt); - libcfs_debug_vmsg2(msgdata, fmt, args, - " req@%p x"LPU64"/t"LPD64"("LPD64") o%d->%s@%s:%d/%d" - " lens %d/%d e %d to %d dl "CFS_TIME_T" ref %d " - "fl "REQ_FLAGS_FMT"/%x/%x rc %d/%d\n", - req, req->rq_xid, req->rq_transno, - req_ok ? lustre_msg_get_transno(req->rq_reqmsg) : 0, - req_ok ? lustre_msg_get_opc(req->rq_reqmsg) : -1, - req->rq_import ? - req->rq_import->imp_obd->obd_name : - req->rq_export ? - req->rq_export->exp_client_uuid.uuid : - "", - libcfs_nid2str(nid), - req->rq_request_portal, req->rq_reply_portal, - req->rq_reqlen, req->rq_replen, - req->rq_early_count, req->rq_timedout, - req->rq_deadline, - cfs_atomic_read(&req->rq_refcount), - DEBUG_REQ_FLAGS(req), - req_ok ? lustre_msg_get_flags(req->rq_reqmsg) : -1, - rep_ok ? lustre_msg_get_flags(req->rq_repmsg) : -1, - req->rq_status, - rep_ok ? lustre_msg_get_status(req->rq_repmsg) : -1); + va_start(args, fmt); + libcfs_debug_vmsg2(msgdata, fmt, args, + " req@%p x"LPU64"/t"LPD64"("LPD64") o%d->%s@%s:%d/%d" + " lens %d/%d e %d to %d dl "CFS_TIME_T" ref %d " + "fl "REQ_FLAGS_FMT"/%x/%x rc %d/%d\n", + req, req->rq_xid, req->rq_transno, + req_ok ? lustre_msg_get_transno(req->rq_reqmsg) : 0, + req_ok ? lustre_msg_get_opc(req->rq_reqmsg) : -1, + req->rq_import ? + req->rq_import->imp_obd->obd_name : + req->rq_export ? + req->rq_export->exp_client_uuid.uuid : + "", + libcfs_nid2str(nid), + 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_ok ? lustre_msg_get_flags(req->rq_reqmsg) : -1, + rep_ok ? lustre_msg_get_flags(req->rq_repmsg) : -1, + req->rq_status, + rep_ok ? lustre_msg_get_status(req->rq_repmsg) : -1); + va_end(args); } EXPORT_SYMBOL(_debug_req); @@ -2544,21 +2568,119 @@ void lustre_swab_hsm_request(struct hsm_request *hr) } EXPORT_SYMBOL(lustre_swab_hsm_request); -void lustre_swab_update_buf(struct update_buf *ub) +void lustre_swab_object_update(struct object_update *ou) +{ + struct object_update_param *param; + int i; + + __swab16s(&ou->ou_type); + __swab16s(&ou->ou_params_count); + __swab32s(&ou->ou_master_index); + __swab32s(&ou->ou_flags); + __swab32s(&ou->ou_padding1); + __swab64s(&ou->ou_batchid); + lustre_swab_lu_fid(&ou->ou_fid); + param = &ou->ou_params[0]; + for (i = 0; i < ou->ou_params_count; i++) { + __swab16s(¶m->oup_len); + __swab16s(¶m->oup_padding); + __swab32s(¶m->oup_padding2); + param = (struct object_update_param *)((char *)param + + object_update_param_size(param)); + } +} +EXPORT_SYMBOL(lustre_swab_object_update); + +void lustre_swab_object_update_request(struct object_update_request *our) +{ + int i; + __swab32s(&our->ourq_magic); + __swab16s(&our->ourq_count); + __swab16s(&our->ourq_padding); + for (i = 0; i < our->ourq_count; i++) { + struct object_update *ou; + + ou = object_update_request_get(our, i, NULL); + if (ou == NULL) + return; + lustre_swab_object_update(ou); + } +} +EXPORT_SYMBOL(lustre_swab_object_update_request); + +void lustre_swab_object_update_result(struct object_update_result *our) { - __swab32s(&ub->ub_magic); - __swab32s(&ub->ub_count); + __swab32s(&our->our_rc); + __swab16s(&our->our_datalen); + __swab16s(&our->our_padding); } -EXPORT_SYMBOL(lustre_swab_update_buf); +EXPORT_SYMBOL(lustre_swab_object_update_result); -void lustre_swab_update_reply_buf(struct update_reply *ur) +void lustre_swab_object_update_reply(struct object_update_reply *our) { int i; - __swab32s(&ur->ur_version); - __swab32s(&ur->ur_count); - for (i = 0; i < ur->ur_count; i++) - __swab32s(&ur->ur_lens[i]); + __swab32s(&our->ourp_magic); + __swab16s(&our->ourp_count); + __swab16s(&our->ourp_padding); + for (i = 0; i < our->ourp_count; i++) { + struct object_update_result *ourp; + + __swab16s(&our->ourp_lens[i]); + ourp = object_update_result_get(our, i, NULL); + if (ourp == NULL) + return; + 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) +{ + __swab32s(&lr->lr_event); + __swab32s(&lr->lr_index); + __swab32s(&lr->lr_flags); + __swab32s(&lr->lr_valid); + __swab32s(&lr->lr_speed); + __swab16s(&lr->lr_version); + __swab16s(&lr->lr_active); + __swab16s(&lr->lr_param); + __swab16s(&lr->lr_async_windows); + CLASSERT(offsetof(typeof(*lr), lr_padding_1) != 0); + lustre_swab_lu_fid(&lr->lr_fid); + lustre_swab_lu_fid(&lr->lr_fid2); + lustre_swab_lu_fid(&lr->lr_fid3); + CLASSERT(offsetof(typeof(*lr), lr_padding_2) != 0); + CLASSERT(offsetof(typeof(*lr), lr_padding_3) != 0); +} +EXPORT_SYMBOL(lustre_swab_lfsck_request); + +void lustre_swab_lfsck_reply(struct lfsck_reply *lr) +{ + __swab32s(&lr->lr_status); + CLASSERT(offsetof(typeof(*lr), lr_padding_1) != 0); + CLASSERT(offsetof(typeof(*lr), lr_padding_2) != 0); } -EXPORT_SYMBOL(lustre_swab_update_reply_buf); +EXPORT_SYMBOL(lustre_swab_lfsck_reply); +void lustre_swab_orphan_ent(struct lu_orphan_ent *ent) +{ + lustre_swab_lu_fid(&ent->loe_key); + lustre_swab_lu_fid(&ent->loe_rec.lor_fid); + __swab32s(&ent->loe_rec.lor_uid); + __swab32s(&ent->loe_rec.lor_gid); +} +EXPORT_SYMBOL(lustre_swab_orphan_ent);