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 int dev_set_mac_address_user(struct net_device *dev, struct sockaddr *sa, 86 struct netlink_ext_ack *extack) 87 { 88 int ret; 89 90 netdev_lock_ops(dev); 91 ret = netif_set_mac_address_user(dev, sa, extack); 92 netdev_unlock_ops(dev); 93 94 return ret; 95 } 96 EXPORT_SYMBOL(dev_set_mac_address_user); 97 98 /** 99 * dev_change_net_namespace() - move device to different nethost namespace 100 * @dev: device 101 * @net: network namespace 102 * @pat: If not NULL name pattern to try if the current device name 103 * is already taken in the destination network namespace. 104 * 105 * This function shuts down a device interface and moves it 106 * to a new network namespace. On success 0 is returned, on 107 * a failure a netagive errno code is returned. 108 * 109 * Callers must hold the rtnl semaphore. 110 * 111 * Return: 0 on success, -errno on failure. 112 */ 113 int dev_change_net_namespace(struct net_device *dev, struct net *net, 114 const char *pat) 115 { 116 int ret; 117 118 netdev_lock_ops(dev); 119 ret = netif_change_net_namespace(dev, net, pat, 0, NULL); 120 netdev_unlock_ops(dev); 121 122 return ret; 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