cregit-Linux how code gets into the kernel

Release 4.8 net/tipc/socket.c

Directory: net/tipc
/*
 * net/tipc/socket.c: TIPC socket API
 *
 * Copyright (c) 2001-2007, 2012-2015, Ericsson AB
 * Copyright (c) 2004-2008, 2010-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 <linux/rhashtable.h>
#include "core.h"
#include "name_table.h"
#include "node.h"
#include "link.h"
#include "name_distr.h"
#include "socket.h"
#include "bcast.h"
#include "netlink.h"


#define SS_LISTENING		-1	
/* socket is listening */

#define SS_READY		-2	
/* socket is connectionless */


#define CONN_TIMEOUT_DEFAULT	8000	
/* default connect timeout = 8s */

#define CONN_PROBING_INTERVAL	msecs_to_jiffies(3600000)  
/* [ms] => 1 h */

#define TIPC_FWD_MSG		1

#define TIPC_CONN_OK		0

#define TIPC_CONN_PROBING	1

#define TIPC_MAX_PORT		0xffffffff

#define TIPC_MIN_PORT		1

/**
 * struct tipc_sock - TIPC socket structure
 * @sk: socket - interacts with 'port' and with user via the socket API
 * @connected: non-zero if port is currently connected to a peer port
 * @conn_type: TIPC type used when connection was established
 * @conn_instance: TIPC instance used when connection was established
 * @published: non-zero if port has one or more associated names
 * @max_pkt: maximum packet size "hint" used when building messages sent by port
 * @portid: unique port identity in TIPC socket hash table
 * @phdr: preformatted message header used when sending messages
 * @port_list: adjacent ports in TIPC's global list of ports
 * @publications: list of publications for port
 * @pub_count: total # of publications port has made during its lifetime
 * @probing_state:
 * @probing_intv:
 * @conn_timeout: the time we can wait for an unresponded setup request
 * @dupl_rcvcnt: number of bytes counted twice, in both backlog and rcv queue
 * @link_cong: non-zero if owner must sleep because of link congestion
 * @sent_unacked: # messages sent by socket, and not yet acked by peer
 * @rcv_unacked: # messages read by user, but not yet acked back to peer
 * @remote: 'connected' peer for dgram/rdm
 * @node: hash table node
 * @rcu: rcu struct for tipc_sock
 */

struct tipc_sock {
	
struct sock sk;
	
int connected;
	
u32 conn_type;
	
u32 conn_instance;
	
int published;
	
u32 max_pkt;
	
u32 portid;
	
struct tipc_msg phdr;
	
struct list_head sock_list;
	
struct list_head publications;
	
u32 pub_count;
	
u32 probing_state;
	
unsigned long probing_intv;
	
uint conn_timeout;
	
atomic_t dupl_rcvcnt;
	
bool link_cong;
	
u16 snt_unacked;
	
u16 snd_win;
	
u16 peer_caps;
	
u16 rcv_unacked;
	
u16 rcv_win;
	
struct sockaddr_tipc remote;
	
struct rhash_head node;
	
struct rcu_head rcu;
};

static int tipc_backlog_rcv(struct sock *sk, struct sk_buff *skb);
static void tipc_data_ready(struct sock *sk);
static void tipc_write_space(struct sock *sk);
static void tipc_sock_destruct(struct sock *sk);
static int tipc_release(struct socket *sock);
static int tipc_accept(struct socket *sock, struct socket *new_sock, int flags);
static int tipc_wait_for_sndmsg(struct socket *sock, long *timeo_p);
static void tipc_sk_timeout(unsigned long data);
static int tipc_sk_publish(struct tipc_sock *tsk, uint scope,
			   struct tipc_name_seq const *seq);
static int tipc_sk_withdraw(struct tipc_sock *tsk, uint scope,
			    struct tipc_name_seq const *seq);
static struct tipc_sock *tipc_sk_lookup(struct net *net, u32 portid);
static int tipc_sk_insert(struct tipc_sock *tsk);
static void tipc_sk_remove(struct tipc_sock *tsk);
static int __tipc_send_stream(struct socket *sock, struct msghdr *m,
			      size_t dsz);
static int __tipc_sendmsg(struct socket *sock, struct msghdr *m, size_t dsz);


static const struct proto_ops packet_ops;

static const struct proto_ops stream_ops;

static const struct proto_ops msg_ops;

static struct proto tipc_proto;


static const struct rhashtable_params tsk_rht_params;

/*
 * Revised TIPC socket locking policy:
 *
 * Most socket operations take the standard socket lock when they start
 * and hold it until they finish (or until they need to sleep).  Acquiring
 * this lock grants the owner exclusive access to the fields of the socket
 * data structures, with the exception of the backlog queue.  A few socket
 * operations can be done without taking the socket lock because they only
 * read socket information that never changes during the life of the socket.
 *
 * Socket operations may acquire the lock for the associated TIPC port if they
 * need to perform an operation on the port.  If any routine needs to acquire
 * both the socket lock and the port lock it must take the socket lock first
 * to avoid the risk of deadlock.
 *
 * The dispatcher handling incoming messages cannot grab the socket lock in
 * the standard fashion, since invoked it runs at the BH level and cannot block.
 * Instead, it checks to see if the socket lock is currently owned by someone,
 * and either handles the message itself or adds it to the socket's backlog
 * queue; in the latter case the queued message is processed once the process
 * owning the socket lock releases it.
 *
 * NOTE: Releasing the socket lock while an operation is sleeping overcomes
 * the problem of a blocked socket operation preventing any other operations
 * from occurring.  However, applications must be careful if they have
 * multiple threads trying to send (or receive) on the same socket, as these
 * operations might interfere with each other.  For example, doing a connect
 * and a receive at the same time might allow the receive to consume the
 * ACK message meant for the connect.  While additional work could be done
 * to try and overcome this, it doesn't seem to be worthwhile at the present.
 *
 * NOTE: Releasing the socket lock while an operation is sleeping also ensures
 * that another operation that must be performed in a non-blocking manner is
 * not delayed for very long because the lock has already been taken.
 *
 * NOTE: This code assumes that certain fields of a port/socket pair are
 * constant over its lifetime; such fields can be examined without taking
 * the socket lock and/or port lock, and do not need to be re-read even
 * after resuming processing after waiting.  These fields include:
 *   - socket type
 *   - pointer to socket sk structure (aka tipc_sock structure)
 *   - pointer to port structure
 *   - port reference
 */


static u32 tsk_own_node(struct tipc_sock *tsk) { return msg_prevnode(&tsk->phdr); }

Contributors

PersonTokensPropCommitsCommitProp
jon paul maloyjon paul maloy20100.00%1100.00%
Total20100.00%1100.00%


static u32 tsk_peer_node(struct tipc_sock *tsk) { return msg_destnode(&tsk->phdr); }

Contributors

PersonTokensPropCommitsCommitProp
jon paul maloyjon paul maloy20100.00%2100.00%
Total20100.00%2100.00%


static u32 tsk_peer_port(struct tipc_sock *tsk) { return msg_destport(&tsk->phdr); }

Contributors

PersonTokensPropCommitsCommitProp
jon paul maloyjon paul maloy20100.00%2100.00%
Total20100.00%2100.00%


static bool tsk_unreliable(struct tipc_sock *tsk) { return msg_src_droppable(&tsk->phdr) != 0; }

Contributors

PersonTokensPropCommitsCommitProp
jon paul maloyjon paul maloy22100.00%2100.00%
Total22100.00%2100.00%


static void tsk_set_unreliable(struct tipc_sock *tsk, bool unreliable) { msg_set_src_droppable(&tsk->phdr, unreliable ? 1 : 0); }

Contributors

PersonTokensPropCommitsCommitProp
jon paul maloyjon paul maloy28100.00%2100.00%
Total28100.00%2100.00%


static bool tsk_unreturnable(struct tipc_sock *tsk) { return msg_dest_droppable(&tsk->phdr) != 0; }

Contributors

PersonTokensPropCommitsCommitProp
jon paul maloyjon paul maloy22100.00%2100.00%
Total22100.00%2100.00%


static void tsk_set_unreturnable(struct tipc_sock *tsk, bool unreturnable) { msg_set_dest_droppable(&tsk->phdr, unreturnable ? 1 : 0); }

Contributors

PersonTokensPropCommitsCommitProp
jon paul maloyjon paul maloy28100.00%2100.00%
Total28100.00%2100.00%


static int tsk_importance(struct tipc_sock *tsk) { return msg_importance(&tsk->phdr); }

Contributors

PersonTokensPropCommitsCommitProp
jon paul maloyjon paul maloy20100.00%2100.00%
Total20100.00%2100.00%


static int tsk_set_importance(struct tipc_sock *tsk, int imp) { if (imp > TIPC_CRITICAL_IMPORTANCE) return -EINVAL; msg_set_importance(&tsk->phdr, (u32)imp); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
jon paul maloyjon paul maloy40100.00%2100.00%
Total40100.00%2100.00%


static struct tipc_sock *tipc_sk(const struct sock *sk) { return container_of(sk, struct tipc_sock, sk); }

Contributors

PersonTokensPropCommitsCommitProp
jon paul maloyjon paul maloy25100.00%1100.00%
Total25100.00%1100.00%


static bool tsk_conn_cong(struct tipc_sock *tsk) { return tsk->snt_unacked >= tsk->snd_win; }

Contributors

PersonTokensPropCommitsCommitProp
jon paul maloyjon paul maloy20100.00%2100.00%
Total20100.00%2100.00%

/* tsk_blocks(): translate a buffer size in bytes to number of * advertisable blocks, taking into account the ratio truesize(len)/len * We can trust that this ratio is always < 4 for len >= FLOWCTL_BLK_SZ */
static u16 tsk_adv_blocks(int len) { return len / FLOWCTL_BLK_SZ / 4; }

Contributors

PersonTokensPropCommitsCommitProp
jon paul maloyjon paul maloy16100.00%1100.00%
Total16100.00%1100.00%

/* tsk_inc(): increment counter for sent or received data * - If block based flow control is not supported by peer we * fall back to message based ditto, incrementing the counter */
static u16 tsk_inc(struct tipc_sock *tsk, int msglen) { if (likely(tsk->peer_caps & TIPC_BLOCK_FLOWCTL)) return ((msglen / FLOWCTL_BLK_SZ) + 1); return 1; }

Contributors

PersonTokensPropCommitsCommitProp
jon paul maloyjon paul maloy39100.00%2100.00%
Total39100.00%2100.00%

/** * tsk_advance_rx_queue - discard first buffer in socket receive queue * * Caller must hold socket lock */
static void tsk_advance_rx_queue(struct sock *sk) { kfree_skb(__skb_dequeue(&sk->sk_receive_queue)); }

Contributors

PersonTokensPropCommitsCommitProp
allan stephensallan stephens1150.00%250.00%
per lidenper liden1045.45%125.00%
jon paul maloyjon paul maloy14.55%125.00%
Total22100.00%4100.00%

/* tipc_sk_respond() : send response message back to sender */
static void tipc_sk_respond(struct sock *sk, struct sk_buff *skb, int err) { u32 selector; u32 dnode; u32 onode = tipc_own_addr(sock_net(sk)); if (!tipc_msg_reverse(onode, &skb, err)) return; dnode = msg_destnode(buf_msg(skb)); selector = msg_origport(buf_msg(skb)); tipc_node_xmit_skb(sock_net(sk), skb, dnode, selector); }

Contributors

PersonTokensPropCommitsCommitProp
jon paul maloyjon paul maloy5869.05%550.00%
ying xueying xue1011.90%330.00%
allan stephensallan stephens89.52%110.00%
per lidenper liden89.52%110.00%
Total84100.00%10100.00%

/** * tsk_rej_rx_queue - reject all buffers in socket receive queue * * Caller must hold socket lock */
static void tsk_rej_rx_queue(struct sock *sk) { struct sk_buff *skb; while ((skb = __skb_dequeue(&sk->sk_receive_queue))) tipc_sk_respond(sk, skb, TIPC_ERR_NO_PORT); }

Contributors

PersonTokensPropCommitsCommitProp
jon paul maloyjon paul maloy39100.00%2100.00%
Total39100.00%2100.00%

/* tsk_peer_msg - verify if message was sent by connected port's peer * * Handles cases where the node's network address has changed from * the default of <0.0.0> to its configured setting. */
static bool tsk_peer_msg(struct tipc_sock *tsk, struct tipc_msg *msg) { struct tipc_net *tn = net_generic(sock_net(&tsk->sk), tipc_net_id); u32 peer_port = tsk_peer_port(tsk); u32 orig_node; u32 peer_node; if (unlikely(!tsk->connected)) return false; if (unlikely(msg_origport(msg) != peer_port)) return false; orig_node = msg_orignode(msg); peer_node = tsk_peer_node(tsk); if (likely(orig_node == peer_node)) return true; if (!orig_node && (peer_node == tn->own_addr)) return true; if (!peer_node && (orig_node == tn->own_addr)) return true; return false; }

Contributors

PersonTokensPropCommitsCommitProp
jon paul maloyjon paul maloy11382.48%266.67%
ying xueying xue2417.52%133.33%
Total137100.00%3100.00%

/** * tipc_sk_create - create a TIPC socket * @net: network namespace (must be default network) * @sock: pre-allocated socket structure * @protocol: protocol indicator (must be 0) * @kern: caused by kernel or by userspace? * * This routine creates additional data structures used by the TIPC socket, * initializes them, and links them together. * * Returns 0 on success, errno otherwise */
static int tipc_sk_create(struct net *net, struct socket *sock, int protocol, int kern) { struct tipc_net *tn; const struct proto_ops *ops; socket_state state; struct sock *sk; struct tipc_sock *tsk; struct tipc_msg *msg; /* Validate arguments */ if (unlikely(protocol != 0)) return -EPROTONOSUPPORT; switch (sock->type) { case SOCK_STREAM: ops = &stream_ops; state = SS_UNCONNECTED; break; case SOCK_SEQPACKET: ops = &packet_ops; state = SS_UNCONNECTED; break; case SOCK_DGRAM: case SOCK_RDM: ops = &msg_ops; state = SS_READY; break; default: return -EPROTOTYPE; } /* Allocate socket's protocol area */ sk = sk_alloc(net, AF_TIPC, GFP_KERNEL, &tipc_proto, kern); if (sk == NULL) return -ENOMEM; tsk = tipc_sk(sk); tsk->max_pkt = MAX_PKT_DEFAULT; INIT_LIST_HEAD(&tsk->publications); msg = &tsk->phdr; tn = net_generic(sock_net(sk), tipc_net_id); tipc_msg_init(tn->own_addr, msg, TIPC_LOW_IMPORTANCE, TIPC_NAMED_MSG, NAMED_H_SIZE, 0); /* Finish initializing socket data structures */ sock->ops = ops; sock->state = state; sock_init_data(sock, sk); if (tipc_sk_insert(tsk)) { pr_warn("Socket create failed; port number exhausted\n"); return -EINVAL; } msg_set_origport(msg, tsk->portid); setup_timer(&sk->sk_timer, tipc_sk_timeout, (unsigned long)tsk); sk->sk_backlog_rcv = tipc_backlog_rcv; sk->sk_rcvbuf = sysctl_tipc_rmem[1]; sk->sk_data_ready = tipc_data_ready; sk->sk_write_space = tipc_write_space; sk->sk_destruct = tipc_sock_destruct; tsk->conn_timeout = CONN_TIMEOUT_DEFAULT; atomic_set(&tsk->dupl_rcvcnt, 0); /* Start out with safe limits until we receive an advertised window */ tsk->snd_win = tsk_adv_blocks(RCVBUF_MIN); tsk->rcv_win = tsk->snd_win; if (sock->state == SS_READY) { tsk_set_unreturnable(tsk, true); if (sock->type == SOCK_DGRAM) tsk_set_unreliable(tsk, true); } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
jon paul maloyjon paul maloy10929.54%932.14%
per lidenper liden10829.27%13.57%
allan stephensallan stephens7620.60%414.29%
ying xueying xue6116.53%932.14%
eric w. biedermaneric w. biederman92.44%27.14%
eric pariseric paris30.81%13.57%
erik hugneerik hugne20.54%13.57%
masanari iidamasanari iida10.27%13.57%
Total369100.00%28100.00%


static void tipc_sk_callback(struct rcu_head *head) { struct tipc_sock *tsk = container_of(head, struct tipc_sock, rcu); sock_put(&tsk->sk); }

Contributors

PersonTokensPropCommitsCommitProp
ying xueying xue34100.00%1100.00%
Total34100.00%1100.00%

/** * tipc_release - destroy a TIPC socket * @sock: socket to destroy * * This routine cleans up any messages that are still queued on the socket. * For DGRAM and RDM socket types, all queued messages are rejected. * For SEQPACKET and STREAM socket types, the first message is rejected * and any others are discarded. (If the first message on a STREAM socket * is partially-read, it is discarded and the next one is rejected instead.) * * NOTE: Rejected messages are not necessarily returned to the sender! They * are returned or discarded according to the "destination droppable" setting * specified for the message by the sender. * * Returns 0 on success, errno otherwise */
static int tipc_release(struct socket *sock) { struct sock *sk = sock->sk; struct net *net; struct tipc_sock *tsk; struct sk_buff *skb; u32 dnode; /* * Exit if socket isn't fully initialized (occurs when a failed accept() * releases a pre-allocated child socket that was never used) */ if (sk == NULL) return 0; net = sock_net(sk); tsk = tipc_sk(sk); lock_sock(sk); /* * Reject all unreceived messages, except on an active connection * (which disconnects locally & sends a 'FIN+' to peer) */ dnode = tsk_peer_node(tsk); while (sock->state != SS_DISCONNECTING) { skb = __skb_dequeue(&sk->sk_receive_queue); if (skb == NULL) break; if (TIPC_SKB_CB(skb)->handle != NULL) kfree_skb(skb); else { if ((sock->state == SS_CONNECTING) || (sock->state == SS_CONNECTED)) { sock->state = SS_DISCONNECTING; tsk->connected = 0; tipc_node_remove_conn(net, dnode, tsk->portid); } tipc_sk_respond(sk, skb, TIPC_ERR_NO_PORT); } } tipc_sk_withdraw(tsk, 0, NULL); sk_stop_timer(sk, &sk->sk_timer); tipc_sk_remove(tsk); if (tsk->connected) { skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, TIPC_CONN_MSG, SHORT_H_SIZE, 0, dnode, tsk_own_node(tsk), tsk_peer_port(tsk), tsk->portid, TIPC_ERR_NO_PORT); if (skb) tipc_node_xmit_skb(net, skb, dnode, tsk->portid); tipc_node_remove_conn(net, dnode, tsk->portid); } /* Reject any messages that accumulated in backlog queue */ sock->state = SS_DISCONNECTING; release_sock(sk); call_rcu(&tsk->rcu, tipc_sk_callback); sock->sk = NULL; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
jon paul maloyjon paul maloy10535.59%1041.67%
per lidenper liden8729.49%14.17%
allan stephensallan stephens5317.97%28.33%
ying xueying xue4113.90%833.33%
sasha levinsasha levin72.37%14.17%
geert uytterhoevengeert uytterhoeven10.34%14.17%
sam ravnborgsam ravnborg10.34%14.17%
Total295100.00%24100.00%

/** * tipc_bind - associate or disassocate TIPC name(s) with a socket * @sock: socket structure * @uaddr: socket address describing name(s) and desired operation * @uaddr_len: size of socket address data structure * * Name and name sequence binding is indicated using a positive scope value; * a negative scope value unbinds the specified name. Specifying no name * (i.e. a socket address length of 0) unbinds all names from the socket. * * Returns 0 on success, errno otherwise * * NOTE: This routine doesn't need to take the socket lock since it doesn't * access any non-constant socket information. */
static int tipc_bind(struct socket *sock, struct sockaddr *uaddr, int uaddr_len) { struct sock *sk = sock->sk; struct sockaddr_tipc *addr = (struct sockaddr_tipc *)uaddr; struct tipc_sock *tsk = tipc_sk(sk); int res = -EINVAL; lock_sock(sk); if (unlikely(!uaddr_len)) { res = tipc_sk_withdraw(tsk, 0, NULL); goto exit; } if (uaddr_len < sizeof(struct sockaddr_tipc)) { res = -EINVAL; goto exit; } if (addr->family != AF_TIPC) { res = -EAFNOSUPPORT; goto exit; } if (addr->addrtype == TIPC_ADDR_NAME) addr->addr.nameseq.upper = addr->addr.nameseq.lower; else if (addr->addrtype != TIPC_ADDR_NAMESEQ) { res = -EAFNOSUPPORT; goto exit; } if ((addr->addr.nameseq.type < TIPC_RESERVED_TYPES) && (addr->addr.nameseq.type != TIPC_TOP_SRV) && (addr->addr.nameseq.type != TIPC_CFG_SRV)) { res = -EACCES; goto exit; } res = (addr->scope > 0) ? tipc_sk_publish(tsk, addr->scope, &addr->addr.nameseq) : tipc_sk_withdraw(tsk, -addr->scope, &addr->addr.nameseq); exit: release_sock(sk); return res; }

Contributors

PersonTokensPropCommitsCommitProp
per lidenper liden13550.56%110.00%
ying xueying xue10137.83%440.00%
allan stephensallan stephens217.87%220.00%
jon paul maloyjon paul maloy93.37%220.00%
sam ravnborgsam ravnborg10.37%110.00%
Total267100.00%10100.00%

/** * tipc_getname - get port ID of socket or peer socket * @sock: socket structure * @uaddr: area for returned socket address * @uaddr_len: area for returned length of socket address * @peer: 0 = own ID, 1 = current peer ID, 2 = current/former peer ID * * Returns 0 on success, errno otherwise * * NOTE: This routine doesn't need to take the socket lock since it only * accesses socket information that is unchanging (or which changes in * a completely predictable manner). */
static int tipc_getname(struct socket *sock, struct sockaddr *uaddr, int *uaddr_len, int peer) { struct sockaddr_tipc *addr = (struct sockaddr_tipc *)uaddr; struct tipc_sock *tsk = tipc_sk(sock->sk); struct tipc_net *tn = net_generic(sock_net(sock->sk), tipc_net_id); memset(addr, 0, sizeof(*addr)); if (peer) { if ((sock->state != SS_CONNECTED) && ((peer != 2) || (sock->state != SS_DISCONNECTING))) return -ENOTCONN; addr->addr.id.ref = tsk_peer_port(tsk); addr->addr.id.node = tsk_peer_node(tsk); } else { addr->addr.id.ref = tsk->portid; addr->addr.id.node = tn->own_addr; } *uaddr_len = sizeof(*addr); addr->addrtype = TIPC_ADDR_ID; addr->family = AF_TIPC; addr->scope = 0; addr->addr.name.domain = 0; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
allan stephensallan stephens8239.81%327.27%
per lidenper liden7737.38%19.09%
ying xueying xue2210.68%327.27%
vasiliy kulikovvasiliy kulikov136.31%19.09%
jon paul maloyjon paul maloy125.83%327.27%
Total206100.00%11100.00%

/** * tipc_poll - read and possibly block on pollmask * @file: file structure associated with the socket * @sock: socket for which to calculate the poll bits * @wait: ??? * * Returns pollmask value * * COMMENTARY: * It appears that the usual socket locking mechanisms are not useful here * since the pollmask info is potentially out-of-date the moment this routine * exits. TCP and other protocols seem to rely on higher level poll routines * to handle any preventable race conditions, so TIPC will do the same ... * * TIPC sets the returned events as follows: * * socket state flags set * ------------ --------- * unconnected no read flags * POLLOUT if port is not congested * * connecting POLLIN/POLLRDNORM if ACK/NACK in rx queue * no write flags * * connected POLLIN/POLLRDNORM if data in rx queue * POLLOUT if port is not congested * * disconnecting POLLIN/POLLRDNORM/POLLHUP * no write flags * * listening POLLIN if SYN in rx queue * no write flags * * ready POLLIN/POLLRDNORM if data in rx queue * [connectionless] POLLOUT (since port cannot be congested) * * IMPORTANT: The fact that a read or write operation is indicated does NOT * imply that the operation will succeed, merely that it should be performed * and will not block. */
static unsigned int tipc_poll(struct file *file, struct socket *sock, poll_table *wait) { struct sock *sk = sock->sk; struct tipc_sock *tsk = tipc_sk(sk); u32 mask = 0; sock_poll_wait(file, sk_sleep(sk), wait); switch ((int)sock->state) { case SS_UNCONNECTED: if (!tsk->link_cong) mask |= POLLOUT; break; case SS_READY: case SS_CONNECTED: if (!tsk->link_cong && !tsk_conn_cong(tsk)) mask |= POLLOUT; /* fall thru' */ case SS_CONNECTING: case SS_LISTENING: if (!skb_queue_empty(&sk->sk_receive_queue)) mask |= (POLLIN | POLLRDNORM); break; case SS_DISCONNECTING: mask = (POLLIN | POLLRDNORM | POLLHUP); break; } return mask; }

Contributors

PersonTokensPropCommitsCommitProp
allan stephensallan stephens8154.00%220.00%
per lidenper liden3120.67%110.00%
jon paul maloyjon paul maloy2013.33%330.00%
erik hugneerik hugne138.67%110.00%
eric dumazeteric dumazet32.00%110.00%
ying xueying xue21.33%220.00%
Total150100.00%10100.00%

/** * tipc_sendmcast - send multicast message * @sock: socket structure * @seq: destination address * @msg: message to send * @dsz: total length of message data * @timeo: timeout to wait for wakeup * * Called from function tipc_sendmsg(), which has done all sanity checks * Returns the number of bytes sent on success, or errno */
static int tipc_sendmcast(struct socket *sock, struct tipc_name_seq *seq, struct msghdr *msg, size_t dsz, long timeo) { struct sock *sk = sock->sk; struct tipc_sock *tsk = tipc_sk(sk); struct net *net = sock_net(sk); struct tipc_msg *mhdr = &tsk->phdr; struct sk_buff_head pktchain; struct iov_iter save = msg->msg_iter; uint mtu; int rc; msg_set_type(mhdr, TIPC_MCAST_MSG); msg_set_lookup_scope(mhdr, TIPC_CLUSTER_SCOPE); msg_set_destport(mhdr, 0); msg_set_destnode(mhdr, 0); msg_set_nametype(mhdr, seq->type); msg_set_namelower(mhdr, seq->lower); msg_set_nameupper(mhdr, seq->upper); msg_set_hdr_sz(mhdr, MCAST_H_SIZE); skb_queue_head_init(&pktchain); new_mtu: mtu = tipc_bcast_get_mtu(net); rc = tipc_msg_build(mhdr, msg, 0, dsz, mtu, &pktchain); if (unlikely(rc < 0)) return rc; do { rc = tipc_bcast_xmit(net, &pktchain); if (likely(!rc)) return dsz; if (rc == -ELINKCONG) { tsk->link_cong = 1; rc = tipc_wait_for_sndmsg(sock, &timeo); if (!rc) continue; } __skb_queue_purge(&pktchain); if (rc == -EMSGSIZE) { msg->msg_iter = save; goto new_mtu; } break; } while (1); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
jon paul maloyjon paul maloy24587.81%861.54%
ying xueying xue145.02%215.38%
al viroal viro113.94%215.38%
parthasarathy bhuvaraganparthasarathy bhuvaragan93.23%17.69%
Total279100.00%13100.00%

/** * tipc_sk_mcast_rcv - Deliver multicast messages to all destination sockets * @arrvq: queue with arriving messages, to be cloned after destination lookup * @inputq: queue with cloned messages, delivered to socket after dest lookup * * Multi-threaded: parallel calls with reference to same queues may occur */
void tipc_sk_mcast_rcv(struct net *net, struct sk_buff_head *arrvq, struct sk_buff_head *inputq) { struct tipc_msg *msg; struct tipc_plist dports; u32 portid; u32 scope = TIPC_CLUSTER_SCOPE; struct sk_buff_head tmpq; uint hsz; struct sk_buff *skb, *_skb; __skb_queue_head_init(&tmpq); tipc_plist_init(&dports); skb = tipc_skb_peek(arrvq, &inputq->lock); for (; skb; skb = tipc_skb_peek(arrvq, &inputq->lock)) { msg = buf_msg(skb); hsz = skb_headroom(skb) + msg_hdr_sz(msg); if (in_own_node(net, msg_orignode(msg))) scope = TIPC_NODE_SCOPE; /* Create destination port list and message clones: */ tipc_nametbl_mc_translate(net, msg_nametype(msg), msg_namelower(msg), msg_nameupper(msg), scope, &dports); portid = tipc_plist_pop(&dports); for (; portid; portid = tipc_plist_pop(&dports)) { _skb = __pskb_copy(skb, hsz, GFP_ATOMIC); if (_skb) { msg_set_destport(buf_msg(_skb), portid); __skb_queue_tail(&tmpq, _skb); continue; } pr_warn("Failed to clone mcast rcv buffer\n"); } /* Append to inputq if not already done by other thread */ spin_lock_bh(&inputq->lock); if (skb_peek(arrvq) == skb) { skb_queue_splice_tail_init(&tmpq, inputq); kfree_skb(__skb_dequeue(arrvq)); } spin_unlock_bh(&inputq->lock); __skb_queue_purge(&tmpq); kfree_skb(skb); } tipc_sk_rcv(net, inputq); }

Contributors

PersonTokensPropCommitsCommitProp
jon paul maloyjon paul maloy27396.81%457.14%
ying xueying xue93.19%342.86%
Total282100.00%7100.00%

/** * tipc_sk_proto_rcv - receive a connection mng protocol message * @tsk: receiving socket * @skb: pointer to message buffer. */
static