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, slave_port; 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 221 slave_port = mlx4_phys_to_slave_port(dev->dev, slave_id, port_num); 222 if (slave_port < 0) /* this port isn't available for the VF */ 223 continue; 224 225 tmp_cur_ag = *(__be64 *)&p_data[i * GUID_REC_SIZE]; 226 form_cache_ag = get_cached_alias_guid(dev, port_num, 227 (NUM_ALIAS_GUID_IN_REC * block_num) + i); 228 /* 229 * Check if guid is not the same as in the cache, 230 * If it is different, wait for the snoop_smp or the port mgmt 231 * change event to update the slave on its port state change 232 */ 233 if (tmp_cur_ag != form_cache_ag) 234 continue; 235 236 spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags); 237 required_value = *(__be64 *)&rec->all_recs[i * GUID_REC_SIZE]; 238 239 if (required_value == cpu_to_be64(MLX4_GUID_FOR_DELETE_VAL)) 240 required_value = 0; 241 242 if (tmp_cur_ag == required_value) { 243 rec->guid_indexes = rec->guid_indexes & 244 ~mlx4_ib_get_aguid_comp_mask_from_ix(i); 245 } else { 246 /* may notify port down if value is 0 */ 247 if (tmp_cur_ag != MLX4_NOT_SET_GUID) { 248 spin_unlock_irqrestore(&dev->sriov. 249 alias_guid.ag_work_lock, flags); 250 continue; 251 } 252 } 253 spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, 254 flags); 255 mlx4_gen_guid_change_eqe(dev->dev, slave_id, port_num); 256 /*2 cases: Valid GUID, and Invalid Guid*/ 257 258 if (tmp_cur_ag != MLX4_NOT_SET_GUID) { /*valid GUID*/ 259 prev_state = mlx4_get_slave_port_state(dev->dev, slave_id, port_num); 260 new_state = set_and_calc_slave_port_state(dev->dev, slave_id, port_num, 261 MLX4_PORT_STATE_IB_PORT_STATE_EVENT_GID_VALID, 262 &gen_event); 263 pr_debug("slave: %d, port: %d prev_port_state: %d," 264 " new_port_state: %d, gen_event: %d\n", 265 slave_id, port_num, prev_state, new_state, gen_event); 266 if (gen_event == SLAVE_PORT_GEN_EVENT_UP) { 267 pr_debug("sending PORT_UP event to slave: %d, port: %d\n", 268 slave_id, port_num); 269 mlx4_gen_port_state_change_eqe(dev->dev, slave_id, 270 port_num, MLX4_PORT_CHANGE_SUBTYPE_ACTIVE); 271 } 272 } else { /* request to invalidate GUID */ 273 set_and_calc_slave_port_state(dev->dev, slave_id, port_num, 274 MLX4_PORT_STATE_IB_EVENT_GID_INVALID, 275 &gen_event); 276 if (gen_event == SLAVE_PORT_GEN_EVENT_DOWN) { 277 pr_debug("sending PORT DOWN event to slave: %d, port: %d\n", 278 slave_id, port_num); 279 mlx4_gen_port_state_change_eqe(dev->dev, 280 slave_id, 281 port_num, 282 MLX4_PORT_CHANGE_SUBTYPE_DOWN); 283 } 284 } 285 } 286 } 287 288 static void aliasguid_query_handler(int status, 289 struct ib_sa_guidinfo_rec *guid_rec, 290 void *context) 291 { 292 struct mlx4_ib_dev *dev; 293 struct mlx4_alias_guid_work_context *cb_ctx = context; 294 u8 port_index ; 295 int i; 296 struct mlx4_sriov_alias_guid_info_rec_det *rec; 297 unsigned long flags, flags1; 298 ib_sa_comp_mask declined_guid_indexes = 0; 299 ib_sa_comp_mask applied_guid_indexes = 0; 300 unsigned int resched_delay_sec = 0; 301 302 if (!context) 303 return; 304 305 dev = cb_ctx->dev; 306 port_index = cb_ctx->port - 1; 307 rec = &dev->sriov.alias_guid.ports_guid[port_index]. 308 all_rec_per_port[cb_ctx->block_num]; 309 310 if (status) { 311 pr_debug("(port: %d) failed: status = %d\n", 312 cb_ctx->port, status); 313 rec->time_to_run = ktime_get_boot_ns() + 1 * NSEC_PER_SEC; 314 goto out; 315 } 316 317 if (guid_rec->block_num != cb_ctx->block_num) { 318 pr_err("block num mismatch: %d != %d\n", 319 cb_ctx->block_num, guid_rec->block_num); 320 goto out; 321 } 322 323 pr_debug("lid/port: %d/%d, block_num: %d\n", 324 be16_to_cpu(guid_rec->lid), cb_ctx->port, 325 guid_rec->block_num); 326 327 rec = &dev->sriov.alias_guid.ports_guid[port_index]. 328 all_rec_per_port[guid_rec->block_num]; 329 330 spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags); 331 for (i = 0 ; i < NUM_ALIAS_GUID_IN_REC; i++) { 332 __be64 sm_response, required_val; 333 334 if (!(cb_ctx->guid_indexes & 335 mlx4_ib_get_aguid_comp_mask_from_ix(i))) 336 continue; 337 sm_response = *(__be64 *)&guid_rec->guid_info_list 338 [i * GUID_REC_SIZE]; 339 required_val = *(__be64 *)&rec->all_recs[i * GUID_REC_SIZE]; 340 if (cb_ctx->method == MLX4_GUID_INFO_RECORD_DELETE) { 341 if (required_val == 342 cpu_to_be64(MLX4_GUID_FOR_DELETE_VAL)) 343 goto next_entry; 344 345 /* A new value was set till we got the response */ 346 pr_debug("need to set new value %llx, record num %d, block_num:%d\n", 347 be64_to_cpu(required_val), 348 i, guid_rec->block_num); 349 goto entry_declined; 350 } 351 352 /* check if the SM didn't assign one of the records. 353 * if it didn't, re-ask for. 354 */ 355 if (sm_response == MLX4_NOT_SET_GUID) { 356 if (rec->guids_retry_schedule[i] == 0) 357 mlx4_ib_warn(&dev->ib_dev, 358 "%s:Record num %d in block_num: %d was declined by SM\n", 359 __func__, i, 360 guid_rec->block_num); 361 goto entry_declined; 362 } else { 363 /* properly assigned record. */ 364 /* We save the GUID we just got from the SM in the 365 * admin_guid in order to be persistent, and in the 366 * request from the sm the process will ask for the same GUID */ 367 if (required_val && 368 sm_response != required_val) { 369 /* Warn only on first retry */ 370 if (rec->guids_retry_schedule[i] == 0) 371 mlx4_ib_warn(&dev->ib_dev, "%s: Failed to set" 372 " admin guid after SysAdmin " 373 "configuration. " 374 "Record num %d in block_num:%d " 375 "was declined by SM, " 376 "new val(0x%llx) was kept, SM returned (0x%llx)\n", 377 __func__, i, 378 guid_rec->block_num, 379 be64_to_cpu(required_val), 380 be64_to_cpu(sm_response)); 381 goto entry_declined; 382 } else { 383 *(__be64 *)&rec->all_recs[i * GUID_REC_SIZE] = 384 sm_response; 385 if (required_val == 0) 386 mlx4_set_admin_guid(dev->dev, 387 sm_response, 388 (guid_rec->block_num 389 * NUM_ALIAS_GUID_IN_REC) + i, 390 cb_ctx->port); 391 goto next_entry; 392 } 393 } 394 entry_declined: 395 declined_guid_indexes |= mlx4_ib_get_aguid_comp_mask_from_ix(i); 396 rec->guids_retry_schedule[i] = 397 (rec->guids_retry_schedule[i] == 0) ? 1 : 398 min((unsigned int)60, 399 rec->guids_retry_schedule[i] * 2); 400 /* using the minimum value among all entries in that record */ 401 resched_delay_sec = (resched_delay_sec == 0) ? 402 rec->guids_retry_schedule[i] : 403 min(resched_delay_sec, 404 rec->guids_retry_schedule[i]); 405 continue; 406 407 next_entry: 408 rec->guids_retry_schedule[i] = 0; 409 } 410 411 applied_guid_indexes = cb_ctx->guid_indexes & ~declined_guid_indexes; 412 if (declined_guid_indexes || 413 rec->guid_indexes & ~(applied_guid_indexes)) { 414 pr_debug("record=%d wasn't fully set, guid_indexes=0x%llx applied_indexes=0x%llx, declined_indexes=0x%llx\n", 415 guid_rec->block_num, 416 be64_to_cpu((__force __be64)rec->guid_indexes), 417 be64_to_cpu((__force __be64)applied_guid_indexes), 418 be64_to_cpu((__force __be64)declined_guid_indexes)); 419 rec->time_to_run = ktime_get_boot_ns() + 420 resched_delay_sec * NSEC_PER_SEC; 421 } else { 422 rec->status = MLX4_GUID_INFO_STATUS_SET; 423 } 424 spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags); 425 /* 426 The func is call here to close the cases when the 427 sm doesn't send smp, so in the sa response the driver 428 notifies the slave. 429 */ 430 mlx4_ib_notify_slaves_on_guid_change(dev, guid_rec->block_num, 431 cb_ctx->port, 432 guid_rec->guid_info_list); 433 out: 434 spin_lock_irqsave(&dev->sriov.going_down_lock, flags); 435 spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags1); 436 if (!dev->sriov.is_going_down) { 437 get_low_record_time_index(dev, port_index, &resched_delay_sec); 438 queue_delayed_work(dev->sriov.alias_guid.ports_guid[port_index].wq, 439 &dev->sriov.alias_guid.ports_guid[port_index]. 440 alias_guid_work, 441 msecs_to_jiffies(resched_delay_sec * 1000)); 442 } 443 if (cb_ctx->sa_query) { 444 list_del(&cb_ctx->list); 445 kfree(cb_ctx); 446 } else 447 complete(&cb_ctx->done); 448 spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags1); 449 spin_unlock_irqrestore(&dev->sriov.going_down_lock, flags); 450 } 451 452 static void invalidate_guid_record(struct mlx4_ib_dev *dev, u8 port, int index) 453 { 454 int i; 455 u64 cur_admin_val; 456 ib_sa_comp_mask comp_mask = 0; 457 458 dev->sriov.alias_guid.ports_guid[port - 1].all_rec_per_port[index].status 459 = MLX4_GUID_INFO_STATUS_SET; 460 461 /* calculate the comp_mask for that record.*/ 462 for (i = 0; i < NUM_ALIAS_GUID_IN_REC; i++) { 463 cur_admin_val = 464 *(u64 *)&dev->sriov.alias_guid.ports_guid[port - 1]. 465 all_rec_per_port[index].all_recs[GUID_REC_SIZE * i]; 466 /* 467 check the admin value: if it's for delete (~00LL) or 468 it is the first guid of the first record (hw guid) or 469 the records is not in ownership of the sysadmin and the sm doesn't 470 need to assign GUIDs, then don't put it up for assignment. 471 */ 472 if (MLX4_GUID_FOR_DELETE_VAL == cur_admin_val || 473 (!index && !i)) 474 continue; 475 comp_mask |= mlx4_ib_get_aguid_comp_mask_from_ix(i); 476 } 477 dev->sriov.alias_guid.ports_guid[port - 1]. 478 all_rec_per_port[index].guid_indexes |= comp_mask; 479 if (dev->sriov.alias_guid.ports_guid[port - 1]. 480 all_rec_per_port[index].guid_indexes) 481 dev->sriov.alias_guid.ports_guid[port - 1]. 482 all_rec_per_port[index].status = MLX4_GUID_INFO_STATUS_IDLE; 483 484 } 485 486 static int set_guid_rec(struct ib_device *ibdev, 487 struct mlx4_next_alias_guid_work *rec) 488 { 489 int err; 490 struct mlx4_ib_dev *dev = to_mdev(ibdev); 491 struct ib_sa_guidinfo_rec guid_info_rec; 492 ib_sa_comp_mask comp_mask; 493 struct ib_port_attr attr; 494 struct mlx4_alias_guid_work_context *callback_context; 495 unsigned long resched_delay, flags, flags1; 496 u8 port = rec->port + 1; 497 int index = rec->block_num; 498 struct mlx4_sriov_alias_guid_info_rec_det *rec_det = &rec->rec_det; 499 struct list_head *head = 500 &dev->sriov.alias_guid.ports_guid[port - 1].cb_list; 501 502 err = __mlx4_ib_query_port(ibdev, port, &attr, 1); 503 if (err) { 504 pr_debug("mlx4_ib_query_port failed (err: %d), port: %d\n", 505 err, port); 506 return err; 507 } 508 /*check the port was configured by the sm, otherwise no need to send */ 509 if (attr.state != IB_PORT_ACTIVE) { 510 pr_debug("port %d not active...rescheduling\n", port); 511 resched_delay = 5 * HZ; 512 err = -EAGAIN; 513 goto new_schedule; 514 } 515 516 callback_context = kmalloc(sizeof *callback_context, GFP_KERNEL); 517 if (!callback_context) { 518 err = -ENOMEM; 519 resched_delay = HZ * 5; 520 goto new_schedule; 521 } 522 callback_context->port = port; 523 callback_context->dev = dev; 524 callback_context->block_num = index; 525 callback_context->guid_indexes = rec_det->guid_indexes; 526 callback_context->method = rec->method; 527 528 memset(&guid_info_rec, 0, sizeof (struct ib_sa_guidinfo_rec)); 529 530 guid_info_rec.lid = cpu_to_be16(attr.lid); 531 guid_info_rec.block_num = index; 532 533 memcpy(guid_info_rec.guid_info_list, rec_det->all_recs, 534 GUID_REC_SIZE * NUM_ALIAS_GUID_IN_REC); 535 comp_mask = IB_SA_GUIDINFO_REC_LID | IB_SA_GUIDINFO_REC_BLOCK_NUM | 536 rec_det->guid_indexes; 537 538 init_completion(&callback_context->done); 539 spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags1); 540 list_add_tail(&callback_context->list, head); 541 spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags1); 542 543 callback_context->query_id = 544 ib_sa_guid_info_rec_query(dev->sriov.alias_guid.sa_client, 545 ibdev, port, &guid_info_rec, 546 comp_mask, rec->method, 1000, 547 GFP_KERNEL, aliasguid_query_handler, 548 callback_context, 549 &callback_context->sa_query); 550 if (callback_context->query_id < 0) { 551 pr_debug("ib_sa_guid_info_rec_query failed, query_id: " 552 "%d. will reschedule to the next 1 sec.\n", 553 callback_context->query_id); 554 spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags1); 555 list_del(&callback_context->list); 556 kfree(callback_context); 557 spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags1); 558 resched_delay = 1 * HZ; 559 err = -EAGAIN; 560 goto new_schedule; 561 } 562 err = 0; 563 goto out; 564 565 new_schedule: 566 spin_lock_irqsave(&dev->sriov.going_down_lock, flags); 567 spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags1); 568 invalidate_guid_record(dev, port, index); 569 if (!dev->sriov.is_going_down) { 570 queue_delayed_work(dev->sriov.alias_guid.ports_guid[port - 1].wq, 571 &dev->sriov.alias_guid.ports_guid[port - 1].alias_guid_work, 572 resched_delay); 573 } 574 spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags1); 575 spin_unlock_irqrestore(&dev->sriov.going_down_lock, flags); 576 577 out: 578 return err; 579 } 580 581 static void mlx4_ib_guid_port_init(struct mlx4_ib_dev *dev, int port) 582 { 583 int j, k, entry; 584 __be64 guid; 585 586 /*Check if the SM doesn't need to assign the GUIDs*/ 587 for (j = 0; j < NUM_ALIAS_GUID_REC_IN_PORT; j++) { 588 for (k = 0; k < NUM_ALIAS_GUID_IN_REC; k++) { 589 entry = j * NUM_ALIAS_GUID_IN_REC + k; 590 /* no request for the 0 entry (hw guid) */ 591 if (!entry || entry > dev->dev->persist->num_vfs || 592 !mlx4_is_slave_active(dev->dev, entry)) 593 continue; 594 guid = mlx4_get_admin_guid(dev->dev, entry, port); 595 *(__be64 *)&dev->sriov.alias_guid.ports_guid[port - 1]. 596 all_rec_per_port[j].all_recs 597 [GUID_REC_SIZE * k] = guid; 598 pr_debug("guid was set, entry=%d, val=0x%llx, port=%d\n", 599 entry, 600 be64_to_cpu(guid), 601 port); 602 } 603 } 604 } 605 void mlx4_ib_invalidate_all_guid_record(struct mlx4_ib_dev *dev, int port) 606 { 607 int i; 608 unsigned long flags, flags1; 609 610 pr_debug("port %d\n", port); 611 612 spin_lock_irqsave(&dev->sriov.going_down_lock, flags); 613 spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags1); 614 615 if (dev->sriov.alias_guid.ports_guid[port - 1].state_flags & 616 GUID_STATE_NEED_PORT_INIT) { 617 mlx4_ib_guid_port_init(dev, port); 618 dev->sriov.alias_guid.ports_guid[port - 1].state_flags &= 619 (~GUID_STATE_NEED_PORT_INIT); 620 } 621 for (i = 0; i < NUM_ALIAS_GUID_REC_IN_PORT; i++) 622 invalidate_guid_record(dev, port, i); 623 624 if (mlx4_is_master(dev->dev) && !dev->sriov.is_going_down) { 625 /* 626 make sure no work waits in the queue, if the work is already 627 queued(not on the timer) the cancel will fail. That is not a problem 628 because we just want the work started. 629 */ 630 cancel_delayed_work(&dev->sriov.alias_guid. 631 ports_guid[port - 1].alias_guid_work); 632 queue_delayed_work(dev->sriov.alias_guid.ports_guid[port - 1].wq, 633 &dev->sriov.alias_guid.ports_guid[port - 1].alias_guid_work, 634 0); 635 } 636 spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags1); 637 spin_unlock_irqrestore(&dev->sriov.going_down_lock, flags); 638 } 639 640 static void set_required_record(struct mlx4_ib_dev *dev, u8 port, 641 struct mlx4_next_alias_guid_work *next_rec, 642 int record_index) 643 { 644 int i; 645 int lowset_time_entry = -1; 646 int lowest_time = 0; 647 ib_sa_comp_mask delete_guid_indexes = 0; 648 ib_sa_comp_mask set_guid_indexes = 0; 649 struct mlx4_sriov_alias_guid_info_rec_det *rec = 650 &dev->sriov.alias_guid.ports_guid[port]. 651 all_rec_per_port[record_index]; 652 653 for (i = 0; i < NUM_ALIAS_GUID_IN_REC; i++) { 654 if (!(rec->guid_indexes & 655 mlx4_ib_get_aguid_comp_mask_from_ix(i))) 656 continue; 657 658 if (*(__be64 *)&rec->all_recs[i * GUID_REC_SIZE] == 659 cpu_to_be64(MLX4_GUID_FOR_DELETE_VAL)) 660 delete_guid_indexes |= 661 mlx4_ib_get_aguid_comp_mask_from_ix(i); 662 else 663 set_guid_indexes |= 664 mlx4_ib_get_aguid_comp_mask_from_ix(i); 665 666 if (lowset_time_entry == -1 || rec->guids_retry_schedule[i] <= 667 lowest_time) { 668 lowset_time_entry = i; 669 lowest_time = rec->guids_retry_schedule[i]; 670 } 671 } 672 673 memcpy(&next_rec->rec_det, rec, sizeof(*rec)); 674 next_rec->port = port; 675 next_rec->block_num = record_index; 676 677 if (*(__be64 *)&rec->all_recs[lowset_time_entry * GUID_REC_SIZE] == 678 cpu_to_be64(MLX4_GUID_FOR_DELETE_VAL)) { 679 next_rec->rec_det.guid_indexes = delete_guid_indexes; 680 next_rec->method = MLX4_GUID_INFO_RECORD_DELETE; 681 } else { 682 next_rec->rec_det.guid_indexes = set_guid_indexes; 683 next_rec->method = MLX4_GUID_INFO_RECORD_SET; 684 } 685 } 686 687 /* return index of record that should be updated based on lowest 688 * rescheduled time 689 */ 690 static int get_low_record_time_index(struct mlx4_ib_dev *dev, u8 port, 691 int *resched_delay_sec) 692 { 693 int record_index = -1; 694 u64 low_record_time = 0; 695 struct mlx4_sriov_alias_guid_info_rec_det rec; 696 int j; 697 698 for (j = 0; j < NUM_ALIAS_GUID_REC_IN_PORT; j++) { 699 rec = dev->sriov.alias_guid.ports_guid[port]. 700 all_rec_per_port[j]; 701 if (rec.status == MLX4_GUID_INFO_STATUS_IDLE && 702 rec.guid_indexes) { 703 if (record_index == -1 || 704 rec.time_to_run < low_record_time) { 705 record_index = j; 706 low_record_time = rec.time_to_run; 707 } 708 } 709 } 710 if (resched_delay_sec) { 711 u64 curr_time = ktime_get_boot_ns(); 712 713 *resched_delay_sec = (low_record_time < curr_time) ? 0 : 714 div_u64((low_record_time - curr_time), NSEC_PER_SEC); 715 } 716 717 return record_index; 718 } 719 720 /* The function returns the next record that was 721 * not configured (or failed to be configured) */ 722 static int get_next_record_to_update(struct mlx4_ib_dev *dev, u8 port, 723 struct mlx4_next_alias_guid_work *rec) 724 { 725 unsigned long flags; 726 int record_index; 727 int ret = 0; 728 729 spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags); 730 record_index = get_low_record_time_index(dev, port, NULL); 731 732 if (record_index < 0) { 733 ret = -ENOENT; 734 goto out; 735 } 736 737 set_required_record(dev, port, rec, record_index); 738 out: 739 spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags); 740 return ret; 741 } 742 743 static void alias_guid_work(struct work_struct *work) 744 { 745 struct delayed_work *delay = to_delayed_work(work); 746 int ret = 0; 747 struct mlx4_next_alias_guid_work *rec; 748 struct mlx4_sriov_alias_guid_port_rec_det *sriov_alias_port = 749 container_of(delay, struct mlx4_sriov_alias_guid_port_rec_det, 750 alias_guid_work); 751 struct mlx4_sriov_alias_guid *sriov_alias_guid = sriov_alias_port->parent; 752 struct mlx4_ib_sriov *ib_sriov = container_of(sriov_alias_guid, 753 struct mlx4_ib_sriov, 754 alias_guid); 755 struct mlx4_ib_dev *dev = container_of(ib_sriov, struct mlx4_ib_dev, sriov); 756 757 rec = kzalloc(sizeof *rec, GFP_KERNEL); 758 if (!rec) { 759 pr_err("alias_guid_work: No Memory\n"); 760 return; 761 } 762 763 pr_debug("starting [port: %d]...\n", sriov_alias_port->port + 1); 764 ret = get_next_record_to_update(dev, sriov_alias_port->port, rec); 765 if (ret) { 766 pr_debug("No more records to update.\n"); 767 goto out; 768 } 769 770 set_guid_rec(&dev->ib_dev, rec); 771 out: 772 kfree(rec); 773 } 774 775 776 void mlx4_ib_init_alias_guid_work(struct mlx4_ib_dev *dev, int port) 777 { 778 unsigned long flags, flags1; 779 780 if (!mlx4_is_master(dev->dev)) 781 return; 782 spin_lock_irqsave(&dev->sriov.going_down_lock, flags); 783 spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags1); 784 if (!dev->sriov.is_going_down) { 785 /* If there is pending one should cancell then run, otherwise 786 * won't run till previous one is ended as same work 787 * struct is used. 788 */ 789 cancel_delayed_work(&dev->sriov.alias_guid.ports_guid[port]. 790 alias_guid_work); 791 queue_delayed_work(dev->sriov.alias_guid.ports_guid[port].wq, 792 &dev->sriov.alias_guid.ports_guid[port].alias_guid_work, 0); 793 } 794 spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags1); 795 spin_unlock_irqrestore(&dev->sriov.going_down_lock, flags); 796 } 797 798 void mlx4_ib_destroy_alias_guid_service(struct mlx4_ib_dev *dev) 799 { 800 int i; 801 struct mlx4_ib_sriov *sriov = &dev->sriov; 802 struct mlx4_alias_guid_work_context *cb_ctx; 803 struct mlx4_sriov_alias_guid_port_rec_det *det; 804 struct ib_sa_query *sa_query; 805 unsigned long flags; 806 807 for (i = 0 ; i < dev->num_ports; i++) { 808 cancel_delayed_work(&dev->sriov.alias_guid.ports_guid[i].alias_guid_work); 809 det = &sriov->alias_guid.ports_guid[i]; 810 spin_lock_irqsave(&sriov->alias_guid.ag_work_lock, flags); 811 while (!list_empty(&det->cb_list)) { 812 cb_ctx = list_entry(det->cb_list.next, 813 struct mlx4_alias_guid_work_context, 814 list); 815 sa_query = cb_ctx->sa_query; 816 cb_ctx->sa_query = NULL; 817 list_del(&cb_ctx->list); 818 spin_unlock_irqrestore(&sriov->alias_guid.ag_work_lock, flags); 819 ib_sa_cancel_query(cb_ctx->query_id, sa_query); 820 wait_for_completion(&cb_ctx->done); 821 kfree(cb_ctx); 822 spin_lock_irqsave(&sriov->alias_guid.ag_work_lock, flags); 823 } 824 spin_unlock_irqrestore(&sriov->alias_guid.ag_work_lock, flags); 825 } 826 for (i = 0 ; i < dev->num_ports; i++) { 827 flush_workqueue(dev->sriov.alias_guid.ports_guid[i].wq); 828 destroy_workqueue(dev->sriov.alias_guid.ports_guid[i].wq); 829 } 830 ib_sa_unregister_client(dev->sriov.alias_guid.sa_client); 831 kfree(dev->sriov.alias_guid.sa_client); 832 } 833 834 int mlx4_ib_init_alias_guid_service(struct mlx4_ib_dev *dev) 835 { 836 char alias_wq_name[15]; 837 int ret = 0; 838 int i, j; 839 union ib_gid gid; 840 841 if (!mlx4_is_master(dev->dev)) 842 return 0; 843 dev->sriov.alias_guid.sa_client = 844 kzalloc(sizeof *dev->sriov.alias_guid.sa_client, GFP_KERNEL); 845 if (!dev->sriov.alias_guid.sa_client) 846 return -ENOMEM; 847 848 ib_sa_register_client(dev->sriov.alias_guid.sa_client); 849 850 spin_lock_init(&dev->sriov.alias_guid.ag_work_lock); 851 852 for (i = 1; i <= dev->num_ports; ++i) { 853 if (dev->ib_dev.query_gid(&dev->ib_dev , i, 0, &gid)) { 854 ret = -EFAULT; 855 goto err_unregister; 856 } 857 } 858 859 for (i = 0 ; i < dev->num_ports; i++) { 860 memset(&dev->sriov.alias_guid.ports_guid[i], 0, 861 sizeof (struct mlx4_sriov_alias_guid_port_rec_det)); 862 dev->sriov.alias_guid.ports_guid[i].state_flags |= 863 GUID_STATE_NEED_PORT_INIT; 864 for (j = 0; j < NUM_ALIAS_GUID_REC_IN_PORT; j++) { 865 /* mark each val as it was deleted */ 866 memset(dev->sriov.alias_guid.ports_guid[i]. 867 all_rec_per_port[j].all_recs, 0xFF, 868 sizeof(dev->sriov.alias_guid.ports_guid[i]. 869 all_rec_per_port[j].all_recs)); 870 } 871 INIT_LIST_HEAD(&dev->sriov.alias_guid.ports_guid[i].cb_list); 872 /*prepare the records, set them to be allocated by sm*/ 873 if (mlx4_ib_sm_guid_assign) 874 for (j = 1; j < NUM_ALIAS_GUID_PER_PORT; j++) 875 mlx4_set_admin_guid(dev->dev, 0, j, i + 1); 876 for (j = 0 ; j < NUM_ALIAS_GUID_REC_IN_PORT; j++) 877 invalidate_guid_record(dev, i + 1, j); 878 879 dev->sriov.alias_guid.ports_guid[i].parent = &dev->sriov.alias_guid; 880 dev->sriov.alias_guid.ports_guid[i].port = i; 881 882 snprintf(alias_wq_name, sizeof alias_wq_name, "alias_guid%d", i); 883 dev->sriov.alias_guid.ports_guid[i].wq = 884 create_singlethread_workqueue(alias_wq_name); 885 if (!dev->sriov.alias_guid.ports_guid[i].wq) { 886 ret = -ENOMEM; 887 goto err_thread; 888 } 889 INIT_DELAYED_WORK(&dev->sriov.alias_guid.ports_guid[i].alias_guid_work, 890 alias_guid_work); 891 } 892 return 0; 893 894 err_thread: 895 for (--i; i >= 0; i--) { 896 destroy_workqueue(dev->sriov.alias_guid.ports_guid[i].wq); 897 dev->sriov.alias_guid.ports_guid[i].wq = NULL; 898 } 899 900 err_unregister: 901 ib_sa_unregister_client(dev->sriov.alias_guid.sa_client); 902 kfree(dev->sriov.alias_guid.sa_client); 903 dev->sriov.alias_guid.sa_client = NULL; 904 pr_err("init_alias_guid_service: Failed. (ret:%d)\n", ret); 905 return ret; 906 } 907