device.c revision 255932
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 300 ret = read_port_table_lengths(device); 301 if (ret) { 302 printk(KERN_WARNING "Couldn't create table lengths cache for device %s\n", 303 device->name); 304 goto out; 305 } 306 307 ret = ib_device_register_sysfs(device, port_callback); 308 if (ret) { 309 printk(KERN_WARNING "Couldn't register device %s with driver model\n", 310 device->name); 311 kfree(device->gid_tbl_len); 312 kfree(device->pkey_tbl_len); 313 goto out; 314 } 315 316 list_add_tail(&device->core_list, &device_list); 317 318 device->reg_state = IB_DEV_REGISTERED; 319 320 { 321 struct ib_client *client; 322 323 list_for_each_entry(client, &client_list, list) 324 if (client->add && !add_client_context(device, client)) 325 client->add(device); 326 } 327 328 out: 329 mutex_unlock(&device_mutex); 330 return ret; 331} 332EXPORT_SYMBOL(ib_register_device); 333 334/** 335 * ib_unregister_device - Unregister an IB device 336 * @device:Device to unregister 337 * 338 * Unregister an IB device. All clients will receive a remove callback. 339 */ 340void ib_unregister_device(struct ib_device *device) 341{ 342 struct ib_client *client; 343 struct ib_client_data *context, *tmp; 344 unsigned long flags; 345 346 mutex_lock(&device_mutex); 347 348 list_for_each_entry_reverse(client, &client_list, list) 349 if (client->remove) 350 client->remove(device); 351 352 list_del(&device->core_list); 353 354 kfree(device->gid_tbl_len); 355 kfree(device->pkey_tbl_len); 356 357 mutex_unlock(&device_mutex); 358 359 ib_device_unregister_sysfs(device); 360 361 spin_lock_irqsave(&device->client_data_lock, flags); 362 list_for_each_entry_safe(context, tmp, &device->client_data_list, list) 363 kfree(context); 364 spin_unlock_irqrestore(&device->client_data_lock, flags); 365 366 device->reg_state = IB_DEV_UNREGISTERED; 367} 368EXPORT_SYMBOL(ib_unregister_device); 369 370/** 371 * ib_register_client - Register an IB client 372 * @client:Client to register 373 * 374 * Upper level users of the IB drivers can use ib_register_client() to 375 * register callbacks for IB device addition and removal. When an IB 376 * device is added, each registered client's add method will be called 377 * (in the order the clients were registered), and when a device is 378 * removed, each client's remove method will be called (in the reverse 379 * order that clients were registered). In addition, when 380 * ib_register_client() is called, the client will receive an add 381 * callback for all devices already registered. 382 */ 383int ib_register_client(struct ib_client *client) 384{ 385 struct ib_device *device; 386 387 mutex_lock(&device_mutex); 388 389 list_add_tail(&client->list, &client_list); 390 list_for_each_entry(device, &device_list, core_list) 391 if (client->add && !add_client_context(device, client)) 392 client->add(device); 393 394 mutex_unlock(&device_mutex); 395 396 return 0; 397} 398EXPORT_SYMBOL(ib_register_client); 399 400/** 401 * ib_unregister_client - Unregister an IB client 402 * @client:Client to unregister 403 * 404 * Upper level users use ib_unregister_client() to remove their client 405 * registration. When ib_unregister_client() is called, the client 406 * will receive a remove callback for each IB device still registered. 407 */ 408void ib_unregister_client(struct ib_client *client) 409{ 410 struct ib_client_data *context, *tmp; 411 struct ib_device *device; 412 unsigned long flags; 413 414 mutex_lock(&device_mutex); 415 416 list_for_each_entry(device, &device_list, core_list) { 417 if (client->remove) 418 client->remove(device); 419 420 spin_lock_irqsave(&device->client_data_lock, flags); 421 list_for_each_entry_safe(context, tmp, &device->client_data_list, list) 422 if (context->client == client) { 423 list_del(&context->list); 424 kfree(context); 425 } 426 spin_unlock_irqrestore(&device->client_data_lock, flags); 427 } 428 list_del(&client->list); 429 430 mutex_unlock(&device_mutex); 431} 432EXPORT_SYMBOL(ib_unregister_client); 433 434/** 435 * ib_get_client_data - Get IB client context 436 * @device:Device to get context for 437 * @client:Client to get context for 438 * 439 * ib_get_client_data() returns client context set with 440 * ib_set_client_data(). 441 */ 442void *ib_get_client_data(struct ib_device *device, struct ib_client *client) 443{ 444 struct ib_client_data *context; 445 void *ret = NULL; 446 unsigned long flags; 447 448 spin_lock_irqsave(&device->client_data_lock, flags); 449 list_for_each_entry(context, &device->client_data_list, list) 450 if (context->client == client) { 451 ret = context->data; 452 break; 453 } 454 spin_unlock_irqrestore(&device->client_data_lock, flags); 455 456 return ret; 457} 458EXPORT_SYMBOL(ib_get_client_data); 459 460/** 461 * ib_set_client_data - Set IB client context 462 * @device:Device to set context for 463 * @client:Client to set context for 464 * @data:Context to set 465 * 466 * ib_set_client_data() sets client context that can be retrieved with 467 * ib_get_client_data(). 468 */ 469void ib_set_client_data(struct ib_device *device, struct ib_client *client, 470 void *data) 471{ 472 struct ib_client_data *context; 473 unsigned long flags; 474 475 spin_lock_irqsave(&device->client_data_lock, flags); 476 list_for_each_entry(context, &device->client_data_list, list) 477 if (context->client == client) { 478 context->data = data; 479 goto out; 480 } 481 482 printk(KERN_WARNING "No client context found for %s/%s\n", 483 device->name, client->name); 484 485out: 486 spin_unlock_irqrestore(&device->client_data_lock, flags); 487} 488EXPORT_SYMBOL(ib_set_client_data); 489 490/** 491 * ib_register_event_handler - Register an IB event handler 492 * @event_handler:Handler to register 493 * 494 * ib_register_event_handler() registers an event handler that will be 495 * called back when asynchronous IB events occur (as defined in 496 * chapter 11 of the InfiniBand Architecture Specification). This 497 * callback may occur in interrupt context. 498 */ 499int ib_register_event_handler (struct ib_event_handler *event_handler) 500{ 501 unsigned long flags; 502 503 spin_lock_irqsave(&event_handler->device->event_handler_lock, flags); 504 list_add_tail(&event_handler->list, 505 &event_handler->device->event_handler_list); 506 spin_unlock_irqrestore(&event_handler->device->event_handler_lock, flags); 507 508 return 0; 509} 510EXPORT_SYMBOL(ib_register_event_handler); 511 512/** 513 * ib_unregister_event_handler - Unregister an event handler 514 * @event_handler:Handler to unregister 515 * 516 * Unregister an event handler registered with 517 * ib_register_event_handler(). 518 */ 519int ib_unregister_event_handler(struct ib_event_handler *event_handler) 520{ 521 unsigned long flags; 522 523 spin_lock_irqsave(&event_handler->device->event_handler_lock, flags); 524 list_del(&event_handler->list); 525 spin_unlock_irqrestore(&event_handler->device->event_handler_lock, flags); 526 527 return 0; 528} 529EXPORT_SYMBOL(ib_unregister_event_handler); 530 531/** 532 * ib_dispatch_event - Dispatch an asynchronous event 533 * @event:Event to dispatch 534 * 535 * Low-level drivers must call ib_dispatch_event() to dispatch the 536 * event to all registered event handlers when an asynchronous event 537 * occurs. 538 */ 539void ib_dispatch_event(struct ib_event *event) 540{ 541 unsigned long flags; 542 struct ib_event_handler *handler; 543 544 spin_lock_irqsave(&event->device->event_handler_lock, flags); 545 546 list_for_each_entry(handler, &event->device->event_handler_list, list) 547 handler->handler(handler, event); 548 549 spin_unlock_irqrestore(&event->device->event_handler_lock, flags); 550} 551EXPORT_SYMBOL(ib_dispatch_event); 552 553/** 554 * ib_query_device - Query IB device attributes 555 * @device:Device to query 556 * @device_attr:Device attributes 557 * 558 * ib_query_device() returns the attributes of a device through the 559 * @device_attr pointer. 560 */ 561int ib_query_device(struct ib_device *device, 562 struct ib_device_attr *device_attr) 563{ 564 return device->query_device(device, device_attr); 565} 566EXPORT_SYMBOL(ib_query_device); 567 568/** 569 * ib_query_port - Query IB port attributes 570 * @device:Device to query 571 * @port_num:Port number to query 572 * @port_attr:Port attributes 573 * 574 * ib_query_port() returns the attributes of a port through the 575 * @port_attr pointer. 576 */ 577int ib_query_port(struct ib_device *device, 578 u8 port_num, 579 struct ib_port_attr *port_attr) 580{ 581 if (port_num < start_port(device) || port_num > end_port(device)) 582 return -EINVAL; 583 584 return device->query_port(device, port_num, port_attr); 585} 586EXPORT_SYMBOL(ib_query_port); 587 588/** 589 * ib_query_gid - Get GID table entry 590 * @device:Device to query 591 * @port_num:Port number to query 592 * @index:GID table index to query 593 * @gid:Returned GID 594 * 595 * ib_query_gid() fetches the specified GID table entry. 596 */ 597int ib_query_gid(struct ib_device *device, 598 u8 port_num, int index, union ib_gid *gid) 599{ 600 return device->query_gid(device, port_num, index, gid); 601} 602EXPORT_SYMBOL(ib_query_gid); 603 604/** 605 * ib_query_pkey - Get P_Key table entry 606 * @device:Device to query 607 * @port_num:Port number to query 608 * @index:P_Key table index to query 609 * @pkey:Returned P_Key 610 * 611 * ib_query_pkey() fetches the specified P_Key table entry. 612 */ 613int ib_query_pkey(struct ib_device *device, 614 u8 port_num, u16 index, u16 *pkey) 615{ 616 return device->query_pkey(device, port_num, index, pkey); 617} 618EXPORT_SYMBOL(ib_query_pkey); 619 620/** 621 * ib_modify_device - Change IB device attributes 622 * @device:Device to modify 623 * @device_modify_mask:Mask of attributes to change 624 * @device_modify:New attribute values 625 * 626 * ib_modify_device() changes a device's attributes as specified by 627 * the @device_modify_mask and @device_modify structure. 628 */ 629int ib_modify_device(struct ib_device *device, 630 int device_modify_mask, 631 struct ib_device_modify *device_modify) 632{ 633 return device->modify_device(device, device_modify_mask, 634 device_modify); 635} 636EXPORT_SYMBOL(ib_modify_device); 637 638/** 639 * ib_modify_port - Modifies the attributes for the specified port. 640 * @device: The device to modify. 641 * @port_num: The number of the port to modify. 642 * @port_modify_mask: Mask used to specify which attributes of the port 643 * to change. 644 * @port_modify: New attribute values for the port. 645 * 646 * ib_modify_port() changes a port's attributes as specified by the 647 * @port_modify_mask and @port_modify structure. 648 */ 649int ib_modify_port(struct ib_device *device, 650 u8 port_num, int port_modify_mask, 651 struct ib_port_modify *port_modify) 652{ 653 if (port_num < start_port(device) || port_num > end_port(device)) 654 return -EINVAL; 655 656 return device->modify_port(device, port_num, port_modify_mask, 657 port_modify); 658} 659EXPORT_SYMBOL(ib_modify_port); 660 661/** 662 * ib_find_gid - Returns the port number and GID table index where 663 * a specified GID value occurs. 664 * @device: The device to query. 665 * @gid: The GID value to search for. 666 * @port_num: The port number of the device where the GID value was found. 667 * @index: The index into the GID table where the GID was found. This 668 * parameter may be NULL. 669 */ 670int ib_find_gid(struct ib_device *device, union ib_gid *gid, 671 u8 *port_num, u16 *index) 672{ 673 union ib_gid tmp_gid; 674 int ret, port, i; 675 676 for (port = start_port(device); port <= end_port(device); ++port) { 677 for (i = 0; i < device->gid_tbl_len[port - start_port(device)]; ++i) { 678 ret = ib_query_gid(device, port, i, &tmp_gid); 679 if (ret) 680 return ret; 681 if (!memcmp(&tmp_gid, gid, sizeof *gid)) { 682 *port_num = port; 683 if (index) 684 *index = i; 685 return 0; 686 } 687 } 688 } 689 690 return -ENOENT; 691} 692EXPORT_SYMBOL(ib_find_gid); 693 694/** 695 * ib_find_pkey - Returns the PKey table index where a specified 696 * PKey value occurs. 697 * @device: The device to query. 698 * @port_num: The port number of the device to search for the PKey. 699 * @pkey: The PKey value to search for. 700 * @index: The index into the PKey table where the PKey was found. 701 */ 702int ib_find_pkey(struct ib_device *device, 703 u8 port_num, u16 pkey, u16 *index) 704{ 705 int ret, i; 706 u16 tmp_pkey; 707 708 for (i = 0; i < device->pkey_tbl_len[port_num - start_port(device)]; ++i) { 709 ret = ib_query_pkey(device, port_num, i, &tmp_pkey); 710 if (ret) 711 return ret; 712 713 if ((pkey & 0x7fff) == (tmp_pkey & 0x7fff)) { 714 *index = i; 715 return 0; 716 } 717 } 718 719 return -ENOENT; 720} 721EXPORT_SYMBOL(ib_find_pkey); 722 723static int __init ib_core_init(void) 724{ 725 int ret; 726 727#ifdef __ia64__ 728 if (ia64_platform_is("hpzx1")) 729 dma_map_sg_hp_wa = 1; 730#endif 731 732 ret = ib_sysfs_setup(); 733 if (ret) 734 printk(KERN_WARNING "Couldn't create InfiniBand device class\n"); 735 736 ret = ib_cache_setup(); 737 if (ret) { 738 printk(KERN_WARNING "Couldn't set up InfiniBand P_Key/GID cache\n"); 739 ib_sysfs_cleanup(); 740 } 741 742 return ret; 743} 744 745static void __exit ib_core_cleanup(void) 746{ 747 ib_cache_cleanup(); 748 ib_sysfs_cleanup(); 749 /* Make sure that any pending umem accounting work is done. */ 750 flush_scheduled_work(); 751} 752 753module_init(ib_core_init); 754module_exit(ib_core_cleanup); 755 756#undef MODULE_VERSION 757#include <sys/module.h> 758static int 759ibcore_evhand(module_t mod, int event, void *arg) 760{ 761 return (0); 762} 763 764static moduledata_t ibcore_mod = { 765 .name = "ibcore", 766 .evhand = ibcore_evhand, 767}; 768 769MODULE_VERSION(ibcore, 1); 770DECLARE_MODULE(ibcore, ibcore_mod, SI_SUB_SMP, SI_ORDER_ANY); 771