net/tipc/server.c

   1 /*
   2  * net/tipc/server.c: TIPC server infrastructure
   3  *
   4  * Copyright (c) 2012-2013, Wind River Systems
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the names of the copyright holders nor the names of its
  16  *    contributors may be used to endorse or promote products derived from
  17  *    this software without specific prior written permission.
  18  *
  19  * Alternatively, this software may be distributed under the terms of the
  20  * GNU General Public License ("GPL") version 2 as published by the Free
  21  * Software Foundation.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  24  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  27  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  28  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  29  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  30  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  31  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  32  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  33  * POSSIBILITY OF SUCH DAMAGE.
  34  */
  35
  36 #include "server.h"
  37 #include "core.h"
  38 #include "socket.h"
  39 #include <net/sock.h>
  40 #include <linux/module.h>
  41
  42 /* Number of messages to send before rescheduling */
  43 #define MAX_SEND_MSG_COUNT      25
  44 #define MAX_RECV_MSG_COUNT      25
  45 #define CF_CONNECTED            1
  46 #define CF_SERVER               2
  47
  48 #define sock2con(x) ((struct tipc_conn *)(x)->sk_user_data)
  49
  50 /**
  51  * struct tipc_conn - TIPC connection structure
  52  * @kref: reference counter to connection object
  53  * @conid: connection identifier
  54  * @sock: socket handler associated with connection
  55  * @flags: indicates connection state
  56  * @server: pointer to connected server
  57  * @rwork: receive work item
  58  * @usr_data: user-specified field
  59  * @rx_action: what to do when connection socket is active
  60  * @outqueue: pointer to first outbound message in queue
  61  * @outqueue_lock: control access to the outqueue
  62  * @outqueue: list of connection objects for its server
  63  * @swork: send work item
  64  */
  65 struct tipc_conn {
  66         struct kref kref;
  67         int conid;
  68         struct socket *sock;
  69         unsigned long flags;
  70         struct tipc_server *server;
  71         struct work_struct rwork;
  72         int (*rx_action) (struct tipc_conn *con);
  73         void *usr_data;
  74         struct list_head outqueue;
  75         spinlock_t outqueue_lock;
  76         struct work_struct swork;
  77 };
  78
  79 /* An entry waiting to be sent */
  80 struct outqueue_entry {
  81         struct list_head list;
  82         struct kvec iov;
  83         struct sockaddr_tipc dest;
  84 };
  85
  86 static void tipc_recv_work(struct work_struct *work);
  87 static void tipc_send_work(struct work_struct *work);
  88 static void tipc_clean_outqueues(struct tipc_conn *con);
  89 static void tipc_sock_release(struct tipc_conn *con);
  90
  91 static void tipc_conn_kref_release(struct kref *kref)
  92 {
  93         struct tipc_conn *con = container_of(kref, struct tipc_conn, kref);
  94         struct sockaddr_tipc *saddr = con->server->saddr;
  95         struct socket *sock = con->sock;
  96         struct sock *sk;
  97
  98         if (sock) {
  99                 sk = sock->sk;
 100                 if (test_bit(CF_SERVER, &con->flags)) {
 101                         __module_get(sock->ops->owner);
 102                         __module_get(sk->sk_prot_creator->owner);
 103                 }
 104                 saddr->scope = -TIPC_NODE_SCOPE;
 105                 kernel_bind(sock, (struct sockaddr *)saddr, sizeof(*saddr));
 106                 tipc_sock_release(con);
 107                 sock_release(sock);
 108                 con->sock = NULL;
 109         }
 110
 111         tipc_clean_outqueues(con);
 112         kfree(con);
 113 }
 114
 115 static void conn_put(struct tipc_conn *con)
 116 {
 117         kref_put(&con->kref, tipc_conn_kref_release);
 118 }
 119
 120 static void conn_get(struct tipc_conn *con)
 121 {
 122         kref_get(&con->kref);
 123 }
 124
 125 static struct tipc_conn *tipc_conn_lookup(struct tipc_server *s, int conid)
 126 {
 127         struct tipc_conn *con;
 128
 129         spin_lock_bh(&s->idr_lock);
 130         con = idr_find(&s->conn_idr, conid);
 131         if (con)
 132                 conn_get(con);
 133         spin_unlock_bh(&s->idr_lock);
 134         return con;
 135 }
 136
 137 static void sock_data_ready(struct sock *sk)
 138 {
 139         struct tipc_conn *con;
 140
 141         read_lock_bh(&sk->sk_callback_lock);
 142         con = sock2con(sk);
 143         if (con && test_bit(CF_CONNECTED, &con->flags)) {
 144                 conn_get(con);
 145                 if (!queue_work(con->server->rcv_wq, &con->rwork))
 146                         conn_put(con);
 147         }
 148         read_unlock_bh(&sk->sk_callback_lock);
 149 }
 150
 151 static void sock_write_space(struct sock *sk)
 152 {
 153         struct tipc_conn *con;
 154
 155         read_lock_bh(&sk->sk_callback_lock);
 156         con = sock2con(sk);
 157         if (con && test_bit(CF_CONNECTED, &con->flags)) {
 158                 conn_get(con);
 159                 if (!queue_work(con->server->send_wq, &con->swork))
 160                         conn_put(con);
 161         }
 162         read_unlock_bh(&sk->sk_callback_lock);
 163 }
 164
 165 static void tipc_register_callbacks(struct socket *sock, struct tipc_conn *con)
 166 {
 167         struct sock *sk = sock->sk;
 168
 169         write_lock_bh(&sk->sk_callback_lock);
 170
 171         sk->sk_data_ready = sock_data_ready;
 172         sk->sk_write_space = sock_write_space;
 173         sk->sk_user_data = con;
 174
 175         con->sock = sock;
 176
 177         write_unlock_bh(&sk->sk_callback_lock);
 178 }
 179
 180 static void tipc_unregister_callbacks(struct tipc_conn *con)
 181 {
 182         struct sock *sk = con->sock->sk;
 183
 184         write_lock_bh(&sk->sk_callback_lock);
 185         sk->sk_user_data = NULL;
 186         write_unlock_bh(&sk->sk_callback_lock);
 187 }
 188
 189 static void tipc_sock_release(struct tipc_conn *con)
 190 {
 191         struct tipc_server *s = con->server;
 192
 193         if (con->conid)
 194                 s->tipc_conn_release(con->conid, con->usr_data);
 195
 196         tipc_unregister_callbacks(con);
 197 }
 198
 199 static void tipc_close_conn(struct tipc_conn *con)
 200 {
 201         struct tipc_server *s = con->server;
 202
 203         if (test_and_clear_bit(CF_CONNECTED, &con->flags)) {
 204
 205                 spin_lock_bh(&s->idr_lock);
 206                 idr_remove(&s->conn_idr, con->conid);
 207                 s->idr_in_use--;
 208                 spin_unlock_bh(&s->idr_lock);
 209
 210                 /* We shouldn't flush pending works as we may be in the
 211                  * thread. In fact the races with pending rx/tx work structs
 212                  * are harmless for us here as we have already deleted this
 213                  * connection from server connection list.
 214                  */
 215                 kernel_sock_shutdown(con->sock, SHUT_RDWR);
 216
 217                 conn_put(con);
 218         }
 219 }
 220
 221 static struct tipc_conn *tipc_alloc_conn(struct tipc_server *s)
 222 {
 223         struct tipc_conn *con;
 224         int ret;
 225
 226         con = kzalloc(sizeof(struct tipc_conn), GFP_ATOMIC);
 227         if (!con)
 228                 return ERR_PTR(-ENOMEM);
 229
 230         kref_init(&con->kref);
 231         INIT_LIST_HEAD(&con->outqueue);
 232         spin_lock_init(&con->outqueue_lock);
 233         INIT_WORK(&con->swork, tipc_send_work);
 234         INIT_WORK(&con->rwork, tipc_recv_work);
 235
 236         spin_lock_bh(&s->idr_lock);
 237         ret = idr_alloc(&s->conn_idr, con, 0, 0, GFP_ATOMIC);
 238         if (ret < 0) {
 239                 kfree(con);
 240                 spin_unlock_bh(&s->idr_lock);
 241                 return ERR_PTR(-ENOMEM);
 242         }
 243         con->conid = ret;
 244         s->idr_in_use++;
 245         spin_unlock_bh(&s->idr_lock);
 246
 247         set_bit(CF_CONNECTED, &con->flags);
 248         con->server = s;
 249
 250         return con;
 251 }
 252
 253 static int tipc_receive_from_sock(struct tipc_conn *con)
 254 {
 255         struct msghdr msg = {};
 256         struct tipc_server *s = con->server;
 257         struct sockaddr_tipc addr;
 258         struct kvec iov;
 259         void *buf;
 260         int ret;
 261
 262         buf = kmem_cache_alloc(s->rcvbuf_cache, GFP_ATOMIC);
 263         if (!buf) {
 264                 ret = -ENOMEM;
 265                 goto out_close;
 266         }
 267
 268         iov.iov_base = buf;
 269         iov.iov_len = s->max_rcvbuf_size;
 270         msg.msg_name = &addr;
 271         ret = kernel_recvmsg(con->sock, &msg, &iov, 1, iov.iov_len,
 272                              MSG_DONTWAIT);
 273         if (ret <= 0) {
 274                 kmem_cache_free(s->rcvbuf_cache, buf);
 275                 goto out_close;
 276         }
 277
 278         s->tipc_conn_recvmsg(sock_net(con->sock->sk), con->conid, &addr,
 279                              con->usr_data, buf, ret);
 280
 281         kmem_cache_free(s->rcvbuf_cache, buf);
 282
 283         return 0;
 284
 285 out_close:
 286         if (ret != -EWOULDBLOCK)
 287                 tipc_close_conn(con);
 288         else if (ret == 0)
 289                 /* Don't return success if we really got EOF */
 290                 ret = -EAGAIN;
 291
 292         return ret;
 293 }
 294
 295 static int tipc_accept_from_sock(struct tipc_conn *con)
 296 {
 297         struct tipc_server *s = con->server;
 298         struct socket *sock = con->sock;
 299         struct socket *newsock;
 300         struct tipc_conn *newcon;
 301         int ret;
 302
 303         ret = kernel_accept(sock, &newsock, O_NONBLOCK);
 304         if (ret < 0)
 305                 return ret;
 306
 307         newcon = tipc_alloc_conn(con->server);
 308         if (IS_ERR(newcon)) {
 309                 ret = PTR_ERR(newcon);
 310                 sock_release(newsock);
 311                 return ret;
 312         }
 313
 314         newcon->rx_action = tipc_receive_from_sock;
 315         tipc_register_callbacks(newsock, newcon);
 316
 317         /* Notify that new connection is incoming */
 318         newcon->usr_data = s->tipc_conn_new(newcon->conid);
 319         if (!newcon->usr_data) {
 320                 sock_release(newsock);
 321                 return -ENOMEM;
 322         }
 323
 324         /* Wake up receive process in case of 'SYN+' message */
 325         newsock->sk->sk_data_ready(newsock->sk);
 326         return ret;
 327 }
 328
 329 static struct socket *tipc_create_listen_sock(struct tipc_conn *con)
 330 {
 331         struct tipc_server *s = con->server;
 332         struct socket *sock = NULL;
 333         int ret;
 334
 335         ret = sock_create_kern(s->net, AF_TIPC, SOCK_SEQPACKET, 0, &sock);
 336         if (ret < 0)
 337                 return NULL;
 338         ret = kernel_setsockopt(sock, SOL_TIPC, TIPC_IMPORTANCE,
 339                                 (char *)&s->imp, sizeof(s->imp));
 340         if (ret < 0)
 341                 goto create_err;
 342         ret = kernel_bind(sock, (struct sockaddr *)s->saddr, sizeof(*s->saddr));
 343         if (ret < 0)
 344                 goto create_err;
 345
 346         switch (s->type) {
 347         case SOCK_STREAM:
 348         case SOCK_SEQPACKET:
 349                 con->rx_action = tipc_accept_from_sock;
 350
 351                 ret = kernel_listen(sock, 0);
 352                 if (ret < 0)
 353                         goto create_err;
 354                 break;
 355         case SOCK_DGRAM:
 356         case SOCK_RDM:
 357                 con->rx_action = tipc_receive_from_sock;
 358                 break;
 359         default:
 360                 pr_err("Unknown socket type %d\n", s->type);
 361                 goto create_err;
 362         }
 363
 364         /* As server's listening socket owner and creator is the same module,
 365          * we have to decrease TIPC module reference count to guarantee that
 366          * it remains zero after the server socket is created, otherwise,
 367          * executing "rmmod" command is unable to make TIPC module deleted
 368          * after TIPC module is inserted successfully.
 369          *
 370          * However, the reference count is ever increased twice in
 371          * sock_create_kern(): one is to increase the reference count of owner
 372          * of TIPC socket's proto_ops struct; another is to increment the
 373          * reference count of owner of TIPC proto struct. Therefore, we must
 374          * decrement the module reference count twice to ensure that it keeps
 375          * zero after server's listening socket is created. Of course, we
 376          * must bump the module reference count twice as well before the socket
 377          * is closed.
 378          */
 379         module_put(sock->ops->owner);
 380         module_put(sock->sk->sk_prot_creator->owner);
 381         set_bit(CF_SERVER, &con->flags);
 382
 383         return sock;
 384
 385 create_err:
 386         kernel_sock_shutdown(sock, SHUT_RDWR);
 387         sock_release(sock);
 388         return NULL;
 389 }
 390
 391 static int tipc_open_listening_sock(struct tipc_server *s)
 392 {
 393         struct socket *sock;
 394         struct tipc_conn *con;
 395
 396         con = tipc_alloc_conn(s);
 397         if (IS_ERR(con))
 398                 return PTR_ERR(con);
 399
 400         sock = tipc_create_listen_sock(con);
 401         if (!sock) {
 402                 idr_remove(&s->conn_idr, con->conid);
 403                 s->idr_in_use--;
 404                 kfree(con);
 405                 return -EINVAL;
 406         }
 407
 408         tipc_register_callbacks(sock, con);
 409         return 0;
 410 }
 411
 412 static struct outqueue_entry *tipc_alloc_entry(void *data, int len)
 413 {
 414         struct outqueue_entry *entry;
 415         void *buf;
 416
 417         entry = kmalloc(sizeof(struct outqueue_entry), GFP_ATOMIC);
 418         if (!entry)
 419                 return NULL;
 420
 421         buf = kmemdup(data, len, GFP_ATOMIC);
 422         if (!buf) {
 423                 kfree(entry);
 424                 return NULL;
 425         }
 426
 427         entry->iov.iov_base = buf;
 428         entry->iov.iov_len = len;
 429
 430         return entry;
 431 }
 432
 433 static void tipc_free_entry(struct outqueue_entry *e)
 434 {
 435         kfree(e->iov.iov_base);
 436         kfree(e);
 437 }
 438
 439 static void tipc_clean_outqueues(struct tipc_conn *con)
 440 {
 441         struct outqueue_entry *e, *safe;
 442
 443         spin_lock_bh(&con->outqueue_lock);
 444         list_for_each_entry_safe(e, safe, &con->outqueue, list) {
 445                 list_del(&e->list);
 446                 tipc_free_entry(e);
 447         }
 448         spin_unlock_bh(&con->outqueue_lock);
 449 }
 450
 451 int tipc_conn_sendmsg(struct tipc_server *s, int conid,
 452                       struct sockaddr_tipc *addr, void *data, size_t len)
 453 {
 454         struct outqueue_entry *e;
 455         struct tipc_conn *con;
 456
 457         con = tipc_conn_lookup(s, conid);
 458         if (!con)
 459                 return -EINVAL;
 460
 461         e = tipc_alloc_entry(data, len);
 462         if (!e) {
 463                 conn_put(con);
 464                 return -ENOMEM;
 465         }
 466
 467         if (addr)
 468                 memcpy(&e->dest, addr, sizeof(struct sockaddr_tipc));
 469
 470         spin_lock_bh(&con->outqueue_lock);
 471         list_add_tail(&e->list, &con->outqueue);
 472         spin_unlock_bh(&con->outqueue_lock);
 473
 474         if (test_bit(CF_CONNECTED, &con->flags)) {
 475                 if (!queue_work(s->send_wq, &con->swork))
 476                         conn_put(con);
 477         } else {
 478                 conn_put(con);
 479         }
 480         return 0;
 481 }
 482
 483 void tipc_conn_terminate(struct tipc_server *s, int conid)
 484 {
 485         struct tipc_conn *con;
 486
 487         con = tipc_conn_lookup(s, conid);
 488         if (con) {
 489                 tipc_close_conn(con);
 490                 conn_put(con);
 491         }
 492 }
 493
 494 static void tipc_send_to_sock(struct tipc_conn *con)
 495 {
 496         int count = 0;
 497         struct tipc_server *s = con->server;
 498         struct outqueue_entry *e;
 499         struct msghdr msg;
 500         int ret;
 501
 502         spin_lock_bh(&con->outqueue_lock);
 503         while (1) {
 504                 e = list_entry(con->outqueue.next, struct outqueue_entry,
 505                                list);
 506                 if ((struct list_head *) e == &con->outqueue)
 507                         break;
 508                 spin_unlock_bh(&con->outqueue_lock);
 509
 510                 memset(&msg, 0, sizeof(msg));
 511                 msg.msg_flags = MSG_DONTWAIT;
 512
 513                 if (s->type == SOCK_DGRAM || s->type == SOCK_RDM) {
 514                         msg.msg_name = &e->dest;
 515                         msg.msg_namelen = sizeof(struct sockaddr_tipc);
 516                 }
 517                 ret = kernel_sendmsg(con->sock, &msg, &e->iov, 1,
 518                                      e->iov.iov_len);
 519                 if (ret == -EWOULDBLOCK || ret == 0) {
 520                         cond_resched();
 521                         goto out;
 522                 } else if (ret < 0) {
 523                         goto send_err;
 524                 }
 525
 526                 /* Don't starve users filling buffers */
 527                 if (++count >= MAX_SEND_MSG_COUNT) {
 528                         cond_resched();
 529                         count = 0;
 530                 }
 531
 532                 spin_lock_bh(&con->outqueue_lock);
 533                 list_del(&e->list);
 534                 tipc_free_entry(e);
 535         }
 536         spin_unlock_bh(&con->outqueue_lock);
 537 out:
 538         return;
 539
 540 send_err:
 541         tipc_close_conn(con);
 542 }
 543
 544 static void tipc_recv_work(struct work_struct *work)
 545 {
 546         struct tipc_conn *con = container_of(work, struct tipc_conn, rwork);
 547         int count = 0;
 548
 549         while (test_bit(CF_CONNECTED, &con->flags)) {
 550                 if (con->rx_action(con))
 551                         break;
 552
 553                 /* Don't flood Rx machine */
 554                 if (++count >= MAX_RECV_MSG_COUNT) {
 555                         cond_resched();
 556                         count = 0;
 557                 }
 558         }
 559         conn_put(con);
 560 }
 561
 562 static void tipc_send_work(struct work_struct *work)
 563 {
 564         struct tipc_conn *con = container_of(work, struct tipc_conn, swork);
 565
 566         if (test_bit(CF_CONNECTED, &con->flags))
 567                 tipc_send_to_sock(con);
 568
 569         conn_put(con);
 570 }
 571
 572 static void tipc_work_stop(struct tipc_server *s)
 573 {
 574         destroy_workqueue(s->rcv_wq);
 575         destroy_workqueue(s->send_wq);
 576 }
 577
 578 static int tipc_work_start(struct tipc_server *s)
 579 {
 580         s->rcv_wq = alloc_ordered_workqueue("tipc_rcv", 0);
 581         if (!s->rcv_wq) {
 582                 pr_err("can't start tipc receive workqueue\n");
 583                 return -ENOMEM;
 584         }
 585
 586         s->send_wq = alloc_ordered_workqueue("tipc_send", 0);
 587         if (!s->send_wq) {
 588                 pr_err("can't start tipc send workqueue\n");
 589                 destroy_workqueue(s->rcv_wq);
 590                 return -ENOMEM;
 591         }
 592
 593         return 0;
 594 }
 595
 596 int tipc_server_start(struct tipc_server *s)
 597 {
 598         int ret;
 599
 600         spin_lock_init(&s->idr_lock);
 601         idr_init(&s->conn_idr);
 602         s->idr_in_use = 0;
 603
 604         s->rcvbuf_cache = kmem_cache_create(s->name, s->max_rcvbuf_size,
 605                                             0, SLAB_HWCACHE_ALIGN, NULL);
 606         if (!s->rcvbuf_cache)
 607                 return -ENOMEM;
 608
 609         ret = tipc_work_start(s);
 610         if (ret < 0) {
 611                 kmem_cache_destroy(s->rcvbuf_cache);
 612                 return ret;
 613         }
 614         ret = tipc_open_listening_sock(s);
 615         if (ret < 0) {
 616                 tipc_work_stop(s);
 617                 kmem_cache_destroy(s->rcvbuf_cache);
 618                 return ret;
 619         }
 620         return ret;
 621 }
 622
 623 void tipc_server_stop(struct tipc_server *s)
 624 {
 625         struct tipc_conn *con;
 626         int total = 0;
 627         int id;
 628
 629         spin_lock_bh(&s->idr_lock);
 630         for (id = 0; total < s->idr_in_use; id++) {
 631                 con = idr_find(&s->conn_idr, id);
 632                 if (con) {
 633                         total++;
 634                         spin_unlock_bh(&s->idr_lock);
 635                         tipc_close_conn(con);
 636                         spin_lock_bh(&s->idr_lock);
 637                 }
 638         }
 639         spin_unlock_bh(&s->idr_lock);
 640
 641         tipc_work_stop(s);
 642         kmem_cache_destroy(s->rcvbuf_cache);
 643         idr_destroy(&s->conn_idr);
 644 }