Home | History | Annotate | Line # | Download | only in ifconfig
lagg.c revision 1.3 
      1 /*	$NetBSD: lagg.c,v 1.3 2022/03/31 01:53:22 yamaguchi Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 2021 Internet Initiative Japan Inc.
      5  * All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  *
     16  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     17  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     18  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     19  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     20  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     26  * POSSIBILITY OF SUCH DAMAGE.
     27  */
     28 
     29 #include <sys/cdefs.h>
     30 #if !defined(lint)
     31 __RCSID("$NetBSD: lagg.c,v 1.3 2022/03/31 01:53:22 yamaguchi Exp $");
     32 #endif /* !defined(lint) */
     33 
     34 #include <sys/param.h>
     35 
     36 #include <sys/ioctl.h>
     37 
     38 #include <net/if.h>
     39 #include <net/if_ether.h>
     40 #include <net/if_lagg.h>
     41 
     42 #include <ctype.h>
     43 #include <err.h>
     44 #include <errno.h>
     45 #include <string.h>
     46 #include <stdio.h>
     47 #include <stdlib.h>
     48 #include <util.h>
     49 
     50 #include "env.h"
     51 #include "extern.h"
     52 #include "util.h"
     53 
     54 static status_func_t	 status;
     55 static usage_func_t	 usage;
     56 static cmdloop_branch_t	 branch;
     57 
     58 static void	lagg_constructor(void) __attribute__((constructor));
     59 static void	lagg_status(prop_dictionary_t, prop_dictionary_t);
     60 static void	lagg_usage(prop_dictionary_t);
     61 
     62 static int	setlaggproto(prop_dictionary_t, prop_dictionary_t);
     63 static int	setlaggport(prop_dictionary_t, prop_dictionary_t);
     64 static int	setlagglacp(prop_dictionary_t, prop_dictionary_t);
     65 static int	setlagglacpmaxports(prop_dictionary_t, prop_dictionary_t);
     66 static int	setlaggfail(prop_dictionary_t, prop_dictionary_t);
     67 static void	lagg_status_proto(lagg_proto, struct laggreqproto *);
     68 static void	lagg_status_port(lagg_proto, struct laggreqport *);
     69 
     70 #ifdef LAGG_DEBUG
     71 static const bool	 lagg_debug = true;
     72 #else
     73 static const bool	 lagg_debug = false;
     74 #endif
     75 
     76 #define LAGG_RETRY_MAX 10
     77 
     78 static const char	*laggprotostr[LAGG_PROTO_MAX] = {
     79 	[LAGG_PROTO_NONE] = "none",
     80 	[LAGG_PROTO_LACP] = "lacp",
     81 	[LAGG_PROTO_FAILOVER] = "failover",
     82 	[LAGG_PROTO_LOADBALANCE] = "loadbalance",
     83 };
     84 
     85 enum laggportcmd {
     86 	LAGGPORT_NOCMD = 1,
     87 	LAGGPORT_ADD,
     88 	LAGGPORT_DEL,
     89 };
     90 
     91 enum lagglacpcmd {
     92 	LAGGLACP_ADD = 1,
     93 	LAGGLACP_DEL,
     94 };
     95 
     96 enum lagglacpopt {
     97 	LAGGLACPOPT_DUMPDU = 1,
     98 	LAGGLACPOPT_STOPDU,
     99 	LAGGLACPOPT_OPTIMISTIC,
    100 	LAGGLACPOPT_MULTILS,
    101 };
    102 
    103 enum laggfailopt {
    104 	LAGGFAILOPT_RXALL = 1,
    105 };
    106 
    107 struct pbranch	 laggport_root;
    108 struct pbranch	 lagglacp_root;
    109 struct pbranch	 laggfail_root;
    110 
    111 struct pstr	 laggproto = PSTR_INITIALIZER(&laggproto, "lagg-protocol",
    112 		    setlaggproto, "laggproto", &command_root.pb_parser);
    113 struct piface	 laggaddport = PIFACE_INITIALIZER(&laggaddport,
    114 		    "lagg-port-interface", setlaggport, "laggport",
    115 		    &laggport_root.pb_parser);
    116 struct piface	 laggdelport = PIFACE_INITIALIZER(&laggdelport,
    117 		    "lagg-port-interface", setlaggport, "laggport",
    118 		    &command_root.pb_parser);
    119 struct pinteger	 laggportoptpri =  PINTEGER_INITIALIZER1(&laggportoptpri,
    120 		    "lagg-port-priority", 0, UINT16_MAX, 10,
    121 		    setlaggport, "laggportpri", &laggport_root.pb_parser);
    122 struct pinteger	 lagglacpmaxports = PINTEGER_INITIALIZER1(&lagglacpmaxports,
    123 		    "lagg-lacp-maxports", 1, UINT32_MAX, 10,
    124 		    setlagglacpmaxports, "lacpmaxports",
    125 		    &lagglacp_root.pb_parser);
    126 struct pinteger	 laggportpri_num = PINTEGER_INITIALIZER1(&laggportpri_num,
    127 		    "lagg-port-priority", 0, UINT16_MAX, 10,
    128 		    setlaggport, "laggportpri", &command_root.pb_parser);
    129 struct piface	 laggportpri_if = PIFACE_INITIALIZER(&laggportpri_if,
    130 		    "lagg-port-interface", NULL, "laggport",
    131 		    &laggportpri_num.pi_parser);
    132 
    133 static const struct kwinst	 lagglacpkw[] = {
    134 	  {.k_word = "dumpdu", .k_key = "lacpdumpdu",
    135 	   .k_type = KW_T_INT, .k_int = LAGGLACPOPT_DUMPDU}
    136 	, {.k_word = "-dumpdu", .k_key = "lacpdumpdu",
    137 	   .k_type = KW_T_INT, .k_int = -LAGGLACPOPT_DUMPDU}
    138 	, {.k_word = "stopdu", .k_key = "lacpstopdu",
    139 	   .k_type = KW_T_INT, .k_int = LAGGLACPOPT_STOPDU}
    140 	, {.k_word = "-stopdu", .k_key = "lacpstopdu",
    141 	   .k_type = KW_T_INT, .k_int = -LAGGLACPOPT_STOPDU}
    142 	, {.k_word = "optimistic", .k_key = "lacpoptimistic",
    143 	   .k_type = KW_T_INT, .k_int = LAGGLACPOPT_OPTIMISTIC}
    144 	, {.k_word = "-optimistic", .k_key = "lacpoptimistic",
    145 	   .k_type = KW_T_INT, .k_int = -LAGGLACPOPT_OPTIMISTIC}
    146 	, {.k_word = "maxports", .k_nextparser = &lagglacpmaxports.pi_parser}
    147 	, {.k_word = "-maxports", .k_key = "lacpmaxports",
    148 	   .k_type = KW_T_INT, .k_int = 0}
    149 	, {.k_word = "multi-linkspeed", .k_key = "lacpmultils",
    150 	   .k_type = KW_T_INT, .k_int = LAGGLACPOPT_MULTILS}
    151 	, {.k_word = "-multi-linkspeed", .k_key = "lacpmultils",
    152 	   .k_type = KW_T_INT, .k_int = -LAGGLACPOPT_MULTILS}
    153 };
    154 struct pkw	 lagglacp = PKW_INITIALIZER(&lagglacp, "lagg-lacp-option",
    155 		    setlagglacp, NULL, lagglacpkw, __arraycount(lagglacpkw),
    156 		    &lagglacp_root.pb_parser);
    157 
    158 static const struct kwinst	 laggfailkw[] = {
    159 	  {.k_word = "rx-all", .k_key = "failrxall",
    160 	   .k_type = KW_T_INT, .k_int = LAGGFAILOPT_RXALL}
    161 	, {.k_word = "-rx-all", .k_key = "failrxall",
    162 	   .k_type = KW_T_INT, .k_int = -LAGGFAILOPT_RXALL}
    163 };
    164 struct pkw	 laggfail = PKW_INITIALIZER(&laggfail, "lagg-failover-option",
    165 		    setlaggfail, NULL, laggfailkw, __arraycount(laggfailkw),
    166 		    &laggfail_root.pb_parser);
    167 
    168 static const struct kwinst	 laggkw[] = {
    169 	  {.k_word = "laggproto", .k_nextparser = &laggproto.ps_parser}
    170 	, {.k_word = "-laggproto", .k_key = "laggproto", .k_type = KW_T_STR,
    171 	   .k_str = "none", .k_exec = setlaggproto}
    172 	, {.k_word = "laggport", .k_key = "laggportcmd", .k_type = KW_T_INT,
    173 	   .k_int = LAGGPORT_ADD, .k_nextparser = &laggaddport.pif_parser}
    174 	, {.k_word = "-laggport", .k_key = "laggportcmd", .k_type = KW_T_INT,
    175 	   .k_int = LAGGPORT_DEL, .k_nextparser = &laggdelport.pif_parser}
    176 	, {.k_word = "lagglacp", .k_nextparser = &lagglacp.pk_parser}
    177 	, {.k_word = "laggportpri", .k_nextparser = &laggportpri_if.pif_parser}
    178 	, {.k_word = "laggfailover", .k_nextparser = &laggfail.pk_parser}
    179 };
    180 struct pkw	 lagg = PKW_INITIALIZER(&lagg, "lagg", NULL, NULL,
    181 		    laggkw, __arraycount(laggkw), NULL);
    182 
    183 static const struct kwinst	 laggportkw[] = {
    184 	  {.k_word = "pri", .k_nextparser = &laggportoptpri.pi_parser}
    185 };
    186 struct pkw	laggportopt = PKW_INITIALIZER(&laggportopt, "lagg-port-option",
    187 		    NULL, NULL, laggportkw, __arraycount(laggportkw), NULL);
    188 
    189 struct branch	 laggport_brs[] = {
    190 	  {.b_nextparser = &laggportopt.pk_parser}
    191 	, {.b_nextparser = &command_root.pb_parser}
    192 };
    193 struct branch	 lagglacp_brs[] = {
    194 	  {.b_nextparser = &lagglacp.pk_parser}
    195 	, {.b_nextparser = &command_root.pb_parser}
    196 };
    197 struct branch	 laggfail_brs[] = {
    198 	  {.b_nextparser = &laggfail.pk_parser}
    199 	, {.b_nextparser = &command_root.pb_parser}
    200 };
    201 
    202 static void
    203 lagg_constructor(void)
    204 {
    205 	struct pbranch _laggport_root = PBRANCH_INITIALIZER(&laggport_root,
    206 	    "laggport-root", laggport_brs, __arraycount(laggport_brs), true);
    207 	struct pbranch _lagglacp_root = PBRANCH_INITIALIZER(&lagglacp_root,
    208 	    "lagglacp-root", lagglacp_brs, __arraycount(lagglacp_brs), true);
    209 	struct pbranch _laggfail_root = PBRANCH_INITIALIZER(&laggfail_root,
    210 	    "laggfail-root", laggfail_brs, __arraycount(laggfail_brs), true);
    211 
    212 	laggport_root = _laggport_root;
    213 	lagglacp_root = _lagglacp_root;
    214 	laggfail_root = _laggfail_root;
    215 
    216 	cmdloop_branch_init(&branch, &lagg.pk_parser);
    217 	status_func_init(&status, lagg_status);
    218 	usage_func_init(&usage, lagg_usage);
    219 
    220 	register_cmdloop_branch(&branch);
    221 	register_status(&status);
    222 	register_usage(&usage);
    223 }
    224 
    225 static int
    226 is_laggif(prop_dictionary_t env)
    227 {
    228 	const char *ifname;
    229 	size_t i, len;
    230 
    231 	if ((ifname = getifname(env)) == NULL)
    232 		return 0;
    233 
    234 	if (strncmp(ifname, "lagg", 4) != 0)
    235 		return 0;
    236 
    237 	len = strlen(ifname);
    238 	for (i = 4; i < len; i++) {
    239 		if (!isdigit((unsigned char)ifname[i]))
    240 			return 0;
    241 	}
    242 
    243 	return 1;
    244 }
    245 
    246 static struct lagg_req *
    247 getlagg(prop_dictionary_t env)
    248 {
    249 	struct lagg_req *req = NULL, *p;
    250 	size_t nports, bufsiz;
    251 	int i;
    252 
    253 	if (!is_laggif(env)) {
    254 		if (lagg_debug)
    255 			warnx("valid only with lagg(4) interfaces");
    256 		goto done;
    257 	}
    258 
    259 	for (i = 0, nports = 0; i < LAGG_RETRY_MAX; i++) {
    260 		bufsiz = sizeof(*req);
    261 		bufsiz += sizeof(req->lrq_reqports[0]) * nports;
    262 		p = realloc(req, bufsiz);
    263 		if (p == NULL)
    264 			break;
    265 
    266 		req = p;
    267 		memset(req, 0, bufsiz);
    268 		req->lrq_nports = nports;
    269 		if (indirect_ioctl(env, SIOCGLAGG, req) == 0)
    270 			goto done;
    271 
    272 		if (errno != ENOBUFS)
    273 			break;
    274 		nports = req->lrq_nports + 3; /* 3: additional space */
    275 	}
    276 
    277 	if (req != NULL) {
    278 		free(req);
    279 		req = NULL;
    280 	}
    281 
    282 done:
    283 	return req;
    284 }
    285 
    286 static void
    287 freelagg(struct lagg_req *req)
    288 {
    289 
    290 	free(req);
    291 }
    292 
    293 static void
    294 lagg_status(prop_dictionary_t env, prop_dictionary_t oenv)
    295 {
    296 	struct lagg_req *req;
    297 	struct laggreqport *port;
    298 	const char *proto;
    299 	char str[256];
    300 	size_t i;
    301 
    302 	req = getlagg(env);
    303 	if (req == NULL)
    304 		return;
    305 
    306 	if (req->lrq_proto >= LAGG_PROTO_MAX ||
    307 	    (proto = laggprotostr[req->lrq_proto]) == NULL) {
    308 		proto = "unknown";
    309 	}
    310 
    311 	printf("\tlaggproto %s", proto);
    312 	if (vflag)
    313 		lagg_status_proto(req->lrq_proto, &req->lrq_reqproto);
    314 	putchar('\n');
    315 
    316 	if (req->lrq_nports > 0) {
    317 		printf("\tlaggport:\n");
    318 		for (i = 0; i < req->lrq_nports; i++) {
    319 			port = &req->lrq_reqports[i];
    320 			snprintb(str, sizeof(str),
    321 			    LAGG_PORT_BITS, port->rp_flags);
    322 
    323 			printf("\t\t%.*s pri=%u flags=%s",
    324 			    IFNAMSIZ, port->rp_portname,
    325 			    (unsigned int)port->rp_prio,
    326 			    str);
    327 			if (vflag)
    328 				lagg_status_port(req->lrq_proto, port);
    329 			putchar('\n');
    330 		}
    331 	}
    332 
    333 	freelagg(req);
    334 }
    335 
    336 static int
    337 setlaggproto(prop_dictionary_t env, prop_dictionary_t oenv)
    338 {
    339 	prop_object_t obj;
    340 	struct lagg_req req;
    341 	const char *proto;
    342 	size_t i, proto_len;
    343 
    344 	memset(&req, 0, sizeof(req));
    345 
    346 	obj = prop_dictionary_get(env, "laggproto");
    347 	if (obj == NULL) {
    348 		errno = ENOENT;
    349 		return -1;
    350 	}
    351 
    352 	switch (prop_object_type(obj)) {
    353 	case PROP_TYPE_DATA:
    354 		proto = prop_data_value(obj);
    355 		proto_len = prop_data_size(obj);
    356 		break;
    357 	case PROP_TYPE_STRING:
    358 		proto = prop_string_value(obj);
    359 		proto_len = prop_string_size(obj);
    360 		break;
    361 	default:
    362 		errno = EFAULT;
    363 		return -1;
    364 	}
    365 
    366 	for (i = 0; i < LAGG_PROTO_MAX; i++) {
    367 		if (strncmp(proto, laggprotostr[i], proto_len) == 0)
    368 			break;
    369 	}
    370 
    371 	if (i >= LAGG_PROTO_MAX) {
    372 		errno = EPROTONOSUPPORT;
    373 		return -1;
    374 	}
    375 
    376 	req.lrq_ioctl = LAGGIOC_SETPROTO;
    377 	req.lrq_proto = i;
    378 
    379 	if (indirect_ioctl(env, SIOCSLAGG, &req) == -1)
    380 		return -1;
    381 
    382 	return 0;
    383 }
    384 
    385 static int
    386 setlaggport(prop_dictionary_t env, prop_dictionary_t oenv __unused)
    387 {
    388 	struct lagg_req req;
    389 	struct laggreqport *rp;
    390 	const char *ifname;
    391 	enum lagg_ioctl ioc;
    392 	int64_t lpcmd, pri;
    393 
    394 	if (!prop_dictionary_get_string(env, "laggport", &ifname)) {
    395 		if (lagg_debug)
    396 			warnx("%s.%d", __func__, __LINE__);
    397 		errno = ENOENT;
    398 		return -1;
    399 	}
    400 
    401 	memset(&req, 0, sizeof(req));
    402 	req.lrq_nports = 1;
    403 	rp = &req.lrq_reqports[0];
    404 	strlcpy(rp->rp_portname, ifname, sizeof(rp->rp_portname));
    405 	ioc = LAGGIOC_NOCMD;
    406 
    407 	if (prop_dictionary_get_int64(env, "laggportcmd", &lpcmd)) {
    408 		if (lpcmd == LAGGPORT_ADD) {
    409 			ioc = LAGGIOC_ADDPORT;
    410 		} else {
    411 			ioc = LAGGIOC_DELPORT;
    412 		}
    413 	}
    414 
    415 	if (prop_dictionary_get_int64(env, "laggportpri", &pri)) {
    416 		ioc = LAGGIOC_SETPORTPRI;
    417 		rp->rp_prio = (uint32_t)pri;
    418 	}
    419 
    420 	if (ioc != LAGGIOC_NOCMD) {
    421 		req.lrq_ioctl = ioc;
    422 		if (indirect_ioctl(env, SIOCSLAGG, &req) == -1) {
    423 			if (lagg_debug) {
    424 				warn("cmd=%d", ioc);
    425 			}
    426 			return -1;
    427 		}
    428 	}
    429 
    430 	return 0;
    431 }
    432 
    433 static int
    434 setlagglacp(prop_dictionary_t env, prop_dictionary_t oenv __unused)
    435 {
    436 	struct lagg_req req_add, req_del;
    437 	struct laggreq_lacp *add_lacp, *del_lacp;
    438 	int64_t v;
    439 
    440 	memset(&req_add, 0, sizeof(req_add));
    441 	memset(&req_del, 0, sizeof(req_del));
    442 
    443 	req_add.lrq_proto = req_del.lrq_proto = LAGG_PROTO_LACP;
    444 	req_add.lrq_ioctl = req_del.lrq_ioctl = LAGGIOC_SETPROTOOPT;
    445 	add_lacp = &req_add.lrq_reqproto.rp_lacp;
    446 	del_lacp = &req_del.lrq_reqproto.rp_lacp;
    447 
    448 	add_lacp->command = LAGGIOC_LACPSETFLAGS;
    449 	del_lacp->command = LAGGIOC_LACPCLRFLAGS;
    450 
    451 	if (prop_dictionary_get_int64(env, "lacpdumpdu", &v)) {
    452 		if (v == LAGGLACPOPT_DUMPDU) {
    453 			add_lacp->flags |= LAGGREQLACP_DUMPDU;
    454 		} else {
    455 			del_lacp->flags |= LAGGREQLACP_DUMPDU;
    456 		}
    457 	}
    458 
    459 	if (prop_dictionary_get_int64(env, "lacpstopdu", &v)) {
    460 		if (v == LAGGLACPOPT_STOPDU) {
    461 			add_lacp->flags |= LAGGREQLACP_STOPDU;
    462 		} else {
    463 			del_lacp->flags |= LAGGREQLACP_STOPDU;
    464 		}
    465 	}
    466 
    467 	if (prop_dictionary_get_int64(env, "lacpoptimistic", &v)) {
    468 		if (v == LAGGLACPOPT_OPTIMISTIC) {
    469 			add_lacp->flags |= LAGGREQLACP_OPTIMISTIC;
    470 		} else {
    471 			del_lacp->flags |= LAGGREQLACP_OPTIMISTIC;
    472 		}
    473 	}
    474 
    475 	if (prop_dictionary_get_int64(env, "lacpmultils", &v)) {
    476 		if (v == LAGGLACPOPT_MULTILS) {
    477 			add_lacp->flags |= LAGGREQLACP_MULTILS;
    478 		} else {
    479 			del_lacp->flags |= LAGGREQLACP_MULTILS;
    480 		}
    481 	}
    482 
    483 	if (del_lacp->flags != 0) {
    484 		if (indirect_ioctl(env, SIOCSLAGG, &req_del) == -1) {
    485 			if (lagg_debug) {
    486 				warn("cmd=%d, pcmd=%d",
    487 				    req_del.lrq_ioctl,
    488 				    del_lacp->command);
    489 			}
    490 			return -1;
    491 		}
    492 	}
    493 
    494 	if (add_lacp->flags != 0) {
    495 		if (indirect_ioctl(env, SIOCSLAGG, &req_add) == -1) {
    496 			if (lagg_debug) {
    497 				warn("cmd=%d, pcmd=%d",
    498 				    req_add.lrq_ioctl,
    499 				    add_lacp->command);
    500 			}
    501 			return -1;
    502 		}
    503 	}
    504 
    505 	return 0;
    506 }
    507 
    508 static int
    509 setlagglacpmaxports(prop_dictionary_t env,
    510     prop_dictionary_t oenv __unused)
    511 {
    512 	struct lagg_req req;
    513 	struct laggreq_lacp *lrq_lacp;
    514 	int64_t v;
    515 
    516 	memset(&req, 0, sizeof(req));
    517 	req.lrq_proto = LAGG_PROTO_LACP;
    518 	req.lrq_ioctl = LAGGIOC_SETPROTOOPT;
    519 	lrq_lacp = &req.lrq_reqproto.rp_lacp;
    520 
    521 	if (!prop_dictionary_get_int64(env, "lacpmaxports", &v)) {
    522 		if (lagg_debug)
    523 			warnx("%s.%d", __func__, __LINE__);
    524 		errno = ENOENT;
    525 		return -1;
    526 	}
    527 
    528 	if (v <= 0) {
    529 		lrq_lacp->command = LAGGIOC_LACPCLRMAXPORTS;
    530 	} else if (v > 0){
    531 		lrq_lacp->command = LAGGIOC_LACPSETMAXPORTS;
    532 		lrq_lacp->maxports = (size_t)v;
    533 	}
    534 
    535 	if (indirect_ioctl(env, SIOCSLAGG, &req) == -1) {
    536 		err(EXIT_FAILURE, "SIOCSLAGGPROTO");
    537 	}
    538 
    539 	return 0;
    540 }
    541 
    542 static int
    543 setlaggfail(prop_dictionary_t env,
    544     prop_dictionary_t oenv __unused)
    545 {
    546 	struct lagg_req req_add, req_del;
    547 	struct laggreq_fail *add_fail, *del_fail;
    548 	int64_t v;
    549 
    550 	memset(&req_add, 0, sizeof(req_add));
    551 	memset(&req_del, 0, sizeof(req_del));
    552 
    553 	req_add.lrq_proto = req_del.lrq_proto = LAGG_PROTO_FAILOVER;
    554 	req_add.lrq_ioctl = req_del.lrq_ioctl = LAGGIOC_SETPROTOOPT;
    555 	add_fail = &req_add.lrq_reqproto.rp_fail;
    556 	del_fail = &req_del.lrq_reqproto.rp_fail;
    557 
    558 	add_fail->command = LAGGIOC_FAILSETFLAGS;
    559 	del_fail->command = LAGGIOC_FAILCLRFLAGS;
    560 
    561 	if (prop_dictionary_get_int64(env, "failrxall", &v)) {
    562 		if (v == LAGGFAILOPT_RXALL) {
    563 			add_fail->flags |= LAGGREQFAIL_RXALL;
    564 		} else {
    565 			del_fail->flags |= LAGGREQFAIL_RXALL;
    566 		}
    567 	}
    568 
    569 	if (del_fail->flags != 0) {
    570 		if (indirect_ioctl(env, SIOCSLAGG, &req_del) == -1) {
    571 			if (lagg_debug) {
    572 				warn("cmd=%d, pcmd=%d",
    573 				    req_del.lrq_ioctl,
    574 				    del_fail->command);
    575 			}
    576 			return -1;
    577 		}
    578 	}
    579 
    580 	if (add_fail->flags != 0) {
    581 		if (indirect_ioctl(env, SIOCSLAGG, &req_add) == -1) {
    582 			if (lagg_debug) {
    583 				warn("cmd=%d, pcmd=%d",
    584 				    req_add.lrq_ioctl,
    585 				    add_fail->command);
    586 			}
    587 			return -1;
    588 		}
    589 	}
    590 
    591 	return 0;
    592 }
    593 
    594 static void
    595 lagg_usage(prop_dictionary_t env __unused)
    596 {
    597 
    598 	fprintf(stderr, "\t[ laggproto p ]\n");
    599 	fprintf(stderr, "\t[ laggport i [ pri n ] ] "
    600 	    "[ -laggport i ]\n");
    601 	fprintf(stderr, "\t[ laggportpri i [ pri n]]\n");
    602 	fprintf(stderr, "\t[ lagglacp [ dumpdu | -dumpdu ] "
    603 	    "[ stopdu | -stopdu ]\n"
    604 	    "\t\t[ maxports n | -maxports ] [ optimistic | -optimistic ] ]\n");
    605 	fprintf(stderr, "\t[ laggfailover] [ rx-all | -rx-all ]\n");
    606 }
    607 static void
    608 lacp_format_id(char *buf, size_t len,
    609     uint16_t system_prio, uint8_t *system_mac, uint16_t system_key)
    610 {
    611 
    612 	snprintf(buf, len, "[%04X,%02X-%02X-%02X-%02X-%02X-%02X,"
    613 	    "%04X]",
    614 	    system_prio,
    615 	    (unsigned int)system_mac[0],(unsigned int)system_mac[1],
    616 	    (unsigned int)system_mac[2],(unsigned int)system_mac[3],
    617 	    (unsigned int)system_mac[4],(unsigned int)system_mac[5],
    618 	    system_key);
    619 }
    620 
    621 static void
    622 lagg_status_proto(lagg_proto pr, struct laggreqproto *req)
    623 {
    624 	struct laggreq_lacp *lacp;
    625 	char str[256];
    626 
    627 	switch (pr) {
    628 	case LAGG_PROTO_LACP:
    629 		lacp = &req->rp_lacp;
    630 
    631 		printf("\n");
    632 		snprintb(str, sizeof(str), LAGGREQLACP_BITS,
    633 		    lacp->flags);
    634 		printf("\t\tmax ports=%zu, flags=%s\n",
    635 		    lacp->maxports, str);
    636 
    637 		lacp_format_id(str, sizeof(str), lacp->actor_prio,
    638 		    lacp->actor_mac, lacp->actor_key);
    639 		printf("\t\tactor=%s\n", str);
    640 
    641 		lacp_format_id(str, sizeof(str), lacp->partner_prio,
    642 		    lacp->partner_mac, lacp->partner_key);
    643 		printf("\t\tpartner=%s", str);
    644 		break;
    645 	default:
    646 		break;
    647 	}
    648 }
    649 
    650 static void
    651 lagg_status_port(lagg_proto pr, struct laggreqport *req)
    652 {
    653 	struct laggreq_lacpport *lacp;
    654 	char str[256];
    655 
    656 	switch (pr) {
    657 	case LAGG_PROTO_LACP:
    658 		lacp = &req->rp_lacpport;
    659 
    660 		putchar('\n');
    661 
    662 		snprintb(str, sizeof(str), LACP_STATE_BITS, lacp->actor_state);
    663 		printf("\t\t\tactor: state=%s\n",str);
    664 
    665 		lacp_format_id(str, sizeof(str), lacp->partner_prio,
    666 		    lacp->partner_mac, lacp->partner_key);
    667 		printf("\t\t\tpartner=%s\n", str);
    668 		snprintb(str, sizeof(str), LACP_STATE_BITS,
    669 		    lacp->partner_state);
    670 		printf("\t\t\tpartner: port=%04X prio=%04X state=%s",
    671 		    lacp->partner_portno, lacp->partner_portprio, str);
    672 		break;
    673 	default:
    674 		break;
    675 	}
    676 }
    677