/*ARGSUSED*/ static dladm_status_t print_flow(show_flow_state_t *state, dladm_flow_attr_t *attr, flow_fields_buf_t *fbuf) { char link[MAXLINKNAMELEN]; dladm_status_t status; if ((status = dladm_datalink_id2info(handle, attr->fa_linkid, NULL, NULL, NULL, link, sizeof (link))) != DLADM_STATUS_OK) { return (status); } (void) snprintf(fbuf->flow_name, sizeof (fbuf->flow_name), "%s", attr->fa_flowname); (void) snprintf(fbuf->flow_link, sizeof (fbuf->flow_link), "%s", link); (void) dladm_flow_attr_ip2str(attr, fbuf->flow_ipaddr, sizeof (fbuf->flow_ipaddr)); (void) dladm_flow_attr_proto2str(attr, fbuf->flow_proto, sizeof (fbuf->flow_proto)); if ((attr->fa_flow_desc.fd_mask & FLOW_ULP_PORT_LOCAL) != 0) { (void) dladm_flow_attr_port2str(attr, fbuf->flow_lport, sizeof (fbuf->flow_lport)); } if ((attr->fa_flow_desc.fd_mask & FLOW_ULP_PORT_REMOTE) != 0) { (void) dladm_flow_attr_port2str(attr, fbuf->flow_rport, sizeof (fbuf->flow_rport)); } (void) dladm_flow_attr_dsfield2str(attr, fbuf->flow_dsfield, sizeof (fbuf->flow_dsfield)); return (DLADM_STATUS_OK); }
int collect_link_names( dladm_handle_t handle, datalink_id_t link_id, void* arg ) { char** it = arg; dladm_datalink_id2info( handle, link_id, NULL, NULL, NULL, *it, MAXLINKNAMELEN ); *it += MAXLINKNAMELEN; return DLADM_WALK_CONTINUE; }
vlan_infos_t* get_vlan_infos() { char* links; int links_len = 0; dladm_walk_datalink_id( &count_links, handle, &links_len, DATALINK_CLASS_VLAN, DATALINK_ANY_MEDIATYPE, DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST ); char* links_it = links = malloc( links_len * MAXLINKNAMELEN ); dladm_walk_datalink_id( &collect_link_names, handle, &links_it, DATALINK_CLASS_VLAN, DATALINK_ANY_MEDIATYPE, DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST ); vlan_infos_t* infos = malloc_vlan_infos( links_len ); infos->len = links_len; for ( int i = 0; i < links_len; ++i ) { char* name = links + i * MAXLINKNAMELEN; datalink_id_t vlanid = { 0 }; dladm_vlan_attr_t vinfo; char parent[ MAXLINKNAMELEN ] = { 0 }; strcpy( infos->vlan_infos[ i ]->name, name ); if ( DLADM_STATUS_OK != dladm_name2info( handle, name, &vlanid, NULL, NULL, NULL ) ) { } else { dladm_vlan_info( handle, vlanid, &vinfo, DLADM_OPT_ACTIVE ); if ( DLADM_STATUS_OK != dladm_datalink_id2info( handle, vinfo.dv_linkid, NULL, NULL, NULL, parent, sizeof( parent ) ) ) { } else { infos->vlan_infos[ i ]->tag = vinfo.dv_vid; strcpy( infos->vlan_infos[ i ]->link, parent ); } } } free( links ); return infos; }
/* * Wrapper of dladm_walk_flow(show_walk_fn,...) to make it * usable to dladm_walk_datalink_id() */ static int show_flowprop_onelink(dladm_handle_t dh, datalink_id_t linkid, void *arg) { char name[MAXLINKNAMELEN]; if (dladm_datalink_id2info(dh, linkid, NULL, NULL, NULL, name, sizeof (name)) != DLADM_STATUS_OK) return (DLADM_WALK_TERMINATE); (void) dladm_walk_flow(show_flowprop, dh, linkid, arg, B_FALSE); return (DLADM_WALK_CONTINUE); }
static int dladm_callback(dladm_handle_t dh, datalink_id_t linkid, void *obj) { dladm_status_t status; char link[MAXLINKNAMELEN]; datalink_class_t dl_class; uint32_t flags; std::list<std::string> *interfaces = (std::list<std::string> *)(obj); if ((status = dladm_datalink_id2info(g_handle, linkid, &flags, &dl_class, NULL, link, sizeof (link))) != DLADM_STATUS_OK) { return (status); } interfaces->push_back(link); return (DLADM_WALK_CONTINUE); }
char* get_etherstub_parameter( char *name, char* parameter) { dladm_status_t status; datalink_class_t class; datalink_id_t linkid; uint_t maxpropertycnt = 1; uint32_t flags = DLADM_OPT_ACTIVE; status = dladm_name2info(handle, name, &linkid, NULL, &class, NULL); if (status != DLADM_STATUS_OK) return NULL; char *value = (char*)malloc(MAXLENGTH); dladm_vnic_attr_t vinfo; if(strcasecmp("OVER", parameter) == 0) { if (dladm_vnic_info(handle, linkid, &vinfo, flags) != DLADM_STATUS_OK) { (void) strcpy(value, "?"); return value; } if (dladm_datalink_id2info(handle, vinfo.va_link_id, NULL, NULL, NULL, value, MAXLENGTH) != DLADM_STATUS_OK) (void) strcpy(value, "?"); } else if(strcasecmp("MTU", parameter) == 0 || strcasecmp("BRIDGE", parameter) == 0 || strcasecmp("STATE", parameter) == 0) { status = dladm_get_linkprop(handle, linkid, DLADM_PROP_VAL_CURRENT, parameter, &value, &maxpropertycnt); } else if(strcasecmp("CLASS", parameter) == 0) { (void) dladm_class2str(class, value); }
/*ARGSUSED*/ static int net_getinfo(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flag, char **info, char **errstr, nvlist_t *proplist, rcm_info_t **depend_info) { int len; dladm_status_t status; char link[MAXLINKNAMELEN]; char errmsg[DLADM_STRSIZE]; char *exported; const char *info_fmt; net_cache_t *node; assert(hd != NULL); assert(rsrc != NULL); assert(id == (id_t)0); assert(info != NULL); assert(depend_info != NULL); rcm_log_message(RCM_TRACE1, _("NET: getinfo(%s)\n"), rsrc); info_fmt = _("Network interface %s"); (void) mutex_lock(&cache_lock); node = cache_lookup(rsrc); if (!node) { rcm_log_message(RCM_WARNING, _("NET: unrecognized resource %s\n"), rsrc); (void) mutex_unlock(&cache_lock); errno = ENOENT; return (RCM_FAILURE); } len = strlen(info_fmt) + MAXLINKNAMELEN + 1; if ((status = dladm_datalink_id2info(dld_handle, node->linkid, NULL, NULL, NULL, link, sizeof (link))) != DLADM_STATUS_OK) { rcm_log_message(RCM_ERROR, _("NET: usage(%s) get link name failure(%s)\n"), node->resource, dladm_status2str(status, errmsg)); (void) mutex_unlock(&cache_lock); return (RCM_FAILURE); } else if ((*info = (char *)malloc(len)) == NULL) { rcm_log_message(RCM_ERROR, _("NET: malloc failure")); (void) mutex_unlock(&cache_lock); return (RCM_FAILURE); } /* Fill in the string */ (void) snprintf(*info, len, info_fmt, link); len = strlen("SUNW_datalink/") + LINKID_STR_WIDTH + 1; exported = malloc(len); if (!exported) { rcm_log_message(RCM_ERROR, _("NET: allocation failure")); free(*info); (void) mutex_unlock(&cache_lock); return (RCM_FAILURE); } (void) snprintf(exported, len, "SUNW_datalink/%u", node->linkid); (void) mutex_unlock(&cache_lock); /* Get dependent info if requested */ if ((flag & RCM_INCLUDE_DEPENDENT) || (flag & RCM_INCLUDE_SUBTREE)) { (void) rcm_get_info(hd, exported, flag, depend_info); } (void) nvlist_add_string(proplist, RCM_CLIENT_NAME, "SunOS"); (void) nvlist_add_string_array(proplist, RCM_CLIENT_EXPORTS, &exported, 1); free(exported); return (RCM_SUCCESS); }
static int dltran_dump_transceivers(dladm_handle_t hdl, datalink_id_t linkid, void *arg) { dladm_status_t status; char name[MAXLINKNAMELEN]; dld_ioc_gettran_t gt; uint_t count, i, tranid = UINT_MAX; boolean_t tran_found = B_FALSE; uint_t *tranidp = arg; if (tranidp != NULL) tranid = *tranidp; if ((status = dladm_datalink_id2info(hdl, linkid, NULL, NULL, NULL, name, sizeof (name))) != DLADM_STATUS_OK) { (void) fprintf(stderr, "failed to get datalink name for link " "%d: %s", linkid, dladm_status2str(status, dltran_dlerrmsg)); dltran_errors++; return (DLADM_WALK_CONTINUE); } bzero(>, sizeof (gt)); gt.dgt_linkid = linkid; gt.dgt_tran_id = DLDIOC_GETTRAN_GETNTRAN; if (ioctl(dladm_dld_fd(hdl), DLDIOC_GETTRAN, >) != 0) { if (errno != ENOTSUP) { (void) fprintf(stderr, "failed to get transceiver " "count for device %s: %s\n", name, strerror(errno)); dltran_errors++; } return (DLADM_WALK_CONTINUE); } count = gt.dgt_tran_id; (void) printf("%s: discovered %d transceiver%s\n", name, count, count > 1 ? "s" : ""); for (i = 0; i < count; i++) { if (tranid != UINT_MAX && i != tranid) continue; if (tranid != UINT_MAX) tran_found = B_TRUE; bzero(>, sizeof (gt)); gt.dgt_linkid = linkid; gt.dgt_tran_id = i; if (ioctl(dladm_dld_fd(hdl), DLDIOC_GETTRAN, >) != 0) { (void) fprintf(stderr, "failed to get tran info for " "%s: %s\n", name, strerror(errno)); dltran_errors++; return (DLADM_WALK_CONTINUE); } if (dltran_hex && !gt.dgt_present) continue; if (!dltran_hex && !dltran_write) { (void) printf("\ttransceiver %d present: %s\n", i, gt.dgt_present ? "yes" : "no"); if (!gt.dgt_present) continue; (void) printf("\ttransceiver %d usable: %s\n", i, gt.dgt_usable ? "yes" : "no"); } if (dltran_verbose) { dltran_verbose_dump(linkid, i); } if (dltran_write) { if (!gt.dgt_present) { (void) fprintf(stderr, "warning: no " "transceiver present in port %d, not " "writing\n", i); dltran_errors++; continue; } dltran_write_page(linkid, i); } if (dltran_hex) { printf("transceiver %d data:\n", i); dltran_hex_dump(linkid, i); } } if (tranid != UINT_MAX && !tran_found) { dltran_errors++; (void) fprintf(stderr, "failed to find transceiver %d on " "link %s\n", tranid, name); } return (DLADM_WALK_CONTINUE); }
static int aoeadm_list_ports(int argc, char **argv) { AOE_STATUS ret; aoe_port_list_t *portlist = NULL; char c; dladm_handle_t handle; int i; int portid = -1; int verbose = 0; uint32_t nports; while ((c = getopt(argc, argv, "v")) != -1) { switch (c) { case 'v': verbose = 1; break; default: usage(); } } argc -= optind; argv += optind; if (argc == 1) { errno = 0; portid = strtol(argv[0], (char **)NULL, 10); if (errno != 0 || portid < 0) usage(); } ret = aoe_get_port_list(&nports, &portlist); if (ret != AOE_STATUS_OK) { (void) fprintf(stderr, _("Failed to list ports: %s\n"), aoe_strerror(ret)); return (ret); } if (nports == 0) { free(portlist); return (0); } if (dladm_open(&handle) != DLADM_STATUS_OK) handle = NULL; for (i = 0; i < nports; i++) { aoe_port_instance_t *pi = &portlist->ports[i]; char linknames[AOE_MAX_MACOBJ * MAXLINKNAMELEN]; int j; if (portid >= 0 && pi->api_port_id != portid) continue; if ((pi->api_port_type == AOE_CLIENT_INITIATOR && strcmp(cmdname, "list-target") == 0) || (pi->api_port_type == AOE_CLIENT_TARGET && strcmp(cmdname, "list-initiator") == 0)) continue; /* Convert linkid to interface name */ for (j = 0; j < pi->api_mac_cnt; j++) { aoe_mac_instance_t *mi = &pi->api_mac[j]; char *linkname = linknames + j * MAXLINKNAMELEN; if (handle == NULL || dladm_datalink_id2info(handle, mi->ami_mac_linkid, NULL, NULL, NULL, linkname, MAXLINKNAMELEN - 1) != DLADM_STATUS_OK) (void) strcpy(linkname, "<unknown>"); } print_port_info(pi, linknames, verbose); if (portid >= 0) { if (handle != NULL) dladm_close(handle); free(portlist); return (0); } } if (handle != NULL) dladm_close(handle); free(portlist); return (portid >= 0 ? 1 : 0); }
/* * Callback function that configures a single datalink in a non-global zone. */ static int i_ipadm_zone_network_attr(dladm_handle_t dh, datalink_id_t linkid, void *arg) { ngz_walk_data_t *nwd = arg; zoneid_t zoneid = nwd->ngz_zoneid; uint8_t buf[PIPE_BUF]; dladm_status_t dlstatus; ipadm_status_t ipstatus; char link[MAXLINKNAMELEN]; ipadm_handle_t iph = nwd->ngz_iph; int rtsock = iph->iph_rtsock; char *ifname = nwd->ngz_ifname; boolean_t s10c = nwd->ngz_s10c; boolean_t is_ipmgmtd = (iph->iph_flags & IPH_IPMGMTD); size_t bufsize = sizeof (buf); bzero(buf, bufsize); ipstatus = i_ipadm_zone_get_network(zoneid, linkid, ZONE_NETWORK_ADDRESS, buf, &bufsize); if (ipstatus != IPADM_SUCCESS) goto fail; dlstatus = dladm_datalink_id2info(dh, linkid, NULL, NULL, NULL, link, sizeof (link)); if (dlstatus != DLADM_STATUS_OK) return (DLADM_WALK_CONTINUE); /* * if ifname has been specified, then skip interfaces that don't match */ if (ifname != NULL && strcmp(ifname, link) != 0) return (DLADM_WALK_CONTINUE); /* * Plumb the interface and configure addresses on for S10 Containers. * We need to always do this for S10C because ipadm persistent * configuration is not available in S10C. For ipkg zones, * we skip the actual plumbing/configuration, but will call the * (*ngz_persist_if)() callback to create the persistent state for the * interface. The interface will be configured in ipkg zones when * ipadm_enable_if() is invoked to restore persistent configuration. */ if (is_ipmgmtd && !s10c) { (void) i_ipadm_ngz_persist_if(link, (char *)buf, nwd->ngz_persist_if); return (DLADM_WALK_CONTINUE); } ipstatus = i_ipadm_ngz_addr(iph, link, (char *)buf); if (ipstatus != IPADM_SUCCESS) goto fail; /* apply any default router information. */ bufsize = sizeof (buf); bzero(buf, bufsize); ipstatus = i_ipadm_zone_get_network(zoneid, linkid, ZONE_NETWORK_DEFROUTER, buf, &bufsize); if (ipstatus != IPADM_SUCCESS) goto fail; i_ipadm_create_ngz_route(rtsock, link, buf, bufsize); return (DLADM_WALK_CONTINUE); fail: if (ifname != NULL) { nwd->ngz_ipstatus = ipstatus; return (DLADM_WALK_TERMINATE); } return (DLADM_WALK_CONTINUE); }