1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 2002-2004, Network Appliance, Inc. All rights reserved. 23 */ 24 25 /* 26 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 27 * Use is subject to license terms. 28 */ 29 30 31 #ifndef _UDAT_H_ 32 #define _UDAT_H_ 33 34 /* 35 * 36 * HEADER: udat.h 37 * 38 * PURPOSE: defines the user DAT API 39 * 40 * Description: Header file for "uDAPL: User Direct Access Programming 41 * Library, Version: 1.2" 42 * 43 * Mapping rules: 44 * All global symbols are prepended with "DAT_" or "dat_" 45 * All DAT objects have an 'api' tag which, such as 'ep' or 'lmr' 46 * The method table is in the provider definition structure. 47 * 48 * 49 */ 50 51 #ifdef __cplusplus 52 extern "C" { 53 #endif 54 55 #include <dat/udat_config.h> 56 57 #include <dat/dat_platform_specific.h> 58 59 typedef enum dat_mem_type 60 { 61 /* Shared between udat and kdat */ 62 DAT_MEM_TYPE_VIRTUAL = 0x00, 63 DAT_MEM_TYPE_LMR = 0x01, 64 /* udat specific */ 65 DAT_MEM_TYPE_SHARED_VIRTUAL = 0x02, 66 DAT_MEM_TYPE_SO_VIRTUAL = 0x03 67 } DAT_MEM_TYPE; 68 69 /* dat handle types */ 70 typedef enum dat_handle_type 71 { 72 DAT_HANDLE_TYPE_CR, 73 DAT_HANDLE_TYPE_EP, 74 DAT_HANDLE_TYPE_EVD, 75 DAT_HANDLE_TYPE_IA, 76 DAT_HANDLE_TYPE_LMR, 77 DAT_HANDLE_TYPE_PSP, 78 DAT_HANDLE_TYPE_PZ, 79 DAT_HANDLE_TYPE_RMR, 80 DAT_HANDLE_TYPE_RSP, 81 DAT_HANDLE_TYPE_CNO, 82 DAT_HANDLE_TYPE_SRQ 83 } DAT_HANDLE_TYPE; 84 85 /* 86 * EVD state consists of 3 orthogonal substates. One for 87 * enabled/disabled, one for waitable/unwaitable, and one 88 * for configuration. Within each substates the values are 89 * mutually exclusive. 90 */ 91 typedef enum dat_evd_state 92 { 93 DAT_EVD_STATE_ENABLED = 0x01, 94 DAT_EVD_STATE_DISABLED = 0x02, 95 DAT_EVD_STATE_WAITABLE = 0x04, 96 DAT_EVD_STATE_UNWAITABLE = 0x08, 97 DAT_EVD_STATE_CONFIG_NOTIFY = 0x10, 98 DAT_EVD_STATE_CONFIG_SOLICITED = 0x20, 99 DAT_EVD_STATE_CONFIG_THRESHOLD = 0x30 100 } DAT_EVD_STATE; 101 102 typedef enum dat_evd_param_mask 103 { 104 DAT_EVD_FIELD_IA_HANDLE = 0x01, 105 DAT_EVD_FIELD_EVD_QLEN = 0x02, 106 DAT_EVD_FIELD_EVD_STATE = 0x04, 107 DAT_EVD_FIELD_CNO = 0x08, 108 DAT_EVD_FIELD_EVD_FLAGS = 0x10, 109 110 DAT_EVD_FIELD_ALL = 0x1F 111 } DAT_EVD_PARAM_MASK; 112 113 typedef DAT_UINT64 DAT_PROVIDER_ATTR_MASK; 114 115 #include <dat/dat.h> 116 117 typedef DAT_HANDLE DAT_CNO_HANDLE; 118 119 struct dat_evd_param 120 { 121 DAT_IA_HANDLE ia_handle; 122 DAT_COUNT evd_qlen; 123 DAT_EVD_STATE evd_state; 124 DAT_CNO_HANDLE cno_handle; 125 DAT_EVD_FLAGS evd_flags; 126 }; 127 128 #define DAT_LMR_COOKIE_SIZE 40 /* size of DAT_LMR_COOKIE in bytes */ 129 typedef char (* DAT_LMR_COOKIE)[DAT_LMR_COOKIE_SIZE]; 130 131 /* Format for OS wait proxy agent function */ 132 133 typedef void (*DAT_AGENT_FUNC)( 134 DAT_PVOID, /* instance data */ 135 DAT_EVD_HANDLE /* Event Dispatcher*/); 136 137 /* Definition */ 138 139 typedef struct dat_os_wait_proxy_agent 140 { 141 DAT_PVOID instance_data; 142 DAT_AGENT_FUNC proxy_agent_func; 143 } DAT_OS_WAIT_PROXY_AGENT; 144 145 /* Define NULL Proxy agent */ 146 147 #define DAT_OS_WAIT_PROXY_AGENT_NULL \ 148 (DAT_OS_WAIT_PROXY_AGENT) { \ 149 (DAT_PVOID) NULL, \ 150 (DAT_AGENT_FUNC) NULL } 151 152 153 /* Flags */ 154 155 /* 156 * The value specified by the uDAPL Consumer for dat_ia_open to indicate 157 * that not async EVD should be created for the opening instance of an IA. 158 * The same IA have been open before that has the only async EVD to 159 * handle async errors for all open instances of the IA. 160 */ 161 162 #define DAT_EVD_ASYNC_EXISTS (DAT_EVD_HANDLE) 0x1 163 164 /* 165 * The value return by the dat_ia_query for the case when there is no 166 * async EVD for the IA instance. Consumer had specified the value of 167 * DAT_EVD_ASYNC_EXISTS for the async_evd_handle for dat_ia_open. 168 */ 169 170 #define DAT_EVD_OUT_OF_SCOPE (DAT_EVD_HANDLE) 0x2 171 172 /* 173 * Memory types 174 * 175 * Specifing memory type for LMR create. A consumer must use a single 176 * value when registering memory. The union of any of these 177 * flags is used in the provider parameters to indicate what memory 178 * type provider supports for LMR memory creation. 179 */ 180 181 182 183 /* For udapl only */ 184 185 typedef struct dat_shared_memory 186 { 187 DAT_PVOID virtual_address; 188 DAT_LMR_COOKIE shared_memory_id; 189 } DAT_SHARED_MEMORY; 190 191 typedef union dat_region_description 192 { 193 DAT_PVOID for_va; 194 DAT_LMR_HANDLE for_lmr_handle; 195 DAT_SHARED_MEMORY for_shared_memory; /* For udapl only */ 196 } DAT_REGION_DESCRIPTION; 197 198 /* LMR Arguments */ 199 200 struct dat_lmr_param 201 { 202 DAT_IA_HANDLE ia_handle; 203 DAT_MEM_TYPE mem_type; 204 DAT_REGION_DESCRIPTION region_desc; 205 DAT_VLEN length; 206 DAT_PZ_HANDLE pz_handle; 207 DAT_MEM_PRIV_FLAGS mem_priv; 208 DAT_LMR_CONTEXT lmr_context; 209 DAT_RMR_CONTEXT rmr_context; 210 DAT_VLEN registered_size; 211 DAT_VADDR registered_address; 212 }; 213 214 215 typedef struct dat_cno_param 216 { 217 DAT_IA_HANDLE ia_handle; 218 DAT_OS_WAIT_PROXY_AGENT agent; 219 } DAT_CNO_PARAM; 220 221 typedef enum dat_cno_param_mask 222 { 223 DAT_CNO_FIELD_IA_HANDLE = 0x1, 224 DAT_CNO_FIELD_AGENT = 0x2, 225 226 DAT_CNO_FIELD_ALL = 0x3 227 } DAT_CNO_PARAM_MASK; 228 229 230 /* General Provider attributes. udat specific. */ 231 typedef enum dat_pz_support 232 { 233 DAT_PZ_UNIQUE, 234 DAT_PZ_SAME, 235 DAT_PZ_SHAREABLE 236 } DAT_PZ_SUPPORT; 237 238 /* 239 * Provider should support merging of all event stream types. Provider 240 * attribute specify support for merging different event stream types. 241 * It is a 2D binary matrix where each row and column represents an event 242 * stream type. Each binary entry is 1 if the event streams of its raw 243 * and column can fed the same EVD, and 0 otherwise. The order of event 244 * streams in row and column is the same as in the definition of 245 * DAT_EVD_FLAGS: index 0 - Software Event, 1- Connection Request, 246 * 2 - DTO Completion, 3 - Connection event, 4 - RMR Bind Completion, 247 * 5 - Asynchronous event. By definition each diagonal entry is 1. 248 * Consumer allocates an array for it and passes it IN as a pointer 249 * for the array that Provider fills. Provider must fill the array 250 * that Consumer passes. 251 */ 252 253 struct dat_provider_attr 254 { 255 char provider_name[DAT_NAME_MAX_LENGTH]; 256 DAT_UINT32 provider_version_major; 257 DAT_UINT32 provider_version_minor; 258 DAT_UINT32 dapl_version_major; 259 DAT_UINT32 dapl_version_minor; 260 DAT_MEM_TYPE lmr_mem_types_supported; 261 DAT_IOV_OWNERSHIP iov_ownership_on_return; 262 DAT_QOS dat_qos_supported; 263 DAT_COMPLETION_FLAGS completion_flags_supported; 264 DAT_BOOLEAN is_thread_safe; 265 DAT_COUNT max_private_data_size; 266 DAT_BOOLEAN supports_multipath; 267 DAT_EP_CREATOR_FOR_PSP ep_creator; 268 DAT_PZ_SUPPORT pz_support; 269 DAT_UINT32 optimal_buffer_alignment; 270 const DAT_BOOLEAN evd_stream_merging_supported[6][6]; 271 DAT_BOOLEAN srq_supported; 272 DAT_COUNT srq_watermarks_supported; 273 DAT_BOOLEAN srq_ep_pz_difference_supported; 274 DAT_COUNT srq_info_supported; 275 DAT_COUNT ep_recv_info_supported; 276 DAT_BOOLEAN lmr_sync_req; 277 DAT_BOOLEAN dto_async_return_guaranteed; 278 DAT_BOOLEAN rdma_write_for_rdma_read_req; 279 DAT_COUNT num_provider_specific_attr; 280 DAT_NAMED_ATTR * provider_specific_attr; 281 }; 282 283 #define DAT_PROVIDER_FIELD_PROVIDER_NAME UINT64_C(0x0000001) 284 #define DAT_PROVIDER_FIELD_PROVIDER_VERSION_MAJOR UINT64_C(0x0000002) 285 #define DAT_PROVIDER_FIELD_PROVIDER_VERSION_MINOR UINT64_C(0x0000004) 286 #define DAT_PROVIDER_FIELD_DAPL_VERSION_MAJOR UINT64_C(0x0000008) 287 #define DAT_PROVIDER_FIELD_DAPL_VERSION_MINOR UINT64_C(0x0000010) 288 #define DAT_PROVIDER_FIELD_LMR_MEM_TYPE_SUPPORTED UINT64_C(0x0000020) 289 #define DAT_PROVIDER_FIELD_IOV_OWNERSHIP UINT64_C(0x0000040) 290 #define DAT_PROVIDER_FIELD_DAT_QOS_SUPPORTED UINT64_C(0x0000080) 291 #define DAT_PROVIDER_FIELD_COMPLETION_FLAGS_SUPPORTED UINT64_C(0x0000100) 292 #define DAT_PROVIDER_FIELD_IS_THREAD_SAFE UINT64_C(0x0000200) 293 #define DAT_PROVIDER_FIELD_MAX_PRIVATE_DATA_SIZE UINT64_C(0x0000400) 294 #define DAT_PROVIDER_FIELD_SUPPORTS_MULTIPATH UINT64_C(0x0000800) 295 #define DAT_PROVIDER_FIELD_EP_CREATOR UINT64_C(0x0001000) 296 #define DAT_PROVIDER_FIELD_PZ_SUPPORT UINT64_C(0x0002000) 297 #define DAT_PROVIDER_FIELD_OPTIMAL_BUFFER_ALIGNMENT UINT64_C(0x0004000) 298 #define DAT_PROVIDER_FIELD_EVD_STREAM_MERGING_SUPPORTED UINT64_C(0x0008000) 299 #define DAT_PROVIDER_FIELD_SRQ_SUPPORTED UINT64_C(0x0010000) 300 #define DAT_PROVIDER_FIELD_SRQ_WATERMARKS_SUPPORTED UINT64_C(0x0020000) 301 #define DAT_PROVIDER_FIELD_SRQ_EP_PZ_DIFFERENCE_SUPPORTED \ 302 UINT64_C(0x0040000) 303 #define DAT_PROVIDER_FIELD_SRQ_INFO_SUPPORTED UINT64_C(0x0080000) 304 #define DAT_PROVIDER_FIELD_EP_RECV_INFO_SUPPORTED UINT64_C(0x0100000) 305 #define DAT_PROVIDER_FIELD_LMR_SYNC_REQ UINT64_C(0x0200000) 306 #define DAT_PROVIDER_FIELD_DTO_ASYNC_RETURN_GUARANTEED UINT64_C(0x0400000) 307 #define DAT_PROVIDER_FIELD_RDMA_WRITE_FOR_RDMA_READ_REQ UINT64_C(0x0800000) 308 #define DAT_PROVIDER_FIELD_NUM_PROVIDER_SPECIFIC_ATTR UINT64_C(0x1000000) 309 #define DAT_PROVIDER_FIELD_PROVIDER_SPECIFIC_ATTR UINT64_C(0x2000000) 310 311 #define DAT_PROVIDER_FIELD_ALL UINT64_C(0x3FFFFFF) 312 #define DAT_PROVIDER_FIELD_NONE UINT64_C(0x0) 313 314 #include <dat/udat_vendor_specific.h> 315 316 /* ************************************************************************ */ 317 318 /* 319 * User DAT functions definitions. 320 */ 321 322 323 extern DAT_RETURN dat_lmr_create( 324 IN DAT_IA_HANDLE, /* ia_handle */ 325 IN DAT_MEM_TYPE, /* mem_type */ 326 IN DAT_REGION_DESCRIPTION, /* region_description */ 327 IN DAT_VLEN, /* length */ 328 IN DAT_PZ_HANDLE, /* pz_handle */ 329 IN DAT_MEM_PRIV_FLAGS, /* privileges */ 330 OUT DAT_LMR_HANDLE *, /* lmr_handle */ 331 OUT DAT_LMR_CONTEXT *, /* lmr_context */ 332 OUT DAT_RMR_CONTEXT *, /* rmr_context */ 333 OUT DAT_VLEN *, /* registered_length */ 334 OUT DAT_VADDR *); /* registered_address */ 335 336 /* Event Functions */ 337 338 extern DAT_RETURN dat_evd_create( 339 IN DAT_IA_HANDLE, /* ia_handle */ 340 IN DAT_COUNT, /* evd_min_qlen */ 341 IN DAT_CNO_HANDLE, /* cno_handle */ 342 IN DAT_EVD_FLAGS, /* evd_flags */ 343 OUT DAT_EVD_HANDLE *); /* evd_handle */ 344 345 extern DAT_RETURN dat_evd_modify_cno( 346 IN DAT_EVD_HANDLE, /* evd_handle */ 347 IN DAT_CNO_HANDLE); /* cno_handle */ 348 349 extern DAT_RETURN dat_cno_create( 350 IN DAT_IA_HANDLE, /* ia_handle */ 351 IN DAT_OS_WAIT_PROXY_AGENT, /* agent */ 352 OUT DAT_CNO_HANDLE *); /* cno_handle */ 353 354 extern DAT_RETURN dat_cno_modify_agent( 355 IN DAT_CNO_HANDLE, /* cno_handle */ 356 IN DAT_OS_WAIT_PROXY_AGENT); /* agent */ 357 358 extern DAT_RETURN dat_cno_query( 359 IN DAT_CNO_HANDLE, /* cno_handle */ 360 IN DAT_CNO_PARAM_MASK, /* cno_param_mask */ 361 OUT DAT_CNO_PARAM *); /* cno_param */ 362 363 extern DAT_RETURN dat_cno_free( 364 IN DAT_CNO_HANDLE); /* cno_handle */ 365 366 extern DAT_RETURN dat_cno_wait( 367 IN DAT_CNO_HANDLE, /* cno_handle */ 368 IN DAT_TIMEOUT, /* timeout */ 369 OUT DAT_EVD_HANDLE *); /* evd_handle */ 370 371 extern DAT_RETURN dat_evd_enable( 372 IN DAT_EVD_HANDLE); /* evd_handle */ 373 374 extern DAT_RETURN dat_evd_wait( 375 IN DAT_EVD_HANDLE, /* evd_handle */ 376 IN DAT_TIMEOUT, /* Timeout */ 377 IN DAT_COUNT, /* Threshold */ 378 OUT DAT_EVENT *, /* event */ 379 OUT DAT_COUNT *); /* N more events */ 380 381 extern DAT_RETURN dat_evd_disable( 382 IN DAT_EVD_HANDLE); /* evd_handle */ 383 384 extern DAT_RETURN dat_evd_set_unwaitable( 385 IN DAT_EVD_HANDLE); /* evd_handle */ 386 387 extern DAT_RETURN dat_evd_clear_unwaitable( 388 IN DAT_EVD_HANDLE); /* evd_handle */ 389 390 #ifdef __cplusplus 391 } 392 #endif 393 394 #endif /* _UDAT_H_ */ 395