projects/linux·blob master · refs

385 lines · 8.8 KiB

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 */
18int 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 */
39int 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}
49EXPORT_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 */
62int 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}
74EXPORT_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 */
81void 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
88int 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}
102EXPORT_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 */
119int 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}
124EXPORT_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 */
135int 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 */
153int 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 */
171int 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 */
197int 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}
207EXPORT_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 */
218void dev_close(struct net_device *dev)
219{
220 netdev_lock_ops(dev);
221 netif_close(dev);
222 netdev_unlock_ops(dev);
223}
224EXPORT_SYMBOL(dev_close);
225
226int 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}
242EXPORT_SYMBOL(dev_eth_ioctl);
243
244int 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}
254EXPORT_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 */
264void dev_disable_lro(struct net_device *dev)
265{
266 netdev_lock_ops(dev);
267 netif_disable_lro(dev);
268 netdev_unlock_ops(dev);
269}
270EXPORT_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 */
283int 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}
294EXPORT_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
310int 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}
321EXPORT_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 */
333int 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}
344EXPORT_SYMBOL(dev_set_mac_address);
345
346int 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}
356EXPORT_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 */
366void netdev_state_change(struct net_device *dev)
367{
368 netdev_lock_ops(dev);
369 netif_state_change(dev);
370 netdev_unlock_ops(dev);
371}
372EXPORT_SYMBOL(netdev_state_change);
373
374int 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}
385EXPORT_SYMBOL(dev_set_threaded);