cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

transport_tcp.c (14154B)


      1// SPDX-License-Identifier: GPL-2.0-or-later
      2/*
      3 *   Copyright (C) 2016 Namjae Jeon <linkinjeon@kernel.org>
      4 *   Copyright (C) 2018 Samsung Electronics Co., Ltd.
      5 */
      6
      7#include <linux/freezer.h>
      8
      9#include "smb_common.h"
     10#include "server.h"
     11#include "auth.h"
     12#include "connection.h"
     13#include "transport_tcp.h"
     14
     15#define IFACE_STATE_DOWN		BIT(0)
     16#define IFACE_STATE_CONFIGURED		BIT(1)
     17
     18struct interface {
     19	struct task_struct	*ksmbd_kthread;
     20	struct socket		*ksmbd_socket;
     21	struct list_head	entry;
     22	char			*name;
     23	struct mutex		sock_release_lock;
     24	int			state;
     25};
     26
     27static LIST_HEAD(iface_list);
     28
     29static int bind_additional_ifaces;
     30
     31struct tcp_transport {
     32	struct ksmbd_transport		transport;
     33	struct socket			*sock;
     34	struct kvec			*iov;
     35	unsigned int			nr_iov;
     36};
     37
     38static struct ksmbd_transport_ops ksmbd_tcp_transport_ops;
     39
     40static void tcp_stop_kthread(struct task_struct *kthread);
     41static struct interface *alloc_iface(char *ifname);
     42
     43#define KSMBD_TRANS(t)	(&(t)->transport)
     44#define TCP_TRANS(t)	((struct tcp_transport *)container_of(t, \
     45				struct tcp_transport, transport))
     46
     47static inline void ksmbd_tcp_nodelay(struct socket *sock)
     48{
     49	tcp_sock_set_nodelay(sock->sk);
     50}
     51
     52static inline void ksmbd_tcp_reuseaddr(struct socket *sock)
     53{
     54	sock_set_reuseaddr(sock->sk);
     55}
     56
     57static inline void ksmbd_tcp_rcv_timeout(struct socket *sock, s64 secs)
     58{
     59	lock_sock(sock->sk);
     60	if (secs && secs < MAX_SCHEDULE_TIMEOUT / HZ - 1)
     61		sock->sk->sk_rcvtimeo = secs * HZ;
     62	else
     63		sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
     64	release_sock(sock->sk);
     65}
     66
     67static inline void ksmbd_tcp_snd_timeout(struct socket *sock, s64 secs)
     68{
     69	sock_set_sndtimeo(sock->sk, secs);
     70}
     71
     72static struct tcp_transport *alloc_transport(struct socket *client_sk)
     73{
     74	struct tcp_transport *t;
     75	struct ksmbd_conn *conn;
     76
     77	t = kzalloc(sizeof(*t), GFP_KERNEL);
     78	if (!t)
     79		return NULL;
     80	t->sock = client_sk;
     81
     82	conn = ksmbd_conn_alloc();
     83	if (!conn) {
     84		kfree(t);
     85		return NULL;
     86	}
     87
     88	conn->transport = KSMBD_TRANS(t);
     89	KSMBD_TRANS(t)->conn = conn;
     90	KSMBD_TRANS(t)->ops = &ksmbd_tcp_transport_ops;
     91	return t;
     92}
     93
     94static void free_transport(struct tcp_transport *t)
     95{
     96	kernel_sock_shutdown(t->sock, SHUT_RDWR);
     97	sock_release(t->sock);
     98	t->sock = NULL;
     99
    100	ksmbd_conn_free(KSMBD_TRANS(t)->conn);
    101	kfree(t->iov);
    102	kfree(t);
    103}
    104
    105/**
    106 * kvec_array_init() - initialize a IO vector segment
    107 * @new:	IO vector to be initialized
    108 * @iov:	base IO vector
    109 * @nr_segs:	number of segments in base iov
    110 * @bytes:	total iovec length so far for read
    111 *
    112 * Return:	Number of IO segments
    113 */
    114static unsigned int kvec_array_init(struct kvec *new, struct kvec *iov,
    115				    unsigned int nr_segs, size_t bytes)
    116{
    117	size_t base = 0;
    118
    119	while (bytes || !iov->iov_len) {
    120		int copy = min(bytes, iov->iov_len);
    121
    122		bytes -= copy;
    123		base += copy;
    124		if (iov->iov_len == base) {
    125			iov++;
    126			nr_segs--;
    127			base = 0;
    128		}
    129	}
    130
    131	memcpy(new, iov, sizeof(*iov) * nr_segs);
    132	new->iov_base += base;
    133	new->iov_len -= base;
    134	return nr_segs;
    135}
    136
    137/**
    138 * get_conn_iovec() - get connection iovec for reading from socket
    139 * @t:		TCP transport instance
    140 * @nr_segs:	number of segments in iov
    141 *
    142 * Return:	return existing or newly allocate iovec
    143 */
    144static struct kvec *get_conn_iovec(struct tcp_transport *t, unsigned int nr_segs)
    145{
    146	struct kvec *new_iov;
    147
    148	if (t->iov && nr_segs <= t->nr_iov)
    149		return t->iov;
    150
    151	/* not big enough -- allocate a new one and release the old */
    152	new_iov = kmalloc_array(nr_segs, sizeof(*new_iov), GFP_KERNEL);
    153	if (new_iov) {
    154		kfree(t->iov);
    155		t->iov = new_iov;
    156		t->nr_iov = nr_segs;
    157	}
    158	return new_iov;
    159}
    160
    161static unsigned short ksmbd_tcp_get_port(const struct sockaddr *sa)
    162{
    163	switch (sa->sa_family) {
    164	case AF_INET:
    165		return ntohs(((struct sockaddr_in *)sa)->sin_port);
    166	case AF_INET6:
    167		return ntohs(((struct sockaddr_in6 *)sa)->sin6_port);
    168	}
    169	return 0;
    170}
    171
    172/**
    173 * ksmbd_tcp_new_connection() - create a new tcp session on mount
    174 * @client_sk:	socket associated with new connection
    175 *
    176 * whenever a new connection is requested, create a conn thread
    177 * (session thread) to handle new incoming smb requests from the connection
    178 *
    179 * Return:	0 on success, otherwise error
    180 */
    181static int ksmbd_tcp_new_connection(struct socket *client_sk)
    182{
    183	struct sockaddr *csin;
    184	int rc = 0;
    185	struct tcp_transport *t;
    186
    187	t = alloc_transport(client_sk);
    188	if (!t)
    189		return -ENOMEM;
    190
    191	csin = KSMBD_TCP_PEER_SOCKADDR(KSMBD_TRANS(t)->conn);
    192	if (kernel_getpeername(client_sk, csin) < 0) {
    193		pr_err("client ip resolution failed\n");
    194		rc = -EINVAL;
    195		goto out_error;
    196	}
    197
    198	KSMBD_TRANS(t)->handler = kthread_run(ksmbd_conn_handler_loop,
    199					      KSMBD_TRANS(t)->conn,
    200					      "ksmbd:%u",
    201					      ksmbd_tcp_get_port(csin));
    202	if (IS_ERR(KSMBD_TRANS(t)->handler)) {
    203		pr_err("cannot start conn thread\n");
    204		rc = PTR_ERR(KSMBD_TRANS(t)->handler);
    205		free_transport(t);
    206	}
    207	return rc;
    208
    209out_error:
    210	free_transport(t);
    211	return rc;
    212}
    213
    214/**
    215 * ksmbd_kthread_fn() - listen to new SMB connections and callback server
    216 * @p:		arguments to forker thread
    217 *
    218 * Return:	0 on success, error number otherwise
    219 */
    220static int ksmbd_kthread_fn(void *p)
    221{
    222	struct socket *client_sk = NULL;
    223	struct interface *iface = (struct interface *)p;
    224	int ret;
    225
    226	while (!kthread_should_stop()) {
    227		mutex_lock(&iface->sock_release_lock);
    228		if (!iface->ksmbd_socket) {
    229			mutex_unlock(&iface->sock_release_lock);
    230			break;
    231		}
    232		ret = kernel_accept(iface->ksmbd_socket, &client_sk,
    233				    SOCK_NONBLOCK);
    234		mutex_unlock(&iface->sock_release_lock);
    235		if (ret) {
    236			if (ret == -EAGAIN)
    237				/* check for new connections every 100 msecs */
    238				schedule_timeout_interruptible(HZ / 10);
    239			continue;
    240		}
    241
    242		ksmbd_debug(CONN, "connect success: accepted new connection\n");
    243		client_sk->sk->sk_rcvtimeo = KSMBD_TCP_RECV_TIMEOUT;
    244		client_sk->sk->sk_sndtimeo = KSMBD_TCP_SEND_TIMEOUT;
    245
    246		ksmbd_tcp_new_connection(client_sk);
    247	}
    248
    249	ksmbd_debug(CONN, "releasing socket\n");
    250	return 0;
    251}
    252
    253/**
    254 * ksmbd_tcp_run_kthread() - start forker thread
    255 * @iface: pointer to struct interface
    256 *
    257 * start forker thread(ksmbd/0) at module init time to listen
    258 * on port 445 for new SMB connection requests. It creates per connection
    259 * server threads(ksmbd/x)
    260 *
    261 * Return:	0 on success or error number
    262 */
    263static int ksmbd_tcp_run_kthread(struct interface *iface)
    264{
    265	int rc;
    266	struct task_struct *kthread;
    267
    268	kthread = kthread_run(ksmbd_kthread_fn, (void *)iface, "ksmbd-%s",
    269			      iface->name);
    270	if (IS_ERR(kthread)) {
    271		rc = PTR_ERR(kthread);
    272		return rc;
    273	}
    274	iface->ksmbd_kthread = kthread;
    275
    276	return 0;
    277}
    278
    279/**
    280 * ksmbd_tcp_readv() - read data from socket in given iovec
    281 * @t:		TCP transport instance
    282 * @iov_orig:	base IO vector
    283 * @nr_segs:	number of segments in base iov
    284 * @to_read:	number of bytes to read from socket
    285 *
    286 * Return:	on success return number of bytes read from socket,
    287 *		otherwise return error number
    288 */
    289static int ksmbd_tcp_readv(struct tcp_transport *t, struct kvec *iov_orig,
    290			   unsigned int nr_segs, unsigned int to_read)
    291{
    292	int length = 0;
    293	int total_read;
    294	unsigned int segs;
    295	struct msghdr ksmbd_msg;
    296	struct kvec *iov;
    297	struct ksmbd_conn *conn = KSMBD_TRANS(t)->conn;
    298
    299	iov = get_conn_iovec(t, nr_segs);
    300	if (!iov)
    301		return -ENOMEM;
    302
    303	ksmbd_msg.msg_control = NULL;
    304	ksmbd_msg.msg_controllen = 0;
    305
    306	for (total_read = 0; to_read; total_read += length, to_read -= length) {
    307		try_to_freeze();
    308
    309		if (!ksmbd_conn_alive(conn)) {
    310			total_read = -ESHUTDOWN;
    311			break;
    312		}
    313		segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
    314
    315		length = kernel_recvmsg(t->sock, &ksmbd_msg,
    316					iov, segs, to_read, 0);
    317
    318		if (length == -EINTR) {
    319			total_read = -ESHUTDOWN;
    320			break;
    321		} else if (conn->status == KSMBD_SESS_NEED_RECONNECT) {
    322			total_read = -EAGAIN;
    323			break;
    324		} else if (length == -ERESTARTSYS || length == -EAGAIN) {
    325			usleep_range(1000, 2000);
    326			length = 0;
    327			continue;
    328		} else if (length <= 0) {
    329			total_read = -EAGAIN;
    330			break;
    331		}
    332	}
    333	return total_read;
    334}
    335
    336/**
    337 * ksmbd_tcp_read() - read data from socket in given buffer
    338 * @t:		TCP transport instance
    339 * @buf:	buffer to store read data from socket
    340 * @to_read:	number of bytes to read from socket
    341 *
    342 * Return:	on success return number of bytes read from socket,
    343 *		otherwise return error number
    344 */
    345static int ksmbd_tcp_read(struct ksmbd_transport *t, char *buf, unsigned int to_read)
    346{
    347	struct kvec iov;
    348
    349	iov.iov_base = buf;
    350	iov.iov_len = to_read;
    351
    352	return ksmbd_tcp_readv(TCP_TRANS(t), &iov, 1, to_read);
    353}
    354
    355static int ksmbd_tcp_writev(struct ksmbd_transport *t, struct kvec *iov,
    356			    int nvecs, int size, bool need_invalidate,
    357			    unsigned int remote_key)
    358
    359{
    360	struct msghdr smb_msg = {.msg_flags = MSG_NOSIGNAL};
    361
    362	return kernel_sendmsg(TCP_TRANS(t)->sock, &smb_msg, iov, nvecs, size);
    363}
    364
    365static void ksmbd_tcp_disconnect(struct ksmbd_transport *t)
    366{
    367	free_transport(TCP_TRANS(t));
    368}
    369
    370static void tcp_destroy_socket(struct socket *ksmbd_socket)
    371{
    372	int ret;
    373
    374	if (!ksmbd_socket)
    375		return;
    376
    377	/* set zero to timeout */
    378	ksmbd_tcp_rcv_timeout(ksmbd_socket, 0);
    379	ksmbd_tcp_snd_timeout(ksmbd_socket, 0);
    380
    381	ret = kernel_sock_shutdown(ksmbd_socket, SHUT_RDWR);
    382	if (ret)
    383		pr_err("Failed to shutdown socket: %d\n", ret);
    384	sock_release(ksmbd_socket);
    385}
    386
    387/**
    388 * create_socket - create socket for ksmbd/0
    389 *
    390 * Return:	0 on success, error number otherwise
    391 */
    392static int create_socket(struct interface *iface)
    393{
    394	int ret;
    395	struct sockaddr_in6 sin6;
    396	struct sockaddr_in sin;
    397	struct socket *ksmbd_socket;
    398	bool ipv4 = false;
    399
    400	ret = sock_create(PF_INET6, SOCK_STREAM, IPPROTO_TCP, &ksmbd_socket);
    401	if (ret) {
    402		pr_err("Can't create socket for ipv6, try ipv4: %d\n", ret);
    403		ret = sock_create(PF_INET, SOCK_STREAM, IPPROTO_TCP,
    404				  &ksmbd_socket);
    405		if (ret) {
    406			pr_err("Can't create socket for ipv4: %d\n", ret);
    407			goto out_clear;
    408		}
    409
    410		sin.sin_family = PF_INET;
    411		sin.sin_addr.s_addr = htonl(INADDR_ANY);
    412		sin.sin_port = htons(server_conf.tcp_port);
    413		ipv4 = true;
    414	} else {
    415		sin6.sin6_family = PF_INET6;
    416		sin6.sin6_addr = in6addr_any;
    417		sin6.sin6_port = htons(server_conf.tcp_port);
    418	}
    419
    420	ksmbd_tcp_nodelay(ksmbd_socket);
    421	ksmbd_tcp_reuseaddr(ksmbd_socket);
    422
    423	ret = sock_setsockopt(ksmbd_socket,
    424			      SOL_SOCKET,
    425			      SO_BINDTODEVICE,
    426			      KERNEL_SOCKPTR(iface->name),
    427			      strlen(iface->name));
    428	if (ret != -ENODEV && ret < 0) {
    429		pr_err("Failed to set SO_BINDTODEVICE: %d\n", ret);
    430		goto out_error;
    431	}
    432
    433	if (ipv4)
    434		ret = kernel_bind(ksmbd_socket, (struct sockaddr *)&sin,
    435				  sizeof(sin));
    436	else
    437		ret = kernel_bind(ksmbd_socket, (struct sockaddr *)&sin6,
    438				  sizeof(sin6));
    439	if (ret) {
    440		pr_err("Failed to bind socket: %d\n", ret);
    441		goto out_error;
    442	}
    443
    444	ksmbd_socket->sk->sk_rcvtimeo = KSMBD_TCP_RECV_TIMEOUT;
    445	ksmbd_socket->sk->sk_sndtimeo = KSMBD_TCP_SEND_TIMEOUT;
    446
    447	ret = kernel_listen(ksmbd_socket, KSMBD_SOCKET_BACKLOG);
    448	if (ret) {
    449		pr_err("Port listen() error: %d\n", ret);
    450		goto out_error;
    451	}
    452
    453	iface->ksmbd_socket = ksmbd_socket;
    454	ret = ksmbd_tcp_run_kthread(iface);
    455	if (ret) {
    456		pr_err("Can't start ksmbd main kthread: %d\n", ret);
    457		goto out_error;
    458	}
    459	iface->state = IFACE_STATE_CONFIGURED;
    460
    461	return 0;
    462
    463out_error:
    464	tcp_destroy_socket(ksmbd_socket);
    465out_clear:
    466	iface->ksmbd_socket = NULL;
    467	return ret;
    468}
    469
    470static int ksmbd_netdev_event(struct notifier_block *nb, unsigned long event,
    471			      void *ptr)
    472{
    473	struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
    474	struct interface *iface;
    475	int ret, found = 0;
    476
    477	switch (event) {
    478	case NETDEV_UP:
    479		if (netif_is_bridge_port(netdev))
    480			return NOTIFY_OK;
    481
    482		list_for_each_entry(iface, &iface_list, entry) {
    483			if (!strcmp(iface->name, netdev->name)) {
    484				found = 1;
    485				if (iface->state != IFACE_STATE_DOWN)
    486					break;
    487				ret = create_socket(iface);
    488				if (ret)
    489					return NOTIFY_OK;
    490				break;
    491			}
    492		}
    493		if (!found && bind_additional_ifaces) {
    494			iface = alloc_iface(kstrdup(netdev->name, GFP_KERNEL));
    495			if (!iface)
    496				return NOTIFY_OK;
    497			ret = create_socket(iface);
    498			if (ret)
    499				break;
    500		}
    501		break;
    502	case NETDEV_DOWN:
    503		list_for_each_entry(iface, &iface_list, entry) {
    504			if (!strcmp(iface->name, netdev->name) &&
    505			    iface->state == IFACE_STATE_CONFIGURED) {
    506				tcp_stop_kthread(iface->ksmbd_kthread);
    507				iface->ksmbd_kthread = NULL;
    508				mutex_lock(&iface->sock_release_lock);
    509				tcp_destroy_socket(iface->ksmbd_socket);
    510				iface->ksmbd_socket = NULL;
    511				mutex_unlock(&iface->sock_release_lock);
    512
    513				iface->state = IFACE_STATE_DOWN;
    514				break;
    515			}
    516		}
    517		break;
    518	}
    519
    520	return NOTIFY_DONE;
    521}
    522
    523static struct notifier_block ksmbd_netdev_notifier = {
    524	.notifier_call = ksmbd_netdev_event,
    525};
    526
    527int ksmbd_tcp_init(void)
    528{
    529	register_netdevice_notifier(&ksmbd_netdev_notifier);
    530
    531	return 0;
    532}
    533
    534static void tcp_stop_kthread(struct task_struct *kthread)
    535{
    536	int ret;
    537
    538	if (!kthread)
    539		return;
    540
    541	ret = kthread_stop(kthread);
    542	if (ret)
    543		pr_err("failed to stop forker thread\n");
    544}
    545
    546void ksmbd_tcp_destroy(void)
    547{
    548	struct interface *iface, *tmp;
    549
    550	unregister_netdevice_notifier(&ksmbd_netdev_notifier);
    551
    552	list_for_each_entry_safe(iface, tmp, &iface_list, entry) {
    553		list_del(&iface->entry);
    554		kfree(iface->name);
    555		kfree(iface);
    556	}
    557}
    558
    559static struct interface *alloc_iface(char *ifname)
    560{
    561	struct interface *iface;
    562
    563	if (!ifname)
    564		return NULL;
    565
    566	iface = kzalloc(sizeof(struct interface), GFP_KERNEL);
    567	if (!iface) {
    568		kfree(ifname);
    569		return NULL;
    570	}
    571
    572	iface->name = ifname;
    573	iface->state = IFACE_STATE_DOWN;
    574	list_add(&iface->entry, &iface_list);
    575	mutex_init(&iface->sock_release_lock);
    576	return iface;
    577}
    578
    579int ksmbd_tcp_set_interfaces(char *ifc_list, int ifc_list_sz)
    580{
    581	int sz = 0;
    582
    583	if (!ifc_list_sz) {
    584		struct net_device *netdev;
    585
    586		rtnl_lock();
    587		for_each_netdev(&init_net, netdev) {
    588			if (netif_is_bridge_port(netdev))
    589				continue;
    590			if (!alloc_iface(kstrdup(netdev->name, GFP_KERNEL)))
    591				return -ENOMEM;
    592		}
    593		rtnl_unlock();
    594		bind_additional_ifaces = 1;
    595		return 0;
    596	}
    597
    598	while (ifc_list_sz > 0) {
    599		if (!alloc_iface(kstrdup(ifc_list, GFP_KERNEL)))
    600			return -ENOMEM;
    601
    602		sz = strlen(ifc_list);
    603		if (!sz)
    604			break;
    605
    606		ifc_list += sz + 1;
    607		ifc_list_sz -= (sz + 1);
    608	}
    609
    610	bind_additional_ifaces = 0;
    611
    612	return 0;
    613}
    614
    615static struct ksmbd_transport_ops ksmbd_tcp_transport_ops = {
    616	.read		= ksmbd_tcp_read,
    617	.writev		= ksmbd_tcp_writev,
    618	.disconnect	= ksmbd_tcp_disconnect,
    619};