ofp-util: Avoid use-after-free in ofputil_encode_flow_mod().
[openvswitch] / lib / netdev-provider.h
1 /*
2  * Copyright (c) 2009, 2010, 2011, 2012 Nicira, Inc.
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
22 #include <assert.h>
23
24 #include "netdev.h"
25 #include "list.h"
26 #include "shash.h"
27 #include "smap.h"
28
29 #ifdef  __cplusplus
30 extern "C" {
31 #endif
32
33 /* A network device (e.g. an Ethernet device).
34  *
35  * This structure should be treated as opaque by network device
36  * implementations. */
37 struct netdev_dev {
38     char *name;                         /* Name of network device. */
39     const struct netdev_class *netdev_class; /* Functions to control
40                                                 this device. */
41     int ref_cnt;                        /* Times this devices was opened. */
42     struct shash_node *node;            /* Pointer to element in global map. */
43 };
44
45 void netdev_dev_init(struct netdev_dev *, const char *name,
46                      const struct netdev_class *);
47 void netdev_dev_uninit(struct netdev_dev *, bool destroy);
48 const char *netdev_dev_get_type(const struct netdev_dev *);
49 const struct netdev_class *netdev_dev_get_class(const struct netdev_dev *);
50 const char *netdev_dev_get_name(const struct netdev_dev *);
51 struct netdev_dev *netdev_dev_from_name(const char *name);
52 void netdev_dev_get_devices(const struct netdev_class *,
53                             struct shash *device_list);
54
55 static inline void netdev_dev_assert_class(const struct netdev_dev *netdev_dev,
56                                            const struct netdev_class *class_)
57 {
58     assert(netdev_dev->netdev_class == class_);
59 }
60
61 /* A instance of an open network device.
62  *
63  * This structure should be treated as opaque by network device
64  * implementations. */
65 struct netdev {
66     struct netdev_dev *netdev_dev;   /* Parent netdev_dev. */
67     struct list node;                /* Element in global list. */
68
69     enum netdev_flags save_flags;    /* Initial device flags. */
70     enum netdev_flags changed_flags; /* Flags that we changed. */
71 };
72
73 void netdev_init(struct netdev *, struct netdev_dev *);
74 void netdev_uninit(struct netdev *, bool close);
75 struct netdev_dev *netdev_get_dev(const struct netdev *);
76
77 static inline void netdev_assert_class(const struct netdev *netdev,
78                                        const struct netdev_class *netdev_class)
79 {
80     netdev_dev_assert_class(netdev_get_dev(netdev), netdev_class);
81 }
82
83 /* Network device class structure, to be defined by each implementation of a
84  * network device.
85  *
86  * These functions return 0 if successful or a positive errno value on failure,
87  * except where otherwise noted. */
88 struct netdev_class {
89     /* Type of netdevs in this class, e.g. "system", "tap", "gre", etc.
90      *
91      * One of the providers should supply a "system" type, since this is
92      * the type assumed if no type is specified when opening a netdev.
93      * The "system" type corresponds to an existing network device on
94      * the system. */
95     const char *type;
96
97     /* Called when the netdev provider is registered, typically at program
98      * startup.  Returning an error from this function will prevent any network
99      * device in this class from being opened.
100      *
101      * This function may be set to null if a network device class needs no
102      * initialization at registration time. */
103     int (*init)(void);
104
105     /* Performs periodic work needed by netdevs of this class.  May be null if
106      * no periodic work is necessary. */
107     void (*run)(void);
108
109     /* Arranges for poll_block() to wake up if the "run" member function needs
110      * to be called.  Implementations are additionally required to wake
111      * whenever something changes in any of its netdevs which would cause their
112      * ->change_seq() function to change its result.  May be null if nothing is
113      * needed here. */
114     void (*wait)(void);
115
116     /* Attempts to create a network device named 'name' in 'netdev_class'.  On
117      * success sets 'netdev_devp' to the newly created device. */
118     int (*create)(const struct netdev_class *netdev_class, const char *name,
119                   struct netdev_dev **netdev_devp);
120
121     /* Destroys 'netdev_dev'.
122      *
123      * Netdev devices maintain a reference count that is incremented on
124      * netdev_open() and decremented on netdev_close().  If 'netdev_dev'
125      * has a non-zero reference count, then this function will not be
126      * called. */
127     void (*destroy)(struct netdev_dev *netdev_dev);
128
129     /* Fetches the device 'netdev_dev''s configuration, storing it in 'args'.
130      * The caller owns 'args' and pre-initializes it to an empty smap.
131      *
132      * If this netdev class does not have any configuration options, this may
133      * be a null pointer. */
134     int (*get_config)(struct netdev_dev *netdev_dev, struct smap *args);
135
136     /* Changes the device 'netdev_dev''s configuration to 'args'.
137      *
138      * If this netdev class does not support configuration, this may be a null
139      * pointer. */
140     int (*set_config)(struct netdev_dev *netdev_dev, const struct smap *args);
141
142     /* Attempts to open a network device.  On success, sets 'netdevp'
143      * to the new network device. */
144     int (*open)(struct netdev_dev *netdev_dev, struct netdev **netdevp);
145
146     /* Closes 'netdev'. */
147     void (*close)(struct netdev *netdev);
148 \f
149 /* ## ----------------- ## */
150 /* ## Receiving Packets ## */
151 /* ## ----------------- ## */
152
153 /* The network provider interface is mostly used for inspecting and configuring
154  * device "metadata", not for sending and receiving packets directly.  It may
155  * be impractical to implement these functions on some operating systems and
156  * hardware.  These functions may all be NULL in such cases.
157  *
158  * (However, the "dpif-netdev" implementation, which is the easiest way to
159  * integrate Open vSwitch with a new operating system or hardware, does require
160  * the ability to receive packets.) */
161
162     /* Attempts to set up 'netdev' for receiving packets with ->recv().
163      * Returns 0 if successful, otherwise a positive errno value.  Return
164      * EOPNOTSUPP to indicate that the network device does not implement packet
165      * reception through this interface.  This function may be set to null if
166      * it would always return EOPNOTSUPP anyhow.  (This will prevent the
167      * network device from being usefully used by the netdev-based "userspace
168      * datapath".)*/
169     int (*listen)(struct netdev *netdev);
170
171     /* Attempts to receive a packet from 'netdev' into the 'size' bytes in
172      * 'buffer'.  If successful, returns the number of bytes in the received
173      * packet, otherwise a negative errno value.  Returns -EAGAIN immediately
174      * if no packet is ready to be received.
175      *
176      * Returns -EMSGSIZE, and discards the packet, if the received packet is
177      * longer than 'size' bytes.
178      *
179      * This function can only be expected to return a packet if ->listen() has
180      * been called successfully.
181      *
182      * May be null if not needed, such as for a network device that does not
183      * implement packet reception through the 'recv' member function. */
184     int (*recv)(struct netdev *netdev, void *buffer, size_t size);
185
186     /* Registers with the poll loop to wake up from the next call to
187      * poll_block() when a packet is ready to be received with netdev_recv() on
188      * 'netdev'.
189      *
190      * May be null if not needed, such as for a network device that does not
191      * implement packet reception through the 'recv' member function. */
192     void (*recv_wait)(struct netdev *netdev);
193
194     /* Discards all packets waiting to be received from 'netdev'.
195      *
196      * May be null if not needed, such as for a network device that does not
197      * implement packet reception through the 'recv' member function. */
198     int (*drain)(struct netdev *netdev);
199 \f
200     /* Sends the 'size'-byte packet in 'buffer' on 'netdev'.  Returns 0 if
201      * successful, otherwise a positive errno value.  Returns EAGAIN without
202      * blocking if the packet cannot be queued immediately.  Returns EMSGSIZE
203      * if a partial packet was transmitted or if the packet is too big or too
204      * small to transmit on the device.
205      *
206      * The caller retains ownership of 'buffer' in all cases.
207      *
208      * The network device is expected to maintain a packet transmission queue,
209      * so that the caller does not ordinarily have to do additional queuing of
210      * packets.
211      *
212      * May return EOPNOTSUPP if a network device does not implement packet
213      * transmission through this interface.  This function may be set to null
214      * if it would always return EOPNOTSUPP anyhow.  (This will prevent the
215      * network device from being usefully used by the netdev-based "userspace
216      * datapath".  It will also prevent the OVS implementation of bonding from
217      * working properly over 'netdev'.) */
218     int (*send)(struct netdev *netdev, const void *buffer, size_t size);
219
220     /* Registers with the poll loop to wake up from the next call to
221      * poll_block() when the packet transmission queue for 'netdev' has
222      * sufficient room to transmit a packet with netdev_send().
223      *
224      * The network device is expected to maintain a packet transmission queue,
225      * so that the caller does not ordinarily have to do additional queuing of
226      * packets.  Thus, this function is unlikely to ever be useful.
227      *
228      * May be null if not needed, such as for a network device that does not
229      * implement packet transmission through the 'send' member function. */
230     void (*send_wait)(struct netdev *netdev);
231
232     /* Sets 'netdev''s Ethernet address to 'mac' */
233     int (*set_etheraddr)(struct netdev *netdev, const uint8_t mac[6]);
234
235     /* Retrieves 'netdev''s Ethernet address into 'mac'.
236      *
237      * This address will be advertised as 'netdev''s MAC address through the
238      * OpenFlow protocol, among other uses. */
239     int (*get_etheraddr)(const struct netdev *netdev, uint8_t mac[6]);
240
241     /* Retrieves 'netdev''s MTU into '*mtup'.
242      *
243      * The MTU is the maximum size of transmitted (and received) packets, in
244      * bytes, not including the hardware header; thus, this is typically 1500
245      * bytes for Ethernet devices.
246      *
247      * If 'netdev' does not have an MTU (e.g. as some tunnels do not), then
248      * this function should return EOPNOTSUPP.  This function may be set to
249      * null if it would always return EOPNOTSUPP. */
250     int (*get_mtu)(const struct netdev *netdev, int *mtup);
251
252     /* Sets 'netdev''s MTU to 'mtu'.
253      *
254      * If 'netdev' does not have an MTU (e.g. as some tunnels do not), then
255      * this function should return EOPNOTSUPP.  This function may be set to
256      * null if it would always return EOPNOTSUPP. */
257     int (*set_mtu)(const struct netdev *netdev, int mtu);
258
259     /* Returns the ifindex of 'netdev', if successful, as a positive number.
260      * On failure, returns a negative errno value.
261      *
262      * The desired semantics of the ifindex value are a combination of those
263      * specified by POSIX for if_nametoindex() and by SNMP for ifIndex.  An
264      * ifindex value should be unique within a host and remain stable at least
265      * until reboot.  SNMP says an ifindex "ranges between 1 and the value of
266      * ifNumber" but many systems do not follow this rule anyhow.
267      *
268      * This function may be set to null if it would always return -EOPNOTSUPP.
269      */
270     int (*get_ifindex)(const struct netdev *netdev);
271
272     /* Sets 'carrier' to true if carrier is active (link light is on) on
273      * 'netdev'.
274      *
275      * May be null if device does not provide carrier status (will be always
276      * up as long as device is up).
277      */
278     int (*get_carrier)(const struct netdev *netdev, bool *carrier);
279
280     /* Returns the number of times 'netdev''s carrier has changed since being
281      * initialized.
282      *
283      * If null, callers will assume the number of carrier resets is zero. */
284     long long int (*get_carrier_resets)(const struct netdev *netdev);
285
286     /* Forces ->get_carrier() to poll 'netdev''s MII registers for link status
287      * instead of checking 'netdev''s carrier.  'netdev''s MII registers will
288      * be polled once ever 'interval' milliseconds.  If 'netdev' does not
289      * support MII, another method may be used as a fallback.  If 'interval' is
290      * less than or equal to zero, reverts ->get_carrier() to its normal
291      * behavior.
292      *
293      * Most network devices won't support this feature and will set this
294      * function pointer to NULL, which is equivalent to returning EOPNOTSUPP.
295      */
296     int (*set_miimon_interval)(struct netdev *netdev, long long int interval);
297
298     /* Retrieves current device stats for 'netdev' into 'stats'.
299      *
300      * A network device that supports some statistics but not others, it should
301      * set the values of the unsupported statistics to all-1-bits
302      * (UINT64_MAX). */
303     int (*get_stats)(const struct netdev *netdev, struct netdev_stats *);
304
305     /* Sets the device stats for 'netdev' to 'stats'.
306      *
307      * Most network devices won't support this feature and will set this
308      * function pointer to NULL, which is equivalent to returning EOPNOTSUPP.
309      *
310      * Some network devices might only allow setting their stats to 0. */
311     int (*set_stats)(struct netdev *netdev, const struct netdev_stats *);
312
313     /* Stores the features supported by 'netdev' into each of '*current',
314      * '*advertised', '*supported', and '*peer'.  Each value is a bitmap of
315      * NETDEV_F_* bits.
316      *
317      * This function may be set to null if it would always return EOPNOTSUPP.
318      */
319     int (*get_features)(const struct netdev *netdev,
320                         enum netdev_features *current,
321                         enum netdev_features *advertised,
322                         enum netdev_features *supported,
323                         enum netdev_features *peer);
324
325     /* Set the features advertised by 'netdev' to 'advertise', which is a
326      * set of NETDEV_F_* bits.
327      *
328      * This function may be set to null for a network device that does not
329      * support configuring advertisements. */
330     int (*set_advertisements)(struct netdev *netdev,
331                               enum netdev_features advertise);
332
333     /* Attempts to set input rate limiting (policing) policy, such that up to
334      * 'kbits_rate' kbps of traffic is accepted, with a maximum accumulative
335      * burst size of 'kbits' kb.
336      *
337      * This function may be set to null if policing is not supported. */
338     int (*set_policing)(struct netdev *netdev, unsigned int kbits_rate,
339                         unsigned int kbits_burst);
340
341     /* Adds to 'types' all of the forms of QoS supported by 'netdev', or leaves
342      * it empty if 'netdev' does not support QoS.  Any names added to 'types'
343      * should be documented as valid for the "type" column in the "QoS" table
344      * in vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
345      *
346      * Every network device must support disabling QoS with a type of "", but
347      * this function must not add "" to 'types'.
348      *
349      * The caller is responsible for initializing 'types' (e.g. with
350      * sset_init()) before calling this function.  The caller retains ownership
351      * of 'types'.
352      *
353      * May be NULL if 'netdev' does not support QoS at all. */
354     int (*get_qos_types)(const struct netdev *netdev, struct sset *types);
355
356     /* Queries 'netdev' for its capabilities regarding the specified 'type' of
357      * QoS.  On success, initializes 'caps' with the QoS capabilities.
358      *
359      * Should return EOPNOTSUPP if 'netdev' does not support 'type'.  May be
360      * NULL if 'netdev' does not support QoS at all. */
361     int (*get_qos_capabilities)(const struct netdev *netdev,
362                                 const char *type,
363                                 struct netdev_qos_capabilities *caps);
364
365     /* Queries 'netdev' about its currently configured form of QoS.  If
366      * successful, stores the name of the current form of QoS into '*typep'
367      * and any details of configuration as string key-value pairs in
368      * 'details'.
369      *
370      * A '*typep' of "" indicates that QoS is currently disabled on 'netdev'.
371      *
372      * The caller initializes 'details' before calling this function.  The
373      * caller takes ownership of the string key-values pairs added to
374      * 'details'.
375      *
376      * The netdev retains ownership of '*typep'.
377      *
378      * '*typep' will be one of the types returned by netdev_get_qos_types() for
379      * 'netdev'.  The contents of 'details' should be documented as valid for
380      * '*typep' in the "other_config" column in the "QoS" table in
381      * vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
382      *
383      * May be NULL if 'netdev' does not support QoS at all. */
384     int (*get_qos)(const struct netdev *netdev,
385                    const char **typep, struct smap *details);
386
387     /* Attempts to reconfigure QoS on 'netdev', changing the form of QoS to
388      * 'type' with details of configuration from 'details'.
389      *
390      * On error, the previous QoS configuration is retained.
391      *
392      * When this function changes the type of QoS (not just 'details'), this
393      * also resets all queue configuration for 'netdev' to their defaults
394      * (which depend on the specific type of QoS).  Otherwise, the queue
395      * configuration for 'netdev' is unchanged.
396      *
397      * 'type' should be "" (to disable QoS) or one of the types returned by
398      * netdev_get_qos_types() for 'netdev'.  The contents of 'details' should
399      * be documented as valid for the given 'type' in the "other_config" column
400      * in the "QoS" table in vswitchd/vswitch.xml (which is built as
401      * ovs-vswitchd.conf.db(8)).
402      *
403      * May be NULL if 'netdev' does not support QoS at all. */
404     int (*set_qos)(struct netdev *netdev,
405                    const char *type, const struct smap *details);
406
407     /* Queries 'netdev' for information about the queue numbered 'queue_id'.
408      * If successful, adds that information as string key-value pairs to
409      * 'details'.  Returns 0 if successful, otherwise a positive errno value.
410      *
411      * Should return EINVAL if 'queue_id' is greater than or equal to the
412      * number of supported queues (as reported in the 'n_queues' member of
413      * struct netdev_qos_capabilities by 'get_qos_capabilities').
414      *
415      * The caller initializes 'details' before calling this function.  The
416      * caller takes ownership of the string key-values pairs added to
417      * 'details'.
418      *
419      * The returned contents of 'details' should be documented as valid for the
420      * given 'type' in the "other_config" column in the "Queue" table in
421      * vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
422      */
423     int (*get_queue)(const struct netdev *netdev,
424                      unsigned int queue_id, struct smap *details);
425
426     /* Configures the queue numbered 'queue_id' on 'netdev' with the key-value
427      * string pairs in 'details'.  The contents of 'details' should be
428      * documented as valid for the given 'type' in the "other_config" column in
429      * the "Queue" table in vswitchd/vswitch.xml (which is built as
430      * ovs-vswitchd.conf.db(8)).  Returns 0 if successful, otherwise a positive
431      * errno value.  On failure, the given queue's configuration should be
432      * unmodified.
433      *
434      * Should return EINVAL if 'queue_id' is greater than or equal to the
435      * number of supported queues (as reported in the 'n_queues' member of
436      * struct netdev_qos_capabilities by 'get_qos_capabilities'), or if
437      * 'details' is invalid for the type of queue.
438      *
439      * This function does not modify 'details', and the caller retains
440      * ownership of it.
441      *
442      * May be NULL if 'netdev' does not support QoS at all. */
443     int (*set_queue)(struct netdev *netdev,
444                      unsigned int queue_id, const struct smap *details);
445
446     /* Attempts to delete the queue numbered 'queue_id' from 'netdev'.
447      *
448      * Should return EINVAL if 'queue_id' is greater than or equal to the
449      * number of supported queues (as reported in the 'n_queues' member of
450      * struct netdev_qos_capabilities by 'get_qos_capabilities').  Should
451      * return EOPNOTSUPP if 'queue_id' is valid but may not be deleted (e.g. if
452      * 'netdev' has a fixed set of queues with the current QoS mode).
453      *
454      * May be NULL if 'netdev' does not support QoS at all, or if all of its
455      * QoS modes have fixed sets of queues. */
456     int (*delete_queue)(struct netdev *netdev, unsigned int queue_id);
457
458     /* Obtains statistics about 'queue_id' on 'netdev'.  Fills 'stats' with the
459      * queue's statistics.  May set individual members of 'stats' to all-1-bits
460      * if the statistic is unavailable.
461      *
462      * May be NULL if 'netdev' does not support QoS at all. */
463     int (*get_queue_stats)(const struct netdev *netdev, unsigned int queue_id,
464                            struct netdev_queue_stats *stats);
465
466     /* Iterates over all of 'netdev''s queues, calling 'cb' with the queue's
467      * ID, its configuration, and the 'aux' specified by the caller.  The order
468      * of iteration is unspecified, but (when successful) each queue is visited
469      * exactly once.
470      *
471      * 'cb' will not modify or free the 'details' argument passed in.  It may
472      * delete or modify the queue passed in as its 'queue_id' argument.  It may
473      * modify but will not delete any other queue within 'netdev'.  If 'cb'
474      * adds new queues, then ->dump_queues is allowed to visit some queues
475      * twice or not at all.
476      */
477     int (*dump_queues)(const struct netdev *netdev,
478                        void (*cb)(unsigned int queue_id,
479                                   const struct smap *details,
480                                   void *aux),
481                        void *aux);
482
483     /* Iterates over all of 'netdev''s queues, calling 'cb' with the queue's
484      * ID, its statistics, and the 'aux' specified by the caller.  The order of
485      * iteration is unspecified, but (when successful) each queue must be
486      * visited exactly once.
487      *
488      * 'cb' will not modify or free the statistics passed in. */
489     int (*dump_queue_stats)(const struct netdev *netdev,
490                             void (*cb)(unsigned int queue_id,
491                                        struct netdev_queue_stats *,
492                                        void *aux),
493                             void *aux);
494
495     /* If 'netdev' has an assigned IPv4 address, sets '*address' to that
496      * address and '*netmask' to the associated netmask.
497      *
498      * The following error values have well-defined meanings:
499      *
500      *   - EADDRNOTAVAIL: 'netdev' has no assigned IPv4 address.
501      *
502      *   - EOPNOTSUPP: No IPv4 network stack attached to 'netdev'.
503      *
504      * This function may be set to null if it would always return EOPNOTSUPP
505      * anyhow. */
506     int (*get_in4)(const struct netdev *netdev, struct in_addr *address,
507                    struct in_addr *netmask);
508
509     /* Assigns 'addr' as 'netdev''s IPv4 address and 'mask' as its netmask.  If
510      * 'addr' is INADDR_ANY, 'netdev''s IPv4 address is cleared.
511      *
512      * This function may be set to null if it would always return EOPNOTSUPP
513      * anyhow. */
514     int (*set_in4)(struct netdev *netdev, struct in_addr addr,
515                    struct in_addr mask);
516
517     /* If 'netdev' has an assigned IPv6 address, sets '*in6' to that address.
518      *
519      * The following error values have well-defined meanings:
520      *
521      *   - EADDRNOTAVAIL: 'netdev' has no assigned IPv6 address.
522      *
523      *   - EOPNOTSUPP: No IPv6 network stack attached to 'netdev'.
524      *
525      * This function may be set to null if it would always return EOPNOTSUPP
526      * anyhow. */
527     int (*get_in6)(const struct netdev *netdev, struct in6_addr *in6);
528
529     /* Adds 'router' as a default IP gateway for the TCP/IP stack that
530      * corresponds to 'netdev'.
531      *
532      * This function may be set to null if it would always return EOPNOTSUPP
533      * anyhow. */
534     int (*add_router)(struct netdev *netdev, struct in_addr router);
535
536     /* Looks up the next hop for 'host'.  If succesful, stores the next hop
537      * gateway's address (0 if 'host' is on a directly connected network) in
538      * '*next_hop' and a copy of the name of the device to reach 'host' in
539      * '*netdev_name', and returns 0.  The caller is responsible for freeing
540      * '*netdev_name' (by calling free()).
541      *
542      * This function may be set to null if it would always return EOPNOTSUPP
543      * anyhow. */
544     int (*get_next_hop)(const struct in_addr *host, struct in_addr *next_hop,
545                         char **netdev_name);
546
547     /* Retrieves driver information of the device.
548      *
549      * Populates 'sh' with key-value pairs representing the status of the
550      * device.  Driver info is a set of key-value string pairs
551      * representing netdev type specific information.  For more information see
552      * ovs-vswitchd.conf.db(5).
553      *
554      * The caller is responsible for destroying 'smap' and its data.
555      *
556      * This function may be set to null if it would always return EOPNOTSUPP
557      * anyhow. */
558     int (*get_drv_info)(const struct netdev *netdev, struct smap *smap);
559
560     /* Looks up the ARP table entry for 'ip' on 'netdev' and stores the
561      * corresponding MAC address in 'mac'.  A return value of ENXIO, in
562      * particular, indicates that there is no ARP table entry for 'ip' on
563      * 'netdev'.
564      *
565      * This function may be set to null if it would always return EOPNOTSUPP
566      * anyhow. */
567     int (*arp_lookup)(const struct netdev *netdev, ovs_be32 ip,
568                       uint8_t mac[6]);
569
570     /* Retrieves the current set of flags on 'netdev' into '*old_flags'.
571      * Then, turns off the flags that are set to 1 in 'off' and turns on the
572      * flags that are set to 1 in 'on'.  (No bit will be set to 1 in both 'off'
573      * and 'on'; that is, off & on == 0.)
574      *
575      * This function may be invoked from a signal handler.  Therefore, it
576      * should not do anything that is not signal-safe (such as logging). */
577     int (*update_flags)(struct netdev *netdev, enum netdev_flags off,
578                         enum netdev_flags on, enum netdev_flags *old_flags);
579
580     /* Returns a sequence number which indicates changes in one of 'netdev''s
581      * properties.  The returned sequence number must be nonzero so that
582      * callers have a value which they may use as a reset when tracking
583      * 'netdev'.
584      *
585      * Minimally, the returned sequence number is required to change whenever
586      * 'netdev''s flags, features, ethernet address, or carrier changes.  The
587      * returned sequence number is allowed to change even when 'netdev' doesn't
588      * change, although implementations should try to avoid this. */
589     unsigned int (*change_seq)(const struct netdev *netdev);
590 };
591
592 int netdev_register_provider(const struct netdev_class *);
593 int netdev_unregister_provider(const char *type);
594 const struct netdev_class *netdev_lookup_provider(const char *type);
595
596 extern const struct netdev_class netdev_linux_class;
597 extern const struct netdev_class netdev_internal_class;
598 extern const struct netdev_class netdev_tap_class;
599
600 #ifdef  __cplusplus
601 }
602 #endif
603
604 #endif /* netdev.h */