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: user_mad.c 1389 2004-12-27 22:56:47Z roland $ 33 */ 34 35 #include <linux/module.h> 36 #include <linux/init.h> 37 #include <linux/device.h> 38 #include <linux/err.h> 39 #include <linux/fs.h> 40 #include <linux/cdev.h> 41 #include <linux/pci.h> 42 #include <linux/dma-mapping.h> 43 #include <linux/poll.h> 44 #include <linux/rwsem.h> 45 #include <linux/kref.h> 46 47 #include <asm/uaccess.h> 48 #include <asm/semaphore.h> 49 50 #include <ib_mad.h> 51 #include <ib_user_mad.h> 52 53 MODULE_AUTHOR("Roland Dreier"); 54 MODULE_DESCRIPTION("InfiniBand userspace MAD packet access"); 55 MODULE_LICENSE("Dual BSD/GPL"); 56 57 enum { 58 IB_UMAD_MAX_PORTS = 64, 59 IB_UMAD_MAX_AGENTS = 32, 60 61 IB_UMAD_MAJOR = 231, 62 IB_UMAD_MINOR_BASE = 0 63 }; 64 65 struct ib_umad_port { 66 int devnum; 67 struct cdev dev; 68 struct class_device class_dev; 69 70 int sm_devnum; 71 struct cdev sm_dev; 72 struct class_device sm_class_dev; 73 struct semaphore sm_sem; 74 75 struct ib_device *ib_dev; 76 struct ib_umad_device *umad_dev; 77 u8 port_num; 78 }; 79 80 struct ib_umad_device { 81 int start_port, end_port; 82 struct kref ref; 83 struct ib_umad_port port[0]; 84 }; 85 86 struct ib_umad_file { 87 struct ib_umad_port *port; 88 spinlock_t recv_lock; 89 struct list_head recv_list; 90 wait_queue_head_t recv_wait; 91 struct rw_semaphore agent_mutex; 92 struct ib_mad_agent *agent[IB_UMAD_MAX_AGENTS]; 93 struct ib_mr *mr[IB_UMAD_MAX_AGENTS]; 94 }; 95 96 struct ib_umad_packet { 97 struct ib_user_mad mad; 98 struct ib_ah *ah; 99 struct list_head list; 100 DECLARE_PCI_UNMAP_ADDR(mapping) 101 }; 102 103 static const dev_t base_dev = MKDEV(IB_UMAD_MAJOR, IB_UMAD_MINOR_BASE); 104 static spinlock_t map_lock; 105 static DECLARE_BITMAP(dev_map, IB_UMAD_MAX_PORTS * 2); 106 107 static void ib_umad_add_one(struct ib_device *device); 108 static void ib_umad_remove_one(struct ib_device *device); 109 110 static int queue_packet(struct ib_umad_file *file, 111 struct ib_mad_agent *agent, 112 struct ib_umad_packet *packet) 113 { 114 int ret = 1; 115 116 down_read(&file->agent_mutex); 117 for (packet->mad.id = 0; 118 packet->mad.id < IB_UMAD_MAX_AGENTS; 119 packet->mad.id++) 120 if (agent == file->agent[packet->mad.id]) { 121 spin_lock_irq(&file->recv_lock); 122 list_add_tail(&packet->list, &file->recv_list); 123 spin_unlock_irq(&file->recv_lock); 124 wake_up_interruptible(&file->recv_wait); 125 ret = 0; 126 break; 127 } 128 129 up_read(&file->agent_mutex); 130 131 return ret; 132 } 133 134 static void send_handler(struct ib_mad_agent *agent, 135 struct ib_mad_send_wc *send_wc) 136 { 137 struct ib_umad_file *file = agent->context; 138 struct ib_umad_packet *packet = 139 (void *) (unsigned long) send_wc->wr_id; 140 141 dma_unmap_single(agent->device->dma_device, 142 pci_unmap_addr(packet, mapping), 143 sizeof packet->mad.data, 144 DMA_TO_DEVICE); 145 ib_destroy_ah(packet->ah); 146 147 if (send_wc->status == IB_WC_RESP_TIMEOUT_ERR) { 148 packet->mad.status = ETIMEDOUT; 149 150 if (!queue_packet(file, agent, packet)) 151 return; 152 } 153 154 kfree(packet); 155 } 156 157 static void recv_handler(struct ib_mad_agent *agent, 158 struct ib_mad_recv_wc *mad_recv_wc) 159 { 160 struct ib_umad_file *file = agent->context; 161 struct ib_umad_packet *packet; 162 163 if (mad_recv_wc->wc->status != IB_WC_SUCCESS) 164 goto out; 165 166 packet = kmalloc(sizeof *packet, GFP_KERNEL); 167 if (!packet) 168 goto out; 169 170 memset(packet, 0, sizeof *packet); 171 172 memcpy(packet->mad.data, mad_recv_wc->recv_buf.mad, sizeof packet->mad.data); 173 packet->mad.status = 0; 174 packet->mad.qpn = cpu_to_be32(mad_recv_wc->wc->src_qp); 175 packet->mad.lid = cpu_to_be16(mad_recv_wc->wc->slid); 176 packet->mad.sl = mad_recv_wc->wc->sl; 177 packet->mad.path_bits = mad_recv_wc->wc->dlid_path_bits; 178 packet->mad.grh_present = !!(mad_recv_wc->wc->wc_flags & IB_WC_GRH); 179 if (packet->mad.grh_present) { 180 /* XXX parse GRH */ 181 packet->mad.gid_index = 0; 182 packet->mad.hop_limit = 0; 183 packet->mad.traffic_class = 0; 184 memset(packet->mad.gid, 0, 16); 185 packet->mad.flow_label = 0; 186 } 187 188 if (queue_packet(file, agent, packet)) 189 kfree(packet); 190 191 out: 192 ib_free_recv_mad(mad_recv_wc); 193 } 194 195 static ssize_t ib_umad_read(struct file *filp, char __user *buf, 196 size_t count, loff_t *pos) 197 { 198 struct ib_umad_file *file = filp->private_data; 199 struct ib_umad_packet *packet; 200 ssize_t ret; 201 202 if (count < sizeof (struct ib_user_mad)) 203 return -EINVAL; 204 205 spin_lock_irq(&file->recv_lock); 206 207 while (list_empty(&file->recv_list)) { 208 spin_unlock_irq(&file->recv_lock); 209 210 if (filp->f_flags & O_NONBLOCK) 211 return -EAGAIN; 212 213 if (wait_event_interruptible(file->recv_wait, 214 !list_empty(&file->recv_list))) 215 return -ERESTARTSYS; 216 217 spin_lock_irq(&file->recv_lock); 218 } 219 220 packet = list_entry(file->recv_list.next, struct ib_umad_packet, list); 221 list_del(&packet->list); 222 223 spin_unlock_irq(&file->recv_lock); 224 225 if (copy_to_user(buf, &packet->mad, sizeof packet->mad)) 226 ret = -EFAULT; 227 else 228 ret = sizeof packet->mad; 229 230 kfree(packet); 231 return ret; 232 } 233 234 static ssize_t ib_umad_write(struct file *filp, const char __user *buf, 235 size_t count, loff_t *pos) 236 { 237 struct ib_umad_file *file = filp->private_data; 238 struct ib_umad_packet *packet; 239 struct ib_mad_agent *agent; 240 struct ib_ah_attr ah_attr; 241 struct ib_sge gather_list; 242 struct ib_send_wr *bad_wr, wr = { 243 .opcode = IB_WR_SEND, 244 .sg_list = &gather_list, 245 .num_sge = 1, 246 .send_flags = IB_SEND_SIGNALED, 247 }; 248 u8 method; 249 u64 *tid; 250 int ret; 251 252 if (count < sizeof (struct ib_user_mad)) 253 return -EINVAL; 254 255 packet = kmalloc(sizeof *packet, GFP_KERNEL); 256 if (!packet) 257 return -ENOMEM; 258 259 if (copy_from_user(&packet->mad, buf, sizeof packet->mad)) { 260 kfree(packet); 261 return -EFAULT; 262 } 263 264 if (packet->mad.id < 0 || packet->mad.id >= IB_UMAD_MAX_AGENTS) { 265 ret = -EINVAL; 266 goto err; 267 } 268 269 down_read(&file->agent_mutex); 270 271 agent = file->agent[packet->mad.id]; 272 if (!agent) { 273 ret = -EINVAL; 274 goto err_up; 275 } 276 277 /* 278 * If userspace is generating a request that will generate a 279 * response, we need to make sure the high-order part of the 280 * transaction ID matches the agent being used to send the 281 * MAD. 282 */ 283 method = ((struct ib_mad_hdr *) packet->mad.data)->method; 284 285 if (!(method & IB_MGMT_METHOD_RESP) && 286 method != IB_MGMT_METHOD_TRAP_REPRESS && 287 method != IB_MGMT_METHOD_SEND) { 288 tid = &((struct ib_mad_hdr *) packet->mad.data)->tid; 289 *tid = cpu_to_be64(((u64) agent->hi_tid) << 32 | 290 (be64_to_cpup(tid) & 0xffffffff)); 291 } 292 293 memset(&ah_attr, 0, sizeof ah_attr); 294 ah_attr.dlid = be16_to_cpu(packet->mad.lid); 295 ah_attr.sl = packet->mad.sl; 296 ah_attr.src_path_bits = packet->mad.path_bits; 297 ah_attr.port_num = file->port->port_num; 298 if (packet->mad.grh_present) { 299 ah_attr.ah_flags = IB_AH_GRH; 300 memcpy(ah_attr.grh.dgid.raw, packet->mad.gid, 16); 301 ah_attr.grh.flow_label = packet->mad.flow_label; 302 ah_attr.grh.hop_limit = packet->mad.hop_limit; 303 ah_attr.grh.traffic_class = packet->mad.traffic_class; 304 } 305 306 packet->ah = ib_create_ah(agent->qp->pd, &ah_attr); 307 if (IS_ERR(packet->ah)) { 308 ret = PTR_ERR(packet->ah); 309 goto err_up; 310 } 311 312 gather_list.addr = dma_map_single(agent->device->dma_device, 313 packet->mad.data, 314 sizeof packet->mad.data, 315 DMA_TO_DEVICE); 316 gather_list.length = sizeof packet->mad.data; 317 gather_list.lkey = file->mr[packet->mad.id]->lkey; 318 pci_unmap_addr_set(packet, mapping, gather_list.addr); 319 320 wr.wr.ud.mad_hdr = (struct ib_mad_hdr *) packet->mad.data; 321 wr.wr.ud.ah = packet->ah; 322 wr.wr.ud.remote_qpn = be32_to_cpu(packet->mad.qpn); 323 wr.wr.ud.remote_qkey = be32_to_cpu(packet->mad.qkey); 324 wr.wr.ud.timeout_ms = packet->mad.timeout_ms; 325 326 wr.wr_id = (unsigned long) packet; 327 328 ret = ib_post_send_mad(agent, &wr, &bad_wr); 329 if (ret) { 330 dma_unmap_single(agent->device->dma_device, 331 pci_unmap_addr(packet, mapping), 332 sizeof packet->mad.data, 333 DMA_TO_DEVICE); 334 goto err_up; 335 } 336 337 up_read(&file->agent_mutex); 338 339 return sizeof packet->mad; 340 341 err_up: 342 up_read(&file->agent_mutex); 343 344 err: 345 kfree(packet); 346 return ret; 347 } 348 349 static unsigned int ib_umad_poll(struct file *filp, struct poll_table_struct *wait) 350 { 351 struct ib_umad_file *file = filp->private_data; 352 353 /* we will always be able to post a MAD send */ 354 unsigned int mask = POLLOUT | POLLWRNORM; 355 356 poll_wait(filp, &file->recv_wait, wait); 357 358 if (!list_empty(&file->recv_list)) 359 mask |= POLLIN | POLLRDNORM; 360 361 return mask; 362 } 363 364 static int ib_umad_reg_agent(struct ib_umad_file *file, unsigned long arg) 365 { 366 struct ib_user_mad_reg_req ureq; 367 struct ib_mad_reg_req req; 368 struct ib_mad_agent *agent; 369 int agent_id; 370 int ret; 371 372 down_write(&file->agent_mutex); 373 374 if (copy_from_user(&ureq, (void __user *) arg, sizeof ureq)) { 375 ret = -EFAULT; 376 goto out; 377 } 378 379 if (ureq.qpn != 0 && ureq.qpn != 1) { 380 ret = -EINVAL; 381 goto out; 382 } 383 384 for (agent_id = 0; agent_id < IB_UMAD_MAX_AGENTS; ++agent_id) 385 if (!file->agent[agent_id]) 386 goto found; 387 388 ret = -ENOMEM; 389 goto out; 390 391 found: 392 if (ureq.mgmt_class) { 393 req.mgmt_class = ureq.mgmt_class; 394 req.mgmt_class_version = ureq.mgmt_class_version; 395 memcpy(req.method_mask, ureq.method_mask, sizeof req.method_mask); 396 memcpy(req.oui, ureq.oui, sizeof req.oui); 397 } 398 399 agent = ib_register_mad_agent(file->port->ib_dev, file->port->port_num, 400 ureq.qpn ? IB_QPT_GSI : IB_QPT_SMI, 401 ureq.mgmt_class ? &req : NULL, 402 0, send_handler, recv_handler, file); 403 if (IS_ERR(agent)) { 404 ret = PTR_ERR(agent); 405 goto out; 406 } 407 408 file->agent[agent_id] = agent; 409 410 file->mr[agent_id] = ib_get_dma_mr(agent->qp->pd, IB_ACCESS_LOCAL_WRITE); 411 if (IS_ERR(file->mr[agent_id])) { 412 ret = -ENOMEM; 413 goto err; 414 } 415 416 if (put_user(agent_id, 417 (u32 __user *) (arg + offsetof(struct ib_user_mad_reg_req, id)))) { 418 ret = -EFAULT; 419 goto err_mr; 420 } 421 422 ret = 0; 423 goto out; 424 425 err_mr: 426 ib_dereg_mr(file->mr[agent_id]); 427 428 err: 429 file->agent[agent_id] = NULL; 430 ib_unregister_mad_agent(agent); 431 432 out: 433 up_write(&file->agent_mutex); 434 return ret; 435 } 436 437 static int ib_umad_unreg_agent(struct ib_umad_file *file, unsigned long arg) 438 { 439 u32 id; 440 int ret = 0; 441 442 down_write(&file->agent_mutex); 443 444 if (get_user(id, (u32 __user *) arg)) { 445 ret = -EFAULT; 446 goto out; 447 } 448 449 if (id < 0 || id >= IB_UMAD_MAX_AGENTS || !file->agent[id]) { 450 ret = -EINVAL; 451 goto out; 452 } 453 454 ib_dereg_mr(file->mr[id]); 455 ib_unregister_mad_agent(file->agent[id]); 456 file->agent[id] = NULL; 457 458 out: 459 up_write(&file->agent_mutex); 460 return ret; 461 } 462 463 static long ib_umad_ioctl(struct file *filp, 464 unsigned int cmd, unsigned long arg) 465 { 466 switch (cmd) { 467 case IB_USER_MAD_REGISTER_AGENT: 468 return ib_umad_reg_agent(filp->private_data, arg); 469 case IB_USER_MAD_UNREGISTER_AGENT: 470 return ib_umad_unreg_agent(filp->private_data, arg); 471 default: 472 return -ENOIOCTLCMD; 473 } 474 } 475 476 static int ib_umad_open(struct inode *inode, struct file *filp) 477 { 478 struct ib_umad_port *port = 479 container_of(inode->i_cdev, struct ib_umad_port, dev); 480 struct ib_umad_file *file; 481 482 file = kmalloc(sizeof *file, GFP_KERNEL); 483 if (!file) 484 return -ENOMEM; 485 486 memset(file, 0, sizeof *file); 487 488 spin_lock_init(&file->recv_lock); 489 init_rwsem(&file->agent_mutex); 490 INIT_LIST_HEAD(&file->recv_list); 491 init_waitqueue_head(&file->recv_wait); 492 493 file->port = port; 494 filp->private_data = file; 495 496 return 0; 497 } 498 499 static int ib_umad_close(struct inode *inode, struct file *filp) 500 { 501 struct ib_umad_file *file = filp->private_data; 502 struct ib_umad_packet *packet, *tmp; 503 int i; 504 505 for (i = 0; i < IB_UMAD_MAX_AGENTS; ++i) 506 if (file->agent[i]) { 507 ib_dereg_mr(file->mr[i]); 508 ib_unregister_mad_agent(file->agent[i]); 509 } 510 511 list_for_each_entry_safe(packet, tmp, &file->recv_list, list) 512 kfree(packet); 513 514 kfree(file); 515 516 return 0; 517 } 518 519 static struct file_operations umad_fops = { 520 .owner = THIS_MODULE, 521 .read = ib_umad_read, 522 .write = ib_umad_write, 523 .poll = ib_umad_poll, 524 .unlocked_ioctl = ib_umad_ioctl, 525 .compat_ioctl = ib_umad_ioctl, 526 .open = ib_umad_open, 527 .release = ib_umad_close 528 }; 529 530 static int ib_umad_sm_open(struct inode *inode, struct file *filp) 531 { 532 struct ib_umad_port *port = 533 container_of(inode->i_cdev, struct ib_umad_port, sm_dev); 534 struct ib_port_modify props = { 535 .set_port_cap_mask = IB_PORT_SM 536 }; 537 int ret; 538 539 if (filp->f_flags & O_NONBLOCK) { 540 if (down_trylock(&port->sm_sem)) 541 return -EAGAIN; 542 } else { 543 if (down_interruptible(&port->sm_sem)) 544 return -ERESTARTSYS; 545 } 546 547 ret = ib_modify_port(port->ib_dev, port->port_num, 0, &props); 548 if (ret) { 549 up(&port->sm_sem); 550 return ret; 551 } 552 553 filp->private_data = port; 554 555 return 0; 556 } 557 558 static int ib_umad_sm_close(struct inode *inode, struct file *filp) 559 { 560 struct ib_umad_port *port = filp->private_data; 561 struct ib_port_modify props = { 562 .clr_port_cap_mask = IB_PORT_SM 563 }; 564 int ret; 565 566 ret = ib_modify_port(port->ib_dev, port->port_num, 0, &props); 567 up(&port->sm_sem); 568 569 return ret; 570 } 571 572 static struct file_operations umad_sm_fops = { 573 .owner = THIS_MODULE, 574 .open = ib_umad_sm_open, 575 .release = ib_umad_sm_close 576 }; 577 578 static struct ib_client umad_client = { 579 .name = "umad", 580 .add = ib_umad_add_one, 581 .remove = ib_umad_remove_one 582 }; 583 584 static ssize_t show_dev(struct class_device *class_dev, char *buf) 585 { 586 struct ib_umad_port *port = class_get_devdata(class_dev); 587 588 if (class_dev == &port->class_dev) 589 return print_dev_t(buf, port->dev.dev); 590 else 591 return print_dev_t(buf, port->sm_dev.dev); 592 } 593 static CLASS_DEVICE_ATTR(dev, S_IRUGO, show_dev, NULL); 594 595 static ssize_t show_ibdev(struct class_device *class_dev, char *buf) 596 { 597 struct ib_umad_port *port = class_get_devdata(class_dev); 598 599 return sprintf(buf, "%s\n", port->ib_dev->name); 600 } 601 static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); 602 603 static ssize_t show_port(struct class_device *class_dev, char *buf) 604 { 605 struct ib_umad_port *port = class_get_devdata(class_dev); 606 607 return sprintf(buf, "%d\n", port->port_num); 608 } 609 static CLASS_DEVICE_ATTR(port, S_IRUGO, show_port, NULL); 610 611 static void ib_umad_release_dev(struct kref *ref) 612 { 613 struct ib_umad_device *dev = 614 container_of(ref, struct ib_umad_device, ref); 615 616 kfree(dev); 617 } 618 619 static void ib_umad_release_port(struct class_device *class_dev) 620 { 621 struct ib_umad_port *port = class_get_devdata(class_dev); 622 623 if (class_dev == &port->class_dev) { 624 cdev_del(&port->dev); 625 clear_bit(port->devnum, dev_map); 626 } else { 627 cdev_del(&port->sm_dev); 628 clear_bit(port->sm_devnum, dev_map); 629 } 630 631 kref_put(&port->umad_dev->ref, ib_umad_release_dev); 632 } 633 634 static struct class umad_class = { 635 .name = "infiniband_mad", 636 .release = ib_umad_release_port 637 }; 638 639 static ssize_t show_abi_version(struct class *class, char *buf) 640 { 641 return sprintf(buf, "%d\n", IB_USER_MAD_ABI_VERSION); 642 } 643 static CLASS_ATTR(abi_version, S_IRUGO, show_abi_version, NULL); 644 645 static int ib_umad_init_port(struct ib_device *device, int port_num, 646 struct ib_umad_port *port) 647 { 648 spin_lock(&map_lock); 649 port->devnum = find_first_zero_bit(dev_map, IB_UMAD_MAX_PORTS); 650 if (port->devnum >= IB_UMAD_MAX_PORTS) { 651 spin_unlock(&map_lock); 652 return -1; 653 } 654 port->sm_devnum = find_next_zero_bit(dev_map, IB_UMAD_MAX_PORTS * 2, IB_UMAD_MAX_PORTS); 655 if (port->sm_devnum >= IB_UMAD_MAX_PORTS * 2) { 656 spin_unlock(&map_lock); 657 return -1; 658 } 659 set_bit(port->devnum, dev_map); 660 set_bit(port->sm_devnum, dev_map); 661 spin_unlock(&map_lock); 662 663 port->ib_dev = device; 664 port->port_num = port_num; 665 init_MUTEX(&port->sm_sem); 666 667 cdev_init(&port->dev, &umad_fops); 668 port->dev.owner = THIS_MODULE; 669 kobject_set_name(&port->dev.kobj, "umad%d", port->devnum); 670 if (cdev_add(&port->dev, base_dev + port->devnum, 1)) 671 return -1; 672 673 port->class_dev.class = &umad_class; 674 port->class_dev.dev = device->dma_device; 675 676 snprintf(port->class_dev.class_id, BUS_ID_SIZE, "umad%d", port->devnum); 677 678 if (class_device_register(&port->class_dev)) 679 goto err_cdev; 680 681 class_set_devdata(&port->class_dev, port); 682 kref_get(&port->umad_dev->ref); 683 684 if (class_device_create_file(&port->class_dev, &class_device_attr_dev)) 685 goto err_class; 686 if (class_device_create_file(&port->class_dev, &class_device_attr_ibdev)) 687 goto err_class; 688 if (class_device_create_file(&port->class_dev, &class_device_attr_port)) 689 goto err_class; 690 691 cdev_init(&port->sm_dev, &umad_sm_fops); 692 port->sm_dev.owner = THIS_MODULE; 693 kobject_set_name(&port->dev.kobj, "issm%d", port->sm_devnum - IB_UMAD_MAX_PORTS); 694 if (cdev_add(&port->sm_dev, base_dev + port->sm_devnum, 1)) 695 return -1; 696 697 port->sm_class_dev.class = &umad_class; 698 port->sm_class_dev.dev = device->dma_device; 699 700 snprintf(port->sm_class_dev.class_id, BUS_ID_SIZE, "issm%d", port->sm_devnum - IB_UMAD_MAX_PORTS); 701 702 if (class_device_register(&port->sm_class_dev)) 703 goto err_sm_cdev; 704 705 class_set_devdata(&port->sm_class_dev, port); 706 kref_get(&port->umad_dev->ref); 707 708 if (class_device_create_file(&port->sm_class_dev, &class_device_attr_dev)) 709 goto err_sm_class; 710 if (class_device_create_file(&port->sm_class_dev, &class_device_attr_ibdev)) 711 goto err_sm_class; 712 if (class_device_create_file(&port->sm_class_dev, &class_device_attr_port)) 713 goto err_sm_class; 714 715 return 0; 716 717 err_sm_class: 718 class_device_unregister(&port->sm_class_dev); 719 720 err_sm_cdev: 721 cdev_del(&port->sm_dev); 722 723 err_class: 724 class_device_unregister(&port->class_dev); 725 726 err_cdev: 727 cdev_del(&port->dev); 728 clear_bit(port->devnum, dev_map); 729 730 return -1; 731 } 732 733 static void ib_umad_add_one(struct ib_device *device) 734 { 735 struct ib_umad_device *umad_dev; 736 int s, e, i; 737 738 if (device->node_type == IB_NODE_SWITCH) 739 s = e = 0; 740 else { 741 s = 1; 742 e = device->phys_port_cnt; 743 } 744 745 umad_dev = kmalloc(sizeof *umad_dev + 746 (e - s + 1) * sizeof (struct ib_umad_port), 747 GFP_KERNEL); 748 if (!umad_dev) 749 return; 750 751 memset(umad_dev, 0, sizeof *umad_dev + 752 (e - s + 1) * sizeof (struct ib_umad_port)); 753 754 kref_init(&umad_dev->ref); 755 756 umad_dev->start_port = s; 757 umad_dev->end_port = e; 758 759 for (i = s; i <= e; ++i) { 760 umad_dev->port[i - s].umad_dev = umad_dev; 761 762 if (ib_umad_init_port(device, i, &umad_dev->port[i - s])) 763 goto err; 764 } 765 766 ib_set_client_data(device, &umad_client, umad_dev); 767 768 return; 769 770 err: 771 while (--i >= s) { 772 class_device_unregister(&umad_dev->port[i - s].class_dev); 773 class_device_unregister(&umad_dev->port[i - s].sm_class_dev); 774 } 775 776 kref_put(&umad_dev->ref, ib_umad_release_dev); 777 } 778 779 static void ib_umad_remove_one(struct ib_device *device) 780 { 781 struct ib_umad_device *umad_dev = ib_get_client_data(device, &umad_client); 782 int i; 783 784 if (!umad_dev) 785 return; 786 787 for (i = 0; i <= umad_dev->end_port - umad_dev->start_port; ++i) { 788 class_device_unregister(&umad_dev->port[i].class_dev); 789 class_device_unregister(&umad_dev->port[i].sm_class_dev); 790 } 791 792 kref_put(&umad_dev->ref, ib_umad_release_dev); 793 } 794 795 static int __init ib_umad_init(void) 796 { 797 int ret; 798 799 spin_lock_init(&map_lock); 800 801 ret = register_chrdev_region(base_dev, IB_UMAD_MAX_PORTS * 2, 802 "infiniband_mad"); 803 if (ret) { 804 printk(KERN_ERR "user_mad: couldn't register device number\n"); 805 goto out; 806 } 807 808 ret = class_register(&umad_class); 809 if (ret) { 810 printk(KERN_ERR "user_mad: couldn't create class infiniband_mad\n"); 811 goto out_chrdev; 812 } 813 814 ret = class_create_file(&umad_class, &class_attr_abi_version); 815 if (ret) { 816 printk(KERN_ERR "user_mad: couldn't create abi_version attribute\n"); 817 goto out_class; 818 } 819 820 ret = ib_register_client(&umad_client); 821 if (ret) { 822 printk(KERN_ERR "user_mad: couldn't register ib_umad client\n"); 823 goto out_class; 824 } 825 826 return 0; 827 828 out_class: 829 class_unregister(&umad_class); 830 831 out_chrdev: 832 unregister_chrdev_region(base_dev, IB_UMAD_MAX_PORTS * 2); 833 834 out: 835 return ret; 836 } 837 838 static void __exit ib_umad_cleanup(void) 839 { 840 ib_unregister_client(&umad_client); 841 class_unregister(&umad_class); 842 unregister_chrdev_region(base_dev, IB_UMAD_MAX_PORTS * 2); 843 } 844 845 module_init(ib_umad_init); 846 module_exit(ib_umad_cleanup); 847