struct ptlrpc_request;
struct obd_export;
struct lu_target;
+struct l_wait_info;
#include <lustre_ha.h>
#include <lustre_net.h>
#include <lvfs.h>
+#ifdef HAVE_SERVER_SUPPORT
void target_client_add_cb(struct obd_device *obd, __u64 transno, void *cb_data,
int error);
int target_handle_connect(struct ptlrpc_request *req);
int target_handle_disconnect(struct ptlrpc_request *req);
void target_destroy_export(struct obd_export *exp);
-int target_pack_pool_reply(struct ptlrpc_request *req);
int target_handle_ping(struct ptlrpc_request *req);
void target_committed_to_req(struct ptlrpc_request *req);
+void target_cancel_recovery_timer(struct obd_device *obd);
+void target_stop_recovery_thread(struct obd_device *obd);
+void target_cleanup_recovery(struct obd_device *obd);
+int target_queue_recovery_request(struct ptlrpc_request *req,
+ struct obd_device *obd);
+int target_bulk_io(struct obd_export *exp, struct ptlrpc_bulk_desc *desc,
+ struct l_wait_info *lwi);
+#endif
+
+int target_pack_pool_reply(struct ptlrpc_request *req);
int do_set_info_async(struct obd_import *imp,
int opcode, int version,
obd_count keylen, void *key,
#define OBD_RECOVERY_MAX_TIME (obd_timeout * 18) /* b13079 */
-struct l_wait_info;
-
-void target_cancel_recovery_timer(struct obd_device *obd);
-void target_stop_recovery_thread(struct obd_device *obd);
-void target_cleanup_recovery(struct obd_device *obd);
-int target_queue_recovery_request(struct ptlrpc_request *req,
- struct obd_device *obd);
void target_send_reply(struct ptlrpc_request *req, int rc, int fail_id);
-int target_bulk_io(struct obd_export *exp, struct ptlrpc_bulk_desc *desc,
- struct l_wait_info *lwi);
/* client.c */
* underlying buffer
* @{
*/
-extern void request_out_callback (lnet_event_t *ev);
+extern void request_out_callback(lnet_event_t *ev);
extern void reply_in_callback(lnet_event_t *ev);
-extern void client_bulk_callback (lnet_event_t *ev);
+extern void client_bulk_callback(lnet_event_t *ev);
extern void request_in_callback(lnet_event_t *ev);
extern void reply_out_callback(lnet_event_t *ev);
-extern void server_bulk_callback (lnet_event_t *ev);
+#ifdef HAVE_SERVER_SUPPORT
+extern void server_bulk_callback(lnet_event_t *ev);
+#endif
/** @} */
/* ptlrpc/connection.c */
* Actual interfacing with LNet to put/get/register/unregister stuff
* @{
*/
+#ifdef HAVE_SERVER_SUPPORT
+struct ptlrpc_bulk_desc *ptlrpc_prep_bulk_exp(struct ptlrpc_request *req,
+ int npages, int type, int portal);
int ptlrpc_start_bulk_transfer(struct ptlrpc_bulk_desc *desc);
void ptlrpc_abort_bulk(struct ptlrpc_bulk_desc *desc);
-int ptlrpc_register_bulk(struct ptlrpc_request *req);
-int ptlrpc_unregister_bulk(struct ptlrpc_request *req, int async);
static inline int ptlrpc_server_bulk_active(struct ptlrpc_bulk_desc *desc)
{
cfs_spin_unlock(&desc->bd_lock);
return rc;
}
+#endif
+
+int ptlrpc_register_bulk(struct ptlrpc_request *req);
+int ptlrpc_unregister_bulk(struct ptlrpc_request *req, int async);
static inline int ptlrpc_client_bulk_active(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_register_rqbd(struct ptlrpc_request_buffer_desc *rqbd);
/** @} */
/* ptlrpc/client.c */
void ptlrpc_req_finished(struct ptlrpc_request *request);
void ptlrpc_req_finished_with_imp_lock(struct ptlrpc_request *request);
struct ptlrpc_request *ptlrpc_request_addref(struct ptlrpc_request *req);
-struct ptlrpc_bulk_desc *ptlrpc_prep_bulk_imp (struct ptlrpc_request *req,
- int npages, int type, int portal);
-struct ptlrpc_bulk_desc *ptlrpc_prep_bulk_exp(struct ptlrpc_request *req,
+struct ptlrpc_bulk_desc *ptlrpc_prep_bulk_imp(struct ptlrpc_request *req,
int npages, int type, int portal);
void ptlrpc_free_bulk(struct ptlrpc_bulk_desc *bulk);
void ptlrpc_prep_bulk_page(struct ptlrpc_bulk_desc *desc,
*
* @{
*/
-void ptlrpc_save_lock (struct ptlrpc_request *req,
- struct lustre_handle *lock, int mode, int no_ack);
+void ptlrpc_save_lock(struct ptlrpc_request *req,
+ struct lustre_handle *lock, int mode, int no_ack);
void ptlrpc_commit_replies(struct obd_export *exp);
-void ptlrpc_dispatch_difficult_reply (struct ptlrpc_reply_state *rs);
-void ptlrpc_schedule_difficult_reply (struct ptlrpc_reply_state *rs);
+void ptlrpc_dispatch_difficult_reply(struct ptlrpc_reply_state *rs);
+void ptlrpc_schedule_difficult_reply(struct ptlrpc_reply_state *rs);
struct ptlrpc_service *ptlrpc_init_svc_conf(struct ptlrpc_service_conf *c,
svc_handler_t h, char *name,
struct proc_dir_entry *proc_entry,
int ptlrpc_start_threads(struct ptlrpc_service *svc);
int ptlrpc_start_thread(struct ptlrpc_service *svc);
int ptlrpc_unregister_service(struct ptlrpc_service *service);
-int liblustre_check_services (void *arg);
+int liblustre_check_services(void *arg);
void ptlrpc_daemonize(char *name);
int ptlrpc_service_health_check(struct ptlrpc_service *);
void ptlrpc_hpreq_reorder(struct ptlrpc_request *req);
int lustre_msg_buflen(struct lustre_msg *m, int n);
void lustre_msg_set_buflen(struct lustre_msg *m, int n, int len);
int lustre_msg_bufcount(struct lustre_msg *m);
-char *lustre_msg_string (struct lustre_msg *m, int n, int max_len);
+char *lustre_msg_string(struct lustre_msg *m, int n, int max_len);
__u32 lustre_msghdr_get_flags(struct lustre_msg *msg);
void lustre_msghdr_set_flags(struct lustre_msg *msg, __u32 flags);
__u32 lustre_msg_get_flags(struct lustre_msg *msg);
void client_destroy_import(struct obd_import *imp);
/** @} */
+#ifdef HAVE_SERVER_SUPPORT
int server_disconnect_export(struct obd_export *exp);
+#endif
/* ptlrpc/pinger.c */
/**
int nob);
int sptlrpc_cli_unwrap_bulk_write(struct ptlrpc_request *req,
struct ptlrpc_bulk_desc *desc);
+#ifdef HAVE_SERVER_SUPPORT
int sptlrpc_svc_prep_bulk(struct ptlrpc_request *req,
struct ptlrpc_bulk_desc *desc);
int sptlrpc_svc_wrap_bulk(struct ptlrpc_request *req,
struct ptlrpc_bulk_desc *desc);
int sptlrpc_svc_unwrap_bulk(struct ptlrpc_request *req,
struct ptlrpc_bulk_desc *desc);
+#endif
/* bulk helpers (internal use only by policies) */
int sptlrpc_get_bulk_checksum(struct ptlrpc_bulk_desc *desc, __u8 alg,
RETURN(rc);
}
+#ifdef HAVE_SERVER_SUPPORT
int server_disconnect_export(struct obd_export *exp)
{
int rc;
}
EXPORT_SYMBOL(target_recovery_init);
-#endif
+#endif /* __KERNEL__ */
static int target_process_req_flags(struct obd_device *obd,
struct ptlrpc_request *req)
RETURN(0);
}
+int target_handle_ping(struct ptlrpc_request *req)
+{
+ obd_ping(req->rq_export);
+ return req_capsule_server_pack(&req->rq_pill);
+}
+
+void target_committed_to_req(struct ptlrpc_request *req)
+{
+ struct obd_export *exp = req->rq_export;
+
+ if (!exp->exp_obd->obd_no_transno && req->rq_repmsg != NULL)
+ lustre_msg_set_last_committed(req->rq_repmsg,
+ exp->exp_last_committed);
+ else
+ DEBUG_REQ(D_IOCTL, req, "not sending last_committed update (%d/"
+ "%d)", exp->exp_obd->obd_no_transno,
+ req->rq_repmsg == NULL);
+
+ CDEBUG(D_INFO, "last_committed "LPU64", transno "LPU64", xid "LPU64"\n",
+ exp->exp_last_committed, req->rq_transno, req->rq_xid);
+}
+EXPORT_SYMBOL(target_committed_to_req);
+
+#endif /* HAVE_SERVER_SUPPORT */
+
/**
* Packs current SLV and Limit into \a req.
*/
EXIT;
}
-int target_handle_ping(struct ptlrpc_request *req)
-{
- obd_ping(req->rq_export);
- return req_capsule_server_pack(&req->rq_pill);
-}
-
-void target_committed_to_req(struct ptlrpc_request *req)
-{
- struct obd_export *exp = req->rq_export;
-
- if (!exp->exp_obd->obd_no_transno && req->rq_repmsg != NULL)
- lustre_msg_set_last_committed(req->rq_repmsg,
- exp->exp_last_committed);
- else
- DEBUG_REQ(D_IOCTL, req, "not sending last_committed update (%d/"
- "%d)", exp->exp_obd->obd_no_transno,
- req->rq_repmsg == NULL);
-
- CDEBUG(D_INFO, "last_committed "LPU64", transno "LPU64", xid "LPU64"\n",
- exp->exp_last_committed, req->rq_transno, req->rq_xid);
-}
-EXPORT_SYMBOL(target_committed_to_req);
-
int target_handle_qc_callback(struct ptlrpc_request *req)
{
struct obd_quotactl *oqctl;
}
#endif
+#ifdef HAVE_SERVER_SUPPORT
static int target_bulk_timeout(void *data)
{
ENTRY;
RETURN(rc);
}
EXPORT_SYMBOL(target_bulk_io);
+
+#endif /* HAVE_SERVER_SUPPORT */
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_send_reply);
EXPORT_SYMBOL(target_queue_recovery_request);
EXPORT_SYMBOL(target_handle_ping);
-EXPORT_SYMBOL(target_pack_pool_reply);
EXPORT_SYMBOL(target_handle_disconnect);
+#endif
/* l_lock.c */
EXPORT_SYMBOL(lock_res_and_lock);
MODULES := obdecho
-obdecho-objs := echo.o echo_client.o lproc_echo.o
+obdecho-objs := echo_client.o lproc_echo.o
+@SERVER_TRUE@obdecho-objs += echo.o
EXTRA_DIST = $(obdecho-objs:%.o=%.c) echo_internal.h
macos_PROGRAMS := obdecho
obdecho_SOURCES := \
lproc_echo.c \
- echo.c \
echo_client.c
+if SERVER
+obdecho_SOURCES += echo.c
+endif
+
obdecho_CFLAGS := $(EXTRA_KCFLAGS)
obdecho_LDFLAGS := $(EXTRA_KLDFLAGS)
obdecho_LDADD := $(EXTRA_KLIBS)
return id;
}
-int echo_create(struct obd_export *exp, struct obdo *oa,
- struct lov_stripe_md **ea, struct obd_trans_info *oti)
+static int echo_create(struct obd_export *exp, struct obdo *oa,
+ struct lov_stripe_md **ea, struct obd_trans_info *oti)
{
struct obd_device *obd = class_exp2obd(exp);
return 0;
}
-int echo_destroy(struct obd_export *exp, struct obdo *oa,
- struct lov_stripe_md *ea, struct obd_trans_info *oti,
- struct obd_export *md_exp, void *capa)
+static int echo_destroy(struct obd_export *exp, struct obdo *oa,
+ struct lov_stripe_md *ea, struct obd_trans_info *oti,
+ struct obd_export *md_exp, void *capa)
{
struct obd_device *obd = class_exp2obd(exp);
return rc;
}
-int echo_preprw(int cmd, struct obd_export *export, struct obdo *oa,
- int objcount, struct obd_ioobj *obj, struct niobuf_remote *nb,
- int *pages, struct niobuf_local *res,
- struct obd_trans_info *oti, struct lustre_capa *unused)
+static int echo_preprw(int cmd, struct obd_export *export, struct obdo *oa,
+ int objcount, struct obd_ioobj *obj,
+ struct niobuf_remote *nb, int *pages,
+ struct niobuf_local *res, struct obd_trans_info *oti,
+ struct lustre_capa *unused)
{
struct obd_device *obd;
int tot_bytes = 0;
return rc;
}
-int echo_commitrw(int cmd, struct obd_export *export, struct obdo *oa,
- int objcount, struct obd_ioobj *obj,
- struct niobuf_remote *rb, int niocount,
- struct niobuf_local *res, struct obd_trans_info *oti, int rc)
+static int echo_commitrw(int cmd, struct obd_export *export, struct obdo *oa,
+ int objcount, struct obd_ioobj *obj,
+ struct niobuf_remote *rb, int niocount,
+ struct niobuf_local *res, struct obd_trans_info *oti,
+ int rc)
{
struct obd_device *obd;
int pgs = 0;
RETURN(0);
}
-static struct obd_ops echo_obd_ops = {
+struct obd_ops echo_obd_ops = {
.o_owner = THIS_MODULE,
.o_connect = echo_connect,
.o_disconnect = echo_disconnect,
.o_cleanup = echo_cleanup
};
-extern int echo_client_init(void);
-extern void echo_client_exit(void);
-
-static void
-echo_persistent_pages_fini (void)
+void echo_persistent_pages_fini(void)
{
int i;
}
}
-static int
-echo_persistent_pages_init (void)
+int echo_persistent_pages_init(void)
{
cfs_page_t *pg;
int i;
return (0);
}
-
-static int __init obdecho_init(void)
-{
- struct lprocfs_static_vars lvars;
- int rc;
-
- ENTRY;
- LCONSOLE_INFO("Echo OBD driver; http://www.lustre.org/\n");
-
- LASSERT(CFS_PAGE_SIZE % OBD_ECHO_BLOCK_SIZE == 0);
-
- lprocfs_echo_init_vars(&lvars);
-
- rc = echo_persistent_pages_init ();
- if (rc != 0)
- goto failed_0;
-
- rc = class_register_type(&echo_obd_ops, NULL, lvars.module_vars,
- LUSTRE_ECHO_NAME, NULL);
- if (rc != 0)
- goto failed_1;
-
- rc = echo_client_init();
- if (rc == 0)
- RETURN (0);
-
- class_unregister_type(LUSTRE_ECHO_NAME);
- failed_1:
- echo_persistent_pages_fini ();
- failed_0:
- RETURN(rc);
-}
-
-static void /*__exit*/ obdecho_exit(void)
-{
- echo_client_exit();
- class_unregister_type(LUSTRE_ECHO_NAME);
- echo_persistent_pages_fini ();
-}
-
-MODULE_AUTHOR("Sun Microsystems, Inc. <http://www.lustre.org/>");
-MODULE_DESCRIPTION("Lustre Testing Echo OBD driver");
-MODULE_LICENSE("GPL");
-
-cfs_module(obdecho, "1.0.0", obdecho_init, obdecho_exit);
*
* @{
*/
-cfs_page_t *echo_page_vmpage(const struct lu_env *env,
- const struct cl_page_slice *slice)
+static cfs_page_t *echo_page_vmpage(const struct lu_env *env,
+ const struct cl_page_slice *slice)
{
return cl2echo_page(slice)->ep_vmpage;
}
RETURN(rc);
}
-struct lu_object *echo_resolve_path(const struct lu_env *env,
- struct echo_device *ed, char *path,
- int path_len)
+static struct lu_object *echo_resolve_path(const struct lu_env *env,
+ struct echo_device *ed, char *path,
+ int path_len)
{
struct lu_device *ld = ed->ed_next;
struct md_device *md = lu2md_dev(ld);
return rc;
}
-static struct obd_ops echo_obd_ops = {
+static struct obd_ops echo_client_obd_ops = {
.o_owner = THIS_MODULE,
#if 0
rc = lu_kmem_init(echo_caches);
if (rc == 0) {
- rc = class_register_type(&echo_obd_ops, NULL,
+ rc = class_register_type(&echo_client_obd_ops, NULL,
lvars.module_vars,
LUSTRE_ECHO_CLIENT_NAME,
&echo_device_type);
lu_kmem_fini(echo_caches);
}
+#ifdef __KERNEL__
+static int __init obdecho_init(void)
+{
+ struct lprocfs_static_vars lvars;
+ int rc;
+
+ ENTRY;
+ LCONSOLE_INFO("Echo OBD driver; http://www.lustre.org/\n");
+
+ LASSERT(CFS_PAGE_SIZE % OBD_ECHO_BLOCK_SIZE == 0);
+
+ lprocfs_echo_init_vars(&lvars);
+
+# ifdef HAVE_SERVER_SUPPORT
+ rc = echo_persistent_pages_init();
+ if (rc != 0)
+ goto failed_0;
+
+ rc = class_register_type(&echo_obd_ops, NULL, lvars.module_vars,
+ LUSTRE_ECHO_NAME, NULL);
+ if (rc != 0)
+ goto failed_1;
+# endif
+
+ rc = echo_client_init();
+
+# ifdef HAVE_SERVER_SUPPORT
+ if (rc == 0)
+ RETURN(0);
+
+ class_unregister_type(LUSTRE_ECHO_NAME);
+failed_1:
+ echo_persistent_pages_fini();
+failed_0:
+# endif
+ RETURN(rc);
+}
+
+static void /*__exit*/ obdecho_exit(void)
+{
+ echo_client_exit();
+
+# ifdef HAVE_SERVER_SUPPORT
+ class_unregister_type(LUSTRE_ECHO_NAME);
+ echo_persistent_pages_fini();
+# endif
+}
+
+MODULE_AUTHOR("Sun Microsystems, Inc. <http://www.lustre.org/>");
+MODULE_DESCRIPTION("Lustre Testing Echo OBD driver");
+MODULE_LICENSE("GPL");
+
+cfs_module(obdecho, LUSTRE_VERSION_STRING, obdecho_init, obdecho_exit);
+#endif /* __KERNEL__ */
+
/** @} echo_client */
/* block size to use for data verification */
#define OBD_ECHO_BLOCK_SIZE (4<<10)
-#ifndef __KERNEL__
+#ifdef __KERNEL__
+# ifdef HAVE_SERVER_SUPPORT
+extern struct obd_ops echo_obd_ops;
+int echo_persistent_pages_init(void);
+void echo_persistent_pages_fini(void);
+# endif
+#else /* ! __KERNEL__ */
/* Kludge here, define some functions and macros needed by liblustre -jay */
static inline void page_cache_get(struct page *page)
{
#define READ 0
#define WRITE 1
-#endif /* ifndef __KERNEL__ */
+#endif /* ifdef __KERNEL__ */
#endif
* Allocate and initialize new bulk descriptor
* Returns pointer to the descriptor or NULL on error.
*/
-static inline struct ptlrpc_bulk_desc *new_bulk(int npages, int type, int portal)
+struct ptlrpc_bulk_desc *new_bulk(int npages, int type, int portal)
{
struct ptlrpc_bulk_desc *desc;
}
/**
- * Prepare bulk descriptor for specified incoming request \a req that
- * can fit \a npages * pages. \a type is bulk type. \a portal is where
- * the bulk to be sent. Used on server-side after request was already
- * received.
- * Returns pointer to newly allocatrd initialized bulk descriptor or NULL on
- * error.
- */
-struct ptlrpc_bulk_desc *ptlrpc_prep_bulk_exp(struct ptlrpc_request *req,
- int npages, int type, int portal)
-{
- struct obd_export *exp = req->rq_export;
- struct ptlrpc_bulk_desc *desc;
-
- ENTRY;
- LASSERT(type == BULK_PUT_SOURCE || type == BULK_GET_SINK);
-
- desc = new_bulk(npages, type, portal);
- if (desc == NULL)
- RETURN(NULL);
-
- desc->bd_export = class_export_get(exp);
- desc->bd_req = req;
-
- desc->bd_cbid.cbid_fn = server_bulk_callback;
- desc->bd_cbid.cbid_arg = desc;
-
- /* NB we don't assign rq_bulk here; server-side requests are
- * re-used, and the handler frees the bulk desc explicitly. */
-
- return desc;
-}
-
-/**
* Add a page \a page to the bulk descriptor \a desc.
* Data to transfer in the page starts at offset \a pageoffset and
* amount of data to transfer from the page is \a len
EXIT;
}
+#ifdef HAVE_SERVER_SUPPORT
/*
* Server's bulk completion callback
*/
cfs_spin_unlock(&desc->bd_lock);
EXIT;
}
+#endif
static void ptlrpc_master_callback(lnet_event_t *ev)
{
callback == reply_in_callback ||
callback == client_bulk_callback ||
callback == request_in_callback ||
- callback == reply_out_callback ||
- callback == server_bulk_callback);
+ callback == reply_out_callback
+#ifdef HAVE_SERVER_SUPPORT
+ || callback == server_bulk_callback
+#endif
+ );
callback (ev);
}
#include <lustre_net.h>
#include <lustre_lib.h>
#include <obd.h>
+#include <obd_class.h>
#include "ptlrpc_internal.h"
/**
RETURN (0);
}
+#ifdef HAVE_SERVER_SUPPORT
+/**
+ * Prepare bulk descriptor for specified incoming request \a req that
+ * can fit \a npages * pages. \a type is bulk type. \a portal is where
+ * the bulk to be sent. Used on server-side after request was already
+ * received.
+ * Returns pointer to newly allocatrd initialized bulk descriptor or NULL on
+ * error.
+ */
+struct ptlrpc_bulk_desc *ptlrpc_prep_bulk_exp(struct ptlrpc_request *req,
+ int npages, int type, int portal)
+{
+ struct obd_export *exp = req->rq_export;
+ struct ptlrpc_bulk_desc *desc;
+
+ ENTRY;
+ LASSERT(type == BULK_PUT_SOURCE || type == BULK_GET_SINK);
+
+ desc = new_bulk(npages, type, portal);
+ if (desc == NULL)
+ RETURN(NULL);
+
+ desc->bd_export = class_export_get(exp);
+ desc->bd_req = req;
+
+ desc->bd_cbid.cbid_fn = server_bulk_callback;
+ desc->bd_cbid.cbid_arg = desc;
+
+ /* NB we don't assign rq_bulk here; server-side requests are
+ * re-used, and the handler frees the bulk desc explicitly. */
+
+ return desc;
+}
+
/**
* Starts bulk transfer for descriptor \a desc
* Returns 0 on success or error code.
CWARN("Unexpectedly long timeout: desc %p\n", desc);
}
}
+#endif /* HAVE_SERVER_SUPPORT */
/**
* Register bulk for later transfer
int ptlrpcd_start(int index, int max, const char *name, struct ptlrpcd_ctl *pc);
/* client.c */
+struct ptlrpc_bulk_desc *new_bulk(int npages, int type, int portal);
void ptlrpc_init_xid(void);
/* events.c */
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_req_finished_with_imp_lock);
EXPORT_SYMBOL(ptlrpc_request_addref);
EXPORT_SYMBOL(ptlrpc_prep_bulk_imp);
-EXPORT_SYMBOL(ptlrpc_prep_bulk_exp);
EXPORT_SYMBOL(ptlrpc_free_bulk);
EXPORT_SYMBOL(ptlrpc_prep_bulk_page);
EXPORT_SYMBOL(ptlrpc_abort_inflight);
}
EXPORT_SYMBOL(sptlrpc_cli_unwrap_bulk_write);
+#ifdef HAVE_SERVER_SUPPORT
/**
* Performe transformation upon outgoing bulk read.
*/
}
EXPORT_SYMBOL(sptlrpc_svc_prep_bulk);
+#endif /* HAVE_SERVER_SUPPORT */
+
/****************************************
* user descriptor helpers *
****************************************/