X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fdpif-linux.c;h=b142f2be6c603fbe4d0a528815c6c392d57f7bd7;hb=b063d9f06e6bb005193a219bcb9f0a74dfdf7882;hp=88707d8df2913e8e76ab73c7cbc54eb83ebc9aa2;hpb=45c8d3a189843f0f45398caa420b952d5acd1f19;p=sliver-openvswitch.git

diff --git a/lib/dpif-linux.c b/lib/dpif-linux.c
index 88707d8df..b142f2be6 100644
--- a/lib/dpif-linux.c
+++ b/lib/dpif-linux.c
@@ -44,10 +44,10 @@
 #include "netlink.h"
 #include "odp-util.h"
 #include "ofpbuf.h"
+#include "openvswitch/datapath-compat.h"
 #include "openvswitch/tunnel.h"
 #include "packets.h"
 #include "poll-loop.h"
-#include "rtnetlink-link.h"
 #include "shash.h"
 #include "sset.h"
 #include "unaligned.h"
@@ -73,10 +73,10 @@ struct dpif_linux_dp {
 
     /* Attributes. */
     const char *name;                  /* OVS_DP_ATTR_NAME. */
+    uint32_t upcall_pid;               /* OVS_DP_UPCALL_PID. */
     struct ovs_dp_stats stats;         /* OVS_DP_ATTR_STATS. */
     enum ovs_frag_handling ipv4_frags; /* OVS_DP_ATTR_IPV4_FRAGS. */
     const uint32_t *sampling;          /* OVS_DP_ATTR_SAMPLING. */
-    uint32_t mcgroups[DPIF_N_UC_TYPES]; /* OVS_DP_ATTR_MCGROUPS. */
 };
 
 static void dpif_linux_dp_init(struct dpif_linux_dp *);
@@ -109,6 +109,7 @@ struct dpif_linux_flow {
     size_t key_len;
     const struct nlattr *actions;       /* OVS_FLOW_ATTR_ACTIONS. */
     size_t actions_len;
+    uint32_t upcall_pid;                /* OVS_FLOW_ATTR_UPCALL_PID. */
     const struct ovs_flow_stats *stats; /* OVS_FLOW_ATTR_STATS. */
     const uint8_t *tcp_flags;           /* OVS_FLOW_ATTR_TCP_FLAGS. */
     const uint64_t *used;               /* OVS_FLOW_ATTR_USED. */
@@ -131,14 +132,13 @@ struct dpif_linux {
     struct dpif dpif;
     int dp_ifindex;
 
-    /* Multicast group messages. */
-    struct nl_sock *mc_sock;
-    uint32_t mcgroups[DPIF_N_UC_TYPES];
+    /* Upcall messages. */
+    struct nl_sock *upcall_sock;
     unsigned int listen_mask;
 
     /* Change notification. */
     struct sset changed_ports;  /* Ports that have changed. */
-    struct rtnetlink_notifier port_notifier;
+    struct nln_notifier *port_notifier;
     bool change_error;
 
     /* Queue of unused ports. */
@@ -158,11 +158,12 @@ static int ovs_packet_family;
 
 /* Generic Netlink socket. */
 static struct nl_sock *genl_sock;
+static struct nln *nln = NULL;
 
 static int dpif_linux_init(void);
-static int open_dpif(const struct dpif_linux_dp *, struct dpif **);
-static void dpif_linux_port_changed(const struct rtnetlink_link_change *,
-                                    void *dpif);
+static void open_dpif(const struct dpif_linux_dp *, struct dpif **);
+static bool dpif_linux_nln_parse(struct ofpbuf *, void *);
+static void dpif_linux_port_changed(const void *vport, void *dpif);
 
 static void dpif_linux_vport_to_ofpbuf(const struct dpif_linux_vport *,
                                        struct ofpbuf *);
@@ -243,33 +244,26 @@ dpif_linux_open(const struct dpif_class *class OVS_UNUSED, const char *name,
     if (error) {
         return error;
     }
-    error = open_dpif(&dp, dpifp);
-    ofpbuf_delete(buf);
 
-    return error;
+    open_dpif(&dp, dpifp);
+    ofpbuf_delete(buf);
+    return 0;
 }
 
-static int
+static void
 open_dpif(const struct dpif_linux_dp *dp, struct dpif **dpifp)
 {
     struct dpif_linux *dpif;
-    int error;
     int i;
 
     dpif = xmalloc(sizeof *dpif);
-    error = rtnetlink_link_notifier_register(&dpif->port_notifier,
-                                             dpif_linux_port_changed, dpif);
-    if (error) {
-        goto error_free;
-    }
+    dpif->port_notifier = nln_notifier_create(nln, dpif_linux_port_changed,
+                                              dpif);
 
     dpif_init(&dpif->dpif, &dpif_linux_class, dp->name,
               dp->dp_ifindex, dp->dp_ifindex);
 
-    dpif->mc_sock = NULL;
-    for (i = 0; i < DPIF_N_UC_TYPES; i++) {
-        dpif->mcgroups[i] = dp->mcgroups[i];
-    }
+    dpif->upcall_sock = NULL;
     dpif->listen_mask = 0;
     dpif->dp_ifindex = dp->dp_ifindex;
     sset_init(&dpif->changed_ports);
@@ -282,19 +276,15 @@ open_dpif(const struct dpif_linux_dp *dp, struct dpif **dpifp)
     for (i = 1; i < LRU_MAX_PORTS; i++) {
         dpif_linux_push_port(dpif, i);
     }
-    return 0;
-
-error_free:
-    free(dpif);
-    return error;
 }
 
 static void
 dpif_linux_close(struct dpif *dpif_)
 {
     struct dpif_linux *dpif = dpif_linux_cast(dpif_);
-    nl_sock_destroy(dpif->mc_sock);
-    rtnetlink_link_notifier_unregister(&dpif->port_notifier);
+
+    nln_notifier_destroy(dpif->port_notifier);
+    nl_sock_destroy(dpif->upcall_sock);
     sset_destroy(&dpif->changed_ports);
     free(dpif->lru_bitmap);
     free(dpif);
@@ -315,13 +305,17 @@ dpif_linux_destroy(struct dpif *dpif_)
 static void
 dpif_linux_run(struct dpif *dpif OVS_UNUSED)
 {
-    rtnetlink_link_notifier_run();
+    if (nln) {
+        nln_run(nln);
+    }
 }
 
 static void
 dpif_linux_wait(struct dpif *dpif OVS_UNUSED)
 {
-    rtnetlink_link_notifier_wait();
+    if (nln) {
+        nln_wait(nln);
+    }
 }
 
 static int
@@ -404,6 +398,9 @@ dpif_linux_port_add(struct dpif *dpif_, struct netdev *netdev,
     /* Loop until we find a port that isn't used. */
     do {
         request.port_no = dpif_linux_pop_port(dpif);
+        if (dpif->upcall_sock) {
+            request.upcall_pid = nl_sock_pid(dpif->upcall_sock);
+        }
         error = dpif_linux_vport_transact(&request, &reply, &buf);
 
         if (!error) {
@@ -455,12 +452,6 @@ dpif_linux_port_query__(const struct dpif *dpif, uint32_t port_no,
         dpif_port->name = xstrdup(reply.name);
         dpif_port->type = xstrdup(netdev_vport_get_netdev_type(&reply));
         dpif_port->port_no = reply.port_no;
-        if (reply.stats) {
-            netdev_stats_from_rtnl_link_stats64(&dpif_port->stats,
-                                                reply.stats);
-        } else {
-            memset(&dpif_port->stats, 0xff, sizeof dpif_port->stats);
-        }
         ofpbuf_delete(buf);
     }
     return error;
@@ -556,11 +547,6 @@ dpif_linux_port_dump_next(const struct dpif *dpif OVS_UNUSED, void *state_,
     dpif_port->name = (char *) vport.name;
     dpif_port->type = (char *) netdev_vport_get_netdev_type(&vport);
     dpif_port->port_no = vport.port_no;
-    if (vport.stats) {
-        netdev_stats_from_rtnl_link_stats64(&dpif_port->stats, vport.stats);
-    } else {
-        memset(&dpif_port->stats, 0xff, sizeof dpif_port->stats);
-    }
     return 0;
 }
 
@@ -673,6 +659,9 @@ dpif_linux_flow_put(struct dpif *dpif_, enum dpif_flow_put_flags flags,
     /* Ensure that OVS_FLOW_ATTR_ACTIONS will always be included. */
     request.actions = actions ? actions : &dummy_action;
     request.actions_len = actions_len;
+    if (dpif->upcall_sock) {
+        request.upcall_pid = nl_sock_pid(dpif->upcall_sock);
+    }
     if (flags & DPIF_FP_ZERO_STATS) {
         request.clear = true;
     }
@@ -804,7 +793,7 @@ dpif_linux_flow_dump_done(const struct dpif *dpif OVS_UNUSED, void *state_)
 }
 
 static int
-dpif_linux_execute__(int dp_ifindex,
+dpif_linux_execute__(int dp_ifindex, uint32_t upcall_pid,
                      const struct nlattr *key, size_t key_len,
                      const struct nlattr *actions, size_t actions_len,
                      const struct ofpbuf *packet)
@@ -824,6 +813,7 @@ dpif_linux_execute__(int dp_ifindex,
     nl_msg_put_unspec(buf, OVS_PACKET_ATTR_PACKET, packet->data, packet->size);
     nl_msg_put_unspec(buf, OVS_PACKET_ATTR_KEY, key, key_len);
     nl_msg_put_unspec(buf, OVS_PACKET_ATTR_ACTIONS, actions, actions_len);
+    nl_msg_put_u32(buf, OVS_PACKET_ATTR_UPCALL_PID, upcall_pid);
 
     error = nl_sock_transact(genl_sock, buf, NULL);
     ofpbuf_delete(buf);
@@ -837,8 +827,13 @@ dpif_linux_execute(struct dpif *dpif_,
                    const struct ofpbuf *packet)
 {
     struct dpif_linux *dpif = dpif_linux_cast(dpif_);
+    uint32_t upcall_pid = 0;
+
+    if (dpif->upcall_sock) {
+        upcall_pid = nl_sock_pid(dpif->upcall_sock);
+    }
 
-    return dpif_linux_execute__(dpif->dp_ifindex, key, key_len,
+    return dpif_linux_execute__(dpif->dp_ifindex, upcall_pid, key, key_len,
                                 actions, actions_len, packet);
 }
 
@@ -855,45 +850,61 @@ dpif_linux_recv_set_mask(struct dpif *dpif_, int listen_mask)
 {
     struct dpif_linux *dpif = dpif_linux_cast(dpif_);
     int error;
-    int i;
 
     if (listen_mask == dpif->listen_mask) {
         return 0;
     } else if (!listen_mask) {
-        nl_sock_destroy(dpif->mc_sock);
-        dpif->mc_sock = NULL;
-        dpif->listen_mask = 0;
-        return 0;
-    } else if (!dpif->mc_sock) {
-        error = nl_sock_create(NETLINK_GENERIC, &dpif->mc_sock);
+        nl_sock_destroy(dpif->upcall_sock);
+        dpif->upcall_sock = NULL;
+    } else if (!dpif->upcall_sock) {
+        struct dpif_port port;
+        struct dpif_port_dump port_dump;
+        struct dpif_flow_dump flow_dump;
+        const struct nlattr *key;
+        size_t key_len;
+
+        error = nl_sock_create(NETLINK_GENERIC, &dpif->upcall_sock);
         if (error) {
             return error;
         }
-    }
 
-    /* Unsubscribe from old groups. */
-    for (i = 0; i < DPIF_N_UC_TYPES; i++) {
-        if (dpif->listen_mask & (1u << i)) {
-            nl_sock_leave_mcgroup(dpif->mc_sock, dpif->mcgroups[i]);
+        DPIF_PORT_FOR_EACH (&port, &port_dump, dpif_) {
+            struct dpif_linux_vport vport_request;
+
+            dpif_linux_vport_init(&vport_request);
+            vport_request.cmd = OVS_VPORT_CMD_SET;
+            vport_request.dp_ifindex = dpif->dp_ifindex;
+            vport_request.port_no = port.port_no;
+            vport_request.upcall_pid = nl_sock_pid(dpif->upcall_sock);
+            error = dpif_linux_vport_transact(&vport_request, NULL, NULL);
+            if (error) {
+                VLOG_WARN_RL(&error_rl, "%s: failed to set upcall pid on "
+                          "port: %s", dpif_name(dpif_), strerror(error));
+            }
         }
-    }
-
-    /* Update listen_mask. */
-    dpif->listen_mask = listen_mask;
-
-    /* Subscribe to new groups. */
-    error = 0;
-    for (i = 0; i < DPIF_N_UC_TYPES; i++) {
-        if (dpif->listen_mask & (1u << i)) {
-            int retval;
 
-            retval = nl_sock_join_mcgroup(dpif->mc_sock, dpif->mcgroups[i]);
-            if (retval) {
-                error = retval;
+        dpif_flow_dump_start(&flow_dump, dpif_);
+        while (dpif_flow_dump_next(&flow_dump, &key, &key_len,
+                                   NULL, NULL, NULL)) {
+            struct dpif_linux_flow flow_request;
+
+            dpif_linux_flow_init(&flow_request);
+            flow_request.cmd = OVS_FLOW_CMD_SET;
+            flow_request.dp_ifindex = dpif->dp_ifindex;
+            flow_request.key = key;
+            flow_request.key_len = key_len;
+            flow_request.upcall_pid = nl_sock_pid(dpif->upcall_sock);
+            error = dpif_linux_flow_transact(&flow_request, NULL, NULL);
+            if (error) {
+                VLOG_WARN_RL(&error_rl, "%s: failed to set upcall pid on "
+                          "flow: %s", dpif_name(dpif_), strerror(error));
             }
         }
+        dpif_flow_dump_done(&flow_dump);
     }
-    return error;
+
+    dpif->listen_mask = listen_mask;
+    return 0;
 }
 
 static int
@@ -1013,14 +1024,14 @@ dpif_linux_recv(struct dpif *dpif_, struct dpif_upcall *upcall)
     int error;
     int i;
 
-    if (!dpif->mc_sock) {
+    if (!dpif->upcall_sock) {
         return EAGAIN;
     }
 
     for (i = 0; i < 50; i++) {
         int dp_ifindex;
 
-        error = nl_sock_recv(dpif->mc_sock, &buf, false);
+        error = nl_sock_recv(dpif->upcall_sock, &buf, false);
         if (error) {
             return error;
         }
@@ -1045,8 +1056,8 @@ static void
 dpif_linux_recv_wait(struct dpif *dpif_)
 {
     struct dpif_linux *dpif = dpif_linux_cast(dpif_);
-    if (dpif->mc_sock) {
-        nl_sock_wait(dpif->mc_sock, POLLIN);
+    if (dpif->upcall_sock) {
+        nl_sock_wait(dpif->upcall_sock, POLLIN);
     }
 }
 
@@ -1055,8 +1066,8 @@ dpif_linux_recv_purge(struct dpif *dpif_)
 {
     struct dpif_linux *dpif = dpif_linux_cast(dpif_);
 
-    if (dpif->mc_sock) {
-        nl_sock_drain(dpif->mc_sock);
+    if (dpif->upcall_sock) {
+        nl_sock_drain(dpif->upcall_sock);
     }
 }
 
@@ -1105,6 +1116,8 @@ dpif_linux_init(void)
     static int error = -1;
 
     if (error < 0) {
+        unsigned int ovs_vport_mcgroup;
+
         error = nl_lookup_genl_family(OVS_DATAPATH_FAMILY,
                                       &ovs_datapath_family);
         if (error) {
@@ -1125,6 +1138,16 @@ dpif_linux_init(void)
         if (!error) {
             error = nl_sock_create(NETLINK_GENERIC, &genl_sock);
         }
+        if (!error) {
+            error = nl_lookup_genl_mcgroup(OVS_VPORT_FAMILY, OVS_VPORT_MCGROUP,
+                                           &ovs_vport_mcgroup,
+                                           OVS_VPORT_MCGROUP_FALLBACK_ID);
+        }
+        if (!error) {
+            static struct dpif_linux_vport vport;
+            nln = nln_create(NETLINK_GENERIC, ovs_vport_mcgroup,
+                             dpif_linux_nln_parse, &vport);
+        }
     }
 
     return error;
@@ -1166,24 +1189,31 @@ dpif_linux_vport_send(int dp_ifindex, uint32_t port_no,
     ofpbuf_use_stack(&actions, &action, sizeof action);
     nl_msg_put_u32(&actions, OVS_ACTION_ATTR_OUTPUT, port_no);
 
-    return dpif_linux_execute__(dp_ifindex, key.data, key.size,
+    return dpif_linux_execute__(dp_ifindex, 0, key.data, key.size,
                                 actions.data, actions.size, &packet);
 }
 
+static bool
+dpif_linux_nln_parse(struct ofpbuf *buf, void *vport_)
+{
+    struct dpif_linux_vport *vport = vport_;
+    return dpif_linux_vport_from_ofpbuf(vport, buf) == 0;
+}
+
 static void
-dpif_linux_port_changed(const struct rtnetlink_link_change *change,
-                        void *dpif_)
+dpif_linux_port_changed(const void *vport_, void *dpif_)
 {
+    const struct dpif_linux_vport *vport = vport_;
     struct dpif_linux *dpif = dpif_;
 
-    if (change) {
-        if (change->master_ifindex == dpif->dp_ifindex
-            && (change->nlmsg_type == RTM_NEWLINK
-                || change->nlmsg_type == RTM_DELLINK))
-        {
-            /* Our datapath changed, either adding a new port or deleting an
-             * existing one. */
-            sset_add(&dpif->changed_ports, change->ifname);
+    if (vport) {
+        if (vport->dp_ifindex == dpif->dp_ifindex
+            && (vport->cmd == OVS_VPORT_CMD_NEW
+                || vport->cmd == OVS_VPORT_CMD_DEL
+                || vport->cmd == OVS_VPORT_CMD_SET)) {
+            VLOG_DBG("port_changed: dpif:%s vport:%s cmd:%"PRIu8,
+                     dpif->dpif.full_name, vport->name, vport->cmd);
+            sset_add(&dpif->changed_ports, vport->name);
         }
     } else {
         dpif->change_error = true;
@@ -1204,18 +1234,17 @@ dpif_linux_vport_from_ofpbuf(struct dpif_linux_vport *vport,
         [OVS_VPORT_ATTR_PORT_NO] = { .type = NL_A_U32 },
         [OVS_VPORT_ATTR_TYPE] = { .type = NL_A_U32 },
         [OVS_VPORT_ATTR_NAME] = { .type = NL_A_STRING, .max_len = IFNAMSIZ },
+        [OVS_VPORT_ATTR_UPCALL_PID] = { .type = NL_A_U32 },
         [OVS_VPORT_ATTR_STATS] = { .type = NL_A_UNSPEC,
-                                   .min_len = sizeof(struct rtnl_link_stats64),
-                                   .max_len = sizeof(struct rtnl_link_stats64),
+                                   .min_len = sizeof(struct ovs_vport_stats),
+                                   .max_len = sizeof(struct ovs_vport_stats),
                                    .optional = true },
         [OVS_VPORT_ATTR_ADDRESS] = { .type = NL_A_UNSPEC,
                                      .min_len = ETH_ADDR_LEN,
                                      .max_len = ETH_ADDR_LEN,
                                      .optional = true },
-        [OVS_VPORT_ATTR_MTU] = { .type = NL_A_U32, .optional = true },
         [OVS_VPORT_ATTR_OPTIONS] = { .type = NL_A_NESTED, .optional = true },
         [OVS_VPORT_ATTR_IFINDEX] = { .type = NL_A_U32, .optional = true },
-        [OVS_VPORT_ATTR_IFLINK] = { .type = NL_A_U32, .optional = true },
     };
 
     struct nlattr *a[ARRAY_SIZE(ovs_vport_policy)];
@@ -1242,17 +1271,15 @@ dpif_linux_vport_from_ofpbuf(struct dpif_linux_vport *vport,
     vport->port_no = nl_attr_get_u32(a[OVS_VPORT_ATTR_PORT_NO]);
     vport->type = nl_attr_get_u32(a[OVS_VPORT_ATTR_TYPE]);
     vport->name = nl_attr_get_string(a[OVS_VPORT_ATTR_NAME]);
+    if (a[OVS_VPORT_ATTR_UPCALL_PID]) {
+        vport->upcall_pid = nl_attr_get_u32(a[OVS_VPORT_ATTR_UPCALL_PID]);
+    }
     if (a[OVS_VPORT_ATTR_STATS]) {
         vport->stats = nl_attr_get(a[OVS_VPORT_ATTR_STATS]);
     }
     if (a[OVS_VPORT_ATTR_ADDRESS]) {
         vport->address = nl_attr_get(a[OVS_VPORT_ATTR_ADDRESS]);
     }
-    if (a[OVS_VPORT_ATTR_MTU]) {
-        vport->mtu = nl_attr_get_u32(a[OVS_VPORT_ATTR_MTU]);
-    } else {
-        vport->mtu = INT_MAX;
-    }
     if (a[OVS_VPORT_ATTR_OPTIONS]) {
         vport->options = nl_attr_get(a[OVS_VPORT_ATTR_OPTIONS]);
         vport->options_len = nl_attr_get_size(a[OVS_VPORT_ATTR_OPTIONS]);
@@ -1260,9 +1287,6 @@ dpif_linux_vport_from_ofpbuf(struct dpif_linux_vport *vport,
     if (a[OVS_VPORT_ATTR_IFINDEX]) {
         vport->ifindex = nl_attr_get_u32(a[OVS_VPORT_ATTR_IFINDEX]);
     }
-    if (a[OVS_VPORT_ATTR_IFLINK]) {
-        vport->iflink = nl_attr_get_u32(a[OVS_VPORT_ATTR_IFLINK]);
-    }
     return 0;
 }
 
@@ -1292,6 +1316,8 @@ dpif_linux_vport_to_ofpbuf(const struct dpif_linux_vport *vport,
         nl_msg_put_string(buf, OVS_VPORT_ATTR_NAME, vport->name);
     }
 
+    nl_msg_put_u32(buf, OVS_VPORT_ATTR_UPCALL_PID, vport->upcall_pid);
+
     if (vport->stats) {
         nl_msg_put_unspec(buf, OVS_VPORT_ATTR_STATS,
                           vport->stats, sizeof *vport->stats);
@@ -1302,10 +1328,6 @@ dpif_linux_vport_to_ofpbuf(const struct dpif_linux_vport *vport,
                           vport->address, ETH_ADDR_LEN);
     }
 
-    if (vport->mtu && vport->mtu != INT_MAX) {
-        nl_msg_put_u32(buf, OVS_VPORT_ATTR_MTU, vport->mtu);
-    }
-
     if (vport->options) {
         nl_msg_put_nested(buf, OVS_VPORT_ATTR_OPTIONS,
                           vport->options, vport->options_len);
@@ -1314,10 +1336,6 @@ dpif_linux_vport_to_ofpbuf(const struct dpif_linux_vport *vport,
     if (vport->ifindex) {
         nl_msg_put_u32(buf, OVS_VPORT_ATTR_IFINDEX, vport->ifindex);
     }
-
-    if (vport->iflink) {
-        nl_msg_put_u32(buf, OVS_VPORT_ATTR_IFLINK, vport->iflink);
-    }
 }
 
 /* Clears 'vport' to "empty" values. */
@@ -1404,7 +1422,6 @@ dpif_linux_dp_from_ofpbuf(struct dpif_linux_dp *dp, const struct ofpbuf *buf)
                                 .optional = true },
         [OVS_DP_ATTR_IPV4_FRAGS] = { .type = NL_A_U32, .optional = true },
         [OVS_DP_ATTR_SAMPLING] = { .type = NL_A_U32, .optional = true },
-        [OVS_DP_ATTR_MCGROUPS] = { .type = NL_A_NESTED, .optional = true },
     };
 
     struct nlattr *a[ARRAY_SIZE(ovs_datapath_policy)];
@@ -1442,34 +1459,6 @@ dpif_linux_dp_from_ofpbuf(struct dpif_linux_dp *dp, const struct ofpbuf *buf)
         dp->sampling = nl_attr_get(a[OVS_DP_ATTR_SAMPLING]);
     }
 
-    if (a[OVS_DP_ATTR_MCGROUPS]) {
-        static const struct nl_policy ovs_mcgroup_policy[] = {
-            [OVS_PACKET_CMD_MISS] = { .type = NL_A_U32, .optional = true },
-            [OVS_PACKET_CMD_ACTION] = { .type = NL_A_U32, .optional = true },
-            [OVS_PACKET_CMD_SAMPLE] = { .type = NL_A_U32, .optional = true },
-        };
-
-        struct nlattr *mcgroups[ARRAY_SIZE(ovs_mcgroup_policy)];
-
-        if (!nl_parse_nested(a[OVS_DP_ATTR_MCGROUPS], ovs_mcgroup_policy,
-                             mcgroups, ARRAY_SIZE(ovs_mcgroup_policy))) {
-            return EINVAL;
-        }
-
-        if (mcgroups[OVS_PACKET_CMD_MISS]) {
-            dp->mcgroups[DPIF_UC_MISS]
-                = nl_attr_get_u32(mcgroups[OVS_PACKET_CMD_MISS]);
-        }
-        if (mcgroups[OVS_PACKET_CMD_ACTION]) {
-            dp->mcgroups[DPIF_UC_ACTION]
-                = nl_attr_get_u32(mcgroups[OVS_PACKET_CMD_ACTION]);
-        }
-        if (mcgroups[OVS_PACKET_CMD_SAMPLE]) {
-            dp->mcgroups[DPIF_UC_SAMPLE]
-                = nl_attr_get_u32(mcgroups[OVS_PACKET_CMD_SAMPLE]);
-        }
-    }
-
     return 0;
 }
 
@@ -1489,6 +1478,8 @@ dpif_linux_dp_to_ofpbuf(const struct dpif_linux_dp *dp, struct ofpbuf *buf)
         nl_msg_put_string(buf, OVS_DP_ATTR_NAME, dp->name);
     }
 
+    nl_msg_put_u32(buf, OVS_DP_ATTR_UPCALL_PID, dp->upcall_pid);
+
     /* Skip OVS_DP_ATTR_STATS since we never have a reason to serialize it. */
 
     if (dp->ipv4_frags) {
@@ -1585,6 +1576,7 @@ dpif_linux_flow_from_ofpbuf(struct dpif_linux_flow *flow,
     static const struct nl_policy ovs_flow_policy[] = {
         [OVS_FLOW_ATTR_KEY] = { .type = NL_A_NESTED },
         [OVS_FLOW_ATTR_ACTIONS] = { .type = NL_A_NESTED, .optional = true },
+        [OVS_FLOW_ATTR_UPCALL_PID] = { .type = NL_A_U32 },
         [OVS_FLOW_ATTR_STATS] = { .type = NL_A_UNSPEC,
                                   .min_len = sizeof(struct ovs_flow_stats),
                                   .max_len = sizeof(struct ovs_flow_stats),
@@ -1621,6 +1613,9 @@ dpif_linux_flow_from_ofpbuf(struct dpif_linux_flow *flow,
         flow->actions = nl_attr_get(a[OVS_FLOW_ATTR_ACTIONS]);
         flow->actions_len = nl_attr_get_size(a[OVS_FLOW_ATTR_ACTIONS]);
     }
+    if (a[OVS_FLOW_ATTR_UPCALL_PID]) {
+        flow->upcall_pid = nl_attr_get_u32(a[OVS_FLOW_ATTR_UPCALL_PID]);
+    }
     if (a[OVS_FLOW_ATTR_STATS]) {
         flow->stats = nl_attr_get(a[OVS_FLOW_ATTR_STATS]);
     }
@@ -1657,6 +1652,8 @@ dpif_linux_flow_to_ofpbuf(const struct dpif_linux_flow *flow,
                           flow->actions, flow->actions_len);
     }
 
+    nl_msg_put_u32(buf, OVS_FLOW_ATTR_UPCALL_PID, flow->upcall_pid);
+
     /* We never need to send these to the kernel. */
     assert(!flow->stats);
     assert(!flow->tcp_flags);