From: Liu Xuezhao Date: Sun, 7 Oct 2012 11:40:36 +0000 (+0800) Subject: LU-1347 ldlm: makes EXPORT_SYMBOL follows function body X-Git-Tag: 2.3.54~28 X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=commitdiff_plain;h=2ad695f40cf1920033d77723311ed5ed7a3b07cc LU-1347 ldlm: 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: I5644d908c652b2e34d81e923367af4b5728399e1 Reviewed-on: http://review.whamcloud.com/2837 Tested-by: Hudson Reviewed-by: Keith Mannthey Reviewed-by: Andreas Dilger Tested-by: Maloo Reviewed-by: Oleg Drokin --- diff --git a/lustre/ldlm/l_lock.c b/lustre/ldlm/l_lock.c index d1de7d1..124f834 100644 --- a/lustre/ldlm/l_lock.c +++ b/lustre/ldlm/l_lock.c @@ -35,7 +35,7 @@ #define DEBUG_SUBSYSTEM S_LDLM #ifdef __KERNEL__ #include -#else +#else #include #endif @@ -59,6 +59,7 @@ struct ldlm_resource * lock_res_and_lock(struct ldlm_lock *lock) lock->l_res_locked = 1; return lock->l_resource; } +EXPORT_SYMBOL(lock_res_and_lock); void unlock_res_and_lock(struct ldlm_lock *lock) { @@ -69,3 +70,4 @@ void unlock_res_and_lock(struct ldlm_lock *lock) if (!lock->l_ns_srv) cfs_spin_unlock(&lock->l_lock); } +EXPORT_SYMBOL(unlock_res_and_lock); diff --git a/lustre/ldlm/ldlm_extent.c b/lustre/ldlm/ldlm_extent.c index 892b507..2ddf2f7 100644 --- a/lustre/ldlm/ldlm_extent.c +++ b/lustre/ldlm/ldlm_extent.c @@ -798,6 +798,7 @@ __u64 ldlm_extent_shift_kms(struct ldlm_lock *lock, __u64 old_kms) RETURN(kms); } +EXPORT_SYMBOL(ldlm_extent_shift_kms); cfs_mem_cache_t *ldlm_interval_slab; struct ldlm_interval *ldlm_interval_alloc(struct ldlm_lock *lock) diff --git a/lustre/ldlm/ldlm_lib.c b/lustre/ldlm/ldlm_lib.c index 3bf5de1..f0123e0 100644 --- a/lustre/ldlm/ldlm_lib.c +++ b/lustre/ldlm/ldlm_lib.c @@ -131,6 +131,7 @@ int client_import_add_conn(struct obd_import *imp, struct obd_uuid *uuid, { return import_set_conn(imp, uuid, priority, 1); } +EXPORT_SYMBOL(client_import_add_conn); int client_import_del_conn(struct obd_import *imp, struct obd_uuid *uuid) { @@ -186,6 +187,7 @@ out: CERROR("connection %s not found\n", uuid->uuid); RETURN(rc); } +EXPORT_SYMBOL(client_import_del_conn); /** * Find conn uuid by peer nid. @peer is a server nid. This function is used @@ -464,6 +466,7 @@ err: RETURN(rc); } +EXPORT_SYMBOL(client_obd_setup); int client_obd_cleanup(struct obd_device *obddev) { @@ -477,6 +480,7 @@ int client_obd_cleanup(struct obd_device *obddev) ldlm_put_ref(); RETURN(0); } +EXPORT_SYMBOL(client_obd_cleanup); /* ->o_connect() method for client side (OSC and MDC and MGC) */ int client_connect_import(const struct lu_env *env, @@ -545,6 +549,7 @@ out_sem: return rc; } +EXPORT_SYMBOL(client_connect_import); int client_disconnect_export(struct obd_export *exp) { @@ -619,6 +624,7 @@ int client_disconnect_export(struct obd_export *exp) RETURN(rc); } +EXPORT_SYMBOL(client_disconnect_export); #ifdef HAVE_SERVER_SUPPORT int server_disconnect_export(struct obd_export *exp) @@ -656,6 +662,7 @@ int server_disconnect_export(struct obd_export *exp) RETURN(rc); } +EXPORT_SYMBOL(server_disconnect_export); /* -------------------------------------------------------------------------- * from old lib/target.c @@ -1278,6 +1285,7 @@ out: req->rq_status = rc; RETURN(rc); } +EXPORT_SYMBOL(target_handle_connect); int target_handle_disconnect(struct ptlrpc_request *req) { @@ -1293,6 +1301,7 @@ int target_handle_disconnect(struct ptlrpc_request *req) RETURN(0); } +EXPORT_SYMBOL(target_handle_disconnect); void target_destroy_export(struct obd_export *exp) { @@ -1313,6 +1322,7 @@ void target_destroy_export(struct obd_export *exp) LASSERT_ATOMIC_ZERO(&exp->exp_cb_count); LASSERT_ATOMIC_ZERO(&exp->exp_replay_count); } +EXPORT_SYMBOL(target_destroy_export); /* * Recovery functions @@ -1518,6 +1528,7 @@ void target_cleanup_recovery(struct obd_device *obd) EXIT; } +EXPORT_SYMBOL(target_cleanup_recovery); /* obd_recovery_task_lock should be held */ void target_cancel_recovery_timer(struct obd_device *obd) @@ -1525,6 +1536,7 @@ void target_cancel_recovery_timer(struct obd_device *obd) CDEBUG(D_HA, "%s: cancel recovery timer\n", obd->obd_name); cfs_timer_disarm(&obd->obd_recovery_timer); } +EXPORT_SYMBOL(target_cancel_recovery_timer); static void target_start_recovery_timer(struct obd_device *obd) { @@ -2136,6 +2148,7 @@ void target_stop_recovery_thread(struct obd_device *obd) cfs_wait_for_completion(&trd->trd_finishing); } } +EXPORT_SYMBOL(target_stop_recovery_thread); void target_recovery_fini(struct obd_device *obd) { @@ -2349,12 +2362,14 @@ int target_queue_recovery_request(struct ptlrpc_request *req, cfs_waitq_signal(&obd->obd_next_transno_waitq); RETURN(0); } +EXPORT_SYMBOL(target_queue_recovery_request); int target_handle_ping(struct ptlrpc_request *req) { obd_ping(req->rq_svc_thread->t_env, req->rq_export); return req_capsule_server_pack(&req->rq_pill); } +EXPORT_SYMBOL(target_handle_ping); void target_committed_to_req(struct ptlrpc_request *req) { @@ -2406,6 +2421,7 @@ int target_pack_pool_reply(struct ptlrpc_request *req) RETURN(0); } +EXPORT_SYMBOL(target_pack_pool_reply); int target_send_reply_msg(struct ptlrpc_request *req, int rc, int fail_id) { @@ -2516,6 +2532,7 @@ void target_send_reply(struct ptlrpc_request *req, int rc, int fail_id) cfs_spin_unlock(&svcpt->scp_rep_lock); EXIT; } +EXPORT_SYMBOL(target_send_reply); ldlm_mode_t lck_compat_array[] = { [LCK_EX] LCK_COMPAT_EX, diff --git a/lustre/ldlm/ldlm_lock.c b/lustre/ldlm/ldlm_lock.c index e25e85a..165fe68 100644 --- a/lustre/ldlm/ldlm_lock.c +++ b/lustre/ldlm/ldlm_lock.c @@ -63,6 +63,7 @@ char *ldlm_lockname[] = { [LCK_GROUP] "GROUP", [LCK_COS] "COS" }; +EXPORT_SYMBOL(ldlm_lockname); char *ldlm_typename[] = { [LDLM_PLAIN] "PLN", @@ -70,6 +71,7 @@ char *ldlm_typename[] = { [LDLM_FLOCK] "FLK", [LDLM_IBITS] "IBT", }; +EXPORT_SYMBOL(ldlm_typename); static ldlm_policy_wire_to_local_t ldlm_policy_wire18_to_local[] = { [LDLM_PLAIN - LDLM_MIN_TYPE] ldlm_plain_policy_wire_to_local, @@ -152,6 +154,7 @@ char *ldlm_it2str(int it) return "UNKNOWN"; } } +EXPORT_SYMBOL(ldlm_it2str); extern cfs_mem_cache_t *ldlm_lock_slab; @@ -169,12 +172,14 @@ ldlm_processing_policy ldlm_get_processing_policy(struct ldlm_resource *res) { return ldlm_processing_policy_table[res->lr_type]; } +EXPORT_SYMBOL(ldlm_get_processing_policy); #endif /* HAVE_SERVER_SUPPORT */ void ldlm_register_intent(struct ldlm_namespace *ns, ldlm_res_policy arg) { ns->ns_policy = arg; } +EXPORT_SYMBOL(ldlm_register_intent); /* * REFCOUNTED LOCK OBJECTS @@ -192,6 +197,7 @@ struct ldlm_lock *ldlm_lock_get(struct ldlm_lock *lock) cfs_atomic_inc(&lock->l_refc); return lock; } +EXPORT_SYMBOL(ldlm_lock_get); void ldlm_lock_put(struct ldlm_lock *lock) { @@ -230,6 +236,7 @@ void ldlm_lock_put(struct ldlm_lock *lock) EXIT; } +EXPORT_SYMBOL(ldlm_lock_put); int ldlm_lock_remove_from_lru_nolock(struct ldlm_lock *lock) { @@ -520,6 +527,7 @@ int ldlm_lock_change_resource(struct ldlm_namespace *ns, struct ldlm_lock *lock, RETURN(0); } +EXPORT_SYMBOL(ldlm_lock_change_resource); /* * HANDLES @@ -529,6 +537,7 @@ void ldlm_lock2handle(const struct ldlm_lock *lock, struct lustre_handle *lockh) { lockh->cookie = lock->l_handle.h_cookie; } +EXPORT_SYMBOL(ldlm_lock2handle); /* if flags: atomically get the lock and set the flags. * Return NULL if flag already set @@ -577,6 +586,7 @@ struct ldlm_lock *__ldlm_handle2lock(const struct lustre_handle *handle, unlock_res_and_lock(lock); RETURN(lock); } +EXPORT_SYMBOL(__ldlm_handle2lock); void ldlm_lock2desc(struct ldlm_lock *lock, struct ldlm_lock_desc *desc) { @@ -626,6 +636,7 @@ void ldlm_lock2desc(struct ldlm_lock *lock, struct ldlm_lock_desc *desc) &desc->l_policy_data); } } +EXPORT_SYMBOL(ldlm_lock2desc); void ldlm_add_bl_work_item(struct ldlm_lock *lock, struct ldlm_lock *new, cfs_list_t *work_list) @@ -678,6 +689,7 @@ void ldlm_lock_addref(struct lustre_handle *lockh, __u32 mode) ldlm_lock_addref_internal(lock, mode); LDLM_LOCK_PUT(lock); } +EXPORT_SYMBOL(ldlm_lock_addref); void ldlm_lock_addref_internal_nolock(struct ldlm_lock *lock, __u32 mode) { @@ -722,6 +734,7 @@ int ldlm_lock_addref_try(struct lustre_handle *lockh, __u32 mode) } return result; } +EXPORT_SYMBOL(ldlm_lock_addref_try); /* only called for local locks */ void ldlm_lock_addref_internal(struct ldlm_lock *lock, __u32 mode) @@ -828,6 +841,7 @@ void ldlm_lock_decref(struct lustre_handle *lockh, __u32 mode) ldlm_lock_decref_internal(lock, mode); LDLM_LOCK_PUT(lock); } +EXPORT_SYMBOL(ldlm_lock_decref); /* This will drop a lock reference and mark it for destruction, but will not * necessarily cancel the lock before returning. */ @@ -845,6 +859,7 @@ void ldlm_lock_decref_and_cancel(struct lustre_handle *lockh, __u32 mode) ldlm_lock_decref_internal(lock, mode); LDLM_LOCK_PUT(lock); } +EXPORT_SYMBOL(ldlm_lock_decref_and_cancel); struct sl_insert_point { cfs_list_t *res_link; @@ -1117,6 +1132,7 @@ void ldlm_lock_allow_match_locked(struct ldlm_lock *lock) lock->l_flags |= LDLM_FL_LVB_READY; cfs_waitq_broadcast(&lock->l_waitq); } +EXPORT_SYMBOL(ldlm_lock_allow_match_locked); void ldlm_lock_allow_match(struct ldlm_lock *lock) { @@ -1124,6 +1140,7 @@ void ldlm_lock_allow_match(struct ldlm_lock *lock) ldlm_lock_allow_match_locked(lock); unlock_res_and_lock(lock); } +EXPORT_SYMBOL(ldlm_lock_allow_match); /* Can be called in two ways: * @@ -1270,6 +1287,7 @@ ldlm_mode_t ldlm_lock_match(struct ldlm_namespace *ns, int flags, return rc ? mode : 0; } +EXPORT_SYMBOL(ldlm_lock_match); ldlm_mode_t ldlm_revalidate_lock_handle(struct lustre_handle *lockh, __u64 *bits) @@ -1737,6 +1755,7 @@ void ldlm_reprocess_all_ns(struct ldlm_namespace *ns) } EXIT; } +EXPORT_SYMBOL(ldlm_reprocess_all_ns); void ldlm_reprocess_all(struct ldlm_resource *res) { @@ -1845,6 +1864,7 @@ void ldlm_lock_cancel(struct ldlm_lock *lock) EXIT; } +EXPORT_SYMBOL(ldlm_lock_cancel); int ldlm_lock_set_data(struct lustre_handle *lockh, void *data) { @@ -1941,6 +1961,7 @@ void ldlm_lock_downgrade(struct ldlm_lock *lock, int new_mode) EXIT; } +EXPORT_SYMBOL(ldlm_lock_downgrade); struct ldlm_resource *ldlm_lock_convert(struct ldlm_lock *lock, int new_mode, __u32 *flags) @@ -2060,6 +2081,7 @@ struct ldlm_resource *ldlm_lock_convert(struct ldlm_lock *lock, int new_mode, OBD_SLAB_FREE(node, ldlm_interval_slab, sizeof(*node)); RETURN(res); } +EXPORT_SYMBOL(ldlm_lock_convert); void ldlm_lock_dump_handle(int level, struct lustre_handle *lockh) { @@ -2076,6 +2098,7 @@ void ldlm_lock_dump_handle(int level, struct lustre_handle *lockh) LDLM_LOCK_PUT(lock); } +EXPORT_SYMBOL(ldlm_lock_dump_handle); void _ldlm_lock_debug(struct ldlm_lock *lock, struct libcfs_debug_msg_data *msgdata, diff --git a/lustre/ldlm/ldlm_lockd.c b/lustre/ldlm/ldlm_lockd.c index 8dcde3e..27178d1 100644 --- a/lustre/ldlm/ldlm_lockd.c +++ b/lustre/ldlm/ldlm_lockd.c @@ -551,6 +551,7 @@ int ldlm_del_waiting_lock(struct ldlm_lock *lock) LDLM_DEBUG(lock, "%s", ret == 0 ? "wasn't waiting" : "removed"); return ret; } +EXPORT_SYMBOL(ldlm_del_waiting_lock); /* * Prolong the lock @@ -582,6 +583,7 @@ int ldlm_refresh_waiting_lock(struct ldlm_lock *lock, int timeout) LDLM_DEBUG(lock, "refreshed"); return 1; } +EXPORT_SYMBOL(ldlm_refresh_waiting_lock); #else /* !HAVE_SERVER_SUPPORT || !__KERNEL__ */ @@ -889,6 +891,7 @@ int ldlm_server_blocking_ast(struct ldlm_lock *lock, RETURN(rc); } +EXPORT_SYMBOL(ldlm_server_blocking_ast); int ldlm_server_completion_ast(struct ldlm_lock *lock, int flags, void *data) { @@ -1004,6 +1007,7 @@ int ldlm_server_completion_ast(struct ldlm_lock *lock, int flags, void *data) RETURN(rc); } +EXPORT_SYMBOL(ldlm_server_completion_ast); int ldlm_server_glimpse_ast(struct ldlm_lock *lock, void *data) { @@ -1067,6 +1071,7 @@ int ldlm_server_glimpse_ast(struct ldlm_lock *lock, void *data) RETURN(rc); } +EXPORT_SYMBOL(ldlm_server_glimpse_ast); int ldlm_glimpse_locks(struct ldlm_resource *res, cfs_list_t *gl_work_list) { @@ -1080,6 +1085,7 @@ int ldlm_glimpse_locks(struct ldlm_resource *res, cfs_list_t *gl_work_list) RETURN(rc); } +EXPORT_SYMBOL(ldlm_glimpse_locks); /* return ldlm lock associated with a lock callback request */ struct ldlm_lock *ldlm_request_lock(struct ptlrpc_request *req) @@ -1403,6 +1409,7 @@ existing_lock: return rc; } +EXPORT_SYMBOL(ldlm_handle_enqueue0); int ldlm_handle_enqueue(struct ptlrpc_request *req, ldlm_completion_callback completion_callback, @@ -1426,6 +1433,7 @@ int ldlm_handle_enqueue(struct ptlrpc_request *req, } return rc; } +EXPORT_SYMBOL(ldlm_handle_enqueue); int ldlm_handle_convert0(struct ptlrpc_request *req, const struct ldlm_request *dlm_req) @@ -1477,6 +1485,7 @@ int ldlm_handle_convert0(struct ptlrpc_request *req, RETURN(0); } +EXPORT_SYMBOL(ldlm_handle_convert0); int ldlm_handle_convert(struct ptlrpc_request *req) { @@ -1492,6 +1501,7 @@ int ldlm_handle_convert(struct ptlrpc_request *req) } return rc; } +EXPORT_SYMBOL(ldlm_handle_convert); /* Cancel all the locks whos handles are packed into ldlm_request */ int ldlm_request_cancel(struct ptlrpc_request *req, @@ -1553,6 +1563,7 @@ int ldlm_request_cancel(struct ptlrpc_request *req, LDLM_DEBUG_NOLOCK("server-side cancel handler END"); RETURN(done); } +EXPORT_SYMBOL(ldlm_request_cancel); int ldlm_handle_cancel(struct ptlrpc_request *req) { @@ -1580,6 +1591,7 @@ int ldlm_handle_cancel(struct ptlrpc_request *req) RETURN(ptlrpc_reply(req)); } +EXPORT_SYMBOL(ldlm_handle_cancel); #endif /* HAVE_SERVER_SUPPORT */ void ldlm_handle_bl_callback(struct ldlm_namespace *ns, @@ -2364,6 +2376,7 @@ void ldlm_revoke_export_locks(struct obd_export *exp) EXIT; } +EXPORT_SYMBOL(ldlm_revoke_export_locks); #endif /* HAVE_SERVER_SUPPORT */ #ifdef __KERNEL__ @@ -2522,6 +2535,7 @@ int ldlm_get_ref(void) RETURN(rc); } +EXPORT_SYMBOL(ldlm_get_ref); void ldlm_put_ref(void) { @@ -2540,6 +2554,7 @@ void ldlm_put_ref(void) EXIT; } +EXPORT_SYMBOL(ldlm_put_ref); /* * Export handle<->lock hash operations. @@ -2918,113 +2933,3 @@ void ldlm_exit(void) rc = cfs_mem_cache_destroy(ldlm_interval_slab); LASSERTF(rc == 0, "couldn't free interval node slab\n"); } - -/* ldlm_extent.c */ -EXPORT_SYMBOL(ldlm_extent_shift_kms); - -/* ldlm_lock.c */ -#ifdef HAVE_SERVER_SUPPORT -EXPORT_SYMBOL(ldlm_get_processing_policy); -#endif -EXPORT_SYMBOL(ldlm_lock2desc); -EXPORT_SYMBOL(ldlm_register_intent); -EXPORT_SYMBOL(ldlm_lockname); -EXPORT_SYMBOL(ldlm_typename); -EXPORT_SYMBOL(ldlm_lock2handle); -EXPORT_SYMBOL(__ldlm_handle2lock); -EXPORT_SYMBOL(ldlm_lock_get); -EXPORT_SYMBOL(ldlm_lock_put); -EXPORT_SYMBOL(ldlm_lock_match); -EXPORT_SYMBOL(ldlm_lock_cancel); -EXPORT_SYMBOL(ldlm_lock_addref); -EXPORT_SYMBOL(ldlm_lock_addref_try); -EXPORT_SYMBOL(ldlm_lock_decref); -EXPORT_SYMBOL(ldlm_lock_decref_and_cancel); -EXPORT_SYMBOL(ldlm_lock_change_resource); -EXPORT_SYMBOL(ldlm_it2str); -EXPORT_SYMBOL(ldlm_lock_dump_handle); -EXPORT_SYMBOL(ldlm_reprocess_all_ns); -EXPORT_SYMBOL(ldlm_lock_allow_match_locked); -EXPORT_SYMBOL(ldlm_lock_allow_match); -EXPORT_SYMBOL(ldlm_lock_downgrade); -EXPORT_SYMBOL(ldlm_lock_convert); - -/* ldlm_request.c */ -EXPORT_SYMBOL(ldlm_completion_ast_async); -EXPORT_SYMBOL(ldlm_blocking_ast_nocheck); -EXPORT_SYMBOL(ldlm_completion_ast); -EXPORT_SYMBOL(ldlm_blocking_ast); -EXPORT_SYMBOL(ldlm_glimpse_ast); -EXPORT_SYMBOL(ldlm_expired_completion_wait); -EXPORT_SYMBOL(ldlm_prep_enqueue_req); -EXPORT_SYMBOL(ldlm_prep_elc_req); -EXPORT_SYMBOL(ldlm_cli_convert); -EXPORT_SYMBOL(ldlm_cli_enqueue); -EXPORT_SYMBOL(ldlm_cli_enqueue_fini); -EXPORT_SYMBOL(ldlm_cli_enqueue_local); -EXPORT_SYMBOL(ldlm_cli_cancel); -EXPORT_SYMBOL(ldlm_cli_cancel_unused); -EXPORT_SYMBOL(ldlm_cli_cancel_unused_resource); -EXPORT_SYMBOL(ldlm_cli_cancel_req); -EXPORT_SYMBOL(ldlm_replay_locks); -EXPORT_SYMBOL(ldlm_resource_foreach); -EXPORT_SYMBOL(ldlm_namespace_foreach); -EXPORT_SYMBOL(ldlm_resource_iterate); -EXPORT_SYMBOL(ldlm_cancel_resource_local); -EXPORT_SYMBOL(ldlm_cli_cancel_list_local); -EXPORT_SYMBOL(ldlm_cli_cancel_list); - -/* ldlm_lockd.c */ -#ifdef HAVE_SERVER_SUPPORT -EXPORT_SYMBOL(ldlm_server_blocking_ast); -EXPORT_SYMBOL(ldlm_server_completion_ast); -EXPORT_SYMBOL(ldlm_server_glimpse_ast); -EXPORT_SYMBOL(ldlm_glimpse_locks); -EXPORT_SYMBOL(ldlm_handle_enqueue); -EXPORT_SYMBOL(ldlm_handle_enqueue0); -EXPORT_SYMBOL(ldlm_handle_cancel); -EXPORT_SYMBOL(ldlm_request_cancel); -EXPORT_SYMBOL(ldlm_handle_convert); -EXPORT_SYMBOL(ldlm_handle_convert0); -EXPORT_SYMBOL(ldlm_revoke_export_locks); -#endif -EXPORT_SYMBOL(ldlm_del_waiting_lock); -EXPORT_SYMBOL(ldlm_get_ref); -EXPORT_SYMBOL(ldlm_put_ref); -EXPORT_SYMBOL(ldlm_refresh_waiting_lock); - -/* ldlm_resource.c */ -EXPORT_SYMBOL(ldlm_namespace_new); -EXPORT_SYMBOL(ldlm_namespace_cleanup); -EXPORT_SYMBOL(ldlm_namespace_free); -EXPORT_SYMBOL(ldlm_namespace_dump); -EXPORT_SYMBOL(ldlm_dump_all_namespaces); -EXPORT_SYMBOL(ldlm_resource_get); -EXPORT_SYMBOL(ldlm_resource_putref); -EXPORT_SYMBOL(ldlm_resource_unlink_lock); - -/* ldlm_lib.c */ -EXPORT_SYMBOL(client_import_add_conn); -EXPORT_SYMBOL(client_import_del_conn); -EXPORT_SYMBOL(client_obd_setup); -EXPORT_SYMBOL(client_obd_cleanup); -EXPORT_SYMBOL(client_connect_import); -EXPORT_SYMBOL(client_disconnect_export); -EXPORT_SYMBOL(target_send_reply); -EXPORT_SYMBOL(target_pack_pool_reply); - -#ifdef HAVE_SERVER_SUPPORT -EXPORT_SYMBOL(server_disconnect_export); -EXPORT_SYMBOL(target_stop_recovery_thread); -EXPORT_SYMBOL(target_handle_connect); -EXPORT_SYMBOL(target_cleanup_recovery); -EXPORT_SYMBOL(target_destroy_export); -EXPORT_SYMBOL(target_cancel_recovery_timer); -EXPORT_SYMBOL(target_queue_recovery_request); -EXPORT_SYMBOL(target_handle_ping); -EXPORT_SYMBOL(target_handle_disconnect); -#endif - -/* l_lock.c */ -EXPORT_SYMBOL(lock_res_and_lock); -EXPORT_SYMBOL(unlock_res_and_lock); diff --git a/lustre/ldlm/ldlm_request.c b/lustre/ldlm/ldlm_request.c index d899f5f..dd561dc 100644 --- a/lustre/ldlm/ldlm_request.c +++ b/lustre/ldlm/ldlm_request.c @@ -108,6 +108,7 @@ int ldlm_expired_completion_wait(void *data) RETURN(0); } +EXPORT_SYMBOL(ldlm_expired_completion_wait); /* We use the same basis for both server side and client side functions from a single node. */ @@ -175,6 +176,7 @@ int ldlm_completion_ast_async(struct ldlm_lock *lock, int flags, void *data) ldlm_reprocess_all(lock->l_resource); RETURN(0); } +EXPORT_SYMBOL(ldlm_completion_ast_async); /** * Client side LDLM "completion" AST. This is called in several cases: @@ -272,6 +274,7 @@ noreproc: RETURN(ldlm_completion_tail(lock)); } +EXPORT_SYMBOL(ldlm_completion_ast); /** * A helper to build a blocking ast function @@ -308,6 +311,7 @@ int ldlm_blocking_ast_nocheck(struct ldlm_lock *lock) } RETURN(0); } +EXPORT_SYMBOL(ldlm_blocking_ast_nocheck); /** * Server blocking AST @@ -344,6 +348,7 @@ int ldlm_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc, } RETURN(ldlm_blocking_ast_nocheck(lock)); } +EXPORT_SYMBOL(ldlm_blocking_ast); /* * ->l_glimpse_ast() for DLM extent locks acquired on the server-side. See @@ -371,6 +376,7 @@ int ldlm_glimpse_ast(struct ldlm_lock *lock, void *reqp) */ return -ELDLM_NO_LOCK_DATA; } +EXPORT_SYMBOL(ldlm_glimpse_ast); int ldlm_cli_enqueue_local(struct ldlm_namespace *ns, const struct ldlm_res_id *res_id, @@ -434,6 +440,7 @@ int ldlm_cli_enqueue_local(struct ldlm_namespace *ns, out_nolock: return err; } +EXPORT_SYMBOL(ldlm_cli_enqueue_local); static void failed_lock_cleanup(struct ldlm_namespace *ns, struct ldlm_lock *lock, int mode) @@ -658,6 +665,7 @@ cleanup: LDLM_LOCK_RELEASE(lock); return rc; } +EXPORT_SYMBOL(ldlm_cli_enqueue_fini); /* PAGE_SIZE-512 is to allow TCP/IP and LNET headers to fit into * a single page on the send/receive side. XXX: 512 should be changed @@ -757,6 +765,7 @@ int ldlm_prep_elc_req(struct obd_export *exp, struct ptlrpc_request *req, } RETURN(0); } +EXPORT_SYMBOL(ldlm_prep_elc_req); int ldlm_prep_enqueue_req(struct obd_export *exp, struct ptlrpc_request *req, cfs_list_t *cancels, int count) @@ -764,6 +773,7 @@ int ldlm_prep_enqueue_req(struct obd_export *exp, struct ptlrpc_request *req, return ldlm_prep_elc_req(exp, req, LUSTRE_DLM_VERSION, LDLM_ENQUEUE, LDLM_ENQUEUE_CANCEL_OFF, cancels, count); } +EXPORT_SYMBOL(ldlm_prep_enqueue_req); /* If a request has some specific initialisation it is passed in @reqp, * otherwise it is created in ldlm_cli_enqueue. @@ -914,6 +924,7 @@ int ldlm_cli_enqueue(struct obd_export *exp, struct ptlrpc_request **reqp, RETURN(rc); } +EXPORT_SYMBOL(ldlm_cli_enqueue); static int ldlm_cli_convert_local(struct ldlm_lock *lock, int new_mode, __u32 *flags) @@ -1012,6 +1023,7 @@ int ldlm_cli_convert(struct lustre_handle *lockh, int new_mode, __u32 *flags) ptlrpc_req_finished(req); return rc; } +EXPORT_SYMBOL(ldlm_cli_convert); /* Cancel locks locally. * Returns: @@ -1178,6 +1190,7 @@ int ldlm_cli_cancel_req(struct obd_export *exp, cfs_list_t *cancels, out: return sent ? sent : rc; } +EXPORT_SYMBOL(ldlm_cli_cancel_req); static inline struct ldlm_pool *ldlm_imp2pl(struct obd_import *imp) { @@ -1282,6 +1295,7 @@ int ldlm_cli_cancel(struct lustre_handle *lockh) ldlm_cli_cancel_list(&cancels, count, NULL, 0); RETURN(0); } +EXPORT_SYMBOL(ldlm_cli_cancel); /* XXX until we will have compound requests and can cut cancels from generic rpc * we need send cancels with LDLM_FL_BL_AST flag as separate rpc */ @@ -1325,6 +1339,7 @@ int ldlm_cli_cancel_list_local(cfs_list_t *cancels, int count, RETURN(count); } +EXPORT_SYMBOL(ldlm_cli_cancel_list_local); /** * Cancel as many locks as possible w/o sending any rpcs (e.g. to write back @@ -1750,6 +1765,7 @@ int ldlm_cancel_resource_local(struct ldlm_resource *res, RETURN(ldlm_cli_cancel_list_local(cancels, count, cancel_flags)); } +EXPORT_SYMBOL(ldlm_cancel_resource_local); /* If @req is NULL, send CANCEL request to server with handles of locks * in the @cancels. If EARLY_CANCEL is not supported, send CANCEL requests @@ -1802,6 +1818,7 @@ int ldlm_cli_cancel_list(cfs_list_t *cancels, int count, LASSERT(count == 0); RETURN(0); } +EXPORT_SYMBOL(ldlm_cli_cancel_list); int ldlm_cli_cancel_unused_resource(struct ldlm_namespace *ns, const struct ldlm_res_id *res_id, @@ -1834,6 +1851,7 @@ int ldlm_cli_cancel_unused_resource(struct ldlm_namespace *ns, ldlm_resource_putref(res); RETURN(0); } +EXPORT_SYMBOL(ldlm_cli_cancel_unused_resource); struct ldlm_cli_cancel_arg { int lc_flags; @@ -1887,6 +1905,7 @@ int ldlm_cli_cancel_unused(struct ldlm_namespace *ns, RETURN(ELDLM_OK); } } +EXPORT_SYMBOL(ldlm_cli_cancel_unused); /* Lock iterators. */ @@ -1927,6 +1946,7 @@ int ldlm_resource_foreach(struct ldlm_resource *res, ldlm_iterator_t iter, unlock_res(res); RETURN(rc); } +EXPORT_SYMBOL(ldlm_resource_foreach); struct iter_helper_data { ldlm_iterator_t iter; @@ -1959,6 +1979,7 @@ void ldlm_namespace_foreach(struct ldlm_namespace *ns, ldlm_res_iter_helper, &helper); } +EXPORT_SYMBOL(ldlm_namespace_foreach); /* non-blocking function to manipulate a lock whose cb_data is being put away. * return 0: find no resource @@ -1988,6 +2009,7 @@ int ldlm_resource_iterate(struct ldlm_namespace *ns, ldlm_resource_putref(res); RETURN(rc); } +EXPORT_SYMBOL(ldlm_resource_iterate); /* Lock replay */ @@ -2212,3 +2234,4 @@ int ldlm_replay_locks(struct obd_import *imp) RETURN(rc); } +EXPORT_SYMBOL(ldlm_replay_locks); diff --git a/lustre/ldlm/ldlm_resource.c b/lustre/ldlm/ldlm_resource.c index a55e947..bb916b6 100644 --- a/lustre/ldlm/ldlm_resource.c +++ b/lustre/ldlm/ldlm_resource.c @@ -658,6 +658,7 @@ out_ref: ldlm_put_ref(); RETURN(NULL); } +EXPORT_SYMBOL(ldlm_namespace_new); extern struct ldlm_lock *ldlm_lock_get(struct ldlm_lock *lock); @@ -780,6 +781,7 @@ int ldlm_namespace_cleanup(struct ldlm_namespace *ns, int flags) cfs_hash_for_each_nolock(ns->ns_rs_hash, ldlm_resource_complain, NULL); return ELDLM_OK; } +EXPORT_SYMBOL(ldlm_namespace_cleanup); static int __ldlm_namespace_free(struct ldlm_namespace *ns, int force) { @@ -931,6 +933,7 @@ void ldlm_namespace_free(struct ldlm_namespace *ns, ldlm_namespace_free_prior(ns, imp, force); ldlm_namespace_free_post(ns); } +EXPORT_SYMBOL(ldlm_namespace_free); void ldlm_namespace_get(struct ldlm_namespace *ns) { @@ -1107,6 +1110,7 @@ ldlm_resource_get(struct ldlm_namespace *ns, struct ldlm_resource *parent, return res; } +EXPORT_SYMBOL(ldlm_resource_get); struct ldlm_resource *ldlm_resource_getref(struct ldlm_resource *res) { @@ -1166,6 +1170,7 @@ int ldlm_resource_putref(struct ldlm_resource *res) } return 0; } +EXPORT_SYMBOL(ldlm_resource_putref); /* Returns 1 if the resource was freed, 0 if it remains. */ int ldlm_resource_putref_locked(struct ldlm_resource *res) @@ -1247,6 +1252,7 @@ void ldlm_resource_unlink_lock(struct ldlm_lock *lock) ldlm_extent_unlink_lock(lock); cfs_list_del_init(&lock->l_res_link); } +EXPORT_SYMBOL(ldlm_resource_unlink_lock); void ldlm_res2desc(struct ldlm_resource *res, struct ldlm_resource_desc *desc) { @@ -1271,6 +1277,7 @@ void ldlm_dump_all_namespaces(ldlm_side_t client, int level) cfs_mutex_unlock(ldlm_namespace_lock(client)); } +EXPORT_SYMBOL(ldlm_dump_all_namespaces); static int ldlm_res_hash_dump(cfs_hash_t *hs, cfs_hash_bd_t *bd, cfs_hlist_node_t *hnode, void *arg) @@ -1304,6 +1311,7 @@ void ldlm_namespace_dump(int level, struct ldlm_namespace *ns) ns->ns_next_dump = cfs_time_shift(10); cfs_spin_unlock(&ns->ns_lock); } +EXPORT_SYMBOL(ldlm_namespace_dump); void ldlm_resource_dump(int level, struct ldlm_resource *res) {