From: Frank Zago <fzago@cray.com>
Date: Fri, 9 Jan 2015 18:25:58 +0000 (-0600)
Subject: LU-5829 ldlm: remove unnecessary EXPORT_SYMBOL
X-Git-Tag: 2.7.51~38
X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=commitdiff_plain;h=e536e511c9e634d8cb7faf763ecab4cab5f40267

LU-5829 ldlm: remove unnecessary EXPORT_SYMBOL

A lot of symbols don't need to be exported at all because they are
only used in the module they belong to.

Signed-off-by: frank zago <fzago@cray.com>
Change-Id: Ic182e844d621e6ba3c22e685c72b3702ccbb793b
Reviewed-on: http://review.whamcloud.com/13324
Tested-by: Jenkins
Tested-by: Maloo <hpdd-maloo@intel.com>
Reviewed-by: James Simmons <uja.ornl@gmail.com>
Reviewed-by: John L. Hammond <john.hammond@intel.com>
Reviewed-by: Oleg Drokin <oleg.drokin@intel.com>
---

diff --git a/lustre/ldlm/interval_tree.c b/lustre/ldlm/interval_tree.c
index e69d13f..12efd11 100644
--- a/lustre/ldlm/interval_tree.c
+++ b/lustre/ldlm/interval_tree.c
@@ -116,7 +116,6 @@ int node_equal(struct interval_node *n1, struct interval_node *n2)
 {
 	return extent_equal(&n1->in_extent, &n2->in_extent);
 }
-EXPORT_SYMBOL(node_equal);
 
 static inline __u64 max_u64(__u64 x, __u64 y)
 {
@@ -768,4 +767,3 @@ void interval_expand(struct interval_node *root,
                 ext->end = interval_expand_high(root, ext->end);
         LASSERT(interval_is_overlapped(root, ext) == 0);
 }
-EXPORT_SYMBOL(interval_expand);
diff --git a/lustre/ldlm/ldlm_flock.c b/lustre/ldlm/ldlm_flock.c
index f8c0907..f2a0859 100644
--- a/lustre/ldlm/ldlm_flock.c
+++ b/lustre/ldlm/ldlm_flock.c
@@ -965,7 +965,6 @@ int ldlm_init_flock_export(struct obd_export *exp)
 
 	RETURN(0);
 }
-EXPORT_SYMBOL(ldlm_init_flock_export);
 
 void ldlm_destroy_flock_export(struct obd_export *exp)
 {
@@ -976,4 +975,3 @@ void ldlm_destroy_flock_export(struct obd_export *exp)
 	}
 	EXIT;
 }
-EXPORT_SYMBOL(ldlm_destroy_flock_export);
diff --git a/lustre/ldlm/ldlm_lib.c b/lustre/ldlm/ldlm_lib.c
index 14a0ac7..e1d9132 100644
--- a/lustre/ldlm/ldlm_lib.c
+++ b/lustre/ldlm/ldlm_lib.c
@@ -752,7 +752,6 @@ void target_client_add_cb(struct obd_device *obd, __u64 transno, void *cb_data,
 	spin_unlock(&exp->exp_lock);
 	class_export_cb_put(exp);
 }
-EXPORT_SYMBOL(target_client_add_cb);
 
 static void
 check_and_start_recovery_timer(struct obd_device *obd,
@@ -1281,7 +1280,6 @@ out:
 		req->rq_status = rc;
 	RETURN(rc);
 }
-EXPORT_SYMBOL(target_handle_connect);
 
 int target_handle_disconnect(struct ptlrpc_request *req)
 {
@@ -1297,7 +1295,6 @@ int target_handle_disconnect(struct ptlrpc_request *req)
 
         RETURN(0);
 }
-EXPORT_SYMBOL(target_handle_disconnect);
 
 void target_destroy_export(struct obd_export *exp)
 {
@@ -1531,7 +1528,6 @@ 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)
 {
@@ -2357,14 +2353,12 @@ added:
 	wake_up(&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)
 {
@@ -2381,7 +2375,6 @@ void target_committed_to_req(struct ptlrpc_request *req)
         CDEBUG(D_INFO, "last_committed "LPU64", transno "LPU64", xid "LPU64"\n",
                exp->exp_last_committed, req->rq_transno, req->rq_xid);
 }
-EXPORT_SYMBOL(target_committed_to_req);
 
 #endif /* HAVE_SERVER_SUPPORT */
 
@@ -2412,7 +2405,6 @@ int target_pack_pool_reply(struct ptlrpc_request *req)
 
         RETURN(0);
 }
-EXPORT_SYMBOL(target_pack_pool_reply);
 
 static int target_send_reply_msg(struct ptlrpc_request *req,
 				 int rc, int fail_id)
@@ -2524,7 +2516,6 @@ void target_send_reply(struct ptlrpc_request *req, int rc, int fail_id)
 	spin_unlock(&svcpt->scp_rep_lock);
 	EXIT;
 }
-EXPORT_SYMBOL(target_send_reply);
 
 ldlm_mode_t lck_compat_array[] = {
 	[LCK_EX]    = LCK_COMPAT_EX,
@@ -2614,7 +2605,6 @@ ldlm_error_t ldlm_errno2error(int err_no)
         }
         return error;
 }
-EXPORT_SYMBOL(ldlm_errno2error);
 
 #if LUSTRE_TRACKS_LOCK_EXP_REFS
 void ldlm_dump_export_locks(struct obd_export *exp)
diff --git a/lustre/ldlm/ldlm_lock.c b/lustre/ldlm/ldlm_lock.c
index 05f6ff6..d41c964 100644
--- a/lustre/ldlm/ldlm_lock.c
+++ b/lustre/ldlm/ldlm_lock.c
@@ -65,7 +65,6 @@ 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,
@@ -570,7 +569,6 @@ int ldlm_lock_change_resource(struct ldlm_namespace *ns, struct ldlm_lock *lock,
 
         RETURN(0);
 }
-EXPORT_SYMBOL(ldlm_lock_change_resource);
 
 /** \defgroup ldlm_handles LDLM HANDLES
  * Ways to get hold of locks without any addresses.
@@ -654,7 +652,6 @@ void ldlm_lock2desc(struct ldlm_lock *lock, struct ldlm_lock_desc *desc)
 				    &lock->l_policy_data,
 				    &desc->l_policy_data);
 }
-EXPORT_SYMBOL(ldlm_lock2desc);
 
 /**
  * Add a lock to list of conflicting locks to send AST to.
@@ -1231,7 +1228,6 @@ void ldlm_lock_fail_match(struct ldlm_lock *lock)
         ldlm_lock_fail_match_locked(lock);
         unlock_res_and_lock(lock);
 }
-EXPORT_SYMBOL(ldlm_lock_fail_match);
 
 /**
  * Mark lock as "matchable" by OST.
@@ -2032,7 +2028,6 @@ void ldlm_reprocess_all_ns(struct ldlm_namespace *ns)
         }
         EXIT;
 }
-EXPORT_SYMBOL(ldlm_reprocess_all_ns);
 
 /**
  * Try to grant all waiting locks on a resource.
@@ -2401,7 +2396,6 @@ 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);
 
 /**
  * Print lock with lock handle \a lockh description into debug log.
diff --git a/lustre/ldlm/ldlm_lockd.c b/lustre/ldlm/ldlm_lockd.c
index 7f70349..394e11f 100644
--- a/lustre/ldlm/ldlm_lockd.c
+++ b/lustre/ldlm/ldlm_lockd.c
@@ -521,7 +521,6 @@ 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 contended lock waiting time.
@@ -897,7 +896,6 @@ int ldlm_server_blocking_ast(struct ldlm_lock *lock,
 
         RETURN(rc);
 }
-EXPORT_SYMBOL(ldlm_server_blocking_ast);
 
 /**
  * ->l_completion_ast callback for a remote lock in server namespace.
@@ -1029,7 +1027,6 @@ int ldlm_server_completion_ast(struct ldlm_lock *lock, __u64 flags, void *data)
 
 	RETURN(lvb_len < 0 ? lvb_len : rc);
 }
-EXPORT_SYMBOL(ldlm_server_completion_ast);
 
 /**
  * Server side ->l_glimpse_ast handler for client locks.
@@ -1101,7 +1098,6 @@ 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,
 		       struct list_head *gl_work_list)
@@ -1489,7 +1485,6 @@ existing_lock:
 
         return rc;
 }
-EXPORT_SYMBOL(ldlm_handle_enqueue0);
 
 /**
  * Old-style LDLM main entry point for server code enqueue.
@@ -1516,7 +1511,6 @@ int ldlm_handle_enqueue(struct ptlrpc_request *req,
         }
         return rc;
 }
-EXPORT_SYMBOL(ldlm_handle_enqueue);
 
 /**
  * Main LDLM entry point for server code to process lock conversion requests.
@@ -1570,7 +1564,6 @@ int ldlm_handle_convert0(struct ptlrpc_request *req,
 
         RETURN(0);
 }
-EXPORT_SYMBOL(ldlm_handle_convert0);
 
 /**
  * Old-style main LDLM entry point for server code to process lock conversion
@@ -1590,7 +1583,6 @@ int ldlm_handle_convert(struct ptlrpc_request *req)
         }
         return rc;
 }
-EXPORT_SYMBOL(ldlm_handle_convert);
 
 /**
  * Cancel all the locks whose handles are packed into ldlm_request
@@ -1702,7 +1694,6 @@ int ldlm_handle_cancel(struct ptlrpc_request *req)
 
         RETURN(ptlrpc_reply(req));
 }
-EXPORT_SYMBOL(ldlm_handle_cancel);
 #endif /* HAVE_SERVER_SUPPORT */
 
 /**
@@ -2698,7 +2689,6 @@ int ldlm_get_ref(void)
 
         RETURN(rc);
 }
-EXPORT_SYMBOL(ldlm_get_ref);
 
 void ldlm_put_ref(void)
 {
@@ -2717,7 +2707,6 @@ void ldlm_put_ref(void)
 
         EXIT;
 }
-EXPORT_SYMBOL(ldlm_put_ref);
 
 /*
  * Export handle<->lock hash operations.
diff --git a/lustre/ldlm/ldlm_pool.c b/lustre/ldlm/ldlm_pool.c
index 94f6d7b..274be06 100644
--- a/lustre/ldlm/ldlm_pool.c
+++ b/lustre/ldlm/ldlm_pool.c
@@ -648,7 +648,6 @@ int ldlm_pool_shrink(struct ldlm_pool *pl, int nr, gfp_t gfp_mask)
         }
         return cancel;
 }
-EXPORT_SYMBOL(ldlm_pool_shrink);
 
 /**
  * Pool setup wrapper. Will call either client or server pool recalc callback
@@ -662,7 +661,6 @@ int ldlm_pool_setup(struct ldlm_pool *pl, int limit)
                 return(pl->pl_ops->po_setup(pl, limit));
         return 0;
 }
-EXPORT_SYMBOL(ldlm_pool_setup);
 
 static int lprocfs_pool_state_seq_show(struct seq_file *m, void *unused)
 {
@@ -888,7 +886,6 @@ int ldlm_pool_init(struct ldlm_pool *pl, struct ldlm_namespace *ns,
 
         RETURN(rc);
 }
-EXPORT_SYMBOL(ldlm_pool_init);
 
 void ldlm_pool_fini(struct ldlm_pool *pl)
 {
@@ -903,7 +900,6 @@ void ldlm_pool_fini(struct ldlm_pool *pl)
         POISON(pl, 0x5a, sizeof(*pl));
         EXIT;
 }
-EXPORT_SYMBOL(ldlm_pool_fini);
 
 /**
  * Add new taken ldlm lock \a lock into pool \a pl accounting.
@@ -931,7 +927,6 @@ void ldlm_pool_add(struct ldlm_pool *pl, struct ldlm_lock *lock)
 	if (ns_is_server(ldlm_pl2ns(pl)))
 		ldlm_pool_recalc(pl);
 }
-EXPORT_SYMBOL(ldlm_pool_add);
 
 /**
  * Remove ldlm lock \a lock from pool \a pl accounting.
@@ -953,7 +948,6 @@ void ldlm_pool_del(struct ldlm_pool *pl, struct ldlm_lock *lock)
 	if (ns_is_server(ldlm_pl2ns(pl)))
 		ldlm_pool_recalc(pl);
 }
-EXPORT_SYMBOL(ldlm_pool_del);
 
 /**
  * Returns current \a pl SLV.
@@ -968,7 +962,6 @@ __u64 ldlm_pool_get_slv(struct ldlm_pool *pl)
 	spin_unlock(&pl->pl_lock);
 	return slv;
 }
-EXPORT_SYMBOL(ldlm_pool_get_slv);
 
 /**
  * Sets passed \a slv to \a pl.
@@ -981,7 +974,6 @@ void ldlm_pool_set_slv(struct ldlm_pool *pl, __u64 slv)
 	pl->pl_server_lock_volume = slv;
 	spin_unlock(&pl->pl_lock);
 }
-EXPORT_SYMBOL(ldlm_pool_set_slv);
 
 /**
  * Returns current \a pl CLV.
@@ -996,7 +988,6 @@ __u64 ldlm_pool_get_clv(struct ldlm_pool *pl)
 	spin_unlock(&pl->pl_lock);
 	return slv;
 }
-EXPORT_SYMBOL(ldlm_pool_get_clv);
 
 /**
  * Sets passed \a clv to \a pl.
@@ -1009,7 +1000,6 @@ void ldlm_pool_set_clv(struct ldlm_pool *pl, __u64 clv)
 	pl->pl_client_lock_volume = clv;
 	spin_unlock(&pl->pl_lock);
 }
-EXPORT_SYMBOL(ldlm_pool_set_clv);
 
 /**
  * Returns current \a pl limit.
@@ -1018,7 +1008,6 @@ __u32 ldlm_pool_get_limit(struct ldlm_pool *pl)
 {
 	return atomic_read(&pl->pl_limit);
 }
-EXPORT_SYMBOL(ldlm_pool_get_limit);
 
 /**
  * Sets passed \a limit to \a pl.
@@ -1027,7 +1016,6 @@ void ldlm_pool_set_limit(struct ldlm_pool *pl, __u32 limit)
 {
 	atomic_set(&pl->pl_limit, limit);
 }
-EXPORT_SYMBOL(ldlm_pool_set_limit);
 
 /**
  * Returns current LVF from \a pl.
@@ -1036,7 +1024,6 @@ __u32 ldlm_pool_get_lvf(struct ldlm_pool *pl)
 {
 	return atomic_read(&pl->pl_lock_volume_factor);
 }
-EXPORT_SYMBOL(ldlm_pool_get_lvf);
 
 static struct ptlrpc_thread *ldlm_pools_thread;
 static struct shrinker *ldlm_pools_srv_shrinker;
@@ -1371,7 +1358,6 @@ int ldlm_pools_recalc(ldlm_side_t client)
         }
 	return time;
 }
-EXPORT_SYMBOL(ldlm_pools_recalc);
 
 static int ldlm_pools_thread_main(void *arg)
 {
@@ -1490,7 +1476,6 @@ int ldlm_pools_init(void)
 	}
 	RETURN(rc);
 }
-EXPORT_SYMBOL(ldlm_pools_init);
 
 void ldlm_pools_fini(void)
 {
@@ -1504,110 +1489,92 @@ void ldlm_pools_fini(void)
 	}
 	ldlm_pools_thread_stop();
 }
-EXPORT_SYMBOL(ldlm_pools_fini);
 
 #else /* !HAVE_LRU_RESIZE_SUPPORT */
 int ldlm_pool_setup(struct ldlm_pool *pl, int limit)
 {
         return 0;
 }
-EXPORT_SYMBOL(ldlm_pool_setup);
 
 int ldlm_pool_recalc(struct ldlm_pool *pl)
 {
         return 0;
 }
-EXPORT_SYMBOL(ldlm_pool_recalc);
 
 int ldlm_pool_shrink(struct ldlm_pool *pl,
 		     int nr, gfp_t gfp_mask)
 {
         return 0;
 }
-EXPORT_SYMBOL(ldlm_pool_shrink);
 
 int ldlm_pool_init(struct ldlm_pool *pl, struct ldlm_namespace *ns,
                    int idx, ldlm_side_t client)
 {
         return 0;
 }
-EXPORT_SYMBOL(ldlm_pool_init);
 
 void ldlm_pool_fini(struct ldlm_pool *pl)
 {
         return;
 }
-EXPORT_SYMBOL(ldlm_pool_fini);
 
 void ldlm_pool_add(struct ldlm_pool *pl, struct ldlm_lock *lock)
 {
         return;
 }
-EXPORT_SYMBOL(ldlm_pool_add);
 
 void ldlm_pool_del(struct ldlm_pool *pl, struct ldlm_lock *lock)
 {
         return;
 }
-EXPORT_SYMBOL(ldlm_pool_del);
 
 __u64 ldlm_pool_get_slv(struct ldlm_pool *pl)
 {
         return 1;
 }
-EXPORT_SYMBOL(ldlm_pool_get_slv);
 
 void ldlm_pool_set_slv(struct ldlm_pool *pl, __u64 slv)
 {
         return;
 }
-EXPORT_SYMBOL(ldlm_pool_set_slv);
 
 __u64 ldlm_pool_get_clv(struct ldlm_pool *pl)
 {
         return 1;
 }
-EXPORT_SYMBOL(ldlm_pool_get_clv);
 
 void ldlm_pool_set_clv(struct ldlm_pool *pl, __u64 clv)
 {
         return;
 }
-EXPORT_SYMBOL(ldlm_pool_set_clv);
 
 __u32 ldlm_pool_get_limit(struct ldlm_pool *pl)
 {
         return 0;
 }
-EXPORT_SYMBOL(ldlm_pool_get_limit);
 
 void ldlm_pool_set_limit(struct ldlm_pool *pl, __u32 limit)
 {
         return;
 }
-EXPORT_SYMBOL(ldlm_pool_set_limit);
 
 __u32 ldlm_pool_get_lvf(struct ldlm_pool *pl)
 {
         return 0;
 }
-EXPORT_SYMBOL(ldlm_pool_get_lvf);
 
 int ldlm_pools_init(void)
 {
         return 0;
 }
-EXPORT_SYMBOL(ldlm_pools_init);
 
 void ldlm_pools_fini(void)
 {
         return;
 }
-EXPORT_SYMBOL(ldlm_pools_fini);
 
 int ldlm_pools_recalc(ldlm_side_t client)
 {
         return 0;
 }
-EXPORT_SYMBOL(ldlm_pools_recalc);
 #endif /* HAVE_LRU_RESIZE_SUPPORT */
diff --git a/lustre/ldlm/ldlm_request.c b/lustre/ldlm/ldlm_request.c
index d8e77b4..c278b3a 100644
--- a/lustre/ldlm/ldlm_request.c
+++ b/lustre/ldlm/ldlm_request.c
@@ -131,7 +131,6 @@ int ldlm_expired_completion_wait(void *data)
 
         RETURN(0);
 }
-EXPORT_SYMBOL(ldlm_expired_completion_wait);
 
 /**
  * Calculate the Completion timeout (covering enqueue, BL AST, data flush,
@@ -414,7 +413,6 @@ int ldlm_glimpse_ast(struct ldlm_lock *lock, void *reqp)
 {
         return -ELDLM_NO_LOCK_DATA;
 }
-EXPORT_SYMBOL(ldlm_glimpse_ast);
 
 /**
  * Enqueue a local lock (typically on a server).
@@ -1099,7 +1097,6 @@ 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.
@@ -1270,7 +1267,6 @@ int ldlm_cli_cancel_req(struct obd_export *exp, struct list_head *cancels,
 out:
         return sent ? sent : rc;
 }
-EXPORT_SYMBOL(ldlm_cli_cancel_req);
 
 static inline struct ldlm_pool *ldlm_imp2pl(struct obd_import *imp)
 {
@@ -1326,7 +1322,6 @@ int ldlm_cli_update_pool(struct ptlrpc_request *req)
 
         RETURN(0);
 }
-EXPORT_SYMBOL(ldlm_cli_update_pool);
 
 /**
  * Client side lock cancel.
@@ -1428,7 +1423,6 @@ int ldlm_cli_cancel_list_local(struct list_head *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
@@ -1995,7 +1989,6 @@ int ldlm_cli_cancel_unused(struct ldlm_namespace *ns,
                 RETURN(ELDLM_OK);
         }
 }
-EXPORT_SYMBOL(ldlm_cli_cancel_unused);
 
 /* Lock iterators. */
 
@@ -2036,7 +2029,6 @@ 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;
@@ -2069,7 +2061,6 @@ 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
@@ -2320,4 +2311,3 @@ 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 e4cdfef..44023bd 100644
--- a/lustre/ldlm/ldlm_resource.c
+++ b/lustre/ldlm/ldlm_resource.c
@@ -957,7 +957,6 @@ void ldlm_namespace_get(struct ldlm_namespace *ns)
 {
 	atomic_inc(&ns->ns_bref);
 }
-EXPORT_SYMBOL(ldlm_namespace_get);
 
 /* This is only for callers that care about refcount */
 static int ldlm_namespace_get_return(struct ldlm_namespace *ns)
@@ -972,7 +971,6 @@ void ldlm_namespace_put(struct ldlm_namespace *ns)
 		spin_unlock(&ns->ns_lock);
 	}
 }
-EXPORT_SYMBOL(ldlm_namespace_put);
 
 /** Register \a ns in the list of namespaces */
 void ldlm_namespace_register(struct ldlm_namespace *ns, ldlm_side_t client)
@@ -1317,7 +1315,6 @@ void ldlm_dump_all_namespaces(ldlm_side_t client, int level)
 
 	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,
 			      struct hlist_node *hnode, void *arg)
@@ -1355,7 +1352,6 @@ void ldlm_namespace_dump(int level, struct ldlm_namespace *ns)
 	ns->ns_next_dump = cfs_time_shift(10);
 	spin_unlock(&ns->ns_lock);
 }
-EXPORT_SYMBOL(ldlm_namespace_dump);
 
 /**
  * Print information about all locks in this resource to debug log.