/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright (c) 1998-2001 by Sun Microsystems, Inc.
* All rights reserved.
*/
#ifndef _SYS_RSM_RSMPI_H
#define _SYS_RSM_RSMPI_H
#pragma ident "%Z%%M% %I% %E% SMI"
#ifdef __cplusplus
extern "C" {
#endif
#ifndef _KERNEL
typedef void * ddi_as_handle_t;
#endif
#include <sys/sunddi.h>
#include <sys/rsm/rsm_common.h>
struct __rsm_resource_callback_arg;
typedef struct __rsm_resource_callback_arg *rsm_resource_callback_arg_t;
typedef void (*rsm_resource_callback_t)(rsm_resource_callback_arg_t);
struct __rsm_callback_arg;
typedef struct __rsm_callback_arg *rsm_callback_arg_t;
typedef void (*rsm_callback_t)(rsm_callback_arg_t);
/* Values for resource callback function pointer */
#define RSM_RESOURCE_SLEEP (rsm_resource_callback_t)0
#define RSM_RESOURCE_DONTWAIT (rsm_resource_callback_t)-1
/* rsm_seg_create() flags values */
#define RSM_ALLOW_UNBIND_REBIND 0x01
typedef uint_t rsm_intr_t;
typedef rsm_intr_t rsm_intr_service_t;
/* The following definitions used to describe the ranges fro rsm_intr_t */
#define RSM_INTR_T_DRV_BASE 0
#define RSM_INTR_T_DRV_END 0x3F
#define RSM_INTR_T_FRM_BASE 0x40
#define RSM_INTR_T_FRM_END 0x4F
#define RSM_INTR_T_RESERVED_BASE 0x50
#define RSM_INTR_T_RESERVED_END 0x5F
#define RSM_INTR_T_SUN_BASE 0x60
#define RSM_INTR_T_SUN_END 0xDF
#define RSM_INTR_T_USR_BASE 0xE0
#define RSM_INTR_T_USR_END 0xFF
#define RSM_INTR_T_NSVC 0x100
/* kstat's ks_name for RSMPI controller drivers */
#define RSM_KS_NAME "rsmpi_stat"
/* named kstat component names */
#define RSM_KS_CTLR_STATE "ctlr_state" /* CHAR */
#define RSM_KS_ADDR "addr" /* UINT64 */
#define RSM_KS_EX_MEMSEGS "ex_memsegs" /* UINT32 */
#define RSM_KS_EX_MEMSEGS_PUB "ex_memsegs_pub" /* UINT32 */
#define RSM_KS_EX_MEMSEGS_CON "ex_memsegs_con" /* UINT32 */
#define RSM_KS_BYTES_BOUND "bytes_bound" /* UINT64 */
#define RSM_KS_IM_MEMSEGS_CON "im_memsegs_con" /* UINT32 */
#define RSM_KS_SENDQS "sendqs" /* UINT64 */
#define RSM_KS_HANDLERS "handlers" /* UINT64 */
/* The following are the possible values of RSM_KS_CTLR_STATE */
#define RSM_AE_CTLR_DOWN "rsm_down"
#define RSM_AE_CTLR_UP "rsm_up"
struct __rsm_send_q_handle;
typedef struct __rsm_send_q_handle *rsm_send_q_handle_t;
/* rsm_intr_send_q_create flags values */
#define RSM_INTR_SEND_Q_NO_FENCE 0x1
#define RSM_INTR_SEND_Q_FULL_FAIL 0x2
#define RSM_INTR_SEND_Q_UNRELIABLE 0x4
typedef struct {
void *is_data;
size_t is_size;
int is_flags;
clock_t is_wait;
} rsm_send_t;
/* rsm_send_t flags values */
#define RSM_INTR_SEND_QUEUE 0x1
#define RSM_INTR_SEND_DELIVER 0x2
#define RSM_INTR_SEND_POLL 0x4
#define RSM_INTR_SEND_SLEEP 0x8
#define RSM_INTR_SEND_LOWER_FENCE 0x10
typedef enum {
RSM_INTR_HAND_UNCLAIMED = 0,
RSM_INTR_HAND_CLAIMED = 1,
RSM_INTR_HAND_CLAIMED_EXCLUSIVE = 2
} rsm_intr_hand_ret_t;
typedef enum {
RSM_INTR_Q_OP_CREATE,
RSM_INTR_Q_OP_CONFIGURE,
RSM_INTR_Q_OP_DESTROY,
RSM_INTR_Q_OP_RECEIVE,
RSM_INTR_Q_OP_DROP
} rsm_intr_q_op_t;
struct __rsm_intr_hand_arg;
typedef struct __rsm_intr_hand_arg *rsm_intr_hand_arg_t;
struct __rsm_registry_item;
typedef struct __rsm_registry_item *rsm_registry_item_t;
typedef int rsm_intr_pri_t;
typedef struct {
rsm_addr_t ae_addr; /* node hwaddr allowed access */
rsm_permission_t ae_permission; /* permissions for node */
} rsm_access_entry_t;
/*
* ae_addr can be set to the following value to mean that the permissions
* should apply to all nodes accessible through this RSM controller
*/
#define RSM_ACCESS_PUBLIC 0xFFFF
struct __rsm_controller_handle;
typedef struct __rsm_controller_handle *rsm_controller_handle_t;
/*
* The following typedef is used to represent a controller object.
*/
typedef struct rsm_controller_object {
struct rsm_ops *ops;
rsm_controller_handle_t handle;
} rsm_controller_object_t;
typedef rsm_intr_hand_ret_t (*rsm_intr_hand_t)(
rsm_controller_object_t *controller,
rsm_intr_q_op_t operation,
rsm_addr_t sender,
void *data,
size_t size,
rsm_intr_hand_arg_t arg);
typedef struct {
enum { RSM_MEM_VADDR,
RSM_MEM_BUF,
RSM_MEM_HANDLE,
RSM_MEM_INVALID } ms_type;
union {
struct {
void *vaddr;
size_t length;
ddi_as_handle_t as;
} vr;
struct buf *bp;
rsm_memseg_export_handle_t handle;
} ms_memory;
#define ms_bp ms_memory.bp
#define ms_vaddr ms_memory.vr.vaddr
#define ms_length ms_memory.vr.length
#define ms_as ms_memory.vr.as
} rsm_memory_local_t;
typedef struct {
rsm_memory_local_t local_mem;
size_t local_offset;
rsm_memseg_import_handle_t remote_handle;
size_t remote_offset;
size_t transfer_length;
} rsmpi_iovec_t;
typedef struct {
ulong_t io_request_count; /* size of iovec array */
ulong_t io_residual_count; /* zero for success */
uio_seg_t io_segflg; /* user/kernel addr */
rsmpi_iovec_t *iovec; /* ptr to array */
} rsmpi_scat_gath_t;
typedef struct {
char *attr_name;
rsm_addr_t attr_controller_addr;
uint_t attr_direct_access_sizes;
uint_t attr_atomic_sizes;
uint_t attr_error_sizes;
uint_t attr_error_behavior;
boolean_t attr_mmu_protections;
size_t attr_page_size;
size_t attr_max_export_segment_size;
size_t attr_tot_export_segment_size;
ulong_t attr_max_export_segments;
size_t attr_max_import_map_size;
size_t attr_tot_import_map_size;
ulong_t attr_max_import_segments;
boolean_t attr_io_space_exportable;
boolean_t attr_imported_space_ioable;
boolean_t attr_intr_sender_ident;
size_t attr_intr_data_size_max;
uint_t attr_intr_data_align;
boolean_t attr_intr_piggyback;
boolean_t attr_resource_callbacks;
} rsm_controller_attr_t;
/*
* The following three defines are possible values for attr_error_behavior
* field of the rsm_controller_attr_t struct.
*/
#define RSM_ERR_NOCHANGE 0
#define RSM_ERR_ZEROES 0x1
#define RSM_ERR_RANDOM 0x2
typedef struct rsm_ops {
/*
* structure revision number:
*/
uint_t rsm_version;
/*
* export side memory segment operations:
*/
int (*rsm_seg_create)
(rsm_controller_handle_t controller,
rsm_memseg_export_handle_t *memseg,
size_t size,
uint_t flags,
rsm_memory_local_t *memory,
rsm_resource_callback_t callback,
rsm_resource_callback_arg_t callback_arg);
int (*rsm_seg_destroy)
(rsm_memseg_export_handle_t handle);
int (*rsm_bind)
(rsm_memseg_export_handle_t memseg,
off_t offset,
rsm_memory_local_t *memory,
rsm_resource_callback_t callback,
rsm_resource_callback_arg_t callback_arg);
int (*rsm_unbind)
(rsm_memseg_export_handle_t memseg,
off_t offset,
size_t length);
int (*rsm_rebind)
(rsm_memseg_export_handle_t memseg,
off_t offset,
rsm_memory_local_t *memory,
rsm_resource_callback_t callback,
rsm_resource_callback_arg_t callback_arg);
int (*rsm_publish)
(rsm_memseg_export_handle_t memseg,
rsm_access_entry_t access_list[],
uint_t access_list_length,
rsm_memseg_id_t segment_id,
rsm_resource_callback_t callback,
rsm_resource_callback_arg_t callback_arg);
int (*rsm_unpublish)
(rsm_memseg_export_handle_t memseg);
int (*rsm_republish)
(rsm_memseg_export_handle_t memseg,
rsm_access_entry_t access_list[],
uint_t access_list_length,
rsm_resource_callback_t callback,
rsm_resource_callback_arg_t callback_arg);
/*
* import side memory segment operations
*/
int (*rsm_connect)
(rsm_controller_handle_t controller,
rsm_addr_t addr,
rsm_memseg_id_t segment_id,
rsm_memseg_import_handle_t *im_memseg);
int (*rsm_disconnect)
(rsm_memseg_import_handle_t im_memseg);
/*
* import side memory segment operations (read access functions):
*/
int (* rsm_get8)
(rsm_memseg_import_handle_t im_memseg,
off_t offset,
uint8_t *datap,
ulong_t rep_cnt,
boolean_t byte_swap);
int (* rsm_get16)
(rsm_memseg_import_handle_t im_memseg,
off_t offset,
uint16_t *datap,
ulong_t rep_cnt,
boolean_t byte_swap);
int (* rsm_get32)
(rsm_memseg_import_handle_t im_memseg,
off_t offset,
uint32_t *datap,
ulong_t rep_cnt,
boolean_t byte_swap);
int (* rsm_get64)
(rsm_memseg_import_handle_t im_memseg,
off_t offset,
uint64_t *datap,
ulong_t rep_cnt,
boolean_t byte_swap);
int (* rsm_get)
(rsm_memseg_import_handle_t im_memseg,
off_t offset,
void *datap,
size_t length);
/*
* import side memory segment operations (write access functions)
*/
int (* rsm_put8)
(rsm_memseg_import_handle_t im_memseg,
off_t offset,
uint8_t *datap,
ulong_t rep_cnt,
boolean_t byte_swap);
int (* rsm_put16)
(rsm_memseg_import_handle_t im_memseg,
off_t offset,
uint16_t *datap,
ulong_t rep_cnt,
boolean_t byte_swap);
int (* rsm_put32)
(rsm_memseg_import_handle_t im_memseg,
off_t offset,
uint32_t *datap,
ulong_t rep_cnt,
boolean_t byte_swap);
int (* rsm_put64)
(rsm_memseg_import_handle_t im_memseg,
off_t offset,
uint64_t *datap,
ulong_t rep_cnt,
boolean_t byte_swap);
int (* rsm_put)
(rsm_memseg_import_handle_t im_memseg,
off_t offset,
void *datap,
size_t length);
/*
* import side memory segment operations (mapping)
*/
int (*rsm_map)(rsm_memseg_import_handle_t im_memseg,
off_t offset,
size_t len,
size_t *maplen,
dev_info_t **dipp,
uint_t *register_number,
off_t *register_offset,
rsm_resource_callback_t callback,
rsm_resource_callback_arg_t callback_arg);
int (*rsm_unmap)
(rsm_memseg_import_handle_t im_memseg);
/*
* import side memory segment operations (barriers):
*/
int (* rsm_open_barrier_region)
(rsm_memseg_import_handle_t region,
rsm_barrier_t *barrier);
int (* rsm_open_barrier_regions)
(rsm_memseg_import_handle_t regions[],
uint_t num_regions,
rsm_barrier_t *barrier);
int (* rsm_open_barrier_node)
(rsm_controller_handle_t controller,
rsm_addr_t addr,
rsm_barrier_t *barrier);
int (* rsm_open_barrier_ctrl)
(rsm_controller_handle_t controller,
rsm_barrier_t *barrier);
int (* rsm_open_barrier_region_thr)
(rsm_memseg_import_handle_t region,
rsm_barrier_t *barrier);
int (* rsm_open_barrier_regions_thr)
(rsm_memseg_import_handle_t regions[],
uint_t num_regions,
rsm_barrier_t *barrier);
int (* rsm_open_barrier_node_thr)
(rsm_controller_handle_t controller,
rsm_addr_t addr,
rsm_barrier_t *barrier);
int (* rsm_open_barrier_ctrl_thr)
(rsm_controller_handle_t controller,
rsm_barrier_t *barrier);
int (* rsm_close_barrier)
(rsm_barrier_t *barrier);
int (* rsm_reopen_barrier)
(rsm_barrier_t *barrier);
int (* rsm_order_barrier)
(rsm_barrier_t *barrier);
int (* rsm_thread_init)
(rsm_controller_handle_t controller);
int (* rsm_thread_fini)
(rsm_controller_handle_t controller);
int (* rsm_get_barrier_mode)
(rsm_memseg_import_handle_t im_memseg,
rsm_barrier_mode_t *mode);
int (* rsm_set_barrier_mode)
(rsm_memseg_import_handle_t im_memseg,
rsm_barrier_mode_t mode);
/*
* sending side interrupt operations:
*/
int (* rsm_sendq_create)
(rsm_controller_handle_t controller,
rsm_addr_t addr,
rsm_intr_service_t service,
rsm_intr_pri_t pri,
ulong_t qdepth,
uint_t flags,
rsm_resource_callback_t callback,
rsm_resource_callback_arg_t arg,
rsm_send_q_handle_t *iqp);
int (* rsm_sendq_config)
(rsm_send_q_handle_t iq,
rsm_intr_pri_t pri,
ulong_t qdepth,
uint_t flags,
rsm_resource_callback_t callback,
rsm_resource_callback_arg_t arg);
int (* rsm_sendq_destroy)
(rsm_send_q_handle_t iq);
int (* rsm_send)
(rsm_send_q_handle_t iq,
rsm_send_t *is,
rsm_barrier_t *barrier);
/*
* receiving side interrupt operations:
*/
int (* rsm_register_handler)
(rsm_controller_handle_t controller,
rsm_controller_object_t *controller_obj,
rsm_intr_t type,
rsm_intr_hand_t handler,
rsm_intr_hand_arg_t handler_arg,
rsm_addr_t senders_list[],
uint_t senders_list_length);
int (* rsm_unregister_handler)
(rsm_controller_handle_t controller,
rsm_intr_t type,
rsm_intr_hand_t handler,
rsm_intr_hand_arg_t handler_arg);
/* scatter-gather I/O */
int (* rsm_memseg_import_getv)
(rsm_controller_handle_t cp,
rsmpi_scat_gath_t *sg_io);
int (* rsm_memseg_import_putv)
(rsm_controller_handle_t cp,
rsmpi_scat_gath_t *sg_io);
/* Management operation */
int (*rsm_get_peers)
(rsm_controller_handle_t controller,
rsm_addr_t *addr_list,
uint_t count,
uint_t *num_addrs);
/* Extension operation */
int (*rsm_extension)
(rsm_controller_handle_t controller,
char *extname,
void *extobj);
} rsm_ops_t;
/*
* service module function templates:
*/
int rsm_get_controller(const char *name, uint_t number,
rsm_controller_object_t *controller,
uint_t version);
int rsm_release_controller(const char *name, uint_t number,
rsm_controller_object_t *controller);
int rsm_get_controller_attr(rsm_controller_handle_t,
rsm_controller_attr_t **attrp);
/*
* MACROS for Clients requesting services via RSMPI module
*/
/*
* Export Side segment operations
*/
#define RSM_SEG_CREATE(controller, memseg, size, flags, memory, callback, \
callback_arg) \
(*((controller).ops->rsm_seg_create)) \
((controller).handle, (memseg), (size), (flags), (memory), \
(callback), (callback_arg))
#define RSM_SEG_DESTROY(controller, memseg) \
(*((controller).ops->rsm_seg_destroy)) \
((memseg))
#define RSM_BIND(controller, memseg, offset, memory, callback, \
callback_arg) \
(*((controller).ops->rsm_bind)) \
((memseg), offset, (memory), (callback), (callback_arg))
#define RSM_UNBIND(controller, memseg, offset, length) \
(*((controller).ops->rsm_unbind)) \
((memseg), (offset), (length))
#define RSM_REBIND(controller, memseg, offset, memory, callback, \
callback_arg) \
(*((controller).ops->rsm_rebind)) \
((memseg), offset, (memory), (callback), (callback_arg))
#define RSM_PUBLISH(controller, memseg, access_list, access_list_length, \
segment_id, callback, callback_arg) \
(*((controller).ops->rsm_publish)) \
((memseg), access_list, access_list_length, segment_id, \
(callback), (callback_arg))
#define RSM_UNPUBLISH(controller, memseg) \
(*((controller).ops->rsm_unpublish)) \
((memseg))
#define RSM_REPUBLISH(controller, memseg, access_list, access_list_length, \
callback, callback_arg) \
(*((controller).ops->rsm_republish)) \
((memseg), (access_list), (access_list_length), (callback), \
(callback_arg))
#define RSM_CONNECT(controller, addr, segment_id, im_memseg) \
(*((controller).ops->rsm_connect)) \
((controller).handle, (addr), (segment_id), (im_memseg))
#define RSM_DISCONNECT(controller, im_memseg) \
(*((controller).ops->rsm_disconnect)) \
((im_memseg))
/*
* import side memory segment operations (read access functions)
*/
#define RSM_GET8(controller, im_memseg, offset, datap, rep_cnt, byte_swap) \
(*((controller).ops->rsm_get8)) \
((im_memseg), (offset), (datap), (rep_cnt), (byte_swap))
#define RSM_GET16(controller, im_memseg, offset, datap, rep_cnt, byte_swap) \
(*((controller).ops->rsm_get16)) \
((im_memseg), (offset), (datap), (rep_cnt), (byte_swap))
#define RSM_GET32(controller, im_memseg, offset, datap, rep_cnt, byte_swap) \
(*((controller).ops->rsm_get32)) \
((im_memseg), (offset), (datap), (rep_cnt), (byte_swap))
#define RSM_GET64(controller, im_memseg, offset, datap, rep_cnt, byte_swap) \
(*((controller).ops->rsm_get64)) \
((im_memseg), (offset), (datap), (rep_cnt), (byte_swap))
#define RSM_GET(controller, im_memseg, offset, dst_addr, length) \
(*((controller).ops->rsm_get)) \
((im_memseg), (offset), (dst_addr), (length))
/*
* import side memory segment operations (write access functions)
*/
#define RSM_PUT8(controller, im_memseg, offset, datap, rep_cnt, byte_swap) \
(*((controller).ops->rsm_put8)) \
((im_memseg), (offset), (datap), (rep_cnt), (byte_swap))
#define RSM_PUT16(controller, im_memseg, offset, datap, rep_cnt, byte_swap) \
(*((controller).ops->rsm_put16)) \
((im_memseg), (offset), (datap), (rep_cnt), (byte_swap))
#define RSM_PUT32(controller, im_memseg, offset, datap, rep_cnt, byte_swap) \
(*((controller).ops->rsm_put32)) \
((im_memseg), (offset), (datap), (rep_cnt), (byte_swap))
#define RSM_PUT64(controller, im_memseg, offset, datap, rep_cnt, byte_swap) \
(*((controller).ops->rsm_put64)) \
((im_memseg), (offset), (datap), (rep_cnt), (byte_swap))
#define RSM_PUT(controller, im_memseg, offset, datap, length) \
(*((controller).ops->rsm_put)) \
((im_memseg), (offset), (datap), (length))
/*
* import side memory segment operations (mapping):
*/
#define RSM_MAP(controller, im_memseg, offset, length, maplen, dipp, \
dev_register, dev_offset, callback, arg) \
(*((controller).ops->rsm_map)) \
((im_memseg), (offset), (length), (maplen), (dipp), (dev_register), \
(dev_offset), (callback), (arg))
#define RSM_UNMAP(controller, im_memseg) \
(*((controller).ops->rsm_unmap)) \
((im_memseg))
/*
* import side memory segment operations (barriers):
*/
#define RSM_OPEN_BARRIER_REGION(controller, region, barrier) \
(*((controller).ops->rsm_open_barrier_region)) \
((region), (barrier))
#define RSM_OPEN_BARRIER_REGIONS(controller, regions, num_regions, barrier) \
(*((controller).ops->rsm_open_barrier_regions)) \
((regions), (num_regions), (barrier))
#define RSM_OPEN_BARRIER_NODE(controller, addr, barrier) \
(*((controller).ops-> rsm_open_barrier_node)) \
((controller).handle, (addr), (barrier))
#define RSM_OPEN_BARRIER_CTRL(controller, barrier) \
(*((controller).ops->rsm_open_barrier_ctrl)) \
((controller).handle, (barrier))
#define RSM_OPEN_BARRIER_REGION_THR(controller, region, barrier) \
(*((controller).ops->rsm_open_barrier_region_thr)) \
((region), (barrier))
#define RSM_OPEN_BARRIER_REGIONS_THR(controller, regions, num_regions, barrier)\
(*((controller).ops->rsm_open_barrier_regions_thr)) \
((regions), (num_regions), (barrier))
#define RSM_OPEN_BARRIER_NODE_THR(controller, addr, barrier) \
(*((controller).ops->rsm_open_barrier_node_thr)) \
((controller).handle, (addr), (barrier))
#define RSM_OPEN_BARRIER_CTRL_THR(controller, barrier) \
(*((controller).ops->rsm_open_barrier_ctrl_thr)) \
((controller).handle, (barrier));
#define RSM_CLOSE_BARRIER(controller, barrier) \
(*((controller).ops->rsm_close_barrier)) \
((barrier))
#define RSM_REOPEN_BARRIER(controller, barrier) \
(*((controller).ops->rsm_reopen_barrier)) \
((barrier));
#define RSM_ORDER_BARRIER(controller, barrier) \
(*((controller).ops->rsm_order_barrier)) \
((barrier))
#define RSM_THREAD_INIT(controller) \
(*((controller).ops->rsm_thread_init)) \
((controller).handle)
#define RSM_THREAD_FINI(controller) \
(*((controller).ops->rsm_thread_fini)) \
((controller).handle)
#define RSM_GET_BARRIER_MODE(controller, im_memseg, mode) \
(*((controller).ops->rsm_get_barrier_mode)) \
((im_memseg), (mode))
#define RSM_SET_BARRIER_MODE(controller, im_memseg, mode) \
(*((controller).ops->rsm_set_barrier_mode)) \
((im_memseg), (mode))
/*
* sending side interrupt operations:
*/
#define RSM_SENDQ_CREATE(controller, addr, service, pri, qdepth, flags, \
callback, arg, iqp) \
(*((controller).ops->rsm_sendq_create)) \
((controller).handle, (addr), (service), (pri), (qdepth), (flags), \
(callback), (arg), (iqp))
#define RSM_SENDQ_CONFIG(controller, iq, pri, qdepth, flags, callback, arg) \
(*((controller).ops->rsm_sendq_config)) \
((iq), (pri), (qdepth), (flags), \
(callback), (arg))
#define RSM_SENDQ_DESTROY(controller, iq) \
(*((controller).ops->rsm_sendq_destroy)) \
((iq))
#define RSM_SEND(controller, iq, is, barrier) \
(*((controller).ops->rsm_send)) \
((iq), (is), (barrier))
/*
* receiving side interrupt operations:
*/
#define RSM_REGISTER_HANDLER(controller, type, handler, handler_arg, \
senders_list, senders_list_length) \
(*((controller).ops->rsm_register_handler)) \
((controller).handle, &(controller), (type), (handler), (handler_arg), \
(senders_list), (senders_list_length))
#define RSM_UNREGISTER_HANDLER(controller, type, handler, handler_arg) \
(*((controller).ops->rsm_unregister_handler)) \
((controller).handle, (type), (handler), (handler_arg))
#define RSM_GETV(controller, sg_io) \
(*((controller).ops->rsm_memseg_import_getv)) \
((controller).handle, (sg_io))
#define RSM_PUTV(controller, sg_io) \
(*((controller).ops->rsm_memseg_import_putv)) \
((controller).handle, (sg_io))
#define RSM_GET_PEERS(controller, addr_list, count, num_addrs) \
(*((controller).ops->rsm_get_peers)) \
((controller).handle, (addr_list), (count), (num_addrs))
#define RSM_EXTENSION(controller, extname, extobj) \
(*((controller).ops->rsm_extension)) \
((controller).handle, (extname), (extobj))
#ifdef __cplusplus
}
#endif
#endif /* _SYS_RSM_RSMPI_H */