drivers/infiniband/core/cache.c

   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
  47 struct ib_pkey_cache {
  48         int             table_len;
  49         u16             table[0];
  50 };
  51
  52 struct ib_update_work {
  53         struct work_struct work;
  54         struct ib_device  *device;
  55         u8                 port_num;
  56 };
  57
  58 union ib_gid zgid;
  59 EXPORT_SYMBOL(zgid);
  60
  61 static const struct ib_gid_attr zattr;
  62
  63 enum gid_attr_find_mask {
  64         GID_ATTR_FIND_MASK_GID          = 1UL << 0,
  65         GID_ATTR_FIND_MASK_NETDEV       = 1UL << 1,
  66         GID_ATTR_FIND_MASK_DEFAULT      = 1UL << 2,
  67 };
  68
  69 enum gid_table_entry_props {
  70         GID_TABLE_ENTRY_INVALID         = 1UL << 0,
  71         GID_TABLE_ENTRY_DEFAULT         = 1UL << 1,
  72 };
  73
  74 enum gid_table_write_action {
  75         GID_TABLE_WRITE_ACTION_ADD,
  76         GID_TABLE_WRITE_ACTION_DEL,
  77         /* MODIFY only updates the GID table. Currently only used by
  78          * ib_cache_update.
  79          */
  80         GID_TABLE_WRITE_ACTION_MODIFY
  81 };
  82
  83 struct ib_gid_table_entry {
  84         /* This lock protects an entry from being
  85          * read and written simultaneously.
  86          */
  87         rwlock_t            lock;
  88         unsigned long       props;
  89         union ib_gid        gid;
  90         struct ib_gid_attr  attr;
  91         void               *context;
  92 };
  93
  94 struct ib_gid_table {
  95         int                  sz;
  96         /* In RoCE, adding a GID to the table requires:
  97          * (a) Find if this GID is already exists.
  98          * (b) Find a free space.
  99          * (c) Write the new GID
 100          *
 101          * Delete requires different set of operations:
 102          * (a) Find the GID
 103          * (b) Delete it.
 104          *
 105          * Add/delete should be carried out atomically.
 106          * This is done by locking this mutex from multiple
 107          * writers. We don't need this lock for IB, as the MAD
 108          * layer replaces all entries. All data_vec entries
 109          * are locked by this lock.
 110          **/
 111         struct mutex         lock;
 112         struct ib_gid_table_entry *data_vec;
 113 };
 114
 115 static int write_gid(struct ib_device *ib_dev, u8 port,
 116                      struct ib_gid_table *table, int ix,
 117                      const union ib_gid *gid,
 118                      const struct ib_gid_attr *attr,
 119                      enum gid_table_write_action action,
 120                      bool  default_gid)
 121 {
 122         int ret = 0;
 123         struct net_device *old_net_dev;
 124         unsigned long flags;
 125
 126         /* in rdma_cap_roce_gid_table, this funciton should be protected by a
 127          * sleep-able lock.
 128          */
 129         write_lock_irqsave(&table->data_vec[ix].lock, flags);
 130
 131         if (rdma_cap_roce_gid_table(ib_dev, port)) {
 132                 table->data_vec[ix].props |= GID_TABLE_ENTRY_INVALID;
 133                 write_unlock_irqrestore(&table->data_vec[ix].lock, flags);
 134                 /* GID_TABLE_WRITE_ACTION_MODIFY currently isn't supported by
 135                  * RoCE providers and thus only updates the cache.
 136                  */
 137                 if (action == GID_TABLE_WRITE_ACTION_ADD)
 138                         ret = ib_dev->add_gid(ib_dev, port, ix, gid, attr,
 139                                               &table->data_vec[ix].context);
 140                 else if (action == GID_TABLE_WRITE_ACTION_DEL)
 141                         ret = ib_dev->del_gid(ib_dev, port, ix,
 142                                               &table->data_vec[ix].context);
 143                 write_lock_irqsave(&table->data_vec[ix].lock, flags);
 144         }
 145
 146         old_net_dev = table->data_vec[ix].attr.ndev;
 147         if (old_net_dev && old_net_dev != attr->ndev)
 148                 dev_put(old_net_dev);
 149         /* if modify_gid failed, just delete the old gid */
 150         if (ret || action == GID_TABLE_WRITE_ACTION_DEL) {
 151                 gid = &zgid;
 152                 attr = &zattr;
 153                 table->data_vec[ix].context = NULL;
 154         }
 155         if (default_gid)
 156                 table->data_vec[ix].props |= GID_TABLE_ENTRY_DEFAULT;
 157         memcpy(&table->data_vec[ix].gid, gid, sizeof(*gid));
 158         memcpy(&table->data_vec[ix].attr, attr, sizeof(*attr));
 159         if (table->data_vec[ix].attr.ndev &&
 160             table->data_vec[ix].attr.ndev != old_net_dev)
 161                 dev_hold(table->data_vec[ix].attr.ndev);
 162
 163         table->data_vec[ix].props &= ~GID_TABLE_ENTRY_INVALID;
 164
 165         write_unlock_irqrestore(&table->data_vec[ix].lock, flags);
 166
 167         if (!ret && rdma_cap_roce_gid_table(ib_dev, port)) {
 168                 struct ib_event event;
 169
 170                 event.device            = ib_dev;
 171                 event.element.port_num  = port;
 172                 event.event             = IB_EVENT_GID_CHANGE;
 173
 174                 ib_dispatch_event(&event);
 175         }
 176         return ret;
 177 }
 178
 179 static int add_gid(struct ib_device *ib_dev, u8 port,
 180                    struct ib_gid_table *table, int ix,
 181                    const union ib_gid *gid,
 182                    const struct ib_gid_attr *attr,
 183                    bool  default_gid) {
 184         return write_gid(ib_dev, port, table, ix, gid, attr,
 185                          GID_TABLE_WRITE_ACTION_ADD, default_gid);
 186 }
 187
 188 static int modify_gid(struct ib_device *ib_dev, u8 port,
 189                       struct ib_gid_table *table, int ix,
 190                       const union ib_gid *gid,
 191                       const struct ib_gid_attr *attr,
 192                       bool  default_gid) {
 193         return write_gid(ib_dev, port, table, ix, gid, attr,
 194                          GID_TABLE_WRITE_ACTION_MODIFY, default_gid);
 195 }
 196
 197 static int del_gid(struct ib_device *ib_dev, u8 port,
 198                    struct ib_gid_table *table, int ix,
 199                    bool  default_gid) {
 200         return write_gid(ib_dev, port, table, ix, &zgid, &zattr,
 201                          GID_TABLE_WRITE_ACTION_DEL, default_gid);
 202 }
 203
 204 static int find_gid(struct ib_gid_table *table, const union ib_gid *gid,
 205                     const struct ib_gid_attr *val, bool default_gid,
 206                     unsigned long mask)
 207 {
 208         int i;
 209
 210         for (i = 0; i < table->sz; i++) {
 211                 unsigned long flags;
 212                 struct ib_gid_attr *attr = &table->data_vec[i].attr;
 213
 214                 read_lock_irqsave(&table->data_vec[i].lock, flags);
 215
 216                 if (table->data_vec[i].props & GID_TABLE_ENTRY_INVALID)
 217                         goto next;
 218
 219                 if (mask & GID_ATTR_FIND_MASK_GID &&
 220                     memcmp(gid, &table->data_vec[i].gid, sizeof(*gid)))
 221                         goto next;
 222
 223                 if (mask & GID_ATTR_FIND_MASK_NETDEV &&
 224                     attr->ndev != val->ndev)
 225                         goto next;
 226
 227                 if (mask & GID_ATTR_FIND_MASK_DEFAULT &&
 228                     !!(table->data_vec[i].props & GID_TABLE_ENTRY_DEFAULT) !=
 229                     default_gid)
 230                         goto next;
 231
 232                 read_unlock_irqrestore(&table->data_vec[i].lock, flags);
 233                 return i;
 234 next:
 235                 read_unlock_irqrestore(&table->data_vec[i].lock, flags);
 236         }
 237
 238         return -1;
 239 }
 240
 241 static void make_default_gid(struct  net_device *dev, union ib_gid *gid)
 242 {
 243         gid->global.subnet_prefix = cpu_to_be64(0xfe80000000000000LL);
 244         addrconf_ifid_eui48(&gid->raw[8], dev);
 245 }
 246
 247 int ib_cache_gid_add(struct ib_device *ib_dev, u8 port,
 248                      union ib_gid *gid, struct ib_gid_attr *attr)
 249 {
 250         struct ib_gid_table **ports_table = ib_dev->cache.gid_cache;
 251         struct ib_gid_table *table;
 252         int ix;
 253         int ret = 0;
 254         struct net_device *idev;
 255
 256         table = ports_table[port - rdma_start_port(ib_dev)];
 257
 258         if (!memcmp(gid, &zgid, sizeof(*gid)))
 259                 return -EINVAL;
 260
 261         if (ib_dev->get_netdev) {
 262                 idev = ib_dev->get_netdev(ib_dev, port);
 263                 if (idev && attr->ndev != idev) {
 264                         union ib_gid default_gid;
 265
 266                         /* Adding default GIDs in not permitted */
 267                         make_default_gid(idev, &default_gid);
 268                         if (!memcmp(gid, &default_gid, sizeof(*gid))) {
 269                                 dev_put(idev);
 270                                 return -EPERM;
 271                         }
 272                 }
 273                 if (idev)
 274                         dev_put(idev);
 275         }
 276
 277         mutex_lock(&table->lock);
 278
 279         ix = find_gid(table, gid, attr, false, GID_ATTR_FIND_MASK_GID |
 280                       GID_ATTR_FIND_MASK_NETDEV);
 281         if (ix >= 0)
 282                 goto out_unlock;
 283
 284         ix = find_gid(table, &zgid, NULL, false, GID_ATTR_FIND_MASK_GID |
 285                       GID_ATTR_FIND_MASK_DEFAULT);
 286         if (ix < 0) {
 287                 ret = -ENOSPC;
 288                 goto out_unlock;
 289         }
 290
 291         add_gid(ib_dev, port, table, ix, gid, attr, false);
 292
 293 out_unlock:
 294         mutex_unlock(&table->lock);
 295         return ret;
 296 }
 297
 298 int ib_cache_gid_del(struct ib_device *ib_dev, u8 port,
 299                      union ib_gid *gid, struct ib_gid_attr *attr)
 300 {
 301         struct ib_gid_table **ports_table = ib_dev->cache.gid_cache;
 302         struct ib_gid_table *table;
 303         int ix;
 304
 305         table = ports_table[port - rdma_start_port(ib_dev)];
 306
 307         mutex_lock(&table->lock);
 308
 309         ix = find_gid(table, gid, attr, false,
 310                       GID_ATTR_FIND_MASK_GID      |
 311                       GID_ATTR_FIND_MASK_NETDEV   |
 312                       GID_ATTR_FIND_MASK_DEFAULT);
 313         if (ix < 0)
 314                 goto out_unlock;
 315
 316         del_gid(ib_dev, port, table, ix, false);
 317
 318 out_unlock:
 319         mutex_unlock(&table->lock);
 320         return 0;
 321 }
 322
 323 int ib_cache_gid_del_all_netdev_gids(struct ib_device *ib_dev, u8 port,
 324                                      struct net_device *ndev)
 325 {
 326         struct ib_gid_table **ports_table = ib_dev->cache.gid_cache;
 327         struct ib_gid_table *table;
 328         int ix;
 329
 330         table  = ports_table[port - rdma_start_port(ib_dev)];
 331
 332         mutex_lock(&table->lock);
 333
 334         for (ix = 0; ix < table->sz; ix++)
 335                 if (table->data_vec[ix].attr.ndev == ndev)
 336                         del_gid(ib_dev, port, table, ix, false);
 337
 338         mutex_unlock(&table->lock);
 339         return 0;
 340 }
 341
 342 static int __ib_cache_gid_get(struct ib_device *ib_dev, u8 port, int index,
 343                               union ib_gid *gid, struct ib_gid_attr *attr)
 344 {
 345         struct ib_gid_table **ports_table = ib_dev->cache.gid_cache;
 346         struct ib_gid_table *table;
 347         unsigned long flags;
 348
 349         table = ports_table[port - rdma_start_port(ib_dev)];
 350
 351         if (index < 0 || index >= table->sz)
 352                 return -EINVAL;
 353
 354         read_lock_irqsave(&table->data_vec[index].lock, flags);
 355         if (table->data_vec[index].props & GID_TABLE_ENTRY_INVALID) {
 356                 read_unlock_irqrestore(&table->data_vec[index].lock, flags);
 357                 return -EAGAIN;
 358         }
 359
 360         memcpy(gid, &table->data_vec[index].gid, sizeof(*gid));
 361         if (attr) {
 362                 memcpy(attr, &table->data_vec[index].attr, sizeof(*attr));
 363                 if (attr->ndev)
 364                         dev_hold(attr->ndev);
 365         }
 366
 367         read_unlock_irqrestore(&table->data_vec[index].lock, flags);
 368         return 0;
 369 }
 370
 371 static int _ib_cache_gid_table_find(struct ib_device *ib_dev,
 372                                     const union ib_gid *gid,
 373                                     const struct ib_gid_attr *val,
 374                                     unsigned long mask,
 375                                     u8 *port, u16 *index)
 376 {
 377         struct ib_gid_table **ports_table = ib_dev->cache.gid_cache;
 378         struct ib_gid_table *table;
 379         u8 p;
 380         int local_index;
 381
 382         for (p = 0; p < ib_dev->phys_port_cnt; p++) {
 383                 table = ports_table[p];
 384                 local_index = find_gid(table, gid, val, false, mask);
 385                 if (local_index >= 0) {
 386                         if (index)
 387                                 *index = local_index;
 388                         if (port)
 389                                 *port = p + rdma_start_port(ib_dev);
 390                         return 0;
 391                 }
 392         }
 393
 394         return -ENOENT;
 395 }
 396
 397 static int ib_cache_gid_find(struct ib_device *ib_dev,
 398                              const union ib_gid *gid,
 399                              struct net_device *ndev, u8 *port,
 400                              u16 *index)
 401 {
 402         unsigned long mask = GID_ATTR_FIND_MASK_GID;
 403         struct ib_gid_attr gid_attr_val = {.ndev = ndev};
 404
 405         if (ndev)
 406                 mask |= GID_ATTR_FIND_MASK_NETDEV;
 407
 408         return _ib_cache_gid_table_find(ib_dev, gid, &gid_attr_val,
 409                                         mask, port, index);
 410 }
 411
 412 int ib_cache_gid_find_by_port(struct ib_device *ib_dev,
 413                               const union ib_gid *gid,
 414                               u8 port, struct net_device *ndev,
 415                               u16 *index)
 416 {
 417         int local_index;
 418         struct ib_gid_table **ports_table = ib_dev->cache.gid_cache;
 419         struct ib_gid_table *table;
 420         unsigned long mask = GID_ATTR_FIND_MASK_GID;
 421         struct ib_gid_attr val = {.ndev = ndev};
 422
 423         if (port < rdma_start_port(ib_dev) ||
 424             port > rdma_end_port(ib_dev))
 425                 return -ENOENT;
 426
 427         table = ports_table[port - rdma_start_port(ib_dev)];
 428
 429         if (ndev)
 430                 mask |= GID_ATTR_FIND_MASK_NETDEV;
 431
 432         local_index = find_gid(table, gid, &val, false, mask);
 433         if (local_index >= 0) {
 434                 if (index)
 435                         *index = local_index;
 436                 return 0;
 437         }
 438
 439         return -ENOENT;
 440 }
 441
 442 static struct ib_gid_table *alloc_gid_table(int sz)
 443 {
 444         unsigned int i;
 445         struct ib_gid_table *table =
 446                 kzalloc(sizeof(struct ib_gid_table), GFP_KERNEL);
 447         if (!table)
 448                 return NULL;
 449
 450         table->data_vec = kcalloc(sz, sizeof(*table->data_vec), GFP_KERNEL);
 451         if (!table->data_vec)
 452                 goto err_free_table;
 453
 454         mutex_init(&table->lock);
 455
 456         table->sz = sz;
 457
 458         for (i = 0; i < sz; i++)
 459                 rwlock_init(&table->data_vec[i].lock);
 460
 461         return table;
 462
 463 err_free_table:
 464         kfree(table);
 465         return NULL;
 466 }
 467
 468 static void release_gid_table(struct ib_gid_table *table)
 469 {
 470         if (table) {
 471                 kfree(table->data_vec);
 472                 kfree(table);
 473         }
 474 }
 475
 476 static void cleanup_gid_table_port(struct ib_device *ib_dev, u8 port,
 477                                    struct ib_gid_table *table)
 478 {
 479         int i;
 480
 481         if (!table)
 482                 return;
 483
 484         for (i = 0; i < table->sz; ++i) {
 485                 if (memcmp(&table->data_vec[i].gid, &zgid,
 486                            sizeof(table->data_vec[i].gid)))
 487                         del_gid(ib_dev, port, table, i,
 488                                 table->data_vec[i].props &
 489                                 GID_ATTR_FIND_MASK_DEFAULT);
 490         }
 491 }
 492
 493 void ib_cache_gid_set_default_gid(struct ib_device *ib_dev, u8 port,
 494                                   struct net_device *ndev,
 495                                   enum ib_cache_gid_default_mode mode)
 496 {
 497         struct ib_gid_table **ports_table = ib_dev->cache.gid_cache;
 498         union ib_gid gid;
 499         struct ib_gid_attr gid_attr;
 500         struct ib_gid_table *table;
 501         int ix;
 502         union ib_gid current_gid;
 503         struct ib_gid_attr current_gid_attr = {};
 504
 505         table  = ports_table[port - rdma_start_port(ib_dev)];
 506
 507         make_default_gid(ndev, &gid);
 508         memset(&gid_attr, 0, sizeof(gid_attr));
 509         gid_attr.ndev = ndev;
 510
 511         mutex_lock(&table->lock);
 512         ix = find_gid(table, NULL, NULL, true, GID_ATTR_FIND_MASK_DEFAULT);
 513
 514         /* Coudn't find default GID location */
 515         WARN_ON(ix < 0);
 516
 517         if (!__ib_cache_gid_get(ib_dev, port, ix,
 518                                 &current_gid, &current_gid_attr) &&
 519             mode == IB_CACHE_GID_DEFAULT_MODE_SET &&
 520             !memcmp(&gid, &current_gid, sizeof(gid)) &&
 521             !memcmp(&gid_attr, &current_gid_attr, sizeof(gid_attr)))
 522                 goto unlock;
 523
 524         if ((memcmp(&current_gid, &zgid, sizeof(current_gid)) ||
 525              memcmp(&current_gid_attr, &zattr,
 526                     sizeof(current_gid_attr))) &&
 527             del_gid(ib_dev, port, table, ix, true)) {
 528                 pr_warn("ib_cache_gid: can't delete index %d for default gid %pI6\n",
 529                         ix, gid.raw);
 530                 goto unlock;
 531         }
 532
 533         if (mode == IB_CACHE_GID_DEFAULT_MODE_SET)
 534                 if (add_gid(ib_dev, port, table, ix, &gid, &gid_attr, true))
 535                         pr_warn("ib_cache_gid: unable to add default gid %pI6\n",
 536                                 gid.raw);
 537
 538 unlock:
 539         if (current_gid_attr.ndev)
 540                 dev_put(current_gid_attr.ndev);
 541         mutex_unlock(&table->lock);
 542 }
 543
 544 static int gid_table_reserve_default(struct ib_device *ib_dev, u8 port,
 545                                      struct ib_gid_table *table)
 546 {
 547         if (rdma_protocol_roce(ib_dev, port)) {
 548                 struct ib_gid_table_entry *entry = &table->data_vec[0];
 549
 550                 entry->props |= GID_TABLE_ENTRY_DEFAULT;
 551         }
 552
 553         return 0;
 554 }
 555
 556 static int _gid_table_setup_one(struct ib_device *ib_dev)
 557 {
 558         u8 port;
 559         struct ib_gid_table **table;
 560         int err = 0;
 561
 562         table = kcalloc(ib_dev->phys_port_cnt, sizeof(*table), GFP_KERNEL);
 563
 564         if (!table) {
 565                 pr_warn("failed to allocate ib gid cache for %s\n",
 566                         ib_dev->name);
 567                 return -ENOMEM;
 568         }
 569
 570         for (port = 0; port < ib_dev->phys_port_cnt; port++) {
 571                 u8 rdma_port = port + rdma_start_port(ib_dev);
 572
 573                 table[port] =
 574                         alloc_gid_table(
 575                                 ib_dev->port_immutable[rdma_port].gid_tbl_len);
 576                 if (!table[port]) {
 577                         err = -ENOMEM;
 578                         goto rollback_table_setup;
 579                 }
 580
 581                 err = gid_table_reserve_default(ib_dev,
 582                                                 port + rdma_start_port(ib_dev),
 583                                                 table[port]);
 584                 if (err)
 585                         goto rollback_table_setup;
 586         }
 587
 588         ib_dev->cache.gid_cache = table;
 589         return 0;
 590
 591 rollback_table_setup:
 592         for (port = 0; port < ib_dev->phys_port_cnt; port++) {
 593                 cleanup_gid_table_port(ib_dev, port + rdma_start_port(ib_dev),
 594                                        table[port]);
 595                 release_gid_table(table[port]);
 596         }
 597
 598         kfree(table);
 599         return err;
 600 }
 601
 602 static void gid_table_release_one(struct ib_device *ib_dev)
 603 {
 604         struct ib_gid_table **table = ib_dev->cache.gid_cache;
 605         u8 port;
 606
 607         if (!table)
 608                 return;
 609
 610         for (port = 0; port < ib_dev->phys_port_cnt; port++)
 611                 release_gid_table(table[port]);
 612
 613         kfree(table);
 614         ib_dev->cache.gid_cache = NULL;
 615 }
 616
 617 static void gid_table_cleanup_one(struct ib_device *ib_dev)
 618 {
 619         struct ib_gid_table **table = ib_dev->cache.gid_cache;
 620         u8 port;
 621
 622         if (!table)
 623                 return;
 624
 625         for (port = 0; port < ib_dev->phys_port_cnt; port++)
 626                 cleanup_gid_table_port(ib_dev, port + rdma_start_port(ib_dev),
 627                                        table[port]);
 628 }
 629
 630 static int gid_table_setup_one(struct ib_device *ib_dev)
 631 {
 632         int err;
 633
 634         err = _gid_table_setup_one(ib_dev);
 635
 636         if (err)
 637                 return err;
 638
 639         err = roce_rescan_device(ib_dev);
 640
 641         if (err) {
 642                 gid_table_cleanup_one(ib_dev);
 643                 gid_table_release_one(ib_dev);
 644         }
 645
 646         return err;
 647 }
 648
 649 int ib_get_cached_gid(struct ib_device *device,
 650                       u8                port_num,
 651                       int               index,
 652                       union ib_gid     *gid)
 653 {
 654         if (port_num < rdma_start_port(device) || port_num > rdma_end_port(device))
 655                 return -EINVAL;
 656
 657         return __ib_cache_gid_get(device, port_num, index, gid, NULL);
 658 }
 659 EXPORT_SYMBOL(ib_get_cached_gid);
 660
 661 int ib_find_cached_gid(struct ib_device *device,
 662                        const union ib_gid *gid,
 663                        u8               *port_num,
 664                        u16              *index)
 665 {
 666         return ib_cache_gid_find(device, gid, NULL, port_num, index);
 667 }
 668 EXPORT_SYMBOL(ib_find_cached_gid);
 669
 670 int ib_get_cached_pkey(struct ib_device *device,
 671                        u8                port_num,
 672                        int               index,
 673                        u16              *pkey)
 674 {
 675         struct ib_pkey_cache *cache;
 676         unsigned long flags;
 677         int ret = 0;
 678
 679         if (port_num < rdma_start_port(device) || port_num > rdma_end_port(device))
 680                 return -EINVAL;
 681
 682         read_lock_irqsave(&device->cache.lock, flags);
 683
 684         cache = device->cache.pkey_cache[port_num - rdma_start_port(device)];
 685
 686         if (index < 0 || index >= cache->table_len)
 687                 ret = -EINVAL;
 688         else
 689                 *pkey = cache->table[index];
 690
 691         read_unlock_irqrestore(&device->cache.lock, flags);
 692
 693         return ret;
 694 }
 695 EXPORT_SYMBOL(ib_get_cached_pkey);
 696
 697 int ib_find_cached_pkey(struct ib_device *device,
 698                         u8                port_num,
 699                         u16               pkey,
 700                         u16              *index)
 701 {
 702         struct ib_pkey_cache *cache;
 703         unsigned long flags;
 704         int i;
 705         int ret = -ENOENT;
 706         int partial_ix = -1;
 707
 708         if (port_num < rdma_start_port(device) || port_num > rdma_end_port(device))
 709                 return -EINVAL;
 710
 711         read_lock_irqsave(&device->cache.lock, flags);
 712
 713         cache = device->cache.pkey_cache[port_num - rdma_start_port(device)];
 714
 715         *index = -1;
 716
 717         for (i = 0; i < cache->table_len; ++i)
 718                 if ((cache->table[i] & 0x7fff) == (pkey & 0x7fff)) {
 719                         if (cache->table[i] & 0x8000) {
 720                                 *index = i;
 721                                 ret = 0;
 722                                 break;
 723                         } else
 724                                 partial_ix = i;
 725                 }
 726
 727         if (ret && partial_ix >= 0) {
 728                 *index = partial_ix;
 729                 ret = 0;
 730         }
 731
 732         read_unlock_irqrestore(&device->cache.lock, flags);
 733
 734         return ret;
 735 }
 736 EXPORT_SYMBOL(ib_find_cached_pkey);
 737
 738 int ib_find_exact_cached_pkey(struct ib_device *device,
 739                               u8                port_num,
 740                               u16               pkey,
 741                               u16              *index)
 742 {
 743         struct ib_pkey_cache *cache;
 744         unsigned long flags;
 745         int i;
 746         int ret = -ENOENT;
 747
 748         if (port_num < rdma_start_port(device) || port_num > rdma_end_port(device))
 749                 return -EINVAL;
 750
 751         read_lock_irqsave(&device->cache.lock, flags);
 752
 753         cache = device->cache.pkey_cache[port_num - rdma_start_port(device)];
 754
 755         *index = -1;
 756
 757         for (i = 0; i < cache->table_len; ++i)
 758                 if (cache->table[i] == pkey) {
 759                         *index = i;
 760                         ret = 0;
 761                         break;
 762                 }
 763
 764         read_unlock_irqrestore(&device->cache.lock, flags);
 765
 766         return ret;
 767 }
 768 EXPORT_SYMBOL(ib_find_exact_cached_pkey);
 769
 770 int ib_get_cached_lmc(struct ib_device *device,
 771                       u8                port_num,
 772                       u8                *lmc)
 773 {
 774         unsigned long flags;
 775         int ret = 0;
 776
 777         if (port_num < rdma_start_port(device) || port_num > rdma_end_port(device))
 778                 return -EINVAL;
 779
 780         read_lock_irqsave(&device->cache.lock, flags);
 781         *lmc = device->cache.lmc_cache[port_num - rdma_start_port(device)];
 782         read_unlock_irqrestore(&device->cache.lock, flags);
 783
 784         return ret;
 785 }
 786 EXPORT_SYMBOL(ib_get_cached_lmc);
 787
 788 static void ib_cache_update(struct ib_device *device,
 789                             u8                port)
 790 {
 791         struct ib_port_attr       *tprops = NULL;
 792         struct ib_pkey_cache      *pkey_cache = NULL, *old_pkey_cache;
 793         struct ib_gid_cache {
 794                 int             table_len;
 795                 union ib_gid    table[0];
 796         }                         *gid_cache = NULL;
 797         int                        i;
 798         int                        ret;
 799         struct ib_gid_table       *table;
 800         struct ib_gid_table      **ports_table = device->cache.gid_cache;
 801         bool                       use_roce_gid_table =
 802                                         rdma_cap_roce_gid_table(device, port);
 803
 804         if (port < rdma_start_port(device) || port > rdma_end_port(device))
 805                 return;
 806
 807         table = ports_table[port - rdma_start_port(device)];
 808
 809         tprops = kmalloc(sizeof *tprops, GFP_KERNEL);
 810         if (!tprops)
 811                 return;
 812
 813         ret = ib_query_port(device, port, tprops);
 814         if (ret) {
 815                 printk(KERN_WARNING "ib_query_port failed (%d) for %s\n",
 816                        ret, device->name);
 817                 goto err;
 818         }
 819
 820         pkey_cache = kmalloc(sizeof *pkey_cache + tprops->pkey_tbl_len *
 821                              sizeof *pkey_cache->table, GFP_KERNEL);
 822         if (!pkey_cache)
 823                 goto err;
 824
 825         pkey_cache->table_len = tprops->pkey_tbl_len;
 826
 827         if (!use_roce_gid_table) {
 828                 gid_cache = kmalloc(sizeof(*gid_cache) + tprops->gid_tbl_len *
 829                             sizeof(*gid_cache->table), GFP_KERNEL);
 830                 if (!gid_cache)
 831                         goto err;
 832
 833                 gid_cache->table_len = tprops->gid_tbl_len;
 834         }
 835
 836         for (i = 0; i < pkey_cache->table_len; ++i) {
 837                 ret = ib_query_pkey(device, port, i, pkey_cache->table + i);
 838                 if (ret) {
 839                         printk(KERN_WARNING "ib_query_pkey failed (%d) for %s (index %d)\n",
 840                                ret, device->name, i);
 841                         goto err;
 842                 }
 843         }
 844
 845         if (!use_roce_gid_table) {
 846                 for (i = 0;  i < gid_cache->table_len; ++i) {
 847                         ret = ib_query_gid(device, port, i,
 848                                            gid_cache->table + i);
 849                         if (ret) {
 850                                 printk(KERN_WARNING "ib_query_gid failed (%d) for %s (index %d)\n",
 851                                        ret, device->name, i);
 852                                 goto err;
 853                         }
 854                 }
 855         }
 856
 857         write_lock_irq(&device->cache.lock);
 858
 859         old_pkey_cache = device->cache.pkey_cache[port - rdma_start_port(device)];
 860
 861         device->cache.pkey_cache[port - rdma_start_port(device)] = pkey_cache;
 862         if (!use_roce_gid_table) {
 863                 for (i = 0; i < gid_cache->table_len; i++) {
 864                         modify_gid(device, port, table, i, gid_cache->table + i,
 865                                    &zattr, false);
 866                 }
 867         }
 868
 869         device->cache.lmc_cache[port - rdma_start_port(device)] = tprops->lmc;
 870
 871         write_unlock_irq(&device->cache.lock);
 872
 873         kfree(gid_cache);
 874         kfree(old_pkey_cache);
 875         kfree(tprops);
 876         return;
 877
 878 err:
 879         kfree(pkey_cache);
 880         kfree(gid_cache);
 881         kfree(tprops);
 882 }
 883
 884 static void ib_cache_task(struct work_struct *_work)
 885 {
 886         struct ib_update_work *work =
 887                 container_of(_work, struct ib_update_work, work);
 888
 889         ib_cache_update(work->device, work->port_num);
 890         kfree(work);
 891 }
 892
 893 static void ib_cache_event(struct ib_event_handler *handler,
 894                            struct ib_event *event)
 895 {
 896         struct ib_update_work *work;
 897
 898         if (event->event == IB_EVENT_PORT_ERR    ||
 899             event->event == IB_EVENT_PORT_ACTIVE ||
 900             event->event == IB_EVENT_LID_CHANGE  ||
 901             event->event == IB_EVENT_PKEY_CHANGE ||
 902             event->event == IB_EVENT_SM_CHANGE   ||
 903             event->event == IB_EVENT_CLIENT_REREGISTER ||
 904             event->event == IB_EVENT_GID_CHANGE) {
 905                 work = kmalloc(sizeof *work, GFP_ATOMIC);
 906                 if (work) {
 907                         INIT_WORK(&work->work, ib_cache_task);
 908                         work->device   = event->device;
 909                         work->port_num = event->element.port_num;
 910                         queue_work(ib_wq, &work->work);
 911                 }
 912         }
 913 }
 914
 915 int ib_cache_setup_one(struct ib_device *device)
 916 {
 917         int p;
 918         int err;
 919
 920         rwlock_init(&device->cache.lock);
 921
 922         device->cache.pkey_cache =
 923                 kzalloc(sizeof *device->cache.pkey_cache *
 924                         (rdma_end_port(device) - rdma_start_port(device) + 1), GFP_KERNEL);
 925         device->cache.lmc_cache = kmalloc(sizeof *device->cache.lmc_cache *
 926                                           (rdma_end_port(device) -
 927                                            rdma_start_port(device) + 1),
 928                                           GFP_KERNEL);
 929         if (!device->cache.pkey_cache ||
 930             !device->cache.lmc_cache) {
 931                 printk(KERN_WARNING "Couldn't allocate cache "
 932                        "for %s\n", device->name);
 933                 return -ENOMEM;
 934         }
 935
 936         err = gid_table_setup_one(device);
 937         if (err)
 938                 /* Allocated memory will be cleaned in the release function */
 939                 return err;
 940
 941         for (p = 0; p <= rdma_end_port(device) - rdma_start_port(device); ++p)
 942                 ib_cache_update(device, p + rdma_start_port(device));
 943
 944         INIT_IB_EVENT_HANDLER(&device->cache.event_handler,
 945                               device, ib_cache_event);
 946         err = ib_register_event_handler(&device->cache.event_handler);
 947         if (err)
 948                 goto err;
 949
 950         return 0;
 951
 952 err:
 953         gid_table_cleanup_one(device);
 954         return err;
 955 }
 956
 957 void ib_cache_release_one(struct ib_device *device)
 958 {
 959         int p;
 960
 961         /*
 962          * The release function frees all the cache elements.
 963          * This function should be called as part of freeing
 964          * all the device's resources when the cache could no
 965          * longer be accessed.
 966          */
 967         if (device->cache.pkey_cache)
 968                 for (p = 0;
 969                      p <= rdma_end_port(device) - rdma_start_port(device); ++p)
 970                         kfree(device->cache.pkey_cache[p]);
 971
 972         gid_table_release_one(device);
 973         kfree(device->cache.pkey_cache);
 974         kfree(device->cache.lmc_cache);
 975 }
 976
 977 void ib_cache_cleanup_one(struct ib_device *device)
 978 {
 979         /* The cleanup function unregisters the event handler,
 980          * waits for all in-progress workqueue elements and cleans
 981          * up the GID cache. This function should be called after
 982          * the device was removed from the devices list and all
 983          * clients were removed, so the cache exists but is
 984          * non-functional and shouldn't be updated anymore.
 985          */
 986         ib_unregister_event_handler(&device->cache.event_handler);
 987         flush_workqueue(ib_wq);
 988         gid_table_cleanup_one(device);
 989 }
 990
 991 void __init ib_cache_setup(void)
 992 {
 993         roce_gid_mgmt_init();
 994 }
 995
 996 void __exit ib_cache_cleanup(void)
 997 {
 998         roce_gid_mgmt_cleanup();
 999 }