1 // SPDX-License-Identifier: GPL-2.0-or-later 2 3 #include <linux/netdevice.h> 4 #include <net/netdev_lock.h> 5 6 #include "dev.h" 7 8 /** 9 * dev_change_name() - change name of a device 10 * @dev: device 11 * @newname: name (or format string) must be at least IFNAMSIZ 12 * 13 * Change name of a device, can pass format strings "eth%d". 14 * for wildcarding. 15 * 16 * Return: 0 on success, -errno on failure. 17 */ 18 int dev_change_name(struct net_device *dev, const char *newname) 19 { 20 int ret; 21 22 netdev_lock_ops(dev); 23 ret = netif_change_name(dev, newname); 24 netdev_unlock_ops(dev); 25 26 return ret; 27 } 28 29 /** 30 * dev_set_alias() - change ifalias of a device 31 * @dev: device 32 * @alias: name up to IFALIASZ 33 * @len: limit of bytes to copy from info 34 * 35 * Set ifalias for a device. 36 * 37 * Return: 0 on success, -errno on failure. 38 */ 39 int dev_set_alias(struct net_device *dev, const char *alias, size_t len) 40 { 41 int ret; 42 43 netdev_lock_ops(dev); 44 ret = netif_set_alias(dev, alias, len); 45 netdev_unlock_ops(dev); 46 47 return ret; 48 } 49 EXPORT_SYMBOL(dev_set_alias); 50 51 /** 52 * dev_change_flags() - change device settings 53 * @dev: device 54 * @flags: device state flags 55 * @extack: netlink extended ack 56 * 57 * Change settings on device based state flags. The flags are 58 * in the userspace exported format. 59 * 60 * Return: 0 on success, -errno on failure. 61 */ 62 int dev_change_flags(struct net_device *dev, unsigned int flags, 63 struct netlink_ext_ack *extack) 64 { 65 int ret; 66 67 netdev_lock_ops(dev); 68 ret = netif_change_flags(dev, flags, extack); 69 netdev_unlock_ops(dev); 70 71 return ret; 72 } 73 EXPORT_SYMBOL(dev_change_flags); 74 75 /** 76 * dev_set_group() - change group this device belongs to 77 * @dev: device 78 * @new_group: group this device should belong to 79 */ 80 void dev_set_group(struct net_device *dev, int new_group) 81 { 82 netdev_lock_ops(dev); 83 netif_set_group(dev, new_group); 84 netdev_unlock_ops(dev); 85 } 86 87 int dev_set_mac_address_user(struct net_device *dev, struct sockaddr *sa, 88 struct netlink_ext_ack *extack) 89 { 90 int ret; 91 92 down_write(&dev_addr_sem); 93 netdev_lock_ops(dev); 94 ret = netif_set_mac_address(dev, sa, extack); 95 netdev_unlock_ops(dev); 96 up_write(&dev_addr_sem); 97 98 return ret; 99 } 100 EXPORT_SYMBOL(dev_set_mac_address_user); 101 102 /** 103 * dev_change_net_namespace() - move device to different nethost namespace 104 * @dev: device 105 * @net: network namespace 106 * @pat: If not NULL name pattern to try if the current device name 107 * is already taken in the destination network namespace. 108 * 109 * This function shuts down a device interface and moves it 110 * to a new network namespace. On success 0 is returned, on 111 * a failure a netagive errno code is returned. 112 * 113 * Callers must hold the rtnl semaphore. 114 * 115 * Return: 0 on success, -errno on failure. 116 */ 117 int dev_change_net_namespace(struct net_device *dev, struct net *net, 118 const char *pat) 119 { 120 return __dev_change_net_namespace(dev, net, pat, 0, NULL); 121 } 122 EXPORT_SYMBOL_GPL(dev_change_net_namespace); 123 124 /** 125 * dev_change_carrier() - change device carrier 126 * @dev: device 127 * @new_carrier: new value 128 * 129 * Change device carrier 130 * 131 * Return: 0 on success, -errno on failure. 132 */ 133 int dev_change_carrier(struct net_device *dev, bool new_carrier) 134 { 135 int ret; 136 137 netdev_lock_ops(dev); 138 ret = netif_change_carrier(dev, new_carrier); 139 netdev_unlock_ops(dev); 140 141 return ret; 142 } 143 144 /** 145 * dev_change_tx_queue_len() - change TX queue length of a netdevice 146 * @dev: device 147 * @new_len: new tx queue length 148 * 149 * Return: 0 on success, -errno on failure. 150 */ 151 int dev_change_tx_queue_len(struct net_device *dev, unsigned long new_len) 152 { 153 int ret; 154 155 netdev_lock_ops(dev); 156 ret = netif_change_tx_queue_len(dev, new_len); 157 netdev_unlock_ops(dev); 158 159 return ret; 160 } 161 162 /** 163 * dev_change_proto_down() - set carrier according to proto_down 164 * @dev: device 165 * @proto_down: new value 166 * 167 * Return: 0 on success, -errno on failure. 168 */ 169 int dev_change_proto_down(struct net_device *dev, bool proto_down) 170 { 171 int ret; 172 173 netdev_lock_ops(dev); 174 ret = netif_change_proto_down(dev, proto_down); 175 netdev_unlock_ops(dev); 176 177 return ret; 178 } 179 180 /** 181 * dev_open() - prepare an interface for use 182 * @dev: device to open 183 * @extack: netlink extended ack 184 * 185 * Takes a device from down to up state. The device's private open 186 * function is invoked and then the multicast lists are loaded. Finally 187 * the device is moved into the up state and a %NETDEV_UP message is 188 * sent to the netdev notifier chain. 189 * 190 * Calling this function on an active interface is a nop. On a failure 191 * a negative errno code is returned. 192 * 193 * Return: 0 on success, -errno on failure. 194 */ 195 int dev_open(struct net_device *dev, struct netlink_ext_ack *extack) 196 { 197 int ret; 198 199 netdev_lock_ops(dev); 200 ret = netif_open(dev, extack); 201 netdev_unlock_ops(dev); 202 203 return ret; 204 } 205 EXPORT_SYMBOL(dev_open); 206 207 /** 208 * dev_close() - shutdown an interface 209 * @dev: device to shutdown 210 * 211 * This function moves an active device into down state. A 212 * %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device 213 * is then deactivated and finally a %NETDEV_DOWN is sent to the notifier 214 * chain. 215 */ 216 void dev_close(struct net_device *dev) 217 { 218 netdev_lock_ops(dev); 219 netif_close(dev); 220 netdev_unlock_ops(dev); 221 } 222 EXPORT_SYMBOL(dev_close); 223 224 int dev_eth_ioctl(struct net_device *dev, 225 struct ifreq *ifr, unsigned int cmd) 226 { 227 const struct net_device_ops *ops = dev->netdev_ops; 228 int ret = -ENODEV; 229 230 if (!ops->ndo_eth_ioctl) 231 return -EOPNOTSUPP; 232 233 netdev_lock_ops(dev); 234 if (netif_device_present(dev)) 235 ret = ops->ndo_eth_ioctl(dev, ifr, cmd); 236 netdev_unlock_ops(dev); 237 238 return ret; 239 } 240 EXPORT_SYMBOL(dev_eth_ioctl); 241 242 int dev_set_mtu(struct net_device *dev, int new_mtu) 243 { 244 int ret; 245 246 netdev_lock_ops(dev); 247 ret = netif_set_mtu(dev, new_mtu); 248 netdev_unlock_ops(dev); 249 250 return ret; 251 } 252 EXPORT_SYMBOL(dev_set_mtu); 253 254 /** 255 * dev_disable_lro() - disable Large Receive Offload on a device 256 * @dev: device 257 * 258 * Disable Large Receive Offload (LRO) on a net device. Must be 259 * called under RTNL. This is needed if received packets may be 260 * forwarded to another interface. 261 */ 262 void dev_disable_lro(struct net_device *dev) 263 { 264 netdev_lock_ops(dev); 265 netif_disable_lro(dev); 266 netdev_unlock_ops(dev); 267 } 268 EXPORT_SYMBOL(dev_disable_lro); 269 270 /** 271 * dev_set_allmulti() - update allmulti count on a device 272 * @dev: device 273 * @inc: modifier 274 * 275 * Add or remove reception of all multicast frames to a device. While the 276 * count in the device remains above zero the interface remains listening 277 * to all interfaces. Once it hits zero the device reverts back to normal 278 * filtering operation. A negative @inc value is used to drop the counter 279 * when releasing a resource needing all multicasts. 280 * 281 * Return: 0 on success, -errno on failure. 282 */ 283 284 int dev_set_allmulti(struct net_device *dev, int inc) 285 { 286 int ret; 287 288 netdev_lock_ops(dev); 289 ret = netif_set_allmulti(dev, inc, true); 290 netdev_unlock_ops(dev); 291 292 return ret; 293 } 294 EXPORT_SYMBOL(dev_set_allmulti); 295 296 /** 297 * dev_set_mac_address() - change Media Access Control Address 298 * @dev: device 299 * @sa: new address 300 * @extack: netlink extended ack 301 * 302 * Change the hardware (MAC) address of the device 303 * 304 * Return: 0 on success, -errno on failure. 305 */ 306 int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa, 307 struct netlink_ext_ack *extack) 308 { 309 int ret; 310 311 netdev_lock_ops(dev); 312 ret = netif_set_mac_address(dev, sa, extack); 313 netdev_unlock_ops(dev); 314 315 return ret; 316 } 317 EXPORT_SYMBOL(dev_set_mac_address); 318 319 int dev_xdp_propagate(struct net_device *dev, struct netdev_bpf *bpf) 320 { 321 int ret; 322 323 netdev_lock_ops(dev); 324 ret = netif_xdp_propagate(dev, bpf); 325 netdev_unlock_ops(dev); 326 327 return ret; 328 } 329 EXPORT_SYMBOL_GPL(dev_xdp_propagate); 330 331 /** 332 * netdev_state_change() - device changes state 333 * @dev: device to cause notification 334 * 335 * Called to indicate a device has changed state. This function calls 336 * the notifier chains for netdev_chain and sends a NEWLINK message 337 * to the routing socket. 338 */ 339 void netdev_state_change(struct net_device *dev) 340 { 341 netdev_lock_ops(dev); 342 netif_state_change(dev); 343 netdev_unlock_ops(dev); 344 } 345 EXPORT_SYMBOL(netdev_state_change); 346