FILE
bond_options.c
File preview with syntax highlighting.
linux-6.19.14/drivers/net/bonding/bond_options.c
1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * drivers/net/bond/bond_options.c - bonding options 4 * Copyright (c) 2013 Jiri Pirko <jiri@resnulli.us> 5 * Copyright (c) 2013 Scott Feldman <sfeldma@cumulusnetworks.com> 6 */ 7 8#include <linux/errno.h> 9#include <linux/if.h> 10#include <linux/netdevice.h> 11#include <linux/spinlock.h> 12#include <linux/rcupdate.h> 13#include <linux/ctype.h> 14#include <linux/inet.h> 15#include <linux/sched/signal.h> 16 17#include <net/bonding.h> 18#include <net/ndisc.h> 19 20static int bond_option_active_slave_set(struct bonding *bond, 21 const struct bond_opt_value *newval); 22static int bond_option_miimon_set(struct bonding *bond, 23 const struct bond_opt_value *newval); 24static int bond_option_updelay_set(struct bonding *bond, 25 const struct bond_opt_value *newval); 26static int bond_option_downdelay_set(struct bonding *bond, 27 const struct bond_opt_value *newval); 28static int bond_option_peer_notif_delay_set(struct bonding *bond, 29 const struct bond_opt_value *newval); 30static int bond_option_use_carrier_set(struct bonding *bond, 31 const struct bond_opt_value *newval); 32static int bond_option_arp_interval_set(struct bonding *bond, 33 const struct bond_opt_value *newval); 34static int bond_option_arp_ip_target_add(struct bonding *bond, __be32 target); 35static int bond_option_arp_ip_target_rem(struct bonding *bond, __be32 target); 36static int bond_option_arp_ip_targets_set(struct bonding *bond, 37 const struct bond_opt_value *newval); 38static int bond_option_ns_ip6_targets_set(struct bonding *bond, 39 const struct bond_opt_value *newval); 40static int bond_option_arp_validate_set(struct bonding *bond, 41 const struct bond_opt_value *newval); 42static int bond_option_arp_all_targets_set(struct bonding *bond, 43 const struct bond_opt_value *newval); 44static int bond_option_prio_set(struct bonding *bond, 45 const struct bond_opt_value *newval); 46static int bond_option_primary_set(struct bonding *bond, 47 const struct bond_opt_value *newval); 48static int bond_option_primary_reselect_set(struct bonding *bond, 49 const struct bond_opt_value *newval); 50static int bond_option_fail_over_mac_set(struct bonding *bond, 51 const struct bond_opt_value *newval); 52static int bond_option_xmit_hash_policy_set(struct bonding *bond, 53 const struct bond_opt_value *newval); 54static int bond_option_resend_igmp_set(struct bonding *bond, 55 const struct bond_opt_value *newval); 56static int bond_option_num_peer_notif_set(struct bonding *bond, 57 const struct bond_opt_value *newval); 58static int bond_option_all_slaves_active_set(struct bonding *bond, 59 const struct bond_opt_value *newval); 60static int bond_option_min_links_set(struct bonding *bond, 61 const struct bond_opt_value *newval); 62static int bond_option_lp_interval_set(struct bonding *bond, 63 const struct bond_opt_value *newval); 64static int bond_option_pps_set(struct bonding *bond, 65 const struct bond_opt_value *newval); 66static int bond_option_lacp_active_set(struct bonding *bond, 67 const struct bond_opt_value *newval); 68static int bond_option_lacp_rate_set(struct bonding *bond, 69 const struct bond_opt_value *newval); 70static int bond_option_ad_select_set(struct bonding *bond, 71 const struct bond_opt_value *newval); 72static int bond_option_queue_id_set(struct bonding *bond, 73 const struct bond_opt_value *newval); 74static int bond_option_mode_set(struct bonding *bond, 75 const struct bond_opt_value *newval); 76static int bond_option_slaves_set(struct bonding *bond, 77 const struct bond_opt_value *newval); 78static int bond_option_tlb_dynamic_lb_set(struct bonding *bond, 79 const struct bond_opt_value *newval); 80static int bond_option_ad_actor_sys_prio_set(struct bonding *bond, 81 const struct bond_opt_value *newval); 82static int bond_option_actor_port_prio_set(struct bonding *bond, 83 const struct bond_opt_value *newval); 84static int bond_option_ad_actor_system_set(struct bonding *bond, 85 const struct bond_opt_value *newval); 86static int bond_option_ad_user_port_key_set(struct bonding *bond, 87 const struct bond_opt_value *newval); 88static int bond_option_missed_max_set(struct bonding *bond, 89 const struct bond_opt_value *newval); 90static int bond_option_coupled_control_set(struct bonding *bond, 91 const struct bond_opt_value *newval); 92static int bond_option_broadcast_neigh_set(struct bonding *bond, 93 const struct bond_opt_value *newval); 94 95static const struct bond_opt_value bond_mode_tbl[] = { 96 { "balance-rr", BOND_MODE_ROUNDROBIN, BOND_VALFLAG_DEFAULT}, 97 { "active-backup", BOND_MODE_ACTIVEBACKUP, 0}, 98 { "balance-xor", BOND_MODE_XOR, 0}, 99 { "broadcast", BOND_MODE_BROADCAST, 0}, 100 { "802.3ad", BOND_MODE_8023AD, 0}, 101 { "balance-tlb", BOND_MODE_TLB, 0}, 102 { "balance-alb", BOND_MODE_ALB, 0}, 103 { NULL, -1, 0}, 104}; 105 106static const struct bond_opt_value bond_pps_tbl[] = { 107 { "default", 1, BOND_VALFLAG_DEFAULT}, 108 { "maxval", USHRT_MAX, BOND_VALFLAG_MAX}, 109 { NULL, -1, 0}, 110}; 111 112static const struct bond_opt_value bond_xmit_hashtype_tbl[] = { 113 { "layer2", BOND_XMIT_POLICY_LAYER2, BOND_VALFLAG_DEFAULT}, 114 { "layer3+4", BOND_XMIT_POLICY_LAYER34, 0}, 115 { "layer2+3", BOND_XMIT_POLICY_LAYER23, 0}, 116 { "encap2+3", BOND_XMIT_POLICY_ENCAP23, 0}, 117 { "encap3+4", BOND_XMIT_POLICY_ENCAP34, 0}, 118 { "vlan+srcmac", BOND_XMIT_POLICY_VLAN_SRCMAC, 0}, 119 { NULL, -1, 0}, 120}; 121 122static const struct bond_opt_value bond_arp_validate_tbl[] = { 123 { "none", BOND_ARP_VALIDATE_NONE, BOND_VALFLAG_DEFAULT}, 124 { "active", BOND_ARP_VALIDATE_ACTIVE, 0}, 125 { "backup", BOND_ARP_VALIDATE_BACKUP, 0}, 126 { "all", BOND_ARP_VALIDATE_ALL, 0}, 127 { "filter", BOND_ARP_FILTER, 0}, 128 { "filter_active", BOND_ARP_FILTER_ACTIVE, 0}, 129 { "filter_backup", BOND_ARP_FILTER_BACKUP, 0}, 130 { NULL, -1, 0}, 131}; 132 133static const struct bond_opt_value bond_arp_all_targets_tbl[] = { 134 { "any", BOND_ARP_TARGETS_ANY, BOND_VALFLAG_DEFAULT}, 135 { "all", BOND_ARP_TARGETS_ALL, 0}, 136 { NULL, -1, 0}, 137}; 138 139static const struct bond_opt_value bond_fail_over_mac_tbl[] = { 140 { "none", BOND_FOM_NONE, BOND_VALFLAG_DEFAULT}, 141 { "active", BOND_FOM_ACTIVE, 0}, 142 { "follow", BOND_FOM_FOLLOW, 0}, 143 { NULL, -1, 0}, 144}; 145 146static const struct bond_opt_value bond_intmax_tbl[] = { 147 { "off", 0, BOND_VALFLAG_DEFAULT}, 148 { "maxval", INT_MAX, BOND_VALFLAG_MAX}, 149 { NULL, -1, 0} 150}; 151 152static const struct bond_opt_value bond_lacp_active[] = { 153 { "off", 0, 0}, 154 { "on", 1, BOND_VALFLAG_DEFAULT}, 155 { NULL, -1, 0} 156}; 157 158static const struct bond_opt_value bond_lacp_rate_tbl[] = { 159 { "slow", AD_LACP_SLOW, 0}, 160 { "fast", AD_LACP_FAST, 0}, 161 { NULL, -1, 0}, 162}; 163 164static const struct bond_opt_value bond_ad_select_tbl[] = { 165 { "stable", BOND_AD_STABLE, BOND_VALFLAG_DEFAULT}, 166 { "bandwidth", BOND_AD_BANDWIDTH, 0}, 167 { "count", BOND_AD_COUNT, 0}, 168 { "actor_port_prio", BOND_AD_PRIO, 0}, 169 { NULL, -1, 0}, 170}; 171 172static const struct bond_opt_value bond_num_peer_notif_tbl[] = { 173 { "off", 0, 0}, 174 { "maxval", 255, BOND_VALFLAG_MAX}, 175 { "default", 1, BOND_VALFLAG_DEFAULT}, 176 { NULL, -1, 0} 177}; 178 179static const struct bond_opt_value bond_peer_notif_delay_tbl[] = { 180 { "off", 0, 0}, 181 { "maxval", 300000, BOND_VALFLAG_MAX}, 182 { NULL, -1, 0} 183}; 184 185static const struct bond_opt_value bond_primary_reselect_tbl[] = { 186 { "always", BOND_PRI_RESELECT_ALWAYS, BOND_VALFLAG_DEFAULT}, 187 { "better", BOND_PRI_RESELECT_BETTER, 0}, 188 { "failure", BOND_PRI_RESELECT_FAILURE, 0}, 189 { NULL, -1}, 190}; 191 192static const struct bond_opt_value bond_use_carrier_tbl[] = { 193 { "on", 1, BOND_VALFLAG_DEFAULT}, 194 { NULL, -1, 0} 195}; 196 197static const struct bond_opt_value bond_all_slaves_active_tbl[] = { 198 { "off", 0, BOND_VALFLAG_DEFAULT}, 199 { "on", 1, 0}, 200 { NULL, -1, 0} 201}; 202 203static const struct bond_opt_value bond_resend_igmp_tbl[] = { 204 { "off", 0, 0}, 205 { "maxval", 255, BOND_VALFLAG_MAX}, 206 { "default", 1, BOND_VALFLAG_DEFAULT}, 207 { NULL, -1, 0} 208}; 209 210static const struct bond_opt_value bond_lp_interval_tbl[] = { 211 { "minval", 1, BOND_VALFLAG_MIN | BOND_VALFLAG_DEFAULT}, 212 { "maxval", INT_MAX, BOND_VALFLAG_MAX}, 213 { NULL, -1, 0}, 214}; 215 216static const struct bond_opt_value bond_tlb_dynamic_lb_tbl[] = { 217 { "off", 0, 0}, 218 { "on", 1, BOND_VALFLAG_DEFAULT}, 219 { NULL, -1, 0} 220}; 221 222static const struct bond_opt_value bond_ad_actor_sys_prio_tbl[] = { 223 { "minval", 1, BOND_VALFLAG_MIN}, 224 { "maxval", 65535, BOND_VALFLAG_MAX | BOND_VALFLAG_DEFAULT}, 225 { NULL, -1, 0}, 226}; 227 228static const struct bond_opt_value bond_ad_user_port_key_tbl[] = { 229 { "minval", 0, BOND_VALFLAG_MIN | BOND_VALFLAG_DEFAULT}, 230 { "maxval", 1023, BOND_VALFLAG_MAX}, 231 { NULL, -1, 0}, 232}; 233 234static const struct bond_opt_value bond_missed_max_tbl[] = { 235 { "minval", 1, BOND_VALFLAG_MIN}, 236 { "maxval", 255, BOND_VALFLAG_MAX}, 237 { "default", 2, BOND_VALFLAG_DEFAULT}, 238 { NULL, -1, 0}, 239}; 240 241static const struct bond_opt_value bond_coupled_control_tbl[] = { 242 { "on", 1, BOND_VALFLAG_DEFAULT}, 243 { "off", 0, 0}, 244 { NULL, -1, 0}, 245}; 246 247static const struct bond_opt_value bond_broadcast_neigh_tbl[] = { 248 { "off", 0, BOND_VALFLAG_DEFAULT}, 249 { "on", 1, 0}, 250 { NULL, -1, 0} 251}; 252 253static const struct bond_option bond_opts[BOND_OPT_LAST] = { 254 [BOND_OPT_MODE] = { 255 .id = BOND_OPT_MODE, 256 .name = "mode", 257 .desc = "bond device mode", 258 .flags = BOND_OPTFLAG_NOSLAVES | BOND_OPTFLAG_IFDOWN, 259 .values = bond_mode_tbl, 260 .set = bond_option_mode_set 261 }, 262 [BOND_OPT_PACKETS_PER_SLAVE] = { 263 .id = BOND_OPT_PACKETS_PER_SLAVE, 264 .name = "packets_per_slave", 265 .desc = "Packets to send per slave in RR mode", 266 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_ROUNDROBIN)), 267 .values = bond_pps_tbl, 268 .set = bond_option_pps_set 269 }, 270 [BOND_OPT_XMIT_HASH] = { 271 .id = BOND_OPT_XMIT_HASH, 272 .name = "xmit_hash_policy", 273 .desc = "balance-xor, 802.3ad, and tlb hashing method", 274 .values = bond_xmit_hashtype_tbl, 275 .set = bond_option_xmit_hash_policy_set 276 }, 277 [BOND_OPT_ARP_VALIDATE] = { 278 .id = BOND_OPT_ARP_VALIDATE, 279 .name = "arp_validate", 280 .desc = "validate src/dst of ARP probes", 281 .unsuppmodes = BIT(BOND_MODE_8023AD) | BIT(BOND_MODE_TLB) | 282 BIT(BOND_MODE_ALB), 283 .values = bond_arp_validate_tbl, 284 .set = bond_option_arp_validate_set 285 }, 286 [BOND_OPT_ARP_ALL_TARGETS] = { 287 .id = BOND_OPT_ARP_ALL_TARGETS, 288 .name = "arp_all_targets", 289 .desc = "fail on any/all arp targets timeout", 290 .values = bond_arp_all_targets_tbl, 291 .set = bond_option_arp_all_targets_set 292 }, 293 [BOND_OPT_FAIL_OVER_MAC] = { 294 .id = BOND_OPT_FAIL_OVER_MAC, 295 .name = "fail_over_mac", 296 .desc = "For active-backup, do not set all slaves to the same MAC", 297 .flags = BOND_OPTFLAG_NOSLAVES, 298 .values = bond_fail_over_mac_tbl, 299 .set = bond_option_fail_over_mac_set 300 }, 301 [BOND_OPT_ARP_INTERVAL] = { 302 .id = BOND_OPT_ARP_INTERVAL, 303 .name = "arp_interval", 304 .desc = "arp interval in milliseconds", 305 .unsuppmodes = BIT(BOND_MODE_8023AD) | BIT(BOND_MODE_TLB) | 306 BIT(BOND_MODE_ALB), 307 .values = bond_intmax_tbl, 308 .set = bond_option_arp_interval_set 309 }, 310 [BOND_OPT_MISSED_MAX] = { 311 .id = BOND_OPT_MISSED_MAX, 312 .name = "arp_missed_max", 313 .desc = "Maximum number of missed ARP interval", 314 .unsuppmodes = BIT(BOND_MODE_8023AD) | BIT(BOND_MODE_TLB) | 315 BIT(BOND_MODE_ALB), 316 .values = bond_missed_max_tbl, 317 .set = bond_option_missed_max_set 318 }, 319 [BOND_OPT_ARP_TARGETS] = { 320 .id = BOND_OPT_ARP_TARGETS, 321 .name = "arp_ip_target", 322 .desc = "arp targets in n.n.n.n form", 323 .flags = BOND_OPTFLAG_RAWVAL, 324 .set = bond_option_arp_ip_targets_set 325 }, 326 [BOND_OPT_NS_TARGETS] = { 327 .id = BOND_OPT_NS_TARGETS, 328 .name = "ns_ip6_target", 329 .desc = "NS targets in ffff:ffff::ffff:ffff form", 330 .flags = BOND_OPTFLAG_RAWVAL, 331 .set = bond_option_ns_ip6_targets_set 332 }, 333 [BOND_OPT_DOWNDELAY] = { 334 .id = BOND_OPT_DOWNDELAY, 335 .name = "downdelay", 336 .desc = "Delay before considering link down, in milliseconds", 337 .values = bond_intmax_tbl, 338 .set = bond_option_downdelay_set 339 }, 340 [BOND_OPT_UPDELAY] = { 341 .id = BOND_OPT_UPDELAY, 342 .name = "updelay", 343 .desc = "Delay before considering link up, in milliseconds", 344 .values = bond_intmax_tbl, 345 .set = bond_option_updelay_set 346 }, 347 [BOND_OPT_LACP_ACTIVE] = { 348 .id = BOND_OPT_LACP_ACTIVE, 349 .name = "lacp_active", 350 .desc = "Send LACPDU frames with configured lacp rate or acts as speak when spoken to", 351 .flags = BOND_OPTFLAG_IFDOWN, 352 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD)), 353 .values = bond_lacp_active, 354 .set = bond_option_lacp_active_set 355 }, 356 [BOND_OPT_LACP_RATE] = { 357 .id = BOND_OPT_LACP_RATE, 358 .name = "lacp_rate", 359 .desc = "LACPDU tx rate to request from 802.3ad partner", 360 .flags = BOND_OPTFLAG_IFDOWN, 361 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD)), 362 .values = bond_lacp_rate_tbl, 363 .set = bond_option_lacp_rate_set 364 }, 365 [BOND_OPT_MINLINKS] = { 366 .id = BOND_OPT_MINLINKS, 367 .name = "min_links", 368 .desc = "Minimum number of available links before turning on carrier", 369 .values = bond_intmax_tbl, 370 .set = bond_option_min_links_set 371 }, 372 [BOND_OPT_AD_SELECT] = { 373 .id = BOND_OPT_AD_SELECT, 374 .name = "ad_select", 375 .desc = "802.3ad aggregation selection logic", 376 .flags = BOND_OPTFLAG_IFDOWN, 377 .values = bond_ad_select_tbl, 378 .set = bond_option_ad_select_set 379 }, 380 [BOND_OPT_NUM_PEER_NOTIF] = { 381 .id = BOND_OPT_NUM_PEER_NOTIF, 382 .name = "num_unsol_na", 383 .desc = "Number of peer notifications to send on failover event", 384 .values = bond_num_peer_notif_tbl, 385 .set = bond_option_num_peer_notif_set 386 }, 387 [BOND_OPT_MIIMON] = { 388 .id = BOND_OPT_MIIMON, 389 .name = "miimon", 390 .desc = "Link check interval in milliseconds", 391 .values = bond_intmax_tbl, 392 .set = bond_option_miimon_set 393 }, 394 [BOND_OPT_PRIO] = { 395 .id = BOND_OPT_PRIO, 396 .name = "prio", 397 .desc = "Link priority for failover re-selection", 398 .flags = BOND_OPTFLAG_RAWVAL, 399 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_ACTIVEBACKUP) | 400 BIT(BOND_MODE_TLB) | 401 BIT(BOND_MODE_ALB)), 402 .set = bond_option_prio_set 403 }, 404 [BOND_OPT_PRIMARY] = { 405 .id = BOND_OPT_PRIMARY, 406 .name = "primary", 407 .desc = "Primary network device to use", 408 .flags = BOND_OPTFLAG_RAWVAL, 409 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_ACTIVEBACKUP) | 410 BIT(BOND_MODE_TLB) | 411 BIT(BOND_MODE_ALB)), 412 .set = bond_option_primary_set 413 }, 414 [BOND_OPT_PRIMARY_RESELECT] = { 415 .id = BOND_OPT_PRIMARY_RESELECT, 416 .name = "primary_reselect", 417 .desc = "Reselect primary slave once it comes up", 418 .values = bond_primary_reselect_tbl, 419 .set = bond_option_primary_reselect_set 420 }, 421 [BOND_OPT_USE_CARRIER] = { 422 .id = BOND_OPT_USE_CARRIER, 423 .name = "use_carrier", 424 .desc = "option obsolete, use_carrier cannot be disabled", 425 .values = bond_use_carrier_tbl, 426 .set = bond_option_use_carrier_set 427 }, 428 [BOND_OPT_ACTIVE_SLAVE] = { 429 .id = BOND_OPT_ACTIVE_SLAVE, 430 .name = "active_slave", 431 .desc = "Currently active slave", 432 .flags = BOND_OPTFLAG_RAWVAL, 433 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_ACTIVEBACKUP) | 434 BIT(BOND_MODE_TLB) | 435 BIT(BOND_MODE_ALB)), 436 .set = bond_option_active_slave_set 437 }, 438 [BOND_OPT_QUEUE_ID] = { 439 .id = BOND_OPT_QUEUE_ID, 440 .name = "queue_id", 441 .desc = "Set queue id of a slave", 442 .flags = BOND_OPTFLAG_RAWVAL, 443 .set = bond_option_queue_id_set 444 }, 445 [BOND_OPT_ALL_SLAVES_ACTIVE] = { 446 .id = BOND_OPT_ALL_SLAVES_ACTIVE, 447 .name = "all_slaves_active", 448 .desc = "Keep all frames received on an interface by setting active flag for all slaves", 449 .values = bond_all_slaves_active_tbl, 450 .set = bond_option_all_slaves_active_set 451 }, 452 [BOND_OPT_RESEND_IGMP] = { 453 .id = BOND_OPT_RESEND_IGMP, 454 .name = "resend_igmp", 455 .desc = "Number of IGMP membership reports to send on link failure", 456 .values = bond_resend_igmp_tbl, 457 .set = bond_option_resend_igmp_set 458 }, 459 [BOND_OPT_LP_INTERVAL] = { 460 .id = BOND_OPT_LP_INTERVAL, 461 .name = "lp_interval", 462 .desc = "The number of seconds between instances where the bonding driver sends learning packets to each slave's peer switch", 463 .values = bond_lp_interval_tbl, 464 .set = bond_option_lp_interval_set 465 }, 466 [BOND_OPT_SLAVES] = { 467 .id = BOND_OPT_SLAVES, 468 .name = "slaves", 469 .desc = "Slave membership management", 470 .flags = BOND_OPTFLAG_RAWVAL, 471 .set = bond_option_slaves_set 472 }, 473 [BOND_OPT_TLB_DYNAMIC_LB] = { 474 .id = BOND_OPT_TLB_DYNAMIC_LB, 475 .name = "tlb_dynamic_lb", 476 .desc = "Enable dynamic flow shuffling", 477 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_TLB) | BIT(BOND_MODE_ALB)), 478 .values = bond_tlb_dynamic_lb_tbl, 479 .flags = BOND_OPTFLAG_IFDOWN, 480 .set = bond_option_tlb_dynamic_lb_set, 481 }, 482 [BOND_OPT_AD_ACTOR_SYS_PRIO] = { 483 .id = BOND_OPT_AD_ACTOR_SYS_PRIO, 484 .name = "ad_actor_sys_prio", 485 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD)), 486 .values = bond_ad_actor_sys_prio_tbl, 487 .set = bond_option_ad_actor_sys_prio_set, 488 }, 489 [BOND_OPT_ACTOR_PORT_PRIO] = { 490 .id = BOND_OPT_ACTOR_PORT_PRIO, 491 .name = "actor_port_prio", 492 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD)), 493 .flags = BOND_OPTFLAG_RAWVAL, 494 .set = bond_option_actor_port_prio_set, 495 }, 496 [BOND_OPT_AD_ACTOR_SYSTEM] = { 497 .id = BOND_OPT_AD_ACTOR_SYSTEM, 498 .name = "ad_actor_system", 499 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD)), 500 .flags = BOND_OPTFLAG_RAWVAL, 501 .set = bond_option_ad_actor_system_set, 502 }, 503 [BOND_OPT_AD_USER_PORT_KEY] = { 504 .id = BOND_OPT_AD_USER_PORT_KEY, 505 .name = "ad_user_port_key", 506 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD)), 507 .flags = BOND_OPTFLAG_IFDOWN, 508 .values = bond_ad_user_port_key_tbl, 509 .set = bond_option_ad_user_port_key_set, 510 }, 511 [BOND_OPT_NUM_PEER_NOTIF_ALIAS] = { 512 .id = BOND_OPT_NUM_PEER_NOTIF_ALIAS, 513 .name = "num_grat_arp", 514 .desc = "Number of peer notifications to send on failover event", 515 .values = bond_num_peer_notif_tbl, 516 .set = bond_option_num_peer_notif_set 517 }, 518 [BOND_OPT_PEER_NOTIF_DELAY] = { 519 .id = BOND_OPT_PEER_NOTIF_DELAY, 520 .name = "peer_notif_delay", 521 .desc = "Delay between each peer notification on failover event, in milliseconds", 522 .values = bond_peer_notif_delay_tbl, 523 .set = bond_option_peer_notif_delay_set 524 }, 525 [BOND_OPT_COUPLED_CONTROL] = { 526 .id = BOND_OPT_COUPLED_CONTROL, 527 .name = "coupled_control", 528 .desc = "Opt into using coupled control MUX for LACP states", 529 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD)), 530 .flags = BOND_OPTFLAG_IFDOWN, 531 .values = bond_coupled_control_tbl, 532 .set = bond_option_coupled_control_set, 533 }, 534 [BOND_OPT_BROADCAST_NEIGH] = { 535 .id = BOND_OPT_BROADCAST_NEIGH, 536 .name = "broadcast_neighbor", 537 .desc = "Broadcast neighbor packets to all active slaves", 538 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD)), 539 .values = bond_broadcast_neigh_tbl, 540 .set = bond_option_broadcast_neigh_set, 541 } 542}; 543 544/* Searches for an option by name */ 545const struct bond_option *bond_opt_get_by_name(const char *name) 546{ 547 const struct bond_option *opt; 548 int option; 549 550 for (option = 0; option < BOND_OPT_LAST; option++) { 551 opt = bond_opt_get(option); 552 if (opt && !strcmp(opt->name, name)) 553 return opt; 554 } 555 556 return NULL; 557} 558 559/* Searches for a value in opt's values[] table */ 560const struct bond_opt_value *bond_opt_get_val(unsigned int option, u64 val) 561{ 562 const struct bond_option *opt; 563 int i; 564 565 opt = bond_opt_get(option); 566 if (WARN_ON(!opt)) 567 return NULL; 568 for (i = 0; opt->values && opt->values[i].string; i++) 569 if (opt->values[i].value == val) 570 return &opt->values[i]; 571 572 return NULL; 573} 574 575/* Searches for a value in opt's values[] table which matches the flagmask */ 576static const struct bond_opt_value *bond_opt_get_flags(const struct bond_option *opt, 577 u32 flagmask) 578{ 579 int i; 580 581 for (i = 0; opt->values && opt->values[i].string; i++) 582 if (opt->values[i].flags & flagmask) 583 return &opt->values[i]; 584 585 return NULL; 586} 587 588/* If maxval is missing then there's no range to check. In case minval is 589 * missing then it's considered to be 0. 590 */ 591static bool bond_opt_check_range(const struct bond_option *opt, u64 val) 592{ 593 const struct bond_opt_value *minval, *maxval; 594 595 minval = bond_opt_get_flags(opt, BOND_VALFLAG_MIN); 596 maxval = bond_opt_get_flags(opt, BOND_VALFLAG_MAX); 597 if (!maxval || (minval && val < minval->value) || val > maxval->value) 598 return false; 599 600 return true; 601} 602 603/** 604 * bond_opt_parse - parse option value 605 * @opt: the option to parse against 606 * @val: value to parse 607 * 608 * This function tries to extract the value from @val and check if it's 609 * a possible match for the option and returns NULL if a match isn't found, 610 * or the struct_opt_value that matched. It also strips the new line from 611 * @val->string if it's present. 612 */ 613const struct bond_opt_value *bond_opt_parse(const struct bond_option *opt, 614 struct bond_opt_value *val) 615{ 616 char *p, valstr[BOND_OPT_MAX_NAMELEN + 1] = { 0, }; 617 const struct bond_opt_value *tbl; 618 const struct bond_opt_value *ret = NULL; 619 bool checkval; 620 int i, rv; 621 622 /* No parsing if the option wants a raw val */ 623 if (opt->flags & BOND_OPTFLAG_RAWVAL) 624 return val; 625 626 tbl = opt->values; 627 if (!tbl) 628 goto out; 629 630 /* ULLONG_MAX is used to bypass string processing */ 631 checkval = val->value != ULLONG_MAX; 632 if (!checkval) { 633 if (!val->string) 634 goto out; 635 p = strchr(val->string, '\n'); 636 if (p) 637 *p = '\0'; 638 for (p = val->string; *p; p++) 639 if (!(isdigit(*p) || isspace(*p))) 640 break; 641 /* The following code extracts the string to match or the value 642 * and sets checkval appropriately 643 */ 644 if (*p) { 645 rv = sscanf(val->string, "%32s", valstr); 646 } else { 647 rv = sscanf(val->string, "%llu", &val->value); 648 checkval = true; 649 } 650 if (!rv) 651 goto out; 652 } 653 654 for (i = 0; tbl[i].string; i++) { 655 /* Check for exact match */ 656 if (checkval) { 657 if (val->value == tbl[i].value) 658 ret = &tbl[i]; 659 } else { 660 if (!strcmp(valstr, "default") && 661 (tbl[i].flags & BOND_VALFLAG_DEFAULT)) 662 ret = &tbl[i]; 663 664 if (!strcmp(valstr, tbl[i].string)) 665 ret = &tbl[i]; 666 } 667 /* Found an exact match */ 668 if (ret) 669 goto out; 670 } 671 /* Possible range match */ 672 if (checkval && bond_opt_check_range(opt, val->value)) 673 ret = val; 674out: 675 return ret; 676} 677 678/* Check opt's dependencies against bond mode and currently set options */ 679static int bond_opt_check_deps(struct bonding *bond, 680 const struct bond_option *opt) 681{ 682 struct bond_params *params = &bond->params; 683 684 if (test_bit(params->mode, &opt->unsuppmodes)) 685 return -EACCES; 686 if ((opt->flags & BOND_OPTFLAG_NOSLAVES) && bond_has_slaves(bond)) 687 return -ENOTEMPTY; 688 if ((opt->flags & BOND_OPTFLAG_IFDOWN) && (bond->dev->flags & IFF_UP)) 689 return -EBUSY; 690 691 return 0; 692} 693 694static void bond_opt_dep_print(struct bonding *bond, 695 const struct bond_option *opt, 696 struct nlattr *bad_attr, 697 struct netlink_ext_ack *extack) 698{ 699 const struct bond_opt_value *modeval; 700 struct bond_params *params; 701 702 params = &bond->params; 703 modeval = bond_opt_get_val(BOND_OPT_MODE, params->mode); 704 if (test_bit(params->mode, &opt->unsuppmodes)) { 705 netdev_err(bond->dev, "option %s: mode dependency failed, not supported in mode %s(%llu)\n", 706 opt->name, modeval->string, modeval->value); 707 NL_SET_ERR_MSG_ATTR(extack, bad_attr, 708 "option not supported in mode"); 709 } 710} 711 712static void bond_opt_error_interpret(struct bonding *bond, 713 const struct bond_option *opt, 714 int error, const struct bond_opt_value *val, 715 struct nlattr *bad_attr, 716 struct netlink_ext_ack *extack) 717{ 718 const struct bond_opt_value *minval, *maxval; 719 char *p; 720 721 switch (error) { 722 case -EINVAL: 723 NL_SET_ERR_MSG_ATTR(extack, bad_attr, "invalid option value"); 724 if (val) { 725 if (val->string) { 726 /* sometimes RAWVAL opts may have new lines */ 727 p = strchr(val->string, '\n'); 728 if (p) 729 *p = '\0'; 730 netdev_err(bond->dev, "option %s: invalid value (%s)\n", 731 opt->name, val->string); 732 } else { 733 netdev_err(bond->dev, "option %s: invalid value (%llu)\n", 734 opt->name, val->value); 735 } 736 } 737 minval = bond_opt_get_flags(opt, BOND_VALFLAG_MIN); 738 maxval = bond_opt_get_flags(opt, BOND_VALFLAG_MAX); 739 if (!maxval) 740 break; 741 netdev_err(bond->dev, "option %s: allowed values %llu - %llu\n", 742 opt->name, minval ? minval->value : 0, maxval->value); 743 break; 744 case -EACCES: 745 bond_opt_dep_print(bond, opt, bad_attr, extack); 746 break; 747 case -ENOTEMPTY: 748 NL_SET_ERR_MSG_ATTR(extack, bad_attr, 749 "unable to set option because the bond device has slaves"); 750 netdev_err(bond->dev, "option %s: unable to set because the bond device has slaves\n", 751 opt->name); 752 break; 753 case -EBUSY: 754 NL_SET_ERR_MSG_ATTR(extack, bad_attr, 755 "unable to set option because the bond is up"); 756 netdev_err(bond->dev, "option %s: unable to set because the bond device is up\n", 757 opt->name); 758 break; 759 case -ENODEV: 760 if (val && val->string) { 761 p = strchr(val->string, '\n'); 762 if (p) 763 *p = '\0'; 764 netdev_err(bond->dev, "option %s: interface %s does not exist!\n", 765 opt->name, val->string); 766 NL_SET_ERR_MSG_ATTR(extack, bad_attr, 767 "interface does not exist"); 768 } 769 break; 770 default: 771 break; 772 } 773} 774 775/** 776 * __bond_opt_set - set a bonding option 777 * @bond: target bond device 778 * @option: option to set 779 * @val: value to set it to 780 * @bad_attr: netlink attribue that caused the error 781 * @extack: extended netlink error structure, used when an error message 782 * needs to be returned to the caller via netlink 783 * 784 * This function is used to change the bond's option value, it can be 785 * used for both enabling/changing an option and for disabling it. RTNL lock 786 * must be obtained before calling this function. 787 */ 788int __bond_opt_set(struct bonding *bond, 789 unsigned int option, struct bond_opt_value *val, 790 struct nlattr *bad_attr, struct netlink_ext_ack *extack) 791{ 792 const struct bond_opt_value *retval = NULL; 793 const struct bond_option *opt; 794 int ret = -ENOENT; 795 796 ASSERT_RTNL(); 797 798 opt = bond_opt_get(option); 799 if (WARN_ON(!val) || WARN_ON(!opt)) 800 goto out; 801 ret = bond_opt_check_deps(bond, opt); 802 if (ret) 803 goto out; 804 retval = bond_opt_parse(opt, val); 805 if (!retval) { 806 ret = -EINVAL; 807 goto out; 808 } 809 ret = opt->set(bond, retval); 810out: 811 if (ret) 812 bond_opt_error_interpret(bond, opt, ret, val, bad_attr, extack); 813 814 return ret; 815} 816/** 817 * __bond_opt_set_notify - set a bonding option 818 * @bond: target bond device 819 * @option: option to set 820 * @val: value to set it to 821 * 822 * This function is used to change the bond's option value and trigger 823 * a notification to user sapce. It can be used for both enabling/changing 824 * an option and for disabling it. RTNL lock must be obtained before calling 825 * this function. 826 */ 827int __bond_opt_set_notify(struct bonding *bond, 828 unsigned int option, struct bond_opt_value *val) 829{ 830 int ret; 831 832 ASSERT_RTNL(); 833 834 ret = __bond_opt_set(bond, option, val, NULL, NULL); 835 836 if (!ret && (bond->dev->reg_state == NETREG_REGISTERED)) 837 call_netdevice_notifiers(NETDEV_CHANGEINFODATA, bond->dev); 838 839 return ret; 840} 841 842/** 843 * bond_opt_tryset_rtnl - try to acquire rtnl and call __bond_opt_set 844 * @bond: target bond device 845 * @option: option to set 846 * @buf: value to set it to 847 * 848 * This function tries to acquire RTNL without blocking and if successful 849 * calls __bond_opt_set. It is mainly used for sysfs option manipulation. 850 */ 851int bond_opt_tryset_rtnl(struct bonding *bond, unsigned int option, char *buf) 852{ 853 struct bond_opt_value optval; 854 int ret; 855 856 if (!rtnl_trylock()) 857 return restart_syscall(); 858 bond_opt_initstr(&optval, buf); 859 ret = __bond_opt_set_notify(bond, option, &optval); 860 rtnl_unlock(); 861 862 return ret; 863} 864 865/** 866 * bond_opt_get - get a pointer to an option 867 * @option: option for which to return a pointer 868 * 869 * This function checks if option is valid and if so returns a pointer 870 * to its entry in the bond_opts[] option array. 871 */ 872const struct bond_option *bond_opt_get(unsigned int option) 873{ 874 if (!BOND_OPT_VALID(option)) 875 return NULL; 876 877 return &bond_opts[option]; 878} 879 880static bool bond_set_xfrm_features(struct bonding *bond) 881{ 882 if (!IS_ENABLED(CONFIG_XFRM_OFFLOAD)) 883 return false; 884 885 if (BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP) 886 bond->dev->wanted_features |= BOND_XFRM_FEATURES; 887 else 888 bond->dev->wanted_features &= ~BOND_XFRM_FEATURES; 889 890 return true; 891} 892 893static int bond_option_mode_set(struct bonding *bond, 894 const struct bond_opt_value *newval) 895{ 896 if (bond->xdp_prog && !bond_xdp_check(bond, newval->value)) 897 return -EOPNOTSUPP; 898 899 if (!bond_mode_uses_arp(newval->value)) { 900 if (bond->params.arp_interval) { 901 netdev_dbg(bond->dev, "%s mode is incompatible with arp monitoring, start mii monitoring\n", 902 newval->string); 903 /* disable arp monitoring */ 904 bond->params.arp_interval = 0; 905 } 906 907 if (!bond->params.miimon) { 908 /* set miimon to default value */ 909 bond->params.miimon = BOND_DEFAULT_MIIMON; 910 netdev_dbg(bond->dev, "Setting MII monitoring interval to %d\n", 911 bond->params.miimon); 912 } 913 } 914 915 if (newval->value == BOND_MODE_ALB) 916 bond->params.tlb_dynamic_lb = 1; 917 918 /* don't cache arp_validate between modes */ 919 bond->params.arp_validate = BOND_ARP_VALIDATE_NONE; 920 bond->params.mode = newval->value; 921 922 /* When changing mode, the bond device is down, we may reduce 923 * the bond_bcast_neigh_enabled in bond_close() if broadcast_neighbor 924 * enabled in 8023ad mode. Therefore, only clear broadcast_neighbor 925 * to 0. 926 */ 927 bond->params.broadcast_neighbor = 0; 928 929 if (bond->dev->reg_state == NETREG_REGISTERED) { 930 bool update = false; 931 932 update |= bond_set_xfrm_features(bond); 933 934 if (update) 935 netdev_update_features(bond->dev); 936 } 937 938 bond_xdp_set_features(bond->dev); 939 940 return 0; 941} 942 943static int bond_option_active_slave_set(struct bonding *bond, 944 const struct bond_opt_value *newval) 945{ 946 char ifname[IFNAMSIZ] = { 0, }; 947 struct net_device *slave_dev; 948 int ret = 0; 949 950 sscanf(newval->string, "%15s", ifname); /* IFNAMSIZ */ 951 if (!strlen(ifname) || newval->string[0] == '\n') { 952 slave_dev = NULL; 953 } else { 954 slave_dev = __dev_get_by_name(dev_net(bond->dev), ifname); 955 if (!slave_dev) 956 return -ENODEV; 957 } 958 959 if (slave_dev) { 960 if (!netif_is_bond_slave(slave_dev)) { 961 slave_err(bond->dev, slave_dev, "Device is not bonding slave\n"); 962 return -EINVAL; 963 } 964 965 if (bond->dev != netdev_master_upper_dev_get(slave_dev)) { 966 slave_err(bond->dev, slave_dev, "Device is not our slave\n"); 967 return -EINVAL; 968 } 969 } 970 971 block_netpoll_tx(); 972 /* check to see if we are clearing active */ 973 if (!slave_dev) { 974 netdev_dbg(bond->dev, "Clearing current active slave\n"); 975 bond_change_active_slave(bond, NULL); 976 bond_select_active_slave(bond); 977 } else { 978 struct slave *old_active = rtnl_dereference(bond->curr_active_slave); 979 struct slave *new_active = bond_slave_get_rtnl(slave_dev); 980 981 BUG_ON(!new_active); 982 983 if (new_active == old_active) { 984 /* do nothing */ 985 slave_dbg(bond->dev, new_active->dev, "is already the current active slave\n"); 986 } else { 987 if (old_active && (new_active->link == BOND_LINK_UP) && 988 bond_slave_is_up(new_active)) { 989 slave_dbg(bond->dev, new_active->dev, "Setting as active slave\n"); 990 bond_change_active_slave(bond, new_active); 991 } else { 992 slave_err(bond->dev, new_active->dev, "Could not set as active slave; either %s is down or the link is down\n", 993 new_active->dev->name); 994 ret = -EINVAL; 995 } 996 } 997 } 998 unblock_netpoll_tx(); 999 1000 return ret; 1001} 1002 1003/* There are two tricky bits here. First, if MII monitoring is activated, then 1004 * we must disable ARP monitoring. Second, if the timer isn't running, we must 1005 * start it. 1006 */ 1007static int bond_option_miimon_set(struct bonding *bond, 1008 const struct bond_opt_value *newval) 1009{ 1010 netdev_dbg(bond->dev, "Setting MII monitoring interval to %llu\n", 1011 newval->value); 1012 bond->params.miimon = newval->value; 1013 if (bond->params.updelay) 1014 netdev_dbg(bond->dev, "Note: Updating updelay (to %d) since it is a multiple of the miimon value\n", 1015 bond->params.updelay * bond->params.miimon); 1016 if (bond->params.downdelay) 1017 netdev_dbg(bond->dev, "Note: Updating downdelay (to %d) since it is a multiple of the miimon value\n", 1018 bond->params.downdelay * bond->params.miimon); 1019 if (bond->params.peer_notif_delay) 1020 netdev_dbg(bond->dev, "Note: Updating peer_notif_delay (to %d) since it is a multiple of the miimon value\n", 1021 bond->params.peer_notif_delay * bond->params.miimon); 1022 if (newval->value && bond->params.arp_interval) { 1023 netdev_dbg(bond->dev, "MII monitoring cannot be used with ARP monitoring - disabling ARP monitoring...\n"); 1024 bond->params.arp_interval = 0; 1025 if (bond->params.arp_validate) 1026 bond->params.arp_validate = BOND_ARP_VALIDATE_NONE; 1027 } 1028 if (bond->dev->flags & IFF_UP) { 1029 /* If the interface is up, we may need to fire off 1030 * the MII timer. If the interface is down, the 1031 * timer will get fired off when the open function 1032 * is called. 1033 */ 1034 if (!newval->value) { 1035 cancel_delayed_work_sync(&bond->mii_work); 1036 } else { 1037 cancel_delayed_work_sync(&bond->arp_work); 1038 queue_delayed_work(bond->wq, &bond->mii_work, 0); 1039 } 1040 } 1041 1042 return 0; 1043} 1044 1045/* Set up, down and peer notification delays. These must be multiples 1046 * of the MII monitoring value, and are stored internally as the 1047 * multiplier. Thus, we must translate to MS for the real world. 1048 */ 1049static int _bond_option_delay_set(struct bonding *bond, 1050 const struct bond_opt_value *newval, 1051 const char *name, 1052 int *target) 1053{ 1054 int value = newval->value; 1055 1056 if (!bond->params.miimon) { 1057 netdev_err(bond->dev, "Unable to set %s as MII monitoring is disabled\n", 1058 name); 1059 return -EPERM; 1060 } 1061 if ((value % bond->params.miimon) != 0) { 1062 netdev_warn(bond->dev, 1063 "%s (%d) is not a multiple of miimon (%d), value rounded to %d ms\n", 1064 name, 1065 value, bond->params.miimon, 1066 (value / bond->params.miimon) * 1067 bond->params.miimon); 1068 } 1069 *target = value / bond->params.miimon; 1070 netdev_dbg(bond->dev, "Setting %s to %d\n", 1071 name, 1072 *target * bond->params.miimon); 1073 1074 return 0; 1075} 1076 1077static int bond_option_updelay_set(struct bonding *bond, 1078 const struct bond_opt_value *newval) 1079{ 1080 return _bond_option_delay_set(bond, newval, "up delay", 1081 &bond->params.updelay); 1082} 1083 1084static int bond_option_downdelay_set(struct bonding *bond, 1085 const struct bond_opt_value *newval) 1086{ 1087 return _bond_option_delay_set(bond, newval, "down delay", 1088 &bond->params.downdelay); 1089} 1090 1091static int bond_option_peer_notif_delay_set(struct bonding *bond, 1092 const struct bond_opt_value *newval) 1093{ 1094 int ret = _bond_option_delay_set(bond, newval, 1095 "peer notification delay", 1096 &bond->params.peer_notif_delay); 1097 return ret; 1098} 1099 1100static int bond_option_use_carrier_set(struct bonding *bond, 1101 const struct bond_opt_value *newval) 1102{ 1103 return 0; 1104} 1105 1106/* There are two tricky bits here. First, if ARP monitoring is activated, then 1107 * we must disable MII monitoring. Second, if the ARP timer isn't running, 1108 * we must start it. 1109 */ 1110static int bond_option_arp_interval_set(struct bonding *bond, 1111 const struct bond_opt_value *newval) 1112{ 1113 netdev_dbg(bond->dev, "Setting ARP monitoring interval to %llu\n", 1114 newval->value); 1115 bond->params.arp_interval = newval->value; 1116 if (newval->value) { 1117 if (bond->params.miimon) { 1118 netdev_dbg(bond->dev, "ARP monitoring cannot be used with MII monitoring. Disabling MII monitoring\n"); 1119 bond->params.miimon = 0; 1120 } 1121 if (!bond->params.arp_targets[0]) 1122 netdev_dbg(bond->dev, "ARP monitoring has been set up, but no ARP targets have been specified\n"); 1123 } 1124 if (bond->dev->flags & IFF_UP) { 1125 /* If the interface is up, we may need to fire off 1126 * the ARP timer. If the interface is down, the 1127 * timer will get fired off when the open function 1128 * is called. 1129 */ 1130 if (!newval->value) { 1131 if (bond->params.arp_validate) 1132 bond->recv_probe = NULL; 1133 cancel_delayed_work_sync(&bond->arp_work); 1134 } else { 1135 /* arp_validate can be set only in active-backup mode */ 1136 bond->recv_probe = bond_rcv_validate; 1137 cancel_delayed_work_sync(&bond->mii_work); 1138 queue_delayed_work(bond->wq, &bond->arp_work, 0); 1139 } 1140 } 1141 1142 return 0; 1143} 1144 1145static void _bond_options_arp_ip_target_set(struct bonding *bond, int slot, 1146 __be32 target, 1147 unsigned long last_rx) 1148{ 1149 __be32 *targets = bond->params.arp_targets; 1150 struct list_head *iter; 1151 struct slave *slave; 1152 1153 if (slot >= 0 && slot < BOND_MAX_ARP_TARGETS) { 1154 bond_for_each_slave(bond, slave, iter) 1155 WRITE_ONCE(slave->target_last_arp_rx[slot], last_rx); 1156 targets[slot] = target; 1157 } 1158} 1159 1160static int _bond_option_arp_ip_target_add(struct bonding *bond, __be32 target) 1161{ 1162 __be32 *targets = bond->params.arp_targets; 1163 int ind; 1164 1165 if (!bond_is_ip_target_ok(target)) { 1166 netdev_err(bond->dev, "invalid ARP target %pI4 specified for addition\n", 1167 &target); 1168 return -EINVAL; 1169 } 1170 1171 if (bond_get_targets_ip(targets, target) != -1) { /* dup */ 1172 netdev_err(bond->dev, "ARP target %pI4 is already present\n", 1173 &target); 1174 return -EINVAL; 1175 } 1176 1177 ind = bond_get_targets_ip(targets, 0); /* first free slot */ 1178 if (ind == -1) { 1179 netdev_err(bond->dev, "ARP target table is full!\n"); 1180 return -EINVAL; 1181 } 1182 1183 netdev_dbg(bond->dev, "Adding ARP target %pI4\n", &target); 1184 1185 _bond_options_arp_ip_target_set(bond, ind, target, jiffies); 1186 1187 return 0; 1188} 1189 1190static int bond_option_arp_ip_target_add(struct bonding *bond, __be32 target) 1191{ 1192 return _bond_option_arp_ip_target_add(bond, target); 1193} 1194 1195static int bond_option_arp_ip_target_rem(struct bonding *bond, __be32 target) 1196{ 1197 __be32 *targets = bond->params.arp_targets; 1198 struct list_head *iter; 1199 struct slave *slave; 1200 unsigned long *targets_rx; 1201 int ind, i; 1202 1203 if (!bond_is_ip_target_ok(target)) { 1204 netdev_err(bond->dev, "invalid ARP target %pI4 specified for removal\n", 1205 &target); 1206 return -EINVAL; 1207 } 1208 1209 ind = bond_get_targets_ip(targets, target); 1210 if (ind == -1) { 1211 netdev_err(bond->dev, "unable to remove nonexistent ARP target %pI4\n", 1212 &target); 1213 return -EINVAL; 1214 } 1215 1216 if (ind == 0 && !targets[1] && bond->params.arp_interval) 1217 netdev_warn(bond->dev, "Removing last arp target with arp_interval on\n"); 1218 1219 netdev_dbg(bond->dev, "Removing ARP target %pI4\n", &target); 1220 1221 bond_for_each_slave(bond, slave, iter) { 1222 targets_rx = slave->target_last_arp_rx; 1223 for (i = ind; (i < BOND_MAX_ARP_TARGETS-1) && targets[i+1]; i++) 1224 WRITE_ONCE(targets_rx[i], READ_ONCE(targets_rx[i+1])); 1225 WRITE_ONCE(targets_rx[i], 0); 1226 } 1227 for (i = ind; (i < BOND_MAX_ARP_TARGETS-1) && targets[i+1]; i++) 1228 targets[i] = targets[i+1]; 1229 targets[i] = 0; 1230 1231 return 0; 1232} 1233 1234void bond_option_arp_ip_targets_clear(struct bonding *bond) 1235{ 1236 int i; 1237 1238 for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) 1239 _bond_options_arp_ip_target_set(bond, i, 0, 0); 1240} 1241 1242static int bond_option_arp_ip_targets_set(struct bonding *bond, 1243 const struct bond_opt_value *newval) 1244{ 1245 int ret = -EPERM; 1246 __be32 target; 1247 1248 if (newval->string) { 1249 if (strlen(newval->string) < 1 || 1250 !in4_pton(newval->string + 1, -1, (u8 *)&target, -1, NULL)) { 1251 netdev_err(bond->dev, "invalid ARP target specified\n"); 1252 return ret; 1253 } 1254 if (newval->string[0] == '+') 1255 ret = bond_option_arp_ip_target_add(bond, target); 1256 else if (newval->string[0] == '-') 1257 ret = bond_option_arp_ip_target_rem(bond, target); 1258 else 1259 netdev_err(bond->dev, "no command found in arp_ip_targets file - use +<addr> or -<addr>\n"); 1260 } else { 1261 target = newval->value; 1262 ret = bond_option_arp_ip_target_add(bond, target); 1263 } 1264 1265 return ret; 1266} 1267 1268#if IS_ENABLED(CONFIG_IPV6) 1269static bool slave_can_set_ns_maddr(const struct bonding *bond, struct slave *slave) 1270{ 1271 return BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP && 1272 !bond_is_active_slave(slave) && 1273 slave->dev->flags & IFF_MULTICAST; 1274} 1275 1276/** 1277 * slave_set_ns_maddrs - add/del all NS mac addresses for slave 1278 * @bond: bond device 1279 * @slave: slave device 1280 * @add: add or remove all the NS mac addresses 1281 * 1282 * This function tries to add or delete all the NS mac addresses on the slave 1283 * 1284 * Note, the IPv6 NS target address is the unicast address in Neighbor 1285 * Solicitation (NS) message. The dest address of NS message should be 1286 * solicited-node multicast address of the target. The dest mac of NS message 1287 * is converted from the solicited-node multicast address. 1288 * 1289 * This function is called when 1290 * * arp_validate changes 1291 * * enslaving, releasing new slaves 1292 */ 1293static void slave_set_ns_maddrs(struct bonding *bond, struct slave *slave, bool add) 1294{ 1295 struct in6_addr *targets = bond->params.ns_targets; 1296 char slot_maddr[MAX_ADDR_LEN]; 1297 struct in6_addr mcaddr; 1298 int i; 1299 1300 if (!slave_can_set_ns_maddr(bond, slave)) 1301 return; 1302 1303 for (i = 0; i < BOND_MAX_NS_TARGETS; i++) { 1304 if (ipv6_addr_any(&targets[i])) 1305 break; 1306 1307 addrconf_addr_solict_mult(&targets[i], &mcaddr); 1308 if (!ndisc_mc_map(&mcaddr, slot_maddr, slave->dev, 0)) { 1309 if (add) 1310 dev_mc_add(slave->dev, slot_maddr); 1311 else 1312 dev_mc_del(slave->dev, slot_maddr); 1313 } 1314 } 1315} 1316 1317void bond_slave_ns_maddrs_add(struct bonding *bond, struct slave *slave) 1318{ 1319 if (!bond->params.arp_validate) 1320 return; 1321 slave_set_ns_maddrs(bond, slave, true); 1322} 1323 1324void bond_slave_ns_maddrs_del(struct bonding *bond, struct slave *slave) 1325{ 1326 if (!bond->params.arp_validate) 1327 return; 1328 slave_set_ns_maddrs(bond, slave, false); 1329} 1330 1331/** 1332 * slave_set_ns_maddr - set new NS mac address for slave 1333 * @bond: bond device 1334 * @slave: slave device 1335 * @target: the new IPv6 target 1336 * @slot: the old IPv6 target in the slot 1337 * 1338 * This function tries to replace the old mac address to new one on the slave. 1339 * 1340 * Note, the target/slot IPv6 address is the unicast address in Neighbor 1341 * Solicitation (NS) message. The dest address of NS message should be 1342 * solicited-node multicast address of the target. The dest mac of NS message 1343 * is converted from the solicited-node multicast address. 1344 * 1345 * This function is called when 1346 * * An IPv6 NS target is added or removed. 1347 */ 1348static void slave_set_ns_maddr(struct bonding *bond, struct slave *slave, 1349 struct in6_addr *target, struct in6_addr *slot) 1350{ 1351 char mac_addr[MAX_ADDR_LEN]; 1352 struct in6_addr mcast_addr; 1353 1354 if (!bond->params.arp_validate || !slave_can_set_ns_maddr(bond, slave)) 1355 return; 1356 1357 /* remove the previous mac addr from slave */ 1358 addrconf_addr_solict_mult(slot, &mcast_addr); 1359 if (!ipv6_addr_any(slot) && 1360 !ndisc_mc_map(&mcast_addr, mac_addr, slave->dev, 0)) 1361 dev_mc_del(slave->dev, mac_addr); 1362 1363 /* add new mac addr on slave if target is set */ 1364 addrconf_addr_solict_mult(target, &mcast_addr); 1365 if (!ipv6_addr_any(target) && 1366 !ndisc_mc_map(&mcast_addr, mac_addr, slave->dev, 0)) 1367 dev_mc_add(slave->dev, mac_addr); 1368} 1369 1370static void _bond_options_ns_ip6_target_set(struct bonding *bond, int slot, 1371 struct in6_addr *target, 1372 unsigned long last_rx) 1373{ 1374 struct in6_addr *targets = bond->params.ns_targets; 1375 struct list_head *iter; 1376 struct slave *slave; 1377 1378 if (slot >= 0 && slot < BOND_MAX_NS_TARGETS) { 1379 bond_for_each_slave(bond, slave, iter) { 1380 WRITE_ONCE(slave->target_last_arp_rx[slot], last_rx); 1381 slave_set_ns_maddr(bond, slave, target, &targets[slot]); 1382 } 1383 targets[slot] = *target; 1384 } 1385} 1386 1387void bond_option_ns_ip6_targets_clear(struct bonding *bond) 1388{ 1389 struct in6_addr addr_any = in6addr_any; 1390 int i; 1391 1392 for (i = 0; i < BOND_MAX_NS_TARGETS; i++) 1393 _bond_options_ns_ip6_target_set(bond, i, &addr_any, 0); 1394} 1395 1396static int bond_option_ns_ip6_targets_set(struct bonding *bond, 1397 const struct bond_opt_value *newval) 1398{ 1399 struct in6_addr *target = (struct in6_addr *)newval->extra; 1400 struct in6_addr *targets = bond->params.ns_targets; 1401 struct in6_addr addr_any = in6addr_any; 1402 int index; 1403 1404 if (!bond_is_ip6_target_ok(target)) { 1405 netdev_err(bond->dev, "invalid NS target %pI6c specified for addition\n", 1406 target); 1407 return -EINVAL; 1408 } 1409 1410 if (bond_get_targets_ip6(targets, target) != -1) { /* dup */ 1411 netdev_err(bond->dev, "NS target %pI6c is already present\n", 1412 target); 1413 return -EINVAL; 1414 } 1415 1416 index = bond_get_targets_ip6(targets, &addr_any); /* first free slot */ 1417 if (index == -1) { 1418 netdev_err(bond->dev, "NS target table is full!\n"); 1419 return -EINVAL; 1420 } 1421 1422 netdev_dbg(bond->dev, "Adding NS target %pI6c\n", target); 1423 1424 _bond_options_ns_ip6_target_set(bond, index, target, jiffies); 1425 1426 return 0; 1427} 1428#else 1429static int bond_option_ns_ip6_targets_set(struct bonding *bond, 1430 const struct bond_opt_value *newval) 1431{ 1432 return -EPERM; 1433} 1434 1435static void slave_set_ns_maddrs(struct bonding *bond, struct slave *slave, bool add) {} 1436 1437void bond_slave_ns_maddrs_add(struct bonding *bond, struct slave *slave) {} 1438 1439void bond_slave_ns_maddrs_del(struct bonding *bond, struct slave *slave) {} 1440#endif 1441 1442static int bond_option_arp_validate_set(struct bonding *bond, 1443 const struct bond_opt_value *newval) 1444{ 1445 bool changed = !!bond->params.arp_validate != !!newval->value; 1446 struct list_head *iter; 1447 struct slave *slave; 1448 1449 netdev_dbg(bond->dev, "Setting arp_validate to %s (%llu)\n", 1450 newval->string, newval->value); 1451 bond->params.arp_validate = newval->value; 1452 1453 if (changed) { 1454 bond_for_each_slave(bond, slave, iter) 1455 slave_set_ns_maddrs(bond, slave, !!bond->params.arp_validate); 1456 } 1457 1458 return 0; 1459} 1460 1461static int bond_option_arp_all_targets_set(struct bonding *bond, 1462 const struct bond_opt_value *newval) 1463{ 1464 netdev_dbg(bond->dev, "Setting arp_all_targets to %s (%llu)\n", 1465 newval->string, newval->value); 1466 bond->params.arp_all_targets = newval->value; 1467 1468 return 0; 1469} 1470 1471static int bond_option_missed_max_set(struct bonding *bond, 1472 const struct bond_opt_value *newval) 1473{ 1474 netdev_dbg(bond->dev, "Setting missed max to %s (%llu)\n", 1475 newval->string, newval->value); 1476 bond->params.missed_max = newval->value; 1477 1478 return 0; 1479} 1480 1481static int bond_option_prio_set(struct bonding *bond, 1482 const struct bond_opt_value *newval) 1483{ 1484 struct slave *slave; 1485 1486 slave = bond_slave_get_rtnl(newval->slave_dev); 1487 if (!slave) { 1488 netdev_dbg(newval->slave_dev, "%s called on NULL slave\n", __func__); 1489 return -ENODEV; 1490 } 1491 slave->prio = newval->value; 1492 1493 if (rtnl_dereference(bond->primary_slave)) 1494 slave_warn(bond->dev, slave->dev, 1495 "prio updated, but will not affect failover re-selection as primary slave have been set\n"); 1496 else 1497 bond_select_active_slave(bond); 1498 1499 return 0; 1500} 1501 1502static int bond_option_primary_set(struct bonding *bond, 1503 const struct bond_opt_value *newval) 1504{ 1505 char *p, *primary = newval->string; 1506 struct list_head *iter; 1507 struct slave *slave; 1508 1509 block_netpoll_tx(); 1510 1511 p = strchr(primary, '\n'); 1512 if (p) 1513 *p = '\0'; 1514 /* check to see if we are clearing primary */ 1515 if (!strlen(primary)) { 1516 netdev_dbg(bond->dev, "Setting primary slave to None\n"); 1517 RCU_INIT_POINTER(bond->primary_slave, NULL); 1518 memset(bond->params.primary, 0, sizeof(bond->params.primary)); 1519 bond_select_active_slave(bond); 1520 goto out; 1521 } 1522 1523 bond_for_each_slave(bond, slave, iter) { 1524 if (strncmp(slave->dev->name, primary, IFNAMSIZ) == 0) { 1525 slave_dbg(bond->dev, slave->dev, "Setting as primary slave\n"); 1526 rcu_assign_pointer(bond->primary_slave, slave); 1527 strcpy(bond->params.primary, slave->dev->name); 1528 bond->force_primary = true; 1529 bond_select_active_slave(bond); 1530 goto out; 1531 } 1532 } 1533 1534 if (rtnl_dereference(bond->primary_slave)) { 1535 netdev_dbg(bond->dev, "Setting primary slave to None\n"); 1536 RCU_INIT_POINTER(bond->primary_slave, NULL); 1537 bond_select_active_slave(bond); 1538 } 1539 strscpy_pad(bond->params.primary, primary, IFNAMSIZ); 1540 1541 netdev_dbg(bond->dev, "Recording %s as primary, but it has not been enslaved yet\n", 1542 primary); 1543 1544out: 1545 unblock_netpoll_tx(); 1546 1547 return 0; 1548} 1549 1550static int bond_option_primary_reselect_set(struct bonding *bond, 1551 const struct bond_opt_value *newval) 1552{ 1553 netdev_dbg(bond->dev, "Setting primary_reselect to %s (%llu)\n", 1554 newval->string, newval->value); 1555 bond->params.primary_reselect = newval->value; 1556 1557 block_netpoll_tx(); 1558 bond_select_active_slave(bond); 1559 unblock_netpoll_tx(); 1560 1561 return 0; 1562} 1563 1564static int bond_option_fail_over_mac_set(struct bonding *bond, 1565 const struct bond_opt_value *newval) 1566{ 1567 netdev_dbg(bond->dev, "Setting fail_over_mac to %s (%llu)\n", 1568 newval->string, newval->value); 1569 bond->params.fail_over_mac = newval->value; 1570 1571 return 0; 1572} 1573 1574static int bond_option_xmit_hash_policy_set(struct bonding *bond, 1575 const struct bond_opt_value *newval) 1576{ 1577 if (bond->xdp_prog && !__bond_xdp_check(BOND_MODE(bond), newval->value)) 1578 return -EOPNOTSUPP; 1579 netdev_dbg(bond->dev, "Setting xmit hash policy to %s (%llu)\n", 1580 newval->string, newval->value); 1581 bond->params.xmit_policy = newval->value; 1582 1583 return 0; 1584} 1585 1586static int bond_option_resend_igmp_set(struct bonding *bond, 1587 const struct bond_opt_value *newval) 1588{ 1589 netdev_dbg(bond->dev, "Setting resend_igmp to %llu\n", 1590 newval->value); 1591 bond->params.resend_igmp = newval->value; 1592 1593 return 0; 1594} 1595 1596static int bond_option_num_peer_notif_set(struct bonding *bond, 1597 const struct bond_opt_value *newval) 1598{ 1599 bond->params.num_peer_notif = newval->value; 1600 1601 return 0; 1602} 1603 1604static int bond_option_all_slaves_active_set(struct bonding *bond, 1605 const struct bond_opt_value *newval) 1606{ 1607 struct list_head *iter; 1608 struct slave *slave; 1609 1610 if (newval->value == bond->params.all_slaves_active) 1611 return 0; 1612 bond->params.all_slaves_active = newval->value; 1613 bond_for_each_slave(bond, slave, iter) { 1614 if (!bond_is_active_slave(slave)) { 1615 if (newval->value) 1616 slave->inactive = 0; 1617 else 1618 slave->inactive = 1; 1619 } 1620 } 1621 1622 return 0; 1623} 1624 1625static int bond_option_min_links_set(struct bonding *bond, 1626 const struct bond_opt_value *newval) 1627{ 1628 netdev_dbg(bond->dev, "Setting min links value to %llu\n", 1629 newval->value); 1630 bond->params.min_links = newval->value; 1631 bond_set_carrier(bond); 1632 1633 return 0; 1634} 1635 1636static int bond_option_lp_interval_set(struct bonding *bond, 1637 const struct bond_opt_value *newval) 1638{ 1639 bond->params.lp_interval = newval->value; 1640 1641 return 0; 1642} 1643 1644static int bond_option_pps_set(struct bonding *bond, 1645 const struct bond_opt_value *newval) 1646{ 1647 netdev_dbg(bond->dev, "Setting packets per slave to %llu\n", 1648 newval->value); 1649 bond->params.packets_per_slave = newval->value; 1650 if (newval->value > 0) { 1651 bond->params.reciprocal_packets_per_slave = 1652 reciprocal_value(newval->value); 1653 } else { 1654 /* reciprocal_packets_per_slave is unused if 1655 * packets_per_slave is 0 or 1, just initialize it 1656 */ 1657 bond->params.reciprocal_packets_per_slave = 1658 (struct reciprocal_value) { 0 }; 1659 } 1660 1661 return 0; 1662} 1663 1664static int bond_option_lacp_active_set(struct bonding *bond, 1665 const struct bond_opt_value *newval) 1666{ 1667 netdev_dbg(bond->dev, "Setting LACP active to %s (%llu)\n", 1668 newval->string, newval->value); 1669 bond->params.lacp_active = newval->value; 1670 bond_3ad_update_lacp_active(bond); 1671 1672 return 0; 1673} 1674 1675static int bond_option_lacp_rate_set(struct bonding *bond, 1676 const struct bond_opt_value *newval) 1677{ 1678 netdev_dbg(bond->dev, "Setting LACP rate to %s (%llu)\n", 1679 newval->string, newval->value); 1680 bond->params.lacp_fast = newval->value; 1681 bond_3ad_update_lacp_rate(bond); 1682 1683 return 0; 1684} 1685 1686static int bond_option_ad_select_set(struct bonding *bond, 1687 const struct bond_opt_value *newval) 1688{ 1689 netdev_dbg(bond->dev, "Setting ad_select to %s (%llu)\n", 1690 newval->string, newval->value); 1691 bond->params.ad_select = newval->value; 1692 1693 return 0; 1694} 1695 1696static int bond_option_queue_id_set(struct bonding *bond, 1697 const struct bond_opt_value *newval) 1698{ 1699 struct slave *slave, *update_slave; 1700 struct net_device *sdev; 1701 struct list_head *iter; 1702 char *delim; 1703 int ret = 0; 1704 u16 qid; 1705 1706 /* delim will point to queue id if successful */ 1707 delim = strchr(newval->string, ':'); 1708 if (!delim) 1709 goto err_no_cmd; 1710 1711 /* Terminate string that points to device name and bump it 1712 * up one, so we can read the queue id there. 1713 */ 1714 *delim = '\0'; 1715 if (sscanf(++delim, "%hd\n", &qid) != 1) 1716 goto err_no_cmd; 1717 1718 /* Check buffer length, valid ifname and queue id */ 1719 if (!dev_valid_name(newval->string) || 1720 qid > bond->dev->real_num_tx_queues) 1721 goto err_no_cmd; 1722 1723 /* Get the pointer to that interface if it exists */ 1724 sdev = __dev_get_by_name(dev_net(bond->dev), newval->string); 1725 if (!sdev) 1726 goto err_no_cmd; 1727 1728 /* Search for thes slave and check for duplicate qids */ 1729 update_slave = NULL; 1730 bond_for_each_slave(bond, slave, iter) { 1731 if (sdev == slave->dev) 1732 /* We don't need to check the matching 1733 * slave for dups, since we're overwriting it 1734 */ 1735 update_slave = slave; 1736 else if (qid && qid == slave->queue_id) { 1737 goto err_no_cmd; 1738 } 1739 } 1740 1741 if (!update_slave) 1742 goto err_no_cmd; 1743 1744 /* Actually set the qids for the slave */ 1745 WRITE_ONCE(update_slave->queue_id, qid); 1746 1747out: 1748 return ret; 1749 1750err_no_cmd: 1751 netdev_dbg(bond->dev, "invalid input for queue_id set\n"); 1752 ret = -EPERM; 1753 goto out; 1754 1755} 1756 1757static int bond_option_slaves_set(struct bonding *bond, 1758 const struct bond_opt_value *newval) 1759{ 1760 char command[IFNAMSIZ + 1] = { 0, }; 1761 struct net_device *dev; 1762 char *ifname; 1763 int ret; 1764 1765 sscanf(newval->string, "%16s", command); /* IFNAMSIZ*/ 1766 ifname = command + 1; 1767 if ((strlen(command) <= 1) || 1768 (command[0] != '+' && command[0] != '-') || 1769 !dev_valid_name(ifname)) 1770 goto err_no_cmd; 1771 1772 dev = __dev_get_by_name(dev_net(bond->dev), ifname); 1773 if (!dev) { 1774 netdev_dbg(bond->dev, "interface %s does not exist!\n", 1775 ifname); 1776 ret = -ENODEV; 1777 goto out; 1778 } 1779 1780 switch (command[0]) { 1781 case '+': 1782 slave_dbg(bond->dev, dev, "Enslaving interface\n"); 1783 ret = bond_enslave(bond->dev, dev, NULL); 1784 break; 1785 1786 case '-': 1787 slave_dbg(bond->dev, dev, "Releasing interface\n"); 1788 ret = bond_release(bond->dev, dev); 1789 break; 1790 1791 default: 1792 /* should not run here. */ 1793 goto err_no_cmd; 1794 } 1795 1796out: 1797 return ret; 1798 1799err_no_cmd: 1800 netdev_err(bond->dev, "no command found in slaves file - use +ifname or -ifname\n"); 1801 ret = -EPERM; 1802 goto out; 1803} 1804 1805static int bond_option_tlb_dynamic_lb_set(struct bonding *bond, 1806 const struct bond_opt_value *newval) 1807{ 1808 netdev_dbg(bond->dev, "Setting dynamic-lb to %s (%llu)\n", 1809 newval->string, newval->value); 1810 bond->params.tlb_dynamic_lb = newval->value; 1811 1812 return 0; 1813} 1814 1815static int bond_option_ad_actor_sys_prio_set(struct bonding *bond, 1816 const struct bond_opt_value *newval) 1817{ 1818 netdev_dbg(bond->dev, "Setting ad_actor_sys_prio to %llu\n", 1819 newval->value); 1820 1821 bond->params.ad_actor_sys_prio = newval->value; 1822 bond_3ad_update_ad_actor_settings(bond); 1823 1824 return 0; 1825} 1826 1827static int bond_option_actor_port_prio_set(struct bonding *bond, 1828 const struct bond_opt_value *newval) 1829{ 1830 struct slave *slave; 1831 1832 slave = bond_slave_get_rtnl(newval->slave_dev); 1833 if (!slave) { 1834 netdev_dbg(bond->dev, "%s called on NULL slave\n", __func__); 1835 return -ENODEV; 1836 } 1837 1838 netdev_dbg(newval->slave_dev, "Setting actor_port_prio to %llu\n", 1839 newval->value); 1840 1841 SLAVE_AD_INFO(slave)->port_priority = newval->value; 1842 bond_3ad_update_ad_actor_settings(bond); 1843 1844 return 0; 1845} 1846 1847static int bond_option_ad_actor_system_set(struct bonding *bond, 1848 const struct bond_opt_value *newval) 1849{ 1850 u8 macaddr[ETH_ALEN]; 1851 u8 *mac; 1852 1853 if (newval->string) { 1854 if (!mac_pton(newval->string, macaddr)) 1855 goto err; 1856 mac = macaddr; 1857 } else { 1858 mac = (u8 *)&newval->value; 1859 } 1860 1861 if (is_multicast_ether_addr(mac)) 1862 goto err; 1863 1864 netdev_dbg(bond->dev, "Setting ad_actor_system to %pM\n", mac); 1865 ether_addr_copy(bond->params.ad_actor_system, mac); 1866 bond_3ad_update_ad_actor_settings(bond); 1867 1868 return 0; 1869 1870err: 1871 netdev_err(bond->dev, "Invalid ad_actor_system MAC address.\n"); 1872 return -EINVAL; 1873} 1874 1875static int bond_option_ad_user_port_key_set(struct bonding *bond, 1876 const struct bond_opt_value *newval) 1877{ 1878 netdev_dbg(bond->dev, "Setting ad_user_port_key to %llu\n", 1879 newval->value); 1880 1881 bond->params.ad_user_port_key = newval->value; 1882 return 0; 1883} 1884 1885static int bond_option_coupled_control_set(struct bonding *bond, 1886 const struct bond_opt_value *newval) 1887{ 1888 netdev_info(bond->dev, "Setting coupled_control to %s (%llu)\n", 1889 newval->string, newval->value); 1890 1891 bond->params.coupled_control = newval->value; 1892 return 0; 1893} 1894 1895static int bond_option_broadcast_neigh_set(struct bonding *bond, 1896 const struct bond_opt_value *newval) 1897{ 1898 if (bond->params.broadcast_neighbor == newval->value) 1899 return 0; 1900 1901 bond->params.broadcast_neighbor = newval->value; 1902 if (bond->dev->flags & IFF_UP) { 1903 if (bond->params.broadcast_neighbor) 1904 static_branch_inc(&bond_bcast_neigh_enabled); 1905 else 1906 static_branch_dec(&bond_bcast_neigh_enabled); 1907 } 1908 1909 netdev_dbg(bond->dev, "Setting broadcast_neighbor to %s (%llu)\n", 1910 newval->string, newval->value); 1911 return 0; 1912}
~/
Read-only file preview.