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 if (matches(*argv, "help") == 0) {
 343                         explain();
 344                         return -1;
 345                 } else {
 346                         fprintf(stderr, "bond: unknown command \"%s\"?\n", *argv);
 347                         explain();
 348                         return -1;
 349                 }
 350                 argc--, argv++;
 351         }
 352
 353         return 0;
 354 }
 355
 356 static void bond_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[])
 357 {
 358         unsigned ifindex;
 359
 360         if (!tb)
 361                 return;
 362
 363         if (tb[IFLA_BOND_MODE]) {
 364                 const char *mode = get_name(mode_tbl,
 365                         rta_getattr_u8(tb[IFLA_BOND_MODE]));
 366                 fprintf(f, "mode %s ", mode);
 367         }
 368
 369         if (tb[IFLA_BOND_ACTIVE_SLAVE] &&
 370             (ifindex = rta_getattr_u32(tb[IFLA_BOND_ACTIVE_SLAVE]))) {
 371                 char buf[IFNAMSIZ];
 372                 const char *n = if_indextoname(ifindex, buf);
 373
 374                 if (n)
 375                         fprintf(f, "active_slave %s ", n);
 376                 else
 377                         fprintf(f, "active_slave %u ", ifindex);
 378         }
 379
 380         if (tb[IFLA_BOND_MIIMON])
 381                 fprintf(f, "miimon %u ", rta_getattr_u32(tb[IFLA_BOND_MIIMON]));
 382
 383         if (tb[IFLA_BOND_UPDELAY])
 384                 fprintf(f, "updelay %u ", rta_getattr_u32(tb[IFLA_BOND_UPDELAY]));
 385
 386         if (tb[IFLA_BOND_DOWNDELAY])
 387                 fprintf(f, "downdelay %u ",
 388                         rta_getattr_u32(tb[IFLA_BOND_DOWNDELAY]));
 389
 390         if (tb[IFLA_BOND_USE_CARRIER])
 391                 fprintf(f, "use_carrier %u ",
 392                         rta_getattr_u8(tb[IFLA_BOND_USE_CARRIER]));
 393
 394         if (tb[IFLA_BOND_ARP_INTERVAL])
 395                 fprintf(f, "arp_interval %u ",
 396                         rta_getattr_u32(tb[IFLA_BOND_ARP_INTERVAL]));
 397
 398         if (tb[IFLA_BOND_ARP_IP_TARGET]) {
 399                 struct rtattr *iptb[BOND_MAX_ARP_TARGETS + 1];
 400                 char buf[INET_ADDRSTRLEN];
 401                 int i;
 402
 403                 parse_rtattr_nested(iptb, BOND_MAX_ARP_TARGETS,
 404                         tb[IFLA_BOND_ARP_IP_TARGET]);
 405
 406                 if (iptb[0])
 407                         fprintf(f, "arp_ip_target ");
 408
 409                 for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) {
 410                         if (iptb[i])
 411                                 fprintf(f, "%s",
 412                                         rt_addr_n2a(AF_INET,
 413                                                     RTA_DATA(iptb[i]),
 414                                                     buf,
 415                                                     INET_ADDRSTRLEN));
 416                         if (i < BOND_MAX_ARP_TARGETS-1 && iptb[i+1])
 417                                 fprintf(f, ",");
 418                 }
 419
 420                 if (iptb[0])
 421                         fprintf(f, " ");
 422         }
 423
 424         if (tb[IFLA_BOND_ARP_VALIDATE]) {
 425                 const char *arp_validate = get_name(arp_validate_tbl,
 426                         rta_getattr_u32(tb[IFLA_BOND_ARP_VALIDATE]));
 427                 fprintf(f, "arp_validate %s ", arp_validate);
 428         }
 429
 430         if (tb[IFLA_BOND_ARP_ALL_TARGETS]) {
 431                 const char *arp_all_targets = get_name(arp_all_targets_tbl,
 432                         rta_getattr_u32(tb[IFLA_BOND_ARP_ALL_TARGETS]));
 433                 fprintf(f, "arp_all_targets %s ", arp_all_targets);
 434         }
 435
 436         if (tb[IFLA_BOND_PRIMARY] &&
 437             (ifindex = rta_getattr_u32(tb[IFLA_BOND_PRIMARY]))) {
 438                 char buf[IFNAMSIZ];
 439                 const char *n = if_indextoname(ifindex, buf);
 440
 441                 if (n)
 442                         fprintf(f, "primary %s ", n);
 443                 else
 444                         fprintf(f, "primary %u ", ifindex);
 445         }
 446
 447         if (tb[IFLA_BOND_PRIMARY_RESELECT]) {
 448                 const char *primary_reselect = get_name(primary_reselect_tbl,
 449                         rta_getattr_u8(tb[IFLA_BOND_PRIMARY_RESELECT]));
 450                 fprintf(f, "primary_reselect %s ", primary_reselect);
 451         }
 452
 453         if (tb[IFLA_BOND_FAIL_OVER_MAC]) {
 454                 const char *fail_over_mac = get_name(fail_over_mac_tbl,
 455                         rta_getattr_u8(tb[IFLA_BOND_FAIL_OVER_MAC]));
 456                 fprintf(f, "fail_over_mac %s ", fail_over_mac);
 457         }
 458
 459         if (tb[IFLA_BOND_XMIT_HASH_POLICY]) {
 460                 const char *xmit_hash_policy = get_name(xmit_hash_policy_tbl,
 461                         rta_getattr_u8(tb[IFLA_BOND_XMIT_HASH_POLICY]));
 462                 fprintf(f, "xmit_hash_policy %s ", xmit_hash_policy);
 463         }
 464
 465         if (tb[IFLA_BOND_RESEND_IGMP])
 466                 fprintf(f, "resend_igmp %u ",
 467                         rta_getattr_u32(tb[IFLA_BOND_RESEND_IGMP]));
 468
 469         if (tb[IFLA_BOND_NUM_PEER_NOTIF])
 470                 fprintf(f, "num_grat_arp %u ",
 471                         rta_getattr_u8(tb[IFLA_BOND_NUM_PEER_NOTIF]));
 472
 473         if (tb[IFLA_BOND_ALL_SLAVES_ACTIVE])
 474                 fprintf(f, "all_slaves_active %u ",
 475                         rta_getattr_u8(tb[IFLA_BOND_ALL_SLAVES_ACTIVE]));
 476
 477         if (tb[IFLA_BOND_MIN_LINKS])
 478                 fprintf(f, "min_links %u ",
 479                         rta_getattr_u32(tb[IFLA_BOND_MIN_LINKS]));
 480
 481         if (tb[IFLA_BOND_LP_INTERVAL])
 482                 fprintf(f, "lp_interval %u ",
 483                         rta_getattr_u32(tb[IFLA_BOND_LP_INTERVAL]));
 484
 485         if (tb[IFLA_BOND_PACKETS_PER_SLAVE])
 486                 fprintf(f, "packets_per_slave %u ",
 487                         rta_getattr_u32(tb[IFLA_BOND_PACKETS_PER_SLAVE]));
 488
 489         if (tb[IFLA_BOND_AD_LACP_RATE]) {
 490                 const char *lacp_rate = get_name(lacp_rate_tbl,
 491                         rta_getattr_u8(tb[IFLA_BOND_AD_LACP_RATE]));
 492                 fprintf(f, "lacp_rate %s ", lacp_rate);
 493         }
 494
 495         if (tb[IFLA_BOND_AD_SELECT]) {
 496                 const char *ad_select = get_name(ad_select_tbl,
 497                         rta_getattr_u8(tb[IFLA_BOND_AD_SELECT]));
 498                 fprintf(f, "ad_select %s ", ad_select);
 499         }
 500
 501         if (tb[IFLA_BOND_AD_INFO]) {
 502                 struct rtattr *adtb[IFLA_BOND_AD_INFO_MAX + 1];
 503
 504                 parse_rtattr_nested(adtb, IFLA_BOND_AD_INFO_MAX,
 505                         tb[IFLA_BOND_AD_INFO]);
 506
 507                 if (adtb[IFLA_BOND_AD_INFO_AGGREGATOR])
 508                         fprintf(f, "ad_aggregator %d ",
 509                           rta_getattr_u16(adtb[IFLA_BOND_AD_INFO_AGGREGATOR]));
 510
 511                 if (adtb[IFLA_BOND_AD_INFO_NUM_PORTS])
 512                         fprintf(f, "ad_num_ports %d ",
 513                           rta_getattr_u16(adtb[IFLA_BOND_AD_INFO_NUM_PORTS]));
 514
 515                 if (adtb[IFLA_BOND_AD_INFO_ACTOR_KEY])
 516                         fprintf(f, "ad_actor_key %d ",
 517                           rta_getattr_u16(adtb[IFLA_BOND_AD_INFO_ACTOR_KEY]));
 518
 519                 if (adtb[IFLA_BOND_AD_INFO_PARTNER_KEY])
 520                         fprintf(f, "ad_partner_key %d ",
 521                           rta_getattr_u16(adtb[IFLA_BOND_AD_INFO_PARTNER_KEY]));
 522
 523                 if (adtb[IFLA_BOND_AD_INFO_PARTNER_MAC]) {
 524                         unsigned char *p =
 525                                 RTA_DATA(adtb[IFLA_BOND_AD_INFO_PARTNER_MAC]);
 526                         SPRINT_BUF(b);
 527                         fprintf(f, "ad_partner_mac %s ",
 528                                 ll_addr_n2a(p, ETH_ALEN, 0, b, sizeof(b)));
 529                 }
 530         }
 531 }
 532
 533 struct link_util bond_link_util = {
 534         .id             = "bond",
 535         .maxattr        = IFLA_BOND_MAX,
 536         .parse_opt      = bond_parse_opt,
 537         .print_opt      = bond_print_opt,
 538 };