ip/iplink_bond.c

   1 /*
   2  * iplink_bond.c        Bonding device support
   3  *
   4  *              This program is free software; you can redistribute it and/or
   5  *              modify it under the terms of the GNU General Public License
   6  *              as published by the Free Software Foundation; either version
   7  *              2 of the License, or (at your option) any later version.
   8  *
   9  * Authors:     Jiri Pirko <jiri@resnulli.us>
  10  *              Scott Feldman <sfeldma@cumulusnetworks.com>
  11  */
  12
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <linux/if_link.h>
  17 #include <linux/if_ether.h>
  18 #include <net/if.h>
  19
  20 #include "rt_names.h"
  21 #include "utils.h"
  22 #include "ip_common.h"
  23
  24 #define BOND_MAX_ARP_TARGETS    16
  25
  26 static const char *mode_tbl[] = {
  27         "balance-rr",
  28         "active-backup",
  29         "balance-xor",
  30         "broadcast",
  31         "802.3ad",
  32         "balance-tlb",
  33         "balance-alb",
  34         NULL,
  35 };
  36
  37 static const char *arp_validate_tbl[] = {
  38         "none",
  39         "active",
  40         "backup",
  41         "all",
  42         NULL,
  43 };
  44
  45 static const char *arp_all_targets_tbl[] = {
  46         "any",
  47         "all",
  48         NULL,
  49 };
  50
  51 static const char *primary_reselect_tbl[] = {
  52         "always",
  53         "better",
  54         "failure",
  55         NULL,
  56 };
  57
  58 static const char *fail_over_mac_tbl[] = {
  59         "none",
  60         "active",
  61         "follow",
  62         NULL,
  63 };
  64
  65 static const char *xmit_hash_policy_tbl[] = {
  66         "layer2",
  67         "layer3+4",
  68         "layer2+3",
  69         "encap2+3",
  70         "encap3+4",
  71         NULL,
  72 };
  73
  74 static const char *lacp_rate_tbl[] = {
  75         "slow",
  76         "fast",
  77         NULL,
  78 };
  79
  80 static const char *ad_select_tbl[] = {
  81         "stable",
  82         "bandwidth",
  83         "count",
  84         NULL,
  85 };
  86
  87 static const char *get_name(const char **tbl, int index)
  88 {
  89         int i;
  90
  91         for (i = 0; tbl[i]; i++)
  92                 if (i == index)
  93                         return tbl[i];
  94
  95         return "UNKNOWN";
  96 }
  97
  98 static int get_index(const char **tbl, char *name)
  99 {
 100         int i, index;
 101
 102         /* check for integer index passed in instead of name */
 103         if (get_integer(&index, name, 10) == 0)
 104                 for (i = 0; tbl[i]; i++)
 105                         if (i == index)
 106                                 return i;
 107
 108         for (i = 0; tbl[i]; i++)
 109                 if (strcmp(tbl[i], name) == 0)
 110                         return i;
 111
 112         return -1;
 113 }
 114
 115 static void explain(void)
 116 {
 117         fprintf(stderr,
 118                 "Usage: ... bond [ mode BONDMODE ] [ active_slave SLAVE_DEV ]\n"
 119                 "                [ clear_active_slave ] [ miimon MIIMON ]\n"
 120                 "                [ updelay UPDELAY ] [ downdelay DOWNDELAY ]\n"
 121                 "                [ use_carrier USE_CARRIER ]\n"
 122                 "                [ arp_interval ARP_INTERVAL ]\n"
 123                 "                [ arp_validate ARP_VALIDATE ]\n"
 124                 "                [ arp_all_targets ARP_ALL_TARGETS ]\n"
 125                 "                [ arp_ip_target [ ARP_IP_TARGET, ... ] ]\n"
 126                 "                [ primary SLAVE_DEV ]\n"
 127                 "                [ primary_reselect PRIMARY_RESELECT ]\n"
 128                 "                [ fail_over_mac FAIL_OVER_MAC ]\n"
 129                 "                [ xmit_hash_policy XMIT_HASH_POLICY ]\n"
 130                 "                [ resend_igmp RESEND_IGMP ]\n"
 131                 "                [ num_grat_arp|num_unsol_na NUM_GRAT_ARP|NUM_UNSOL_NA ]\n"
 132                 "                [ all_slaves_active ALL_SLAVES_ACTIVE ]\n"
 133                 "                [ min_links MIN_LINKS ]\n"
 134                 "                [ lp_interval LP_INTERVAL ]\n"
 135                 "                [ packets_per_slave PACKETS_PER_SLAVE ]\n"
 136                 "                [ lacp_rate LACP_RATE ]\n"
 137                 "                [ ad_select AD_SELECT ]\n"
 138                 "\n"
 139                 "BONDMODE := balance-rr|active-backup|balance-xor|broadcast|802.3ad|balance-tlb|balance-alb\n"
 140                 "ARP_VALIDATE := none|active|backup|all\n"
 141                 "ARP_ALL_TARGETS := any|all\n"
 142                 "PRIMARY_RESELECT := always|better|failure\n"
 143                 "FAIL_OVER_MAC := none|active|follow\n"
 144                 "XMIT_HASH_POLICY := layer2|layer2+3|layer3+4\n"
 145                 "LACP_RATE := slow|fast\n"
 146                 "AD_SELECT := stable|bandwidth|count\n"
 147         );
 148 }
 149
 150 static int bond_parse_opt(struct link_util *lu, int argc, char **argv,
 151                           struct nlmsghdr *n)
 152 {
 153         __u8 mode, use_carrier, primary_reselect, fail_over_mac;
 154         __u8 xmit_hash_policy, num_peer_notif, all_slaves_active;
 155         __u8 lacp_rate, ad_select;
 156         __u32 miimon, updelay, downdelay, arp_interval, arp_validate;
 157         __u32 arp_all_targets, resend_igmp, min_links, lp_interval;
 158         __u32 packets_per_slave;
 159         unsigned ifindex;
 160
 161         while (argc > 0) {
 162                 if (matches(*argv, "mode") == 0) {
 163                         NEXT_ARG();
 164                         if (get_index(mode_tbl, *argv) < 0) {
 165                                 invarg("invalid mode", *argv);
 166                                 return -1;
 167                         }
 168                         mode = get_index(mode_tbl, *argv);
 169                         addattr8(n, 1024, IFLA_BOND_MODE, mode);
 170                 } else if (matches(*argv, "active_slave") == 0) {
 171                         NEXT_ARG();
 172                         ifindex = if_nametoindex(*argv);
 173                         if (!ifindex)
 174                                 return -1;
 175                         addattr32(n, 1024, IFLA_BOND_ACTIVE_SLAVE, ifindex);
 176                 } else if (matches(*argv, "clear_active_slave") == 0) {
 177                         addattr32(n, 1024, IFLA_BOND_ACTIVE_SLAVE, 0);
 178                 } else if (matches(*argv, "miimon") == 0) {
 179                         NEXT_ARG();
 180                         if (get_u32(&miimon, *argv, 0)) {
 181                                 invarg("invalid miimon", *argv);
 182                                 return -1;
 183                         }
 184                         addattr32(n, 1024, IFLA_BOND_MIIMON, miimon);
 185                 } else if (matches(*argv, "updelay") == 0) {
 186                         NEXT_ARG();
 187                         if (get_u32(&updelay, *argv, 0)) {
 188                                 invarg("invalid updelay", *argv);
 189                                 return -1;
 190                         }
 191                         addattr32(n, 1024, IFLA_BOND_UPDELAY, updelay);
 192                 } else if (matches(*argv, "downdelay") == 0) {
 193                         NEXT_ARG();
 194                         if (get_u32(&downdelay, *argv, 0)) {
 195                                 invarg("invalid downdelay", *argv);
 196                                 return -1;
 197                         }
 198                         addattr32(n, 1024, IFLA_BOND_DOWNDELAY, downdelay);
 199                 } else if (matches(*argv, "use_carrier") == 0) {
 200                         NEXT_ARG();
 201                         if (get_u8(&use_carrier, *argv, 0)) {
 202                                 invarg("invalid use_carrier", *argv);
 203                                 return -1;
 204                         }
 205                         addattr8(n, 1024, IFLA_BOND_USE_CARRIER, use_carrier);
 206                 } else if (matches(*argv, "arp_interval") == 0) {
 207                         NEXT_ARG();
 208                         if (get_u32(&arp_interval, *argv, 0)) {
 209                                 invarg("invalid arp_interval", *argv);
 210                                 return -1;
 211                         }
 212                         addattr32(n, 1024, IFLA_BOND_ARP_INTERVAL, arp_interval);
 213                 } else if (matches(*argv, "arp_ip_target") == 0) {
 214                         struct rtattr * nest = addattr_nest(n, 1024,
 215                                 IFLA_BOND_ARP_IP_TARGET);
 216                         if (NEXT_ARG_OK()) {
 217                                 NEXT_ARG();
 218                                 char *targets = strdupa(*argv);
 219                                 char *target = strtok(targets, ",");
 220                                 int i;
 221
 222                                 for(i = 0; target && i < BOND_MAX_ARP_TARGETS; i++) {
 223                                         __u32 addr = get_addr32(target);
 224                                         addattr32(n, 1024, i, addr);
 225                                         target = strtok(NULL, ",");
 226                                 }
 227                                 addattr_nest_end(n, nest);
 228                         }
 229                         addattr_nest_end(n, nest);
 230                 } else if (matches(*argv, "arp_validate") == 0) {
 231                         NEXT_ARG();
 232                         if (get_index(arp_validate_tbl, *argv) < 0) {
 233                                 invarg("invalid arp_validate", *argv);
 234                                 return -1;
 235                         }
 236                         arp_validate = get_index(arp_validate_tbl, *argv);
 237                         addattr32(n, 1024, IFLA_BOND_ARP_VALIDATE, arp_validate);
 238                 } else if (matches(*argv, "arp_all_targets") == 0) {
 239                         NEXT_ARG();
 240                         if (get_index(arp_all_targets_tbl, *argv) < 0) {
 241                                 invarg("invalid arp_all_targets", *argv);
 242                                 return -1;
 243                         }
 244                         arp_all_targets = get_index(arp_all_targets_tbl, *argv);
 245                         addattr32(n, 1024, IFLA_BOND_ARP_ALL_TARGETS, arp_all_targets);
 246                 } else if (matches(*argv, "primary") == 0) {
 247                         NEXT_ARG();
 248                         ifindex = if_nametoindex(*argv);
 249                         if (!ifindex)
 250                                 return -1;
 251                         addattr32(n, 1024, IFLA_BOND_PRIMARY, ifindex);
 252                 } else if (matches(*argv, "primary_reselect") == 0) {
 253                         NEXT_ARG();
 254                         if (get_index(primary_reselect_tbl, *argv) < 0) {
 255                                 invarg("invalid primary_reselect", *argv);
 256                                 return -1;
 257                         }
 258                         primary_reselect = get_index(primary_reselect_tbl, *argv);
 259                         addattr8(n, 1024, IFLA_BOND_PRIMARY_RESELECT,
 260                                  primary_reselect);
 261                 } else if (matches(*argv, "fail_over_mac") == 0) {
 262                         NEXT_ARG();
 263                         if (get_index(fail_over_mac_tbl, *argv) < 0) {
 264                                 invarg("invalid fail_over_mac", *argv);
 265                                 return -1;
 266                         }
 267                         fail_over_mac = get_index(fail_over_mac_tbl, *argv);
 268                         addattr8(n, 1024, IFLA_BOND_FAIL_OVER_MAC,
 269                                  fail_over_mac);
 270                 } else if (matches(*argv, "xmit_hash_policy") == 0) {
 271                         NEXT_ARG();
 272                         if (get_index(xmit_hash_policy_tbl, *argv) < 0) {
 273                                 invarg("invalid xmit_hash_policy", *argv);
 274                                 return -1;
 275                         }
 276                         xmit_hash_policy = get_index(xmit_hash_policy_tbl, *argv);
 277                         addattr8(n, 1024, IFLA_BOND_XMIT_HASH_POLICY,
 278                                  xmit_hash_policy);
 279                 } else if (matches(*argv, "resend_igmp") == 0) {
 280                         NEXT_ARG();
 281                         if (get_u32(&resend_igmp, *argv, 0)) {
 282                                 invarg("invalid resend_igmp", *argv);
 283                                 return -1;
 284                         }
 285                         addattr32(n, 1024, IFLA_BOND_RESEND_IGMP, resend_igmp);
 286                 } else if (matches(*argv, "num_grat_arp") == 0 ||
 287                            matches(*argv, "num_unsol_na") == 0) {
 288                         NEXT_ARG();
 289                         if (get_u8(&num_peer_notif, *argv, 0)) {
 290                                 invarg("invalid num_grat_arp|num_unsol_na",
 291                                        *argv);
 292                                 return -1;
 293                         }
 294                         addattr8(n, 1024, IFLA_BOND_NUM_PEER_NOTIF,
 295                                  num_peer_notif);
 296                 } else if (matches(*argv, "all_slaves_active") == 0) {
 297                         NEXT_ARG();
 298                         if (get_u8(&all_slaves_active, *argv, 0)) {
 299                                 invarg("invalid all_slaves_active", *argv);
 300                                 return -1;
 301                         }
 302                         addattr8(n, 1024, IFLA_BOND_ALL_SLAVES_ACTIVE,
 303                                  all_slaves_active);
 304                 } else if (matches(*argv, "min_links") == 0) {
 305                         NEXT_ARG();
 306                         if (get_u32(&min_links, *argv, 0)) {
 307                                 invarg("invalid min_links", *argv);
 308                                 return -1;
 309                         }
 310                         addattr32(n, 1024, IFLA_BOND_MIN_LINKS, min_links);
 311                 } else if (matches(*argv, "lp_interval") == 0) {
 312                         NEXT_ARG();
 313                         if (get_u32(&lp_interval, *argv, 0)) {
 314                                 invarg("invalid lp_interval", *argv);
 315                                 return -1;
 316                         }
 317                         addattr32(n, 1024, IFLA_BOND_LP_INTERVAL, lp_interval);
 318                 } else if (matches(*argv, "packets_per_slave") == 0) {
 319                         NEXT_ARG();
 320                         if (get_u32(&packets_per_slave, *argv, 0)) {
 321                                 invarg("invalid packets_per_slave", *argv);
 322                                 return -1;
 323                         }
 324                         addattr32(n, 1024, IFLA_BOND_PACKETS_PER_SLAVE,
 325                                   packets_per_slave);
 326                 } else if (matches(*argv, "lacp_rate") == 0) {
 327                         NEXT_ARG();
 328                         if (get_index(lacp_rate_tbl, *argv) < 0) {
 329                                 invarg("invalid lacp_rate", *argv);
 330                                 return -1;
 331                         }
 332                         lacp_rate = get_index(lacp_rate_tbl, *argv);
 333                         addattr8(n, 1024, IFLA_BOND_AD_LACP_RATE, lacp_rate);
 334                 } else if (matches(*argv, "ad_select") == 0) {
 335                         NEXT_ARG();
 336                         if (get_index(ad_select_tbl, *argv) < 0) {
 337                                 invarg("invalid ad_select", *argv);
 338                                 return -1;
 339                         }
 340                         ad_select = get_index(ad_select_tbl, *argv);
 341                         addattr8(n, 1024, IFLA_BOND_AD_SELECT, ad_select);
 342                 } else {
 343                         fprintf(stderr, "bond: unknown command \"%s\"?\n", *argv);
 344                         explain();
 345                         return -1;
 346                 }
 347                 argc--, argv++;
 348         }
 349
 350         return 0;
 351 }
 352
 353 static void bond_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[])
 354 {
 355         unsigned ifindex;
 356
 357         if (!tb)
 358                 return;
 359
 360         if (tb[IFLA_BOND_MODE]) {
 361                 const char *mode = get_name(mode_tbl,
 362                         rta_getattr_u8(tb[IFLA_BOND_MODE]));
 363                 fprintf(f, "mode %s ", mode);
 364         }
 365
 366         if (tb[IFLA_BOND_ACTIVE_SLAVE] &&
 367             (ifindex = rta_getattr_u32(tb[IFLA_BOND_ACTIVE_SLAVE]))) {
 368                 char buf[IFNAMSIZ];
 369                 const char *n = if_indextoname(ifindex, buf);
 370
 371                 if (n)
 372                         fprintf(f, "active_slave %s ", n);
 373                 else
 374                         fprintf(f, "active_slave %u ", ifindex);
 375         }
 376
 377         if (tb[IFLA_BOND_MIIMON])
 378                 fprintf(f, "miimon %u ", rta_getattr_u32(tb[IFLA_BOND_MIIMON]));
 379
 380         if (tb[IFLA_BOND_UPDELAY])
 381                 fprintf(f, "updelay %u ", rta_getattr_u32(tb[IFLA_BOND_UPDELAY]));
 382
 383         if (tb[IFLA_BOND_DOWNDELAY])
 384                 fprintf(f, "downdelay %u ",
 385                         rta_getattr_u32(tb[IFLA_BOND_DOWNDELAY]));
 386
 387         if (tb[IFLA_BOND_USE_CARRIER])
 388                 fprintf(f, "use_carrier %u ",
 389                         rta_getattr_u8(tb[IFLA_BOND_USE_CARRIER]));
 390
 391         if (tb[IFLA_BOND_ARP_INTERVAL])
 392                 fprintf(f, "arp_interval %u ",
 393                         rta_getattr_u32(tb[IFLA_BOND_ARP_INTERVAL]));
 394
 395         if (tb[IFLA_BOND_ARP_IP_TARGET]) {
 396                 struct rtattr *iptb[BOND_MAX_ARP_TARGETS + 1];
 397                 char buf[INET_ADDRSTRLEN];
 398                 int i;
 399
 400                 parse_rtattr_nested(iptb, BOND_MAX_ARP_TARGETS,
 401                         tb[IFLA_BOND_ARP_IP_TARGET]);
 402
 403                 if (iptb[0])
 404                         fprintf(f, "arp_ip_target ");
 405
 406                 for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) {
 407                         if (iptb[i])
 408                                 fprintf(f, "%s",
 409                                         rt_addr_n2a(AF_INET,
 410                                                     RTA_PAYLOAD(iptb[i]),
 411                                                     RTA_DATA(iptb[i]),
 412                                                     buf,
 413                                                     INET_ADDRSTRLEN));
 414                         if (i < BOND_MAX_ARP_TARGETS-1 && iptb[i+1])
 415                                 fprintf(f, ",");
 416                 }
 417
 418                 if (iptb[0])
 419                         fprintf(f, " ");
 420         }
 421
 422         if (tb[IFLA_BOND_ARP_VALIDATE]) {
 423                 const char *arp_validate = get_name(arp_validate_tbl,
 424                         rta_getattr_u32(tb[IFLA_BOND_ARP_VALIDATE]));
 425                 fprintf(f, "arp_validate %s ", arp_validate);
 426         }
 427
 428         if (tb[IFLA_BOND_ARP_ALL_TARGETS]) {
 429                 const char *arp_all_targets = get_name(arp_all_targets_tbl,
 430                         rta_getattr_u32(tb[IFLA_BOND_ARP_ALL_TARGETS]));
 431                 fprintf(f, "arp_all_targets %s ", arp_all_targets);
 432         }
 433
 434         if (tb[IFLA_BOND_PRIMARY] &&
 435             (ifindex = rta_getattr_u32(tb[IFLA_BOND_PRIMARY]))) {
 436                 char buf[IFNAMSIZ];
 437                 const char *n = if_indextoname(ifindex, buf);
 438
 439                 if (n)
 440                         fprintf(f, "primary %s ", n);
 441                 else
 442                         fprintf(f, "primary %u ", ifindex);
 443         }
 444
 445         if (tb[IFLA_BOND_PRIMARY_RESELECT]) {
 446                 const char *primary_reselect = get_name(primary_reselect_tbl,
 447                         rta_getattr_u8(tb[IFLA_BOND_PRIMARY_RESELECT]));
 448                 fprintf(f, "primary_reselect %s ", primary_reselect);
 449         }
 450
 451         if (tb[IFLA_BOND_FAIL_OVER_MAC]) {
 452                 const char *fail_over_mac = get_name(fail_over_mac_tbl,
 453                         rta_getattr_u8(tb[IFLA_BOND_FAIL_OVER_MAC]));
 454                 fprintf(f, "fail_over_mac %s ", fail_over_mac);
 455         }
 456
 457         if (tb[IFLA_BOND_XMIT_HASH_POLICY]) {
 458                 const char *xmit_hash_policy = get_name(xmit_hash_policy_tbl,
 459                         rta_getattr_u8(tb[IFLA_BOND_XMIT_HASH_POLICY]));
 460                 fprintf(f, "xmit_hash_policy %s ", xmit_hash_policy);
 461         }
 462
 463         if (tb[IFLA_BOND_RESEND_IGMP])
 464                 fprintf(f, "resend_igmp %u ",
 465                         rta_getattr_u32(tb[IFLA_BOND_RESEND_IGMP]));
 466
 467         if (tb[IFLA_BOND_NUM_PEER_NOTIF])
 468                 fprintf(f, "num_grat_arp %u ",
 469                         rta_getattr_u8(tb[IFLA_BOND_NUM_PEER_NOTIF]));
 470
 471         if (tb[IFLA_BOND_ALL_SLAVES_ACTIVE])
 472                 fprintf(f, "all_slaves_active %u ",
 473                         rta_getattr_u8(tb[IFLA_BOND_ALL_SLAVES_ACTIVE]));
 474
 475         if (tb[IFLA_BOND_MIN_LINKS])
 476                 fprintf(f, "min_links %u ",
 477                         rta_getattr_u32(tb[IFLA_BOND_MIN_LINKS]));
 478
 479         if (tb[IFLA_BOND_LP_INTERVAL])
 480                 fprintf(f, "lp_interval %u ",
 481                         rta_getattr_u32(tb[IFLA_BOND_LP_INTERVAL]));
 482
 483         if (tb[IFLA_BOND_PACKETS_PER_SLAVE])
 484                 fprintf(f, "packets_per_slave %u ",
 485                         rta_getattr_u32(tb[IFLA_BOND_PACKETS_PER_SLAVE]));
 486
 487         if (tb[IFLA_BOND_AD_LACP_RATE]) {
 488                 const char *lacp_rate = get_name(lacp_rate_tbl,
 489                         rta_getattr_u8(tb[IFLA_BOND_AD_LACP_RATE]));
 490                 fprintf(f, "lacp_rate %s ", lacp_rate);
 491         }
 492
 493         if (tb[IFLA_BOND_AD_SELECT]) {
 494                 const char *ad_select = get_name(ad_select_tbl,
 495                         rta_getattr_u8(tb[IFLA_BOND_AD_SELECT]));
 496                 fprintf(f, "ad_select %s ", ad_select);
 497         }
 498
 499         if (tb[IFLA_BOND_AD_INFO]) {
 500                 struct rtattr *adtb[IFLA_BOND_AD_INFO_MAX + 1];
 501
 502                 parse_rtattr_nested(adtb, IFLA_BOND_AD_INFO_MAX,
 503                         tb[IFLA_BOND_AD_INFO]);
 504
 505                 if (adtb[IFLA_BOND_AD_INFO_AGGREGATOR])
 506                         fprintf(f, "ad_aggregator %d ",
 507                           rta_getattr_u16(adtb[IFLA_BOND_AD_INFO_AGGREGATOR]));
 508
 509                 if (adtb[IFLA_BOND_AD_INFO_NUM_PORTS])
 510                         fprintf(f, "ad_num_ports %d ",
 511                           rta_getattr_u16(adtb[IFLA_BOND_AD_INFO_NUM_PORTS]));
 512
 513                 if (adtb[IFLA_BOND_AD_INFO_ACTOR_KEY])
 514                         fprintf(f, "ad_actor_key %d ",
 515                           rta_getattr_u16(adtb[IFLA_BOND_AD_INFO_ACTOR_KEY]));
 516
 517                 if (adtb[IFLA_BOND_AD_INFO_PARTNER_KEY])
 518                         fprintf(f, "ad_partner_key %d ",
 519                           rta_getattr_u16(adtb[IFLA_BOND_AD_INFO_PARTNER_KEY]));
 520
 521                 if (adtb[IFLA_BOND_AD_INFO_PARTNER_MAC]) {
 522                         unsigned char *p =
 523                                 RTA_DATA(adtb[IFLA_BOND_AD_INFO_PARTNER_MAC]);
 524                         SPRINT_BUF(b);
 525                         fprintf(f, "ad_partner_mac %s ",
 526                                 ll_addr_n2a(p, ETH_ALEN, 0, b, sizeof(b)));
 527                 }
 528         }
 529 }
 530
 531 struct link_util bond_link_util = {
 532         .id             = "bond",
 533         .maxattr        = IFLA_BOND_MAX,
 534         .parse_opt      = bond_parse_opt,
 535         .print_opt      = bond_print_opt,
 536 };