X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=datapath%2Ftunnel.c;h=08906e4ca1ba4b02561311af5638febfd4cbf087;hb=c19e653509deb3f1002c4ed99714e16549ec74e9;hp=239e604c7dbf1e0d722f7cf292530d83b3ad05b7;hpb=ad9197112ae58f338491e6344a9f66073e4bce95;p=sliver-openvswitch.git

diff --git a/datapath/tunnel.c b/datapath/tunnel.c
index 239e604c7..08906e4ca 100644
--- a/datapath/tunnel.c
+++ b/datapath/tunnel.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010 Nicira Networks.
+ * Copyright (c) 2010, 2011 Nicira Networks.
  * Distributed under the terms of the GNU GPL version 2.
  *
  * Significant portions of this file may be copied from parts of the Linux
@@ -99,6 +99,15 @@ static inline struct tnl_vport *tnl_vport_table_cast(const struct tbl_node *node
 	return container_of(node, struct tnl_vport, tbl_node);
 }
 
+/* This is analogous to rtnl_dereference for the tunnel cache.  It checks that
+ * cache_lock is held, so it is only for update side code.
+ */
+static inline struct tnl_cache *cache_dereference(struct tnl_vport *tnl_vport)
+{
+	return rcu_dereference_protected(tnl_vport->cache,
+					 lockdep_is_held(&tnl_vport->cache_lock));
+}
+
 static inline void schedule_cache_cleaner(void)
 {
 	schedule_delayed_work(&cache_cleaner_wq, CACHE_CLEANER_INTERVAL);
@@ -142,7 +151,7 @@ static void assign_cache_rcu(struct vport *vport, struct tnl_cache *new_cache)
 	struct tnl_vport *tnl_vport = tnl_vport_priv(vport);
 	struct tnl_cache *old_cache;
 
-	old_cache = tnl_vport->cache;
+	old_cache = cache_dereference(tnl_vport);
 	rcu_assign_pointer(tnl_vport->cache, new_cache);
 
 	if (old_cache)
@@ -151,13 +160,13 @@ static void assign_cache_rcu(struct vport *vport, struct tnl_cache *new_cache)
 
 static unsigned int *find_port_pool(const struct tnl_mutable_config *mutable)
 {
-	if (mutable->port_config.flags & TNL_F_IN_KEY_MATCH) {
-		if (mutable->port_config.saddr)
+	if (mutable->flags & TNL_F_IN_KEY_MATCH) {
+		if (mutable->saddr)
 			return &local_remote_ports;
 		else
 			return &remote_ports;
 	} else {
-		if (mutable->port_config.saddr)
+		if (mutable->saddr)
 			return &key_local_remote_ports;
 		else
 			return &key_remote_ports;
@@ -181,12 +190,12 @@ static int port_cmp(const struct tbl_node *node, void *target)
 	const struct tnl_vport *tnl_vport = tnl_vport_table_cast(node);
 	struct port_lookup_key *lookup = target;
 
-	lookup->mutable = rcu_dereference(tnl_vport->mutable);
+	lookup->mutable = rcu_dereference_rtnl(tnl_vport->mutable);
 
 	return (lookup->mutable->tunnel_type == lookup->tunnel_type &&
-		lookup->mutable->port_config.daddr == lookup->daddr &&
-		lookup->mutable->port_config.in_key == lookup->key &&
-		lookup->mutable->port_config.saddr == lookup->saddr);
+		lookup->mutable->daddr == lookup->daddr &&
+		lookup->mutable->in_key == lookup->key &&
+		lookup->mutable->saddr == lookup->saddr);
 }
 
 static u32 port_hash(struct port_lookup_key *k)
@@ -200,9 +209,9 @@ static u32 mutable_hash(const struct tnl_mutable_config *mutable)
 {
 	struct port_lookup_key lookup;
 
-	lookup.saddr = mutable->port_config.saddr;
-	lookup.daddr = mutable->port_config.daddr;
-	lookup.key = mutable->port_config.in_key;
+	lookup.saddr = mutable->saddr;
+	lookup.daddr = mutable->daddr;
+	lookup.key = mutable->in_key;
 	lookup.tunnel_type = mutable->tunnel_type;
 
 	return port_hash(&lookup);
@@ -228,7 +237,7 @@ static int add_port(struct vport *vport)
 	if (!port_table) {
 		struct tbl *new_table;
 
-		new_table = tbl_create(0);
+		new_table = tbl_create(TBL_MIN_BUCKETS);
 		if (!new_table)
 			return -ENOMEM;
 
@@ -313,7 +322,7 @@ struct vport *tnl_find_port(__be32 saddr, __be32 daddr, __be64 key,
 			    const struct tnl_mutable_config **mutable)
 {
 	struct port_lookup_key lookup;
-	struct tbl *table = rcu_dereference(port_table);
+	struct tbl *table = rcu_dereference_rtnl(port_table);
 	struct tbl_node *tbl_node;
 
 	if (unlikely(!table))
@@ -692,7 +701,7 @@ bool tnl_frag_needed(struct vport *vport, const struct tnl_mutable_config *mutab
 	 * not symmetric then PMTUD needs to be disabled since we won't have
 	 * any way of synthesizing packets.
 	 */
-	if ((mutable->port_config.flags & (TNL_F_IN_KEY_MATCH | TNL_F_OUT_KEY_ACTION)) ==
+	if ((mutable->flags & (TNL_F_IN_KEY_MATCH | TNL_F_OUT_KEY_ACTION)) ==
 	    (TNL_F_IN_KEY_MATCH | TNL_F_OUT_KEY_ACTION))
 		OVS_CB(nskb)->tun_id = flow_key;
 
@@ -710,7 +719,7 @@ static bool check_mtu(struct sk_buff *skb,
 	int mtu;
 	__be16 frag_off;
 
-	frag_off = (mutable->port_config.flags & TNL_F_PMTUD) ? htons(IP_DF) : 0;
+	frag_off = (mutable->flags & TNL_F_PMTUD) ? htons(IP_DF) : 0;
 	if (frag_off)
 		mtu = dst_mtu(&rt_dst(rt))
 			- ETH_HLEN
@@ -768,10 +777,10 @@ static void create_tunnel_header(const struct vport *vport,
 	iph->ihl	= sizeof(struct iphdr) >> 2;
 	iph->frag_off	= htons(IP_DF);
 	iph->protocol	= tnl_vport->tnl_ops->ipproto;
-	iph->tos	= mutable->port_config.tos;
+	iph->tos	= mutable->tos;
 	iph->daddr	= rt->rt_dst;
 	iph->saddr	= rt->rt_src;
-	iph->ttl	= mutable->port_config.ttl;
+	iph->ttl	= mutable->ttl;
 	if (!iph->ttl)
 		iph->ttl = dst_metric(&rt_dst(rt), RTAX_HOPLIMIT);
 
@@ -857,7 +866,7 @@ static struct tnl_cache *build_cache(struct vport *vport,
 	void *cache_data;
 	int cache_len;
 
-	if (!(mutable->port_config.flags & TNL_F_HDR_CACHE))
+	if (!(mutable->flags & TNL_F_HDR_CACHE))
 		return NULL;
 
 	/*
@@ -874,7 +883,7 @@ static struct tnl_cache *build_cache(struct vport *vport,
 	if (!spin_trylock_bh(&tnl_vport->cache_lock))
 		return NULL;
 
-	cache = tnl_vport->cache;
+	cache = cache_dereference(tnl_vport);
 	if (check_cache_valid(cache, mutable))
 		goto unlock;
 	else
@@ -901,15 +910,15 @@ static struct tnl_cache *build_cache(struct vport *vport,
 #endif
 
 	if (is_internal_dev(rt_dst(rt).dev)) {
-		struct odp_flow_key flow_key;
+		struct sw_flow_key flow_key;
 		struct tbl_node *flow_node;
-		struct vport *vport;
+		struct vport *dst_vport;
 		struct sk_buff *skb;
 		bool is_frag;
 		int err;
 
-		vport = internal_dev_get_vport(rt_dst(rt).dev);
-		if (!vport)
+		dst_vport = internal_dev_get_vport(rt_dst(rt).dev);
+		if (!dst_vport)
 			goto done;
 
 		skb = alloc_skb(cache->len, GFP_ATOMIC);
@@ -919,13 +928,13 @@ static struct tnl_cache *build_cache(struct vport *vport,
 		__skb_put(skb, cache->len);
 		memcpy(skb->data, get_cached_header(cache), cache->len);
 
-		err = flow_extract(skb, vport->port_no, &flow_key, &is_frag);
+		err = flow_extract(skb, dst_vport->port_no, &flow_key, &is_frag);
 
 		kfree_skb(skb);
 		if (err || is_frag)
 			goto done;
 
-		flow_node = tbl_lookup(rcu_dereference(vport->dp->table),
+		flow_node = tbl_lookup(rcu_dereference(dst_vport->dp->table),
 				       &flow_key, flow_hash(&flow_key),
 				       flow_cmp);
 		if (flow_node) {
@@ -955,22 +964,21 @@ static struct rtable *find_route(struct vport *vport,
 	*cache = NULL;
 	tos = RT_TOS(tos);
 
-	if (likely(tos == mutable->port_config.tos &&
-		   check_cache_valid(cur_cache, mutable))) {
+	if (likely(tos == mutable->tos && check_cache_valid(cur_cache, mutable))) {
 		*cache = cur_cache;
 		return cur_cache->rt;
 	} else {
 		struct rtable *rt;
 		struct flowi fl = { .nl_u = { .ip4_u =
-					      { .daddr = mutable->port_config.daddr,
-						.saddr = mutable->port_config.saddr,
+					      { .daddr = mutable->daddr,
+						.saddr = mutable->saddr,
 						.tos = tos } },
 				    .proto = tnl_vport->tnl_ops->ipproto };
 
 		if (unlikely(ip_route_output_key(&init_net, &rt, &fl)))
 			return NULL;
 
-		if (likely(tos == mutable->port_config.tos))
+		if (likely(tos == mutable->tos))
 			*cache = build_cache(vport, mutable, rt);
 
 		return rt;
@@ -1180,10 +1188,10 @@ int tnl_send(struct vport *vport, struct sk_buff *skb)
 	else
 		inner_tos = 0;
 
-	if (mutable->port_config.flags & TNL_F_TOS_INHERIT)
+	if (mutable->flags & TNL_F_TOS_INHERIT)
 		tos = inner_tos;
 	else
-		tos = mutable->port_config.tos;
+		tos = mutable->tos;
 
 	tos = INET_ECN_encapsulate(tos, inner_tos);
 
@@ -1222,11 +1230,11 @@ int tnl_send(struct vport *vport, struct sk_buff *skb)
 	}
 
 	/* TTL */
-	ttl = mutable->port_config.ttl;
+	ttl = mutable->ttl;
 	if (!ttl)
 		ttl = dst_metric(&rt_dst(rt), RTAX_HOPLIMIT);
 
-	if (mutable->port_config.flags & TNL_F_TTL_INHERIT) {
+	if (mutable->flags & TNL_F_TTL_INHERIT) {
 		if (skb->protocol == htons(ETH_P_IP))
 			ttl = ip_hdr(skb)->ttl;
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
@@ -1275,6 +1283,7 @@ int tnl_send(struct vport *vport, struct sk_buff *skb)
 			struct vport *cache_vport = internal_dev_get_vport(rt_dst(rt).dev);
 
 			skb->protocol = htons(ETH_P_IP);
+			iph = ip_hdr(skb);
 			iph->tot_len = htons(skb->len - skb_network_offset(skb));
 			ip_send_check(iph);
 
@@ -1284,12 +1293,12 @@ int tnl_send(struct vport *vport, struct sk_buff *skb)
 				vport_receive(cache_vport, skb);
 				sent_len += orig_len;
 			} else {
-				int err;
+				int xmit_err;
 
 				skb->dev = rt_dst(rt).dev;
-				err = dev_queue_xmit(skb);
+				xmit_err = dev_queue_xmit(skb);
 
-				if (likely(net_xmit_eval(err) == 0))
+				if (likely(net_xmit_eval(xmit_err) == 0))
 					sent_len += orig_len;
 			}
 		} else
@@ -1313,46 +1322,78 @@ out:
 	return sent_len;
 }
 
-static int set_config(const void *config, const struct tnl_ops *tnl_ops,
-		      const struct vport *cur_vport,
-		      struct tnl_mutable_config *mutable)
+static const struct nla_policy tnl_policy[ODP_TUNNEL_ATTR_MAX + 1] = {
+	[ODP_TUNNEL_ATTR_FLAGS]    = { .type = NLA_U32 },
+	[ODP_TUNNEL_ATTR_DST_IPV4] = { .type = NLA_U32 },
+	[ODP_TUNNEL_ATTR_SRC_IPV4] = { .type = NLA_U32 },
+	[ODP_TUNNEL_ATTR_OUT_KEY]  = { .type = NLA_U64 },
+	[ODP_TUNNEL_ATTR_IN_KEY]   = { .type = NLA_U64 },
+	[ODP_TUNNEL_ATTR_TOS]      = { .type = NLA_U8 },
+	[ODP_TUNNEL_ATTR_TTL]      = { .type = NLA_U8 },
+};
+
+/* Sets ODP_TUNNEL_ATTR_* fields in 'mutable', which must initially be zeroed. */
+static int tnl_set_config(struct nlattr *options, const struct tnl_ops *tnl_ops,
+			  const struct vport *cur_vport,
+			  struct tnl_mutable_config *mutable)
 {
 	const struct vport *old_vport;
 	const struct tnl_mutable_config *old_mutable;
+	struct nlattr *a[ODP_TUNNEL_ATTR_MAX + 1];
+	int err;
 
-	mutable->port_config = *(struct tnl_port_config *)config;
-
-	if (mutable->port_config.daddr == 0)
+	if (!options)
 		return -EINVAL;
 
-	if (mutable->port_config.tos != RT_TOS(mutable->port_config.tos))
+	err = nla_parse_nested(a, ODP_TUNNEL_ATTR_MAX, options, tnl_policy);
+	if (err)
+		return err;
+
+	if (!a[ODP_TUNNEL_ATTR_FLAGS] || !a[ODP_TUNNEL_ATTR_DST_IPV4])
 		return -EINVAL;
 
-	mutable->tunnel_hlen = tnl_ops->hdr_len(&mutable->port_config);
+	mutable->flags = nla_get_u32(a[ODP_TUNNEL_ATTR_FLAGS]) & TNL_F_PUBLIC;
+
+	if (a[ODP_TUNNEL_ATTR_SRC_IPV4])
+		mutable->saddr = nla_get_be32(a[ODP_TUNNEL_ATTR_SRC_IPV4]);
+	mutable->daddr = nla_get_be32(a[ODP_TUNNEL_ATTR_DST_IPV4]);
+
+	if (a[ODP_TUNNEL_ATTR_TOS]) {
+		mutable->tos = nla_get_u8(a[ODP_TUNNEL_ATTR_TOS]);
+		if (mutable->tos != RT_TOS(mutable->tos))
+			return -EINVAL;
+	}
+
+	if (a[ODP_TUNNEL_ATTR_TTL])
+		mutable->ttl = nla_get_u8(a[ODP_TUNNEL_ATTR_TTL]);
+
+	mutable->tunnel_hlen = tnl_ops->hdr_len(mutable);
 	if (mutable->tunnel_hlen < 0)
 		return mutable->tunnel_hlen;
 
 	mutable->tunnel_hlen += sizeof(struct iphdr);
 
 	mutable->tunnel_type = tnl_ops->tunnel_type;
-	if (mutable->port_config.flags & TNL_F_IN_KEY_MATCH) {
+	if (!a[ODP_TUNNEL_ATTR_IN_KEY]) {
 		mutable->tunnel_type |= TNL_T_KEY_MATCH;
-		mutable->port_config.in_key = 0;
-	} else
+		mutable->flags |= TNL_F_IN_KEY_MATCH;
+	} else {
 		mutable->tunnel_type |= TNL_T_KEY_EXACT;
+		mutable->in_key = nla_get_be64(a[ODP_TUNNEL_ATTR_IN_KEY]);
+	}
+
+	if (!a[ODP_TUNNEL_ATTR_OUT_KEY])
+		mutable->flags |= TNL_F_OUT_KEY_ACTION;
+	else
+		mutable->out_key = nla_get_be64(a[ODP_TUNNEL_ATTR_OUT_KEY]);
 
-	old_vport = tnl_find_port(mutable->port_config.saddr,
-				  mutable->port_config.daddr,
-				  mutable->port_config.in_key,
-				  mutable->tunnel_type,
+	old_vport = tnl_find_port(mutable->saddr, mutable->daddr,
+				  mutable->in_key, mutable->tunnel_type,
 				  &old_mutable);
 
 	if (old_vport && old_vport != cur_vport)
 		return -EEXIST;
 
-	if (mutable->port_config.flags & TNL_F_OUT_KEY_ACTION)
-		mutable->port_config.out_key = 0;
-
 	return 0;
 }
 
@@ -1362,6 +1403,7 @@ struct vport *tnl_create(const struct vport_parms *parms,
 {
 	struct vport *vport;
 	struct tnl_vport *tnl_vport;
+	struct tnl_mutable_config *mutable;
 	int initial_frag_id;
 	int err;
 
@@ -1376,19 +1418,19 @@ struct vport *tnl_create(const struct vport_parms *parms,
 	strcpy(tnl_vport->name, parms->name);
 	tnl_vport->tnl_ops = tnl_ops;
 
-	tnl_vport->mutable = kzalloc(sizeof(struct tnl_mutable_config), GFP_KERNEL);
-	if (!tnl_vport->mutable) {
+	mutable = kzalloc(sizeof(struct tnl_mutable_config), GFP_KERNEL);
+	if (!mutable) {
 		err = -ENOMEM;
 		goto error_free_vport;
 	}
 
-	vport_gen_rand_ether_addr(tnl_vport->mutable->eth_addr);
-	tnl_vport->mutable->mtu = ETH_DATA_LEN;
+	vport_gen_rand_ether_addr(mutable->eth_addr);
+	mutable->mtu = ETH_DATA_LEN;
 
 	get_random_bytes(&initial_frag_id, sizeof(int));
 	atomic_set(&tnl_vport->frag_id, initial_frag_id);
 
-	err = set_config(parms->config, tnl_ops, NULL, tnl_vport->mutable);
+	err = tnl_set_config(parms->options, tnl_ops, NULL, mutable);
 	if (err)
 		goto error_free_mutable;
 
@@ -1396,9 +1438,11 @@ struct vport *tnl_create(const struct vport_parms *parms,
 
 #ifdef NEED_CACHE_TIMEOUT
 	tnl_vport->cache_exp_interval = MAX_CACHE_EXP -
-					(net_random() % (MAX_CACHE_EXP / 2));
+				       (net_random() % (MAX_CACHE_EXP / 2));
 #endif
 
+	rcu_assign_pointer(tnl_vport->mutable, mutable);
+
 	err = add_port(vport);
 	if (err)
 		goto error_free_mutable;
@@ -1406,31 +1450,37 @@ struct vport *tnl_create(const struct vport_parms *parms,
 	return vport;
 
 error_free_mutable:
-	kfree(tnl_vport->mutable);
+	kfree(mutable);
 error_free_vport:
 	vport_free(vport);
 error:
 	return ERR_PTR(err);
 }
 
-int tnl_modify(struct vport *vport, struct odp_port *port)
+int tnl_set_options(struct vport *vport, struct nlattr *options)
 {
 	struct tnl_vport *tnl_vport = tnl_vport_priv(vport);
+	const struct tnl_mutable_config *old_mutable;
 	struct tnl_mutable_config *mutable;
 	int err;
 
-	mutable = kmemdup(tnl_vport->mutable, sizeof(struct tnl_mutable_config), GFP_KERNEL);
+	mutable = kzalloc(sizeof(struct tnl_mutable_config), GFP_KERNEL);
 	if (!mutable) {
 		err = -ENOMEM;
 		goto error;
 	}
 
-	err = set_config(port->config, tnl_vport->tnl_ops, vport, mutable);
+	/* Copy fields whose values should be retained. */
+	old_mutable = rtnl_dereference(tnl_vport->mutable);
+	mutable->seq = old_mutable->seq + 1;
+	memcpy(mutable->eth_addr, old_mutable->eth_addr, ETH_ALEN);
+	mutable->mtu = old_mutable->mtu;
+
+	/* Parse the others configured by userspace. */
+	err = tnl_set_config(options, tnl_vport->tnl_ops, vport, mutable);
 	if (err)
 		goto error_free;
 
-	mutable->seq++;
-
 	err = move_port(vport, mutable);
 	if (err)
 		goto error_free;
@@ -1443,28 +1493,51 @@ error:
 	return err;
 }
 
-static void free_port_rcu(struct rcu_head *rcu)
+int tnl_get_options(const struct vport *vport, struct sk_buff *skb)
 {
-	struct tnl_vport *tnl_vport = container_of(rcu, struct tnl_vport, rcu);
+	const struct tnl_vport *tnl_vport = tnl_vport_priv(vport);
+	const struct tnl_mutable_config *mutable = rcu_dereference_rtnl(tnl_vport->mutable);
+
+	NLA_PUT_U32(skb, ODP_TUNNEL_ATTR_FLAGS, mutable->flags & TNL_F_PUBLIC);
+	NLA_PUT_BE32(skb, ODP_TUNNEL_ATTR_DST_IPV4, mutable->daddr);
+
+	if (!(mutable->flags & TNL_F_IN_KEY_MATCH))
+		NLA_PUT_BE64(skb, ODP_TUNNEL_ATTR_IN_KEY, mutable->in_key);
+	if (!(mutable->flags & TNL_F_OUT_KEY_ACTION))
+		NLA_PUT_BE64(skb, ODP_TUNNEL_ATTR_OUT_KEY, mutable->out_key);
+	if (mutable->saddr)
+		NLA_PUT_BE32(skb, ODP_TUNNEL_ATTR_SRC_IPV4, mutable->saddr);
+	if (mutable->tos)
+		NLA_PUT_U8(skb, ODP_TUNNEL_ATTR_TOS, mutable->tos);
+	if (mutable->ttl)
+		NLA_PUT_U8(skb, ODP_TUNNEL_ATTR_TTL, mutable->ttl);
 
-	spin_lock_bh(&tnl_vport->cache_lock);
-	free_cache(tnl_vport->cache);
-	spin_unlock_bh(&tnl_vport->cache_lock);
+	return 0;
 
-	kfree(tnl_vport->mutable);
+nla_put_failure:
+	return -EMSGSIZE;
+}
+
+static void free_port_rcu(struct rcu_head *rcu)
+{
+	struct tnl_vport *tnl_vport = container_of(rcu,
+						   struct tnl_vport, rcu);
+
+	free_cache((struct tnl_cache __force *)tnl_vport->cache);
+	kfree((struct tnl_mutable __force *)tnl_vport->mutable);
 	vport_free(tnl_vport_to_vport(tnl_vport));
 }
 
 int tnl_destroy(struct vport *vport)
 {
 	struct tnl_vport *tnl_vport = tnl_vport_priv(vport);
-	const struct tnl_mutable_config *old_mutable;
+	const struct tnl_mutable_config *mutable, *old_mutable;
+
+	mutable = rtnl_dereference(tnl_vport->mutable);
 
-	if (vport == tnl_find_port(tnl_vport->mutable->port_config.saddr,
-	    tnl_vport->mutable->port_config.daddr,
-	    tnl_vport->mutable->port_config.in_key,
-	    tnl_vport->mutable->tunnel_type,
-	    &old_mutable))
+	if (vport == tnl_find_port(mutable->saddr, mutable->daddr,
+				   mutable->in_key, mutable->tunnel_type,
+				   &old_mutable))
 		del_port(vport);
 
 	call_rcu(&tnl_vport->rcu, free_port_rcu);
@@ -1477,7 +1550,8 @@ int tnl_set_mtu(struct vport *vport, int mtu)
 	struct tnl_vport *tnl_vport = tnl_vport_priv(vport);
 	struct tnl_mutable_config *mutable;
 
-	mutable = kmemdup(tnl_vport->mutable, sizeof(struct tnl_mutable_config), GFP_KERNEL);
+	mutable = kmemdup(rtnl_dereference(tnl_vport->mutable),
+			  sizeof(struct tnl_mutable_config), GFP_KERNEL);
 	if (!mutable)
 		return -ENOMEM;
 
@@ -1492,7 +1566,8 @@ int tnl_set_addr(struct vport *vport, const unsigned char *addr)
 	struct tnl_vport *tnl_vport = tnl_vport_priv(vport);
 	struct tnl_mutable_config *mutable;
 
-	mutable = kmemdup(tnl_vport->mutable, sizeof(struct tnl_mutable_config), GFP_KERNEL);
+	mutable = kmemdup(rtnl_dereference(tnl_vport->mutable),
+			  sizeof(struct tnl_mutable_config), GFP_KERNEL);
 	if (!mutable)
 		return -ENOMEM;
 
@@ -1511,13 +1586,13 @@ const char *tnl_get_name(const struct vport *vport)
 const unsigned char *tnl_get_addr(const struct vport *vport)
 {
 	const struct tnl_vport *tnl_vport = tnl_vport_priv(vport);
-	return rcu_dereference(tnl_vport->mutable)->eth_addr;
+	return rcu_dereference_rtnl(tnl_vport->mutable)->eth_addr;
 }
 
 int tnl_get_mtu(const struct vport *vport)
 {
 	const struct tnl_vport *tnl_vport = tnl_vport_priv(vport);
-	return rcu_dereference(tnl_vport->mutable)->mtu;
+	return rcu_dereference_rtnl(tnl_vport->mutable)->mtu;
 }
 
 void tnl_free_linked_skbs(struct sk_buff *skb)