Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 51a8e4de authored by Allan Stephens's avatar Allan Stephens Committed by David S. Miller
Browse files

tipc: Remove prototype code for supporting inter-cluster routing 



Eliminates routines and data structures that were intended to allow
TIPC to route messages to other clusters. Currently, TIPC supports only
networks consisting of a single cluster within a single zone, so this
code is unnecessary.

Signed-off-by: default avatarAllan Stephens <Allan.Stephens@windriver.com>
Signed-off-by: default avatarPaul Gortmaker <paul.gortmaker@windriver.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 08c80e9a

include/linux/tipc_config.h

+0 −5
Original line number Diff line number Diff line
@@ -254,11 +254,6 @@ struct tipc_link_create { 
	struct tipc_media_addr peer_addr;

	char bearer_name[TIPC_MAX_BEARER_NAME];

};



struct tipc_route_info {

	__u32 dest;

	__u32 router;

};

#endif



/*

net/tipc/addr.h

+0 −15
Original line number Diff line number Diff line
@@ -37,21 +37,6 @@ 
#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);

net/tipc/cluster.c

+1 −278
Original line number Diff line number Diff line
@@ -38,9 +38,6 @@ 
#include "cluster.h"

#include "link.h"



static void tipc_cltr_multicast(struct cluster *c_ptr, struct sk_buff *buf,

				u32 lower, u32 upper);



struct tipc_node **tipc_local_nodes = NULL;

struct tipc_node_map tipc_cltr_bcast_nodes = {0,{0,}};
@@ -65,7 +62,6 @@ struct cluster *tipc_cltr_create(u32 addr) 
		return NULL;

	}



	if (in_own_cluster(addr))

	tipc_local_nodes = c_ptr->nodes;

	c_ptr->highest_node = 0;
@@ -100,278 +96,6 @@ void tipc_cltr_attach_node(struct cluster *c_ptr, struct tipc_node *n_ptr) 
		c_ptr->highest_node = n_num;

}



/**

 * tipc_cltr_select_router - select router to a cluster

 *

 * Uses deterministic and fair algorithm.

 */



u32 tipc_cltr_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 (tipc_node_is_up(c_ptr->nodes[n_num]))

			break;

	} while (++n_num <= ulim);

	if (n_num > ulim) {

		n_num = 1;

		do {

			if (tipc_node_is_up(c_ptr->nodes[n_num]))

				break;

		} while (++n_num < tstart);

		if (n_num == tstart)

			return 0;

	}

	assert(n_num <= ulim);

	return tipc_node_select_router(c_ptr->nodes[n_num], ref);

}



/**

 * tipc_cltr_select_node - select destination node within a remote cluster

 *

 * Uses deterministic and fair algorithm.

 */



struct tipc_node *tipc_cltr_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 NULL;



	/* 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 (tipc_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 (tipc_node_has_active_links(c_ptr->nodes[n_num]))

			return c_ptr->nodes[n_num];

	}

	return NULL;

}



/*

 *    Routing table management: See description in node.c

 */



static struct sk_buff *tipc_cltr_prepare_routing_msg(u32 data_size, u32 dest)

{

	u32 size = INT_H_SIZE + data_size;

	struct sk_buff *buf = tipc_buf_acquire(size);

	struct tipc_msg *msg;



	if (buf) {

		msg = buf_msg(buf);

		memset((char *)msg, 0, size);

		tipc_msg_init(msg, ROUTE_DISTRIBUTOR, 0, INT_H_SIZE, dest);

	}

	return buf;

}



void tipc_cltr_bcast_new_route(struct cluster *c_ptr, u32 dest,

			     u32 lower, u32 upper)

{

	struct sk_buff *buf = tipc_cltr_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);

		tipc_cltr_multicast(c_ptr, buf, lower, upper);

	} else {

		warn("Memory squeeze: broadcast of new route failed\n");

	}

}



void tipc_cltr_bcast_lost_route(struct cluster *c_ptr, u32 dest,

				u32 lower, u32 upper)

{

	struct sk_buff *buf = tipc_cltr_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);

		tipc_cltr_multicast(c_ptr, buf, lower, upper);

	} else {

		warn("Memory squeeze: broadcast of lost route failed\n");

	}

}



void tipc_cltr_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(in_own_cluster(dest));

	highest = c_ptr->highest_node;

	buf = tipc_cltr_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] &&

			    tipc_node_has_active_links(c_ptr->nodes[n_num])) {

				send = 1;

				msg_set_dataoctet(msg, n_num);

			}

		}

		if (send)

			tipc_link_send(buf, dest, dest);

		else

			buf_discard(buf);

	} else {

		warn("Memory squeeze: broadcast of external route failed\n");

	}

}



void tipc_cltr_recv_routing_table(struct sk_buff *buf)

{

	struct tipc_msg *msg = buf_msg(buf);

	struct cluster *c_ptr;

	struct tipc_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 = tipc_cltr_find(rem_node);

	if (!c_ptr) {

		c_ptr = tipc_cltr_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 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 = tipc_node_create(addr);

				}

				if (n_ptr)

					tipc_node_add_router(n_ptr, router);

			}

		}

		break;

	case SLAVE_ROUTING_TABLE:

		assert(in_own_cluster(c_ptr->addr));

		break;

	case ROUTE_ADDITION:

		assert(!in_own_cluster(c_ptr->addr));

		n_ptr = c_ptr->nodes[tipc_node(rem_node)];

		if (!n_ptr)

			n_ptr = tipc_node_create(rem_node);

		if (n_ptr)

			tipc_node_add_router(n_ptr, router);

		break;

	case ROUTE_REMOVAL:

		assert(!in_own_cluster(c_ptr->addr));

		n_ptr = c_ptr->nodes[tipc_node(rem_node)];

		if (n_ptr)

			tipc_node_remove_router(n_ptr, router);

		break;

	default:

		assert(!"Illegal routing manager message received\n");

	}

	buf_discard(buf);

}



void tipc_cltr_remove_as_router(struct cluster *c_ptr, u32 router)

{

	u32 n_num;



	if (in_own_cluster(c_ptr->addr))

		return;



	for (n_num = 1; n_num <= c_ptr->highest_node; n_num++) {

		if (c_ptr->nodes[n_num]) {

			tipc_node_remove_router(c_ptr->nodes[n_num], router);

		}

	}

}



/**

 * tipc_cltr_multicast - multicast message to local nodes

 */



static void tipc_cltr_multicast(struct cluster *c_ptr, struct sk_buff *buf,

			 u32 lower, u32 upper)

{

	struct sk_buff *buf_copy;

	struct tipc_node *n_ptr;

	u32 n_num;

	u32 tstop;



	assert(lower <= upper);

	assert((lower >= 1) && (lower <= tipc_max_nodes));

	assert((upper >= 1) && (upper <= tipc_max_nodes));

	assert(in_own_cluster(c_ptr->addr));



	tstop = 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 && tipc_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);

			tipc_link_send(buf_copy, n_ptr->addr, n_ptr->addr);

		}

	}

	buf_discard(buf);

}



/**

 * tipc_cltr_broadcast - broadcast message to all nodes within cluster

 */
@@ -385,7 +109,6 @@ void tipc_cltr_broadcast(struct sk_buff *buf) 


	if (tipc_mode == TIPC_NET_MODE) {

		c_ptr = tipc_cltr_find(tipc_own_addr);

		assert(in_own_cluster(c_ptr->addr));	/* For now */



		/* Send to nodes */

		for (n_num = 1; n_num <= c_ptr->highest_node; n_num++) {

net/tipc/cluster.h

+0 −8
Original line number Diff line number Diff line
@@ -57,20 +57,12 @@ struct cluster { 
extern struct tipc_node **tipc_local_nodes;

extern struct tipc_node_map tipc_cltr_bcast_nodes;



void tipc_cltr_remove_as_router(struct cluster *c_ptr, u32 router);

void tipc_cltr_send_ext_routes(struct cluster *c_ptr, u32 dest);

struct tipc_node *tipc_cltr_select_node(struct cluster *c_ptr, u32 selector);

u32 tipc_cltr_select_router(struct cluster *c_ptr, u32 ref);

void tipc_cltr_recv_routing_table(struct sk_buff *buf);

struct cluster *tipc_cltr_create(u32 addr);

void tipc_cltr_delete(struct cluster *c_ptr);

void tipc_cltr_attach_node(struct cluster *c_ptr, struct tipc_node *n_ptr);

void tipc_cltr_broadcast(struct sk_buff *buf);

int tipc_cltr_init(void);



void tipc_cltr_bcast_new_route(struct cluster *c_ptr, u32 dest, u32 lo, u32 hi);

void tipc_cltr_bcast_lost_route(struct cluster *c_ptr, u32 dest, u32 lo, u32 hi);



static inline struct cluster *tipc_cltr_find(u32 addr)

{

	if (!in_own_cluster(addr))

net/tipc/link.c

+6 −7
Original line number Diff line number Diff line
@@ -1061,7 +1061,7 @@ int tipc_link_send(struct sk_buff *buf, u32 dest, u32 selector) 
	int res = -ELINKCONG;



	read_lock_bh(&tipc_net_lock);

	n_ptr = tipc_node_select(dest, selector);

	n_ptr = tipc_node_find(dest);

	if (n_ptr) {

		tipc_node_lock(n_ptr);

		l_ptr = n_ptr->active_links[selector & 1];
@@ -1137,7 +1137,7 @@ int tipc_send_buf_fast(struct sk_buff *buf, u32 destnode) 
		return tipc_port_recv_msg(buf);



	read_lock_bh(&tipc_net_lock);

	n_ptr = tipc_node_select(destnode, selector);

	n_ptr = tipc_node_find(destnode);

	if (likely(n_ptr)) {

		tipc_node_lock(n_ptr);

		l_ptr = n_ptr->active_links[selector];
@@ -1186,7 +1186,7 @@ int tipc_link_send_sections_fast(struct port *sender, 
			!sender->user_port, &buf);



	read_lock_bh(&tipc_net_lock);

	node = tipc_node_select(destaddr, selector);

	node = tipc_node_find(destaddr);

	if (likely(node)) {

		tipc_node_lock(node);

		l_ptr = node->active_links[selector];
@@ -1376,7 +1376,7 @@ static int link_send_sections_long(struct port *sender, 
	 * Now we have a buffer chain. Select a link and check

	 * that packet size is still OK

	 */

	node = tipc_node_select(destaddr, sender->publ.ref & 1);

	node = tipc_node_find(destaddr);

	if (likely(node)) {

		tipc_node_lock(node);

		l_ptr = node->active_links[sender->publ.ref & 1];
@@ -1893,7 +1893,7 @@ void tipc_recv_msg(struct sk_buff *head, struct tipc_bearer *tb_ptr) 
						continue;

					case ROUTE_DISTRIBUTOR:

						tipc_node_unlock(n_ptr);

						tipc_cltr_recv_routing_table(buf);

						buf_discard(buf);

						continue;

					case NAME_DISTRIBUTOR:

						tipc_node_unlock(n_ptr);
@@ -2852,7 +2852,6 @@ void tipc_link_set_queue_limits(struct link *l_ptr, u32 window) 
	l_ptr->queue_limit[TIPC_HIGH_IMPORTANCE + 4] = 900;

	l_ptr->queue_limit[TIPC_CRITICAL_IMPORTANCE + 4] = 1200;

	l_ptr->queue_limit[CONN_MANAGER] = 1200;

	l_ptr->queue_limit[ROUTE_DISTRIBUTOR] = 1200;

	l_ptr->queue_limit[CHANGEOVER_PROTOCOL] = 2500;

	l_ptr->queue_limit[NAME_DISTRIBUTOR] = 3000;

	/* FRAGMENT and LAST_FRAGMENT packets */
@@ -3154,7 +3153,7 @@ u32 tipc_link_get_max_pkt(u32 dest, u32 selector) 
		return MAX_MSG_SIZE;



	read_lock_bh(&tipc_net_lock);

	n_ptr = tipc_node_select(dest, selector);

	n_ptr = tipc_node_find(dest);

	if (n_ptr) {

		tipc_node_lock(n_ptr);

		l_ptr = n_ptr->active_links[selector & 1];