Commit 58c6d133 authored by Oleg Drokin's avatar Oleg Drokin Committed by Greg Kroah-Hartman
Browse files

staging/lustre/ldlm: Remove unused exported symbols. 



This rather large patch prunes all unused EXPORT_SYMBOLS and
marks functions only used locally as static lustre ldlm module.

The only two remaining nonstatic functions that should be static
now are:
ldlm_cancel_lru_local
ldlm_resource_putref_locked

But some bigger code shuffling around is needed to achieve that, so
it's left for a future patch.

Signed-off-by: default avatarOleg Drokin <green@linuxhacker.ru>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 00f9d12b

drivers/staging/lustre/lustre/include/lustre_dlm.h

+0 −26
Original line number Diff line number Diff line
@@ -60,9 +60,6 @@ 
struct obd_ops;

struct obd_device;



extern struct kset *ldlm_ns_kset;

extern struct kset *ldlm_svc_kset;



#define OBD_LDLM_DEVICENAME  "ldlm"



#define LDLM_DEFAULT_LRU_SIZE (100 * num_online_cpus())
@@ -561,9 +558,6 @@ typedef union { 
	struct ldlm_inodebits l_inodebits;

} ldlm_policy_data_t;



void ldlm_convert_policy_to_wire(ldlm_type_t type,

				 const ldlm_policy_data_t *lpolicy,

				 ldlm_wire_policy_data_t *wpolicy);

void ldlm_convert_policy_to_local(struct obd_export *exp, ldlm_type_t type,

				  const ldlm_wire_policy_data_t *wpolicy,

				  ldlm_policy_data_t *lpolicy);
@@ -980,7 +974,6 @@ struct ldlm_enqueue_info { 
extern struct obd_ops ldlm_obd_ops;



extern char *ldlm_lockname[];

extern char *ldlm_typename[];

char *ldlm_it2str(int it);



/**
@@ -1051,10 +1044,6 @@ typedef int (*ldlm_res_iterator_t)(struct ldlm_resource *, void *); 
 * LDLM provides for a way to iterate through every lock on a resource or

 * namespace or every resource in a namespace.

 * @{ */

int ldlm_resource_foreach(struct ldlm_resource *res, ldlm_iterator_t iter,

			  void *closure);

void ldlm_namespace_foreach(struct ldlm_namespace *ns, ldlm_iterator_t iter,

			    void *closure);

int ldlm_resource_iterate(struct ldlm_namespace *, const struct ldlm_res_id *,

			  ldlm_iterator_t iter, void *data);

/** @} ldlm_iterator */
@@ -1172,7 +1161,6 @@ do { \ 


struct ldlm_lock *ldlm_lock_get(struct ldlm_lock *lock);

void ldlm_lock_put(struct ldlm_lock *lock);

void ldlm_lock_destroy(struct ldlm_lock *lock);

void ldlm_lock2desc(struct ldlm_lock *lock, struct ldlm_lock_desc *desc);

void ldlm_lock_addref(struct lustre_handle *lockh, __u32 mode);

int  ldlm_lock_addref_try(struct lustre_handle *lockh, __u32 mode);
@@ -1197,8 +1185,6 @@ ldlm_namespace_new(struct obd_device *obd, char *name, 
		   ldlm_side_t client, ldlm_appetite_t apt,

		   ldlm_ns_type_t ns_type);

int ldlm_namespace_cleanup(struct ldlm_namespace *ns, __u64 flags);

void ldlm_namespace_register(struct ldlm_namespace *ns, ldlm_side_t client);

void ldlm_namespace_unregister(struct ldlm_namespace *ns, ldlm_side_t client);

void ldlm_namespace_get(struct ldlm_namespace *ns);

void ldlm_namespace_put(struct ldlm_namespace *ns);

int ldlm_debugfs_setup(void);
@@ -1209,7 +1195,6 @@ struct ldlm_resource *ldlm_resource_get(struct ldlm_namespace *ns, 
					struct ldlm_resource *parent,

					const struct ldlm_res_id *,

					ldlm_type_t type, int create);

struct ldlm_resource *ldlm_resource_getref(struct ldlm_resource *res);

int ldlm_resource_putref(struct ldlm_resource *res);

void ldlm_resource_add_lock(struct ldlm_resource *res,

			    struct list_head *head,
@@ -1231,7 +1216,6 @@ int ldlm_lock_change_resource(struct ldlm_namespace *, struct ldlm_lock *, 
} while (0)



/* ldlm_request.c */

int ldlm_expired_completion_wait(void *data);

/** \defgroup ldlm_local_ast Default AST handlers for local locks

 * These AST handlers are typically used for server-side local locks and are

 * also used by client-side lock handlers to perform minimum level base
@@ -1275,8 +1259,6 @@ int ldlm_cli_cancel_unused_resource(struct ldlm_namespace *ns, 
				    ldlm_mode_t mode,

				    ldlm_cancel_flags_t flags,

				    void *opaque);

int ldlm_cli_cancel_req(struct obd_export *exp, struct list_head *head,

			int count, ldlm_cancel_flags_t flags);

int ldlm_cancel_resource_local(struct ldlm_resource *res,

			       struct list_head *cancels,

			       ldlm_policy_data_t *policy,
@@ -1351,15 +1333,7 @@ void ldlm_pools_fini(void); 


int ldlm_pool_init(struct ldlm_pool *pl, struct ldlm_namespace *ns,

		   int idx, ldlm_side_t client);

int ldlm_pool_shrink(struct ldlm_pool *pl, int nr,

		     gfp_t gfp_mask);

void ldlm_pool_fini(struct ldlm_pool *pl);

int ldlm_pool_recalc(struct ldlm_pool *pl);

__u32 ldlm_pool_get_lvf(struct ldlm_pool *pl);

__u64 ldlm_pool_get_slv(struct ldlm_pool *pl);

__u32 ldlm_pool_get_limit(struct ldlm_pool *pl);

void ldlm_pool_set_clv(struct ldlm_pool *pl, __u64 clv);

void ldlm_pool_set_limit(struct ldlm_pool *pl, __u32 limit);

void ldlm_pool_add(struct ldlm_pool *pl, struct ldlm_lock *lock);

void ldlm_pool_del(struct ldlm_pool *pl, struct ldlm_lock *lock);

/** @} */

drivers/staging/lustre/lustre/ldlm/ldlm_extent.c

+11 −11
Original line number Diff line number Diff line
@@ -97,6 +97,17 @@ __u64 ldlm_extent_shift_kms(struct ldlm_lock *lock, __u64 old_kms) 
EXPORT_SYMBOL(ldlm_extent_shift_kms);



struct kmem_cache *ldlm_interval_slab;



/* interval tree, for LDLM_EXTENT. */

static void ldlm_interval_attach(struct ldlm_interval *n, struct ldlm_lock *l)

{

	LASSERT(!l->l_tree_node);

	LASSERT(l->l_resource->lr_type == LDLM_EXTENT);



	list_add_tail(&l->l_sl_policy, &n->li_group);

	l->l_tree_node = n;

}



struct ldlm_interval *ldlm_interval_alloc(struct ldlm_lock *lock)

{

	struct ldlm_interval *node;
@@ -120,17 +131,6 @@ void ldlm_interval_free(struct ldlm_interval *node) 
	}

}



/* interval tree, for LDLM_EXTENT. */

void ldlm_interval_attach(struct ldlm_interval *n,

			  struct ldlm_lock *l)

{

	LASSERT(l->l_tree_node == NULL);

	LASSERT(l->l_resource->lr_type == LDLM_EXTENT);



	list_add_tail(&l->l_sl_policy, &n->li_group);

	l->l_tree_node = n;

}



struct ldlm_interval *ldlm_interval_detach(struct ldlm_lock *l)

{

	struct ldlm_interval *n = l->l_tree_node;

drivers/staging/lustre/lustre/ldlm/ldlm_flock.c

+3 −3
Original line number Diff line number Diff line
@@ -239,9 +239,9 @@ static void ldlm_flock_cancel_on_deadlock(struct ldlm_lock *lock, 
 *   - blocking ASTs have not been sent yet, so list of conflicting locks

 *     would be collected and ASTs sent.

 */

int

ldlm_process_flock_lock(struct ldlm_lock *req, __u64 *flags, int first_enq,

			ldlm_error_t *err, struct list_head *work_list)

static int ldlm_process_flock_lock(struct ldlm_lock *req, __u64 *flags,

				   int first_enq, ldlm_error_t *err,

				   struct list_head *work_list)

{

	struct ldlm_resource *res = req->l_resource;

	struct ldlm_namespace *ns = ldlm_res_to_ns(res);

drivers/staging/lustre/lustre/ldlm/ldlm_internal.h

+8 −13
Original line number Diff line number Diff line
@@ -112,7 +112,6 @@ int ldlm_cancel_lru_local(struct ldlm_namespace *ns, 
			 struct list_head *cancels, int count, int max,

			 ldlm_cancel_flags_t cancel_flags, int flags);

extern int ldlm_enqueue_min;

int ldlm_get_enq_timeout(struct ldlm_lock *lock);



/* ldlm_resource.c */

int ldlm_resource_putref_locked(struct ldlm_resource *res);
@@ -154,12 +153,8 @@ void ldlm_add_ast_work_item(struct ldlm_lock *lock, struct ldlm_lock *new, 
			    struct list_head *work_list);

int ldlm_run_ast_work(struct ldlm_namespace *ns, struct list_head *rpc_list,

		      enum ldlm_desc_ast_t ast_type);

int ldlm_work_gl_ast_lock(struct ptlrpc_request_set *rqset, void *opaq);

int ldlm_lock_remove_from_lru(struct ldlm_lock *lock);

int ldlm_lock_remove_from_lru_nolock(struct ldlm_lock *lock);

void ldlm_lock_add_to_lru_nolock(struct ldlm_lock *lock);

void ldlm_lock_add_to_lru(struct ldlm_lock *lock);

void ldlm_lock_touch_in_lru(struct ldlm_lock *lock);

void ldlm_lock_destroy_nolock(struct ldlm_lock *lock);



/* ldlm_lockd.c */
@@ -174,6 +169,7 @@ void ldlm_handle_bl_callback(struct ldlm_namespace *ns, 
			     struct ldlm_lock_desc *ld, struct ldlm_lock *lock);



extern struct kmem_cache *ldlm_resource_slab;

extern struct kset *ldlm_ns_kset;



/* ldlm_lockd.c & ldlm_lock.c */

extern struct kmem_cache *ldlm_lock_slab;
@@ -182,11 +178,6 @@ extern struct kmem_cache *ldlm_lock_slab; 
void ldlm_extent_add_lock(struct ldlm_resource *res, struct ldlm_lock *lock);

void ldlm_extent_unlink_lock(struct ldlm_lock *lock);



/* ldlm_flock.c */

int ldlm_process_flock_lock(struct ldlm_lock *req, __u64 *flags,

			    int first_enq, ldlm_error_t *err,

			    struct list_head *work_list);



/* l_lock.c */

void l_check_ns_lock(struct ldlm_namespace *ns);

void l_check_no_ns_lock(struct ldlm_namespace *ns);
@@ -201,9 +192,13 @@ struct ldlm_state { 
	struct ldlm_bl_pool *ldlm_bl_pool;

};



/* ldlm_pool.c */

__u64 ldlm_pool_get_slv(struct ldlm_pool *pl);

void ldlm_pool_set_clv(struct ldlm_pool *pl, __u64 clv);

__u32 ldlm_pool_get_lvf(struct ldlm_pool *pl);



/* interval tree, for LDLM_EXTENT. */

extern struct kmem_cache *ldlm_interval_slab; /* slab cache for ldlm_interval */

void ldlm_interval_attach(struct ldlm_interval *n, struct ldlm_lock *l);

struct ldlm_interval *ldlm_interval_detach(struct ldlm_lock *l);

struct ldlm_interval *ldlm_interval_alloc(struct ldlm_lock *lock);

void ldlm_interval_free(struct ldlm_interval *node);

drivers/staging/lustre/lustre/ldlm/ldlm_lock.c

+15 −15
Original line number Diff line number Diff line
@@ -60,13 +60,12 @@ char *ldlm_lockname[] = { 
};

EXPORT_SYMBOL(ldlm_lockname);



char *ldlm_typename[] = {

static char *ldlm_typename[] = {

	[LDLM_PLAIN]	= "PLN",

	[LDLM_EXTENT]	= "EXT",

	[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,
@@ -92,7 +91,7 @@ static ldlm_policy_local_to_wire_t ldlm_policy_local_to_wire[] = { 
/**

 * Converts lock policy from local format to on the wire lock_desc format

 */

void ldlm_convert_policy_to_wire(ldlm_type_t type,

static void ldlm_convert_policy_to_wire(ldlm_type_t type,

					const ldlm_policy_data_t *lpolicy,

					ldlm_wire_policy_data_t *wpolicy)

{
@@ -246,7 +245,7 @@ int ldlm_lock_remove_from_lru(struct ldlm_lock *lock) 
/**

 * Adds LDLM lock \a lock to namespace LRU. Assumes LRU is already locked.

 */

void ldlm_lock_add_to_lru_nolock(struct ldlm_lock *lock)

static void ldlm_lock_add_to_lru_nolock(struct ldlm_lock *lock)

{

	struct ldlm_namespace *ns = ldlm_lock_to_ns(lock);
@@ -264,7 +263,7 @@ void ldlm_lock_add_to_lru_nolock(struct ldlm_lock *lock) 
 * Adds LDLM lock \a lock to namespace LRU. Obtains necessary LRU locks

 * first.

 */

void ldlm_lock_add_to_lru(struct ldlm_lock *lock)

static void ldlm_lock_add_to_lru(struct ldlm_lock *lock)

{

	struct ldlm_namespace *ns = ldlm_lock_to_ns(lock);
@@ -277,7 +276,7 @@ void ldlm_lock_add_to_lru(struct ldlm_lock *lock) 
 * Moves LDLM lock \a lock that is already in namespace LRU to the tail of

 * the LRU. Performs necessary LRU locking

 */

void ldlm_lock_touch_in_lru(struct ldlm_lock *lock)

static void ldlm_lock_touch_in_lru(struct ldlm_lock *lock)

{

	struct ldlm_namespace *ns = ldlm_lock_to_ns(lock);
@@ -308,7 +307,7 @@ void ldlm_lock_touch_in_lru(struct ldlm_lock *lock) 
 * ldlm_lock_destroy, you can never drop your final references on this lock.

 * Because it's not in the hash table anymore.  -phil

 */

int ldlm_lock_destroy_internal(struct ldlm_lock *lock)

static int ldlm_lock_destroy_internal(struct ldlm_lock *lock)

{

	if (lock->l_readers || lock->l_writers) {

		LDLM_ERROR(lock, "lock still has references");
@@ -355,7 +354,7 @@ int ldlm_lock_destroy_internal(struct ldlm_lock *lock) 
/**

 * Destroys a LDLM lock \a lock. Performs necessary locking first.

 */

void ldlm_lock_destroy(struct ldlm_lock *lock)

static void ldlm_lock_destroy(struct ldlm_lock *lock)

{

	int first;
@@ -397,7 +396,7 @@ static void lock_handle_free(void *lock, int size) 
	OBD_SLAB_FREE(lock, ldlm_lock_slab, size);

}



struct portals_handle_ops lock_handle_ops = {

static struct portals_handle_ops lock_handle_ops = {

	.hop_addref = lock_handle_addref,

	.hop_free   = lock_handle_free,

};
@@ -606,7 +605,7 @@ EXPORT_SYMBOL(ldlm_lock2desc); 
 *

 * Only add if we have not sent a blocking AST to the lock yet.

 */

void ldlm_add_bl_work_item(struct ldlm_lock *lock, struct ldlm_lock *new,

static void ldlm_add_bl_work_item(struct ldlm_lock *lock, struct ldlm_lock *new,

				  struct list_head *work_list)

{

	if ((lock->l_flags & LDLM_FL_AST_SENT) == 0) {
@@ -627,7 +626,8 @@ void ldlm_add_bl_work_item(struct ldlm_lock *lock, struct ldlm_lock *new, 
/**

 * Add a lock to list of just granted locks to send completion AST to.

 */

void ldlm_add_cp_work_item(struct ldlm_lock *lock, struct list_head *work_list)

static void ldlm_add_cp_work_item(struct ldlm_lock *lock,

				  struct list_head *work_list)

{

	if ((lock->l_flags & LDLM_FL_CP_REQD) == 0) {

		lock->l_flags |= LDLM_FL_CP_REQD;
@@ -1673,7 +1673,7 @@ ldlm_work_revoke_ast_lock(struct ptlrpc_request_set *rqset, void *opaq) 
/**

 * Process a call to glimpse AST callback for a lock in ast_work list

 */

int ldlm_work_gl_ast_lock(struct ptlrpc_request_set *rqset, void *opaq)

static int ldlm_work_gl_ast_lock(struct ptlrpc_request_set *rqset, void *opaq)

{

	struct ldlm_cb_set_arg		*arg = opaq;

	struct ldlm_glimpse_work	*gl_work;