fs/smb/server/transport_tcp.c

   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
  18 static atomic_t active_num_conn;
  19
  20 struct 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
  29 static LIST_HEAD(iface_list);
  30
  31 static int bind_additional_ifaces;
  32
  33 struct tcp_transport {
  34         struct ksmbd_transport          transport;
  35         struct socket                   *sock;
  36         struct kvec                     *iov;
  37         unsigned int                    nr_iov;
  38 };
  39
  40 static const struct ksmbd_transport_ops ksmbd_tcp_transport_ops;
  41
  42 static void tcp_stop_kthread(struct task_struct *kthread);
  43 static 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
  49 static inline void ksmbd_tcp_nodelay(struct socket *sock)
  50 {
  51         tcp_sock_set_nodelay(sock->sk);
  52 }
  53
  54 static inline void ksmbd_tcp_reuseaddr(struct socket *sock)
  55 {
  56         sock_set_reuseaddr(sock->sk);
  57 }
  58
  59 static 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         else
  65                 sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
  66         release_sock(sock->sk);
  67 }
  68
  69 static inline void ksmbd_tcp_snd_timeout(struct socket *sock, s64 secs)
  70 {
  71         sock_set_sndtimeo(sock->sk, secs);
  72 }
  73
  74 static 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
  96 static 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 segment
 109  * @new:        IO vector to be initialized
 110  * @iov:        base IO vector
 111  * @nr_segs:    number of segments in base iov
 112  * @bytes:      total iovec length so far for read
 113  *
 114  * Return:      Number of IO segments
 115  */
 116 static 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 socket
 141  * @t:          TCP transport instance
 142  * @nr_segs:    number of segments in iov
 143  *
 144  * Return:      return existing or newly allocate iovec
 145  */
 146 static 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
 163 static 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 mount
 176  * @client_sk:  socket associated with new connection
 177  *
 178  * whenever a new connection is requested, create a conn thread
 179  * (session thread) to handle new incoming smb requests from the connection
 180  *
 181  * Return:      0 on success, otherwise error
 182  */
 183 static 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
 214 out_error:
 215         free_transport(t);
 216         return rc;
 217 }
 218
 219 /**
 220  * ksmbd_kthread_fn() - listen to new SMB connections and callback server
 221  * @p:          arguments to forker thread
 222  *
 223  * Return:      0 on success, error number otherwise
 224  */
 225 static 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 thread
 269  * @iface: pointer to struct interface
 270  *
 271  * start forker thread(ksmbd/0) at module init time to listen
 272  * on port 445 for new SMB connection requests. It creates per connection
 273  * server threads(ksmbd/x)
 274  *
 275  * Return:      0 on success or error number
 276  */
 277 static 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 iovec
 295  * @t:                  TCP transport instance
 296  * @iov_orig:           base IO vector
 297  * @nr_segs:            number of segments in base iov
 298  * @to_read:            number of bytes to read from socket
 299  * @max_retries:        maximum retry count
 300  *
 301  * Return:      on success return number of bytes read from socket,
 302  *              otherwise return error number
 303  */
 304 static 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 unlimited
 343                          * 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 buffer
 365  * @t:          TCP transport instance
 366  * @buf:        buffer to store read data from socket
 367  * @to_read:    number of bytes to read from socket
 368  * @max_retries: number of retries if reading from socket fails
 369  *
 370  * Return:      on success return number of bytes read from socket,
 371  *              otherwise return error number
 372  */
 373 static 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
 384 static 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
 394 static 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
 401 static 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/0
 420  * @iface:      interface to bind the created socket to
 421  *
 422  * Return:      0 on success, error number otherwise
 423  */
 424 static 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         else
 474                 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
 500 out_error:
 501         tcp_destroy_socket(ksmbd_socket);
 502 out_clear:
 503         iface->ksmbd_socket = NULL;
 504         return ret;
 505 }
 506
 507 static 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
 560 static struct notifier_block ksmbd_netdev_notifier = {
 561         .notifier_call = ksmbd_netdev_event,
 562 };
 563
 564 int ksmbd_tcp_init(void)
 565 {
 566         register_netdevice_notifier(&ksmbd_netdev_notifier);
 567
 568         return 0;
 569 }
 570
 571 static 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
 583 void 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
 596 static 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
 616 int 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
 654 static 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 };