1/* 2 * Copyright (c) 2004 Topspin Communications. All rights reserved. 3 * Copyright (c) 2005 Intel Corporation. All rights reserved. 4 * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved. 5 * Copyright (c) 2005 Voltaire, Inc. All rights reserved. 6 * 7 * This software is available to you under a choice of one of two 8 * licenses. You may choose to be licensed under the terms of the GNU 9 * General Public License (GPL) Version 2, available from the file 10 * COPYING in the main directory of this source tree, or the 11 * OpenIB.org BSD license below: 12 * 13 * Redistribution and use in source and binary forms, with or 14 * without modification, are permitted provided that the following 15 * conditions are met: 16 * 17 * - Redistributions of source code must retain the above 18 * copyright notice, this list of conditions and the following 19 * disclaimer. 20 * 21 * - Redistributions in binary form must reproduce the above 22 * copyright notice, this list of conditions and the following 23 * disclaimer in the documentation and/or other materials 24 * provided with the distribution. 25 * 26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 27 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 28 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 29 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 30 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 31 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 32 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 33 * SOFTWARE. 34 */ 35 36#include <linux/module.h> 37#include <linux/errno.h> 38#include <linux/slab.h> 39#include <linux/workqueue.h> 40#include <linux/netdevice.h> 41#include <net/addrconf.h> 42 43#include <rdma/ib_cache.h> 44 45#include "core_priv.h" 46 47struct ib_pkey_cache { 48 int table_len; 49 u16 table[]; 50}; 51 52struct ib_update_work { 53 struct work_struct work; 54 struct ib_event event; 55 bool enforce_security; 56}; 57 58union ib_gid zgid; 59EXPORT_SYMBOL(zgid); 60 61enum gid_attr_find_mask { 62 GID_ATTR_FIND_MASK_GID = 1UL << 0, 63 GID_ATTR_FIND_MASK_NETDEV = 1UL << 1, 64 GID_ATTR_FIND_MASK_DEFAULT = 1UL << 2, 65 GID_ATTR_FIND_MASK_GID_TYPE = 1UL << 3, 66}; 67 68enum gid_table_entry_state { 69 GID_TABLE_ENTRY_INVALID = 1, 70 GID_TABLE_ENTRY_VALID = 2, 71 /* 72 * Indicates that entry is pending to be removed, there may 73 * be active users of this GID entry. 74 * When last user of the GID entry releases reference to it, 75 * GID entry is detached from the table. 76 */ 77 GID_TABLE_ENTRY_PENDING_DEL = 3, 78}; 79 80struct roce_gid_ndev_storage { 81 struct rcu_head rcu_head; 82 struct net_device *ndev; 83}; 84 85struct ib_gid_table_entry { 86 struct kref kref; 87 struct work_struct del_work; 88 struct ib_gid_attr attr; 89 void *context; 90 /* Store the ndev pointer to release reference later on in 91 * call_rcu context because by that time gid_table_entry 92 * and attr might be already freed. So keep a copy of it. 93 * ndev_storage is freed by rcu callback. 94 */ 95 struct roce_gid_ndev_storage *ndev_storage; 96 enum gid_table_entry_state state; 97}; 98 99struct ib_gid_table { 100 int sz; 101 /* In RoCE, adding a GID to the table requires: 102 * (a) Find if this GID is already exists. 103 * (b) Find a free space. 104 * (c) Write the new GID 105 * 106 * Delete requires different set of operations: 107 * (a) Find the GID 108 * (b) Delete it. 109 * 110 **/ 111 /* Any writer to data_vec must hold this lock and the write side of 112 * rwlock. Readers must hold only rwlock. All writers must be in a 113 * sleepable context. 114 */ 115 struct mutex lock; 116 /* rwlock protects data_vec[ix]->state and entry pointer. 117 */ 118 rwlock_t rwlock; 119 struct ib_gid_table_entry **data_vec; 120 /* bit field, each bit indicates the index of default GID */ 121 u32 default_gid_indices; 122}; 123 124static void dispatch_gid_change_event(struct ib_device *ib_dev, u8 port) 125{ 126 struct ib_event event; 127 128 event.device = ib_dev; 129 event.element.port_num = port; 130 event.event = IB_EVENT_GID_CHANGE; 131 132 ib_dispatch_event_clients(&event); 133} 134 135static const char * const gid_type_str[] = { 136 /* IB/RoCE v1 value is set for IB_GID_TYPE_IB and IB_GID_TYPE_ROCE for 137 * user space compatibility reasons. 138 */ 139 [IB_GID_TYPE_IB] = "IB/RoCE v1", 140 [IB_GID_TYPE_ROCE] = "IB/RoCE v1", 141 [IB_GID_TYPE_ROCE_UDP_ENCAP] = "RoCE v2", 142}; 143 144const char *ib_cache_gid_type_str(enum ib_gid_type gid_type) 145{ 146 if (gid_type < ARRAY_SIZE(gid_type_str) && gid_type_str[gid_type]) 147 return gid_type_str[gid_type]; 148 149 return "Invalid GID type"; 150} 151EXPORT_SYMBOL(ib_cache_gid_type_str); 152 153/** rdma_is_zero_gid - Check if given GID is zero or not. 154 * @gid: GID to check 155 * Returns true if given GID is zero, returns false otherwise. 156 */ 157bool rdma_is_zero_gid(const union ib_gid *gid) 158{ 159 return !memcmp(gid, &zgid, sizeof(*gid)); 160} 161EXPORT_SYMBOL(rdma_is_zero_gid); 162 163/** is_gid_index_default - Check if a given index belongs to 164 * reserved default GIDs or not. 165 * @table: GID table pointer 166 * @index: Index to check in GID table 167 * Returns true if index is one of the reserved default GID index otherwise 168 * returns false. 169 */ 170static bool is_gid_index_default(const struct ib_gid_table *table, 171 unsigned int index) 172{ 173 return index < 32 && (BIT(index) & table->default_gid_indices); 174} 175 176int ib_cache_gid_parse_type_str(const char *buf) 177{ 178 unsigned int i; 179 size_t len; 180 int err = -EINVAL; 181 182 len = strlen(buf); 183 if (len == 0) 184 return -EINVAL; 185 186 if (buf[len - 1] == '\n') 187 len--; 188 189 for (i = 0; i < ARRAY_SIZE(gid_type_str); ++i) 190 if (gid_type_str[i] && !strncmp(buf, gid_type_str[i], len) && 191 len == strlen(gid_type_str[i])) { 192 err = i; 193 break; 194 } 195 196 return err; 197} 198EXPORT_SYMBOL(ib_cache_gid_parse_type_str); 199 200static struct ib_gid_table *rdma_gid_table(struct ib_device *device, u8 port) 201{ 202 return device->port_data[port].cache.gid; 203} 204 205static bool is_gid_entry_free(const struct ib_gid_table_entry *entry) 206{ 207 return !entry; 208} 209 210static bool is_gid_entry_valid(const struct ib_gid_table_entry *entry) 211{ 212 return entry && entry->state == GID_TABLE_ENTRY_VALID; 213} 214 215static void schedule_free_gid(struct kref *kref) 216{ 217 struct ib_gid_table_entry *entry = 218 container_of(kref, struct ib_gid_table_entry, kref); 219 220 queue_work(ib_wq, &entry->del_work); 221} 222 223static void put_gid_ndev(struct rcu_head *head) 224{ 225 struct roce_gid_ndev_storage *storage = 226 container_of(head, struct roce_gid_ndev_storage, rcu_head); 227 228 WARN_ON(!storage->ndev); 229 /* At this point its safe to release netdev reference, 230 * as all callers working on gid_attr->ndev are done 231 * using this netdev. 232 */ 233 dev_put(storage->ndev); 234 kfree(storage); 235} 236 237static void free_gid_entry_locked(struct ib_gid_table_entry *entry) 238{ 239 struct ib_device *device = entry->attr.device; 240 u8 port_num = entry->attr.port_num; 241 struct ib_gid_table *table = rdma_gid_table(device, port_num); 242 243 dev_dbg(&device->dev, "%s port=%d index=%d gid %pI6\n", __func__, 244 port_num, entry->attr.index, entry->attr.gid.raw); 245 246 write_lock_irq(&table->rwlock); 247 248 /* 249 * The only way to avoid overwriting NULL in table is 250 * by comparing if it is same entry in table or not! 251 * If new entry in table is added by the time we free here, 252 * don't overwrite the table entry. 253 */ 254 if (entry == table->data_vec[entry->attr.index]) 255 table->data_vec[entry->attr.index] = NULL; 256 /* Now this index is ready to be allocated */ 257 write_unlock_irq(&table->rwlock); 258 259 if (entry->ndev_storage) 260 call_rcu(&entry->ndev_storage->rcu_head, put_gid_ndev); 261 kfree(entry); 262} 263 264static void free_gid_entry(struct kref *kref) 265{ 266 struct ib_gid_table_entry *entry = 267 container_of(kref, struct ib_gid_table_entry, kref); 268 269 free_gid_entry_locked(entry); 270} 271 272/** 273 * free_gid_work - Release reference to the GID entry 274 * @work: Work structure to refer to GID entry which needs to be 275 * deleted. 276 * 277 * free_gid_work() frees the entry from the HCA's hardware table 278 * if provider supports it. It releases reference to netdevice. 279 */ 280static void free_gid_work(struct work_struct *work) 281{ 282 struct ib_gid_table_entry *entry = 283 container_of(work, struct ib_gid_table_entry, del_work); 284 struct ib_device *device = entry->attr.device; 285 u8 port_num = entry->attr.port_num; 286 struct ib_gid_table *table = rdma_gid_table(device, port_num); 287 288 mutex_lock(&table->lock); 289 free_gid_entry_locked(entry); 290 mutex_unlock(&table->lock); 291} 292 293static struct ib_gid_table_entry * 294alloc_gid_entry(const struct ib_gid_attr *attr) 295{ 296 struct ib_gid_table_entry *entry; 297 struct net_device *ndev; 298 299 entry = kzalloc(sizeof(*entry), GFP_KERNEL); 300 if (!entry) 301 return NULL; 302 303 ndev = rcu_dereference_protected(attr->ndev, 1); 304 if (ndev) { 305 entry->ndev_storage = kzalloc(sizeof(*entry->ndev_storage), 306 GFP_KERNEL); 307 if (!entry->ndev_storage) { 308 kfree(entry); 309 return NULL; 310 } 311 dev_hold(ndev); 312 entry->ndev_storage->ndev = ndev; 313 } 314 kref_init(&entry->kref); 315 memcpy(&entry->attr, attr, sizeof(*attr)); 316 INIT_WORK(&entry->del_work, free_gid_work); 317 entry->state = GID_TABLE_ENTRY_INVALID; 318 return entry; 319} 320 321static void store_gid_entry(struct ib_gid_table *table, 322 struct ib_gid_table_entry *entry) 323{ 324 entry->state = GID_TABLE_ENTRY_VALID; 325 326 dev_dbg(&entry->attr.device->dev, "%s port=%d index=%d gid %pI6\n", 327 __func__, entry->attr.port_num, entry->attr.index, 328 entry->attr.gid.raw); 329 330 lockdep_assert_held(&table->lock); 331 write_lock_irq(&table->rwlock); 332 table->data_vec[entry->attr.index] = entry; 333 write_unlock_irq(&table->rwlock); 334} 335 336static void get_gid_entry(struct ib_gid_table_entry *entry) 337{ 338 kref_get(&entry->kref); 339} 340 341static void put_gid_entry(struct ib_gid_table_entry *entry) 342{ 343 kref_put(&entry->kref, schedule_free_gid); 344} 345 346static void put_gid_entry_locked(struct ib_gid_table_entry *entry) 347{ 348 kref_put(&entry->kref, free_gid_entry); 349} 350 351static int add_roce_gid(struct ib_gid_table_entry *entry) 352{ 353 const struct ib_gid_attr *attr = &entry->attr; 354 int ret; 355 356 if (!attr->ndev) { 357 dev_err(&attr->device->dev, "%s NULL netdev port=%d index=%d\n", 358 __func__, attr->port_num, attr->index); 359 return -EINVAL; 360 } 361 if (rdma_cap_roce_gid_table(attr->device, attr->port_num)) { 362 ret = attr->device->ops.add_gid(attr, &entry->context); 363 if (ret) { 364 dev_err(&attr->device->dev, 365 "%s GID add failed port=%d index=%d\n", 366 __func__, attr->port_num, attr->index); 367 return ret; 368 } 369 } 370 return 0; 371} 372 373/** 374 * del_gid - Delete GID table entry 375 * 376 * @ib_dev: IB device whose GID entry to be deleted 377 * @port: Port number of the IB device 378 * @table: GID table of the IB device for a port 379 * @ix: GID entry index to delete 380 * 381 */ 382static void del_gid(struct ib_device *ib_dev, u8 port, 383 struct ib_gid_table *table, int ix) 384{ 385 struct roce_gid_ndev_storage *ndev_storage; 386 struct ib_gid_table_entry *entry; 387 388 lockdep_assert_held(&table->lock); 389 390 dev_dbg(&ib_dev->dev, "%s port=%d index=%d gid %pI6\n", __func__, port, 391 ix, table->data_vec[ix]->attr.gid.raw); 392 393 write_lock_irq(&table->rwlock); 394 entry = table->data_vec[ix]; 395 entry->state = GID_TABLE_ENTRY_PENDING_DEL; 396 /* 397 * For non RoCE protocol, GID entry slot is ready to use. 398 */ 399 if (!rdma_protocol_roce(ib_dev, port)) 400 table->data_vec[ix] = NULL; 401 write_unlock_irq(&table->rwlock); 402 403 ndev_storage = entry->ndev_storage; 404 if (ndev_storage) { 405 entry->ndev_storage = NULL; 406 rcu_assign_pointer(entry->attr.ndev, NULL); 407 call_rcu(&ndev_storage->rcu_head, put_gid_ndev); 408 } 409 410 if (rdma_cap_roce_gid_table(ib_dev, port)) 411 ib_dev->ops.del_gid(&entry->attr, &entry->context); 412 413 put_gid_entry_locked(entry); 414} 415 416/** 417 * add_modify_gid - Add or modify GID table entry 418 * 419 * @table: GID table in which GID to be added or modified 420 * @attr: Attributes of the GID 421 * 422 * Returns 0 on success or appropriate error code. It accepts zero 423 * GID addition for non RoCE ports for HCA's who report them as valid 424 * GID. However such zero GIDs are not added to the cache. 425 */ 426static int add_modify_gid(struct ib_gid_table *table, 427 const struct ib_gid_attr *attr) 428{ 429 struct ib_gid_table_entry *entry; 430 int ret = 0; 431 432 /* 433 * Invalidate any old entry in the table to make it safe to write to 434 * this index. 435 */ 436 if (is_gid_entry_valid(table->data_vec[attr->index])) 437 del_gid(attr->device, attr->port_num, table, attr->index); 438 439 /* 440 * Some HCA's report multiple GID entries with only one valid GID, and 441 * leave other unused entries as the zero GID. Convert zero GIDs to 442 * empty table entries instead of storing them. 443 */ 444 if (rdma_is_zero_gid(&attr->gid)) 445 return 0; 446 447 entry = alloc_gid_entry(attr); 448 if (!entry) 449 return -ENOMEM; 450 451 if (rdma_protocol_roce(attr->device, attr->port_num)) { 452 ret = add_roce_gid(entry); 453 if (ret) 454 goto done; 455 } 456 457 store_gid_entry(table, entry); 458 return 0; 459 460done: 461 put_gid_entry(entry); 462 return ret; 463} 464 465/* rwlock should be read locked, or lock should be held */ 466static int find_gid(struct ib_gid_table *table, const union ib_gid *gid, 467 const struct ib_gid_attr *val, bool default_gid, 468 unsigned long mask, int *pempty) 469{ 470 int i = 0; 471 int found = -1; 472 int empty = pempty ? -1 : 0; 473 474 while (i < table->sz && (found < 0 || empty < 0)) { 475 struct ib_gid_table_entry *data = table->data_vec[i]; 476 struct ib_gid_attr *attr; 477 int curr_index = i; 478 479 i++; 480 481 /* find_gid() is used during GID addition where it is expected 482 * to return a free entry slot which is not duplicate. 483 * Free entry slot is requested and returned if pempty is set, 484 * so lookup free slot only if requested. 485 */ 486 if (pempty && empty < 0) { 487 if (is_gid_entry_free(data) && 488 default_gid == 489 is_gid_index_default(table, curr_index)) { 490 /* 491 * Found an invalid (free) entry; allocate it. 492 * If default GID is requested, then our 493 * found slot must be one of the DEFAULT 494 * reserved slots or we fail. 495 * This ensures that only DEFAULT reserved 496 * slots are used for default property GIDs. 497 */ 498 empty = curr_index; 499 } 500 } 501 502 /* 503 * Additionally find_gid() is used to find valid entry during 504 * lookup operation; so ignore the entries which are marked as 505 * pending for removal and the entries which are marked as 506 * invalid. 507 */ 508 if (!is_gid_entry_valid(data)) 509 continue; 510 511 if (found >= 0) 512 continue; 513 514 attr = &data->attr; 515 if (mask & GID_ATTR_FIND_MASK_GID_TYPE && 516 attr->gid_type != val->gid_type) 517 continue; 518 519 if (mask & GID_ATTR_FIND_MASK_GID && 520 memcmp(gid, &data->attr.gid, sizeof(*gid))) 521 continue; 522 523 if (mask & GID_ATTR_FIND_MASK_NETDEV && 524 attr->ndev != val->ndev) 525 continue; 526 527 if (mask & GID_ATTR_FIND_MASK_DEFAULT && 528 is_gid_index_default(table, curr_index) != default_gid) 529 continue; 530 531 found = curr_index; 532 } 533 534 if (pempty) 535 *pempty = empty; 536 537 return found; 538} 539 540static void make_default_gid(struct net_device *dev, union ib_gid *gid) 541{ 542 gid->global.subnet_prefix = cpu_to_be64(0xfe80000000000000LL); 543 addrconf_ifid_eui48(&gid->raw[8], dev); 544} 545 546static int __ib_cache_gid_add(struct ib_device *ib_dev, u8 port, 547 union ib_gid *gid, struct ib_gid_attr *attr, 548 unsigned long mask, bool default_gid) 549{ 550 struct ib_gid_table *table; 551 int ret = 0; 552 int empty; 553 int ix; 554 555 /* Do not allow adding zero GID in support of 556 * IB spec version 1.3 section 4.1.1 point (6) and 557 * section 12.7.10 and section 12.7.20 558 */ 559 if (rdma_is_zero_gid(gid)) 560 return -EINVAL; 561 562 table = rdma_gid_table(ib_dev, port); 563 564 mutex_lock(&table->lock); 565 566 ix = find_gid(table, gid, attr, default_gid, mask, &empty); 567 if (ix >= 0) 568 goto out_unlock; 569 570 if (empty < 0) { 571 ret = -ENOSPC; 572 goto out_unlock; 573 } 574 attr->device = ib_dev; 575 attr->index = empty; 576 attr->port_num = port; 577 attr->gid = *gid; 578 ret = add_modify_gid(table, attr); 579 if (!ret) 580 dispatch_gid_change_event(ib_dev, port); 581 582out_unlock: 583 mutex_unlock(&table->lock); 584 if (ret) 585 pr_warn("%s: unable to add gid %pI6 error=%d\n", 586 __func__, gid->raw, ret); 587 return ret; 588} 589 590int ib_cache_gid_add(struct ib_device *ib_dev, u8 port, 591 union ib_gid *gid, struct ib_gid_attr *attr) 592{ 593 unsigned long mask = GID_ATTR_FIND_MASK_GID | 594 GID_ATTR_FIND_MASK_GID_TYPE | 595 GID_ATTR_FIND_MASK_NETDEV; 596 597 return __ib_cache_gid_add(ib_dev, port, gid, attr, mask, false); 598} 599 600static int 601_ib_cache_gid_del(struct ib_device *ib_dev, u8 port, 602 union ib_gid *gid, struct ib_gid_attr *attr, 603 unsigned long mask, bool default_gid) 604{ 605 struct ib_gid_table *table; 606 int ret = 0; 607 int ix; 608 609 table = rdma_gid_table(ib_dev, port); 610 611 mutex_lock(&table->lock); 612 613 ix = find_gid(table, gid, attr, default_gid, mask, NULL); 614 if (ix < 0) { 615 ret = -EINVAL; 616 goto out_unlock; 617 } 618 619 del_gid(ib_dev, port, table, ix); 620 dispatch_gid_change_event(ib_dev, port); 621 622out_unlock: 623 mutex_unlock(&table->lock); 624 if (ret) 625 pr_debug("%s: can't delete gid %pI6 error=%d\n", 626 __func__, gid->raw, ret); 627 return ret; 628} 629 630int ib_cache_gid_del(struct ib_device *ib_dev, u8 port, 631 union ib_gid *gid, struct ib_gid_attr *attr) 632{ 633 unsigned long mask = GID_ATTR_FIND_MASK_GID | 634 GID_ATTR_FIND_MASK_GID_TYPE | 635 GID_ATTR_FIND_MASK_DEFAULT | 636 GID_ATTR_FIND_MASK_NETDEV; 637 638 return _ib_cache_gid_del(ib_dev, port, gid, attr, mask, false); 639} 640 641int ib_cache_gid_del_all_netdev_gids(struct ib_device *ib_dev, u8 port, 642 struct net_device *ndev) 643{ 644 struct ib_gid_table *table; 645 int ix; 646 bool deleted = false; 647 648 table = rdma_gid_table(ib_dev, port); 649 650 mutex_lock(&table->lock); 651 652 for (ix = 0; ix < table->sz; ix++) { 653 if (is_gid_entry_valid(table->data_vec[ix]) && 654 table->data_vec[ix]->attr.ndev == ndev) { 655 del_gid(ib_dev, port, table, ix); 656 deleted = true; 657 } 658 } 659 660 mutex_unlock(&table->lock); 661 662 if (deleted) 663 dispatch_gid_change_event(ib_dev, port); 664 665 return 0; 666} 667 668/** 669 * rdma_find_gid_by_port - Returns the GID entry attributes when it finds 670 * a valid GID entry for given search parameters. It searches for the specified 671 * GID value in the local software cache. 672 * @device: The device to query. 673 * @gid: The GID value to search for. 674 * @gid_type: The GID type to search for. 675 * @port_num: The port number of the device where the GID value should be 676 * searched. 677 * @ndev: In RoCE, the net device of the device. NULL means ignore. 678 * 679 * Returns sgid attributes if the GID is found with valid reference or 680 * returns ERR_PTR for the error. 681 * The caller must invoke rdma_put_gid_attr() to release the reference. 682 */ 683const struct ib_gid_attr * 684rdma_find_gid_by_port(struct ib_device *ib_dev, 685 const union ib_gid *gid, 686 enum ib_gid_type gid_type, 687 u8 port, struct net_device *ndev) 688{ 689 int local_index; 690 struct ib_gid_table *table; 691 unsigned long mask = GID_ATTR_FIND_MASK_GID | 692 GID_ATTR_FIND_MASK_GID_TYPE; 693 struct ib_gid_attr val = {.ndev = ndev, .gid_type = gid_type}; 694 const struct ib_gid_attr *attr; 695 unsigned long flags; 696 697 if (!rdma_is_port_valid(ib_dev, port)) 698 return ERR_PTR(-ENOENT); 699 700 table = rdma_gid_table(ib_dev, port); 701 702 if (ndev) 703 mask |= GID_ATTR_FIND_MASK_NETDEV; 704 705 read_lock_irqsave(&table->rwlock, flags); 706 local_index = find_gid(table, gid, &val, false, mask, NULL); 707 if (local_index >= 0) { 708 get_gid_entry(table->data_vec[local_index]); 709 attr = &table->data_vec[local_index]->attr; 710 read_unlock_irqrestore(&table->rwlock, flags); 711 return attr; 712 } 713 714 read_unlock_irqrestore(&table->rwlock, flags); 715 return ERR_PTR(-ENOENT); 716} 717EXPORT_SYMBOL(rdma_find_gid_by_port); 718 719/** 720 * rdma_find_gid_by_filter - Returns the GID table attribute where a 721 * specified GID value occurs 722 * @device: The device to query. 723 * @gid: The GID value to search for. 724 * @port: The port number of the device where the GID value could be 725 * searched. 726 * @filter: The filter function is executed on any matching GID in the table. 727 * If the filter function returns true, the corresponding index is returned, 728 * otherwise, we continue searching the GID table. It's guaranteed that 729 * while filter is executed, ndev field is valid and the structure won't 730 * change. filter is executed in an atomic context. filter must not be NULL. 731 * 732 * rdma_find_gid_by_filter() searches for the specified GID value 733 * of which the filter function returns true in the port's GID table. 734 * 735 */ 736const struct ib_gid_attr *rdma_find_gid_by_filter( 737 struct ib_device *ib_dev, const union ib_gid *gid, u8 port, 738 bool (*filter)(const union ib_gid *gid, const struct ib_gid_attr *, 739 void *), 740 void *context) 741{ 742 const struct ib_gid_attr *res = ERR_PTR(-ENOENT); 743 struct ib_gid_table *table; 744 unsigned long flags; 745 unsigned int i; 746 747 if (!rdma_is_port_valid(ib_dev, port)) 748 return ERR_PTR(-EINVAL); 749 750 table = rdma_gid_table(ib_dev, port); 751 752 read_lock_irqsave(&table->rwlock, flags); 753 for (i = 0; i < table->sz; i++) { 754 struct ib_gid_table_entry *entry = table->data_vec[i]; 755 756 if (!is_gid_entry_valid(entry)) 757 continue; 758 759 if (memcmp(gid, &entry->attr.gid, sizeof(*gid))) 760 continue; 761 762 if (filter(gid, &entry->attr, context)) { 763 get_gid_entry(entry); 764 res = &entry->attr; 765 break; 766 } 767 } 768 read_unlock_irqrestore(&table->rwlock, flags); 769 return res; 770} 771 772static struct ib_gid_table *alloc_gid_table(int sz) 773{ 774 struct ib_gid_table *table = kzalloc(sizeof(*table), GFP_KERNEL); 775 776 if (!table) 777 return NULL; 778 779 table->data_vec = kcalloc(sz, sizeof(*table->data_vec), GFP_KERNEL); 780 if (!table->data_vec) 781 goto err_free_table; 782 783 mutex_init(&table->lock); 784 785 table->sz = sz; 786 rwlock_init(&table->rwlock); 787 return table; 788 789err_free_table: 790 kfree(table); 791 return NULL; 792} 793 794static void release_gid_table(struct ib_device *device, 795 struct ib_gid_table *table) 796{ 797 bool leak = false; 798 int i; 799 800 if (!table) 801 return; 802 803 for (i = 0; i < table->sz; i++) { 804 if (is_gid_entry_free(table->data_vec[i])) 805 continue; 806 if (kref_read(&table->data_vec[i]->kref) > 1) { 807 dev_err(&device->dev, 808 "GID entry ref leak for index %d ref=%d\n", i, 809 kref_read(&table->data_vec[i]->kref)); 810 leak = true; 811 } 812 } 813 if (leak) 814 return; 815 816 mutex_destroy(&table->lock); 817 kfree(table->data_vec); 818 kfree(table); 819} 820 821static void cleanup_gid_table_port(struct ib_device *ib_dev, u8 port, 822 struct ib_gid_table *table) 823{ 824 int i; 825 826 if (!table) 827 return; 828 829 mutex_lock(&table->lock); 830 for (i = 0; i < table->sz; ++i) { 831 if (is_gid_entry_valid(table->data_vec[i])) 832 del_gid(ib_dev, port, table, i); 833 } 834 mutex_unlock(&table->lock); 835} 836 837void ib_cache_gid_set_default_gid(struct ib_device *ib_dev, u8 port, 838 struct net_device *ndev, 839 unsigned long gid_type_mask, 840 enum ib_cache_gid_default_mode mode) 841{ 842 union ib_gid gid = { }; 843 struct ib_gid_attr gid_attr; 844 unsigned int gid_type; 845 unsigned long mask; 846 847 mask = GID_ATTR_FIND_MASK_GID_TYPE | 848 GID_ATTR_FIND_MASK_DEFAULT | 849 GID_ATTR_FIND_MASK_NETDEV; 850 memset(&gid_attr, 0, sizeof(gid_attr)); 851 gid_attr.ndev = ndev; 852 853 for (gid_type = 0; gid_type < IB_GID_TYPE_SIZE; ++gid_type) { 854 if (1UL << gid_type & ~gid_type_mask) 855 continue; 856 857 gid_attr.gid_type = gid_type; 858 859 if (mode == IB_CACHE_GID_DEFAULT_MODE_SET) { 860 make_default_gid(ndev, &gid); 861 __ib_cache_gid_add(ib_dev, port, &gid, 862 &gid_attr, mask, true); 863 } else if (mode == IB_CACHE_GID_DEFAULT_MODE_DELETE) { 864 _ib_cache_gid_del(ib_dev, port, &gid, 865 &gid_attr, mask, true); 866 } 867 } 868} 869 870static void gid_table_reserve_default(struct ib_device *ib_dev, u8 port, 871 struct ib_gid_table *table) 872{ 873 unsigned int i; 874 unsigned long roce_gid_type_mask; 875 unsigned int num_default_gids; 876 877 roce_gid_type_mask = roce_gid_type_mask_support(ib_dev, port); 878 num_default_gids = hweight_long(roce_gid_type_mask); 879 /* Reserve starting indices for default GIDs */ 880 for (i = 0; i < num_default_gids && i < table->sz; i++) 881 table->default_gid_indices |= BIT(i); 882} 883 884 885static void gid_table_release_one(struct ib_device *ib_dev) 886{ 887 unsigned int p; 888 889 rdma_for_each_port (ib_dev, p) { 890 release_gid_table(ib_dev, ib_dev->port_data[p].cache.gid); 891 ib_dev->port_data[p].cache.gid = NULL; 892 } 893} 894 895static int _gid_table_setup_one(struct ib_device *ib_dev) 896{ 897 struct ib_gid_table *table; 898 unsigned int rdma_port; 899 900 rdma_for_each_port (ib_dev, rdma_port) { 901 table = alloc_gid_table( 902 ib_dev->port_data[rdma_port].immutable.gid_tbl_len); 903 if (!table) 904 goto rollback_table_setup; 905 906 gid_table_reserve_default(ib_dev, rdma_port, table); 907 ib_dev->port_data[rdma_port].cache.gid = table; 908 } 909 return 0; 910 911rollback_table_setup: 912 gid_table_release_one(ib_dev); 913 return -ENOMEM; 914} 915 916static void gid_table_cleanup_one(struct ib_device *ib_dev) 917{ 918 unsigned int p; 919 920 rdma_for_each_port (ib_dev, p) 921 cleanup_gid_table_port(ib_dev, p, 922 ib_dev->port_data[p].cache.gid); 923} 924 925static int gid_table_setup_one(struct ib_device *ib_dev) 926{ 927 int err; 928 929 err = _gid_table_setup_one(ib_dev); 930 931 if (err) 932 return err; 933 934 rdma_roce_rescan_device(ib_dev); 935 936 return err; 937} 938 939/** 940 * rdma_query_gid - Read the GID content from the GID software cache 941 * @device: Device to query the GID 942 * @port_num: Port number of the device 943 * @index: Index of the GID table entry to read 944 * @gid: Pointer to GID where to store the entry's GID 945 * 946 * rdma_query_gid() only reads the GID entry content for requested device, 947 * port and index. It reads for IB, RoCE and iWarp link layers. It doesn't 948 * hold any reference to the GID table entry in the HCA or software cache. 949 * 950 * Returns 0 on success or appropriate error code. 951 * 952 */ 953int rdma_query_gid(struct ib_device *device, u8 port_num, 954 int index, union ib_gid *gid) 955{ 956 struct ib_gid_table *table; 957 unsigned long flags; 958 int res = -EINVAL; 959 960 if (!rdma_is_port_valid(device, port_num)) 961 return -EINVAL; 962 963 table = rdma_gid_table(device, port_num); 964 read_lock_irqsave(&table->rwlock, flags); 965 966 if (index < 0 || index >= table->sz || 967 !is_gid_entry_valid(table->data_vec[index])) 968 goto done; 969 970 memcpy(gid, &table->data_vec[index]->attr.gid, sizeof(*gid)); 971 res = 0; 972 973done: 974 read_unlock_irqrestore(&table->rwlock, flags); 975 return res; 976} 977EXPORT_SYMBOL(rdma_query_gid); 978 979/** 980 * rdma_read_gid_hw_context - Read the HW GID context from GID attribute 981 * @attr: Potinter to the GID attribute 982 * 983 * rdma_read_gid_hw_context() reads the drivers GID HW context corresponding 984 * to the SGID attr. Callers are required to already be holding the reference 985 * to an existing GID entry. 986 * 987 * Returns the HW GID context 988 * 989 */ 990void *rdma_read_gid_hw_context(const struct ib_gid_attr *attr) 991{ 992 return container_of(attr, struct ib_gid_table_entry, attr)->context; 993} 994EXPORT_SYMBOL(rdma_read_gid_hw_context); 995 996/** 997 * rdma_find_gid - Returns SGID attributes if the matching GID is found. 998 * @device: The device to query. 999 * @gid: The GID value to search for. 1000 * @gid_type: The GID type to search for. 1001 * @ndev: In RoCE, the net device of the device. NULL means ignore. 1002 * 1003 * rdma_find_gid() searches for the specified GID value in the software cache. 1004 * 1005 * Returns GID attributes if a valid GID is found or returns ERR_PTR for the 1006 * error. The caller must invoke rdma_put_gid_attr() to release the reference. 1007 * 1008 */ 1009const struct ib_gid_attr *rdma_find_gid(struct ib_device *device, 1010 const union ib_gid *gid, 1011 enum ib_gid_type gid_type, 1012 struct net_device *ndev) 1013{ 1014 unsigned long mask = GID_ATTR_FIND_MASK_GID | 1015 GID_ATTR_FIND_MASK_GID_TYPE; 1016 struct ib_gid_attr gid_attr_val = {.ndev = ndev, .gid_type = gid_type}; 1017 unsigned int p; 1018 1019 if (ndev) 1020 mask |= GID_ATTR_FIND_MASK_NETDEV; 1021 1022 rdma_for_each_port(device, p) { 1023 struct ib_gid_table *table; 1024 unsigned long flags; 1025 int index; 1026 1027 table = device->port_data[p].cache.gid; 1028 read_lock_irqsave(&table->rwlock, flags); 1029 index = find_gid(table, gid, &gid_attr_val, false, mask, NULL); 1030 if (index >= 0) { 1031 const struct ib_gid_attr *attr; 1032 1033 get_gid_entry(table->data_vec[index]); 1034 attr = &table->data_vec[index]->attr; 1035 read_unlock_irqrestore(&table->rwlock, flags); 1036 return attr; 1037 } 1038 read_unlock_irqrestore(&table->rwlock, flags); 1039 } 1040 1041 return ERR_PTR(-ENOENT); 1042} 1043EXPORT_SYMBOL(rdma_find_gid); 1044 1045int ib_get_cached_pkey(struct ib_device *device, 1046 u8 port_num, 1047 int index, 1048 u16 *pkey) 1049{ 1050 struct ib_pkey_cache *cache; 1051 unsigned long flags; 1052 int ret = 0; 1053 1054 if (!rdma_is_port_valid(device, port_num)) 1055 return -EINVAL; 1056 1057 read_lock_irqsave(&device->cache_lock, flags); 1058 1059 cache = device->port_data[port_num].cache.pkey; 1060 1061 if (!cache || index < 0 || index >= cache->table_len) 1062 ret = -EINVAL; 1063 else 1064 *pkey = cache->table[index]; 1065 1066 read_unlock_irqrestore(&device->cache_lock, flags); 1067 1068 return ret; 1069} 1070EXPORT_SYMBOL(ib_get_cached_pkey); 1071 1072int ib_get_cached_subnet_prefix(struct ib_device *device, 1073 u8 port_num, 1074 u64 *sn_pfx) 1075{ 1076 unsigned long flags; 1077 1078 if (!rdma_is_port_valid(device, port_num)) 1079 return -EINVAL; 1080 1081 read_lock_irqsave(&device->cache_lock, flags); 1082 *sn_pfx = device->port_data[port_num].cache.subnet_prefix; 1083 read_unlock_irqrestore(&device->cache_lock, flags); 1084 1085 return 0; 1086} 1087EXPORT_SYMBOL(ib_get_cached_subnet_prefix); 1088 1089int ib_find_cached_pkey(struct ib_device *device, 1090 u8 port_num, 1091 u16 pkey, 1092 u16 *index) 1093{ 1094 struct ib_pkey_cache *cache; 1095 unsigned long flags; 1096 int i; 1097 int ret = -ENOENT; 1098 int partial_ix = -1; 1099 1100 if (!rdma_is_port_valid(device, port_num)) 1101 return -EINVAL; 1102 1103 read_lock_irqsave(&device->cache_lock, flags); 1104 1105 cache = device->port_data[port_num].cache.pkey; 1106 if (!cache) { 1107 ret = -EINVAL; 1108 goto err; 1109 } 1110 1111 *index = -1; 1112 1113 for (i = 0; i < cache->table_len; ++i) 1114 if ((cache->table[i] & 0x7fff) == (pkey & 0x7fff)) { 1115 if (cache->table[i] & 0x8000) { 1116 *index = i; 1117 ret = 0; 1118 break; 1119 } else 1120 partial_ix = i; 1121 } 1122 1123 if (ret && partial_ix >= 0) { 1124 *index = partial_ix; 1125 ret = 0; 1126 } 1127 1128err: 1129 read_unlock_irqrestore(&device->cache_lock, flags); 1130 1131 return ret; 1132} 1133EXPORT_SYMBOL(ib_find_cached_pkey); 1134 1135int ib_find_exact_cached_pkey(struct ib_device *device, 1136 u8 port_num, 1137 u16 pkey, 1138 u16 *index) 1139{ 1140 struct ib_pkey_cache *cache; 1141 unsigned long flags; 1142 int i; 1143 int ret = -ENOENT; 1144 1145 if (!rdma_is_port_valid(device, port_num)) 1146 return -EINVAL; 1147 1148 read_lock_irqsave(&device->cache_lock, flags); 1149 1150 cache = device->port_data[port_num].cache.pkey; 1151 if (!cache) { 1152 ret = -EINVAL; 1153 goto err; 1154 } 1155 1156 *index = -1; 1157 1158 for (i = 0; i < cache->table_len; ++i) 1159 if (cache->table[i] == pkey) { 1160 *index = i; 1161 ret = 0; 1162 break; 1163 } 1164 1165err: 1166 read_unlock_irqrestore(&device->cache_lock, flags); 1167 1168 return ret; 1169} 1170EXPORT_SYMBOL(ib_find_exact_cached_pkey); 1171 1172int ib_get_cached_lmc(struct ib_device *device, 1173 u8 port_num, 1174 u8 *lmc) 1175{ 1176 unsigned long flags; 1177 int ret = 0; 1178 1179 if (!rdma_is_port_valid(device, port_num)) 1180 return -EINVAL; 1181 1182 read_lock_irqsave(&device->cache_lock, flags); 1183 *lmc = device->port_data[port_num].cache.lmc; 1184 read_unlock_irqrestore(&device->cache_lock, flags); 1185 1186 return ret; 1187} 1188EXPORT_SYMBOL(ib_get_cached_lmc); 1189 1190int ib_get_cached_port_state(struct ib_device *device, 1191 u8 port_num, 1192 enum ib_port_state *port_state) 1193{ 1194 unsigned long flags; 1195 int ret = 0; 1196 1197 if (!rdma_is_port_valid(device, port_num)) 1198 return -EINVAL; 1199 1200 read_lock_irqsave(&device->cache_lock, flags); 1201 *port_state = device->port_data[port_num].cache.port_state; 1202 read_unlock_irqrestore(&device->cache_lock, flags); 1203 1204 return ret; 1205} 1206EXPORT_SYMBOL(ib_get_cached_port_state); 1207 1208/** 1209 * rdma_get_gid_attr - Returns GID attributes for a port of a device 1210 * at a requested gid_index, if a valid GID entry exists. 1211 * @device: The device to query. 1212 * @port_num: The port number on the device where the GID value 1213 * is to be queried. 1214 * @index: Index of the GID table entry whose attributes are to 1215 * be queried. 1216 * 1217 * rdma_get_gid_attr() acquires reference count of gid attributes from the 1218 * cached GID table. Caller must invoke rdma_put_gid_attr() to release 1219 * reference to gid attribute regardless of link layer. 1220 * 1221 * Returns pointer to valid gid attribute or ERR_PTR for the appropriate error 1222 * code. 1223 */ 1224const struct ib_gid_attr * 1225rdma_get_gid_attr(struct ib_device *device, u8 port_num, int index) 1226{ 1227 const struct ib_gid_attr *attr = ERR_PTR(-ENODATA); 1228 struct ib_gid_table *table; 1229 unsigned long flags; 1230 1231 if (!rdma_is_port_valid(device, port_num)) 1232 return ERR_PTR(-EINVAL); 1233 1234 table = rdma_gid_table(device, port_num); 1235 if (index < 0 || index >= table->sz) 1236 return ERR_PTR(-EINVAL); 1237 1238 read_lock_irqsave(&table->rwlock, flags); 1239 if (!is_gid_entry_valid(table->data_vec[index])) 1240 goto done; 1241 1242 get_gid_entry(table->data_vec[index]); 1243 attr = &table->data_vec[index]->attr; 1244done: 1245 read_unlock_irqrestore(&table->rwlock, flags); 1246 return attr; 1247} 1248EXPORT_SYMBOL(rdma_get_gid_attr); 1249 1250/** 1251 * rdma_query_gid_table - Reads GID table entries of all the ports of a device up to max_entries. 1252 * @device: The device to query. 1253 * @entries: Entries where GID entries are returned. 1254 * @max_entries: Maximum number of entries that can be returned. 1255 * Entries array must be allocated to hold max_entries number of entries. 1256 * @num_entries: Updated to the number of entries that were successfully read. 1257 * 1258 * Returns number of entries on success or appropriate error code. 1259 */ 1260ssize_t rdma_query_gid_table(struct ib_device *device, 1261 struct ib_uverbs_gid_entry *entries, 1262 size_t max_entries) 1263{ 1264 const struct ib_gid_attr *gid_attr; 1265 ssize_t num_entries = 0, ret; 1266 struct ib_gid_table *table; 1267 unsigned int port_num, i; 1268 struct net_device *ndev; 1269 unsigned long flags; 1270 1271 rdma_for_each_port(device, port_num) { 1272 table = rdma_gid_table(device, port_num); 1273 read_lock_irqsave(&table->rwlock, flags); 1274 for (i = 0; i < table->sz; i++) { 1275 if (!is_gid_entry_valid(table->data_vec[i])) 1276 continue; 1277 if (num_entries >= max_entries) { 1278 ret = -EINVAL; 1279 goto err; 1280 } 1281 1282 gid_attr = &table->data_vec[i]->attr; 1283 1284 memcpy(&entries->gid, &gid_attr->gid, 1285 sizeof(gid_attr->gid)); 1286 entries->gid_index = gid_attr->index; 1287 entries->port_num = gid_attr->port_num; 1288 entries->gid_type = gid_attr->gid_type; 1289 ndev = rcu_dereference_protected( 1290 gid_attr->ndev, 1291 lockdep_is_held(&table->rwlock)); 1292 if (ndev) 1293 entries->netdev_ifindex = ndev->ifindex; 1294 1295 num_entries++; 1296 entries++; 1297 } 1298 read_unlock_irqrestore(&table->rwlock, flags); 1299 } 1300 1301 return num_entries; 1302err: 1303 read_unlock_irqrestore(&table->rwlock, flags); 1304 return ret; 1305} 1306EXPORT_SYMBOL(rdma_query_gid_table); 1307 1308/** 1309 * rdma_put_gid_attr - Release reference to the GID attribute 1310 * @attr: Pointer to the GID attribute whose reference 1311 * needs to be released. 1312 * 1313 * rdma_put_gid_attr() must be used to release reference whose 1314 * reference is acquired using rdma_get_gid_attr() or any APIs 1315 * which returns a pointer to the ib_gid_attr regardless of link layer 1316 * of IB or RoCE. 1317 * 1318 */ 1319void rdma_put_gid_attr(const struct ib_gid_attr *attr) 1320{ 1321 struct ib_gid_table_entry *entry = 1322 container_of(attr, struct ib_gid_table_entry, attr); 1323 1324 put_gid_entry(entry); 1325} 1326EXPORT_SYMBOL(rdma_put_gid_attr); 1327 1328/** 1329 * rdma_hold_gid_attr - Get reference to existing GID attribute 1330 * 1331 * @attr: Pointer to the GID attribute whose reference 1332 * needs to be taken. 1333 * 1334 * Increase the reference count to a GID attribute to keep it from being 1335 * freed. Callers are required to already be holding a reference to attribute. 1336 * 1337 */ 1338void rdma_hold_gid_attr(const struct ib_gid_attr *attr) 1339{ 1340 struct ib_gid_table_entry *entry = 1341 container_of(attr, struct ib_gid_table_entry, attr); 1342 1343 get_gid_entry(entry); 1344} 1345EXPORT_SYMBOL(rdma_hold_gid_attr); 1346 1347/** 1348 * rdma_read_gid_attr_ndev_rcu - Read GID attribute netdevice 1349 * which must be in UP state. 1350 * 1351 * @attr:Pointer to the GID attribute 1352 * 1353 * Returns pointer to netdevice if the netdevice was attached to GID and 1354 * netdevice is in UP state. Caller must hold RCU lock as this API 1355 * reads the netdev flags which can change while netdevice migrates to 1356 * different net namespace. Returns ERR_PTR with error code otherwise. 1357 * 1358 */ 1359struct net_device *rdma_read_gid_attr_ndev_rcu(const struct ib_gid_attr *attr) 1360{ 1361 struct ib_gid_table_entry *entry = 1362 container_of(attr, struct ib_gid_table_entry, attr); 1363 struct ib_device *device = entry->attr.device; 1364 struct net_device *ndev = ERR_PTR(-EINVAL); 1365 u8 port_num = entry->attr.port_num; 1366 struct ib_gid_table *table; 1367 unsigned long flags; 1368 bool valid; 1369 1370 table = rdma_gid_table(device, port_num); 1371 1372 read_lock_irqsave(&table->rwlock, flags); 1373 valid = is_gid_entry_valid(table->data_vec[attr->index]); 1374 if (valid) { 1375 ndev = rcu_dereference(attr->ndev); 1376 if (!ndev) 1377 ndev = ERR_PTR(-ENODEV); 1378 } 1379 read_unlock_irqrestore(&table->rwlock, flags); 1380 return ndev; 1381} 1382EXPORT_SYMBOL(rdma_read_gid_attr_ndev_rcu); 1383 1384static int get_lower_dev_vlan(struct net_device *lower_dev, 1385 struct netdev_nested_priv *priv) 1386{ 1387 u16 *vlan_id = (u16 *)priv->data; 1388 1389 if (is_vlan_dev(lower_dev)) 1390 *vlan_id = vlan_dev_vlan_id(lower_dev); 1391 1392 /* We are interested only in first level vlan device, so 1393 * always return 1 to stop iterating over next level devices. 1394 */ 1395 return 1; 1396} 1397 1398/** 1399 * rdma_read_gid_l2_fields - Read the vlan ID and source MAC address 1400 * of a GID entry. 1401 * 1402 * @attr: GID attribute pointer whose L2 fields to be read 1403 * @vlan_id: Pointer to vlan id to fill up if the GID entry has 1404 * vlan id. It is optional. 1405 * @smac: Pointer to smac to fill up for a GID entry. It is optional. 1406 * 1407 * rdma_read_gid_l2_fields() returns 0 on success and returns vlan id 1408 * (if gid entry has vlan) and source MAC, or returns error. 1409 */ 1410int rdma_read_gid_l2_fields(const struct ib_gid_attr *attr, 1411 u16 *vlan_id, u8 *smac) 1412{ 1413 struct netdev_nested_priv priv = { 1414 .data = (void *)vlan_id, 1415 }; 1416 struct net_device *ndev; 1417 1418 rcu_read_lock(); 1419 ndev = rcu_dereference(attr->ndev); 1420 if (!ndev) { 1421 rcu_read_unlock(); 1422 return -ENODEV; 1423 } 1424 if (smac) 1425 ether_addr_copy(smac, ndev->dev_addr); 1426 if (vlan_id) { 1427 *vlan_id = 0xffff; 1428 if (is_vlan_dev(ndev)) { 1429 *vlan_id = vlan_dev_vlan_id(ndev); 1430 } else { 1431 /* If the netdev is upper device and if it's lower 1432 * device is vlan device, consider vlan id of the 1433 * the lower vlan device for this gid entry. 1434 */ 1435 netdev_walk_all_lower_dev_rcu(attr->ndev, 1436 get_lower_dev_vlan, &priv); 1437 } 1438 } 1439 rcu_read_unlock(); 1440 return 0; 1441} 1442EXPORT_SYMBOL(rdma_read_gid_l2_fields); 1443 1444static int config_non_roce_gid_cache(struct ib_device *device, 1445 u8 port, int gid_tbl_len) 1446{ 1447 struct ib_gid_attr gid_attr = {}; 1448 struct ib_gid_table *table; 1449 int ret = 0; 1450 int i; 1451 1452 gid_attr.device = device; 1453 gid_attr.port_num = port; 1454 table = rdma_gid_table(device, port); 1455 1456 mutex_lock(&table->lock); 1457 for (i = 0; i < gid_tbl_len; ++i) { 1458 if (!device->ops.query_gid) 1459 continue; 1460 ret = device->ops.query_gid(device, port, i, &gid_attr.gid); 1461 if (ret) { 1462 dev_warn(&device->dev, 1463 "query_gid failed (%d) for index %d\n", ret, 1464 i); 1465 goto err; 1466 } 1467 gid_attr.index = i; 1468 add_modify_gid(table, &gid_attr); 1469 } 1470err: 1471 mutex_unlock(&table->lock); 1472 return ret; 1473} 1474 1475static int 1476ib_cache_update(struct ib_device *device, u8 port, bool enforce_security) 1477{ 1478 struct ib_port_attr *tprops = NULL; 1479 struct ib_pkey_cache *pkey_cache = NULL, *old_pkey_cache; 1480 int i; 1481 int ret; 1482 1483 if (!rdma_is_port_valid(device, port)) 1484 return -EINVAL; 1485 1486 tprops = kmalloc(sizeof *tprops, GFP_KERNEL); 1487 if (!tprops) 1488 return -ENOMEM; 1489 1490 ret = ib_query_port(device, port, tprops); 1491 if (ret) { 1492 dev_warn(&device->dev, "ib_query_port failed (%d)\n", ret); 1493 goto err; 1494 } 1495 1496 if (!rdma_protocol_roce(device, port)) { 1497 ret = config_non_roce_gid_cache(device, port, 1498 tprops->gid_tbl_len); 1499 if (ret) 1500 goto err; 1501 } 1502 1503 if (tprops->pkey_tbl_len) { 1504 pkey_cache = kmalloc(struct_size(pkey_cache, table, 1505 tprops->pkey_tbl_len), 1506 GFP_KERNEL); 1507 if (!pkey_cache) { 1508 ret = -ENOMEM; 1509 goto err; 1510 } 1511 1512 pkey_cache->table_len = tprops->pkey_tbl_len; 1513 1514 for (i = 0; i < pkey_cache->table_len; ++i) { 1515 ret = ib_query_pkey(device, port, i, 1516 pkey_cache->table + i); 1517 if (ret) { 1518 dev_warn(&device->dev, 1519 "ib_query_pkey failed (%d) for index %d\n", 1520 ret, i); 1521 goto err; 1522 } 1523 } 1524 } 1525 1526 write_lock_irq(&device->cache_lock); 1527 1528 old_pkey_cache = device->port_data[port].cache.pkey; 1529 1530 device->port_data[port].cache.pkey = pkey_cache; 1531 device->port_data[port].cache.lmc = tprops->lmc; 1532 device->port_data[port].cache.port_state = tprops->state; 1533 1534 device->port_data[port].cache.subnet_prefix = tprops->subnet_prefix; 1535 write_unlock_irq(&device->cache_lock); 1536 1537 if (enforce_security) 1538 ib_security_cache_change(device, 1539 port, 1540 tprops->subnet_prefix); 1541 1542 kfree(old_pkey_cache); 1543 kfree(tprops); 1544 return 0; 1545 1546err: 1547 kfree(pkey_cache); 1548 kfree(tprops); 1549 return ret; 1550} 1551 1552static void ib_cache_event_task(struct work_struct *_work) 1553{ 1554 struct ib_update_work *work = 1555 container_of(_work, struct ib_update_work, work); 1556 int ret; 1557 1558 /* Before distributing the cache update event, first sync 1559 * the cache. 1560 */ 1561 ret = ib_cache_update(work->event.device, work->event.element.port_num, 1562 work->enforce_security); 1563 1564 /* GID event is notified already for individual GID entries by 1565 * dispatch_gid_change_event(). Hence, notifiy for rest of the 1566 * events. 1567 */ 1568 if (!ret && work->event.event != IB_EVENT_GID_CHANGE) 1569 ib_dispatch_event_clients(&work->event); 1570 1571 kfree(work); 1572} 1573 1574static void ib_generic_event_task(struct work_struct *_work) 1575{ 1576 struct ib_update_work *work = 1577 container_of(_work, struct ib_update_work, work); 1578 1579 ib_dispatch_event_clients(&work->event); 1580 kfree(work); 1581} 1582 1583static bool is_cache_update_event(const struct ib_event *event) 1584{ 1585 return (event->event == IB_EVENT_PORT_ERR || 1586 event->event == IB_EVENT_PORT_ACTIVE || 1587 event->event == IB_EVENT_LID_CHANGE || 1588 event->event == IB_EVENT_PKEY_CHANGE || 1589 event->event == IB_EVENT_CLIENT_REREGISTER || 1590 event->event == IB_EVENT_GID_CHANGE); 1591} 1592 1593/** 1594 * ib_dispatch_event - Dispatch an asynchronous event 1595 * @event:Event to dispatch 1596 * 1597 * Low-level drivers must call ib_dispatch_event() to dispatch the 1598 * event to all registered event handlers when an asynchronous event 1599 * occurs. 1600 */ 1601void ib_dispatch_event(const struct ib_event *event) 1602{ 1603 struct ib_update_work *work; 1604 1605 work = kzalloc(sizeof(*work), GFP_ATOMIC); 1606 if (!work) 1607 return; 1608 1609 if (is_cache_update_event(event)) 1610 INIT_WORK(&work->work, ib_cache_event_task); 1611 else 1612 INIT_WORK(&work->work, ib_generic_event_task); 1613 1614 work->event = *event; 1615 if (event->event == IB_EVENT_PKEY_CHANGE || 1616 event->event == IB_EVENT_GID_CHANGE) 1617 work->enforce_security = true; 1618 1619 queue_work(ib_wq, &work->work); 1620} 1621EXPORT_SYMBOL(ib_dispatch_event); 1622 1623int ib_cache_setup_one(struct ib_device *device) 1624{ 1625 unsigned int p; 1626 int err; 1627 1628 rwlock_init(&device->cache_lock); 1629 1630 err = gid_table_setup_one(device); 1631 if (err) 1632 return err; 1633 1634 rdma_for_each_port (device, p) { 1635 err = ib_cache_update(device, p, true); 1636 if (err) 1637 return err; 1638 } 1639 1640 return 0; 1641} 1642 1643void ib_cache_release_one(struct ib_device *device) 1644{ 1645 unsigned int p; 1646 1647 /* 1648 * The release function frees all the cache elements. 1649 * This function should be called as part of freeing 1650 * all the device's resources when the cache could no 1651 * longer be accessed. 1652 */ 1653 rdma_for_each_port (device, p) 1654 kfree(device->port_data[p].cache.pkey); 1655 1656 gid_table_release_one(device); 1657} 1658 1659void ib_cache_cleanup_one(struct ib_device *device) 1660{ 1661 /* The cleanup function waits for all in-progress workqueue 1662 * elements and cleans up the GID cache. This function should be 1663 * called after the device was removed from the devices list and 1664 * all clients were removed, so the cache exists but is 1665 * non-functional and shouldn't be updated anymore. 1666 */ 1667 flush_workqueue(ib_wq); 1668 gid_table_cleanup_one(device); 1669 1670 /* 1671 * Flush the wq second time for any pending GID delete work. 1672 */ 1673 flush_workqueue(ib_wq); 1674} 1675