projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
IB/mlx4: Request alias GUID on demand
[deliverable/linux.git] / drivers / infiniband / hw / mlx4 / alias_GUID.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 /*This file support the handling of the Alias GUID feature. */
34 /***********************************************************/
35 #include <rdma/ib_mad.h>
36 #include <rdma/ib_smi.h>
37 #include <rdma/ib_cache.h>
38 #include <rdma/ib_sa.h>
39 #include <rdma/ib_pack.h>
40 #include <linux/mlx4/cmd.h>
41 #include <linux/module.h>
42 #include <linux/init.h>
43 #include <linux/errno.h>
44 #include <rdma/ib_user_verbs.h>
45 #include <linux/delay.h>
46 #include "mlx4_ib.h"
47
48 /*
49 The driver keeps the current state of all guids, as they are in the HW.
50 Whenever we receive an smp mad GUIDInfo record, the data will be cached.
51 */
52
53 struct mlx4_alias_guid_work_context {
54 u8 port;
55 struct mlx4_ib_dev *dev ;
56 struct ib_sa_query *sa_query;
57 struct completion done;
58 int query_id;
59 struct list_head list;
60 int block_num;
61 ib_sa_comp_mask guid_indexes;
62 u8 method;
63 };
64
65 struct mlx4_next_alias_guid_work {
66 u8 port;
67 u8 block_num;
68 u8 method;
69 struct mlx4_sriov_alias_guid_info_rec_det rec_det;
70 };
71
72 static int get_low_record_time_index(struct mlx4_ib_dev *dev, u8 port,
73 int *resched_delay_sec);
74
75 void mlx4_ib_update_cache_on_guid_change(struct mlx4_ib_dev *dev, int block_num,
76 u8 port_num, u8 *p_data)
77 {
78 int i;
79 u64 guid_indexes;
80 int slave_id;
81 int port_index = port_num - 1;
82
83 if (!mlx4_is_master(dev->dev))
84 return;
85
86 guid_indexes = be64_to_cpu((__force __be64) dev->sriov.alias_guid.
87 ports_guid[port_num - 1].
88 all_rec_per_port[block_num].guid_indexes);
89 pr_debug("port: %d, guid_indexes: 0x%llx\n", port_num, guid_indexes);
90
91 for (i = 0; i < NUM_ALIAS_GUID_IN_REC; i++) {
92 /* The location of the specific index starts from bit number 4
93 * until bit num 11 */
94 if (test_bit(i + 4, (unsigned long *)&guid_indexes)) {
95 slave_id = (block_num * NUM_ALIAS_GUID_IN_REC) + i ;
96 if (slave_id >= dev->dev->num_slaves) {
97 pr_debug("The last slave: %d\n", slave_id);
98 return;
99 }
100
101 /* cache the guid: */
102 memcpy(&dev->sriov.demux[port_index].guid_cache[slave_id],
103 &p_data[i * GUID_REC_SIZE],
104 GUID_REC_SIZE);
105 } else
106 pr_debug("Guid number: %d in block: %d"
107 " was not updated\n", i, block_num);
108 }
109 }
110
111 static __be64 get_cached_alias_guid(struct mlx4_ib_dev *dev, int port, int index)
112 {
113 if (index >= NUM_ALIAS_GUID_PER_PORT) {
114 pr_err("%s: ERROR: asked for index:%d\n", __func__, index);
115 return (__force __be64) -1;
116 }
117 return *(__be64 *)&dev->sriov.demux[port - 1].guid_cache[index];
118 }
119
120
121 ib_sa_comp_mask mlx4_ib_get_aguid_comp_mask_from_ix(int index)
122 {
123 return IB_SA_COMP_MASK(4 + index);
124 }
125
126 void mlx4_ib_slave_alias_guid_event(struct mlx4_ib_dev *dev, int slave,
127 int port, int slave_init)
128 {
129 __be64 curr_guid, required_guid;
130 int record_num = slave / 8;
131 int index = slave % 8;
132 int port_index = port - 1;
133 unsigned long flags;
134 int do_work = 0;
135
136 spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags);
137 if (dev->sriov.alias_guid.ports_guid[port_index].state_flags &
138 GUID_STATE_NEED_PORT_INIT)
139 goto unlock;
140 if (!slave_init) {
141 curr_guid = *(__be64 *)&dev->sriov.
142 alias_guid.ports_guid[port_index].
143 all_rec_per_port[record_num].
144 all_recs[GUID_REC_SIZE * index];
145 if (curr_guid == cpu_to_be64(MLX4_GUID_FOR_DELETE_VAL) ||
146 !curr_guid)
147 goto unlock;
148 required_guid = cpu_to_be64(MLX4_GUID_FOR_DELETE_VAL);
149 } else {
150 required_guid = mlx4_get_admin_guid(dev->dev, slave, port);
151 if (required_guid == cpu_to_be64(MLX4_GUID_FOR_DELETE_VAL))
152 goto unlock;
153 }
154 *(__be64 *)&dev->sriov.alias_guid.ports_guid[port_index].
155 all_rec_per_port[record_num].
156 all_recs[GUID_REC_SIZE * index] = required_guid;
157 dev->sriov.alias_guid.ports_guid[port_index].
158 all_rec_per_port[record_num].guid_indexes
159 |= mlx4_ib_get_aguid_comp_mask_from_ix(index);
160 dev->sriov.alias_guid.ports_guid[port_index].
161 all_rec_per_port[record_num].status
162 = MLX4_GUID_INFO_STATUS_IDLE;
163 /* set to run immediately */
164 dev->sriov.alias_guid.ports_guid[port_index].
165 all_rec_per_port[record_num].time_to_run = 0;
166 dev->sriov.alias_guid.ports_guid[port_index].
167 all_rec_per_port[record_num].
168 guids_retry_schedule[index] = 0;
169 do_work = 1;
170 unlock:
171 spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags);
172
173 if (do_work)
174 mlx4_ib_init_alias_guid_work(dev, port_index);
175 }
176
177 /*
178 * Whenever new GUID is set/unset (guid table change) create event and
179 * notify the relevant slave (master also should be notified).
180 * If the GUID value is not as we have in the cache the slave will not be
181 * updated; in this case it waits for the smp_snoop or the port management
182 * event to call the function and to update the slave.
183 * block_number - the index of the block (16 blocks available)
184 * port_number - 1 or 2
185 */
186 void mlx4_ib_notify_slaves_on_guid_change(struct mlx4_ib_dev *dev,
187 int block_num, u8 port_num,
188 u8 *p_data)
189 {
190 int i;
191 u64 guid_indexes;
192 int slave_id;
193 enum slave_port_state new_state;
194 enum slave_port_state prev_state;
195 __be64 tmp_cur_ag, form_cache_ag;
196 enum slave_port_gen_event gen_event;
197 struct mlx4_sriov_alias_guid_info_rec_det *rec;
198 unsigned long flags;
199 __be64 required_value;
200
201 if (!mlx4_is_master(dev->dev))
202 return;
203
204 rec = &dev->sriov.alias_guid.ports_guid[port_num - 1].
205 all_rec_per_port[block_num];
206 guid_indexes = be64_to_cpu((__force __be64) dev->sriov.alias_guid.
207 ports_guid[port_num - 1].
208 all_rec_per_port[block_num].guid_indexes);
209 pr_debug("port: %d, guid_indexes: 0x%llx\n", port_num, guid_indexes);
210
211 /*calculate the slaves and notify them*/
212 for (i = 0; i < NUM_ALIAS_GUID_IN_REC; i++) {
213 /* the location of the specific index runs from bits 4..11 */
214 if (!(test_bit(i + 4, (unsigned long *)&guid_indexes)))
215 continue;
216
217 slave_id = (block_num * NUM_ALIAS_GUID_IN_REC) + i ;
218 if (slave_id >= dev->dev->persist->num_vfs + 1)
219 return;
220 tmp_cur_ag = *(__be64 *)&p_data[i * GUID_REC_SIZE];
221 form_cache_ag = get_cached_alias_guid(dev, port_num,
222 (NUM_ALIAS_GUID_IN_REC * block_num) + i);
223 /*
224 * Check if guid is not the same as in the cache,
225 * If it is different, wait for the snoop_smp or the port mgmt
226 * change event to update the slave on its port state change
227 */
228 if (tmp_cur_ag != form_cache_ag)
229 continue;
230
231 spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags);
232 required_value = *(__be64 *)&rec->all_recs[i * GUID_REC_SIZE];
233
234 if (required_value == cpu_to_be64(MLX4_GUID_FOR_DELETE_VAL))
235 required_value = 0;
236
237 if (tmp_cur_ag == required_value) {
238 rec->guid_indexes = rec->guid_indexes &
239 ~mlx4_ib_get_aguid_comp_mask_from_ix(i);
240 } else {
241 /* may notify port down if value is 0 */
242 if (tmp_cur_ag != MLX4_NOT_SET_GUID) {
243 spin_unlock_irqrestore(&dev->sriov.
244 alias_guid.ag_work_lock, flags);
245 continue;
246 }
247 }
248 spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock,
249 flags);
250 mlx4_gen_guid_change_eqe(dev->dev, slave_id, port_num);
251 /*2 cases: Valid GUID, and Invalid Guid*/
252
253 if (tmp_cur_ag != MLX4_NOT_SET_GUID) { /*valid GUID*/
254 prev_state = mlx4_get_slave_port_state(dev->dev, slave_id, port_num);
255 new_state = set_and_calc_slave_port_state(dev->dev, slave_id, port_num,
256 MLX4_PORT_STATE_IB_PORT_STATE_EVENT_GID_VALID,
257 &gen_event);
258 pr_debug("slave: %d, port: %d prev_port_state: %d,"
259 " new_port_state: %d, gen_event: %d\n",
260 slave_id, port_num, prev_state, new_state, gen_event);
261 if (gen_event == SLAVE_PORT_GEN_EVENT_UP) {
262 pr_debug("sending PORT_UP event to slave: %d, port: %d\n",
263 slave_id, port_num);
264 mlx4_gen_port_state_change_eqe(dev->dev, slave_id,
265 port_num, MLX4_PORT_CHANGE_SUBTYPE_ACTIVE);
266 }
267 } else { /* request to invalidate GUID */
268 set_and_calc_slave_port_state(dev->dev, slave_id, port_num,
269 MLX4_PORT_STATE_IB_EVENT_GID_INVALID,
270 &gen_event);
271 if (gen_event == SLAVE_PORT_GEN_EVENT_DOWN) {
272 pr_debug("sending PORT DOWN event to slave: %d, port: %d\n",
273 slave_id, port_num);
274 mlx4_gen_port_state_change_eqe(dev->dev,
275 slave_id,
276 port_num,
277 MLX4_PORT_CHANGE_SUBTYPE_DOWN);
278 }
279 }
280 }
281 }
282
283 static void aliasguid_query_handler(int status,
284 struct ib_sa_guidinfo_rec *guid_rec,
285 void *context)
286 {
287 struct mlx4_ib_dev *dev;
288 struct mlx4_alias_guid_work_context *cb_ctx = context;
289 u8 port_index ;
290 int i;
291 struct mlx4_sriov_alias_guid_info_rec_det *rec;
292 unsigned long flags, flags1;
293 ib_sa_comp_mask declined_guid_indexes = 0;
294 ib_sa_comp_mask applied_guid_indexes = 0;
295 unsigned int resched_delay_sec = 0;
296
297 if (!context)
298 return;
299
300 dev = cb_ctx->dev;
301 port_index = cb_ctx->port - 1;
302 rec = &dev->sriov.alias_guid.ports_guid[port_index].
303 all_rec_per_port[cb_ctx->block_num];
304
305 if (status) {
306 pr_debug("(port: %d) failed: status = %d\n",
307 cb_ctx->port, status);
308 rec->time_to_run = ktime_get_real_ns() + 1 * NSEC_PER_SEC;
309 goto out;
310 }
311
312 if (guid_rec->block_num != cb_ctx->block_num) {
313 pr_err("block num mismatch: %d != %d\n",
314 cb_ctx->block_num, guid_rec->block_num);
315 goto out;
316 }
317
318 pr_debug("lid/port: %d/%d, block_num: %d\n",
319 be16_to_cpu(guid_rec->lid), cb_ctx->port,
320 guid_rec->block_num);
321
322 rec = &dev->sriov.alias_guid.ports_guid[port_index].
323 all_rec_per_port[guid_rec->block_num];
324
325 spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags);
326 for (i = 0 ; i < NUM_ALIAS_GUID_IN_REC; i++) {
327 __be64 sm_response, required_val;
328
329 if (!(cb_ctx->guid_indexes &
330 mlx4_ib_get_aguid_comp_mask_from_ix(i)))
331 continue;
332 sm_response = *(__be64 *)&guid_rec->guid_info_list
333 [i * GUID_REC_SIZE];
334 required_val = *(__be64 *)&rec->all_recs[i * GUID_REC_SIZE];
335 if (cb_ctx->method == MLX4_GUID_INFO_RECORD_DELETE) {
336 if (required_val ==
337 cpu_to_be64(MLX4_GUID_FOR_DELETE_VAL))
338 goto next_entry;
339
340 /* A new value was set till we got the response */
341 pr_debug("need to set new value %llx, record num %d, block_num:%d\n",
342 be64_to_cpu(required_val),
343 i, guid_rec->block_num);
344 goto entry_declined;
345 }
346
347 /* check if the SM didn't assign one of the records.
348 * if it didn't, re-ask for.
349 */
350 if (sm_response == MLX4_NOT_SET_GUID) {
351 if (rec->guids_retry_schedule[i] == 0)
352 mlx4_ib_warn(&dev->ib_dev,
353 "%s:Record num %d in block_num: %d was declined by SM\n",
354 __func__, i,
355 guid_rec->block_num);
356 goto entry_declined;
357 } else {
358 /* properly assigned record. */
359 /* We save the GUID we just got from the SM in the
360 * admin_guid in order to be persistent, and in the
361 * request from the sm the process will ask for the same GUID */
362 if (required_val &&
363 sm_response != required_val) {
364 /* Warn only on first retry */
365 if (rec->guids_retry_schedule[i] == 0)
366 mlx4_ib_warn(&dev->ib_dev, "%s: Failed to set"
367 " admin guid after SysAdmin "
368 "configuration. "
369 "Record num %d in block_num:%d "
370 "was declined by SM, "
371 "new val(0x%llx) was kept, SM returned (0x%llx)\n",
372 __func__, i,
373 guid_rec->block_num,
374 be64_to_cpu(required_val),
375 be64_to_cpu(sm_response));
376 goto entry_declined;
377 } else {
378 *(__be64 *)&rec->all_recs[i * GUID_REC_SIZE] =
379 sm_response;
380 if (required_val == 0)
381 mlx4_set_admin_guid(dev->dev,
382 sm_response,
383 (guid_rec->block_num
384 * NUM_ALIAS_GUID_IN_REC) + i,
385 cb_ctx->port);
386 goto next_entry;
387 }
388 }
389 entry_declined:
390 declined_guid_indexes |= mlx4_ib_get_aguid_comp_mask_from_ix(i);
391 rec->guids_retry_schedule[i] =
392 (rec->guids_retry_schedule[i] == 0) ? 1 :
393 min((unsigned int)60,
394 rec->guids_retry_schedule[i] * 2);
395 /* using the minimum value among all entries in that record */
396 resched_delay_sec = (resched_delay_sec == 0) ?
397 rec->guids_retry_schedule[i] :
398 min(resched_delay_sec,
399 rec->guids_retry_schedule[i]);
400 continue;
401
402 next_entry:
403 rec->guids_retry_schedule[i] = 0;
404 }
405
406 applied_guid_indexes = cb_ctx->guid_indexes & ~declined_guid_indexes;
407 if (declined_guid_indexes ||
408 rec->guid_indexes & ~(applied_guid_indexes)) {
409 pr_debug("record=%d wasn't fully set, guid_indexes=0x%llx applied_indexes=0x%llx, declined_indexes=0x%llx\n",
410 guid_rec->block_num,
411 be64_to_cpu((__force __be64)rec->guid_indexes),
412 be64_to_cpu((__force __be64)applied_guid_indexes),
413 be64_to_cpu((__force __be64)declined_guid_indexes));
414 rec->time_to_run = ktime_get_real_ns() +
415 resched_delay_sec * NSEC_PER_SEC;
416 } else {
417 rec->status = MLX4_GUID_INFO_STATUS_SET;
418 }
419 spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags);
420 /*
421 The func is call here to close the cases when the
422 sm doesn't send smp, so in the sa response the driver
423 notifies the slave.
424 */
425 mlx4_ib_notify_slaves_on_guid_change(dev, guid_rec->block_num,
426 cb_ctx->port,
427 guid_rec->guid_info_list);
428 out:
429 spin_lock_irqsave(&dev->sriov.going_down_lock, flags);
430 spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags1);
431 if (!dev->sriov.is_going_down) {
432 get_low_record_time_index(dev, port_index, &resched_delay_sec);
433 queue_delayed_work(dev->sriov.alias_guid.ports_guid[port_index].wq,
434 &dev->sriov.alias_guid.ports_guid[port_index].
435 alias_guid_work,
436 msecs_to_jiffies(resched_delay_sec * 1000));
437 }
438 if (cb_ctx->sa_query) {
439 list_del(&cb_ctx->list);
440 kfree(cb_ctx);
441 } else
442 complete(&cb_ctx->done);
443 spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags1);
444 spin_unlock_irqrestore(&dev->sriov.going_down_lock, flags);
445 }
446
447 static void invalidate_guid_record(struct mlx4_ib_dev *dev, u8 port, int index)
448 {
449 int i;
450 u64 cur_admin_val;
451 ib_sa_comp_mask comp_mask = 0;
452
453 dev->sriov.alias_guid.ports_guid[port - 1].all_rec_per_port[index].status
454 = MLX4_GUID_INFO_STATUS_SET;
455
456 /* calculate the comp_mask for that record.*/
457 for (i = 0; i < NUM_ALIAS_GUID_IN_REC; i++) {
458 cur_admin_val =
459 *(u64 *)&dev->sriov.alias_guid.ports_guid[port - 1].
460 all_rec_per_port[index].all_recs[GUID_REC_SIZE * i];
461 /*
462 check the admin value: if it's for delete (~00LL) or
463 it is the first guid of the first record (hw guid) or
464 the records is not in ownership of the sysadmin and the sm doesn't
465 need to assign GUIDs, then don't put it up for assignment.
466 */
467 if (MLX4_GUID_FOR_DELETE_VAL == cur_admin_val ||
468 (!index && !i))
469 continue;
470 comp_mask |= mlx4_ib_get_aguid_comp_mask_from_ix(i);
471 }
472 dev->sriov.alias_guid.ports_guid[port - 1].
473 all_rec_per_port[index].guid_indexes |= comp_mask;
474 if (dev->sriov.alias_guid.ports_guid[port - 1].
475 all_rec_per_port[index].guid_indexes)
476 dev->sriov.alias_guid.ports_guid[port - 1].
477 all_rec_per_port[index].status = MLX4_GUID_INFO_STATUS_IDLE;
478
479 }
480
481 static int set_guid_rec(struct ib_device *ibdev,
482 struct mlx4_next_alias_guid_work *rec)
483 {
484 int err;
485 struct mlx4_ib_dev *dev = to_mdev(ibdev);
486 struct ib_sa_guidinfo_rec guid_info_rec;
487 ib_sa_comp_mask comp_mask;
488 struct ib_port_attr attr;
489 struct mlx4_alias_guid_work_context *callback_context;
490 unsigned long resched_delay, flags, flags1;
491 u8 port = rec->port + 1;
492 int index = rec->block_num;
493 struct mlx4_sriov_alias_guid_info_rec_det *rec_det = &rec->rec_det;
494 struct list_head *head =
495 &dev->sriov.alias_guid.ports_guid[port - 1].cb_list;
496
497 err = __mlx4_ib_query_port(ibdev, port, &attr, 1);
498 if (err) {
499 pr_debug("mlx4_ib_query_port failed (err: %d), port: %d\n",
500 err, port);
501 return err;
502 }
503 /*check the port was configured by the sm, otherwise no need to send */
504 if (attr.state != IB_PORT_ACTIVE) {
505 pr_debug("port %d not active...rescheduling\n", port);
506 resched_delay = 5 * HZ;
507 err = -EAGAIN;
508 goto new_schedule;
509 }
510
511 callback_context = kmalloc(sizeof *callback_context, GFP_KERNEL);
512 if (!callback_context) {
513 err = -ENOMEM;
514 resched_delay = HZ * 5;
515 goto new_schedule;
516 }
517 callback_context->port = port;
518 callback_context->dev = dev;
519 callback_context->block_num = index;
520 callback_context->guid_indexes = rec_det->guid_indexes;
521 callback_context->method = rec->method;
522
523 memset(&guid_info_rec, 0, sizeof (struct ib_sa_guidinfo_rec));
524
525 guid_info_rec.lid = cpu_to_be16(attr.lid);
526 guid_info_rec.block_num = index;
527
528 memcpy(guid_info_rec.guid_info_list, rec_det->all_recs,
529 GUID_REC_SIZE * NUM_ALIAS_GUID_IN_REC);
530 comp_mask = IB_SA_GUIDINFO_REC_LID | IB_SA_GUIDINFO_REC_BLOCK_NUM |
531 rec_det->guid_indexes;
532
533 init_completion(&callback_context->done);
534 spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags1);
535 list_add_tail(&callback_context->list, head);
536 spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags1);
537
538 callback_context->query_id =
539 ib_sa_guid_info_rec_query(dev->sriov.alias_guid.sa_client,
540 ibdev, port, &guid_info_rec,
541 comp_mask, rec->method, 1000,
542 GFP_KERNEL, aliasguid_query_handler,
543 callback_context,
544 &callback_context->sa_query);
545 if (callback_context->query_id < 0) {
546 pr_debug("ib_sa_guid_info_rec_query failed, query_id: "
547 "%d. will reschedule to the next 1 sec.\n",
548 callback_context->query_id);
549 spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags1);
550 list_del(&callback_context->list);
551 kfree(callback_context);
552 spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags1);
553 resched_delay = 1 * HZ;
554 err = -EAGAIN;
555 goto new_schedule;
556 }
557 err = 0;
558 goto out;
559
560 new_schedule:
561 spin_lock_irqsave(&dev->sriov.going_down_lock, flags);
562 spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags1);
563 invalidate_guid_record(dev, port, index);
564 if (!dev->sriov.is_going_down) {
565 queue_delayed_work(dev->sriov.alias_guid.ports_guid[port - 1].wq,
566 &dev->sriov.alias_guid.ports_guid[port - 1].alias_guid_work,
567 resched_delay);
568 }
569 spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags1);
570 spin_unlock_irqrestore(&dev->sriov.going_down_lock, flags);
571
572 out:
573 return err;
574 }
575
576 static void mlx4_ib_guid_port_init(struct mlx4_ib_dev *dev, int port)
577 {
578 int j, k, entry;
579 __be64 guid;
580
581 /*Check if the SM doesn't need to assign the GUIDs*/
582 for (j = 0; j < NUM_ALIAS_GUID_REC_IN_PORT; j++) {
583 for (k = 0; k < NUM_ALIAS_GUID_IN_REC; k++) {
584 entry = j * NUM_ALIAS_GUID_IN_REC + k;
585 /* no request for the 0 entry (hw guid) */
586 if (!entry || entry > dev->dev->persist->num_vfs ||
587 !mlx4_is_slave_active(dev->dev, entry))
588 continue;
589 guid = mlx4_get_admin_guid(dev->dev, entry, port);
590 *(__be64 *)&dev->sriov.alias_guid.ports_guid[port - 1].
591 all_rec_per_port[j].all_recs
592 [GUID_REC_SIZE * k] = guid;
593 pr_debug("guid was set, entry=%d, val=0x%llx, port=%d\n",
594 entry,
595 be64_to_cpu(guid),
596 port);
597 }
598 }
599 }
600 void mlx4_ib_invalidate_all_guid_record(struct mlx4_ib_dev *dev, int port)
601 {
602 int i;
603 unsigned long flags, flags1;
604
605 pr_debug("port %d\n", port);
606
607 spin_lock_irqsave(&dev->sriov.going_down_lock, flags);
608 spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags1);
609
610 if (dev->sriov.alias_guid.ports_guid[port - 1].state_flags &
611 GUID_STATE_NEED_PORT_INIT) {
612 mlx4_ib_guid_port_init(dev, port);
613 dev->sriov.alias_guid.ports_guid[port - 1].state_flags &=
614 (~GUID_STATE_NEED_PORT_INIT);
615 }
616 for (i = 0; i < NUM_ALIAS_GUID_REC_IN_PORT; i++)
617 invalidate_guid_record(dev, port, i);
618
619 if (mlx4_is_master(dev->dev) && !dev->sriov.is_going_down) {
620 /*
621 make sure no work waits in the queue, if the work is already
622 queued(not on the timer) the cancel will fail. That is not a problem
623 because we just want the work started.
624 */
625 cancel_delayed_work(&dev->sriov.alias_guid.
626 ports_guid[port - 1].alias_guid_work);
627 queue_delayed_work(dev->sriov.alias_guid.ports_guid[port - 1].wq,
628 &dev->sriov.alias_guid.ports_guid[port - 1].alias_guid_work,
629 0);
630 }
631 spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags1);
632 spin_unlock_irqrestore(&dev->sriov.going_down_lock, flags);
633 }
634
635 static void set_required_record(struct mlx4_ib_dev *dev, u8 port,
636 struct mlx4_next_alias_guid_work *next_rec,
637 int record_index)
638 {
639 int i;
640 int lowset_time_entry = -1;
641 int lowest_time = 0;
642 ib_sa_comp_mask delete_guid_indexes = 0;
643 ib_sa_comp_mask set_guid_indexes = 0;
644 struct mlx4_sriov_alias_guid_info_rec_det *rec =
645 &dev->sriov.alias_guid.ports_guid[port].
646 all_rec_per_port[record_index];
647
648 for (i = 0; i < NUM_ALIAS_GUID_IN_REC; i++) {
649 if (!(rec->guid_indexes &
650 mlx4_ib_get_aguid_comp_mask_from_ix(i)))
651 continue;
652
653 if (*(__be64 *)&rec->all_recs[i * GUID_REC_SIZE] ==
654 cpu_to_be64(MLX4_GUID_FOR_DELETE_VAL))
655 delete_guid_indexes |=
656 mlx4_ib_get_aguid_comp_mask_from_ix(i);
657 else
658 set_guid_indexes |=
659 mlx4_ib_get_aguid_comp_mask_from_ix(i);
660
661 if (lowset_time_entry == -1 || rec->guids_retry_schedule[i] <=
662 lowest_time) {
663 lowset_time_entry = i;
664 lowest_time = rec->guids_retry_schedule[i];
665 }
666 }
667
668 memcpy(&next_rec->rec_det, rec, sizeof(*rec));
669 next_rec->port = port;
670 next_rec->block_num = record_index;
671
672 if (*(__be64 *)&rec->all_recs[lowset_time_entry * GUID_REC_SIZE] ==
673 cpu_to_be64(MLX4_GUID_FOR_DELETE_VAL)) {
674 next_rec->rec_det.guid_indexes = delete_guid_indexes;
675 next_rec->method = MLX4_GUID_INFO_RECORD_DELETE;
676 } else {
677 next_rec->rec_det.guid_indexes = set_guid_indexes;
678 next_rec->method = MLX4_GUID_INFO_RECORD_SET;
679 }
680 }
681
682 /* return index of record that should be updated based on lowest
683 * rescheduled time
684 */
685 static int get_low_record_time_index(struct mlx4_ib_dev *dev, u8 port,
686 int *resched_delay_sec)
687 {
688 int record_index = -1;
689 u64 low_record_time = 0;
690 struct mlx4_sriov_alias_guid_info_rec_det rec;
691 int j;
692
693 for (j = 0; j < NUM_ALIAS_GUID_REC_IN_PORT; j++) {
694 rec = dev->sriov.alias_guid.ports_guid[port].
695 all_rec_per_port[j];
696 if (rec.status == MLX4_GUID_INFO_STATUS_IDLE &&
697 rec.guid_indexes) {
698 if (record_index == -1 ||
699 rec.time_to_run < low_record_time) {
700 record_index = j;
701 low_record_time = rec.time_to_run;
702 }
703 }
704 }
705 if (resched_delay_sec) {
706 u64 curr_time = ktime_get_real_ns();
707
708 *resched_delay_sec = (low_record_time < curr_time) ? 0 :
709 div_u64((low_record_time - curr_time), NSEC_PER_SEC);
710 }
711
712 return record_index;
713 }
714
715 /* The function returns the next record that was
716 * not configured (or failed to be configured) */
717 static int get_next_record_to_update(struct mlx4_ib_dev *dev, u8 port,
718 struct mlx4_next_alias_guid_work *rec)
719 {
720 unsigned long flags;
721 int record_index;
722 int ret = 0;
723
724 spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags);
725 record_index = get_low_record_time_index(dev, port, NULL);
726
727 if (record_index < 0) {
728 ret = -ENOENT;
729 goto out;
730 }
731
732 set_required_record(dev, port, rec, record_index);
733 out:
734 spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags);
735 return ret;
736 }
737
738 static void alias_guid_work(struct work_struct *work)
739 {
740 struct delayed_work *delay = to_delayed_work(work);
741 int ret = 0;
742 struct mlx4_next_alias_guid_work *rec;
743 struct mlx4_sriov_alias_guid_port_rec_det *sriov_alias_port =
744 container_of(delay, struct mlx4_sriov_alias_guid_port_rec_det,
745 alias_guid_work);
746 struct mlx4_sriov_alias_guid *sriov_alias_guid = sriov_alias_port->parent;
747 struct mlx4_ib_sriov *ib_sriov = container_of(sriov_alias_guid,
748 struct mlx4_ib_sriov,
749 alias_guid);
750 struct mlx4_ib_dev *dev = container_of(ib_sriov, struct mlx4_ib_dev, sriov);
751
752 rec = kzalloc(sizeof *rec, GFP_KERNEL);
753 if (!rec) {
754 pr_err("alias_guid_work: No Memory\n");
755 return;
756 }
757
758 pr_debug("starting [port: %d]...\n", sriov_alias_port->port + 1);
759 ret = get_next_record_to_update(dev, sriov_alias_port->port, rec);
760 if (ret) {
761 pr_debug("No more records to update.\n");
762 goto out;
763 }
764
765 set_guid_rec(&dev->ib_dev, rec);
766 out:
767 kfree(rec);
768 }
769
770
771 void mlx4_ib_init_alias_guid_work(struct mlx4_ib_dev *dev, int port)
772 {
773 unsigned long flags, flags1;
774
775 if (!mlx4_is_master(dev->dev))
776 return;
777 spin_lock_irqsave(&dev->sriov.going_down_lock, flags);
778 spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags1);
779 if (!dev->sriov.is_going_down) {
780 /* If there is pending one should cancell then run, otherwise
781 * won't run till previous one is ended as same work
782 * struct is used.
783 */
784 cancel_delayed_work(&dev->sriov.alias_guid.ports_guid[port].
785 alias_guid_work);
786 queue_delayed_work(dev->sriov.alias_guid.ports_guid[port].wq,
787 &dev->sriov.alias_guid.ports_guid[port].alias_guid_work, 0);
788 }
789 spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags1);
790 spin_unlock_irqrestore(&dev->sriov.going_down_lock, flags);
791 }
792
793 void mlx4_ib_destroy_alias_guid_service(struct mlx4_ib_dev *dev)
794 {
795 int i;
796 struct mlx4_ib_sriov *sriov = &dev->sriov;
797 struct mlx4_alias_guid_work_context *cb_ctx;
798 struct mlx4_sriov_alias_guid_port_rec_det *det;
799 struct ib_sa_query *sa_query;
800 unsigned long flags;
801
802 for (i = 0 ; i < dev->num_ports; i++) {
803 cancel_delayed_work(&dev->sriov.alias_guid.ports_guid[i].alias_guid_work);
804 det = &sriov->alias_guid.ports_guid[i];
805 spin_lock_irqsave(&sriov->alias_guid.ag_work_lock, flags);
806 while (!list_empty(&det->cb_list)) {
807 cb_ctx = list_entry(det->cb_list.next,
808 struct mlx4_alias_guid_work_context,
809 list);
810 sa_query = cb_ctx->sa_query;
811 cb_ctx->sa_query = NULL;
812 list_del(&cb_ctx->list);
813 spin_unlock_irqrestore(&sriov->alias_guid.ag_work_lock, flags);
814 ib_sa_cancel_query(cb_ctx->query_id, sa_query);
815 wait_for_completion(&cb_ctx->done);
816 kfree(cb_ctx);
817 spin_lock_irqsave(&sriov->alias_guid.ag_work_lock, flags);
818 }
819 spin_unlock_irqrestore(&sriov->alias_guid.ag_work_lock, flags);
820 }
821 for (i = 0 ; i < dev->num_ports; i++) {
822 flush_workqueue(dev->sriov.alias_guid.ports_guid[i].wq);
823 destroy_workqueue(dev->sriov.alias_guid.ports_guid[i].wq);
824 }
825 ib_sa_unregister_client(dev->sriov.alias_guid.sa_client);
826 kfree(dev->sriov.alias_guid.sa_client);
827 }
828
829 int mlx4_ib_init_alias_guid_service(struct mlx4_ib_dev *dev)
830 {
831 char alias_wq_name[15];
832 int ret = 0;
833 int i, j;
834 union ib_gid gid;
835
836 if (!mlx4_is_master(dev->dev))
837 return 0;
838 dev->sriov.alias_guid.sa_client =
839 kzalloc(sizeof *dev->sriov.alias_guid.sa_client, GFP_KERNEL);
840 if (!dev->sriov.alias_guid.sa_client)
841 return -ENOMEM;
842
843 ib_sa_register_client(dev->sriov.alias_guid.sa_client);
844
845 spin_lock_init(&dev->sriov.alias_guid.ag_work_lock);
846
847 for (i = 1; i <= dev->num_ports; ++i) {
848 if (dev->ib_dev.query_gid(&dev->ib_dev , i, 0, &gid)) {
849 ret = -EFAULT;
850 goto err_unregister;
851 }
852 }
853
854 for (i = 0 ; i < dev->num_ports; i++) {
855 memset(&dev->sriov.alias_guid.ports_guid[i], 0,
856 sizeof (struct mlx4_sriov_alias_guid_port_rec_det));
857 dev->sriov.alias_guid.ports_guid[i].state_flags |=
858 GUID_STATE_NEED_PORT_INIT;
859 for (j = 0; j < NUM_ALIAS_GUID_REC_IN_PORT; j++) {
860 /* mark each val as it was deleted */
861 memset(dev->sriov.alias_guid.ports_guid[i].
862 all_rec_per_port[j].all_recs, 0xFF,
863 sizeof(dev->sriov.alias_guid.ports_guid[i].
864 all_rec_per_port[j].all_recs));
865 }
866 INIT_LIST_HEAD(&dev->sriov.alias_guid.ports_guid[i].cb_list);
867 /*prepare the records, set them to be allocated by sm*/
868 if (mlx4_ib_sm_guid_assign)
869 for (j = 1; j < NUM_ALIAS_GUID_PER_PORT; j++)
870 mlx4_set_admin_guid(dev->dev, 0, j, i + 1);
871 for (j = 0 ; j < NUM_ALIAS_GUID_REC_IN_PORT; j++)
872 invalidate_guid_record(dev, i + 1, j);
873
874 dev->sriov.alias_guid.ports_guid[i].parent = &dev->sriov.alias_guid;
875 dev->sriov.alias_guid.ports_guid[i].port = i;
876
877 snprintf(alias_wq_name, sizeof alias_wq_name, "alias_guid%d", i);
878 dev->sriov.alias_guid.ports_guid[i].wq =
879 create_singlethread_workqueue(alias_wq_name);
880 if (!dev->sriov.alias_guid.ports_guid[i].wq) {
881 ret = -ENOMEM;
882 goto err_thread;
883 }
884 INIT_DELAYED_WORK(&dev->sriov.alias_guid.ports_guid[i].alias_guid_work,
885 alias_guid_work);
886 }
887 return 0;
888
889 err_thread:
890 for (--i; i >= 0; i--) {
891 destroy_workqueue(dev->sriov.alias_guid.ports_guid[i].wq);
892 dev->sriov.alias_guid.ports_guid[i].wq = NULL;
893 }
894
895 err_unregister:
896 ib_sa_unregister_client(dev->sriov.alias_guid.sa_client);
897 kfree(dev->sriov.alias_guid.sa_client);
898 dev->sriov.alias_guid.sa_client = NULL;
899 pr_err("init_alias_guid_service: Failed. (ret:%d)\n", ret);
900 return ret;
901 }
Linux kernel - Deliverables
This page took 0.057436 seconds and 5 git commands to generate.