+\f
+/* Parses the contents of 'buf', which contains a "struct odp_datapath"
+ * followed by Netlink attributes, into 'dp'. Returns 0 if successful,
+ * otherwise a positive errno value.
+ *
+ * 'dp' will contain pointers into 'buf', so the caller should not free 'buf'
+ * while 'dp' is still in use. */
+static int
+dpif_linux_dp_from_ofpbuf(struct dpif_linux_dp *dp, const struct ofpbuf *buf)
+{
+ static const struct nl_policy odp_datapath_policy[] = {
+ [ODP_DP_ATTR_NAME] = { .type = NL_A_STRING, .max_len = IFNAMSIZ },
+ [ODP_DP_ATTR_STATS] = { .type = NL_A_UNSPEC,
+ .min_len = sizeof(struct odp_stats),
+ .max_len = sizeof(struct odp_stats),
+ .optional = true },
+ [ODP_DP_ATTR_IPV4_FRAGS] = { .type = NL_A_U32, .optional = true },
+ [ODP_DP_ATTR_SAMPLING] = { .type = NL_A_U32, .optional = true },
+ };
+
+ struct odp_datapath *odp_dp;
+ struct nlattr *a[ARRAY_SIZE(odp_datapath_policy)];
+
+ dpif_linux_dp_init(dp);
+
+ if (!nl_policy_parse(buf, sizeof *odp_dp, odp_datapath_policy,
+ a, ARRAY_SIZE(odp_datapath_policy))) {
+ return EINVAL;
+ }
+ odp_dp = buf->data;
+
+ dp->dp_idx = odp_dp->dp_idx;
+ dp->name = nl_attr_get_string(a[ODP_DP_ATTR_NAME]);
+ if (a[ODP_DP_ATTR_STATS]) {
+ /* Can't use structure assignment because Netlink doesn't ensure
+ * sufficient alignment for 64-bit members. */
+ memcpy(&dp->stats, nl_attr_get(a[ODP_DP_ATTR_STATS]),
+ sizeof dp->stats);
+ }
+ if (a[ODP_DP_ATTR_IPV4_FRAGS]) {
+ dp->ipv4_frags = nl_attr_get_u32(a[ODP_DP_ATTR_IPV4_FRAGS]);
+ }
+ if (a[ODP_DP_ATTR_SAMPLING]) {
+ dp->sampling = nl_attr_get(a[ODP_DP_ATTR_SAMPLING]);
+ }
+ return 0;
+}
+
+/* Appends to 'buf' (which must initially be empty) a "struct odp_datapath"
+ * followed by Netlink attributes corresponding to 'dp'. */
+static void
+dpif_linux_dp_to_ofpbuf(const struct dpif_linux_dp *dp, struct ofpbuf *buf)
+{
+ struct odp_datapath *odp_dp;
+
+ ofpbuf_reserve(buf, sizeof odp_dp);
+
+ if (dp->name) {
+ nl_msg_put_string(buf, ODP_DP_ATTR_NAME, dp->name);
+ }
+
+ /* Skip ODP_DP_ATTR_STATS since we never have a reason to serialize it. */
+
+ if (dp->ipv4_frags) {
+ nl_msg_put_u32(buf, ODP_DP_ATTR_IPV4_FRAGS, dp->ipv4_frags);
+ }
+
+ if (dp->sampling) {
+ nl_msg_put_u32(buf, ODP_DP_ATTR_SAMPLING, *dp->sampling);
+ }
+
+ odp_dp = ofpbuf_push_uninit(buf, sizeof *odp_dp);
+ odp_dp->dp_idx = dp->dp_idx;
+ odp_dp->len = buf->size;
+ odp_dp->total_len = (char *) ofpbuf_end(buf) - (char *) buf->data;
+}
+
+/* Clears 'dp' to "empty" values. */
+void
+dpif_linux_dp_init(struct dpif_linux_dp *dp)
+{
+ memset(dp, 0, sizeof *dp);
+ dp->dp_idx = -1;
+}
+
+/* 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_datapath 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_dp_transact(const struct dpif_linux_dp *request,
+ struct dpif_linux_dp *reply, struct ofpbuf **bufp)
+{
+ struct ofpbuf *buf = NULL;
+ int error;
+ int fd;
+
+ assert((reply != NULL) == (bufp != NULL));
+
+ error = get_dp0_fd(&fd);
+ if (error) {
+ goto error;
+ }
+
+ buf = ofpbuf_new(1024);
+ dpif_linux_dp_to_ofpbuf(request, buf);
+
+ error = ioctl(fd, request->cmd, buf->data) ? errno : 0;
+ if (error) {
+ goto error;
+ }
+
+ if (bufp) {
+ buf->size = ((struct odp_datapath *) buf->data)->len;
+ error = dpif_linux_dp_from_ofpbuf(reply, buf);
+ if (error) {
+ goto error;
+ }
+ *bufp = buf;
+ } else {
+ ofpbuf_delete(buf);
+ }
+ return 0;
+
+error:
+ ofpbuf_delete(buf);
+ if (bufp) {
+ memset(reply, 0, sizeof *reply);
+ *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_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;
+ int error;
+ int fd;
+
+ assert((reply != NULL) == (bufp != NULL));
+
+ error = get_dp0_fd(&fd);
+ if (error) {
+ goto error;
+ }
+
+ buf = ofpbuf_new(1024);
+ dpif_linux_flow_to_ofpbuf(request, buf);
+
+ error = ioctl(fd, request->cmd, buf->data) ? errno : 0;
+ if (error) {
+ goto error;
+ }
+
+ if (bufp) {
+ buf->size = ((struct odp_flow *) buf->data)->len;
+ error = dpif_linux_flow_from_ofpbuf(reply, buf);
+ if (error) {
+ goto error;
+ }
+ *bufp = buf;
+ } else {
+ ofpbuf_delete(buf);
+ }
+ return 0;
+
+error:
+ ofpbuf_delete(buf);
+ if (bufp) {
+ memset(reply, 0, sizeof *reply);
+ *bufp = NULL;
+ }
+ return error;
+}
+
+static void
+dpif_linux_flow_get_stats(const struct dpif_linux_flow *flow,
+ struct dpif_flow_stats *stats)
+{
+ if (flow->stats) {
+ stats->n_packets = get_unaligned_u64(&flow->stats->n_packets);
+ stats->n_bytes = get_unaligned_u64(&flow->stats->n_bytes);
+ } else {
+ stats->n_packets = 0;
+ stats->n_bytes = 0;
+ }
+ stats->used = flow->used ? get_unaligned_u64(flow->used) : 0;
+ stats->tcp_flags = flow->tcp_flags ? *flow->tcp_flags : 0;
+}