Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * drivers/net/bond/bond_options.c - bonding options
0004  * Copyright (c) 2013 Jiri Pirko <jiri@resnulli.us>
0005  * Copyright (c) 2013 Scott Feldman <sfeldma@cumulusnetworks.com>
0006  */
0007 
0008 #include <linux/errno.h>
0009 #include <linux/if.h>
0010 #include <linux/netdevice.h>
0011 #include <linux/spinlock.h>
0012 #include <linux/rcupdate.h>
0013 #include <linux/ctype.h>
0014 #include <linux/inet.h>
0015 #include <linux/sched/signal.h>
0016 
0017 #include <net/bonding.h>
0018 
0019 static int bond_option_active_slave_set(struct bonding *bond,
0020                     const struct bond_opt_value *newval);
0021 static int bond_option_miimon_set(struct bonding *bond,
0022                   const struct bond_opt_value *newval);
0023 static int bond_option_updelay_set(struct bonding *bond,
0024                    const struct bond_opt_value *newval);
0025 static int bond_option_downdelay_set(struct bonding *bond,
0026                      const struct bond_opt_value *newval);
0027 static int bond_option_peer_notif_delay_set(struct bonding *bond,
0028                         const struct bond_opt_value *newval);
0029 static int bond_option_use_carrier_set(struct bonding *bond,
0030                        const struct bond_opt_value *newval);
0031 static int bond_option_arp_interval_set(struct bonding *bond,
0032                     const struct bond_opt_value *newval);
0033 static int bond_option_arp_ip_target_add(struct bonding *bond, __be32 target);
0034 static int bond_option_arp_ip_target_rem(struct bonding *bond, __be32 target);
0035 static int bond_option_arp_ip_targets_set(struct bonding *bond,
0036                       const struct bond_opt_value *newval);
0037 static int bond_option_ns_ip6_targets_set(struct bonding *bond,
0038                       const struct bond_opt_value *newval);
0039 static int bond_option_arp_validate_set(struct bonding *bond,
0040                     const struct bond_opt_value *newval);
0041 static int bond_option_arp_all_targets_set(struct bonding *bond,
0042                        const struct bond_opt_value *newval);
0043 static int bond_option_prio_set(struct bonding *bond,
0044                 const struct bond_opt_value *newval);
0045 static int bond_option_primary_set(struct bonding *bond,
0046                    const struct bond_opt_value *newval);
0047 static int bond_option_primary_reselect_set(struct bonding *bond,
0048                         const struct bond_opt_value *newval);
0049 static int bond_option_fail_over_mac_set(struct bonding *bond,
0050                      const struct bond_opt_value *newval);
0051 static int bond_option_xmit_hash_policy_set(struct bonding *bond,
0052                         const struct bond_opt_value *newval);
0053 static int bond_option_resend_igmp_set(struct bonding *bond,
0054                        const struct bond_opt_value *newval);
0055 static int bond_option_num_peer_notif_set(struct bonding *bond,
0056                       const struct bond_opt_value *newval);
0057 static int bond_option_all_slaves_active_set(struct bonding *bond,
0058                          const struct bond_opt_value *newval);
0059 static int bond_option_min_links_set(struct bonding *bond,
0060                      const struct bond_opt_value *newval);
0061 static int bond_option_lp_interval_set(struct bonding *bond,
0062                        const struct bond_opt_value *newval);
0063 static int bond_option_pps_set(struct bonding *bond,
0064                    const struct bond_opt_value *newval);
0065 static int bond_option_lacp_active_set(struct bonding *bond,
0066                        const struct bond_opt_value *newval);
0067 static int bond_option_lacp_rate_set(struct bonding *bond,
0068                      const struct bond_opt_value *newval);
0069 static int bond_option_ad_select_set(struct bonding *bond,
0070                      const struct bond_opt_value *newval);
0071 static int bond_option_queue_id_set(struct bonding *bond,
0072                     const struct bond_opt_value *newval);
0073 static int bond_option_mode_set(struct bonding *bond,
0074                 const struct bond_opt_value *newval);
0075 static int bond_option_slaves_set(struct bonding *bond,
0076                   const struct bond_opt_value *newval);
0077 static int bond_option_tlb_dynamic_lb_set(struct bonding *bond,
0078                   const struct bond_opt_value *newval);
0079 static int bond_option_ad_actor_sys_prio_set(struct bonding *bond,
0080                          const struct bond_opt_value *newval);
0081 static int bond_option_ad_actor_system_set(struct bonding *bond,
0082                        const struct bond_opt_value *newval);
0083 static int bond_option_ad_user_port_key_set(struct bonding *bond,
0084                         const struct bond_opt_value *newval);
0085 static int bond_option_missed_max_set(struct bonding *bond,
0086                       const struct bond_opt_value *newval);
0087 
0088 
0089 static const struct bond_opt_value bond_mode_tbl[] = {
0090     { "balance-rr",    BOND_MODE_ROUNDROBIN,   BOND_VALFLAG_DEFAULT},
0091     { "active-backup", BOND_MODE_ACTIVEBACKUP, 0},
0092     { "balance-xor",   BOND_MODE_XOR,          0},
0093     { "broadcast",     BOND_MODE_BROADCAST,    0},
0094     { "802.3ad",       BOND_MODE_8023AD,       0},
0095     { "balance-tlb",   BOND_MODE_TLB,          0},
0096     { "balance-alb",   BOND_MODE_ALB,          0},
0097     { NULL,            -1,                     0},
0098 };
0099 
0100 static const struct bond_opt_value bond_pps_tbl[] = {
0101     { "default", 1,         BOND_VALFLAG_DEFAULT},
0102     { "maxval",  USHRT_MAX, BOND_VALFLAG_MAX},
0103     { NULL,      -1,        0},
0104 };
0105 
0106 static const struct bond_opt_value bond_xmit_hashtype_tbl[] = {
0107     { "layer2",      BOND_XMIT_POLICY_LAYER2,      BOND_VALFLAG_DEFAULT},
0108     { "layer3+4",    BOND_XMIT_POLICY_LAYER34,     0},
0109     { "layer2+3",    BOND_XMIT_POLICY_LAYER23,     0},
0110     { "encap2+3",    BOND_XMIT_POLICY_ENCAP23,     0},
0111     { "encap3+4",    BOND_XMIT_POLICY_ENCAP34,     0},
0112     { "vlan+srcmac", BOND_XMIT_POLICY_VLAN_SRCMAC, 0},
0113     { NULL,          -1,                           0},
0114 };
0115 
0116 static const struct bond_opt_value bond_arp_validate_tbl[] = {
0117     { "none",       BOND_ARP_VALIDATE_NONE,     BOND_VALFLAG_DEFAULT},
0118     { "active",     BOND_ARP_VALIDATE_ACTIVE,   0},
0119     { "backup",     BOND_ARP_VALIDATE_BACKUP,   0},
0120     { "all",        BOND_ARP_VALIDATE_ALL,      0},
0121     { "filter",     BOND_ARP_FILTER,        0},
0122     { "filter_active",  BOND_ARP_FILTER_ACTIVE,     0},
0123     { "filter_backup",  BOND_ARP_FILTER_BACKUP,     0},
0124     { NULL,         -1,             0},
0125 };
0126 
0127 static const struct bond_opt_value bond_arp_all_targets_tbl[] = {
0128     { "any", BOND_ARP_TARGETS_ANY, BOND_VALFLAG_DEFAULT},
0129     { "all", BOND_ARP_TARGETS_ALL, 0},
0130     { NULL,  -1,                   0},
0131 };
0132 
0133 static const struct bond_opt_value bond_fail_over_mac_tbl[] = {
0134     { "none",   BOND_FOM_NONE,   BOND_VALFLAG_DEFAULT},
0135     { "active", BOND_FOM_ACTIVE, 0},
0136     { "follow", BOND_FOM_FOLLOW, 0},
0137     { NULL,     -1,              0},
0138 };
0139 
0140 static const struct bond_opt_value bond_intmax_tbl[] = {
0141     { "off",     0,       BOND_VALFLAG_DEFAULT},
0142     { "maxval",  INT_MAX, BOND_VALFLAG_MAX},
0143     { NULL,      -1,      0}
0144 };
0145 
0146 static const struct bond_opt_value bond_lacp_active[] = {
0147     { "off", 0,  0},
0148     { "on",  1,  BOND_VALFLAG_DEFAULT},
0149     { NULL,  -1, 0}
0150 };
0151 
0152 static const struct bond_opt_value bond_lacp_rate_tbl[] = {
0153     { "slow", AD_LACP_SLOW, 0},
0154     { "fast", AD_LACP_FAST, 0},
0155     { NULL,   -1,           0},
0156 };
0157 
0158 static const struct bond_opt_value bond_ad_select_tbl[] = {
0159     { "stable",    BOND_AD_STABLE,    BOND_VALFLAG_DEFAULT},
0160     { "bandwidth", BOND_AD_BANDWIDTH, 0},
0161     { "count",     BOND_AD_COUNT,     0},
0162     { NULL,        -1,                0},
0163 };
0164 
0165 static const struct bond_opt_value bond_num_peer_notif_tbl[] = {
0166     { "off",     0,   0},
0167     { "maxval",  255, BOND_VALFLAG_MAX},
0168     { "default", 1,   BOND_VALFLAG_DEFAULT},
0169     { NULL,      -1,  0}
0170 };
0171 
0172 static const struct bond_opt_value bond_primary_reselect_tbl[] = {
0173     { "always",  BOND_PRI_RESELECT_ALWAYS,  BOND_VALFLAG_DEFAULT},
0174     { "better",  BOND_PRI_RESELECT_BETTER,  0},
0175     { "failure", BOND_PRI_RESELECT_FAILURE, 0},
0176     { NULL,      -1},
0177 };
0178 
0179 static const struct bond_opt_value bond_use_carrier_tbl[] = {
0180     { "off", 0,  0},
0181     { "on",  1,  BOND_VALFLAG_DEFAULT},
0182     { NULL,  -1, 0}
0183 };
0184 
0185 static const struct bond_opt_value bond_all_slaves_active_tbl[] = {
0186     { "off", 0,  BOND_VALFLAG_DEFAULT},
0187     { "on",  1,  0},
0188     { NULL,  -1, 0}
0189 };
0190 
0191 static const struct bond_opt_value bond_resend_igmp_tbl[] = {
0192     { "off",     0,   0},
0193     { "maxval",  255, BOND_VALFLAG_MAX},
0194     { "default", 1,   BOND_VALFLAG_DEFAULT},
0195     { NULL,      -1,  0}
0196 };
0197 
0198 static const struct bond_opt_value bond_lp_interval_tbl[] = {
0199     { "minval",  1,       BOND_VALFLAG_MIN | BOND_VALFLAG_DEFAULT},
0200     { "maxval",  INT_MAX, BOND_VALFLAG_MAX},
0201     { NULL,      -1,      0},
0202 };
0203 
0204 static const struct bond_opt_value bond_tlb_dynamic_lb_tbl[] = {
0205     { "off", 0,  0},
0206     { "on",  1,  BOND_VALFLAG_DEFAULT},
0207     { NULL,  -1, 0}
0208 };
0209 
0210 static const struct bond_opt_value bond_ad_actor_sys_prio_tbl[] = {
0211     { "minval",  1,     BOND_VALFLAG_MIN},
0212     { "maxval",  65535, BOND_VALFLAG_MAX | BOND_VALFLAG_DEFAULT},
0213     { NULL,      -1,    0},
0214 };
0215 
0216 static const struct bond_opt_value bond_ad_user_port_key_tbl[] = {
0217     { "minval",  0,     BOND_VALFLAG_MIN | BOND_VALFLAG_DEFAULT},
0218     { "maxval",  1023,  BOND_VALFLAG_MAX},
0219     { NULL,      -1,    0},
0220 };
0221 
0222 static const struct bond_opt_value bond_missed_max_tbl[] = {
0223     { "minval", 1,  BOND_VALFLAG_MIN},
0224     { "maxval", 255,    BOND_VALFLAG_MAX},
0225     { "default",    2,  BOND_VALFLAG_DEFAULT},
0226     { NULL,     -1, 0},
0227 };
0228 
0229 static const struct bond_option bond_opts[BOND_OPT_LAST] = {
0230     [BOND_OPT_MODE] = {
0231         .id = BOND_OPT_MODE,
0232         .name = "mode",
0233         .desc = "bond device mode",
0234         .flags = BOND_OPTFLAG_NOSLAVES | BOND_OPTFLAG_IFDOWN,
0235         .values = bond_mode_tbl,
0236         .set = bond_option_mode_set
0237     },
0238     [BOND_OPT_PACKETS_PER_SLAVE] = {
0239         .id = BOND_OPT_PACKETS_PER_SLAVE,
0240         .name = "packets_per_slave",
0241         .desc = "Packets to send per slave in RR mode",
0242         .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_ROUNDROBIN)),
0243         .values = bond_pps_tbl,
0244         .set = bond_option_pps_set
0245     },
0246     [BOND_OPT_XMIT_HASH] = {
0247         .id = BOND_OPT_XMIT_HASH,
0248         .name = "xmit_hash_policy",
0249         .desc = "balance-xor, 802.3ad, and tlb hashing method",
0250         .values = bond_xmit_hashtype_tbl,
0251         .set = bond_option_xmit_hash_policy_set
0252     },
0253     [BOND_OPT_ARP_VALIDATE] = {
0254         .id = BOND_OPT_ARP_VALIDATE,
0255         .name = "arp_validate",
0256         .desc = "validate src/dst of ARP probes",
0257         .unsuppmodes = BIT(BOND_MODE_8023AD) | BIT(BOND_MODE_TLB) |
0258                    BIT(BOND_MODE_ALB),
0259         .values = bond_arp_validate_tbl,
0260         .set = bond_option_arp_validate_set
0261     },
0262     [BOND_OPT_ARP_ALL_TARGETS] = {
0263         .id = BOND_OPT_ARP_ALL_TARGETS,
0264         .name = "arp_all_targets",
0265         .desc = "fail on any/all arp targets timeout",
0266         .values = bond_arp_all_targets_tbl,
0267         .set = bond_option_arp_all_targets_set
0268     },
0269     [BOND_OPT_FAIL_OVER_MAC] = {
0270         .id = BOND_OPT_FAIL_OVER_MAC,
0271         .name = "fail_over_mac",
0272         .desc = "For active-backup, do not set all slaves to the same MAC",
0273         .flags = BOND_OPTFLAG_NOSLAVES,
0274         .values = bond_fail_over_mac_tbl,
0275         .set = bond_option_fail_over_mac_set
0276     },
0277     [BOND_OPT_ARP_INTERVAL] = {
0278         .id = BOND_OPT_ARP_INTERVAL,
0279         .name = "arp_interval",
0280         .desc = "arp interval in milliseconds",
0281         .unsuppmodes = BIT(BOND_MODE_8023AD) | BIT(BOND_MODE_TLB) |
0282                    BIT(BOND_MODE_ALB),
0283         .values = bond_intmax_tbl,
0284         .set = bond_option_arp_interval_set
0285     },
0286     [BOND_OPT_MISSED_MAX] = {
0287         .id = BOND_OPT_MISSED_MAX,
0288         .name = "arp_missed_max",
0289         .desc = "Maximum number of missed ARP interval",
0290         .unsuppmodes = BIT(BOND_MODE_8023AD) | BIT(BOND_MODE_TLB) |
0291                    BIT(BOND_MODE_ALB),
0292         .values = bond_missed_max_tbl,
0293         .set = bond_option_missed_max_set
0294     },
0295     [BOND_OPT_ARP_TARGETS] = {
0296         .id = BOND_OPT_ARP_TARGETS,
0297         .name = "arp_ip_target",
0298         .desc = "arp targets in n.n.n.n form",
0299         .flags = BOND_OPTFLAG_RAWVAL,
0300         .set = bond_option_arp_ip_targets_set
0301     },
0302     [BOND_OPT_NS_TARGETS] = {
0303         .id = BOND_OPT_NS_TARGETS,
0304         .name = "ns_ip6_target",
0305         .desc = "NS targets in ffff:ffff::ffff:ffff form",
0306         .flags = BOND_OPTFLAG_RAWVAL,
0307         .set = bond_option_ns_ip6_targets_set
0308     },
0309     [BOND_OPT_DOWNDELAY] = {
0310         .id = BOND_OPT_DOWNDELAY,
0311         .name = "downdelay",
0312         .desc = "Delay before considering link down, in milliseconds",
0313         .values = bond_intmax_tbl,
0314         .set = bond_option_downdelay_set
0315     },
0316     [BOND_OPT_UPDELAY] = {
0317         .id = BOND_OPT_UPDELAY,
0318         .name = "updelay",
0319         .desc = "Delay before considering link up, in milliseconds",
0320         .values = bond_intmax_tbl,
0321         .set = bond_option_updelay_set
0322     },
0323     [BOND_OPT_LACP_ACTIVE] = {
0324         .id = BOND_OPT_LACP_ACTIVE,
0325         .name = "lacp_active",
0326         .desc = "Send LACPDU frames with configured lacp rate or acts as speak when spoken to",
0327         .flags = BOND_OPTFLAG_IFDOWN,
0328         .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD)),
0329         .values = bond_lacp_active,
0330         .set = bond_option_lacp_active_set
0331     },
0332     [BOND_OPT_LACP_RATE] = {
0333         .id = BOND_OPT_LACP_RATE,
0334         .name = "lacp_rate",
0335         .desc = "LACPDU tx rate to request from 802.3ad partner",
0336         .flags = BOND_OPTFLAG_IFDOWN,
0337         .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD)),
0338         .values = bond_lacp_rate_tbl,
0339         .set = bond_option_lacp_rate_set
0340     },
0341     [BOND_OPT_MINLINKS] = {
0342         .id = BOND_OPT_MINLINKS,
0343         .name = "min_links",
0344         .desc = "Minimum number of available links before turning on carrier",
0345         .values = bond_intmax_tbl,
0346         .set = bond_option_min_links_set
0347     },
0348     [BOND_OPT_AD_SELECT] = {
0349         .id = BOND_OPT_AD_SELECT,
0350         .name = "ad_select",
0351         .desc = "803.ad aggregation selection logic",
0352         .flags = BOND_OPTFLAG_IFDOWN,
0353         .values = bond_ad_select_tbl,
0354         .set = bond_option_ad_select_set
0355     },
0356     [BOND_OPT_NUM_PEER_NOTIF] = {
0357         .id = BOND_OPT_NUM_PEER_NOTIF,
0358         .name = "num_unsol_na",
0359         .desc = "Number of peer notifications to send on failover event",
0360         .values = bond_num_peer_notif_tbl,
0361         .set = bond_option_num_peer_notif_set
0362     },
0363     [BOND_OPT_MIIMON] = {
0364         .id = BOND_OPT_MIIMON,
0365         .name = "miimon",
0366         .desc = "Link check interval in milliseconds",
0367         .values = bond_intmax_tbl,
0368         .set = bond_option_miimon_set
0369     },
0370     [BOND_OPT_PRIO] = {
0371         .id = BOND_OPT_PRIO,
0372         .name = "prio",
0373         .desc = "Link priority for failover re-selection",
0374         .flags = BOND_OPTFLAG_RAWVAL,
0375         .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_ACTIVEBACKUP) |
0376                         BIT(BOND_MODE_TLB) |
0377                         BIT(BOND_MODE_ALB)),
0378         .set = bond_option_prio_set
0379     },
0380     [BOND_OPT_PRIMARY] = {
0381         .id = BOND_OPT_PRIMARY,
0382         .name = "primary",
0383         .desc = "Primary network device to use",
0384         .flags = BOND_OPTFLAG_RAWVAL,
0385         .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_ACTIVEBACKUP) |
0386                         BIT(BOND_MODE_TLB) |
0387                         BIT(BOND_MODE_ALB)),
0388         .set = bond_option_primary_set
0389     },
0390     [BOND_OPT_PRIMARY_RESELECT] = {
0391         .id = BOND_OPT_PRIMARY_RESELECT,
0392         .name = "primary_reselect",
0393         .desc = "Reselect primary slave once it comes up",
0394         .values = bond_primary_reselect_tbl,
0395         .set = bond_option_primary_reselect_set
0396     },
0397     [BOND_OPT_USE_CARRIER] = {
0398         .id = BOND_OPT_USE_CARRIER,
0399         .name = "use_carrier",
0400         .desc = "Use netif_carrier_ok (vs MII ioctls) in miimon",
0401         .values = bond_use_carrier_tbl,
0402         .set = bond_option_use_carrier_set
0403     },
0404     [BOND_OPT_ACTIVE_SLAVE] = {
0405         .id = BOND_OPT_ACTIVE_SLAVE,
0406         .name = "active_slave",
0407         .desc = "Currently active slave",
0408         .flags = BOND_OPTFLAG_RAWVAL,
0409         .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_ACTIVEBACKUP) |
0410                         BIT(BOND_MODE_TLB) |
0411                         BIT(BOND_MODE_ALB)),
0412         .set = bond_option_active_slave_set
0413     },
0414     [BOND_OPT_QUEUE_ID] = {
0415         .id = BOND_OPT_QUEUE_ID,
0416         .name = "queue_id",
0417         .desc = "Set queue id of a slave",
0418         .flags = BOND_OPTFLAG_RAWVAL,
0419         .set = bond_option_queue_id_set
0420     },
0421     [BOND_OPT_ALL_SLAVES_ACTIVE] = {
0422         .id = BOND_OPT_ALL_SLAVES_ACTIVE,
0423         .name = "all_slaves_active",
0424         .desc = "Keep all frames received on an interface by setting active flag for all slaves",
0425         .values = bond_all_slaves_active_tbl,
0426         .set = bond_option_all_slaves_active_set
0427     },
0428     [BOND_OPT_RESEND_IGMP] = {
0429         .id = BOND_OPT_RESEND_IGMP,
0430         .name = "resend_igmp",
0431         .desc = "Number of IGMP membership reports to send on link failure",
0432         .values = bond_resend_igmp_tbl,
0433         .set = bond_option_resend_igmp_set
0434     },
0435     [BOND_OPT_LP_INTERVAL] = {
0436         .id = BOND_OPT_LP_INTERVAL,
0437         .name = "lp_interval",
0438         .desc = "The number of seconds between instances where the bonding driver sends learning packets to each slave's peer switch",
0439         .values = bond_lp_interval_tbl,
0440         .set = bond_option_lp_interval_set
0441     },
0442     [BOND_OPT_SLAVES] = {
0443         .id = BOND_OPT_SLAVES,
0444         .name = "slaves",
0445         .desc = "Slave membership management",
0446         .flags = BOND_OPTFLAG_RAWVAL,
0447         .set = bond_option_slaves_set
0448     },
0449     [BOND_OPT_TLB_DYNAMIC_LB] = {
0450         .id = BOND_OPT_TLB_DYNAMIC_LB,
0451         .name = "tlb_dynamic_lb",
0452         .desc = "Enable dynamic flow shuffling",
0453         .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_TLB) | BIT(BOND_MODE_ALB)),
0454         .values = bond_tlb_dynamic_lb_tbl,
0455         .flags = BOND_OPTFLAG_IFDOWN,
0456         .set = bond_option_tlb_dynamic_lb_set,
0457     },
0458     [BOND_OPT_AD_ACTOR_SYS_PRIO] = {
0459         .id = BOND_OPT_AD_ACTOR_SYS_PRIO,
0460         .name = "ad_actor_sys_prio",
0461         .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD)),
0462         .values = bond_ad_actor_sys_prio_tbl,
0463         .set = bond_option_ad_actor_sys_prio_set,
0464     },
0465     [BOND_OPT_AD_ACTOR_SYSTEM] = {
0466         .id = BOND_OPT_AD_ACTOR_SYSTEM,
0467         .name = "ad_actor_system",
0468         .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD)),
0469         .flags = BOND_OPTFLAG_RAWVAL,
0470         .set = bond_option_ad_actor_system_set,
0471     },
0472     [BOND_OPT_AD_USER_PORT_KEY] = {
0473         .id = BOND_OPT_AD_USER_PORT_KEY,
0474         .name = "ad_user_port_key",
0475         .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD)),
0476         .flags = BOND_OPTFLAG_IFDOWN,
0477         .values = bond_ad_user_port_key_tbl,
0478         .set = bond_option_ad_user_port_key_set,
0479     },
0480     [BOND_OPT_NUM_PEER_NOTIF_ALIAS] = {
0481         .id = BOND_OPT_NUM_PEER_NOTIF_ALIAS,
0482         .name = "num_grat_arp",
0483         .desc = "Number of peer notifications to send on failover event",
0484         .values = bond_num_peer_notif_tbl,
0485         .set = bond_option_num_peer_notif_set
0486     },
0487     [BOND_OPT_PEER_NOTIF_DELAY] = {
0488         .id = BOND_OPT_PEER_NOTIF_DELAY,
0489         .name = "peer_notif_delay",
0490         .desc = "Delay between each peer notification on failover event, in milliseconds",
0491         .values = bond_intmax_tbl,
0492         .set = bond_option_peer_notif_delay_set
0493     }
0494 };
0495 
0496 /* Searches for an option by name */
0497 const struct bond_option *bond_opt_get_by_name(const char *name)
0498 {
0499     const struct bond_option *opt;
0500     int option;
0501 
0502     for (option = 0; option < BOND_OPT_LAST; option++) {
0503         opt = bond_opt_get(option);
0504         if (opt && !strcmp(opt->name, name))
0505             return opt;
0506     }
0507 
0508     return NULL;
0509 }
0510 
0511 /* Searches for a value in opt's values[] table */
0512 const struct bond_opt_value *bond_opt_get_val(unsigned int option, u64 val)
0513 {
0514     const struct bond_option *opt;
0515     int i;
0516 
0517     opt = bond_opt_get(option);
0518     if (WARN_ON(!opt))
0519         return NULL;
0520     for (i = 0; opt->values && opt->values[i].string; i++)
0521         if (opt->values[i].value == val)
0522             return &opt->values[i];
0523 
0524     return NULL;
0525 }
0526 
0527 /* Searches for a value in opt's values[] table which matches the flagmask */
0528 static const struct bond_opt_value *bond_opt_get_flags(const struct bond_option *opt,
0529                                u32 flagmask)
0530 {
0531     int i;
0532 
0533     for (i = 0; opt->values && opt->values[i].string; i++)
0534         if (opt->values[i].flags & flagmask)
0535             return &opt->values[i];
0536 
0537     return NULL;
0538 }
0539 
0540 /* If maxval is missing then there's no range to check. In case minval is
0541  * missing then it's considered to be 0.
0542  */
0543 static bool bond_opt_check_range(const struct bond_option *opt, u64 val)
0544 {
0545     const struct bond_opt_value *minval, *maxval;
0546 
0547     minval = bond_opt_get_flags(opt, BOND_VALFLAG_MIN);
0548     maxval = bond_opt_get_flags(opt, BOND_VALFLAG_MAX);
0549     if (!maxval || (minval && val < minval->value) || val > maxval->value)
0550         return false;
0551 
0552     return true;
0553 }
0554 
0555 /**
0556  * bond_opt_parse - parse option value
0557  * @opt: the option to parse against
0558  * @val: value to parse
0559  *
0560  * This function tries to extract the value from @val and check if it's
0561  * a possible match for the option and returns NULL if a match isn't found,
0562  * or the struct_opt_value that matched. It also strips the new line from
0563  * @val->string if it's present.
0564  */
0565 const struct bond_opt_value *bond_opt_parse(const struct bond_option *opt,
0566                         struct bond_opt_value *val)
0567 {
0568     char *p, valstr[BOND_OPT_MAX_NAMELEN + 1] = { 0, };
0569     const struct bond_opt_value *tbl;
0570     const struct bond_opt_value *ret = NULL;
0571     bool checkval;
0572     int i, rv;
0573 
0574     /* No parsing if the option wants a raw val */
0575     if (opt->flags & BOND_OPTFLAG_RAWVAL)
0576         return val;
0577 
0578     tbl = opt->values;
0579     if (!tbl)
0580         goto out;
0581 
0582     /* ULLONG_MAX is used to bypass string processing */
0583     checkval = val->value != ULLONG_MAX;
0584     if (!checkval) {
0585         if (!val->string)
0586             goto out;
0587         p = strchr(val->string, '\n');
0588         if (p)
0589             *p = '\0';
0590         for (p = val->string; *p; p++)
0591             if (!(isdigit(*p) || isspace(*p)))
0592                 break;
0593         /* The following code extracts the string to match or the value
0594          * and sets checkval appropriately
0595          */
0596         if (*p) {
0597             rv = sscanf(val->string, "%32s", valstr);
0598         } else {
0599             rv = sscanf(val->string, "%llu", &val->value);
0600             checkval = true;
0601         }
0602         if (!rv)
0603             goto out;
0604     }
0605 
0606     for (i = 0; tbl[i].string; i++) {
0607         /* Check for exact match */
0608         if (checkval) {
0609             if (val->value == tbl[i].value)
0610                 ret = &tbl[i];
0611         } else {
0612             if (!strcmp(valstr, "default") &&
0613                 (tbl[i].flags & BOND_VALFLAG_DEFAULT))
0614                 ret = &tbl[i];
0615 
0616             if (!strcmp(valstr, tbl[i].string))
0617                 ret = &tbl[i];
0618         }
0619         /* Found an exact match */
0620         if (ret)
0621             goto out;
0622     }
0623     /* Possible range match */
0624     if (checkval && bond_opt_check_range(opt, val->value))
0625         ret = val;
0626 out:
0627     return ret;
0628 }
0629 
0630 /* Check opt's dependencies against bond mode and currently set options */
0631 static int bond_opt_check_deps(struct bonding *bond,
0632                    const struct bond_option *opt)
0633 {
0634     struct bond_params *params = &bond->params;
0635 
0636     if (test_bit(params->mode, &opt->unsuppmodes))
0637         return -EACCES;
0638     if ((opt->flags & BOND_OPTFLAG_NOSLAVES) && bond_has_slaves(bond))
0639         return -ENOTEMPTY;
0640     if ((opt->flags & BOND_OPTFLAG_IFDOWN) && (bond->dev->flags & IFF_UP))
0641         return -EBUSY;
0642 
0643     return 0;
0644 }
0645 
0646 static void bond_opt_dep_print(struct bonding *bond,
0647                    const struct bond_option *opt,
0648                    struct nlattr *bad_attr,
0649                    struct netlink_ext_ack *extack)
0650 {
0651     const struct bond_opt_value *modeval;
0652     struct bond_params *params;
0653 
0654     params = &bond->params;
0655     modeval = bond_opt_get_val(BOND_OPT_MODE, params->mode);
0656     if (test_bit(params->mode, &opt->unsuppmodes)) {
0657         netdev_err(bond->dev, "option %s: mode dependency failed, not supported in mode %s(%llu)\n",
0658                opt->name, modeval->string, modeval->value);
0659         NL_SET_ERR_MSG_ATTR(extack, bad_attr,
0660                     "option not supported in mode");
0661     }
0662 }
0663 
0664 static void bond_opt_error_interpret(struct bonding *bond,
0665                      const struct bond_option *opt,
0666                      int error, const struct bond_opt_value *val,
0667                      struct nlattr *bad_attr,
0668                      struct netlink_ext_ack *extack)
0669 {
0670     const struct bond_opt_value *minval, *maxval;
0671     char *p;
0672 
0673     switch (error) {
0674     case -EINVAL:
0675         NL_SET_ERR_MSG_ATTR(extack, bad_attr, "invalid option value");
0676         if (val) {
0677             if (val->string) {
0678                 /* sometimes RAWVAL opts may have new lines */
0679                 p = strchr(val->string, '\n');
0680                 if (p)
0681                     *p = '\0';
0682                 netdev_err(bond->dev, "option %s: invalid value (%s)\n",
0683                        opt->name, val->string);
0684             } else {
0685                 netdev_err(bond->dev, "option %s: invalid value (%llu)\n",
0686                        opt->name, val->value);
0687             }
0688         }
0689         minval = bond_opt_get_flags(opt, BOND_VALFLAG_MIN);
0690         maxval = bond_opt_get_flags(opt, BOND_VALFLAG_MAX);
0691         if (!maxval)
0692             break;
0693         netdev_err(bond->dev, "option %s: allowed values %llu - %llu\n",
0694                opt->name, minval ? minval->value : 0, maxval->value);
0695         break;
0696     case -EACCES:
0697         bond_opt_dep_print(bond, opt, bad_attr, extack);
0698         break;
0699     case -ENOTEMPTY:
0700         NL_SET_ERR_MSG_ATTR(extack, bad_attr,
0701                     "unable to set option because the bond device has slaves");
0702         netdev_err(bond->dev, "option %s: unable to set because the bond device has slaves\n",
0703                opt->name);
0704         break;
0705     case -EBUSY:
0706         NL_SET_ERR_MSG_ATTR(extack, bad_attr,
0707                     "unable to set option because the bond is up");
0708         netdev_err(bond->dev, "option %s: unable to set because the bond device is up\n",
0709                opt->name);
0710         break;
0711     case -ENODEV:
0712         if (val && val->string) {
0713             p = strchr(val->string, '\n');
0714             if (p)
0715                 *p = '\0';
0716             netdev_err(bond->dev, "option %s: interface %s does not exist!\n",
0717                    opt->name, val->string);
0718             NL_SET_ERR_MSG_ATTR(extack, bad_attr,
0719                         "interface does not exist");
0720         }
0721         break;
0722     default:
0723         break;
0724     }
0725 }
0726 
0727 /**
0728  * __bond_opt_set - set a bonding option
0729  * @bond: target bond device
0730  * @option: option to set
0731  * @val: value to set it to
0732  * @bad_attr: netlink attribue that caused the error
0733  * @extack: extended netlink error structure, used when an error message
0734  *          needs to be returned to the caller via netlink
0735  *
0736  * This function is used to change the bond's option value, it can be
0737  * used for both enabling/changing an option and for disabling it. RTNL lock
0738  * must be obtained before calling this function.
0739  */
0740 int __bond_opt_set(struct bonding *bond,
0741            unsigned int option, struct bond_opt_value *val,
0742            struct nlattr *bad_attr, struct netlink_ext_ack *extack)
0743 {
0744     const struct bond_opt_value *retval = NULL;
0745     const struct bond_option *opt;
0746     int ret = -ENOENT;
0747 
0748     ASSERT_RTNL();
0749 
0750     opt = bond_opt_get(option);
0751     if (WARN_ON(!val) || WARN_ON(!opt))
0752         goto out;
0753     ret = bond_opt_check_deps(bond, opt);
0754     if (ret)
0755         goto out;
0756     retval = bond_opt_parse(opt, val);
0757     if (!retval) {
0758         ret = -EINVAL;
0759         goto out;
0760     }
0761     ret = opt->set(bond, retval);
0762 out:
0763     if (ret)
0764         bond_opt_error_interpret(bond, opt, ret, val, bad_attr, extack);
0765 
0766     return ret;
0767 }
0768 /**
0769  * __bond_opt_set_notify - set a bonding option
0770  * @bond: target bond device
0771  * @option: option to set
0772  * @val: value to set it to
0773  *
0774  * This function is used to change the bond's option value and trigger
0775  * a notification to user sapce. It can be used for both enabling/changing
0776  * an option and for disabling it. RTNL lock must be obtained before calling
0777  * this function.
0778  */
0779 int __bond_opt_set_notify(struct bonding *bond,
0780               unsigned int option, struct bond_opt_value *val)
0781 {
0782     int ret;
0783 
0784     ASSERT_RTNL();
0785 
0786     ret = __bond_opt_set(bond, option, val, NULL, NULL);
0787 
0788     if (!ret && (bond->dev->reg_state == NETREG_REGISTERED))
0789         call_netdevice_notifiers(NETDEV_CHANGEINFODATA, bond->dev);
0790 
0791     return ret;
0792 }
0793 
0794 /**
0795  * bond_opt_tryset_rtnl - try to acquire rtnl and call __bond_opt_set
0796  * @bond: target bond device
0797  * @option: option to set
0798  * @buf: value to set it to
0799  *
0800  * This function tries to acquire RTNL without blocking and if successful
0801  * calls __bond_opt_set. It is mainly used for sysfs option manipulation.
0802  */
0803 int bond_opt_tryset_rtnl(struct bonding *bond, unsigned int option, char *buf)
0804 {
0805     struct bond_opt_value optval;
0806     int ret;
0807 
0808     if (!rtnl_trylock())
0809         return restart_syscall();
0810     bond_opt_initstr(&optval, buf);
0811     ret = __bond_opt_set_notify(bond, option, &optval);
0812     rtnl_unlock();
0813 
0814     return ret;
0815 }
0816 
0817 /**
0818  * bond_opt_get - get a pointer to an option
0819  * @option: option for which to return a pointer
0820  *
0821  * This function checks if option is valid and if so returns a pointer
0822  * to its entry in the bond_opts[] option array.
0823  */
0824 const struct bond_option *bond_opt_get(unsigned int option)
0825 {
0826     if (!BOND_OPT_VALID(option))
0827         return NULL;
0828 
0829     return &bond_opts[option];
0830 }
0831 
0832 static bool bond_set_xfrm_features(struct bonding *bond)
0833 {
0834     if (!IS_ENABLED(CONFIG_XFRM_OFFLOAD))
0835         return false;
0836 
0837     if (BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP)
0838         bond->dev->wanted_features |= BOND_XFRM_FEATURES;
0839     else
0840         bond->dev->wanted_features &= ~BOND_XFRM_FEATURES;
0841 
0842     return true;
0843 }
0844 
0845 static bool bond_set_tls_features(struct bonding *bond)
0846 {
0847     if (!IS_ENABLED(CONFIG_TLS_DEVICE))
0848         return false;
0849 
0850     if (bond_sk_check(bond))
0851         bond->dev->wanted_features |= BOND_TLS_FEATURES;
0852     else
0853         bond->dev->wanted_features &= ~BOND_TLS_FEATURES;
0854 
0855     return true;
0856 }
0857 
0858 static int bond_option_mode_set(struct bonding *bond,
0859                 const struct bond_opt_value *newval)
0860 {
0861     if (!bond_mode_uses_arp(newval->value)) {
0862         if (bond->params.arp_interval) {
0863             netdev_dbg(bond->dev, "%s mode is incompatible with arp monitoring, start mii monitoring\n",
0864                    newval->string);
0865             /* disable arp monitoring */
0866             bond->params.arp_interval = 0;
0867         }
0868 
0869         if (!bond->params.miimon) {
0870             /* set miimon to default value */
0871             bond->params.miimon = BOND_DEFAULT_MIIMON;
0872             netdev_dbg(bond->dev, "Setting MII monitoring interval to %d\n",
0873                    bond->params.miimon);
0874         }
0875     }
0876 
0877     if (newval->value == BOND_MODE_ALB)
0878         bond->params.tlb_dynamic_lb = 1;
0879 
0880     /* don't cache arp_validate between modes */
0881     bond->params.arp_validate = BOND_ARP_VALIDATE_NONE;
0882     bond->params.mode = newval->value;
0883 
0884     if (bond->dev->reg_state == NETREG_REGISTERED) {
0885         bool update = false;
0886 
0887         update |= bond_set_xfrm_features(bond);
0888         update |= bond_set_tls_features(bond);
0889 
0890         if (update)
0891             netdev_update_features(bond->dev);
0892     }
0893 
0894     return 0;
0895 }
0896 
0897 static int bond_option_active_slave_set(struct bonding *bond,
0898                     const struct bond_opt_value *newval)
0899 {
0900     char ifname[IFNAMSIZ] = { 0, };
0901     struct net_device *slave_dev;
0902     int ret = 0;
0903 
0904     sscanf(newval->string, "%15s", ifname); /* IFNAMSIZ */
0905     if (!strlen(ifname) || newval->string[0] == '\n') {
0906         slave_dev = NULL;
0907     } else {
0908         slave_dev = __dev_get_by_name(dev_net(bond->dev), ifname);
0909         if (!slave_dev)
0910             return -ENODEV;
0911     }
0912 
0913     if (slave_dev) {
0914         if (!netif_is_bond_slave(slave_dev)) {
0915             slave_err(bond->dev, slave_dev, "Device is not bonding slave\n");
0916             return -EINVAL;
0917         }
0918 
0919         if (bond->dev != netdev_master_upper_dev_get(slave_dev)) {
0920             slave_err(bond->dev, slave_dev, "Device is not our slave\n");
0921             return -EINVAL;
0922         }
0923     }
0924 
0925     block_netpoll_tx();
0926     /* check to see if we are clearing active */
0927     if (!slave_dev) {
0928         netdev_dbg(bond->dev, "Clearing current active slave\n");
0929         RCU_INIT_POINTER(bond->curr_active_slave, NULL);
0930         bond_select_active_slave(bond);
0931     } else {
0932         struct slave *old_active = rtnl_dereference(bond->curr_active_slave);
0933         struct slave *new_active = bond_slave_get_rtnl(slave_dev);
0934 
0935         BUG_ON(!new_active);
0936 
0937         if (new_active == old_active) {
0938             /* do nothing */
0939             slave_dbg(bond->dev, new_active->dev, "is already the current active slave\n");
0940         } else {
0941             if (old_active && (new_active->link == BOND_LINK_UP) &&
0942                 bond_slave_is_up(new_active)) {
0943                 slave_dbg(bond->dev, new_active->dev, "Setting as active slave\n");
0944                 bond_change_active_slave(bond, new_active);
0945             } else {
0946                 slave_err(bond->dev, new_active->dev, "Could not set as active slave; either %s is down or the link is down\n",
0947                       new_active->dev->name);
0948                 ret = -EINVAL;
0949             }
0950         }
0951     }
0952     unblock_netpoll_tx();
0953 
0954     return ret;
0955 }
0956 
0957 /* There are two tricky bits here.  First, if MII monitoring is activated, then
0958  * we must disable ARP monitoring.  Second, if the timer isn't running, we must
0959  * start it.
0960  */
0961 static int bond_option_miimon_set(struct bonding *bond,
0962                   const struct bond_opt_value *newval)
0963 {
0964     netdev_dbg(bond->dev, "Setting MII monitoring interval to %llu\n",
0965            newval->value);
0966     bond->params.miimon = newval->value;
0967     if (bond->params.updelay)
0968         netdev_dbg(bond->dev, "Note: Updating updelay (to %d) since it is a multiple of the miimon value\n",
0969                bond->params.updelay * bond->params.miimon);
0970     if (bond->params.downdelay)
0971         netdev_dbg(bond->dev, "Note: Updating downdelay (to %d) since it is a multiple of the miimon value\n",
0972                bond->params.downdelay * bond->params.miimon);
0973     if (bond->params.peer_notif_delay)
0974         netdev_dbg(bond->dev, "Note: Updating peer_notif_delay (to %d) since it is a multiple of the miimon value\n",
0975                bond->params.peer_notif_delay * bond->params.miimon);
0976     if (newval->value && bond->params.arp_interval) {
0977         netdev_dbg(bond->dev, "MII monitoring cannot be used with ARP monitoring - disabling ARP monitoring...\n");
0978         bond->params.arp_interval = 0;
0979         if (bond->params.arp_validate)
0980             bond->params.arp_validate = BOND_ARP_VALIDATE_NONE;
0981     }
0982     if (bond->dev->flags & IFF_UP) {
0983         /* If the interface is up, we may need to fire off
0984          * the MII timer. If the interface is down, the
0985          * timer will get fired off when the open function
0986          * is called.
0987          */
0988         if (!newval->value) {
0989             cancel_delayed_work_sync(&bond->mii_work);
0990         } else {
0991             cancel_delayed_work_sync(&bond->arp_work);
0992             queue_delayed_work(bond->wq, &bond->mii_work, 0);
0993         }
0994     }
0995 
0996     return 0;
0997 }
0998 
0999 /* Set up, down and peer notification delays. These must be multiples
1000  * of the MII monitoring value, and are stored internally as the
1001  * multiplier. Thus, we must translate to MS for the real world.
1002  */
1003 static int _bond_option_delay_set(struct bonding *bond,
1004                   const struct bond_opt_value *newval,
1005                   const char *name,
1006                   int *target)
1007 {
1008     int value = newval->value;
1009 
1010     if (!bond->params.miimon) {
1011         netdev_err(bond->dev, "Unable to set %s as MII monitoring is disabled\n",
1012                name);
1013         return -EPERM;
1014     }
1015     if ((value % bond->params.miimon) != 0) {
1016         netdev_warn(bond->dev,
1017                 "%s (%d) is not a multiple of miimon (%d), value rounded to %d ms\n",
1018                 name,
1019                 value, bond->params.miimon,
1020                 (value / bond->params.miimon) *
1021                 bond->params.miimon);
1022     }
1023     *target = value / bond->params.miimon;
1024     netdev_dbg(bond->dev, "Setting %s to %d\n",
1025            name,
1026            *target * bond->params.miimon);
1027 
1028     return 0;
1029 }
1030 
1031 static int bond_option_updelay_set(struct bonding *bond,
1032                    const struct bond_opt_value *newval)
1033 {
1034     return _bond_option_delay_set(bond, newval, "up delay",
1035                       &bond->params.updelay);
1036 }
1037 
1038 static int bond_option_downdelay_set(struct bonding *bond,
1039                      const struct bond_opt_value *newval)
1040 {
1041     return _bond_option_delay_set(bond, newval, "down delay",
1042                       &bond->params.downdelay);
1043 }
1044 
1045 static int bond_option_peer_notif_delay_set(struct bonding *bond,
1046                         const struct bond_opt_value *newval)
1047 {
1048     int ret = _bond_option_delay_set(bond, newval,
1049                      "peer notification delay",
1050                      &bond->params.peer_notif_delay);
1051     return ret;
1052 }
1053 
1054 static int bond_option_use_carrier_set(struct bonding *bond,
1055                        const struct bond_opt_value *newval)
1056 {
1057     netdev_dbg(bond->dev, "Setting use_carrier to %llu\n",
1058            newval->value);
1059     bond->params.use_carrier = newval->value;
1060 
1061     return 0;
1062 }
1063 
1064 /* There are two tricky bits here.  First, if ARP monitoring is activated, then
1065  * we must disable MII monitoring.  Second, if the ARP timer isn't running,
1066  * we must start it.
1067  */
1068 static int bond_option_arp_interval_set(struct bonding *bond,
1069                     const struct bond_opt_value *newval)
1070 {
1071     netdev_dbg(bond->dev, "Setting ARP monitoring interval to %llu\n",
1072            newval->value);
1073     bond->params.arp_interval = newval->value;
1074     if (newval->value) {
1075         if (bond->params.miimon) {
1076             netdev_dbg(bond->dev, "ARP monitoring cannot be used with MII monitoring. Disabling MII monitoring\n");
1077             bond->params.miimon = 0;
1078         }
1079         if (!bond->params.arp_targets[0])
1080             netdev_dbg(bond->dev, "ARP monitoring has been set up, but no ARP targets have been specified\n");
1081     }
1082     if (bond->dev->flags & IFF_UP) {
1083         /* If the interface is up, we may need to fire off
1084          * the ARP timer.  If the interface is down, the
1085          * timer will get fired off when the open function
1086          * is called.
1087          */
1088         if (!newval->value) {
1089             if (bond->params.arp_validate)
1090                 bond->recv_probe = NULL;
1091             cancel_delayed_work_sync(&bond->arp_work);
1092         } else {
1093             /* arp_validate can be set only in active-backup mode */
1094             bond->recv_probe = bond_rcv_validate;
1095             cancel_delayed_work_sync(&bond->mii_work);
1096             queue_delayed_work(bond->wq, &bond->arp_work, 0);
1097         }
1098     }
1099 
1100     return 0;
1101 }
1102 
1103 static void _bond_options_arp_ip_target_set(struct bonding *bond, int slot,
1104                         __be32 target,
1105                         unsigned long last_rx)
1106 {
1107     __be32 *targets = bond->params.arp_targets;
1108     struct list_head *iter;
1109     struct slave *slave;
1110 
1111     if (slot >= 0 && slot < BOND_MAX_ARP_TARGETS) {
1112         bond_for_each_slave(bond, slave, iter)
1113             slave->target_last_arp_rx[slot] = last_rx;
1114         targets[slot] = target;
1115     }
1116 }
1117 
1118 static int _bond_option_arp_ip_target_add(struct bonding *bond, __be32 target)
1119 {
1120     __be32 *targets = bond->params.arp_targets;
1121     int ind;
1122 
1123     if (!bond_is_ip_target_ok(target)) {
1124         netdev_err(bond->dev, "invalid ARP target %pI4 specified for addition\n",
1125                &target);
1126         return -EINVAL;
1127     }
1128 
1129     if (bond_get_targets_ip(targets, target) != -1) { /* dup */
1130         netdev_err(bond->dev, "ARP target %pI4 is already present\n",
1131                &target);
1132         return -EINVAL;
1133     }
1134 
1135     ind = bond_get_targets_ip(targets, 0); /* first free slot */
1136     if (ind == -1) {
1137         netdev_err(bond->dev, "ARP target table is full!\n");
1138         return -EINVAL;
1139     }
1140 
1141     netdev_dbg(bond->dev, "Adding ARP target %pI4\n", &target);
1142 
1143     _bond_options_arp_ip_target_set(bond, ind, target, jiffies);
1144 
1145     return 0;
1146 }
1147 
1148 static int bond_option_arp_ip_target_add(struct bonding *bond, __be32 target)
1149 {
1150     return _bond_option_arp_ip_target_add(bond, target);
1151 }
1152 
1153 static int bond_option_arp_ip_target_rem(struct bonding *bond, __be32 target)
1154 {
1155     __be32 *targets = bond->params.arp_targets;
1156     struct list_head *iter;
1157     struct slave *slave;
1158     unsigned long *targets_rx;
1159     int ind, i;
1160 
1161     if (!bond_is_ip_target_ok(target)) {
1162         netdev_err(bond->dev, "invalid ARP target %pI4 specified for removal\n",
1163                &target);
1164         return -EINVAL;
1165     }
1166 
1167     ind = bond_get_targets_ip(targets, target);
1168     if (ind == -1) {
1169         netdev_err(bond->dev, "unable to remove nonexistent ARP target %pI4\n",
1170                &target);
1171         return -EINVAL;
1172     }
1173 
1174     if (ind == 0 && !targets[1] && bond->params.arp_interval)
1175         netdev_warn(bond->dev, "Removing last arp target with arp_interval on\n");
1176 
1177     netdev_dbg(bond->dev, "Removing ARP target %pI4\n", &target);
1178 
1179     bond_for_each_slave(bond, slave, iter) {
1180         targets_rx = slave->target_last_arp_rx;
1181         for (i = ind; (i < BOND_MAX_ARP_TARGETS-1) && targets[i+1]; i++)
1182             targets_rx[i] = targets_rx[i+1];
1183         targets_rx[i] = 0;
1184     }
1185     for (i = ind; (i < BOND_MAX_ARP_TARGETS-1) && targets[i+1]; i++)
1186         targets[i] = targets[i+1];
1187     targets[i] = 0;
1188 
1189     return 0;
1190 }
1191 
1192 void bond_option_arp_ip_targets_clear(struct bonding *bond)
1193 {
1194     int i;
1195 
1196     for (i = 0; i < BOND_MAX_ARP_TARGETS; i++)
1197         _bond_options_arp_ip_target_set(bond, i, 0, 0);
1198 }
1199 
1200 static int bond_option_arp_ip_targets_set(struct bonding *bond,
1201                       const struct bond_opt_value *newval)
1202 {
1203     int ret = -EPERM;
1204     __be32 target;
1205 
1206     if (newval->string) {
1207         if (!in4_pton(newval->string+1, -1, (u8 *)&target, -1, NULL)) {
1208             netdev_err(bond->dev, "invalid ARP target %pI4 specified\n",
1209                    &target);
1210             return ret;
1211         }
1212         if (newval->string[0] == '+')
1213             ret = bond_option_arp_ip_target_add(bond, target);
1214         else if (newval->string[0] == '-')
1215             ret = bond_option_arp_ip_target_rem(bond, target);
1216         else
1217             netdev_err(bond->dev, "no command found in arp_ip_targets file - use +<addr> or -<addr>\n");
1218     } else {
1219         target = newval->value;
1220         ret = bond_option_arp_ip_target_add(bond, target);
1221     }
1222 
1223     return ret;
1224 }
1225 
1226 #if IS_ENABLED(CONFIG_IPV6)
1227 static void _bond_options_ns_ip6_target_set(struct bonding *bond, int slot,
1228                         struct in6_addr *target,
1229                         unsigned long last_rx)
1230 {
1231     struct in6_addr *targets = bond->params.ns_targets;
1232     struct list_head *iter;
1233     struct slave *slave;
1234 
1235     if (slot >= 0 && slot < BOND_MAX_NS_TARGETS) {
1236         bond_for_each_slave(bond, slave, iter)
1237             slave->target_last_arp_rx[slot] = last_rx;
1238         targets[slot] = *target;
1239     }
1240 }
1241 
1242 void bond_option_ns_ip6_targets_clear(struct bonding *bond)
1243 {
1244     struct in6_addr addr_any = in6addr_any;
1245     int i;
1246 
1247     for (i = 0; i < BOND_MAX_NS_TARGETS; i++)
1248         _bond_options_ns_ip6_target_set(bond, i, &addr_any, 0);
1249 }
1250 
1251 static int bond_option_ns_ip6_targets_set(struct bonding *bond,
1252                       const struct bond_opt_value *newval)
1253 {
1254     struct in6_addr *target = (struct in6_addr *)newval->extra;
1255     struct in6_addr *targets = bond->params.ns_targets;
1256     struct in6_addr addr_any = in6addr_any;
1257     int index;
1258 
1259     if (!bond_is_ip6_target_ok(target)) {
1260         netdev_err(bond->dev, "invalid NS target %pI6c specified for addition\n",
1261                target);
1262         return -EINVAL;
1263     }
1264 
1265     if (bond_get_targets_ip6(targets, target) != -1) { /* dup */
1266         netdev_err(bond->dev, "NS target %pI6c is already present\n",
1267                target);
1268         return -EINVAL;
1269     }
1270 
1271     index = bond_get_targets_ip6(targets, &addr_any); /* first free slot */
1272     if (index == -1) {
1273         netdev_err(bond->dev, "NS target table is full!\n");
1274         return -EINVAL;
1275     }
1276 
1277     netdev_dbg(bond->dev, "Adding NS target %pI6c\n", target);
1278 
1279     _bond_options_ns_ip6_target_set(bond, index, target, jiffies);
1280 
1281     return 0;
1282 }
1283 #else
1284 static int bond_option_ns_ip6_targets_set(struct bonding *bond,
1285                       const struct bond_opt_value *newval)
1286 {
1287     return -EPERM;
1288 }
1289 #endif
1290 
1291 static int bond_option_arp_validate_set(struct bonding *bond,
1292                     const struct bond_opt_value *newval)
1293 {
1294     netdev_dbg(bond->dev, "Setting arp_validate to %s (%llu)\n",
1295            newval->string, newval->value);
1296     bond->params.arp_validate = newval->value;
1297 
1298     return 0;
1299 }
1300 
1301 static int bond_option_arp_all_targets_set(struct bonding *bond,
1302                        const struct bond_opt_value *newval)
1303 {
1304     netdev_dbg(bond->dev, "Setting arp_all_targets to %s (%llu)\n",
1305            newval->string, newval->value);
1306     bond->params.arp_all_targets = newval->value;
1307 
1308     return 0;
1309 }
1310 
1311 static int bond_option_missed_max_set(struct bonding *bond,
1312                       const struct bond_opt_value *newval)
1313 {
1314     netdev_dbg(bond->dev, "Setting missed max to %s (%llu)\n",
1315            newval->string, newval->value);
1316     bond->params.missed_max = newval->value;
1317 
1318     return 0;
1319 }
1320 
1321 static int bond_option_prio_set(struct bonding *bond,
1322                 const struct bond_opt_value *newval)
1323 {
1324     struct slave *slave;
1325 
1326     slave = bond_slave_get_rtnl(newval->slave_dev);
1327     if (!slave) {
1328         netdev_dbg(newval->slave_dev, "%s called on NULL slave\n", __func__);
1329         return -ENODEV;
1330     }
1331     slave->prio = newval->value;
1332 
1333     if (rtnl_dereference(bond->primary_slave))
1334         slave_warn(bond->dev, slave->dev,
1335                "prio updated, but will not affect failover re-selection as primary slave have been set\n");
1336     else
1337         bond_select_active_slave(bond);
1338 
1339     return 0;
1340 }
1341 
1342 static int bond_option_primary_set(struct bonding *bond,
1343                    const struct bond_opt_value *newval)
1344 {
1345     char *p, *primary = newval->string;
1346     struct list_head *iter;
1347     struct slave *slave;
1348 
1349     block_netpoll_tx();
1350 
1351     p = strchr(primary, '\n');
1352     if (p)
1353         *p = '\0';
1354     /* check to see if we are clearing primary */
1355     if (!strlen(primary)) {
1356         netdev_dbg(bond->dev, "Setting primary slave to None\n");
1357         RCU_INIT_POINTER(bond->primary_slave, NULL);
1358         memset(bond->params.primary, 0, sizeof(bond->params.primary));
1359         bond_select_active_slave(bond);
1360         goto out;
1361     }
1362 
1363     bond_for_each_slave(bond, slave, iter) {
1364         if (strncmp(slave->dev->name, primary, IFNAMSIZ) == 0) {
1365             slave_dbg(bond->dev, slave->dev, "Setting as primary slave\n");
1366             rcu_assign_pointer(bond->primary_slave, slave);
1367             strcpy(bond->params.primary, slave->dev->name);
1368             bond->force_primary = true;
1369             bond_select_active_slave(bond);
1370             goto out;
1371         }
1372     }
1373 
1374     if (rtnl_dereference(bond->primary_slave)) {
1375         netdev_dbg(bond->dev, "Setting primary slave to None\n");
1376         RCU_INIT_POINTER(bond->primary_slave, NULL);
1377         bond_select_active_slave(bond);
1378     }
1379     strscpy_pad(bond->params.primary, primary, IFNAMSIZ);
1380 
1381     netdev_dbg(bond->dev, "Recording %s as primary, but it has not been enslaved yet\n",
1382            primary);
1383 
1384 out:
1385     unblock_netpoll_tx();
1386 
1387     return 0;
1388 }
1389 
1390 static int bond_option_primary_reselect_set(struct bonding *bond,
1391                         const struct bond_opt_value *newval)
1392 {
1393     netdev_dbg(bond->dev, "Setting primary_reselect to %s (%llu)\n",
1394            newval->string, newval->value);
1395     bond->params.primary_reselect = newval->value;
1396 
1397     block_netpoll_tx();
1398     bond_select_active_slave(bond);
1399     unblock_netpoll_tx();
1400 
1401     return 0;
1402 }
1403 
1404 static int bond_option_fail_over_mac_set(struct bonding *bond,
1405                      const struct bond_opt_value *newval)
1406 {
1407     netdev_dbg(bond->dev, "Setting fail_over_mac to %s (%llu)\n",
1408            newval->string, newval->value);
1409     bond->params.fail_over_mac = newval->value;
1410 
1411     return 0;
1412 }
1413 
1414 static int bond_option_xmit_hash_policy_set(struct bonding *bond,
1415                         const struct bond_opt_value *newval)
1416 {
1417     netdev_dbg(bond->dev, "Setting xmit hash policy to %s (%llu)\n",
1418            newval->string, newval->value);
1419     bond->params.xmit_policy = newval->value;
1420 
1421     if (bond->dev->reg_state == NETREG_REGISTERED)
1422         if (bond_set_tls_features(bond))
1423             netdev_update_features(bond->dev);
1424 
1425     return 0;
1426 }
1427 
1428 static int bond_option_resend_igmp_set(struct bonding *bond,
1429                        const struct bond_opt_value *newval)
1430 {
1431     netdev_dbg(bond->dev, "Setting resend_igmp to %llu\n",
1432            newval->value);
1433     bond->params.resend_igmp = newval->value;
1434 
1435     return 0;
1436 }
1437 
1438 static int bond_option_num_peer_notif_set(struct bonding *bond,
1439                    const struct bond_opt_value *newval)
1440 {
1441     bond->params.num_peer_notif = newval->value;
1442 
1443     return 0;
1444 }
1445 
1446 static int bond_option_all_slaves_active_set(struct bonding *bond,
1447                          const struct bond_opt_value *newval)
1448 {
1449     struct list_head *iter;
1450     struct slave *slave;
1451 
1452     if (newval->value == bond->params.all_slaves_active)
1453         return 0;
1454     bond->params.all_slaves_active = newval->value;
1455     bond_for_each_slave(bond, slave, iter) {
1456         if (!bond_is_active_slave(slave)) {
1457             if (newval->value)
1458                 slave->inactive = 0;
1459             else
1460                 slave->inactive = 1;
1461         }
1462     }
1463 
1464     return 0;
1465 }
1466 
1467 static int bond_option_min_links_set(struct bonding *bond,
1468                      const struct bond_opt_value *newval)
1469 {
1470     netdev_dbg(bond->dev, "Setting min links value to %llu\n",
1471            newval->value);
1472     bond->params.min_links = newval->value;
1473     bond_set_carrier(bond);
1474 
1475     return 0;
1476 }
1477 
1478 static int bond_option_lp_interval_set(struct bonding *bond,
1479                        const struct bond_opt_value *newval)
1480 {
1481     bond->params.lp_interval = newval->value;
1482 
1483     return 0;
1484 }
1485 
1486 static int bond_option_pps_set(struct bonding *bond,
1487                    const struct bond_opt_value *newval)
1488 {
1489     netdev_dbg(bond->dev, "Setting packets per slave to %llu\n",
1490            newval->value);
1491     bond->params.packets_per_slave = newval->value;
1492     if (newval->value > 0) {
1493         bond->params.reciprocal_packets_per_slave =
1494             reciprocal_value(newval->value);
1495     } else {
1496         /* reciprocal_packets_per_slave is unused if
1497          * packets_per_slave is 0 or 1, just initialize it
1498          */
1499         bond->params.reciprocal_packets_per_slave =
1500             (struct reciprocal_value) { 0 };
1501     }
1502 
1503     return 0;
1504 }
1505 
1506 static int bond_option_lacp_active_set(struct bonding *bond,
1507                        const struct bond_opt_value *newval)
1508 {
1509     netdev_dbg(bond->dev, "Setting LACP active to %s (%llu)\n",
1510            newval->string, newval->value);
1511     bond->params.lacp_active = newval->value;
1512 
1513     return 0;
1514 }
1515 
1516 static int bond_option_lacp_rate_set(struct bonding *bond,
1517                      const struct bond_opt_value *newval)
1518 {
1519     netdev_dbg(bond->dev, "Setting LACP rate to %s (%llu)\n",
1520            newval->string, newval->value);
1521     bond->params.lacp_fast = newval->value;
1522     bond_3ad_update_lacp_rate(bond);
1523 
1524     return 0;
1525 }
1526 
1527 static int bond_option_ad_select_set(struct bonding *bond,
1528                      const struct bond_opt_value *newval)
1529 {
1530     netdev_dbg(bond->dev, "Setting ad_select to %s (%llu)\n",
1531            newval->string, newval->value);
1532     bond->params.ad_select = newval->value;
1533 
1534     return 0;
1535 }
1536 
1537 static int bond_option_queue_id_set(struct bonding *bond,
1538                     const struct bond_opt_value *newval)
1539 {
1540     struct slave *slave, *update_slave;
1541     struct net_device *sdev;
1542     struct list_head *iter;
1543     char *delim;
1544     int ret = 0;
1545     u16 qid;
1546 
1547     /* delim will point to queue id if successful */
1548     delim = strchr(newval->string, ':');
1549     if (!delim)
1550         goto err_no_cmd;
1551 
1552     /* Terminate string that points to device name and bump it
1553      * up one, so we can read the queue id there.
1554      */
1555     *delim = '\0';
1556     if (sscanf(++delim, "%hd\n", &qid) != 1)
1557         goto err_no_cmd;
1558 
1559     /* Check buffer length, valid ifname and queue id */
1560     if (!dev_valid_name(newval->string) ||
1561         qid > bond->dev->real_num_tx_queues)
1562         goto err_no_cmd;
1563 
1564     /* Get the pointer to that interface if it exists */
1565     sdev = __dev_get_by_name(dev_net(bond->dev), newval->string);
1566     if (!sdev)
1567         goto err_no_cmd;
1568 
1569     /* Search for thes slave and check for duplicate qids */
1570     update_slave = NULL;
1571     bond_for_each_slave(bond, slave, iter) {
1572         if (sdev == slave->dev)
1573             /* We don't need to check the matching
1574              * slave for dups, since we're overwriting it
1575              */
1576             update_slave = slave;
1577         else if (qid && qid == slave->queue_id) {
1578             goto err_no_cmd;
1579         }
1580     }
1581 
1582     if (!update_slave)
1583         goto err_no_cmd;
1584 
1585     /* Actually set the qids for the slave */
1586     update_slave->queue_id = qid;
1587 
1588 out:
1589     return ret;
1590 
1591 err_no_cmd:
1592     netdev_dbg(bond->dev, "invalid input for queue_id set\n");
1593     ret = -EPERM;
1594     goto out;
1595 
1596 }
1597 
1598 static int bond_option_slaves_set(struct bonding *bond,
1599                   const struct bond_opt_value *newval)
1600 {
1601     char command[IFNAMSIZ + 1] = { 0, };
1602     struct net_device *dev;
1603     char *ifname;
1604     int ret;
1605 
1606     sscanf(newval->string, "%16s", command); /* IFNAMSIZ*/
1607     ifname = command + 1;
1608     if ((strlen(command) <= 1) ||
1609         (command[0] != '+' && command[0] != '-') ||
1610         !dev_valid_name(ifname))
1611         goto err_no_cmd;
1612 
1613     dev = __dev_get_by_name(dev_net(bond->dev), ifname);
1614     if (!dev) {
1615         netdev_dbg(bond->dev, "interface %s does not exist!\n",
1616                ifname);
1617         ret = -ENODEV;
1618         goto out;
1619     }
1620 
1621     switch (command[0]) {
1622     case '+':
1623         slave_dbg(bond->dev, dev, "Enslaving interface\n");
1624         ret = bond_enslave(bond->dev, dev, NULL);
1625         break;
1626 
1627     case '-':
1628         slave_dbg(bond->dev, dev, "Releasing interface\n");
1629         ret = bond_release(bond->dev, dev);
1630         break;
1631 
1632     default:
1633         /* should not run here. */
1634         goto err_no_cmd;
1635     }
1636 
1637 out:
1638     return ret;
1639 
1640 err_no_cmd:
1641     netdev_err(bond->dev, "no command found in slaves file - use +ifname or -ifname\n");
1642     ret = -EPERM;
1643     goto out;
1644 }
1645 
1646 static int bond_option_tlb_dynamic_lb_set(struct bonding *bond,
1647                       const struct bond_opt_value *newval)
1648 {
1649     netdev_dbg(bond->dev, "Setting dynamic-lb to %s (%llu)\n",
1650            newval->string, newval->value);
1651     bond->params.tlb_dynamic_lb = newval->value;
1652 
1653     return 0;
1654 }
1655 
1656 static int bond_option_ad_actor_sys_prio_set(struct bonding *bond,
1657                          const struct bond_opt_value *newval)
1658 {
1659     netdev_dbg(bond->dev, "Setting ad_actor_sys_prio to %llu\n",
1660            newval->value);
1661 
1662     bond->params.ad_actor_sys_prio = newval->value;
1663     bond_3ad_update_ad_actor_settings(bond);
1664 
1665     return 0;
1666 }
1667 
1668 static int bond_option_ad_actor_system_set(struct bonding *bond,
1669                        const struct bond_opt_value *newval)
1670 {
1671     u8 macaddr[ETH_ALEN];
1672     u8 *mac;
1673 
1674     if (newval->string) {
1675         if (!mac_pton(newval->string, macaddr))
1676             goto err;
1677         mac = macaddr;
1678     } else {
1679         mac = (u8 *)&newval->value;
1680     }
1681 
1682     if (is_multicast_ether_addr(mac))
1683         goto err;
1684 
1685     netdev_dbg(bond->dev, "Setting ad_actor_system to %pM\n", mac);
1686     ether_addr_copy(bond->params.ad_actor_system, mac);
1687     bond_3ad_update_ad_actor_settings(bond);
1688 
1689     return 0;
1690 
1691 err:
1692     netdev_err(bond->dev, "Invalid ad_actor_system MAC address.\n");
1693     return -EINVAL;
1694 }
1695 
1696 static int bond_option_ad_user_port_key_set(struct bonding *bond,
1697                         const struct bond_opt_value *newval)
1698 {
1699     netdev_dbg(bond->dev, "Setting ad_user_port_key to %llu\n",
1700            newval->value);
1701 
1702     bond->params.ad_user_port_key = newval->value;
1703     return 0;
1704 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!