projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
IB/mlx4: Add multicast group (MCG) paravirtualization for SR-IOV
[deliverable/linux.git] / drivers / infiniband / hw / mlx4 / mcg.c
1 /*
2 * Copyright (c) 2012 Mellanox Technologies. All rights reserved.
3 *
4 * This software is available to you under a choice of one of two
5 * licenses. You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
9 *
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
12 * conditions are met:
13 *
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
16 * disclaimer.
17 *
18 * - Redistributions in binary form must reproduce the above
19 * copyright notice, this list of conditions and the following
20 * disclaimer in the documentation and/or other materials
21 * provided with the distribution.
22 *
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30 * SOFTWARE.
31 */
32
33 #include <rdma/ib_mad.h>
34 #include <rdma/ib_smi.h>
35 #include <rdma/ib_cache.h>
36 #include <rdma/ib_sa.h>
37
38 #include <linux/mlx4/cmd.h>
39 #include <linux/rbtree.h>
40 #include <linux/delay.h>
41
42 #include "mlx4_ib.h"
43
44 #define MAX_VFS 80
45 #define MAX_PEND_REQS_PER_FUNC 4
46 #define MAD_TIMEOUT_MS 2000
47
48 #define mcg_warn(fmt, arg...) pr_warn("MCG WARNING: " fmt, ##arg)
49 #define mcg_error(fmt, arg...) pr_err(fmt, ##arg)
50 #define mcg_warn_group(group, format, arg...) \
51 pr_warn("%s-%d: %16s (port %d): WARNING: " format, __func__, __LINE__,\
52 (group)->name, group->demux->port, ## arg)
53
54 #define mcg_error_group(group, format, arg...) \
55 pr_err(" %16s: " format, (group)->name, ## arg)
56
57
58 static union ib_gid mgid0;
59
60 static struct workqueue_struct *clean_wq;
61
62 enum mcast_state {
63 MCAST_NOT_MEMBER = 0,
64 MCAST_MEMBER,
65 };
66
67 enum mcast_group_state {
68 MCAST_IDLE,
69 MCAST_JOIN_SENT,
70 MCAST_LEAVE_SENT,
71 MCAST_RESP_READY
72 };
73
74 struct mcast_member {
75 enum mcast_state state;
76 uint8_t join_state;
77 int num_pend_reqs;
78 struct list_head pending;
79 };
80
81 struct ib_sa_mcmember_data {
82 union ib_gid mgid;
83 union ib_gid port_gid;
84 __be32 qkey;
85 __be16 mlid;
86 u8 mtusel_mtu;
87 u8 tclass;
88 __be16 pkey;
89 u8 ratesel_rate;
90 u8 lifetmsel_lifetm;
91 __be32 sl_flowlabel_hoplimit;
92 u8 scope_join_state;
93 u8 proxy_join;
94 u8 reserved[2];
95 };
96
97 struct mcast_group {
98 struct ib_sa_mcmember_data rec;
99 struct rb_node node;
100 struct list_head mgid0_list;
101 struct mlx4_ib_demux_ctx *demux;
102 struct mcast_member func[MAX_VFS];
103 struct mutex lock;
104 struct work_struct work;
105 struct list_head pending_list;
106 int members[3];
107 enum mcast_group_state state;
108 enum mcast_group_state prev_state;
109 struct ib_sa_mad response_sa_mad;
110 __be64 last_req_tid;
111
112 char name[33]; /* MGID string */
113
114 /* refcount is the reference count for the following:
115 1. Each queued request
116 2. Each invocation of the worker thread
117 3. Membership of the port at the SA
118 */
119 atomic_t refcount;
120
121 /* delayed work to clean pending SM request */
122 struct delayed_work timeout_work;
123 struct list_head cleanup_list;
124 };
125
126 struct mcast_req {
127 int func;
128 struct ib_sa_mad sa_mad;
129 struct list_head group_list;
130 struct list_head func_list;
131 struct mcast_group *group;
132 int clean;
133 };
134
135
136 #define safe_atomic_dec(ref) \
137 do {\
138 if (atomic_dec_and_test(ref)) \
139 mcg_warn_group(group, "did not expect to reach zero\n"); \
140 } while (0)
141
142 static const char *get_state_string(enum mcast_group_state state)
143 {
144 switch (state) {
145 case MCAST_IDLE:
146 return "MCAST_IDLE";
147 case MCAST_JOIN_SENT:
148 return "MCAST_JOIN_SENT";
149 case MCAST_LEAVE_SENT:
150 return "MCAST_LEAVE_SENT";
151 case MCAST_RESP_READY:
152 return "MCAST_RESP_READY";
153 }
154 return "Invalid State";
155 }
156
157 static struct mcast_group *mcast_find(struct mlx4_ib_demux_ctx *ctx,
158 union ib_gid *mgid)
159 {
160 struct rb_node *node = ctx->mcg_table.rb_node;
161 struct mcast_group *group;
162 int ret;
163
164 while (node) {
165 group = rb_entry(node, struct mcast_group, node);
166 ret = memcmp(mgid->raw, group->rec.mgid.raw, sizeof *mgid);
167 if (!ret)
168 return group;
169
170 if (ret < 0)
171 node = node->rb_left;
172 else
173 node = node->rb_right;
174 }
175 return NULL;
176 }
177
178 static struct mcast_group *mcast_insert(struct mlx4_ib_demux_ctx *ctx,
179 struct mcast_group *group)
180 {
181 struct rb_node **link = &ctx->mcg_table.rb_node;
182 struct rb_node *parent = NULL;
183 struct mcast_group *cur_group;
184 int ret;
185
186 while (*link) {
187 parent = *link;
188 cur_group = rb_entry(parent, struct mcast_group, node);
189
190 ret = memcmp(group->rec.mgid.raw, cur_group->rec.mgid.raw,
191 sizeof group->rec.mgid);
192 if (ret < 0)
193 link = &(*link)->rb_left;
194 else if (ret > 0)
195 link = &(*link)->rb_right;
196 else
197 return cur_group;
198 }
199 rb_link_node(&group->node, parent, link);
200 rb_insert_color(&group->node, &ctx->mcg_table);
201 return NULL;
202 }
203
204 static int send_mad_to_wire(struct mlx4_ib_demux_ctx *ctx, struct ib_mad *mad)
205 {
206 struct mlx4_ib_dev *dev = ctx->dev;
207 struct ib_ah_attr ah_attr;
208
209 spin_lock(&dev->sm_lock);
210 if (!dev->sm_ah[ctx->port - 1]) {
211 /* port is not yet Active, sm_ah not ready */
212 spin_unlock(&dev->sm_lock);
213 return -EAGAIN;
214 }
215 mlx4_ib_query_ah(dev->sm_ah[ctx->port - 1], &ah_attr);
216 spin_unlock(&dev->sm_lock);
217 return mlx4_ib_send_to_wire(dev, mlx4_master_func_num(dev->dev), ctx->port,
218 IB_QPT_GSI, 0, 1, IB_QP1_QKEY, &ah_attr, mad);
219 }
220
221 static int send_mad_to_slave(int slave, struct mlx4_ib_demux_ctx *ctx,
222 struct ib_mad *mad)
223 {
224 struct mlx4_ib_dev *dev = ctx->dev;
225 struct ib_mad_agent *agent = dev->send_agent[ctx->port - 1][1];
226 struct ib_wc wc;
227 struct ib_ah_attr ah_attr;
228
229 /* Our agent might not yet be registered when mads start to arrive */
230 if (!agent)
231 return -EAGAIN;
232
233 ib_query_ah(dev->sm_ah[ctx->port - 1], &ah_attr);
234
235 wc.pkey_index = 0;
236 wc.sl = 0;
237 wc.dlid_path_bits = 0;
238 wc.port_num = ctx->port;
239 wc.slid = ah_attr.dlid; /* opensm lid */
240 wc.src_qp = 1;
241 return mlx4_ib_send_to_slave(dev, slave, ctx->port, IB_QPT_GSI, &wc, NULL, mad);
242 }
243
244 static int send_join_to_wire(struct mcast_group *group, struct ib_sa_mad *sa_mad)
245 {
246 struct ib_sa_mad mad;
247 struct ib_sa_mcmember_data *sa_mad_data = (struct ib_sa_mcmember_data *)&mad.data;
248 int ret;
249
250 /* we rely on a mad request as arrived from a VF */
251 memcpy(&mad, sa_mad, sizeof mad);
252
253 /* fix port GID to be the real one (slave 0) */
254 sa_mad_data->port_gid.global.interface_id = group->demux->guid_cache[0];
255
256 /* assign our own TID */
257 mad.mad_hdr.tid = mlx4_ib_get_new_demux_tid(group->demux);
258 group->last_req_tid = mad.mad_hdr.tid; /* keep it for later validation */
259
260 ret = send_mad_to_wire(group->demux, (struct ib_mad *)&mad);
261 /* set timeout handler */
262 if (!ret) {
263 /* calls mlx4_ib_mcg_timeout_handler */
264 queue_delayed_work(group->demux->mcg_wq, &group->timeout_work,
265 msecs_to_jiffies(MAD_TIMEOUT_MS));
266 }
267
268 return ret;
269 }
270
271 static int send_leave_to_wire(struct mcast_group *group, u8 join_state)
272 {
273 struct ib_sa_mad mad;
274 struct ib_sa_mcmember_data *sa_data = (struct ib_sa_mcmember_data *)&mad.data;
275 int ret;
276
277 memset(&mad, 0, sizeof mad);
278 mad.mad_hdr.base_version = 1;
279 mad.mad_hdr.mgmt_class = IB_MGMT_CLASS_SUBN_ADM;
280 mad.mad_hdr.class_version = 2;
281 mad.mad_hdr.method = IB_SA_METHOD_DELETE;
282 mad.mad_hdr.status = cpu_to_be16(0);
283 mad.mad_hdr.class_specific = cpu_to_be16(0);
284 mad.mad_hdr.tid = mlx4_ib_get_new_demux_tid(group->demux);
285 group->last_req_tid = mad.mad_hdr.tid; /* keep it for later validation */
286 mad.mad_hdr.attr_id = cpu_to_be16(IB_SA_ATTR_MC_MEMBER_REC);
287 mad.mad_hdr.attr_mod = cpu_to_be32(0);
288 mad.sa_hdr.sm_key = 0x0;
289 mad.sa_hdr.attr_offset = cpu_to_be16(7);
290 mad.sa_hdr.comp_mask = IB_SA_MCMEMBER_REC_MGID |
291 IB_SA_MCMEMBER_REC_PORT_GID | IB_SA_MCMEMBER_REC_JOIN_STATE;
292
293 *sa_data = group->rec;
294 sa_data->scope_join_state = join_state;
295
296 ret = send_mad_to_wire(group->demux, (struct ib_mad *)&mad);
297 if (ret)
298 group->state = MCAST_IDLE;
299
300 /* set timeout handler */
301 if (!ret) {
302 /* calls mlx4_ib_mcg_timeout_handler */
303 queue_delayed_work(group->demux->mcg_wq, &group->timeout_work,
304 msecs_to_jiffies(MAD_TIMEOUT_MS));
305 }
306
307 return ret;
308 }
309
310 static int send_reply_to_slave(int slave, struct mcast_group *group,
311 struct ib_sa_mad *req_sa_mad, u16 status)
312 {
313 struct ib_sa_mad mad;
314 struct ib_sa_mcmember_data *sa_data = (struct ib_sa_mcmember_data *)&mad.data;
315 struct ib_sa_mcmember_data *req_sa_data = (struct ib_sa_mcmember_data *)&req_sa_mad->data;
316 int ret;
317
318 memset(&mad, 0, sizeof mad);
319 mad.mad_hdr.base_version = 1;
320 mad.mad_hdr.mgmt_class = IB_MGMT_CLASS_SUBN_ADM;
321 mad.mad_hdr.class_version = 2;
322 mad.mad_hdr.method = IB_MGMT_METHOD_GET_RESP;
323 mad.mad_hdr.status = cpu_to_be16(status);
324 mad.mad_hdr.class_specific = cpu_to_be16(0);
325 mad.mad_hdr.tid = req_sa_mad->mad_hdr.tid;
326 *(u8 *)&mad.mad_hdr.tid = 0; /* resetting tid to 0 */
327 mad.mad_hdr.attr_id = cpu_to_be16(IB_SA_ATTR_MC_MEMBER_REC);
328 mad.mad_hdr.attr_mod = cpu_to_be32(0);
329 mad.sa_hdr.sm_key = req_sa_mad->sa_hdr.sm_key;
330 mad.sa_hdr.attr_offset = cpu_to_be16(7);
331 mad.sa_hdr.comp_mask = 0; /* ignored on responses, see IBTA spec */
332
333 *sa_data = group->rec;
334
335 /* reconstruct VF's requested join_state and port_gid */
336 sa_data->scope_join_state &= 0xf0;
337 sa_data->scope_join_state |= (group->func[slave].join_state & 0x0f);
338 memcpy(&sa_data->port_gid, &req_sa_data->port_gid, sizeof req_sa_data->port_gid);
339
340 ret = send_mad_to_slave(slave, group->demux, (struct ib_mad *)&mad);
341 return ret;
342 }
343
344 static int check_selector(ib_sa_comp_mask comp_mask,
345 ib_sa_comp_mask selector_mask,
346 ib_sa_comp_mask value_mask,
347 u8 src_value, u8 dst_value)
348 {
349 int err;
350 u8 selector = dst_value >> 6;
351 dst_value &= 0x3f;
352 src_value &= 0x3f;
353
354 if (!(comp_mask & selector_mask) || !(comp_mask & value_mask))
355 return 0;
356
357 switch (selector) {
358 case IB_SA_GT:
359 err = (src_value <= dst_value);
360 break;
361 case IB_SA_LT:
362 err = (src_value >= dst_value);
363 break;
364 case IB_SA_EQ:
365 err = (src_value != dst_value);
366 break;
367 default:
368 err = 0;
369 break;
370 }
371
372 return err;
373 }
374
375 static u16 cmp_rec(struct ib_sa_mcmember_data *src,
376 struct ib_sa_mcmember_data *dst, ib_sa_comp_mask comp_mask)
377 {
378 /* src is group record, dst is request record */
379 /* MGID must already match */
380 /* Port_GID we always replace to our Port_GID, so it is a match */
381
382 #define MAD_STATUS_REQ_INVALID 0x0200
383 if (comp_mask & IB_SA_MCMEMBER_REC_QKEY && src->qkey != dst->qkey)
384 return MAD_STATUS_REQ_INVALID;
385 if (comp_mask & IB_SA_MCMEMBER_REC_MLID && src->mlid != dst->mlid)
386 return MAD_STATUS_REQ_INVALID;
387 if (check_selector(comp_mask, IB_SA_MCMEMBER_REC_MTU_SELECTOR,
388 IB_SA_MCMEMBER_REC_MTU,
389 src->mtusel_mtu, dst->mtusel_mtu))
390 return MAD_STATUS_REQ_INVALID;
391 if (comp_mask & IB_SA_MCMEMBER_REC_TRAFFIC_CLASS &&
392 src->tclass != dst->tclass)
393 return MAD_STATUS_REQ_INVALID;
394 if (comp_mask & IB_SA_MCMEMBER_REC_PKEY && src->pkey != dst->pkey)
395 return MAD_STATUS_REQ_INVALID;
396 if (check_selector(comp_mask, IB_SA_MCMEMBER_REC_RATE_SELECTOR,
397 IB_SA_MCMEMBER_REC_RATE,
398 src->ratesel_rate, dst->ratesel_rate))
399 return MAD_STATUS_REQ_INVALID;
400 if (check_selector(comp_mask,
401 IB_SA_MCMEMBER_REC_PACKET_LIFE_TIME_SELECTOR,
402 IB_SA_MCMEMBER_REC_PACKET_LIFE_TIME,
403 src->lifetmsel_lifetm, dst->lifetmsel_lifetm))
404 return MAD_STATUS_REQ_INVALID;
405 if (comp_mask & IB_SA_MCMEMBER_REC_SL &&
406 (be32_to_cpu(src->sl_flowlabel_hoplimit) & 0xf0000000) !=
407 (be32_to_cpu(dst->sl_flowlabel_hoplimit) & 0xf0000000))
408 return MAD_STATUS_REQ_INVALID;
409 if (comp_mask & IB_SA_MCMEMBER_REC_FLOW_LABEL &&
410 (be32_to_cpu(src->sl_flowlabel_hoplimit) & 0x0fffff00) !=
411 (be32_to_cpu(dst->sl_flowlabel_hoplimit) & 0x0fffff00))
412 return MAD_STATUS_REQ_INVALID;
413 if (comp_mask & IB_SA_MCMEMBER_REC_HOP_LIMIT &&
414 (be32_to_cpu(src->sl_flowlabel_hoplimit) & 0x000000ff) !=
415 (be32_to_cpu(dst->sl_flowlabel_hoplimit) & 0x000000ff))
416 return MAD_STATUS_REQ_INVALID;
417 if (comp_mask & IB_SA_MCMEMBER_REC_SCOPE &&
418 (src->scope_join_state & 0xf0) !=
419 (dst->scope_join_state & 0xf0))
420 return MAD_STATUS_REQ_INVALID;
421
422 /* join_state checked separately, proxy_join ignored */
423
424 return 0;
425 }
426
427 /* release group, return 1 if this was last release and group is destroyed
428 * timout work is canceled sync */
429 static int release_group(struct mcast_group *group, int from_timeout_handler)
430 {
431 struct mlx4_ib_demux_ctx *ctx = group->demux;
432 int nzgroup;
433
434 mutex_lock(&ctx->mcg_table_lock);
435 mutex_lock(&group->lock);
436 if (atomic_dec_and_test(&group->refcount)) {
437 if (!from_timeout_handler) {
438 if (group->state != MCAST_IDLE &&
439 !cancel_delayed_work(&group->timeout_work)) {
440 atomic_inc(&group->refcount);
441 mutex_unlock(&group->lock);
442 mutex_unlock(&ctx->mcg_table_lock);
443 return 0;
444 }
445 }
446
447 nzgroup = memcmp(&group->rec.mgid, &mgid0, sizeof mgid0);
448 if (!list_empty(&group->pending_list))
449 mcg_warn_group(group, "releasing a group with non empty pending list\n");
450 if (nzgroup)
451 rb_erase(&group->node, &ctx->mcg_table);
452 list_del_init(&group->mgid0_list);
453 mutex_unlock(&group->lock);
454 mutex_unlock(&ctx->mcg_table_lock);
455 kfree(group);
456 return 1;
457 } else {
458 mutex_unlock(&group->lock);
459 mutex_unlock(&ctx->mcg_table_lock);
460 }
461 return 0;
462 }
463
464 static void adjust_membership(struct mcast_group *group, u8 join_state, int inc)
465 {
466 int i;
467
468 for (i = 0; i < 3; i++, join_state >>= 1)
469 if (join_state & 0x1)
470 group->members[i] += inc;
471 }
472
473 static u8 get_leave_state(struct mcast_group *group)
474 {
475 u8 leave_state = 0;
476 int i;
477
478 for (i = 0; i < 3; i++)
479 if (!group->members[i])
480 leave_state |= (1 << i);
481
482 return leave_state & (group->rec.scope_join_state & 7);
483 }
484
485 static int join_group(struct mcast_group *group, int slave, u8 join_mask)
486 {
487 int ret = 0;
488 u8 join_state;
489
490 /* remove bits that slave is already member of, and adjust */
491 join_state = join_mask & (~group->func[slave].join_state);
492 adjust_membership(group, join_state, 1);
493 group->func[slave].join_state |= join_state;
494 if (group->func[slave].state != MCAST_MEMBER && join_state) {
495 group->func[slave].state = MCAST_MEMBER;
496 ret = 1;
497 }
498 return ret;
499 }
500
501 static int leave_group(struct mcast_group *group, int slave, u8 leave_state)
502 {
503 int ret = 0;
504
505 adjust_membership(group, leave_state, -1);
506 group->func[slave].join_state &= ~leave_state;
507 if (!group->func[slave].join_state) {
508 group->func[slave].state = MCAST_NOT_MEMBER;
509 ret = 1;
510 }
511 return ret;
512 }
513
514 static int check_leave(struct mcast_group *group, int slave, u8 leave_mask)
515 {
516 if (group->func[slave].state != MCAST_MEMBER)
517 return MAD_STATUS_REQ_INVALID;
518
519 /* make sure we're not deleting unset bits */
520 if (~group->func[slave].join_state & leave_mask)
521 return MAD_STATUS_REQ_INVALID;
522
523 if (!leave_mask)
524 return MAD_STATUS_REQ_INVALID;
525
526 return 0;
527 }
528
529 static void mlx4_ib_mcg_timeout_handler(struct work_struct *work)
530 {
531 struct delayed_work *delay = to_delayed_work(work);
532 struct mcast_group *group;
533 struct mcast_req *req = NULL;
534
535 group = container_of(delay, typeof(*group), timeout_work);
536
537 mutex_lock(&group->lock);
538 if (group->state == MCAST_JOIN_SENT) {
539 if (!list_empty(&group->pending_list)) {
540 req = list_first_entry(&group->pending_list, struct mcast_req, group_list);
541 list_del(&req->group_list);
542 list_del(&req->func_list);
543 --group->func[req->func].num_pend_reqs;
544 mutex_unlock(&group->lock);
545 kfree(req);
546 if (memcmp(&group->rec.mgid, &mgid0, sizeof mgid0)) {
547 if (release_group(group, 1))
548 return;
549 } else {
550 kfree(group);
551 return;
552 }
553 mutex_lock(&group->lock);
554 } else
555 mcg_warn_group(group, "DRIVER BUG\n");
556 } else if (group->state == MCAST_LEAVE_SENT) {
557 if (group->rec.scope_join_state & 7)
558 group->rec.scope_join_state &= 0xf8;
559 group->state = MCAST_IDLE;
560 mutex_unlock(&group->lock);
561 if (release_group(group, 1))
562 return;
563 mutex_lock(&group->lock);
564 } else
565 mcg_warn_group(group, "invalid state %s\n", get_state_string(group->state));
566 group->state = MCAST_IDLE;
567 atomic_inc(&group->refcount);
568 if (!queue_work(group->demux->mcg_wq, &group->work))
569 safe_atomic_dec(&group->refcount);
570
571 mutex_unlock(&group->lock);
572 }
573
574 static int handle_leave_req(struct mcast_group *group, u8 leave_mask,
575 struct mcast_req *req)
576 {
577 u16 status;
578
579 if (req->clean)
580 leave_mask = group->func[req->func].join_state;
581
582 status = check_leave(group, req->func, leave_mask);
583 if (!status)
584 leave_group(group, req->func, leave_mask);
585
586 if (!req->clean)
587 send_reply_to_slave(req->func, group, &req->sa_mad, status);
588 --group->func[req->func].num_pend_reqs;
589 list_del(&req->group_list);
590 list_del(&req->func_list);
591 kfree(req);
592 return 1;
593 }
594
595 static int handle_join_req(struct mcast_group *group, u8 join_mask,
596 struct mcast_req *req)
597 {
598 u8 group_join_state = group->rec.scope_join_state & 7;
599 int ref = 0;
600 u16 status;
601 struct ib_sa_mcmember_data *sa_data = (struct ib_sa_mcmember_data *)req->sa_mad.data;
602
603 if (join_mask == (group_join_state & join_mask)) {
604 /* port's membership need not change */
605 status = cmp_rec(&group->rec, sa_data, req->sa_mad.sa_hdr.comp_mask);
606 if (!status)
607 join_group(group, req->func, join_mask);
608
609 --group->func[req->func].num_pend_reqs;
610 send_reply_to_slave(req->func, group, &req->sa_mad, status);
611 list_del(&req->group_list);
612 list_del(&req->func_list);
613 kfree(req);
614 ++ref;
615 } else {
616 /* port's membership needs to be updated */
617 group->prev_state = group->state;
618 if (send_join_to_wire(group, &req->sa_mad)) {
619 --group->func[req->func].num_pend_reqs;
620 list_del(&req->group_list);
621 list_del(&req->func_list);
622 kfree(req);
623 ref = 1;
624 group->state = group->prev_state;
625 } else
626 group->state = MCAST_JOIN_SENT;
627 }
628
629 return ref;
630 }
631
632 static void mlx4_ib_mcg_work_handler(struct work_struct *work)
633 {
634 struct mcast_group *group;
635 struct mcast_req *req = NULL;
636 struct ib_sa_mcmember_data *sa_data;
637 u8 req_join_state;
638 int rc = 1; /* release_count - this is for the scheduled work */
639 u16 status;
640 u8 method;
641
642 group = container_of(work, typeof(*group), work);
643
644 mutex_lock(&group->lock);
645
646 /* First, let's see if a response from SM is waiting regarding this group.
647 * If so, we need to update the group's REC. If this is a bad response, we
648 * may need to send a bad response to a VF waiting for it. If VF is waiting
649 * and this is a good response, the VF will be answered later in this func. */
650 if (group->state == MCAST_RESP_READY) {
651 /* cancels mlx4_ib_mcg_timeout_handler */
652 cancel_delayed_work(&group->timeout_work);
653 status = be16_to_cpu(group->response_sa_mad.mad_hdr.status);
654 method = group->response_sa_mad.mad_hdr.method;
655 if (group->last_req_tid != group->response_sa_mad.mad_hdr.tid) {
656 mcg_warn_group(group, "Got MAD response to existing MGID but wrong TID, dropping. Resp TID=%llx, group TID=%llx\n",
657 be64_to_cpu(group->response_sa_mad.mad_hdr.tid),
658 be64_to_cpu(group->last_req_tid));
659 group->state = group->prev_state;
660 goto process_requests;
661 }
662 if (status) {
663 if (!list_empty(&group->pending_list))
664 req = list_first_entry(&group->pending_list,
665 struct mcast_req, group_list);
666 if ((method == IB_MGMT_METHOD_GET_RESP)) {
667 if (req) {
668 send_reply_to_slave(req->func, group, &req->sa_mad, status);
669 --group->func[req->func].num_pend_reqs;
670 list_del(&req->group_list);
671 list_del(&req->func_list);
672 kfree(req);
673 ++rc;
674 } else
675 mcg_warn_group(group, "no request for failed join\n");
676 } else if (method == IB_SA_METHOD_DELETE_RESP && group->demux->flushing)
677 ++rc;
678 } else {
679 u8 resp_join_state;
680 u8 cur_join_state;
681
682 resp_join_state = ((struct ib_sa_mcmember_data *)
683 group->response_sa_mad.data)->scope_join_state & 7;
684 cur_join_state = group->rec.scope_join_state & 7;
685
686 if (method == IB_MGMT_METHOD_GET_RESP) {
687 /* successfull join */
688 if (!cur_join_state && resp_join_state)
689 --rc;
690 } else if (!resp_join_state)
691 ++rc;
692 memcpy(&group->rec, group->response_sa_mad.data, sizeof group->rec);
693 }
694 group->state = MCAST_IDLE;
695 }
696
697 process_requests:
698 /* We should now go over pending join/leave requests, as long as we are idle. */
699 while (!list_empty(&group->pending_list) && group->state == MCAST_IDLE) {
700 req = list_first_entry(&group->pending_list, struct mcast_req,
701 group_list);
702 sa_data = (struct ib_sa_mcmember_data *)req->sa_mad.data;
703 req_join_state = sa_data->scope_join_state & 0x7;
704
705 /* For a leave request, we will immediately answer the VF, and
706 * update our internal counters. The actual leave will be sent
707 * to SM later, if at all needed. We dequeue the request now. */
708 if (req->sa_mad.mad_hdr.method == IB_SA_METHOD_DELETE)
709 rc += handle_leave_req(group, req_join_state, req);
710 else
711 rc += handle_join_req(group, req_join_state, req);
712 }
713
714 /* Handle leaves */
715 if (group->state == MCAST_IDLE) {
716 req_join_state = get_leave_state(group);
717 if (req_join_state) {
718 group->rec.scope_join_state &= ~req_join_state;
719 group->prev_state = group->state;
720 if (send_leave_to_wire(group, req_join_state)) {
721 group->state = group->prev_state;
722 ++rc;
723 } else
724 group->state = MCAST_LEAVE_SENT;
725 }
726 }
727
728 if (!list_empty(&group->pending_list) && group->state == MCAST_IDLE)
729 goto process_requests;
730 mutex_unlock(&group->lock);
731
732 while (rc--)
733 release_group(group, 0);
734 }
735
736 static struct mcast_group *search_relocate_mgid0_group(struct mlx4_ib_demux_ctx *ctx,
737 __be64 tid,
738 union ib_gid *new_mgid)
739 {
740 struct mcast_group *group = NULL, *cur_group;
741 struct mcast_req *req;
742 struct list_head *pos;
743 struct list_head *n;
744
745 mutex_lock(&ctx->mcg_table_lock);
746 list_for_each_safe(pos, n, &ctx->mcg_mgid0_list) {
747 group = list_entry(pos, struct mcast_group, mgid0_list);
748 mutex_lock(&group->lock);
749 if (group->last_req_tid == tid) {
750 if (memcmp(new_mgid, &mgid0, sizeof mgid0)) {
751 group->rec.mgid = *new_mgid;
752 sprintf(group->name, "%016llx%016llx",
753 be64_to_cpu(group->rec.mgid.global.subnet_prefix),
754 be64_to_cpu(group->rec.mgid.global.interface_id));
755 list_del_init(&group->mgid0_list);
756 cur_group = mcast_insert(ctx, group);
757 if (cur_group) {
758 /* A race between our code and SM. Silently cleaning the new one */
759 req = list_first_entry(&group->pending_list,
760 struct mcast_req, group_list);
761 --group->func[req->func].num_pend_reqs;
762 list_del(&req->group_list);
763 list_del(&req->func_list);
764 kfree(req);
765 mutex_unlock(&group->lock);
766 mutex_unlock(&ctx->mcg_table_lock);
767 release_group(group, 0);
768 return NULL;
769 }
770
771 atomic_inc(&group->refcount);
772 mutex_unlock(&group->lock);
773 mutex_unlock(&ctx->mcg_table_lock);
774 return group;
775 } else {
776 struct mcast_req *tmp1, *tmp2;
777
778 list_del(&group->mgid0_list);
779 if (!list_empty(&group->pending_list) && group->state != MCAST_IDLE)
780 cancel_delayed_work_sync(&group->timeout_work);
781
782 list_for_each_entry_safe(tmp1, tmp2, &group->pending_list, group_list) {
783 list_del(&tmp1->group_list);
784 kfree(tmp1);
785 }
786 mutex_unlock(&group->lock);
787 mutex_unlock(&ctx->mcg_table_lock);
788 kfree(group);
789 return NULL;
790 }
791 }
792 mutex_unlock(&group->lock);
793 }
794 mutex_unlock(&ctx->mcg_table_lock);
795
796 return NULL;
797 }
798
799 static struct mcast_group *acquire_group(struct mlx4_ib_demux_ctx *ctx,
800 union ib_gid *mgid, int create,
801 gfp_t gfp_mask)
802 {
803 struct mcast_group *group, *cur_group;
804 int is_mgid0;
805 int i;
806
807 is_mgid0 = !memcmp(&mgid0, mgid, sizeof mgid0);
808 if (!is_mgid0) {
809 group = mcast_find(ctx, mgid);
810 if (group)
811 goto found;
812 }
813
814 if (!create)
815 return ERR_PTR(-ENOENT);
816
817 group = kzalloc(sizeof *group, gfp_mask);
818 if (!group)
819 return ERR_PTR(-ENOMEM);
820
821 group->demux = ctx;
822 group->rec.mgid = *mgid;
823 INIT_LIST_HEAD(&group->pending_list);
824 INIT_LIST_HEAD(&group->mgid0_list);
825 for (i = 0; i < MAX_VFS; ++i)
826 INIT_LIST_HEAD(&group->func[i].pending);
827 INIT_WORK(&group->work, mlx4_ib_mcg_work_handler);
828 INIT_DELAYED_WORK(&group->timeout_work, mlx4_ib_mcg_timeout_handler);
829 mutex_init(&group->lock);
830 sprintf(group->name, "%016llx%016llx",
831 be64_to_cpu(group->rec.mgid.global.subnet_prefix),
832 be64_to_cpu(group->rec.mgid.global.interface_id));
833 group->state = MCAST_IDLE;
834
835 if (is_mgid0) {
836 list_add(&group->mgid0_list, &ctx->mcg_mgid0_list);
837 goto found;
838 }
839
840 cur_group = mcast_insert(ctx, group);
841 if (cur_group) {
842 mcg_warn("group just showed up %s - confused\n", cur_group->name);
843 kfree(group);
844 return ERR_PTR(-EINVAL);
845 }
846
847 found:
848 atomic_inc(&group->refcount);
849 return group;
850 }
851
852 static void queue_req(struct mcast_req *req)
853 {
854 struct mcast_group *group = req->group;
855
856 atomic_inc(&group->refcount); /* for the request */
857 atomic_inc(&group->refcount); /* for scheduling the work */
858 list_add_tail(&req->group_list, &group->pending_list);
859 list_add_tail(&req->func_list, &group->func[req->func].pending);
860 /* calls mlx4_ib_mcg_work_handler */
861 if (!queue_work(group->demux->mcg_wq, &group->work))
862 safe_atomic_dec(&group->refcount);
863 }
864
865 int mlx4_ib_mcg_demux_handler(struct ib_device *ibdev, int port, int slave,
866 struct ib_sa_mad *mad)
867 {
868 struct mlx4_ib_dev *dev = to_mdev(ibdev);
869 struct ib_sa_mcmember_data *rec = (struct ib_sa_mcmember_data *)mad->data;
870 struct mlx4_ib_demux_ctx *ctx = &dev->sriov.demux[port - 1];
871 struct mcast_group *group;
872
873 switch (mad->mad_hdr.method) {
874 case IB_MGMT_METHOD_GET_RESP:
875 case IB_SA_METHOD_DELETE_RESP:
876 mutex_lock(&ctx->mcg_table_lock);
877 group = acquire_group(ctx, &rec->mgid, 0, GFP_KERNEL);
878 mutex_unlock(&ctx->mcg_table_lock);
879 if (IS_ERR(group)) {
880 if (mad->mad_hdr.method == IB_MGMT_METHOD_GET_RESP) {
881 __be64 tid = mad->mad_hdr.tid;
882 *(u8 *)(&tid) = (u8)slave; /* in group we kept the modified TID */
883 group = search_relocate_mgid0_group(ctx, tid, &rec->mgid);
884 } else
885 group = NULL;
886 }
887
888 if (!group)
889 return 1;
890
891 mutex_lock(&group->lock);
892 group->response_sa_mad = *mad;
893 group->prev_state = group->state;
894 group->state = MCAST_RESP_READY;
895 /* calls mlx4_ib_mcg_work_handler */
896 atomic_inc(&group->refcount);
897 if (!queue_work(ctx->mcg_wq, &group->work))
898 safe_atomic_dec(&group->refcount);
899 mutex_unlock(&group->lock);
900 release_group(group, 0);
901 return 1; /* consumed */
902 case IB_MGMT_METHOD_SET:
903 case IB_SA_METHOD_GET_TABLE:
904 case IB_SA_METHOD_GET_TABLE_RESP:
905 case IB_SA_METHOD_DELETE:
906 return 0; /* not consumed, pass-through to guest over tunnel */
907 default:
908 mcg_warn("In demux, port %d: unexpected MCMember method: 0x%x, dropping\n",
909 port, mad->mad_hdr.method);
910 return 1; /* consumed */
911 }
912 }
913
914 int mlx4_ib_mcg_multiplex_handler(struct ib_device *ibdev, int port,
915 int slave, struct ib_sa_mad *sa_mad)
916 {
917 struct mlx4_ib_dev *dev = to_mdev(ibdev);
918 struct ib_sa_mcmember_data *rec = (struct ib_sa_mcmember_data *)sa_mad->data;
919 struct mlx4_ib_demux_ctx *ctx = &dev->sriov.demux[port - 1];
920 struct mcast_group *group;
921 struct mcast_req *req;
922 int may_create = 0;
923
924 if (ctx->flushing)
925 return -EAGAIN;
926
927 switch (sa_mad->mad_hdr.method) {
928 case IB_MGMT_METHOD_SET:
929 may_create = 1;
930 case IB_SA_METHOD_DELETE:
931 req = kzalloc(sizeof *req, GFP_KERNEL);
932 if (!req)
933 return -ENOMEM;
934
935 req->func = slave;
936 req->sa_mad = *sa_mad;
937
938 mutex_lock(&ctx->mcg_table_lock);
939 group = acquire_group(ctx, &rec->mgid, may_create, GFP_KERNEL);
940 mutex_unlock(&ctx->mcg_table_lock);
941 if (IS_ERR(group)) {
942 kfree(req);
943 return PTR_ERR(group);
944 }
945 mutex_lock(&group->lock);
946 if (group->func[slave].num_pend_reqs > MAX_PEND_REQS_PER_FUNC) {
947 mutex_unlock(&group->lock);
948 mcg_warn_group(group, "Port %d, Func %d has too many pending requests (%d), dropping\n",
949 port, slave, MAX_PEND_REQS_PER_FUNC);
950 release_group(group, 0);
951 kfree(req);
952 return -ENOMEM;
953 }
954 ++group->func[slave].num_pend_reqs;
955 req->group = group;
956 queue_req(req);
957 mutex_unlock(&group->lock);
958 release_group(group, 0);
959 return 1; /* consumed */
960 case IB_SA_METHOD_GET_TABLE:
961 case IB_MGMT_METHOD_GET_RESP:
962 case IB_SA_METHOD_GET_TABLE_RESP:
963 case IB_SA_METHOD_DELETE_RESP:
964 return 0; /* not consumed, pass-through */
965 default:
966 mcg_warn("In multiplex, port %d, func %d: unexpected MCMember method: 0x%x, dropping\n",
967 port, slave, sa_mad->mad_hdr.method);
968 return 1; /* consumed */
969 }
970 }
971
972 int mlx4_ib_mcg_port_init(struct mlx4_ib_demux_ctx *ctx)
973 {
974 char name[20];
975
976 atomic_set(&ctx->tid, 0);
977 sprintf(name, "mlx4_ib_mcg%d", ctx->port);
978 ctx->mcg_wq = create_singlethread_workqueue(name);
979 if (!ctx->mcg_wq)
980 return -ENOMEM;
981
982 mutex_init(&ctx->mcg_table_lock);
983 ctx->mcg_table = RB_ROOT;
984 INIT_LIST_HEAD(&ctx->mcg_mgid0_list);
985 ctx->flushing = 0;
986
987 return 0;
988 }
989
990 static void force_clean_group(struct mcast_group *group)
991 {
992 struct mcast_req *req, *tmp
993 ;
994 list_for_each_entry_safe(req, tmp, &group->pending_list, group_list) {
995 list_del(&req->group_list);
996 kfree(req);
997 }
998 rb_erase(&group->node, &group->demux->mcg_table);
999 kfree(group);
1000 }
1001
1002 static void _mlx4_ib_mcg_port_cleanup(struct mlx4_ib_demux_ctx *ctx, int destroy_wq)
1003 {
1004 int i;
1005 struct rb_node *p;
1006 struct mcast_group *group;
1007 unsigned long end;
1008 int count;
1009
1010 if (ctx->flushing)
1011 return;
1012
1013 ctx->flushing = 1;
1014 for (i = 0; i < MAX_VFS; ++i)
1015 clean_vf_mcast(ctx, i);
1016
1017 end = jiffies + msecs_to_jiffies(MAD_TIMEOUT_MS + 3000);
1018 do {
1019 count = 0;
1020 mutex_lock(&ctx->mcg_table_lock);
1021 for (p = rb_first(&ctx->mcg_table); p; p = rb_next(p))
1022 ++count;
1023 mutex_unlock(&ctx->mcg_table_lock);
1024 if (!count)
1025 break;
1026
1027 msleep(1);
1028 } while (time_after(end, jiffies));
1029
1030 flush_workqueue(ctx->mcg_wq);
1031 if (destroy_wq)
1032 destroy_workqueue(ctx->mcg_wq);
1033
1034 mutex_lock(&ctx->mcg_table_lock);
1035 while ((p = rb_first(&ctx->mcg_table)) != NULL) {
1036 group = rb_entry(p, struct mcast_group, node);
1037 if (atomic_read(&group->refcount))
1038 mcg_warn_group(group, "group refcount %d!!! (pointer %p)\n", atomic_read(&group->refcount), group);
1039
1040 force_clean_group(group);
1041 }
1042 mutex_unlock(&ctx->mcg_table_lock);
1043
1044 if (!destroy_wq)
1045 ctx->flushing = 0;
1046 }
1047
1048 struct clean_work {
1049 struct work_struct work;
1050 struct mlx4_ib_demux_ctx *ctx;
1051 int destroy_wq;
1052 };
1053
1054 static void mcg_clean_task(struct work_struct *work)
1055 {
1056 struct clean_work *cw = container_of(work, struct clean_work, work);
1057
1058 _mlx4_ib_mcg_port_cleanup(cw->ctx, cw->destroy_wq);
1059 kfree(cw);
1060 }
1061
1062 void mlx4_ib_mcg_port_cleanup(struct mlx4_ib_demux_ctx *ctx, int destroy_wq)
1063 {
1064 struct clean_work *work;
1065
1066 if (destroy_wq) {
1067 _mlx4_ib_mcg_port_cleanup(ctx, destroy_wq);
1068 return;
1069 }
1070
1071 work = kmalloc(sizeof *work, GFP_KERNEL);
1072 if (!work) {
1073 mcg_warn("failed allocating work for cleanup\n");
1074 return;
1075 }
1076
1077 work->ctx = ctx;
1078 work->destroy_wq = destroy_wq;
1079 INIT_WORK(&work->work, mcg_clean_task);
1080 queue_work(clean_wq, &work->work);
1081 }
1082
1083 static void build_leave_mad(struct mcast_req *req)
1084 {
1085 struct ib_sa_mad *mad = &req->sa_mad;
1086
1087 mad->mad_hdr.method = IB_SA_METHOD_DELETE;
1088 }
1089
1090
1091 static void clear_pending_reqs(struct mcast_group *group, int vf)
1092 {
1093 struct mcast_req *req, *tmp, *group_first = NULL;
1094 int clear;
1095 int pend = 0;
1096
1097 if (!list_empty(&group->pending_list))
1098 group_first = list_first_entry(&group->pending_list, struct mcast_req, group_list);
1099
1100 list_for_each_entry_safe(req, tmp, &group->func[vf].pending, func_list) {
1101 clear = 1;
1102 if (group_first == req &&
1103 (group->state == MCAST_JOIN_SENT ||
1104 group->state == MCAST_LEAVE_SENT)) {
1105 clear = cancel_delayed_work(&group->timeout_work);
1106 pend = !clear;
1107 group->state = MCAST_IDLE;
1108 }
1109 if (clear) {
1110 --group->func[vf].num_pend_reqs;
1111 list_del(&req->group_list);
1112 list_del(&req->func_list);
1113 kfree(req);
1114 atomic_dec(&group->refcount);
1115 }
1116 }
1117
1118 if (!pend && (!list_empty(&group->func[vf].pending) || group->func[vf].num_pend_reqs)) {
1119 mcg_warn_group(group, "DRIVER BUG: list_empty %d, num_pend_reqs %d\n",
1120 list_empty(&group->func[vf].pending), group->func[vf].num_pend_reqs);
1121 }
1122 }
1123
1124 static int push_deleteing_req(struct mcast_group *group, int slave)
1125 {
1126 struct mcast_req *req;
1127 struct mcast_req *pend_req;
1128
1129 if (!group->func[slave].join_state)
1130 return 0;
1131
1132 req = kzalloc(sizeof *req, GFP_KERNEL);
1133 if (!req) {
1134 mcg_warn_group(group, "failed allocation - may leave stall groups\n");
1135 return -ENOMEM;
1136 }
1137
1138 if (!list_empty(&group->func[slave].pending)) {
1139 pend_req = list_entry(group->func[slave].pending.prev, struct mcast_req, group_list);
1140 if (pend_req->clean) {
1141 kfree(req);
1142 return 0;
1143 }
1144 }
1145
1146 req->clean = 1;
1147 req->func = slave;
1148 req->group = group;
1149 ++group->func[slave].num_pend_reqs;
1150 build_leave_mad(req);
1151 queue_req(req);
1152 return 0;
1153 }
1154
1155 void clean_vf_mcast(struct mlx4_ib_demux_ctx *ctx, int slave)
1156 {
1157 struct mcast_group *group;
1158 struct rb_node *p;
1159
1160 mutex_lock(&ctx->mcg_table_lock);
1161 for (p = rb_first(&ctx->mcg_table); p; p = rb_next(p)) {
1162 group = rb_entry(p, struct mcast_group, node);
1163 mutex_lock(&group->lock);
1164 if (atomic_read(&group->refcount)) {
1165 /* clear pending requests of this VF */
1166 clear_pending_reqs(group, slave);
1167 push_deleteing_req(group, slave);
1168 }
1169 mutex_unlock(&group->lock);
1170 }
1171 mutex_unlock(&ctx->mcg_table_lock);
1172 }
1173
1174
1175 int mlx4_ib_mcg_init(void)
1176 {
1177 clean_wq = create_singlethread_workqueue("mlx4_ib_mcg");
1178 if (!clean_wq)
1179 return -ENOMEM;
1180
1181 return 0;
1182 }
1183
1184 void mlx4_ib_mcg_destroy(void)
1185 {
1186 destroy_workqueue(clean_wq);
1187 }
Linux kernel - Deliverables
This page took 0.055871 seconds and 5 git commands to generate.