From 39cecbf532a266aac8caea8b215dcec281a31d73 Mon Sep 17 00:00:00 2001 From: Liu Xuezhao Date: Sun, 15 Jul 2012 22:49:48 +0800 Subject: [PATCH] LU-1347 ptlrpc: makes EXPORT_SYMBOL follows function body Makes EXPORT_SYMBOL macros immediately follow the function body, to follow normal Linux kernel coding style. Signed-off-by: Liu Xuezhao Change-Id: Ifbebd942033d65382f443edeb9b6fb5100096a47 Reviewed-on: http://review.whamcloud.com/2670 Tested-by: Hudson Tested-by: Maloo Reviewed-by: Andreas Dilger Reviewed-by: Peng Tao Reviewed-by: Yang Sheng Reviewed-by: Oleg Drokin --- lustre/ptlrpc/client.c | 41 +++++++++ lustre/ptlrpc/connection.c | 5 ++ lustre/ptlrpc/import.c | 6 ++ lustre/ptlrpc/llog_client.c | 1 + lustre/ptlrpc/llog_server.c | 6 ++ lustre/ptlrpc/niobuf.c | 10 +++ lustre/ptlrpc/pack_generic.c | 87 ++++++++++++++++++- lustre/ptlrpc/pinger.c | 5 ++ lustre/ptlrpc/ptlrpc_module.c | 198 ------------------------------------------ lustre/ptlrpc/ptlrpcd.c | 4 + lustre/ptlrpc/recover.c | 4 + lustre/ptlrpc/service.c | 9 ++ 12 files changed, 177 insertions(+), 199 deletions(-) diff --git a/lustre/ptlrpc/client.c b/lustre/ptlrpc/client.c index aefce46..8305110 100644 --- a/lustre/ptlrpc/client.c +++ b/lustre/ptlrpc/client.c @@ -64,6 +64,7 @@ void ptlrpc_init_client(int req_portal, int rep_portal, char *name, cl->cli_reply_portal = rep_portal; cl->cli_name = name; } +EXPORT_SYMBOL(ptlrpc_init_client); /** * Return PortalRPC connection for remore uud \a uuid @@ -91,6 +92,7 @@ struct ptlrpc_connection *ptlrpc_uuid_to_connection(struct obd_uuid *uuid) return c; } +EXPORT_SYMBOL(ptlrpc_uuid_to_connection); /** * Allocate and initialize new bulk descriptor @@ -146,6 +148,7 @@ struct ptlrpc_bulk_desc *ptlrpc_prep_bulk_imp(struct ptlrpc_request *req, return desc; } +EXPORT_SYMBOL(ptlrpc_prep_bulk_imp); /** * Add a page \a page to the bulk descriptor \a desc. @@ -166,6 +169,7 @@ void ptlrpc_prep_bulk_page(struct ptlrpc_bulk_desc *desc, cfs_page_pin(page); ptlrpc_add_bulk_page(desc, page, pageoffset, len); } +EXPORT_SYMBOL(ptlrpc_prep_bulk_page); /** * Uninitialize and free bulk descriptor \a desc. @@ -195,6 +199,7 @@ void ptlrpc_free_bulk(struct ptlrpc_bulk_desc *desc) bd_iov[desc->bd_max_iov])); EXIT; } +EXPORT_SYMBOL(ptlrpc_free_bulk); /** * Set server timelimit for this req, i.e. how long are we willing to wait @@ -233,6 +238,7 @@ void ptlrpc_at_set_req_timeout(struct ptlrpc_request *req) reqmsg*/ lustre_msg_set_timeout(req->rq_reqmsg, req->rq_timeout); } +EXPORT_SYMBOL(ptlrpc_at_set_req_timeout); /* Adjust max service estimate based on server value */ static void ptlrpc_at_adj_service(struct ptlrpc_request *req, @@ -387,6 +393,7 @@ void ptlrpc_free_rq_pool(struct ptlrpc_request_pool *pool) cfs_spin_unlock(&pool->prp_lock); OBD_FREE(pool, sizeof(*pool)); } +EXPORT_SYMBOL(ptlrpc_free_rq_pool); /** * Allocates, initializes and adds \a num_rq requests to the pool \a pool @@ -428,6 +435,7 @@ void ptlrpc_add_rqs_to_pool(struct ptlrpc_request_pool *pool, int num_rq) cfs_spin_unlock(&pool->prp_lock); return; } +EXPORT_SYMBOL(ptlrpc_add_rqs_to_pool); /** * Create and initialize new request pool with given attributes: @@ -464,6 +472,7 @@ ptlrpc_init_rq_pool(int num_rq, int msgsize, } return pool; } +EXPORT_SYMBOL(ptlrpc_init_rq_pool); /** * Fetches one request from pool \a pool @@ -633,6 +642,7 @@ int ptlrpc_request_pack(struct ptlrpc_request *request, return rc; } +EXPORT_SYMBOL(ptlrpc_request_pack); /** * Helper function to allocate new request on import \a imp @@ -698,6 +708,7 @@ struct ptlrpc_request *ptlrpc_request_alloc(struct obd_import *imp, { return ptlrpc_request_alloc_internal(imp, NULL, format); } +EXPORT_SYMBOL(ptlrpc_request_alloc); /** * Allocate new request structure for import \a imp from pool \a pool and @@ -709,6 +720,7 @@ struct ptlrpc_request *ptlrpc_request_alloc_pool(struct obd_import *imp, { return ptlrpc_request_alloc_internal(imp, pool, format); } +EXPORT_SYMBOL(ptlrpc_request_alloc_pool); /** * For requests not from pool, free memory of the request structure. @@ -721,6 +733,7 @@ void ptlrpc_request_free(struct ptlrpc_request *request) else OBD_FREE_PTR(request); } +EXPORT_SYMBOL(ptlrpc_request_free); /** * Allocate new request for operatione \a opcode and immediatelly pack it for @@ -745,6 +758,7 @@ struct ptlrpc_request *ptlrpc_request_alloc_pack(struct obd_import *imp, } return req; } +EXPORT_SYMBOL(ptlrpc_request_alloc_pack); /** * Prepare request (fetched from pool \a poolif not NULL) on import \a imp @@ -774,6 +788,7 @@ ptlrpc_prep_req_pool(struct obd_import *imp, } return request; } +EXPORT_SYMBOL(ptlrpc_prep_req_pool); /** * Same as ptlrpc_prep_req_pool, but without pool @@ -785,6 +800,7 @@ ptlrpc_prep_req(struct obd_import *imp, __u32 version, int opcode, int count, return ptlrpc_prep_req_pool(imp, version, opcode, count, lengths, bufs, NULL); } +EXPORT_SYMBOL(ptlrpc_prep_req); /** * Allocate "fake" request that would not be sent anywhere in the end. @@ -839,6 +855,7 @@ struct ptlrpc_request *ptlrpc_prep_fakereq(struct obd_import *imp, RETURN(request); } +EXPORT_SYMBOL(ptlrpc_prep_fakereq); /** * Indicate that processing of "fake" request is finished. @@ -864,6 +881,7 @@ void ptlrpc_fakereq_finished(struct ptlrpc_request *req) cfs_waitq_signal(&set->set_waitq); ptlrpc_req_finished(req); } +EXPORT_SYMBOL(ptlrpc_fakereq_finished); /** * Allocate and initialize new request set structure. @@ -892,6 +910,7 @@ struct ptlrpc_request_set *ptlrpc_prep_set(void) RETURN(set); } +EXPORT_SYMBOL(ptlrpc_prep_set); /** * Allocate and initialize new request set structure with flow control @@ -977,6 +996,7 @@ void ptlrpc_set_destroy(struct ptlrpc_request_set *set) ptlrpc_reqset_put(set); EXIT; } +EXPORT_SYMBOL(ptlrpc_set_destroy); /** * Add a callback function \a fn to the set. @@ -998,6 +1018,7 @@ int ptlrpc_set_add_cb(struct ptlrpc_request_set *set, RETURN(0); } +EXPORT_SYMBOL(ptlrpc_set_add_cb); /** * Add a new request to the general purpose request set. @@ -1025,6 +1046,7 @@ void ptlrpc_set_add_req(struct ptlrpc_request_set *set, * sent straight away */ ptlrpc_send_new_req(req); } +EXPORT_SYMBOL(ptlrpc_set_add_req); /** * Add a request to a request with dedicated server thread @@ -1061,6 +1083,7 @@ void ptlrpc_set_add_new_req(struct ptlrpcd_ctl *pc, cfs_waitq_signal(&pc->pc_partners[i]->pc_set->set_waitq); } } +EXPORT_SYMBOL(ptlrpc_set_add_new_req); /** * Based on the current state of the import, determine if the request @@ -1869,6 +1892,7 @@ int ptlrpc_check_set(const struct lu_env *env, struct ptlrpc_request_set *set) /* If we hit an error, we want to recover promptly. */ RETURN(cfs_atomic_read(&set->set_remaining) == 0 || force_timer_recalc); } +EXPORT_SYMBOL(ptlrpc_check_set); /** * Time out request \a req. is \a async_unlink is set, that means do not wait @@ -1993,6 +2017,7 @@ int ptlrpc_expired_set(void *data) */ RETURN(1); } +EXPORT_SYMBOL(ptlrpc_expired_set); /** * Sets rq_intr flag in \a req under spinlock. @@ -2003,6 +2028,7 @@ void ptlrpc_mark_interrupted(struct ptlrpc_request *req) req->rq_intr = 1; cfs_spin_unlock(&req->rq_lock); } +EXPORT_SYMBOL(ptlrpc_mark_interrupted); /** * Interrupts (sets interrupted flag) all uncompleted requests in @@ -2028,6 +2054,7 @@ void ptlrpc_interrupted_set(void *data) ptlrpc_mark_interrupted(req); } } +EXPORT_SYMBOL(ptlrpc_interrupted_set); /** * Get the smallest timeout in the set; this does NOT set a timeout. @@ -2080,6 +2107,7 @@ int ptlrpc_set_next_timeout(struct ptlrpc_request_set *set) } RETURN(timeout); } +EXPORT_SYMBOL(ptlrpc_set_next_timeout); /** * Send all unset request from the set and then wait untill all @@ -2205,6 +2233,7 @@ int ptlrpc_set_wait(struct ptlrpc_request_set *set) RETURN(rc); } +EXPORT_SYMBOL(ptlrpc_set_wait); /** * Helper fuction for request freeing. @@ -2284,6 +2313,7 @@ void ptlrpc_req_finished_with_imp_lock(struct ptlrpc_request *request) LASSERT_SPIN_LOCKED(&request->rq_import->imp_lock); (void)__ptlrpc_req_finished(request, 1); } +EXPORT_SYMBOL(ptlrpc_req_finished_with_imp_lock); /** * Helper function @@ -2322,6 +2352,7 @@ void ptlrpc_req_finished(struct ptlrpc_request *request) { __ptlrpc_req_finished(request, 0); } +EXPORT_SYMBOL(ptlrpc_req_finished); /** * Returns xid of a \a request @@ -2411,6 +2442,7 @@ int ptlrpc_unregister_reply(struct ptlrpc_request *request, int async) } RETURN(0); } +EXPORT_SYMBOL(ptlrpc_unregister_reply); /** * Iterates through replay_list on import and prunes @@ -2495,6 +2527,7 @@ void ptlrpc_cleanup_client(struct obd_import *imp) EXIT; return; } +EXPORT_SYMBOL(ptlrpc_cleanup_client); /** * Schedule previously sent request for resend. @@ -2523,6 +2556,7 @@ void ptlrpc_resend_req(struct ptlrpc_request *req) ptlrpc_client_wake_req(req); cfs_spin_unlock(&req->rq_lock); } +EXPORT_SYMBOL(ptlrpc_resend_req); /* XXX: this function and rq_status are currently unused */ void ptlrpc_restart_req(struct ptlrpc_request *req) @@ -2536,6 +2570,7 @@ void ptlrpc_restart_req(struct ptlrpc_request *req) ptlrpc_client_wake_req(req); cfs_spin_unlock(&req->rq_lock); } +EXPORT_SYMBOL(ptlrpc_restart_req); /** * Grab additional reference on a request \a req @@ -2546,6 +2581,7 @@ struct ptlrpc_request *ptlrpc_request_addref(struct ptlrpc_request *req) cfs_atomic_inc(&req->rq_refcount); RETURN(req); } +EXPORT_SYMBOL(ptlrpc_request_addref); /** * Add a request to import replay_list. @@ -2602,6 +2638,7 @@ void ptlrpc_retain_replayable_request(struct ptlrpc_request *req, cfs_list_add(&req->rq_replay_list, &imp->imp_replay_list); } +EXPORT_SYMBOL(ptlrpc_retain_replayable_request); /** * Send request and wait until it completes. @@ -2633,6 +2670,7 @@ int ptlrpc_queue_wait(struct ptlrpc_request *req) RETURN(rc); } +EXPORT_SYMBOL(ptlrpc_queue_wait); struct ptlrpc_replay_async_args { int praa_old_state; @@ -2775,6 +2813,7 @@ int ptlrpc_replay_req(struct ptlrpc_request *req) ptlrpcd_add_req(req, PDL_POLICY_LOCAL, -1); RETURN(0); } +EXPORT_SYMBOL(ptlrpc_replay_req); /** * Aborts all in-flight request on import \a imp sending and delayed lists @@ -2833,6 +2872,7 @@ void ptlrpc_abort_inflight(struct obd_import *imp) EXIT; } +EXPORT_SYMBOL(ptlrpc_abort_inflight); /** * Abort all uncompleted requests in request set \a set @@ -2905,6 +2945,7 @@ __u64 ptlrpc_next_xid(void) cfs_spin_unlock(&ptlrpc_last_xid_lock); return tmp; } +EXPORT_SYMBOL(ptlrpc_next_xid); /** * Get a glimpse at what next xid value might have been. diff --git a/lustre/ptlrpc/connection.c b/lustre/ptlrpc/connection.c index 36d962f..c8f749b 100644 --- a/lustre/ptlrpc/connection.c +++ b/lustre/ptlrpc/connection.c @@ -88,6 +88,7 @@ out: libcfs_nid2str(conn->c_peer.nid)); return conn; } +EXPORT_SYMBOL(ptlrpc_connection_get); int ptlrpc_connection_put(struct ptlrpc_connection *conn) { @@ -124,6 +125,7 @@ int ptlrpc_connection_put(struct ptlrpc_connection *conn) RETURN(rc); } +EXPORT_SYMBOL(ptlrpc_connection_put); struct ptlrpc_connection * ptlrpc_connection_addref(struct ptlrpc_connection *conn) @@ -137,6 +139,7 @@ ptlrpc_connection_addref(struct ptlrpc_connection *conn) RETURN(conn); } +EXPORT_SYMBOL(ptlrpc_connection_addref); int ptlrpc_connection_init(void) { @@ -154,12 +157,14 @@ int ptlrpc_connection_init(void) RETURN(0); } +EXPORT_SYMBOL(ptlrpc_connection_init); void ptlrpc_connection_fini(void) { ENTRY; cfs_hash_putref(conn_hash); EXIT; } +EXPORT_SYMBOL(ptlrpc_connection_fini); /* * Hash operations for net_peer<->connection diff --git a/lustre/ptlrpc/import.c b/lustre/ptlrpc/import.c index 9d2aa7c..5df9591 100644 --- a/lustre/ptlrpc/import.c +++ b/lustre/ptlrpc/import.c @@ -221,6 +221,7 @@ void ptlrpc_deactivate_import(struct obd_import *imp) cfs_spin_lock(&imp->imp_lock); ptlrpc_deactivate_and_unlock_import(imp); } +EXPORT_SYMBOL(ptlrpc_deactivate_import); static unsigned int ptlrpc_inflight_deadline(struct ptlrpc_request *req, time_t now) @@ -379,6 +380,7 @@ void ptlrpc_invalidate_import(struct obd_import *imp) cfs_atomic_dec(&imp->imp_inval_count); cfs_waitq_broadcast(&imp->imp_recovery_waitq); } +EXPORT_SYMBOL(ptlrpc_invalidate_import); /* unset imp_invalid */ void ptlrpc_activate_import(struct obd_import *imp) @@ -391,6 +393,7 @@ void ptlrpc_activate_import(struct obd_import *imp) cfs_spin_unlock(&imp->imp_lock); obd_import_event(obd, imp, IMP_EVENT_ACTIVE); } +EXPORT_SYMBOL(ptlrpc_activate_import); void ptlrpc_fail_import(struct obd_import *imp, __u32 conn_cnt) { @@ -419,6 +422,7 @@ void ptlrpc_fail_import(struct obd_import *imp, __u32 conn_cnt) } EXIT; } +EXPORT_SYMBOL(ptlrpc_fail_import); int ptlrpc_reconnect_import(struct obd_import *imp) { @@ -1456,6 +1460,7 @@ out: RETURN(rc); } +EXPORT_SYMBOL(ptlrpc_disconnect_import); void ptlrpc_cleanup_imp(struct obd_import *imp) { @@ -1469,6 +1474,7 @@ void ptlrpc_cleanup_imp(struct obd_import *imp) EXIT; } +EXPORT_SYMBOL(ptlrpc_cleanup_imp); /* Adaptive Timeout utils */ extern unsigned int at_min, at_max, at_history; diff --git a/lustre/ptlrpc/llog_client.c b/lustre/ptlrpc/llog_client.c index dffd854..eb69a4a 100644 --- a/lustre/ptlrpc/llog_client.c +++ b/lustre/ptlrpc/llog_client.c @@ -351,3 +351,4 @@ struct llog_operations llog_client_ops = { lop_destroy: llog_client_destroy, lop_close: llog_client_close, }; +EXPORT_SYMBOL(llog_client_ops); diff --git a/lustre/ptlrpc/llog_server.c b/lustre/ptlrpc/llog_server.c index 242b830..3337198 100644 --- a/lustre/ptlrpc/llog_server.c +++ b/lustre/ptlrpc/llog_server.c @@ -112,6 +112,7 @@ out_pop: llog_ctxt_put(ctxt); return rc; } +EXPORT_SYMBOL(llog_origin_handle_create); int llog_origin_handle_destroy(struct ptlrpc_request *req) { @@ -166,6 +167,7 @@ out_pop: llog_ctxt_put(ctxt); return rc; } +EXPORT_SYMBOL(llog_origin_handle_destroy); int llog_origin_handle_next_block(struct ptlrpc_request *req) { @@ -236,6 +238,7 @@ out_free: OBD_FREE(buf, LLOG_CHUNK_SIZE); return rc; } +EXPORT_SYMBOL(llog_origin_handle_next_block); int llog_origin_handle_prev_block(struct ptlrpc_request *req) { @@ -307,6 +310,7 @@ out_free: OBD_FREE(buf, LLOG_CHUNK_SIZE); return rc; } +EXPORT_SYMBOL(llog_origin_handle_prev_block); int llog_origin_handle_read_header(struct ptlrpc_request *req) { @@ -361,6 +365,7 @@ out_pop: llog_ctxt_put(ctxt); return rc; } +EXPORT_SYMBOL(llog_origin_handle_read_header); int llog_origin_handle_close(struct ptlrpc_request *req) { @@ -368,6 +373,7 @@ int llog_origin_handle_close(struct ptlrpc_request *req) /* Nothing to do */ RETURN(0); } +EXPORT_SYMBOL(llog_origin_handle_close); int llog_origin_handle_cancel(struct ptlrpc_request *req) { diff --git a/lustre/ptlrpc/niobuf.c b/lustre/ptlrpc/niobuf.c index e517e10..b0d3a52 100644 --- a/lustre/ptlrpc/niobuf.c +++ b/lustre/ptlrpc/niobuf.c @@ -132,6 +132,7 @@ struct ptlrpc_bulk_desc *ptlrpc_prep_bulk_exp(struct ptlrpc_request *req, return desc; } +EXPORT_SYMBOL(ptlrpc_prep_bulk_exp); /** * Starts bulk transfer for descriptor \a desc @@ -203,6 +204,7 @@ int ptlrpc_start_bulk_transfer(struct ptlrpc_bulk_desc *desc) RETURN(0); } +EXPORT_SYMBOL(ptlrpc_start_bulk_transfer); /** * Server side bulk abort. Idempotent. Not thread-safe (i.e. only @@ -244,6 +246,7 @@ void ptlrpc_abort_bulk(struct ptlrpc_bulk_desc *desc) CWARN("Unexpectedly long timeout: desc %p\n", desc); } } +EXPORT_SYMBOL(ptlrpc_abort_bulk); #endif /* HAVE_SERVER_SUPPORT */ /** @@ -326,6 +329,7 @@ int ptlrpc_register_bulk(struct ptlrpc_request *req) req->rq_xid, desc->bd_portal); RETURN(0); } +EXPORT_SYMBOL(ptlrpc_register_bulk); /** * Disconnect a bulk desc from the network. Idempotent. Not @@ -392,6 +396,7 @@ int ptlrpc_unregister_bulk(struct ptlrpc_request *req, int async) } RETURN(0); } +EXPORT_SYMBOL(ptlrpc_unregister_bulk); static void ptlrpc_at_set_reply(struct ptlrpc_request *req, int flags) { @@ -529,6 +534,7 @@ out: ptlrpc_connection_put(conn); return rc; } +EXPORT_SYMBOL(ptlrpc_send_reply); int ptlrpc_reply (struct ptlrpc_request *req) { @@ -537,6 +543,7 @@ int ptlrpc_reply (struct ptlrpc_request *req) else return (ptlrpc_send_reply(req, 0)); } +EXPORT_SYMBOL(ptlrpc_reply); /** * For request \a req send an error reply back. Create empty @@ -561,11 +568,13 @@ int ptlrpc_send_error(struct ptlrpc_request *req, int may_be_difficult) rc = ptlrpc_send_reply(req, may_be_difficult); RETURN(rc); } +EXPORT_SYMBOL(ptlrpc_send_error); int ptlrpc_error(struct ptlrpc_request *req) { return ptlrpc_send_error(req, 0); } +EXPORT_SYMBOL(ptlrpc_error); /** * Send request \a request. @@ -757,6 +766,7 @@ int ptl_send_rpc(struct ptlrpc_request *request, int noreply) cfs_memory_pressure_restore(mpflag); return rc; } +EXPORT_SYMBOL(ptl_send_rpc); /** * Register request buffer descriptor for request receiving. diff --git a/lustre/ptlrpc/pack_generic.c b/lustre/ptlrpc/pack_generic.c index e20a03d..d59fa98 100644 --- a/lustre/ptlrpc/pack_generic.c +++ b/lustre/ptlrpc/pack_generic.c @@ -81,6 +81,7 @@ void ptlrpc_buf_set_swabbed(struct ptlrpc_request *req, const int inout, 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) @@ -92,6 +93,7 @@ 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); static inline int lustre_msg_check_version_v2(struct lustre_msg_v2 *msg, __u32 version) @@ -113,6 +115,7 @@ 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() @@ -172,6 +175,7 @@ int lustre_msg_size(__u32 magic, int count, __u32 *lens) return -EINVAL; } } +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. */ @@ -185,6 +189,7 @@ 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) @@ -252,6 +257,7 @@ 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); @@ -393,12 +399,14 @@ 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) { return lustre_pack_reply_flags(req, count, lens, bufs, 0); } +EXPORT_SYMBOL(lustre_pack_reply); void *lustre_msg_buf_v2(struct lustre_msg_v2 *m, int n, int min_size) { @@ -439,6 +447,7 @@ void *lustre_msg_buf(struct lustre_msg *m, int n, int min_size) return NULL; } } +EXPORT_SYMBOL(lustre_msg_buf); int lustre_shrink_msg_v2(struct lustre_msg_v2 *msg, int segment, unsigned int newlen, int move_data) @@ -497,6 +506,7 @@ int lustre_shrink_msg(struct lustre_msg *msg, int segment, LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic); } } +EXPORT_SYMBOL(lustre_shrink_msg); void lustre_free_reply_state(struct ptlrpc_reply_state *rs) { @@ -513,6 +523,7 @@ void lustre_free_reply_state(struct ptlrpc_reply_state *rs) sptlrpc_svc_free_rs(rs); } +EXPORT_SYMBOL(lustre_free_reply_state); static int lustre_unpack_msg_v2(struct lustre_msg_v2 *m, int len) { @@ -600,6 +611,7 @@ 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) { @@ -611,6 +623,7 @@ 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) @@ -767,6 +780,7 @@ 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, @@ -841,6 +855,7 @@ __u32 lustre_msg_get_flags(struct lustre_msg *msg) return 0; } } +EXPORT_SYMBOL(lustre_msg_get_flags); void lustre_msg_add_flags(struct lustre_msg *msg, int flags) { @@ -855,6 +870,7 @@ void lustre_msg_add_flags(struct lustre_msg *msg, int flags) LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic); } } +EXPORT_SYMBOL(lustre_msg_add_flags); void lustre_msg_set_flags(struct lustre_msg *msg, int flags) { @@ -869,6 +885,7 @@ 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) { @@ -883,6 +900,7 @@ void lustre_msg_clear_flags(struct lustre_msg *msg, int flags) LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic); } } +EXPORT_SYMBOL(lustre_msg_clear_flags); __u32 lustre_msg_get_op_flags(struct lustre_msg *msg) { @@ -899,6 +917,7 @@ __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) { @@ -913,6 +932,7 @@ void lustre_msg_add_op_flags(struct lustre_msg *msg, int flags) LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic); } } +EXPORT_SYMBOL(lustre_msg_add_op_flags); void lustre_msg_set_op_flags(struct lustre_msg *msg, int flags) { @@ -927,6 +947,7 @@ 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) { @@ -944,6 +965,7 @@ 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) { @@ -961,6 +983,7 @@ __u32 lustre_msg_get_type(struct lustre_msg *msg) return PTL_RPC_MSG_ERR; } } +EXPORT_SYMBOL(lustre_msg_get_type); __u32 lustre_msg_get_version(struct lustre_msg *msg) { @@ -978,6 +1001,7 @@ __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) { @@ -992,6 +1016,7 @@ 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) { @@ -1010,6 +1035,7 @@ __u32 lustre_msg_get_opc(struct lustre_msg *msg) return 0; } } +EXPORT_SYMBOL(lustre_msg_get_opc); __u64 lustre_msg_get_last_xid(struct lustre_msg *msg) { @@ -1027,6 +1053,7 @@ __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) { @@ -1044,6 +1071,7 @@ __u64 lustre_msg_get_last_committed(struct lustre_msg *msg) return 0; } } +EXPORT_SYMBOL(lustre_msg_get_last_committed); __u64 *lustre_msg_get_versions(struct lustre_msg *msg) { @@ -1063,6 +1091,7 @@ __u64 *lustre_msg_get_versions(struct lustre_msg *msg) return NULL; } } +EXPORT_SYMBOL(lustre_msg_get_versions); __u64 lustre_msg_get_transno(struct lustre_msg *msg) { @@ -1080,6 +1109,7 @@ __u64 lustre_msg_get_transno(struct lustre_msg *msg) return 0; } } +EXPORT_SYMBOL(lustre_msg_get_transno); int lustre_msg_get_status(struct lustre_msg *msg) { @@ -1098,6 +1128,7 @@ int lustre_msg_get_status(struct lustre_msg *msg) return -EINVAL; } } +EXPORT_SYMBOL(lustre_msg_get_status); __u64 lustre_msg_get_slv(struct lustre_msg *msg) { @@ -1115,6 +1146,7 @@ __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) @@ -1134,6 +1166,7 @@ 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) { @@ -1151,6 +1184,7 @@ __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) @@ -1170,6 +1204,7 @@ 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) { @@ -1187,6 +1222,7 @@ __u32 lustre_msg_get_conn_cnt(struct lustre_msg *msg) return 0; } } +EXPORT_SYMBOL(lustre_msg_get_conn_cnt); int lustre_msg_is_v1(struct lustre_msg *msg) { @@ -1198,6 +1234,7 @@ 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) { @@ -1209,6 +1246,7 @@ __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) { @@ -1342,6 +1380,7 @@ 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) { @@ -1356,6 +1395,7 @@ 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) { @@ -1370,6 +1410,7 @@ 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) { @@ -1384,6 +1425,7 @@ 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) { @@ -1398,6 +1440,7 @@ 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) { @@ -1417,6 +1460,7 @@ 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_versions); void lustre_msg_set_transno(struct lustre_msg *msg, __u64 transno) { @@ -1431,6 +1475,7 @@ void lustre_msg_set_transno(struct lustre_msg *msg, __u64 transno) LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic); } } +EXPORT_SYMBOL(lustre_msg_set_transno); void lustre_msg_set_status(struct lustre_msg *msg, __u32 status) { @@ -1445,6 +1490,7 @@ void lustre_msg_set_status(struct lustre_msg *msg, __u32 status) LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic); } } +EXPORT_SYMBOL(lustre_msg_set_status); void lustre_msg_set_conn_cnt(struct lustre_msg *msg, __u32 conn_cnt) { @@ -1459,6 +1505,7 @@ 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) { @@ -1542,6 +1589,7 @@ void ptlrpc_request_set_replen(struct ptlrpc_request *req) if (req->rq_reqmsg->lm_magic == LUSTRE_MSG_MAGIC_V2) req->rq_reqmsg->lm_repsize = req->rq_replen; } +EXPORT_SYMBOL(ptlrpc_request_set_replen); void ptlrpc_req_set_repsize(struct ptlrpc_request *req, int count, __u32 *lens) { @@ -1549,6 +1597,7 @@ 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. @@ -1631,6 +1680,7 @@ 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) { @@ -1706,6 +1756,7 @@ void lustre_swab_obdo (struct obdo *o) CLASSERT(offsetof(typeof(*o), o_padding_6) != 0); } +EXPORT_SYMBOL(lustre_swab_obdo); void lustre_swab_obd_statfs (struct obd_statfs *os) { @@ -1730,6 +1781,7 @@ 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) { @@ -1738,6 +1790,7 @@ void lustre_swab_obd_ioobj (struct obd_ioobj *ioo) __swab32s (&ioo->ioo_type); __swab32s (&ioo->ioo_bufcnt); } +EXPORT_SYMBOL(lustre_swab_obd_ioobj); void lustre_swab_niobuf_remote (struct niobuf_remote *nbr) { @@ -1745,21 +1798,25 @@ void lustre_swab_niobuf_remote (struct niobuf_remote *nbr) __swab32s (&nbr->len); __swab32s (&nbr->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) { __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_lvb(union ldlm_wire_lvb *lvb) { @@ -1774,6 +1831,7 @@ void lustre_swab_lvb(union ldlm_wire_lvb *lvb) __swab64s(&lvb->l_ost.lvb_ctime); __swab64s(&lvb->l_ost.lvb_blocks); } +EXPORT_SYMBOL(lustre_swab_lvb); void lustre_swab_mdt_body (struct mdt_body *b) { @@ -1807,6 +1865,7 @@ void lustre_swab_mdt_body (struct mdt_body *b) __swab32s (&b->gid_h); CLASSERT(offsetof(typeof(*b), padding_5) != 0); } +EXPORT_SYMBOL(lustre_swab_mdt_body); void lustre_swab_mdt_ioepoch (struct mdt_ioepoch *b) { @@ -1815,6 +1874,7 @@ 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) { @@ -1829,6 +1889,7 @@ 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) { @@ -1899,6 +1960,7 @@ 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_quota_adjust_qunit (struct quota_adjust_qunit *q) { @@ -1908,6 +1970,7 @@ void lustre_swab_quota_adjust_qunit (struct quota_adjust_qunit *q) __swab64s (&q->qaq_iunit_sz); __swab64s (&q->padding1); } +EXPORT_SYMBOL(lustre_swab_quota_adjust_qunit); void lustre_swab_mdt_remote_perm (struct mdt_remote_perm *p) { @@ -1920,6 +1983,7 @@ void lustre_swab_mdt_remote_perm (struct mdt_remote_perm *p) __swab32s (&p->rp_access_perm); __swab32s (&p->rp_padding); }; +EXPORT_SYMBOL(lustre_swab_mdt_remote_perm); void lustre_swab_fid2path(struct getinfo_fid2path *gf) { @@ -1953,6 +2017,7 @@ 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_mdt_rec_reint (struct mdt_rec_reint *rr) { @@ -1981,6 +2046,7 @@ void lustre_swab_mdt_rec_reint (struct mdt_rec_reint *rr) CLASSERT(offsetof(typeof(*rr), rr_padding_3) != 0); CLASSERT(offsetof(typeof(*rr), rr_padding_4) != 0); }; +EXPORT_SYMBOL(lustre_swab_mdt_rec_reint); void lustre_swab_lov_desc (struct lov_desc *ld) { @@ -1993,6 +2059,7 @@ void lustre_swab_lov_desc (struct lov_desc *ld) __swab32s (&ld->ld_qos_maxage); /* uuid endian insensitive */ } +EXPORT_SYMBOL(lustre_swab_lov_desc); void lustre_swab_lmv_desc (struct lmv_desc *ld) { @@ -2048,6 +2115,7 @@ void lustre_swab_lov_user_md_v1(struct lov_user_md_v1 *lum) lustre_swab_lov_user_md_common(lum); EXIT; } +EXPORT_SYMBOL(lustre_swab_lov_user_md_v1); void lustre_swab_lov_user_md_v3(struct lov_user_md_v3 *lum) { @@ -2057,6 +2125,7 @@ void lustre_swab_lov_user_md_v3(struct lov_user_md_v3 *lum) /* lmm_pool_name nothing to do with char */ EXIT; } +EXPORT_SYMBOL(lustre_swab_lov_user_md_v3); void lustre_swab_lov_mds_md(struct lov_mds_md *lmm) { @@ -2071,6 +2140,7 @@ 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) @@ -2085,7 +2155,7 @@ void lustre_swab_lov_user_md_objects(struct lov_user_ost_data *lod, } EXIT; } - +EXPORT_SYMBOL(lustre_swab_lov_user_md_objects); void lustre_swab_ldlm_res_id (struct ldlm_res_id *id) { @@ -2094,6 +2164,7 @@ 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) { @@ -2106,11 +2177,13 @@ 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) { @@ -2118,6 +2191,7 @@ 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) { @@ -2126,6 +2200,7 @@ 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) { @@ -2134,6 +2209,7 @@ 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) { @@ -2144,6 +2220,7 @@ 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); /* no one calls this */ int llog_log_swabbed(struct llog_log_hdr *hdr) @@ -2163,6 +2240,7 @@ void lustre_swab_qdata(struct qunit_data *d) __swab64s (&d->qd_qunit); CLASSERT(offsetof(typeof(*d), padding) != 0); } +EXPORT_SYMBOL(lustre_swab_qdata); /* Dump functions */ void dump_ioo(struct obd_ioobj *ioo) @@ -2172,12 +2250,14 @@ void dump_ioo(struct obd_ioobj *ioo) "ioo_bufct=%d\n", ioo->ioo_id, ioo->ioo_seq, ioo->ioo_type, 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); } +EXPORT_SYMBOL(dump_rniobuf); void dump_obdo(struct obdo *oa) { @@ -2243,16 +2323,19 @@ 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); #ifdef __KERNEL__ @@ -2400,6 +2483,7 @@ 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) { @@ -2407,6 +2491,7 @@ 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_state(struct hsm_state_set_ioc *hssi) { diff --git a/lustre/ptlrpc/pinger.c b/lustre/ptlrpc/pinger.c index 2d48a43..1b3038c 100644 --- a/lustre/ptlrpc/pinger.c +++ b/lustre/ptlrpc/pinger.c @@ -407,6 +407,7 @@ void ptlrpc_pinger_sending_on_import(struct obd_import *imp) { ptlrpc_update_next_ping(imp, 0); } +EXPORT_SYMBOL(ptlrpc_pinger_sending_on_import); void ptlrpc_pinger_commit_expected(struct obd_import *imp) { @@ -434,6 +435,7 @@ int ptlrpc_pinger_add_import(struct obd_import *imp) RETURN(0); } +EXPORT_SYMBOL(ptlrpc_pinger_add_import); int ptlrpc_pinger_del_import(struct obd_import *imp) { @@ -451,6 +453,7 @@ int ptlrpc_pinger_del_import(struct obd_import *imp) cfs_mutex_unlock(&pinger_mutex); RETURN(0); } +EXPORT_SYMBOL(ptlrpc_pinger_del_import); /** * Register a timeout callback to the pinger list, and the callback will @@ -524,6 +527,7 @@ int ptlrpc_add_timeout_client(int time, enum timeout_event event, cfs_mutex_unlock(&pinger_mutex); return 0; } +EXPORT_SYMBOL(ptlrpc_add_timeout_client); int ptlrpc_del_timeout_client(cfs_list_t *obd_list, enum timeout_event event) @@ -552,6 +556,7 @@ int ptlrpc_del_timeout_client(cfs_list_t *obd_list, cfs_mutex_unlock(&pinger_mutex); return 0; } +EXPORT_SYMBOL(ptlrpc_del_timeout_client); int ptlrpc_pinger_remove_timeouts(void) { diff --git a/lustre/ptlrpc/ptlrpc_module.c b/lustre/ptlrpc/ptlrpc_module.c index 0eed7d7..9554935 100644 --- a/lustre/ptlrpc/ptlrpc_module.c +++ b/lustre/ptlrpc/ptlrpc_module.c @@ -156,204 +156,6 @@ static void __exit ptlrpc_exit(void) ptlrpc_connection_fini(); } -/* connection.c */ -EXPORT_SYMBOL(ptlrpc_connection_get); -EXPORT_SYMBOL(ptlrpc_connection_put); -EXPORT_SYMBOL(ptlrpc_connection_addref); -EXPORT_SYMBOL(ptlrpc_connection_init); -EXPORT_SYMBOL(ptlrpc_connection_fini); - -/* niobuf.c */ -#ifdef HAVE_SERVER_SUPPORT -EXPORT_SYMBOL(ptlrpc_prep_bulk_exp); -EXPORT_SYMBOL(ptlrpc_start_bulk_transfer); -EXPORT_SYMBOL(ptlrpc_abort_bulk); -#endif -EXPORT_SYMBOL(ptlrpc_register_bulk); -EXPORT_SYMBOL(ptlrpc_unregister_bulk); -EXPORT_SYMBOL(ptlrpc_send_reply); -EXPORT_SYMBOL(ptlrpc_reply); -EXPORT_SYMBOL(ptlrpc_send_error); -EXPORT_SYMBOL(ptlrpc_error); -EXPORT_SYMBOL(ptlrpc_resend_req); -EXPORT_SYMBOL(ptl_send_rpc); - -/* client.c */ -EXPORT_SYMBOL(ptlrpc_init_client); -EXPORT_SYMBOL(ptlrpc_cleanup_client); -EXPORT_SYMBOL(ptlrpc_uuid_to_connection); -EXPORT_SYMBOL(ptlrpc_queue_wait); -EXPORT_SYMBOL(ptlrpc_replay_req); -EXPORT_SYMBOL(ptlrpc_restart_req); -EXPORT_SYMBOL(ptlrpc_add_rqs_to_pool); -EXPORT_SYMBOL(ptlrpc_init_rq_pool); -EXPORT_SYMBOL(ptlrpc_free_rq_pool); -EXPORT_SYMBOL(ptlrpc_prep_req_pool); -EXPORT_SYMBOL(ptlrpc_prep_fakereq); -EXPORT_SYMBOL(ptlrpc_fakereq_finished); -EXPORT_SYMBOL(ptlrpc_at_set_req_timeout); -EXPORT_SYMBOL(ptlrpc_request_alloc); -EXPORT_SYMBOL(ptlrpc_request_alloc_pool); -EXPORT_SYMBOL(ptlrpc_request_free); -EXPORT_SYMBOL(ptlrpc_request_pack); -EXPORT_SYMBOL(ptlrpc_request_alloc_pack); -EXPORT_SYMBOL(ptlrpc_prep_req); -EXPORT_SYMBOL(ptlrpc_unregister_reply); -EXPORT_SYMBOL(ptlrpc_req_finished); -EXPORT_SYMBOL(ptlrpc_req_finished_with_imp_lock); -EXPORT_SYMBOL(ptlrpc_request_addref); -EXPORT_SYMBOL(ptlrpc_prep_bulk_imp); -EXPORT_SYMBOL(ptlrpc_free_bulk); -EXPORT_SYMBOL(ptlrpc_prep_bulk_page); -EXPORT_SYMBOL(ptlrpc_abort_inflight); -EXPORT_SYMBOL(ptlrpc_cleanup_imp); -EXPORT_SYMBOL(ptlrpc_retain_replayable_request); -EXPORT_SYMBOL(ptlrpc_next_xid); -EXPORT_SYMBOL(ptlrpc_req_set_repsize); -EXPORT_SYMBOL(ptlrpc_request_set_replen); - -EXPORT_SYMBOL(ptlrpc_prep_set); -EXPORT_SYMBOL(ptlrpc_set_add_cb); -EXPORT_SYMBOL(ptlrpc_set_add_req); -EXPORT_SYMBOL(ptlrpc_set_add_new_req); -EXPORT_SYMBOL(ptlrpc_set_destroy); -EXPORT_SYMBOL(ptlrpc_set_next_timeout); -EXPORT_SYMBOL(ptlrpc_check_set); -EXPORT_SYMBOL(ptlrpc_set_wait); -EXPORT_SYMBOL(ptlrpc_expired_set); -EXPORT_SYMBOL(ptlrpc_interrupted_set); -EXPORT_SYMBOL(ptlrpc_mark_interrupted); - -/* service.c */ -EXPORT_SYMBOL(ptlrpc_save_lock); -EXPORT_SYMBOL(ptlrpc_schedule_difficult_reply); -EXPORT_SYMBOL(ptlrpc_commit_replies); -EXPORT_SYMBOL(ptlrpc_register_service); -EXPORT_SYMBOL(ptlrpc_stop_all_threads); -EXPORT_SYMBOL(ptlrpc_start_threads); -EXPORT_SYMBOL(ptlrpc_unregister_service); -EXPORT_SYMBOL(ptlrpc_service_health_check); -EXPORT_SYMBOL(ptlrpc_hpreq_reorder); - -/* pack_generic.c */ -EXPORT_SYMBOL(lustre_msg_check_version); -EXPORT_SYMBOL(lustre_pack_request); -EXPORT_SYMBOL(lustre_pack_reply); -EXPORT_SYMBOL(lustre_pack_reply_flags); -EXPORT_SYMBOL(lustre_shrink_msg); -EXPORT_SYMBOL(lustre_free_reply_state); -EXPORT_SYMBOL(lustre_msg_size); -EXPORT_SYMBOL(lustre_packed_msg_size); -EXPORT_SYMBOL(ptlrpc_unpack_rep_msg); -EXPORT_SYMBOL(ptlrpc_unpack_req_msg); -EXPORT_SYMBOL(lustre_msg_buf); -EXPORT_SYMBOL(lustre_msg_string); -EXPORT_SYMBOL(ptlrpc_buf_set_swabbed); -EXPORT_SYMBOL(ptlrpc_buf_need_swab); -EXPORT_SYMBOL(lustre_swab_ptlrpc_body); -EXPORT_SYMBOL(lustre_swab_obdo); -EXPORT_SYMBOL(lustre_swab_obd_statfs); -EXPORT_SYMBOL(lustre_swab_obd_ioobj); -EXPORT_SYMBOL(lustre_swab_niobuf_remote); -EXPORT_SYMBOL(lustre_swab_ost_body); -EXPORT_SYMBOL(lustre_swab_ost_last_id); -EXPORT_SYMBOL(lustre_swab_lvb); -EXPORT_SYMBOL(lustre_swab_mdt_body); -EXPORT_SYMBOL(lustre_swab_mdt_ioepoch); -EXPORT_SYMBOL(lustre_swab_obd_quotactl); -EXPORT_SYMBOL(lustre_swab_mdt_remote_perm); -EXPORT_SYMBOL(lustre_swab_mdt_rec_reint); -EXPORT_SYMBOL(lustre_swab_lov_desc); -EXPORT_SYMBOL(lustre_swab_lov_user_md_v1); -EXPORT_SYMBOL(lustre_swab_lov_user_md_v3); -EXPORT_SYMBOL(lustre_swab_lov_user_md_objects); -EXPORT_SYMBOL(lustre_swab_lov_mds_md); -EXPORT_SYMBOL(lustre_swab_ldlm_res_id); -EXPORT_SYMBOL(lustre_swab_ldlm_policy_data); -EXPORT_SYMBOL(lustre_swab_ldlm_intent); -EXPORT_SYMBOL(lustre_swab_ldlm_resource_desc); -EXPORT_SYMBOL(lustre_swab_ldlm_lock_desc); -EXPORT_SYMBOL(lustre_swab_ldlm_request); -EXPORT_SYMBOL(lustre_swab_ldlm_reply); -EXPORT_SYMBOL(dump_ioo); -EXPORT_SYMBOL(dump_rniobuf); -EXPORT_SYMBOL(dump_obdo); -EXPORT_SYMBOL(dump_ost_body); -EXPORT_SYMBOL(dump_rcs); -EXPORT_SYMBOL(lustre_swab_qdata); -EXPORT_SYMBOL(lustre_swab_quota_adjust_qunit); -EXPORT_SYMBOL(lustre_msg_get_flags); -EXPORT_SYMBOL(lustre_msg_add_flags); -EXPORT_SYMBOL(lustre_msg_set_flags); -EXPORT_SYMBOL(lustre_msg_clear_flags); -EXPORT_SYMBOL(lustre_msg_get_op_flags); -EXPORT_SYMBOL(lustre_msg_add_op_flags); -EXPORT_SYMBOL(lustre_msg_set_op_flags); -EXPORT_SYMBOL(lustre_msg_get_handle ); -EXPORT_SYMBOL(lustre_msg_get_type); -EXPORT_SYMBOL(lustre_msg_get_version); -EXPORT_SYMBOL(lustre_msg_add_version); -EXPORT_SYMBOL(lustre_msg_get_opc); -EXPORT_SYMBOL(lustre_msg_get_last_xid); -EXPORT_SYMBOL(lustre_msg_get_last_committed); -EXPORT_SYMBOL(lustre_msg_get_versions); -EXPORT_SYMBOL(lustre_msg_get_transno); -EXPORT_SYMBOL(lustre_msg_get_status); -EXPORT_SYMBOL(lustre_msg_get_slv); -EXPORT_SYMBOL(lustre_msg_get_limit); -EXPORT_SYMBOL(lustre_msg_set_slv); -EXPORT_SYMBOL(lustre_msg_set_limit); -EXPORT_SYMBOL(lustre_msg_get_conn_cnt); -EXPORT_SYMBOL(lustre_msg_is_v1); -EXPORT_SYMBOL(lustre_msg_get_magic); -EXPORT_SYMBOL(lustre_msg_set_handle); -EXPORT_SYMBOL(lustre_msg_set_type); -EXPORT_SYMBOL(lustre_msg_set_opc); -EXPORT_SYMBOL(lustre_msg_set_last_xid); -EXPORT_SYMBOL(lustre_msg_set_last_committed); -EXPORT_SYMBOL(lustre_msg_set_versions); -EXPORT_SYMBOL(lustre_msg_set_transno); -EXPORT_SYMBOL(lustre_msg_set_status); -EXPORT_SYMBOL(lustre_msg_set_conn_cnt); -EXPORT_SYMBOL(lustre_swab_mgs_target_info); -EXPORT_SYMBOL(lustre_swab_generic_32s); -EXPORT_SYMBOL(lustre_swab_lustre_capa); -EXPORT_SYMBOL(lustre_swab_lustre_capa_key); -EXPORT_SYMBOL(lustre_swab_fiemap); - -/* recover.c */ -EXPORT_SYMBOL(ptlrpc_disconnect_import); -EXPORT_SYMBOL(ptlrpc_resend); -EXPORT_SYMBOL(ptlrpc_wake_delayed); -EXPORT_SYMBOL(ptlrpc_set_import_active); -EXPORT_SYMBOL(ptlrpc_activate_import); -EXPORT_SYMBOL(ptlrpc_deactivate_import); -EXPORT_SYMBOL(ptlrpc_invalidate_import); -EXPORT_SYMBOL(ptlrpc_fail_import); -EXPORT_SYMBOL(ptlrpc_recover_import); - -/* pinger.c */ -EXPORT_SYMBOL(ptlrpc_pinger_add_import); -EXPORT_SYMBOL(ptlrpc_pinger_del_import); -EXPORT_SYMBOL(ptlrpc_add_timeout_client); -EXPORT_SYMBOL(ptlrpc_del_timeout_client); -EXPORT_SYMBOL(ptlrpc_pinger_sending_on_import); - -/* ptlrpcd.c */ -EXPORT_SYMBOL(ptlrpcd_addref); -EXPORT_SYMBOL(ptlrpcd_decref); -EXPORT_SYMBOL(ptlrpcd_add_req); -EXPORT_SYMBOL(ptlrpcd_wake); - -/* llogd.c */ -EXPORT_SYMBOL(llog_origin_handle_create); -EXPORT_SYMBOL(llog_origin_handle_destroy); -EXPORT_SYMBOL(llog_origin_handle_next_block); -EXPORT_SYMBOL(llog_origin_handle_prev_block); -EXPORT_SYMBOL(llog_origin_handle_read_header); -EXPORT_SYMBOL(llog_origin_handle_close); -EXPORT_SYMBOL(llog_client_ops); - MODULE_AUTHOR("Sun Microsystems, Inc. "); MODULE_DESCRIPTION("Lustre Request Processor and Lock Management"); MODULE_LICENSE("GPL"); diff --git a/lustre/ptlrpc/ptlrpcd.c b/lustre/ptlrpc/ptlrpcd.c index 32b5b17..8c7d8a2 100644 --- a/lustre/ptlrpc/ptlrpcd.c +++ b/lustre/ptlrpc/ptlrpcd.c @@ -103,6 +103,7 @@ void ptlrpcd_wake(struct ptlrpc_request *req) cfs_waitq_signal(&rq_set->set_waitq); } +EXPORT_SYMBOL(ptlrpcd_wake); static struct ptlrpcd_ctl * ptlrpcd_select_pc(struct ptlrpc_request *req, pdl_policy_t policy, int index) @@ -274,6 +275,7 @@ void ptlrpcd_add_req(struct ptlrpc_request *req, pdl_policy_t policy, int idx) ptlrpc_set_add_new_req(pc, req); } +EXPORT_SYMBOL(ptlrpcd_add_req); static inline void ptlrpc_reqset_get(struct ptlrpc_request_set *set) { @@ -881,6 +883,7 @@ int ptlrpcd_addref(void) cfs_mutex_unlock(&ptlrpcd_mutex); RETURN(rc); } +EXPORT_SYMBOL(ptlrpcd_addref); void ptlrpcd_decref(void) { @@ -889,4 +892,5 @@ void ptlrpcd_decref(void) ptlrpcd_fini(); cfs_mutex_unlock(&ptlrpcd_mutex); } +EXPORT_SYMBOL(ptlrpcd_decref); /** @} ptlrpcd */ diff --git a/lustre/ptlrpc/recover.c b/lustre/ptlrpc/recover.c index 7818765..106bb95 100644 --- a/lustre/ptlrpc/recover.c +++ b/lustre/ptlrpc/recover.c @@ -182,6 +182,7 @@ int ptlrpc_resend(struct obd_import *imp) RETURN(0); } +EXPORT_SYMBOL(ptlrpc_resend); /** * Go through all requests in delayed list and wake their threads @@ -201,6 +202,7 @@ void ptlrpc_wake_delayed(struct obd_import *imp) } cfs_spin_unlock(&imp->imp_lock); } +EXPORT_SYMBOL(ptlrpc_wake_delayed); void ptlrpc_request_handle_notconn(struct ptlrpc_request *failed_req) { @@ -283,6 +285,7 @@ int ptlrpc_set_import_active(struct obd_import *imp, int active) RETURN(rc); } +EXPORT_SYMBOL(ptlrpc_set_import_active); /* Attempt to reconnect an import */ int ptlrpc_recover_import(struct obd_import *imp, char *new_uuid, int async) @@ -343,6 +346,7 @@ int ptlrpc_recover_import(struct obd_import *imp, char *new_uuid, int async) out: return rc; } +EXPORT_SYMBOL(ptlrpc_recover_import); int ptlrpc_import_in_recovery(struct obd_import *imp) { diff --git a/lustre/ptlrpc/service.c b/lustre/ptlrpc/service.c index 28bb89a..25bb4c2 100644 --- a/lustre/ptlrpc/service.c +++ b/lustre/ptlrpc/service.c @@ -175,6 +175,7 @@ ptlrpc_save_lock(struct ptlrpc_request *req, rs->rs_no_ack = !!no_ack; } } +EXPORT_SYMBOL(ptlrpc_save_lock); #ifdef __KERNEL__ @@ -391,6 +392,7 @@ ptlrpc_schedule_difficult_reply(struct ptlrpc_reply_state *rs) ptlrpc_dispatch_difficult_reply(rs); EXIT; } +EXPORT_SYMBOL(ptlrpc_schedule_difficult_reply); void ptlrpc_commit_replies(struct obd_export *exp) { @@ -418,6 +420,7 @@ void ptlrpc_commit_replies(struct obd_export *exp) rs_batch_fini(&batch); EXIT; } +EXPORT_SYMBOL(ptlrpc_commit_replies); static int ptlrpc_server_post_idle_rqbds(struct ptlrpc_service_part *svcpt) @@ -818,6 +821,7 @@ failed: ptlrpc_unregister_service(service); RETURN(ERR_PTR(rc)); } +EXPORT_SYMBOL(ptlrpc_register_service); /** * to actually free the request, must be called without holding svc_lock. @@ -1548,6 +1552,7 @@ void ptlrpc_hpreq_reorder(struct ptlrpc_request *req) cfs_spin_unlock(&svcpt->scp_req_lock); EXIT; } +EXPORT_SYMBOL(ptlrpc_hpreq_reorder); /** Check if the request is a high priority one. */ static int ptlrpc_server_hpreq_check(struct ptlrpc_service *svc, @@ -2689,6 +2694,7 @@ void ptlrpc_stop_all_threads(struct ptlrpc_service *svc) EXIT; } +EXPORT_SYMBOL(ptlrpc_stop_all_threads); int ptlrpc_start_threads(struct ptlrpc_service *svc) { @@ -2720,6 +2726,7 @@ int ptlrpc_start_threads(struct ptlrpc_service *svc) ptlrpc_stop_all_threads(svc); RETURN(rc); } +EXPORT_SYMBOL(ptlrpc_start_threads); int ptlrpc_start_thread(struct ptlrpc_service_part *svcpt, int wait) { @@ -3116,6 +3123,7 @@ int ptlrpc_unregister_service(struct ptlrpc_service *service) RETURN(0); } +EXPORT_SYMBOL(ptlrpc_unregister_service); /** * Returns 0 if the service is healthy. @@ -3176,3 +3184,4 @@ ptlrpc_service_health_check(struct ptlrpc_service *svc) } return 0; } +EXPORT_SYMBOL(ptlrpc_service_health_check); -- 1.8.3.1