1/* 2 * Copyright (c) 2004 Topspin Communications. All rights reserved. 3 * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved. 4 * 5 * This software is available to you under a choice of one of two 6 * licenses. You may choose to be licensed under the terms of the GNU 7 * General Public License (GPL) Version 2, available from the file 8 * COPYING in the main directory of this source tree, or the 9 * OpenIB.org BSD license below: 10 * 11 * Redistribution and use in source and binary forms, with or 12 * without modification, are permitted provided that the following 13 * conditions are met: 14 * 15 * - Redistributions of source code must retain the above 16 * copyright notice, this list of conditions and the following 17 * disclaimer. 18 * 19 * - Redistributions in binary form must reproduce the above 20 * copyright notice, this list of conditions and the following 21 * disclaimer in the documentation and/or other materials 22 * provided with the distribution. 23 * 24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 31 * SOFTWARE. 32 */ 33 34#include <linux/module.h> 35#include <linux/string.h> 36#include <linux/errno.h> 37#include <linux/kernel.h> 38#include <linux/slab.h> 39#include <linux/init.h> 40#include <linux/mutex.h> 41#include <linux/workqueue.h> 42 43#include "core_priv.h" 44 45MODULE_AUTHOR("Roland Dreier"); 46MODULE_DESCRIPTION("core kernel InfiniBand API"); 47MODULE_LICENSE("Dual BSD/GPL"); 48 49#ifdef __ia64__ 50/* workaround for a bug in hp chipset that would cause kernel 51 panic when dma resources are exhaused */ 52int dma_map_sg_hp_wa = 0; 53#endif 54 55struct ib_client_data { 56 struct list_head list; 57 struct ib_client *client; 58 void * data; 59}; 60 61static LIST_HEAD(device_list); 62static LIST_HEAD(client_list); 63 64/* 65 * device_mutex protects access to both device_list and client_list. 66 * There's no real point to using multiple locks or something fancier 67 * like an rwsem: we always access both lists, and we're always 68 * modifying one list or the other list. In any case this is not a 69 * hot path so there's no point in trying to optimize. 70 */ 71static DEFINE_MUTEX(device_mutex); 72 73static int ib_device_check_mandatory(struct ib_device *device) 74{ 75#define IB_MANDATORY_FUNC(x) { offsetof(struct ib_device, x), #x } 76 static const struct { 77 size_t offset; 78 char *name; 79 } mandatory_table[] = { 80 IB_MANDATORY_FUNC(query_device), 81 IB_MANDATORY_FUNC(query_port), 82 IB_MANDATORY_FUNC(query_pkey), 83 IB_MANDATORY_FUNC(query_gid), 84 IB_MANDATORY_FUNC(alloc_pd), 85 IB_MANDATORY_FUNC(dealloc_pd), 86 IB_MANDATORY_FUNC(create_ah), 87 IB_MANDATORY_FUNC(destroy_ah), 88 IB_MANDATORY_FUNC(create_qp), 89 IB_MANDATORY_FUNC(modify_qp), 90 IB_MANDATORY_FUNC(destroy_qp), 91 IB_MANDATORY_FUNC(post_send), 92 IB_MANDATORY_FUNC(post_recv), 93 IB_MANDATORY_FUNC(create_cq), 94 IB_MANDATORY_FUNC(destroy_cq), 95 IB_MANDATORY_FUNC(poll_cq), 96 IB_MANDATORY_FUNC(req_notify_cq), 97 IB_MANDATORY_FUNC(get_dma_mr), 98 IB_MANDATORY_FUNC(dereg_mr) 99 }; 100 int i; 101 102 for (i = 0; i < ARRAY_SIZE(mandatory_table); ++i) { 103 if (!*(void **) ((u_char *) device + mandatory_table[i].offset)) { 104 printk(KERN_WARNING "Device %s is missing mandatory function %s\n", 105 device->name, mandatory_table[i].name); 106 return -EINVAL; 107 } 108 } 109 110 return 0; 111} 112 113static struct ib_device *__ib_device_get_by_name(const char *name) 114{ 115 struct ib_device *device; 116 117 list_for_each_entry(device, &device_list, core_list) 118 if (!strncmp(name, device->name, IB_DEVICE_NAME_MAX)) 119 return device; 120 121 return NULL; 122} 123 124 125static int alloc_name(char *name) 126{ 127 unsigned long *inuse; 128 char buf[IB_DEVICE_NAME_MAX]; 129 struct ib_device *device; 130 int i; 131 132 inuse = (unsigned long *) get_zeroed_page(GFP_KERNEL); 133 if (!inuse) 134 return -ENOMEM; 135 136 list_for_each_entry(device, &device_list, core_list) { 137 if (!sscanf(device->name, name, &i)) 138 continue; 139 if (i < 0 || i >= PAGE_SIZE * 8) 140 continue; 141 snprintf(buf, sizeof buf, name, i); 142 if (!strncmp(buf, device->name, IB_DEVICE_NAME_MAX)) 143 set_bit(i, inuse); 144 } 145 146 i = find_first_zero_bit(inuse, PAGE_SIZE * 8); 147 free_page((unsigned long) inuse); 148 snprintf(buf, sizeof buf, name, i); 149 150 if (__ib_device_get_by_name(buf)) 151 return -ENFILE; 152 153 strlcpy(name, buf, IB_DEVICE_NAME_MAX); 154 return 0; 155} 156 157static int start_port(struct ib_device *device) 158{ 159 return (device->node_type == RDMA_NODE_IB_SWITCH) ? 0 : 1; 160} 161 162 163static int end_port(struct ib_device *device) 164{ 165 return (device->node_type == RDMA_NODE_IB_SWITCH) ? 166 0 : device->phys_port_cnt; 167} 168 169/** 170 * ib_alloc_device - allocate an IB device struct 171 * @size:size of structure to allocate 172 * 173 * Low-level drivers should use ib_alloc_device() to allocate &struct 174 * ib_device. @size is the size of the structure to be allocated, 175 * including any private data used by the low-level driver. 176 * ib_dealloc_device() must be used to free structures allocated with 177 * ib_alloc_device(). 178 */ 179struct ib_device *ib_alloc_device(size_t size) 180{ 181 BUG_ON(size < sizeof (struct ib_device)); 182 183 return kzalloc(size, GFP_KERNEL); 184} 185EXPORT_SYMBOL(ib_alloc_device); 186 187/** 188 * ib_dealloc_device - free an IB device struct 189 * @device:structure to free 190 * 191 * Free a structure allocated with ib_alloc_device(). 192 */ 193void ib_dealloc_device(struct ib_device *device) 194{ 195 if (device->reg_state == IB_DEV_UNINITIALIZED) { 196 kfree(device); 197 return; 198 } 199 200 BUG_ON(device->reg_state != IB_DEV_UNREGISTERED); 201 202 kobject_put(&device->dev.kobj); 203} 204EXPORT_SYMBOL(ib_dealloc_device); 205 206static int add_client_context(struct ib_device *device, struct ib_client *client) 207{ 208 struct ib_client_data *context; 209 unsigned long flags; 210 211 context = kmalloc(sizeof *context, GFP_KERNEL); 212 if (!context) { 213 printk(KERN_WARNING "Couldn't allocate client context for %s/%s\n", 214 device->name, client->name); 215 return -ENOMEM; 216 } 217 218 context->client = client; 219 context->data = NULL; 220 221 spin_lock_irqsave(&device->client_data_lock, flags); 222 list_add(&context->list, &device->client_data_list); 223 spin_unlock_irqrestore(&device->client_data_lock, flags); 224 225 return 0; 226} 227 228static int read_port_table_lengths(struct ib_device *device) 229{ 230 struct ib_port_attr *tprops = NULL; 231 int num_ports, ret = -ENOMEM; 232 u8 port_index; 233 234 tprops = kmalloc(sizeof *tprops, GFP_KERNEL); 235 if (!tprops) 236 goto out; 237 238 num_ports = end_port(device) - start_port(device) + 1; 239 240 device->pkey_tbl_len = kmalloc(sizeof *device->pkey_tbl_len * num_ports, 241 GFP_KERNEL); 242 device->gid_tbl_len = kmalloc(sizeof *device->gid_tbl_len * num_ports, 243 GFP_KERNEL); 244 if (!device->pkey_tbl_len || !device->gid_tbl_len) 245 goto err; 246 247 for (port_index = 0; port_index < num_ports; ++port_index) { 248 ret = ib_query_port(device, port_index + start_port(device), 249 tprops); 250 if (ret) 251 goto err; 252 device->pkey_tbl_len[port_index] = tprops->pkey_tbl_len; 253 device->gid_tbl_len[port_index] = tprops->gid_tbl_len; 254 } 255 256 ret = 0; 257 goto out; 258 259err: 260 kfree(device->gid_tbl_len); 261 kfree(device->pkey_tbl_len); 262out: 263 kfree(tprops); 264 return ret; 265} 266 267/** 268 * ib_register_device - Register an IB device with IB core 269 * @device:Device to register 270 * 271 * Low-level drivers use ib_register_device() to register their 272 * devices with the IB core. All registered clients will receive a 273 * callback for each device that is added. @device must be allocated 274 * with ib_alloc_device(). 275 */ 276int ib_register_device(struct ib_device *device, 277 int (*port_callback)(struct ib_device *, 278 u8, struct kobject *)) 279{ 280 int ret; 281 282 mutex_lock(&device_mutex); 283 284 if (strchr(device->name, '%')) { 285 ret = alloc_name(device->name); 286 if (ret) 287 goto out; 288 } 289 290 if (ib_device_check_mandatory(device)) { 291 ret = -EINVAL; 292 goto out; 293 } 294 295 INIT_LIST_HEAD(&device->event_handler_list); 296 INIT_LIST_HEAD(&device->client_data_list); 297 spin_lock_init(&device->event_handler_lock); 298 spin_lock_init(&device->client_data_lock); 299 device->ib_uverbs_xrcd_table = RB_ROOT; 300 mutex_init(&device->xrcd_table_mutex); 301 302 ret = read_port_table_lengths(device); 303 if (ret) { 304 printk(KERN_WARNING "Couldn't create table lengths cache for device %s\n", 305 device->name); 306 goto out; 307 } 308 309 ret = ib_device_register_sysfs(device, port_callback); 310 if (ret) { 311 printk(KERN_WARNING "Couldn't register device %s with driver model\n", 312 device->name); 313 kfree(device->gid_tbl_len); 314 kfree(device->pkey_tbl_len); 315 goto out; 316 } 317 318 list_add_tail(&device->core_list, &device_list); 319 320 device->reg_state = IB_DEV_REGISTERED; 321 322 { 323 struct ib_client *client; 324 325 list_for_each_entry(client, &client_list, list) 326 if (client->add && !add_client_context(device, client)) 327 client->add(device); 328 } 329 330 out: 331 mutex_unlock(&device_mutex); 332 return ret; 333} 334EXPORT_SYMBOL(ib_register_device); 335 336/** 337 * ib_unregister_device - Unregister an IB device 338 * @device:Device to unregister 339 * 340 * Unregister an IB device. All clients will receive a remove callback. 341 */ 342void ib_unregister_device(struct ib_device *device) 343{ 344 struct ib_client *client; 345 struct ib_client_data *context, *tmp; 346 unsigned long flags; 347 348 mutex_lock(&device_mutex); 349 350 list_for_each_entry_reverse(client, &client_list, list) 351 if (client->remove) 352 client->remove(device); 353 354 list_del(&device->core_list); 355 356 kfree(device->gid_tbl_len); 357 kfree(device->pkey_tbl_len); 358 359 mutex_unlock(&device_mutex); 360 361 ib_device_unregister_sysfs(device); 362 363 spin_lock_irqsave(&device->client_data_lock, flags); 364 list_for_each_entry_safe(context, tmp, &device->client_data_list, list) 365 kfree(context); 366 spin_unlock_irqrestore(&device->client_data_lock, flags); 367 368 device->reg_state = IB_DEV_UNREGISTERED; 369} 370EXPORT_SYMBOL(ib_unregister_device); 371 372/** 373 * ib_register_client - Register an IB client 374 * @client:Client to register 375 * 376 * Upper level users of the IB drivers can use ib_register_client() to 377 * register callbacks for IB device addition and removal. When an IB 378 * device is added, each registered client's add method will be called 379 * (in the order the clients were registered), and when a device is 380 * removed, each client's remove method will be called (in the reverse 381 * order that clients were registered). In addition, when 382 * ib_register_client() is called, the client will receive an add 383 * callback for all devices already registered. 384 */ 385int ib_register_client(struct ib_client *client) 386{ 387 struct ib_device *device; 388 389 mutex_lock(&device_mutex); 390 391 list_add_tail(&client->list, &client_list); 392 list_for_each_entry(device, &device_list, core_list) 393 if (client->add && !add_client_context(device, client)) 394 client->add(device); 395 396 mutex_unlock(&device_mutex); 397 398 return 0; 399} 400EXPORT_SYMBOL(ib_register_client); 401 402/** 403 * ib_unregister_client - Unregister an IB client 404 * @client:Client to unregister 405 * 406 * Upper level users use ib_unregister_client() to remove their client 407 * registration. When ib_unregister_client() is called, the client 408 * will receive a remove callback for each IB device still registered. 409 */ 410void ib_unregister_client(struct ib_client *client) 411{ 412 struct ib_client_data *context, *tmp; 413 struct ib_device *device; 414 unsigned long flags; 415 416 mutex_lock(&device_mutex); 417 418 list_for_each_entry(device, &device_list, core_list) { 419 if (client->remove) 420 client->remove(device); 421 422 spin_lock_irqsave(&device->client_data_lock, flags); 423 list_for_each_entry_safe(context, tmp, &device->client_data_list, list) 424 if (context->client == client) { 425 list_del(&context->list); 426 kfree(context); 427 } 428 spin_unlock_irqrestore(&device->client_data_lock, flags); 429 } 430 list_del(&client->list); 431 432 mutex_unlock(&device_mutex); 433} 434EXPORT_SYMBOL(ib_unregister_client); 435 436/** 437 * ib_get_client_data - Get IB client context 438 * @device:Device to get context for 439 * @client:Client to get context for 440 * 441 * ib_get_client_data() returns client context set with 442 * ib_set_client_data(). 443 */ 444void *ib_get_client_data(struct ib_device *device, struct ib_client *client) 445{ 446 struct ib_client_data *context; 447 void *ret = NULL; 448 unsigned long flags; 449 450 spin_lock_irqsave(&device->client_data_lock, flags); 451 list_for_each_entry(context, &device->client_data_list, list) 452 if (context->client == client) { 453 ret = context->data; 454 break; 455 } 456 spin_unlock_irqrestore(&device->client_data_lock, flags); 457 458 return ret; 459} 460EXPORT_SYMBOL(ib_get_client_data); 461 462/** 463 * ib_set_client_data - Set IB client context 464 * @device:Device to set context for 465 * @client:Client to set context for 466 * @data:Context to set 467 * 468 * ib_set_client_data() sets client context that can be retrieved with 469 * ib_get_client_data(). 470 */ 471void ib_set_client_data(struct ib_device *device, struct ib_client *client, 472 void *data) 473{ 474 struct ib_client_data *context; 475 unsigned long flags; 476 477 spin_lock_irqsave(&device->client_data_lock, flags); 478 list_for_each_entry(context, &device->client_data_list, list) 479 if (context->client == client) { 480 context->data = data; 481 goto out; 482 } 483 484 printk(KERN_WARNING "No client context found for %s/%s\n", 485 device->name, client->name); 486 487out: 488 spin_unlock_irqrestore(&device->client_data_lock, flags); 489} 490EXPORT_SYMBOL(ib_set_client_data); 491 492/** 493 * ib_register_event_handler - Register an IB event handler 494 * @event_handler:Handler to register 495 * 496 * ib_register_event_handler() registers an event handler that will be 497 * called back when asynchronous IB events occur (as defined in 498 * chapter 11 of the InfiniBand Architecture Specification). This 499 * callback may occur in interrupt context. 500 */ 501int ib_register_event_handler (struct ib_event_handler *event_handler) 502{ 503 unsigned long flags; 504 505 spin_lock_irqsave(&event_handler->device->event_handler_lock, flags); 506 list_add_tail(&event_handler->list, 507 &event_handler->device->event_handler_list); 508 spin_unlock_irqrestore(&event_handler->device->event_handler_lock, flags); 509 510 return 0; 511} 512EXPORT_SYMBOL(ib_register_event_handler); 513 514/** 515 * ib_unregister_event_handler - Unregister an event handler 516 * @event_handler:Handler to unregister 517 * 518 * Unregister an event handler registered with 519 * ib_register_event_handler(). 520 */ 521int ib_unregister_event_handler(struct ib_event_handler *event_handler) 522{ 523 unsigned long flags; 524 525 spin_lock_irqsave(&event_handler->device->event_handler_lock, flags); 526 list_del(&event_handler->list); 527 spin_unlock_irqrestore(&event_handler->device->event_handler_lock, flags); 528 529 return 0; 530} 531EXPORT_SYMBOL(ib_unregister_event_handler); 532 533/** 534 * ib_dispatch_event - Dispatch an asynchronous event 535 * @event:Event to dispatch 536 * 537 * Low-level drivers must call ib_dispatch_event() to dispatch the 538 * event to all registered event handlers when an asynchronous event 539 * occurs. 540 */ 541void ib_dispatch_event(struct ib_event *event) 542{ 543 unsigned long flags; 544 struct ib_event_handler *handler; 545 546 spin_lock_irqsave(&event->device->event_handler_lock, flags); 547 548 list_for_each_entry(handler, &event->device->event_handler_list, list) 549 handler->handler(handler, event); 550 551 spin_unlock_irqrestore(&event->device->event_handler_lock, flags); 552} 553EXPORT_SYMBOL(ib_dispatch_event); 554 555/** 556 * ib_query_device - Query IB device attributes 557 * @device:Device to query 558 * @device_attr:Device attributes 559 * 560 * ib_query_device() returns the attributes of a device through the 561 * @device_attr pointer. 562 */ 563int ib_query_device(struct ib_device *device, 564 struct ib_device_attr *device_attr) 565{ 566 return device->query_device(device, device_attr); 567} 568EXPORT_SYMBOL(ib_query_device); 569 570/** 571 * ib_query_port - Query IB port attributes 572 * @device:Device to query 573 * @port_num:Port number to query 574 * @port_attr:Port attributes 575 * 576 * ib_query_port() returns the attributes of a port through the 577 * @port_attr pointer. 578 */ 579int ib_query_port(struct ib_device *device, 580 u8 port_num, 581 struct ib_port_attr *port_attr) 582{ 583 if (port_num < start_port(device) || port_num > end_port(device)) 584 return -EINVAL; 585 586 return device->query_port(device, port_num, port_attr); 587} 588EXPORT_SYMBOL(ib_query_port); 589 590/** 591 * ib_query_gid - Get GID table entry 592 * @device:Device to query 593 * @port_num:Port number to query 594 * @index:GID table index to query 595 * @gid:Returned GID 596 * 597 * ib_query_gid() fetches the specified GID table entry. 598 */ 599int ib_query_gid(struct ib_device *device, 600 u8 port_num, int index, union ib_gid *gid) 601{ 602 return device->query_gid(device, port_num, index, gid); 603} 604EXPORT_SYMBOL(ib_query_gid); 605 606/** 607 * ib_query_pkey - Get P_Key table entry 608 * @device:Device to query 609 * @port_num:Port number to query 610 * @index:P_Key table index to query 611 * @pkey:Returned P_Key 612 * 613 * ib_query_pkey() fetches the specified P_Key table entry. 614 */ 615int ib_query_pkey(struct ib_device *device, 616 u8 port_num, u16 index, u16 *pkey) 617{ 618 return device->query_pkey(device, port_num, index, pkey); 619} 620EXPORT_SYMBOL(ib_query_pkey); 621 622/** 623 * ib_modify_device - Change IB device attributes 624 * @device:Device to modify 625 * @device_modify_mask:Mask of attributes to change 626 * @device_modify:New attribute values 627 * 628 * ib_modify_device() changes a device's attributes as specified by 629 * the @device_modify_mask and @device_modify structure. 630 */ 631int ib_modify_device(struct ib_device *device, 632 int device_modify_mask, 633 struct ib_device_modify *device_modify) 634{ 635 return device->modify_device(device, device_modify_mask, 636 device_modify); 637} 638EXPORT_SYMBOL(ib_modify_device); 639 640/** 641 * ib_modify_port - Modifies the attributes for the specified port. 642 * @device: The device to modify. 643 * @port_num: The number of the port to modify. 644 * @port_modify_mask: Mask used to specify which attributes of the port 645 * to change. 646 * @port_modify: New attribute values for the port. 647 * 648 * ib_modify_port() changes a port's attributes as specified by the 649 * @port_modify_mask and @port_modify structure. 650 */ 651int ib_modify_port(struct ib_device *device, 652 u8 port_num, int port_modify_mask, 653 struct ib_port_modify *port_modify) 654{ 655 if (port_num < start_port(device) || port_num > end_port(device)) 656 return -EINVAL; 657 658 return device->modify_port(device, port_num, port_modify_mask, 659 port_modify); 660} 661EXPORT_SYMBOL(ib_modify_port); 662 663/** 664 * ib_find_gid - Returns the port number and GID table index where 665 * a specified GID value occurs. 666 * @device: The device to query. 667 * @gid: The GID value to search for. 668 * @port_num: The port number of the device where the GID value was found. 669 * @index: The index into the GID table where the GID was found. This 670 * parameter may be NULL. 671 */ 672int ib_find_gid(struct ib_device *device, union ib_gid *gid, 673 u8 *port_num, u16 *index) 674{ 675 union ib_gid tmp_gid; 676 int ret, port, i; 677 678 for (port = start_port(device); port <= end_port(device); ++port) { 679 for (i = 0; i < device->gid_tbl_len[port - start_port(device)]; ++i) { 680 ret = ib_query_gid(device, port, i, &tmp_gid); 681 if (ret) 682 return ret; 683 if (!memcmp(&tmp_gid, gid, sizeof *gid)) { 684 *port_num = port; 685 if (index) 686 *index = i; 687 return 0; 688 } 689 } 690 } 691 692 return -ENOENT; 693} 694EXPORT_SYMBOL(ib_find_gid); 695 696/** 697 * ib_find_pkey - Returns the PKey table index where a specified 698 * PKey value occurs. 699 * @device: The device to query. 700 * @port_num: The port number of the device to search for the PKey. 701 * @pkey: The PKey value to search for. 702 * @index: The index into the PKey table where the PKey was found. 703 */ 704int ib_find_pkey(struct ib_device *device, 705 u8 port_num, u16 pkey, u16 *index) 706{ 707 int ret, i; 708 u16 tmp_pkey; 709 710 for (i = 0; i < device->pkey_tbl_len[port_num - start_port(device)]; ++i) { 711 ret = ib_query_pkey(device, port_num, i, &tmp_pkey); 712 if (ret) 713 return ret; 714 715 if ((pkey & 0x7fff) == (tmp_pkey & 0x7fff)) { 716 *index = i; 717 return 0; 718 } 719 } 720 721 return -ENOENT; 722} 723EXPORT_SYMBOL(ib_find_pkey); 724 725static int __init ib_core_init(void) 726{ 727 int ret; 728 729#ifdef __ia64__ 730 if (ia64_platform_is("hpzx1")) 731 dma_map_sg_hp_wa = 1; 732#endif 733 734 ret = ib_sysfs_setup(); 735 if (ret) 736 printk(KERN_WARNING "Couldn't create InfiniBand device class\n"); 737 738 ret = ib_cache_setup(); 739 if (ret) { 740 printk(KERN_WARNING "Couldn't set up InfiniBand P_Key/GID cache\n"); 741 ib_sysfs_cleanup(); 742 } 743 744 return ret; 745} 746 747static void __exit ib_core_cleanup(void) 748{ 749 ib_cache_cleanup(); 750 ib_sysfs_cleanup(); 751 /* Make sure that any pending umem accounting work is done. */ 752 flush_scheduled_work(); 753} 754 755module_init(ib_core_init); 756module_exit(ib_core_cleanup); 757 758#undef MODULE_VERSION 759#include <sys/module.h> 760static int 761ibcore_evhand(module_t mod, int event, void *arg) 762{ 763 return (0); 764} 765 766static moduledata_t ibcore_mod = { 767 .name = "ibcore", 768 .evhand = ibcore_evhand, 769}; 770 771MODULE_VERSION(ibcore, 1); 772DECLARE_MODULE(ibcore, ibcore_mod, SI_SUB_SMP, SI_ORDER_ANY); 773