cregit-Linux how code gets into the kernel

Release 4.11 net/tipc/server.c

Directory: net/tipc
/*
 * net/tipc/server.c: TIPC server infrastructure
 *
 * Copyright (c) 2012-2013, Wind River Systems
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the names of the copyright holders nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "server.h"
#include "core.h"
#include "socket.h"
#include <net/sock.h>
#include <linux/module.h>

/* Number of messages to send before rescheduling */

#define MAX_SEND_MSG_COUNT	25

#define MAX_RECV_MSG_COUNT	25

#define CF_CONNECTED		1

#define CF_SERVER		2


#define sock2con(x) ((struct tipc_conn *)(x)->sk_user_data)

/**
 * struct tipc_conn - TIPC connection structure
 * @kref: reference counter to connection object
 * @conid: connection identifier
 * @sock: socket handler associated with connection
 * @flags: indicates connection state
 * @server: pointer to connected server
 * @rwork: receive work item
 * @usr_data: user-specified field
 * @rx_action: what to do when connection socket is active
 * @outqueue: pointer to first outbound message in queue
 * @outqueue_lock: control access to the outqueue
 * @outqueue: list of connection objects for its server
 * @swork: send work item
 */

struct tipc_conn {
	
struct kref kref;
	
int conid;
	
struct socket *sock;
	
unsigned long flags;
	
struct tipc_server *server;
	
struct work_struct rwork;
	
int (*rx_action) (struct tipc_conn *con);
	
void *usr_data;
	
struct list_head outqueue;
	
spinlock_t outqueue_lock;
	
struct work_struct swork;
};

/* An entry waiting to be sent */

struct outqueue_entry {
	
struct list_head list;
	
struct kvec iov;
	
struct sockaddr_tipc dest;
};

static void tipc_recv_work(struct work_struct *work);
static void tipc_send_work(struct work_struct *work);
static void tipc_clean_outqueues(struct tipc_conn *con);


static void tipc_conn_kref_release(struct kref *kref) { struct tipc_conn *con = container_of(kref, struct tipc_conn, kref); struct tipc_server *s = con->server; struct sockaddr_tipc *saddr = s->saddr; struct socket *sock = con->sock; struct sock *sk; if (sock) { sk = sock->sk; if (test_bit(CF_SERVER, &con->flags)) { __module_get(sock->ops->owner); __module_get(sk->sk_prot_creator->owner); } saddr->scope = -TIPC_NODE_SCOPE; kernel_bind(sock, (struct sockaddr *)saddr, sizeof(*saddr)); sock_release(sock); con->sock = NULL; spin_lock_bh(&s->idr_lock); idr_remove(&s->conn_idr, con->conid); s->idr_in_use--; spin_unlock_bh(&s->idr_lock); } tipc_clean_outqueues(con); kfree(con); }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue13976.80%480.00%
Parthasarathy Bhuvaragan4223.20%120.00%
Total181100.00%5100.00%


static void conn_put(struct tipc_conn *con) { kref_put(&con->kref, tipc_conn_kref_release); }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue21100.00%1100.00%
Total21100.00%1100.00%


static void conn_get(struct tipc_conn *con) { kref_get(&con->kref); }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue19100.00%1100.00%
Total19100.00%1100.00%


static struct tipc_conn *tipc_conn_lookup(struct tipc_server *s, int conid) { struct tipc_conn *con; spin_lock_bh(&s->idr_lock); con = idr_find(&s->conn_idr, conid); if (con && test_bit(CF_CONNECTED, &con->flags)) conn_get(con); else con = NULL; spin_unlock_bh(&s->idr_lock); return con; }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue6180.26%150.00%
Parthasarathy Bhuvaragan1519.74%150.00%
Total76100.00%2100.00%


static void sock_data_ready(struct sock *sk) { struct tipc_conn *con; read_lock_bh(&sk->sk_callback_lock); con = sock2con(sk); if (con && test_bit(CF_CONNECTED, &con->flags)) { conn_get(con); if (!queue_work(con->server->rcv_wq, &con->rwork)) conn_put(con); } read_unlock_bh(&sk->sk_callback_lock); }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue8097.56%150.00%
Eric Dumazet22.44%150.00%
Total82100.00%2100.00%


static void sock_write_space(struct sock *sk) { struct tipc_conn *con; read_lock_bh(&sk->sk_callback_lock); con = sock2con(sk); if (con && test_bit(CF_CONNECTED, &con->flags)) { conn_get(con); if (!queue_work(con->server->send_wq, &con->swork)) conn_put(con); } read_unlock_bh(&sk->sk_callback_lock); }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue8097.56%150.00%
Eric Dumazet22.44%150.00%
Total82100.00%2100.00%


static void tipc_register_callbacks(struct socket *sock, struct tipc_conn *con) { struct sock *sk = sock->sk; write_lock_bh(&sk->sk_callback_lock); sk->sk_data_ready = sock_data_ready; sk->sk_write_space = sock_write_space; sk->sk_user_data = con; con->sock = sock; write_unlock_bh(&sk->sk_callback_lock); }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue65100.00%1100.00%
Total65100.00%1100.00%


static void tipc_unregister_callbacks(struct tipc_conn *con) { struct sock *sk = con->sock->sk; write_lock_bh(&sk->sk_callback_lock); sk->sk_user_data = NULL; write_unlock_bh(&sk->sk_callback_lock); }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue44100.00%1100.00%
Total44100.00%1100.00%


static void tipc_close_conn(struct tipc_conn *con) { struct tipc_server *s = con->server; if (test_and_clear_bit(CF_CONNECTED, &con->flags)) { tipc_unregister_callbacks(con); if (con->conid) s->tipc_conn_release(con->conid, con->usr_data); /* We shouldn't flush pending works as we may be in the * thread. In fact the races with pending rx/tx work structs * are harmless for us here as we have already deleted this * connection from server connection list. */ kernel_sock_shutdown(con->sock, SHUT_RDWR); conn_put(con); } }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue4156.16%250.00%
Parthasarathy Bhuvaragan3243.84%250.00%
Total73100.00%4100.00%


static struct tipc_conn *tipc_alloc_conn(struct tipc_server *s) { struct tipc_conn *con; int ret; con = kzalloc(sizeof(struct tipc_conn), GFP_ATOMIC); if (!con) return ERR_PTR(-ENOMEM); kref_init(&con->kref); INIT_LIST_HEAD(&con->outqueue); spin_lock_init(&con->outqueue_lock); INIT_WORK(&con->swork, tipc_send_work); INIT_WORK(&con->rwork, tipc_recv_work); spin_lock_bh(&s->idr_lock); ret = idr_alloc(&s->conn_idr, con, 0, 0, GFP_ATOMIC); if (ret < 0) { kfree(con); spin_unlock_bh(&s->idr_lock); return ERR_PTR(-ENOMEM); } con->conid = ret; s->idr_in_use++; spin_unlock_bh(&s->idr_lock); set_bit(CF_CONNECTED, &con->flags); con->server = s; return con; }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue182100.00%1100.00%
Total182100.00%1100.00%


static int tipc_receive_from_sock(struct tipc_conn *con) { struct msghdr msg = {}; struct tipc_server *s = con->server; struct sockaddr_tipc addr; struct kvec iov; void *buf; int ret; buf = kmem_cache_alloc(s->rcvbuf_cache, GFP_ATOMIC); if (!buf) { ret = -ENOMEM; goto out_close; } iov.iov_base = buf; iov.iov_len = s->max_rcvbuf_size; msg.msg_name = &addr; ret = kernel_recvmsg(con->sock, &msg, &iov, 1, iov.iov_len, MSG_DONTWAIT); if (ret <= 0) { kmem_cache_free(s->rcvbuf_cache, buf); goto out_close; } s->tipc_conn_recvmsg(sock_net(con->sock->sk), con->conid, &addr, con->usr_data, buf, ret); kmem_cache_free(s->rcvbuf_cache, buf); return 0; out_close: if (ret != -EWOULDBLOCK) tipc_close_conn(con); else if (ret == 0) /* Don't return success if we really got EOF */ ret = -EAGAIN; return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue202100.00%2100.00%
Total202100.00%2100.00%


static int tipc_accept_from_sock(struct tipc_conn *con) { struct tipc_server *s = con->server; struct socket *sock = con->sock; struct socket *newsock; struct tipc_conn *newcon; int ret; ret = kernel_accept(sock, &newsock, O_NONBLOCK); if (ret < 0) return ret; newcon = tipc_alloc_conn(con->server); if (IS_ERR(newcon)) { ret = PTR_ERR(newcon); sock_release(newsock); return ret; } newcon->rx_action = tipc_receive_from_sock; tipc_register_callbacks(newsock, newcon); /* Notify that new connection is incoming */ newcon->usr_data = s->tipc_conn_new(newcon->conid); if (!newcon->usr_data) { sock_release(newsock); return -ENOMEM; } /* Wake up receive process in case of 'SYN+' message */ newsock->sk->sk_data_ready(newsock->sk); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue156100.00%3100.00%
Total156100.00%3100.00%


static struct socket *tipc_create_listen_sock(struct tipc_conn *con) { struct tipc_server *s = con->server; struct socket *sock = NULL; int ret; ret = sock_create_kern(s->net, AF_TIPC, SOCK_SEQPACKET, 0, &sock); if (ret < 0) return NULL; ret = kernel_setsockopt(sock, SOL_TIPC, TIPC_IMPORTANCE, (char *)&s->imp, sizeof(s->imp)); if (ret < 0) goto create_err; ret = kernel_bind(sock, (struct sockaddr *)s->saddr, sizeof(*s->saddr)); if (ret < 0) goto create_err; switch (s->type) { case SOCK_STREAM: case SOCK_SEQPACKET: con->rx_action = tipc_accept_from_sock; ret = kernel_listen(sock, 0); if (ret < 0) goto create_err; break; case SOCK_DGRAM: case SOCK_RDM: con->rx_action = tipc_receive_from_sock; break; default: pr_err("Unknown socket type %d\n", s->type); goto create_err; } /* As server's listening socket owner and creator is the same module, * we have to decrease TIPC module reference count to guarantee that * it remains zero after the server socket is created, otherwise, * executing "rmmod" command is unable to make TIPC module deleted * after TIPC module is inserted successfully. * * However, the reference count is ever increased twice in * sock_create_kern(): one is to increase the reference count of owner * of TIPC socket's proto_ops struct; another is to increment the * reference count of owner of TIPC proto struct. Therefore, we must * decrement the module reference count twice to ensure that it keeps * zero after server's listening socket is created. Of course, we * must bump the module reference count twice as well before the socket * is closed. */ module_put(sock->ops->owner); module_put(sock->sk->sk_prot_creator->owner); set_bit(CF_SERVER, &con->flags); return sock; create_err: kernel_sock_shutdown(sock, SHUT_RDWR); sock_release(sock); return NULL; }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue244100.00%5100.00%
Total244100.00%5100.00%


static int tipc_open_listening_sock(struct tipc_server *s) { struct socket *sock; struct tipc_conn *con; con = tipc_alloc_conn(s); if (IS_ERR(con)) return PTR_ERR(con); sock = tipc_create_listen_sock(con); if (!sock) { idr_remove(&s->conn_idr, con->conid); s->idr_in_use--; kfree(con); return -EINVAL; } tipc_register_callbacks(sock, con); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue91100.00%2100.00%
Total91100.00%2100.00%


static struct outqueue_entry *tipc_alloc_entry(void *data, int len) { struct outqueue_entry *entry; void *buf; entry = kmalloc(sizeof(struct outqueue_entry), GFP_ATOMIC); if (!entry) return NULL; buf = kmemdup(data, len, GFP_ATOMIC); if (!buf) { kfree(entry); return NULL; } entry->iov.iov_base = buf; entry->iov.iov_len = len; return entry; }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue8796.67%150.00%
Amitoj Kaur Chawla33.33%150.00%
Total90100.00%2100.00%


static void tipc_free_entry(struct outqueue_entry *e) { kfree(e->iov.iov_base); kfree(e); }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue25100.00%1100.00%
Total25100.00%1100.00%


static void tipc_clean_outqueues(struct tipc_conn *con) { struct outqueue_entry *e, *safe; spin_lock_bh(&con->outqueue_lock); list_for_each_entry_safe(e, safe, &con->outqueue, list) { list_del(&e->list); tipc_free_entry(e); } spin_unlock_bh(&con->outqueue_lock); }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue60100.00%1100.00%
Total60100.00%1100.00%


int tipc_conn_sendmsg(struct tipc_server *s, int conid, struct sockaddr_tipc *addr, void *data, size_t len) { struct outqueue_entry *e; struct tipc_conn *con; con = tipc_conn_lookup(s, conid); if (!con) return -EINVAL; if (!test_bit(CF_CONNECTED, &con->flags)) { conn_put(con); return 0; } e = tipc_alloc_entry(data, len); if (!e) { conn_put(con); return -ENOMEM; } if (addr) memcpy(&e->dest, addr, sizeof(struct sockaddr_tipc)); spin_lock_bh(&con->outqueue_lock); list_add_tail(&e->list, &con->outqueue); spin_unlock_bh(&con->outqueue_lock); if (!queue_work(s->send_wq, &con->swork)) conn_put(con); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue15086.71%150.00%
Parthasarathy Bhuvaragan2313.29%150.00%
Total173100.00%2100.00%


void tipc_conn_terminate(struct tipc_server *s, int conid) { struct tipc_conn *con; con = tipc_conn_lookup(s, conid); if (con) { tipc_close_conn(con); conn_put(con); } }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue43100.00%1100.00%
Total43100.00%1100.00%


static void tipc_send_to_sock(struct tipc_conn *con) { int count = 0; struct tipc_server *s = con->server; struct outqueue_entry *e; struct msghdr msg; int ret; spin_lock_bh(&con->outqueue_lock); while (test_bit(CF_CONNECTED, &con->flags)) { e = list_entry(con->outqueue.next, struct outqueue_entry, list); if ((struct list_head *) e == &con->outqueue) break; spin_unlock_bh(&con->outqueue_lock); memset(&msg, 0, sizeof(msg)); msg.msg_flags = MSG_DONTWAIT; if (s->type == SOCK_DGRAM || s->type == SOCK_RDM) { msg.msg_name = &e->dest; msg.msg_namelen = sizeof(struct sockaddr_tipc); } ret = kernel_sendmsg(con->sock, &msg, &e->iov, 1, e->iov.iov_len); if (ret == -EWOULDBLOCK || ret == 0) { cond_resched(); goto out; } else if (ret < 0) { goto send_err; } /* Don't starve users filling buffers */ if (++count >= MAX_SEND_MSG_COUNT) { cond_resched(); count = 0; } spin_lock_bh(&con->outqueue_lock); list_del(&e->list); tipc_free_entry(e); } spin_unlock_bh(&con->outqueue_lock); out: return; send_err: tipc_close_conn(con); }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue25596.59%150.00%
Parthasarathy Bhuvaragan93.41%150.00%
Total264100.00%2100.00%


static void tipc_recv_work(struct work_struct *work) { struct tipc_conn *con = container_of(work, struct tipc_conn, rwork); int count = 0; while (test_bit(CF_CONNECTED, &con->flags)) { if (con->rx_action(con)) break; /* Don't flood Rx machine */ if (++count >= MAX_RECV_MSG_COUNT) { cond_resched(); count = 0; } } conn_put(con); }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue77100.00%1100.00%
Total77100.00%1100.00%


static void tipc_send_work(struct work_struct *work) { struct tipc_conn *con = container_of(work, struct tipc_conn, swork); if (test_bit(CF_CONNECTED, &con->flags)) tipc_send_to_sock(con); conn_put(con); }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue48100.00%1100.00%
Total48100.00%1100.00%


static void tipc_work_stop(struct tipc_server *s) { destroy_workqueue(s->rcv_wq); destroy_workqueue(s->send_wq); }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue25100.00%1100.00%
Total25100.00%1100.00%


static int tipc_work_start(struct tipc_server *s) { s->rcv_wq = alloc_ordered_workqueue("tipc_rcv", 0); if (!s->rcv_wq) { pr_err("can't start tipc receive workqueue\n"); return -ENOMEM; } s->send_wq = alloc_ordered_workqueue("tipc_send", 0); if (!s->send_wq) { pr_err("can't start tipc send workqueue\n"); destroy_workqueue(s->rcv_wq); return -ENOMEM; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue7594.94%150.00%
Parthasarathy Bhuvaragan45.06%150.00%
Total79100.00%2100.00%


int tipc_server_start(struct tipc_server *s) { int ret; spin_lock_init(&s->idr_lock); idr_init(&s->conn_idr); s->idr_in_use = 0; s->rcvbuf_cache = kmem_cache_create(s->name, s->max_rcvbuf_size, 0, SLAB_HWCACHE_ALIGN, NULL); if (!s->rcvbuf_cache) return -ENOMEM; ret = tipc_work_start(s); if (ret < 0) { kmem_cache_destroy(s->rcvbuf_cache); return ret; } ret = tipc_open_listening_sock(s); if (ret < 0) { tipc_work_stop(s); kmem_cache_destroy(s->rcvbuf_cache); return ret; } return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue125100.00%2100.00%
Total125100.00%2100.00%


void tipc_server_stop(struct tipc_server *s) { struct tipc_conn *con; int id; spin_lock_bh(&s->idr_lock); for (id = 0; s->idr_in_use; id++) { con = idr_find(&s->conn_idr, id); if (con) { spin_unlock_bh(&s->idr_lock); tipc_close_conn(con); spin_lock_bh(&s->idr_lock); } } spin_unlock_bh(&s->idr_lock); tipc_work_stop(s); kmem_cache_destroy(s->rcvbuf_cache); idr_destroy(&s->conn_idr); }

Contributors

PersonTokensPropCommitsCommitProp
Ying Xue108100.00%1100.00%
Total108100.00%1100.00%


Overall Contributors

PersonTokensPropCommitsCommitProp
Ying Xue264895.22%1157.89%
Parthasarathy Bhuvaragan1254.49%526.32%
Eric Dumazet40.14%15.26%
Amitoj Kaur Chawla30.11%15.26%
Stephen Hemminger10.04%15.26%
Total2781100.00%19100.00%
Directory: net/tipc
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.