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 netdev_lock_ops(dev); 93 ret = netif_set_mac_address_user(dev, sa, extack); 94 netdev_unlock_ops(dev); 95 96 return ret; 97 } 98 EXPORT_SYMBOL(dev_set_mac_address_user); 99 100 /** 101 * dev_change_net_namespace() - move device to different nethost namespace 102 * @dev: device 103 * @net: network namespace 104 * @pat: If not NULL name pattern to try if the current device name 105 * is already taken in the destination network namespace. 106 * 107 * This function shuts down a device interface and moves it 108 * to a new network namespace. On success 0 is returned, on 109 * a failure a netagive errno code is returned. 110 * 111 * Callers must hold the rtnl semaphore. 112 * 113 * Return: 0 on success, -errno on failure. 114 */ 115 int dev_change_net_namespace(struct net_device *dev, struct net *net, 116 const char *pat) 117 { 118 int ret; 119 120 netdev_lock_ops(dev); 121 ret = netif_change_net_namespace(dev, net, pat, 0, NULL); 122 netdev_unlock_ops(dev); 123 124 return ret; 125 } 126 EXPORT_SYMBOL_GPL(dev_change_net_namespace); 127 128 /** 129 * dev_change_carrier() - change device carrier 130 * @dev: device 131 * @new_carrier: new value 132 * 133 * Change device carrier 134 * 135 * Return: 0 on success, -errno on failure. 136 */ 137 int dev_change_carrier(struct net_device *dev, bool new_carrier) 138 { 139 int ret; 140 141 netdev_lock_ops(dev); 142 ret = netif_change_carrier(dev, new_carrier); 143 netdev_unlock_ops(dev); 144 145 return ret; 146 } 147 148 /** 149 * dev_change_tx_queue_len() - change TX queue length of a netdevice 150 * @dev: device 151 * @new_len: new tx queue length 152 * 153 * Return: 0 on success, -errno on failure. 154 */ 155 int dev_change_tx_queue_len(struct net_device *dev, unsigned long new_len) 156 { 157 int ret; 158 159 netdev_lock_ops(dev); 160 ret = netif_change_tx_queue_len(dev, new_len); 161 netdev_unlock_ops(dev); 162 163 return ret; 164 } 165 166 /** 167 * dev_change_proto_down() - set carrier according to proto_down 168 * @dev: device 169 * @proto_down: new value 170 * 171 * Return: 0 on success, -errno on failure. 172 */ 173 int dev_change_proto_down(struct net_device *dev, bool proto_down) 174 { 175 int ret; 176 177 netdev_lock_ops(dev); 178 ret = netif_change_proto_down(dev, proto_down); 179 netdev_unlock_ops(dev); 180 181 return ret; 182 } 183 184 /** 185 * dev_open() - prepare an interface for use 186 * @dev: device to open 187 * @extack: netlink extended ack 188 * 189 * Takes a device from down to up state. The device's private open 190 * function is invoked and then the multicast lists are loaded. Finally 191 * the device is moved into the up state and a %NETDEV_UP message is 192 * sent to the netdev notifier chain. 193 * 194 * Calling this function on an active interface is a nop. On a failure 195 * a negative errno code is returned. 196 * 197 * Return: 0 on success, -errno on failure. 198 */ 199 int dev_open(struct net_device *dev, struct netlink_ext_ack *extack) 200 { 201 int ret; 202 203 netdev_lock_ops(dev); 204 ret = netif_open(dev, extack); 205 netdev_unlock_ops(dev); 206 207 return ret; 208 } 209 EXPORT_SYMBOL(dev_open); 210 211 /** 212 * dev_close() - shutdown an interface 213 * @dev: device to shutdown 214 * 215 * This function moves an active device into down state. A 216 * %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device 217 * is then deactivated and finally a %NETDEV_DOWN is sent to the notifier 218 * chain. 219 */ 220 void dev_close(struct net_device *dev) 221 { 222 netdev_lock_ops(dev); 223 netif_close(dev); 224 netdev_unlock_ops(dev); 225 } 226 EXPORT_SYMBOL(dev_close); 227 228 int dev_eth_ioctl(struct net_device *dev, 229 struct ifreq *ifr, unsigned int cmd) 230 { 231 const struct net_device_ops *ops = dev->netdev_ops; 232 int ret = -ENODEV; 233 234 if (!ops->ndo_eth_ioctl) 235 return -EOPNOTSUPP; 236 237 netdev_lock_ops(dev); 238 if (netif_device_present(dev)) 239 ret = ops->ndo_eth_ioctl(dev, ifr, cmd); 240 netdev_unlock_ops(dev); 241 242 return ret; 243 } 244 EXPORT_SYMBOL(dev_eth_ioctl); 245 246 int dev_set_mtu(struct net_device *dev, int new_mtu) 247 { 248 int ret; 249 250 netdev_lock_ops(dev); 251 ret = netif_set_mtu(dev, new_mtu); 252 netdev_unlock_ops(dev); 253 254 return ret; 255 } 256 EXPORT_SYMBOL(dev_set_mtu); 257 258 /** 259 * dev_disable_lro() - disable Large Receive Offload on a device 260 * @dev: device 261 * 262 * Disable Large Receive Offload (LRO) on a net device. Must be 263 * called under RTNL. This is needed if received packets may be 264 * forwarded to another interface. 265 */ 266 void dev_disable_lro(struct net_device *dev) 267 { 268 netdev_lock_ops(dev); 269 netif_disable_lro(dev); 270 netdev_unlock_ops(dev); 271 } 272 EXPORT_SYMBOL(dev_disable_lro); 273 274 /** 275 * dev_set_allmulti() - update allmulti count on a device 276 * @dev: device 277 * @inc: modifier 278 * 279 * Add or remove reception of all multicast frames to a device. While the 280 * count in the device remains above zero the interface remains listening 281 * to all interfaces. Once it hits zero the device reverts back to normal 282 * filtering operation. A negative @inc value is used to drop the counter 283 * when releasing a resource needing all multicasts. 284 * 285 * Return: 0 on success, -errno on failure. 286 */ 287 288 int dev_set_allmulti(struct net_device *dev, int inc) 289 { 290 int ret; 291 292 netdev_lock_ops(dev); 293 ret = netif_set_allmulti(dev, inc, true); 294 netdev_unlock_ops(dev); 295 296 return ret; 297 } 298 EXPORT_SYMBOL(dev_set_allmulti); 299 300 /** 301 * dev_set_mac_address() - change Media Access Control Address 302 * @dev: device 303 * @sa: new address 304 * @extack: netlink extended ack 305 * 306 * Change the hardware (MAC) address of the device 307 * 308 * Return: 0 on success, -errno on failure. 309 */ 310 int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa, 311 struct netlink_ext_ack *extack) 312 { 313 int ret; 314 315 netdev_lock_ops(dev); 316 ret = netif_set_mac_address(dev, sa, extack); 317 netdev_unlock_ops(dev); 318 319 return ret; 320 } 321 EXPORT_SYMBOL(dev_set_mac_address); 322 323 int dev_xdp_propagate(struct net_device *dev, struct netdev_bpf *bpf) 324 { 325 int ret; 326 327 netdev_lock_ops(dev); 328 ret = netif_xdp_propagate(dev, bpf); 329 netdev_unlock_ops(dev); 330 331 return ret; 332 } 333 EXPORT_SYMBOL_GPL(dev_xdp_propagate); 334