Print this page
5072 all rdma cm events should be in the enum
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/sys/ib/clients/rdsv3/rdsv3_impl.h
+++ new/usr/src/uts/common/sys/ib/clients/rdsv3/rdsv3_impl.h
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
23 23 * Copyright 2012 Nexenta Systems, Inc. All rights reserved.
24 24 */
25 25
26 26 #ifndef _RDSV3_IMPL_H
27 27 #define _RDSV3_IMPL_H
28 28
29 29 #include <sys/atomic.h>
30 30
31 31 /*
32 32 * This file is only present in Solaris
33 33 */
34 34
35 35 #ifdef __cplusplus
36 36 extern "C" {
37 37 #endif
38 38
39 39 extern dev_info_t *rdsv3_dev_info;
40 40
41 41 #define uint16_be_t uint16_t
42 42 #define uint32_be_t uint32_t
43 43 #define uint64_be_t uint64_t
44 44
45 45 /*
46 46 * RDS Well known service id
47 47 * Format: 0x1h00144Fhhhhhhhh
48 48 * "00144F" is the Sun OUI
49 49 * 'h' can be any hex-decimal digit.
50 50 */
51 51 #define RDS_SERVICE_ID 0x1000144F00000001ULL
52 52
53 53 /*
54 54 * Atomic operations
55 55 */
56 56 typedef unsigned int atomic_t;
57 57 #define ATOMIC_INIT(a) a
58 58
59 59 #define atomic_get(p) (*(p))
60 60
61 61 #define atomic_cmpset_long(p, c, n) \
62 62 ((c == atomic_cas_uint(p, c, n)) ? c : -1)
63 63
64 64 #define atomic_dec_and_test(a) \
65 65 (atomic_dec_uint_nv((a)) == 0)
66 66
67 67 #define atomic_cmpxchg(a, o, n) \
68 68 atomic_cas_uint(a, o, n)
69 69
70 70 #ifdef _LP64
71 71 #define set_bit(b, p) \
72 72 atomic_or_ulong(((volatile ulong_t *)(void *)(p)) + ((b) >> 6), \
73 73 1ul << ((b) & 0x3f))
74 74
75 75 #define clear_bit(b, p) \
76 76 atomic_and_ulong(((volatile ulong_t *)(void *)(p)) + ((b) >> 6), \
77 77 ~(1ul << ((b) & 0x3f)))
78 78
79 79 #define test_bit(b, p) \
80 80 (((volatile ulong_t *)(void *)(p))[(b) >> 6] & (1ul << ((b) & 0x3f)))
81 81
82 82 #define test_and_set_bit(b, p) \
83 83 atomic_set_long_excl(((ulong_t *)(void *)(p)) + \
84 84 ((b) >> 6), ((b) & 0x3f))
85 85 #define test_and_clear_bit(b, p) \
86 86 !atomic_clear_long_excl(((ulong_t *)(void *)(p)) + ((b) >> 6), \
87 87 ((b) & 0x3f))
88 88 #else
89 89 #define set_bit(b, p) \
90 90 atomic_or_uint(((volatile uint_t *)(void *)p) + (b >> 5), \
91 91 1ul << (b & 0x1f))
92 92
93 93 #define clear_bit(b, p) \
94 94 atomic_and_uint(((volatile uint_t *)(void *)p) + (b >> 5), \
95 95 ~(1ul << (b & 0x1f)))
96 96
97 97 #define test_bit(b, p) \
98 98 (((volatile uint_t *)(void *)p)[b >> 5] & (1ul << (b & 0x1f)))
99 99
100 100 #define test_and_set_bit(b, p) \
101 101 atomic_set_long_excl(((ulong_t *)(void *)p) + (b >> 5), (b & 0x1f))
102 102 #define test_and_clear_bit(b, p) \
103 103 !atomic_clear_long_excl(((ulong_t *)(void *)p) + (b >> 5), (b & 0x1f))
104 104 #endif
105 105
106 106 /*
107 107 * These macros and/or constants are used instead of Linux
108 108 * generic_{test,__{clear,set}}_le_bit().
109 109 */
110 110 #if defined(sparc)
111 111 #define LE_BIT_XOR ((BITS_PER_LONG-1) & ~0x7)
112 112 #else
113 113 #define LE_BIT_XOR 0
114 114 #endif
115 115
116 116 #define set_le_bit(b, p) set_bit(b ^ LE_BIT_XOR, p)
117 117 #define clear_le_bit(b, p) clear_bit(b ^ LE_BIT_XOR, p)
118 118 #define test_le_bit(b, p) test_bit(b ^ LE_BIT_XOR, p)
119 119
120 120 uint_t rdsv3_one_sec_in_hz;
121 121
122 122 #define jiffies 100
123 123 #define HZ (drv_hztousec(1))
124 124 /* setting this to PAGESIZE throws build errors */
125 125 #define PAGE_SIZE 4096 /* xxx - fix this */
126 126 #define BITS_PER_LONG (sizeof (unsigned long) * 8)
127 127
128 128 /* debug */
|
↓ open down ↓ |
128 lines elided |
↑ open up ↑ |
129 129 #define RDSV3_PANIC() cmn_err(CE_PANIC, "Panic forced by RDSV3");
130 130
131 131 /* ERR */
132 132 #define MAX_ERRNO 4095
133 133 #define ERR_PTR(x) ((void *)(uintptr_t)x)
134 134 #define IS_ERR(ptr) (((uintptr_t)ptr) >= (uintptr_t)-MAX_ERRNO)
135 135 #define PTR_ERR(ptr) (int)(uintptr_t)ptr
136 136
137 137 #define MAX_SCHEDULE_TIMEOUT (~0UL>>1)
138 138
139 -#define RDMA_CM_EVENT_ADDR_CHANGE 14
140 -
141 139 /* list */
142 140 /* copied and modified list_remove_node */
143 141 #define list_remove_node(node) \
144 142 if ((node)->list_next != NULL) { \
145 143 (node)->list_prev->list_next = (node)->list_next; \
146 144 (node)->list_next->list_prev = (node)->list_prev; \
147 145 (node)->list_next = (node)->list_prev = NULL; \
148 146 }
149 147
150 148 #define list_splice(src, dst) { \
151 149 list_create(dst, (src)->list_size, (src)->list_offset); \
152 150 list_move_tail(dst, src); \
153 151 }
154 152
155 153 #define RDSV3_FOR_EACH_LIST_NODE(objp, listp, member) \
156 154 for (objp = list_head(listp); objp; objp = list_next(listp, objp))
157 155 #define RDSV3_FOR_EACH_LIST_NODE_SAFE(objp, tmp, listp, member) \
158 156 for (objp = list_head(listp), tmp = (objp != NULL) ? \
159 157 list_next(listp, objp) : NULL; \
160 158 objp; \
161 159 objp = tmp, tmp = (objp != NULL) ? \
162 160 list_next(listp, objp) : NULL)
163 161
164 162 /* simulate wait_queue_head_t */
165 163 typedef struct rdsv3_wait_queue_s {
166 164 kmutex_t waitq_mutex;
167 165 kcondvar_t waitq_cv;
168 166 uint_t waitq_waiters;
169 167 } rdsv3_wait_queue_t;
170 168
171 169 #define rdsv3_init_waitqueue(waitqp) \
172 170 mutex_init(&(waitqp)->waitq_mutex, NULL, MUTEX_DRIVER, NULL); \
173 171 cv_init(&(waitqp)->waitq_cv, NULL, CV_DRIVER, NULL); \
174 172 (waitqp)->waitq_waiters = 0
175 173
176 174 #define rdsv3_exit_waitqueue(waitqp) \
177 175 ASSERT((waitqp)->waitq_waiters == 0); \
178 176 mutex_destroy(&(waitqp)->waitq_mutex); \
179 177 cv_destroy(&(waitqp)->waitq_cv)
180 178
181 179 #define rdsv3_wake_up(waitqp) { \
182 180 mutex_enter(&(waitqp)->waitq_mutex); \
183 181 if ((waitqp)->waitq_waiters) \
184 182 cv_signal(&(waitqp)->waitq_cv); \
185 183 mutex_exit(&(waitqp)->waitq_mutex); \
186 184 }
187 185
188 186 #define rdsv3_wake_up_all(waitqp) { \
189 187 mutex_enter(&(waitqp)->waitq_mutex); \
190 188 if ((waitqp)->waitq_waiters) \
191 189 cv_broadcast(&(waitqp)->waitq_cv); \
192 190 mutex_exit(&(waitqp)->waitq_mutex); \
193 191 }
194 192
195 193 /* analogous to cv_wait */
196 194 #define rdsv3_wait_event(waitq, condition) \
197 195 { \
198 196 mutex_enter(&(waitq)->waitq_mutex); \
199 197 (waitq)->waitq_waiters++; \
200 198 while (!(condition)) { \
201 199 cv_wait(&(waitq)->waitq_cv, &(waitq)->waitq_mutex); \
202 200 } \
203 201 (waitq)->waitq_waiters--; \
204 202 mutex_exit(&(waitq)->waitq_mutex); \
205 203 }
206 204
207 205 /* analogous to cv_wait_sig */
208 206 #define rdsv3_wait_sig(waitqp, condition) \
209 207 ( \
210 208 { \
211 209 int cv_return = 1; \
212 210 mutex_enter(&(waitqp)->waitq_mutex); \
213 211 (waitqp)->waitq_waiters++; \
214 212 while (!(condition)) { \
215 213 cv_return = cv_wait_sig(&(waitqp)->waitq_cv, \
216 214 &(waitqp)->waitq_mutex); \
217 215 if (cv_return == 0) { \
218 216 break; \
219 217 } \
220 218 } \
221 219 (waitqp)->waitq_waiters--; \
222 220 mutex_exit(&(waitqp)->waitq_mutex); \
223 221 cv_return; \
224 222 } \
225 223 )
226 224
227 225 #define SOCK_DEAD 1ul
228 226
229 227 /* socket */
230 228 typedef struct rsock {
231 229 sock_upper_handle_t sk_upper_handle;
232 230 sock_upcalls_t *sk_upcalls;
233 231
234 232 kmutex_t sk_lock;
235 233 ulong_t sk_flag;
236 234 rdsv3_wait_queue_t *sk_sleep; /* Also protected by rs_recv_lock */
237 235 int sk_sndbuf;
238 236 int sk_rcvbuf;
239 237 atomic_t sk_refcount;
240 238
241 239 struct rdsv3_sock *sk_protinfo;
242 240 } rsock_t;
243 241
244 242 typedef struct rdsv3_conn_info_s {
245 243 uint32_be_t c_laddr;
246 244 uint32_be_t c_faddr;
247 245 } rdsv3_conn_info_t;
248 246
249 247 /* WQ */
250 248 typedef struct rdsv3_workqueue_struct_s {
251 249 kmutex_t wq_lock;
252 250 uint_t wq_state;
253 251 int wq_pending;
254 252 list_t wq_queue;
255 253 } rdsv3_workqueue_struct_t;
256 254
257 255 struct rdsv3_work_s;
258 256 typedef void (*rdsv3_work_func_t)(struct rdsv3_work_s *);
259 257 typedef struct rdsv3_work_s {
260 258 list_node_t work_item;
261 259 rdsv3_work_func_t func;
262 260 } rdsv3_work_t;
263 261
264 262 /* simulate delayed_work */
265 263 typedef struct rdsv3_delayed_work_s {
266 264 kmutex_t lock;
267 265 rdsv3_work_t work;
268 266 timeout_id_t timeid;
269 267 rdsv3_workqueue_struct_t *wq;
270 268 } rdsv3_delayed_work_t;
271 269
272 270 #define RDSV3_INIT_WORK(wp, f) (wp)->func = f
273 271 #define RDSV3_INIT_DELAYED_WORK(dwp, f) \
274 272 (dwp)->work.func = f; \
275 273 mutex_init(&(dwp)->lock, NULL, MUTEX_DRIVER, NULL); \
276 274 (dwp)->timeid = 0
277 275
278 276 /* simulate scatterlist */
279 277 struct rdsv3_scatterlist {
280 278 caddr_t vaddr;
281 279 uint_t length;
282 280 ibt_wr_ds_t *sgl;
283 281 ibt_mi_hdl_t mihdl;
284 282 };
285 283 #define rdsv3_sg_page(scat) (scat)->vaddr
286 284 #define rdsv3_sg_len(scat) (scat)->length
287 285 #define rdsv3_sg_set_page(scat, pg, len, off) \
288 286 (scat)->vaddr = (caddr_t)(pg + off); \
289 287 (scat)->length = len
290 288 #define rdsv3_ib_sg_dma_len(dev, scat) rdsv3_sg_len(scat)
291 289
292 290 /* copied from sys/socket.h */
293 291 #if defined(__sparc)
294 292 /* To maintain backward compatibility, alignment needs to be 8 on sparc. */
295 293 #define _CMSG_HDR_ALIGNMENT 8
296 294 #else
297 295 /* for __i386 (and other future architectures) */
298 296 #define _CMSG_HDR_ALIGNMENT 4
299 297 #endif /* defined(__sparc) */
300 298
301 299 /*
302 300 * The cmsg headers (and macros dealing with them) were made available as
303 301 * part of UNIX95 and hence need to be protected with a _XPG4_2 define.
304 302 */
305 303 #define _CMSG_DATA_ALIGNMENT (sizeof (int))
306 304 #define _CMSG_HDR_ALIGN(x) (((uintptr_t)(x) + _CMSG_HDR_ALIGNMENT - 1) & \
307 305 ~(_CMSG_HDR_ALIGNMENT - 1))
308 306 #define _CMSG_DATA_ALIGN(x) (((uintptr_t)(x) + _CMSG_DATA_ALIGNMENT - 1) & \
309 307 ~(_CMSG_DATA_ALIGNMENT - 1))
310 308 #define CMSG_DATA(c) \
311 309 ((unsigned char *)_CMSG_DATA_ALIGN((struct cmsghdr *)(c) + 1))
312 310
313 311 #define CMSG_FIRSTHDR(m) \
314 312 (((m)->msg_controllen < sizeof (struct cmsghdr)) ? \
315 313 (struct cmsghdr *)0 : (struct cmsghdr *)((m)->msg_control))
316 314
317 315 #define CMSG_NXTHDR(m, c) \
318 316 (((c) == 0) ? CMSG_FIRSTHDR(m) : \
319 317 ((((uintptr_t)_CMSG_HDR_ALIGN((char *)(c) + \
320 318 ((struct cmsghdr *)(c))->cmsg_len) + sizeof (struct cmsghdr)) > \
321 319 (((uintptr_t)((struct msghdr *)(m))->msg_control) + \
322 320 ((uintptr_t)((struct msghdr *)(m))->msg_controllen))) ? \
323 321 ((struct cmsghdr *)0) : \
324 322 ((struct cmsghdr *)_CMSG_HDR_ALIGN((char *)(c) + \
325 323 ((struct cmsghdr *)(c))->cmsg_len))))
326 324
327 325 /* Amount of space + padding needed for a message of length l */
328 326 #define CMSG_SPACE(l) \
329 327 ((unsigned int)_CMSG_HDR_ALIGN(sizeof (struct cmsghdr) + (l)))
330 328
331 329 /* Value to be used in cmsg_len, does not include trailing padding */
332 330 #define CMSG_LEN(l) \
333 331 ((unsigned int)_CMSG_DATA_ALIGN(sizeof (struct cmsghdr)) + (l))
334 332
335 333 /* OFUV -> IB */
336 334 #define RDSV3_IBDEV2HCAHDL(device) (device)->hca_hdl
337 335 #define RDSV3_QP2CHANHDL(qp) (qp)->ibt_qp
338 336 #define RDSV3_PD2PDHDL(pd) (pd)->ibt_pd
339 337 #define RDSV3_CQ2CQHDL(cq) (cq)->ibt_cq
340 338
341 339 struct rdsv3_hdrs_mr {
342 340 ibt_lkey_t lkey;
343 341 caddr_t addr;
344 342 size_t size;
345 343 ibt_mr_hdl_t hdl;
346 344 };
347 345
348 346 /* rdsv3_impl.c */
349 347 void rdsv3_trans_init();
350 348 boolean_t rdsv3_capable_interface(struct lifreq *lifrp);
351 349 int rdsv3_do_ip_ioctl(ksocket_t so4, void **ipaddrs, int *size, int *nifs);
352 350 int rdsv3_do_ip_ioctl_old(ksocket_t so4, void **ipaddrs, int *size, int *nifs);
353 351 boolean_t rdsv3_isloopback(ipaddr_t addr);
354 352 void rdsv3_cancel_delayed_work(rdsv3_delayed_work_t *dwp);
355 353 void rdsv3_flush_workqueue(rdsv3_workqueue_struct_t *wq);
356 354 void rdsv3_queue_work(rdsv3_workqueue_struct_t *wq, rdsv3_work_t *wp);
357 355 void rdsv3_queue_delayed_work(rdsv3_workqueue_struct_t *wq,
358 356 rdsv3_delayed_work_t *dwp, uint_t delay);
359 357 struct rsock *rdsv3_sk_alloc();
360 358 void rdsv3_sock_init_data(struct rsock *sk);
361 359 void rdsv3_sock_exit_data(struct rsock *sk);
362 360 void rdsv3_destroy_task_workqueue(rdsv3_workqueue_struct_t *wq);
363 361 rdsv3_workqueue_struct_t *rdsv3_create_task_workqueue(char *name);
364 362 int rdsv3_conn_constructor(void *buf, void *arg, int kmflags);
365 363 void rdsv3_conn_destructor(void *buf, void *arg);
366 364 int rdsv3_conn_compare(const void *conn1, const void *conn2);
367 365 void rdsv3_loop_init();
368 366 int rdsv3_mr_compare(const void *mr1, const void *mr2);
369 367 int rdsv3_put_cmsg(struct nmsghdr *msg, int level, int type, size_t size,
370 368 void *payload);
371 369 int rdsv3_verify_bind_address(ipaddr_t addr);
372 370 uint16_t rdsv3_ip_fast_csum(void *buffer, size_t length);
373 371 uint_t rdsv3_ib_dma_map_sg(struct ib_device *dev, struct rdsv3_scatterlist
374 372 *scat, uint_t num);
375 373 void rdsv3_ib_dma_unmap_sg(ib_device_t *dev, struct rdsv3_scatterlist *scat,
376 374 uint_t num);
377 375 static inline void
378 376 rdsv3_sk_sock_hold(struct rsock *sk)
379 377 {
380 378 atomic_add_32(&sk->sk_refcount, 1);
381 379 }
382 380 static inline void
383 381 rdsv3_sk_sock_put(struct rsock *sk)
384 382 {
385 383 if (atomic_dec_and_test(&sk->sk_refcount))
386 384 rdsv3_sock_exit_data(sk);
387 385 }
388 386 static inline int
389 387 rdsv3_sk_sock_flag(struct rsock *sk, uint_t flag)
390 388 {
391 389 return (test_bit(flag, &sk->sk_flag));
392 390 }
393 391 static inline void
394 392 rdsv3_sk_sock_orphan(struct rsock *sk)
395 393 {
396 394 set_bit(SOCK_DEAD, &sk->sk_flag);
397 395 }
398 396
399 397 #define rdsv3_sndtimeo(a, b) b ? 0 : 3600 /* check this value on linux */
400 398 #define rdsv3_rcvtimeo(a, b) b ? 0 : 3600 /* check this value on linux */
401 399
402 400 void rdsv3_ib_free_conn(void *arg);
403 401
404 402 #ifdef __cplusplus
405 403 }
406 404 #endif
407 405
408 406 #endif /* _RDSV3_IMPL_H */
|
↓ open down ↓ |
258 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX