- /* 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);
-
- /* Retrieves 'dpif''s sFlow sampling probability into '*probability'.
- * Return value is 0 or a positive errno value. EOPNOTSUPP indicates that
- * the datapath does not support sFlow, as does a null pointer.
- *
- * '*probability' is expressed as the number of packets out of UINT_MAX to
- * sample, e.g. probability/UINT_MAX is the probability of sampling a given
- * packet. */
- int (*get_sflow_probability)(const struct dpif *dpif,
- uint32_t *probability);
-
- /* Sets 'dpif''s sFlow sampling probability to 'probability'. Return value
- * is 0 or a positive errno value. EOPNOTSUPP indicates that the datapath
- * does not support sFlow, as does a null pointer.
- *
- * 'probability' is expressed as the number of packets out of UINT_MAX to
- * sample, e.g. probability/UINT_MAX is the probability of sampling a given
- * packet. */
- int (*set_sflow_probability)(struct dpif *dpif, uint32_t probability);
-
- /* 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);