linkprop.c revision 4045d94132614e1de2073685a6cdd4fbd86bec33
/*
* 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
* 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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <stdlib.h>
#include <strings.h>
#include <errno.h>
#include <ctype.h>
#include <stddef.h>
#include <fcntl.h>
#include <unistd.h>
#include <libdevinfo.h>
#include <zone.h>
#include <libdllink.h>
#include <libdladm_impl.h>
#include <libdlwlan_impl.h>
#include <libdlwlan.h>
#include <libdlvlan.h>
#include <dlfcn.h>
#include <link.h>
#include <inet/wifi_ioctl.h>
#include <libdladm.h>
#include <inttypes.h>
#include <sys/ethernet.h>
/*
* The linkprop get() callback.
* - pd: pointer to the struct prop_desc
* - 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;
/*
* 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.
*/
/*
* 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.
*/
datalink_id_t, char **propstrp,
typedef struct dld_public_prop_s {
char *pp_name;
char *pp_desc;
uint_t, dladm_status_t *);
typedef struct prop_desc {
/*
* link property name
*/
char *pd_name;
/*
* default property value, can be set to { "", NULL }
*/
/*
* 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.
*/
/*
* count of the above optional property values. 0 if pd_optval is NULL.
*/
/*
* callback to set link property;
* set to NULL if this property is read-only
*/
/*
* callback to get modifiable link property
*/
/*
* callback to get current link property
*/
/*
* 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.
*/
/*
* indicate link classes this property applies to.
*/
/*
* indicate link media type this property applies to.
*/
} prop_desc_t;
static dld_public_prop_t dld_prop[] = {
{ DLD_PROP_DUPLEX, sizeof (link_duplex_t),
"duplex", "link duplex mode" },
{DLD_PROP_SPEED, sizeof (uint64_t),
"speed", "link speed (bps)" },
{ DLD_PROP_STATUS, sizeof (link_state_t),
{ DLD_PROP_AUTONEG, sizeof (uint8_t),
"adv_autoneg_cap", "Advertised auto-negotiation" },
{ DLD_PROP_MTU, sizeof (uint32_t),
"mtu", "current link mtu" },
{ DLD_PROP_FLOWCTRL, sizeof (link_flowctrl_t),
"flowctrl", "flowcontrol" },
{ DLD_PROP_ADV_1000FDX_CAP, sizeof (uint8_t),
"adv_1000fdx_cap", "Adv 1000 Mbps fdx" },
{ DLD_PROP_EN_1000FDX_CAP, sizeof (uint8_t),
"en_1000fdx_cap", "Enable 1000 Mbps fdx" },
{ DLD_PROP_ADV_1000HDX_CAP, sizeof (uint8_t),
"adv_1000hdx_cap", "Adv 1000 Mbps hdx" },
{ DLD_PROP_EN_1000HDX_CAP, sizeof (uint8_t),
"en_1000hdx_cap", "Enable 1000 Mbps hdx" },
{ DLD_PROP_ADV_100FDX_CAP, sizeof (uint8_t),
"adv_100fdx_cap", "Adv 100 Mbps fdx" },
{ DLD_PROP_EN_100FDX_CAP, sizeof (uint8_t),
"en_100fdx_cap", "Enable 100 Mbps fdx" },
{ DLD_PROP_ADV_100HDX_CAP, sizeof (uint8_t),
"adv_100hdx_cap", "Adv 100 Mbps hdx" },
{ DLD_PROP_EN_100HDX_CAP, sizeof (uint8_t),
"en_100hdx_cap", "Enable 100 Mbps hdx" },
{ DLD_PROP_ADV_10FDX_CAP, sizeof (uint8_t),
"adv_10fdx_cap", "Adv 10 Mbps fdx" },
{ DLD_PROP_EN_10FDX_CAP, sizeof (uint8_t),
"en_10fdx_cap", "Enable 10 Mbps fdx" },
{ DLD_PROP_ADV_10HDX_CAP, sizeof (uint8_t),
"adv_10hdx_cap", "Adv 10 Mbps hdx" },
{ DLD_PROP_EN_10HDX_CAP, sizeof (uint8_t),
"en_10hdx_cap", "Enable 10 Mbps hdx" },
{ DLD_PROP_PRIVATE, 0,
"driver-private", "" }
};
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 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 prop_desc_t prop_table[] = {
{ "channel", { NULL, 0 },
do_get_channel_prop, NULL, 0,
do_get_radio_prop, NULL, 0,
{ "duplex", { "", 0 },
0, DATALINK_CLASS_PHYS, DL_ETHER },
{ "adv_autoneg_cap", { "1", 1 },
0, DATALINK_CLASS_PHYS, DL_ETHER },
{ "flowctrl", { "", 0 },
0, DATALINK_CLASS_PHYS, DL_ETHER },
{ "adv_1000fdx_cap", { "", 0 },
0, DATALINK_CLASS_PHYS, DL_ETHER },
{ "en_1000fdx_cap", { "", 0 },
0, DATALINK_CLASS_PHYS, DL_ETHER },
{ "adv_1000hdx_cap", { "", 0 },
0, DATALINK_CLASS_PHYS, DL_ETHER },
{ "en_1000hdx_cap", { "", 0 },
0, DATALINK_CLASS_PHYS, DL_ETHER },
{ "adv_100fdx_cap", { "", 0 },
0, DATALINK_CLASS_PHYS, DL_ETHER },
{ "en_100fdx_cap", { "", 0 },
0, DATALINK_CLASS_PHYS, DL_ETHER },
{ "adv_100hdx_cap", { "", 0 },
0, DATALINK_CLASS_PHYS, DL_ETHER },
{ "en_100hdx_cap", { "", 0 },
0, DATALINK_CLASS_PHYS, DL_ETHER },
{ "adv_10fdx_cap", { "", 0 },
0, DATALINK_CLASS_PHYS, DL_ETHER },
{ "en_10fdx_cap", { "", 0 },
0, DATALINK_CLASS_PHYS, DL_ETHER },
{ "adv_10hdx_cap", { "", 0 },
0, DATALINK_CLASS_PHYS, DL_ETHER },
{ "en_10hdx_cap", { "", 0 },
0, DATALINK_CLASS_PHYS, DL_ETHER }
};
char **, uint_t);
char **, 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
{
int i, j;
for (j = 0; j < val_cnt; j++) {
for (i = 0; i < pdp->pd_noptval; i++) {
if (strcasecmp(*prop_val,
break;
}
}
if (i == pdp->pd_noptval) {
goto done;
}
}
done:
return (status);
}
static dladm_status_t
{
return (DLADM_STATUS_BADARG);
return (DLADM_STATUS_BADARG);
return (DLADM_STATUS_TEMPONLY);
if (!(flags & DLADM_OPT_ACTIVE))
return (DLADM_STATUS_OK);
return (DLADM_STATUS_PROPRDONLY);
else
return (DLADM_STATUS_NOMEM);
} else {
}
if (status != DLADM_STATUS_OK)
goto done;
} else {
return (DLADM_STATUS_NOTSUP);
return (DLADM_STATUS_NOMEM);
sizeof (val_desc_t));
} else {
return (status);
}
cnt = 1;
}
if (needfree) {
for (i = 0; i < cnt; i++)
}
done:
return (status);
}
static dladm_status_t
{
int i;
if (status != DLADM_STATUS_OK)
return (status);
for (i = 0; i < DLADM_MAX_PROPS; i++) {
continue;
status = s;
break;
} else {
if (s != DLADM_STATUS_OK &&
s != DLADM_STATUS_NOTSUP)
status = s;
}
}
if (!found) {
if (prop_name[0] == '_') {
/* other private properties */
} else {
}
}
return (status);
}
/*
*/
{
return (DLADM_STATUS_BADARG);
}
if (status != DLADM_STATUS_OK)
return (status);
if (flags & DLADM_OPT_PERSIST) {
}
return (status);
}
/*
* Walk link properties of the given specific link.
*/
int (*func)(datalink_id_t, const char *, void *))
{
int i;
return (DLADM_STATUS_BADARG);
if (status != DLADM_STATUS_OK)
return (status);
for (i = 0; i < DLADM_MAX_PROPS; i++) {
continue;
continue;
break;
}
}
return (DLADM_STATUS_OK);
}
/*
* Get linkprop of the given specific link.
*/
{
int i;
if (type == DLADM_PROP_VAL_DEFAULT)
return (DLADM_STATUS_BADARG);
for (i = 0; i < DLADM_MAX_PROPS; i++)
break;
if (i == DLADM_MAX_PROPS) {
if (prop_name[0] == '_') {
/*
* private property.
*/
} else {
return (DLADM_STATUS_NOTFOUND);
}
}
pdp = &prop_table[i];
if (status != DLADM_STATUS_OK)
return (status);
return (DLADM_STATUS_BADARG);
return (DLADM_STATUS_BADARG);
switch (type) {
case DLADM_PROP_VAL_CURRENT:
break;
case DLADM_PROP_VAL_DEFAULT:
break;
}
} else {
}
*val_cntp = 1;
break;
break;
}
if (cnt == 0) {
} else {
for (i = 0; i < cnt; i++) {
}
}
break;
return (DLADM_STATUS_TEMPONLY);
break;
default:
break;
}
return (status);
}
/*ARGSUSED*/
static int
{
DLADM_MAX_PROP_VALCNT)) == NULL) {
return (DLADM_WALK_CONTINUE);
}
for (i = 0; i < valcnt; i++) {
sizeof (char *) * DLADM_MAX_PROP_VALCNT +
i * DLADM_PROP_VAL_MAX;
}
goto done;
}
done:
return (DLADM_WALK_CONTINUE);
}
/*ARGSUSED*/
static int
{
(void) dladm_init_linkprop(linkid);
return (DLADM_WALK_CONTINUE);
}
{
if (linkid == DATALINK_ALL_LINKID) {
} else {
}
return (DLADM_STATUS_OK);
}
/* ARGSUSED */
static dladm_status_t
{
char zone_name[ZONENAME_MAX];
if (flags != 0)
return (DLADM_STATUS_NOTSUP);
if (status != DLADM_STATUS_OK)
return (status);
*val_cnt = 1;
if (zid != GLOBAL_ZONEID) {
return (dladm_errno2status(errno));
} else {
*prop_val[0] = '\0';
}
return (DLADM_STATUS_OK);
}
typedef int (*zone_get_devroot_t)(char *, char *, size_t);
static int
{
char root[MAXPATHLEN];
void *dlhandle;
void *sym;
int ret;
return (-1);
return (-1);
}
return (ret);
}
static dladm_status_t
{
char path[MAXPATHLEN];
char name[MAXLINKNAMELEN];
char zone_name[ZONENAME_MAX];
int ret;
return (dladm_errno2status(errno));
return (dladm_errno2status(errno));
return (dladm_errno2status(errno));
if (status != DLADM_STATUS_OK)
goto cleanup;
if (add)
else
if (ret != 0) {
goto cleanup;
}
if (di_prof_commit(prof) != 0)
if (prof)
return (status);
}
/* ARGSUSED */
static dladm_status_t
{
char link[MAXLINKNAMELEN];
if (val_cnt != 1)
return (DLADM_STATUS_BADVALCNT);
if (status != DLADM_STATUS_OK)
return (status);
/* Do nothing if setting to current value */
return (DLADM_STATUS_OK);
return (status);
}
if (zid_new != GLOBAL_ZONEID) {
/*
* If the new zoneid is the global zone, we could destroy
* the link (in the case of an implicitly-created VLAN) as a
* result of the dladm_setzid() operation. In that case,
* we defer the operation to the end of this function to avoid
* recreating the VLAN and getting a different linkid during
* the rollback if other operation fails.
*
* Otherwise, dladm_setzid() will hold a reference to the
* link and prevent a link renaming, so we need to do it
* before other operations.
*/
if (status != DLADM_STATUS_OK)
return (status);
}
if (zid_old != GLOBAL_ZONEID) {
goto rollback1;
}
/*
* It is okay to fail to update the /dev entry (some
* vanity-named links do not have a /dev entry).
*/
}
if (zid_new != GLOBAL_ZONEID) {
goto rollback2;
}
} else {
if (status != DLADM_STATUS_OK)
goto rollback2;
}
return (DLADM_STATUS_OK);
if (zid_old != GLOBAL_ZONEID)
if (zid_old != GLOBAL_ZONEID)
if (zid_new != GLOBAL_ZONEID)
return (status);
}
/* ARGSUSED */
static dladm_status_t
{
if (val_cnt != 1)
return (DLADM_STATUS_BADVALCNT);
return (DLADM_STATUS_BADVAL);
if (zid != GLOBAL_ZONEID) {
sizeof (flags)) < 0) {
return (dladm_errno2status(errno));
}
if (!(flags & ZF_NET_EXCL)) {
return (DLADM_STATUS_BADVAL);
}
}
return (DLADM_STATUS_OK);
}
/* ARGSUSED */
static dladm_status_t
{
if (flags & DLD_DEFAULT)
return (DLADM_STATUS_NOTSUP);
return (dladm_errno2status(errno));
*val_cnt = 1;
(*prop_val)[0] = '\0';
goto done;
}
if (i != 0) {
len += 1;
}
}
}
done:
return (DLADM_STATUS_OK);
}
/* ARGSUSED */
static dladm_status_t
{
int fd, i;
int ic_cmd;
if (val_cnt != 1)
return (DLADM_STATUS_BADVALCNT);
return (dladm_errno2status(errno));
FMNAMESZ+1);
}
} else {
}
return (status);
}
/*
* Add the specified module to the dlautopush structure; returns a
* DLADM_STATUS_* code.
*/
{
return (DLADM_STATUS_BADVAL);
/*
* 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);
return (DLADM_STATUS_BADVAL);
return (DLADM_STATUS_OK);
}
return (DLADM_STATUS_BADVALCNT);
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(1M) file.
*/
/* ARGSUSED */
static dladm_status_t
{
char *module;
struct dlautopush *dlap;
char val[DLADM_PROP_VAL_MAX];
char delimiters[4];
if (val_cnt != 1)
return (DLADM_STATUS_BADVALCNT);
return (DLADM_STATUS_NOMEM);
if (status != DLADM_STATUS_OK)
return (status);
}
return (DLADM_STATUS_OK);
}
/* ARGSUSED */
static dladm_status_t
{
uint_t i;
goto done;
}
if (status != DLADM_STATUS_OK)
goto done;
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++) {
}
done:
return (status);
}
static dladm_status_t
{
}
/* ARGSUSED */
static dladm_status_t
{
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:
default:
return (DLADM_STATUS_BADARG);
}
}
static dladm_status_t
{
int i;
return (DLADM_STATUS_NOMEM);
return (status);
}
/* ARGSUSED */
static dladm_status_t
{
/*
* can currently set rate on WIFI links only.
*/
return (DLADM_STATUS_PROPRDONLY);
if (val_cnt != 1)
return (DLADM_STATUS_BADVALCNT);
done:
return (status);
}
/* ARGSUSED */
static dladm_status_t
{
int i;
if (val_cnt != 1)
return (DLADM_STATUS_BADVALCNT);
goto done;
}
for (i = 0; i < MAX_SUPPORT_RATES; i++) {
i * DLADM_STRSIZE;
}
if (status != DLADM_STATUS_OK)
goto done;
for (i = 0; i < modval_cnt; i++) {
break;
}
}
if (i == modval_cnt)
done:
return (status);
}
static dladm_status_t
{
}
/* ARGSUSED */
static dladm_status_t
{
return (DLADM_STATUS_NOMEM);
goto done;
&channel)) {
goto done;
}
*val_cnt = 1;
done:
return (status);
}
static dladm_status_t
{
}
/* ARGSUSED */
static dladm_status_t
{
const char *s;
return (DLADM_STATUS_NOMEM);
goto done;
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:
goto done;
}
*val_cnt = 1;
done:
return (status);
}
static dladm_status_t
{
switch (*pm) {
case DLADM_WLAN_PM_OFF:
break;
case DLADM_WLAN_PM_MAX:
break;
case DLADM_WLAN_PM_FAST:
break;
default:
return (DLADM_STATUS_NOTSUP);
}
sizeof (ps_mode)));
}
/* ARGSUSED */
static dladm_status_t
{
if (val_cnt != 1)
return (DLADM_STATUS_BADVALCNT);
return (status);
}
static dladm_status_t
{
}
/* ARGSUSED */
static dladm_status_t
{
const char *s;
return (DLADM_STATUS_NOMEM);
goto done;
switch (radio) {
case B_TRUE:
s = "on";
break;
case B_FALSE:
s = "off";
break;
default:
goto done;
}
*val_cnt = 1;
done:
return (status);
}
static dladm_status_t
{
wl_radio_t r;
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);
}
}
/* ARGSUSED */
static dladm_status_t
{
if (val_cnt != 1)
return (DLADM_STATUS_BADVALCNT);
return (status);
}
static dladm_status_t
{
char buf[MAXLINELEN];
int i;
if (status != DLADM_STATUS_OK)
return (status);
/*
* reset case.
*/
if (val_cnt == 0) {
if (status == DLADM_STATUS_OK)
goto done;
}
buf[0] = '\0';
for (i = 0; i < val_cnt; i++) {
if (i != val_cnt - 1)
}
if (status == DLADM_STATUS_OK)
done:
return (status);
}
static dladm_status_t
{
if (status != DLADM_STATUS_OK)
return (status);
if (status != DLADM_STATUS_OK)
goto done;
goto done;
}
}
done:
return (status);
}
static dld_public_prop_t *
dladm_name2prop(const char *prop_name)
{
break;
}
return (p);
}
static dld_ioc_prop_t *
{
int dsize;
p = dladm_name2prop(prop_name);
if (p->pp_id != DLD_PROP_PRIVATE)
valsize = p->pp_valsize;
return (NULL);
}
return (dip);
}
/* ARGSUSED */
static dladm_status_t
{
void *val;
return (status);
else {
/*
* No need (yet) to distinguish these from arrays of same size.
*/
switch (dip->pr_valsize) {
case 1:
break;
case 2:
break;
case 4:
break;
default:
break;
}
}
goto done;
}
done:
return (status);
}
static dld_ioc_prop_t *
{
return (NULL);
goto done;
}
}
done:
if (*status != DLADM_STATUS_OK) {
return (NULL);
}
return (dip);
}
/* ARGSUSED */
static dladm_status_t
{
if (val_cnt != 1)
return (DLADM_STATUS_BADVAL);
return (DLADM_STATUS_OK);
}
/* ARGSUSED */
static dladm_status_t
{
if (flags & DLD_DEFAULT)
return (DLADM_STATUS_NOTSUP);
KSTAT_DATA_UINT32, &link_duplex)) != 0)
return (status);
switch (link_duplex) {
case LINK_DUPLEX_FULL:
break;
case LINK_DUPLEX_HALF:
break;
default:
break;
}
*val_cnt = 1;
return (DLADM_STATUS_OK);
}
/* ARGSUSED */
static dladm_status_t
{
if (flags & DLD_DEFAULT)
return (DLADM_STATUS_NOTSUP);
KSTAT_DATA_UINT64, &ifspeed)) != 0)
return (status);
if ((ifspeed % 1000000) != 0) {
} else {
}
*val_cnt = 1;
return (DLADM_STATUS_OK);
}
/* ARGSUSED */
static dladm_status_t
{
if (flags & DLD_DEFAULT)
return (DLADM_STATUS_NOTSUP);
if (status != DLADM_STATUS_OK)
return (status);
switch (link_state) {
case LINK_STATE_UP:
break;
case LINK_STATE_DOWN:
break;
default:
break;
}
*val_cnt = 1;
return (DLADM_STATUS_OK);
}
/* ARGSUSED */
static dladm_status_t
{
return (status);
*val_cnt = 1;
return (DLADM_STATUS_OK);
}
/* ARGSUSED */
static dladm_status_t
{
uint32_t v = 0;
return (status);
*val_cnt = 1;
return (DLADM_STATUS_OK);
}
/* ARGSUSED */
static dladm_status_t
{
return (status);
switch (v) {
case LINK_FLOWCTRL_NONE:
break;
case LINK_FLOWCTRL_RX:
break;
case LINK_FLOWCTRL_TX:
break;
case LINK_FLOWCTRL_BI:
break;
}
*val_cnt = 1;
return (DLADM_STATUS_OK);
}
/* ARGSUSED */
static dladm_status_t
{
return (DLADM_STATUS_BADARG);
p = dladm_name2prop(prop_name);
if (p->pp_id != DLD_PROP_PRIVATE)
return (DLADM_STATUS_BADARG);
/*
* 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++) {
}
/*
* getting default value. so use more buffer space.
*/
bufsize += 1024;
}
return (status);
slen = 0;
goto done;
}
goto done;
}
} else {
for (i = 0; i < val_cnt; i++) {
int plen = 0;
/*
* add a "," separator and update dp.
*/
if (i != (val_cnt -1))
}
}
}
done:
if (fd > 0)
return (status);
}
static dladm_status_t
{
int fd;
char tmp = '\0';
return (DLADM_STATUS_BADARG);
p = dladm_name2prop(prop_name);
if (p->pp_id != DLD_PROP_PRIVATE)
return (DLADM_STATUS_BADARG);
if (type == DLADM_PROP_VAL_MODIFIABLE) {
*val_cnt = 1;
return (DLADM_STATUS_OK);
}
/*
* private properties: all parsing is done in the kernel.
*/
return (status);
return (DLADM_STATUS_BADARG);
}
} else {
*val_cnt = 1;
}
return (status);
}
static dladm_status_t
{
int i;
/*
* 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;
for (i = 0; i < DLADM_MAX_PROP_VALCNT; i++) {
sizeof (char *) * DLADM_MAX_PROP_VALCNT +
i * DLADM_PROP_VAL_MAX;
}
if (status == DLADM_STATUS_OK) {
}
return (status);
}