/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. * Copyright 2017 Joyent, Inc. * Copyright 2015 Garrett D'Amore * Copyright 2020 RackTop Systems, Inc. * Copyright 2023 Oxide Computer Company */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* * The linkprop get() callback. * - pd: pointer to the prop_desc_t * - propstrp: a property string array to keep the returned property. * Caller allocated. * - cntp: number of returned properties. * Caller also uses it to indicate how many it expects. */ struct prop_desc; typedef struct prop_desc prop_desc_t; typedef dladm_status_t pd_getf_t(dladm_handle_t, prop_desc_t *pdp, datalink_id_t, char **propstp, uint_t *cntp, datalink_media_t, uint_t, uint_t *); /* * The linkprop set() callback. * - propval: a val_desc_t array which keeps the property values to be set. * - cnt: number of properties to be set. * - flags: additional flags passed down the system call. * * pd_set takes val_desc_t given by pd_check(), translates it into * a format suitable for kernel consumption. This may require allocation * of ioctl buffers etc. pd_set() may call another common routine (used * by all other pd_sets) which invokes the ioctl. */ typedef dladm_status_t pd_setf_t(dladm_handle_t, prop_desc_t *, datalink_id_t, val_desc_t *propval, uint_t cnt, uint_t flags, datalink_media_t); /* * The linkprop check() callback. * - propstrp: property string array which keeps the property to be checked. * - cnt: number of properties. * - propval: return value; the property values of the given property strings. * * pd_check checks that the input values are valid. It does so by * iteraring through the pd_modval list for the property. If * the modifiable values cannot be expressed as a list, a pd_check * specific to this property can be used. If the input values are * verified to be valid, pd_check allocates a val_desc_t and fills it * with either a val_desc_t found on the pd_modval list or something * generated on the fly. */ typedef dladm_status_t pd_checkf_t(dladm_handle_t, prop_desc_t *pdp, datalink_id_t, char **propstrp, uint_t *cnt, uint_t flags, val_desc_t **propval, datalink_media_t); typedef struct link_attr_s { mac_prop_id_t pp_id; size_t pp_valsize; char *pp_name; } link_attr_t; typedef struct dladm_linkprop_args_s { dladm_status_t dla_status; uint_t dla_flags; } dladm_linkprop_args_t; static dld_ioc_macprop_t *i_dladm_buf_alloc_by_name(size_t, datalink_id_t, const char *, uint_t, dladm_status_t *); static dld_ioc_macprop_t *i_dladm_buf_alloc_by_id(size_t, datalink_id_t, mac_prop_id_t, uint_t, dladm_status_t *); static dladm_status_t i_dladm_get_public_prop(dladm_handle_t, datalink_id_t, char *, uint_t, uint_t *, void *, size_t); static dladm_status_t i_dladm_set_private_prop(dladm_handle_t, datalink_id_t, const char *, char **, uint_t, uint_t); static dladm_status_t i_dladm_get_priv_prop(dladm_handle_t, datalink_id_t, const char *, char **, uint_t *, dladm_prop_type_t, uint_t); static dladm_status_t i_dladm_macprop(dladm_handle_t, void *, boolean_t); static const char *dladm_perm2str(uint_t, char *); static link_attr_t *dladm_name2prop(const char *); static link_attr_t *dladm_id2prop(mac_prop_id_t); static pd_getf_t get_zone, get_autopush, get_rate_mod, get_rate, get_speed, get_channel, get_powermode, get_radio, get_duplex, get_link_state, get_binary, get_uint32, get_flowctl, get_maxbw, get_cpus, get_priority, get_tagmode, get_range, get_stp, get_bridge_forward, get_bridge_pvid, get_protection, get_rxrings, get_txrings, get_cntavail, get_secondary_macs, get_allowedips, get_allowedcids, get_pool, get_rings_range, get_linkmode_prop, get_bits, get_promisc_filtered, get_media; static pd_setf_t set_zone, set_rate, set_powermode, set_radio, set_public_prop, set_resource, set_stp_prop, set_bridge_forward, set_bridge_pvid, set_secondary_macs, set_promisc_filtered, set_public_bitprop; static pd_checkf_t check_zone, check_autopush, check_rate, check_hoplimit, check_encaplim, check_uint32, check_maxbw, check_cpus, check_stp_prop, check_bridge_pvid, check_allowedips, check_allowedcids, check_secondary_macs, check_rings, check_pool, check_prop; struct prop_desc { /* * link property name */ char *pd_name; /* * default property value, can be set to { "", NULL } */ val_desc_t pd_defval; /* * list of optional property values, can be NULL. * * This is set to non-NULL if there is a list of possible property * values. pd_optval would point to the array of possible values. */ val_desc_t *pd_optval; /* * count of the above optional property values. 0 if pd_optval is NULL. */ uint_t pd_noptval; /* * callback to set link property; set to NULL if this property is * read-only and may be called before or after permanent update; see * flags. */ pd_setf_t *pd_set; /* * callback to get modifiable link property */ pd_getf_t *pd_getmod; /* * callback to get current link property */ pd_getf_t *pd_get; /* * callback to validate link property value, set to NULL if pd_optval * is not NULL. In that case, validate the value by comparing it with * the pd_optval. Return a val_desc_t array pointer if the value is * valid. */ pd_checkf_t *pd_check; uint_t pd_flags; #define PD_TEMPONLY 0x1 /* property is temporary only */ #define PD_CHECK_ALLOC 0x2 /* alloc vd_val as part of pd_check */ #define PD_AFTER_PERM 0x4 /* pd_set after db update; no temporary */ /* * indicate link classes this property applies to. */ datalink_class_t pd_class; /* * indicate link media type this property applies to. */ datalink_media_t pd_dmedia; }; #define MAC_PROP_BUFSIZE(v) sizeof (dld_ioc_macprop_t) + (v) - 1 /* * Supported link properties enumerated in the prop_table[] array are * computed using the callback functions in that array. To compute the * property value, multiple distinct system calls may be needed (e.g., * for wifi speed, we need to issue system calls to get desired/supported * rates). The link_attr[] table enumerates the interfaces to the kernel, * and the type/size of the data passed in the user-kernel interface. */ static link_attr_t link_attr[] = { { MAC_PROP_DUPLEX, sizeof (link_duplex_t), "duplex"}, { MAC_PROP_SPEED, sizeof (uint64_t), "speed"}, { MAC_PROP_STATUS, sizeof (link_state_t), "state"}, { MAC_PROP_AUTONEG, sizeof (uint8_t), "adv_autoneg_cap"}, { MAC_PROP_MTU, sizeof (uint32_t), "mtu"}, { MAC_PROP_FLOWCTRL, sizeof (link_flowctrl_t), "flowctrl"}, { MAC_PROP_ADV_FEC_CAP, sizeof (link_fec_t), "adv_fec_cap"}, { MAC_PROP_EN_FEC_CAP, sizeof (link_fec_t), "en_fec_cap"}, { MAC_PROP_ZONE, sizeof (dld_ioc_zid_t), "zone"}, { MAC_PROP_AUTOPUSH, sizeof (struct dlautopush), "autopush"}, { MAC_PROP_ADV_5000FDX_CAP, sizeof (uint8_t), "adv_5000fdx_cap"}, { MAC_PROP_EN_5000FDX_CAP, sizeof (uint8_t), "en_5000fdx_cap"}, { MAC_PROP_ADV_2500FDX_CAP, sizeof (uint8_t), "adv_2500fdx_cap"}, { MAC_PROP_EN_2500FDX_CAP, sizeof (uint8_t), "en_2500fdx_cap"}, { MAC_PROP_ADV_400GFDX_CAP, sizeof (uint8_t), "adv_400gfdx_cap"}, { MAC_PROP_EN_400GFDX_CAP, sizeof (uint8_t), "en_400gfdx_cap"}, { MAC_PROP_ADV_200GFDX_CAP, sizeof (uint8_t), "adv_200gfdx_cap"}, { MAC_PROP_EN_200GFDX_CAP, sizeof (uint8_t), "en_200gfdx_cap"}, { MAC_PROP_ADV_100GFDX_CAP, sizeof (uint8_t), "adv_100gfdx_cap"}, { MAC_PROP_EN_100GFDX_CAP, sizeof (uint8_t), "en_100gfdx_cap"}, { MAC_PROP_ADV_50GFDX_CAP, sizeof (uint8_t), "adv_50gfdx_cap"}, { MAC_PROP_EN_50GFDX_CAP, sizeof (uint8_t), "en_50gfdx_cap"}, { MAC_PROP_ADV_40GFDX_CAP, sizeof (uint8_t), "adv_40gfdx_cap"}, { MAC_PROP_EN_40GFDX_CAP, sizeof (uint8_t), "en_40gfdx_cap"}, { MAC_PROP_ADV_25GFDX_CAP, sizeof (uint8_t), "adv_25gfdx_cap"}, { MAC_PROP_EN_25GFDX_CAP, sizeof (uint8_t), "en_25gfdx_cap"}, { MAC_PROP_ADV_10GFDX_CAP, sizeof (uint8_t), "adv_10gfdx_cap"}, { MAC_PROP_EN_10GFDX_CAP, sizeof (uint8_t), "en_10gfdx_cap"}, { MAC_PROP_ADV_1000FDX_CAP, sizeof (uint8_t), "adv_1000fdx_cap"}, { MAC_PROP_EN_1000FDX_CAP, sizeof (uint8_t), "en_1000fdx_cap"}, { MAC_PROP_ADV_1000HDX_CAP, sizeof (uint8_t), "adv_1000hdx_cap"}, { MAC_PROP_EN_1000HDX_CAP, sizeof (uint8_t), "en_1000hdx_cap"}, { MAC_PROP_ADV_100FDX_CAP, sizeof (uint8_t), "adv_100fdx_cap"}, { MAC_PROP_EN_100FDX_CAP, sizeof (uint8_t), "en_100fdx_cap"}, { MAC_PROP_ADV_100HDX_CAP, sizeof (uint8_t), "adv_100hdx_cap"}, { MAC_PROP_EN_100HDX_CAP, sizeof (uint8_t), "en_100hdx_cap"}, { MAC_PROP_ADV_10FDX_CAP, sizeof (uint8_t), "adv_10fdx_cap"}, { MAC_PROP_EN_10FDX_CAP, sizeof (uint8_t), "en_10fdx_cap"}, { MAC_PROP_ADV_10HDX_CAP, sizeof (uint8_t), "adv_10hdx_cap"}, { MAC_PROP_EN_10HDX_CAP, sizeof (uint8_t), "en_10hdx_cap"}, { MAC_PROP_WL_ESSID, sizeof (wl_linkstatus_t), "essid"}, { MAC_PROP_WL_BSSID, sizeof (wl_bssid_t), "bssid"}, { MAC_PROP_WL_BSSTYPE, sizeof (wl_bss_type_t), "bsstype"}, { MAC_PROP_WL_LINKSTATUS, sizeof (wl_linkstatus_t), "wl_linkstatus"}, /* wl_rates_t has variable length */ { MAC_PROP_WL_DESIRED_RATES, sizeof (wl_rates_t), "desired_rates"}, /* wl_rates_t has variable length */ { MAC_PROP_WL_SUPPORTED_RATES, sizeof (wl_rates_t), "supported_rates"}, { MAC_PROP_WL_AUTH_MODE, sizeof (wl_authmode_t), "authmode"}, { MAC_PROP_WL_ENCRYPTION, sizeof (wl_encryption_t), "encryption"}, { MAC_PROP_WL_RSSI, sizeof (wl_rssi_t), "signal"}, { MAC_PROP_WL_PHY_CONFIG, sizeof (wl_phy_conf_t), "phy_conf"}, { MAC_PROP_WL_CAPABILITY, sizeof (wl_capability_t), "capability"}, { MAC_PROP_WL_WPA, sizeof (wl_wpa_t), "wpa"}, /* wl_wpa_ess_t has variable length */ { MAC_PROP_WL_SCANRESULTS, sizeof (wl_wpa_ess_t), "scan_results"}, { MAC_PROP_WL_POWER_MODE, sizeof (wl_ps_mode_t), "powermode"}, { MAC_PROP_WL_RADIO, sizeof (dladm_wlan_radio_t), "wl_radio"}, { MAC_PROP_WL_ESS_LIST, sizeof (wl_ess_list_t), "wl_ess_list"}, { MAC_PROP_WL_KEY_TAB, sizeof (wl_wep_key_tab_t), "wl_wep_key"}, { MAC_PROP_WL_CREATE_IBSS, sizeof (wl_create_ibss_t), "createibss"}, /* wl_wpa_ie_t has variable length */ { MAC_PROP_WL_SETOPTIE, sizeof (wl_wpa_ie_t), "set_ie"}, { MAC_PROP_WL_DELKEY, sizeof (wl_del_key_t), "wpa_del_key"}, { MAC_PROP_WL_KEY, sizeof (wl_key_t), "wl_key"}, { MAC_PROP_WL_MLME, sizeof (wl_mlme_t), "mlme"}, { MAC_PROP_TAGMODE, sizeof (link_tagmode_t), "tagmode"}, { MAC_PROP_IPTUN_HOPLIMIT, sizeof (uint32_t), "hoplimit"}, { MAC_PROP_IPTUN_ENCAPLIMIT, sizeof (uint32_t), "encaplimit"}, { MAC_PROP_PVID, sizeof (uint16_t), "default_tag"}, { MAC_PROP_LLIMIT, sizeof (uint32_t), "learn_limit"}, { MAC_PROP_LDECAY, sizeof (uint32_t), "learn_decay"}, { MAC_PROP_RESOURCE, sizeof (mac_resource_props_t), "resource"}, { MAC_PROP_RESOURCE_EFF, sizeof (mac_resource_props_t), "resource-effective"}, { MAC_PROP_RXRINGSRANGE, sizeof (mac_propval_range_t), "rxrings"}, { MAC_PROP_TXRINGSRANGE, sizeof (mac_propval_range_t), "txrings"}, { MAC_PROP_MAX_TX_RINGS_AVAIL, sizeof (uint_t), "txrings-available"}, { MAC_PROP_MAX_RX_RINGS_AVAIL, sizeof (uint_t), "rxrings-available"}, { MAC_PROP_MAX_RXHWCLNT_AVAIL, sizeof (uint_t), "rxhwclnt-available"}, { MAC_PROP_MAX_TXHWCLNT_AVAIL, sizeof (uint_t), "txhwclnt-available"}, { MAC_PROP_IB_LINKMODE, sizeof (uint32_t), "linkmode"}, { MAC_PROP_VN_PROMISC_FILTERED, sizeof (boolean_t), "promisc-filtered"}, { MAC_PROP_SECONDARY_ADDRS, sizeof (mac_secondary_addr_t), "secondary-macs"}, { MAC_PROP_MEDIA, sizeof (uint32_t), "media" }, { MAC_PROP_PRIVATE, 0, "driver-private"} }; typedef struct bridge_public_prop_s { const char *bpp_name; int bpp_code; } bridge_public_prop_t; static const bridge_public_prop_t bridge_prop[] = { { "stp", PT_CFG_NON_STP }, { "stp_priority", PT_CFG_PRIO }, { "stp_cost", PT_CFG_COST }, { "stp_edge", PT_CFG_EDGE }, { "stp_p2p", PT_CFG_P2P }, { "stp_mcheck", PT_CFG_MCHECK }, { NULL, 0 } }; static val_desc_t link_duplex_vals[] = { { "half", LINK_DUPLEX_HALF }, { "full", LINK_DUPLEX_HALF } }; static val_desc_t link_status_vals[] = { { "up", LINK_STATE_UP }, { "down", LINK_STATE_DOWN } }; static val_desc_t link_01_vals[] = { { "1", 1 }, { "0", 0 } }; static val_desc_t link_flow_vals[] = { { "no", LINK_FLOWCTRL_NONE }, { "tx", LINK_FLOWCTRL_TX }, { "rx", LINK_FLOWCTRL_RX }, { "bi", LINK_FLOWCTRL_BI } }; static val_desc_t link_fec_vals[] = { { "none", LINK_FEC_NONE }, { "auto", LINK_FEC_AUTO }, { "rs", LINK_FEC_RS }, { "base-r", LINK_FEC_BASE_R } }; static val_desc_t link_priority_vals[] = { { "low", MPL_LOW }, { "medium", MPL_MEDIUM }, { "high", MPL_HIGH } }; static val_desc_t link_tagmode_vals[] = { { "normal", LINK_TAGMODE_NORMAL }, { "vlanonly", LINK_TAGMODE_VLANONLY } }; static val_desc_t link_protect_vals[] = { { "mac-nospoof", MPT_MACNOSPOOF }, { "restricted", MPT_RESTRICTED }, { "ip-nospoof", MPT_IPNOSPOOF }, { "dhcp-nospoof", MPT_DHCPNOSPOOF }, }; static val_desc_t link_promisc_filtered_vals[] = { { "off", B_FALSE }, { "on", B_TRUE }, }; static val_desc_t dladm_wlan_radio_vals[] = { { "on", DLADM_WLAN_RADIO_ON }, { "off", DLADM_WLAN_RADIO_OFF } }; static val_desc_t dladm_wlan_powermode_vals[] = { { "off", DLADM_WLAN_PM_OFF }, { "fast", DLADM_WLAN_PM_FAST }, { "max", DLADM_WLAN_PM_MAX } }; static val_desc_t stp_p2p_vals[] = { { "true", P2P_FORCE_TRUE }, { "false", P2P_FORCE_FALSE }, { "auto", P2P_AUTO } }; static val_desc_t dladm_part_linkmode_vals[] = { { "cm", DLADM_PART_CM_MODE }, { "ud", DLADM_PART_UD_MODE }, }; static val_desc_t dladm_ether_media_vals[] = { { "unknown", ETHER_MEDIA_UNKNOWN }, { "none", ETHER_MEDIA_NONE }, { "10BASE-T", ETHER_MEDIA_10BASE_T }, { "100BASE-T4", ETHER_MEDIA_100BASE_T4 }, { "100BASE-X", ETHER_MEDIA_100BASE_X }, { "100BASE-T2", ETHER_MEDIA_100BASE_T2 }, { "1000BASE-X", ETHER_MEDIA_1000BASE_X }, { "1000BASE-T", ETHER_MEDIA_1000BASE_T }, { "1000BASE-KX", ETHER_MEDIA_1000BASE_KX }, { "1000BASE-T1", ETHER_MEDIA_1000BASE_T1 }, { "1000BASE-CX", ETHER_MEDIA_1000BASE_CX }, { "1000BASE-SX", ETHER_MEDIA_1000BASE_SX }, { "1000BASE-LX", ETHER_MEDIA_1000BASE_LX }, { "1000BASE-BX", ETHER_MEDIA_1000BASE_BX }, { "1000-SGMII", ETHER_MEDIA_1000_SGMII }, { "100BASE-TX", ETHER_MEDIA_100BASE_TX }, { "100BASE-FX", ETHER_MEDIA_100BASE_FX }, { "100-SGMII", ETHER_MEDIA_100_SGMII }, { "10BASE-T1", ETHER_MEDIA_10BASE_T1 }, { "100BASE-T1", ETHER_MEDIA_100BASE_T1 }, { "2500BASE-T", ETHER_MEDIA_2500BASE_T }, { "2500BASE-KX", ETHER_MEDIA_2500BASE_KX }, { "2500BASE-X", ETHER_MEDIA_2500BASE_X }, { "5000BASE-T", ETHER_MEDIA_5000BASE_T }, { "5000BASE-KR", ETHER_MEDIA_5000BASE_KR }, { "10GBASE-T", ETHER_MEDIA_10GBASE_T }, { "10GBASE-SR", ETHER_MEDIA_10GBASE_SR }, { "10GBASE-LR", ETHER_MEDIA_10GBASE_LR }, { "10GBASE-LRM", ETHER_MEDIA_10GBASE_LRM }, { "10GBASE-KR", ETHER_MEDIA_10GBASE_KR }, { "10GBASE-CX4", ETHER_MEDIA_10GBASE_CX4 }, { "10GBASE-KX4", ETHER_MEDIA_10GBASE_KX4 }, { "10G-XAUI", ETHER_MEDIA_10G_XAUI }, { "10GBASE-AOC", ETHER_MEDIA_10GBASE_AOC }, { "10GBASE-ACC", ETHER_MEDIA_10GBASE_ACC }, { "10GBASE-CR", ETHER_MEDIA_10GBASE_CR }, { "10GBASE-ER", ETHER_MEDIA_10GBASE_ER }, { "10G-SFI", ETHER_MEDIA_10G_SFI }, { "10G-XFI", ETHER_MEDIA_10G_XFI }, { "25GBASE-T", ETHER_MEDIA_25GBASE_T }, { "25GBASE-SR", ETHER_MEDIA_25GBASE_SR }, { "25GBASE-LR", ETHER_MEDIA_25GBASE_LR }, { "25GBASE-ER", ETHER_MEDIA_25GBASE_ER }, { "25GBASE-KR", ETHER_MEDIA_25GBASE_KR }, { "25GBASE-CR", ETHER_MEDIA_25GBASE_CR }, { "25GBASE-AOC", ETHER_MEDIA_25GBASE_AOC }, { "25GBASE-ACC", ETHER_MEDIA_25GBASE_ACC }, { "25G-AUI", ETHER_MEDIA_25G_AUI }, { "40GBASE-T", ETHER_MEDIA_40GBASE_T }, { "40GBASE-CR4", ETHER_MEDIA_40GBASE_CR4 }, { "40GBASE-KR4", ETHER_MEDIA_40GBASE_KR4 }, { "40GBASE-LR4", ETHER_MEDIA_40GBASE_LR4 }, { "40GBASE-SR4", ETHER_MEDIA_40GBASE_SR4 }, { "40GBASE-ER4", ETHER_MEDIA_40GBASE_ER4 }, { "40GBASE-LM4", ETHER_MEDIA_40GBASE_LM4 }, { "40GBASE-AOC4", ETHER_MEDIA_40GBASE_AOC4 }, { "40GBASE-ACC4", ETHER_MEDIA_40GBASE_ACC4 }, { "40G-XLAUI", ETHER_MEDIA_40G_XLAUI }, { "40G-XLPPI", ETHER_MEDIA_40G_XLPPI }, { "50GBASE-KR2", ETHER_MEDIA_50GBASE_KR2 }, { "50GBASE-CR2", ETHER_MEDIA_50GBASE_CR2 }, { "50GBASE-SR2", ETHER_MEDIA_50GBASE_SR2 }, { "50GBASE-LR2", ETHER_MEDIA_50GBASE_LR2 }, { "50GBASE-AOC2", ETHER_MEDIA_50GBASE_AOC2 }, { "50GBASE-ACC2", ETHER_MEDIA_50GBASE_ACC2 }, { "50GBASE-KR", ETHER_MEDIA_50GBASE_KR }, { "50GBASE-CR", ETHER_MEDIA_50GBASE_CR }, { "50GBASE-SR", ETHER_MEDIA_50GBASE_SR }, { "50GBASE-LR", ETHER_MEDIA_50GBASE_LR }, { "50GBASE-FR", ETHER_MEDIA_50GBASE_FR }, { "50GBASE-ER", ETHER_MEDIA_50GBASE_ER }, { "50GBASE-AOC", ETHER_MEDIA_50GBASE_AOC }, { "50GBASE-ACC", ETHER_MEDIA_50GBASE_ACC }, { "100GBASE-CR10", ETHER_MEDIA_100GBASE_CR10 }, { "100GBASE-SR10", ETHER_MEDIA_100GBASE_SR10 }, { "100GBASE-SR4", ETHER_MEDIA_100GBASE_SR4 }, { "100GBASE-LR4", ETHER_MEDIA_100GBASE_LR4 }, { "100GBASE-ER4", ETHER_MEDIA_100GBASE_ER4 }, { "100GBASE-KR4", ETHER_MEDIA_100GBASE_KR4 }, { "100GBASE-CR4", ETHER_MEDIA_100GBASE_CR4 }, { "100GBASE-CAUI4", ETHER_MEDIA_100GBASE_CAUI4 }, { "100GBASE-AOC4", ETHER_MEDIA_100GBASE_AOC4 }, { "100GBASE-ACC4", ETHER_MEDIA_100GBASE_ACC4 }, { "100GBASE-KR2", ETHER_MEDIA_100GBASE_KR2 }, { "100GBASE-CR2", ETHER_MEDIA_100GBASE_CR2 }, { "100GBASE-SR2", ETHER_MEDIA_100GBASE_SR2 }, { "100GBASE-KR", ETHER_MEDIA_100GBASE_KR }, { "100GBASE-CR", ETHER_MEDIA_100GBASE_CR }, { "100GBASE-SR", ETHER_MEDIA_100GBASE_SR }, { "100GBASE-DR", ETHER_MEDIA_100GBASE_DR }, { "100GBASE-LR", ETHER_MEDIA_100GBASE_LR }, { "100GBASE-FR", ETHER_MEDIA_100GBASE_FR }, { "200GAUI-4", ETHER_MEDIA_200GAUI_4 }, { "200GBASE-CR4", ETHER_MEDIA_200GBASE_CR4 }, { "200GBASE-KR4", ETHER_MEDIA_200GBASE_KR4 }, { "200GBASE-SR4", ETHER_MEDIA_200GBASE_SR4 }, { "200GBASE-DR4", ETHER_MEDIA_200GBASE_DR4 }, { "200GBASE-FR4", ETHER_MEDIA_200GBASE_FR4 }, { "200GBASE-LR4", ETHER_MEDIA_200GBASE_LR4 }, { "200GBASE-ER4", ETHER_MEDIA_200GBASE_ER4 }, { "200GAUI-2", ETHER_MEDIA_200GAUI_2 }, { "200GBASE-KR2", ETHER_MEDIA_200GBASE_KR2 }, { "200GBASE-CR2", ETHER_MEDIA_200GBASE_CR2 }, { "200GBASE-SR2", ETHER_MEDIA_200GBASE_SR2 }, { "400GAUI-8", ETHER_MEDIA_400GAUI_8 }, { "400GBASE-KR8", ETHER_MEDIA_400GBASE_KR8 }, { "400GBASE-FR8", ETHER_MEDIA_400GBASE_FR8 }, { "400GBASE-LR8", ETHER_MEDIA_400GBASE_LR8 }, { "400GBASE-ER8", ETHER_MEDIA_400GBASE_ER8 }, { "400GAUI-4", ETHER_MEDIA_400GAUI_4 }, { "400GBASE-KR4", ETHER_MEDIA_400GBASE_KR4 }, { "400GBASE-CR4", ETHER_MEDIA_400GBASE_CR4 }, { "400GBASE-SR4", ETHER_MEDIA_400GBASE_SR4 }, { "400GBASE-DR4", ETHER_MEDIA_400GBASE_DR4 }, { "400GBASE-FR4", ETHER_MEDIA_400GBASE_FR4 } }; #define VALCNT(vals) (sizeof ((vals)) / sizeof (val_desc_t)) #define RESET_VAL ((uintptr_t)-1) #define UNSPEC_VAL ((uintptr_t)-2) /* * For the default, if defaults are not defined for the property, * pd_defval.vd_name should be null. If the driver has to be contacted for the * value, vd_name should be the empty string (""). Otherwise, dladm will * just print whatever is in the table. */ static prop_desc_t prop_table[] = { { "channel", { NULL, 0 }, NULL, 0, NULL, NULL, get_channel, NULL, 0, DATALINK_CLASS_PHYS, DL_WIFI }, { "powermode", { "off", DLADM_WLAN_PM_OFF }, dladm_wlan_powermode_vals, VALCNT(dladm_wlan_powermode_vals), set_powermode, NULL, get_powermode, NULL, 0, DATALINK_CLASS_PHYS, DL_WIFI }, { "radio", { "on", DLADM_WLAN_RADIO_ON }, dladm_wlan_radio_vals, VALCNT(dladm_wlan_radio_vals), set_radio, NULL, get_radio, NULL, 0, DATALINK_CLASS_PHYS, DL_WIFI }, { "linkmode", { "cm", DLADM_PART_CM_MODE }, dladm_part_linkmode_vals, VALCNT(dladm_part_linkmode_vals), set_public_prop, NULL, get_linkmode_prop, NULL, 0, DATALINK_CLASS_PART, DL_IB }, { "speed", { "", 0 }, NULL, 0, set_rate, get_rate_mod, get_rate, check_rate, 0, DATALINK_CLASS_PHYS, DATALINK_ANY_MEDIATYPE }, { "autopush", { "", 0 }, NULL, 0, set_public_prop, NULL, get_autopush, check_autopush, PD_CHECK_ALLOC, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, { "zone", { "", 0 }, NULL, 0, set_zone, NULL, get_zone, check_zone, PD_TEMPONLY|PD_CHECK_ALLOC, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, { "duplex", { "", 0 }, link_duplex_vals, VALCNT(link_duplex_vals), NULL, NULL, get_duplex, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "state", { "up", LINK_STATE_UP }, link_status_vals, VALCNT(link_status_vals), NULL, NULL, get_link_state, NULL, 0, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, { "adv_autoneg_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), set_public_prop, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "mtu", { "", 0 }, NULL, 0, set_public_prop, get_range, get_uint32, check_uint32, 0, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, { "flowctrl", { "", 0 }, link_flow_vals, VALCNT(link_flow_vals), set_public_prop, NULL, get_flowctl, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "adv_fec_cap", { "", LINK_FEC_AUTO }, link_fec_vals, VALCNT(link_fec_vals), NULL, NULL, get_bits, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "en_fec_cap", { "", LINK_FEC_AUTO }, link_fec_vals, VALCNT(link_fec_vals), set_public_bitprop, NULL, get_bits, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "secondary-macs", { "--", 0 }, NULL, 0, set_secondary_macs, NULL, get_secondary_macs, check_secondary_macs, PD_CHECK_ALLOC, DATALINK_CLASS_VNIC, DL_ETHER }, { "adv_400gfdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), NULL, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "en_400gfdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), set_public_prop, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "adv_200gfdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), NULL, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "en_200gfdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), set_public_prop, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "adv_100gfdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), NULL, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "en_100gfdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), set_public_prop, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "adv_50gfdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), NULL, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "en_50gfdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), set_public_prop, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "adv_40gfdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), NULL, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "en_40gfdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), set_public_prop, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "adv_25gfdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), NULL, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "en_25gfdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), set_public_prop, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "adv_10gfdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), NULL, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "en_10gfdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), set_public_prop, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "adv_5000fdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), NULL, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "en_5000fdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), set_public_prop, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "adv_2500fdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), NULL, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "en_2500fdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), set_public_prop, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "adv_1000fdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), NULL, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "en_1000fdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), set_public_prop, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "adv_1000hdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), NULL, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "en_1000hdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), set_public_prop, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "adv_100fdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), NULL, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "en_100fdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), set_public_prop, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "adv_100hdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), NULL, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "en_100hdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), set_public_prop, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "adv_10fdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), NULL, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "en_10fdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), set_public_prop, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "adv_10hdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), NULL, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "en_10hdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), set_public_prop, NULL, get_binary, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, { "maxbw", { "--", RESET_VAL }, NULL, 0, set_resource, NULL, get_maxbw, check_maxbw, PD_CHECK_ALLOC, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, { "cpus", { "--", RESET_VAL }, NULL, 0, set_resource, NULL, get_cpus, check_cpus, 0, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, { "cpus-effective", { "--", 0 }, NULL, 0, NULL, NULL, get_cpus, 0, 0, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, { "pool", { "--", RESET_VAL }, NULL, 0, set_resource, NULL, get_pool, check_pool, 0, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, { "pool-effective", { "--", 0 }, NULL, 0, NULL, NULL, get_pool, 0, 0, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, { "priority", { "high", MPL_RESET }, link_priority_vals, VALCNT(link_priority_vals), set_resource, NULL, get_priority, check_prop, 0, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, { "tagmode", { "vlanonly", LINK_TAGMODE_VLANONLY }, link_tagmode_vals, VALCNT(link_tagmode_vals), set_public_prop, NULL, get_tagmode, NULL, 0, DATALINK_CLASS_PHYS | DATALINK_CLASS_AGGR | DATALINK_CLASS_VNIC, DL_ETHER }, { "hoplimit", { "", 0 }, NULL, 0, set_public_prop, get_range, get_uint32, check_hoplimit, 0, DATALINK_CLASS_IPTUN, DATALINK_ANY_MEDIATYPE}, { "encaplimit", { "", 0 }, NULL, 0, set_public_prop, get_range, get_uint32, check_encaplim, 0, DATALINK_CLASS_IPTUN, DL_IPV6}, { "forward", { "1", 1 }, link_01_vals, VALCNT(link_01_vals), set_bridge_forward, NULL, get_bridge_forward, NULL, PD_AFTER_PERM, DATALINK_CLASS_ALL & ~DATALINK_CLASS_VNIC, DL_ETHER }, { "default_tag", { "1", 1 }, NULL, 0, set_bridge_pvid, NULL, get_bridge_pvid, check_bridge_pvid, 0, DATALINK_CLASS_PHYS|DATALINK_CLASS_AGGR| DATALINK_CLASS_ETHERSTUB|DATALINK_CLASS_SIMNET, DL_ETHER }, { "learn_limit", { "1000", 1000 }, NULL, 0, set_public_prop, NULL, get_uint32, check_uint32, 0, DATALINK_CLASS_PHYS|DATALINK_CLASS_AGGR| DATALINK_CLASS_ETHERSTUB|DATALINK_CLASS_SIMNET, DL_ETHER }, { "learn_decay", { "200", 200 }, NULL, 0, set_public_prop, NULL, get_uint32, check_uint32, 0, DATALINK_CLASS_PHYS|DATALINK_CLASS_AGGR| DATALINK_CLASS_ETHERSTUB|DATALINK_CLASS_SIMNET, DL_ETHER }, { "stp", { "1", 1 }, link_01_vals, VALCNT(link_01_vals), set_stp_prop, NULL, get_stp, NULL, PD_AFTER_PERM, DATALINK_CLASS_PHYS|DATALINK_CLASS_AGGR| DATALINK_CLASS_ETHERSTUB|DATALINK_CLASS_SIMNET, DL_ETHER }, { "stp_priority", { "128", 128 }, NULL, 0, set_stp_prop, NULL, get_stp, check_stp_prop, PD_AFTER_PERM, DATALINK_CLASS_PHYS|DATALINK_CLASS_AGGR| DATALINK_CLASS_ETHERSTUB|DATALINK_CLASS_SIMNET, DL_ETHER }, { "stp_cost", { "auto", 0 }, NULL, 0, set_stp_prop, NULL, get_stp, check_stp_prop, PD_AFTER_PERM, DATALINK_CLASS_PHYS|DATALINK_CLASS_AGGR| DATALINK_CLASS_ETHERSTUB|DATALINK_CLASS_SIMNET, DL_ETHER }, { "stp_edge", { "1", 1 }, link_01_vals, VALCNT(link_01_vals), set_stp_prop, NULL, get_stp, NULL, PD_AFTER_PERM, DATALINK_CLASS_PHYS|DATALINK_CLASS_AGGR| DATALINK_CLASS_ETHERSTUB|DATALINK_CLASS_SIMNET, DL_ETHER }, { "stp_p2p", { "auto", P2P_AUTO }, stp_p2p_vals, VALCNT(stp_p2p_vals), set_stp_prop, NULL, get_stp, NULL, PD_AFTER_PERM, DATALINK_CLASS_PHYS|DATALINK_CLASS_AGGR| DATALINK_CLASS_ETHERSTUB|DATALINK_CLASS_SIMNET, DL_ETHER }, { "stp_mcheck", { "0", 0 }, link_01_vals, VALCNT(link_01_vals), set_stp_prop, NULL, get_stp, check_stp_prop, PD_AFTER_PERM, DATALINK_CLASS_PHYS|DATALINK_CLASS_AGGR| DATALINK_CLASS_ETHERSTUB|DATALINK_CLASS_SIMNET, DL_ETHER }, { "protection", { "--", RESET_VAL }, link_protect_vals, VALCNT(link_protect_vals), set_resource, NULL, get_protection, check_prop, 0, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, { "promisc-filtered", { "on", 1 }, link_promisc_filtered_vals, VALCNT(link_promisc_filtered_vals), set_promisc_filtered, NULL, get_promisc_filtered, check_prop, 0, DATALINK_CLASS_VNIC, DATALINK_ANY_MEDIATYPE }, { "allowed-ips", { "--", 0 }, NULL, 0, set_resource, NULL, get_allowedips, check_allowedips, PD_CHECK_ALLOC, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, { "allowed-dhcp-cids", { "--", 0 }, NULL, 0, set_resource, NULL, get_allowedcids, check_allowedcids, PD_CHECK_ALLOC, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, { "rxrings", { "--", RESET_VAL }, NULL, 0, set_resource, get_rings_range, get_rxrings, check_rings, 0, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, { "rxrings-effective", { "--", 0 }, NULL, 0, NULL, NULL, get_rxrings, NULL, 0, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, { "txrings", { "--", RESET_VAL }, NULL, 0, set_resource, get_rings_range, get_txrings, check_rings, 0, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, { "txrings-effective", { "--", 0 }, NULL, 0, NULL, NULL, get_txrings, NULL, 0, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, { "txrings-available", { "", 0 }, NULL, 0, NULL, NULL, get_cntavail, NULL, 0, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, { "rxrings-available", { "", 0 }, NULL, 0, NULL, NULL, get_cntavail, NULL, 0, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, { "rxhwclnt-available", { "", 0 }, NULL, 0, NULL, NULL, get_cntavail, NULL, 0, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, { "txhwclnt-available", { "", 0 }, NULL, 0, NULL, NULL, get_cntavail, NULL, 0, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, { "media", { NULL, 0 }, NULL, 0, NULL, NULL, get_media, NULL, 0, DATALINK_CLASS_PHYS, DATALINK_ANY_MEDIATYPE } }; #define DLADM_MAX_PROPS (sizeof (prop_table) / sizeof (prop_desc_t)) static resource_prop_t rsrc_prop_table[] = { {"maxbw", extract_maxbw}, {"priority", extract_priority}, {"cpus", extract_cpus}, {"cpus-effective", extract_cpus}, {"pool", extract_pool}, {"pool-effective", extract_pool}, {"protection", extract_protection}, {"allowed-ips", extract_allowedips}, {"allowed-dhcp-cids", extract_allowedcids}, {"rxrings", extract_rxrings}, {"rxrings-effective", extract_rxrings}, {"txrings", extract_txrings}, {"txrings-effective", extract_txrings} }; #define DLADM_MAX_RSRC_PROP (sizeof (rsrc_prop_table) / \ sizeof (resource_prop_t)) /* * when retrieving private properties, we pass down a buffer with * DLADM_PROP_BUF_CHUNK of space for the driver to return the property value. */ #define DLADM_PROP_BUF_CHUNK 1024 static dladm_status_t i_dladm_set_linkprop_db(dladm_handle_t, datalink_id_t, const char *, char **, uint_t); static dladm_status_t i_dladm_get_linkprop_db(dladm_handle_t, datalink_id_t, const char *, char **, uint_t *); static dladm_status_t i_dladm_walk_linkprop_priv_db(dladm_handle_t, datalink_id_t, void *, int (*)(dladm_handle_t, datalink_id_t, const char *, void *)); static dladm_status_t i_dladm_set_single_prop(dladm_handle_t, datalink_id_t, datalink_class_t, uint32_t, prop_desc_t *, char **, uint_t, uint_t); static dladm_status_t i_dladm_set_linkprop(dladm_handle_t, datalink_id_t, const char *, char **, uint_t, uint_t, datalink_class_t, uint32_t); static dladm_status_t i_dladm_getset_defval(dladm_handle_t, prop_desc_t *, datalink_id_t, datalink_media_t, uint_t); /* * Unfortunately, MAX_SCAN_SUPPORT_RATES is too small to allow all * rates to be retrieved. However, we cannot increase it at this * time because it will break binary compatibility with unbundled * WiFi drivers and utilities. So for now we define an additional * constant, MAX_SUPPORT_RATES, to allow all rates to be retrieved. */ #define MAX_SUPPORT_RATES 64 #define AP_ANCHOR "[anchor]" #define AP_DELIMITER '.' static dladm_status_t check_prop(dladm_handle_t handle __unused, prop_desc_t *pdp, datalink_id_t linkid __unused, char **prop_val, uint_t *val_cntp, uint_t flags __unused, val_desc_t **vdpp, datalink_media_t media __unused) { uint_t i, j; uint_t val_cnt = *val_cntp; val_desc_t *vdp = *vdpp; for (j = 0; j < val_cnt; j++) { for (i = 0; i < pdp->pd_noptval; i++) { if (strcasecmp(prop_val[j], pdp->pd_optval[i].vd_name) == 0) { break; } } if (i == pdp->pd_noptval) return (DLADM_STATUS_BADVAL); (void) memcpy(&vdp[j], &pdp->pd_optval[i], sizeof (val_desc_t)); } return (DLADM_STATUS_OK); } static dladm_status_t i_dladm_set_single_prop(dladm_handle_t handle, datalink_id_t linkid, datalink_class_t class, uint32_t media, prop_desc_t *pdp, char **prop_val, uint_t val_cnt, uint_t flags) { dladm_status_t status = DLADM_STATUS_OK; val_desc_t *vdp = NULL; boolean_t needfree = B_FALSE; uint_t cnt, i; if (!(pdp->pd_class & class)) return (DLADM_STATUS_BADARG); if (!DATALINK_MEDIA_ACCEPTED(pdp->pd_dmedia, media)) return (DLADM_STATUS_BADARG); if ((flags & DLADM_OPT_PERSIST) && (pdp->pd_flags & PD_TEMPONLY)) return (DLADM_STATUS_TEMPONLY); if (!(flags & DLADM_OPT_ACTIVE)) return (DLADM_STATUS_OK); if (pdp->pd_set == NULL) return (DLADM_STATUS_PROPRDONLY); if (prop_val != NULL) { vdp = calloc(val_cnt, sizeof (val_desc_t)); if (vdp == NULL) return (DLADM_STATUS_NOMEM); if (pdp->pd_check != NULL) { needfree = ((pdp->pd_flags & PD_CHECK_ALLOC) != 0); status = pdp->pd_check(handle, pdp, linkid, prop_val, &val_cnt, flags, &vdp, media); } else if (pdp->pd_optval != NULL) { status = check_prop(handle, pdp, linkid, prop_val, &val_cnt, flags, &vdp, media); } else { status = DLADM_STATUS_BADARG; } if (status != DLADM_STATUS_OK) goto done; cnt = val_cnt; } else { boolean_t defval; if (pdp->pd_defval.vd_name == NULL) return (DLADM_STATUS_NOTSUP); cnt = 1; defval = (strlen(pdp->pd_defval.vd_name) > 0); if ((pdp->pd_flags & PD_CHECK_ALLOC) == 0 && !defval) { status = i_dladm_getset_defval(handle, pdp, linkid, media, flags); return (status); } vdp = calloc(1, sizeof (val_desc_t)); if (vdp == NULL) return (DLADM_STATUS_NOMEM); if (defval) { (void) memcpy(vdp, &pdp->pd_defval, sizeof (val_desc_t)); } else if (pdp->pd_check != NULL) { needfree = ((pdp->pd_flags & PD_CHECK_ALLOC) != 0); status = pdp->pd_check(handle, pdp, linkid, prop_val, &cnt, flags, &vdp, media); if (status != DLADM_STATUS_OK) goto done; } } if (pdp->pd_flags & PD_AFTER_PERM) status = (flags & DLADM_OPT_PERSIST) ? DLADM_STATUS_OK : DLADM_STATUS_PERMONLY; else status = pdp->pd_set(handle, pdp, linkid, vdp, cnt, flags, media); if (needfree) { for (i = 0; i < cnt; i++) free((void *)((val_desc_t *)vdp + i)->vd_val); } done: free(vdp); return (status); } static dladm_status_t i_dladm_set_linkprop(dladm_handle_t handle, datalink_id_t linkid, const char *prop_name, char **prop_val, uint_t val_cnt, uint_t flags, datalink_class_t class, uint32_t media) { uint_t i; boolean_t found = B_FALSE; dladm_status_t status = DLADM_STATUS_OK; for (i = 0; i < DLADM_MAX_PROPS; i++) { prop_desc_t *pdp = &prop_table[i]; dladm_status_t s; if (prop_name != NULL && (strcasecmp(prop_name, pdp->pd_name) != 0)) continue; found = B_TRUE; s = i_dladm_set_single_prop(handle, linkid, class, media, pdp, prop_val, val_cnt, flags); if (prop_name != NULL) { status = s; break; } else { /* * Some consumers of this function pass a * prop_name of NULL to indicate that all * properties should reset to their default * value. Some properties don't support a * default value and will return NOTSUP -- for * the purpose of resetting property values we * treat it the same as success. We need the * separate status variable 's' so that we can * record any failed calls in 'status' and * continue resetting the rest of the * properties. */ if (s != DLADM_STATUS_OK && s != DLADM_STATUS_NOTSUP) status = s; } } if (!found) { if (prop_name[0] == '_') { /* other private properties */ status = i_dladm_set_private_prop(handle, linkid, prop_name, prop_val, val_cnt, flags); } else { status = DLADM_STATUS_NOTFOUND; } } return (status); } /* * Set/reset link property for specific link */ dladm_status_t dladm_set_linkprop(dladm_handle_t handle, datalink_id_t linkid, const char *prop_name, char **prop_val, uint_t val_cnt, uint_t flags) { dladm_status_t status = DLADM_STATUS_OK; datalink_class_t class; uint32_t media; uint32_t link_flags; if ((linkid == DATALINK_INVALID_LINKID) || (flags == 0) || (prop_val == NULL && val_cnt > 0) || (prop_val != NULL && val_cnt == 0) || (prop_name == NULL && prop_val != NULL)) { return (DLADM_STATUS_BADARG); } /* * For well-known property names, normalize the case. We can also * save the property name itself, so that we can just do a pointer * equality test later and avoid an extra strcmp. */ if (prop_name != NULL) { uint_t i; for (i = 0; i < DLADM_MAX_PROPS; i++) { if (strcasecmp(prop_name, prop_table[i].pd_name) == 0) { prop_name = prop_table[i].pd_name; break; } } } /* * Check for valid link property against the flags passed * and set the link property when active flag is passed. */ status = dladm_datalink_id2info(handle, linkid, &link_flags, &class, &media, NULL, 0); if (status != DLADM_STATUS_OK) return (status); status = i_dladm_set_linkprop(handle, linkid, prop_name, prop_val, val_cnt, flags, class, media); if (status != DLADM_STATUS_OK) return (status); /* * Write an entry to the persistent configuration database if * and only if the user has requested the property to be * persistent and the link is a persistent link. */ if ((flags & DLADM_OPT_PERSIST) && (link_flags & DLMGMT_PERSIST)) { status = i_dladm_set_linkprop_db(handle, linkid, prop_name, prop_val, val_cnt); if (status == DLADM_STATUS_OK && (flags & DLADM_OPT_ACTIVE)) { prop_desc_t *pdp = prop_table; uint_t i; for (i = 0; i < DLADM_MAX_PROPS; i++, pdp++) { if (!(pdp->pd_flags & PD_AFTER_PERM)) continue; if (prop_name != NULL && prop_name != pdp->pd_name) continue; status = pdp->pd_set(handle, pdp, linkid, NULL, 0, flags, 0); } } } return (status); } /* * Walk all link properties of the given specific link. * * Note: this function currently lacks the ability to walk _all_ private * properties if the link, because there is no kernel interface to * retrieve all known private property names. Once such an interface * is added, this function should be fixed accordingly. */ dladm_status_t dladm_walk_linkprop(dladm_handle_t handle, datalink_id_t linkid, void *arg, int (*func)(dladm_handle_t, datalink_id_t, const char *, void *)) { dladm_status_t status; datalink_class_t class; uint_t media; uint_t i; if (linkid == DATALINK_INVALID_LINKID || func == NULL) return (DLADM_STATUS_BADARG); status = dladm_datalink_id2info(handle, linkid, NULL, &class, &media, NULL, 0); if (status != DLADM_STATUS_OK) return (status); /* public */ for (i = 0; i < DLADM_MAX_PROPS; i++) { if (!(prop_table[i].pd_class & class)) continue; if (!DATALINK_MEDIA_ACCEPTED(prop_table[i].pd_dmedia, media)) continue; if (func(handle, linkid, prop_table[i].pd_name, arg) == DLADM_WALK_TERMINATE) { break; } } /* private */ status = i_dladm_walk_linkprop_priv_db(handle, linkid, arg, func); return (status); } /* * Get linkprop of the given specific link. */ dladm_status_t dladm_get_linkprop(dladm_handle_t handle, datalink_id_t linkid, dladm_prop_type_t type, const char *prop_name, char **prop_val, uint_t *val_cntp) { dladm_status_t status = DLADM_STATUS_OK; datalink_class_t class; uint_t media; prop_desc_t *pdp; uint_t cnt, dld_flags = 0; uint_t i; uint_t perm_flags; if (type == DLADM_PROP_VAL_DEFAULT) dld_flags |= DLD_PROP_DEFAULT; else if (type == DLADM_PROP_VAL_MODIFIABLE) dld_flags |= DLD_PROP_POSSIBLE; if (linkid == DATALINK_INVALID_LINKID || prop_name == NULL || prop_val == NULL || val_cntp == NULL || *val_cntp == 0) return (DLADM_STATUS_BADARG); for (i = 0; i < DLADM_MAX_PROPS; i++) { if (strcasecmp(prop_name, prop_table[i].pd_name) == 0) { prop_name = prop_table[i].pd_name; break; } } if (i == DLADM_MAX_PROPS) { if (prop_name[0] == '_') { /* * private property. */ if (type == DLADM_PROP_VAL_PERSISTENT) return (i_dladm_get_linkprop_db(handle, linkid, prop_name, prop_val, val_cntp)); else return (i_dladm_get_priv_prop(handle, linkid, prop_name, prop_val, val_cntp, type, dld_flags)); } else { return (DLADM_STATUS_NOTFOUND); } } pdp = &prop_table[i]; status = dladm_datalink_id2info(handle, linkid, NULL, &class, &media, NULL, 0); if (status != DLADM_STATUS_OK) return (status); if (!(pdp->pd_class & class)) return (DLADM_STATUS_BADARG); if (!DATALINK_MEDIA_ACCEPTED(pdp->pd_dmedia, media)) return (DLADM_STATUS_BADARG); switch (type) { case DLADM_PROP_VAL_CURRENT: status = pdp->pd_get(handle, pdp, linkid, prop_val, val_cntp, media, dld_flags, &perm_flags); break; case DLADM_PROP_VAL_PERM: if (pdp->pd_set == NULL) { perm_flags = MAC_PROP_PERM_READ; } else { status = pdp->pd_get(handle, pdp, linkid, prop_val, val_cntp, media, dld_flags, &perm_flags); } *prop_val[0] = '\0'; *val_cntp = 1; if (status == DLADM_STATUS_OK) (void) dladm_perm2str(perm_flags, *prop_val); break; case DLADM_PROP_VAL_DEFAULT: /* * If defaults are not defined for the property, * pd_defval.vd_name should be null. If the driver * has to be contacted for the value, vd_name should * be the empty string (""). Otherwise, dladm will * just print whatever is in the table. */ if (pdp->pd_defval.vd_name == NULL) { status = DLADM_STATUS_NOTSUP; break; } if (strlen(pdp->pd_defval.vd_name) == 0) { status = pdp->pd_get(handle, pdp, linkid, prop_val, val_cntp, media, dld_flags, &perm_flags); } else { (void) strcpy(*prop_val, pdp->pd_defval.vd_name); } *val_cntp = 1; break; case DLADM_PROP_VAL_MODIFIABLE: if (pdp->pd_getmod != NULL) { status = pdp->pd_getmod(handle, pdp, linkid, prop_val, val_cntp, media, dld_flags, &perm_flags); break; } cnt = pdp->pd_noptval; if (cnt == 0) { status = DLADM_STATUS_NOTSUP; } else if (cnt > *val_cntp) { status = DLADM_STATUS_TOOSMALL; } else { for (i = 0; i < cnt; i++) { (void) strcpy(prop_val[i], pdp->pd_optval[i].vd_name); } *val_cntp = cnt; } break; case DLADM_PROP_VAL_PERSISTENT: if (pdp->pd_flags & PD_TEMPONLY) return (DLADM_STATUS_TEMPONLY); status = i_dladm_get_linkprop_db(handle, linkid, prop_name, prop_val, val_cntp); break; default: status = DLADM_STATUS_BADARG; break; } return (status); } /* * Get linkprop of the given specific link and run any possible conversion * of the values using the check function for the property. Fails if the * check function doesn't succeed for the property value. */ dladm_status_t dladm_get_linkprop_values(dladm_handle_t handle, datalink_id_t linkid, dladm_prop_type_t type, const char *prop_name, uint_t *ret_val, uint_t *val_cntp) { dladm_status_t status; datalink_class_t class; uint_t media; prop_desc_t *pdp; uint_t dld_flags; uint_t valc, i; char **prop_val; uint_t perm_flags; if (linkid == DATALINK_INVALID_LINKID || prop_name == NULL || ret_val == NULL || val_cntp == NULL || *val_cntp == 0) return (DLADM_STATUS_BADARG); for (pdp = prop_table; pdp < prop_table + DLADM_MAX_PROPS; pdp++) { if (strcasecmp(prop_name, pdp->pd_name) == 0) { prop_name = pdp->pd_name; break; } } if (pdp == prop_table + DLADM_MAX_PROPS) return (DLADM_STATUS_NOTFOUND); if (pdp->pd_flags & PD_CHECK_ALLOC) return (DLADM_STATUS_BADARG); status = dladm_datalink_id2info(handle, linkid, NULL, &class, &media, NULL, 0); if (status != DLADM_STATUS_OK) return (status); if (!(pdp->pd_class & class)) return (DLADM_STATUS_BADARG); if (!DATALINK_MEDIA_ACCEPTED(pdp->pd_dmedia, media)) return (DLADM_STATUS_BADARG); prop_val = malloc(*val_cntp * sizeof (*prop_val) + *val_cntp * DLADM_PROP_VAL_MAX); if (prop_val == NULL) return (DLADM_STATUS_NOMEM); for (valc = 0; valc < *val_cntp; valc++) prop_val[valc] = (char *)(prop_val + *val_cntp) + valc * DLADM_PROP_VAL_MAX; dld_flags = (type == DLADM_PROP_VAL_DEFAULT) ? DLD_PROP_DEFAULT : 0; switch (type) { case DLADM_PROP_VAL_CURRENT: status = pdp->pd_get(handle, pdp, linkid, prop_val, val_cntp, media, dld_flags, &perm_flags); break; case DLADM_PROP_VAL_DEFAULT: /* * If defaults are not defined for the property, * pd_defval.vd_name should be null. If the driver * has to be contacted for the value, vd_name should * be the empty string (""). Otherwise, dladm will * just print whatever is in the table. */ if (pdp->pd_defval.vd_name == NULL) { status = DLADM_STATUS_NOTSUP; break; } if (pdp->pd_defval.vd_name[0] != '\0') { *val_cntp = 1; *ret_val = pdp->pd_defval.vd_val; free(prop_val); return (DLADM_STATUS_OK); } status = pdp->pd_get(handle, pdp, linkid, prop_val, val_cntp, media, dld_flags, &perm_flags); break; case DLADM_PROP_VAL_PERSISTENT: if (pdp->pd_flags & PD_TEMPONLY) status = DLADM_STATUS_TEMPONLY; else status = i_dladm_get_linkprop_db(handle, linkid, prop_name, prop_val, val_cntp); break; default: status = DLADM_STATUS_BADARG; break; } if (status == DLADM_STATUS_OK) { if (pdp->pd_check != NULL) { val_desc_t *vdp; vdp = malloc(sizeof (val_desc_t) * *val_cntp); if (vdp == NULL) status = DLADM_STATUS_NOMEM; else status = pdp->pd_check(handle, pdp, linkid, prop_val, val_cntp, 0, &vdp, media); if (status == DLADM_STATUS_OK) { for (valc = 0; valc < *val_cntp; valc++) ret_val[valc] = vdp[valc].vd_val; } free(vdp); } else { for (valc = 0; valc < *val_cntp; valc++) { for (i = 0; i < pdp->pd_noptval; i++) { if (strcmp(pdp->pd_optval[i].vd_name, prop_val[valc]) == 0) { ret_val[valc] = pdp->pd_optval[i].vd_val; break; } } if (i == pdp->pd_noptval) { status = DLADM_STATUS_FAILED; break; } } } } free(prop_val); return (status); } static int i_dladm_init_one_prop(dladm_handle_t handle, datalink_id_t linkid, const char *prop_name, void *arg) { char *buf, **propvals; uint_t i, valcnt = DLADM_MAX_PROP_VALCNT; dladm_status_t status; dladm_linkprop_args_t *dla = arg; if ((buf = malloc((sizeof (char *) + DLADM_PROP_VAL_MAX) * DLADM_MAX_PROP_VALCNT)) == NULL) { return (DLADM_WALK_CONTINUE); } propvals = (char **)(void *)buf; for (i = 0; i < valcnt; i++) { propvals[i] = buf + sizeof (char *) * DLADM_MAX_PROP_VALCNT + i * DLADM_PROP_VAL_MAX; } if (dladm_get_linkprop(handle, linkid, DLADM_PROP_VAL_PERSISTENT, prop_name, propvals, &valcnt) != DLADM_STATUS_OK) { goto done; } status = dladm_set_linkprop(handle, linkid, prop_name, propvals, valcnt, dla->dla_flags | DLADM_OPT_ACTIVE); if (status != DLADM_STATUS_OK) dla->dla_status = status; done: if (buf != NULL) free(buf); return (DLADM_WALK_CONTINUE); } static int i_dladm_init_linkprop(dladm_handle_t handle, datalink_id_t linkid, void *arg __unused) { datalink_class_t class; dladm_status_t status; status = dladm_datalink_id2info(handle, linkid, NULL, &class, NULL, NULL, 0); if (status != DLADM_STATUS_OK) return (DLADM_WALK_TERMINATE); if ((class & (DATALINK_CLASS_VNIC | DATALINK_CLASS_VLAN)) == 0) (void) dladm_init_linkprop(handle, linkid, B_TRUE); return (DLADM_WALK_CONTINUE); } dladm_status_t dladm_init_linkprop(dladm_handle_t handle, datalink_id_t linkid, boolean_t any_media) { dladm_status_t status = DLADM_STATUS_OK; datalink_media_t dmedia; uint32_t media; dladm_linkprop_args_t *dla; dmedia = any_media ? DATALINK_ANY_MEDIATYPE : DL_WIFI; dla = malloc(sizeof (dladm_linkprop_args_t)); if (dla == NULL) return (DLADM_STATUS_NOMEM); dla->dla_flags = DLADM_OPT_BOOT; dla->dla_status = DLADM_STATUS_OK; if (linkid == DATALINK_ALL_LINKID) { (void) dladm_walk_datalink_id(i_dladm_init_linkprop, handle, NULL, DATALINK_CLASS_ALL, dmedia, DLADM_OPT_PERSIST); } else if (any_media || ((dladm_datalink_id2info(handle, linkid, NULL, NULL, &media, NULL, 0) == DLADM_STATUS_OK) && DATALINK_MEDIA_ACCEPTED(dmedia, media))) { (void) dladm_walk_linkprop(handle, linkid, (void *)dla, i_dladm_init_one_prop); status = dla->dla_status; } free(dla); return (status); } static dladm_status_t get_zone(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags) { char zone_name[ZONENAME_MAX]; zoneid_t zid; dladm_status_t status; if (flags != 0) return (DLADM_STATUS_NOTSUP); status = i_dladm_get_public_prop(handle, linkid, pdp->pd_name, flags, perm_flags, &zid, sizeof (zid)); if (status != DLADM_STATUS_OK) return (status); *val_cnt = 1; if (zid != GLOBAL_ZONEID) { if (getzonenamebyid(zid, zone_name, sizeof (zone_name)) < 0) { return (dladm_errno2status(errno)); } (void) strncpy(*prop_val, zone_name, DLADM_PROP_VAL_MAX); } else { *prop_val[0] = '\0'; } return (DLADM_STATUS_OK); } typedef int (*zone_get_devroot_t)(char *, char *, size_t); static int i_dladm_get_zone_dev(char *zone_name, char *dev, size_t devlen) { char root[MAXPATHLEN]; zone_get_devroot_t real_zone_get_devroot; void *dlhandle; void *sym; int ret; if ((dlhandle = dlopen("libzonecfg.so.1", RTLD_LAZY)) == NULL) return (-1); if ((sym = dlsym(dlhandle, "zone_get_devroot")) == NULL) { (void) dlclose(dlhandle); return (-1); } real_zone_get_devroot = (zone_get_devroot_t)sym; if ((ret = real_zone_get_devroot(zone_name, root, sizeof (root))) == 0) (void) snprintf(dev, devlen, "%s%s", root, "/dev"); (void) dlclose(dlhandle); return (ret); } static dladm_status_t i_dladm_update_deventry(dladm_handle_t handle, zoneid_t zid, datalink_id_t linkid, boolean_t add) { char path[MAXPATHLEN]; char name[MAXLINKNAMELEN]; di_prof_t prof = NULL; char zone_name[ZONENAME_MAX]; dladm_status_t status; int ret; if (getzonenamebyid(zid, zone_name, sizeof (zone_name)) < 0) return (dladm_errno2status(errno)); if (i_dladm_get_zone_dev(zone_name, path, sizeof (path)) != 0) return (dladm_errno2status(errno)); if (di_prof_init(path, &prof) != 0) return (dladm_errno2status(errno)); status = dladm_linkid2legacyname(handle, linkid, name, MAXLINKNAMELEN); if (status != DLADM_STATUS_OK) goto cleanup; if (add) ret = di_prof_add_dev(prof, name); else ret = di_prof_add_exclude(prof, name); if (ret != 0) { status = dladm_errno2status(errno); goto cleanup; } if (di_prof_commit(prof) != 0) status = dladm_errno2status(errno); cleanup: if (prof) di_prof_fini(prof); return (status); } static dladm_status_t set_zone(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, val_desc_t *vdp, uint_t val_cnt, uint_t flags, datalink_media_t media) { dladm_status_t status = DLADM_STATUS_OK; zoneid_t zid_old, zid_new; dld_ioc_zid_t *dzp; if (val_cnt != 1) return (DLADM_STATUS_BADVALCNT); dzp = (dld_ioc_zid_t *)vdp->vd_val; status = i_dladm_get_public_prop(handle, linkid, pdp->pd_name, flags, NULL, &zid_old, sizeof (zid_old)); if (status != DLADM_STATUS_OK) return (status); zid_new = dzp->diz_zid; if (zid_new == zid_old) return (DLADM_STATUS_OK); if ((status = set_public_prop(handle, pdp, linkid, vdp, val_cnt, flags, media)) != DLADM_STATUS_OK) return (status); /* * It is okay to fail to update the /dev entry (some vanity-named * links do not have a /dev entry). */ if (zid_old != GLOBAL_ZONEID) { (void) i_dladm_update_deventry(handle, zid_old, linkid, B_FALSE); } if (zid_new != GLOBAL_ZONEID) (void) i_dladm_update_deventry(handle, zid_new, linkid, B_TRUE); return (DLADM_STATUS_OK); } static dladm_status_t check_zone(dladm_handle_t handle __unused, prop_desc_t *pdp __unused, datalink_id_t linkid, char **prop_val, uint_t *val_cntp, uint_t flags __unused, val_desc_t **vdpp, datalink_media_t media __unused) { char *zone_name; zoneid_t zoneid; dladm_status_t status = DLADM_STATUS_OK; dld_ioc_zid_t *dzp; uint_t val_cnt = *val_cntp; val_desc_t *vdp = *vdpp; if (val_cnt != 1) return (DLADM_STATUS_BADVALCNT); dzp = malloc(sizeof (dld_ioc_zid_t)); if (dzp == NULL) return (DLADM_STATUS_NOMEM); zone_name = (prop_val != NULL) ? *prop_val : GLOBAL_ZONENAME; if ((zoneid = getzoneidbyname(zone_name)) == -1) { status = DLADM_STATUS_BADVAL; goto done; } if (zoneid != GLOBAL_ZONEID) { ushort_t flags; if (zone_getattr(zoneid, ZONE_ATTR_FLAGS, &flags, sizeof (flags)) < 0) { status = dladm_errno2status(errno); goto done; } if (!(flags & ZF_NET_EXCL)) { status = DLADM_STATUS_BADVAL; goto done; } } (void) memset(dzp, 0, sizeof (dld_ioc_zid_t)); dzp->diz_zid = zoneid; dzp->diz_linkid = linkid; vdp->vd_val = (uintptr_t)dzp; return (DLADM_STATUS_OK); done: free(dzp); return (status); } static dladm_status_t get_maxbw(dladm_handle_t handle, prop_desc_t *pdp __unused, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags) { mac_resource_props_t mrp; dladm_status_t status; status = i_dladm_get_public_prop(handle, linkid, "resource", flags, perm_flags, &mrp, sizeof (mrp)); if (status != DLADM_STATUS_OK) return (status); if ((mrp.mrp_mask & MRP_MAXBW) == 0) { *val_cnt = 0; return (DLADM_STATUS_OK); } (void) dladm_bw2str(mrp.mrp_maxbw, prop_val[0]); *val_cnt = 1; return (DLADM_STATUS_OK); } static dladm_status_t check_maxbw(dladm_handle_t handle __unused, prop_desc_t *pdp __unused, datalink_id_t linkid __unused, char **prop_val, uint_t *val_cntp, uint_t flags __unused, val_desc_t **vdpp, datalink_media_t media __unused) { uint64_t *maxbw; dladm_status_t status = DLADM_STATUS_OK; uint_t val_cnt = *val_cntp; val_desc_t *vdp = *vdpp; if (val_cnt != 1) return (DLADM_STATUS_BADVALCNT); maxbw = malloc(sizeof (uint64_t)); if (maxbw == NULL) return (DLADM_STATUS_NOMEM); status = dladm_str2bw(*prop_val, maxbw); if (status != DLADM_STATUS_OK) { free(maxbw); return (status); } if ((*maxbw < MRP_MAXBW_MINVAL) && (*maxbw != 0)) { free(maxbw); return (DLADM_STATUS_MINMAXBW); } vdp->vd_val = (uintptr_t)maxbw; return (DLADM_STATUS_OK); } dladm_status_t extract_maxbw(val_desc_t *vdp, uint_t cnt __unused, void *arg) { mac_resource_props_t *mrp = arg; if (vdp->vd_val == RESET_VAL) { mrp->mrp_maxbw = MRP_MAXBW_RESETVAL; } else { bcopy((char *)vdp->vd_val, &mrp->mrp_maxbw, sizeof (uint64_t)); } mrp->mrp_mask |= MRP_MAXBW; return (DLADM_STATUS_OK); } static dladm_status_t get_cpus(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags) { dladm_status_t status; mac_resource_props_t mrp; mac_propval_range_t *pv_range; int err; if (strcmp(pdp->pd_name, "cpus-effective") == 0) { status = i_dladm_get_public_prop(handle, linkid, "resource-effective", flags, perm_flags, &mrp, sizeof (mrp)); } else { status = i_dladm_get_public_prop(handle, linkid, "resource", flags, perm_flags, &mrp, sizeof (mrp)); } if (status != DLADM_STATUS_OK) return (status); if (mrp.mrp_ncpus > *val_cnt) return (DLADM_STATUS_TOOSMALL); if (mrp.mrp_ncpus == 0) { *val_cnt = 0; return (DLADM_STATUS_OK); } /* Sort CPU list and convert it to a mac_propval_range */ status = dladm_list2range(mrp.mrp_cpu, mrp.mrp_ncpus, MAC_PROPVAL_UINT32, &pv_range); if (status != DLADM_STATUS_OK) return (status); /* Write CPU ranges and individual CPUs */ err = dladm_range2strs(pv_range, prop_val); if (err != 0) { free(pv_range); return (dladm_errno2status(err)); } *val_cnt = pv_range->mpr_count; free(pv_range); return (DLADM_STATUS_OK); } static dladm_status_t check_cpus(dladm_handle_t handle, prop_desc_t *pdp __unused, datalink_id_t linkid, char **prop_val, uint_t *val_cntp, uint_t flags __unused, val_desc_t **vdpp, datalink_media_t media __unused) { int rc; uint_t i, j; long nproc = sysconf(_SC_NPROCESSORS_CONF); mac_resource_props_t mrp; mac_propval_range_t *pv_range; uint_t perm_flags; uint32_t ncpus; uint32_t *cpus = mrp.mrp_cpu; val_desc_t *vdp = *vdpp; val_desc_t *newvdp = NULL; uint_t val_cnt = *val_cntp; dladm_status_t status = DLADM_STATUS_OK; /* Get the current pool property */ status = i_dladm_get_public_prop(handle, linkid, "resource", 0, &perm_flags, &mrp, sizeof (mrp)); if (status == DLADM_STATUS_OK) { /* Can't set cpus if a pool is set */ if (strlen(mrp.mrp_pool) != 0) return (DLADM_STATUS_POOLCPU); } /* Read ranges and convert to mac_propval_range */ status = dladm_strs2range(prop_val, val_cnt, MAC_PROPVAL_UINT32, &pv_range); if (status != DLADM_STATUS_OK) goto done1; /* Convert mac_propval_range to a single CPU list */ ncpus = MRP_NCPUS; status = dladm_range2list(pv_range, cpus, &ncpus); if (status != DLADM_STATUS_OK) goto done1; /* * If a range of CPUs was entered, update value count and reallocate * the array of val_desc_t's. The array allocated was sized for * indvidual elements, but needs to be reallocated to accomodate the * expanded list of CPUs. */ if (val_cnt < ncpus) { newvdp = calloc(*val_cntp, sizeof (val_desc_t)); if (newvdp == NULL) { status = DLADM_STATUS_NOMEM; goto done1; } vdp = newvdp; } /* Check if all CPUs in the list are online */ for (i = 0; i < ncpus; i++) { if (cpus[i] >= (uint32_t)nproc) { status = DLADM_STATUS_BADCPUID; goto done2; } rc = p_online(cpus[i], P_STATUS); if (rc < 1) { status = DLADM_STATUS_CPUERR; goto done2; } if (rc != P_ONLINE) { status = DLADM_STATUS_CPUNOTONLINE; goto done2; } vdp[i].vd_val = (uintptr_t)cpus[i]; } /* Check for duplicate CPUs */ for (i = 0; i < *val_cntp; i++) { for (j = 0; j < *val_cntp; j++) { if (i != j && vdp[i].vd_val == vdp[j].vd_val) { status = DLADM_STATUS_BADVAL; goto done2; } } } /* Update *val_cntp and *vdpp if everything was OK */ if (val_cnt < ncpus) { *val_cntp = ncpus; free(*vdpp); *vdpp = newvdp; } status = DLADM_STATUS_OK; goto done1; done2: free(newvdp); done1: free(pv_range); return (status); } dladm_status_t extract_cpus(val_desc_t *vdp, uint_t cnt, void *arg) { mac_resource_props_t *mrp = arg; uint_t i; if (vdp[0].vd_val == RESET_VAL) { bzero(&mrp->mrp_cpus, sizeof (mac_cpus_t)); mrp->mrp_mask |= MRP_CPUS; return (DLADM_STATUS_OK); } for (i = 0; i < cnt; i++) mrp->mrp_cpu[i] = (uint32_t)vdp[i].vd_val; mrp->mrp_ncpus = cnt; mrp->mrp_mask |= (MRP_CPUS|MRP_CPUS_USERSPEC); mrp->mrp_fanout_mode = MCM_CPUS; mrp->mrp_rx_intr_cpu = -1; return (DLADM_STATUS_OK); } /* * Get the pool datalink property from the kernel. This is used * for both the user specified pool and effective pool properties. */ static dladm_status_t get_pool(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags) { mac_resource_props_t mrp; dladm_status_t status; if (strcmp(pdp->pd_name, "pool-effective") == 0) { status = i_dladm_get_public_prop(handle, linkid, "resource-effective", flags, perm_flags, &mrp, sizeof (mrp)); } else { status = i_dladm_get_public_prop(handle, linkid, "resource", flags, perm_flags, &mrp, sizeof (mrp)); } if (status != DLADM_STATUS_OK) return (status); if (strlen(mrp.mrp_pool) == 0) { (*prop_val)[0] = '\0'; } else { (void) snprintf(*prop_val, DLADM_PROP_VAL_MAX, "%s", mrp.mrp_pool); } *val_cnt = 1; return (DLADM_STATUS_OK); } static dladm_status_t check_pool(dladm_handle_t handle, prop_desc_t *pdp __unused, datalink_id_t linkid, char **prop_val, uint_t *val_cntp __unused, uint_t flags, val_desc_t **vdpp, datalink_media_t media __unused) { pool_conf_t *poolconf; pool_t *pool; mac_resource_props_t mrp; dladm_status_t status; uint_t perm_flags; char *poolname; val_desc_t *vdp = *vdpp; /* Get the current cpus property */ status = i_dladm_get_public_prop(handle, linkid, "resource", 0, &perm_flags, &mrp, sizeof (mrp)); if (status == DLADM_STATUS_OK) { /* Can't set pool if cpus are set */ if (mrp.mrp_ncpus != 0) return (DLADM_STATUS_POOLCPU); } poolname = malloc(sizeof (mrp.mrp_pool)); if (poolname == NULL) return (DLADM_STATUS_NOMEM); /* Check for pool's availability if not booting */ if ((flags & DLADM_OPT_BOOT) == 0) { /* Allocate and open pool configuration */ if ((poolconf = pool_conf_alloc()) == NULL) return (DLADM_STATUS_BADVAL); if (pool_conf_open(poolconf, pool_dynamic_location(), PO_RDONLY) != PO_SUCCESS) { pool_conf_free(poolconf); return (DLADM_STATUS_BADVAL); } /* Look for pool name */ if ((pool = pool_get_pool(poolconf, *prop_val)) == NULL) { pool_conf_free(poolconf); return (DLADM_STATUS_BADVAL); } pool_conf_free(poolconf); free(pool); } (void) strlcpy(poolname, *prop_val, sizeof (mrp.mrp_pool)); vdp->vd_val = (uintptr_t)poolname; return (DLADM_STATUS_OK); } dladm_status_t extract_pool(val_desc_t *vdp, uint_t cnt __unused, void *arg) { mac_resource_props_t *mrp = (mac_resource_props_t *)arg; if (vdp->vd_val == RESET_VAL) { bzero(&mrp->mrp_pool, sizeof (mrp->mrp_pool)); mrp->mrp_mask |= MRP_POOL; return (DLADM_STATUS_OK); } (void) strlcpy(mrp->mrp_pool, (char *)vdp->vd_val, sizeof (mrp->mrp_pool)); mrp->mrp_mask |= MRP_POOL; /* * Use MCM_CPUS since the fanout count is not user specified * and will be determined by the cpu list generated from the * pool. */ mrp->mrp_fanout_mode = MCM_CPUS; return (DLADM_STATUS_OK); } static dladm_status_t get_priority(dladm_handle_t handle, prop_desc_t *pdp __unused, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags) { mac_resource_props_t mrp; mac_priority_level_t pri; dladm_status_t status; status = i_dladm_get_public_prop(handle, linkid, "resource", flags, perm_flags, &mrp, sizeof (mrp)); if (status != DLADM_STATUS_OK) return (status); pri = ((mrp.mrp_mask & MRP_PRIORITY) == 0) ? MPL_HIGH : mrp.mrp_priority; (void) dladm_pri2str(pri, prop_val[0]); *val_cnt = 1; return (DLADM_STATUS_OK); } dladm_status_t extract_priority(val_desc_t *vdp, uint_t cnt, void *arg) { mac_resource_props_t *mrp = arg; if (cnt != 1) return (DLADM_STATUS_BADVAL); mrp->mrp_priority = (mac_priority_level_t)vdp->vd_val; mrp->mrp_mask |= MRP_PRIORITY; return (DLADM_STATUS_OK); } /* * Determines the size of the structure that needs to be sent to drivers * for retrieving the property range values. */ static int i_dladm_range_size(mac_propval_range_t *r, size_t *sz, uint_t *rcount) { uint_t count = r->mpr_count; *sz = sizeof (mac_propval_range_t); *rcount = count; --count; switch (r->mpr_type) { case MAC_PROPVAL_UINT32: *sz += (count * sizeof (mac_propval_uint32_range_t)); return (0); default: break; } *sz = 0; *rcount = 0; return (EINVAL); } static dladm_status_t check_rings(dladm_handle_t handle __unused, prop_desc_t *pdp __unused, datalink_id_t linkid __unused, char **prop_val, uint_t *val_cntp, uint_t flags __unused, val_desc_t **vp, datalink_media_t media __unused) { uint_t val_cnt = *val_cntp; val_desc_t *v = *vp; if (val_cnt != 1) return (DLADM_STATUS_BADVAL); if (strncasecmp(prop_val[0], "hw", strlen("hw")) == 0) { v->vd_val = UNSPEC_VAL; } else if (strncasecmp(prop_val[0], "sw", strlen("sw")) == 0) { v->vd_val = 0; } else { v->vd_val = strtoul(prop_val[0], NULL, 0); if (v->vd_val == 0) return (DLADM_STATUS_BADVAL); } return (DLADM_STATUS_OK); } static dladm_status_t get_rings_range(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags __unused) { dld_ioc_macprop_t *dip; dladm_status_t status = DLADM_STATUS_OK; mac_propval_range_t *rangep; size_t sz; mac_propval_uint32_range_t *ur; sz = sizeof (mac_propval_range_t); if ((dip = i_dladm_buf_alloc_by_name(sz, linkid, pdp->pd_name, flags, &status)) == NULL) return (status); status = i_dladm_macprop(handle, dip, B_FALSE); if (status != DLADM_STATUS_OK) return (status); rangep = (mac_propval_range_t *)(void *)&dip->pr_val; *val_cnt = 1; ur = &rangep->mpr_range_uint32[0]; /* This is the case where the dev doesn't have any rings/groups */ if (rangep->mpr_count == 0) { (*prop_val)[0] = '\0'; /* * This is the case where the dev supports rings, but static * grouping. */ } else if (ur->mpur_min == ur->mpur_max && ur->mpur_max == 0) { (void) snprintf(prop_val[0], DLADM_PROP_VAL_MAX, "sw,hw"); /* * This is the case where the dev supports rings and dynamic * grouping, but has only one value (say 2 rings and 2 groups). */ } else if (ur->mpur_min == ur->mpur_max) { (void) snprintf(prop_val[0], DLADM_PROP_VAL_MAX, "sw,hw,%d", ur->mpur_min); /* * This is the case where the dev supports rings and dynamic * grouping and has a range of rings. */ } else { (void) snprintf(prop_val[0], DLADM_PROP_VAL_MAX, "sw,hw,<%ld-%ld>", ur->mpur_min, ur->mpur_max); } free(dip); return (status); } static dladm_status_t get_rxrings(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags) { mac_resource_props_t mrp; dladm_status_t status; uint32_t nrings = 0; /* * Get the number of (effective-)rings from the resource property. */ if (strcmp(pdp->pd_name, "rxrings-effective") == 0) { status = i_dladm_get_public_prop(handle, linkid, "resource-effective", flags, perm_flags, &mrp, sizeof (mrp)); } else { /* * Get the permissions from the "rxrings" property. */ status = i_dladm_get_public_prop(handle, linkid, "rxrings", flags, perm_flags, NULL, 0); if (status != DLADM_STATUS_OK) return (status); status = i_dladm_get_public_prop(handle, linkid, "resource", flags, NULL, &mrp, sizeof (mrp)); } if (status != DLADM_STATUS_OK) return (status); if ((mrp.mrp_mask & MRP_RX_RINGS) == 0) { *val_cnt = 0; return (DLADM_STATUS_OK); } nrings = mrp.mrp_nrxrings; *val_cnt = 1; if (mrp.mrp_mask & MRP_RXRINGS_UNSPEC) (void) snprintf(*prop_val, DLADM_PROP_VAL_MAX, "hw"); else if (nrings == 0) (void) snprintf(*prop_val, DLADM_PROP_VAL_MAX, "sw"); else (void) snprintf(*prop_val, DLADM_PROP_VAL_MAX, "%ld", nrings); return (DLADM_STATUS_OK); } dladm_status_t extract_rxrings(val_desc_t *vdp, uint_t cnt __unused, void *arg) { mac_resource_props_t *mrp = (mac_resource_props_t *)arg; mrp->mrp_nrxrings = 0; if (vdp->vd_val == RESET_VAL) mrp->mrp_mask = MRP_RINGS_RESET; else if (vdp->vd_val == UNSPEC_VAL) mrp->mrp_mask = MRP_RXRINGS_UNSPEC; else mrp->mrp_nrxrings = vdp->vd_val; mrp->mrp_mask |= MRP_RX_RINGS; return (DLADM_STATUS_OK); } static dladm_status_t get_txrings(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags) { mac_resource_props_t mrp; dladm_status_t status; uint32_t nrings = 0; /* * Get the number of (effective-)rings from the resource property. */ if (strcmp(pdp->pd_name, "txrings-effective") == 0) { status = i_dladm_get_public_prop(handle, linkid, "resource-effective", flags, perm_flags, &mrp, sizeof (mrp)); } else { /* * Get the permissions from the "txrings" property. */ status = i_dladm_get_public_prop(handle, linkid, "txrings", flags, perm_flags, NULL, 0); if (status != DLADM_STATUS_OK) return (status); /* * Get the number of rings from the "resource" property. */ status = i_dladm_get_public_prop(handle, linkid, "resource", flags, NULL, &mrp, sizeof (mrp)); } if (status != DLADM_STATUS_OK) return (status); if ((mrp.mrp_mask & MRP_TX_RINGS) == 0) { *val_cnt = 0; return (DLADM_STATUS_OK); } nrings = mrp.mrp_ntxrings; *val_cnt = 1; if (mrp.mrp_mask & MRP_TXRINGS_UNSPEC) (void) snprintf(*prop_val, DLADM_PROP_VAL_MAX, "hw"); else if (nrings == 0) (void) snprintf(*prop_val, DLADM_PROP_VAL_MAX, "sw"); else (void) snprintf(*prop_val, DLADM_PROP_VAL_MAX, "%ld", nrings); return (DLADM_STATUS_OK); } dladm_status_t extract_txrings(val_desc_t *vdp, uint_t cnt __unused, void *arg) { mac_resource_props_t *mrp = (mac_resource_props_t *)arg; mrp->mrp_ntxrings = 0; if (vdp->vd_val == RESET_VAL) mrp->mrp_mask = MRP_RINGS_RESET; else if (vdp->vd_val == UNSPEC_VAL) mrp->mrp_mask = MRP_TXRINGS_UNSPEC; else mrp->mrp_ntxrings = vdp->vd_val; mrp->mrp_mask |= MRP_TX_RINGS; return (DLADM_STATUS_OK); } static dladm_status_t get_cntavail(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media, uint_t flags, uint_t *perm_flags) { if (flags & DLD_PROP_DEFAULT) return (DLADM_STATUS_NOTDEFINED); return (get_uint32(handle, pdp, linkid, prop_val, val_cnt, media, flags, perm_flags)); } static dladm_status_t set_resource(dladm_handle_t handle, prop_desc_t *pdp __unused, datalink_id_t linkid, val_desc_t *vdp, uint_t val_cnt, uint_t flags, datalink_media_t media __unused) { mac_resource_props_t mrp; dladm_status_t status = DLADM_STATUS_OK; dld_ioc_macprop_t *dip; uint_t i; bzero(&mrp, sizeof (mac_resource_props_t)); dip = i_dladm_buf_alloc_by_name(0, linkid, "resource", flags, &status); if (dip == NULL) return (status); for (i = 0; i < DLADM_MAX_RSRC_PROP; i++) { resource_prop_t *rp = &rsrc_prop_table[i]; if (strcmp(pdp->pd_name, rp->rp_name) != 0) continue; status = rp->rp_extract(vdp, val_cnt, &mrp); if (status != DLADM_STATUS_OK) goto done; break; } (void) memcpy(dip->pr_val, &mrp, dip->pr_valsize); status = i_dladm_macprop(handle, dip, B_TRUE); done: free(dip); return (status); } static dladm_status_t get_protection(dladm_handle_t handle, prop_desc_t *pdp __unused, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags) { mac_resource_props_t mrp; mac_protect_t *p; dladm_status_t status; uint32_t i, cnt = 0, setbits[32]; status = i_dladm_get_public_prop(handle, linkid, "resource", flags, perm_flags, &mrp, sizeof (mrp)); if (status != DLADM_STATUS_OK) return (status); p = &mrp.mrp_protect; if ((mrp.mrp_mask & MRP_PROTECT) == 0) { *val_cnt = 0; return (DLADM_STATUS_OK); } dladm_find_setbits32(p->mp_types, setbits, &cnt); if (cnt > *val_cnt) return (DLADM_STATUS_BADVALCNT); for (i = 0; i < cnt; i++) (void) dladm_protect2str(setbits[i], prop_val[i]); *val_cnt = cnt; return (DLADM_STATUS_OK); } static dladm_status_t get_allowedips(dladm_handle_t handle, prop_desc_t *pdp __unused, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags) { mac_resource_props_t mrp; mac_protect_t *p; dladm_status_t status; uint_t i; status = i_dladm_get_public_prop(handle, linkid, "resource", flags, perm_flags, &mrp, sizeof (mrp)); if (status != DLADM_STATUS_OK) return (status); p = &mrp.mrp_protect; if (p->mp_ipaddrcnt == 0) { *val_cnt = 0; return (DLADM_STATUS_OK); } if (p->mp_ipaddrcnt > *val_cnt) return (DLADM_STATUS_BADVALCNT); for (i = 0; i < p->mp_ipaddrcnt; i++) { int len; if (p->mp_ipaddrs[i].ip_version == IPV4_VERSION) { ipaddr_t v4addr; v4addr = V4_PART_OF_V6(p->mp_ipaddrs[i].ip_addr); (void) dladm_ipv4addr2str(&v4addr, prop_val[i]); } else { (void) dladm_ipv6addr2str(&p->mp_ipaddrs[i].ip_addr, prop_val[i]); } len = strlen(prop_val[i]); (void) sprintf(prop_val[i] + len, "/%d", p->mp_ipaddrs[i].ip_netmask); } *val_cnt = p->mp_ipaddrcnt; return (DLADM_STATUS_OK); } dladm_status_t extract_protection(val_desc_t *vdp, uint_t cnt, void *arg) { mac_resource_props_t *mrp = arg; uint32_t types = 0; uint_t i; for (i = 0; i < cnt; i++) types |= (uint32_t)vdp[i].vd_val; mrp->mrp_protect.mp_types = types; mrp->mrp_mask |= MRP_PROTECT; return (DLADM_STATUS_OK); } dladm_status_t extract_allowedips(val_desc_t *vdp, uint_t cnt, void *arg) { mac_resource_props_t *mrp = arg; mac_protect_t *p = &mrp->mrp_protect; uint_t i; if (vdp->vd_val == 0) { cnt = (uint_t)-1; } else { for (i = 0; i < cnt; i++) { bcopy((void *)vdp[i].vd_val, &p->mp_ipaddrs[i], sizeof (mac_ipaddr_t)); } } p->mp_ipaddrcnt = cnt; mrp->mrp_mask |= MRP_PROTECT; return (DLADM_STATUS_OK); } static dladm_status_t check_single_ip(char *buf, mac_ipaddr_t *addr) { dladm_status_t status; ipaddr_t v4addr; in6_addr_t v6addr; boolean_t isv4 = B_TRUE; char *p; uint32_t mask = 0; /* * If the IP address is in CIDR format, parse the bits component * seperately. An address in this style will be used to indicate an * entire subnet, so it must be a network number with no host address. */ if ((p = strchr(buf, '/')) != NULL) { char *end = NULL; *p++ = '\0'; if (!isdigit(*p)) return (DLADM_STATUS_INVALID_IP); mask = strtol(p, &end, 10); if (end != NULL && *end != '\0') return (DLADM_STATUS_INVALID_IP); if (mask > 128|| mask < 1) return (DLADM_STATUS_INVALID_IP); } status = dladm_str2ipv4addr(buf, &v4addr); if (status == DLADM_STATUS_INVALID_IP) { status = dladm_str2ipv6addr(buf, &v6addr); if (status == DLADM_STATUS_OK) isv4 = B_FALSE; } if (status != DLADM_STATUS_OK) return (status); if (isv4) { if (v4addr == INADDR_ANY) return (DLADM_STATUS_INVALID_IP); IN6_IPADDR_TO_V4MAPPED(v4addr, &addr->ip_addr); addr->ip_version = IPV4_VERSION; if (p != NULL) { uint32_t smask; /* * Validate the netmask is in the proper range for v4 */ if (mask > 32 || mask < 1) return (DLADM_STATUS_INVALID_IP); /* * We have a CIDR style address, confirm that only the * network number is set. */ smask = 0xFFFFFFFFu << (32 - mask); if (htonl(v4addr) & ~smask) return (DLADM_STATUS_INVALID_IP); } else { mask = 32; } addr->ip_netmask = mask; } else { if (IN6_IS_ADDR_UNSPECIFIED(&v6addr)) return (DLADM_STATUS_INVALID_IP); if (IN6_IS_ADDR_V4MAPPED_ANY(&v6addr)) return (DLADM_STATUS_INVALID_IP); if (p != NULL) { int i, off, high; /* * Note that the address in our buffer is stored in * network byte order. */ off = 0; for (i = 3; i >= 0; i--) { high = ffsl(ntohl(v6addr._S6_un._S6_u32[i])); if (high != 0) break; off += 32; } off += high; if (128 - off >= (int)mask) return (DLADM_STATUS_INVALID_IP); } else { mask = 128; } addr->ip_addr = v6addr; addr->ip_version = IPV6_VERSION; addr->ip_netmask = mask; } return (DLADM_STATUS_OK); } static dladm_status_t check_allowedips(dladm_handle_t handle __unused, prop_desc_t *pdp __unused, datalink_id_t linkid __unused, char **prop_val, uint_t *val_cntp, uint_t flags __unused, val_desc_t **vdpp, datalink_media_t media __unused) { dladm_status_t status; mac_ipaddr_t *addr; uint_t i; uint_t val_cnt = *val_cntp; val_desc_t *vdp = *vdpp; if (val_cnt > MPT_MAXIPADDR) return (DLADM_STATUS_BADVALCNT); for (i = 0; i < val_cnt; i++) { if ((addr = calloc(1, sizeof (mac_ipaddr_t))) == NULL) { status = DLADM_STATUS_NOMEM; goto fail; } vdp[i].vd_val = (uintptr_t)addr; status = check_single_ip(prop_val[i], addr); if (status != DLADM_STATUS_OK) goto fail; } return (DLADM_STATUS_OK); fail: for (i = 0; i < val_cnt; i++) { free((void *)vdp[i].vd_val); vdp[i].vd_val = 0; } return (status); } static void dladm_cid2str(mac_dhcpcid_t *cid, char *buf) { char tmp_buf[DLADM_STRSIZE]; uint_t hexlen; switch (cid->dc_form) { case CIDFORM_TYPED: { uint16_t duidtype, hwtype; uint32_t timestamp, ennum; char *lladdr; if (cid->dc_len < sizeof (duidtype)) goto fail; bcopy(cid->dc_id, &duidtype, sizeof (duidtype)); duidtype = ntohs(duidtype); switch (duidtype) { case DHCPV6_DUID_LLT: { duid_llt_t llt; if (cid->dc_len < sizeof (llt)) goto fail; bcopy(cid->dc_id, &llt, sizeof (llt)); hwtype = ntohs(llt.dllt_hwtype); timestamp = ntohl(llt.dllt_time); lladdr = _link_ntoa(cid->dc_id + sizeof (llt), NULL, cid->dc_len - sizeof (llt), IFT_OTHER); if (lladdr == NULL) goto fail; (void) snprintf(buf, DLADM_STRSIZE, "%d.%d.%d.%s", duidtype, hwtype, timestamp, lladdr); free(lladdr); break; } case DHCPV6_DUID_EN: { duid_en_t en; if (cid->dc_len < sizeof (en)) goto fail; bcopy(cid->dc_id, &en, sizeof (en)); ennum = DHCPV6_GET_ENTNUM(&en); hexlen = sizeof (tmp_buf); if (octet_to_hexascii(cid->dc_id + sizeof (en), cid->dc_len - sizeof (en), tmp_buf, &hexlen) != 0) goto fail; (void) snprintf(buf, DLADM_STRSIZE, "%d.%d.%s", duidtype, ennum, tmp_buf); break; } case DHCPV6_DUID_LL: { duid_ll_t ll; if (cid->dc_len < sizeof (ll)) goto fail; bcopy(cid->dc_id, &ll, sizeof (ll)); hwtype = ntohs(ll.dll_hwtype); lladdr = _link_ntoa(cid->dc_id + sizeof (ll), NULL, cid->dc_len - sizeof (ll), IFT_OTHER); if (lladdr == NULL) goto fail; (void) snprintf(buf, DLADM_STRSIZE, "%d.%d.%s", duidtype, hwtype, lladdr); free(lladdr); break; } default: { hexlen = sizeof (tmp_buf); if (octet_to_hexascii(cid->dc_id + sizeof (duidtype), cid->dc_len - sizeof (duidtype), tmp_buf, &hexlen) != 0) goto fail; (void) snprintf(buf, DLADM_STRSIZE, "%d.%s", duidtype, tmp_buf); } } break; } case CIDFORM_HEX: { hexlen = sizeof (tmp_buf); if (octet_to_hexascii(cid->dc_id, cid->dc_len, tmp_buf, &hexlen) != 0) goto fail; (void) snprintf(buf, DLADM_STRSIZE, "0x%s", tmp_buf); break; } case CIDFORM_STR: { uint_t i; for (i = 0; i < cid->dc_len; i++) { if (!isprint(cid->dc_id[i])) goto fail; } (void) snprintf(buf, DLADM_STRSIZE, "%s", cid->dc_id); break; } default: goto fail; } return; fail: (void) snprintf(buf, DLADM_STRSIZE, ""); } static dladm_status_t dladm_str2cid(char *buf, mac_dhcpcid_t *cid) { char *ptr = buf; char tmp_buf[DLADM_STRSIZE]; uint_t hexlen, cidlen; bzero(cid, sizeof (*cid)); if (isdigit(*ptr) && ptr[strspn(ptr, "0123456789")] == '.') { char *cp; ulong_t duidtype; ulong_t subtype = 0; ulong_t timestamp; uchar_t *lladdr; int addrlen; errno = 0; duidtype = strtoul(ptr, &cp, 0); if (ptr == cp || errno != 0 || *cp != '.' || duidtype > USHRT_MAX) return (DLADM_STATUS_BADARG); ptr = cp + 1; if (duidtype != 0 && duidtype <= DHCPV6_DUID_LL) { errno = 0; subtype = strtoul(ptr, &cp, 0); if (ptr == cp || errno != 0 || *cp != '.') return (DLADM_STATUS_BADARG); ptr = cp + 1; } switch (duidtype) { case DHCPV6_DUID_LLT: { duid_llt_t llt; errno = 0; timestamp = strtoul(ptr, &cp, 0); if (ptr == cp || errno != 0 || *cp != '.') return (DLADM_STATUS_BADARG); ptr = cp + 1; lladdr = _link_aton(ptr, &addrlen); if (lladdr == NULL) return (DLADM_STATUS_BADARG); cidlen = sizeof (llt) + addrlen; if (cidlen > sizeof (cid->dc_id)) { free(lladdr); return (DLADM_STATUS_TOOSMALL); } llt.dllt_dutype = htons(duidtype); llt.dllt_hwtype = htons(subtype); llt.dllt_time = htonl(timestamp); bcopy(&llt, cid->dc_id, sizeof (llt)); bcopy(lladdr, cid->dc_id + sizeof (llt), addrlen); free(lladdr); break; } case DHCPV6_DUID_LL: { duid_ll_t ll; lladdr = _link_aton(ptr, &addrlen); if (lladdr == NULL) return (DLADM_STATUS_BADARG); cidlen = sizeof (ll) + addrlen; if (cidlen > sizeof (cid->dc_id)) { free(lladdr); return (DLADM_STATUS_TOOSMALL); } ll.dll_dutype = htons(duidtype); ll.dll_hwtype = htons(subtype); bcopy(&ll, cid->dc_id, sizeof (ll)); bcopy(lladdr, cid->dc_id + sizeof (ll), addrlen); free(lladdr); break; } default: { hexlen = sizeof (tmp_buf); if (hexascii_to_octet(ptr, strlen(ptr), tmp_buf, &hexlen) != 0) return (DLADM_STATUS_BADARG); if (duidtype == DHCPV6_DUID_EN) { duid_en_t en; en.den_dutype = htons(duidtype); DHCPV6_SET_ENTNUM(&en, subtype); cidlen = sizeof (en) + hexlen; if (cidlen > sizeof (cid->dc_id)) return (DLADM_STATUS_TOOSMALL); bcopy(&en, cid->dc_id, sizeof (en)); bcopy(tmp_buf, cid->dc_id + sizeof (en), hexlen); } else { uint16_t dutype = htons(duidtype); cidlen = sizeof (dutype) + hexlen; if (cidlen > sizeof (cid->dc_id)) return (DLADM_STATUS_TOOSMALL); bcopy(&dutype, cid->dc_id, sizeof (dutype)); bcopy(tmp_buf, cid->dc_id + sizeof (dutype), hexlen); } break; } } cid->dc_form = CIDFORM_TYPED; } else if (strncasecmp("0x", ptr, 2) == 0 && ptr[2] != '\0') { ptr += 2; hexlen = sizeof (tmp_buf); if (hexascii_to_octet(ptr, strlen(ptr), tmp_buf, &hexlen) != 0) { return (DLADM_STATUS_BADARG); } cidlen = hexlen; if (cidlen > sizeof (cid->dc_id)) return (DLADM_STATUS_TOOSMALL); bcopy(tmp_buf, cid->dc_id, cidlen); cid->dc_form = CIDFORM_HEX; } else { cidlen = strlen(ptr); if (cidlen > sizeof (cid->dc_id)) return (DLADM_STATUS_TOOSMALL); bcopy(ptr, cid->dc_id, cidlen); cid->dc_form = CIDFORM_STR; } cid->dc_len = cidlen; return (DLADM_STATUS_OK); } static dladm_status_t get_allowedcids(dladm_handle_t handle, prop_desc_t *pdp __unused, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags) { mac_resource_props_t mrp; mac_protect_t *p; dladm_status_t status; uint_t i; status = i_dladm_get_public_prop(handle, linkid, "resource", flags, perm_flags, &mrp, sizeof (mrp)); if (status != DLADM_STATUS_OK) return (status); p = &mrp.mrp_protect; if (p->mp_cidcnt == 0) { *val_cnt = 0; return (DLADM_STATUS_OK); } if (p->mp_cidcnt > *val_cnt) return (DLADM_STATUS_BADVALCNT); for (i = 0; i < p->mp_cidcnt; i++) { mac_dhcpcid_t *cid = &p->mp_cids[i]; dladm_cid2str(cid, prop_val[i]); } *val_cnt = p->mp_cidcnt; return (DLADM_STATUS_OK); } dladm_status_t extract_allowedcids(val_desc_t *vdp, uint_t cnt, void *arg) { mac_resource_props_t *mrp = arg; mac_protect_t *p = &mrp->mrp_protect; uint_t i; if (vdp->vd_val == 0) { cnt = (uint_t)-1; } else { for (i = 0; i < cnt; i++) { bcopy((void *)vdp[i].vd_val, &p->mp_cids[i], sizeof (mac_dhcpcid_t)); } } p->mp_cidcnt = cnt; mrp->mrp_mask |= MRP_PROTECT; return (DLADM_STATUS_OK); } static dladm_status_t check_allowedcids(dladm_handle_t handle __unused, prop_desc_t *pdp __unused, datalink_id_t linkid __unused, char **prop_val, uint_t *val_cntp, uint_t flags __unused, val_desc_t **vdpp, datalink_media_t media __unused) { dladm_status_t status; mac_dhcpcid_t *cid; uint_t i; uint_t val_cnt = *val_cntp; val_desc_t *vdp = *vdpp; if (val_cnt > MPT_MAXCID) return (DLADM_STATUS_BADVALCNT); for (i = 0; i < val_cnt; i++) { if ((cid = calloc(1, sizeof (mac_dhcpcid_t))) == NULL) { status = DLADM_STATUS_NOMEM; goto fail; } vdp[i].vd_val = (uintptr_t)cid; status = dladm_str2cid(prop_val[i], cid); if (status != DLADM_STATUS_OK) goto fail; } return (DLADM_STATUS_OK); fail: for (i = 0; i < val_cnt; i++) { free((void *)vdp[i].vd_val); vdp[i].vd_val = 0; } return (status); } static dladm_status_t get_secondary_macs(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags) { mac_secondary_addr_t sa; dladm_status_t status; uint_t i; status = i_dladm_get_public_prop(handle, linkid, pdp->pd_name, flags, perm_flags, &sa, sizeof (sa)); if (status != DLADM_STATUS_OK) return (status); if (sa.ms_addrcnt > *val_cnt) return (DLADM_STATUS_BADVALCNT); for (i = 0; i < sa.ms_addrcnt; i++) { if (dladm_aggr_macaddr2str( (const unsigned char *)&sa.ms_addrs[i], prop_val[i]) == NULL) { *val_cnt = i; return (DLADM_STATUS_NOMEM); } } *val_cnt = sa.ms_addrcnt; return (DLADM_STATUS_OK); } static dladm_status_t check_secondary_macs(dladm_handle_t handle __unused, prop_desc_t *pdp __unused, datalink_id_t linkid __unused, char **prop_val, uint_t *val_cntp, uint_t flags __unused, val_desc_t **vdpp, datalink_media_t media __unused) { dladm_status_t status; uchar_t *addr; uint_t len = 0; uint_t i; uint_t val_cnt = *val_cntp; val_desc_t *vdp = *vdpp; if (val_cnt >= MPT_MAXMACADDR) return (DLADM_STATUS_BADVALCNT); for (i = 0; i < val_cnt; i++) { addr = _link_aton(prop_val[i], (int *)&len); if (addr == NULL) { if (len == (uint_t)-1) status = DLADM_STATUS_MACADDRINVAL; else status = DLADM_STATUS_NOMEM; goto fail; } vdp[i].vd_val = (uintptr_t)addr; } return (DLADM_STATUS_OK); fail: for (i = 0; i < val_cnt; i++) { free((void *)vdp[i].vd_val); vdp[i].vd_val = 0; } return (status); } static dladm_status_t set_secondary_macs(dladm_handle_t handle, prop_desc_t *pd __unused, datalink_id_t linkid, val_desc_t *vdp, uint_t val_cnt, uint_t flags __unused, datalink_media_t media __unused) { dladm_status_t status; dld_ioc_macprop_t *dip; uint_t i; mac_secondary_addr_t msa; dip = i_dladm_buf_alloc_by_name(0, linkid, "secondary-macs", 0, &status); if (dip == NULL) return (status); if (vdp->vd_val == 0) { val_cnt = (uint_t)-1; } else { for (i = 0; i < val_cnt; i++) { bcopy((void *)vdp[i].vd_val, msa.ms_addrs[i], MAXMACADDRLEN); } } msa.ms_addrcnt = val_cnt; bcopy(&msa, dip->pr_val, dip->pr_valsize); status = i_dladm_macprop(handle, dip, B_TRUE); free(dip); return (status); } static dladm_status_t get_autopush(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags) { struct dlautopush dlap; int len; uint_t i; dladm_status_t status; if (flags & DLD_PROP_DEFAULT) return (DLADM_STATUS_NOTDEFINED); status = i_dladm_get_public_prop(handle, linkid, pdp->pd_name, flags, perm_flags, &dlap, sizeof (dlap)); if (status != DLADM_STATUS_OK) return (status); if (dlap.dap_npush == 0) { *val_cnt = 0; return (DLADM_STATUS_OK); } for (i = 0, len = 0; i < dlap.dap_npush; i++) { if (i != 0) { (void) snprintf(*prop_val + len, DLADM_PROP_VAL_MAX - len, "%c", AP_DELIMITER); len += 1; } (void) snprintf(*prop_val + len, DLADM_PROP_VAL_MAX - len, "%s", dlap.dap_aplist[i]); len += strlen(dlap.dap_aplist[i]); if (dlap.dap_anchor - 1 == i) { (void) snprintf(*prop_val + len, DLADM_PROP_VAL_MAX - len, "%c%s", AP_DELIMITER, AP_ANCHOR); len += (strlen(AP_ANCHOR) + 1); } } *val_cnt = 1; return (DLADM_STATUS_OK); } /* * Add the specified module to the dlautopush structure; returns a * DLADM_STATUS_* code. */ dladm_status_t i_dladm_add_ap_module(const char *module, struct dlautopush *dlap) { if ((strlen(module) == 0) || (strlen(module) > FMNAMESZ)) return (DLADM_STATUS_BADVAL); if (strncasecmp(module, AP_ANCHOR, strlen(AP_ANCHOR)) == 0) { /* * We don't allow multiple anchors, and the anchor must * be after at least one module. */ if (dlap->dap_anchor != 0) return (DLADM_STATUS_BADVAL); if (dlap->dap_npush == 0) return (DLADM_STATUS_BADVAL); dlap->dap_anchor = dlap->dap_npush; return (DLADM_STATUS_OK); } if (dlap->dap_npush >= MAXAPUSH) return (DLADM_STATUS_BADVALCNT); (void) strlcpy(dlap->dap_aplist[dlap->dap_npush++], module, FMNAMESZ + 1); return (DLADM_STATUS_OK); } /* * Currently, both '.' and ' '(space) can be used as the delimiters between * autopush modules. The former is used in dladm set-linkprop, and the * latter is used in the autopush(8) file. */ static dladm_status_t check_autopush(dladm_handle_t handle __unused, prop_desc_t *pdp __unused, datalink_id_t linkid __unused, char **prop_val, uint_t *val_cntp, uint_t flags __unused, val_desc_t **vdpp, datalink_media_t media __unused) { char *module; struct dlautopush *dlap; dladm_status_t status; char val[DLADM_PROP_VAL_MAX]; char delimiters[4]; uint_t val_cnt = *val_cntp; val_desc_t *vdp = *vdpp; if (val_cnt != 1) return (DLADM_STATUS_BADVALCNT); if (prop_val != NULL) { dlap = malloc(sizeof (struct dlautopush)); if (dlap == NULL) return (DLADM_STATUS_NOMEM); (void) memset(dlap, 0, sizeof (struct dlautopush)); (void) snprintf(delimiters, 4, " %c\n", AP_DELIMITER); bcopy(*prop_val, val, DLADM_PROP_VAL_MAX); module = strtok(val, delimiters); while (module != NULL) { status = i_dladm_add_ap_module(module, dlap); if (status != DLADM_STATUS_OK) return (status); module = strtok(NULL, delimiters); } vdp->vd_val = (uintptr_t)dlap; } else { vdp->vd_val = 0; } return (DLADM_STATUS_OK); } #define WLDP_BUFSIZE (MAX_BUF_LEN - WIFI_BUF_OFFSET) static dladm_status_t get_rate_common(dladm_handle_t handle, prop_desc_t *pdp __unused, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, uint_t id, uint_t *perm_flags) { wl_rates_t *wrp; uint_t i; dladm_status_t status = DLADM_STATUS_OK; wrp = malloc(WLDP_BUFSIZE); if (wrp == NULL) return (DLADM_STATUS_NOMEM); status = i_dladm_wlan_param(handle, linkid, wrp, id, WLDP_BUFSIZE, B_FALSE); if (status != DLADM_STATUS_OK) goto done; if (wrp->wl_rates_num > *val_cnt) { status = DLADM_STATUS_TOOSMALL; goto done; } if (wrp->wl_rates_rates[0] == 0) { prop_val[0][0] = '\0'; *val_cnt = 1; goto done; } for (i = 0; i < wrp->wl_rates_num; i++) { (void) snprintf(prop_val[i], DLADM_STRSIZE, "%.*f", wrp->wl_rates_rates[i] % 2, (float)wrp->wl_rates_rates[i] / 2); } *val_cnt = wrp->wl_rates_num; *perm_flags = MAC_PROP_PERM_RW; done: free(wrp); return (status); } static dladm_status_t get_rate(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media, uint_t flags, uint_t *perm_flags) { if (media != DL_WIFI) { return (get_speed(handle, pdp, linkid, prop_val, val_cnt, media, flags, perm_flags)); } return (get_rate_common(handle, pdp, linkid, prop_val, val_cnt, MAC_PROP_WL_DESIRED_RATES, perm_flags)); } static dladm_status_t get_rate_mod(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media, uint_t flags __unused, uint_t *perm_flags) { switch (media) { case DL_ETHER: /* * Speed for ethernet links is unbounded. E.g., 802.11b * links can have a speed of 5.5 Gbps. */ return (DLADM_STATUS_NOTSUP); case DL_WIFI: return (get_rate_common(handle, pdp, linkid, prop_val, val_cnt, MAC_PROP_WL_SUPPORTED_RATES, perm_flags)); default: return (DLADM_STATUS_BADARG); } } static dladm_status_t set_wlan_rate(dladm_handle_t handle, datalink_id_t linkid, dladm_wlan_rates_t *rates) { int i; uint_t len; wl_rates_t *wrp; dladm_status_t status = DLADM_STATUS_OK; wrp = malloc(WLDP_BUFSIZE); if (wrp == NULL) return (DLADM_STATUS_NOMEM); bzero(wrp, WLDP_BUFSIZE); for (i = 0; i < rates->wr_cnt; i++) wrp->wl_rates_rates[i] = rates->wr_rates[i]; wrp->wl_rates_num = rates->wr_cnt; len = offsetof(wl_rates_t, wl_rates_rates) + (rates->wr_cnt * sizeof (char)) + WIFI_BUF_OFFSET; status = i_dladm_wlan_param(handle, linkid, wrp, MAC_PROP_WL_DESIRED_RATES, len, B_TRUE); free(wrp); return (status); } static dladm_status_t set_rate(dladm_handle_t handle, prop_desc_t *pdp __unused, datalink_id_t linkid, val_desc_t *vdp, uint_t val_cnt, uint_t flags __unused, datalink_media_t media) { dladm_wlan_rates_t rates; dladm_status_t status; /* * can currently set rate on WIFI links only. */ if (media != DL_WIFI) return (DLADM_STATUS_PROPRDONLY); if (val_cnt != 1) return (DLADM_STATUS_BADVALCNT); rates.wr_cnt = 1; rates.wr_rates[0] = vdp[0].vd_val; status = set_wlan_rate(handle, linkid, &rates); return (status); } static dladm_status_t check_rate(dladm_handle_t handle, prop_desc_t *pdp __unused, datalink_id_t linkid, char **prop_val, uint_t *val_cntp, uint_t flags __unused, val_desc_t **vdpp, datalink_media_t media) { uint_t i; uint_t modval_cnt = MAX_SUPPORT_RATES; char *buf, **modval; dladm_status_t status; uint_t perm_flags; uint_t val_cnt = *val_cntp; val_desc_t *vdp = *vdpp; if (val_cnt != 1) return (DLADM_STATUS_BADVALCNT); buf = malloc((sizeof (char *) + DLADM_STRSIZE) * MAX_SUPPORT_RATES); if (buf == NULL) { status = DLADM_STATUS_NOMEM; goto done; } modval = (char **)(void *)buf; for (i = 0; i < MAX_SUPPORT_RATES; i++) { modval[i] = buf + sizeof (char *) * MAX_SUPPORT_RATES + i * DLADM_STRSIZE; } status = get_rate_mod(handle, NULL, linkid, modval, &modval_cnt, media, 0, &perm_flags); if (status != DLADM_STATUS_OK) goto done; for (i = 0; i < modval_cnt; i++) { if (strcasecmp(*prop_val, modval[i]) == 0) { vdp->vd_val = (uintptr_t)(uint_t) (atof(*prop_val) * 2); status = DLADM_STATUS_OK; break; } } if (i == modval_cnt) status = DLADM_STATUS_BADVAL; done: free(buf); return (status); } static dladm_status_t get_phyconf(dladm_handle_t handle, datalink_id_t linkid, void *buf, int buflen) { return (i_dladm_wlan_param(handle, linkid, buf, MAC_PROP_WL_PHY_CONFIG, buflen, B_FALSE)); } static dladm_status_t get_channel(dladm_handle_t handle, prop_desc_t *pdp __unused, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags __unused, uint_t *perm_flags) { uint32_t channel; char buf[WLDP_BUFSIZE]; dladm_status_t status; wl_phy_conf_t wl_phy_conf; if ((status = get_phyconf(handle, linkid, buf, sizeof (buf))) != DLADM_STATUS_OK) return (status); (void) memcpy(&wl_phy_conf, buf, sizeof (wl_phy_conf)); if (!i_dladm_wlan_convert_chan(&wl_phy_conf, &channel)) return (DLADM_STATUS_NOTFOUND); (void) snprintf(*prop_val, DLADM_STRSIZE, "%u", channel); *val_cnt = 1; *perm_flags = MAC_PROP_PERM_READ; return (DLADM_STATUS_OK); } static dladm_status_t get_powermode(dladm_handle_t handle, prop_desc_t *pdp __unused, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags __unused, uint_t *perm_flags) { wl_ps_mode_t mode; const char *s; char buf[WLDP_BUFSIZE]; dladm_status_t status; if ((status = i_dladm_wlan_param(handle, linkid, buf, MAC_PROP_WL_POWER_MODE, sizeof (buf), B_FALSE)) != DLADM_STATUS_OK) return (status); (void) memcpy(&mode, buf, sizeof (mode)); switch (mode.wl_ps_mode) { case WL_PM_AM: s = "off"; break; case WL_PM_MPS: s = "max"; break; case WL_PM_FAST: s = "fast"; break; default: return (DLADM_STATUS_NOTFOUND); } (void) snprintf(*prop_val, DLADM_STRSIZE, "%s", s); *val_cnt = 1; *perm_flags = MAC_PROP_PERM_RW; return (DLADM_STATUS_OK); } static dladm_status_t set_powermode(dladm_handle_t handle, prop_desc_t *pdp __unused, datalink_id_t linkid, val_desc_t *vdp, uint_t val_cnt, uint_t flags __unused, datalink_media_t media __unused) { dladm_wlan_powermode_t powermode = vdp->vd_val; wl_ps_mode_t ps_mode; if (val_cnt != 1) return (DLADM_STATUS_BADVALCNT); (void) memset(&ps_mode, 0xff, sizeof (ps_mode)); switch (powermode) { case DLADM_WLAN_PM_OFF: ps_mode.wl_ps_mode = WL_PM_AM; break; case DLADM_WLAN_PM_MAX: ps_mode.wl_ps_mode = WL_PM_MPS; break; case DLADM_WLAN_PM_FAST: ps_mode.wl_ps_mode = WL_PM_FAST; break; default: return (DLADM_STATUS_NOTSUP); } return (i_dladm_wlan_param(handle, linkid, &ps_mode, MAC_PROP_WL_POWER_MODE, sizeof (ps_mode), B_TRUE)); } static dladm_status_t get_radio(dladm_handle_t handle, prop_desc_t *pdp __unused, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags __unused, uint_t *perm_flags) { wl_radio_t radio; const char *s; char buf[WLDP_BUFSIZE]; dladm_status_t status; if ((status = i_dladm_wlan_param(handle, linkid, buf, MAC_PROP_WL_RADIO, sizeof (buf), B_FALSE)) != DLADM_STATUS_OK) return (status); (void) memcpy(&radio, buf, sizeof (radio)); switch (radio) { case B_TRUE: s = "on"; break; case B_FALSE: s = "off"; break; default: return (DLADM_STATUS_NOTFOUND); } (void) snprintf(*prop_val, DLADM_STRSIZE, "%s", s); *val_cnt = 1; *perm_flags = MAC_PROP_PERM_RW; return (DLADM_STATUS_OK); } static dladm_status_t set_radio(dladm_handle_t handle, prop_desc_t *pdp __unused, datalink_id_t linkid, val_desc_t *vdp, uint_t val_cnt, uint_t flags __unused, datalink_media_t media __unused) { dladm_wlan_radio_t radio = vdp->vd_val; wl_radio_t r; if (val_cnt != 1) return (DLADM_STATUS_BADVALCNT); switch (radio) { case DLADM_WLAN_RADIO_ON: r = B_TRUE; break; case DLADM_WLAN_RADIO_OFF: r = B_FALSE; break; default: return (DLADM_STATUS_NOTSUP); } return (i_dladm_wlan_param(handle, linkid, &r, MAC_PROP_WL_RADIO, sizeof (r), B_TRUE)); } static dladm_status_t check_hoplimit(dladm_handle_t handle __unused, prop_desc_t *pdp __unused, datalink_id_t linkid __unused, char **prop_val, uint_t *val_cntp, uint_t flags __unused, val_desc_t **vdpp, datalink_media_t media __unused) { int32_t hlim; char *ep; uint_t val_cnt = *val_cntp; val_desc_t *vdp = *vdpp; if (val_cnt != 1) return (DLADM_STATUS_BADVALCNT); errno = 0; hlim = strtol(*prop_val, &ep, 10); if (errno != 0 || ep == *prop_val || hlim < 1 || hlim > (int32_t)UINT8_MAX) return (DLADM_STATUS_BADVAL); vdp->vd_val = hlim; return (DLADM_STATUS_OK); } static dladm_status_t check_encaplim(dladm_handle_t handle __unused, prop_desc_t *pdp __unused, datalink_id_t linkid __unused, char **prop_val, uint_t *val_cntp, uint_t flags __unused, val_desc_t **vdpp, datalink_media_t media) { int32_t elim; char *ep; uint_t val_cnt = *val_cntp; val_desc_t *vdp = *vdpp; if (media != DL_IPV6) return (DLADM_STATUS_BADARG); if (val_cnt != 1) return (DLADM_STATUS_BADVALCNT); errno = 0; elim = strtol(*prop_val, &ep, 10); if (errno != 0 || ep == *prop_val || elim < 0 || elim > (int32_t)UINT8_MAX) return (DLADM_STATUS_BADVAL); vdp->vd_val = elim; return (DLADM_STATUS_OK); } static dladm_status_t i_dladm_set_linkprop_db(dladm_handle_t handle, datalink_id_t linkid, const char *prop_name, char **prop_val, uint_t val_cnt) { char buf[MAXLINELEN]; uint_t i; dladm_conf_t conf; dladm_status_t status; status = dladm_open_conf(handle, linkid, &conf); if (status != DLADM_STATUS_OK) return (status); /* * reset case. */ if (val_cnt == 0) { status = dladm_unset_conf_field(handle, conf, prop_name); if (status == DLADM_STATUS_OK) status = dladm_write_conf(handle, conf); goto done; } buf[0] = '\0'; for (i = 0; i < val_cnt; i++) { (void) strlcat(buf, prop_val[i], MAXLINELEN); if (i != val_cnt - 1) (void) strlcat(buf, ",", MAXLINELEN); } status = dladm_set_conf_field(handle, conf, prop_name, DLADM_TYPE_STR, buf); if (status == DLADM_STATUS_OK) status = dladm_write_conf(handle, conf); done: dladm_destroy_conf(handle, conf); return (status); } static dladm_status_t i_dladm_get_linkprop_db(dladm_handle_t handle, datalink_id_t linkid, const char *prop_name, char **prop_val, uint_t *val_cntp) { char buf[MAXLINELEN], *str; uint_t cnt = 0; dladm_conf_t conf; dladm_status_t status; status = dladm_getsnap_conf(handle, linkid, &conf); if (status != DLADM_STATUS_OK) return (status); status = dladm_get_conf_field(handle, conf, prop_name, buf, MAXLINELEN); if (status != DLADM_STATUS_OK) goto done; str = strtok(buf, ","); while (str != NULL) { if (cnt == *val_cntp) { status = DLADM_STATUS_TOOSMALL; goto done; } (void) strlcpy(prop_val[cnt++], str, DLADM_PROP_VAL_MAX); str = strtok(NULL, ","); } *val_cntp = cnt; done: dladm_destroy_conf(handle, conf); return (status); } /* * Walk persistent private link properties of a link. */ static dladm_status_t i_dladm_walk_linkprop_priv_db(dladm_handle_t handle, datalink_id_t linkid, void *arg, int (*func)(dladm_handle_t, datalink_id_t, const char *, void *)) { dladm_status_t status; dladm_conf_t conf; char last_attr[MAXLINKATTRLEN]; char attr[MAXLINKATTRLEN]; char attrval[MAXLINKATTRVALLEN]; size_t attrsz; if (linkid == DATALINK_INVALID_LINKID || func == NULL) return (DLADM_STATUS_BADARG); status = dladm_getsnap_conf(handle, linkid, &conf); if (status != DLADM_STATUS_OK) return (status); last_attr[0] = '\0'; while ((status = dladm_getnext_conf_linkprop(handle, conf, last_attr, attr, attrval, MAXLINKATTRVALLEN, &attrsz)) == DLADM_STATUS_OK) { if (attr[0] == '_') { if (func(handle, linkid, attr, arg) == DLADM_WALK_TERMINATE) break; } (void) strlcpy(last_attr, attr, MAXLINKATTRLEN); } dladm_destroy_conf(handle, conf); return (DLADM_STATUS_OK); } static link_attr_t * dladm_name2prop(const char *prop_name) { link_attr_t *p; for (p = link_attr; p->pp_id != MAC_PROP_PRIVATE; p++) { if (strcmp(p->pp_name, prop_name) == 0) break; } return (p); } static link_attr_t * dladm_id2prop(mac_prop_id_t propid) { link_attr_t *p; for (p = link_attr; p->pp_id != MAC_PROP_PRIVATE; p++) { if (p->pp_id == propid) break; } return (p); } static dld_ioc_macprop_t * i_dladm_buf_alloc_impl(size_t valsize, datalink_id_t linkid, const char *prop_name, mac_prop_id_t propid, uint_t flags, dladm_status_t *status) { int dsize; dld_ioc_macprop_t *dip; *status = DLADM_STATUS_OK; dsize = MAC_PROP_BUFSIZE(valsize); dip = malloc(dsize); if (dip == NULL) { *status = DLADM_STATUS_NOMEM; return (NULL); } bzero(dip, dsize); dip->pr_valsize = valsize; (void) strlcpy(dip->pr_name, prop_name, sizeof (dip->pr_name)); dip->pr_linkid = linkid; dip->pr_num = propid; dip->pr_flags = flags; return (dip); } static dld_ioc_macprop_t * i_dladm_buf_alloc_by_name(size_t valsize, datalink_id_t linkid, const char *prop_name, uint_t flags, dladm_status_t *status) { link_attr_t *p; p = dladm_name2prop(prop_name); valsize = MAX(p->pp_valsize, valsize); return (i_dladm_buf_alloc_impl(valsize, linkid, prop_name, p->pp_id, flags, status)); } static dld_ioc_macprop_t * i_dladm_buf_alloc_by_id(size_t valsize, datalink_id_t linkid, mac_prop_id_t propid, uint_t flags, dladm_status_t *status) { link_attr_t *p; p = dladm_id2prop(propid); valsize = MAX(p->pp_valsize, valsize); return (i_dladm_buf_alloc_impl(valsize, linkid, p->pp_name, propid, flags, status)); } static dladm_status_t set_public_prop(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, val_desc_t *vdp, uint_t val_cnt __unused, uint_t flags __unused, datalink_media_t media __unused) { dld_ioc_macprop_t *dip; dladm_status_t status = DLADM_STATUS_OK; uint8_t u8; uint16_t u16; uint32_t u32; void *val; dip = i_dladm_buf_alloc_by_name(0, linkid, pdp->pd_name, 0, &status); if (dip == NULL) return (status); if (pdp->pd_flags & PD_CHECK_ALLOC) val = (void *)vdp->vd_val; else { /* * Currently all 1/2/4-byte size properties are byte/word/int. * No need (yet) to distinguish these from arrays of same size. */ switch (dip->pr_valsize) { case 1: u8 = vdp->vd_val; val = &u8; break; case 2: u16 = vdp->vd_val; val = &u16; break; case 4: u32 = vdp->vd_val; val = &u32; break; default: val = &vdp->vd_val; break; } } if (val != NULL) (void) memcpy(dip->pr_val, val, dip->pr_valsize); else dip->pr_valsize = 0; status = i_dladm_macprop(handle, dip, B_TRUE); free(dip); return (status); } static dladm_status_t set_public_bitprop(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, val_desc_t *vdp, uint_t val_cnt, uint_t flags, datalink_media_t media) { uint_t i, j; val_desc_t vd = { 0 }; if ((pdp->pd_flags & PD_CHECK_ALLOC) != 0) return (DLADM_STATUS_BADARG); for (i = 0; i < val_cnt; i++) { for (j = 0; j < pdp->pd_noptval; j++) { if (strcasecmp(vdp[i].vd_name, pdp->pd_optval[j].vd_name) == 0) { vd.vd_val |= pdp->pd_optval[j].vd_val; break; } } } if (vd.vd_val == 0) return (DLADM_STATUS_BADARG); return (set_public_prop(handle, pdp, linkid, &vd, 1, flags, media)); } dladm_status_t i_dladm_macprop(dladm_handle_t handle, void *dip, boolean_t set) { dladm_status_t status = DLADM_STATUS_OK; if (ioctl(dladm_dld_fd(handle), (set ? DLDIOC_SETMACPROP : DLDIOC_GETMACPROP), dip)) status = dladm_errno2status(errno); return (status); } static dladm_status_t i_dladm_get_public_prop(dladm_handle_t handle, datalink_id_t linkid, char *prop_name, uint_t flags, uint_t *perm_flags, void *arg, size_t size) { dld_ioc_macprop_t *dip; dladm_status_t status; dip = i_dladm_buf_alloc_by_name(0, linkid, prop_name, flags, &status); if (dip == NULL) return (DLADM_STATUS_NOMEM); status = i_dladm_macprop(handle, dip, B_FALSE); if (status != DLADM_STATUS_OK) { free(dip); return (status); } if (perm_flags != NULL) *perm_flags = dip->pr_perm_flags; if (arg != NULL) (void) memcpy(arg, dip->pr_val, size); free(dip); return (DLADM_STATUS_OK); } static dladm_status_t check_uint32(dladm_handle_t handle __unused, prop_desc_t *pdp __unused, datalink_id_t linkid __unused, char **prop_val, uint_t *val_cntp, uint_t flags __unused, val_desc_t **vp, datalink_media_t media __unused) { uint_t val_cnt = *val_cntp; val_desc_t *v = *vp; if (val_cnt != 1) return (DLADM_STATUS_BADVAL); v->vd_val = strtoul(prop_val[0], NULL, 0); return (DLADM_STATUS_OK); } static dladm_status_t get_duplex(dladm_handle_t handle, prop_desc_t *pdp __unused, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags __unused, uint_t *perm_flags __unused) { link_duplex_t link_duplex; dladm_status_t status; if ((status = dladm_get_single_mac_stat(handle, linkid, "link_duplex", KSTAT_DATA_UINT32, &link_duplex)) != 0) return (status); switch (link_duplex) { case LINK_DUPLEX_FULL: (void) strcpy(*prop_val, "full"); break; case LINK_DUPLEX_HALF: (void) strcpy(*prop_val, "half"); break; default: (void) strcpy(*prop_val, "unknown"); break; } *val_cnt = 1; return (DLADM_STATUS_OK); } static dladm_status_t get_speed(dladm_handle_t handle, prop_desc_t *pdp __unused, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags __unused, uint_t *perm_flags) { uint64_t ifspeed = 0; dladm_status_t status; if ((status = dladm_get_single_mac_stat(handle, linkid, "ifspeed", KSTAT_DATA_UINT64, &ifspeed)) != 0) return (status); if ((ifspeed % 1000000) != 0) { (void) snprintf(*prop_val, DLADM_PROP_VAL_MAX, "%llf", ifspeed / (float)1000000); /* Mbps */ } else { (void) snprintf(*prop_val, DLADM_PROP_VAL_MAX, "%llu", ifspeed / 1000000); /* Mbps */ } *val_cnt = 1; *perm_flags = MAC_PROP_PERM_READ; return (DLADM_STATUS_OK); } static dladm_status_t get_link_state(dladm_handle_t handle, prop_desc_t *pdp __unused, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags __unused, uint_t *perm_flags) { link_state_t link_state; dladm_status_t status; status = dladm_get_state(handle, linkid, &link_state); if (status != DLADM_STATUS_OK) return (status); switch (link_state) { case LINK_STATE_UP: (void) strcpy(*prop_val, "up"); break; case LINK_STATE_DOWN: (void) strcpy(*prop_val, "down"); break; default: (void) strcpy(*prop_val, "unknown"); break; } *val_cnt = 1; *perm_flags = MAC_PROP_PERM_READ; return (DLADM_STATUS_OK); } static dladm_status_t get_binary(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags) { dladm_status_t status; uint_t v = 0; status = i_dladm_get_public_prop(handle, linkid, pdp->pd_name, flags, perm_flags, &v, sizeof (v)); if (status != DLADM_STATUS_OK) return (status); (void) snprintf(*prop_val, DLADM_PROP_VAL_MAX, "%d", (uint_t)(v > 0)); *val_cnt = 1; return (DLADM_STATUS_OK); } static dladm_status_t get_uint32(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags) { dladm_status_t status; uint32_t v = 0; status = i_dladm_get_public_prop(handle, linkid, pdp->pd_name, flags, perm_flags, &v, sizeof (v)); if (status != DLADM_STATUS_OK) return (status); (void) snprintf(*prop_val, DLADM_PROP_VAL_MAX, "%ld", v); *val_cnt = 1; return (DLADM_STATUS_OK); } static dladm_status_t get_range(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags __unused) { dld_ioc_macprop_t *dip; dladm_status_t status = DLADM_STATUS_OK; size_t sz; uint_t rcount; mac_propval_range_t *rangep; /* * As caller we don't know number of value ranges, the driver * supports. To begin with we assume that number to be 1. If the * buffer size is insufficient, driver returns back with the * actual count of value ranges. See mac.h for more details. */ sz = sizeof (mac_propval_range_t); rcount = 1; retry: if ((dip = i_dladm_buf_alloc_by_name(sz, linkid, pdp->pd_name, flags, &status)) == NULL) return (status); rangep = (mac_propval_range_t *)(void *)&dip->pr_val; rangep->mpr_count = rcount; status = i_dladm_macprop(handle, dip, B_FALSE); if (status != DLADM_STATUS_OK) { if (status == DLADM_STATUS_TOOSMALL) { int err; if ((err = i_dladm_range_size(rangep, &sz, &rcount)) == 0) { free(dip); goto retry; } else { status = dladm_errno2status(err); } } free(dip); return (status); } if (rangep->mpr_count == 0) { *val_cnt = 1; (void) snprintf(prop_val[0], DLADM_PROP_VAL_MAX, "--"); goto done; } switch (rangep->mpr_type) { case MAC_PROPVAL_UINT32: { mac_propval_uint32_range_t *ur; uint_t count = rangep->mpr_count, i; ur = &rangep->mpr_range_uint32[0]; for (i = 0; i < count; i++, ur++) { if (ur->mpur_min == ur->mpur_max) { (void) snprintf(prop_val[i], DLADM_PROP_VAL_MAX, "%ld", ur->mpur_min); } else { (void) snprintf(prop_val[i], DLADM_PROP_VAL_MAX, "%ld-%ld", ur->mpur_min, ur->mpur_max); } } *val_cnt = count; break; } default: status = DLADM_STATUS_BADARG; break; } done: free(dip); return (status); } static dladm_status_t get_tagmode(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags) { link_tagmode_t mode; dladm_status_t status; status = i_dladm_get_public_prop(handle, linkid, pdp->pd_name, flags, perm_flags, &mode, sizeof (mode)); if (status != DLADM_STATUS_OK) return (status); switch (mode) { case LINK_TAGMODE_NORMAL: (void) strlcpy(*prop_val, "normal", DLADM_PROP_VAL_MAX); break; case LINK_TAGMODE_VLANONLY: (void) strlcpy(*prop_val, "vlanonly", DLADM_PROP_VAL_MAX); break; default: (void) strlcpy(*prop_val, "unknown", DLADM_PROP_VAL_MAX); } *val_cnt = 1; return (DLADM_STATUS_OK); } static dladm_status_t get_flowctl(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags) { link_flowctrl_t v; dladm_status_t status; status = i_dladm_get_public_prop(handle, linkid, pdp->pd_name, flags, perm_flags, &v, sizeof (v)); if (status != DLADM_STATUS_OK) return (status); switch (v) { case LINK_FLOWCTRL_NONE: (void) sprintf(*prop_val, "no"); break; case LINK_FLOWCTRL_RX: (void) sprintf(*prop_val, "rx"); break; case LINK_FLOWCTRL_TX: (void) sprintf(*prop_val, "tx"); break; case LINK_FLOWCTRL_BI: (void) sprintf(*prop_val, "bi"); break; } *val_cnt = 1; return (DLADM_STATUS_OK); } static dladm_status_t get_bits(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags) { uint32_t v; dladm_status_t status; uint_t i, cnt; status = i_dladm_get_public_prop(handle, linkid, pdp->pd_name, flags, perm_flags, &v, sizeof (v)); if (status != DLADM_STATUS_OK) return (status); cnt = 0; for (i = 0; cnt < *val_cnt && i < pdp->pd_noptval; i++) { if ((v & pdp->pd_optval[i].vd_val) != 0) { (void) snprintf(prop_val[cnt++], DLADM_STRSIZE, pdp->pd_optval[i].vd_name); } } if (i < pdp->pd_noptval) return (DLADM_STATUS_BADVALCNT); *val_cnt = cnt; return (DLADM_STATUS_OK); } static dladm_status_t i_dladm_set_private_prop(dladm_handle_t handle, datalink_id_t linkid, const char *prop_name, char **prop_val, uint_t val_cnt, uint_t flags) { uint_t i; int slen; int bufsize = 0; dld_ioc_macprop_t *dip = NULL; uchar_t *dp; link_attr_t *p; dladm_status_t status = DLADM_STATUS_OK; if ((prop_name == NULL && prop_val != NULL) || (prop_val != NULL && val_cnt == 0)) return (DLADM_STATUS_BADARG); p = dladm_name2prop(prop_name); if (p->pp_id != MAC_PROP_PRIVATE) return (DLADM_STATUS_BADARG); if (!(flags & DLADM_OPT_ACTIVE)) return (DLADM_STATUS_OK); /* * private properties: all parsing is done in the kernel. * allocate a enough space for each property + its separator (','). */ for (i = 0; i < val_cnt; i++) { bufsize += strlen(prop_val[i]) + 1; } if (prop_val == NULL) { /* * getting default value. so use more buffer space. */ bufsize += DLADM_PROP_BUF_CHUNK; } dip = i_dladm_buf_alloc_by_name(bufsize + 1, linkid, prop_name, (prop_val != NULL ? 0 : DLD_PROP_DEFAULT), &status); if (dip == NULL) return (status); dp = (uchar_t *)dip->pr_val; slen = 0; if (prop_val == NULL) { status = i_dladm_macprop(handle, dip, B_FALSE); dip->pr_flags = 0; } else { for (i = 0; i < val_cnt; i++) { int plen = 0; plen = strlen(prop_val[i]); bcopy(prop_val[i], dp, plen); slen += plen; /* * add a "," separator and update dp. */ if (i != (val_cnt - 1)) dp[slen++] = ','; dp += (plen + 1); } } if (status == DLADM_STATUS_OK) status = i_dladm_macprop(handle, dip, B_TRUE); free(dip); return (status); } static dladm_status_t i_dladm_get_priv_prop(dladm_handle_t handle, datalink_id_t linkid, const char *prop_name, char **prop_val, uint_t *val_cnt, dladm_prop_type_t type, uint_t dld_flags) { dladm_status_t status = DLADM_STATUS_OK; dld_ioc_macprop_t *dip = NULL; link_attr_t *p; if ((prop_name == NULL && prop_val != NULL) || (prop_val != NULL && val_cnt == 0)) return (DLADM_STATUS_BADARG); p = dladm_name2prop(prop_name); if (p->pp_id != MAC_PROP_PRIVATE) return (DLADM_STATUS_BADARG); /* * private properties: all parsing is done in the kernel. */ dip = i_dladm_buf_alloc_by_name(DLADM_PROP_BUF_CHUNK, linkid, prop_name, dld_flags, &status); if (dip == NULL) return (status); if ((status = i_dladm_macprop(handle, dip, B_FALSE)) == DLADM_STATUS_OK) { if (type == DLADM_PROP_VAL_PERM) { (void) dladm_perm2str(dip->pr_perm_flags, *prop_val); } else if (type == DLADM_PROP_VAL_MODIFIABLE) { *prop_val[0] = '\0'; } else { (void) strncpy(*prop_val, dip->pr_val, DLADM_PROP_VAL_MAX); } *val_cnt = 1; } else if ((status == DLADM_STATUS_NOTSUP) && (type == DLADM_PROP_VAL_CURRENT)) { status = DLADM_STATUS_NOTFOUND; } free(dip); return (status); } static dladm_status_t i_dladm_getset_defval(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, datalink_media_t media, uint_t flags) { dladm_status_t status; char **prop_vals = NULL, *buf; size_t bufsize; uint_t cnt; int i; uint_t perm_flags; /* * Allocate buffer needed for prop_vals array. We can have at most * DLADM_MAX_PROP_VALCNT char *prop_vals[] entries, where * each entry has max size DLADM_PROP_VAL_MAX */ bufsize = (sizeof (char *) + DLADM_PROP_VAL_MAX) * DLADM_MAX_PROP_VALCNT; buf = malloc(bufsize); prop_vals = (char **)(void *)buf; for (i = 0; i < DLADM_MAX_PROP_VALCNT; i++) { prop_vals[i] = buf + sizeof (char *) * DLADM_MAX_PROP_VALCNT + i * DLADM_PROP_VAL_MAX; } /* * For properties which have pdp->pd_defval.vd_name as a non-empty * string, the "" itself is used to reset the property (exceptions * are zone and autopush, which populate vdp->vd_val). So * libdladm can copy pdp->pd_defval over to the val_desc_t passed * down on the setprop using the global values in the table. For * other cases (vd_name is ""), doing reset-linkprop will cause * libdladm to do a getprop to find the default value and then do * a setprop to reset the value to default. */ status = pdp->pd_get(handle, pdp, linkid, prop_vals, &cnt, media, DLD_PROP_DEFAULT, &perm_flags); if (status == DLADM_STATUS_OK) { if (perm_flags == MAC_PROP_PERM_RW) { status = i_dladm_set_single_prop(handle, linkid, pdp->pd_class, media, pdp, prop_vals, cnt, flags); } else status = DLADM_STATUS_NOTSUP; } free(buf); return (status); } static dladm_status_t get_stp(dladm_handle_t handle, struct prop_desc *pd, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags) { const bridge_public_prop_t *bpp; dladm_status_t retv; int val; uint_t i; if (flags != 0) return (DLADM_STATUS_NOTSUP); *perm_flags = MAC_PROP_PERM_RW; *val_cnt = 1; for (bpp = bridge_prop; bpp->bpp_name != NULL; bpp++) if (strcmp(bpp->bpp_name, pd->pd_name) == 0) break; retv = dladm_bridge_get_port_cfg(handle, linkid, bpp->bpp_code, &val); /* If the daemon isn't running, then return the persistent value */ if (retv == DLADM_STATUS_NOTFOUND) { if (i_dladm_get_linkprop_db(handle, linkid, pd->pd_name, prop_val, val_cnt) != DLADM_STATUS_OK) (void) strlcpy(*prop_val, pd->pd_defval.vd_name, DLADM_PROP_VAL_MAX); return (DLADM_STATUS_OK); } if (retv != DLADM_STATUS_OK) { (void) strlcpy(*prop_val, "?", DLADM_PROP_VAL_MAX); return (retv); } if ((uintptr_t)val == pd->pd_defval.vd_val && pd->pd_defval.vd_name[0] != '\0') { (void) strlcpy(*prop_val, pd->pd_defval.vd_name, DLADM_PROP_VAL_MAX); return (DLADM_STATUS_OK); } for (i = 0; i < pd->pd_noptval; i++) { if ((uintptr_t)val == pd->pd_optval[i].vd_val) { (void) strlcpy(*prop_val, pd->pd_optval[i].vd_name, DLADM_PROP_VAL_MAX); return (DLADM_STATUS_OK); } } (void) snprintf(*prop_val, DLADM_PROP_VAL_MAX, "%u", (unsigned)val); return (DLADM_STATUS_OK); } static dladm_status_t set_stp_prop(dladm_handle_t handle, prop_desc_t *pd __unused, datalink_id_t linkid, val_desc_t *vdp __unused, uint_t val_cnt __unused, uint_t flags, datalink_media_t media __unused) { /* * Special case for mcheck: the daemon resets the value to zero, and we * don't want the daemon to refresh itself; it leads to deadlock. */ if (flags & DLADM_OPT_NOREFRESH) return (DLADM_STATUS_OK); /* Tell the running daemon, if any */ return (dladm_bridge_refresh(handle, linkid)); } /* * This is used only for stp_priority, stp_cost, and stp_mcheck. */ static dladm_status_t check_stp_prop(dladm_handle_t handle, struct prop_desc *pd, datalink_id_t linkid, char **prop_val, uint_t *val_cntp, uint_t flags __unused, val_desc_t **vdpp, datalink_media_t media __unused) { char *cp; boolean_t iscost = B_FALSE; uint_t val_cnt = *val_cntp; val_desc_t *vdp = *vdpp; if (val_cnt != 1) return (DLADM_STATUS_BADVALCNT); if (prop_val == NULL) { vdp->vd_val = 0; } else { /* Only stp_priority and stp_cost use this function */ iscost = strcmp(pd->pd_name, "stp_cost") == 0; if (iscost && strcmp(prop_val[0], "auto") == 0) { /* Illegal value 0 is allowed to mean "automatic" */ vdp->vd_val = 0; } else { errno = 0; vdp->vd_val = strtoul(prop_val[0], &cp, 0); if (errno != 0 || *cp != '\0') return (DLADM_STATUS_BADVAL); } } if (iscost) { return (vdp->vd_val > 65535 ? DLADM_STATUS_BADVAL : DLADM_STATUS_OK); } else { if (vdp->vd_val > 255) return (DLADM_STATUS_BADVAL); /* * If the user is setting stp_mcheck non-zero, then (per the * IEEE management standards and UNH testing) we need to check * whether this link is part of a bridge that is running RSTP. * If it's not, then setting the flag is an error. Note that * errors are intentionally discarded here; it's the value * that's the problem -- it's not a bad value, merely one that * can't be used now. */ if (strcmp(pd->pd_name, "stp_mcheck") == 0 && vdp->vd_val != 0) { char bridge[MAXLINKNAMELEN]; UID_STP_CFG_T cfg; dladm_bridge_prot_t brprot; if (dladm_bridge_getlink(handle, linkid, bridge, sizeof (bridge)) != DLADM_STATUS_OK || dladm_bridge_get_properties(bridge, &cfg, &brprot) != DLADM_STATUS_OK) return (DLADM_STATUS_FAILED); if (cfg.force_version <= 1) return (DLADM_STATUS_FAILED); } return (DLADM_STATUS_OK); } } static dladm_status_t get_bridge_forward(dladm_handle_t handle, struct prop_desc *pd, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags) { dladm_status_t retv; uint_t val; if (flags != 0) return (DLADM_STATUS_NOTSUP); *perm_flags = MAC_PROP_PERM_RW; *val_cnt = 1; retv = dladm_bridge_get_forwarding(handle, linkid, &val); if (retv == DLADM_STATUS_NOTFOUND) { if (i_dladm_get_linkprop_db(handle, linkid, pd->pd_name, prop_val, val_cnt) != DLADM_STATUS_OK) (void) strlcpy(*prop_val, pd->pd_defval.vd_name, DLADM_PROP_VAL_MAX); return (DLADM_STATUS_OK); } if (retv == DLADM_STATUS_OK) (void) snprintf(*prop_val, DLADM_PROP_VAL_MAX, "%u", val); else (void) strlcpy(*prop_val, "?", DLADM_PROP_VAL_MAX); return (retv); } static dladm_status_t set_bridge_forward(dladm_handle_t handle, prop_desc_t *pd __unused, datalink_id_t linkid, val_desc_t *vdp __unused, uint_t val_cnt __unused, uint_t flags __unused, datalink_media_t media __unused) { /* Tell the running daemon, if any */ return (dladm_bridge_refresh(handle, linkid)); } static dladm_status_t get_bridge_pvid(dladm_handle_t handle, struct prop_desc *pd __unused, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags) { dladm_status_t status; dld_ioc_macprop_t *dip; uint16_t pvid; if (flags != 0) return (DLADM_STATUS_NOTSUP); *perm_flags = MAC_PROP_PERM_RW; *val_cnt = 1; dip = i_dladm_buf_alloc_by_id(sizeof (uint16_t), linkid, MAC_PROP_PVID, 0, &status); if (dip == NULL) return (status); status = i_dladm_macprop(handle, dip, B_FALSE); if (status == DLADM_STATUS_OK) { (void) memcpy(&pvid, dip->pr_val, sizeof (pvid)); (void) snprintf(*prop_val, DLADM_PROP_VAL_MAX, "%u", pvid); } else { (void) strlcpy(*prop_val, "?", DLADM_PROP_VAL_MAX); } free(dip); return (status); } static dladm_status_t set_bridge_pvid(dladm_handle_t handle, prop_desc_t *pd __unused, datalink_id_t linkid, val_desc_t *vdp, uint_t val_cnt __unused, uint_t flags __unused, datalink_media_t media __unused) { dladm_status_t status; dld_ioc_macprop_t *dip; uint16_t pvid; dip = i_dladm_buf_alloc_by_id(sizeof (uint16_t), linkid, MAC_PROP_PVID, 0, &status); if (dip == NULL) return (status); pvid = vdp->vd_val; (void) memcpy(dip->pr_val, &pvid, sizeof (pvid)); status = i_dladm_macprop(handle, dip, B_TRUE); free(dip); if (status != DLADM_STATUS_OK) return (status); /* Tell the running daemon, if any */ return (dladm_bridge_refresh(handle, linkid)); } static dladm_status_t check_bridge_pvid(dladm_handle_t handle __unused, struct prop_desc *pd __unused, datalink_id_t linkid __unused, char **prop_val, uint_t *val_cntp, uint_t flags __unused, val_desc_t **vdpp, datalink_media_t media __unused) { char *cp; uint_t val_cnt = *val_cntp; val_desc_t *vdp = *vdpp; if (val_cnt != 1) return (DLADM_STATUS_BADVALCNT); if (prop_val == NULL) { vdp->vd_val = 1; } else { errno = 0; vdp->vd_val = strtoul(prop_val[0], &cp, 0); if (errno != 0 || *cp != '\0') return (DLADM_STATUS_BADVAL); } return (vdp->vd_val > VLAN_ID_MAX ? DLADM_STATUS_BADVAL : DLADM_STATUS_OK); } dladm_status_t i_dladm_wlan_param(dladm_handle_t handle, datalink_id_t linkid, void *buf, mac_prop_id_t cmd, size_t len, boolean_t set) { uint32_t flags; dladm_status_t status; uint32_t media; dld_ioc_macprop_t *dip; void *dp; if ((status = dladm_datalink_id2info(handle, linkid, &flags, NULL, &media, NULL, 0)) != DLADM_STATUS_OK) { return (status); } if (media != DL_WIFI) return (DLADM_STATUS_BADARG); if (!(flags & DLADM_OPT_ACTIVE)) return (DLADM_STATUS_TEMPONLY); if (len == (MAX_BUF_LEN - WIFI_BUF_OFFSET)) len = MAX_BUF_LEN - sizeof (dld_ioc_macprop_t) - 1; dip = i_dladm_buf_alloc_by_id(len, linkid, cmd, 0, &status); if (dip == NULL) return (DLADM_STATUS_NOMEM); dp = (uchar_t *)dip->pr_val; if (set) (void) memcpy(dp, buf, len); status = i_dladm_macprop(handle, dip, set); if (status == DLADM_STATUS_OK) { if (!set) (void) memcpy(buf, dp, len); } free(dip); return (status); } dladm_status_t dladm_parse_link_props(char *str, dladm_arg_list_t **listp, boolean_t novalues) { return (dladm_parse_args(str, listp, novalues)); } /* * Retrieve the one link property from the database */ static int i_dladm_get_one_prop(dladm_handle_t handle, datalink_id_t linkid, const char *prop_name, void *arg) { dladm_arg_list_t *proplist = arg; dladm_arg_info_t *aip = NULL; aip = &proplist->al_info[proplist->al_count]; /* * it is fine to point to prop_name since prop_name points to the * prop_table[n].pd_name. */ aip->ai_name = prop_name; (void) dladm_get_linkprop(handle, linkid, DLADM_PROP_VAL_PERSISTENT, prop_name, aip->ai_val, &aip->ai_count); if (aip->ai_count != 0) proplist->al_count++; return (DLADM_WALK_CONTINUE); } /* * Retrieve all link properties for a link from the database and * return a property list. */ dladm_status_t dladm_link_get_proplist(dladm_handle_t handle, datalink_id_t linkid, dladm_arg_list_t **listp) { dladm_arg_list_t *list; dladm_status_t status = DLADM_STATUS_OK; list = calloc(1, sizeof (dladm_arg_list_t)); if (list == NULL) return (dladm_errno2status(errno)); status = dladm_walk_linkprop(handle, linkid, list, i_dladm_get_one_prop); *listp = list; return (status); } /* * Retrieve the named property from a proplist, check the value and * convert to a kernel structure. */ static dladm_status_t i_dladm_link_proplist_extract_one(dladm_handle_t handle, dladm_arg_list_t *proplist, const char *name, uint_t flags, void *arg) { dladm_status_t status = DLADM_STATUS_OK; dladm_arg_info_t *aip = NULL; uint_t i, j; /* Find named property in proplist */ for (i = 0; i < proplist->al_count; i++) { aip = &proplist->al_info[i]; if (strcasecmp(aip->ai_name, name) == 0) break; } /* Property not in list */ if (i == proplist->al_count) return (status); if (aip->ai_val[0] == NULL) return (DLADM_STATUS_BADARG); for (i = 0; i < DLADM_MAX_PROPS; i++) { prop_desc_t *pdp = &prop_table[i]; val_desc_t *vdp; vdp = malloc(sizeof (val_desc_t) * aip->ai_count); if (vdp == NULL) return (DLADM_STATUS_NOMEM); if (strcasecmp(aip->ai_name, pdp->pd_name) != 0) continue; /* Check property value */ if (pdp->pd_check != NULL) { status = pdp->pd_check(handle, pdp, 0, aip->ai_val, &(aip->ai_count), flags, &vdp, 0); } else { status = DLADM_STATUS_BADARG; } if (status != DLADM_STATUS_OK) return (status); for (j = 0; j < DLADM_MAX_RSRC_PROP; j++) { resource_prop_t *rpp = &rsrc_prop_table[j]; if (strcasecmp(aip->ai_name, rpp->rp_name) != 0) continue; /* Extract kernel structure */ if (rpp->rp_extract != NULL) { status = rpp->rp_extract(vdp, aip->ai_count, arg); } else { status = DLADM_STATUS_BADARG; } break; } if (status != DLADM_STATUS_OK) return (status); break; } return (status); } /* * Extract properties from a proplist and convert to mac_resource_props_t. */ dladm_status_t dladm_link_proplist_extract(dladm_handle_t handle, dladm_arg_list_t *proplist, mac_resource_props_t *mrp, uint_t flags) { dladm_status_t status; uint_t i; for (i = 0; i < DLADM_MAX_RSRC_PROP; i++) { status = i_dladm_link_proplist_extract_one(handle, proplist, rsrc_prop_table[i].rp_name, flags, mrp); if (status != DLADM_STATUS_OK) return (status); } return (status); } static const char * dladm_perm2str(uint_t perm, char *buf) { (void) snprintf(buf, DLADM_STRSIZE, "%c%c", ((perm & MAC_PROP_PERM_READ) != 0) ? 'r' : '-', ((perm & MAC_PROP_PERM_WRITE) != 0) ? 'w' : '-'); return (buf); } dladm_status_t dladm_get_state(dladm_handle_t handle, datalink_id_t linkid, link_state_t *state) { uint_t perms; return (i_dladm_get_public_prop(handle, linkid, "state", 0, &perms, state, sizeof (*state))); } boolean_t dladm_attr_is_linkprop(const char *name) { /* non-property attribute names */ const char *nonprop[] = { /* dlmgmtd core attributes */ "name", "class", "media", FPHYMAJ, FPHYINST, FDEVNAME, /* other attributes for vlan, aggr, etc */ DLADM_ATTR_NAMES }; boolean_t is_nonprop = B_FALSE; uint_t i; for (i = 0; i < sizeof (nonprop) / sizeof (nonprop[0]); i++) { if (strcmp(name, nonprop[i]) == 0) { is_nonprop = B_TRUE; break; } } return (!is_nonprop); } dladm_status_t dladm_linkprop_is_set(dladm_handle_t handle, datalink_id_t linkid, dladm_prop_type_t type, const char *prop_name, boolean_t *is_set) { char *buf, **propvals; uint_t valcnt = DLADM_MAX_PROP_VALCNT; uint_t i; dladm_status_t status = DLADM_STATUS_OK; size_t bufsize; *is_set = B_FALSE; bufsize = (sizeof (char *) + DLADM_PROP_VAL_MAX) * DLADM_MAX_PROP_VALCNT; if ((buf = calloc(1, bufsize)) == NULL) return (DLADM_STATUS_NOMEM); propvals = (char **)(void *)buf; for (i = 0; i < valcnt; i++) { propvals[i] = buf + sizeof (char *) * DLADM_MAX_PROP_VALCNT + i * DLADM_PROP_VAL_MAX; } if (dladm_get_linkprop(handle, linkid, type, prop_name, propvals, &valcnt) != DLADM_STATUS_OK) { goto done; } /* * valcnt is always set to 1 by get_pool(), hence we need to check * for a non-null string to see if it is set. For protection, * secondary-macs and allowed-ips, we can check either the *propval * or the valcnt. */ if ((strcmp(prop_name, "pool") == 0 || strcmp(prop_name, "protection") == 0 || strcmp(prop_name, "secondary-macs") == 0 || strcmp(prop_name, "allowed-ips") == 0) && (strlen(*propvals) != 0)) { *is_set = B_TRUE; } else if ((strcmp(prop_name, "cpus") == 0) && (valcnt != 0)) { *is_set = B_TRUE; } else if ((strcmp(prop_name, "_softmac") == 0) && (valcnt != 0) && (strcmp(propvals[0], "true") == 0)) { *is_set = B_TRUE; } done: if (buf != NULL) free(buf); return (status); } static dladm_status_t get_linkmode_prop(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags) { char *s; uint32_t v; dladm_status_t status; status = i_dladm_get_public_prop(handle, linkid, pdp->pd_name, flags, perm_flags, &v, sizeof (v)); if (status != DLADM_STATUS_OK) return (status); switch (v) { case DLADM_PART_CM_MODE: s = "cm"; break; case DLADM_PART_UD_MODE: s = "ud"; break; default: s = ""; break; } (void) snprintf(prop_val[0], DLADM_STRSIZE, "%s", s); *val_cnt = 1; return (DLADM_STATUS_OK); } static dladm_status_t get_promisc_filtered(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media __unused, uint_t flags, uint_t *perm_flags) { char *s; dladm_status_t status; boolean_t filt; status = i_dladm_get_public_prop(handle, linkid, pdp->pd_name, flags, perm_flags, &filt, sizeof (filt)); if (status != DLADM_STATUS_OK) return (status); if (filt != 0) s = link_promisc_filtered_vals[1].vd_name; else s = link_promisc_filtered_vals[0].vd_name; (void) snprintf(prop_val[0], DLADM_STRSIZE, "%s", s); *val_cnt = 1; return (DLADM_STATUS_OK); } static dladm_status_t set_promisc_filtered(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, val_desc_t *vdp, uint_t val_cnt __unused, uint_t flags __unused, datalink_media_t media __unused) { dld_ioc_macprop_t *dip; dladm_status_t status = DLADM_STATUS_OK; dip = i_dladm_buf_alloc_by_name(0, linkid, pdp->pd_name, 0, &status); if (dip == NULL) return (status); (void) memcpy(dip->pr_val, &vdp->vd_val, dip->pr_valsize); status = i_dladm_macprop(handle, dip, B_TRUE); free(dip); return (status); } static dladm_status_t get_media(dladm_handle_t handle, prop_desc_t *pdp, datalink_id_t linkid, char **prop_val, uint_t *val_cnt, datalink_media_t media, uint_t flags, uint_t *perm_flags) { dladm_status_t status = DLADM_STATUS_OK; uint32_t raw_val; val_desc_t *descs; size_t desc_count; if (*val_cnt == 0) return (DLADM_STATUS_TOOSMALL); status = i_dladm_get_public_prop(handle, linkid, pdp->pd_name, flags, perm_flags, &raw_val, sizeof (raw_val)); if (status != DLADM_STATUS_OK) return (status); /* * To translate the property into a string we need to know the actual * datalink_media_t type to use as these values are media-type specific. */ switch (media) { case DL_ETHER: descs = dladm_ether_media_vals; desc_count = VALCNT(dladm_ether_media_vals); break; default: descs = NULL; desc_count = 0; break; } *val_cnt = 1; for (size_t i = 0; i < desc_count; i++) { if (descs[i].vd_val == raw_val) { (void) strlcpy(prop_val[0], descs[i].vd_name, DLADM_PROP_VAL_MAX); return (DLADM_STATUS_OK); } } (void) snprintf(prop_val[0], DLADM_STRSIZE, "unknown (0x%x)", raw_val); return (DLADM_STATUS_OK); }