[TIPC] Initial merge
TIPC (Transparent Inter Process Communication) is a protocol designed for intra cluster communication. For more information see http://tipc.sourceforge.net Signed-off-by: Per Liden <per.liden@nospam.ericsson.com>
This commit is contained in:
Per Liden
David S. Miller
parent
58cba4650a
commit
b97bf3fd8f
54 changed files with 19464 additions and 0 deletions
|
|
@ -186,6 +186,7 @@ struct ucred {
|
|||
#define AF_PPPOX 24 /* PPPoX sockets */
|
||||
#define AF_WANPIPE 25 /* Wanpipe API Sockets */
|
||||
#define AF_LLC 26 /* Linux LLC */
|
||||
#define AF_TIPC 30 /* TIPC sockets */
|
||||
#define AF_BLUETOOTH 31 /* Bluetooth sockets */
|
||||
#define AF_MAX 32 /* For now.. */
|
||||
|
||||
|
|
@ -218,6 +219,7 @@ struct ucred {
|
|||
#define PF_PPPOX AF_PPPOX
|
||||
#define PF_WANPIPE AF_WANPIPE
|
||||
#define PF_LLC AF_LLC
|
||||
#define PF_TIPC AF_TIPC
|
||||
#define PF_BLUETOOTH AF_BLUETOOTH
|
||||
#define PF_MAX AF_MAX
|
||||
|
||||
|
|
@ -279,6 +281,7 @@ struct ucred {
|
|||
#define SOL_LLC 268
|
||||
#define SOL_DCCP 269
|
||||
#define SOL_NETLINK 270
|
||||
#define SOL_TIPC 271
|
||||
|
||||
/* IPX options */
|
||||
#define IPX_TYPE 1
|
||||
|
|
|
|||
598
include/linux/tipc.h
Normal file
598
include/linux/tipc.h
Normal file
|
|
@ -0,0 +1,598 @@
|
|||
/*
|
||||
* include/linux/tipc.h: Include file for TIPC users
|
||||
*
|
||||
* Copyright (c) 2003-2005, Ericsson Research Canada
|
||||
* Copyright (c) 2005, Wind River Systems
|
||||
* Copyright (c) 2005-2006, Ericsson AB
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
* list of conditions and the following disclaimer.
|
||||
* 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.
|
||||
* 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.
|
||||
*
|
||||
* 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 _LINUX_TIPC_H_
|
||||
#define _LINUX_TIPC_H_
|
||||
|
||||
#include <linux/types.h>
|
||||
#include <linux/string.h>
|
||||
#include <asm/byteorder.h>
|
||||
|
||||
/*
|
||||
* TIPC addressing primitives
|
||||
*/
|
||||
|
||||
struct tipc_portid {
|
||||
__u32 ref;
|
||||
__u32 node;
|
||||
};
|
||||
|
||||
struct tipc_name {
|
||||
__u32 type;
|
||||
__u32 instance;
|
||||
};
|
||||
|
||||
struct tipc_name_seq {
|
||||
__u32 type;
|
||||
__u32 lower;
|
||||
__u32 upper;
|
||||
};
|
||||
|
||||
static inline __u32 tipc_addr(unsigned int zone,
|
||||
unsigned int cluster,
|
||||
unsigned int node)
|
||||
{
|
||||
return(zone << 24) | (cluster << 12) | node;
|
||||
}
|
||||
|
||||
static inline unsigned int tipc_zone(__u32 addr)
|
||||
{
|
||||
return addr >> 24;
|
||||
}
|
||||
|
||||
static inline unsigned int tipc_cluster(__u32 addr)
|
||||
{
|
||||
return(addr >> 12) & 0xfff;
|
||||
}
|
||||
|
||||
static inline unsigned int tipc_node(__u32 addr)
|
||||
{
|
||||
return addr & 0xfff;
|
||||
}
|
||||
|
||||
/*
|
||||
* Application-accessible port name types
|
||||
*/
|
||||
|
||||
#define TIPC_NET_EVENTS 0 /* network event subscription name type */
|
||||
#define TIPC_TOP_SRV 1 /* topology service name type */
|
||||
#define TIPC_RESERVED_TYPES 64 /* lowest user-publishable name type */
|
||||
|
||||
/*
|
||||
* Publication scopes when binding port names and port name sequences
|
||||
*/
|
||||
|
||||
#define TIPC_ZONE_SCOPE 1
|
||||
#define TIPC_CLUSTER_SCOPE 2
|
||||
#define TIPC_NODE_SCOPE 3
|
||||
|
||||
/*
|
||||
* Limiting values for messages
|
||||
*/
|
||||
|
||||
#define TIPC_MAX_USER_MSG_SIZE 66000
|
||||
|
||||
/*
|
||||
* Message importance levels
|
||||
*/
|
||||
|
||||
#define TIPC_LOW_IMPORTANCE 0 /* default */
|
||||
#define TIPC_MEDIUM_IMPORTANCE 1
|
||||
#define TIPC_HIGH_IMPORTANCE 2
|
||||
#define TIPC_CRITICAL_IMPORTANCE 3
|
||||
|
||||
/*
|
||||
* Msg rejection/connection shutdown reasons
|
||||
*/
|
||||
|
||||
#define TIPC_OK 0
|
||||
#define TIPC_ERR_NO_NAME 1
|
||||
#define TIPC_ERR_NO_PORT 2
|
||||
#define TIPC_ERR_NO_NODE 3
|
||||
#define TIPC_ERR_OVERLOAD 4
|
||||
#define TIPC_CONN_SHUTDOWN 5
|
||||
|
||||
/*
|
||||
* TIPC topology subscription service definitions
|
||||
*/
|
||||
|
||||
#define TIPC_SUB_PORTS 0x01 /* filter for port availability */
|
||||
#define TIPC_SUB_SERVICE 0x02 /* filter for service availability */
|
||||
#if 0
|
||||
/* The following filter options are not currently implemented */
|
||||
#define TIPC_SUB_NO_BIND_EVTS 0x04 /* filter out "publish" events */
|
||||
#define TIPC_SUB_NO_UNBIND_EVTS 0x08 /* filter out "withdraw" events */
|
||||
#define TIPC_SUB_SINGLE_EVT 0x10 /* expire after first event */
|
||||
#endif
|
||||
|
||||
#define TIPC_WAIT_FOREVER ~0 /* timeout for permanent subscription */
|
||||
|
||||
struct tipc_subscr {
|
||||
struct tipc_name_seq seq; /* name sequence of interest */
|
||||
__u32 timeout; /* subscription duration (in ms) */
|
||||
__u32 filter; /* bitmask of filter options */
|
||||
char usr_handle[8]; /* available for subscriber use */
|
||||
};
|
||||
|
||||
|
||||
#define TIPC_PUBLISHED 1 /* publication event */
|
||||
#define TIPC_WITHDRAWN 2 /* withdraw event */
|
||||
#define TIPC_SUBSCR_TIMEOUT 3 /* subscription timeout event */
|
||||
|
||||
struct tipc_event {
|
||||
__u32 event; /* event type */
|
||||
__u32 found_lower; /* matching name seq instances */
|
||||
__u32 found_upper; /* " " " " */
|
||||
struct tipc_portid port; /* associated port */
|
||||
struct tipc_subscr s; /* associated subscription */
|
||||
};
|
||||
|
||||
/*
|
||||
* Socket API
|
||||
*/
|
||||
|
||||
#ifndef AF_TIPC
|
||||
#define AF_TIPC 30
|
||||
#endif
|
||||
|
||||
#ifndef PF_TIPC
|
||||
#define PF_TIPC AF_TIPC
|
||||
#endif
|
||||
|
||||
#ifndef SOL_TIPC
|
||||
#define SOL_TIPC 271
|
||||
#endif
|
||||
|
||||
#define TIPC_ADDR_NAMESEQ 1
|
||||
#define TIPC_ADDR_MCAST 1
|
||||
#define TIPC_ADDR_NAME 2
|
||||
#define TIPC_ADDR_ID 3
|
||||
|
||||
struct sockaddr_tipc {
|
||||
unsigned short family;
|
||||
unsigned char addrtype;
|
||||
signed char scope;
|
||||
union {
|
||||
struct tipc_portid id;
|
||||
struct tipc_name_seq nameseq;
|
||||
struct {
|
||||
struct tipc_name name;
|
||||
__u32 domain; /* 0: own zone */
|
||||
} name;
|
||||
} addr;
|
||||
};
|
||||
|
||||
/*
|
||||
* Ancillary data objects supported by recvmsg()
|
||||
*/
|
||||
|
||||
#define TIPC_ERRINFO 1 /* error info */
|
||||
#define TIPC_RETDATA 2 /* returned data */
|
||||
#define TIPC_DESTNAME 3 /* destination name */
|
||||
|
||||
/*
|
||||
* TIPC-specific socket option values
|
||||
*/
|
||||
|
||||
#define TIPC_IMPORTANCE 127 /* Default: TIPC_LOW_IMPORTANCE */
|
||||
#define TIPC_SRC_DROPPABLE 128 /* Default: 0 (resend congested msg) */
|
||||
#define TIPC_DEST_DROPPABLE 129 /* Default: based on socket type */
|
||||
#define TIPC_CONN_TIMEOUT 130 /* Default: 8000 (ms) */
|
||||
|
||||
/*
|
||||
* Bearer
|
||||
*/
|
||||
|
||||
/* Identifiers of supported TIPC media types */
|
||||
|
||||
#define TIPC_MEDIA_TYPE_ETH 1
|
||||
|
||||
/* Maximum sizes of TIPC bearer-related names (including terminating NUL) */
|
||||
|
||||
#define TIPC_MAX_MEDIA_NAME 16 /* format = media */
|
||||
#define TIPC_MAX_IF_NAME 16 /* format = interface */
|
||||
#define TIPC_MAX_BEARER_NAME 32 /* format = media:interface */
|
||||
#define TIPC_MAX_LINK_NAME 60 /* format = Z.C.N:interface-Z.C.N:interface */
|
||||
|
||||
struct tipc_media_addr {
|
||||
__u32 type;
|
||||
union {
|
||||
__u8 eth_addr[6]; /* Ethernet bearer */
|
||||
#if 0
|
||||
/* Prototypes for other possible bearer types */
|
||||
|
||||
struct {
|
||||
__u16 sin_family;
|
||||
__u16 sin_port;
|
||||
struct {
|
||||
__u32 s_addr;
|
||||
} sin_addr;
|
||||
char pad[4];
|
||||
} addr_in; /* IP-based bearer */
|
||||
__u16 sock_descr; /* generic socket bearer */
|
||||
#endif
|
||||
} dev_addr;
|
||||
};
|
||||
|
||||
|
||||
/* Link priority limits (range from 0 to # priorities - 1) */
|
||||
|
||||
#define TIPC_NUM_LINK_PRI 32
|
||||
|
||||
/* Link tolerance limits (min, default, max), in ms */
|
||||
|
||||
#define TIPC_MIN_LINK_TOL 50
|
||||
#define TIPC_DEF_LINK_TOL 1500
|
||||
#define TIPC_MAX_LINK_TOL 30000
|
||||
|
||||
/* Link window limits (min, default, max), in packets */
|
||||
|
||||
#define TIPC_MIN_LINK_WIN 16
|
||||
#define TIPC_DEF_LINK_WIN 50
|
||||
#define TIPC_MAX_LINK_WIN 150
|
||||
|
||||
/*
|
||||
* Configuration
|
||||
*
|
||||
* All configuration management messaging involves sending a request message
|
||||
* to the TIPC configuration service on a node, which sends a reply message
|
||||
* back. (In the future multi-message replies may be supported.)
|
||||
*
|
||||
* Both request and reply messages consist of a transport header and payload.
|
||||
* The transport header contains info about the desired operation;
|
||||
* the payload consists of zero or more type/length/value (TLV) items
|
||||
* which specify parameters or results for the operation.
|
||||
*
|
||||
* For many operations, the request and reply messages have a fixed number
|
||||
* of TLVs (usually zero or one); however, some reply messages may return
|
||||
* a variable number of TLVs. A failed request is denoted by the presence
|
||||
* of an "error string" TLV in the reply message instead of the TLV(s) the
|
||||
* reply should contain if the request succeeds.
|
||||
*/
|
||||
|
||||
#define TIPC_CFG_SRV 0 /* configuration service name type */
|
||||
|
||||
/*
|
||||
* Public commands:
|
||||
* May be issued by any process.
|
||||
* Accepted by own node, or by remote node only if remote management enabled.
|
||||
*/
|
||||
|
||||
#define TIPC_CMD_NOOP 0x0000 /* tx none, rx none */
|
||||
#define TIPC_CMD_GET_NODES 0x0001 /* tx net_addr, rx node_info(s) */
|
||||
#define TIPC_CMD_GET_MEDIA_NAMES 0x0002 /* tx none, rx media_name(s) */
|
||||
#define TIPC_CMD_GET_BEARER_NAMES 0x0003 /* tx none, rx bearer_name(s) */
|
||||
#define TIPC_CMD_GET_LINKS 0x0004 /* tx net_addr, rx link_info(s) */
|
||||
#define TIPC_CMD_SHOW_NAME_TABLE 0x0005 /* tx name_tbl_query, rx ultra_string */
|
||||
#define TIPC_CMD_SHOW_PORTS 0x0006 /* tx none, rx ultra_string */
|
||||
#define TIPC_CMD_SHOW_LINK_STATS 0x000B /* tx link_name, rx ultra_string */
|
||||
|
||||
#if 0
|
||||
#define TIPC_CMD_SHOW_PORT_STATS 0x0008 /* tx port_ref, rx ultra_string */
|
||||
#define TIPC_CMD_RESET_PORT_STATS 0x0009 /* tx port_ref, rx none */
|
||||
#define TIPC_CMD_GET_ROUTES 0x000A /* tx ?, rx ? */
|
||||
#define TIPC_CMD_GET_LINK_PEER 0x000D /* tx link_name, rx ? */
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Protected commands:
|
||||
* May only be issued by "network administration capable" process.
|
||||
* Accepted by own node, or by remote node only if remote management enabled
|
||||
* and this node is zone manager.
|
||||
*/
|
||||
|
||||
#define TIPC_CMD_GET_REMOTE_MNG 0x4003 /* tx none, rx unsigned */
|
||||
#define TIPC_CMD_GET_MAX_PORTS 0x4004 /* tx none, rx unsigned */
|
||||
#define TIPC_CMD_GET_MAX_PUBL 0x4005 /* tx none, rx unsigned */
|
||||
#define TIPC_CMD_GET_MAX_SUBSCR 0x4006 /* tx none, rx unsigned */
|
||||
#define TIPC_CMD_GET_MAX_ZONES 0x4007 /* tx none, rx unsigned */
|
||||
#define TIPC_CMD_GET_MAX_CLUSTERS 0x4008 /* tx none, rx unsigned */
|
||||
#define TIPC_CMD_GET_MAX_NODES 0x4009 /* tx none, rx unsigned */
|
||||
#define TIPC_CMD_GET_MAX_SLAVES 0x400A /* tx none, rx unsigned */
|
||||
#define TIPC_CMD_GET_NETID 0x400B /* tx none, rx unsigned */
|
||||
|
||||
#define TIPC_CMD_ENABLE_BEARER 0x4101 /* tx bearer_config, rx none */
|
||||
#define TIPC_CMD_DISABLE_BEARER 0x4102 /* tx bearer_name, rx none */
|
||||
#define TIPC_CMD_SET_LINK_TOL 0x4107 /* tx link_config, rx none */
|
||||
#define TIPC_CMD_SET_LINK_PRI 0x4108 /* tx link_config, rx none */
|
||||
#define TIPC_CMD_SET_LINK_WINDOW 0x4109 /* tx link_config, rx none */
|
||||
#define TIPC_CMD_SET_LOG_SIZE 0x410A /* tx unsigned, rx none */
|
||||
#define TIPC_CMD_DUMP_LOG 0x410B /* tx none, rx ultra_string */
|
||||
#define TIPC_CMD_RESET_LINK_STATS 0x410C /* tx link_name, rx none */
|
||||
|
||||
#if 0
|
||||
#define TIPC_CMD_CREATE_LINK 0x4103 /* tx link_create, rx none */
|
||||
#define TIPC_CMD_REMOVE_LINK 0x4104 /* tx link_name, rx none */
|
||||
#define TIPC_CMD_BLOCK_LINK 0x4105 /* tx link_name, rx none */
|
||||
#define TIPC_CMD_UNBLOCK_LINK 0x4106 /* tx link_name, rx none */
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Private commands:
|
||||
* May only be issued by "network administration capable" process.
|
||||
* Accepted by own node only; cannot be used on a remote node.
|
||||
*/
|
||||
|
||||
#define TIPC_CMD_SET_NODE_ADDR 0x8001 /* tx net_addr, rx none */
|
||||
#if 0
|
||||
#define TIPC_CMD_SET_ZONE_MASTER 0x8002 /* tx none, rx none */
|
||||
#endif
|
||||
#define TIPC_CMD_SET_REMOTE_MNG 0x8003 /* tx unsigned, rx none */
|
||||
#define TIPC_CMD_SET_MAX_PORTS 0x8004 /* tx unsigned, rx none */
|
||||
#define TIPC_CMD_SET_MAX_PUBL 0x8005 /* tx unsigned, rx none */
|
||||
#define TIPC_CMD_SET_MAX_SUBSCR 0x8006 /* tx unsigned, rx none */
|
||||
#define TIPC_CMD_SET_MAX_ZONES 0x8007 /* tx unsigned, rx none */
|
||||
#define TIPC_CMD_SET_MAX_CLUSTERS 0x8008 /* tx unsigned, rx none */
|
||||
#define TIPC_CMD_SET_MAX_NODES 0x8009 /* tx unsigned, rx none */
|
||||
#define TIPC_CMD_SET_MAX_SLAVES 0x800A /* tx unsigned, rx none */
|
||||
#define TIPC_CMD_SET_NETID 0x800B /* tx unsigned, rx none */
|
||||
|
||||
/*
|
||||
* TLV types defined for TIPC
|
||||
*/
|
||||
|
||||
#define TIPC_TLV_NONE 0 /* no TLV present */
|
||||
#define TIPC_TLV_VOID 1 /* empty TLV (0 data bytes)*/
|
||||
#define TIPC_TLV_UNSIGNED 2 /* 32-bit integer */
|
||||
#define TIPC_TLV_STRING 3 /* char[128] (max) */
|
||||
#define TIPC_TLV_LARGE_STRING 4 /* char[2048] (max) */
|
||||
#define TIPC_TLV_ULTRA_STRING 5 /* char[32768] (max) */
|
||||
|
||||
#define TIPC_TLV_ERROR_STRING 16 /* char[128] containing "error code" */
|
||||
#define TIPC_TLV_NET_ADDR 17 /* 32-bit integer denoting <Z.C.N> */
|
||||
#define TIPC_TLV_MEDIA_NAME 18 /* char[MAX_MEDIA_NAME] */
|
||||
#define TIPC_TLV_BEARER_NAME 19 /* char[MAX_BEARER_NAME] */
|
||||
#define TIPC_TLV_LINK_NAME 20 /* char[MAX_LINK_NAME] */
|
||||
#define TIPC_TLV_NODE_INFO 21 /* struct tipc_node_info */
|
||||
#define TIPC_TLV_LINK_INFO 22 /* struct tipc_link_info */
|
||||
#define TIPC_TLV_BEARER_CONFIG 23 /* struct tipc_bearer_config */
|
||||
#define TIPC_TLV_LINK_CONFIG 24 /* struct tipc_link_config */
|
||||
#define TIPC_TLV_NAME_TBL_QUERY 25 /* struct tipc_name_table_query */
|
||||
#define TIPC_TLV_PORT_REF 26 /* 32-bit port reference */
|
||||
|
||||
struct tipc_node_info {
|
||||
__u32 addr; /* network address of node */
|
||||
__u32 up; /* 0=down, 1= up */
|
||||
};
|
||||
|
||||
struct tipc_link_info {
|
||||
__u32 dest; /* network address of peer node */
|
||||
__u32 up; /* 0=down, 1=up */
|
||||
char str[TIPC_MAX_LINK_NAME]; /* link name */
|
||||
};
|
||||
|
||||
struct tipc_bearer_config {
|
||||
__u32 priority; /* Range [1,31]. Override per link */
|
||||
__u32 detect_scope;
|
||||
char name[TIPC_MAX_BEARER_NAME];
|
||||
};
|
||||
|
||||
struct tipc_link_config {
|
||||
__u32 value;
|
||||
char name[TIPC_MAX_LINK_NAME];
|
||||
};
|
||||
|
||||
#define TIPC_NTQ_ALLTYPES 0x80000000
|
||||
|
||||
struct tipc_name_table_query {
|
||||
__u32 depth; /* 1:type, 2:+name info, 3:+port info, 4+:+debug info */
|
||||
__u32 type; /* {t,l,u} info ignored if high bit of "depth" is set */
|
||||
__u32 lowbound; /* (i.e. displays all entries of name table) */
|
||||
__u32 upbound;
|
||||
};
|
||||
|
||||
/*
|
||||
* The error string TLV is a null-terminated string describing the cause
|
||||
* of the request failure. To simplify error processing (and to save space)
|
||||
* the first character of the string can be a special error code character
|
||||
* (lying by the range 0x80 to 0xFF) which represents a pre-defined reason.
|
||||
*/
|
||||
|
||||
#define TIPC_CFG_TLV_ERROR "\x80" /* request contains incorrect TLV(s) */
|
||||
#define TIPC_CFG_NOT_NET_ADMIN "\x81" /* must be network administrator */
|
||||
#define TIPC_CFG_NOT_ZONE_MSTR "\x82" /* must be zone master */
|
||||
#define TIPC_CFG_NO_REMOTE "\x83" /* remote management not enabled */
|
||||
#define TIPC_CFG_NOT_SUPPORTED "\x84" /* request is not supported by TIPC */
|
||||
#define TIPC_CFG_INVALID_VALUE "\x85" /* request has invalid argument value */
|
||||
|
||||
#if 0
|
||||
/* prototypes TLV structures for proposed commands */
|
||||
struct tipc_link_create {
|
||||
__u32 domain;
|
||||
struct tipc_media_addr peer_addr;
|
||||
char bearer_name[MAX_BEARER_NAME];
|
||||
};
|
||||
|
||||
struct tipc_route_info {
|
||||
__u32 dest;
|
||||
__u32 router;
|
||||
};
|
||||
#endif
|
||||
|
||||
/*
|
||||
* A TLV consists of a descriptor, followed by the TLV value.
|
||||
* TLV descriptor fields are stored in network byte order;
|
||||
* TLV values must also be stored in network byte order (where applicable).
|
||||
* TLV descriptors must be aligned to addresses which are multiple of 4,
|
||||
* so up to 3 bytes of padding may exist at the end of the TLV value area.
|
||||
* There must not be any padding between the TLV descriptor and its value.
|
||||
*/
|
||||
|
||||
struct tlv_desc {
|
||||
__u16 tlv_len; /* TLV length (descriptor + value) */
|
||||
__u16 tlv_type; /* TLV identifier */
|
||||
};
|
||||
|
||||
#define TLV_ALIGNTO 4
|
||||
|
||||
#define TLV_ALIGN(datalen) (((datalen)+(TLV_ALIGNTO-1)) & ~(TLV_ALIGNTO-1))
|
||||
#define TLV_LENGTH(datalen) (sizeof(struct tlv_desc) + (datalen))
|
||||
#define TLV_SPACE(datalen) (TLV_ALIGN(TLV_LENGTH(datalen)))
|
||||
#define TLV_DATA(tlv) ((void *)((char *)(tlv) + TLV_LENGTH(0)))
|
||||
|
||||
static inline int TLV_OK(const void *tlv, __u16 space)
|
||||
{
|
||||
/*
|
||||
* Would also like to check that "tlv" is a multiple of 4,
|
||||
* but don't know how to do this in a portable way.
|
||||
* - Tried doing (!(tlv & (TLV_ALIGNTO-1))), but GCC compiler
|
||||
* won't allow binary "&" with a pointer.
|
||||
* - Tried casting "tlv" to integer type, but causes warning about size
|
||||
* mismatch when pointer is bigger than chosen type (int, long, ...).
|
||||
*/
|
||||
|
||||
return (space >= TLV_SPACE(0)) &&
|
||||
(ntohs(((struct tlv_desc *)tlv)->tlv_len) <= space);
|
||||
}
|
||||
|
||||
static inline int TLV_CHECK(const void *tlv, __u16 space, __u16 exp_type)
|
||||
{
|
||||
return TLV_OK(tlv, space) &&
|
||||
(ntohs(((struct tlv_desc *)tlv)->tlv_type) == exp_type);
|
||||
}
|
||||
|
||||
static inline int TLV_SET(void *tlv, __u16 type, void *data, __u16 len)
|
||||
{
|
||||
struct tlv_desc *tlv_ptr;
|
||||
int tlv_len;
|
||||
|
||||
tlv_len = TLV_LENGTH(len);
|
||||
tlv_ptr = (struct tlv_desc *)tlv;
|
||||
tlv_ptr->tlv_type = htons(type);
|
||||
tlv_ptr->tlv_len = htons(tlv_len);
|
||||
if (len && data)
|
||||
memcpy(TLV_DATA(tlv_ptr), data, tlv_len);
|
||||
return TLV_SPACE(len);
|
||||
}
|
||||
|
||||
/*
|
||||
* A TLV list descriptor simplifies processing of messages
|
||||
* containing multiple TLVs.
|
||||
*/
|
||||
|
||||
struct tlv_list_desc {
|
||||
struct tlv_desc *tlv_ptr; /* ptr to current TLV */
|
||||
__u32 tlv_space; /* # bytes from curr TLV to list end */
|
||||
};
|
||||
|
||||
static inline void TLV_LIST_INIT(struct tlv_list_desc *list,
|
||||
void *data, __u32 space)
|
||||
{
|
||||
list->tlv_ptr = (struct tlv_desc *)data;
|
||||
list->tlv_space = space;
|
||||
}
|
||||
|
||||
static inline int TLV_LIST_EMPTY(struct tlv_list_desc *list)
|
||||
{
|
||||
return (list->tlv_space == 0);
|
||||
}
|
||||
|
||||
static inline int TLV_LIST_CHECK(struct tlv_list_desc *list, __u16 exp_type)
|
||||
{
|
||||
return TLV_CHECK(list->tlv_ptr, list->tlv_space, exp_type);
|
||||
}
|
||||
|
||||
static inline void *TLV_LIST_DATA(struct tlv_list_desc *list)
|
||||
{
|
||||
return TLV_DATA(list->tlv_ptr);
|
||||
}
|
||||
|
||||
static inline void TLV_LIST_STEP(struct tlv_list_desc *list)
|
||||
{
|
||||
__u16 tlv_space = TLV_ALIGN(ntohs(list->tlv_ptr->tlv_len));
|
||||
|
||||
list->tlv_ptr = (struct tlv_desc *)((char *)list->tlv_ptr + tlv_space);
|
||||
list->tlv_space -= tlv_space;
|
||||
}
|
||||
|
||||
/*
|
||||
* Configuration messages exchanged via NETLINK_GENERIC use the following
|
||||
* family id, name, version and command.
|
||||
*/
|
||||
#define TIPC_GENL_FAMILY 0x222
|
||||
#define TIPC_GENL_NAME "TIPC"
|
||||
#define TIPC_GENL_VERSION 0x1
|
||||
#define TIPC_GENL_CMD 0x1
|
||||
|
||||
/*
|
||||
* TIPC specific header used in NETLINK_GENERIC requests.
|
||||
*/
|
||||
struct tipc_genlmsghdr {
|
||||
__u32 dest; /* Destination address */
|
||||
__u16 cmd; /* Command */
|
||||
__u16 reserved; /* Unused */
|
||||
};
|
||||
|
||||
#define TIPC_GENL_HDRLEN NLMSG_ALIGN(sizeof(struct tipc_genlmsghdr))
|
||||
|
||||
/*
|
||||
* Configuration messages exchanged via TIPC sockets use the TIPC configuration
|
||||
* message header, which is defined below. This structure is analogous
|
||||
* to the Netlink message header, but fields are stored in network byte order
|
||||
* and no padding is permitted between the header and the message data
|
||||
* that follows.
|
||||
*/
|
||||
|
||||
struct tipc_cfg_msg_hdr
|
||||
{
|
||||
__u32 tcm_len; /* Message length (including header) */
|
||||
__u16 tcm_type; /* Command type */
|
||||
__u16 tcm_flags; /* Additional flags */
|
||||
char tcm_reserved[8]; /* Unused */
|
||||
};
|
||||
|
||||
#define TCM_F_REQUEST 0x1 /* Flag: Request message */
|
||||
#define TCM_F_MORE 0x2 /* Flag: Message to be continued */
|
||||
|
||||
#define TCM_ALIGN(datalen) (((datalen)+3) & ~3)
|
||||
#define TCM_LENGTH(datalen) (sizeof(struct tipc_cfg_msg_hdr) + datalen)
|
||||
#define TCM_SPACE(datalen) (TCM_ALIGN(TCM_LENGTH(datalen)))
|
||||
#define TCM_DATA(tcm_hdr) ((void *)((char *)(tcm_hdr) + TCM_LENGTH(0)))
|
||||
|
||||
static inline int TCM_SET(void *msg, __u16 cmd, __u16 flags,
|
||||
void *data, __u16 data_len)
|
||||
{
|
||||
struct tipc_cfg_msg_hdr *tcm_hdr;
|
||||
int msg_len;
|
||||
|
||||
msg_len = TCM_LENGTH(data_len);
|
||||
tcm_hdr = (struct tipc_cfg_msg_hdr *)msg;
|
||||
tcm_hdr->tcm_len = htonl(msg_len);
|
||||
tcm_hdr->tcm_type = htons(cmd);
|
||||
tcm_hdr->tcm_flags = htons(flags);
|
||||
if (data_len && data)
|
||||
memcpy(TCM_DATA(msg), data, data_len);
|
||||
return TCM_SPACE(data_len);
|
||||
}
|
||||
|
||||
#endif
|
||||
255
include/net/tipc/tipc.h
Normal file
255
include/net/tipc/tipc.h
Normal file
|
|
@ -0,0 +1,255 @@
|
|||
/*
|
||||
* include/net/tipc/tipc.h: Main include file for TIPC users
|
||||
*
|
||||
* Copyright (c) 2003-2005, Ericsson Research Canada
|
||||
* Copyright (c) 2005, Wind River Systems
|
||||
* Copyright (c) 2005-2006, Ericsson AB
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
* list of conditions and the following disclaimer.
|
||||
* 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.
|
||||
* 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.
|
||||
*
|
||||
* 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_H_
|
||||
#define _NET_TIPC_H_
|
||||
|
||||
#ifdef __KERNEL__
|
||||
|
||||
#include <linux/tipc.h>
|
||||
#include <linux/skbuff.h>
|
||||
|
||||
/*
|
||||
* Native API
|
||||
* ----------
|
||||
*/
|
||||
|
||||
/*
|
||||
* TIPC operating mode routines
|
||||
*/
|
||||
|
||||
u32 tipc_get_addr(void);
|
||||
|
||||
#define TIPC_NOT_RUNNING 0
|
||||
#define TIPC_NODE_MODE 1
|
||||
#define TIPC_NET_MODE 2
|
||||
|
||||
typedef void (*tipc_mode_event)(void *usr_handle, int mode, u32 addr);
|
||||
|
||||
int tipc_attach(unsigned int *userref, tipc_mode_event, void *usr_handle);
|
||||
|
||||
void tipc_detach(unsigned int userref);
|
||||
|
||||
int tipc_get_mode(void);
|
||||
|
||||
/*
|
||||
* TIPC port manipulation routines
|
||||
*/
|
||||
|
||||
typedef void (*tipc_msg_err_event) (void *usr_handle,
|
||||
u32 portref,
|
||||
struct sk_buff **buf,
|
||||
unsigned char const *data,
|
||||
unsigned int size,
|
||||
int reason,
|
||||
struct tipc_portid const *attmpt_destid);
|
||||
|
||||
typedef void (*tipc_named_msg_err_event) (void *usr_handle,
|
||||
u32 portref,
|
||||
struct sk_buff **buf,
|
||||
unsigned char const *data,
|
||||
unsigned int size,
|
||||
int reason,
|
||||
struct tipc_name_seq const *attmpt_dest);
|
||||
|
||||
typedef void (*tipc_conn_shutdown_event) (void *usr_handle,
|
||||
u32 portref,
|
||||
struct sk_buff **buf,
|
||||
unsigned char const *data,
|
||||
unsigned int size,
|
||||
int reason);
|
||||
|
||||
typedef void (*tipc_msg_event) (void *usr_handle,
|
||||
u32 portref,
|
||||
struct sk_buff **buf,
|
||||
unsigned char const *data,
|
||||
unsigned int size,
|
||||
unsigned int importance,
|
||||
struct tipc_portid const *origin);
|
||||
|
||||
typedef void (*tipc_named_msg_event) (void *usr_handle,
|
||||
u32 portref,
|
||||
struct sk_buff **buf,
|
||||
unsigned char const *data,
|
||||
unsigned int size,
|
||||
unsigned int importance,
|
||||
struct tipc_portid const *orig,
|
||||
struct tipc_name_seq const *dest);
|
||||
|
||||
typedef void (*tipc_conn_msg_event) (void *usr_handle,
|
||||
u32 portref,
|
||||
struct sk_buff **buf,
|
||||
unsigned char const *data,
|
||||
unsigned int size);
|
||||
|
||||
typedef void (*tipc_continue_event) (void *usr_handle,
|
||||
u32 portref);
|
||||
|
||||
int tipc_createport(unsigned int tipc_user,
|
||||
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 message_cb,
|
||||
tipc_named_msg_event named_message_cb,
|
||||
tipc_conn_msg_event conn_message_cb,
|
||||
tipc_continue_event continue_event_cb,/* May be zero */
|
||||
u32 *portref);
|
||||
|
||||
int tipc_deleteport(u32 portref);
|
||||
|
||||
int tipc_ownidentity(u32 portref, struct tipc_portid *port);
|
||||
|
||||
int tipc_portimportance(u32 portref, unsigned int *importance);
|
||||
int tipc_set_portimportance(u32 portref, unsigned int importance);
|
||||
|
||||
int tipc_portunreliable(u32 portref, unsigned int *isunreliable);
|
||||
int tipc_set_portunreliable(u32 portref, unsigned int isunreliable);
|
||||
|
||||
int tipc_portunreturnable(u32 portref, unsigned int *isunreturnable);
|
||||
int tipc_set_portunreturnable(u32 portref, unsigned int isunreturnable);
|
||||
|
||||
int tipc_publish(u32 portref, unsigned int scope,
|
||||
struct tipc_name_seq const *name_seq);
|
||||
int tipc_withdraw(u32 portref, unsigned int scope,
|
||||
struct tipc_name_seq const *name_seq); /* 0: all */
|
||||
|
||||
int tipc_connect2port(u32 portref, struct tipc_portid const *port);
|
||||
|
||||
int tipc_disconnect(u32 portref);
|
||||
|
||||
int tipc_shutdown(u32 ref); /* Sends SHUTDOWN msg */
|
||||
|
||||
int tipc_isconnected(u32 portref, int *isconnected);
|
||||
|
||||
int tipc_peer(u32 portref, struct tipc_portid *peer);
|
||||
|
||||
int tipc_ref_valid(u32 portref);
|
||||
|
||||
/*
|
||||
* TIPC messaging routines
|
||||
*/
|
||||
|
||||
#define TIPC_PORT_IMPORTANCE 100 /* send using current port setting */
|
||||
|
||||
|
||||
int tipc_send(u32 portref,
|
||||
unsigned int num_sect,
|
||||
struct iovec const *msg_sect);
|
||||
|
||||
int tipc_send_buf(u32 portref,
|
||||
struct sk_buff *buf,
|
||||
unsigned int dsz);
|
||||
|
||||
int tipc_send2name(u32 portref,
|
||||
struct tipc_name const *name,
|
||||
u32 domain, /* 0:own zone */
|
||||
unsigned int num_sect,
|
||||
struct iovec const *msg_sect);
|
||||
|
||||
int tipc_send_buf2name(u32 portref,
|
||||
struct tipc_name const *name,
|
||||
u32 domain,
|
||||
struct sk_buff *buf,
|
||||
unsigned int dsz);
|
||||
|
||||
int tipc_forward2name(u32 portref,
|
||||
struct tipc_name const *name,
|
||||
u32 domain, /*0: own zone */
|
||||
unsigned int section_count,
|
||||
struct iovec const *msg_sect,
|
||||
struct tipc_portid const *origin,
|
||||
unsigned int importance);
|
||||
|
||||
int tipc_forward_buf2name(u32 portref,
|
||||
struct tipc_name const *name,
|
||||
u32 domain,
|
||||
struct sk_buff *buf,
|
||||
unsigned int dsz,
|
||||
struct tipc_portid const *orig,
|
||||
unsigned int importance);
|
||||
|
||||
int tipc_send2port(u32 portref,
|
||||
struct tipc_portid const *dest,
|
||||
unsigned int num_sect,
|
||||
struct iovec const *msg_sect);
|
||||
|
||||
int tipc_send_buf2port(u32 portref,
|
||||
struct tipc_portid const *dest,
|
||||
struct sk_buff *buf,
|
||||
unsigned int dsz);
|
||||
|
||||
int tipc_forward2port(u32 portref,
|
||||
struct tipc_portid const *dest,
|
||||
unsigned int num_sect,
|
||||
struct iovec const *msg_sect,
|
||||
struct tipc_portid const *origin,
|
||||
unsigned int importance);
|
||||
|
||||
int tipc_forward_buf2port(u32 portref,
|
||||
struct tipc_portid const *dest,
|
||||
struct sk_buff *buf,
|
||||
unsigned int dsz,
|
||||
struct tipc_portid const *orig,
|
||||
unsigned int importance);
|
||||
|
||||
int tipc_multicast(u32 portref,
|
||||
struct tipc_name_seq const *seq,
|
||||
u32 domain, /* 0:own zone */
|
||||
unsigned int section_count,
|
||||
struct iovec const *msg);
|
||||
|
||||
#if 0
|
||||
int tipc_multicast_buf(u32 portref,
|
||||
struct tipc_name_seq const *seq,
|
||||
u32 domain, /* 0:own zone */
|
||||
void *buf,
|
||||
unsigned int size);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* TIPC subscription routines
|
||||
*/
|
||||
|
||||
int tipc_ispublished(struct tipc_name const *name);
|
||||
|
||||
/*
|
||||
* Get number of available nodes within specified domain (excluding own node)
|
||||
*/
|
||||
|
||||
unsigned int tipc_available_nodes(const u32 domain);
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
92
include/net/tipc/tipc_bearer.h
Normal file
92
include/net/tipc/tipc_bearer.h
Normal file
|
|
@ -0,0 +1,92 @@
|
|||
/*
|
||||
* include/net/tipc/tipc_bearer.h: Include file for privileged access to TIPC bearers
|
||||
*
|
||||
* Copyright (c) 2003-2005, Ericsson Research Canada
|
||||
* Copyright (c) 2005, Wind River Systems
|
||||
* Copyright (c) 2005-2006, Ericsson AB
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
* list of conditions and the following disclaimer.
|
||||
* 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.
|
||||
* 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.
|
||||
*
|
||||
* 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_BEARER_H_
|
||||
#define _NET_TIPC_BEARER_H_
|
||||
|
||||
#ifdef __KERNEL__
|
||||
|
||||
#include <linux/tipc.h>
|
||||
#include <linux/skbuff.h>
|
||||
#include <linux/spinlock.h>
|
||||
|
||||
/**
|
||||
* struct tipc_bearer - TIPC bearer info available to privileged users
|
||||
* @usr_handle: pointer to additional user-defined information about bearer
|
||||
* @mtu: max packet size bearer can support
|
||||
* @blocked: non-zero if bearer is blocked
|
||||
* @lock: spinlock for controlling access to bearer
|
||||
* @addr: media-specific address associated with bearer
|
||||
* @name: bearer name (format = media:interface)
|
||||
*
|
||||
* Note: TIPC initializes "name" and "lock" fields; user is responsible for
|
||||
* initialization all other fields when a bearer is enabled.
|
||||
*/
|
||||
|
||||
struct tipc_bearer {
|
||||
void *usr_handle;
|
||||
u32 mtu;
|
||||
int blocked;
|
||||
spinlock_t lock;
|
||||
struct tipc_media_addr addr;
|
||||
char name[TIPC_MAX_BEARER_NAME];
|
||||
};
|
||||
|
||||
|
||||
int tipc_register_media(u32 media_type,
|
||||
char *media_name,
|
||||
int (*enable)(struct tipc_bearer *),
|
||||
void (*disable)(struct tipc_bearer *),
|
||||
int (*send_msg)(struct sk_buff *,
|
||||
struct tipc_bearer *,
|
||||
struct tipc_media_addr *),
|
||||
char *(*addr2str)(struct tipc_media_addr *a,
|
||||
char *str_buf,
|
||||
int str_size),
|
||||
struct tipc_media_addr *bcast_addr,
|
||||
const u32 bearer_priority,
|
||||
const u32 link_tolerance, /* [ms] */
|
||||
const u32 send_window_limit);
|
||||
|
||||
void tipc_recv_msg(struct sk_buff *buf, struct tipc_bearer *tb_ptr);
|
||||
|
||||
int tipc_block_bearer(const char *name);
|
||||
void tipc_continue(struct tipc_bearer *tb_ptr);
|
||||
|
||||
int tipc_enable_bearer(const char *bearer_name, u32 bcast_scope, u32 priority);
|
||||
int tipc_disable_bearer(const char *name);
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
220
include/net/tipc/tipc_msg.h
Normal file
220
include/net/tipc/tipc_msg.h
Normal file
|
|
@ -0,0 +1,220 @@
|
|||
/*
|
||||
* include/net/tipc/tipc_msg.h: Include file for privileged access to TIPC message headers
|
||||
*
|
||||
* Copyright (c) 2003-2005, Ericsson Research Canada
|
||||
* Copyright (c) 2005, Wind River Systems
|
||||
* Copyright (c) 2005-2006, Ericsson AB
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
* list of conditions and the following disclaimer.
|
||||
* 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.
|
||||
* 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.
|
||||
*
|
||||
* 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_MSG_H_
|
||||
#define _NET_TIPC_MSG_H_
|
||||
|
||||
#ifdef __KERNEL__
|
||||
|
||||
struct tipc_msg {
|
||||
u32 hdr[15];
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
TIPC user data message header format, version 2:
|
||||
|
||||
|
||||
1 0 9 8 7 6 5 4|3 2 1 0 9 8 7 6|5 4 3 2 1 0 9 8|7 6 5 4 3 2 1 0
|
||||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
w0:|vers | user |hdr sz |n|d|s|-| message size |
|
||||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
w1:|mstyp| error |rer cnt|lsc|opt p| broadcast ack no |
|
||||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
w2:| link level ack no | broadcast/link level seq no |
|
||||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
w3:| previous node |
|
||||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
w4:| originating port |
|
||||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
w5:| destination port |
|
||||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
w6:| originating node |
|
||||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
w7:| destination node |
|
||||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
w8:| name type / transport sequence number |
|
||||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
w9:| name instance/multicast lower bound |
|
||||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
wA:| multicast upper bound |
|
||||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
/ /
|
||||
\ options \
|
||||
/ /
|
||||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
|
||||
*/
|
||||
|
||||
#define TIPC_CONN_MSG 0
|
||||
#define TIPC_MCAST_MSG 1
|
||||
#define TIPC_NAMED_MSG 2
|
||||
#define TIPC_DIRECT_MSG 3
|
||||
|
||||
|
||||
static inline u32 msg_word(struct tipc_msg *m, u32 pos)
|
||||
{
|
||||
return ntohl(m->hdr[pos]);
|
||||
}
|
||||
|
||||
static inline u32 msg_bits(struct tipc_msg *m, u32 w, u32 pos, u32 mask)
|
||||
{
|
||||
return (msg_word(m, w) >> pos) & mask;
|
||||
}
|
||||
|
||||
static inline u32 msg_importance(struct tipc_msg *m)
|
||||
{
|
||||
return msg_bits(m, 0, 25, 0xf);
|
||||
}
|
||||
|
||||
static inline u32 msg_hdr_sz(struct tipc_msg *m)
|
||||
{
|
||||
return msg_bits(m, 0, 21, 0xf) << 2;
|
||||
}
|
||||
|
||||
static inline int msg_short(struct tipc_msg *m)
|
||||
{
|
||||
return (msg_hdr_sz(m) == 24);
|
||||
}
|
||||
|
||||
static inline u32 msg_size(struct tipc_msg *m)
|
||||
{
|
||||
return msg_bits(m, 0, 0, 0x1ffff);
|
||||
}
|
||||
|
||||
static inline u32 msg_data_sz(struct tipc_msg *m)
|
||||
{
|
||||
return (msg_size(m) - msg_hdr_sz(m));
|
||||
}
|
||||
|
||||
static inline unchar *msg_data(struct tipc_msg *m)
|
||||
{
|
||||
return ((unchar *)m) + msg_hdr_sz(m);
|
||||
}
|
||||
|
||||
static inline u32 msg_type(struct tipc_msg *m)
|
||||
{
|
||||
return msg_bits(m, 1, 29, 0x7);
|
||||
}
|
||||
|
||||
static inline u32 msg_direct(struct tipc_msg *m)
|
||||
{
|
||||
return (msg_type(m) == TIPC_DIRECT_MSG);
|
||||
}
|
||||
|
||||
static inline u32 msg_named(struct tipc_msg *m)
|
||||
{
|
||||
return (msg_type(m) == TIPC_NAMED_MSG);
|
||||
}
|
||||
|
||||
static inline u32 msg_mcast(struct tipc_msg *m)
|
||||
{
|
||||
return (msg_type(m) == TIPC_MCAST_MSG);
|
||||
}
|
||||
|
||||
static inline u32 msg_connected(struct tipc_msg *m)
|
||||
{
|
||||
return (msg_type(m) == TIPC_CONN_MSG);
|
||||
}
|
||||
|
||||
static inline u32 msg_errcode(struct tipc_msg *m)
|
||||
{
|
||||
return msg_bits(m, 1, 25, 0xf);
|
||||
}
|
||||
|
||||
static inline u32 msg_prevnode(struct tipc_msg *m)
|
||||
{
|
||||
return msg_word(m, 3);
|
||||
}
|
||||
|
||||
static inline u32 msg_origport(struct tipc_msg *m)
|
||||
{
|
||||
return msg_word(m, 4);
|
||||
}
|
||||
|
||||
static inline u32 msg_destport(struct tipc_msg *m)
|
||||
{
|
||||
return msg_word(m, 5);
|
||||
}
|
||||
|
||||
static inline u32 msg_mc_netid(struct tipc_msg *m)
|
||||
{
|
||||
return msg_word(m, 5);
|
||||
}
|
||||
|
||||
static inline u32 msg_orignode(struct tipc_msg *m)
|
||||
{
|
||||
if (likely(msg_short(m)))
|
||||
return msg_prevnode(m);
|
||||
return msg_word(m, 6);
|
||||
}
|
||||
|
||||
static inline u32 msg_destnode(struct tipc_msg *m)
|
||||
{
|
||||
return msg_word(m, 7);
|
||||
}
|
||||
|
||||
static inline u32 msg_nametype(struct tipc_msg *m)
|
||||
{
|
||||
return msg_word(m, 8);
|
||||
}
|
||||
|
||||
static inline u32 msg_nameinst(struct tipc_msg *m)
|
||||
{
|
||||
return msg_word(m, 9);
|
||||
}
|
||||
|
||||
static inline u32 msg_namelower(struct tipc_msg *m)
|
||||
{
|
||||
return msg_nameinst(m);
|
||||
}
|
||||
|
||||
static inline u32 msg_nameupper(struct tipc_msg *m)
|
||||
{
|
||||
return msg_word(m, 10);
|
||||
}
|
||||
|
||||
static inline char *msg_options(struct tipc_msg *m, u32 *len)
|
||||
{
|
||||
u32 pos = msg_bits(m, 1, 16, 0x7);
|
||||
|
||||
if (!pos)
|
||||
return 0;
|
||||
pos = (pos * 4) + 28;
|
||||
*len = msg_hdr_sz(m) - pos;
|
||||
return (char *)&m->hdr[pos/4];
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
105
include/net/tipc/tipc_port.h
Normal file
105
include/net/tipc/tipc_port.h
Normal file
|
|
@ -0,0 +1,105 @@
|
|||
/*
|
||||
* include/net/tipc/tipc_port.h: Include file for privileged access to TIPC ports
|
||||
*
|
||||
* Copyright (c) 2003-2005, Ericsson Research Canada
|
||||
* Copyright (c) 2005, Wind River Systems
|
||||
* Copyright (c) 2005-2006, Ericsson AB
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
* list of conditions and the following disclaimer.
|
||||
* 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.
|
||||
* 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.
|
||||
*
|
||||
* 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
|
||||
* @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 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);
|
||||
|
||||
/*
|
||||
* tipc_set_msg_option(): port must be locked.
|
||||
*/
|
||||
int tipc_set_msg_option(struct tipc_port *tp_ptr,
|
||||
const char *opt,
|
||||
const u32 len);
|
||||
|
||||
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);
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -159,6 +159,7 @@ source "net/ipx/Kconfig"
|
|||
source "drivers/net/appletalk/Kconfig"
|
||||
source "net/x25/Kconfig"
|
||||
source "net/lapb/Kconfig"
|
||||
source "net/tipc/Kconfig"
|
||||
|
||||
config NET_DIVERT
|
||||
bool "Frame Diverter (EXPERIMENTAL)"
|
||||
|
|
|
|||
|
|
@ -45,6 +45,7 @@ obj-$(CONFIG_VLAN_8021Q) += 8021q/
|
|||
obj-$(CONFIG_IP_DCCP) += dccp/
|
||||
obj-$(CONFIG_IP_SCTP) += sctp/
|
||||
obj-$(CONFIG_IEEE80211) += ieee80211/
|
||||
obj-$(CONFIG_TIPC) += tipc/
|
||||
|
||||
ifeq ($(CONFIG_NET),y)
|
||||
obj-$(CONFIG_SYSCTL) += sysctl_net.o
|
||||
|
|
|
|||
112
net/tipc/Kconfig
Normal file
112
net/tipc/Kconfig
Normal file
|
|
@ -0,0 +1,112 @@
|
|||
#
|
||||
# TIPC configuration
|
||||
#
|
||||
|
||||
menu "TIPC Configuration (EXPERIMENTAL)"
|
||||
depends on INET && EXPERIMENTAL
|
||||
|
||||
config TIPC
|
||||
tristate "The TIPC Protocol (EXPERIMENTAL)"
|
||||
---help---
|
||||
TBD.
|
||||
|
||||
This protocol support is also available as a module ( = code which
|
||||
can be inserted in and removed from the running kernel whenever you
|
||||
want). The module will be called tipc. If you want to compile it
|
||||
as a module, say M here and read <file:Documentation/modules.txt>.
|
||||
|
||||
If in doubt, say N.
|
||||
|
||||
config TIPC_ADVANCED
|
||||
bool "TIPC: Advanced configuration"
|
||||
depends on TIPC
|
||||
default n
|
||||
help
|
||||
Saying Y here will open some advanced configuration
|
||||
for TIPC. Most users do not need to bother, so if
|
||||
unsure, just say N.
|
||||
|
||||
config TIPC_ZONES
|
||||
int "Maximum number of zones in network"
|
||||
depends on TIPC && TIPC_ADVANCED
|
||||
default "3"
|
||||
help
|
||||
Max number of zones inside TIPC network. Max supported value
|
||||
is 255 zones, minimum is 1
|
||||
|
||||
Default is 3 zones in a network; setting this to higher
|
||||
allows more zones but might use more memory.
|
||||
|
||||
config TIPC_CLUSTERS
|
||||
int "Maximum number of clusters in a zone"
|
||||
depends on TIPC && TIPC_ADVANCED
|
||||
default "1"
|
||||
help
|
||||
***Only 1 (one cluster in a zone) is supported by current code.
|
||||
Any value set here will be overridden.***
|
||||
|
||||
(Max number of clusters inside TIPC zone. Max supported
|
||||
value is 4095 clusters, minimum is 1.
|
||||
|
||||
Default is 1; setting this to smaller value might save
|
||||
some memory, setting it to higher
|
||||
allows more clusters and might consume more memory.)
|
||||
|
||||
config TIPC_NODES
|
||||
int "Maximum number of nodes in cluster"
|
||||
depends on TIPC && TIPC_ADVANCED
|
||||
default "255"
|
||||
help
|
||||
Maximum number of nodes inside a TIPC cluster. Maximum
|
||||
supported value is 2047 nodes, minimum is 8.
|
||||
|
||||
Setting this to a smaller value saves some memory,
|
||||
setting it to higher allows more nodes.
|
||||
|
||||
config TIPC_SLAVE_NODES
|
||||
int "Maximum number of slave nodes in cluster"
|
||||
depends on TIPC && TIPC_ADVANCED
|
||||
default "0"
|
||||
help
|
||||
***This capability is not supported by current code.***
|
||||
|
||||
Maximum number of slave nodes inside a TIPC cluster. Maximum
|
||||
supported value is 2047 nodes, minimum is 0.
|
||||
|
||||
Setting this to a smaller value saves some memory,
|
||||
setting it to higher allows more nodes.
|
||||
|
||||
config TIPC_PORTS
|
||||
int "Maximum number of ports in a node"
|
||||
depends on TIPC && TIPC_ADVANCED
|
||||
default "8191"
|
||||
help
|
||||
Maximum number of ports within a node. Maximum
|
||||
supported value is 64535 nodes, minimum is 127.
|
||||
|
||||
Setting this to a smaller value saves some memory,
|
||||
setting it to higher allows more ports.
|
||||
|
||||
config TIPC_LOG
|
||||
int "Size of log buffer"
|
||||
depends on TIPC && TIPC_ADVANCED
|
||||
default 0
|
||||
help
|
||||
Size (in bytes) of TIPC's internal log buffer, which records the
|
||||
occurrence of significant events. Maximum supported value
|
||||
is 32768 bytes, minimum is 0.
|
||||
|
||||
There is no need to enable the log buffer unless the node will be
|
||||
managed remotely via TIPC.
|
||||
|
||||
config TIPC_DEBUG
|
||||
bool "Enable debugging support"
|
||||
depends on TIPC
|
||||
default n
|
||||
help
|
||||
This will enable debugging of TIPC.
|
||||
|
||||
Only say Y here if you are having trouble with TIPC. It will
|
||||
enable the display of detailed information about what is going on.
|
||||
|
||||
endmenu
|
||||
13
net/tipc/Makefile
Normal file
13
net/tipc/Makefile
Normal file
|
|
@ -0,0 +1,13 @@
|
|||
#
|
||||
# Makefile for the Linux TIPC layer
|
||||
#
|
||||
|
||||
obj-$(CONFIG_TIPC) := tipc.o
|
||||
|
||||
tipc-y += addr.o bcast.o bearer.o config.o cluster.o \
|
||||
core.o handler.o link.o discover.o msg.o \
|
||||
name_distr.o subscr.o name_table.o net.o \
|
||||
netlink.o node.o node_subscr.o port.o ref.o \
|
||||
socket.o user_reg.o zone.o dbg.o eth_media.o
|
||||
|
||||
# End of file
|
||||
91
net/tipc/addr.c
Normal file
91
net/tipc/addr.c
Normal file
|
|
@ -0,0 +1,91 @@
|
|||
/*
|
||||
* net/tipc/addr.c: TIPC address utility routines
|
||||
*
|
||||
* Copyright (c) 2003-2005, Ericsson Research Canada
|
||||
* Copyright (c) 2004-2005, Wind River Systems
|
||||
* Copyright (c) 2005-2006, Ericsson AB
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
* list of conditions and the following disclaimer.
|
||||
* 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.
|
||||
* 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.
|
||||
*
|
||||
* 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 "dbg.h"
|
||||
#include "addr.h"
|
||||
#include "zone.h"
|
||||
#include "cluster.h"
|
||||
#include "net.h"
|
||||
|
||||
u32 tipc_get_addr(void)
|
||||
{
|
||||
return tipc_own_addr;
|
||||
}
|
||||
|
||||
/**
|
||||
* addr_domain_valid - validates a network domain address
|
||||
*
|
||||
* Accepts <Z.C.N>, <Z.C.0>, <Z.0.0>, and <0.0.0>,
|
||||
* where Z, C, and N are non-zero and do not exceed the configured limits.
|
||||
*
|
||||
* Returns 1 if domain address is valid, otherwise 0
|
||||
*/
|
||||
|
||||
int addr_domain_valid(u32 addr)
|
||||
{
|
||||
u32 n = tipc_node(addr);
|
||||
u32 c = tipc_cluster(addr);
|
||||
u32 z = tipc_zone(addr);
|
||||
u32 max_nodes = tipc_max_nodes;
|
||||
|
||||
if (is_slave(addr))
|
||||
max_nodes = LOWEST_SLAVE + tipc_max_slaves;
|
||||
if (n > max_nodes)
|
||||
return 0;
|
||||
if (c > tipc_max_clusters)
|
||||
return 0;
|
||||
if (z > tipc_max_zones)
|
||||
return 0;
|
||||
|
||||
if (n && (!z || !c))
|
||||
return 0;
|
||||
if (c && !z)
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* addr_node_valid - validates a proposed network address for this node
|
||||
*
|
||||
* Accepts <Z.C.N>, where Z, C, and N are non-zero and do not exceed
|
||||
* the configured limits.
|
||||
*
|
||||
* Returns 1 if address can be used, otherwise 0
|
||||
*/
|
||||
|
||||
int addr_node_valid(u32 addr)
|
||||
{
|
||||
return (addr_domain_valid(addr) && tipc_node(addr));
|
||||
}
|
||||
|
||||
125
net/tipc/addr.h
Normal file
125
net/tipc/addr.h
Normal file
|
|
@ -0,0 +1,125 @@
|
|||
/*
|
||||
* net/tipc/addr.h: Include file for TIPC address utility routines
|
||||
*
|
||||
* Copyright (c) 2003-2005, Ericsson Research Canada
|
||||
* Copyright (c) 2004-2005, Wind River Systems
|
||||
* Copyright (c) 2005-2006, Ericsson AB
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
* list of conditions and the following disclaimer.
|
||||
* 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.
|
||||
* 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.
|
||||
*
|
||||
* 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 _TIPC_ADDR_H
|
||||
#define _TIPC_ADDR_H
|
||||
|
||||
static inline u32 own_node(void)
|
||||
{
|
||||
return tipc_node(tipc_own_addr);
|
||||
}
|
||||
|
||||
static inline u32 own_cluster(void)
|
||||
{
|
||||
return tipc_cluster(tipc_own_addr);
|
||||
}
|
||||
|
||||
static inline u32 own_zone(void)
|
||||
{
|
||||
return tipc_zone(tipc_own_addr);
|
||||
}
|
||||
|
||||
static inline int in_own_cluster(u32 addr)
|
||||
{
|
||||
return !((addr ^ tipc_own_addr) >> 12);
|
||||
}
|
||||
|
||||
static inline int in_own_zone(u32 addr)
|
||||
{
|
||||
return !((addr ^ tipc_own_addr) >> 24);
|
||||
}
|
||||
|
||||
static inline int is_slave(u32 addr)
|
||||
{
|
||||
return addr & 0x800;
|
||||
}
|
||||
|
||||
static inline int may_route(u32 addr)
|
||||
{
|
||||
return(addr ^ tipc_own_addr) >> 11;
|
||||
}
|
||||
|
||||
static inline int in_scope(u32 domain, u32 addr)
|
||||
{
|
||||
if (!domain || (domain == addr))
|
||||
return 1;
|
||||
if (domain == (addr & 0xfffff000u)) /* domain <Z.C.0> */
|
||||
return 1;
|
||||
if (domain == (addr & 0xff000000u)) /* domain <Z.0.0> */
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* addr_scope - convert message lookup domain to equivalent 2-bit scope value
|
||||
*/
|
||||
|
||||
static inline int addr_scope(u32 domain)
|
||||
{
|
||||
if (likely(!domain))
|
||||
return TIPC_ZONE_SCOPE;
|
||||
if (tipc_node(domain))
|
||||
return TIPC_NODE_SCOPE;
|
||||
if (tipc_cluster(domain))
|
||||
return TIPC_CLUSTER_SCOPE;
|
||||
return TIPC_ZONE_SCOPE;
|
||||
}
|
||||
|
||||
/**
|
||||
* addr_domain - convert 2-bit scope value to equivalent message lookup domain
|
||||
*
|
||||
* Needed when address of a named message must be looked up a second time
|
||||
* after a network hop.
|
||||
*/
|
||||
|
||||
static inline int addr_domain(int sc)
|
||||
{
|
||||
if (likely(sc == TIPC_NODE_SCOPE))
|
||||
return tipc_own_addr;
|
||||
if (sc == TIPC_CLUSTER_SCOPE)
|
||||
return tipc_addr(tipc_zone(tipc_own_addr),
|
||||
tipc_cluster(tipc_own_addr), 0);
|
||||
return tipc_addr(tipc_zone(tipc_own_addr), 0, 0);
|
||||
}
|
||||
|
||||
static inline char *addr_string_fill(char *string, u32 addr)
|
||||
{
|
||||
snprintf(string, 16, "<%u.%u.%u>",
|
||||
tipc_zone(addr), tipc_cluster(addr), tipc_node(addr));
|
||||
return string;
|
||||
}
|
||||
|
||||
int addr_domain_valid(u32);
|
||||
int addr_node_valid(u32 addr);
|
||||
|
||||
#endif
|
||||
803
net/tipc/bcast.c
Normal file
803
net/tipc/bcast.c
Normal file
|
|
@ -0,0 +1,803 @@
|
|||
/*
|
||||
* net/tipc/bcast.c: TIPC broadcast code
|
||||
*
|
||||
* Copyright (c) 2003-2005, Ericsson Research Canada
|
||||
* Copyright (c) 2004, Intel Corporation.
|
||||
* Copyright (c) 2005, Wind River Systems
|
||||
* Copyright (c) 2005-2006, Ericsson AB
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
* list of conditions and the following disclaimer.
|
||||
* 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.
|
||||
* 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.
|
||||
*
|
||||
* 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 "msg.h"
|
||||
#include "dbg.h"
|
||||
#include "link.h"
|
||||
#include "net.h"
|
||||
#include "node.h"
|
||||
#include "port.h"
|
||||
#include "addr.h"
|
||||
#include "node_subscr.h"
|
||||
#include "name_distr.h"
|
||||
#include "bearer.h"
|
||||
#include "name_table.h"
|
||||
#include "bcast.h"
|
||||
|
||||
|
||||
#define MAX_PKT_DEFAULT_MCAST 1500 /* bcast link max packet size (fixed) */
|
||||
|
||||
#define BCLINK_WIN_DEFAULT 20 /* bcast link window size (default) */
|
||||
|
||||
#define BCLINK_LOG_BUF_SIZE 0
|
||||
|
||||
/**
|
||||
* struct bcbearer_pair - a pair of bearers used by broadcast link
|
||||
* @primary: pointer to primary bearer
|
||||
* @secondary: pointer to secondary bearer
|
||||
*
|
||||
* Bearers must have same priority and same set of reachable destinations
|
||||
* to be paired.
|
||||
*/
|
||||
|
||||
struct bcbearer_pair {
|
||||
struct bearer *primary;
|
||||
struct bearer *secondary;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct bcbearer - bearer used by broadcast link
|
||||
* @bearer: (non-standard) broadcast bearer structure
|
||||
* @media: (non-standard) broadcast media structure
|
||||
* @bpairs: array of bearer pairs
|
||||
* @bpairs_temp: array of bearer pairs used during creation of "bpairs"
|
||||
*/
|
||||
|
||||
struct bcbearer {
|
||||
struct bearer bearer;
|
||||
struct media media;
|
||||
struct bcbearer_pair bpairs[MAX_BEARERS];
|
||||
struct bcbearer_pair bpairs_temp[TIPC_NUM_LINK_PRI];
|
||||
};
|
||||
|
||||
/**
|
||||
* struct bclink - link used for broadcast messages
|
||||
* @link: (non-standard) broadcast link structure
|
||||
* @node: (non-standard) node structure representing b'cast link's peer node
|
||||
*
|
||||
* Handles sequence numbering, fragmentation, bundling, etc.
|
||||
*/
|
||||
|
||||
struct bclink {
|
||||
struct link link;
|
||||
struct node node;
|
||||
};
|
||||
|
||||
|
||||
static struct bcbearer *bcbearer = NULL;
|
||||
static struct bclink *bclink = NULL;
|
||||
static struct link *bcl = NULL;
|
||||
static spinlock_t bc_lock = SPIN_LOCK_UNLOCKED;
|
||||
|
||||
char bc_link_name[] = "multicast-link";
|
||||
|
||||
|
||||
static inline u32 buf_seqno(struct sk_buff *buf)
|
||||
{
|
||||
return msg_seqno(buf_msg(buf));
|
||||
}
|
||||
|
||||
static inline u32 bcbuf_acks(struct sk_buff *buf)
|
||||
{
|
||||
return (u32)TIPC_SKB_CB(buf)->handle;
|
||||
}
|
||||
|
||||
static inline void bcbuf_set_acks(struct sk_buff *buf, u32 acks)
|
||||
{
|
||||
TIPC_SKB_CB(buf)->handle = (void *)acks;
|
||||
}
|
||||
|
||||
static inline void bcbuf_decr_acks(struct sk_buff *buf)
|
||||
{
|
||||
bcbuf_set_acks(buf, bcbuf_acks(buf) - 1);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* bclink_set_gap - set gap according to contents of current deferred pkt queue
|
||||
*
|
||||
* Called with 'node' locked, bc_lock unlocked
|
||||
*/
|
||||
|
||||
static inline void bclink_set_gap(struct node *n_ptr)
|
||||
{
|
||||
struct sk_buff *buf = n_ptr->bclink.deferred_head;
|
||||
|
||||
n_ptr->bclink.gap_after = n_ptr->bclink.gap_to =
|
||||
mod(n_ptr->bclink.last_in);
|
||||
if (unlikely(buf != NULL))
|
||||
n_ptr->bclink.gap_to = mod(buf_seqno(buf) - 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* bclink_ack_allowed - test if ACK or NACK message can be sent at this moment
|
||||
*
|
||||
* This mechanism endeavours to prevent all nodes in network from trying
|
||||
* to ACK or NACK at the same time.
|
||||
*
|
||||
* Note: TIPC uses a different trigger to distribute ACKs than it does to
|
||||
* distribute NACKs, but tries to use the same spacing (divide by 16).
|
||||
*/
|
||||
|
||||
static inline int bclink_ack_allowed(u32 n)
|
||||
{
|
||||
return((n % TIPC_MIN_LINK_WIN) == tipc_own_tag);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* bclink_retransmit_pkt - retransmit broadcast packets
|
||||
* @after: sequence number of last packet to *not* retransmit
|
||||
* @to: sequence number of last packet to retransmit
|
||||
*
|
||||
* Called with 'node' locked, bc_lock unlocked
|
||||
*/
|
||||
|
||||
static void bclink_retransmit_pkt(u32 after, u32 to)
|
||||
{
|
||||
struct sk_buff *buf;
|
||||
|
||||
spin_lock_bh(&bc_lock);
|
||||
buf = bcl->first_out;
|
||||
while (buf && less_eq(buf_seqno(buf), after)) {
|
||||
buf = buf->next;
|
||||
}
|
||||
if (buf != NULL)
|
||||
link_retransmit(bcl, buf, mod(to - after));
|
||||
spin_unlock_bh(&bc_lock);
|
||||
}
|
||||
|
||||
/**
|
||||
* bclink_acknowledge - handle acknowledgement of broadcast packets
|
||||
* @n_ptr: node that sent acknowledgement info
|
||||
* @acked: broadcast sequence # that has been acknowledged
|
||||
*
|
||||
* Node is locked, bc_lock unlocked.
|
||||
*/
|
||||
|
||||
void bclink_acknowledge(struct node *n_ptr, u32 acked)
|
||||
{
|
||||
struct sk_buff *crs;
|
||||
struct sk_buff *next;
|
||||
unsigned int released = 0;
|
||||
|
||||
if (less_eq(acked, n_ptr->bclink.acked))
|
||||
return;
|
||||
|
||||
spin_lock_bh(&bc_lock);
|
||||
|
||||
/* Skip over packets that node has previously acknowledged */
|
||||
|
||||
crs = bcl->first_out;
|
||||
while (crs && less_eq(buf_seqno(crs), n_ptr->bclink.acked)) {
|
||||
crs = crs->next;
|
||||
}
|
||||
|
||||
/* Update packets that node is now acknowledging */
|
||||
|
||||
while (crs && less_eq(buf_seqno(crs), acked)) {
|
||||
next = crs->next;
|
||||
bcbuf_decr_acks(crs);
|
||||
if (bcbuf_acks(crs) == 0) {
|
||||
bcl->first_out = next;
|
||||
bcl->out_queue_size--;
|
||||
buf_discard(crs);
|
||||
released = 1;
|
||||
}
|
||||
crs = next;
|
||||
}
|
||||
n_ptr->bclink.acked = acked;
|
||||
|
||||
/* Try resolving broadcast link congestion, if necessary */
|
||||
|
||||
if (unlikely(bcl->next_out))
|
||||
link_push_queue(bcl);
|
||||
if (unlikely(released && !list_empty(&bcl->waiting_ports)))
|
||||
link_wakeup_ports(bcl, 0);
|
||||
spin_unlock_bh(&bc_lock);
|
||||
}
|
||||
|
||||
/**
|
||||
* bclink_send_ack - unicast an ACK msg
|
||||
*
|
||||
* net_lock and node lock set
|
||||
*/
|
||||
|
||||
static void bclink_send_ack(struct node *n_ptr)
|
||||
{
|
||||
struct link *l_ptr = n_ptr->active_links[n_ptr->addr & 1];
|
||||
|
||||
if (l_ptr != NULL)
|
||||
link_send_proto_msg(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* bclink_send_nack- broadcast a NACK msg
|
||||
*
|
||||
* net_lock and node lock set
|
||||
*/
|
||||
|
||||
static void bclink_send_nack(struct node *n_ptr)
|
||||
{
|
||||
struct sk_buff *buf;
|
||||
struct tipc_msg *msg;
|
||||
|
||||
if (!less(n_ptr->bclink.gap_after, n_ptr->bclink.gap_to))
|
||||
return;
|
||||
|
||||
buf = buf_acquire(INT_H_SIZE);
|
||||
if (buf) {
|
||||
msg = buf_msg(buf);
|
||||
msg_init(msg, BCAST_PROTOCOL, STATE_MSG,
|
||||
TIPC_OK, INT_H_SIZE, n_ptr->addr);
|
||||
msg_set_mc_netid(msg, tipc_net_id);
|
||||
msg_set_bcast_ack(msg, mod(n_ptr->bclink.last_in));
|
||||
msg_set_bcgap_after(msg, n_ptr->bclink.gap_after);
|
||||
msg_set_bcgap_to(msg, n_ptr->bclink.gap_to);
|
||||
msg_set_bcast_tag(msg, tipc_own_tag);
|
||||
|
||||
if (bearer_send(&bcbearer->bearer, buf, 0)) {
|
||||
bcl->stats.sent_nacks++;
|
||||
buf_discard(buf);
|
||||
} else {
|
||||
bearer_schedule(bcl->b_ptr, bcl);
|
||||
bcl->proto_msg_queue = buf;
|
||||
bcl->stats.bearer_congs++;
|
||||
}
|
||||
|
||||
/*
|
||||
* Ensure we doesn't send another NACK msg to the node
|
||||
* until 16 more deferred messages arrive from it
|
||||
* (i.e. helps prevent all nodes from NACK'ing at same time)
|
||||
*/
|
||||
|
||||
n_ptr->bclink.nack_sync = tipc_own_tag;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* bclink_check_gap - send a NACK if a sequence gap exists
|
||||
*
|
||||
* net_lock and node lock set
|
||||
*/
|
||||
|
||||
void bclink_check_gap(struct node *n_ptr, u32 last_sent)
|
||||
{
|
||||
if (!n_ptr->bclink.supported ||
|
||||
less_eq(last_sent, mod(n_ptr->bclink.last_in)))
|
||||
return;
|
||||
|
||||
bclink_set_gap(n_ptr);
|
||||
if (n_ptr->bclink.gap_after == n_ptr->bclink.gap_to)
|
||||
n_ptr->bclink.gap_to = last_sent;
|
||||
bclink_send_nack(n_ptr);
|
||||
}
|
||||
|
||||
/**
|
||||
* bclink_peek_nack - process a NACK msg meant for another node
|
||||
*
|
||||
* Only net_lock set.
|
||||
*/
|
||||
|
||||
void bclink_peek_nack(u32 dest, u32 sender_tag, u32 gap_after, u32 gap_to)
|
||||
{
|
||||
struct node *n_ptr = node_find(dest);
|
||||
u32 my_after, my_to;
|
||||
|
||||
if (unlikely(!n_ptr || !node_is_up(n_ptr)))
|
||||
return;
|
||||
node_lock(n_ptr);
|
||||
/*
|
||||
* Modify gap to suppress unnecessary NACKs from this node
|
||||
*/
|
||||
my_after = n_ptr->bclink.gap_after;
|
||||
my_to = n_ptr->bclink.gap_to;
|
||||
|
||||
if (less_eq(gap_after, my_after)) {
|
||||
if (less(my_after, gap_to) && less(gap_to, my_to))
|
||||
n_ptr->bclink.gap_after = gap_to;
|
||||
else if (less_eq(my_to, gap_to))
|
||||
n_ptr->bclink.gap_to = n_ptr->bclink.gap_after;
|
||||
} else if (less_eq(gap_after, my_to)) {
|
||||
if (less_eq(my_to, gap_to))
|
||||
n_ptr->bclink.gap_to = gap_after;
|
||||
} else {
|
||||
/*
|
||||
* Expand gap if missing bufs not in deferred queue:
|
||||
*/
|
||||
struct sk_buff *buf = n_ptr->bclink.deferred_head;
|
||||
u32 prev = n_ptr->bclink.gap_to;
|
||||
|
||||
for (; buf; buf = buf->next) {
|
||||
u32 seqno = buf_seqno(buf);
|
||||
|
||||
if (mod(seqno - prev) != 1)
|
||||
buf = NULL;
|
||||
if (seqno == gap_after)
|
||||
break;
|
||||
prev = seqno;
|
||||
}
|
||||
if (buf == NULL)
|
||||
n_ptr->bclink.gap_to = gap_after;
|
||||
}
|
||||
/*
|
||||
* Some nodes may send a complementary NACK now:
|
||||
*/
|
||||
if (bclink_ack_allowed(sender_tag + 1)) {
|
||||
if (n_ptr->bclink.gap_to != n_ptr->bclink.gap_after) {
|
||||
bclink_send_nack(n_ptr);
|
||||
bclink_set_gap(n_ptr);
|
||||
}
|
||||
}
|
||||
node_unlock(n_ptr);
|
||||
}
|
||||
|
||||
/**
|
||||
* bclink_send_msg - broadcast a packet to all nodes in cluster
|
||||
*/
|
||||
|
||||
int bclink_send_msg(struct sk_buff *buf)
|
||||
{
|
||||
int res;
|
||||
|
||||
spin_lock_bh(&bc_lock);
|
||||
|
||||
res = link_send_buf(bcl, buf);
|
||||
if (unlikely(res == -ELINKCONG))
|
||||
buf_discard(buf);
|
||||
else
|
||||
bcl->stats.sent_info++;
|
||||
|
||||
if (bcl->out_queue_size > bcl->stats.max_queue_sz)
|
||||
bcl->stats.max_queue_sz = bcl->out_queue_size;
|
||||
bcl->stats.queue_sz_counts++;
|
||||
bcl->stats.accu_queue_sz += bcl->out_queue_size;
|
||||
|
||||
spin_unlock_bh(&bc_lock);
|
||||
return res;
|
||||
}
|
||||
|
||||
/**
|
||||
* bclink_recv_pkt - receive a broadcast packet, and deliver upwards
|
||||
*
|
||||
* net_lock is read_locked, no other locks set
|
||||
*/
|
||||
|
||||
void bclink_recv_pkt(struct sk_buff *buf)
|
||||
{
|
||||
struct tipc_msg *msg = buf_msg(buf);
|
||||
struct node* node = node_find(msg_prevnode(msg));
|
||||
u32 next_in;
|
||||
u32 seqno;
|
||||
struct sk_buff *deferred;
|
||||
|
||||
msg_dbg(msg, "<BC<<<");
|
||||
|
||||
if (unlikely(!node || !node_is_up(node) || !node->bclink.supported ||
|
||||
(msg_mc_netid(msg) != tipc_net_id))) {
|
||||
buf_discard(buf);
|
||||
return;
|
||||
}
|
||||
|
||||
if (unlikely(msg_user(msg) == BCAST_PROTOCOL)) {
|
||||
msg_dbg(msg, "<BCNACK<<<");
|
||||
if (msg_destnode(msg) == tipc_own_addr) {
|
||||
node_lock(node);
|
||||
bclink_acknowledge(node, msg_bcast_ack(msg));
|
||||
node_unlock(node);
|
||||
bcl->stats.recv_nacks++;
|
||||
bclink_retransmit_pkt(msg_bcgap_after(msg),
|
||||
msg_bcgap_to(msg));
|
||||
} else {
|
||||
bclink_peek_nack(msg_destnode(msg),
|
||||
msg_bcast_tag(msg),
|
||||
msg_bcgap_after(msg),
|
||||
msg_bcgap_to(msg));
|
||||
}
|
||||
buf_discard(buf);
|
||||
return;
|
||||
}
|
||||
|
||||
node_lock(node);
|
||||
receive:
|
||||
deferred = node->bclink.deferred_head;
|
||||
next_in = mod(node->bclink.last_in + 1);
|
||||
seqno = msg_seqno(msg);
|
||||
|
||||
if (likely(seqno == next_in)) {
|
||||
bcl->stats.recv_info++;
|
||||
node->bclink.last_in++;
|
||||
bclink_set_gap(node);
|
||||
if (unlikely(bclink_ack_allowed(seqno))) {
|
||||
bclink_send_ack(node);
|
||||
bcl->stats.sent_acks++;
|
||||
}
|
||||
if (likely(msg_isdata(msg))) {
|
||||
node_unlock(node);
|
||||
port_recv_mcast(buf, NULL);
|
||||
} else if (msg_user(msg) == MSG_BUNDLER) {
|
||||
bcl->stats.recv_bundles++;
|
||||
bcl->stats.recv_bundled += msg_msgcnt(msg);
|
||||
node_unlock(node);
|
||||
link_recv_bundle(buf);
|
||||
} else if (msg_user(msg) == MSG_FRAGMENTER) {
|
||||
bcl->stats.recv_fragments++;
|
||||
if (link_recv_fragment(&node->bclink.defragm,
|
||||
&buf, &msg))
|
||||
bcl->stats.recv_fragmented++;
|
||||
node_unlock(node);
|
||||
net_route_msg(buf);
|
||||
} else {
|
||||
node_unlock(node);
|
||||
net_route_msg(buf);
|
||||
}
|
||||
if (deferred && (buf_seqno(deferred) == mod(next_in + 1))) {
|
||||
node_lock(node);
|
||||
buf = deferred;
|
||||
msg = buf_msg(buf);
|
||||
node->bclink.deferred_head = deferred->next;
|
||||
goto receive;
|
||||
}
|
||||
return;
|
||||
} else if (less(next_in, seqno)) {
|
||||
u32 gap_after = node->bclink.gap_after;
|
||||
u32 gap_to = node->bclink.gap_to;
|
||||
|
||||
if (link_defer_pkt(&node->bclink.deferred_head,
|
||||
&node->bclink.deferred_tail,
|
||||
buf)) {
|
||||
node->bclink.nack_sync++;
|
||||
bcl->stats.deferred_recv++;
|
||||
if (seqno == mod(gap_after + 1))
|
||||
node->bclink.gap_after = seqno;
|
||||
else if (less(gap_after, seqno) && less(seqno, gap_to))
|
||||
node->bclink.gap_to = seqno;
|
||||
}
|
||||
if (bclink_ack_allowed(node->bclink.nack_sync)) {
|
||||
if (gap_to != gap_after)
|
||||
bclink_send_nack(node);
|
||||
bclink_set_gap(node);
|
||||
}
|
||||
} else {
|
||||
bcl->stats.duplicates++;
|
||||
buf_discard(buf);
|
||||
}
|
||||
node_unlock(node);
|
||||
}
|
||||
|
||||
u32 bclink_get_last_sent(void)
|
||||
{
|
||||
u32 last_sent = mod(bcl->next_out_no - 1);
|
||||
|
||||
if (bcl->next_out)
|
||||
last_sent = mod(buf_seqno(bcl->next_out) - 1);
|
||||
return last_sent;
|
||||
}
|
||||
|
||||
u32 bclink_acks_missing(struct node *n_ptr)
|
||||
{
|
||||
return (n_ptr->bclink.supported &&
|
||||
(bclink_get_last_sent() != n_ptr->bclink.acked));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* bcbearer_send - send a packet through the broadcast pseudo-bearer
|
||||
*
|
||||
* Send through as many bearers as necessary to reach all nodes
|
||||
* that support TIPC multicasting.
|
||||
*
|
||||
* Returns 0 if packet sent successfully, non-zero if not
|
||||
*/
|
||||
|
||||
int bcbearer_send(struct sk_buff *buf,
|
||||
struct tipc_bearer *unused1,
|
||||
struct tipc_media_addr *unused2)
|
||||
{
|
||||
static int send_count = 0;
|
||||
|
||||
struct node_map remains;
|
||||
struct node_map remains_new;
|
||||
int bp_index;
|
||||
int swap_time;
|
||||
|
||||
/* Prepare buffer for broadcasting (if first time trying to send it) */
|
||||
|
||||
if (likely(!msg_non_seq(buf_msg(buf)))) {
|
||||
struct tipc_msg *msg;
|
||||
|
||||
assert(cluster_bcast_nodes.count != 0);
|
||||
bcbuf_set_acks(buf, cluster_bcast_nodes.count);
|
||||
msg = buf_msg(buf);
|
||||
msg_set_non_seq(msg);
|
||||
msg_set_mc_netid(msg, tipc_net_id);
|
||||
}
|
||||
|
||||
/* Determine if bearer pairs should be swapped following this attempt */
|
||||
|
||||
if ((swap_time = (++send_count >= 10)))
|
||||
send_count = 0;
|
||||
|
||||
/* Send buffer over bearers until all targets reached */
|
||||
|
||||
remains = cluster_bcast_nodes;
|
||||
|
||||
for (bp_index = 0; bp_index < MAX_BEARERS; bp_index++) {
|
||||
struct bearer *p = bcbearer->bpairs[bp_index].primary;
|
||||
struct bearer *s = bcbearer->bpairs[bp_index].secondary;
|
||||
|
||||
if (!p)
|
||||
break; /* no more bearers to try */
|
||||
|
||||
nmap_diff(&remains, &p->nodes, &remains_new);
|
||||
if (remains_new.count == remains.count)
|
||||
continue; /* bearer pair doesn't add anything */
|
||||
|
||||
if (!p->publ.blocked &&
|
||||
!p->media->send_msg(buf, &p->publ, &p->media->bcast_addr)) {
|
||||
if (swap_time && s && !s->publ.blocked)
|
||||
goto swap;
|
||||
else
|
||||
goto update;
|
||||
}
|
||||
|
||||
if (!s || s->publ.blocked ||
|
||||
s->media->send_msg(buf, &s->publ, &s->media->bcast_addr))
|
||||
continue; /* unable to send using bearer pair */
|
||||
swap:
|
||||
bcbearer->bpairs[bp_index].primary = s;
|
||||
bcbearer->bpairs[bp_index].secondary = p;
|
||||
update:
|
||||
if (remains_new.count == 0)
|
||||
return TIPC_OK;
|
||||
|
||||
remains = remains_new;
|
||||
}
|
||||
|
||||
/* Unable to reach all targets */
|
||||
|
||||
bcbearer->bearer.publ.blocked = 1;
|
||||
bcl->stats.bearer_congs++;
|
||||
return ~TIPC_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* bcbearer_sort - create sets of bearer pairs used by broadcast bearer
|
||||
*/
|
||||
|
||||
void bcbearer_sort(void)
|
||||
{
|
||||
struct bcbearer_pair *bp_temp = bcbearer->bpairs_temp;
|
||||
struct bcbearer_pair *bp_curr;
|
||||
int b_index;
|
||||
int pri;
|
||||
|
||||
spin_lock_bh(&bc_lock);
|
||||
|
||||
/* Group bearers by priority (can assume max of two per priority) */
|
||||
|
||||
memset(bp_temp, 0, sizeof(bcbearer->bpairs_temp));
|
||||
|
||||
for (b_index = 0; b_index < MAX_BEARERS; b_index++) {
|
||||
struct bearer *b = &bearers[b_index];
|
||||
|
||||
if (!b->active || !b->nodes.count)
|
||||
continue;
|
||||
|
||||
if (!bp_temp[b->priority].primary)
|
||||
bp_temp[b->priority].primary = b;
|
||||
else
|
||||
bp_temp[b->priority].secondary = b;
|
||||
}
|
||||
|
||||
/* Create array of bearer pairs for broadcasting */
|
||||
|
||||
bp_curr = bcbearer->bpairs;
|
||||
memset(bcbearer->bpairs, 0, sizeof(bcbearer->bpairs));
|
||||
|
||||
for (pri = (TIPC_NUM_LINK_PRI - 1); pri >= 0; pri--) {
|
||||
|
||||
if (!bp_temp[pri].primary)
|
||||
continue;
|
||||
|
||||
bp_curr->primary = bp_temp[pri].primary;
|
||||
|
||||
if (bp_temp[pri].secondary) {
|
||||
if (nmap_equal(&bp_temp[pri].primary->nodes,
|
||||
&bp_temp[pri].secondary->nodes)) {
|
||||
bp_curr->secondary = bp_temp[pri].secondary;
|
||||
} else {
|
||||
bp_curr++;
|
||||
bp_curr->primary = bp_temp[pri].secondary;
|
||||
}
|
||||
}
|
||||
|
||||
bp_curr++;
|
||||
}
|
||||
|
||||
spin_unlock_bh(&bc_lock);
|
||||
}
|
||||
|
||||
/**
|
||||
* bcbearer_push - resolve bearer congestion
|
||||
*
|
||||
* Forces bclink to push out any unsent packets, until all packets are gone
|
||||
* or congestion reoccurs.
|
||||
* No locks set when function called
|
||||
*/
|
||||
|
||||
void bcbearer_push(void)
|
||||
{
|
||||
struct bearer *b_ptr;
|
||||
|
||||
spin_lock_bh(&bc_lock);
|
||||
b_ptr = &bcbearer->bearer;
|
||||
if (b_ptr->publ.blocked) {
|
||||
b_ptr->publ.blocked = 0;
|
||||
bearer_lock_push(b_ptr);
|
||||
}
|
||||
spin_unlock_bh(&bc_lock);
|
||||
}
|
||||
|
||||
|
||||
int bclink_stats(char *buf, const u32 buf_size)
|
||||
{
|
||||
struct print_buf pb;
|
||||
|
||||
if (!bcl)
|
||||
return 0;
|
||||
|
||||
printbuf_init(&pb, buf, buf_size);
|
||||
|
||||
spin_lock_bh(&bc_lock);
|
||||
|
||||
tipc_printf(&pb, "Link <%s>\n"
|
||||
" Window:%u packets\n",
|
||||
bcl->name, bcl->queue_limit[0]);
|
||||
tipc_printf(&pb, " RX packets:%u fragments:%u/%u bundles:%u/%u\n",
|
||||
bcl->stats.recv_info,
|
||||
bcl->stats.recv_fragments,
|
||||
bcl->stats.recv_fragmented,
|
||||
bcl->stats.recv_bundles,
|
||||
bcl->stats.recv_bundled);
|
||||
tipc_printf(&pb, " TX packets:%u fragments:%u/%u bundles:%u/%u\n",
|
||||
bcl->stats.sent_info,
|
||||
bcl->stats.sent_fragments,
|
||||
bcl->stats.sent_fragmented,
|
||||
bcl->stats.sent_bundles,
|
||||
bcl->stats.sent_bundled);
|
||||
tipc_printf(&pb, " RX naks:%u defs:%u dups:%u\n",
|
||||
bcl->stats.recv_nacks,
|
||||
bcl->stats.deferred_recv,
|
||||
bcl->stats.duplicates);
|
||||
tipc_printf(&pb, " TX naks:%u acks:%u dups:%u\n",
|
||||
bcl->stats.sent_nacks,
|
||||
bcl->stats.sent_acks,
|
||||
bcl->stats.retransmitted);
|
||||
tipc_printf(&pb, " Congestion bearer:%u link:%u Send queue max:%u avg:%u\n",
|
||||
bcl->stats.bearer_congs,
|
||||
bcl->stats.link_congs,
|
||||
bcl->stats.max_queue_sz,
|
||||
bcl->stats.queue_sz_counts
|
||||
? (bcl->stats.accu_queue_sz / bcl->stats.queue_sz_counts)
|
||||
: 0);
|
||||
|
||||
spin_unlock_bh(&bc_lock);
|
||||
return printbuf_validate(&pb);
|
||||
}
|
||||
|
||||
int bclink_reset_stats(void)
|
||||
{
|
||||
if (!bcl)
|
||||
return -ENOPROTOOPT;
|
||||
|
||||
spin_lock_bh(&bc_lock);
|
||||
memset(&bcl->stats, 0, sizeof(bcl->stats));
|
||||
spin_unlock_bh(&bc_lock);
|
||||
return TIPC_OK;
|
||||
}
|
||||
|
||||
int bclink_set_queue_limits(u32 limit)
|
||||
{
|
||||
if (!bcl)
|
||||
return -ENOPROTOOPT;
|
||||
if ((limit < TIPC_MIN_LINK_WIN) || (limit > TIPC_MAX_LINK_WIN))
|
||||
return -EINVAL;
|
||||
|
||||
spin_lock_bh(&bc_lock);
|
||||
link_set_queue_limits(bcl, limit);
|
||||
spin_unlock_bh(&bc_lock);
|
||||
return TIPC_OK;
|
||||
}
|
||||
|
||||
int bclink_init(void)
|
||||
{
|
||||
bcbearer = kmalloc(sizeof(*bcbearer), GFP_ATOMIC);
|
||||
bclink = kmalloc(sizeof(*bclink), GFP_ATOMIC);
|
||||
if (!bcbearer || !bclink) {
|
||||
nomem:
|
||||
warn("Memory squeeze; Failed to create multicast link\n");
|
||||
kfree(bcbearer);
|
||||
bcbearer = NULL;
|
||||
kfree(bclink);
|
||||
bclink = NULL;
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
memset(bcbearer, 0, sizeof(struct bcbearer));
|
||||
INIT_LIST_HEAD(&bcbearer->bearer.cong_links);
|
||||
bcbearer->bearer.media = &bcbearer->media;
|
||||
bcbearer->media.send_msg = bcbearer_send;
|
||||
sprintf(bcbearer->media.name, "tipc-multicast");
|
||||
|
||||
bcl = &bclink->link;
|
||||
memset(bclink, 0, sizeof(struct bclink));
|
||||
INIT_LIST_HEAD(&bcl->waiting_ports);
|
||||
bcl->next_out_no = 1;
|
||||
bclink->node.lock = SPIN_LOCK_UNLOCKED;
|
||||
bcl->owner = &bclink->node;
|
||||
bcl->max_pkt = MAX_PKT_DEFAULT_MCAST;
|
||||
link_set_queue_limits(bcl, BCLINK_WIN_DEFAULT);
|
||||
bcl->b_ptr = &bcbearer->bearer;
|
||||
bcl->state = WORKING_WORKING;
|
||||
sprintf(bcl->name, bc_link_name);
|
||||
|
||||
if (BCLINK_LOG_BUF_SIZE) {
|
||||
char *pb = kmalloc(BCLINK_LOG_BUF_SIZE, GFP_ATOMIC);
|
||||
|
||||
if (!pb)
|
||||
goto nomem;
|
||||
printbuf_init(&bcl->print_buf, pb, BCLINK_LOG_BUF_SIZE);
|
||||
}
|
||||
|
||||
return TIPC_OK;
|
||||
}
|
||||
|
||||
void bclink_stop(void)
|
||||
{
|
||||
spin_lock_bh(&bc_lock);
|
||||
if (bcbearer) {
|
||||
link_stop(bcl);
|
||||
if (BCLINK_LOG_BUF_SIZE)
|
||||
kfree(bcl->print_buf.buf);
|
||||
bcl = NULL;
|
||||
kfree(bclink);
|
||||
bclink = NULL;
|
||||
kfree(bcbearer);
|
||||
bcbearer = NULL;
|
||||
}
|
||||
spin_unlock_bh(&bc_lock);
|
||||
}
|
||||
|
||||
220
net/tipc/bcast.h
Normal file
220
net/tipc/bcast.h
Normal file
|
|
@ -0,0 +1,220 @@
|
|||
/*
|
||||
* net/tipc/bcast.h: Include file for TIPC broadcast code
|
||||
*
|
||||
* Copyright (c) 2003-2005, Ericsson Research Canada
|
||||
* Copyright (c) 2005, Wind River Systems
|
||||
* Copyright (c) 2005-2006, Ericsson AB
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
* list of conditions and the following disclaimer.
|
||||
* 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.
|
||||
* 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.
|
||||
*
|
||||
* 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 _TIPC_BCAST_H
|
||||
#define _TIPC_BCAST_H
|
||||
|
||||
#define MAX_NODES 4096
|
||||
#define WSIZE 32
|
||||
|
||||
/**
|
||||
* struct node_map - set of node identifiers
|
||||
* @count: # of nodes in set
|
||||
* @map: bitmap of node identifiers that are in the set
|
||||
*/
|
||||
|
||||
struct node_map {
|
||||
u32 count;
|
||||
u32 map[MAX_NODES / WSIZE];
|
||||
};
|
||||
|
||||
|
||||
#define PLSIZE 32
|
||||
|
||||
/**
|
||||
* struct port_list - set of node local destination ports
|
||||
* @count: # of ports in set (only valid for first entry in list)
|
||||
* @next: pointer to next entry in list
|
||||
* @ports: array of port references
|
||||
*/
|
||||
|
||||
struct port_list {
|
||||
int count;
|
||||
struct port_list *next;
|
||||
u32 ports[PLSIZE];
|
||||
};
|
||||
|
||||
|
||||
struct node;
|
||||
|
||||
extern char bc_link_name[];
|
||||
|
||||
|
||||
/**
|
||||
* nmap_get - determine if node exists in a node map
|
||||
*/
|
||||
|
||||
static inline int nmap_get(struct node_map *nm_ptr, u32 node)
|
||||
{
|
||||
int n = tipc_node(node);
|
||||
int w = n / WSIZE;
|
||||
int b = n % WSIZE;
|
||||
|
||||
return nm_ptr->map[w] & (1 << b);
|
||||
}
|
||||
|
||||
/**
|
||||
* nmap_add - add a node to a node map
|
||||
*/
|
||||
|
||||
static inline void nmap_add(struct node_map *nm_ptr, u32 node)
|
||||
{
|
||||
int n = tipc_node(node);
|
||||
int w = n / WSIZE;
|
||||
u32 mask = (1 << (n % WSIZE));
|
||||
|
||||
if ((nm_ptr->map[w] & mask) == 0) {
|
||||
nm_ptr->count++;
|
||||
nm_ptr->map[w] |= mask;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* nmap_remove - remove a node from a node map
|
||||
*/
|
||||
|
||||
static inline void nmap_remove(struct node_map *nm_ptr, u32 node)
|
||||
{
|
||||
int n = tipc_node(node);
|
||||
int w = n / WSIZE;
|
||||
u32 mask = (1 << (n % WSIZE));
|
||||
|
||||
if ((nm_ptr->map[w] & mask) != 0) {
|
||||
nm_ptr->map[w] &= ~mask;
|
||||
nm_ptr->count--;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* nmap_equal - test for equality of node maps
|
||||
*/
|
||||
|
||||
static inline int nmap_equal(struct node_map *nm_a, struct node_map *nm_b)
|
||||
{
|
||||
return !memcmp(nm_a, nm_b, sizeof(*nm_a));
|
||||
}
|
||||
|
||||
/**
|
||||
* nmap_diff - find differences between node maps
|
||||
* @nm_a: input node map A
|
||||
* @nm_b: input node map B
|
||||
* @nm_diff: output node map A-B (i.e. nodes of A that are not in B)
|
||||
*/
|
||||
|
||||
static inline void nmap_diff(struct node_map *nm_a, struct node_map *nm_b,
|
||||
struct node_map *nm_diff)
|
||||
{
|
||||
int stop = sizeof(nm_a->map) / sizeof(u32);
|
||||
int w;
|
||||
int b;
|
||||
u32 map;
|
||||
|
||||
memset(nm_diff, 0, sizeof(*nm_diff));
|
||||
for (w = 0; w < stop; w++) {
|
||||
map = nm_a->map[w] ^ (nm_a->map[w] & nm_b->map[w]);
|
||||
nm_diff->map[w] = map;
|
||||
if (map != 0) {
|
||||
for (b = 0 ; b < WSIZE; b++) {
|
||||
if (map & (1 << b))
|
||||
nm_diff->count++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* port_list_add - add a port to a port list, ensuring no duplicates
|
||||
*/
|
||||
|
||||
static inline void port_list_add(struct port_list *pl_ptr, u32 port)
|
||||
{
|
||||
struct port_list *item = pl_ptr;
|
||||
int i;
|
||||
int item_sz = PLSIZE;
|
||||
int cnt = pl_ptr->count;
|
||||
|
||||
for (; ; cnt -= item_sz, item = item->next) {
|
||||
if (cnt < PLSIZE)
|
||||
item_sz = cnt;
|
||||
for (i = 0; i < item_sz; i++)
|
||||
if (item->ports[i] == port)
|
||||
return;
|
||||
if (i < PLSIZE) {
|
||||
item->ports[i] = port;
|
||||
pl_ptr->count++;
|
||||
return;
|
||||
}
|
||||
if (!item->next) {
|
||||
item->next = kmalloc(sizeof(*item), GFP_ATOMIC);
|
||||
if (!item->next) {
|
||||
warn("Memory squeeze: multicast destination port list is incomplete\n");
|
||||
return;
|
||||
}
|
||||
item->next->next = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* port_list_free - free dynamically created entries in port_list chain
|
||||
*
|
||||
* Note: First item is on stack, so it doesn't need to be released
|
||||
*/
|
||||
|
||||
static inline void port_list_free(struct port_list *pl_ptr)
|
||||
{
|
||||
struct port_list *item;
|
||||
struct port_list *next;
|
||||
|
||||
for (item = pl_ptr->next; item; item = next) {
|
||||
next = item->next;
|
||||
kfree(item);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int bclink_init(void);
|
||||
void bclink_stop(void);
|
||||
void bclink_acknowledge(struct node *n_ptr, u32 acked);
|
||||
int bclink_send_msg(struct sk_buff *buf);
|
||||
void bclink_recv_pkt(struct sk_buff *buf);
|
||||
u32 bclink_get_last_sent(void);
|
||||
u32 bclink_acks_missing(struct node *n_ptr);
|
||||
void bclink_check_gap(struct node *n_ptr, u32 seqno);
|
||||
int bclink_stats(char *stats_buf, const u32 buf_size);
|
||||
int bclink_reset_stats(void);
|
||||
int bclink_set_queue_limits(u32 limit);
|
||||
void bcbearer_sort(void);
|
||||
void bcbearer_push(void);
|
||||
|
||||
#endif
|
||||
689
net/tipc/bearer.c
Normal file
689
net/tipc/bearer.c
Normal file
|
|
@ -0,0 +1,689 @@
|
|||
/*
|
||||
* net/tipc/bearer.c: TIPC bearer code
|
||||
*
|
||||
* Copyright (c) 2003-2005, Ericsson Research Canada
|
||||
* Copyright (c) 2004-2005, Wind River Systems
|
||||
* Copyright (c) 2005-2006, Ericsson AB
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
* list of conditions and the following disclaimer.
|
||||
* 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.
|
||||
* 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.
|
||||
*
|
||||
* 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 "bearer.h"
|
||||
#include "link.h"
|
||||
#include "port.h"
|
||||
#include "discover.h"
|
||||
#include "bcast.h"
|
||||
|
||||
#define MAX_ADDR_STR 32
|
||||
|
||||
static struct media *media_list = 0;
|
||||
static u32 media_count = 0;
|
||||
|
||||
struct bearer *bearers = 0;
|
||||
|
||||
/**
|
||||
* media_name_valid - validate media name
|
||||
*
|
||||
* Returns 1 if media name is valid, otherwise 0.
|
||||
*/
|
||||
|
||||
static int media_name_valid(const char *name)
|
||||
{
|
||||
u32 len;
|
||||
|
||||
len = strlen(name);
|
||||
if ((len + 1) > TIPC_MAX_MEDIA_NAME)
|
||||
return 0;
|
||||
return (strspn(name, tipc_alphabet) == len);
|
||||
}
|
||||
|
||||
/**
|
||||
* media_find - locates specified media object by name
|
||||
*/
|
||||
|
||||
static struct media *media_find(const char *name)
|
||||
{
|
||||
struct media *m_ptr;
|
||||
u32 i;
|
||||
|
||||
for (i = 0, m_ptr = media_list; i < media_count; i++, m_ptr++) {
|
||||
if (!strcmp(m_ptr->name, name))
|
||||
return m_ptr;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* tipc_register_media - register a media type
|
||||
*
|
||||
* Bearers for this media type must be activated separately at a later stage.
|
||||
*/
|
||||
|
||||
int tipc_register_media(u32 media_type,
|
||||
char *name,
|
||||
int (*enable)(struct tipc_bearer *),
|
||||
void (*disable)(struct tipc_bearer *),
|
||||
int (*send_msg)(struct sk_buff *,
|
||||
struct tipc_bearer *,
|
||||
struct tipc_media_addr *),
|
||||
char *(*addr2str)(struct tipc_media_addr *a,
|
||||
char *str_buf, int str_size),
|
||||
struct tipc_media_addr *bcast_addr,
|
||||
const u32 bearer_priority,
|
||||
const u32 link_tolerance, /* [ms] */
|
||||
const u32 send_window_limit)
|
||||
{
|
||||
struct media *m_ptr;
|
||||
u32 media_id;
|
||||
u32 i;
|
||||
int res = -EINVAL;
|
||||
|
||||
write_lock_bh(&net_lock);
|
||||
if (!media_list)
|
||||
goto exit;
|
||||
|
||||
if (!media_name_valid(name)) {
|
||||
warn("Media registration error: illegal name <%s>\n", name);
|
||||
goto exit;
|
||||
}
|
||||
if (!bcast_addr) {
|
||||
warn("Media registration error: no broadcast address supplied\n");
|
||||
goto exit;
|
||||
}
|
||||
if (bearer_priority >= TIPC_NUM_LINK_PRI) {
|
||||
warn("Media registration error: priority %u\n", bearer_priority);
|
||||
goto exit;
|
||||
}
|
||||
if ((link_tolerance < TIPC_MIN_LINK_TOL) ||
|
||||
(link_tolerance > TIPC_MAX_LINK_TOL)) {
|
||||
warn("Media registration error: tolerance %u\n", link_tolerance);
|
||||
goto exit;
|
||||
}
|
||||
|
||||
media_id = media_count++;
|
||||
if (media_id >= MAX_MEDIA) {
|
||||
warn("Attempt to register more than %u media\n", MAX_MEDIA);
|
||||
media_count--;
|
||||
goto exit;
|
||||
}
|
||||
for (i = 0; i < media_id; i++) {
|
||||
if (media_list[i].type_id == media_type) {
|
||||
warn("Attempt to register second media with type %u\n",
|
||||
media_type);
|
||||
media_count--;
|
||||
goto exit;
|
||||
}
|
||||
if (!strcmp(name, media_list[i].name)) {
|
||||
warn("Attempt to re-register media name <%s>\n", name);
|
||||
media_count--;
|
||||
goto exit;
|
||||
}
|
||||
}
|
||||
|
||||
m_ptr = &media_list[media_id];
|
||||
m_ptr->type_id = media_type;
|
||||
m_ptr->send_msg = send_msg;
|
||||
m_ptr->enable_bearer = enable;
|
||||
m_ptr->disable_bearer = disable;
|
||||
m_ptr->addr2str = addr2str;
|
||||
memcpy(&m_ptr->bcast_addr, bcast_addr, sizeof(*bcast_addr));
|
||||
m_ptr->bcast = 1;
|
||||
strcpy(m_ptr->name, name);
|
||||
m_ptr->priority = bearer_priority;
|
||||
m_ptr->tolerance = link_tolerance;
|
||||
m_ptr->window = send_window_limit;
|
||||
dbg("Media <%s> registered\n", name);
|
||||
res = 0;
|
||||
exit:
|
||||
write_unlock_bh(&net_lock);
|
||||
return res;
|
||||
}
|
||||
|
||||
/**
|
||||
* media_addr_printf - record media address in print buffer
|
||||
*/
|
||||
|
||||
void media_addr_printf(struct print_buf *pb, struct tipc_media_addr *a)
|
||||
{
|
||||
struct media *m_ptr;
|
||||
u32 media_type;
|
||||
u32 i;
|
||||
|
||||
media_type = ntohl(a->type);
|
||||
for (i = 0, m_ptr = media_list; i < media_count; i++, m_ptr++) {
|
||||
if (m_ptr->type_id == media_type)
|
||||
break;
|
||||
}
|
||||
|
||||
if ((i < media_count) && (m_ptr->addr2str != NULL)) {
|
||||
char addr_str[MAX_ADDR_STR];
|
||||
|
||||
tipc_printf(pb, "%s(%s) ", m_ptr->name,
|
||||
m_ptr->addr2str(a, addr_str, sizeof(addr_str)));
|
||||
} else {
|
||||
unchar *addr = (unchar *)&a->dev_addr;
|
||||
|
||||
tipc_printf(pb, "UNKNOWN(%u):", media_type);
|
||||
for (i = 0; i < (sizeof(*a) - sizeof(a->type)); i++) {
|
||||
tipc_printf(pb, "%02x ", addr[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* media_get_names - record names of registered media in buffer
|
||||
*/
|
||||
|
||||
struct sk_buff *media_get_names(void)
|
||||
{
|
||||
struct sk_buff *buf;
|
||||
struct media *m_ptr;
|
||||
int i;
|
||||
|
||||
buf = cfg_reply_alloc(MAX_MEDIA * TLV_SPACE(TIPC_MAX_MEDIA_NAME));
|
||||
if (!buf)
|
||||
return NULL;
|
||||
|
||||
read_lock_bh(&net_lock);
|
||||
for (i = 0, m_ptr = media_list; i < media_count; i++, m_ptr++) {
|
||||
cfg_append_tlv(buf, TIPC_TLV_MEDIA_NAME, m_ptr->name,
|
||||
strlen(m_ptr->name) + 1);
|
||||
}
|
||||
read_unlock_bh(&net_lock);
|
||||
return buf;
|
||||
}
|
||||
|
||||
/**
|
||||
* bearer_name_validate - validate & (optionally) deconstruct bearer name
|
||||
* @name - ptr to bearer name string
|
||||
* @name_parts - ptr to area for bearer name components (or NULL if not needed)
|
||||
*
|
||||
* Returns 1 if bearer name is valid, otherwise 0.
|
||||
*/
|
||||
|
||||
static int bearer_name_validate(const char *name,
|
||||
struct bearer_name *name_parts)
|
||||
{
|
||||
char name_copy[TIPC_MAX_BEARER_NAME];
|
||||
char *media_name;
|
||||
char *if_name;
|
||||
u32 media_len;
|
||||
u32 if_len;
|
||||
|
||||
/* copy bearer name & ensure length is OK */
|
||||
|
||||
name_copy[TIPC_MAX_BEARER_NAME - 1] = 0;
|
||||
/* need above in case non-Posix strncpy() doesn't pad with nulls */
|
||||
strncpy(name_copy, name, TIPC_MAX_BEARER_NAME);
|
||||
if (name_copy[TIPC_MAX_BEARER_NAME - 1] != 0)
|
||||
return 0;
|
||||
|
||||
/* ensure all component parts of bearer name are present */
|
||||
|
||||
media_name = name_copy;
|
||||
if ((if_name = strchr(media_name, ':')) == NULL)
|
||||
return 0;
|
||||
*(if_name++) = 0;
|
||||
media_len = if_name - media_name;
|
||||
if_len = strlen(if_name) + 1;
|
||||
|
||||
/* validate component parts of bearer name */
|
||||
|
||||
if ((media_len <= 1) || (media_len > TIPC_MAX_MEDIA_NAME) ||
|
||||
(if_len <= 1) || (if_len > TIPC_MAX_IF_NAME) ||
|
||||
(strspn(media_name, tipc_alphabet) != (media_len - 1)) ||
|
||||
(strspn(if_name, tipc_alphabet) != (if_len - 1)))
|
||||
return 0;
|
||||
|
||||
/* return bearer name components, if necessary */
|
||||
|
||||
if (name_parts) {
|
||||
strcpy(name_parts->media_name, media_name);
|
||||
strcpy(name_parts->if_name, if_name);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* bearer_find - locates bearer object with matching bearer name
|
||||
*/
|
||||
|
||||
static struct bearer *bearer_find(const char *name)
|
||||
{
|
||||
struct bearer *b_ptr;
|
||||
u32 i;
|
||||
|
||||
for (i = 0, b_ptr = bearers; i < MAX_BEARERS; i++, b_ptr++) {
|
||||
if (b_ptr->active && (!strcmp(b_ptr->publ.name, name)))
|
||||
return b_ptr;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* bearer_find - locates bearer object with matching interface name
|
||||
*/
|
||||
|
||||
struct bearer *bearer_find_interface(const char *if_name)
|
||||
{
|
||||
struct bearer *b_ptr;
|
||||
char *b_if_name;
|
||||
u32 i;
|
||||
|
||||
for (i = 0, b_ptr = bearers; i < MAX_BEARERS; i++, b_ptr++) {
|
||||
if (!b_ptr->active)
|
||||
continue;
|
||||
b_if_name = strchr(b_ptr->publ.name, ':') + 1;
|
||||
if (!strcmp(b_if_name, if_name))
|
||||
return b_ptr;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* bearer_get_names - record names of bearers in buffer
|
||||
*/
|
||||
|
||||
struct sk_buff *bearer_get_names(void)
|
||||
{
|
||||
struct sk_buff *buf;
|
||||
struct media *m_ptr;
|
||||
struct bearer *b_ptr;
|
||||
int i, j;
|
||||
|
||||
buf = cfg_reply_alloc(MAX_BEARERS * TLV_SPACE(TIPC_MAX_BEARER_NAME));
|
||||
if (!buf)
|
||||
return NULL;
|
||||
|
||||
read_lock_bh(&net_lock);
|
||||
for (i = 0, m_ptr = media_list; i < media_count; i++, m_ptr++) {
|
||||
for (j = 0; j < MAX_BEARERS; j++) {
|
||||
b_ptr = &bearers[j];
|
||||
if (b_ptr->active && (b_ptr->media == m_ptr)) {
|
||||
cfg_append_tlv(buf, TIPC_TLV_BEARER_NAME,
|
||||
b_ptr->publ.name,
|
||||
strlen(b_ptr->publ.name) + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
read_unlock_bh(&net_lock);
|
||||
return buf;
|
||||
}
|
||||
|
||||
void bearer_add_dest(struct bearer *b_ptr, u32 dest)
|
||||
{
|
||||
nmap_add(&b_ptr->nodes, dest);
|
||||
disc_update_link_req(b_ptr->link_req);
|
||||
bcbearer_sort();
|
||||
}
|
||||
|
||||
void bearer_remove_dest(struct bearer *b_ptr, u32 dest)
|
||||
{
|
||||
nmap_remove(&b_ptr->nodes, dest);
|
||||
disc_update_link_req(b_ptr->link_req);
|
||||
bcbearer_sort();
|
||||
}
|
||||
|
||||
/*
|
||||
* bearer_push(): Resolve bearer congestion. Force the waiting
|
||||
* links to push out their unsent packets, one packet per link
|
||||
* per iteration, until all packets are gone or congestion reoccurs.
|
||||
* 'net_lock' is read_locked when this function is called
|
||||
* bearer.lock must be taken before calling
|
||||
* Returns binary true(1) ore false(0)
|
||||
*/
|
||||
static int bearer_push(struct bearer *b_ptr)
|
||||
{
|
||||
u32 res = TIPC_OK;
|
||||
struct link *ln, *tln;
|
||||
|
||||
if (b_ptr->publ.blocked)
|
||||
return 0;
|
||||
|
||||
while (!list_empty(&b_ptr->cong_links) && (res != PUSH_FAILED)) {
|
||||
list_for_each_entry_safe(ln, tln, &b_ptr->cong_links, link_list) {
|
||||
res = link_push_packet(ln);
|
||||
if (res == PUSH_FAILED)
|
||||
break;
|
||||
if (res == PUSH_FINISHED)
|
||||
list_move_tail(&ln->link_list, &b_ptr->links);
|
||||
}
|
||||
}
|
||||
return list_empty(&b_ptr->cong_links);
|
||||
}
|
||||
|
||||
void bearer_lock_push(struct bearer *b_ptr)
|
||||
{
|
||||
int res;
|
||||
|
||||
spin_lock_bh(&b_ptr->publ.lock);
|
||||
res = bearer_push(b_ptr);
|
||||
spin_unlock_bh(&b_ptr->publ.lock);
|
||||
if (res)
|
||||
bcbearer_push();
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Interrupt enabling new requests after bearer congestion or blocking:
|
||||
* See bearer_send().
|
||||
*/
|
||||
void tipc_continue(struct tipc_bearer *tb_ptr)
|
||||
{
|
||||
struct bearer *b_ptr = (struct bearer *)tb_ptr;
|
||||
|
||||
spin_lock_bh(&b_ptr->publ.lock);
|
||||
b_ptr->continue_count++;
|
||||
if (!list_empty(&b_ptr->cong_links))
|
||||
k_signal((Handler)bearer_lock_push, (unsigned long)b_ptr);
|
||||
b_ptr->publ.blocked = 0;
|
||||
spin_unlock_bh(&b_ptr->publ.lock);
|
||||
}
|
||||
|
||||
/*
|
||||
* Schedule link for sending of messages after the bearer
|
||||
* has been deblocked by 'continue()'. This method is called
|
||||
* when somebody tries to send a message via this link while
|
||||
* the bearer is congested. 'net_lock' is in read_lock here
|
||||
* bearer.lock is busy
|
||||
*/
|
||||
|
||||
static void bearer_schedule_unlocked(struct bearer *b_ptr, struct link *l_ptr)
|
||||
{
|
||||
list_move_tail(&l_ptr->link_list, &b_ptr->cong_links);
|
||||
}
|
||||
|
||||
/*
|
||||
* Schedule link for sending of messages after the bearer
|
||||
* has been deblocked by 'continue()'. This method is called
|
||||
* when somebody tries to send a message via this link while
|
||||
* the bearer is congested. 'net_lock' is in read_lock here,
|
||||
* bearer.lock is free
|
||||
*/
|
||||
|
||||
void bearer_schedule(struct bearer *b_ptr, struct link *l_ptr)
|
||||
{
|
||||
spin_lock_bh(&b_ptr->publ.lock);
|
||||
bearer_schedule_unlocked(b_ptr, l_ptr);
|
||||
spin_unlock_bh(&b_ptr->publ.lock);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* bearer_resolve_congestion(): Check if there is bearer congestion,
|
||||
* and if there is, try to resolve it before returning.
|
||||
* 'net_lock' is read_locked when this function is called
|
||||
*/
|
||||
int bearer_resolve_congestion(struct bearer *b_ptr, struct link *l_ptr)
|
||||
{
|
||||
int res = 1;
|
||||
|
||||
if (list_empty(&b_ptr->cong_links))
|
||||
return 1;
|
||||
spin_lock_bh(&b_ptr->publ.lock);
|
||||
if (!bearer_push(b_ptr)) {
|
||||
bearer_schedule_unlocked(b_ptr, l_ptr);
|
||||
res = 0;
|
||||
}
|
||||
spin_unlock_bh(&b_ptr->publ.lock);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* tipc_enable_bearer - enable bearer with the given name
|
||||
*/
|
||||
|
||||
int tipc_enable_bearer(const char *name, u32 bcast_scope, u32 priority)
|
||||
{
|
||||
struct bearer *b_ptr;
|
||||
struct media *m_ptr;
|
||||
struct bearer_name b_name;
|
||||
char addr_string[16];
|
||||
u32 bearer_id;
|
||||
u32 with_this_prio;
|
||||
u32 i;
|
||||
int res = -EINVAL;
|
||||
|
||||
if (tipc_mode != TIPC_NET_MODE)
|
||||
return -ENOPROTOOPT;
|
||||
if (!bearer_name_validate(name, &b_name) ||
|
||||
!addr_domain_valid(bcast_scope) ||
|
||||
!in_scope(bcast_scope, tipc_own_addr) ||
|
||||
(priority > TIPC_NUM_LINK_PRI))
|
||||
return -EINVAL;
|
||||
|
||||
write_lock_bh(&net_lock);
|
||||
if (!bearers)
|
||||
goto failed;
|
||||
|
||||
m_ptr = media_find(b_name.media_name);
|
||||
if (!m_ptr) {
|
||||
warn("No media <%s>\n", b_name.media_name);
|
||||
goto failed;
|
||||
}
|
||||
if (priority == TIPC_NUM_LINK_PRI)
|
||||
priority = m_ptr->priority;
|
||||
|
||||
restart:
|
||||
bearer_id = MAX_BEARERS;
|
||||
with_this_prio = 1;
|
||||
for (i = MAX_BEARERS; i-- != 0; ) {
|
||||
if (!bearers[i].active) {
|
||||
bearer_id = i;
|
||||
continue;
|
||||
}
|
||||
if (!strcmp(name, bearers[i].publ.name)) {
|
||||
warn("Bearer <%s> already enabled\n", name);
|
||||
goto failed;
|
||||
}
|
||||
if ((bearers[i].priority == priority) &&
|
||||
(++with_this_prio > 2)) {
|
||||
if (priority-- == 0) {
|
||||
warn("Third bearer <%s> with priority %u, unable to lower to %u\n",
|
||||
name, priority + 1, priority);
|
||||
goto failed;
|
||||
}
|
||||
warn("Third bearer <%s> with priority %u, lowering to %u\n",
|
||||
name, priority + 1, priority);
|
||||
goto restart;
|
||||
}
|
||||
}
|
||||
if (bearer_id >= MAX_BEARERS) {
|
||||
warn("Attempt to enable more than %d bearers\n", MAX_BEARERS);
|
||||
goto failed;
|
||||
}
|
||||
|
||||
b_ptr = &bearers[bearer_id];
|
||||
memset(b_ptr, 0, sizeof(struct bearer));
|
||||
|
||||
strcpy(b_ptr->publ.name, name);
|
||||
res = m_ptr->enable_bearer(&b_ptr->publ);
|
||||
if (res) {
|
||||
warn("Failed to enable bearer <%s>\n", name);
|
||||
goto failed;
|
||||
}
|
||||
|
||||
b_ptr->identity = bearer_id;
|
||||
b_ptr->media = m_ptr;
|
||||
b_ptr->net_plane = bearer_id + 'A';
|
||||
b_ptr->active = 1;
|
||||
b_ptr->detect_scope = bcast_scope;
|
||||
b_ptr->priority = priority;
|
||||
INIT_LIST_HEAD(&b_ptr->cong_links);
|
||||
INIT_LIST_HEAD(&b_ptr->links);
|
||||
if (m_ptr->bcast) {
|
||||
b_ptr->link_req = disc_init_link_req(b_ptr, &m_ptr->bcast_addr,
|
||||
bcast_scope, 2);
|
||||
}
|
||||
b_ptr->publ.lock = SPIN_LOCK_UNLOCKED;
|
||||
write_unlock_bh(&net_lock);
|
||||
info("Enabled bearer <%s>, discovery domain %s\n",
|
||||
name, addr_string_fill(addr_string, bcast_scope));
|
||||
return 0;
|
||||
failed:
|
||||
write_unlock_bh(&net_lock);
|
||||
return res;
|
||||
}
|
||||
|
||||
/**
|
||||
* tipc_block_bearer(): Block the bearer with the given name,
|
||||
* and reset all its links
|
||||
*/
|
||||
|
||||
int tipc_block_bearer(const char *name)
|
||||
{
|
||||
struct bearer *b_ptr = 0;
|
||||
struct link *l_ptr;
|
||||
struct link *temp_l_ptr;
|
||||
|
||||
if (tipc_mode != TIPC_NET_MODE)
|
||||
return -ENOPROTOOPT;
|
||||
|
||||
read_lock_bh(&net_lock);
|
||||
b_ptr = bearer_find(name);
|
||||
if (!b_ptr) {
|
||||
warn("Attempt to block unknown bearer <%s>\n", name);
|
||||
read_unlock_bh(&net_lock);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
spin_lock_bh(&b_ptr->publ.lock);
|
||||
b_ptr->publ.blocked = 1;
|
||||
list_for_each_entry_safe(l_ptr, temp_l_ptr, &b_ptr->links, link_list) {
|
||||
struct node *n_ptr = l_ptr->owner;
|
||||
|
||||
spin_lock_bh(&n_ptr->lock);
|
||||
link_reset(l_ptr);
|
||||
spin_unlock_bh(&n_ptr->lock);
|
||||
}
|
||||
spin_unlock_bh(&b_ptr->publ.lock);
|
||||
read_unlock_bh(&net_lock);
|
||||
info("Blocked bearer <%s>\n", name);
|
||||
return TIPC_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* bearer_disable -
|
||||
*
|
||||
* Note: This routine assumes caller holds net_lock.
|
||||
*/
|
||||
|
||||
static int bearer_disable(const char *name)
|
||||
{
|
||||
struct bearer *b_ptr;
|
||||
struct link *l_ptr;
|
||||
struct link *temp_l_ptr;
|
||||
|
||||
if (tipc_mode != TIPC_NET_MODE)
|
||||
return -ENOPROTOOPT;
|
||||
|
||||
b_ptr = bearer_find(name);
|
||||
if (!b_ptr) {
|
||||
warn("Attempt to disable unknown bearer <%s>\n", name);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
disc_stop_link_req(b_ptr->link_req);
|
||||
spin_lock_bh(&b_ptr->publ.lock);
|
||||
b_ptr->link_req = NULL;
|
||||
b_ptr->publ.blocked = 1;
|
||||
if (b_ptr->media->disable_bearer) {
|
||||
spin_unlock_bh(&b_ptr->publ.lock);
|
||||
write_unlock_bh(&net_lock);
|
||||
b_ptr->media->disable_bearer(&b_ptr->publ);
|
||||
write_lock_bh(&net_lock);
|
||||
spin_lock_bh(&b_ptr->publ.lock);
|
||||
}
|
||||
list_for_each_entry_safe(l_ptr, temp_l_ptr, &b_ptr->links, link_list) {
|
||||
link_delete(l_ptr);
|
||||
}
|
||||
spin_unlock_bh(&b_ptr->publ.lock);
|
||||
info("Disabled bearer <%s>\n", name);
|
||||
memset(b_ptr, 0, sizeof(struct bearer));
|
||||
return TIPC_OK;
|
||||
}
|
||||
|
||||
int tipc_disable_bearer(const char *name)
|
||||
{
|
||||
int res;
|
||||
|
||||
write_lock_bh(&net_lock);
|
||||
res = bearer_disable(name);
|
||||
write_unlock_bh(&net_lock);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
|
||||
int bearer_init(void)
|
||||
{
|
||||
int res;
|
||||
|
||||
write_lock_bh(&net_lock);
|
||||
bearers = kmalloc(MAX_BEARERS * sizeof(struct bearer), GFP_ATOMIC);
|
||||
media_list = kmalloc(MAX_MEDIA * sizeof(struct media), GFP_ATOMIC);
|
||||
if (bearers && media_list) {
|
||||
memset(bearers, 0, MAX_BEARERS * sizeof(struct bearer));
|
||||
memset(media_list, 0, MAX_MEDIA * sizeof(struct media));
|
||||
res = TIPC_OK;
|
||||
} else {
|
||||
kfree(bearers);
|
||||
kfree(media_list);
|
||||
bearers = 0;
|
||||
media_list = 0;
|
||||
res = -ENOMEM;
|
||||
}
|
||||
write_unlock_bh(&net_lock);
|
||||
return res;
|
||||
}
|
||||
|
||||
void bearer_stop(void)
|
||||
{
|
||||
u32 i;
|
||||
|
||||
if (!bearers)
|
||||
return;
|
||||
|
||||
for (i = 0; i < MAX_BEARERS; i++) {
|
||||
if (bearers[i].active)
|
||||
bearers[i].publ.blocked = 1;
|
||||
}
|
||||
for (i = 0; i < MAX_BEARERS; i++) {
|
||||
if (bearers[i].active)
|
||||
bearer_disable(bearers[i].publ.name);
|
||||
}
|
||||
kfree(bearers);
|
||||
kfree(media_list);
|
||||
bearers = 0;
|
||||
media_list = 0;
|
||||
media_count = 0;
|
||||
}
|
||||
|
||||
|
||||
169
net/tipc/bearer.h
Normal file
169
net/tipc/bearer.h
Normal file
|
|
@ -0,0 +1,169 @@
|
|||
/*
|
||||
* net/tipc/bearer.h: Include file for TIPC bearer code
|
||||
*
|
||||
* Copyright (c) 2003-2005, Ericsson Research Canada
|
||||
* Copyright (c) 2005, Wind River Systems
|
||||
* Copyright (c) 2005-2006, Ericsson AB
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
* list of conditions and the following disclaimer.
|
||||
* 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.
|
||||
* 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.
|
||||
*
|
||||
* 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 _TIPC_BEARER_H
|
||||
#define _TIPC_BEARER_H
|
||||
|
||||
#include <net/tipc/tipc_bearer.h>
|
||||
#include "bcast.h"
|
||||
|
||||
#define MAX_BEARERS 8
|
||||
#define MAX_MEDIA 4
|
||||
|
||||
|
||||
/**
|
||||
* struct media - TIPC media information available to internal users
|
||||
* @send_msg: routine which handles buffer transmission
|
||||
* @enable_bearer: routine which enables a bearer
|
||||
* @disable_bearer: routine which disables a bearer
|
||||
* @addr2str: routine which converts bearer's address to string form
|
||||
* @bcast_addr: media address used in broadcasting
|
||||
* @bcast: non-zero if media supports broadcasting [currently mandatory]
|
||||
* @priority: default link (and bearer) priority
|
||||
* @tolerance: default time (in ms) before declaring link failure
|
||||
* @window: default window (in packets) before declaring link congestion
|
||||
* @type_id: TIPC media identifier [defined in tipc_bearer.h]
|
||||
* @name: media name
|
||||
*/
|
||||
|
||||
struct media {
|
||||
int (*send_msg)(struct sk_buff *buf,
|
||||
struct tipc_bearer *b_ptr,
|
||||
struct tipc_media_addr *dest);
|
||||
int (*enable_bearer)(struct tipc_bearer *b_ptr);
|
||||
void (*disable_bearer)(struct tipc_bearer *b_ptr);
|
||||
char *(*addr2str)(struct tipc_media_addr *a,
|
||||
char *str_buf, int str_size);
|
||||
struct tipc_media_addr bcast_addr;
|
||||
int bcast;
|
||||
u32 priority;
|
||||
u32 tolerance;
|
||||
u32 window;
|
||||
u32 type_id;
|
||||
char name[TIPC_MAX_MEDIA_NAME];
|
||||
};
|
||||
|
||||
/**
|
||||
* struct bearer - TIPC bearer information available to internal users
|
||||
* @publ: bearer information available to privileged users
|
||||
* @media: ptr to media structure associated with bearer
|
||||
* @priority: default link priority for bearer
|
||||
* @detect_scope: network address mask used during automatic link creation
|
||||
* @identity: array index of this bearer within TIPC bearer array
|
||||
* @link_req: ptr to (optional) structure making periodic link setup requests
|
||||
* @links: list of non-congested links associated with bearer
|
||||
* @cong_links: list of congested links associated with bearer
|
||||
* @continue_count: # of times bearer has resumed after congestion or blocking
|
||||
* @active: non-zero if bearer structure is represents a bearer
|
||||
* @net_plane: network plane ('A' through 'H') currently associated with bearer
|
||||
* @nodes: indicates which nodes in cluster can be reached through bearer
|
||||
*/
|
||||
|
||||
struct bearer {
|
||||
struct tipc_bearer publ;
|
||||
struct media *media;
|
||||
u32 priority;
|
||||
u32 detect_scope;
|
||||
u32 identity;
|
||||
struct link_req *link_req;
|
||||
struct list_head links;
|
||||
struct list_head cong_links;
|
||||
u32 continue_count;
|
||||
int active;
|
||||
char net_plane;
|
||||
struct node_map nodes;
|
||||
};
|
||||
|
||||
struct bearer_name {
|
||||
char media_name[TIPC_MAX_MEDIA_NAME];
|
||||
char if_name[TIPC_MAX_IF_NAME];
|
||||
};
|
||||
|
||||
struct link;
|
||||
|
||||
extern struct bearer *bearers;
|
||||
|
||||
void media_addr_printf(struct print_buf *pb, struct tipc_media_addr *a);
|
||||
struct sk_buff *media_get_names(void);
|
||||
|
||||
struct sk_buff *bearer_get_names(void);
|
||||
void bearer_add_dest(struct bearer *b_ptr, u32 dest);
|
||||
void bearer_remove_dest(struct bearer *b_ptr, u32 dest);
|
||||
void bearer_schedule(struct bearer *b_ptr, struct link *l_ptr);
|
||||
struct bearer *bearer_find_interface(const char *if_name);
|
||||
int bearer_resolve_congestion(struct bearer *b_ptr, struct link *l_ptr);
|
||||
int bearer_init(void);
|
||||
void bearer_stop(void);
|
||||
int bearer_broadcast(struct sk_buff *buf, struct tipc_bearer *b_ptr,
|
||||
struct tipc_media_addr *dest);
|
||||
void bearer_lock_push(struct bearer *b_ptr);
|
||||
|
||||
|
||||
/**
|
||||
* bearer_send- sends buffer to destination over bearer
|
||||
*
|
||||
* Returns true (1) if successful, or false (0) if unable to send
|
||||
*
|
||||
* IMPORTANT:
|
||||
* The media send routine must not alter the buffer being passed in
|
||||
* as it may be needed for later retransmission!
|
||||
*
|
||||
* If the media send routine returns a non-zero value (indicating that
|
||||
* it was unable to send the buffer), it must:
|
||||
* 1) mark the bearer as blocked,
|
||||
* 2) call tipc_continue() once the bearer is able to send again.
|
||||
* Media types that are unable to meet these two critera must ensure their
|
||||
* send routine always returns success -- even if the buffer was not sent --
|
||||
* and let TIPC's link code deal with the undelivered message.
|
||||
*/
|
||||
|
||||
static inline int bearer_send(struct bearer *b_ptr, struct sk_buff *buf,
|
||||
struct tipc_media_addr *dest)
|
||||
{
|
||||
return !b_ptr->media->send_msg(buf, &b_ptr->publ, dest);
|
||||
}
|
||||
|
||||
/**
|
||||
* bearer_congested - determines if bearer is currently congested
|
||||
*/
|
||||
|
||||
static inline int bearer_congested(struct bearer *b_ptr, struct link *l_ptr)
|
||||
{
|
||||
if (unlikely(b_ptr->publ.blocked))
|
||||
return 1;
|
||||
if (likely(list_empty(&b_ptr->cong_links)))
|
||||
return 0;
|
||||
return !bearer_resolve_congestion(b_ptr, l_ptr);
|
||||
}
|
||||
|
||||
#endif
|
||||
573
net/tipc/cluster.c
Normal file
573
net/tipc/cluster.c
Normal file
|
|
@ -0,0 +1,573 @@
|
|||
/*
|
||||
* net/tipc/cluster.c: TIPC cluster management routines
|
||||
*
|
||||
* Copyright (c) 2003-2005, Ericsson Research Canada
|
||||
* Copyright (c) 2005, Wind River Systems
|
||||
* Copyright (c) 2005-2006, Ericsson AB
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
* list of conditions and the following disclaimer.
|
||||
* 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.
|
||||
* 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.
|
||||
*
|
||||
* 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 "cluster.h"
|
||||
#include "addr.h"
|
||||
#include "node_subscr.h"
|
||||
#include "link.h"
|
||||
#include "node.h"
|
||||
#include "net.h"
|
||||
#include "msg.h"
|
||||
#include "bearer.h"
|
||||
|
||||
void cluster_multicast(struct cluster *c_ptr, struct sk_buff *buf,
|
||||
u32 lower, u32 upper);
|
||||
struct sk_buff *cluster_prepare_routing_msg(u32 data_size, u32 dest);
|
||||
|
||||
struct node **local_nodes = 0;
|
||||
struct node_map cluster_bcast_nodes = {0,{0,}};
|
||||
u32 highest_allowed_slave = 0;
|
||||
|
||||
struct cluster *cluster_create(u32 addr)
|
||||
{
|
||||
struct _zone *z_ptr;
|
||||
struct cluster *c_ptr;
|
||||
int max_nodes;
|
||||
int alloc;
|
||||
|
||||
c_ptr = (struct cluster *)kmalloc(sizeof(*c_ptr), GFP_ATOMIC);
|
||||
if (c_ptr == NULL)
|
||||
return 0;
|
||||
memset(c_ptr, 0, sizeof(*c_ptr));
|
||||
|
||||
c_ptr->addr = tipc_addr(tipc_zone(addr), tipc_cluster(addr), 0);
|
||||
if (in_own_cluster(addr))
|
||||
max_nodes = LOWEST_SLAVE + tipc_max_slaves;
|
||||
else
|
||||
max_nodes = tipc_max_nodes + 1;
|
||||
alloc = sizeof(void *) * (max_nodes + 1);
|
||||
c_ptr->nodes = (struct node **)kmalloc(alloc, GFP_ATOMIC);
|
||||
if (c_ptr->nodes == NULL) {
|
||||
kfree(c_ptr);
|
||||
return 0;
|
||||
}
|
||||
memset(c_ptr->nodes, 0, alloc);
|
||||
if (in_own_cluster(addr))
|
||||
local_nodes = c_ptr->nodes;
|
||||
c_ptr->highest_slave = LOWEST_SLAVE - 1;
|
||||
c_ptr->highest_node = 0;
|
||||
|
||||
z_ptr = zone_find(tipc_zone(addr));
|
||||
if (z_ptr == NULL) {
|
||||
z_ptr = zone_create(addr);
|
||||
}
|
||||
if (z_ptr != NULL) {
|
||||
zone_attach_cluster(z_ptr, c_ptr);
|
||||
c_ptr->owner = z_ptr;
|
||||
}
|
||||
else {
|
||||
kfree(c_ptr);
|
||||
c_ptr = 0;
|
||||
}
|
||||
|
||||
return c_ptr;
|
||||
}
|
||||
|
||||
void cluster_delete(struct cluster *c_ptr)
|
||||
{
|
||||
u32 n_num;
|
||||
|
||||
if (!c_ptr)
|
||||
return;
|
||||
for (n_num = 1; n_num <= c_ptr->highest_node; n_num++) {
|
||||
node_delete(c_ptr->nodes[n_num]);
|
||||
}
|
||||
for (n_num = LOWEST_SLAVE; n_num <= c_ptr->highest_slave; n_num++) {
|
||||
node_delete(c_ptr->nodes[n_num]);
|
||||
}
|
||||
kfree(c_ptr->nodes);
|
||||
kfree(c_ptr);
|
||||
}
|
||||
|
||||
u32 cluster_next_node(struct cluster *c_ptr, u32 addr)
|
||||
{
|
||||
struct node *n_ptr;
|
||||
u32 n_num = tipc_node(addr) + 1;
|
||||
|
||||
if (!c_ptr)
|
||||
return addr;
|
||||
for (; n_num <= c_ptr->highest_node; n_num++) {
|
||||
n_ptr = c_ptr->nodes[n_num];
|
||||
if (n_ptr && node_has_active_links(n_ptr))
|
||||
return n_ptr->addr;
|
||||
}
|
||||
for (n_num = 1; n_num < tipc_node(addr); n_num++) {
|
||||
n_ptr = c_ptr->nodes[n_num];
|
||||
if (n_ptr && node_has_active_links(n_ptr))
|
||||
return n_ptr->addr;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void cluster_attach_node(struct cluster *c_ptr, struct node *n_ptr)
|
||||
{
|
||||
u32 n_num = tipc_node(n_ptr->addr);
|
||||
u32 max_n_num = tipc_max_nodes;
|
||||
|
||||
if (in_own_cluster(n_ptr->addr))
|
||||
max_n_num = highest_allowed_slave;
|
||||
assert(n_num > 0);
|
||||
assert(n_num <= max_n_num);
|
||||
assert(c_ptr->nodes[n_num] == 0);
|
||||
c_ptr->nodes[n_num] = n_ptr;
|
||||
if (n_num > c_ptr->highest_node)
|
||||
c_ptr->highest_node = n_num;
|
||||
}
|
||||
|
||||
/**
|
||||
* cluster_select_router - select router to a cluster
|
||||
*
|
||||
* Uses deterministic and fair algorithm.
|
||||
*/
|
||||
|
||||
u32 cluster_select_router(struct cluster *c_ptr, u32 ref)
|
||||
{
|
||||
u32 n_num;
|
||||
u32 ulim = c_ptr->highest_node;
|
||||
u32 mask;
|
||||
u32 tstart;
|
||||
|
||||
assert(!in_own_cluster(c_ptr->addr));
|
||||
if (!ulim)
|
||||
return 0;
|
||||
|
||||
/* Start entry must be random */
|
||||
mask = tipc_max_nodes;
|
||||
while (mask > ulim)
|
||||
mask >>= 1;
|
||||
tstart = ref & mask;
|
||||
n_num = tstart;
|
||||
|
||||
/* Lookup upwards with wrap-around */
|
||||
do {
|
||||
if (node_is_up(c_ptr->nodes[n_num]))
|
||||
break;
|
||||
} while (++n_num <= ulim);
|
||||
if (n_num > ulim) {
|
||||
n_num = 1;
|
||||
do {
|
||||
if (node_is_up(c_ptr->nodes[n_num]))
|
||||
break;
|
||||
} while (++n_num < tstart);
|
||||
if (n_num == tstart)
|
||||
return 0;
|
||||
}
|
||||
assert(n_num <= ulim);
|
||||
return node_select_router(c_ptr->nodes[n_num], ref);
|
||||
}
|
||||
|
||||
/**
|
||||
* cluster_select_node - select destination node within a remote cluster
|
||||
*
|
||||
* Uses deterministic and fair algorithm.
|
||||
*/
|
||||
|
||||
struct node *cluster_select_node(struct cluster *c_ptr, u32 selector)
|
||||
{
|
||||
u32 n_num;
|
||||
u32 mask = tipc_max_nodes;
|
||||
u32 start_entry;
|
||||
|
||||
assert(!in_own_cluster(c_ptr->addr));
|
||||
if (!c_ptr->highest_node)
|
||||
return 0;
|
||||
|
||||
/* Start entry must be random */
|
||||
while (mask > c_ptr->highest_node) {
|
||||
mask >>= 1;
|
||||
}
|
||||
start_entry = (selector & mask) ? selector & mask : 1u;
|
||||
assert(start_entry <= c_ptr->highest_node);
|
||||
|
||||
/* Lookup upwards with wrap-around */
|
||||
for (n_num = start_entry; n_num <= c_ptr->highest_node; n_num++) {
|
||||
if (node_has_active_links(c_ptr->nodes[n_num]))
|
||||
return c_ptr->nodes[n_num];
|
||||
}
|
||||
for (n_num = 1; n_num < start_entry; n_num++) {
|
||||
if (node_has_active_links(c_ptr->nodes[n_num]))
|
||||
return c_ptr->nodes[n_num];
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Routing table management: See description in node.c
|
||||
*/
|
||||
|
||||
struct sk_buff *cluster_prepare_routing_msg(u32 data_size, u32 dest)
|
||||
{
|
||||
u32 size = INT_H_SIZE + data_size;
|
||||
struct sk_buff *buf = buf_acquire(size);
|
||||
struct tipc_msg *msg;
|
||||
|
||||
if (buf) {
|
||||
msg = buf_msg(buf);
|
||||
memset((char *)msg, 0, size);
|
||||
msg_init(msg, ROUTE_DISTRIBUTOR, 0, TIPC_OK, INT_H_SIZE, dest);
|
||||
}
|
||||
return buf;
|
||||
}
|
||||
|
||||
void cluster_bcast_new_route(struct cluster *c_ptr, u32 dest,
|
||||
u32 lower, u32 upper)
|
||||
{
|
||||
struct sk_buff *buf = cluster_prepare_routing_msg(0, c_ptr->addr);
|
||||
struct tipc_msg *msg;
|
||||
|
||||
if (buf) {
|
||||
msg = buf_msg(buf);
|
||||
msg_set_remote_node(msg, dest);
|
||||
msg_set_type(msg, ROUTE_ADDITION);
|
||||
cluster_multicast(c_ptr, buf, lower, upper);
|
||||
} else {
|
||||
warn("Memory squeeze: broadcast of new route failed\n");
|
||||
}
|
||||
}
|
||||
|
||||
void cluster_bcast_lost_route(struct cluster *c_ptr, u32 dest,
|
||||
u32 lower, u32 upper)
|
||||
{
|
||||
struct sk_buff *buf = cluster_prepare_routing_msg(0, c_ptr->addr);
|
||||
struct tipc_msg *msg;
|
||||
|
||||
if (buf) {
|
||||
msg = buf_msg(buf);
|
||||
msg_set_remote_node(msg, dest);
|
||||
msg_set_type(msg, ROUTE_REMOVAL);
|
||||
cluster_multicast(c_ptr, buf, lower, upper);
|
||||
} else {
|
||||
warn("Memory squeeze: broadcast of lost route failed\n");
|
||||
}
|
||||
}
|
||||
|
||||
void cluster_send_slave_routes(struct cluster *c_ptr, u32 dest)
|
||||
{
|
||||
struct sk_buff *buf;
|
||||
struct tipc_msg *msg;
|
||||
u32 highest = c_ptr->highest_slave;
|
||||
u32 n_num;
|
||||
int send = 0;
|
||||
|
||||
assert(!is_slave(dest));
|
||||
assert(in_own_cluster(dest));
|
||||
assert(in_own_cluster(c_ptr->addr));
|
||||
if (highest <= LOWEST_SLAVE)
|
||||
return;
|
||||
buf = cluster_prepare_routing_msg(highest - LOWEST_SLAVE + 1,
|
||||
c_ptr->addr);
|
||||
if (buf) {
|
||||
msg = buf_msg(buf);
|
||||
msg_set_remote_node(msg, c_ptr->addr);
|
||||
msg_set_type(msg, SLAVE_ROUTING_TABLE);
|
||||
for (n_num = LOWEST_SLAVE; n_num <= highest; n_num++) {
|
||||
if (c_ptr->nodes[n_num] &&
|
||||
node_has_active_links(c_ptr->nodes[n_num])) {
|
||||
send = 1;
|
||||
msg_set_dataoctet(msg, n_num);
|
||||
}
|
||||
}
|
||||
if (send)
|
||||
link_send(buf, dest, dest);
|
||||
else
|
||||
buf_discard(buf);
|
||||
} else {
|
||||
warn("Memory squeeze: broadcast of lost route failed\n");
|
||||
}
|
||||
}
|
||||
|
||||
void cluster_send_ext_routes(struct cluster *c_ptr, u32 dest)
|
||||
{
|
||||
struct sk_buff *buf;
|
||||
struct tipc_msg *msg;
|
||||
u32 highest = c_ptr->highest_node;
|
||||
u32 n_num;
|
||||
int send = 0;
|
||||
|
||||
if (in_own_cluster(c_ptr->addr))
|
||||
return;
|
||||
assert(!is_slave(dest));
|
||||
assert(in_own_cluster(dest));
|
||||
highest = c_ptr->highest_node;
|
||||
buf = cluster_prepare_routing_msg(highest + 1, c_ptr->addr);
|
||||
if (buf) {
|
||||
msg = buf_msg(buf);
|
||||
msg_set_remote_node(msg, c_ptr->addr);
|
||||
msg_set_type(msg, EXT_ROUTING_TABLE);
|
||||
for (n_num = 1; n_num <= highest; n_num++) {
|
||||
if (c_ptr->nodes[n_num] &&
|
||||
node_has_active_links(c_ptr->nodes[n_num])) {
|
||||
send = 1;
|
||||
msg_set_dataoctet(msg, n_num);
|
||||
}
|
||||
}
|
||||
if (send)
|
||||
link_send(buf, dest, dest);
|
||||
else
|
||||
buf_discard(buf);
|
||||
} else {
|
||||
warn("Memory squeeze: broadcast of external route failed\n");
|
||||
}
|
||||
}
|
||||
|
||||
void cluster_send_local_routes(struct cluster *c_ptr, u32 dest)
|
||||
{
|
||||
struct sk_buff *buf;
|
||||
struct tipc_msg *msg;
|
||||
u32 highest = c_ptr->highest_node;
|
||||
u32 n_num;
|
||||
int send = 0;
|
||||
|
||||
assert(is_slave(dest));
|
||||
assert(in_own_cluster(c_ptr->addr));
|
||||
buf = cluster_prepare_routing_msg(highest, c_ptr->addr);
|
||||
if (buf) {
|
||||
msg = buf_msg(buf);
|
||||
msg_set_remote_node(msg, c_ptr->addr);
|
||||
msg_set_type(msg, LOCAL_ROUTING_TABLE);
|
||||
for (n_num = 1; n_num <= highest; n_num++) {
|
||||
if (c_ptr->nodes[n_num] &&
|
||||
node_has_active_links(c_ptr->nodes[n_num])) {
|
||||
send = 1;
|
||||
msg_set_dataoctet(msg, n_num);
|
||||
}
|
||||
}
|
||||
if (send)
|
||||
link_send(buf, dest, dest);
|
||||
else
|
||||
buf_discard(buf);
|
||||
} else {
|
||||
warn("Memory squeeze: broadcast of local route failed\n");
|
||||
}
|
||||
}
|
||||
|
||||
void cluster_recv_routing_table(struct sk_buff *buf)
|
||||
{
|
||||
struct tipc_msg *msg = buf_msg(buf);
|
||||
struct cluster *c_ptr;
|
||||
struct node *n_ptr;
|
||||
unchar *node_table;
|
||||
u32 table_size;
|
||||
u32 router;
|
||||
u32 rem_node = msg_remote_node(msg);
|
||||
u32 z_num;
|
||||
u32 c_num;
|
||||
u32 n_num;
|
||||
|
||||
c_ptr = cluster_find(rem_node);
|
||||
if (!c_ptr) {
|
||||
c_ptr = cluster_create(rem_node);
|
||||
if (!c_ptr) {
|
||||
buf_discard(buf);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
node_table = buf->data + msg_hdr_sz(msg);
|
||||
table_size = msg_size(msg) - msg_hdr_sz(msg);
|
||||
router = msg_prevnode(msg);
|
||||
z_num = tipc_zone(rem_node);
|
||||
c_num = tipc_cluster(rem_node);
|
||||
|
||||
switch (msg_type(msg)) {
|
||||
case LOCAL_ROUTING_TABLE:
|
||||
assert(is_slave(tipc_own_addr));
|
||||
case EXT_ROUTING_TABLE:
|
||||
for (n_num = 1; n_num < table_size; n_num++) {
|
||||
if (node_table[n_num]) {
|
||||
u32 addr = tipc_addr(z_num, c_num, n_num);
|
||||
n_ptr = c_ptr->nodes[n_num];
|
||||
if (!n_ptr) {
|
||||
n_ptr = node_create(addr);
|
||||
}
|
||||
if (n_ptr)
|
||||
node_add_router(n_ptr, router);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case SLAVE_ROUTING_TABLE:
|
||||
assert(!is_slave(tipc_own_addr));
|
||||
assert(in_own_cluster(c_ptr->addr));
|
||||
for (n_num = 1; n_num < table_size; n_num++) {
|
||||
if (node_table[n_num]) {
|
||||
u32 slave_num = n_num + LOWEST_SLAVE;
|
||||
u32 addr = tipc_addr(z_num, c_num, slave_num);
|
||||
n_ptr = c_ptr->nodes[slave_num];
|
||||
if (!n_ptr) {
|
||||
n_ptr = node_create(addr);
|
||||
}
|
||||
if (n_ptr)
|
||||
node_add_router(n_ptr, router);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case ROUTE_ADDITION:
|
||||
if (!is_slave(tipc_own_addr)) {
|
||||
assert(!in_own_cluster(c_ptr->addr)
|
||||
|| is_slave(rem_node));
|
||||
} else {
|
||||
assert(in_own_cluster(c_ptr->addr)
|
||||
&& !is_slave(rem_node));
|
||||
}
|
||||
n_ptr = c_ptr->nodes[tipc_node(rem_node)];
|
||||
if (!n_ptr)
|
||||
n_ptr = node_create(rem_node);
|
||||
if (n_ptr)
|
||||
node_add_router(n_ptr, router);
|
||||
break;
|
||||
case ROUTE_REMOVAL:
|
||||
if (!is_slave(tipc_own_addr)) {
|
||||
assert(!in_own_cluster(c_ptr->addr)
|
||||
|| is_slave(rem_node));
|
||||
} else {
|
||||
assert(in_own_cluster(c_ptr->addr)
|
||||
&& !is_slave(rem_node));
|
||||
}
|
||||
n_ptr = c_ptr->nodes[tipc_node(rem_node)];
|
||||
if (n_ptr)
|
||||
node_remove_router(n_ptr, router);
|
||||
break;
|
||||
default:
|
||||
assert(!"Illegal routing manager message received\n");
|
||||
}
|
||||
buf_discard(buf);
|
||||
}
|
||||
|
||||
void cluster_remove_as_router(struct cluster *c_ptr, u32 router)
|
||||
{
|
||||
u32 start_entry;
|
||||
u32 tstop;
|
||||
u32 n_num;
|
||||
|
||||
if (is_slave(router))
|
||||
return; /* Slave nodes can not be routers */
|
||||
|
||||
if (in_own_cluster(c_ptr->addr)) {
|
||||
start_entry = LOWEST_SLAVE;
|
||||
tstop = c_ptr->highest_slave;
|
||||
} else {
|
||||
start_entry = 1;
|
||||
tstop = c_ptr->highest_node;
|
||||
}
|
||||
|
||||
for (n_num = start_entry; n_num <= tstop; n_num++) {
|
||||
if (c_ptr->nodes[n_num]) {
|
||||
node_remove_router(c_ptr->nodes[n_num], router);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* cluster_multicast - multicast message to local nodes
|
||||
*/
|
||||
|
||||
void cluster_multicast(struct cluster *c_ptr, struct sk_buff *buf,
|
||||
u32 lower, u32 upper)
|
||||
{
|
||||
struct sk_buff *buf_copy;
|
||||
struct node *n_ptr;
|
||||
u32 n_num;
|
||||
u32 tstop;
|
||||
|
||||
assert(lower <= upper);
|
||||
assert(((lower >= 1) && (lower <= tipc_max_nodes)) ||
|
||||
((lower >= LOWEST_SLAVE) && (lower <= highest_allowed_slave)));
|
||||
assert(((upper >= 1) && (upper <= tipc_max_nodes)) ||
|
||||
((upper >= LOWEST_SLAVE) && (upper <= highest_allowed_slave)));
|
||||
assert(in_own_cluster(c_ptr->addr));
|
||||
|
||||
tstop = is_slave(upper) ? c_ptr->highest_slave : c_ptr->highest_node;
|
||||
if (tstop > upper)
|
||||
tstop = upper;
|
||||
for (n_num = lower; n_num <= tstop; n_num++) {
|
||||
n_ptr = c_ptr->nodes[n_num];
|
||||
if (n_ptr && node_has_active_links(n_ptr)) {
|
||||
buf_copy = skb_copy(buf, GFP_ATOMIC);
|
||||
if (buf_copy == NULL)
|
||||
break;
|
||||
msg_set_destnode(buf_msg(buf_copy), n_ptr->addr);
|
||||
link_send(buf_copy, n_ptr->addr, n_ptr->addr);
|
||||
}
|
||||
}
|
||||
buf_discard(buf);
|
||||
}
|
||||
|
||||
/**
|
||||
* cluster_broadcast - broadcast message to all nodes within cluster
|
||||
*/
|
||||
|
||||
void cluster_broadcast(struct sk_buff *buf)
|
||||
{
|
||||
struct sk_buff *buf_copy;
|
||||
struct cluster *c_ptr;
|
||||
struct node *n_ptr;
|
||||
u32 n_num;
|
||||
u32 tstart;
|
||||
u32 tstop;
|
||||
u32 node_type;
|
||||
|
||||
if (tipc_mode == TIPC_NET_MODE) {
|
||||
c_ptr = cluster_find(tipc_own_addr);
|
||||
assert(in_own_cluster(c_ptr->addr)); /* For now */
|
||||
|
||||
/* Send to standard nodes, then repeat loop sending to slaves */
|
||||
tstart = 1;
|
||||
tstop = c_ptr->highest_node;
|
||||
for (node_type = 1; node_type <= 2; node_type++) {
|
||||
for (n_num = tstart; n_num <= tstop; n_num++) {
|
||||
n_ptr = c_ptr->nodes[n_num];
|
||||
if (n_ptr && node_has_active_links(n_ptr)) {
|
||||
buf_copy = skb_copy(buf, GFP_ATOMIC);
|
||||
if (buf_copy == NULL)
|
||||
goto exit;
|
||||
msg_set_destnode(buf_msg(buf_copy),
|
||||
n_ptr->addr);
|
||||
link_send(buf_copy, n_ptr->addr,
|
||||
n_ptr->addr);
|
||||
}
|
||||
}
|
||||
tstart = LOWEST_SLAVE;
|
||||
tstop = c_ptr->highest_slave;
|
||||
}
|
||||
}
|
||||
exit:
|
||||
buf_discard(buf);
|
||||
}
|
||||
|
||||
int cluster_init(void)
|
||||
{
|
||||
highest_allowed_slave = LOWEST_SLAVE + tipc_max_slaves;
|
||||
return cluster_create(tipc_own_addr) ? TIPC_OK : -ENOMEM;
|
||||
}
|
||||
|
||||
89
net/tipc/cluster.h
Normal file
89
net/tipc/cluster.h
Normal file
|
|
@ -0,0 +1,89 @@
|
|||
/*
|
||||
* net/tipc/cluster.h: Include file for TIPC cluster management routines
|
||||
*
|
||||
* Copyright (c) 2003-2005, Ericsson Research Canada
|
||||
* Copyright (c) 2005, Wind River Systems
|
||||
* Copyright (c) 2005-2006, Ericsson AB
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
* list of conditions and the following disclaimer.
|
||||
* 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.
|
||||
* 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.
|
||||
*
|
||||
* 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 _TIPC_CLUSTER_H
|
||||
#define _TIPC_CLUSTER_H
|
||||
|
||||
#include "addr.h"
|
||||
#include "zone.h"
|
||||
|
||||
#define LOWEST_SLAVE 2048u
|
||||
|
||||
/**
|
||||
* struct cluster - TIPC cluster structure
|
||||
* @addr: network address of cluster
|
||||
* @owner: pointer to zone that cluster belongs to
|
||||
* @nodes: array of pointers to all nodes within cluster
|
||||
* @highest_node: id of highest numbered node within cluster
|
||||
* @highest_slave: (used for secondary node support)
|
||||
*/
|
||||
|
||||
struct cluster {
|
||||
u32 addr;
|
||||
struct _zone *owner;
|
||||
struct node **nodes;
|
||||
u32 highest_node;
|
||||
u32 highest_slave;
|
||||
};
|
||||
|
||||
|
||||
extern struct node **local_nodes;
|
||||
extern u32 highest_allowed_slave;
|
||||
extern struct node_map cluster_bcast_nodes;
|
||||
|
||||
void cluster_remove_as_router(struct cluster *c_ptr, u32 router);
|
||||
void cluster_send_ext_routes(struct cluster *c_ptr, u32 dest);
|
||||
struct node *cluster_select_node(struct cluster *c_ptr, u32 selector);
|
||||
u32 cluster_select_router(struct cluster *c_ptr, u32 ref);
|
||||
void cluster_recv_routing_table(struct sk_buff *buf);
|
||||
struct cluster *cluster_create(u32 addr);
|
||||
void cluster_delete(struct cluster *c_ptr);
|
||||
void cluster_attach_node(struct cluster *c_ptr, struct node *n_ptr);
|
||||
void cluster_send_slave_routes(struct cluster *c_ptr, u32 dest);
|
||||
void cluster_broadcast(struct sk_buff *buf);
|
||||
int cluster_init(void);
|
||||
u32 cluster_next_node(struct cluster *c_ptr, u32 addr);
|
||||
void cluster_bcast_new_route(struct cluster *c_ptr, u32 dest, u32 lo, u32 hi);
|
||||
void cluster_send_local_routes(struct cluster *c_ptr, u32 dest);
|
||||
void cluster_bcast_lost_route(struct cluster *c_ptr, u32 dest, u32 lo, u32 hi);
|
||||
|
||||
static inline struct cluster *cluster_find(u32 addr)
|
||||
{
|
||||
struct _zone *z_ptr = zone_find(addr);
|
||||
|
||||
if (z_ptr)
|
||||
return z_ptr->clusters[1];
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif
|
||||
715
net/tipc/config.c
Normal file
715
net/tipc/config.c
Normal file
|
|
@ -0,0 +1,715 @@
|
|||
/*
|
||||
* net/tipc/config.c: TIPC configuration management code
|
||||
*
|
||||
* Copyright (c) 2003-2005, Ericsson Research Canada
|
||||
* Copyright (c) 2004-2005, Wind River Systems
|
||||
* Copyright (c) 2005-2006, Ericsson AB
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
* list of conditions and the following disclaimer.
|
||||
* 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.
|
||||
* 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.
|
||||
*
|
||||
* 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 "dbg.h"
|
||||
#include "bearer.h"
|
||||
#include "port.h"
|
||||
#include "link.h"
|
||||
#include "zone.h"
|
||||
#include "addr.h"
|
||||
#include "name_table.h"
|
||||
#include "node.h"
|
||||
#include "config.h"
|
||||
#include "discover.h"
|
||||
|
||||
struct subscr_data {
|
||||
char usr_handle[8];
|
||||
u32 domain;
|
||||
u32 port_ref;
|
||||
struct list_head subd_list;
|
||||
};
|
||||
|
||||
struct manager {
|
||||
u32 user_ref;
|
||||
u32 port_ref;
|
||||
u32 subscr_ref;
|
||||
u32 link_subscriptions;
|
||||
struct list_head link_subscribers;
|
||||
};
|
||||
|
||||
static struct manager mng = { 0};
|
||||
|
||||
static spinlock_t config_lock = SPIN_LOCK_UNLOCKED;
|
||||
|
||||
static const void *req_tlv_area; /* request message TLV area */
|
||||
static int req_tlv_space; /* request message TLV area size */
|
||||
static int rep_headroom; /* reply message headroom to use */
|
||||
|
||||
|
||||
void cfg_link_event(u32 addr, char *name, int up)
|
||||
{
|
||||
/* TIPC DOESN'T HANDLE LINK EVENT SUBSCRIPTIONS AT THE MOMENT */
|
||||
}
|
||||
|
||||
|
||||
struct sk_buff *cfg_reply_alloc(int payload_size)
|
||||
{
|
||||
struct sk_buff *buf;
|
||||
|
||||
buf = alloc_skb(rep_headroom + payload_size, GFP_ATOMIC);
|
||||
if (buf)
|
||||
skb_reserve(buf, rep_headroom);
|
||||
return buf;
|
||||
}
|
||||
|
||||
int cfg_append_tlv(struct sk_buff *buf, int tlv_type,
|
||||
void *tlv_data, int tlv_data_size)
|
||||
{
|
||||
struct tlv_desc *tlv = (struct tlv_desc *)buf->tail;
|
||||
int new_tlv_space = TLV_SPACE(tlv_data_size);
|
||||
|
||||
if (skb_tailroom(buf) < new_tlv_space) {
|
||||
dbg("cfg_append_tlv unable to append TLV\n");
|
||||
return 0;
|
||||
}
|
||||
skb_put(buf, new_tlv_space);
|
||||
tlv->tlv_type = htons(tlv_type);
|
||||
tlv->tlv_len = htons(TLV_LENGTH(tlv_data_size));
|
||||
if (tlv_data_size && tlv_data)
|
||||
memcpy(TLV_DATA(tlv), tlv_data, tlv_data_size);
|
||||
return 1;
|
||||
}
|
||||
|
||||
struct sk_buff *cfg_reply_unsigned_type(u16 tlv_type, u32 value)
|
||||
{
|
||||
struct sk_buff *buf;
|
||||
u32 value_net;
|
||||
|
||||
buf = cfg_reply_alloc(TLV_SPACE(sizeof(value)));
|
||||
if (buf) {
|
||||
value_net = htonl(value);
|
||||
cfg_append_tlv(buf, tlv_type, &value_net,
|
||||
sizeof(value_net));
|
||||
}
|
||||
return buf;
|
||||
}
|
||||
|
||||
struct sk_buff *cfg_reply_string_type(u16 tlv_type, char *string)
|
||||
{
|
||||
struct sk_buff *buf;
|
||||
int string_len = strlen(string) + 1;
|
||||
|
||||
buf = cfg_reply_alloc(TLV_SPACE(string_len));
|
||||
if (buf)
|
||||
cfg_append_tlv(buf, tlv_type, string, string_len);
|
||||
return buf;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
#if 0
|
||||
|
||||
/* Now obsolete code for handling commands not yet implemented the new way */
|
||||
|
||||
int tipc_cfg_cmd(const struct tipc_cmd_msg * msg,
|
||||
char *data,
|
||||
u32 sz,
|
||||
u32 *ret_size,
|
||||
struct tipc_portid *orig)
|
||||
{
|
||||
int rv = -EINVAL;
|
||||
u32 cmd = msg->cmd;
|
||||
|
||||
*ret_size = 0;
|
||||
switch (cmd) {
|
||||
case TIPC_REMOVE_LINK:
|
||||
case TIPC_CMD_BLOCK_LINK:
|
||||
case TIPC_CMD_UNBLOCK_LINK:
|
||||
if (!cfg_check_connection(orig))
|
||||
rv = link_control(msg->argv.link_name, msg->cmd, 0);
|
||||
break;
|
||||
case TIPC_ESTABLISH:
|
||||
{
|
||||
int connected;
|
||||
|
||||
tipc_isconnected(mng.conn_port_ref, &connected);
|
||||
if (connected || !orig) {
|
||||
rv = TIPC_FAILURE;
|
||||
break;
|
||||
}
|
||||
rv = tipc_connect2port(mng.conn_port_ref, orig);
|
||||
if (rv == TIPC_OK)
|
||||
orig = 0;
|
||||
break;
|
||||
}
|
||||
case TIPC_GET_PEER_ADDRESS:
|
||||
*ret_size = link_peer_addr(msg->argv.link_name, data, sz);
|
||||
break;
|
||||
case TIPC_GET_ROUTES:
|
||||
rv = TIPC_OK;
|
||||
break;
|
||||
default: {}
|
||||
}
|
||||
if (*ret_size)
|
||||
rv = TIPC_OK;
|
||||
return rv;
|
||||
}
|
||||
|
||||
static void cfg_cmd_event(struct tipc_cmd_msg *msg,
|
||||
char *data,
|
||||
u32 sz,
|
||||
struct tipc_portid const *orig)
|
||||
{
|
||||
int rv = -EINVAL;
|
||||
struct tipc_cmd_result_msg rmsg;
|
||||
struct iovec msg_sect[2];
|
||||
int *arg;
|
||||
|
||||
msg->cmd = ntohl(msg->cmd);
|
||||
|
||||
cfg_prepare_res_msg(msg->cmd, msg->usr_handle, rv, &rmsg, msg_sect,
|
||||
data, 0);
|
||||
if (ntohl(msg->magic) != TIPC_MAGIC)
|
||||
goto exit;
|
||||
|
||||
switch (msg->cmd) {
|
||||
case TIPC_CREATE_LINK:
|
||||
if (!cfg_check_connection(orig))
|
||||
rv = disc_create_link(&msg->argv.create_link);
|
||||
break;
|
||||
case TIPC_LINK_SUBSCRIBE:
|
||||
{
|
||||
struct subscr_data *sub;
|
||||
|
||||
if (mng.link_subscriptions > 64)
|
||||
break;
|
||||
sub = (struct subscr_data *)kmalloc(sizeof(*sub),
|
||||
GFP_ATOMIC);
|
||||
if (sub == NULL) {
|
||||
warn("Memory squeeze; dropped remote link subscription\n");
|
||||
break;
|
||||
}
|
||||
INIT_LIST_HEAD(&sub->subd_list);
|
||||
tipc_createport(mng.user_ref,
|
||||
(void *)sub,
|
||||
TIPC_HIGH_IMPORTANCE,
|
||||
0,
|
||||
0,
|
||||
(tipc_conn_shutdown_event)cfg_linksubscr_cancel,
|
||||
0,
|
||||
0,
|
||||
(tipc_conn_msg_event)cfg_linksubscr_cancel,
|
||||
0,
|
||||
&sub->port_ref);
|
||||
if (!sub->port_ref) {
|
||||
kfree(sub);
|
||||
break;
|
||||
}
|
||||
memcpy(sub->usr_handle,msg->usr_handle,
|
||||
sizeof(sub->usr_handle));
|
||||
sub->domain = msg->argv.domain;
|
||||
list_add_tail(&sub->subd_list, &mng.link_subscribers);
|
||||
tipc_connect2port(sub->port_ref, orig);
|
||||
rmsg.retval = TIPC_OK;
|
||||
tipc_send(sub->port_ref, 2u, msg_sect);
|
||||
mng.link_subscriptions++;
|
||||
return;
|
||||
}
|
||||
default:
|
||||
rv = tipc_cfg_cmd(msg, data, sz, (u32 *)&msg_sect[1].iov_len, orig);
|
||||
}
|
||||
exit:
|
||||
rmsg.result_len = htonl(msg_sect[1].iov_len);
|
||||
rmsg.retval = htonl(rv);
|
||||
cfg_respond(msg_sect, 2u, orig);
|
||||
}
|
||||
#endif
|
||||
|
||||
static struct sk_buff *cfg_enable_bearer(void)
|
||||
{
|
||||
struct tipc_bearer_config *args;
|
||||
|
||||
if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_BEARER_CONFIG))
|
||||
return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
|
||||
|
||||
args = (struct tipc_bearer_config *)TLV_DATA(req_tlv_area);
|
||||
if (tipc_enable_bearer(args->name,
|
||||
ntohl(args->detect_scope),
|
||||
ntohl(args->priority)))
|
||||
return cfg_reply_error_string("unable to enable bearer");
|
||||
|
||||
return cfg_reply_none();
|
||||
}
|
||||
|
||||
static struct sk_buff *cfg_disable_bearer(void)
|
||||
{
|
||||
if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_BEARER_NAME))
|
||||
return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
|
||||
|
||||
if (tipc_disable_bearer((char *)TLV_DATA(req_tlv_area)))
|
||||
return cfg_reply_error_string("unable to disable bearer");
|
||||
|
||||
return cfg_reply_none();
|
||||
}
|
||||
|
||||
static struct sk_buff *cfg_set_own_addr(void)
|
||||
{
|
||||
u32 addr;
|
||||
|
||||
if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NET_ADDR))
|
||||
return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
|
||||
|
||||
addr = *(u32 *)TLV_DATA(req_tlv_area);
|
||||
addr = ntohl(addr);
|
||||
if (addr == tipc_own_addr)
|
||||
return cfg_reply_none();
|
||||
if (!addr_node_valid(addr))
|
||||
return cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
|
||||
" (node address)");
|
||||
if (tipc_own_addr)
|
||||
return cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
|
||||
" (cannot change node address once assigned)");
|
||||
|
||||
spin_unlock_bh(&config_lock);
|
||||
stop_net();
|
||||
tipc_own_addr = addr;
|
||||
start_net();
|
||||
spin_lock_bh(&config_lock);
|
||||
return cfg_reply_none();
|
||||
}
|
||||
|
||||
static struct sk_buff *cfg_set_remote_mng(void)
|
||||
{
|
||||
u32 value;
|
||||
|
||||
if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
|
||||
return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
|
||||
|
||||
value = *(u32 *)TLV_DATA(req_tlv_area);
|
||||
value = ntohl(value);
|
||||
tipc_remote_management = (value != 0);
|
||||
return cfg_reply_none();
|
||||
}
|
||||
|
||||
static struct sk_buff *cfg_set_max_publications(void)
|
||||
{
|
||||
u32 value;
|
||||
|
||||
if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
|
||||
return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
|
||||
|
||||
value = *(u32 *)TLV_DATA(req_tlv_area);
|
||||
value = ntohl(value);
|
||||
if (value != delimit(value, 1, 65535))
|
||||
return cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
|
||||
" (max publications must be 1-65535)");
|
||||
tipc_max_publications = value;
|
||||
return cfg_reply_none();
|
||||
}
|
||||
|
||||
static struct sk_buff *cfg_set_max_subscriptions(void)
|
||||
{
|
||||
u32 value;
|
||||
|
||||
if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
|
||||
return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
|
||||
|
||||
value = *(u32 *)TLV_DATA(req_tlv_area);
|
||||
value = ntohl(value);
|
||||
if (value != delimit(value, 1, 65535))
|
||||
return cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
|
||||
" (max subscriptions must be 1-65535");
|
||||
tipc_max_subscriptions = value;
|
||||
return cfg_reply_none();
|
||||
}
|
||||
|
||||
static struct sk_buff *cfg_set_max_ports(void)
|
||||
{
|
||||
int orig_mode;
|
||||
u32 value;
|
||||
|
||||
if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
|
||||
return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
|
||||
value = *(u32 *)TLV_DATA(req_tlv_area);
|
||||
value = ntohl(value);
|
||||
if (value != delimit(value, 127, 65535))
|
||||
return cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
|
||||
" (max ports must be 127-65535)");
|
||||
|
||||
if (value == tipc_max_ports)
|
||||
return cfg_reply_none();
|
||||
|
||||
if (atomic_read(&tipc_user_count) > 2)
|
||||
return cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
|
||||
" (cannot change max ports while TIPC users exist)");
|
||||
|
||||
spin_unlock_bh(&config_lock);
|
||||
orig_mode = tipc_get_mode();
|
||||
if (orig_mode == TIPC_NET_MODE)
|
||||
stop_net();
|
||||
stop_core();
|
||||
tipc_max_ports = value;
|
||||
start_core();
|
||||
if (orig_mode == TIPC_NET_MODE)
|
||||
start_net();
|
||||
spin_lock_bh(&config_lock);
|
||||
return cfg_reply_none();
|
||||
}
|
||||
|
||||
static struct sk_buff *set_net_max(int value, int *parameter)
|
||||
{
|
||||
int orig_mode;
|
||||
|
||||
if (value != *parameter) {
|
||||
orig_mode = tipc_get_mode();
|
||||
if (orig_mode == TIPC_NET_MODE)
|
||||
stop_net();
|
||||
*parameter = value;
|
||||
if (orig_mode == TIPC_NET_MODE)
|
||||
start_net();
|
||||
}
|
||||
|
||||
return cfg_reply_none();
|
||||
}
|
||||
|
||||
static struct sk_buff *cfg_set_max_zones(void)
|
||||
{
|
||||
u32 value;
|
||||
|
||||
if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
|
||||
return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
|
||||
value = *(u32 *)TLV_DATA(req_tlv_area);
|
||||
value = ntohl(value);
|
||||
if (value != delimit(value, 1, 255))
|
||||
return cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
|
||||
" (max zones must be 1-255)");
|
||||
return set_net_max(value, &tipc_max_zones);
|
||||
}
|
||||
|
||||
static struct sk_buff *cfg_set_max_clusters(void)
|
||||
{
|
||||
u32 value;
|
||||
|
||||
if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
|
||||
return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
|
||||
value = *(u32 *)TLV_DATA(req_tlv_area);
|
||||
value = ntohl(value);
|
||||
if (value != 1)
|
||||
return cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
|
||||
" (max clusters fixed at 1)");
|
||||
return cfg_reply_none();
|
||||
}
|
||||
|
||||
static struct sk_buff *cfg_set_max_nodes(void)
|
||||
{
|
||||
u32 value;
|
||||
|
||||
if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
|
||||
return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
|
||||
value = *(u32 *)TLV_DATA(req_tlv_area);
|
||||
value = ntohl(value);
|
||||
if (value != delimit(value, 8, 2047))
|
||||
return cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
|
||||
" (max nodes must be 8-2047)");
|
||||
return set_net_max(value, &tipc_max_nodes);
|
||||
}
|
||||
|
||||
static struct sk_buff *cfg_set_max_slaves(void)
|
||||
{
|
||||
u32 value;
|
||||
|
||||
if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
|
||||
return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
|
||||
value = *(u32 *)TLV_DATA(req_tlv_area);
|
||||
value = ntohl(value);
|
||||
if (value != 0)
|
||||
return cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
|
||||
" (max secondary nodes fixed at 0)");
|
||||
return cfg_reply_none();
|
||||
}
|
||||
|
||||
static struct sk_buff *cfg_set_netid(void)
|
||||
{
|
||||
u32 value;
|
||||
|
||||
if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
|
||||
return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
|
||||
value = *(u32 *)TLV_DATA(req_tlv_area);
|
||||
value = ntohl(value);
|
||||
if (value != delimit(value, 1, 9999))
|
||||
return cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
|
||||
" (network id must be 1-9999)");
|
||||
|
||||
if (tipc_own_addr)
|
||||
return cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
|
||||
" (cannot change network id once part of network)");
|
||||
|
||||
return set_net_max(value, &tipc_net_id);
|
||||
}
|
||||
|
||||
struct sk_buff *cfg_do_cmd(u32 orig_node, u16 cmd, const void *request_area,
|
||||
int request_space, int reply_headroom)
|
||||
{
|
||||
struct sk_buff *rep_tlv_buf;
|
||||
|
||||
spin_lock_bh(&config_lock);
|
||||
|
||||
/* Save request and reply details in a well-known location */
|
||||
|
||||
req_tlv_area = request_area;
|
||||
req_tlv_space = request_space;
|
||||
rep_headroom = reply_headroom;
|
||||
|
||||
/* Check command authorization */
|
||||
|
||||
if (likely(orig_node == tipc_own_addr)) {
|
||||
/* command is permitted */
|
||||
} else if (cmd >= 0x8000) {
|
||||
rep_tlv_buf = cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
|
||||
" (cannot be done remotely)");
|
||||
goto exit;
|
||||
} else if (!tipc_remote_management) {
|
||||
rep_tlv_buf = cfg_reply_error_string(TIPC_CFG_NO_REMOTE);
|
||||
goto exit;
|
||||
}
|
||||
else if (cmd >= 0x4000) {
|
||||
u32 domain = 0;
|
||||
|
||||
if ((nametbl_translate(TIPC_ZM_SRV, 0, &domain) == 0) ||
|
||||
(domain != orig_node)) {
|
||||
rep_tlv_buf = cfg_reply_error_string(TIPC_CFG_NOT_ZONE_MSTR);
|
||||
goto exit;
|
||||
}
|
||||
}
|
||||
|
||||
/* Call appropriate processing routine */
|
||||
|
||||
switch (cmd) {
|
||||
case TIPC_CMD_NOOP:
|
||||
rep_tlv_buf = cfg_reply_none();
|
||||
break;
|
||||
case TIPC_CMD_GET_NODES:
|
||||
rep_tlv_buf = node_get_nodes(req_tlv_area, req_tlv_space);
|
||||
break;
|
||||
case TIPC_CMD_GET_LINKS:
|
||||
rep_tlv_buf = node_get_links(req_tlv_area, req_tlv_space);
|
||||
break;
|
||||
case TIPC_CMD_SHOW_LINK_STATS:
|
||||
rep_tlv_buf = link_cmd_show_stats(req_tlv_area, req_tlv_space);
|
||||
break;
|
||||
case TIPC_CMD_RESET_LINK_STATS:
|
||||
rep_tlv_buf = link_cmd_reset_stats(req_tlv_area, req_tlv_space);
|
||||
break;
|
||||
case TIPC_CMD_SHOW_NAME_TABLE:
|
||||
rep_tlv_buf = nametbl_get(req_tlv_area, req_tlv_space);
|
||||
break;
|
||||
case TIPC_CMD_GET_BEARER_NAMES:
|
||||
rep_tlv_buf = bearer_get_names();
|
||||
break;
|
||||
case TIPC_CMD_GET_MEDIA_NAMES:
|
||||
rep_tlv_buf = media_get_names();
|
||||
break;
|
||||
case TIPC_CMD_SHOW_PORTS:
|
||||
rep_tlv_buf = port_get_ports();
|
||||
break;
|
||||
#if 0
|
||||
case TIPC_CMD_SHOW_PORT_STATS:
|
||||
rep_tlv_buf = port_show_stats(req_tlv_area, req_tlv_space);
|
||||
break;
|
||||
case TIPC_CMD_RESET_PORT_STATS:
|
||||
rep_tlv_buf = cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED);
|
||||
break;
|
||||
#endif
|
||||
case TIPC_CMD_SET_LOG_SIZE:
|
||||
rep_tlv_buf = log_resize(req_tlv_area, req_tlv_space);
|
||||
break;
|
||||
case TIPC_CMD_DUMP_LOG:
|
||||
rep_tlv_buf = log_dump();
|
||||
break;
|
||||
case TIPC_CMD_SET_LINK_TOL:
|
||||
case TIPC_CMD_SET_LINK_PRI:
|
||||
case TIPC_CMD_SET_LINK_WINDOW:
|
||||
rep_tlv_buf = link_cmd_config(req_tlv_area, req_tlv_space, cmd);
|
||||
break;
|
||||
case TIPC_CMD_ENABLE_BEARER:
|
||||
rep_tlv_buf = cfg_enable_bearer();
|
||||
break;
|
||||
case TIPC_CMD_DISABLE_BEARER:
|
||||
rep_tlv_buf = cfg_disable_bearer();
|
||||
break;
|
||||
case TIPC_CMD_SET_NODE_ADDR:
|
||||
rep_tlv_buf = cfg_set_own_addr();
|
||||
break;
|
||||
case TIPC_CMD_SET_REMOTE_MNG:
|
||||
rep_tlv_buf = cfg_set_remote_mng();
|
||||
break;
|
||||
case TIPC_CMD_SET_MAX_PORTS:
|
||||
rep_tlv_buf = cfg_set_max_ports();
|
||||
break;
|
||||
case TIPC_CMD_SET_MAX_PUBL:
|
||||
rep_tlv_buf = cfg_set_max_publications();
|
||||
break;
|
||||
case TIPC_CMD_SET_MAX_SUBSCR:
|
||||
rep_tlv_buf = cfg_set_max_subscriptions();
|
||||
break;
|
||||
case TIPC_CMD_SET_MAX_ZONES:
|
||||
rep_tlv_buf = cfg_set_max_zones();
|
||||
break;
|
||||
case TIPC_CMD_SET_MAX_CLUSTERS:
|
||||
rep_tlv_buf = cfg_set_max_clusters();
|
||||
break;
|
||||
case TIPC_CMD_SET_MAX_NODES:
|
||||
rep_tlv_buf = cfg_set_max_nodes();
|
||||
break;
|
||||
case TIPC_CMD_SET_MAX_SLAVES:
|
||||
rep_tlv_buf = cfg_set_max_slaves();
|
||||
break;
|
||||
case TIPC_CMD_SET_NETID:
|
||||
rep_tlv_buf = cfg_set_netid();
|
||||
break;
|
||||
case TIPC_CMD_GET_REMOTE_MNG:
|
||||
rep_tlv_buf = cfg_reply_unsigned(tipc_remote_management);
|
||||
break;
|
||||
case TIPC_CMD_GET_MAX_PORTS:
|
||||
rep_tlv_buf = cfg_reply_unsigned(tipc_max_ports);
|
||||
break;
|
||||
case TIPC_CMD_GET_MAX_PUBL:
|
||||
rep_tlv_buf = cfg_reply_unsigned(tipc_max_publications);
|
||||
break;
|
||||
case TIPC_CMD_GET_MAX_SUBSCR:
|
||||
rep_tlv_buf = cfg_reply_unsigned(tipc_max_subscriptions);
|
||||
break;
|
||||
case TIPC_CMD_GET_MAX_ZONES:
|
||||
rep_tlv_buf = cfg_reply_unsigned(tipc_max_zones);
|
||||
break;
|
||||
case TIPC_CMD_GET_MAX_CLUSTERS:
|
||||
rep_tlv_buf = cfg_reply_unsigned(tipc_max_clusters);
|
||||
break;
|
||||
case TIPC_CMD_GET_MAX_NODES:
|
||||
rep_tlv_buf = cfg_reply_unsigned(tipc_max_nodes);
|
||||
break;
|
||||
case TIPC_CMD_GET_MAX_SLAVES:
|
||||
rep_tlv_buf = cfg_reply_unsigned(tipc_max_slaves);
|
||||
break;
|
||||
case TIPC_CMD_GET_NETID:
|
||||
rep_tlv_buf = cfg_reply_unsigned(tipc_net_id);
|
||||
break;
|
||||
default:
|
||||
rep_tlv_buf = NULL;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Return reply buffer */
|
||||
exit:
|
||||
spin_unlock_bh(&config_lock);
|
||||
return rep_tlv_buf;
|
||||
}
|
||||
|
||||
static void cfg_named_msg_event(void *userdata,
|
||||
u32 port_ref,
|
||||
struct sk_buff **buf,
|
||||
const unchar *msg,
|
||||
u32 size,
|
||||
u32 importance,
|
||||
struct tipc_portid const *orig,
|
||||
struct tipc_name_seq const *dest)
|
||||
{
|
||||
struct tipc_cfg_msg_hdr *req_hdr;
|
||||
struct tipc_cfg_msg_hdr *rep_hdr;
|
||||
struct sk_buff *rep_buf;
|
||||
|
||||
/* Validate configuration message header (ignore invalid message) */
|
||||
|
||||
req_hdr = (struct tipc_cfg_msg_hdr *)msg;
|
||||
if ((size < sizeof(*req_hdr)) ||
|
||||
(size != TCM_ALIGN(ntohl(req_hdr->tcm_len))) ||
|
||||
(ntohs(req_hdr->tcm_flags) != TCM_F_REQUEST)) {
|
||||
warn("discarded invalid configuration message\n");
|
||||
return;
|
||||
}
|
||||
|
||||
/* Generate reply for request (if can't, return request) */
|
||||
|
||||
rep_buf = cfg_do_cmd(orig->node,
|
||||
ntohs(req_hdr->tcm_type),
|
||||
msg + sizeof(*req_hdr),
|
||||
size - sizeof(*req_hdr),
|
||||
BUF_HEADROOM + MAX_H_SIZE + sizeof(*rep_hdr));
|
||||
if (rep_buf) {
|
||||
skb_push(rep_buf, sizeof(*rep_hdr));
|
||||
rep_hdr = (struct tipc_cfg_msg_hdr *)rep_buf->data;
|
||||
memcpy(rep_hdr, req_hdr, sizeof(*rep_hdr));
|
||||
rep_hdr->tcm_len = htonl(rep_buf->len);
|
||||
rep_hdr->tcm_flags &= htons(~TCM_F_REQUEST);
|
||||
} else {
|
||||
rep_buf = *buf;
|
||||
*buf = NULL;
|
||||
}
|
||||
|
||||
/* NEED TO ADD CODE TO HANDLE FAILED SEND (SUCH AS CONGESTION) */
|
||||
tipc_send_buf2port(port_ref, orig, rep_buf, rep_buf->len);
|
||||
}
|
||||
|
||||
int cfg_init(void)
|
||||
{
|
||||
struct tipc_name_seq seq;
|
||||
int res;
|
||||
|
||||
memset(&mng, 0, sizeof(mng));
|
||||
INIT_LIST_HEAD(&mng.link_subscribers);
|
||||
|
||||
res = tipc_attach(&mng.user_ref, 0, 0);
|
||||
if (res)
|
||||
goto failed;
|
||||
|
||||
res = tipc_createport(mng.user_ref, 0, TIPC_CRITICAL_IMPORTANCE,
|
||||
NULL, NULL, NULL,
|
||||
NULL, cfg_named_msg_event, NULL,
|
||||
NULL, &mng.port_ref);
|
||||
if (res)
|
||||
goto failed;
|
||||
|
||||
seq.type = TIPC_CFG_SRV;
|
||||
seq.lower = seq.upper = tipc_own_addr;
|
||||
res = nametbl_publish_rsv(mng.port_ref, TIPC_ZONE_SCOPE, &seq);
|
||||
if (res)
|
||||
goto failed;
|
||||
|
||||
return 0;
|
||||
|
||||
failed:
|
||||
err("Unable to create configuration service\n");
|
||||
tipc_detach(mng.user_ref);
|
||||
mng.user_ref = 0;
|
||||
return res;
|
||||
}
|
||||
|
||||
void cfg_stop(void)
|
||||
{
|
||||
if (mng.user_ref) {
|
||||
tipc_detach(mng.user_ref);
|
||||
mng.user_ref = 0;
|
||||
}
|
||||
}
|
||||
76
net/tipc/config.h
Normal file
76
net/tipc/config.h
Normal file
|
|
@ -0,0 +1,76 @@
|
|||
/*
|
||||
* net/tipc/config.h: Include file for TIPC configuration service code
|
||||
*
|
||||
* Copyright (c) 2003-2005, Ericsson Research Canada
|
||||
* Copyright (c) 2005, Wind River Systems
|
||||
* Copyright (c) 2005-2006, Ericsson AB
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
* list of conditions and the following disclaimer.
|
||||
* 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.
|
||||
* 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.
|
||||
*
|
||||
* 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 _TIPC_CONFIG_H
|
||||
#define _TIPC_CONFIG_H
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
#include <linux/tipc.h>
|
||||
#include "link.h"
|
||||
|
||||
struct sk_buff *cfg_reply_alloc(int payload_size);
|
||||
int cfg_append_tlv(struct sk_buff *buf, int tlv_type,
|
||||
void *tlv_data, int tlv_data_size);
|
||||
struct sk_buff *cfg_reply_unsigned_type(u16 tlv_type, u32 value);
|
||||
struct sk_buff *cfg_reply_string_type(u16 tlv_type, char *string);
|
||||
|
||||
static inline struct sk_buff *cfg_reply_none(void)
|
||||
{
|
||||
return cfg_reply_alloc(0);
|
||||
}
|
||||
|
||||
static inline struct sk_buff *cfg_reply_unsigned(u32 value)
|
||||
{
|
||||
return cfg_reply_unsigned_type(TIPC_TLV_UNSIGNED, value);
|
||||
}
|
||||
|
||||
static inline struct sk_buff *cfg_reply_error_string(char *string)
|
||||
{
|
||||
return cfg_reply_string_type(TIPC_TLV_ERROR_STRING, string);
|
||||
}
|
||||
|
||||
static inline struct sk_buff *cfg_reply_ultra_string(char *string)
|
||||
{
|
||||
return cfg_reply_string_type(TIPC_TLV_ULTRA_STRING, string);
|
||||
}
|
||||
|
||||
struct sk_buff *cfg_do_cmd(u32 orig_node, u16 cmd,
|
||||
const void *req_tlv_area, int req_tlv_space,
|
||||
int headroom);
|
||||
|
||||
void cfg_link_event(u32 addr, char *name, int up);
|
||||
int cfg_init(void);
|
||||
void cfg_stop(void);
|
||||
|
||||
#endif
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue