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 (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 25 /* 26 * This RCM module adds support to the RCM framework for VNIC links 27 */ 28 29 #include <stdio.h> 30 #include <stdlib.h> 31 #include <string.h> 32 #include <errno.h> 33 #include <sys/types.h> 34 #include <synch.h> 35 #include <assert.h> 36 #include <strings.h> 37 #include "rcm_module.h" 38 #include <libintl.h> 39 #include <libdllink.h> 40 #include <libdlvnic.h> 41 #include <libdlpi.h> 42 43 /* 44 * Definitions 45 */ 46 #ifndef lint 47 #define _(x) gettext(x) 48 #else 49 #define _(x) x 50 #endif 51 52 /* Some generic well-knowns and defaults used in this module */ 53 #define RCM_LINK_PREFIX "SUNW_datalink" /* RCM datalink name prefix */ 54 #define RCM_LINK_RESOURCE_MAX (13 + LINKID_STR_WIDTH) 55 56 /* VNIC link flags */ 57 typedef enum { 58 VNIC_OFFLINED = 0x1, 59 VNIC_CONSUMER_OFFLINED = 0x2, 60 VNIC_STALE = 0x4 61 } vnic_flag_t; 62 63 /* link representation */ 64 typedef struct dl_vnic { 65 struct dl_vnic *dlv_next; /* next VNIC on the same link */ 66 struct dl_vnic *dlv_prev; /* prev VNIC on the same link */ 67 datalink_id_t dlv_vnic_id; 68 vnic_flag_t dlv_flags; /* VNIC link flags */ 69 } dl_vnic_t; 70 71 /* VNIC Cache state flags */ 72 typedef enum { 73 CACHE_NODE_STALE = 0x1, /* stale cached data */ 74 CACHE_NODE_NEW = 0x2, /* new cached nodes */ 75 CACHE_NODE_OFFLINED = 0x4 /* nodes offlined */ 76 } cache_node_state_t; 77 78 /* Network Cache lookup options */ 79 #define CACHE_NO_REFRESH 0x1 /* cache refresh not needed */ 80 #define CACHE_REFRESH 0x2 /* refresh cache */ 81 82 /* Cache element */ 83 typedef struct link_cache { 84 struct link_cache *vc_next; /* next cached resource */ 85 struct link_cache *vc_prev; /* prev cached resource */ 86 char *vc_resource; /* resource name */ 87 datalink_id_t vc_linkid; /* linkid */ 88 dl_vnic_t *vc_vnic; /* VNIC list on this link */ 89 cache_node_state_t vc_state; /* cache state flags */ 90 } link_cache_t; 91 92 /* 93 * Global cache for network VNICs 94 */ 95 static link_cache_t cache_head; 96 static link_cache_t cache_tail; 97 static mutex_t cache_lock; 98 static int events_registered = 0; 99 100 static dladm_handle_t dld_handle = NULL; 101 102 /* 103 * RCM module interface prototypes 104 */ 105 static int vnic_register(rcm_handle_t *); 106 static int vnic_unregister(rcm_handle_t *); 107 static int vnic_get_info(rcm_handle_t *, char *, id_t, uint_t, 108 char **, char **, nvlist_t *, rcm_info_t **); 109 static int vnic_suspend(rcm_handle_t *, char *, id_t, 110 timespec_t *, uint_t, char **, rcm_info_t **); 111 static int vnic_resume(rcm_handle_t *, char *, id_t, uint_t, 112 char **, rcm_info_t **); 113 static int vnic_offline(rcm_handle_t *, char *, id_t, uint_t, 114 char **, rcm_info_t **); 115 static int vnic_undo_offline(rcm_handle_t *, char *, id_t, uint_t, 116 char **, rcm_info_t **); 117 static int vnic_remove(rcm_handle_t *, char *, id_t, uint_t, 118 char **, rcm_info_t **); 119 static int vnic_notify_event(rcm_handle_t *, char *, id_t, uint_t, 120 char **, nvlist_t *, rcm_info_t **); 121 static int vnic_configure(rcm_handle_t *, datalink_id_t); 122 123 /* Module private routines */ 124 static void cache_free(); 125 static int cache_update(rcm_handle_t *); 126 static void cache_remove(link_cache_t *); 127 static void node_free(link_cache_t *); 128 static void cache_insert(link_cache_t *); 129 static link_cache_t *cache_lookup(rcm_handle_t *, char *, char); 130 static int vnic_consumer_offline(rcm_handle_t *, link_cache_t *, 131 char **, uint_t, rcm_info_t **); 132 static void vnic_consumer_online(rcm_handle_t *, link_cache_t *, 133 char **, uint_t, rcm_info_t **); 134 static int vnic_offline_vnic(link_cache_t *, uint32_t, 135 cache_node_state_t); 136 static void vnic_online_vnic(link_cache_t *); 137 static char *vnic_usage(link_cache_t *); 138 static void vnic_log_err(datalink_id_t, char **, char *); 139 static int vnic_consumer_notify(rcm_handle_t *, datalink_id_t, 140 char **, uint_t, rcm_info_t **); 141 142 /* Module-Private data */ 143 static struct rcm_mod_ops vnic_ops = 144 { 145 RCM_MOD_OPS_VERSION, 146 vnic_register, 147 vnic_unregister, 148 vnic_get_info, 149 vnic_suspend, 150 vnic_resume, 151 vnic_offline, 152 vnic_undo_offline, 153 vnic_remove, 154 NULL, 155 NULL, 156 vnic_notify_event 157 }; 158 159 /* 160 * rcm_mod_init() - Update registrations, and return the ops structure. 161 */ 162 struct rcm_mod_ops * 163 rcm_mod_init(void) 164 { 165 char errmsg[DLADM_STRSIZE]; 166 dladm_status_t status; 167 168 rcm_log_message(RCM_TRACE1, "VNIC: mod_init\n"); 169 170 cache_head.vc_next = &cache_tail; 171 cache_head.vc_prev = NULL; 172 cache_tail.vc_prev = &cache_head; 173 cache_tail.vc_next = NULL; 174 (void) mutex_init(&cache_lock, 0, NULL); 175 176 if ((status = dladm_open(&dld_handle)) != DLADM_STATUS_OK) { 177 rcm_log_message(RCM_WARNING, 178 "VNIC: mod_init failed: cannot open datalink handle: %s\n", 179 dladm_status2str(status, errmsg)); 180 return (NULL); 181 } 182 183 /* Return the ops vectors */ 184 return (&vnic_ops); 185 } 186 187 /* 188 * rcm_mod_info() - Return a string describing this module. 189 */ 190 const char * 191 rcm_mod_info(void) 192 { 193 rcm_log_message(RCM_TRACE1, "VNIC: mod_info\n"); 194 195 return ("VNIC module"); 196 } 197 198 /* 199 * rcm_mod_fini() - Destroy the network VNIC cache. 200 */ 201 int 202 rcm_mod_fini(void) 203 { 204 rcm_log_message(RCM_TRACE1, "VNIC: mod_fini\n"); 205 206 /* 207 * Note that vnic_unregister() does not seem to be called anywhere, 208 * therefore we free the cache nodes here. In theory we should call 209 * rcm_register_interest() for each node before we free it, the 210 * framework does not provide the rcm_handle to allow us to do so. 211 */ 212 cache_free(); 213 (void) mutex_destroy(&cache_lock); 214 215 dladm_close(dld_handle); 216 return (RCM_SUCCESS); 217 } 218 219 /* 220 * vnic_register() - Make sure the cache is properly sync'ed, and its 221 * registrations are in order. 222 */ 223 static int 224 vnic_register(rcm_handle_t *hd) 225 { 226 rcm_log_message(RCM_TRACE1, "VNIC: register\n"); 227 228 if (cache_update(hd) < 0) 229 return (RCM_FAILURE); 230 231 /* 232 * Need to register interest in all new resources 233 * getting attached, so we get attach event notifications 234 */ 235 if (!events_registered) { 236 if (rcm_register_event(hd, RCM_RESOURCE_LINK_NEW, 0, NULL) 237 != RCM_SUCCESS) { 238 rcm_log_message(RCM_ERROR, 239 _("VNIC: failed to register %s\n"), 240 RCM_RESOURCE_LINK_NEW); 241 return (RCM_FAILURE); 242 } else { 243 rcm_log_message(RCM_DEBUG, "VNIC: registered %s\n", 244 RCM_RESOURCE_LINK_NEW); 245 events_registered++; 246 } 247 } 248 249 return (RCM_SUCCESS); 250 } 251 252 /* 253 * vnic_unregister() - Walk the cache, unregistering all the networks. 254 */ 255 static int 256 vnic_unregister(rcm_handle_t *hd) 257 { 258 link_cache_t *node; 259 260 rcm_log_message(RCM_TRACE1, "VNIC: unregister\n"); 261 262 /* Walk the cache, unregistering everything */ 263 (void) mutex_lock(&cache_lock); 264 node = cache_head.vc_next; 265 while (node != &cache_tail) { 266 if (rcm_unregister_interest(hd, node->vc_resource, 0) 267 != RCM_SUCCESS) { 268 rcm_log_message(RCM_ERROR, 269 _("VNIC: failed to unregister %s\n"), 270 node->vc_resource); 271 (void) mutex_unlock(&cache_lock); 272 return (RCM_FAILURE); 273 } 274 cache_remove(node); 275 node_free(node); 276 node = cache_head.vc_next; 277 } 278 (void) mutex_unlock(&cache_lock); 279 280 /* 281 * Unregister interest in all new resources 282 */ 283 if (events_registered) { 284 if (rcm_unregister_event(hd, RCM_RESOURCE_LINK_NEW, 0) 285 != RCM_SUCCESS) { 286 rcm_log_message(RCM_ERROR, 287 _("VNIC: failed to unregister %s\n"), 288 RCM_RESOURCE_LINK_NEW); 289 return (RCM_FAILURE); 290 } else { 291 rcm_log_message(RCM_DEBUG, "VNIC: unregistered %s\n", 292 RCM_RESOURCE_LINK_NEW); 293 events_registered--; 294 } 295 } 296 297 return (RCM_SUCCESS); 298 } 299 300 /* 301 * vnic_offline() - Offline VNICs on a specific node. 302 */ 303 static int 304 vnic_offline(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags, 305 char **errorp, rcm_info_t **info) 306 { 307 link_cache_t *node; 308 309 rcm_log_message(RCM_TRACE1, "VNIC: offline(%s)\n", rsrc); 310 311 /* Lock the cache and lookup the resource */ 312 (void) mutex_lock(&cache_lock); 313 node = cache_lookup(hd, rsrc, CACHE_REFRESH); 314 if (node == NULL) { 315 /* should not happen because the resource is registered. */ 316 vnic_log_err(DATALINK_INVALID_LINKID, errorp, 317 "unrecognized resource"); 318 (void) mutex_unlock(&cache_lock); 319 return (RCM_SUCCESS); 320 } 321 322 /* 323 * Inform consumers (IP interfaces) of associated VNICs to be offlined 324 */ 325 if (vnic_consumer_offline(hd, node, errorp, flags, info) == 326 RCM_SUCCESS) { 327 rcm_log_message(RCM_DEBUG, 328 "VNIC: consumers agreed on offline\n"); 329 } else { 330 vnic_log_err(node->vc_linkid, errorp, 331 "consumers failed to offline"); 332 (void) mutex_unlock(&cache_lock); 333 return (RCM_FAILURE); 334 } 335 336 /* Check if it's a query */ 337 if (flags & RCM_QUERY) { 338 rcm_log_message(RCM_TRACE1, 339 "VNIC: offline query succeeded(%s)\n", rsrc); 340 (void) mutex_unlock(&cache_lock); 341 return (RCM_SUCCESS); 342 } 343 344 if (vnic_offline_vnic(node, VNIC_OFFLINED, CACHE_NODE_OFFLINED) != 345 RCM_SUCCESS) { 346 vnic_online_vnic(node); 347 vnic_log_err(node->vc_linkid, errorp, "offline failed"); 348 (void) mutex_unlock(&cache_lock); 349 return (RCM_FAILURE); 350 } 351 352 rcm_log_message(RCM_TRACE1, "VNIC: Offline succeeded(%s)\n", rsrc); 353 (void) mutex_unlock(&cache_lock); 354 return (RCM_SUCCESS); 355 } 356 357 /* 358 * vnic_undo_offline() - Undo offline of a previously offlined node. 359 */ 360 /*ARGSUSED*/ 361 static int 362 vnic_undo_offline(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags, 363 char **errorp, rcm_info_t **info) 364 { 365 link_cache_t *node; 366 367 rcm_log_message(RCM_TRACE1, "VNIC: online(%s)\n", rsrc); 368 369 (void) mutex_lock(&cache_lock); 370 node = cache_lookup(hd, rsrc, CACHE_NO_REFRESH); 371 if (node == NULL) { 372 vnic_log_err(DATALINK_INVALID_LINKID, errorp, "no such link"); 373 (void) mutex_unlock(&cache_lock); 374 errno = ENOENT; 375 return (RCM_FAILURE); 376 } 377 378 /* Check if no attempt should be made to online the link here */ 379 if (!(node->vc_state & CACHE_NODE_OFFLINED)) { 380 vnic_log_err(node->vc_linkid, errorp, "link not offlined"); 381 (void) mutex_unlock(&cache_lock); 382 errno = ENOTSUP; 383 return (RCM_SUCCESS); 384 } 385 386 vnic_online_vnic(node); 387 388 /* 389 * Inform IP interfaces on associated VNICs to be onlined 390 */ 391 vnic_consumer_online(hd, node, errorp, flags, info); 392 393 node->vc_state &= ~CACHE_NODE_OFFLINED; 394 rcm_log_message(RCM_TRACE1, "VNIC: online succeeded(%s)\n", rsrc); 395 (void) mutex_unlock(&cache_lock); 396 return (RCM_SUCCESS); 397 } 398 399 static void 400 vnic_online_vnic(link_cache_t *node) 401 { 402 dl_vnic_t *vnic; 403 dladm_status_t status; 404 char errmsg[DLADM_STRSIZE]; 405 406 /* 407 * Try to bring on all offlined VNICs 408 */ 409 for (vnic = node->vc_vnic; vnic != NULL; vnic = vnic->dlv_next) { 410 if (!(vnic->dlv_flags & VNIC_OFFLINED)) 411 continue; 412 413 if ((status = dladm_vnic_up(dld_handle, vnic->dlv_vnic_id, 0)) 414 != DLADM_STATUS_OK) { 415 /* 416 * Print a warning message and continue to online 417 * other VNICs. 418 */ 419 rcm_log_message(RCM_WARNING, 420 _("VNIC: VNIC online failed (%u): %s\n"), 421 vnic->dlv_vnic_id, 422 dladm_status2str(status, errmsg)); 423 } else { 424 vnic->dlv_flags &= ~VNIC_OFFLINED; 425 } 426 } 427 } 428 429 static int 430 vnic_offline_vnic(link_cache_t *node, uint32_t flags, cache_node_state_t state) 431 { 432 dl_vnic_t *vnic; 433 dladm_status_t status; 434 char errmsg[DLADM_STRSIZE]; 435 436 rcm_log_message(RCM_TRACE2, "VNIC: vnic_offline_vnic (%s %u %u)\n", 437 node->vc_resource, flags, state); 438 439 /* 440 * Try to delete all explicit created VNIC 441 */ 442 for (vnic = node->vc_vnic; vnic != NULL; vnic = vnic->dlv_next) { 443 444 if ((status = dladm_vnic_delete(dld_handle, vnic->dlv_vnic_id, 445 DLADM_OPT_ACTIVE)) != DLADM_STATUS_OK) { 446 rcm_log_message(RCM_WARNING, 447 _("VNIC: VNIC offline failed (%u): %s\n"), 448 vnic->dlv_vnic_id, 449 dladm_status2str(status, errmsg)); 450 return (RCM_FAILURE); 451 } else { 452 rcm_log_message(RCM_TRACE1, 453 "VNIC: VNIC offline succeeded(%u)\n", 454 vnic->dlv_vnic_id); 455 vnic->dlv_flags |= flags; 456 } 457 } 458 459 node->vc_state |= state; 460 return (RCM_SUCCESS); 461 } 462 463 /* 464 * vnic_get_info() - Gather usage information for this resource. 465 */ 466 /*ARGSUSED*/ 467 int 468 vnic_get_info(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags, 469 char **usagep, char **errorp, nvlist_t *props, rcm_info_t **info) 470 { 471 link_cache_t *node; 472 473 rcm_log_message(RCM_TRACE1, "VNIC: get_info(%s)\n", rsrc); 474 475 (void) mutex_lock(&cache_lock); 476 node = cache_lookup(hd, rsrc, CACHE_REFRESH); 477 if (node == NULL) { 478 rcm_log_message(RCM_INFO, 479 _("VNIC: get_info(%s) unrecognized resource\n"), rsrc); 480 (void) mutex_unlock(&cache_lock); 481 errno = ENOENT; 482 return (RCM_FAILURE); 483 } 484 485 *usagep = vnic_usage(node); 486 (void) mutex_unlock(&cache_lock); 487 if (*usagep == NULL) { 488 /* most likely malloc failure */ 489 rcm_log_message(RCM_ERROR, 490 _("VNIC: get_info(%s) malloc failure\n"), rsrc); 491 (void) mutex_unlock(&cache_lock); 492 errno = ENOMEM; 493 return (RCM_FAILURE); 494 } 495 496 /* Set client/role properties */ 497 (void) nvlist_add_string(props, RCM_CLIENT_NAME, "VNIC"); 498 499 rcm_log_message(RCM_TRACE1, "VNIC: get_info(%s) info = %s\n", 500 rsrc, *usagep); 501 return (RCM_SUCCESS); 502 } 503 504 /* 505 * vnic_suspend() - Nothing to do, always okay 506 */ 507 /*ARGSUSED*/ 508 static int 509 vnic_suspend(rcm_handle_t *hd, char *rsrc, id_t id, timespec_t *interval, 510 uint_t flags, char **errorp, rcm_info_t **info) 511 { 512 rcm_log_message(RCM_TRACE1, "VNIC: suspend(%s)\n", rsrc); 513 return (RCM_SUCCESS); 514 } 515 516 /* 517 * vnic_resume() - Nothing to do, always okay 518 */ 519 /*ARGSUSED*/ 520 static int 521 vnic_resume(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags, 522 char **errorp, rcm_info_t **info) 523 { 524 rcm_log_message(RCM_TRACE1, "VNIC: resume(%s)\n", rsrc); 525 return (RCM_SUCCESS); 526 } 527 528 /* 529 * vnic_consumer_remove() 530 * 531 * Notify VNIC consumers to remove cache. 532 */ 533 static int 534 vnic_consumer_remove(rcm_handle_t *hd, link_cache_t *node, uint_t flags, 535 rcm_info_t **info) 536 { 537 dl_vnic_t *vnic = NULL; 538 char rsrc[RCM_LINK_RESOURCE_MAX]; 539 int ret = RCM_SUCCESS; 540 541 rcm_log_message(RCM_TRACE2, "VNIC: vnic_consumer_remove (%s)\n", 542 node->vc_resource); 543 544 for (vnic = node->vc_vnic; vnic != NULL; vnic = vnic->dlv_next) { 545 546 /* 547 * This will only be called when the offline operation 548 * succeeds, so the VNIC consumers must have been offlined 549 * at this point. 550 */ 551 assert(vnic->dlv_flags & VNIC_CONSUMER_OFFLINED); 552 553 (void) snprintf(rsrc, RCM_LINK_RESOURCE_MAX, "%s/%u", 554 RCM_LINK_PREFIX, vnic->dlv_vnic_id); 555 556 ret = rcm_notify_remove(hd, rsrc, flags, info); 557 if (ret != RCM_SUCCESS) { 558 rcm_log_message(RCM_WARNING, 559 _("VNIC: notify remove failed (%s)\n"), rsrc); 560 break; 561 } 562 } 563 564 rcm_log_message(RCM_TRACE2, "VNIC: vnic_consumer_remove done\n"); 565 return (ret); 566 } 567 568 /* 569 * vnic_remove() - remove a resource from cache 570 */ 571 /*ARGSUSED*/ 572 static int 573 vnic_remove(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags, 574 char **errorp, rcm_info_t **info) 575 { 576 link_cache_t *node; 577 int rv; 578 579 rcm_log_message(RCM_TRACE1, "VNIC: remove(%s)\n", rsrc); 580 581 (void) mutex_lock(&cache_lock); 582 node = cache_lookup(hd, rsrc, CACHE_NO_REFRESH); 583 if (node == NULL) { 584 rcm_log_message(RCM_INFO, 585 _("VNIC: remove(%s) unrecognized resource\n"), rsrc); 586 (void) mutex_unlock(&cache_lock); 587 errno = ENOENT; 588 return (RCM_FAILURE); 589 } 590 591 /* remove the cached entry for the resource */ 592 cache_remove(node); 593 (void) mutex_unlock(&cache_lock); 594 595 rv = vnic_consumer_remove(hd, node, flags, info); 596 node_free(node); 597 return (rv); 598 } 599 600 /* 601 * vnic_notify_event - Project private implementation to receive new resource 602 * events. It intercepts all new resource events. If the 603 * new resource is a network resource, pass up a notify 604 * for it too. The new resource need not be cached, since 605 * it is done at register again. 606 */ 607 /*ARGSUSED*/ 608 static int 609 vnic_notify_event(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags, 610 char **errorp, nvlist_t *nvl, rcm_info_t **info) 611 { 612 nvpair_t *nvp = NULL; 613 datalink_id_t linkid; 614 uint64_t id64; 615 int rv = RCM_SUCCESS; 616 617 rcm_log_message(RCM_TRACE1, "VNIC: notify_event(%s)\n", rsrc); 618 619 if (strcmp(rsrc, RCM_RESOURCE_LINK_NEW) != 0) { 620 vnic_log_err(DATALINK_INVALID_LINKID, errorp, 621 "unrecognized event"); 622 errno = EINVAL; 623 return (RCM_FAILURE); 624 } 625 626 /* Update cache to reflect latest VNICs */ 627 if (cache_update(hd) < 0) { 628 vnic_log_err(DATALINK_INVALID_LINKID, errorp, 629 "private Cache update failed"); 630 return (RCM_FAILURE); 631 } 632 633 /* 634 * Try best to recover all configuration. 635 */ 636 rcm_log_message(RCM_DEBUG, "VNIC: process_nvlist\n"); 637 while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) { 638 if (strcmp(nvpair_name(nvp), RCM_NV_LINKID) != 0) 639 continue; 640 641 if (nvpair_value_uint64(nvp, &id64) != 0) { 642 vnic_log_err(DATALINK_INVALID_LINKID, errorp, 643 "cannot get linkid"); 644 rv = RCM_FAILURE; 645 continue; 646 } 647 648 linkid = (datalink_id_t)id64; 649 if (vnic_configure(hd, linkid) != 0) { 650 vnic_log_err(linkid, errorp, "configuring failed"); 651 rv = RCM_FAILURE; 652 continue; 653 } 654 655 /* Notify all VNIC consumers */ 656 if (vnic_consumer_notify(hd, linkid, errorp, flags, 657 info) != 0) { 658 vnic_log_err(linkid, errorp, "consumer notify failed"); 659 rv = RCM_FAILURE; 660 } 661 } 662 663 rcm_log_message(RCM_TRACE1, 664 "VNIC: notify_event: link configuration complete\n"); 665 return (rv); 666 } 667 668 /* 669 * vnic_usage - Determine the usage of a link. 670 * The returned buffer is owned by caller, and the caller 671 * must free it up when done. 672 */ 673 static char * 674 vnic_usage(link_cache_t *node) 675 { 676 dl_vnic_t *vnic; 677 int nvnic; 678 char *buf; 679 const char *fmt; 680 char *sep; 681 char errmsg[DLADM_STRSIZE]; 682 char name[MAXLINKNAMELEN]; 683 dladm_status_t status; 684 size_t bufsz; 685 686 rcm_log_message(RCM_TRACE2, "VNIC: usage(%s)\n", node->vc_resource); 687 688 assert(MUTEX_HELD(&cache_lock)); 689 if ((status = dladm_datalink_id2info(dld_handle, node->vc_linkid, NULL, 690 NULL, NULL, name, sizeof (name))) != DLADM_STATUS_OK) { 691 rcm_log_message(RCM_ERROR, 692 _("VNIC: usage(%s) get link name failure(%s)\n"), 693 node->vc_resource, dladm_status2str(status, errmsg)); 694 return (NULL); 695 } 696 697 if (node->vc_state & CACHE_NODE_OFFLINED) 698 fmt = _("%1$s offlined"); 699 else 700 fmt = _("%1$s VNICs: "); 701 702 /* TRANSLATION_NOTE: separator used between VNIC linkids */ 703 sep = _(", "); 704 705 nvnic = 0; 706 for (vnic = node->vc_vnic; vnic != NULL; vnic = vnic->dlv_next) 707 nvnic++; 708 709 /* space for VNICs and separators, plus message */ 710 bufsz = nvnic * (MAXLINKNAMELEN + strlen(sep)) + 711 strlen(fmt) + MAXLINKNAMELEN + 1; 712 if ((buf = malloc(bufsz)) == NULL) { 713 rcm_log_message(RCM_ERROR, 714 _("VNIC: usage(%s) malloc failure(%s)\n"), 715 node->vc_resource, strerror(errno)); 716 return (NULL); 717 } 718 (void) snprintf(buf, bufsz, fmt, name); 719 720 if (node->vc_state & CACHE_NODE_OFFLINED) { 721 /* Nothing else to do */ 722 rcm_log_message(RCM_TRACE2, "VNIC: usage (%s) info = %s\n", 723 node->vc_resource, buf); 724 return (buf); 725 } 726 727 for (vnic = node->vc_vnic; vnic != NULL; vnic = vnic->dlv_next) { 728 rcm_log_message(RCM_DEBUG, "VNIC:= %u\n", vnic->dlv_vnic_id); 729 730 if ((status = dladm_datalink_id2info(dld_handle, 731 vnic->dlv_vnic_id, NULL, NULL, NULL, name, sizeof (name))) 732 != DLADM_STATUS_OK) { 733 rcm_log_message(RCM_ERROR, 734 _("VNIC: usage(%s) get vnic %u name failure(%s)\n"), 735 node->vc_resource, vnic->dlv_vnic_id, 736 dladm_status2str(status, errmsg)); 737 free(buf); 738 return (NULL); 739 } 740 741 (void) strlcat(buf, name, bufsz); 742 if (vnic->dlv_next != NULL) 743 (void) strlcat(buf, sep, bufsz); 744 } 745 746 rcm_log_message(RCM_TRACE2, "VNIC: usage (%s) info = %s\n", 747 node->vc_resource, buf); 748 749 return (buf); 750 } 751 752 /* 753 * Cache management routines, all cache management functions should be 754 * be called with cache_lock held. 755 */ 756 757 /* 758 * cache_lookup() - Get a cache node for a resource. 759 * Call with cache lock held. 760 * 761 * This ensures that the cache is consistent with the system state and 762 * returns a pointer to the cache element corresponding to the resource. 763 */ 764 static link_cache_t * 765 cache_lookup(rcm_handle_t *hd, char *rsrc, char options) 766 { 767 link_cache_t *node; 768 769 rcm_log_message(RCM_TRACE2, "VNIC: cache lookup(%s)\n", rsrc); 770 771 assert(MUTEX_HELD(&cache_lock)); 772 if (options & CACHE_REFRESH) { 773 /* drop lock since update locks cache again */ 774 (void) mutex_unlock(&cache_lock); 775 (void) cache_update(hd); 776 (void) mutex_lock(&cache_lock); 777 } 778 779 node = cache_head.vc_next; 780 for (; node != &cache_tail; node = node->vc_next) { 781 if (strcmp(rsrc, node->vc_resource) == 0) { 782 rcm_log_message(RCM_TRACE2, 783 "VNIC: cache lookup succeeded(%s)\n", rsrc); 784 return (node); 785 } 786 } 787 return (NULL); 788 } 789 790 /* 791 * node_free - Free a node from the cache 792 */ 793 static void 794 node_free(link_cache_t *node) 795 { 796 dl_vnic_t *vnic, *next; 797 798 if (node != NULL) { 799 free(node->vc_resource); 800 801 /* free the VNIC list */ 802 for (vnic = node->vc_vnic; vnic != NULL; vnic = next) { 803 next = vnic->dlv_next; 804 free(vnic); 805 } 806 free(node); 807 } 808 } 809 810 /* 811 * cache_insert - Insert a resource node in cache 812 */ 813 static void 814 cache_insert(link_cache_t *node) 815 { 816 assert(MUTEX_HELD(&cache_lock)); 817 818 /* insert at the head for best performance */ 819 node->vc_next = cache_head.vc_next; 820 node->vc_prev = &cache_head; 821 822 node->vc_next->vc_prev = node; 823 node->vc_prev->vc_next = node; 824 } 825 826 /* 827 * cache_remove() - Remove a resource node from cache. 828 */ 829 static void 830 cache_remove(link_cache_t *node) 831 { 832 assert(MUTEX_HELD(&cache_lock)); 833 node->vc_next->vc_prev = node->vc_prev; 834 node->vc_prev->vc_next = node->vc_next; 835 node->vc_next = NULL; 836 node->vc_prev = NULL; 837 } 838 839 typedef struct vnic_update_arg_s { 840 rcm_handle_t *hd; 841 int retval; 842 } vnic_update_arg_t; 843 844 /* 845 * vnic_update() - Update physical interface properties 846 */ 847 static int 848 vnic_update(dladm_handle_t handle, datalink_id_t vnicid, void *arg) 849 { 850 vnic_update_arg_t *vnic_update_argp = arg; 851 rcm_handle_t *hd = vnic_update_argp->hd; 852 link_cache_t *node; 853 dl_vnic_t *vnic; 854 char *rsrc; 855 dladm_vnic_attr_t vnic_attr; 856 dladm_status_t status; 857 char errmsg[DLADM_STRSIZE]; 858 boolean_t newnode = B_FALSE; 859 int ret = -1; 860 861 rcm_log_message(RCM_TRACE2, "VNIC: vnic_update(%u)\n", vnicid); 862 863 assert(MUTEX_HELD(&cache_lock)); 864 status = dladm_vnic_info(handle, vnicid, &vnic_attr, DLADM_OPT_ACTIVE); 865 if (status != DLADM_STATUS_OK) { 866 rcm_log_message(RCM_TRACE1, 867 "VNIC: vnic_update() cannot get vnic information for " 868 "%u(%s)\n", vnicid, dladm_status2str(status, errmsg)); 869 return (DLADM_WALK_CONTINUE); 870 } 871 872 if (vnic_attr.va_link_id == DATALINK_INVALID_LINKID) { 873 /* 874 * Skip the etherstubs. 875 */ 876 rcm_log_message(RCM_TRACE1, 877 "VNIC: vnic_update(): skip the etherstub %u\n", vnicid); 878 return (DLADM_WALK_CONTINUE); 879 } 880 881 rsrc = malloc(RCM_LINK_RESOURCE_MAX); 882 if (rsrc == NULL) { 883 rcm_log_message(RCM_ERROR, _("VNIC: malloc error(%s): %u\n"), 884 strerror(errno), vnicid); 885 goto done; 886 } 887 888 (void) snprintf(rsrc, RCM_LINK_RESOURCE_MAX, "%s/%u", 889 RCM_LINK_PREFIX, vnic_attr.va_link_id); 890 891 node = cache_lookup(hd, rsrc, CACHE_NO_REFRESH); 892 if (node != NULL) { 893 rcm_log_message(RCM_DEBUG, 894 "VNIC: %s already registered (vnicid:%d)\n", 895 rsrc, vnic_attr.va_vnic_id); 896 free(rsrc); 897 } else { 898 rcm_log_message(RCM_DEBUG, 899 "VNIC: %s is a new resource (vnicid:%d)\n", 900 rsrc, vnic_attr.va_vnic_id); 901 if ((node = calloc(1, sizeof (link_cache_t))) == NULL) { 902 free(rsrc); 903 rcm_log_message(RCM_ERROR, _("VNIC: calloc: %s\n"), 904 strerror(errno)); 905 goto done; 906 } 907 908 node->vc_resource = rsrc; 909 node->vc_vnic = NULL; 910 node->vc_linkid = vnic_attr.va_link_id; 911 node->vc_state |= CACHE_NODE_NEW; 912 newnode = B_TRUE; 913 } 914 915 for (vnic = node->vc_vnic; vnic != NULL; vnic = vnic->dlv_next) { 916 if (vnic->dlv_vnic_id == vnicid) { 917 vnic->dlv_flags &= ~VNIC_STALE; 918 break; 919 } 920 } 921 922 if (vnic == NULL) { 923 if ((vnic = calloc(1, sizeof (dl_vnic_t))) == NULL) { 924 rcm_log_message(RCM_ERROR, _("VNIC: malloc: %s\n"), 925 strerror(errno)); 926 if (newnode) { 927 free(rsrc); 928 free(node); 929 } 930 goto done; 931 } 932 vnic->dlv_vnic_id = vnicid; 933 vnic->dlv_next = node->vc_vnic; 934 vnic->dlv_prev = NULL; 935 if (node->vc_vnic != NULL) 936 node->vc_vnic->dlv_prev = vnic; 937 node->vc_vnic = vnic; 938 } 939 940 node->vc_state &= ~CACHE_NODE_STALE; 941 942 if (newnode) 943 cache_insert(node); 944 945 rcm_log_message(RCM_TRACE3, "VNIC: vnic_update: succeeded(%u)\n", 946 vnicid); 947 ret = 0; 948 done: 949 vnic_update_argp->retval = ret; 950 return (ret == 0 ? DLADM_WALK_CONTINUE : DLADM_WALK_TERMINATE); 951 } 952 953 /* 954 * vnic_update_all() - Determine all VNIC links in the system 955 */ 956 static int 957 vnic_update_all(rcm_handle_t *hd) 958 { 959 vnic_update_arg_t arg = {NULL, 0}; 960 961 rcm_log_message(RCM_TRACE2, "VNIC: vnic_update_all\n"); 962 963 assert(MUTEX_HELD(&cache_lock)); 964 arg.hd = hd; 965 (void) dladm_walk_datalink_id(vnic_update, dld_handle, &arg, 966 DATALINK_CLASS_VNIC, DATALINK_ANY_MEDIATYPE, DLADM_OPT_ACTIVE); 967 return (arg.retval); 968 } 969 970 /* 971 * cache_update() - Update cache with latest interface info 972 */ 973 static int 974 cache_update(rcm_handle_t *hd) 975 { 976 link_cache_t *node, *nnode; 977 dl_vnic_t *vnic; 978 int rv; 979 980 rcm_log_message(RCM_TRACE2, "VNIC: cache_update\n"); 981 982 (void) mutex_lock(&cache_lock); 983 984 /* first we walk the entire cache, marking each entry stale */ 985 node = cache_head.vc_next; 986 for (; node != &cache_tail; node = node->vc_next) { 987 node->vc_state |= CACHE_NODE_STALE; 988 for (vnic = node->vc_vnic; vnic != NULL; vnic = vnic->dlv_next) 989 vnic->dlv_flags |= VNIC_STALE; 990 } 991 992 rv = vnic_update_all(hd); 993 994 /* 995 * Continue to delete all stale nodes from the cache even 996 * vnic_update_all() failed. Unregister link that are not offlined 997 * and still in cache 998 */ 999 for (node = cache_head.vc_next; node != &cache_tail; node = nnode) { 1000 dl_vnic_t *vnic, *next; 1001 1002 for (vnic = node->vc_vnic; vnic != NULL; vnic = next) { 1003 next = vnic->dlv_next; 1004 1005 /* clear stale VNICs */ 1006 if (vnic->dlv_flags & VNIC_STALE) { 1007 if (vnic->dlv_prev != NULL) 1008 vnic->dlv_prev->dlv_next = next; 1009 else 1010 node->vc_vnic = next; 1011 1012 if (next != NULL) 1013 next->dlv_prev = vnic->dlv_prev; 1014 free(vnic); 1015 } 1016 } 1017 1018 nnode = node->vc_next; 1019 if (node->vc_state & CACHE_NODE_STALE) { 1020 (void) rcm_unregister_interest(hd, node->vc_resource, 1021 0); 1022 rcm_log_message(RCM_DEBUG, "VNIC: unregistered %s\n", 1023 node->vc_resource); 1024 assert(node->vc_vnic == NULL); 1025 cache_remove(node); 1026 node_free(node); 1027 continue; 1028 } 1029 1030 if (!(node->vc_state & CACHE_NODE_NEW)) 1031 continue; 1032 1033 if (rcm_register_interest(hd, node->vc_resource, 0, NULL) != 1034 RCM_SUCCESS) { 1035 rcm_log_message(RCM_ERROR, 1036 _("VNIC: failed to register %s\n"), 1037 node->vc_resource); 1038 rv = -1; 1039 } else { 1040 rcm_log_message(RCM_DEBUG, "VNIC: registered %s\n", 1041 node->vc_resource); 1042 node->vc_state &= ~CACHE_NODE_NEW; 1043 } 1044 } 1045 1046 (void) mutex_unlock(&cache_lock); 1047 return (rv); 1048 } 1049 1050 /* 1051 * cache_free() - Empty the cache 1052 */ 1053 static void 1054 cache_free() 1055 { 1056 link_cache_t *node; 1057 1058 rcm_log_message(RCM_TRACE2, "VNIC: cache_free\n"); 1059 1060 (void) mutex_lock(&cache_lock); 1061 node = cache_head.vc_next; 1062 while (node != &cache_tail) { 1063 cache_remove(node); 1064 node_free(node); 1065 node = cache_head.vc_next; 1066 } 1067 (void) mutex_unlock(&cache_lock); 1068 } 1069 1070 /* 1071 * vnic_log_err() - RCM error log wrapper 1072 */ 1073 static void 1074 vnic_log_err(datalink_id_t linkid, char **errorp, char *errmsg) 1075 { 1076 char link[MAXLINKNAMELEN]; 1077 char errstr[DLADM_STRSIZE]; 1078 dladm_status_t status; 1079 int len; 1080 const char *errfmt; 1081 char *error; 1082 1083 link[0] = '\0'; 1084 if (linkid != DATALINK_INVALID_LINKID) { 1085 char rsrc[RCM_LINK_RESOURCE_MAX]; 1086 1087 (void) snprintf(rsrc, sizeof (rsrc), "%s/%u", 1088 RCM_LINK_PREFIX, linkid); 1089 1090 rcm_log_message(RCM_ERROR, _("VNIC: %s(%s)\n"), errmsg, rsrc); 1091 if ((status = dladm_datalink_id2info(dld_handle, linkid, NULL, 1092 NULL, NULL, link, sizeof (link))) != DLADM_STATUS_OK) { 1093 rcm_log_message(RCM_WARNING, 1094 _("VNIC: cannot get link name for (%s) %s\n"), 1095 rsrc, dladm_status2str(status, errstr)); 1096 } 1097 } else { 1098 rcm_log_message(RCM_ERROR, _("VNIC: %s\n"), errmsg); 1099 } 1100 1101 errfmt = strlen(link) > 0 ? _("VNIC: %s(%s)") : _("VNIC: %s"); 1102 len = strlen(errfmt) + strlen(errmsg) + MAXLINKNAMELEN + 1; 1103 if ((error = malloc(len)) != NULL) { 1104 if (strlen(link) > 0) 1105 (void) snprintf(error, len, errfmt, errmsg, link); 1106 else 1107 (void) snprintf(error, len, errfmt, errmsg); 1108 } 1109 1110 if (errorp != NULL) 1111 *errorp = error; 1112 } 1113 1114 /* 1115 * vnic_consumer_online() 1116 * 1117 * Notify online to VNIC consumers. 1118 */ 1119 /* ARGSUSED */ 1120 static void 1121 vnic_consumer_online(rcm_handle_t *hd, link_cache_t *node, char **errorp, 1122 uint_t flags, rcm_info_t **info) 1123 { 1124 dl_vnic_t *vnic; 1125 char rsrc[RCM_LINK_RESOURCE_MAX]; 1126 1127 rcm_log_message(RCM_TRACE2, "VNIC: vnic_consumer_online (%s)\n", 1128 node->vc_resource); 1129 1130 for (vnic = node->vc_vnic; vnic != NULL; vnic = vnic->dlv_next) { 1131 if (!(vnic->dlv_flags & VNIC_CONSUMER_OFFLINED)) 1132 continue; 1133 1134 (void) snprintf(rsrc, RCM_LINK_RESOURCE_MAX, "%s/%u", 1135 RCM_LINK_PREFIX, vnic->dlv_vnic_id); 1136 1137 if (rcm_notify_online(hd, rsrc, flags, info) == RCM_SUCCESS) 1138 vnic->dlv_flags &= ~VNIC_CONSUMER_OFFLINED; 1139 } 1140 1141 rcm_log_message(RCM_TRACE2, "VNIC: vnic_consumer_online done\n"); 1142 } 1143 1144 /* 1145 * vnic_consumer_offline() 1146 * 1147 * Offline VNIC consumers. 1148 */ 1149 static int 1150 vnic_consumer_offline(rcm_handle_t *hd, link_cache_t *node, char **errorp, 1151 uint_t flags, rcm_info_t **info) 1152 { 1153 dl_vnic_t *vnic; 1154 char rsrc[RCM_LINK_RESOURCE_MAX]; 1155 int ret = RCM_SUCCESS; 1156 1157 rcm_log_message(RCM_TRACE2, "VNIC: vnic_consumer_offline (%s)\n", 1158 node->vc_resource); 1159 1160 for (vnic = node->vc_vnic; vnic != NULL; vnic = vnic->dlv_next) { 1161 (void) snprintf(rsrc, RCM_LINK_RESOURCE_MAX, "%s/%u", 1162 RCM_LINK_PREFIX, vnic->dlv_vnic_id); 1163 1164 ret = rcm_request_offline(hd, rsrc, flags, info); 1165 if (ret != RCM_SUCCESS) 1166 break; 1167 1168 vnic->dlv_flags |= VNIC_CONSUMER_OFFLINED; 1169 } 1170 1171 if (vnic != NULL) 1172 vnic_consumer_online(hd, node, errorp, flags, info); 1173 1174 rcm_log_message(RCM_TRACE2, "VNIC: vnic_consumer_offline done\n"); 1175 return (ret); 1176 } 1177 1178 /* 1179 * Send RCM_RESOURCE_LINK_NEW events to other modules about new VNICs. 1180 * Return 0 on success, -1 on failure. 1181 */ 1182 static int 1183 vnic_notify_new_vnic(rcm_handle_t *hd, char *rsrc) 1184 { 1185 link_cache_t *node; 1186 dl_vnic_t *vnic; 1187 nvlist_t *nvl = NULL; 1188 uint64_t id; 1189 int ret = -1; 1190 1191 rcm_log_message(RCM_TRACE2, "VNIC: vnic_notify_new_vnic (%s)\n", rsrc); 1192 1193 (void) mutex_lock(&cache_lock); 1194 if ((node = cache_lookup(hd, rsrc, CACHE_REFRESH)) == NULL) { 1195 (void) mutex_unlock(&cache_lock); 1196 return (0); 1197 } 1198 1199 if (nvlist_alloc(&nvl, 0, 0) != 0) { 1200 (void) mutex_unlock(&cache_lock); 1201 rcm_log_message(RCM_WARNING, 1202 _("VNIC: failed to allocate nvlist\n")); 1203 goto done; 1204 } 1205 1206 for (vnic = node->vc_vnic; vnic != NULL; vnic = vnic->dlv_next) { 1207 rcm_log_message(RCM_TRACE2, 1208 "VNIC: vnic_notify_new_vnic add (%u)\n", vnic->dlv_vnic_id); 1209 1210 id = vnic->dlv_vnic_id; 1211 if (nvlist_add_uint64(nvl, RCM_NV_LINKID, id) != 0) { 1212 rcm_log_message(RCM_ERROR, 1213 _("VNIC: failed to construct nvlist\n")); 1214 (void) mutex_unlock(&cache_lock); 1215 goto done; 1216 } 1217 } 1218 (void) mutex_unlock(&cache_lock); 1219 1220 if (rcm_notify_event(hd, RCM_RESOURCE_LINK_NEW, 0, nvl, NULL) != 1221 RCM_SUCCESS) { 1222 rcm_log_message(RCM_ERROR, 1223 _("VNIC: failed to notify %s event for %s\n"), 1224 RCM_RESOURCE_LINK_NEW, node->vc_resource); 1225 goto done; 1226 } 1227 1228 ret = 0; 1229 done: 1230 nvlist_free(nvl); 1231 return (ret); 1232 } 1233 1234 /* 1235 * vnic_consumer_notify() - Notify consumers of VNICs coming back online. 1236 */ 1237 static int 1238 vnic_consumer_notify(rcm_handle_t *hd, datalink_id_t linkid, char **errorp, 1239 uint_t flags, rcm_info_t **info) 1240 { 1241 char rsrc[RCM_LINK_RESOURCE_MAX]; 1242 link_cache_t *node; 1243 1244 /* Check for the interface in the cache */ 1245 (void) snprintf(rsrc, RCM_LINK_RESOURCE_MAX, "%s/%u", RCM_LINK_PREFIX, 1246 linkid); 1247 1248 rcm_log_message(RCM_TRACE2, "VNIC: vnic_consumer_notify(%s)\n", rsrc); 1249 1250 /* 1251 * Inform IP consumers of the new link. 1252 */ 1253 if (vnic_notify_new_vnic(hd, rsrc) != 0) { 1254 (void) mutex_lock(&cache_lock); 1255 if ((node = cache_lookup(hd, rsrc, CACHE_NO_REFRESH)) != NULL) { 1256 (void) vnic_offline_vnic(node, VNIC_STALE, 1257 CACHE_NODE_STALE); 1258 } 1259 (void) mutex_unlock(&cache_lock); 1260 rcm_log_message(RCM_TRACE2, 1261 "VNIC: vnic_notify_new_vnic failed(%s)\n", rsrc); 1262 return (-1); 1263 } 1264 1265 rcm_log_message(RCM_TRACE2, "VNIC: vnic_consumer_notify succeeded\n"); 1266 return (0); 1267 } 1268 1269 typedef struct vnic_up_arg_s { 1270 datalink_id_t linkid; 1271 int retval; 1272 } vnic_up_arg_t; 1273 1274 static int 1275 vnic_up(dladm_handle_t handle, datalink_id_t vnicid, void *arg) 1276 { 1277 vnic_up_arg_t *vnic_up_argp = arg; 1278 dladm_status_t status; 1279 dladm_vnic_attr_t vnic_attr; 1280 char errmsg[DLADM_STRSIZE]; 1281 1282 status = dladm_vnic_info(handle, vnicid, &vnic_attr, DLADM_OPT_PERSIST); 1283 if (status != DLADM_STATUS_OK) { 1284 rcm_log_message(RCM_TRACE1, 1285 "VNIC: vnic_up(): cannot get information for VNIC %u " 1286 "(%s)\n", vnicid, dladm_status2str(status, errmsg)); 1287 return (DLADM_WALK_CONTINUE); 1288 } 1289 1290 if (vnic_attr.va_link_id != vnic_up_argp->linkid) 1291 return (DLADM_WALK_CONTINUE); 1292 1293 rcm_log_message(RCM_TRACE3, "VNIC: vnic_up(%u)\n", vnicid); 1294 if ((status = dladm_vnic_up(handle, vnicid, 0)) == DLADM_STATUS_OK) 1295 return (DLADM_WALK_CONTINUE); 1296 1297 /* 1298 * Prompt the warning message and continue to UP other VNICs. 1299 */ 1300 rcm_log_message(RCM_WARNING, 1301 _("VNIC: VNIC up failed (%u): %s\n"), 1302 vnicid, dladm_status2str(status, errmsg)); 1303 1304 vnic_up_argp->retval = -1; 1305 return (DLADM_WALK_CONTINUE); 1306 } 1307 1308 /* 1309 * vnic_configure() - Configure VNICs over a physical link after it attaches 1310 */ 1311 static int 1312 vnic_configure(rcm_handle_t *hd, datalink_id_t linkid) 1313 { 1314 char rsrc[RCM_LINK_RESOURCE_MAX]; 1315 link_cache_t *node; 1316 vnic_up_arg_t arg = {DATALINK_INVALID_LINKID, 0}; 1317 1318 /* Check for the VNICs in the cache */ 1319 (void) snprintf(rsrc, sizeof (rsrc), "%s/%u", RCM_LINK_PREFIX, linkid); 1320 1321 rcm_log_message(RCM_TRACE2, "VNIC: vnic_configure(%s)\n", rsrc); 1322 1323 /* Check if the link is new or was previously offlined */ 1324 (void) mutex_lock(&cache_lock); 1325 if (((node = cache_lookup(hd, rsrc, CACHE_REFRESH)) != NULL) && 1326 (!(node->vc_state & CACHE_NODE_OFFLINED))) { 1327 rcm_log_message(RCM_TRACE2, 1328 "VNIC: Skipping configured interface(%s)\n", rsrc); 1329 (void) mutex_unlock(&cache_lock); 1330 return (0); 1331 } 1332 (void) mutex_unlock(&cache_lock); 1333 1334 arg.linkid = linkid; 1335 (void) dladm_walk_datalink_id(vnic_up, dld_handle, &arg, 1336 DATALINK_CLASS_VNIC, DATALINK_ANY_MEDIATYPE, DLADM_OPT_PERSIST); 1337 1338 if (arg.retval == 0) { 1339 rcm_log_message(RCM_TRACE2, 1340 "VNIC: vnic_configure succeeded(%s)\n", rsrc); 1341 } 1342 return (arg.retval); 1343 } 1344