/*
- * Copyright (c) 2009, 2010 Nicira Networks.
+ * Copyright (c) 2009, 2010, 2011 Nicira Networks.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
int (*port_del)(struct dpif *dpif, uint16_t port_no);
/* Queries 'dpif' for a port with the given 'port_no' or 'devname'. Stores
- * information about the port into '*port' if successful. */
+ * information about the port into '*port' if successful.
+ *
+ * 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, uint16_t port_no,
- struct odp_port *port);
+ struct dpif_port *port);
int (*port_query_by_name)(const struct dpif *dpif, const char *devname,
- struct odp_port *port);
+ struct dpif_port *port);
+
+ /* 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
* 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'. */
- int (*execute)(struct dpif *dpif,
- const union odp_action actions[], int n_actions,
- const struct ofpbuf *packet);
+ /* Attempts to begin dumping the flows in a dpif. On success, returns 0
+ * and initializes '*statep' with any data needed for iteration. On
+ * failure, returns a positive errno value. */
+ int (*flow_dump_start)(const struct dpif *dpif, void **statep);
+
+ /* Attempts to retrieve another flow from 'dpif' for 'state', which was
+ * initialized by a successful call to the 'flow_dump_start' function for
+ * 'dpif'. On success, stores a new odp_flow into 'flow' and returns 0.
+ * Returns EOF if the end of the flow 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 'flow_dump_done'
+ * function will be called afterward).
+ *
+ * Dumping flow actions is optional. If the caller does not want to dump
+ * actions it will initialize 'flow->actions' to NULL and
+ * 'flow->actions_len' to 0. Otherwise, 'flow->actions' points to an array
+ * of struct nlattr and 'flow->actions_len' contains the number of bytes of
+ * Netlink attributes. The implemention should fill in as many actions as
+ * will fit into the provided array and update 'flow->actions_len' with the
+ * number of bytes required (regardless of whether they fit in the provided
+ * space). */
+ int (*flow_dump_next)(const struct dpif *dpif, void *state,
+ struct odp_flow *flow);
+
+ /* Releases resources from 'dpif' for 'state', which was initialized by a
+ * successful call to the 'flow_dump_start' function for 'dpif'. */
+ int (*flow_dump_done)(const struct dpif *dpif, void *state);
+
+ /* Performs the 'actions_len' bytes of actions in 'actions' on the Ethernet
+ * frame specified in 'packet'. */
+ int (*execute)(struct dpif *dpif, const struct nlattr *actions,
+ size_t actions_len, 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
int (*queue_to_priority)(const struct dpif *dpif, uint32_t queue_id,
uint32_t *priority);
- /* 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, and must have at least
- * DPIF_RECV_MSG_PADDING bytes of headroom (allocated using
- * e.g. ofpbuf_reserve()). Only messages of the types selected with the
- * set_listen_mask member function should be received.
+ /* Polls for an upcall from 'dpif'. If successful, stores the upcall into
+ * '*upcall'. Only upcalls 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);
+ * The caller takes ownership of the data that 'upcall' points to.
+ * 'upcall->key' and 'upcall->actions' (if nonnull) point into data owned
+ * by 'upcall->packet', so their memory cannot be freed separately. (This
+ * is hardly a great way to do things but it works out OK for the dpif
+ * providers that exist so far.)
+ *
+ * For greatest efficiency, 'upcall->packet' should have at least
+ * offsetof(struct ofp_packet_in, data) bytes of headroom.
+ *
+ * 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, struct dpif_upcall *upcall);
/* 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);
+
+ /* Throws away any queued upcalls that 'dpif' currently has ready to
+ * return. */
+ void (*recv_purge)(struct dpif *dpif);
};
extern const struct dpif_class dpif_linux_class;
git://git.onelab.eu / sliver-openvswitch.git / blobdiff