A lot of symbols don't need to be exported at all because they are
only used in the module they belong to.
Change-Id: I5dad1093f136577fa268cd7ecbebd1d660cfa8ef
Signed-off-by: frank zago <fzago@cray.com>
Reviewed-on: http://review.whamcloud.com/12510
Tested-by: Jenkins
Tested-by: Maloo <hpdd-maloo@intel.com>
Reviewed-by: Dmitry Eremin <dmitry.eremin@intel.com>
Reviewed-by: John L. Hammond <john.hammond@intel.com>
Reviewed-by: James Simmons <uja.ornl@gmail.com>
Reviewed-by: Oleg Drokin <oleg.drokin@intel.com>
17 files changed:
int ptlrpc_reply(struct ptlrpc_request *req);
int ptlrpc_send_error(struct ptlrpc_request *req, int difficult);
int ptlrpc_error(struct ptlrpc_request *req);
int ptlrpc_reply(struct ptlrpc_request *req);
int ptlrpc_send_error(struct ptlrpc_request *req, int difficult);
int ptlrpc_error(struct ptlrpc_request *req);
-void ptlrpc_resend_req(struct ptlrpc_request *request);
int ptlrpc_at_get_net_latency(struct ptlrpc_request *req);
int ptl_send_rpc(struct ptlrpc_request *request, int noreply);
int ptlrpc_register_rqbd(struct ptlrpc_request_buffer_desc *rqbd);
int ptlrpc_at_get_net_latency(struct ptlrpc_request *req);
int ptl_send_rpc(struct ptlrpc_request *request, int noreply);
int ptlrpc_register_rqbd(struct ptlrpc_request_buffer_desc *rqbd);
int ptlrpc_queue_wait(struct ptlrpc_request *req);
int ptlrpc_replay_req(struct ptlrpc_request *req);
int ptlrpc_queue_wait(struct ptlrpc_request *req);
int ptlrpc_replay_req(struct ptlrpc_request *req);
-int ptlrpc_unregister_reply(struct ptlrpc_request *req, int async);
void ptlrpc_restart_req(struct ptlrpc_request *req);
void ptlrpc_abort_inflight(struct obd_import *imp);
void ptlrpc_cleanup_imp(struct obd_import *imp);
void ptlrpc_restart_req(struct ptlrpc_request *req);
void ptlrpc_abort_inflight(struct obd_import *imp);
void ptlrpc_cleanup_imp(struct obd_import *imp);
void *arg);
int ptlrpc_set_add_cb(struct ptlrpc_request_set *set,
set_interpreter_func fn, void *data);
void *arg);
int ptlrpc_set_add_cb(struct ptlrpc_request_set *set,
set_interpreter_func fn, void *data);
-int ptlrpc_set_next_timeout(struct ptlrpc_request_set *);
int ptlrpc_check_set(const struct lu_env *env, struct ptlrpc_request_set *set);
int ptlrpc_set_wait(struct ptlrpc_request_set *);
int ptlrpc_check_set(const struct lu_env *env, struct ptlrpc_request_set *set);
int ptlrpc_set_wait(struct ptlrpc_request_set *);
-int ptlrpc_expired_set(void *data);
-void ptlrpc_interrupted_set(void *data);
void ptlrpc_mark_interrupted(struct ptlrpc_request *req);
void ptlrpc_set_destroy(struct ptlrpc_request_set *);
void ptlrpc_set_add_req(struct ptlrpc_request_set *, struct ptlrpc_request *);
void ptlrpc_mark_interrupted(struct ptlrpc_request *req);
void ptlrpc_set_destroy(struct ptlrpc_request_set *);
void ptlrpc_set_add_req(struct ptlrpc_request_set *, struct ptlrpc_request *);
-void ptlrpc_set_add_new_req(struct ptlrpcd_ctl *pc,
- struct ptlrpc_request *req);
void ptlrpc_free_rq_pool(struct ptlrpc_request_pool *pool);
void ptlrpc_add_rqs_to_pool(struct ptlrpc_request_pool *pool, int num_rq);
void ptlrpc_free_rq_pool(struct ptlrpc_request_pool *pool);
void ptlrpc_add_rqs_to_pool(struct ptlrpc_request_pool *pool, int num_rq);
static int ptlrpc_send_new_req(struct ptlrpc_request *req);
static int ptlrpcd_check_work(struct ptlrpc_request *req);
static int ptlrpc_send_new_req(struct ptlrpc_request *req);
static int ptlrpcd_check_work(struct ptlrpc_request *req);
+static int ptlrpc_unregister_reply(struct ptlrpc_request *request, int async);
/**
* Initialize passed in client structure \a cl.
/**
* Initialize passed in client structure \a cl.
-EXPORT_SYMBOL(ptlrpc_uuid_to_connection);
/**
* Allocate and initialize new bulk descriptor on the sender.
/**
* Allocate and initialize new bulk descriptor on the sender.
-EXPORT_SYMBOL(ptlrpc_prep_req_pool);
/**
* Same as ptlrpc_prep_req_pool, but without pool
/**
* Same as ptlrpc_prep_req_pool, but without pool
return ptlrpc_prep_req_pool(imp, version, opcode, count, lengths, bufs,
NULL);
}
return ptlrpc_prep_req_pool(imp, version, opcode, count, lengths, bufs,
NULL);
}
-EXPORT_SYMBOL(ptlrpc_prep_req);
/**
* Allocate and initialize new request set structure.
/**
* Allocate and initialize new request set structure.
-EXPORT_SYMBOL(ptlrpc_prep_fcset);
/**
* Wind down and free request set structure previously allocated with
/**
* Wind down and free request set structure previously allocated with
-EXPORT_SYMBOL(ptlrpc_set_add_cb);
/**
* Add a new request to the general purpose request set.
/**
* Add a new request to the general purpose request set.
wake_up(&pc->pc_partners[i]->pc_set->set_waitq);
}
}
wake_up(&pc->pc_partners[i]->pc_set->set_waitq);
}
}
-EXPORT_SYMBOL(ptlrpc_set_add_new_req);
/**
* Based on the current state of the import, determine if the request
/**
* Based on the current state of the import, determine if the request
-EXPORT_SYMBOL(ptlrpc_expired_set);
/**
* Sets rq_intr flag in \a req under spinlock.
/**
* Sets rq_intr flag in \a req under spinlock.
* Interrupts (sets interrupted flag) all uncompleted requests in
* a set \a data. Callback for l_wait_event for interruptible waits.
*/
* Interrupts (sets interrupted flag) all uncompleted requests in
* a set \a data. Callback for l_wait_event for interruptible waits.
*/
-void ptlrpc_interrupted_set(void *data)
+static void ptlrpc_interrupted_set(void *data)
{
struct ptlrpc_request_set *set = data;
struct list_head *tmp;
{
struct ptlrpc_request_set *set = data;
struct list_head *tmp;
ptlrpc_mark_interrupted(req);
}
}
ptlrpc_mark_interrupted(req);
}
}
-EXPORT_SYMBOL(ptlrpc_interrupted_set);
/**
* Get the smallest timeout in the set; this does NOT set a timeout.
/**
* Get the smallest timeout in the set; this does NOT set a timeout.
-EXPORT_SYMBOL(ptlrpc_set_next_timeout);
/**
* Send all unset request from the set and then wait untill all
/**
* Send all unset request from the set and then wait untill all
assert_spin_locked(&request->rq_import->imp_lock);
(void)__ptlrpc_req_finished(request, 1);
}
assert_spin_locked(&request->rq_import->imp_lock);
(void)__ptlrpc_req_finished(request, 1);
}
-EXPORT_SYMBOL(ptlrpc_req_finished_with_imp_lock);
* The request owner (i.e. the thread doing the I/O) must call...
* Returns 0 on success or 1 if unregistering cannot be made.
*/
* The request owner (i.e. the thread doing the I/O) must call...
* Returns 0 on success or 1 if unregistering cannot be made.
*/
-int ptlrpc_unregister_reply(struct ptlrpc_request *request, int async)
+static int ptlrpc_unregister_reply(struct ptlrpc_request *request, int async)
{
int rc;
struct l_wait_info lwi;
{
int rc;
struct l_wait_info lwi;
-EXPORT_SYMBOL(ptlrpc_unregister_reply);
static void ptlrpc_free_request(struct ptlrpc_request *req)
{
static void ptlrpc_free_request(struct ptlrpc_request *req)
{
-EXPORT_SYMBOL(ptlrpc_cleanup_client);
/**
* Schedule previously sent request for resend.
/**
* Schedule previously sent request for resend.
ptlrpc_client_wake_req(req);
spin_unlock(&req->rq_lock);
}
ptlrpc_client_wake_req(req);
spin_unlock(&req->rq_lock);
}
-EXPORT_SYMBOL(ptlrpc_resend_req);
/* XXX: this function and rq_status are currently unused */
void ptlrpc_restart_req(struct ptlrpc_request *req)
/* XXX: this function and rq_status are currently unused */
void ptlrpc_restart_req(struct ptlrpc_request *req)
ptlrpc_client_wake_req(req);
spin_unlock(&req->rq_lock);
}
ptlrpc_client_wake_req(req);
spin_unlock(&req->rq_lock);
}
-EXPORT_SYMBOL(ptlrpc_restart_req);
/**
* Grab additional reference on a request \a req
/**
* Grab additional reference on a request \a req
list_add(&req->rq_replay_list, &imp->imp_replay_list);
}
list_add(&req->rq_replay_list, &imp->imp_replay_list);
}
-EXPORT_SYMBOL(ptlrpc_retain_replayable_request);
/**
* Send request and wait until it completes.
/**
* Send request and wait until it completes.
ptlrpcd_add_req(req, PDL_POLICY_LOCAL, -1);
RETURN(0);
}
ptlrpcd_add_req(req, PDL_POLICY_LOCAL, -1);
RETURN(0);
}
-EXPORT_SYMBOL(ptlrpc_replay_req);
/**
* Aborts all in-flight request on import \a imp sending and delayed lists
/**
* Aborts all in-flight request on import \a imp sending and delayed lists
-EXPORT_SYMBOL(ptlrpc_abort_inflight);
/**
* Abort all uncompleted requests in request set \a set
/**
* Abort all uncompleted requests in request set \a set
-EXPORT_SYMBOL(ptlrpc_next_xid);
/**
* Get a glimpse at what next xid value might have been.
/**
* Get a glimpse at what next xid value might have been.
libcfs_nid2str(conn->c_peer.nid));
return conn;
}
libcfs_nid2str(conn->c_peer.nid));
return conn;
}
-EXPORT_SYMBOL(ptlrpc_connection_get);
int ptlrpc_connection_put(struct ptlrpc_connection *conn)
{
int ptlrpc_connection_put(struct ptlrpc_connection *conn)
{
-EXPORT_SYMBOL(ptlrpc_connection_put);
struct ptlrpc_connection *
ptlrpc_connection_addref(struct ptlrpc_connection *conn)
struct ptlrpc_connection *
ptlrpc_connection_addref(struct ptlrpc_connection *conn)
-EXPORT_SYMBOL(ptlrpc_connection_addref);
int ptlrpc_connection_init(void)
{
int ptlrpc_connection_init(void)
{
-EXPORT_SYMBOL(ptlrpc_connection_init);
void ptlrpc_connection_fini(void) {
ENTRY;
cfs_hash_putref(conn_hash);
EXIT;
}
void ptlrpc_connection_fini(void) {
ENTRY;
cfs_hash_putref(conn_hash);
EXIT;
}
-EXPORT_SYMBOL(ptlrpc_connection_fini);
/*
* Hash operations for net_peer<->connection
/*
* Hash operations for net_peer<->connection
{
rsc_flush_target(target);
}
{
rsc_flush_target(target);
}
-EXPORT_SYMBOL(gss_secsvc_flush);
static struct rsc *gss_svc_searchbyctx(rawobj_t *handle)
{
static struct rsc *gss_svc_searchbyctx(rawobj_t *handle)
{
UUID_STR, strlen(UUID_STR)))
*uuid_len -= strlen(UUID_STR);
}
UUID_STR, strlen(UUID_STR)))
*uuid_len -= strlen(UUID_STR);
}
-EXPORT_SYMBOL(deuuidify);
/**
* Returns true if import was FULL, false if import was already not
/**
* Returns true if import was FULL, false if import was already not
-EXPORT_SYMBOL(ptlrpc_fail_import);
int ptlrpc_reconnect_import(struct obd_import *imp)
{
int ptlrpc_reconnect_import(struct obd_import *imp)
{
-EXPORT_SYMBOL(ptlrpc_cleanup_imp);
/* Adaptive Timeout utils */
extern unsigned int at_min, at_max, at_history;
/* Adaptive Timeout utils */
extern unsigned int at_min, at_max, at_history;
llog_ctxt_put(ctxt);
return rc;
}
llog_ctxt_put(ctxt);
return rc;
}
-EXPORT_SYMBOL(llog_origin_handle_open);
int llog_origin_handle_destroy(struct ptlrpc_request *req)
{
int llog_origin_handle_destroy(struct ptlrpc_request *req)
{
llog_ctxt_put(ctxt);
RETURN(rc);
}
llog_ctxt_put(ctxt);
RETURN(rc);
}
-EXPORT_SYMBOL(llog_origin_handle_destroy);
int llog_origin_handle_next_block(struct ptlrpc_request *req)
{
int llog_origin_handle_next_block(struct ptlrpc_request *req)
{
llog_ctxt_put(ctxt);
return rc;
}
llog_ctxt_put(ctxt);
return rc;
}
-EXPORT_SYMBOL(llog_origin_handle_next_block);
int llog_origin_handle_prev_block(struct ptlrpc_request *req)
{
int llog_origin_handle_prev_block(struct ptlrpc_request *req)
{
llog_ctxt_put(ctxt);
return rc;
}
llog_ctxt_put(ctxt);
return rc;
}
-EXPORT_SYMBOL(llog_origin_handle_prev_block);
int llog_origin_handle_read_header(struct ptlrpc_request *req)
{
int llog_origin_handle_read_header(struct ptlrpc_request *req)
{
llog_ctxt_put(ctxt);
return rc;
}
llog_ctxt_put(ctxt);
return rc;
}
-EXPORT_SYMBOL(llog_origin_handle_read_header);
int llog_origin_handle_close(struct ptlrpc_request *req)
{
int llog_origin_handle_close(struct ptlrpc_request *req)
{
RETURN(err_serious(-ENOMEM));
RETURN(0);
}
RETURN(err_serious(-ENOMEM));
RETURN(0);
}
-EXPORT_SYMBOL(llog_origin_handle_close);
-EXPORT_SYMBOL(ptlrpc_start_bulk_transfer);
/**
* Server side bulk abort. Idempotent. Not thread-safe (i.e. only
/**
* Server side bulk abort. Idempotent. Not thread-safe (i.e. only
CWARN("Unexpectedly long timeout: desc %p\n", desc);
}
}
CWARN("Unexpectedly long timeout: desc %p\n", desc);
}
}
-EXPORT_SYMBOL(ptlrpc_abort_bulk);
#endif /* HAVE_SERVER_SUPPORT */
/**
#endif /* HAVE_SERVER_SUPPORT */
/**
-EXPORT_SYMBOL(ptlrpc_register_bulk);
/**
* Disconnect a bulk desc from the network. Idempotent. Not
/**
* Disconnect a bulk desc from the network. Idempotent. Not
-EXPORT_SYMBOL(ptlrpc_unregister_bulk);
static void ptlrpc_at_set_reply(struct ptlrpc_request *req, int flags)
{
static void ptlrpc_at_set_reply(struct ptlrpc_request *req, int flags)
{
ptlrpc_connection_put(conn);
return rc;
}
ptlrpc_connection_put(conn);
return rc;
}
-EXPORT_SYMBOL(ptlrpc_send_reply);
int ptlrpc_reply (struct ptlrpc_request *req)
{
int ptlrpc_reply (struct ptlrpc_request *req)
{
else
return (ptlrpc_send_reply(req, 0));
}
else
return (ptlrpc_send_reply(req, 0));
}
-EXPORT_SYMBOL(ptlrpc_reply);
/**
* For request \a req send an error reply back. Create empty
/**
* For request \a req send an error reply back. Create empty
rc = ptlrpc_send_reply(req, may_be_difficult);
RETURN(rc);
}
rc = ptlrpc_send_reply(req, may_be_difficult);
RETURN(rc);
}
-EXPORT_SYMBOL(ptlrpc_send_error);
int ptlrpc_error(struct ptlrpc_request *req)
{
return ptlrpc_send_error(req, 0);
}
int ptlrpc_error(struct ptlrpc_request *req)
{
return ptlrpc_send_error(req, 0);
}
-EXPORT_SYMBOL(ptlrpc_error);
/**
* Send request \a request.
/**
* Send request \a request.
-EXPORT_SYMBOL(ptlrpc_nrs_policy_register);
/**
* Unregisters a previously registered policy with NRS core. All instances of
/**
* Unregisters a previously registered policy with NRS core. All instances of
-EXPORT_SYMBOL(ptlrpc_nrs_policy_unregister);
/**
* Setup NRS heads on all service partitions of service \a svc, and register
/**
* Setup NRS heads on all service partitions of service \a svc, and register
-EXPORT_SYMBOL(lustre_msg_hdr_size);
void ptlrpc_buf_set_swabbed(struct ptlrpc_request *req, const int inout,
__u32 index)
void ptlrpc_buf_set_swabbed(struct ptlrpc_request *req, const int inout,
__u32 index)
else
lustre_set_rep_swabbed(req, index);
}
else
lustre_set_rep_swabbed(req, index);
}
-EXPORT_SYMBOL(ptlrpc_buf_set_swabbed);
int ptlrpc_buf_need_swab(struct ptlrpc_request *req, const int inout,
__u32 index)
int ptlrpc_buf_need_swab(struct ptlrpc_request *req, const int inout,
__u32 index)
return (ptlrpc_rep_need_swab(req) &&
!lustre_rep_swabbed(req, index));
}
return (ptlrpc_rep_need_swab(req) &&
!lustre_rep_swabbed(req, index));
}
-EXPORT_SYMBOL(ptlrpc_buf_need_swab);
static inline int lustre_msg_check_version_v2(struct lustre_msg_v2 *msg,
__u32 version)
static inline int lustre_msg_check_version_v2(struct lustre_msg_v2 *msg,
__u32 version)
-EXPORT_SYMBOL(lustre_msg_check_version);
/* early reply size */
__u32 lustre_msg_early_size()
/* early reply size */
__u32 lustre_msg_early_size()
-EXPORT_SYMBOL(lustre_msg_size);
/* This is used to determine the size of a buffer that was already packed
* and will correctly handle the different message formats. */
/* This is used to determine the size of a buffer that was already packed
* and will correctly handle the different message formats. */
-EXPORT_SYMBOL(lustre_packed_msg_size);
void lustre_init_msg_v2(struct lustre_msg_v2 *msg, int count, __u32 *lens,
char **bufs)
void lustre_init_msg_v2(struct lustre_msg_v2 *msg, int count, __u32 *lens,
char **bufs)
-EXPORT_SYMBOL(lustre_pack_request);
#if RS_DEBUG
struct list_head ptlrpc_rs_debug_lru =
#if RS_DEBUG
struct list_head ptlrpc_rs_debug_lru =
lustre_msg_size(req->rq_reqmsg->lm_magic, count, lens));
return rc;
}
lustre_msg_size(req->rq_reqmsg->lm_magic, count, lens));
return rc;
}
-EXPORT_SYMBOL(lustre_pack_reply_flags);
int lustre_pack_reply(struct ptlrpc_request *req, int count, __u32 *lens,
char **bufs)
int lustre_pack_reply(struct ptlrpc_request *req, int count, __u32 *lens,
char **bufs)
sptlrpc_svc_free_rs(rs);
}
sptlrpc_svc_free_rs(rs);
}
-EXPORT_SYMBOL(lustre_free_reply_state);
static int lustre_unpack_msg_v2(struct lustre_msg_v2 *m, int len)
{
static int lustre_unpack_msg_v2(struct lustre_msg_v2 *m, int len)
{
-EXPORT_SYMBOL(ptlrpc_unpack_req_msg);
int ptlrpc_unpack_rep_msg(struct ptlrpc_request *req, int len)
{
int ptlrpc_unpack_rep_msg(struct ptlrpc_request *req, int len)
{
-EXPORT_SYMBOL(ptlrpc_unpack_rep_msg);
static inline int lustre_unpack_ptlrpc_body_v2(struct ptlrpc_request *req,
const int inout, int offset)
static inline int lustre_unpack_ptlrpc_body_v2(struct ptlrpc_request *req,
const int inout, int offset)
-EXPORT_SYMBOL(lustre_msg_set_buflen);
-
/* NB return the bufcount for lustre_msg_v2 format, so if message is packed
* in V1 format, the result is one bigger. (add struct ptlrpc_body). */
__u32 lustre_msg_bufcount(struct lustre_msg *m)
/* NB return the bufcount for lustre_msg_v2 format, so if message is packed
* in V1 format, the result is one bigger. (add struct ptlrpc_body). */
__u32 lustre_msg_bufcount(struct lustre_msg *m)
-EXPORT_SYMBOL(lustre_msg_bufcount);
char *lustre_msg_string(struct lustre_msg *m, __u32 index, __u32 max_len)
{
char *lustre_msg_string(struct lustre_msg *m, __u32 index, __u32 max_len)
{
-EXPORT_SYMBOL(lustre_msg_string);
/* Wrap up the normal fixed length cases */
static inline void *__lustre_swab_buf(struct lustre_msg *msg, __u32 index,
/* Wrap up the normal fixed length cases */
static inline void *__lustre_swab_buf(struct lustre_msg *msg, __u32 index,
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
-EXPORT_SYMBOL(lustre_msg_set_flags);
void lustre_msg_clear_flags(struct lustre_msg *msg, __u32 flags)
{
void lustre_msg_clear_flags(struct lustre_msg *msg, __u32 flags)
{
-EXPORT_SYMBOL(lustre_msg_get_op_flags);
void lustre_msg_add_op_flags(struct lustre_msg *msg, __u32 flags)
{
void lustre_msg_add_op_flags(struct lustre_msg *msg, __u32 flags)
{
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
-EXPORT_SYMBOL(lustre_msg_set_op_flags);
struct lustre_handle *lustre_msg_get_handle(struct lustre_msg *msg)
{
struct lustre_handle *lustre_msg_get_handle(struct lustre_msg *msg)
{
-EXPORT_SYMBOL(lustre_msg_get_handle);
__u32 lustre_msg_get_type(struct lustre_msg *msg)
{
__u32 lustre_msg_get_type(struct lustre_msg *msg)
{
-EXPORT_SYMBOL(lustre_msg_get_version);
void lustre_msg_add_version(struct lustre_msg *msg, __u32 version)
{
void lustre_msg_add_version(struct lustre_msg *msg, __u32 version)
{
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
-EXPORT_SYMBOL(lustre_msg_add_version);
__u32 lustre_msg_get_opc(struct lustre_msg *msg)
{
__u32 lustre_msg_get_opc(struct lustre_msg *msg)
{
-EXPORT_SYMBOL(lustre_msg_get_last_xid);
__u64 lustre_msg_get_last_committed(struct lustre_msg *msg)
{
__u64 lustre_msg_get_last_committed(struct lustre_msg *msg)
{
-EXPORT_SYMBOL(lustre_msg_get_slv);
void lustre_msg_set_slv(struct lustre_msg *msg, __u64 slv)
void lustre_msg_set_slv(struct lustre_msg *msg, __u64 slv)
-EXPORT_SYMBOL(lustre_msg_set_slv);
__u32 lustre_msg_get_limit(struct lustre_msg *msg)
{
__u32 lustre_msg_get_limit(struct lustre_msg *msg)
{
-EXPORT_SYMBOL(lustre_msg_get_limit);
void lustre_msg_set_limit(struct lustre_msg *msg, __u64 limit)
void lustre_msg_set_limit(struct lustre_msg *msg, __u64 limit)
-EXPORT_SYMBOL(lustre_msg_set_limit);
__u32 lustre_msg_get_conn_cnt(struct lustre_msg *msg)
{
__u32 lustre_msg_get_conn_cnt(struct lustre_msg *msg)
{
-EXPORT_SYMBOL(lustre_msg_is_v1);
__u32 lustre_msg_get_magic(struct lustre_msg *msg)
{
__u32 lustre_msg_get_magic(struct lustre_msg *msg)
{
-EXPORT_SYMBOL(lustre_msg_get_magic);
__u32 lustre_msg_get_timeout(struct lustre_msg *msg)
{
__u32 lustre_msg_get_timeout(struct lustre_msg *msg)
{
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
-EXPORT_SYMBOL(lustre_msg_set_handle);
void lustre_msg_set_type(struct lustre_msg *msg, __u32 type)
{
void lustre_msg_set_type(struct lustre_msg *msg, __u32 type)
{
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
-EXPORT_SYMBOL(lustre_msg_set_type);
void lustre_msg_set_opc(struct lustre_msg *msg, __u32 opc)
{
void lustre_msg_set_opc(struct lustre_msg *msg, __u32 opc)
{
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
-EXPORT_SYMBOL(lustre_msg_set_opc);
void lustre_msg_set_last_xid(struct lustre_msg *msg, __u64 last_xid)
{
void lustre_msg_set_last_xid(struct lustre_msg *msg, __u64 last_xid)
{
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
-EXPORT_SYMBOL(lustre_msg_set_last_xid);
void lustre_msg_set_last_committed(struct lustre_msg *msg, __u64 last_committed)
{
void lustre_msg_set_last_committed(struct lustre_msg *msg, __u64 last_committed)
{
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
-EXPORT_SYMBOL(lustre_msg_set_last_committed);
void lustre_msg_set_versions(struct lustre_msg *msg, __u64 *versions)
{
void lustre_msg_set_versions(struct lustre_msg *msg, __u64 *versions)
{
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
-EXPORT_SYMBOL(lustre_msg_set_conn_cnt);
void lustre_msg_set_timeout(struct lustre_msg *msg, __u32 timeout)
{
void lustre_msg_set_timeout(struct lustre_msg *msg, __u32 timeout)
{
if (req->rq_reqmsg->lm_magic == LUSTRE_MSG_MAGIC_V2)
req->rq_reqmsg->lm_repsize = req->rq_replen;
}
if (req->rq_reqmsg->lm_magic == LUSTRE_MSG_MAGIC_V2)
req->rq_reqmsg->lm_repsize = req->rq_replen;
}
-EXPORT_SYMBOL(ptlrpc_req_set_repsize);
/**
* Send a remote set_info_async.
/**
* Send a remote set_info_async.
* and ptlrpc_body_v2. */
CLASSERT(offsetof(typeof(*b), pb_jobid) != 0);
}
* and ptlrpc_body_v2. */
CLASSERT(offsetof(typeof(*b), pb_jobid) != 0);
}
-EXPORT_SYMBOL(lustre_swab_ptlrpc_body);
void lustre_swab_connect(struct obd_connect_data *ocd)
{
void lustre_swab_connect(struct obd_connect_data *ocd)
{
CLASSERT(offsetof(typeof(*os), os_spare8) != 0);
CLASSERT(offsetof(typeof(*os), os_spare9) != 0);
}
CLASSERT(offsetof(typeof(*os), os_spare8) != 0);
CLASSERT(offsetof(typeof(*os), os_spare9) != 0);
}
-EXPORT_SYMBOL(lustre_swab_obd_statfs);
void lustre_swab_obd_ioobj(struct obd_ioobj *ioo)
{
void lustre_swab_obd_ioobj(struct obd_ioobj *ioo)
{
__swab32s(&ioo->ioo_max_brw);
__swab32s(&ioo->ioo_bufcnt);
}
__swab32s(&ioo->ioo_max_brw);
__swab32s(&ioo->ioo_bufcnt);
}
-EXPORT_SYMBOL(lustre_swab_obd_ioobj);
void lustre_swab_niobuf_remote(struct niobuf_remote *nbr)
{
void lustre_swab_niobuf_remote(struct niobuf_remote *nbr)
{
__swab32s(&nbr->rnb_len);
__swab32s(&nbr->rnb_flags);
}
__swab32s(&nbr->rnb_len);
__swab32s(&nbr->rnb_flags);
}
-EXPORT_SYMBOL(lustre_swab_niobuf_remote);
void lustre_swab_ost_body (struct ost_body *b)
{
lustre_swab_obdo (&b->oa);
}
void lustre_swab_ost_body (struct ost_body *b)
{
lustre_swab_obdo (&b->oa);
}
-EXPORT_SYMBOL(lustre_swab_ost_body);
void lustre_swab_ost_last_id(u64 *id)
{
__swab64s(id);
}
void lustre_swab_ost_last_id(u64 *id)
{
__swab64s(id);
}
-EXPORT_SYMBOL(lustre_swab_ost_last_id);
void lustre_swab_generic_32s(__u32 *val)
{
__swab32s(val);
}
void lustre_swab_generic_32s(__u32 *val)
{
__swab32s(val);
}
-EXPORT_SYMBOL(lustre_swab_generic_32s);
void lustre_swab_gl_desc(union ldlm_gl_desc *desc)
{
void lustre_swab_gl_desc(union ldlm_gl_desc *desc)
{
__swab32s(&b->mbo_gid_h);
CLASSERT(offsetof(typeof(*b), mbo_padding_5) != 0);
}
__swab32s(&b->mbo_gid_h);
CLASSERT(offsetof(typeof(*b), mbo_padding_5) != 0);
}
-EXPORT_SYMBOL(lustre_swab_mdt_body);
void lustre_swab_mdt_ioepoch (struct mdt_ioepoch *b)
{
void lustre_swab_mdt_ioepoch (struct mdt_ioepoch *b)
{
__swab32s (&b->flags);
CLASSERT(offsetof(typeof(*b), padding) != 0);
}
__swab32s (&b->flags);
CLASSERT(offsetof(typeof(*b), padding) != 0);
}
-EXPORT_SYMBOL(lustre_swab_mdt_ioepoch);
void lustre_swab_mgs_target_info(struct mgs_target_info *mti)
{
void lustre_swab_mgs_target_info(struct mgs_target_info *mti)
{
for (i = 0; i < MTI_NIDS_MAX; i++)
__swab64s(&mti->mti_nids[i]);
}
for (i = 0; i < MTI_NIDS_MAX; i++)
__swab64s(&mti->mti_nids[i]);
}
-EXPORT_SYMBOL(lustre_swab_mgs_target_info);
void lustre_swab_mgs_nidtbl_entry(struct mgs_nidtbl_entry *entry)
{
void lustre_swab_mgs_nidtbl_entry(struct mgs_nidtbl_entry *entry)
{
__swab32s(&body->mcb_units);
__swab16s(&body->mcb_type);
}
__swab32s(&body->mcb_units);
__swab16s(&body->mcb_type);
}
-EXPORT_SYMBOL(lustre_swab_mgs_config_body);
void lustre_swab_mgs_config_res(struct mgs_config_res *body)
{
__swab64s(&body->mcr_offset);
__swab64s(&body->mcr_size);
}
void lustre_swab_mgs_config_res(struct mgs_config_res *body)
{
__swab64s(&body->mcr_offset);
__swab64s(&body->mcr_size);
}
-EXPORT_SYMBOL(lustre_swab_mgs_config_res);
static void lustre_swab_obd_dqinfo (struct obd_dqinfo *i)
{
static void lustre_swab_obd_dqinfo (struct obd_dqinfo *i)
{
lustre_swab_obd_dqinfo (&q->qc_dqinfo);
lustre_swab_obd_dqblk (&q->qc_dqblk);
}
lustre_swab_obd_dqinfo (&q->qc_dqinfo);
lustre_swab_obd_dqblk (&q->qc_dqblk);
}
-EXPORT_SYMBOL(lustre_swab_obd_quotactl);
void lustre_swab_mdt_remote_perm (struct mdt_remote_perm *p)
{
void lustre_swab_mdt_remote_perm (struct mdt_remote_perm *p)
{
for (i = 0; i < fiemap->fm_mapped_extents; i++)
lustre_swab_fiemap_extent(&fiemap->fm_extents[i]);
}
for (i = 0; i < fiemap->fm_mapped_extents; i++)
lustre_swab_fiemap_extent(&fiemap->fm_extents[i]);
}
-EXPORT_SYMBOL(lustre_swab_fiemap);
void lustre_swab_idx_info(struct idx_info *ii)
{
void lustre_swab_idx_info(struct idx_info *ii)
{
CLASSERT(offsetof(typeof(*rr), rr_padding_4) != 0);
};
CLASSERT(offsetof(typeof(*rr), rr_padding_4) != 0);
};
-EXPORT_SYMBOL(lustre_swab_mdt_rec_reint);
void lustre_swab_lov_desc (struct lov_desc *ld)
{
void lustre_swab_lov_desc (struct lov_desc *ld)
{
-EXPORT_SYMBOL(lustre_swab_lmv_mds_md);
void lustre_swab_lmv_user_md(struct lmv_user_md *lum)
{
void lustre_swab_lmv_user_md(struct lmv_user_md *lum)
{
__swab16s(&lmm->lmm_layout_gen);
EXIT;
}
__swab16s(&lmm->lmm_layout_gen);
EXIT;
}
-EXPORT_SYMBOL(lustre_swab_lov_mds_md);
void lustre_swab_lov_user_md_objects(struct lov_user_ost_data *lod,
int stripe_count)
void lustre_swab_lov_user_md_objects(struct lov_user_ost_data *lod,
int stripe_count)
for (i = 0; i < RES_NAME_SIZE; i++)
__swab64s (&id->name[i]);
}
for (i = 0; i < RES_NAME_SIZE; i++)
__swab64s (&id->name[i]);
}
-EXPORT_SYMBOL(lustre_swab_ldlm_res_id);
void lustre_swab_ldlm_policy_data (ldlm_wire_policy_data_t *d)
{
void lustre_swab_ldlm_policy_data (ldlm_wire_policy_data_t *d)
{
__swab64s(&d->l_flock.lfw_owner);
__swab32s(&d->l_flock.lfw_pid);
}
__swab64s(&d->l_flock.lfw_owner);
__swab32s(&d->l_flock.lfw_pid);
}
-EXPORT_SYMBOL(lustre_swab_ldlm_policy_data);
void lustre_swab_ldlm_intent (struct ldlm_intent *i)
{
__swab64s (&i->opc);
}
void lustre_swab_ldlm_intent (struct ldlm_intent *i)
{
__swab64s (&i->opc);
}
-EXPORT_SYMBOL(lustre_swab_ldlm_intent);
void lustre_swab_ldlm_resource_desc (struct ldlm_resource_desc *r)
{
void lustre_swab_ldlm_resource_desc (struct ldlm_resource_desc *r)
{
CLASSERT(offsetof(typeof(*r), lr_padding) != 0);
lustre_swab_ldlm_res_id (&r->lr_name);
}
CLASSERT(offsetof(typeof(*r), lr_padding) != 0);
lustre_swab_ldlm_res_id (&r->lr_name);
}
-EXPORT_SYMBOL(lustre_swab_ldlm_resource_desc);
void lustre_swab_ldlm_lock_desc (struct ldlm_lock_desc *l)
{
void lustre_swab_ldlm_lock_desc (struct ldlm_lock_desc *l)
{
__swab32s (&l->l_granted_mode);
lustre_swab_ldlm_policy_data (&l->l_policy_data);
}
__swab32s (&l->l_granted_mode);
lustre_swab_ldlm_policy_data (&l->l_policy_data);
}
-EXPORT_SYMBOL(lustre_swab_ldlm_lock_desc);
void lustre_swab_ldlm_request (struct ldlm_request *rq)
{
void lustre_swab_ldlm_request (struct ldlm_request *rq)
{
__swab32s (&rq->lock_count);
/* lock_handle[] opaque */
}
__swab32s (&rq->lock_count);
/* lock_handle[] opaque */
}
-EXPORT_SYMBOL(lustre_swab_ldlm_request);
void lustre_swab_ldlm_reply (struct ldlm_reply *r)
{
void lustre_swab_ldlm_reply (struct ldlm_reply *r)
{
__swab64s (&r->lock_policy_res1);
__swab64s (&r->lock_policy_res2);
}
__swab64s (&r->lock_policy_res1);
__swab64s (&r->lock_policy_res2);
}
-EXPORT_SYMBOL(lustre_swab_ldlm_reply);
void lustre_swab_quota_body(struct quota_body *b)
{
void lustre_swab_quota_body(struct quota_body *b)
{
"ioo_bufct=%d\n", POSTID(&ioo->ioo_oid), ioo->ioo_max_brw,
ioo->ioo_bufcnt);
}
"ioo_bufct=%d\n", POSTID(&ioo->ioo_oid), ioo->ioo_max_brw,
ioo->ioo_bufcnt);
}
-EXPORT_SYMBOL(dump_ioo);
void dump_rniobuf(struct niobuf_remote *nb)
{
CDEBUG(D_RPCTRACE, "niobuf_remote: offset="LPU64", len=%d, flags=%x\n",
nb->rnb_offset, nb->rnb_len, nb->rnb_flags);
}
void dump_rniobuf(struct niobuf_remote *nb)
{
CDEBUG(D_RPCTRACE, "niobuf_remote: offset="LPU64", len=%d, flags=%x\n",
nb->rnb_offset, nb->rnb_len, nb->rnb_flags);
}
-EXPORT_SYMBOL(dump_rniobuf);
void dump_obdo(struct obdo *oa)
{
void dump_obdo(struct obdo *oa)
{
CDEBUG(D_RPCTRACE, "obdo: o_lcookie = "
"(llog_cookie dumping not yet implemented)\n");
}
CDEBUG(D_RPCTRACE, "obdo: o_lcookie = "
"(llog_cookie dumping not yet implemented)\n");
}
-EXPORT_SYMBOL(dump_obdo);
void dump_ost_body(struct ost_body *ob)
{
dump_obdo(&ob->oa);
}
void dump_ost_body(struct ost_body *ob)
{
dump_obdo(&ob->oa);
}
-EXPORT_SYMBOL(dump_ost_body);
void dump_rcs(__u32 *rc)
{
CDEBUG(D_RPCTRACE, "rmf_rcs: %d\n", *rc);
}
void dump_rcs(__u32 *rc)
{
CDEBUG(D_RPCTRACE, "rmf_rcs: %d\n", *rc);
}
-EXPORT_SYMBOL(dump_rcs);
static inline int req_ptlrpc_body_swabbed(struct ptlrpc_request *req)
{
static inline int req_ptlrpc_body_swabbed(struct ptlrpc_request *req)
{
__swab32s (&c->lc_timeout);
__swab32s (&c->lc_expiry);
}
__swab32s (&c->lc_timeout);
__swab32s (&c->lc_expiry);
}
-EXPORT_SYMBOL(lustre_swab_lustre_capa);
void lustre_swab_lustre_capa_key(struct lustre_capa_key *k)
{
void lustre_swab_lustre_capa_key(struct lustre_capa_key *k)
{
__swab32s (&k->lk_keyid);
CLASSERT(offsetof(typeof(*k), lk_padding) != 0);
}
__swab32s (&k->lk_keyid);
CLASSERT(offsetof(typeof(*k), lk_padding) != 0);
}
-EXPORT_SYMBOL(lustre_swab_lustre_capa_key);
void lustre_swab_hsm_user_state(struct hsm_user_state *state)
{
__swab32s(&state->hus_states);
__swab32s(&state->hus_archive_id);
}
void lustre_swab_hsm_user_state(struct hsm_user_state *state)
{
__swab32s(&state->hus_states);
__swab32s(&state->hus_archive_id);
}
-EXPORT_SYMBOL(lustre_swab_hsm_user_state);
void lustre_swab_hsm_state_set(struct hsm_state_set *hss)
{
void lustre_swab_hsm_state_set(struct hsm_state_set *hss)
{
__swab64s(&hss->hss_clearmask);
__swab32s(&hss->hss_archive_id);
}
__swab64s(&hss->hss_clearmask);
__swab32s(&hss->hss_archive_id);
}
-EXPORT_SYMBOL(lustre_swab_hsm_state_set);
static void lustre_swab_hsm_extent(struct hsm_extent *extent)
{
static void lustre_swab_hsm_extent(struct hsm_extent *extent)
{
__swab32s(&action->hca_action);
lustre_swab_hsm_extent(&action->hca_location);
}
__swab32s(&action->hca_action);
lustre_swab_hsm_extent(&action->hca_location);
}
-EXPORT_SYMBOL(lustre_swab_hsm_current_action);
void lustre_swab_hsm_user_item(struct hsm_user_item *hui)
{
lustre_swab_lu_fid(&hui->hui_fid);
lustre_swab_hsm_extent(&hui->hui_extent);
}
void lustre_swab_hsm_user_item(struct hsm_user_item *hui)
{
lustre_swab_lu_fid(&hui->hui_fid);
lustre_swab_hsm_extent(&hui->hui_extent);
}
-EXPORT_SYMBOL(lustre_swab_hsm_user_item);
void lustre_swab_layout_intent(struct layout_intent *li)
{
void lustre_swab_layout_intent(struct layout_intent *li)
{
__swab64s(&li->li_start);
__swab64s(&li->li_end);
}
__swab64s(&li->li_start);
__swab64s(&li->li_end);
}
-EXPORT_SYMBOL(lustre_swab_layout_intent);
void lustre_swab_hsm_progress_kernel(struct hsm_progress_kernel *hpk)
{
void lustre_swab_hsm_progress_kernel(struct hsm_progress_kernel *hpk)
{
__swab16s(&hpk->hpk_flags);
__swab16s(&hpk->hpk_errval);
}
__swab16s(&hpk->hpk_flags);
__swab16s(&hpk->hpk_errval);
}
-EXPORT_SYMBOL(lustre_swab_hsm_progress_kernel);
void lustre_swab_hsm_request(struct hsm_request *hr)
{
void lustre_swab_hsm_request(struct hsm_request *hr)
{
__swab32s(&hr->hr_itemcount);
__swab32s(&hr->hr_data_len);
}
__swab32s(&hr->hr_itemcount);
__swab32s(&hr->hr_data_len);
}
-EXPORT_SYMBOL(lustre_swab_hsm_request);
void lustre_swab_object_update(struct object_update *ou)
{
void lustre_swab_object_update(struct object_update *ou)
{
object_update_param_size(param));
}
}
object_update_param_size(param));
}
}
-EXPORT_SYMBOL(lustre_swab_object_update);
void lustre_swab_object_update_request(struct object_update_request *our)
{
void lustre_swab_object_update_request(struct object_update_request *our)
{
lustre_swab_object_update(ou);
}
}
lustre_swab_object_update(ou);
}
}
-EXPORT_SYMBOL(lustre_swab_object_update_request);
void lustre_swab_object_update_result(struct object_update_result *our)
{
void lustre_swab_object_update_result(struct object_update_result *our)
{
__swab16s(&our->our_datalen);
__swab16s(&our->our_padding);
}
__swab16s(&our->our_datalen);
__swab16s(&our->our_padding);
}
-EXPORT_SYMBOL(lustre_swab_object_update_result);
void lustre_swab_object_update_reply(struct object_update_reply *our)
{
void lustre_swab_object_update_reply(struct object_update_reply *our)
{
lustre_swab_object_update_result(ourp);
}
}
lustre_swab_object_update_result(ourp);
}
}
-EXPORT_SYMBOL(lustre_swab_object_update_reply);
void lustre_swab_swap_layouts(struct mdc_swap_layouts *msl)
{
__swab64s(&msl->msl_flags);
}
void lustre_swab_swap_layouts(struct mdc_swap_layouts *msl)
{
__swab64s(&msl->msl_flags);
}
-EXPORT_SYMBOL(lustre_swab_swap_layouts);
void lustre_swab_close_data(struct close_data *cd)
{
lustre_swab_lu_fid(&cd->cd_fid);
__swab64s(&cd->cd_data_version);
}
void lustre_swab_close_data(struct close_data *cd)
{
lustre_swab_lu_fid(&cd->cd_fid);
__swab64s(&cd->cd_data_version);
}
-EXPORT_SYMBOL(lustre_swab_close_data);
void lustre_swab_lfsck_request(struct lfsck_request *lr)
{
void lustre_swab_lfsck_request(struct lfsck_request *lr)
{
CLASSERT(offsetof(typeof(*lr), lr_padding_1) != 0);
CLASSERT(offsetof(typeof(*lr), lr_padding_2) != 0);
}
CLASSERT(offsetof(typeof(*lr), lr_padding_1) != 0);
CLASSERT(offsetof(typeof(*lr), lr_padding_2) != 0);
}
-EXPORT_SYMBOL(lustre_swab_lfsck_request);
void lustre_swab_lfsck_reply(struct lfsck_reply *lr)
{
void lustre_swab_lfsck_reply(struct lfsck_reply *lr)
{
CLASSERT(offsetof(typeof(*lr), lr_padding_1) != 0);
CLASSERT(offsetof(typeof(*lr), lr_padding_2) != 0);
}
CLASSERT(offsetof(typeof(*lr), lr_padding_1) != 0);
CLASSERT(offsetof(typeof(*lr), lr_padding_2) != 0);
}
-EXPORT_SYMBOL(lustre_swab_lfsck_reply);
void lustre_swab_orphan_ent(struct lu_orphan_ent *ent)
{
void lustre_swab_orphan_ent(struct lu_orphan_ent *ent)
{
{
ptlrpc_update_next_ping(imp, 0);
}
{
ptlrpc_update_next_ping(imp, 0);
}
-EXPORT_SYMBOL(ptlrpc_pinger_sending_on_import);
void ptlrpc_pinger_commit_expected(struct obd_import *imp)
{
void ptlrpc_pinger_commit_expected(struct obd_import *imp)
{
struct ptlrpc_request *ptlrpc_request_cache_alloc(gfp_t flags);
void ptlrpc_request_cache_free(struct ptlrpc_request *req);
void ptlrpc_init_xid(void);
struct ptlrpc_request *ptlrpc_request_cache_alloc(gfp_t flags);
void ptlrpc_request_cache_free(struct ptlrpc_request *req);
void ptlrpc_init_xid(void);
+void ptlrpc_set_add_new_req(struct ptlrpcd_ctl *pc,
+ struct ptlrpc_request *req);
+int ptlrpc_expired_set(void *data);
+int ptlrpc_set_next_timeout(struct ptlrpc_request_set *);
+void ptlrpc_resend_req(struct ptlrpc_request *request);
/* events.c */
int ptlrpc_init_portals(void);
/* events.c */
int ptlrpc_init_portals(void);
wake_up(&pc->pc_partners[i]->pc_set->set_waitq);
}
}
wake_up(&pc->pc_partners[i]->pc_set->set_waitq);
}
}
-EXPORT_SYMBOL(ptlrpcd_add_rqset);
/**
* Return transferred RPCs count.
/**
* Return transferred RPCs count.
-EXPORT_SYMBOL(ptlrpc_resend);
/**
* Go through all requests in delayed list and wake their threads
/**
* Go through all requests in delayed list and wake their threads
}
spin_unlock(&imp->imp_lock);
}
}
spin_unlock(&imp->imp_lock);
}
-EXPORT_SYMBOL(ptlrpc_wake_delayed);
void ptlrpc_request_handle_notconn(struct ptlrpc_request *failed_req)
{
void ptlrpc_request_handle_notconn(struct ptlrpc_request *failed_req)
{
desc->bd_iov_count * sizeof(*desc->bd_enc_iov));
desc->bd_enc_iov = NULL;
}
desc->bd_iov_count * sizeof(*desc->bd_enc_iov));
desc->bd_enc_iov = NULL;
}
-EXPORT_SYMBOL(sptlrpc_enc_pool_put_pages);
/*
* we don't do much stuff for add_user/del_user anymore, except adding some
/*
* we don't do much stuff for add_user/del_user anymore, except adding some
{
return cfs_crypto_hash_name(cfs_hash_alg_id[hash_alg]);
}
{
return cfs_crypto_hash_name(cfs_hash_alg_id[hash_alg]);
}
-EXPORT_SYMBOL(sptlrpc_get_hash_name);
__u8 sptlrpc_get_hash_alg(const char *algname)
{
return cfs_crypto_hash_alg(algname);
}
__u8 sptlrpc_get_hash_alg(const char *algname)
{
return cfs_crypto_hash_alg(algname);
}
-EXPORT_SYMBOL(sptlrpc_get_hash_alg);
int bulk_sec_desc_unpack(struct lustre_msg *msg, int offset, int swabbed)
{
int bulk_sec_desc_unpack(struct lustre_msg *msg, int offset, int swabbed)
{
-EXPORT_SYMBOL(sptlrpc_get_bulk_checksum);
CERROR("unknown target %p(%s)\n", obd, type);
return LUSTRE_SP_ANY;
}
CERROR("unknown target %p(%s)\n", obd, type);
return LUSTRE_SP_ANY;
}
-EXPORT_SYMBOL(sptlrpc_target_sec_part);
/****************************************
* user supplied flavor string parsing *
/****************************************
* user supplied flavor string parsing *
rset->srs_nslot = nslot;
return 0;
}
rset->srs_nslot = nslot;
return 0;
}
-EXPORT_SYMBOL(sptlrpc_rule_set_expand);
static inline int rule_spec_dir(struct sptlrpc_rule *rule)
{
static inline int rule_spec_dir(struct sptlrpc_rule *rule)
{
-EXPORT_SYMBOL(sptlrpc_rule_set_choose);
void sptlrpc_rule_set_dump(struct sptlrpc_rule_set *rset)
{
void sptlrpc_rule_set_dump(struct sptlrpc_rule_set *rset)
{
r->sr_from, r->sr_to, r->sr_netid, r->sr_flvr.sf_rpc);
}
}
r->sr_from, r->sr_to, r->sr_netid, r->sr_flvr.sf_rpc);
}
}
-EXPORT_SYMBOL(sptlrpc_rule_set_dump);
static int sptlrpc_rule_set_extract(struct sptlrpc_rule_set *gen,
struct sptlrpc_rule_set *tgt,
static int sptlrpc_rule_set_extract(struct sptlrpc_rule_set *gen,
struct sptlrpc_rule_set *tgt,
if (sptlrpc_rule_set_choose(rset, from, LUSTRE_SP_ANY, nid, sf) == 0)
get_default_flavor(sf);
}
if (sptlrpc_rule_set_choose(rset, from, LUSTRE_SP_ANY, nid, sf) == 0)
get_default_flavor(sf);
}
-EXPORT_SYMBOL(sptlrpc_target_choose_flavor);
#define SEC_ADAPT_DELAY (10)
#define SEC_ADAPT_DELAY (10)
mutex_unlock(&sptlrpc_conf_lock);
RETURN(rc);
}
mutex_unlock(&sptlrpc_conf_lock);
RETURN(rc);
}
-EXPORT_SYMBOL(sptlrpc_conf_target_get_rules);
int sptlrpc_conf_init(void)
{
int sptlrpc_conf_init(void)
{
CDEBUG(D_SEC, "added sec %p(%s)\n", sec, sec->ps_policy->sp_name);
}
CDEBUG(D_SEC, "added sec %p(%s)\n", sec, sec->ps_policy->sp_name);
}
-EXPORT_SYMBOL(sptlrpc_gc_add_sec);
void sptlrpc_gc_del_sec(struct ptlrpc_sec *sec)
{
void sptlrpc_gc_del_sec(struct ptlrpc_sec *sec)
{
CDEBUG(D_SEC, "del sec %p(%s)\n", sec, sec->ps_policy->sp_name);
}
CDEBUG(D_SEC, "del sec %p(%s)\n", sec, sec->ps_policy->sp_name);
}
-EXPORT_SYMBOL(sptlrpc_gc_del_sec);
void sptlrpc_gc_add_ctx(struct ptlrpc_cli_ctx *ctx)
{
void sptlrpc_gc_add_ctx(struct ptlrpc_cli_ctx *ctx)
{
rs_batch_fini(&batch);
EXIT;
}
rs_batch_fini(&batch);
EXIT;
}
-EXPORT_SYMBOL(ptlrpc_commit_replies);
static int
ptlrpc_server_post_idle_rqbds(struct ptlrpc_service_part *svcpt)
static int
ptlrpc_server_post_idle_rqbds(struct ptlrpc_service_part *svcpt)
-EXPORT_SYMBOL(ptlrpc_update_export_timer);
/**
* Sanity check request \a req.
/**
* Sanity check request \a req.
-EXPORT_SYMBOL(ptlrpc_stop_all_threads);
int ptlrpc_start_threads(struct ptlrpc_service *svc)
{
int ptlrpc_start_threads(struct ptlrpc_service *svc)
{
ptlrpc_stop_all_threads(svc);
RETURN(rc);
}
ptlrpc_stop_all_threads(svc);
RETURN(rc);
}
-EXPORT_SYMBOL(ptlrpc_start_threads);
int ptlrpc_start_thread(struct ptlrpc_service_part *svcpt, int wait)
{
int ptlrpc_start_thread(struct ptlrpc_service_part *svcpt, int wait)
{
git://git.whamcloud.com / fs / lustre-release.git / commitdiff