2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* TUN - Universal TUN/TAP device driver.
|
|
|
|
* Copyright (C) 1999-2002 Maxim Krasnyansky <maxk@qualcomm.com>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* $Id: tun.c,v 1.15 2002/03/01 02:44:24 maxk Exp $
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Changes:
|
|
|
|
*
|
2005-09-01 18:40:05 -06:00
|
|
|
* Mike Kershaw <dragorn@kismetwireless.net> 2005/08/14
|
|
|
|
* Add TUNSETLINK ioctl to set the link encapsulation
|
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* Mark Smith <markzzzsmith@yahoo.com.au>
|
2012-07-12 13:33:09 -06:00
|
|
|
* Use eth_random_addr() for tap MAC address.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Harald Roelle <harald.roelle@ifi.lmu.de> 2004/04/20
|
|
|
|
* Fixes in packet dropping, queue length setting and queue wakeup.
|
|
|
|
* Increased default tx queue length.
|
|
|
|
* Added ethtool API.
|
|
|
|
* Minor cleanups
|
|
|
|
*
|
|
|
|
* Daniel Podlejski <underley@underley.eu.org>
|
|
|
|
* Modifications for 2.3.99-pre5 kernel.
|
|
|
|
*/
|
|
|
|
|
2011-03-02 00:18:10 -07:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#define DRV_NAME "tun"
|
|
|
|
#define DRV_VERSION "1.6"
|
|
|
|
#define DRV_DESCRIPTION "Universal TUN/TAP device driver"
|
|
|
|
#define DRV_COPYRIGHT "(C) 1999-2004 Max Krasnyansky <maxk@qualcomm.com>"
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/kernel.h>
|
2017-02-02 11:15:33 -07:00
|
|
|
#include <linux/sched/signal.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/major.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/poll.h>
|
|
|
|
#include <linux/fcntl.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/miscdevice.h>
|
|
|
|
#include <linux/ethtool.h>
|
|
|
|
#include <linux/rtnetlink.h>
|
2009-11-06 23:52:32 -07:00
|
|
|
#include <linux/compat.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/if.h>
|
|
|
|
#include <linux/if_arp.h>
|
|
|
|
#include <linux/if_ether.h>
|
|
|
|
#include <linux/if_tun.h>
|
2013-07-24 23:00:33 -06:00
|
|
|
#include <linux/if_vlan.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/crc32.h>
|
2008-04-16 01:41:16 -06:00
|
|
|
#include <linux/nsproxy.h>
|
2008-07-03 04:48:02 -06:00
|
|
|
#include <linux/virtio_net.h>
|
2010-02-13 18:01:10 -07:00
|
|
|
#include <linux/rcupdate.h>
|
2007-09-17 12:56:21 -06:00
|
|
|
#include <net/net_namespace.h>
|
2008-04-16 01:40:46 -06:00
|
|
|
#include <net/netns/generic.h>
|
2009-01-21 17:02:16 -07:00
|
|
|
#include <net/rtnetlink.h>
|
2009-02-05 22:25:32 -07:00
|
|
|
#include <net/sock.h>
|
2014-01-29 00:43:31 -07:00
|
|
|
#include <linux/seq_file.h>
|
2014-11-07 06:22:23 -07:00
|
|
|
#include <linux/uio.h>
|
2016-06-30 00:45:36 -06:00
|
|
|
#include <linux/skb_array.h>
|
2017-08-11 05:41:18 -06:00
|
|
|
#include <linux/bpf.h>
|
|
|
|
#include <linux/bpf_trace.h>
|
2017-09-22 14:49:15 -06:00
|
|
|
#include <linux/mutex.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-12-24 12:46:01 -07:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-12 19:48:58 -06:00
|
|
|
/* Uncomment to enable debugging */
|
|
|
|
/* #define TUN_DEBUG 1 */
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef TUN_DEBUG
|
|
|
|
static int debug;
|
2008-04-12 19:48:58 -06:00
|
|
|
|
2011-03-02 00:18:10 -07:00
|
|
|
#define tun_debug(level, tun, fmt, args...) \
|
|
|
|
do { \
|
|
|
|
if (tun->debug) \
|
|
|
|
netdev_printk(level, tun->dev, fmt, ##args); \
|
|
|
|
} while (0)
|
|
|
|
#define DBG1(level, fmt, args...) \
|
|
|
|
do { \
|
|
|
|
if (debug == 2) \
|
|
|
|
printk(level fmt, ##args); \
|
|
|
|
} while (0)
|
2008-04-12 19:48:58 -06:00
|
|
|
#else
|
2011-03-02 00:18:10 -07:00
|
|
|
#define tun_debug(level, tun, fmt, args...) \
|
|
|
|
do { \
|
|
|
|
if (0) \
|
|
|
|
netdev_printk(level, tun->dev, fmt, ##args); \
|
|
|
|
} while (0)
|
|
|
|
#define DBG1(level, fmt, args...) \
|
|
|
|
do { \
|
|
|
|
if (0) \
|
|
|
|
printk(level fmt, ##args); \
|
|
|
|
} while (0)
|
2008-04-12 19:48:58 -06:00
|
|
|
#endif
|
|
|
|
|
2017-08-11 05:41:18 -06:00
|
|
|
#define TUN_HEADROOM 256
|
2017-09-03 21:36:08 -06:00
|
|
|
#define TUN_RX_PAD (NET_IP_ALIGN + NET_SKB_PAD)
|
2017-08-11 05:41:16 -06:00
|
|
|
|
2014-11-19 05:44:40 -07:00
|
|
|
/* TUN device flags */
|
|
|
|
|
|
|
|
/* IFF_ATTACH_QUEUE is never stored in device flags,
|
|
|
|
* overload it to mean fasync when stored there.
|
|
|
|
*/
|
|
|
|
#define TUN_FASYNC IFF_ATTACH_QUEUE
|
2014-12-16 06:05:06 -07:00
|
|
|
/* High bits in flags field are unused. */
|
|
|
|
#define TUN_VNET_LE 0x80000000
|
2015-04-24 06:50:36 -06:00
|
|
|
#define TUN_VNET_BE 0x40000000
|
2014-11-19 05:44:40 -07:00
|
|
|
|
|
|
|
#define TUN_FEATURES (IFF_NO_PI | IFF_ONE_QUEUE | IFF_VNET_HDR | \
|
2017-09-22 14:49:15 -06:00
|
|
|
IFF_MULTI_QUEUE | IFF_NAPI | IFF_NAPI_FRAGS)
|
|
|
|
|
2012-07-20 03:23:23 -06:00
|
|
|
#define GOODCOPY_LEN 128
|
|
|
|
|
2008-07-14 23:18:19 -06:00
|
|
|
#define FLT_EXACT_COUNT 8
|
|
|
|
struct tap_filter {
|
|
|
|
unsigned int count; /* Number of addrs. Zero means disabled */
|
|
|
|
u32 mask[2]; /* Mask of the hashed addrs */
|
|
|
|
unsigned char addr[FLT_EXACT_COUNT][ETH_ALEN];
|
|
|
|
};
|
|
|
|
|
2015-01-11 23:11:29 -07:00
|
|
|
/* MAX_TAP_QUEUES 256 is chosen to allow rx/tx queues to be equal
|
|
|
|
* to max number of VCPUs in guest. */
|
|
|
|
#define MAX_TAP_QUEUES 256
|
2013-01-22 20:59:13 -07:00
|
|
|
#define MAX_TAP_FLOWS 4096
|
2012-10-31 13:46:00 -06:00
|
|
|
|
2012-10-31 13:46:02 -06:00
|
|
|
#define TUN_FLOW_EXPIRE (3 * HZ)
|
|
|
|
|
2016-04-13 02:52:20 -06:00
|
|
|
struct tun_pcpu_stats {
|
|
|
|
u64 rx_packets;
|
|
|
|
u64 rx_bytes;
|
|
|
|
u64 tx_packets;
|
|
|
|
u64 tx_bytes;
|
|
|
|
struct u64_stats_sync syncp;
|
|
|
|
u32 rx_dropped;
|
|
|
|
u32 tx_dropped;
|
|
|
|
u32 rx_frame_errors;
|
|
|
|
};
|
|
|
|
|
2012-10-31 13:45:57 -06:00
|
|
|
/* A tun_file connects an open character device to a tuntap netdevice. It
|
2013-12-05 21:42:58 -07:00
|
|
|
* also contains all socket related structures (except sock_fprog and tap_filter)
|
2012-10-31 13:45:57 -06:00
|
|
|
* to serve as one transmit queue for tuntap device. The sock_fprog and
|
|
|
|
* tap_filter were kept in tun_struct since they were used for filtering for the
|
2012-11-25 15:07:40 -07:00
|
|
|
* netdevice not for a specific queue (at least I didn't see the requirement for
|
2012-10-31 13:45:57 -06:00
|
|
|
* this).
|
2012-10-31 13:45:58 -06:00
|
|
|
*
|
|
|
|
* RCU usage:
|
2012-11-25 15:07:40 -07:00
|
|
|
* The tun_file and tun_struct are loosely coupled, the pointer from one to the
|
2012-10-31 13:45:58 -06:00
|
|
|
* other can only be read while rcu_read_lock or rtnl_lock is held.
|
2012-10-31 13:45:57 -06:00
|
|
|
*/
|
2009-01-20 04:00:40 -07:00
|
|
|
struct tun_file {
|
2012-10-31 13:45:57 -06:00
|
|
|
struct sock sk;
|
|
|
|
struct socket socket;
|
|
|
|
struct socket_wq wq;
|
2012-10-31 13:45:58 -06:00
|
|
|
struct tun_struct __rcu *tun;
|
2012-10-31 13:45:57 -06:00
|
|
|
struct fasync_struct *fasync;
|
|
|
|
/* only used for fasnyc */
|
|
|
|
unsigned int flags;
|
tun: Add ability to create tun device with given index
Tun devices cannot be created with ifidex user wants, but it's
required by checkpoint-restore project.
Long time ago such ability was implemented for rtnl_ops-based
interface for creating links (9c7dafbf net: Allow to create links
with given ifindex), but the only API for creating and managing
tuntap devices is ioctl-based and is evolving with adding new ones
(cde8b15f tuntap: add ioctl to attach or detach a file form tuntap
device).
Following that trend, here's how a new ioctl that sets the ifindex
for device, that _will_ be created by TUNSETIFF ioctl looks like.
So those who want a tuntap device with the ifindex N, should open
the tun device, call ioctl(fd, TUNSETIFINDEX, &N), then call TUNSETIFF.
If the index N is busy, then the register_netdev will find this out
and the ioctl would be failed with -EBUSY.
If setifindex is not called, then it will be generated as before.
Signed-off-by: Pavel Emelyanov <xemul@parallels.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-08-21 04:31:38 -06:00
|
|
|
union {
|
|
|
|
u16 queue_index;
|
|
|
|
unsigned int ifindex;
|
|
|
|
};
|
2017-09-22 14:49:14 -06:00
|
|
|
struct napi_struct napi;
|
2017-10-18 13:12:09 -06:00
|
|
|
bool napi_enabled;
|
2017-09-22 14:49:15 -06:00
|
|
|
struct mutex napi_mutex; /* Protects access to the above napi */
|
2012-12-13 16:53:30 -07:00
|
|
|
struct list_head next;
|
|
|
|
struct tun_struct *detached;
|
2018-01-03 20:14:27 -07:00
|
|
|
struct ptr_ring tx_ring;
|
2018-01-03 03:25:59 -07:00
|
|
|
struct xdp_rxq_info xdp_rxq;
|
2009-01-20 04:00:40 -07:00
|
|
|
};
|
|
|
|
|
2012-10-31 13:46:02 -06:00
|
|
|
struct tun_flow_entry {
|
|
|
|
struct hlist_node hash_link;
|
|
|
|
struct rcu_head rcu;
|
|
|
|
struct tun_struct *tun;
|
|
|
|
|
|
|
|
u32 rxhash;
|
2013-12-22 03:54:32 -07:00
|
|
|
u32 rps_rxhash;
|
2012-10-31 13:46:02 -06:00
|
|
|
int queue_index;
|
|
|
|
unsigned long updated;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define TUN_NUM_FLOW_ENTRIES 1024
|
|
|
|
|
2018-01-16 01:31:01 -07:00
|
|
|
struct tun_prog {
|
2017-12-04 02:31:23 -07:00
|
|
|
struct rcu_head rcu;
|
|
|
|
struct bpf_prog *prog;
|
|
|
|
};
|
|
|
|
|
2012-10-31 13:45:57 -06:00
|
|
|
/* Since the socket were moved to tun_file, to preserve the behavior of persist
|
2012-11-25 15:07:40 -07:00
|
|
|
* device, socket filter, sndbuf and vnet header size were restore when the
|
2012-10-31 13:45:57 -06:00
|
|
|
* file were attached to a persist device.
|
|
|
|
*/
|
2008-04-12 19:48:58 -06:00
|
|
|
struct tun_struct {
|
2012-10-31 13:46:00 -06:00
|
|
|
struct tun_file __rcu *tfiles[MAX_TAP_QUEUES];
|
|
|
|
unsigned int numqueues;
|
2008-07-14 23:18:19 -06:00
|
|
|
unsigned int flags;
|
2012-02-07 17:48:55 -07:00
|
|
|
kuid_t owner;
|
|
|
|
kgid_t group;
|
2008-04-12 19:48:58 -06:00
|
|
|
|
|
|
|
struct net_device *dev;
|
2011-11-15 08:29:55 -07:00
|
|
|
netdev_features_t set_features;
|
2011-04-19 00:13:10 -06:00
|
|
|
#define TUN_USER_FEATURES (NETIF_F_HW_CSUM|NETIF_F_TSO_ECN|NETIF_F_TSO| \
|
2017-07-03 07:35:32 -06:00
|
|
|
NETIF_F_TSO6)
|
2010-03-17 09:45:01 -06:00
|
|
|
|
2016-02-26 02:45:40 -07:00
|
|
|
int align;
|
2010-03-17 09:45:01 -06:00
|
|
|
int vnet_hdr_sz;
|
2012-10-31 13:45:57 -06:00
|
|
|
int sndbuf;
|
|
|
|
struct tap_filter txflt;
|
|
|
|
struct sock_fprog fprog;
|
|
|
|
/* protected by rtnl lock */
|
|
|
|
bool filter_attached;
|
2008-04-12 19:48:58 -06:00
|
|
|
#ifdef TUN_DEBUG
|
|
|
|
int debug;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2012-10-31 13:46:02 -06:00
|
|
|
spinlock_t lock;
|
|
|
|
struct hlist_head flows[TUN_NUM_FLOW_ENTRIES];
|
|
|
|
struct timer_list flow_gc_timer;
|
|
|
|
unsigned long ageing_time;
|
2012-12-13 16:53:30 -07:00
|
|
|
unsigned int numdisabled;
|
|
|
|
struct list_head disabled;
|
2013-01-14 00:12:19 -07:00
|
|
|
void *security;
|
2013-01-22 20:59:13 -07:00
|
|
|
u32 flow_count;
|
2017-01-18 00:02:03 -07:00
|
|
|
u32 rx_batched;
|
2016-04-13 02:52:20 -06:00
|
|
|
struct tun_pcpu_stats __percpu *pcpu_stats;
|
2017-08-11 05:41:18 -06:00
|
|
|
struct bpf_prog __rcu *xdp_prog;
|
2018-01-16 01:31:01 -07:00
|
|
|
struct tun_prog __rcu *steering_prog;
|
2018-01-16 01:31:02 -07:00
|
|
|
struct tun_prog __rcu *filter_prog;
|
2008-04-12 19:48:58 -06:00
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2018-01-16 01:31:02 -07:00
|
|
|
struct veth {
|
|
|
|
__be16 h_vlan_proto;
|
|
|
|
__be16 h_vlan_TCI;
|
2008-04-12 19:48:58 -06:00
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2018-01-03 20:14:28 -07:00
|
|
|
bool tun_is_xdp_buff(void *ptr)
|
|
|
|
{
|
|
|
|
return (unsigned long)ptr & TUN_XDP_FLAG;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(tun_is_xdp_buff);
|
|
|
|
|
|
|
|
void *tun_xdp_to_ptr(void *ptr)
|
|
|
|
{
|
|
|
|
return (void *)((unsigned long)ptr | TUN_XDP_FLAG);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(tun_xdp_to_ptr);
|
|
|
|
|
|
|
|
void *tun_ptr_to_xdp(void *ptr)
|
|
|
|
{
|
|
|
|
return (void *)((unsigned long)ptr & ~TUN_XDP_FLAG);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(tun_ptr_to_xdp);
|
|
|
|
|
2017-09-22 14:49:14 -06:00
|
|
|
static int tun_napi_receive(struct napi_struct *napi, int budget)
|
|
|
|
{
|
|
|
|
struct tun_file *tfile = container_of(napi, struct tun_file, napi);
|
|
|
|
struct sk_buff_head *queue = &tfile->sk.sk_write_queue;
|
|
|
|
struct sk_buff_head process_queue;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
int received = 0;
|
|
|
|
|
|
|
|
__skb_queue_head_init(&process_queue);
|
|
|
|
|
|
|
|
spin_lock(&queue->lock);
|
|
|
|
skb_queue_splice_tail_init(queue, &process_queue);
|
|
|
|
spin_unlock(&queue->lock);
|
|
|
|
|
|
|
|
while (received < budget && (skb = __skb_dequeue(&process_queue))) {
|
|
|
|
napi_gro_receive(napi, skb);
|
|
|
|
++received;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!skb_queue_empty(&process_queue)) {
|
|
|
|
spin_lock(&queue->lock);
|
|
|
|
skb_queue_splice(&process_queue, queue);
|
|
|
|
spin_unlock(&queue->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
return received;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tun_napi_poll(struct napi_struct *napi, int budget)
|
|
|
|
{
|
|
|
|
unsigned int received;
|
|
|
|
|
|
|
|
received = tun_napi_receive(napi, budget);
|
|
|
|
|
|
|
|
if (received < budget)
|
|
|
|
napi_complete_done(napi, received);
|
|
|
|
|
|
|
|
return received;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tun_napi_init(struct tun_struct *tun, struct tun_file *tfile,
|
|
|
|
bool napi_en)
|
|
|
|
{
|
2017-10-18 13:12:09 -06:00
|
|
|
tfile->napi_enabled = napi_en;
|
2017-09-22 14:49:14 -06:00
|
|
|
if (napi_en) {
|
|
|
|
netif_napi_add(tun->dev, &tfile->napi, tun_napi_poll,
|
|
|
|
NAPI_POLL_WEIGHT);
|
|
|
|
napi_enable(&tfile->napi);
|
2017-09-22 14:49:15 -06:00
|
|
|
mutex_init(&tfile->napi_mutex);
|
2017-09-22 14:49:14 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tun_napi_disable(struct tun_struct *tun, struct tun_file *tfile)
|
|
|
|
{
|
2017-10-18 13:12:09 -06:00
|
|
|
if (tfile->napi_enabled)
|
2017-09-22 14:49:14 -06:00
|
|
|
napi_disable(&tfile->napi);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tun_napi_del(struct tun_struct *tun, struct tun_file *tfile)
|
|
|
|
{
|
2017-10-18 13:12:09 -06:00
|
|
|
if (tfile->napi_enabled)
|
2017-09-22 14:49:14 -06:00
|
|
|
netif_napi_del(&tfile->napi);
|
|
|
|
}
|
|
|
|
|
2017-09-22 14:49:15 -06:00
|
|
|
static bool tun_napi_frags_enabled(const struct tun_struct *tun)
|
|
|
|
{
|
|
|
|
return READ_ONCE(tun->flags) & IFF_NAPI_FRAGS;
|
|
|
|
}
|
|
|
|
|
2015-04-24 06:50:36 -06:00
|
|
|
#ifdef CONFIG_TUN_VNET_CROSS_LE
|
|
|
|
static inline bool tun_legacy_is_little_endian(struct tun_struct *tun)
|
|
|
|
{
|
|
|
|
return tun->flags & TUN_VNET_BE ? false :
|
|
|
|
virtio_legacy_is_little_endian();
|
|
|
|
}
|
|
|
|
|
|
|
|
static long tun_get_vnet_be(struct tun_struct *tun, int __user *argp)
|
|
|
|
{
|
|
|
|
int be = !!(tun->flags & TUN_VNET_BE);
|
|
|
|
|
|
|
|
if (put_user(be, argp))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static long tun_set_vnet_be(struct tun_struct *tun, int __user *argp)
|
|
|
|
{
|
|
|
|
int be;
|
|
|
|
|
|
|
|
if (get_user(be, argp))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
if (be)
|
|
|
|
tun->flags |= TUN_VNET_BE;
|
|
|
|
else
|
|
|
|
tun->flags &= ~TUN_VNET_BE;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline bool tun_legacy_is_little_endian(struct tun_struct *tun)
|
|
|
|
{
|
|
|
|
return virtio_legacy_is_little_endian();
|
|
|
|
}
|
|
|
|
|
|
|
|
static long tun_get_vnet_be(struct tun_struct *tun, int __user *argp)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static long tun_set_vnet_be(struct tun_struct *tun, int __user *argp)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_TUN_VNET_CROSS_LE */
|
|
|
|
|
2015-04-24 06:24:38 -06:00
|
|
|
static inline bool tun_is_little_endian(struct tun_struct *tun)
|
|
|
|
{
|
2015-04-24 06:26:24 -06:00
|
|
|
return tun->flags & TUN_VNET_LE ||
|
2015-04-24 06:50:36 -06:00
|
|
|
tun_legacy_is_little_endian(tun);
|
2015-04-24 06:24:38 -06:00
|
|
|
}
|
|
|
|
|
2014-10-23 13:59:31 -06:00
|
|
|
static inline u16 tun16_to_cpu(struct tun_struct *tun, __virtio16 val)
|
|
|
|
{
|
2015-04-24 06:24:38 -06:00
|
|
|
return __virtio16_to_cpu(tun_is_little_endian(tun), val);
|
2014-10-23 13:59:31 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline __virtio16 cpu_to_tun16(struct tun_struct *tun, u16 val)
|
|
|
|
{
|
2015-04-24 06:24:38 -06:00
|
|
|
return __cpu_to_virtio16(tun_is_little_endian(tun), val);
|
2014-10-23 13:59:31 -06:00
|
|
|
}
|
|
|
|
|
2012-10-31 13:46:02 -06:00
|
|
|
static inline u32 tun_hashfn(u32 rxhash)
|
|
|
|
{
|
|
|
|
return rxhash & 0x3ff;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct tun_flow_entry *tun_flow_find(struct hlist_head *head, u32 rxhash)
|
|
|
|
{
|
|
|
|
struct tun_flow_entry *e;
|
|
|
|
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
hlist_for_each_entry_rcu(e, head, hash_link) {
|
2012-10-31 13:46:02 -06:00
|
|
|
if (e->rxhash == rxhash)
|
|
|
|
return e;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct tun_flow_entry *tun_flow_create(struct tun_struct *tun,
|
|
|
|
struct hlist_head *head,
|
|
|
|
u32 rxhash, u16 queue_index)
|
|
|
|
{
|
2012-12-21 00:17:21 -07:00
|
|
|
struct tun_flow_entry *e = kmalloc(sizeof(*e), GFP_ATOMIC);
|
|
|
|
|
2012-10-31 13:46:02 -06:00
|
|
|
if (e) {
|
|
|
|
tun_debug(KERN_INFO, tun, "create flow: hash %u index %u\n",
|
|
|
|
rxhash, queue_index);
|
|
|
|
e->updated = jiffies;
|
|
|
|
e->rxhash = rxhash;
|
2013-12-22 03:54:32 -07:00
|
|
|
e->rps_rxhash = 0;
|
2012-10-31 13:46:02 -06:00
|
|
|
e->queue_index = queue_index;
|
|
|
|
e->tun = tun;
|
|
|
|
hlist_add_head_rcu(&e->hash_link, head);
|
2013-01-22 20:59:13 -07:00
|
|
|
++tun->flow_count;
|
2012-10-31 13:46:02 -06:00
|
|
|
}
|
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tun_flow_delete(struct tun_struct *tun, struct tun_flow_entry *e)
|
|
|
|
{
|
|
|
|
tun_debug(KERN_INFO, tun, "delete flow: hash %u index %u\n",
|
|
|
|
e->rxhash, e->queue_index);
|
|
|
|
hlist_del_rcu(&e->hash_link);
|
2012-12-21 00:17:21 -07:00
|
|
|
kfree_rcu(e, rcu);
|
2013-01-22 20:59:13 -07:00
|
|
|
--tun->flow_count;
|
2012-10-31 13:46:02 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void tun_flow_flush(struct tun_struct *tun)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
spin_lock_bh(&tun->lock);
|
|
|
|
for (i = 0; i < TUN_NUM_FLOW_ENTRIES; i++) {
|
|
|
|
struct tun_flow_entry *e;
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
struct hlist_node *n;
|
2012-10-31 13:46:02 -06:00
|
|
|
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
hlist_for_each_entry_safe(e, n, &tun->flows[i], hash_link)
|
2012-10-31 13:46:02 -06:00
|
|
|
tun_flow_delete(tun, e);
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&tun->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tun_flow_delete_by_queue(struct tun_struct *tun, u16 queue_index)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
spin_lock_bh(&tun->lock);
|
|
|
|
for (i = 0; i < TUN_NUM_FLOW_ENTRIES; i++) {
|
|
|
|
struct tun_flow_entry *e;
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
struct hlist_node *n;
|
2012-10-31 13:46:02 -06:00
|
|
|
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
hlist_for_each_entry_safe(e, n, &tun->flows[i], hash_link) {
|
2012-10-31 13:46:02 -06:00
|
|
|
if (e->queue_index == queue_index)
|
|
|
|
tun_flow_delete(tun, e);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&tun->lock);
|
|
|
|
}
|
|
|
|
|
treewide: setup_timer() -> timer_setup()
This converts all remaining cases of the old setup_timer() API into using
timer_setup(), where the callback argument is the structure already
holding the struct timer_list. These should have no behavioral changes,
since they just change which pointer is passed into the callback with
the same available pointers after conversion. It handles the following
examples, in addition to some other variations.
Casting from unsigned long:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
setup_timer(&ptr->my_timer, my_callback, ptr);
and forced object casts:
void my_callback(struct something *ptr)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, (unsigned long)ptr);
become:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
Direct function assignments:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
ptr->my_timer.function = my_callback;
have a temporary cast added, along with converting the args:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
ptr->my_timer.function = (TIMER_FUNC_TYPE)my_callback;
And finally, callbacks without a data assignment:
void my_callback(unsigned long data)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, 0);
have their argument renamed to verify they're unused during conversion:
void my_callback(struct timer_list *unused)
{
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
The conversion is done with the following Coccinelle script:
spatch --very-quiet --all-includes --include-headers \
-I ./arch/x86/include -I ./arch/x86/include/generated \
-I ./include -I ./arch/x86/include/uapi \
-I ./arch/x86/include/generated/uapi -I ./include/uapi \
-I ./include/generated/uapi --include ./include/linux/kconfig.h \
--dir . \
--cocci-file ~/src/data/timer_setup.cocci
@fix_address_of@
expression e;
@@
setup_timer(
-&(e)
+&e
, ...)
// Update any raw setup_timer() usages that have a NULL callback, but
// would otherwise match change_timer_function_usage, since the latter
// will update all function assignments done in the face of a NULL
// function initialization in setup_timer().
@change_timer_function_usage_NULL@
expression _E;
identifier _timer;
type _cast_data;
@@
(
-setup_timer(&_E->_timer, NULL, _E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E->_timer, NULL, (_cast_data)_E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, &_E);
+timer_setup(&_E._timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, (_cast_data)&_E);
+timer_setup(&_E._timer, NULL, 0);
)
@change_timer_function_usage@
expression _E;
identifier _timer;
struct timer_list _stl;
identifier _callback;
type _cast_func, _cast_data;
@@
(
-setup_timer(&_E->_timer, _callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
_E->_timer@_stl.function = _callback;
|
_E->_timer@_stl.function = &_callback;
|
_E->_timer@_stl.function = (_cast_func)_callback;
|
_E->_timer@_stl.function = (_cast_func)&_callback;
|
_E._timer@_stl.function = _callback;
|
_E._timer@_stl.function = &_callback;
|
_E._timer@_stl.function = (_cast_func)_callback;
|
_E._timer@_stl.function = (_cast_func)&_callback;
)
// callback(unsigned long arg)
@change_callback_handle_cast
depends on change_timer_function_usage@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
identifier _handle;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
(
... when != _origarg
_handletype *_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
)
}
// callback(unsigned long arg) without existing variable
@change_callback_handle_cast_no_arg
depends on change_timer_function_usage &&
!change_callback_handle_cast@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
+ _handletype *_origarg = from_timer(_origarg, t, _timer);
+
... when != _origarg
- (_handletype *)_origarg
+ _origarg
... when != _origarg
}
// Avoid already converted callbacks.
@match_callback_converted
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier t;
@@
void _callback(struct timer_list *t)
{ ... }
// callback(struct something *handle)
@change_callback_handle_arg
depends on change_timer_function_usage &&
!match_callback_converted &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
@@
void _callback(
-_handletype *_handle
+struct timer_list *t
)
{
+ _handletype *_handle = from_timer(_handle, t, _timer);
...
}
// If change_callback_handle_arg ran on an empty function, remove
// the added handler.
@unchange_callback_handle_arg
depends on change_timer_function_usage &&
change_callback_handle_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
identifier t;
@@
void _callback(struct timer_list *t)
{
- _handletype *_handle = from_timer(_handle, t, _timer);
}
// We only want to refactor the setup_timer() data argument if we've found
// the matching callback. This undoes changes in change_timer_function_usage.
@unchange_timer_function_usage
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg &&
!change_callback_handle_arg@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type change_timer_function_usage._cast_data;
@@
(
-timer_setup(&_E->_timer, _callback, 0);
+setup_timer(&_E->_timer, _callback, (_cast_data)_E);
|
-timer_setup(&_E._timer, _callback, 0);
+setup_timer(&_E._timer, _callback, (_cast_data)&_E);
)
// If we fixed a callback from a .function assignment, fix the
// assignment cast now.
@change_timer_function_assignment
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_func;
typedef TIMER_FUNC_TYPE;
@@
(
_E->_timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-&_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
)
// Sometimes timer functions are called directly. Replace matched args.
@change_timer_function_calls
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression _E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_data;
@@
_callback(
(
-(_cast_data)_E
+&_E->_timer
|
-(_cast_data)&_E
+&_E._timer
|
-_E
+&_E->_timer
)
)
// If a timer has been configured without a data argument, it can be
// converted without regard to the callback argument, since it is unused.
@match_timer_function_unused_data@
expression _E;
identifier _timer;
identifier _callback;
@@
(
-setup_timer(&_E->_timer, _callback, 0);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0L);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0UL);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0L);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0UL);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0L);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0UL);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0L);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0UL);
+timer_setup(_timer, _callback, 0);
)
@change_callback_unused_data
depends on match_timer_function_unused_data@
identifier match_timer_function_unused_data._callback;
type _origtype;
identifier _origarg;
@@
void _callback(
-_origtype _origarg
+struct timer_list *unused
)
{
... when != _origarg
}
Signed-off-by: Kees Cook <keescook@chromium.org>
2017-10-16 15:43:17 -06:00
|
|
|
static void tun_flow_cleanup(struct timer_list *t)
|
2012-10-31 13:46:02 -06:00
|
|
|
{
|
treewide: setup_timer() -> timer_setup()
This converts all remaining cases of the old setup_timer() API into using
timer_setup(), where the callback argument is the structure already
holding the struct timer_list. These should have no behavioral changes,
since they just change which pointer is passed into the callback with
the same available pointers after conversion. It handles the following
examples, in addition to some other variations.
Casting from unsigned long:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
setup_timer(&ptr->my_timer, my_callback, ptr);
and forced object casts:
void my_callback(struct something *ptr)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, (unsigned long)ptr);
become:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
Direct function assignments:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
ptr->my_timer.function = my_callback;
have a temporary cast added, along with converting the args:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
ptr->my_timer.function = (TIMER_FUNC_TYPE)my_callback;
And finally, callbacks without a data assignment:
void my_callback(unsigned long data)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, 0);
have their argument renamed to verify they're unused during conversion:
void my_callback(struct timer_list *unused)
{
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
The conversion is done with the following Coccinelle script:
spatch --very-quiet --all-includes --include-headers \
-I ./arch/x86/include -I ./arch/x86/include/generated \
-I ./include -I ./arch/x86/include/uapi \
-I ./arch/x86/include/generated/uapi -I ./include/uapi \
-I ./include/generated/uapi --include ./include/linux/kconfig.h \
--dir . \
--cocci-file ~/src/data/timer_setup.cocci
@fix_address_of@
expression e;
@@
setup_timer(
-&(e)
+&e
, ...)
// Update any raw setup_timer() usages that have a NULL callback, but
// would otherwise match change_timer_function_usage, since the latter
// will update all function assignments done in the face of a NULL
// function initialization in setup_timer().
@change_timer_function_usage_NULL@
expression _E;
identifier _timer;
type _cast_data;
@@
(
-setup_timer(&_E->_timer, NULL, _E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E->_timer, NULL, (_cast_data)_E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, &_E);
+timer_setup(&_E._timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, (_cast_data)&_E);
+timer_setup(&_E._timer, NULL, 0);
)
@change_timer_function_usage@
expression _E;
identifier _timer;
struct timer_list _stl;
identifier _callback;
type _cast_func, _cast_data;
@@
(
-setup_timer(&_E->_timer, _callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
_E->_timer@_stl.function = _callback;
|
_E->_timer@_stl.function = &_callback;
|
_E->_timer@_stl.function = (_cast_func)_callback;
|
_E->_timer@_stl.function = (_cast_func)&_callback;
|
_E._timer@_stl.function = _callback;
|
_E._timer@_stl.function = &_callback;
|
_E._timer@_stl.function = (_cast_func)_callback;
|
_E._timer@_stl.function = (_cast_func)&_callback;
)
// callback(unsigned long arg)
@change_callback_handle_cast
depends on change_timer_function_usage@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
identifier _handle;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
(
... when != _origarg
_handletype *_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
)
}
// callback(unsigned long arg) without existing variable
@change_callback_handle_cast_no_arg
depends on change_timer_function_usage &&
!change_callback_handle_cast@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
+ _handletype *_origarg = from_timer(_origarg, t, _timer);
+
... when != _origarg
- (_handletype *)_origarg
+ _origarg
... when != _origarg
}
// Avoid already converted callbacks.
@match_callback_converted
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier t;
@@
void _callback(struct timer_list *t)
{ ... }
// callback(struct something *handle)
@change_callback_handle_arg
depends on change_timer_function_usage &&
!match_callback_converted &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
@@
void _callback(
-_handletype *_handle
+struct timer_list *t
)
{
+ _handletype *_handle = from_timer(_handle, t, _timer);
...
}
// If change_callback_handle_arg ran on an empty function, remove
// the added handler.
@unchange_callback_handle_arg
depends on change_timer_function_usage &&
change_callback_handle_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
identifier t;
@@
void _callback(struct timer_list *t)
{
- _handletype *_handle = from_timer(_handle, t, _timer);
}
// We only want to refactor the setup_timer() data argument if we've found
// the matching callback. This undoes changes in change_timer_function_usage.
@unchange_timer_function_usage
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg &&
!change_callback_handle_arg@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type change_timer_function_usage._cast_data;
@@
(
-timer_setup(&_E->_timer, _callback, 0);
+setup_timer(&_E->_timer, _callback, (_cast_data)_E);
|
-timer_setup(&_E._timer, _callback, 0);
+setup_timer(&_E._timer, _callback, (_cast_data)&_E);
)
// If we fixed a callback from a .function assignment, fix the
// assignment cast now.
@change_timer_function_assignment
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_func;
typedef TIMER_FUNC_TYPE;
@@
(
_E->_timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-&_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
)
// Sometimes timer functions are called directly. Replace matched args.
@change_timer_function_calls
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression _E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_data;
@@
_callback(
(
-(_cast_data)_E
+&_E->_timer
|
-(_cast_data)&_E
+&_E._timer
|
-_E
+&_E->_timer
)
)
// If a timer has been configured without a data argument, it can be
// converted without regard to the callback argument, since it is unused.
@match_timer_function_unused_data@
expression _E;
identifier _timer;
identifier _callback;
@@
(
-setup_timer(&_E->_timer, _callback, 0);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0L);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0UL);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0L);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0UL);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0L);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0UL);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0L);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0UL);
+timer_setup(_timer, _callback, 0);
)
@change_callback_unused_data
depends on match_timer_function_unused_data@
identifier match_timer_function_unused_data._callback;
type _origtype;
identifier _origarg;
@@
void _callback(
-_origtype _origarg
+struct timer_list *unused
)
{
... when != _origarg
}
Signed-off-by: Kees Cook <keescook@chromium.org>
2017-10-16 15:43:17 -06:00
|
|
|
struct tun_struct *tun = from_timer(tun, t, flow_gc_timer);
|
2012-10-31 13:46:02 -06:00
|
|
|
unsigned long delay = tun->ageing_time;
|
|
|
|
unsigned long next_timer = jiffies + delay;
|
|
|
|
unsigned long count = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
tun_debug(KERN_INFO, tun, "tun_flow_cleanup\n");
|
|
|
|
|
2017-10-20 12:29:55 -06:00
|
|
|
spin_lock(&tun->lock);
|
2012-10-31 13:46:02 -06:00
|
|
|
for (i = 0; i < TUN_NUM_FLOW_ENTRIES; i++) {
|
|
|
|
struct tun_flow_entry *e;
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
struct hlist_node *n;
|
2012-10-31 13:46:02 -06:00
|
|
|
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
hlist_for_each_entry_safe(e, n, &tun->flows[i], hash_link) {
|
2012-10-31 13:46:02 -06:00
|
|
|
unsigned long this_timer;
|
2017-10-20 12:29:56 -06:00
|
|
|
|
2012-10-31 13:46:02 -06:00
|
|
|
this_timer = e->updated + delay;
|
2017-10-20 12:29:56 -06:00
|
|
|
if (time_before_eq(this_timer, jiffies)) {
|
2012-10-31 13:46:02 -06:00
|
|
|
tun_flow_delete(tun, e);
|
2017-10-20 12:29:56 -06:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
count++;
|
|
|
|
if (time_before(this_timer, next_timer))
|
2012-10-31 13:46:02 -06:00
|
|
|
next_timer = this_timer;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (count)
|
|
|
|
mod_timer(&tun->flow_gc_timer, round_jiffies_up(next_timer));
|
2017-10-20 12:29:55 -06:00
|
|
|
spin_unlock(&tun->lock);
|
2012-10-31 13:46:02 -06:00
|
|
|
}
|
|
|
|
|
2012-12-12 12:22:57 -07:00
|
|
|
static void tun_flow_update(struct tun_struct *tun, u32 rxhash,
|
2013-01-27 18:05:19 -07:00
|
|
|
struct tun_file *tfile)
|
2012-10-31 13:46:02 -06:00
|
|
|
{
|
|
|
|
struct hlist_head *head;
|
|
|
|
struct tun_flow_entry *e;
|
|
|
|
unsigned long delay = tun->ageing_time;
|
2013-01-27 18:05:19 -07:00
|
|
|
u16 queue_index = tfile->queue_index;
|
2012-10-31 13:46:02 -06:00
|
|
|
|
|
|
|
if (!rxhash)
|
|
|
|
return;
|
|
|
|
else
|
|
|
|
head = &tun->flows[tun_hashfn(rxhash)];
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
2013-01-27 18:05:19 -07:00
|
|
|
/* We may get a very small possibility of OOO during switching, not
|
|
|
|
* worth to optimize.*/
|
|
|
|
if (tun->numqueues == 1 || tfile->detached)
|
2012-10-31 13:46:02 -06:00
|
|
|
goto unlock;
|
|
|
|
|
|
|
|
e = tun_flow_find(head, rxhash);
|
|
|
|
if (likely(e)) {
|
|
|
|
/* TODO: keep queueing to old queue until it's empty? */
|
|
|
|
e->queue_index = queue_index;
|
|
|
|
e->updated = jiffies;
|
2013-12-22 03:54:32 -07:00
|
|
|
sock_rps_record_flow_hash(e->rps_rxhash);
|
2012-10-31 13:46:02 -06:00
|
|
|
} else {
|
|
|
|
spin_lock_bh(&tun->lock);
|
2013-01-22 20:59:13 -07:00
|
|
|
if (!tun_flow_find(head, rxhash) &&
|
|
|
|
tun->flow_count < MAX_TAP_FLOWS)
|
2012-10-31 13:46:02 -06:00
|
|
|
tun_flow_create(tun, head, rxhash, queue_index);
|
|
|
|
|
|
|
|
if (!timer_pending(&tun->flow_gc_timer))
|
|
|
|
mod_timer(&tun->flow_gc_timer,
|
|
|
|
round_jiffies_up(jiffies + delay));
|
|
|
|
spin_unlock_bh(&tun->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
unlock:
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
|
2013-12-22 03:54:32 -07:00
|
|
|
/**
|
|
|
|
* Save the hash received in the stack receive path and update the
|
|
|
|
* flow_hash table accordingly.
|
|
|
|
*/
|
|
|
|
static inline void tun_flow_save_rps_rxhash(struct tun_flow_entry *e, u32 hash)
|
|
|
|
{
|
net: rfs: add hash collision detection
Receive Flow Steering is a nice solution but suffers from
hash collisions when a mix of connected and unconnected traffic
is received on the host, when flow hash table is populated.
Also, clearing flow in inet_release() makes RFS not very good
for short lived flows, as many packets can follow close().
(FIN , ACK packets, ...)
This patch extends the information stored into global hash table
to not only include cpu number, but upper part of the hash value.
I use a 32bit value, and dynamically split it in two parts.
For host with less than 64 possible cpus, this gives 6 bits for the
cpu number, and 26 (32-6) bits for the upper part of the hash.
Since hash bucket selection use low order bits of the hash, we have
a full hash match, if /proc/sys/net/core/rps_sock_flow_entries is big
enough.
If the hash found in flow table does not match, we fallback to RPS (if
it is enabled for the rxqueue).
This means that a packet for an non connected flow can avoid the
IPI through a unrelated/victim CPU.
This also means we no longer have to clear the table at socket
close time, and this helps short lived flows performance.
Signed-off-by: Eric Dumazet <edumazet@google.com>
Acked-by: Tom Herbert <therbert@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2015-02-06 13:59:01 -07:00
|
|
|
if (unlikely(e->rps_rxhash != hash))
|
2013-12-22 03:54:32 -07:00
|
|
|
e->rps_rxhash = hash;
|
|
|
|
}
|
|
|
|
|
2012-10-31 13:46:00 -06:00
|
|
|
/* We try to identify a flow through its rxhash first. The reason that
|
2013-12-05 21:42:58 -07:00
|
|
|
* we do not check rxq no. is because some cards(e.g 82599), chooses
|
2012-10-31 13:46:00 -06:00
|
|
|
* the rxq based on the txq where the last packet of the flow comes. As
|
|
|
|
* the userspace application move between processors, we may get a
|
|
|
|
* different rxq no. here. If we could not get rxhash, then we would
|
|
|
|
* hope the rxq no. may help here.
|
|
|
|
*/
|
2017-12-04 02:31:23 -07:00
|
|
|
static u16 tun_automq_select_queue(struct tun_struct *tun, struct sk_buff *skb)
|
2012-10-31 13:46:00 -06:00
|
|
|
{
|
2012-10-31 13:46:02 -06:00
|
|
|
struct tun_flow_entry *e;
|
2012-10-31 13:46:00 -06:00
|
|
|
u32 txq = 0;
|
|
|
|
u32 numqueues = 0;
|
|
|
|
|
locking/atomics: COCCINELLE/treewide: Convert trivial ACCESS_ONCE() patterns to READ_ONCE()/WRITE_ONCE()
Please do not apply this to mainline directly, instead please re-run the
coccinelle script shown below and apply its output.
For several reasons, it is desirable to use {READ,WRITE}_ONCE() in
preference to ACCESS_ONCE(), and new code is expected to use one of the
former. So far, there's been no reason to change most existing uses of
ACCESS_ONCE(), as these aren't harmful, and changing them results in
churn.
However, for some features, the read/write distinction is critical to
correct operation. To distinguish these cases, separate read/write
accessors must be used. This patch migrates (most) remaining
ACCESS_ONCE() instances to {READ,WRITE}_ONCE(), using the following
coccinelle script:
----
// Convert trivial ACCESS_ONCE() uses to equivalent READ_ONCE() and
// WRITE_ONCE()
// $ make coccicheck COCCI=/home/mark/once.cocci SPFLAGS="--include-headers" MODE=patch
virtual patch
@ depends on patch @
expression E1, E2;
@@
- ACCESS_ONCE(E1) = E2
+ WRITE_ONCE(E1, E2)
@ depends on patch @
expression E;
@@
- ACCESS_ONCE(E)
+ READ_ONCE(E)
----
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: davem@davemloft.net
Cc: linux-arch@vger.kernel.org
Cc: mpe@ellerman.id.au
Cc: shuah@kernel.org
Cc: snitzer@redhat.com
Cc: thor.thayer@linux.intel.com
Cc: tj@kernel.org
Cc: viro@zeniv.linux.org.uk
Cc: will.deacon@arm.com
Link: http://lkml.kernel.org/r/1508792849-3115-19-git-send-email-paulmck@linux.vnet.ibm.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2017-10-23 15:07:29 -06:00
|
|
|
numqueues = READ_ONCE(tun->numqueues);
|
2012-10-31 13:46:00 -06:00
|
|
|
|
2017-06-06 00:09:49 -06:00
|
|
|
txq = __skb_get_hash_symmetric(skb);
|
2012-10-31 13:46:00 -06:00
|
|
|
if (txq) {
|
2012-10-31 13:46:02 -06:00
|
|
|
e = tun_flow_find(&tun->flows[tun_hashfn(txq)], txq);
|
2013-12-22 03:54:32 -07:00
|
|
|
if (e) {
|
|
|
|
tun_flow_save_rps_rxhash(e, txq);
|
2014-01-01 22:24:28 -07:00
|
|
|
txq = e->queue_index;
|
2013-12-22 03:54:32 -07:00
|
|
|
} else
|
2012-10-31 13:46:02 -06:00
|
|
|
/* use multiply and shift instead of expensive divide */
|
|
|
|
txq = ((u64)txq * numqueues) >> 32;
|
2012-10-31 13:46:00 -06:00
|
|
|
} else if (likely(skb_rx_queue_recorded(skb))) {
|
|
|
|
txq = skb_get_rx_queue(skb);
|
|
|
|
while (unlikely(txq >= numqueues))
|
|
|
|
txq -= numqueues;
|
|
|
|
}
|
|
|
|
|
|
|
|
return txq;
|
|
|
|
}
|
|
|
|
|
2017-12-04 02:31:23 -07:00
|
|
|
static u16 tun_ebpf_select_queue(struct tun_struct *tun, struct sk_buff *skb)
|
|
|
|
{
|
2018-01-16 01:31:01 -07:00
|
|
|
struct tun_prog *prog;
|
2017-12-04 02:31:23 -07:00
|
|
|
u16 ret = 0;
|
|
|
|
|
|
|
|
prog = rcu_dereference(tun->steering_prog);
|
|
|
|
if (prog)
|
|
|
|
ret = bpf_prog_run_clear_cb(prog->prog, skb);
|
|
|
|
|
|
|
|
return ret % tun->numqueues;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u16 tun_select_queue(struct net_device *dev, struct sk_buff *skb,
|
|
|
|
void *accel_priv, select_queue_fallback_t fallback)
|
|
|
|
{
|
|
|
|
struct tun_struct *tun = netdev_priv(dev);
|
|
|
|
u16 ret;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
if (rcu_dereference(tun->steering_prog))
|
|
|
|
ret = tun_ebpf_select_queue(tun, skb);
|
|
|
|
else
|
|
|
|
ret = tun_automq_select_queue(tun, skb);
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-10-31 13:46:01 -06:00
|
|
|
static inline bool tun_not_capable(struct tun_struct *tun)
|
|
|
|
{
|
|
|
|
const struct cred *cred = current_cred();
|
2012-11-18 14:34:11 -07:00
|
|
|
struct net *net = dev_net(tun->dev);
|
2012-10-31 13:46:01 -06:00
|
|
|
|
|
|
|
return ((uid_valid(tun->owner) && !uid_eq(cred->euid, tun->owner)) ||
|
|
|
|
(gid_valid(tun->group) && !in_egroup_p(tun->group))) &&
|
2012-11-18 14:34:11 -07:00
|
|
|
!ns_capable(net->user_ns, CAP_NET_ADMIN);
|
2012-10-31 13:46:01 -06:00
|
|
|
}
|
|
|
|
|
2012-10-31 13:46:00 -06:00
|
|
|
static void tun_set_real_num_queues(struct tun_struct *tun)
|
|
|
|
{
|
|
|
|
netif_set_real_num_tx_queues(tun->dev, tun->numqueues);
|
|
|
|
netif_set_real_num_rx_queues(tun->dev, tun->numqueues);
|
|
|
|
}
|
|
|
|
|
2012-12-13 16:53:30 -07:00
|
|
|
static void tun_disable_queue(struct tun_struct *tun, struct tun_file *tfile)
|
|
|
|
{
|
|
|
|
tfile->detached = tun;
|
|
|
|
list_add_tail(&tfile->next, &tun->disabled);
|
|
|
|
++tun->numdisabled;
|
|
|
|
}
|
|
|
|
|
2012-12-17 20:00:27 -07:00
|
|
|
static struct tun_struct *tun_enable_queue(struct tun_file *tfile)
|
2012-12-13 16:53:30 -07:00
|
|
|
{
|
|
|
|
struct tun_struct *tun = tfile->detached;
|
|
|
|
|
|
|
|
tfile->detached = NULL;
|
|
|
|
list_del_init(&tfile->next);
|
|
|
|
--tun->numdisabled;
|
|
|
|
return tun;
|
|
|
|
}
|
|
|
|
|
2018-01-03 20:14:28 -07:00
|
|
|
static void tun_ptr_free(void *ptr)
|
|
|
|
{
|
|
|
|
if (!ptr)
|
|
|
|
return;
|
|
|
|
if (tun_is_xdp_buff(ptr)) {
|
|
|
|
struct xdp_buff *xdp = tun_ptr_to_xdp(ptr);
|
|
|
|
|
|
|
|
put_page(virt_to_head_page(xdp->data));
|
|
|
|
} else {
|
|
|
|
__skb_array_destroy_skb(ptr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-05 03:53:59 -06:00
|
|
|
static void tun_queue_purge(struct tun_file *tfile)
|
|
|
|
{
|
2018-01-03 20:14:28 -07:00
|
|
|
void *ptr;
|
2016-06-30 00:45:36 -06:00
|
|
|
|
2018-01-03 20:14:28 -07:00
|
|
|
while ((ptr = ptr_ring_consume(&tfile->tx_ring)) != NULL)
|
|
|
|
tun_ptr_free(ptr);
|
2016-06-30 00:45:36 -06:00
|
|
|
|
2017-01-18 00:02:03 -07:00
|
|
|
skb_queue_purge(&tfile->sk.sk_write_queue);
|
2013-09-05 03:53:59 -06:00
|
|
|
skb_queue_purge(&tfile->sk.sk_error_queue);
|
|
|
|
}
|
|
|
|
|
2018-01-19 20:59:33 -07:00
|
|
|
static void tun_cleanup_tx_ring(struct tun_file *tfile)
|
2018-01-15 12:37:29 -07:00
|
|
|
{
|
2018-01-19 20:59:33 -07:00
|
|
|
if (tfile->tx_ring.queue) {
|
|
|
|
ptr_ring_cleanup(&tfile->tx_ring, tun_ptr_free);
|
|
|
|
xdp_rxq_info_unreg(&tfile->xdp_rxq);
|
|
|
|
memset(&tfile->tx_ring, 0, sizeof(tfile->tx_ring));
|
2018-01-15 12:37:29 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-31 13:46:00 -06:00
|
|
|
static void __tun_detach(struct tun_file *tfile, bool clean)
|
|
|
|
{
|
|
|
|
struct tun_file *ntfile;
|
|
|
|
struct tun_struct *tun;
|
|
|
|
|
2013-01-11 09:59:32 -07:00
|
|
|
tun = rtnl_dereference(tfile->tun);
|
|
|
|
|
2017-09-22 14:49:14 -06:00
|
|
|
if (tun && clean) {
|
|
|
|
tun_napi_disable(tun, tfile);
|
|
|
|
tun_napi_del(tun, tfile);
|
|
|
|
}
|
|
|
|
|
2013-01-27 18:05:19 -07:00
|
|
|
if (tun && !tfile->detached) {
|
2012-10-31 13:46:00 -06:00
|
|
|
u16 index = tfile->queue_index;
|
|
|
|
BUG_ON(index >= tun->numqueues);
|
|
|
|
|
|
|
|
rcu_assign_pointer(tun->tfiles[index],
|
|
|
|
tun->tfiles[tun->numqueues - 1]);
|
2013-01-11 09:59:32 -07:00
|
|
|
ntfile = rtnl_dereference(tun->tfiles[index]);
|
2012-10-31 13:46:00 -06:00
|
|
|
ntfile->queue_index = index;
|
|
|
|
|
|
|
|
--tun->numqueues;
|
2013-01-27 18:05:19 -07:00
|
|
|
if (clean) {
|
2014-03-23 12:32:32 -06:00
|
|
|
RCU_INIT_POINTER(tfile->tun, NULL);
|
2012-12-13 16:53:30 -07:00
|
|
|
sock_put(&tfile->sk);
|
2013-01-27 18:05:19 -07:00
|
|
|
} else
|
2012-12-13 16:53:30 -07:00
|
|
|
tun_disable_queue(tun, tfile);
|
2012-10-31 13:46:00 -06:00
|
|
|
|
|
|
|
synchronize_net();
|
2012-10-31 13:46:02 -06:00
|
|
|
tun_flow_delete_by_queue(tun, tun->numqueues + 1);
|
2012-10-31 13:46:00 -06:00
|
|
|
/* Drop read queue */
|
2013-09-05 03:53:59 -06:00
|
|
|
tun_queue_purge(tfile);
|
2012-10-31 13:46:00 -06:00
|
|
|
tun_set_real_num_queues(tun);
|
2013-01-11 09:59:34 -07:00
|
|
|
} else if (tfile->detached && clean) {
|
2012-12-13 16:53:30 -07:00
|
|
|
tun = tun_enable_queue(tfile);
|
2013-01-11 09:59:34 -07:00
|
|
|
sock_put(&tfile->sk);
|
|
|
|
}
|
2012-10-31 13:46:00 -06:00
|
|
|
|
|
|
|
if (clean) {
|
2013-01-27 17:38:02 -07:00
|
|
|
if (tun && tun->numqueues == 0 && tun->numdisabled == 0) {
|
|
|
|
netif_carrier_off(tun->dev);
|
|
|
|
|
2014-11-19 06:17:31 -07:00
|
|
|
if (!(tun->flags & IFF_PERSIST) &&
|
2013-01-27 17:38:02 -07:00
|
|
|
tun->dev->reg_state == NETREG_REGISTERED)
|
2012-12-13 16:53:30 -07:00
|
|
|
unregister_netdevice(tun->dev);
|
2013-01-27 17:38:02 -07:00
|
|
|
}
|
2018-01-19 20:59:33 -07:00
|
|
|
tun_cleanup_tx_ring(tfile);
|
2015-05-08 20:07:08 -06:00
|
|
|
sock_put(&tfile->sk);
|
2012-10-31 13:46:00 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tun_detach(struct tun_file *tfile, bool clean)
|
|
|
|
{
|
|
|
|
rtnl_lock();
|
|
|
|
__tun_detach(tfile, clean);
|
|
|
|
rtnl_unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tun_detach_all(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct tun_struct *tun = netdev_priv(dev);
|
2012-12-13 16:53:30 -07:00
|
|
|
struct tun_file *tfile, *tmp;
|
2012-10-31 13:46:00 -06:00
|
|
|
int i, n = tun->numqueues;
|
|
|
|
|
|
|
|
for (i = 0; i < n; i++) {
|
2013-01-11 09:59:32 -07:00
|
|
|
tfile = rtnl_dereference(tun->tfiles[i]);
|
2012-10-31 13:46:00 -06:00
|
|
|
BUG_ON(!tfile);
|
2017-09-22 14:49:14 -06:00
|
|
|
tun_napi_disable(tun, tfile);
|
2016-05-18 23:36:51 -06:00
|
|
|
tfile->socket.sk->sk_shutdown = RCV_SHUTDOWN;
|
2014-05-16 16:11:48 -06:00
|
|
|
tfile->socket.sk->sk_data_ready(tfile->socket.sk);
|
2014-03-23 12:32:32 -06:00
|
|
|
RCU_INIT_POINTER(tfile->tun, NULL);
|
2012-10-31 13:46:00 -06:00
|
|
|
--tun->numqueues;
|
|
|
|
}
|
2013-01-27 18:05:19 -07:00
|
|
|
list_for_each_entry(tfile, &tun->disabled, next) {
|
2016-05-18 23:36:51 -06:00
|
|
|
tfile->socket.sk->sk_shutdown = RCV_SHUTDOWN;
|
2014-05-16 16:11:48 -06:00
|
|
|
tfile->socket.sk->sk_data_ready(tfile->socket.sk);
|
2014-03-23 12:32:32 -06:00
|
|
|
RCU_INIT_POINTER(tfile->tun, NULL);
|
2013-01-27 18:05:19 -07:00
|
|
|
}
|
2012-10-31 13:46:00 -06:00
|
|
|
BUG_ON(tun->numqueues != 0);
|
|
|
|
|
|
|
|
synchronize_net();
|
|
|
|
for (i = 0; i < n; i++) {
|
2013-01-11 09:59:32 -07:00
|
|
|
tfile = rtnl_dereference(tun->tfiles[i]);
|
2017-09-22 14:49:14 -06:00
|
|
|
tun_napi_del(tun, tfile);
|
2012-10-31 13:46:00 -06:00
|
|
|
/* Drop read queue */
|
2013-09-05 03:53:59 -06:00
|
|
|
tun_queue_purge(tfile);
|
2012-10-31 13:46:00 -06:00
|
|
|
sock_put(&tfile->sk);
|
2018-01-19 20:59:33 -07:00
|
|
|
tun_cleanup_tx_ring(tfile);
|
2012-10-31 13:46:00 -06:00
|
|
|
}
|
2012-12-13 16:53:30 -07:00
|
|
|
list_for_each_entry_safe(tfile, tmp, &tun->disabled, next) {
|
|
|
|
tun_enable_queue(tfile);
|
2013-09-05 03:53:59 -06:00
|
|
|
tun_queue_purge(tfile);
|
2012-12-13 16:53:30 -07:00
|
|
|
sock_put(&tfile->sk);
|
2018-01-19 20:59:33 -07:00
|
|
|
tun_cleanup_tx_ring(tfile);
|
2012-12-13 16:53:30 -07:00
|
|
|
}
|
|
|
|
BUG_ON(tun->numdisabled != 0);
|
2013-01-11 09:59:34 -07:00
|
|
|
|
2014-11-19 06:17:31 -07:00
|
|
|
if (tun->flags & IFF_PERSIST)
|
2013-01-11 09:59:34 -07:00
|
|
|
module_put(THIS_MODULE);
|
2012-10-31 13:46:00 -06:00
|
|
|
}
|
|
|
|
|
2017-09-22 14:49:14 -06:00
|
|
|
static int tun_attach(struct tun_struct *tun, struct file *file,
|
|
|
|
bool skip_filter, bool napi)
|
2009-01-20 03:57:48 -07:00
|
|
|
{
|
2009-01-20 04:00:40 -07:00
|
|
|
struct tun_file *tfile = file->private_data;
|
2016-06-30 00:45:36 -06:00
|
|
|
struct net_device *dev = tun->dev;
|
2009-01-20 04:02:28 -07:00
|
|
|
int err;
|
2009-01-20 03:57:48 -07:00
|
|
|
|
2013-01-14 00:12:19 -07:00
|
|
|
err = security_tun_dev_attach(tfile->socket.sk, tun->security);
|
|
|
|
if (err < 0)
|
|
|
|
goto out;
|
|
|
|
|
2009-01-20 04:02:28 -07:00
|
|
|
err = -EINVAL;
|
2013-01-27 18:05:19 -07:00
|
|
|
if (rtnl_dereference(tfile->tun) && !tfile->detached)
|
2009-01-20 04:02:28 -07:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
err = -EBUSY;
|
2014-11-19 06:17:31 -07:00
|
|
|
if (!(tun->flags & IFF_MULTI_QUEUE) && tun->numqueues == 1)
|
2012-10-31 13:46:00 -06:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
err = -E2BIG;
|
2012-12-13 16:53:30 -07:00
|
|
|
if (!tfile->detached &&
|
|
|
|
tun->numqueues + tun->numdisabled == MAX_TAP_QUEUES)
|
2009-01-20 04:02:28 -07:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
err = 0;
|
2012-10-31 13:45:57 -06:00
|
|
|
|
2013-12-05 21:42:58 -07:00
|
|
|
/* Re-attach the filter to persist device */
|
tun: Allow to skip filter on attach
There's a small problem with sk-filters on tun devices. Consider
an application doing this sequence of steps:
fd = open("/dev/net/tun");
ioctl(fd, TUNSETIFF, { .ifr_name = "tun0" });
ioctl(fd, TUNATTACHFILTER, &my_filter);
ioctl(fd, TUNSETPERSIST, 1);
close(fd);
At that point the tun0 will remain in the system and will keep in
mind that there should be a socket filter at address '&my_filter'.
If after that we do
fd = open("/dev/net/tun");
ioctl(fd, TUNSETIFF, { .ifr_name = "tun0" });
we most likely receive the -EFAULT error, since tun_attach() would
try to connect the filter back. But (!) if we provide a filter at
address &my_filter, then tun0 will be created and the "new" filter
would be attached, but application may not know about that.
This may create certain problems to anyone using tun-s, but it's
critical problem for c/r -- if we meet a persistent tun device
with a filter in mind, we will not be able to attach to it to dump
its state (flags, owner, address, vnethdr size, etc.).
The proposal is to allow to attach to tun device (with TUNSETIFF)
w/o attaching the filter to the tun-file's socket. After this
attach app may e.g clean the device by dropping the filter, it
doesn't want to have one, or (in case of c/r) get information
about the device with tun ioctls.
Signed-off-by: Pavel Emelyanov <xemul@parallels.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-08-21 04:32:21 -06:00
|
|
|
if (!skip_filter && (tun->filter_attached == true)) {
|
2016-04-05 09:10:16 -06:00
|
|
|
lock_sock(tfile->socket.sk);
|
|
|
|
err = sk_attach_filter(&tun->fprog, tfile->socket.sk);
|
|
|
|
release_sock(tfile->socket.sk);
|
2012-10-31 13:45:57 -06:00
|
|
|
if (!err)
|
|
|
|
goto out;
|
|
|
|
}
|
2016-06-30 00:45:36 -06:00
|
|
|
|
|
|
|
if (!tfile->detached &&
|
2018-01-03 20:14:27 -07:00
|
|
|
ptr_ring_init(&tfile->tx_ring, dev->tx_queue_len, GFP_KERNEL)) {
|
2016-06-30 00:45:36 -06:00
|
|
|
err = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2012-10-31 13:46:00 -06:00
|
|
|
tfile->queue_index = tun->numqueues;
|
2016-05-18 23:36:51 -06:00
|
|
|
tfile->socket.sk->sk_shutdown &= ~RCV_SHUTDOWN;
|
2018-01-03 03:25:59 -07:00
|
|
|
|
|
|
|
if (tfile->detached) {
|
|
|
|
/* Re-attach detached tfile, updating XDP queue_index */
|
|
|
|
WARN_ON(!xdp_rxq_info_is_reg(&tfile->xdp_rxq));
|
|
|
|
|
|
|
|
if (tfile->xdp_rxq.queue_index != tfile->queue_index)
|
|
|
|
tfile->xdp_rxq.queue_index = tfile->queue_index;
|
|
|
|
} else {
|
|
|
|
/* Setup XDP RX-queue info, for new tfile getting attached */
|
|
|
|
err = xdp_rxq_info_reg(&tfile->xdp_rxq,
|
|
|
|
tun->dev, tfile->queue_index);
|
|
|
|
if (err < 0)
|
|
|
|
goto out;
|
|
|
|
err = 0;
|
|
|
|
}
|
|
|
|
|
2012-10-31 13:45:58 -06:00
|
|
|
rcu_assign_pointer(tfile->tun, tun);
|
2012-10-31 13:46:00 -06:00
|
|
|
rcu_assign_pointer(tun->tfiles[tun->numqueues], tfile);
|
|
|
|
tun->numqueues++;
|
2009-01-20 03:57:48 -07:00
|
|
|
|
2017-09-22 14:49:14 -06:00
|
|
|
if (tfile->detached) {
|
2012-12-13 16:53:30 -07:00
|
|
|
tun_enable_queue(tfile);
|
2017-09-22 14:49:14 -06:00
|
|
|
} else {
|
2012-12-13 16:53:30 -07:00
|
|
|
sock_hold(&tfile->sk);
|
2017-09-22 14:49:14 -06:00
|
|
|
tun_napi_init(tun, tfile, napi);
|
|
|
|
}
|
2012-12-13 16:53:30 -07:00
|
|
|
|
2012-10-31 13:46:00 -06:00
|
|
|
tun_set_real_num_queues(tun);
|
2009-01-20 03:57:48 -07:00
|
|
|
|
2012-10-31 13:46:00 -06:00
|
|
|
/* device is allowed to go away first, so no need to hold extra
|
|
|
|
* refcnt.
|
|
|
|
*/
|
|
|
|
|
|
|
|
out:
|
|
|
|
return err;
|
2009-01-20 04:00:40 -07:00
|
|
|
}
|
|
|
|
|
2017-09-23 08:36:52 -06:00
|
|
|
static struct tun_struct *tun_get(struct tun_file *tfile)
|
2009-01-20 04:00:40 -07:00
|
|
|
{
|
2012-10-31 13:45:58 -06:00
|
|
|
struct tun_struct *tun;
|
2009-01-20 04:07:17 -07:00
|
|
|
|
2012-10-31 13:45:58 -06:00
|
|
|
rcu_read_lock();
|
|
|
|
tun = rcu_dereference(tfile->tun);
|
|
|
|
if (tun)
|
|
|
|
dev_hold(tun->dev);
|
|
|
|
rcu_read_unlock();
|
2009-01-20 04:07:17 -07:00
|
|
|
|
|
|
|
return tun;
|
2009-01-20 04:00:40 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void tun_put(struct tun_struct *tun)
|
|
|
|
{
|
2012-10-31 13:45:58 -06:00
|
|
|
dev_put(tun->dev);
|
2009-01-20 04:00:40 -07:00
|
|
|
}
|
|
|
|
|
2011-03-02 00:18:10 -07:00
|
|
|
/* TAP filtering */
|
2008-07-14 23:18:19 -06:00
|
|
|
static void addr_hash_set(u32 *mask, const u8 *addr)
|
|
|
|
{
|
|
|
|
int n = ether_crc(ETH_ALEN, addr) >> 26;
|
|
|
|
mask[n >> 5] |= (1 << (n & 31));
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int addr_hash_test(const u32 *mask, const u8 *addr)
|
|
|
|
{
|
|
|
|
int n = ether_crc(ETH_ALEN, addr) >> 26;
|
|
|
|
return mask[n >> 5] & (1 << (n & 31));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int update_filter(struct tap_filter *filter, void __user *arg)
|
|
|
|
{
|
|
|
|
struct { u8 u[ETH_ALEN]; } *addr;
|
|
|
|
struct tun_filter uf;
|
|
|
|
int err, alen, n, nexact;
|
|
|
|
|
|
|
|
if (copy_from_user(&uf, arg, sizeof(uf)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
if (!uf.count) {
|
|
|
|
/* Disabled */
|
|
|
|
filter->count = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
alen = ETH_ALEN * uf.count;
|
2016-08-20 00:54:15 -06:00
|
|
|
addr = memdup_user(arg + sizeof(uf), alen);
|
|
|
|
if (IS_ERR(addr))
|
|
|
|
return PTR_ERR(addr);
|
2008-07-14 23:18:19 -06:00
|
|
|
|
|
|
|
/* The filter is updated without holding any locks. Which is
|
|
|
|
* perfectly safe. We disable it first and in the worst
|
|
|
|
* case we'll accept a few undesired packets. */
|
|
|
|
filter->count = 0;
|
|
|
|
wmb();
|
|
|
|
|
|
|
|
/* Use first set of addresses as an exact filter */
|
|
|
|
for (n = 0; n < uf.count && n < FLT_EXACT_COUNT; n++)
|
|
|
|
memcpy(filter->addr[n], addr[n].u, ETH_ALEN);
|
|
|
|
|
|
|
|
nexact = n;
|
|
|
|
|
2009-02-08 18:49:17 -07:00
|
|
|
/* Remaining multicast addresses are hashed,
|
|
|
|
* unicast will leave the filter disabled. */
|
2008-07-14 23:18:19 -06:00
|
|
|
memset(filter->mask, 0, sizeof(filter->mask));
|
2009-02-08 18:49:17 -07:00
|
|
|
for (; n < uf.count; n++) {
|
|
|
|
if (!is_multicast_ether_addr(addr[n].u)) {
|
|
|
|
err = 0; /* no filter */
|
2016-08-20 01:00:34 -06:00
|
|
|
goto free_addr;
|
2009-02-08 18:49:17 -07:00
|
|
|
}
|
2008-07-14 23:18:19 -06:00
|
|
|
addr_hash_set(filter->mask, addr[n].u);
|
2009-02-08 18:49:17 -07:00
|
|
|
}
|
2008-07-14 23:18:19 -06:00
|
|
|
|
|
|
|
/* For ALLMULTI just set the mask to all ones.
|
|
|
|
* This overrides the mask populated above. */
|
|
|
|
if ((uf.flags & TUN_FLT_ALLMULTI))
|
|
|
|
memset(filter->mask, ~0, sizeof(filter->mask));
|
|
|
|
|
|
|
|
/* Now enable the filter */
|
|
|
|
wmb();
|
|
|
|
filter->count = nexact;
|
|
|
|
|
|
|
|
/* Return the number of exact filters */
|
|
|
|
err = nexact;
|
2016-08-20 01:00:34 -06:00
|
|
|
free_addr:
|
2008-07-14 23:18:19 -06:00
|
|
|
kfree(addr);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Returns: 0 - drop, !=0 - accept */
|
|
|
|
static int run_filter(struct tap_filter *filter, const struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
/* Cannot use eth_hdr(skb) here because skb_mac_hdr() is incorrect
|
|
|
|
* at this point. */
|
|
|
|
struct ethhdr *eh = (struct ethhdr *) skb->data;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Exact match */
|
|
|
|
for (i = 0; i < filter->count; i++)
|
drivers/net: Convert compare_ether_addr to ether_addr_equal
Use the new bool function ether_addr_equal to add
some clarity and reduce the likelihood for misuse
of compare_ether_addr for sorting.
Done via cocci script:
$ cat compare_ether_addr.cocci
@@
expression a,b;
@@
- !compare_ether_addr(a, b)
+ ether_addr_equal(a, b)
@@
expression a,b;
@@
- compare_ether_addr(a, b)
+ !ether_addr_equal(a, b)
@@
expression a,b;
@@
- !ether_addr_equal(a, b) == 0
+ ether_addr_equal(a, b)
@@
expression a,b;
@@
- !ether_addr_equal(a, b) != 0
+ !ether_addr_equal(a, b)
@@
expression a,b;
@@
- ether_addr_equal(a, b) == 0
+ !ether_addr_equal(a, b)
@@
expression a,b;
@@
- ether_addr_equal(a, b) != 0
+ ether_addr_equal(a, b)
@@
expression a,b;
@@
- !!ether_addr_equal(a, b)
+ ether_addr_equal(a, b)
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2012-05-09 11:17:46 -06:00
|
|
|
if (ether_addr_equal(eh->h_dest, filter->addr[i]))
|
2008-07-14 23:18:19 -06:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* Inexact match (multicast only) */
|
|
|
|
if (is_multicast_ether_addr(eh->h_dest))
|
|
|
|
return addr_hash_test(filter->mask, eh->h_dest);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Checks whether the packet is accepted or not.
|
|
|
|
* Returns: 0 - drop, !=0 - accept
|
|
|
|
*/
|
|
|
|
static int check_filter(struct tap_filter *filter, const struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
if (!filter->count)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return run_filter(filter, skb);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Network device part of the driver */
|
|
|
|
|
2006-09-13 12:30:00 -06:00
|
|
|
static const struct ethtool_ops tun_ethtool_ops;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-01-20 04:07:17 -07:00
|
|
|
/* Net device detach from fd. */
|
|
|
|
static void tun_net_uninit(struct net_device *dev)
|
|
|
|
{
|
2012-10-31 13:46:00 -06:00
|
|
|
tun_detach_all(dev);
|
2009-01-20 04:07:17 -07:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Net device open. */
|
|
|
|
static int tun_net_open(struct net_device *dev)
|
|
|
|
{
|
2017-03-12 17:00:26 -06:00
|
|
|
struct tun_struct *tun = netdev_priv(dev);
|
|
|
|
int i;
|
|
|
|
|
2012-10-31 13:46:00 -06:00
|
|
|
netif_tx_start_all_queues(dev);
|
2017-03-12 17:00:26 -06:00
|
|
|
|
|
|
|
for (i = 0; i < tun->numqueues; i++) {
|
|
|
|
struct tun_file *tfile;
|
|
|
|
|
|
|
|
tfile = rtnl_dereference(tun->tfiles[i]);
|
|
|
|
tfile->socket.sk->sk_write_space(tfile->socket.sk);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Net device close. */
|
|
|
|
static int tun_net_close(struct net_device *dev)
|
|
|
|
{
|
2012-10-31 13:46:00 -06:00
|
|
|
netif_tx_stop_all_queues(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Net device start xmit */
|
2017-12-04 02:31:23 -07:00
|
|
|
static void tun_automq_xmit(struct tun_struct *tun, struct sk_buff *skb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2016-04-25 21:13:42 -06:00
|
|
|
#ifdef CONFIG_RPS
|
2017-12-04 02:31:23 -07:00
|
|
|
if (tun->numqueues == 1 && static_key_false(&rps_needed)) {
|
2013-12-22 03:54:32 -07:00
|
|
|
/* Select queue was not called for the skbuff, so we extract the
|
|
|
|
* RPS hash and save it into the flow_table here.
|
|
|
|
*/
|
|
|
|
__u32 rxhash;
|
|
|
|
|
2017-06-06 00:09:49 -06:00
|
|
|
rxhash = __skb_get_hash_symmetric(skb);
|
2013-12-22 03:54:32 -07:00
|
|
|
if (rxhash) {
|
|
|
|
struct tun_flow_entry *e;
|
|
|
|
e = tun_flow_find(&tun->flows[tun_hashfn(rxhash)],
|
|
|
|
rxhash);
|
|
|
|
if (e)
|
|
|
|
tun_flow_save_rps_rxhash(e, rxhash);
|
|
|
|
}
|
|
|
|
}
|
2016-04-25 21:13:42 -06:00
|
|
|
#endif
|
2017-12-04 02:31:23 -07:00
|
|
|
}
|
|
|
|
|
2018-01-16 01:31:02 -07:00
|
|
|
static unsigned int run_ebpf_filter(struct tun_struct *tun,
|
|
|
|
struct sk_buff *skb,
|
|
|
|
int len)
|
|
|
|
{
|
|
|
|
struct tun_prog *prog = rcu_dereference(tun->filter_prog);
|
|
|
|
|
|
|
|
if (prog)
|
|
|
|
len = bpf_prog_run_clear_cb(prog->prog, skb);
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2017-12-04 02:31:23 -07:00
|
|
|
/* Net device start xmit */
|
|
|
|
static netdev_tx_t tun_net_xmit(struct sk_buff *skb, struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct tun_struct *tun = netdev_priv(dev);
|
|
|
|
int txq = skb->queue_mapping;
|
|
|
|
struct tun_file *tfile;
|
2018-01-16 01:31:02 -07:00
|
|
|
int len = skb->len;
|
2017-12-04 02:31:23 -07:00
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
tfile = rcu_dereference(tun->tfiles[txq]);
|
|
|
|
|
|
|
|
/* Drop packet if interface is not attached */
|
2017-12-05 20:11:17 -07:00
|
|
|
if (txq >= tun->numqueues)
|
2017-12-04 02:31:23 -07:00
|
|
|
goto drop;
|
|
|
|
|
|
|
|
if (!rcu_dereference(tun->steering_prog))
|
|
|
|
tun_automq_xmit(tun, skb);
|
2013-12-22 03:54:32 -07:00
|
|
|
|
2012-10-31 13:45:58 -06:00
|
|
|
tun_debug(KERN_INFO, tun, "tun_net_xmit %d\n", skb->len);
|
|
|
|
|
2012-10-31 13:46:00 -06:00
|
|
|
BUG_ON(!tfile);
|
|
|
|
|
2008-07-14 23:18:19 -06:00
|
|
|
/* Drop if the filter does not like it.
|
|
|
|
* This is a noop if the filter is disabled.
|
|
|
|
* Filter can be enabled only for the TAP devices. */
|
|
|
|
if (!check_filter(&tun->txflt, skb))
|
|
|
|
goto drop;
|
|
|
|
|
2012-10-31 13:45:57 -06:00
|
|
|
if (tfile->socket.sk->sk_filter &&
|
|
|
|
sk_filter(tfile->socket.sk, skb))
|
2010-02-13 18:01:10 -07:00
|
|
|
goto drop;
|
|
|
|
|
2018-01-16 01:31:02 -07:00
|
|
|
len = run_ebpf_filter(tun, skb, len);
|
|
|
|
|
|
|
|
/* Trim extra bytes since we may insert vlan proto & TCI
|
|
|
|
* in tun_put_user().
|
|
|
|
*/
|
|
|
|
len -= skb_vlan_tag_present(skb) ? sizeof(struct veth) : 0;
|
|
|
|
if (len <= 0 || pskb_trim(skb, len))
|
|
|
|
goto drop;
|
|
|
|
|
sock: enable MSG_ZEROCOPY
Prepare the datapath for refcounted ubuf_info. Clone ubuf_info with
skb_zerocopy_clone() wherever needed due to skb split, merge, resize
or clone.
Split skb_orphan_frags into two variants. The split, merge, .. paths
support reference counted zerocopy buffers, so do not do a deep copy.
Add skb_orphan_frags_rx for paths that may loop packets to receive
sockets. That is not allowed, as it may cause unbounded latency.
Deep copy all zerocopy copy buffers, ref-counted or not, in this path.
The exact locations to modify were chosen by exhaustively searching
through all code that might modify skb_frag references and/or the
the SKBTX_DEV_ZEROCOPY tx_flags bit.
The changes err on the safe side, in two ways.
(1) legacy ubuf_info paths virtio and tap are not modified. They keep
a 1:1 ubuf_info to sk_buff relationship. Calls to skb_orphan_frags
still call skb_copy_ubufs and thus copy frags in this case.
(2) not all copies deep in the stack are addressed yet. skb_shift,
skb_split and skb_try_coalesce can be refined to avoid copying.
These are not in the hot path and this patch is hairy enough as
is, so that is left for future refinement.
Signed-off-by: Willem de Bruijn <willemb@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-03 14:29:41 -06:00
|
|
|
if (unlikely(skb_orphan_frags_rx(skb, GFP_ATOMIC)))
|
2013-09-05 03:54:00 -06:00
|
|
|
goto drop;
|
|
|
|
|
2016-08-23 16:22:33 -06:00
|
|
|
skb_tx_timestamp(skb);
|
2013-07-19 11:40:10 -06:00
|
|
|
|
tun: orphan an skb on tx
The following situation was observed in the field:
tap1 sends packets, tap2 does not consume them, as a result
tap1 can not be closed. This happens because
tun/tap devices can hang on to skbs undefinitely.
As noted by Herbert, possible solutions include a timeout followed by a
copy/change of ownership of the skb, or always copying/changing
ownership if we're going into a hostile device.
This patch implements the second approach.
Note: one issue still remaining is that since skbs
keep reference to tun socket and tun socket has a
reference to tun device, we won't flush backlog,
instead simply waiting for all skbs to get transmitted.
At least this is not user-triggerable, and
this was not reported in practice, my assumption is
other devices besides tap complete an skb
within finite time after it has been queued.
A possible solution for the second issue
would not to have socket reference the device,
instead, implement dev->destructor for tun, and
wait for all skbs to complete there, but this
needs some thought, probably too risky for 2.6.34.
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Tested-by: Yan Vugenfirer <yvugenfi@redhat.com>
Acked-by: Herbert Xu <herbert@gondor.apana.org.au>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 22:59:44 -06:00
|
|
|
/* Orphan the skb - required as we might hang on to it
|
2013-09-05 03:54:00 -06:00
|
|
|
* for indefinite time.
|
|
|
|
*/
|
tun: orphan an skb on tx
The following situation was observed in the field:
tap1 sends packets, tap2 does not consume them, as a result
tap1 can not be closed. This happens because
tun/tap devices can hang on to skbs undefinitely.
As noted by Herbert, possible solutions include a timeout followed by a
copy/change of ownership of the skb, or always copying/changing
ownership if we're going into a hostile device.
This patch implements the second approach.
Note: one issue still remaining is that since skbs
keep reference to tun socket and tun socket has a
reference to tun device, we won't flush backlog,
instead simply waiting for all skbs to get transmitted.
At least this is not user-triggerable, and
this was not reported in practice, my assumption is
other devices besides tap complete an skb
within finite time after it has been queued.
A possible solution for the second issue
would not to have socket reference the device,
instead, implement dev->destructor for tun, and
wait for all skbs to complete there, but this
needs some thought, probably too risky for 2.6.34.
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Tested-by: Yan Vugenfirer <yvugenfi@redhat.com>
Acked-by: Herbert Xu <herbert@gondor.apana.org.au>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 22:59:44 -06:00
|
|
|
skb_orphan(skb);
|
|
|
|
|
2013-03-06 04:02:37 -07:00
|
|
|
nf_reset(skb);
|
|
|
|
|
2018-01-03 20:14:27 -07:00
|
|
|
if (ptr_ring_produce(&tfile->tx_ring, skb))
|
2016-06-30 00:45:36 -06:00
|
|
|
goto drop;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Notify and wake up reader process */
|
2012-10-31 13:45:57 -06:00
|
|
|
if (tfile->flags & TUN_FASYNC)
|
|
|
|
kill_fasync(&tfile->fasync, SIGIO, POLL_IN);
|
2014-05-16 16:11:48 -06:00
|
|
|
tfile->socket.sk->sk_data_ready(tfile->socket.sk);
|
2012-10-31 13:45:58 -06:00
|
|
|
|
|
|
|
rcu_read_unlock();
|
2009-06-23 00:03:08 -06:00
|
|
|
return NETDEV_TX_OK;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
drop:
|
2016-04-13 02:52:20 -06:00
|
|
|
this_cpu_inc(tun->pcpu_stats->tx_dropped);
|
2012-11-01 03:16:32 -06:00
|
|
|
skb_tx_error(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree_skb(skb);
|
2012-10-31 13:45:58 -06:00
|
|
|
rcu_read_unlock();
|
2014-11-17 22:20:41 -07:00
|
|
|
return NET_XMIT_DROP;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-07-14 23:18:19 -06:00
|
|
|
static void tun_net_mclist(struct net_device *dev)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-07-14 23:18:19 -06:00
|
|
|
/*
|
|
|
|
* This callback is supposed to deal with mc filter in
|
|
|
|
* _rx_ path and has nothing to do with the _tx_ path.
|
|
|
|
* In rx path we always accept everything userspace gives us.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2011-11-15 08:29:55 -07:00
|
|
|
static netdev_features_t tun_net_fix_features(struct net_device *dev,
|
|
|
|
netdev_features_t features)
|
2011-04-19 00:13:10 -06:00
|
|
|
{
|
|
|
|
struct tun_struct *tun = netdev_priv(dev);
|
|
|
|
|
|
|
|
return (features & tun->set_features) | (features & ~TUN_USER_FEATURES);
|
|
|
|
}
|
2011-06-14 23:25:01 -06:00
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
|
|
static void tun_poll_controller(struct net_device *dev)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Tun only receives frames when:
|
|
|
|
* 1) the char device endpoint gets data from user space
|
|
|
|
* 2) the tun socket gets a sendmsg call from user space
|
2017-09-22 14:49:14 -06:00
|
|
|
* If NAPI is not enabled, since both of those are synchronous
|
|
|
|
* operations, we are guaranteed never to have pending data when we poll
|
|
|
|
* for it so there is nothing to do here but return.
|
2011-06-14 23:25:01 -06:00
|
|
|
* We need this though so netpoll recognizes us as an interface that
|
|
|
|
* supports polling, which enables bridge devices in virt setups to
|
|
|
|
* still use netconsole
|
2017-09-22 14:49:14 -06:00
|
|
|
* If NAPI is enabled, however, we need to schedule polling for all
|
2017-09-22 14:49:15 -06:00
|
|
|
* queues unless we are using napi_gro_frags(), which we call in
|
|
|
|
* process context and not in NAPI context.
|
2011-06-14 23:25:01 -06:00
|
|
|
*/
|
2017-09-22 14:49:14 -06:00
|
|
|
struct tun_struct *tun = netdev_priv(dev);
|
|
|
|
|
|
|
|
if (tun->flags & IFF_NAPI) {
|
|
|
|
struct tun_file *tfile;
|
|
|
|
int i;
|
|
|
|
|
2017-09-22 14:49:15 -06:00
|
|
|
if (tun_napi_frags_enabled(tun))
|
|
|
|
return;
|
|
|
|
|
2017-09-22 14:49:14 -06:00
|
|
|
rcu_read_lock();
|
|
|
|
for (i = 0; i < tun->numqueues; i++) {
|
|
|
|
tfile = rcu_dereference(tun->tfiles[i]);
|
2017-10-18 13:12:09 -06:00
|
|
|
if (tfile->napi_enabled)
|
|
|
|
napi_schedule(&tfile->napi);
|
2017-09-22 14:49:14 -06:00
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
2011-06-14 23:25:01 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
2016-02-26 02:45:40 -07:00
|
|
|
|
|
|
|
static void tun_set_headroom(struct net_device *dev, int new_hr)
|
|
|
|
{
|
|
|
|
struct tun_struct *tun = netdev_priv(dev);
|
|
|
|
|
|
|
|
if (new_hr < NET_SKB_PAD)
|
|
|
|
new_hr = NET_SKB_PAD;
|
|
|
|
|
|
|
|
tun->align = new_hr;
|
|
|
|
}
|
|
|
|
|
2017-01-06 20:12:52 -07:00
|
|
|
static void
|
2016-04-13 02:52:20 -06:00
|
|
|
tun_net_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats)
|
|
|
|
{
|
|
|
|
u32 rx_dropped = 0, tx_dropped = 0, rx_frame_errors = 0;
|
|
|
|
struct tun_struct *tun = netdev_priv(dev);
|
|
|
|
struct tun_pcpu_stats *p;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for_each_possible_cpu(i) {
|
|
|
|
u64 rxpackets, rxbytes, txpackets, txbytes;
|
|
|
|
unsigned int start;
|
|
|
|
|
|
|
|
p = per_cpu_ptr(tun->pcpu_stats, i);
|
|
|
|
do {
|
|
|
|
start = u64_stats_fetch_begin(&p->syncp);
|
|
|
|
rxpackets = p->rx_packets;
|
|
|
|
rxbytes = p->rx_bytes;
|
|
|
|
txpackets = p->tx_packets;
|
|
|
|
txbytes = p->tx_bytes;
|
|
|
|
} while (u64_stats_fetch_retry(&p->syncp, start));
|
|
|
|
|
|
|
|
stats->rx_packets += rxpackets;
|
|
|
|
stats->rx_bytes += rxbytes;
|
|
|
|
stats->tx_packets += txpackets;
|
|
|
|
stats->tx_bytes += txbytes;
|
|
|
|
|
|
|
|
/* u32 counters */
|
|
|
|
rx_dropped += p->rx_dropped;
|
|
|
|
rx_frame_errors += p->rx_frame_errors;
|
|
|
|
tx_dropped += p->tx_dropped;
|
|
|
|
}
|
|
|
|
stats->rx_dropped = rx_dropped;
|
|
|
|
stats->rx_frame_errors = rx_frame_errors;
|
|
|
|
stats->tx_dropped = tx_dropped;
|
|
|
|
}
|
|
|
|
|
2017-08-11 05:41:18 -06:00
|
|
|
static int tun_xdp_set(struct net_device *dev, struct bpf_prog *prog,
|
|
|
|
struct netlink_ext_ack *extack)
|
|
|
|
{
|
|
|
|
struct tun_struct *tun = netdev_priv(dev);
|
|
|
|
struct bpf_prog *old_prog;
|
|
|
|
|
|
|
|
old_prog = rtnl_dereference(tun->xdp_prog);
|
|
|
|
rcu_assign_pointer(tun->xdp_prog, prog);
|
|
|
|
if (old_prog)
|
|
|
|
bpf_prog_put(old_prog);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 tun_xdp_query(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct tun_struct *tun = netdev_priv(dev);
|
|
|
|
const struct bpf_prog *xdp_prog;
|
|
|
|
|
|
|
|
xdp_prog = rtnl_dereference(tun->xdp_prog);
|
|
|
|
if (xdp_prog)
|
|
|
|
return xdp_prog->aux->id;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-11-03 14:56:16 -06:00
|
|
|
static int tun_xdp(struct net_device *dev, struct netdev_bpf *xdp)
|
2017-08-11 05:41:18 -06:00
|
|
|
{
|
|
|
|
switch (xdp->command) {
|
|
|
|
case XDP_SETUP_PROG:
|
|
|
|
return tun_xdp_set(dev, xdp->prog, xdp->extack);
|
|
|
|
case XDP_QUERY_PROG:
|
|
|
|
xdp->prog_id = tun_xdp_query(dev);
|
|
|
|
xdp->prog_attached = !!xdp->prog_id;
|
|
|
|
return 0;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-19 23:10:37 -07:00
|
|
|
static const struct net_device_ops tun_netdev_ops = {
|
2009-01-20 04:07:17 -07:00
|
|
|
.ndo_uninit = tun_net_uninit,
|
2008-11-19 23:10:37 -07:00
|
|
|
.ndo_open = tun_net_open,
|
|
|
|
.ndo_stop = tun_net_close,
|
2008-11-20 21:14:53 -07:00
|
|
|
.ndo_start_xmit = tun_net_xmit,
|
2011-04-19 00:13:10 -06:00
|
|
|
.ndo_fix_features = tun_net_fix_features,
|
2012-10-31 13:46:00 -06:00
|
|
|
.ndo_select_queue = tun_select_queue,
|
2011-06-14 23:25:01 -06:00
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
|
|
.ndo_poll_controller = tun_poll_controller,
|
|
|
|
#endif
|
2016-02-26 02:45:40 -07:00
|
|
|
.ndo_set_rx_headroom = tun_set_headroom,
|
2016-04-13 02:52:20 -06:00
|
|
|
.ndo_get_stats64 = tun_net_get_stats64,
|
2008-11-19 23:10:37 -07:00
|
|
|
};
|
|
|
|
|
2018-01-03 20:14:28 -07:00
|
|
|
static int tun_xdp_xmit(struct net_device *dev, struct xdp_buff *xdp)
|
|
|
|
{
|
|
|
|
struct tun_struct *tun = netdev_priv(dev);
|
|
|
|
struct xdp_buff *buff = xdp->data_hard_start;
|
|
|
|
int headroom = xdp->data - xdp->data_hard_start;
|
|
|
|
struct tun_file *tfile;
|
|
|
|
u32 numqueues;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
/* Assure headroom is available and buff is properly aligned */
|
|
|
|
if (unlikely(headroom < sizeof(*xdp) || tun_is_xdp_buff(xdp)))
|
|
|
|
return -ENOSPC;
|
|
|
|
|
|
|
|
*buff = *xdp;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
|
|
|
numqueues = READ_ONCE(tun->numqueues);
|
|
|
|
if (!numqueues) {
|
|
|
|
ret = -ENOSPC;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
tfile = rcu_dereference(tun->tfiles[smp_processor_id() %
|
|
|
|
numqueues]);
|
|
|
|
/* Encode the XDP flag into lowest bit for consumer to differ
|
|
|
|
* XDP buffer from sk_buff.
|
|
|
|
*/
|
|
|
|
if (ptr_ring_produce(&tfile->tx_ring, tun_xdp_to_ptr(buff))) {
|
|
|
|
this_cpu_inc(tun->pcpu_stats->tx_dropped);
|
|
|
|
ret = -ENOSPC;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
rcu_read_unlock();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tun_xdp_flush(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct tun_struct *tun = netdev_priv(dev);
|
|
|
|
struct tun_file *tfile;
|
|
|
|
u32 numqueues;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
|
|
|
numqueues = READ_ONCE(tun->numqueues);
|
|
|
|
if (!numqueues)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
tfile = rcu_dereference(tun->tfiles[smp_processor_id() %
|
|
|
|
numqueues]);
|
|
|
|
/* Notify and wake up reader process */
|
|
|
|
if (tfile->flags & TUN_FASYNC)
|
|
|
|
kill_fasync(&tfile->fasync, SIGIO, POLL_IN);
|
|
|
|
tfile->socket.sk->sk_data_ready(tfile->socket.sk);
|
|
|
|
|
|
|
|
out:
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
|
2008-11-19 23:10:37 -07:00
|
|
|
static const struct net_device_ops tap_netdev_ops = {
|
2009-01-20 04:07:17 -07:00
|
|
|
.ndo_uninit = tun_net_uninit,
|
2008-11-19 23:10:37 -07:00
|
|
|
.ndo_open = tun_net_open,
|
|
|
|
.ndo_stop = tun_net_close,
|
2008-11-20 21:14:53 -07:00
|
|
|
.ndo_start_xmit = tun_net_xmit,
|
2011-04-19 00:13:10 -06:00
|
|
|
.ndo_fix_features = tun_net_fix_features,
|
2011-08-16 00:29:01 -06:00
|
|
|
.ndo_set_rx_mode = tun_net_mclist,
|
2008-11-19 23:10:37 -07:00
|
|
|
.ndo_set_mac_address = eth_mac_addr,
|
|
|
|
.ndo_validate_addr = eth_validate_addr,
|
2012-10-31 13:46:00 -06:00
|
|
|
.ndo_select_queue = tun_select_queue,
|
2011-06-14 23:25:01 -06:00
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
|
|
.ndo_poll_controller = tun_poll_controller,
|
|
|
|
#endif
|
2015-07-31 00:03:27 -06:00
|
|
|
.ndo_features_check = passthru_features_check,
|
2016-02-26 02:45:40 -07:00
|
|
|
.ndo_set_rx_headroom = tun_set_headroom,
|
2016-04-13 02:52:20 -06:00
|
|
|
.ndo_get_stats64 = tun_net_get_stats64,
|
2017-11-03 14:56:16 -06:00
|
|
|
.ndo_bpf = tun_xdp,
|
2018-01-03 20:14:28 -07:00
|
|
|
.ndo_xdp_xmit = tun_xdp_xmit,
|
|
|
|
.ndo_xdp_flush = tun_xdp_flush,
|
2008-11-19 23:10:37 -07:00
|
|
|
};
|
|
|
|
|
2013-06-11 07:01:08 -06:00
|
|
|
static void tun_flow_init(struct tun_struct *tun)
|
2012-10-31 13:46:02 -06:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < TUN_NUM_FLOW_ENTRIES; i++)
|
|
|
|
INIT_HLIST_HEAD(&tun->flows[i]);
|
|
|
|
|
|
|
|
tun->ageing_time = TUN_FLOW_EXPIRE;
|
treewide: setup_timer() -> timer_setup()
This converts all remaining cases of the old setup_timer() API into using
timer_setup(), where the callback argument is the structure already
holding the struct timer_list. These should have no behavioral changes,
since they just change which pointer is passed into the callback with
the same available pointers after conversion. It handles the following
examples, in addition to some other variations.
Casting from unsigned long:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
setup_timer(&ptr->my_timer, my_callback, ptr);
and forced object casts:
void my_callback(struct something *ptr)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, (unsigned long)ptr);
become:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
Direct function assignments:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
ptr->my_timer.function = my_callback;
have a temporary cast added, along with converting the args:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
ptr->my_timer.function = (TIMER_FUNC_TYPE)my_callback;
And finally, callbacks without a data assignment:
void my_callback(unsigned long data)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, 0);
have their argument renamed to verify they're unused during conversion:
void my_callback(struct timer_list *unused)
{
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
The conversion is done with the following Coccinelle script:
spatch --very-quiet --all-includes --include-headers \
-I ./arch/x86/include -I ./arch/x86/include/generated \
-I ./include -I ./arch/x86/include/uapi \
-I ./arch/x86/include/generated/uapi -I ./include/uapi \
-I ./include/generated/uapi --include ./include/linux/kconfig.h \
--dir . \
--cocci-file ~/src/data/timer_setup.cocci
@fix_address_of@
expression e;
@@
setup_timer(
-&(e)
+&e
, ...)
// Update any raw setup_timer() usages that have a NULL callback, but
// would otherwise match change_timer_function_usage, since the latter
// will update all function assignments done in the face of a NULL
// function initialization in setup_timer().
@change_timer_function_usage_NULL@
expression _E;
identifier _timer;
type _cast_data;
@@
(
-setup_timer(&_E->_timer, NULL, _E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E->_timer, NULL, (_cast_data)_E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, &_E);
+timer_setup(&_E._timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, (_cast_data)&_E);
+timer_setup(&_E._timer, NULL, 0);
)
@change_timer_function_usage@
expression _E;
identifier _timer;
struct timer_list _stl;
identifier _callback;
type _cast_func, _cast_data;
@@
(
-setup_timer(&_E->_timer, _callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
_E->_timer@_stl.function = _callback;
|
_E->_timer@_stl.function = &_callback;
|
_E->_timer@_stl.function = (_cast_func)_callback;
|
_E->_timer@_stl.function = (_cast_func)&_callback;
|
_E._timer@_stl.function = _callback;
|
_E._timer@_stl.function = &_callback;
|
_E._timer@_stl.function = (_cast_func)_callback;
|
_E._timer@_stl.function = (_cast_func)&_callback;
)
// callback(unsigned long arg)
@change_callback_handle_cast
depends on change_timer_function_usage@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
identifier _handle;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
(
... when != _origarg
_handletype *_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
)
}
// callback(unsigned long arg) without existing variable
@change_callback_handle_cast_no_arg
depends on change_timer_function_usage &&
!change_callback_handle_cast@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
+ _handletype *_origarg = from_timer(_origarg, t, _timer);
+
... when != _origarg
- (_handletype *)_origarg
+ _origarg
... when != _origarg
}
// Avoid already converted callbacks.
@match_callback_converted
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier t;
@@
void _callback(struct timer_list *t)
{ ... }
// callback(struct something *handle)
@change_callback_handle_arg
depends on change_timer_function_usage &&
!match_callback_converted &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
@@
void _callback(
-_handletype *_handle
+struct timer_list *t
)
{
+ _handletype *_handle = from_timer(_handle, t, _timer);
...
}
// If change_callback_handle_arg ran on an empty function, remove
// the added handler.
@unchange_callback_handle_arg
depends on change_timer_function_usage &&
change_callback_handle_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
identifier t;
@@
void _callback(struct timer_list *t)
{
- _handletype *_handle = from_timer(_handle, t, _timer);
}
// We only want to refactor the setup_timer() data argument if we've found
// the matching callback. This undoes changes in change_timer_function_usage.
@unchange_timer_function_usage
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg &&
!change_callback_handle_arg@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type change_timer_function_usage._cast_data;
@@
(
-timer_setup(&_E->_timer, _callback, 0);
+setup_timer(&_E->_timer, _callback, (_cast_data)_E);
|
-timer_setup(&_E._timer, _callback, 0);
+setup_timer(&_E._timer, _callback, (_cast_data)&_E);
)
// If we fixed a callback from a .function assignment, fix the
// assignment cast now.
@change_timer_function_assignment
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_func;
typedef TIMER_FUNC_TYPE;
@@
(
_E->_timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-&_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
)
// Sometimes timer functions are called directly. Replace matched args.
@change_timer_function_calls
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression _E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_data;
@@
_callback(
(
-(_cast_data)_E
+&_E->_timer
|
-(_cast_data)&_E
+&_E._timer
|
-_E
+&_E->_timer
)
)
// If a timer has been configured without a data argument, it can be
// converted without regard to the callback argument, since it is unused.
@match_timer_function_unused_data@
expression _E;
identifier _timer;
identifier _callback;
@@
(
-setup_timer(&_E->_timer, _callback, 0);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0L);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0UL);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0L);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0UL);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0L);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0UL);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0L);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0UL);
+timer_setup(_timer, _callback, 0);
)
@change_callback_unused_data
depends on match_timer_function_unused_data@
identifier match_timer_function_unused_data._callback;
type _origtype;
identifier _origarg;
@@
void _callback(
-_origtype _origarg
+struct timer_list *unused
)
{
... when != _origarg
}
Signed-off-by: Kees Cook <keescook@chromium.org>
2017-10-16 15:43:17 -06:00
|
|
|
timer_setup(&tun->flow_gc_timer, tun_flow_cleanup, 0);
|
|
|
|
mod_timer(&tun->flow_gc_timer,
|
|
|
|
round_jiffies_up(jiffies + tun->ageing_time));
|
2012-10-31 13:46:02 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void tun_flow_uninit(struct tun_struct *tun)
|
|
|
|
{
|
|
|
|
del_timer_sync(&tun->flow_gc_timer);
|
|
|
|
tun_flow_flush(tun);
|
|
|
|
}
|
|
|
|
|
net: use core MTU range checking in core net infra
geneve:
- Merge __geneve_change_mtu back into geneve_change_mtu, set max_mtu
- This one isn't quite as straight-forward as others, could use some
closer inspection and testing
macvlan:
- set min/max_mtu
tun:
- set min/max_mtu, remove tun_net_change_mtu
vxlan:
- Merge __vxlan_change_mtu back into vxlan_change_mtu
- Set max_mtu to IP_MAX_MTU and retain dynamic MTU range checks in
change_mtu function
- This one is also not as straight-forward and could use closer inspection
and testing from vxlan folks
bridge:
- set max_mtu of IP_MAX_MTU and retain dynamic MTU range checks in
change_mtu function
openvswitch:
- set min/max_mtu, remove internal_dev_change_mtu
- note: max_mtu wasn't checked previously, it's been set to 65535, which
is the largest possible size supported
sch_teql:
- set min/max_mtu (note: max_mtu previously unchecked, used max of 65535)
macsec:
- min_mtu = 0, max_mtu = 65535
macvlan:
- min_mtu = 0, max_mtu = 65535
ntb_netdev:
- min_mtu = 0, max_mtu = 65535
veth:
- min_mtu = 68, max_mtu = 65535
8021q:
- min_mtu = 0, max_mtu = 65535
CC: netdev@vger.kernel.org
CC: Nicolas Dichtel <nicolas.dichtel@6wind.com>
CC: Hannes Frederic Sowa <hannes@stressinduktion.org>
CC: Tom Herbert <tom@herbertland.com>
CC: Daniel Borkmann <daniel@iogearbox.net>
CC: Alexander Duyck <alexander.h.duyck@intel.com>
CC: Paolo Abeni <pabeni@redhat.com>
CC: Jiri Benc <jbenc@redhat.com>
CC: WANG Cong <xiyou.wangcong@gmail.com>
CC: Roopa Prabhu <roopa@cumulusnetworks.com>
CC: Pravin B Shelar <pshelar@ovn.org>
CC: Sabrina Dubroca <sd@queasysnail.net>
CC: Patrick McHardy <kaber@trash.net>
CC: Stephen Hemminger <stephen@networkplumber.org>
CC: Pravin Shelar <pshelar@nicira.com>
CC: Maxim Krasnyansky <maxk@qti.qualcomm.com>
Signed-off-by: Jarod Wilson <jarod@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-10-20 11:55:20 -06:00
|
|
|
#define MIN_MTU 68
|
|
|
|
#define MAX_MTU 65535
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Initialize net device. */
|
|
|
|
static void tun_net_init(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct tun_struct *tun = netdev_priv(dev);
|
2006-09-13 11:24:59 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
switch (tun->flags & TUN_TYPE_MASK) {
|
2014-11-19 06:17:31 -07:00
|
|
|
case IFF_TUN:
|
2008-11-19 23:10:37 -07:00
|
|
|
dev->netdev_ops = &tun_netdev_ops;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Point-to-Point TUN Device */
|
|
|
|
dev->hard_header_len = 0;
|
|
|
|
dev->addr_len = 0;
|
|
|
|
dev->mtu = 1500;
|
|
|
|
|
|
|
|
/* Zero header length */
|
2006-09-13 11:24:59 -06:00
|
|
|
dev->type = ARPHRD_NONE;
|
2005-04-16 16:20:36 -06:00
|
|
|
dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
|
|
|
|
break;
|
|
|
|
|
2014-11-19 06:17:31 -07:00
|
|
|
case IFF_TAP:
|
2008-12-29 19:23:28 -07:00
|
|
|
dev->netdev_ops = &tap_netdev_ops;
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Ethernet TAP Device */
|
|
|
|
ether_setup(dev);
|
2011-07-26 00:05:38 -06:00
|
|
|
dev->priv_flags &= ~IFF_TX_SKB_SHARING;
|
2012-12-10 08:16:00 -07:00
|
|
|
dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
|
2007-04-26 02:00:55 -06:00
|
|
|
|
2012-02-14 23:45:39 -07:00
|
|
|
eth_hw_addr_random(dev);
|
2007-04-26 02:00:55 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
net: use core MTU range checking in core net infra
geneve:
- Merge __geneve_change_mtu back into geneve_change_mtu, set max_mtu
- This one isn't quite as straight-forward as others, could use some
closer inspection and testing
macvlan:
- set min/max_mtu
tun:
- set min/max_mtu, remove tun_net_change_mtu
vxlan:
- Merge __vxlan_change_mtu back into vxlan_change_mtu
- Set max_mtu to IP_MAX_MTU and retain dynamic MTU range checks in
change_mtu function
- This one is also not as straight-forward and could use closer inspection
and testing from vxlan folks
bridge:
- set max_mtu of IP_MAX_MTU and retain dynamic MTU range checks in
change_mtu function
openvswitch:
- set min/max_mtu, remove internal_dev_change_mtu
- note: max_mtu wasn't checked previously, it's been set to 65535, which
is the largest possible size supported
sch_teql:
- set min/max_mtu (note: max_mtu previously unchecked, used max of 65535)
macsec:
- min_mtu = 0, max_mtu = 65535
macvlan:
- min_mtu = 0, max_mtu = 65535
ntb_netdev:
- min_mtu = 0, max_mtu = 65535
veth:
- min_mtu = 68, max_mtu = 65535
8021q:
- min_mtu = 0, max_mtu = 65535
CC: netdev@vger.kernel.org
CC: Nicolas Dichtel <nicolas.dichtel@6wind.com>
CC: Hannes Frederic Sowa <hannes@stressinduktion.org>
CC: Tom Herbert <tom@herbertland.com>
CC: Daniel Borkmann <daniel@iogearbox.net>
CC: Alexander Duyck <alexander.h.duyck@intel.com>
CC: Paolo Abeni <pabeni@redhat.com>
CC: Jiri Benc <jbenc@redhat.com>
CC: WANG Cong <xiyou.wangcong@gmail.com>
CC: Roopa Prabhu <roopa@cumulusnetworks.com>
CC: Pravin B Shelar <pshelar@ovn.org>
CC: Sabrina Dubroca <sd@queasysnail.net>
CC: Patrick McHardy <kaber@trash.net>
CC: Stephen Hemminger <stephen@networkplumber.org>
CC: Pravin Shelar <pshelar@nicira.com>
CC: Maxim Krasnyansky <maxk@qti.qualcomm.com>
Signed-off-by: Jarod Wilson <jarod@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-10-20 11:55:20 -06:00
|
|
|
|
|
|
|
dev->min_mtu = MIN_MTU;
|
|
|
|
dev->max_mtu = MAX_MTU - dev->hard_header_len;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Character device part */
|
|
|
|
|
|
|
|
/* Poll */
|
2017-07-03 04:39:46 -06:00
|
|
|
static __poll_t tun_chr_poll(struct file *file, poll_table *wait)
|
2006-09-13 11:24:59 -06:00
|
|
|
{
|
2009-01-20 04:03:21 -07:00
|
|
|
struct tun_file *tfile = file->private_data;
|
2017-09-23 08:36:52 -06:00
|
|
|
struct tun_struct *tun = tun_get(tfile);
|
2009-07-05 13:48:35 -06:00
|
|
|
struct sock *sk;
|
2017-07-03 04:39:46 -06:00
|
|
|
__poll_t mask = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!tun)
|
2009-01-20 03:59:05 -07:00
|
|
|
return POLLERR;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-10-31 13:45:57 -06:00
|
|
|
sk = tfile->socket.sk;
|
2009-07-05 13:48:35 -06:00
|
|
|
|
2011-03-02 00:18:10 -07:00
|
|
|
tun_debug(KERN_INFO, tun, "tun_chr_poll\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-05-16 16:11:48 -06:00
|
|
|
poll_wait(file, sk_sleep(sk), wait);
|
2006-09-13 11:24:59 -06:00
|
|
|
|
2018-01-03 20:14:27 -07:00
|
|
|
if (!ptr_ring_empty(&tfile->tx_ring))
|
2005-04-16 16:20:36 -06:00
|
|
|
mask |= POLLIN | POLLRDNORM;
|
|
|
|
|
2017-03-12 17:00:26 -06:00
|
|
|
if (tun->dev->flags & IFF_UP &&
|
|
|
|
(sock_writeable(sk) ||
|
|
|
|
(!test_and_set_bit(SOCKWQ_ASYNC_NOSPACE, &sk->sk_socket->flags) &&
|
|
|
|
sock_writeable(sk))))
|
2009-02-05 22:25:32 -07:00
|
|
|
mask |= POLLOUT | POLLWRNORM;
|
|
|
|
|
2009-01-20 04:07:17 -07:00
|
|
|
if (tun->dev->reg_state != NETREG_REGISTERED)
|
|
|
|
mask = POLLERR;
|
|
|
|
|
2009-01-20 04:00:40 -07:00
|
|
|
tun_put(tun);
|
2005-04-16 16:20:36 -06:00
|
|
|
return mask;
|
|
|
|
}
|
|
|
|
|
2017-09-22 14:49:15 -06:00
|
|
|
static struct sk_buff *tun_napi_alloc_frags(struct tun_file *tfile,
|
|
|
|
size_t len,
|
|
|
|
const struct iov_iter *it)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
size_t linear;
|
|
|
|
int err;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (it->nr_segs > MAX_SKB_FRAGS + 1)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
local_bh_disable();
|
|
|
|
skb = napi_get_frags(&tfile->napi);
|
|
|
|
local_bh_enable();
|
|
|
|
if (!skb)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
linear = iov_iter_single_seg_count(it);
|
|
|
|
err = __skb_grow(skb, linear);
|
|
|
|
if (err)
|
|
|
|
goto free;
|
|
|
|
|
|
|
|
skb->len = len;
|
|
|
|
skb->data_len = len - linear;
|
|
|
|
skb->truesize += skb->data_len;
|
|
|
|
|
|
|
|
for (i = 1; i < it->nr_segs; i++) {
|
|
|
|
size_t fragsz = it->iov[i].iov_len;
|
|
|
|
unsigned long offset;
|
|
|
|
struct page *page;
|
|
|
|
void *data;
|
|
|
|
|
|
|
|
if (fragsz == 0 || fragsz > PAGE_SIZE) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto free;
|
|
|
|
}
|
|
|
|
|
|
|
|
local_bh_disable();
|
|
|
|
data = napi_alloc_frag(fragsz);
|
|
|
|
local_bh_enable();
|
|
|
|
if (!data) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto free;
|
|
|
|
}
|
|
|
|
|
|
|
|
page = virt_to_head_page(data);
|
|
|
|
offset = data - page_address(page);
|
|
|
|
skb_fill_page_desc(skb, i - 1, page, offset, fragsz);
|
|
|
|
}
|
|
|
|
|
|
|
|
return skb;
|
|
|
|
free:
|
|
|
|
/* frees skb and all frags allocated with napi_alloc_frag() */
|
|
|
|
napi_free_frags(&tfile->napi);
|
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
|
2008-08-15 16:15:10 -06:00
|
|
|
/* prepad is the amount to reserve at front. len is length after that.
|
|
|
|
* linear is a hint as to how much to copy (usually headers). */
|
2012-10-31 13:45:57 -06:00
|
|
|
static struct sk_buff *tun_alloc_skb(struct tun_file *tfile,
|
2011-06-08 08:33:08 -06:00
|
|
|
size_t prepad, size_t len,
|
|
|
|
size_t linear, int noblock)
|
2008-08-15 16:15:10 -06:00
|
|
|
{
|
2012-10-31 13:45:57 -06:00
|
|
|
struct sock *sk = tfile->socket.sk;
|
2008-08-15 16:15:10 -06:00
|
|
|
struct sk_buff *skb;
|
2009-02-05 22:25:32 -07:00
|
|
|
int err;
|
2008-08-15 16:15:10 -06:00
|
|
|
|
|
|
|
/* Under a page? Don't bother with paged skb. */
|
2009-04-14 03:09:43 -06:00
|
|
|
if (prepad + len < PAGE_SIZE || !linear)
|
2009-02-05 22:25:32 -07:00
|
|
|
linear = len;
|
2008-08-15 16:15:10 -06:00
|
|
|
|
2009-02-05 22:25:32 -07:00
|
|
|
skb = sock_alloc_send_pskb(sk, prepad + linear, len - linear, noblock,
|
2013-08-08 15:38:47 -06:00
|
|
|
&err, 0);
|
2008-08-15 16:15:10 -06:00
|
|
|
if (!skb)
|
2009-02-05 22:25:32 -07:00
|
|
|
return ERR_PTR(err);
|
2008-08-15 16:15:10 -06:00
|
|
|
|
|
|
|
skb_reserve(skb, prepad);
|
|
|
|
skb_put(skb, linear);
|
2009-02-05 22:25:32 -07:00
|
|
|
skb->data_len = len - linear;
|
|
|
|
skb->len += len - linear;
|
2008-08-15 16:15:10 -06:00
|
|
|
|
|
|
|
return skb;
|
|
|
|
}
|
|
|
|
|
2017-01-18 00:02:03 -07:00
|
|
|
static void tun_rx_batched(struct tun_struct *tun, struct tun_file *tfile,
|
|
|
|
struct sk_buff *skb, int more)
|
|
|
|
{
|
|
|
|
struct sk_buff_head *queue = &tfile->sk.sk_write_queue;
|
|
|
|
struct sk_buff_head process_queue;
|
|
|
|
u32 rx_batched = tun->rx_batched;
|
|
|
|
bool rcv = false;
|
|
|
|
|
|
|
|
if (!rx_batched || (!more && skb_queue_empty(queue))) {
|
|
|
|
local_bh_disable();
|
|
|
|
netif_receive_skb(skb);
|
|
|
|
local_bh_enable();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock(&queue->lock);
|
|
|
|
if (!more || skb_queue_len(queue) == rx_batched) {
|
|
|
|
__skb_queue_head_init(&process_queue);
|
|
|
|
skb_queue_splice_tail_init(queue, &process_queue);
|
|
|
|
rcv = true;
|
|
|
|
} else {
|
|
|
|
__skb_queue_tail(queue, skb);
|
|
|
|
}
|
|
|
|
spin_unlock(&queue->lock);
|
|
|
|
|
|
|
|
if (rcv) {
|
|
|
|
struct sk_buff *nskb;
|
|
|
|
|
|
|
|
local_bh_disable();
|
|
|
|
while ((nskb = __skb_dequeue(&process_queue)))
|
|
|
|
netif_receive_skb(nskb);
|
|
|
|
netif_receive_skb(skb);
|
|
|
|
local_bh_enable();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-11 05:41:16 -06:00
|
|
|
static bool tun_can_build_skb(struct tun_struct *tun, struct tun_file *tfile,
|
|
|
|
int len, int noblock, bool zerocopy)
|
|
|
|
{
|
|
|
|
if ((tun->flags & TUN_TYPE_MASK) != IFF_TAP)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (tfile->socket.sk->sk_sndbuf != INT_MAX)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!noblock)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (zerocopy)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (SKB_DATA_ALIGN(len + TUN_RX_PAD) +
|
|
|
|
SKB_DATA_ALIGN(sizeof(struct skb_shared_info)) > PAGE_SIZE)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-08-11 05:41:18 -06:00
|
|
|
static struct sk_buff *tun_build_skb(struct tun_struct *tun,
|
|
|
|
struct tun_file *tfile,
|
2017-08-11 05:41:16 -06:00
|
|
|
struct iov_iter *from,
|
2017-08-11 05:41:18 -06:00
|
|
|
struct virtio_net_hdr *hdr,
|
2017-09-03 21:36:09 -06:00
|
|
|
int len, int *skb_xdp)
|
2017-08-11 05:41:16 -06:00
|
|
|
{
|
2017-08-16 08:14:33 -06:00
|
|
|
struct page_frag *alloc_frag = ¤t->task_frag;
|
2017-08-11 05:41:16 -06:00
|
|
|
struct sk_buff *skb;
|
2017-08-11 05:41:18 -06:00
|
|
|
struct bpf_prog *xdp_prog;
|
2017-09-03 21:36:08 -06:00
|
|
|
int buflen = SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
|
2017-08-11 05:41:18 -06:00
|
|
|
unsigned int delta = 0;
|
2017-08-11 05:41:16 -06:00
|
|
|
char *buf;
|
|
|
|
size_t copied;
|
2017-08-11 05:41:18 -06:00
|
|
|
bool xdp_xmit = false;
|
2017-09-03 21:36:08 -06:00
|
|
|
int err, pad = TUN_RX_PAD;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
xdp_prog = rcu_dereference(tun->xdp_prog);
|
|
|
|
if (xdp_prog)
|
|
|
|
pad += TUN_HEADROOM;
|
|
|
|
buflen += SKB_DATA_ALIGN(len + pad);
|
|
|
|
rcu_read_unlock();
|
2017-08-11 05:41:16 -06:00
|
|
|
|
2017-10-26 21:05:44 -06:00
|
|
|
alloc_frag->offset = ALIGN((u64)alloc_frag->offset, SMP_CACHE_BYTES);
|
2017-08-11 05:41:16 -06:00
|
|
|
if (unlikely(!skb_page_frag_refill(buflen, alloc_frag, GFP_KERNEL)))
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
buf = (char *)page_address(alloc_frag->page) + alloc_frag->offset;
|
|
|
|
copied = copy_page_from_iter(alloc_frag->page,
|
2017-09-03 21:36:08 -06:00
|
|
|
alloc_frag->offset + pad,
|
2017-08-11 05:41:16 -06:00
|
|
|
len, from);
|
|
|
|
if (copied != len)
|
|
|
|
return ERR_PTR(-EFAULT);
|
|
|
|
|
2017-09-03 21:36:08 -06:00
|
|
|
/* There's a small window that XDP may be set after the check
|
|
|
|
* of xdp_prog above, this should be rare and for simplicity
|
|
|
|
* we do XDP on skb in case the headroom is not enough.
|
|
|
|
*/
|
|
|
|
if (hdr->gso_type || !xdp_prog)
|
2017-09-03 21:36:09 -06:00
|
|
|
*skb_xdp = 1;
|
2017-08-11 05:41:18 -06:00
|
|
|
else
|
2017-09-03 21:36:09 -06:00
|
|
|
*skb_xdp = 0;
|
2017-08-11 05:41:18 -06:00
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
xdp_prog = rcu_dereference(tun->xdp_prog);
|
2017-09-03 21:36:09 -06:00
|
|
|
if (xdp_prog && !*skb_xdp) {
|
2017-08-11 05:41:18 -06:00
|
|
|
struct xdp_buff xdp;
|
|
|
|
void *orig_data;
|
|
|
|
u32 act;
|
|
|
|
|
|
|
|
xdp.data_hard_start = buf;
|
2017-09-03 21:36:08 -06:00
|
|
|
xdp.data = buf + pad;
|
bpf: add meta pointer for direct access
This work enables generic transfer of metadata from XDP into skb. The
basic idea is that we can make use of the fact that the resulting skb
must be linear and already comes with a larger headroom for supporting
bpf_xdp_adjust_head(), which mangles xdp->data. Here, we base our work
on a similar principle and introduce a small helper bpf_xdp_adjust_meta()
for adjusting a new pointer called xdp->data_meta. Thus, the packet has
a flexible and programmable room for meta data, followed by the actual
packet data. struct xdp_buff is therefore laid out that we first point
to data_hard_start, then data_meta directly prepended to data followed
by data_end marking the end of packet. bpf_xdp_adjust_head() takes into
account whether we have meta data already prepended and if so, memmove()s
this along with the given offset provided there's enough room.
xdp->data_meta is optional and programs are not required to use it. The
rationale is that when we process the packet in XDP (e.g. as DoS filter),
we can push further meta data along with it for the XDP_PASS case, and
give the guarantee that a clsact ingress BPF program on the same device
can pick this up for further post-processing. Since we work with skb
there, we can also set skb->mark, skb->priority or other skb meta data
out of BPF, thus having this scratch space generic and programmable
allows for more flexibility than defining a direct 1:1 transfer of
potentially new XDP members into skb (it's also more efficient as we
don't need to initialize/handle each of such new members). The facility
also works together with GRO aggregation. The scratch space at the head
of the packet can be multiple of 4 byte up to 32 byte large. Drivers not
yet supporting xdp->data_meta can simply be set up with xdp->data_meta
as xdp->data + 1 as bpf_xdp_adjust_meta() will detect this and bail out,
such that the subsequent match against xdp->data for later access is
guaranteed to fail.
The verifier treats xdp->data_meta/xdp->data the same way as we treat
xdp->data/xdp->data_end pointer comparisons. The requirement for doing
the compare against xdp->data is that it hasn't been modified from it's
original address we got from ctx access. It may have a range marking
already from prior successful xdp->data/xdp->data_end pointer comparisons
though.
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Acked-by: Alexei Starovoitov <ast@kernel.org>
Acked-by: John Fastabend <john.fastabend@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-24 18:25:51 -06:00
|
|
|
xdp_set_data_meta_invalid(&xdp);
|
2017-08-11 05:41:18 -06:00
|
|
|
xdp.data_end = xdp.data + len;
|
2018-01-03 03:25:59 -07:00
|
|
|
xdp.rxq = &tfile->xdp_rxq;
|
2017-08-11 05:41:18 -06:00
|
|
|
orig_data = xdp.data;
|
|
|
|
act = bpf_prog_run_xdp(xdp_prog, &xdp);
|
|
|
|
|
|
|
|
switch (act) {
|
|
|
|
case XDP_REDIRECT:
|
|
|
|
get_page(alloc_frag->page);
|
|
|
|
alloc_frag->offset += buflen;
|
|
|
|
err = xdp_do_redirect(tun->dev, &xdp, xdp_prog);
|
|
|
|
if (err)
|
|
|
|
goto err_redirect;
|
2017-11-19 04:31:04 -07:00
|
|
|
rcu_read_unlock();
|
2017-08-11 05:41:18 -06:00
|
|
|
return NULL;
|
|
|
|
case XDP_TX:
|
|
|
|
xdp_xmit = true;
|
|
|
|
/* fall through */
|
|
|
|
case XDP_PASS:
|
|
|
|
delta = orig_data - xdp.data;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
bpf_warn_invalid_xdp_action(act);
|
|
|
|
/* fall through */
|
|
|
|
case XDP_ABORTED:
|
|
|
|
trace_xdp_exception(tun->dev, xdp_prog, act);
|
|
|
|
/* fall through */
|
|
|
|
case XDP_DROP:
|
|
|
|
goto err_xdp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-11 05:41:16 -06:00
|
|
|
skb = build_skb(buf, buflen);
|
2017-08-11 05:41:18 -06:00
|
|
|
if (!skb) {
|
|
|
|
rcu_read_unlock();
|
2017-08-11 05:41:16 -06:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2017-08-11 05:41:18 -06:00
|
|
|
}
|
2017-08-11 05:41:16 -06:00
|
|
|
|
2017-09-03 21:36:08 -06:00
|
|
|
skb_reserve(skb, pad - delta);
|
2017-08-11 05:41:18 -06:00
|
|
|
skb_put(skb, len + delta);
|
2017-08-11 05:41:16 -06:00
|
|
|
get_page(alloc_frag->page);
|
|
|
|
alloc_frag->offset += buflen;
|
|
|
|
|
2017-08-11 05:41:18 -06:00
|
|
|
if (xdp_xmit) {
|
|
|
|
skb->dev = tun->dev;
|
|
|
|
generic_xdp_tx(skb, xdp_prog);
|
2017-11-19 04:31:04 -07:00
|
|
|
rcu_read_unlock();
|
2017-08-11 05:41:18 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
2017-08-11 05:41:16 -06:00
|
|
|
return skb;
|
2017-08-11 05:41:18 -06:00
|
|
|
|
|
|
|
err_redirect:
|
|
|
|
put_page(alloc_frag->page);
|
|
|
|
err_xdp:
|
|
|
|
rcu_read_unlock();
|
|
|
|
this_cpu_inc(tun->pcpu_stats->rx_dropped);
|
|
|
|
return NULL;
|
2017-08-11 05:41:16 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Get packet from user space buffer */
|
2012-10-31 13:45:57 -06:00
|
|
|
static ssize_t tun_get_user(struct tun_struct *tun, struct tun_file *tfile,
|
2014-06-19 13:36:49 -06:00
|
|
|
void *msg_control, struct iov_iter *from,
|
2017-01-18 00:02:03 -07:00
|
|
|
int noblock, bool more)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-02-01 01:45:17 -07:00
|
|
|
struct tun_pi pi = { 0, cpu_to_be16(ETH_P_IP) };
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sk_buff *skb;
|
2014-06-19 13:36:49 -06:00
|
|
|
size_t total_len = iov_iter_count(from);
|
2016-02-26 02:45:40 -07:00
|
|
|
size_t len = total_len, align = tun->align, linear;
|
2008-07-03 04:48:02 -06:00
|
|
|
struct virtio_net_hdr gso = { 0 };
|
2016-04-13 02:52:20 -06:00
|
|
|
struct tun_pcpu_stats *stats;
|
2013-11-12 23:00:39 -07:00
|
|
|
int good_linear;
|
2012-07-20 03:23:23 -06:00
|
|
|
int copylen;
|
|
|
|
bool zerocopy = false;
|
|
|
|
int err;
|
2017-12-04 02:31:23 -07:00
|
|
|
u32 rxhash = 0;
|
2017-09-03 21:36:09 -06:00
|
|
|
int skb_xdp = 1;
|
2017-09-22 14:49:15 -06:00
|
|
|
bool frags = tun_napi_frags_enabled(tun);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-12-16 09:57:37 -07:00
|
|
|
if (!(tun->dev->flags & IFF_UP))
|
|
|
|
return -EIO;
|
|
|
|
|
2014-11-19 06:17:31 -07:00
|
|
|
if (!(tun->flags & IFF_NO_PI)) {
|
2013-08-15 06:52:57 -06:00
|
|
|
if (len < sizeof(pi))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
2013-08-15 06:52:57 -06:00
|
|
|
len -= sizeof(pi);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-11-01 20:09:04 -06:00
|
|
|
if (!copy_from_iter_full(&pi, sizeof(pi), from))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
|
2014-11-19 06:17:31 -07:00
|
|
|
if (tun->flags & IFF_VNET_HDR) {
|
2017-02-03 16:20:48 -07:00
|
|
|
int vnet_hdr_sz = READ_ONCE(tun->vnet_hdr_sz);
|
|
|
|
|
|
|
|
if (len < vnet_hdr_sz)
|
2008-07-03 04:48:02 -06:00
|
|
|
return -EINVAL;
|
2017-02-03 16:20:48 -07:00
|
|
|
len -= vnet_hdr_sz;
|
2008-07-03 04:48:02 -06:00
|
|
|
|
2016-11-01 20:09:04 -06:00
|
|
|
if (!copy_from_iter_full(&gso, sizeof(gso), from))
|
2008-07-03 04:48:02 -06:00
|
|
|
return -EFAULT;
|
|
|
|
|
2009-06-08 01:20:01 -06:00
|
|
|
if ((gso.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) &&
|
2014-10-23 13:59:31 -06:00
|
|
|
tun16_to_cpu(tun, gso.csum_start) + tun16_to_cpu(tun, gso.csum_offset) + 2 > tun16_to_cpu(tun, gso.hdr_len))
|
|
|
|
gso.hdr_len = cpu_to_tun16(tun, tun16_to_cpu(tun, gso.csum_start) + tun16_to_cpu(tun, gso.csum_offset) + 2);
|
2009-06-08 01:20:01 -06:00
|
|
|
|
2014-10-23 13:59:31 -06:00
|
|
|
if (tun16_to_cpu(tun, gso.hdr_len) > len)
|
2008-07-03 04:48:02 -06:00
|
|
|
return -EINVAL;
|
2017-02-03 16:20:48 -07:00
|
|
|
iov_iter_advance(from, vnet_hdr_sz - sizeof(gso));
|
2008-07-03 04:48:02 -06:00
|
|
|
}
|
|
|
|
|
2014-11-19 06:17:31 -07:00
|
|
|
if ((tun->flags & TUN_TYPE_MASK) == IFF_TAP) {
|
2011-06-08 08:33:07 -06:00
|
|
|
align += NET_IP_ALIGN;
|
2009-04-14 03:09:43 -06:00
|
|
|
if (unlikely(len < ETH_HLEN ||
|
2014-10-23 13:59:31 -06:00
|
|
|
(gso.hdr_len && tun16_to_cpu(tun, gso.hdr_len) < ETH_HLEN)))
|
2008-04-12 19:49:30 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2006-09-13 11:24:59 -06:00
|
|
|
|
2013-11-12 23:00:39 -07:00
|
|
|
good_linear = SKB_MAX_HEAD(align);
|
|
|
|
|
2013-07-17 20:55:15 -06:00
|
|
|
if (msg_control) {
|
2014-06-19 13:36:49 -06:00
|
|
|
struct iov_iter i = *from;
|
|
|
|
|
2013-07-17 20:55:15 -06:00
|
|
|
/* There are 256 bytes to be copied in skb, so there is
|
|
|
|
* enough room for skb expand head in case it is used.
|
2012-07-20 03:23:23 -06:00
|
|
|
* The rest of the buffer is mapped from userspace.
|
|
|
|
*/
|
2014-10-23 13:59:31 -06:00
|
|
|
copylen = gso.hdr_len ? tun16_to_cpu(tun, gso.hdr_len) : GOODCOPY_LEN;
|
2013-11-12 23:00:39 -07:00
|
|
|
if (copylen > good_linear)
|
|
|
|
copylen = good_linear;
|
2013-07-09 23:43:27 -06:00
|
|
|
linear = copylen;
|
2014-06-19 13:36:49 -06:00
|
|
|
iov_iter_advance(&i, copylen);
|
|
|
|
if (iov_iter_npages(&i, INT_MAX) <= MAX_SKB_FRAGS)
|
2013-07-17 20:55:15 -06:00
|
|
|
zerocopy = true;
|
|
|
|
}
|
|
|
|
|
2017-09-22 14:49:15 -06:00
|
|
|
if (!frags && tun_can_build_skb(tun, tfile, len, noblock, zerocopy)) {
|
2017-09-03 21:36:09 -06:00
|
|
|
/* For the packet that is not easy to be processed
|
|
|
|
* (e.g gso or jumbo packet), we will do it at after
|
|
|
|
* skb was created with generic XDP routine.
|
|
|
|
*/
|
|
|
|
skb = tun_build_skb(tun, tfile, from, &gso, len, &skb_xdp);
|
2017-08-11 05:41:16 -06:00
|
|
|
if (IS_ERR(skb)) {
|
2016-04-13 02:52:20 -06:00
|
|
|
this_cpu_inc(tun->pcpu_stats->rx_dropped);
|
2017-08-11 05:41:16 -06:00
|
|
|
return PTR_ERR(skb);
|
|
|
|
}
|
2017-08-11 05:41:18 -06:00
|
|
|
if (!skb)
|
|
|
|
return total_len;
|
2017-08-11 05:41:16 -06:00
|
|
|
} else {
|
|
|
|
if (!zerocopy) {
|
|
|
|
copylen = len;
|
|
|
|
if (tun16_to_cpu(tun, gso.hdr_len) > good_linear)
|
|
|
|
linear = good_linear;
|
|
|
|
else
|
|
|
|
linear = tun16_to_cpu(tun, gso.hdr_len);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-09-22 14:49:15 -06:00
|
|
|
if (frags) {
|
|
|
|
mutex_lock(&tfile->napi_mutex);
|
|
|
|
skb = tun_napi_alloc_frags(tfile, copylen, from);
|
|
|
|
/* tun_napi_alloc_frags() enforces a layout for the skb.
|
|
|
|
* If zerocopy is enabled, then this layout will be
|
|
|
|
* overwritten by zerocopy_sg_from_iter().
|
|
|
|
*/
|
|
|
|
zerocopy = false;
|
|
|
|
} else {
|
|
|
|
skb = tun_alloc_skb(tfile, align, copylen, linear,
|
|
|
|
noblock);
|
|
|
|
}
|
|
|
|
|
2017-08-11 05:41:16 -06:00
|
|
|
if (IS_ERR(skb)) {
|
|
|
|
if (PTR_ERR(skb) != -EAGAIN)
|
|
|
|
this_cpu_inc(tun->pcpu_stats->rx_dropped);
|
2017-09-22 14:49:15 -06:00
|
|
|
if (frags)
|
|
|
|
mutex_unlock(&tfile->napi_mutex);
|
2017-08-11 05:41:16 -06:00
|
|
|
return PTR_ERR(skb);
|
|
|
|
}
|
2012-07-20 03:23:23 -06:00
|
|
|
|
2017-08-11 05:41:16 -06:00
|
|
|
if (zerocopy)
|
|
|
|
err = zerocopy_sg_from_iter(skb, from);
|
|
|
|
else
|
|
|
|
err = skb_copy_datagram_from_iter(skb, 0, from, len);
|
|
|
|
|
|
|
|
if (err) {
|
|
|
|
this_cpu_inc(tun->pcpu_stats->rx_dropped);
|
|
|
|
kfree_skb(skb);
|
2017-09-22 14:49:15 -06:00
|
|
|
if (frags) {
|
|
|
|
tfile->napi.skb = NULL;
|
|
|
|
mutex_unlock(&tfile->napi_mutex);
|
|
|
|
}
|
|
|
|
|
2017-08-11 05:41:16 -06:00
|
|
|
return -EFAULT;
|
|
|
|
}
|
2006-03-11 19:49:13 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-11-18 16:40:38 -07:00
|
|
|
if (virtio_net_hdr_to_skb(skb, &gso, tun_is_little_endian(tun))) {
|
2016-06-13 16:00:04 -06:00
|
|
|
this_cpu_inc(tun->pcpu_stats->rx_frame_errors);
|
|
|
|
kfree_skb(skb);
|
2017-09-22 14:49:15 -06:00
|
|
|
if (frags) {
|
|
|
|
tfile->napi.skb = NULL;
|
|
|
|
mutex_unlock(&tfile->napi_mutex);
|
|
|
|
}
|
|
|
|
|
2016-06-13 16:00:04 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
switch (tun->flags & TUN_TYPE_MASK) {
|
2014-11-19 06:17:31 -07:00
|
|
|
case IFF_TUN:
|
|
|
|
if (tun->flags & IFF_NO_PI) {
|
tun: bail out from tun_get_user() if the skb is empty
KMSAN (https://github.com/google/kmsan) reported accessing uninitialized
skb->data[0] in the case the skb is empty (i.e. skb->len is 0):
================================================
BUG: KMSAN: use of uninitialized memory in tun_get_user+0x19ba/0x3770
CPU: 0 PID: 3051 Comm: probe Not tainted 4.13.0+ #3140
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS Bochs 01/01/2011
Call Trace:
...
__msan_warning_32+0x66/0xb0 mm/kmsan/kmsan_instr.c:477
tun_get_user+0x19ba/0x3770 drivers/net/tun.c:1301
tun_chr_write_iter+0x19f/0x300 drivers/net/tun.c:1365
call_write_iter ./include/linux/fs.h:1743
new_sync_write fs/read_write.c:457
__vfs_write+0x6c3/0x7f0 fs/read_write.c:470
vfs_write+0x3e4/0x770 fs/read_write.c:518
SYSC_write+0x12f/0x2b0 fs/read_write.c:565
SyS_write+0x55/0x80 fs/read_write.c:557
do_syscall_64+0x242/0x330 arch/x86/entry/common.c:284
entry_SYSCALL64_slow_path+0x25/0x25 arch/x86/entry/entry_64.S:245
...
origin:
...
kmsan_poison_shadow+0x6e/0xc0 mm/kmsan/kmsan.c:211
slab_alloc_node mm/slub.c:2732
__kmalloc_node_track_caller+0x351/0x370 mm/slub.c:4351
__kmalloc_reserve net/core/skbuff.c:138
__alloc_skb+0x26a/0x810 net/core/skbuff.c:231
alloc_skb ./include/linux/skbuff.h:903
alloc_skb_with_frags+0x1d7/0xc80 net/core/skbuff.c:4756
sock_alloc_send_pskb+0xabf/0xfe0 net/core/sock.c:2037
tun_alloc_skb drivers/net/tun.c:1144
tun_get_user+0x9a8/0x3770 drivers/net/tun.c:1274
tun_chr_write_iter+0x19f/0x300 drivers/net/tun.c:1365
call_write_iter ./include/linux/fs.h:1743
new_sync_write fs/read_write.c:457
__vfs_write+0x6c3/0x7f0 fs/read_write.c:470
vfs_write+0x3e4/0x770 fs/read_write.c:518
SYSC_write+0x12f/0x2b0 fs/read_write.c:565
SyS_write+0x55/0x80 fs/read_write.c:557
do_syscall_64+0x242/0x330 arch/x86/entry/common.c:284
return_from_SYSCALL_64+0x0/0x6a arch/x86/entry/entry_64.S:245
================================================
Make sure tun_get_user() doesn't touch skb->data[0] unless there is
actual data.
C reproducer below:
==========================
// autogenerated by syzkaller (http://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <fcntl.h>
#include <linux/if_tun.h>
#include <netinet/ip.h>
#include <net/if.h>
#include <string.h>
#include <sys/ioctl.h>
int main()
{
int sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP);
int tun_fd = open("/dev/net/tun", O_RDWR);
struct ifreq req;
memset(&req, 0, sizeof(struct ifreq));
strcpy((char*)&req.ifr_name, "gre0");
req.ifr_flags = IFF_UP | IFF_MULTICAST;
ioctl(tun_fd, TUNSETIFF, &req);
ioctl(sock, SIOCSIFFLAGS, "gre0");
write(tun_fd, "hi", 0);
return 0;
}
==========================
Signed-off-by: Alexander Potapenko <glider@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-28 03:32:37 -06:00
|
|
|
u8 ip_version = skb->len ? (skb->data[0] >> 4) : 0;
|
|
|
|
|
|
|
|
switch (ip_version) {
|
|
|
|
case 4:
|
2008-06-17 22:10:33 -06:00
|
|
|
pi.proto = htons(ETH_P_IP);
|
|
|
|
break;
|
tun: bail out from tun_get_user() if the skb is empty
KMSAN (https://github.com/google/kmsan) reported accessing uninitialized
skb->data[0] in the case the skb is empty (i.e. skb->len is 0):
================================================
BUG: KMSAN: use of uninitialized memory in tun_get_user+0x19ba/0x3770
CPU: 0 PID: 3051 Comm: probe Not tainted 4.13.0+ #3140
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS Bochs 01/01/2011
Call Trace:
...
__msan_warning_32+0x66/0xb0 mm/kmsan/kmsan_instr.c:477
tun_get_user+0x19ba/0x3770 drivers/net/tun.c:1301
tun_chr_write_iter+0x19f/0x300 drivers/net/tun.c:1365
call_write_iter ./include/linux/fs.h:1743
new_sync_write fs/read_write.c:457
__vfs_write+0x6c3/0x7f0 fs/read_write.c:470
vfs_write+0x3e4/0x770 fs/read_write.c:518
SYSC_write+0x12f/0x2b0 fs/read_write.c:565
SyS_write+0x55/0x80 fs/read_write.c:557
do_syscall_64+0x242/0x330 arch/x86/entry/common.c:284
entry_SYSCALL64_slow_path+0x25/0x25 arch/x86/entry/entry_64.S:245
...
origin:
...
kmsan_poison_shadow+0x6e/0xc0 mm/kmsan/kmsan.c:211
slab_alloc_node mm/slub.c:2732
__kmalloc_node_track_caller+0x351/0x370 mm/slub.c:4351
__kmalloc_reserve net/core/skbuff.c:138
__alloc_skb+0x26a/0x810 net/core/skbuff.c:231
alloc_skb ./include/linux/skbuff.h:903
alloc_skb_with_frags+0x1d7/0xc80 net/core/skbuff.c:4756
sock_alloc_send_pskb+0xabf/0xfe0 net/core/sock.c:2037
tun_alloc_skb drivers/net/tun.c:1144
tun_get_user+0x9a8/0x3770 drivers/net/tun.c:1274
tun_chr_write_iter+0x19f/0x300 drivers/net/tun.c:1365
call_write_iter ./include/linux/fs.h:1743
new_sync_write fs/read_write.c:457
__vfs_write+0x6c3/0x7f0 fs/read_write.c:470
vfs_write+0x3e4/0x770 fs/read_write.c:518
SYSC_write+0x12f/0x2b0 fs/read_write.c:565
SyS_write+0x55/0x80 fs/read_write.c:557
do_syscall_64+0x242/0x330 arch/x86/entry/common.c:284
return_from_SYSCALL_64+0x0/0x6a arch/x86/entry/entry_64.S:245
================================================
Make sure tun_get_user() doesn't touch skb->data[0] unless there is
actual data.
C reproducer below:
==========================
// autogenerated by syzkaller (http://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <fcntl.h>
#include <linux/if_tun.h>
#include <netinet/ip.h>
#include <net/if.h>
#include <string.h>
#include <sys/ioctl.h>
int main()
{
int sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP);
int tun_fd = open("/dev/net/tun", O_RDWR);
struct ifreq req;
memset(&req, 0, sizeof(struct ifreq));
strcpy((char*)&req.ifr_name, "gre0");
req.ifr_flags = IFF_UP | IFF_MULTICAST;
ioctl(tun_fd, TUNSETIFF, &req);
ioctl(sock, SIOCSIFFLAGS, "gre0");
write(tun_fd, "hi", 0);
return 0;
}
==========================
Signed-off-by: Alexander Potapenko <glider@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-28 03:32:37 -06:00
|
|
|
case 6:
|
2008-06-17 22:10:33 -06:00
|
|
|
pi.proto = htons(ETH_P_IPV6);
|
|
|
|
break;
|
|
|
|
default:
|
2016-04-13 02:52:20 -06:00
|
|
|
this_cpu_inc(tun->pcpu_stats->rx_dropped);
|
2008-06-17 22:10:33 -06:00
|
|
|
kfree_skb(skb);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-03-19 16:30:44 -06:00
|
|
|
skb_reset_mac_header(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
skb->protocol = pi.proto;
|
2007-04-25 18:40:23 -06:00
|
|
|
skb->dev = tun->dev;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2014-11-19 06:17:31 -07:00
|
|
|
case IFF_TAP:
|
2017-09-22 14:49:15 -06:00
|
|
|
if (!frags)
|
|
|
|
skb->protocol = eth_type_trans(skb, tun->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2011-06-03 05:51:20 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-07-20 03:23:23 -06:00
|
|
|
/* copy skb_ubuf_info for callback when skb has no error */
|
|
|
|
if (zerocopy) {
|
|
|
|
skb_shinfo(skb)->destructor_arg = msg_control;
|
|
|
|
skb_shinfo(skb)->tx_flags |= SKBTX_DEV_ZEROCOPY;
|
2013-02-11 02:27:41 -07:00
|
|
|
skb_shinfo(skb)->tx_flags |= SKBTX_SHARED_FRAG;
|
2016-11-29 22:17:51 -07:00
|
|
|
} else if (msg_control) {
|
|
|
|
struct ubuf_info *uarg = msg_control;
|
|
|
|
uarg->callback(uarg, false);
|
2012-07-20 03:23:23 -06:00
|
|
|
}
|
|
|
|
|
2015-02-03 14:36:16 -07:00
|
|
|
skb_reset_network_header(skb);
|
2013-03-26 17:11:22 -06:00
|
|
|
skb_probe_transport_header(skb, 0);
|
2013-03-25 14:19:56 -06:00
|
|
|
|
2017-09-03 21:36:09 -06:00
|
|
|
if (skb_xdp) {
|
2017-08-11 05:41:18 -06:00
|
|
|
struct bpf_prog *xdp_prog;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
xdp_prog = rcu_dereference(tun->xdp_prog);
|
|
|
|
if (xdp_prog) {
|
|
|
|
ret = do_xdp_generic(xdp_prog, skb);
|
|
|
|
if (ret != XDP_PASS) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return total_len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
|
2017-12-04 02:31:23 -07:00
|
|
|
rcu_read_lock();
|
|
|
|
if (!rcu_dereference(tun->steering_prog))
|
|
|
|
rxhash = __skb_get_hash_symmetric(skb);
|
|
|
|
rcu_read_unlock();
|
2017-09-22 14:49:14 -06:00
|
|
|
|
2017-09-22 14:49:15 -06:00
|
|
|
if (frags) {
|
|
|
|
/* Exercise flow dissector code path. */
|
|
|
|
u32 headlen = eth_get_headlen(skb->data, skb_headlen(skb));
|
|
|
|
|
2017-10-17 11:07:44 -06:00
|
|
|
if (unlikely(headlen > skb_headlen(skb))) {
|
2017-09-22 14:49:15 -06:00
|
|
|
this_cpu_inc(tun->pcpu_stats->rx_dropped);
|
|
|
|
napi_free_frags(&tfile->napi);
|
|
|
|
mutex_unlock(&tfile->napi_mutex);
|
|
|
|
WARN_ON(1);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
local_bh_disable();
|
|
|
|
napi_gro_frags(&tfile->napi);
|
|
|
|
local_bh_enable();
|
|
|
|
mutex_unlock(&tfile->napi_mutex);
|
2017-10-18 13:12:09 -06:00
|
|
|
} else if (tfile->napi_enabled) {
|
2017-09-22 14:49:14 -06:00
|
|
|
struct sk_buff_head *queue = &tfile->sk.sk_write_queue;
|
|
|
|
int queue_len;
|
|
|
|
|
|
|
|
spin_lock_bh(&queue->lock);
|
|
|
|
__skb_queue_tail(queue, skb);
|
|
|
|
queue_len = skb_queue_len(queue);
|
|
|
|
spin_unlock(&queue->lock);
|
|
|
|
|
|
|
|
if (!more || queue_len > NAPI_POLL_WEIGHT)
|
|
|
|
napi_schedule(&tfile->napi);
|
|
|
|
|
|
|
|
local_bh_enable();
|
|
|
|
} else if (!IS_ENABLED(CONFIG_4KSTACKS)) {
|
|
|
|
tun_rx_batched(tun, tfile, skb, more);
|
|
|
|
} else {
|
|
|
|
netif_rx_ni(skb);
|
|
|
|
}
|
2006-09-13 11:24:59 -06:00
|
|
|
|
2016-04-13 02:52:20 -06:00
|
|
|
stats = get_cpu_ptr(tun->pcpu_stats);
|
|
|
|
u64_stats_update_begin(&stats->syncp);
|
|
|
|
stats->rx_packets++;
|
|
|
|
stats->rx_bytes += len;
|
|
|
|
u64_stats_update_end(&stats->syncp);
|
|
|
|
put_cpu_ptr(stats);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-12-04 02:31:23 -07:00
|
|
|
if (rxhash)
|
|
|
|
tun_flow_update(tun, rxhash, tfile);
|
|
|
|
|
2012-07-20 03:23:23 -06:00
|
|
|
return total_len;
|
2006-09-13 11:24:59 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-06-19 13:36:49 -06:00
|
|
|
static ssize_t tun_chr_write_iter(struct kiocb *iocb, struct iov_iter *from)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-02-05 22:25:32 -07:00
|
|
|
struct file *file = iocb->ki_filp;
|
2012-10-31 13:45:57 -06:00
|
|
|
struct tun_file *tfile = file->private_data;
|
2017-09-23 08:36:52 -06:00
|
|
|
struct tun_struct *tun = tun_get(tfile);
|
2009-01-20 04:00:40 -07:00
|
|
|
ssize_t result;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!tun)
|
|
|
|
return -EBADFD;
|
|
|
|
|
2017-01-18 00:02:03 -07:00
|
|
|
result = tun_get_user(tun, tfile, NULL, from,
|
|
|
|
file->f_flags & O_NONBLOCK, false);
|
2009-01-20 04:00:40 -07:00
|
|
|
|
|
|
|
tun_put(tun);
|
|
|
|
return result;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2018-01-03 20:14:28 -07:00
|
|
|
static ssize_t tun_put_user_xdp(struct tun_struct *tun,
|
|
|
|
struct tun_file *tfile,
|
|
|
|
struct xdp_buff *xdp,
|
|
|
|
struct iov_iter *iter)
|
|
|
|
{
|
|
|
|
int vnet_hdr_sz = 0;
|
|
|
|
size_t size = xdp->data_end - xdp->data;
|
|
|
|
struct tun_pcpu_stats *stats;
|
|
|
|
size_t ret;
|
|
|
|
|
|
|
|
if (tun->flags & IFF_VNET_HDR) {
|
|
|
|
struct virtio_net_hdr gso = { 0 };
|
|
|
|
|
|
|
|
vnet_hdr_sz = READ_ONCE(tun->vnet_hdr_sz);
|
|
|
|
if (unlikely(iov_iter_count(iter) < vnet_hdr_sz))
|
|
|
|
return -EINVAL;
|
|
|
|
if (unlikely(copy_to_iter(&gso, sizeof(gso), iter) !=
|
|
|
|
sizeof(gso)))
|
|
|
|
return -EFAULT;
|
|
|
|
iov_iter_advance(iter, vnet_hdr_sz - sizeof(gso));
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = copy_to_iter(xdp->data, size, iter) + vnet_hdr_sz;
|
|
|
|
|
|
|
|
stats = get_cpu_ptr(tun->pcpu_stats);
|
|
|
|
u64_stats_update_begin(&stats->syncp);
|
|
|
|
stats->tx_packets++;
|
|
|
|
stats->tx_bytes += ret;
|
|
|
|
u64_stats_update_end(&stats->syncp);
|
|
|
|
put_cpu_ptr(tun->pcpu_stats);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Put packet to the user space buffer */
|
2011-06-08 08:33:08 -06:00
|
|
|
static ssize_t tun_put_user(struct tun_struct *tun,
|
2012-10-31 13:45:57 -06:00
|
|
|
struct tun_file *tfile,
|
2011-06-08 08:33:08 -06:00
|
|
|
struct sk_buff *skb,
|
2014-11-07 06:22:23 -07:00
|
|
|
struct iov_iter *iter)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct tun_pi pi = { 0, skb->protocol };
|
2016-04-13 02:52:20 -06:00
|
|
|
struct tun_pcpu_stats *stats;
|
2014-11-07 06:22:23 -07:00
|
|
|
ssize_t total;
|
2014-11-13 01:54:14 -07:00
|
|
|
int vlan_offset = 0;
|
2014-11-02 13:30:13 -07:00
|
|
|
int vlan_hlen = 0;
|
2014-11-02 13:30:14 -07:00
|
|
|
int vnet_hdr_sz = 0;
|
2014-11-02 13:30:13 -07:00
|
|
|
|
2015-01-13 09:13:44 -07:00
|
|
|
if (skb_vlan_tag_present(skb))
|
2014-11-02 13:30:13 -07:00
|
|
|
vlan_hlen = VLAN_HLEN;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-11-19 06:17:31 -07:00
|
|
|
if (tun->flags & IFF_VNET_HDR)
|
2017-02-03 16:20:48 -07:00
|
|
|
vnet_hdr_sz = READ_ONCE(tun->vnet_hdr_sz);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-11-07 06:22:23 -07:00
|
|
|
total = skb->len + vlan_hlen + vnet_hdr_sz;
|
|
|
|
|
2014-11-19 06:17:31 -07:00
|
|
|
if (!(tun->flags & IFF_NO_PI)) {
|
2014-11-07 06:22:23 -07:00
|
|
|
if (iov_iter_count(iter) < sizeof(pi))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2014-11-07 06:22:23 -07:00
|
|
|
total += sizeof(pi);
|
|
|
|
if (iov_iter_count(iter) < total) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Packet will be striped */
|
|
|
|
pi.flags |= TUN_PKT_STRIP;
|
|
|
|
}
|
2006-09-13 11:24:59 -06:00
|
|
|
|
2014-11-07 06:22:23 -07:00
|
|
|
if (copy_to_iter(&pi, sizeof(pi), iter) != sizeof(pi))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EFAULT;
|
2006-09-13 11:24:59 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-11-02 13:30:14 -07:00
|
|
|
if (vnet_hdr_sz) {
|
2016-11-18 16:40:40 -07:00
|
|
|
struct virtio_net_hdr gso;
|
2016-06-08 07:09:20 -06:00
|
|
|
|
2014-11-07 06:22:23 -07:00
|
|
|
if (iov_iter_count(iter) < vnet_hdr_sz)
|
2008-07-03 04:48:02 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2016-11-18 16:40:38 -07:00
|
|
|
if (virtio_net_hdr_from_skb(skb, &gso,
|
2017-01-19 23:32:42 -07:00
|
|
|
tun_is_little_endian(tun), true)) {
|
2008-07-03 04:48:02 -06:00
|
|
|
struct skb_shared_info *sinfo = skb_shinfo(skb);
|
2016-06-08 07:09:20 -06:00
|
|
|
pr_err("unexpected GSO type: "
|
|
|
|
"0x%x, gso_size %d, hdr_len %d\n",
|
|
|
|
sinfo->gso_type, tun16_to_cpu(tun, gso.gso_size),
|
|
|
|
tun16_to_cpu(tun, gso.hdr_len));
|
|
|
|
print_hex_dump(KERN_ERR, "tun: ",
|
|
|
|
DUMP_PREFIX_NONE,
|
|
|
|
16, 1, skb->head,
|
|
|
|
min((int)tun16_to_cpu(tun, gso.hdr_len), 64), true);
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2008-07-03 04:48:02 -06:00
|
|
|
|
2014-11-07 06:22:23 -07:00
|
|
|
if (copy_to_iter(&gso, sizeof(gso), iter) != sizeof(gso))
|
2008-07-03 04:48:02 -06:00
|
|
|
return -EFAULT;
|
2014-11-13 01:54:14 -07:00
|
|
|
|
|
|
|
iov_iter_advance(iter, vnet_hdr_sz - sizeof(gso));
|
2008-07-03 04:48:02 -06:00
|
|
|
}
|
|
|
|
|
2014-11-02 13:30:13 -07:00
|
|
|
if (vlan_hlen) {
|
2014-11-07 06:22:23 -07:00
|
|
|
int ret;
|
2018-01-16 01:31:02 -07:00
|
|
|
struct veth veth;
|
2013-07-24 23:00:33 -06:00
|
|
|
|
|
|
|
veth.h_vlan_proto = skb->vlan_proto;
|
2015-01-13 09:13:44 -07:00
|
|
|
veth.h_vlan_TCI = htons(skb_vlan_tag_get(skb));
|
2013-07-24 23:00:33 -06:00
|
|
|
|
|
|
|
vlan_offset = offsetof(struct vlan_ethhdr, h_vlan_proto);
|
|
|
|
|
2014-11-07 06:22:23 -07:00
|
|
|
ret = skb_copy_datagram_iter(skb, 0, iter, vlan_offset);
|
|
|
|
if (ret || !iov_iter_count(iter))
|
2013-07-24 23:00:33 -06:00
|
|
|
goto done;
|
|
|
|
|
2014-11-07 06:22:23 -07:00
|
|
|
ret = copy_to_iter(&veth, sizeof(veth), iter);
|
|
|
|
if (ret != sizeof(veth) || !iov_iter_count(iter))
|
2013-07-24 23:00:33 -06:00
|
|
|
goto done;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-11-07 06:22:23 -07:00
|
|
|
skb_copy_datagram_iter(skb, vlan_offset, iter, skb->len - vlan_offset);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-07-24 23:00:33 -06:00
|
|
|
done:
|
2016-04-13 02:52:20 -06:00
|
|
|
/* caller is in process context, */
|
|
|
|
stats = get_cpu_ptr(tun->pcpu_stats);
|
|
|
|
u64_stats_update_begin(&stats->syncp);
|
|
|
|
stats->tx_packets++;
|
|
|
|
stats->tx_bytes += skb->len + vlan_hlen;
|
|
|
|
u64_stats_update_end(&stats->syncp);
|
|
|
|
put_cpu_ptr(tun->pcpu_stats);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return total;
|
|
|
|
}
|
|
|
|
|
2018-01-03 20:14:28 -07:00
|
|
|
static void *tun_ring_recv(struct tun_file *tfile, int noblock, int *err)
|
2016-06-30 00:45:36 -06:00
|
|
|
{
|
|
|
|
DECLARE_WAITQUEUE(wait, current);
|
2018-01-03 20:14:28 -07:00
|
|
|
void *ptr = NULL;
|
2016-07-03 23:53:38 -06:00
|
|
|
int error = 0;
|
2016-06-30 00:45:36 -06:00
|
|
|
|
2018-01-03 20:14:28 -07:00
|
|
|
ptr = ptr_ring_consume(&tfile->tx_ring);
|
|
|
|
if (ptr)
|
2016-06-30 00:45:36 -06:00
|
|
|
goto out;
|
|
|
|
if (noblock) {
|
2016-07-03 23:53:38 -06:00
|
|
|
error = -EAGAIN;
|
2016-06-30 00:45:36 -06:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
add_wait_queue(&tfile->wq.wait, &wait);
|
|
|
|
current->state = TASK_INTERRUPTIBLE;
|
|
|
|
|
|
|
|
while (1) {
|
2018-01-03 20:14:28 -07:00
|
|
|
ptr = ptr_ring_consume(&tfile->tx_ring);
|
|
|
|
if (ptr)
|
2016-06-30 00:45:36 -06:00
|
|
|
break;
|
|
|
|
if (signal_pending(current)) {
|
2016-07-03 23:53:38 -06:00
|
|
|
error = -ERESTARTSYS;
|
2016-06-30 00:45:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (tfile->socket.sk->sk_shutdown & RCV_SHUTDOWN) {
|
2016-07-03 23:53:38 -06:00
|
|
|
error = -EFAULT;
|
2016-06-30 00:45:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
schedule();
|
|
|
|
}
|
|
|
|
|
|
|
|
current->state = TASK_RUNNING;
|
|
|
|
remove_wait_queue(&tfile->wq.wait, &wait);
|
|
|
|
|
|
|
|
out:
|
2016-07-03 23:53:38 -06:00
|
|
|
*err = error;
|
2018-01-03 20:14:28 -07:00
|
|
|
return ptr;
|
2016-06-30 00:45:36 -06:00
|
|
|
}
|
|
|
|
|
2012-10-31 13:45:57 -06:00
|
|
|
static ssize_t tun_do_read(struct tun_struct *tun, struct tun_file *tfile,
|
2014-11-07 11:52:07 -07:00
|
|
|
struct iov_iter *to,
|
2018-01-03 20:14:28 -07:00
|
|
|
int noblock, void *ptr)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-11-07 11:52:07 -07:00
|
|
|
ssize_t ret;
|
2016-06-30 00:45:36 -06:00
|
|
|
int err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-11-25 15:07:41 -07:00
|
|
|
tun_debug(KERN_INFO, tun, "tun_do_read\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-12-01 03:10:37 -07:00
|
|
|
if (!iov_iter_count(to)) {
|
2018-01-03 20:14:28 -07:00
|
|
|
tun_ptr_free(ptr);
|
2014-11-07 11:52:07 -07:00
|
|
|
return 0;
|
2017-12-01 03:10:37 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2018-01-03 20:14:28 -07:00
|
|
|
if (!ptr) {
|
2017-05-16 22:14:43 -06:00
|
|
|
/* Read frames from ring */
|
2018-01-03 20:14:28 -07:00
|
|
|
ptr = tun_ring_recv(tfile, noblock, &err);
|
|
|
|
if (!ptr)
|
2017-05-16 22:14:43 -06:00
|
|
|
return err;
|
|
|
|
}
|
2014-11-07 06:22:23 -07:00
|
|
|
|
2018-01-03 20:14:28 -07:00
|
|
|
if (tun_is_xdp_buff(ptr)) {
|
|
|
|
struct xdp_buff *xdp = tun_ptr_to_xdp(ptr);
|
|
|
|
|
|
|
|
ret = tun_put_user_xdp(tun, tfile, xdp, to);
|
|
|
|
put_page(virt_to_head_page(xdp->data));
|
|
|
|
} else {
|
|
|
|
struct sk_buff *skb = ptr;
|
|
|
|
|
|
|
|
ret = tun_put_user(tun, tfile, skb, to);
|
|
|
|
if (unlikely(ret < 0))
|
|
|
|
kfree_skb(skb);
|
|
|
|
else
|
|
|
|
consume_skb(skb);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-01-13 23:17:09 -07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-11-07 11:52:07 -07:00
|
|
|
static ssize_t tun_chr_read_iter(struct kiocb *iocb, struct iov_iter *to)
|
2010-01-13 23:17:09 -07:00
|
|
|
{
|
|
|
|
struct file *file = iocb->ki_filp;
|
|
|
|
struct tun_file *tfile = file->private_data;
|
2017-09-23 08:36:52 -06:00
|
|
|
struct tun_struct *tun = tun_get(tfile);
|
2014-11-07 11:52:07 -07:00
|
|
|
ssize_t len = iov_iter_count(to), ret;
|
2010-01-13 23:17:09 -07:00
|
|
|
|
|
|
|
if (!tun)
|
|
|
|
return -EBADFD;
|
2017-05-16 22:14:43 -06:00
|
|
|
ret = tun_do_read(tun, tfile, to, file->f_flags & O_NONBLOCK, NULL);
|
2013-12-10 20:05:45 -07:00
|
|
|
ret = min_t(ssize_t, ret, len);
|
2013-12-05 23:16:51 -07:00
|
|
|
if (ret > 0)
|
|
|
|
iocb->ki_pos = ret;
|
2009-01-20 04:00:40 -07:00
|
|
|
tun_put(tun);
|
2005-04-16 16:20:36 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-01-16 01:31:01 -07:00
|
|
|
static void tun_prog_free(struct rcu_head *rcu)
|
2017-12-04 02:31:23 -07:00
|
|
|
{
|
2018-01-16 01:31:01 -07:00
|
|
|
struct tun_prog *prog = container_of(rcu, struct tun_prog, rcu);
|
2017-12-04 02:31:23 -07:00
|
|
|
|
|
|
|
bpf_prog_destroy(prog->prog);
|
|
|
|
kfree(prog);
|
|
|
|
}
|
|
|
|
|
2018-01-21 19:55:38 -07:00
|
|
|
static int __tun_set_ebpf(struct tun_struct *tun,
|
|
|
|
struct tun_prog __rcu **prog_p,
|
2018-01-16 01:31:01 -07:00
|
|
|
struct bpf_prog *prog)
|
2017-12-04 02:31:23 -07:00
|
|
|
{
|
2018-01-16 01:31:01 -07:00
|
|
|
struct tun_prog *old, *new = NULL;
|
2017-12-04 02:31:23 -07:00
|
|
|
|
|
|
|
if (prog) {
|
|
|
|
new = kmalloc(sizeof(*new), GFP_KERNEL);
|
|
|
|
if (!new)
|
|
|
|
return -ENOMEM;
|
|
|
|
new->prog = prog;
|
|
|
|
}
|
|
|
|
|
2017-12-07 21:02:30 -07:00
|
|
|
spin_lock_bh(&tun->lock);
|
2018-01-16 01:31:01 -07:00
|
|
|
old = rcu_dereference_protected(*prog_p,
|
2017-12-07 21:02:30 -07:00
|
|
|
lockdep_is_held(&tun->lock));
|
2018-01-16 01:31:01 -07:00
|
|
|
rcu_assign_pointer(*prog_p, new);
|
2017-12-07 21:02:30 -07:00
|
|
|
spin_unlock_bh(&tun->lock);
|
2017-12-04 02:31:23 -07:00
|
|
|
|
|
|
|
if (old)
|
2018-01-16 01:31:01 -07:00
|
|
|
call_rcu(&old->rcu, tun_prog_free);
|
2017-12-04 02:31:23 -07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-10-31 13:46:02 -06:00
|
|
|
static void tun_free_netdev(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct tun_struct *tun = netdev_priv(dev);
|
|
|
|
|
2012-12-13 16:53:30 -07:00
|
|
|
BUG_ON(!(list_empty(&tun->disabled)));
|
2016-04-13 02:52:20 -06:00
|
|
|
free_percpu(tun->pcpu_stats);
|
2012-10-31 13:46:02 -06:00
|
|
|
tun_flow_uninit(tun);
|
2013-01-14 00:12:19 -07:00
|
|
|
security_tun_dev_free_security(tun->security);
|
2018-01-16 01:31:01 -07:00
|
|
|
__tun_set_ebpf(tun, &tun->steering_prog, NULL);
|
2018-01-16 01:31:02 -07:00
|
|
|
__tun_set_ebpf(tun, &tun->filter_prog, NULL);
|
2012-10-31 13:46:02 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static void tun_setup(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct tun_struct *tun = netdev_priv(dev);
|
|
|
|
|
2012-02-07 17:48:55 -07:00
|
|
|
tun->owner = INVALID_UID;
|
|
|
|
tun->group = INVALID_GID;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dev->ethtool_ops = &tun_ethtool_ops;
|
net: Fix inconsistent teardown and release of private netdev state.
Network devices can allocate reasources and private memory using
netdev_ops->ndo_init(). However, the release of these resources
can occur in one of two different places.
Either netdev_ops->ndo_uninit() or netdev->destructor().
The decision of which operation frees the resources depends upon
whether it is necessary for all netdev refs to be released before it
is safe to perform the freeing.
netdev_ops->ndo_uninit() presumably can occur right after the
NETDEV_UNREGISTER notifier completes and the unicast and multicast
address lists are flushed.
netdev->destructor(), on the other hand, does not run until the
netdev references all go away.
Further complicating the situation is that netdev->destructor()
almost universally does also a free_netdev().
This creates a problem for the logic in register_netdevice().
Because all callers of register_netdevice() manage the freeing
of the netdev, and invoke free_netdev(dev) if register_netdevice()
fails.
If netdev_ops->ndo_init() succeeds, but something else fails inside
of register_netdevice(), it does call ndo_ops->ndo_uninit(). But
it is not able to invoke netdev->destructor().
This is because netdev->destructor() will do a free_netdev() and
then the caller of register_netdevice() will do the same.
However, this means that the resources that would normally be released
by netdev->destructor() will not be.
Over the years drivers have added local hacks to deal with this, by
invoking their destructor parts by hand when register_netdevice()
fails.
Many drivers do not try to deal with this, and instead we have leaks.
Let's close this hole by formalizing the distinction between what
private things need to be freed up by netdev->destructor() and whether
the driver needs unregister_netdevice() to perform the free_netdev().
netdev->priv_destructor() performs all actions to free up the private
resources that used to be freed by netdev->destructor(), except for
free_netdev().
netdev->needs_free_netdev is a boolean that indicates whether
free_netdev() should be done at the end of unregister_netdevice().
Now, register_netdevice() can sanely release all resources after
ndo_ops->ndo_init() succeeds, by invoking both ndo_ops->ndo_uninit()
and netdev->priv_destructor().
And at the end of unregister_netdevice(), we invoke
netdev->priv_destructor() and optionally call free_netdev().
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-08 10:52:56 -06:00
|
|
|
dev->needs_free_netdev = true;
|
|
|
|
dev->priv_destructor = tun_free_netdev;
|
2016-04-07 23:26:48 -06:00
|
|
|
/* We prefer our own queue length */
|
|
|
|
dev->tx_queue_len = TUN_READQ_SIZE;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-01-21 17:02:16 -07:00
|
|
|
/* Trivial set of netlink ops to allow deleting tun or tap
|
|
|
|
* device with netlink.
|
|
|
|
*/
|
2017-06-25 15:56:01 -06:00
|
|
|
static int tun_validate(struct nlattr *tb[], struct nlattr *data[],
|
|
|
|
struct netlink_ext_ack *extack)
|
2009-01-21 17:02:16 -07:00
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct rtnl_link_ops tun_link_ops __read_mostly = {
|
|
|
|
.kind = DRV_NAME,
|
|
|
|
.priv_size = sizeof(struct tun_struct),
|
|
|
|
.setup = tun_setup,
|
|
|
|
.validate = tun_validate,
|
|
|
|
};
|
|
|
|
|
2009-02-05 22:25:32 -07:00
|
|
|
static void tun_sock_write_space(struct sock *sk)
|
|
|
|
{
|
2012-10-31 13:45:57 -06:00
|
|
|
struct tun_file *tfile;
|
2010-04-29 05:01:49 -06:00
|
|
|
wait_queue_head_t *wqueue;
|
2009-02-05 22:25:32 -07:00
|
|
|
|
|
|
|
if (!sock_writeable(sk))
|
|
|
|
return;
|
|
|
|
|
2015-11-29 21:03:10 -07:00
|
|
|
if (!test_and_clear_bit(SOCKWQ_ASYNC_NOSPACE, &sk->sk_socket->flags))
|
2009-02-05 22:25:32 -07:00
|
|
|
return;
|
|
|
|
|
2010-04-29 05:01:49 -06:00
|
|
|
wqueue = sk_sleep(sk);
|
|
|
|
if (wqueue && waitqueue_active(wqueue))
|
|
|
|
wake_up_interruptible_sync_poll(wqueue, POLLOUT |
|
2010-01-13 23:17:09 -07:00
|
|
|
POLLWRNORM | POLLWRBAND);
|
2009-06-03 22:45:55 -06:00
|
|
|
|
2012-10-31 13:45:57 -06:00
|
|
|
tfile = container_of(sk, struct tun_file, sk);
|
|
|
|
kill_fasync(&tfile->fasync, SIGIO, POLL_OUT);
|
2009-02-05 22:25:32 -07:00
|
|
|
}
|
|
|
|
|
2015-03-02 00:37:48 -07:00
|
|
|
static int tun_sendmsg(struct socket *sock, struct msghdr *m, size_t total_len)
|
2010-01-13 23:17:09 -07:00
|
|
|
{
|
2012-10-31 13:45:57 -06:00
|
|
|
int ret;
|
|
|
|
struct tun_file *tfile = container_of(sock, struct tun_file, socket);
|
2017-09-23 08:36:52 -06:00
|
|
|
struct tun_struct *tun = tun_get(tfile);
|
2012-10-31 13:45:57 -06:00
|
|
|
|
|
|
|
if (!tun)
|
|
|
|
return -EBADFD;
|
2014-06-19 13:36:49 -06:00
|
|
|
|
2014-11-24 08:42:55 -07:00
|
|
|
ret = tun_get_user(tun, tfile, m->msg_control, &m->msg_iter,
|
2017-01-18 00:02:03 -07:00
|
|
|
m->msg_flags & MSG_DONTWAIT,
|
|
|
|
m->msg_flags & MSG_MORE);
|
2012-10-31 13:45:57 -06:00
|
|
|
tun_put(tun);
|
|
|
|
return ret;
|
2010-01-13 23:17:09 -07:00
|
|
|
}
|
|
|
|
|
2015-03-02 00:37:48 -07:00
|
|
|
static int tun_recvmsg(struct socket *sock, struct msghdr *m, size_t total_len,
|
2010-01-13 23:17:09 -07:00
|
|
|
int flags)
|
|
|
|
{
|
2012-10-31 13:45:57 -06:00
|
|
|
struct tun_file *tfile = container_of(sock, struct tun_file, socket);
|
2017-09-23 08:36:52 -06:00
|
|
|
struct tun_struct *tun = tun_get(tfile);
|
2018-01-03 20:14:28 -07:00
|
|
|
void *ptr = m->msg_control;
|
2010-01-13 23:17:09 -07:00
|
|
|
int ret;
|
2012-10-31 13:45:57 -06:00
|
|
|
|
2017-12-01 03:10:37 -07:00
|
|
|
if (!tun) {
|
|
|
|
ret = -EBADFD;
|
2018-01-03 20:14:28 -07:00
|
|
|
goto out_free;
|
2017-12-01 03:10:37 -07:00
|
|
|
}
|
2012-10-31 13:45:57 -06:00
|
|
|
|
2013-07-19 11:40:10 -06:00
|
|
|
if (flags & ~(MSG_DONTWAIT|MSG_TRUNC|MSG_ERRQUEUE)) {
|
2013-04-24 15:59:23 -06:00
|
|
|
ret = -EINVAL;
|
2017-12-01 03:10:37 -07:00
|
|
|
goto out_put_tun;
|
2013-04-24 15:59:23 -06:00
|
|
|
}
|
2013-07-19 11:40:10 -06:00
|
|
|
if (flags & MSG_ERRQUEUE) {
|
|
|
|
ret = sock_recv_errqueue(sock->sk, m, total_len,
|
|
|
|
SOL_PACKET, TUN_TX_TIMESTAMP);
|
|
|
|
goto out;
|
|
|
|
}
|
2018-01-03 20:14:28 -07:00
|
|
|
ret = tun_do_read(tun, tfile, &m->msg_iter, flags & MSG_DONTWAIT, ptr);
|
2014-12-26 00:05:03 -07:00
|
|
|
if (ret > (ssize_t)total_len) {
|
2013-12-10 20:05:45 -07:00
|
|
|
m->msg_flags |= MSG_TRUNC;
|
|
|
|
ret = flags & MSG_TRUNC ? ret : total_len;
|
|
|
|
}
|
2013-04-24 15:59:23 -06:00
|
|
|
out:
|
2012-10-31 13:45:57 -06:00
|
|
|
tun_put(tun);
|
2010-01-13 23:17:09 -07:00
|
|
|
return ret;
|
2017-12-01 03:10:37 -07:00
|
|
|
|
|
|
|
out_put_tun:
|
|
|
|
tun_put(tun);
|
2018-01-03 20:14:28 -07:00
|
|
|
out_free:
|
|
|
|
tun_ptr_free(ptr);
|
2017-12-01 03:10:37 -07:00
|
|
|
return ret;
|
2010-01-13 23:17:09 -07:00
|
|
|
}
|
|
|
|
|
2018-01-03 20:14:28 -07:00
|
|
|
static int tun_ptr_peek_len(void *ptr)
|
|
|
|
{
|
|
|
|
if (likely(ptr)) {
|
|
|
|
if (tun_is_xdp_buff(ptr)) {
|
|
|
|
struct xdp_buff *xdp = tun_ptr_to_xdp(ptr);
|
|
|
|
|
|
|
|
return xdp->data_end - xdp->data;
|
|
|
|
}
|
|
|
|
return __skb_array_len_with_tag(ptr);
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-30 00:45:36 -06:00
|
|
|
static int tun_peek_len(struct socket *sock)
|
|
|
|
{
|
|
|
|
struct tun_file *tfile = container_of(sock, struct tun_file, socket);
|
|
|
|
struct tun_struct *tun;
|
|
|
|
int ret = 0;
|
|
|
|
|
2017-09-23 08:36:52 -06:00
|
|
|
tun = tun_get(tfile);
|
2016-06-30 00:45:36 -06:00
|
|
|
if (!tun)
|
|
|
|
return 0;
|
|
|
|
|
2018-01-03 20:14:28 -07:00
|
|
|
ret = PTR_RING_PEEK_CALL(&tfile->tx_ring, tun_ptr_peek_len);
|
2016-06-30 00:45:36 -06:00
|
|
|
tun_put(tun);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-01-13 23:17:09 -07:00
|
|
|
/* Ops structure to mimic raw sockets with tun */
|
|
|
|
static const struct proto_ops tun_socket_ops = {
|
2016-06-30 00:45:36 -06:00
|
|
|
.peek_len = tun_peek_len,
|
2010-01-13 23:17:09 -07:00
|
|
|
.sendmsg = tun_sendmsg,
|
|
|
|
.recvmsg = tun_recvmsg,
|
|
|
|
};
|
|
|
|
|
2009-02-05 22:25:32 -07:00
|
|
|
static struct proto tun_proto = {
|
|
|
|
.name = "tun",
|
|
|
|
.owner = THIS_MODULE,
|
2012-10-31 13:45:57 -06:00
|
|
|
.obj_size = sizeof(struct tun_file),
|
2009-02-05 22:25:32 -07:00
|
|
|
};
|
2009-01-21 17:02:16 -07:00
|
|
|
|
2009-05-09 23:54:21 -06:00
|
|
|
static int tun_flags(struct tun_struct *tun)
|
|
|
|
{
|
2014-11-19 05:44:40 -07:00
|
|
|
return tun->flags & (TUN_FEATURES | IFF_PERSIST | IFF_TUN | IFF_TAP);
|
2009-05-09 23:54:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t tun_show_flags(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct tun_struct *tun = netdev_priv(to_net_dev(dev));
|
|
|
|
return sprintf(buf, "0x%x\n", tun_flags(tun));
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t tun_show_owner(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct tun_struct *tun = netdev_priv(to_net_dev(dev));
|
2012-02-07 17:48:55 -07:00
|
|
|
return uid_valid(tun->owner)?
|
|
|
|
sprintf(buf, "%u\n",
|
|
|
|
from_kuid_munged(current_user_ns(), tun->owner)):
|
|
|
|
sprintf(buf, "-1\n");
|
2009-05-09 23:54:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t tun_show_group(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct tun_struct *tun = netdev_priv(to_net_dev(dev));
|
2012-02-07 17:48:55 -07:00
|
|
|
return gid_valid(tun->group) ?
|
|
|
|
sprintf(buf, "%u\n",
|
|
|
|
from_kgid_munged(current_user_ns(), tun->group)):
|
|
|
|
sprintf(buf, "-1\n");
|
2009-05-09 23:54:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(tun_flags, 0444, tun_show_flags, NULL);
|
|
|
|
static DEVICE_ATTR(owner, 0444, tun_show_owner, NULL);
|
|
|
|
static DEVICE_ATTR(group, 0444, tun_show_group, NULL);
|
|
|
|
|
2015-02-04 06:37:34 -07:00
|
|
|
static struct attribute *tun_dev_attrs[] = {
|
|
|
|
&dev_attr_tun_flags.attr,
|
|
|
|
&dev_attr_owner.attr,
|
|
|
|
&dev_attr_group.attr,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct attribute_group tun_attr_group = {
|
|
|
|
.attrs = tun_dev_attrs
|
|
|
|
};
|
|
|
|
|
2008-04-16 01:41:16 -06:00
|
|
|
static int tun_set_iff(struct net *net, struct file *file, struct ifreq *ifr)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct tun_struct *tun;
|
2012-10-31 13:45:57 -06:00
|
|
|
struct tun_file *tfile = file->private_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct net_device *dev;
|
|
|
|
int err;
|
|
|
|
|
2013-01-11 09:59:33 -07:00
|
|
|
if (tfile->detached)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2017-09-22 14:49:15 -06:00
|
|
|
if ((ifr->ifr_flags & IFF_NAPI_FRAGS)) {
|
|
|
|
if (!capable(CAP_NET_ADMIN))
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
if (!(ifr->ifr_flags & IFF_NAPI) ||
|
|
|
|
(ifr->ifr_flags & TUN_TYPE_MASK) != IFF_TAP)
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-01-20 03:56:20 -07:00
|
|
|
dev = __dev_get_by_name(net, ifr->ifr_name);
|
|
|
|
if (dev) {
|
2009-04-27 04:23:54 -06:00
|
|
|
if (ifr->ifr_flags & IFF_TUN_EXCL)
|
|
|
|
return -EBUSY;
|
2009-01-20 03:56:20 -07:00
|
|
|
if ((ifr->ifr_flags & IFF_TUN) && dev->netdev_ops == &tun_netdev_ops)
|
|
|
|
tun = netdev_priv(dev);
|
|
|
|
else if ((ifr->ifr_flags & IFF_TAP) && dev->netdev_ops == &tap_netdev_ops)
|
|
|
|
tun = netdev_priv(dev);
|
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
|
2013-05-28 12:32:11 -06:00
|
|
|
if (!!(ifr->ifr_flags & IFF_MULTI_QUEUE) !=
|
2014-11-19 06:17:31 -07:00
|
|
|
!!(tun->flags & IFF_MULTI_QUEUE))
|
2013-05-28 12:32:11 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2012-10-31 13:46:01 -06:00
|
|
|
if (tun_not_capable(tun))
|
2009-08-28 16:12:43 -06:00
|
|
|
return -EPERM;
|
2013-01-14 00:12:19 -07:00
|
|
|
err = security_tun_dev_open(tun->security);
|
2009-08-28 16:12:43 -06:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
2017-09-22 14:49:14 -06:00
|
|
|
err = tun_attach(tun, file, ifr->ifr_flags & IFF_NOFILTER,
|
|
|
|
ifr->ifr_flags & IFF_NAPI);
|
2009-01-20 03:57:48 -07:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2012-12-13 16:53:30 -07:00
|
|
|
|
2014-11-19 06:17:31 -07:00
|
|
|
if (tun->flags & IFF_MULTI_QUEUE &&
|
2013-04-22 14:40:39 -06:00
|
|
|
(tun->numqueues + tun->numdisabled > 1)) {
|
|
|
|
/* One or more queue has already been attached, no need
|
|
|
|
* to initialize the device again.
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
}
|
2006-09-13 11:24:59 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
else {
|
|
|
|
char *name;
|
|
|
|
unsigned long flags = 0;
|
2013-01-22 20:59:12 -07:00
|
|
|
int queues = ifr->ifr_flags & IFF_MULTI_QUEUE ?
|
|
|
|
MAX_TAP_QUEUES : 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-11-18 14:34:11 -07:00
|
|
|
if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
|
2006-06-22 17:07:52 -06:00
|
|
|
return -EPERM;
|
2009-08-28 16:12:43 -06:00
|
|
|
err = security_tun_dev_create();
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2006-06-22 17:07:52 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Set dev type */
|
|
|
|
if (ifr->ifr_flags & IFF_TUN) {
|
|
|
|
/* TUN device */
|
2014-11-19 06:17:31 -07:00
|
|
|
flags |= IFF_TUN;
|
2005-04-16 16:20:36 -06:00
|
|
|
name = "tun%d";
|
|
|
|
} else if (ifr->ifr_flags & IFF_TAP) {
|
|
|
|
/* TAP device */
|
2014-11-19 06:17:31 -07:00
|
|
|
flags |= IFF_TAP;
|
2005-04-16 16:20:36 -06:00
|
|
|
name = "tap%d";
|
2006-09-13 11:24:59 -06:00
|
|
|
} else
|
2009-09-16 15:36:13 -06:00
|
|
|
return -EINVAL;
|
2006-09-13 11:24:59 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (*ifr->ifr_name)
|
|
|
|
name = ifr->ifr_name;
|
|
|
|
|
2012-10-31 13:46:00 -06:00
|
|
|
dev = alloc_netdev_mqs(sizeof(struct tun_struct), name,
|
net: set name_assign_type in alloc_netdev()
Extend alloc_netdev{,_mq{,s}}() to take name_assign_type as argument, and convert
all users to pass NET_NAME_UNKNOWN.
Coccinelle patch:
@@
expression sizeof_priv, name, setup, txqs, rxqs, count;
@@
(
-alloc_netdev_mqs(sizeof_priv, name, setup, txqs, rxqs)
+alloc_netdev_mqs(sizeof_priv, name, NET_NAME_UNKNOWN, setup, txqs, rxqs)
|
-alloc_netdev_mq(sizeof_priv, name, setup, count)
+alloc_netdev_mq(sizeof_priv, name, NET_NAME_UNKNOWN, setup, count)
|
-alloc_netdev(sizeof_priv, name, setup)
+alloc_netdev(sizeof_priv, name, NET_NAME_UNKNOWN, setup)
)
v9: move comments here from the wrong commit
Signed-off-by: Tom Gundersen <teg@jklm.no>
Reviewed-by: David Herrmann <dh.herrmann@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-07-14 08:37:24 -06:00
|
|
|
NET_NAME_UNKNOWN, tun_setup, queues,
|
|
|
|
queues);
|
2013-01-22 20:59:12 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!dev)
|
|
|
|
return -ENOMEM;
|
2017-10-13 12:58:53 -06:00
|
|
|
err = dev_get_valid_name(net, dev, name);
|
2017-10-25 12:50:50 -06:00
|
|
|
if (err < 0)
|
2017-10-13 12:58:53 -06:00
|
|
|
goto err_free_dev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-16 01:41:53 -06:00
|
|
|
dev_net_set(dev, net);
|
2009-01-21 17:02:16 -07:00
|
|
|
dev->rtnl_link_ops = &tun_link_ops;
|
tun: Add ability to create tun device with given index
Tun devices cannot be created with ifidex user wants, but it's
required by checkpoint-restore project.
Long time ago such ability was implemented for rtnl_ops-based
interface for creating links (9c7dafbf net: Allow to create links
with given ifindex), but the only API for creating and managing
tuntap devices is ioctl-based and is evolving with adding new ones
(cde8b15f tuntap: add ioctl to attach or detach a file form tuntap
device).
Following that trend, here's how a new ioctl that sets the ifindex
for device, that _will_ be created by TUNSETIFF ioctl looks like.
So those who want a tuntap device with the ifindex N, should open
the tun device, call ioctl(fd, TUNSETIFINDEX, &N), then call TUNSETIFF.
If the index N is busy, then the register_netdev will find this out
and the ioctl would be failed with -EBUSY.
If setifindex is not called, then it will be generated as before.
Signed-off-by: Pavel Emelyanov <xemul@parallels.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-08-21 04:31:38 -06:00
|
|
|
dev->ifindex = tfile->ifindex;
|
2015-02-04 06:37:34 -07:00
|
|
|
dev->sysfs_groups[0] = &tun_attr_group;
|
2008-11-19 23:10:37 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
tun = netdev_priv(dev);
|
|
|
|
tun->dev = dev;
|
|
|
|
tun->flags = flags;
|
2008-07-14 23:18:19 -06:00
|
|
|
tun->txflt.count = 0;
|
2010-03-17 09:45:01 -06:00
|
|
|
tun->vnet_hdr_sz = sizeof(struct virtio_net_hdr);
|
2009-02-05 22:25:32 -07:00
|
|
|
|
2016-02-26 02:45:40 -07:00
|
|
|
tun->align = NET_SKB_PAD;
|
2012-10-31 13:45:57 -06:00
|
|
|
tun->filter_attached = false;
|
|
|
|
tun->sndbuf = tfile->socket.sk->sk_sndbuf;
|
2017-01-18 00:02:03 -07:00
|
|
|
tun->rx_batched = 0;
|
2017-12-04 02:31:23 -07:00
|
|
|
RCU_INIT_POINTER(tun->steering_prog, NULL);
|
2009-02-05 22:25:32 -07:00
|
|
|
|
2016-04-13 02:52:20 -06:00
|
|
|
tun->pcpu_stats = netdev_alloc_pcpu_stats(struct tun_pcpu_stats);
|
|
|
|
if (!tun->pcpu_stats) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto err_free_dev;
|
|
|
|
}
|
|
|
|
|
2012-10-31 13:46:02 -06:00
|
|
|
spin_lock_init(&tun->lock);
|
|
|
|
|
2013-01-14 00:12:19 -07:00
|
|
|
err = security_tun_dev_alloc_security(&tun->security);
|
|
|
|
if (err < 0)
|
2016-04-13 02:52:20 -06:00
|
|
|
goto err_free_stat;
|
2009-08-28 16:12:43 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
tun_net_init(dev);
|
2013-06-11 07:01:08 -06:00
|
|
|
tun_flow_init(tun);
|
2012-10-31 13:46:02 -06:00
|
|
|
|
2011-04-19 00:13:10 -06:00
|
|
|
dev->hw_features = NETIF_F_SG | NETIF_F_FRAGLIST |
|
2013-07-24 23:00:33 -06:00
|
|
|
TUN_USER_FEATURES | NETIF_F_HW_VLAN_CTAG_TX |
|
|
|
|
NETIF_F_HW_VLAN_STAG_TX;
|
2016-04-14 10:39:39 -06:00
|
|
|
dev->features = dev->hw_features | NETIF_F_LLTX;
|
2014-02-18 05:20:09 -07:00
|
|
|
dev->vlan_features = dev->features &
|
|
|
|
~(NETIF_F_HW_VLAN_CTAG_TX |
|
|
|
|
NETIF_F_HW_VLAN_STAG_TX);
|
2011-04-19 00:13:10 -06:00
|
|
|
|
2012-12-13 16:53:30 -07:00
|
|
|
INIT_LIST_HEAD(&tun->disabled);
|
2017-09-22 14:49:14 -06:00
|
|
|
err = tun_attach(tun, file, false, ifr->ifr_flags & IFF_NAPI);
|
2012-12-02 10:19:45 -07:00
|
|
|
if (err < 0)
|
2013-09-11 04:09:48 -06:00
|
|
|
goto err_free_flow;
|
2012-12-02 10:19:45 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
err = register_netdevice(tun->dev);
|
|
|
|
if (err < 0)
|
2013-09-11 04:09:48 -06:00
|
|
|
goto err_detach;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-01-27 17:38:02 -07:00
|
|
|
netif_carrier_on(tun->dev);
|
|
|
|
|
2011-03-02 00:18:10 -07:00
|
|
|
tun_debug(KERN_INFO, tun, "tun_set_iff\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-11-19 05:44:40 -07:00
|
|
|
tun->flags = (tun->flags & ~TUN_FEATURES) |
|
|
|
|
(ifr->ifr_flags & TUN_FEATURES);
|
2012-10-31 13:46:00 -06:00
|
|
|
|
2008-07-10 17:59:11 -06:00
|
|
|
/* Make sure persistent devices do not get stuck in
|
|
|
|
* xoff state.
|
|
|
|
*/
|
|
|
|
if (netif_running(tun->dev))
|
2012-10-31 13:46:00 -06:00
|
|
|
netif_tx_wake_all_queues(tun->dev);
|
2008-07-10 17:59:11 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
strcpy(ifr->ifr_name, tun->dev->name);
|
|
|
|
return 0;
|
|
|
|
|
2013-09-11 04:09:48 -06:00
|
|
|
err_detach:
|
|
|
|
tun_detach_all(dev);
|
2017-08-18 14:39:56 -06:00
|
|
|
/* register_netdevice() already called tun_free_netdev() */
|
|
|
|
goto err_free_dev;
|
|
|
|
|
2013-09-11 04:09:48 -06:00
|
|
|
err_free_flow:
|
|
|
|
tun_flow_uninit(tun);
|
|
|
|
security_tun_dev_free_security(tun->security);
|
2016-04-13 02:52:20 -06:00
|
|
|
err_free_stat:
|
|
|
|
free_percpu(tun->pcpu_stats);
|
2013-09-11 04:09:48 -06:00
|
|
|
err_free_dev:
|
2005-04-16 16:20:36 -06:00
|
|
|
free_netdev(dev);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-11-22 20:58:10 -07:00
|
|
|
static void tun_get_iff(struct net *net, struct tun_struct *tun,
|
2009-08-06 08:22:44 -06:00
|
|
|
struct ifreq *ifr)
|
2008-08-15 16:09:56 -06:00
|
|
|
{
|
2011-03-02 00:18:10 -07:00
|
|
|
tun_debug(KERN_INFO, tun, "tun_get_iff\n");
|
2008-08-15 16:09:56 -06:00
|
|
|
|
|
|
|
strcpy(ifr->ifr_name, tun->dev->name);
|
|
|
|
|
2009-05-09 23:54:21 -06:00
|
|
|
ifr->ifr_flags = tun_flags(tun);
|
2008-08-15 16:09:56 -06:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2008-07-03 04:46:16 -06:00
|
|
|
/* This is like a cut-down ethtool ops, except done via tun fd so no
|
|
|
|
* privs required. */
|
2011-04-19 00:13:10 -06:00
|
|
|
static int set_offload(struct tun_struct *tun, unsigned long arg)
|
2008-07-03 04:46:16 -06:00
|
|
|
{
|
2011-11-15 08:29:55 -07:00
|
|
|
netdev_features_t features = 0;
|
2008-07-03 04:46:16 -06:00
|
|
|
|
|
|
|
if (arg & TUN_F_CSUM) {
|
2011-04-19 00:13:10 -06:00
|
|
|
features |= NETIF_F_HW_CSUM;
|
2008-07-03 04:46:16 -06:00
|
|
|
arg &= ~TUN_F_CSUM;
|
|
|
|
|
|
|
|
if (arg & (TUN_F_TSO4|TUN_F_TSO6)) {
|
|
|
|
if (arg & TUN_F_TSO_ECN) {
|
|
|
|
features |= NETIF_F_TSO_ECN;
|
|
|
|
arg &= ~TUN_F_TSO_ECN;
|
|
|
|
}
|
|
|
|
if (arg & TUN_F_TSO4)
|
|
|
|
features |= NETIF_F_TSO;
|
|
|
|
if (arg & TUN_F_TSO6)
|
|
|
|
features |= NETIF_F_TSO6;
|
|
|
|
arg &= ~(TUN_F_TSO4|TUN_F_TSO6);
|
|
|
|
}
|
net: accept UFO datagrams from tuntap and packet
Tuntap and similar devices can inject GSO packets. Accept type
VIRTIO_NET_HDR_GSO_UDP, even though not generating UFO natively.
Processes are expected to use feature negotiation such as TUNSETOFFLOAD
to detect supported offload types and refrain from injecting other
packets. This process breaks down with live migration: guest kernels
do not renegotiate flags, so destination hosts need to expose all
features that the source host does.
Partially revert the UFO removal from 182e0b6b5846~1..d9d30adf5677.
This patch introduces nearly(*) no new code to simplify verification.
It brings back verbatim tuntap UFO negotiation, VIRTIO_NET_HDR_GSO_UDP
insertion and software UFO segmentation.
It does not reinstate protocol stack support, hardware offload
(NETIF_F_UFO), SKB_GSO_UDP tunneling in SKB_GSO_SOFTWARE or reception
of VIRTIO_NET_HDR_GSO_UDP packets in tuntap.
To support SKB_GSO_UDP reappearing in the stack, also reinstate
logic in act_csum and openvswitch. Achieve equivalence with v4.13 HEAD
by squashing in commit 939912216fa8 ("net: skb_needs_check() removes
CHECKSUM_UNNECESSARY check for tx.") and reverting commit 8d63bee643f1
("net: avoid skb_warn_bad_offload false positives on UFO").
(*) To avoid having to bring back skb_shinfo(skb)->ip6_frag_id,
ipv6_proxy_select_ident is changed to return a __be32 and this is
assigned directly to the frag_hdr. Also, SKB_GSO_UDP is inserted
at the end of the enum to minimize code churn.
Tested
Booted a v4.13 guest kernel with QEMU. On a host kernel before this
patch `ethtool -k eth0` shows UFO disabled. After the patch, it is
enabled, same as on a v4.13 host kernel.
A UFO packet sent from the guest appears on the tap device:
host:
nc -l -p -u 8000 &
tcpdump -n -i tap0
guest:
dd if=/dev/zero of=payload.txt bs=1 count=2000
nc -u 192.16.1.1 8000 < payload.txt
Direct tap to tap transmission of VIRTIO_NET_HDR_GSO_UDP succeeds,
packets arriving fragmented:
./with_tap_pair.sh ./tap_send_ufo tap0 tap1
(from https://github.com/wdebruij/kerneltools/tree/master/tests)
Changes
v1 -> v2
- simplified set_offload change (review comment)
- documented test procedure
Link: http://lkml.kernel.org/r/<CAF=yD-LuUeDuL9YWPJD9ykOZ0QCjNeznPDr6whqZ9NGMNF12Mw@mail.gmail.com>
Fixes: fb652fdfe837 ("macvlan/macvtap: Remove NETIF_F_UFO advertisement.")
Reported-by: Michal Kubecek <mkubecek@suse.cz>
Signed-off-by: Willem de Bruijn <willemb@google.com>
Acked-by: Jason Wang <jasowang@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-11-21 08:22:25 -07:00
|
|
|
|
|
|
|
arg &= ~TUN_F_UFO;
|
2008-07-03 04:46:16 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* This gives the user a way to test for new features in future by
|
|
|
|
* trying to set them. */
|
|
|
|
if (arg)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-04-19 00:13:10 -06:00
|
|
|
tun->set_features = features;
|
2017-03-16 13:44:10 -06:00
|
|
|
tun->dev->wanted_features &= ~TUN_USER_FEATURES;
|
|
|
|
tun->dev->wanted_features |= features;
|
2011-04-19 00:13:10 -06:00
|
|
|
netdev_update_features(tun->dev);
|
2008-07-03 04:46:16 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-10-31 13:46:00 -06:00
|
|
|
static void tun_detach_filter(struct tun_struct *tun, int n)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct tun_file *tfile;
|
|
|
|
|
|
|
|
for (i = 0; i < n; i++) {
|
2013-01-11 09:59:32 -07:00
|
|
|
tfile = rtnl_dereference(tun->tfiles[i]);
|
2016-04-05 09:10:16 -06:00
|
|
|
lock_sock(tfile->socket.sk);
|
|
|
|
sk_detach_filter(tfile->socket.sk);
|
|
|
|
release_sock(tfile->socket.sk);
|
2012-10-31 13:46:00 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
tun->filter_attached = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tun_attach_filter(struct tun_struct *tun)
|
|
|
|
{
|
|
|
|
int i, ret = 0;
|
|
|
|
struct tun_file *tfile;
|
|
|
|
|
|
|
|
for (i = 0; i < tun->numqueues; i++) {
|
2013-01-11 09:59:32 -07:00
|
|
|
tfile = rtnl_dereference(tun->tfiles[i]);
|
2016-04-05 09:10:16 -06:00
|
|
|
lock_sock(tfile->socket.sk);
|
|
|
|
ret = sk_attach_filter(&tun->fprog, tfile->socket.sk);
|
|
|
|
release_sock(tfile->socket.sk);
|
2012-10-31 13:46:00 -06:00
|
|
|
if (ret) {
|
|
|
|
tun_detach_filter(tun, i);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
tun->filter_attached = true;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tun_set_sndbuf(struct tun_struct *tun)
|
|
|
|
{
|
|
|
|
struct tun_file *tfile;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < tun->numqueues; i++) {
|
2013-01-11 09:59:32 -07:00
|
|
|
tfile = rtnl_dereference(tun->tfiles[i]);
|
2012-10-31 13:46:00 -06:00
|
|
|
tfile->socket.sk->sk_sndbuf = tun->sndbuf;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-31 13:46:01 -06:00
|
|
|
static int tun_set_queue(struct file *file, struct ifreq *ifr)
|
|
|
|
{
|
|
|
|
struct tun_file *tfile = file->private_data;
|
|
|
|
struct tun_struct *tun;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
rtnl_lock();
|
|
|
|
|
|
|
|
if (ifr->ifr_flags & IFF_ATTACH_QUEUE) {
|
2012-12-13 16:53:30 -07:00
|
|
|
tun = tfile->detached;
|
2013-01-14 00:12:19 -07:00
|
|
|
if (!tun) {
|
2012-10-31 13:46:01 -06:00
|
|
|
ret = -EINVAL;
|
2013-01-14 00:12:19 -07:00
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
ret = security_tun_dev_attach_queue(tun->security);
|
|
|
|
if (ret < 0)
|
|
|
|
goto unlock;
|
2017-09-22 14:49:14 -06:00
|
|
|
ret = tun_attach(tun, file, false, tun->flags & IFF_NAPI);
|
2012-12-13 16:53:30 -07:00
|
|
|
} else if (ifr->ifr_flags & IFF_DETACH_QUEUE) {
|
2013-01-11 09:59:32 -07:00
|
|
|
tun = rtnl_dereference(tfile->tun);
|
2014-11-19 06:17:31 -07:00
|
|
|
if (!tun || !(tun->flags & IFF_MULTI_QUEUE) || tfile->detached)
|
2012-12-13 16:53:30 -07:00
|
|
|
ret = -EINVAL;
|
|
|
|
else
|
|
|
|
__tun_detach(tfile, false);
|
|
|
|
} else
|
2012-10-31 13:46:01 -06:00
|
|
|
ret = -EINVAL;
|
|
|
|
|
2013-01-14 00:12:19 -07:00
|
|
|
unlock:
|
2012-10-31 13:46:01 -06:00
|
|
|
rtnl_unlock();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-01-16 01:31:01 -07:00
|
|
|
static int tun_set_ebpf(struct tun_struct *tun, struct tun_prog **prog_p,
|
|
|
|
void __user *data)
|
2017-12-04 02:31:23 -07:00
|
|
|
{
|
|
|
|
struct bpf_prog *prog;
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
if (copy_from_user(&fd, data, sizeof(fd)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
if (fd == -1) {
|
|
|
|
prog = NULL;
|
|
|
|
} else {
|
|
|
|
prog = bpf_prog_get_type(fd, BPF_PROG_TYPE_SOCKET_FILTER);
|
|
|
|
if (IS_ERR(prog))
|
|
|
|
return PTR_ERR(prog);
|
|
|
|
}
|
|
|
|
|
2018-01-16 01:31:01 -07:00
|
|
|
return __tun_set_ebpf(tun, prog_p, prog);
|
2017-12-04 02:31:23 -07:00
|
|
|
}
|
|
|
|
|
2009-11-06 23:52:32 -07:00
|
|
|
static long __tun_chr_ioctl(struct file *file, unsigned int cmd,
|
|
|
|
unsigned long arg, int ifreq_len)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-01-20 04:01:48 -07:00
|
|
|
struct tun_file *tfile = file->private_data;
|
2009-01-20 04:00:40 -07:00
|
|
|
struct tun_struct *tun;
|
2005-04-16 16:20:36 -06:00
|
|
|
void __user* argp = (void __user*)arg;
|
|
|
|
struct ifreq ifr;
|
2012-02-07 17:48:55 -07:00
|
|
|
kuid_t owner;
|
|
|
|
kgid_t group;
|
2009-02-05 22:25:32 -07:00
|
|
|
int sndbuf;
|
2010-03-17 09:45:01 -06:00
|
|
|
int vnet_hdr_sz;
|
tun: Add ability to create tun device with given index
Tun devices cannot be created with ifidex user wants, but it's
required by checkpoint-restore project.
Long time ago such ability was implemented for rtnl_ops-based
interface for creating links (9c7dafbf net: Allow to create links
with given ifindex), but the only API for creating and managing
tuntap devices is ioctl-based and is evolving with adding new ones
(cde8b15f tuntap: add ioctl to attach or detach a file form tuntap
device).
Following that trend, here's how a new ioctl that sets the ifindex
for device, that _will_ be created by TUNSETIFF ioctl looks like.
So those who want a tuntap device with the ifindex N, should open
the tun device, call ioctl(fd, TUNSETIFINDEX, &N), then call TUNSETIFF.
If the index N is busy, then the register_netdev will find this out
and the ioctl would be failed with -EBUSY.
If setifindex is not called, then it will be generated as before.
Signed-off-by: Pavel Emelyanov <xemul@parallels.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-08-21 04:31:38 -06:00
|
|
|
unsigned int ifindex;
|
2014-12-16 06:05:06 -07:00
|
|
|
int le;
|
2008-07-14 23:18:19 -06:00
|
|
|
int ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-10-26 19:05:22 -06:00
|
|
|
if (cmd == TUNSETIFF || cmd == TUNSETQUEUE || _IOC_TYPE(cmd) == SOCK_IOC_TYPE) {
|
2009-11-06 23:52:32 -07:00
|
|
|
if (copy_from_user(&ifr, argp, ifreq_len))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EFAULT;
|
2012-07-30 15:52:48 -06:00
|
|
|
} else {
|
2012-07-29 13:45:14 -06:00
|
|
|
memset(&ifr, 0, sizeof(ifr));
|
2012-07-30 15:52:48 -06:00
|
|
|
}
|
2009-01-20 04:00:40 -07:00
|
|
|
if (cmd == TUNGETFEATURES) {
|
|
|
|
/* Currently this just means: "what IFF flags are valid?".
|
|
|
|
* This is needed because we never checked for invalid flags on
|
2014-11-19 05:44:40 -07:00
|
|
|
* TUNSETIFF.
|
|
|
|
*/
|
|
|
|
return put_user(IFF_TUN | IFF_TAP | TUN_FEATURES,
|
2009-01-20 04:00:40 -07:00
|
|
|
(unsigned int __user*)argp);
|
2012-10-31 13:46:01 -06:00
|
|
|
} else if (cmd == TUNSETQUEUE)
|
|
|
|
return tun_set_queue(file, &ifr);
|
2009-01-20 04:00:40 -07:00
|
|
|
|
2012-10-31 13:46:00 -06:00
|
|
|
ret = 0;
|
2009-08-06 08:22:44 -06:00
|
|
|
rtnl_lock();
|
|
|
|
|
2017-09-23 08:36:52 -06:00
|
|
|
tun = tun_get(tfile);
|
2016-10-25 08:26:09 -06:00
|
|
|
if (cmd == TUNSETIFF) {
|
|
|
|
ret = -EEXIST;
|
|
|
|
if (tun)
|
|
|
|
goto unlock;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
ifr.ifr_name[IFNAMSIZ-1] = '\0';
|
|
|
|
|
2015-05-08 20:07:08 -06:00
|
|
|
ret = tun_set_iff(sock_net(&tfile->sk), file, &ifr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-08-06 08:22:44 -06:00
|
|
|
if (ret)
|
|
|
|
goto unlock;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-11-06 23:52:32 -07:00
|
|
|
if (copy_to_user(argp, &ifr, ifreq_len))
|
2009-08-06 08:22:44 -06:00
|
|
|
ret = -EFAULT;
|
|
|
|
goto unlock;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
tun: Add ability to create tun device with given index
Tun devices cannot be created with ifidex user wants, but it's
required by checkpoint-restore project.
Long time ago such ability was implemented for rtnl_ops-based
interface for creating links (9c7dafbf net: Allow to create links
with given ifindex), but the only API for creating and managing
tuntap devices is ioctl-based and is evolving with adding new ones
(cde8b15f tuntap: add ioctl to attach or detach a file form tuntap
device).
Following that trend, here's how a new ioctl that sets the ifindex
for device, that _will_ be created by TUNSETIFF ioctl looks like.
So those who want a tuntap device with the ifindex N, should open
the tun device, call ioctl(fd, TUNSETIFINDEX, &N), then call TUNSETIFF.
If the index N is busy, then the register_netdev will find this out
and the ioctl would be failed with -EBUSY.
If setifindex is not called, then it will be generated as before.
Signed-off-by: Pavel Emelyanov <xemul@parallels.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-08-21 04:31:38 -06:00
|
|
|
if (cmd == TUNSETIFINDEX) {
|
|
|
|
ret = -EPERM;
|
|
|
|
if (tun)
|
|
|
|
goto unlock;
|
|
|
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
if (copy_from_user(&ifindex, argp, sizeof(ifindex)))
|
|
|
|
goto unlock;
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
tfile->ifindex = ifindex;
|
|
|
|
goto unlock;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-08-06 08:22:44 -06:00
|
|
|
ret = -EBADFD;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!tun)
|
2009-08-06 08:22:44 -06:00
|
|
|
goto unlock;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-10-31 13:45:56 -06:00
|
|
|
tun_debug(KERN_INFO, tun, "tun_chr_ioctl cmd %u\n", cmd);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-01-20 04:00:40 -07:00
|
|
|
ret = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
switch (cmd) {
|
2008-08-15 16:09:56 -06:00
|
|
|
case TUNGETIFF:
|
2012-11-22 20:58:10 -07:00
|
|
|
tun_get_iff(current->nsproxy->net_ns, tun, &ifr);
|
2008-08-15 16:09:56 -06:00
|
|
|
|
2013-08-21 04:32:00 -06:00
|
|
|
if (tfile->detached)
|
|
|
|
ifr.ifr_flags |= IFF_DETACH_QUEUE;
|
tun: Allow to skip filter on attach
There's a small problem with sk-filters on tun devices. Consider
an application doing this sequence of steps:
fd = open("/dev/net/tun");
ioctl(fd, TUNSETIFF, { .ifr_name = "tun0" });
ioctl(fd, TUNATTACHFILTER, &my_filter);
ioctl(fd, TUNSETPERSIST, 1);
close(fd);
At that point the tun0 will remain in the system and will keep in
mind that there should be a socket filter at address '&my_filter'.
If after that we do
fd = open("/dev/net/tun");
ioctl(fd, TUNSETIFF, { .ifr_name = "tun0" });
we most likely receive the -EFAULT error, since tun_attach() would
try to connect the filter back. But (!) if we provide a filter at
address &my_filter, then tun0 will be created and the "new" filter
would be attached, but application may not know about that.
This may create certain problems to anyone using tun-s, but it's
critical problem for c/r -- if we meet a persistent tun device
with a filter in mind, we will not be able to attach to it to dump
its state (flags, owner, address, vnethdr size, etc.).
The proposal is to allow to attach to tun device (with TUNSETIFF)
w/o attaching the filter to the tun-file's socket. After this
attach app may e.g clean the device by dropping the filter, it
doesn't want to have one, or (in case of c/r) get information
about the device with tun ioctls.
Signed-off-by: Pavel Emelyanov <xemul@parallels.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-08-21 04:32:21 -06:00
|
|
|
if (!tfile->socket.sk->sk_filter)
|
|
|
|
ifr.ifr_flags |= IFF_NOFILTER;
|
2013-08-21 04:32:00 -06:00
|
|
|
|
2009-11-06 23:52:32 -07:00
|
|
|
if (copy_to_user(argp, &ifr, ifreq_len))
|
2009-01-20 04:00:40 -07:00
|
|
|
ret = -EFAULT;
|
2008-08-15 16:09:56 -06:00
|
|
|
break;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
case TUNSETNOCSUM:
|
|
|
|
/* Disable/Enable checksum */
|
|
|
|
|
2011-04-19 00:13:10 -06:00
|
|
|
/* [unimplemented] */
|
|
|
|
tun_debug(KERN_INFO, tun, "ignored: set checksum %s\n",
|
2011-03-02 00:18:10 -07:00
|
|
|
arg ? "disabled" : "enabled");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TUNSETPERSIST:
|
2012-10-31 13:45:57 -06:00
|
|
|
/* Disable/Enable persist mode. Keep an extra reference to the
|
|
|
|
* module to prevent the module being unprobed.
|
|
|
|
*/
|
2014-11-19 06:17:31 -07:00
|
|
|
if (arg && !(tun->flags & IFF_PERSIST)) {
|
|
|
|
tun->flags |= IFF_PERSIST;
|
2012-10-31 13:45:57 -06:00
|
|
|
__module_get(THIS_MODULE);
|
2013-01-11 09:59:34 -07:00
|
|
|
}
|
2014-11-19 06:17:31 -07:00
|
|
|
if (!arg && (tun->flags & IFF_PERSIST)) {
|
|
|
|
tun->flags &= ~IFF_PERSIST;
|
2012-10-31 13:45:57 -06:00
|
|
|
module_put(THIS_MODULE);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-03-02 00:18:10 -07:00
|
|
|
tun_debug(KERN_INFO, tun, "persist %s\n",
|
|
|
|
arg ? "enabled" : "disabled");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TUNSETOWNER:
|
|
|
|
/* Set owner of the device */
|
2012-02-07 17:48:55 -07:00
|
|
|
owner = make_kuid(current_user_ns(), arg);
|
|
|
|
if (!uid_valid(owner)) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
tun->owner = owner;
|
2012-10-31 13:45:56 -06:00
|
|
|
tun_debug(KERN_INFO, tun, "owner set to %u\n",
|
2012-02-07 17:48:55 -07:00
|
|
|
from_kuid(&init_user_ns, tun->owner));
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
2007-07-02 23:50:25 -06:00
|
|
|
case TUNSETGROUP:
|
|
|
|
/* Set group of the device */
|
2012-02-07 17:48:55 -07:00
|
|
|
group = make_kgid(current_user_ns(), arg);
|
|
|
|
if (!gid_valid(group)) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
tun->group = group;
|
2012-10-31 13:45:56 -06:00
|
|
|
tun_debug(KERN_INFO, tun, "group set to %u\n",
|
2012-02-07 17:48:55 -07:00
|
|
|
from_kgid(&init_user_ns, tun->group));
|
2007-07-02 23:50:25 -06:00
|
|
|
break;
|
|
|
|
|
2005-09-01 18:40:05 -06:00
|
|
|
case TUNSETLINK:
|
|
|
|
/* Only allow setting the type when the interface is down */
|
|
|
|
if (tun->dev->flags & IFF_UP) {
|
2011-03-02 00:18:10 -07:00
|
|
|
tun_debug(KERN_INFO, tun,
|
|
|
|
"Linktype set failed because interface is up\n");
|
2008-04-23 20:37:58 -06:00
|
|
|
ret = -EBUSY;
|
2005-09-01 18:40:05 -06:00
|
|
|
} else {
|
|
|
|
tun->dev->type = (int) arg;
|
2011-03-02 00:18:10 -07:00
|
|
|
tun_debug(KERN_INFO, tun, "linktype set to %d\n",
|
|
|
|
tun->dev->type);
|
2008-04-23 20:37:58 -06:00
|
|
|
ret = 0;
|
2005-09-01 18:40:05 -06:00
|
|
|
}
|
2009-01-20 04:00:40 -07:00
|
|
|
break;
|
2005-09-01 18:40:05 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef TUN_DEBUG
|
|
|
|
case TUNSETDEBUG:
|
|
|
|
tun->debug = arg;
|
|
|
|
break;
|
|
|
|
#endif
|
2008-07-03 04:46:16 -06:00
|
|
|
case TUNSETOFFLOAD:
|
2011-04-19 00:13:10 -06:00
|
|
|
ret = set_offload(tun, arg);
|
2009-01-20 04:00:40 -07:00
|
|
|
break;
|
2008-07-03 04:46:16 -06:00
|
|
|
|
2008-07-14 23:18:19 -06:00
|
|
|
case TUNSETTXFILTER:
|
|
|
|
/* Can be set only for TAPs */
|
2009-01-20 04:00:40 -07:00
|
|
|
ret = -EINVAL;
|
2014-11-19 06:17:31 -07:00
|
|
|
if ((tun->flags & TUN_TYPE_MASK) != IFF_TAP)
|
2009-01-20 04:00:40 -07:00
|
|
|
break;
|
2008-07-16 13:45:34 -06:00
|
|
|
ret = update_filter(&tun->txflt, (void __user *)arg);
|
2009-01-20 04:00:40 -07:00
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
case SIOCGIFHWADDR:
|
tree-wide: fix comment/printk typos
"gadget", "through", "command", "maintain", "maintain", "controller", "address",
"between", "initiali[zs]e", "instead", "function", "select", "already",
"equal", "access", "management", "hierarchy", "registration", "interest",
"relative", "memory", "offset", "already",
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2010-11-01 13:38:34 -06:00
|
|
|
/* Get hw address */
|
2008-07-14 23:18:19 -06:00
|
|
|
memcpy(ifr.ifr_hwaddr.sa_data, tun->dev->dev_addr, ETH_ALEN);
|
|
|
|
ifr.ifr_hwaddr.sa_family = tun->dev->type;
|
2009-11-06 23:52:32 -07:00
|
|
|
if (copy_to_user(argp, &ifr, ifreq_len))
|
2009-01-20 04:00:40 -07:00
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
case SIOCSIFHWADDR:
|
2008-07-14 23:18:19 -06:00
|
|
|
/* Set hw address */
|
2011-03-02 00:18:10 -07:00
|
|
|
tun_debug(KERN_DEBUG, tun, "set hw address: %pM\n",
|
|
|
|
ifr.ifr_hwaddr.sa_data);
|
2008-02-29 13:26:21 -07:00
|
|
|
|
|
|
|
ret = dev_set_mac_address(tun->dev, &ifr.ifr_hwaddr);
|
2009-01-20 04:00:40 -07:00
|
|
|
break;
|
2009-02-05 22:25:32 -07:00
|
|
|
|
|
|
|
case TUNGETSNDBUF:
|
2012-10-31 13:45:57 -06:00
|
|
|
sndbuf = tfile->socket.sk->sk_sndbuf;
|
2009-02-05 22:25:32 -07:00
|
|
|
if (copy_to_user(argp, &sndbuf, sizeof(sndbuf)))
|
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TUNSETSNDBUF:
|
|
|
|
if (copy_from_user(&sndbuf, argp, sizeof(sndbuf))) {
|
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
|
|
|
}
|
2017-10-30 16:50:11 -06:00
|
|
|
if (sndbuf <= 0) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2009-02-05 22:25:32 -07:00
|
|
|
|
2012-10-31 13:46:00 -06:00
|
|
|
tun->sndbuf = sndbuf;
|
|
|
|
tun_set_sndbuf(tun);
|
2009-02-05 22:25:32 -07:00
|
|
|
break;
|
|
|
|
|
2010-03-17 09:45:01 -06:00
|
|
|
case TUNGETVNETHDRSZ:
|
|
|
|
vnet_hdr_sz = tun->vnet_hdr_sz;
|
|
|
|
if (copy_to_user(argp, &vnet_hdr_sz, sizeof(vnet_hdr_sz)))
|
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TUNSETVNETHDRSZ:
|
|
|
|
if (copy_from_user(&vnet_hdr_sz, argp, sizeof(vnet_hdr_sz))) {
|
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (vnet_hdr_sz < (int)sizeof(struct virtio_net_hdr)) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
tun->vnet_hdr_sz = vnet_hdr_sz;
|
|
|
|
break;
|
|
|
|
|
2014-12-16 06:05:06 -07:00
|
|
|
case TUNGETVNETLE:
|
|
|
|
le = !!(tun->flags & TUN_VNET_LE);
|
|
|
|
if (put_user(le, (int __user *)argp))
|
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TUNSETVNETLE:
|
|
|
|
if (get_user(le, (int __user *)argp)) {
|
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (le)
|
|
|
|
tun->flags |= TUN_VNET_LE;
|
|
|
|
else
|
|
|
|
tun->flags &= ~TUN_VNET_LE;
|
|
|
|
break;
|
|
|
|
|
2015-04-24 06:50:36 -06:00
|
|
|
case TUNGETVNETBE:
|
|
|
|
ret = tun_get_vnet_be(tun, argp);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TUNSETVNETBE:
|
|
|
|
ret = tun_set_vnet_be(tun, argp);
|
|
|
|
break;
|
|
|
|
|
2010-02-13 18:01:10 -07:00
|
|
|
case TUNATTACHFILTER:
|
|
|
|
/* Can be set only for TAPs */
|
|
|
|
ret = -EINVAL;
|
2014-11-19 06:17:31 -07:00
|
|
|
if ((tun->flags & TUN_TYPE_MASK) != IFF_TAP)
|
2010-02-13 18:01:10 -07:00
|
|
|
break;
|
|
|
|
ret = -EFAULT;
|
2012-10-31 13:45:57 -06:00
|
|
|
if (copy_from_user(&tun->fprog, argp, sizeof(tun->fprog)))
|
2010-02-13 18:01:10 -07:00
|
|
|
break;
|
|
|
|
|
2012-10-31 13:46:00 -06:00
|
|
|
ret = tun_attach_filter(tun);
|
2010-02-13 18:01:10 -07:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TUNDETACHFILTER:
|
|
|
|
/* Can be set only for TAPs */
|
|
|
|
ret = -EINVAL;
|
2014-11-19 06:17:31 -07:00
|
|
|
if ((tun->flags & TUN_TYPE_MASK) != IFF_TAP)
|
2010-02-13 18:01:10 -07:00
|
|
|
break;
|
2012-10-31 13:46:00 -06:00
|
|
|
ret = 0;
|
|
|
|
tun_detach_filter(tun, tun->numqueues);
|
2010-02-13 18:01:10 -07:00
|
|
|
break;
|
|
|
|
|
2013-08-21 04:32:39 -06:00
|
|
|
case TUNGETFILTER:
|
|
|
|
ret = -EINVAL;
|
2014-11-19 06:17:31 -07:00
|
|
|
if ((tun->flags & TUN_TYPE_MASK) != IFF_TAP)
|
2013-08-21 04:32:39 -06:00
|
|
|
break;
|
|
|
|
ret = -EFAULT;
|
|
|
|
if (copy_to_user(argp, &tun->fprog, sizeof(tun->fprog)))
|
|
|
|
break;
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
|
2017-12-04 02:31:23 -07:00
|
|
|
case TUNSETSTEERINGEBPF:
|
2018-01-16 01:31:01 -07:00
|
|
|
ret = tun_set_ebpf(tun, &tun->steering_prog, argp);
|
2017-12-04 02:31:23 -07:00
|
|
|
break;
|
|
|
|
|
2018-01-16 01:31:02 -07:00
|
|
|
case TUNSETFILTEREBPF:
|
|
|
|
ret = tun_set_ebpf(tun, &tun->filter_prog, argp);
|
|
|
|
break;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
default:
|
2009-01-20 04:00:40 -07:00
|
|
|
ret = -EINVAL;
|
|
|
|
break;
|
2010-05-17 23:47:34 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-08-06 08:22:44 -06:00
|
|
|
unlock:
|
|
|
|
rtnl_unlock();
|
|
|
|
if (tun)
|
|
|
|
tun_put(tun);
|
2009-01-20 04:00:40 -07:00
|
|
|
return ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-11-06 23:52:32 -07:00
|
|
|
static long tun_chr_ioctl(struct file *file,
|
|
|
|
unsigned int cmd, unsigned long arg)
|
|
|
|
{
|
|
|
|
return __tun_chr_ioctl(file, cmd, arg, sizeof (struct ifreq));
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
static long tun_chr_compat_ioctl(struct file *file,
|
|
|
|
unsigned int cmd, unsigned long arg)
|
|
|
|
{
|
|
|
|
switch (cmd) {
|
|
|
|
case TUNSETIFF:
|
|
|
|
case TUNGETIFF:
|
|
|
|
case TUNSETTXFILTER:
|
|
|
|
case TUNGETSNDBUF:
|
|
|
|
case TUNSETSNDBUF:
|
|
|
|
case SIOCGIFHWADDR:
|
|
|
|
case SIOCSIFHWADDR:
|
|
|
|
arg = (unsigned long)compat_ptr(arg);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
arg = (compat_ulong_t)arg;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* compat_ifreq is shorter than ifreq, so we must not access beyond
|
|
|
|
* the end of that structure. All fields that are used in this
|
|
|
|
* driver are compatible though, we don't need to convert the
|
|
|
|
* contents.
|
|
|
|
*/
|
|
|
|
return __tun_chr_ioctl(file, cmd, arg, sizeof(struct compat_ifreq));
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_COMPAT */
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static int tun_chr_fasync(int fd, struct file *file, int on)
|
|
|
|
{
|
2012-10-31 13:45:57 -06:00
|
|
|
struct tun_file *tfile = file->private_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
int ret;
|
|
|
|
|
2012-10-31 13:45:57 -06:00
|
|
|
if ((ret = fasync_helper(fd, file, on, &tfile->fasync)) < 0)
|
2008-06-19 15:50:37 -06:00
|
|
|
goto out;
|
2006-09-13 11:24:59 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (on) {
|
2014-08-22 09:27:32 -06:00
|
|
|
__f_setown(file, task_pid(current), PIDTYPE_PID, 0);
|
2012-10-31 13:45:57 -06:00
|
|
|
tfile->flags |= TUN_FASYNC;
|
2006-09-13 11:24:59 -06:00
|
|
|
} else
|
2012-10-31 13:45:57 -06:00
|
|
|
tfile->flags &= ~TUN_FASYNC;
|
2008-06-19 15:50:37 -06:00
|
|
|
ret = 0;
|
|
|
|
out:
|
|
|
|
return ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int tun_chr_open(struct inode *inode, struct file * file)
|
|
|
|
{
|
2015-05-08 20:07:08 -06:00
|
|
|
struct net *net = current->nsproxy->net_ns;
|
2009-01-20 04:00:40 -07:00
|
|
|
struct tun_file *tfile;
|
2009-10-14 02:19:46 -06:00
|
|
|
|
2011-03-02 00:18:10 -07:00
|
|
|
DBG1(KERN_INFO, "tunX: tun_chr_open\n");
|
2009-01-20 04:00:40 -07:00
|
|
|
|
2015-05-08 20:07:08 -06:00
|
|
|
tfile = (struct tun_file *)sk_alloc(net, AF_UNSPEC, GFP_KERNEL,
|
2015-05-08 20:09:13 -06:00
|
|
|
&tun_proto, 0);
|
2009-01-20 04:00:40 -07:00
|
|
|
if (!tfile)
|
|
|
|
return -ENOMEM;
|
2014-03-23 12:32:32 -06:00
|
|
|
RCU_INIT_POINTER(tfile->tun, NULL);
|
2012-10-31 13:45:57 -06:00
|
|
|
tfile->flags = 0;
|
tun: Add ability to create tun device with given index
Tun devices cannot be created with ifidex user wants, but it's
required by checkpoint-restore project.
Long time ago such ability was implemented for rtnl_ops-based
interface for creating links (9c7dafbf net: Allow to create links
with given ifindex), but the only API for creating and managing
tuntap devices is ioctl-based and is evolving with adding new ones
(cde8b15f tuntap: add ioctl to attach or detach a file form tuntap
device).
Following that trend, here's how a new ioctl that sets the ifindex
for device, that _will_ be created by TUNSETIFF ioctl looks like.
So those who want a tuntap device with the ifindex N, should open
the tun device, call ioctl(fd, TUNSETIFINDEX, &N), then call TUNSETIFF.
If the index N is busy, then the register_netdev will find this out
and the ioctl would be failed with -EBUSY.
If setifindex is not called, then it will be generated as before.
Signed-off-by: Pavel Emelyanov <xemul@parallels.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-08-21 04:31:38 -06:00
|
|
|
tfile->ifindex = 0;
|
2012-10-31 13:45:57 -06:00
|
|
|
|
|
|
|
init_waitqueue_head(&tfile->wq.wait);
|
2014-05-16 16:11:48 -06:00
|
|
|
RCU_INIT_POINTER(tfile->socket.wq, &tfile->wq);
|
2012-10-31 13:45:57 -06:00
|
|
|
|
|
|
|
tfile->socket.file = file;
|
|
|
|
tfile->socket.ops = &tun_socket_ops;
|
|
|
|
|
|
|
|
sock_init_data(&tfile->socket, &tfile->sk);
|
|
|
|
|
|
|
|
tfile->sk.sk_write_space = tun_sock_write_space;
|
|
|
|
tfile->sk.sk_sndbuf = INT_MAX;
|
|
|
|
|
2009-01-20 04:00:40 -07:00
|
|
|
file->private_data = tfile;
|
2012-12-13 16:53:30 -07:00
|
|
|
INIT_LIST_HEAD(&tfile->next);
|
2012-10-31 13:45:57 -06:00
|
|
|
|
2013-06-08 00:17:41 -06:00
|
|
|
sock_set_flag(&tfile->sk, SOCK_ZEROCOPY);
|
|
|
|
|
2018-01-19 20:59:33 -07:00
|
|
|
memset(&tfile->tx_ring, 0, sizeof(tfile->tx_ring));
|
2018-01-15 12:37:29 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tun_chr_close(struct inode *inode, struct file *file)
|
|
|
|
{
|
2009-01-20 04:00:40 -07:00
|
|
|
struct tun_file *tfile = file->private_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-10-31 13:46:00 -06:00
|
|
|
tun_detach(tfile, true);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-01-29 00:43:31 -07:00
|
|
|
#ifdef CONFIG_PROC_FS
|
2017-09-23 08:36:52 -06:00
|
|
|
static void tun_chr_show_fdinfo(struct seq_file *m, struct file *file)
|
2014-01-29 00:43:31 -07:00
|
|
|
{
|
2017-09-23 08:36:52 -06:00
|
|
|
struct tun_file *tfile = file->private_data;
|
2014-01-29 00:43:31 -07:00
|
|
|
struct tun_struct *tun;
|
|
|
|
struct ifreq ifr;
|
|
|
|
|
|
|
|
memset(&ifr, 0, sizeof(ifr));
|
|
|
|
|
|
|
|
rtnl_lock();
|
2017-09-23 08:36:52 -06:00
|
|
|
tun = tun_get(tfile);
|
2014-01-29 00:43:31 -07:00
|
|
|
if (tun)
|
|
|
|
tun_get_iff(current->nsproxy->net_ns, tun, &ifr);
|
|
|
|
rtnl_unlock();
|
|
|
|
|
|
|
|
if (tun)
|
|
|
|
tun_put(tun);
|
|
|
|
|
2014-09-29 17:08:25 -06:00
|
|
|
seq_printf(m, "iff:\t%s\n", ifr.ifr_name);
|
2014-01-29 00:43:31 -07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-02-12 01:55:34 -07:00
|
|
|
static const struct file_operations tun_fops = {
|
2006-09-13 11:24:59 -06:00
|
|
|
.owner = THIS_MODULE,
|
2005-04-16 16:20:36 -06:00
|
|
|
.llseek = no_llseek,
|
2014-11-07 11:52:07 -07:00
|
|
|
.read_iter = tun_chr_read_iter,
|
2014-06-19 13:36:49 -06:00
|
|
|
.write_iter = tun_chr_write_iter,
|
2005-04-16 16:20:36 -06:00
|
|
|
.poll = tun_chr_poll,
|
2009-11-06 23:52:32 -07:00
|
|
|
.unlocked_ioctl = tun_chr_ioctl,
|
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
.compat_ioctl = tun_chr_compat_ioctl,
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
.open = tun_chr_open,
|
|
|
|
.release = tun_chr_close,
|
2014-01-29 00:43:31 -07:00
|
|
|
.fasync = tun_chr_fasync,
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
.show_fdinfo = tun_chr_show_fdinfo,
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct miscdevice tun_miscdev = {
|
|
|
|
.minor = TUN_MINOR,
|
|
|
|
.name = "tun",
|
2009-09-18 15:01:12 -06:00
|
|
|
.nodename = "net/tun",
|
2005-04-16 16:20:36 -06:00
|
|
|
.fops = &tun_fops,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* ethtool interface */
|
|
|
|
|
2017-03-11 14:03:50 -07:00
|
|
|
static int tun_get_link_ksettings(struct net_device *dev,
|
|
|
|
struct ethtool_link_ksettings *cmd)
|
|
|
|
{
|
|
|
|
ethtool_link_ksettings_zero_link_mode(cmd, supported);
|
|
|
|
ethtool_link_ksettings_zero_link_mode(cmd, advertising);
|
|
|
|
cmd->base.speed = SPEED_10;
|
|
|
|
cmd->base.duplex = DUPLEX_FULL;
|
|
|
|
cmd->base.port = PORT_TP;
|
|
|
|
cmd->base.phy_address = 0;
|
|
|
|
cmd->base.autoneg = AUTONEG_DISABLE;
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tun_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
|
|
|
|
{
|
|
|
|
struct tun_struct *tun = netdev_priv(dev);
|
|
|
|
|
2011-11-15 07:59:53 -07:00
|
|
|
strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
|
|
|
|
strlcpy(info->version, DRV_VERSION, sizeof(info->version));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
switch (tun->flags & TUN_TYPE_MASK) {
|
2014-11-19 06:17:31 -07:00
|
|
|
case IFF_TUN:
|
2011-11-15 07:59:53 -07:00
|
|
|
strlcpy(info->bus_info, "tun", sizeof(info->bus_info));
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2014-11-19 06:17:31 -07:00
|
|
|
case IFF_TAP:
|
2011-11-15 07:59:53 -07:00
|
|
|
strlcpy(info->bus_info, "tap", sizeof(info->bus_info));
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 tun_get_msglevel(struct net_device *dev)
|
|
|
|
{
|
|
|
|
#ifdef TUN_DEBUG
|
|
|
|
struct tun_struct *tun = netdev_priv(dev);
|
|
|
|
return tun->debug;
|
|
|
|
#else
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tun_set_msglevel(struct net_device *dev, u32 value)
|
|
|
|
{
|
|
|
|
#ifdef TUN_DEBUG
|
|
|
|
struct tun_struct *tun = netdev_priv(dev);
|
|
|
|
tun->debug = value;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2017-01-18 00:02:03 -07:00
|
|
|
static int tun_get_coalesce(struct net_device *dev,
|
|
|
|
struct ethtool_coalesce *ec)
|
|
|
|
{
|
|
|
|
struct tun_struct *tun = netdev_priv(dev);
|
|
|
|
|
|
|
|
ec->rx_max_coalesced_frames = tun->rx_batched;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tun_set_coalesce(struct net_device *dev,
|
|
|
|
struct ethtool_coalesce *ec)
|
|
|
|
{
|
|
|
|
struct tun_struct *tun = netdev_priv(dev);
|
|
|
|
|
|
|
|
if (ec->rx_max_coalesced_frames > NAPI_POLL_WEIGHT)
|
|
|
|
tun->rx_batched = NAPI_POLL_WEIGHT;
|
|
|
|
else
|
|
|
|
tun->rx_batched = ec->rx_max_coalesced_frames;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-09-13 12:30:00 -06:00
|
|
|
static const struct ethtool_ops tun_ethtool_ops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.get_drvinfo = tun_get_drvinfo,
|
|
|
|
.get_msglevel = tun_get_msglevel,
|
|
|
|
.set_msglevel = tun_set_msglevel,
|
2010-07-27 07:53:43 -06:00
|
|
|
.get_link = ethtool_op_get_link,
|
2013-07-19 11:40:10 -06:00
|
|
|
.get_ts_info = ethtool_op_get_ts_info,
|
2017-01-18 00:02:03 -07:00
|
|
|
.get_coalesce = tun_get_coalesce,
|
|
|
|
.set_coalesce = tun_set_coalesce,
|
2017-03-11 14:03:50 -07:00
|
|
|
.get_link_ksettings = tun_get_link_ksettings,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2016-06-30 00:45:36 -06:00
|
|
|
static int tun_queue_resize(struct tun_struct *tun)
|
|
|
|
{
|
|
|
|
struct net_device *dev = tun->dev;
|
|
|
|
struct tun_file *tfile;
|
2018-01-03 20:14:27 -07:00
|
|
|
struct ptr_ring **rings;
|
2016-06-30 00:45:36 -06:00
|
|
|
int n = tun->numqueues + tun->numdisabled;
|
|
|
|
int ret, i;
|
|
|
|
|
2018-01-03 20:14:27 -07:00
|
|
|
rings = kmalloc_array(n, sizeof(*rings), GFP_KERNEL);
|
|
|
|
if (!rings)
|
2016-06-30 00:45:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
for (i = 0; i < tun->numqueues; i++) {
|
|
|
|
tfile = rtnl_dereference(tun->tfiles[i]);
|
2018-01-03 20:14:27 -07:00
|
|
|
rings[i] = &tfile->tx_ring;
|
2016-06-30 00:45:36 -06:00
|
|
|
}
|
|
|
|
list_for_each_entry(tfile, &tun->disabled, next)
|
2018-01-03 20:14:27 -07:00
|
|
|
rings[i++] = &tfile->tx_ring;
|
2016-06-30 00:45:36 -06:00
|
|
|
|
2018-01-03 20:14:27 -07:00
|
|
|
ret = ptr_ring_resize_multiple(rings, n,
|
|
|
|
dev->tx_queue_len, GFP_KERNEL,
|
2018-01-03 20:14:28 -07:00
|
|
|
tun_ptr_free);
|
2016-06-30 00:45:36 -06:00
|
|
|
|
2018-01-03 20:14:27 -07:00
|
|
|
kfree(rings);
|
2016-06-30 00:45:36 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tun_device_event(struct notifier_block *unused,
|
|
|
|
unsigned long event, void *ptr)
|
|
|
|
{
|
|
|
|
struct net_device *dev = netdev_notifier_info_to_dev(ptr);
|
|
|
|
struct tun_struct *tun = netdev_priv(dev);
|
|
|
|
|
2016-07-06 16:44:20 -06:00
|
|
|
if (dev->rtnl_link_ops != &tun_link_ops)
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
2016-06-30 00:45:36 -06:00
|
|
|
switch (event) {
|
|
|
|
case NETDEV_CHANGE_TX_QUEUE_LEN:
|
|
|
|
if (tun_queue_resize(tun))
|
|
|
|
return NOTIFY_BAD;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block tun_notifier_block __read_mostly = {
|
|
|
|
.notifier_call = tun_device_event,
|
|
|
|
};
|
2008-04-16 01:40:46 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static int __init tun_init(void)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
2011-03-02 00:18:10 -07:00
|
|
|
pr_info("%s, %s\n", DRV_DESCRIPTION, DRV_VERSION);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-01-21 17:02:16 -07:00
|
|
|
ret = rtnl_link_register(&tun_link_ops);
|
2008-04-16 01:40:46 -06:00
|
|
|
if (ret) {
|
2011-03-02 00:18:10 -07:00
|
|
|
pr_err("Can't register link_ops\n");
|
2009-01-21 17:02:16 -07:00
|
|
|
goto err_linkops;
|
2008-04-16 01:40:46 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
ret = misc_register(&tun_miscdev);
|
2008-04-16 01:40:46 -06:00
|
|
|
if (ret) {
|
2011-03-02 00:18:10 -07:00
|
|
|
pr_err("Can't register misc device %d\n", TUN_MINOR);
|
2008-04-16 01:40:46 -06:00
|
|
|
goto err_misc;
|
|
|
|
}
|
2016-06-30 00:45:36 -06:00
|
|
|
|
2017-07-20 03:41:34 -06:00
|
|
|
ret = register_netdevice_notifier(&tun_notifier_block);
|
|
|
|
if (ret) {
|
|
|
|
pr_err("Can't register netdevice notifier\n");
|
|
|
|
goto err_notifier;
|
|
|
|
}
|
|
|
|
|
2009-01-21 17:02:16 -07:00
|
|
|
return 0;
|
2017-07-20 03:41:34 -06:00
|
|
|
|
|
|
|
err_notifier:
|
|
|
|
misc_deregister(&tun_miscdev);
|
2008-04-16 01:40:46 -06:00
|
|
|
err_misc:
|
2009-01-21 17:02:16 -07:00
|
|
|
rtnl_link_unregister(&tun_link_ops);
|
|
|
|
err_linkops:
|
2005-04-16 16:20:36 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tun_cleanup(void)
|
|
|
|
{
|
2006-09-13 11:24:59 -06:00
|
|
|
misc_deregister(&tun_miscdev);
|
2009-01-21 17:02:16 -07:00
|
|
|
rtnl_link_unregister(&tun_link_ops);
|
2016-06-30 00:45:36 -06:00
|
|
|
unregister_netdevice_notifier(&tun_notifier_block);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-01-13 23:17:09 -07:00
|
|
|
/* Get an underlying socket object from tun file. Returns error unless file is
|
|
|
|
* attached to a device. The returned object works like a packet socket, it
|
|
|
|
* can be used for sock_sendmsg/sock_recvmsg. The caller is responsible for
|
|
|
|
* holding a reference to the file for as long as the socket is in use. */
|
|
|
|
struct socket *tun_get_socket(struct file *file)
|
|
|
|
{
|
2012-10-31 13:45:58 -06:00
|
|
|
struct tun_file *tfile;
|
2010-01-13 23:17:09 -07:00
|
|
|
if (file->f_op != &tun_fops)
|
|
|
|
return ERR_PTR(-EINVAL);
|
2012-10-31 13:45:58 -06:00
|
|
|
tfile = file->private_data;
|
|
|
|
if (!tfile)
|
2010-01-13 23:17:09 -07:00
|
|
|
return ERR_PTR(-EBADFD);
|
2012-10-31 13:45:57 -06:00
|
|
|
return &tfile->socket;
|
2010-01-13 23:17:09 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(tun_get_socket);
|
|
|
|
|
2018-01-03 20:14:27 -07:00
|
|
|
struct ptr_ring *tun_get_tx_ring(struct file *file)
|
2017-05-16 22:14:41 -06:00
|
|
|
{
|
|
|
|
struct tun_file *tfile;
|
|
|
|
|
|
|
|
if (file->f_op != &tun_fops)
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
tfile = file->private_data;
|
|
|
|
if (!tfile)
|
|
|
|
return ERR_PTR(-EBADFD);
|
2018-01-03 20:14:27 -07:00
|
|
|
return &tfile->tx_ring;
|
2017-05-16 22:14:41 -06:00
|
|
|
}
|
2018-01-03 20:14:27 -07:00
|
|
|
EXPORT_SYMBOL_GPL(tun_get_tx_ring);
|
2017-05-16 22:14:41 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
module_init(tun_init);
|
|
|
|
module_exit(tun_cleanup);
|
|
|
|
MODULE_DESCRIPTION(DRV_DESCRIPTION);
|
|
|
|
MODULE_AUTHOR(DRV_COPYRIGHT);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_ALIAS_MISCDEV(TUN_MINOR);
|
driver core: add devname module aliases to allow module on-demand auto-loading
This adds:
alias: devname:<name>
to some common kernel modules, which will allow the on-demand loading
of the kernel module when the device node is accessed.
Ideally all these modules would be compiled-in, but distros seems too
much in love with their modularization that we need to cover the common
cases with this new facility. It will allow us to remove a bunch of pretty
useless init scripts and modprobes from init scripts.
The static device node aliases will be carried in the module itself. The
program depmod will extract this information to a file in the module directory:
$ cat /lib/modules/2.6.34-00650-g537b60d-dirty/modules.devname
# Device nodes to trigger on-demand module loading.
microcode cpu/microcode c10:184
fuse fuse c10:229
ppp_generic ppp c108:0
tun net/tun c10:200
dm_mod mapper/control c10:235
Udev will pick up the depmod created file on startup and create all the
static device nodes which the kernel modules specify, so that these modules
get automatically loaded when the device node is accessed:
$ /sbin/udevd --debug
...
static_dev_create_from_modules: mknod '/dev/cpu/microcode' c10:184
static_dev_create_from_modules: mknod '/dev/fuse' c10:229
static_dev_create_from_modules: mknod '/dev/ppp' c108:0
static_dev_create_from_modules: mknod '/dev/net/tun' c10:200
static_dev_create_from_modules: mknod '/dev/mapper/control' c10:235
udev_rules_apply_static_dev_perms: chmod '/dev/net/tun' 0666
udev_rules_apply_static_dev_perms: chmod '/dev/fuse' 0666
A few device nodes are switched to statically allocated numbers, to allow
the static nodes to work. This might also useful for systems which still run
a plain static /dev, which is completely unsafe to use with any dynamic minor
numbers.
Note:
The devname aliases must be limited to the *common* and *single*instance*
device nodes, like the misc devices, and never be used for conceptually limited
systems like the loop devices, which should rather get fixed properly and get a
control node for losetup to talk to, instead of creating a random number of
device nodes in advance, regardless if they are ever used.
This facility is to hide the mess distros are creating with too modualized
kernels, and just to hide that these modules are not compiled-in, and not to
paper-over broken concepts. Thanks! :)
Cc: Greg Kroah-Hartman <gregkh@suse.de>
Cc: David S. Miller <davem@davemloft.net>
Cc: Miklos Szeredi <miklos@szeredi.hu>
Cc: Chris Mason <chris.mason@oracle.com>
Cc: Alasdair G Kergon <agk@redhat.com>
Cc: Tigran Aivazian <tigran@aivazian.fsnet.co.uk>
Cc: Ian Kent <raven@themaw.net>
Signed-Off-By: Kay Sievers <kay.sievers@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2010-05-20 10:07:20 -06:00
|
|
|
MODULE_ALIAS("devname:net/tun");
|