drivers/infiniband/core/cache.c

   1 /*
   2  * Copyright (c) 2004 Topspin Communications.  All rights reserved.
   3  *
   4  * This software is available to you under a choice of one of two
   5  * licenses.  You may choose to be licensed under the terms of the GNU
   6  * General Public License (GPL) Version 2, available from the file
   7  * COPYING in the main directory of this source tree, or the
   8  * OpenIB.org BSD license below:
   9  *
  10  *     Redistribution and use in source and binary forms, with or
  11  *     without modification, are permitted provided that the following
  12  *     conditions are met:
  13  *
  14  *      - Redistributions of source code must retain the above
  15  *        copyright notice, this list of conditions and the following
  16  *        disclaimer.
  17  *
  18  *      - Redistributions in binary form must reproduce the above
  19  *        copyright notice, this list of conditions and the following
  20  *        disclaimer in the documentation and/or other materials
  21  *        provided with the distribution.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30  * SOFTWARE.
  31  *
  32  * $Id: cache.c 1349 2004-12-16 21:09:43Z roland $
  33  */
  34
  35 #include <linux/version.h>
  36 #include <linux/module.h>
  37 #include <linux/errno.h>
  38 #include <linux/slab.h>
  39
  40 #include <ib_cache.h>
  41
  42 #include "core_priv.h"
  43
  44 struct ib_pkey_cache {
  45         int             table_len;
  46         u16             table[0];
  47 };
  48
  49 struct ib_gid_cache {
  50         int             table_len;
  51         union ib_gid    table[0];
  52 };
  53
  54 struct ib_update_work {
  55         struct work_struct work;
  56         struct ib_device  *device;
  57         u8                 port_num;
  58 };
  59
  60 static inline int start_port(struct ib_device *device)
  61 {
  62         return device->node_type == IB_NODE_SWITCH ? 0 : 1;
  63 }
  64
  65 static inline int end_port(struct ib_device *device)
  66 {
  67         return device->node_type == IB_NODE_SWITCH ? 0 : device->phys_port_cnt;
  68 }
  69
  70 int ib_get_cached_gid(struct ib_device *device,
  71                       u8                port_num,
  72                       int               index,
  73                       union ib_gid     *gid)
  74 {
  75         struct ib_gid_cache *cache;
  76         unsigned long flags;
  77         int ret = 0;
  78
  79         if (port_num < start_port(device) || port_num > end_port(device))
  80                 return -EINVAL;
  81
  82         read_lock_irqsave(&device->cache.lock, flags);
  83
  84         cache = device->cache.gid_cache[port_num - start_port(device)];
  85
  86         if (index < 0 || index >= cache->table_len)
  87                 ret = -EINVAL;
  88         else
  89                 *gid = cache->table[index];
  90
  91         read_unlock_irqrestore(&device->cache.lock, flags);
  92
  93         return ret;
  94 }
  95 EXPORT_SYMBOL(ib_get_cached_gid);
  96
  97 int ib_find_cached_gid(struct ib_device *device,
  98                        union ib_gid     *gid,
  99                        u8               *port_num,
 100                        u16              *index)
 101 {
 102         struct ib_gid_cache *cache;
 103         unsigned long flags;
 104         int p, i;
 105         int ret = -ENOENT;
 106
 107         *port_num = -1;
 108         if (index)
 109                 *index = -1;
 110
 111         read_lock_irqsave(&device->cache.lock, flags);
 112
 113         for (p = 0; p <= end_port(device) - start_port(device); ++p) {
 114                 cache = device->cache.gid_cache[p];
 115                 for (i = 0; i < cache->table_len; ++i) {
 116                         if (!memcmp(gid, &cache->table[i], sizeof *gid)) {
 117                                 *port_num = p + start_port(device);
 118                                 if (index)
 119                                         *index = i;
 120                                 ret = 0;
 121                                 goto found;
 122                         }
 123                 }
 124         }
 125 found:
 126         read_unlock_irqrestore(&device->cache.lock, flags);
 127
 128         return ret;
 129 }
 130 EXPORT_SYMBOL(ib_find_cached_gid);
 131
 132 int ib_get_cached_pkey(struct ib_device *device,
 133                        u8                port_num,
 134                        int               index,
 135                        u16              *pkey)
 136 {
 137         struct ib_pkey_cache *cache;
 138         unsigned long flags;
 139         int ret = 0;
 140
 141         if (port_num < start_port(device) || port_num > end_port(device))
 142                 return -EINVAL;
 143
 144         read_lock_irqsave(&device->cache.lock, flags);
 145
 146         cache = device->cache.pkey_cache[port_num - start_port(device)];
 147
 148         if (index < 0 || index >= cache->table_len)
 149                 ret = -EINVAL;
 150         else
 151                 *pkey = cache->table[index];
 152
 153         read_unlock_irqrestore(&device->cache.lock, flags);
 154
 155         return ret;
 156 }
 157 EXPORT_SYMBOL(ib_get_cached_pkey);
 158
 159 int ib_find_cached_pkey(struct ib_device *device,
 160                         u8                port_num,
 161                         u16               pkey,
 162                         u16              *index)
 163 {
 164         struct ib_pkey_cache *cache;
 165         unsigned long flags;
 166         int i;
 167         int ret = -ENOENT;
 168
 169         if (port_num < start_port(device) || port_num > end_port(device))
 170                 return -EINVAL;
 171
 172         read_lock_irqsave(&device->cache.lock, flags);
 173
 174         cache = device->cache.pkey_cache[port_num - start_port(device)];
 175
 176         *index = -1;
 177
 178         for (i = 0; i < cache->table_len; ++i)
 179                 if ((cache->table[i] & 0x7fff) == (pkey & 0x7fff)) {
 180                         *index = i;
 181                         ret = 0;
 182                         break;
 183                 }
 184
 185         read_unlock_irqrestore(&device->cache.lock, flags);
 186
 187         return ret;
 188 }
 189 EXPORT_SYMBOL(ib_find_cached_pkey);
 190
 191 static void ib_cache_update(struct ib_device *device,
 192                             u8                port)
 193 {
 194         struct ib_port_attr       *tprops = NULL;
 195         struct ib_pkey_cache      *pkey_cache = NULL, *old_pkey_cache;
 196         struct ib_gid_cache       *gid_cache = NULL, *old_gid_cache;
 197         int                        i;
 198         int                        ret;
 199
 200         tprops = kmalloc(sizeof *tprops, GFP_KERNEL);
 201         if (!tprops)
 202                 return;
 203
 204         ret = ib_query_port(device, port, tprops);
 205         if (ret) {
 206                 printk(KERN_WARNING "ib_query_port failed (%d) for %s\n",
 207                        ret, device->name);
 208                 goto err;
 209         }
 210
 211         pkey_cache = kmalloc(sizeof *pkey_cache + tprops->pkey_tbl_len *
 212                              sizeof *pkey_cache->table, GFP_KERNEL);
 213         if (!pkey_cache)
 214                 goto err;
 215
 216         pkey_cache->table_len = tprops->pkey_tbl_len;
 217
 218         gid_cache = kmalloc(sizeof *gid_cache + tprops->gid_tbl_len *
 219                             sizeof *gid_cache->table, GFP_KERNEL);
 220         if (!gid_cache)
 221                 goto err;
 222
 223         gid_cache->table_len = tprops->gid_tbl_len;
 224
 225         for (i = 0; i < pkey_cache->table_len; ++i) {
 226                 ret = ib_query_pkey(device, port, i, pkey_cache->table + i);
 227                 if (ret) {
 228                         printk(KERN_WARNING "ib_query_pkey failed (%d) for %s (index %d)\n",
 229                                ret, device->name, i);
 230                         goto err;
 231                 }
 232         }
 233
 234         for (i = 0; i < gid_cache->table_len; ++i) {
 235                 ret = ib_query_gid(device, port, i, gid_cache->table + i);
 236                 if (ret) {
 237                         printk(KERN_WARNING "ib_query_gid failed (%d) for %s (index %d)\n",
 238                                ret, device->name, i);
 239                         goto err;
 240                 }
 241         }
 242
 243         write_lock_irq(&device->cache.lock);
 244
 245         old_pkey_cache = device->cache.pkey_cache[port - start_port(device)];
 246         old_gid_cache  = device->cache.gid_cache [port - start_port(device)];
 247
 248         device->cache.pkey_cache[port - start_port(device)] = pkey_cache;
 249         device->cache.gid_cache [port - start_port(device)] = gid_cache;
 250
 251         write_unlock_irq(&device->cache.lock);
 252
 253         kfree(old_pkey_cache);
 254         kfree(old_gid_cache);
 255         kfree(tprops);
 256         return;
 257
 258 err:
 259         kfree(pkey_cache);
 260         kfree(gid_cache);
 261         kfree(tprops);
 262 }
 263
 264 static void ib_cache_task(void *work_ptr)
 265 {
 266         struct ib_update_work *work = work_ptr;
 267
 268         ib_cache_update(work->device, work->port_num);
 269         kfree(work);
 270 }
 271
 272 static void ib_cache_event(struct ib_event_handler *handler,
 273                            struct ib_event *event)
 274 {
 275         struct ib_update_work *work;
 276
 277         if (event->event == IB_EVENT_PORT_ERR    ||
 278             event->event == IB_EVENT_PORT_ACTIVE ||
 279             event->event == IB_EVENT_LID_CHANGE  ||
 280             event->event == IB_EVENT_PKEY_CHANGE ||
 281             event->event == IB_EVENT_SM_CHANGE) {
 282                 work = kmalloc(sizeof *work, GFP_ATOMIC);
 283                 if (work) {
 284                         INIT_WORK(&work->work, ib_cache_task, work);
 285                         work->device   = event->device;
 286                         work->port_num = event->element.port_num;
 287                         schedule_work(&work->work);
 288                 }
 289         }
 290 }
 291
 292 static void ib_cache_setup_one(struct ib_device *device)
 293 {
 294         int p;
 295
 296         rwlock_init(&device->cache.lock);
 297
 298         device->cache.pkey_cache =
 299                 kmalloc(sizeof *device->cache.pkey_cache *
 300                         (end_port(device) - start_port(device) + 1), GFP_KERNEL);
 301         device->cache.gid_cache =
 302                 kmalloc(sizeof *device->cache.pkey_cache *
 303                         (end_port(device) - start_port(device) + 1), GFP_KERNEL);
 304
 305         if (!device->cache.pkey_cache || !device->cache.gid_cache) {
 306                 printk(KERN_WARNING "Couldn't allocate cache "
 307                        "for %s\n", device->name);
 308                 goto err;
 309         }
 310
 311         for (p = 0; p <= end_port(device) - start_port(device); ++p) {
 312                 device->cache.pkey_cache[p] = NULL;
 313                 device->cache.gid_cache [p] = NULL;
 314                 ib_cache_update(device, p + start_port(device));
 315         }
 316
 317         INIT_IB_EVENT_HANDLER(&device->cache.event_handler,
 318                               device, ib_cache_event);
 319         if (ib_register_event_handler(&device->cache.event_handler))
 320                 goto err_cache;
 321
 322         return;
 323
 324 err_cache:
 325         for (p = 0; p <= end_port(device) - start_port(device); ++p) {
 326                 kfree(device->cache.pkey_cache[p]);
 327                 kfree(device->cache.gid_cache[p]);
 328         }
 329
 330 err:
 331         kfree(device->cache.pkey_cache);
 332         kfree(device->cache.gid_cache);
 333 }
 334
 335 static void ib_cache_cleanup_one(struct ib_device *device)
 336 {
 337         int p;
 338
 339         ib_unregister_event_handler(&device->cache.event_handler);
 340         flush_scheduled_work();
 341
 342         for (p = 0; p <= end_port(device) - start_port(device); ++p) {
 343                 kfree(device->cache.pkey_cache[p]);
 344                 kfree(device->cache.gid_cache[p]);
 345         }
 346
 347         kfree(device->cache.pkey_cache);
 348         kfree(device->cache.gid_cache);
 349 }
 350
 351 static struct ib_client cache_client = {
 352         .name   = "cache",
 353         .add    = ib_cache_setup_one,
 354         .remove = ib_cache_cleanup_one
 355 };
 356
 357 int __init ib_cache_setup(void)
 358 {
 359         return ib_register_client(&cache_client);
 360 }
 361
 362 void __exit ib_cache_cleanup(void)
 363 {
 364         ib_unregister_client(&cache_client);
 365 }