openvswitch: Add support for unique flow IDs. (74ed7ab9) · Commits · 戴 / test

Documentation/networking/openvswitch.txt

+13 −0

Original line number	Diff line number	Diff line
		@@ -131,6 +131,19 @@ performs best-effort detection of overlapping wildcarded flows and may reject
		some but not all of them. However, this behavior may change in future versions.


		Unique flow identifiers
		-----------------------

		An alternative to using the original match portion of a key as the handle for
		flow identification is a unique flow identifier, or "UFID". UFIDs are optional
		for both the kernel and user space program.

		User space programs that support UFID are expected to provide it during flow
		setup in addition to the flow, then refer to the flow using the UFID for all
		future operations. The kernel is not required to index flows by the original
		flow key if a UFID is specified.


		Basic rule for evolving flow keys
		---------------------------------

include/uapi/linux/openvswitch.h

+20 −0

Original line number	Diff line number	Diff line
		@@ -459,6 +459,14 @@ struct ovs_key_nd {
		* a wildcarded match. Omitting attribute is treated as wildcarding all
		* corresponding fields. Optional for all requests. If not present,
		* all flow key bits are exact match bits.
		* @OVS_FLOW_ATTR_UFID: A value between 1-16 octets specifying a unique
		* identifier for the flow. Causes the flow to be indexed by this value rather
		* than the value of the %OVS_FLOW_ATTR_KEY attribute. Optional for all
		* requests. Present in notifications if the flow was created with this
		* attribute.
		* @OVS_FLOW_ATTR_UFID_FLAGS: A 32-bit value of OR'd %OVS_UFID_F_*
		* flags that provide alternative semantics for flow installation and
		* retrieval. Optional for all requests.
		*
		* These attributes follow the &struct ovs_header within the Generic Netlink
		* payload for %OVS_FLOW_* commands.
		@@ -474,11 +482,23 @@ enum ovs_flow_attr {
		OVS_FLOW_ATTR_MASK, /* Sequence of OVS_KEY_ATTR_* attributes. */
		OVS_FLOW_ATTR_PROBE, /* Flow operation is a feature probe, error
		* logging should be suppressed. */
		OVS_FLOW_ATTR_UFID, /* Variable length unique flow identifier. */
		OVS_FLOW_ATTR_UFID_FLAGS,/* u32 of OVS_UFID_F_. /
		__OVS_FLOW_ATTR_MAX
		};

		#define OVS_FLOW_ATTR_MAX (__OVS_FLOW_ATTR_MAX - 1)

		/**
		* Omit attributes for notifications.
		*
		* If a datapath request contains an %OVS_UFID_F_OMIT_* flag, then the datapath
		* may omit the corresponding %OVS_FLOW_ATTR_* from the response.
		*/
		#define OVS_UFID_F_OMIT_KEY (1 << 0)
		#define OVS_UFID_F_OMIT_MASK (1 << 1)
		#define OVS_UFID_F_OMIT_ACTIONS (1 << 2)

		/**
		* enum ovs_sample_attr - Attributes for %OVS_ACTION_ATTR_SAMPLE action.
		* @OVS_SAMPLE_ATTR_PROBABILITY: 32-bit fraction of packets to sample with

net/openvswitch/datapath.c

+157 −50

Original line number	Diff line number	Diff line
		@@ -65,6 +65,8 @@ static struct genl_family dp_packet_genl_family;
		static struct genl_family dp_flow_genl_family;
		static struct genl_family dp_datapath_genl_family;

		static const struct nla_policy flow_policy[];

		static const struct genl_multicast_group ovs_dp_flow_multicast_group = {
		.name = OVS_FLOW_MCGROUP,
		};
		@@ -662,15 +664,48 @@ static void get_dp_stats(const struct datapath dp, struct ovs_dp_stats stats,
		}
		}

		static size_t ovs_flow_cmd_msg_size(const struct sw_flow_actions *acts)
		static bool should_fill_key(const struct sw_flow_id *sfid, uint32_t ufid_flags)
		{
		return ovs_identifier_is_ufid(sfid) &&
		!(ufid_flags & OVS_UFID_F_OMIT_KEY);
		}

		static bool should_fill_mask(uint32_t ufid_flags)
		{
		return !(ufid_flags & OVS_UFID_F_OMIT_MASK);
		}

		static bool should_fill_actions(uint32_t ufid_flags)
		{
		return NLMSG_ALIGN(sizeof(struct ovs_header))
		+ nla_total_size(ovs_key_attr_size()) /* OVS_FLOW_ATTR_KEY */
		+ nla_total_size(ovs_key_attr_size()) /* OVS_FLOW_ATTR_MASK */
		return !(ufid_flags & OVS_UFID_F_OMIT_ACTIONS);
		}

		static size_t ovs_flow_cmd_msg_size(const struct sw_flow_actions *acts,
		const struct sw_flow_id *sfid,
		uint32_t ufid_flags)
		{
		size_t len = NLMSG_ALIGN(sizeof(struct ovs_header));

		/* OVS_FLOW_ATTR_UFID */
		if (sfid && ovs_identifier_is_ufid(sfid))
		len += nla_total_size(sfid->ufid_len);

		/* OVS_FLOW_ATTR_KEY */
		if (!sfid \|\| should_fill_key(sfid, ufid_flags))
		len += nla_total_size(ovs_key_attr_size());

		/* OVS_FLOW_ATTR_MASK */
		if (should_fill_mask(ufid_flags))
		len += nla_total_size(ovs_key_attr_size());

		/* OVS_FLOW_ATTR_ACTIONS */
		if (should_fill_actions(ufid_flags))
		len += nla_total_size(acts->actions_len);

		return len
		+ nla_total_size(sizeof(struct ovs_flow_stats)) /* OVS_FLOW_ATTR_STATS */
		+ nla_total_size(1) /* OVS_FLOW_ATTR_TCP_FLAGS */
		+ nla_total_size(8) /* OVS_FLOW_ATTR_USED */
		+ nla_total_size(acts->actions_len); /* OVS_FLOW_ATTR_ACTIONS */
		+ nla_total_size(8); /* OVS_FLOW_ATTR_USED */
		}

		/* Called with ovs_mutex or RCU read lock. */
		@@ -741,7 +776,7 @@ static int ovs_flow_cmd_fill_actions(const struct sw_flow *flow,
		/* Called with ovs_mutex or RCU read lock. */
		static int ovs_flow_cmd_fill_info(const struct sw_flow *flow, int dp_ifindex,
		struct sk_buff *skb, u32 portid,
		u32 seq, u32 flags, u8 cmd)
		u32 seq, u32 flags, u8 cmd, u32 ufid_flags)
		{
		const int skb_orig_len = skb->len;
		struct ovs_header *ovs_header;
		@@ -754,21 +789,31 @@ static int ovs_flow_cmd_fill_info(const struct sw_flow *flow, int dp_ifindex,

		ovs_header->dp_ifindex = dp_ifindex;

		err = ovs_nla_put_unmasked_key(flow, skb);
		err = ovs_nla_put_identifier(flow, skb);
		if (err)
		goto error;

		if (should_fill_key(&flow->id, ufid_flags)) {
		err = ovs_nla_put_masked_key(flow, skb);
		if (err)
		goto error;
		}

		if (should_fill_mask(ufid_flags)) {
		err = ovs_nla_put_mask(flow, skb);
		if (err)
		goto error;
		}

		err = ovs_flow_cmd_fill_stats(flow, skb);
		if (err)
		goto error;

		if (should_fill_actions(ufid_flags)) {
		err = ovs_flow_cmd_fill_actions(flow, skb, skb_orig_len);
		if (err)
		goto error;
		}

		genlmsg_end(skb, ovs_header);
		return 0;
		@@ -780,15 +825,19 @@ error:

		/* May not be called with RCU read lock. */
		static struct sk_buff ovs_flow_cmd_alloc_info(const struct sw_flow_actions acts,
		const struct sw_flow_id *sfid,
		struct genl_info *info,
		bool always)
		bool always,
		uint32_t ufid_flags)
		{
		struct sk_buff *skb;
		size_t len;

		if (!always && !ovs_must_notify(&dp_flow_genl_family, info, 0))
		return NULL;

		skb = genlmsg_new_unicast(ovs_flow_cmd_msg_size(acts), info, GFP_KERNEL);
		len = ovs_flow_cmd_msg_size(acts, sfid, ufid_flags);
		skb = genlmsg_new_unicast(len, info, GFP_KERNEL);
		if (!skb)
		return ERR_PTR(-ENOMEM);

		@@ -799,19 +848,19 @@ static struct sk_buff ovs_flow_cmd_alloc_info(const struct sw_flow_actions act
		static struct sk_buff ovs_flow_cmd_build_info(const struct sw_flow flow,
		int dp_ifindex,
		struct genl_info *info, u8 cmd,
		bool always)
		bool always, u32 ufid_flags)
		{
		struct sk_buff *skb;
		int retval;

		skb = ovs_flow_cmd_alloc_info(ovsl_dereference(flow->sf_acts), info,
		always);
		skb = ovs_flow_cmd_alloc_info(ovsl_dereference(flow->sf_acts),
		&flow->id, info, always, ufid_flags);
		if (IS_ERR_OR_NULL(skb))
		return skb;

		retval = ovs_flow_cmd_fill_info(flow, dp_ifindex, skb,
		info->snd_portid, info->snd_seq, 0,
		cmd);
		cmd, ufid_flags);
		BUG_ON(retval < 0);
		return skb;
		}
		@@ -820,12 +869,14 @@ static int ovs_flow_cmd_new(struct sk_buff skb, struct genl_info info)
		{
		struct nlattr **a = info->attrs;
		struct ovs_header *ovs_header = info->userhdr;
		struct sw_flow flow, new_flow;
		struct sw_flow flow = NULL, new_flow;
		struct sw_flow_mask mask;
		struct sk_buff *reply;
		struct datapath *dp;
		struct sw_flow_key key;
		struct sw_flow_actions *acts;
		struct sw_flow_match match;
		u32 ufid_flags = ovs_nla_get_ufid_flags(a[OVS_FLOW_ATTR_UFID_FLAGS]);
		int error;
		bool log = !a[OVS_FLOW_ATTR_PROBE];

		@@ -850,13 +901,19 @@ static int ovs_flow_cmd_new(struct sk_buff skb, struct genl_info info)
		}

		/* Extract key. */
		ovs_match_init(&match, &new_flow->unmasked_key, &mask);
		ovs_match_init(&match, &key, &mask);
		error = ovs_nla_get_match(&match, a[OVS_FLOW_ATTR_KEY],
		a[OVS_FLOW_ATTR_MASK], log);
		if (error)
		goto err_kfree_flow;

		ovs_flow_mask_key(&new_flow->key, &new_flow->unmasked_key, &mask);
		ovs_flow_mask_key(&new_flow->key, &key, &mask);

		/* Extract flow identifier. */
		error = ovs_nla_get_identifier(&new_flow->id, a[OVS_FLOW_ATTR_UFID],
		&key, log);
		if (error)
		goto err_kfree_flow;

		/* Validate actions. */
		error = ovs_nla_copy_actions(a[OVS_FLOW_ATTR_ACTIONS], &new_flow->key,
		@@ -866,7 +923,8 @@ static int ovs_flow_cmd_new(struct sk_buff skb, struct genl_info info)
		goto err_kfree_flow;
		}

		reply = ovs_flow_cmd_alloc_info(acts, info, false);
		reply = ovs_flow_cmd_alloc_info(acts, &new_flow->id, info, false,
		ufid_flags);
		if (IS_ERR(reply)) {
		error = PTR_ERR(reply);
		goto err_kfree_acts;
		@@ -878,8 +936,12 @@ static int ovs_flow_cmd_new(struct sk_buff skb, struct genl_info info)
		error = -ENODEV;
		goto err_unlock_ovs;
		}

		/* Check if this is a duplicate flow */
		flow = ovs_flow_tbl_lookup(&dp->table, &new_flow->unmasked_key);
		if (ovs_identifier_is_ufid(&new_flow->id))
		flow = ovs_flow_tbl_lookup_ufid(&dp->table, &new_flow->id);
		if (!flow)
		flow = ovs_flow_tbl_lookup(&dp->table, &key);
		if (likely(!flow)) {
		rcu_assign_pointer(new_flow->sf_acts, acts);

		@@ -895,7 +957,8 @@ static int ovs_flow_cmd_new(struct sk_buff skb, struct genl_info info)
		ovs_header->dp_ifindex,
		reply, info->snd_portid,
		info->snd_seq, 0,
		OVS_FLOW_CMD_NEW);
		OVS_FLOW_CMD_NEW,
		ufid_flags);
		BUG_ON(error < 0);
		}
		ovs_unlock();
		@@ -913,10 +976,15 @@ static int ovs_flow_cmd_new(struct sk_buff skb, struct genl_info info)
		error = -EEXIST;
		goto err_unlock_ovs;
		}
		/* The unmasked key has to be the same for flow updates. */
		if (unlikely(!ovs_flow_cmp_unmasked_key(flow, &match))) {
		/* Look for any overlapping flow. */
		flow = ovs_flow_tbl_lookup_exact(&dp->table, &match);
		/* The flow identifier has to be the same for flow updates.
		* Look for any overlapping flow.
		*/
		if (unlikely(!ovs_flow_cmp(flow, &match))) {
		if (ovs_identifier_is_key(&flow->id))
		flow = ovs_flow_tbl_lookup_exact(&dp->table,
		&match);
		else /* UFID matches but key is different */
		flow = NULL;
		if (!flow) {
		error = -ENOENT;
		goto err_unlock_ovs;
		@@ -931,7 +999,8 @@ static int ovs_flow_cmd_new(struct sk_buff skb, struct genl_info info)
		ovs_header->dp_ifindex,
		reply, info->snd_portid,
		info->snd_seq, 0,
		OVS_FLOW_CMD_NEW);
		OVS_FLOW_CMD_NEW,
		ufid_flags);
		BUG_ON(error < 0);
		}
		ovs_unlock();
		@@ -987,8 +1056,11 @@ static int ovs_flow_cmd_set(struct sk_buff skb, struct genl_info info)
		struct datapath *dp;
		struct sw_flow_actions old_acts = NULL, acts = NULL;
		struct sw_flow_match match;
		struct sw_flow_id sfid;
		u32 ufid_flags = ovs_nla_get_ufid_flags(a[OVS_FLOW_ATTR_UFID_FLAGS]);
		int error;
		bool log = !a[OVS_FLOW_ATTR_PROBE];
		bool ufid_present;

		/* Extract key. */
		error = -EINVAL;
		@@ -997,6 +1069,7 @@ static int ovs_flow_cmd_set(struct sk_buff skb, struct genl_info info)
		goto error;
		}

		ufid_present = ovs_nla_get_ufid(&sfid, a[OVS_FLOW_ATTR_UFID], log);
		ovs_match_init(&match, &key, &mask);
		error = ovs_nla_get_match(&match, a[OVS_FLOW_ATTR_KEY],
		a[OVS_FLOW_ATTR_MASK], log);
		@@ -1013,7 +1086,8 @@ static int ovs_flow_cmd_set(struct sk_buff skb, struct genl_info info)
		}

		/* Can allocate before locking if have acts. */
		reply = ovs_flow_cmd_alloc_info(acts, info, false);
		reply = ovs_flow_cmd_alloc_info(acts, &sfid, info, false,
		ufid_flags);
		if (IS_ERR(reply)) {
		error = PTR_ERR(reply);
		goto err_kfree_acts;
		@@ -1027,6 +1101,9 @@ static int ovs_flow_cmd_set(struct sk_buff skb, struct genl_info info)
		goto err_unlock_ovs;
		}
		/* Check that the flow exists. */
		if (ufid_present)
		flow = ovs_flow_tbl_lookup_ufid(&dp->table, &sfid);
		else
		flow = ovs_flow_tbl_lookup_exact(&dp->table, &match);
		if (unlikely(!flow)) {
		error = -ENOENT;
		@@ -1043,13 +1120,16 @@ static int ovs_flow_cmd_set(struct sk_buff skb, struct genl_info info)
		ovs_header->dp_ifindex,
		reply, info->snd_portid,
		info->snd_seq, 0,
		OVS_FLOW_CMD_NEW);
		OVS_FLOW_CMD_NEW,
		ufid_flags);
		BUG_ON(error < 0);
		}
		} else {
		/* Could not alloc without acts before locking. */
		reply = ovs_flow_cmd_build_info(flow, ovs_header->dp_ifindex,
		info, OVS_FLOW_CMD_NEW, false);
		info, OVS_FLOW_CMD_NEW, false,
		ufid_flags);

		if (unlikely(IS_ERR(reply))) {
		error = PTR_ERR(reply);
		goto err_unlock_ovs;
		@@ -1086,17 +1166,22 @@ static int ovs_flow_cmd_get(struct sk_buff skb, struct genl_info info)
		struct sw_flow *flow;
		struct datapath *dp;
		struct sw_flow_match match;
		int err;
		struct sw_flow_id ufid;
		u32 ufid_flags = ovs_nla_get_ufid_flags(a[OVS_FLOW_ATTR_UFID_FLAGS]);
		int err = 0;
		bool log = !a[OVS_FLOW_ATTR_PROBE];
		bool ufid_present;

		if (!a[OVS_FLOW_ATTR_KEY]) {
		ufid_present = ovs_nla_get_ufid(&ufid, a[OVS_FLOW_ATTR_UFID], log);
		if (a[OVS_FLOW_ATTR_KEY]) {
		ovs_match_init(&match, &key, NULL);
		err = ovs_nla_get_match(&match, a[OVS_FLOW_ATTR_KEY], NULL,
		log);
		} else if (!ufid_present) {
		OVS_NLERR(log,
		"Flow get message rejected, Key attribute missing.");
		return -EINVAL;
		err = -EINVAL;
		}

		ovs_match_init(&match, &key, NULL);
		err = ovs_nla_get_match(&match, a[OVS_FLOW_ATTR_KEY], NULL, log);
		if (err)
		return err;

		@@ -1107,6 +1192,9 @@ static int ovs_flow_cmd_get(struct sk_buff skb, struct genl_info info)
		goto unlock;
		}

		if (ufid_present)
		flow = ovs_flow_tbl_lookup_ufid(&dp->table, &ufid);
		else
		flow = ovs_flow_tbl_lookup_exact(&dp->table, &match);
		if (!flow) {
		err = -ENOENT;
		@@ -1114,7 +1202,7 @@ static int ovs_flow_cmd_get(struct sk_buff skb, struct genl_info info)
		}

		reply = ovs_flow_cmd_build_info(flow, ovs_header->dp_ifindex, info,
		OVS_FLOW_CMD_NEW, true);
		OVS_FLOW_CMD_NEW, true, ufid_flags);
		if (IS_ERR(reply)) {
		err = PTR_ERR(reply);
		goto unlock;
		@@ -1133,13 +1221,17 @@ static int ovs_flow_cmd_del(struct sk_buff skb, struct genl_info info)
		struct ovs_header *ovs_header = info->userhdr;
		struct sw_flow_key key;
		struct sk_buff *reply;
		struct sw_flow *flow;
		struct sw_flow *flow = NULL;
		struct datapath *dp;
		struct sw_flow_match match;
		struct sw_flow_id ufid;
		u32 ufid_flags = ovs_nla_get_ufid_flags(a[OVS_FLOW_ATTR_UFID_FLAGS]);
		int err;
		bool log = !a[OVS_FLOW_ATTR_PROBE];
		bool ufid_present;

		if (likely(a[OVS_FLOW_ATTR_KEY])) {
		ufid_present = ovs_nla_get_ufid(&ufid, a[OVS_FLOW_ATTR_UFID], log);
		if (a[OVS_FLOW_ATTR_KEY]) {
		ovs_match_init(&match, &key, NULL);
		err = ovs_nla_get_match(&match, a[OVS_FLOW_ATTR_KEY], NULL,
		log);
		@@ -1154,11 +1246,14 @@ static int ovs_flow_cmd_del(struct sk_buff skb, struct genl_info info)
		goto unlock;
		}

		if (unlikely(!a[OVS_FLOW_ATTR_KEY])) {
		if (unlikely(!a[OVS_FLOW_ATTR_KEY] && !ufid_present)) {
		err = ovs_flow_tbl_flush(&dp->table);
		goto unlock;
		}

		if (ufid_present)
		flow = ovs_flow_tbl_lookup_ufid(&dp->table, &ufid);
		else
		flow = ovs_flow_tbl_lookup_exact(&dp->table, &match);
		if (unlikely(!flow)) {
		err = -ENOENT;
		@@ -1169,14 +1264,15 @@ static int ovs_flow_cmd_del(struct sk_buff skb, struct genl_info info)
		ovs_unlock();

		reply = ovs_flow_cmd_alloc_info((const struct sw_flow_actions __force *) flow->sf_acts,
		info, false);
		&flow->id, info, false, ufid_flags);
		if (likely(reply)) {
		if (likely(!IS_ERR(reply))) {
		rcu_read_lock(); /To keep RCU checker happy. /
		err = ovs_flow_cmd_fill_info(flow, ovs_header->dp_ifindex,
		reply, info->snd_portid,
		info->snd_seq, 0,
		OVS_FLOW_CMD_DEL);
		OVS_FLOW_CMD_DEL,
		ufid_flags);
		rcu_read_unlock();
		BUG_ON(err < 0);

		@@ -1195,9 +1291,18 @@ unlock:

		static int ovs_flow_cmd_dump(struct sk_buff skb, struct netlink_callback cb)
		{
		struct nlattr *a[__OVS_FLOW_ATTR_MAX];
		struct ovs_header *ovs_header = genlmsg_data(nlmsg_data(cb->nlh));
		struct table_instance *ti;
		struct datapath *dp;
		u32 ufid_flags;
		int err;

		err = genlmsg_parse(cb->nlh, &dp_flow_genl_family, a,
		OVS_FLOW_ATTR_MAX, flow_policy);
		if (err)
		return err;
		ufid_flags = ovs_nla_get_ufid_flags(a[OVS_FLOW_ATTR_UFID_FLAGS]);

		rcu_read_lock();
		dp = get_dp_rcu(sock_net(skb->sk), ovs_header->dp_ifindex);
		@@ -1220,7 +1325,7 @@ static int ovs_flow_cmd_dump(struct sk_buff skb, struct netlink_callback cb)
		if (ovs_flow_cmd_fill_info(flow, ovs_header->dp_ifindex, skb,
		NETLINK_CB(cb->skb).portid,
		cb->nlh->nlmsg_seq, NLM_F_MULTI,
		OVS_FLOW_CMD_NEW) < 0)
		OVS_FLOW_CMD_NEW, ufid_flags) < 0)
		break;

		cb->args[0] = bucket;
		@@ -1236,6 +1341,8 @@ static const struct nla_policy flow_policy[OVS_FLOW_ATTR_MAX + 1] = {
		[OVS_FLOW_ATTR_ACTIONS] = { .type = NLA_NESTED },
		[OVS_FLOW_ATTR_CLEAR] = { .type = NLA_FLAG },
		[OVS_FLOW_ATTR_PROBE] = { .type = NLA_FLAG },
		[OVS_FLOW_ATTR_UFID] = { .type = NLA_UNSPEC, .len = 1 },
		[OVS_FLOW_ATTR_UFID_FLAGS] = { .type = NLA_U32 },
		};

		static const struct genl_ops dp_flow_genl_ops[] = {

net/openvswitch/flow.h

+25 −3

Original line number	Diff line number	Diff line
		@@ -197,6 +197,16 @@ struct sw_flow_match {
		struct sw_flow_mask *mask;
		};

		#define MAX_UFID_LENGTH 16 /* 128 bits */

		struct sw_flow_id {
		u32 ufid_len;
		union {
		u32 ufid[MAX_UFID_LENGTH / 4];
		struct sw_flow_key *unmasked_key;
		};
		};

		struct sw_flow_actions {
		struct rcu_head rcu;
		u32 actions_len;
		@@ -213,13 +223,15 @@ struct flow_stats {

		struct sw_flow {
		struct rcu_head rcu;
		struct hlist_node hash_node[2];
		struct {
		struct hlist_node node[2];
		u32 hash;
		} flow_table, ufid_table;
		int stats_last_writer; /* NUMA-node id of the last writer on
		* 'stats[0]'.
		*/
		struct sw_flow_key key;
		struct sw_flow_key unmasked_key;
		struct sw_flow_id id;
		struct sw_flow_mask *mask;
		struct sw_flow_actions __rcu *sf_acts;
		struct flow_stats __rcu stats[]; / One for each NUMA node. First one
		@@ -243,6 +255,16 @@ struct arp_eth_header {
		unsigned char ar_tip[4]; /* target IP address */
		} __packed;

		static inline bool ovs_identifier_is_ufid(const struct sw_flow_id *sfid)
		{
		return sfid->ufid_len;
		}

		static inline bool ovs_identifier_is_key(const struct sw_flow_id *sfid)
		{
		return !ovs_identifier_is_ufid(sfid);
		}

		void ovs_flow_stats_update(struct sw_flow *, __be16 tcp_flags,
		const struct sk_buff *);
		void ovs_flow_stats_get(const struct sw_flow , struct ovs_flow_stats ,

net/openvswitch/flow_netlink.c

+66 −2

Original line number	Diff line number	Diff line
		@@ -1180,6 +1180,59 @@ free_newmask:
		return err;
		}

		static size_t get_ufid_len(const struct nlattr *attr, bool log)
		{
		size_t len;

		if (!attr)
		return 0;

		len = nla_len(attr);
		if (len < 1 \|\| len > MAX_UFID_LENGTH) {
		OVS_NLERR(log, "ufid size %u bytes exceeds the range (1, %d)",
		nla_len(attr), MAX_UFID_LENGTH);
		return 0;
		}

		return len;
		}

		/* Initializes 'flow->ufid', returning true if 'attr' contains a valid UFID,
		* or false otherwise.
		*/
		bool ovs_nla_get_ufid(struct sw_flow_id sfid, const struct nlattr attr,
		bool log)
		{
		sfid->ufid_len = get_ufid_len(attr, log);
		if (sfid->ufid_len)
		memcpy(sfid->ufid, nla_data(attr), sfid->ufid_len);

		return sfid->ufid_len;
		}

		int ovs_nla_get_identifier(struct sw_flow_id sfid, const struct nlattr ufid,
		const struct sw_flow_key *key, bool log)
		{
		struct sw_flow_key *new_key;

		if (ovs_nla_get_ufid(sfid, ufid, log))
		return 0;

		/* If UFID was not provided, use unmasked key. */
		new_key = kmalloc(sizeof(*new_key), GFP_KERNEL);
		if (!new_key)
		return -ENOMEM;
		memcpy(new_key, key, sizeof(*key));
		sfid->unmasked_key = new_key;

		return 0;
		}

		u32 ovs_nla_get_ufid_flags(const struct nlattr *attr)
		{
		return attr ? nla_get_u32(attr) : 0;
		}

		/**
		* ovs_nla_get_flow_metadata - parses Netlink attributes into a flow key.
		* @key: Receives extracted in_port, priority, tun_key and skb_mark.
		@@ -1450,9 +1503,20 @@ int ovs_nla_put_key(const struct sw_flow_key *swkey,
		}

		/* Called with ovs_mutex or RCU read lock. */
		int ovs_nla_put_unmasked_key(const struct sw_flow flow, struct sk_buff skb)
		int ovs_nla_put_identifier(const struct sw_flow flow, struct sk_buff skb)
		{
		if (ovs_identifier_is_ufid(&flow->id))
		return nla_put(skb, OVS_FLOW_ATTR_UFID, flow->id.ufid_len,
		flow->id.ufid);

		return ovs_nla_put_key(flow->id.unmasked_key, flow->id.unmasked_key,
		OVS_FLOW_ATTR_KEY, false, skb);
		}

		/* Called with ovs_mutex or RCU read lock. */
		int ovs_nla_put_masked_key(const struct sw_flow flow, struct sk_buff skb)
		{
		return ovs_nla_put_key(&flow->unmasked_key, &flow->unmasked_key,
		return ovs_nla_put_key(&flow->mask->key, &flow->key,
		OVS_FLOW_ATTR_KEY, false, skb);
		}

Admin message