137 char *, uint_t, uint_t *, void *, size_t);
138
139 static dladm_status_t i_dladm_set_private_prop(dladm_handle_t, datalink_id_t,
140 const char *, char **, uint_t, uint_t);
141 static dladm_status_t i_dladm_get_priv_prop(dladm_handle_t, datalink_id_t,
142 const char *, char **, uint_t *, dladm_prop_type_t,
143 uint_t);
144 static dladm_status_t i_dladm_macprop(dladm_handle_t, void *, boolean_t);
145 static const char *dladm_perm2str(uint_t, char *);
146 static link_attr_t *dladm_name2prop(const char *);
147 static link_attr_t *dladm_id2prop(mac_prop_id_t);
148
149 static pd_getf_t get_zone, get_autopush, get_rate_mod, get_rate,
150 get_speed, get_channel, get_powermode, get_radio,
151 get_duplex, get_link_state, get_binary, get_uint32,
152 get_flowctl, get_maxbw, get_cpus, get_priority,
153 get_tagmode, get_range, get_stp, get_bridge_forward,
154 get_bridge_pvid, get_protection, get_rxrings,
155 get_txrings, get_cntavail, get_secondary_macs,
156 get_allowedips, get_allowedcids, get_pool,
157 get_rings_range, get_linkmode_prop,
158 get_promisc_filtered;
159
160 static pd_setf_t set_zone, set_rate, set_powermode, set_radio,
161 set_public_prop, set_resource, set_stp_prop,
162 set_bridge_forward, set_bridge_pvid, set_secondary_macs,
163 set_promisc_filtered;
164
165 static pd_checkf_t check_zone, check_autopush, check_rate, check_hoplimit,
166 check_encaplim, check_uint32, check_maxbw, check_cpus,
167 check_stp_prop, check_bridge_pvid, check_allowedips,
168 check_allowedcids, check_secondary_macs, check_rings,
169 check_pool, check_prop;
170
171 struct prop_desc {
172 /*
173 * link property name
174 */
175 char *pd_name;
176
177 /*
178 * default property value, can be set to { "", NULL }
179 */
180 val_desc_t pd_defval;
181
182 /*
183 * list of optional property values, can be NULL.
367
368 { MAC_PROP_RESOURCE_EFF, sizeof (mac_resource_props_t),
369 "resource-effective"},
370
371 { MAC_PROP_RXRINGSRANGE, sizeof (mac_propval_range_t), "rxrings"},
372
373 { MAC_PROP_TXRINGSRANGE, sizeof (mac_propval_range_t), "txrings"},
374
375 { MAC_PROP_MAX_TX_RINGS_AVAIL, sizeof (uint_t),
376 "txrings-available"},
377
378 { MAC_PROP_MAX_RX_RINGS_AVAIL, sizeof (uint_t),
379 "rxrings-available"},
380
381 { MAC_PROP_MAX_RXHWCLNT_AVAIL, sizeof (uint_t), "rxhwclnt-available"},
382
383 { MAC_PROP_MAX_TXHWCLNT_AVAIL, sizeof (uint_t), "txhwclnt-available"},
384
385 { MAC_PROP_IB_LINKMODE, sizeof (uint32_t), "linkmode"},
386
387 { MAC_PROP_VN_PROMISC_FILTERED, sizeof (boolean_t), "promisc-filtered"},
388
389 { MAC_PROP_SECONDARY_ADDRS, sizeof (mac_secondary_addr_t),
390 "secondary-macs"},
391
392 { MAC_PROP_PRIVATE, 0, "driver-private"}
393 };
394
395 typedef struct bridge_public_prop_s {
396 const char *bpp_name;
397 int bpp_code;
398 } bridge_public_prop_t;
399
400 static const bridge_public_prop_t bridge_prop[] = {
401 { "stp", PT_CFG_NON_STP },
402 { "stp_priority", PT_CFG_PRIO },
403 { "stp_cost", PT_CFG_COST },
404 { "stp_edge", PT_CFG_EDGE },
405 { "stp_p2p", PT_CFG_P2P },
406 { "stp_mcheck", PT_CFG_MCHECK },
407 { NULL, 0 }
408 };
426 { "bi", LINK_FLOWCTRL_BI }
427 };
428 static val_desc_t link_priority_vals[] = {
429 { "low", MPL_LOW },
430 { "medium", MPL_MEDIUM },
431 { "high", MPL_HIGH }
432 };
433
434 static val_desc_t link_tagmode_vals[] = {
435 { "normal", LINK_TAGMODE_NORMAL },
436 { "vlanonly", LINK_TAGMODE_VLANONLY }
437 };
438
439 static val_desc_t link_protect_vals[] = {
440 { "mac-nospoof", MPT_MACNOSPOOF },
441 { "restricted", MPT_RESTRICTED },
442 { "ip-nospoof", MPT_IPNOSPOOF },
443 { "dhcp-nospoof", MPT_DHCPNOSPOOF },
444 };
445
446 static val_desc_t link_promisc_filtered_vals[] = {
447 { "off", B_FALSE },
448 { "on", B_TRUE },
449 };
450
451 static val_desc_t dladm_wlan_radio_vals[] = {
452 { "on", DLADM_WLAN_RADIO_ON },
453 { "off", DLADM_WLAN_RADIO_OFF }
454 };
455
456 static val_desc_t dladm_wlan_powermode_vals[] = {
457 { "off", DLADM_WLAN_PM_OFF },
458 { "fast", DLADM_WLAN_PM_FAST },
459 { "max", DLADM_WLAN_PM_MAX }
460 };
461
462 static val_desc_t stp_p2p_vals[] = {
463 { "true", P2P_FORCE_TRUE },
464 { "false", P2P_FORCE_FALSE },
465 { "auto", P2P_AUTO }
466 };
467
468 static val_desc_t dladm_part_linkmode_vals[] = {
469 { "cm", DLADM_PART_CM_MODE },
470 { "ud", DLADM_PART_UD_MODE },
747 DATALINK_CLASS_PHYS|DATALINK_CLASS_AGGR|
748 DATALINK_CLASS_ETHERSTUB|DATALINK_CLASS_SIMNET, DL_ETHER },
749
750 { "stp_p2p", { "auto", P2P_AUTO },
751 stp_p2p_vals, VALCNT(stp_p2p_vals),
752 set_stp_prop, NULL, get_stp, NULL, PD_AFTER_PERM,
753 DATALINK_CLASS_PHYS|DATALINK_CLASS_AGGR|
754 DATALINK_CLASS_ETHERSTUB|DATALINK_CLASS_SIMNET, DL_ETHER },
755
756 { "stp_mcheck", { "0", 0 },
757 link_01_vals, VALCNT(link_01_vals),
758 set_stp_prop, NULL, get_stp, check_stp_prop, PD_AFTER_PERM,
759 DATALINK_CLASS_PHYS|DATALINK_CLASS_AGGR|
760 DATALINK_CLASS_ETHERSTUB|DATALINK_CLASS_SIMNET, DL_ETHER },
761
762 { "protection", { "--", RESET_VAL },
763 link_protect_vals, VALCNT(link_protect_vals),
764 set_resource, NULL, get_protection, check_prop, 0,
765 DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE },
766
767 { "promisc-filtered", { "on", 1 },
768 link_promisc_filtered_vals, VALCNT(link_promisc_filtered_vals),
769 set_promisc_filtered, NULL, get_promisc_filtered, check_prop, 0,
770 DATALINK_CLASS_VNIC, DATALINK_ANY_MEDIATYPE },
771
772
773 { "allowed-ips", { "--", 0 },
774 NULL, 0, set_resource, NULL,
775 get_allowedips, check_allowedips, PD_CHECK_ALLOC,
776 DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE },
777
778 { "allowed-dhcp-cids", { "--", 0 },
779 NULL, 0, set_resource, NULL,
780 get_allowedcids, check_allowedcids, PD_CHECK_ALLOC,
781 DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE },
782
783 { "rxrings", { "--", RESET_VAL }, NULL, 0,
784 set_resource, get_rings_range, get_rxrings, check_rings, 0,
785 DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE },
786
787 { "rxrings-effective", { "--", 0 },
788 NULL, 0, NULL, NULL,
789 get_rxrings, NULL, 0,
790 DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE },
791
792 { "txrings", { "--", RESET_VAL }, NULL, 0,
1494 status = i_dladm_get_public_prop(handle, linkid, pdp->pd_name, flags,
1495 perm_flags, &zid, sizeof (zid));
1496 if (status != DLADM_STATUS_OK)
1497 return (status);
1498
1499 *val_cnt = 1;
1500 if (zid != GLOBAL_ZONEID) {
1501 if (getzonenamebyid(zid, zone_name, sizeof (zone_name)) < 0) {
1502 return (dladm_errno2status(errno));
1503 }
1504
1505 (void) strncpy(*prop_val, zone_name, DLADM_PROP_VAL_MAX);
1506 } else {
1507 *prop_val[0] = '\0';
1508 }
1509
1510 return (DLADM_STATUS_OK);
1511 }
1512
1513 typedef int (*zone_get_devroot_t)(char *, char *, size_t);
1514
1515 static int
1516 i_dladm_get_zone_dev(char *zone_name, char *dev, size_t devlen)
1517 {
1518 char root[MAXPATHLEN];
1519 zone_get_devroot_t real_zone_get_devroot;
1520 void *dlhandle;
1521 void *sym;
1522 int ret;
1523
1524 if ((dlhandle = dlopen("libzonecfg.so.1", RTLD_LAZY)) == NULL)
1525 return (-1);
1526
1527 if ((sym = dlsym(dlhandle, "zone_get_devroot")) == NULL) {
1528 (void) dlclose(dlhandle);
1529 return (-1);
1530 }
1531
1532 real_zone_get_devroot = (zone_get_devroot_t)sym;
1533
1534 if ((ret = real_zone_get_devroot(zone_name, root, sizeof (root))) == 0)
1535 (void) snprintf(dev, devlen, "%s%s", root, "/dev");
1536 (void) dlclose(dlhandle);
1537 return (ret);
1538 }
1539
1540 static dladm_status_t
1541 i_dladm_update_deventry(dladm_handle_t handle, zoneid_t zid,
1542 datalink_id_t linkid, boolean_t add)
1543 {
1544 char path[MAXPATHLEN];
1545 char name[MAXLINKNAMELEN];
1546 di_prof_t prof = NULL;
1547 char zone_name[ZONENAME_MAX];
1548 dladm_status_t status;
1549 int ret;
1550
1551 if (getzonenamebyid(zid, zone_name, sizeof (zone_name)) < 0)
1552 return (dladm_errno2status(errno));
1553 if (i_dladm_get_zone_dev(zone_name, path, sizeof (path)) != 0)
1554 return (dladm_errno2status(errno));
1555 if (di_prof_init(path, &prof) != 0)
1584 val_desc_t *vdp, uint_t val_cnt, uint_t flags, datalink_media_t media)
1585 {
1586 dladm_status_t status = DLADM_STATUS_OK;
1587 zoneid_t zid_old, zid_new;
1588 dld_ioc_zid_t *dzp;
1589
1590 if (val_cnt != 1)
1591 return (DLADM_STATUS_BADVALCNT);
1592
1593 dzp = (dld_ioc_zid_t *)vdp->vd_val;
1594
1595 status = i_dladm_get_public_prop(handle, linkid, pdp->pd_name, flags,
1596 NULL, &zid_old, sizeof (zid_old));
1597 if (status != DLADM_STATUS_OK)
1598 return (status);
1599
1600 zid_new = dzp->diz_zid;
1601 if (zid_new == zid_old)
1602 return (DLADM_STATUS_OK);
1603
1604 if (flags & DLADM_OPT_TRANSIENT)
1605 dzp->diz_transient = B_TRUE;
1606
1607 if ((status = set_public_prop(handle, pdp, linkid, vdp, val_cnt,
1608 flags, media)) != DLADM_STATUS_OK)
1609 return (status);
1610
1611 /*
1612 * It is okay to fail to update the /dev entry (some vanity-named
1613 * links do not have a /dev entry).
1614 */
1615 if (zid_old != GLOBAL_ZONEID) {
1616 (void) i_dladm_update_deventry(handle, zid_old, linkid,
1617 B_FALSE);
1618 }
1619 if (zid_new != GLOBAL_ZONEID)
1620 (void) i_dladm_update_deventry(handle, zid_new, linkid, B_TRUE);
1621
1622 return (DLADM_STATUS_OK);
1623 }
1624
1625 /* ARGSUSED */
1626 static dladm_status_t
4827 status = i_dladm_get_public_prop(handle, linkid, pdp->pd_name, flags,
4828 perm_flags, &v, sizeof (v));
4829 if (status != DLADM_STATUS_OK)
4830 return (status);
4831
4832 switch (v) {
4833 case DLADM_PART_CM_MODE:
4834 s = "cm";
4835 break;
4836 case DLADM_PART_UD_MODE:
4837 s = "ud";
4838 break;
4839 default:
4840 s = "";
4841 break;
4842 }
4843 (void) snprintf(prop_val[0], DLADM_STRSIZE, "%s", s);
4844
4845 *val_cnt = 1;
4846 return (DLADM_STATUS_OK);
4847 }
4848
4849 /*ARGSUSED*/
4850 static dladm_status_t
4851 get_promisc_filtered(dladm_handle_t handle, prop_desc_t *pdp,
4852 datalink_id_t linkid, char **prop_val, uint_t *val_cnt,
4853 datalink_media_t media, uint_t flags, uint_t *perm_flags)
4854 {
4855 char *s;
4856 dladm_status_t status;
4857 boolean_t filt;
4858
4859 status = i_dladm_get_public_prop(handle, linkid, pdp->pd_name, flags,
4860 perm_flags, &filt, sizeof (filt));
4861 if (status != DLADM_STATUS_OK)
4862 return (status);
4863
4864 if (filt != 0)
4865 s = link_promisc_filtered_vals[1].vd_name;
4866 else
4867 s = link_promisc_filtered_vals[0].vd_name;
4868 (void) snprintf(prop_val[0], DLADM_STRSIZE, "%s", s);
4869
4870 *val_cnt = 1;
4871 return (DLADM_STATUS_OK);
4872 }
4873
4874 /* ARGSUSED */
4875 static dladm_status_t
4876 set_promisc_filtered(dladm_handle_t handle, prop_desc_t *pdp,
4877 datalink_id_t linkid, val_desc_t *vdp, uint_t val_cnt, uint_t flags,
4878 datalink_media_t media)
4879 {
4880 dld_ioc_macprop_t *dip;
4881 dladm_status_t status = DLADM_STATUS_OK;
4882
4883 dip = i_dladm_buf_alloc_by_name(0, linkid, pdp->pd_name,
4884 0, &status);
4885
4886 if (dip == NULL)
4887 return (status);
4888
4889 (void) memcpy(dip->pr_val, &vdp->vd_val, dip->pr_valsize);
4890 status = i_dladm_macprop(handle, dip, B_TRUE);
4891
4892 free(dip);
4893 return (status);
4894 }
|
137 char *, uint_t, uint_t *, void *, size_t);
138
139 static dladm_status_t i_dladm_set_private_prop(dladm_handle_t, datalink_id_t,
140 const char *, char **, uint_t, uint_t);
141 static dladm_status_t i_dladm_get_priv_prop(dladm_handle_t, datalink_id_t,
142 const char *, char **, uint_t *, dladm_prop_type_t,
143 uint_t);
144 static dladm_status_t i_dladm_macprop(dladm_handle_t, void *, boolean_t);
145 static const char *dladm_perm2str(uint_t, char *);
146 static link_attr_t *dladm_name2prop(const char *);
147 static link_attr_t *dladm_id2prop(mac_prop_id_t);
148
149 static pd_getf_t get_zone, get_autopush, get_rate_mod, get_rate,
150 get_speed, get_channel, get_powermode, get_radio,
151 get_duplex, get_link_state, get_binary, get_uint32,
152 get_flowctl, get_maxbw, get_cpus, get_priority,
153 get_tagmode, get_range, get_stp, get_bridge_forward,
154 get_bridge_pvid, get_protection, get_rxrings,
155 get_txrings, get_cntavail, get_secondary_macs,
156 get_allowedips, get_allowedcids, get_pool,
157 get_rings_range, get_linkmode_prop;
158
159 static pd_setf_t set_zone, set_rate, set_powermode, set_radio,
160 set_public_prop, set_resource, set_stp_prop,
161 set_bridge_forward, set_bridge_pvid, set_secondary_macs;
162
163 static pd_checkf_t check_zone, check_autopush, check_rate, check_hoplimit,
164 check_encaplim, check_uint32, check_maxbw, check_cpus,
165 check_stp_prop, check_bridge_pvid, check_allowedips,
166 check_allowedcids, check_secondary_macs, check_rings,
167 check_pool, check_prop;
168
169 struct prop_desc {
170 /*
171 * link property name
172 */
173 char *pd_name;
174
175 /*
176 * default property value, can be set to { "", NULL }
177 */
178 val_desc_t pd_defval;
179
180 /*
181 * list of optional property values, can be NULL.
365
366 { MAC_PROP_RESOURCE_EFF, sizeof (mac_resource_props_t),
367 "resource-effective"},
368
369 { MAC_PROP_RXRINGSRANGE, sizeof (mac_propval_range_t), "rxrings"},
370
371 { MAC_PROP_TXRINGSRANGE, sizeof (mac_propval_range_t), "txrings"},
372
373 { MAC_PROP_MAX_TX_RINGS_AVAIL, sizeof (uint_t),
374 "txrings-available"},
375
376 { MAC_PROP_MAX_RX_RINGS_AVAIL, sizeof (uint_t),
377 "rxrings-available"},
378
379 { MAC_PROP_MAX_RXHWCLNT_AVAIL, sizeof (uint_t), "rxhwclnt-available"},
380
381 { MAC_PROP_MAX_TXHWCLNT_AVAIL, sizeof (uint_t), "txhwclnt-available"},
382
383 { MAC_PROP_IB_LINKMODE, sizeof (uint32_t), "linkmode"},
384
385 { MAC_PROP_SECONDARY_ADDRS, sizeof (mac_secondary_addr_t),
386 "secondary-macs"},
387
388 { MAC_PROP_PRIVATE, 0, "driver-private"}
389 };
390
391 typedef struct bridge_public_prop_s {
392 const char *bpp_name;
393 int bpp_code;
394 } bridge_public_prop_t;
395
396 static const bridge_public_prop_t bridge_prop[] = {
397 { "stp", PT_CFG_NON_STP },
398 { "stp_priority", PT_CFG_PRIO },
399 { "stp_cost", PT_CFG_COST },
400 { "stp_edge", PT_CFG_EDGE },
401 { "stp_p2p", PT_CFG_P2P },
402 { "stp_mcheck", PT_CFG_MCHECK },
403 { NULL, 0 }
404 };
422 { "bi", LINK_FLOWCTRL_BI }
423 };
424 static val_desc_t link_priority_vals[] = {
425 { "low", MPL_LOW },
426 { "medium", MPL_MEDIUM },
427 { "high", MPL_HIGH }
428 };
429
430 static val_desc_t link_tagmode_vals[] = {
431 { "normal", LINK_TAGMODE_NORMAL },
432 { "vlanonly", LINK_TAGMODE_VLANONLY }
433 };
434
435 static val_desc_t link_protect_vals[] = {
436 { "mac-nospoof", MPT_MACNOSPOOF },
437 { "restricted", MPT_RESTRICTED },
438 { "ip-nospoof", MPT_IPNOSPOOF },
439 { "dhcp-nospoof", MPT_DHCPNOSPOOF },
440 };
441
442 static val_desc_t dladm_wlan_radio_vals[] = {
443 { "on", DLADM_WLAN_RADIO_ON },
444 { "off", DLADM_WLAN_RADIO_OFF }
445 };
446
447 static val_desc_t dladm_wlan_powermode_vals[] = {
448 { "off", DLADM_WLAN_PM_OFF },
449 { "fast", DLADM_WLAN_PM_FAST },
450 { "max", DLADM_WLAN_PM_MAX }
451 };
452
453 static val_desc_t stp_p2p_vals[] = {
454 { "true", P2P_FORCE_TRUE },
455 { "false", P2P_FORCE_FALSE },
456 { "auto", P2P_AUTO }
457 };
458
459 static val_desc_t dladm_part_linkmode_vals[] = {
460 { "cm", DLADM_PART_CM_MODE },
461 { "ud", DLADM_PART_UD_MODE },
738 DATALINK_CLASS_PHYS|DATALINK_CLASS_AGGR|
739 DATALINK_CLASS_ETHERSTUB|DATALINK_CLASS_SIMNET, DL_ETHER },
740
741 { "stp_p2p", { "auto", P2P_AUTO },
742 stp_p2p_vals, VALCNT(stp_p2p_vals),
743 set_stp_prop, NULL, get_stp, NULL, PD_AFTER_PERM,
744 DATALINK_CLASS_PHYS|DATALINK_CLASS_AGGR|
745 DATALINK_CLASS_ETHERSTUB|DATALINK_CLASS_SIMNET, DL_ETHER },
746
747 { "stp_mcheck", { "0", 0 },
748 link_01_vals, VALCNT(link_01_vals),
749 set_stp_prop, NULL, get_stp, check_stp_prop, PD_AFTER_PERM,
750 DATALINK_CLASS_PHYS|DATALINK_CLASS_AGGR|
751 DATALINK_CLASS_ETHERSTUB|DATALINK_CLASS_SIMNET, DL_ETHER },
752
753 { "protection", { "--", RESET_VAL },
754 link_protect_vals, VALCNT(link_protect_vals),
755 set_resource, NULL, get_protection, check_prop, 0,
756 DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE },
757
758 { "allowed-ips", { "--", 0 },
759 NULL, 0, set_resource, NULL,
760 get_allowedips, check_allowedips, PD_CHECK_ALLOC,
761 DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE },
762
763 { "allowed-dhcp-cids", { "--", 0 },
764 NULL, 0, set_resource, NULL,
765 get_allowedcids, check_allowedcids, PD_CHECK_ALLOC,
766 DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE },
767
768 { "rxrings", { "--", RESET_VAL }, NULL, 0,
769 set_resource, get_rings_range, get_rxrings, check_rings, 0,
770 DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE },
771
772 { "rxrings-effective", { "--", 0 },
773 NULL, 0, NULL, NULL,
774 get_rxrings, NULL, 0,
775 DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE },
776
777 { "txrings", { "--", RESET_VAL }, NULL, 0,
1479 status = i_dladm_get_public_prop(handle, linkid, pdp->pd_name, flags,
1480 perm_flags, &zid, sizeof (zid));
1481 if (status != DLADM_STATUS_OK)
1482 return (status);
1483
1484 *val_cnt = 1;
1485 if (zid != GLOBAL_ZONEID) {
1486 if (getzonenamebyid(zid, zone_name, sizeof (zone_name)) < 0) {
1487 return (dladm_errno2status(errno));
1488 }
1489
1490 (void) strncpy(*prop_val, zone_name, DLADM_PROP_VAL_MAX);
1491 } else {
1492 *prop_val[0] = '\0';
1493 }
1494
1495 return (DLADM_STATUS_OK);
1496 }
1497
1498 typedef int (*zone_get_devroot_t)(char *, char *, size_t);
1499 typedef int (*zone_get_brand_t)(char *, char *, size_t);
1500
1501 static int
1502 i_dladm_get_zone_dev(char *zone_name, char *dev, size_t devlen)
1503 {
1504 char root[MAXPATHLEN];
1505 char brand[MAXPATHLEN]; /* Overkill, for sure. */
1506 static char *full_native_path = "/native/dev";
1507 char *native_dev_path = full_native_path;
1508 zone_get_devroot_t real_zone_get_devroot;
1509 zone_get_brand_t real_zone_get_brand;
1510 void *dlhandle;
1511 void *sym;
1512 int ret;
1513
1514 if ((dlhandle = dlopen("libzonecfg.so.1", RTLD_LAZY)) == NULL)
1515 return (-1);
1516
1517 if ((sym = dlsym(dlhandle, "zone_get_devroot")) == NULL) {
1518 (void) dlclose(dlhandle);
1519 return (-1);
1520 }
1521 real_zone_get_devroot = (zone_get_devroot_t)sym;
1522
1523 if ((sym = dlsym(dlhandle, "zone_get_brand")) == NULL) {
1524 (void) dlclose(dlhandle);
1525 return (-1);
1526 }
1527 real_zone_get_brand = (zone_get_devroot_t)sym;
1528
1529 /* Have "/dev" be LX-agile for possibility of "/native/dev". */
1530 ret = real_zone_get_brand(zone_name, brand, sizeof (brand));
1531 if (ret != 0) {
1532 (void) dlclose(dlhandle);
1533 return (ret);
1534 }
1535 /* Can use strcmp with constant string... */
1536 if (strcmp(brand, "lx") != 0) {
1537 /* Non-LX zone, don't use "/native/dev" */
1538 native_dev_path += 7; /* strlen("/native") */
1539 }
1540
1541 if ((ret = real_zone_get_devroot(zone_name, root, sizeof (root))) == 0)
1542 (void) snprintf(dev, devlen, "%s%s", root, native_dev_path);
1543 (void) dlclose(dlhandle);
1544 return (ret);
1545 }
1546
1547 static dladm_status_t
1548 i_dladm_update_deventry(dladm_handle_t handle, zoneid_t zid,
1549 datalink_id_t linkid, boolean_t add)
1550 {
1551 char path[MAXPATHLEN];
1552 char name[MAXLINKNAMELEN];
1553 di_prof_t prof = NULL;
1554 char zone_name[ZONENAME_MAX];
1555 dladm_status_t status;
1556 int ret;
1557
1558 if (getzonenamebyid(zid, zone_name, sizeof (zone_name)) < 0)
1559 return (dladm_errno2status(errno));
1560 if (i_dladm_get_zone_dev(zone_name, path, sizeof (path)) != 0)
1561 return (dladm_errno2status(errno));
1562 if (di_prof_init(path, &prof) != 0)
1591 val_desc_t *vdp, uint_t val_cnt, uint_t flags, datalink_media_t media)
1592 {
1593 dladm_status_t status = DLADM_STATUS_OK;
1594 zoneid_t zid_old, zid_new;
1595 dld_ioc_zid_t *dzp;
1596
1597 if (val_cnt != 1)
1598 return (DLADM_STATUS_BADVALCNT);
1599
1600 dzp = (dld_ioc_zid_t *)vdp->vd_val;
1601
1602 status = i_dladm_get_public_prop(handle, linkid, pdp->pd_name, flags,
1603 NULL, &zid_old, sizeof (zid_old));
1604 if (status != DLADM_STATUS_OK)
1605 return (status);
1606
1607 zid_new = dzp->diz_zid;
1608 if (zid_new == zid_old)
1609 return (DLADM_STATUS_OK);
1610
1611 if ((status = set_public_prop(handle, pdp, linkid, vdp, val_cnt,
1612 flags, media)) != DLADM_STATUS_OK)
1613 return (status);
1614
1615 /*
1616 * It is okay to fail to update the /dev entry (some vanity-named
1617 * links do not have a /dev entry).
1618 */
1619 if (zid_old != GLOBAL_ZONEID) {
1620 (void) i_dladm_update_deventry(handle, zid_old, linkid,
1621 B_FALSE);
1622 }
1623 if (zid_new != GLOBAL_ZONEID)
1624 (void) i_dladm_update_deventry(handle, zid_new, linkid, B_TRUE);
1625
1626 return (DLADM_STATUS_OK);
1627 }
1628
1629 /* ARGSUSED */
1630 static dladm_status_t
4831 status = i_dladm_get_public_prop(handle, linkid, pdp->pd_name, flags,
4832 perm_flags, &v, sizeof (v));
4833 if (status != DLADM_STATUS_OK)
4834 return (status);
4835
4836 switch (v) {
4837 case DLADM_PART_CM_MODE:
4838 s = "cm";
4839 break;
4840 case DLADM_PART_UD_MODE:
4841 s = "ud";
4842 break;
4843 default:
4844 s = "";
4845 break;
4846 }
4847 (void) snprintf(prop_val[0], DLADM_STRSIZE, "%s", s);
4848
4849 *val_cnt = 1;
4850 return (DLADM_STATUS_OK);
4851 }
|