1 /* 2 * drivers/net/bond/bond_netlink.c - Netlink interface for bonding 3 * Copyright (c) 2013 Jiri Pirko <jiri@resnulli.us> 4 * Copyright (c) 2013 Scott Feldman <sfeldma@cumulusnetworks.com> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 */ 11 12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 14 #include <linux/module.h> 15 #include <linux/errno.h> 16 #include <linux/netdevice.h> 17 #include <linux/etherdevice.h> 18 #include <linux/if_link.h> 19 #include <linux/if_ether.h> 20 #include <net/netlink.h> 21 #include <net/rtnetlink.h> 22 #include <linux/reciprocal_div.h> 23 #include "bonding.h" 24 25 static const struct nla_policy bond_policy[IFLA_BOND_MAX + 1] = { 26 [IFLA_BOND_MODE] = { .type = NLA_U8 }, 27 [IFLA_BOND_ACTIVE_SLAVE] = { .type = NLA_U32 }, 28 [IFLA_BOND_MIIMON] = { .type = NLA_U32 }, 29 [IFLA_BOND_UPDELAY] = { .type = NLA_U32 }, 30 [IFLA_BOND_DOWNDELAY] = { .type = NLA_U32 }, 31 [IFLA_BOND_USE_CARRIER] = { .type = NLA_U8 }, 32 [IFLA_BOND_ARP_INTERVAL] = { .type = NLA_U32 }, 33 [IFLA_BOND_ARP_IP_TARGET] = { .type = NLA_NESTED }, 34 [IFLA_BOND_ARP_VALIDATE] = { .type = NLA_U32 }, 35 [IFLA_BOND_ARP_ALL_TARGETS] = { .type = NLA_U32 }, 36 [IFLA_BOND_PRIMARY] = { .type = NLA_U32 }, 37 [IFLA_BOND_PRIMARY_RESELECT] = { .type = NLA_U8 }, 38 [IFLA_BOND_FAIL_OVER_MAC] = { .type = NLA_U8 }, 39 [IFLA_BOND_XMIT_HASH_POLICY] = { .type = NLA_U8 }, 40 [IFLA_BOND_RESEND_IGMP] = { .type = NLA_U32 }, 41 [IFLA_BOND_NUM_PEER_NOTIF] = { .type = NLA_U8 }, 42 [IFLA_BOND_ALL_SLAVES_ACTIVE] = { .type = NLA_U8 }, 43 [IFLA_BOND_MIN_LINKS] = { .type = NLA_U32 }, 44 [IFLA_BOND_LP_INTERVAL] = { .type = NLA_U32 }, 45 [IFLA_BOND_PACKETS_PER_SLAVE] = { .type = NLA_U32 }, 46 }; 47 48 static int bond_validate(struct nlattr *tb[], struct nlattr *data[]) 49 { 50 if (tb[IFLA_ADDRESS]) { 51 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN) 52 return -EINVAL; 53 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS]))) 54 return -EADDRNOTAVAIL; 55 } 56 return 0; 57 } 58 59 static int bond_changelink(struct net_device *bond_dev, 60 struct nlattr *tb[], struct nlattr *data[]) 61 { 62 struct bonding *bond = netdev_priv(bond_dev); 63 int miimon = 0; 64 int err; 65 66 if (!data) 67 return 0; 68 69 if (data[IFLA_BOND_MODE]) { 70 int mode = nla_get_u8(data[IFLA_BOND_MODE]); 71 72 err = bond_option_mode_set(bond, mode); 73 if (err) 74 return err; 75 } 76 if (data[IFLA_BOND_ACTIVE_SLAVE]) { 77 int ifindex = nla_get_u32(data[IFLA_BOND_ACTIVE_SLAVE]); 78 struct net_device *slave_dev; 79 80 if (ifindex == 0) { 81 slave_dev = NULL; 82 } else { 83 slave_dev = __dev_get_by_index(dev_net(bond_dev), 84 ifindex); 85 if (!slave_dev) 86 return -ENODEV; 87 } 88 err = bond_option_active_slave_set(bond, slave_dev); 89 if (err) 90 return err; 91 } 92 if (data[IFLA_BOND_MIIMON]) { 93 miimon = nla_get_u32(data[IFLA_BOND_MIIMON]); 94 95 err = bond_option_miimon_set(bond, miimon); 96 if (err) 97 return err; 98 } 99 if (data[IFLA_BOND_UPDELAY]) { 100 int updelay = nla_get_u32(data[IFLA_BOND_UPDELAY]); 101 102 err = bond_option_updelay_set(bond, updelay); 103 if (err) 104 return err; 105 } 106 if (data[IFLA_BOND_DOWNDELAY]) { 107 int downdelay = nla_get_u32(data[IFLA_BOND_DOWNDELAY]); 108 109 err = bond_option_downdelay_set(bond, downdelay); 110 if (err) 111 return err; 112 } 113 if (data[IFLA_BOND_USE_CARRIER]) { 114 int use_carrier = nla_get_u8(data[IFLA_BOND_USE_CARRIER]); 115 116 err = bond_option_use_carrier_set(bond, use_carrier); 117 if (err) 118 return err; 119 } 120 if (data[IFLA_BOND_ARP_INTERVAL]) { 121 int arp_interval = nla_get_u32(data[IFLA_BOND_ARP_INTERVAL]); 122 123 if (arp_interval && miimon) { 124 pr_err("%s: ARP monitoring cannot be used with MII monitoring.\n", 125 bond->dev->name); 126 return -EINVAL; 127 } 128 129 err = bond_option_arp_interval_set(bond, arp_interval); 130 if (err) 131 return err; 132 } 133 if (data[IFLA_BOND_ARP_IP_TARGET]) { 134 __be32 targets[BOND_MAX_ARP_TARGETS] = { 0, }; 135 struct nlattr *attr; 136 int i = 0, rem; 137 138 nla_for_each_nested(attr, data[IFLA_BOND_ARP_IP_TARGET], rem) { 139 __be32 target = nla_get_be32(attr); 140 targets[i++] = target; 141 } 142 143 err = bond_option_arp_ip_targets_set(bond, targets, i); 144 if (err) 145 return err; 146 } 147 if (data[IFLA_BOND_ARP_VALIDATE]) { 148 int arp_validate = nla_get_u32(data[IFLA_BOND_ARP_VALIDATE]); 149 150 if (arp_validate && miimon) { 151 pr_err("%s: ARP validating cannot be used with MII monitoring.\n", 152 bond->dev->name); 153 return -EINVAL; 154 } 155 156 err = bond_option_arp_validate_set(bond, arp_validate); 157 if (err) 158 return err; 159 } 160 if (data[IFLA_BOND_ARP_ALL_TARGETS]) { 161 int arp_all_targets = 162 nla_get_u32(data[IFLA_BOND_ARP_ALL_TARGETS]); 163 164 err = bond_option_arp_all_targets_set(bond, arp_all_targets); 165 if (err) 166 return err; 167 } 168 if (data[IFLA_BOND_PRIMARY]) { 169 int ifindex = nla_get_u32(data[IFLA_BOND_PRIMARY]); 170 struct net_device *dev; 171 char *primary = ""; 172 173 dev = __dev_get_by_index(dev_net(bond_dev), ifindex); 174 if (dev) 175 primary = dev->name; 176 177 err = bond_option_primary_set(bond, primary); 178 if (err) 179 return err; 180 } 181 if (data[IFLA_BOND_PRIMARY_RESELECT]) { 182 int primary_reselect = 183 nla_get_u8(data[IFLA_BOND_PRIMARY_RESELECT]); 184 185 err = bond_option_primary_reselect_set(bond, primary_reselect); 186 if (err) 187 return err; 188 } 189 if (data[IFLA_BOND_FAIL_OVER_MAC]) { 190 int fail_over_mac = 191 nla_get_u8(data[IFLA_BOND_FAIL_OVER_MAC]); 192 193 err = bond_option_fail_over_mac_set(bond, fail_over_mac); 194 if (err) 195 return err; 196 } 197 if (data[IFLA_BOND_XMIT_HASH_POLICY]) { 198 int xmit_hash_policy = 199 nla_get_u8(data[IFLA_BOND_XMIT_HASH_POLICY]); 200 201 err = bond_option_xmit_hash_policy_set(bond, xmit_hash_policy); 202 if (err) 203 return err; 204 } 205 if (data[IFLA_BOND_RESEND_IGMP]) { 206 int resend_igmp = 207 nla_get_u32(data[IFLA_BOND_RESEND_IGMP]); 208 209 err = bond_option_resend_igmp_set(bond, resend_igmp); 210 if (err) 211 return err; 212 } 213 if (data[IFLA_BOND_NUM_PEER_NOTIF]) { 214 int num_peer_notif = 215 nla_get_u8(data[IFLA_BOND_NUM_PEER_NOTIF]); 216 217 err = bond_option_num_peer_notif_set(bond, num_peer_notif); 218 if (err) 219 return err; 220 } 221 if (data[IFLA_BOND_ALL_SLAVES_ACTIVE]) { 222 int all_slaves_active = 223 nla_get_u8(data[IFLA_BOND_ALL_SLAVES_ACTIVE]); 224 225 err = bond_option_all_slaves_active_set(bond, 226 all_slaves_active); 227 if (err) 228 return err; 229 } 230 if (data[IFLA_BOND_MIN_LINKS]) { 231 int min_links = 232 nla_get_u32(data[IFLA_BOND_MIN_LINKS]); 233 234 err = bond_option_min_links_set(bond, min_links); 235 if (err) 236 return err; 237 } 238 if (data[IFLA_BOND_LP_INTERVAL]) { 239 int lp_interval = 240 nla_get_u32(data[IFLA_BOND_LP_INTERVAL]); 241 242 err = bond_option_lp_interval_set(bond, lp_interval); 243 if (err) 244 return err; 245 } 246 if (data[IFLA_BOND_PACKETS_PER_SLAVE]) { 247 int packets_per_slave = 248 nla_get_u32(data[IFLA_BOND_PACKETS_PER_SLAVE]); 249 250 err = bond_option_packets_per_slave_set(bond, 251 packets_per_slave); 252 if (err) 253 return err; 254 } 255 return 0; 256 } 257 258 static int bond_newlink(struct net *src_net, struct net_device *bond_dev, 259 struct nlattr *tb[], struct nlattr *data[]) 260 { 261 int err; 262 263 err = bond_changelink(bond_dev, tb, data); 264 if (err < 0) 265 return err; 266 267 return register_netdevice(bond_dev); 268 } 269 270 static size_t bond_get_size(const struct net_device *bond_dev) 271 { 272 return nla_total_size(sizeof(u8)) + /* IFLA_BOND_MODE */ 273 nla_total_size(sizeof(u32)) + /* IFLA_BOND_ACTIVE_SLAVE */ 274 nla_total_size(sizeof(u32)) + /* IFLA_BOND_MIIMON */ 275 nla_total_size(sizeof(u32)) + /* IFLA_BOND_UPDELAY */ 276 nla_total_size(sizeof(u32)) + /* IFLA_BOND_DOWNDELAY */ 277 nla_total_size(sizeof(u8)) + /* IFLA_BOND_USE_CARRIER */ 278 nla_total_size(sizeof(u32)) + /* IFLA_BOND_ARP_INTERVAL */ 279 /* IFLA_BOND_ARP_IP_TARGET */ 280 nla_total_size(sizeof(u32)) * BOND_MAX_ARP_TARGETS + 281 nla_total_size(sizeof(u32)) + /* IFLA_BOND_ARP_VALIDATE */ 282 nla_total_size(sizeof(u32)) + /* IFLA_BOND_ARP_ALL_TARGETS */ 283 nla_total_size(sizeof(u32)) + /* IFLA_BOND_PRIMARY */ 284 nla_total_size(sizeof(u8)) + /* IFLA_BOND_PRIMARY_RESELECT */ 285 nla_total_size(sizeof(u8)) + /* IFLA_BOND_FAIL_OVER_MAC */ 286 nla_total_size(sizeof(u8)) + /* IFLA_BOND_XMIT_HASH_POLICY */ 287 nla_total_size(sizeof(u32)) + /* IFLA_BOND_RESEND_IGMP */ 288 nla_total_size(sizeof(u8)) + /* IFLA_BOND_NUM_PEER_NOTIF */ 289 nla_total_size(sizeof(u8)) + /* IFLA_BOND_ALL_SLAVES_ACTIVE */ 290 nla_total_size(sizeof(u32)) + /* IFLA_BOND_MIN_LINKS */ 291 nla_total_size(sizeof(u32)) + /* IFLA_BOND_LP_INTERVAL */ 292 nla_total_size(sizeof(u32)) + /* IFLA_BOND_PACKETS_PER_SLAVE */ 293 0; 294 } 295 296 static int bond_fill_info(struct sk_buff *skb, 297 const struct net_device *bond_dev) 298 { 299 struct bonding *bond = netdev_priv(bond_dev); 300 struct net_device *slave_dev = bond_option_active_slave_get(bond); 301 struct nlattr *targets; 302 unsigned int packets_per_slave; 303 int i, targets_added; 304 305 if (nla_put_u8(skb, IFLA_BOND_MODE, bond->params.mode)) 306 goto nla_put_failure; 307 308 if (slave_dev && 309 nla_put_u32(skb, IFLA_BOND_ACTIVE_SLAVE, slave_dev->ifindex)) 310 goto nla_put_failure; 311 312 if (nla_put_u32(skb, IFLA_BOND_MIIMON, bond->params.miimon)) 313 goto nla_put_failure; 314 315 if (nla_put_u32(skb, IFLA_BOND_UPDELAY, 316 bond->params.updelay * bond->params.miimon)) 317 goto nla_put_failure; 318 319 if (nla_put_u32(skb, IFLA_BOND_DOWNDELAY, 320 bond->params.downdelay * bond->params.miimon)) 321 goto nla_put_failure; 322 323 if (nla_put_u8(skb, IFLA_BOND_USE_CARRIER, bond->params.use_carrier)) 324 goto nla_put_failure; 325 326 if (nla_put_u32(skb, IFLA_BOND_ARP_INTERVAL, bond->params.arp_interval)) 327 goto nla_put_failure; 328 329 targets = nla_nest_start(skb, IFLA_BOND_ARP_IP_TARGET); 330 if (!targets) 331 goto nla_put_failure; 332 333 targets_added = 0; 334 for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) { 335 if (bond->params.arp_targets[i]) { 336 nla_put_be32(skb, i, bond->params.arp_targets[i]); 337 targets_added = 1; 338 } 339 } 340 341 if (targets_added) 342 nla_nest_end(skb, targets); 343 else 344 nla_nest_cancel(skb, targets); 345 346 if (nla_put_u32(skb, IFLA_BOND_ARP_VALIDATE, bond->params.arp_validate)) 347 goto nla_put_failure; 348 349 if (nla_put_u32(skb, IFLA_BOND_ARP_ALL_TARGETS, 350 bond->params.arp_all_targets)) 351 goto nla_put_failure; 352 353 if (bond->primary_slave && 354 nla_put_u32(skb, IFLA_BOND_PRIMARY, 355 bond->primary_slave->dev->ifindex)) 356 goto nla_put_failure; 357 358 if (nla_put_u8(skb, IFLA_BOND_PRIMARY_RESELECT, 359 bond->params.primary_reselect)) 360 goto nla_put_failure; 361 362 if (nla_put_u8(skb, IFLA_BOND_FAIL_OVER_MAC, 363 bond->params.fail_over_mac)) 364 goto nla_put_failure; 365 366 if (nla_put_u8(skb, IFLA_BOND_XMIT_HASH_POLICY, 367 bond->params.xmit_policy)) 368 goto nla_put_failure; 369 370 if (nla_put_u32(skb, IFLA_BOND_RESEND_IGMP, 371 bond->params.resend_igmp)) 372 goto nla_put_failure; 373 374 if (nla_put_u8(skb, IFLA_BOND_NUM_PEER_NOTIF, 375 bond->params.num_peer_notif)) 376 goto nla_put_failure; 377 378 if (nla_put_u8(skb, IFLA_BOND_ALL_SLAVES_ACTIVE, 379 bond->params.all_slaves_active)) 380 goto nla_put_failure; 381 382 if (nla_put_u32(skb, IFLA_BOND_MIN_LINKS, 383 bond->params.min_links)) 384 goto nla_put_failure; 385 386 if (nla_put_u32(skb, IFLA_BOND_LP_INTERVAL, 387 bond->params.lp_interval)) 388 goto nla_put_failure; 389 390 packets_per_slave = bond->params.packets_per_slave; 391 if (packets_per_slave > 1) 392 packets_per_slave = reciprocal_value(packets_per_slave); 393 394 if (nla_put_u32(skb, IFLA_BOND_PACKETS_PER_SLAVE, 395 packets_per_slave)) 396 goto nla_put_failure; 397 398 return 0; 399 400 nla_put_failure: 401 return -EMSGSIZE; 402 } 403 404 struct rtnl_link_ops bond_link_ops __read_mostly = { 405 .kind = "bond", 406 .priv_size = sizeof(struct bonding), 407 .setup = bond_setup, 408 .maxtype = IFLA_BOND_MAX, 409 .policy = bond_policy, 410 .validate = bond_validate, 411 .newlink = bond_newlink, 412 .changelink = bond_changelink, 413 .get_size = bond_get_size, 414 .fill_info = bond_fill_info, 415 .get_num_tx_queues = bond_get_num_tx_queues, 416 .get_num_rx_queues = bond_get_num_tx_queues, /* Use the same number 417 as for TX queues */ 418 }; 419 420 int __init bond_netlink_init(void) 421 { 422 return rtnl_link_register(&bond_link_ops); 423 } 424 425 void bond_netlink_fini(void) 426 { 427 rtnl_link_unregister(&bond_link_ops); 428 } 429 430 MODULE_ALIAS_RTNL_LINK("bond"); 431