1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #include <sys/types.h> 27 #include <sys/param.h> 28 #include <sys/modctl.h> 29 #include <sys/sysmacros.h> 30 #include <sys/kmem.h> 31 #include <sys/cmn_err.h> 32 #include <sys/ddi.h> 33 #include <sys/sunddi.h> 34 #include <sys/spl.h> 35 #include <sys/time.h> 36 #include <sys/varargs.h> 37 #include <ipp/ipp.h> 38 #include <ipp/ipp_impl.h> 39 #include <ipp/ipgpc/ipgpc.h> 40 41 /* 42 * Debug switch. 43 */ 44 45 #if defined(DEBUG) 46 #define IPP_DBG 47 #endif 48 49 /* 50 * Globals 51 */ 52 53 /* 54 * ipp_action_count is not static because it is imported by inet/ipp_common.h 55 */ 56 uint32_t ipp_action_count = 0; 57 58 static kmem_cache_t *ipp_mod_cache = NULL; 59 static uint32_t ipp_mod_count = 0; 60 static uint32_t ipp_max_mod = IPP_NMOD; 61 static ipp_mod_t **ipp_mod_byid; 62 static krwlock_t ipp_mod_byid_lock[1]; 63 64 static ipp_mod_id_t ipp_next_mid = IPP_MOD_RESERVED + 1; 65 static ipp_mod_id_t ipp_mid_limit; 66 67 static ipp_ref_t *ipp_mod_byname[IPP_NBUCKET]; 68 static krwlock_t ipp_mod_byname_lock[1]; 69 70 static kmem_cache_t *ipp_action_cache = NULL; 71 static uint32_t ipp_max_action = IPP_NACTION; 72 static ipp_action_t **ipp_action_byid; 73 static krwlock_t ipp_action_byid_lock[1]; 74 75 static ipp_action_id_t ipp_next_aid = IPP_ACTION_RESERVED + 1; 76 static ipp_action_id_t ipp_aid_limit; 77 78 static ipp_ref_t *ipp_action_byname[IPP_NBUCKET]; 79 static krwlock_t ipp_action_byname_lock[1]; 80 static ipp_ref_t *ipp_action_noname; 81 82 static kmem_cache_t *ipp_packet_cache = NULL; 83 static uint_t ipp_packet_classes = IPP_NCLASS; 84 static uint_t ipp_packet_logging = 0; 85 static uint_t ipp_packet_log_entries = IPP_NLOG; 86 87 /* 88 * Prototypes 89 */ 90 91 void ipp_init(void); 92 93 int ipp_list_mods(ipp_mod_id_t **, int *); 94 95 ipp_mod_id_t ipp_mod_lookup(const char *); 96 int ipp_mod_name(ipp_mod_id_t, char **); 97 int ipp_mod_register(const char *, ipp_ops_t *); 98 int ipp_mod_unregister(ipp_mod_id_t); 99 int ipp_mod_list_actions(ipp_mod_id_t, ipp_action_id_t **, 100 int *); 101 102 ipp_action_id_t ipp_action_lookup(const char *); 103 int ipp_action_name(ipp_action_id_t, char **); 104 int ipp_action_mod(ipp_action_id_t, ipp_mod_id_t *); 105 int ipp_action_create(ipp_mod_id_t, const char *, 106 nvlist_t **, ipp_flags_t, ipp_action_id_t *); 107 int ipp_action_modify(ipp_action_id_t, nvlist_t **, 108 ipp_flags_t); 109 int ipp_action_destroy(ipp_action_id_t, ipp_flags_t); 110 int ipp_action_info(ipp_action_id_t, int (*)(nvlist_t *, 111 void *), void *, ipp_flags_t); 112 void ipp_action_set_ptr(ipp_action_id_t, void *); 113 void *ipp_action_get_ptr(ipp_action_id_t); 114 int ipp_action_ref(ipp_action_id_t, ipp_action_id_t, 115 ipp_flags_t); 116 int ipp_action_unref(ipp_action_id_t, ipp_action_id_t, 117 ipp_flags_t); 118 119 int ipp_packet_alloc(ipp_packet_t **, const char *, 120 ipp_action_id_t); 121 void ipp_packet_free(ipp_packet_t *); 122 int ipp_packet_add_class(ipp_packet_t *, const char *, 123 ipp_action_id_t); 124 int ipp_packet_process(ipp_packet_t **); 125 int ipp_packet_next(ipp_packet_t *, ipp_action_id_t); 126 void ipp_packet_set_data(ipp_packet_t *, mblk_t *); 127 mblk_t *ipp_packet_get_data(ipp_packet_t *); 128 void ipp_packet_set_private(ipp_packet_t *, void *, 129 void (*)(void *)); 130 void *ipp_packet_get_private(ipp_packet_t *); 131 132 int ipp_stat_create(ipp_action_id_t, const char *, int, 133 int (*)(ipp_stat_t *, void *, int), void *, ipp_stat_t **); 134 void ipp_stat_install(ipp_stat_t *); 135 void ipp_stat_destroy(ipp_stat_t *); 136 int ipp_stat_named_init(ipp_stat_t *, const char *, uchar_t, 137 ipp_named_t *); 138 int ipp_stat_named_op(ipp_named_t *, void *, int); 139 140 static int ref_mod(ipp_action_t *, ipp_mod_t *); 141 static void unref_mod(ipp_action_t *, ipp_mod_t *); 142 static int is_mod_busy(ipp_mod_t *); 143 static int get_mod_ref(ipp_mod_t *, ipp_action_id_t **, int *); 144 static int get_mods(ipp_mod_id_t **bufp, int *); 145 static ipp_mod_id_t find_mod(const char *); 146 static int alloc_mod(const char *, ipp_mod_id_t *); 147 static void free_mod(ipp_mod_t *); 148 static ipp_mod_t *hold_mod(ipp_mod_id_t); 149 static void rele_mod(ipp_mod_t *); 150 static ipp_mod_id_t get_mid(void); 151 152 static int condemn_action(ipp_ref_t **, ipp_action_t *); 153 static int destroy_action(ipp_action_t *, ipp_flags_t); 154 static int ref_action(ipp_action_t *, ipp_action_t *); 155 static int unref_action(ipp_action_t *, ipp_action_t *); 156 static int is_action_refd(ipp_action_t *); 157 static ipp_action_id_t find_action(const char *); 158 static int alloc_action(const char *, ipp_action_id_t *); 159 static void free_action(ipp_action_t *); 160 static ipp_action_t *hold_action(ipp_action_id_t); 161 static void rele_action(ipp_action_t *); 162 static ipp_action_id_t get_aid(void); 163 164 static int alloc_packet(const char *, ipp_action_id_t, 165 ipp_packet_t **); 166 static int realloc_packet(ipp_packet_t *); 167 static void free_packet(ipp_packet_t *); 168 169 static int hash(const char *); 170 static int update_stats(kstat_t *, int); 171 static void init_mods(void); 172 static void init_actions(void); 173 static void init_packets(void); 174 static int mod_constructor(void *, void *, int); 175 static void mod_destructor(void *, void *); 176 static int action_constructor(void *, void *, int); 177 static void action_destructor(void *, void *); 178 static int packet_constructor(void *, void *, int); 179 static void packet_destructor(void *, void *); 180 181 /* 182 * Debug message macros 183 */ 184 185 #ifdef IPP_DBG 186 187 #define DBG_MOD 0x00000001ull 188 #define DBG_ACTION 0x00000002ull 189 #define DBG_PACKET 0x00000004ull 190 #define DBG_STATS 0x00000008ull 191 #define DBG_LIST 0x00000010ull 192 193 static uint64_t ipp_debug_flags = 194 /* 195 * DBG_PACKET | 196 * DBG_STATS | 197 * DBG_LIST | 198 * DBG_MOD | 199 * DBG_ACTION | 200 */ 201 0; 202 203 static kmutex_t debug_mutex[1]; 204 205 /*PRINTFLIKE3*/ 206 static void ipp_debug(uint64_t, const char *, char *, ...) 207 __KPRINTFLIKE(3); 208 209 #define DBG0(_type, _fmt) \ 210 ipp_debug((_type), __FN__, (_fmt)); 211 212 #define DBG1(_type, _fmt, _a1) \ 213 ipp_debug((_type), __FN__, (_fmt), (_a1)); 214 215 #define DBG2(_type, _fmt, _a1, _a2) \ 216 ipp_debug((_type), __FN__, (_fmt), (_a1), (_a2)); 217 218 #define DBG3(_type, _fmt, _a1, _a2, _a3) \ 219 ipp_debug((_type), __FN__, (_fmt), (_a1), (_a2), \ 220 (_a3)); 221 222 #define DBG4(_type, _fmt, _a1, _a2, _a3, _a4) \ 223 ipp_debug((_type), __FN__, (_fmt), (_a1), (_a2), \ 224 (_a3), (_a4)); 225 226 #define DBG5(_type, _fmt, _a1, _a2, _a3, _a4, _a5) \ 227 ipp_debug((_type), __FN__, (_fmt), (_a1), (_a2), \ 228 (_a3), (_a4), (_a5)); 229 230 #else /* IPP_DBG */ 231 232 #define DBG0(_type, _fmt) 233 #define DBG1(_type, _fmt, _a1) 234 #define DBG2(_type, _fmt, _a1, _a2) 235 #define DBG3(_type, _fmt, _a1, _a2, _a3) 236 #define DBG4(_type, _fmt, _a1, _a2, _a3, _a4) 237 #define DBG5(_type, _fmt, _a1, _a2, _a3, _a4, _a5) 238 239 #endif /* IPP_DBG */ 240 241 /* 242 * Lock macros 243 */ 244 245 #define LOCK_MOD(_imp, _rw) \ 246 rw_enter((_imp)->ippm_lock, (_rw)) 247 #define UNLOCK_MOD(_imp) \ 248 rw_exit((_imp)->ippm_lock) 249 250 #define LOCK_ACTION(_ap, _rw) \ 251 rw_enter((_ap)->ippa_lock, (_rw)) 252 #define UNLOCK_ACTION(_imp) \ 253 rw_exit((_imp)->ippa_lock) 254 255 #define CONFIG_WRITE_START(_ap) \ 256 CONFIG_LOCK_ENTER((_ap)->ippa_config_lock, CL_WRITE) 257 258 #define CONFIG_WRITE_END(_ap) \ 259 CONFIG_LOCK_EXIT((_ap)->ippa_config_lock) 260 261 #define CONFIG_READ_START(_ap) \ 262 CONFIG_LOCK_ENTER((_ap)->ippa_config_lock, CL_READ) 263 264 #define CONFIG_READ_END(_ap) \ 265 CONFIG_LOCK_EXIT((_ap)->ippa_config_lock) 266 267 /* 268 * Exported functions 269 */ 270 271 #define __FN__ "ipp_init" 272 void 273 ipp_init( 274 void) 275 { 276 #ifdef IPP_DBG 277 mutex_init(debug_mutex, NULL, MUTEX_ADAPTIVE, 278 (void *)ipltospl(LOCK_LEVEL)); 279 #endif /* IPP_DBG */ 280 281 /* 282 * Initialize module and action structure caches and associated locks. 283 */ 284 285 init_mods(); 286 init_actions(); 287 init_packets(); 288 } 289 #undef __FN__ 290 291 #define __FN__ "ipp_list_mods" 292 int 293 ipp_list_mods( 294 ipp_mod_id_t **bufp, 295 int *neltp) 296 { 297 ASSERT(bufp != NULL); 298 ASSERT(neltp != NULL); 299 300 return (get_mods(bufp, neltp)); 301 } 302 #undef __FN__ 303 304 /* 305 * Module manipulation interface. 306 */ 307 308 #define __FN__ "ipp_mod_lookup" 309 ipp_mod_id_t 310 ipp_mod_lookup( 311 const char *modname) 312 { 313 ipp_mod_id_t mid; 314 #define FIRST_TIME 0 315 int try = FIRST_TIME; 316 317 /* 318 * Sanity check the module name. 319 */ 320 321 if (modname == NULL || strlen(modname) > MAXNAMELEN - 1) 322 return (IPP_MOD_INVAL); 323 324 try_again: 325 if ((mid = find_mod(modname)) == IPP_MOD_INVAL) { 326 327 /* 328 * Module not installed. 329 */ 330 331 if (try++ == FIRST_TIME) { 332 333 /* 334 * This is the first attempt to find the module so 335 * try to 'demand load' it. 336 */ 337 338 DBG1(DBG_MOD, "loading module '%s'\n", modname); 339 (void) modload("ipp", (char *)modname); 340 goto try_again; 341 } 342 } 343 344 return (mid); 345 346 #undef FIRST_TIME 347 } 348 #undef __FN__ 349 350 #define __FN__ "ipp_mod_name" 351 int 352 ipp_mod_name( 353 ipp_mod_id_t mid, 354 char **modnamep) 355 { 356 ipp_mod_t *imp; 357 char *modname; 358 char *buf; 359 360 ASSERT(modnamep != NULL); 361 362 /* 363 * Translate the module id into the module pointer. 364 */ 365 366 if ((imp = hold_mod(mid)) == NULL) 367 return (ENOENT); 368 369 LOCK_MOD(imp, RW_READER); 370 modname = imp->ippm_name; 371 372 /* 373 * Allocate a buffer to pass back to the caller. 374 */ 375 376 if ((buf = kmem_zalloc(strlen(modname) + 1, KM_NOSLEEP)) == NULL) { 377 UNLOCK_MOD(imp); 378 rele_mod(imp); 379 return (ENOMEM); 380 } 381 382 /* 383 * Copy the module name into the buffer. 384 */ 385 386 (void) strcpy(buf, modname); 387 UNLOCK_MOD(imp); 388 389 *modnamep = buf; 390 391 rele_mod(imp); 392 return (0); 393 } 394 #undef __FN__ 395 396 #define __FN__ "ipp_mod_register" 397 int 398 ipp_mod_register( 399 const char *modname, 400 ipp_ops_t *ipp_ops) 401 { 402 ipp_mod_id_t mid; 403 ipp_mod_t *imp; 404 int rc; 405 406 ASSERT(ipp_ops != NULL); 407 408 /* 409 * Sanity check the module name. 410 */ 411 412 if (modname == NULL || strlen(modname) > MAXNAMELEN - 1) 413 return (EINVAL); 414 415 /* 416 * Allocate a module structure. 417 */ 418 419 if ((rc = alloc_mod(modname, &mid)) != 0) 420 return (rc); 421 422 imp = hold_mod(mid); 423 ASSERT(imp != NULL); 424 425 /* 426 * Make module available for use. 427 */ 428 429 LOCK_MOD(imp, RW_WRITER); 430 DBG1(DBG_MOD, "registering module '%s'\n", imp->ippm_name); 431 imp->ippm_ops = ipp_ops; 432 imp->ippm_state = IPP_MODSTATE_AVAILABLE; 433 UNLOCK_MOD(imp); 434 435 rele_mod(imp); 436 return (0); 437 } 438 #undef __FN__ 439 440 #define __FN__ "ipp_mod_unregister" 441 int 442 ipp_mod_unregister( 443 ipp_mod_id_t mid) 444 { 445 ipp_mod_t *imp; 446 447 /* 448 * Translate the module id into the module pointer. 449 */ 450 451 if ((imp = hold_mod(mid)) == NULL) 452 return (ENOENT); 453 454 LOCK_MOD(imp, RW_WRITER); 455 ASSERT(imp->ippm_state == IPP_MODSTATE_AVAILABLE); 456 457 /* 458 * Check to see if there are any actions that reference the module. 459 */ 460 461 if (is_mod_busy(imp)) { 462 UNLOCK_MOD(imp); 463 rele_mod(imp); 464 return (EBUSY); 465 } 466 467 /* 468 * Prevent further use of the module. 469 */ 470 471 DBG1(DBG_MOD, "unregistering module '%s'\n", imp->ippm_name); 472 imp->ippm_state = IPP_MODSTATE_PROTO; 473 imp->ippm_ops = NULL; 474 UNLOCK_MOD(imp); 475 476 /* 477 * Free the module structure. 478 */ 479 480 free_mod(imp); 481 rele_mod(imp); 482 483 return (0); 484 } 485 #undef __FN__ 486 487 #define __FN__ "ipp_mod_list_actions" 488 int 489 ipp_mod_list_actions( 490 ipp_mod_id_t mid, 491 ipp_action_id_t **bufp, 492 int *neltp) 493 { 494 ipp_mod_t *imp; 495 int rc; 496 497 ASSERT(bufp != NULL); 498 ASSERT(neltp != NULL); 499 500 /* 501 * Translate the module id into the module pointer. 502 */ 503 504 if ((imp = hold_mod(mid)) == NULL) 505 return (ENOENT); 506 507 /* 508 * Get the list of actions referencing the module. 509 */ 510 511 LOCK_MOD(imp, RW_READER); 512 rc = get_mod_ref(imp, bufp, neltp); 513 UNLOCK_MOD(imp); 514 515 rele_mod(imp); 516 return (rc); 517 } 518 #undef __FN__ 519 520 /* 521 * Action manipulation interface. 522 */ 523 524 #define __FN__ "ipp_action_lookup" 525 ipp_action_id_t 526 ipp_action_lookup( 527 const char *aname) 528 { 529 if (aname == NULL) 530 return (IPP_ACTION_INVAL); 531 532 /* 533 * Check for special case 'virtual action' names. 534 */ 535 536 if (strcmp(aname, IPP_ANAME_CONT) == 0) 537 return (IPP_ACTION_CONT); 538 else if (strcmp(aname, IPP_ANAME_DEFER) == 0) 539 return (IPP_ACTION_DEFER); 540 else if (strcmp(aname, IPP_ANAME_DROP) == 0) 541 return (IPP_ACTION_DROP); 542 543 /* 544 * Now check real actions. 545 */ 546 547 return (find_action(aname)); 548 } 549 #undef __FN__ 550 551 #define __FN__ "ipp_action_name" 552 int 553 ipp_action_name( 554 ipp_action_id_t aid, 555 char **anamep) 556 { 557 ipp_action_t *ap; 558 char *aname; 559 char *buf; 560 int rc; 561 562 ASSERT(anamep != NULL); 563 564 /* 565 * Check for special case 'virtual action' ids. 566 */ 567 568 switch (aid) { 569 case IPP_ACTION_CONT: 570 ap = NULL; 571 aname = IPP_ANAME_CONT; 572 break; 573 case IPP_ACTION_DEFER: 574 ap = NULL; 575 aname = IPP_ANAME_DEFER; 576 break; 577 case IPP_ACTION_DROP: 578 ap = NULL; 579 aname = IPP_ANAME_DROP; 580 break; 581 default: 582 583 /* 584 * Not a special case. Check for a real action. 585 */ 586 587 if ((ap = hold_action(aid)) == NULL) 588 return (ENOENT); 589 590 LOCK_ACTION(ap, RW_READER); 591 aname = ap->ippa_name; 592 break; 593 } 594 595 /* 596 * Allocate a buffer to pass back to the caller. 597 */ 598 599 if ((buf = kmem_zalloc(strlen(aname) + 1, KM_NOSLEEP)) == NULL) { 600 rc = ENOMEM; 601 goto done; 602 } 603 604 /* 605 * Copy the action name into the buffer. 606 */ 607 608 (void) strcpy(buf, aname); 609 *anamep = buf; 610 rc = 0; 611 done: 612 /* 613 * Unlock the action if necessary (i.e. it wasn't a virtual action). 614 */ 615 616 if (ap != NULL) { 617 UNLOCK_ACTION(ap); 618 rele_action(ap); 619 } 620 621 return (rc); 622 } 623 #undef __FN__ 624 625 #define __FN__ "ipp_action_mod" 626 int 627 ipp_action_mod( 628 ipp_action_id_t aid, 629 ipp_mod_id_t *midp) 630 { 631 ipp_action_t *ap; 632 ipp_mod_t *imp; 633 634 ASSERT(midp != NULL); 635 636 /* 637 * Return an error for 'virtual action' ids. 638 */ 639 640 switch (aid) { 641 case IPP_ACTION_CONT: 642 /*FALLTHRU*/ 643 case IPP_ACTION_DEFER: 644 /*FALLTHRU*/ 645 case IPP_ACTION_DROP: 646 return (EINVAL); 647 default: 648 break; 649 } 650 651 /* 652 * This is a real action. 653 */ 654 655 if ((ap = hold_action(aid)) == NULL) 656 return (ENOENT); 657 658 /* 659 * Check that the action is not in prototype state. 660 */ 661 662 LOCK_ACTION(ap, RW_READER); 663 if (ap->ippa_state == IPP_ASTATE_PROTO) { 664 UNLOCK_ACTION(ap); 665 rele_action(ap); 666 return (ENOENT); 667 } 668 669 imp = ap->ippa_mod; 670 ASSERT(imp != NULL); 671 UNLOCK_ACTION(ap); 672 673 *midp = imp->ippm_id; 674 675 rele_action(ap); 676 return (0); 677 } 678 #undef __FN__ 679 680 #define __FN__ "ipp_action_create" 681 int 682 ipp_action_create( 683 ipp_mod_id_t mid, 684 const char *aname, 685 nvlist_t **nvlpp, 686 ipp_flags_t flags, 687 ipp_action_id_t *aidp) 688 { 689 ipp_ops_t *ippo; 690 ipp_mod_t *imp; 691 ipp_action_id_t aid; 692 ipp_action_t *ap; 693 int rc; 694 695 ASSERT(nvlpp != NULL); 696 ASSERT(*nvlpp != NULL); 697 698 /* 699 * Sanity check the action name (NULL means the framework chooses the 700 * name). 701 */ 702 703 if (aname != NULL && strlen(aname) > MAXNAMELEN - 1) 704 return (EINVAL); 705 706 /* 707 * Translate the module id into the module pointer. 708 */ 709 710 if ((imp = hold_mod(mid)) == NULL) 711 return (ENOENT); 712 713 /* 714 * Allocate an action. 715 */ 716 717 if ((rc = alloc_action(aname, &aid)) != 0) { 718 rele_mod(imp); 719 return (rc); 720 } 721 722 ap = hold_action(aid); 723 ASSERT(ap != NULL); 724 725 /* 726 * Note that the action is in the process of creation/destruction. 727 */ 728 729 LOCK_ACTION(ap, RW_WRITER); 730 ap->ippa_state = IPP_ASTATE_CONFIG_PENDING; 731 732 /* 733 * Reference the module for which the action is being created. 734 */ 735 736 LOCK_MOD(imp, RW_WRITER); 737 if ((rc = ref_mod(ap, imp)) != 0) { 738 UNLOCK_MOD(imp); 739 ap->ippa_state = IPP_ASTATE_PROTO; 740 UNLOCK_ACTION(ap); 741 742 free_action(ap); 743 rele_action(ap); 744 rele_mod(imp); 745 return (rc); 746 } 747 748 UNLOCK_ACTION(ap); 749 750 ippo = imp->ippm_ops; 751 ASSERT(ippo != NULL); 752 UNLOCK_MOD(imp); 753 754 /* 755 * Call into the module to create the action context. 756 */ 757 758 CONFIG_WRITE_START(ap); 759 DBG2(DBG_ACTION, "creating action '%s' in module '%s'\n", 760 ap->ippa_name, imp->ippm_name); 761 if ((rc = ippo->ippo_action_create(ap->ippa_id, nvlpp, flags)) != 0) { 762 LOCK_ACTION(ap, RW_WRITER); 763 LOCK_MOD(imp, RW_WRITER); 764 unref_mod(ap, imp); 765 UNLOCK_MOD(imp); 766 ap->ippa_state = IPP_ASTATE_PROTO; 767 UNLOCK_ACTION(ap); 768 769 CONFIG_WRITE_END(ap); 770 771 free_action(ap); 772 rele_action(ap); 773 rele_mod(imp); 774 return (rc); 775 } 776 CONFIG_WRITE_END(ap); 777 778 /* 779 * Make the action available for use. 780 */ 781 782 LOCK_ACTION(ap, RW_WRITER); 783 ap->ippa_state = IPP_ASTATE_AVAILABLE; 784 if (aidp != NULL) 785 *aidp = ap->ippa_id; 786 UNLOCK_ACTION(ap); 787 788 rele_action(ap); 789 rele_mod(imp); 790 return (0); 791 } 792 #undef __FN__ 793 794 #define __FN__ "ipp_action_destroy" 795 int 796 ipp_action_destroy( 797 ipp_action_id_t aid, 798 ipp_flags_t flags) 799 { 800 ipp_ref_t *rp = NULL; 801 ipp_ref_t *tmp; 802 ipp_action_t *ap; 803 int rc; 804 805 /* 806 * Translate the action id into the action pointer. 807 */ 808 809 if ((ap = hold_action(aid)) == NULL) 810 return (ENOENT); 811 812 /* 813 * Set the condemned action list pointer and destroy the action. 814 */ 815 816 ap->ippa_condemned = &rp; 817 if ((rc = destroy_action(ap, flags)) == 0) { 818 819 /* 820 * Destroy any other actions condemned by the destruction of 821 * the first action. 822 */ 823 824 for (tmp = rp; tmp != NULL; tmp = tmp->ippr_nextp) { 825 ap = tmp->ippr_action; 826 ap->ippa_condemned = &rp; 827 (void) destroy_action(ap, flags); 828 } 829 } else { 830 831 /* 832 * Unreference any condemned actions since the destruction of 833 * the first action failed. 834 */ 835 836 for (tmp = rp; tmp != NULL; tmp = tmp->ippr_nextp) { 837 ap = tmp->ippr_action; 838 rele_action(ap); 839 } 840 } 841 842 /* 843 * Clean up the condemned list. 844 */ 845 846 while (rp != NULL) { 847 tmp = rp; 848 rp = rp->ippr_nextp; 849 kmem_free(tmp, sizeof (ipp_ref_t)); 850 } 851 852 return (rc); 853 } 854 #undef __FN__ 855 856 #define __FN__ "ipp_action_modify" 857 int 858 ipp_action_modify( 859 ipp_action_id_t aid, 860 nvlist_t **nvlpp, 861 ipp_flags_t flags) 862 { 863 ipp_action_t *ap; 864 ipp_ops_t *ippo; 865 ipp_mod_t *imp; 866 int rc; 867 868 ASSERT(nvlpp != NULL); 869 ASSERT(*nvlpp != NULL); 870 871 /* 872 * Translate the action id into the action pointer. 873 */ 874 875 if ((ap = hold_action(aid)) == NULL) 876 return (ENOENT); 877 878 /* 879 * Check that the action is either available for use or is in the 880 * process of creation/destruction. 881 * 882 * NOTE: It is up to the module to lock multiple configuration 883 * operations against each other if necessary. 884 */ 885 886 LOCK_ACTION(ap, RW_READER); 887 if (ap->ippa_state != IPP_ASTATE_AVAILABLE && 888 ap->ippa_state != IPP_ASTATE_CONFIG_PENDING) { 889 UNLOCK_ACTION(ap); 890 rele_action(ap); 891 return (EPROTO); 892 } 893 894 imp = ap->ippa_mod; 895 ASSERT(imp != NULL); 896 UNLOCK_ACTION(ap); 897 898 ippo = imp->ippm_ops; 899 ASSERT(ippo != NULL); 900 901 /* 902 * Call into the module to modify the action context. 903 */ 904 905 DBG1(DBG_ACTION, "modifying action '%s'\n", ap->ippa_name); 906 CONFIG_WRITE_START(ap); 907 rc = ippo->ippo_action_modify(aid, nvlpp, flags); 908 CONFIG_WRITE_END(ap); 909 910 rele_action(ap); 911 return (rc); 912 } 913 #undef __FN__ 914 915 #define __FN__ "ipp_action_info" 916 int 917 ipp_action_info( 918 ipp_action_id_t aid, 919 int (*fn)(nvlist_t *, void *), 920 void *arg, 921 ipp_flags_t flags) 922 { 923 ipp_action_t *ap; 924 ipp_mod_t *imp; 925 ipp_ops_t *ippo; 926 int rc; 927 928 /* 929 * Translate the action id into the action pointer. 930 */ 931 932 if ((ap = hold_action(aid)) == NULL) 933 return (ENOENT); 934 935 /* 936 * Check that the action is available for use. We don't want to 937 * read back parameters while the action is in the process of 938 * creation/destruction. 939 */ 940 941 LOCK_ACTION(ap, RW_READER); 942 if (ap->ippa_state != IPP_ASTATE_AVAILABLE) { 943 UNLOCK_ACTION(ap); 944 rele_action(ap); 945 return (EPROTO); 946 } 947 948 imp = ap->ippa_mod; 949 ASSERT(imp != NULL); 950 UNLOCK_ACTION(ap); 951 952 ippo = imp->ippm_ops; 953 ASSERT(ippo != NULL); 954 955 /* 956 * Call into the module to get the action configuration information. 957 */ 958 959 DBG1(DBG_ACTION, 960 "getting configuration information from action '%s'\n", 961 ap->ippa_name); 962 CONFIG_READ_START(ap); 963 if ((rc = ippo->ippo_action_info(aid, fn, arg, flags)) != 0) { 964 CONFIG_READ_END(ap); 965 rele_action(ap); 966 return (rc); 967 } 968 CONFIG_READ_END(ap); 969 970 rele_action(ap); 971 return (0); 972 } 973 #undef __FN__ 974 975 #define __FN__ "ipp_action_set_ptr" 976 void 977 ipp_action_set_ptr( 978 ipp_action_id_t aid, 979 void *ptr) 980 { 981 ipp_action_t *ap; 982 983 /* 984 * Translate the action id into the action pointer. 985 */ 986 987 ap = hold_action(aid); 988 ASSERT(ap != NULL); 989 990 /* 991 * Set the private data pointer. 992 */ 993 994 ap->ippa_ptr = ptr; 995 rele_action(ap); 996 } 997 #undef __FN__ 998 999 #define __FN__ "ipp_action_get_ptr" 1000 void * 1001 ipp_action_get_ptr( 1002 ipp_action_id_t aid) 1003 { 1004 ipp_action_t *ap; 1005 void *ptr; 1006 1007 /* 1008 * Translate the action id into the action pointer. 1009 */ 1010 1011 ap = hold_action(aid); 1012 ASSERT(ap != NULL); 1013 1014 /* 1015 * Return the private data pointer. 1016 */ 1017 1018 ptr = ap->ippa_ptr; 1019 rele_action(ap); 1020 1021 return (ptr); 1022 } 1023 #undef __FN__ 1024 1025 #define __FN__ "ipp_action_ref" 1026 /*ARGSUSED*/ 1027 int 1028 ipp_action_ref( 1029 ipp_action_id_t aid, 1030 ipp_action_id_t ref_aid, 1031 ipp_flags_t flags) 1032 { 1033 ipp_action_t *ap; 1034 ipp_action_t *ref_ap; 1035 int rc; 1036 1037 /* 1038 * Actions are not allowed to reference themselves. 1039 */ 1040 1041 if (aid == ref_aid) 1042 return (EINVAL); 1043 1044 /* 1045 * Check for a special case 'virtual action' id. 1046 */ 1047 1048 switch (ref_aid) { 1049 case IPP_ACTION_CONT: 1050 /*FALLTHRU*/ 1051 case IPP_ACTION_DEFER: 1052 /*FALLTHRU*/ 1053 case IPP_ACTION_DROP: 1054 return (0); 1055 default: 1056 break; 1057 } 1058 1059 /* 1060 * Translate the action ids into action pointers. 1061 */ 1062 1063 if ((ap = hold_action(aid)) == NULL) 1064 return (ENOENT); 1065 1066 if ((ref_ap = hold_action(ref_aid)) == NULL) { 1067 rele_action(ap); 1068 return (ENOENT); 1069 } 1070 1071 LOCK_ACTION(ap, RW_WRITER); 1072 LOCK_ACTION(ref_ap, RW_WRITER); 1073 1074 if (ref_ap->ippa_state != IPP_ASTATE_AVAILABLE) { 1075 UNLOCK_ACTION(ref_ap); 1076 UNLOCK_ACTION(ap); 1077 1078 rele_action(ref_ap); 1079 rele_action(ap); 1080 return (EPROTO); 1081 } 1082 1083 /* 1084 * Create references between the two actions. 1085 */ 1086 1087 rc = ref_action(ap, ref_ap); 1088 UNLOCK_ACTION(ref_ap); 1089 UNLOCK_ACTION(ap); 1090 1091 rele_action(ref_ap); 1092 rele_action(ap); 1093 return (rc); 1094 } 1095 #undef __FN__ 1096 1097 #define __FN__ "ipp_action_unref" 1098 int 1099 ipp_action_unref( 1100 ipp_action_id_t aid, 1101 ipp_action_id_t ref_aid, 1102 ipp_flags_t flags) 1103 { 1104 ipp_action_t *ap; 1105 ipp_action_t *ref_ap; 1106 int ref_is_busy; 1107 int rc; 1108 1109 if (aid == ref_aid) 1110 return (EINVAL); 1111 1112 /* 1113 * Check for a special case 'virtual action' id. 1114 */ 1115 1116 switch (ref_aid) { 1117 case IPP_ACTION_CONT: 1118 /*FALLTHRU*/ 1119 case IPP_ACTION_DEFER: 1120 /*FALLTHRU*/ 1121 case IPP_ACTION_DROP: 1122 return (0); 1123 default: 1124 break; 1125 } 1126 1127 /* 1128 * Translate the action ids into action pointers. 1129 */ 1130 1131 if ((ap = hold_action(aid)) == NULL) 1132 return (ENOENT); 1133 1134 if ((ref_ap = hold_action(ref_aid)) == NULL) { 1135 rele_action(ap); 1136 return (ENOENT); 1137 } 1138 1139 LOCK_ACTION(ap, RW_WRITER); 1140 LOCK_ACTION(ref_ap, RW_WRITER); 1141 1142 /* 1143 * Remove the reference between the actions. 1144 */ 1145 1146 if ((rc = unref_action(ap, ref_ap)) != 0) { 1147 UNLOCK_ACTION(ref_ap); 1148 UNLOCK_ACTION(ap); 1149 rele_action(ref_ap); 1150 rele_action(ap); 1151 return (rc); 1152 } 1153 1154 ref_is_busy = is_action_refd(ref_ap); 1155 1156 UNLOCK_ACTION(ref_ap); 1157 UNLOCK_ACTION(ap); 1158 1159 if (flags & IPP_DESTROY_REF) { 1160 if (!ref_is_busy) { 1161 1162 /* 1163 * Condemn the action so that it will be destroyed. 1164 */ 1165 1166 (void) condemn_action(ap->ippa_condemned, ref_ap); 1167 return (0); 1168 } 1169 } 1170 1171 rele_action(ref_ap); 1172 rele_action(ap); 1173 return (0); 1174 } 1175 #undef __FN__ 1176 1177 /* 1178 * Packet manipulation interface. 1179 */ 1180 1181 #define __FN__ "ipp_packet_alloc" 1182 int 1183 ipp_packet_alloc( 1184 ipp_packet_t **ppp, 1185 const char *name, 1186 ipp_action_id_t aid) 1187 { 1188 ipp_packet_t *pp; 1189 int rc; 1190 1191 ASSERT(ppp != NULL); 1192 1193 /* 1194 * A name is required. 1195 */ 1196 1197 if (name == NULL || strlen(name) > MAXNAMELEN - 1) 1198 return (EINVAL); 1199 1200 /* 1201 * Allocate a packet structure from the cache. 1202 */ 1203 1204 if ((rc = alloc_packet(name, aid, &pp)) != 0) 1205 return (rc); 1206 1207 if (ipp_packet_logging != 0 && pp->ippp_log == NULL) { 1208 1209 /* 1210 * Logging is turned on but there's no log buffer. We need 1211 * to allocate one. 1212 */ 1213 if ((pp->ippp_log = kmem_alloc( 1214 ipp_packet_log_entries * sizeof (ipp_log_t), 1215 KM_NOSLEEP)) != NULL) { 1216 pp->ippp_log_limit = ipp_packet_log_entries - 1; 1217 pp->ippp_log_windex = 0; 1218 } 1219 } else if (ipp_packet_logging == 0 && pp->ippp_log != NULL) { 1220 1221 /* 1222 * A log buffer is present but logging has been turned off. 1223 * Free the buffer now, 1224 */ 1225 1226 kmem_free(pp->ippp_log, 1227 (pp->ippp_log_limit + 1) * sizeof (ipp_log_t)); 1228 pp->ippp_log = NULL; 1229 pp->ippp_log_limit = 0; 1230 pp->ippp_log_windex = 0; 1231 } 1232 1233 *ppp = pp; 1234 return (0); 1235 } 1236 #undef __FN__ 1237 1238 #define __FN__ "ipp_packet_free" 1239 void 1240 ipp_packet_free( 1241 ipp_packet_t *pp) 1242 { 1243 1244 ASSERT(pp != NULL); 1245 1246 /* 1247 * If there is a private structure pointer set, call its free 1248 * function. 1249 */ 1250 1251 if (pp->ippp_private) { 1252 pp->ippp_private_free(pp->ippp_private); 1253 pp->ippp_private = NULL; 1254 pp->ippp_private_free = NULL; 1255 } 1256 1257 /* 1258 * Free the packet structure back to the cache. 1259 */ 1260 1261 free_packet(pp); 1262 } 1263 #undef __FN__ 1264 1265 #define __FN__ "ipp_packet_add_class" 1266 int 1267 ipp_packet_add_class( 1268 ipp_packet_t *pp, 1269 const char *name, 1270 ipp_action_id_t aid) 1271 { 1272 ipp_class_t *cp; 1273 int rc; 1274 1275 ASSERT(pp != NULL); 1276 1277 /* 1278 * A name is required. 1279 */ 1280 1281 if (name == NULL || strlen(name) > MAXNAMELEN - 1) 1282 return (EINVAL); 1283 1284 /* 1285 * Check if there is an available class structure. 1286 */ 1287 1288 if (pp->ippp_class_windex == pp->ippp_class_limit) { 1289 1290 /* 1291 * No more structures. Re-allocate the array. 1292 */ 1293 1294 if ((rc = realloc_packet(pp)) != 0) 1295 return (rc); 1296 } 1297 ASSERT(pp->ippp_class_windex < pp->ippp_class_limit); 1298 1299 /* 1300 * Set up a new class structure. 1301 */ 1302 1303 cp = &(pp->ippp_class_array[pp->ippp_class_windex++]); 1304 (void) strcpy(cp->ippc_name, name); 1305 cp->ippc_aid = aid; 1306 1307 return (0); 1308 } 1309 #undef __FN__ 1310 1311 #define __FN__ "ipp_packet_process" 1312 int 1313 ipp_packet_process( 1314 ipp_packet_t **ppp) 1315 { 1316 ipp_packet_t *pp; 1317 ipp_action_id_t aid; 1318 ipp_class_t *cp; 1319 ipp_log_t *lp; 1320 ipp_action_t *ap; 1321 ipp_mod_t *imp; 1322 ipp_ops_t *ippo; 1323 int rc; 1324 1325 ASSERT(ppp != NULL); 1326 pp = *ppp; 1327 ASSERT(pp != NULL); 1328 1329 /* 1330 * Walk the class list. 1331 */ 1332 1333 while (pp->ippp_class_rindex < pp->ippp_class_windex) { 1334 cp = &(pp->ippp_class_array[pp->ippp_class_rindex]); 1335 1336 /* 1337 * While there is a real action to invoke... 1338 */ 1339 1340 aid = cp->ippc_aid; 1341 while (aid != IPP_ACTION_CONT && 1342 aid != IPP_ACTION_DEFER && 1343 aid != IPP_ACTION_DROP) { 1344 1345 ASSERT(aid != IPP_ACTION_INVAL); 1346 1347 /* 1348 * Translate the action id to the action pointer. 1349 */ 1350 1351 if ((ap = hold_action(aid)) == NULL) { 1352 DBG1(DBG_PACKET, 1353 "action id '%d' not found\n", aid); 1354 return (ENOENT); 1355 } 1356 1357 /* 1358 * Check that the action is available for use... 1359 */ 1360 LOCK_ACTION(ap, RW_READER); 1361 if (ap->ippa_state != IPP_ASTATE_AVAILABLE) { 1362 UNLOCK_ACTION(ap); 1363 rele_action(ap); 1364 return (EPROTO); 1365 } 1366 1367 /* 1368 * Increment the action's packet count to note that 1369 * it's being used. 1370 * 1371 * NOTE: We only have a read lock, so we need to use 1372 * atomic_add_32(). The read lock is still 1373 * important though as it is crucial to block 1374 * out a destroy operation between the action 1375 * state being checked and the packet count 1376 * being incremented. 1377 */ 1378 1379 atomic_inc_32(&(ap->ippa_packets)); 1380 1381 imp = ap->ippa_mod; 1382 ASSERT(imp != NULL); 1383 UNLOCK_ACTION(ap); 1384 1385 ippo = imp->ippm_ops; 1386 ASSERT(ippo != NULL); 1387 1388 /* 1389 * If there's a log, grab the next entry and fill it 1390 * in. 1391 */ 1392 1393 if (pp->ippp_log != NULL && 1394 pp->ippp_log_windex <= pp->ippp_log_limit) { 1395 lp = &(pp->ippp_log[pp->ippp_log_windex++]); 1396 lp->ippl_aid = aid; 1397 (void) strcpy(lp->ippl_name, cp->ippc_name); 1398 gethrestime(&lp->ippl_begin); 1399 } else { 1400 lp = NULL; 1401 } 1402 1403 /* 1404 * Invoke the action. 1405 */ 1406 1407 rc = ippo->ippo_action_invoke(aid, pp); 1408 1409 /* 1410 * Also log the time that the action finished 1411 * processing. 1412 */ 1413 1414 if (lp != NULL) 1415 gethrestime(&lp->ippl_end); 1416 1417 /* 1418 * Decrement the packet count. 1419 */ 1420 1421 atomic_dec_32(&(ap->ippa_packets)); 1422 1423 /* 1424 * If the class' action id is the same now as it was 1425 * before then clearly no 'next action' has been set. 1426 * This is a protocol error. 1427 */ 1428 1429 if (cp->ippc_aid == aid) { 1430 DBG1(DBG_PACKET, 1431 "action '%s' did not set next action\n", 1432 ap->ippa_name); 1433 rele_action(ap); 1434 return (EPROTO); 1435 } 1436 1437 /* 1438 * The action did not complete successfully. Terminate 1439 * packet processing. 1440 */ 1441 1442 if (rc != 0) { 1443 DBG2(DBG_PACKET, 1444 "action error '%d' from action '%s'\n", 1445 rc, ap->ippa_name); 1446 rele_action(ap); 1447 return (rc); 1448 } 1449 1450 rele_action(ap); 1451 1452 /* 1453 * Look at the next action. 1454 */ 1455 1456 aid = cp->ippc_aid; 1457 } 1458 1459 /* 1460 * No more real actions to invoke, check for 'virtual' ones. 1461 */ 1462 1463 /* 1464 * Packet deferred: module has held onto packet for processing 1465 * later. 1466 */ 1467 1468 if (cp->ippc_aid == IPP_ACTION_DEFER) { 1469 *ppp = NULL; 1470 return (0); 1471 } 1472 1473 /* 1474 * Packet dropped: free the packet and discontinue processing. 1475 */ 1476 1477 if (cp->ippc_aid == IPP_ACTION_DROP) { 1478 freemsg(pp->ippp_data); 1479 ipp_packet_free(pp); 1480 *ppp = NULL; 1481 return (0); 1482 } 1483 1484 /* 1485 * Must be 'continue processing': move onto the next class. 1486 */ 1487 1488 ASSERT(cp->ippc_aid == IPP_ACTION_CONT); 1489 pp->ippp_class_rindex++; 1490 } 1491 1492 return (0); 1493 } 1494 #undef __FN__ 1495 1496 #define __FN__ "ipp_packet_next" 1497 int 1498 ipp_packet_next( 1499 ipp_packet_t *pp, 1500 ipp_action_id_t aid) 1501 { 1502 ipp_action_t *ap; 1503 ipp_class_t *cp; 1504 1505 ASSERT(pp != NULL); 1506 1507 cp = &(pp->ippp_class_array[pp->ippp_class_rindex]); 1508 ASSERT(cp != NULL); 1509 1510 /* 1511 * Check for a special case 'virtual action' id. 1512 */ 1513 1514 switch (aid) { 1515 case IPP_ACTION_INVAL: 1516 return (EINVAL); 1517 case IPP_ACTION_DEFER: 1518 /*FALLTHRU*/ 1519 case IPP_ACTION_CONT: 1520 /*FALLTHRU*/ 1521 case IPP_ACTION_DROP: 1522 break; 1523 default: 1524 1525 /* 1526 * Not a virtual action so try to translate the action id 1527 * into the action pointer to confirm the actions existence. 1528 */ 1529 1530 if ((ap = hold_action(aid)) == NULL) { 1531 DBG0(DBG_PACKET, "invalid action\n"); 1532 return (ENOENT); 1533 } 1534 rele_action(ap); 1535 1536 break; 1537 } 1538 1539 /* 1540 * Set the class' new action id. 1541 */ 1542 1543 cp->ippc_aid = aid; 1544 1545 return (0); 1546 } 1547 #undef __FN__ 1548 1549 #define __FN__ "ipp_packet_set_data" 1550 void 1551 ipp_packet_set_data( 1552 ipp_packet_t *pp, 1553 mblk_t *data) 1554 { 1555 ASSERT(pp != NULL); 1556 pp->ippp_data = data; 1557 } 1558 #undef __FN__ 1559 1560 #define __FN__ "ipp_packet_get_data" 1561 mblk_t * 1562 ipp_packet_get_data( 1563 ipp_packet_t *pp) 1564 { 1565 ASSERT(pp != NULL); 1566 return (pp->ippp_data); 1567 } 1568 #undef __FN__ 1569 1570 #define __FN__ "ipp_packet_set_private" 1571 void 1572 ipp_packet_set_private( 1573 ipp_packet_t *pp, 1574 void *buf, 1575 void (*free_func)(void *)) 1576 { 1577 ASSERT(pp != NULL); 1578 ASSERT(free_func != NULL); 1579 1580 pp->ippp_private = buf; 1581 pp->ippp_private_free = free_func; 1582 } 1583 #undef __FN__ 1584 1585 #define __FN__ "ipp_packet_get_private" 1586 void * 1587 ipp_packet_get_private( 1588 ipp_packet_t *pp) 1589 { 1590 ASSERT(pp != NULL); 1591 return (pp->ippp_private); 1592 } 1593 #undef __FN__ 1594 1595 /* 1596 * Statistics interface. 1597 */ 1598 1599 #define __FN__ "ipp_stat_create" 1600 int 1601 ipp_stat_create( 1602 ipp_action_id_t aid, 1603 const char *name, 1604 int nstat, 1605 int (*update)(ipp_stat_t *, void *, int), 1606 void *arg, 1607 ipp_stat_t **spp) 1608 { 1609 ipp_action_t *ap; 1610 ipp_mod_t *imp; 1611 ipp_stat_impl_t *sip; 1612 ipp_stat_t *sp; 1613 kstat_t *ksp; 1614 char *class; 1615 char *modname; 1616 int instance; 1617 1618 ASSERT(spp != NULL); 1619 1620 /* 1621 * Sanity check the arguments. 1622 */ 1623 1624 if (name == NULL || nstat <= 0 || update == NULL) 1625 return (EINVAL); 1626 1627 /* 1628 * Translate the action id into the action pointer. 1629 */ 1630 1631 if ((ap = hold_action(aid)) == NULL) 1632 return (ENOENT); 1633 1634 /* 1635 * Grab relevant action and module information. 1636 */ 1637 1638 LOCK_ACTION(ap, RW_READER); 1639 class = ap->ippa_name; 1640 instance = (int)ap->ippa_id; 1641 1642 imp = ap->ippa_mod; 1643 ASSERT(imp != NULL); 1644 1645 LOCK_MOD(imp, RW_READER); 1646 modname = imp->ippm_name; 1647 1648 /* 1649 * Allocate a stats info structure. 1650 */ 1651 1652 if ((sip = kmem_alloc(sizeof (ipp_stat_impl_t), KM_NOSLEEP)) == NULL) 1653 return (ENOMEM); 1654 1655 /* 1656 * Create a set of kstats. 1657 */ 1658 1659 DBG2(DBG_STATS, "creating stat set '%s' for action '%s'\n", 1660 name, class); 1661 if ((ksp = kstat_create(modname, instance, name, class, 1662 KSTAT_TYPE_NAMED, nstat, KSTAT_FLAG_WRITABLE)) == NULL) { 1663 kmem_free(sip, sizeof (ipp_stat_impl_t)); 1664 UNLOCK_ACTION(ap); 1665 UNLOCK_MOD(imp); 1666 return (EINVAL); /* Assume EINVAL was the cause */ 1667 } 1668 1669 UNLOCK_ACTION(ap); 1670 UNLOCK_MOD(imp); 1671 1672 DBG1(DBG_STATS, "ks_data = %p\n", ksp->ks_data); 1673 1674 /* 1675 * Set up the kstats structure with a private data pointer and an 1676 * 'update' function. 1677 */ 1678 1679 ksp->ks_update = update_stats; 1680 ksp->ks_private = (void *)sip; 1681 1682 /* 1683 * Keep a reference to the kstats structure in our own stats info 1684 * structure. 1685 */ 1686 1687 sip->ippsi_ksp = ksp; 1688 sip->ippsi_data = ksp->ks_data; 1689 1690 /* 1691 * Fill in the rest of the stats info structure. 1692 */ 1693 1694 (void) strcpy(sip->ippsi_name, name); 1695 sip->ippsi_arg = arg; 1696 sip->ippsi_update = update; 1697 sip->ippsi_limit = nstat; 1698 sip->ippsi_count = 0; 1699 mutex_init(sip->ippsi_lock, NULL, MUTEX_ADAPTIVE, 1700 (void *)ipltospl(LOCK_LEVEL)); 1701 1702 /* 1703 * Case the stats info structure to a semi-opaque structure that 1704 * we pass back to the caller. 1705 */ 1706 1707 sp = (ipp_stat_t *)sip; 1708 ASSERT(sp->ipps_data == sip->ippsi_data); 1709 *spp = sp; 1710 1711 rele_action(ap); 1712 return (0); 1713 } 1714 #undef __FN__ 1715 1716 #define __FN__ "ipp_stat_install" 1717 void 1718 ipp_stat_install( 1719 ipp_stat_t *sp) 1720 { 1721 ipp_stat_impl_t *sip = (ipp_stat_impl_t *)sp; 1722 1723 ASSERT(sp != NULL); 1724 1725 /* 1726 * Install the set of kstats referenced by the stats info structure. 1727 */ 1728 1729 DBG1(DBG_STATS, "installing stat set '%s'\n", sip->ippsi_name); 1730 kstat_install(sip->ippsi_ksp); 1731 } 1732 #undef __FN__ 1733 1734 #define __FN__ "ipp_stat_destroy" 1735 void 1736 ipp_stat_destroy( 1737 ipp_stat_t *sp) 1738 { 1739 ipp_stat_impl_t *sip = (ipp_stat_impl_t *)sp; 1740 1741 ASSERT(sp != NULL); 1742 1743 /* 1744 * Destroy the set of kstats referenced by the stats info structure. 1745 */ 1746 1747 DBG1(DBG_STATS, "destroying stat set '%s'\n", sip->ippsi_name); 1748 kstat_delete(sip->ippsi_ksp); 1749 1750 /* 1751 * Destroy the stats info structure itself. 1752 */ 1753 1754 mutex_destroy(sip->ippsi_lock); 1755 kmem_free(sip, sizeof (ipp_stat_impl_t)); 1756 } 1757 #undef __FN__ 1758 1759 #define __FN__ "ipp_stat_named_init" 1760 int 1761 ipp_stat_named_init( 1762 ipp_stat_t *sp, 1763 const char *name, 1764 uchar_t type, 1765 ipp_named_t *np) 1766 { 1767 ipp_stat_impl_t *sip = (ipp_stat_impl_t *)sp; 1768 uchar_t ktype; 1769 1770 ASSERT(sp != NULL); 1771 ASSERT(np != NULL); 1772 1773 if (name == NULL) 1774 return (EINVAL); 1775 1776 if ((type & IPP_STAT_TAG) == 0) 1777 return (EINVAL); 1778 ktype = type & ~IPP_STAT_TAG; 1779 1780 /* 1781 * Check we will not exceed the maximum number of a stats that was 1782 * indicated during set creation. 1783 */ 1784 1785 mutex_enter(sip->ippsi_lock); 1786 if (sip->ippsi_count >= sip->ippsi_limit) { 1787 mutex_exit(sip->ippsi_lock); 1788 return (ENOSPC); 1789 } 1790 1791 /* 1792 * Bump the count. 1793 */ 1794 1795 sip->ippsi_count++; 1796 1797 /* 1798 * Create a new named kstat. 1799 */ 1800 1801 DBG3(DBG_STATS, "%s.%s: knp = %p\n", sip->ippsi_name, name, np); 1802 kstat_named_init(np, name, ktype); 1803 mutex_exit(sip->ippsi_lock); 1804 1805 return (0); 1806 } 1807 #undef __FN__ 1808 1809 #define __FN__ "ipp_stat_named_op" 1810 int 1811 ipp_stat_named_op( 1812 ipp_named_t *np, 1813 void *valp, 1814 int rw) 1815 { 1816 kstat_named_t *knp; 1817 uchar_t type; 1818 int rc = 0; 1819 1820 ASSERT(np != NULL); 1821 ASSERT(valp != NULL); 1822 1823 knp = np; 1824 type = knp->data_type | IPP_STAT_TAG; 1825 1826 /* 1827 * Copy data to or from the named kstat, depending on the specified 1828 * opcode. 1829 */ 1830 1831 switch (rw) { 1832 case IPP_STAT_WRITE: 1833 switch (type) { 1834 case IPP_STAT_INT32: 1835 *(int32_t *)valp = knp->value.i32; 1836 break; 1837 case IPP_STAT_UINT32: 1838 *(uint32_t *)valp = knp->value.ui32; 1839 break; 1840 case IPP_STAT_INT64: 1841 *(int64_t *)valp = knp->value.i64; 1842 break; 1843 case IPP_STAT_UINT64: 1844 *(uint64_t *)valp = knp->value.ui64; 1845 break; 1846 case IPP_STAT_STRING: 1847 (void) strncpy(valp, knp->value.c, 16); 1848 break; 1849 default: 1850 ASSERT(0); /* should not reach here */ 1851 break; 1852 } 1853 1854 break; 1855 case IPP_STAT_READ: 1856 switch (type) { 1857 case IPP_STAT_INT32: 1858 knp->value.i32 = *(int32_t *)valp; 1859 break; 1860 case IPP_STAT_UINT32: 1861 knp->value.ui32 = *(uint32_t *)valp; 1862 break; 1863 case IPP_STAT_INT64: 1864 knp->value.i64 = *(int64_t *)valp; 1865 break; 1866 case IPP_STAT_UINT64: 1867 knp->value.ui64 = *(uint64_t *)valp; 1868 break; 1869 case IPP_STAT_STRING: 1870 (void) strncpy(knp->value.c, valp, 16); 1871 break; 1872 default: 1873 ASSERT(0); /* should not reach here */ 1874 break; 1875 } 1876 1877 break; 1878 default: 1879 rc = EINVAL; 1880 } 1881 1882 return (rc); 1883 } 1884 #undef __FN__ 1885 1886 /* 1887 * Local functions (for local people. There's nothing for you here!) 1888 */ 1889 1890 #define __FN__ "ref_mod" 1891 static int 1892 ref_mod( 1893 ipp_action_t *ap, 1894 ipp_mod_t *imp) 1895 { 1896 ipp_ref_t **rpp; 1897 ipp_ref_t *rp; 1898 1899 ASSERT(rw_write_held(ap->ippa_lock)); 1900 ASSERT(rw_write_held(imp->ippm_lock)); 1901 1902 /* 1903 * Add the new reference at the end of the module's list. 1904 */ 1905 1906 rpp = &(imp->ippm_action); 1907 while ((rp = *rpp) != NULL) { 1908 ASSERT(rp->ippr_action != ap); 1909 rpp = &(rp->ippr_nextp); 1910 } 1911 1912 /* 1913 * Allocate a reference structure. 1914 */ 1915 1916 if ((rp = kmem_zalloc(sizeof (ipp_ref_t), KM_NOSLEEP)) == NULL) 1917 return (ENOMEM); 1918 1919 /* 1920 * Set the reference to the action and link it onto the module's list. 1921 */ 1922 1923 rp->ippr_action = ap; 1924 *rpp = rp; 1925 1926 /* 1927 * Keep a 'back pointer' from the action structure to the module 1928 * structure. 1929 */ 1930 1931 ap->ippa_mod = imp; 1932 1933 return (0); 1934 } 1935 #undef __FN__ 1936 1937 #define __FN__ "unref_mod" 1938 static void 1939 unref_mod( 1940 ipp_action_t *ap, 1941 ipp_mod_t *imp) 1942 { 1943 ipp_ref_t **rpp; 1944 ipp_ref_t *rp; 1945 1946 ASSERT(rw_write_held(ap->ippa_lock)); 1947 ASSERT(rw_write_held(imp->ippm_lock)); 1948 1949 /* 1950 * Scan the module's list for the reference to the action. 1951 */ 1952 1953 rpp = &(imp->ippm_action); 1954 while ((rp = *rpp) != NULL) { 1955 if (rp->ippr_action == ap) 1956 break; 1957 rpp = &(rp->ippr_nextp); 1958 } 1959 ASSERT(rp != NULL); 1960 1961 /* 1962 * Unlink the reference structure and free it. 1963 */ 1964 1965 *rpp = rp->ippr_nextp; 1966 kmem_free(rp, sizeof (ipp_ref_t)); 1967 1968 /* 1969 * NULL the 'back pointer'. 1970 */ 1971 1972 ap->ippa_mod = NULL; 1973 } 1974 #undef __FN__ 1975 1976 #define __FN__ "is_mod_busy" 1977 static int 1978 is_mod_busy( 1979 ipp_mod_t *imp) 1980 { 1981 /* 1982 * Return a value which is true (non-zero) iff the module refers 1983 * to no actions. 1984 */ 1985 1986 return (imp->ippm_action != NULL); 1987 } 1988 #undef __FN__ 1989 1990 #define __FN__ "get_mod_ref" 1991 static int 1992 get_mod_ref( 1993 ipp_mod_t *imp, 1994 ipp_action_id_t **bufp, 1995 int *neltp) 1996 { 1997 ipp_ref_t *rp; 1998 int nelt; 1999 ipp_action_t *ap; 2000 ipp_action_id_t *buf; 2001 int length; 2002 2003 ASSERT(rw_lock_held(imp->ippm_lock)); 2004 2005 /* 2006 * Count the number of actions referred to from the module structure. 2007 */ 2008 2009 nelt = 0; 2010 for (rp = imp->ippm_action; rp != NULL; rp = rp->ippr_nextp) { 2011 nelt++; 2012 } 2013 DBG1(DBG_LIST, "%d actions found\n", nelt); 2014 2015 /* 2016 * If there are no actions referred to then there's nothing to do. 2017 */ 2018 2019 if (nelt == 0) { 2020 *bufp = NULL; 2021 *neltp = 0; 2022 return (0); 2023 } 2024 2025 /* 2026 * Allocate a buffer to pass back to the caller. 2027 */ 2028 2029 length = nelt * sizeof (ipp_action_id_t); 2030 if ((buf = kmem_alloc(length, KM_NOSLEEP)) == NULL) 2031 return (ENOMEM); 2032 2033 /* 2034 * Fill the buffer with an array of action ids. 2035 */ 2036 2037 *bufp = buf; 2038 *neltp = nelt; 2039 2040 for (rp = imp->ippm_action; rp != NULL; rp = rp->ippr_nextp) { 2041 ap = rp->ippr_action; 2042 *buf++ = ap->ippa_id; 2043 } 2044 2045 ASSERT((uintptr_t)buf == (uintptr_t)*bufp + length); 2046 return (0); 2047 } 2048 #undef __FN__ 2049 2050 #define __FN__ "get_mods" 2051 static int 2052 get_mods( 2053 ipp_mod_id_t **bufp, 2054 int *neltp) 2055 { 2056 ipp_mod_id_t *buf; 2057 int length; 2058 ipp_mod_id_t mid; 2059 ipp_mod_t *imp; 2060 2061 2062 rw_enter(ipp_mod_byname_lock, RW_READER); 2063 2064 /* 2065 * If there are no modules registered then there's nothing to do. 2066 */ 2067 2068 if (ipp_mod_count == 0) { 2069 DBG0(DBG_LIST, "no modules registered\n"); 2070 *bufp = NULL; 2071 *neltp = 0; 2072 rw_exit(ipp_mod_byname_lock); 2073 return (0); 2074 } 2075 2076 /* 2077 * Allocate a buffer to pass back to the caller. 2078 */ 2079 2080 DBG1(DBG_LIST, "%d modules registered\n", ipp_mod_count); 2081 length = ipp_mod_count * sizeof (ipp_mod_id_t); 2082 if ((buf = kmem_alloc(length, KM_NOSLEEP)) == NULL) { 2083 rw_exit(ipp_mod_byname_lock); 2084 return (ENOMEM); 2085 } 2086 2087 rw_enter(ipp_mod_byid_lock, RW_READER); 2088 2089 /* 2090 * Search the array of all modules. 2091 */ 2092 2093 *bufp = buf; 2094 *neltp = ipp_mod_count; 2095 2096 for (mid = IPP_MOD_RESERVED + 1; mid <= ipp_mid_limit; mid++) { 2097 if ((imp = ipp_mod_byid[mid]) == NULL) 2098 continue; 2099 2100 /* 2101 * If the module has 'destruct pending' set then it means it 2102 * is either still in the cache (i.e not allocated) or in the 2103 * process of being set up by alloc_mod(). 2104 */ 2105 2106 LOCK_MOD(imp, RW_READER); 2107 ASSERT(imp->ippm_id == mid); 2108 2109 if (imp->ippm_destruct_pending) { 2110 UNLOCK_MOD(imp); 2111 continue; 2112 } 2113 UNLOCK_MOD(imp); 2114 2115 *buf++ = mid; 2116 } 2117 2118 rw_exit(ipp_mod_byid_lock); 2119 rw_exit(ipp_mod_byname_lock); 2120 2121 ASSERT((uintptr_t)buf == (uintptr_t)*bufp + length); 2122 return (0); 2123 } 2124 #undef __FN__ 2125 2126 #define __FN__ "find_mod" 2127 static ipp_mod_id_t 2128 find_mod( 2129 const char *modname) 2130 { 2131 ipp_mod_id_t mid; 2132 ipp_mod_t *imp; 2133 ipp_ref_t *rp; 2134 int hb; 2135 2136 ASSERT(modname != NULL); 2137 2138 rw_enter(ipp_mod_byname_lock, RW_READER); 2139 2140 /* 2141 * Quick return if no modules are registered. 2142 */ 2143 2144 if (ipp_mod_count == 0) { 2145 rw_exit(ipp_mod_byname_lock); 2146 return (IPP_MOD_INVAL); 2147 } 2148 2149 /* 2150 * Find the hash bucket where the module structure should be. 2151 */ 2152 2153 hb = hash(modname); 2154 rp = ipp_mod_byname[hb]; 2155 2156 /* 2157 * Scan the bucket for a match. 2158 */ 2159 2160 while (rp != NULL) { 2161 imp = rp->ippr_mod; 2162 if (strcmp(imp->ippm_name, modname) == 0) 2163 break; 2164 rp = rp->ippr_nextp; 2165 } 2166 2167 if (rp == NULL) { 2168 rw_exit(ipp_mod_byname_lock); 2169 return (IPP_MOD_INVAL); 2170 } 2171 2172 if (imp->ippm_state == IPP_MODSTATE_PROTO) { 2173 rw_exit(ipp_mod_byname_lock); 2174 return (IPP_MOD_INVAL); 2175 } 2176 2177 mid = imp->ippm_id; 2178 rw_exit(ipp_mod_byname_lock); 2179 2180 return (mid); 2181 } 2182 #undef __FN__ 2183 2184 #define __FN__ "alloc_mod" 2185 static int 2186 alloc_mod( 2187 const char *modname, 2188 ipp_mod_id_t *midp) 2189 { 2190 ipp_mod_t *imp; 2191 ipp_ref_t **rpp; 2192 ipp_ref_t *rp; 2193 int hb; 2194 2195 ASSERT(modname != NULL); 2196 ASSERT(midp != NULL); 2197 2198 rw_enter(ipp_mod_byname_lock, RW_WRITER); 2199 2200 /* 2201 * Find the right hash bucket for a module of the given name. 2202 */ 2203 2204 hb = hash(modname); 2205 rpp = &ipp_mod_byname[hb]; 2206 2207 /* 2208 * Scan the bucket making sure the module isn't already 2209 * registered. 2210 */ 2211 2212 while ((rp = *rpp) != NULL) { 2213 imp = rp->ippr_mod; 2214 if (strcmp(imp->ippm_name, modname) == 0) { 2215 DBG1(DBG_MOD, "module '%s' already exists\n", modname); 2216 rw_exit(ipp_mod_byname_lock); 2217 return (EEXIST); 2218 } 2219 rpp = &(rp->ippr_nextp); 2220 } 2221 2222 /* 2223 * Allocate a new reference structure and a new module structure. 2224 */ 2225 2226 if ((rp = kmem_zalloc(sizeof (ipp_ref_t), KM_NOSLEEP)) == NULL) { 2227 rw_exit(ipp_mod_byname_lock); 2228 return (ENOMEM); 2229 } 2230 2231 if ((imp = kmem_cache_alloc(ipp_mod_cache, KM_NOSLEEP)) == NULL) { 2232 kmem_free(rp, sizeof (ipp_ref_t)); 2233 rw_exit(ipp_mod_byname_lock); 2234 return (ENOMEM); 2235 } 2236 2237 /* 2238 * Set up the name of the new structure. 2239 */ 2240 2241 (void) strcpy(imp->ippm_name, modname); 2242 2243 /* 2244 * Make sure the 'destruct pending' flag is clear. This indicates 2245 * that the structure is no longer part of the cache. 2246 */ 2247 2248 LOCK_MOD(imp, RW_WRITER); 2249 imp->ippm_destruct_pending = B_FALSE; 2250 UNLOCK_MOD(imp); 2251 2252 /* 2253 * Set the reference and link it into the hash bucket. 2254 */ 2255 2256 rp->ippr_mod = imp; 2257 *rpp = rp; 2258 2259 /* 2260 * Increment the module count. 2261 */ 2262 2263 ipp_mod_count++; 2264 2265 *midp = imp->ippm_id; 2266 rw_exit(ipp_mod_byname_lock); 2267 return (0); 2268 } 2269 #undef __FN__ 2270 2271 #define __FN__ "free_mod" 2272 static void 2273 free_mod( 2274 ipp_mod_t *imp) 2275 { 2276 ipp_ref_t **rpp; 2277 ipp_ref_t *rp; 2278 int hb; 2279 2280 rw_enter(ipp_mod_byname_lock, RW_WRITER); 2281 2282 /* 2283 * Find the hash bucket where the module structure should be. 2284 */ 2285 2286 hb = hash(imp->ippm_name); 2287 rpp = &ipp_mod_byname[hb]; 2288 2289 /* 2290 * Scan the bucket for a match. 2291 */ 2292 2293 while ((rp = *rpp) != NULL) { 2294 if (rp->ippr_mod == imp) 2295 break; 2296 rpp = &(rp->ippr_nextp); 2297 } 2298 ASSERT(rp != NULL); 2299 2300 /* 2301 * Unlink the reference structure and free it. 2302 */ 2303 2304 *rpp = rp->ippr_nextp; 2305 kmem_free(rp, sizeof (ipp_ref_t)); 2306 2307 /* 2308 * Decrement the module count. 2309 */ 2310 2311 ipp_mod_count--; 2312 2313 /* 2314 * Empty the name. 2315 */ 2316 2317 *imp->ippm_name = '\0'; 2318 2319 /* 2320 * If the hold count is zero then we can free the structure 2321 * immediately, otherwise we defer to rele_mod(). 2322 */ 2323 2324 LOCK_MOD(imp, RW_WRITER); 2325 imp->ippm_destruct_pending = B_TRUE; 2326 if (imp->ippm_hold_count == 0) { 2327 UNLOCK_MOD(imp); 2328 kmem_cache_free(ipp_mod_cache, imp); 2329 rw_exit(ipp_mod_byname_lock); 2330 return; 2331 } 2332 UNLOCK_MOD(imp); 2333 2334 rw_exit(ipp_mod_byname_lock); 2335 } 2336 #undef __FN__ 2337 2338 #define __FN__ "hold_mod" 2339 static ipp_mod_t * 2340 hold_mod( 2341 ipp_mod_id_t mid) 2342 { 2343 ipp_mod_t *imp; 2344 2345 if (mid < 0) 2346 return (NULL); 2347 2348 /* 2349 * Use the module id as an index into the array of all module 2350 * structures. 2351 */ 2352 2353 rw_enter(ipp_mod_byid_lock, RW_READER); 2354 if ((imp = ipp_mod_byid[mid]) == NULL) { 2355 rw_exit(ipp_mod_byid_lock); 2356 return (NULL); 2357 } 2358 2359 ASSERT(imp->ippm_id == mid); 2360 2361 /* 2362 * If the modul has 'destruct pending' set then it means it is either 2363 * still in the cache (i.e not allocated) or in the process of 2364 * being set up by alloc_mod(). 2365 */ 2366 2367 LOCK_MOD(imp, RW_READER); 2368 if (imp->ippm_destruct_pending) { 2369 UNLOCK_MOD(imp); 2370 rw_exit(ipp_mod_byid_lock); 2371 return (NULL); 2372 } 2373 UNLOCK_MOD(imp); 2374 2375 /* 2376 * Increment the hold count to prevent the structure from being 2377 * freed. 2378 */ 2379 2380 atomic_inc_32(&(imp->ippm_hold_count)); 2381 rw_exit(ipp_mod_byid_lock); 2382 2383 return (imp); 2384 } 2385 #undef __FN__ 2386 2387 #define __FN__ "rele_mod" 2388 static void 2389 rele_mod( 2390 ipp_mod_t *imp) 2391 { 2392 /* 2393 * This call means we're done with the pointer so we can drop the 2394 * hold count. 2395 */ 2396 2397 ASSERT(imp->ippm_hold_count != 0); 2398 atomic_dec_32(&(imp->ippm_hold_count)); 2399 2400 /* 2401 * If the structure has 'destruct pending' set then we tried to free 2402 * it but couldn't, so do it now. 2403 */ 2404 2405 LOCK_MOD(imp, RW_READER); 2406 if (imp->ippm_destruct_pending && imp->ippm_hold_count == 0) { 2407 UNLOCK_MOD(imp); 2408 kmem_cache_free(ipp_mod_cache, imp); 2409 return; 2410 } 2411 2412 UNLOCK_MOD(imp); 2413 } 2414 #undef __FN__ 2415 2416 #define __FN__ "get_mid" 2417 static ipp_mod_id_t 2418 get_mid( 2419 void) 2420 { 2421 int index; 2422 int start; 2423 int limit; 2424 2425 ASSERT(rw_write_held(ipp_mod_byid_lock)); 2426 2427 /* 2428 * Start searching after the last module id we allocated. 2429 */ 2430 2431 start = (int)ipp_next_mid; 2432 limit = (int)ipp_mid_limit; 2433 2434 /* 2435 * Look for a spare slot in the array. 2436 */ 2437 2438 index = start; 2439 while (ipp_mod_byid[index] != NULL) { 2440 index++; 2441 if (index > limit) 2442 index = IPP_MOD_RESERVED + 1; 2443 if (index == start) 2444 return (IPP_MOD_INVAL); 2445 } 2446 2447 /* 2448 * Note that we've just allocated a new module id so that we can 2449 * start our search there next time. 2450 */ 2451 2452 index++; 2453 if (index > limit) { 2454 ipp_next_mid = IPP_MOD_RESERVED + 1; 2455 } else 2456 ipp_next_mid = (ipp_mod_id_t)index; 2457 2458 return ((ipp_mod_id_t)(--index)); 2459 } 2460 #undef __FN__ 2461 2462 #define __FN__ "condemn_action" 2463 static int 2464 condemn_action( 2465 ipp_ref_t **rpp, 2466 ipp_action_t *ap) 2467 { 2468 ipp_ref_t *rp; 2469 2470 DBG1(DBG_ACTION, "condemning action '%s'\n", ap->ippa_name); 2471 2472 /* 2473 * Check to see if the action is already condemned. 2474 */ 2475 2476 while ((rp = *rpp) != NULL) { 2477 if (rp->ippr_action == ap) 2478 break; 2479 rpp = &(rp->ippr_nextp); 2480 } 2481 2482 /* 2483 * Create a new entry for the action. 2484 */ 2485 2486 if (rp == NULL) { 2487 if ((rp = kmem_zalloc(sizeof (ipp_ref_t), KM_NOSLEEP)) == NULL) 2488 return (ENOMEM); 2489 2490 rp->ippr_action = ap; 2491 *rpp = rp; 2492 } 2493 2494 return (0); 2495 } 2496 #undef __FN__ 2497 2498 #define __FN__ "destroy_action" 2499 static int 2500 destroy_action( 2501 ipp_action_t *ap, 2502 ipp_flags_t flags) 2503 { 2504 ipp_ops_t *ippo; 2505 ipp_mod_t *imp; 2506 #define MAXWAIT 10 2507 uint32_t wait; 2508 int rc; 2509 2510 /* 2511 * Check that the action is available. 2512 */ 2513 2514 LOCK_ACTION(ap, RW_WRITER); 2515 if (ap->ippa_state != IPP_ASTATE_AVAILABLE) { 2516 UNLOCK_ACTION(ap); 2517 rele_action(ap); 2518 return (EPROTO); 2519 } 2520 2521 /* 2522 * Note that the action is in the process of creation/destruction. 2523 */ 2524 2525 ap->ippa_state = IPP_ASTATE_CONFIG_PENDING; 2526 2527 /* 2528 * Wait for the in-transit packet count for this action to fall to 2529 * zero (checking at millisecond intervals). 2530 * 2531 * NOTE: no new packets will enter the action now that the 2532 * state has been changed. 2533 */ 2534 2535 for (wait = 0; ap->ippa_packets > 0 && wait < (MAXWAIT * 1000000); 2536 wait += 1000) { 2537 2538 /* 2539 * NOTE: We can hang onto the lock because the packet count is 2540 * decremented without needing to take the lock. 2541 */ 2542 2543 drv_usecwait(1000); 2544 } 2545 2546 /* 2547 * The packet count did not fall to zero. 2548 */ 2549 if (ap->ippa_packets > 0) { 2550 ap->ippa_state = IPP_ASTATE_AVAILABLE; 2551 UNLOCK_ACTION(ap); 2552 rele_action(ap); 2553 return (EAGAIN); 2554 } 2555 2556 /* 2557 * Check to see if any other action has a dependency on this one. 2558 */ 2559 2560 if (is_action_refd(ap)) { 2561 ap->ippa_state = IPP_ASTATE_AVAILABLE; 2562 UNLOCK_ACTION(ap); 2563 rele_action(ap); 2564 return (EBUSY); 2565 } 2566 2567 imp = ap->ippa_mod; 2568 ASSERT(imp != NULL); 2569 UNLOCK_ACTION(ap); 2570 2571 ippo = imp->ippm_ops; 2572 ASSERT(ippo != NULL); 2573 2574 /* 2575 * Call into the module to destroy the action context. 2576 */ 2577 2578 CONFIG_WRITE_START(ap); 2579 DBG1(DBG_ACTION, "destroying action '%s'\n", ap->ippa_name); 2580 if ((rc = ippo->ippo_action_destroy(ap->ippa_id, flags)) != 0) { 2581 LOCK_ACTION(ap, RW_WRITER); 2582 ap->ippa_state = IPP_ASTATE_AVAILABLE; 2583 UNLOCK_ACTION(ap); 2584 2585 CONFIG_WRITE_END(ap); 2586 2587 rele_action(ap); 2588 return (rc); 2589 } 2590 CONFIG_WRITE_END(ap); 2591 2592 LOCK_ACTION(ap, RW_WRITER); 2593 LOCK_MOD(imp, RW_WRITER); 2594 unref_mod(ap, imp); 2595 UNLOCK_MOD(imp); 2596 ap->ippa_state = IPP_ASTATE_PROTO; 2597 UNLOCK_ACTION(ap); 2598 2599 /* 2600 * Free the action structure. 2601 */ 2602 2603 ASSERT(ap->ippa_ref == NULL); 2604 free_action(ap); 2605 rele_action(ap); 2606 return (0); 2607 #undef MAXWAIT 2608 } 2609 #undef __FN__ 2610 2611 #define __FN__ "ref_action" 2612 static int 2613 ref_action( 2614 ipp_action_t *refby_ap, 2615 ipp_action_t *ref_ap) 2616 { 2617 ipp_ref_t **rpp; 2618 ipp_ref_t **save_rpp; 2619 ipp_ref_t *rp; 2620 2621 ASSERT(rw_write_held(refby_ap->ippa_lock)); 2622 ASSERT(rw_write_held(ref_ap->ippa_lock)); 2623 2624 /* 2625 * We want to add the new reference at the end of the refering 2626 * action's list. 2627 */ 2628 2629 rpp = &(refby_ap->ippa_ref); 2630 while ((rp = *rpp) != NULL) { 2631 if (rp->ippr_action == ref_ap) 2632 break; 2633 rpp = &(rp->ippr_nextp); 2634 } 2635 2636 if ((rp = *rpp) != NULL) { 2637 2638 /* 2639 * There is an existing reference so increment its counter. 2640 */ 2641 2642 rp->ippr_count++; 2643 2644 /* 2645 * Find the 'back pointer' and increment its counter too. 2646 */ 2647 2648 rp = ref_ap->ippa_refby; 2649 while (rp != NULL) { 2650 if (rp->ippr_action == refby_ap) 2651 break; 2652 rp = rp->ippr_nextp; 2653 } 2654 ASSERT(rp != NULL); 2655 2656 rp->ippr_count++; 2657 } else { 2658 2659 /* 2660 * Allocate, fill in and link a new reference structure. 2661 */ 2662 2663 if ((rp = kmem_zalloc(sizeof (ipp_ref_t), KM_NOSLEEP)) == NULL) 2664 return (ENOMEM); 2665 2666 rp->ippr_action = ref_ap; 2667 rp->ippr_count = 1; 2668 *rpp = rp; 2669 save_rpp = rpp; 2670 2671 /* 2672 * We keep a 'back pointer' which we want to add at the end of 2673 * a list in the referred action's structure. 2674 */ 2675 2676 rpp = &(ref_ap->ippa_refby); 2677 while ((rp = *rpp) != NULL) { 2678 ASSERT(rp->ippr_action != refby_ap); 2679 rpp = &(rp->ippr_nextp); 2680 } 2681 2682 /* 2683 * Allocate another reference structure and, if this fails, 2684 * remember to clean up the first reference structure we 2685 * allocated. 2686 */ 2687 2688 if ((rp = kmem_zalloc(sizeof (ipp_ref_t), 2689 KM_NOSLEEP)) == NULL) { 2690 rpp = save_rpp; 2691 rp = *rpp; 2692 *rpp = NULL; 2693 kmem_free(rp, sizeof (ipp_ref_t)); 2694 2695 return (ENOMEM); 2696 } 2697 2698 /* 2699 * Fill in the reference structure with the 'back pointer' and 2700 * link it into the list. 2701 */ 2702 2703 rp->ippr_action = refby_ap; 2704 rp->ippr_count = 1; 2705 *rpp = rp; 2706 } 2707 2708 return (0); 2709 } 2710 #undef __FN__ 2711 2712 #define __FN__ "unref_action" 2713 static int 2714 unref_action( 2715 ipp_action_t *refby_ap, 2716 ipp_action_t *ref_ap) 2717 { 2718 ipp_ref_t **rpp; 2719 ipp_ref_t *rp; 2720 2721 ASSERT(rw_write_held(refby_ap->ippa_lock)); 2722 ASSERT(rw_write_held(ref_ap->ippa_lock)); 2723 2724 /* 2725 * Scan for the reference in the referring action's list. 2726 */ 2727 2728 rpp = &(refby_ap->ippa_ref); 2729 while ((rp = *rpp) != NULL) { 2730 if (rp->ippr_action == ref_ap) 2731 break; 2732 rpp = &(rp->ippr_nextp); 2733 } 2734 2735 if (rp == NULL) 2736 return (ENOENT); 2737 2738 if (rp->ippr_count > 1) { 2739 2740 /* 2741 * There are currently multiple references so decrement the 2742 * count. 2743 */ 2744 2745 rp->ippr_count--; 2746 2747 /* 2748 * Find the 'back pointer' and decrement its counter too. 2749 */ 2750 2751 rp = ref_ap->ippa_refby; 2752 while (rp != NULL) { 2753 if (rp->ippr_action == refby_ap) 2754 break; 2755 rp = rp->ippr_nextp; 2756 } 2757 ASSERT(rp != NULL); 2758 2759 rp->ippr_count--; 2760 } else { 2761 2762 /* 2763 * There is currently only a single reference, so unlink and 2764 * free the reference structure. 2765 */ 2766 2767 *rpp = rp->ippr_nextp; 2768 kmem_free(rp, sizeof (ipp_ref_t)); 2769 2770 /* 2771 * Scan for the 'back pointer' in the referred action's list. 2772 */ 2773 2774 rpp = &(ref_ap->ippa_refby); 2775 while ((rp = *rpp) != NULL) { 2776 if (rp->ippr_action == refby_ap) 2777 break; 2778 rpp = &(rp->ippr_nextp); 2779 } 2780 ASSERT(rp != NULL); 2781 2782 /* 2783 * Unlink and free this reference structure too. 2784 */ 2785 2786 *rpp = rp->ippr_nextp; 2787 kmem_free(rp, sizeof (ipp_ref_t)); 2788 } 2789 2790 return (0); 2791 } 2792 #undef __FN__ 2793 2794 #define __FN__ "is_action_refd" 2795 static int 2796 is_action_refd( 2797 ipp_action_t *ap) 2798 { 2799 /* 2800 * Return a value which is true (non-zero) iff the action is not 2801 * referred to by any other actions. 2802 */ 2803 2804 return (ap->ippa_refby != NULL); 2805 } 2806 #undef __FN__ 2807 2808 #define __FN__ "find_action" 2809 static ipp_action_id_t 2810 find_action( 2811 const char *aname) 2812 { 2813 ipp_action_id_t aid; 2814 ipp_action_t *ap; 2815 ipp_ref_t *rp; 2816 int hb; 2817 2818 ASSERT(aname != NULL); 2819 2820 rw_enter(ipp_action_byname_lock, RW_READER); 2821 2822 /* 2823 * Quick return if there are no actions defined at all. 2824 */ 2825 2826 if (ipp_action_count == 0) { 2827 rw_exit(ipp_action_byname_lock); 2828 return (IPP_ACTION_INVAL); 2829 } 2830 2831 /* 2832 * Find the hash bucket where the action structure should be. 2833 */ 2834 2835 hb = hash(aname); 2836 rp = ipp_action_byname[hb]; 2837 2838 /* 2839 * Scan the bucket looking for a match. 2840 */ 2841 2842 while (rp != NULL) { 2843 ap = rp->ippr_action; 2844 if (strcmp(ap->ippa_name, aname) == 0) 2845 break; 2846 rp = rp->ippr_nextp; 2847 } 2848 2849 if (rp == NULL) { 2850 rw_exit(ipp_action_byname_lock); 2851 return (IPP_ACTION_INVAL); 2852 } 2853 2854 if (ap->ippa_state == IPP_ASTATE_PROTO) { 2855 rw_exit(ipp_action_byname_lock); 2856 return (IPP_ACTION_INVAL); 2857 } 2858 2859 aid = ap->ippa_id; 2860 rw_exit(ipp_action_byname_lock); 2861 2862 return (aid); 2863 } 2864 #undef __FN__ 2865 2866 #define __FN__ "alloc_action" 2867 static int 2868 alloc_action( 2869 const char *aname, 2870 ipp_action_id_t *aidp) 2871 { 2872 ipp_action_t *ap; 2873 ipp_ref_t **rpp; 2874 ipp_ref_t *rp; 2875 int hb; 2876 2877 ASSERT(aidp != NULL); 2878 2879 rw_enter(ipp_action_byname_lock, RW_WRITER); 2880 2881 /* 2882 * Find the right hash bucket for an action of the given name. 2883 * (Nameless actions always go in a special bucket). 2884 */ 2885 2886 if (aname != NULL) { 2887 hb = hash(aname); 2888 rpp = &ipp_action_byname[hb]; 2889 } else 2890 rpp = &ipp_action_noname; 2891 2892 /* 2893 * Scan the bucket to make sure that an action with the given name 2894 * does not already exist. 2895 */ 2896 2897 while ((rp = *rpp) != NULL) { 2898 ap = rp->ippr_action; 2899 if (aname != NULL && strcmp(ap->ippa_name, aname) == 0) { 2900 DBG1(DBG_ACTION, "action '%s' already exists\n", 2901 aname); 2902 rw_exit(ipp_action_byname_lock); 2903 return (EEXIST); 2904 } 2905 rpp = &(rp->ippr_nextp); 2906 } 2907 2908 /* 2909 * Allocate a new reference structure and a new action structure. 2910 */ 2911 2912 if ((rp = kmem_zalloc(sizeof (ipp_ref_t), KM_NOSLEEP)) == NULL) { 2913 rw_exit(ipp_action_byname_lock); 2914 return (ENOMEM); 2915 } 2916 2917 if ((ap = kmem_cache_alloc(ipp_action_cache, KM_NOSLEEP)) == NULL) { 2918 kmem_free(rp, sizeof (ipp_ref_t)); 2919 rw_exit(ipp_action_byname_lock); 2920 return (ENOMEM); 2921 } 2922 2923 /* 2924 * Dream up a name if there isn't a real one and note that the action is 2925 * really nameless. 2926 */ 2927 2928 if (aname == NULL) { 2929 (void) sprintf(ap->ippa_name, "$%08X", ap->ippa_id); 2930 ap->ippa_nameless = B_TRUE; 2931 } else 2932 (void) strcpy(ap->ippa_name, aname); 2933 2934 /* 2935 * Make sure the 'destruct pending' flag is clear. This indicates that 2936 * the structure is no longer part of the cache. 2937 */ 2938 2939 LOCK_ACTION(ap, RW_WRITER); 2940 ap->ippa_destruct_pending = B_FALSE; 2941 UNLOCK_ACTION(ap); 2942 2943 /* 2944 * Fill in the reference structure and lint it onto the list. 2945 */ 2946 2947 rp->ippr_action = ap; 2948 *rpp = rp; 2949 2950 /* 2951 * Increment the action count. 2952 */ 2953 2954 ipp_action_count++; 2955 2956 *aidp = ap->ippa_id; 2957 rw_exit(ipp_action_byname_lock); 2958 return (0); 2959 } 2960 #undef __FN__ 2961 2962 #define __FN__ "free_action" 2963 static void 2964 free_action( 2965 ipp_action_t *ap) 2966 { 2967 ipp_ref_t **rpp; 2968 ipp_ref_t *rp; 2969 int hb; 2970 2971 rw_enter(ipp_action_byname_lock, RW_WRITER); 2972 2973 /* 2974 * Find the hash bucket where the action structure should be. 2975 */ 2976 2977 if (!ap->ippa_nameless) { 2978 hb = hash(ap->ippa_name); 2979 rpp = &ipp_action_byname[hb]; 2980 } else 2981 rpp = &ipp_action_noname; 2982 2983 /* 2984 * Scan the bucket for a match. 2985 */ 2986 2987 while ((rp = *rpp) != NULL) { 2988 if (rp->ippr_action == ap) 2989 break; 2990 rpp = &(rp->ippr_nextp); 2991 } 2992 ASSERT(rp != NULL); 2993 2994 /* 2995 * Unlink and free the reference structure. 2996 */ 2997 2998 *rpp = rp->ippr_nextp; 2999 kmem_free(rp, sizeof (ipp_ref_t)); 3000 3001 /* 3002 * Decrement the action count. 3003 */ 3004 3005 ipp_action_count--; 3006 3007 /* 3008 * Empty the name. 3009 */ 3010 3011 *ap->ippa_name = '\0'; 3012 3013 /* 3014 * If the hold count is zero then we can free the structure 3015 * immediately, otherwise we defer to rele_action(). 3016 */ 3017 3018 LOCK_ACTION(ap, RW_WRITER); 3019 ap->ippa_destruct_pending = B_TRUE; 3020 if (ap->ippa_hold_count == 0) { 3021 UNLOCK_ACTION(ap); 3022 kmem_cache_free(ipp_action_cache, ap); 3023 rw_exit(ipp_action_byname_lock); 3024 return; 3025 } 3026 UNLOCK_ACTION(ap); 3027 3028 rw_exit(ipp_action_byname_lock); 3029 } 3030 #undef __FN__ 3031 3032 #define __FN__ "hold_action" 3033 static ipp_action_t * 3034 hold_action( 3035 ipp_action_id_t aid) 3036 { 3037 ipp_action_t *ap; 3038 3039 if (aid < 0) 3040 return (NULL); 3041 3042 /* 3043 * Use the action id as an index into the array of all action 3044 * structures. 3045 */ 3046 3047 rw_enter(ipp_action_byid_lock, RW_READER); 3048 if ((ap = ipp_action_byid[aid]) == NULL) { 3049 rw_exit(ipp_action_byid_lock); 3050 return (NULL); 3051 } 3052 3053 /* 3054 * If the action has 'destruct pending' set then it means it is either 3055 * still in the cache (i.e not allocated) or in the process of 3056 * being set up by alloc_action(). 3057 */ 3058 3059 LOCK_ACTION(ap, RW_READER); 3060 if (ap->ippa_destruct_pending) { 3061 UNLOCK_ACTION(ap); 3062 rw_exit(ipp_action_byid_lock); 3063 return (NULL); 3064 } 3065 UNLOCK_ACTION(ap); 3066 3067 /* 3068 * Increment the hold count to prevent the structure from being 3069 * freed. 3070 */ 3071 3072 atomic_inc_32(&(ap->ippa_hold_count)); 3073 rw_exit(ipp_action_byid_lock); 3074 3075 return (ap); 3076 } 3077 #undef __FN__ 3078 3079 #define __FN__ "rele_action" 3080 static void 3081 rele_action( 3082 ipp_action_t *ap) 3083 { 3084 /* 3085 * This call means we're done with the pointer so we can drop the 3086 * hold count. 3087 */ 3088 3089 ASSERT(ap->ippa_hold_count != 0); 3090 atomic_dec_32(&(ap->ippa_hold_count)); 3091 3092 /* 3093 * If the structure has 'destruct pending' set then we tried to free 3094 * it but couldn't, so do it now. 3095 */ 3096 3097 LOCK_ACTION(ap, RW_READER); 3098 if (ap->ippa_destruct_pending && ap->ippa_hold_count == 0) { 3099 UNLOCK_ACTION(ap); 3100 kmem_cache_free(ipp_action_cache, ap); 3101 return; 3102 } 3103 UNLOCK_ACTION(ap); 3104 } 3105 #undef __FN__ 3106 3107 #define __FN__ "get_aid" 3108 static ipp_action_id_t 3109 get_aid( 3110 void) 3111 { 3112 int index; 3113 int start; 3114 int limit; 3115 3116 ASSERT(rw_write_held(ipp_action_byid_lock)); 3117 3118 /* 3119 * Start searching after the last action id that we allocated. 3120 */ 3121 3122 start = (int)ipp_next_aid; 3123 limit = (int)ipp_aid_limit; 3124 3125 /* 3126 * Look for a spare slot in the array. 3127 */ 3128 3129 index = start; 3130 while (ipp_action_byid[index] != NULL) { 3131 index++; 3132 if (index > limit) 3133 index = IPP_ACTION_RESERVED + 1; 3134 if (index == start) 3135 return (IPP_ACTION_INVAL); 3136 } 3137 3138 /* 3139 * Note that we've just allocated a new action id so that we can 3140 * start our search there next time. 3141 */ 3142 3143 index++; 3144 if (index > limit) 3145 ipp_next_aid = IPP_ACTION_RESERVED + 1; 3146 else 3147 ipp_next_aid = (ipp_action_id_t)index; 3148 3149 return ((ipp_action_id_t)(--index)); 3150 } 3151 #undef __FN__ 3152 3153 #define __FN__ "alloc_packet" 3154 static int 3155 alloc_packet( 3156 const char *name, 3157 ipp_action_id_t aid, 3158 ipp_packet_t **ppp) 3159 { 3160 ipp_packet_t *pp; 3161 ipp_class_t *cp; 3162 3163 if ((pp = kmem_cache_alloc(ipp_packet_cache, KM_NOSLEEP)) == NULL) 3164 return (ENOMEM); 3165 3166 /* 3167 * Set the packet up with a single class. 3168 */ 3169 3170 cp = &(pp->ippp_class_array[0]); 3171 pp->ippp_class_windex = 1; 3172 3173 (void) strcpy(cp->ippc_name, name); 3174 cp->ippc_aid = aid; 3175 3176 *ppp = pp; 3177 return (0); 3178 } 3179 #undef __FN__ 3180 3181 #define __FN__ "realloc_packet" 3182 static int 3183 realloc_packet( 3184 ipp_packet_t *pp) 3185 { 3186 uint_t length; 3187 ipp_class_t *array; 3188 3189 length = (pp->ippp_class_limit + 1) << 1; 3190 if ((array = kmem_alloc(length * sizeof (ipp_class_t), 3191 KM_NOSLEEP)) == NULL) 3192 return (ENOMEM); 3193 3194 bcopy(pp->ippp_class_array, array, 3195 (length >> 1) * sizeof (ipp_class_t)); 3196 3197 kmem_free(pp->ippp_class_array, 3198 (length >> 1) * sizeof (ipp_class_t)); 3199 3200 pp->ippp_class_array = array; 3201 pp->ippp_class_limit = length - 1; 3202 3203 return (0); 3204 } 3205 #undef __FN__ 3206 3207 #define __FN__ "free_packet" 3208 static void 3209 free_packet( 3210 ipp_packet_t *pp) 3211 { 3212 pp->ippp_class_windex = 0; 3213 pp->ippp_class_rindex = 0; 3214 3215 pp->ippp_data = NULL; 3216 pp->ippp_private = NULL; 3217 3218 kmem_cache_free(ipp_packet_cache, pp); 3219 } 3220 #undef __FN__ 3221 3222 #define __FN__ "hash" 3223 static int 3224 hash( 3225 const char *name) 3226 { 3227 int val = 0; 3228 char *ptr; 3229 3230 /* 3231 * Make a hash value by XORing all the ascii codes in the text string. 3232 */ 3233 3234 for (ptr = (char *)name; *ptr != NULL; ptr++) { 3235 val ^= *ptr; 3236 } 3237 3238 /* 3239 * Return the value modulo the number of hash buckets we allow. 3240 */ 3241 3242 return (val % IPP_NBUCKET); 3243 } 3244 #undef __FN__ 3245 3246 #define __FN__ "update_stats" 3247 static int 3248 update_stats( 3249 kstat_t *ksp, 3250 int rw) 3251 { 3252 ipp_stat_impl_t *sip; 3253 3254 ASSERT(ksp->ks_private != NULL); 3255 sip = (ipp_stat_impl_t *)ksp->ks_private; 3256 3257 /* 3258 * Call the update function passed to ipp_stat_create() for the given 3259 * set of kstats. 3260 */ 3261 3262 return (sip->ippsi_update((ipp_stat_t *)sip, sip->ippsi_arg, rw)); 3263 } 3264 #undef __FN__ 3265 3266 #define __FN__ "init_mods" 3267 static void 3268 init_mods( 3269 void) 3270 { 3271 /* 3272 * Initialise the array of all module structures and the module 3273 * structure kmem cache. 3274 */ 3275 3276 rw_init(ipp_mod_byid_lock, NULL, RW_DEFAULT, 3277 (void *)ipltospl(LOCK_LEVEL)); 3278 ipp_mod_byid = kmem_zalloc(sizeof (ipp_mod_t *) * (ipp_max_mod + 1), 3279 KM_SLEEP); 3280 ipp_mod_byid[ipp_max_mod] = (ipp_mod_t *)-1; 3281 ipp_mid_limit = (ipp_mod_id_t)(ipp_max_mod - 1); 3282 3283 ipp_mod_cache = kmem_cache_create("ipp_mod", sizeof (ipp_mod_t), 3284 IPP_ALIGN, mod_constructor, mod_destructor, NULL, NULL, NULL, 0); 3285 ASSERT(ipp_mod_cache != NULL); 3286 3287 /* 3288 * Initialize the 'module by name' hash bucket array. 3289 */ 3290 3291 rw_init(ipp_mod_byname_lock, NULL, RW_DEFAULT, 3292 (void *)ipltospl(LOCK_LEVEL)); 3293 bzero(ipp_mod_byname, IPP_NBUCKET * sizeof (ipp_ref_t *)); 3294 } 3295 #undef __FN__ 3296 3297 #define __FN__ "init_actions" 3298 static void 3299 init_actions( 3300 void) 3301 { 3302 /* 3303 * Initialise the array of all action structures and the action 3304 * structure cache. 3305 */ 3306 3307 rw_init(ipp_action_byid_lock, NULL, RW_DEFAULT, 3308 (void *)ipltospl(LOCK_LEVEL)); 3309 ipp_action_byid = kmem_zalloc(sizeof (ipp_action_t *) * 3310 (ipp_max_action + 1), KM_SLEEP); 3311 ipp_action_byid[ipp_max_action] = (ipp_action_t *)-1; 3312 ipp_aid_limit = (ipp_action_id_t)(ipp_max_action - 1); 3313 3314 ipp_action_cache = kmem_cache_create("ipp_action", 3315 sizeof (ipp_action_t), IPP_ALIGN, action_constructor, 3316 action_destructor, NULL, NULL, NULL, 0); 3317 ASSERT(ipp_action_cache != NULL); 3318 3319 /* 3320 * Initialize the 'action by name' hash bucket array (and the special 3321 * 'hash' bucket for nameless actions). 3322 */ 3323 3324 rw_init(ipp_action_byname_lock, NULL, RW_DEFAULT, 3325 (void *)ipltospl(LOCK_LEVEL)); 3326 bzero(ipp_action_byname, IPP_NBUCKET * sizeof (ipp_ref_t *)); 3327 ipp_action_noname = NULL; 3328 } 3329 #undef __FN__ 3330 3331 #define __FN__ "init_packets" 3332 static void 3333 init_packets( 3334 void) 3335 { 3336 /* 3337 * Initialise the packet structure cache. 3338 */ 3339 3340 ipp_packet_cache = kmem_cache_create("ipp_packet", 3341 sizeof (ipp_packet_t), IPP_ALIGN, packet_constructor, 3342 packet_destructor, NULL, NULL, NULL, 0); 3343 ASSERT(ipp_packet_cache != NULL); 3344 } 3345 #undef __FN__ 3346 3347 /* 3348 * Kmem cache constructor/destructor functions. 3349 */ 3350 3351 #define __FN__ "mod_constructor" 3352 /*ARGSUSED*/ 3353 static int 3354 mod_constructor( 3355 void *buf, 3356 void *cdrarg, 3357 int kmflags) 3358 { 3359 ipp_mod_t *imp; 3360 ipp_mod_id_t mid; 3361 3362 ASSERT(buf != NULL); 3363 bzero(buf, sizeof (ipp_mod_t)); 3364 imp = (ipp_mod_t *)buf; 3365 3366 rw_enter(ipp_mod_byid_lock, RW_WRITER); 3367 3368 /* 3369 * Get a new module id. 3370 */ 3371 3372 if ((mid = get_mid()) <= IPP_MOD_RESERVED) { 3373 rw_exit(ipp_mod_byid_lock); 3374 return (-1); 3375 } 3376 3377 /* 3378 * Initialize the buffer as a module structure in PROTO form. 3379 */ 3380 3381 imp->ippm_destruct_pending = B_TRUE; 3382 imp->ippm_state = IPP_MODSTATE_PROTO; 3383 rw_init(imp->ippm_lock, NULL, RW_DEFAULT, 3384 (void *)ipltospl(LOCK_LEVEL)); 3385 3386 /* 3387 * Insert it into the array of all module structures. 3388 */ 3389 3390 imp->ippm_id = mid; 3391 ipp_mod_byid[mid] = imp; 3392 3393 rw_exit(ipp_mod_byid_lock); 3394 3395 return (0); 3396 } 3397 #undef __FN__ 3398 3399 #define __FN__ "mod_destructor" 3400 /*ARGSUSED*/ 3401 static void 3402 mod_destructor( 3403 void *buf, 3404 void *cdrarg) 3405 { 3406 ipp_mod_t *imp; 3407 3408 ASSERT(buf != NULL); 3409 imp = (ipp_mod_t *)buf; 3410 3411 ASSERT(imp->ippm_state == IPP_MODSTATE_PROTO); 3412 ASSERT(imp->ippm_action == NULL); 3413 ASSERT(*imp->ippm_name == '\0'); 3414 ASSERT(imp->ippm_destruct_pending); 3415 3416 rw_enter(ipp_mod_byid_lock, RW_WRITER); 3417 ASSERT(imp->ippm_hold_count == 0); 3418 3419 /* 3420 * NULL the entry in the array of all module structures. 3421 */ 3422 3423 ipp_mod_byid[imp->ippm_id] = NULL; 3424 3425 /* 3426 * Clean up any remnants of the module structure as the buffer is 3427 * about to disappear. 3428 */ 3429 3430 rw_destroy(imp->ippm_lock); 3431 rw_exit(ipp_mod_byid_lock); 3432 } 3433 #undef __FN__ 3434 3435 #define __FN__ "action_constructor" 3436 /*ARGSUSED*/ 3437 static int 3438 action_constructor( 3439 void *buf, 3440 void *cdrarg, 3441 int kmflags) 3442 { 3443 ipp_action_t *ap; 3444 ipp_action_id_t aid; 3445 3446 ASSERT(buf != NULL); 3447 bzero(buf, sizeof (ipp_action_t)); 3448 ap = (ipp_action_t *)buf; 3449 3450 rw_enter(ipp_action_byid_lock, RW_WRITER); 3451 3452 /* 3453 * Get a new action id. 3454 */ 3455 3456 if ((aid = get_aid()) <= IPP_ACTION_RESERVED) { 3457 rw_exit(ipp_action_byid_lock); 3458 return (-1); 3459 } 3460 3461 /* 3462 * Initialize the buffer as an action structure in PROTO form. 3463 */ 3464 3465 ap->ippa_state = IPP_ASTATE_PROTO; 3466 ap->ippa_destruct_pending = B_TRUE; 3467 rw_init(ap->ippa_lock, NULL, RW_DEFAULT, 3468 (void *)ipltospl(LOCK_LEVEL)); 3469 CONFIG_LOCK_INIT(ap->ippa_config_lock); 3470 3471 /* 3472 * Insert it into the array of all action structures. 3473 */ 3474 3475 ap->ippa_id = aid; 3476 ipp_action_byid[aid] = ap; 3477 3478 rw_exit(ipp_action_byid_lock); 3479 return (0); 3480 } 3481 #undef __FN__ 3482 3483 #define __FN__ "action_destructor" 3484 /*ARGSUSED*/ 3485 static void 3486 action_destructor( 3487 void *buf, 3488 void *cdrarg) 3489 { 3490 ipp_action_t *ap; 3491 3492 ASSERT(buf != NULL); 3493 ap = (ipp_action_t *)buf; 3494 3495 ASSERT(ap->ippa_state == IPP_ASTATE_PROTO); 3496 ASSERT(ap->ippa_ref == NULL); 3497 ASSERT(ap->ippa_refby == NULL); 3498 ASSERT(ap->ippa_packets == 0); 3499 ASSERT(*ap->ippa_name == '\0'); 3500 ASSERT(ap->ippa_destruct_pending); 3501 3502 rw_enter(ipp_action_byid_lock, RW_WRITER); 3503 ASSERT(ap->ippa_hold_count == 0); 3504 3505 /* 3506 * NULL the entry in the array of all action structures. 3507 */ 3508 3509 ipp_action_byid[ap->ippa_id] = NULL; 3510 3511 /* 3512 * Clean up any remnants of the action structure as the buffer is 3513 * about to disappear. 3514 */ 3515 3516 CONFIG_LOCK_FINI(ap->ippa_config_lock); 3517 rw_destroy(ap->ippa_lock); 3518 3519 rw_exit(ipp_action_byid_lock); 3520 } 3521 #undef __FN__ 3522 3523 #define __FN__ "packet_constructor" 3524 /*ARGSUSED*/ 3525 static int 3526 packet_constructor( 3527 void *buf, 3528 void *cdrarg, 3529 int kmflags) 3530 { 3531 ipp_packet_t *pp; 3532 ipp_class_t *cp; 3533 3534 ASSERT(buf != NULL); 3535 bzero(buf, sizeof (ipp_packet_t)); 3536 pp = (ipp_packet_t *)buf; 3537 3538 if ((cp = kmem_alloc(ipp_packet_classes * sizeof (ipp_class_t), 3539 KM_NOSLEEP)) == NULL) 3540 return (ENOMEM); 3541 3542 pp->ippp_class_array = cp; 3543 pp->ippp_class_windex = 0; 3544 pp->ippp_class_rindex = 0; 3545 pp->ippp_class_limit = ipp_packet_classes - 1; 3546 3547 return (0); 3548 } 3549 #undef __FN__ 3550 3551 #define __FN__ "packet_destructor" 3552 /*ARGSUSED*/ 3553 static void 3554 packet_destructor( 3555 void *buf, 3556 void *cdrarg) 3557 { 3558 ipp_packet_t *pp; 3559 3560 ASSERT(buf != NULL); 3561 pp = (ipp_packet_t *)buf; 3562 3563 ASSERT(pp->ippp_data == NULL); 3564 ASSERT(pp->ippp_class_windex == 0); 3565 ASSERT(pp->ippp_class_rindex == 0); 3566 ASSERT(pp->ippp_private == NULL); 3567 ASSERT(pp->ippp_private_free == NULL); 3568 3569 kmem_free(pp->ippp_class_array, 3570 (pp->ippp_class_limit + 1) * sizeof (ipp_class_t)); 3571 3572 if (pp->ippp_log != NULL) { 3573 kmem_free(pp->ippp_log, 3574 (pp->ippp_log_limit + 1) * sizeof (ipp_log_t)); 3575 } 3576 } 3577 #undef __FN__ 3578 3579 /* 3580 * Debug message printout code. 3581 */ 3582 3583 #ifdef IPP_DBG 3584 static void 3585 ipp_debug( 3586 uint64_t type, 3587 const char *fn, 3588 char *fmt, 3589 ...) 3590 { 3591 char buf[255]; 3592 va_list adx; 3593 3594 if ((type & ipp_debug_flags) == 0) 3595 return; 3596 3597 mutex_enter(debug_mutex); 3598 va_start(adx, fmt); 3599 (void) vsnprintf(buf, 255, fmt, adx); 3600 va_end(adx); 3601 3602 printf("(%llx) %s: %s", (unsigned long long)curthread->t_did, fn, 3603 buf); 3604 mutex_exit(debug_mutex); 3605 } 3606 #endif /* IPP_DBG */ 3607