+ memset(dp, 0, sizeof *dp);
+ dp->dp_idx = -1;
+}
+
+static void
+dpif_linux_dp_dump_start(struct nl_dump *dump)
+{
+ struct dpif_linux_dp request;
+ struct ofpbuf *buf;
+
+ dpif_linux_dp_init(&request);
+ request.cmd = ODP_DP_CMD_GET;
+
+ buf = ofpbuf_new(1024);
+ dpif_linux_dp_to_ofpbuf(&request, buf);
+ nl_dump_start(dump, genl_sock, buf);
+ ofpbuf_delete(buf);
+}
+
+/* Executes 'request' in the kernel datapath. If the command fails, returns a
+ * positive errno value. Otherwise, if 'reply' and 'bufp' are null, returns 0
+ * without doing anything else. If 'reply' and 'bufp' are nonnull, then the
+ * result of the command is expected to be of the same form, which is decoded
+ * and stored in '*reply' and '*bufp'. The caller must free '*bufp' when the
+ * reply is no longer needed ('reply' will contain pointers into '*bufp'). */
+int
+dpif_linux_dp_transact(const struct dpif_linux_dp *request,
+ struct dpif_linux_dp *reply, struct ofpbuf **bufp)
+{
+ struct ofpbuf *request_buf;
+ int error;
+
+ assert((reply != NULL) == (bufp != NULL));
+
+ request_buf = ofpbuf_new(1024);
+ dpif_linux_dp_to_ofpbuf(request, request_buf);
+ error = nl_sock_transact(genl_sock, request_buf, bufp);
+ ofpbuf_delete(request_buf);
+
+ if (reply) {
+ if (!error) {
+ error = dpif_linux_dp_from_ofpbuf(reply, *bufp);
+ }
+ if (error) {
+ dpif_linux_dp_init(reply);
+ ofpbuf_delete(*bufp);
+ *bufp = NULL;
+ }
+ }
+ return error;
+}
+
+/* Obtains information about 'dpif_' and stores it into '*reply' and '*bufp'.
+ * The caller must free '*bufp' when the reply is no longer needed ('reply'
+ * will contain pointers into '*bufp'). */
+int
+dpif_linux_dp_get(const struct dpif *dpif_, struct dpif_linux_dp *reply,
+ struct ofpbuf **bufp)
+{
+ struct dpif_linux *dpif = dpif_linux_cast(dpif_);
+ struct dpif_linux_dp request;
+
+ dpif_linux_dp_init(&request);
+ request.cmd = ODP_DP_CMD_GET;
+ request.dp_idx = dpif->minor;
+
+ return dpif_linux_dp_transact(&request, reply, bufp);
+}
+\f
+/* Parses the contents of 'buf', which contains a "struct odp_flow" followed by
+ * Netlink attributes, into 'flow'. Returns 0 if successful, otherwise a
+ * positive errno value.
+ *
+ * 'flow' will contain pointers into 'buf', so the caller should not free 'buf'
+ * while 'flow' is still in use. */
+static int
+dpif_linux_flow_from_ofpbuf(struct dpif_linux_flow *flow,
+ const struct ofpbuf *buf)
+{
+ static const struct nl_policy odp_flow_policy[] = {
+ [ODP_FLOW_ATTR_KEY] = { .type = NL_A_NESTED },
+ [ODP_FLOW_ATTR_ACTIONS] = { .type = NL_A_NESTED, .optional = true },
+ [ODP_FLOW_ATTR_STATS] = { .type = NL_A_UNSPEC,
+ .min_len = sizeof(struct odp_flow_stats),
+ .max_len = sizeof(struct odp_flow_stats),
+ .optional = true },
+ [ODP_FLOW_ATTR_TCP_FLAGS] = { .type = NL_A_U8, .optional = true },
+ [ODP_FLOW_ATTR_USED] = { .type = NL_A_U64, .optional = true },
+ /* The kernel never uses ODP_FLOW_ATTR_CLEAR. */
+ [ODP_FLOW_ATTR_STATE] = { .type = NL_A_U64, .optional = true },
+ };
+
+ struct odp_flow *odp_flow;
+ struct nlattr *a[ARRAY_SIZE(odp_flow_policy)];
+
+ dpif_linux_flow_init(flow);
+
+ if (!nl_policy_parse(buf, sizeof *odp_flow, odp_flow_policy,
+ a, ARRAY_SIZE(odp_flow_policy))) {
+ return EINVAL;
+ }
+ odp_flow = buf->data;
+
+ flow->nlmsg_flags = odp_flow->nlmsg_flags;
+ flow->dp_idx = odp_flow->dp_idx;
+ flow->key = nl_attr_get(a[ODP_FLOW_ATTR_KEY]);
+ flow->key_len = nl_attr_get_size(a[ODP_FLOW_ATTR_KEY]);
+ if (a[ODP_FLOW_ATTR_ACTIONS]) {
+ flow->actions = nl_attr_get(a[ODP_FLOW_ATTR_ACTIONS]);
+ flow->actions_len = nl_attr_get_size(a[ODP_FLOW_ATTR_ACTIONS]);
+ }
+ if (a[ODP_FLOW_ATTR_STATS]) {
+ flow->stats = nl_attr_get(a[ODP_FLOW_ATTR_STATS]);
+ }
+ if (a[ODP_FLOW_ATTR_TCP_FLAGS]) {
+ flow->tcp_flags = nl_attr_get(a[ODP_FLOW_ATTR_TCP_FLAGS]);
+ }
+ if (a[ODP_FLOW_ATTR_STATE]) {
+ flow->state = nl_attr_get(a[ODP_FLOW_ATTR_STATE]);
+ }
+ return 0;
+}
+
+/* Appends to 'buf' (which must initially be empty) a "struct odp_flow"
+ * followed by Netlink attributes corresponding to 'flow'. */
+static void
+dpif_linux_flow_to_ofpbuf(const struct dpif_linux_flow *flow,
+ struct ofpbuf *buf)
+{
+ struct odp_flow *odp_flow;
+
+ ofpbuf_reserve(buf, sizeof odp_flow);
+
+ if (flow->key_len) {
+ nl_msg_put_unspec(buf, ODP_FLOW_ATTR_KEY, flow->key, flow->key_len);
+ }
+
+ if (flow->actions_len) {
+ nl_msg_put_unspec(buf, ODP_FLOW_ATTR_ACTIONS,
+ flow->actions, flow->actions_len);
+ }
+
+ /* We never need to send these to the kernel. */
+ assert(!flow->stats);
+ assert(!flow->tcp_flags);
+ assert(!flow->used);
+
+ if (flow->clear) {
+ nl_msg_put_flag(buf, ODP_FLOW_ATTR_CLEAR);
+ }
+
+ if (flow->state) {
+ nl_msg_put_u64(buf, ODP_FLOW_ATTR_STATE,
+ get_unaligned_u64(flow->state));
+ }
+
+ odp_flow = ofpbuf_push_uninit(buf, sizeof *odp_flow);
+ odp_flow->nlmsg_flags = flow->nlmsg_flags;
+ odp_flow->dp_idx = flow->dp_idx;
+ odp_flow->len = buf->size;
+ odp_flow->total_len = (char *) ofpbuf_end(buf) - (char *) buf->data;
+}
+
+/* Clears 'flow' to "empty" values. */
+void
+dpif_linux_flow_init(struct dpif_linux_flow *flow)
+{
+ memset(flow, 0, sizeof *flow);
+}
+
+/* Executes 'request' in the kernel datapath. If the command fails, returns a
+ * positive errno value. Otherwise, if 'reply' and 'bufp' are null, returns 0
+ * without doing anything else. If 'reply' and 'bufp' are nonnull, then the
+ * result of the command is expected to be an odp_flow also, which is decoded
+ * and stored in '*reply' and '*bufp'. The caller must free '*bufp' when the
+ * reply is no longer needed ('reply' will contain pointers into '*bufp'). */
+int
+dpif_linux_flow_transact(const struct dpif_linux_flow *request,
+ struct dpif_linux_flow *reply, struct ofpbuf **bufp)
+{
+ struct ofpbuf *buf = NULL;