1 // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
2 /*
3 * Copyright (c) 2016 Mellanox Technologies Ltd. All rights reserved.
4 * Copyright (c) 2015 System Fabric Works, Inc. All rights reserved.
5 */
6
7 #include "rxe.h"
8 #include "rxe_loc.h"
9
10 /* caller should hold mc_grp_pool->pool_lock */
create_grp(struct rxe_dev * rxe,struct rxe_pool * pool,union ib_gid * mgid)11 static struct rxe_mc_grp *create_grp(struct rxe_dev *rxe,
12 struct rxe_pool *pool,
13 union ib_gid *mgid)
14 {
15 int err;
16 struct rxe_mc_grp *grp;
17
18 grp = rxe_alloc_locked(&rxe->mc_grp_pool);
19 if (!grp)
20 return ERR_PTR(-ENOMEM);
21
22 INIT_LIST_HEAD(&grp->qp_list);
23 spin_lock_init(&grp->mcg_lock);
24 grp->rxe = rxe;
25 rxe_add_key_locked(grp, mgid);
26
27 err = rxe_mcast_add(rxe, mgid);
28 if (unlikely(err)) {
29 rxe_drop_key_locked(grp);
30 rxe_drop_ref(grp);
31 return ERR_PTR(err);
32 }
33
34 return grp;
35 }
36
rxe_mcast_get_grp(struct rxe_dev * rxe,union ib_gid * mgid,struct rxe_mc_grp ** grp_p)37 int rxe_mcast_get_grp(struct rxe_dev *rxe, union ib_gid *mgid,
38 struct rxe_mc_grp **grp_p)
39 {
40 int err;
41 struct rxe_mc_grp *grp;
42 struct rxe_pool *pool = &rxe->mc_grp_pool;
43 unsigned long flags;
44
45 if (rxe->attr.max_mcast_qp_attach == 0)
46 return -EINVAL;
47
48 write_lock_irqsave(&pool->pool_lock, flags);
49
50 grp = rxe_pool_get_key_locked(pool, mgid);
51 if (grp)
52 goto done;
53
54 grp = create_grp(rxe, pool, mgid);
55 if (IS_ERR(grp)) {
56 write_unlock_irqrestore(&pool->pool_lock, flags);
57 err = PTR_ERR(grp);
58 return err;
59 }
60
61 done:
62 write_unlock_irqrestore(&pool->pool_lock, flags);
63 *grp_p = grp;
64 return 0;
65 }
66
rxe_mcast_add_grp_elem(struct rxe_dev * rxe,struct rxe_qp * qp,struct rxe_mc_grp * grp)67 int rxe_mcast_add_grp_elem(struct rxe_dev *rxe, struct rxe_qp *qp,
68 struct rxe_mc_grp *grp)
69 {
70 int err;
71 struct rxe_mc_elem *elem;
72
73 /* check to see of the qp is already a member of the group */
74 spin_lock_bh(&qp->grp_lock);
75 spin_lock_bh(&grp->mcg_lock);
76 list_for_each_entry(elem, &grp->qp_list, qp_list) {
77 if (elem->qp == qp) {
78 err = 0;
79 goto out;
80 }
81 }
82
83 if (grp->num_qp >= rxe->attr.max_mcast_qp_attach) {
84 err = -ENOMEM;
85 goto out;
86 }
87
88 elem = rxe_alloc_locked(&rxe->mc_elem_pool);
89 if (!elem) {
90 err = -ENOMEM;
91 goto out;
92 }
93
94 /* each qp holds a ref on the grp */
95 rxe_add_ref(grp);
96
97 grp->num_qp++;
98 elem->qp = qp;
99 elem->grp = grp;
100
101 list_add(&elem->qp_list, &grp->qp_list);
102 list_add(&elem->grp_list, &qp->grp_list);
103
104 err = 0;
105 out:
106 spin_unlock_bh(&grp->mcg_lock);
107 spin_unlock_bh(&qp->grp_lock);
108 return err;
109 }
110
rxe_mcast_drop_grp_elem(struct rxe_dev * rxe,struct rxe_qp * qp,union ib_gid * mgid)111 int rxe_mcast_drop_grp_elem(struct rxe_dev *rxe, struct rxe_qp *qp,
112 union ib_gid *mgid)
113 {
114 struct rxe_mc_grp *grp;
115 struct rxe_mc_elem *elem, *tmp;
116
117 grp = rxe_pool_get_key(&rxe->mc_grp_pool, mgid);
118 if (!grp)
119 goto err1;
120
121 spin_lock_bh(&qp->grp_lock);
122 spin_lock_bh(&grp->mcg_lock);
123
124 list_for_each_entry_safe(elem, tmp, &grp->qp_list, qp_list) {
125 if (elem->qp == qp) {
126 list_del(&elem->qp_list);
127 list_del(&elem->grp_list);
128 grp->num_qp--;
129
130 spin_unlock_bh(&grp->mcg_lock);
131 spin_unlock_bh(&qp->grp_lock);
132 rxe_drop_ref(elem);
133 rxe_drop_ref(grp); /* ref held by QP */
134 rxe_drop_ref(grp); /* ref from get_key */
135 return 0;
136 }
137 }
138
139 spin_unlock_bh(&grp->mcg_lock);
140 spin_unlock_bh(&qp->grp_lock);
141 rxe_drop_ref(grp); /* ref from get_key */
142 err1:
143 return -EINVAL;
144 }
145
rxe_drop_all_mcast_groups(struct rxe_qp * qp)146 void rxe_drop_all_mcast_groups(struct rxe_qp *qp)
147 {
148 struct rxe_mc_grp *grp;
149 struct rxe_mc_elem *elem;
150
151 while (1) {
152 spin_lock_bh(&qp->grp_lock);
153 if (list_empty(&qp->grp_list)) {
154 spin_unlock_bh(&qp->grp_lock);
155 break;
156 }
157 elem = list_first_entry(&qp->grp_list, struct rxe_mc_elem,
158 grp_list);
159 list_del(&elem->grp_list);
160 spin_unlock_bh(&qp->grp_lock);
161
162 grp = elem->grp;
163 spin_lock_bh(&grp->mcg_lock);
164 list_del(&elem->qp_list);
165 grp->num_qp--;
166 spin_unlock_bh(&grp->mcg_lock);
167 rxe_drop_ref(grp);
168 rxe_drop_ref(elem);
169 }
170 }
171
rxe_mc_cleanup(struct rxe_pool_entry * arg)172 void rxe_mc_cleanup(struct rxe_pool_entry *arg)
173 {
174 struct rxe_mc_grp *grp = container_of(arg, typeof(*grp), pelem);
175 struct rxe_dev *rxe = grp->rxe;
176
177 rxe_drop_key(grp);
178 rxe_mcast_delete(rxe, &grp->mgid);
179 }
180