git.oblomov.eu Git - linux-2.6/blob - drivers/infiniband/core/user_mad.c

   1 /*
   2  * Copyright (c) 2004 Topspin Communications.  All rights reserved.
   3  * Copyright (c) 2005 Voltaire, Inc. All rights reserved.
   4  * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
   5  *
   6  * This software is available to you under a choice of one of two
   7  * licenses.  You may choose to be licensed under the terms of the GNU
   8  * General Public License (GPL) Version 2, available from the file
   9  * COPYING in the main directory of this source tree, or the
  10  * OpenIB.org BSD license below:
  11  *
  12  *     Redistribution and use in source and binary forms, with or
  13  *     without modification, are permitted provided that the following
  14  *     conditions are met:
  15  *
  16  *      - Redistributions of source code must retain the above
  17  *        copyright notice, this list of conditions and the following
  18  *        disclaimer.
  19  *
  20  *      - Redistributions in binary form must reproduce the above
  21  *        copyright notice, this list of conditions and the following
  22  *        disclaimer in the documentation and/or other materials
  23  *        provided with the distribution.
  24  *
  25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  29  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  30  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  31  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  32  * SOFTWARE.
  33  *
  34  * $Id: user_mad.c 2814 2005-07-06 19:14:09Z halr $
  35  */
  36
  37 #include <linux/module.h>
  38 #include <linux/init.h>
  39 #include <linux/device.h>
  40 #include <linux/err.h>
  41 #include <linux/fs.h>
  42 #include <linux/cdev.h>
  43 #include <linux/pci.h>
  44 #include <linux/dma-mapping.h>
  45 #include <linux/poll.h>
  46 #include <linux/rwsem.h>
  47 #include <linux/kref.h>
  48
  49 #include <asm/uaccess.h>
  50 #include <asm/semaphore.h>
  51
  52 #include <rdma/ib_mad.h>
  53 #include <rdma/ib_user_mad.h>
  54
  55 MODULE_AUTHOR("Roland Dreier");
  56 MODULE_DESCRIPTION("InfiniBand userspace MAD packet access");
  57 MODULE_LICENSE("Dual BSD/GPL");
  58
  59 enum {
  60         IB_UMAD_MAX_PORTS  = 64,
  61         IB_UMAD_MAX_AGENTS = 32,
  62
  63         IB_UMAD_MAJOR      = 231,
  64         IB_UMAD_MINOR_BASE = 0
  65 };
  66
  67 /*
  68  * Our lifetime rules for these structs are the following: each time a
  69  * device special file is opened, we look up the corresponding struct
  70  * ib_umad_port by minor in the umad_port[] table while holding the
  71  * port_lock.  If this lookup succeeds, we take a reference on the
  72  * ib_umad_port's struct ib_umad_device while still holding the
  73  * port_lock; if the lookup fails, we fail the open().  We drop these
  74  * references in the corresponding close().
  75  *
  76  * In addition to references coming from open character devices, there
  77  * is one more reference to each ib_umad_device representing the
  78  * module's reference taken when allocating the ib_umad_device in
  79  * ib_umad_add_one().
  80  *
  81  * When destroying an ib_umad_device, we clear all of its
  82  * ib_umad_ports from umad_port[] while holding port_lock before
  83  * dropping the module's reference to the ib_umad_device.  This is
  84  * always safe because any open() calls will either succeed and obtain
  85  * a reference before we clear the umad_port[] entries, or fail after
  86  * we clear the umad_port[] entries.
  87  */
  88
  89 struct ib_umad_port {
  90         struct cdev           *dev;
  91         struct class_device   *class_dev;
  92
  93         struct cdev           *sm_dev;
  94         struct class_device   *sm_class_dev;
  95         struct semaphore       sm_sem;
  96
  97         struct rw_semaphore    mutex;
  98         struct list_head       file_list;
  99
 100         struct ib_device      *ib_dev;
 101         struct ib_umad_device *umad_dev;
 102         int                    dev_num;
 103         u8                     port_num;
 104 };
 105
 106 struct ib_umad_device {
 107         int                  start_port, end_port;
 108         struct kref          ref;
 109         struct ib_umad_port  port[0];
 110 };
 111
 112 struct ib_umad_file {
 113         struct ib_umad_port *port;
 114         struct list_head     recv_list;
 115         struct list_head     port_list;
 116         spinlock_t           recv_lock;
 117         wait_queue_head_t    recv_wait;
 118         struct ib_mad_agent *agent[IB_UMAD_MAX_AGENTS];
 119         struct ib_mr        *mr[IB_UMAD_MAX_AGENTS];
 120 };
 121
 122 struct ib_umad_packet {
 123         struct ib_mad_send_buf *msg;
 124         struct list_head   list;
 125         int                length;
 126         struct ib_user_mad mad;
 127 };
 128
 129 static struct class *umad_class;
 130
 131 static const dev_t base_dev = MKDEV(IB_UMAD_MAJOR, IB_UMAD_MINOR_BASE);
 132
 133 static DEFINE_SPINLOCK(port_lock);
 134 static struct ib_umad_port *umad_port[IB_UMAD_MAX_PORTS];
 135 static DECLARE_BITMAP(dev_map, IB_UMAD_MAX_PORTS * 2);
 136
 137 static void ib_umad_add_one(struct ib_device *device);
 138 static void ib_umad_remove_one(struct ib_device *device);
 139
 140 static void ib_umad_release_dev(struct kref *ref)
 141 {
 142         struct ib_umad_device *dev =
 143                 container_of(ref, struct ib_umad_device, ref);
 144
 145         kfree(dev);
 146 }
 147
 148 static int queue_packet(struct ib_umad_file *file,
 149                         struct ib_mad_agent *agent,
 150                         struct ib_umad_packet *packet)
 151 {
 152         int ret = 1;
 153
 154         down_read(&file->port->mutex);
 155         for (packet->mad.hdr.id = 0;
 156              packet->mad.hdr.id < IB_UMAD_MAX_AGENTS;
 157              packet->mad.hdr.id++)
 158                 if (agent == file->agent[packet->mad.hdr.id]) {
 159                         spin_lock_irq(&file->recv_lock);
 160                         list_add_tail(&packet->list, &file->recv_list);
 161                         spin_unlock_irq(&file->recv_lock);
 162                         wake_up_interruptible(&file->recv_wait);
 163                         ret = 0;
 164                         break;
 165                 }
 166
 167         up_read(&file->port->mutex);
 168
 169         return ret;
 170 }
 171
 172 static void send_handler(struct ib_mad_agent *agent,
 173                          struct ib_mad_send_wc *send_wc)
 174 {
 175         struct ib_umad_file *file = agent->context;
 176         struct ib_umad_packet *timeout;
 177         struct ib_umad_packet *packet = send_wc->send_buf->context[0];
 178
 179         ib_destroy_ah(packet->msg->ah);
 180         ib_free_send_mad(packet->msg);
 181
 182         if (send_wc->status == IB_WC_RESP_TIMEOUT_ERR) {
 183                 timeout = kzalloc(sizeof *timeout + IB_MGMT_MAD_HDR, GFP_KERNEL);
 184                 if (!timeout)
 185                         goto out;
 186
 187                 timeout->length         = IB_MGMT_MAD_HDR;
 188                 timeout->mad.hdr.id     = packet->mad.hdr.id;
 189                 timeout->mad.hdr.status = ETIMEDOUT;
 190                 memcpy(timeout->mad.data, packet->mad.data,
 191                        sizeof (struct ib_mad_hdr));
 192
 193                 if (!queue_packet(file, agent, timeout))
 194                                 return;
 195         }
 196 out:
 197         kfree(packet);
 198 }
 199
 200 static void recv_handler(struct ib_mad_agent *agent,
 201                          struct ib_mad_recv_wc *mad_recv_wc)
 202 {
 203         struct ib_umad_file *file = agent->context;
 204         struct ib_umad_packet *packet;
 205         int length;
 206
 207         if (mad_recv_wc->wc->status != IB_WC_SUCCESS)
 208                 goto out;
 209
 210         length = mad_recv_wc->mad_len;
 211         packet = kzalloc(sizeof *packet + length, GFP_KERNEL);
 212         if (!packet)
 213                 goto out;
 214
 215         packet->length = length;
 216
 217         ib_coalesce_recv_mad(mad_recv_wc, packet->mad.data);
 218
 219         packet->mad.hdr.status    = 0;
 220         packet->mad.hdr.length    = length + sizeof (struct ib_user_mad);
 221         packet->mad.hdr.qpn       = cpu_to_be32(mad_recv_wc->wc->src_qp);
 222         packet->mad.hdr.lid       = cpu_to_be16(mad_recv_wc->wc->slid);
 223         packet->mad.hdr.sl        = mad_recv_wc->wc->sl;
 224         packet->mad.hdr.path_bits = mad_recv_wc->wc->dlid_path_bits;
 225         packet->mad.hdr.grh_present = !!(mad_recv_wc->wc->wc_flags & IB_WC_GRH);
 226         if (packet->mad.hdr.grh_present) {
 227                 /* XXX parse GRH */
 228                 packet->mad.hdr.gid_index       = 0;
 229                 packet->mad.hdr.hop_limit       = 0;
 230                 packet->mad.hdr.traffic_class   = 0;
 231                 memset(packet->mad.hdr.gid, 0, 16);
 232                 packet->mad.hdr.flow_label      = 0;
 233         }
 234
 235         if (queue_packet(file, agent, packet))
 236                 kfree(packet);
 237
 238 out:
 239         ib_free_recv_mad(mad_recv_wc);
 240 }
 241
 242 static ssize_t ib_umad_read(struct file *filp, char __user *buf,
 243                             size_t count, loff_t *pos)
 244 {
 245         struct ib_umad_file *file = filp->private_data;
 246         struct ib_umad_packet *packet;
 247         ssize_t ret;
 248
 249         if (count < sizeof (struct ib_user_mad) + sizeof (struct ib_mad))
 250                 return -EINVAL;
 251
 252         spin_lock_irq(&file->recv_lock);
 253
 254         while (list_empty(&file->recv_list)) {
 255                 spin_unlock_irq(&file->recv_lock);
 256
 257                 if (filp->f_flags & O_NONBLOCK)
 258                         return -EAGAIN;
 259
 260                 if (wait_event_interruptible(file->recv_wait,
 261                                              !list_empty(&file->recv_list)))
 262                         return -ERESTARTSYS;
 263
 264                 spin_lock_irq(&file->recv_lock);
 265         }
 266
 267         packet = list_entry(file->recv_list.next, struct ib_umad_packet, list);
 268         list_del(&packet->list);
 269
 270         spin_unlock_irq(&file->recv_lock);
 271
 272         if (count < packet->length + sizeof (struct ib_user_mad)) {
 273                 /* Return length needed (and first RMPP segment) if too small */
 274                 if (copy_to_user(buf, &packet->mad,
 275                                  sizeof (struct ib_user_mad) + sizeof (struct ib_mad)))
 276                         ret = -EFAULT;
 277                 else
 278                         ret = -ENOSPC;
 279         } else if (copy_to_user(buf, &packet->mad,
 280                                 packet->length + sizeof (struct ib_user_mad)))
 281                 ret = -EFAULT;
 282         else
 283                 ret = packet->length + sizeof (struct ib_user_mad);
 284         if (ret < 0) {
 285                 /* Requeue packet */
 286                 spin_lock_irq(&file->recv_lock);
 287                 list_add(&packet->list, &file->recv_list);
 288                 spin_unlock_irq(&file->recv_lock);
 289         } else
 290                 kfree(packet);
 291         return ret;
 292 }
 293
 294 static ssize_t ib_umad_write(struct file *filp, const char __user *buf,
 295                              size_t count, loff_t *pos)
 296 {
 297         struct ib_umad_file *file = filp->private_data;
 298         struct ib_umad_packet *packet;
 299         struct ib_mad_agent *agent;
 300         struct ib_ah_attr ah_attr;
 301         struct ib_ah *ah;
 302         struct ib_rmpp_mad *rmpp_mad;
 303         u8 method;
 304         __be64 *tid;
 305         int ret, length, hdr_len, copy_offset;
 306         int rmpp_active = 0;
 307
 308         if (count < sizeof (struct ib_user_mad))
 309                 return -EINVAL;
 310
 311         length = count - sizeof (struct ib_user_mad);
 312         packet = kmalloc(sizeof *packet + IB_MGMT_RMPP_HDR, GFP_KERNEL);
 313         if (!packet)
 314                 return -ENOMEM;
 315
 316         if (copy_from_user(&packet->mad, buf,
 317                             sizeof (struct ib_user_mad) + IB_MGMT_RMPP_HDR)) {
 318                 ret = -EFAULT;
 319                 goto err;
 320         }
 321
 322         if (packet->mad.hdr.id < 0 ||
 323             packet->mad.hdr.id >= IB_UMAD_MAX_AGENTS) {
 324                 ret = -EINVAL;
 325                 goto err;
 326         }
 327
 328         down_read(&file->port->mutex);
 329
 330         agent = file->agent[packet->mad.hdr.id];
 331         if (!agent) {
 332                 ret = -EINVAL;
 333                 goto err_up;
 334         }
 335
 336         memset(&ah_attr, 0, sizeof ah_attr);
 337         ah_attr.dlid          = be16_to_cpu(packet->mad.hdr.lid);
 338         ah_attr.sl            = packet->mad.hdr.sl;
 339         ah_attr.src_path_bits = packet->mad.hdr.path_bits;
 340         ah_attr.port_num      = file->port->port_num;
 341         if (packet->mad.hdr.grh_present) {
 342                 ah_attr.ah_flags = IB_AH_GRH;
 343                 memcpy(ah_attr.grh.dgid.raw, packet->mad.hdr.gid, 16);
 344                 ah_attr.grh.flow_label     = be32_to_cpu(packet->mad.hdr.flow_label);
 345                 ah_attr.grh.hop_limit      = packet->mad.hdr.hop_limit;
 346                 ah_attr.grh.traffic_class  = packet->mad.hdr.traffic_class;
 347         }
 348
 349         ah = ib_create_ah(agent->qp->pd, &ah_attr);
 350         if (IS_ERR(ah)) {
 351                 ret = PTR_ERR(ah);
 352                 goto err_up;
 353         }
 354
 355         rmpp_mad = (struct ib_rmpp_mad *) packet->mad.data;
 356         if (ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) & IB_MGMT_RMPP_FLAG_ACTIVE) {
 357                 /* RMPP active */
 358                 if (!agent->rmpp_version) {
 359                         ret = -EINVAL;
 360                         goto err_ah;
 361                 }
 362
 363                 /* Validate that the management class can support RMPP */
 364                 if (rmpp_mad->mad_hdr.mgmt_class == IB_MGMT_CLASS_SUBN_ADM) {
 365                         hdr_len = IB_MGMT_SA_HDR;
 366                 } else if ((rmpp_mad->mad_hdr.mgmt_class >= IB_MGMT_CLASS_VENDOR_RANGE2_START) &&
 367                             (rmpp_mad->mad_hdr.mgmt_class <= IB_MGMT_CLASS_VENDOR_RANGE2_END)) {
 368                                 hdr_len = IB_MGMT_VENDOR_HDR;
 369                 } else {
 370                         ret = -EINVAL;
 371                         goto err_ah;
 372                 }
 373                 rmpp_active = 1;
 374                 copy_offset = IB_MGMT_RMPP_HDR;
 375         } else {
 376                 hdr_len = IB_MGMT_MAD_HDR;
 377                 copy_offset = IB_MGMT_MAD_HDR;
 378         }
 379
 380         packet->msg = ib_create_send_mad(agent,
 381                                          be32_to_cpu(packet->mad.hdr.qpn),
 382                                          0, rmpp_active,
 383                                          hdr_len, length - hdr_len,
 384                                          GFP_KERNEL);
 385         if (IS_ERR(packet->msg)) {
 386                 ret = PTR_ERR(packet->msg);
 387                 goto err_ah;
 388         }
 389
 390         packet->msg->ah         = ah;
 391         packet->msg->timeout_ms = packet->mad.hdr.timeout_ms;
 392         packet->msg->retries    = packet->mad.hdr.retries;
 393         packet->msg->context[0] = packet;
 394
 395         /* Copy MAD headers (RMPP header in place) */
 396         memcpy(packet->msg->mad, packet->mad.data, IB_MGMT_MAD_HDR);
 397         /* Now, copy rest of message from user into send buffer */
 398         if (copy_from_user(packet->msg->mad + copy_offset,
 399                            buf + sizeof (struct ib_user_mad) + copy_offset,
 400                            length - copy_offset)) {
 401                 ret = -EFAULT;
 402                 goto err_msg;
 403         }
 404
 405         /*
 406          * If userspace is generating a request that will generate a
 407          * response, we need to make sure the high-order part of the
 408          * transaction ID matches the agent being used to send the
 409          * MAD.
 410          */
 411         method = ((struct ib_mad_hdr *) packet->msg->mad)->method;
 412
 413         if (!(method & IB_MGMT_METHOD_RESP)       &&
 414             method != IB_MGMT_METHOD_TRAP_REPRESS &&
 415             method != IB_MGMT_METHOD_SEND) {
 416                 tid = &((struct ib_mad_hdr *) packet->msg->mad)->tid;
 417                 *tid = cpu_to_be64(((u64) agent->hi_tid) << 32 |
 418                                    (be64_to_cpup(tid) & 0xffffffff));
 419         }
 420
 421         ret = ib_post_send_mad(packet->msg, NULL);
 422         if (ret)
 423                 goto err_msg;
 424
 425         up_read(&file->port->mutex);
 426
 427         return count;
 428
 429 err_msg:
 430         ib_free_send_mad(packet->msg);
 431
 432 err_ah:
 433         ib_destroy_ah(ah);
 434
 435 err_up:
 436         up_read(&file->port->mutex);
 437
 438 err:
 439         kfree(packet);
 440         return ret;
 441 }
 442
 443 static unsigned int ib_umad_poll(struct file *filp, struct poll_table_struct *wait)
 444 {
 445         struct ib_umad_file *file = filp->private_data;
 446
 447         /* we will always be able to post a MAD send */
 448         unsigned int mask = POLLOUT | POLLWRNORM;
 449
 450         poll_wait(filp, &file->recv_wait, wait);
 451
 452         if (!list_empty(&file->recv_list))
 453                 mask |= POLLIN | POLLRDNORM;
 454
 455         return mask;
 456 }
 457
 458 static int ib_umad_reg_agent(struct ib_umad_file *file, unsigned long arg)
 459 {
 460         struct ib_user_mad_reg_req ureq;
 461         struct ib_mad_reg_req req;
 462         struct ib_mad_agent *agent;
 463         int agent_id;
 464         int ret;
 465
 466         down_write(&file->port->mutex);
 467
 468         if (!file->port->ib_dev) {
 469                 ret = -EPIPE;
 470                 goto out;
 471         }
 472
 473         if (copy_from_user(&ureq, (void __user *) arg, sizeof ureq)) {
 474                 ret = -EFAULT;
 475                 goto out;
 476         }
 477
 478         if (ureq.qpn != 0 && ureq.qpn != 1) {
 479                 ret = -EINVAL;
 480                 goto out;
 481         }
 482
 483         for (agent_id = 0; agent_id < IB_UMAD_MAX_AGENTS; ++agent_id)
 484                 if (!file->agent[agent_id])
 485                         goto found;
 486
 487         ret = -ENOMEM;
 488         goto out;
 489
 490 found:
 491         if (ureq.mgmt_class) {
 492                 req.mgmt_class         = ureq.mgmt_class;
 493                 req.mgmt_class_version = ureq.mgmt_class_version;
 494                 memcpy(req.method_mask, ureq.method_mask, sizeof req.method_mask);
 495                 memcpy(req.oui,         ureq.oui,         sizeof req.oui);
 496         }
 497
 498         agent = ib_register_mad_agent(file->port->ib_dev, file->port->port_num,
 499                                       ureq.qpn ? IB_QPT_GSI : IB_QPT_SMI,
 500                                       ureq.mgmt_class ? &req : NULL,
 501                                       ureq.rmpp_version,
 502                                       send_handler, recv_handler, file);
 503         if (IS_ERR(agent)) {
 504                 ret = PTR_ERR(agent);
 505                 goto out;
 506         }
 507
 508         file->mr[agent_id] = ib_get_dma_mr(agent->qp->pd, IB_ACCESS_LOCAL_WRITE);
 509         if (IS_ERR(file->mr[agent_id])) {
 510                 ret = -ENOMEM;
 511                 goto err;
 512         }
 513
 514         if (put_user(agent_id,
 515                      (u32 __user *) (arg + offsetof(struct ib_user_mad_reg_req, id)))) {
 516                 ret = -EFAULT;
 517                 goto err_mr;
 518         }
 519
 520         file->agent[agent_id] = agent;
 521         ret = 0;
 522
 523         goto out;
 524
 525 err_mr:
 526         ib_dereg_mr(file->mr[agent_id]);
 527
 528 err:
 529         ib_unregister_mad_agent(agent);
 530
 531 out:
 532         up_write(&file->port->mutex);
 533         return ret;
 534 }
 535
 536 static int ib_umad_unreg_agent(struct ib_umad_file *file, unsigned long arg)
 537 {
 538         struct ib_mad_agent *agent = NULL;
 539         struct ib_mr *mr = NULL;
 540         u32 id;
 541         int ret = 0;
 542
 543         if (get_user(id, (u32 __user *) arg))
 544                 return -EFAULT;
 545
 546         down_write(&file->port->mutex);
 547
 548         if (id < 0 || id >= IB_UMAD_MAX_AGENTS || !file->agent[id]) {
 549                 ret = -EINVAL;
 550                 goto out;
 551         }
 552
 553         agent = file->agent[id];
 554         mr    = file->mr[id];
 555         file->agent[id] = NULL;
 556
 557 out:
 558         up_write(&file->port->mutex);
 559
 560         if (agent) {
 561                 ib_unregister_mad_agent(agent);
 562                 ib_dereg_mr(mr);
 563         }
 564
 565         return ret;
 566 }
 567
 568 static long ib_umad_ioctl(struct file *filp, unsigned int cmd,
 569                           unsigned long arg)
 570 {
 571         switch (cmd) {
 572         case IB_USER_MAD_REGISTER_AGENT:
 573                 return ib_umad_reg_agent(filp->private_data, arg);
 574         case IB_USER_MAD_UNREGISTER_AGENT:
 575                 return ib_umad_unreg_agent(filp->private_data, arg);
 576         default:
 577                 return -ENOIOCTLCMD;
 578         }
 579 }
 580
 581 static int ib_umad_open(struct inode *inode, struct file *filp)
 582 {
 583         struct ib_umad_port *port;
 584         struct ib_umad_file *file;
 585         int ret = 0;
 586
 587         spin_lock(&port_lock);
 588         port = umad_port[iminor(inode) - IB_UMAD_MINOR_BASE];
 589         if (port)
 590                 kref_get(&port->umad_dev->ref);
 591         spin_unlock(&port_lock);
 592
 593         if (!port)
 594                 return -ENXIO;
 595
 596         down_write(&port->mutex);
 597
 598         if (!port->ib_dev) {
 599                 ret = -ENXIO;
 600                 goto out;
 601         }
 602
 603         file = kzalloc(sizeof *file, GFP_KERNEL);
 604         if (!file) {
 605                 kref_put(&port->umad_dev->ref, ib_umad_release_dev);
 606                 ret = -ENOMEM;
 607                 goto out;
 608         }
 609
 610         spin_lock_init(&file->recv_lock);
 611         INIT_LIST_HEAD(&file->recv_list);
 612         init_waitqueue_head(&file->recv_wait);
 613
 614         file->port = port;
 615         filp->private_data = file;
 616
 617         list_add_tail(&file->port_list, &port->file_list);
 618
 619 out:
 620         up_write(&port->mutex);
 621         return ret;
 622 }
 623
 624 static int ib_umad_close(struct inode *inode, struct file *filp)
 625 {
 626         struct ib_umad_file *file = filp->private_data;
 627         struct ib_umad_device *dev = file->port->umad_dev;
 628         struct ib_umad_packet *packet, *tmp;
 629         int i;
 630
 631         for (i = 0; i < IB_UMAD_MAX_AGENTS; ++i)
 632                 if (file->agent[i]) {
 633                         ib_unregister_mad_agent(file->agent[i]);
 634                         ib_dereg_mr(file->mr[i]);
 635                 }
 636
 637         list_for_each_entry_safe(packet, tmp, &file->recv_list, list)
 638                 kfree(packet);
 639
 640         down_write(&file->port->mutex);
 641         list_del(&file->port_list);
 642         up_write(&file->port->mutex);
 643
 644         kfree(file);
 645
 646         kref_put(&dev->ref, ib_umad_release_dev);
 647
 648         return 0;
 649 }
 650
 651 static struct file_operations umad_fops = {
 652         .owner          = THIS_MODULE,
 653         .read           = ib_umad_read,
 654         .write          = ib_umad_write,
 655         .poll           = ib_umad_poll,
 656         .unlocked_ioctl = ib_umad_ioctl,
 657         .compat_ioctl   = ib_umad_ioctl,
 658         .open           = ib_umad_open,
 659         .release        = ib_umad_close
 660 };
 661
 662 static int ib_umad_sm_open(struct inode *inode, struct file *filp)
 663 {
 664         struct ib_umad_port *port;
 665         struct ib_port_modify props = {
 666                 .set_port_cap_mask = IB_PORT_SM
 667         };
 668         int ret;
 669
 670         spin_lock(&port_lock);
 671         port = umad_port[iminor(inode) - IB_UMAD_MINOR_BASE - IB_UMAD_MAX_PORTS];
 672         if (port)
 673                 kref_get(&port->umad_dev->ref);
 674         spin_unlock(&port_lock);
 675
 676         if (!port)
 677                 return -ENXIO;
 678
 679         if (filp->f_flags & O_NONBLOCK) {
 680                 if (down_trylock(&port->sm_sem)) {
 681                         ret = -EAGAIN;
 682                         goto fail;
 683                 }
 684         } else {
 685                 if (down_interruptible(&port->sm_sem)) {
 686                         ret = -ERESTARTSYS;
 687                         goto fail;
 688                 }
 689         }
 690
 691         ret = ib_modify_port(port->ib_dev, port->port_num, 0, &props);
 692         if (ret) {
 693                 up(&port->sm_sem);
 694                 goto fail;
 695         }
 696
 697         filp->private_data = port;
 698
 699         return 0;
 700
 701 fail:
 702         kref_put(&port->umad_dev->ref, ib_umad_release_dev);
 703         return ret;
 704 }
 705
 706 static int ib_umad_sm_close(struct inode *inode, struct file *filp)
 707 {
 708         struct ib_umad_port *port = filp->private_data;
 709         struct ib_port_modify props = {
 710                 .clr_port_cap_mask = IB_PORT_SM
 711         };
 712         int ret = 0;
 713
 714         down_write(&port->mutex);
 715         if (port->ib_dev)
 716                 ret = ib_modify_port(port->ib_dev, port->port_num, 0, &props);
 717         up_write(&port->mutex);
 718
 719         up(&port->sm_sem);
 720
 721         kref_put(&port->umad_dev->ref, ib_umad_release_dev);
 722
 723         return ret;
 724 }
 725
 726 static struct file_operations umad_sm_fops = {
 727         .owner   = THIS_MODULE,
 728         .open    = ib_umad_sm_open,
 729         .release = ib_umad_sm_close
 730 };
 731
 732 static struct ib_client umad_client = {
 733         .name   = "umad",
 734         .add    = ib_umad_add_one,
 735         .remove = ib_umad_remove_one
 736 };
 737
 738 static ssize_t show_ibdev(struct class_device *class_dev, char *buf)
 739 {
 740         struct ib_umad_port *port = class_get_devdata(class_dev);
 741
 742         if (!port)
 743                 return -ENODEV;
 744
 745         return sprintf(buf, "%s\n", port->ib_dev->name);
 746 }
 747 static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);
 748
 749 static ssize_t show_port(struct class_device *class_dev, char *buf)
 750 {
 751         struct ib_umad_port *port = class_get_devdata(class_dev);
 752
 753         if (!port)
 754                 return -ENODEV;
 755
 756         return sprintf(buf, "%d\n", port->port_num);
 757 }
 758 static CLASS_DEVICE_ATTR(port, S_IRUGO, show_port, NULL);
 759
 760 static ssize_t show_abi_version(struct class *class, char *buf)
 761 {
 762         return sprintf(buf, "%d\n", IB_USER_MAD_ABI_VERSION);
 763 }
 764 static CLASS_ATTR(abi_version, S_IRUGO, show_abi_version, NULL);
 765
 766 static int ib_umad_init_port(struct ib_device *device, int port_num,
 767                              struct ib_umad_port *port)
 768 {
 769         spin_lock(&port_lock);
 770         port->dev_num = find_first_zero_bit(dev_map, IB_UMAD_MAX_PORTS);
 771         if (port->dev_num >= IB_UMAD_MAX_PORTS) {
 772                 spin_unlock(&port_lock);
 773                 return -1;
 774         }
 775         set_bit(port->dev_num, dev_map);
 776         spin_unlock(&port_lock);
 777
 778         port->ib_dev   = device;
 779         port->port_num = port_num;
 780         init_MUTEX(&port->sm_sem);
 781         init_rwsem(&port->mutex);
 782         INIT_LIST_HEAD(&port->file_list);
 783
 784         port->dev = cdev_alloc();
 785         if (!port->dev)
 786                 return -1;
 787         port->dev->owner = THIS_MODULE;
 788         port->dev->ops   = &umad_fops;
 789         kobject_set_name(&port->dev->kobj, "umad%d", port->dev_num);
 790         if (cdev_add(port->dev, base_dev + port->dev_num, 1))
 791                 goto err_cdev;
 792
 793         port->class_dev = class_device_create(umad_class, NULL, port->dev->dev,
 794                                               device->dma_device,
 795                                               "umad%d", port->dev_num);
 796         if (IS_ERR(port->class_dev))
 797                 goto err_cdev;
 798
 799         if (class_device_create_file(port->class_dev, &class_device_attr_ibdev))
 800                 goto err_class;
 801         if (class_device_create_file(port->class_dev, &class_device_attr_port))
 802                 goto err_class;
 803
 804         port->sm_dev = cdev_alloc();
 805         if (!port->sm_dev)
 806                 goto err_class;
 807         port->sm_dev->owner = THIS_MODULE;
 808         port->sm_dev->ops   = &umad_sm_fops;
 809         kobject_set_name(&port->sm_dev->kobj, "issm%d", port->dev_num);
 810         if (cdev_add(port->sm_dev, base_dev + port->dev_num + IB_UMAD_MAX_PORTS, 1))
 811                 goto err_sm_cdev;
 812
 813         port->sm_class_dev = class_device_create(umad_class, NULL, port->sm_dev->dev,
 814                                                  device->dma_device,
 815                                                  "issm%d", port->dev_num);
 816         if (IS_ERR(port->sm_class_dev))
 817                 goto err_sm_cdev;
 818
 819         class_set_devdata(port->class_dev,    port);
 820         class_set_devdata(port->sm_class_dev, port);
 821
 822         if (class_device_create_file(port->sm_class_dev, &class_device_attr_ibdev))
 823                 goto err_sm_class;
 824         if (class_device_create_file(port->sm_class_dev, &class_device_attr_port))
 825                 goto err_sm_class;
 826
 827         spin_lock(&port_lock);
 828         umad_port[port->dev_num] = port;
 829         spin_unlock(&port_lock);
 830
 831         return 0;
 832
 833 err_sm_class:
 834         class_device_destroy(umad_class, port->sm_dev->dev);
 835
 836 err_sm_cdev:
 837         cdev_del(port->sm_dev);
 838
 839 err_class:
 840         class_device_destroy(umad_class, port->dev->dev);
 841
 842 err_cdev:
 843         cdev_del(port->dev);
 844         clear_bit(port->dev_num, dev_map);
 845
 846         return -1;
 847 }
 848
 849 static void ib_umad_kill_port(struct ib_umad_port *port)
 850 {
 851         struct ib_umad_file *file;
 852         int id;
 853
 854         class_set_devdata(port->class_dev,    NULL);
 855         class_set_devdata(port->sm_class_dev, NULL);
 856
 857         class_device_destroy(umad_class, port->dev->dev);
 858         class_device_destroy(umad_class, port->sm_dev->dev);
 859
 860         cdev_del(port->dev);
 861         cdev_del(port->sm_dev);
 862
 863         spin_lock(&port_lock);
 864         umad_port[port->dev_num] = NULL;
 865         spin_unlock(&port_lock);
 866
 867         down_write(&port->mutex);
 868
 869         port->ib_dev = NULL;
 870
 871         list_for_each_entry(file, &port->file_list, port_list)
 872                 for (id = 0; id < IB_UMAD_MAX_AGENTS; ++id) {
 873                         if (!file->agent[id])
 874                                 continue;
 875                         ib_dereg_mr(file->mr[id]);
 876                         ib_unregister_mad_agent(file->agent[id]);
 877                         file->agent[id] = NULL;
 878                 }
 879
 880         up_write(&port->mutex);
 881
 882         clear_bit(port->dev_num, dev_map);
 883 }
 884
 885 static void ib_umad_add_one(struct ib_device *device)
 886 {
 887         struct ib_umad_device *umad_dev;
 888         int s, e, i;
 889
 890         if (device->node_type == IB_NODE_SWITCH)
 891                 s = e = 0;
 892         else {
 893                 s = 1;
 894                 e = device->phys_port_cnt;
 895         }
 896
 897         umad_dev = kzalloc(sizeof *umad_dev +
 898                            (e - s + 1) * sizeof (struct ib_umad_port),
 899                            GFP_KERNEL);
 900         if (!umad_dev)
 901                 return;
 902
 903         kref_init(&umad_dev->ref);
 904
 905         umad_dev->start_port = s;
 906         umad_dev->end_port   = e;
 907
 908         for (i = s; i <= e; ++i) {
 909                 umad_dev->port[i - s].umad_dev = umad_dev;
 910
 911                 if (ib_umad_init_port(device, i, &umad_dev->port[i - s]))
 912                         goto err;
 913         }
 914
 915         ib_set_client_data(device, &umad_client, umad_dev);
 916
 917         return;
 918
 919 err:
 920         while (--i >= s)
 921                 ib_umad_kill_port(&umad_dev->port[i - s]);
 922
 923         kref_put(&umad_dev->ref, ib_umad_release_dev);
 924 }
 925
 926 static void ib_umad_remove_one(struct ib_device *device)
 927 {
 928         struct ib_umad_device *umad_dev = ib_get_client_data(device, &umad_client);
 929         int i;
 930
 931         if (!umad_dev)
 932                 return;
 933
 934         for (i = 0; i <= umad_dev->end_port - umad_dev->start_port; ++i)
 935                 ib_umad_kill_port(&umad_dev->port[i]);
 936
 937         kref_put(&umad_dev->ref, ib_umad_release_dev);
 938 }
 939
 940 static int __init ib_umad_init(void)
 941 {
 942         int ret;
 943
 944         ret = register_chrdev_region(base_dev, IB_UMAD_MAX_PORTS * 2,
 945                                      "infiniband_mad");
 946         if (ret) {
 947                 printk(KERN_ERR "user_mad: couldn't register device number\n");
 948                 goto out;
 949         }
 950
 951         umad_class = class_create(THIS_MODULE, "infiniband_mad");
 952         if (IS_ERR(umad_class)) {
 953                 ret = PTR_ERR(umad_class);
 954                 printk(KERN_ERR "user_mad: couldn't create class infiniband_mad\n");
 955                 goto out_chrdev;
 956         }
 957
 958         ret = class_create_file(umad_class, &class_attr_abi_version);
 959         if (ret) {
 960                 printk(KERN_ERR "user_mad: couldn't create abi_version attribute\n");
 961                 goto out_class;
 962         }
 963
 964         ret = ib_register_client(&umad_client);
 965         if (ret) {
 966                 printk(KERN_ERR "user_mad: couldn't register ib_umad client\n");
 967                 goto out_class;
 968         }
 969
 970         return 0;
 971
 972 out_class:
 973         class_destroy(umad_class);
 974
 975 out_chrdev:
 976         unregister_chrdev_region(base_dev, IB_UMAD_MAX_PORTS * 2);
 977
 978 out:
 979         return ret;
 980 }
 981
 982 static void __exit ib_umad_cleanup(void)
 983 {
 984         ib_unregister_client(&umad_client);
 985         class_destroy(umad_class);
 986         unregister_chrdev_region(base_dev, IB_UMAD_MAX_PORTS * 2);
 987 }
 988
 989 module_init(ib_umad_init);
 990 module_exit(ib_umad_cleanup);