#define DEBUG_SUBSYSTEM S_LDLM
#ifdef __KERNEL__
#include <libcfs/libcfs.h>
-#else
+#else
#include <liblustre.h>
#endif
lock->l_res_locked = 1;
return lock->l_resource;
}
+EXPORT_SYMBOL(lock_res_and_lock);
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);
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)
{
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)
{
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
RETURN(rc);
}
+EXPORT_SYMBOL(client_obd_setup);
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,
return rc;
}
+EXPORT_SYMBOL(client_connect_import);
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)
RETURN(rc);
}
+EXPORT_SYMBOL(server_disconnect_export);
/* --------------------------------------------------------------------------
* from old lib/target.c
req->rq_status = rc;
RETURN(rc);
}
+EXPORT_SYMBOL(target_handle_connect);
int target_handle_disconnect(struct ptlrpc_request *req)
{
RETURN(0);
}
+EXPORT_SYMBOL(target_handle_disconnect);
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
EXIT;
}
+EXPORT_SYMBOL(target_cleanup_recovery);
/* obd_recovery_task_lock should be held */
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)
{
cfs_wait_for_completion(&trd->trd_finishing);
}
}
+EXPORT_SYMBOL(target_stop_recovery_thread);
void target_recovery_fini(struct obd_device *obd)
{
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)
{
RETURN(0);
}
+EXPORT_SYMBOL(target_pack_pool_reply);
int target_send_reply_msg(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,
[LCK_GROUP] "GROUP",
[LCK_COS] "COS"
};
+EXPORT_SYMBOL(ldlm_lockname);
char *ldlm_typename[] = {
[LDLM_PLAIN] "PLN",
[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,
return "UNKNOWN";
}
}
+EXPORT_SYMBOL(ldlm_it2str);
extern cfs_mem_cache_t *ldlm_lock_slab;
{
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
cfs_atomic_inc(&lock->l_refc);
return lock;
}
+EXPORT_SYMBOL(ldlm_lock_get);
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)
{
RETURN(0);
}
+EXPORT_SYMBOL(ldlm_lock_change_resource);
/*
* HANDLES
{
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
unlock_res_and_lock(lock);
RETURN(lock);
}
+EXPORT_SYMBOL(__ldlm_handle2lock);
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)
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)
{
}
return result;
}
+EXPORT_SYMBOL(ldlm_lock_addref_try);
/* only called for local locks */
void ldlm_lock_addref_internal(struct ldlm_lock *lock, __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. */
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;
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)
{
ldlm_lock_allow_match_locked(lock);
unlock_res_and_lock(lock);
}
+EXPORT_SYMBOL(ldlm_lock_allow_match);
/* Can be called in two ways:
*
return rc ? mode : 0;
}
+EXPORT_SYMBOL(ldlm_lock_match);
ldlm_mode_t ldlm_revalidate_lock_handle(struct lustre_handle *lockh,
__u64 *bits)
}
EXIT;
}
+EXPORT_SYMBOL(ldlm_reprocess_all_ns);
void ldlm_reprocess_all(struct ldlm_resource *res)
{
EXIT;
}
+EXPORT_SYMBOL(ldlm_lock_cancel);
int ldlm_lock_set_data(struct lustre_handle *lockh, void *data)
{
EXIT;
}
+EXPORT_SYMBOL(ldlm_lock_downgrade);
struct ldlm_resource *ldlm_lock_convert(struct ldlm_lock *lock, int new_mode,
__u32 *flags)
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)
{
LDLM_LOCK_PUT(lock);
}
+EXPORT_SYMBOL(ldlm_lock_dump_handle);
void _ldlm_lock_debug(struct ldlm_lock *lock,
struct libcfs_debug_msg_data *msgdata,
LDLM_DEBUG(lock, "%s", ret == 0 ? "wasn't waiting" : "removed");
return ret;
}
+EXPORT_SYMBOL(ldlm_del_waiting_lock);
/*
* Prolong the lock
LDLM_DEBUG(lock, "refreshed");
return 1;
}
+EXPORT_SYMBOL(ldlm_refresh_waiting_lock);
#else /* !HAVE_SERVER_SUPPORT || !__KERNEL__ */
RETURN(rc);
}
+EXPORT_SYMBOL(ldlm_server_blocking_ast);
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)
{
RETURN(rc);
}
+EXPORT_SYMBOL(ldlm_server_glimpse_ast);
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)
return rc;
}
+EXPORT_SYMBOL(ldlm_handle_enqueue0);
int ldlm_handle_enqueue(struct ptlrpc_request *req,
ldlm_completion_callback completion_callback,
}
return rc;
}
+EXPORT_SYMBOL(ldlm_handle_enqueue);
int ldlm_handle_convert0(struct ptlrpc_request *req,
const struct ldlm_request *dlm_req)
RETURN(0);
}
+EXPORT_SYMBOL(ldlm_handle_convert0);
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,
LDLM_DEBUG_NOLOCK("server-side cancel handler END");
RETURN(done);
}
+EXPORT_SYMBOL(ldlm_request_cancel);
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,
EXIT;
}
+EXPORT_SYMBOL(ldlm_revoke_export_locks);
#endif /* HAVE_SERVER_SUPPORT */
#ifdef __KERNEL__
RETURN(rc);
}
+EXPORT_SYMBOL(ldlm_get_ref);
void ldlm_put_ref(void)
{
EXIT;
}
+EXPORT_SYMBOL(ldlm_put_ref);
/*
* Export handle<->lock hash operations.
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);
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. */
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:
RETURN(ldlm_completion_tail(lock));
}
+EXPORT_SYMBOL(ldlm_completion_ast);
/**
* A helper to build a blocking ast function
}
RETURN(0);
}
+EXPORT_SYMBOL(ldlm_blocking_ast_nocheck);
/**
* Server blocking AST
}
RETURN(ldlm_blocking_ast_nocheck(lock));
}
+EXPORT_SYMBOL(ldlm_blocking_ast);
/*
* ->l_glimpse_ast() for DLM extent locks acquired on the server-side. See
*/
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,
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)
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
}
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)
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.
RETURN(rc);
}
+EXPORT_SYMBOL(ldlm_cli_enqueue);
static int ldlm_cli_convert_local(struct ldlm_lock *lock, int new_mode,
__u32 *flags)
ptlrpc_req_finished(req);
return rc;
}
+EXPORT_SYMBOL(ldlm_cli_convert);
/* Cancel locks locally.
* Returns:
out:
return sent ? sent : rc;
}
+EXPORT_SYMBOL(ldlm_cli_cancel_req);
static inline struct ldlm_pool *ldlm_imp2pl(struct obd_import *imp)
{
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 */
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
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
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,
ldlm_resource_putref(res);
RETURN(0);
}
+EXPORT_SYMBOL(ldlm_cli_cancel_unused_resource);
struct ldlm_cli_cancel_arg {
int lc_flags;
RETURN(ELDLM_OK);
}
}
+EXPORT_SYMBOL(ldlm_cli_cancel_unused);
/* Lock iterators. */
unlock_res(res);
RETURN(rc);
}
+EXPORT_SYMBOL(ldlm_resource_foreach);
struct iter_helper_data {
ldlm_iterator_t iter;
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
ldlm_resource_putref(res);
RETURN(rc);
}
+EXPORT_SYMBOL(ldlm_resource_iterate);
/* Lock replay */
RETURN(rc);
}
+EXPORT_SYMBOL(ldlm_replay_locks);
ldlm_put_ref();
RETURN(NULL);
}
+EXPORT_SYMBOL(ldlm_namespace_new);
extern struct ldlm_lock *ldlm_lock_get(struct ldlm_lock *lock);
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)
{
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)
{
return res;
}
+EXPORT_SYMBOL(ldlm_resource_get);
struct ldlm_resource *ldlm_resource_getref(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)
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)
{
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)
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)
{