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 int i; 503 504 for (i = 0; i < IB_UMAD_MAX_AGENTS; ++i) 505 if (file->agent[i]) { 506 ib_dereg_mr(file->mr[i]); 507 ib_unregister_mad_agent(file->agent[i]); 508 } 509 510 kfree(file); 511 512 return 0; 513 } 514 515 static struct file_operations umad_fops = { 516 .owner = THIS_MODULE, 517 .read = ib_umad_read, 518 .write = ib_umad_write, 519 .poll = ib_umad_poll, 520 .unlocked_ioctl = ib_umad_ioctl, 521 .compat_ioctl = ib_umad_ioctl, 522 .open = ib_umad_open, 523 .release = ib_umad_close 524 }; 525 526 static int ib_umad_sm_open(struct inode *inode, struct file *filp) 527 { 528 struct ib_umad_port *port = 529 container_of(inode->i_cdev, struct ib_umad_port, sm_dev); 530 struct ib_port_modify props = { 531 .set_port_cap_mask = IB_PORT_SM 532 }; 533 int ret; 534 535 if (filp->f_flags & O_NONBLOCK) { 536 if (down_trylock(&port->sm_sem)) 537 return -EAGAIN; 538 } else { 539 if (down_interruptible(&port->sm_sem)) 540 return -ERESTARTSYS; 541 } 542 543 ret = ib_modify_port(port->ib_dev, port->port_num, 0, &props); 544 if (ret) { 545 up(&port->sm_sem); 546 return ret; 547 } 548 549 filp->private_data = port; 550 551 return 0; 552 } 553 554 static int ib_umad_sm_close(struct inode *inode, struct file *filp) 555 { 556 struct ib_umad_port *port = filp->private_data; 557 struct ib_port_modify props = { 558 .clr_port_cap_mask = IB_PORT_SM 559 }; 560 int ret; 561 562 ret = ib_modify_port(port->ib_dev, port->port_num, 0, &props); 563 up(&port->sm_sem); 564 565 return ret; 566 } 567 568 static struct file_operations umad_sm_fops = { 569 .owner = THIS_MODULE, 570 .open = ib_umad_sm_open, 571 .release = ib_umad_sm_close 572 }; 573 574 static struct ib_client umad_client = { 575 .name = "umad", 576 .add = ib_umad_add_one, 577 .remove = ib_umad_remove_one 578 }; 579 580 static ssize_t show_dev(struct class_device *class_dev, char *buf) 581 { 582 struct ib_umad_port *port = class_get_devdata(class_dev); 583 584 if (class_dev == &port->class_dev) 585 return print_dev_t(buf, port->dev.dev); 586 else 587 return print_dev_t(buf, port->sm_dev.dev); 588 } 589 static CLASS_DEVICE_ATTR(dev, S_IRUGO, show_dev, NULL); 590 591 static ssize_t show_ibdev(struct class_device *class_dev, char *buf) 592 { 593 struct ib_umad_port *port = class_get_devdata(class_dev); 594 595 return sprintf(buf, "%s\n", port->ib_dev->name); 596 } 597 static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); 598 599 static ssize_t show_port(struct class_device *class_dev, char *buf) 600 { 601 struct ib_umad_port *port = class_get_devdata(class_dev); 602 603 return sprintf(buf, "%d\n", port->port_num); 604 } 605 static CLASS_DEVICE_ATTR(port, S_IRUGO, show_port, NULL); 606 607 static void ib_umad_release_dev(struct kref *ref) 608 { 609 struct ib_umad_device *dev = 610 container_of(ref, struct ib_umad_device, ref); 611 612 kfree(dev); 613 } 614 615 static void ib_umad_release_port(struct class_device *class_dev) 616 { 617 struct ib_umad_port *port = class_get_devdata(class_dev); 618 619 if (class_dev == &port->class_dev) { 620 cdev_del(&port->dev); 621 clear_bit(port->devnum, dev_map); 622 } else { 623 cdev_del(&port->sm_dev); 624 clear_bit(port->sm_devnum, dev_map); 625 } 626 627 kref_put(&port->umad_dev->ref, ib_umad_release_dev); 628 } 629 630 static struct class umad_class = { 631 .name = "infiniband_mad", 632 .release = ib_umad_release_port 633 }; 634 635 static ssize_t show_abi_version(struct class *class, char *buf) 636 { 637 return sprintf(buf, "%d\n", IB_USER_MAD_ABI_VERSION); 638 } 639 static CLASS_ATTR(abi_version, S_IRUGO, show_abi_version, NULL); 640 641 static int ib_umad_init_port(struct ib_device *device, int port_num, 642 struct ib_umad_port *port) 643 { 644 spin_lock(&map_lock); 645 port->devnum = find_first_zero_bit(dev_map, IB_UMAD_MAX_PORTS); 646 if (port->devnum >= IB_UMAD_MAX_PORTS) { 647 spin_unlock(&map_lock); 648 return -1; 649 } 650 port->sm_devnum = find_next_zero_bit(dev_map, IB_UMAD_MAX_PORTS * 2, IB_UMAD_MAX_PORTS); 651 if (port->sm_devnum >= IB_UMAD_MAX_PORTS * 2) { 652 spin_unlock(&map_lock); 653 return -1; 654 } 655 set_bit(port->devnum, dev_map); 656 set_bit(port->sm_devnum, dev_map); 657 spin_unlock(&map_lock); 658 659 port->ib_dev = device; 660 port->port_num = port_num; 661 init_MUTEX(&port->sm_sem); 662 663 cdev_init(&port->dev, &umad_fops); 664 port->dev.owner = THIS_MODULE; 665 kobject_set_name(&port->dev.kobj, "umad%d", port->devnum); 666 if (cdev_add(&port->dev, base_dev + port->devnum, 1)) 667 return -1; 668 669 port->class_dev.class = &umad_class; 670 port->class_dev.dev = device->dma_device; 671 672 snprintf(port->class_dev.class_id, BUS_ID_SIZE, "umad%d", port->devnum); 673 674 if (class_device_register(&port->class_dev)) 675 goto err_cdev; 676 677 class_set_devdata(&port->class_dev, port); 678 kref_get(&port->umad_dev->ref); 679 680 if (class_device_create_file(&port->class_dev, &class_device_attr_dev)) 681 goto err_class; 682 if (class_device_create_file(&port->class_dev, &class_device_attr_ibdev)) 683 goto err_class; 684 if (class_device_create_file(&port->class_dev, &class_device_attr_port)) 685 goto err_class; 686 687 cdev_init(&port->sm_dev, &umad_sm_fops); 688 port->sm_dev.owner = THIS_MODULE; 689 kobject_set_name(&port->dev.kobj, "issm%d", port->sm_devnum - IB_UMAD_MAX_PORTS); 690 if (cdev_add(&port->sm_dev, base_dev + port->sm_devnum, 1)) 691 return -1; 692 693 port->sm_class_dev.class = &umad_class; 694 port->sm_class_dev.dev = device->dma_device; 695 696 snprintf(port->sm_class_dev.class_id, BUS_ID_SIZE, "issm%d", port->sm_devnum - IB_UMAD_MAX_PORTS); 697 698 if (class_device_register(&port->sm_class_dev)) 699 goto err_sm_cdev; 700 701 class_set_devdata(&port->sm_class_dev, port); 702 kref_get(&port->umad_dev->ref); 703 704 if (class_device_create_file(&port->sm_class_dev, &class_device_attr_dev)) 705 goto err_sm_class; 706 if (class_device_create_file(&port->sm_class_dev, &class_device_attr_ibdev)) 707 goto err_sm_class; 708 if (class_device_create_file(&port->sm_class_dev, &class_device_attr_port)) 709 goto err_sm_class; 710 711 return 0; 712 713 err_sm_class: 714 class_device_unregister(&port->sm_class_dev); 715 716 err_sm_cdev: 717 cdev_del(&port->sm_dev); 718 719 err_class: 720 class_device_unregister(&port->class_dev); 721 722 err_cdev: 723 cdev_del(&port->dev); 724 clear_bit(port->devnum, dev_map); 725 726 return -1; 727 } 728 729 static void ib_umad_add_one(struct ib_device *device) 730 { 731 struct ib_umad_device *umad_dev; 732 int s, e, i; 733 734 if (device->node_type == IB_NODE_SWITCH) 735 s = e = 0; 736 else { 737 s = 1; 738 e = device->phys_port_cnt; 739 } 740 741 umad_dev = kmalloc(sizeof *umad_dev + 742 (e - s + 1) * sizeof (struct ib_umad_port), 743 GFP_KERNEL); 744 if (!umad_dev) 745 return; 746 747 memset(umad_dev, 0, sizeof *umad_dev + 748 (e - s + 1) * sizeof (struct ib_umad_port)); 749 750 kref_init(&umad_dev->ref); 751 752 umad_dev->start_port = s; 753 umad_dev->end_port = e; 754 755 for (i = s; i <= e; ++i) { 756 umad_dev->port[i - s].umad_dev = umad_dev; 757 758 if (ib_umad_init_port(device, i, &umad_dev->port[i - s])) 759 goto err; 760 } 761 762 ib_set_client_data(device, &umad_client, umad_dev); 763 764 return; 765 766 err: 767 while (--i >= s) { 768 class_device_unregister(&umad_dev->port[i - s].class_dev); 769 class_device_unregister(&umad_dev->port[i - s].sm_class_dev); 770 } 771 772 kref_put(&umad_dev->ref, ib_umad_release_dev); 773 } 774 775 static void ib_umad_remove_one(struct ib_device *device) 776 { 777 struct ib_umad_device *umad_dev = ib_get_client_data(device, &umad_client); 778 int i; 779 780 if (!umad_dev) 781 return; 782 783 for (i = 0; i <= umad_dev->end_port - umad_dev->start_port; ++i) { 784 class_device_unregister(&umad_dev->port[i].class_dev); 785 class_device_unregister(&umad_dev->port[i].sm_class_dev); 786 } 787 788 kref_put(&umad_dev->ref, ib_umad_release_dev); 789 } 790 791 static int __init ib_umad_init(void) 792 { 793 int ret; 794 795 spin_lock_init(&map_lock); 796 797 ret = register_chrdev_region(base_dev, IB_UMAD_MAX_PORTS * 2, 798 "infiniband_mad"); 799 if (ret) { 800 printk(KERN_ERR "user_mad: couldn't register device number\n"); 801 goto out; 802 } 803 804 ret = class_register(&umad_class); 805 if (ret) { 806 printk(KERN_ERR "user_mad: couldn't create class infiniband_mad\n"); 807 goto out_chrdev; 808 } 809 810 ret = class_create_file(&umad_class, &class_attr_abi_version); 811 if (ret) { 812 printk(KERN_ERR "user_mad: couldn't create abi_version attribute\n"); 813 goto out_class; 814 } 815 816 ret = ib_register_client(&umad_client); 817 if (ret) { 818 printk(KERN_ERR "user_mad: couldn't register ib_umad client\n"); 819 goto out_class; 820 } 821 822 return 0; 823 824 out_class: 825 class_unregister(&umad_class); 826 827 out_chrdev: 828 unregister_chrdev_region(base_dev, IB_UMAD_MAX_PORTS * 2); 829 830 out: 831 return ret; 832 } 833 834 static void __exit ib_umad_cleanup(void) 835 { 836 ib_unregister_client(&umad_client); 837 class_unregister(&umad_class); 838 unregister_chrdev_region(base_dev, IB_UMAD_MAX_PORTS * 2); 839 } 840 841 module_init(ib_umad_init); 842 module_exit(ib_umad_cleanup); 843