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 netif_rx_mode_sync(dev); 70 netdev_unlock_ops(dev); 71 72 return ret; 73 } 74 EXPORT_SYMBOL(dev_change_flags); 75 76 /** 77 * dev_set_group() - change group this device belongs to 78 * @dev: device 79 * @new_group: group this device should belong to 80 */ 81 void dev_set_group(struct net_device *dev, int new_group) 82 { 83 netdev_lock_ops(dev); 84 netif_set_group(dev, new_group); 85 netdev_unlock_ops(dev); 86 } 87 88 int dev_set_mac_address_user(struct net_device *dev, 89 struct sockaddr_storage *ss, 90 struct netlink_ext_ack *extack) 91 { 92 int ret; 93 94 down_write(&dev_addr_sem); 95 netdev_lock_ops(dev); 96 ret = netif_set_mac_address(dev, ss, extack); 97 netdev_unlock_ops(dev); 98 up_write(&dev_addr_sem); 99 100 return ret; 101 } 102 EXPORT_SYMBOL(dev_set_mac_address_user); 103 104 /** 105 * dev_change_net_namespace() - move device to different nethost namespace 106 * @dev: device 107 * @net: network namespace 108 * @pat: If not NULL name pattern to try if the current device name 109 * is already taken in the destination network namespace. 110 * 111 * This function shuts down a device interface and moves it 112 * to a new network namespace. On success 0 is returned, on 113 * a failure a netagive errno code is returned. 114 * 115 * Callers must hold the rtnl semaphore. 116 * 117 * Return: 0 on success, -errno on failure. 118 */ 119 int dev_change_net_namespace(struct net_device *dev, struct net *net, 120 const char *pat) 121 { 122 return __dev_change_net_namespace(dev, net, pat, 0, NULL); 123 } 124 EXPORT_SYMBOL_GPL(dev_change_net_namespace); 125 126 /** 127 * dev_change_carrier() - change device carrier 128 * @dev: device 129 * @new_carrier: new value 130 * 131 * Change device carrier 132 * 133 * Return: 0 on success, -errno on failure. 134 */ 135 int dev_change_carrier(struct net_device *dev, bool new_carrier) 136 { 137 int ret; 138 139 netdev_lock_ops(dev); 140 ret = netif_change_carrier(dev, new_carrier); 141 netdev_unlock_ops(dev); 142 143 return ret; 144 } 145 146 /** 147 * dev_change_tx_queue_len() - change TX queue length of a netdevice 148 * @dev: device 149 * @new_len: new tx queue length 150 * 151 * Return: 0 on success, -errno on failure. 152 */ 153 int dev_change_tx_queue_len(struct net_device *dev, unsigned long new_len) 154 { 155 int ret; 156 157 netdev_lock_ops(dev); 158 ret = netif_change_tx_queue_len(dev, new_len); 159 netdev_unlock_ops(dev); 160 161 return ret; 162 } 163 164 /** 165 * dev_change_proto_down() - set carrier according to proto_down 166 * @dev: device 167 * @proto_down: new value 168 * 169 * Return: 0 on success, -errno on failure. 170 */ 171 int dev_change_proto_down(struct net_device *dev, bool proto_down) 172 { 173 int ret; 174 175 netdev_lock_ops(dev); 176 ret = netif_change_proto_down(dev, proto_down); 177 netdev_unlock_ops(dev); 178 179 return ret; 180 } 181 182 /** 183 * dev_open() - prepare an interface for use 184 * @dev: device to open 185 * @extack: netlink extended ack 186 * 187 * Takes a device from down to up state. The device's private open 188 * function is invoked and then the multicast lists are loaded. Finally 189 * the device is moved into the up state and a %NETDEV_UP message is 190 * sent to the netdev notifier chain. 191 * 192 * Calling this function on an active interface is a nop. On a failure 193 * a negative errno code is returned. 194 * 195 * Return: 0 on success, -errno on failure. 196 */ 197 int dev_open(struct net_device *dev, struct netlink_ext_ack *extack) 198 { 199 int ret; 200 201 netdev_lock_ops(dev); 202 ret = netif_open(dev, extack); 203 netdev_unlock_ops(dev); 204 205 return ret; 206 } 207 EXPORT_SYMBOL(dev_open); 208 209 /** 210 * dev_close() - shutdown an interface 211 * @dev: device to shutdown 212 * 213 * This function moves an active device into down state. A 214 * %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device 215 * is then deactivated and finally a %NETDEV_DOWN is sent to the notifier 216 * chain. 217 */ 218 void dev_close(struct net_device *dev) 219 { 220 netdev_lock_ops(dev); 221 netif_close(dev); 222 netdev_unlock_ops(dev); 223 } 224 EXPORT_SYMBOL(dev_close); 225 226 int dev_eth_ioctl(struct net_device *dev, 227 struct ifreq *ifr, unsigned int cmd) 228 { 229 const struct net_device_ops *ops = dev->netdev_ops; 230 int ret = -ENODEV; 231 232 if (!ops->ndo_eth_ioctl) 233 return -EOPNOTSUPP; 234 235 netdev_lock_ops(dev); 236 if (netif_device_present(dev)) 237 ret = ops->ndo_eth_ioctl(dev, ifr, cmd); 238 netdev_unlock_ops(dev); 239 240 return ret; 241 } 242 EXPORT_SYMBOL(dev_eth_ioctl); 243 244 int dev_set_mtu(struct net_device *dev, int new_mtu) 245 { 246 int ret; 247 248 netdev_lock_ops(dev); 249 ret = netif_set_mtu(dev, new_mtu); 250 netdev_unlock_ops(dev); 251 252 return ret; 253 } 254 EXPORT_SYMBOL(dev_set_mtu); 255 256 /** 257 * dev_disable_lro() - disable Large Receive Offload on a device 258 * @dev: device 259 * 260 * Disable Large Receive Offload (LRO) on a net device. Must be 261 * called under RTNL. This is needed if received packets may be 262 * forwarded to another interface. 263 */ 264 void dev_disable_lro(struct net_device *dev) 265 { 266 netdev_lock_ops(dev); 267 netif_disable_lro(dev); 268 netdev_unlock_ops(dev); 269 } 270 EXPORT_SYMBOL(dev_disable_lro); 271 272 /** 273 * dev_set_promiscuity() - update promiscuity count on a device 274 * @dev: device 275 * @inc: modifier 276 * 277 * Add or remove promiscuity from a device. While the count in the device 278 * remains above zero the interface remains promiscuous. Once it hits zero 279 * the device reverts back to normal filtering operation. A negative inc 280 * value is used to drop promiscuity on the device. 281 * Return 0 if successful or a negative errno code on error. 282 */ 283 int dev_set_promiscuity(struct net_device *dev, int inc) 284 { 285 int ret; 286 287 netdev_lock_ops(dev); 288 ret = netif_set_promiscuity(dev, inc); 289 netif_rx_mode_sync(dev); 290 netdev_unlock_ops(dev); 291 292 return ret; 293 } 294 EXPORT_SYMBOL(dev_set_promiscuity); 295 296 /** 297 * dev_set_allmulti() - update allmulti count on a device 298 * @dev: device 299 * @inc: modifier 300 * 301 * Add or remove reception of all multicast frames to a device. While the 302 * count in the device remains above zero the interface remains listening 303 * to all interfaces. Once it hits zero the device reverts back to normal 304 * filtering operation. A negative @inc value is used to drop the counter 305 * when releasing a resource needing all multicasts. 306 * 307 * Return: 0 on success, -errno on failure. 308 */ 309 310 int dev_set_allmulti(struct net_device *dev, int inc) 311 { 312 int ret; 313 314 netdev_lock_ops(dev); 315 ret = netif_set_allmulti(dev, inc, true); 316 netif_rx_mode_sync(dev); 317 netdev_unlock_ops(dev); 318 319 return ret; 320 } 321 EXPORT_SYMBOL(dev_set_allmulti); 322 323 /** 324 * dev_set_mac_address() - change Media Access Control Address 325 * @dev: device 326 * @ss: new address 327 * @extack: netlink extended ack 328 * 329 * Change the hardware (MAC) address of the device 330 * 331 * Return: 0 on success, -errno on failure. 332 */ 333 int dev_set_mac_address(struct net_device *dev, struct sockaddr_storage *ss, 334 struct netlink_ext_ack *extack) 335 { 336 int ret; 337 338 netdev_lock_ops(dev); 339 ret = netif_set_mac_address(dev, ss, extack); 340 netdev_unlock_ops(dev); 341 342 return ret; 343 } 344 EXPORT_SYMBOL(dev_set_mac_address); 345 346 int dev_xdp_propagate(struct net_device *dev, struct netdev_bpf *bpf) 347 { 348 int ret; 349 350 netdev_lock_ops(dev); 351 ret = netif_xdp_propagate(dev, bpf); 352 netdev_unlock_ops(dev); 353 354 return ret; 355 } 356 EXPORT_SYMBOL_GPL(dev_xdp_propagate); 357 358 /** 359 * netdev_state_change() - device changes state 360 * @dev: device to cause notification 361 * 362 * Called to indicate a device has changed state. This function calls 363 * the notifier chains for netdev_chain and sends a NEWLINK message 364 * to the routing socket. 365 */ 366 void netdev_state_change(struct net_device *dev) 367 { 368 netdev_lock_ops(dev); 369 netif_state_change(dev); 370 netdev_unlock_ops(dev); 371 } 372 EXPORT_SYMBOL(netdev_state_change); 373 374 int dev_set_threaded(struct net_device *dev, 375 enum netdev_napi_threaded threaded) 376 { 377 int ret; 378 379 netdev_lock(dev); 380 ret = netif_set_threaded(dev, threaded); 381 netdev_unlock(dev); 382 383 return ret; 384 } 385 EXPORT_SYMBOL(dev_set_threaded); 386