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