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) 2007, 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 25 #include <sys/types.h> 26 #include <unistd.h> 27 #include <errno.h> 28 #include <fcntl.h> 29 #include <assert.h> 30 #include <ctype.h> 31 #include <strings.h> 32 #include <sys/stat.h> 33 #include <sys/dld.h> 34 #include <sys/vlan.h> 35 #include <zone.h> 36 #include <librcm.h> 37 #include <libdlpi.h> 38 #include <libdevinfo.h> 39 #include <libdlaggr.h> 40 #include <libdlvlan.h> 41 #include <libdlvnic.h> 42 #include <libdlib.h> 43 #include <libdllink.h> 44 #include <libdlmgmt.h> 45 #include <libdladm_impl.h> 46 #include <libinetutil.h> 47 48 /* 49 * Return the attributes of the specified datalink from the DLD driver. 50 */ 51 static dladm_status_t 52 i_dladm_info(dladm_handle_t handle, const datalink_id_t linkid, 53 dladm_attr_t *dap) 54 { 55 dld_ioc_attr_t dia; 56 57 dia.dia_linkid = linkid; 58 59 if (ioctl(dladm_dld_fd(handle), DLDIOC_ATTR, &dia) < 0) 60 return (dladm_errno2status(errno)); 61 62 dap->da_max_sdu = dia.dia_max_sdu; 63 64 return (DLADM_STATUS_OK); 65 } 66 67 static dladm_status_t 68 dladm_usagelog(dladm_handle_t handle, dladm_logtype_t type, 69 dld_ioc_usagelog_t *log_info) 70 { 71 if (type == DLADM_LOGTYPE_FLOW) 72 log_info->ul_type = MAC_LOGTYPE_FLOW; 73 else 74 log_info->ul_type = MAC_LOGTYPE_LINK; 75 76 if (ioctl(dladm_dld_fd(handle), DLDIOC_USAGELOG, log_info) < 0) 77 return (DLADM_STATUS_IOERR); 78 79 return (DLADM_STATUS_OK); 80 } 81 82 dladm_status_t 83 dladm_start_usagelog(dladm_handle_t handle, dladm_logtype_t type, 84 uint_t interval) 85 { 86 dld_ioc_usagelog_t log_info; 87 88 log_info.ul_onoff = B_TRUE; 89 log_info.ul_interval = interval; 90 91 return (dladm_usagelog(handle, type, &log_info)); 92 } 93 94 dladm_status_t 95 dladm_stop_usagelog(dladm_handle_t handle, dladm_logtype_t type) 96 { 97 dld_ioc_usagelog_t log_info; 98 99 log_info.ul_onoff = B_FALSE; 100 log_info.ul_interval = 0; 101 102 return (dladm_usagelog(handle, type, &log_info)); 103 } 104 105 struct i_dladm_walk_arg { 106 dladm_walkcb_t *fn; 107 void *arg; 108 }; 109 110 static int 111 i_dladm_walk(dladm_handle_t handle, datalink_id_t linkid, void *arg) 112 { 113 struct i_dladm_walk_arg *walk_arg = arg; 114 char link[MAXLINKNAMELEN]; 115 116 if (dladm_datalink_id2info(handle, linkid, NULL, NULL, NULL, link, 117 sizeof (link)) == DLADM_STATUS_OK) { 118 return (walk_arg->fn(link, walk_arg->arg)); 119 } 120 121 return (DLADM_WALK_CONTINUE); 122 } 123 124 /* 125 * Walk all datalinks. 126 */ 127 dladm_status_t 128 dladm_walk(dladm_walkcb_t *fn, dladm_handle_t handle, void *arg, 129 datalink_class_t class, datalink_media_t dmedia, uint32_t flags) 130 { 131 struct i_dladm_walk_arg walk_arg; 132 133 walk_arg.fn = fn; 134 walk_arg.arg = arg; 135 return (dladm_walk_datalink_id(i_dladm_walk, handle, &walk_arg, 136 class, dmedia, flags)); 137 } 138 139 #define MAXGRPPERLINK 64 140 141 int 142 dladm_walk_hwgrp(dladm_handle_t handle, datalink_id_t linkid, void *arg, 143 boolean_t (*fn)(void *, dladm_hwgrp_attr_t *)) 144 { 145 int bufsize, ret; 146 int nhwgrp = MAXGRPPERLINK; 147 dld_ioc_hwgrpget_t *iomp = NULL; 148 149 bufsize = sizeof (dld_ioc_hwgrpget_t) + 150 nhwgrp * sizeof (dld_hwgrpinfo_t); 151 152 if ((iomp = (dld_ioc_hwgrpget_t *)calloc(1, bufsize)) == NULL) 153 return (-1); 154 155 iomp->dih_size = nhwgrp * sizeof (dld_hwgrpinfo_t); 156 iomp->dih_linkid = linkid; 157 158 ret = ioctl(dladm_dld_fd(handle), DLDIOC_GETHWGRP, iomp); 159 if (ret == 0) { 160 int i; 161 int j; 162 dld_hwgrpinfo_t *dhip; 163 dladm_hwgrp_attr_t attr; 164 165 dhip = (dld_hwgrpinfo_t *)(iomp + 1); 166 for (i = 0; i < iomp->dih_n_groups; i++) { 167 bzero(&attr, sizeof (attr)); 168 169 (void) strlcpy(attr.hg_link_name, 170 dhip->dhi_link_name, sizeof (attr.hg_link_name)); 171 attr.hg_grp_num = dhip->dhi_grp_num; 172 attr.hg_grp_type = dhip->dhi_grp_type; 173 attr.hg_n_rings = dhip->dhi_n_rings; 174 for (j = 0; j < dhip->dhi_n_rings; j++) 175 attr.hg_rings[j] = dhip->dhi_rings[j]; 176 dladm_sort_index_list(attr.hg_rings, attr.hg_n_rings); 177 attr.hg_n_clnts = dhip->dhi_n_clnts; 178 (void) strlcpy(attr.hg_client_names, 179 dhip->dhi_clnts, sizeof (attr.hg_client_names)); 180 181 if (!(*fn)(arg, &attr)) 182 break; 183 dhip++; 184 } 185 } 186 free(iomp); 187 return (ret); 188 } 189 190 /* 191 * Invoke the specified callback for each MAC address entry defined on 192 * the specified device. 193 */ 194 int 195 dladm_walk_macaddr(dladm_handle_t handle, datalink_id_t linkid, void *arg, 196 boolean_t (*fn)(void *, dladm_macaddr_attr_t *)) 197 { 198 int bufsize, ret; 199 int nmacaddr = 1024; 200 dld_ioc_macaddrget_t *iomp = NULL; 201 202 bufsize = sizeof (dld_ioc_macaddrget_t) + 203 nmacaddr * sizeof (dld_macaddrinfo_t); 204 205 if ((iomp = (dld_ioc_macaddrget_t *)calloc(1, bufsize)) == NULL) 206 return (-1); 207 208 iomp->dig_size = nmacaddr * sizeof (dld_macaddrinfo_t); 209 iomp->dig_linkid = linkid; 210 211 ret = ioctl(dladm_dld_fd(handle), DLDIOC_MACADDRGET, iomp); 212 if (ret == 0) { 213 int i; 214 dld_macaddrinfo_t *dmip; 215 dladm_macaddr_attr_t attr; 216 217 dmip = (dld_macaddrinfo_t *)(iomp + 1); 218 for (i = 0; i < iomp->dig_count; i++) { 219 bzero(&attr, sizeof (attr)); 220 221 attr.ma_slot = dmip->dmi_slot; 222 attr.ma_flags = 0; 223 if (dmip->dmi_flags & DLDIOCMACADDR_USED) 224 attr.ma_flags |= DLADM_MACADDR_USED; 225 bcopy(dmip->dmi_addr, attr.ma_addr, 226 dmip->dmi_addrlen); 227 attr.ma_addrlen = dmip->dmi_addrlen; 228 (void) strlcpy(attr.ma_client_name, 229 dmip->dmi_client_name, MAXNAMELEN); 230 attr.ma_client_linkid = dmip->dma_client_linkid; 231 232 if (!(*fn)(arg, &attr)) 233 break; 234 dmip++; 235 } 236 } 237 free(iomp); 238 return (ret); 239 } 240 241 /* 242 * These routines are used by administration tools such as dladm(1M) to 243 * iterate through the list of MAC interfaces 244 */ 245 246 typedef struct dladm_mac_dev { 247 char dm_name[MAXNAMELEN]; 248 struct dladm_mac_dev *dm_next; 249 } dladm_mac_dev_t; 250 251 typedef struct macadm_walk { 252 dladm_mac_dev_t *dmd_dev_list; 253 } dladm_mac_walk_t; 254 255 /* 256 * Local callback invoked for each DDI_NT_NET node. 257 */ 258 /* ARGSUSED */ 259 static int 260 i_dladm_mac_walk(di_node_t node, di_minor_t minor, void *arg) 261 { 262 dladm_mac_walk_t *dmwp = arg; 263 dladm_mac_dev_t *dmdp = dmwp->dmd_dev_list; 264 dladm_mac_dev_t **last_dmdp = &dmwp->dmd_dev_list; 265 char mac[MAXNAMELEN]; 266 267 (void) snprintf(mac, MAXNAMELEN, "%s%d", 268 di_driver_name(node), di_instance(node)); 269 270 /* 271 * Skip aggregations. 272 */ 273 if (strcmp("aggr", di_driver_name(node)) == 0) 274 return (DI_WALK_CONTINUE); 275 276 /* 277 * Skip softmacs. 278 */ 279 if (strcmp("softmac", di_driver_name(node)) == 0) 280 return (DI_WALK_CONTINUE); 281 282 while (dmdp) { 283 /* 284 * Skip duplicates. 285 */ 286 if (strcmp(dmdp->dm_name, mac) == 0) 287 return (DI_WALK_CONTINUE); 288 289 last_dmdp = &dmdp->dm_next; 290 dmdp = dmdp->dm_next; 291 } 292 293 if ((dmdp = malloc(sizeof (*dmdp))) == NULL) 294 return (DI_WALK_CONTINUE); 295 296 (void) strlcpy(dmdp->dm_name, mac, MAXNAMELEN); 297 dmdp->dm_next = NULL; 298 *last_dmdp = dmdp; 299 300 return (DI_WALK_CONTINUE); 301 } 302 303 /* 304 * Invoke the specified callback for each DDI_NT_NET node. 305 */ 306 dladm_status_t 307 dladm_mac_walk(int (*fn)(const char *, void *arg), void *arg) 308 { 309 di_node_t root; 310 dladm_mac_walk_t dmw; 311 dladm_mac_dev_t *dmdp, *next; 312 boolean_t done = B_FALSE; 313 314 if ((root = di_init("/", DINFOCACHE)) == DI_NODE_NIL) 315 return (dladm_errno2status(errno)); 316 317 dmw.dmd_dev_list = NULL; 318 319 (void) di_walk_minor(root, DDI_NT_NET, DI_CHECK_ALIAS, &dmw, 320 i_dladm_mac_walk); 321 322 di_fini(root); 323 324 dmdp = dmw.dmd_dev_list; 325 for (dmdp = dmw.dmd_dev_list; dmdp != NULL; dmdp = next) { 326 next = dmdp->dm_next; 327 if (!done && 328 ((*fn)(dmdp->dm_name, arg) == DLADM_WALK_TERMINATE)) { 329 done = B_TRUE; 330 } 331 free(dmdp); 332 } 333 334 return (DLADM_STATUS_OK); 335 } 336 337 /* 338 * Get the current attributes of the specified datalink. 339 */ 340 dladm_status_t 341 dladm_info(dladm_handle_t handle, datalink_id_t linkid, dladm_attr_t *dap) 342 { 343 return (i_dladm_info(handle, linkid, dap)); 344 } 345 346 const char * 347 dladm_linkstate2str(link_state_t state, char *buf) 348 { 349 const char *s; 350 351 switch (state) { 352 case LINK_STATE_UP: 353 s = "up"; 354 break; 355 case LINK_STATE_DOWN: 356 s = "down"; 357 break; 358 default: 359 s = "unknown"; 360 break; 361 } 362 (void) snprintf(buf, DLADM_STRSIZE, "%s", s); 363 return (buf); 364 } 365 366 const char * 367 dladm_linkduplex2str(link_duplex_t duplex, char *buf) 368 { 369 const char *s; 370 371 switch (duplex) { 372 case LINK_DUPLEX_FULL: 373 s = "full"; 374 break; 375 case LINK_DUPLEX_HALF: 376 s = "half"; 377 break; 378 default: 379 s = "unknown"; 380 break; 381 } 382 (void) snprintf(buf, DLADM_STRSIZE, "%s", s); 383 return (buf); 384 } 385 386 /* 387 * Case 1: rename an existing link1 to a link2 that does not exist. 388 * Result: <linkid1, link2> 389 */ 390 static dladm_status_t 391 i_dladm_rename_link_c1(dladm_handle_t handle, datalink_id_t linkid1, 392 const char *link1, const char *link2, uint32_t flags) 393 { 394 dld_ioc_rename_t dir; 395 dladm_status_t status = DLADM_STATUS_OK; 396 397 /* 398 * Link is currently available. Check to see whether anything is 399 * holding this link to prevent a rename operation. 400 */ 401 if (flags & DLADM_OPT_ACTIVE) { 402 dir.dir_linkid1 = linkid1; 403 dir.dir_linkid2 = DATALINK_INVALID_LINKID; 404 (void) strlcpy(dir.dir_link, link2, MAXLINKNAMELEN); 405 406 if (ioctl(dladm_dld_fd(handle), DLDIOC_RENAME, &dir) < 0) { 407 status = dladm_errno2status(errno); 408 return (status); 409 } 410 } 411 412 status = dladm_remap_datalink_id(handle, linkid1, link2); 413 if (status != DLADM_STATUS_OK && (flags & DLADM_OPT_ACTIVE)) { 414 (void) strlcpy(dir.dir_link, link1, MAXLINKNAMELEN); 415 (void) ioctl(dladm_dld_fd(handle), DLDIOC_RENAME, &dir); 416 } 417 return (status); 418 } 419 420 typedef struct link_hold_arg_s { 421 datalink_id_t linkid; 422 datalink_id_t holder; 423 uint32_t flags; 424 } link_hold_arg_t; 425 426 static int 427 i_dladm_aggr_link_hold(dladm_handle_t handle, datalink_id_t aggrid, void *arg) 428 { 429 link_hold_arg_t *hold_arg = arg; 430 dladm_aggr_grp_attr_t ginfo; 431 dladm_status_t status; 432 int i; 433 434 status = dladm_aggr_info(handle, aggrid, &ginfo, hold_arg->flags); 435 if (status != DLADM_STATUS_OK) 436 return (DLADM_WALK_CONTINUE); 437 438 for (i = 0; i < ginfo.lg_nports; i++) { 439 if (ginfo.lg_ports[i].lp_linkid == hold_arg->linkid) { 440 hold_arg->holder = aggrid; 441 return (DLADM_WALK_TERMINATE); 442 } 443 } 444 return (DLADM_WALK_CONTINUE); 445 } 446 447 static int 448 i_dladm_vlan_link_hold(dladm_handle_t handle, datalink_id_t vlanid, void *arg) 449 { 450 link_hold_arg_t *hold_arg = arg; 451 dladm_vlan_attr_t vinfo; 452 dladm_status_t status; 453 454 status = dladm_vlan_info(handle, vlanid, &vinfo, hold_arg->flags); 455 if (status != DLADM_STATUS_OK) 456 return (DLADM_WALK_CONTINUE); 457 458 if (vinfo.dv_linkid == hold_arg->linkid) { 459 hold_arg->holder = vlanid; 460 return (DLADM_WALK_TERMINATE); 461 } 462 return (DLADM_WALK_CONTINUE); 463 } 464 465 /* 466 * Case 2: rename an available physical link link1 to a REMOVED physical link 467 * link2. As a result, link1 directly inherits all datalinks configured 468 * over link2 (linkid2). 469 * Result: <linkid2, link2, link1_phymaj, link1_phyinst, link1_devname, 470 * link2_other_attr> 471 */ 472 static dladm_status_t 473 i_dladm_rename_link_c2(dladm_handle_t handle, datalink_id_t linkid1, 474 datalink_id_t linkid2) 475 { 476 rcm_handle_t *rcm_hdl = NULL; 477 nvlist_t *nvl = NULL; 478 link_hold_arg_t arg; 479 dld_ioc_rename_t dir; 480 dladm_conf_t conf1, conf2; 481 char devname[MAXLINKNAMELEN]; 482 uint64_t phymaj, phyinst; 483 dladm_status_t status = DLADM_STATUS_OK; 484 485 /* 486 * First check if linkid1 is associated with any persistent 487 * aggregations or VLANs. If yes, return BUSY. 488 */ 489 arg.linkid = linkid1; 490 arg.holder = DATALINK_INVALID_LINKID; 491 arg.flags = DLADM_OPT_PERSIST; 492 (void) dladm_walk_datalink_id(i_dladm_aggr_link_hold, handle, &arg, 493 DATALINK_CLASS_AGGR, DATALINK_ANY_MEDIATYPE, DLADM_OPT_PERSIST); 494 if (arg.holder != DATALINK_INVALID_LINKID) 495 return (DLADM_STATUS_LINKBUSY); 496 497 arg.flags = DLADM_OPT_PERSIST; 498 (void) dladm_walk_datalink_id(i_dladm_vlan_link_hold, handle, &arg, 499 DATALINK_CLASS_VLAN, DATALINK_ANY_MEDIATYPE, DLADM_OPT_PERSIST); 500 if (arg.holder != DATALINK_INVALID_LINKID) 501 return (DLADM_STATUS_LINKBUSY); 502 503 /* 504 * Send DLDIOC_RENAME to request to rename link1's linkid to 505 * be linkid2. This will check whether link1 is used by any 506 * aggregations or VLANs, or is held by any application. If yes, 507 * return failure. 508 */ 509 dir.dir_linkid1 = linkid1; 510 dir.dir_linkid2 = linkid2; 511 if (ioctl(dladm_dld_fd(handle), DLDIOC_RENAME, &dir) < 0) 512 status = dladm_errno2status(errno); 513 514 if (status != DLADM_STATUS_OK) { 515 return (status); 516 } 517 518 /* 519 * Now change the phymaj, phyinst and devname associated with linkid1 520 * to be associated with linkid2. Before doing that, the old active 521 * linkprop of linkid1 should be deleted. 522 */ 523 (void) dladm_set_linkprop(handle, linkid1, NULL, NULL, 0, 524 DLADM_OPT_ACTIVE); 525 526 if (((status = dladm_getsnap_conf(handle, linkid1, &conf1)) != 527 DLADM_STATUS_OK) || 528 ((status = dladm_get_conf_field(handle, conf1, FDEVNAME, devname, 529 MAXLINKNAMELEN)) != DLADM_STATUS_OK) || 530 ((status = dladm_get_conf_field(handle, conf1, FPHYMAJ, &phymaj, 531 sizeof (uint64_t))) != DLADM_STATUS_OK) || 532 ((status = dladm_get_conf_field(handle, conf1, FPHYINST, &phyinst, 533 sizeof (uint64_t))) != DLADM_STATUS_OK) || 534 ((status = dladm_open_conf(handle, linkid2, &conf2)) != 535 DLADM_STATUS_OK)) { 536 dir.dir_linkid1 = linkid2; 537 dir.dir_linkid2 = linkid1; 538 (void) dladm_init_linkprop(handle, linkid1, B_FALSE); 539 (void) ioctl(dladm_dld_fd(handle), DLDIOC_RENAME, &dir); 540 return (status); 541 } 542 543 dladm_destroy_conf(handle, conf1); 544 (void) dladm_set_conf_field(handle, conf2, FDEVNAME, DLADM_TYPE_STR, 545 devname); 546 (void) dladm_set_conf_field(handle, conf2, FPHYMAJ, DLADM_TYPE_UINT64, 547 &phymaj); 548 (void) dladm_set_conf_field(handle, conf2, FPHYINST, 549 DLADM_TYPE_UINT64, &phyinst); 550 (void) dladm_write_conf(handle, conf2); 551 dladm_destroy_conf(handle, conf2); 552 553 /* 554 * Delete link1 and mark link2 up. 555 */ 556 (void) dladm_remove_conf(handle, linkid1); 557 (void) dladm_destroy_datalink_id(handle, linkid1, DLADM_OPT_ACTIVE | 558 DLADM_OPT_PERSIST); 559 (void) dladm_up_datalink_id(handle, linkid2); 560 561 /* 562 * Now generate the RCM_RESOURCE_LINK_NEW sysevent which can be 563 * consumed by the RCM framework to restore all the datalink and 564 * IP configuration. 565 */ 566 status = DLADM_STATUS_FAILED; 567 if ((nvlist_alloc(&nvl, 0, 0) != 0) || 568 (nvlist_add_uint64(nvl, RCM_NV_LINKID, linkid2) != 0)) { 569 goto done; 570 } 571 572 if (rcm_alloc_handle(NULL, 0, NULL, &rcm_hdl) != RCM_SUCCESS) 573 goto done; 574 575 if (rcm_notify_event(rcm_hdl, RCM_RESOURCE_LINK_NEW, 0, nvl, NULL) == 576 RCM_SUCCESS) { 577 status = DLADM_STATUS_OK; 578 } 579 580 done: 581 if (rcm_hdl != NULL) 582 (void) rcm_free_handle(rcm_hdl); 583 if (nvl != NULL) 584 nvlist_free(nvl); 585 return (status); 586 } 587 588 /* 589 * case 3: rename a non-existent link to a REMOVED physical link. 590 * Set the removed physical link's device name to link1, so that 591 * when link1 attaches, it inherits all the link configuration of 592 * the removed physical link. 593 */ 594 static dladm_status_t 595 i_dladm_rename_link_c3(dladm_handle_t handle, const char *link1, 596 datalink_id_t linkid2) 597 { 598 dladm_conf_t conf; 599 dladm_status_t status; 600 601 if (!dladm_valid_linkname(link1)) 602 return (DLADM_STATUS_LINKINVAL); 603 604 status = dladm_open_conf(handle, linkid2, &conf); 605 if (status != DLADM_STATUS_OK) 606 goto done; 607 608 if ((status = dladm_set_conf_field(handle, conf, FDEVNAME, 609 DLADM_TYPE_STR, link1)) == DLADM_STATUS_OK) { 610 status = dladm_write_conf(handle, conf); 611 } 612 613 dladm_destroy_conf(handle, conf); 614 615 done: 616 return (status); 617 } 618 619 dladm_status_t 620 dladm_rename_link(dladm_handle_t handle, const char *link1, const char *link2) 621 { 622 datalink_id_t linkid1 = DATALINK_INVALID_LINKID; 623 datalink_id_t linkid2 = DATALINK_INVALID_LINKID; 624 uint32_t flags1, flags2; 625 datalink_class_t class1, class2; 626 uint32_t media1, media2; 627 boolean_t remphy2 = B_FALSE; 628 dladm_status_t status; 629 630 (void) dladm_name2info(handle, link1, &linkid1, &flags1, &class1, 631 &media1); 632 if ((dladm_name2info(handle, link2, &linkid2, &flags2, &class2, 633 &media2) == DLADM_STATUS_OK) && (class2 == DATALINK_CLASS_PHYS) && 634 (flags2 == DLADM_OPT_PERSIST)) { 635 /* 636 * see whether link2 is a removed physical link. 637 */ 638 remphy2 = B_TRUE; 639 } 640 641 if (linkid1 != DATALINK_INVALID_LINKID) { 642 if (linkid2 == DATALINK_INVALID_LINKID) { 643 /* 644 * case 1: rename an existing link to a link that 645 * does not exist. 646 */ 647 status = i_dladm_rename_link_c1(handle, linkid1, link1, 648 link2, flags1); 649 } else if (remphy2) { 650 /* 651 * case 2: rename an available link to a REMOVED 652 * physical link. Return failure if link1 is not 653 * an active physical link. 654 */ 655 if ((class1 != class2) || (media1 != media2) || 656 !(flags1 & DLADM_OPT_ACTIVE)) { 657 status = DLADM_STATUS_BADARG; 658 } else { 659 status = i_dladm_rename_link_c2(handle, linkid1, 660 linkid2); 661 } 662 } else { 663 status = DLADM_STATUS_EXIST; 664 } 665 } else if (remphy2) { 666 status = i_dladm_rename_link_c3(handle, link1, linkid2); 667 } else { 668 status = DLADM_STATUS_NOTFOUND; 669 } 670 return (status); 671 } 672 673 typedef struct consumer_del_phys_arg_s { 674 datalink_id_t linkid; 675 } consumer_del_phys_arg_t; 676 677 static int 678 i_dladm_vlan_link_del(dladm_handle_t handle, datalink_id_t vlanid, void *arg) 679 { 680 consumer_del_phys_arg_t *del_arg = arg; 681 dladm_vlan_attr_t vinfo; 682 dladm_status_t status; 683 684 status = dladm_vlan_info(handle, vlanid, &vinfo, DLADM_OPT_PERSIST); 685 if (status != DLADM_STATUS_OK) 686 return (DLADM_WALK_CONTINUE); 687 688 if (vinfo.dv_linkid == del_arg->linkid) 689 (void) dladm_vlan_delete(handle, vlanid, DLADM_OPT_PERSIST); 690 return (DLADM_WALK_CONTINUE); 691 } 692 693 static int 694 i_dladm_part_link_del(dladm_handle_t handle, datalink_id_t partid, void *arg) 695 { 696 consumer_del_phys_arg_t *del_arg = arg; 697 dladm_part_attr_t pinfo; 698 dladm_status_t status; 699 700 status = dladm_part_info(handle, partid, &pinfo, DLADM_OPT_PERSIST); 701 if (status != DLADM_STATUS_OK) 702 return (DLADM_WALK_CONTINUE); 703 704 if (pinfo.dia_physlinkid == del_arg->linkid) 705 (void) dladm_part_delete(handle, partid, DLADM_OPT_PERSIST); 706 return (DLADM_WALK_CONTINUE); 707 } 708 709 static int 710 i_dladm_aggr_link_del(dladm_handle_t handle, datalink_id_t aggrid, void *arg) 711 { 712 consumer_del_phys_arg_t *del_arg = arg; 713 dladm_aggr_grp_attr_t ginfo; 714 dladm_status_t status; 715 dladm_aggr_port_attr_db_t port[1]; 716 int i; 717 718 status = dladm_aggr_info(handle, aggrid, &ginfo, DLADM_OPT_PERSIST); 719 if (status != DLADM_STATUS_OK) 720 return (DLADM_WALK_CONTINUE); 721 722 for (i = 0; i < ginfo.lg_nports; i++) 723 if (ginfo.lg_ports[i].lp_linkid == del_arg->linkid) 724 break; 725 726 if (i != ginfo.lg_nports) { 727 if (ginfo.lg_nports == 1 && i == 0) { 728 consumer_del_phys_arg_t aggr_del_arg; 729 730 /* 731 * First delete all the VLANs on this aggregation, then 732 * delete the aggregation itself. 733 */ 734 aggr_del_arg.linkid = aggrid; 735 (void) dladm_walk_datalink_id(i_dladm_vlan_link_del, 736 handle, &aggr_del_arg, DATALINK_CLASS_VLAN, 737 DATALINK_ANY_MEDIATYPE, DLADM_OPT_PERSIST); 738 (void) dladm_aggr_delete(handle, aggrid, 739 DLADM_OPT_PERSIST); 740 } else { 741 port[0].lp_linkid = del_arg->linkid; 742 (void) dladm_aggr_remove(handle, aggrid, 1, port, 743 DLADM_OPT_PERSIST); 744 } 745 } 746 return (DLADM_WALK_CONTINUE); 747 } 748 749 typedef struct del_phys_arg_s { 750 dladm_status_t rval; 751 } del_phys_arg_t; 752 753 static int 754 i_dladm_phys_delete(dladm_handle_t handle, datalink_id_t linkid, void *arg) 755 { 756 uint32_t flags; 757 datalink_class_t class; 758 uint32_t media; 759 dladm_status_t status = DLADM_STATUS_OK; 760 del_phys_arg_t *del_phys_arg = arg; 761 consumer_del_phys_arg_t del_arg; 762 763 if ((status = dladm_datalink_id2info(handle, linkid, &flags, &class, 764 &media, NULL, 0)) != DLADM_STATUS_OK) { 765 goto done; 766 } 767 768 /* 769 * see whether this link is a removed physical link. 770 */ 771 if ((class != DATALINK_CLASS_PHYS) || !(flags & DLADM_OPT_PERSIST) || 772 (flags & DLADM_OPT_ACTIVE)) { 773 status = DLADM_STATUS_BADARG; 774 goto done; 775 } 776 777 if (media == DL_ETHER) { 778 del_arg.linkid = linkid; 779 (void) dladm_walk_datalink_id(i_dladm_aggr_link_del, handle, 780 &del_arg, DATALINK_CLASS_AGGR, DATALINK_ANY_MEDIATYPE, 781 DLADM_OPT_PERSIST); 782 (void) dladm_walk_datalink_id(i_dladm_vlan_link_del, handle, 783 &del_arg, DATALINK_CLASS_VLAN, DATALINK_ANY_MEDIATYPE, 784 DLADM_OPT_PERSIST); 785 } else if (media == DL_IB) { 786 del_arg.linkid = linkid; 787 (void) dladm_walk_datalink_id(i_dladm_part_link_del, handle, 788 &del_arg, DATALINK_CLASS_PART, DL_IB, DLADM_OPT_PERSIST); 789 } 790 791 (void) dladm_remove_conf(handle, linkid); 792 (void) dladm_destroy_datalink_id(handle, linkid, DLADM_OPT_PERSIST); 793 done: 794 del_phys_arg->rval = status; 795 return (DLADM_WALK_CONTINUE); 796 } 797 798 dladm_status_t 799 dladm_phys_delete(dladm_handle_t handle, datalink_id_t linkid) 800 { 801 del_phys_arg_t arg = {DLADM_STATUS_OK}; 802 803 if (linkid == DATALINK_ALL_LINKID) { 804 (void) dladm_walk_datalink_id(i_dladm_phys_delete, handle, &arg, 805 DATALINK_CLASS_PHYS, DATALINK_ANY_MEDIATYPE, 806 DLADM_OPT_PERSIST); 807 return (DLADM_STATUS_OK); 808 } else { 809 (void) i_dladm_phys_delete(handle, linkid, &arg); 810 return (arg.rval); 811 } 812 } 813 814 dladm_status_t 815 dladm_phys_info(dladm_handle_t handle, datalink_id_t linkid, 816 dladm_phys_attr_t *dpap, uint32_t flags) 817 { 818 dladm_status_t status; 819 820 assert(flags == DLADM_OPT_ACTIVE || flags == DLADM_OPT_PERSIST); 821 822 switch (flags) { 823 case DLADM_OPT_PERSIST: { 824 dladm_conf_t conf; 825 826 status = dladm_getsnap_conf(handle, linkid, &conf); 827 if (status != DLADM_STATUS_OK) 828 return (status); 829 830 status = dladm_get_conf_field(handle, conf, FDEVNAME, 831 dpap->dp_dev, MAXLINKNAMELEN); 832 dladm_destroy_conf(handle, conf); 833 return (status); 834 } 835 case DLADM_OPT_ACTIVE: { 836 dld_ioc_phys_attr_t dip; 837 838 dip.dip_linkid = linkid; 839 if (ioctl(dladm_dld_fd(handle), DLDIOC_PHYS_ATTR, &dip) < 0) { 840 status = dladm_errno2status(errno); 841 return (status); 842 } 843 dpap->dp_novanity = dip.dip_novanity; 844 (void) strlcpy(dpap->dp_dev, dip.dip_dev, MAXLINKNAMELEN); 845 return (DLADM_STATUS_OK); 846 } 847 default: 848 return (DLADM_STATUS_BADARG); 849 } 850 } 851 852 typedef struct i_walk_dev_state_s { 853 const char *devname; 854 datalink_id_t linkid; 855 boolean_t found; 856 } i_walk_dev_state_t; 857 858 int 859 i_dladm_walk_dev2linkid(dladm_handle_t handle, datalink_id_t linkid, void *arg) 860 { 861 dladm_phys_attr_t dpa; 862 dladm_status_t status; 863 i_walk_dev_state_t *statep = arg; 864 865 status = dladm_phys_info(handle, linkid, &dpa, DLADM_OPT_PERSIST); 866 if ((status == DLADM_STATUS_OK) && 867 (strcmp(statep->devname, dpa.dp_dev) == 0)) { 868 statep->found = B_TRUE; 869 statep->linkid = linkid; 870 return (DLADM_WALK_TERMINATE); 871 } 872 return (DLADM_WALK_CONTINUE); 873 } 874 875 /* 876 * Get the linkid from the physical device name. 877 */ 878 dladm_status_t 879 dladm_dev2linkid(dladm_handle_t handle, const char *devname, 880 datalink_id_t *linkidp) 881 { 882 i_walk_dev_state_t state; 883 884 state.found = B_FALSE; 885 state.devname = devname; 886 887 (void) dladm_walk_datalink_id(i_dladm_walk_dev2linkid, handle, &state, 888 DATALINK_CLASS_PHYS, DATALINK_ANY_MEDIATYPE, DLADM_OPT_PERSIST); 889 if (state.found == B_TRUE) { 890 *linkidp = state.linkid; 891 return (DLADM_STATUS_OK); 892 } else { 893 return (dladm_errno2status(ENOENT)); 894 } 895 } 896 897 static int 898 parse_devname(const char *devname, char *driver, uint_t *ppa, size_t maxlen) 899 { 900 char *cp, *tp; 901 int len; 902 903 /* 904 * device name length must not be 0, and it must end with digit. 905 */ 906 if (((len = strlen(devname)) == 0) || !isdigit(devname[len - 1])) 907 return (EINVAL); 908 909 (void) strlcpy(driver, devname, maxlen); 910 cp = (char *)&driver[len - 1]; 911 912 for (tp = cp; isdigit(*tp); tp--) { 913 if (tp <= driver) 914 return (EINVAL); 915 } 916 917 *ppa = atoi(tp + 1); 918 *(tp + 1) = '\0'; 919 return (0); 920 } 921 922 dladm_status_t 923 dladm_linkid2legacyname(dladm_handle_t handle, datalink_id_t linkid, char *dev, 924 size_t len) 925 { 926 char devname[MAXLINKNAMELEN]; 927 uint16_t vid = VLAN_ID_NONE; 928 datalink_class_t class; 929 dladm_status_t status; 930 931 status = dladm_datalink_id2info(handle, linkid, NULL, &class, NULL, 932 NULL, 0); 933 if (status != DLADM_STATUS_OK) 934 goto done; 935 936 /* 937 * If this is a VLAN, we must first determine the class and linkid of 938 * the link the VLAN has been created over. 939 */ 940 if (class == DATALINK_CLASS_VLAN) { 941 dladm_vlan_attr_t dva; 942 943 status = dladm_vlan_info(handle, linkid, &dva, 944 DLADM_OPT_ACTIVE); 945 if (status != DLADM_STATUS_OK) 946 goto done; 947 linkid = dva.dv_linkid; 948 vid = dva.dv_vid; 949 950 if ((status = dladm_datalink_id2info(handle, linkid, NULL, 951 &class, NULL, NULL, 0)) != DLADM_STATUS_OK) { 952 goto done; 953 } 954 } 955 956 switch (class) { 957 case DATALINK_CLASS_AGGR: { 958 dladm_aggr_grp_attr_t dga; 959 960 status = dladm_aggr_info(handle, linkid, &dga, 961 DLADM_OPT_ACTIVE); 962 if (status != DLADM_STATUS_OK) 963 goto done; 964 965 if (dga.lg_key == 0) { 966 /* 967 * If the key was not specified when the aggregation 968 * is created, we cannot guess its /dev node name. 969 */ 970 status = DLADM_STATUS_BADARG; 971 goto done; 972 } 973 (void) snprintf(devname, MAXLINKNAMELEN, "aggr%d", dga.lg_key); 974 break; 975 } 976 case DATALINK_CLASS_PHYS: { 977 dladm_phys_attr_t dpa; 978 979 status = dladm_phys_info(handle, linkid, &dpa, 980 DLADM_OPT_PERSIST); 981 if (status != DLADM_STATUS_OK) 982 goto done; 983 984 (void) strlcpy(devname, dpa.dp_dev, MAXLINKNAMELEN); 985 break; 986 } 987 default: 988 status = DLADM_STATUS_BADARG; 989 goto done; 990 } 991 992 if (vid != VLAN_ID_NONE) { 993 char drv[MAXNAMELEN]; 994 uint_t ppa; 995 996 if (parse_devname(devname, drv, &ppa, MAXNAMELEN) != 0) { 997 status = DLADM_STATUS_BADARG; 998 goto done; 999 } 1000 if (snprintf(dev, len, "%s%d", drv, vid * 1000 + ppa) >= len) 1001 status = DLADM_STATUS_TOOSMALL; 1002 } else { 1003 if (strlcpy(dev, devname, len) >= len) 1004 status = DLADM_STATUS_TOOSMALL; 1005 } 1006 1007 done: 1008 return (status); 1009 } 1010 1011 dladm_status_t 1012 dladm_parselink(const char *dev, char *provider, uint_t *ppa) 1013 { 1014 ifspec_t ifsp; 1015 1016 if (dev == NULL || !ifparse_ifspec(dev, &ifsp)) 1017 return (DLADM_STATUS_LINKINVAL); 1018 1019 if (provider != NULL) 1020 (void) strlcpy(provider, ifsp.ifsp_devnm, DLPI_LINKNAME_MAX); 1021 1022 if (ppa != NULL) 1023 *ppa = ifsp.ifsp_ppa; 1024 1025 return (DLADM_STATUS_OK); 1026 } 1027