2006-01-02 18:04:38 +00:00
|
|
|
/*
|
|
|
|
* net/tipc/port.c: TIPC port code
|
2007-02-09 14:25:21 +00:00
|
|
|
*
|
2014-03-12 15:31:09 +00:00
|
|
|
* Copyright (c) 1992-2007, 2014, Ericsson AB
|
2013-06-17 14:54:42 +00:00
|
|
|
* Copyright (c) 2004-2008, 2010-2013, Wind River Systems
|
2006-01-02 18:04:38 +00:00
|
|
|
* All rights reserved.
|
|
|
|
*
|
2006-01-11 12:30:43 +00:00
|
|
|
* Redistribution and use in source and binary forms, with or without
|
2006-01-02 18:04:38 +00:00
|
|
|
* modification, are permitted provided that the following conditions are met:
|
|
|
|
*
|
2006-01-11 12:30:43 +00:00
|
|
|
* 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.
|
2006-01-02 18:04:38 +00:00
|
|
|
*
|
2006-01-11 12:30:43 +00:00
|
|
|
* 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
|
2006-01-02 18:04:38 +00:00
|
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "core.h"
|
|
|
|
#include "config.h"
|
|
|
|
#include "port.h"
|
|
|
|
#include "name_table.h"
|
2014-03-12 15:31:09 +00:00
|
|
|
#include "socket.h"
|
2006-01-02 18:04:38 +00:00
|
|
|
|
|
|
|
/* Connection management: */
|
|
|
|
#define PROBING_INTERVAL 3600000 /* [ms] => 1 h */
|
|
|
|
#define CONFIRMED 0
|
|
|
|
#define PROBING 1
|
|
|
|
|
|
|
|
#define MAX_REJECT_SIZE 1024
|
|
|
|
|
2006-06-27 09:53:55 +00:00
|
|
|
DEFINE_SPINLOCK(tipc_port_list_lock);
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2006-01-17 23:38:21 +00:00
|
|
|
static LIST_HEAD(ports);
|
2006-01-02 18:04:38 +00:00
|
|
|
static void port_handle_node_down(unsigned long ref);
|
2011-01-07 16:43:40 +00:00
|
|
|
static struct sk_buff *port_build_self_abort_msg(struct tipc_port *, u32 err);
|
|
|
|
static struct sk_buff *port_build_peer_abort_msg(struct tipc_port *, u32 err);
|
2006-01-02 18:04:38 +00:00
|
|
|
static void port_timeout(unsigned long ref);
|
|
|
|
|
2012-07-10 10:55:09 +00:00
|
|
|
/**
|
2012-04-17 22:42:28 +00:00
|
|
|
* tipc_port_peer_msg - verify message was sent by connected port's peer
|
|
|
|
*
|
|
|
|
* Handles cases where the node's network address has changed from
|
|
|
|
* the default of <0.0.0> to its configured setting.
|
|
|
|
*/
|
|
|
|
int tipc_port_peer_msg(struct tipc_port *p_ptr, struct tipc_msg *msg)
|
|
|
|
{
|
|
|
|
u32 peernode;
|
|
|
|
u32 orignode;
|
|
|
|
|
2014-03-12 15:31:08 +00:00
|
|
|
if (msg_origport(msg) != tipc_port_peerport(p_ptr))
|
2012-04-17 22:42:28 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
orignode = msg_orignode(msg);
|
2014-03-12 15:31:08 +00:00
|
|
|
peernode = tipc_port_peernode(p_ptr);
|
2012-04-17 22:42:28 +00:00
|
|
|
return (orignode == peernode) ||
|
|
|
|
(!orignode && (peernode == tipc_own_addr)) ||
|
|
|
|
(!peernode && (orignode == tipc_own_addr));
|
|
|
|
}
|
|
|
|
|
2006-01-02 18:04:38 +00:00
|
|
|
/**
|
2014-02-18 08:06:46 +00:00
|
|
|
* tipc_port_mcast_xmit - send a multicast message to local and remote
|
|
|
|
* destinations
|
2006-01-02 18:04:38 +00:00
|
|
|
*/
|
2014-03-12 15:31:13 +00:00
|
|
|
int tipc_port_mcast_xmit(struct tipc_port *oport,
|
|
|
|
struct tipc_name_seq const *seq,
|
|
|
|
struct iovec const *msg_sect,
|
|
|
|
unsigned int len)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
|
|
|
struct tipc_msg *hdr;
|
|
|
|
struct sk_buff *buf;
|
|
|
|
struct sk_buff *ibuf = NULL;
|
2011-12-30 01:33:30 +00:00
|
|
|
struct tipc_port_list dports = {0, NULL, };
|
2006-01-02 18:04:38 +00:00
|
|
|
int ext_targets;
|
|
|
|
int res;
|
|
|
|
|
|
|
|
/* Create multicast message */
|
2011-01-07 16:43:40 +00:00
|
|
|
hdr = &oport->phdr;
|
2006-01-02 18:04:38 +00:00
|
|
|
msg_set_type(hdr, TIPC_MCAST_MSG);
|
2011-04-17 20:02:11 +00:00
|
|
|
msg_set_lookup_scope(hdr, TIPC_CLUSTER_SCOPE);
|
2011-04-18 14:08:22 +00:00
|
|
|
msg_set_destport(hdr, 0);
|
|
|
|
msg_set_destnode(hdr, 0);
|
2006-01-02 18:04:38 +00:00
|
|
|
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);
|
2013-10-18 05:23:15 +00:00
|
|
|
res = tipc_msg_build(hdr, msg_sect, len, MAX_MSG_SIZE, &buf);
|
2006-01-02 18:04:38 +00:00
|
|
|
if (unlikely(!buf))
|
|
|
|
return res;
|
|
|
|
|
|
|
|
/* Figure out where to send multicast message */
|
2006-01-17 23:38:21 +00:00
|
|
|
ext_targets = tipc_nametbl_mc_translate(seq->type, seq->lower, seq->upper,
|
|
|
|
TIPC_NODE_SCOPE, &dports);
|
2007-02-09 14:25:21 +00:00
|
|
|
|
|
|
|
/* Send message to destinations (duplicate it only if necessary) */
|
2006-01-02 18:04:38 +00:00
|
|
|
if (ext_targets) {
|
|
|
|
if (dports.count != 0) {
|
|
|
|
ibuf = skb_copy(buf, GFP_ATOMIC);
|
|
|
|
if (ibuf == NULL) {
|
2006-01-17 23:38:21 +00:00
|
|
|
tipc_port_list_free(&dports);
|
2011-11-04 17:24:29 +00:00
|
|
|
kfree_skb(buf);
|
2006-01-02 18:04:38 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
}
|
2014-02-18 08:06:46 +00:00
|
|
|
res = tipc_bclink_xmit(buf);
|
2010-12-31 18:59:35 +00:00
|
|
|
if ((res < 0) && (dports.count != 0))
|
2011-11-04 17:24:29 +00:00
|
|
|
kfree_skb(ibuf);
|
2006-01-02 18:04:38 +00:00
|
|
|
} else {
|
|
|
|
ibuf = buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (res >= 0) {
|
|
|
|
if (ibuf)
|
2014-02-18 08:06:46 +00:00
|
|
|
tipc_port_mcast_rcv(ibuf, &dports);
|
2006-01-02 18:04:38 +00:00
|
|
|
} else {
|
2006-01-17 23:38:21 +00:00
|
|
|
tipc_port_list_free(&dports);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2014-02-18 08:06:46 +00:00
|
|
|
* tipc_port_mcast_rcv - deliver multicast message to all destination ports
|
2007-02-09 14:25:21 +00:00
|
|
|
*
|
2006-01-02 18:04:38 +00:00
|
|
|
* If there is no port list, perform a lookup to create one
|
|
|
|
*/
|
2014-02-18 08:06:46 +00:00
|
|
|
void tipc_port_mcast_rcv(struct sk_buff *buf, struct tipc_port_list *dp)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2010-12-31 18:59:32 +00:00
|
|
|
struct tipc_msg *msg;
|
2011-12-30 01:33:30 +00:00
|
|
|
struct tipc_port_list dports = {0, NULL, };
|
|
|
|
struct tipc_port_list *item = dp;
|
2006-01-02 18:04:38 +00:00
|
|
|
int cnt = 0;
|
|
|
|
|
|
|
|
msg = buf_msg(buf);
|
|
|
|
|
|
|
|
/* Create destination port list, if one wasn't supplied */
|
|
|
|
if (dp == NULL) {
|
2006-01-17 23:38:21 +00:00
|
|
|
tipc_nametbl_mc_translate(msg_nametype(msg),
|
2006-01-02 18:04:38 +00:00
|
|
|
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) {
|
2011-04-18 14:14:26 +00:00
|
|
|
msg_set_destnode(msg, tipc_own_addr);
|
2006-01-02 18:04:38 +00:00
|
|
|
if (dp->count == 1) {
|
|
|
|
msg_set_destport(msg, dp->ports[0]);
|
2014-05-14 09:39:15 +00:00
|
|
|
tipc_sk_rcv(buf);
|
2006-01-17 23:38:21 +00:00
|
|
|
tipc_port_list_free(dp);
|
2006-01-02 18:04:38 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
for (; cnt < dp->count; cnt++) {
|
|
|
|
int index = cnt % PLSIZE;
|
|
|
|
struct sk_buff *b = skb_clone(buf, GFP_ATOMIC);
|
|
|
|
|
|
|
|
if (b == NULL) {
|
2012-06-29 04:16:37 +00:00
|
|
|
pr_warn("Unable to deliver multicast message(s)\n");
|
2006-01-02 18:04:38 +00:00
|
|
|
goto exit;
|
|
|
|
}
|
2010-12-31 18:59:35 +00:00
|
|
|
if ((index == 0) && (cnt != 0))
|
2006-01-02 18:04:38 +00:00
|
|
|
item = item->next;
|
2010-12-31 18:59:32 +00:00
|
|
|
msg_set_destport(buf_msg(b), item->ports[index]);
|
2014-05-14 09:39:15 +00:00
|
|
|
tipc_sk_rcv(b);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
exit:
|
2011-11-04 17:24:29 +00:00
|
|
|
kfree_skb(buf);
|
2006-01-17 23:38:21 +00:00
|
|
|
tipc_port_list_free(dp);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
2014-03-12 15:31:10 +00:00
|
|
|
|
|
|
|
void tipc_port_wakeup(struct tipc_port *port)
|
|
|
|
{
|
2014-03-12 15:31:12 +00:00
|
|
|
tipc_sock_wakeup(tipc_port_to_sock(port));
|
2014-03-12 15:31:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* tipc_port_init - intiate TIPC port and lock it
|
2007-02-09 14:25:21 +00:00
|
|
|
*
|
2014-03-12 15:31:10 +00:00
|
|
|
* Returns obtained reference if initialization is successful, zero otherwise
|
2006-01-02 18:04:38 +00:00
|
|
|
*/
|
2014-03-12 15:31:10 +00:00
|
|
|
u32 tipc_port_init(struct tipc_port *p_ptr,
|
|
|
|
const unsigned int importance)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
|
|
|
struct tipc_msg *msg;
|
|
|
|
u32 ref;
|
|
|
|
|
2011-01-07 16:43:40 +00:00
|
|
|
ref = tipc_ref_acquire(p_ptr, &p_ptr->lock);
|
2006-01-02 18:04:38 +00:00
|
|
|
if (!ref) {
|
2014-03-12 15:31:09 +00:00
|
|
|
pr_warn("Port registration failed, ref. table exhausted\n");
|
2014-03-12 15:31:10 +00:00
|
|
|
return 0;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
2011-01-07 16:43:40 +00:00
|
|
|
p_ptr->max_pkt = MAX_PKT_DEFAULT;
|
2014-06-26 01:41:38 +00:00
|
|
|
p_ptr->sent = 1;
|
2011-01-07 16:43:40 +00:00
|
|
|
p_ptr->ref = ref;
|
2006-01-02 18:04:38 +00:00
|
|
|
INIT_LIST_HEAD(&p_ptr->wait_list);
|
|
|
|
INIT_LIST_HEAD(&p_ptr->subscription.nodesub_list);
|
|
|
|
k_init_timer(&p_ptr->timer, (Handler)port_timeout, ref);
|
|
|
|
INIT_LIST_HEAD(&p_ptr->publications);
|
|
|
|
INIT_LIST_HEAD(&p_ptr->port_list);
|
2012-04-17 22:22:49 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Must hold port list lock while initializing message header template
|
|
|
|
* to ensure a change to node's own network address doesn't result
|
|
|
|
* in template containing out-dated network address information
|
|
|
|
*/
|
|
|
|
spin_lock_bh(&tipc_port_list_lock);
|
|
|
|
msg = &p_ptr->phdr;
|
|
|
|
tipc_msg_init(msg, importance, TIPC_NAMED_MSG, NAMED_H_SIZE, 0);
|
|
|
|
msg_set_origport(msg, ref);
|
2006-01-02 18:04:38 +00:00
|
|
|
list_add_tail(&p_ptr->port_list, &ports);
|
2006-01-17 23:38:21 +00:00
|
|
|
spin_unlock_bh(&tipc_port_list_lock);
|
2014-03-12 15:31:10 +00:00
|
|
|
return ref;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
2014-03-12 15:31:10 +00:00
|
|
|
void tipc_port_destroy(struct tipc_port *p_ptr)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2006-03-21 06:36:47 +00:00
|
|
|
struct sk_buff *buf = NULL;
|
2014-06-26 01:41:39 +00:00
|
|
|
struct tipc_msg *msg = NULL;
|
|
|
|
u32 peer;
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2013-12-27 02:18:28 +00:00
|
|
|
tipc_withdraw(p_ptr, 0, NULL);
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2013-12-27 02:18:28 +00:00
|
|
|
spin_lock_bh(p_ptr->lock);
|
|
|
|
tipc_ref_discard(p_ptr->ref);
|
|
|
|
spin_unlock_bh(p_ptr->lock);
|
2006-01-02 18:04:38 +00:00
|
|
|
|
|
|
|
k_cancel_timer(&p_ptr->timer);
|
2011-01-07 16:43:40 +00:00
|
|
|
if (p_ptr->connected) {
|
2006-01-02 18:04:38 +00:00
|
|
|
buf = port_build_peer_abort_msg(p_ptr, TIPC_ERR_NO_PORT);
|
2006-01-17 23:38:21 +00:00
|
|
|
tipc_nodesub_unsubscribe(&p_ptr->subscription);
|
2014-06-26 01:41:39 +00:00
|
|
|
msg = buf_msg(buf);
|
|
|
|
peer = msg_destnode(msg);
|
|
|
|
tipc_link_xmit2(buf, peer, msg_link_selector(msg));
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
2006-01-17 23:38:21 +00:00
|
|
|
spin_lock_bh(&tipc_port_list_lock);
|
2006-01-02 18:04:38 +00:00
|
|
|
list_del(&p_ptr->port_list);
|
|
|
|
list_del(&p_ptr->wait_list);
|
2006-01-17 23:38:21 +00:00
|
|
|
spin_unlock_bh(&tipc_port_list_lock);
|
2006-01-02 18:04:38 +00:00
|
|
|
k_term_timer(&p_ptr->timer);
|
|
|
|
}
|
|
|
|
|
2007-02-09 14:25:21 +00:00
|
|
|
/*
|
2011-06-01 20:21:12 +00:00
|
|
|
* port_build_proto_msg(): create connection protocol message for port
|
|
|
|
*
|
|
|
|
* On entry the port must be locked and connected.
|
2006-01-02 18:04:38 +00:00
|
|
|
*/
|
2011-06-01 20:21:12 +00:00
|
|
|
static struct sk_buff *port_build_proto_msg(struct tipc_port *p_ptr,
|
|
|
|
u32 type, u32 ack)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
|
|
|
struct sk_buff *buf;
|
|
|
|
struct tipc_msg *msg;
|
2007-02-09 14:25:21 +00:00
|
|
|
|
2011-05-31 19:03:18 +00:00
|
|
|
buf = tipc_buf_acquire(INT_H_SIZE);
|
2006-01-02 18:04:38 +00:00
|
|
|
if (buf) {
|
|
|
|
msg = buf_msg(buf);
|
2011-06-01 20:21:12 +00:00
|
|
|
tipc_msg_init(msg, CONN_MANAGER, type, INT_H_SIZE,
|
2014-03-12 15:31:08 +00:00
|
|
|
tipc_port_peernode(p_ptr));
|
|
|
|
msg_set_destport(msg, tipc_port_peerport(p_ptr));
|
2011-06-01 20:21:12 +00:00
|
|
|
msg_set_origport(msg, p_ptr->ref);
|
2006-01-02 18:04:38 +00:00
|
|
|
msg_set_msgcnt(msg, ack);
|
2014-06-26 01:41:39 +00:00
|
|
|
buf->next = NULL;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void port_timeout(unsigned long ref)
|
|
|
|
{
|
2011-01-07 16:43:40 +00:00
|
|
|
struct tipc_port *p_ptr = tipc_port_lock(ref);
|
2006-03-21 06:36:47 +00:00
|
|
|
struct sk_buff *buf = NULL;
|
2014-06-26 01:41:39 +00:00
|
|
|
struct tipc_msg *msg = NULL;
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2006-10-17 04:38:05 +00:00
|
|
|
if (!p_ptr)
|
|
|
|
return;
|
|
|
|
|
2011-01-07 16:43:40 +00:00
|
|
|
if (!p_ptr->connected) {
|
2006-10-17 04:38:05 +00:00
|
|
|
tipc_port_unlock(p_ptr);
|
2006-01-02 18:04:38 +00:00
|
|
|
return;
|
2006-10-17 04:38:05 +00:00
|
|
|
}
|
2006-01-02 18:04:38 +00:00
|
|
|
|
|
|
|
/* Last probe answered ? */
|
|
|
|
if (p_ptr->probing_state == PROBING) {
|
|
|
|
buf = port_build_self_abort_msg(p_ptr, TIPC_ERR_NO_PORT);
|
|
|
|
} else {
|
2011-06-01 20:21:12 +00:00
|
|
|
buf = port_build_proto_msg(p_ptr, CONN_PROBE, 0);
|
2006-01-02 18:04:38 +00:00
|
|
|
p_ptr->probing_state = PROBING;
|
|
|
|
k_start_timer(&p_ptr->timer, p_ptr->probing_interval);
|
|
|
|
}
|
2006-01-17 23:38:21 +00:00
|
|
|
tipc_port_unlock(p_ptr);
|
2014-06-26 01:41:39 +00:00
|
|
|
msg = buf_msg(buf);
|
|
|
|
tipc_link_xmit2(buf, msg_destnode(msg), msg_link_selector(msg));
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void port_handle_node_down(unsigned long ref)
|
|
|
|
{
|
2011-01-07 16:43:40 +00:00
|
|
|
struct tipc_port *p_ptr = tipc_port_lock(ref);
|
2010-12-31 18:59:32 +00:00
|
|
|
struct sk_buff *buf = NULL;
|
2014-06-26 01:41:39 +00:00
|
|
|
struct tipc_msg *msg = NULL;
|
2006-01-02 18:04:38 +00:00
|
|
|
|
|
|
|
if (!p_ptr)
|
|
|
|
return;
|
|
|
|
buf = port_build_self_abort_msg(p_ptr, TIPC_ERR_NO_NODE);
|
2006-01-17 23:38:21 +00:00
|
|
|
tipc_port_unlock(p_ptr);
|
2014-06-26 01:41:39 +00:00
|
|
|
msg = buf_msg(buf);
|
|
|
|
tipc_link_xmit2(buf, msg_destnode(msg), msg_link_selector(msg));
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-07 16:43:40 +00:00
|
|
|
static struct sk_buff *port_build_self_abort_msg(struct tipc_port *p_ptr, u32 err)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2011-05-31 20:10:08 +00:00
|
|
|
struct sk_buff *buf = port_build_peer_abort_msg(p_ptr, err);
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2011-05-31 20:10:08 +00:00
|
|
|
if (buf) {
|
|
|
|
struct tipc_msg *msg = buf_msg(buf);
|
|
|
|
msg_swap_words(msg, 4, 5);
|
|
|
|
msg_swap_words(msg, 6, 7);
|
2014-06-26 01:41:39 +00:00
|
|
|
buf->next = NULL;
|
2011-05-31 20:10:08 +00:00
|
|
|
}
|
|
|
|
return buf;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-07 16:43:40 +00:00
|
|
|
static struct sk_buff *port_build_peer_abort_msg(struct tipc_port *p_ptr, u32 err)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2011-05-31 20:10:08 +00:00
|
|
|
struct sk_buff *buf;
|
|
|
|
struct tipc_msg *msg;
|
|
|
|
u32 imp;
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2011-01-07 16:43:40 +00:00
|
|
|
if (!p_ptr->connected)
|
2006-03-21 06:36:47 +00:00
|
|
|
return NULL;
|
2011-05-31 20:10:08 +00:00
|
|
|
|
|
|
|
buf = tipc_buf_acquire(BASIC_H_SIZE);
|
|
|
|
if (buf) {
|
|
|
|
msg = buf_msg(buf);
|
|
|
|
memcpy(msg, &p_ptr->phdr, BASIC_H_SIZE);
|
|
|
|
msg_set_hdr_sz(msg, BASIC_H_SIZE);
|
|
|
|
msg_set_size(msg, BASIC_H_SIZE);
|
|
|
|
imp = msg_importance(msg);
|
|
|
|
if (imp < TIPC_CRITICAL_IMPORTANCE)
|
|
|
|
msg_set_importance(msg, ++imp);
|
|
|
|
msg_set_errcode(msg, err);
|
2014-06-26 01:41:39 +00:00
|
|
|
buf->next = NULL;
|
2011-05-31 20:10:08 +00:00
|
|
|
}
|
|
|
|
return buf;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
2014-06-26 01:41:40 +00:00
|
|
|
void tipc_port_proto_rcv(struct tipc_port *p_ptr, struct sk_buff *buf)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
|
|
|
struct tipc_msg *msg = buf_msg(buf);
|
2006-03-21 06:36:47 +00:00
|
|
|
struct sk_buff *r_buf = NULL;
|
2011-06-01 19:08:10 +00:00
|
|
|
u32 destport = msg_destport(msg);
|
|
|
|
int wakeable;
|
|
|
|
|
|
|
|
/* Validate connection */
|
2012-04-17 22:42:28 +00:00
|
|
|
if (!p_ptr || !p_ptr->connected || !tipc_port_peer_msg(p_ptr, msg)) {
|
2011-06-01 19:48:42 +00:00
|
|
|
r_buf = tipc_buf_acquire(BASIC_H_SIZE);
|
|
|
|
if (r_buf) {
|
|
|
|
msg = buf_msg(r_buf);
|
|
|
|
tipc_msg_init(msg, TIPC_HIGH_IMPORTANCE, TIPC_CONN_MSG,
|
2012-04-17 22:42:28 +00:00
|
|
|
BASIC_H_SIZE, msg_orignode(msg));
|
2011-06-01 19:48:42 +00:00
|
|
|
msg_set_errcode(msg, TIPC_ERR_NO_PORT);
|
|
|
|
msg_set_origport(msg, destport);
|
2012-04-17 22:42:28 +00:00
|
|
|
msg_set_destport(msg, msg_origport(msg));
|
2011-06-01 19:48:42 +00:00
|
|
|
}
|
2006-01-02 18:04:38 +00:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
2011-06-01 19:08:10 +00:00
|
|
|
/* Process protocol message sent by peer */
|
|
|
|
switch (msg_type(msg)) {
|
|
|
|
case CONN_ACK:
|
2014-03-12 15:31:10 +00:00
|
|
|
wakeable = tipc_port_congested(p_ptr) && p_ptr->congested;
|
2011-06-01 19:08:10 +00:00
|
|
|
p_ptr->acked += msg_msgcnt(msg);
|
|
|
|
if (!tipc_port_congested(p_ptr)) {
|
|
|
|
p_ptr->congested = 0;
|
|
|
|
if (wakeable)
|
2014-03-12 15:31:10 +00:00
|
|
|
tipc_port_wakeup(p_ptr);
|
2011-06-01 19:08:10 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case CONN_PROBE:
|
2011-06-01 20:21:12 +00:00
|
|
|
r_buf = port_build_proto_msg(p_ptr, CONN_PROBE_REPLY, 0);
|
2011-06-01 19:08:10 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* CONN_PROBE_REPLY or unrecognized - no action required */
|
|
|
|
break;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
p_ptr->probing_state = CONFIRMED;
|
|
|
|
exit:
|
2014-06-26 01:41:39 +00:00
|
|
|
tipc_link_xmit2(r_buf, msg_destnode(msg), msg_link_selector(msg));
|
2011-11-04 17:24:29 +00:00
|
|
|
kfree_skb(buf);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
2012-06-29 04:50:23 +00:00
|
|
|
static int port_print(struct tipc_port *p_ptr, char *buf, int len, int full_id)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2007-02-09 14:25:21 +00:00
|
|
|
struct publication *publ;
|
2012-06-29 04:50:23 +00:00
|
|
|
int ret;
|
2006-01-02 18:04:38 +00:00
|
|
|
|
|
|
|
if (full_id)
|
2012-06-29 04:50:23 +00:00
|
|
|
ret = tipc_snprintf(buf, len, "<%u.%u.%u:%u>:",
|
|
|
|
tipc_zone(tipc_own_addr),
|
|
|
|
tipc_cluster(tipc_own_addr),
|
|
|
|
tipc_node(tipc_own_addr), p_ptr->ref);
|
2006-01-02 18:04:38 +00:00
|
|
|
else
|
2012-06-29 04:50:23 +00:00
|
|
|
ret = tipc_snprintf(buf, len, "%-10u:", p_ptr->ref);
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2011-01-07 16:43:40 +00:00
|
|
|
if (p_ptr->connected) {
|
2014-03-12 15:31:08 +00:00
|
|
|
u32 dport = tipc_port_peerport(p_ptr);
|
|
|
|
u32 destnode = tipc_port_peernode(p_ptr);
|
2007-02-09 14:25:21 +00:00
|
|
|
|
2012-06-29 04:50:23 +00:00
|
|
|
ret += tipc_snprintf(buf + ret, len - ret,
|
|
|
|
" connected to <%u.%u.%u:%u>",
|
|
|
|
tipc_zone(destnode),
|
|
|
|
tipc_cluster(destnode),
|
|
|
|
tipc_node(destnode), dport);
|
2011-01-07 16:43:40 +00:00
|
|
|
if (p_ptr->conn_type != 0)
|
2012-06-29 04:50:23 +00:00
|
|
|
ret += tipc_snprintf(buf + ret, len - ret,
|
|
|
|
" via {%u,%u}", p_ptr->conn_type,
|
|
|
|
p_ptr->conn_instance);
|
2011-01-07 16:43:40 +00:00
|
|
|
} else if (p_ptr->published) {
|
2012-06-29 04:50:23 +00:00
|
|
|
ret += tipc_snprintf(buf + ret, len - ret, " bound to");
|
2007-02-09 14:25:21 +00:00
|
|
|
list_for_each_entry(publ, &p_ptr->publications, pport_list) {
|
2006-01-02 18:04:38 +00:00
|
|
|
if (publ->lower == publ->upper)
|
2012-06-29 04:50:23 +00:00
|
|
|
ret += tipc_snprintf(buf + ret, len - ret,
|
|
|
|
" {%u,%u}", publ->type,
|
|
|
|
publ->lower);
|
2006-01-02 18:04:38 +00:00
|
|
|
else
|
2012-06-29 04:50:23 +00:00
|
|
|
ret += tipc_snprintf(buf + ret, len - ret,
|
|
|
|
" {%u,%u,%u}", publ->type,
|
|
|
|
publ->lower, publ->upper);
|
2007-02-09 14:25:21 +00:00
|
|
|
}
|
|
|
|
}
|
2012-06-29 04:50:23 +00:00
|
|
|
ret += tipc_snprintf(buf + ret, len - ret, "\n");
|
|
|
|
return ret;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
2006-01-17 23:38:21 +00:00
|
|
|
struct sk_buff *tipc_port_get_ports(void)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
|
|
|
struct sk_buff *buf;
|
|
|
|
struct tlv_desc *rep_tlv;
|
2012-06-29 04:50:23 +00:00
|
|
|
char *pb;
|
|
|
|
int pb_len;
|
2011-01-07 16:43:40 +00:00
|
|
|
struct tipc_port *p_ptr;
|
2012-06-29 04:50:23 +00:00
|
|
|
int str_len = 0;
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2012-06-29 04:50:23 +00:00
|
|
|
buf = tipc_cfg_reply_alloc(TLV_SPACE(ULTRA_STRING_MAX_LEN));
|
2006-01-02 18:04:38 +00:00
|
|
|
if (!buf)
|
|
|
|
return NULL;
|
|
|
|
rep_tlv = (struct tlv_desc *)buf->data;
|
2012-06-29 04:50:23 +00:00
|
|
|
pb = TLV_DATA(rep_tlv);
|
|
|
|
pb_len = ULTRA_STRING_MAX_LEN;
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2006-01-17 23:38:21 +00:00
|
|
|
spin_lock_bh(&tipc_port_list_lock);
|
2006-01-02 18:04:38 +00:00
|
|
|
list_for_each_entry(p_ptr, &ports, port_list) {
|
2011-01-07 16:43:40 +00:00
|
|
|
spin_lock_bh(p_ptr->lock);
|
2012-06-29 04:50:23 +00:00
|
|
|
str_len += port_print(p_ptr, pb, pb_len, 0);
|
2011-01-07 16:43:40 +00:00
|
|
|
spin_unlock_bh(p_ptr->lock);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
2006-01-17 23:38:21 +00:00
|
|
|
spin_unlock_bh(&tipc_port_list_lock);
|
2012-06-29 04:50:23 +00:00
|
|
|
str_len += 1; /* for "\0" */
|
2006-01-02 18:04:38 +00:00
|
|
|
skb_put(buf, TLV_SPACE(str_len));
|
|
|
|
TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
|
|
|
|
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
2006-01-17 23:38:21 +00:00
|
|
|
void tipc_port_reinit(void)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2011-01-07 16:43:40 +00:00
|
|
|
struct tipc_port *p_ptr;
|
2006-01-02 18:04:38 +00:00
|
|
|
struct tipc_msg *msg;
|
|
|
|
|
2006-01-17 23:38:21 +00:00
|
|
|
spin_lock_bh(&tipc_port_list_lock);
|
2006-01-02 18:04:38 +00:00
|
|
|
list_for_each_entry(p_ptr, &ports, port_list) {
|
2011-01-07 16:43:40 +00:00
|
|
|
msg = &p_ptr->phdr;
|
2008-05-21 21:54:12 +00:00
|
|
|
msg_set_prevnode(msg, tipc_own_addr);
|
2006-01-02 18:04:38 +00:00
|
|
|
msg_set_orignode(msg, tipc_own_addr);
|
|
|
|
}
|
2006-01-17 23:38:21 +00:00
|
|
|
spin_unlock_bh(&tipc_port_list_lock);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void tipc_acknowledge(u32 ref, u32 ack)
|
|
|
|
{
|
2011-01-07 16:43:40 +00:00
|
|
|
struct tipc_port *p_ptr;
|
2006-03-21 06:36:47 +00:00
|
|
|
struct sk_buff *buf = NULL;
|
2014-06-26 01:41:39 +00:00
|
|
|
struct tipc_msg *msg;
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2006-01-17 23:38:21 +00:00
|
|
|
p_ptr = tipc_port_lock(ref);
|
2006-01-02 18:04:38 +00:00
|
|
|
if (!p_ptr)
|
|
|
|
return;
|
2011-01-07 16:43:40 +00:00
|
|
|
if (p_ptr->connected) {
|
|
|
|
p_ptr->conn_unacked -= ack;
|
2011-06-01 20:21:12 +00:00
|
|
|
buf = port_build_proto_msg(p_ptr, CONN_ACK, ack);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
2006-01-17 23:38:21 +00:00
|
|
|
tipc_port_unlock(p_ptr);
|
2014-06-26 01:41:39 +00:00
|
|
|
if (!buf)
|
|
|
|
return;
|
|
|
|
msg = buf_msg(buf);
|
|
|
|
tipc_link_xmit2(buf, msg_destnode(msg), msg_link_selector(msg));
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
2013-12-27 02:18:28 +00:00
|
|
|
int tipc_publish(struct tipc_port *p_ptr, unsigned int scope,
|
|
|
|
struct tipc_name_seq const *seq)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
|
|
|
struct publication *publ;
|
|
|
|
u32 key;
|
|
|
|
|
2013-12-27 02:18:28 +00:00
|
|
|
if (p_ptr->connected)
|
2006-11-01 00:59:35 +00:00
|
|
|
return -EINVAL;
|
2013-12-27 02:18:28 +00:00
|
|
|
key = p_ptr->ref + p_ptr->pub_count + 1;
|
|
|
|
if (key == p_ptr->ref)
|
|
|
|
return -EADDRINUSE;
|
2006-11-01 00:59:35 +00:00
|
|
|
|
2006-01-17 23:38:21 +00:00
|
|
|
publ = tipc_nametbl_publish(seq->type, seq->lower, seq->upper,
|
2011-01-07 16:43:40 +00:00
|
|
|
scope, p_ptr->ref, key);
|
2006-01-02 18:04:38 +00:00
|
|
|
if (publ) {
|
|
|
|
list_add(&publ->pport_list, &p_ptr->publications);
|
|
|
|
p_ptr->pub_count++;
|
2011-01-07 16:43:40 +00:00
|
|
|
p_ptr->published = 1;
|
2013-12-27 02:18:28 +00:00
|
|
|
return 0;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
2013-12-27 02:18:28 +00:00
|
|
|
return -EINVAL;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
2013-12-27 02:18:28 +00:00
|
|
|
int tipc_withdraw(struct tipc_port *p_ptr, unsigned int scope,
|
|
|
|
struct tipc_name_seq const *seq)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
|
|
|
struct publication *publ;
|
|
|
|
struct publication *tpubl;
|
|
|
|
int res = -EINVAL;
|
2007-02-09 14:25:21 +00:00
|
|
|
|
2006-01-02 18:04:38 +00:00
|
|
|
if (!seq) {
|
2007-02-09 14:25:21 +00:00
|
|
|
list_for_each_entry_safe(publ, tpubl,
|
2006-01-02 18:04:38 +00:00
|
|
|
&p_ptr->publications, pport_list) {
|
2007-02-09 14:25:21 +00:00
|
|
|
tipc_nametbl_withdraw(publ->type, publ->lower,
|
2006-01-17 23:38:21 +00:00
|
|
|
publ->ref, publ->key);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
2008-07-15 05:44:01 +00:00
|
|
|
res = 0;
|
2006-01-02 18:04:38 +00:00
|
|
|
} else {
|
2007-02-09 14:25:21 +00:00
|
|
|
list_for_each_entry_safe(publ, tpubl,
|
2006-01-02 18:04:38 +00:00
|
|
|
&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;
|
2007-02-09 14:25:21 +00:00
|
|
|
tipc_nametbl_withdraw(publ->type, publ->lower,
|
2006-01-17 23:38:21 +00:00
|
|
|
publ->ref, publ->key);
|
2008-07-15 05:44:01 +00:00
|
|
|
res = 0;
|
2006-01-02 18:04:38 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (list_empty(&p_ptr->publications))
|
2011-01-07 16:43:40 +00:00
|
|
|
p_ptr->published = 0;
|
2006-01-02 18:04:38 +00:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2014-02-18 08:06:46 +00:00
|
|
|
int tipc_port_connect(u32 ref, struct tipc_portid const *peer)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2011-01-07 16:43:40 +00:00
|
|
|
struct tipc_port *p_ptr;
|
tipc: standardize across connect/disconnect function naming
Currently we have tipc_disconnect and tipc_disconnect_port. It is
not clear from the names alone, what they do or how they differ.
It turns out that tipc_disconnect just deals with the port locking
and then calls tipc_disconnect_port which does all the work.
If we rename as follows: tipc_disconnect_port --> __tipc_disconnect
then we will be following typical linux convention, where:
__tipc_disconnect: "raw" function that does all the work.
tipc_disconnect: wrapper that deals with locking and then calls
the real core __tipc_disconnect function
With this, the difference is immediately evident, and locking
violations are more apt to be spotted by chance while working on,
or even just while reading the code.
On the connect side of things, we currently only have the single
"tipc_connect2port" function. It does both the locking at enter/exit,
and the core of the work. Pending changes will make it desireable to
have the connect be a two part locking wrapper + worker function,
just like the disconnect is already.
Here, we make the connect look just like the updated disconnect case,
for the above reason, and for consistency. In the process, we also
get rid of the "2port" suffix that was on the original name, since
it adds no descriptive value.
On close examination, one might notice that the above connect
changes implicitly move the call to tipc_link_get_max_pkt() to be
within the scope of tipc_port_lock() protected region; when it was
not previously. We don't see any issues with this, and it is in
keeping with __tipc_connect doing the work and tipc_connect just
handling the locking.
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2012-11-29 18:48:40 +00:00
|
|
|
int res;
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2006-01-17 23:38:21 +00:00
|
|
|
p_ptr = tipc_port_lock(ref);
|
2006-01-02 18:04:38 +00:00
|
|
|
if (!p_ptr)
|
|
|
|
return -EINVAL;
|
2014-02-18 08:06:46 +00:00
|
|
|
res = __tipc_port_connect(ref, p_ptr, peer);
|
tipc: standardize across connect/disconnect function naming
Currently we have tipc_disconnect and tipc_disconnect_port. It is
not clear from the names alone, what they do or how they differ.
It turns out that tipc_disconnect just deals with the port locking
and then calls tipc_disconnect_port which does all the work.
If we rename as follows: tipc_disconnect_port --> __tipc_disconnect
then we will be following typical linux convention, where:
__tipc_disconnect: "raw" function that does all the work.
tipc_disconnect: wrapper that deals with locking and then calls
the real core __tipc_disconnect function
With this, the difference is immediately evident, and locking
violations are more apt to be spotted by chance while working on,
or even just while reading the code.
On the connect side of things, we currently only have the single
"tipc_connect2port" function. It does both the locking at enter/exit,
and the core of the work. Pending changes will make it desireable to
have the connect be a two part locking wrapper + worker function,
just like the disconnect is already.
Here, we make the connect look just like the updated disconnect case,
for the above reason, and for consistency. In the process, we also
get rid of the "2port" suffix that was on the original name, since
it adds no descriptive value.
On close examination, one might notice that the above connect
changes implicitly move the call to tipc_link_get_max_pkt() to be
within the scope of tipc_port_lock() protected region; when it was
not previously. We don't see any issues with this, and it is in
keeping with __tipc_connect doing the work and tipc_connect just
handling the locking.
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2012-11-29 18:48:40 +00:00
|
|
|
tipc_port_unlock(p_ptr);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2014-02-18 08:06:46 +00:00
|
|
|
* __tipc_port_connect - connect to a remote peer
|
tipc: standardize across connect/disconnect function naming
Currently we have tipc_disconnect and tipc_disconnect_port. It is
not clear from the names alone, what they do or how they differ.
It turns out that tipc_disconnect just deals with the port locking
and then calls tipc_disconnect_port which does all the work.
If we rename as follows: tipc_disconnect_port --> __tipc_disconnect
then we will be following typical linux convention, where:
__tipc_disconnect: "raw" function that does all the work.
tipc_disconnect: wrapper that deals with locking and then calls
the real core __tipc_disconnect function
With this, the difference is immediately evident, and locking
violations are more apt to be spotted by chance while working on,
or even just while reading the code.
On the connect side of things, we currently only have the single
"tipc_connect2port" function. It does both the locking at enter/exit,
and the core of the work. Pending changes will make it desireable to
have the connect be a two part locking wrapper + worker function,
just like the disconnect is already.
Here, we make the connect look just like the updated disconnect case,
for the above reason, and for consistency. In the process, we also
get rid of the "2port" suffix that was on the original name, since
it adds no descriptive value.
On close examination, one might notice that the above connect
changes implicitly move the call to tipc_link_get_max_pkt() to be
within the scope of tipc_port_lock() protected region; when it was
not previously. We don't see any issues with this, and it is in
keeping with __tipc_connect doing the work and tipc_connect just
handling the locking.
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2012-11-29 18:48:40 +00:00
|
|
|
*
|
|
|
|
* Port must be locked.
|
|
|
|
*/
|
2014-02-18 08:06:46 +00:00
|
|
|
int __tipc_port_connect(u32 ref, struct tipc_port *p_ptr,
|
tipc: standardize across connect/disconnect function naming
Currently we have tipc_disconnect and tipc_disconnect_port. It is
not clear from the names alone, what they do or how they differ.
It turns out that tipc_disconnect just deals with the port locking
and then calls tipc_disconnect_port which does all the work.
If we rename as follows: tipc_disconnect_port --> __tipc_disconnect
then we will be following typical linux convention, where:
__tipc_disconnect: "raw" function that does all the work.
tipc_disconnect: wrapper that deals with locking and then calls
the real core __tipc_disconnect function
With this, the difference is immediately evident, and locking
violations are more apt to be spotted by chance while working on,
or even just while reading the code.
On the connect side of things, we currently only have the single
"tipc_connect2port" function. It does both the locking at enter/exit,
and the core of the work. Pending changes will make it desireable to
have the connect be a two part locking wrapper + worker function,
just like the disconnect is already.
Here, we make the connect look just like the updated disconnect case,
for the above reason, and for consistency. In the process, we also
get rid of the "2port" suffix that was on the original name, since
it adds no descriptive value.
On close examination, one might notice that the above connect
changes implicitly move the call to tipc_link_get_max_pkt() to be
within the scope of tipc_port_lock() protected region; when it was
not previously. We don't see any issues with this, and it is in
keeping with __tipc_connect doing the work and tipc_connect just
handling the locking.
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2012-11-29 18:48:40 +00:00
|
|
|
struct tipc_portid const *peer)
|
|
|
|
{
|
|
|
|
struct tipc_msg *msg;
|
|
|
|
int res = -EINVAL;
|
|
|
|
|
2011-01-07 16:43:40 +00:00
|
|
|
if (p_ptr->published || p_ptr->connected)
|
2006-01-02 18:04:38 +00:00
|
|
|
goto exit;
|
|
|
|
if (!peer->ref)
|
|
|
|
goto exit;
|
|
|
|
|
2011-01-07 16:43:40 +00:00
|
|
|
msg = &p_ptr->phdr;
|
2006-01-02 18:04:38 +00:00
|
|
|
msg_set_destnode(msg, peer->node);
|
|
|
|
msg_set_destport(msg, peer->ref);
|
|
|
|
msg_set_type(msg, TIPC_CONN_MSG);
|
2011-04-17 20:02:11 +00:00
|
|
|
msg_set_lookup_scope(msg, 0);
|
2010-12-31 18:59:17 +00:00
|
|
|
msg_set_hdr_sz(msg, SHORT_H_SIZE);
|
2006-01-02 18:04:38 +00:00
|
|
|
|
|
|
|
p_ptr->probing_interval = PROBING_INTERVAL;
|
|
|
|
p_ptr->probing_state = CONFIRMED;
|
2011-01-07 16:43:40 +00:00
|
|
|
p_ptr->connected = 1;
|
2006-01-02 18:04:38 +00:00
|
|
|
k_start_timer(&p_ptr->timer, p_ptr->probing_interval);
|
|
|
|
|
2010-12-31 18:59:32 +00:00
|
|
|
tipc_nodesub_subscribe(&p_ptr->subscription, peer->node,
|
2006-01-12 21:22:32 +00:00
|
|
|
(void *)(unsigned long)ref,
|
2006-01-02 18:04:38 +00:00
|
|
|
(net_ev_handler)port_handle_node_down);
|
2008-07-15 05:44:01 +00:00
|
|
|
res = 0;
|
2006-01-02 18:04:38 +00:00
|
|
|
exit:
|
2014-06-26 01:41:38 +00:00
|
|
|
p_ptr->max_pkt = tipc_node_get_mtu(peer->node, ref);
|
2006-01-02 18:04:38 +00:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
tipc: standardize across connect/disconnect function naming
Currently we have tipc_disconnect and tipc_disconnect_port. It is
not clear from the names alone, what they do or how they differ.
It turns out that tipc_disconnect just deals with the port locking
and then calls tipc_disconnect_port which does all the work.
If we rename as follows: tipc_disconnect_port --> __tipc_disconnect
then we will be following typical linux convention, where:
__tipc_disconnect: "raw" function that does all the work.
tipc_disconnect: wrapper that deals with locking and then calls
the real core __tipc_disconnect function
With this, the difference is immediately evident, and locking
violations are more apt to be spotted by chance while working on,
or even just while reading the code.
On the connect side of things, we currently only have the single
"tipc_connect2port" function. It does both the locking at enter/exit,
and the core of the work. Pending changes will make it desireable to
have the connect be a two part locking wrapper + worker function,
just like the disconnect is already.
Here, we make the connect look just like the updated disconnect case,
for the above reason, and for consistency. In the process, we also
get rid of the "2port" suffix that was on the original name, since
it adds no descriptive value.
On close examination, one might notice that the above connect
changes implicitly move the call to tipc_link_get_max_pkt() to be
within the scope of tipc_port_lock() protected region; when it was
not previously. We don't see any issues with this, and it is in
keeping with __tipc_connect doing the work and tipc_connect just
handling the locking.
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2012-11-29 18:48:40 +00:00
|
|
|
/*
|
|
|
|
* __tipc_disconnect - disconnect port from peer
|
2008-04-15 07:22:02 +00:00
|
|
|
*
|
|
|
|
* Port must be locked.
|
|
|
|
*/
|
2014-02-18 08:06:46 +00:00
|
|
|
int __tipc_port_disconnect(struct tipc_port *tp_ptr)
|
2008-04-15 07:22:02 +00:00
|
|
|
{
|
|
|
|
if (tp_ptr->connected) {
|
|
|
|
tp_ptr->connected = 0;
|
|
|
|
/* let timer expire on it's own to avoid deadlock! */
|
2012-06-03 17:41:40 +00:00
|
|
|
tipc_nodesub_unsubscribe(&tp_ptr->subscription);
|
2013-12-12 01:36:39 +00:00
|
|
|
return 0;
|
2008-04-15 07:22:02 +00:00
|
|
|
}
|
2013-12-12 01:36:39 +00:00
|
|
|
|
|
|
|
return -ENOTCONN;
|
2008-04-15 07:22:02 +00:00
|
|
|
}
|
|
|
|
|
2006-01-02 18:04:38 +00:00
|
|
|
/*
|
2014-02-18 08:06:46 +00:00
|
|
|
* tipc_port_disconnect(): Disconnect port form peer.
|
2006-01-02 18:04:38 +00:00
|
|
|
* This is a node local operation.
|
|
|
|
*/
|
2014-02-18 08:06:46 +00:00
|
|
|
int tipc_port_disconnect(u32 ref)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2011-01-07 16:43:40 +00:00
|
|
|
struct tipc_port *p_ptr;
|
2008-04-15 07:22:02 +00:00
|
|
|
int res;
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2006-01-17 23:38:21 +00:00
|
|
|
p_ptr = tipc_port_lock(ref);
|
2006-01-02 18:04:38 +00:00
|
|
|
if (!p_ptr)
|
|
|
|
return -EINVAL;
|
2014-02-18 08:06:46 +00:00
|
|
|
res = __tipc_port_disconnect(p_ptr);
|
2006-01-17 23:38:21 +00:00
|
|
|
tipc_port_unlock(p_ptr);
|
2006-01-02 18:04:38 +00:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2014-02-18 08:06:46 +00:00
|
|
|
* tipc_port_shutdown(): Send a SHUTDOWN msg to peer and disconnect
|
2006-01-02 18:04:38 +00:00
|
|
|
*/
|
2014-02-18 08:06:46 +00:00
|
|
|
int tipc_port_shutdown(u32 ref)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2014-06-26 01:41:39 +00:00
|
|
|
struct tipc_msg *msg;
|
2011-01-07 16:43:40 +00:00
|
|
|
struct tipc_port *p_ptr;
|
2006-03-21 06:36:47 +00:00
|
|
|
struct sk_buff *buf = NULL;
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2006-01-17 23:38:21 +00:00
|
|
|
p_ptr = tipc_port_lock(ref);
|
2006-01-02 18:04:38 +00:00
|
|
|
if (!p_ptr)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-05-31 20:10:08 +00:00
|
|
|
buf = port_build_peer_abort_msg(p_ptr, TIPC_CONN_SHUTDOWN);
|
2006-01-17 23:38:21 +00:00
|
|
|
tipc_port_unlock(p_ptr);
|
2014-06-26 01:41:39 +00:00
|
|
|
msg = buf_msg(buf);
|
|
|
|
tipc_link_xmit2(buf, msg_destnode(msg), msg_link_selector(msg));
|
2014-02-18 08:06:46 +00:00
|
|
|
return tipc_port_disconnect(ref);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|