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 <xuezhao.liu@emc.com>
Change-Id: I5644d908c652b2e34d81e923367af4b5728399e1
Reviewed-on: http://review.whamcloud.com/2837
Tested-by: Hudson
Reviewed-by: Keith Mannthey <keith.mannthey@intel.com>
Reviewed-by: Andreas Dilger <adilger@whamcloud.com>
Tested-by: Maloo <whamcloud.maloo@gmail.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>

diff --git a/lustre/ldlm/l_lock.c b/lustre/ldlm/l_lock.c
index d1de7d1..124f834 100644 (file)
--- a/lustre/ldlm/l_lock.c
+++ b/lustre/ldlm/l_lock.c
@@ -35,7 +35,7 @@
 #define DEBUG_SUBSYSTEM S_LDLM
 #ifdef __KERNEL__
 #include <libcfs/libcfs.h>
 #define DEBUG_SUBSYSTEM S_LDLM
 #ifdef __KERNEL__
 #include <libcfs/libcfs.h>

-#else 
+#else

 #include <liblustre.h>
 #endif
 
 #include <liblustre.h>
 #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;
 }
        lock->l_res_locked = 1;
        return lock->l_resource;
 }

+EXPORT_SYMBOL(lock_res_and_lock);

 
 void unlock_res_and_lock(struct ldlm_lock *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);
 }
        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 (file)
--- 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);
 }
 
         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)
 
 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 (file)
--- 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);
 }
 {
         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)
 {
 
 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);
 }
                 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
 
 /**
  * Find conn uuid by peer nid. @peer is a server nid. This function is used


@@ -464,6 +466,7 @@ err:
         RETURN(rc);
 
 }
         RETURN(rc);
 
 }

+EXPORT_SYMBOL(client_obd_setup);

 
 int client_obd_cleanup(struct obd_device *obddev)
 {
 
 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);
 }
         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,
 
 /* ->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;
 }
 
         return rc;
 }

+EXPORT_SYMBOL(client_connect_import);

 
 int client_disconnect_export(struct obd_export *exp)
 {
 
 int client_disconnect_export(struct obd_export *exp)
 {


@@ -619,6 +624,7 @@ int client_disconnect_export(struct obd_export *exp)
 
         RETURN(rc);
 }
 
         RETURN(rc);
 }

+EXPORT_SYMBOL(client_disconnect_export);

 
 #ifdef HAVE_SERVER_SUPPORT
 int server_disconnect_export(struct obd_export *exp)
 
 #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);
 }
 
        RETURN(rc);
 }

+EXPORT_SYMBOL(server_disconnect_export);

 
 /* --------------------------------------------------------------------------
  * from old lib/target.c
 
 /* --------------------------------------------------------------------------
  * from old lib/target.c


@@ -1278,6 +1285,7 @@ out:
                 req->rq_status = rc;
         RETURN(rc);
 }
                 req->rq_status = rc;
         RETURN(rc);
 }

+EXPORT_SYMBOL(target_handle_connect);

 
 int target_handle_disconnect(struct ptlrpc_request *req)
 {
 
 int target_handle_disconnect(struct ptlrpc_request *req)
 {


@@ -1293,6 +1301,7 @@ int target_handle_disconnect(struct ptlrpc_request *req)
 
         RETURN(0);
 }
 
         RETURN(0);
 }

+EXPORT_SYMBOL(target_handle_disconnect);

 
 void target_destroy_export(struct obd_export *exp)
 {
 
 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);
 }
        LASSERT_ATOMIC_ZERO(&exp->exp_cb_count);
        LASSERT_ATOMIC_ZERO(&exp->exp_replay_count);
 }

+EXPORT_SYMBOL(target_destroy_export);

 
 /*
  * Recovery functions
 
 /*
  * Recovery functions


@@ -1518,6 +1528,7 @@ void target_cleanup_recovery(struct obd_device *obd)
 
         EXIT;
 }
 
         EXIT;
 }

+EXPORT_SYMBOL(target_cleanup_recovery);

 
 /* obd_recovery_task_lock should be held */
 void target_cancel_recovery_timer(struct obd_device *obd)
 
 /* 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);
 }
         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)
 {
 
 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);
         }
 }
                 cfs_wait_for_completion(&trd->trd_finishing);
         }
 }

+EXPORT_SYMBOL(target_stop_recovery_thread);

 
 void target_recovery_fini(struct obd_device *obd)
 {
 
 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);
 }
         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);
 }
 
 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)
 {
 
 void target_committed_to_req(struct ptlrpc_request *req)
 {


@@ -2406,6 +2421,7 @@ int target_pack_pool_reply(struct ptlrpc_request *req)
 
         RETURN(0);
 }
 
         RETURN(0);
 }

+EXPORT_SYMBOL(target_pack_pool_reply);

 
 int target_send_reply_msg(struct ptlrpc_request *req, int rc, int fail_id)
 {
 
 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;
 }
        cfs_spin_unlock(&svcpt->scp_rep_lock);
        EXIT;
 }

+EXPORT_SYMBOL(target_send_reply);

 
 ldlm_mode_t lck_compat_array[] = {
         [LCK_EX] LCK_COMPAT_EX,
 
 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 (file)
--- 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"
 };
         [LCK_GROUP] "GROUP",
         [LCK_COS] "COS"
 };

+EXPORT_SYMBOL(ldlm_lockname);

 
 char *ldlm_typename[] = {
         [LDLM_PLAIN] "PLN",
 
 char *ldlm_typename[] = {
         [LDLM_PLAIN] "PLN",


@@ -70,6 +71,7 @@ char *ldlm_typename[] = {
         [LDLM_FLOCK] "FLK",
         [LDLM_IBITS] "IBT",
 };
         [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,
 
 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";
         }
 }
                 return "UNKNOWN";
         }
 }

+EXPORT_SYMBOL(ldlm_it2str);

 
 extern cfs_mem_cache_t *ldlm_lock_slab;
 
 
 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];
 }
 {
         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;
 }
 #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
 
 /*
  * 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;
 }
         cfs_atomic_inc(&lock->l_refc);
         return lock;
 }

+EXPORT_SYMBOL(ldlm_lock_get);

 
 void ldlm_lock_put(struct ldlm_lock *lock)
 {
 
 void ldlm_lock_put(struct ldlm_lock *lock)
 {


@@ -230,6 +236,7 @@ void ldlm_lock_put(struct ldlm_lock *lock)
 
         EXIT;
 }
 
         EXIT;
 }

+EXPORT_SYMBOL(ldlm_lock_put);

 
 int ldlm_lock_remove_from_lru_nolock(struct ldlm_lock *lock)
 {
 
 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);
 }
 
         RETURN(0);
 }

+EXPORT_SYMBOL(ldlm_lock_change_resource);

 
 /*
  *  HANDLES
 
 /*
  *  HANDLES


@@ -529,6 +537,7 @@ void ldlm_lock2handle(const struct ldlm_lock *lock, struct lustre_handle *lockh)
 {
         lockh->cookie = lock->l_handle.h_cookie;
 }
 {
         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
 
 /* 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);
 }
         unlock_res_and_lock(lock);
         RETURN(lock);
 }

+EXPORT_SYMBOL(__ldlm_handle2lock);

 
 void ldlm_lock2desc(struct ldlm_lock *lock, struct ldlm_lock_desc *desc)
 {
 
 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);
         }
 }
                                             &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)
 
 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);
 }
         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)
 {
 
 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;
 }
         }
         return result;
 }

+EXPORT_SYMBOL(ldlm_lock_addref_try);

 
 /* only called for local locks */
 void ldlm_lock_addref_internal(struct ldlm_lock *lock, __u32 mode)
 
 /* 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);
 }
         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. */
 
 /* 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);
 }
         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;
 
 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);
 }
         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)
 {
 
 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);
 }
         ldlm_lock_allow_match_locked(lock);
         unlock_res_and_lock(lock);
 }

+EXPORT_SYMBOL(ldlm_lock_allow_match);

 
 /* Can be called in two ways:
  *
 
 /* 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;
 }
 
         return rc ? mode : 0;
 }

+EXPORT_SYMBOL(ldlm_lock_match);

 
 ldlm_mode_t ldlm_revalidate_lock_handle(struct lustre_handle *lockh,
                                         __u64 *bits)
 
 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;
 }
         }
         EXIT;
 }

+EXPORT_SYMBOL(ldlm_reprocess_all_ns);

 
 void ldlm_reprocess_all(struct ldlm_resource *res)
 {
 
 void ldlm_reprocess_all(struct ldlm_resource *res)
 {


@@ -1845,6 +1864,7 @@ void ldlm_lock_cancel(struct ldlm_lock *lock)
 
         EXIT;
 }
 
         EXIT;
 }

+EXPORT_SYMBOL(ldlm_lock_cancel);

 
 int ldlm_lock_set_data(struct lustre_handle *lockh, void *data)
 {
 
 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;
 }
 
         EXIT;
 }

+EXPORT_SYMBOL(ldlm_lock_downgrade);

 
 struct ldlm_resource *ldlm_lock_convert(struct ldlm_lock *lock, int new_mode,
                                         __u32 *flags)
 
 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);
 }
                 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)
 {
 
 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);
 }
 
         LDLM_LOCK_PUT(lock);
 }

+EXPORT_SYMBOL(ldlm_lock_dump_handle);

 
 void _ldlm_lock_debug(struct ldlm_lock *lock,
                       struct libcfs_debug_msg_data *msgdata,
 
 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 (file)
--- 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;
 }
         LDLM_DEBUG(lock, "%s", ret == 0 ? "wasn't waiting" : "removed");
         return ret;
 }

+EXPORT_SYMBOL(ldlm_del_waiting_lock);

 
 /*
  * Prolong the 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;
 }
         LDLM_DEBUG(lock, "refreshed");
         return 1;
 }

+EXPORT_SYMBOL(ldlm_refresh_waiting_lock);

 
 #else /* !HAVE_SERVER_SUPPORT ||  !__KERNEL__ */
 
 
 #else /* !HAVE_SERVER_SUPPORT ||  !__KERNEL__ */
 


@@ -889,6 +891,7 @@ int ldlm_server_blocking_ast(struct ldlm_lock *lock,
 
         RETURN(rc);
 }
 
         RETURN(rc);
 }

+EXPORT_SYMBOL(ldlm_server_blocking_ast);

 
 int ldlm_server_completion_ast(struct ldlm_lock *lock, int flags, void *data)
 {
 
 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);
 }
 
         RETURN(rc);
 }

+EXPORT_SYMBOL(ldlm_server_completion_ast);

 
 int ldlm_server_glimpse_ast(struct ldlm_lock *lock, void *data)
 {
 
 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);
 }
 
        RETURN(rc);
 }

+EXPORT_SYMBOL(ldlm_server_glimpse_ast);

 
 int ldlm_glimpse_locks(struct ldlm_resource *res, cfs_list_t *gl_work_list)
 {
 
 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);
 }
 
        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)
 
 /* 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;
 }
 
         return rc;
 }

+EXPORT_SYMBOL(ldlm_handle_enqueue0);

 
 int ldlm_handle_enqueue(struct ptlrpc_request *req,
                         ldlm_completion_callback completion_callback,
 
 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;
 }
         }
         return rc;
 }

+EXPORT_SYMBOL(ldlm_handle_enqueue);

 
 int ldlm_handle_convert0(struct ptlrpc_request *req,
                          const struct ldlm_request *dlm_req)
 
 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);
 }
 
         RETURN(0);
 }

+EXPORT_SYMBOL(ldlm_handle_convert0);

 
 int ldlm_handle_convert(struct ptlrpc_request *req)
 {
 
 int ldlm_handle_convert(struct ptlrpc_request *req)
 {


@@ -1492,6 +1501,7 @@ int ldlm_handle_convert(struct ptlrpc_request *req)
         }
         return rc;
 }
         }
         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,
 
 /* 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);
 }
         LDLM_DEBUG_NOLOCK("server-side cancel handler END");
         RETURN(done);
 }

+EXPORT_SYMBOL(ldlm_request_cancel);

 
 int ldlm_handle_cancel(struct ptlrpc_request *req)
 {
 
 int ldlm_handle_cancel(struct ptlrpc_request *req)
 {


@@ -1580,6 +1591,7 @@ int ldlm_handle_cancel(struct ptlrpc_request *req)
 
         RETURN(ptlrpc_reply(req));
 }
 
         RETURN(ptlrpc_reply(req));
 }

+EXPORT_SYMBOL(ldlm_handle_cancel);

 #endif /* HAVE_SERVER_SUPPORT */
 
 void ldlm_handle_bl_callback(struct ldlm_namespace *ns,
 #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;
 }
 
         EXIT;
 }

+EXPORT_SYMBOL(ldlm_revoke_export_locks);

 #endif /* HAVE_SERVER_SUPPORT */
 
 #ifdef __KERNEL__
 #endif /* HAVE_SERVER_SUPPORT */
 
 #ifdef __KERNEL__


@@ -2522,6 +2535,7 @@ int ldlm_get_ref(void)
 
         RETURN(rc);
 }
 
         RETURN(rc);
 }

+EXPORT_SYMBOL(ldlm_get_ref);

 
 void ldlm_put_ref(void)
 {
 
 void ldlm_put_ref(void)
 {


@@ -2540,6 +2554,7 @@ void ldlm_put_ref(void)
 
         EXIT;
 }
 
         EXIT;
 }

+EXPORT_SYMBOL(ldlm_put_ref);

 
 /*
  * Export handle<->lock hash operations.
 
 /*
  * 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");
 }
         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 (file)
--- 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);
 }
 
         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. */
 
 /* 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);
 }
         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:
 
 /**
  * Client side LDLM "completion" AST. This is called in several cases:


@@ -272,6 +274,7 @@ noreproc:
 
         RETURN(ldlm_completion_tail(lock));
 }
 
         RETURN(ldlm_completion_tail(lock));
 }

+EXPORT_SYMBOL(ldlm_completion_ast);

 
 /**
  * A helper to build a blocking ast function
 
 /**
  * A helper to build a blocking ast function


@@ -308,6 +311,7 @@ int ldlm_blocking_ast_nocheck(struct ldlm_lock *lock)
         }
         RETURN(0);
 }
         }
         RETURN(0);
 }

+EXPORT_SYMBOL(ldlm_blocking_ast_nocheck);

 
 /**
  * Server blocking AST
 
 /**
  * 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));
 }
         }
         RETURN(ldlm_blocking_ast_nocheck(lock));
 }

+EXPORT_SYMBOL(ldlm_blocking_ast);

 
 /*
  * ->l_glimpse_ast() for DLM extent locks acquired on the server-side. See
 
 /*
  * ->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;
 }
          */
         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,
 
 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;
 }
  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)
 
 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;
 }
         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
 
 /* 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);
 }
         }
         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)
 
 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);
 }
         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.
 
 /* 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);
 }
 
         RETURN(rc);
 }

+EXPORT_SYMBOL(ldlm_cli_enqueue);

 
 static int ldlm_cli_convert_local(struct ldlm_lock *lock, int new_mode,
                                   __u32 *flags)
 
 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;
 }
         ptlrpc_req_finished(req);
         return rc;
 }

+EXPORT_SYMBOL(ldlm_cli_convert);

 
 /* Cancel locks locally.
  * Returns:
 
 /* 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;
 }
 out:
         return sent ? sent : rc;
 }

+EXPORT_SYMBOL(ldlm_cli_cancel_req);

 
 static inline struct ldlm_pool *ldlm_imp2pl(struct obd_import *imp)
 {
 
 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);
 }
         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 */
 
 /* 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);
 }
 
         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
 
 /**
  * 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));
 }
 
         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
 
 /* 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);
 }
         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,
 
 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);
 }
         ldlm_resource_putref(res);
         RETURN(0);
 }

+EXPORT_SYMBOL(ldlm_cli_cancel_unused_resource);

 
 struct ldlm_cli_cancel_arg {
         int     lc_flags;
 
 struct ldlm_cli_cancel_arg {
         int     lc_flags;


@@ -1887,6 +1905,7 @@ int ldlm_cli_cancel_unused(struct ldlm_namespace *ns,
                 RETURN(ELDLM_OK);
         }
 }
                 RETURN(ELDLM_OK);
         }
 }

+EXPORT_SYMBOL(ldlm_cli_cancel_unused);

 
 /* Lock iterators. */
 
 
 /* Lock iterators. */
 


@@ -1927,6 +1946,7 @@ int ldlm_resource_foreach(struct ldlm_resource *res, ldlm_iterator_t iter,
         unlock_res(res);
         RETURN(rc);
 }
         unlock_res(res);
         RETURN(rc);
 }

+EXPORT_SYMBOL(ldlm_resource_foreach);

 
 struct iter_helper_data {
         ldlm_iterator_t iter;
 
 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);
 
 }
                                  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
 
 /* 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);
 }
         ldlm_resource_putref(res);
         RETURN(rc);
 }

+EXPORT_SYMBOL(ldlm_resource_iterate);

 
 /* Lock replay */
 
 
 /* Lock replay */
 


@@ -2212,3 +2234,4 @@ int ldlm_replay_locks(struct obd_import *imp)
 
         RETURN(rc);
 }
 
         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 (file)
--- a/lustre/ldlm/ldlm_resource.c
+++ b/lustre/ldlm/ldlm_resource.c
@@ -658,6 +658,7 @@ out_ref:
         ldlm_put_ref();
         RETURN(NULL);
 }
         ldlm_put_ref();
         RETURN(NULL);
 }

+EXPORT_SYMBOL(ldlm_namespace_new);

 
 extern struct ldlm_lock *ldlm_lock_get(struct ldlm_lock *lock);
 
 
 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;
 }
         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)
 {
 
 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);
 }
         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)
 {
 
 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;
 }
 
         return res;
 }

+EXPORT_SYMBOL(ldlm_resource_get);

 
 struct ldlm_resource *ldlm_resource_getref(struct ldlm_resource *res)
 {
 
 struct ldlm_resource *ldlm_resource_getref(struct ldlm_resource *res)
 {


@@ -1166,6 +1170,7 @@ int ldlm_resource_putref(struct ldlm_resource *res)
         }
         return 0;
 }
         }
         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)
 
 /* 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);
 }
                 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)
 {
 
 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));
 }
 
         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)
 
 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);
 }
         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)
 {
 
 void ldlm_resource_dump(int level, struct ldlm_resource *res)
 {