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  * $Id: cache.c 1349 2004-12-16 21:09:43Z roland $
  36  */
  37
  38 #include <linux/module.h>
  39 #include <linux/errno.h>
  40 #include <linux/slab.h>
  41 #include <linux/sched.h>        /* INIT_WORK, schedule_work(), flush_scheduled_work() */
  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_gid_cache {
  53         int             table_len;
  54         union ib_gid    table[0];
  55 };
  56
  57 struct ib_update_work {
  58         struct work_struct work;
  59         struct ib_device  *device;
  60         u8                 port_num;
  61 };
  62
  63 static inline int start_port(struct ib_device *device)
  64 {
  65         return device->node_type == IB_NODE_SWITCH ? 0 : 1;
  66 }
  67
  68 static inline int end_port(struct ib_device *device)
  69 {
  70         return device->node_type == IB_NODE_SWITCH ? 0 : device->phys_port_cnt;
  71 }
  72
  73 int ib_get_cached_gid(struct ib_device *device,
  74                       u8                port_num,
  75                       int               index,
  76                       union ib_gid     *gid)
  77 {
  78         struct ib_gid_cache *cache;
  79         unsigned long flags;
  80         int ret = 0;
  81
  82         if (port_num < start_port(device) || port_num > end_port(device))
  83                 return -EINVAL;
  84
  85         read_lock_irqsave(&device->cache.lock, flags);
  86
  87         cache = device->cache.gid_cache[port_num - start_port(device)];
  88
  89         if (index < 0 || index >= cache->table_len)
  90                 ret = -EINVAL;
  91         else
  92                 *gid = cache->table[index];
  93
  94         read_unlock_irqrestore(&device->cache.lock, flags);
  95
  96         return ret;
  97 }
  98 EXPORT_SYMBOL(ib_get_cached_gid);
  99
 100 int ib_find_cached_gid(struct ib_device *device,
 101                        union ib_gid     *gid,
 102                        u8               *port_num,
 103                        u16              *index)
 104 {
 105         struct ib_gid_cache *cache;
 106         unsigned long flags;
 107         int p, i;
 108         int ret = -ENOENT;
 109
 110         *port_num = -1;
 111         if (index)
 112                 *index = -1;
 113
 114         read_lock_irqsave(&device->cache.lock, flags);
 115
 116         for (p = 0; p <= end_port(device) - start_port(device); ++p) {
 117                 cache = device->cache.gid_cache[p];
 118                 for (i = 0; i < cache->table_len; ++i) {
 119                         if (!memcmp(gid, &cache->table[i], sizeof *gid)) {
 120                                 *port_num = p + start_port(device);
 121                                 if (index)
 122                                         *index = i;
 123                                 ret = 0;
 124                                 goto found;
 125                         }
 126                 }
 127         }
 128 found:
 129         read_unlock_irqrestore(&device->cache.lock, flags);
 130
 131         return ret;
 132 }
 133 EXPORT_SYMBOL(ib_find_cached_gid);
 134
 135 int ib_get_cached_pkey(struct ib_device *device,
 136                        u8                port_num,
 137                        int               index,
 138                        u16              *pkey)
 139 {
 140         struct ib_pkey_cache *cache;
 141         unsigned long flags;
 142         int ret = 0;
 143
 144         if (port_num < start_port(device) || port_num > end_port(device))
 145                 return -EINVAL;
 146
 147         read_lock_irqsave(&device->cache.lock, flags);
 148
 149         cache = device->cache.pkey_cache[port_num - start_port(device)];
 150
 151         if (index < 0 || index >= cache->table_len)
 152                 ret = -EINVAL;
 153         else
 154                 *pkey = cache->table[index];
 155
 156         read_unlock_irqrestore(&device->cache.lock, flags);
 157
 158         return ret;
 159 }
 160 EXPORT_SYMBOL(ib_get_cached_pkey);
 161
 162 int ib_find_cached_pkey(struct ib_device *device,
 163                         u8                port_num,
 164                         u16               pkey,
 165                         u16              *index)
 166 {
 167         struct ib_pkey_cache *cache;
 168         unsigned long flags;
 169         int i;
 170         int ret = -ENOENT;
 171
 172         if (port_num < start_port(device) || port_num > end_port(device))
 173                 return -EINVAL;
 174
 175         read_lock_irqsave(&device->cache.lock, flags);
 176
 177         cache = device->cache.pkey_cache[port_num - start_port(device)];
 178
 179         *index = -1;
 180
 181         for (i = 0; i < cache->table_len; ++i)
 182                 if ((cache->table[i] & 0x7fff) == (pkey & 0x7fff)) {
 183                         *index = i;
 184                         ret = 0;
 185                         break;
 186                 }
 187
 188         read_unlock_irqrestore(&device->cache.lock, flags);
 189
 190         return ret;
 191 }
 192 EXPORT_SYMBOL(ib_find_cached_pkey);
 193
 194 int ib_get_cached_lmc(struct ib_device *device,
 195                       u8                port_num,
 196                       u8                *lmc)
 197 {
 198         unsigned long flags;
 199         int ret = 0;
 200
 201         if (port_num < start_port(device) || port_num > end_port(device))
 202                 return -EINVAL;
 203
 204         read_lock_irqsave(&device->cache.lock, flags);
 205         *lmc = device->cache.lmc_cache[port_num - start_port(device)];
 206         read_unlock_irqrestore(&device->cache.lock, flags);
 207
 208         return ret;
 209 }
 210 EXPORT_SYMBOL(ib_get_cached_lmc);
 211
 212 static void ib_cache_update(struct ib_device *device,
 213                             u8                port)
 214 {
 215         struct ib_port_attr       *tprops = NULL;
 216         struct ib_pkey_cache      *pkey_cache = NULL, *old_pkey_cache;
 217         struct ib_gid_cache       *gid_cache = NULL, *old_gid_cache;
 218         int                        i;
 219         int                        ret;
 220
 221         tprops = kmalloc(sizeof *tprops, GFP_KERNEL);
 222         if (!tprops)
 223                 return;
 224
 225         ret = ib_query_port(device, port, tprops);
 226         if (ret) {
 227                 printk(KERN_WARNING "ib_query_port failed (%d) for %s\n",
 228                        ret, device->name);
 229                 goto err;
 230         }
 231
 232         pkey_cache = kmalloc(sizeof *pkey_cache + tprops->pkey_tbl_len *
 233                              sizeof *pkey_cache->table, GFP_KERNEL);
 234         if (!pkey_cache)
 235                 goto err;
 236
 237         pkey_cache->table_len = tprops->pkey_tbl_len;
 238
 239         gid_cache = kmalloc(sizeof *gid_cache + tprops->gid_tbl_len *
 240                             sizeof *gid_cache->table, GFP_KERNEL);
 241         if (!gid_cache)
 242                 goto err;
 243
 244         gid_cache->table_len = tprops->gid_tbl_len;
 245
 246         for (i = 0; i < pkey_cache->table_len; ++i) {
 247                 ret = ib_query_pkey(device, port, i, pkey_cache->table + i);
 248                 if (ret) {
 249                         printk(KERN_WARNING "ib_query_pkey failed (%d) for %s (index %d)\n",
 250                                ret, device->name, i);
 251                         goto err;
 252                 }
 253         }
 254
 255         for (i = 0; i < gid_cache->table_len; ++i) {
 256                 ret = ib_query_gid(device, port, i, gid_cache->table + i);
 257                 if (ret) {
 258                         printk(KERN_WARNING "ib_query_gid failed (%d) for %s (index %d)\n",
 259                                ret, device->name, i);
 260                         goto err;
 261                 }
 262         }
 263
 264         write_lock_irq(&device->cache.lock);
 265
 266         old_pkey_cache = device->cache.pkey_cache[port - start_port(device)];
 267         old_gid_cache  = device->cache.gid_cache [port - start_port(device)];
 268
 269         device->cache.pkey_cache[port - start_port(device)] = pkey_cache;
 270         device->cache.gid_cache [port - start_port(device)] = gid_cache;
 271
 272         device->cache.lmc_cache[port - start_port(device)] = tprops->lmc;
 273
 274         write_unlock_irq(&device->cache.lock);
 275
 276         kfree(old_pkey_cache);
 277         kfree(old_gid_cache);
 278         kfree(tprops);
 279         return;
 280
 281 err:
 282         kfree(pkey_cache);
 283         kfree(gid_cache);
 284         kfree(tprops);
 285 }
 286
 287 static void ib_cache_task(void *work_ptr)
 288 {
 289         struct ib_update_work *work = work_ptr;
 290
 291         ib_cache_update(work->device, work->port_num);
 292         kfree(work);
 293 }
 294
 295 static void ib_cache_event(struct ib_event_handler *handler,
 296                            struct ib_event *event)
 297 {
 298         struct ib_update_work *work;
 299
 300         if (event->event == IB_EVENT_PORT_ERR    ||
 301             event->event == IB_EVENT_PORT_ACTIVE ||
 302             event->event == IB_EVENT_LID_CHANGE  ||
 303             event->event == IB_EVENT_PKEY_CHANGE ||
 304             event->event == IB_EVENT_SM_CHANGE) {
 305                 work = kmalloc(sizeof *work, GFP_ATOMIC);
 306                 if (work) {
 307                         INIT_WORK(&work->work, ib_cache_task, work);
 308                         work->device   = event->device;
 309                         work->port_num = event->element.port_num;
 310                         schedule_work(&work->work);
 311                 }
 312         }
 313 }
 314
 315 static void ib_cache_setup_one(struct ib_device *device)
 316 {
 317         int p;
 318
 319         rwlock_init(&device->cache.lock);
 320
 321         device->cache.pkey_cache =
 322                 kmalloc(sizeof *device->cache.pkey_cache *
 323                         (end_port(device) - start_port(device) + 1), GFP_KERNEL);
 324         device->cache.gid_cache =
 325                 kmalloc(sizeof *device->cache.gid_cache *
 326                         (end_port(device) - start_port(device) + 1), GFP_KERNEL);
 327
 328         device->cache.lmc_cache = kmalloc(sizeof *device->cache.lmc_cache *
 329                                           (end_port(device) -
 330                                            start_port(device) + 1),
 331                                           GFP_KERNEL);
 332
 333         if (!device->cache.pkey_cache || !device->cache.gid_cache ||
 334             !device->cache.lmc_cache) {
 335                 printk(KERN_WARNING "Couldn't allocate cache "
 336                        "for %s\n", device->name);
 337                 goto err;
 338         }
 339
 340         for (p = 0; p <= end_port(device) - start_port(device); ++p) {
 341                 device->cache.pkey_cache[p] = NULL;
 342                 device->cache.gid_cache [p] = NULL;
 343                 ib_cache_update(device, p + start_port(device));
 344         }
 345
 346         INIT_IB_EVENT_HANDLER(&device->cache.event_handler,
 347                               device, ib_cache_event);
 348         if (ib_register_event_handler(&device->cache.event_handler))
 349                 goto err_cache;
 350
 351         return;
 352
 353 err_cache:
 354         for (p = 0; p <= end_port(device) - start_port(device); ++p) {
 355                 kfree(device->cache.pkey_cache[p]);
 356                 kfree(device->cache.gid_cache[p]);
 357         }
 358
 359 err:
 360         kfree(device->cache.pkey_cache);
 361         kfree(device->cache.gid_cache);
 362         kfree(device->cache.lmc_cache);
 363 }
 364
 365 static void ib_cache_cleanup_one(struct ib_device *device)
 366 {
 367         int p;
 368
 369         ib_unregister_event_handler(&device->cache.event_handler);
 370         flush_scheduled_work();
 371
 372         for (p = 0; p <= end_port(device) - start_port(device); ++p) {
 373                 kfree(device->cache.pkey_cache[p]);
 374                 kfree(device->cache.gid_cache[p]);
 375         }
 376
 377         kfree(device->cache.pkey_cache);
 378         kfree(device->cache.gid_cache);
 379         kfree(device->cache.lmc_cache);
 380 }
 381
 382 static struct ib_client cache_client = {
 383         .name   = "cache",
 384         .add    = ib_cache_setup_one,
 385         .remove = ib_cache_cleanup_one
 386 };
 387
 388 int __init ib_cache_setup(void)
 389 {
 390         return ib_register_client(&cache_client);
 391 }
 392
 393 void __exit ib_cache_cleanup(void)
 394 {
 395         ib_unregister_client(&cache_client);
 396 }