X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fptlrpc%2Fpack_generic.c;h=dcab780fb7f16a90a05ea028263e29679acc2225;hp=262ee3ba4ca112295e5e0f9ec2f32bc2ce4f3149;hb=807a40c5678109087e2c8759bd86253034804c8d;hpb=b2bb3b247d1dc75e25f1b5c14a333905909b5e70 diff --git a/lustre/ptlrpc/pack_generic.c b/lustre/ptlrpc/pack_generic.c index 262ee3b..dcab780f 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, 2013, Intel Corporation. + * Copyright (c) 2011, 2014, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -43,9 +43,6 @@ */ #define DEBUG_SUBSYSTEM S_RPC -#ifndef __KERNEL__ -# include -#endif #include @@ -54,38 +51,37 @@ #include #include #include -#include -static inline int lustre_msg_hdr_size_v2(int count) +#include "ptlrpc_internal.h" + +static inline __u32 lustre_msg_hdr_size_v2(__u32 count) { return cfs_size_round(offsetof(struct lustre_msg_v2, lm_buflens[count])); } -int lustre_msg_hdr_size(__u32 magic, int count) +__u32 lustre_msg_hdr_size(__u32 magic, __u32 count) { switch (magic) { case LUSTRE_MSG_MAGIC_V2: return lustre_msg_hdr_size_v2(count); default: LASSERTF(0, "incorrect message magic: %08x\n", magic); - return -EINVAL; + return 0; } } -EXPORT_SYMBOL(lustre_msg_hdr_size); void ptlrpc_buf_set_swabbed(struct ptlrpc_request *req, const int inout, - int index) + __u32 index) { if (inout) lustre_set_req_swabbed(req, 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, - int index) + __u32 index) { if (inout) return (ptlrpc_req_need_swab(req) && @@ -94,50 +90,9 @@ int ptlrpc_buf_need_swab(struct ptlrpc_request *req, const int inout, return (ptlrpc_rep_need_swab(req) && !lustre_rep_swabbed(req, index)); } -EXPORT_SYMBOL(ptlrpc_buf_need_swab); - -/* This enlarges the req buffer of request \a req to the next power of 2 - * multiple of \a newbuf_size. - * Returns zero on success or ENOMEM if it failed to allocate the new buffer. - * - * This is used in the reply path on the client if the server responded - * with a bigger message than we expected so we can save the new state for - * a possible future replay where we'll need to present this new info - * (usually striping that's not available at create time) */ -int ptlrpc_enlarge_req_buffer(struct ptlrpc_request *req, int newbuf_size) -{ - struct lustre_msg *newbuf; - - newbuf_size = size_roundup_power2(newbuf_size); - - OBD_ALLOC_LARGE(newbuf, newbuf_size); - if (newbuf == NULL) - return -ENOMEM; - - /* Must lock this, so that otherwise unprotected change of - * rq_reqmsg is not racing with parallel processing of - * imp_replay_list traversing threads. See LU-3333 - * This is a bandaid at best, we really need to deal with this - * in request enlarging code before unpacking what's already - * there */ - if (req->rq_import) - spin_lock(&req->rq_import->imp_lock); - - memcpy(newbuf, req->rq_reqbuf, req->rq_reqbuf_len); - - OBD_FREE_LARGE(req->rq_reqbuf, req->rq_reqbuf_len); - req->rq_reqbuf = newbuf; - req->rq_reqbuf_len = newbuf_size; - req->rq_reqmsg = lustre_msg_buf(req->rq_reqbuf, 1, 0); - - if (req->rq_import) - spin_unlock(&req->rq_import->imp_lock); - - return 0; -} static inline int lustre_msg_check_version_v2(struct lustre_msg_v2 *msg, - __u32 version) + __u32 version) { __u32 ver = lustre_msg_get_version(msg); return (ver & LUSTRE_VERSION_MASK) != version; @@ -156,12 +111,11 @@ int lustre_msg_check_version(struct lustre_msg *msg, __u32 version) return 0; } } -EXPORT_SYMBOL(lustre_msg_check_version); /* early reply size */ -int lustre_msg_early_size() +__u32 lustre_msg_early_size() { - static int size = 0; + static __u32 size; if (!size) { /* Always reply old ptlrpc_body_v2 to keep interoprability * with the old client (< 2.3) which doesn't have pb_jobid @@ -173,13 +127,13 @@ int lustre_msg_early_size() __u32 pblen = sizeof(struct ptlrpc_body_v2); size = lustre_msg_size(LUSTRE_MSG_MAGIC_V2, 1, &pblen); } - return size; + return size; } EXPORT_SYMBOL(lustre_msg_early_size); -int lustre_msg_size_v2(int count, __u32 *lengths) +__u32 lustre_msg_size_v2(int count, __u32 *lengths) { - int size; + __u32 size; int i; size = lustre_msg_hdr_size_v2(count); @@ -196,7 +150,7 @@ EXPORT_SYMBOL(lustre_msg_size_v2); * in the form of a v2 request. If this is a connection to a v1 * target then the first buffer will be stripped because the ptlrpc * data is part of the lustre_msg_v1 header. b=14043 */ -int lustre_msg_size(__u32 magic, int count, __u32 *lens) +__u32 lustre_msg_size(__u32 magic, int count, __u32 *lens) { __u32 size[] = { sizeof(struct ptlrpc_body) }; @@ -213,14 +167,13 @@ int lustre_msg_size(__u32 magic, int count, __u32 *lens) return lustre_msg_size_v2(count, lens); default: LASSERTF(0, "incorrect message magic: %08x\n", magic); - return -EINVAL; + 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. */ -int lustre_packed_msg_size(struct lustre_msg *msg) +__u32 lustre_packed_msg_size(struct lustre_msg *msg) { switch (msg->lm_magic) { case LUSTRE_MSG_MAGIC_V2: @@ -230,7 +183,6 @@ int lustre_packed_msg_size(struct lustre_msg *msg) return 0; } } -EXPORT_SYMBOL(lustre_packed_msg_size); void lustre_init_msg_v2(struct lustre_msg_v2 *msg, int count, __u32 *lens, char **bufs) @@ -298,23 +250,23 @@ int lustre_pack_request(struct ptlrpc_request *req, __u32 magic, int count, return -EINVAL; } } -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 @@ -330,7 +282,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; @@ -339,15 +291,15 @@ 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); @@ -364,7 +316,7 @@ 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); wake_up(&svcpt->scp_rep_waitq); } @@ -394,9 +346,9 @@ int lustre_pack_reply_v2(struct ptlrpc_request *req, int count, 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; @@ -440,7 +392,6 @@ int lustre_pack_reply_flags(struct ptlrpc_request *req, int count, __u32 *lens, 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) @@ -449,12 +400,11 @@ int lustre_pack_reply(struct ptlrpc_request *req, int count, __u32 *lens, } EXPORT_SYMBOL(lustre_pack_reply); -void *lustre_msg_buf_v2(struct lustre_msg_v2 *m, int n, int min_size) +void *lustre_msg_buf_v2(struct lustre_msg_v2 *m, __u32 n, __u32 min_size) { - int i, offset, buflen, bufcount; + __u32 i, offset, buflen, bufcount; LASSERT(m != NULL); - LASSERT(n >= 0); bufcount = m->lm_bufcount; if (unlikely(n >= bufcount)) { @@ -478,7 +428,7 @@ void *lustre_msg_buf_v2(struct lustre_msg_v2 *m, int n, int min_size) return (char *)m + offset; } -void *lustre_msg_buf(struct lustre_msg *m, int n, int min_size) +void *lustre_msg_buf(struct lustre_msg *m, __u32 n, __u32 min_size) { switch (m->lm_magic) { case LUSTRE_MSG_MAGIC_V2: @@ -490,8 +440,8 @@ void *lustre_msg_buf(struct lustre_msg *m, int n, int min_size) } EXPORT_SYMBOL(lustre_msg_buf); -int lustre_shrink_msg_v2(struct lustre_msg_v2 *msg, int segment, - unsigned int newlen, int move_data) +static int lustre_shrink_msg_v2(struct lustre_msg_v2 *msg, __u32 segment, + unsigned int newlen, int move_data) { char *tail = NULL, *newpos; int tail_len = 0, n; @@ -559,12 +509,11 @@ void lustre_free_reply_state(struct ptlrpc_reply_state *rs) 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(list_empty(&rs->rs_exp_list)); + LASSERT(list_empty(&rs->rs_obd_list)); sptlrpc_svc_free_rs(rs); } -EXPORT_SYMBOL(lustre_free_reply_state); static int lustre_unpack_msg_v2(struct lustre_msg_v2 *m, int len) { @@ -652,7 +601,6 @@ int ptlrpc_unpack_req_msg(struct ptlrpc_request *req, int len) } return rc; } -EXPORT_SYMBOL(ptlrpc_unpack_req_msg); int ptlrpc_unpack_rep_msg(struct ptlrpc_request *req, int len) { @@ -664,7 +612,6 @@ 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) @@ -717,7 +664,7 @@ int lustre_unpack_rep_ptlrpc_body(struct ptlrpc_request *req, int offset) } } -static inline int lustre_msg_buflen_v2(struct lustre_msg_v2 *m, int n) +static inline __u32 lustre_msg_buflen_v2(struct lustre_msg_v2 *m, __u32 n) { if (n >= m->lm_bufcount) return 0; @@ -732,20 +679,20 @@ static inline int lustre_msg_buflen_v2(struct lustre_msg_v2 *m, int n) * * returns zero for non-existent message indices */ -int lustre_msg_buflen(struct lustre_msg *m, int n) +__u32 lustre_msg_buflen(struct lustre_msg *m, __u32 n) { switch (m->lm_magic) { case LUSTRE_MSG_MAGIC_V2: return lustre_msg_buflen_v2(m, n); default: CERROR("incorrect message magic: %08x\n", m->lm_magic); - return -EINVAL; + return 0; } } EXPORT_SYMBOL(lustre_msg_buflen); static inline void -lustre_msg_set_buflen_v2(struct lustre_msg_v2 *m, int n, int len) +lustre_msg_set_buflen_v2(struct lustre_msg_v2 *m, __u32 n, __u32 len) { if (n >= m->lm_bufcount) LBUG(); @@ -753,7 +700,7 @@ lustre_msg_set_buflen_v2(struct lustre_msg_v2 *m, int n, int len) m->lm_buflens[n] = len; } -void lustre_msg_set_buflen(struct lustre_msg *m, int n, int len) +void lustre_msg_set_buflen(struct lustre_msg *m, __u32 n, __u32 len) { switch (m->lm_magic) { case LUSTRE_MSG_MAGIC_V2: @@ -764,27 +711,24 @@ void lustre_msg_set_buflen(struct lustre_msg *m, int n, int len) } } -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). */ -int lustre_msg_bufcount(struct lustre_msg *m) +__u32 lustre_msg_bufcount(struct lustre_msg *m) { switch (m->lm_magic) { case LUSTRE_MSG_MAGIC_V2: return m->lm_bufcount; default: CERROR("incorrect message magic: %08x\n", m->lm_magic); - return -EINVAL; + return 0; } } -EXPORT_SYMBOL(lustre_msg_bufcount); -char *lustre_msg_string(struct lustre_msg *m, int index, int max_len) +char *lustre_msg_string(struct lustre_msg *m, __u32 index, __u32 max_len) { - /* max_len == 0 means the string should fill the buffer */ - char *str; - int slen, blen; + /* max_len == 0 means the string should fill the buffer */ + char *str; + __u32 slen, blen; switch (m->lm_magic) { case LUSTRE_MSG_MAGIC_V2: @@ -824,11 +768,10 @@ char *lustre_msg_string(struct lustre_msg *m, int index, int 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, int index, - int min_size, void *swabber) +static inline void *__lustre_swab_buf(struct lustre_msg *msg, __u32 index, + __u32 min_size, void *swabber) { void *ptr = NULL; @@ -901,7 +844,7 @@ __u32 lustre_msg_get_flags(struct lustre_msg *msg) } EXPORT_SYMBOL(lustre_msg_get_flags); -void lustre_msg_add_flags(struct lustre_msg *msg, int flags) +void lustre_msg_add_flags(struct lustre_msg *msg, __u32 flags) { switch (msg->lm_magic) { case LUSTRE_MSG_MAGIC_V2: { @@ -916,7 +859,7 @@ void lustre_msg_add_flags(struct lustre_msg *msg, int flags) } EXPORT_SYMBOL(lustre_msg_add_flags); -void lustre_msg_set_flags(struct lustre_msg *msg, int flags) +void lustre_msg_set_flags(struct lustre_msg *msg, __u32 flags) { switch (msg->lm_magic) { case LUSTRE_MSG_MAGIC_V2: { @@ -929,9 +872,8 @@ void lustre_msg_set_flags(struct lustre_msg *msg, int flags) 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, int flags) +void lustre_msg_clear_flags(struct lustre_msg *msg, __u32 flags) { switch (msg->lm_magic) { case LUSTRE_MSG_MAGIC_V2: { @@ -961,9 +903,8 @@ __u32 lustre_msg_get_op_flags(struct lustre_msg *msg) return 0; } } -EXPORT_SYMBOL(lustre_msg_get_op_flags); -void lustre_msg_add_op_flags(struct lustre_msg *msg, int flags) +void lustre_msg_add_op_flags(struct lustre_msg *msg, __u32 flags) { switch (msg->lm_magic) { case LUSTRE_MSG_MAGIC_V2: { @@ -978,7 +919,7 @@ void lustre_msg_add_op_flags(struct lustre_msg *msg, int flags) } EXPORT_SYMBOL(lustre_msg_add_op_flags); -void lustre_msg_set_op_flags(struct lustre_msg *msg, int flags) +void lustre_msg_set_op_flags(struct lustre_msg *msg, __u32 flags) { switch (msg->lm_magic) { case LUSTRE_MSG_MAGIC_V2: { @@ -991,7 +932,6 @@ void lustre_msg_set_op_flags(struct lustre_msg *msg, int 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) { @@ -1009,7 +949,6 @@ 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) { @@ -1045,9 +984,8 @@ __u32 lustre_msg_get_version(struct lustre_msg *msg) return 0; } } -EXPORT_SYMBOL(lustre_msg_get_version); -void lustre_msg_add_version(struct lustre_msg *msg, int version) +void lustre_msg_add_version(struct lustre_msg *msg, __u32 version) { switch (msg->lm_magic) { case LUSTRE_MSG_MAGIC_V2: { @@ -1060,7 +998,6 @@ void lustre_msg_add_version(struct lustre_msg *msg, int 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) { @@ -1097,7 +1034,6 @@ __u64 lustre_msg_get_last_xid(struct lustre_msg *msg) return 0; } } -EXPORT_SYMBOL(lustre_msg_get_last_xid); __u64 lustre_msg_get_last_committed(struct lustre_msg *msg) { @@ -1190,7 +1126,6 @@ __u64 lustre_msg_get_slv(struct lustre_msg *msg) return -EINVAL; } } -EXPORT_SYMBOL(lustre_msg_get_slv); void lustre_msg_set_slv(struct lustre_msg *msg, __u64 slv) @@ -1210,7 +1145,6 @@ 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) { @@ -1228,7 +1162,6 @@ __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) @@ -1248,7 +1181,6 @@ 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) { @@ -1278,7 +1210,6 @@ int lustre_msg_is_v1(struct lustre_msg *msg) return 0; } } -EXPORT_SYMBOL(lustre_msg_is_v1); __u32 lustre_msg_get_magic(struct lustre_msg *msg) { @@ -1290,7 +1221,6 @@ __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) { @@ -1367,7 +1297,7 @@ __u32 lustre_msg_get_cksum(struct lustre_msg *msg) } } -#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 7, 50, 0) +#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 7, 53, 0) /* * In 1.6 and 1.8 the checksum was computed only on struct ptlrpc_body as * it was in 1.6 (88 bytes, smaller than the full size in 1.8). It makes @@ -1378,32 +1308,26 @@ __u32 lustre_msg_get_cksum(struct lustre_msg *msg) __u32 lustre_msg_calc_cksum(struct lustre_msg *msg, int compat18) #else -# warning "remove checksum compatibility support for b1_8" __u32 lustre_msg_calc_cksum(struct lustre_msg *msg) #endif { switch (msg->lm_magic) { case LUSTRE_MSG_MAGIC_V2: { struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg); -#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 7, 50, 0) - __u32 crc; - unsigned int hsize = 4; +#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 7, 53, 0) __u32 len = compat18 ? ptlrpc_body_cksum_size_compat18 : lustre_msg_buflen(msg, MSG_PTLRPC_BODY_OFF); - LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg); - cfs_crypto_hash_digest(CFS_HASH_ALG_CRC32, (unsigned char *)pb, - len, NULL, 0, (unsigned char *)&crc, - &hsize); - return crc; #else -# warning "remove checksum compatibility support for b1_8" - __u32 crc; + __u32 len = lustre_msg_buflen(msg, MSG_PTLRPC_BODY_OFF); +#endif unsigned int hsize = 4; + __u32 crc; + + LASSERTF(pb != NULL, "invalid msg %p: no ptlrpc body!\n", msg); cfs_crypto_hash_digest(CFS_HASH_ALG_CRC32, (unsigned char *)pb, - lustre_msg_buflen(msg, MSG_PTLRPC_BODY_OFF), - NULL, 0, (unsigned char *)&crc, &hsize); + len, NULL, 0, (unsigned char *)&crc, + &hsize); return crc; -#endif } default: CERROR("incorrect message magic: %08x\n", msg->lm_magic); @@ -1424,7 +1348,6 @@ void lustre_msg_set_handle(struct lustre_msg *msg, struct lustre_handle *handle) 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) { @@ -1439,7 +1362,6 @@ 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) { @@ -1454,7 +1376,6 @@ 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) { @@ -1469,7 +1390,6 @@ void lustre_msg_set_last_xid(struct lustre_msg *msg, __u64 last_xid) LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic); } } -EXPORT_SYMBOL(lustre_msg_set_last_xid); void lustre_msg_set_last_committed(struct lustre_msg *msg, __u64 last_committed) { @@ -1484,7 +1404,6 @@ void lustre_msg_set_last_committed(struct lustre_msg *msg, __u64 last_committed) 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) { @@ -1549,7 +1468,6 @@ void lustre_msg_set_conn_cnt(struct lustre_msg *msg, __u32 conn_cnt) 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) { @@ -1603,7 +1521,7 @@ void lustre_msg_set_jobid(struct lustre_msg *msg, char *jobid) LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg); if (jobid != NULL) - memcpy(pb->pb_jobid, jobid, JOBSTATS_JOBID_SIZE); + memcpy(pb->pb_jobid, jobid, LUSTRE_JOBID_SIZE); else if (pb->pb_jobid[0] == '\0') lustre_get_jobid(pb->pb_jobid); return; @@ -1645,7 +1563,6 @@ void ptlrpc_req_set_repsize(struct ptlrpc_request *req, int count, __u32 *lens) 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. @@ -1653,10 +1570,10 @@ EXPORT_SYMBOL(ptlrpc_req_set_repsize); * 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) + int opcode, int version, + size_t keylen, void *key, + size_t vallen, void *val, + struct ptlrpc_request_set *set) { struct ptlrpc_request *req; char *tmp; @@ -1728,7 +1645,6 @@ void lustre_swab_ptlrpc_body(struct ptlrpc_body *b) * 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) { @@ -1754,6 +1670,9 @@ 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); @@ -1828,7 +1747,6 @@ void lustre_swab_obd_statfs (struct obd_statfs *os) 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) { @@ -1836,33 +1754,28 @@ 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) +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); 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(obd_id *id) +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) { @@ -1911,37 +1824,36 @@ 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); + lustre_swab_lu_fid(&b->mbo_fid1); + lustre_swab_lu_fid(&b->mbo_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); - __swab64s(&b->t_state); - __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); -} -EXPORT_SYMBOL(lustre_swab_mdt_body); + __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); +} void lustre_swab_mdt_ioepoch (struct mdt_ioepoch *b) { @@ -1950,7 +1862,6 @@ 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) { @@ -1965,11 +1876,10 @@ 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) { - int i; + __u8 i; __swab64s(&entry->mne_version); __swab32s(&entry->mne_instance); @@ -1996,14 +1906,12 @@ void lustre_swab_mgs_config_body(struct mgs_config_body *body) __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) { @@ -2036,7 +1944,6 @@ void lustre_swab_obd_quotactl (struct obd_quotactl *q) 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) { @@ -2060,7 +1967,7 @@ void lustre_swab_fid2path(struct getinfo_fid2path *gf) } EXPORT_SYMBOL(lustre_swab_fid2path); -void lustre_swab_fiemap_extent(struct ll_fiemap_extent *fm_extent) +static void lustre_swab_fiemap_extent(struct ll_fiemap_extent *fm_extent) { __swab64s(&fm_extent->fe_logical); __swab64s(&fm_extent->fe_physical); @@ -2071,7 +1978,7 @@ void lustre_swab_fiemap_extent(struct ll_fiemap_extent *fm_extent) void lustre_swab_fiemap(struct ll_user_fiemap *fiemap) { - int i; + __u32 i; __swab64s(&fiemap->fm_start); __swab64s(&fiemap->fm_length); @@ -2083,7 +1990,6 @@ void lustre_swab_fiemap(struct ll_user_fiemap *fiemap) 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) { @@ -2135,7 +2041,6 @@ void lustre_swab_mdt_rec_reint (struct mdt_rec_reint *rr) CLASSERT(offsetof(typeof(*rr), rr_padding_4) != 0); }; -EXPORT_SYMBOL(lustre_swab_mdt_rec_reint); void lustre_swab_lov_desc (struct lov_desc *ld) { @@ -2188,34 +2093,47 @@ void lustre_swab_lmv_mds_md(union lmv_mds_md *lmm) void lustre_swab_lmv_user_md(struct lmv_user_md *lum) { - int i; - __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); - for (i = 0; i < lum->lum_stripe_count; i++) { - __swab32s(&lum->lum_objects[i].lum_mds); - lustre_swab_lu_fid(&lum->lum_objects[i].lum_fid); - } - } EXPORT_SYMBOL(lustre_swab_lmv_user_md); -static void print_lum (struct lov_user_md *lum) +void lustre_print_user_md(unsigned int lvl, struct lov_user_md *lum, + const char *msg) { - 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); + if (likely(!cfs_cdebug_show(lvl, DEBUG_SUBSYSTEM))) + return; + + CDEBUG(lvl, "%s lov_user_md %p:\n", msg, lum); + CDEBUG(lvl, "\tlmm_magic: %#x\n", lum->lmm_magic); + CDEBUG(lvl, "\tlmm_pattern: %#x\n", lum->lmm_pattern); + CDEBUG(lvl, "\tlmm_object_id: "LPU64"\n", lmm_oi_id(&lum->lmm_oi)); + CDEBUG(lvl, "\tlmm_object_gr: "LPU64"\n", lmm_oi_seq(&lum->lmm_oi)); + CDEBUG(lvl, "\tlmm_stripe_size: %#x\n", lum->lmm_stripe_size); + CDEBUG(lvl, "\tlmm_stripe_count: %#x\n", lum->lmm_stripe_count); + CDEBUG(lvl, "\tlmm_stripe_offset/lmm_layout_gen: %#x\n", + lum->lmm_stripe_offset); + if (lum->lmm_magic == LOV_USER_MAGIC_V3) { + struct lov_user_md_v3 *v3 = (void *)lum; + CDEBUG(lvl, "\tlmm_pool_name: %s\n", v3->lmm_pool_name); + } + if (lum->lmm_magic == LOV_USER_MAGIC_SPECIFIC) { + struct lov_user_md_v3 *v3 = (void *)lum; + int i; + + if (v3->lmm_pool_name[0] != '\0') + CDEBUG(lvl, "\tlmm_pool_name: %s\n", v3->lmm_pool_name); + + CDEBUG(lvl, "\ttarget list:\n"); + for (i = 0; i < v3->lmm_stripe_count; i++) + CDEBUG(lvl, "\t\t%u\n", v3->lmm_objects[i].l_ost_idx); + } } +EXPORT_SYMBOL(lustre_print_user_md); static void lustre_swab_lmm_oi(struct ost_id *oi) { @@ -2232,7 +2150,6 @@ static void lustre_swab_lov_user_md_common(struct lov_user_md_v1 *lum) __swab32s(&lum->lmm_stripe_size); __swab16s(&lum->lmm_stripe_count); __swab16s(&lum->lmm_stripe_offset); - print_lum(lum); EXIT; } @@ -2267,7 +2184,6 @@ void lustre_swab_lov_mds_md(struct lov_mds_md *lmm) __swab16s(&lmm->lmm_layout_gen); EXIT; } -EXPORT_SYMBOL(lustre_swab_lov_mds_md); void lustre_swab_lov_user_md_objects(struct lov_user_ost_data *lod, int stripe_count) @@ -2290,7 +2206,6 @@ void lustre_swab_ldlm_res_id (struct ldlm_res_id *id) 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) { @@ -2303,13 +2218,11 @@ 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) { @@ -2317,7 +2230,6 @@ 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) { @@ -2326,7 +2238,6 @@ 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) { @@ -2335,7 +2246,6 @@ 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) { @@ -2346,7 +2256,6 @@ 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) { @@ -2366,20 +2275,18 @@ void dump_ioo(struct obd_ioobj *ioo) "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; + 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) @@ -2437,19 +2344,16 @@ void dump_obdo(struct obdo *oa) 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) { @@ -2536,7 +2440,6 @@ void lustre_swab_lustre_capa(struct lustre_capa *c) __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) { @@ -2544,14 +2447,12 @@ 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) { @@ -2560,9 +2461,8 @@ 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); -void lustre_swab_hsm_extent(struct hsm_extent *extent) +static void lustre_swab_hsm_extent(struct hsm_extent *extent) { __swab64s(&extent->offset); __swab64s(&extent->length); @@ -2574,14 +2474,12 @@ void lustre_swab_hsm_current_action(struct hsm_current_action *action) __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) { @@ -2590,7 +2488,6 @@ 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) { @@ -2601,7 +2498,6 @@ 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) { @@ -2611,12 +2507,11 @@ 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) { struct object_update_param *param; - int i; + size_t i; __swab16s(&ou->ou_type); __swab16s(&ou->ou_params_count); @@ -2634,11 +2529,10 @@ 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) { - int i; + size_t i; __swab32s(&our->ourq_magic); __swab16s(&our->ourq_count); __swab16s(&our->ourq_padding); @@ -2651,7 +2545,6 @@ 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) { @@ -2659,11 +2552,10 @@ 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) { - int i; + size_t i; __swab32s(&our->ourp_magic); __swab16s(&our->ourp_count); @@ -2678,20 +2570,17 @@ 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) { @@ -2704,14 +2593,13 @@ void lustre_swab_lfsck_request(struct lfsck_request *lr) __swab16s(&lr->lr_active); __swab16s(&lr->lr_param); __swab16s(&lr->lr_async_windows); - CLASSERT(offsetof(typeof(*lr), lr_padding_1) != 0); + __swab32s(&lr->lr_flags); 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_1) != 0); 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) { @@ -2719,7 +2607,6 @@ 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) {