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>
{
return extent_equal(&n1->in_extent, &n2->in_extent);
}
{
return extent_equal(&n1->in_extent, &n2->in_extent);
}
-EXPORT_SYMBOL(node_equal);
static inline __u64 max_u64(__u64 x, __u64 y)
{
static inline __u64 max_u64(__u64 x, __u64 y)
{
ext->end = interval_expand_high(root, ext->end);
LASSERT(interval_is_overlapped(root, ext) == 0);
}
ext->end = interval_expand_high(root, ext->end);
LASSERT(interval_is_overlapped(root, ext) == 0);
}
-EXPORT_SYMBOL(interval_expand);
-EXPORT_SYMBOL(ldlm_init_flock_export);
void ldlm_destroy_flock_export(struct obd_export *exp)
{
void ldlm_destroy_flock_export(struct obd_export *exp)
{
-EXPORT_SYMBOL(ldlm_destroy_flock_export);
spin_unlock(&exp->exp_lock);
class_export_cb_put(exp);
}
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,
static void
check_and_start_recovery_timer(struct obd_device *obd,
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)
{
-EXPORT_SYMBOL(target_handle_disconnect);
void target_destroy_export(struct obd_export *exp)
{
void target_destroy_export(struct obd_export *exp)
{
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)
{
wake_up(&obd->obd_next_transno_waitq);
RETURN(0);
}
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);
}
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)
{
CDEBUG(D_INFO, "last_committed "LPU64", transno "LPU64", xid "LPU64"\n",
exp->exp_last_committed, req->rq_transno, req->rq_xid);
}
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 */
#endif /* HAVE_SERVER_SUPPORT */
-EXPORT_SYMBOL(target_pack_pool_reply);
static int target_send_reply_msg(struct ptlrpc_request *req,
int rc, int fail_id)
static int target_send_reply_msg(struct ptlrpc_request *req,
int rc, int fail_id)
spin_unlock(&svcpt->scp_rep_lock);
EXIT;
}
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,
-EXPORT_SYMBOL(ldlm_errno2error);
#if LUSTRE_TRACKS_LOCK_EXP_REFS
void ldlm_dump_export_locks(struct obd_export *exp)
#if LUSTRE_TRACKS_LOCK_EXP_REFS
void ldlm_dump_export_locks(struct obd_export *exp)
[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,
-EXPORT_SYMBOL(ldlm_lock_change_resource);
/** \defgroup ldlm_handles LDLM HANDLES
* Ways to get hold of locks without any addresses.
/** \defgroup ldlm_handles LDLM HANDLES
* Ways to get hold of locks without any addresses.
&lock->l_policy_data,
&desc->l_policy_data);
}
&lock->l_policy_data,
&desc->l_policy_data);
}
-EXPORT_SYMBOL(ldlm_lock2desc);
/**
* Add a lock to list of conflicting locks to send AST to.
/**
* Add a lock to list of conflicting locks to send AST to.
ldlm_lock_fail_match_locked(lock);
unlock_res_and_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.
/**
* Mark lock as "matchable" by OST.
-EXPORT_SYMBOL(ldlm_reprocess_all_ns);
/**
* Try to grant all waiting locks on a resource.
/**
* Try to grant all waiting locks on a resource.
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);
/**
* Print lock with lock handle \a lockh description into debug log.
/**
* Print lock with lock handle \a lockh description into debug log.
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 contended lock waiting time.
/**
* Prolong the contended lock waiting time.
-EXPORT_SYMBOL(ldlm_server_blocking_ast);
/**
* ->l_completion_ast callback for a remote lock in server namespace.
/**
* ->l_completion_ast callback for a remote lock in server namespace.
RETURN(lvb_len < 0 ? lvb_len : rc);
}
RETURN(lvb_len < 0 ? lvb_len : rc);
}
-EXPORT_SYMBOL(ldlm_server_completion_ast);
/**
* Server side ->l_glimpse_ast handler for client locks.
/**
* Server side ->l_glimpse_ast handler for client locks.
-EXPORT_SYMBOL(ldlm_server_glimpse_ast);
int ldlm_glimpse_locks(struct ldlm_resource *res,
struct list_head *gl_work_list)
int ldlm_glimpse_locks(struct ldlm_resource *res,
struct list_head *gl_work_list)
-EXPORT_SYMBOL(ldlm_handle_enqueue0);
/**
* Old-style LDLM main entry point for server code enqueue.
/**
* Old-style LDLM main entry point for server code enqueue.
-EXPORT_SYMBOL(ldlm_handle_enqueue);
/**
* Main LDLM entry point for server code to process lock conversion requests.
/**
* Main LDLM entry point for server code to process lock conversion requests.
-EXPORT_SYMBOL(ldlm_handle_convert0);
/**
* Old-style main LDLM entry point for server code to process lock conversion
/**
* Old-style main LDLM entry point for server code to process lock conversion
-EXPORT_SYMBOL(ldlm_handle_convert);
/**
* Cancel all the locks whose handles are packed into ldlm_request
/**
* Cancel all the locks whose handles are packed into ldlm_request
RETURN(ptlrpc_reply(req));
}
RETURN(ptlrpc_reply(req));
}
-EXPORT_SYMBOL(ldlm_handle_cancel);
#endif /* HAVE_SERVER_SUPPORT */
/**
#endif /* HAVE_SERVER_SUPPORT */
/**
-EXPORT_SYMBOL(ldlm_get_ref);
void ldlm_put_ref(void)
{
void ldlm_put_ref(void)
{
-EXPORT_SYMBOL(ldlm_put_ref);
/*
* Export handle<->lock hash operations.
/*
* Export handle<->lock hash operations.
-EXPORT_SYMBOL(ldlm_pool_shrink);
/**
* Pool setup wrapper. Will call either client or server pool recalc callback
/**
* Pool setup wrapper. Will call either client or server pool recalc callback
return(pl->pl_ops->po_setup(pl, limit));
return 0;
}
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)
{
static int lprocfs_pool_state_seq_show(struct seq_file *m, void *unused)
{
-EXPORT_SYMBOL(ldlm_pool_init);
void ldlm_pool_fini(struct ldlm_pool *pl)
{
void ldlm_pool_fini(struct ldlm_pool *pl)
{
POISON(pl, 0x5a, sizeof(*pl));
EXIT;
}
POISON(pl, 0x5a, sizeof(*pl));
EXIT;
}
-EXPORT_SYMBOL(ldlm_pool_fini);
/**
* Add new taken ldlm lock \a lock into pool \a pl accounting.
/**
* Add new taken ldlm lock \a lock into pool \a pl accounting.
if (ns_is_server(ldlm_pl2ns(pl)))
ldlm_pool_recalc(pl);
}
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.
/**
* Remove ldlm lock \a lock from pool \a pl accounting.
if (ns_is_server(ldlm_pl2ns(pl)))
ldlm_pool_recalc(pl);
}
if (ns_is_server(ldlm_pl2ns(pl)))
ldlm_pool_recalc(pl);
}
-EXPORT_SYMBOL(ldlm_pool_del);
/**
* Returns current \a pl SLV.
/**
* Returns current \a pl SLV.
spin_unlock(&pl->pl_lock);
return slv;
}
spin_unlock(&pl->pl_lock);
return slv;
}
-EXPORT_SYMBOL(ldlm_pool_get_slv);
/**
* Sets passed \a slv to \a pl.
/**
* Sets passed \a slv to \a pl.
pl->pl_server_lock_volume = slv;
spin_unlock(&pl->pl_lock);
}
pl->pl_server_lock_volume = slv;
spin_unlock(&pl->pl_lock);
}
-EXPORT_SYMBOL(ldlm_pool_set_slv);
/**
* Returns current \a pl CLV.
/**
* Returns current \a pl CLV.
spin_unlock(&pl->pl_lock);
return slv;
}
spin_unlock(&pl->pl_lock);
return slv;
}
-EXPORT_SYMBOL(ldlm_pool_get_clv);
/**
* Sets passed \a clv to \a pl.
/**
* Sets passed \a clv to \a pl.
pl->pl_client_lock_volume = clv;
spin_unlock(&pl->pl_lock);
}
pl->pl_client_lock_volume = clv;
spin_unlock(&pl->pl_lock);
}
-EXPORT_SYMBOL(ldlm_pool_set_clv);
/**
* Returns current \a pl limit.
/**
* Returns current \a pl limit.
{
return atomic_read(&pl->pl_limit);
}
{
return atomic_read(&pl->pl_limit);
}
-EXPORT_SYMBOL(ldlm_pool_get_limit);
/**
* Sets passed \a limit to \a pl.
/**
* Sets passed \a limit to \a pl.
{
atomic_set(&pl->pl_limit, limit);
}
{
atomic_set(&pl->pl_limit, limit);
}
-EXPORT_SYMBOL(ldlm_pool_set_limit);
/**
* Returns current LVF from \a pl.
/**
* Returns current LVF from \a pl.
{
return atomic_read(&pl->pl_lock_volume_factor);
}
{
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;
static struct ptlrpc_thread *ldlm_pools_thread;
static struct shrinker *ldlm_pools_srv_shrinker;
-EXPORT_SYMBOL(ldlm_pools_recalc);
static int ldlm_pools_thread_main(void *arg)
{
static int ldlm_pools_thread_main(void *arg)
{
-EXPORT_SYMBOL(ldlm_pools_init);
void ldlm_pools_fini(void)
{
void ldlm_pools_fini(void)
{
}
ldlm_pools_thread_stop();
}
}
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;
}
#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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
__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;
}
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;
}
__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;
}
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;
}
__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;
}
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;
}
__u32 ldlm_pool_get_lvf(struct ldlm_pool *pl)
{
return 0;
}
-EXPORT_SYMBOL(ldlm_pool_get_lvf);
int ldlm_pools_init(void)
{
return 0;
}
int ldlm_pools_init(void)
{
return 0;
}
-EXPORT_SYMBOL(ldlm_pools_init);
void ldlm_pools_fini(void)
{
return;
}
void ldlm_pools_fini(void)
{
return;
}
-EXPORT_SYMBOL(ldlm_pools_fini);
int ldlm_pools_recalc(ldlm_side_t client)
{
return 0;
}
int ldlm_pools_recalc(ldlm_side_t client)
{
return 0;
}
-EXPORT_SYMBOL(ldlm_pools_recalc);
#endif /* HAVE_LRU_RESIZE_SUPPORT */
#endif /* HAVE_LRU_RESIZE_SUPPORT */
-EXPORT_SYMBOL(ldlm_expired_completion_wait);
/**
* Calculate the Completion timeout (covering enqueue, BL AST, data flush,
/**
* Calculate the Completion timeout (covering enqueue, BL AST, data flush,
{
return -ELDLM_NO_LOCK_DATA;
}
{
return -ELDLM_NO_LOCK_DATA;
}
-EXPORT_SYMBOL(ldlm_glimpse_ast);
/**
* Enqueue a local lock (typically on a server).
/**
* Enqueue a local lock (typically on a server).
ptlrpc_req_finished(req);
return rc;
}
ptlrpc_req_finished(req);
return rc;
}
-EXPORT_SYMBOL(ldlm_cli_convert);
/**
* Cancel locks locally.
/**
* Cancel locks locally.
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)
{
-EXPORT_SYMBOL(ldlm_cli_update_pool);
/**
* Client side lock cancel.
/**
* Client side lock cancel.
-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
-EXPORT_SYMBOL(ldlm_cli_cancel_unused);
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;
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
-EXPORT_SYMBOL(ldlm_replay_locks);
{
atomic_inc(&ns->ns_bref);
}
{
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)
/* This is only for callers that care about refcount */
static int ldlm_namespace_get_return(struct ldlm_namespace *ns)
spin_unlock(&ns->ns_lock);
}
}
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)
/** Register \a ns in the list of namespaces */
void ldlm_namespace_register(struct ldlm_namespace *ns, ldlm_side_t client)
mutex_unlock(ldlm_namespace_lock(client));
}
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)
static int ldlm_res_hash_dump(cfs_hash_t *hs, cfs_hash_bd_t *bd,
struct hlist_node *hnode, void *arg)
ns->ns_next_dump = cfs_time_shift(10);
spin_unlock(&ns->ns_lock);
}
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.
/**
* Print information about all locks in this resource to debug log.
git://git.whamcloud.com / fs / lustre-release.git / commitdiff