fs/ksmbd/transport_tcp.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *   Copyright (C) 2016 Namjae Jeon <linkinjeon@kernel.org>
0004  *   Copyright (C) 2018 Samsung Electronics Co., Ltd.
0005  */
0006
0007 #include <linux/freezer.h>
0008
0009 #include "smb_common.h"
0010 #include "server.h"
0011 #include "auth.h"
0012 #include "connection.h"
0013 #include "transport_tcp.h"
0014
0015 #define IFACE_STATE_DOWN        BIT(0)
0016 #define IFACE_STATE_CONFIGURED      BIT(1)
0017
0018 struct interface {
0019     struct task_struct  *ksmbd_kthread;
0020     struct socket       *ksmbd_socket;
0021     struct list_head    entry;
0022     char            *name;
0023     struct mutex        sock_release_lock;
0024     int         state;
0025 };
0026
0027 static LIST_HEAD(iface_list);
0028
0029 static int bind_additional_ifaces;
0030
0031 struct tcp_transport {
0032     struct ksmbd_transport      transport;
0033     struct socket           *sock;
0034     struct kvec         *iov;
0035     unsigned int            nr_iov;
0036 };
0037
0038 static struct ksmbd_transport_ops ksmbd_tcp_transport_ops;
0039
0040 static void tcp_stop_kthread(struct task_struct *kthread);
0041 static struct interface *alloc_iface(char *ifname);
0042
0043 #define KSMBD_TRANS(t)  (&(t)->transport)
0044 #define TCP_TRANS(t)    ((struct tcp_transport *)container_of(t, \
0045                 struct tcp_transport, transport))
0046
0047 static inline void ksmbd_tcp_nodelay(struct socket *sock)
0048 {
0049     tcp_sock_set_nodelay(sock->sk);
0050 }
0051
0052 static inline void ksmbd_tcp_reuseaddr(struct socket *sock)
0053 {
0054     sock_set_reuseaddr(sock->sk);
0055 }
0056
0057 static inline void ksmbd_tcp_rcv_timeout(struct socket *sock, s64 secs)
0058 {
0059     lock_sock(sock->sk);
0060     if (secs && secs < MAX_SCHEDULE_TIMEOUT / HZ - 1)
0061         sock->sk->sk_rcvtimeo = secs * HZ;
0062     else
0063         sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
0064     release_sock(sock->sk);
0065 }
0066
0067 static inline void ksmbd_tcp_snd_timeout(struct socket *sock, s64 secs)
0068 {
0069     sock_set_sndtimeo(sock->sk, secs);
0070 }
0071
0072 static struct tcp_transport *alloc_transport(struct socket *client_sk)
0073 {
0074     struct tcp_transport *t;
0075     struct ksmbd_conn *conn;
0076
0077     t = kzalloc(sizeof(*t), GFP_KERNEL);
0078     if (!t)
0079         return NULL;
0080     t->sock = client_sk;
0081
0082     conn = ksmbd_conn_alloc();
0083     if (!conn) {
0084         kfree(t);
0085         return NULL;
0086     }
0087
0088     conn->transport = KSMBD_TRANS(t);
0089     KSMBD_TRANS(t)->conn = conn;
0090     KSMBD_TRANS(t)->ops = &ksmbd_tcp_transport_ops;
0091     return t;
0092 }
0093
0094 static void free_transport(struct tcp_transport *t)
0095 {
0096     kernel_sock_shutdown(t->sock, SHUT_RDWR);
0097     sock_release(t->sock);
0098     t->sock = NULL;
0099
0100     ksmbd_conn_free(KSMBD_TRANS(t)->conn);
0101     kfree(t->iov);
0102     kfree(t);
0103 }
0104
0105 /**
0106  * kvec_array_init() - initialize a IO vector segment
0107  * @new:    IO vector to be initialized
0108  * @iov:    base IO vector
0109  * @nr_segs:    number of segments in base iov
0110  * @bytes:  total iovec length so far for read
0111  *
0112  * Return:  Number of IO segments
0113  */
0114 static unsigned int kvec_array_init(struct kvec *new, struct kvec *iov,
0115                     unsigned int nr_segs, size_t bytes)
0116 {
0117     size_t base = 0;
0118
0119     while (bytes || !iov->iov_len) {
0120         int copy = min(bytes, iov->iov_len);
0121
0122         bytes -= copy;
0123         base += copy;
0124         if (iov->iov_len == base) {
0125             iov++;
0126             nr_segs--;
0127             base = 0;
0128         }
0129     }
0130
0131     memcpy(new, iov, sizeof(*iov) * nr_segs);
0132     new->iov_base += base;
0133     new->iov_len -= base;
0134     return nr_segs;
0135 }
0136
0137 /**
0138  * get_conn_iovec() - get connection iovec for reading from socket
0139  * @t:      TCP transport instance
0140  * @nr_segs:    number of segments in iov
0141  *
0142  * Return:  return existing or newly allocate iovec
0143  */
0144 static struct kvec *get_conn_iovec(struct tcp_transport *t, unsigned int nr_segs)
0145 {
0146     struct kvec *new_iov;
0147
0148     if (t->iov && nr_segs <= t->nr_iov)
0149         return t->iov;
0150
0151     /* not big enough -- allocate a new one and release the old */
0152     new_iov = kmalloc_array(nr_segs, sizeof(*new_iov), GFP_KERNEL);
0153     if (new_iov) {
0154         kfree(t->iov);
0155         t->iov = new_iov;
0156         t->nr_iov = nr_segs;
0157     }
0158     return new_iov;
0159 }
0160
0161 static unsigned short ksmbd_tcp_get_port(const struct sockaddr *sa)
0162 {
0163     switch (sa->sa_family) {
0164     case AF_INET:
0165         return ntohs(((struct sockaddr_in *)sa)->sin_port);
0166     case AF_INET6:
0167         return ntohs(((struct sockaddr_in6 *)sa)->sin6_port);
0168     }
0169     return 0;
0170 }
0171
0172 /**
0173  * ksmbd_tcp_new_connection() - create a new tcp session on mount
0174  * @client_sk:  socket associated with new connection
0175  *
0176  * whenever a new connection is requested, create a conn thread
0177  * (session thread) to handle new incoming smb requests from the connection
0178  *
0179  * Return:  0 on success, otherwise error
0180  */
0181 static int ksmbd_tcp_new_connection(struct socket *client_sk)
0182 {
0183     struct sockaddr *csin;
0184     int rc = 0;
0185     struct tcp_transport *t;
0186
0187     t = alloc_transport(client_sk);
0188     if (!t)
0189         return -ENOMEM;
0190
0191     csin = KSMBD_TCP_PEER_SOCKADDR(KSMBD_TRANS(t)->conn);
0192     if (kernel_getpeername(client_sk, csin) < 0) {
0193         pr_err("client ip resolution failed\n");
0194         rc = -EINVAL;
0195         goto out_error;
0196     }
0197
0198     KSMBD_TRANS(t)->handler = kthread_run(ksmbd_conn_handler_loop,
0199                           KSMBD_TRANS(t)->conn,
0200                           "ksmbd:%u",
0201                           ksmbd_tcp_get_port(csin));
0202     if (IS_ERR(KSMBD_TRANS(t)->handler)) {
0203         pr_err("cannot start conn thread\n");
0204         rc = PTR_ERR(KSMBD_TRANS(t)->handler);
0205         free_transport(t);
0206     }
0207     return rc;
0208
0209 out_error:
0210     free_transport(t);
0211     return rc;
0212 }
0213
0214 /**
0215  * ksmbd_kthread_fn() - listen to new SMB connections and callback server
0216  * @p:      arguments to forker thread
0217  *
0218  * Return:  0 on success, error number otherwise
0219  */
0220 static int ksmbd_kthread_fn(void *p)
0221 {
0222     struct socket *client_sk = NULL;
0223     struct interface *iface = (struct interface *)p;
0224     int ret;
0225
0226     while (!kthread_should_stop()) {
0227         mutex_lock(&iface->sock_release_lock);
0228         if (!iface->ksmbd_socket) {
0229             mutex_unlock(&iface->sock_release_lock);
0230             break;
0231         }
0232         ret = kernel_accept(iface->ksmbd_socket, &client_sk,
0233                     SOCK_NONBLOCK);
0234         mutex_unlock(&iface->sock_release_lock);
0235         if (ret) {
0236             if (ret == -EAGAIN)
0237                 /* check for new connections every 100 msecs */
0238                 schedule_timeout_interruptible(HZ / 10);
0239             continue;
0240         }
0241
0242         ksmbd_debug(CONN, "connect success: accepted new connection\n");
0243         client_sk->sk->sk_rcvtimeo = KSMBD_TCP_RECV_TIMEOUT;
0244         client_sk->sk->sk_sndtimeo = KSMBD_TCP_SEND_TIMEOUT;
0245
0246         ksmbd_tcp_new_connection(client_sk);
0247     }
0248
0249     ksmbd_debug(CONN, "releasing socket\n");
0250     return 0;
0251 }
0252
0253 /**
0254  * ksmbd_tcp_run_kthread() - start forker thread
0255  * @iface: pointer to struct interface
0256  *
0257  * start forker thread(ksmbd/0) at module init time to listen
0258  * on port 445 for new SMB connection requests. It creates per connection
0259  * server threads(ksmbd/x)
0260  *
0261  * Return:  0 on success or error number
0262  */
0263 static int ksmbd_tcp_run_kthread(struct interface *iface)
0264 {
0265     int rc;
0266     struct task_struct *kthread;
0267
0268     kthread = kthread_run(ksmbd_kthread_fn, (void *)iface, "ksmbd-%s",
0269                   iface->name);
0270     if (IS_ERR(kthread)) {
0271         rc = PTR_ERR(kthread);
0272         return rc;
0273     }
0274     iface->ksmbd_kthread = kthread;
0275
0276     return 0;
0277 }
0278
0279 /**
0280  * ksmbd_tcp_readv() - read data from socket in given iovec
0281  * @t:      TCP transport instance
0282  * @iov_orig:   base IO vector
0283  * @nr_segs:    number of segments in base iov
0284  * @to_read:    number of bytes to read from socket
0285  *
0286  * Return:  on success return number of bytes read from socket,
0287  *      otherwise return error number
0288  */
0289 static int ksmbd_tcp_readv(struct tcp_transport *t, struct kvec *iov_orig,
0290                unsigned int nr_segs, unsigned int to_read)
0291 {
0292     int length = 0;
0293     int total_read;
0294     unsigned int segs;
0295     struct msghdr ksmbd_msg;
0296     struct kvec *iov;
0297     struct ksmbd_conn *conn = KSMBD_TRANS(t)->conn;
0298
0299     iov = get_conn_iovec(t, nr_segs);
0300     if (!iov)
0301         return -ENOMEM;
0302
0303     ksmbd_msg.msg_control = NULL;
0304     ksmbd_msg.msg_controllen = 0;
0305
0306     for (total_read = 0; to_read; total_read += length, to_read -= length) {
0307         try_to_freeze();
0308
0309         if (!ksmbd_conn_alive(conn)) {
0310             total_read = -ESHUTDOWN;
0311             break;
0312         }
0313         segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
0314
0315         length = kernel_recvmsg(t->sock, &ksmbd_msg,
0316                     iov, segs, to_read, 0);
0317
0318         if (length == -EINTR) {
0319             total_read = -ESHUTDOWN;
0320             break;
0321         } else if (conn->status == KSMBD_SESS_NEED_RECONNECT) {
0322             total_read = -EAGAIN;
0323             break;
0324         } else if (length == -ERESTARTSYS || length == -EAGAIN) {
0325             usleep_range(1000, 2000);
0326             length = 0;
0327             continue;
0328         } else if (length <= 0) {
0329             total_read = -EAGAIN;
0330             break;
0331         }
0332     }
0333     return total_read;
0334 }
0335
0336 /**
0337  * ksmbd_tcp_read() - read data from socket in given buffer
0338  * @t:      TCP transport instance
0339  * @buf:    buffer to store read data from socket
0340  * @to_read:    number of bytes to read from socket
0341  *
0342  * Return:  on success return number of bytes read from socket,
0343  *      otherwise return error number
0344  */
0345 static int ksmbd_tcp_read(struct ksmbd_transport *t, char *buf, unsigned int to_read)
0346 {
0347     struct kvec iov;
0348
0349     iov.iov_base = buf;
0350     iov.iov_len = to_read;
0351
0352     return ksmbd_tcp_readv(TCP_TRANS(t), &iov, 1, to_read);
0353 }
0354
0355 static int ksmbd_tcp_writev(struct ksmbd_transport *t, struct kvec *iov,
0356                 int nvecs, int size, bool need_invalidate,
0357                 unsigned int remote_key)
0358
0359 {
0360     struct msghdr smb_msg = {.msg_flags = MSG_NOSIGNAL};
0361
0362     return kernel_sendmsg(TCP_TRANS(t)->sock, &smb_msg, iov, nvecs, size);
0363 }
0364
0365 static void ksmbd_tcp_disconnect(struct ksmbd_transport *t)
0366 {
0367     free_transport(TCP_TRANS(t));
0368 }
0369
0370 static void tcp_destroy_socket(struct socket *ksmbd_socket)
0371 {
0372     int ret;
0373
0374     if (!ksmbd_socket)
0375         return;
0376
0377     /* set zero to timeout */
0378     ksmbd_tcp_rcv_timeout(ksmbd_socket, 0);
0379     ksmbd_tcp_snd_timeout(ksmbd_socket, 0);
0380
0381     ret = kernel_sock_shutdown(ksmbd_socket, SHUT_RDWR);
0382     if (ret)
0383         pr_err("Failed to shutdown socket: %d\n", ret);
0384     sock_release(ksmbd_socket);
0385 }
0386
0387 /**
0388  * create_socket - create socket for ksmbd/0
0389  *
0390  * Return:  0 on success, error number otherwise
0391  */
0392 static int create_socket(struct interface *iface)
0393 {
0394     int ret;
0395     struct sockaddr_in6 sin6;
0396     struct sockaddr_in sin;
0397     struct socket *ksmbd_socket;
0398     bool ipv4 = false;
0399
0400     ret = sock_create(PF_INET6, SOCK_STREAM, IPPROTO_TCP, &ksmbd_socket);
0401     if (ret) {
0402         pr_err("Can't create socket for ipv6, try ipv4: %d\n", ret);
0403         ret = sock_create(PF_INET, SOCK_STREAM, IPPROTO_TCP,
0404                   &ksmbd_socket);
0405         if (ret) {
0406             pr_err("Can't create socket for ipv4: %d\n", ret);
0407             goto out_clear;
0408         }
0409
0410         sin.sin_family = PF_INET;
0411         sin.sin_addr.s_addr = htonl(INADDR_ANY);
0412         sin.sin_port = htons(server_conf.tcp_port);
0413         ipv4 = true;
0414     } else {
0415         sin6.sin6_family = PF_INET6;
0416         sin6.sin6_addr = in6addr_any;
0417         sin6.sin6_port = htons(server_conf.tcp_port);
0418     }
0419
0420     ksmbd_tcp_nodelay(ksmbd_socket);
0421     ksmbd_tcp_reuseaddr(ksmbd_socket);
0422
0423     ret = sock_setsockopt(ksmbd_socket,
0424                   SOL_SOCKET,
0425                   SO_BINDTODEVICE,
0426                   KERNEL_SOCKPTR(iface->name),
0427                   strlen(iface->name));
0428     if (ret != -ENODEV && ret < 0) {
0429         pr_err("Failed to set SO_BINDTODEVICE: %d\n", ret);
0430         goto out_error;
0431     }
0432
0433     if (ipv4)
0434         ret = kernel_bind(ksmbd_socket, (struct sockaddr *)&sin,
0435                   sizeof(sin));
0436     else
0437         ret = kernel_bind(ksmbd_socket, (struct sockaddr *)&sin6,
0438                   sizeof(sin6));
0439     if (ret) {
0440         pr_err("Failed to bind socket: %d\n", ret);
0441         goto out_error;
0442     }
0443
0444     ksmbd_socket->sk->sk_rcvtimeo = KSMBD_TCP_RECV_TIMEOUT;
0445     ksmbd_socket->sk->sk_sndtimeo = KSMBD_TCP_SEND_TIMEOUT;
0446
0447     ret = kernel_listen(ksmbd_socket, KSMBD_SOCKET_BACKLOG);
0448     if (ret) {
0449         pr_err("Port listen() error: %d\n", ret);
0450         goto out_error;
0451     }
0452
0453     iface->ksmbd_socket = ksmbd_socket;
0454     ret = ksmbd_tcp_run_kthread(iface);
0455     if (ret) {
0456         pr_err("Can't start ksmbd main kthread: %d\n", ret);
0457         goto out_error;
0458     }
0459     iface->state = IFACE_STATE_CONFIGURED;
0460
0461     return 0;
0462
0463 out_error:
0464     tcp_destroy_socket(ksmbd_socket);
0465 out_clear:
0466     iface->ksmbd_socket = NULL;
0467     return ret;
0468 }
0469
0470 static int ksmbd_netdev_event(struct notifier_block *nb, unsigned long event,
0471                   void *ptr)
0472 {
0473     struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
0474     struct interface *iface;
0475     int ret, found = 0;
0476
0477     switch (event) {
0478     case NETDEV_UP:
0479         if (netif_is_bridge_port(netdev))
0480             return NOTIFY_OK;
0481
0482         list_for_each_entry(iface, &iface_list, entry) {
0483             if (!strcmp(iface->name, netdev->name)) {
0484                 found = 1;
0485                 if (iface->state != IFACE_STATE_DOWN)
0486                     break;
0487                 ret = create_socket(iface);
0488                 if (ret)
0489                     return NOTIFY_OK;
0490                 break;
0491             }
0492         }
0493         if (!found && bind_additional_ifaces) {
0494             iface = alloc_iface(kstrdup(netdev->name, GFP_KERNEL));
0495             if (!iface)
0496                 return NOTIFY_OK;
0497             ret = create_socket(iface);
0498             if (ret)
0499                 break;
0500         }
0501         break;
0502     case NETDEV_DOWN:
0503         list_for_each_entry(iface, &iface_list, entry) {
0504             if (!strcmp(iface->name, netdev->name) &&
0505                 iface->state == IFACE_STATE_CONFIGURED) {
0506                 tcp_stop_kthread(iface->ksmbd_kthread);
0507                 iface->ksmbd_kthread = NULL;
0508                 mutex_lock(&iface->sock_release_lock);
0509                 tcp_destroy_socket(iface->ksmbd_socket);
0510                 iface->ksmbd_socket = NULL;
0511                 mutex_unlock(&iface->sock_release_lock);
0512
0513                 iface->state = IFACE_STATE_DOWN;
0514                 break;
0515             }
0516         }
0517         break;
0518     }
0519
0520     return NOTIFY_DONE;
0521 }
0522
0523 static struct notifier_block ksmbd_netdev_notifier = {
0524     .notifier_call = ksmbd_netdev_event,
0525 };
0526
0527 int ksmbd_tcp_init(void)
0528 {
0529     register_netdevice_notifier(&ksmbd_netdev_notifier);
0530
0531     return 0;
0532 }
0533
0534 static void tcp_stop_kthread(struct task_struct *kthread)
0535 {
0536     int ret;
0537
0538     if (!kthread)
0539         return;
0540
0541     ret = kthread_stop(kthread);
0542     if (ret)
0543         pr_err("failed to stop forker thread\n");
0544 }
0545
0546 void ksmbd_tcp_destroy(void)
0547 {
0548     struct interface *iface, *tmp;
0549
0550     unregister_netdevice_notifier(&ksmbd_netdev_notifier);
0551
0552     list_for_each_entry_safe(iface, tmp, &iface_list, entry) {
0553         list_del(&iface->entry);
0554         kfree(iface->name);
0555         kfree(iface);
0556     }
0557 }
0558
0559 static struct interface *alloc_iface(char *ifname)
0560 {
0561     struct interface *iface;
0562
0563     if (!ifname)
0564         return NULL;
0565
0566     iface = kzalloc(sizeof(struct interface), GFP_KERNEL);
0567     if (!iface) {
0568         kfree(ifname);
0569         return NULL;
0570     }
0571
0572     iface->name = ifname;
0573     iface->state = IFACE_STATE_DOWN;
0574     list_add(&iface->entry, &iface_list);
0575     mutex_init(&iface->sock_release_lock);
0576     return iface;
0577 }
0578
0579 int ksmbd_tcp_set_interfaces(char *ifc_list, int ifc_list_sz)
0580 {
0581     int sz = 0;
0582
0583     if (!ifc_list_sz) {
0584         struct net_device *netdev;
0585
0586         rtnl_lock();
0587         for_each_netdev(&init_net, netdev) {
0588             if (netif_is_bridge_port(netdev))
0589                 continue;
0590             if (!alloc_iface(kstrdup(netdev->name, GFP_KERNEL)))
0591                 return -ENOMEM;
0592         }
0593         rtnl_unlock();
0594         bind_additional_ifaces = 1;
0595         return 0;
0596     }
0597
0598     while (ifc_list_sz > 0) {
0599         if (!alloc_iface(kstrdup(ifc_list, GFP_KERNEL)))
0600             return -ENOMEM;
0601
0602         sz = strlen(ifc_list);
0603         if (!sz)
0604             break;
0605
0606         ifc_list += sz + 1;
0607         ifc_list_sz -= (sz + 1);
0608     }
0609
0610     bind_additional_ifaces = 0;
0611
0612     return 0;
0613 }
0614
0615 static struct ksmbd_transport_ops ksmbd_tcp_transport_ops = {
0616     .read       = ksmbd_tcp_read,
0617     .writev     = ksmbd_tcp_writev,
0618     .disconnect = ksmbd_tcp_disconnect,
0619 };