]>
Commit | Line | Data |
---|---|---|
8b61709d | 1 | /* |
7dbd520e | 2 | * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014, 2016 Nicira, Inc. |
8b61709d BP |
3 | * |
4 | * Licensed under the Apache License, Version 2.0 (the "License"); | |
5 | * you may not use this file except in compliance with the License. | |
6 | * You may obtain a copy of the License at: | |
7 | * | |
8 | * http://www.apache.org/licenses/LICENSE-2.0 | |
9 | * | |
10 | * Unless required by applicable law or agreed to in writing, software | |
11 | * distributed under the License is distributed on an "AS IS" BASIS, | |
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
13 | * See the License for the specific language governing permissions and | |
14 | * limitations under the License. | |
15 | */ | |
16 | ||
17 | #ifndef NETDEV_PROVIDER_H | |
18 | #define NETDEV_PROVIDER_H 1 | |
19 | ||
20 | /* Generic interface to network devices. */ | |
21 | ||
3e912ffc | 22 | #include "connectivity.h" |
8b61709d | 23 | #include "netdev.h" |
b19bab5b | 24 | #include "openvswitch/list.h" |
7dec44fe | 25 | #include "ovs-numa.h" |
3bd0fd39 | 26 | #include "packets.h" |
3e912ffc | 27 | #include "seq.h" |
ee89ea7b | 28 | #include "openvswitch/shash.h" |
79f1cbe9 | 29 | #include "smap.h" |
6c88d577 | 30 | |
6dfd0304 BP |
31 | #ifdef __cplusplus |
32 | extern "C" { | |
33 | #endif | |
34 | ||
4975aa3e | 35 | struct netdev_tnl_build_header_params; |
7dec44fe AW |
36 | #define NETDEV_NUMA_UNSPEC OVS_NUMA_UNSPEC |
37 | ||
149f577a | 38 | /* A network device (e.g. an Ethernet device). |
6c88d577 | 39 | * |
9dc63482 BP |
40 | * Network device implementations may read these members but should not modify |
41 | * them. */ | |
b5d57fc8 | 42 | struct netdev { |
86383816 | 43 | /* The following do not change during the lifetime of a struct netdev. */ |
149f577a | 44 | char *name; /* Name of network device. */ |
d295e8e9 | 45 | const struct netdev_class *netdev_class; /* Functions to control |
a4af0040 | 46 | this device. */ |
86383816 | 47 | |
8c2c225e EC |
48 | /* If this is 'true' the user did not specify a netdev_class when |
49 | * opening this device, and therefore got assigned to the "system" class */ | |
50 | bool auto_classified; | |
51 | ||
85e16a45 BB |
52 | /* If this is 'true', the user explicitly specified an MTU for this |
53 | * netdev. Otherwise, Open vSwitch is allowed to override it. */ | |
54 | bool mtu_user_config; | |
55 | ||
56 | int ref_cnt; /* Times this devices was opened. */ | |
57 | ||
3e912ffc AW |
58 | /* A sequence number which indicates changes in one of 'netdev''s |
59 | * properties. It must be nonzero so that users have a value which | |
60 | * they may use as a reset when tracking 'netdev'. | |
61 | * | |
62 | * Minimally, the sequence number is required to change whenever | |
63 | * 'netdev''s flags, features, ethernet address, or carrier changes. */ | |
64 | uint64_t change_seq; | |
65 | ||
790fb3b7 DDP |
66 | /* A netdev provider might be unable to change some of the device's |
67 | * parameter (n_rxq, mtu) when the device is in use. In this case | |
68 | * the provider can notify the upper layer by calling | |
69 | * netdev_request_reconfigure(). The upper layer will react by stopping | |
70 | * the operations on the device and calling netdev_reconfigure() to allow | |
71 | * the configuration changes. 'last_reconfigure_seq' remembers the value | |
72 | * of 'reconfigure_seq' when the last reconfiguration happened. */ | |
73 | struct seq *reconfigure_seq; | |
74 | uint64_t last_reconfigure_seq; | |
75 | ||
a14b8947 IM |
76 | /* The core netdev code initializes these at netdev construction and only |
77 | * provide read-only access to its client. Netdev implementations may | |
78 | * modify them. */ | |
f00fa8cb | 79 | int n_txq; |
55c955bd | 80 | int n_rxq; |
149f577a | 81 | struct shash_node *node; /* Pointer to element in global map. */ |
ca6ba700 | 82 | struct ovs_list saved_flags_list; /* Contains "struct netdev_saved_flags". */ |
6c88d577 JP |
83 | }; |
84 | ||
6b241d64 | 85 | static inline void |
053acb81 | 86 | netdev_change_seq_changed(const struct netdev *netdev_) |
3e912ffc | 87 | { |
053acb81 | 88 | struct netdev *netdev = CONST_CAST(struct netdev *, netdev_); |
3e912ffc AW |
89 | seq_change(connectivity_seq_get()); |
90 | netdev->change_seq++; | |
91 | if (!netdev->change_seq) { | |
92 | netdev->change_seq++; | |
93 | } | |
94 | } | |
95 | ||
790fb3b7 DDP |
96 | static inline void |
97 | netdev_request_reconfigure(struct netdev *netdev) | |
98 | { | |
99 | seq_change(netdev->reconfigure_seq); | |
100 | } | |
101 | ||
b5d57fc8 BP |
102 | const char *netdev_get_type(const struct netdev *); |
103 | const struct netdev_class *netdev_get_class(const struct netdev *); | |
104 | const char *netdev_get_name(const struct netdev *); | |
105 | struct netdev *netdev_from_name(const char *name); | |
106 | void netdev_get_devices(const struct netdev_class *, | |
107 | struct shash *device_list); | |
41ca1e0a | 108 | struct netdev **netdev_get_vports(size_t *size); |
149f577a | 109 | |
9dc63482 BP |
110 | /* A data structure for capturing packets received by a network device. |
111 | * | |
112 | * Network device implementations may read these members but should not modify | |
113 | * them. | |
114 | * | |
f7791740 PS |
115 | * None of these members change during the lifetime of a struct netdev_rxq. */ |
116 | struct netdev_rxq { | |
9dc63482 | 117 | struct netdev *netdev; /* Owns a reference to the netdev. */ |
55c955bd | 118 | int queue_id; |
9dc63482 BP |
119 | }; |
120 | ||
f7791740 | 121 | struct netdev *netdev_rxq_get_netdev(const struct netdev_rxq *); |
9dc63482 | 122 | |
18ebd48c PB |
123 | |
124 | struct netdev_flow_dump { | |
125 | struct netdev *netdev; | |
126 | odp_port_t port; | |
18ebd48c | 127 | bool terse; |
0d9bdf2e | 128 | struct nl_dump *nl_dump; |
18ebd48c PB |
129 | }; |
130 | ||
8b61709d BP |
131 | /* Network device class structure, to be defined by each implementation of a |
132 | * network device. | |
133 | * | |
134 | * These functions return 0 if successful or a positive errno value on failure, | |
9dc63482 BP |
135 | * except where otherwise noted. |
136 | * | |
137 | * | |
138 | * Data Structures | |
139 | * =============== | |
140 | * | |
141 | * These functions work primarily with two different kinds of data structures: | |
142 | * | |
143 | * - "struct netdev", which represents a network device. | |
144 | * | |
f7791740 | 145 | * - "struct netdev_rxq", which represents a handle for capturing packets |
9dc63482 BP |
146 | * received on a network device |
147 | * | |
148 | * Each of these data structures contains all of the implementation-independent | |
149 | * generic state for the respective concept, called the "base" state. None of | |
150 | * them contains any extra space for implementations to use. Instead, each | |
151 | * implementation is expected to declare its own data structure that contains | |
152 | * an instance of the generic data structure plus additional | |
153 | * implementation-specific members, called the "derived" state. The | |
154 | * implementation can use casts or (preferably) the CONTAINER_OF macro to | |
155 | * obtain access to derived state given only a pointer to the embedded generic | |
156 | * data structure. | |
157 | * | |
158 | * | |
159 | * Life Cycle | |
160 | * ========== | |
161 | * | |
162 | * Four stylized functions accompany each of these data structures: | |
163 | * | |
f7791740 PS |
164 | * "alloc" "construct" "destruct" "dealloc" |
165 | * ------------ ---------------- --------------- -------------- | |
166 | * netdev ->alloc ->construct ->destruct ->dealloc | |
167 | * netdev_rxq ->rxq_alloc ->rxq_construct ->rxq_destruct ->rxq_dealloc | |
9dc63482 BP |
168 | * |
169 | * Any instance of a given data structure goes through the following life | |
170 | * cycle: | |
171 | * | |
172 | * 1. The client calls the "alloc" function to obtain raw memory. If "alloc" | |
173 | * fails, skip all the other steps. | |
174 | * | |
175 | * 2. The client initializes all of the data structure's base state. If this | |
176 | * fails, skip to step 7. | |
177 | * | |
178 | * 3. The client calls the "construct" function. The implementation | |
179 | * initializes derived state. It may refer to the already-initialized | |
180 | * base state. If "construct" fails, skip to step 6. | |
181 | * | |
182 | * 4. The data structure is now initialized and in use. | |
183 | * | |
184 | * 5. When the data structure is no longer needed, the client calls the | |
185 | * "destruct" function. The implementation uninitializes derived state. | |
186 | * The base state has not been uninitialized yet, so the implementation | |
187 | * may still refer to it. | |
188 | * | |
189 | * 6. The client uninitializes all of the data structure's base state. | |
190 | * | |
191 | * 7. The client calls the "dealloc" to free the raw memory. The | |
192 | * implementation must not refer to base or derived state in the data | |
193 | * structure, because it has already been uninitialized. | |
194 | * | |
55c955bd PS |
195 | * If netdev support multi-queue IO then netdev->construct should set initialize |
196 | * netdev->n_rxq to number of queues. | |
197 | * | |
9dc63482 BP |
198 | * Each "alloc" function allocates and returns a new instance of the respective |
199 | * data structure. The "alloc" function is not given any information about the | |
200 | * use of the new data structure, so it cannot perform much initialization. | |
201 | * Its purpose is just to ensure that the new data structure has enough room | |
202 | * for base and derived state. It may return a null pointer if memory is not | |
203 | * available, in which case none of the other functions is called. | |
204 | * | |
205 | * Each "construct" function initializes derived state in its respective data | |
206 | * structure. When "construct" is called, all of the base state has already | |
207 | * been initialized, so the "construct" function may refer to it. The | |
208 | * "construct" function is allowed to fail, in which case the client calls the | |
209 | * "dealloc" function (but not the "destruct" function). | |
210 | * | |
211 | * Each "destruct" function uninitializes and frees derived state in its | |
212 | * respective data structure. When "destruct" is called, the base state has | |
213 | * not yet been uninitialized, so the "destruct" function may refer to it. The | |
214 | * "destruct" function is not allowed to fail. | |
215 | * | |
898dcef1 | 216 | * Each "dealloc" function frees raw memory that was allocated by the |
9dc63482 BP |
217 | * "alloc" function. The memory's base and derived members might not have ever |
218 | * been initialized (but if "construct" returned successfully, then it has been | |
da4a6191 JS |
219 | * "destruct"ed already). The "dealloc" function is not allowed to fail. |
220 | * | |
221 | * | |
222 | * Device Change Notification | |
223 | * ========================== | |
224 | * | |
225 | * Minimally, implementations are required to report changes to netdev flags, | |
226 | * features, ethernet address or carrier through connectivity_seq. Changes to | |
227 | * other properties are allowed to cause notification through this interface, | |
228 | * although implementations should try to avoid this. connectivity_seq_get() | |
229 | * can be used to acquire a reference to the struct seq. The interface is | |
230 | * described in detail in seq.h. */ | |
8b61709d | 231 | struct netdev_class { |
6c88d577 | 232 | /* Type of netdevs in this class, e.g. "system", "tap", "gre", etc. |
8b61709d | 233 | * |
6c88d577 | 234 | * One of the providers should supply a "system" type, since this is |
149f577a JG |
235 | * the type assumed if no type is specified when opening a netdev. |
236 | * The "system" type corresponds to an existing network device on | |
237 | * the system. */ | |
6c88d577 | 238 | const char *type; |
8b61709d | 239 | |
118c77b1 IM |
240 | /* If 'true' then this netdev should be polled by PMD threads. */ |
241 | bool is_pmd; | |
242 | ||
9dc63482 BP |
243 | /* ## ------------------- ## */ |
244 | /* ## Top-Level Functions ## */ | |
245 | /* ## ------------------- ## */ | |
246 | ||
77909859 JG |
247 | /* Called when the netdev provider is registered, typically at program |
248 | * startup. Returning an error from this function will prevent any network | |
249 | * device in this class from being opened. | |
8b61709d BP |
250 | * |
251 | * This function may be set to null if a network device class needs no | |
77909859 | 252 | * initialization at registration time. */ |
8b61709d BP |
253 | int (*init)(void); |
254 | ||
255 | /* Performs periodic work needed by netdevs of this class. May be null if | |
1c33f0c3 DDP |
256 | * no periodic work is necessary. |
257 | * | |
258 | * 'netdev_class' points to the class. It is useful in case the same | |
259 | * function is used to implement different classes. */ | |
260 | void (*run)(const struct netdev_class *netdev_class); | |
8b61709d BP |
261 | |
262 | /* Arranges for poll_block() to wake up if the "run" member function needs | |
ac4d3bcb EJ |
263 | * to be called. Implementations are additionally required to wake |
264 | * whenever something changes in any of its netdevs which would cause their | |
265 | * ->change_seq() function to change its result. May be null if nothing is | |
1c33f0c3 DDP |
266 | * needed here. |
267 | * | |
268 | * 'netdev_class' points to the class. It is useful in case the same | |
269 | * function is used to implement different classes. */ | |
270 | void (*wait)(const struct netdev_class *netdev_class); | |
8b61709d | 271 | |
9dc63482 BP |
272 | /* ## ---------------- ## */ |
273 | /* ## netdev Functions ## */ | |
274 | /* ## ---------------- ## */ | |
149f577a | 275 | |
9dc63482 BP |
276 | /* Life-cycle functions for a netdev. See the large comment above on |
277 | * struct netdev_class. */ | |
278 | struct netdev *(*alloc)(void); | |
279 | int (*construct)(struct netdev *); | |
280 | void (*destruct)(struct netdev *); | |
281 | void (*dealloc)(struct netdev *); | |
6c88d577 | 282 | |
b5d57fc8 | 283 | /* Fetches the device 'netdev''s configuration, storing it in 'args'. |
79f1cbe9 | 284 | * The caller owns 'args' and pre-initializes it to an empty smap. |
6c88d577 | 285 | * |
de5cdb90 BP |
286 | * If this netdev class does not have any configuration options, this may |
287 | * be a null pointer. */ | |
b5d57fc8 | 288 | int (*get_config)(const struct netdev *netdev, struct smap *args); |
6c88d577 | 289 | |
b5d57fc8 | 290 | /* Changes the device 'netdev''s configuration to 'args'. |
aebf4235 | 291 | * |
de5cdb90 | 292 | * If this netdev class does not support configuration, this may be a null |
9fff138e DDP |
293 | * pointer. |
294 | * | |
295 | * If the return value is not zero (meaning that an error occurred), | |
296 | * the provider can allocate a string with an error message in '*errp'. | |
297 | * The caller has to call free on it. */ | |
298 | int (*set_config)(struct netdev *netdev, const struct smap *args, | |
299 | char **errp); | |
aebf4235 | 300 | |
b5d57fc8 | 301 | /* Returns the tunnel configuration of 'netdev'. If 'netdev' is |
f431bf7d EJ |
302 | * not a tunnel, returns null. |
303 | * | |
304 | * If this function would always return null, it may be null instead. */ | |
305 | const struct netdev_tunnel_config * | |
b5d57fc8 | 306 | (*get_tunnel_config)(const struct netdev *netdev); |
7b6b0ef4 | 307 | |
4975aa3e PS |
308 | /* Build Tunnel header. Ethernet and ip header parameters are passed to |
309 | * tunnel implementation to build entire outer header for given flow. */ | |
c876a4bb | 310 | int (*build_header)(const struct netdev *, struct ovs_action_push_tnl *data, |
4975aa3e | 311 | const struct netdev_tnl_build_header_params *params); |
a36de779 PS |
312 | |
313 | /* build_header() can not build entire header for all packets for given | |
314 | * flow. Push header is called for packet to build header specific to | |
315 | * a packet on actual transmit. It uses partial header build by | |
316 | * build_header() which is passed as data. */ | |
754f8acb WT |
317 | void (*push_header)(const struct netdev *, |
318 | struct dp_packet *packet, | |
d625fbd1 | 319 | const struct ovs_action_push_tnl *data); |
a36de779 PS |
320 | |
321 | /* Pop tunnel header from packet, build tunnel metadata and resize packet | |
1c8f98d9 PS |
322 | * for further processing. |
323 | * Returns NULL in case of error or tunnel implementation queued packet for further | |
324 | * processing. */ | |
325 | struct dp_packet * (*pop_header)(struct dp_packet *packet); | |
a36de779 | 326 | |
7dec44fe AW |
327 | /* Returns the id of the numa node the 'netdev' is on. If there is no |
328 | * such info, returns NETDEV_NUMA_UNSPEC. */ | |
329 | int (*get_numa_id)(const struct netdev *netdev); | |
330 | ||
050c60bf DDP |
331 | /* Configures the number of tx queues of 'netdev'. Returns 0 if successful, |
332 | * otherwise a positive errno value. | |
a0cb2d66 DDP |
333 | * |
334 | * 'n_txq' specifies the exact number of transmission queues to create. | |
a0cb2d66 | 335 | * |
050c60bf DDP |
336 | * The caller will call netdev_reconfigure() (if necessary) before using |
337 | * netdev_send() on any of the newly configured queues, giving the provider | |
338 | * a chance to adjust its settings. | |
339 | * | |
340 | * On error, the tx queue configuration is unchanged. */ | |
341 | int (*set_tx_multiq)(struct netdev *netdev, unsigned int n_txq); | |
5496878c | 342 | |
f4fd623c | 343 | /* Sends buffers on 'netdev'. |
f00fa8cb AW |
344 | * Returns 0 if successful (for every buffer), otherwise a positive errno |
345 | * value. Returns EAGAIN without blocking if one or more packets cannot be | |
f4fd623c DDP |
346 | * queued immediately. Returns EMSGSIZE if a partial packet was transmitted |
347 | * or if a packet is too big or too small to transmit on the device. | |
8b61709d | 348 | * |
f4fd623c DDP |
349 | * If the function returns a non-zero value, some of the packets might have |
350 | * been sent anyway. | |
351 | * | |
b30896c9 IM |
352 | * The caller transfers ownership of all the packets to the network |
353 | * device, regardless of success. | |
8b61709d | 354 | * |
324c8374 IM |
355 | * If 'concurrent_txq' is true, the caller may perform concurrent calls |
356 | * to netdev_send() with the same 'qid'. The netdev provider is responsible | |
357 | * for making sure that these concurrent calls do not create a race | |
358 | * condition by using locking or other synchronization if required. | |
359 | * | |
f00fa8cb AW |
360 | * The network device is expected to maintain one or more packet |
361 | * transmission queues, so that the caller does not ordinarily have to | |
362 | * do additional queuing of packets. 'qid' specifies the queue to use | |
363 | * and can be ignored if the implementation does not support multiple | |
364 | * queues. | |
1ac98180 BP |
365 | * |
366 | * May return EOPNOTSUPP if a network device does not implement packet | |
367 | * transmission through this interface. This function may be set to null | |
195c8086 BP |
368 | * if it would always return EOPNOTSUPP anyhow. (This will prevent the |
369 | * network device from being usefully used by the netdev-based "userspace | |
76c308b5 BP |
370 | * datapath". It will also prevent the OVS implementation of bonding from |
371 | * working properly over 'netdev'.) */ | |
64839cf4 | 372 | int (*send)(struct netdev *netdev, int qid, struct dp_packet_batch *batch, |
b30896c9 | 373 | bool concurrent_txq); |
8b61709d BP |
374 | |
375 | /* Registers with the poll loop to wake up from the next call to | |
376 | * poll_block() when the packet transmission queue for 'netdev' has | |
377 | * sufficient room to transmit a packet with netdev_send(). | |
378 | * | |
f00fa8cb AW |
379 | * The network device is expected to maintain one or more packet |
380 | * transmission queues, so that the caller does not ordinarily have to | |
381 | * do additional queuing of packets. 'qid' specifies the queue to use | |
382 | * and can be ignored if the implementation does not support multiple | |
383 | * queues. | |
1ac98180 BP |
384 | * |
385 | * May be null if not needed, such as for a network device that does not | |
386 | * implement packet transmission through the 'send' member function. */ | |
f00fa8cb | 387 | void (*send_wait)(struct netdev *netdev, int qid); |
8b61709d BP |
388 | |
389 | /* Sets 'netdev''s Ethernet address to 'mac' */ | |
74ff3298 | 390 | int (*set_etheraddr)(struct netdev *netdev, const struct eth_addr mac); |
8b61709d | 391 | |
33f1ff84 BP |
392 | /* Retrieves 'netdev''s Ethernet address into 'mac'. |
393 | * | |
394 | * This address will be advertised as 'netdev''s MAC address through the | |
395 | * OpenFlow protocol, among other uses. */ | |
74ff3298 | 396 | int (*get_etheraddr)(const struct netdev *netdev, struct eth_addr *mac); |
8b61709d BP |
397 | |
398 | /* Retrieves 'netdev''s MTU into '*mtup'. | |
399 | * | |
400 | * The MTU is the maximum size of transmitted (and received) packets, in | |
401 | * bytes, not including the hardware header; thus, this is typically 1500 | |
f915f1a8 BP |
402 | * bytes for Ethernet devices. |
403 | * | |
404 | * If 'netdev' does not have an MTU (e.g. as some tunnels do not), then | |
14622f22 BP |
405 | * this function should return EOPNOTSUPP. This function may be set to |
406 | * null if it would always return EOPNOTSUPP. */ | |
149f577a | 407 | int (*get_mtu)(const struct netdev *netdev, int *mtup); |
8b61709d | 408 | |
9b020780 PS |
409 | /* Sets 'netdev''s MTU to 'mtu'. |
410 | * | |
411 | * If 'netdev' does not have an MTU (e.g. as some tunnels do not), then | |
14622f22 BP |
412 | * this function should return EOPNOTSUPP. This function may be set to |
413 | * null if it would always return EOPNOTSUPP. */ | |
4124cb12 | 414 | int (*set_mtu)(struct netdev *netdev, int mtu); |
9b020780 | 415 | |
9ab3d9a3 BP |
416 | /* Returns the ifindex of 'netdev', if successful, as a positive number. |
417 | * On failure, returns a negative errno value. | |
418 | * | |
419 | * The desired semantics of the ifindex value are a combination of those | |
420 | * specified by POSIX for if_nametoindex() and by SNMP for ifIndex. An | |
421 | * ifindex value should be unique within a host and remain stable at least | |
422 | * until reboot. SNMP says an ifindex "ranges between 1 and the value of | |
4c0f1780 JG |
423 | * ifNumber" but many systems do not follow this rule anyhow. |
424 | * | |
425 | * This function may be set to null if it would always return -EOPNOTSUPP. | |
426 | */ | |
149f577a | 427 | int (*get_ifindex)(const struct netdev *netdev); |
9ab3d9a3 | 428 | |
8b61709d | 429 | /* Sets 'carrier' to true if carrier is active (link light is on) on |
85da620e JG |
430 | * 'netdev'. |
431 | * | |
432 | * May be null if device does not provide carrier status (will be always | |
433 | * up as long as device is up). | |
434 | */ | |
8b61709d BP |
435 | int (*get_carrier)(const struct netdev *netdev, bool *carrier); |
436 | ||
65c3058c EJ |
437 | /* Returns the number of times 'netdev''s carrier has changed since being |
438 | * initialized. | |
439 | * | |
440 | * If null, callers will assume the number of carrier resets is zero. */ | |
441 | long long int (*get_carrier_resets)(const struct netdev *netdev); | |
442 | ||
1670c579 EJ |
443 | /* Forces ->get_carrier() to poll 'netdev''s MII registers for link status |
444 | * instead of checking 'netdev''s carrier. 'netdev''s MII registers will | |
87df2bfc | 445 | * be polled once every 'interval' milliseconds. If 'netdev' does not |
1670c579 EJ |
446 | * support MII, another method may be used as a fallback. If 'interval' is |
447 | * less than or equal to zero, reverts ->get_carrier() to its normal | |
448 | * behavior. | |
63331829 | 449 | * |
1670c579 EJ |
450 | * Most network devices won't support this feature and will set this |
451 | * function pointer to NULL, which is equivalent to returning EOPNOTSUPP. | |
63331829 | 452 | */ |
1670c579 | 453 | int (*set_miimon_interval)(struct netdev *netdev, long long int interval); |
63331829 | 454 | |
8b61709d BP |
455 | /* Retrieves current device stats for 'netdev' into 'stats'. |
456 | * | |
457 | * A network device that supports some statistics but not others, it should | |
458 | * set the values of the unsupported statistics to all-1-bits | |
459 | * (UINT64_MAX). */ | |
149f577a | 460 | int (*get_stats)(const struct netdev *netdev, struct netdev_stats *); |
8b61709d | 461 | |
971f4b39 MW |
462 | /* Retrieves current device custom stats for 'netdev' into 'custom_stats'. |
463 | * | |
464 | * A network device should return only available statistics (if any). | |
465 | * If there are not statistics available, empty array should be | |
466 | * returned. | |
467 | * | |
468 | * The caller initializes 'custom_stats' before calling this function. | |
469 | * The caller takes ownership over allocated array of counters inside | |
470 | * structure netdev_custom_stats. | |
471 | * */ | |
472 | int (*get_custom_stats)(const struct netdev *netdev, | |
473 | struct netdev_custom_stats *custom_stats); | |
474 | ||
8b61709d BP |
475 | /* Stores the features supported by 'netdev' into each of '*current', |
476 | * '*advertised', '*supported', and '*peer'. Each value is a bitmap of | |
6c038611 | 477 | * NETDEV_F_* bits. |
4c0f1780 JG |
478 | * |
479 | * This function may be set to null if it would always return EOPNOTSUPP. | |
480 | */ | |
6f2f5cce | 481 | int (*get_features)(const struct netdev *netdev, |
6c038611 BP |
482 | enum netdev_features *current, |
483 | enum netdev_features *advertised, | |
484 | enum netdev_features *supported, | |
485 | enum netdev_features *peer); | |
8b61709d BP |
486 | |
487 | /* Set the features advertised by 'netdev' to 'advertise', which is a | |
6c038611 | 488 | * set of NETDEV_F_* bits. |
8b61709d BP |
489 | * |
490 | * This function may be set to null for a network device that does not | |
491 | * support configuring advertisements. */ | |
6c038611 BP |
492 | int (*set_advertisements)(struct netdev *netdev, |
493 | enum netdev_features advertise); | |
8b61709d | 494 | |
875ab130 BP |
495 | /* Returns 'netdev''s configured packet_type mode. |
496 | * | |
497 | * This function may be set to null if it would always return | |
498 | * NETDEV_PT_LEGACY_L2. */ | |
499 | enum netdev_pt_mode (*get_pt_mode)(const struct netdev *netdev); | |
500 | ||
8b61709d BP |
501 | /* Attempts to set input rate limiting (policing) policy, such that up to |
502 | * 'kbits_rate' kbps of traffic is accepted, with a maximum accumulative | |
503 | * burst size of 'kbits' kb. | |
504 | * | |
505 | * This function may be set to null if policing is not supported. */ | |
506 | int (*set_policing)(struct netdev *netdev, unsigned int kbits_rate, | |
507 | unsigned int kbits_burst); | |
508 | ||
c1c9c9c4 BP |
509 | /* Adds to 'types' all of the forms of QoS supported by 'netdev', or leaves |
510 | * it empty if 'netdev' does not support QoS. Any names added to 'types' | |
511 | * should be documented as valid for the "type" column in the "QoS" table | |
512 | * in vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)). | |
513 | * | |
514 | * Every network device must support disabling QoS with a type of "", but | |
515 | * this function must not add "" to 'types'. | |
516 | * | |
517 | * The caller is responsible for initializing 'types' (e.g. with | |
19993ef3 BP |
518 | * sset_init()) before calling this function. The caller retains ownership |
519 | * of 'types'. | |
c1c9c9c4 BP |
520 | * |
521 | * May be NULL if 'netdev' does not support QoS at all. */ | |
19993ef3 | 522 | int (*get_qos_types)(const struct netdev *netdev, struct sset *types); |
c1c9c9c4 BP |
523 | |
524 | /* Queries 'netdev' for its capabilities regarding the specified 'type' of | |
525 | * QoS. On success, initializes 'caps' with the QoS capabilities. | |
526 | * | |
527 | * Should return EOPNOTSUPP if 'netdev' does not support 'type'. May be | |
528 | * NULL if 'netdev' does not support QoS at all. */ | |
529 | int (*get_qos_capabilities)(const struct netdev *netdev, | |
530 | const char *type, | |
531 | struct netdev_qos_capabilities *caps); | |
532 | ||
533 | /* Queries 'netdev' about its currently configured form of QoS. If | |
534 | * successful, stores the name of the current form of QoS into '*typep' | |
535 | * and any details of configuration as string key-value pairs in | |
536 | * 'details'. | |
537 | * | |
538 | * A '*typep' of "" indicates that QoS is currently disabled on 'netdev'. | |
539 | * | |
540 | * The caller initializes 'details' before calling this function. The | |
541 | * caller takes ownership of the string key-values pairs added to | |
542 | * 'details'. | |
543 | * | |
544 | * The netdev retains ownership of '*typep'. | |
545 | * | |
546 | * '*typep' will be one of the types returned by netdev_get_qos_types() for | |
547 | * 'netdev'. The contents of 'details' should be documented as valid for | |
548 | * '*typep' in the "other_config" column in the "QoS" table in | |
549 | * vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)). | |
550 | * | |
551 | * May be NULL if 'netdev' does not support QoS at all. */ | |
552 | int (*get_qos)(const struct netdev *netdev, | |
79f1cbe9 | 553 | const char **typep, struct smap *details); |
c1c9c9c4 BP |
554 | |
555 | /* Attempts to reconfigure QoS on 'netdev', changing the form of QoS to | |
556 | * 'type' with details of configuration from 'details'. | |
557 | * | |
558 | * On error, the previous QoS configuration is retained. | |
559 | * | |
560 | * When this function changes the type of QoS (not just 'details'), this | |
561 | * also resets all queue configuration for 'netdev' to their defaults | |
562 | * (which depend on the specific type of QoS). Otherwise, the queue | |
563 | * configuration for 'netdev' is unchanged. | |
564 | * | |
565 | * 'type' should be "" (to disable QoS) or one of the types returned by | |
566 | * netdev_get_qos_types() for 'netdev'. The contents of 'details' should | |
567 | * be documented as valid for the given 'type' in the "other_config" column | |
568 | * in the "QoS" table in vswitchd/vswitch.xml (which is built as | |
569 | * ovs-vswitchd.conf.db(8)). | |
570 | * | |
571 | * May be NULL if 'netdev' does not support QoS at all. */ | |
572 | int (*set_qos)(struct netdev *netdev, | |
79f1cbe9 | 573 | const char *type, const struct smap *details); |
c1c9c9c4 BP |
574 | |
575 | /* Queries 'netdev' for information about the queue numbered 'queue_id'. | |
576 | * If successful, adds that information as string key-value pairs to | |
577 | * 'details'. Returns 0 if successful, otherwise a positive errno value. | |
578 | * | |
579 | * Should return EINVAL if 'queue_id' is greater than or equal to the | |
580 | * number of supported queues (as reported in the 'n_queues' member of | |
581 | * struct netdev_qos_capabilities by 'get_qos_capabilities'). | |
582 | * | |
583 | * The caller initializes 'details' before calling this function. The | |
584 | * caller takes ownership of the string key-values pairs added to | |
585 | * 'details'. | |
586 | * | |
587 | * The returned contents of 'details' should be documented as valid for the | |
588 | * given 'type' in the "other_config" column in the "Queue" table in | |
589 | * vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)). | |
590 | */ | |
591 | int (*get_queue)(const struct netdev *netdev, | |
79f1cbe9 | 592 | unsigned int queue_id, struct smap *details); |
c1c9c9c4 BP |
593 | |
594 | /* Configures the queue numbered 'queue_id' on 'netdev' with the key-value | |
595 | * string pairs in 'details'. The contents of 'details' should be | |
596 | * documented as valid for the given 'type' in the "other_config" column in | |
597 | * the "Queue" table in vswitchd/vswitch.xml (which is built as | |
598 | * ovs-vswitchd.conf.db(8)). Returns 0 if successful, otherwise a positive | |
599 | * errno value. On failure, the given queue's configuration should be | |
600 | * unmodified. | |
601 | * | |
602 | * Should return EINVAL if 'queue_id' is greater than or equal to the | |
603 | * number of supported queues (as reported in the 'n_queues' member of | |
604 | * struct netdev_qos_capabilities by 'get_qos_capabilities'), or if | |
605 | * 'details' is invalid for the type of queue. | |
606 | * | |
607 | * This function does not modify 'details', and the caller retains | |
608 | * ownership of it. | |
609 | * | |
610 | * May be NULL if 'netdev' does not support QoS at all. */ | |
611 | int (*set_queue)(struct netdev *netdev, | |
79f1cbe9 | 612 | unsigned int queue_id, const struct smap *details); |
c1c9c9c4 BP |
613 | |
614 | /* Attempts to delete the queue numbered 'queue_id' from 'netdev'. | |
615 | * | |
616 | * Should return EINVAL if 'queue_id' is greater than or equal to the | |
617 | * number of supported queues (as reported in the 'n_queues' member of | |
618 | * struct netdev_qos_capabilities by 'get_qos_capabilities'). Should | |
619 | * return EOPNOTSUPP if 'queue_id' is valid but may not be deleted (e.g. if | |
620 | * 'netdev' has a fixed set of queues with the current QoS mode). | |
621 | * | |
622 | * May be NULL if 'netdev' does not support QoS at all, or if all of its | |
623 | * QoS modes have fixed sets of queues. */ | |
624 | int (*delete_queue)(struct netdev *netdev, unsigned int queue_id); | |
625 | ||
626 | /* Obtains statistics about 'queue_id' on 'netdev'. Fills 'stats' with the | |
627 | * queue's statistics. May set individual members of 'stats' to all-1-bits | |
628 | * if the statistic is unavailable. | |
629 | * | |
630 | * May be NULL if 'netdev' does not support QoS at all. */ | |
631 | int (*get_queue_stats)(const struct netdev *netdev, unsigned int queue_id, | |
632 | struct netdev_queue_stats *stats); | |
633 | ||
89454bf4 BP |
634 | /* Attempts to begin dumping the queues in 'netdev'. On success, returns 0 |
635 | * and initializes '*statep' with any data needed for iteration. On | |
636 | * failure, returns a positive errno value. | |
637 | * | |
638 | * May be NULL if 'netdev' does not support QoS at all. */ | |
639 | int (*queue_dump_start)(const struct netdev *netdev, void **statep); | |
640 | ||
641 | /* Attempts to retrieve another queue from 'netdev' for 'state', which was | |
642 | * initialized by a successful call to the 'queue_dump_start' function for | |
643 | * 'netdev'. On success, stores a queue ID into '*queue_id' and fills | |
644 | * 'details' with the configuration of the queue with that ID. Returns EOF | |
645 | * if the last queue has been dumped, or a positive errno value on error. | |
646 | * This function will not be called again once it returns nonzero once for | |
647 | * a given iteration (but the 'queue_dump_done' function will be called | |
648 | * afterward). | |
649 | * | |
650 | * The caller initializes and clears 'details' before calling this | |
651 | * function. The caller takes ownership of the string key-values pairs | |
652 | * added to 'details'. | |
653 | * | |
654 | * The returned contents of 'details' should be documented as valid for the | |
655 | * given 'type' in the "other_config" column in the "Queue" table in | |
656 | * vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)). | |
657 | * | |
658 | * May be NULL if 'netdev' does not support QoS at all. */ | |
659 | int (*queue_dump_next)(const struct netdev *netdev, void *state, | |
660 | unsigned int *queue_id, struct smap *details); | |
661 | ||
662 | /* Releases resources from 'netdev' for 'state', which was initialized by a | |
663 | * successful call to the 'queue_dump_start' function for 'netdev'. | |
664 | * | |
665 | * May be NULL if 'netdev' does not support QoS at all. */ | |
666 | int (*queue_dump_done)(const struct netdev *netdev, void *state); | |
c1c9c9c4 BP |
667 | |
668 | /* Iterates over all of 'netdev''s queues, calling 'cb' with the queue's | |
669 | * ID, its statistics, and the 'aux' specified by the caller. The order of | |
670 | * iteration is unspecified, but (when successful) each queue must be | |
671 | * visited exactly once. | |
672 | * | |
673 | * 'cb' will not modify or free the statistics passed in. */ | |
674 | int (*dump_queue_stats)(const struct netdev *netdev, | |
675 | void (*cb)(unsigned int queue_id, | |
676 | struct netdev_queue_stats *, | |
677 | void *aux), | |
678 | void *aux); | |
679 | ||
8b61709d BP |
680 | /* Assigns 'addr' as 'netdev''s IPv4 address and 'mask' as its netmask. If |
681 | * 'addr' is INADDR_ANY, 'netdev''s IPv4 address is cleared. | |
682 | * | |
683 | * This function may be set to null if it would always return EOPNOTSUPP | |
684 | * anyhow. */ | |
149f577a JG |
685 | int (*set_in4)(struct netdev *netdev, struct in_addr addr, |
686 | struct in_addr mask); | |
8b61709d | 687 | |
a8704b50 PS |
688 | /* Returns all assigned IP address to 'netdev' and returns 0. |
689 | * API allocates array of address and masks and set it to | |
690 | * '*addr' and '*mask'. | |
691 | * Otherwise, returns a positive errno value and sets '*addr', '*mask | |
692 | * and '*n_addr' to NULL. | |
8b61709d BP |
693 | * |
694 | * The following error values have well-defined meanings: | |
695 | * | |
696 | * - EADDRNOTAVAIL: 'netdev' has no assigned IPv6 address. | |
697 | * | |
698 | * - EOPNOTSUPP: No IPv6 network stack attached to 'netdev'. | |
699 | * | |
a8704b50 PS |
700 | * 'addr' may be null, in which case the address itself is not reported. */ |
701 | int (*get_addr_list)(const struct netdev *netdev, struct in6_addr **in, | |
702 | struct in6_addr **mask, int *n_in6); | |
8b61709d BP |
703 | |
704 | /* Adds 'router' as a default IP gateway for the TCP/IP stack that | |
705 | * corresponds to 'netdev'. | |
706 | * | |
707 | * This function may be set to null if it would always return EOPNOTSUPP | |
708 | * anyhow. */ | |
709 | int (*add_router)(struct netdev *netdev, struct in_addr router); | |
710 | ||
c27fd2f9 BP |
711 | /* Looks up the next hop for 'host' in the host's routing table. If |
712 | * successful, stores the next hop gateway's address (0 if 'host' is on a | |
713 | * directly connected network) in '*next_hop' and a copy of the name of the | |
714 | * device to reach 'host' in '*netdev_name', and returns 0. The caller is | |
715 | * responsible for freeing '*netdev_name' (by calling free()). | |
f1acd62b BP |
716 | * |
717 | * This function may be set to null if it would always return EOPNOTSUPP | |
718 | * anyhow. */ | |
719 | int (*get_next_hop)(const struct in_addr *host, struct in_addr *next_hop, | |
720 | char **netdev_name); | |
721 | ||
2c2ea5a8 | 722 | /* Retrieves driver information of the device. |
ea763e0e | 723 | * |
275707c3 EJ |
724 | * Populates 'smap' with key-value pairs representing the status of the |
725 | * device. 'smap' is a set of key-value string pairs representing netdev | |
726 | * type specific information. For more information see | |
ea763e0e EJ |
727 | * ovs-vswitchd.conf.db(5). |
728 | * | |
79f1cbe9 | 729 | * The caller is responsible for destroying 'smap' and its data. |
ea763e0e EJ |
730 | * |
731 | * This function may be set to null if it would always return EOPNOTSUPP | |
732 | * anyhow. */ | |
275707c3 | 733 | int (*get_status)(const struct netdev *netdev, struct smap *smap); |
ea83a2fc | 734 | |
8b61709d BP |
735 | /* Looks up the ARP table entry for 'ip' on 'netdev' and stores the |
736 | * corresponding MAC address in 'mac'. A return value of ENXIO, in | |
737 | * particular, indicates that there is no ARP table entry for 'ip' on | |
738 | * 'netdev'. | |
739 | * | |
740 | * This function may be set to null if it would always return EOPNOTSUPP | |
741 | * anyhow. */ | |
dbba996b | 742 | int (*arp_lookup)(const struct netdev *netdev, ovs_be32 ip, |
74ff3298 | 743 | struct eth_addr *mac); |
8b61709d | 744 | |
b5d57fc8 | 745 | /* Retrieves the current set of flags on 'netdev' into '*old_flags'. Then, |
4b609110 BP |
746 | * turns off the flags that are set to 1 in 'off' and turns on the flags |
747 | * that are set to 1 in 'on'. (No bit will be set to 1 in both 'off' and | |
748 | * 'on'; that is, off & on == 0.) | |
8b61709d BP |
749 | * |
750 | * This function may be invoked from a signal handler. Therefore, it | |
751 | * should not do anything that is not signal-safe (such as logging). */ | |
b5d57fc8 | 752 | int (*update_flags)(struct netdev *netdev, enum netdev_flags off, |
8b61709d BP |
753 | enum netdev_flags on, enum netdev_flags *old_flags); |
754 | ||
790fb3b7 DDP |
755 | /* If the provider called netdev_request_reconfigure(), the upper layer |
756 | * will eventually call this. The provider can update the device | |
757 | * configuration knowing that the upper layer will not call rxq_recv() or | |
758 | * send() until this function returns. | |
759 | * | |
760 | * On error, the configuration is indeterminant and the device cannot be | |
761 | * used to send and receive packets until a successful configuration is | |
762 | * applied. */ | |
763 | int (*reconfigure)(struct netdev *netdev); | |
f7791740 PS |
764 | /* ## -------------------- ## */ |
765 | /* ## netdev_rxq Functions ## */ | |
766 | /* ## -------------------- ## */ | |
9dc63482 BP |
767 | |
768 | /* If a particular netdev class does not support receiving packets, all these | |
769 | * function pointers must be NULL. */ | |
796223f5 | 770 | |
f7791740 | 771 | /* Life-cycle functions for a netdev_rxq. See the large comment above on |
9dc63482 | 772 | * struct netdev_class. */ |
f7791740 PS |
773 | struct netdev_rxq *(*rxq_alloc)(void); |
774 | int (*rxq_construct)(struct netdev_rxq *); | |
775 | void (*rxq_destruct)(struct netdev_rxq *); | |
776 | void (*rxq_dealloc)(struct netdev_rxq *); | |
796223f5 | 777 | |
64839cf4 WT |
778 | /* Attempts to receive a batch of packets from 'rx'. In 'batch', the |
779 | * caller supplies 'packets' as the pointer to the beginning of an array | |
c90e4d9c MK |
780 | * of NETDEV_MAX_BURST pointers to dp_packet. If successful, the |
781 | * implementation stores pointers to up to NETDEV_MAX_BURST dp_packets into | |
64839cf4 WT |
782 | * the array, transferring ownership of the packets to the caller, stores |
783 | * the number of received packets into 'count', and returns 0. | |
e175dc83 BP |
784 | * |
785 | * The implementation does not necessarily initialize any non-data members | |
64839cf4 WT |
786 | * of 'packets' in 'batch'. That is, the caller must initialize layer |
787 | * pointers and metadata itself, if desired, e.g. with pkt_metadata_init() | |
788 | * and miniflow_extract(). | |
e175dc83 BP |
789 | * |
790 | * Implementations should allocate buffers with DP_NETDEV_HEADROOM bytes of | |
791 | * headroom. | |
792 | * | |
8492adc2 JS |
793 | * If the caller provides a non-NULL qfill pointer, the implementation |
794 | * should return the number (zero or more) of remaining packets in the | |
795 | * queue after the reception the current batch, if it supports that, | |
796 | * or -ENOTSUP otherwise. | |
797 | * | |
e175dc83 BP |
798 | * Returns EAGAIN immediately if no packet is ready to be received or |
799 | * another positive errno value if an error was encountered. */ | |
8492adc2 JS |
800 | int (*rxq_recv)(struct netdev_rxq *rx, struct dp_packet_batch *batch, |
801 | int *qfill); | |
796223f5 BP |
802 | |
803 | /* Registers with the poll loop to wake up from the next call to | |
e175dc83 BP |
804 | * poll_block() when a packet is ready to be received with |
805 | * netdev_rxq_recv() on 'rx'. */ | |
f7791740 | 806 | void (*rxq_wait)(struct netdev_rxq *rx); |
796223f5 BP |
807 | |
808 | /* Discards all packets waiting to be received from 'rx'. */ | |
f7791740 | 809 | int (*rxq_drain)(struct netdev_rxq *rx); |
18ebd48c PB |
810 | |
811 | /* ## -------------------------------- ## */ | |
812 | /* ## netdev flow offloading functions ## */ | |
813 | /* ## -------------------------------- ## */ | |
814 | ||
815 | /* If a particular netdev class does not support offloading flows, | |
816 | * all these function pointers must be NULL. */ | |
817 | ||
818 | /* Flush all offloaded flows from a netdev. | |
819 | * Return 0 if successful, otherwise returns a positive errno value. */ | |
820 | int (*flow_flush)(struct netdev *); | |
821 | ||
822 | /* Flow dumping interface. | |
823 | * | |
824 | * This is the back-end for the flow dumping interface described in | |
825 | * dpif.h. Please read the comments there first, because this code | |
826 | * closely follows it. | |
827 | * | |
828 | * On success returns 0 and allocates data, on failure returns | |
829 | * positive errno. */ | |
830 | int (*flow_dump_create)(struct netdev *, struct netdev_flow_dump **dump); | |
831 | int (*flow_dump_destroy)(struct netdev_flow_dump *); | |
832 | ||
833 | /* Returns true if there are more flows to dump. | |
834 | * 'rbuffer' is used as a temporary buffer and needs to be pre allocated | |
835 | * by the caller. While there are more flows the same 'rbuffer' | |
836 | * should be provided. 'wbuffer' is used to store dumped actions and needs | |
837 | * to be pre allocated by the caller. */ | |
838 | bool (*flow_dump_next)(struct netdev_flow_dump *, struct match *, | |
839 | struct nlattr **actions, | |
d63ca532 GT |
840 | struct dpif_flow_stats *stats, |
841 | struct dpif_flow_attrs *attrs, ovs_u128 *ufid, | |
18ebd48c PB |
842 | struct ofpbuf *rbuffer, struct ofpbuf *wbuffer); |
843 | ||
844 | /* Offload the given flow on netdev. | |
845 | * To modify a flow, use the same ufid. | |
846 | * 'actions' are in netlink format, as with struct dpif_flow_put. | |
847 | * 'info' is extra info needed to offload the flow. | |
848 | * 'stats' is populated according to the rules set out in the description | |
849 | * above 'struct dpif_flow_put'. | |
850 | * Return 0 if successful, otherwise returns a positive errno value. */ | |
851 | int (*flow_put)(struct netdev *, struct match *, struct nlattr *actions, | |
852 | size_t actions_len, const ovs_u128 *ufid, | |
853 | struct offload_info *info, struct dpif_flow_stats *); | |
854 | ||
855 | /* Queries a flow specified by ufid on netdev. | |
856 | * Fills output buffer as 'wbuffer' in flow_dump_next, which | |
857 | * needs to be be pre allocated. | |
858 | * Return 0 if successful, otherwise returns a positive errno value. */ | |
859 | int (*flow_get)(struct netdev *, struct match *, struct nlattr **actions, | |
860 | const ovs_u128 *ufid, struct dpif_flow_stats *, | |
d63ca532 | 861 | struct dpif_flow_attrs *, struct ofpbuf *wbuffer); |
18ebd48c PB |
862 | |
863 | /* Delete a flow specified by ufid from netdev. | |
864 | * 'stats' is populated according to the rules set out in the description | |
865 | * above 'struct dpif_flow_del'. | |
866 | * Return 0 if successful, otherwise returns a positive errno value. */ | |
867 | int (*flow_del)(struct netdev *, const ovs_u128 *ufid, | |
868 | struct dpif_flow_stats *); | |
869 | ||
870 | /* Initializies the netdev flow api. | |
871 | * Return 0 if successful, otherwise returns a positive errno value. */ | |
872 | int (*init_flow_api)(struct netdev *); | |
88dcf2aa JH |
873 | |
874 | /* Get a block_id from the netdev. | |
875 | * Returns the block_id or 0 if none exists for netdev. */ | |
876 | uint32_t (*get_block_id)(struct netdev *); | |
796223f5 BP |
877 | }; |
878 | ||
2b9d6589 BP |
879 | int netdev_register_provider(const struct netdev_class *); |
880 | int netdev_unregister_provider(const char *type); | |
881 | ||
666afb55 | 882 | #if defined(__FreeBSD__) || defined(__NetBSD__) |
f6eb6b20 | 883 | extern const struct netdev_class netdev_bsd_class; |
078eedf4 NR |
884 | #elif defined(_WIN32) |
885 | extern const struct netdev_class netdev_windows_class; | |
886 | #else | |
887 | extern const struct netdev_class netdev_linux_class; | |
f6eb6b20 | 888 | #endif |
078eedf4 NR |
889 | extern const struct netdev_class netdev_internal_class; |
890 | extern const struct netdev_class netdev_tap_class; | |
8b61709d | 891 | |
6dfd0304 BP |
892 | #ifdef __cplusplus |
893 | } | |
894 | #endif | |
895 | ||
8b61709d | 896 | #endif /* netdev.h */ |