int dladm_init() {
dladm_status_t dlstat;
char errmsg[DLADM_STRSIZE];
dlstat = dladm_open(&g_handle);
if (dlstat != DLADM_STATUS_OK) {
fprintf(stderr, "dladm_open: %s\n", dladm_status2str(dlstat, errmsg));
return 1;
}
return 0;
}
/* PRINTFLIKE2 */
static void
warn_dlerr(dladm_status_t err, const char *format, ...)
{
va_list alist;
char errmsg[DLADM_STRSIZE];
format = gettext(format);
(void) fprintf(stderr, gettext("%s: warning: "), progname);
va_start(alist, format);
(void) vfprintf(stderr, format, alist);
va_end(alist);
(void) fprintf(stderr, ": %s\n", dladm_status2str(err, errmsg));
}
/* PRINTFLIKE2 */
static void
die_dlerr(dladm_status_t err, const char *format, ...)
{
va_list alist;
char errmsg[DLADM_STRSIZE];
format = gettext(format);
(void) fprintf(stderr, "%s: ", progname);
va_start(alist, format);
(void) vfprintf(stderr, format, alist);
va_end(alist);
(void) fprintf(stderr, ": %s\n", dladm_status2str(err, errmsg));
/* close dladm handle if it was opened */
if (handle != NULL)
dladm_close(handle);
exit(EXIT_FAILURE);
}
/*
* rcm_mod_init()
*
* Update registrations, and return the ops structure.
*/
struct rcm_mod_ops *
rcm_mod_init(void)
{
dladm_status_t status;
char errmsg[DLADM_STRSIZE];
cache_head.next = &cache_tail;
cache_head.prev = NULL;
cache_tail.prev = &cache_head;
cache_tail.next = NULL;
(void) mutex_init(&cache_lock, NULL, NULL);
if ((status = dladm_open(&dld_handle)) != DLADM_STATUS_OK) {
rcm_log_message(RCM_WARNING,
"NET: mod_init failed: cannot open datalink handle: %s\n",
dladm_status2str(status, errmsg));
return (NULL);
}
/* Return the ops vectors */
return (&net_ops);
}
/*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);
}
int
main(int argc, char *argv[])
{
int c;
dladm_status_t status;
const char *outfile = NULL;
uint_t count = 0;
dltran_progname = basename(argv[0]);
while ((c = getopt(argc, argv, ":xvw:")) != -1) {
switch (c) {
case 'v':
dltran_verbose = B_TRUE;
break;
case 'x':
dltran_hex = B_TRUE;
break;
case 'w':
dltran_write = B_TRUE;
outfile = optarg;
break;
case ':':
dltran_usage("option -%c requires an "
"operand\n", optopt);
return (2);
case '?':
default:
dltran_usage("unknown option: -%c\n", optopt);
return (2);
}
}
argc -= optind;
argv += optind;
if (dltran_verbose)
count++;
if (dltran_hex)
count++;
if (dltran_write)
count++;
if (count > 1) {
(void) fprintf(stderr, "only one of -v, -w, and -x may be "
"specified\n");
return (2);
}
if (dltran_write) {
if ((dltran_outfd = open(outfile, O_RDWR | O_TRUNC | O_CREAT,
0644)) < 0) {
(void) fprintf(stderr, "failed to open output file "
"%s: %s\n", outfile, strerror(errno));
return (1);
}
}
if ((status = dladm_open(&dltran_hdl)) != DLADM_STATUS_OK) {
(void) fprintf(stderr, "failed to open /dev/dld: %s\n",
dladm_status2str(status, dltran_dlerrmsg));
return (1);
}
if (argc == 0) {
(void) dladm_walk_datalink_id(dltran_dump_transceivers,
dltran_hdl, NULL, DATALINK_CLASS_PHYS,
DATALINK_ANY_MEDIATYPE, DLADM_OPT_ACTIVE);
} else {
int i;
char *c;
for (i = 0; i < argc; i++) {
uint_t tran;
uint_t *tranidp = NULL;
datalink_id_t linkid;
if ((c = strrchr(argv[i], '/')) != NULL) {
unsigned long u;
char *eptr;
c++;
errno = 0;
u = strtoul(c, &eptr, 10);
if (errno != 0 || *eptr != '\0' ||
u >= UINT_MAX) {
(void) fprintf(stderr, "failed to "
"parse link/transceiver: %s\n",
argv[i]);
return (1);
}
c--;
*c = '\0';
tran = (uint_t)u;
tranidp = &tran;
}
if ((status = dladm_name2info(dltran_hdl, argv[i],
&linkid, NULL, NULL, NULL)) != DLADM_STATUS_OK) {
(void) fprintf(stderr, "failed to get link "
"id for link %s: %s\n", argv[i],
dladm_status2str(status, dltran_dlerrmsg));
return (1);
}
(void) dltran_dump_transceivers(dltran_hdl, linkid,
tranidp);
}
}
return (dltran_errors != 0 ? 1 : 0);
}
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);
}