cl->cli_reply_portal = rep_portal;
cl->cli_name = name;
}
+EXPORT_SYMBOL(ptlrpc_init_client);
/**
* Return PortalRPC connection for remore uud \a uuid
return c;
}
+EXPORT_SYMBOL(ptlrpc_uuid_to_connection);
/**
* Allocate and initialize new bulk descriptor
return desc;
}
+EXPORT_SYMBOL(ptlrpc_prep_bulk_imp);
/**
* Add a page \a page to the bulk descriptor \a desc.
cfs_page_pin(page);
ptlrpc_add_bulk_page(desc, page, pageoffset, len);
}
+EXPORT_SYMBOL(ptlrpc_prep_bulk_page);
/**
* Uninitialize and free bulk descriptor \a desc.
bd_iov[desc->bd_max_iov]));
EXIT;
}
+EXPORT_SYMBOL(ptlrpc_free_bulk);
/**
* Set server timelimit for this req, i.e. how long are we willing to wait
reqmsg*/
lustre_msg_set_timeout(req->rq_reqmsg, req->rq_timeout);
}
+EXPORT_SYMBOL(ptlrpc_at_set_req_timeout);
/* Adjust max service estimate based on server value */
static void ptlrpc_at_adj_service(struct ptlrpc_request *req,
cfs_spin_unlock(&pool->prp_lock);
OBD_FREE(pool, sizeof(*pool));
}
+EXPORT_SYMBOL(ptlrpc_free_rq_pool);
/**
* Allocates, initializes and adds \a num_rq requests to the pool \a pool
cfs_spin_unlock(&pool->prp_lock);
return;
}
+EXPORT_SYMBOL(ptlrpc_add_rqs_to_pool);
/**
* Create and initialize new request pool with given attributes:
}
return pool;
}
+EXPORT_SYMBOL(ptlrpc_init_rq_pool);
/**
* Fetches one request from pool \a pool
return rc;
}
+EXPORT_SYMBOL(ptlrpc_request_pack);
/**
* Helper function to allocate new request on import \a imp
{
return ptlrpc_request_alloc_internal(imp, NULL, format);
}
+EXPORT_SYMBOL(ptlrpc_request_alloc);
/**
* Allocate new request structure for import \a imp from pool \a pool and
{
return ptlrpc_request_alloc_internal(imp, pool, format);
}
+EXPORT_SYMBOL(ptlrpc_request_alloc_pool);
/**
* For requests not from pool, free memory of the request structure.
else
OBD_FREE_PTR(request);
}
+EXPORT_SYMBOL(ptlrpc_request_free);
/**
* Allocate new request for operatione \a opcode and immediatelly pack it for
}
return req;
}
+EXPORT_SYMBOL(ptlrpc_request_alloc_pack);
/**
* Prepare request (fetched from pool \a poolif not NULL) on import \a imp
}
return request;
}
+EXPORT_SYMBOL(ptlrpc_prep_req_pool);
/**
* Same as ptlrpc_prep_req_pool, but without pool
return ptlrpc_prep_req_pool(imp, version, opcode, count, lengths, bufs,
NULL);
}
+EXPORT_SYMBOL(ptlrpc_prep_req);
/**
* Allocate "fake" request that would not be sent anywhere in the end.
RETURN(request);
}
+EXPORT_SYMBOL(ptlrpc_prep_fakereq);
/**
* Indicate that processing of "fake" request is finished.
cfs_waitq_signal(&set->set_waitq);
ptlrpc_req_finished(req);
}
+EXPORT_SYMBOL(ptlrpc_fakereq_finished);
/**
* Allocate and initialize new request set structure.
RETURN(set);
}
+EXPORT_SYMBOL(ptlrpc_prep_set);
/**
* Allocate and initialize new request set structure with flow control
ptlrpc_reqset_put(set);
EXIT;
}
+EXPORT_SYMBOL(ptlrpc_set_destroy);
/**
* Add a callback function \a fn to the set.
RETURN(0);
}
+EXPORT_SYMBOL(ptlrpc_set_add_cb);
/**
* Add a new request to the general purpose request set.
* sent straight away */
ptlrpc_send_new_req(req);
}
+EXPORT_SYMBOL(ptlrpc_set_add_req);
/**
* Add a request to a request with dedicated server thread
cfs_waitq_signal(&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
/* If we hit an error, we want to recover promptly. */
RETURN(cfs_atomic_read(&set->set_remaining) == 0 || force_timer_recalc);
}
+EXPORT_SYMBOL(ptlrpc_check_set);
/**
* Time out request \a req. is \a async_unlink is set, that means do not wait
*/
RETURN(1);
}
+EXPORT_SYMBOL(ptlrpc_expired_set);
/**
* Sets rq_intr flag in \a req under spinlock.
req->rq_intr = 1;
cfs_spin_unlock(&req->rq_lock);
}
+EXPORT_SYMBOL(ptlrpc_mark_interrupted);
/**
* Interrupts (sets interrupted flag) all uncompleted requests in
ptlrpc_mark_interrupted(req);
}
}
+EXPORT_SYMBOL(ptlrpc_interrupted_set);
/**
* Get the smallest timeout in the set; this does NOT set a timeout.
}
RETURN(timeout);
}
+EXPORT_SYMBOL(ptlrpc_set_next_timeout);
/**
* Send all unset request from the set and then wait untill all
RETURN(rc);
}
+EXPORT_SYMBOL(ptlrpc_set_wait);
/**
* Helper fuction for request freeing.
LASSERT_SPIN_LOCKED(&request->rq_import->imp_lock);
(void)__ptlrpc_req_finished(request, 1);
}
+EXPORT_SYMBOL(ptlrpc_req_finished_with_imp_lock);
/**
* Helper function
{
__ptlrpc_req_finished(request, 0);
}
+EXPORT_SYMBOL(ptlrpc_req_finished);
/**
* Returns xid of a \a request
}
RETURN(0);
}
+EXPORT_SYMBOL(ptlrpc_unregister_reply);
/**
* Iterates through replay_list on import and prunes
EXIT;
return;
}
+EXPORT_SYMBOL(ptlrpc_cleanup_client);
/**
* Schedule previously sent request for resend.
ptlrpc_client_wake_req(req);
cfs_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)
ptlrpc_client_wake_req(req);
cfs_spin_unlock(&req->rq_lock);
}
+EXPORT_SYMBOL(ptlrpc_restart_req);
/**
* Grab additional reference on a request \a req
cfs_atomic_inc(&req->rq_refcount);
RETURN(req);
}
+EXPORT_SYMBOL(ptlrpc_request_addref);
/**
* Add a request to import replay_list.
cfs_list_add(&req->rq_replay_list, &imp->imp_replay_list);
}
+EXPORT_SYMBOL(ptlrpc_retain_replayable_request);
/**
* Send request and wait until it completes.
RETURN(rc);
}
+EXPORT_SYMBOL(ptlrpc_queue_wait);
struct ptlrpc_replay_async_args {
int praa_old_state;
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
EXIT;
}
+EXPORT_SYMBOL(ptlrpc_abort_inflight);
/**
* Abort all uncompleted requests in request set \a set
cfs_spin_unlock(&ptlrpc_last_xid_lock);
return tmp;
}
+EXPORT_SYMBOL(ptlrpc_next_xid);
/**
* Get a glimpse at what next xid value might have been.
libcfs_nid2str(conn->c_peer.nid));
return conn;
}
+EXPORT_SYMBOL(ptlrpc_connection_get);
int ptlrpc_connection_put(struct ptlrpc_connection *conn)
{
RETURN(rc);
}
+EXPORT_SYMBOL(ptlrpc_connection_put);
struct ptlrpc_connection *
ptlrpc_connection_addref(struct ptlrpc_connection *conn)
RETURN(conn);
}
+EXPORT_SYMBOL(ptlrpc_connection_addref);
int ptlrpc_connection_init(void)
{
RETURN(0);
}
+EXPORT_SYMBOL(ptlrpc_connection_init);
void ptlrpc_connection_fini(void) {
ENTRY;
cfs_hash_putref(conn_hash);
EXIT;
}
+EXPORT_SYMBOL(ptlrpc_connection_fini);
/*
* Hash operations for net_peer<->connection
cfs_spin_lock(&imp->imp_lock);
ptlrpc_deactivate_and_unlock_import(imp);
}
+EXPORT_SYMBOL(ptlrpc_deactivate_import);
static unsigned int
ptlrpc_inflight_deadline(struct ptlrpc_request *req, time_t now)
cfs_atomic_dec(&imp->imp_inval_count);
cfs_waitq_broadcast(&imp->imp_recovery_waitq);
}
+EXPORT_SYMBOL(ptlrpc_invalidate_import);
/* unset imp_invalid */
void ptlrpc_activate_import(struct obd_import *imp)
cfs_spin_unlock(&imp->imp_lock);
obd_import_event(obd, imp, IMP_EVENT_ACTIVE);
}
+EXPORT_SYMBOL(ptlrpc_activate_import);
void ptlrpc_fail_import(struct obd_import *imp, __u32 conn_cnt)
{
}
EXIT;
}
+EXPORT_SYMBOL(ptlrpc_fail_import);
int ptlrpc_reconnect_import(struct obd_import *imp)
{
RETURN(rc);
}
+EXPORT_SYMBOL(ptlrpc_disconnect_import);
void ptlrpc_cleanup_imp(struct obd_import *imp)
{
EXIT;
}
+EXPORT_SYMBOL(ptlrpc_cleanup_imp);
/* Adaptive Timeout utils */
extern unsigned int at_min, at_max, at_history;
lop_destroy: llog_client_destroy,
lop_close: llog_client_close,
};
+EXPORT_SYMBOL(llog_client_ops);
llog_ctxt_put(ctxt);
return rc;
}
+EXPORT_SYMBOL(llog_origin_handle_create);
int llog_origin_handle_destroy(struct ptlrpc_request *req)
{
llog_ctxt_put(ctxt);
return rc;
}
+EXPORT_SYMBOL(llog_origin_handle_destroy);
int llog_origin_handle_next_block(struct ptlrpc_request *req)
{
OBD_FREE(buf, LLOG_CHUNK_SIZE);
return rc;
}
+EXPORT_SYMBOL(llog_origin_handle_next_block);
int llog_origin_handle_prev_block(struct ptlrpc_request *req)
{
OBD_FREE(buf, LLOG_CHUNK_SIZE);
return rc;
}
+EXPORT_SYMBOL(llog_origin_handle_prev_block);
int llog_origin_handle_read_header(struct ptlrpc_request *req)
{
llog_ctxt_put(ctxt);
return rc;
}
+EXPORT_SYMBOL(llog_origin_handle_read_header);
int llog_origin_handle_close(struct ptlrpc_request *req)
{
/* Nothing to do */
RETURN(0);
}
+EXPORT_SYMBOL(llog_origin_handle_close);
int llog_origin_handle_cancel(struct ptlrpc_request *req)
{
return desc;
}
+EXPORT_SYMBOL(ptlrpc_prep_bulk_exp);
/**
* Starts bulk transfer for descriptor \a desc
RETURN(0);
}
+EXPORT_SYMBOL(ptlrpc_start_bulk_transfer);
/**
* Server side bulk abort. Idempotent. Not thread-safe (i.e. only
CWARN("Unexpectedly long timeout: desc %p\n", desc);
}
}
+EXPORT_SYMBOL(ptlrpc_abort_bulk);
#endif /* HAVE_SERVER_SUPPORT */
/**
req->rq_xid, desc->bd_portal);
RETURN(0);
}
+EXPORT_SYMBOL(ptlrpc_register_bulk);
/**
* Disconnect a bulk desc from the network. Idempotent. Not
}
RETURN(0);
}
+EXPORT_SYMBOL(ptlrpc_unregister_bulk);
static void ptlrpc_at_set_reply(struct ptlrpc_request *req, int flags)
{
ptlrpc_connection_put(conn);
return rc;
}
+EXPORT_SYMBOL(ptlrpc_send_reply);
int ptlrpc_reply (struct ptlrpc_request *req)
{
else
return (ptlrpc_send_reply(req, 0));
}
+EXPORT_SYMBOL(ptlrpc_reply);
/**
* For request \a req send an error reply back. Create empty
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);
}
+EXPORT_SYMBOL(ptlrpc_error);
/**
* Send request \a request.
cfs_memory_pressure_restore(mpflag);
return rc;
}
+EXPORT_SYMBOL(ptl_send_rpc);
/**
* Register request buffer descriptor for request receiving.
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,
int 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)
return 0;
}
}
+EXPORT_SYMBOL(lustre_msg_check_version);
/* early reply size */
int lustre_msg_early_size()
return -EINVAL;
}
}
+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. */
return 0;
}
}
+EXPORT_SYMBOL(lustre_packed_msg_size);
void lustre_init_msg_v2(struct lustre_msg_v2 *msg, int count, __u32 *lens,
char **bufs)
return -EINVAL;
}
}
+EXPORT_SYMBOL(lustre_pack_request);
#if RS_DEBUG
CFS_LIST_HEAD(ptlrpc_rs_debug_lru);
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)
{
return lustre_pack_reply_flags(req, count, lens, bufs, 0);
}
+EXPORT_SYMBOL(lustre_pack_reply);
void *lustre_msg_buf_v2(struct lustre_msg_v2 *m, int n, int min_size)
{
return NULL;
}
}
+EXPORT_SYMBOL(lustre_msg_buf);
int lustre_shrink_msg_v2(struct lustre_msg_v2 *msg, int segment,
unsigned int newlen, int move_data)
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
+EXPORT_SYMBOL(lustre_shrink_msg);
void lustre_free_reply_state(struct ptlrpc_reply_state *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)
{
}
return rc;
}
+EXPORT_SYMBOL(ptlrpc_unpack_req_msg);
int ptlrpc_unpack_rep_msg(struct ptlrpc_request *req, int len)
{
}
return rc;
}
+EXPORT_SYMBOL(ptlrpc_unpack_rep_msg);
static inline int lustre_unpack_ptlrpc_body_v2(struct ptlrpc_request *req,
const int inout, int offset)
return str;
}
+EXPORT_SYMBOL(lustre_msg_string);
/* Wrap up the normal fixed length cases */
static inline void *__lustre_swab_buf(struct lustre_msg *msg, int index,
return 0;
}
}
+EXPORT_SYMBOL(lustre_msg_get_flags);
void lustre_msg_add_flags(struct lustre_msg *msg, int flags)
{
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
+EXPORT_SYMBOL(lustre_msg_add_flags);
void lustre_msg_set_flags(struct lustre_msg *msg, int flags)
{
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, int flags)
{
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
+EXPORT_SYMBOL(lustre_msg_clear_flags);
__u32 lustre_msg_get_op_flags(struct lustre_msg *msg)
{
return 0;
}
}
+EXPORT_SYMBOL(lustre_msg_get_op_flags);
void lustre_msg_add_op_flags(struct lustre_msg *msg, int flags)
{
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
+EXPORT_SYMBOL(lustre_msg_add_op_flags);
void lustre_msg_set_op_flags(struct lustre_msg *msg, int flags)
{
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)
{
return NULL;
}
}
+EXPORT_SYMBOL(lustre_msg_get_handle);
__u32 lustre_msg_get_type(struct lustre_msg *msg)
{
return PTL_RPC_MSG_ERR;
}
}
+EXPORT_SYMBOL(lustre_msg_get_type);
__u32 lustre_msg_get_version(struct lustre_msg *msg)
{
return 0;
}
}
+EXPORT_SYMBOL(lustre_msg_get_version);
void lustre_msg_add_version(struct lustre_msg *msg, int version)
{
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)
{
return 0;
}
}
+EXPORT_SYMBOL(lustre_msg_get_opc);
__u64 lustre_msg_get_last_xid(struct lustre_msg *msg)
{
return 0;
}
}
+EXPORT_SYMBOL(lustre_msg_get_last_xid);
__u64 lustre_msg_get_last_committed(struct lustre_msg *msg)
{
return 0;
}
}
+EXPORT_SYMBOL(lustre_msg_get_last_committed);
__u64 *lustre_msg_get_versions(struct lustre_msg *msg)
{
return NULL;
}
}
+EXPORT_SYMBOL(lustre_msg_get_versions);
__u64 lustre_msg_get_transno(struct lustre_msg *msg)
{
return 0;
}
}
+EXPORT_SYMBOL(lustre_msg_get_transno);
int lustre_msg_get_status(struct lustre_msg *msg)
{
return -EINVAL;
}
}
+EXPORT_SYMBOL(lustre_msg_get_status);
__u64 lustre_msg_get_slv(struct lustre_msg *msg)
{
return -EINVAL;
}
}
+EXPORT_SYMBOL(lustre_msg_get_slv);
void lustre_msg_set_slv(struct lustre_msg *msg, __u64 slv)
return;
}
}
+EXPORT_SYMBOL(lustre_msg_set_slv);
__u32 lustre_msg_get_limit(struct lustre_msg *msg)
{
return -EINVAL;
}
}
+EXPORT_SYMBOL(lustre_msg_get_limit);
void lustre_msg_set_limit(struct lustre_msg *msg, __u64 limit)
return;
}
}
+EXPORT_SYMBOL(lustre_msg_set_limit);
__u32 lustre_msg_get_conn_cnt(struct lustre_msg *msg)
{
return 0;
}
}
+EXPORT_SYMBOL(lustre_msg_get_conn_cnt);
int lustre_msg_is_v1(struct lustre_msg *msg)
{
return 0;
}
}
+EXPORT_SYMBOL(lustre_msg_is_v1);
__u32 lustre_msg_get_magic(struct lustre_msg *msg)
{
return 0;
}
}
+EXPORT_SYMBOL(lustre_msg_get_magic);
__u32 lustre_msg_get_timeout(struct lustre_msg *msg)
{
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)
{
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)
{
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)
{
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)
{
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)
{
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
+EXPORT_SYMBOL(lustre_msg_set_versions);
void lustre_msg_set_transno(struct lustre_msg *msg, __u64 transno)
{
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
+EXPORT_SYMBOL(lustre_msg_set_transno);
void lustre_msg_set_status(struct lustre_msg *msg, __u32 status)
{
LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
}
}
+EXPORT_SYMBOL(lustre_msg_set_status);
void lustre_msg_set_conn_cnt(struct lustre_msg *msg, __u32 conn_cnt)
{
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)
{
if (req->rq_reqmsg->lm_magic == LUSTRE_MSG_MAGIC_V2)
req->rq_reqmsg->lm_repsize = req->rq_replen;
}
+EXPORT_SYMBOL(ptlrpc_request_set_replen);
void ptlrpc_req_set_repsize(struct ptlrpc_request *req, int count, __u32 *lens)
{
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.
* 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)
{
CLASSERT(offsetof(typeof(*o), o_padding_6) != 0);
}
+EXPORT_SYMBOL(lustre_swab_obdo);
void lustre_swab_obd_statfs (struct obd_statfs *os)
{
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)
{
__swab32s (&ioo->ioo_type);
__swab32s (&ioo->ioo_bufcnt);
}
+EXPORT_SYMBOL(lustre_swab_obd_ioobj);
void lustre_swab_niobuf_remote (struct niobuf_remote *nbr)
{
__swab32s (&nbr->len);
__swab32s (&nbr->flags);
}
+EXPORT_SYMBOL(lustre_swab_niobuf_remote);
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(obd_id *id)
{
__swab64s(id);
}
+EXPORT_SYMBOL(lustre_swab_ost_last_id);
void lustre_swab_generic_32s(__u32 *val)
{
__swab32s(val);
}
+EXPORT_SYMBOL(lustre_swab_generic_32s);
void lustre_swab_lvb(union ldlm_wire_lvb *lvb)
{
__swab64s(&lvb->l_ost.lvb_ctime);
__swab64s(&lvb->l_ost.lvb_blocks);
}
+EXPORT_SYMBOL(lustre_swab_lvb);
void lustre_swab_mdt_body (struct mdt_body *b)
{
__swab32s (&b->gid_h);
CLASSERT(offsetof(typeof(*b), padding_5) != 0);
}
+EXPORT_SYMBOL(lustre_swab_mdt_body);
void lustre_swab_mdt_ioepoch (struct mdt_ioepoch *b)
{
__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)
{
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)
{
lustre_swab_obd_dqinfo (&q->qc_dqinfo);
lustre_swab_obd_dqblk (&q->qc_dqblk);
}
+EXPORT_SYMBOL(lustre_swab_obd_quotactl);
void lustre_swab_quota_adjust_qunit (struct quota_adjust_qunit *q)
{
__swab64s (&q->qaq_iunit_sz);
__swab64s (&q->padding1);
}
+EXPORT_SYMBOL(lustre_swab_quota_adjust_qunit);
void lustre_swab_mdt_remote_perm (struct mdt_remote_perm *p)
{
__swab32s (&p->rp_access_perm);
__swab32s (&p->rp_padding);
};
+EXPORT_SYMBOL(lustre_swab_mdt_remote_perm);
void lustre_swab_fid2path(struct getinfo_fid2path *gf)
{
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_mdt_rec_reint (struct mdt_rec_reint *rr)
{
CLASSERT(offsetof(typeof(*rr), rr_padding_3) != 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)
{
__swab32s (&ld->ld_qos_maxage);
/* uuid endian insensitive */
}
+EXPORT_SYMBOL(lustre_swab_lov_desc);
void lustre_swab_lmv_desc (struct lmv_desc *ld)
{
lustre_swab_lov_user_md_common(lum);
EXIT;
}
+EXPORT_SYMBOL(lustre_swab_lov_user_md_v1);
void lustre_swab_lov_user_md_v3(struct lov_user_md_v3 *lum)
{
/* lmm_pool_name nothing to do with char */
EXIT;
}
+EXPORT_SYMBOL(lustre_swab_lov_user_md_v3);
void lustre_swab_lov_mds_md(struct lov_mds_md *lmm)
{
__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)
}
EXIT;
}
-
+EXPORT_SYMBOL(lustre_swab_lov_user_md_objects);
void lustre_swab_ldlm_res_id (struct ldlm_res_id *id)
{
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)
{
__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);
}
+EXPORT_SYMBOL(lustre_swab_ldlm_intent);
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);
}
+EXPORT_SYMBOL(lustre_swab_ldlm_resource_desc);
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);
}
+EXPORT_SYMBOL(lustre_swab_ldlm_lock_desc);
void lustre_swab_ldlm_request (struct ldlm_request *rq)
{
__swab32s (&rq->lock_count);
/* lock_handle[] opaque */
}
+EXPORT_SYMBOL(lustre_swab_ldlm_request);
void lustre_swab_ldlm_reply (struct ldlm_reply *r)
{
__swab64s (&r->lock_policy_res1);
__swab64s (&r->lock_policy_res2);
}
+EXPORT_SYMBOL(lustre_swab_ldlm_reply);
/* no one calls this */
int llog_log_swabbed(struct llog_log_hdr *hdr)
__swab64s (&d->qd_qunit);
CLASSERT(offsetof(typeof(*d), padding) != 0);
}
+EXPORT_SYMBOL(lustre_swab_qdata);
/* Dump functions */
void dump_ioo(struct obd_ioobj *ioo)
"ioo_bufct=%d\n", ioo->ioo_id, ioo->ioo_seq, ioo->ioo_type,
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->offset, nb->len, nb->flags);
}
+EXPORT_SYMBOL(dump_rniobuf);
void dump_obdo(struct obdo *oa)
{
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);
}
+EXPORT_SYMBOL(dump_ost_body);
void dump_rcs(__u32 *rc)
{
CDEBUG(D_RPCTRACE, "rmf_rcs: %d\n", *rc);
}
+EXPORT_SYMBOL(dump_rcs);
#ifdef __KERNEL__
__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)
{
__swab32s (&k->lk_keyid);
CLASSERT(offsetof(typeof(*k), lk_padding) != 0);
}
+EXPORT_SYMBOL(lustre_swab_lustre_capa_key);
void lustre_swab_hsm_state(struct hsm_state_set_ioc *hssi)
{
{
ptlrpc_update_next_ping(imp, 0);
}
+EXPORT_SYMBOL(ptlrpc_pinger_sending_on_import);
void ptlrpc_pinger_commit_expected(struct obd_import *imp)
{
RETURN(0);
}
+EXPORT_SYMBOL(ptlrpc_pinger_add_import);
int ptlrpc_pinger_del_import(struct obd_import *imp)
{
cfs_mutex_unlock(&pinger_mutex);
RETURN(0);
}
+EXPORT_SYMBOL(ptlrpc_pinger_del_import);
/**
* Register a timeout callback to the pinger list, and the callback will
cfs_mutex_unlock(&pinger_mutex);
return 0;
}
+EXPORT_SYMBOL(ptlrpc_add_timeout_client);
int ptlrpc_del_timeout_client(cfs_list_t *obd_list,
enum timeout_event event)
cfs_mutex_unlock(&pinger_mutex);
return 0;
}
+EXPORT_SYMBOL(ptlrpc_del_timeout_client);
int ptlrpc_pinger_remove_timeouts(void)
{
ptlrpc_connection_fini();
}
-/* connection.c */
-EXPORT_SYMBOL(ptlrpc_connection_get);
-EXPORT_SYMBOL(ptlrpc_connection_put);
-EXPORT_SYMBOL(ptlrpc_connection_addref);
-EXPORT_SYMBOL(ptlrpc_connection_init);
-EXPORT_SYMBOL(ptlrpc_connection_fini);
-
-/* niobuf.c */
-#ifdef HAVE_SERVER_SUPPORT
-EXPORT_SYMBOL(ptlrpc_prep_bulk_exp);
-EXPORT_SYMBOL(ptlrpc_start_bulk_transfer);
-EXPORT_SYMBOL(ptlrpc_abort_bulk);
-#endif
-EXPORT_SYMBOL(ptlrpc_register_bulk);
-EXPORT_SYMBOL(ptlrpc_unregister_bulk);
-EXPORT_SYMBOL(ptlrpc_send_reply);
-EXPORT_SYMBOL(ptlrpc_reply);
-EXPORT_SYMBOL(ptlrpc_send_error);
-EXPORT_SYMBOL(ptlrpc_error);
-EXPORT_SYMBOL(ptlrpc_resend_req);
-EXPORT_SYMBOL(ptl_send_rpc);
-
-/* client.c */
-EXPORT_SYMBOL(ptlrpc_init_client);
-EXPORT_SYMBOL(ptlrpc_cleanup_client);
-EXPORT_SYMBOL(ptlrpc_uuid_to_connection);
-EXPORT_SYMBOL(ptlrpc_queue_wait);
-EXPORT_SYMBOL(ptlrpc_replay_req);
-EXPORT_SYMBOL(ptlrpc_restart_req);
-EXPORT_SYMBOL(ptlrpc_add_rqs_to_pool);
-EXPORT_SYMBOL(ptlrpc_init_rq_pool);
-EXPORT_SYMBOL(ptlrpc_free_rq_pool);
-EXPORT_SYMBOL(ptlrpc_prep_req_pool);
-EXPORT_SYMBOL(ptlrpc_prep_fakereq);
-EXPORT_SYMBOL(ptlrpc_fakereq_finished);
-EXPORT_SYMBOL(ptlrpc_at_set_req_timeout);
-EXPORT_SYMBOL(ptlrpc_request_alloc);
-EXPORT_SYMBOL(ptlrpc_request_alloc_pool);
-EXPORT_SYMBOL(ptlrpc_request_free);
-EXPORT_SYMBOL(ptlrpc_request_pack);
-EXPORT_SYMBOL(ptlrpc_request_alloc_pack);
-EXPORT_SYMBOL(ptlrpc_prep_req);
-EXPORT_SYMBOL(ptlrpc_unregister_reply);
-EXPORT_SYMBOL(ptlrpc_req_finished);
-EXPORT_SYMBOL(ptlrpc_req_finished_with_imp_lock);
-EXPORT_SYMBOL(ptlrpc_request_addref);
-EXPORT_SYMBOL(ptlrpc_prep_bulk_imp);
-EXPORT_SYMBOL(ptlrpc_free_bulk);
-EXPORT_SYMBOL(ptlrpc_prep_bulk_page);
-EXPORT_SYMBOL(ptlrpc_abort_inflight);
-EXPORT_SYMBOL(ptlrpc_cleanup_imp);
-EXPORT_SYMBOL(ptlrpc_retain_replayable_request);
-EXPORT_SYMBOL(ptlrpc_next_xid);
-EXPORT_SYMBOL(ptlrpc_req_set_repsize);
-EXPORT_SYMBOL(ptlrpc_request_set_replen);
-
-EXPORT_SYMBOL(ptlrpc_prep_set);
-EXPORT_SYMBOL(ptlrpc_set_add_cb);
-EXPORT_SYMBOL(ptlrpc_set_add_req);
-EXPORT_SYMBOL(ptlrpc_set_add_new_req);
-EXPORT_SYMBOL(ptlrpc_set_destroy);
-EXPORT_SYMBOL(ptlrpc_set_next_timeout);
-EXPORT_SYMBOL(ptlrpc_check_set);
-EXPORT_SYMBOL(ptlrpc_set_wait);
-EXPORT_SYMBOL(ptlrpc_expired_set);
-EXPORT_SYMBOL(ptlrpc_interrupted_set);
-EXPORT_SYMBOL(ptlrpc_mark_interrupted);
-
-/* service.c */
-EXPORT_SYMBOL(ptlrpc_save_lock);
-EXPORT_SYMBOL(ptlrpc_schedule_difficult_reply);
-EXPORT_SYMBOL(ptlrpc_commit_replies);
-EXPORT_SYMBOL(ptlrpc_register_service);
-EXPORT_SYMBOL(ptlrpc_stop_all_threads);
-EXPORT_SYMBOL(ptlrpc_start_threads);
-EXPORT_SYMBOL(ptlrpc_unregister_service);
-EXPORT_SYMBOL(ptlrpc_service_health_check);
-EXPORT_SYMBOL(ptlrpc_hpreq_reorder);
-
-/* pack_generic.c */
-EXPORT_SYMBOL(lustre_msg_check_version);
-EXPORT_SYMBOL(lustre_pack_request);
-EXPORT_SYMBOL(lustre_pack_reply);
-EXPORT_SYMBOL(lustre_pack_reply_flags);
-EXPORT_SYMBOL(lustre_shrink_msg);
-EXPORT_SYMBOL(lustre_free_reply_state);
-EXPORT_SYMBOL(lustre_msg_size);
-EXPORT_SYMBOL(lustre_packed_msg_size);
-EXPORT_SYMBOL(ptlrpc_unpack_rep_msg);
-EXPORT_SYMBOL(ptlrpc_unpack_req_msg);
-EXPORT_SYMBOL(lustre_msg_buf);
-EXPORT_SYMBOL(lustre_msg_string);
-EXPORT_SYMBOL(ptlrpc_buf_set_swabbed);
-EXPORT_SYMBOL(ptlrpc_buf_need_swab);
-EXPORT_SYMBOL(lustre_swab_ptlrpc_body);
-EXPORT_SYMBOL(lustre_swab_obdo);
-EXPORT_SYMBOL(lustre_swab_obd_statfs);
-EXPORT_SYMBOL(lustre_swab_obd_ioobj);
-EXPORT_SYMBOL(lustre_swab_niobuf_remote);
-EXPORT_SYMBOL(lustre_swab_ost_body);
-EXPORT_SYMBOL(lustre_swab_ost_last_id);
-EXPORT_SYMBOL(lustre_swab_lvb);
-EXPORT_SYMBOL(lustre_swab_mdt_body);
-EXPORT_SYMBOL(lustre_swab_mdt_ioepoch);
-EXPORT_SYMBOL(lustre_swab_obd_quotactl);
-EXPORT_SYMBOL(lustre_swab_mdt_remote_perm);
-EXPORT_SYMBOL(lustre_swab_mdt_rec_reint);
-EXPORT_SYMBOL(lustre_swab_lov_desc);
-EXPORT_SYMBOL(lustre_swab_lov_user_md_v1);
-EXPORT_SYMBOL(lustre_swab_lov_user_md_v3);
-EXPORT_SYMBOL(lustre_swab_lov_user_md_objects);
-EXPORT_SYMBOL(lustre_swab_lov_mds_md);
-EXPORT_SYMBOL(lustre_swab_ldlm_res_id);
-EXPORT_SYMBOL(lustre_swab_ldlm_policy_data);
-EXPORT_SYMBOL(lustre_swab_ldlm_intent);
-EXPORT_SYMBOL(lustre_swab_ldlm_resource_desc);
-EXPORT_SYMBOL(lustre_swab_ldlm_lock_desc);
-EXPORT_SYMBOL(lustre_swab_ldlm_request);
-EXPORT_SYMBOL(lustre_swab_ldlm_reply);
-EXPORT_SYMBOL(dump_ioo);
-EXPORT_SYMBOL(dump_rniobuf);
-EXPORT_SYMBOL(dump_obdo);
-EXPORT_SYMBOL(dump_ost_body);
-EXPORT_SYMBOL(dump_rcs);
-EXPORT_SYMBOL(lustre_swab_qdata);
-EXPORT_SYMBOL(lustre_swab_quota_adjust_qunit);
-EXPORT_SYMBOL(lustre_msg_get_flags);
-EXPORT_SYMBOL(lustre_msg_add_flags);
-EXPORT_SYMBOL(lustre_msg_set_flags);
-EXPORT_SYMBOL(lustre_msg_clear_flags);
-EXPORT_SYMBOL(lustre_msg_get_op_flags);
-EXPORT_SYMBOL(lustre_msg_add_op_flags);
-EXPORT_SYMBOL(lustre_msg_set_op_flags);
-EXPORT_SYMBOL(lustre_msg_get_handle );
-EXPORT_SYMBOL(lustre_msg_get_type);
-EXPORT_SYMBOL(lustre_msg_get_version);
-EXPORT_SYMBOL(lustre_msg_add_version);
-EXPORT_SYMBOL(lustre_msg_get_opc);
-EXPORT_SYMBOL(lustre_msg_get_last_xid);
-EXPORT_SYMBOL(lustre_msg_get_last_committed);
-EXPORT_SYMBOL(lustre_msg_get_versions);
-EXPORT_SYMBOL(lustre_msg_get_transno);
-EXPORT_SYMBOL(lustre_msg_get_status);
-EXPORT_SYMBOL(lustre_msg_get_slv);
-EXPORT_SYMBOL(lustre_msg_get_limit);
-EXPORT_SYMBOL(lustre_msg_set_slv);
-EXPORT_SYMBOL(lustre_msg_set_limit);
-EXPORT_SYMBOL(lustre_msg_get_conn_cnt);
-EXPORT_SYMBOL(lustre_msg_is_v1);
-EXPORT_SYMBOL(lustre_msg_get_magic);
-EXPORT_SYMBOL(lustre_msg_set_handle);
-EXPORT_SYMBOL(lustre_msg_set_type);
-EXPORT_SYMBOL(lustre_msg_set_opc);
-EXPORT_SYMBOL(lustre_msg_set_last_xid);
-EXPORT_SYMBOL(lustre_msg_set_last_committed);
-EXPORT_SYMBOL(lustre_msg_set_versions);
-EXPORT_SYMBOL(lustre_msg_set_transno);
-EXPORT_SYMBOL(lustre_msg_set_status);
-EXPORT_SYMBOL(lustre_msg_set_conn_cnt);
-EXPORT_SYMBOL(lustre_swab_mgs_target_info);
-EXPORT_SYMBOL(lustre_swab_generic_32s);
-EXPORT_SYMBOL(lustre_swab_lustre_capa);
-EXPORT_SYMBOL(lustre_swab_lustre_capa_key);
-EXPORT_SYMBOL(lustre_swab_fiemap);
-
-/* recover.c */
-EXPORT_SYMBOL(ptlrpc_disconnect_import);
-EXPORT_SYMBOL(ptlrpc_resend);
-EXPORT_SYMBOL(ptlrpc_wake_delayed);
-EXPORT_SYMBOL(ptlrpc_set_import_active);
-EXPORT_SYMBOL(ptlrpc_activate_import);
-EXPORT_SYMBOL(ptlrpc_deactivate_import);
-EXPORT_SYMBOL(ptlrpc_invalidate_import);
-EXPORT_SYMBOL(ptlrpc_fail_import);
-EXPORT_SYMBOL(ptlrpc_recover_import);
-
-/* pinger.c */
-EXPORT_SYMBOL(ptlrpc_pinger_add_import);
-EXPORT_SYMBOL(ptlrpc_pinger_del_import);
-EXPORT_SYMBOL(ptlrpc_add_timeout_client);
-EXPORT_SYMBOL(ptlrpc_del_timeout_client);
-EXPORT_SYMBOL(ptlrpc_pinger_sending_on_import);
-
-/* ptlrpcd.c */
-EXPORT_SYMBOL(ptlrpcd_addref);
-EXPORT_SYMBOL(ptlrpcd_decref);
-EXPORT_SYMBOL(ptlrpcd_add_req);
-EXPORT_SYMBOL(ptlrpcd_wake);
-
-/* llogd.c */
-EXPORT_SYMBOL(llog_origin_handle_create);
-EXPORT_SYMBOL(llog_origin_handle_destroy);
-EXPORT_SYMBOL(llog_origin_handle_next_block);
-EXPORT_SYMBOL(llog_origin_handle_prev_block);
-EXPORT_SYMBOL(llog_origin_handle_read_header);
-EXPORT_SYMBOL(llog_origin_handle_close);
-EXPORT_SYMBOL(llog_client_ops);
-
MODULE_AUTHOR("Sun Microsystems, Inc. <http://www.lustre.org/>");
MODULE_DESCRIPTION("Lustre Request Processor and Lock Management");
MODULE_LICENSE("GPL");
cfs_waitq_signal(&rq_set->set_waitq);
}
+EXPORT_SYMBOL(ptlrpcd_wake);
static struct ptlrpcd_ctl *
ptlrpcd_select_pc(struct ptlrpc_request *req, pdl_policy_t policy, int index)
ptlrpc_set_add_new_req(pc, req);
}
+EXPORT_SYMBOL(ptlrpcd_add_req);
static inline void ptlrpc_reqset_get(struct ptlrpc_request_set *set)
{
cfs_mutex_unlock(&ptlrpcd_mutex);
RETURN(rc);
}
+EXPORT_SYMBOL(ptlrpcd_addref);
void ptlrpcd_decref(void)
{
ptlrpcd_fini();
cfs_mutex_unlock(&ptlrpcd_mutex);
}
+EXPORT_SYMBOL(ptlrpcd_decref);
/** @} ptlrpcd */
RETURN(0);
}
+EXPORT_SYMBOL(ptlrpc_resend);
/**
* Go through all requests in delayed list and wake their threads
}
cfs_spin_unlock(&imp->imp_lock);
}
+EXPORT_SYMBOL(ptlrpc_wake_delayed);
void ptlrpc_request_handle_notconn(struct ptlrpc_request *failed_req)
{
RETURN(rc);
}
+EXPORT_SYMBOL(ptlrpc_set_import_active);
/* Attempt to reconnect an import */
int ptlrpc_recover_import(struct obd_import *imp, char *new_uuid, int async)
out:
return rc;
}
+EXPORT_SYMBOL(ptlrpc_recover_import);
int ptlrpc_import_in_recovery(struct obd_import *imp)
{
rs->rs_no_ack = !!no_ack;
}
}
+EXPORT_SYMBOL(ptlrpc_save_lock);
#ifdef __KERNEL__
ptlrpc_dispatch_difficult_reply(rs);
EXIT;
}
+EXPORT_SYMBOL(ptlrpc_schedule_difficult_reply);
void ptlrpc_commit_replies(struct obd_export *exp)
{
rs_batch_fini(&batch);
EXIT;
}
+EXPORT_SYMBOL(ptlrpc_commit_replies);
static int
ptlrpc_server_post_idle_rqbds(struct ptlrpc_service_part *svcpt)
ptlrpc_unregister_service(service);
RETURN(ERR_PTR(rc));
}
+EXPORT_SYMBOL(ptlrpc_register_service);
/**
* to actually free the request, must be called without holding svc_lock.
cfs_spin_unlock(&svcpt->scp_req_lock);
EXIT;
}
+EXPORT_SYMBOL(ptlrpc_hpreq_reorder);
/** Check if the request is a high priority one. */
static int ptlrpc_server_hpreq_check(struct ptlrpc_service *svc,
EXIT;
}
+EXPORT_SYMBOL(ptlrpc_stop_all_threads);
int ptlrpc_start_threads(struct ptlrpc_service *svc)
{
ptlrpc_stop_all_threads(svc);
RETURN(rc);
}
+EXPORT_SYMBOL(ptlrpc_start_threads);
int ptlrpc_start_thread(struct ptlrpc_service_part *svcpt, int wait)
{
RETURN(0);
}
+EXPORT_SYMBOL(ptlrpc_unregister_service);
/**
* Returns 0 if the service is healthy.
}
return 0;
}
+EXPORT_SYMBOL(ptlrpc_service_health_check);
git://git.whamcloud.com / fs / lustre-release.git / commitdiff