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