Eric Lee / smarc-fsl-linux-kernel

Commit 0c3141e910eaaa0b617e2f26c69b266d1cd1f035

Authored by Allan Stephens 17 years ago

Committed by David S. Miller 17 years ago

Exists in master and in 39 other branches

[TIPC]: Overhaul of socket locking logic

This patch modifies TIPC's socket code to follow the same approach
used by other protocols.  This change eliminates the need for a
mutex in the TIPC-specific portion of the socket protocol data
structure -- in its place, the standard Linux socket backlog queue
and associated locking routines are utilized.  These changes fix
a long-standing receive queue bug on SMP systems, and also enable
individual read and write threads to utilize a socket without
unnecessarily interfering with each other.

Signed-off-by: Allan Stephens <allan.stephens@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

Showing 3 changed files with 608 additions and 431 deletions Inline Diff

include/net/tipc/tipc_port.h
net/tipc/port.c
net/tipc/socket.c

include/net/tipc/tipc_port.h

Diff comments View file @ 0c3141e

 /*
  * include/net/tipc/tipc_port.h: Include file for privileged access to TIPC ports
  *
  * Copyright (c) 1994-2007, Ericsson AB
  * Copyright (c) 2005-2007, 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.
  */
 #ifndef _NET_TIPC_PORT_H_
 #define _NET_TIPC_PORT_H_
 #ifdef __KERNEL__
 #include <linux/tipc.h>
 #include <linux/skbuff.h>
 #include <net/tipc/tipc_msg.h>
 #define TIPC_FLOW_CONTROL_WIN 512
 /**
  * struct tipc_port - native TIPC port info available to privileged users
  * @usr_handle: pointer to additional user-defined information about port
  * @lock: pointer to spinlock for controlling access to port
  * @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
  * @conn_unacked: number of unacknowledged messages received from peer port
  * @published: non-zero if port has one or more associated names
  * @congested: non-zero if cannot send because of link or port congestion
  * @max_pkt: maximum packet size "hint" used when building messages sent by port
  * @ref: unique reference to port in TIPC object registry
  * @phdr: preformatted message header used when sending messages
  */
 struct tipc_port {
         void *usr_handle;
         spinlock_t *lock;
 	int connected;
         u32 conn_type;
         u32 conn_instance;
 	u32 conn_unacked;
 	int published;
 	u32 congested;
 	u32 max_pkt;
 	u32 ref;
 	struct tipc_msg phdr;
 };
 /**
  * tipc_createport_raw - create a native TIPC port and return it's reference
  *
  * Note: 'dispatcher' and 'wakeup' deliver a locked port.
  */
 u32 tipc_createport_raw(void *usr_handle,
 			u32 (*dispatcher)(struct tipc_port *, struct sk_buff *),
 			void (*wakeup)(struct tipc_port *),
 			const u32 importance);
 int tipc_reject_msg(struct sk_buff *buf, u32 err);
 int tipc_send_buf_fast(struct sk_buff *buf, u32 destnode);
 void tipc_acknowledge(u32 port_ref,u32 ack);
 struct tipc_port *tipc_get_port(const u32 ref);
 void *tipc_get_handle(const u32 ref);
+/*
+ * The following routines require that the port be locked on entry
+ */
+int tipc_disconnect_port(struct tipc_port *tp_ptr);
 #endif
 #endif

net/tipc/port.c

Diff comments View file @ 0c3141e

 /*
  * net/tipc/port.c: TIPC port code
  *
  * Copyright (c) 1992-2007, Ericsson AB
  * Copyright (c) 2004-2007, 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 "core.h"
 #include "config.h"
 #include "dbg.h"
 #include "port.h"
 #include "addr.h"
 #include "link.h"
 #include "node.h"
 #include "name_table.h"
 #include "user_reg.h"
 #include "msg.h"
 #include "bcast.h"
 /* Connection management: */
 #define PROBING_INTERVAL 3600000	/* [ms] => 1 h */
 #define CONFIRMED 0
 #define PROBING 1
 #define MAX_REJECT_SIZE 1024
 static struct sk_buff *msg_queue_head = NULL;
 static struct sk_buff *msg_queue_tail = NULL;
 DEFINE_SPINLOCK(tipc_port_list_lock);
 static DEFINE_SPINLOCK(queue_lock);
 static LIST_HEAD(ports);
 static void port_handle_node_down(unsigned long ref);
 static struct sk_buff* port_build_self_abort_msg(struct port *,u32 err);
 static struct sk_buff* port_build_peer_abort_msg(struct port *,u32 err);
 static void port_timeout(unsigned long ref);
 static u32 port_peernode(struct port *p_ptr)
 {
 	return msg_destnode(&p_ptr->publ.phdr);
 }
 static u32 port_peerport(struct port *p_ptr)
 {
 	return msg_destport(&p_ptr->publ.phdr);
 }
 static u32 port_out_seqno(struct port *p_ptr)
 {
 	return msg_transp_seqno(&p_ptr->publ.phdr);
 }
 static void port_incr_out_seqno(struct port *p_ptr)
 {
 	struct tipc_msg *m = &p_ptr->publ.phdr;
 	if (likely(!msg_routed(m)))
 		return;
 	msg_set_transp_seqno(m, (msg_transp_seqno(m) + 1));
 }
 /**
  * tipc_multicast - send a multicast message to local and remote destinations
  */
 int tipc_multicast(u32 ref, struct tipc_name_seq const *seq, u32 domain,
 		   u32 num_sect, struct iovec const *msg_sect)
 {
 	struct tipc_msg *hdr;
 	struct sk_buff *buf;
 	struct sk_buff *ibuf = NULL;
 	struct port_list dports = {0, NULL, };
 	struct port *oport = tipc_port_deref(ref);
 	int ext_targets;
 	int res;
 	if (unlikely(!oport))
 		return -EINVAL;
 	/* Create multicast message */
 	hdr = &oport->publ.phdr;
 	msg_set_type(hdr, TIPC_MCAST_MSG);
 	msg_set_nametype(hdr, seq->type);
 	msg_set_namelower(hdr, seq->lower);
 	msg_set_nameupper(hdr, seq->upper);
 	msg_set_hdr_sz(hdr, MCAST_H_SIZE);
 	res = msg_build(hdr, msg_sect, num_sect, MAX_MSG_SIZE,
 			!oport->user_port, &buf);
 	if (unlikely(!buf))
 		return res;
 	/* Figure out where to send multicast message */
 	ext_targets = tipc_nametbl_mc_translate(seq->type, seq->lower, seq->upper,
 						TIPC_NODE_SCOPE, &dports);
 	/* Send message to destinations (duplicate it only if necessary) */
 	if (ext_targets) {
 		if (dports.count != 0) {
 			ibuf = skb_copy(buf, GFP_ATOMIC);
 			if (ibuf == NULL) {
 				tipc_port_list_free(&dports);
 				buf_discard(buf);
 				return -ENOMEM;
 			}
 		}
 		res = tipc_bclink_send_msg(buf);
 		if ((res < 0) && (dports.count != 0)) {
 			buf_discard(ibuf);
 		}
 	} else {
 		ibuf = buf;
 	}
 	if (res >= 0) {
 		if (ibuf)
 			tipc_port_recv_mcast(ibuf, &dports);
 	} else {
 		tipc_port_list_free(&dports);
 	}
 	return res;
 }
 /**
  * tipc_port_recv_mcast - deliver multicast message to all destination ports
  *
  * If there is no port list, perform a lookup to create one
  */
 void tipc_port_recv_mcast(struct sk_buff *buf, struct port_list *dp)
 {
 	struct tipc_msg* msg;
 	struct port_list dports = {0, NULL, };
 	struct port_list *item = dp;
 	int cnt = 0;
 	msg = buf_msg(buf);
 	/* Create destination port list, if one wasn't supplied */
 	if (dp == NULL) {
 		tipc_nametbl_mc_translate(msg_nametype(msg),
 				     msg_namelower(msg),
 				     msg_nameupper(msg),
 				     TIPC_CLUSTER_SCOPE,
 				     &dports);
 		item = dp = &dports;
 	}
 	/* Deliver a copy of message to each destination port */
 	if (dp->count != 0) {
 		if (dp->count == 1) {
 			msg_set_destport(msg, dp->ports[0]);
 			tipc_port_recv_msg(buf);
 			tipc_port_list_free(dp);
 			return;
 		}
 		for (; cnt < dp->count; cnt++) {
 			int index = cnt % PLSIZE;
 			struct sk_buff *b = skb_clone(buf, GFP_ATOMIC);
 			if (b == NULL) {
 				warn("Unable to deliver multicast message(s)\n");
 				msg_dbg(msg, "LOST:");
 				goto exit;
 			}
 			if ((index == 0) && (cnt != 0)) {
 				item = item->next;
 			}
 			msg_set_destport(buf_msg(b),item->ports[index]);
 			tipc_port_recv_msg(b);
 		}
 	}
 exit:
 	buf_discard(buf);
 	tipc_port_list_free(dp);
 }
 /**
  * tipc_createport_raw - create a native TIPC port
  *
  * Returns local port reference
  */
 u32 tipc_createport_raw(void *usr_handle,
 			u32 (*dispatcher)(struct tipc_port *, struct sk_buff *),
 			void (*wakeup)(struct tipc_port *),
 			const u32 importance)
 {
 	struct port *p_ptr;
 	struct tipc_msg *msg;
 	u32 ref;
 	p_ptr = kzalloc(sizeof(*p_ptr), GFP_ATOMIC);
 	if (!p_ptr) {
 		warn("Port creation failed, no memory\n");
 		return 0;
 	}
 	ref = tipc_ref_acquire(p_ptr, &p_ptr->publ.lock);
 	if (!ref) {
 		warn("Port creation failed, reference table exhausted\n");
 		kfree(p_ptr);
 		return 0;
 	}
 	tipc_port_lock(ref);
 	p_ptr->publ.usr_handle = usr_handle;
 	p_ptr->publ.max_pkt = MAX_PKT_DEFAULT;
 	p_ptr->publ.ref = ref;
 	msg = &p_ptr->publ.phdr;
 	msg_init(msg, TIPC_LOW_IMPORTANCE, TIPC_NAMED_MSG, TIPC_OK, LONG_H_SIZE,
 		 0);
 	msg_set_orignode(msg, tipc_own_addr);
 	msg_set_prevnode(msg, tipc_own_addr);
 	msg_set_origport(msg, ref);
 	msg_set_importance(msg,importance);
 	p_ptr->last_in_seqno = 41;
 	p_ptr->sent = 1;
 	INIT_LIST_HEAD(&p_ptr->wait_list);
 	INIT_LIST_HEAD(&p_ptr->subscription.nodesub_list);
 	p_ptr->congested_link = NULL;
 	p_ptr->dispatcher = dispatcher;
 	p_ptr->wakeup = wakeup;
 	p_ptr->user_port = NULL;
 	k_init_timer(&p_ptr->timer, (Handler)port_timeout, ref);
 	spin_lock_bh(&tipc_port_list_lock);
 	INIT_LIST_HEAD(&p_ptr->publications);
 	INIT_LIST_HEAD(&p_ptr->port_list);
 	list_add_tail(&p_ptr->port_list, &ports);
 	spin_unlock_bh(&tipc_port_list_lock);
 	tipc_port_unlock(p_ptr);
 	return ref;
 }
 int tipc_deleteport(u32 ref)
 {
 	struct port *p_ptr;
 	struct sk_buff *buf = NULL;
 	tipc_withdraw(ref, 0, NULL);
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	tipc_ref_discard(ref);
 	tipc_port_unlock(p_ptr);
 	k_cancel_timer(&p_ptr->timer);
 	if (p_ptr->publ.connected) {
 		buf = port_build_peer_abort_msg(p_ptr, TIPC_ERR_NO_PORT);
 		tipc_nodesub_unsubscribe(&p_ptr->subscription);
 	}
 	if (p_ptr->user_port) {
 		tipc_reg_remove_port(p_ptr->user_port);
 		kfree(p_ptr->user_port);
 	}
 	spin_lock_bh(&tipc_port_list_lock);
 	list_del(&p_ptr->port_list);
 	list_del(&p_ptr->wait_list);
 	spin_unlock_bh(&tipc_port_list_lock);
 	k_term_timer(&p_ptr->timer);
 	kfree(p_ptr);
 	dbg("Deleted port %u\n", ref);
 	tipc_net_route_msg(buf);
 	return TIPC_OK;
 }
 /**
  * tipc_get_port() - return port associated with 'ref'
  *
  * Note: Port is not locked.
  */
 struct tipc_port *tipc_get_port(const u32 ref)
 {
 	return (struct tipc_port *)tipc_ref_deref(ref);
 }
 /**
  * tipc_get_handle - return user handle associated to port 'ref'
  */
 void *tipc_get_handle(const u32 ref)
 {
 	struct port *p_ptr;
 	void * handle;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return NULL;
 	handle = p_ptr->publ.usr_handle;
 	tipc_port_unlock(p_ptr);
 	return handle;
 }
 static int port_unreliable(struct port *p_ptr)
 {
 	return msg_src_droppable(&p_ptr->publ.phdr);
 }
 int tipc_portunreliable(u32 ref, unsigned int *isunreliable)
 {
 	struct port *p_ptr;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	*isunreliable = port_unreliable(p_ptr);
 	tipc_port_unlock(p_ptr);
 	return TIPC_OK;
 }
 int tipc_set_portunreliable(u32 ref, unsigned int isunreliable)
 {
 	struct port *p_ptr;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	msg_set_src_droppable(&p_ptr->publ.phdr, (isunreliable != 0));
 	tipc_port_unlock(p_ptr);
 	return TIPC_OK;
 }
 static int port_unreturnable(struct port *p_ptr)
 {
 	return msg_dest_droppable(&p_ptr->publ.phdr);
 }
 int tipc_portunreturnable(u32 ref, unsigned int *isunrejectable)
 {
 	struct port *p_ptr;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	*isunrejectable = port_unreturnable(p_ptr);
 	tipc_port_unlock(p_ptr);
 	return TIPC_OK;
 }
 int tipc_set_portunreturnable(u32 ref, unsigned int isunrejectable)
 {
 	struct port *p_ptr;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	msg_set_dest_droppable(&p_ptr->publ.phdr, (isunrejectable != 0));
 	tipc_port_unlock(p_ptr);
 	return TIPC_OK;
 }
 /*
  * port_build_proto_msg(): build a port level protocol
  * or a connection abortion message. Called with
  * tipc_port lock on.
  */
 static struct sk_buff *port_build_proto_msg(u32 destport, u32 destnode,
 					    u32 origport, u32 orignode,
 					    u32 usr, u32 type, u32 err,
 					    u32 seqno, u32 ack)
 {
 	struct sk_buff *buf;
 	struct tipc_msg *msg;
 	buf = buf_acquire(LONG_H_SIZE);
 	if (buf) {
 		msg = buf_msg(buf);
 		msg_init(msg, usr, type, err, LONG_H_SIZE, destnode);
 		msg_set_destport(msg, destport);
 		msg_set_origport(msg, origport);
 		msg_set_destnode(msg, destnode);
 		msg_set_orignode(msg, orignode);
 		msg_set_transp_seqno(msg, seqno);
 		msg_set_msgcnt(msg, ack);
 		msg_dbg(msg, "PORT>SEND>:");
 	}
 	return buf;
 }
 int tipc_reject_msg(struct sk_buff *buf, u32 err)
 {
 	struct tipc_msg *msg = buf_msg(buf);
 	struct sk_buff *rbuf;
 	struct tipc_msg *rmsg;
 	int hdr_sz;
 	u32 imp = msg_importance(msg);
 	u32 data_sz = msg_data_sz(msg);
 	if (data_sz > MAX_REJECT_SIZE)
 		data_sz = MAX_REJECT_SIZE;
 	if (msg_connected(msg) && (imp < TIPC_CRITICAL_IMPORTANCE))
 		imp++;
 	msg_dbg(msg, "port->rej: ");
 	/* discard rejected message if it shouldn't be returned to sender */
 	if (msg_errcode(msg) || msg_dest_droppable(msg)) {
 		buf_discard(buf);
 		return data_sz;
 	}
 	/* construct rejected message */
 	if (msg_mcast(msg))
 		hdr_sz = MCAST_H_SIZE;
 	else
 		hdr_sz = LONG_H_SIZE;
 	rbuf = buf_acquire(data_sz + hdr_sz);
 	if (rbuf == NULL) {
 		buf_discard(buf);
 		return data_sz;
 	}
 	rmsg = buf_msg(rbuf);
 	msg_init(rmsg, imp, msg_type(msg), err, hdr_sz, msg_orignode(msg));
 	msg_set_destport(rmsg, msg_origport(msg));
 	msg_set_prevnode(rmsg, tipc_own_addr);
 	msg_set_origport(rmsg, msg_destport(msg));
 	if (msg_short(msg))
 		msg_set_orignode(rmsg, tipc_own_addr);
 	else
 		msg_set_orignode(rmsg, msg_destnode(msg));
 	msg_set_size(rmsg, data_sz + hdr_sz);
 	msg_set_nametype(rmsg, msg_nametype(msg));
 	msg_set_nameinst(rmsg, msg_nameinst(msg));
 	skb_copy_to_linear_data_offset(rbuf, hdr_sz, msg_data(msg), data_sz);
 	/* send self-abort message when rejecting on a connected port */
 	if (msg_connected(msg)) {
 		struct sk_buff *abuf = NULL;
 		struct port *p_ptr = tipc_port_lock(msg_destport(msg));
 		if (p_ptr) {
 			if (p_ptr->publ.connected)
 				abuf = port_build_self_abort_msg(p_ptr, err);
 			tipc_port_unlock(p_ptr);
 		}
 		tipc_net_route_msg(abuf);
 	}
 	/* send rejected message */
 	buf_discard(buf);
 	tipc_net_route_msg(rbuf);
 	return data_sz;
 }
 int tipc_port_reject_sections(struct port *p_ptr, struct tipc_msg *hdr,
 			      struct iovec const *msg_sect, u32 num_sect,
 			      int err)
 {
 	struct sk_buff *buf;
 	int res;
 	res = msg_build(hdr, msg_sect, num_sect, MAX_MSG_SIZE,
 			!p_ptr->user_port, &buf);
 	if (!buf)
 		return res;
 	return tipc_reject_msg(buf, err);
 }
 static void port_timeout(unsigned long ref)
 {
 	struct port *p_ptr = tipc_port_lock(ref);
 	struct sk_buff *buf = NULL;
 	if (!p_ptr)
 		return;
 	if (!p_ptr->publ.connected) {
 		tipc_port_unlock(p_ptr);
 		return;
 	}
 	/* Last probe answered ? */
 	if (p_ptr->probing_state == PROBING) {
 		buf = port_build_self_abort_msg(p_ptr, TIPC_ERR_NO_PORT);
 	} else {
 		buf = port_build_proto_msg(port_peerport(p_ptr),
 					   port_peernode(p_ptr),
 					   p_ptr->publ.ref,
 					   tipc_own_addr,
 					   CONN_MANAGER,
 					   CONN_PROBE,
 					   TIPC_OK,
 					   port_out_seqno(p_ptr),
 					   0);
 		port_incr_out_seqno(p_ptr);
 		p_ptr->probing_state = PROBING;
 		k_start_timer(&p_ptr->timer, p_ptr->probing_interval);
 	}
 	tipc_port_unlock(p_ptr);
 	tipc_net_route_msg(buf);
 }
 static void port_handle_node_down(unsigned long ref)
 {
 	struct port *p_ptr = tipc_port_lock(ref);
 	struct sk_buff* buf = NULL;
 	if (!p_ptr)
 		return;
 	buf = port_build_self_abort_msg(p_ptr, TIPC_ERR_NO_NODE);
 	tipc_port_unlock(p_ptr);
 	tipc_net_route_msg(buf);
 }
 static struct sk_buff *port_build_self_abort_msg(struct port *p_ptr, u32 err)
 {
 	u32 imp = msg_importance(&p_ptr->publ.phdr);
 	if (!p_ptr->publ.connected)
 		return NULL;
 	if (imp < TIPC_CRITICAL_IMPORTANCE)
 		imp++;
 	return port_build_proto_msg(p_ptr->publ.ref,
 				    tipc_own_addr,
 				    port_peerport(p_ptr),
 				    port_peernode(p_ptr),
 				    imp,
 				    TIPC_CONN_MSG,
 				    err,
 				    p_ptr->last_in_seqno + 1,
 				    0);
 }
 static struct sk_buff *port_build_peer_abort_msg(struct port *p_ptr, u32 err)
 {
 	u32 imp = msg_importance(&p_ptr->publ.phdr);
 	if (!p_ptr->publ.connected)
 		return NULL;
 	if (imp < TIPC_CRITICAL_IMPORTANCE)
 		imp++;
 	return port_build_proto_msg(port_peerport(p_ptr),
 				    port_peernode(p_ptr),
 				    p_ptr->publ.ref,
 				    tipc_own_addr,
 				    imp,
 				    TIPC_CONN_MSG,
 				    err,
 				    port_out_seqno(p_ptr),
 				    0);
 }
 void tipc_port_recv_proto_msg(struct sk_buff *buf)
 {
 	struct tipc_msg *msg = buf_msg(buf);
 	struct port *p_ptr = tipc_port_lock(msg_destport(msg));
 	u32 err = TIPC_OK;
 	struct sk_buff *r_buf = NULL;
 	struct sk_buff *abort_buf = NULL;
 	msg_dbg(msg, "PORT<RECV<:");
 	if (!p_ptr) {
 		err = TIPC_ERR_NO_PORT;
 	} else if (p_ptr->publ.connected) {
 		if (port_peernode(p_ptr) != msg_orignode(msg))
 			err = TIPC_ERR_NO_PORT;
 		if (port_peerport(p_ptr) != msg_origport(msg))
 			err = TIPC_ERR_NO_PORT;
 		if (!err && msg_routed(msg)) {
 			u32 seqno = msg_transp_seqno(msg);
 			u32 myno =  ++p_ptr->last_in_seqno;
 			if (seqno != myno) {
 				err = TIPC_ERR_NO_PORT;
 				abort_buf = port_build_self_abort_msg(p_ptr, err);
 			}
 		}
 		if (msg_type(msg) == CONN_ACK) {
 			int wakeup = tipc_port_congested(p_ptr) &&
 				     p_ptr->publ.congested &&
 				     p_ptr->wakeup;
 			p_ptr->acked += msg_msgcnt(msg);
 			if (tipc_port_congested(p_ptr))
 				goto exit;
 			p_ptr->publ.congested = 0;
 			if (!wakeup)
 				goto exit;
 			p_ptr->wakeup(&p_ptr->publ);
 			goto exit;
 		}
 	} else if (p_ptr->publ.published) {
 		err = TIPC_ERR_NO_PORT;
 	}
 	if (err) {
 		r_buf = port_build_proto_msg(msg_origport(msg),
 					     msg_orignode(msg),
 					     msg_destport(msg),
 					     tipc_own_addr,
 					     TIPC_HIGH_IMPORTANCE,
 					     TIPC_CONN_MSG,
 					     err,
 					     0,
 					     0);
 		goto exit;
 	}
 	/* All is fine */
 	if (msg_type(msg) == CONN_PROBE) {
 		r_buf = port_build_proto_msg(msg_origport(msg),
 					     msg_orignode(msg),
 					     msg_destport(msg),
 					     tipc_own_addr,
 					     CONN_MANAGER,
 					     CONN_PROBE_REPLY,
 					     TIPC_OK,
 					     port_out_seqno(p_ptr),
 					     0);
 	}
 	p_ptr->probing_state = CONFIRMED;
 	port_incr_out_seqno(p_ptr);
 exit:
 	if (p_ptr)
 		tipc_port_unlock(p_ptr);
 	tipc_net_route_msg(r_buf);
 	tipc_net_route_msg(abort_buf);
 	buf_discard(buf);
 }
 static void port_print(struct port *p_ptr, struct print_buf *buf, int full_id)
 {
 	struct publication *publ;
 	if (full_id)
 		tipc_printf(buf, "<%u.%u.%u:%u>:",
 			    tipc_zone(tipc_own_addr), tipc_cluster(tipc_own_addr),
 			    tipc_node(tipc_own_addr), p_ptr->publ.ref);
 	else
 		tipc_printf(buf, "%-10u:", p_ptr->publ.ref);
 	if (p_ptr->publ.connected) {
 		u32 dport = port_peerport(p_ptr);
 		u32 destnode = port_peernode(p_ptr);
 		tipc_printf(buf, " connected to <%u.%u.%u:%u>",
 			    tipc_zone(destnode), tipc_cluster(destnode),
 			    tipc_node(destnode), dport);
 		if (p_ptr->publ.conn_type != 0)
 			tipc_printf(buf, " via {%u,%u}",
 				    p_ptr->publ.conn_type,
 				    p_ptr->publ.conn_instance);
 	}
 	else if (p_ptr->publ.published) {
 		tipc_printf(buf, " bound to");
 		list_for_each_entry(publ, &p_ptr->publications, pport_list) {
 			if (publ->lower == publ->upper)
 				tipc_printf(buf, " {%u,%u}", publ->type,
 					    publ->lower);
 			else
 				tipc_printf(buf, " {%u,%u,%u}", publ->type,
 					    publ->lower, publ->upper);
 		}
 	}
 	tipc_printf(buf, "\n");
 }
 #define MAX_PORT_QUERY 32768
 struct sk_buff *tipc_port_get_ports(void)
 {
 	struct sk_buff *buf;
 	struct tlv_desc *rep_tlv;
 	struct print_buf pb;
 	struct port *p_ptr;
 	int str_len;
 	buf = tipc_cfg_reply_alloc(TLV_SPACE(MAX_PORT_QUERY));
 	if (!buf)
 		return NULL;
 	rep_tlv = (struct tlv_desc *)buf->data;
 	tipc_printbuf_init(&pb, TLV_DATA(rep_tlv), MAX_PORT_QUERY);
 	spin_lock_bh(&tipc_port_list_lock);
 	list_for_each_entry(p_ptr, &ports, port_list) {
 		spin_lock_bh(p_ptr->publ.lock);
 		port_print(p_ptr, &pb, 0);
 		spin_unlock_bh(p_ptr->publ.lock);
 	}
 	spin_unlock_bh(&tipc_port_list_lock);
 	str_len = tipc_printbuf_validate(&pb);
 	skb_put(buf, TLV_SPACE(str_len));
 	TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
 	return buf;
 }
 #if 0
 #define MAX_PORT_STATS 2000
 struct sk_buff *port_show_stats(const void *req_tlv_area, int req_tlv_space)
 {
 	u32 ref;
 	struct port *p_ptr;
 	struct sk_buff *buf;
 	struct tlv_desc *rep_tlv;
 	struct print_buf pb;
 	int str_len;
 	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_PORT_REF))
 		return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
 	ref = *(u32 *)TLV_DATA(req_tlv_area);
 	ref = ntohl(ref);
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return cfg_reply_error_string("port not found");
 	buf = tipc_cfg_reply_alloc(TLV_SPACE(MAX_PORT_STATS));
 	if (!buf) {
 		tipc_port_unlock(p_ptr);
 		return NULL;
 	}
 	rep_tlv = (struct tlv_desc *)buf->data;
 	tipc_printbuf_init(&pb, TLV_DATA(rep_tlv), MAX_PORT_STATS);
 	port_print(p_ptr, &pb, 1);
 	/* NEED TO FILL IN ADDITIONAL PORT STATISTICS HERE */
 	tipc_port_unlock(p_ptr);
 	str_len = tipc_printbuf_validate(&pb);
 	skb_put(buf, TLV_SPACE(str_len));
 	TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
 	return buf;
 }
 #endif
 void tipc_port_reinit(void)
 {
 	struct port *p_ptr;
 	struct tipc_msg *msg;
 	spin_lock_bh(&tipc_port_list_lock);
 	list_for_each_entry(p_ptr, &ports, port_list) {
 		msg = &p_ptr->publ.phdr;
 		if (msg_orignode(msg) == tipc_own_addr)
 			break;
 		msg_set_orignode(msg, tipc_own_addr);
 	}
 	spin_unlock_bh(&tipc_port_list_lock);
 }
 /*
  *  port_dispatcher_sigh(): Signal handler for messages destinated
  *                          to the tipc_port interface.
  */
 static void port_dispatcher_sigh(void *dummy)
 {
 	struct sk_buff *buf;
 	spin_lock_bh(&queue_lock);
 	buf = msg_queue_head;
 	msg_queue_head = NULL;
 	spin_unlock_bh(&queue_lock);
 	while (buf) {
 		struct port *p_ptr;
 		struct user_port *up_ptr;
 		struct tipc_portid orig;
 		struct tipc_name_seq dseq;
 		void *usr_handle;
 		int connected;
 		int published;
 		u32 message_type;
 		struct sk_buff *next = buf->next;
 		struct tipc_msg *msg = buf_msg(buf);
 		u32 dref = msg_destport(msg);
 		message_type = msg_type(msg);
 		if (message_type > TIPC_DIRECT_MSG)
 			goto reject;	/* Unsupported message type */
 		p_ptr = tipc_port_lock(dref);
 		if (!p_ptr)
 			goto reject;	/* Port deleted while msg in queue */
 		orig.ref = msg_origport(msg);
 		orig.node = msg_orignode(msg);
 		up_ptr = p_ptr->user_port;
 		usr_handle = up_ptr->usr_handle;
 		connected = p_ptr->publ.connected;
 		published = p_ptr->publ.published;
 		if (unlikely(msg_errcode(msg)))
 			goto err;
 		switch (message_type) {
 		case TIPC_CONN_MSG:{
 				tipc_conn_msg_event cb = up_ptr->conn_msg_cb;
 				u32 peer_port = port_peerport(p_ptr);
 				u32 peer_node = port_peernode(p_ptr);
 				tipc_port_unlock(p_ptr);
 				if (unlikely(!connected)) {
 					if (unlikely(published))
 						goto reject;
 					tipc_connect2port(dref,&orig);
 				}
 				if (unlikely(msg_origport(msg) != peer_port))
 					goto reject;
 				if (unlikely(msg_orignode(msg) != peer_node))
 					goto reject;
 				if (unlikely(!cb))
 					goto reject;
 				if (unlikely(++p_ptr->publ.conn_unacked >=
 					     TIPC_FLOW_CONTROL_WIN))
 					tipc_acknowledge(dref,
 							 p_ptr->publ.conn_unacked);
 				skb_pull(buf, msg_hdr_sz(msg));
 				cb(usr_handle, dref, &buf, msg_data(msg),
 				   msg_data_sz(msg));
 				break;
 			}
 		case TIPC_DIRECT_MSG:{
 				tipc_msg_event cb = up_ptr->msg_cb;
 				tipc_port_unlock(p_ptr);
 				if (unlikely(connected))
 					goto reject;
 				if (unlikely(!cb))
 					goto reject;
 				skb_pull(buf, msg_hdr_sz(msg));
 				cb(usr_handle, dref, &buf, msg_data(msg),
 				   msg_data_sz(msg), msg_importance(msg),
 				   &orig);
 				break;
 			}
 		case TIPC_MCAST_MSG:
 		case TIPC_NAMED_MSG:{
 				tipc_named_msg_event cb = up_ptr->named_msg_cb;
 				tipc_port_unlock(p_ptr);
 				if (unlikely(connected))
 					goto reject;
 				if (unlikely(!cb))
 					goto reject;
 				if (unlikely(!published))
 					goto reject;
 				dseq.type =  msg_nametype(msg);
 				dseq.lower = msg_nameinst(msg);
 				dseq.upper = (message_type == TIPC_NAMED_MSG)
 					? dseq.lower : msg_nameupper(msg);
 				skb_pull(buf, msg_hdr_sz(msg));
 				cb(usr_handle, dref, &buf, msg_data(msg),
 				   msg_data_sz(msg), msg_importance(msg),
 				   &orig, &dseq);
 				break;
 			}
 		}
 		if (buf)
 			buf_discard(buf);
 		buf = next;
 		continue;
 err:
 		switch (message_type) {
 		case TIPC_CONN_MSG:{
 				tipc_conn_shutdown_event cb =
 					up_ptr->conn_err_cb;
 				u32 peer_port = port_peerport(p_ptr);
 				u32 peer_node = port_peernode(p_ptr);
 				tipc_port_unlock(p_ptr);
 				if (!connected || !cb)
 					break;
 				if (msg_origport(msg) != peer_port)
 					break;
 				if (msg_orignode(msg) != peer_node)
 					break;
 				tipc_disconnect(dref);
 				skb_pull(buf, msg_hdr_sz(msg));
 				cb(usr_handle, dref, &buf, msg_data(msg),
 				   msg_data_sz(msg), msg_errcode(msg));
 				break;
 			}
 		case TIPC_DIRECT_MSG:{
 				tipc_msg_err_event cb = up_ptr->err_cb;
 				tipc_port_unlock(p_ptr);
 				if (connected || !cb)
 					break;
 				skb_pull(buf, msg_hdr_sz(msg));
 				cb(usr_handle, dref, &buf, msg_data(msg),
 				   msg_data_sz(msg), msg_errcode(msg), &orig);
 				break;
 			}
 		case TIPC_MCAST_MSG:
 		case TIPC_NAMED_MSG:{
 				tipc_named_msg_err_event cb =
 					up_ptr->named_err_cb;
 				tipc_port_unlock(p_ptr);
 				if (connected || !cb)
 					break;
 				dseq.type =  msg_nametype(msg);
 				dseq.lower = msg_nameinst(msg);
 				dseq.upper = (message_type == TIPC_NAMED_MSG)
 					? dseq.lower : msg_nameupper(msg);
 				skb_pull(buf, msg_hdr_sz(msg));
 				cb(usr_handle, dref, &buf, msg_data(msg),
 				   msg_data_sz(msg), msg_errcode(msg), &dseq);
 				break;
 			}
 		}
 		if (buf)
 			buf_discard(buf);
 		buf = next;
 		continue;
 reject:
 		tipc_reject_msg(buf, TIPC_ERR_NO_PORT);
 		buf = next;
 	}
 }
 /*
  *  port_dispatcher(): Dispatcher for messages destinated
  *  to the tipc_port interface. Called with port locked.
  */
 static u32 port_dispatcher(struct tipc_port *dummy, struct sk_buff *buf)
 {
 	buf->next = NULL;
 	spin_lock_bh(&queue_lock);
 	if (msg_queue_head) {
 		msg_queue_tail->next = buf;
 		msg_queue_tail = buf;
 	} else {
 		msg_queue_tail = msg_queue_head = buf;
 		tipc_k_signal((Handler)port_dispatcher_sigh, 0);
 	}
 	spin_unlock_bh(&queue_lock);
 	return TIPC_OK;
 }
 /*
  * Wake up port after congestion: Called with port locked,
  *
  */
 static void port_wakeup_sh(unsigned long ref)
 {
 	struct port *p_ptr;
 	struct user_port *up_ptr;
 	tipc_continue_event cb = NULL;
 	void *uh = NULL;
 	p_ptr = tipc_port_lock(ref);
 	if (p_ptr) {
 		up_ptr = p_ptr->user_port;
 		if (up_ptr) {
 			cb = up_ptr->continue_event_cb;
 			uh = up_ptr->usr_handle;
 		}
 		tipc_port_unlock(p_ptr);
 	}
 	if (cb)
 		cb(uh, ref);
 }
 static void port_wakeup(struct tipc_port *p_ptr)
 {
 	tipc_k_signal((Handler)port_wakeup_sh, p_ptr->ref);
 }
 void tipc_acknowledge(u32 ref, u32 ack)
 {
 	struct port *p_ptr;
 	struct sk_buff *buf = NULL;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return;
 	if (p_ptr->publ.connected) {
 		p_ptr->publ.conn_unacked -= ack;
 		buf = port_build_proto_msg(port_peerport(p_ptr),
 					   port_peernode(p_ptr),
 					   ref,
 					   tipc_own_addr,
 					   CONN_MANAGER,
 					   CONN_ACK,
 					   TIPC_OK,
 					   port_out_seqno(p_ptr),
 					   ack);
 	}
 	tipc_port_unlock(p_ptr);
 	tipc_net_route_msg(buf);
 }
 /*
  * tipc_createport(): user level call. Will add port to
  *                    registry if non-zero user_ref.
  */
 int tipc_createport(u32 user_ref,
 		    void *usr_handle,
 		    unsigned int importance,
 		    tipc_msg_err_event error_cb,
 		    tipc_named_msg_err_event named_error_cb,
 		    tipc_conn_shutdown_event conn_error_cb,
 		    tipc_msg_event msg_cb,
 		    tipc_named_msg_event named_msg_cb,
 		    tipc_conn_msg_event conn_msg_cb,
 		    tipc_continue_event continue_event_cb,/* May be zero */
 		    u32 *portref)
 {
 	struct user_port *up_ptr;
 	struct port *p_ptr;
 	u32 ref;
 	up_ptr = kmalloc(sizeof(*up_ptr), GFP_ATOMIC);
 	if (!up_ptr) {
 		warn("Port creation failed, no memory\n");
 		return -ENOMEM;
 	}
 	ref = tipc_createport_raw(NULL, port_dispatcher, port_wakeup, importance);
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr) {
 		kfree(up_ptr);
 		return -ENOMEM;
 	}
 	p_ptr->user_port = up_ptr;
 	up_ptr->user_ref = user_ref;
 	up_ptr->usr_handle = usr_handle;
 	up_ptr->ref = p_ptr->publ.ref;
 	up_ptr->err_cb = error_cb;
 	up_ptr->named_err_cb = named_error_cb;
 	up_ptr->conn_err_cb = conn_error_cb;
 	up_ptr->msg_cb = msg_cb;
 	up_ptr->named_msg_cb = named_msg_cb;
 	up_ptr->conn_msg_cb = conn_msg_cb;
 	up_ptr->continue_event_cb = continue_event_cb;
 	INIT_LIST_HEAD(&up_ptr->uport_list);
 	tipc_reg_add_port(up_ptr);
 	*portref = p_ptr->publ.ref;
 	dbg(" tipc_createport: %x with ref %u\n", p_ptr, p_ptr->publ.ref);
 	tipc_port_unlock(p_ptr);
 	return TIPC_OK;
 }
 int tipc_ownidentity(u32 ref, struct tipc_portid *id)
 {
 	id->ref = ref;
 	id->node = tipc_own_addr;
 	return TIPC_OK;
 }
 int tipc_portimportance(u32 ref, unsigned int *importance)
 {
 	struct port *p_ptr;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	*importance = (unsigned int)msg_importance(&p_ptr->publ.phdr);
 	tipc_port_unlock(p_ptr);
 	return TIPC_OK;
 }
 int tipc_set_portimportance(u32 ref, unsigned int imp)
 {
 	struct port *p_ptr;
 	if (imp > TIPC_CRITICAL_IMPORTANCE)
 		return -EINVAL;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	msg_set_importance(&p_ptr->publ.phdr, (u32)imp);
 	tipc_port_unlock(p_ptr);
 	return TIPC_OK;
 }
 int tipc_publish(u32 ref, unsigned int scope, struct tipc_name_seq const *seq)
 {
 	struct port *p_ptr;
 	struct publication *publ;
 	u32 key;
 	int res = -EINVAL;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	dbg("tipc_publ %u, p_ptr = %x, conn = %x, scope = %x, "
 	    "lower = %u, upper = %u\n",
 	    ref, p_ptr, p_ptr->publ.connected, scope, seq->lower, seq->upper);
 	if (p_ptr->publ.connected)
 		goto exit;
 	if (seq->lower > seq->upper)
 		goto exit;
 	if ((scope < TIPC_ZONE_SCOPE) || (scope > TIPC_NODE_SCOPE))
 		goto exit;
 	key = ref + p_ptr->pub_count + 1;
 	if (key == ref) {
 		res = -EADDRINUSE;
 		goto exit;
 	}
 	publ = tipc_nametbl_publish(seq->type, seq->lower, seq->upper,
 				    scope, p_ptr->publ.ref, key);
 	if (publ) {
 		list_add(&publ->pport_list, &p_ptr->publications);
 		p_ptr->pub_count++;
 		p_ptr->publ.published = 1;
 		res = TIPC_OK;
 	}
 exit:
 	tipc_port_unlock(p_ptr);
 	return res;
 }
 int tipc_withdraw(u32 ref, unsigned int scope, struct tipc_name_seq const *seq)
 {
 	struct port *p_ptr;
 	struct publication *publ;
 	struct publication *tpubl;
 	int res = -EINVAL;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	if (!seq) {
 		list_for_each_entry_safe(publ, tpubl,
 					 &p_ptr->publications, pport_list) {
 			tipc_nametbl_withdraw(publ->type, publ->lower,
 					      publ->ref, publ->key);
 		}
 		res = TIPC_OK;
 	} else {
 		list_for_each_entry_safe(publ, tpubl,
 					 &p_ptr->publications, pport_list) {
 			if (publ->scope != scope)
 				continue;
 			if (publ->type != seq->type)
 				continue;
 			if (publ->lower != seq->lower)
 				continue;
 			if (publ->upper != seq->upper)
 				break;
 			tipc_nametbl_withdraw(publ->type, publ->lower,
 					      publ->ref, publ->key);
 			res = TIPC_OK;
 			break;
 		}
 	}
 	if (list_empty(&p_ptr->publications))
 		p_ptr->publ.published = 0;
 	tipc_port_unlock(p_ptr);
 	return res;
 }
 int tipc_connect2port(u32 ref, struct tipc_portid const *peer)
 {
 	struct port *p_ptr;
 	struct tipc_msg *msg;
 	int res = -EINVAL;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	if (p_ptr->publ.published || p_ptr->publ.connected)
 		goto exit;
 	if (!peer->ref)
 		goto exit;
 	msg = &p_ptr->publ.phdr;
 	msg_set_destnode(msg, peer->node);
 	msg_set_destport(msg, peer->ref);
 	msg_set_orignode(msg, tipc_own_addr);
 	msg_set_origport(msg, p_ptr->publ.ref);
 	msg_set_transp_seqno(msg, 42);
 	msg_set_type(msg, TIPC_CONN_MSG);
 	if (!may_route(peer->node))
 		msg_set_hdr_sz(msg, SHORT_H_SIZE);
 	else
 		msg_set_hdr_sz(msg, LONG_H_SIZE);
 	p_ptr->probing_interval = PROBING_INTERVAL;
 	p_ptr->probing_state = CONFIRMED;
 	p_ptr->publ.connected = 1;
 	k_start_timer(&p_ptr->timer, p_ptr->probing_interval);
 	tipc_nodesub_subscribe(&p_ptr->subscription,peer->node,
 			  (void *)(unsigned long)ref,
 			  (net_ev_handler)port_handle_node_down);
 	res = TIPC_OK;
 exit:
 	tipc_port_unlock(p_ptr);
 	p_ptr->publ.max_pkt = tipc_link_get_max_pkt(peer->node, ref);
 	return res;
 }
+/**
+ * tipc_disconnect_port - disconnect port from peer
+ *
+ * Port must be locked.
+ */
+int tipc_disconnect_port(struct tipc_port *tp_ptr)
+{
+	int res;
+	if (tp_ptr->connected) {
+		tp_ptr->connected = 0;
+		/* let timer expire on it's own to avoid deadlock! */
+		tipc_nodesub_unsubscribe(
+			&((struct port *)tp_ptr)->subscription);
+		res = TIPC_OK;
+	} else {
+		res = -ENOTCONN;
+	}
+	return res;
+}
 /*
  * tipc_disconnect(): Disconnect port form peer.
  *                    This is a node local operation.
  */
 int tipc_disconnect(u32 ref)
 {
 	struct port *p_ptr;
-	int res = -ENOTCONN;
+	int res;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
-	if (p_ptr->publ.connected) {
+	res = tipc_disconnect_port((struct tipc_port *)p_ptr);
-		p_ptr->publ.connected = 0;
-		/* let timer expire on it's own to avoid deadlock! */
-		tipc_nodesub_unsubscribe(&p_ptr->subscription);
-		res = TIPC_OK;
-	}
 	tipc_port_unlock(p_ptr);
 	return res;
 }
 /*
  * tipc_shutdown(): Send a SHUTDOWN msg to peer and disconnect
  */
 int tipc_shutdown(u32 ref)
 {
 	struct port *p_ptr;
 	struct sk_buff *buf = NULL;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	if (p_ptr->publ.connected) {
 		u32 imp = msg_importance(&p_ptr->publ.phdr);
 		if (imp < TIPC_CRITICAL_IMPORTANCE)
 			imp++;
 		buf = port_build_proto_msg(port_peerport(p_ptr),
 					   port_peernode(p_ptr),
 					   ref,
 					   tipc_own_addr,
 					   imp,
 					   TIPC_CONN_MSG,
 					   TIPC_CONN_SHUTDOWN,
 					   port_out_seqno(p_ptr),
 					   0);
 	}
 	tipc_port_unlock(p_ptr);
 	tipc_net_route_msg(buf);
 	return tipc_disconnect(ref);
 }
 int tipc_isconnected(u32 ref, int *isconnected)
 {
 	struct port *p_ptr;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	*isconnected = p_ptr->publ.connected;
 	tipc_port_unlock(p_ptr);
 	return TIPC_OK;
 }
 int tipc_peer(u32 ref, struct tipc_portid *peer)
 {
 	struct port *p_ptr;
 	int res;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	if (p_ptr->publ.connected) {
 		peer->ref = port_peerport(p_ptr);
 		peer->node = port_peernode(p_ptr);
 		res = TIPC_OK;
 	} else
 		res = -ENOTCONN;
 	tipc_port_unlock(p_ptr);
 	return res;
 }
 int tipc_ref_valid(u32 ref)
 {
 	/* Works irrespective of type */
 	return !!tipc_ref_deref(ref);
 }
 /*
  *  tipc_port_recv_sections(): Concatenate and deliver sectioned
  *                        message for this node.
  */
 int tipc_port_recv_sections(struct port *sender, unsigned int num_sect,
 		       struct iovec const *msg_sect)
 {
 	struct sk_buff *buf;
 	int res;
 	res = msg_build(&sender->publ.phdr, msg_sect, num_sect,
 			MAX_MSG_SIZE, !sender->user_port, &buf);
 	if (likely(buf))
 		tipc_port_recv_msg(buf);
 	return res;
 }
 /**
  * tipc_send - send message sections on connection
  */
 int tipc_send(u32 ref, unsigned int num_sect, struct iovec const *msg_sect)
 {
 	struct port *p_ptr;
 	u32 destnode;
 	int res;
 	p_ptr = tipc_port_deref(ref);
 	if (!p_ptr || !p_ptr->publ.connected)
 		return -EINVAL;
 	p_ptr->publ.congested = 1;
 	if (!tipc_port_congested(p_ptr)) {
 		destnode = port_peernode(p_ptr);
 		if (likely(destnode != tipc_own_addr))
 			res = tipc_link_send_sections_fast(p_ptr, msg_sect, num_sect,
 							   destnode);
 		else
 			res = tipc_port_recv_sections(p_ptr, num_sect, msg_sect);
 		if (likely(res != -ELINKCONG)) {
 			port_incr_out_seqno(p_ptr);
 			p_ptr->publ.congested = 0;
 			p_ptr->sent++;
 			return res;
 		}
 	}
 	if (port_unreliable(p_ptr)) {
 		p_ptr->publ.congested = 0;
 		/* Just calculate msg length and return */
 		return msg_calc_data_size(msg_sect, num_sect);
 	}
 	return -ELINKCONG;
 }
 /**
  * tipc_send_buf - send message buffer on connection
  */
 int tipc_send_buf(u32 ref, struct sk_buff *buf, unsigned int dsz)
 {
 	struct port *p_ptr;
 	struct tipc_msg *msg;
 	u32 destnode;
 	u32 hsz;
 	u32 sz;
 	u32 res;
 	p_ptr = tipc_port_deref(ref);
 	if (!p_ptr || !p_ptr->publ.connected)
 		return -EINVAL;
 	msg = &p_ptr->publ.phdr;
 	hsz = msg_hdr_sz(msg);
 	sz = hsz + dsz;
 	msg_set_size(msg, sz);
 	if (skb_cow(buf, hsz))
 		return -ENOMEM;
 	skb_push(buf, hsz);
 	skb_copy_to_linear_data(buf, msg, hsz);
 	destnode = msg_destnode(msg);
 	p_ptr->publ.congested = 1;
 	if (!tipc_port_congested(p_ptr)) {
 		if (likely(destnode != tipc_own_addr))
 			res = tipc_send_buf_fast(buf, destnode);
 		else {
 			tipc_port_recv_msg(buf);
 			res = sz;
 		}
 		if (likely(res != -ELINKCONG)) {
 			port_incr_out_seqno(p_ptr);
 			p_ptr->sent++;
 			p_ptr->publ.congested = 0;
 			return res;
 		}
 	}
 	if (port_unreliable(p_ptr)) {
 		p_ptr->publ.congested = 0;
 		return dsz;
 	}
 	return -ELINKCONG;
 }
 /**
  * tipc_forward2name - forward message sections to port name
  */
 int tipc_forward2name(u32 ref,
 		      struct tipc_name const *name,
 		      u32 domain,
 		      u32 num_sect,
 		      struct iovec const *msg_sect,
 		      struct tipc_portid const *orig,
 		      unsigned int importance)
 {
 	struct port *p_ptr;
 	struct tipc_msg *msg;
 	u32 destnode = domain;
 	u32 destport = 0;
 	int res;
 	p_ptr = tipc_port_deref(ref);
 	if (!p_ptr || p_ptr->publ.connected)
 		return -EINVAL;
 	msg = &p_ptr->publ.phdr;
 	msg_set_type(msg, TIPC_NAMED_MSG);
 	msg_set_orignode(msg, orig->node);
 	msg_set_origport(msg, orig->ref);
 	msg_set_hdr_sz(msg, LONG_H_SIZE);
 	msg_set_nametype(msg, name->type);
 	msg_set_nameinst(msg, name->instance);
 	msg_set_lookup_scope(msg, addr_scope(domain));
 	if (importance <= TIPC_CRITICAL_IMPORTANCE)
 		msg_set_importance(msg,importance);
 	destport = tipc_nametbl_translate(name->type, name->instance, &destnode);
 	msg_set_destnode(msg, destnode);
 	msg_set_destport(msg, destport);
 	if (likely(destport || destnode)) {
 		p_ptr->sent++;
 		if (likely(destnode == tipc_own_addr))
 			return tipc_port_recv_sections(p_ptr, num_sect, msg_sect);
 		res = tipc_link_send_sections_fast(p_ptr, msg_sect, num_sect,
 						   destnode);
 		if (likely(res != -ELINKCONG))
 			return res;
 		if (port_unreliable(p_ptr)) {
 			/* Just calculate msg length and return */
 			return msg_calc_data_size(msg_sect, num_sect);
 		}
 		return -ELINKCONG;
 	}
 	return tipc_port_reject_sections(p_ptr, msg, msg_sect, num_sect,
 					 TIPC_ERR_NO_NAME);
 }
 /**
  * tipc_send2name - send message sections to port name
  */
 int tipc_send2name(u32 ref,
 		   struct tipc_name const *name,
 		   unsigned int domain,
 		   unsigned int num_sect,
 		   struct iovec const *msg_sect)
 {
 	struct tipc_portid orig;
 	orig.ref = ref;
 	orig.node = tipc_own_addr;
 	return tipc_forward2name(ref, name, domain, num_sect, msg_sect, &orig,
 				 TIPC_PORT_IMPORTANCE);
 }
 /**
  * tipc_forward_buf2name - forward message buffer to port name
  */
 int tipc_forward_buf2name(u32 ref,
 			  struct tipc_name const *name,
 			  u32 domain,
 			  struct sk_buff *buf,
 			  unsigned int dsz,
 			  struct tipc_portid const *orig,
 			  unsigned int importance)
 {
 	struct port *p_ptr;
 	struct tipc_msg *msg;
 	u32 destnode = domain;
 	u32 destport = 0;
 	int res;
 	p_ptr = (struct port *)tipc_ref_deref(ref);
 	if (!p_ptr || p_ptr->publ.connected)
 		return -EINVAL;
 	msg = &p_ptr->publ.phdr;
 	if (importance <= TIPC_CRITICAL_IMPORTANCE)
 		msg_set_importance(msg, importance);
 	msg_set_type(msg, TIPC_NAMED_MSG);
 	msg_set_orignode(msg, orig->node);
 	msg_set_origport(msg, orig->ref);
 	msg_set_nametype(msg, name->type);
 	msg_set_nameinst(msg, name->instance);
 	msg_set_lookup_scope(msg, addr_scope(domain));
 	msg_set_hdr_sz(msg, LONG_H_SIZE);
 	msg_set_size(msg, LONG_H_SIZE + dsz);
 	destport = tipc_nametbl_translate(name->type, name->instance, &destnode);
 	msg_set_destnode(msg, destnode);
 	msg_set_destport(msg, destport);
 	msg_dbg(msg, "forw2name ==> ");
 	if (skb_cow(buf, LONG_H_SIZE))
 		return -ENOMEM;
 	skb_push(buf, LONG_H_SIZE);
 	skb_copy_to_linear_data(buf, msg, LONG_H_SIZE);
 	msg_dbg(buf_msg(buf),"PREP:");
 	if (likely(destport || destnode)) {
 		p_ptr->sent++;
 		if (destnode == tipc_own_addr)
 			return tipc_port_recv_msg(buf);
 		res = tipc_send_buf_fast(buf, destnode);
 		if (likely(res != -ELINKCONG))
 			return res;
 		if (port_unreliable(p_ptr))
 			return dsz;
 		return -ELINKCONG;
 	}
 	return tipc_reject_msg(buf, TIPC_ERR_NO_NAME);
 }
 /**
  * tipc_send_buf2name - send message buffer to port name
  */
 int tipc_send_buf2name(u32 ref,
 		       struct tipc_name const *dest,
 		       u32 domain,
 		       struct sk_buff *buf,
 		       unsigned int dsz)
 {
 	struct tipc_portid orig;
 	orig.ref = ref;
 	orig.node = tipc_own_addr;
 	return tipc_forward_buf2name(ref, dest, domain, buf, dsz, &orig,
 				     TIPC_PORT_IMPORTANCE);
 }
 /**
  * tipc_forward2port - forward message sections to port identity
  */
 int tipc_forward2port(u32 ref,
 		      struct tipc_portid const *dest,
 		      unsigned int num_sect,
 		      struct iovec const *msg_sect,
 		      struct tipc_portid const *orig,
 		      unsigned int importance)
 {
 	struct port *p_ptr;
 	struct tipc_msg *msg;
 	int res;
 	p_ptr = tipc_port_deref(ref);
 	if (!p_ptr || p_ptr->publ.connected)
 		return -EINVAL;
 	msg = &p_ptr->publ.phdr;
 	msg_set_type(msg, TIPC_DIRECT_MSG);
 	msg_set_orignode(msg, orig->node);
 	msg_set_origport(msg, orig->ref);
 	msg_set_destnode(msg, dest->node);
 	msg_set_destport(msg, dest->ref);
 	msg_set_hdr_sz(msg, DIR_MSG_H_SIZE);
 	if (importance <= TIPC_CRITICAL_IMPORTANCE)
 		msg_set_importance(msg, importance);
 	p_ptr->sent++;
 	if (dest->node == tipc_own_addr)
 		return tipc_port_recv_sections(p_ptr, num_sect, msg_sect);
 	res = tipc_link_send_sections_fast(p_ptr, msg_sect, num_sect, dest->node);
 	if (likely(res != -ELINKCONG))
 		return res;
 	if (port_unreliable(p_ptr)) {
 		/* Just calculate msg length and return */
 		return msg_calc_data_size(msg_sect, num_sect);
 	}
 	return -ELINKCONG;
 }
 /**
  * tipc_send2port - send message sections to port identity
  */
 int tipc_send2port(u32 ref,
 		   struct tipc_portid const *dest,
 		   unsigned int num_sect,
 		   struct iovec const *msg_sect)
 {
 	struct tipc_portid orig;
 	orig.ref = ref;
 	orig.node = tipc_own_addr;
 	return tipc_forward2port(ref, dest, num_sect, msg_sect, &orig,
 				 TIPC_PORT_IMPORTANCE);
 }
 /**
  * tipc_forward_buf2port - forward message buffer to port identity
  */
 int tipc_forward_buf2port(u32 ref,
 			  struct tipc_portid const *dest,
 			  struct sk_buff *buf,
 			  unsigned int dsz,
 			  struct tipc_portid const *orig,
 			  unsigned int importance)
 {
 	struct port *p_ptr;
 	struct tipc_msg *msg;
 	int res;
 	p_ptr = (struct port *)tipc_ref_deref(ref);
 	if (!p_ptr || p_ptr->publ.connected)
 		return -EINVAL;
 	msg = &p_ptr->publ.phdr;
 	msg_set_type(msg, TIPC_DIRECT_MSG);
 	msg_set_orignode(msg, orig->node);
 	msg_set_origport(msg, orig->ref);
 	msg_set_destnode(msg, dest->node);
 	msg_set_destport(msg, dest->ref);
 	msg_set_hdr_sz(msg, DIR_MSG_H_SIZE);
 	if (importance <= TIPC_CRITICAL_IMPORTANCE)
 		msg_set_importance(msg, importance);
 	msg_set_size(msg, DIR_MSG_H_SIZE + dsz);
 	if (skb_cow(buf, DIR_MSG_H_SIZE))
 		return -ENOMEM;
 	skb_push(buf, DIR_MSG_H_SIZE);
 	skb_copy_to_linear_data(buf, msg, DIR_MSG_H_SIZE);
 	msg_dbg(msg, "buf2port: ");
 	p_ptr->sent++;
 	if (dest->node == tipc_own_addr)
 		return tipc_port_recv_msg(buf);
 	res = tipc_send_buf_fast(buf, dest->node);
 	if (likely(res != -ELINKCONG))
 		return res;
 	if (port_unreliable(p_ptr))
 		return dsz;
 	return -ELINKCONG;
 }
 /**
  * tipc_send_buf2port - send message buffer to port identity
  */
 int tipc_send_buf2port(u32 ref,
 		       struct tipc_portid const *dest,
 		       struct sk_buff *buf,
 		       unsigned int dsz)
 {
 	struct tipc_portid orig;
 	orig.ref = ref;
 	orig.node = tipc_own_addr;

net/tipc/socket.c

Diff comments View file @ 0c3141e

1	/*	1	/*
2	* net/tipc/socket.c: TIPC socket API	2	* net/tipc/socket.c: TIPC socket API
3	*	3	*
4	* Copyright (c) 2001-2007, Ericsson AB	4	* Copyright (c) 2001-2007, Ericsson AB
5	* Copyright (c) 2004-2007, Wind River Systems	5	* Copyright (c) 2004-2007, Wind River Systems
6	* All rights reserved.	6	* All rights reserved.
7	*	7	*
8	* Redistribution and use in source and binary forms, with or without	8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions are met:	9	* modification, are permitted provided that the following conditions are met:
10	*	10	*
11	* 1. Redistributions of source code must retain the above copyright	11	* 1. Redistributions of source code must retain the above copyright
12	* notice, this list of conditions and the following disclaimer.	12	* notice, this list of conditions and the following disclaimer.
13	* 2. Redistributions in binary form must reproduce the above copyright	13	* 2. Redistributions in binary form must reproduce the above copyright
14	* notice, this list of conditions and the following disclaimer in the	14	* notice, this list of conditions and the following disclaimer in the
15	* documentation and/or other materials provided with the distribution.	15	* documentation and/or other materials provided with the distribution.
16	* 3. Neither the names of the copyright holders nor the names of its	16	* 3. Neither the names of the copyright holders nor the names of its
17	* contributors may be used to endorse or promote products derived from	17	* contributors may be used to endorse or promote products derived from
18	* this software without specific prior written permission.	18	* this software without specific prior written permission.
19	*	19	*
20	* Alternatively, this software may be distributed under the terms of the	20	* Alternatively, this software may be distributed under the terms of the
21	* GNU General Public License ("GPL") version 2 as published by the Free	21	* GNU General Public License ("GPL") version 2 as published by the Free
22	* Software Foundation.	22	* Software Foundation.
23	*	23	*
24	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"	24	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE	25	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE	26	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE	27	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
28	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR	28	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF	29	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS	30	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN	31	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)	32	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE	33	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34	* POSSIBILITY OF SUCH DAMAGE.	34	* POSSIBILITY OF SUCH DAMAGE.
35	*/	35	*/
36		36
37	#include <linux/module.h>	37	#include <linux/module.h>
38	#include <linux/types.h>	38	#include <linux/types.h>
39	#include <linux/net.h>	39	#include <linux/net.h>
40	#include <linux/socket.h>	40	#include <linux/socket.h>
41	#include <linux/errno.h>	41	#include <linux/errno.h>
42	#include <linux/mm.h>	42	#include <linux/mm.h>
43	#include <linux/slab.h>	43	#include <linux/slab.h>
44	#include <linux/poll.h>	44	#include <linux/poll.h>
45	#include <linux/fcntl.h>	45	#include <linux/fcntl.h>
46	#include <linux/mutex.h>
47	#include <asm/string.h>	46	#include <asm/string.h>
48	#include <asm/atomic.h>	47	#include <asm/atomic.h>
49	#include <net/sock.h>	48	#include <net/sock.h>
50		49
51	#include <linux/tipc.h>	50	#include <linux/tipc.h>
52	#include <linux/tipc_config.h>	51	#include <linux/tipc_config.h>
53	#include <net/tipc/tipc_msg.h>	52	#include <net/tipc/tipc_msg.h>
54	#include <net/tipc/tipc_port.h>	53	#include <net/tipc/tipc_port.h>
55		54
56	#include "core.h"	55	#include "core.h"
57		56
58	#define SS_LISTENING -1 /* socket is listening */	57	#define SS_LISTENING -1 /* socket is listening */
59	#define SS_READY -2 /* socket is connectionless */	58	#define SS_READY -2 /* socket is connectionless */
60		59
61	#define OVERLOAD_LIMIT_BASE 5000	60	#define OVERLOAD_LIMIT_BASE 5000
62	#define CONN_TIMEOUT_DEFAULT 8000 /* default connect timeout = 8s */	61	#define CONN_TIMEOUT_DEFAULT 8000 /* default connect timeout = 8s */
63		62
64	struct tipc_sock {	63	struct tipc_sock {
65	struct sock sk;	64	struct sock sk;
66	struct tipc_port *p;	65	struct tipc_port *p;
67	struct mutex lock;
68	};	66	};
69		67
70	#define tipc_sk(sk) ((struct tipc_sock*)sk)	68	#define tipc_sk(sk) ((struct tipc_sock *)(sk))
		69	#define tipc_sk_port(sk) ((struct tipc_port *)(tipc_sk(sk)->p))
71		70
		71	static int backlog_rcv(struct sock sk, struct sk_buff skb);
72	static u32 dispatch(struct tipc_port tport, struct sk_buff buf);	72	static u32 dispatch(struct tipc_port tport, struct sk_buff buf);
73	static void wakeupdispatch(struct tipc_port *tport);	73	static void wakeupdispatch(struct tipc_port *tport);
74		74
75	static const struct proto_ops packet_ops;	75	static const struct proto_ops packet_ops;
76	static const struct proto_ops stream_ops;	76	static const struct proto_ops stream_ops;
77	static const struct proto_ops msg_ops;	77	static const struct proto_ops msg_ops;
78		78
79	static struct proto tipc_proto;	79	static struct proto tipc_proto;
80		80
81	static int sockets_enabled = 0;	81	static int sockets_enabled = 0;
82		82
83	static atomic_t tipc_queue_size = ATOMIC_INIT(0);	83	static atomic_t tipc_queue_size = ATOMIC_INIT(0);
84		84
85
86	/*	85	/*
87	* sock_lock(): Lock a port/socket pair. lock_sock() can	86	* Revised TIPC socket locking policy:
88	* not be used here, since the same lock must protect ports	87	*
89	* with non-socket interfaces.	88	* Most socket operations take the standard socket lock when they start
90	* See net.c for description of locking policy.	89	* and hold it until they finish (or until they need to sleep). Acquiring
		90	* this lock grants the owner exclusive access to the fields of the socket
		91	* data structures, with the exception of the backlog queue. A few socket
		92	* operations can be done without taking the socket lock because they only
		93	* read socket information that never changes during the life of the socket.
		94	*
		95	* Socket operations may acquire the lock for the associated TIPC port if they
		96	* need to perform an operation on the port. If any routine needs to acquire
		97	* both the socket lock and the port lock it must take the socket lock first
		98	* to avoid the risk of deadlock.
		99	*
		100	* The dispatcher handling incoming messages cannot grab the socket lock in
		101	* the standard fashion, since invoked it runs at the BH level and cannot block.
		102	* Instead, it checks to see if the socket lock is currently owned by someone,
		103	* and either handles the message itself or adds it to the socket's backlog
		104	* queue; in the latter case the queued message is processed once the process
		105	* owning the socket lock releases it.
		106	*
		107	* NOTE: Releasing the socket lock while an operation is sleeping overcomes
		108	* the problem of a blocked socket operation preventing any other operations
		109	* from occurring. However, applications must be careful if they have
		110	* multiple threads trying to send (or receive) on the same socket, as these
		111	* operations might interfere with each other. For example, doing a connect
		112	* and a receive at the same time might allow the receive to consume the
		113	* ACK message meant for the connect. While additional work could be done
		114	* to try and overcome this, it doesn't seem to be worthwhile at the present.
		115	*
		116	* NOTE: Releasing the socket lock while an operation is sleeping also ensures
		117	* that another operation that must be performed in a non-blocking manner is
		118	* not delayed for very long because the lock has already been taken.
		119	*
		120	* NOTE: This code assumes that certain fields of a port/socket pair are
		121	* constant over its lifetime; such fields can be examined without taking
		122	* the socket lock and/or port lock, and do not need to be re-read even
		123	* after resuming processing after waiting. These fields include:
		124	* - socket type
		125	* - pointer to socket sk structure (aka tipc_sock structure)
		126	* - pointer to port structure
		127	* - port reference
91	*/	128	*/
92	static void sock_lock(struct tipc_sock* tsock)	129
		130	/**
		131	* advance_rx_queue - discard first buffer in socket receive queue
		132	*
		133	* Caller must hold socket lock
		134	*/
		135
		136	static void advance_rx_queue(struct sock *sk)
93	{	137	{
94	spin_lock_bh(tsock->p->lock);	138	buf_discard(__skb_dequeue(&sk->sk_receive_queue));
		139	atomic_dec(&tipc_queue_size);
95	}	140	}
96		141
97	/*	142	/**
98	* sock_unlock(): Unlock a port/socket pair	143	* discard_rx_queue - discard all buffers in socket receive queue
		144	*
		145	* Caller must hold socket lock
99	*/	146	*/
100	static void sock_unlock(struct tipc_sock* tsock)	147
		148	static void discard_rx_queue(struct sock *sk)
101	{	149	{
102	spin_unlock_bh(tsock->p->lock);	150	struct sk_buff *buf;
		151
		152	while ((buf = __skb_dequeue(&sk->sk_receive_queue))) {
		153	atomic_dec(&tipc_queue_size);
		154	buf_discard(buf);
		155	}
103	}	156	}
104		157
105	/**	158	/**
106	* advance_queue - discard first buffer in queue	159	* reject_rx_queue - reject all buffers in socket receive queue
107	* @tsock: TIPC socket	160	*
		161	* Caller must hold socket lock
108	*/	162	*/
109		163
110	static void advance_queue(struct tipc_sock *tsock)	164	static void reject_rx_queue(struct sock *sk)
111	{	165	{
112	sock_lock(tsock);	166	struct sk_buff *buf;
113	buf_discard(skb_dequeue(&tsock->sk.sk_receive_queue));	167
114	sock_unlock(tsock);	168	while ((buf = __skb_dequeue(&sk->sk_receive_queue))) {
115	atomic_dec(&tipc_queue_size);	169	tipc_reject_msg(buf, TIPC_ERR_NO_PORT);
		170	atomic_dec(&tipc_queue_size);
		171	}
116	}	172	}
117		173
118	/**	174	/**
119	* tipc_create - create a TIPC socket	175	* tipc_create - create a TIPC socket
		176	* @net: network namespace (must be default network)
120	* @sock: pre-allocated socket structure	177	* @sock: pre-allocated socket structure
121	* @protocol: protocol indicator (must be 0)	178	* @protocol: protocol indicator (must be 0)
122	*	179	*
123	* This routine creates and attaches a 'struct sock' to the 'struct socket',	180	* This routine creates additional data structures used by the TIPC socket,
124	* then create and attaches a TIPC port to the 'struct sock' part.	181	* initializes them, and links them together.
125	*	182	*
126	* Returns 0 on success, errno otherwise	183	* Returns 0 on success, errno otherwise
127	*/	184	*/
		185
128	static int tipc_create(struct net net, struct socket sock, int protocol)	186	static int tipc_create(struct net net, struct socket sock, int protocol)
129	{	187	{
130	struct tipc_sock *tsock;	188	const struct proto_ops *ops;
131	struct tipc_port *port;	189	socket_state state;
132	struct sock *sk;	190	struct sock *sk;
133	u32 ref;	191	u32 portref;
134		192
		193	/* Validate arguments */
		194
135	if (net != &init_net)	195	if (net != &init_net)
136	return -EAFNOSUPPORT;	196	return -EAFNOSUPPORT;
137		197
138	if (unlikely(protocol != 0))	198	if (unlikely(protocol != 0))
139	return -EPROTONOSUPPORT;	199	return -EPROTONOSUPPORT;
140		200
141	ref = tipc_createport_raw(NULL, &dispatch, &wakeupdispatch, TIPC_LOW_IMPORTANCE);
142	if (unlikely(!ref))
143	return -ENOMEM;
144
145	sock->state = SS_UNCONNECTED;
146
147	switch (sock->type) {	201	switch (sock->type) {
148	case SOCK_STREAM:	202	case SOCK_STREAM:
149	sock->ops = &stream_ops;	203	ops = &stream_ops;
		204	state = SS_UNCONNECTED;
150	break;	205	break;
151	case SOCK_SEQPACKET:	206	case SOCK_SEQPACKET:
152	sock->ops = &packet_ops;	207	ops = &packet_ops;
		208	state = SS_UNCONNECTED;
153	break;	209	break;
154	case SOCK_DGRAM:	210	case SOCK_DGRAM:
155	tipc_set_portunreliable(ref, 1);
156	/* fall through */
157	case SOCK_RDM:	211	case SOCK_RDM:
158	tipc_set_portunreturnable(ref, 1);	212	ops = &msg_ops;
159	sock->ops = &msg_ops;	213	state = SS_READY;
160	sock->state = SS_READY;
161	break;	214	break;
162	default:	215	default:
163	tipc_deleteport(ref);
164	return -EPROTOTYPE;	216	return -EPROTOTYPE;
165	}	217	}
166		218
		219	/* Allocate socket's protocol area */
		220
167	sk = sk_alloc(net, AF_TIPC, GFP_KERNEL, &tipc_proto);	221	sk = sk_alloc(net, AF_TIPC, GFP_KERNEL, &tipc_proto);
168	if (!sk) {	222	if (sk == NULL)
169	tipc_deleteport(ref);
170	return -ENOMEM;	223	return -ENOMEM;
171	}
172		224
173	sock_init_data(sock, sk);	225	/* Allocate TIPC port for socket to use */
174	sk->sk_rcvtimeo = msecs_to_jiffies(CONN_TIMEOUT_DEFAULT);
175		226
176	tsock = tipc_sk(sk);	227	portref = tipc_createport_raw(sk, &dispatch, &wakeupdispatch,
177	port = tipc_get_port(ref);	228	TIPC_LOW_IMPORTANCE);
		229	if (unlikely(portref == 0)) {
		230	sk_free(sk);
		231	return -ENOMEM;
		232	}
178		233
179	tsock->p = port;	234	/* Finish initializing socket data structures */
180	port->usr_handle = tsock;
181		235
182	mutex_init(&tsock->lock);	236	sock->ops = ops;
		237	sock->state = state;
183		238
184	dbg("sock_create: %x\n",tsock);	239	sock_init_data(sock, sk);
		240	sk->sk_rcvtimeo = msecs_to_jiffies(CONN_TIMEOUT_DEFAULT);
		241	sk->sk_backlog_rcv = backlog_rcv;
		242	tipc_sk(sk)->p = tipc_get_port(portref);
185		243
186	atomic_inc(&tipc_user_count);	244	if (sock->state == SS_READY) {
		245	tipc_set_portunreturnable(portref, 1);
		246	if (sock->type == SOCK_DGRAM)
		247	tipc_set_portunreliable(portref, 1);
		248	}
187		249
		250	atomic_inc(&tipc_user_count);
188	return 0;	251	return 0;
189	}	252	}
190		253
191	/**	254	/**
192	* release - destroy a TIPC socket	255	* release - destroy a TIPC socket
193	* @sock: socket to destroy	256	* @sock: socket to destroy
194	*	257	*
195	* This routine cleans up any messages that are still queued on the socket.	258	* This routine cleans up any messages that are still queued on the socket.
196	* For DGRAM and RDM socket types, all queued messages are rejected.	259	* For DGRAM and RDM socket types, all queued messages are rejected.
197	* For SEQPACKET and STREAM socket types, the first message is rejected	260	* For SEQPACKET and STREAM socket types, the first message is rejected
198	* and any others are discarded. (If the first message on a STREAM socket	261	* and any others are discarded. (If the first message on a STREAM socket
199	* is partially-read, it is discarded and the next one is rejected instead.)	262	* is partially-read, it is discarded and the next one is rejected instead.)
200	*	263	*
201	* NOTE: Rejected messages are not necessarily returned to the sender! They	264	* NOTE: Rejected messages are not necessarily returned to the sender! They
202	* are returned or discarded according to the "destination droppable" setting	265	* are returned or discarded according to the "destination droppable" setting
203	* specified for the message by the sender.	266	* specified for the message by the sender.
204	*	267	*
205	* Returns 0 on success, errno otherwise	268	* Returns 0 on success, errno otherwise
206	*/	269	*/
207		270
208	static int release(struct socket *sock)	271	static int release(struct socket *sock)
209	{	272	{
210	struct tipc_sock *tsock = tipc_sk(sock->sk);
211	struct sock *sk = sock->sk;	273	struct sock *sk = sock->sk;
212	int res = TIPC_OK;	274	struct tipc_port *tport;
213	struct sk_buff *buf;	275	struct sk_buff *buf;
		276	int res;
214		277
215	dbg("sock_delete: %x\n",tsock);	278	/*
216	if (!tsock)	279	* Exit if socket isn't fully initialized (occurs when a failed accept()
		280	* releases a pre-allocated child socket that was never used)
		281	*/
		282
		283	if (sk == NULL)
217	return 0;	284	return 0;
218	mutex_lock(&tsock->lock);
219	if (!sock->sk) {
220	mutex_unlock(&tsock->lock);
221	return 0;
222	}
223		285
224	/* Reject unreceived messages, unless no longer connected */	286	tport = tipc_sk_port(sk);
		287	lock_sock(sk);
225		288
		289	/*
		290	* Reject all unreceived messages, except on an active connection
		291	* (which disconnects locally & sends a 'FIN+' to peer)
		292	*/
		293
226	while (sock->state != SS_DISCONNECTING) {	294	while (sock->state != SS_DISCONNECTING) {
227	sock_lock(tsock);	295	buf = __skb_dequeue(&sk->sk_receive_queue);
228	buf = skb_dequeue(&sk->sk_receive_queue);	296	if (buf == NULL)
229	if (!buf)
230	tsock->p->usr_handle = NULL;
231	sock_unlock(tsock);
232	if (!buf)
233	break;	297	break;
		298	atomic_dec(&tipc_queue_size);
234	if (TIPC_SKB_CB(buf)->handle != msg_data(buf_msg(buf)))	299	if (TIPC_SKB_CB(buf)->handle != msg_data(buf_msg(buf)))
235	buf_discard(buf);	300	buf_discard(buf);
236	else	301	else {
		302	if ((sock->state == SS_CONNECTING) \|\|
		303	(sock->state == SS_CONNECTED)) {
		304	sock->state = SS_DISCONNECTING;
		305	tipc_disconnect(tport->ref);
		306	}
237	tipc_reject_msg(buf, TIPC_ERR_NO_PORT);	307	tipc_reject_msg(buf, TIPC_ERR_NO_PORT);
238	atomic_dec(&tipc_queue_size);	308	}
239	}	309	}
240		310
241	/* Delete TIPC port */	311	/*
		312	* Delete TIPC port; this ensures no more messages are queued
		313	* (also disconnects an active connection & sends a 'FIN-' to peer)
		314	*/
242		315
243	res = tipc_deleteport(tsock->p->ref);	316	res = tipc_deleteport(tport->ref);
244	sock->sk = NULL;
245		317
246	/* Discard any remaining messages */	318	/* Discard any remaining (connection-based) messages in receive queue */
247		319
248	while ((buf = skb_dequeue(&sk->sk_receive_queue))) {	320	discard_rx_queue(sk);
249	buf_discard(buf);
250	atomic_dec(&tipc_queue_size);
251	}
252		321
253	mutex_unlock(&tsock->lock);	322	/* Reject any messages that accumulated in backlog queue */
254		323
		324	sock->state = SS_DISCONNECTING;
		325	release_sock(sk);
		326
255	sock_put(sk);	327	sock_put(sk);
		328	sock->sk = NULL;
256		329
257	atomic_dec(&tipc_user_count);	330	atomic_dec(&tipc_user_count);
258	return res;	331	return res;
259	}	332	}
260		333
261	/**	334	/**
262	* bind - associate or disassocate TIPC name(s) with a socket	335	* bind - associate or disassocate TIPC name(s) with a socket
263	* @sock: socket structure	336	* @sock: socket structure
264	* @uaddr: socket address describing name(s) and desired operation	337	* @uaddr: socket address describing name(s) and desired operation
265	* @uaddr_len: size of socket address data structure	338	* @uaddr_len: size of socket address data structure
266	*	339	*
267	* Name and name sequence binding is indicated using a positive scope value;	340	* Name and name sequence binding is indicated using a positive scope value;
268	* a negative scope value unbinds the specified name. Specifying no name	341	* a negative scope value unbinds the specified name. Specifying no name
269	* (i.e. a socket address length of 0) unbinds all names from the socket.	342	* (i.e. a socket address length of 0) unbinds all names from the socket.
270	*	343	*
271	* Returns 0 on success, errno otherwise	344	* Returns 0 on success, errno otherwise
		345	*
		346	* NOTE: This routine doesn't need to take the socket lock since it doesn't
		347	* access any non-constant socket information.
272	*/	348	*/
273		349
274	static int bind(struct socket sock, struct sockaddr uaddr, int uaddr_len)	350	static int bind(struct socket sock, struct sockaddr uaddr, int uaddr_len)
275	{	351	{
276	struct tipc_sock *tsock = tipc_sk(sock->sk);
277	struct sockaddr_tipc addr = (struct sockaddr_tipc )uaddr;	352	struct sockaddr_tipc addr = (struct sockaddr_tipc )uaddr;
278	int res;	353	u32 portref = tipc_sk_port(sock->sk)->ref;
279		354
280	if (mutex_lock_interruptible(&tsock->lock))	355	if (unlikely(!uaddr_len))
281	return -ERESTARTSYS;	356	return tipc_withdraw(portref, 0, NULL);
282		357
283	if (unlikely(!uaddr_len)) {	358	if (uaddr_len < sizeof(struct sockaddr_tipc))
284	res = tipc_withdraw(tsock->p->ref, 0, NULL);	359	return -EINVAL;
285	goto exit;	360	if (addr->family != AF_TIPC)
286	}	361	return -EAFNOSUPPORT;
287		362
288	if (uaddr_len < sizeof(struct sockaddr_tipc)) {
289	res = -EINVAL;
290	goto exit;
291	}
292
293	if (addr->family != AF_TIPC) {
294	res = -EAFNOSUPPORT;
295	goto exit;
296	}
297	if (addr->addrtype == TIPC_ADDR_NAME)	363	if (addr->addrtype == TIPC_ADDR_NAME)
298	addr->addr.nameseq.upper = addr->addr.nameseq.lower;	364	addr->addr.nameseq.upper = addr->addr.nameseq.lower;
299	else if (addr->addrtype != TIPC_ADDR_NAMESEQ) {	365	else if (addr->addrtype != TIPC_ADDR_NAMESEQ)
300	res = -EAFNOSUPPORT;	366	return -EAFNOSUPPORT;
301	goto exit;
302	}
303		367
304	if (addr->scope > 0)	368	return (addr->scope > 0) ?
305	res = tipc_publish(tsock->p->ref, addr->scope,	369	tipc_publish(portref, addr->scope, &addr->addr.nameseq) :
306	&addr->addr.nameseq);	370	tipc_withdraw(portref, -addr->scope, &addr->addr.nameseq);
307	else
308	res = tipc_withdraw(tsock->p->ref, -addr->scope,
309	&addr->addr.nameseq);
310	exit:
311	mutex_unlock(&tsock->lock);
312	return res;
313	}	371	}
314		372
315	/**	373	/**
316	* get_name - get port ID of socket or peer socket	374	* get_name - get port ID of socket or peer socket
317	* @sock: socket structure	375	* @sock: socket structure
318	* @uaddr: area for returned socket address	376	* @uaddr: area for returned socket address
319	* @uaddr_len: area for returned length of socket address	377	* @uaddr_len: area for returned length of socket address
320	* @peer: 0 to obtain socket name, 1 to obtain peer socket name	378	* @peer: 0 to obtain socket name, 1 to obtain peer socket name
321	*	379	*
322	* Returns 0 on success, errno otherwise	380	* Returns 0 on success, errno otherwise
		381	*
		382	* NOTE: This routine doesn't need to take the socket lock since it doesn't
		383	* access any non-constant socket information.
323	*/	384	*/
324		385
325	static int get_name(struct socket sock, struct sockaddr uaddr,	386	static int get_name(struct socket sock, struct sockaddr uaddr,
326	int *uaddr_len, int peer)	387	int *uaddr_len, int peer)
327	{	388	{
328	struct tipc_sock *tsock = tipc_sk(sock->sk);
329	struct sockaddr_tipc addr = (struct sockaddr_tipc )uaddr;	389	struct sockaddr_tipc addr = (struct sockaddr_tipc )uaddr;
		390	u32 portref = tipc_sk_port(sock->sk)->ref;
330	u32 res;	391	u32 res;
331		392
332	if (mutex_lock_interruptible(&tsock->lock))	393	if (peer) {
333	return -ERESTARTSYS;	394	res = tipc_peer(portref, &addr->addr.id);
		395	if (res)
		396	return res;
		397	} else {
		398	tipc_ownidentity(portref, &addr->addr.id);
		399	}
334		400
335	uaddr_len = sizeof(addr);	401	uaddr_len = sizeof(addr);
336	addr->addrtype = TIPC_ADDR_ID;	402	addr->addrtype = TIPC_ADDR_ID;
337	addr->family = AF_TIPC;	403	addr->family = AF_TIPC;
338	addr->scope = 0;	404	addr->scope = 0;
339	if (peer)
340	res = tipc_peer(tsock->p->ref, &addr->addr.id);
341	else
342	res = tipc_ownidentity(tsock->p->ref, &addr->addr.id);
343	addr->addr.name.domain = 0;	405	addr->addr.name.domain = 0;
344		406
345	mutex_unlock(&tsock->lock);	407	return 0;
346	return res;
347	}	408	}
348		409
349	/**	410	/**
350	* poll - read and possibly block on pollmask	411	* poll - read and possibly block on pollmask
351	* @file: file structure associated with the socket	412	* @file: file structure associated with the socket
352	* @sock: socket for which to calculate the poll bits	413	* @sock: socket for which to calculate the poll bits
353	* @wait: ???	414	* @wait: ???
354	*	415	*
355	* Returns pollmask value	416	* Returns pollmask value
356	*	417	*
357	* COMMENTARY:	418	* COMMENTARY:
358	* It appears that the usual socket locking mechanisms are not useful here	419	* It appears that the usual socket locking mechanisms are not useful here
359	* since the pollmask info is potentially out-of-date the moment this routine	420	* since the pollmask info is potentially out-of-date the moment this routine
360	* exits. TCP and other protocols seem to rely on higher level poll routines	421	* exits. TCP and other protocols seem to rely on higher level poll routines
361	* to handle any preventable race conditions, so TIPC will do the same ...	422	* to handle any preventable race conditions, so TIPC will do the same ...
362	*	423	*
363	* TIPC sets the returned events as follows:	424	* TIPC sets the returned events as follows:
364	* a) POLLRDNORM and POLLIN are set if the socket's receive queue is non-empty	425	* a) POLLRDNORM and POLLIN are set if the socket's receive queue is non-empty
365	* or if a connection-oriented socket is does not have an active connection	426	* or if a connection-oriented socket is does not have an active connection
366	* (i.e. a read operation will not block).	427	* (i.e. a read operation will not block).
367	* b) POLLOUT is set except when a socket's connection has been terminated	428	* b) POLLOUT is set except when a socket's connection has been terminated
368	* (i.e. a write operation will not block).	429	* (i.e. a write operation will not block).
369	* c) POLLHUP is set when a socket's connection has been terminated.	430	* c) POLLHUP is set when a socket's connection has been terminated.
370	*	431	*
371	* IMPORTANT: The fact that a read or write operation will not block does NOT	432	* IMPORTANT: The fact that a read or write operation will not block does NOT
372	* imply that the operation will succeed!	433	* imply that the operation will succeed!
373	*/	434	*/
374		435
375	static unsigned int poll(struct file file, struct socket sock,	436	static unsigned int poll(struct file file, struct socket sock,
376	poll_table *wait)	437	poll_table *wait)
377	{	438	{
378	struct sock *sk = sock->sk;	439	struct sock *sk = sock->sk;
379	u32 mask;	440	u32 mask;
380		441
381	poll_wait(file, sk->sk_sleep, wait);	442	poll_wait(file, sk->sk_sleep, wait);
382		443
383	if (!skb_queue_empty(&sk->sk_receive_queue) \|\|	444	if (!skb_queue_empty(&sk->sk_receive_queue) \|\|
384	(sock->state == SS_UNCONNECTED) \|\|	445	(sock->state == SS_UNCONNECTED) \|\|
385	(sock->state == SS_DISCONNECTING))	446	(sock->state == SS_DISCONNECTING))
386	mask = (POLLRDNORM \| POLLIN);	447	mask = (POLLRDNORM \| POLLIN);
387	else	448	else
388	mask = 0;	449	mask = 0;
389		450
390	if (sock->state == SS_DISCONNECTING)	451	if (sock->state == SS_DISCONNECTING)
391	mask \|= POLLHUP;	452	mask \|= POLLHUP;
392	else	453	else
393	mask \|= POLLOUT;	454	mask \|= POLLOUT;
394		455
395	return mask;	456	return mask;
396	}	457	}
397		458
398	/**	459	/**
399	* dest_name_check - verify user is permitted to send to specified port name	460	* dest_name_check - verify user is permitted to send to specified port name
400	* @dest: destination address	461	* @dest: destination address
401	* @m: descriptor for message to be sent	462	* @m: descriptor for message to be sent
402	*	463	*
403	* Prevents restricted configuration commands from being issued by	464	* Prevents restricted configuration commands from being issued by
404	* unauthorized users.	465	* unauthorized users.
405	*	466	*
406	* Returns 0 if permission is granted, otherwise errno	467	* Returns 0 if permission is granted, otherwise errno
407	*/	468	*/
408		469
409	static int dest_name_check(struct sockaddr_tipc dest, struct msghdr m)	470	static int dest_name_check(struct sockaddr_tipc dest, struct msghdr m)
410	{	471	{
411	struct tipc_cfg_msg_hdr hdr;	472	struct tipc_cfg_msg_hdr hdr;
412		473
413	if (likely(dest->addr.name.name.type >= TIPC_RESERVED_TYPES))	474	if (likely(dest->addr.name.name.type >= TIPC_RESERVED_TYPES))
414	return 0;	475	return 0;
415	if (likely(dest->addr.name.name.type == TIPC_TOP_SRV))	476	if (likely(dest->addr.name.name.type == TIPC_TOP_SRV))
416	return 0;	477	return 0;
417
418	if (likely(dest->addr.name.name.type != TIPC_CFG_SRV))	478	if (likely(dest->addr.name.name.type != TIPC_CFG_SRV))
419	return -EACCES;	479	return -EACCES;
420		480
421	if (copy_from_user(&hdr, m->msg_iov[0].iov_base, sizeof(hdr)))	481	if (copy_from_user(&hdr, m->msg_iov[0].iov_base, sizeof(hdr)))
422	return -EFAULT;	482	return -EFAULT;
423	if ((ntohs(hdr.tcm_type) & 0xC000) && (!capable(CAP_NET_ADMIN)))	483	if ((ntohs(hdr.tcm_type) & 0xC000) && (!capable(CAP_NET_ADMIN)))
424	return -EACCES;	484	return -EACCES;
425		485
426	return 0;	486	return 0;
427	}	487	}
428		488
429	/**	489	/**
430	* send_msg - send message in connectionless manner	490	* send_msg - send message in connectionless manner
431	* @iocb: (unused)	491	* @iocb: if NULL, indicates that socket lock is already held
432	* @sock: socket structure	492	* @sock: socket structure
433	* @m: message to send	493	* @m: message to send
434	* @total_len: length of message	494	* @total_len: length of message
435	*	495	*
436	* Message must have an destination specified explicitly.	496	* Message must have an destination specified explicitly.
437	* Used for SOCK_RDM and SOCK_DGRAM messages,	497	* Used for SOCK_RDM and SOCK_DGRAM messages,
438	* and for 'SYN' messages on SOCK_SEQPACKET and SOCK_STREAM connections.	498	* and for 'SYN' messages on SOCK_SEQPACKET and SOCK_STREAM connections.
439	* (Note: 'SYN+' is prohibited on SOCK_STREAM.)	499	* (Note: 'SYN+' is prohibited on SOCK_STREAM.)
440	*	500	*
441	* Returns the number of bytes sent on success, or errno otherwise	501	* Returns the number of bytes sent on success, or errno otherwise
442	*/	502	*/
443		503
444	static int send_msg(struct kiocb iocb, struct socket sock,	504	static int send_msg(struct kiocb iocb, struct socket sock,
445	struct msghdr *m, size_t total_len)	505	struct msghdr *m, size_t total_len)
446	{	506	{
447	struct tipc_sock *tsock = tipc_sk(sock->sk);	507	struct sock *sk = sock->sk;
		508	struct tipc_port *tport = tipc_sk_port(sk);
448	struct sockaddr_tipc dest = (struct sockaddr_tipc )m->msg_name;	509	struct sockaddr_tipc dest = (struct sockaddr_tipc )m->msg_name;
449	struct sk_buff *buf;
450	int needs_conn;	510	int needs_conn;
451	int res = -EINVAL;	511	int res = -EINVAL;
452		512
453	if (unlikely(!dest))	513	if (unlikely(!dest))
454	return -EDESTADDRREQ;	514	return -EDESTADDRREQ;
455	if (unlikely((m->msg_namelen < sizeof(*dest)) \|\|	515	if (unlikely((m->msg_namelen < sizeof(*dest)) \|\|
456	(dest->family != AF_TIPC)))	516	(dest->family != AF_TIPC)))
457	return -EINVAL;	517	return -EINVAL;
458		518
		519	if (iocb)
		520	lock_sock(sk);
		521
459	needs_conn = (sock->state != SS_READY);	522	needs_conn = (sock->state != SS_READY);
460	if (unlikely(needs_conn)) {	523	if (unlikely(needs_conn)) {
461	if (sock->state == SS_LISTENING)	524	if (sock->state == SS_LISTENING) {
462	return -EPIPE;	525	res = -EPIPE;
463	if (sock->state != SS_UNCONNECTED)	526	goto exit;
464	return -EISCONN;	527	}
465	if ((tsock->p->published) \|\|	528	if (sock->state != SS_UNCONNECTED) {
466	((sock->type == SOCK_STREAM) && (total_len != 0)))	529	res = -EISCONN;
467	return -EOPNOTSUPP;	530	goto exit;
		531	}
		532	if ((tport->published) \|\|
		533	((sock->type == SOCK_STREAM) && (total_len != 0))) {
		534	res = -EOPNOTSUPP;
		535	goto exit;
		536	}
468	if (dest->addrtype == TIPC_ADDR_NAME) {	537	if (dest->addrtype == TIPC_ADDR_NAME) {
469	tsock->p->conn_type = dest->addr.name.name.type;	538	tport->conn_type = dest->addr.name.name.type;
470	tsock->p->conn_instance = dest->addr.name.name.instance;	539	tport->conn_instance = dest->addr.name.name.instance;
471	}	540	}
472	}
473		541
474	if (mutex_lock_interruptible(&tsock->lock))
475	return -ERESTARTSYS;
476
477	if (needs_conn) {
478
479	/* Abort any pending connection attempts (very unlikely) */	542	/* Abort any pending connection attempts (very unlikely) */
480		543
481	while ((buf = skb_dequeue(&sock->sk->sk_receive_queue))) {	544	reject_rx_queue(sk);
482	tipc_reject_msg(buf, TIPC_ERR_NO_PORT);
483	atomic_dec(&tipc_queue_size);
484	}
485
486	sock->state = SS_CONNECTING;
487	}	545	}
488		546
489	do {	547	do {
490	if (dest->addrtype == TIPC_ADDR_NAME) {	548	if (dest->addrtype == TIPC_ADDR_NAME) {
491	if ((res = dest_name_check(dest, m)))	549	if ((res = dest_name_check(dest, m)))
492	goto exit;	550	break;
493	res = tipc_send2name(tsock->p->ref,	551	res = tipc_send2name(tport->ref,
494	&dest->addr.name.name,	552	&dest->addr.name.name,
495	dest->addr.name.domain,	553	dest->addr.name.domain,
496	m->msg_iovlen,	554	m->msg_iovlen,
497	m->msg_iov);	555	m->msg_iov);
498	}	556	}
499	else if (dest->addrtype == TIPC_ADDR_ID) {	557	else if (dest->addrtype == TIPC_ADDR_ID) {
500	res = tipc_send2port(tsock->p->ref,	558	res = tipc_send2port(tport->ref,
501	&dest->addr.id,	559	&dest->addr.id,
502	m->msg_iovlen,	560	m->msg_iovlen,
503	m->msg_iov);	561	m->msg_iov);
504	}	562	}
505	else if (dest->addrtype == TIPC_ADDR_MCAST) {	563	else if (dest->addrtype == TIPC_ADDR_MCAST) {
506	if (needs_conn) {	564	if (needs_conn) {
507	res = -EOPNOTSUPP;	565	res = -EOPNOTSUPP;
508	goto exit;	566	break;
509	}	567	}
510	if ((res = dest_name_check(dest, m)))	568	if ((res = dest_name_check(dest, m)))
511	goto exit;	569	break;
512	res = tipc_multicast(tsock->p->ref,	570	res = tipc_multicast(tport->ref,
513	&dest->addr.nameseq,	571	&dest->addr.nameseq,
514	0,	572	0,
515	m->msg_iovlen,	573	m->msg_iovlen,
516	m->msg_iov);	574	m->msg_iov);
517	}	575	}
518	if (likely(res != -ELINKCONG)) {	576	if (likely(res != -ELINKCONG)) {
519	exit:	577	if (needs_conn && (res >= 0)) {
520	mutex_unlock(&tsock->lock);	578	sock->state = SS_CONNECTING;
521	return res;	579	}
		580	break;
522	}	581	}
523	if (m->msg_flags & MSG_DONTWAIT) {	582	if (m->msg_flags & MSG_DONTWAIT) {
524	res = -EWOULDBLOCK;	583	res = -EWOULDBLOCK;
525	goto exit;	584	break;
526	}	585	}
527	if (wait_event_interruptible(*sock->sk->sk_sleep,	586	release_sock(sk);
528	!tsock->p->congested)) {	587	res = wait_event_interruptible(*sk->sk_sleep,
529	res = -ERESTARTSYS;	588	!tport->congested);
530	goto exit;	589	lock_sock(sk);
531	}	590	if (res)
		591	break;
532	} while (1);	592	} while (1);
		593
		594	exit:
		595	if (iocb)
		596	release_sock(sk);
		597	return res;
533	}	598	}
534		599
535	/**	600	/**
536	* send_packet - send a connection-oriented message	601	* send_packet - send a connection-oriented message
537	* @iocb: (unused)	602	* @iocb: if NULL, indicates that socket lock is already held
538	* @sock: socket structure	603	* @sock: socket structure
539	* @m: message to send	604	* @m: message to send
540	* @total_len: length of message	605	* @total_len: length of message
541	*	606	*
542	* Used for SOCK_SEQPACKET messages and SOCK_STREAM data.	607	* Used for SOCK_SEQPACKET messages and SOCK_STREAM data.
543	*	608	*
544	* Returns the number of bytes sent on success, or errno otherwise	609	* Returns the number of bytes sent on success, or errno otherwise
545	*/	610	*/
546		611
547	static int send_packet(struct kiocb iocb, struct socket sock,	612	static int send_packet(struct kiocb iocb, struct socket sock,
548	struct msghdr *m, size_t total_len)	613	struct msghdr *m, size_t total_len)
549	{	614	{
550	struct tipc_sock *tsock = tipc_sk(sock->sk);	615	struct sock *sk = sock->sk;
		616	struct tipc_port *tport = tipc_sk_port(sk);
551	struct sockaddr_tipc dest = (struct sockaddr_tipc )m->msg_name;	617	struct sockaddr_tipc dest = (struct sockaddr_tipc )m->msg_name;
552	int res;	618	int res;
553		619
554	/* Handle implied connection establishment */	620	/* Handle implied connection establishment */
555		621
556	if (unlikely(dest))	622	if (unlikely(dest))
557	return send_msg(iocb, sock, m, total_len);	623	return send_msg(iocb, sock, m, total_len);
558		624
559	if (mutex_lock_interruptible(&tsock->lock)) {	625	if (iocb)
560	return -ERESTARTSYS;	626	lock_sock(sk);
561	}
562		627
563	do {	628	do {
564	if (unlikely(sock->state != SS_CONNECTED)) {	629	if (unlikely(sock->state != SS_CONNECTED)) {
565	if (sock->state == SS_DISCONNECTING)	630	if (sock->state == SS_DISCONNECTING)
566	res = -EPIPE;	631	res = -EPIPE;
567	else	632	else
568	res = -ENOTCONN;	633	res = -ENOTCONN;
569	goto exit;	634	break;
570	}	635	}
571		636
572	res = tipc_send(tsock->p->ref, m->msg_iovlen, m->msg_iov);	637	res = tipc_send(tport->ref, m->msg_iovlen, m->msg_iov);
573	if (likely(res != -ELINKCONG)) {	638	if (likely(res != -ELINKCONG)) {
574	exit:	639	break;
575	mutex_unlock(&tsock->lock);
576	return res;
577	}	640	}
578	if (m->msg_flags & MSG_DONTWAIT) {	641	if (m->msg_flags & MSG_DONTWAIT) {
579	res = -EWOULDBLOCK;	642	res = -EWOULDBLOCK;
580	goto exit;	643	break;
581	}	644	}
582	if (wait_event_interruptible(*sock->sk->sk_sleep,	645	release_sock(sk);
583	!tsock->p->congested)) {	646	res = wait_event_interruptible(*sk->sk_sleep,
584	res = -ERESTARTSYS;	647	(!tport->congested \|\| !tport->connected));
585	goto exit;	648	lock_sock(sk);
586	}	649	if (res)
		650	break;
587	} while (1);	651	} while (1);
		652
		653	if (iocb)
		654	release_sock(sk);
		655	return res;
588	}	656	}
589		657
590	/**	658	/**
591	* send_stream - send stream-oriented data	659	* send_stream - send stream-oriented data
592	* @iocb: (unused)	660	* @iocb: (unused)
593	* @sock: socket structure	661	* @sock: socket structure
594	* @m: data to send	662	* @m: data to send
595	* @total_len: total length of data to be sent	663	* @total_len: total length of data to be sent
596	*	664	*
597	* Used for SOCK_STREAM data.	665	* Used for SOCK_STREAM data.
598	*	666	*
599	* Returns the number of bytes sent on success (or partial success),	667	* Returns the number of bytes sent on success (or partial success),
600	* or errno if no data sent	668	* or errno if no data sent
601	*/	669	*/
602		670
603
604	static int send_stream(struct kiocb iocb, struct socket sock,	671	static int send_stream(struct kiocb iocb, struct socket sock,
605	struct msghdr *m, size_t total_len)	672	struct msghdr *m, size_t total_len)
606	{	673	{
607	struct tipc_port *tport;	674	struct sock *sk = sock->sk;
		675	struct tipc_port *tport = tipc_sk_port(sk);
608	struct msghdr my_msg;	676	struct msghdr my_msg;
609	struct iovec my_iov;	677	struct iovec my_iov;
610	struct iovec *curr_iov;	678	struct iovec *curr_iov;
611	int curr_iovlen;	679	int curr_iovlen;
612	char __user *curr_start;	680	char __user *curr_start;
613	u32 hdr_size;	681	u32 hdr_size;
614	int curr_left;	682	int curr_left;
615	int bytes_to_send;	683	int bytes_to_send;
616	int bytes_sent;	684	int bytes_sent;
617	int res;	685	int res;
618		686
		687	lock_sock(sk);
		688
619	/* Handle special cases where there is no connection */	689	/* Handle special cases where there is no connection */
620		690
621	if (unlikely(sock->state != SS_CONNECTED)) {	691	if (unlikely(sock->state != SS_CONNECTED)) {
622	if (sock->state == SS_UNCONNECTED)	692	if (sock->state == SS_UNCONNECTED) {
623	return send_packet(iocb, sock, m, total_len);	693	res = send_packet(NULL, sock, m, total_len);
624	else if (sock->state == SS_DISCONNECTING)	694	goto exit;
625	return -EPIPE;	695	} else if (sock->state == SS_DISCONNECTING) {
626	else	696	res = -EPIPE;
627	return -ENOTCONN;	697	goto exit;
		698	} else {
		699	res = -ENOTCONN;
		700	goto exit;
		701	}
628	}	702	}
629		703
630	if (unlikely(m->msg_name))	704	if (unlikely(m->msg_name)) {
631	return -EISCONN;	705	res = -EISCONN;
		706	goto exit;
		707	}
632		708
633	/*	709	/*
634	* Send each iovec entry using one or more messages	710	* Send each iovec entry using one or more messages
635	*	711	*
636	* Note: This algorithm is good for the most likely case	712	* Note: This algorithm is good for the most likely case
637	* (i.e. one large iovec entry), but could be improved to pass sets	713	* (i.e. one large iovec entry), but could be improved to pass sets
638	* of small iovec entries into send_packet().	714	* of small iovec entries into send_packet().
639	*/	715	*/
640		716
641	curr_iov = m->msg_iov;	717	curr_iov = m->msg_iov;
642	curr_iovlen = m->msg_iovlen;	718	curr_iovlen = m->msg_iovlen;
643	my_msg.msg_iov = &my_iov;	719	my_msg.msg_iov = &my_iov;
644	my_msg.msg_iovlen = 1;	720	my_msg.msg_iovlen = 1;
645	my_msg.msg_flags = m->msg_flags;	721	my_msg.msg_flags = m->msg_flags;
646	my_msg.msg_name = NULL;	722	my_msg.msg_name = NULL;
647	bytes_sent = 0;	723	bytes_sent = 0;
648		724
649	tport = tipc_sk(sock->sk)->p;
650	hdr_size = msg_hdr_sz(&tport->phdr);	725	hdr_size = msg_hdr_sz(&tport->phdr);
651		726
652	while (curr_iovlen--) {	727	while (curr_iovlen--) {
653	curr_start = curr_iov->iov_base;	728	curr_start = curr_iov->iov_base;
654	curr_left = curr_iov->iov_len;	729	curr_left = curr_iov->iov_len;
655		730
656	while (curr_left) {	731	while (curr_left) {
657	bytes_to_send = tport->max_pkt - hdr_size;	732	bytes_to_send = tport->max_pkt - hdr_size;
658	if (bytes_to_send > TIPC_MAX_USER_MSG_SIZE)	733	if (bytes_to_send > TIPC_MAX_USER_MSG_SIZE)
659	bytes_to_send = TIPC_MAX_USER_MSG_SIZE;	734	bytes_to_send = TIPC_MAX_USER_MSG_SIZE;
660	if (curr_left < bytes_to_send)	735	if (curr_left < bytes_to_send)
661	bytes_to_send = curr_left;	736	bytes_to_send = curr_left;
662	my_iov.iov_base = curr_start;	737	my_iov.iov_base = curr_start;
663	my_iov.iov_len = bytes_to_send;	738	my_iov.iov_len = bytes_to_send;
664	if ((res = send_packet(iocb, sock, &my_msg, 0)) < 0) {	739	if ((res = send_packet(NULL, sock, &my_msg, 0)) < 0) {
665	if (bytes_sent != 0)	740	if (bytes_sent)
666	res = bytes_sent;	741	res = bytes_sent;
667	return res;	742	goto exit;
668	}	743	}
669	curr_left -= bytes_to_send;	744	curr_left -= bytes_to_send;
670	curr_start += bytes_to_send;	745	curr_start += bytes_to_send;
671	bytes_sent += bytes_to_send;	746	bytes_sent += bytes_to_send;
672	}	747	}
673		748
674	curr_iov++;	749	curr_iov++;
675	}	750	}
676		751	res = bytes_sent;
677	return bytes_sent;	752	exit:
		753	release_sock(sk);
		754	return res;
678	}	755	}
679		756
680	/**	757	/**
681	* auto_connect - complete connection setup to a remote port	758	* auto_connect - complete connection setup to a remote port
682	* @sock: socket structure	759	* @sock: socket structure
683	* @tsock: TIPC-specific socket structure
684	* @msg: peer's response message	760	* @msg: peer's response message
685	*	761	*
686	* Returns 0 on success, errno otherwise	762	* Returns 0 on success, errno otherwise
687	*/	763	*/
688		764
689	static int auto_connect(struct socket sock, struct tipc_sock tsock,	765	static int auto_connect(struct socket sock, struct tipc_msg msg)
690	struct tipc_msg *msg)
691	{	766	{
		767	struct tipc_port *tport = tipc_sk_port(sock->sk);
692	struct tipc_portid peer;	768	struct tipc_portid peer;
693		769
694	if (msg_errcode(msg)) {	770	if (msg_errcode(msg)) {
695	sock->state = SS_DISCONNECTING;	771	sock->state = SS_DISCONNECTING;
696	return -ECONNREFUSED;	772	return -ECONNREFUSED;
697	}	773	}
698		774
699	peer.ref = msg_origport(msg);	775	peer.ref = msg_origport(msg);
700	peer.node = msg_orignode(msg);	776	peer.node = msg_orignode(msg);
701	tipc_connect2port(tsock->p->ref, &peer);	777	tipc_connect2port(tport->ref, &peer);
702	tipc_set_portimportance(tsock->p->ref, msg_importance(msg));	778	tipc_set_portimportance(tport->ref, msg_importance(msg));
703	sock->state = SS_CONNECTED;	779	sock->state = SS_CONNECTED;
704	return 0;	780	return 0;
705	}	781	}
706		782
707	/**	783	/**
708	* set_orig_addr - capture sender's address for received message	784	* set_orig_addr - capture sender's address for received message
709	* @m: descriptor for message info	785	* @m: descriptor for message info
710	* @msg: received message header	786	* @msg: received message header
711	*	787	*
712	* Note: Address is not captured if not requested by receiver.	788	* Note: Address is not captured if not requested by receiver.
713	*/	789	*/
714		790
715	static void set_orig_addr(struct msghdr m, struct tipc_msg msg)	791	static void set_orig_addr(struct msghdr m, struct tipc_msg msg)
716	{	792	{
717	struct sockaddr_tipc addr = (struct sockaddr_tipc )m->msg_name;	793	struct sockaddr_tipc addr = (struct sockaddr_tipc )m->msg_name;
718		794
719	if (addr) {	795	if (addr) {
720	addr->family = AF_TIPC;	796	addr->family = AF_TIPC;
721	addr->addrtype = TIPC_ADDR_ID;	797	addr->addrtype = TIPC_ADDR_ID;
722	addr->addr.id.ref = msg_origport(msg);	798	addr->addr.id.ref = msg_origport(msg);
723	addr->addr.id.node = msg_orignode(msg);	799	addr->addr.id.node = msg_orignode(msg);
724	addr->addr.name.domain = 0; /* could leave uninitialized */	800	addr->addr.name.domain = 0; /* could leave uninitialized */
725	addr->scope = 0; /* could leave uninitialized */	801	addr->scope = 0; /* could leave uninitialized */
726	m->msg_namelen = sizeof(struct sockaddr_tipc);	802	m->msg_namelen = sizeof(struct sockaddr_tipc);
727	}	803	}
728	}	804	}
729		805
730	/**	806	/**
731	* anc_data_recv - optionally capture ancillary data for received message	807	* anc_data_recv - optionally capture ancillary data for received message
732	* @m: descriptor for message info	808	* @m: descriptor for message info
733	* @msg: received message header	809	* @msg: received message header
734	* @tport: TIPC port associated with message	810	* @tport: TIPC port associated with message
735	*	811	*
736	* Note: Ancillary data is not captured if not requested by receiver.	812	* Note: Ancillary data is not captured if not requested by receiver.
737	*	813	*
738	* Returns 0 if successful, otherwise errno	814	* Returns 0 if successful, otherwise errno
739	*/	815	*/
740		816
741	static int anc_data_recv(struct msghdr m, struct tipc_msg msg,	817	static int anc_data_recv(struct msghdr m, struct tipc_msg msg,
742	struct tipc_port *tport)	818	struct tipc_port *tport)
743	{	819	{
744	u32 anc_data[3];	820	u32 anc_data[3];
745	u32 err;	821	u32 err;
746	u32 dest_type;	822	u32 dest_type;
747	int has_name;	823	int has_name;
748	int res;	824	int res;
749		825
750	if (likely(m->msg_controllen == 0))	826	if (likely(m->msg_controllen == 0))
751	return 0;	827	return 0;
752		828
753	/* Optionally capture errored message object(s) */	829	/* Optionally capture errored message object(s) */
754		830
755	err = msg ? msg_errcode(msg) : 0;	831	err = msg ? msg_errcode(msg) : 0;
756	if (unlikely(err)) {	832	if (unlikely(err)) {
757	anc_data[0] = err;	833	anc_data[0] = err;
758	anc_data[1] = msg_data_sz(msg);	834	anc_data[1] = msg_data_sz(msg);
759	if ((res = put_cmsg(m, SOL_TIPC, TIPC_ERRINFO, 8, anc_data)))	835	if ((res = put_cmsg(m, SOL_TIPC, TIPC_ERRINFO, 8, anc_data)))
760	return res;	836	return res;
761	if (anc_data[1] &&	837	if (anc_data[1] &&
762	(res = put_cmsg(m, SOL_TIPC, TIPC_RETDATA, anc_data[1],	838	(res = put_cmsg(m, SOL_TIPC, TIPC_RETDATA, anc_data[1],
763	msg_data(msg))))	839	msg_data(msg))))
764	return res;	840	return res;
765	}	841	}
766		842
767	/* Optionally capture message destination object */	843	/* Optionally capture message destination object */
768		844
769	dest_type = msg ? msg_type(msg) : TIPC_DIRECT_MSG;	845	dest_type = msg ? msg_type(msg) : TIPC_DIRECT_MSG;
770	switch (dest_type) {	846	switch (dest_type) {
771	case TIPC_NAMED_MSG:	847	case TIPC_NAMED_MSG:
772	has_name = 1;	848	has_name = 1;
773	anc_data[0] = msg_nametype(msg);	849	anc_data[0] = msg_nametype(msg);
774	anc_data[1] = msg_namelower(msg);	850	anc_data[1] = msg_namelower(msg);
775	anc_data[2] = msg_namelower(msg);	851	anc_data[2] = msg_namelower(msg);
776	break;	852	break;
777	case TIPC_MCAST_MSG:	853	case TIPC_MCAST_MSG:
778	has_name = 1;	854	has_name = 1;
779	anc_data[0] = msg_nametype(msg);	855	anc_data[0] = msg_nametype(msg);
780	anc_data[1] = msg_namelower(msg);	856	anc_data[1] = msg_namelower(msg);
781	anc_data[2] = msg_nameupper(msg);	857	anc_data[2] = msg_nameupper(msg);
782	break;	858	break;
783	case TIPC_CONN_MSG:	859	case TIPC_CONN_MSG:
784	has_name = (tport->conn_type != 0);	860	has_name = (tport->conn_type != 0);
785	anc_data[0] = tport->conn_type;	861	anc_data[0] = tport->conn_type;
786	anc_data[1] = tport->conn_instance;	862	anc_data[1] = tport->conn_instance;
787	anc_data[2] = tport->conn_instance;	863	anc_data[2] = tport->conn_instance;
788	break;	864	break;
789	default:	865	default:
790	has_name = 0;	866	has_name = 0;
791	}	867	}
792	if (has_name &&	868	if (has_name &&
793	(res = put_cmsg(m, SOL_TIPC, TIPC_DESTNAME, 12, anc_data)))	869	(res = put_cmsg(m, SOL_TIPC, TIPC_DESTNAME, 12, anc_data)))
794	return res;	870	return res;
795		871
796	return 0;	872	return 0;
797	}	873	}
798		874
799	/**	875	/**
800	* recv_msg - receive packet-oriented message	876	* recv_msg - receive packet-oriented message
801	* @iocb: (unused)	877	* @iocb: (unused)
802	* @m: descriptor for message info	878	* @m: descriptor for message info
803	* @buf_len: total size of user buffer area	879	* @buf_len: total size of user buffer area
804	* @flags: receive flags	880	* @flags: receive flags
805	*	881	*
806	* Used for SOCK_DGRAM, SOCK_RDM, and SOCK_SEQPACKET messages.	882	* Used for SOCK_DGRAM, SOCK_RDM, and SOCK_SEQPACKET messages.
807	* If the complete message doesn't fit in user area, truncate it.	883	* If the complete message doesn't fit in user area, truncate it.
808	*	884	*
809	* Returns size of returned message data, errno otherwise	885	* Returns size of returned message data, errno otherwise
810	*/	886	*/
811		887
812	static int recv_msg(struct kiocb iocb, struct socket sock,	888	static int recv_msg(struct kiocb iocb, struct socket sock,
813	struct msghdr *m, size_t buf_len, int flags)	889	struct msghdr *m, size_t buf_len, int flags)
814	{	890	{
815	struct tipc_sock *tsock = tipc_sk(sock->sk);	891	struct sock *sk = sock->sk;
		892	struct tipc_port *tport = tipc_sk_port(sk);
816	struct sk_buff *buf;	893	struct sk_buff *buf;
817	struct tipc_msg *msg;	894	struct tipc_msg *msg;
818	unsigned int q_len;
819	unsigned int sz;	895	unsigned int sz;
820	u32 err;	896	u32 err;
821	int res;	897	int res;
822		898
823	/* Currently doesn't support receiving into multiple iovec entries */	899	/* Catch invalid receive requests */
824		900
825	if (m->msg_iovlen != 1)	901	if (m->msg_iovlen != 1)
826	return -EOPNOTSUPP;	902	return -EOPNOTSUPP; /* Don't do multiple iovec entries yet */
827		903
828	/* Catch invalid receive attempts */
829
830	if (unlikely(!buf_len))	904	if (unlikely(!buf_len))
831	return -EINVAL;	905	return -EINVAL;
832		906
833	if (sock->type == SOCK_SEQPACKET) {	907	lock_sock(sk);
834	if (unlikely(sock->state == SS_UNCONNECTED))
835	return -ENOTCONN;
836	if (unlikely((sock->state == SS_DISCONNECTING) &&
837	(skb_queue_len(&sock->sk->sk_receive_queue) == 0)))
838	return -ENOTCONN;
839	}
840		908
841	/* Look for a message in receive queue; wait if necessary */	909	if (unlikely(sock->state == SS_UNCONNECTED)) {
842		910	res = -ENOTCONN;
843	if (unlikely(mutex_lock_interruptible(&tsock->lock)))
844	return -ERESTARTSYS;
845
846	restart:
847	if (unlikely((skb_queue_len(&sock->sk->sk_receive_queue) == 0) &&
848	(flags & MSG_DONTWAIT))) {
849	res = -EWOULDBLOCK;
850	goto exit;	911	goto exit;
851	}	912	}
852		913
853	if ((res = wait_event_interruptible(	914	restart:
854	*sock->sk->sk_sleep,
855	((q_len = skb_queue_len(&sock->sk->sk_receive_queue)) \|\|
856	(sock->state == SS_DISCONNECTING))) )) {
857	goto exit;
858	}
859		915
860	/* Catch attempt to receive on an already terminated connection */	916	/* Look for a message in receive queue; wait if necessary */
861	/* [THIS CHECK MAY OVERLAP WITH AN EARLIER CHECK] */
862		917
863	if (!q_len) {	918	while (skb_queue_empty(&sk->sk_receive_queue)) {
864	res = -ENOTCONN;	919	if (sock->state == SS_DISCONNECTING) {
865	goto exit;	920	res = -ENOTCONN;
		921	goto exit;
		922	}
		923	if (flags & MSG_DONTWAIT) {
		924	res = -EWOULDBLOCK;
		925	goto exit;
		926	}
		927	release_sock(sk);
		928	res = wait_event_interruptible(*sk->sk_sleep,
		929	(!skb_queue_empty(&sk->sk_receive_queue) \|\|
		930	(sock->state == SS_DISCONNECTING)));
		931	lock_sock(sk);
		932	if (res)
		933	goto exit;
866	}	934	}
867		935
868	/* Get access to first message in receive queue */	936	/* Look at first message in receive queue */
869		937
870	buf = skb_peek(&sock->sk->sk_receive_queue);	938	buf = skb_peek(&sk->sk_receive_queue);
871	msg = buf_msg(buf);	939	msg = buf_msg(buf);
872	sz = msg_data_sz(msg);	940	sz = msg_data_sz(msg);
873	err = msg_errcode(msg);	941	err = msg_errcode(msg);
874		942
875	/* Complete connection setup for an implied connect */	943	/* Complete connection setup for an implied connect */
876		944
877	if (unlikely(sock->state == SS_CONNECTING)) {	945	if (unlikely(sock->state == SS_CONNECTING)) {
878	if ((res = auto_connect(sock, tsock, msg)))	946	res = auto_connect(sock, msg);
		947	if (res)
879	goto exit;	948	goto exit;
880	}	949	}
881		950
882	/* Discard an empty non-errored message & try again */	951	/* Discard an empty non-errored message & try again */
883		952
884	if ((!sz) && (!err)) {	953	if ((!sz) && (!err)) {
885	advance_queue(tsock);	954	advance_rx_queue(sk);
886	goto restart;	955	goto restart;
887	}	956	}
888		957
889	/* Capture sender's address (optional) */	958	/* Capture sender's address (optional) */
890		959
891	set_orig_addr(m, msg);	960	set_orig_addr(m, msg);
892		961
893	/* Capture ancillary data (optional) */	962	/* Capture ancillary data (optional) */
894		963
895	if ((res = anc_data_recv(m, msg, tsock->p)))	964	res = anc_data_recv(m, msg, tport);
		965	if (res)
896	goto exit;	966	goto exit;
897		967
898	/* Capture message data (if valid) & compute return value (always) */	968	/* Capture message data (if valid) & compute return value (always) */
899		969
900	if (!err) {	970	if (!err) {
901	if (unlikely(buf_len < sz)) {	971	if (unlikely(buf_len < sz)) {
902	sz = buf_len;	972	sz = buf_len;
903	m->msg_flags \|= MSG_TRUNC;	973	m->msg_flags \|= MSG_TRUNC;
904	}	974	}
905	if (unlikely(copy_to_user(m->msg_iov->iov_base, msg_data(msg),	975	if (unlikely(copy_to_user(m->msg_iov->iov_base, msg_data(msg),
906	sz))) {	976	sz))) {
907	res = -EFAULT;	977	res = -EFAULT;
908	goto exit;	978	goto exit;
909	}	979	}
910	res = sz;	980	res = sz;
911	} else {	981	} else {
912	if ((sock->state == SS_READY) \|\|	982	if ((sock->state == SS_READY) \|\|
913	((err == TIPC_CONN_SHUTDOWN) \|\| m->msg_control))	983	((err == TIPC_CONN_SHUTDOWN) \|\| m->msg_control))
914	res = 0;	984	res = 0;
915	else	985	else
916	res = -ECONNRESET;	986	res = -ECONNRESET;
917	}	987	}
918		988
919	/* Consume received message (optional) */	989	/* Consume received message (optional) */
920		990
921	if (likely(!(flags & MSG_PEEK))) {	991	if (likely(!(flags & MSG_PEEK))) {
922	if ((sock->state != SS_READY) &&	992	if ((sock->state != SS_READY) &&
923	(++tsock->p->conn_unacked >= TIPC_FLOW_CONTROL_WIN))	993	(++tport->conn_unacked >= TIPC_FLOW_CONTROL_WIN))
924	tipc_acknowledge(tsock->p->ref, tsock->p->conn_unacked);	994	tipc_acknowledge(tport->ref, tport->conn_unacked);
925	advance_queue(tsock);	995	advance_rx_queue(sk);
926	}	996	}
927	exit:	997	exit:
928	mutex_unlock(&tsock->lock);	998	release_sock(sk);
929	return res;	999	return res;
930	}	1000	}
931		1001
932	/**	1002	/**
933	* recv_stream - receive stream-oriented data	1003	* recv_stream - receive stream-oriented data
934	* @iocb: (unused)	1004	* @iocb: (unused)
935	* @m: descriptor for message info	1005	* @m: descriptor for message info
936	* @buf_len: total size of user buffer area	1006	* @buf_len: total size of user buffer area
937	* @flags: receive flags	1007	* @flags: receive flags
938	*	1008	*
939	* Used for SOCK_STREAM messages only. If not enough data is available	1009	* Used for SOCK_STREAM messages only. If not enough data is available
940	* will optionally wait for more; never truncates data.	1010	* will optionally wait for more; never truncates data.
941	*	1011	*
942	* Returns size of returned message data, errno otherwise	1012	* Returns size of returned message data, errno otherwise
943	*/	1013	*/
944		1014
945	static int recv_stream(struct kiocb iocb, struct socket sock,	1015	static int recv_stream(struct kiocb iocb, struct socket sock,
946	struct msghdr *m, size_t buf_len, int flags)	1016	struct msghdr *m, size_t buf_len, int flags)
947	{	1017	{
948	struct tipc_sock *tsock = tipc_sk(sock->sk);	1018	struct sock *sk = sock->sk;
		1019	struct tipc_port *tport = tipc_sk_port(sk);
949	struct sk_buff *buf;	1020	struct sk_buff *buf;
950	struct tipc_msg *msg;	1021	struct tipc_msg *msg;
951	unsigned int q_len;
952	unsigned int sz;	1022	unsigned int sz;
953	int sz_to_copy;	1023	int sz_to_copy;
954	int sz_copied = 0;	1024	int sz_copied = 0;
955	int needed;	1025	int needed;
956	char __user *crs = m->msg_iov->iov_base;	1026	char __user *crs = m->msg_iov->iov_base;
957	unsigned char *buf_crs;	1027	unsigned char *buf_crs;
958	u32 err;	1028	u32 err;
959	int res;	1029	int res = 0;
960		1030
961	/* Currently doesn't support receiving into multiple iovec entries */	1031	/* Catch invalid receive attempts */
962		1032
963	if (m->msg_iovlen != 1)	1033	if (m->msg_iovlen != 1)
964	return -EOPNOTSUPP;	1034	return -EOPNOTSUPP; /* Don't do multiple iovec entries yet */
965		1035
966	/* Catch invalid receive attempts */
967
968	if (unlikely(!buf_len))	1036	if (unlikely(!buf_len))
969	return -EINVAL;	1037	return -EINVAL;
970		1038
971	if (unlikely(sock->state == SS_DISCONNECTING)) {	1039	lock_sock(sk);
972	if (skb_queue_len(&sock->sk->sk_receive_queue) == 0)
973	return -ENOTCONN;
974	} else if (unlikely(sock->state != SS_CONNECTED))
975	return -ENOTCONN;
976		1040
977	/* Look for a message in receive queue; wait if necessary */	1041	if (unlikely((sock->state == SS_UNCONNECTED) \|\|
978		1042	(sock->state == SS_CONNECTING))) {
979	if (unlikely(mutex_lock_interruptible(&tsock->lock)))	1043	res = -ENOTCONN;
980	return -ERESTARTSYS;
981
982	restart:
983	if (unlikely((skb_queue_len(&sock->sk->sk_receive_queue) == 0) &&
984	(flags & MSG_DONTWAIT))) {
985	res = -EWOULDBLOCK;
986	goto exit;	1044	goto exit;
987	}	1045	}
988		1046
989	if ((res = wait_event_interruptible(	1047	restart:
990	*sock->sk->sk_sleep,
991	((q_len = skb_queue_len(&sock->sk->sk_receive_queue)) \|\|
992	(sock->state == SS_DISCONNECTING))) )) {
993	goto exit;
994	}
995		1048
996	/* Catch attempt to receive on an already terminated connection */	1049	/* Look for a message in receive queue; wait if necessary */
997	/* [THIS CHECK MAY OVERLAP WITH AN EARLIER CHECK] */
998		1050
999	if (!q_len) {	1051	while (skb_queue_empty(&sk->sk_receive_queue)) {
1000	res = -ENOTCONN;	1052	if (sock->state == SS_DISCONNECTING) {
1001	goto exit;	1053	res = -ENOTCONN;
		1054	goto exit;
		1055	}
		1056	if (flags & MSG_DONTWAIT) {
		1057	res = -EWOULDBLOCK;
		1058	goto exit;
		1059	}
		1060	release_sock(sk);
		1061	res = wait_event_interruptible(*sk->sk_sleep,
		1062	(!skb_queue_empty(&sk->sk_receive_queue) \|\|
		1063	(sock->state == SS_DISCONNECTING)));
		1064	lock_sock(sk);
		1065	if (res)
		1066	goto exit;
1002	}	1067	}
1003		1068
1004	/* Get access to first message in receive queue */	1069	/* Look at first message in receive queue */
1005		1070
1006	buf = skb_peek(&sock->sk->sk_receive_queue);	1071	buf = skb_peek(&sk->sk_receive_queue);
1007	msg = buf_msg(buf);	1072	msg = buf_msg(buf);
1008	sz = msg_data_sz(msg);	1073	sz = msg_data_sz(msg);
1009	err = msg_errcode(msg);	1074	err = msg_errcode(msg);
1010		1075
1011	/* Discard an empty non-errored message & try again */	1076	/* Discard an empty non-errored message & try again */
1012		1077
1013	if ((!sz) && (!err)) {	1078	if ((!sz) && (!err)) {
1014	advance_queue(tsock);	1079	advance_rx_queue(sk);
1015	goto restart;	1080	goto restart;
1016	}	1081	}
1017		1082
1018	/* Optionally capture sender's address & ancillary data of first msg */	1083	/* Optionally capture sender's address & ancillary data of first msg */
1019		1084
1020	if (sz_copied == 0) {	1085	if (sz_copied == 0) {
1021	set_orig_addr(m, msg);	1086	set_orig_addr(m, msg);
1022	if ((res = anc_data_recv(m, msg, tsock->p)))	1087	res = anc_data_recv(m, msg, tport);
		1088	if (res)
1023	goto exit;	1089	goto exit;
1024	}	1090	}
1025		1091
1026	/* Capture message data (if valid) & compute return value (always) */	1092	/* Capture message data (if valid) & compute return value (always) */
1027		1093
1028	if (!err) {	1094	if (!err) {
1029	buf_crs = (unsigned char *)(TIPC_SKB_CB(buf)->handle);	1095	buf_crs = (unsigned char *)(TIPC_SKB_CB(buf)->handle);
1030	sz = (unsigned char *)msg + msg_size(msg) - buf_crs;	1096	sz = (unsigned char *)msg + msg_size(msg) - buf_crs;
1031		1097
1032	needed = (buf_len - sz_copied);	1098	needed = (buf_len - sz_copied);
1033	sz_to_copy = (sz <= needed) ? sz : needed;	1099	sz_to_copy = (sz <= needed) ? sz : needed;
1034	if (unlikely(copy_to_user(crs, buf_crs, sz_to_copy))) {	1100	if (unlikely(copy_to_user(crs, buf_crs, sz_to_copy))) {
1035	res = -EFAULT;	1101	res = -EFAULT;
1036	goto exit;	1102	goto exit;
1037	}	1103	}
1038	sz_copied += sz_to_copy;	1104	sz_copied += sz_to_copy;
1039		1105
1040	if (sz_to_copy < sz) {	1106	if (sz_to_copy < sz) {
1041	if (!(flags & MSG_PEEK))	1107	if (!(flags & MSG_PEEK))
1042	TIPC_SKB_CB(buf)->handle = buf_crs + sz_to_copy;	1108	TIPC_SKB_CB(buf)->handle = buf_crs + sz_to_copy;
1043	goto exit;	1109	goto exit;
1044	}	1110	}
1045		1111
1046	crs += sz_to_copy;	1112	crs += sz_to_copy;
1047	} else {	1113	} else {
1048	if (sz_copied != 0)	1114	if (sz_copied != 0)
1049	goto exit; /* can't add error msg to valid data */	1115	goto exit; /* can't add error msg to valid data */
1050		1116
1051	if ((err == TIPC_CONN_SHUTDOWN) \|\| m->msg_control)	1117	if ((err == TIPC_CONN_SHUTDOWN) \|\| m->msg_control)
1052	res = 0;	1118	res = 0;
1053	else	1119	else
1054	res = -ECONNRESET;	1120	res = -ECONNRESET;
1055	}	1121	}
1056		1122
1057	/* Consume received message (optional) */	1123	/* Consume received message (optional) */
1058		1124
1059	if (likely(!(flags & MSG_PEEK))) {	1125	if (likely(!(flags & MSG_PEEK))) {
1060	if (unlikely(++tsock->p->conn_unacked >= TIPC_FLOW_CONTROL_WIN))	1126	if (unlikely(++tport->conn_unacked >= TIPC_FLOW_CONTROL_WIN))
1061	tipc_acknowledge(tsock->p->ref, tsock->p->conn_unacked);	1127	tipc_acknowledge(tport->ref, tport->conn_unacked);
1062	advance_queue(tsock);	1128	advance_rx_queue(sk);
1063	}	1129	}
1064		1130
1065	/* Loop around if more data is required */	1131	/* Loop around if more data is required */
1066		1132
1067	if ((sz_copied < buf_len) /* didn't get all requested data */	1133	if ((sz_copied < buf_len) /* didn't get all requested data */
1068	&& (!skb_queue_empty(&sock->sk->sk_receive_queue) \|\|	1134	&& (!skb_queue_empty(&sock->sk->sk_receive_queue) \|\|
1069	(flags & MSG_WAITALL))	1135	(flags & MSG_WAITALL))
1070	/* ... and more is ready or required */	1136	/* ... and more is ready or required */
1071	&& (!(flags & MSG_PEEK)) /* ... and aren't just peeking at data */	1137	&& (!(flags & MSG_PEEK)) /* ... and aren't just peeking at data */
1072	&& (!err) /* ... and haven't reached a FIN */	1138	&& (!err) /* ... and haven't reached a FIN */
1073	)	1139	)
1074	goto restart;	1140	goto restart;
1075		1141
1076	exit:	1142	exit:
1077	mutex_unlock(&tsock->lock);	1143	release_sock(sk);
1078	return sz_copied ? sz_copied : res;	1144	return sz_copied ? sz_copied : res;
1079	}	1145	}
1080		1146
1081	/**	1147	/**
1082	* rx_queue_full - determine if receive queue can accept another message	1148	* rx_queue_full - determine if receive queue can accept another message
1083	* @msg: message to be added to queue	1149	* @msg: message to be added to queue
1084	* @queue_size: current size of queue	1150	* @queue_size: current size of queue
1085	* @base: nominal maximum size of queue	1151	* @base: nominal maximum size of queue
1086	*	1152	*
1087	* Returns 1 if queue is unable to accept message, 0 otherwise	1153	* Returns 1 if queue is unable to accept message, 0 otherwise
1088	*/	1154	*/
1089		1155
1090	static int rx_queue_full(struct tipc_msg *msg, u32 queue_size, u32 base)	1156	static int rx_queue_full(struct tipc_msg *msg, u32 queue_size, u32 base)
1091	{	1157	{
1092	u32 threshold;	1158	u32 threshold;
1093	u32 imp = msg_importance(msg);	1159	u32 imp = msg_importance(msg);
1094		1160
1095	if (imp == TIPC_LOW_IMPORTANCE)	1161	if (imp == TIPC_LOW_IMPORTANCE)
1096	threshold = base;	1162	threshold = base;
1097	else if (imp == TIPC_MEDIUM_IMPORTANCE)	1163	else if (imp == TIPC_MEDIUM_IMPORTANCE)
1098	threshold = base * 2;	1164	threshold = base * 2;
1099	else if (imp == TIPC_HIGH_IMPORTANCE)	1165	else if (imp == TIPC_HIGH_IMPORTANCE)
1100	threshold = base * 100;	1166	threshold = base * 100;
1101	else	1167	else
1102	return 0;	1168	return 0;
1103		1169
1104	if (msg_connected(msg))	1170	if (msg_connected(msg))
1105	threshold *= 4;	1171	threshold *= 4;
1106		1172
1107	return (queue_size >= threshold);	1173	return (queue_size >= threshold);
1108	}	1174	}
1109		1175
1110	/**	1176	/**
1111	* async_disconnect - wrapper function used to disconnect port	1177	* filter_rcv - validate incoming message
1112	* @portref: TIPC port reference (passed as pointer-sized value)	1178	* @sk: socket
1113	*/
1114
1115	static void async_disconnect(unsigned long portref)
1116	{
1117	tipc_disconnect((u32)portref);
1118	}
1119
1120	/**
1121	* dispatch - handle arriving message
1122	* @tport: TIPC port that received message
1123	* @buf: message	1179	* @buf: message
1124	*	1180	*
1125	* Called with port locked. Must not take socket lock to avoid deadlock risk.	1181	* Enqueues message on receive queue if acceptable; optionally handles
		1182	* disconnect indication for a connected socket.
1126	*	1183	*
		1184	* Called with socket lock already taken; port lock may also be taken.
		1185	*
1127	* Returns TIPC error status code (TIPC_OK if message is not to be rejected)	1186	* Returns TIPC error status code (TIPC_OK if message is not to be rejected)
1128	*/	1187	*/
1129		1188
1130	static u32 dispatch(struct tipc_port tport, struct sk_buff buf)	1189	static u32 filter_rcv(struct sock sk, struct sk_buff buf)
1131	{	1190	{
		1191	struct socket *sock = sk->sk_socket;
1132	struct tipc_msg *msg = buf_msg(buf);	1192	struct tipc_msg *msg = buf_msg(buf);
1133	struct tipc_sock tsock = (struct tipc_sock )tport->usr_handle;
1134	struct socket *sock;
1135	u32 recv_q_len;	1193	u32 recv_q_len;
1136		1194
1137	/* Reject message if socket is closing */
1138
1139	if (!tsock)
1140	return TIPC_ERR_NO_PORT;
1141
1142	/* Reject message if it is wrong sort of message for socket */	1195	/* Reject message if it is wrong sort of message for socket */
1143		1196
1144	/*	1197	/*
1145	* WOULD IT BE BETTER TO JUST DISCARD THESE MESSAGES INSTEAD?	1198	* WOULD IT BE BETTER TO JUST DISCARD THESE MESSAGES INSTEAD?
1146	* "NO PORT" ISN'T REALLY THE RIGHT ERROR CODE, AND THERE MAY	1199	* "NO PORT" ISN'T REALLY THE RIGHT ERROR CODE, AND THERE MAY
1147	* BE SECURITY IMPLICATIONS INHERENT IN REJECTING INVALID TRAFFIC	1200	* BE SECURITY IMPLICATIONS INHERENT IN REJECTING INVALID TRAFFIC
1148	*/	1201	*/
1149	sock = tsock->sk.sk_socket;	1202
1150	if (sock->state == SS_READY) {	1203	if (sock->state == SS_READY) {
1151	if (msg_connected(msg)) {	1204	if (msg_connected(msg)) {
1152	msg_dbg(msg, "dispatch filter 1\n");	1205	msg_dbg(msg, "dispatch filter 1\n");
1153	return TIPC_ERR_NO_PORT;	1206	return TIPC_ERR_NO_PORT;
1154	}	1207	}
1155	} else {	1208	} else {
1156	if (msg_mcast(msg)) {	1209	if (msg_mcast(msg)) {
1157	msg_dbg(msg, "dispatch filter 2\n");	1210	msg_dbg(msg, "dispatch filter 2\n");
1158	return TIPC_ERR_NO_PORT;	1211	return TIPC_ERR_NO_PORT;
1159	}	1212	}
1160	if (sock->state == SS_CONNECTED) {	1213	if (sock->state == SS_CONNECTED) {
1161	if (!msg_connected(msg)) {	1214	if (!msg_connected(msg)) {
1162	msg_dbg(msg, "dispatch filter 3\n");	1215	msg_dbg(msg, "dispatch filter 3\n");
1163	return TIPC_ERR_NO_PORT;	1216	return TIPC_ERR_NO_PORT;
1164	}	1217	}
1165	}	1218	}
1166	else if (sock->state == SS_CONNECTING) {	1219	else if (sock->state == SS_CONNECTING) {
1167	if (!msg_connected(msg) && (msg_errcode(msg) == 0)) {	1220	if (!msg_connected(msg) && (msg_errcode(msg) == 0)) {
1168	msg_dbg(msg, "dispatch filter 4\n");	1221	msg_dbg(msg, "dispatch filter 4\n");
1169	return TIPC_ERR_NO_PORT;	1222	return TIPC_ERR_NO_PORT;
1170	}	1223	}
1171	}	1224	}
1172	else if (sock->state == SS_LISTENING) {	1225	else if (sock->state == SS_LISTENING) {
1173	if (msg_connected(msg) \|\| msg_errcode(msg)) {	1226	if (msg_connected(msg) \|\| msg_errcode(msg)) {
1174	msg_dbg(msg, "dispatch filter 5\n");	1227	msg_dbg(msg, "dispatch filter 5\n");
1175	return TIPC_ERR_NO_PORT;	1228	return TIPC_ERR_NO_PORT;
1176	}	1229	}
1177	}	1230	}
1178	else if (sock->state == SS_DISCONNECTING) {	1231	else if (sock->state == SS_DISCONNECTING) {
1179	msg_dbg(msg, "dispatch filter 6\n");	1232	msg_dbg(msg, "dispatch filter 6\n");
1180	return TIPC_ERR_NO_PORT;	1233	return TIPC_ERR_NO_PORT;
1181	}	1234	}
1182	else /* (sock->state == SS_UNCONNECTED) */ {	1235	else /* (sock->state == SS_UNCONNECTED) */ {
1183	if (msg_connected(msg) \|\| msg_errcode(msg)) {	1236	if (msg_connected(msg) \|\| msg_errcode(msg)) {
1184	msg_dbg(msg, "dispatch filter 7\n");	1237	msg_dbg(msg, "dispatch filter 7\n");
1185	return TIPC_ERR_NO_PORT;	1238	return TIPC_ERR_NO_PORT;
1186	}	1239	}
1187	}	1240	}
1188	}	1241	}
1189		1242
1190	/* Reject message if there isn't room to queue it */	1243	/* Reject message if there isn't room to queue it */
1191		1244
1192	recv_q_len = (u32)atomic_read(&tipc_queue_size);	1245	recv_q_len = (u32)atomic_read(&tipc_queue_size);
1193	if (unlikely(recv_q_len >= OVERLOAD_LIMIT_BASE)) {	1246	if (unlikely(recv_q_len >= OVERLOAD_LIMIT_BASE)) {
1194	if (rx_queue_full(msg, recv_q_len, OVERLOAD_LIMIT_BASE))	1247	if (rx_queue_full(msg, recv_q_len, OVERLOAD_LIMIT_BASE))
1195	return TIPC_ERR_OVERLOAD;	1248	return TIPC_ERR_OVERLOAD;
1196	}	1249	}
1197	recv_q_len = skb_queue_len(&tsock->sk.sk_receive_queue);	1250	recv_q_len = skb_queue_len(&sk->sk_receive_queue);
1198	if (unlikely(recv_q_len >= (OVERLOAD_LIMIT_BASE / 2))) {	1251	if (unlikely(recv_q_len >= (OVERLOAD_LIMIT_BASE / 2))) {
1199	if (rx_queue_full(msg, recv_q_len, OVERLOAD_LIMIT_BASE / 2))	1252	if (rx_queue_full(msg, recv_q_len, OVERLOAD_LIMIT_BASE / 2))
1200	return TIPC_ERR_OVERLOAD;	1253	return TIPC_ERR_OVERLOAD;
1201	}	1254	}
1202		1255
		1256	/* Enqueue message (finally!) */
		1257
		1258	msg_dbg(msg, "<DISP<: ");
		1259	TIPC_SKB_CB(buf)->handle = msg_data(msg);
		1260	atomic_inc(&tipc_queue_size);
		1261	__skb_queue_tail(&sk->sk_receive_queue, buf);
		1262
1203	/* Initiate connection termination for an incoming 'FIN' */	1263	/* Initiate connection termination for an incoming 'FIN' */
1204		1264
1205	if (unlikely(msg_errcode(msg) && (sock->state == SS_CONNECTED))) {	1265	if (unlikely(msg_errcode(msg) && (sock->state == SS_CONNECTED))) {
1206	sock->state = SS_DISCONNECTING;	1266	sock->state = SS_DISCONNECTING;
1207	/* Note: Use signal since port lock is already taken! */	1267	tipc_disconnect_port(tipc_sk_port(sk));
1208	tipc_k_signal((Handler)async_disconnect, tport->ref);
1209	}	1268	}
1210		1269
1211	/* Enqueue message (finally!) */	1270	if (waitqueue_active(sk->sk_sleep))
		1271	wake_up_interruptible(sk->sk_sleep);
		1272	return TIPC_OK;
		1273	}
1212		1274
1213	msg_dbg(msg,"<DISP<: ");	1275	/**
1214	TIPC_SKB_CB(buf)->handle = msg_data(msg);	1276	* backlog_rcv - handle incoming message from backlog queue
1215	atomic_inc(&tipc_queue_size);	1277	* @sk: socket
1216	skb_queue_tail(&sock->sk->sk_receive_queue, buf);	1278	* @buf: message
		1279	*
		1280	* Caller must hold socket lock, but not port lock.
		1281	*
		1282	* Returns 0
		1283	*/
1217		1284
1218	if (waitqueue_active(sock->sk->sk_sleep))	1285	static int backlog_rcv(struct sock sk, struct sk_buff buf)
1219	wake_up_interruptible(sock->sk->sk_sleep);	1286	{
1220	return TIPC_OK;	1287	u32 res;
		1288
		1289	res = filter_rcv(sk, buf);
		1290	if (res)
		1291	tipc_reject_msg(buf, res);
		1292	return 0;
1221	}	1293	}
1222		1294
1223	/**	1295	/**
		1296	* dispatch - handle incoming message
		1297	* @tport: TIPC port that received message
		1298	* @buf: message
		1299	*
		1300	* Called with port lock already taken.
		1301	*
		1302	* Returns TIPC error status code (TIPC_OK if message is not to be rejected)
		1303	*/
		1304
		1305	static u32 dispatch(struct tipc_port tport, struct sk_buff buf)
		1306	{
		1307	struct sock sk = (struct sock )tport->usr_handle;
		1308	u32 res;
		1309
		1310	/*
		1311	* Process message if socket is unlocked; otherwise add to backlog queue
		1312	*
		1313	* This code is based on sk_receive_skb(), but must be distinct from it
		1314	* since a TIPC-specific filter/reject mechanism is utilized
		1315	*/
		1316
		1317	bh_lock_sock(sk);
		1318	if (!sock_owned_by_user(sk)) {
		1319	res = filter_rcv(sk, buf);
		1320	} else {
		1321	sk_add_backlog(sk, buf);
		1322	res = TIPC_OK;
		1323	}
		1324	bh_unlock_sock(sk);
		1325
		1326	return res;
		1327	}
		1328
		1329	/**
1224	* wakeupdispatch - wake up port after congestion	1330	* wakeupdispatch - wake up port after congestion
1225	* @tport: port to wakeup	1331	* @tport: port to wakeup
1226	*	1332	*
1227	* Called with port lock on.	1333	* Called with port lock already taken.
1228	*/	1334	*/
1229		1335
1230	static void wakeupdispatch(struct tipc_port *tport)	1336	static void wakeupdispatch(struct tipc_port *tport)
1231	{	1337	{
1232	struct tipc_sock tsock = (struct tipc_sock )tport->usr_handle;	1338	struct sock sk = (struct sock )tport->usr_handle;
1233		1339
1234	if (waitqueue_active(tsock->sk.sk_sleep))	1340	if (waitqueue_active(sk->sk_sleep))
1235	wake_up_interruptible(tsock->sk.sk_sleep);	1341	wake_up_interruptible(sk->sk_sleep);
1236	}	1342	}
1237		1343
1238	/**	1344	/**
1239	* connect - establish a connection to another TIPC port	1345	* connect - establish a connection to another TIPC port
1240	* @sock: socket structure	1346	* @sock: socket structure
1241	* @dest: socket address for destination port	1347	* @dest: socket address for destination port
1242	* @destlen: size of socket address data structure	1348	* @destlen: size of socket address data structure
1243	* @flags: (unused)	1349	* @flags: file-related flags associated with socket
1244	*	1350	*
1245	* Returns 0 on success, errno otherwise	1351	* Returns 0 on success, errno otherwise
1246	*/	1352	*/
1247		1353
1248	static int connect(struct socket sock, struct sockaddr dest, int destlen,	1354	static int connect(struct socket sock, struct sockaddr dest, int destlen,
1249	int flags)	1355	int flags)
1250	{	1356	{
1251	struct tipc_sock *tsock = tipc_sk(sock->sk);	1357	struct sock *sk = sock->sk;
1252	struct sockaddr_tipc dst = (struct sockaddr_tipc )dest;	1358	struct sockaddr_tipc dst = (struct sockaddr_tipc )dest;
1253	struct msghdr m = {NULL,};	1359	struct msghdr m = {NULL,};
1254	struct sk_buff *buf;	1360	struct sk_buff *buf;
1255	struct tipc_msg *msg;	1361	struct tipc_msg *msg;
1256	int res;	1362	int res;
1257		1363
		1364	lock_sock(sk);
		1365
1258	/* For now, TIPC does not allow use of connect() with DGRAM/RDM types */	1366	/* For now, TIPC does not allow use of connect() with DGRAM/RDM types */
1259		1367
1260	if (sock->state == SS_READY)	1368	if (sock->state == SS_READY) {
1261	return -EOPNOTSUPP;	1369	res = -EOPNOTSUPP;
		1370	goto exit;
		1371	}
1262		1372
1263	/* For now, TIPC does not support the non-blocking form of connect() */	1373	/* For now, TIPC does not support the non-blocking form of connect() */
1264		1374
1265	if (flags & O_NONBLOCK)	1375	if (flags & O_NONBLOCK) {
1266	return -EWOULDBLOCK;	1376	res = -EWOULDBLOCK;
		1377	goto exit;
		1378	}
1267		1379
1268	/* Issue Posix-compliant error code if socket is in the wrong state */	1380	/* Issue Posix-compliant error code if socket is in the wrong state */
1269		1381
1270	if (sock->state == SS_LISTENING)	1382	if (sock->state == SS_LISTENING) {
1271	return -EOPNOTSUPP;	1383	res = -EOPNOTSUPP;
1272	if (sock->state == SS_CONNECTING)	1384	goto exit;
1273	return -EALREADY;	1385	}
1274	if (sock->state != SS_UNCONNECTED)	1386	if (sock->state == SS_CONNECTING) {
1275	return -EISCONN;	1387	res = -EALREADY;
		1388	goto exit;
		1389	}
		1390	if (sock->state != SS_UNCONNECTED) {
		1391	res = -EISCONN;
		1392	goto exit;
		1393	}
1276		1394
1277	/*	1395	/*
1278	* Reject connection attempt using multicast address	1396	* Reject connection attempt using multicast address
1279	*	1397	*
1280	* Note: send_msg() validates the rest of the address fields,	1398	* Note: send_msg() validates the rest of the address fields,
1281	* so there's no need to do it here	1399	* so there's no need to do it here
1282	*/	1400	*/
1283		1401
1284	if (dst->addrtype == TIPC_ADDR_MCAST)	1402	if (dst->addrtype == TIPC_ADDR_MCAST) {
1285	return -EINVAL;	1403	res = -EINVAL;
		1404	goto exit;
		1405	}
1286		1406
		1407	/* Reject any messages already in receive queue (very unlikely) */
		1408
		1409	reject_rx_queue(sk);
		1410
1287	/* Send a 'SYN-' to destination */	1411	/* Send a 'SYN-' to destination */
1288		1412
1289	m.msg_name = dest;	1413	m.msg_name = dest;
1290	m.msg_namelen = destlen;	1414	m.msg_namelen = destlen;
1291	res = send_msg(NULL, sock, &m, 0);	1415	res = send_msg(NULL, sock, &m, 0);
1292	if (res < 0) {	1416	if (res < 0) {
1293	sock->state = SS_DISCONNECTING;	1417	goto exit;
1294	return res;
1295	}	1418	}
1296		1419
1297	if (mutex_lock_interruptible(&tsock->lock))	1420	/* Wait until an 'ACK' or 'RST' arrives, or a timeout occurs */
1298	return -ERESTARTSYS;
1299		1421
1300	/* Wait for destination's 'ACK' response */	1422	release_sock(sk);
		1423	res = wait_event_interruptible_timeout(*sk->sk_sleep,
		1424	(!skb_queue_empty(&sk->sk_receive_queue) \|\|
		1425	(sock->state != SS_CONNECTING)),
		1426	sk->sk_rcvtimeo);
		1427	lock_sock(sk);
1301		1428
1302	res = wait_event_interruptible_timeout(*sock->sk->sk_sleep,
1303	skb_queue_len(&sock->sk->sk_receive_queue),
1304	sock->sk->sk_rcvtimeo);
1305	buf = skb_peek(&sock->sk->sk_receive_queue);
1306	if (res > 0) {	1429	if (res > 0) {
1307	msg = buf_msg(buf);	1430	buf = skb_peek(&sk->sk_receive_queue);
1308	res = auto_connect(sock, tsock, msg);	1431	if (buf != NULL) {
1309	if (!res) {	1432	msg = buf_msg(buf);
1310	if (!msg_data_sz(msg))	1433	res = auto_connect(sock, msg);
1311	advance_queue(tsock);	1434	if (!res) {
		1435	if (!msg_data_sz(msg))
		1436	advance_rx_queue(sk);
		1437	}
		1438	} else {
		1439	if (sock->state == SS_CONNECTED) {
		1440	res = -EISCONN;
		1441	} else {
		1442	res = -ECONNREFUSED;
		1443	}
1312	}	1444	}
1313	} else {	1445	} else {
1314	if (res == 0)	1446	if (res == 0)
1315	res = -ETIMEDOUT;	1447	res = -ETIMEDOUT;
1316	else	1448	else
1317	; /* leave "res" unchanged */	1449	; /* leave "res" unchanged */
1318	sock->state = SS_DISCONNECTING;	1450	sock->state = SS_DISCONNECTING;
1319	}	1451	}
1320		1452
1321	mutex_unlock(&tsock->lock);	1453	exit:
		1454	release_sock(sk);
1322	return res;	1455	return res;
1323	}	1456	}
1324		1457
1325	/**	1458	/**
1326	* listen - allow socket to listen for incoming connections	1459	* listen - allow socket to listen for incoming connections
1327	* @sock: socket structure	1460	* @sock: socket structure
1328	* @len: (unused)	1461	* @len: (unused)
1329	*	1462	*
1330	* Returns 0 on success, errno otherwise	1463	* Returns 0 on success, errno otherwise
1331	*/	1464	*/
1332		1465
1333	static int listen(struct socket *sock, int len)	1466	static int listen(struct socket *sock, int len)
1334	{	1467	{
1335	/* REQUIRES SOCKET LOCKING OF SOME SORT? */	1468	struct sock *sk = sock->sk;
		1469	int res;
1336		1470
		1471	lock_sock(sk);
		1472
1337	if (sock->state == SS_READY)	1473	if (sock->state == SS_READY)
1338	return -EOPNOTSUPP;	1474	res = -EOPNOTSUPP;
1339	if (sock->state != SS_UNCONNECTED)	1475	else if (sock->state != SS_UNCONNECTED)
1340	return -EINVAL;	1476	res = -EINVAL;
1341	sock->state = SS_LISTENING;	1477	else {
1342	return 0;	1478	sock->state = SS_LISTENING;
		1479	res = 0;
		1480	}
		1481
		1482	release_sock(sk);
		1483	return res;
1343	}	1484	}
1344		1485
1345	/**	1486	/**
1346	* accept - wait for connection request	1487	* accept - wait for connection request
1347	* @sock: listening socket	1488	* @sock: listening socket
1348	* @newsock: new socket that is to be connected	1489	* @newsock: new socket that is to be connected
1349	* @flags: file-related flags associated with socket	1490	* @flags: file-related flags associated with socket
1350	*	1491	*
1351	* Returns 0 on success, errno otherwise	1492	* Returns 0 on success, errno otherwise
1352	*/	1493	*/
1353		1494
1354	static int accept(struct socket sock, struct socket newsock, int flags)	1495	static int accept(struct socket sock, struct socket new_sock, int flags)
1355	{	1496	{
1356	struct tipc_sock *tsock = tipc_sk(sock->sk);	1497	struct sock *sk = sock->sk;
1357	struct sk_buff *buf;	1498	struct sk_buff *buf;
1358	int res = -EFAULT;	1499	int res;
1359		1500
1360	if (sock->state == SS_READY)	1501	lock_sock(sk);
1361	return -EOPNOTSUPP;
1362	if (sock->state != SS_LISTENING)
1363	return -EINVAL;
1364		1502
1365	if (unlikely((skb_queue_len(&sock->sk->sk_receive_queue) == 0) &&	1503	if (sock->state == SS_READY) {
1366	(flags & O_NONBLOCK)))	1504	res = -EOPNOTSUPP;
1367	return -EWOULDBLOCK;
1368
1369	if (mutex_lock_interruptible(&tsock->lock))
1370	return -ERESTARTSYS;
1371
1372	if (wait_event_interruptible(*sock->sk->sk_sleep,
1373	skb_queue_len(&sock->sk->sk_receive_queue))) {
1374	res = -ERESTARTSYS;
1375	goto exit;	1505	goto exit;
1376	}	1506	}
1377	buf = skb_peek(&sock->sk->sk_receive_queue);	1507	if (sock->state != SS_LISTENING) {
		1508	res = -EINVAL;
		1509	goto exit;
		1510	}
1378		1511
1379	res = tipc_create(sock_net(sock->sk), newsock, 0);	1512	while (skb_queue_empty(&sk->sk_receive_queue)) {
		1513	if (flags & O_NONBLOCK) {
		1514	res = -EWOULDBLOCK;
		1515	goto exit;
		1516	}
		1517	release_sock(sk);
		1518	res = wait_event_interruptible(*sk->sk_sleep,
		1519	(!skb_queue_empty(&sk->sk_receive_queue)));
		1520	lock_sock(sk);
		1521	if (res)
		1522	goto exit;
		1523	}
		1524
		1525	buf = skb_peek(&sk->sk_receive_queue);
		1526
		1527	res = tipc_create(sock_net(sock->sk), new_sock, 0);
1380	if (!res) {	1528	if (!res) {
1381	struct tipc_sock *new_tsock = tipc_sk(newsock->sk);	1529	struct sock *new_sk = new_sock->sk;
		1530	struct tipc_port *new_tport = tipc_sk_port(new_sk);
		1531	u32 new_ref = new_tport->ref;
1382	struct tipc_portid id;	1532	struct tipc_portid id;
1383	struct tipc_msg *msg = buf_msg(buf);	1533	struct tipc_msg *msg = buf_msg(buf);
1384	u32 new_ref = new_tsock->p->ref;
1385		1534
		1535	lock_sock(new_sk);
		1536
		1537	/*
		1538	* Reject any stray messages received by new socket
		1539	* before the socket lock was taken (very, very unlikely)
		1540	*/
		1541
		1542	reject_rx_queue(new_sk);
		1543
		1544	/* Connect new socket to it's peer */
		1545
1386	id.ref = msg_origport(msg);	1546	id.ref = msg_origport(msg);
1387	id.node = msg_orignode(msg);	1547	id.node = msg_orignode(msg);
1388	tipc_connect2port(new_ref, &id);	1548	tipc_connect2port(new_ref, &id);
1389	newsock->state = SS_CONNECTED;	1549	new_sock->state = SS_CONNECTED;
1390		1550
1391	tipc_set_portimportance(new_ref, msg_importance(msg));	1551	tipc_set_portimportance(new_ref, msg_importance(msg));
1392	if (msg_named(msg)) {	1552	if (msg_named(msg)) {
1393	new_tsock->p->conn_type = msg_nametype(msg);	1553	new_tport->conn_type = msg_nametype(msg);
1394	new_tsock->p->conn_instance = msg_nameinst(msg);	1554	new_tport->conn_instance = msg_nameinst(msg);
1395	}	1555	}
1396		1556
1397	/*	1557	/*
1398	* Respond to 'SYN-' by discarding it & returning 'ACK'-.	1558	* Respond to 'SYN-' by discarding it & returning 'ACK'-.
1399	* Respond to 'SYN+' by queuing it on new socket.	1559	* Respond to 'SYN+' by queuing it on new socket.
1400	*/	1560	*/
1401		1561
1402	msg_dbg(msg,"<ACC<: ");	1562	msg_dbg(msg,"<ACC<: ");
1403	if (!msg_data_sz(msg)) {	1563	if (!msg_data_sz(msg)) {
1404	struct msghdr m = {NULL,};	1564	struct msghdr m = {NULL,};
1405		1565
1406	send_packet(NULL, newsock, &m, 0);	1566	advance_rx_queue(sk);
1407	advance_queue(tsock);	1567	send_packet(NULL, new_sock, &m, 0);
1408	} else {	1568	} else {
1409	sock_lock(tsock);	1569	__skb_dequeue(&sk->sk_receive_queue);
1410	skb_dequeue(&sock->sk->sk_receive_queue);	1570	__skb_queue_head(&new_sk->sk_receive_queue, buf);
1411	sock_unlock(tsock);
1412	skb_queue_head(&newsock->sk->sk_receive_queue, buf);
1413	}	1571	}
		1572	release_sock(new_sk);
1414	}	1573	}
1415	exit:	1574	exit:
1416	mutex_unlock(&tsock->lock);	1575	release_sock(sk);
1417	return res;	1576	return res;
1418	}	1577	}
1419		1578
1420	/**	1579	/**
1421	* shutdown - shutdown socket connection	1580	* shutdown - shutdown socket connection
1422	* @sock: socket structure	1581	* @sock: socket structure
1423	* @how: direction to close (must be SHUT_RDWR)	1582	* @how: direction to close (must be SHUT_RDWR)
1424	*	1583	*
1425	* Terminates connection (if necessary), then purges socket's receive queue.	1584	* Terminates connection (if necessary), then purges socket's receive queue.
1426	*	1585	*
1427	* Returns 0 on success, errno otherwise	1586	* Returns 0 on success, errno otherwise
1428	*/	1587	*/
1429		1588
1430	static int shutdown(struct socket *sock, int how)	1589	static int shutdown(struct socket *sock, int how)
1431	{	1590	{
1432	struct tipc_sock* tsock = tipc_sk(sock->sk);	1591	struct sock *sk = sock->sk;
		1592	struct tipc_port *tport = tipc_sk_port(sk);
1433	struct sk_buff *buf;	1593	struct sk_buff *buf;
1434	int res;	1594	int res;
1435		1595
1436	if (how != SHUT_RDWR)	1596	if (how != SHUT_RDWR)
1437	return -EINVAL;	1597	return -EINVAL;
1438		1598
1439	if (mutex_lock_interruptible(&tsock->lock))	1599	lock_sock(sk);
1440	return -ERESTARTSYS;
1441		1600
1442	sock_lock(tsock);
1443
1444	switch (sock->state) {	1601	switch (sock->state) {
		1602	case SS_CONNECTING:
1445	case SS_CONNECTED:	1603	case SS_CONNECTED:
1446		1604
1447	/* Send 'FIN+' or 'FIN-' message to peer */	1605	/* Disconnect and send a 'FIN+' or 'FIN-' message to peer */
1448
1449	sock_unlock(tsock);
1450	restart:	1606	restart:
1451	if ((buf = skb_dequeue(&sock->sk->sk_receive_queue))) {	1607	buf = __skb_dequeue(&sk->sk_receive_queue);
		1608	if (buf) {
1452	atomic_dec(&tipc_queue_size);	1609	atomic_dec(&tipc_queue_size);
1453	if (TIPC_SKB_CB(buf)->handle != msg_data(buf_msg(buf))) {	1610	if (TIPC_SKB_CB(buf)->handle != msg_data(buf_msg(buf))) {
1454	buf_discard(buf);	1611	buf_discard(buf);
1455	goto restart;	1612	goto restart;
1456	}	1613	}
		1614	tipc_disconnect(tport->ref);
1457	tipc_reject_msg(buf, TIPC_CONN_SHUTDOWN);	1615	tipc_reject_msg(buf, TIPC_CONN_SHUTDOWN);
		1616	} else {
		1617	tipc_shutdown(tport->ref);
1458	}	1618	}
1459	else {
1460	tipc_shutdown(tsock->p->ref);
1461	}
1462	sock_lock(tsock);
1463		1619
		1620	sock->state = SS_DISCONNECTING;
		1621
1464	/* fall through */	1622	/* fall through */
1465		1623
1466	case SS_DISCONNECTING:	1624	case SS_DISCONNECTING:
1467		1625
1468	/* Discard any unreceived messages */	1626	/* Discard any unreceived messages; wake up sleeping tasks */
1469		1627
1470	while ((buf = skb_dequeue(&sock->sk->sk_receive_queue))) {	1628	discard_rx_queue(sk);
1471	atomic_dec(&tipc_queue_size);	1629	if (waitqueue_active(sk->sk_sleep))
1472	buf_discard(buf);	1630	wake_up_interruptible(sk->sk_sleep);
1473	}
1474	tsock->p->conn_unacked = 0;
1475
1476	/* fall through */
1477
1478	case SS_CONNECTING:
1479	sock->state = SS_DISCONNECTING;
1480	res = 0;	1631	res = 0;
1481	break;	1632	break;
1482		1633
1483	default:	1634	default:
1484	res = -ENOTCONN;	1635	res = -ENOTCONN;
1485	}	1636	}
1486		1637
1487	sock_unlock(tsock);	1638	release_sock(sk);
1488
1489	mutex_unlock(&tsock->lock);
1490	return res;	1639	return res;
1491	}	1640	}
1492		1641
1493	/**	1642	/**
1494	* setsockopt - set socket option	1643	* setsockopt - set socket option
1495	* @sock: socket structure	1644	* @sock: socket structure
1496	* @lvl: option level	1645	* @lvl: option level
1497	* @opt: option identifier	1646	* @opt: option identifier
1498	* @ov: pointer to new option value	1647	* @ov: pointer to new option value
1499	* @ol: length of option value	1648	* @ol: length of option value
1500	*	1649	*
1501	* For stream sockets only, accepts and ignores all IPPROTO_TCP options	1650	* For stream sockets only, accepts and ignores all IPPROTO_TCP options
1502	* (to ease compatibility).	1651	* (to ease compatibility).
1503	*	1652	*
1504	* Returns 0 on success, errno otherwise	1653	* Returns 0 on success, errno otherwise
1505	*/	1654	*/
1506		1655
1507	static int setsockopt(struct socket *sock,	1656	static int setsockopt(struct socket *sock,
1508	int lvl, int opt, char __user *ov, int ol)	1657	int lvl, int opt, char __user *ov, int ol)
1509	{	1658	{
1510	struct tipc_sock *tsock = tipc_sk(sock->sk);	1659	struct sock *sk = sock->sk;
		1660	struct tipc_port *tport = tipc_sk_port(sk);
1511	u32 value;	1661	u32 value;
1512	int res;	1662	int res;
1513		1663
1514	if ((lvl == IPPROTO_TCP) && (sock->type == SOCK_STREAM))	1664	if ((lvl == IPPROTO_TCP) && (sock->type == SOCK_STREAM))
1515	return 0;	1665	return 0;
1516	if (lvl != SOL_TIPC)	1666	if (lvl != SOL_TIPC)
1517	return -ENOPROTOOPT;	1667	return -ENOPROTOOPT;
1518	if (ol < sizeof(value))	1668	if (ol < sizeof(value))
1519	return -EINVAL;	1669	return -EINVAL;
1520	if ((res = get_user(value, (u32 __user *)ov)))	1670	if ((res = get_user(value, (u32 __user *)ov)))
1521	return res;	1671	return res;
1522		1672
1523	if (mutex_lock_interruptible(&tsock->lock))	1673	lock_sock(sk);
1524	return -ERESTARTSYS;
1525		1674
1526	switch (opt) {	1675	switch (opt) {
1527	case TIPC_IMPORTANCE:	1676	case TIPC_IMPORTANCE:
1528	res = tipc_set_portimportance(tsock->p->ref, value);	1677	res = tipc_set_portimportance(tport->ref, value);
1529	break;	1678	break;
1530	case TIPC_SRC_DROPPABLE:	1679	case TIPC_SRC_DROPPABLE:
1531	if (sock->type != SOCK_STREAM)	1680	if (sock->type != SOCK_STREAM)
1532	res = tipc_set_portunreliable(tsock->p->ref, value);	1681	res = tipc_set_portunreliable(tport->ref, value);
1533	else	1682	else
1534	res = -ENOPROTOOPT;	1683	res = -ENOPROTOOPT;
1535	break;	1684	break;
1536	case TIPC_DEST_DROPPABLE:	1685	case TIPC_DEST_DROPPABLE:
1537	res = tipc_set_portunreturnable(tsock->p->ref, value);	1686	res = tipc_set_portunreturnable(tport->ref, value);
1538	break;	1687	break;
1539	case TIPC_CONN_TIMEOUT:	1688	case TIPC_CONN_TIMEOUT:
1540	sock->sk->sk_rcvtimeo = msecs_to_jiffies(value);	1689	sk->sk_rcvtimeo = msecs_to_jiffies(value);
		1690	/* no need to set "res", since already 0 at this point */
1541	break;	1691	break;
1542	default:	1692	default:
1543	res = -EINVAL;	1693	res = -EINVAL;
1544	}	1694	}
1545		1695
1546	mutex_unlock(&tsock->lock);	1696	release_sock(sk);
		1697
1547	return res;	1698	return res;
1548	}	1699	}
1549		1700
1550	/**	1701	/**
1551	* getsockopt - get socket option	1702	* getsockopt - get socket option
1552	* @sock: socket structure	1703	* @sock: socket structure
1553	* @lvl: option level	1704	* @lvl: option level
1554	* @opt: option identifier	1705	* @opt: option identifier
1555	* @ov: receptacle for option value	1706	* @ov: receptacle for option value
1556	* @ol: receptacle for length of option value	1707	* @ol: receptacle for length of option value
1557	*	1708	*
1558	* For stream sockets only, returns 0 length result for all IPPROTO_TCP options	1709	* For stream sockets only, returns 0 length result for all IPPROTO_TCP options
1559	* (to ease compatibility).	1710	* (to ease compatibility).
1560	*	1711	*
1561	* Returns 0 on success, errno otherwise	1712	* Returns 0 on success, errno otherwise
1562	*/	1713	*/
1563		1714
1564	static int getsockopt(struct socket *sock,	1715	static int getsockopt(struct socket *sock,
1565	int lvl, int opt, char __user ov, int __user ol)	1716	int lvl, int opt, char __user ov, int __user ol)