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