?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge commit '00f1a4f432b3d8aad1aa270e91c44c57f03ef407'
[unleashed.git] / usr / src / cmd / dladm / dladm.c
blob7c05549a0f4f9c8b8768c83d4141d06ba89f36bb
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright 2016 Nexenta Systems, Inc.
25 */
26
27 #include <stdio.h>
28 #include <ctype.h>
29 #include <dlfcn.h>
30 #include <locale.h>
31 #include <signal.h>
32 #include <stdarg.h>
33 #include <stdlib.h>
34 #include <fcntl.h>
35 #include <string.h>
36 #include <stropts.h>
37 #include <sys/stat.h>
38 #include <errno.h>
39 #include <kstat.h>
40 #include <strings.h>
41 #include <getopt.h>
42 #include <unistd.h>
43 #include <priv.h>
44 #include <limits.h>
45 #include <termios.h>
46 #include <pwd.h>
47 #include <auth_attr.h>
48 #include <auth_list.h>
49 #include <libintl.h>
50 #include <libdevinfo.h>
51 #include <libdlpi.h>
52 #include <libdladm.h>
53 #include <libdllink.h>
54 #include <libdlstat.h>
55 #include <libdlaggr.h>
56 #include <libdlwlan.h>
57 #include <libdlvlan.h>
58 #include <libdlvnic.h>
59 #include <libdlib.h>
60 #include <libdlether.h>
61 #include <libdliptun.h>
62 #include <libdlsim.h>
63 #include <libdlbridge.h>
64 #include <libinetutil.h>
65 #include <libvrrpadm.h>
66 #include <bsm/adt.h>
67 #include <bsm/adt_event.h>
68 #include <libdlvnic.h>
69 #include <sys/types.h>
70 #include <sys/socket.h>
71 #include <sys/ib/ib_types.h>
72 #include <sys/processor.h>
73 #include <netinet/in.h>
74 #include <arpa/inet.h>
75 #include <net/if_types.h>
76 #include <stddef.h>
77 #include <stp_in.h>
78 #include <ofmt.h>
79
80 #define MAXPORT 256
81 #define MAXVNIC 256
82 #define BUFLEN(lim, ptr) (((lim) > (ptr)) ? ((lim) - (ptr)) : 0)
83 #define MAXLINELEN 1024
84 #define SMF_UPGRADE_FILE "/var/svc/profile/upgrade"
85 #define SMF_UPGRADEDATALINK_FILE "/var/svc/profile/upgrade_datalink"
86 #define SMF_DLADM_UPGRADE_MSG " # added by dladm(8)"
87 #define DLADM_DEFAULT_COL 80
88
89 /*
90 * used by the wifi show-* commands to set up ofmt_field_t structures.
91 */
92 #define WIFI_CMD_SCAN 0x00000001
93 #define WIFI_CMD_SHOW 0x00000002
94 #define WIFI_CMD_ALL (WIFI_CMD_SCAN | WIFI_CMD_SHOW)
95
96 /* No larger than pktsum_t */
97 typedef struct brsum_s {
98 uint64_t drops;
99 uint64_t forward_dir;
100 uint64_t forward_mb;
101 uint64_t forward_unk;
102 uint64_t recv;
103 uint64_t sent;
104 } brsum_t;
105
106 /* No larger than pktsum_t */
107 typedef struct brlsum_s {
108 uint32_t cfgbpdu;
109 uint32_t tcnbpdu;
110 uint32_t rstpbpdu;
111 uint32_t txbpdu;
112 uint64_t drops;
113 uint64_t recv;
114 uint64_t xmit;
115 } brlsum_t;
116
117 typedef struct show_state {
118 boolean_t ls_firstonly;
119 boolean_t ls_donefirst;
120 pktsum_t ls_prevstats;
121 uint32_t ls_flags;
122 dladm_status_t ls_status;
123 ofmt_handle_t ls_ofmt;
124 boolean_t ls_parsable;
125 boolean_t ls_mac;
126 boolean_t ls_hwgrp;
127 } show_state_t;
128
129 typedef struct show_grp_state {
130 pktsum_t gs_prevstats[MAXPORT];
131 uint32_t gs_flags;
132 dladm_status_t gs_status;
133 boolean_t gs_parsable;
134 boolean_t gs_lacp;
135 boolean_t gs_extended;
136 boolean_t gs_stats;
137 boolean_t gs_firstonly;
138 boolean_t gs_donefirst;
139 ofmt_handle_t gs_ofmt;
140 } show_grp_state_t;
141
142 typedef struct show_vnic_state {
143 datalink_id_t vs_vnic_id;
144 datalink_id_t vs_link_id;
145 char vs_vnic[MAXLINKNAMELEN];
146 char vs_link[MAXLINKNAMELEN];
147 boolean_t vs_parsable;
148 boolean_t vs_found;
149 boolean_t vs_firstonly;
150 boolean_t vs_donefirst;
151 boolean_t vs_stats;
152 boolean_t vs_printstats;
153 pktsum_t vs_totalstats;
154 pktsum_t vs_prevstats[MAXVNIC];
155 boolean_t vs_etherstub;
156 dladm_status_t vs_status;
157 uint32_t vs_flags;
158 ofmt_handle_t vs_ofmt;
159 } show_vnic_state_t;
160
161 typedef struct show_part_state {
162 datalink_id_t ps_over_id;
163 char ps_part[MAXLINKNAMELEN];
164 boolean_t ps_parsable;
165 boolean_t ps_found;
166 dladm_status_t ps_status;
167 uint32_t ps_flags;
168 ofmt_handle_t ps_ofmt;
169 } show_part_state_t;
170
171 typedef struct show_ib_state {
172 datalink_id_t is_link_id;
173 char is_link[MAXLINKNAMELEN];
174 boolean_t is_parsable;
175 dladm_status_t is_status;
176 uint32_t is_flags;
177 ofmt_handle_t is_ofmt;
178 } show_ib_state_t;
179
180 typedef struct show_usage_state_s {
181 boolean_t us_plot;
182 boolean_t us_parsable;
183 boolean_t us_printheader;
184 boolean_t us_first;
185 boolean_t us_showall;
186 ofmt_handle_t us_ofmt;
187 } show_usage_state_t;
188
189 /*
190 * callback functions for printing output and error diagnostics.
191 */
192 static ofmt_cb_t print_default_cb, print_link_stats_cb, print_linkprop_cb;
193 static ofmt_cb_t print_lacp_cb, print_phys_one_mac_cb;
194 static ofmt_cb_t print_xaggr_cb, print_aggr_stats_cb;
195 static ofmt_cb_t print_phys_one_hwgrp_cb, print_wlan_attr_cb;
196 static ofmt_cb_t print_wifi_status_cb, print_link_attr_cb;
197
198 typedef void cmdfunc_t(int, char **, const char *);
199
200 static cmdfunc_t do_show_link, do_show_wifi, do_show_phys;
201 static cmdfunc_t do_create_aggr, do_delete_aggr, do_add_aggr, do_remove_aggr;
202 static cmdfunc_t do_modify_aggr, do_show_aggr, do_up_aggr;
203 static cmdfunc_t do_scan_wifi, do_connect_wifi, do_disconnect_wifi;
204 static cmdfunc_t do_show_linkprop, do_set_linkprop, do_reset_linkprop;
205 static cmdfunc_t do_create_secobj, do_delete_secobj, do_show_secobj;
206 static cmdfunc_t do_init_linkprop, do_init_secobj;
207 static cmdfunc_t do_create_vlan, do_delete_vlan, do_up_vlan, do_show_vlan;
208 static cmdfunc_t do_rename_link, do_delete_phys, do_init_phys;
209 static cmdfunc_t do_show_linkmap;
210 static cmdfunc_t do_show_ether;
211 static cmdfunc_t do_create_vnic, do_delete_vnic, do_show_vnic;
212 static cmdfunc_t do_up_vnic;
213 static cmdfunc_t do_create_part, do_delete_part, do_show_part, do_show_ib;
214 static cmdfunc_t do_up_part;
215 static cmdfunc_t do_create_etherstub, do_delete_etherstub, do_show_etherstub;
216 static cmdfunc_t do_create_simnet, do_modify_simnet;
217 static cmdfunc_t do_delete_simnet, do_show_simnet, do_up_simnet;
218 static cmdfunc_t do_show_usage;
219 static cmdfunc_t do_create_bridge, do_modify_bridge, do_delete_bridge;
220 static cmdfunc_t do_add_bridge, do_remove_bridge, do_show_bridge;
221 static cmdfunc_t do_create_iptun, do_modify_iptun, do_delete_iptun;
222 static cmdfunc_t do_show_iptun, do_up_iptun, do_down_iptun;
223
224 static void do_up_vnic_common(int, char **, const char *, boolean_t);
225
226 static int show_part(dladm_handle_t, datalink_id_t, void *);
227
228 static void altroot_cmd(char *, int, char **);
229 static int show_linkprop_onelink(dladm_handle_t, datalink_id_t, void *);
230
231 static void link_stats(datalink_id_t, uint_t, char *, show_state_t *);
232 static void aggr_stats(datalink_id_t, show_grp_state_t *, uint_t);
233 static void vnic_stats(show_vnic_state_t *, uint32_t);
234
235 static int get_one_kstat(const char *, const char *, uint8_t,
236 void *, boolean_t);
237 static void get_mac_stats(const char *, pktsum_t *);
238 static void get_link_stats(const char *, pktsum_t *);
239 static uint64_t get_ifspeed(const char *, boolean_t);
240 static const char *get_linkstate(const char *, boolean_t, char *);
241 static const char *get_linkduplex(const char *, boolean_t, char *);
242
243 static iptun_type_t iptun_gettypebyname(char *);
244 static const char *iptun_gettypebyvalue(iptun_type_t);
245 static dladm_status_t print_iptun(dladm_handle_t, datalink_id_t,
246 show_state_t *);
247 static int print_iptun_walker(dladm_handle_t, datalink_id_t, void *);
248
249 static int show_etherprop(dladm_handle_t, datalink_id_t, void *);
250 static void show_ether_xprop(void *, dladm_ether_info_t *);
251 static boolean_t link_is_ether(const char *, datalink_id_t *);
252
253 static boolean_t str2int(const char *, int *);
254 static void die(const char *, ...);
255 static void die_optdup(int);
256 static void die_opterr(int, int, const char *);
257 static void die_dlerr(dladm_status_t, const char *, ...);
258 static void warn(const char *, ...);
259 static void warn_dlerr(dladm_status_t, const char *, ...);
260
261 typedef struct cmd {
262 char *c_name;
263 cmdfunc_t *c_fn;
264 const char *c_usage;
265 } cmd_t;
266
267 static cmd_t cmds[] = {
268 { "rename-link", do_rename_link,
269 " rename-link <oldlink> <newlink>" },
270 { "show-link", do_show_link,
271 " show-link [-pP] [-o <field>,..] [-s [-i <interval>]] "
272 "[<link>]\n" },
273 { "create-aggr", do_create_aggr,
274 " create-aggr [-t] [-P <policy>] [-L <mode>] [-T <time>] "
275 "[-u <address>]\n"
276 "\t\t -l <link> [-l <link>...] <link>" },
277 { "delete-aggr", do_delete_aggr,
278 " delete-aggr [-t] <link>" },
279 { "add-aggr", do_add_aggr,
280 " add-aggr [-t] -l <link> [-l <link>...] <link>" },
281 { "remove-aggr", do_remove_aggr,
282 " remove-aggr [-t] -l <link> [-l <link>...] <link>" },
283 { "modify-aggr", do_modify_aggr,
284 " modify-aggr [-t] [-P <policy>] [-L <mode>] [-T <time>] "
285 "[-u <address>]\n"
286 "\t\t <link>" },
287 { "show-aggr", do_show_aggr,
288 " show-aggr [-pPLx] [-o <field>,..] [-s [-i <interval>]] "
289 "[<link>]\n" },
290 { "up-aggr", do_up_aggr, NULL },
291 { "scan-wifi", do_scan_wifi,
292 " scan-wifi [-p] [-o <field>,...] [<link>]" },
293 { "connect-wifi", do_connect_wifi,
294 " connect-wifi [-e <essid>] [-i <bssid>] [-k <key>,...] "
295 "[-s wep|wpa]\n"
296 "\t\t [-a open|shared] [-b bss|ibss] [-c] [-m a|b|g] "
297 "[-T <time>]\n"
298 "\t\t [<link>]" },
299 { "disconnect-wifi", do_disconnect_wifi,
300 " disconnect-wifi [-a] [<link>]" },
301 { "show-wifi", do_show_wifi,
302 " show-wifi [-p] [-o <field>,...] [<link>]\n" },
303 { "set-linkprop", do_set_linkprop,
304 " set-linkprop [-t] -p <prop>=<value>[,...] <name>" },
305 { "reset-linkprop", do_reset_linkprop,
306 " reset-linkprop [-t] [-p <prop>,...] <name>" },
307 { "show-linkprop", do_show_linkprop,
308 " show-linkprop [-cP] [-o <field>,...] [-p <prop>,...] "
309 "<name>\n" },
310 { "show-ether", do_show_ether,
311 " show-ether [-px][-o <field>,...] <link>\n" },
312 { "create-secobj", do_create_secobj,
313 " create-secobj [-t] [-f <file>] -c <class> <secobj>" },
314 { "delete-secobj", do_delete_secobj,
315 " delete-secobj [-t] <secobj>[,...]" },
316 { "show-secobj", do_show_secobj,
317 " show-secobj [-pP] [-o <field>,...] [<secobj>,...]\n" },
318 { "init-linkprop", do_init_linkprop, NULL },
319 { "init-secobj", do_init_secobj, NULL },
320 { "create-vlan", do_create_vlan,
321 " create-vlan [-ft] -l <link> -v <vid> [link]" },
322 { "delete-vlan", do_delete_vlan,
323 " delete-vlan [-t] <link>" },
324 { "show-vlan", do_show_vlan,
325 " show-vlan [-pP] [-o <field>,..] [<link>]\n" },
326 { "up-vlan", do_up_vlan, NULL },
327 { "create-iptun", do_create_iptun,
328 " create-iptun [-t] -T <type> "
329 "[-a {local|remote}=<addr>,...] <link>]" },
330 { "delete-iptun", do_delete_iptun,
331 " delete-iptun [-t] <link>" },
332 { "modify-iptun", do_modify_iptun,
333 " modify-iptun [-t] -a {local|remote}=<addr>,... <link>" },
334 { "show-iptun", do_show_iptun,
335 " show-iptun [-pP] [-o <field>,..] [<link>]\n" },
336 { "up-iptun", do_up_iptun, NULL },
337 { "down-iptun", do_down_iptun, NULL },
338 { "delete-phys", do_delete_phys,
339 " delete-phys <link>" },
340 { "show-phys", do_show_phys,
341 " show-phys [-m | -H | -P] [[-p] [-o <field>[,...]] "
342 "[<link>]\n" },
343 { "init-phys", do_init_phys, NULL },
344 { "show-linkmap", do_show_linkmap, NULL },
345 { "create-vnic", do_create_vnic,
346 " create-vnic [-t] -l <link> [-m <value> | auto |\n"
347 "\t\t {factory [-n <slot-id>]} | {random [-r <prefix>]} |\n"
348 "\t\t {vrrp -V <vrid> -A {inet | inet6}} [-v <vid> [-f]]\n"
349 "\t\t [-p <prop>=<value>[,...]] <vnic-link>" },
350 { "delete-vnic", do_delete_vnic,
351 " delete-vnic [-t] <vnic-link>" },
352 { "show-vnic", do_show_vnic,
353 " show-vnic [-pP] [-l <link>] [-s [-i <interval>]] "
354 "[<link>]\n" },
355 { "up-vnic", do_up_vnic, NULL },
356 { "create-part", do_create_part,
357 " create-part [-t] [-f] -l <link> [-P <pkey>]\n"
358 "\t\t [-R <root-dir>] <part-link>" },
359 { "delete-part", do_delete_part,
360 " delete-part [-t] [-R <root-dir>] <part-link>"},
361 { "show-part", do_show_part,
362 " show-part [-pP] [-o <field>,...][-l <linkover>]\n"
363 "\t\t [<part-link>]" },
364 { "show-ib", do_show_ib,
365 " show-ib [-p] [-o <field>,...] [<link>]\n" },
366 { "up-part", do_up_part, NULL },
367 { "create-etherstub", do_create_etherstub,
368 " create-etherstub [-t] <link>" },
369 { "delete-etherstub", do_delete_etherstub,
370 " delete-etherstub [-t] <link>" },
371 { "show-etherstub", do_show_etherstub,
372 " show-etherstub [-t] [<link>]\n" },
373 { "create-simnet", do_create_simnet, NULL },
374 { "modify-simnet", do_modify_simnet, NULL },
375 { "delete-simnet", do_delete_simnet, NULL },
376 { "show-simnet", do_show_simnet, NULL },
377 { "up-simnet", do_up_simnet, NULL },
378 { "create-bridge", do_create_bridge,
379 " create-bridge [-R <root-dir>] [-P <protect>] "
380 "[-p <priority>]\n"
381 "\t\t [-m <max-age>] [-h <hello-time>] [-d <forward-delay>]\n"
382 "\t\t [-f <force-protocol>] [-l <link>]... <bridge>" },
383 { "modify-bridge", do_modify_bridge,
384 " modify-bridge [-R <root-dir>] [-P <protect>] "
385 "[-p <priority>]\n"
386 "\t\t [-m <max-age>] [-h <hello-time>] [-d <forward-delay>]\n"
387 "\t\t [-f <force-protocol>] <bridge>" },
388 { "delete-bridge", do_delete_bridge,
389 " delete-bridge [-R <root-dir>] <bridge>" },
390 { "add-bridge", do_add_bridge,
391 " add-bridge [-R <root-dir>] -l <link> [-l <link>]... "
392 "<bridge>" },
393 { "remove-bridge", do_remove_bridge,
394 " remove-bridge [-R <root-dir>] -l <link> [-l <link>]... "
395 "<bridge>" },
396 { "show-bridge", do_show_bridge,
397 " show-bridge [-p] [-o <field>,...] [-s [-i <interval>]] "
398 "[<bridge>]\n"
399 " show-bridge -l [-p] [-o <field>,...] [-s [-i <interval>]]"
400 " <bridge>\n"
401 " show-bridge -f [-p] [-o <field>,...] [-s [-i <interval>]]"
402 " <bridge>\n"
403 " show-bridge -t [-p] [-o <field>,...] [-s [-i <interval>]]"
404 " <bridge>\n" },
405 { "show-usage", do_show_usage,
406 " show-usage [-a] [-d | -F <format>] "
407 "[-s <DD/MM/YYYY,HH:MM:SS>]\n"
408 "\t\t [-e <DD/MM/YYYY,HH:MM:SS>] -f <logfile> [<link>]" }
409 };
410
411 static const struct option lopts[] = {
412 {"vlan-id", required_argument, 0, 'v'},
413 {"output", required_argument, 0, 'o'},
414 {"dev", required_argument, 0, 'd'},
415 {"policy", required_argument, 0, 'P'},
416 {"lacp-mode", required_argument, 0, 'L'},
417 {"lacp-timer", required_argument, 0, 'T'},
418 {"unicast", required_argument, 0, 'u'},
419 {"temporary", no_argument, 0, 't'},
420 {"root-dir", required_argument, 0, 'R'},
421 {"link", required_argument, 0, 'l'},
422 {"forcible", no_argument, 0, 'f'},
423 {"bw-limit", required_argument, 0, 'b'},
424 {"mac-address", required_argument, 0, 'm'},
425 {"slot", required_argument, 0, 'n'},
426 { 0, 0, 0, 0 }
427 };
428
429 static const struct option show_lopts[] = {
430 {"statistics", no_argument, 0, 's'},
431 {"continuous", no_argument, 0, 'S'},
432 {"interval", required_argument, 0, 'i'},
433 {"parsable", no_argument, 0, 'p'},
434 {"parseable", no_argument, 0, 'p'},
435 {"extended", no_argument, 0, 'x'},
436 {"output", required_argument, 0, 'o'},
437 {"persistent", no_argument, 0, 'P'},
438 {"lacp", no_argument, 0, 'L'},
439 { 0, 0, 0, 0 }
440 };
441
442 static const struct option iptun_lopts[] = {
443 {"output", required_argument, 0, 'o'},
444 {"tunnel-type", required_argument, 0, 'T'},
445 {"address", required_argument, 0, 'a'},
446 {"root-dir", required_argument, 0, 'R'},
447 {"parsable", no_argument, 0, 'p'},
448 {"parseable", no_argument, 0, 'p'},
449 {"persistent", no_argument, 0, 'P'},
450 { 0, 0, 0, 0 }
451 };
452
453 static char * const iptun_addropts[] = {
454 #define IPTUN_LOCAL 0
455 "local",
456 #define IPTUN_REMOTE 1
457 "remote",
458 NULL};
459
460 static const struct {
461 const char *type_name;
462 iptun_type_t type_value;
463 } iptun_types[] = {
464 {"ipv4", IPTUN_TYPE_IPV4},
465 {"ipv6", IPTUN_TYPE_IPV6},
466 {"6to4", IPTUN_TYPE_6TO4},
467 {NULL, 0}
468 };
469
470 static const struct option prop_longopts[] = {
471 {"temporary", no_argument, 0, 't' },
472 {"output", required_argument, 0, 'o' },
473 {"root-dir", required_argument, 0, 'R' },
474 {"prop", required_argument, 0, 'p' },
475 {"parsable", no_argument, 0, 'c' },
476 {"parseable", no_argument, 0, 'c' },
477 {"persistent", no_argument, 0, 'P' },
478 { 0, 0, 0, 0 }
479 };
480
481 static const struct option wifi_longopts[] = {
482 {"parsable", no_argument, 0, 'p' },
483 {"parseable", no_argument, 0, 'p' },
484 {"output", required_argument, 0, 'o' },
485 {"essid", required_argument, 0, 'e' },
486 {"bsstype", required_argument, 0, 'b' },
487 {"mode", required_argument, 0, 'm' },
488 {"key", required_argument, 0, 'k' },
489 {"sec", required_argument, 0, 's' },
490 {"auth", required_argument, 0, 'a' },
491 {"create-ibss", required_argument, 0, 'c' },
492 {"timeout", required_argument, 0, 'T' },
493 {"all-links", no_argument, 0, 'a' },
494 {"temporary", no_argument, 0, 't' },
495 {"root-dir", required_argument, 0, 'R' },
496 {"persistent", no_argument, 0, 'P' },
497 {"file", required_argument, 0, 'f' },
498 { 0, 0, 0, 0 }
499 };
500
501 static const struct option showeth_lopts[] = {
502 {"parsable", no_argument, 0, 'p' },
503 {"parseable", no_argument, 0, 'p' },
504 {"extended", no_argument, 0, 'x' },
505 {"output", required_argument, 0, 'o' },
506 { 0, 0, 0, 0 }
507 };
508
509 static const struct option vnic_lopts[] = {
510 {"temporary", no_argument, 0, 't' },
511 {"root-dir", required_argument, 0, 'R' },
512 {"dev", required_argument, 0, 'd' },
513 {"mac-address", required_argument, 0, 'm' },
514 {"cpus", required_argument, 0, 'c' },
515 {"bw-limit", required_argument, 0, 'b' },
516 {"slot", required_argument, 0, 'n' },
517 {"mac-prefix", required_argument, 0, 'r' },
518 {"vrid", required_argument, 0, 'V' },
519 {"address-family", required_argument, 0, 'A' },
520 { 0, 0, 0, 0 }
521 };
522
523 static const struct option part_lopts[] = {
524 {"temporary", no_argument, 0, 't' },
525 {"pkey", required_argument, 0, 'P' },
526 {"link", required_argument, 0, 'l' },
527 {"force", no_argument, 0, 'f' },
528 {"root-dir", required_argument, 0, 'R' },
529 {"prop", required_argument, 0, 'p' },
530 { 0, 0, 0, 0 }
531 };
532
533 static const struct option show_part_lopts[] = {
534 {"parsable", no_argument, 0, 'p' },
535 {"parseable", no_argument, 0, 'p' },
536 {"link", required_argument, 0, 'l' },
537 {"persistent", no_argument, 0, 'P' },
538 {"output", required_argument, 0, 'o' },
539 { 0, 0, 0, 0 }
540 };
541
542 static const struct option etherstub_lopts[] = {
543 {"temporary", no_argument, 0, 't' },
544 {"root-dir", required_argument, 0, 'R' },
545 { 0, 0, 0, 0 }
546 };
547
548 static const struct option usage_opts[] = {
549 {"file", required_argument, 0, 'f' },
550 {"format", required_argument, 0, 'F' },
551 {"start", required_argument, 0, 's' },
552 {"stop", required_argument, 0, 'e' },
553 { 0, 0, 0, 0 }
554 };
555
556 static const struct option simnet_lopts[] = {
557 {"temporary", no_argument, 0, 't' },
558 {"root-dir", required_argument, 0, 'R' },
559 {"media", required_argument, 0, 'm' },
560 {"peer", required_argument, 0, 'p' },
561 { 0, 0, 0, 0 }
562 };
563
564 static const struct option bridge_lopts[] = {
565 { "protect", required_argument, 0, 'P' },
566 { "root-dir", required_argument, 0, 'R' },
567 { "forward-delay", required_argument, 0, 'd' },
568 { "force-protocol", required_argument, 0, 'f' },
569 { "hello-time", required_argument, 0, 'h' },
570 { "link", required_argument, 0, 'l' },
571 { "max-age", required_argument, 0, 'm' },
572 { "priority", required_argument, 0, 'p' },
573 { 0, 0, 0, 0 }
574 };
575
576 static const struct option bridge_show_lopts[] = {
577 { "forwarding", no_argument, 0, 'f' },
578 { "interval", required_argument, 0, 'i' },
579 { "link", no_argument, 0, 'l' },
580 { "output", required_argument, 0, 'o' },
581 { "parsable", no_argument, 0, 'p' },
582 { "parseable", no_argument, 0, 'p' },
583 { "statistics", no_argument, 0, 's' },
584 { "trill", no_argument, 0, 't' },
585 { 0, 0, 0, 0 }
586 };
587
588 /*
589 * structures for 'dladm show-ether'
590 */
591 static const char *ptype[] = {LEI_ATTR_NAMES};
592
593 typedef struct ether_fields_buf_s
594 {
595 char eth_link[15];
596 char eth_ptype[8];
597 char eth_state[8];
598 char eth_autoneg[5];
599 char eth_spdx[31];
600 char eth_pause[6];
601 char eth_rem_fault[16];
602 } ether_fields_buf_t;
603
604 static const ofmt_field_t ether_fields[] = {
605 /* name, field width, offset callback */
606 { "LINK", 16,
607 offsetof(ether_fields_buf_t, eth_link), print_default_cb},
608 { "PTYPE", 9,
609 offsetof(ether_fields_buf_t, eth_ptype), print_default_cb},
610 { "STATE", 9,
611 offsetof(ether_fields_buf_t, eth_state),
612 print_default_cb},
613 { "AUTO", 6,
614 offsetof(ether_fields_buf_t, eth_autoneg), print_default_cb},
615 { "SPEED-DUPLEX", 32,
616 offsetof(ether_fields_buf_t, eth_spdx), print_default_cb},
617 { "PAUSE", 7,
618 offsetof(ether_fields_buf_t, eth_pause), print_default_cb},
619 { "REM_FAULT", 17,
620 offsetof(ether_fields_buf_t, eth_rem_fault), print_default_cb},
621 {NULL, 0,
622 0, NULL}}
623 ;
624
625 typedef struct print_ether_state {
626 const char *es_link;
627 boolean_t es_parsable;
628 boolean_t es_header;
629 boolean_t es_extended;
630 ofmt_handle_t es_ofmt;
631 } print_ether_state_t;
632
633 /*
634 * structures for 'dladm show-link -s' (print statistics)
635 */
636 typedef enum {
637 LINK_S_LINK,
638 LINK_S_IPKTS,
639 LINK_S_RBYTES,
640 LINK_S_IERRORS,
641 LINK_S_OPKTS,
642 LINK_S_OBYTES,
643 LINK_S_OERRORS
644 } link_s_field_index_t;
645
646 static const ofmt_field_t link_s_fields[] = {
647 /* name, field width, index, callback */
648 { "LINK", 15, LINK_S_LINK, print_link_stats_cb},
649 { "IPACKETS", 10, LINK_S_IPKTS, print_link_stats_cb},
650 { "RBYTES", 8, LINK_S_RBYTES, print_link_stats_cb},
651 { "IERRORS", 10, LINK_S_IERRORS, print_link_stats_cb},
652 { "OPACKETS", 12, LINK_S_OPKTS, print_link_stats_cb},
653 { "OBYTES", 12, LINK_S_OBYTES, print_link_stats_cb},
654 { "OERRORS", 8, LINK_S_OERRORS, print_link_stats_cb}}
655 ;
656
657 typedef struct link_args_s {
658 char *link_s_link;
659 pktsum_t *link_s_psum;
660 } link_args_t;
661
662 /*
663 * buffer used by print functions for show-{link,phys,vlan} commands.
664 */
665 typedef struct link_fields_buf_s {
666 char link_name[MAXLINKNAMELEN];
667 char link_class[DLADM_STRSIZE];
668 char link_mtu[11];
669 char link_state[DLADM_STRSIZE];
670 char link_bridge[MAXLINKNAMELEN * MAXPORT];
671 char link_over[MAXLINKNAMELEN * MAXPORT];
672 char link_phys_state[DLADM_STRSIZE];
673 char link_phys_media[DLADM_STRSIZE];
674 char link_phys_speed[DLADM_STRSIZE];
675 char link_phys_duplex[DLPI_LINKNAME_MAX];
676 char link_phys_device[DLPI_LINKNAME_MAX];
677 char link_flags[6];
678 char link_vlan_vid[6];
679 } link_fields_buf_t;
680
681 /*
682 * structures for 'dladm show-link'
683 */
684 static const ofmt_field_t link_fields[] = {
685 /* name, field width, index, callback */
686 { "LINK", 12,
687 offsetof(link_fields_buf_t, link_name), print_default_cb},
688 { "CLASS", 10,
689 offsetof(link_fields_buf_t, link_class), print_default_cb},
690 { "MTU", 7,
691 offsetof(link_fields_buf_t, link_mtu), print_default_cb},
692 { "STATE", 9,
693 offsetof(link_fields_buf_t, link_state), print_default_cb},
694 { "BRIDGE", 11,
695 offsetof(link_fields_buf_t, link_bridge), print_default_cb},
696 { "OVER", 30,
697 offsetof(link_fields_buf_t, link_over), print_default_cb},
698 { NULL, 0, 0, NULL}}
699 ;
700
701 /*
702 * structures for 'dladm show-aggr'
703 */
704 typedef struct laggr_fields_buf_s {
705 char laggr_name[DLPI_LINKNAME_MAX];
706 char laggr_policy[9];
707 char laggr_addrpolicy[ETHERADDRL * 3 + 3];
708 char laggr_lacpactivity[14];
709 char laggr_lacptimer[DLADM_STRSIZE];
710 char laggr_flags[7];
711 } laggr_fields_buf_t;
712
713 typedef struct laggr_args_s {
714 int laggr_lport; /* -1 indicates the aggr itself */
715 const char *laggr_link;
716 dladm_aggr_grp_attr_t *laggr_ginfop;
717 dladm_status_t *laggr_status;
718 pktsum_t *laggr_pktsumtot; /* -s only */
719 pktsum_t *laggr_diffstats; /* -s only */
720 boolean_t laggr_parsable;
721 } laggr_args_t;
722
723 static const ofmt_field_t laggr_fields[] = {
724 /* name, field width, offset, callback */
725 { "LINK", 16,
726 offsetof(laggr_fields_buf_t, laggr_name), print_default_cb},
727 { "POLICY", 9,
728 offsetof(laggr_fields_buf_t, laggr_policy), print_default_cb},
729 { "ADDRPOLICY", ETHERADDRL * 3 + 3,
730 offsetof(laggr_fields_buf_t, laggr_addrpolicy), print_default_cb},
731 { "LACPACTIVITY", 14,
732 offsetof(laggr_fields_buf_t, laggr_lacpactivity), print_default_cb},
733 { "LACPTIMER", 12,
734 offsetof(laggr_fields_buf_t, laggr_lacptimer), print_default_cb},
735 { "FLAGS", 8,
736 offsetof(laggr_fields_buf_t, laggr_flags), print_default_cb},
737 { NULL, 0, 0, NULL}}
738 ;
739
740 /*
741 * structures for 'dladm show-aggr -x'.
742 */
743 typedef enum {
744 AGGR_X_LINK,
745 AGGR_X_PORT,
746 AGGR_X_SPEED,
747 AGGR_X_DUPLEX,
748 AGGR_X_STATE,
749 AGGR_X_ADDRESS,
750 AGGR_X_PORTSTATE
751 } aggr_x_field_index_t;
752
753 static const ofmt_field_t aggr_x_fields[] = {
754 /* name, field width, index callback */
755 { "LINK", 12, AGGR_X_LINK, print_xaggr_cb},
756 { "PORT", 15, AGGR_X_PORT, print_xaggr_cb},
757 { "SPEED", 5, AGGR_X_SPEED, print_xaggr_cb},
758 { "DUPLEX", 10, AGGR_X_DUPLEX, print_xaggr_cb},
759 { "STATE", 10, AGGR_X_STATE, print_xaggr_cb},
760 { "ADDRESS", 19, AGGR_X_ADDRESS, print_xaggr_cb},
761 { "PORTSTATE", 16, AGGR_X_PORTSTATE, print_xaggr_cb},
762 { NULL, 0, 0, NULL}}
763 ;
764
765 /*
766 * structures for 'dladm show-aggr -s'.
767 */
768 typedef enum {
769 AGGR_S_LINK,
770 AGGR_S_PORT,
771 AGGR_S_IPKTS,
772 AGGR_S_RBYTES,
773 AGGR_S_OPKTS,
774 AGGR_S_OBYTES,
775 AGGR_S_IPKTDIST,
776 AGGR_S_OPKTDIST
777 } aggr_s_field_index_t;
778
779 static const ofmt_field_t aggr_s_fields[] = {
780 { "LINK", 12, AGGR_S_LINK, print_aggr_stats_cb},
781 { "PORT", 10, AGGR_S_PORT, print_aggr_stats_cb},
782 { "IPACKETS", 8, AGGR_S_IPKTS, print_aggr_stats_cb},
783 { "RBYTES", 8, AGGR_S_RBYTES, print_aggr_stats_cb},
784 { "OPACKETS", 8, AGGR_S_OPKTS, print_aggr_stats_cb},
785 { "OBYTES", 8, AGGR_S_OBYTES, print_aggr_stats_cb},
786 { "IPKTDIST", 9, AGGR_S_IPKTDIST, print_aggr_stats_cb},
787 { "OPKTDIST", 15, AGGR_S_OPKTDIST, print_aggr_stats_cb},
788 { NULL, 0, 0, NULL}}
789 ;
790
791 /*
792 * structures for 'dladm show-aggr -L'.
793 */
794 typedef enum {
795 AGGR_L_LINK,
796 AGGR_L_PORT,
797 AGGR_L_AGGREGATABLE,
798 AGGR_L_SYNC,
799 AGGR_L_COLL,
800 AGGR_L_DIST,
801 AGGR_L_DEFAULTED,
802 AGGR_L_EXPIRED
803 } aggr_l_field_index_t;
804
805 static const ofmt_field_t aggr_l_fields[] = {
806 /* name, field width, index */
807 { "LINK", 12, AGGR_L_LINK, print_lacp_cb},
808 { "PORT", 13, AGGR_L_PORT, print_lacp_cb},
809 { "AGGREGATABLE", 13, AGGR_L_AGGREGATABLE, print_lacp_cb},
810 { "SYNC", 5, AGGR_L_SYNC, print_lacp_cb},
811 { "COLL", 5, AGGR_L_COLL, print_lacp_cb},
812 { "DIST", 5, AGGR_L_DIST, print_lacp_cb},
813 { "DEFAULTED", 10, AGGR_L_DEFAULTED, print_lacp_cb},
814 { "EXPIRED", 15, AGGR_L_EXPIRED, print_lacp_cb},
815 { NULL, 0, 0, NULL}}
816 ;
817
818 /*
819 * structures for 'dladm show-phys'
820 */
821
822 static const ofmt_field_t phys_fields[] = {
823 /* name, field width, offset */
824 { "LINK", 13,
825 offsetof(link_fields_buf_t, link_name), print_default_cb},
826 { "MEDIA", 21,
827 offsetof(link_fields_buf_t, link_phys_media), print_default_cb},
828 { "STATE", 11,
829 offsetof(link_fields_buf_t, link_phys_state), print_default_cb},
830 { "SPEED", 7,
831 offsetof(link_fields_buf_t, link_phys_speed), print_default_cb},
832 { "DUPLEX", 10,
833 offsetof(link_fields_buf_t, link_phys_duplex), print_default_cb},
834 { "DEVICE", 13,
835 offsetof(link_fields_buf_t, link_phys_device), print_default_cb},
836 { "FLAGS", 7,
837 offsetof(link_fields_buf_t, link_flags), print_default_cb},
838 { NULL, 0, 0, NULL}}
839 ;
840
841 /*
842 * structures for 'dladm show-phys -m'
843 */
844
845 typedef enum {
846 PHYS_M_LINK,
847 PHYS_M_SLOT,
848 PHYS_M_ADDRESS,
849 PHYS_M_INUSE,
850 PHYS_M_CLIENT
851 } phys_m_field_index_t;
852
853 static const ofmt_field_t phys_m_fields[] = {
854 /* name, field width, offset */
855 { "LINK", 13, PHYS_M_LINK, print_phys_one_mac_cb},
856 { "SLOT", 9, PHYS_M_SLOT, print_phys_one_mac_cb},
857 { "ADDRESS", 19, PHYS_M_ADDRESS, print_phys_one_mac_cb},
858 { "INUSE", 5, PHYS_M_INUSE, print_phys_one_mac_cb},
859 { "CLIENT", 13, PHYS_M_CLIENT, print_phys_one_mac_cb},
860 { NULL, 0, 0, NULL}}
861 ;
862
863 /*
864 * structures for 'dladm show-phys -H'
865 */
866
867 typedef enum {
868 PHYS_H_LINK,
869 PHYS_H_RINGTYPE,
870 PHYS_H_RINGS,
871 PHYS_H_CLIENTS
872 } phys_h_field_index_t;
873
874 #define RINGSTRLEN 21
875
876 static const ofmt_field_t phys_h_fields[] = {
877 { "LINK", 13, PHYS_H_LINK, print_phys_one_hwgrp_cb},
878 { "RINGTYPE", 9, PHYS_H_RINGTYPE, print_phys_one_hwgrp_cb},
879 { "RINGS", RINGSTRLEN, PHYS_H_RINGS, print_phys_one_hwgrp_cb},
880 { "CLIENTS", 24, PHYS_H_CLIENTS, print_phys_one_hwgrp_cb},
881 { NULL, 0, 0, NULL}}
882 ;
883
884 /*
885 * structures for 'dladm show-vlan'
886 */
887 static const ofmt_field_t vlan_fields[] = {
888 { "LINK", 16,
889 offsetof(link_fields_buf_t, link_name), print_default_cb},
890 { "VID", 9,
891 offsetof(link_fields_buf_t, link_vlan_vid), print_default_cb},
892 { "OVER", 13,
893 offsetof(link_fields_buf_t, link_over), print_default_cb},
894 { "FLAGS", 7,
895 offsetof(link_fields_buf_t, link_flags), print_default_cb},
896 { NULL, 0, 0, NULL}}
897 ;
898
899 /*
900 * structures common to 'dladm scan-wifi' and 'dladm show-wifi'
901 * callback will be determined in parse_wifi_fields.
902 */
903 static ofmt_field_t wifi_common_fields[] = {
904 { "LINK", 11, 0, NULL},
905 { "ESSID", 20, DLADM_WLAN_ATTR_ESSID, NULL},
906 { "BSSID", 18, DLADM_WLAN_ATTR_BSSID, NULL},
907 { "IBSSID", 18, DLADM_WLAN_ATTR_BSSID, NULL},
908 { "MODE", 7, DLADM_WLAN_ATTR_MODE, NULL},
909 { "SPEED", 7, DLADM_WLAN_ATTR_SPEED, NULL},
910 { "BSSTYPE", 9, DLADM_WLAN_ATTR_BSSTYPE, NULL},
911 { "SEC", 7, DLADM_WLAN_ATTR_SECMODE, NULL},
912 { "STRENGTH", 11, DLADM_WLAN_ATTR_STRENGTH, NULL},
913 { NULL, 0, 0, NULL}};
914
915 /*
916 * the 'show-wifi' command supports all the fields in wifi_common_fields
917 * plus the AUTH and STATUS fields.
918 */
919 static ofmt_field_t wifi_show_fields[A_CNT(wifi_common_fields) + 2] = {
920 { "AUTH", 9, DLADM_WLAN_ATTR_AUTH, NULL},
921 { "STATUS", 18, DLADM_WLAN_LINKATTR_STATUS, print_wifi_status_cb},
922 /* copy wifi_common_fields here */
923 };
924
925 static char *all_scan_wifi_fields =
926 "link,essid,bssid,sec,strength,mode,speed,bsstype";
927 static char *all_show_wifi_fields =
928 "link,status,essid,sec,strength,mode,speed,auth,bssid,bsstype";
929 static char *def_scan_wifi_fields =
930 "link,essid,bssid,sec,strength,mode,speed";
931 static char *def_show_wifi_fields =
932 "link,status,essid,sec,strength,mode,speed";
933
934 /*
935 * structures for 'dladm show-linkprop'
936 */
937 typedef enum {
938 LINKPROP_LINK,
939 LINKPROP_PROPERTY,
940 LINKPROP_PERM,
941 LINKPROP_VALUE,
942 LINKPROP_DEFAULT,
943 LINKPROP_POSSIBLE
944 } linkprop_field_index_t;
945
946 static const ofmt_field_t linkprop_fields[] = {
947 /* name, field width, index */
948 { "LINK", 13, LINKPROP_LINK, print_linkprop_cb},
949 { "PROPERTY", 16, LINKPROP_PROPERTY, print_linkprop_cb},
950 { "PERM", 5, LINKPROP_PERM, print_linkprop_cb},
951 { "VALUE", 15, LINKPROP_VALUE, print_linkprop_cb},
952 { "DEFAULT", 15, LINKPROP_DEFAULT, print_linkprop_cb},
953 { "POSSIBLE", 20, LINKPROP_POSSIBLE, print_linkprop_cb},
954 { NULL, 0, 0, NULL}}
955 ;
956
957 #define MAX_PROP_LINE 512
958
959 typedef struct show_linkprop_state {
960 char ls_link[MAXLINKNAMELEN];
961 char *ls_line;
962 char **ls_propvals;
963 dladm_arg_list_t *ls_proplist;
964 boolean_t ls_parsable;
965 boolean_t ls_persist;
966 boolean_t ls_header;
967 dladm_status_t ls_status;
968 dladm_status_t ls_retstatus;
969 ofmt_handle_t ls_ofmt;
970 } show_linkprop_state_t;
971
972 typedef struct set_linkprop_state {
973 const char *ls_name;
974 boolean_t ls_reset;
975 boolean_t ls_temp;
976 dladm_status_t ls_status;
977 } set_linkprop_state_t;
978
979 typedef struct linkprop_args_s {
980 show_linkprop_state_t *ls_state;
981 char *ls_propname;
982 datalink_id_t ls_linkid;
983 } linkprop_args_t;
984
985 /*
986 * structures for 'dladm show-secobj'
987 */
988 typedef struct secobj_fields_buf_s {
989 char ss_obj_name[DLADM_SECOBJ_VAL_MAX];
990 char ss_class[20];
991 char ss_val[30];
992 } secobj_fields_buf_t;
993
994 static const ofmt_field_t secobj_fields[] = {
995 { "OBJECT", 21,
996 offsetof(secobj_fields_buf_t, ss_obj_name), print_default_cb},
997 { "CLASS", 21,
998 offsetof(secobj_fields_buf_t, ss_class), print_default_cb},
999 { "VALUE", 31,
1000 offsetof(secobj_fields_buf_t, ss_val), print_default_cb},
1001 { NULL, 0, 0, NULL}}
1002 ;
1003
1004 /*
1005 * structures for 'dladm show-vnic'
1006 */
1007 typedef struct vnic_fields_buf_s
1008 {
1009 char vnic_link[DLPI_LINKNAME_MAX];
1010 char vnic_over[DLPI_LINKNAME_MAX];
1011 char vnic_speed[6];
1012 char vnic_macaddr[18];
1013 char vnic_macaddrtype[19];
1014 char vnic_vid[6];
1015 } vnic_fields_buf_t;
1016
1017 static const ofmt_field_t vnic_fields[] = {
1018 { "LINK", 13,
1019 offsetof(vnic_fields_buf_t, vnic_link), print_default_cb},
1020 { "OVER", 13,
1021 offsetof(vnic_fields_buf_t, vnic_over), print_default_cb},
1022 { "SPEED", 7,
1023 offsetof(vnic_fields_buf_t, vnic_speed), print_default_cb},
1024 { "MACADDRESS", 18,
1025 offsetof(vnic_fields_buf_t, vnic_macaddr), print_default_cb},
1026 { "MACADDRTYPE", 20,
1027 offsetof(vnic_fields_buf_t, vnic_macaddrtype), print_default_cb},
1028 { "VID", 7,
1029 offsetof(vnic_fields_buf_t, vnic_vid), print_default_cb},
1030 { NULL, 0, 0, NULL}}
1031 ;
1032
1033 /*
1034 * structures for 'dladm show-ib'
1035 */
1036 typedef struct ib_fields_buf_s
1037 {
1038 char ib_link[DLPI_LINKNAME_MAX];
1039 char ib_hcaguid[17];
1040 char ib_portguid[17];
1041 char ib_portnum[4];
1042 char ib_state[6];
1043 char ib_pkeys[MAXPKEYSTRSZ];
1044 } ib_fields_buf_t;
1045
1046 static const ofmt_field_t ib_fields[] = {
1047 { "LINK", 13,
1048 offsetof(ib_fields_buf_t, ib_link), print_default_cb},
1049 { "HCAGUID", IBGUIDSTRLEN,
1050 offsetof(ib_fields_buf_t, ib_hcaguid), print_default_cb},
1051 { "PORTGUID", IBGUIDSTRLEN,
1052 offsetof(ib_fields_buf_t, ib_portguid), print_default_cb},
1053 { "PORT", IBPORTSTRLEN,
1054 offsetof(ib_fields_buf_t, ib_portnum), print_default_cb},
1055 { "STATE", 7,
1056 offsetof(ib_fields_buf_t, ib_state), print_default_cb},
1057 { "PKEYS", 18,
1058 offsetof(ib_fields_buf_t, ib_pkeys), print_default_cb},
1059 { NULL, 0, 0, NULL}};
1060
1061 /*
1062 * structures for 'dladm show-part'
1063 */
1064 typedef struct part_fields_buf_s
1065 {
1066 char part_link[DLPI_LINKNAME_MAX];
1067 char part_pkey[5];
1068 char part_over[DLPI_LINKNAME_MAX];
1069 char part_state[8];
1070 char part_flags[5];
1071 } part_fields_buf_t;
1072
1073 static const ofmt_field_t part_fields[] = {
1074 { "LINK", 13,
1075 offsetof(part_fields_buf_t, part_link), print_default_cb},
1076 { "PKEY", MAXPKEYLEN,
1077 offsetof(part_fields_buf_t, part_pkey), print_default_cb},
1078 { "OVER", 13,
1079 offsetof(part_fields_buf_t, part_over), print_default_cb},
1080 { "STATE", 9,
1081 offsetof(part_fields_buf_t, part_state), print_default_cb},
1082 { "FLAGS", 5,
1083 offsetof(part_fields_buf_t, part_flags), print_default_cb},
1084 { NULL, 0, 0, NULL}};
1085
1086 /*
1087 * structures for 'dladm show-simnet'
1088 */
1089 typedef struct simnet_fields_buf_s
1090 {
1091 char simnet_name[DLPI_LINKNAME_MAX];
1092 char simnet_media[DLADM_STRSIZE];
1093 char simnet_macaddr[18];
1094 char simnet_otherlink[DLPI_LINKNAME_MAX];
1095 } simnet_fields_buf_t;
1096
1097 static const ofmt_field_t simnet_fields[] = {
1098 { "LINK", 12,
1099 offsetof(simnet_fields_buf_t, simnet_name), print_default_cb},
1100 { "MEDIA", 20,
1101 offsetof(simnet_fields_buf_t, simnet_media), print_default_cb},
1102 { "MACADDRESS", 18,
1103 offsetof(simnet_fields_buf_t, simnet_macaddr), print_default_cb},
1104 { "OTHERLINK", 12,
1105 offsetof(simnet_fields_buf_t, simnet_otherlink), print_default_cb},
1106 { NULL, 0, 0, NULL}}
1107 ;
1108
1109 /*
1110 * structures for 'dladm show-usage'
1111 */
1112
1113 typedef struct usage_fields_buf_s {
1114 char usage_link[12];
1115 char usage_duration[10];
1116 char usage_ipackets[9];
1117 char usage_rbytes[10];
1118 char usage_opackets[9];
1119 char usage_obytes[10];
1120 char usage_bandwidth[14];
1121 } usage_fields_buf_t;
1122
1123 static const ofmt_field_t usage_fields[] = {
1124 { "LINK", 13,
1125 offsetof(usage_fields_buf_t, usage_link), print_default_cb},
1126 { "DURATION", 11,
1127 offsetof(usage_fields_buf_t, usage_duration), print_default_cb},
1128 { "IPACKETS", 10,
1129 offsetof(usage_fields_buf_t, usage_ipackets), print_default_cb},
1130 { "RBYTES", 11,
1131 offsetof(usage_fields_buf_t, usage_rbytes), print_default_cb},
1132 { "OPACKETS", 10,
1133 offsetof(usage_fields_buf_t, usage_opackets), print_default_cb},
1134 { "OBYTES", 11,
1135 offsetof(usage_fields_buf_t, usage_obytes), print_default_cb},
1136 { "BANDWIDTH", 15,
1137 offsetof(usage_fields_buf_t, usage_bandwidth), print_default_cb},
1138 { NULL, 0, 0, NULL}}
1139 ;
1140
1141
1142 /*
1143 * structures for 'dladm show-usage link'
1144 */
1145
1146 typedef struct usage_l_fields_buf_s {
1147 char usage_l_link[12];
1148 char usage_l_stime[13];
1149 char usage_l_etime[13];
1150 char usage_l_rbytes[8];
1151 char usage_l_obytes[8];
1152 char usage_l_bandwidth[14];
1153 } usage_l_fields_buf_t;
1154
1155 static const ofmt_field_t usage_l_fields[] = {
1156 /* name, field width, offset */
1157 { "LINK", 13,
1158 offsetof(usage_l_fields_buf_t, usage_l_link), print_default_cb},
1159 { "START", 14,
1160 offsetof(usage_l_fields_buf_t, usage_l_stime), print_default_cb},
1161 { "END", 14,
1162 offsetof(usage_l_fields_buf_t, usage_l_etime), print_default_cb},
1163 { "RBYTES", 9,
1164 offsetof(usage_l_fields_buf_t, usage_l_rbytes), print_default_cb},
1165 { "OBYTES", 9,
1166 offsetof(usage_l_fields_buf_t, usage_l_obytes), print_default_cb},
1167 { "BANDWIDTH", 15,
1168 offsetof(usage_l_fields_buf_t, usage_l_bandwidth), print_default_cb},
1169 { NULL, 0, 0, NULL}}
1170 ;
1171
1172 /* IPTUN_*FLAG_INDEX values are indices into iptun_flags below. */
1173 enum { IPTUN_SFLAG_INDEX, IPTUN_IFLAG_INDEX, IPTUN_NUM_FLAGS };
1174
1175 /*
1176 * structures for 'dladm show-iptun'
1177 */
1178 typedef struct iptun_fields_buf_s {
1179 char iptun_name[MAXLINKNAMELEN];
1180 char iptun_type[5];
1181 char iptun_laddr[NI_MAXHOST];
1182 char iptun_raddr[NI_MAXHOST];
1183 char iptun_flags[IPTUN_NUM_FLAGS + 1];
1184 } iptun_fields_buf_t;
1185
1186 static const ofmt_field_t iptun_fields[] = {
1187 { "LINK", 16,
1188 offsetof(iptun_fields_buf_t, iptun_name), print_default_cb },
1189 { "TYPE", 6,
1190 offsetof(iptun_fields_buf_t, iptun_type), print_default_cb },
1191 { "FLAGS", 7,
1192 offsetof(iptun_fields_buf_t, iptun_flags), print_default_cb },
1193 { "LOCAL", 20,
1194 offsetof(iptun_fields_buf_t, iptun_laddr), print_default_cb },
1195 { "REMOTE", 20,
1196 offsetof(iptun_fields_buf_t, iptun_raddr), print_default_cb },
1197 { NULL, 0, 0, NULL}
1198 };
1199
1200 /*
1201 * structures for 'dladm show-bridge'. These are based on sections 14.8.1.1.3
1202 * and 14.8.1.2.2 of IEEE 802.1D-2004.
1203 */
1204 typedef struct bridge_fields_buf_s {
1205 char bridge_name[MAXLINKNAMELEN]; /* 14.4.1.2.3(b) */
1206 char bridge_protect[7]; /* stp or trill */
1207 char bridge_address[24]; /* 17.18.3, 7.12.5, 14.4.1.2.3(a) */
1208 char bridge_priority[7]; /* 17.18.3 9.2.5 - only upper 4 bits */
1209 char bridge_bmaxage[7]; /* 17.18.4 configured */
1210 char bridge_bhellotime[7]; /* 17.18.4 configured */
1211 char bridge_bfwddelay[7]; /* 17.18.4 configured */
1212 char bridge_forceproto[3]; /* 17.13.4 configured */
1213 char bridge_tctime[12]; /* 14.8.1.1.3(b) */
1214 char bridge_tccount[12]; /* 17.17.8 */
1215 char bridge_tchange[12]; /* 17.17.8 */
1216 char bridge_desroot[24]; /* 17.18.6 priority "/" MAC */
1217 char bridge_rootcost[12]; /* 17.18.6 */
1218 char bridge_rootport[12]; /* 17.18.6 */
1219 char bridge_maxage[7]; /* 17.18.7 for root */
1220 char bridge_hellotime[7]; /* 17.13.6 for root */
1221 char bridge_fwddelay[7]; /* 17.13.5 for root */
1222 char bridge_holdtime[12]; /* 17.13.12 for root */
1223 } bridge_fields_buf_t;
1224
1225 static ofmt_field_t bridge_fields[] = {
1226 /* name, field width, offset, callback */
1227 { "BRIDGE", 12,
1228 offsetof(bridge_fields_buf_t, bridge_name), print_default_cb },
1229 { "PROTECT", 8,
1230 offsetof(bridge_fields_buf_t, bridge_protect), print_default_cb },
1231 { "ADDRESS", 19,
1232 offsetof(bridge_fields_buf_t, bridge_address), print_default_cb },
1233 { "PRIORITY", 9,
1234 offsetof(bridge_fields_buf_t, bridge_priority), print_default_cb },
1235 { "BMAXAGE", 8,
1236 offsetof(bridge_fields_buf_t, bridge_bmaxage), print_default_cb },
1237 { "BHELLOTIME", 11,
1238 offsetof(bridge_fields_buf_t, bridge_bhellotime), print_default_cb },
1239 { "BFWDDELAY", 10,
1240 offsetof(bridge_fields_buf_t, bridge_bfwddelay), print_default_cb },
1241 { "FORCEPROTO", 11,
1242 offsetof(bridge_fields_buf_t, bridge_forceproto), print_default_cb },
1243 { "TCTIME", 10,
1244 offsetof(bridge_fields_buf_t, bridge_tctime), print_default_cb },
1245 { "TCCOUNT", 10,
1246 offsetof(bridge_fields_buf_t, bridge_tccount), print_default_cb },
1247 { "TCHANGE", 10,
1248 offsetof(bridge_fields_buf_t, bridge_tchange), print_default_cb },
1249 { "DESROOT", 23,
1250 offsetof(bridge_fields_buf_t, bridge_desroot), print_default_cb },
1251 { "ROOTCOST", 11,
1252 offsetof(bridge_fields_buf_t, bridge_rootcost), print_default_cb },
1253 { "ROOTPORT", 11,
1254 offsetof(bridge_fields_buf_t, bridge_rootport), print_default_cb },
1255 { "MAXAGE", 8,
1256 offsetof(bridge_fields_buf_t, bridge_maxage), print_default_cb },
1257 { "HELLOTIME", 10,
1258 offsetof(bridge_fields_buf_t, bridge_hellotime), print_default_cb },
1259 { "FWDDELAY", 9,
1260 offsetof(bridge_fields_buf_t, bridge_fwddelay), print_default_cb },
1261 { "HOLDTIME", 9,
1262 offsetof(bridge_fields_buf_t, bridge_holdtime), print_default_cb },
1263 { NULL, 0, 0, NULL}};
1264
1265 /*
1266 * structures for 'dladm show-bridge -l'. These are based on 14.4.1.2.3 and
1267 * 14.8.2.1.3 of IEEE 802.1D-2004.
1268 */
1269 typedef struct bridge_link_fields_buf_s {
1270 char bridgel_link[MAXLINKNAMELEN];
1271 char bridgel_index[7]; /* 14.4.1.2.3(d1) */
1272 char bridgel_state[11]; /* 14.8.2.1.3(b) */
1273 char bridgel_uptime[7]; /* 14.8.2.1.3(a) */
1274 char bridgel_opercost[7] /* 14.8.2.1.3(d) */;
1275 char bridgel_operp2p[4]; /* 14.8.2.1.3(p) */
1276 char bridgel_operedge[4]; /* 14.8.2.1.3(k) */
1277 char bridgel_desroot[23]; /* 14.8.2.1.3(e) */
1278 char bridgel_descost[12]; /* 14.8.2.1.3(f) */
1279 char bridgel_desbridge[23]; /* 14.8.2.1.3(g) */
1280 char bridgel_desport[7]; /* 14.8.2.1.3(h) */
1281 char bridgel_tcack[4]; /* 14.8.2.1.3(i) */
1282 } bridge_link_fields_buf_t;
1283
1284 static ofmt_field_t bridge_link_fields[] = {
1285 /* name, field width, offset, callback */
1286 { "LINK", 12,
1287 offsetof(bridge_link_fields_buf_t, bridgel_link), print_default_cb },
1288 { "INDEX", 8,
1289 offsetof(bridge_link_fields_buf_t, bridgel_index), print_default_cb },
1290 { "STATE", 12,
1291 offsetof(bridge_link_fields_buf_t, bridgel_state), print_default_cb },
1292 { "UPTIME", 8,
1293 offsetof(bridge_link_fields_buf_t, bridgel_uptime), print_default_cb },
1294 { "OPERCOST", 9,
1295 offsetof(bridge_link_fields_buf_t, bridgel_opercost), print_default_cb },
1296 { "OPERP2P", 8,
1297 offsetof(bridge_link_fields_buf_t, bridgel_operp2p), print_default_cb },
1298 { "OPEREDGE", 9,
1299 offsetof(bridge_link_fields_buf_t, bridgel_operedge), print_default_cb },
1300 { "DESROOT", 22,
1301 offsetof(bridge_link_fields_buf_t, bridgel_desroot), print_default_cb },
1302 { "DESCOST", 11,
1303 offsetof(bridge_link_fields_buf_t, bridgel_descost), print_default_cb },
1304 { "DESBRIDGE", 22,
1305 offsetof(bridge_link_fields_buf_t, bridgel_desbridge), print_default_cb },
1306 { "DESPORT", 8,
1307 offsetof(bridge_link_fields_buf_t, bridgel_desport), print_default_cb },
1308 { "TCACK", 6,
1309 offsetof(bridge_link_fields_buf_t, bridgel_tcack), print_default_cb },
1310 { NULL, 0, 0, NULL}};
1311
1312 /*
1313 * structures for 'dladm show-bridge -s'. These are not based on IEEE
1314 * 802.1D-2004.
1315 */
1316 #define ULONG_DIG (((sizeof (ulong_t) * NBBY) * 3 / 10) + 1)
1317 #define UINT64_DIG (((sizeof (uint64_t) * NBBY) * 3 / 10) + 1)
1318 typedef struct bridge_statfields_buf_s {
1319 char bridges_name[MAXLINKNAMELEN];
1320 char bridges_drops[UINT64_DIG];
1321 char bridges_forwards[UINT64_DIG];
1322 char bridges_mbcast[UINT64_DIG];
1323 char bridges_unknown[UINT64_DIG];
1324 char bridges_recv[UINT64_DIG];
1325 char bridges_sent[UINT64_DIG];
1326 } bridge_statfields_buf_t;
1327
1328 static ofmt_field_t bridge_statfields[] = {
1329 /* name, field width, offset, callback */
1330 { "BRIDGE", 12,
1331 offsetof(bridge_statfields_buf_t, bridges_name), print_default_cb },
1332 { "DROPS", 12,
1333 offsetof(bridge_statfields_buf_t, bridges_drops), print_default_cb },
1334 { "FORWARDS", 12,
1335 offsetof(bridge_statfields_buf_t, bridges_forwards), print_default_cb },
1336 { "MBCAST", 12,
1337 offsetof(bridge_statfields_buf_t, bridges_mbcast), print_default_cb },
1338 { "UNKNOWN", 12,
1339 offsetof(bridge_statfields_buf_t, bridges_unknown), print_default_cb },
1340 { "RECV", 12,
1341 offsetof(bridge_statfields_buf_t, bridges_recv), print_default_cb },
1342 { "SENT", 12,
1343 offsetof(bridge_statfields_buf_t, bridges_sent), print_default_cb },
1344 { NULL, 0, 0, NULL}};
1345
1346 /*
1347 * structures for 'dladm show-bridge -s -l'. These are based in part on
1348 * section 14.6.1.1.3 of IEEE 802.1D-2004.
1349 */
1350 typedef struct bridge_link_statfields_buf_s {
1351 char bridgels_link[MAXLINKNAMELEN];
1352 char bridgels_cfgbpdu[ULONG_DIG];
1353 char bridgels_tcnbpdu[ULONG_DIG];
1354 char bridgels_rstpbpdu[ULONG_DIG];
1355 char bridgels_txbpdu[ULONG_DIG];
1356 char bridgels_drops[UINT64_DIG]; /* 14.6.1.1.3(d) */
1357 char bridgels_recv[UINT64_DIG]; /* 14.6.1.1.3(a) */
1358 char bridgels_xmit[UINT64_DIG]; /* 14.6.1.1.3(c) */
1359 } bridge_link_statfields_buf_t;
1360
1361 static ofmt_field_t bridge_link_statfields[] = {
1362 /* name, field width, offset, callback */
1363 { "LINK", 12,
1364 offsetof(bridge_link_statfields_buf_t, bridgels_link), print_default_cb },
1365 { "CFGBPDU", 9,
1366 offsetof(bridge_link_statfields_buf_t, bridgels_cfgbpdu),
1367 print_default_cb },
1368 { "TCNBPDU", 9,
1369 offsetof(bridge_link_statfields_buf_t, bridgels_tcnbpdu),
1370 print_default_cb },
1371 { "RSTPBPDU", 9,
1372 offsetof(bridge_link_statfields_buf_t, bridgels_rstpbpdu),
1373 print_default_cb },
1374 { "TXBPDU", 9,
1375 offsetof(bridge_link_statfields_buf_t, bridgels_txbpdu), print_default_cb },
1376 { "DROPS", 9,
1377 offsetof(bridge_link_statfields_buf_t, bridgels_drops), print_default_cb },
1378 { "RECV", 9,
1379 offsetof(bridge_link_statfields_buf_t, bridgels_recv), print_default_cb },
1380 { "XMIT", 9,
1381 offsetof(bridge_link_statfields_buf_t, bridgels_xmit), print_default_cb },
1382 { NULL, 0, 0, NULL}};
1383
1384 /*
1385 * structures for 'dladm show-bridge -f'. These are based in part on
1386 * section 14.7.6.3.3 of IEEE 802.1D-2004.
1387 */
1388 typedef struct bridge_fwd_fields_buf_s {
1389 char bridgef_dest[18]; /* 14.7.6.3.3(a) */
1390 char bridgef_age[8];
1391 char bridgef_flags[6];
1392 char bridgef_output[MAXLINKNAMELEN]; /* 14.7.6.3.3(c) */
1393 } bridge_fwd_fields_buf_t;
1394
1395 static ofmt_field_t bridge_fwd_fields[] = {
1396 /* name, field width, offset, callback */
1397 { "DEST", 17,
1398 offsetof(bridge_fwd_fields_buf_t, bridgef_dest), print_default_cb },
1399 { "AGE", 7,
1400 offsetof(bridge_fwd_fields_buf_t, bridgef_age), print_default_cb },
1401 { "FLAGS", 6,
1402 offsetof(bridge_fwd_fields_buf_t, bridgef_flags), print_default_cb },
1403 { "OUTPUT", 12,
1404 offsetof(bridge_fwd_fields_buf_t, bridgef_output), print_default_cb },
1405 { NULL, 0, 0, NULL}};
1406
1407 /*
1408 * structures for 'dladm show-bridge -t'.
1409 */
1410 typedef struct bridge_trill_fields_buf_s {
1411 char bridget_nick[6];
1412 char bridget_flags[6];
1413 char bridget_link[MAXLINKNAMELEN];
1414 char bridget_nexthop[18];
1415 } bridge_trill_fields_buf_t;
1416
1417 static ofmt_field_t bridge_trill_fields[] = {
1418 /* name, field width, offset, callback */
1419 { "NICK", 5,
1420 offsetof(bridge_trill_fields_buf_t, bridget_nick), print_default_cb },
1421 { "FLAGS", 6,
1422 offsetof(bridge_trill_fields_buf_t, bridget_flags), print_default_cb },
1423 { "LINK", 12,
1424 offsetof(bridge_trill_fields_buf_t, bridget_link), print_default_cb },
1425 { "NEXTHOP", 17,
1426 offsetof(bridge_trill_fields_buf_t, bridget_nexthop), print_default_cb },
1427 { NULL, 0, 0, NULL}};
1428
1429 static char *progname;
1430 static sig_atomic_t signalled;
1431
1432 /*
1433 * Handle to libdladm. Opened in main() before the sub-command
1434 * specific function is called.
1435 */
1436 static dladm_handle_t handle = NULL;
1437
1438 #define DLADM_ETHERSTUB_NAME "etherstub"
1439 #define DLADM_IS_ETHERSTUB(id) (id == DATALINK_INVALID_LINKID)
1440
1441 static void
1442 usage(void)
1443 {
1444 int i;
1445 cmd_t *cmdp;
1446 (void) fprintf(stderr, gettext("usage: dladm <subcommand> <args> ..."
1447 "\n"));
1448 for (i = 0; i < sizeof (cmds) / sizeof (cmds[0]); i++) {
1449 cmdp = &cmds[i];
1450 if (cmdp->c_usage != NULL)
1451 (void) fprintf(stderr, "%s\n", gettext(cmdp->c_usage));
1452 }
1453
1454 /* close dladm handle if it was opened */
1455 if (handle != NULL)
1456 dladm_close(handle);
1457
1458 exit(EXIT_FAILURE);
1459 }
1460
1461 int
1462 main(int argc, char *argv[])
1463 {
1464 int i;
1465 cmd_t *cmdp;
1466 dladm_status_t status;
1467
1468 (void) setlocale(LC_ALL, "");
1469 #if !defined(TEXT_DOMAIN)
1470 #define TEXT_DOMAIN "SYS_TEST"
1471 #endif
1472 (void) textdomain(TEXT_DOMAIN);
1473
1474 progname = argv[0];
1475
1476 /* Open the libdladm handle */
1477 if ((status = dladm_open(&handle)) != DLADM_STATUS_OK) {
1478 die_dlerr(status,
1479 "could not open /dev/dld");
1480 }
1481
1482 if (argc < 2) {
1483 char *args = "show-link";
1484 do_show_link(1, &args, args);
1485 dladm_close(handle);
1486 return (0);
1487 }
1488
1489 for (i = 0; i < sizeof (cmds) / sizeof (cmds[0]); i++) {
1490 cmdp = &cmds[i];
1491 if (strcmp(argv[1], cmdp->c_name) == 0) {
1492 cmdp->c_fn(argc - 1, &argv[1], cmdp->c_usage);
1493 dladm_close(handle);
1494 return (EXIT_SUCCESS);
1495 }
1496 }
1497
1498 (void) fprintf(stderr, gettext("%s: unknown subcommand '%s'\n"),
1499 progname, argv[1]);
1500 usage();
1501 return (EXIT_FAILURE);
1502 }
1503
1504 /*ARGSUSED*/
1505 static int
1506 show_usage_date(dladm_usage_t *usage, void *arg)
1507 {
1508 show_usage_state_t *state = (show_usage_state_t *)arg;
1509 time_t stime;
1510 char timebuf[20];
1511 dladm_status_t status;
1512 uint32_t flags;
1513
1514 /*
1515 * Only show usage information for existing links unless '-a'
1516 * is specified.
1517 */
1518 if (!state->us_showall) {
1519 if ((status = dladm_name2info(handle, usage->du_name,
1520 NULL, &flags, NULL, NULL)) != DLADM_STATUS_OK) {
1521 return (status);
1522 }
1523 if ((flags & DLADM_OPT_ACTIVE) == 0)
1524 return (DLADM_STATUS_LINKINVAL);
1525 }
1526
1527 stime = usage->du_stime;
1528 (void) strftime(timebuf, sizeof (timebuf), "%m/%d/%Y",
1529 localtime(&stime));
1530 (void) printf("%s\n", timebuf);
1531
1532 return (DLADM_STATUS_OK);
1533 }
1534
1535 static int
1536 show_usage_time(dladm_usage_t *usage, void *arg)
1537 {
1538 show_usage_state_t *state = (show_usage_state_t *)arg;
1539 char buf[DLADM_STRSIZE];
1540 usage_l_fields_buf_t ubuf;
1541 time_t time;
1542 double bw;
1543 dladm_status_t status;
1544 uint32_t flags;
1545
1546 /*
1547 * Only show usage information for existing links unless '-a'
1548 * is specified.
1549 */
1550 if (!state->us_showall) {
1551 if ((status = dladm_name2info(handle, usage->du_name,
1552 NULL, &flags, NULL, NULL)) != DLADM_STATUS_OK) {
1553 return (status);
1554 }
1555 if ((flags & DLADM_OPT_ACTIVE) == 0)
1556 return (DLADM_STATUS_LINKINVAL);
1557 }
1558
1559 if (state->us_plot) {
1560 if (!state->us_printheader) {
1561 if (state->us_first) {
1562 (void) printf("# Time");
1563 state->us_first = B_FALSE;
1564 }
1565 (void) printf(" %s", usage->du_name);
1566 if (usage->du_last) {
1567 (void) printf("\n");
1568 state->us_first = B_TRUE;
1569 state->us_printheader = B_TRUE;
1570 }
1571 } else {
1572 if (state->us_first) {
1573 time = usage->du_etime;
1574 (void) strftime(buf, sizeof (buf), "%T",
1575 localtime(&time));
1576 state->us_first = B_FALSE;
1577 (void) printf("%s", buf);
1578 }
1579 bw = (double)usage->du_bandwidth/1000;
1580 (void) printf(" %.2f", bw);
1581 if (usage->du_last) {
1582 (void) printf("\n");
1583 state->us_first = B_TRUE;
1584 }
1585 }
1586 return (DLADM_STATUS_OK);
1587 }
1588
1589 bzero(&ubuf, sizeof (ubuf));
1590
1591 (void) snprintf(ubuf.usage_l_link, sizeof (ubuf.usage_l_link), "%s",
1592 usage->du_name);
1593 time = usage->du_stime;
1594 (void) strftime(buf, sizeof (buf), "%T", localtime(&time));
1595 (void) snprintf(ubuf.usage_l_stime, sizeof (ubuf.usage_l_stime), "%s",
1596 buf);
1597 time = usage->du_etime;
1598 (void) strftime(buf, sizeof (buf), "%T", localtime(&time));
1599 (void) snprintf(ubuf.usage_l_etime, sizeof (ubuf.usage_l_etime), "%s",
1600 buf);
1601 (void) snprintf(ubuf.usage_l_rbytes, sizeof (ubuf.usage_l_rbytes),
1602 "%llu", usage->du_rbytes);
1603 (void) snprintf(ubuf.usage_l_obytes, sizeof (ubuf.usage_l_obytes),
1604 "%llu", usage->du_obytes);
1605 (void) snprintf(ubuf.usage_l_bandwidth, sizeof (ubuf.usage_l_bandwidth),
1606 "%s Mbps", dladm_bw2str(usage->du_bandwidth, buf));
1607
1608 ofmt_print(state->us_ofmt, &ubuf);
1609 return (DLADM_STATUS_OK);
1610 }
1611
1612 static int
1613 show_usage_res(dladm_usage_t *usage, void *arg)
1614 {
1615 show_usage_state_t *state = (show_usage_state_t *)arg;
1616 char buf[DLADM_STRSIZE];
1617 usage_fields_buf_t ubuf;
1618 dladm_status_t status;
1619 uint32_t flags;
1620
1621 /*
1622 * Only show usage information for existing links unless '-a'
1623 * is specified.
1624 */
1625 if (!state->us_showall) {
1626 if ((status = dladm_name2info(handle, usage->du_name,
1627 NULL, &flags, NULL, NULL)) != DLADM_STATUS_OK) {
1628 return (status);
1629 }
1630 if ((flags & DLADM_OPT_ACTIVE) == 0)
1631 return (DLADM_STATUS_LINKINVAL);
1632 }
1633
1634 bzero(&ubuf, sizeof (ubuf));
1635
1636 (void) snprintf(ubuf.usage_link, sizeof (ubuf.usage_link), "%s",
1637 usage->du_name);
1638 (void) snprintf(ubuf.usage_duration, sizeof (ubuf.usage_duration),
1639 "%llu", usage->du_duration);
1640 (void) snprintf(ubuf.usage_ipackets, sizeof (ubuf.usage_ipackets),
1641 "%llu", usage->du_ipackets);
1642 (void) snprintf(ubuf.usage_rbytes, sizeof (ubuf.usage_rbytes),
1643 "%llu", usage->du_rbytes);
1644 (void) snprintf(ubuf.usage_opackets, sizeof (ubuf.usage_opackets),
1645 "%llu", usage->du_opackets);
1646 (void) snprintf(ubuf.usage_obytes, sizeof (ubuf.usage_obytes),
1647 "%llu", usage->du_obytes);
1648 (void) snprintf(ubuf.usage_bandwidth, sizeof (ubuf.usage_bandwidth),
1649 "%s Mbps", dladm_bw2str(usage->du_bandwidth, buf));
1650
1651 ofmt_print(state->us_ofmt, &ubuf);
1652
1653 return (DLADM_STATUS_OK);
1654 }
1655
1656 static boolean_t
1657 valid_formatspec(char *formatspec_str)
1658 {
1659 if (strcmp(formatspec_str, "gnuplot") == 0)
1660 return (B_TRUE);
1661 return (B_FALSE);
1662
1663 }
1664
1665 /*ARGSUSED*/
1666 static void
1667 do_show_usage(int argc, char *argv[], const char *use)
1668 {
1669 char *file = NULL;
1670 int opt;
1671 dladm_status_t status;
1672 boolean_t d_arg = B_FALSE;
1673 char *stime = NULL;
1674 char *etime = NULL;
1675 char *resource = NULL;
1676 show_usage_state_t state;
1677 boolean_t o_arg = B_FALSE;
1678 boolean_t F_arg = B_FALSE;
1679 char *fields_str = NULL;
1680 char *formatspec_str = NULL;
1681 char *all_l_fields =
1682 "link,start,end,rbytes,obytes,bandwidth";
1683 ofmt_handle_t ofmt;
1684 ofmt_status_t oferr;
1685 uint_t ofmtflags = 0;
1686
1687 bzero(&state, sizeof (show_usage_state_t));
1688 state.us_parsable = B_FALSE;
1689 state.us_printheader = B_FALSE;
1690 state.us_plot = B_FALSE;
1691 state.us_first = B_TRUE;
1692
1693 while ((opt = getopt_long(argc, argv, "das:e:o:f:F:",
1694 usage_opts, NULL)) != -1) {
1695 switch (opt) {
1696 case 'd':
1697 d_arg = B_TRUE;
1698 break;
1699 case 'a':
1700 state.us_showall = B_TRUE;
1701 break;
1702 case 'f':
1703 file = optarg;
1704 break;
1705 case 's':
1706 stime = optarg;
1707 break;
1708 case 'e':
1709 etime = optarg;
1710 break;
1711 case 'o':
1712 o_arg = B_TRUE;
1713 fields_str = optarg;
1714 break;
1715 case 'F':
1716 state.us_plot = F_arg = B_TRUE;
1717 formatspec_str = optarg;
1718 break;
1719 default:
1720 die_opterr(optopt, opt, use);
1721 break;
1722 }
1723 }
1724
1725 if (file == NULL)
1726 die("show-usage requires a file");
1727
1728 if (optind == (argc-1)) {
1729 uint32_t flags;
1730
1731 resource = argv[optind];
1732 if (!state.us_showall &&
1733 (((status = dladm_name2info(handle, resource, NULL, &flags,
1734 NULL, NULL)) != DLADM_STATUS_OK) ||
1735 ((flags & DLADM_OPT_ACTIVE) == 0))) {
1736 die("invalid link: '%s'", resource);
1737 }
1738 }
1739
1740 if (F_arg && d_arg)
1741 die("incompatible -d and -F options");
1742
1743 if (F_arg && valid_formatspec(formatspec_str) == B_FALSE)
1744 die("Format specifier %s not supported", formatspec_str);
1745
1746 if (state.us_parsable)
1747 ofmtflags |= OFMT_PARSABLE;
1748
1749 if (resource == NULL && stime == NULL && etime == NULL) {
1750 oferr = ofmt_open(fields_str, usage_fields, ofmtflags, 0,
1751 &ofmt);
1752 } else {
1753 if (!o_arg || (o_arg && strcasecmp(fields_str, "all") == 0))
1754 fields_str = all_l_fields;
1755 oferr = ofmt_open(fields_str, usage_l_fields, ofmtflags, 0,
1756 &ofmt);
1757
1758 }
1759 ofmt_check(oferr, state.us_parsable, ofmt, die, warn);
1760 state.us_ofmt = ofmt;
1761
1762 if (d_arg) {
1763 /* Print log dates */
1764 status = dladm_usage_dates(show_usage_date,
1765 DLADM_LOGTYPE_LINK, file, resource, &state);
1766 } else if (resource == NULL && stime == NULL && etime == NULL &&
1767 !F_arg) {
1768 /* Print summary */
1769 status = dladm_usage_summary(show_usage_res,
1770 DLADM_LOGTYPE_LINK, file, &state);
1771 } else if (resource != NULL) {
1772 /* Print log entries for named resource */
1773 status = dladm_walk_usage_res(show_usage_time,
1774 DLADM_LOGTYPE_LINK, file, resource, stime, etime, &state);
1775 } else {
1776 /* Print time and information for each link */
1777 status = dladm_walk_usage_time(show_usage_time,
1778 DLADM_LOGTYPE_LINK, file, stime, etime, &state);
1779 }
1780
1781 if (status != DLADM_STATUS_OK)
1782 die_dlerr(status, "show-usage");
1783 ofmt_close(ofmt);
1784 }
1785
1786 static void
1787 do_create_aggr(int argc, char *argv[], const char *use)
1788 {
1789 int option;
1790 int key = 0;
1791 uint32_t policy = AGGR_POLICY_L4;
1792 aggr_lacp_mode_t lacp_mode = AGGR_LACP_OFF;
1793 aggr_lacp_timer_t lacp_timer = AGGR_LACP_TIMER_SHORT;
1794 dladm_aggr_port_attr_db_t port[MAXPORT];
1795 uint_t n, ndev, nlink;
1796 uint8_t mac_addr[ETHERADDRL];
1797 boolean_t mac_addr_fixed = B_FALSE;
1798 boolean_t P_arg = B_FALSE;
1799 boolean_t l_arg = B_FALSE;
1800 boolean_t u_arg = B_FALSE;
1801 boolean_t T_arg = B_FALSE;
1802 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
1803 char *altroot = NULL;
1804 char name[MAXLINKNAMELEN];
1805 char *devs[MAXPORT];
1806 char *links[MAXPORT];
1807 dladm_status_t status;
1808 dladm_status_t pstatus;
1809 char propstr[DLADM_STRSIZE];
1810 dladm_arg_list_t *proplist = NULL;
1811 int i;
1812 datalink_id_t linkid;
1813
1814 ndev = nlink = opterr = 0;
1815 bzero(propstr, DLADM_STRSIZE);
1816
1817 while ((option = getopt_long(argc, argv, ":d:l:L:P:R:tfu:T:p:",
1818 lopts, NULL)) != -1) {
1819 switch (option) {
1820 case 'd':
1821 if (ndev + nlink >= MAXPORT)
1822 die("too many ports specified");
1823
1824 devs[ndev++] = optarg;
1825 break;
1826 case 'P':
1827 if (P_arg)
1828 die_optdup(option);
1829
1830 P_arg = B_TRUE;
1831 if (!dladm_aggr_str2policy(optarg, &policy))
1832 die("invalid policy '%s'", optarg);
1833 break;
1834 case 'u':
1835 if (u_arg)
1836 die_optdup(option);
1837
1838 u_arg = B_TRUE;
1839 if (!dladm_aggr_str2macaddr(optarg, &mac_addr_fixed,
1840 mac_addr))
1841 die("invalid MAC address '%s'", optarg);
1842 break;
1843 case 'l':
1844 if (isdigit(optarg[strlen(optarg) - 1])) {
1845
1846 /*
1847 * Ended with digit, possibly a link name.
1848 */
1849 if (ndev + nlink >= MAXPORT)
1850 die("too many ports specified");
1851
1852 links[nlink++] = optarg;
1853 break;
1854 }
1855 /* FALLTHROUGH */
1856 case 'L':
1857 if (l_arg)
1858 die_optdup(option);
1859
1860 l_arg = B_TRUE;
1861 if (!dladm_aggr_str2lacpmode(optarg, &lacp_mode))
1862 die("invalid LACP mode '%s'", optarg);
1863 break;
1864 case 'T':
1865 if (T_arg)
1866 die_optdup(option);
1867
1868 T_arg = B_TRUE;
1869 if (!dladm_aggr_str2lacptimer(optarg, &lacp_timer))
1870 die("invalid LACP timer value '%s'", optarg);
1871 break;
1872 case 't':
1873 flags &= ~DLADM_OPT_PERSIST;
1874 break;
1875 case 'f':
1876 flags |= DLADM_OPT_FORCE;
1877 break;
1878 case 'R':
1879 altroot = optarg;
1880 break;
1881 case 'p':
1882 (void) strlcat(propstr, optarg, DLADM_STRSIZE);
1883 if (strlcat(propstr, ",", DLADM_STRSIZE) >=
1884 DLADM_STRSIZE)
1885 die("property list too long '%s'", propstr);
1886 break;
1887
1888 default:
1889 die_opterr(optopt, option, use);
1890 break;
1891 }
1892 }
1893
1894 if (ndev + nlink == 0)
1895 usage();
1896
1897 /* get key value or the aggregation name (required last argument) */
1898 if (optind != (argc-1))
1899 usage();
1900
1901 if (!str2int(argv[optind], &key)) {
1902 if (strlcpy(name, argv[optind], MAXLINKNAMELEN) >=
1903 MAXLINKNAMELEN) {
1904 die("link name too long '%s'", argv[optind]);
1905 }
1906
1907 if (!dladm_valid_linkname(name))
1908 die("invalid link name '%s'", argv[optind]);
1909 } else {
1910 (void) snprintf(name, MAXLINKNAMELEN, "aggr%d", key);
1911 }
1912
1913 if (altroot != NULL)
1914 altroot_cmd(altroot, argc, argv);
1915
1916 for (n = 0; n < ndev; n++) {
1917 if ((status = dladm_dev2linkid(handle, devs[n],
1918 &port[n].lp_linkid)) != DLADM_STATUS_OK) {
1919 die_dlerr(status, "invalid dev name '%s'", devs[n]);
1920 }
1921 }
1922
1923 for (n = 0; n < nlink; n++) {
1924 if ((status = dladm_name2info(handle, links[n],
1925 &port[ndev + n].lp_linkid, NULL, NULL, NULL)) !=
1926 DLADM_STATUS_OK) {
1927 die_dlerr(status, "invalid link name '%s'", links[n]);
1928 }
1929 }
1930
1931 status = dladm_aggr_create(handle, name, key, ndev + nlink, port,
1932 policy, mac_addr_fixed, (const uchar_t *)mac_addr, lacp_mode,
1933 lacp_timer, flags);
1934 if (status != DLADM_STATUS_OK)
1935 goto done;
1936
1937 if (dladm_parse_link_props(propstr, &proplist, B_FALSE)
1938 != DLADM_STATUS_OK)
1939 die("invalid aggregation property");
1940
1941 if (proplist == NULL)
1942 return;
1943
1944 status = dladm_name2info(handle, name, &linkid, NULL, NULL, NULL);
1945 if (status != DLADM_STATUS_OK)
1946 goto done;
1947
1948 for (i = 0; i < proplist->al_count; i++) {
1949 dladm_arg_info_t *aip = &proplist->al_info[i];
1950
1951 pstatus = dladm_set_linkprop(handle, linkid, aip->ai_name,
1952 aip->ai_val, aip->ai_count, flags);
1953
1954 if (pstatus != DLADM_STATUS_OK) {
1955 die_dlerr(pstatus,
1956 "aggr creation succeeded but "
1957 "could not set property '%s'", aip->ai_name);
1958 }
1959 }
1960 done:
1961 dladm_free_props(proplist);
1962 if (status != DLADM_STATUS_OK) {
1963 if (status == DLADM_STATUS_NONOTIF) {
1964 die("not all links have link up/down detection; must "
1965 "use -f (see dladm(8))");
1966 } else {
1967 die_dlerr(status, "create operation failed");
1968 }
1969 }
1970 }
1971
1972 /*
1973 * arg is either the key or the aggr name. Validate it and convert it to
1974 * the linkid if altroot is NULL.
1975 */
1976 static dladm_status_t
1977 i_dladm_aggr_get_linkid(const char *altroot, const char *arg,
1978 datalink_id_t *linkidp, uint32_t flags)
1979 {
1980 int key = 0;
1981 char *aggr = NULL;
1982 dladm_status_t status;
1983
1984 if (!str2int(arg, &key))
1985 aggr = (char *)arg;
1986
1987 if (aggr == NULL && key == 0)
1988 return (DLADM_STATUS_LINKINVAL);
1989
1990 if (altroot != NULL)
1991 return (DLADM_STATUS_OK);
1992
1993 if (aggr != NULL) {
1994 status = dladm_name2info(handle, aggr, linkidp, NULL, NULL,
1995 NULL);
1996 } else {
1997 status = dladm_key2linkid(handle, key, linkidp, flags);
1998 }
1999
2000 return (status);
2001 }
2002
2003 static void
2004 do_delete_aggr(int argc, char *argv[], const char *use)
2005 {
2006 int option;
2007 char *altroot = NULL;
2008 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
2009 dladm_status_t status;
2010 datalink_id_t linkid;
2011
2012 opterr = 0;
2013 while ((option = getopt_long(argc, argv, ":R:t", lopts, NULL)) != -1) {
2014 switch (option) {
2015 case 't':
2016 flags &= ~DLADM_OPT_PERSIST;
2017 break;
2018 case 'R':
2019 altroot = optarg;
2020 break;
2021 default:
2022 die_opterr(optopt, option, use);
2023 break;
2024 }
2025 }
2026
2027 /* get key value or the aggregation name (required last argument) */
2028 if (optind != (argc-1))
2029 usage();
2030
2031 status = i_dladm_aggr_get_linkid(altroot, argv[optind], &linkid, flags);
2032 if (status != DLADM_STATUS_OK)
2033 goto done;
2034
2035 if (altroot != NULL)
2036 altroot_cmd(altroot, argc, argv);
2037
2038 status = dladm_aggr_delete(handle, linkid, flags);
2039 done:
2040 if (status != DLADM_STATUS_OK)
2041 die_dlerr(status, "delete operation failed");
2042 }
2043
2044 static void
2045 do_add_aggr(int argc, char *argv[], const char *use)
2046 {
2047 int option;
2048 uint_t n, ndev, nlink;
2049 char *altroot = NULL;
2050 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
2051 datalink_id_t linkid;
2052 dladm_status_t status;
2053 dladm_aggr_port_attr_db_t port[MAXPORT];
2054 char *devs[MAXPORT];
2055 char *links[MAXPORT];
2056
2057 ndev = nlink = opterr = 0;
2058 while ((option = getopt_long(argc, argv, ":d:l:R:tf", lopts,
2059 NULL)) != -1) {
2060 switch (option) {
2061 case 'd':
2062 if (ndev + nlink >= MAXPORT)
2063 die("too many ports specified");
2064
2065 devs[ndev++] = optarg;
2066 break;
2067 case 'l':
2068 if (ndev + nlink >= MAXPORT)
2069 die("too many ports specified");
2070
2071 links[nlink++] = optarg;
2072 break;
2073 case 't':
2074 flags &= ~DLADM_OPT_PERSIST;
2075 break;
2076 case 'f':
2077 flags |= DLADM_OPT_FORCE;
2078 break;
2079 case 'R':
2080 altroot = optarg;
2081 break;
2082 default:
2083 die_opterr(optopt, option, use);
2084 break;
2085 }
2086 }
2087
2088 if (ndev + nlink == 0)
2089 usage();
2090
2091 /* get key value or the aggregation name (required last argument) */
2092 if (optind != (argc-1))
2093 usage();
2094
2095 if ((status = i_dladm_aggr_get_linkid(altroot, argv[optind], &linkid,
2096 flags & (DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST))) !=
2097 DLADM_STATUS_OK) {
2098 goto done;
2099 }
2100
2101 if (altroot != NULL)
2102 altroot_cmd(altroot, argc, argv);
2103
2104 for (n = 0; n < ndev; n++) {
2105 if ((status = dladm_dev2linkid(handle, devs[n],
2106 &(port[n].lp_linkid))) != DLADM_STATUS_OK) {
2107 die_dlerr(status, "invalid <dev> '%s'", devs[n]);
2108 }
2109 }
2110
2111 for (n = 0; n < nlink; n++) {
2112 if ((status = dladm_name2info(handle, links[n],
2113 &port[n + ndev].lp_linkid, NULL, NULL, NULL)) !=
2114 DLADM_STATUS_OK) {
2115 die_dlerr(status, "invalid <link> '%s'", links[n]);
2116 }
2117 }
2118
2119 status = dladm_aggr_add(handle, linkid, ndev + nlink, port, flags);
2120 done:
2121 if (status != DLADM_STATUS_OK) {
2122 /*
2123 * checking DLADM_STATUS_NOTSUP is a temporary workaround
2124 * and should be removed once 6399681 is fixed.
2125 */
2126 if (status == DLADM_STATUS_NOTSUP) {
2127 die("add operation failed: link capabilities don't "
2128 "match");
2129 } else if (status == DLADM_STATUS_NONOTIF) {
2130 die("not all links have link up/down detection; must "
2131 "use -f (see dladm(8))");
2132 } else {
2133 die_dlerr(status, "add operation failed");
2134 }
2135 }
2136 }
2137
2138 static void
2139 do_remove_aggr(int argc, char *argv[], const char *use)
2140 {
2141 int option;
2142 dladm_aggr_port_attr_db_t port[MAXPORT];
2143 uint_t n, ndev, nlink;
2144 char *devs[MAXPORT];
2145 char *links[MAXPORT];
2146 char *altroot = NULL;
2147 uint32_t flags;
2148 datalink_id_t linkid;
2149 dladm_status_t status;
2150
2151 flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
2152 ndev = nlink = opterr = 0;
2153 while ((option = getopt_long(argc, argv, ":d:l:R:t",
2154 lopts, NULL)) != -1) {
2155 switch (option) {
2156 case 'd':
2157 if (ndev + nlink >= MAXPORT)
2158 die("too many ports specified");
2159
2160 devs[ndev++] = optarg;
2161 break;
2162 case 'l':
2163 if (ndev + nlink >= MAXPORT)
2164 die("too many ports specified");
2165
2166 links[nlink++] = optarg;
2167 break;
2168 case 't':
2169 flags &= ~DLADM_OPT_PERSIST;
2170 break;
2171 case 'R':
2172 altroot = optarg;
2173 break;
2174 default:
2175 die_opterr(optopt, option, use);
2176 break;
2177 }
2178 }
2179
2180 if (ndev + nlink == 0)
2181 usage();
2182
2183 /* get key value or the aggregation name (required last argument) */
2184 if (optind != (argc-1))
2185 usage();
2186
2187 status = i_dladm_aggr_get_linkid(altroot, argv[optind], &linkid, flags);
2188 if (status != DLADM_STATUS_OK)
2189 goto done;
2190
2191 if (altroot != NULL)
2192 altroot_cmd(altroot, argc, argv);
2193
2194 for (n = 0; n < ndev; n++) {
2195 if ((status = dladm_dev2linkid(handle, devs[n],
2196 &(port[n].lp_linkid))) != DLADM_STATUS_OK) {
2197 die_dlerr(status, "invalid <dev> '%s'", devs[n]);
2198 }
2199 }
2200
2201 for (n = 0; n < nlink; n++) {
2202 if ((status = dladm_name2info(handle, links[n],
2203 &port[n + ndev].lp_linkid, NULL, NULL, NULL)) !=
2204 DLADM_STATUS_OK) {
2205 die_dlerr(status, "invalid <link> '%s'", links[n]);
2206 }
2207 }
2208
2209 status = dladm_aggr_remove(handle, linkid, ndev + nlink, port, flags);
2210 done:
2211 if (status != DLADM_STATUS_OK)
2212 die_dlerr(status, "remove operation failed");
2213 }
2214
2215 static void
2216 do_modify_aggr(int argc, char *argv[], const char *use)
2217 {
2218 int option;
2219 uint32_t policy = AGGR_POLICY_L4;
2220 aggr_lacp_mode_t lacp_mode = AGGR_LACP_OFF;
2221 aggr_lacp_timer_t lacp_timer = AGGR_LACP_TIMER_SHORT;
2222 uint8_t mac_addr[ETHERADDRL];
2223 boolean_t mac_addr_fixed = B_FALSE;
2224 uint8_t modify_mask = 0;
2225 char *altroot = NULL;
2226 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
2227 datalink_id_t linkid;
2228 dladm_status_t status;
2229
2230 opterr = 0;
2231 while ((option = getopt_long(argc, argv, ":L:l:P:R:tu:T:", lopts,
2232 NULL)) != -1) {
2233 switch (option) {
2234 case 'P':
2235 if (modify_mask & DLADM_AGGR_MODIFY_POLICY)
2236 die_optdup(option);
2237
2238 modify_mask |= DLADM_AGGR_MODIFY_POLICY;
2239
2240 if (!dladm_aggr_str2policy(optarg, &policy))
2241 die("invalid policy '%s'", optarg);
2242 break;
2243 case 'u':
2244 if (modify_mask & DLADM_AGGR_MODIFY_MAC)
2245 die_optdup(option);
2246
2247 modify_mask |= DLADM_AGGR_MODIFY_MAC;
2248
2249 if (!dladm_aggr_str2macaddr(optarg, &mac_addr_fixed,
2250 mac_addr))
2251 die("invalid MAC address '%s'", optarg);
2252 break;
2253 case 'l':
2254 case 'L':
2255 if (modify_mask & DLADM_AGGR_MODIFY_LACP_MODE)
2256 die_optdup(option);
2257
2258 modify_mask |= DLADM_AGGR_MODIFY_LACP_MODE;
2259
2260 if (!dladm_aggr_str2lacpmode(optarg, &lacp_mode))
2261 die("invalid LACP mode '%s'", optarg);
2262 break;
2263 case 'T':
2264 if (modify_mask & DLADM_AGGR_MODIFY_LACP_TIMER)
2265 die_optdup(option);
2266
2267 modify_mask |= DLADM_AGGR_MODIFY_LACP_TIMER;
2268
2269 if (!dladm_aggr_str2lacptimer(optarg, &lacp_timer))
2270 die("invalid LACP timer value '%s'", optarg);
2271 break;
2272 case 't':
2273 flags &= ~DLADM_OPT_PERSIST;
2274 break;
2275 case 'R':
2276 altroot = optarg;
2277 break;
2278 default:
2279 die_opterr(optopt, option, use);
2280 break;
2281 }
2282 }
2283
2284 if (modify_mask == 0)
2285 die("at least one of the -PulT options must be specified");
2286
2287 /* get key value or the aggregation name (required last argument) */
2288 if (optind != (argc-1))
2289 usage();
2290
2291 status = i_dladm_aggr_get_linkid(altroot, argv[optind], &linkid, flags);
2292 if (status != DLADM_STATUS_OK)
2293 goto done;
2294
2295 if (altroot != NULL)
2296 altroot_cmd(altroot, argc, argv);
2297
2298 status = dladm_aggr_modify(handle, linkid, modify_mask, policy,
2299 mac_addr_fixed, (const uchar_t *)mac_addr, lacp_mode, lacp_timer,
2300 flags);
2301
2302 done:
2303 if (status != DLADM_STATUS_OK)
2304 die_dlerr(status, "modify operation failed");
2305 }
2306
2307 /*ARGSUSED*/
2308 static void
2309 do_up_aggr(int argc, char *argv[], const char *use)
2310 {
2311 datalink_id_t linkid = DATALINK_ALL_LINKID;
2312 dladm_status_t status;
2313
2314 /*
2315 * get the key or the name of the aggregation (optional last argument)
2316 */
2317 if (argc == 2) {
2318 if ((status = i_dladm_aggr_get_linkid(NULL, argv[1], &linkid,
2319 DLADM_OPT_PERSIST)) != DLADM_STATUS_OK)
2320 goto done;
2321 } else if (argc > 2) {
2322 usage();
2323 }
2324
2325 status = dladm_aggr_up(handle, linkid);
2326 done:
2327 if (status != DLADM_STATUS_OK) {
2328 if (argc == 2) {
2329 die_dlerr(status,
2330 "could not bring up aggregation '%s'", argv[1]);
2331 } else {
2332 die_dlerr(status, "could not bring aggregations up");
2333 }
2334 }
2335 }
2336
2337 static void
2338 do_create_vlan(int argc, char *argv[], const char *use)
2339 {
2340 char *link = NULL;
2341 char drv[DLPI_LINKNAME_MAX];
2342 uint_t ppa;
2343 datalink_id_t linkid;
2344 datalink_id_t dev_linkid;
2345 int vid = 0;
2346 int option;
2347 uint32_t flags = (DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST);
2348 char *altroot = NULL;
2349 char vlan[MAXLINKNAMELEN];
2350 char propstr[DLADM_STRSIZE];
2351 dladm_arg_list_t *proplist = NULL;
2352 dladm_status_t status;
2353
2354 opterr = 0;
2355 bzero(propstr, DLADM_STRSIZE);
2356
2357 while ((option = getopt_long(argc, argv, ":tfR:l:v:p:",
2358 lopts, NULL)) != -1) {
2359 switch (option) {
2360 case 'v':
2361 if (vid != 0)
2362 die_optdup(option);
2363
2364 if (!str2int(optarg, &vid) || vid < 1 || vid > 4094)
2365 die("invalid VLAN identifier '%s'", optarg);
2366
2367 break;
2368 case 'l':
2369 if (link != NULL)
2370 die_optdup(option);
2371
2372 link = optarg;
2373 break;
2374 case 't':
2375 flags &= ~DLADM_OPT_PERSIST;
2376 break;
2377 case 'R':
2378 altroot = optarg;
2379 break;
2380 case 'p':
2381 (void) strlcat(propstr, optarg, DLADM_STRSIZE);
2382 if (strlcat(propstr, ",", DLADM_STRSIZE) >=
2383 DLADM_STRSIZE)
2384 die("property list too long '%s'", propstr);
2385 break;
2386 case 'f':
2387 flags |= DLADM_OPT_FORCE;
2388 break;
2389 default:
2390 die_opterr(optopt, option, use);
2391 break;
2392 }
2393 }
2394
2395 /* get vlan name if there is any */
2396 if ((vid == 0) || (link == NULL) || (argc - optind > 1))
2397 usage();
2398
2399 if (optind == (argc - 1)) {
2400 if (strlcpy(vlan, argv[optind], MAXLINKNAMELEN) >=
2401 MAXLINKNAMELEN) {
2402 die("vlan name too long '%s'", argv[optind]);
2403 }
2404 } else {
2405 if ((dlpi_parselink(link, drv, &ppa) != DLPI_SUCCESS) ||
2406 (ppa >= 1000) ||
2407 (dlpi_makelink(vlan, drv, vid * 1000 + ppa) !=
2408 DLPI_SUCCESS)) {
2409 die("invalid link name '%s'", link);
2410 }
2411 }
2412
2413 if (altroot != NULL)
2414 altroot_cmd(altroot, argc, argv);
2415
2416 if (dladm_name2info(handle, link, &dev_linkid, NULL, NULL, NULL) !=
2417 DLADM_STATUS_OK) {
2418 die("invalid link name '%s'", link);
2419 }
2420
2421 if (dladm_parse_link_props(propstr, &proplist, B_FALSE)
2422 != DLADM_STATUS_OK)
2423 die("invalid vlan property");
2424
2425 status = dladm_vlan_create(handle, vlan, dev_linkid, vid, proplist,
2426 flags, &linkid);
2427 switch (status) {
2428 case DLADM_STATUS_OK:
2429 break;
2430
2431 case DLADM_STATUS_NOTSUP:
2432 die("VLAN over '%s' may require lowered MTU; must use -f (see "
2433 "dladm(8))", link);
2434 break;
2435
2436 case DLADM_STATUS_LINKBUSY:
2437 die("VLAN over '%s' may not use default_tag ID "
2438 "(see dladm(8))", link);
2439 break;
2440
2441 default:
2442 die_dlerr(status, "create operation failed");
2443 }
2444 }
2445
2446 static void
2447 do_delete_vlan(int argc, char *argv[], const char *use)
2448 {
2449 int option;
2450 uint32_t flags = (DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST);
2451 char *altroot = NULL;
2452 datalink_id_t linkid;
2453 dladm_status_t status;
2454
2455 opterr = 0;
2456 while ((option = getopt_long(argc, argv, ":R:t", lopts, NULL)) != -1) {
2457 switch (option) {
2458 case 't':
2459 flags &= ~DLADM_OPT_PERSIST;
2460 break;
2461 case 'R':
2462 altroot = optarg;
2463 break;
2464 default:
2465 die_opterr(optopt, option, use);
2466 break;
2467 }
2468 }
2469
2470 /* get VLAN link name (required last argument) */
2471 if (optind != (argc - 1))
2472 usage();
2473
2474 if (altroot != NULL)
2475 altroot_cmd(altroot, argc, argv);
2476
2477 status = dladm_name2info(handle, argv[optind], &linkid, NULL, NULL,
2478 NULL);
2479 if (status != DLADM_STATUS_OK)
2480 goto done;
2481
2482 status = dladm_vlan_delete(handle, linkid, flags);
2483 done:
2484 if (status != DLADM_STATUS_OK)
2485 die_dlerr(status, "delete operation failed");
2486 }
2487
2488 /*ARGSUSED*/
2489 static void
2490 do_up_vlan(int argc, char *argv[], const char *use)
2491 {
2492 do_up_vnic_common(argc, argv, use, B_TRUE);
2493 }
2494
2495 static void
2496 do_rename_link(int argc, char *argv[], const char *use)
2497 {
2498 int option;
2499 char *link1, *link2;
2500 char *altroot = NULL;
2501 dladm_status_t status;
2502
2503 opterr = 0;
2504 while ((option = getopt_long(argc, argv, ":R:", lopts, NULL)) != -1) {
2505 switch (option) {
2506 case 'R':
2507 altroot = optarg;
2508 break;
2509 default:
2510 die_opterr(optopt, option, use);
2511 break;
2512 }
2513 }
2514
2515 /* get link1 and link2 name (required the last 2 arguments) */
2516 if (optind != (argc - 2))
2517 usage();
2518
2519 if (altroot != NULL)
2520 altroot_cmd(altroot, argc, argv);
2521
2522 link1 = argv[optind++];
2523 link2 = argv[optind];
2524 if ((status = dladm_rename_link(handle, link1, link2)) !=
2525 DLADM_STATUS_OK)
2526 die_dlerr(status, "rename operation failed");
2527 }
2528
2529 /*ARGSUSED*/
2530 static void
2531 do_delete_phys(int argc, char *argv[], const char *use)
2532 {
2533 datalink_id_t linkid = DATALINK_ALL_LINKID;
2534 dladm_status_t status;
2535
2536 /* get link name (required the last argument) */
2537 if (argc > 2)
2538 usage();
2539
2540 if (argc == 2) {
2541 if ((status = dladm_name2info(handle, argv[1], &linkid, NULL,
2542 NULL, NULL)) != DLADM_STATUS_OK)
2543 die_dlerr(status, "cannot delete '%s'", argv[1]);
2544 }
2545
2546 if ((status = dladm_phys_delete(handle, linkid)) != DLADM_STATUS_OK) {
2547 if (argc == 2)
2548 die_dlerr(status, "cannot delete '%s'", argv[1]);
2549 else
2550 die_dlerr(status, "delete operation failed");
2551 }
2552 }
2553
2554 /*ARGSUSED*/
2555 static int
2556 i_dladm_walk_linkmap(dladm_handle_t dh, datalink_id_t linkid, void *arg)
2557 {
2558 char name[MAXLINKNAMELEN];
2559 char mediabuf[DLADM_STRSIZE];
2560 char classbuf[DLADM_STRSIZE];
2561 datalink_class_t class;
2562 uint32_t media;
2563 uint32_t flags;
2564
2565 if (dladm_datalink_id2info(dh, linkid, &flags, &class, &media, name,
2566 MAXLINKNAMELEN) == DLADM_STATUS_OK) {
2567 (void) dladm_class2str(class, classbuf);
2568 (void) dladm_media2str(media, mediabuf);
2569 (void) printf("%-12s%8d %-12s%-20s %6d\n", name,
2570 linkid, classbuf, mediabuf, flags);
2571 }
2572 return (DLADM_WALK_CONTINUE);
2573 }
2574
2575 /*ARGSUSED*/
2576 static void
2577 do_show_linkmap(int argc, char *argv[], const char *use)
2578 {
2579 if (argc != 1)
2580 die("invalid arguments");
2581
2582 (void) printf("%-12s%8s %-12s%-20s %6s\n", "NAME", "LINKID",
2583 "CLASS", "MEDIA", "FLAGS");
2584
2585 (void) dladm_walk_datalink_id(i_dladm_walk_linkmap, handle, NULL,
2586 DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE,
2587 DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST);
2588 }
2589
2590 /*
2591 * Delete inactive physical links.
2592 */
2593 /*ARGSUSED*/
2594 static int
2595 purge_phys(dladm_handle_t dh, datalink_id_t linkid, void *arg)
2596 {
2597 datalink_class_t class;
2598 uint32_t flags;
2599
2600 if (dladm_datalink_id2info(dh, linkid, &flags, &class, NULL, NULL, 0)
2601 != DLADM_STATUS_OK) {
2602 return (DLADM_WALK_CONTINUE);
2603 }
2604
2605 if (class == DATALINK_CLASS_PHYS && !(flags & DLADM_OPT_ACTIVE))
2606 (void) dladm_phys_delete(dh, linkid);
2607
2608 return (DLADM_WALK_CONTINUE);
2609 }
2610
2611 /*ARGSUSED*/
2612 static void
2613 do_init_phys(int argc, char *argv[], const char *use)
2614 {
2615 di_node_t devtree;
2616
2617 if (argc > 1)
2618 usage();
2619
2620 /*
2621 * Force all the devices to attach, therefore all the network physical
2622 * devices can be known to the dlmgmtd daemon.
2623 */
2624 if ((devtree = di_init("/", DINFOFORCE | DINFOSUBTREE)) != DI_NODE_NIL)
2625 di_fini(devtree);
2626
2627 (void) dladm_walk_datalink_id(purge_phys, handle, NULL,
2628 DATALINK_CLASS_PHYS, DATALINK_ANY_MEDIATYPE, DLADM_OPT_PERSIST);
2629 }
2630
2631 /*
2632 * Print the active topology information.
2633 */
2634 void
2635 print_link_topology(show_state_t *state, datalink_id_t linkid,
2636 datalink_class_t class, link_fields_buf_t *lbuf)
2637 {
2638 uint32_t flags = state->ls_flags;
2639 dladm_status_t status;
2640 char tmpbuf[MAXLINKNAMELEN];
2641
2642 lbuf->link_over[0] = '\0';
2643 lbuf->link_bridge[0] = '\0';
2644
2645 switch (class) {
2646 case DATALINK_CLASS_AGGR:
2647 case DATALINK_CLASS_PHYS:
2648 case DATALINK_CLASS_ETHERSTUB:
2649 status = dladm_bridge_getlink(handle, linkid, lbuf->link_bridge,
2650 sizeof (lbuf->link_bridge));
2651 if (status != DLADM_STATUS_OK &&
2652 status != DLADM_STATUS_NOTFOUND)
2653 (void) strcpy(lbuf->link_bridge, "?");
2654 break;
2655 }
2656
2657 switch (class) {
2658 case DATALINK_CLASS_VLAN: {
2659 dladm_vlan_attr_t vinfo;
2660
2661 if (dladm_vlan_info(handle, linkid, &vinfo, flags) !=
2662 DLADM_STATUS_OK) {
2663 (void) strcpy(lbuf->link_over, "?");
2664 break;
2665 }
2666 if (dladm_datalink_id2info(handle, vinfo.dv_linkid, NULL, NULL,
2667 NULL, lbuf->link_over, sizeof (lbuf->link_over)) !=
2668 DLADM_STATUS_OK)
2669 (void) strcpy(lbuf->link_over, "?");
2670 break;
2671 }
2672 case DATALINK_CLASS_AGGR: {
2673 dladm_aggr_grp_attr_t ginfo;
2674 int i;
2675
2676 if (dladm_aggr_info(handle, linkid, &ginfo, flags) !=
2677 DLADM_STATUS_OK || ginfo.lg_nports == 0) {
2678 (void) strcpy(lbuf->link_over, "?");
2679 break;
2680 }
2681 for (i = 0; i < ginfo.lg_nports; i++) {
2682 if (dladm_datalink_id2info(handle,
2683 ginfo.lg_ports[i].lp_linkid, NULL, NULL, NULL,
2684 tmpbuf, sizeof (tmpbuf)) != DLADM_STATUS_OK) {
2685 (void) strcpy(lbuf->link_over, "?");
2686 break;
2687 }
2688 (void) strlcat(lbuf->link_over, tmpbuf,
2689 sizeof (lbuf->link_over));
2690 if (i != (ginfo.lg_nports - 1)) {
2691 (void) strlcat(lbuf->link_over, ",",
2692 sizeof (lbuf->link_over));
2693 }
2694 }
2695 free(ginfo.lg_ports);
2696 break;
2697 }
2698 case DATALINK_CLASS_VNIC: {
2699 dladm_vnic_attr_t vinfo;
2700
2701 if (dladm_vnic_info(handle, linkid, &vinfo, flags) !=
2702 DLADM_STATUS_OK) {
2703 (void) strcpy(lbuf->link_over, "?");
2704 break;
2705 }
2706 if (dladm_datalink_id2info(handle, vinfo.va_link_id, NULL, NULL,
2707 NULL, lbuf->link_over, sizeof (lbuf->link_over)) !=
2708 DLADM_STATUS_OK)
2709 (void) strcpy(lbuf->link_over, "?");
2710 break;
2711 }
2712
2713 case DATALINK_CLASS_PART: {
2714 dladm_part_attr_t pinfo;
2715
2716 if (dladm_part_info(handle, linkid, &pinfo, flags) !=
2717 DLADM_STATUS_OK) {
2718 (void) strcpy(lbuf->link_over, "?");
2719 break;
2720 }
2721 if (dladm_datalink_id2info(handle, pinfo.dia_physlinkid, NULL,
2722 NULL, NULL, lbuf->link_over, sizeof (lbuf->link_over)) !=
2723 DLADM_STATUS_OK)
2724 (void) strcpy(lbuf->link_over, "?");
2725 break;
2726 }
2727
2728 case DATALINK_CLASS_BRIDGE: {
2729 datalink_id_t *dlp;
2730 uint_t i, nports;
2731
2732 if (dladm_datalink_id2info(handle, linkid, NULL, NULL,
2733 NULL, tmpbuf, sizeof (tmpbuf)) != DLADM_STATUS_OK) {
2734 (void) strcpy(lbuf->link_over, "?");
2735 break;
2736 }
2737 if (tmpbuf[0] != '\0')
2738 tmpbuf[strlen(tmpbuf) - 1] = '\0';
2739 dlp = dladm_bridge_get_portlist(tmpbuf, &nports);
2740 if (dlp == NULL) {
2741 (void) strcpy(lbuf->link_over, "?");
2742 break;
2743 }
2744 for (i = 0; i < nports; i++) {
2745 if (dladm_datalink_id2info(handle, dlp[i], NULL,
2746 NULL, NULL, tmpbuf, sizeof (tmpbuf)) !=
2747 DLADM_STATUS_OK) {
2748 (void) strcpy(lbuf->link_over, "?");
2749 break;
2750 }
2751 (void) strlcat(lbuf->link_over, tmpbuf,
2752 sizeof (lbuf->link_over));
2753 if (i != nports - 1) {
2754 (void) strlcat(lbuf->link_over, ",",
2755 sizeof (lbuf->link_over));
2756 }
2757 }
2758 dladm_bridge_free_portlist(dlp);
2759 break;
2760 }
2761
2762 case DATALINK_CLASS_SIMNET: {
2763 dladm_simnet_attr_t slinfo;
2764
2765 if (dladm_simnet_info(handle, linkid, &slinfo, flags) !=
2766 DLADM_STATUS_OK) {
2767 (void) strcpy(lbuf->link_over, "?");
2768 break;
2769 }
2770 if (slinfo.sna_peer_link_id != DATALINK_INVALID_LINKID) {
2771 if (dladm_datalink_id2info(handle,
2772 slinfo.sna_peer_link_id, NULL, NULL, NULL,
2773 lbuf->link_over, sizeof (lbuf->link_over)) !=
2774 DLADM_STATUS_OK)
2775 (void) strcpy(lbuf->link_over, "?");
2776 }
2777 break;
2778 }
2779 }
2780 }
2781
2782 static dladm_status_t
2783 print_link(show_state_t *state, datalink_id_t linkid, link_fields_buf_t *lbuf)
2784 {
2785 char link[MAXLINKNAMELEN];
2786 datalink_class_t class;
2787 uint_t mtu;
2788 uint32_t flags;
2789 dladm_status_t status;
2790
2791 if ((status = dladm_datalink_id2info(handle, linkid, &flags, &class,
2792 NULL, link, sizeof (link))) != DLADM_STATUS_OK) {
2793 goto done;
2794 }
2795
2796 if (!(state->ls_flags & flags)) {
2797 status = DLADM_STATUS_NOTFOUND;
2798 goto done;
2799 }
2800
2801 if (state->ls_flags == DLADM_OPT_ACTIVE) {
2802 dladm_attr_t dlattr;
2803
2804 if (class == DATALINK_CLASS_PHYS) {
2805 dladm_phys_attr_t dpa;
2806 dlpi_handle_t dh;
2807 dlpi_info_t dlinfo;
2808
2809 if ((status = dladm_phys_info(handle, linkid, &dpa,
2810 DLADM_OPT_ACTIVE)) != DLADM_STATUS_OK) {
2811 goto done;
2812 }
2813
2814 if (!dpa.dp_novanity)
2815 goto link_mtu;
2816
2817 /*
2818 * This is a physical link that does not have
2819 * vanity naming support.
2820 */
2821 if (dlpi_open(dpa.dp_dev, &dh, DLPI_DEVONLY) !=
2822 DLPI_SUCCESS) {
2823 status = DLADM_STATUS_NOTFOUND;
2824 goto done;
2825 }
2826
2827 if (dlpi_info(dh, &dlinfo, 0) != DLPI_SUCCESS) {
2828 dlpi_close(dh);
2829 status = DLADM_STATUS_BADARG;
2830 goto done;
2831 }
2832
2833 dlpi_close(dh);
2834 mtu = dlinfo.di_max_sdu;
2835 } else {
2836 link_mtu:
2837 status = dladm_info(handle, linkid, &dlattr);
2838 if (status != DLADM_STATUS_OK)
2839 goto done;
2840 mtu = dlattr.da_max_sdu;
2841 }
2842 }
2843
2844 (void) snprintf(lbuf->link_name, sizeof (lbuf->link_name),
2845 "%s", link);
2846 (void) dladm_class2str(class, lbuf->link_class);
2847 if (state->ls_flags == DLADM_OPT_ACTIVE) {
2848 (void) snprintf(lbuf->link_mtu, sizeof (lbuf->link_mtu),
2849 "%u", mtu);
2850 (void) get_linkstate(link, B_TRUE, lbuf->link_state);
2851 }
2852
2853 print_link_topology(state, linkid, class, lbuf);
2854 done:
2855 return (status);
2856 }
2857
2858 /* ARGSUSED */
2859 static int
2860 show_link(dladm_handle_t dh, datalink_id_t linkid, void *arg)
2861 {
2862 show_state_t *state = (show_state_t *)arg;
2863 dladm_status_t status;
2864 link_fields_buf_t lbuf;
2865
2866 /*
2867 * first get all the link attributes into lbuf;
2868 */
2869 bzero(&lbuf, sizeof (link_fields_buf_t));
2870 if ((status = print_link(state, linkid, &lbuf)) == DLADM_STATUS_OK)
2871 ofmt_print(state->ls_ofmt, &lbuf);
2872 state->ls_status = status;
2873 return (DLADM_WALK_CONTINUE);
2874 }
2875
2876 static boolean_t
2877 print_link_stats_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
2878 {
2879 link_args_t *largs = ofarg->ofmt_cbarg;
2880 pktsum_t *diff_stats = largs->link_s_psum;
2881
2882 switch (ofarg->ofmt_id) {
2883 case LINK_S_LINK:
2884 (void) snprintf(buf, bufsize, "%s", largs->link_s_link);
2885 break;
2886 case LINK_S_IPKTS:
2887 (void) snprintf(buf, bufsize, "%llu", diff_stats->ipackets);
2888 break;
2889 case LINK_S_RBYTES:
2890 (void) snprintf(buf, bufsize, "%llu", diff_stats->rbytes);
2891 break;
2892 case LINK_S_IERRORS:
2893 (void) snprintf(buf, bufsize, "%u", diff_stats->ierrors);
2894 break;
2895 case LINK_S_OPKTS:
2896 (void) snprintf(buf, bufsize, "%llu", diff_stats->opackets);
2897 break;
2898 case LINK_S_OBYTES:
2899 (void) snprintf(buf, bufsize, "%llu", diff_stats->obytes);
2900 break;
2901 case LINK_S_OERRORS:
2902 (void) snprintf(buf, bufsize, "%u", diff_stats->oerrors);
2903 break;
2904 default:
2905 die("invalid input");
2906 break;
2907 }
2908 return (B_TRUE);
2909 }
2910
2911 static int
2912 show_link_stats(dladm_handle_t dh, datalink_id_t linkid, void *arg)
2913 {
2914 char link[DLPI_LINKNAME_MAX];
2915 datalink_class_t class;
2916 show_state_t *state = arg;
2917 pktsum_t stats, diff_stats;
2918 dladm_phys_attr_t dpa;
2919 link_args_t largs;
2920
2921 if (state->ls_firstonly) {
2922 if (state->ls_donefirst)
2923 return (DLADM_WALK_CONTINUE);
2924 state->ls_donefirst = B_TRUE;
2925 } else {
2926 bzero(&state->ls_prevstats, sizeof (state->ls_prevstats));
2927 }
2928
2929 if (dladm_datalink_id2info(dh, linkid, NULL, &class, NULL, link,
2930 DLPI_LINKNAME_MAX) != DLADM_STATUS_OK) {
2931 return (DLADM_WALK_CONTINUE);
2932 }
2933
2934 if (class == DATALINK_CLASS_PHYS) {
2935 if (dladm_phys_info(dh, linkid, &dpa, DLADM_OPT_ACTIVE) !=
2936 DLADM_STATUS_OK) {
2937 return (DLADM_WALK_CONTINUE);
2938 }
2939 if (dpa.dp_novanity)
2940 get_mac_stats(dpa.dp_dev, &stats);
2941 else
2942 get_link_stats(link, &stats);
2943 } else {
2944 get_link_stats(link, &stats);
2945 }
2946 dladm_stats_diff(&diff_stats, &stats, &state->ls_prevstats);
2947
2948 largs.link_s_link = link;
2949 largs.link_s_psum = &diff_stats;
2950 ofmt_print(state->ls_ofmt, &largs);
2951
2952 state->ls_prevstats = stats;
2953 return (DLADM_WALK_CONTINUE);
2954 }
2955
2956
2957 static dladm_status_t
2958 print_aggr_info(show_grp_state_t *state, const char *link,
2959 dladm_aggr_grp_attr_t *ginfop)
2960 {
2961 char addr_str[ETHERADDRL * 3];
2962 laggr_fields_buf_t lbuf;
2963
2964 (void) snprintf(lbuf.laggr_name, sizeof (lbuf.laggr_name),
2965 "%s", link);
2966
2967 (void) dladm_aggr_policy2str(ginfop->lg_policy,
2968 lbuf.laggr_policy);
2969
2970 if (ginfop->lg_mac_fixed) {
2971 (void) dladm_aggr_macaddr2str(ginfop->lg_mac, addr_str);
2972 (void) snprintf(lbuf.laggr_addrpolicy,
2973 sizeof (lbuf.laggr_addrpolicy), "fixed (%s)", addr_str);
2974 } else {
2975 (void) snprintf(lbuf.laggr_addrpolicy,
2976 sizeof (lbuf.laggr_addrpolicy), "auto");
2977 }
2978
2979 (void) dladm_aggr_lacpmode2str(ginfop->lg_lacp_mode,
2980 lbuf.laggr_lacpactivity);
2981 (void) dladm_aggr_lacptimer2str(ginfop->lg_lacp_timer,
2982 lbuf.laggr_lacptimer);
2983 (void) snprintf(lbuf.laggr_flags, sizeof (lbuf.laggr_flags), "%c----",
2984 ginfop->lg_force ? 'f' : '-');
2985
2986 ofmt_print(state->gs_ofmt, &lbuf);
2987
2988 return (DLADM_STATUS_OK);
2989 }
2990
2991 static boolean_t
2992 print_xaggr_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
2993 {
2994 const laggr_args_t *l = ofarg->ofmt_cbarg;
2995 boolean_t is_port = (l->laggr_lport >= 0);
2996 char tmpbuf[DLADM_STRSIZE];
2997 const char *objname;
2998 dladm_aggr_port_attr_t *portp;
2999 dladm_phys_attr_t dpa;
3000
3001 if (is_port) {
3002 portp = &(l->laggr_ginfop->lg_ports[l->laggr_lport]);
3003 if (dladm_phys_info(handle, portp->lp_linkid, &dpa,
3004 DLADM_OPT_ACTIVE) != DLADM_STATUS_OK)
3005 objname = "?";
3006 else
3007 objname = dpa.dp_dev;
3008 } else {
3009 objname = l->laggr_link;
3010 }
3011
3012 switch (ofarg->ofmt_id) {
3013 case AGGR_X_LINK:
3014 (void) snprintf(buf, bufsize, "%s",
3015 (is_port && !l->laggr_parsable ? " " : l->laggr_link));
3016 break;
3017 case AGGR_X_PORT:
3018 if (is_port) {
3019 if (dladm_datalink_id2info(handle, portp->lp_linkid,
3020 NULL, NULL, NULL, buf, bufsize) != DLADM_STATUS_OK)
3021 (void) sprintf(buf, "?");
3022 }
3023 break;
3024
3025 case AGGR_X_SPEED:
3026 (void) snprintf(buf, bufsize, "%uMb",
3027 (uint_t)((get_ifspeed(objname, !is_port)) / 1000000ull));
3028 break;
3029
3030 case AGGR_X_DUPLEX:
3031 (void) get_linkduplex(objname, !is_port, tmpbuf);
3032 (void) strlcpy(buf, tmpbuf, bufsize);
3033 break;
3034
3035 case AGGR_X_STATE:
3036 (void) get_linkstate(objname, !is_port, tmpbuf);
3037 (void) strlcpy(buf, tmpbuf, bufsize);
3038 break;
3039 case AGGR_X_ADDRESS:
3040 (void) dladm_aggr_macaddr2str(
3041 (is_port ? portp->lp_mac : l->laggr_ginfop->lg_mac),
3042 tmpbuf);
3043 (void) strlcpy(buf, tmpbuf, bufsize);
3044 break;
3045 case AGGR_X_PORTSTATE:
3046 if (is_port) {
3047 (void) dladm_aggr_portstate2str(portp->lp_state,
3048 tmpbuf);
3049 (void) strlcpy(buf, tmpbuf, bufsize);
3050 }
3051 break;
3052 }
3053 err:
3054 *(l->laggr_status) = DLADM_STATUS_OK;
3055 return (B_TRUE);
3056 }
3057
3058 static dladm_status_t
3059 print_aggr_extended(show_grp_state_t *state, const char *link,
3060 dladm_aggr_grp_attr_t *ginfop)
3061 {
3062 int i;
3063 dladm_status_t status;
3064 laggr_args_t largs;
3065
3066 largs.laggr_lport = -1;
3067 largs.laggr_link = link;
3068 largs.laggr_ginfop = ginfop;
3069 largs.laggr_status = &status;
3070 largs.laggr_parsable = state->gs_parsable;
3071
3072 ofmt_print(state->gs_ofmt, &largs);
3073
3074 if (status != DLADM_STATUS_OK)
3075 goto done;
3076
3077 for (i = 0; i < ginfop->lg_nports; i++) {
3078 largs.laggr_lport = i;
3079 ofmt_print(state->gs_ofmt, &largs);
3080 if (status != DLADM_STATUS_OK)
3081 goto done;
3082 }
3083
3084 status = DLADM_STATUS_OK;
3085 done:
3086 return (status);
3087 }
3088
3089 static boolean_t
3090 print_lacp_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
3091 {
3092 const laggr_args_t *l = ofarg->ofmt_cbarg;
3093 int portnum;
3094 boolean_t is_port = (l->laggr_lport >= 0);
3095 dladm_aggr_port_attr_t *portp;
3096 aggr_lacp_state_t *lstate;
3097
3098 if (!is_port)
3099 return (B_FALSE); /* cannot happen! */
3100
3101 portnum = l->laggr_lport;
3102 portp = &(l->laggr_ginfop->lg_ports[portnum]);
3103 lstate = &(portp->lp_lacp_state);
3104
3105 switch (ofarg->ofmt_id) {
3106 case AGGR_L_LINK:
3107 (void) snprintf(buf, bufsize, "%s",
3108 (portnum > 0 ? "" : l->laggr_link));
3109 break;
3110
3111 case AGGR_L_PORT:
3112 if (dladm_datalink_id2info(handle, portp->lp_linkid, NULL, NULL,
3113 NULL, buf, bufsize) != DLADM_STATUS_OK)
3114 (void) sprintf(buf, "?");
3115 break;
3116
3117 case AGGR_L_AGGREGATABLE:
3118 (void) snprintf(buf, bufsize, "%s",
3119 (lstate->bit.aggregation ? "yes" : "no"));
3120 break;
3121
3122 case AGGR_L_SYNC:
3123 (void) snprintf(buf, bufsize, "%s",
3124 (lstate->bit.sync ? "yes" : "no"));
3125 break;
3126
3127 case AGGR_L_COLL:
3128 (void) snprintf(buf, bufsize, "%s",
3129 (lstate->bit.collecting ? "yes" : "no"));
3130 break;
3131
3132 case AGGR_L_DIST:
3133 (void) snprintf(buf, bufsize, "%s",
3134 (lstate->bit.distributing ? "yes" : "no"));
3135 break;
3136
3137 case AGGR_L_DEFAULTED:
3138 (void) snprintf(buf, bufsize, "%s",
3139 (lstate->bit.defaulted ? "yes" : "no"));
3140 break;
3141
3142 case AGGR_L_EXPIRED:
3143 (void) snprintf(buf, bufsize, "%s",
3144 (lstate->bit.expired ? "yes" : "no"));
3145 break;
3146 }
3147
3148 *(l->laggr_status) = DLADM_STATUS_OK;
3149 return (B_TRUE);
3150 }
3151
3152 static dladm_status_t
3153 print_aggr_lacp(show_grp_state_t *state, const char *link,
3154 dladm_aggr_grp_attr_t *ginfop)
3155 {
3156 int i;
3157 dladm_status_t status;
3158 laggr_args_t largs;
3159
3160 largs.laggr_link = link;
3161 largs.laggr_ginfop = ginfop;
3162 largs.laggr_status = &status;
3163
3164 for (i = 0; i < ginfop->lg_nports; i++) {
3165 largs.laggr_lport = i;
3166 ofmt_print(state->gs_ofmt, &largs);
3167 if (status != DLADM_STATUS_OK)
3168 goto done;
3169 }
3170
3171 status = DLADM_STATUS_OK;
3172 done:
3173 return (status);
3174 }
3175
3176 static boolean_t
3177 print_aggr_stats_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
3178 {
3179 const laggr_args_t *l = ofarg->ofmt_cbarg;
3180 int portnum;
3181 boolean_t is_port = (l->laggr_lport >= 0);
3182 dladm_aggr_port_attr_t *portp;
3183 dladm_status_t *stat, status;
3184 pktsum_t *diff_stats;
3185
3186 stat = l->laggr_status;
3187 *stat = DLADM_STATUS_OK;
3188
3189 if (is_port) {
3190 portnum = l->laggr_lport;
3191 portp = &(l->laggr_ginfop->lg_ports[portnum]);
3192
3193 if ((status = dladm_datalink_id2info(handle,
3194 portp->lp_linkid, NULL, NULL, NULL, buf, bufsize)) !=
3195 DLADM_STATUS_OK) {
3196 goto err;
3197 }
3198 diff_stats = l->laggr_diffstats;
3199 }
3200
3201 switch (ofarg->ofmt_id) {
3202 case AGGR_S_LINK:
3203 (void) snprintf(buf, bufsize, "%s",
3204 (is_port ? "" : l->laggr_link));
3205 break;
3206 case AGGR_S_PORT:
3207 /*
3208 * if (is_port), buf has port name. Otherwise we print
3209 * STR_UNDEF_VAL
3210 */
3211 break;
3212
3213 case AGGR_S_IPKTS:
3214 if (is_port) {
3215 (void) snprintf(buf, bufsize, "%llu",
3216 diff_stats->ipackets);
3217 } else {
3218 (void) snprintf(buf, bufsize, "%llu",
3219 l->laggr_pktsumtot->ipackets);
3220 }
3221 break;
3222
3223 case AGGR_S_RBYTES:
3224 if (is_port) {
3225 (void) snprintf(buf, bufsize, "%llu",
3226 diff_stats->rbytes);
3227 } else {
3228 (void) snprintf(buf, bufsize, "%llu",
3229 l->laggr_pktsumtot->rbytes);
3230 }
3231 break;
3232
3233 case AGGR_S_OPKTS:
3234 if (is_port) {
3235 (void) snprintf(buf, bufsize, "%llu",
3236 diff_stats->opackets);
3237 } else {
3238 (void) snprintf(buf, bufsize, "%llu",
3239 l->laggr_pktsumtot->opackets);
3240 }
3241 break;
3242 case AGGR_S_OBYTES:
3243 if (is_port) {
3244 (void) snprintf(buf, bufsize, "%llu",
3245 diff_stats->obytes);
3246 } else {
3247 (void) snprintf(buf, bufsize, "%llu",
3248 l->laggr_pktsumtot->obytes);
3249 }
3250 break;
3251
3252 case AGGR_S_IPKTDIST:
3253 if (is_port) {
3254 (void) snprintf(buf, bufsize, "%-6.1f",
3255 (double)diff_stats->ipackets/
3256 (double)l->laggr_pktsumtot->ipackets * 100);
3257 }
3258 break;
3259 case AGGR_S_OPKTDIST:
3260 if (is_port) {
3261 (void) snprintf(buf, bufsize, "%-6.1f",
3262 (double)diff_stats->opackets/
3263 (double)l->laggr_pktsumtot->opackets * 100);
3264 }
3265 break;
3266 }
3267 return (B_TRUE);
3268
3269 err:
3270 *stat = status;
3271 return (B_TRUE);
3272 }
3273
3274 static dladm_status_t
3275 print_aggr_stats(show_grp_state_t *state, const char *link,
3276 dladm_aggr_grp_attr_t *ginfop)
3277 {
3278 dladm_phys_attr_t dpa;
3279 dladm_aggr_port_attr_t *portp;
3280 pktsum_t pktsumtot, *port_stat;
3281 dladm_status_t status;
3282 int i;
3283 laggr_args_t largs;
3284
3285 /* sum the ports statistics */
3286 bzero(&pktsumtot, sizeof (pktsumtot));
3287
3288 /* Allocate memory to keep stats of each port */
3289 port_stat = malloc(ginfop->lg_nports * sizeof (pktsum_t));
3290 if (port_stat == NULL) {
3291 /* Bail out; no memory */
3292 return (DLADM_STATUS_NOMEM);
3293 }
3294
3295
3296 for (i = 0; i < ginfop->lg_nports; i++) {
3297
3298 portp = &(ginfop->lg_ports[i]);
3299 if ((status = dladm_phys_info(handle, portp->lp_linkid, &dpa,
3300 DLADM_OPT_ACTIVE)) != DLADM_STATUS_OK) {
3301 goto done;
3302 }
3303
3304 get_mac_stats(dpa.dp_dev, &port_stat[i]);
3305
3306 /*
3307 * Let's re-use gs_prevstats[] to store the difference of the
3308 * counters since last use. We will store the new stats from
3309 * port_stat[] once we have the stats displayed.
3310 */
3311
3312 dladm_stats_diff(&state->gs_prevstats[i], &port_stat[i],
3313 &state->gs_prevstats[i]);
3314 dladm_stats_total(&pktsumtot, &pktsumtot,
3315 &state->gs_prevstats[i]);
3316 }
3317
3318 largs.laggr_lport = -1;
3319 largs.laggr_link = link;
3320 largs.laggr_ginfop = ginfop;
3321 largs.laggr_status = &status;
3322 largs.laggr_pktsumtot = &pktsumtot;
3323
3324 ofmt_print(state->gs_ofmt, &largs);
3325
3326 if (status != DLADM_STATUS_OK)
3327 goto done;
3328
3329 for (i = 0; i < ginfop->lg_nports; i++) {
3330 largs.laggr_lport = i;
3331 largs.laggr_diffstats = &state->gs_prevstats[i];
3332 ofmt_print(state->gs_ofmt, &largs);
3333 if (status != DLADM_STATUS_OK)
3334 goto done;
3335 }
3336
3337 status = DLADM_STATUS_OK;
3338 for (i = 0; i < ginfop->lg_nports; i++)
3339 state->gs_prevstats[i] = port_stat[i];
3340
3341 done:
3342 free(port_stat);
3343 return (status);
3344 }
3345
3346 static dladm_status_t
3347 print_aggr(show_grp_state_t *state, datalink_id_t linkid)
3348 {
3349 char link[MAXLINKNAMELEN];
3350 dladm_aggr_grp_attr_t ginfo;
3351 uint32_t flags;
3352 dladm_status_t status;
3353
3354 bzero(&ginfo, sizeof (dladm_aggr_grp_attr_t));
3355 if ((status = dladm_datalink_id2info(handle, linkid, &flags, NULL,
3356 NULL, link, MAXLINKNAMELEN)) != DLADM_STATUS_OK) {
3357 return (status);
3358 }
3359
3360 if (!(state->gs_flags & flags))
3361 return (DLADM_STATUS_NOTFOUND);
3362
3363 status = dladm_aggr_info(handle, linkid, &ginfo, state->gs_flags);
3364 if (status != DLADM_STATUS_OK)
3365 return (status);
3366
3367 if (state->gs_lacp)
3368 status = print_aggr_lacp(state, link, &ginfo);
3369 else if (state->gs_extended)
3370 status = print_aggr_extended(state, link, &ginfo);
3371 else if (state->gs_stats)
3372 status = print_aggr_stats(state, link, &ginfo);
3373 else
3374 status = print_aggr_info(state, link, &ginfo);
3375
3376 done:
3377 free(ginfo.lg_ports);
3378 return (status);
3379 }
3380
3381 /* ARGSUSED */
3382 static int
3383 show_aggr(dladm_handle_t dh, datalink_id_t linkid, void *arg)
3384 {
3385 show_grp_state_t *state = arg;
3386
3387 state->gs_status = print_aggr(state, linkid);
3388 return (DLADM_WALK_CONTINUE);
3389 }
3390
3391 static void
3392 do_show_link(int argc, char *argv[], const char *use)
3393 {
3394 int option;
3395 boolean_t s_arg = B_FALSE;
3396 boolean_t i_arg = B_FALSE;
3397 uint32_t flags = DLADM_OPT_ACTIVE;
3398 boolean_t p_arg = B_FALSE;
3399 datalink_id_t linkid = DATALINK_ALL_LINKID;
3400 char linkname[MAXLINKNAMELEN];
3401 uint32_t interval = 0;
3402 show_state_t state;
3403 dladm_status_t status;
3404 boolean_t o_arg = B_FALSE;
3405 char *fields_str = NULL;
3406 char *all_active_fields = "link,class,mtu,state,bridge,over";
3407 char *all_inactive_fields = "link,class,bridge,over";
3408 char *allstat_fields =
3409 "link,ipackets,rbytes,ierrors,opackets,obytes,oerrors";
3410 ofmt_handle_t ofmt;
3411 ofmt_status_t oferr;
3412 uint_t ofmtflags = 0;
3413
3414 bzero(&state, sizeof (state));
3415
3416 opterr = 0;
3417 while ((option = getopt_long(argc, argv, ":pPsi:o:",
3418 show_lopts, NULL)) != -1) {
3419 switch (option) {
3420 case 'p':
3421 if (p_arg)
3422 die_optdup(option);
3423
3424 p_arg = B_TRUE;
3425 break;
3426 case 's':
3427 if (s_arg)
3428 die_optdup(option);
3429
3430 s_arg = B_TRUE;
3431 break;
3432 case 'P':
3433 if (flags != DLADM_OPT_ACTIVE)
3434 die_optdup(option);
3435
3436 flags = DLADM_OPT_PERSIST;
3437 break;
3438 case 'o':
3439 o_arg = B_TRUE;
3440 fields_str = optarg;
3441 break;
3442 case 'i':
3443 if (i_arg)
3444 die_optdup(option);
3445
3446 i_arg = B_TRUE;
3447 if (!dladm_str2interval(optarg, &interval))
3448 die("invalid interval value '%s'", optarg);
3449 break;
3450 default:
3451 die_opterr(optopt, option, use);
3452 break;
3453 }
3454 }
3455
3456 if (i_arg && !s_arg)
3457 die("the option -i can be used only with -s");
3458
3459 if (s_arg && flags != DLADM_OPT_ACTIVE)
3460 die("the option -P cannot be used with -s");
3461
3462 /* get link name (optional last argument) */
3463 if (optind == (argc-1)) {
3464 uint32_t f;
3465
3466 if (strlcpy(linkname, argv[optind], MAXLINKNAMELEN) >=
3467 MAXLINKNAMELEN)
3468 die("link name too long");
3469 if ((status = dladm_name2info(handle, linkname, &linkid, &f,
3470 NULL, NULL)) != DLADM_STATUS_OK) {
3471 die_dlerr(status, "link %s is not valid", linkname);
3472 }
3473
3474 if (!(f & flags)) {
3475 die_dlerr(DLADM_STATUS_BADARG, "link %s is %s",
3476 argv[optind], flags == DLADM_OPT_PERSIST ?
3477 "a temporary link" : "temporarily removed");
3478 }
3479 } else if (optind != argc) {
3480 usage();
3481 }
3482
3483 if (p_arg && !o_arg)
3484 die("-p requires -o");
3485
3486 if (p_arg && strcasecmp(fields_str, "all") == 0)
3487 die("\"-o all\" is invalid with -p");
3488
3489 if (!o_arg || (o_arg && strcasecmp(fields_str, "all") == 0)) {
3490 if (s_arg)
3491 fields_str = allstat_fields;
3492 else if (flags & DLADM_OPT_ACTIVE)
3493 fields_str = all_active_fields;
3494 else
3495 fields_str = all_inactive_fields;
3496 }
3497
3498 state.ls_parsable = p_arg;
3499 state.ls_flags = flags;
3500 state.ls_donefirst = B_FALSE;
3501
3502 if (s_arg) {
3503 link_stats(linkid, interval, fields_str, &state);
3504 return;
3505 }
3506 if (state.ls_parsable)
3507 ofmtflags |= OFMT_PARSABLE;
3508 else
3509 ofmtflags |= OFMT_WRAP;
3510
3511 oferr = ofmt_open(fields_str, link_fields, ofmtflags, 0, &ofmt);
3512 ofmt_check(oferr, state.ls_parsable, ofmt, die, warn);
3513 state.ls_ofmt = ofmt;
3514
3515 if (linkid == DATALINK_ALL_LINKID) {
3516 (void) dladm_walk_datalink_id(show_link, handle, &state,
3517 DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE, flags);
3518 } else {
3519 (void) show_link(handle, linkid, &state);
3520 if (state.ls_status != DLADM_STATUS_OK) {
3521 die_dlerr(state.ls_status, "failed to show link %s",
3522 argv[optind]);
3523 }
3524 }
3525 ofmt_close(ofmt);
3526 }
3527
3528 static void
3529 do_show_aggr(int argc, char *argv[], const char *use)
3530 {
3531 boolean_t L_arg = B_FALSE;
3532 boolean_t s_arg = B_FALSE;
3533 boolean_t i_arg = B_FALSE;
3534 boolean_t p_arg = B_FALSE;
3535 boolean_t x_arg = B_FALSE;
3536 show_grp_state_t state;
3537 uint32_t flags = DLADM_OPT_ACTIVE;
3538 datalink_id_t linkid = DATALINK_ALL_LINKID;
3539 int option;
3540 uint32_t interval = 0;
3541 int key;
3542 dladm_status_t status;
3543 boolean_t o_arg = B_FALSE;
3544 char *fields_str = NULL;
3545 char *all_fields =
3546 "link,policy,addrpolicy,lacpactivity,lacptimer,flags";
3547 char *all_lacp_fields =
3548 "link,port,aggregatable,sync,coll,dist,defaulted,expired";
3549 char *all_stats_fields =
3550 "link,port,ipackets,rbytes,opackets,obytes,ipktdist,opktdist";
3551 char *all_extended_fields =
3552 "link,port,speed,duplex,state,address,portstate";
3553 const ofmt_field_t *pf;
3554 ofmt_handle_t ofmt;
3555 ofmt_status_t oferr;
3556 uint_t ofmtflags = 0;
3557
3558 opterr = 0;
3559 while ((option = getopt_long(argc, argv, ":LpPxsi:o:",
3560 show_lopts, NULL)) != -1) {
3561 switch (option) {
3562 case 'L':
3563 if (L_arg)
3564 die_optdup(option);
3565
3566 L_arg = B_TRUE;
3567 break;
3568 case 'p':
3569 if (p_arg)
3570 die_optdup(option);
3571
3572 p_arg = B_TRUE;
3573 break;
3574 case 'x':
3575 if (x_arg)
3576 die_optdup(option);
3577
3578 x_arg = B_TRUE;
3579 break;
3580 case 'P':
3581 if (flags != DLADM_OPT_ACTIVE)
3582 die_optdup(option);
3583
3584 flags = DLADM_OPT_PERSIST;
3585 break;
3586 case 's':
3587 if (s_arg)
3588 die_optdup(option);
3589
3590 s_arg = B_TRUE;
3591 break;
3592 case 'o':
3593 o_arg = B_TRUE;
3594 fields_str = optarg;
3595 break;
3596 case 'i':
3597 if (i_arg)
3598 die_optdup(option);
3599
3600 i_arg = B_TRUE;
3601 if (!dladm_str2interval(optarg, &interval))
3602 die("invalid interval value '%s'", optarg);
3603 break;
3604 default:
3605 die_opterr(optopt, option, use);
3606 break;
3607 }
3608 }
3609
3610 if (p_arg && !o_arg)
3611 die("-p requires -o");
3612
3613 if (p_arg && strcasecmp(fields_str, "all") == 0)
3614 die("\"-o all\" is invalid with -p");
3615
3616 if (i_arg && !s_arg)
3617 die("the option -i can be used only with -s");
3618
3619 if (s_arg && (L_arg || p_arg || x_arg || flags != DLADM_OPT_ACTIVE)) {
3620 die("the option -%c cannot be used with -s",
3621 L_arg ? 'L' : (p_arg ? 'p' : (x_arg ? 'x' : 'P')));
3622 }
3623
3624 if (L_arg && flags != DLADM_OPT_ACTIVE)
3625 die("the option -P cannot be used with -L");
3626
3627 if (x_arg && (L_arg || flags != DLADM_OPT_ACTIVE))
3628 die("the option -%c cannot be used with -x", L_arg ? 'L' : 'P');
3629
3630 /* get aggregation key or aggrname (optional last argument) */
3631 if (optind == (argc-1)) {
3632 if (!str2int(argv[optind], &key)) {
3633 status = dladm_name2info(handle, argv[optind],
3634 &linkid, NULL, NULL, NULL);
3635 } else {
3636 status = dladm_key2linkid(handle, (uint16_t)key,
3637 &linkid, DLADM_OPT_ACTIVE);
3638 }
3639
3640 if (status != DLADM_STATUS_OK)
3641 die("non-existent aggregation '%s'", argv[optind]);
3642
3643 } else if (optind != argc) {
3644 usage();
3645 }
3646
3647 bzero(&state, sizeof (state));
3648 state.gs_lacp = L_arg;
3649 state.gs_stats = s_arg;
3650 state.gs_flags = flags;
3651 state.gs_parsable = p_arg;
3652 state.gs_extended = x_arg;
3653
3654 if (!o_arg || (o_arg && strcasecmp(fields_str, "all") == 0)) {
3655 if (state.gs_lacp)
3656 fields_str = all_lacp_fields;
3657 else if (state.gs_stats)
3658 fields_str = all_stats_fields;
3659 else if (state.gs_extended)
3660 fields_str = all_extended_fields;
3661 else
3662 fields_str = all_fields;
3663 }
3664
3665 if (state.gs_lacp) {
3666 pf = aggr_l_fields;
3667 } else if (state.gs_stats) {
3668 pf = aggr_s_fields;
3669 } else if (state.gs_extended) {
3670 pf = aggr_x_fields;
3671 } else {
3672 pf = laggr_fields;
3673 }
3674
3675 if (state.gs_parsable)
3676 ofmtflags |= OFMT_PARSABLE;
3677 oferr = ofmt_open(fields_str, pf, ofmtflags, 0, &ofmt);
3678 ofmt_check(oferr, state.gs_parsable, ofmt, die, warn);
3679 state.gs_ofmt = ofmt;
3680
3681 if (s_arg) {
3682 aggr_stats(linkid, &state, interval);
3683 ofmt_close(ofmt);
3684 return;
3685 }
3686
3687 if (linkid == DATALINK_ALL_LINKID) {
3688 (void) dladm_walk_datalink_id(show_aggr, handle, &state,
3689 DATALINK_CLASS_AGGR, DATALINK_ANY_MEDIATYPE, flags);
3690 } else {
3691 (void) show_aggr(handle, linkid, &state);
3692 if (state.gs_status != DLADM_STATUS_OK) {
3693 die_dlerr(state.gs_status, "failed to show aggr %s",
3694 argv[optind]);
3695 }
3696 }
3697 ofmt_close(ofmt);
3698 }
3699
3700 static dladm_status_t
3701 print_phys_default(show_state_t *state, datalink_id_t linkid,
3702 const char *link, uint32_t flags, uint32_t media)
3703 {
3704 dladm_phys_attr_t dpa;
3705 dladm_status_t status;
3706 link_fields_buf_t pattr;
3707
3708 status = dladm_phys_info(handle, linkid, &dpa, state->ls_flags);
3709 if (status != DLADM_STATUS_OK)
3710 goto done;
3711
3712 bzero(&pattr, sizeof (pattr));
3713 (void) snprintf(pattr.link_phys_device,
3714 sizeof (pattr.link_phys_device), "%s", dpa.dp_dev);
3715 (void) dladm_media2str(media, pattr.link_phys_media);
3716 if (state->ls_flags == DLADM_OPT_ACTIVE) {
3717 boolean_t islink;
3718
3719 if (!dpa.dp_novanity) {
3720 (void) strlcpy(pattr.link_name, link,
3721 sizeof (pattr.link_name));
3722 islink = B_TRUE;
3723 } else {
3724 /*
3725 * This is a physical link that does not have
3726 * vanity naming support.
3727 */
3728 (void) strlcpy(pattr.link_name, dpa.dp_dev,
3729 sizeof (pattr.link_name));
3730 islink = B_FALSE;
3731 }
3732
3733 (void) get_linkstate(pattr.link_name, islink,
3734 pattr.link_phys_state);
3735 (void) snprintf(pattr.link_phys_speed,
3736 sizeof (pattr.link_phys_speed), "%u",
3737 (uint_t)((get_ifspeed(pattr.link_name,
3738 islink)) / 1000000ull));
3739 (void) get_linkduplex(pattr.link_name, islink,
3740 pattr.link_phys_duplex);
3741 } else {
3742 (void) snprintf(pattr.link_name, sizeof (pattr.link_name),
3743 "%s", link);
3744 (void) snprintf(pattr.link_flags, sizeof (pattr.link_flags),
3745 "%c----", flags & DLADM_OPT_ACTIVE ? '-' : 'r');
3746 }
3747
3748 ofmt_print(state->ls_ofmt, &pattr);
3749
3750 done:
3751 return (status);
3752 }
3753
3754 typedef struct {
3755 show_state_t *ms_state;
3756 char *ms_link;
3757 dladm_macaddr_attr_t *ms_mac_attr;
3758 } print_phys_mac_state_t;
3759
3760 /*
3761 * callback for ofmt_print()
3762 */
3763 static boolean_t
3764 print_phys_one_mac_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
3765 {
3766 print_phys_mac_state_t *mac_state = ofarg->ofmt_cbarg;
3767 dladm_macaddr_attr_t *attr = mac_state->ms_mac_attr;
3768 boolean_t is_primary = (attr->ma_slot == 0);
3769 boolean_t is_parsable = mac_state->ms_state->ls_parsable;
3770
3771 switch (ofarg->ofmt_id) {
3772 case PHYS_M_LINK:
3773 (void) snprintf(buf, bufsize, "%s",
3774 (is_primary || is_parsable) ? mac_state->ms_link : " ");
3775 break;
3776 case PHYS_M_SLOT:
3777 if (is_primary)
3778 (void) snprintf(buf, bufsize, gettext("primary"));
3779 else
3780 (void) snprintf(buf, bufsize, "%d", attr->ma_slot);
3781 break;
3782 case PHYS_M_ADDRESS:
3783 (void) dladm_aggr_macaddr2str(attr->ma_addr, buf);
3784 break;
3785 case PHYS_M_INUSE:
3786 (void) snprintf(buf, bufsize, "%s",
3787 attr->ma_flags & DLADM_MACADDR_USED ? gettext("yes") :
3788 gettext("no"));
3789 break;
3790 case PHYS_M_CLIENT:
3791 /*
3792 * CR 6678526: resolve link id to actual link name if
3793 * it is valid.
3794 */
3795 (void) snprintf(buf, bufsize, "%s", attr->ma_client_name);
3796 break;
3797 }
3798
3799 return (B_TRUE);
3800 }
3801
3802 typedef struct {
3803 show_state_t *hs_state;
3804 char *hs_link;
3805 dladm_hwgrp_attr_t *hs_grp_attr;
3806 } print_phys_hwgrp_state_t;
3807
3808 static boolean_t
3809 print_phys_one_hwgrp_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
3810 {
3811 int i;
3812 boolean_t first = B_TRUE;
3813 int start = -1;
3814 int end = -1;
3815 char ringstr[RINGSTRLEN];
3816 char ringsubstr[RINGSTRLEN];
3817
3818 print_phys_hwgrp_state_t *hg_state = ofarg->ofmt_cbarg;
3819 dladm_hwgrp_attr_t *attr = hg_state->hs_grp_attr;
3820
3821 switch (ofarg->ofmt_id) {
3822 case PHYS_H_LINK:
3823 (void) snprintf(buf, bufsize, "%s", attr->hg_link_name);
3824 break;
3825 case PHYS_H_RINGTYPE:
3826 (void) snprintf(buf, bufsize, "%s",
3827 attr->hg_grp_type == DLADM_HWGRP_TYPE_RX ? "RX" : "TX");
3828 break;
3829 case PHYS_H_RINGS:
3830 ringstr[0] = '\0';
3831 for (i = 0; i < attr->hg_n_rings; i++) {
3832 uint_t index = attr->hg_rings[i];
3833
3834 if (start == -1) {
3835 start = index;
3836 end = index;
3837 } else if (index == end + 1) {
3838 end = index;
3839 } else {
3840 if (start == end) {
3841 if (first) {
3842 (void) snprintf(
3843 ringsubstr,
3844 RINGSTRLEN, "%d",
3845 start);
3846 first = B_FALSE;
3847 } else {
3848 (void) snprintf(
3849 ringsubstr,
3850 RINGSTRLEN, ",%d",
3851 start);
3852 }
3853 } else {
3854 if (first) {
3855 (void) snprintf(
3856 ringsubstr,
3857 RINGSTRLEN,
3858 "%d-%d",
3859 start, end);
3860 first = B_FALSE;
3861 } else {
3862 (void) snprintf(
3863 ringsubstr,
3864 RINGSTRLEN,
3865 ",%d-%d",
3866 start, end);
3867 }
3868 }
3869 (void) strlcat(ringstr, ringsubstr,
3870 RINGSTRLEN);
3871 start = index;
3872 end = index;
3873 }
3874 }
3875 /* The last one */
3876 if (start != -1) {
3877 if (first) {
3878 if (start == end) {
3879 (void) snprintf(buf, bufsize, "%d",
3880 start);
3881 } else {
3882 (void) snprintf(buf, bufsize, "%d-%d",
3883 start, end);
3884 }
3885 } else {
3886 if (start == end) {
3887 (void) snprintf(ringsubstr, RINGSTRLEN,
3888 ",%d", start);
3889 } else {
3890 (void) snprintf(ringsubstr, RINGSTRLEN,
3891 ",%d-%d", start, end);
3892 }
3893 (void) strlcat(ringstr, ringsubstr, RINGSTRLEN);
3894 (void) snprintf(buf, bufsize, "%s", ringstr);
3895 }
3896 }
3897 break;
3898 case PHYS_H_CLIENTS:
3899 if (attr->hg_client_names[0] == '\0') {
3900 (void) snprintf(buf, bufsize, "--");
3901 } else {
3902 (void) snprintf(buf, bufsize, "%s ",
3903 attr->hg_client_names);
3904 }
3905 break;
3906 }
3907
3908 return (B_TRUE);
3909 }
3910
3911 /*
3912 * callback for dladm_walk_macaddr, invoked for each MAC address slot
3913 */
3914 static boolean_t
3915 print_phys_mac_callback(void *arg, dladm_macaddr_attr_t *attr)
3916 {
3917 print_phys_mac_state_t *mac_state = arg;
3918 show_state_t *state = mac_state->ms_state;
3919
3920 mac_state->ms_mac_attr = attr;
3921 ofmt_print(state->ls_ofmt, mac_state);
3922
3923 return (B_TRUE);
3924 }
3925
3926 /*
3927 * invoked by show-phys -m for each physical data-link
3928 */
3929 static dladm_status_t
3930 print_phys_mac(show_state_t *state, datalink_id_t linkid, char *link)
3931 {
3932 print_phys_mac_state_t mac_state;
3933
3934 mac_state.ms_state = state;
3935 mac_state.ms_link = link;
3936
3937 return (dladm_walk_macaddr(handle, linkid, &mac_state,
3938 print_phys_mac_callback));
3939 }
3940
3941 /*
3942 * callback for dladm_walk_hwgrp, invoked for each MAC hwgrp
3943 */
3944 static boolean_t
3945 print_phys_hwgrp_callback(void *arg, dladm_hwgrp_attr_t *attr)
3946 {
3947 print_phys_hwgrp_state_t *hwgrp_state = arg;
3948 show_state_t *state = hwgrp_state->hs_state;
3949
3950 hwgrp_state->hs_grp_attr = attr;
3951 ofmt_print(state->ls_ofmt, hwgrp_state);
3952
3953 return (B_TRUE);
3954 }
3955
3956 /* invoked by show-phys -H for each physical data-link */
3957 static dladm_status_t
3958 print_phys_hwgrp(show_state_t *state, datalink_id_t linkid, char *link)
3959 {
3960 print_phys_hwgrp_state_t hwgrp_state;
3961
3962 hwgrp_state.hs_state = state;
3963 hwgrp_state.hs_link = link;
3964 return (dladm_walk_hwgrp(handle, linkid, &hwgrp_state,
3965 print_phys_hwgrp_callback));
3966 }
3967
3968 /*
3969 * Parse the "local=<laddr>,remote=<raddr>" sub-options for the -a option of
3970 * *-iptun subcommands.
3971 */
3972 static void
3973 iptun_process_addrarg(char *addrarg, iptun_params_t *params)
3974 {
3975 char *addrval;
3976
3977 while (*addrarg != '\0') {
3978 switch (getsubopt(&addrarg, iptun_addropts, &addrval)) {
3979 case IPTUN_LOCAL:
3980 if (addrval == NULL)
3981 die("tunnel source address value is missing");
3982 params->iptun_param_flags |= IPTUN_PARAM_LADDR;
3983 if (strlcpy(params->iptun_param_laddr, addrval,
3984 sizeof (params->iptun_param_laddr)) >=
3985 sizeof (params->iptun_param_laddr))
3986 die("tunnel source address is too long");
3987 break;
3988 case IPTUN_REMOTE:
3989 if (addrval == NULL)
3990 die("tunnel destination address value "
3991 "is missing");
3992 params->iptun_param_flags |= IPTUN_PARAM_RADDR;
3993 if (strlcpy(params->iptun_param_raddr, addrval,
3994 sizeof (params->iptun_param_raddr)) >=
3995 sizeof (params->iptun_param_raddr))
3996 die("tunnel destination address is too long");
3997 break;
3998 default:
3999 die("invalid address type: %s", addrval);
4000 break;
4001 }
4002 }
4003 }
4004
4005 /*
4006 * Convenience routine to process iptun-create/modify/delete subcommand
4007 * arguments.
4008 */
4009 static void
4010 iptun_process_args(int argc, char *argv[], const char *opts,
4011 iptun_params_t *params, uint32_t *flags, char *name, const char *use)
4012 {
4013 int option;
4014 char *altroot = NULL;
4015
4016 if (params != NULL)
4017 bzero(params, sizeof (*params));
4018 *flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
4019
4020 opterr = 0;
4021 while ((option = getopt_long(argc, argv, opts, iptun_lopts, NULL)) !=
4022 -1) {
4023 switch (option) {
4024 case 'a':
4025 iptun_process_addrarg(optarg, params);
4026 break;
4027 case 'R':
4028 altroot = optarg;
4029 break;
4030 case 't':
4031 *flags &= ~DLADM_OPT_PERSIST;
4032 break;
4033 case 'T':
4034 params->iptun_param_type = iptun_gettypebyname(optarg);
4035 if (params->iptun_param_type == IPTUN_TYPE_UNKNOWN)
4036 die("unknown tunnel type: %s", optarg);
4037 params->iptun_param_flags |= IPTUN_PARAM_TYPE;
4038 break;
4039 default:
4040 die_opterr(optopt, option, use);
4041 break;
4042 }
4043 }
4044
4045 /* Get the required tunnel name argument. */
4046 if (argc - optind != 1)
4047 usage();
4048
4049 if (strlcpy(name, argv[optind], MAXLINKNAMELEN) >= MAXLINKNAMELEN)
4050 die("tunnel name is too long");
4051
4052 if (altroot != NULL)
4053 altroot_cmd(altroot, argc, argv);
4054 }
4055
4056 static void
4057 do_create_iptun(int argc, char *argv[], const char *use)
4058 {
4059 iptun_params_t params;
4060 dladm_status_t status;
4061 uint32_t flags;
4062 char name[MAXLINKNAMELEN];
4063
4064 iptun_process_args(argc, argv, ":a:R:tT:", &params, &flags, name,
4065 use);
4066
4067 status = dladm_iptun_create(handle, name, &params, flags);
4068 if (status != DLADM_STATUS_OK)
4069 die_dlerr(status, "could not create tunnel");
4070 }
4071
4072 static void
4073 do_delete_iptun(int argc, char *argv[], const char *use)
4074 {
4075 uint32_t flags;
4076 datalink_id_t linkid;
4077 dladm_status_t status;
4078 char name[MAXLINKNAMELEN];
4079
4080 iptun_process_args(argc, argv, ":R:t", NULL, &flags, name, use);
4081
4082 status = dladm_name2info(handle, name, &linkid, NULL, NULL, NULL);
4083 if (status != DLADM_STATUS_OK)
4084 die_dlerr(status, "could not delete tunnel");
4085 status = dladm_iptun_delete(handle, linkid, flags);
4086 if (status != DLADM_STATUS_OK)
4087 die_dlerr(status, "could not delete tunnel");
4088 }
4089
4090 static void
4091 do_modify_iptun(int argc, char *argv[], const char *use)
4092 {
4093 iptun_params_t params;
4094 uint32_t flags;
4095 dladm_status_t status;
4096 char name[MAXLINKNAMELEN];
4097
4098 iptun_process_args(argc, argv, ":a:R:t", &params, &flags, name, use);
4099
4100 if ((status = dladm_name2info(handle, name, &params.iptun_param_linkid,
4101 NULL, NULL, NULL)) != DLADM_STATUS_OK)
4102 die_dlerr(status, "could not modify tunnel");
4103 status = dladm_iptun_modify(handle, &params, flags);
4104 if (status != DLADM_STATUS_OK)
4105 die_dlerr(status, "could not modify tunnel");
4106 }
4107
4108 static void
4109 do_show_iptun(int argc, char *argv[], const char *use)
4110 {
4111 char option;
4112 datalink_id_t linkid;
4113 uint32_t flags = DLADM_OPT_ACTIVE;
4114 char *name = NULL;
4115 dladm_status_t status;
4116 const char *fields_str = NULL;
4117 show_state_t state;
4118 ofmt_handle_t ofmt;
4119 ofmt_status_t oferr;
4120 uint_t ofmtflags = 0;
4121
4122 bzero(&state, sizeof (state));
4123 opterr = 0;
4124 while ((option = getopt_long(argc, argv, ":pPo:",
4125 iptun_lopts, NULL)) != -1) {
4126 switch (option) {
4127 case 'o':
4128 fields_str = optarg;
4129 break;
4130 case 'p':
4131 state.ls_parsable = B_TRUE;
4132 ofmtflags = OFMT_PARSABLE;
4133 break;
4134 case 'P':
4135 flags = DLADM_OPT_PERSIST;
4136 break;
4137 default:
4138 die_opterr(optopt, option, use);
4139 break;
4140 }
4141 }
4142
4143 /*
4144 * Get the optional tunnel name argument. If there is one, it must
4145 * be the last thing remaining on the command-line.
4146 */
4147 if (argc - optind > 1)
4148 die(gettext(use));
4149 if (argc - optind == 1)
4150 name = argv[optind];
4151
4152 oferr = ofmt_open(fields_str, iptun_fields, ofmtflags,
4153 DLADM_DEFAULT_COL, &ofmt);
4154 ofmt_check(oferr, state.ls_parsable, ofmt, die, warn);
4155
4156 state.ls_ofmt = ofmt;
4157 state.ls_flags = flags;
4158
4159 if (name == NULL) {
4160 (void) dladm_walk_datalink_id(print_iptun_walker, handle,
4161 &state, DATALINK_CLASS_IPTUN, DATALINK_ANY_MEDIATYPE,
4162 flags);
4163 status = state.ls_status;
4164 } else {
4165 if ((status = dladm_name2info(handle, name, &linkid, NULL, NULL,
4166 NULL)) == DLADM_STATUS_OK)
4167 status = print_iptun(handle, linkid, &state);
4168 }
4169
4170 if (status != DLADM_STATUS_OK)
4171 die_dlerr(status, "unable to obtain tunnel status");
4172 }
4173
4174 /* ARGSUSED */
4175 static void
4176 do_up_iptun(int argc, char *argv[], const char *use)
4177 {
4178 datalink_id_t linkid = DATALINK_ALL_LINKID;
4179 dladm_status_t status = DLADM_STATUS_OK;
4180
4181 /*
4182 * Get the optional tunnel name argument. If there is one, it must
4183 * be the last thing remaining on the command-line.
4184 */
4185 if (argc - optind > 1)
4186 usage();
4187 if (argc - optind == 1) {
4188 status = dladm_name2info(handle, argv[optind], &linkid, NULL,
4189 NULL, NULL);
4190 }
4191 if (status == DLADM_STATUS_OK)
4192 status = dladm_iptun_up(handle, linkid);
4193 if (status != DLADM_STATUS_OK)
4194 die_dlerr(status, "unable to configure IP tunnel links");
4195 }
4196
4197 /* ARGSUSED */
4198 static void
4199 do_down_iptun(int argc, char *argv[], const char *use)
4200 {
4201 datalink_id_t linkid = DATALINK_ALL_LINKID;
4202 dladm_status_t status = DLADM_STATUS_OK;
4203
4204 /*
4205 * Get the optional tunnel name argument. If there is one, it must
4206 * be the last thing remaining on the command-line.
4207 */
4208 if (argc - optind > 1)
4209 usage();
4210 if (argc - optind == 1) {
4211 status = dladm_name2info(handle, argv[optind], &linkid, NULL,
4212 NULL, NULL);
4213 }
4214 if (status == DLADM_STATUS_OK)
4215 status = dladm_iptun_down(handle, linkid);
4216 if (status != DLADM_STATUS_OK)
4217 die_dlerr(status, "unable to bring down IP tunnel links");
4218 }
4219
4220 static iptun_type_t
4221 iptun_gettypebyname(char *typestr)
4222 {
4223 int i;
4224
4225 for (i = 0; iptun_types[i].type_name != NULL; i++) {
4226 if (strncmp(iptun_types[i].type_name, typestr,
4227 strlen(iptun_types[i].type_name)) == 0) {
4228 return (iptun_types[i].type_value);
4229 }
4230 }
4231 return (IPTUN_TYPE_UNKNOWN);
4232 }
4233
4234 static const char *
4235 iptun_gettypebyvalue(iptun_type_t type)
4236 {
4237 int i;
4238
4239 for (i = 0; iptun_types[i].type_name != NULL; i++) {
4240 if (iptun_types[i].type_value == type)
4241 return (iptun_types[i].type_name);
4242 }
4243 return (NULL);
4244 }
4245
4246 static dladm_status_t
4247 print_iptun(dladm_handle_t dh, datalink_id_t linkid, show_state_t *state)
4248 {
4249 dladm_status_t status;
4250 iptun_params_t params;
4251 iptun_fields_buf_t lbuf;
4252 const char *laddr;
4253 const char *raddr;
4254
4255 params.iptun_param_linkid = linkid;
4256 status = dladm_iptun_getparams(dh, &params, state->ls_flags);
4257 if (status != DLADM_STATUS_OK)
4258 return (status);
4259
4260 /* LINK */
4261 status = dladm_datalink_id2info(dh, linkid, NULL, NULL, NULL,
4262 lbuf.iptun_name, sizeof (lbuf.iptun_name));
4263 if (status != DLADM_STATUS_OK)
4264 return (status);
4265
4266 /* TYPE */
4267 (void) strlcpy(lbuf.iptun_type,
4268 iptun_gettypebyvalue(params.iptun_param_type),
4269 sizeof (lbuf.iptun_type));
4270
4271 /* FLAGS */
4272 (void) memset(lbuf.iptun_flags, '-', IPTUN_NUM_FLAGS);
4273 lbuf.iptun_flags[IPTUN_NUM_FLAGS] = '\0';
4274 if (params.iptun_param_flags & IPTUN_PARAM_IPSECPOL)
4275 lbuf.iptun_flags[IPTUN_SFLAG_INDEX] = 's';
4276 if (params.iptun_param_flags & IPTUN_PARAM_IMPLICIT)
4277 lbuf.iptun_flags[IPTUN_IFLAG_INDEX] = 'i';
4278
4279 /* LOCAL */
4280 if (params.iptun_param_flags & IPTUN_PARAM_LADDR)
4281 laddr = params.iptun_param_laddr;
4282 else
4283 laddr = (state->ls_parsable) ? "" : "--";
4284 (void) strlcpy(lbuf.iptun_laddr, laddr, sizeof (lbuf.iptun_laddr));
4285
4286 /* REMOTE */
4287 if (params.iptun_param_flags & IPTUN_PARAM_RADDR)
4288 raddr = params.iptun_param_raddr;
4289 else
4290 raddr = (state->ls_parsable) ? "" : "--";
4291 (void) strlcpy(lbuf.iptun_raddr, raddr, sizeof (lbuf.iptun_raddr));
4292
4293 ofmt_print(state->ls_ofmt, &lbuf);
4294
4295 return (DLADM_STATUS_OK);
4296 }
4297
4298 static int
4299 print_iptun_walker(dladm_handle_t dh, datalink_id_t linkid, void *arg)
4300 {
4301 ((show_state_t *)arg)->ls_status = print_iptun(dh, linkid, arg);
4302 return (DLADM_WALK_CONTINUE);
4303 }
4304
4305 static dladm_status_t
4306 print_phys(show_state_t *state, datalink_id_t linkid)
4307 {
4308 char link[MAXLINKNAMELEN];
4309 uint32_t flags;
4310 dladm_status_t status;
4311 datalink_class_t class;
4312 uint32_t media;
4313
4314 if ((status = dladm_datalink_id2info(handle, linkid, &flags, &class,
4315 &media, link, MAXLINKNAMELEN)) != DLADM_STATUS_OK) {
4316 goto done;
4317 }
4318
4319 if (class != DATALINK_CLASS_PHYS) {
4320 status = DLADM_STATUS_BADARG;
4321 goto done;
4322 }
4323
4324 if (!(state->ls_flags & flags)) {
4325 status = DLADM_STATUS_NOTFOUND;
4326 goto done;
4327 }
4328
4329 if (state->ls_mac)
4330 status = print_phys_mac(state, linkid, link);
4331 else if (state->ls_hwgrp)
4332 status = print_phys_hwgrp(state, linkid, link);
4333 else
4334 status = print_phys_default(state, linkid, link, flags, media);
4335
4336 done:
4337 return (status);
4338 }
4339
4340 /* ARGSUSED */
4341 static int
4342 show_phys(dladm_handle_t dh, datalink_id_t linkid, void *arg)
4343 {
4344 show_state_t *state = arg;
4345
4346 state->ls_status = print_phys(state, linkid);
4347 return (DLADM_WALK_CONTINUE);
4348 }
4349
4350 /*
4351 * Print the active topology information.
4352 */
4353 static dladm_status_t
4354 print_vlan(show_state_t *state, datalink_id_t linkid, link_fields_buf_t *l)
4355 {
4356 dladm_vlan_attr_t vinfo;
4357 uint32_t flags;
4358 dladm_status_t status;
4359
4360 if ((status = dladm_datalink_id2info(handle, linkid, &flags, NULL, NULL,
4361 l->link_name, sizeof (l->link_name))) != DLADM_STATUS_OK) {
4362 goto done;
4363 }
4364
4365 if (!(state->ls_flags & flags)) {
4366 status = DLADM_STATUS_NOTFOUND;
4367 goto done;
4368 }
4369
4370 if ((status = dladm_vlan_info(handle, linkid, &vinfo,
4371 state->ls_flags)) != DLADM_STATUS_OK ||
4372 (status = dladm_datalink_id2info(handle, vinfo.dv_linkid, NULL,
4373 NULL, NULL, l->link_over, sizeof (l->link_over))) !=
4374 DLADM_STATUS_OK) {
4375 goto done;
4376 }
4377
4378 (void) snprintf(l->link_vlan_vid, sizeof (l->link_vlan_vid), "%d",
4379 vinfo.dv_vid);
4380 (void) snprintf(l->link_flags, sizeof (l->link_flags), "%c----",
4381 vinfo.dv_force ? 'f' : '-');
4382
4383 done:
4384 return (status);
4385 }
4386
4387 /* ARGSUSED */
4388 static int
4389 show_vlan(dladm_handle_t dh, datalink_id_t linkid, void *arg)
4390 {
4391 show_state_t *state = arg;
4392 dladm_status_t status;
4393 link_fields_buf_t lbuf;
4394
4395 bzero(&lbuf, sizeof (link_fields_buf_t));
4396 status = print_vlan(state, linkid, &lbuf);
4397 if (status != DLADM_STATUS_OK)
4398 goto done;
4399
4400 ofmt_print(state->ls_ofmt, &lbuf);
4401
4402 done:
4403 state->ls_status = status;
4404 return (DLADM_WALK_CONTINUE);
4405 }
4406
4407 static void
4408 do_show_phys(int argc, char *argv[], const char *use)
4409 {
4410 int option;
4411 uint32_t flags = DLADM_OPT_ACTIVE;
4412 boolean_t p_arg = B_FALSE;
4413 boolean_t o_arg = B_FALSE;
4414 boolean_t m_arg = B_FALSE;
4415 boolean_t H_arg = B_FALSE;
4416 datalink_id_t linkid = DATALINK_ALL_LINKID;
4417 show_state_t state;
4418 dladm_status_t status;
4419 char *fields_str = NULL;
4420 char *all_active_fields =
4421 "link,media,state,speed,duplex,device";
4422 char *all_inactive_fields = "link,device,media,flags";
4423 char *all_mac_fields = "link,slot,address,inuse,client";
4424 char *all_hwgrp_fields = "link,ringtype,rings,clients";
4425 const ofmt_field_t *pf;
4426 ofmt_handle_t ofmt;
4427 ofmt_status_t oferr;
4428 uint_t ofmtflags = 0;
4429
4430 bzero(&state, sizeof (state));
4431 opterr = 0;
4432 while ((option = getopt_long(argc, argv, ":pPo:mH",
4433 show_lopts, NULL)) != -1) {
4434 switch (option) {
4435 case 'p':
4436 if (p_arg)
4437 die_optdup(option);
4438
4439 p_arg = B_TRUE;
4440 break;
4441 case 'P':
4442 if (flags != DLADM_OPT_ACTIVE)
4443 die_optdup(option);
4444
4445 flags = DLADM_OPT_PERSIST;
4446 break;
4447 case 'o':
4448 o_arg = B_TRUE;
4449 fields_str = optarg;
4450 break;
4451 case 'm':
4452 m_arg = B_TRUE;
4453 break;
4454 case 'H':
4455 H_arg = B_TRUE;
4456 break;
4457 default:
4458 die_opterr(optopt, option, use);
4459 break;
4460 }
4461 }
4462
4463 if (p_arg && !o_arg)
4464 die("-p requires -o");
4465
4466 if (m_arg && H_arg)
4467 die("-m cannot combine with -H");
4468
4469 if (p_arg && strcasecmp(fields_str, "all") == 0)
4470 die("\"-o all\" is invalid with -p");
4471
4472 /* get link name (optional last argument) */
4473 if (optind == (argc-1)) {
4474 if ((status = dladm_name2info(handle, argv[optind], &linkid,
4475 NULL, NULL, NULL)) != DLADM_STATUS_OK) {
4476 die_dlerr(status, "link %s is not valid", argv[optind]);
4477 }
4478 } else if (optind != argc) {
4479 usage();
4480 }
4481
4482 state.ls_parsable = p_arg;
4483 state.ls_flags = flags;
4484 state.ls_donefirst = B_FALSE;
4485 state.ls_mac = m_arg;
4486 state.ls_hwgrp = H_arg;
4487
4488 if (m_arg && !(flags & DLADM_OPT_ACTIVE)) {
4489 /*
4490 * We can only display the factory MAC addresses of
4491 * active data-links.
4492 */
4493 die("-m not compatible with -P");
4494 }
4495
4496 if (!o_arg || (o_arg && strcasecmp(fields_str, "all") == 0)) {
4497 if (state.ls_mac)
4498 fields_str = all_mac_fields;
4499 else if (state.ls_hwgrp)
4500 fields_str = all_hwgrp_fields;
4501 else if (state.ls_flags & DLADM_OPT_ACTIVE) {
4502 fields_str = all_active_fields;
4503 } else {
4504 fields_str = all_inactive_fields;
4505 }
4506 }
4507
4508 if (state.ls_mac) {
4509 pf = phys_m_fields;
4510 } else if (state.ls_hwgrp) {
4511 pf = phys_h_fields;
4512 } else {
4513 pf = phys_fields;
4514 }
4515
4516 if (state.ls_parsable)
4517 ofmtflags |= OFMT_PARSABLE;
4518 oferr = ofmt_open(fields_str, pf, ofmtflags, 0, &ofmt);
4519 ofmt_check(oferr, state.ls_parsable, ofmt, die, warn);
4520 state.ls_ofmt = ofmt;
4521
4522 if (linkid == DATALINK_ALL_LINKID) {
4523 (void) dladm_walk_datalink_id(show_phys, handle, &state,
4524 DATALINK_CLASS_PHYS, DATALINK_ANY_MEDIATYPE, flags);
4525 } else {
4526 (void) show_phys(handle, linkid, &state);
4527 if (state.ls_status != DLADM_STATUS_OK) {
4528 die_dlerr(state.ls_status,
4529 "failed to show physical link %s", argv[optind]);
4530 }
4531 }
4532 ofmt_close(ofmt);
4533 }
4534
4535 static void
4536 do_show_vlan(int argc, char *argv[], const char *use)
4537 {
4538 int option;
4539 uint32_t flags = DLADM_OPT_ACTIVE;
4540 boolean_t p_arg = B_FALSE;
4541 datalink_id_t linkid = DATALINK_ALL_LINKID;
4542 show_state_t state;
4543 dladm_status_t status;
4544 boolean_t o_arg = B_FALSE;
4545 char *fields_str = NULL;
4546 ofmt_handle_t ofmt;
4547 ofmt_status_t oferr;
4548 uint_t ofmtflags = 0;
4549
4550 bzero(&state, sizeof (state));
4551
4552 opterr = 0;
4553 while ((option = getopt_long(argc, argv, ":pPo:",
4554 show_lopts, NULL)) != -1) {
4555 switch (option) {
4556 case 'p':
4557 if (p_arg)
4558 die_optdup(option);
4559
4560 p_arg = B_TRUE;
4561 break;
4562 case 'P':
4563 if (flags != DLADM_OPT_ACTIVE)
4564 die_optdup(option);
4565
4566 flags = DLADM_OPT_PERSIST;
4567 break;
4568 case 'o':
4569 o_arg = B_TRUE;
4570 fields_str = optarg;
4571 break;
4572 default:
4573 die_opterr(optopt, option, use);
4574 break;
4575 }
4576 }
4577
4578 /* get link name (optional last argument) */
4579 if (optind == (argc-1)) {
4580 if ((status = dladm_name2info(handle, argv[optind], &linkid,
4581 NULL, NULL, NULL)) != DLADM_STATUS_OK) {
4582 die_dlerr(status, "link %s is not valid", argv[optind]);
4583 }
4584 } else if (optind != argc) {
4585 usage();
4586 }
4587
4588 state.ls_parsable = p_arg;
4589 state.ls_flags = flags;
4590 state.ls_donefirst = B_FALSE;
4591
4592 if (!o_arg || (o_arg && strcasecmp(fields_str, "all") == 0))
4593 fields_str = NULL;
4594
4595 if (state.ls_parsable)
4596 ofmtflags |= OFMT_PARSABLE;
4597 oferr = ofmt_open(fields_str, vlan_fields, ofmtflags, 0, &ofmt);
4598 ofmt_check(oferr, state.ls_parsable, ofmt, die, warn);
4599 state.ls_ofmt = ofmt;
4600
4601 if (linkid == DATALINK_ALL_LINKID) {
4602 (void) dladm_walk_datalink_id(show_vlan, handle, &state,
4603 DATALINK_CLASS_VLAN, DATALINK_ANY_MEDIATYPE, flags);
4604 } else {
4605 (void) show_vlan(handle, linkid, &state);
4606 if (state.ls_status != DLADM_STATUS_OK) {
4607 die_dlerr(state.ls_status, "failed to show vlan %s",
4608 argv[optind]);
4609 }
4610 }
4611 ofmt_close(ofmt);
4612 }
4613
4614 static void
4615 do_create_vnic(int argc, char *argv[], const char *use)
4616 {
4617 datalink_id_t linkid, dev_linkid;
4618 char devname[MAXLINKNAMELEN];
4619 char name[MAXLINKNAMELEN];
4620 boolean_t l_arg = B_FALSE;
4621 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
4622 char *altroot = NULL;
4623 int option;
4624 char *endp = NULL;
4625 dladm_status_t status;
4626 vnic_mac_addr_type_t mac_addr_type = VNIC_MAC_ADDR_TYPE_UNKNOWN;
4627 uchar_t *mac_addr = NULL;
4628 int mac_slot = -1;
4629 uint_t maclen = 0, mac_prefix_len = 0;
4630 char propstr[DLADM_STRSIZE];
4631 dladm_arg_list_t *proplist = NULL;
4632 int vid = 0;
4633 int af = AF_UNSPEC;
4634 vrid_t vrid = VRRP_VRID_NONE;
4635
4636 opterr = 0;
4637 bzero(propstr, DLADM_STRSIZE);
4638
4639 while ((option = getopt_long(argc, argv, ":tfR:l:m:n:p:r:v:V:A:H",
4640 vnic_lopts, NULL)) != -1) {
4641 switch (option) {
4642 case 't':
4643 flags &= ~DLADM_OPT_PERSIST;
4644 break;
4645 case 'R':
4646 altroot = optarg;
4647 break;
4648 case 'l':
4649 if (strlcpy(devname, optarg, MAXLINKNAMELEN) >=
4650 MAXLINKNAMELEN)
4651 die("link name too long");
4652 l_arg = B_TRUE;
4653 break;
4654 case 'm':
4655 if (mac_addr_type != VNIC_MAC_ADDR_TYPE_UNKNOWN)
4656 die("cannot specify -m option twice");
4657
4658 if (strcmp(optarg, "fixed") == 0) {
4659 /*
4660 * A fixed MAC address must be specified
4661 * by its value, not by the keyword 'fixed'.
4662 */
4663 die("'fixed' is not a valid MAC address");
4664 }
4665 if (dladm_vnic_str2macaddrtype(optarg,
4666 &mac_addr_type) != DLADM_STATUS_OK) {
4667 mac_addr_type = VNIC_MAC_ADDR_TYPE_FIXED;
4668 /* MAC address specified by value */
4669 mac_addr = _link_aton(optarg, (int *)&maclen);
4670 if (mac_addr == NULL) {
4671 if (maclen == (uint_t)-1)
4672 die("invalid MAC address");
4673 else
4674 die("out of memory");
4675 }
4676 }
4677 break;
4678 case 'n':
4679 errno = 0;
4680 mac_slot = (int)strtol(optarg, &endp, 10);
4681 if (errno != 0 || *endp != '\0')
4682 die("invalid slot number");
4683 break;
4684 case 'p':
4685 (void) strlcat(propstr, optarg, DLADM_STRSIZE);
4686 if (strlcat(propstr, ",", DLADM_STRSIZE) >=
4687 DLADM_STRSIZE)
4688 die("property list too long '%s'", propstr);
4689 break;
4690 case 'r':
4691 mac_addr = _link_aton(optarg, (int *)&mac_prefix_len);
4692 if (mac_addr == NULL) {
4693 if (mac_prefix_len == (uint_t)-1)
4694 die("invalid MAC address");
4695 else
4696 die("out of memory");
4697 }
4698 break;
4699 case 'V':
4700 if (!str2int(optarg, (int *)&vrid) ||
4701 vrid < VRRP_VRID_MIN || vrid > VRRP_VRID_MAX) {
4702 die("invalid VRRP identifier '%s'", optarg);
4703 }
4704
4705 break;
4706 case 'A':
4707 if (strcmp(optarg, "inet") == 0)
4708 af = AF_INET;
4709 else if (strcmp(optarg, "inet6") == 0)
4710 af = AF_INET6;
4711 else
4712 die("invalid address family '%s'", optarg);
4713 break;
4714 case 'v':
4715 if (vid != 0)
4716 die_optdup(option);
4717
4718 if (!str2int(optarg, &vid) || vid < 1 || vid > 4094)
4719 die("invalid VLAN identifier '%s'", optarg);
4720
4721 break;
4722 case 'f':
4723 flags |= DLADM_OPT_FORCE;
4724 break;
4725 default:
4726 die_opterr(optopt, option, use);
4727 }
4728 }
4729
4730 if (mac_addr_type == VNIC_MAC_ADDR_TYPE_UNKNOWN)
4731 mac_addr_type = VNIC_MAC_ADDR_TYPE_AUTO;
4732
4733 /*
4734 * 'f' - force, flag can be specified only with 'v' - vlan.
4735 */
4736 if ((flags & DLADM_OPT_FORCE) != 0 && vid == 0)
4737 die("-f option can only be used with -v");
4738
4739 if (mac_prefix_len != 0 && mac_addr_type != VNIC_MAC_ADDR_TYPE_RANDOM &&
4740 mac_addr_type != VNIC_MAC_ADDR_TYPE_FIXED)
4741 usage();
4742
4743 if (mac_addr_type == VNIC_MAC_ADDR_TYPE_VRID) {
4744 if (vrid == VRRP_VRID_NONE || af == AF_UNSPEC ||
4745 mac_addr != NULL || maclen != 0 || mac_slot != -1 ||
4746 mac_prefix_len != 0) {
4747 usage();
4748 }
4749 } else if ((af != AF_UNSPEC || vrid != VRRP_VRID_NONE)) {
4750 usage();
4751 }
4752
4753 /* check required options */
4754 if (!l_arg)
4755 usage();
4756
4757 if (mac_slot != -1 && mac_addr_type != VNIC_MAC_ADDR_TYPE_FACTORY)
4758 usage();
4759
4760 /* the VNIC id is the required operand */
4761 if (optind != (argc - 1))
4762 usage();
4763
4764 if (strlcpy(name, argv[optind], MAXLINKNAMELEN) >= MAXLINKNAMELEN)
4765 die("link name too long '%s'", argv[optind]);
4766
4767 if (!dladm_valid_linkname(name))
4768 die("invalid link name '%s'", argv[optind]);
4769
4770 if (altroot != NULL)
4771 altroot_cmd(altroot, argc, argv);
4772
4773 if (dladm_name2info(handle, devname, &dev_linkid, NULL, NULL, NULL) !=
4774 DLADM_STATUS_OK)
4775 die("invalid link name '%s'", devname);
4776
4777 if (dladm_parse_link_props(propstr, &proplist, B_FALSE)
4778 != DLADM_STATUS_OK)
4779 die("invalid vnic property");
4780
4781 status = dladm_vnic_create(handle, name, dev_linkid, mac_addr_type,
4782 mac_addr, maclen, &mac_slot, mac_prefix_len, vid, vrid, af,
4783 &linkid, proplist, flags);
4784 switch (status) {
4785 case DLADM_STATUS_OK:
4786 break;
4787
4788 case DLADM_STATUS_LINKBUSY:
4789 die("VLAN over '%s' may not use default_tag ID "
4790 "(see dladm(8))", devname);
4791 break;
4792
4793 default:
4794 die_dlerr(status, "vnic creation over %s failed", devname);
4795 }
4796
4797 dladm_free_props(proplist);
4798 free(mac_addr);
4799 }
4800
4801 static void
4802 do_etherstub_check(const char *name, datalink_id_t linkid, boolean_t etherstub,
4803 uint32_t flags)
4804 {
4805 boolean_t is_etherstub;
4806 dladm_vnic_attr_t attr;
4807
4808 if (dladm_vnic_info(handle, linkid, &attr, flags) != DLADM_STATUS_OK) {
4809 /*
4810 * Let the delete continue anyway.
4811 */
4812 return;
4813 }
4814 is_etherstub = (attr.va_link_id == DATALINK_INVALID_LINKID);
4815 if (is_etherstub != etherstub) {
4816 die("'%s' is not %s", name,
4817 (is_etherstub ? "a vnic" : "an etherstub"));
4818 }
4819 }
4820
4821 static void
4822 do_delete_vnic_common(int argc, char *argv[], const char *use,
4823 boolean_t etherstub)
4824 {
4825 int option;
4826 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
4827 datalink_id_t linkid;
4828 char *altroot = NULL;
4829 dladm_status_t status;
4830
4831 opterr = 0;
4832 while ((option = getopt_long(argc, argv, ":R:t", lopts,
4833 NULL)) != -1) {
4834 switch (option) {
4835 case 't':
4836 flags &= ~DLADM_OPT_PERSIST;
4837 break;
4838 case 'R':
4839 altroot = optarg;
4840 break;
4841 default:
4842 die_opterr(optopt, option, use);
4843 }
4844 }
4845
4846 /* get vnic name (required last argument) */
4847 if (optind != (argc - 1))
4848 usage();
4849
4850 if (altroot != NULL)
4851 altroot_cmd(altroot, argc, argv);
4852
4853 status = dladm_name2info(handle, argv[optind], &linkid, NULL, NULL,
4854 NULL);
4855 if (status != DLADM_STATUS_OK)
4856 die("invalid link name '%s'", argv[optind]);
4857
4858 if ((flags & DLADM_OPT_ACTIVE) != 0) {
4859 do_etherstub_check(argv[optind], linkid, etherstub,
4860 DLADM_OPT_ACTIVE);
4861 }
4862 if ((flags & DLADM_OPT_PERSIST) != 0) {
4863 do_etherstub_check(argv[optind], linkid, etherstub,
4864 DLADM_OPT_PERSIST);
4865 }
4866
4867 status = dladm_vnic_delete(handle, linkid, flags);
4868 if (status != DLADM_STATUS_OK)
4869 die_dlerr(status, "vnic deletion failed");
4870 }
4871
4872 static void
4873 do_delete_vnic(int argc, char *argv[], const char *use)
4874 {
4875 do_delete_vnic_common(argc, argv, use, B_FALSE);
4876 }
4877
4878 /* ARGSUSED */
4879 static void
4880 do_up_vnic_common(int argc, char *argv[], const char *use, boolean_t vlan)
4881 {
4882 datalink_id_t linkid = DATALINK_ALL_LINKID;
4883 dladm_status_t status;
4884 char *type;
4885
4886 type = vlan ? "vlan" : "vnic";
4887
4888 /*
4889 * get the id or the name of the vnic/vlan (optional last argument)
4890 */
4891 if (argc == 2) {
4892 status = dladm_name2info(handle, argv[1], &linkid, NULL, NULL,
4893 NULL);
4894 if (status != DLADM_STATUS_OK)
4895 goto done;
4896
4897 } else if (argc > 2) {
4898 usage();
4899 }
4900
4901 if (vlan)
4902 status = dladm_vlan_up(handle, linkid);
4903 else
4904 status = dladm_vnic_up(handle, linkid, 0);
4905
4906 done:
4907 if (status != DLADM_STATUS_OK) {
4908 if (argc == 2) {
4909 die_dlerr(status,
4910 "could not bring up %s '%s'", type, argv[1]);
4911 } else {
4912 die_dlerr(status, "could not bring %ss up", type);
4913 }
4914 }
4915 }
4916
4917 static void
4918 do_up_vnic(int argc, char *argv[], const char *use)
4919 {
4920 do_up_vnic_common(argc, argv, use, B_FALSE);
4921 }
4922
4923 static void
4924 dump_vnics_head(const char *dev)
4925 {
4926 if (strlen(dev))
4927 (void) printf("%s", dev);
4928
4929 (void) printf("\tipackets rbytes opackets obytes ");
4930
4931 if (strlen(dev))
4932 (void) printf("%%ipkts %%opkts\n");
4933 else
4934 (void) printf("\n");
4935 }
4936
4937 static void
4938 dump_vnic_stat(const char *name, datalink_id_t vnic_id,
4939 show_vnic_state_t *state, pktsum_t *vnic_stats, pktsum_t *tot_stats)
4940 {
4941 pktsum_t diff_stats;
4942 pktsum_t *old_stats = &state->vs_prevstats[vnic_id];
4943
4944 dladm_stats_diff(&diff_stats, vnic_stats, old_stats);
4945
4946 (void) printf("%s", name);
4947
4948 (void) printf("\t%-10llu", diff_stats.ipackets);
4949 (void) printf("%-12llu", diff_stats.rbytes);
4950 (void) printf("%-10llu", diff_stats.opackets);
4951 (void) printf("%-12llu", diff_stats.obytes);
4952
4953 if (tot_stats) {
4954 if (tot_stats->ipackets == 0) {
4955 (void) printf("\t-");
4956 } else {
4957 (void) printf("\t%-6.1f", (double)diff_stats.ipackets/
4958 (double)tot_stats->ipackets * 100);
4959 }
4960 if (tot_stats->opackets == 0) {
4961 (void) printf("\t-");
4962 } else {
4963 (void) printf("\t%-6.1f", (double)diff_stats.opackets/
4964 (double)tot_stats->opackets * 100);
4965 }
4966 }
4967 (void) printf("\n");
4968
4969 *old_stats = *vnic_stats;
4970 }
4971
4972 /*
4973 * Called from the walker dladm_vnic_walk_sys() for each vnic to display
4974 * vnic information or statistics.
4975 */
4976 static dladm_status_t
4977 print_vnic(show_vnic_state_t *state, datalink_id_t linkid)
4978 {
4979 dladm_vnic_attr_t attr, *vnic = &attr;
4980 dladm_status_t status;
4981 boolean_t is_etherstub;
4982 char devname[MAXLINKNAMELEN];
4983 char vnic_name[MAXLINKNAMELEN];
4984 char mstr[MAXMACADDRLEN * 3];
4985 vnic_fields_buf_t vbuf;
4986
4987 if ((status = dladm_vnic_info(handle, linkid, vnic, state->vs_flags)) !=
4988 DLADM_STATUS_OK)
4989 return (status);
4990
4991 is_etherstub = (vnic->va_link_id == DATALINK_INVALID_LINKID);
4992 if (state->vs_etherstub != is_etherstub) {
4993 /*
4994 * Want all etherstub but it's not one, or want
4995 * non-etherstub and it's one.
4996 */
4997 return (DLADM_STATUS_OK);
4998 }
4999
5000 if (state->vs_link_id != DATALINK_ALL_LINKID) {
5001 if (state->vs_link_id != vnic->va_link_id)
5002 return (DLADM_STATUS_OK);
5003 }
5004
5005 if (dladm_datalink_id2info(handle, linkid, NULL, NULL,
5006 NULL, vnic_name, sizeof (vnic_name)) != DLADM_STATUS_OK)
5007 return (DLADM_STATUS_BADARG);
5008
5009 bzero(devname, sizeof (devname));
5010 if (!is_etherstub &&
5011 dladm_datalink_id2info(handle, vnic->va_link_id, NULL, NULL,
5012 NULL, devname, sizeof (devname)) != DLADM_STATUS_OK)
5013 (void) sprintf(devname, "?");
5014
5015 state->vs_found = B_TRUE;
5016 if (state->vs_stats) {
5017 /* print vnic statistics */
5018 pktsum_t vnic_stats;
5019
5020 if (state->vs_firstonly) {
5021 if (state->vs_donefirst)
5022 return (0);
5023 state->vs_donefirst = B_TRUE;
5024 }
5025
5026 if (!state->vs_printstats) {
5027 /*
5028 * get vnic statistics and add to the sum for the
5029 * named device.
5030 */
5031 get_link_stats(vnic_name, &vnic_stats);
5032 dladm_stats_total(&state->vs_totalstats, &vnic_stats,
5033 &state->vs_prevstats[vnic->va_vnic_id]);
5034 } else {
5035 /* get and print vnic statistics */
5036 get_link_stats(vnic_name, &vnic_stats);
5037 dump_vnic_stat(vnic_name, linkid, state, &vnic_stats,
5038 &state->vs_totalstats);
5039 }
5040 return (DLADM_STATUS_OK);
5041 } else {
5042 (void) snprintf(vbuf.vnic_link, sizeof (vbuf.vnic_link),
5043 "%s", vnic_name);
5044
5045 if (!is_etherstub) {
5046
5047 (void) snprintf(vbuf.vnic_over, sizeof (vbuf.vnic_over),
5048 "%s", devname);
5049 (void) snprintf(vbuf.vnic_speed,
5050 sizeof (vbuf.vnic_speed), "%u",
5051 (uint_t)((get_ifspeed(vnic_name, B_TRUE))
5052 / 1000000ull));
5053
5054 switch (vnic->va_mac_addr_type) {
5055 case VNIC_MAC_ADDR_TYPE_FIXED:
5056 case VNIC_MAC_ADDR_TYPE_PRIMARY:
5057 (void) snprintf(vbuf.vnic_macaddrtype,
5058 sizeof (vbuf.vnic_macaddrtype),
5059 gettext("fixed"));
5060 break;
5061 case VNIC_MAC_ADDR_TYPE_RANDOM:
5062 (void) snprintf(vbuf.vnic_macaddrtype,
5063 sizeof (vbuf.vnic_macaddrtype),
5064 gettext("random"));
5065 break;
5066 case VNIC_MAC_ADDR_TYPE_FACTORY:
5067 (void) snprintf(vbuf.vnic_macaddrtype,
5068 sizeof (vbuf.vnic_macaddrtype),
5069 gettext("factory, slot %d"),
5070 vnic->va_mac_slot);
5071 break;
5072 case VNIC_MAC_ADDR_TYPE_VRID:
5073 (void) snprintf(vbuf.vnic_macaddrtype,
5074 sizeof (vbuf.vnic_macaddrtype),
5075 gettext("vrrp, %d/%s"),
5076 vnic->va_vrid, vnic->va_af == AF_INET ?
5077 "inet" : "inet6");
5078 break;
5079 }
5080
5081 if (strlen(vbuf.vnic_macaddrtype) > 0) {
5082 (void) snprintf(vbuf.vnic_macaddr,
5083 sizeof (vbuf.vnic_macaddr), "%s",
5084 dladm_aggr_macaddr2str(vnic->va_mac_addr,
5085 mstr));
5086 }
5087
5088 (void) snprintf(vbuf.vnic_vid, sizeof (vbuf.vnic_vid),
5089 "%d", vnic->va_vid);
5090 }
5091
5092 ofmt_print(state->vs_ofmt, &vbuf);
5093
5094 return (DLADM_STATUS_OK);
5095 }
5096 }
5097
5098 /* ARGSUSED */
5099 static int
5100 show_vnic(dladm_handle_t dh, datalink_id_t linkid, void *arg)
5101 {
5102 show_vnic_state_t *state = arg;
5103
5104 state->vs_status = print_vnic(state, linkid);
5105 return (DLADM_WALK_CONTINUE);
5106 }
5107
5108 static void
5109 do_show_vnic_common(int argc, char *argv[], const char *use,
5110 boolean_t etherstub)
5111 {
5112 int option;
5113 boolean_t s_arg = B_FALSE;
5114 boolean_t i_arg = B_FALSE;
5115 boolean_t l_arg = B_FALSE;
5116 uint32_t interval = 0, flags = DLADM_OPT_ACTIVE;
5117 datalink_id_t linkid = DATALINK_ALL_LINKID;
5118 datalink_id_t dev_linkid = DATALINK_ALL_LINKID;
5119 show_vnic_state_t state;
5120 dladm_status_t status;
5121 boolean_t o_arg = B_FALSE;
5122 char *fields_str = NULL;
5123 const ofmt_field_t *pf;
5124 char *all_e_fields = "link";
5125 ofmt_handle_t ofmt;
5126 ofmt_status_t oferr;
5127 uint_t ofmtflags = 0;
5128
5129 bzero(&state, sizeof (state));
5130 opterr = 0;
5131 while ((option = getopt_long(argc, argv, ":pPl:si:o:", lopts,
5132 NULL)) != -1) {
5133 switch (option) {
5134 case 'p':
5135 state.vs_parsable = B_TRUE;
5136 break;
5137 case 'P':
5138 flags = DLADM_OPT_PERSIST;
5139 break;
5140 case 'l':
5141 if (etherstub)
5142 die("option not supported for this command");
5143
5144 if (strlcpy(state.vs_link, optarg, MAXLINKNAMELEN) >=
5145 MAXLINKNAMELEN)
5146 die("link name too long");
5147
5148 l_arg = B_TRUE;
5149 break;
5150 case 's':
5151 if (s_arg) {
5152 die("the option -s cannot be specified "
5153 "more than once");
5154 }
5155 s_arg = B_TRUE;
5156 break;
5157 case 'i':
5158 if (i_arg) {
5159 die("the option -i cannot be specified "
5160 "more than once");
5161 }
5162 i_arg = B_TRUE;
5163 if (!dladm_str2interval(optarg, &interval))
5164 die("invalid interval value '%s'", optarg);
5165 break;
5166 case 'o':
5167 o_arg = B_TRUE;
5168 fields_str = optarg;
5169 break;
5170 default:
5171 die_opterr(optopt, option, use);
5172 }
5173 }
5174
5175 if (i_arg && !s_arg)
5176 die("the option -i can be used only with -s");
5177
5178 /* get vnic ID (optional last argument) */
5179 if (optind == (argc - 1)) {
5180 status = dladm_name2info(handle, argv[optind], &linkid, NULL,
5181 NULL, NULL);
5182 if (status != DLADM_STATUS_OK) {
5183 die_dlerr(status, "invalid vnic name '%s'",
5184 argv[optind]);
5185 }
5186 (void) strlcpy(state.vs_vnic, argv[optind], MAXLINKNAMELEN);
5187 } else if (optind != argc) {
5188 usage();
5189 }
5190
5191 if (l_arg) {
5192 status = dladm_name2info(handle, state.vs_link, &dev_linkid,
5193 NULL, NULL, NULL);
5194 if (status != DLADM_STATUS_OK) {
5195 die_dlerr(status, "invalid link name '%s'",
5196 state.vs_link);
5197 }
5198 }
5199
5200 state.vs_vnic_id = linkid;
5201 state.vs_link_id = dev_linkid;
5202 state.vs_etherstub = etherstub;
5203 state.vs_found = B_FALSE;
5204 state.vs_flags = flags;
5205
5206 if (!o_arg || (o_arg && strcasecmp(fields_str, "all") == 0)) {
5207 if (etherstub)
5208 fields_str = all_e_fields;
5209 }
5210 pf = vnic_fields;
5211
5212 if (state.vs_parsable)
5213 ofmtflags |= OFMT_PARSABLE;
5214 oferr = ofmt_open(fields_str, pf, ofmtflags, 0, &ofmt);
5215 ofmt_check(oferr, state.vs_parsable, ofmt, die, warn);
5216 state.vs_ofmt = ofmt;
5217
5218 if (s_arg) {
5219 /* Display vnic statistics */
5220 vnic_stats(&state, interval);
5221 ofmt_close(ofmt);
5222 return;
5223 }
5224
5225 /* Display vnic information */
5226 state.vs_donefirst = B_FALSE;
5227
5228 if (linkid == DATALINK_ALL_LINKID) {
5229 (void) dladm_walk_datalink_id(show_vnic, handle, &state,
5230 DATALINK_CLASS_VNIC | DATALINK_CLASS_ETHERSTUB,
5231 DATALINK_ANY_MEDIATYPE, flags);
5232 } else {
5233 (void) show_vnic(handle, linkid, &state);
5234 if (state.vs_status != DLADM_STATUS_OK) {
5235 ofmt_close(ofmt);
5236 die_dlerr(state.vs_status, "failed to show vnic '%s'",
5237 state.vs_vnic);
5238 }
5239 }
5240 ofmt_close(ofmt);
5241 }
5242
5243 static void
5244 do_show_vnic(int argc, char *argv[], const char *use)
5245 {
5246 do_show_vnic_common(argc, argv, use, B_FALSE);
5247 }
5248
5249 static void
5250 do_create_etherstub(int argc, char *argv[], const char *use)
5251 {
5252 uint32_t flags;
5253 char *altroot = NULL;
5254 int option;
5255 dladm_status_t status;
5256 char name[MAXLINKNAMELEN];
5257 uchar_t mac_addr[ETHERADDRL];
5258
5259 name[0] = '\0';
5260 bzero(mac_addr, sizeof (mac_addr));
5261 flags = DLADM_OPT_ANCHOR | DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
5262
5263 opterr = 0;
5264 while ((option = getopt_long(argc, argv, "tR:",
5265 etherstub_lopts, NULL)) != -1) {
5266 switch (option) {
5267 case 't':
5268 flags &= ~DLADM_OPT_PERSIST;
5269 break;
5270 case 'R':
5271 altroot = optarg;
5272 break;
5273 default:
5274 die_opterr(optopt, option, use);
5275 }
5276 }
5277
5278 /* the etherstub id is the required operand */
5279 if (optind != (argc - 1))
5280 usage();
5281
5282 if (strlcpy(name, argv[optind], MAXLINKNAMELEN) >= MAXLINKNAMELEN)
5283 die("link name too long '%s'", argv[optind]);
5284
5285 if (!dladm_valid_linkname(name))
5286 die("invalid link name '%s'", argv[optind]);
5287
5288 if (altroot != NULL)
5289 altroot_cmd(altroot, argc, argv);
5290
5291 status = dladm_vnic_create(handle, name, DATALINK_INVALID_LINKID,
5292 VNIC_MAC_ADDR_TYPE_AUTO, mac_addr, ETHERADDRL, NULL, 0, 0,
5293 VRRP_VRID_NONE, AF_UNSPEC, NULL, NULL, flags);
5294 if (status != DLADM_STATUS_OK)
5295 die_dlerr(status, "etherstub creation failed");
5296 }
5297
5298 static void
5299 do_delete_etherstub(int argc, char *argv[], const char *use)
5300 {
5301 do_delete_vnic_common(argc, argv, use, B_TRUE);
5302 }
5303
5304 /* ARGSUSED */
5305 static void
5306 do_show_etherstub(int argc, char *argv[], const char *use)
5307 {
5308 do_show_vnic_common(argc, argv, use, B_TRUE);
5309 }
5310
5311 /* ARGSUSED */
5312 static void
5313 do_up_simnet(int argc, char *argv[], const char *use)
5314 {
5315 (void) dladm_simnet_up(handle, DATALINK_ALL_LINKID, 0);
5316 }
5317
5318 static void
5319 do_create_simnet(int argc, char *argv[], const char *use)
5320 {
5321 uint32_t flags;
5322 char *altroot = NULL;
5323 char *media = NULL;
5324 uint32_t mtype = DL_ETHER;
5325 int option;
5326 dladm_status_t status;
5327 char name[MAXLINKNAMELEN];
5328
5329 name[0] = '\0';
5330 flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
5331
5332 opterr = 0;
5333 while ((option = getopt_long(argc, argv, ":tR:m:",
5334 simnet_lopts, NULL)) != -1) {
5335 switch (option) {
5336 case 't':
5337 flags &= ~DLADM_OPT_PERSIST;
5338 break;
5339 case 'R':
5340 altroot = optarg;
5341 break;
5342 case 'm':
5343 media = optarg;
5344 break;
5345 default:
5346 die_opterr(optopt, option, use);
5347 }
5348 }
5349
5350 /* the simnet id is the required operand */
5351 if (optind != (argc - 1))
5352 usage();
5353
5354 if (strlcpy(name, argv[optind], MAXLINKNAMELEN) >= MAXLINKNAMELEN)
5355 die("link name too long '%s'", argv[optind]);
5356
5357 if (!dladm_valid_linkname(name))
5358 die("invalid link name '%s'", name);
5359
5360 if (media != NULL) {
5361 mtype = dladm_str2media(media);
5362 if (mtype != DL_ETHER && mtype != DL_WIFI)
5363 die("media type '%s' is not supported", media);
5364 }
5365
5366 if (altroot != NULL)
5367 altroot_cmd(altroot, argc, argv);
5368
5369 status = dladm_simnet_create(handle, name, mtype, flags);
5370 if (status != DLADM_STATUS_OK)
5371 die_dlerr(status, "simnet creation failed");
5372 }
5373
5374 static void
5375 do_delete_simnet(int argc, char *argv[], const char *use)
5376 {
5377 int option;
5378 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
5379 datalink_id_t linkid;
5380 char *altroot = NULL;
5381 dladm_status_t status;
5382 dladm_simnet_attr_t slinfo;
5383
5384 opterr = 0;
5385 while ((option = getopt_long(argc, argv, ":tR:", simnet_lopts,
5386 NULL)) != -1) {
5387 switch (option) {
5388 case 't':
5389 flags &= ~DLADM_OPT_PERSIST;
5390 break;
5391 case 'R':
5392 altroot = optarg;
5393 break;
5394 default:
5395 die_opterr(optopt, option, use);
5396 }
5397 }
5398
5399 /* get simnet name (required last argument) */
5400 if (optind != (argc - 1))
5401 usage();
5402
5403 if (!dladm_valid_linkname(argv[optind]))
5404 die("invalid link name '%s'", argv[optind]);
5405
5406 if (altroot != NULL)
5407 altroot_cmd(altroot, argc, argv);
5408
5409 status = dladm_name2info(handle, argv[optind], &linkid, NULL, NULL,
5410 NULL);
5411 if (status != DLADM_STATUS_OK)
5412 die("simnet '%s' not found", argv[optind]);
5413
5414 if ((status = dladm_simnet_info(handle, linkid, &slinfo,
5415 flags)) != DLADM_STATUS_OK)
5416 die_dlerr(status, "failed to retrieve simnet information");
5417
5418 status = dladm_simnet_delete(handle, linkid, flags);
5419 if (status != DLADM_STATUS_OK)
5420 die_dlerr(status, "simnet deletion failed");
5421 }
5422
5423 static void
5424 do_modify_simnet(int argc, char *argv[], const char *use)
5425 {
5426 int option;
5427 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
5428 datalink_id_t linkid;
5429 datalink_id_t peer_linkid;
5430 char *altroot = NULL;
5431 dladm_status_t status;
5432 boolean_t p_arg = B_FALSE;
5433
5434 opterr = 0;
5435 while ((option = getopt_long(argc, argv, ":tR:p:", simnet_lopts,
5436 NULL)) != -1) {
5437 switch (option) {
5438 case 't':
5439 flags &= ~DLADM_OPT_PERSIST;
5440 break;
5441 case 'R':
5442 altroot = optarg;
5443 break;
5444 case 'p':
5445 if (p_arg)
5446 die_optdup(option);
5447 p_arg = B_TRUE;
5448 if (strcasecmp(optarg, "none") == 0)
5449 peer_linkid = DATALINK_INVALID_LINKID;
5450 else if (dladm_name2info(handle, optarg, &peer_linkid,
5451 NULL, NULL, NULL) != DLADM_STATUS_OK)
5452 die("invalid peer link name '%s'", optarg);
5453 break;
5454 default:
5455 die_opterr(optopt, option, use);
5456 }
5457 }
5458
5459 /* get simnet name (required last argument) */
5460 if (optind != (argc - 1))
5461 usage();
5462
5463 /* Nothing to do if no peer link argument */
5464 if (!p_arg)
5465 return;
5466
5467 if (altroot != NULL)
5468 altroot_cmd(altroot, argc, argv);
5469
5470 status = dladm_name2info(handle, argv[optind], &linkid, NULL, NULL,
5471 NULL);
5472 if (status != DLADM_STATUS_OK)
5473 die("invalid link name '%s'", argv[optind]);
5474
5475 status = dladm_simnet_modify(handle, linkid, peer_linkid, flags);
5476 if (status != DLADM_STATUS_OK)
5477 die_dlerr(status, "simnet modification failed");
5478 }
5479
5480 static dladm_status_t
5481 print_simnet(show_state_t *state, datalink_id_t linkid)
5482 {
5483 dladm_simnet_attr_t slinfo;
5484 uint32_t flags;
5485 dladm_status_t status;
5486 simnet_fields_buf_t slbuf;
5487 char mstr[ETHERADDRL * 3];
5488
5489 bzero(&slbuf, sizeof (slbuf));
5490 if ((status = dladm_datalink_id2info(handle, linkid, &flags, NULL, NULL,
5491 slbuf.simnet_name, sizeof (slbuf.simnet_name)))
5492 != DLADM_STATUS_OK)
5493 return (status);
5494
5495 if (!(state->ls_flags & flags))
5496 return (DLADM_STATUS_NOTFOUND);
5497
5498 if ((status = dladm_simnet_info(handle, linkid, &slinfo,
5499 state->ls_flags)) != DLADM_STATUS_OK)
5500 return (status);
5501
5502 if (slinfo.sna_peer_link_id != DATALINK_INVALID_LINKID &&
5503 (status = dladm_datalink_id2info(handle, slinfo.sna_peer_link_id,
5504 NULL, NULL, NULL, slbuf.simnet_otherlink,
5505 sizeof (slbuf.simnet_otherlink))) !=
5506 DLADM_STATUS_OK)
5507 return (status);
5508
5509 if (slinfo.sna_mac_len > sizeof (slbuf.simnet_macaddr))
5510 return (DLADM_STATUS_BADVAL);
5511
5512 (void) strlcpy(slbuf.simnet_macaddr,
5513 dladm_aggr_macaddr2str(slinfo.sna_mac_addr, mstr),
5514 sizeof (slbuf.simnet_macaddr));
5515 (void) dladm_media2str(slinfo.sna_type, slbuf.simnet_media);
5516
5517 ofmt_print(state->ls_ofmt, &slbuf);
5518 return (status);
5519 }
5520
5521 /* ARGSUSED */
5522 static int
5523 show_simnet(dladm_handle_t dh, datalink_id_t linkid, void *arg)
5524 {
5525 show_state_t *state = arg;
5526
5527 state->ls_status = print_simnet(state, linkid);
5528 return (DLADM_WALK_CONTINUE);
5529 }
5530
5531 static void
5532 do_show_simnet(int argc, char *argv[], const char *use)
5533 {
5534 int option;
5535 uint32_t flags = DLADM_OPT_ACTIVE;
5536 boolean_t p_arg = B_FALSE;
5537 datalink_id_t linkid = DATALINK_ALL_LINKID;
5538 show_state_t state;
5539 dladm_status_t status;
5540 boolean_t o_arg = B_FALSE;
5541 ofmt_handle_t ofmt;
5542 ofmt_status_t oferr;
5543 char *all_fields = "link,media,macaddress,otherlink";
5544 char *fields_str = all_fields;
5545 uint_t ofmtflags = 0;
5546
5547 bzero(&state, sizeof (state));
5548
5549 opterr = 0;
5550 while ((option = getopt_long(argc, argv, ":pPo:",
5551 show_lopts, NULL)) != -1) {
5552 switch (option) {
5553 case 'p':
5554 if (p_arg)
5555 die_optdup(option);
5556
5557 p_arg = B_TRUE;
5558 state.ls_parsable = p_arg;
5559 break;
5560 case 'P':
5561 if (flags != DLADM_OPT_ACTIVE)
5562 die_optdup(option);
5563
5564 flags = DLADM_OPT_PERSIST;
5565 break;
5566 case 'o':
5567 o_arg = B_TRUE;
5568 fields_str = optarg;
5569 break;
5570 default:
5571 die_opterr(optopt, option, use);
5572 break;
5573 }
5574 }
5575
5576 if (p_arg && !o_arg)
5577 die("-p requires -o");
5578
5579 if (strcasecmp(fields_str, "all") == 0) {
5580 if (p_arg)
5581 die("\"-o all\" is invalid with -p");
5582 fields_str = all_fields;
5583 }
5584
5585 /* get link name (optional last argument) */
5586 if (optind == (argc-1)) {
5587 if ((status = dladm_name2info(handle, argv[optind], &linkid,
5588 NULL, NULL, NULL)) != DLADM_STATUS_OK) {
5589 die_dlerr(status, "link %s is not valid", argv[optind]);
5590 }
5591 } else if (optind != argc) {
5592 usage();
5593 }
5594
5595 state.ls_flags = flags;
5596 state.ls_donefirst = B_FALSE;
5597 if (state.ls_parsable)
5598 ofmtflags |= OFMT_PARSABLE;
5599 oferr = ofmt_open(fields_str, simnet_fields, ofmtflags, 0, &ofmt);
5600 ofmt_check(oferr, state.ls_parsable, ofmt, die, warn);
5601 state.ls_ofmt = ofmt;
5602
5603 if (linkid == DATALINK_ALL_LINKID) {
5604 (void) dladm_walk_datalink_id(show_simnet, handle, &state,
5605 DATALINK_CLASS_SIMNET, DATALINK_ANY_MEDIATYPE, flags);
5606 } else {
5607 (void) show_simnet(handle, linkid, &state);
5608 if (state.ls_status != DLADM_STATUS_OK) {
5609 ofmt_close(ofmt);
5610 die_dlerr(state.ls_status, "failed to show simnet %s",
5611 argv[optind]);
5612 }
5613 }
5614 ofmt_close(ofmt);
5615 }
5616
5617 static void
5618 link_stats(datalink_id_t linkid, uint_t interval, char *fields_str,
5619 show_state_t *state)
5620 {
5621 ofmt_handle_t ofmt;
5622 ofmt_status_t oferr;
5623 uint_t ofmtflags = 0;
5624
5625 if (state->ls_parsable)
5626 ofmtflags |= OFMT_PARSABLE;
5627 oferr = ofmt_open(fields_str, link_s_fields, ofmtflags, 0, &ofmt);
5628 ofmt_check(oferr, state->ls_parsable, ofmt, die, warn);
5629 state->ls_ofmt = ofmt;
5630
5631 /*
5632 * If an interval is specified, continuously show the stats
5633 * only for the first MAC port.
5634 */
5635 state->ls_firstonly = (interval != 0);
5636
5637 for (;;) {
5638 state->ls_donefirst = B_FALSE;
5639 if (linkid == DATALINK_ALL_LINKID) {
5640 (void) dladm_walk_datalink_id(show_link_stats, handle,
5641 state, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE,
5642 DLADM_OPT_ACTIVE);
5643 } else {
5644 (void) show_link_stats(handle, linkid, state);
5645 }
5646
5647 if (interval == 0)
5648 break;
5649
5650 (void) fflush(stdout);
5651 (void) sleep(interval);
5652 }
5653 ofmt_close(ofmt);
5654 }
5655
5656 static void
5657 aggr_stats(datalink_id_t linkid, show_grp_state_t *state, uint_t interval)
5658 {
5659 /*
5660 * If an interval is specified, continuously show the stats
5661 * only for the first group.
5662 */
5663 state->gs_firstonly = (interval != 0);
5664
5665 for (;;) {
5666 state->gs_donefirst = B_FALSE;
5667 if (linkid == DATALINK_ALL_LINKID)
5668 (void) dladm_walk_datalink_id(show_aggr, handle, state,
5669 DATALINK_CLASS_AGGR, DATALINK_ANY_MEDIATYPE,
5670 DLADM_OPT_ACTIVE);
5671 else
5672 (void) show_aggr(handle, linkid, state);
5673
5674 if (interval == 0)
5675 break;
5676
5677 (void) fflush(stdout);
5678 (void) sleep(interval);
5679 }
5680 }
5681
5682 /* ARGSUSED */
5683 static void
5684 vnic_stats(show_vnic_state_t *sp, uint32_t interval)
5685 {
5686 show_vnic_state_t state;
5687 boolean_t specific_link, specific_dev;
5688
5689 /* Display vnic statistics */
5690 dump_vnics_head(sp->vs_link);
5691
5692 bzero(&state, sizeof (state));
5693 state.vs_stats = B_TRUE;
5694 state.vs_vnic_id = sp->vs_vnic_id;
5695 state.vs_link_id = sp->vs_link_id;
5696
5697 /*
5698 * If an interval is specified, and a vnic ID is not specified,
5699 * continuously show the stats only for the first vnic.
5700 */
5701 specific_link = (sp->vs_vnic_id != DATALINK_ALL_LINKID);
5702 specific_dev = (sp->vs_link_id != DATALINK_ALL_LINKID);
5703
5704 for (;;) {
5705 /* Get stats for each vnic */
5706 state.vs_found = B_FALSE;
5707 state.vs_donefirst = B_FALSE;
5708 state.vs_printstats = B_FALSE;
5709 state.vs_flags = DLADM_OPT_ACTIVE;
5710
5711 if (!specific_link) {
5712 (void) dladm_walk_datalink_id(show_vnic, handle, &state,
5713 DATALINK_CLASS_VNIC, DATALINK_ANY_MEDIATYPE,
5714 DLADM_OPT_ACTIVE);
5715 } else {
5716 (void) show_vnic(handle, sp->vs_vnic_id, &state);
5717 if (state.vs_status != DLADM_STATUS_OK) {
5718 die_dlerr(state.vs_status,
5719 "failed to show vnic '%s'", sp->vs_vnic);
5720 }
5721 }
5722
5723 if (specific_link && !state.vs_found)
5724 die("non-existent vnic '%s'", sp->vs_vnic);
5725 if (specific_dev && !state.vs_found)
5726 die("device %s has no vnics", sp->vs_link);
5727
5728 /* Show totals */
5729 if ((specific_link | specific_dev) && !interval) {
5730 (void) printf("Total");
5731 (void) printf("\t%-10llu",
5732 state.vs_totalstats.ipackets);
5733 (void) printf("%-12llu",
5734 state.vs_totalstats.rbytes);
5735 (void) printf("%-10llu",
5736 state.vs_totalstats.opackets);
5737 (void) printf("%-12llu\n",
5738 state.vs_totalstats.obytes);
5739 }
5740
5741 /* Show stats for each vnic */
5742 state.vs_donefirst = B_FALSE;
5743 state.vs_printstats = B_TRUE;
5744
5745 if (!specific_link) {
5746 (void) dladm_walk_datalink_id(show_vnic, handle, &state,
5747 DATALINK_CLASS_VNIC, DATALINK_ANY_MEDIATYPE,
5748 DLADM_OPT_ACTIVE);
5749 } else {
5750 (void) show_vnic(handle, sp->vs_vnic_id, &state);
5751 if (state.vs_status != DLADM_STATUS_OK) {
5752 die_dlerr(state.vs_status,
5753 "failed to show vnic '%s'", sp->vs_vnic);
5754 }
5755 }
5756
5757 if (interval == 0)
5758 break;
5759
5760 (void) fflush(stdout);
5761 (void) sleep(interval);
5762 }
5763 }
5764
5765 static void
5766 get_mac_stats(const char *dev, pktsum_t *stats)
5767 {
5768 kstat_ctl_t *kcp;
5769 kstat_t *ksp;
5770 char module[DLPI_LINKNAME_MAX];
5771 uint_t instance;
5772
5773
5774 bzero(stats, sizeof (*stats));
5775
5776 if (dlpi_parselink(dev, module, &instance) != DLPI_SUCCESS)
5777 return;
5778
5779 if ((kcp = kstat_open()) == NULL) {
5780 warn("kstat open operation failed");
5781 return;
5782 }
5783
5784 ksp = dladm_kstat_lookup(kcp, module, instance, "mac", NULL);
5785 if (ksp != NULL)
5786 dladm_get_stats(kcp, ksp, stats);
5787
5788 (void) kstat_close(kcp);
5789
5790 }
5791
5792 static void
5793 get_link_stats(const char *link, pktsum_t *stats)
5794 {
5795 kstat_ctl_t *kcp;
5796 kstat_t *ksp;
5797
5798 bzero(stats, sizeof (*stats));
5799
5800 if ((kcp = kstat_open()) == NULL) {
5801 warn("kstat_open operation failed");
5802 return;
5803 }
5804
5805 ksp = dladm_kstat_lookup(kcp, "link", 0, link, NULL);
5806
5807 if (ksp != NULL)
5808 dladm_get_stats(kcp, ksp, stats);
5809
5810 (void) kstat_close(kcp);
5811 }
5812
5813 static int
5814 query_kstat(char *module, int instance, const char *name, const char *stat,
5815 uint8_t type, void *val)
5816 {
5817 kstat_ctl_t *kcp;
5818 kstat_t *ksp;
5819
5820 if ((kcp = kstat_open()) == NULL) {
5821 warn("kstat open operation failed");
5822 return (-1);
5823 }
5824
5825 if ((ksp = kstat_lookup(kcp, module, instance, (char *)name)) == NULL) {
5826 /*
5827 * The kstat query could fail if the underlying MAC
5828 * driver was already detached.
5829 */
5830 goto bail;
5831 }
5832
5833 if (kstat_read(kcp, ksp, NULL) == -1) {
5834 warn("kstat read failed");
5835 goto bail;
5836 }
5837
5838 if (dladm_kstat_value(ksp, stat, type, val) < 0)
5839 goto bail;
5840
5841 (void) kstat_close(kcp);
5842 return (0);
5843
5844 bail:
5845 (void) kstat_close(kcp);
5846 return (-1);
5847 }
5848
5849 static int
5850 get_one_kstat(const char *name, const char *stat, uint8_t type,
5851 void *val, boolean_t islink)
5852 {
5853 char module[DLPI_LINKNAME_MAX];
5854 uint_t instance;
5855
5856 if (islink) {
5857 return (query_kstat("link", 0, name, stat, type, val));
5858 } else {
5859 if (dlpi_parselink(name, module, &instance) != DLPI_SUCCESS)
5860 return (-1);
5861
5862 return (query_kstat(module, instance, "mac", stat, type, val));
5863 }
5864 }
5865
5866 static uint64_t
5867 get_ifspeed(const char *name, boolean_t islink)
5868 {
5869 uint64_t ifspeed = 0;
5870
5871 (void) get_one_kstat(name, "ifspeed", KSTAT_DATA_UINT64,
5872 &ifspeed, islink);
5873
5874 return (ifspeed);
5875 }
5876
5877 static const char *
5878 get_linkstate(const char *name, boolean_t islink, char *buf)
5879 {
5880 link_state_t linkstate;
5881
5882 if (get_one_kstat(name, "link_state", KSTAT_DATA_UINT32,
5883 &linkstate, islink) != 0) {
5884 (void) strlcpy(buf, "?", DLADM_STRSIZE);
5885 return (buf);
5886 }
5887 return (dladm_linkstate2str(linkstate, buf));
5888 }
5889
5890 static const char *
5891 get_linkduplex(const char *name, boolean_t islink, char *buf)
5892 {
5893 link_duplex_t linkduplex;
5894
5895 if (get_one_kstat(name, "link_duplex", KSTAT_DATA_UINT32,
5896 &linkduplex, islink) != 0) {
5897 (void) strlcpy(buf, "unknown", DLADM_STRSIZE);
5898 return (buf);
5899 }
5900
5901 return (dladm_linkduplex2str(linkduplex, buf));
5902 }
5903
5904 static int
5905 parse_wifi_fields(char *str, ofmt_handle_t *ofmt, uint_t cmdtype,
5906 boolean_t parsable)
5907 {
5908 ofmt_field_t *template, *of;
5909 ofmt_cb_t *fn;
5910 ofmt_status_t oferr;
5911
5912 if (cmdtype == WIFI_CMD_SCAN) {
5913 template = wifi_common_fields;
5914 if (str == NULL)
5915 str = def_scan_wifi_fields;
5916 if (strcasecmp(str, "all") == 0)
5917 str = all_scan_wifi_fields;
5918 fn = print_wlan_attr_cb;
5919 } else if (cmdtype == WIFI_CMD_SHOW) {
5920 bcopy(wifi_common_fields, &wifi_show_fields[2],
5921 sizeof (wifi_common_fields));
5922 template = wifi_show_fields;
5923 if (str == NULL)
5924 str = def_show_wifi_fields;
5925 if (strcasecmp(str, "all") == 0)
5926 str = all_show_wifi_fields;
5927 fn = print_link_attr_cb;
5928 } else {
5929 return (-1);
5930 }
5931
5932 for (of = template; of->of_name != NULL; of++) {
5933 if (of->of_cb == NULL)
5934 of->of_cb = fn;
5935 }
5936
5937 oferr = ofmt_open(str, template, (parsable ? OFMT_PARSABLE : 0),
5938 0, ofmt);
5939 ofmt_check(oferr, parsable, *ofmt, die, warn);
5940 return (0);
5941 }
5942
5943 typedef struct print_wifi_state {
5944 char *ws_link;
5945 boolean_t ws_parsable;
5946 boolean_t ws_header;
5947 ofmt_handle_t ws_ofmt;
5948 } print_wifi_state_t;
5949
5950 typedef struct wlan_scan_args_s {
5951 print_wifi_state_t *ws_state;
5952 void *ws_attr;
5953 } wlan_scan_args_t;
5954
5955 static boolean_t
5956 print_wlan_attr_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
5957 {
5958 wlan_scan_args_t *w = ofarg->ofmt_cbarg;
5959 print_wifi_state_t *statep = w->ws_state;
5960 dladm_wlan_attr_t *attrp = w->ws_attr;
5961 char tmpbuf[DLADM_STRSIZE];
5962
5963 if (ofarg->ofmt_id == 0) {
5964 (void) strlcpy(buf, (char *)statep->ws_link, bufsize);
5965 return (B_TRUE);
5966 }
5967
5968 if ((ofarg->ofmt_id & attrp->wa_valid) == 0)
5969 return (B_TRUE);
5970
5971 switch (ofarg->ofmt_id) {
5972 case DLADM_WLAN_ATTR_ESSID:
5973 (void) dladm_wlan_essid2str(&attrp->wa_essid, tmpbuf);
5974 break;
5975 case DLADM_WLAN_ATTR_BSSID:
5976 (void) dladm_wlan_bssid2str(&attrp->wa_bssid, tmpbuf);
5977 break;
5978 case DLADM_WLAN_ATTR_SECMODE:
5979 (void) dladm_wlan_secmode2str(&attrp->wa_secmode, tmpbuf);
5980 break;
5981 case DLADM_WLAN_ATTR_STRENGTH:
5982 (void) dladm_wlan_strength2str(&attrp->wa_strength, tmpbuf);
5983 break;
5984 case DLADM_WLAN_ATTR_MODE:
5985 (void) dladm_wlan_mode2str(&attrp->wa_mode, tmpbuf);
5986 break;
5987 case DLADM_WLAN_ATTR_SPEED:
5988 (void) dladm_wlan_speed2str(&attrp->wa_speed, tmpbuf);
5989 (void) strlcat(tmpbuf, "Mb", sizeof (tmpbuf));
5990 break;
5991 case DLADM_WLAN_ATTR_AUTH:
5992 (void) dladm_wlan_auth2str(&attrp->wa_auth, tmpbuf);
5993 break;
5994 case DLADM_WLAN_ATTR_BSSTYPE:
5995 (void) dladm_wlan_bsstype2str(&attrp->wa_bsstype, tmpbuf);
5996 break;
5997 }
5998 (void) strlcpy(buf, tmpbuf, bufsize);
5999
6000 return (B_TRUE);
6001 }
6002
6003 static boolean_t
6004 print_scan_results(void *arg, dladm_wlan_attr_t *attrp)
6005 {
6006 print_wifi_state_t *statep = arg;
6007 wlan_scan_args_t warg;
6008
6009 bzero(&warg, sizeof (warg));
6010 warg.ws_state = statep;
6011 warg.ws_attr = attrp;
6012 ofmt_print(statep->ws_ofmt, &warg);
6013 return (B_TRUE);
6014 }
6015
6016 static int
6017 scan_wifi(dladm_handle_t dh, datalink_id_t linkid, void *arg)
6018 {
6019 print_wifi_state_t *statep = arg;
6020 dladm_status_t status;
6021 char link[MAXLINKNAMELEN];
6022
6023 if ((status = dladm_datalink_id2info(dh, linkid, NULL, NULL, NULL, link,
6024 sizeof (link))) != DLADM_STATUS_OK) {
6025 return (DLADM_WALK_CONTINUE);
6026 }
6027
6028 statep->ws_link = link;
6029 status = dladm_wlan_scan(dh, linkid, statep, print_scan_results);
6030 if (status != DLADM_STATUS_OK)
6031 die_dlerr(status, "cannot scan link '%s'", statep->ws_link);
6032
6033 return (DLADM_WALK_CONTINUE);
6034 }
6035
6036 static boolean_t
6037 print_wifi_status_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
6038 {
6039 static char tmpbuf[DLADM_STRSIZE];
6040 wlan_scan_args_t *w = ofarg->ofmt_cbarg;
6041 dladm_wlan_linkattr_t *attrp = w->ws_attr;
6042
6043 if ((ofarg->ofmt_id & attrp->la_valid) != 0) {
6044 (void) dladm_wlan_linkstatus2str(&attrp->la_status, tmpbuf);
6045 (void) strlcpy(buf, tmpbuf, bufsize);
6046 }
6047 return (B_TRUE);
6048 }
6049
6050 static boolean_t
6051 print_link_attr_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
6052 {
6053 wlan_scan_args_t *w = ofarg->ofmt_cbarg, w1;
6054 print_wifi_state_t *statep = w->ws_state;
6055 dladm_wlan_linkattr_t *attrp = w->ws_attr;
6056
6057 bzero(&w1, sizeof (w1));
6058 w1.ws_state = statep;
6059 w1.ws_attr = &attrp->la_wlan_attr;
6060 ofarg->ofmt_cbarg = &w1;
6061 return (print_wlan_attr_cb(ofarg, buf, bufsize));
6062 }
6063
6064 static int
6065 show_wifi(dladm_handle_t dh, datalink_id_t linkid, void *arg)
6066 {
6067 print_wifi_state_t *statep = arg;
6068 dladm_wlan_linkattr_t attr;
6069 dladm_status_t status;
6070 char link[MAXLINKNAMELEN];
6071 wlan_scan_args_t warg;
6072
6073 if ((status = dladm_datalink_id2info(dh, linkid, NULL, NULL, NULL, link,
6074 sizeof (link))) != DLADM_STATUS_OK) {
6075 return (DLADM_WALK_CONTINUE);
6076 }
6077
6078 /* dladm_wlan_get_linkattr() memsets attr with 0 */
6079 status = dladm_wlan_get_linkattr(dh, linkid, &attr);
6080 if (status != DLADM_STATUS_OK)
6081 die_dlerr(status, "cannot get link attributes for %s", link);
6082
6083 statep->ws_link = link;
6084
6085 bzero(&warg, sizeof (warg));
6086 warg.ws_state = statep;
6087 warg.ws_attr = &attr;
6088 ofmt_print(statep->ws_ofmt, &warg);
6089 return (DLADM_WALK_CONTINUE);
6090 }
6091
6092 static void
6093 do_display_wifi(int argc, char **argv, int cmd, const char *use)
6094 {
6095 int option;
6096 char *fields_str = NULL;
6097 int (*callback)(dladm_handle_t, datalink_id_t, void *);
6098 print_wifi_state_t state;
6099 datalink_id_t linkid = DATALINK_ALL_LINKID;
6100 dladm_status_t status;
6101
6102 if (cmd == WIFI_CMD_SCAN)
6103 callback = scan_wifi;
6104 else if (cmd == WIFI_CMD_SHOW)
6105 callback = show_wifi;
6106 else
6107 return;
6108
6109 state.ws_parsable = B_FALSE;
6110 state.ws_header = B_TRUE;
6111 opterr = 0;
6112 while ((option = getopt_long(argc, argv, ":o:p",
6113 wifi_longopts, NULL)) != -1) {
6114 switch (option) {
6115 case 'o':
6116 fields_str = optarg;
6117 break;
6118 case 'p':
6119 state.ws_parsable = B_TRUE;
6120 break;
6121 default:
6122 die_opterr(optopt, option, use);
6123 }
6124 }
6125
6126 if (state.ws_parsable && fields_str == NULL)
6127 die("-p requires -o");
6128
6129 if (state.ws_parsable && strcasecmp(fields_str, "all") == 0)
6130 die("\"-o all\" is invalid with -p");
6131
6132 if (optind == (argc - 1)) {
6133 if ((status = dladm_name2info(handle, argv[optind], &linkid,
6134 NULL, NULL, NULL)) != DLADM_STATUS_OK) {
6135 die_dlerr(status, "link %s is not valid", argv[optind]);
6136 }
6137 } else if (optind != argc) {
6138 usage();
6139 }
6140
6141 if (parse_wifi_fields(fields_str, &state.ws_ofmt, cmd,
6142 state.ws_parsable) < 0)
6143 die("invalid field(s) specified");
6144
6145 if (linkid == DATALINK_ALL_LINKID) {
6146 (void) dladm_walk_datalink_id(callback, handle, &state,
6147 DATALINK_CLASS_PHYS | DATALINK_CLASS_SIMNET,
6148 DL_WIFI, DLADM_OPT_ACTIVE);
6149 } else {
6150 (void) (*callback)(handle, linkid, &state);
6151 }
6152 ofmt_close(state.ws_ofmt);
6153 }
6154
6155 static void
6156 do_scan_wifi(int argc, char **argv, const char *use)
6157 {
6158 do_display_wifi(argc, argv, WIFI_CMD_SCAN, use);
6159 }
6160
6161 static void
6162 do_show_wifi(int argc, char **argv, const char *use)
6163 {
6164 do_display_wifi(argc, argv, WIFI_CMD_SHOW, use);
6165 }
6166
6167 typedef struct wlan_count_attr {
6168 uint_t wc_count;
6169 datalink_id_t wc_linkid;
6170 } wlan_count_attr_t;
6171
6172 /* ARGSUSED */
6173 static int
6174 do_count_wlan(dladm_handle_t dh, datalink_id_t linkid, void *arg)
6175 {
6176 wlan_count_attr_t *cp = arg;
6177
6178 if (cp->wc_count == 0)
6179 cp->wc_linkid = linkid;
6180 cp->wc_count++;
6181 return (DLADM_WALK_CONTINUE);
6182 }
6183
6184 static int
6185 parse_wlan_keys(char *str, dladm_wlan_key_t **keys, uint_t *key_countp)
6186 {
6187 uint_t i;
6188 dladm_wlan_key_t *wk;
6189 int nfields = 1;
6190 char *field, *token, *lasts = NULL, c;
6191
6192 token = str;
6193 while ((c = *token++) != '\0') {
6194 if (c == ',')
6195 nfields++;
6196 }
6197 token = strdup(str);
6198 if (token == NULL)
6199 return (-1);
6200
6201 wk = malloc(nfields * sizeof (dladm_wlan_key_t));
6202 if (wk == NULL)
6203 goto fail;
6204
6205 token = str;
6206 for (i = 0; i < nfields; i++) {
6207 char *s;
6208 dladm_secobj_class_t class;
6209 dladm_status_t status;
6210
6211 field = strtok_r(token, ",", &lasts);
6212 token = NULL;
6213
6214 (void) strlcpy(wk[i].wk_name, field,
6215 DLADM_WLAN_MAX_KEYNAME_LEN);
6216
6217 wk[i].wk_idx = 1;
6218 if ((s = strrchr(wk[i].wk_name, ':')) != NULL) {
6219 if (s[1] == '\0' || s[2] != '\0' || !isdigit(s[1]))
6220 goto fail;
6221
6222 wk[i].wk_idx = (uint_t)(s[1] - '0');
6223 *s = '\0';
6224 }
6225 wk[i].wk_len = DLADM_WLAN_MAX_KEY_LEN;
6226
6227 status = dladm_get_secobj(handle, wk[i].wk_name, &class,
6228 wk[i].wk_val, &wk[i].wk_len, 0);
6229 if (status != DLADM_STATUS_OK) {
6230 if (status == DLADM_STATUS_NOTFOUND) {
6231 status = dladm_get_secobj(handle, wk[i].wk_name,
6232 &class, wk[i].wk_val, &wk[i].wk_len,
6233 DLADM_OPT_PERSIST);
6234 }
6235 if (status != DLADM_STATUS_OK)
6236 goto fail;
6237 }
6238 wk[i].wk_class = class;
6239 }
6240 *keys = wk;
6241 *key_countp = i;
6242 free(token);
6243 return (0);
6244 fail:
6245 free(wk);
6246 free(token);
6247 return (-1);
6248 }
6249
6250 static void
6251 do_connect_wifi(int argc, char **argv, const char *use)
6252 {
6253 int option;
6254 dladm_wlan_attr_t attr, *attrp;
6255 dladm_status_t status = DLADM_STATUS_OK;
6256 int timeout = DLADM_WLAN_CONNECT_TIMEOUT_DEFAULT;
6257 datalink_id_t linkid = DATALINK_ALL_LINKID;
6258 dladm_wlan_key_t *keys = NULL;
6259 uint_t key_count = 0;
6260 uint_t flags = 0;
6261 dladm_wlan_secmode_t keysecmode = DLADM_WLAN_SECMODE_NONE;
6262 char buf[DLADM_STRSIZE];
6263
6264 opterr = 0;
6265 (void) memset(&attr, 0, sizeof (attr));
6266 while ((option = getopt_long(argc, argv, ":e:i:a:m:b:s:k:T:c",
6267 wifi_longopts, NULL)) != -1) {
6268 switch (option) {
6269 case 'e':
6270 status = dladm_wlan_str2essid(optarg, &attr.wa_essid);
6271 if (status != DLADM_STATUS_OK)
6272 die("invalid ESSID '%s'", optarg);
6273
6274 attr.wa_valid |= DLADM_WLAN_ATTR_ESSID;
6275 /*
6276 * Try to connect without doing a scan.
6277 */
6278 flags |= DLADM_WLAN_CONNECT_NOSCAN;
6279 break;
6280 case 'i':
6281 status = dladm_wlan_str2bssid(optarg, &attr.wa_bssid);
6282 if (status != DLADM_STATUS_OK)
6283 die("invalid BSSID %s", optarg);
6284
6285 attr.wa_valid |= DLADM_WLAN_ATTR_BSSID;
6286 break;
6287 case 'a':
6288 status = dladm_wlan_str2auth(optarg, &attr.wa_auth);
6289 if (status != DLADM_STATUS_OK)
6290 die("invalid authentication mode '%s'", optarg);
6291
6292 attr.wa_valid |= DLADM_WLAN_ATTR_AUTH;
6293 break;
6294 case 'm':
6295 status = dladm_wlan_str2mode(optarg, &attr.wa_mode);
6296 if (status != DLADM_STATUS_OK)
6297 die("invalid mode '%s'", optarg);
6298
6299 attr.wa_valid |= DLADM_WLAN_ATTR_MODE;
6300 break;
6301 case 'b':
6302 if ((status = dladm_wlan_str2bsstype(optarg,
6303 &attr.wa_bsstype)) != DLADM_STATUS_OK) {
6304 die("invalid bsstype '%s'", optarg);
6305 }
6306
6307 attr.wa_valid |= DLADM_WLAN_ATTR_BSSTYPE;
6308 break;
6309 case 's':
6310 if ((status = dladm_wlan_str2secmode(optarg,
6311 &attr.wa_secmode)) != DLADM_STATUS_OK) {
6312 die("invalid security mode '%s'", optarg);
6313 }
6314
6315 attr.wa_valid |= DLADM_WLAN_ATTR_SECMODE;
6316 break;
6317 case 'k':
6318 if (parse_wlan_keys(optarg, &keys, &key_count) < 0)
6319 die("invalid key(s) '%s'", optarg);
6320
6321 if (keys[0].wk_class == DLADM_SECOBJ_CLASS_WEP)
6322 keysecmode = DLADM_WLAN_SECMODE_WEP;
6323 else
6324 keysecmode = DLADM_WLAN_SECMODE_WPA;
6325 break;
6326 case 'T':
6327 if (strcasecmp(optarg, "forever") == 0) {
6328 timeout = -1;
6329 break;
6330 }
6331 if (!str2int(optarg, &timeout) || timeout < 0)
6332 die("invalid timeout value '%s'", optarg);
6333 break;
6334 case 'c':
6335 flags |= DLADM_WLAN_CONNECT_CREATEIBSS;
6336 flags |= DLADM_WLAN_CONNECT_CREATEIBSS;
6337 break;
6338 default:
6339 die_opterr(optopt, option, use);
6340 break;
6341 }
6342 }
6343
6344 if (keysecmode == DLADM_WLAN_SECMODE_NONE) {
6345 if ((attr.wa_valid & DLADM_WLAN_ATTR_SECMODE) != 0) {
6346 die("key required for security mode '%s'",
6347 dladm_wlan_secmode2str(&attr.wa_secmode, buf));
6348 }
6349 } else {
6350 if ((attr.wa_valid & DLADM_WLAN_ATTR_SECMODE) != 0 &&
6351 attr.wa_secmode != keysecmode)
6352 die("incompatible -s and -k options");
6353 attr.wa_valid |= DLADM_WLAN_ATTR_SECMODE;
6354 attr.wa_secmode = keysecmode;
6355 }
6356
6357 if (optind == (argc - 1)) {
6358 if ((status = dladm_name2info(handle, argv[optind], &linkid,
6359 NULL, NULL, NULL)) != DLADM_STATUS_OK) {
6360 die_dlerr(status, "link %s is not valid", argv[optind]);
6361 }
6362 } else if (optind != argc) {
6363 usage();
6364 }
6365
6366 if (linkid == DATALINK_ALL_LINKID) {
6367 wlan_count_attr_t wcattr;
6368
6369 wcattr.wc_linkid = DATALINK_INVALID_LINKID;
6370 wcattr.wc_count = 0;
6371 (void) dladm_walk_datalink_id(do_count_wlan, handle, &wcattr,
6372 DATALINK_CLASS_PHYS | DATALINK_CLASS_SIMNET,
6373 DL_WIFI, DLADM_OPT_ACTIVE);
6374 if (wcattr.wc_count == 0) {
6375 die("no wifi links are available");
6376 } else if (wcattr.wc_count > 1) {
6377 die("link name is required when more than one wifi "
6378 "link is available");
6379 }
6380 linkid = wcattr.wc_linkid;
6381 }
6382 attrp = (attr.wa_valid == 0) ? NULL : &attr;
6383 again:
6384 if ((status = dladm_wlan_connect(handle, linkid, attrp, timeout, keys,
6385 key_count, flags)) != DLADM_STATUS_OK) {
6386 if ((flags & DLADM_WLAN_CONNECT_NOSCAN) != 0) {
6387 /*
6388 * Try again with scanning and filtering.
6389 */
6390 flags &= ~DLADM_WLAN_CONNECT_NOSCAN;
6391 goto again;
6392 }
6393
6394 if (status == DLADM_STATUS_NOTFOUND) {
6395 if (attr.wa_valid == 0) {
6396 die("no wifi networks are available");
6397 } else {
6398 die("no wifi networks with the specified "
6399 "criteria are available");
6400 }
6401 }
6402 die_dlerr(status, "cannot connect");
6403 }
6404 free(keys);
6405 }
6406
6407 /* ARGSUSED */
6408 static int
6409 do_all_disconnect_wifi(dladm_handle_t dh, datalink_id_t linkid, void *arg)
6410 {
6411 dladm_status_t status;
6412
6413 status = dladm_wlan_disconnect(dh, linkid);
6414 if (status != DLADM_STATUS_OK)
6415 warn_dlerr(status, "cannot disconnect link");
6416
6417 return (DLADM_WALK_CONTINUE);
6418 }
6419
6420 static void
6421 do_disconnect_wifi(int argc, char **argv, const char *use)
6422 {
6423 int option;
6424 datalink_id_t linkid = DATALINK_ALL_LINKID;
6425 boolean_t all_links = B_FALSE;
6426 dladm_status_t status;
6427 wlan_count_attr_t wcattr;
6428
6429 opterr = 0;
6430 while ((option = getopt_long(argc, argv, ":a",
6431 wifi_longopts, NULL)) != -1) {
6432 switch (option) {
6433 case 'a':
6434 all_links = B_TRUE;
6435 break;
6436 default:
6437 die_opterr(optopt, option, use);
6438 break;
6439 }
6440 }
6441
6442 if (optind == (argc - 1)) {
6443 if ((status = dladm_name2info(handle, argv[optind], &linkid,
6444 NULL, NULL, NULL)) != DLADM_STATUS_OK) {
6445 die_dlerr(status, "link %s is not valid", argv[optind]);
6446 }
6447 } else if (optind != argc) {
6448 usage();
6449 }
6450
6451 if (linkid == DATALINK_ALL_LINKID) {
6452 if (!all_links) {
6453 wcattr.wc_linkid = linkid;
6454 wcattr.wc_count = 0;
6455 (void) dladm_walk_datalink_id(do_count_wlan, handle,
6456 &wcattr,
6457 DATALINK_CLASS_PHYS | DATALINK_CLASS_SIMNET,
6458 DL_WIFI, DLADM_OPT_ACTIVE);
6459 if (wcattr.wc_count == 0) {
6460 die("no wifi links are available");
6461 } else if (wcattr.wc_count > 1) {
6462 die("link name is required when more than "
6463 "one wifi link is available");
6464 }
6465 linkid = wcattr.wc_linkid;
6466 } else {
6467 (void) dladm_walk_datalink_id(do_all_disconnect_wifi,
6468 handle, NULL,
6469 DATALINK_CLASS_PHYS | DATALINK_CLASS_SIMNET,
6470 DL_WIFI, DLADM_OPT_ACTIVE);
6471 return;
6472 }
6473 }
6474 status = dladm_wlan_disconnect(handle, linkid);
6475 if (status != DLADM_STATUS_OK)
6476 die_dlerr(status, "cannot disconnect");
6477 }
6478
6479 static void
6480 print_linkprop(datalink_id_t linkid, show_linkprop_state_t *statep,
6481 const char *propname, dladm_prop_type_t type, const char *format,
6482 char **pptr)
6483 {
6484 int i;
6485 char *ptr, *lim;
6486 char buf[DLADM_STRSIZE];
6487 char *unknown = "--", *notsup = "";
6488 char **propvals = statep->ls_propvals;
6489 uint_t valcnt = DLADM_MAX_PROP_VALCNT;
6490 dladm_status_t status;
6491
6492 status = dladm_get_linkprop(handle, linkid, type, propname, propvals,
6493 &valcnt);
6494 if (status != DLADM_STATUS_OK) {
6495 if (status == DLADM_STATUS_TEMPONLY) {
6496 if (type == DLADM_PROP_VAL_MODIFIABLE &&
6497 statep->ls_persist) {
6498 valcnt = 1;
6499 propvals = &unknown;
6500 } else {
6501 statep->ls_status = status;
6502 statep->ls_retstatus = status;
6503 return;
6504 }
6505 } else if (status == DLADM_STATUS_NOTSUP ||
6506 statep->ls_persist) {
6507 valcnt = 1;
6508 if (type == DLADM_PROP_VAL_CURRENT ||
6509 type == DLADM_PROP_VAL_PERM)
6510 propvals = &unknown;
6511 else
6512 propvals = &notsup;
6513 } else if (status == DLADM_STATUS_NOTDEFINED) {
6514 propvals = &notsup; /* STR_UNDEF_VAL */
6515 } else {
6516 if (statep->ls_proplist &&
6517 statep->ls_status == DLADM_STATUS_OK) {
6518 warn_dlerr(status,
6519 "cannot get link property '%s' for %s",
6520 propname, statep->ls_link);
6521 }
6522 statep->ls_status = status;
6523 statep->ls_retstatus = status;
6524 return;
6525 }
6526 }
6527
6528 statep->ls_status = DLADM_STATUS_OK;
6529
6530 buf[0] = '\0';
6531 ptr = buf;
6532 lim = buf + DLADM_STRSIZE;
6533 for (i = 0; i < valcnt; i++) {
6534 if (propvals[i][0] == '\0' && !statep->ls_parsable)
6535 ptr += snprintf(ptr, lim - ptr, "--,");
6536 else
6537 ptr += snprintf(ptr, lim - ptr, "%s,", propvals[i]);
6538 if (ptr >= lim)
6539 break;
6540 }
6541 if (valcnt > 0)
6542 buf[strlen(buf) - 1] = '\0';
6543
6544 lim = statep->ls_line + MAX_PROP_LINE;
6545 if (statep->ls_parsable) {
6546 *pptr += snprintf(*pptr, lim - *pptr,
6547 "%s", buf);
6548 } else {
6549 *pptr += snprintf(*pptr, lim - *pptr, format, buf);
6550 }
6551 }
6552
6553 static boolean_t
6554 print_linkprop_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
6555 {
6556 linkprop_args_t *arg = ofarg->ofmt_cbarg;
6557 char *propname = arg->ls_propname;
6558 show_linkprop_state_t *statep = arg->ls_state;
6559 char *ptr = statep->ls_line;
6560 char *lim = ptr + MAX_PROP_LINE;
6561 datalink_id_t linkid = arg->ls_linkid;
6562
6563 switch (ofarg->ofmt_id) {
6564 case LINKPROP_LINK:
6565 (void) snprintf(ptr, lim - ptr, "%s", statep->ls_link);
6566 break;
6567 case LINKPROP_PROPERTY:
6568 (void) snprintf(ptr, lim - ptr, "%s", propname);
6569 break;
6570 case LINKPROP_VALUE:
6571 print_linkprop(linkid, statep, propname,
6572 statep->ls_persist ? DLADM_PROP_VAL_PERSISTENT :
6573 DLADM_PROP_VAL_CURRENT, "%s", &ptr);
6574 /*
6575 * If we failed to query the link property, for example, query
6576 * the persistent value of a non-persistable link property,
6577 * simply skip the output.
6578 */
6579 if (statep->ls_status != DLADM_STATUS_OK) {
6580 /*
6581 * Ignore the temponly error when we skip printing
6582 * link properties to avoid returning failure on exit.
6583 */
6584 if (statep->ls_retstatus == DLADM_STATUS_TEMPONLY)
6585 statep->ls_retstatus = DLADM_STATUS_OK;
6586 goto skip;
6587 }
6588 ptr = statep->ls_line;
6589 break;
6590 case LINKPROP_PERM:
6591 print_linkprop(linkid, statep, propname,
6592 DLADM_PROP_VAL_PERM, "%s", &ptr);
6593 if (statep->ls_status != DLADM_STATUS_OK)
6594 goto skip;
6595 ptr = statep->ls_line;
6596 break;
6597 case LINKPROP_DEFAULT:
6598 print_linkprop(linkid, statep, propname,
6599 DLADM_PROP_VAL_DEFAULT, "%s", &ptr);
6600 if (statep->ls_status != DLADM_STATUS_OK)
6601 goto skip;
6602 ptr = statep->ls_line;
6603 break;
6604 case LINKPROP_POSSIBLE:
6605 print_linkprop(linkid, statep, propname,
6606 DLADM_PROP_VAL_MODIFIABLE, "%s ", &ptr);
6607 if (statep->ls_status != DLADM_STATUS_OK)
6608 goto skip;
6609 ptr = statep->ls_line;
6610 break;
6611 default:
6612 die("invalid input");
6613 break;
6614 }
6615 (void) strlcpy(buf, ptr, bufsize);
6616 return (B_TRUE);
6617 skip:
6618 return ((statep->ls_status == DLADM_STATUS_OK) ?
6619 B_TRUE : B_FALSE);
6620 }
6621
6622 static boolean_t
6623 linkprop_is_supported(datalink_id_t linkid, const char *propname,
6624 show_linkprop_state_t *statep)
6625 {
6626 dladm_status_t status;
6627 uint_t valcnt = DLADM_MAX_PROP_VALCNT;
6628
6629 /* if used with -p flag, always print output */
6630 if (statep->ls_proplist != NULL)
6631 return (B_TRUE);
6632
6633 status = dladm_get_linkprop(handle, linkid, DLADM_PROP_VAL_DEFAULT,
6634 propname, statep->ls_propvals, &valcnt);
6635
6636 if (status == DLADM_STATUS_OK)
6637 return (B_TRUE);
6638
6639 /*
6640 * A system wide default value is not available for the
6641 * property. Check if current value can be retrieved.
6642 */
6643 status = dladm_get_linkprop(handle, linkid, DLADM_PROP_VAL_CURRENT,
6644 propname, statep->ls_propvals, &valcnt);
6645
6646 return (status == DLADM_STATUS_OK);
6647 }
6648
6649 /* ARGSUSED */
6650 static int
6651 show_linkprop(dladm_handle_t dh, datalink_id_t linkid, const char *propname,
6652 void *arg)
6653 {
6654 show_linkprop_state_t *statep = arg;
6655 linkprop_args_t ls_arg;
6656
6657 bzero(&ls_arg, sizeof (ls_arg));
6658 ls_arg.ls_state = statep;
6659 ls_arg.ls_propname = (char *)propname;
6660 ls_arg.ls_linkid = linkid;
6661
6662 /*
6663 * This will need to be fixed when kernel interfaces are added
6664 * to enable walking of all known private properties. For now,
6665 * we are limited to walking persistent private properties only.
6666 */
6667 if ((propname[0] == '_') && !statep->ls_persist &&
6668 (statep->ls_proplist == NULL))
6669 return (DLADM_WALK_CONTINUE);
6670 if (!statep->ls_parsable &&
6671 !linkprop_is_supported(linkid, propname, statep))
6672 return (DLADM_WALK_CONTINUE);
6673
6674 ofmt_print(statep->ls_ofmt, &ls_arg);
6675
6676 return (DLADM_WALK_CONTINUE);
6677 }
6678
6679 static void
6680 do_show_linkprop(int argc, char **argv, const char *use)
6681 {
6682 int option;
6683 char propstr[DLADM_STRSIZE];
6684 dladm_arg_list_t *proplist = NULL;
6685 datalink_id_t linkid = DATALINK_ALL_LINKID;
6686 show_linkprop_state_t state;
6687 uint32_t flags = DLADM_OPT_ACTIVE;
6688 dladm_status_t status;
6689 char *fields_str = NULL;
6690 ofmt_handle_t ofmt;
6691 ofmt_status_t oferr;
6692 uint_t ofmtflags = 0;
6693
6694 bzero(propstr, DLADM_STRSIZE);
6695 opterr = 0;
6696 state.ls_propvals = NULL;
6697 state.ls_line = NULL;
6698 state.ls_parsable = B_FALSE;
6699 state.ls_persist = B_FALSE;
6700 state.ls_header = B_TRUE;
6701 state.ls_retstatus = DLADM_STATUS_OK;
6702
6703 while ((option = getopt_long(argc, argv, ":p:cPo:",
6704 prop_longopts, NULL)) != -1) {
6705 switch (option) {
6706 case 'p':
6707 (void) strlcat(propstr, optarg, DLADM_STRSIZE);
6708 if (strlcat(propstr, ",", DLADM_STRSIZE) >=
6709 DLADM_STRSIZE)
6710 die("property list too long '%s'", propstr);
6711 break;
6712 case 'c':
6713 state.ls_parsable = B_TRUE;
6714 break;
6715 case 'P':
6716 state.ls_persist = B_TRUE;
6717 flags = DLADM_OPT_PERSIST;
6718 break;
6719 case 'o':
6720 fields_str = optarg;
6721 break;
6722 default:
6723 die_opterr(optopt, option, use);
6724 break;
6725 }
6726 }
6727
6728 if (optind == (argc - 1)) {
6729 if ((status = dladm_name2info(handle, argv[optind], &linkid,
6730 NULL, NULL, NULL)) != DLADM_STATUS_OK) {
6731 die_dlerr(status, "link %s is not valid", argv[optind]);
6732 }
6733 } else if (optind != argc) {
6734 usage();
6735 }
6736
6737 if (dladm_parse_link_props(propstr, &proplist, B_TRUE)
6738 != DLADM_STATUS_OK)
6739 die("invalid link properties specified");
6740 state.ls_proplist = proplist;
6741 state.ls_status = DLADM_STATUS_OK;
6742
6743 if (state.ls_parsable)
6744 ofmtflags |= OFMT_PARSABLE;
6745 else
6746 ofmtflags |= OFMT_WRAP;
6747
6748 oferr = ofmt_open(fields_str, linkprop_fields, ofmtflags, 0, &ofmt);
6749 ofmt_check(oferr, state.ls_parsable, ofmt, die, warn);
6750 state.ls_ofmt = ofmt;
6751
6752 if (linkid == DATALINK_ALL_LINKID) {
6753 (void) dladm_walk_datalink_id(show_linkprop_onelink, handle,
6754 &state, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE, flags);
6755 } else {
6756 (void) show_linkprop_onelink(handle, linkid, &state);
6757 }
6758 ofmt_close(ofmt);
6759 dladm_free_props(proplist);
6760
6761 if (state.ls_retstatus != DLADM_STATUS_OK) {
6762 dladm_close(handle);
6763 exit(EXIT_FAILURE);
6764 }
6765 }
6766
6767 static int
6768 show_linkprop_onelink(dladm_handle_t hdl, datalink_id_t linkid, void *arg)
6769 {
6770 int i;
6771 char *buf;
6772 uint32_t flags;
6773 dladm_arg_list_t *proplist = NULL;
6774 show_linkprop_state_t *statep = arg;
6775 dlpi_handle_t dh = NULL;
6776
6777 statep->ls_status = DLADM_STATUS_OK;
6778
6779 if (dladm_datalink_id2info(hdl, linkid, &flags, NULL, NULL,
6780 statep->ls_link, MAXLINKNAMELEN) != DLADM_STATUS_OK) {
6781 statep->ls_status = DLADM_STATUS_NOTFOUND;
6782 return (DLADM_WALK_CONTINUE);
6783 }
6784
6785 if ((statep->ls_persist && !(flags & DLADM_OPT_PERSIST)) ||
6786 (!statep->ls_persist && !(flags & DLADM_OPT_ACTIVE))) {
6787 statep->ls_status = DLADM_STATUS_BADARG;
6788 return (DLADM_WALK_CONTINUE);
6789 }
6790
6791 proplist = statep->ls_proplist;
6792
6793 /*
6794 * When some WiFi links are opened for the first time, their hardware
6795 * automatically scans for APs and does other slow operations. Thus,
6796 * if there are no open links, the retrieval of link properties
6797 * (below) will proceed slowly unless we hold the link open.
6798 *
6799 * Note that failure of dlpi_open() does not necessarily mean invalid
6800 * link properties, because dlpi_open() may fail because of incorrect
6801 * autopush configuration. Therefore, we ingore the return value of
6802 * dlpi_open().
6803 */
6804 if (!statep->ls_persist)
6805 (void) dlpi_open(statep->ls_link, &dh, 0);
6806
6807 buf = malloc((sizeof (char *) + DLADM_PROP_VAL_MAX) *
6808 DLADM_MAX_PROP_VALCNT + MAX_PROP_LINE);
6809 if (buf == NULL)
6810 die("insufficient memory");
6811
6812 statep->ls_propvals = (char **)(void *)buf;
6813 for (i = 0; i < DLADM_MAX_PROP_VALCNT; i++) {
6814 statep->ls_propvals[i] = buf +
6815 sizeof (char *) * DLADM_MAX_PROP_VALCNT +
6816 i * DLADM_PROP_VAL_MAX;
6817 }
6818 statep->ls_line = buf +
6819 (sizeof (char *) + DLADM_PROP_VAL_MAX) * DLADM_MAX_PROP_VALCNT;
6820
6821 if (proplist != NULL) {
6822 for (i = 0; i < proplist->al_count; i++) {
6823 (void) show_linkprop(hdl, linkid,
6824 proplist->al_info[i].ai_name, statep);
6825 }
6826 } else {
6827 (void) dladm_walk_linkprop(hdl, linkid, statep,
6828 show_linkprop);
6829 }
6830 if (dh != NULL)
6831 dlpi_close(dh);
6832 free(buf);
6833 return (DLADM_WALK_CONTINUE);
6834 }
6835
6836 static int
6837 reset_one_linkprop(dladm_handle_t dh, datalink_id_t linkid,
6838 const char *propname, void *arg)
6839 {
6840 set_linkprop_state_t *statep = arg;
6841 dladm_status_t status;
6842
6843 status = dladm_set_linkprop(dh, linkid, propname, NULL, 0,
6844 DLADM_OPT_ACTIVE | (statep->ls_temp ? 0 : DLADM_OPT_PERSIST));
6845 if (status != DLADM_STATUS_OK &&
6846 status != DLADM_STATUS_PROPRDONLY &&
6847 status != DLADM_STATUS_NOTSUP) {
6848 warn_dlerr(status, "cannot reset link property '%s' on '%s'",
6849 propname, statep->ls_name);
6850 statep->ls_status = status;
6851 }
6852
6853 return (DLADM_WALK_CONTINUE);
6854 }
6855
6856 static void
6857 set_linkprop(int argc, char **argv, boolean_t reset, const char *use)
6858 {
6859 int i, option;
6860 char errmsg[DLADM_STRSIZE];
6861 char *altroot = NULL;
6862 datalink_id_t linkid;
6863 boolean_t temp = B_FALSE;
6864 dladm_status_t status = DLADM_STATUS_OK;
6865 char propstr[DLADM_STRSIZE];
6866 dladm_arg_list_t *proplist = NULL;
6867
6868 opterr = 0;
6869 bzero(propstr, DLADM_STRSIZE);
6870
6871 while ((option = getopt_long(argc, argv, ":p:R:t",
6872 prop_longopts, NULL)) != -1) {
6873 switch (option) {
6874 case 'p':
6875 (void) strlcat(propstr, optarg, DLADM_STRSIZE);
6876 if (strlcat(propstr, ",", DLADM_STRSIZE) >=
6877 DLADM_STRSIZE)
6878 die("property list too long '%s'", propstr);
6879 break;
6880 case 't':
6881 temp = B_TRUE;
6882 break;
6883 case 'R':
6884 altroot = optarg;
6885 break;
6886 default:
6887 die_opterr(optopt, option, use);
6888
6889 }
6890 }
6891
6892 /* get link name (required last argument) */
6893 if (optind != (argc - 1))
6894 usage();
6895
6896 if (dladm_parse_link_props(propstr, &proplist, reset) !=
6897 DLADM_STATUS_OK)
6898 die("invalid link properties specified");
6899
6900 if (proplist == NULL && !reset)
6901 die("link property must be specified");
6902
6903 if (altroot != NULL) {
6904 dladm_free_props(proplist);
6905 altroot_cmd(altroot, argc, argv);
6906 }
6907
6908 status = dladm_name2info(handle, argv[optind], &linkid, NULL, NULL,
6909 NULL);
6910 if (status != DLADM_STATUS_OK)
6911 die_dlerr(status, "link %s is not valid", argv[optind]);
6912
6913 if (proplist == NULL) {
6914 set_linkprop_state_t state;
6915
6916 state.ls_name = argv[optind];
6917 state.ls_reset = reset;
6918 state.ls_temp = temp;
6919 state.ls_status = DLADM_STATUS_OK;
6920
6921 (void) dladm_walk_linkprop(handle, linkid, &state,
6922 reset_one_linkprop);
6923
6924 status = state.ls_status;
6925 goto done;
6926 }
6927
6928 for (i = 0; i < proplist->al_count; i++) {
6929 dladm_arg_info_t *aip = &proplist->al_info[i];
6930 char **val;
6931 uint_t count;
6932
6933 if (reset) {
6934 val = NULL;
6935 count = 0;
6936 } else {
6937 val = aip->ai_val;
6938 count = aip->ai_count;
6939 if (count == 0) {
6940 warn("no value specified for '%s'",
6941 aip->ai_name);
6942 status = DLADM_STATUS_BADARG;
6943 continue;
6944 }
6945 }
6946 status = dladm_set_linkprop(handle, linkid, aip->ai_name, val,
6947 count, DLADM_OPT_ACTIVE | (temp ? 0 : DLADM_OPT_PERSIST));
6948 switch (status) {
6949 case DLADM_STATUS_OK:
6950 break;
6951 case DLADM_STATUS_NOTFOUND:
6952 warn("invalid link property '%s'", aip->ai_name);
6953 break;
6954 case DLADM_STATUS_BADVAL: {
6955 int j;
6956 char *ptr, *lim;
6957 char **propvals = NULL;
6958 uint_t valcnt = DLADM_MAX_PROP_VALCNT;
6959 dladm_status_t s;
6960
6961 ptr = malloc((sizeof (char *) +
6962 DLADM_PROP_VAL_MAX) * DLADM_MAX_PROP_VALCNT +
6963 MAX_PROP_LINE);
6964
6965 propvals = (char **)(void *)ptr;
6966 if (propvals == NULL)
6967 die("insufficient memory");
6968
6969 for (j = 0; j < DLADM_MAX_PROP_VALCNT; j++) {
6970 propvals[j] = ptr + sizeof (char *) *
6971 DLADM_MAX_PROP_VALCNT +
6972 j * DLADM_PROP_VAL_MAX;
6973 }
6974 s = dladm_get_linkprop(handle, linkid,
6975 DLADM_PROP_VAL_MODIFIABLE, aip->ai_name, propvals,
6976 &valcnt);
6977
6978 if (s != DLADM_STATUS_OK) {
6979 warn_dlerr(status, "cannot set link property "
6980 "'%s' on '%s'", aip->ai_name, argv[optind]);
6981 free(propvals);
6982 break;
6983 }
6984
6985 ptr = errmsg;
6986 lim = ptr + DLADM_STRSIZE;
6987 *ptr = '\0';
6988 for (j = 0; j < valcnt; j++) {
6989 ptr += snprintf(ptr, lim - ptr, "%s,",
6990 propvals[j]);
6991 if (ptr >= lim)
6992 break;
6993 }
6994 if (ptr > errmsg) {
6995 *(ptr - 1) = '\0';
6996 warn("link property '%s' must be one of: %s",
6997 aip->ai_name, errmsg);
6998 } else
6999 warn("invalid link property '%s'", *val);
7000 free(propvals);
7001 break;
7002 }
7003 default:
7004 if (reset) {
7005 warn_dlerr(status, "cannot reset link property "
7006 "'%s' on '%s'", aip->ai_name, argv[optind]);
7007 } else {
7008 warn_dlerr(status, "cannot set link property "
7009 "'%s' on '%s'", aip->ai_name, argv[optind]);
7010 }
7011 break;
7012 }
7013 }
7014 done:
7015 dladm_free_props(proplist);
7016 if (status != DLADM_STATUS_OK) {
7017 dladm_close(handle);
7018 exit(EXIT_FAILURE);
7019 }
7020 }
7021
7022 static void
7023 do_set_linkprop(int argc, char **argv, const char *use)
7024 {
7025 set_linkprop(argc, argv, B_FALSE, use);
7026 }
7027
7028 static void
7029 do_reset_linkprop(int argc, char **argv, const char *use)
7030 {
7031 set_linkprop(argc, argv, B_TRUE, use);
7032 }
7033
7034 static int
7035 convert_secobj(char *buf, uint_t len, uint8_t *obj_val, uint_t *obj_lenp,
7036 dladm_secobj_class_t class)
7037 {
7038 int error = 0;
7039
7040 if (class == DLADM_SECOBJ_CLASS_WPA) {
7041 if (len < 8 || len > 63)
7042 return (EINVAL);
7043 (void) memcpy(obj_val, buf, len);
7044 *obj_lenp = len;
7045 return (error);
7046 }
7047
7048 if (class == DLADM_SECOBJ_CLASS_WEP) {
7049 switch (len) {
7050 case 5: /* ASCII key sizes */
7051 case 13:
7052 (void) memcpy(obj_val, buf, len);
7053 *obj_lenp = len;
7054 break;
7055 case 10: /* Hex key sizes, not preceded by 0x */
7056 case 26:
7057 error = hexascii_to_octet(buf, len, obj_val, obj_lenp);
7058 break;
7059 case 12: /* Hex key sizes, preceded by 0x */
7060 case 28:
7061 if (strncmp(buf, "0x", 2) != 0)
7062 return (EINVAL);
7063 error = hexascii_to_octet(buf + 2, len - 2,
7064 obj_val, obj_lenp);
7065 break;
7066 default:
7067 return (EINVAL);
7068 }
7069 return (error);
7070 }
7071
7072 return (ENOENT);
7073 }
7074
7075 static void
7076 defersig(int sig)
7077 {
7078 signalled = sig;
7079 }
7080
7081 static int
7082 get_secobj_from_tty(uint_t try, const char *objname, char *buf)
7083 {
7084 uint_t len = 0;
7085 int c;
7086 struct termios stored, current;
7087 void (*sigfunc)(int);
7088
7089 /*
7090 * Turn off echo -- but before we do so, defer SIGINT handling
7091 * so that a ^C doesn't leave the terminal corrupted.
7092 */
7093 sigfunc = signal(SIGINT, defersig);
7094 (void) fflush(stdin);
7095 (void) tcgetattr(0, &stored);
7096 current = stored;
7097 current.c_lflag &= ~(ICANON|ECHO);
7098 current.c_cc[VTIME] = 0;
7099 current.c_cc[VMIN] = 1;
7100 (void) tcsetattr(0, TCSANOW, &current);
7101 again:
7102 if (try == 1)
7103 (void) printf(gettext("provide value for '%s': "), objname);
7104 else
7105 (void) printf(gettext("confirm value for '%s': "), objname);
7106
7107 (void) fflush(stdout);
7108 while (signalled == 0) {
7109 c = getchar();
7110 if (c == '\n' || c == '\r') {
7111 if (len != 0)
7112 break;
7113 (void) putchar('\n');
7114 goto again;
7115 }
7116
7117 buf[len++] = c;
7118 if (len >= DLADM_SECOBJ_VAL_MAX - 1)
7119 break;
7120 (void) putchar('*');
7121 }
7122
7123 (void) putchar('\n');
7124 (void) fflush(stdin);
7125
7126 /*
7127 * Restore terminal setting and handle deferred signals.
7128 */
7129 (void) tcsetattr(0, TCSANOW, &stored);
7130
7131 (void) signal(SIGINT, sigfunc);
7132 if (signalled != 0)
7133 (void) kill(getpid(), signalled);
7134
7135 return (len);
7136 }
7137
7138 static int
7139 get_secobj_val(char *obj_name, uint8_t *obj_val, uint_t *obj_lenp,
7140 dladm_secobj_class_t class, FILE *filep)
7141 {
7142 int rval;
7143 uint_t len, len2;
7144 char buf[DLADM_SECOBJ_VAL_MAX], buf2[DLADM_SECOBJ_VAL_MAX];
7145
7146 if (filep == NULL) {
7147 len = get_secobj_from_tty(1, obj_name, buf);
7148 rval = convert_secobj(buf, len, obj_val, obj_lenp, class);
7149 if (rval == 0) {
7150 len2 = get_secobj_from_tty(2, obj_name, buf2);
7151 if (len != len2 || memcmp(buf, buf2, len) != 0)
7152 rval = ENOTSUP;
7153 }
7154 return (rval);
7155 } else {
7156 for (;;) {
7157 if (fgets(buf, sizeof (buf), filep) == NULL)
7158 break;
7159 if (isspace(buf[0]))
7160 continue;
7161
7162 len = strlen(buf);
7163 if (buf[len - 1] == '\n') {
7164 buf[len - 1] = '\0';
7165 len--;
7166 }
7167 break;
7168 }
7169 (void) fclose(filep);
7170 }
7171 return (convert_secobj(buf, len, obj_val, obj_lenp, class));
7172 }
7173
7174 static boolean_t
7175 check_auth(const char *auth)
7176 {
7177 struct passwd *pw;
7178
7179 if ((pw = getpwuid(getuid())) == NULL)
7180 return (B_FALSE);
7181
7182 return (chkauthattr(auth, pw->pw_name) != 0);
7183 }
7184
7185 static void
7186 audit_secobj(char *auth, char *class, char *obj,
7187 boolean_t success, boolean_t create)
7188 {
7189 adt_session_data_t *ah;
7190 adt_event_data_t *event;
7191 au_event_t flag;
7192 char *errstr;
7193
7194 if (create) {
7195 flag = ADT_dladm_create_secobj;
7196 errstr = "ADT_dladm_create_secobj";
7197 } else {
7198 flag = ADT_dladm_delete_secobj;
7199 errstr = "ADT_dladm_delete_secobj";
7200 }
7201
7202 if (adt_start_session(&ah, NULL, ADT_USE_PROC_DATA) != 0)
7203 die("adt_start_session: %s", strerror(errno));
7204
7205 if ((event = adt_alloc_event(ah, flag)) == NULL)
7206 die("adt_alloc_event (%s): %s", errstr, strerror(errno));
7207
7208 /* fill in audit info */
7209 if (create) {
7210 event->adt_dladm_create_secobj.auth_used = auth;
7211 event->adt_dladm_create_secobj.obj_class = class;
7212 event->adt_dladm_create_secobj.obj_name = obj;
7213 } else {
7214 event->adt_dladm_delete_secobj.auth_used = auth;
7215 event->adt_dladm_delete_secobj.obj_class = class;
7216 event->adt_dladm_delete_secobj.obj_name = obj;
7217 }
7218
7219 if (success) {
7220 if (adt_put_event(event, ADT_SUCCESS, ADT_SUCCESS) != 0) {
7221 die("adt_put_event (%s, success): %s", errstr,
7222 strerror(errno));
7223 }
7224 } else {
7225 if (adt_put_event(event, ADT_FAILURE,
7226 ADT_FAIL_VALUE_AUTH) != 0) {
7227 die("adt_put_event: (%s, failure): %s", errstr,
7228 strerror(errno));
7229 }
7230 }
7231
7232 adt_free_event(event);
7233 (void) adt_end_session(ah);
7234 }
7235
7236 static void
7237 do_create_secobj(int argc, char **argv, const char *use)
7238 {
7239 int option, rval;
7240 FILE *filep = NULL;
7241 char *obj_name = NULL;
7242 char *class_name = NULL;
7243 uint8_t obj_val[DLADM_SECOBJ_VAL_MAX];
7244 uint_t obj_len;
7245 boolean_t success, temp = B_FALSE;
7246 dladm_status_t status;
7247 dladm_secobj_class_t class = -1;
7248 uid_t euid;
7249
7250 opterr = 0;
7251 (void) memset(obj_val, 0, DLADM_SECOBJ_VAL_MAX);
7252 while ((option = getopt_long(argc, argv, ":f:c:R:t",
7253 wifi_longopts, NULL)) != -1) {
7254 switch (option) {
7255 case 'f':
7256 euid = geteuid();
7257 (void) seteuid(getuid());
7258 filep = fopen(optarg, "r");
7259 if (filep == NULL) {
7260 die("cannot open %s: %s", optarg,
7261 strerror(errno));
7262 }
7263 (void) seteuid(euid);
7264 break;
7265 case 'c':
7266 class_name = optarg;
7267 status = dladm_str2secobjclass(optarg, &class);
7268 if (status != DLADM_STATUS_OK) {
7269 die("invalid secure object class '%s', "
7270 "valid values are: wep, wpa", optarg);
7271 }
7272 break;
7273 case 't':
7274 temp = B_TRUE;
7275 break;
7276 case 'R':
7277 status = dladm_set_rootdir(optarg);
7278 if (status != DLADM_STATUS_OK) {
7279 die_dlerr(status, "invalid directory "
7280 "specified");
7281 }
7282 break;
7283 default:
7284 die_opterr(optopt, option, use);
7285 break;
7286 }
7287 }
7288
7289 if (optind == (argc - 1))
7290 obj_name = argv[optind];
7291 else if (optind != argc)
7292 usage();
7293
7294 if (class == -1)
7295 die("secure object class required");
7296
7297 if (obj_name == NULL)
7298 die("secure object name required");
7299
7300 if (!dladm_valid_secobj_name(obj_name))
7301 die("invalid secure object name '%s'", obj_name);
7302
7303 success = check_auth(LINK_SEC_AUTH);
7304 audit_secobj(LINK_SEC_AUTH, class_name, obj_name, success, B_TRUE);
7305 if (!success)
7306 die("authorization '%s' is required", LINK_SEC_AUTH);
7307
7308 rval = get_secobj_val(obj_name, obj_val, &obj_len, class, filep);
7309 if (rval != 0) {
7310 switch (rval) {
7311 case ENOENT:
7312 die("invalid secure object class");
7313 break;
7314 case EINVAL:
7315 die("invalid secure object value");
7316 break;
7317 case ENOTSUP:
7318 die("verification failed");
7319 break;
7320 default:
7321 die("invalid secure object: %s", strerror(rval));
7322 break;
7323 }
7324 }
7325
7326 status = dladm_set_secobj(handle, obj_name, class, obj_val, obj_len,
7327 DLADM_OPT_CREATE | DLADM_OPT_ACTIVE);
7328 if (status != DLADM_STATUS_OK) {
7329 die_dlerr(status, "could not create secure object '%s'",
7330 obj_name);
7331 }
7332 if (temp)
7333 return;
7334
7335 status = dladm_set_secobj(handle, obj_name, class, obj_val, obj_len,
7336 DLADM_OPT_PERSIST);
7337 if (status != DLADM_STATUS_OK) {
7338 warn_dlerr(status, "could not persistently create secure "
7339 "object '%s'", obj_name);
7340 }
7341 }
7342
7343 static void
7344 do_delete_secobj(int argc, char **argv, const char *use)
7345 {
7346 int i, option;
7347 boolean_t temp = B_FALSE;
7348 boolean_t success;
7349 dladm_status_t status, pstatus;
7350 int nfields = 1;
7351 char *field, *token, *lasts = NULL, c;
7352
7353 opterr = 0;
7354 status = pstatus = DLADM_STATUS_OK;
7355 while ((option = getopt_long(argc, argv, ":R:t",
7356 wifi_longopts, NULL)) != -1) {
7357 switch (option) {
7358 case 't':
7359 temp = B_TRUE;
7360 break;
7361 case 'R':
7362 status = dladm_set_rootdir(optarg);
7363 if (status != DLADM_STATUS_OK) {
7364 die_dlerr(status, "invalid directory "
7365 "specified");
7366 }
7367 break;
7368 default:
7369 die_opterr(optopt, option, use);
7370 break;
7371 }
7372 }
7373
7374 if (optind != (argc - 1))
7375 die("secure object name required");
7376
7377 token = argv[optind];
7378 while ((c = *token++) != '\0') {
7379 if (c == ',')
7380 nfields++;
7381 }
7382 token = strdup(argv[optind]);
7383 if (token == NULL)
7384 die("no memory");
7385
7386 success = check_auth(LINK_SEC_AUTH);
7387 audit_secobj(LINK_SEC_AUTH, "unknown", argv[optind], success, B_FALSE);
7388 if (!success)
7389 die("authorization '%s' is required", LINK_SEC_AUTH);
7390
7391 for (i = 0; i < nfields; i++) {
7392
7393 field = strtok_r(token, ",", &lasts);
7394 token = NULL;
7395 status = dladm_unset_secobj(handle, field, DLADM_OPT_ACTIVE);
7396 if (!temp) {
7397 pstatus = dladm_unset_secobj(handle, field,
7398 DLADM_OPT_PERSIST);
7399 } else {
7400 pstatus = DLADM_STATUS_OK;
7401 }
7402
7403 if (status != DLADM_STATUS_OK) {
7404 warn_dlerr(status, "could not delete secure object "
7405 "'%s'", field);
7406 }
7407 if (pstatus != DLADM_STATUS_OK) {
7408 warn_dlerr(pstatus, "could not persistently delete "
7409 "secure object '%s'", field);
7410 }
7411 }
7412 free(token);
7413
7414 if (status != DLADM_STATUS_OK || pstatus != DLADM_STATUS_OK) {
7415 dladm_close(handle);
7416 exit(EXIT_FAILURE);
7417 }
7418 }
7419
7420 typedef struct show_secobj_state {
7421 boolean_t ss_persist;
7422 boolean_t ss_parsable;
7423 boolean_t ss_header;
7424 ofmt_handle_t ss_ofmt;
7425 } show_secobj_state_t;
7426
7427
7428 static boolean_t
7429 show_secobj(dladm_handle_t dh, void *arg, const char *obj_name)
7430 {
7431 uint_t obj_len = DLADM_SECOBJ_VAL_MAX;
7432 uint8_t obj_val[DLADM_SECOBJ_VAL_MAX];
7433 char buf[DLADM_STRSIZE];
7434 uint_t flags = 0;
7435 dladm_secobj_class_t class;
7436 show_secobj_state_t *statep = arg;
7437 dladm_status_t status;
7438 secobj_fields_buf_t sbuf;
7439
7440 bzero(&sbuf, sizeof (secobj_fields_buf_t));
7441 if (statep->ss_persist)
7442 flags |= DLADM_OPT_PERSIST;
7443
7444 status = dladm_get_secobj(dh, obj_name, &class, obj_val, &obj_len,
7445 flags);
7446 if (status != DLADM_STATUS_OK)
7447 die_dlerr(status, "cannot get secure object '%s'", obj_name);
7448
7449 (void) snprintf(sbuf.ss_obj_name, sizeof (sbuf.ss_obj_name),
7450 obj_name);
7451 (void) dladm_secobjclass2str(class, buf);
7452 (void) snprintf(sbuf.ss_class, sizeof (sbuf.ss_class), "%s", buf);
7453 if (getuid() == 0) {
7454 char val[DLADM_SECOBJ_VAL_MAX * 2];
7455 uint_t len = sizeof (val);
7456
7457 if (octet_to_hexascii(obj_val, obj_len, val, &len) == 0)
7458 (void) snprintf(sbuf.ss_val,
7459 sizeof (sbuf.ss_val), "%s", val);
7460 }
7461 ofmt_print(statep->ss_ofmt, &sbuf);
7462 return (B_TRUE);
7463 }
7464
7465 static void
7466 do_show_secobj(int argc, char **argv, const char *use)
7467 {
7468 int option;
7469 show_secobj_state_t state;
7470 dladm_status_t status;
7471 boolean_t o_arg = B_FALSE;
7472 uint_t i;
7473 uint_t flags;
7474 char *fields_str = NULL;
7475 char *def_fields = "object,class";
7476 char *all_fields = "object,class,value";
7477 char *field, *token, *lasts = NULL, c;
7478 ofmt_handle_t ofmt;
7479 ofmt_status_t oferr;
7480 uint_t ofmtflags = 0;
7481
7482 opterr = 0;
7483 bzero(&state, sizeof (state));
7484 state.ss_parsable = B_FALSE;
7485 fields_str = def_fields;
7486 state.ss_persist = B_FALSE;
7487 state.ss_parsable = B_FALSE;
7488 state.ss_header = B_TRUE;
7489 while ((option = getopt_long(argc, argv, ":pPo:",
7490 wifi_longopts, NULL)) != -1) {
7491 switch (option) {
7492 case 'p':
7493 state.ss_parsable = B_TRUE;
7494 break;
7495 case 'P':
7496 state.ss_persist = B_TRUE;
7497 break;
7498 case 'o':
7499 o_arg = B_TRUE;
7500 if (strcasecmp(optarg, "all") == 0)
7501 fields_str = all_fields;
7502 else
7503 fields_str = optarg;
7504 break;
7505 default:
7506 die_opterr(optopt, option, use);
7507 break;
7508 }
7509 }
7510
7511 if (state.ss_parsable && !o_arg)
7512 die("option -c requires -o");
7513
7514 if (state.ss_parsable && fields_str == all_fields)
7515 die("\"-o all\" is invalid with -p");
7516
7517 if (state.ss_parsable)
7518 ofmtflags |= OFMT_PARSABLE;
7519 oferr = ofmt_open(fields_str, secobj_fields, ofmtflags, 0, &ofmt);
7520 ofmt_check(oferr, state.ss_parsable, ofmt, die, warn);
7521 state.ss_ofmt = ofmt;
7522
7523 flags = state.ss_persist ? DLADM_OPT_PERSIST : 0;
7524
7525 if (optind == (argc - 1)) {
7526 uint_t obj_fields = 1;
7527
7528 token = argv[optind];
7529 if (token == NULL)
7530 die("secure object name required");
7531 while ((c = *token++) != '\0') {
7532 if (c == ',')
7533 obj_fields++;
7534 }
7535 token = strdup(argv[optind]);
7536 if (token == NULL)
7537 die("no memory");
7538 for (i = 0; i < obj_fields; i++) {
7539 field = strtok_r(token, ",", &lasts);
7540 token = NULL;
7541 if (!show_secobj(handle, &state, field))
7542 break;
7543 }
7544 free(token);
7545 ofmt_close(ofmt);
7546 return;
7547 } else if (optind != argc)
7548 usage();
7549
7550 status = dladm_walk_secobj(handle, &state, show_secobj, flags);
7551
7552 if (status != DLADM_STATUS_OK)
7553 die_dlerr(status, "show-secobj");
7554 ofmt_close(ofmt);
7555 }
7556
7557 /*ARGSUSED*/
7558 static int
7559 i_dladm_init_linkprop(dladm_handle_t dh, datalink_id_t linkid, void *arg)
7560 {
7561 (void) dladm_init_linkprop(dh, linkid, B_TRUE);
7562 return (DLADM_WALK_CONTINUE);
7563 }
7564
7565 /*ARGSUSED*/
7566 void
7567 do_init_linkprop(int argc, char **argv, const char *use)
7568 {
7569 int option;
7570 dladm_status_t status;
7571 datalink_id_t linkid = DATALINK_ALL_LINKID;
7572 datalink_media_t media = DATALINK_ANY_MEDIATYPE;
7573 uint_t any_media = B_TRUE;
7574
7575 opterr = 0;
7576 while ((option = getopt(argc, argv, ":w")) != -1) {
7577 switch (option) {
7578 case 'w':
7579 media = DL_WIFI;
7580 any_media = B_FALSE;
7581 break;
7582 default:
7583 /*
7584 * Because init-linkprop is not a public command,
7585 * print the usage instead.
7586 */
7587 usage();
7588 break;
7589 }
7590 }
7591
7592 if (optind == (argc - 1)) {
7593 if ((status = dladm_name2info(handle, argv[optind], &linkid,
7594 NULL, NULL, NULL)) != DLADM_STATUS_OK)
7595 die_dlerr(status, "link %s is not valid", argv[optind]);
7596 } else if (optind != argc) {
7597 usage();
7598 }
7599
7600 if (linkid == DATALINK_ALL_LINKID) {
7601 /*
7602 * linkprops of links of other classes have been initialized as
7603 * part of the dladm up-xxx operation.
7604 */
7605 (void) dladm_walk_datalink_id(i_dladm_init_linkprop, handle,
7606 NULL, DATALINK_CLASS_PHYS, media, DLADM_OPT_PERSIST);
7607 } else {
7608 (void) dladm_init_linkprop(handle, linkid, any_media);
7609 }
7610 }
7611
7612 static void
7613 do_show_ether(int argc, char **argv, const char *use)
7614 {
7615 int option;
7616 datalink_id_t linkid;
7617 print_ether_state_t state;
7618 char *fields_str = NULL;
7619 ofmt_handle_t ofmt;
7620 ofmt_status_t oferr;
7621 uint_t ofmtflags = 0;
7622
7623 bzero(&state, sizeof (state));
7624 state.es_link = NULL;
7625 state.es_parsable = B_FALSE;
7626
7627 while ((option = getopt_long(argc, argv, "o:px",
7628 showeth_lopts, NULL)) != -1) {
7629 switch (option) {
7630 case 'x':
7631 state.es_extended = B_TRUE;
7632 break;
7633 case 'p':
7634 state.es_parsable = B_TRUE;
7635 break;
7636 case 'o':
7637 fields_str = optarg;
7638 break;
7639 default:
7640 die_opterr(optopt, option, use);
7641 break;
7642 }
7643 }
7644
7645 if (optind == (argc - 1))
7646 state.es_link = argv[optind];
7647
7648 if (state.es_parsable)
7649 ofmtflags |= OFMT_PARSABLE;
7650 oferr = ofmt_open(fields_str, ether_fields, ofmtflags,
7651 DLADM_DEFAULT_COL, &ofmt);
7652 ofmt_check(oferr, state.es_parsable, ofmt, die, warn);
7653 state.es_ofmt = ofmt;
7654
7655 if (state.es_link == NULL) {
7656 (void) dladm_walk_datalink_id(show_etherprop, handle, &state,
7657 DATALINK_CLASS_PHYS, DL_ETHER, DLADM_OPT_ACTIVE);
7658 } else {
7659 if (!link_is_ether(state.es_link, &linkid))
7660 die("invalid link specified");
7661 (void) show_etherprop(handle, linkid, &state);
7662 }
7663 ofmt_close(ofmt);
7664 }
7665
7666 static int
7667 show_etherprop(dladm_handle_t dh, datalink_id_t linkid, void *arg)
7668 {
7669 print_ether_state_t *statep = arg;
7670 ether_fields_buf_t ebuf;
7671 dladm_ether_info_t eattr;
7672 dladm_status_t status;
7673
7674 bzero(&ebuf, sizeof (ether_fields_buf_t));
7675 if (dladm_datalink_id2info(dh, linkid, NULL, NULL, NULL,
7676 ebuf.eth_link, sizeof (ebuf.eth_link)) != DLADM_STATUS_OK) {
7677 return (DLADM_WALK_CONTINUE);
7678 }
7679
7680 status = dladm_ether_info(dh, linkid, &eattr);
7681 if (status != DLADM_STATUS_OK)
7682 goto cleanup;
7683
7684 (void) strlcpy(ebuf.eth_ptype, "current", sizeof (ebuf.eth_ptype));
7685
7686 (void) dladm_ether_autoneg2str(ebuf.eth_autoneg,
7687 sizeof (ebuf.eth_autoneg), &eattr, CURRENT);
7688 (void) dladm_ether_pause2str(ebuf.eth_pause,
7689 sizeof (ebuf.eth_pause), &eattr, CURRENT);
7690 (void) dladm_ether_spdx2str(ebuf.eth_spdx,
7691 sizeof (ebuf.eth_spdx), &eattr, CURRENT);
7692 (void) strlcpy(ebuf.eth_state,
7693 dladm_linkstate2str(eattr.lei_state, ebuf.eth_state),
7694 sizeof (ebuf.eth_state));
7695 (void) strlcpy(ebuf.eth_rem_fault,
7696 (eattr.lei_attr[CURRENT].le_fault ? "fault" : "none"),
7697 sizeof (ebuf.eth_rem_fault));
7698
7699 ofmt_print(statep->es_ofmt, &ebuf);
7700
7701 if (statep->es_extended)
7702 show_ether_xprop(arg, &eattr);
7703
7704 cleanup:
7705 dladm_ether_info_done(&eattr);
7706 return (DLADM_WALK_CONTINUE);
7707 }
7708
7709 /* ARGSUSED */
7710 static void
7711 do_init_secobj(int argc, char **argv, const char *use)
7712 {
7713 dladm_status_t status;
7714
7715 status = dladm_init_secobj(handle);
7716 if (status != DLADM_STATUS_OK)
7717 die_dlerr(status, "secure object initialization failed");
7718 }
7719
7720 enum bridge_func {
7721 brCreate, brAdd, brModify
7722 };
7723
7724 static void
7725 create_modify_add_bridge(int argc, char **argv, const char *use,
7726 enum bridge_func func)
7727 {
7728 int option;
7729 uint_t n, i, nlink;
7730 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
7731 char *altroot = NULL;
7732 char *links[MAXPORT];
7733 datalink_id_t linkids[MAXPORT];
7734 dladm_status_t status;
7735 const char *bridge;
7736 UID_STP_CFG_T cfg, cfg_old;
7737 dladm_bridge_prot_t brprot = DLADM_BRIDGE_PROT_UNKNOWN;
7738 dladm_bridge_prot_t brprot_old;
7739
7740 /* Set up the default configuration values */
7741 cfg.field_mask = 0;
7742 cfg.bridge_priority = DEF_BR_PRIO;
7743 cfg.max_age = DEF_BR_MAXAGE;
7744 cfg.hello_time = DEF_BR_HELLOT;
7745 cfg.forward_delay = DEF_BR_FWDELAY;
7746 cfg.force_version = DEF_FORCE_VERS;
7747
7748 nlink = opterr = 0;
7749 while ((option = getopt_long(argc, argv, ":P:R:d:f:h:l:m:p:",
7750 bridge_lopts, NULL)) != -1) {
7751 switch (option) {
7752 case 'P':
7753 if (func == brAdd)
7754 die_opterr(optopt, option, use);
7755 status = dladm_bridge_str2prot(optarg, &brprot);
7756 if (status != DLADM_STATUS_OK)
7757 die_dlerr(status, "protection %s", optarg);
7758 break;
7759 case 'R':
7760 altroot = optarg;
7761 break;
7762 case 'd':
7763 if (func == brAdd)
7764 die_opterr(optopt, option, use);
7765 if (cfg.field_mask & BR_CFG_DELAY)
7766 die("forwarding delay set more than once");
7767 if (!str2int(optarg, &cfg.forward_delay) ||
7768 cfg.forward_delay < MIN_BR_FWDELAY ||
7769 cfg.forward_delay > MAX_BR_FWDELAY)
7770 die("incorrect forwarding delay");
7771 cfg.field_mask |= BR_CFG_DELAY;
7772 break;
7773 case 'f':
7774 if (func == brAdd)
7775 die_opterr(optopt, option, use);
7776 if (cfg.field_mask & BR_CFG_FORCE_VER)
7777 die("force protocol set more than once");
7778 if (!str2int(optarg, &cfg.force_version) ||
7779 cfg.force_version < 0)
7780 die("incorrect force protocol");
7781 cfg.field_mask |= BR_CFG_FORCE_VER;
7782 break;
7783 case 'h':
7784 if (func == brAdd)
7785 die_opterr(optopt, option, use);
7786 if (cfg.field_mask & BR_CFG_HELLO)
7787 die("hello time set more than once");
7788 if (!str2int(optarg, &cfg.hello_time) ||
7789 cfg.hello_time < MIN_BR_HELLOT ||
7790 cfg.hello_time > MAX_BR_HELLOT)
7791 die("incorrect hello time");
7792 cfg.field_mask |= BR_CFG_HELLO;
7793 break;
7794 case 'l':
7795 if (func == brModify)
7796 die_opterr(optopt, option, use);
7797 if (nlink >= MAXPORT)
7798 die("too many links specified");
7799 links[nlink++] = optarg;
7800 break;
7801 case 'm':
7802 if (func == brAdd)
7803 die_opterr(optopt, option, use);
7804 if (cfg.field_mask & BR_CFG_AGE)
7805 die("max age set more than once");
7806 if (!str2int(optarg, &cfg.max_age) ||
7807 cfg.max_age < MIN_BR_MAXAGE ||
7808 cfg.max_age > MAX_BR_MAXAGE)
7809 die("incorrect max age");
7810 cfg.field_mask |= BR_CFG_AGE;
7811 break;
7812 case 'p':
7813 if (func == brAdd)
7814 die_opterr(optopt, option, use);
7815 if (cfg.field_mask & BR_CFG_PRIO)
7816 die("priority set more than once");
7817 if (!str2int(optarg, &cfg.bridge_priority) ||
7818 cfg.bridge_priority < MIN_BR_PRIO ||
7819 cfg.bridge_priority > MAX_BR_PRIO)
7820 die("incorrect priority");
7821 cfg.bridge_priority &= 0xF000;
7822 cfg.field_mask |= BR_CFG_PRIO;
7823 break;
7824 default:
7825 die_opterr(optopt, option, use);
7826 break;
7827 }
7828 }
7829
7830 /* get the bridge name (required last argument) */
7831 if (optind != (argc-1))
7832 usage();
7833
7834 bridge = argv[optind];
7835 if (!dladm_valid_bridgename(bridge))
7836 die("invalid bridge name '%s'", bridge);
7837
7838 /*
7839 * Get the current properties, if any, and merge in with changes. This
7840 * is necessary (even with the field_mask feature) so that the
7841 * value-checking macros will produce the right results with proposed
7842 * changes to existing configuration. We only need it for those
7843 * parameters, though.
7844 */
7845 (void) dladm_bridge_get_properties(bridge, &cfg_old, &brprot_old);
7846 if (brprot == DLADM_BRIDGE_PROT_UNKNOWN)
7847 brprot = brprot_old;
7848 if (!(cfg.field_mask & BR_CFG_AGE))
7849 cfg.max_age = cfg_old.max_age;
7850 if (!(cfg.field_mask & BR_CFG_HELLO))
7851 cfg.hello_time = cfg_old.hello_time;
7852 if (!(cfg.field_mask & BR_CFG_DELAY))
7853 cfg.forward_delay = cfg_old.forward_delay;
7854
7855 if (!CHECK_BRIDGE_CONFIG(cfg)) {
7856 warn("illegal forward delay / max age / hello time "
7857 "combination");
7858 if (NO_MAXAGE(cfg)) {
7859 die("no max age possible: need forward delay >= %d or "
7860 "hello time <= %d", MIN_FWDELAY_NOM(cfg),
7861 MAX_HELLOTIME_NOM(cfg));
7862 } else if (SMALL_MAXAGE(cfg)) {
7863 if (CAPPED_MAXAGE(cfg))
7864 die("max age too small: need age >= %d and "
7865 "<= %d or hello time <= %d",
7866 MIN_MAXAGE(cfg), MAX_MAXAGE(cfg),
7867 MAX_HELLOTIME(cfg));
7868 else
7869 die("max age too small: need age >= %d or "
7870 "hello time <= %d",
7871 MIN_MAXAGE(cfg), MAX_HELLOTIME(cfg));
7872 } else if (FLOORED_MAXAGE(cfg)) {
7873 die("max age too large: need age >= %d and <= %d or "
7874 "forward delay >= %d",
7875 MIN_MAXAGE(cfg), MAX_MAXAGE(cfg),
7876 MIN_FWDELAY(cfg));
7877 } else {
7878 die("max age too large: need age <= %d or forward "
7879 "delay >= %d",
7880 MAX_MAXAGE(cfg), MIN_FWDELAY(cfg));
7881 }
7882 }
7883
7884 if (altroot != NULL)
7885 altroot_cmd(altroot, argc, argv);
7886
7887 for (n = 0; n < nlink; n++) {
7888 datalink_class_t class;
7889 uint32_t media;
7890 char pointless[DLADM_STRSIZE];
7891
7892 if (dladm_name2info(handle, links[n], &linkids[n], NULL, &class,
7893 &media) != DLADM_STATUS_OK)
7894 die("invalid link name '%s'", links[n]);
7895 if (class & ~(DATALINK_CLASS_PHYS | DATALINK_CLASS_AGGR |
7896 DATALINK_CLASS_ETHERSTUB | DATALINK_CLASS_SIMNET))
7897 die("%s %s cannot be bridged",
7898 dladm_class2str(class, pointless), links[n]);
7899 if (media != DL_ETHER && media != DL_100VG &&
7900 media != DL_ETH_CSMA && media != DL_100BT)
7901 die("%s interface %s cannot be bridged",
7902 dladm_media2str(media, pointless), links[n]);
7903 }
7904
7905 if (func == brCreate)
7906 flags |= DLADM_OPT_CREATE;
7907
7908 if (func != brAdd) {
7909 status = dladm_bridge_configure(handle, bridge, &cfg, brprot,
7910 flags);
7911 if (status != DLADM_STATUS_OK)
7912 die_dlerr(status, "create operation failed");
7913 }
7914
7915 status = DLADM_STATUS_OK;
7916 for (n = 0; n < nlink; n++) {
7917 status = dladm_bridge_setlink(handle, linkids[n], bridge);
7918 if (status != DLADM_STATUS_OK)
7919 break;
7920 }
7921
7922 if (n >= nlink) {
7923 /*
7924 * We were successful. If we're creating a new bridge, then
7925 * there's just one more step: enabling. If we're modifying or
7926 * just adding links, then we're done.
7927 */
7928 if (func != brCreate ||
7929 (status = dladm_bridge_enable(bridge)) == DLADM_STATUS_OK)
7930 return;
7931 }
7932
7933 /* clean up the partial configuration */
7934 for (i = 0; i < n; i++)
7935 (void) dladm_bridge_setlink(handle, linkids[i], "");
7936
7937 /* if failure for brCreate, then delete the bridge */
7938 if (func == brCreate)
7939 (void) dladm_bridge_delete(handle, bridge, flags);
7940
7941 if (n < nlink)
7942 die_dlerr(status, "unable to add link %s to bridge %s",
7943 links[n], bridge);
7944 else
7945 die_dlerr(status, "unable to enable bridge %s", bridge);
7946 }
7947
7948 static void
7949 do_create_bridge(int argc, char **argv, const char *use)
7950 {
7951 create_modify_add_bridge(argc, argv, use, brCreate);
7952 }
7953
7954 static void
7955 do_modify_bridge(int argc, char **argv, const char *use)
7956 {
7957 create_modify_add_bridge(argc, argv, use, brModify);
7958 }
7959
7960 static void
7961 do_add_bridge(int argc, char **argv, const char *use)
7962 {
7963 create_modify_add_bridge(argc, argv, use, brAdd);
7964 }
7965
7966 static void
7967 do_delete_bridge(int argc, char **argv, const char *use)
7968 {
7969 char option;
7970 char *altroot = NULL;
7971 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
7972 dladm_status_t status;
7973
7974 opterr = 0;
7975 while ((option = getopt_long(argc, argv, ":R:", bridge_lopts, NULL)) !=
7976 -1) {
7977 switch (option) {
7978 case 'R':
7979 altroot = optarg;
7980 break;
7981 default:
7982 die_opterr(optopt, option, use);
7983 break;
7984 }
7985 }
7986
7987 /* get the bridge name (required last argument) */
7988 if (optind != (argc-1))
7989 usage();
7990
7991 if (altroot != NULL)
7992 altroot_cmd(altroot, argc, argv);
7993
7994 status = dladm_bridge_delete(handle, argv[optind], flags);
7995 if (status != DLADM_STATUS_OK)
7996 die_dlerr(status, "delete operation failed");
7997 }
7998
7999 static void
8000 do_remove_bridge(int argc, char **argv, const char *use)
8001 {
8002 char option;
8003 uint_t n, nlink;
8004 char *links[MAXPORT];
8005 datalink_id_t linkids[MAXPORT];
8006 char *altroot = NULL;
8007 dladm_status_t status;
8008 boolean_t removed_one;
8009
8010 nlink = opterr = 0;
8011 while ((option = getopt_long(argc, argv, ":R:l:", bridge_lopts,
8012 NULL)) != -1) {
8013 switch (option) {
8014 case 'R':
8015 altroot = optarg;
8016 break;
8017 case 'l':
8018 if (nlink >= MAXPORT)
8019 die("too many links specified");
8020 links[nlink++] = optarg;
8021 break;
8022 default:
8023 die_opterr(optopt, option, use);
8024 break;
8025 }
8026 }
8027
8028 if (nlink == 0)
8029 usage();
8030
8031 /* get the bridge name (required last argument) */
8032 if (optind != (argc-1))
8033 usage();
8034
8035 if (altroot != NULL)
8036 altroot_cmd(altroot, argc, argv);
8037
8038 for (n = 0; n < nlink; n++) {
8039 char bridge[MAXLINKNAMELEN];
8040
8041 if (dladm_name2info(handle, links[n], &linkids[n], NULL, NULL,
8042 NULL) != DLADM_STATUS_OK)
8043 die("invalid link name '%s'", links[n]);
8044 status = dladm_bridge_getlink(handle, linkids[n], bridge,
8045 sizeof (bridge));
8046 if (status != DLADM_STATUS_OK &&
8047 status != DLADM_STATUS_NOTFOUND) {
8048 die_dlerr(status, "cannot get bridge status on %s",
8049 links[n]);
8050 }
8051 if (status == DLADM_STATUS_NOTFOUND ||
8052 strcmp(bridge, argv[optind]) != 0)
8053 die("link %s is not on bridge %s", links[n],
8054 argv[optind]);
8055 }
8056
8057 removed_one = B_FALSE;
8058 for (n = 0; n < nlink; n++) {
8059 status = dladm_bridge_setlink(handle, linkids[n], "");
8060 if (status == DLADM_STATUS_OK) {
8061 removed_one = B_TRUE;
8062 } else {
8063 warn_dlerr(status,
8064 "cannot remove link %s from bridge %s",
8065 links[n], argv[optind]);
8066 }
8067 }
8068 if (!removed_one)
8069 die("unable to remove any links from bridge %s", argv[optind]);
8070 }
8071
8072 static void
8073 fmt_int(char *buf, size_t buflen, int value, int runvalue,
8074 boolean_t printstar)
8075 {
8076 (void) snprintf(buf, buflen, "%d", value);
8077 if (value != runvalue && printstar)
8078 (void) strlcat(buf, "*", buflen);
8079 }
8080
8081 static void
8082 fmt_bridge_id(char *buf, size_t buflen, UID_BRIDGE_ID_T *bid)
8083 {
8084 (void) snprintf(buf, buflen, "%u/%x:%x:%x:%x:%x:%x", bid->prio,
8085 bid->addr[0], bid->addr[1], bid->addr[2], bid->addr[3],
8086 bid->addr[4], bid->addr[5]);
8087 }
8088
8089 static dladm_status_t
8090 print_bridge(show_state_t *state, datalink_id_t linkid,
8091 bridge_fields_buf_t *bbuf)
8092 {
8093 char link[MAXLINKNAMELEN];
8094 datalink_class_t class;
8095 uint32_t flags;
8096 dladm_status_t status;
8097 UID_STP_CFG_T smfcfg, runcfg;
8098 UID_STP_STATE_T stpstate;
8099 dladm_bridge_prot_t smfprot, runprot;
8100
8101 if ((status = dladm_datalink_id2info(handle, linkid, &flags, &class,
8102 NULL, link, sizeof (link))) != DLADM_STATUS_OK)
8103 return (status);
8104
8105 if (!(state->ls_flags & flags))
8106 return (DLADM_STATUS_NOTFOUND);
8107
8108 /* Convert observability node name back to bridge name */
8109 if (!dladm_observe_to_bridge(link))
8110 return (DLADM_STATUS_NOTFOUND);
8111 (void) strlcpy(bbuf->bridge_name, link, sizeof (bbuf->bridge_name));
8112
8113 /*
8114 * If the running value differs from the one in SMF, and parsable
8115 * output is not requested, then we show the running value with an
8116 * asterisk.
8117 */
8118 (void) dladm_bridge_get_properties(bbuf->bridge_name, &smfcfg,
8119 &smfprot);
8120 (void) dladm_bridge_run_properties(bbuf->bridge_name, &runcfg,
8121 &runprot);
8122 (void) snprintf(bbuf->bridge_protect, sizeof (bbuf->bridge_protect),
8123 "%s%s", state->ls_parsable || smfprot == runprot ? "" : "*",
8124 dladm_bridge_prot2str(runprot));
8125 fmt_int(bbuf->bridge_priority, sizeof (bbuf->bridge_priority),
8126 smfcfg.bridge_priority, runcfg.bridge_priority,
8127 !state->ls_parsable && (runcfg.field_mask & BR_CFG_AGE));
8128 fmt_int(bbuf->bridge_bmaxage, sizeof (bbuf->bridge_bmaxage),
8129 smfcfg.max_age, runcfg.max_age,
8130 !state->ls_parsable && (runcfg.field_mask & BR_CFG_AGE));
8131 fmt_int(bbuf->bridge_bhellotime,
8132 sizeof (bbuf->bridge_bhellotime), smfcfg.hello_time,
8133 runcfg.hello_time,
8134 !state->ls_parsable && (runcfg.field_mask & BR_CFG_HELLO));
8135 fmt_int(bbuf->bridge_bfwddelay, sizeof (bbuf->bridge_bfwddelay),
8136 smfcfg.forward_delay, runcfg.forward_delay,
8137 !state->ls_parsable && (runcfg.field_mask & BR_CFG_DELAY));
8138 fmt_int(bbuf->bridge_forceproto, sizeof (bbuf->bridge_forceproto),
8139 smfcfg.force_version, runcfg.force_version,
8140 !state->ls_parsable && (runcfg.field_mask & BR_CFG_FORCE_VER));
8141 fmt_int(bbuf->bridge_holdtime, sizeof (bbuf->bridge_holdtime),
8142 smfcfg.hold_time, runcfg.hold_time,
8143 !state->ls_parsable && (runcfg.field_mask & BR_CFG_HOLD_TIME));
8144
8145 if (dladm_bridge_state(bbuf->bridge_name, &stpstate) ==
8146 DLADM_STATUS_OK) {
8147 fmt_bridge_id(bbuf->bridge_address,
8148 sizeof (bbuf->bridge_address), &stpstate.bridge_id);
8149 (void) snprintf(bbuf->bridge_tctime,
8150 sizeof (bbuf->bridge_tctime), "%lu",
8151 stpstate.timeSince_Topo_Change);
8152 (void) snprintf(bbuf->bridge_tccount,
8153 sizeof (bbuf->bridge_tccount), "%lu",
8154 stpstate.Topo_Change_Count);
8155 (void) snprintf(bbuf->bridge_tchange,
8156 sizeof (bbuf->bridge_tchange), "%u", stpstate.Topo_Change);
8157 fmt_bridge_id(bbuf->bridge_desroot,
8158 sizeof (bbuf->bridge_desroot), &stpstate.designated_root);
8159 (void) snprintf(bbuf->bridge_rootcost,
8160 sizeof (bbuf->bridge_rootcost), "%lu",
8161 stpstate.root_path_cost);
8162 (void) snprintf(bbuf->bridge_rootport,
8163 sizeof (bbuf->bridge_rootport), "%u", stpstate.root_port);
8164 (void) snprintf(bbuf->bridge_maxage,
8165 sizeof (bbuf->bridge_maxage), "%d", stpstate.max_age);
8166 (void) snprintf(bbuf->bridge_hellotime,
8167 sizeof (bbuf->bridge_hellotime), "%d", stpstate.hello_time);
8168 (void) snprintf(bbuf->bridge_fwddelay,
8169 sizeof (bbuf->bridge_fwddelay), "%d",
8170 stpstate.forward_delay);
8171 }
8172 return (DLADM_STATUS_OK);
8173 }
8174
8175 static dladm_status_t
8176 print_bridge_stats(show_state_t *state, datalink_id_t linkid,
8177 bridge_statfields_buf_t *bbuf)
8178 {
8179 char link[MAXLINKNAMELEN];
8180 datalink_class_t class;
8181 uint32_t flags;
8182 dladm_status_t status;
8183 kstat_ctl_t *kcp;
8184 kstat_t *ksp;
8185 brsum_t *brsum = (brsum_t *)&state->ls_prevstats;
8186 brsum_t newval;
8187
8188 /* This is a compile-time assertion; optimizer normally fixes this */
8189 extern void brsum_t_is_too_large(void);
8190
8191 if (sizeof (*brsum) > sizeof (state->ls_prevstats))
8192 brsum_t_is_too_large();
8193
8194 if (state->ls_firstonly) {
8195 if (state->ls_donefirst)
8196 return (DLADM_WALK_CONTINUE);
8197 state->ls_donefirst = B_TRUE;
8198 } else {
8199 bzero(brsum, sizeof (*brsum));
8200 }
8201 bzero(&newval, sizeof (newval));
8202
8203 if ((status = dladm_datalink_id2info(handle, linkid, &flags, &class,
8204 NULL, link, sizeof (link))) != DLADM_STATUS_OK)
8205 return (status);
8206
8207 if (!(state->ls_flags & flags))
8208 return (DLADM_STATUS_NOTFOUND);
8209
8210 if ((kcp = kstat_open()) == NULL) {
8211 warn("kstat open operation failed");
8212 return (DLADM_STATUS_OK);
8213 }
8214 if ((ksp = kstat_lookup(kcp, "bridge", 0, link)) != NULL &&
8215 kstat_read(kcp, ksp, NULL) != -1) {
8216 if (dladm_kstat_value(ksp, "drops", KSTAT_DATA_UINT64,
8217 &newval.drops) == DLADM_STATUS_OK) {
8218 (void) snprintf(bbuf->bridges_drops,
8219 sizeof (bbuf->bridges_drops), "%llu",
8220 newval.drops - brsum->drops);
8221 }
8222 if (dladm_kstat_value(ksp, "forward_direct", KSTAT_DATA_UINT64,
8223 &newval.forward_dir) == DLADM_STATUS_OK) {
8224 (void) snprintf(bbuf->bridges_forwards,
8225 sizeof (bbuf->bridges_forwards), "%llu",
8226 newval.forward_dir - brsum->forward_dir);
8227 }
8228 if (dladm_kstat_value(ksp, "forward_mbcast", KSTAT_DATA_UINT64,
8229 &newval.forward_mb) == DLADM_STATUS_OK) {
8230 (void) snprintf(bbuf->bridges_mbcast,
8231 sizeof (bbuf->bridges_mbcast), "%llu",
8232 newval.forward_mb - brsum->forward_mb);
8233 }
8234 if (dladm_kstat_value(ksp, "forward_unknown", KSTAT_DATA_UINT64,
8235 &newval.forward_unk) == DLADM_STATUS_OK) {
8236 (void) snprintf(bbuf->bridges_unknown,
8237 sizeof (bbuf->bridges_unknown), "%llu",
8238 newval.forward_unk - brsum->forward_unk);
8239 }
8240 if (dladm_kstat_value(ksp, "recv", KSTAT_DATA_UINT64,
8241 &newval.recv) == DLADM_STATUS_OK) {
8242 (void) snprintf(bbuf->bridges_recv,
8243 sizeof (bbuf->bridges_recv), "%llu",
8244 newval.recv - brsum->recv);
8245 }
8246 if (dladm_kstat_value(ksp, "sent", KSTAT_DATA_UINT64,
8247 &newval.sent) == DLADM_STATUS_OK) {
8248 (void) snprintf(bbuf->bridges_sent,
8249 sizeof (bbuf->bridges_sent), "%llu",
8250 newval.sent - brsum->sent);
8251 }
8252 }
8253 (void) kstat_close(kcp);
8254
8255 /* Convert observability node name back to bridge name */
8256 if (!dladm_observe_to_bridge(link))
8257 return (DLADM_STATUS_NOTFOUND);
8258 (void) strlcpy(bbuf->bridges_name, link, sizeof (bbuf->bridges_name));
8259
8260 *brsum = newval;
8261
8262 return (DLADM_STATUS_OK);
8263 }
8264
8265 /*
8266 * This structure carries around extra state information for the show-bridge
8267 * command and allows us to use common support functions.
8268 */
8269 typedef struct {
8270 show_state_t state;
8271 boolean_t show_stats;
8272 const char *bridge;
8273 } show_brstate_t;
8274
8275 /* ARGSUSED */
8276 static int
8277 show_bridge(dladm_handle_t handle, datalink_id_t linkid, void *arg)
8278 {
8279 show_brstate_t *brstate = arg;
8280 void *buf;
8281
8282 if (brstate->show_stats) {
8283 bridge_statfields_buf_t bbuf;
8284
8285 bzero(&bbuf, sizeof (bbuf));
8286 brstate->state.ls_status = print_bridge_stats(&brstate->state,
8287 linkid, &bbuf);
8288 buf = &bbuf;
8289 } else {
8290 bridge_fields_buf_t bbuf;
8291
8292 bzero(&bbuf, sizeof (bbuf));
8293 brstate->state.ls_status = print_bridge(&brstate->state, linkid,
8294 &bbuf);
8295 buf = &bbuf;
8296 }
8297 if (brstate->state.ls_status == DLADM_STATUS_OK)
8298 ofmt_print(brstate->state.ls_ofmt, buf);
8299 return (DLADM_WALK_CONTINUE);
8300 }
8301
8302 static void
8303 fmt_bool(char *buf, size_t buflen, int val)
8304 {
8305 (void) strlcpy(buf, val ? "yes" : "no", buflen);
8306 }
8307
8308 static dladm_status_t
8309 print_bridge_link(show_state_t *state, datalink_id_t linkid,
8310 bridge_link_fields_buf_t *bbuf)
8311 {
8312 datalink_class_t class;
8313 uint32_t flags;
8314 dladm_status_t status;
8315 UID_STP_PORT_STATE_T stpstate;
8316
8317 status = dladm_datalink_id2info(handle, linkid, &flags, &class, NULL,
8318 bbuf->bridgel_link, sizeof (bbuf->bridgel_link));
8319 if (status != DLADM_STATUS_OK)
8320 return (status);
8321
8322 if (!(state->ls_flags & flags))
8323 return (DLADM_STATUS_NOTFOUND);
8324
8325 if (dladm_bridge_link_state(handle, linkid, &stpstate) ==
8326 DLADM_STATUS_OK) {
8327 (void) snprintf(bbuf->bridgel_index,
8328 sizeof (bbuf->bridgel_index), "%u", stpstate.port_no);
8329 if (dlsym(RTLD_PROBE, "STP_IN_state2str")) {
8330 (void) strlcpy(bbuf->bridgel_state,
8331 STP_IN_state2str(stpstate.state),
8332 sizeof (bbuf->bridgel_state));
8333 } else {
8334 (void) snprintf(bbuf->bridgel_state,
8335 sizeof (bbuf->bridgel_state), "%u",
8336 stpstate.state);
8337 }
8338 (void) snprintf(bbuf->bridgel_uptime,
8339 sizeof (bbuf->bridgel_uptime), "%lu", stpstate.uptime);
8340 (void) snprintf(bbuf->bridgel_opercost,
8341 sizeof (bbuf->bridgel_opercost), "%lu",
8342 stpstate.oper_port_path_cost);
8343 fmt_bool(bbuf->bridgel_operp2p, sizeof (bbuf->bridgel_operp2p),
8344 stpstate.oper_point2point);
8345 fmt_bool(bbuf->bridgel_operedge,
8346 sizeof (bbuf->bridgel_operedge), stpstate.oper_edge);
8347 fmt_bridge_id(bbuf->bridgel_desroot,
8348 sizeof (bbuf->bridgel_desroot), &stpstate.designated_root);
8349 (void) snprintf(bbuf->bridgel_descost,
8350 sizeof (bbuf->bridgel_descost), "%lu",
8351 stpstate.designated_cost);
8352 fmt_bridge_id(bbuf->bridgel_desbridge,
8353 sizeof (bbuf->bridgel_desbridge),
8354 &stpstate.designated_bridge);
8355 (void) snprintf(bbuf->bridgel_desport,
8356 sizeof (bbuf->bridgel_desport), "%u",
8357 stpstate.designated_port);
8358 fmt_bool(bbuf->bridgel_tcack, sizeof (bbuf->bridgel_tcack),
8359 stpstate.top_change_ack);
8360 }
8361 return (DLADM_STATUS_OK);
8362 }
8363
8364 static dladm_status_t
8365 print_bridge_link_stats(show_state_t *state, datalink_id_t linkid,
8366 bridge_link_statfields_buf_t *bbuf)
8367 {
8368 datalink_class_t class;
8369 uint32_t flags;
8370 dladm_status_t status;
8371 UID_STP_PORT_STATE_T stpstate;
8372 kstat_ctl_t *kcp;
8373 kstat_t *ksp;
8374 char bridge[MAXLINKNAMELEN];
8375 char kstatname[MAXLINKNAMELEN*2 + 1];
8376 brlsum_t *brlsum = (brlsum_t *)&state->ls_prevstats;
8377 brlsum_t newval;
8378
8379 /* This is a compile-time assertion; optimizer normally fixes this */
8380 extern void brlsum_t_is_too_large(void);
8381
8382 if (sizeof (*brlsum) > sizeof (state->ls_prevstats))
8383 brlsum_t_is_too_large();
8384
8385 if (state->ls_firstonly) {
8386 if (state->ls_donefirst)
8387 return (DLADM_WALK_CONTINUE);
8388 state->ls_donefirst = B_TRUE;
8389 } else {
8390 bzero(brlsum, sizeof (*brlsum));
8391 }
8392 bzero(&newval, sizeof (newval));
8393
8394 status = dladm_datalink_id2info(handle, linkid, &flags, &class, NULL,
8395 bbuf->bridgels_link, sizeof (bbuf->bridgels_link));
8396 if (status != DLADM_STATUS_OK)
8397 return (status);
8398
8399 if (!(state->ls_flags & flags))
8400 return (DLADM_STATUS_NOTFOUND);
8401
8402 if (dladm_bridge_link_state(handle, linkid, &stpstate) ==
8403 DLADM_STATUS_OK) {
8404 newval.cfgbpdu = stpstate.rx_cfg_bpdu_cnt;
8405 newval.tcnbpdu = stpstate.rx_tcn_bpdu_cnt;
8406 newval.rstpbpdu = stpstate.rx_rstp_bpdu_cnt;
8407 newval.txbpdu = stpstate.txCount;
8408
8409 (void) snprintf(bbuf->bridgels_cfgbpdu,
8410 sizeof (bbuf->bridgels_cfgbpdu), "%lu",
8411 newval.cfgbpdu - brlsum->cfgbpdu);
8412 (void) snprintf(bbuf->bridgels_tcnbpdu,
8413 sizeof (bbuf->bridgels_tcnbpdu), "%lu",
8414 newval.tcnbpdu - brlsum->tcnbpdu);
8415 (void) snprintf(bbuf->bridgels_rstpbpdu,
8416 sizeof (bbuf->bridgels_rstpbpdu), "%lu",
8417 newval.rstpbpdu - brlsum->rstpbpdu);
8418 (void) snprintf(bbuf->bridgels_txbpdu,
8419 sizeof (bbuf->bridgels_txbpdu), "%lu",
8420 newval.txbpdu - brlsum->txbpdu);
8421 }
8422
8423 if ((status = dladm_bridge_getlink(handle, linkid, bridge,
8424 sizeof (bridge))) != DLADM_STATUS_OK)
8425 goto bls_out;
8426 (void) snprintf(kstatname, sizeof (kstatname), "%s0-%s", bridge,
8427 bbuf->bridgels_link);
8428 if ((kcp = kstat_open()) == NULL) {
8429 warn("kstat open operation failed");
8430 goto bls_out;
8431 }
8432 if ((ksp = kstat_lookup(kcp, "bridge", 0, kstatname)) != NULL &&
8433 kstat_read(kcp, ksp, NULL) != -1) {
8434 if (dladm_kstat_value(ksp, "drops", KSTAT_DATA_UINT64,
8435 &newval.drops) != -1) {
8436 (void) snprintf(bbuf->bridgels_drops,
8437 sizeof (bbuf->bridgels_drops), "%llu",
8438 newval.drops - brlsum->drops);
8439 }
8440 if (dladm_kstat_value(ksp, "recv", KSTAT_DATA_UINT64,
8441 &newval.recv) != -1) {
8442 (void) snprintf(bbuf->bridgels_recv,
8443 sizeof (bbuf->bridgels_recv), "%llu",
8444 newval.recv - brlsum->recv);
8445 }
8446 if (dladm_kstat_value(ksp, "xmit", KSTAT_DATA_UINT64,
8447 &newval.xmit) != -1) {
8448 (void) snprintf(bbuf->bridgels_xmit,
8449 sizeof (bbuf->bridgels_xmit), "%llu",
8450 newval.xmit - brlsum->xmit);
8451 }
8452 }
8453 (void) kstat_close(kcp);
8454 bls_out:
8455 *brlsum = newval;
8456
8457 return (status);
8458 }
8459
8460 static void
8461 show_bridge_link(datalink_id_t linkid, show_brstate_t *brstate)
8462 {
8463 void *buf;
8464
8465 if (brstate->show_stats) {
8466 bridge_link_statfields_buf_t bbuf;
8467
8468 bzero(&bbuf, sizeof (bbuf));
8469 brstate->state.ls_status = print_bridge_link_stats(
8470 &brstate->state, linkid, &bbuf);
8471 buf = &bbuf;
8472 } else {
8473 bridge_link_fields_buf_t bbuf;
8474
8475 bzero(&bbuf, sizeof (bbuf));
8476 brstate->state.ls_status = print_bridge_link(&brstate->state,
8477 linkid, &bbuf);
8478 buf = &bbuf;
8479 }
8480 if (brstate->state.ls_status == DLADM_STATUS_OK)
8481 ofmt_print(brstate->state.ls_ofmt, buf);
8482 }
8483
8484 /* ARGSUSED */
8485 static int
8486 show_bridge_link_walk(dladm_handle_t handle, datalink_id_t linkid, void *arg)
8487 {
8488 show_brstate_t *brstate = arg;
8489 char bridge[MAXLINKNAMELEN];
8490
8491 if (dladm_bridge_getlink(handle, linkid, bridge, sizeof (bridge)) ==
8492 DLADM_STATUS_OK && strcmp(bridge, brstate->bridge) == 0) {
8493 show_bridge_link(linkid, brstate);
8494 }
8495 return (DLADM_WALK_CONTINUE);
8496 }
8497
8498 static void
8499 show_bridge_fwd(dladm_handle_t handle, bridge_listfwd_t *blf,
8500 show_state_t *state)
8501 {
8502 bridge_fwd_fields_buf_t bbuf;
8503
8504 bzero(&bbuf, sizeof (bbuf));
8505 (void) snprintf(bbuf.bridgef_dest, sizeof (bbuf.bridgef_dest),
8506 "%s", ether_ntoa((struct ether_addr *)blf->blf_dest));
8507 if (blf->blf_is_local) {
8508 (void) strlcpy(bbuf.bridgef_flags, "L",
8509 sizeof (bbuf.bridgef_flags));
8510 } else {
8511 (void) snprintf(bbuf.bridgef_age, sizeof (bbuf.bridgef_age),
8512 "%2d.%03d", blf->blf_ms_age / 1000, blf->blf_ms_age % 1000);
8513 if (blf->blf_trill_nick != 0) {
8514 (void) snprintf(bbuf.bridgef_output,
8515 sizeof (bbuf.bridgef_output), "%u",
8516 blf->blf_trill_nick);
8517 }
8518 }
8519 if (blf->blf_linkid != DATALINK_INVALID_LINKID &&
8520 blf->blf_trill_nick == 0) {
8521 state->ls_status = dladm_datalink_id2info(handle,
8522 blf->blf_linkid, NULL, NULL, NULL, bbuf.bridgef_output,
8523 sizeof (bbuf.bridgef_output));
8524 }
8525 if (state->ls_status == DLADM_STATUS_OK)
8526 ofmt_print(state->ls_ofmt, &bbuf);
8527 }
8528
8529 static void
8530 show_bridge_trillnick(trill_listnick_t *tln, show_state_t *state)
8531 {
8532 bridge_trill_fields_buf_t bbuf;
8533
8534 bzero(&bbuf, sizeof (bbuf));
8535 (void) snprintf(bbuf.bridget_nick, sizeof (bbuf.bridget_nick),
8536 "%u", tln->tln_nick);
8537 if (tln->tln_ours) {
8538 (void) strlcpy(bbuf.bridget_flags, "L",
8539 sizeof (bbuf.bridget_flags));
8540 } else {
8541 state->ls_status = dladm_datalink_id2info(handle,
8542 tln->tln_linkid, NULL, NULL, NULL, bbuf.bridget_link,
8543 sizeof (bbuf.bridget_link));
8544 (void) snprintf(bbuf.bridget_nexthop,
8545 sizeof (bbuf.bridget_nexthop), "%s",
8546 ether_ntoa((struct ether_addr *)tln->tln_nexthop));
8547 }
8548 if (state->ls_status == DLADM_STATUS_OK)
8549 ofmt_print(state->ls_ofmt, &bbuf);
8550 }
8551
8552 static void
8553 do_show_bridge(int argc, char **argv, const char *use)
8554 {
8555 int option;
8556 enum {
8557 bridgeMode, linkMode, fwdMode, trillMode
8558 } op_mode = bridgeMode;
8559 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
8560 boolean_t parsable = B_FALSE;
8561 datalink_id_t linkid = DATALINK_ALL_LINKID;
8562 int interval = 0;
8563 show_brstate_t brstate;
8564 dladm_status_t status;
8565 char *fields_str = NULL;
8566 /* default: bridge-related data */
8567 char *all_fields = "bridge,protect,address,priority,bmaxage,"
8568 "bhellotime,bfwddelay,forceproto,tctime,tccount,tchange,"
8569 "desroot,rootcost,rootport,maxage,hellotime,fwddelay,holdtime";
8570 char *default_fields = "bridge,protect,address,priority,"
8571 "desroot";
8572 char *all_statfields = "bridge,drops,forwards,mbcast,"
8573 "unknown,recv,sent";
8574 char *default_statfields = "bridge,drops,forwards,mbcast,"
8575 "unknown";
8576 /* -l: link-related data */
8577 char *all_link_fields = "link,index,state,uptime,opercost,"
8578 "operp2p,operedge,desroot,descost,desbridge,desport,tcack";
8579 char *default_link_fields = "link,state,uptime,desroot";
8580 char *all_link_statfields = "link,cfgbpdu,tcnbpdu,rstpbpdu,"
8581 "txbpdu,drops,recv,xmit";
8582 char *default_link_statfields = "link,drops,recv,xmit";
8583 /* -f: bridge forwarding table related data */
8584 char *default_fwd_fields = "dest,age,flags,output";
8585 /* -t: TRILL nickname table related data */
8586 char *default_trill_fields = "nick,flags,link,nexthop";
8587 char *default_str;
8588 char *all_str;
8589 ofmt_field_t *field_arr;
8590 ofmt_handle_t ofmt;
8591 ofmt_status_t oferr;
8592 uint_t ofmtflags = 0;
8593
8594 bzero(&brstate, sizeof (brstate));
8595
8596 opterr = 0;
8597 while ((option = getopt_long(argc, argv, ":fi:lo:pst",
8598 bridge_show_lopts, NULL)) != -1) {
8599 switch (option) {
8600 case 'f':
8601 if (op_mode != bridgeMode && op_mode != fwdMode)
8602 die("-f is incompatible with -l or -t");
8603 op_mode = fwdMode;
8604 break;
8605 case 'i':
8606 if (interval != 0)
8607 die_optdup(option);
8608 if (!str2int(optarg, &interval) || interval == 0)
8609 die("invalid interval value '%s'", optarg);
8610 break;
8611 case 'l':
8612 if (op_mode != bridgeMode && op_mode != linkMode)
8613 die("-l is incompatible with -f or -t");
8614 op_mode = linkMode;
8615 break;
8616 case 'o':
8617 fields_str = optarg;
8618 break;
8619 case 'p':
8620 if (parsable)
8621 die_optdup(option);
8622 parsable = B_TRUE;
8623 break;
8624 case 's':
8625 if (brstate.show_stats)
8626 die_optdup(option);
8627 brstate.show_stats = B_TRUE;
8628 break;
8629 case 't':
8630 if (op_mode != bridgeMode && op_mode != trillMode)
8631 die("-t is incompatible with -f or -l");
8632 op_mode = trillMode;
8633 break;
8634 default:
8635 die_opterr(optopt, option, use);
8636 break;
8637 }
8638 }
8639
8640 if (interval != 0 && !brstate.show_stats)
8641 die("the -i option can be used only with -s");
8642
8643 if ((op_mode == fwdMode || op_mode == trillMode) && brstate.show_stats)
8644 die("the -f/-t and -s options cannot be used together");
8645
8646 /* get the bridge name (optional last argument) */
8647 if (optind == (argc-1)) {
8648 char lname[MAXLINKNAMELEN];
8649 uint32_t lnkflg;
8650 datalink_class_t class;
8651
8652 brstate.bridge = argv[optind];
8653 (void) snprintf(lname, sizeof (lname), "%s0", brstate.bridge);
8654 if ((status = dladm_name2info(handle, lname, &linkid, &lnkflg,
8655 &class, NULL)) != DLADM_STATUS_OK) {
8656 die_dlerr(status, "bridge %s is not valid",
8657 brstate.bridge);
8658 }
8659
8660 if (class != DATALINK_CLASS_BRIDGE)
8661 die("%s is not a bridge", brstate.bridge);
8662
8663 if (!(lnkflg & flags)) {
8664 die_dlerr(DLADM_STATUS_BADARG,
8665 "bridge %s is temporarily removed", brstate.bridge);
8666 }
8667 } else if (optind != argc) {
8668 usage();
8669 } else if (op_mode != bridgeMode) {
8670 die("bridge name required for -l, -f, or -t");
8671 return;
8672 }
8673
8674 brstate.state.ls_parsable = parsable;
8675 brstate.state.ls_flags = flags;
8676 brstate.state.ls_firstonly = (interval != 0);
8677
8678 switch (op_mode) {
8679 case bridgeMode:
8680 if (brstate.show_stats) {
8681 default_str = default_statfields;
8682 all_str = all_statfields;
8683 field_arr = bridge_statfields;
8684 } else {
8685 default_str = default_fields;
8686 all_str = all_fields;
8687 field_arr = bridge_fields;
8688 }
8689 break;
8690
8691 case linkMode:
8692 if (brstate.show_stats) {
8693 default_str = default_link_statfields;
8694 all_str = all_link_statfields;
8695 field_arr = bridge_link_statfields;
8696 } else {
8697 default_str = default_link_fields;
8698 all_str = all_link_fields;
8699 field_arr = bridge_link_fields;
8700 }
8701 break;
8702
8703 case fwdMode:
8704 default_str = all_str = default_fwd_fields;
8705 field_arr = bridge_fwd_fields;
8706 break;
8707
8708 case trillMode:
8709 default_str = all_str = default_trill_fields;
8710 field_arr = bridge_trill_fields;
8711 break;
8712 }
8713
8714 if (fields_str == NULL)
8715 fields_str = default_str;
8716 else if (strcasecmp(fields_str, "all") == 0)
8717 fields_str = all_str;
8718
8719 if (parsable)
8720 ofmtflags |= OFMT_PARSABLE;
8721 oferr = ofmt_open(fields_str, field_arr, ofmtflags, 0, &ofmt);
8722 ofmt_check(oferr, brstate.state.ls_parsable, ofmt, die, warn);
8723 brstate.state.ls_ofmt = ofmt;
8724
8725 for (;;) {
8726 brstate.state.ls_donefirst = B_FALSE;
8727 switch (op_mode) {
8728 case bridgeMode:
8729 if (linkid == DATALINK_ALL_LINKID) {
8730 (void) dladm_walk_datalink_id(show_bridge,
8731 handle, &brstate, DATALINK_CLASS_BRIDGE,
8732 DATALINK_ANY_MEDIATYPE, flags);
8733 } else {
8734 (void) show_bridge(handle, linkid, &brstate);
8735 if (brstate.state.ls_status !=
8736 DLADM_STATUS_OK) {
8737 die_dlerr(brstate.state.ls_status,
8738 "failed to show bridge %s",
8739 brstate.bridge);
8740 }
8741 }
8742 break;
8743
8744 case linkMode: {
8745 datalink_id_t *dlp;
8746 uint_t i, nlinks;
8747
8748 dlp = dladm_bridge_get_portlist(brstate.bridge,
8749 &nlinks);
8750 if (dlp != NULL) {
8751 for (i = 0; i < nlinks; i++)
8752 show_bridge_link(dlp[i], &brstate);
8753 dladm_bridge_free_portlist(dlp);
8754 } else if (errno == ENOENT) {
8755 /* bridge not running; iterate on libdladm */
8756 (void) dladm_walk_datalink_id(
8757 show_bridge_link_walk, handle,
8758 &brstate, DATALINK_CLASS_PHYS |
8759 DATALINK_CLASS_AGGR |
8760 DATALINK_CLASS_ETHERSTUB,
8761 DATALINK_ANY_MEDIATYPE, flags);
8762 } else {
8763 die("unable to get port list for bridge %s: %s",
8764 brstate.bridge, strerror(errno));
8765 }
8766 break;
8767 }
8768
8769 case fwdMode: {
8770 bridge_listfwd_t *blf;
8771 uint_t i, nfwd;
8772
8773 blf = dladm_bridge_get_fwdtable(handle, brstate.bridge,
8774 &nfwd);
8775 if (blf == NULL) {
8776 die("unable to get forwarding entries for "
8777 "bridge %s", brstate.bridge);
8778 } else {
8779 for (i = 0; i < nfwd; i++)
8780 show_bridge_fwd(handle, blf + i,
8781 &brstate.state);
8782 dladm_bridge_free_fwdtable(blf);
8783 }
8784 break;
8785 }
8786
8787 case trillMode: {
8788 trill_listnick_t *tln;
8789 uint_t i, nnick;
8790
8791 tln = dladm_bridge_get_trillnick(brstate.bridge,
8792 &nnick);
8793 if (tln == NULL) {
8794 if (errno == ENOENT)
8795 die("bridge %s is not running TRILL",
8796 brstate.bridge);
8797 else
8798 die("unable to get TRILL nickname "
8799 "entries for bridge %s",
8800 brstate.bridge);
8801 } else {
8802 for (i = 0; i < nnick; i++)
8803 show_bridge_trillnick(tln + i,
8804 &brstate.state);
8805 dladm_bridge_free_trillnick(tln);
8806 }
8807 break;
8808 }
8809 }
8810 if (interval == 0)
8811 break;
8812 (void) sleep(interval);
8813 }
8814 }
8815
8816 /*
8817 * "-R" option support. It is used for live upgrading. Append dladm commands
8818 * to a upgrade script which will be run when the alternative root boots up:
8819 *
8820 * - If the /etc/dladm/datalink.conf file exists on the alternative root,
8821 * append dladm commands to the <altroot>/var/svc/profile/upgrade_datalink
8822 * script. This script will be run as part of the network/physical service.
8823 * We cannot defer this to /var/svc/profile/upgrade because then the
8824 * configuration will not be able to take effect before network/physical
8825 * plumbs various interfaces.
8826 *
8827 * - If the /etc/dladm/datalink.conf file does not exist on the alternative
8828 * root, append dladm commands to the <altroot>/var/svc/profile/upgrade script,
8829 * which will be run in the manifest-import service.
8830 *
8831 * Note that the SMF team is considering to move the manifest-import service
8832 * to be run at the very begining of boot. Once that is done, the need for
8833 * the /var/svc/profile/upgrade_datalink script will not exist any more.
8834 */
8835 static void
8836 altroot_cmd(char *altroot, int argc, char *argv[])
8837 {
8838 char path[MAXPATHLEN];
8839 struct stat stbuf;
8840 FILE *fp;
8841 int i;
8842
8843 /*
8844 * Check for the existence of the /etc/dladm/datalink.conf
8845 * configuration file, and determine the name of script file.
8846 */
8847 (void) snprintf(path, MAXPATHLEN, "/%s/etc/dladm/datalink.conf",
8848 altroot);
8849 if (stat(path, &stbuf) < 0) {
8850 (void) snprintf(path, MAXPATHLEN, "/%s/%s", altroot,
8851 SMF_UPGRADE_FILE);
8852 } else {
8853 (void) snprintf(path, MAXPATHLEN, "/%s/%s", altroot,
8854 SMF_UPGRADEDATALINK_FILE);
8855 }
8856
8857 if ((fp = fopen(path, "a+")) == NULL)
8858 die("operation not supported on %s", altroot);
8859
8860 (void) fprintf(fp, "/sbin/dladm ");
8861 for (i = 0; i < argc; i++) {
8862 /*
8863 * Directly write to the file if it is not the "-R <altroot>"
8864 * option. In which case, skip it.
8865 */
8866 if (strcmp(argv[i], "-R") != 0)
8867 (void) fprintf(fp, "%s ", argv[i]);
8868 else
8869 i ++;
8870 }
8871 (void) fprintf(fp, "%s\n", SMF_DLADM_UPGRADE_MSG);
8872 (void) fclose(fp);
8873 dladm_close(handle);
8874 exit(EXIT_SUCCESS);
8875 }
8876
8877 /*
8878 * Convert the string to an integer. Note that the string must not have any
8879 * trailing non-integer characters.
8880 */
8881 static boolean_t
8882 str2int(const char *str, int *valp)
8883 {
8884 int val;
8885 char *endp = NULL;
8886
8887 errno = 0;
8888 val = strtol(str, &endp, 10);
8889 if (errno != 0 || *endp != '\0')
8890 return (B_FALSE);
8891
8892 *valp = val;
8893 return (B_TRUE);
8894 }
8895
8896 /* PRINTFLIKE1 */
8897 static void
8898 warn(const char *format, ...)
8899 {
8900 va_list alist;
8901
8902 format = gettext(format);
8903 (void) fprintf(stderr, "%s: warning: ", progname);
8904
8905 va_start(alist, format);
8906 (void) vfprintf(stderr, format, alist);
8907 va_end(alist);
8908
8909 (void) putc('\n', stderr);
8910 }
8911
8912 /* PRINTFLIKE2 */
8913 static void
8914 warn_dlerr(dladm_status_t err, const char *format, ...)
8915 {
8916 va_list alist;
8917 char errmsg[DLADM_STRSIZE];
8918
8919 format = gettext(format);
8920 (void) fprintf(stderr, gettext("%s: warning: "), progname);
8921
8922 va_start(alist, format);
8923 (void) vfprintf(stderr, format, alist);
8924 va_end(alist);
8925 (void) fprintf(stderr, ": %s\n", dladm_status2str(err, errmsg));
8926 }
8927
8928 /*
8929 * Also closes the dladm handle if it is not NULL.
8930 */
8931 /* PRINTFLIKE2 */
8932 static void
8933 die_dlerr(dladm_status_t err, const char *format, ...)
8934 {
8935 va_list alist;
8936 char errmsg[DLADM_STRSIZE];
8937
8938 format = gettext(format);
8939 (void) fprintf(stderr, "%s: ", progname);
8940
8941 va_start(alist, format);
8942 (void) vfprintf(stderr, format, alist);
8943 va_end(alist);
8944 (void) fprintf(stderr, ": %s\n", dladm_status2str(err, errmsg));
8945
8946 /* close dladm handle if it was opened */
8947 if (handle != NULL)
8948 dladm_close(handle);
8949
8950 exit(EXIT_FAILURE);
8951 }
8952
8953 /* PRINTFLIKE1 */
8954 static void
8955 die(const char *format, ...)
8956 {
8957 va_list alist;
8958
8959 format = gettext(format);
8960 (void) fprintf(stderr, "%s: ", progname);
8961
8962 va_start(alist, format);
8963 (void) vfprintf(stderr, format, alist);
8964 va_end(alist);
8965
8966 (void) putc('\n', stderr);
8967
8968 /* close dladm handle if it was opened */
8969 if (handle != NULL)
8970 dladm_close(handle);
8971
8972 exit(EXIT_FAILURE);
8973 }
8974
8975 static void
8976 die_optdup(int opt)
8977 {
8978 die("the option -%c cannot be specified more than once", opt);
8979 }
8980
8981 static void
8982 die_opterr(int opt, int opterr, const char *usage)
8983 {
8984 switch (opterr) {
8985 case ':':
8986 die("option '-%c' requires a value\nusage: %s", opt,
8987 gettext(usage));
8988 break;
8989 case '?':
8990 default:
8991 die("unrecognized option '-%c'\nusage: %s", opt,
8992 gettext(usage));
8993 break;
8994 }
8995 }
8996
8997 static void
8998 show_ether_xprop(void *arg, dladm_ether_info_t *eattr)
8999 {
9000 print_ether_state_t *statep = arg;
9001 ether_fields_buf_t ebuf;
9002 int i;
9003
9004 for (i = CAPABLE; i <= PEERADV; i++) {
9005 bzero(&ebuf, sizeof (ebuf));
9006 (void) strlcpy(ebuf.eth_ptype, ptype[i],
9007 sizeof (ebuf.eth_ptype));
9008 (void) dladm_ether_autoneg2str(ebuf.eth_autoneg,
9009 sizeof (ebuf.eth_autoneg), eattr, i);
9010 (void) dladm_ether_spdx2str(ebuf.eth_spdx,
9011 sizeof (ebuf.eth_spdx), eattr, i);
9012 (void) dladm_ether_pause2str(ebuf.eth_pause,
9013 sizeof (ebuf.eth_pause), eattr, i);
9014 (void) strlcpy(ebuf.eth_rem_fault,
9015 (eattr->lei_attr[i].le_fault ? "fault" : "none"),
9016 sizeof (ebuf.eth_rem_fault));
9017 ofmt_print(statep->es_ofmt, &ebuf);
9018 }
9019
9020 }
9021
9022 static boolean_t
9023 link_is_ether(const char *link, datalink_id_t *linkid)
9024 {
9025 uint32_t media;
9026 datalink_class_t class;
9027
9028 if (dladm_name2info(handle, link, linkid, NULL, &class, &media) ==
9029 DLADM_STATUS_OK) {
9030 if (class == DATALINK_CLASS_PHYS && media == DL_ETHER)
9031 return (B_TRUE);
9032 }
9033 return (B_FALSE);
9034 }
9035
9036 /*
9037 * default output callback function that, when invoked,
9038 * prints string which is offset by ofmt_arg->ofmt_id within buf.
9039 */
9040 static boolean_t
9041 print_default_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
9042 {
9043 char *value;
9044
9045 value = (char *)ofarg->ofmt_cbarg + ofarg->ofmt_id;
9046 (void) strlcpy(buf, value, bufsize);
9047 return (B_TRUE);
9048 }
9049
9050 /*
9051 * Called from the walker dladm_walk_datalink_id() for each IB partition to
9052 * display IB partition specific information.
9053 */
9054 static dladm_status_t
9055 print_part(show_part_state_t *state, datalink_id_t linkid)
9056 {
9057 dladm_part_attr_t attr;
9058 dladm_status_t status;
9059 dladm_conf_t conf;
9060 char part_over[MAXLINKNAMELEN];
9061 char part_name[MAXLINKNAMELEN];
9062 part_fields_buf_t pbuf;
9063 boolean_t force_in_conf = B_FALSE;
9064
9065 /*
9066 * Get the information about the IB partition from the partition
9067 * datlink ID 'linkid'.
9068 */
9069 if ((status = dladm_part_info(handle, linkid, &attr, state->ps_flags))
9070 != DLADM_STATUS_OK)
9071 return (status);
9072
9073 /*
9074 * If an IB Phys link name was provided on the command line we have
9075 * the Phys link's datalink ID in the ps_over_id field of the state
9076 * structure. Proceed only if the IB partition represented by 'linkid'
9077 * was created over Phys link denoted by ps_over_id. The
9078 * 'dia_physlinkid' field of dladm_part_attr_t represents the IB Phys
9079 * link over which the partition was created.
9080 */
9081 if (state->ps_over_id != DATALINK_ALL_LINKID)
9082 if (state->ps_over_id != attr.dia_physlinkid)
9083 return (DLADM_STATUS_OK);
9084
9085 /*
9086 * The linkid argument passed to this function is the datalink ID
9087 * of the IB Partition. Get the partitions name from this linkid.
9088 */
9089 if (dladm_datalink_id2info(handle, linkid, NULL, NULL,
9090 NULL, part_name, sizeof (part_name)) != DLADM_STATUS_OK)
9091 return (DLADM_STATUS_BADARG);
9092
9093 bzero(part_over, sizeof (part_over));
9094
9095 /*
9096 * The 'dia_physlinkid' field contains the datalink ID of the IB Phys
9097 * link over which the partition was created. Use this linkid to get the
9098 * linkover field.
9099 */
9100 if (dladm_datalink_id2info(handle, attr.dia_physlinkid, NULL, NULL,
9101 NULL, part_over, sizeof (part_over)) != DLADM_STATUS_OK)
9102 (void) sprintf(part_over, "?");
9103 state->ps_found = B_TRUE;
9104
9105 /*
9106 * Read the FFORCE field from this datalink's persistent configuration
9107 * database line to determine if this datalink was created forcibly.
9108 * If this datalink is a temporary datalink, then it will not have an
9109 * entry in the persistent configuration, so check if force create flag
9110 * is set in the partition attributes.
9111 *
9112 * We need this two level check since persistent partitions brought up
9113 * by up-part during boot will have force create flag always set, since
9114 * we want up-part to always succeed even if the port is currently down
9115 * or P_Key is not yet available in the subnet.
9116 */
9117 if ((status = dladm_getsnap_conf(handle, linkid, &conf)) ==
9118 DLADM_STATUS_OK) {
9119 (void) dladm_get_conf_field(handle, conf, FFORCE,
9120 &force_in_conf, sizeof (boolean_t));
9121 dladm_destroy_conf(handle, conf);
9122 } else if (status == DLADM_STATUS_NOTFOUND) {
9123 /*
9124 * for a temp link the force create flag will determine
9125 * whether it was created with force flag.
9126 */
9127 force_in_conf = ((attr.dia_flags & DLADM_PART_FORCE_CREATE)
9128 != 0);
9129 }
9130
9131 (void) snprintf(pbuf.part_link, sizeof (pbuf.part_link),
9132 "%s", part_name);
9133
9134 (void) snprintf(pbuf.part_over, sizeof (pbuf.part_over),
9135 "%s", part_over);
9136
9137 (void) snprintf(pbuf.part_pkey, sizeof (pbuf.part_pkey),
9138 "%X", attr.dia_pkey);
9139
9140 (void) get_linkstate(pbuf.part_link, B_TRUE, pbuf.part_state);
9141
9142 (void) snprintf(pbuf.part_flags, sizeof (pbuf.part_flags),
9143 "%c----", force_in_conf ? 'f' : '-');
9144
9145 ofmt_print(state->ps_ofmt, &pbuf);
9146
9147 return (DLADM_STATUS_OK);
9148 }
9149
9150 /* ARGSUSED */
9151 static int
9152 show_part(dladm_handle_t dh, datalink_id_t linkid, void *arg)
9153 {
9154 ((show_part_state_t *)arg)->ps_status = print_part(arg, linkid);
9155 return (DLADM_WALK_CONTINUE);
9156 }
9157
9158 /*
9159 * Show the information about the IB partition objects.
9160 */
9161 static void
9162 do_show_part(int argc, char *argv[], const char *use)
9163 {
9164 int option;
9165 boolean_t l_arg = B_FALSE;
9166 uint32_t flags = DLADM_OPT_ACTIVE;
9167 datalink_id_t linkid = DATALINK_ALL_LINKID;
9168 datalink_id_t over_linkid = DATALINK_ALL_LINKID;
9169 char over_link[MAXLINKNAMELEN];
9170 show_part_state_t state;
9171 dladm_status_t status;
9172 boolean_t o_arg = B_FALSE;
9173 char *fields_str = NULL;
9174 ofmt_handle_t ofmt;
9175 ofmt_status_t oferr;
9176 uint_t ofmtflags = 0;
9177
9178 bzero(&state, sizeof (state));
9179 opterr = 0;
9180 while ((option = getopt_long(argc, argv, ":pPl:o:", show_part_lopts,
9181 NULL)) != -1) {
9182 switch (option) {
9183 case 'p':
9184 state.ps_parsable = B_TRUE;
9185 break;
9186 case 'P':
9187 flags = DLADM_OPT_PERSIST;
9188 break;
9189 case 'l':
9190 /*
9191 * The data link ID of the IB Phys link. When this
9192 * argument is provided we list only the partition
9193 * objects created over this IB Phys link.
9194 */
9195 if (strlcpy(over_link, optarg, MAXLINKNAMELEN) >=
9196 MAXLINKNAMELEN)
9197 die("link name too long");
9198
9199 l_arg = B_TRUE;
9200 break;
9201 case 'o':
9202 o_arg = B_TRUE;
9203 fields_str = optarg;
9204 break;
9205 default:
9206 die_opterr(optopt, option, use);
9207 }
9208 }
9209
9210 /*
9211 * Get the partition ID (optional last argument).
9212 */
9213 if (optind == (argc - 1)) {
9214 status = dladm_name2info(handle, argv[optind], &linkid, NULL,
9215 NULL, NULL);
9216 if (status != DLADM_STATUS_OK) {
9217 die_dlerr(status, "invalid partition link name '%s'",
9218 argv[optind]);
9219 }
9220 (void) strlcpy(state.ps_part, argv[optind], MAXLINKNAMELEN);
9221 } else if (optind != argc) {
9222 usage();
9223 }
9224
9225 if (state.ps_parsable && !o_arg)
9226 die("-p requires -o");
9227
9228 /*
9229 * If an IB Phys link name was provided as an argument, then get its
9230 * datalink ID.
9231 */
9232 if (l_arg) {
9233 status = dladm_name2info(handle, over_link, &over_linkid, NULL,
9234 NULL, NULL);
9235 if (status != DLADM_STATUS_OK) {
9236 die_dlerr(status, "invalid link name '%s'", over_link);
9237 }
9238 }
9239
9240 state.ps_over_id = over_linkid; /* IB Phys link ID */
9241 state.ps_found = B_FALSE;
9242 state.ps_flags = flags;
9243
9244 if (state.ps_parsable)
9245 ofmtflags |= OFMT_PARSABLE;
9246 oferr = ofmt_open(fields_str, part_fields, ofmtflags, 0, &ofmt);
9247 ofmt_check(oferr, state.ps_parsable, ofmt, die, warn);
9248 state.ps_ofmt = ofmt;
9249
9250 /*
9251 * If a specific IB partition name was not provided as an argument,
9252 * walk all the datalinks and display the information for all
9253 * IB partitions. If IB Phys link was provided limit it to only
9254 * IB partitions created over that IB Phys link.
9255 */
9256 if (linkid == DATALINK_ALL_LINKID) {
9257 (void) dladm_walk_datalink_id(show_part, handle, &state,
9258 DATALINK_CLASS_PART, DATALINK_ANY_MEDIATYPE, flags);
9259 } else {
9260 (void) show_part(handle, linkid, &state);
9261 if (state.ps_status != DLADM_STATUS_OK) {
9262 ofmt_close(ofmt);
9263 die_dlerr(state.ps_status, "failed to show IB partition"
9264 " '%s'", state.ps_part);
9265 }
9266 }
9267 ofmt_close(ofmt);
9268 }
9269
9270
9271 /*
9272 * Called from the walker dladm_walk_datalink_id() for each IB Phys link to
9273 * display IB specific information for these Phys links.
9274 */
9275 static dladm_status_t
9276 print_ib(show_ib_state_t *state, datalink_id_t phys_linkid)
9277 {
9278 dladm_ib_attr_t attr;
9279 dladm_status_t status;
9280 char linkname[MAXLINKNAMELEN];
9281 char pkeystr[MAXPKEYLEN];
9282 int i;
9283 ib_fields_buf_t ibuf;
9284
9285 bzero(&attr, sizeof (attr));
9286
9287 /*
9288 * Get the attributes of the IB Phys link from active/Persistent config
9289 * based on the flag passed.
9290 */
9291 if ((status = dladm_ib_info(handle, phys_linkid, &attr,
9292 state->is_flags)) != DLADM_STATUS_OK)
9293 return (status);
9294
9295 if ((state->is_link_id != DATALINK_ALL_LINKID) && (state->is_link_id
9296 != attr.dia_physlinkid)) {
9297 dladm_free_ib_info(&attr);
9298 return (DLADM_STATUS_OK);
9299 }
9300
9301 /*
9302 * Get the data link name for the phys_linkid. If we are doing show-ib
9303 * for all IB Phys links, we have only the datalink IDs not the
9304 * datalink name.
9305 */
9306 if (dladm_datalink_id2info(handle, phys_linkid, NULL, NULL, NULL,
9307 linkname, MAXLINKNAMELEN) != DLADM_STATUS_OK)
9308 return (status);
9309
9310 (void) snprintf(ibuf.ib_link, sizeof (ibuf.ib_link),
9311 "%s", linkname);
9312
9313 (void) snprintf(ibuf.ib_portnum, sizeof (ibuf.ib_portnum),
9314 "%d", attr.dia_portnum);
9315
9316 (void) snprintf(ibuf.ib_hcaguid, sizeof (ibuf.ib_hcaguid),
9317 "%llX", attr.dia_hca_guid);
9318
9319 (void) snprintf(ibuf.ib_portguid, sizeof (ibuf.ib_portguid),
9320 "%llX", attr.dia_port_guid);
9321
9322 (void) get_linkstate(linkname, B_TRUE, ibuf.ib_state);
9323
9324 /*
9325 * Create a comma separated list of pkeys from the pkey table returned
9326 * by the IP over IB driver instance.
9327 */
9328 bzero(ibuf.ib_pkeys, attr.dia_port_pkey_tbl_sz * sizeof (ib_pkey_t));
9329 for (i = 0; i < attr.dia_port_pkey_tbl_sz; i++) {
9330 if (attr.dia_port_pkeys[i] != IB_PKEY_INVALID_FULL &&
9331 attr.dia_port_pkeys[i] != IB_PKEY_INVALID_LIMITED) {
9332 if (i == 0)
9333 (void) snprintf(pkeystr, MAXPKEYLEN, "%X",
9334 attr.dia_port_pkeys[i]);
9335 else
9336 (void) snprintf(pkeystr, MAXPKEYLEN, ",%X",
9337 attr.dia_port_pkeys[i]);
9338 (void) strlcat(ibuf.ib_pkeys, pkeystr, MAXPKEYSTRSZ);
9339 }
9340 }
9341
9342 dladm_free_ib_info(&attr);
9343
9344 ofmt_print(state->is_ofmt, &ibuf);
9345
9346 return (DLADM_STATUS_OK);
9347 }
9348
9349 /* ARGSUSED */
9350 static int
9351 show_ib(dladm_handle_t dh, datalink_id_t linkid, void *arg)
9352 {
9353 ((show_ib_state_t *)arg)->is_status = print_ib(arg, linkid);
9354 return (DLADM_WALK_CONTINUE);
9355 }
9356
9357 /*
9358 * Show the properties of one/all IB Phys links. This is different from
9359 * show-phys command since this will display IB specific information about the
9360 * Phys link like, HCA GUID, PORT GUID, PKEYS active for this port etc.
9361 */
9362 static void
9363 do_show_ib(int argc, char *argv[], const char *use)
9364 {
9365 int option;
9366 uint32_t flags = DLADM_OPT_ACTIVE;
9367 datalink_id_t linkid = DATALINK_ALL_LINKID;
9368 show_ib_state_t state;
9369 dladm_status_t status;
9370 boolean_t o_arg = B_FALSE;
9371 char *fields_str = NULL;
9372 ofmt_handle_t ofmt;
9373 ofmt_status_t oferr;
9374 uint_t ofmtflags = 0;
9375
9376 bzero(&state, sizeof (state));
9377 opterr = 0;
9378 while ((option = getopt_long(argc, argv, ":po:", show_lopts,
9379 NULL)) != -1) {
9380 switch (option) {
9381 case 'p':
9382 state.is_parsable = B_TRUE;
9383 break;
9384 case 'o':
9385 o_arg = B_TRUE;
9386 fields_str = optarg;
9387 break;
9388 default:
9389 die_opterr(optopt, option, use);
9390 }
9391 }
9392
9393 /* get IB Phys link ID (optional last argument) */
9394 if (optind == (argc - 1)) {
9395 status = dladm_name2info(handle, argv[optind], &linkid, NULL,
9396 NULL, NULL);
9397 if (status != DLADM_STATUS_OK) {
9398 die_dlerr(status, "invalid IB port name '%s'",
9399 argv[optind]);
9400 }
9401 (void) strlcpy(state.is_link, argv[optind], MAXLINKNAMELEN);
9402 } else if (optind != argc) {
9403 usage();
9404 }
9405
9406 if (state.is_parsable && !o_arg)
9407 die("-p requires -o");
9408
9409 /*
9410 * linkid is the data link ID of the IB Phys link. By default it will
9411 * be DATALINK_ALL_LINKID.
9412 */
9413 state.is_link_id = linkid;
9414 state.is_flags = flags;
9415
9416 if (state.is_parsable)
9417 ofmtflags |= OFMT_PARSABLE;
9418 oferr = ofmt_open(fields_str, ib_fields, ofmtflags, 0, &ofmt);
9419 ofmt_check(oferr, state.is_parsable, ofmt, die, warn);
9420 state.is_ofmt = ofmt;
9421
9422 /*
9423 * If we are going to display the information for all IB Phys links
9424 * then we'll walk through all the datalinks for datalinks of Phys
9425 * class and media type IB.
9426 */
9427 if (linkid == DATALINK_ALL_LINKID) {
9428 (void) dladm_walk_datalink_id(show_ib, handle, &state,
9429 DATALINK_CLASS_PHYS, DL_IB, flags);
9430 } else {
9431 /*
9432 * We need to display the information only for the IB phys link
9433 * linkid. Call show_ib for this link.
9434 */
9435 (void) show_ib(handle, linkid, &state);
9436 if (state.is_status != DLADM_STATUS_OK) {
9437 ofmt_close(ofmt);
9438 die_dlerr(state.is_status, "failed to show IB Phys link"
9439 " '%s'", state.is_link);
9440 }
9441 }
9442 ofmt_close(ofmt);
9443 }
9444
9445 /*
9446 * Create an IP over Infiniband partition object over an IB Phys link. The IB
9447 * Phys link is associated with an Infiniband HCA port. The IB partition object
9448 * is created over a port, pkey combination. This partition object represents
9449 * an instance of IP over IB interface.
9450 */
9451 /* ARGSUSED */
9452 static void
9453 do_create_part(int argc, char *argv[], const char *use)
9454 {
9455 int status, option;
9456 int flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
9457 char *pname;
9458 char *l_arg = NULL;
9459 char *altroot = NULL;
9460 datalink_id_t physlinkid = 0;
9461 datalink_id_t partlinkid = 0;
9462 unsigned long opt_pkey;
9463 ib_pkey_t pkey = 0;
9464 char *endp = NULL;
9465 char propstr[DLADM_STRSIZE];
9466 dladm_arg_list_t *proplist = NULL;
9467
9468 propstr[0] = '\0';
9469 while ((option = getopt_long(argc, argv, ":tfl:P:R:p:",
9470 part_lopts, NULL)) != -1) {
9471 switch (option) {
9472 case 't':
9473 /*
9474 * Create a temporary IB partition object. This
9475 * instance is not entered into the persistent database
9476 * so it will not be recreated automatically on a
9477 * reboot.
9478 */
9479 flags &= ~DLADM_OPT_PERSIST;
9480 break;
9481 case 'l':
9482 /*
9483 * The IB phys link over which the partition object will
9484 * be created.
9485 */
9486 l_arg = optarg;
9487 break;
9488 case 'R':
9489 altroot = optarg;
9490 break;
9491 case 'p':
9492 (void) strlcat(propstr, optarg, DLADM_STRSIZE);
9493 if (strlcat(propstr, ",", DLADM_STRSIZE) >=
9494 DLADM_STRSIZE)
9495 die("property list too long '%s'", propstr);
9496 break;
9497 case 'P':
9498 /*
9499 * The P_Key for the port, pkey tuple of the partition
9500 * object. This P_Key should exist in the IB subnet.
9501 * The partition creation for a non-existent P_Key will
9502 * fail unless the -f option is used.
9503 *
9504 * The P_Key is expected to be a hexadecimal number.
9505 */
9506 opt_pkey = strtoul(optarg, &endp, 16);
9507 if (errno == ERANGE || opt_pkey > USHRT_MAX ||
9508 *endp != '\0')
9509 die("Invalid pkey");
9510
9511 pkey = (ib_pkey_t)opt_pkey;
9512 break;
9513 case 'f':
9514 flags |= DLADM_OPT_FORCE;
9515 break;
9516 default:
9517 die_opterr(optopt, option, use);
9518 break;
9519 }
9520 }
9521
9522 /* check required options */
9523 if (!l_arg)
9524 usage();
9525
9526 /* the partition name is a required operand */
9527 if (optind != (argc - 1))
9528 usage();
9529
9530 pname = argv[argc - 1];
9531
9532 /*
9533 * Verify that the partition object's name is in the valid link name
9534 * format.
9535 */
9536 if (!dladm_valid_linkname(pname))
9537 die("Invalid link name '%s'", pname);
9538
9539 /* pkey is a mandatory argument */
9540 if (pkey == 0)
9541 usage();
9542
9543 if (altroot != NULL)
9544 altroot_cmd(altroot, argc, argv);
9545
9546 /*
9547 * Get the data link id of the IB Phys link over which we will be
9548 * creating partition object.
9549 */
9550 if (dladm_name2info(handle, l_arg,
9551 &physlinkid, NULL, NULL, NULL) != DLADM_STATUS_OK)
9552 die("invalid link name '%s'", l_arg);
9553
9554 /*
9555 * parse the property list provided with -p option.
9556 */
9557 if (dladm_parse_link_props(propstr, &proplist, B_FALSE)
9558 != DLADM_STATUS_OK)
9559 die("invalid IB partition property");
9560
9561 /*
9562 * Call the library routine to create the partition object.
9563 */
9564 status = dladm_part_create(handle, physlinkid, pkey, flags, pname,
9565 &partlinkid, proplist);
9566 if (status != DLADM_STATUS_OK)
9567 die_dlerr(status,
9568 "partition %x creation over %s failed", pkey, l_arg);
9569 }
9570
9571 /*
9572 * Delete an IP over Infiniband partition object. The partition object should
9573 * be unplumbed before attempting the delete.
9574 */
9575 static void
9576 do_delete_part(int argc, char *argv[], const char *use)
9577 {
9578 int option, flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
9579 int status;
9580 char *altroot = NULL;
9581 datalink_id_t partid;
9582
9583 opterr = 0;
9584 while ((option = getopt_long(argc, argv, "R:t", part_lopts,
9585 NULL)) != -1) {
9586 switch (option) {
9587 case 't':
9588 flags &= ~DLADM_OPT_PERSIST;
9589 break;
9590 case 'R':
9591 altroot = optarg;
9592 break;
9593 default:
9594 die_opterr(optopt, option, use);
9595 }
9596 }
9597
9598 /* get partition name (required last argument) */
9599 if (optind != (argc - 1))
9600 usage();
9601
9602 if (altroot != NULL)
9603 altroot_cmd(altroot, argc, argv);
9604
9605 /*
9606 * Get the data link id of the partition object given the partition
9607 * name.
9608 */
9609 status = dladm_name2info(handle, argv[optind], &partid, NULL, NULL,
9610 NULL);
9611 if (status != DLADM_STATUS_OK)
9612 die("invalid link name '%s'", argv[optind]);
9613
9614 /*
9615 * Call the library routine to delete the IB partition. This will
9616 * result in the IB partition object and all its resources getting
9617 * deleted.
9618 */
9619 status = dladm_part_delete(handle, partid, flags);
9620 if (status != DLADM_STATUS_OK)
9621 die_dlerr(status, "%s: partition deletion failed",
9622 argv[optind]);
9623 }
9624
9625 /*
9626 * Bring up all or one IB partition already present in the persistent database
9627 * but not active yet.
9628 *
9629 * This sub-command is used during the system boot up to bring up all IB
9630 * partitions present in the persistent database. This is similar to a
9631 * create partition except that, the partitions are always created even if the
9632 * HCA port is down or P_Key is not present in the IB subnet. This is similar
9633 * to using the 'force' option while creating the partition except that the 'f'
9634 * flag will be set in the flags field only if the create-part for this command
9635 * was called with '-f' option.
9636 */
9637 /* ARGSUSED */
9638 static void
9639 do_up_part(int argc, char *argv[], const char *use)
9640 {
9641 datalink_id_t partid = DATALINK_ALL_LINKID;
9642 dladm_status_t status;
9643
9644 /*
9645 * If a partition name was passed as an argument, get its data link
9646 * id. By default we'll attempt to bring up all IB partition data
9647 * links.
9648 */
9649 if (argc == 2) {
9650 status = dladm_name2info(handle, argv[argc - 1], &partid, NULL,
9651 NULL, NULL);
9652 if (status != DLADM_STATUS_OK)
9653 return;
9654 } else if (argc > 2) {
9655 usage();
9656 }
9657
9658 (void) dladm_part_up(handle, partid, 0);
9659 }
Unleashed OS