tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

net: use eth_hw_addr_random() and reset addr_assign_type

Use eth_hw_addr_random() instead of calling random_ether_addr()
to set addr_assign_type correctly to NET_ADDR_RANDOM.

Reset the state to NET_ADDR_PERM as soon as the MAC get
changed via .ndo_set_mac_address.

v2: adapt to renamed eth_hw_addr_random()

Signed-off-by: Danny Kukawka <danny.kukawka@bisect.de>
Signed-off-by: David S. Miller <davem@davemloft.net>

authored by

Danny Kukawka and committed by
David S. Miller 7ce5d222 f2cedb63

+29 -14
+2 -1
drivers/net/dummy.c
··· 47 47 if (!is_valid_ether_addr(sa->sa_data)) 48 48 return -EADDRNOTAVAIL; 49 49 50 + dev->addr_assign_type &= ~NET_ADDR_RANDOM; 50 51 memcpy(dev->dev_addr, sa->sa_data, ETH_ALEN); 51 52 return 0; 52 53 } ··· 136 135 dev->flags &= ~IFF_MULTICAST; 137 136 dev->features |= NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_TSO; 138 137 dev->features |= NETIF_F_HW_CSUM | NETIF_F_HIGHDMA | NETIF_F_LLTX; 139 - random_ether_addr(dev->dev_addr); 138 + eth_hw_addr_random(dev); 140 139 } 141 140 142 141 static int dummy_validate(struct nlattr *tb[], struct nlattr *data[])
+1
drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
··· 3007 3007 return rc; 3008 3008 } 3009 3009 3010 + dev->addr_assign_type &= ~NET_ADDR_RANDOM; 3010 3011 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len); 3011 3012 3012 3013 if (netif_running(dev))
+1 -1
drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
··· 9683 9683 9684 9684 if (BP_NOMCP(bp)) { 9685 9685 BNX2X_ERROR("warning: random MAC workaround active\n"); 9686 - random_ether_addr(bp->dev->dev_addr); 9686 + eth_hw_addr_random(bp->dev); 9687 9687 } else if (IS_MF(bp)) { 9688 9688 val2 = MF_CFG_RD(bp, func_mf_config[func].mac_upper); 9689 9689 val = MF_CFG_RD(bp, func_mf_config[func].mac_lower);
+2 -1
drivers/net/ethernet/calxeda/xgmac.c
··· 1012 1012 * address using the following linux command: 1013 1013 * ifconfig eth0 hw ether xx:xx:xx:xx:xx:xx */ 1014 1014 if (!is_valid_ether_addr(dev->dev_addr)) { 1015 - random_ether_addr(dev->dev_addr); 1015 + eth_hw_addr_random(dev); 1016 1016 netdev_dbg(priv->dev, "generated random MAC address %pM\n", 1017 1017 dev->dev_addr); 1018 1018 } ··· 1482 1482 if (!is_valid_ether_addr(addr->sa_data)) 1483 1483 return -EADDRNOTAVAIL; 1484 1484 1485 + dev->addr_assign_type &= ~NET_ADDR_RANDOM; 1485 1486 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len); 1486 1487 1487 1488 xgmac_set_mac_addr(ioaddr, dev->dev_addr, 0);
+2 -1
drivers/net/ethernet/marvell/pxa168_eth.c
··· 629 629 if (!is_valid_ether_addr(sa->sa_data)) 630 630 return -EINVAL; 631 631 memcpy(oldMac, dev->dev_addr, ETH_ALEN); 632 + dev->addr_assign_type &= ~NET_ADDR_RANDOM; 632 633 memcpy(dev->dev_addr, sa->sa_data, ETH_ALEN); 633 634 netif_addr_lock_bh(dev); 634 635 update_hash_table_mac_address(pep, oldMac, dev->dev_addr); ··· 1521 1520 INIT_WORK(&pep->tx_timeout_task, pxa168_eth_tx_timeout_task); 1522 1521 1523 1522 printk(KERN_INFO "%s:Using random mac address\n", DRIVER_NAME); 1524 - random_ether_addr(dev->dev_addr); 1523 + eth_hw_addr_random(dev); 1525 1524 1526 1525 pep->pd = pdev->dev.platform_data; 1527 1526 pep->rx_ring_size = NUM_RX_DESCS;
+2 -1
drivers/net/ethernet/micrel/ks8842.c
··· 1080 1080 if (!is_valid_ether_addr(addr->sa_data)) 1081 1081 return -EADDRNOTAVAIL; 1082 1082 1083 + netdev->addr_assign_type &= ~NET_ADDR_RANDOM; 1083 1084 memcpy(netdev->dev_addr, mac, netdev->addr_len); 1084 1085 1085 1086 ks8842_write_mac_addr(adapter, mac); ··· 1212 1211 ks8842_read_mac_addr(adapter, netdev->dev_addr); 1213 1212 1214 1213 if (!is_valid_ether_addr(netdev->dev_addr)) 1215 - random_ether_addr(netdev->dev_addr); 1214 + eth_hw_addr_random(netdev); 1216 1215 } 1217 1216 1218 1217 id = ks8842_read16(adapter, 32, REG_SW_ID_AND_ENABLE);
+2 -1
drivers/net/ethernet/micrel/ks8851.c
··· 439 439 dev->dev_addr); 440 440 } 441 441 442 - random_ether_addr(dev->dev_addr); 442 + eth_hw_addr_random(dev); 443 443 ks8851_write_mac_addr(dev); 444 444 } 445 445 ··· 1050 1050 if (!is_valid_ether_addr(sa->sa_data)) 1051 1051 return -EADDRNOTAVAIL; 1052 1052 1053 + dev->addr_assign_type &= ~NET_ADDR_RANDOM; 1053 1054 memcpy(dev->dev_addr, sa->sa_data, ETH_ALEN); 1054 1055 return ks8851_write_mac_addr(dev); 1055 1056 }
+1
drivers/net/ethernet/micrel/ks8851_mll.c
··· 1241 1241 struct sockaddr *addr = paddr; 1242 1242 u8 *da; 1243 1243 1244 + netdev->addr_assign_type &= ~NET_ADDR_RANDOM; 1244 1245 memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len); 1245 1246 1246 1247 da = (u8 *)netdev->dev_addr;
+2 -1
drivers/net/ethernet/microchip/enc28j60.c
··· 527 527 if (!is_valid_ether_addr(address->sa_data)) 528 528 return -EADDRNOTAVAIL; 529 529 530 + dev->addr_assign_type &= ~NET_ADDR_RANDOM; 530 531 memcpy(dev->dev_addr, address->sa_data, dev->addr_len); 531 532 return enc28j60_set_hw_macaddr(dev); 532 533 } ··· 1576 1575 ret = -EIO; 1577 1576 goto error_irq; 1578 1577 } 1579 - random_ether_addr(dev->dev_addr); 1578 + eth_hw_addr_random(dev); 1580 1579 enc28j60_set_hw_macaddr(dev); 1581 1580 1582 1581 /* Board setup must set the relevant edge trigger type;
+2 -1
drivers/net/ethernet/nvidia/forcedeth.c
··· 3022 3022 3023 3023 /* synchronized against open : rtnl_lock() held by caller */ 3024 3024 memcpy(dev->dev_addr, macaddr->sa_data, ETH_ALEN); 3025 + dev->addr_assign_type &= ~NET_ADDR_RANDOM; 3025 3026 3026 3027 if (netif_running(dev)) { 3027 3028 netif_tx_lock_bh(dev); ··· 5742 5741 dev_err(&pci_dev->dev, 5743 5742 "Invalid MAC address detected: %pM - Please complain to your hardware vendor.\n", 5744 5743 dev->dev_addr); 5745 - random_ether_addr(dev->dev_addr); 5744 + eth_hw_addr_random(dev); 5746 5745 dev_err(&pci_dev->dev, 5747 5746 "Using random MAC address: %pM\n", dev->dev_addr); 5748 5747 }
+2 -1
drivers/net/ethernet/smsc/smsc911x.c
··· 1833 1833 if (!is_valid_ether_addr(addr->sa_data)) 1834 1834 return -EADDRNOTAVAIL; 1835 1835 1836 + dev->addr_assign_type &= ~NET_ADDR_RANDOM; 1836 1837 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN); 1837 1838 1838 1839 spin_lock_irq(&pdata->mac_lock); ··· 2486 2485 "Mac Address is read from LAN911x EEPROM"); 2487 2486 } else { 2488 2487 /* eeprom values are invalid, generate random MAC */ 2489 - random_ether_addr(dev->dev_addr); 2488 + eth_hw_addr_random(dev); 2490 2489 smsc911x_set_hw_mac_address(pdata, dev->dev_addr); 2491 2490 SMSC_TRACE(pdata, probe, 2492 2491 "MAC Address is set to random_ether_addr");
+2 -1
drivers/net/ethernet/tile/tilepro.c
··· 2190 2190 2191 2191 /* ISSUE: Note that "dev_addr" is now a pointer. */ 2192 2192 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len); 2193 + dev->addr_assign_type &= ~NET_ADDR_RANDOM; 2193 2194 2194 2195 return 0; 2195 2196 } ··· 2255 2254 * can't get its MAC address, we are most likely running 2256 2255 * the simulator, so let's generate a random MAC address. 2257 2256 */ 2258 - random_ether_addr(dev->dev_addr); 2257 + eth_hw_addr_random(dev); 2259 2258 } 2260 2259 2261 2260 return 0;
+2 -1
drivers/net/macvlan.c
··· 372 372 373 373 if (!(dev->flags & IFF_UP)) { 374 374 /* Just copy in the new address */ 375 + dev->addr_assign_type &= ~NET_ADDR_RANDOM; 375 376 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN); 376 377 } else { 377 378 /* Rehash and update the device filters */ ··· 688 687 return -EINVAL; 689 688 690 689 if (!tb[IFLA_ADDRESS]) 691 - random_ether_addr(dev->dev_addr); 690 + eth_hw_addr_random(dev); 692 691 693 692 if (!macvlan_port_exists(lowerdev)) { 694 693 err = macvlan_port_create(lowerdev);
+2 -1
drivers/net/team/team.c
··· 868 868 struct team_port *port; 869 869 struct sockaddr *addr = p; 870 870 871 + dev->addr_assign_type &= ~NET_ADDR_RANDOM; 871 872 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN); 872 873 rcu_read_lock(); 873 874 list_for_each_entry_rcu(port, &team->port_list, list) ··· 1088 1087 int err; 1089 1088 1090 1089 if (tb[IFLA_ADDRESS] == NULL) 1091 - random_ether_addr(dev->dev_addr); 1090 + eth_hw_addr_random(dev); 1092 1091 1093 1092 err = register_netdevice(dev); 1094 1093 if (err)
+2 -1
net/bridge/br_device.c
··· 171 171 172 172 spin_lock_bh(&br->lock); 173 173 if (compare_ether_addr(dev->dev_addr, addr->sa_data)) { 174 + dev->addr_assign_type &= ~NET_ADDR_RANDOM; 174 175 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN); 175 176 br_fdb_change_mac_address(br, addr->sa_data); 176 177 br_stp_change_bridge_id(br, addr->sa_data); ··· 335 334 { 336 335 struct net_bridge *br = netdev_priv(dev); 337 336 338 - random_ether_addr(dev->dev_addr); 337 + eth_hw_addr_random(dev); 339 338 ether_setup(dev); 340 339 341 340 dev->netdev_ops = &br_netdev_ops;
+2 -1
net/openvswitch/vport-internal_dev.c
··· 66 66 67 67 if (!is_valid_ether_addr(addr->sa_data)) 68 68 return -EADDRNOTAVAIL; 69 + dev->addr_assign_type &= ~NET_ADDR_RANDOM; 69 70 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len); 70 71 return 0; 71 72 } ··· 146 145 netdev->vlan_features = netdev->features; 147 146 netdev->features |= NETIF_F_HW_VLAN_TX; 148 147 netdev->hw_features = netdev->features & ~NETIF_F_LLTX; 149 - random_ether_addr(netdev->dev_addr); 148 + eth_hw_addr_random(netdev); 150 149 } 151 150 152 151 static struct vport *internal_dev_create(const struct vport_parms *parms)