Commit 4323add6 authored by Per Liden's avatar Per Liden
Browse files

[TIPC] Avoid polluting the global namespace



This patch adds a tipc_ prefix to all externally visible symbols.
Signed-off-by: default avatarPer Liden <per.liden@ericsson.com>
parent 1e63e681
......@@ -47,7 +47,7 @@ u32 tipc_get_addr(void)
}
/**
* addr_domain_valid - validates a network domain address
* tipc_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.
......@@ -55,7 +55,7 @@ u32 tipc_get_addr(void)
* Returns 1 if domain address is valid, otherwise 0
*/
int addr_domain_valid(u32 addr)
int tipc_addr_domain_valid(u32 addr)
{
u32 n = tipc_node(addr);
u32 c = tipc_cluster(addr);
......@@ -79,7 +79,7 @@ int addr_domain_valid(u32 addr)
}
/**
* addr_node_valid - validates a proposed network address for this node
* tipc_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.
......@@ -87,8 +87,8 @@ int addr_domain_valid(u32 addr)
* Returns 1 if address can be used, otherwise 0
*/
int addr_node_valid(u32 addr)
int tipc_addr_node_valid(u32 addr)
{
return (addr_domain_valid(addr) && tipc_node(addr));
return (tipc_addr_domain_valid(addr) && tipc_node(addr));
}
......@@ -122,7 +122,7 @@ static inline char *addr_string_fill(char *string, u32 addr)
return string;
}
int addr_domain_valid(u32);
int addr_node_valid(u32 addr);
int tipc_addr_domain_valid(u32);
int tipc_addr_node_valid(u32 addr);
#endif
......@@ -104,7 +104,7 @@ static struct bclink *bclink = NULL;
static struct link *bcl = NULL;
static spinlock_t bc_lock = SPIN_LOCK_UNLOCKED;
char bc_link_name[] = "multicast-link";
char tipc_bclink_name[] = "multicast-link";
static inline u32 buf_seqno(struct sk_buff *buf)
......@@ -178,19 +178,19 @@ static void bclink_retransmit_pkt(u32 after, u32 to)
buf = buf->next;
}
if (buf != NULL)
link_retransmit(bcl, buf, mod(to - after));
tipc_link_retransmit(bcl, buf, mod(to - after));
spin_unlock_bh(&bc_lock);
}
/**
* bclink_acknowledge - handle acknowledgement of broadcast packets
* tipc_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)
void tipc_bclink_acknowledge(struct node *n_ptr, u32 acked)
{
struct sk_buff *crs;
struct sk_buff *next;
......@@ -226,16 +226,16 @@ void bclink_acknowledge(struct node *n_ptr, u32 acked)
/* Try resolving broadcast link congestion, if necessary */
if (unlikely(bcl->next_out))
link_push_queue(bcl);
tipc_link_push_queue(bcl);
if (unlikely(released && !list_empty(&bcl->waiting_ports)))
link_wakeup_ports(bcl, 0);
tipc_link_wakeup_ports(bcl, 0);
spin_unlock_bh(&bc_lock);
}
/**
* bclink_send_ack - unicast an ACK msg
*
* net_lock and node lock set
* tipc_net_lock and node lock set
*/
static void bclink_send_ack(struct node *n_ptr)
......@@ -243,13 +243,13 @@ 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);
tipc_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
* tipc_net_lock and node lock set
*/
static void bclink_send_nack(struct node *n_ptr)
......@@ -271,11 +271,11 @@ static void bclink_send_nack(struct node *n_ptr)
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)) {
if (tipc_bearer_send(&bcbearer->bearer, buf, 0)) {
bcl->stats.sent_nacks++;
buf_discard(buf);
} else {
bearer_schedule(bcl->b_ptr, bcl);
tipc_bearer_schedule(bcl->b_ptr, bcl);
bcl->proto_msg_queue = buf;
bcl->stats.bearer_congs++;
}
......@@ -291,12 +291,12 @@ static void bclink_send_nack(struct node *n_ptr)
}
/**
* bclink_check_gap - send a NACK if a sequence gap exists
* tipc_bclink_check_gap - send a NACK if a sequence gap exists
*
* net_lock and node lock set
* tipc_net_lock and node lock set
*/
void bclink_check_gap(struct node *n_ptr, u32 last_sent)
void tipc_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)))
......@@ -309,19 +309,19 @@ void bclink_check_gap(struct node *n_ptr, u32 last_sent)
}
/**
* bclink_peek_nack - process a NACK msg meant for another node
* tipc_bclink_peek_nack - process a NACK msg meant for another node
*
* Only net_lock set.
* Only tipc_net_lock set.
*/
void bclink_peek_nack(u32 dest, u32 sender_tag, u32 gap_after, u32 gap_to)
void tipc_bclink_peek_nack(u32 dest, u32 sender_tag, u32 gap_after, u32 gap_to)
{
struct node *n_ptr = node_find(dest);
struct node *n_ptr = tipc_node_find(dest);
u32 my_after, my_to;
if (unlikely(!n_ptr || !node_is_up(n_ptr)))
if (unlikely(!n_ptr || !tipc_node_is_up(n_ptr)))
return;
node_lock(n_ptr);
tipc_node_lock(n_ptr);
/*
* Modify gap to suppress unnecessary NACKs from this node
*/
......@@ -364,20 +364,20 @@ void bclink_peek_nack(u32 dest, u32 sender_tag, u32 gap_after, u32 gap_to)
bclink_set_gap(n_ptr);
}
}
node_unlock(n_ptr);
tipc_node_unlock(n_ptr);
}
/**
* bclink_send_msg - broadcast a packet to all nodes in cluster
* tipc_bclink_send_msg - broadcast a packet to all nodes in cluster
*/
int bclink_send_msg(struct sk_buff *buf)
int tipc_bclink_send_msg(struct sk_buff *buf)
{
int res;
spin_lock_bh(&bc_lock);
res = link_send_buf(bcl, buf);
res = tipc_link_send_buf(bcl, buf);
if (unlikely(res == -ELINKCONG))
buf_discard(buf);
else
......@@ -393,22 +393,22 @@ int bclink_send_msg(struct sk_buff *buf)
}
/**
* bclink_recv_pkt - receive a broadcast packet, and deliver upwards
* tipc_bclink_recv_pkt - receive a broadcast packet, and deliver upwards
*
* net_lock is read_locked, no other locks set
* tipc_net_lock is read_locked, no other locks set
*/
void bclink_recv_pkt(struct sk_buff *buf)
void tipc_bclink_recv_pkt(struct sk_buff *buf)
{
struct tipc_msg *msg = buf_msg(buf);
struct node* node = node_find(msg_prevnode(msg));
struct node* node = tipc_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 ||
if (unlikely(!node || !tipc_node_is_up(node) || !node->bclink.supported ||
(msg_mc_netid(msg) != tipc_net_id))) {
buf_discard(buf);
return;
......@@ -417,14 +417,14 @@ void bclink_recv_pkt(struct sk_buff *buf)
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);
tipc_node_lock(node);
tipc_bclink_acknowledge(node, msg_bcast_ack(msg));
tipc_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),
tipc_bclink_peek_nack(msg_destnode(msg),
msg_bcast_tag(msg),
msg_bcgap_after(msg),
msg_bcgap_to(msg));
......@@ -433,7 +433,7 @@ void bclink_recv_pkt(struct sk_buff *buf)
return;
}
node_lock(node);
tipc_node_lock(node);
receive:
deferred = node->bclink.deferred_head;
next_in = mod(node->bclink.last_in + 1);
......@@ -448,26 +448,26 @@ receive:
bcl->stats.sent_acks++;
}
if (likely(msg_isdata(msg))) {
node_unlock(node);
port_recv_mcast(buf, NULL);
tipc_node_unlock(node);
tipc_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);
tipc_node_unlock(node);
tipc_link_recv_bundle(buf);
} else if (msg_user(msg) == MSG_FRAGMENTER) {
bcl->stats.recv_fragments++;
if (link_recv_fragment(&node->bclink.defragm,
&buf, &msg))
if (tipc_link_recv_fragment(&node->bclink.defragm,
&buf, &msg))
bcl->stats.recv_fragmented++;
node_unlock(node);
net_route_msg(buf);
tipc_node_unlock(node);
tipc_net_route_msg(buf);
} else {
node_unlock(node);
net_route_msg(buf);
tipc_node_unlock(node);
tipc_net_route_msg(buf);
}
if (deferred && (buf_seqno(deferred) == mod(next_in + 1))) {
node_lock(node);
tipc_node_lock(node);
buf = deferred;
msg = buf_msg(buf);
node->bclink.deferred_head = deferred->next;
......@@ -478,9 +478,9 @@ receive:
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)) {
if (tipc_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))
......@@ -497,10 +497,10 @@ receive:
bcl->stats.duplicates++;
buf_discard(buf);
}
node_unlock(node);
tipc_node_unlock(node);
}
u32 bclink_get_last_sent(void)
u32 tipc_bclink_get_last_sent(void)
{
u32 last_sent = mod(bcl->next_out_no - 1);
......@@ -509,15 +509,15 @@ u32 bclink_get_last_sent(void)
return last_sent;
}
u32 bclink_acks_missing(struct node *n_ptr)
u32 tipc_bclink_acks_missing(struct node *n_ptr)
{
return (n_ptr->bclink.supported &&
(bclink_get_last_sent() != n_ptr->bclink.acked));
(tipc_bclink_get_last_sent() != n_ptr->bclink.acked));
}
/**
* bcbearer_send - send a packet through the broadcast pseudo-bearer
* tipc_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.
......@@ -525,9 +525,9 @@ u32 bclink_acks_missing(struct node *n_ptr)
* 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)
int tipc_bcbearer_send(struct sk_buff *buf,
struct tipc_bearer *unused1,
struct tipc_media_addr *unused2)
{
static int send_count = 0;
......@@ -541,8 +541,8 @@ int bcbearer_send(struct sk_buff *buf,
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);
assert(tipc_cltr_bcast_nodes.count != 0);
bcbuf_set_acks(buf, tipc_cltr_bcast_nodes.count);
msg = buf_msg(buf);
msg_set_non_seq(msg);
msg_set_mc_netid(msg, tipc_net_id);
......@@ -555,7 +555,7 @@ int bcbearer_send(struct sk_buff *buf,
/* Send buffer over bearers until all targets reached */
remains = cluster_bcast_nodes;
remains = tipc_cltr_bcast_nodes;
for (bp_index = 0; bp_index < MAX_BEARERS; bp_index++) {
struct bearer *p = bcbearer->bpairs[bp_index].primary;
......@@ -564,7 +564,7 @@ int bcbearer_send(struct sk_buff *buf,
if (!p)
break; /* no more bearers to try */
nmap_diff(&remains, &p->nodes, &remains_new);
tipc_nmap_diff(&remains, &p->nodes, &remains_new);
if (remains_new.count == remains.count)
continue; /* bearer pair doesn't add anything */
......@@ -597,10 +597,10 @@ update:
}
/**
* bcbearer_sort - create sets of bearer pairs used by broadcast bearer
* tipc_bcbearer_sort - create sets of bearer pairs used by broadcast bearer
*/
void bcbearer_sort(void)
void tipc_bcbearer_sort(void)
{
struct bcbearer_pair *bp_temp = bcbearer->bpairs_temp;
struct bcbearer_pair *bp_curr;
......@@ -614,7 +614,7 @@ void bcbearer_sort(void)
memset(bp_temp, 0, sizeof(bcbearer->bpairs_temp));
for (b_index = 0; b_index < MAX_BEARERS; b_index++) {
struct bearer *b = &bearers[b_index];
struct bearer *b = &tipc_bearers[b_index];
if (!b->active || !b->nodes.count)
continue;
......@@ -638,8 +638,8 @@ void bcbearer_sort(void)
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)) {
if (tipc_nmap_equal(&bp_temp[pri].primary->nodes,
&bp_temp[pri].secondary->nodes)) {
bp_curr->secondary = bp_temp[pri].secondary;
} else {
bp_curr++;
......@@ -654,14 +654,14 @@ void bcbearer_sort(void)
}
/**
* bcbearer_push - resolve bearer congestion
* tipc_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)
void tipc_bcbearer_push(void)
{
struct bearer *b_ptr;
......@@ -669,20 +669,20 @@ void bcbearer_push(void)
b_ptr = &bcbearer->bearer;
if (b_ptr->publ.blocked) {
b_ptr->publ.blocked = 0;
bearer_lock_push(b_ptr);
tipc_bearer_lock_push(b_ptr);
}
spin_unlock_bh(&bc_lock);
}
int bclink_stats(char *buf, const u32 buf_size)
int tipc_bclink_stats(char *buf, const u32 buf_size)
{
struct print_buf pb;
if (!bcl)
return 0;
printbuf_init(&pb, buf, buf_size);
tipc_printbuf_init(&pb, buf, buf_size);
spin_lock_bh(&bc_lock);
......@@ -718,10 +718,10 @@ int bclink_stats(char *buf, const u32 buf_size)
: 0);
spin_unlock_bh(&bc_lock);
return printbuf_validate(&pb);
return tipc_printbuf_validate(&pb);
}
int bclink_reset_stats(void)
int tipc_bclink_reset_stats(void)
{
if (!bcl)
return -ENOPROTOOPT;
......@@ -732,7 +732,7 @@ int bclink_reset_stats(void)
return TIPC_OK;
}
int bclink_set_queue_limits(u32 limit)
int tipc_bclink_set_queue_limits(u32 limit)
{
if (!bcl)
return -ENOPROTOOPT;
......@@ -740,12 +740,12 @@ int bclink_set_queue_limits(u32 limit)
return -EINVAL;
spin_lock_bh(&bc_lock);
link_set_queue_limits(bcl, limit);
tipc_link_set_queue_limits(bcl, limit);
spin_unlock_bh(&bc_lock);
return TIPC_OK;
}
int bclink_init(void)
int tipc_bclink_init(void)
{
bcbearer = kmalloc(sizeof(*bcbearer), GFP_ATOMIC);
bclink = kmalloc(sizeof(*bclink), GFP_ATOMIC);
......@@ -762,7 +762,7 @@ int bclink_init(void)
memset(bcbearer, 0, sizeof(struct bcbearer));
INIT_LIST_HEAD(&bcbearer->bearer.cong_links);
bcbearer->bearer.media = &bcbearer->media;
bcbearer->media.send_msg = bcbearer_send;
bcbearer->media.send_msg = tipc_bcbearer_send;
sprintf(bcbearer->media.name, "tipc-multicast");
bcl = &bclink->link;
......@@ -772,27 +772,27 @@ int bclink_init(void)
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);
tipc_link_set_queue_limits(bcl, BCLINK_WIN_DEFAULT);
bcl->b_ptr = &bcbearer->bearer;
bcl->state = WORKING_WORKING;
sprintf(bcl->name, bc_link_name);
sprintf(bcl->name, tipc_bclink_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);
tipc_printbuf_init(&bcl->print_buf, pb, BCLINK_LOG_BUF_SIZE);
}
return TIPC_OK;
}
void bclink_stop(void)
void tipc_bclink_stop(void)
{
spin_lock_bh(&bc_lock);
if (bcbearer) {
link_stop(bcl);
tipc_link_stop(bcl);
if (BCLINK_LOG_BUF_SIZE)
kfree(bcl->print_buf.buf);
bcl = NULL;
......
......@@ -70,14 +70,14 @@ struct port_list {
struct node;
extern char bc_link_name[];
extern char tipc_bclink_name[];
/**
* nmap_get - determine if node exists in a node map
*/
static inline int nmap_get(struct node_map *nm_ptr, u32 node)
static inline int tipc_nmap_get(struct node_map *nm_ptr, u32 node)
{
int n = tipc_node(node);
int w = n / WSIZE;
......@@ -90,7 +90,7 @@ static inline int nmap_get(struct node_map *nm_ptr, u32 node)
* nmap_add - add a node to a node map
*/
static inline void nmap_add(struct node_map *nm_ptr, u32 node)
static inline void tipc_nmap_add(struct node_map *nm_ptr, u32 node)
{
int n = tipc_node(node);
int w = n / WSIZE;
......@@ -106,7 +106,7 @@ static inline void nmap_add(struct node_map *nm_ptr, u32 node)
* nmap_remove - remove a node from a node map
*/
static inline void nmap_remove(struct node_map *nm_ptr, u32 node)
static inline void tipc_nmap_remove(struct node_map *nm_ptr, u32 node)
{
int n = tipc_node(node);
int w = n / WSIZE;
......@@ -122,7 +122,7 @@ static inline void nmap_remove(struct node_map *nm_ptr, u32 node)
* nmap_equal - test for equality of node maps
*/
static inline int nmap_equal(struct node_map *nm_a, struct node_map *nm_b)
static inline int tipc_nmap_equal(struct node_map *nm_a, struct node_map *nm_b)
{
return !memcmp(nm_a, nm_b, sizeof(*nm_a));
}
......@@ -134,8 +134,8 @@ static inline int nmap_equal(struct node_map *nm_a, struct node_map *nm_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)
static inline void tipc_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;
......@@ -159,7 +159,7 @@ static inline void nmap_diff(struct node_map *nm_a, struct node_map *nm_b,
* 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)
static inline void tipc_port_list_add(struct port_list *pl_ptr, u32 port)
{
struct port_list *item = pl_ptr;
int i;
......@@ -194,7 +194,7 @@ static inline void port_list_add(struct port_list *pl_ptr, u32 port)
* 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)
static inline void tipc_port_list_free(struct port_list *pl_ptr)
{
struct port_list *item;
struct port_list *next;
......@@ -206,18 +206,18 @@ static inline void port_list_free(struct port_list *pl_ptr)
}
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);
int tipc_bclink_init(void);
void tipc_bclink_stop(void);
void tipc_bclink_acknowledge(struct node *n_ptr, u32 acked);
int tipc_bclink_send_msg(struct sk_buff *buf);
void tipc_bclink_recv_pkt(struct sk_buff *buf);
u32 tipc_bclink_get_last_sent(void);
u32 tipc_bclink_acks_missing(struct node *n_ptr);
void tipc_bclink_check_gap(struct node *n_ptr, u32 seqno);
int tipc_bclink_stats(char *stats_buf, const u32 buf_size);
int tipc_bclink_reset_stats(void);
int tipc_bclink_set_queue_limits(u32 limit);
void tipc_bcbearer_sort(void);
void tipc_bcbearer_push(void);
#endif
......@@ -48,7 +48,7 @@
static struct media *media_list = 0;
static u32 media_count = 0;
struct bearer *bearers = 0;
struct bearer *tipc_bearers = 0;
/**