/*
- * Copyright (c) 2009 Nicira Networks.
+ * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#define DPIF_PROVIDER_H 1
/* Provider interface to dpifs, which provide an interface to an Open vSwitch
- * datapath. */
+ * datapath. A datapath is a collection of physical or virtual ports that are
+ * exposed over OpenFlow as a single switch. Datapaths and the collections of
+ * ports that they contain may be fixed or dynamic. */
-#include <assert.h>
+#include "openflow/openflow.h"
#include "dpif.h"
+#include "util.h"
#ifdef __cplusplus
extern "C" {
* This structure should be treated as opaque by dpif implementations. */
struct dpif {
const struct dpif_class *dpif_class;
- char *name;
+ char *base_name;
+ char *full_name;
uint8_t netflow_engine_type;
uint8_t netflow_engine_id;
};
void dpif_init(struct dpif *, const struct dpif_class *, const char *name,
uint8_t netflow_engine_type, uint8_t netflow_engine_id);
+void dpif_uninit(struct dpif *dpif, bool close);
+
static inline void dpif_assert_class(const struct dpif *dpif,
const struct dpif_class *dpif_class)
{
- assert(dpif->dpif_class == dpif_class);
+ ovs_assert(dpif->dpif_class == dpif_class);
+}
+
+struct dpif_flow_dump {
+ struct dpif *dpif;
+ bool terse; /* If true, key/mask/actions may be omitted. */
+};
+
+static inline void
+dpif_flow_dump_init(struct dpif_flow_dump *dump, const struct dpif *dpif)
+{
+ dump->dpif = CONST_CAST(struct dpif *, dpif);
+}
+
+struct dpif_flow_dump_thread {
+ struct dpif *dpif;
+};
+
+static inline void
+dpif_flow_dump_thread_init(struct dpif_flow_dump_thread *thread,
+ struct dpif_flow_dump *dump)
+{
+ thread->dpif = dump->dpif;
}
+struct ct_dpif_dump_state;
+struct ct_dpif_entry;
+
/* Datapath interface class structure, to be defined by each implementation of
* a datapath interface.
*
* EWOULDBLOCK or EINPROGRESS. We may relax this requirement in the future if
* and when we encounter performance problems. */
struct dpif_class {
- /* Prefix for names of dpifs in this class, e.g. "netdev:".
+ /* Type of dpif in this class, e.g. "system", "netdev", etc.
*
- * One dpif class may have the empty string "" as its prefix, in which case
- * that dpif class is associated with dpif names that don't match any other
- * class name. */
- const char *prefix;
-
- /* Class name, for use in error messages. */
- const char *name;
-
- /* Performs periodic work needed by dpifs of this class, if any is
- * necessary. */
- void (*run)(void);
+ * One of the providers should supply a "system" type, since this is
+ * the type assumed if no type is specified when opening a dpif. */
+ const char *type;
- /* Arranges for poll_block() to wake up if the "run" member function needs
- * to be called. */
- void (*wait)(void);
-
- /* Enumerates the names of all known created datapaths, if possible, into
- * 'all_dps'. The caller has already initialized 'all_dps' and other dpif
- * classes might already have added names to it.
+ /* Called when the dpif provider is registered, typically at program
+ * startup. Returning an error from this function will prevent any
+ * datapath with this class from being created.
+ *
+ * This function may be set to null if a datapath class needs no
+ * initialization at registration time. */
+ int (*init)(void);
+
+ /* Enumerates the names of all known created datapaths (of class
+ * 'dpif_class'), if possible, into 'all_dps'. The caller has already
+ * initialized 'all_dps' and other dpif classes might already have added
+ * names to it.
*
* This is used by the vswitch at startup, so that it can delete any
* datapaths that are not configured.
*
* Some kinds of datapaths might not be practically enumerable, in which
* case this function may be a null pointer. */
- int (*enumerate)(struct svec *all_dps);
+ int (*enumerate)(struct sset *all_dps, const struct dpif_class *dpif_class);
- /* Attempts to open an existing dpif, if 'create' is false, or to open an
- * existing dpif or create a new one, if 'create' is true. 'name' is the
- * full dpif name provided by the user, e.g. "udatapath:/var/run/mypath".
- * This name is useful for error messages but must not be modified.
+ /* Returns the type to pass to netdev_open() when a dpif of class
+ * 'dpif_class' has a port of type 'type', for a few special cases
+ * when a netdev type differs from a port type. For example, when
+ * using the userspace datapath, a port of type "internal" needs to
+ * be opened as "tap".
*
- * 'suffix' is a copy of 'name' following the dpif's 'prefix'.
+ * Returns either 'type' itself or a string literal, which must not
+ * be freed. */
+ const char *(*port_open_type)(const struct dpif_class *dpif_class,
+ const char *type);
+
+ /* Attempts to open an existing dpif called 'name', if 'create' is false,
+ * or to open an existing dpif or create a new one, if 'create' is true.
*
- * If successful, stores a pointer to the new dpif in '*dpifp'. On failure
- * there are no requirements on what is stored in '*dpifp'. */
- int (*open)(const char *name, char *suffix, bool create,
- struct dpif **dpifp);
+ * 'dpif_class' is the class of dpif to open.
+ *
+ * If successful, stores a pointer to the new dpif in '*dpifp', which must
+ * have class 'dpif_class'. On failure there are no requirements on what
+ * is stored in '*dpifp'. */
+ int (*open)(const struct dpif_class *dpif_class,
+ const char *name, bool create, struct dpif **dpifp);
/* Closes 'dpif' and frees associated memory. */
void (*close)(struct dpif *dpif);
- /* Enumerates all names that may be used to open 'dpif' into 'all_names'.
- * The Linux datapath, for example, supports opening a datapath both by
- * number, e.g. "dp0", and by the name of the datapath's local port. For
- * some datapaths, this might be an infinite set (e.g. in a file name,
- * slashes may be duplicated any number of times), in which case only the
- * names most likely to be used should be enumerated.
- *
- * The caller has already initialized 'all_names' and might already have
- * added some names to it. This function should not disturb any existing
- * names in 'all_names'.
- *
- * If a datapath class does not support multiple names for a datapath, this
- * function may be a null pointer.
- *
- * This is used by the vswitch at startup, */
- int (*get_all_names)(const struct dpif *dpif, struct svec *all_names);
-
/* Attempts to destroy the dpif underlying 'dpif'.
*
* If successful, 'dpif' will not be used again except as an argument for
* the 'close' member function. */
int (*destroy)(struct dpif *dpif);
- /* Retrieves statistics for 'dpif' into 'stats'. */
- int (*get_stats)(const struct dpif *dpif, struct odp_stats *stats);
+ /* Performs periodic work needed by 'dpif', if any is necessary.
+ * Returns true if need to revalidate. */
+ bool (*run)(struct dpif *dpif);
- /* Retrieves 'dpif''s current treatment of IP fragments into '*drop_frags':
- * true indicates that fragments are dropped, false indicates that
- * fragments are treated in the same way as other IP packets (except that
- * the L4 header cannot be read). */
- int (*get_drop_frags)(const struct dpif *dpif, bool *drop_frags);
+ /* Arranges for poll_block() to wake up if the "run" member function needs
+ * to be called for 'dpif'. */
+ void (*wait)(struct dpif *dpif);
- /* Changes 'dpif''s treatment of IP fragments to 'drop_frags', whose
- * meaning is the same as for the get_drop_frags member function. */
- int (*set_drop_frags)(struct dpif *dpif, bool drop_frags);
+ /* Retrieves statistics for 'dpif' into 'stats'. */
+ int (*get_stats)(const struct dpif *dpif, struct dpif_dp_stats *stats);
- /* Creates a new port in 'dpif' connected to network device 'devname'.
- * 'flags' is a set of ODP_PORT_* flags. If successful, sets '*port_no'
- * to the new port's port number. */
- int (*port_add)(struct dpif *dpif, const char *devname, uint16_t flags,
- uint16_t *port_no);
+ /* Adds 'netdev' as a new port in 'dpif'. If '*port_no' is not
+ * UINT32_MAX, attempts to use that as the port's port number.
+ *
+ * If port is successfully added, sets '*port_no' to the new port's
+ * port number. Returns EBUSY if caller attempted to choose a port
+ * number, and it was in use. */
+ int (*port_add)(struct dpif *dpif, struct netdev *netdev,
+ odp_port_t *port_no);
/* Removes port numbered 'port_no' from 'dpif'. */
- int (*port_del)(struct dpif *dpif, uint16_t port_no);
+ int (*port_del)(struct dpif *dpif, odp_port_t port_no);
- /* Queries 'dpif' for a port with the given 'port_no' or 'devname'. Stores
- * information about the port into '*port' if successful. */
- int (*port_query_by_number)(const struct dpif *dpif, uint16_t port_no,
- struct odp_port *port);
+ /* Queries 'dpif' for a port with the given 'port_no' or 'devname'.
+ * If 'port' is not null, stores information about the port into
+ * '*port' if successful.
+ *
+ * If 'port' is not null, the caller takes ownership of data in
+ * 'port' and must free it with dpif_port_destroy() when it is no
+ * longer needed. */
+ int (*port_query_by_number)(const struct dpif *dpif, odp_port_t port_no,
+ struct dpif_port *port);
int (*port_query_by_name)(const struct dpif *dpif, const char *devname,
- struct odp_port *port);
+ struct dpif_port *port);
+
+ /* Returns the Netlink PID value to supply in OVS_ACTION_ATTR_USERSPACE
+ * actions as the OVS_USERSPACE_ATTR_PID attribute's value, for use in
+ * flows whose packets arrived on port 'port_no'. In the case where the
+ * provider allocates multiple Netlink PIDs to a single port, it may use
+ * 'hash' to spread load among them. The caller need not use a particular
+ * hash function; a 5-tuple hash is suitable.
+ *
+ * (The datapath implementation might use some different hash function for
+ * distributing packets received via flow misses among PIDs. This means
+ * that packets received via flow misses might be reordered relative to
+ * packets received via userspace actions. This is not ordinarily a
+ * problem.)
+ *
+ * A 'port_no' of UINT32_MAX should be treated as a special case. The
+ * implementation should return a reserved PID, not allocated to any port,
+ * that the client may use for special purposes.
+ *
+ * The return value only needs to be meaningful when DPIF_UC_ACTION has
+ * been enabled in the 'dpif''s listen mask, and it is allowed to change
+ * when DPIF_UC_ACTION is disabled and then re-enabled.
+ *
+ * A dpif provider that doesn't have meaningful Netlink PIDs can use NULL
+ * for this function. This is equivalent to always returning 0. */
+ uint32_t (*port_get_pid)(const struct dpif *dpif, odp_port_t port_no,
+ uint32_t hash);
+
+ /* Attempts to begin dumping the ports in a dpif. On success, returns 0
+ * and initializes '*statep' with any data needed for iteration. On
+ * failure, returns a positive errno value. */
+ int (*port_dump_start)(const struct dpif *dpif, void **statep);
+
+ /* Attempts to retrieve another port from 'dpif' for 'state', which was
+ * initialized by a successful call to the 'port_dump_start' function for
+ * 'dpif'. On success, stores a new dpif_port into 'port' and returns 0.
+ * Returns EOF if the end of the port table has been reached, or a positive
+ * errno value on error. This function will not be called again once it
+ * returns nonzero once for a given iteration (but the 'port_dump_done'
+ * function will be called afterward).
+ *
+ * The dpif provider retains ownership of the data stored in 'port'. It
+ * must remain valid until at least the next call to 'port_dump_next' or
+ * 'port_dump_done' for 'state'. */
+ int (*port_dump_next)(const struct dpif *dpif, void *state,
+ struct dpif_port *port);
- /* Stores in 'ports' information about up to 'n' ports attached to 'dpif',
- * in no particular order. Returns the number of ports attached to 'dpif'
- * (not the number stored), if successful, otherwise a negative errno
- * value. */
- int (*port_list)(const struct dpif *dpif, struct odp_port *ports, int n);
+ /* Releases resources from 'dpif' for 'state', which was initialized by a
+ * successful call to the 'port_dump_start' function for 'dpif'. */
+ int (*port_dump_done)(const struct dpif *dpif, void *state);
/* Polls for changes in the set of ports in 'dpif'. If the set of ports in
* 'dpif' has changed, then this function should do one of the
* value other than EAGAIN. */
void (*port_poll_wait)(const struct dpif *dpif);
- /* Stores in 'ports' the port numbers of up to 'n' ports that belong to
- * 'group' in 'dpif'. Returns the number of ports in 'group' (not the
- * number stored), if successful, otherwise a negative errno value. */
- int (*port_group_get)(const struct dpif *dpif, int group,
- uint16_t ports[], int n);
-
- /* Changes port group 'group' in 'dpif' to consist of the 'n' ports whose
- * numbers are given in 'ports'.
- *
- * Use the get_stats member function to obtain the number of supported port
- * groups. */
- int (*port_group_set)(struct dpif *dpif, int group,
- const uint16_t ports[], int n);
-
- /* For each flow 'flow' in the 'n' flows in 'flows':
- *
- * - If a flow matching 'flow->key' exists in 'dpif':
- *
- * Stores 0 into 'flow->stats.error' and stores statistics for the flow
- * into 'flow->stats'.
- *
- * If 'flow->n_actions' is zero, then 'flow->actions' is ignored. If
- * 'flow->n_actions' is nonzero, then 'flow->actions' should point to
- * an array of the specified number of actions. At most that many of
- * the flow's actions will be copied into that array.
- * 'flow->n_actions' will be updated to the number of actions actually
- * present in the flow, which may be greater than the number stored if
- * the flow has more actions than space available in the array.
- *
- * - Flow-specific errors are indicated by a positive errno value in
- * 'flow->stats.error'. In particular, ENOENT indicates that no flow
- * matching 'flow->key' exists in 'dpif'. When an error value is stored,
- * the contents of 'flow->key' are preserved but other members of 'flow'
- * should be treated as indeterminate.
- *
- * Returns 0 if all 'n' flows in 'flows' were updated (whether they were
- * individually successful or not is indicated by 'flow->stats.error',
- * however). Returns a positive errno value if an error that prevented
- * this update occurred, in which the caller must not depend on any
- * elements in 'flows' being updated or not updated.
- */
- int (*flow_get)(const struct dpif *dpif, struct odp_flow flows[], int n);
-
- /* Adds or modifies a flow in 'dpif' as specified in 'put':
- *
- * - If the flow specified in 'put->flow' does not exist in 'dpif', then
- * behavior depends on whether ODPPF_CREATE is specified in 'put->flags':
- * if it is, the flow will be added, otherwise the operation will fail
- * with ENOENT.
- *
- * - Otherwise, the flow specified in 'put->flow' does exist in 'dpif'.
- * Behavior in this case depends on whether ODPPF_MODIFY is specified in
- * 'put->flags': if it is, the flow's actions will be updated, otherwise
- * the operation will fail with EEXIST. If the flow's actions are
- * updated, then its statistics will be zeroed if ODPPF_ZERO_STATS is set
- * in 'put->flags', left as-is otherwise.
- */
- int (*flow_put)(struct dpif *dpif, struct odp_flow_put *put);
-
- /* Deletes a flow matching 'flow->key' from 'dpif' or returns ENOENT if
- * 'dpif' does not contain such a flow.
- *
- * If successful, updates 'flow->stats', 'flow->n_actions', and
- * 'flow->actions' as described in more detail under the flow_get member
- * function below. */
- int (*flow_del)(struct dpif *dpif, struct odp_flow *flow);
-
/* Deletes all flows from 'dpif' and clears all of its queues of received
* packets. */
int (*flow_flush)(struct dpif *dpif);
- /* Stores up to 'n' flows in 'dpif' into 'flows', updating their statistics
- * and actions as described under the flow_get member function. If
- * successful, returns the number of flows actually present in 'dpif',
- * which might be greater than the number stored (if 'dpif' has more than
- * 'n' flows). On failure, returns a negative errno value. */
- int (*flow_list)(const struct dpif *dpif, struct odp_flow flows[], int n);
-
- /* Performs the 'n_actions' actions in 'actions' on the Ethernet frame
- * specified in 'packet'.
- *
- * Pretends that the frame was originally received on the port numbered
- * 'in_port'. This affects only ODPAT_OUTPUT_GROUP actions, which will not
- * send a packet out their input port. Specify the number of an unused
- * port (e.g. UINT16_MAX is currently always unused) to avoid this
- * behavior. */
- int (*execute)(struct dpif *dpif, uint16_t in_port,
- const union odp_action actions[], int n_actions,
- const struct ofpbuf *packet);
-
- /* Retrieves 'dpif''s "listen mask" into '*listen_mask'. Each ODPL_* bit
- * set in '*listen_mask' indicates the 'dpif' will receive messages of the
- * corresponding type when it calls the recv member function. */
- int (*recv_get_mask)(const struct dpif *dpif, int *listen_mask);
-
- /* Sets 'dpif''s "listen mask" to 'listen_mask'. Each ODPL_* bit set in
- * 'listen_mask' indicates the 'dpif' will receive messages of the
- * corresponding type when it calls the recv member function. */
- int (*recv_set_mask)(struct dpif *dpif, int listen_mask);
-
- /* Attempts to receive a message from 'dpif'. If successful, stores the
- * message into '*packetp'. The message, if one is received, must begin
- * with 'struct odp_msg' as a header. Only messages of the types selected
- * with the set_listen_mask member function should be received.
- *
- * This function must not block. If no message is ready to be received
- * when it is called, it should return EAGAIN without blocking. */
- int (*recv)(struct dpif *dpif, struct ofpbuf **packetp);
-
- /* Arranges for the poll loop to wake up when 'dpif' has a message queued
- * to be received with the recv member function. */
- void (*recv_wait)(struct dpif *dpif);
+ /* Flow dumping interface.
+ *
+ * This is the back-end for the flow dumping interface described in
+ * dpif.h. Please read the comments there first, because this code
+ * closely follows it.
+ *
+ * 'flow_dump_create' and 'flow_dump_thread_create' must always return an
+ * initialized and usable data structure and defer error return until
+ * flow_dump_destroy(). This hasn't been a problem for the dpifs that
+ * exist so far.
+ *
+ * 'flow_dump_create' and 'flow_dump_thread_create' must initialize the
+ * structures that they return with dpif_flow_dump_init() and
+ * dpif_flow_dump_thread_init(), respectively.
+ *
+ * If 'terse' is true, then only UID and statistics will
+ * be returned in the dump. Otherwise, all fields will be returned. */
+ struct dpif_flow_dump *(*flow_dump_create)(const struct dpif *dpif,
+ bool terse);
+ int (*flow_dump_destroy)(struct dpif_flow_dump *dump);
+
+ struct dpif_flow_dump_thread *(*flow_dump_thread_create)(
+ struct dpif_flow_dump *dump);
+ void (*flow_dump_thread_destroy)(struct dpif_flow_dump_thread *thread);
+
+ int (*flow_dump_next)(struct dpif_flow_dump_thread *thread,
+ struct dpif_flow *flows, int max_flows);
+
+ /* Executes each of the 'n_ops' operations in 'ops' on 'dpif', in the order
+ * in which they are specified, placing each operation's results in the
+ * "output" members documented in comments and the 'error' member of each
+ * dpif_op. */
+ void (*operate)(struct dpif *dpif, struct dpif_op **ops, size_t n_ops);
+
+ /* Enables or disables receiving packets with dpif_recv() for 'dpif'.
+ * Turning packet receive off and then back on is allowed to change Netlink
+ * PID assignments (see ->port_get_pid()). The client is responsible for
+ * updating flows as necessary if it does this. */
+ int (*recv_set)(struct dpif *dpif, bool enable);
+
+ /* Refreshes the poll loops and Netlink sockets associated to each port,
+ * when the number of upcall handlers (upcall receiving thread) is changed
+ * to 'n_handlers' and receiving packets for 'dpif' is enabled by
+ * recv_set().
+ *
+ * Since multiple upcall handlers can read upcalls simultaneously from
+ * 'dpif', each port can have multiple Netlink sockets, one per upcall
+ * handler. So, handlers_set() is responsible for the following tasks:
+ *
+ * When receiving upcall is enabled, extends or creates the
+ * configuration to support:
+ *
+ * - 'n_handlers' Netlink sockets for each port.
+ *
+ * - 'n_handlers' poll loops, one for each upcall handler.
+ *
+ * - registering the Netlink sockets for the same upcall handler to
+ * the corresponding poll loop.
+ * */
+ int (*handlers_set)(struct dpif *dpif, uint32_t n_handlers);
+
+ /* If 'dpif' creates its own I/O polling threads, refreshes poll threads
+ * configuration. 'cmask' configures the cpu mask for setting the polling
+ * threads' cpu affinity. */
+ int (*poll_threads_set)(struct dpif *dpif, const char *cmask);
+
+ /* Translates OpenFlow queue ID 'queue_id' (in host byte order) into a
+ * priority value used for setting packet priority. */
+ int (*queue_to_priority)(const struct dpif *dpif, uint32_t queue_id,
+ uint32_t *priority);
+
+ /* Polls for an upcall from 'dpif' for an upcall handler. Since there
+ * can be multiple poll loops (see ->handlers_set()), 'handler_id' is
+ * needed as index to identify the corresponding poll loop. If
+ * successful, stores the upcall into '*upcall', using 'buf' for
+ * storage. Should only be called if 'recv_set' has been used to enable
+ * receiving packets from 'dpif'.
+ *
+ * The implementation should point 'upcall->key' and 'upcall->userdata'
+ * (if any) into data in the caller-provided 'buf'. The implementation may
+ * also use 'buf' for storing the data of 'upcall->packet'. If necessary
+ * to make room, the implementation may reallocate the data in 'buf'.
+ *
+ * The caller owns the data of 'upcall->packet' and may modify it. If
+ * packet's headroom is exhausted as it is manipulated, 'upcall->packet'
+ * will be reallocated. This requires the data of 'upcall->packet' to be
+ * released with ofpbuf_uninit() before 'upcall' is destroyed. However,
+ * when an error is returned, the 'upcall->packet' may be uninitialized
+ * and should not be released.
+ *
+ * This function must not block. If no upcall is pending when it is
+ * called, it should return EAGAIN without blocking. */
+ int (*recv)(struct dpif *dpif, uint32_t handler_id,
+ struct dpif_upcall *upcall, struct ofpbuf *buf);
+
+ /* Arranges for the poll loop for an upcall handler to wake up when 'dpif'
+ * has a message queued to be received with the recv member functions.
+ * Since there can be multiple poll loops (see ->handlers_set()),
+ * 'handler_id' is needed as index to identify the corresponding poll loop.
+ * */
+ void (*recv_wait)(struct dpif *dpif, uint32_t handler_id);
+
+ /* Throws away any queued upcalls that 'dpif' currently has ready to
+ * return. */
+ void (*recv_purge)(struct dpif *dpif);
+
+ /* When 'dpif' is about to purge the datapath, the higher layer may want
+ * to be notified so that it could try reacting accordingly (e.g. grabbing
+ * all flow stats before they are gone).
+ *
+ * Registers an upcall callback function with 'dpif'. This is only used
+ * if 'dpif' needs to notify the purging of datapath. 'aux' is passed to
+ * the callback on invocation. */
+ void (*register_dp_purge_cb)(struct dpif *, dp_purge_callback *, void *aux);
+
+ /* For datapaths that run in userspace (i.e. dpif-netdev), threads polling
+ * for incoming packets can directly call upcall functions instead of
+ * offloading packet processing to separate handler threads. Datapaths
+ * that directly call upcall functions should use the functions below to
+ * to register an upcall function and enable / disable upcalls.
+ *
+ * Registers an upcall callback function with 'dpif'. This is only used
+ * if 'dpif' directly executes upcall functions. 'aux' is passed to the
+ * callback on invocation. */
+ void (*register_upcall_cb)(struct dpif *, upcall_callback *, void *aux);
+
+ /* Enables upcalls if 'dpif' directly executes upcall functions. */
+ void (*enable_upcall)(struct dpif *);
+
+ /* Disables upcalls if 'dpif' directly executes upcall functions. */
+ void (*disable_upcall)(struct dpif *);
+
+ /* Get datapath version. Caller is responsible for freeing the string
+ * returned. */
+ char *(*get_datapath_version)(void);
+
+ /* Conntrack entry dumping interface.
+ *
+ * These functions are used by ct-dpif.c to provide a datapath-agnostic
+ * dumping interface to the connection trackes provided by the
+ * datapaths.
+ *
+ * ct_dump_start() should put in '*state' a pointer to a newly allocated
+ * stucture that will be passed by the caller to ct_dump_next() and
+ * ct_dump_done(). If 'zone' is not NULL, only the entries in '*zone'
+ * should be dumped.
+ *
+ * ct_dump_next() should fill 'entry' with information from a connection
+ * and prepare to dump the next one on a subsequest invocation.
+ *
+ * ct_dump_done should perform any cleanup necessary (including
+ * deallocating the 'state' structure, if applicable). */
+ int (*ct_dump_start)(struct dpif *, struct ct_dpif_dump_state **state,
+ const uint16_t *zone);
+ int (*ct_dump_next)(struct dpif *, struct ct_dpif_dump_state *,
+ struct ct_dpif_entry *entry);
+ int (*ct_dump_done)(struct dpif *, struct ct_dpif_dump_state *state);
+
+ /* Flushes the connection tracking tables. If 'zone' is not NULL,
+ * only deletes connections in '*zone'. */
+ int (*ct_flush)(struct dpif *, const uint16_t *zone);
};
-extern const struct dpif_class dpif_linux_class;
+extern const struct dpif_class dpif_netlink_class;
extern const struct dpif_class dpif_netdev_class;
#ifdef __cplusplus
projects / cascardo / ovs.git / blobdiff