77 files changed, 2338 insertions, 2228 deletions
diff --git a/net/Kconfig b/net/Kconfig
index 9296b269d675..bc603d9aea56 100644
--- a/net/Kconfig
+++ b/net/Kconfig
@@ -150,6 +150,7 @@ endif
 source "net/dccp/Kconfig"
 source "net/sctp/Kconfig"
+source "net/tipc/Kconfig"
 source "net/atm/Kconfig"
 source "net/bridge/Kconfig"
 source "net/8021q/Kconfig"
@@ -159,7 +160,6 @@ 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)"
diff --git a/net/bridge/netfilter/ebt_ip.c b/net/bridge/netfilter/ebt_ip.c
index f158fe67dd60..dc5d0b2427cf 100644
--- a/net/bridge/netfilter/ebt_ip.c
+++ b/net/bridge/netfilter/ebt_ip.c
@@ -92,7 +92,9 @@ static int ebt_ip_check(const char *tablename, unsigned int hookmask,
                if (info->invflags & EBT_IP_PROTO)
                        return -EINVAL;
                if (info->protocol != IPPROTO_TCP &&
-                    info->protocol != IPPROTO_UDP)
+                    info->protocol != IPPROTO_UDP &&
+                    info->protocol != IPPROTO_SCTP &&
+                    info->protocol != IPPROTO_DCCP)
                         return -EINVAL;
        }
        if (info->bitmask & EBT_IP_DPORT && info->dport[0] > info->dport[1])
diff --git a/net/bridge/netfilter/ebt_log.c b/net/bridge/netfilter/ebt_log.c
index a29c1232c420..0128fbbe2328 100644
--- a/net/bridge/netfilter/ebt_log.c
+++ b/net/bridge/netfilter/ebt_log.c
@@ -95,7 +95,9 @@ ebt_log_packet(unsigned int pf, unsigned int hooknum,
                       "tos=0x%02X, IP proto=%d", NIPQUAD(ih->saddr),
                       NIPQUAD(ih->daddr), ih->tos, ih->protocol);
                if (ih->protocol == IPPROTO_TCP ||
-                    ih->protocol == IPPROTO_UDP) {
+                    ih->protocol == IPPROTO_UDP ||
+                    ih->protocol == IPPROTO_SCTP ||
+                    ih->protocol == IPPROTO_DCCP) {
                        struct tcpudphdr _ports, *pptr;
                        pptr = skb_header_pointer(skb, ih->ihl*4,
diff --git a/net/core/filter.c b/net/core/filter.c
index a52665f75224..9540946a48f3 100644
--- a/net/core/filter.c
+++ b/net/core/filter.c
@@ -74,7 +74,6 @@ static inline void *load_pointer(struct sk_buff *skb, int k,
 * filtering, filter is the array of filter instructions, and
 * len is the number of filter blocks in the array.
 */
- 
 unsigned int sk_run_filter(struct sk_buff *skb, struct sock_filter *filter, int flen)
 {
        struct sock_filter *fentry;     /* We walk down these */
@@ -175,7 +174,7 @@ unsigned int sk_run_filter(struct sk_buff *skb, struct sock_filter *filter, int
                        continue;
                case BPF_LD|BPF_W|BPF_ABS:
                        k = fentry->k;
- load_w:
+load_w:
                        ptr = load_pointer(skb, k, 4, &tmp);
                        if (ptr != NULL) {
                                A = ntohl(*(u32 *)ptr);
@@ -184,7 +183,7 @@ unsigned int sk_run_filter(struct sk_buff *skb, struct sock_filter *filter, int
                        break;
                case BPF_LD|BPF_H|BPF_ABS:
                        k = fentry->k;
- load_h:
+load_h:
                        ptr = load_pointer(skb, k, 2, &tmp);
                        if (ptr != NULL) {
                                A = ntohs(*(u16 *)ptr);
@@ -374,7 +373,7 @@ int sk_chk_filter(struct sock_filter *filter, int flen)
                case BPF_JMP|BPF_JSET|BPF_K:
                case BPF_JMP|BPF_JSET|BPF_X:
                        /* for conditionals both must be safe */
-                        if (pc + ftest->jt + 1 >= flen ||
+                        if (pc + ftest->jt + 1 >= flen ||
                            pc + ftest->jf + 1 >= flen)
                                return -EINVAL;
                        break;
@@ -384,7 +383,7 @@ int sk_chk_filter(struct sock_filter *filter, int flen)
                }
        }
-        return (BPF_CLASS(filter[flen - 1].code) == BPF_RET) ? 0 : -EINVAL;
+        return (BPF_CLASS(filter[flen - 1].code) == BPF_RET) ? 0 : -EINVAL;
 }
 /**
@@ -404,8 +403,8 @@ int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk)
        int err;
        /* Make sure new filter is there and in the right amounts. */
-        if (fprog->filter == NULL)
+        if (fprog->filter == NULL)
-                return -EINVAL;
+                return -EINVAL;
        fp = sock_kmalloc(sk, fsize+sizeof(*fp), GFP_KERNEL);
        if (!fp)
diff --git a/net/core/netpoll.c b/net/core/netpoll.c
index 281a632fa6a6..ea51f8d02eb8 100644
--- a/net/core/netpoll.c
+++ b/net/core/netpoll.c
@@ -703,7 +703,7 @@ int netpoll_setup(struct netpoll *np)
                }
        }
-        if (!memcmp(np->local_mac, "\0\0\0\0\0\0", 6) && ndev->dev_addr)
+        if (is_zero_ether_addr(np->local_mac) && ndev->dev_addr)
                memcpy(np->local_mac, ndev->dev_addr, 6);
        if (!np->local_ip) {
diff --git a/net/core/pktgen.c b/net/core/pktgen.c
index 39063122fbb7..da16f8fd1494 100644
--- a/net/core/pktgen.c
+++ b/net/core/pktgen.c
@@ -139,6 +139,7 @@
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/wait.h>
+#include <linux/etherdevice.h>
 #include <net/checksum.h>
 #include <net/ipv6.h>
 #include <net/addrconf.h>
@@ -281,8 +282,8 @@ struct pktgen_dev {
        __u32 src_mac_count; /* How many MACs to iterate through */
        __u32 dst_mac_count; /* How many MACs to iterate through */
        
-        unsigned char dst_mac[6];
+        unsigned char dst_mac[ETH_ALEN];
-        unsigned char src_mac[6];
+        unsigned char src_mac[ETH_ALEN];
        
        __u32 cur_dst_mac_offset;
        __u32 cur_src_mac_offset;
@@ -594,16 +595,9 @@ static int pktgen_if_show(struct seq_file *seq, void *v)
        seq_puts(seq, "     src_mac: ");
-        if ((pkt_dev->src_mac[0] == 0) && 
+        if (is_zero_ether_addr(pkt_dev->src_mac))
-            (pkt_dev->src_mac[1] == 0) && 
-            (pkt_dev->src_mac[2] == 0) && 
-            (pkt_dev->src_mac[3] == 0) && 
-            (pkt_dev->src_mac[4] == 0) && 
-            (pkt_dev->src_mac[5] == 0)) 
                for (i = 0; i < 6; i++) 
                        seq_printf(seq,  "%02X%s", pkt_dev->odev->dev_addr[i], i == 5 ? "  " : ":");
        else 
                for (i = 0; i < 6; i++) 
                        seq_printf(seq,  "%02X%s", pkt_dev->src_mac[i], i == 5 ? "  " : ":");
@@ -1189,9 +1183,9 @@ static ssize_t pktgen_if_write(struct file *file, const char __user *user_buffer
        }
        if (!strcmp(name, "dst_mac")) {
                char *v = valstr;
-                unsigned char old_dmac[6];
+                unsigned char old_dmac[ETH_ALEN];
                unsigned char *m = pkt_dev->dst_mac;
-                memcpy(old_dmac, pkt_dev->dst_mac, 6);
+                memcpy(old_dmac, pkt_dev->dst_mac, ETH_ALEN);
                
                len = strn_len(&user_buffer[i], sizeof(valstr) - 1);
                if (len < 0) { return len; }
@@ -1220,8 +1214,8 @@ static ssize_t pktgen_if_write(struct file *file, const char __user *user_buffer
                }
                /* Set up Dest MAC */
-                if (memcmp(old_dmac, pkt_dev->dst_mac, 6) != 0) 
+                if (compare_ether_addr(old_dmac, pkt_dev->dst_mac))
-                        memcpy(&(pkt_dev->hh[0]), pkt_dev->dst_mac, 6);
+                        memcpy(&(pkt_dev->hh[0]), pkt_dev->dst_mac, ETH_ALEN);
                
                sprintf(pg_result, "OK: dstmac");
                return count;
@@ -1560,17 +1554,11 @@ static void pktgen_setup_inject(struct pktgen_dev *pkt_dev)
        
        /* Default to the interface's mac if not explicitly set. */
-        if ((pkt_dev->src_mac[0] == 0) && 
+        if (is_zero_ether_addr(pkt_dev->src_mac))
-            (pkt_dev->src_mac[1] == 0) && 
+               memcpy(&(pkt_dev->hh[6]), pkt_dev->odev->dev_addr, ETH_ALEN);
-            (pkt_dev->src_mac[2] == 0) && 
-            (pkt_dev->src_mac[3] == 0) && 
-            (pkt_dev->src_mac[4] == 0) && 
-            (pkt_dev->src_mac[5] == 0)) {
-               memcpy(&(pkt_dev->hh[6]), pkt_dev->odev->dev_addr, 6);
-       }
        /* Set up Dest MAC */
-        memcpy(&(pkt_dev->hh[0]), pkt_dev->dst_mac, 6);
+        memcpy(&(pkt_dev->hh[0]), pkt_dev->dst_mac, ETH_ALEN);
        /* Set up pkt size */
        pkt_dev->cur_pkt_size = pkt_dev->min_pkt_size;
@@ -1872,13 +1860,14 @@ static struct sk_buff *fill_packet_ipv4(struct net_device *odev,
         */
        mod_cur_headers(pkt_dev);
-        skb = alloc_skb(pkt_dev->cur_pkt_size + 64 + 16, GFP_ATOMIC);
+        datalen = (odev->hard_header_len + 16) & ~0xf;
+        skb = alloc_skb(pkt_dev->cur_pkt_size + 64 + datalen, GFP_ATOMIC);
        if (!skb) {
                sprintf(pkt_dev->result, "No memory");
                return NULL;
        }
-        skb_reserve(skb, 16);
+        skb_reserve(skb, datalen);
        /*  Reserve for ethernet and IP header  */
        eth = (__u8 *) skb_push(skb, 14);
diff --git a/net/dccp/ackvec.c b/net/dccp/ackvec.c
index ce9cb77c5c29..2c77dafbd091 100644
--- a/net/dccp/ackvec.c
+++ b/net/dccp/ackvec.c
@@ -144,7 +144,7 @@ static inline int dccp_ackvec_set_buf_head_state(struct dccp_ackvec *av,
                                                 const unsigned char state)
 {
        unsigned int gap;
-        signed long new_head;
+        long new_head;
        if (av->dccpav_vec_len + packets > av->dccpav_buf_len)
                return -ENOBUFS;
diff --git a/net/ipv4/igmp.c b/net/ipv4/igmp.c
index 192092b89e53..d8ce7133cd8f 100644
--- a/net/ipv4/igmp.c
+++ b/net/ipv4/igmp.c
@@ -233,7 +233,18 @@ static int is_in(struct ip_mc_list *pmc, struct ip_sf_list *psf, int type,
        case IGMPV3_MODE_IS_EXCLUDE:
                if (gdeleted || sdeleted)
                        return 0;
-                return !(pmc->gsquery && !psf->sf_gsresp);
+                if (!(pmc->gsquery && !psf->sf_gsresp)) {
+                        if (pmc->sfmode == MCAST_INCLUDE)
+                                return 1;
+                        /* don't include if this source is excluded
+                         * in all filters
+                         */
+                        if (psf->sf_count[MCAST_INCLUDE])
+                                return type == IGMPV3_MODE_IS_INCLUDE;
+                        return pmc->sfcount[MCAST_EXCLUDE] ==
+                                psf->sf_count[MCAST_EXCLUDE];
+                }
+                return 0;
        case IGMPV3_CHANGE_TO_INCLUDE:
                if (gdeleted || sdeleted)
                        return 0;
@@ -385,7 +396,7 @@ static struct sk_buff *add_grec(struct sk_buff *skb, struct ip_mc_list *pmc,
        struct igmpv3_report *pih;
        struct igmpv3_grec *pgr = NULL;
        struct ip_sf_list *psf, *psf_next, *psf_prev, **psf_list;
-        int scount, first, isquery, truncate;
+        int scount, stotal, first, isquery, truncate;
        if (pmc->multiaddr == IGMP_ALL_HOSTS)
                return skb;
@@ -395,25 +406,13 @@ static struct sk_buff *add_grec(struct sk_buff *skb, struct ip_mc_list *pmc,
        truncate = type == IGMPV3_MODE_IS_EXCLUDE ||
                    type == IGMPV3_CHANGE_TO_EXCLUDE;
+        stotal = scount = 0;
        psf_list = sdeleted ? &pmc->tomb : &pmc->sources;
-        if (!*psf_list) {
+        if (!*psf_list)
-                if (type == IGMPV3_ALLOW_NEW_SOURCES ||
+                goto empty_source;
-                    type == IGMPV3_BLOCK_OLD_SOURCES)
-                        return skb;
-                if (pmc->crcount || isquery) {
-                        /* make sure we have room for group header and at
-                         * least one source.
-                         */
-                        if (skb && AVAILABLE(skb) < sizeof(struct igmpv3_grec)+
-                            sizeof(__u32)) {
-                                igmpv3_sendpack(skb);
-                                skb = NULL; /* add_grhead will get a new one */
-                        }
-                        skb = add_grhead(skb, pmc, type, &pgr);
-                }
-                return skb;
-        }
        pih = skb ? (struct igmpv3_report *)skb->h.igmph : NULL;
        /* EX and TO_EX get a fresh packet, if needed */
@@ -426,7 +425,6 @@ static struct sk_buff *add_grec(struct sk_buff *skb, struct ip_mc_list *pmc,
                }
        }
        first = 1;
-        scount = 0;
        psf_prev = NULL;
        for (psf=*psf_list; psf; psf=psf_next) {
                u32 *psrc;
@@ -460,7 +458,7 @@ static struct sk_buff *add_grec(struct sk_buff *skb, struct ip_mc_list *pmc,
                }
                psrc = (u32 *)skb_put(skb, sizeof(u32));
                *psrc = psf->sf_inaddr;
-                scount++;
+                scount++; stotal++;
                if ((type == IGMPV3_ALLOW_NEW_SOURCES ||
                     type == IGMPV3_BLOCK_OLD_SOURCES) && psf->sf_crcount) {
                        psf->sf_crcount--;
@@ -475,6 +473,21 @@ static struct sk_buff *add_grec(struct sk_buff *skb, struct ip_mc_list *pmc,
                }
                psf_prev = psf;
        }
+empty_source:
+        if (!stotal) {
+                if (type == IGMPV3_ALLOW_NEW_SOURCES ||
+                    type == IGMPV3_BLOCK_OLD_SOURCES)
+                        return skb;
+                if (pmc->crcount || isquery) {
+                        /* make sure we have room for group header */
+                        if (skb && AVAILABLE(skb)<sizeof(struct igmpv3_grec)) {
+                                igmpv3_sendpack(skb);
+                                skb = NULL; /* add_grhead will get a new one */
+                        }
+                        skb = add_grhead(skb, pmc, type, &pgr);
+                }
+        }
        if (pgr)
                pgr->grec_nsrcs = htons(scount);
@@ -557,11 +570,11 @@ static void igmpv3_send_cr(struct in_device *in_dev)
                        skb = add_grec(skb, pmc, dtype, 1, 1);
                }
                if (pmc->crcount) {
-                        pmc->crcount--;
                        if (pmc->sfmode == MCAST_EXCLUDE) {
                                type = IGMPV3_CHANGE_TO_INCLUDE;
                                skb = add_grec(skb, pmc, type, 1, 0);
                        }
+                        pmc->crcount--;
                        if (pmc->crcount == 0) {
                                igmpv3_clear_zeros(&pmc->tomb);
                                igmpv3_clear_zeros(&pmc->sources);
@@ -594,12 +607,12 @@ static void igmpv3_send_cr(struct in_device *in_dev)
                /* filter mode changes */
                if (pmc->crcount) {
-                        pmc->crcount--;
                        if (pmc->sfmode == MCAST_EXCLUDE)
                                type = IGMPV3_CHANGE_TO_EXCLUDE;
                        else
                                type = IGMPV3_CHANGE_TO_INCLUDE;
                        skb = add_grec(skb, pmc, type, 0, 0);
+                        pmc->crcount--;
                }
                spin_unlock_bh(&pmc->lock);
        }
@@ -735,11 +748,43 @@ static void igmp_timer_expire(unsigned long data)
        ip_ma_put(im);
 }
-static void igmp_marksources(struct ip_mc_list *pmc, int nsrcs, __u32 *srcs)
+/* mark EXCLUDE-mode sources */
+static int igmp_xmarksources(struct ip_mc_list *pmc, int nsrcs, __u32 *srcs)
+{
+        struct ip_sf_list *psf;
+        int i, scount;
+        scount = 0;
+        for (psf=pmc->sources; psf; psf=psf->sf_next) {
+                if (scount == nsrcs)
+                        break;
+                for (i=0; i<nsrcs; i++) {
+                        /* skip inactive filters */
+                        if (pmc->sfcount[MCAST_INCLUDE] ||
+                            pmc->sfcount[MCAST_EXCLUDE] !=
+                            psf->sf_count[MCAST_EXCLUDE])
+                                continue;
+                        if (srcs[i] == psf->sf_inaddr) {
+                                scount++;
+                                break;
+                        }
+                }
+        }
+        pmc->gsquery = 0;
+        if (scount == nsrcs)    /* all sources excluded */
+                return 0;
+        return 1;
+}
+static int igmp_marksources(struct ip_mc_list *pmc, int nsrcs, __u32 *srcs)
 {
        struct ip_sf_list *psf;
        int i, scount;
+        if (pmc->sfmode == MCAST_EXCLUDE)
+                return igmp_xmarksources(pmc, nsrcs, srcs);
+        /* mark INCLUDE-mode sources */
        scount = 0;
        for (psf=pmc->sources; psf; psf=psf->sf_next) {
                if (scount == nsrcs)
@@ -751,6 +796,12 @@ static void igmp_marksources(struct ip_mc_list *pmc, int nsrcs, __u32 *srcs)
                                break;
                        }
        }
+        if (!scount) {
+                pmc->gsquery = 0;
+                return 0;
+        }
+        pmc->gsquery = 1;
+        return 1;
 }
 static void igmp_heard_report(struct in_device *in_dev, u32 group)
@@ -845,6 +896,8 @@ static void igmp_heard_query(struct in_device *in_dev, struct sk_buff *skb,
         */
        read_lock(&in_dev->mc_list_lock);
        for (im=in_dev->mc_list; im!=NULL; im=im->next) {
+                int changed;
                if (group && group != im->multiaddr)
                        continue;
                if (im->multiaddr == IGMP_ALL_HOSTS)
@@ -854,10 +907,11 @@ static void igmp_heard_query(struct in_device *in_dev, struct sk_buff *skb,
                        im->gsquery = im->gsquery && mark;
                else
                        im->gsquery = mark;
-                if (im->gsquery)
+                changed = !im->gsquery ||
-                        igmp_marksources(im, ntohs(ih3->nsrcs), ih3->srcs);
+                        igmp_marksources(im, ntohs(ih3->nsrcs), ih3->srcs);
                spin_unlock_bh(&im->lock);
-                igmp_mod_timer(im, max_delay);
+                if (changed)
+                        igmp_mod_timer(im, max_delay);
        }
        read_unlock(&in_dev->mc_list_lock);
 }
@@ -1510,7 +1564,7 @@ static void sf_markstate(struct ip_mc_list *pmc)
 static int sf_setstate(struct ip_mc_list *pmc)
 {
-        struct ip_sf_list *psf;
+        struct ip_sf_list *psf, *dpsf;
        int mca_xcount = pmc->sfcount[MCAST_EXCLUDE];
        int qrv = pmc->interface->mr_qrv;
        int new_in, rv;
@@ -1522,8 +1576,46 @@ static int sf_setstate(struct ip_mc_list *pmc)
                                !psf->sf_count[MCAST_INCLUDE];
                } else
                        new_in = psf->sf_count[MCAST_INCLUDE] != 0;
-                if (new_in != psf->sf_oldin) {
+                if (new_in) {
-                        psf->sf_crcount = qrv;
+                        if (!psf->sf_oldin) {
+                                struct ip_sf_list *prev = 0;
+                                for (dpsf=pmc->tomb; dpsf; dpsf=dpsf->sf_next) {
+                                        if (dpsf->sf_inaddr == psf->sf_inaddr)
+                                                break;
+                                        prev = dpsf;
+                                }
+                                if (dpsf) {
+                                        if (prev)
+                                                prev->sf_next = dpsf->sf_next;
+                                        else
+                                                pmc->tomb = dpsf->sf_next;
+                                        kfree(dpsf);
+                                }
+                                psf->sf_crcount = qrv;
+                                rv++;
+                        }
+                } else if (psf->sf_oldin) {
+                        psf->sf_crcount = 0;
+                        /*
+                         * add or update "delete" records if an active filter
+                         * is now inactive
+                         */
+                        for (dpsf=pmc->tomb; dpsf; dpsf=dpsf->sf_next)
+                                if (dpsf->sf_inaddr == psf->sf_inaddr)
+                                        break;
+                        if (!dpsf) {
+                                dpsf = (struct ip_sf_list *)
+                                        kmalloc(sizeof(*dpsf), GFP_ATOMIC);
+                                if (!dpsf)
+                                        continue;
+                                *dpsf = *psf;
+                                /* pmc->lock held by callers */
+                                dpsf->sf_next = pmc->tomb;
+                                pmc->tomb = dpsf;
+                        }
+                        dpsf->sf_crcount = qrv;
                        rv++;
                }
        }
diff --git a/net/ipv4/netfilter/Makefile b/net/ipv4/netfilter/Makefile
index bcefe64b9317..e5c5b3202f02 100644
--- a/net/ipv4/netfilter/Makefile
+++ b/net/ipv4/netfilter/Makefile
@@ -46,7 +46,6 @@ obj-$(CONFIG_IP_NF_NAT) += iptable_nat.o
 obj-$(CONFIG_IP_NF_RAW) += iptable_raw.o
 # matches
-obj-$(CONFIG_IP_NF_MATCH_HELPER) += ipt_helper.o
 obj-$(CONFIG_IP_NF_MATCH_HASHLIMIT) += ipt_hashlimit.o
 obj-$(CONFIG_IP_NF_MATCH_IPRANGE) += ipt_iprange.o
 obj-$(CONFIG_IP_NF_MATCH_MULTIPORT) += ipt_multiport.o
diff --git a/net/ipv4/netfilter/ip_conntrack_proto_gre.c b/net/ipv4/netfilter/ip_conntrack_proto_gre.c
index c777abf16cb7..56794797d55b 100644
--- a/net/ipv4/netfilter/ip_conntrack_proto_gre.c
+++ b/net/ipv4/netfilter/ip_conntrack_proto_gre.c
@@ -32,6 +32,7 @@
 #include <linux/in.h>
 #include <linux/list.h>
 #include <linux/seq_file.h>
+#include <linux/interrupt.h>
 static DEFINE_RWLOCK(ip_ct_gre_lock);
 #define ASSERT_READ_LOCK(x)
diff --git a/net/ipv4/netfilter/ipt_policy.c b/net/ipv4/netfilter/ipt_policy.c
index 709debcc69c9..18ca8258a1c5 100644
--- a/net/ipv4/netfilter/ipt_policy.c
+++ b/net/ipv4/netfilter/ipt_policy.c
@@ -95,7 +95,10 @@ match_policy_out(const struct sk_buff *skb, const struct ipt_policy_info *info)
 static int match(const struct sk_buff *skb,
                 const struct net_device *in,
                 const struct net_device *out,
-                 const void *matchinfo, int offset, int *hotdrop)
+                 const void *matchinfo,
+                 int offset,
+                 unsigned int protoff,
+                 int *hotdrop)
 {
        const struct ipt_policy_info *info = matchinfo;
        int ret;
@@ -113,7 +116,7 @@ static int match(const struct sk_buff *skb,
        return ret;
 }
-static int checkentry(const char *tablename, const struct ipt_ip *ip,
+static int checkentry(const char *tablename, const void *ip_void,
                      void *matchinfo, unsigned int matchsize,
                      unsigned int hook_mask)
 {
diff --git a/net/ipv4/raw.c b/net/ipv4/raw.c
index 165a4d81efa4..f29a12da5109 100644
--- a/net/ipv4/raw.c
+++ b/net/ipv4/raw.c
@@ -40,12 +40,12 @@
 */
 
 #include <linux/config.h> 
+#include <linux/types.h>
 #include <asm/atomic.h>
 #include <asm/byteorder.h>
 #include <asm/current.h>
 #include <asm/uaccess.h>
 #include <asm/ioctls.h>
-#include <linux/types.h>
 #include <linux/stddef.h>
 #include <linux/slab.h>
 #include <linux/errno.h>
diff --git a/net/ipv4/route.c b/net/ipv4/route.c
index f701a136a6ae..d82c242ea704 100644
--- a/net/ipv4/route.c
+++ b/net/ipv4/route.c
@@ -240,9 +240,9 @@ static unsigned			rt_hash_mask;
 static int                      rt_hash_log;
 static unsigned int             rt_hash_rnd;
-static struct rt_cache_stat *rt_cache_stat;
+static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat);
-#define RT_CACHE_STAT_INC(field)                                          \
+#define RT_CACHE_STAT_INC(field) \
-                (per_cpu_ptr(rt_cache_stat, raw_smp_processor_id())->field++)
+        (per_cpu(rt_cache_stat, raw_smp_processor_id()).field++)
 static int rt_intern_hash(unsigned hash, struct rtable *rth,
                                struct rtable **res);
@@ -401,7 +401,7 @@ static void *rt_cpu_seq_start(struct seq_file *seq, loff_t *pos)
                if (!cpu_possible(cpu))
                        continue;
                *pos = cpu+1;
-                return per_cpu_ptr(rt_cache_stat, cpu);
+                return &per_cpu(rt_cache_stat, cpu);
        }
        return NULL;
 }
@@ -414,7 +414,7 @@ static void *rt_cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos)
                if (!cpu_possible(cpu))
                        continue;
                *pos = cpu+1;
-                return per_cpu_ptr(rt_cache_stat, cpu);
+                return &per_cpu(rt_cache_stat, cpu);
        }
        return NULL;
        
@@ -3160,10 +3160,6 @@ int __init ip_rt_init(void)
        ipv4_dst_ops.gc_thresh = (rt_hash_mask + 1);
        ip_rt_max_size = (rt_hash_mask + 1) * 16;
-        rt_cache_stat = alloc_percpu(struct rt_cache_stat);
-        if (!rt_cache_stat)
-                return -ENOMEM;
        devinet_init();
        ip_fib_init();
@@ -3191,7 +3187,6 @@ int __init ip_rt_init(void)
        if (!proc_net_fops_create("rt_cache", S_IRUGO, &rt_cache_seq_fops) ||
            !(rtstat_pde = create_proc_entry("rt_cache", S_IRUGO, 
                                             proc_net_stat))) {
-                free_percpu(rt_cache_stat);
                return -ENOMEM;
        }
        rtstat_pde->proc_fops = &rt_cpu_seq_fops;
diff --git a/net/ipv6/addrconf.c b/net/ipv6/addrconf.c
index dfb4f145a139..d328d5986143 100644
--- a/net/ipv6/addrconf.c
+++ b/net/ipv6/addrconf.c
@@ -2644,7 +2644,7 @@ static int if6_seq_show(struct seq_file *seq, void *v)
 {
        struct inet6_ifaddr *ifp = (struct inet6_ifaddr *)v;
        seq_printf(seq,
-                   NIP6_FMT " %02x %02x %02x %02x %8s\n",
+                   NIP6_SEQFMT " %02x %02x %02x %02x %8s\n",
                   NIP6(ifp->addr),
                   ifp->idev->dev->ifindex,
                   ifp->prefix_len,
diff --git a/net/ipv6/anycast.c b/net/ipv6/anycast.c
index 72bd08af2dfb..840a33d33296 100644
--- a/net/ipv6/anycast.c
+++ b/net/ipv6/anycast.c
@@ -532,7 +532,7 @@ static int ac6_seq_show(struct seq_file *seq, void *v)
        struct ac6_iter_state *state = ac6_seq_private(seq);
        seq_printf(seq,
-                   "%-4d %-15s " NIP6_FMT " %5d\n",
+                   "%-4d %-15s " NIP6_SEQFMT " %5d\n",
                   state->dev->ifindex, state->dev->name,
                   NIP6(im->aca_addr),
                   im->aca_users);
diff --git a/net/ipv6/ip6_flowlabel.c b/net/ipv6/ip6_flowlabel.c
index 4183c8dac7f6..69cbe8a66d02 100644
--- a/net/ipv6/ip6_flowlabel.c
+++ b/net/ipv6/ip6_flowlabel.c
@@ -629,7 +629,7 @@ static void ip6fl_fl_seq_show(struct seq_file *seq, struct ip6_flowlabel *fl)
 {
        while(fl) {
                seq_printf(seq,
-                           "%05X %-1d %-6d %-6d %-6ld %-8ld " NIP6_FMT " %-4d\n",
+                           "%05X %-1d %-6d %-6d %-6ld %-8ld " NIP6_SEQFMT " %-4d\n",
                           (unsigned)ntohl(fl->label),
                           fl->share,
                           (unsigned)fl->owner,
@@ -645,7 +645,7 @@ static void ip6fl_fl_seq_show(struct seq_file *seq, struct ip6_flowlabel *fl)
 static int ip6fl_seq_show(struct seq_file *seq, void *v)
 {
        if (v == SEQ_START_TOKEN)
-                seq_printf(seq, "%-5s %-1s %-6s %-6s %-6s %-8s %-39s %s\n",
+                seq_printf(seq, "%-5s %-1s %-6s %-6s %-6s %-8s %-32s %s\n",
                           "Label", "S", "Owner", "Users", "Linger", "Expires", "Dst", "Opt");
        else
                ip6fl_fl_seq_show(seq, v);
diff --git a/net/ipv6/mcast.c b/net/ipv6/mcast.c
index 0e03eabfb9da..6c05c7978bef 100644
--- a/net/ipv6/mcast.c
+++ b/net/ipv6/mcast.c
@@ -2373,7 +2373,7 @@ static int igmp6_mc_seq_show(struct seq_file *seq, void *v)
        struct igmp6_mc_iter_state *state = igmp6_mc_seq_private(seq);
        seq_printf(seq,
-                   "%-4d %-15s " NIP6_FMT " %5d %08X %ld\n", 
+                   "%-4d %-15s " NIP6_SEQFMT " %5d %08X %ld\n", 
                   state->dev->ifindex, state->dev->name,
                   NIP6(im->mca_addr),
                   im->mca_users, im->mca_flags,
@@ -2542,12 +2542,12 @@ static int igmp6_mcf_seq_show(struct seq_file *seq, void *v)
        if (v == SEQ_START_TOKEN) {
                seq_printf(seq, 
                           "%3s %6s "
-                           "%39s %39s %6s %6s\n", "Idx",
+                           "%32s %32s %6s %6s\n", "Idx",
                           "Device", "Multicast Address",
                           "Source Address", "INC", "EXC");
        } else {
                seq_printf(seq,
-                           "%3d %6.6s " NIP6_FMT " " NIP6_FMT " %6lu %6lu\n",
+                           "%3d %6.6s " NIP6_SEQFMT " " NIP6_SEQFMT " %6lu %6lu\n",
                           state->dev->ifindex, state->dev->name,
                           NIP6(state->im->mca_addr),
                           NIP6(psf->sf_addr),
diff --git a/net/ipv6/netfilter/Makefile b/net/ipv6/netfilter/Makefile
index 663b4749820d..db6073c94163 100644
--- a/net/ipv6/netfilter/Makefile
+++ b/net/ipv6/netfilter/Makefile
@@ -4,7 +4,6 @@
 # Link order matters here.
 obj-$(CONFIG_IP6_NF_IPTABLES) += ip6_tables.o
-obj-$(CONFIG_IP6_NF_MATCH_LENGTH) += ip6t_length.o
 obj-$(CONFIG_IP6_NF_MATCH_RT) += ip6t_rt.o
 obj-$(CONFIG_IP6_NF_MATCH_OPTS) += ip6t_hbh.o ip6t_dst.o
 obj-$(CONFIG_IP6_NF_MATCH_IPV6HEADER) += ip6t_ipv6header.o
diff --git a/net/ipv6/netfilter/ip6t_dst.c b/net/ipv6/netfilter/ip6t_dst.c
index 80fe82669ce2..b4c153a53500 100644
--- a/net/ipv6/netfilter/ip6t_dst.c
+++ b/net/ipv6/netfilter/ip6t_dst.c
@@ -36,19 +36,19 @@ MODULE_AUTHOR("Andras Kis-Szabo <kisza@sch.bme.hu>");
 #endif
 /*
- * (Type & 0xC0) >> 6
+ *  (Type & 0xC0) >> 6
- *      0       -> ignorable
+ *      0       -> ignorable
- *      1       -> must drop the packet
+ *      1       -> must drop the packet
- *      2       -> send ICMP PARM PROB regardless and drop packet
+ *      2       -> send ICMP PARM PROB regardless and drop packet
- *      3       -> Send ICMP if not a multicast address and drop packet
+ *      3       -> Send ICMP if not a multicast address and drop packet
 *  (Type & 0x20) >> 5
- *      0       -> invariant
+ *      0       -> invariant
- *      1       -> can change the routing
+ *      1       -> can change the routing
 *  (Type & 0x1F) Type
- *      0       -> Pad1 (only 1 byte!)
+ *      0       -> Pad1 (only 1 byte!)
- *      1       -> PadN LENGTH info (total length = length + 2)
+ *      1       -> PadN LENGTH info (total length = length + 2)
- *      C0 | 2  -> JUMBO 4 x x x x ( xxxx > 64k )
+ *      C0 | 2  -> JUMBO 4 x x x x ( xxxx > 64k )
- *      5       -> RTALERT 2 x x
+ *      5       -> RTALERT 2 x x
 */
 static int
@@ -60,16 +60,16 @@ match(const struct sk_buff *skb,
      unsigned int protoff,
      int *hotdrop)
 {
-       struct ipv6_opt_hdr _optsh, *oh;
+        struct ipv6_opt_hdr _optsh, *oh;
-       const struct ip6t_opts *optinfo = matchinfo;
+        const struct ip6t_opts *optinfo = matchinfo;
-       unsigned int temp;
+        unsigned int temp;
-       unsigned int ptr;
+        unsigned int ptr;
-       unsigned int hdrlen = 0;
+        unsigned int hdrlen = 0;
-       unsigned int ret = 0;
+        unsigned int ret = 0;
-       u8 _opttype, *tp = NULL;
+        u8 _opttype, *tp = NULL;
-       u8 _optlen, *lp = NULL;
+        u8 _optlen, *lp = NULL;
-       unsigned int optlen;
+        unsigned int optlen;
-       
 #if HOPBYHOP
        if (ipv6_find_hdr(skb, &ptr, NEXTHDR_HOP, NULL) < 0)
 #else
@@ -77,42 +77,41 @@ match(const struct sk_buff *skb,
 #endif
                return 0;
-       oh = skb_header_pointer(skb, ptr, sizeof(_optsh), &_optsh);
+        oh = skb_header_pointer(skb, ptr, sizeof(_optsh), &_optsh);
-       if (oh == NULL){
+        if (oh == NULL) {
-               *hotdrop = 1;
+                *hotdrop = 1;
-                return 0;
+                return 0;
-       }
+        }
-       hdrlen = ipv6_optlen(oh);
+        hdrlen = ipv6_optlen(oh);
-       if (skb->len - ptr < hdrlen){
+        if (skb->len - ptr < hdrlen) {
-               /* Packet smaller than it's length field */
+                /* Packet smaller than it's length field */
-                return 0;
+                return 0;
-       }
+        }
-       DEBUGP("IPv6 OPTS LEN %u %u ", hdrlen, oh->hdrlen);
+        DEBUGP("IPv6 OPTS LEN %u %u ", hdrlen, oh->hdrlen);
-       DEBUGP("len %02X %04X %02X ",
+        DEBUGP("len %02X %04X %02X ",
-                optinfo->hdrlen, hdrlen,
+               optinfo->hdrlen, hdrlen,
-                (!(optinfo->flags & IP6T_OPTS_LEN) ||
+               (!(optinfo->flags & IP6T_OPTS_LEN) ||
-                           ((optinfo->hdrlen == hdrlen) ^
+                ((optinfo->hdrlen == hdrlen) ^
-                           !!(optinfo->invflags & IP6T_OPTS_INV_LEN))));
+                 !!(optinfo->invflags & IP6T_OPTS_INV_LEN))));
-       ret = (oh != NULL)
+        ret = (oh != NULL) &&
-                &&
+              (!(optinfo->flags & IP6T_OPTS_LEN) ||
-                (!(optinfo->flags & IP6T_OPTS_LEN) ||
+               ((optinfo->hdrlen == hdrlen) ^
-                           ((optinfo->hdrlen == hdrlen) ^
+                !!(optinfo->invflags & IP6T_OPTS_INV_LEN)));
-                           !!(optinfo->invflags & IP6T_OPTS_INV_LEN)));
+        ptr += 2;
-       ptr += 2;
+        hdrlen -= 2;
-       hdrlen -= 2;
+        if (!(optinfo->flags & IP6T_OPTS_OPTS)) {
-       if ( !(optinfo->flags & IP6T_OPTS_OPTS) ){
+                return ret;
-               return ret;
        } else if (optinfo->flags & IP6T_OPTS_NSTRICT) {
                DEBUGP("Not strict - not implemented");
        } else {
                DEBUGP("Strict ");
-                DEBUGP("#%d ",optinfo->optsnr);
+                DEBUGP("#%d ", optinfo->optsnr);
-                for(temp=0; temp<optinfo->optsnr; temp++){
+                for (temp = 0; temp < optinfo->optsnr; temp++) {
                        /* type field exists ? */
                        if (hdrlen < 1)
                                break;
@@ -122,10 +121,10 @@ match(const struct sk_buff *skb,
                                break;
                        /* Type check */
-                        if (*tp != (optinfo->opts[temp] & 0xFF00)>>8){
+                        if (*tp != (optinfo->opts[temp] & 0xFF00) >> 8) {
                                DEBUGP("Tbad %02X %02X\n",
                                       *tp,
-                                       (optinfo->opts[temp] & 0xFF00)>>8);
+                                       (optinfo->opts[temp] & 0xFF00) >> 8);
                                return 0;
                        } else {
                                DEBUGP("Tok ");
@@ -169,7 +168,8 @@ match(const struct sk_buff *skb,
                }
                if (temp == optinfo->optsnr)
                        return ret;
-                else return 0;
+                else
+                        return 0;
        }
        return 0;
@@ -178,25 +178,24 @@ match(const struct sk_buff *skb,
 /* Called when user tries to insert an entry of this type. */
 static int
 checkentry(const char *tablename,
-          const void *info,
+           const void *info,
-          void *matchinfo,
+           void *matchinfo,
-          unsigned int matchinfosize,
+           unsigned int matchinfosize,
-          unsigned int hook_mask)
+           unsigned int hook_mask)
 {
-       const struct ip6t_opts *optsinfo = matchinfo;
+        const struct ip6t_opts *optsinfo = matchinfo;
-       if (matchinfosize != IP6T_ALIGN(sizeof(struct ip6t_opts))) {
+        if (matchinfosize != IP6T_ALIGN(sizeof(struct ip6t_opts))) {
-              DEBUGP("ip6t_opts: matchsize %u != %u\n",
+                DEBUGP("ip6t_opts: matchsize %u != %u\n",
-                      matchinfosize, IP6T_ALIGN(sizeof(struct ip6t_opts)));
+                       matchinfosize, IP6T_ALIGN(sizeof(struct ip6t_opts)));
-              return 0;
+                return 0;
-       }
+        }
-       if (optsinfo->invflags & ~IP6T_OPTS_INV_MASK) {
+        if (optsinfo->invflags & ~IP6T_OPTS_INV_MASK) {
-              DEBUGP("ip6t_opts: unknown flags %X\n",
+                DEBUGP("ip6t_opts: unknown flags %X\n", optsinfo->invflags);
-                      optsinfo->invflags);
+                return 0;
-              return 0;
+        }
-       }
+        return 1;
-       return 1;
 }
 static struct ip6t_match opts_match = {
@@ -212,12 +211,12 @@ static struct ip6t_match opts_match = {
 static int __init init(void)
 {
-       return ip6t_register_match(&opts_match);
+        return ip6t_register_match(&opts_match);
 }
 static void __exit cleanup(void)
 {
-       ip6t_unregister_match(&opts_match);
+        ip6t_unregister_match(&opts_match);
 }
 module_init(init);
diff --git a/net/ipv6/netfilter/ip6t_eui64.c b/net/ipv6/netfilter/ip6t_eui64.c
index ddf5f571909c..27396ac0b9ed 100644
--- a/net/ipv6/netfilter/ip6t_eui64.c
+++ b/net/ipv6/netfilter/ip6t_eui64.c
@@ -27,45 +27,45 @@ match(const struct sk_buff *skb,
      unsigned int protoff,
      int *hotdrop)
 {
+        unsigned char eui64[8];
+        int i = 0;
-    unsigned char eui64[8];
+        if (!(skb->mac.raw >= skb->head &&
-    int i=0;
+              (skb->mac.raw + ETH_HLEN) <= skb->data) &&
+            offset != 0) {
-     if ( !(skb->mac.raw >= skb->head
+                *hotdrop = 1;
-                && (skb->mac.raw + ETH_HLEN) <= skb->data)
+                return 0;
-                && offset != 0) {
+        }
-                        *hotdrop = 1;
-                        return 0;
+        memset(eui64, 0, sizeof(eui64));
-                }
-    
+        if (eth_hdr(skb)->h_proto == ntohs(ETH_P_IPV6)) {
-    memset(eui64, 0, sizeof(eui64));
+                if (skb->nh.ipv6h->version == 0x6) {
+                        memcpy(eui64, eth_hdr(skb)->h_source, 3);
-    if (eth_hdr(skb)->h_proto == ntohs(ETH_P_IPV6)) {
+                        memcpy(eui64 + 5, eth_hdr(skb)->h_source + 3, 3);
-      if (skb->nh.ipv6h->version == 0x6) { 
+                        eui64[3] = 0xff;
-         memcpy(eui64, eth_hdr(skb)->h_source, 3);
+                        eui64[4] = 0xfe;
-         memcpy(eui64 + 5, eth_hdr(skb)->h_source + 3, 3);
+                        eui64[0] |= 0x02;
-         eui64[3]=0xff;
-         eui64[4]=0xfe;
+                        i = 0;
-         eui64[0] |= 0x02;
+                        while ((skb->nh.ipv6h->saddr.s6_addr[8+i] == eui64[i])
+                               && (i < 8))
-         i=0;
+                                i++;
-         while ((skb->nh.ipv6h->saddr.s6_addr[8+i] ==
-                         eui64[i]) && (i<8)) i++;
+                        if (i == 8)
+                                return 1;
-         if ( i == 8 )
+                }
-                return 1;
+        }
-      }
-    }
+        return 0;
-    return 0;
 }
 static int
 ip6t_eui64_checkentry(const char *tablename,
-                   const void  *ip,
+                      const void *ip,
-                   void *matchinfo,
+                      void *matchinfo,
-                   unsigned int matchsize,
+                      unsigned int matchsize,
-                   unsigned int hook_mask)
+                      unsigned int hook_mask)
 {
        if (hook_mask
            & ~((1 << NF_IP6_PRE_ROUTING) | (1 << NF_IP6_LOCAL_IN) |
diff --git a/net/ipv6/netfilter/ip6t_frag.c b/net/ipv6/netfilter/ip6t_frag.c
index a9964b946ed5..4c14125a0e26 100644
--- a/net/ipv6/netfilter/ip6t_frag.c
+++ b/net/ipv6/netfilter/ip6t_frag.c
@@ -31,12 +31,12 @@ MODULE_AUTHOR("Andras Kis-Szabo <kisza@sch.bme.hu>");
 static inline int
 id_match(u_int32_t min, u_int32_t max, u_int32_t id, int invert)
 {
-       int r=0;
+        int r = 0;
-       DEBUGP("frag id_match:%c 0x%x <= 0x%x <= 0x%x",invert? '!':' ',
+        DEBUGP("frag id_match:%c 0x%x <= 0x%x <= 0x%x", invert ? '!' : ' ',
-              min,id,max);
+               min, id, max);
-       r=(id >= min && id <= max) ^ invert;
+        r = (id >= min && id <= max) ^ invert;
-       DEBUGP(" result %s\n",r? "PASS" : "FAILED");
+        DEBUGP(" result %s\n", r ? "PASS" : "FAILED");
-       return r;
+        return r;
 }
 static int
@@ -48,92 +48,91 @@ match(const struct sk_buff *skb,
      unsigned int protoff,
      int *hotdrop)
 {
-       struct frag_hdr _frag, *fh;
+        struct frag_hdr _frag, *fh;
-       const struct ip6t_frag *fraginfo = matchinfo;
+        const struct ip6t_frag *fraginfo = matchinfo;
-       unsigned int ptr;
+        unsigned int ptr;
        if (ipv6_find_hdr(skb, &ptr, NEXTHDR_FRAGMENT, NULL) < 0)
                return 0;
        fh = skb_header_pointer(skb, ptr, sizeof(_frag), &_frag);
-        if (fh == NULL){
+        if (fh == NULL) {
                *hotdrop = 1;
                return 0;
        }
-       DEBUGP("INFO %04X ", fh->frag_off);
+        DEBUGP("INFO %04X ", fh->frag_off);
-       DEBUGP("OFFSET %04X ", ntohs(fh->frag_off) & ~0x7);
+        DEBUGP("OFFSET %04X ", ntohs(fh->frag_off) & ~0x7);
-       DEBUGP("RES %02X %04X", fh->reserved, ntohs(fh->frag_off) & 0x6);
+        DEBUGP("RES %02X %04X", fh->reserved, ntohs(fh->frag_off) & 0x6);
-       DEBUGP("MF %04X ", fh->frag_off & htons(IP6_MF));
+        DEBUGP("MF %04X ", fh->frag_off & htons(IP6_MF));
-       DEBUGP("ID %u %08X\n", ntohl(fh->identification),
+        DEBUGP("ID %u %08X\n", ntohl(fh->identification),
-              ntohl(fh->identification));
+               ntohl(fh->identification));
-       DEBUGP("IPv6 FRAG id %02X ",
+        DEBUGP("IPv6 FRAG id %02X ",
-                (id_match(fraginfo->ids[0], fraginfo->ids[1],
+               (id_match(fraginfo->ids[0], fraginfo->ids[1],
-                           ntohl(fh->identification),
+                         ntohl(fh->identification),
-                           !!(fraginfo->invflags & IP6T_FRAG_INV_IDS))));
+                         !!(fraginfo->invflags & IP6T_FRAG_INV_IDS))));
-       DEBUGP("res %02X %02X%04X %02X ", 
+        DEBUGP("res %02X %02X%04X %02X ",
-                (fraginfo->flags & IP6T_FRAG_RES), fh->reserved,
+               (fraginfo->flags & IP6T_FRAG_RES), fh->reserved,
-                ntohs(fh->frag_off) & 0x6,
+               ntohs(fh->frag_off) & 0x6,
-                !((fraginfo->flags & IP6T_FRAG_RES)
+               !((fraginfo->flags & IP6T_FRAG_RES)
-                        && (fh->reserved || (ntohs(fh->frag_off) & 0x06))));
+                 && (fh->reserved || (ntohs(fh->frag_off) & 0x06))));
-       DEBUGP("first %02X %02X %02X ", 
+        DEBUGP("first %02X %02X %02X ",
-                (fraginfo->flags & IP6T_FRAG_FST),
+               (fraginfo->flags & IP6T_FRAG_FST),
-                ntohs(fh->frag_off) & ~0x7,
+               ntohs(fh->frag_off) & ~0x7,
-                !((fraginfo->flags & IP6T_FRAG_FST)
+               !((fraginfo->flags & IP6T_FRAG_FST)
-                        && (ntohs(fh->frag_off) & ~0x7)));
+                 && (ntohs(fh->frag_off) & ~0x7)));
-       DEBUGP("mf %02X %02X %02X ", 
+        DEBUGP("mf %02X %02X %02X ",
-                (fraginfo->flags & IP6T_FRAG_MF),
+               (fraginfo->flags & IP6T_FRAG_MF),
-                ntohs(fh->frag_off) & IP6_MF,
+               ntohs(fh->frag_off) & IP6_MF,
-                !((fraginfo->flags & IP6T_FRAG_MF)
+               !((fraginfo->flags & IP6T_FRAG_MF)
-                        && !((ntohs(fh->frag_off) & IP6_MF))));
+                 && !((ntohs(fh->frag_off) & IP6_MF))));
-       DEBUGP("last %02X %02X %02X\n", 
+        DEBUGP("last %02X %02X %02X\n",
-                (fraginfo->flags & IP6T_FRAG_NMF),
+               (fraginfo->flags & IP6T_FRAG_NMF),
-                ntohs(fh->frag_off) & IP6_MF,
+               ntohs(fh->frag_off) & IP6_MF,
-                !((fraginfo->flags & IP6T_FRAG_NMF)
+               !((fraginfo->flags & IP6T_FRAG_NMF)
-                        && (ntohs(fh->frag_off) & IP6_MF)));
+                 && (ntohs(fh->frag_off) & IP6_MF)));
-       return (fh != NULL)
+        return (fh != NULL)
-                &&
+               &&
-                (id_match(fraginfo->ids[0], fraginfo->ids[1],
+               (id_match(fraginfo->ids[0], fraginfo->ids[1],
-                          ntohl(fh->identification),
+                         ntohl(fh->identification),
-                           !!(fraginfo->invflags & IP6T_FRAG_INV_IDS)))
+                         !!(fraginfo->invflags & IP6T_FRAG_INV_IDS)))
-                &&
+               &&
-                !((fraginfo->flags & IP6T_FRAG_RES)
+               !((fraginfo->flags & IP6T_FRAG_RES)
-                        && (fh->reserved || (ntohs(fh->frag_off) & 0x6)))
+                 && (fh->reserved || (ntohs(fh->frag_off) & 0x6)))
-                &&
+               &&
-                !((fraginfo->flags & IP6T_FRAG_FST)
+               !((fraginfo->flags & IP6T_FRAG_FST)
-                        && (ntohs(fh->frag_off) & ~0x7))
+                 && (ntohs(fh->frag_off) & ~0x7))
-                &&
+               &&
-                !((fraginfo->flags & IP6T_FRAG_MF)
+               !((fraginfo->flags & IP6T_FRAG_MF)
-                        && !(ntohs(fh->frag_off) & IP6_MF))
+                 && !(ntohs(fh->frag_off) & IP6_MF))
-                &&
+               &&
-                !((fraginfo->flags & IP6T_FRAG_NMF)
+               !((fraginfo->flags & IP6T_FRAG_NMF)
-                        && (ntohs(fh->frag_off) & IP6_MF));
+                 && (ntohs(fh->frag_off) & IP6_MF));
 }
 /* Called when user tries to insert an entry of this type. */
 static int
 checkentry(const char *tablename,
-          const void *ip,
+           const void *ip,
-          void *matchinfo,
+           void *matchinfo,
-          unsigned int matchinfosize,
+           unsigned int matchinfosize,
-          unsigned int hook_mask)
+           unsigned int hook_mask)
 {
-       const struct ip6t_frag *fraginfo = matchinfo;
+        const struct ip6t_frag *fraginfo = matchinfo;
-       if (matchinfosize != IP6T_ALIGN(sizeof(struct ip6t_frag))) {
+        if (matchinfosize != IP6T_ALIGN(sizeof(struct ip6t_frag))) {
-              DEBUGP("ip6t_frag: matchsize %u != %u\n",
+                DEBUGP("ip6t_frag: matchsize %u != %u\n",
-                      matchinfosize, IP6T_ALIGN(sizeof(struct ip6t_frag)));
+                       matchinfosize, IP6T_ALIGN(sizeof(struct ip6t_frag)));
-              return 0;
+                return 0;
-       }
+        }
-       if (fraginfo->invflags & ~IP6T_FRAG_INV_MASK) {
+        if (fraginfo->invflags & ~IP6T_FRAG_INV_MASK) {
-              DEBUGP("ip6t_frag: unknown flags %X\n",
+                DEBUGP("ip6t_frag: unknown flags %X\n", fraginfo->invflags);
-                      fraginfo->invflags);
+                return 0;
-              return 0;
+        }
-       }
+        return 1;
-       return 1;
 }
 static struct ip6t_match frag_match = {
@@ -145,12 +144,12 @@ static struct ip6t_match frag_match = {
 static int __init init(void)
 {
-       return ip6t_register_match(&frag_match);
+        return ip6t_register_match(&frag_match);
 }
 static void __exit cleanup(void)
 {
-       ip6t_unregister_match(&frag_match);
+        ip6t_unregister_match(&frag_match);
 }
 module_init(init);
diff --git a/net/ipv6/netfilter/ip6t_hbh.c b/net/ipv6/netfilter/ip6t_hbh.c
index ed8ded18bbd4..37a8474a7e0c 100644
--- a/net/ipv6/netfilter/ip6t_hbh.c
+++ b/net/ipv6/netfilter/ip6t_hbh.c
@@ -36,19 +36,19 @@ MODULE_AUTHOR("Andras Kis-Szabo <kisza@sch.bme.hu>");
 #endif
 /*
- * (Type & 0xC0) >> 6
+ *  (Type & 0xC0) >> 6
- *      0       -> ignorable
+ *      0       -> ignorable
- *      1       -> must drop the packet
+ *      1       -> must drop the packet
- *      2       -> send ICMP PARM PROB regardless and drop packet
+ *      2       -> send ICMP PARM PROB regardless and drop packet
- *      3       -> Send ICMP if not a multicast address and drop packet
+ *      3       -> Send ICMP if not a multicast address and drop packet
 *  (Type & 0x20) >> 5
- *      0       -> invariant
+ *      0       -> invariant
- *      1       -> can change the routing
+ *      1       -> can change the routing
 *  (Type & 0x1F) Type
- *      0       -> Pad1 (only 1 byte!)
+ *      0       -> Pad1 (only 1 byte!)
- *      1       -> PadN LENGTH info (total length = length + 2)
+ *      1       -> PadN LENGTH info (total length = length + 2)
- *      C0 | 2  -> JUMBO 4 x x x x ( xxxx > 64k )
+ *      C0 | 2  -> JUMBO 4 x x x x ( xxxx > 64k )
- *      5       -> RTALERT 2 x x
+ *      5       -> RTALERT 2 x x
 */
 static int
@@ -60,16 +60,16 @@ match(const struct sk_buff *skb,
      unsigned int protoff,
      int *hotdrop)
 {
-       struct ipv6_opt_hdr _optsh, *oh;
+        struct ipv6_opt_hdr _optsh, *oh;
-       const struct ip6t_opts *optinfo = matchinfo;
+        const struct ip6t_opts *optinfo = matchinfo;
-       unsigned int temp;
+        unsigned int temp;
-       unsigned int ptr;
+        unsigned int ptr;
-       unsigned int hdrlen = 0;
+        unsigned int hdrlen = 0;
-       unsigned int ret = 0;
+        unsigned int ret = 0;
-       u8 _opttype, *tp = NULL;
+        u8 _opttype, *tp = NULL;
-       u8 _optlen, *lp = NULL;
+        u8 _optlen, *lp = NULL;
-       unsigned int optlen;
+        unsigned int optlen;
-       
 #if HOPBYHOP
        if (ipv6_find_hdr(skb, &ptr, NEXTHDR_HOP, NULL) < 0)
 #else
@@ -77,42 +77,41 @@ match(const struct sk_buff *skb,
 #endif
                return 0;
-       oh = skb_header_pointer(skb, ptr, sizeof(_optsh), &_optsh);
+        oh = skb_header_pointer(skb, ptr, sizeof(_optsh), &_optsh);
-       if (oh == NULL){
+        if (oh == NULL) {
-               *hotdrop = 1;
+                *hotdrop = 1;
-                return 0;
+                return 0;
-       }
+        }
-       hdrlen = ipv6_optlen(oh);
+        hdrlen = ipv6_optlen(oh);
-       if (skb->len - ptr < hdrlen){
+        if (skb->len - ptr < hdrlen) {
-               /* Packet smaller than it's length field */
+                /* Packet smaller than it's length field */
-                return 0;
+                return 0;
-       }
+        }
-       DEBUGP("IPv6 OPTS LEN %u %u ", hdrlen, oh->hdrlen);
+        DEBUGP("IPv6 OPTS LEN %u %u ", hdrlen, oh->hdrlen);
-       DEBUGP("len %02X %04X %02X ",
+        DEBUGP("len %02X %04X %02X ",
-                optinfo->hdrlen, hdrlen,
+               optinfo->hdrlen, hdrlen,
-                (!(optinfo->flags & IP6T_OPTS_LEN) ||
+               (!(optinfo->flags & IP6T_OPTS_LEN) ||
-                           ((optinfo->hdrlen == hdrlen) ^
+                ((optinfo->hdrlen == hdrlen) ^
-                           !!(optinfo->invflags & IP6T_OPTS_INV_LEN))));
+                 !!(optinfo->invflags & IP6T_OPTS_INV_LEN))));
-       ret = (oh != NULL)
+        ret = (oh != NULL) &&
-                &&
+              (!(optinfo->flags & IP6T_OPTS_LEN) ||
-                (!(optinfo->flags & IP6T_OPTS_LEN) ||
+               ((optinfo->hdrlen == hdrlen) ^
-                           ((optinfo->hdrlen == hdrlen) ^
+                !!(optinfo->invflags & IP6T_OPTS_INV_LEN)));
-                           !!(optinfo->invflags & IP6T_OPTS_INV_LEN)));
+        ptr += 2;
-       ptr += 2;
+        hdrlen -= 2;
-       hdrlen -= 2;
+        if (!(optinfo->flags & IP6T_OPTS_OPTS)) {
-       if ( !(optinfo->flags & IP6T_OPTS_OPTS) ){
+                return ret;
-               return ret;
        } else if (optinfo->flags & IP6T_OPTS_NSTRICT) {
                DEBUGP("Not strict - not implemented");
        } else {
                DEBUGP("Strict ");
-                DEBUGP("#%d ",optinfo->optsnr);
+                DEBUGP("#%d ", optinfo->optsnr);
-                for(temp=0; temp<optinfo->optsnr; temp++){
+                for (temp = 0; temp < optinfo->optsnr; temp++) {
                        /* type field exists ? */
                        if (hdrlen < 1)
                                break;
@@ -122,10 +121,10 @@ match(const struct sk_buff *skb,
                                break;
                        /* Type check */
-                        if (*tp != (optinfo->opts[temp] & 0xFF00)>>8){
+                        if (*tp != (optinfo->opts[temp] & 0xFF00) >> 8) {
                                DEBUGP("Tbad %02X %02X\n",
                                       *tp,
-                                       (optinfo->opts[temp] & 0xFF00)>>8);
+                                       (optinfo->opts[temp] & 0xFF00) >> 8);
                                return 0;
                        } else {
                                DEBUGP("Tok ");
@@ -169,7 +168,8 @@ match(const struct sk_buff *skb,
                }
                if (temp == optinfo->optsnr)
                        return ret;
-                else return 0;
+                else
+                        return 0;
        }
        return 0;
@@ -178,25 +178,24 @@ match(const struct sk_buff *skb,
 /* Called when user tries to insert an entry of this type. */
 static int
 checkentry(const char *tablename,
-          const void *entry,
+           const void *entry,
-          void *matchinfo,
+           void *matchinfo,
-          unsigned int matchinfosize,
+           unsigned int matchinfosize,
-          unsigned int hook_mask)
+           unsigned int hook_mask)
 {
-       const struct ip6t_opts *optsinfo = matchinfo;
+        const struct ip6t_opts *optsinfo = matchinfo;
-       if (matchinfosize != IP6T_ALIGN(sizeof(struct ip6t_opts))) {
+        if (matchinfosize != IP6T_ALIGN(sizeof(struct ip6t_opts))) {
-              DEBUGP("ip6t_opts: matchsize %u != %u\n",
+                DEBUGP("ip6t_opts: matchsize %u != %u\n",
-                      matchinfosize, IP6T_ALIGN(sizeof(struct ip6t_opts)));
+                       matchinfosize, IP6T_ALIGN(sizeof(struct ip6t_opts)));
-              return 0;
+                return 0;
-       }
+        }
-       if (optsinfo->invflags & ~IP6T_OPTS_INV_MASK) {
+        if (optsinfo->invflags & ~IP6T_OPTS_INV_MASK) {
-              DEBUGP("ip6t_opts: unknown flags %X\n",
+                DEBUGP("ip6t_opts: unknown flags %X\n", optsinfo->invflags);
-                      optsinfo->invflags);
+                return 0;
-              return 0;
+        }
-       }
+        return 1;
-       return 1;
 }
 static struct ip6t_match opts_match = {
@@ -212,12 +211,12 @@ static struct ip6t_match opts_match = {
 static int __init init(void)
 {
-       return ip6t_register_match(&opts_match);
+        return ip6t_register_match(&opts_match);
 }
 static void __exit cleanup(void)
 {
-       ip6t_unregister_match(&opts_match);
+        ip6t_unregister_match(&opts_match);
 }
 module_init(init);
diff --git a/net/ipv6/netfilter/ip6t_ipv6header.c b/net/ipv6/netfilter/ip6t_ipv6header.c
index fda1ceaf5a29..83ad6b272f7e 100644
--- a/net/ipv6/netfilter/ip6t_ipv6header.c
+++ b/net/ipv6/netfilter/ip6t_ipv6header.c
@@ -50,20 +50,20 @@ ipv6header_match(const struct sk_buff *skb,
        len = skb->len - ptr;
        temp = 0;
-        while (ip6t_ext_hdr(nexthdr)) {
+        while (ip6t_ext_hdr(nexthdr)) {
                struct ipv6_opt_hdr _hdr, *hp;
-                int hdrlen;
+                int hdrlen;
                /* Is there enough space for the next ext header? */
-                if (len < (int)sizeof(struct ipv6_opt_hdr))
+                if (len < (int)sizeof(struct ipv6_opt_hdr))
-                        return 0;
+                        return 0;
                /* No more exthdr -> evaluate */
-                if (nexthdr == NEXTHDR_NONE) {
+                if (nexthdr == NEXTHDR_NONE) {
                        temp |= MASK_NONE;
                        break;
                }
                /* ESP -> evaluate */
-                if (nexthdr == NEXTHDR_ESP) {
+                if (nexthdr == NEXTHDR_ESP) {
                        temp |= MASK_ESP;
                        break;
                }
@@ -72,43 +72,43 @@ ipv6header_match(const struct sk_buff *skb,
                BUG_ON(hp == NULL);
                /* Calculate the header length */
-                if (nexthdr == NEXTHDR_FRAGMENT) {
+                if (nexthdr == NEXTHDR_FRAGMENT) {
-                        hdrlen = 8;
+                        hdrlen = 8;
-                } else if (nexthdr == NEXTHDR_AUTH)
+                } else if (nexthdr == NEXTHDR_AUTH)
-                        hdrlen = (hp->hdrlen+2)<<2;
+                        hdrlen = (hp->hdrlen + 2) << 2;
-                else
+                else
-                        hdrlen = ipv6_optlen(hp);
+                        hdrlen = ipv6_optlen(hp);
                /* set the flag */
-                switch (nexthdr){
+                switch (nexthdr) {
-                        case NEXTHDR_HOP:
+                case NEXTHDR_HOP:
-                                temp |= MASK_HOPOPTS;
+                        temp |= MASK_HOPOPTS;
-                                break;
+                        break;
-                        case NEXTHDR_ROUTING:
+                case NEXTHDR_ROUTING:
-                                temp |= MASK_ROUTING;
+                        temp |= MASK_ROUTING;
-                                break;
+                        break;
-                        case NEXTHDR_FRAGMENT:
+                case NEXTHDR_FRAGMENT:
-                                temp |= MASK_FRAGMENT;
+                        temp |= MASK_FRAGMENT;
-                                break;
+                        break;
-                        case NEXTHDR_AUTH:
+                case NEXTHDR_AUTH:
-                                temp |= MASK_AH;
+                        temp |= MASK_AH;
-                                break;
+                        break;
-                        case NEXTHDR_DEST:
+                case NEXTHDR_DEST:
-                                temp |= MASK_DSTOPTS;
+                        temp |= MASK_DSTOPTS;
-                                break;
+                        break;
-                        default:
+                default:
-                                return 0;
+                        return 0;
-                                break;
+                        break;
                }
-                nexthdr = hp->nexthdr;
+                nexthdr = hp->nexthdr;
-                len -= hdrlen;
+                len -= hdrlen;
-                ptr += hdrlen;
+                ptr += hdrlen;
                if (ptr > skb->len)
                        break;
-        }
+        }
-        if ( (nexthdr != NEXTHDR_NONE ) && (nexthdr != NEXTHDR_ESP) )
+        if ((nexthdr != NEXTHDR_NONE) && (nexthdr != NEXTHDR_ESP))
                temp |= MASK_PROTO;
        if (info->modeflag)
@@ -137,8 +137,8 @@ ipv6header_checkentry(const char *tablename,
                return 0;
        /* invflags is 0 or 0xff in hard mode */
-        if ((!info->modeflag) && info->invflags != 0x00
+        if ((!info->modeflag) && info->invflags != 0x00 &&
-                              && info->invflags != 0xFF)
+            info->invflags != 0xFF)
                return 0;
        return 1;
@@ -152,7 +152,7 @@ static struct ip6t_match ip6t_ipv6header_match = {
        .me             = THIS_MODULE,
 };
-static int  __init ipv6header_init(void)
+static int __init ipv6header_init(void)
 {
        return ip6t_register_match(&ip6t_ipv6header_match);
 }
@@ -164,4 +164,3 @@ static void __exit ipv6header_exit(void)
 module_init(ipv6header_init);
 module_exit(ipv6header_exit);
diff --git a/net/ipv6/netfilter/ip6t_owner.c b/net/ipv6/netfilter/ip6t_owner.c
index 5409b375b512..8c8a4c7ec934 100644
--- a/net/ipv6/netfilter/ip6t_owner.c
+++ b/net/ipv6/netfilter/ip6t_owner.c
@@ -36,14 +36,14 @@ match(const struct sk_buff *skb,
        if (!skb->sk || !skb->sk->sk_socket || !skb->sk->sk_socket->file)
                return 0;
-        if(info->match & IP6T_OWNER_UID) {
+        if (info->match & IP6T_OWNER_UID) {
-                if((skb->sk->sk_socket->file->f_uid != info->uid) ^
+                if ((skb->sk->sk_socket->file->f_uid != info->uid) ^
                    !!(info->invert & IP6T_OWNER_UID))
                        return 0;
        }
-        if(info->match & IP6T_OWNER_GID) {
+        if (info->match & IP6T_OWNER_GID) {
-                if((skb->sk->sk_socket->file->f_gid != info->gid) ^
+                if ((skb->sk->sk_socket->file->f_gid != info->gid) ^
                    !!(info->invert & IP6T_OWNER_GID))
                        return 0;
        }
@@ -53,23 +53,23 @@ match(const struct sk_buff *skb,
 static int
 checkentry(const char *tablename,
-           const void  *ip,
+           const void *ip,
-           void *matchinfo,
+           void *matchinfo,
-           unsigned int matchsize,
+           unsigned int matchsize,
-           unsigned int hook_mask)
+           unsigned int hook_mask)
 {
        const struct ip6t_owner_info *info = matchinfo;
-        if (hook_mask
+        if (hook_mask
-            & ~((1 << NF_IP6_LOCAL_OUT) | (1 << NF_IP6_POST_ROUTING))) {
+            & ~((1 << NF_IP6_LOCAL_OUT) | (1 << NF_IP6_POST_ROUTING))) {
-                printk("ip6t_owner: only valid for LOCAL_OUT or POST_ROUTING.\n");
+                printk("ip6t_owner: only valid for LOCAL_OUT or POST_ROUTING.\n");
-                return 0;
+                return 0;
-        }
+        }
        if (matchsize != IP6T_ALIGN(sizeof(struct ip6t_owner_info)))
                return 0;
-        if (info->match & (IP6T_OWNER_PID|IP6T_OWNER_SID)) {
+        if (info->match & (IP6T_OWNER_PID | IP6T_OWNER_SID)) {
                printk("ipt_owner: pid and sid matching "
                       "not supported anymore\n");
                return 0;
diff --git a/net/ipv6/netfilter/ip6t_policy.c b/net/ipv6/netfilter/ip6t_policy.c
index 13fedad48c1d..afe1cc4c18a5 100644
--- a/net/ipv6/netfilter/ip6t_policy.c
+++ b/net/ipv6/netfilter/ip6t_policy.c
@@ -118,7 +118,7 @@ static int match(const struct sk_buff *skb,
        return ret;
 }
-static int checkentry(const char *tablename, const struct ip6t_ip6 *ip,
+static int checkentry(const char *tablename, const void *ip_void,
                      void *matchinfo, unsigned int matchsize,
                      unsigned int hook_mask)
 {
diff --git a/net/ipv6/netfilter/ip6t_rt.c b/net/ipv6/netfilter/ip6t_rt.c
index 8465b4375855..8f82476dc89e 100644
--- a/net/ipv6/netfilter/ip6t_rt.c
+++ b/net/ipv6/netfilter/ip6t_rt.c
@@ -33,12 +33,12 @@ MODULE_AUTHOR("Andras Kis-Szabo <kisza@sch.bme.hu>");
 static inline int
 segsleft_match(u_int32_t min, u_int32_t max, u_int32_t id, int invert)
 {
-       int r=0;
+        int r = 0;
-       DEBUGP("rt segsleft_match:%c 0x%x <= 0x%x <= 0x%x",invert? '!':' ',
+        DEBUGP("rt segsleft_match:%c 0x%x <= 0x%x <= 0x%x",
-              min,id,max);
+               invert ? '!' : ' ', min, id, max);
-       r=(id >= min && id <= max) ^ invert;
+        r = (id >= min && id <= max) ^ invert;
-       DEBUGP(" result %s\n",r? "PASS" : "FAILED");
+        DEBUGP(" result %s\n", r ? "PASS" : "FAILED");
-       return r;
+        return r;
 }
 static int
@@ -50,87 +50,93 @@ match(const struct sk_buff *skb,
      unsigned int protoff,
      int *hotdrop)
 {
-       struct ipv6_rt_hdr _route, *rh;
+        struct ipv6_rt_hdr _route, *rh;
-       const struct ip6t_rt *rtinfo = matchinfo;
+        const struct ip6t_rt *rtinfo = matchinfo;
-       unsigned int temp;
+        unsigned int temp;
-       unsigned int ptr;
+        unsigned int ptr;
-       unsigned int hdrlen = 0;
+        unsigned int hdrlen = 0;
-       unsigned int ret = 0;
+        unsigned int ret = 0;
-       struct in6_addr *ap, _addr;
+        struct in6_addr *ap, _addr;
        if (ipv6_find_hdr(skb, &ptr, NEXTHDR_ROUTING, NULL) < 0)
                return 0;
-       rh = skb_header_pointer(skb, ptr, sizeof(_route), &_route);
+        rh = skb_header_pointer(skb, ptr, sizeof(_route), &_route);
-       if (rh == NULL){
+        if (rh == NULL) {
-               *hotdrop = 1;
+                *hotdrop = 1;
-                return 0;
+                return 0;
-       }
+        }
-       hdrlen = ipv6_optlen(rh);
+        hdrlen = ipv6_optlen(rh);
-       if (skb->len - ptr < hdrlen){
+        if (skb->len - ptr < hdrlen) {
-               /* Pcket smaller than its length field */
+                /* Pcket smaller than its length field */
-                return 0;
+                return 0;
-       }
+        }
-       DEBUGP("IPv6 RT LEN %u %u ", hdrlen, rh->hdrlen);
+        DEBUGP("IPv6 RT LEN %u %u ", hdrlen, rh->hdrlen);
-       DEBUGP("TYPE %04X ", rh->type);
+        DEBUGP("TYPE %04X ", rh->type);
-       DEBUGP("SGS_LEFT %u %02X\n", rh->segments_left, rh->segments_left);
+        DEBUGP("SGS_LEFT %u %02X\n", rh->segments_left, rh->segments_left);
-       DEBUGP("IPv6 RT segsleft %02X ",
+        DEBUGP("IPv6 RT segsleft %02X ",
-                (segsleft_match(rtinfo->segsleft[0], rtinfo->segsleft[1],
+               (segsleft_match(rtinfo->segsleft[0], rtinfo->segsleft[1],
-                           rh->segments_left,
+                               rh->segments_left,
-                           !!(rtinfo->invflags & IP6T_RT_INV_SGS))));
+                               !!(rtinfo->invflags & IP6T_RT_INV_SGS))));
-       DEBUGP("type %02X %02X %02X ",
+        DEBUGP("type %02X %02X %02X ",
-                rtinfo->rt_type, rh->type, 
+               rtinfo->rt_type, rh->type,
-                (!(rtinfo->flags & IP6T_RT_TYP) ||
+               (!(rtinfo->flags & IP6T_RT_TYP) ||
-                           ((rtinfo->rt_type == rh->type) ^
+                ((rtinfo->rt_type == rh->type) ^
-                           !!(rtinfo->invflags & IP6T_RT_INV_TYP))));
+                 !!(rtinfo->invflags & IP6T_RT_INV_TYP))));
-       DEBUGP("len %02X %04X %02X ",
+        DEBUGP("len %02X %04X %02X ",
-                rtinfo->hdrlen, hdrlen,
+               rtinfo->hdrlen, hdrlen,
-                (!(rtinfo->flags & IP6T_RT_LEN) ||
+               (!(rtinfo->flags & IP6T_RT_LEN) ||
-                           ((rtinfo->hdrlen == hdrlen) ^
+                ((rtinfo->hdrlen == hdrlen) ^
-                           !!(rtinfo->invflags & IP6T_RT_INV_LEN))));
+                 !!(rtinfo->invflags & IP6T_RT_INV_LEN))));
-       DEBUGP("res %02X %02X %02X ", 
+        DEBUGP("res %02X %02X %02X ",
-                (rtinfo->flags & IP6T_RT_RES), ((struct rt0_hdr *)rh)->reserved,
+               (rtinfo->flags & IP6T_RT_RES),
-                !((rtinfo->flags & IP6T_RT_RES) && (((struct rt0_hdr *)rh)->reserved)));
+               ((struct rt0_hdr *)rh)->reserved,
+               !((rtinfo->flags & IP6T_RT_RES) &&
-       ret = (rh != NULL)
+                 (((struct rt0_hdr *)rh)->reserved)));
-                &&
-                (segsleft_match(rtinfo->segsleft[0], rtinfo->segsleft[1],
+        ret = (rh != NULL)
-                           rh->segments_left,
+              &&
-                           !!(rtinfo->invflags & IP6T_RT_INV_SGS)))
+              (segsleft_match(rtinfo->segsleft[0], rtinfo->segsleft[1],
-                &&
+                              rh->segments_left,
-                (!(rtinfo->flags & IP6T_RT_LEN) ||
+                              !!(rtinfo->invflags & IP6T_RT_INV_SGS)))
-                           ((rtinfo->hdrlen == hdrlen) ^
+              &&
-                           !!(rtinfo->invflags & IP6T_RT_INV_LEN)))
+              (!(rtinfo->flags & IP6T_RT_LEN) ||
-                &&
+               ((rtinfo->hdrlen == hdrlen) ^
-                (!(rtinfo->flags & IP6T_RT_TYP) ||
+                !!(rtinfo->invflags & IP6T_RT_INV_LEN)))
-                           ((rtinfo->rt_type == rh->type) ^
+              &&
-                           !!(rtinfo->invflags & IP6T_RT_INV_TYP)));
+              (!(rtinfo->flags & IP6T_RT_TYP) ||
+               ((rtinfo->rt_type == rh->type) ^
+                !!(rtinfo->invflags & IP6T_RT_INV_TYP)));
        if (ret && (rtinfo->flags & IP6T_RT_RES)) {
                u_int32_t *rp, _reserved;
                rp = skb_header_pointer(skb,
-                                        ptr + offsetof(struct rt0_hdr, reserved),
+                                        ptr + offsetof(struct rt0_hdr,
-                                        sizeof(_reserved), &_reserved);
+                                                       reserved),
+                                        sizeof(_reserved),
+                                        &_reserved);
                ret = (*rp == 0);
        }
-        DEBUGP("#%d ",rtinfo->addrnr);
+        DEBUGP("#%d ", rtinfo->addrnr);
-       if ( !(rtinfo->flags & IP6T_RT_FST) ){
+        if (!(rtinfo->flags & IP6T_RT_FST)) {
-               return ret;
+                return ret;
        } else if (rtinfo->flags & IP6T_RT_FST_NSTRICT) {
                DEBUGP("Not strict ");
-                if ( rtinfo->addrnr > (unsigned int)((hdrlen-8)/16) ){
+                if (rtinfo->addrnr > (unsigned int)((hdrlen - 8) / 16)) {
                        DEBUGP("There isn't enough space\n");
                        return 0;
                } else {
                        unsigned int i = 0;
-                        DEBUGP("#%d ",rtinfo->addrnr);
+                        DEBUGP("#%d ", rtinfo->addrnr);
-                        for(temp=0; temp<(unsigned int)((hdrlen-8)/16); temp++){
+                        for (temp = 0;
+                             temp < (unsigned int)((hdrlen - 8) / 16);
+                             temp++) {
                                ap = skb_header_pointer(skb,
                                                        ptr
                                                        + sizeof(struct rt0_hdr)
@@ -141,24 +147,26 @@ match(const struct sk_buff *skb,
                                BUG_ON(ap == NULL);
                                if (ipv6_addr_equal(ap, &rtinfo->addrs[i])) {
-                                        DEBUGP("i=%d temp=%d;\n",i,temp);
+                                        DEBUGP("i=%d temp=%d;\n", i, temp);
                                        i++;
                                }
-                                if (i==rtinfo->addrnr) break;
+                                if (i == rtinfo->addrnr)
+                                        break;
                        }
                        DEBUGP("i=%d #%d\n", i, rtinfo->addrnr);
                        if (i == rtinfo->addrnr)
                                return ret;
-                        else return 0;
+                        else
+                                return 0;
                }
        } else {
                DEBUGP("Strict ");
-                if ( rtinfo->addrnr > (unsigned int)((hdrlen-8)/16) ){
+                if (rtinfo->addrnr > (unsigned int)((hdrlen - 8) / 16)) {
                        DEBUGP("There isn't enough space\n");
                        return 0;
                } else {
-                        DEBUGP("#%d ",rtinfo->addrnr);
+                        DEBUGP("#%d ", rtinfo->addrnr);
-                        for(temp=0; temp<rtinfo->addrnr; temp++){
+                        for (temp = 0; temp < rtinfo->addrnr; temp++) {
                                ap = skb_header_pointer(skb,
                                                        ptr
                                                        + sizeof(struct rt0_hdr)
@@ -171,9 +179,11 @@ match(const struct sk_buff *skb,
                                        break;
                        }
                        DEBUGP("temp=%d #%d\n", temp, rtinfo->addrnr);
-                        if ((temp == rtinfo->addrnr) && (temp == (unsigned int)((hdrlen-8)/16)))
+                        if ((temp == rtinfo->addrnr) &&
+                            (temp == (unsigned int)((hdrlen - 8) / 16)))
                                return ret;
-                        else return 0;
+                        else
+                                return 0;
                }
        }
@@ -183,32 +193,31 @@ match(const struct sk_buff *skb,
 /* Called when user tries to insert an entry of this type. */
 static int
 checkentry(const char *tablename,
-          const void *entry,
+           const void *entry,
-          void *matchinfo,
+           void *matchinfo,
-          unsigned int matchinfosize,
+           unsigned int matchinfosize,
-          unsigned int hook_mask)
+           unsigned int hook_mask)
 {
-       const struct ip6t_rt *rtinfo = matchinfo;
+        const struct ip6t_rt *rtinfo = matchinfo;
-       if (matchinfosize != IP6T_ALIGN(sizeof(struct ip6t_rt))) {
+        if (matchinfosize != IP6T_ALIGN(sizeof(struct ip6t_rt))) {
-              DEBUGP("ip6t_rt: matchsize %u != %u\n",
+                DEBUGP("ip6t_rt: matchsize %u != %u\n",
-                      matchinfosize, IP6T_ALIGN(sizeof(struct ip6t_rt)));
+                       matchinfosize, IP6T_ALIGN(sizeof(struct ip6t_rt)));
-              return 0;
+                return 0;
-       }
+        }
-       if (rtinfo->invflags & ~IP6T_RT_INV_MASK) {
+        if (rtinfo->invflags & ~IP6T_RT_INV_MASK) {
-              DEBUGP("ip6t_rt: unknown flags %X\n",
+                DEBUGP("ip6t_rt: unknown flags %X\n", rtinfo->invflags);
-                      rtinfo->invflags);
+                return 0;
-              return 0;
+        }
-       }
+        if ((rtinfo->flags & (IP6T_RT_RES | IP6T_RT_FST_MASK)) &&
-       if ( (rtinfo->flags & (IP6T_RT_RES|IP6T_RT_FST_MASK)) && 
+            (!(rtinfo->flags & IP6T_RT_TYP) ||
-                       (!(rtinfo->flags & IP6T_RT_TYP) || 
+             (rtinfo->rt_type != 0) ||
-                       (rtinfo->rt_type != 0) || 
+             (rtinfo->invflags & IP6T_RT_INV_TYP))) {
-                       (rtinfo->invflags & IP6T_RT_INV_TYP)) ) {
+                DEBUGP("`--rt-type 0' required before `--rt-0-*'");
-              DEBUGP("`--rt-type 0' required before `--rt-0-*'");
+                return 0;
-              return 0;
+        }
-       }
+        return 1;
-       return 1;
 }
 static struct ip6t_match rt_match = {
@@ -220,12 +229,12 @@ static struct ip6t_match rt_match = {
 static int __init init(void)
 {
-       return ip6t_register_match(&rt_match);
+        return ip6t_register_match(&rt_match);
 }
 static void __exit cleanup(void)
 {
-       ip6t_unregister_match(&rt_match);
+        ip6t_unregister_match(&rt_match);
 }
 module_init(init);
diff --git a/net/rxrpc/krxtimod.c b/net/rxrpc/krxtimod.c
index 3ac81cdd1211..3e7466900bd4 100644
--- a/net/rxrpc/krxtimod.c
+++ b/net/rxrpc/krxtimod.c
@@ -81,7 +81,7 @@ static int krxtimod(void *arg)
        for (;;) {
                unsigned long jif;
-                signed long timeout;
+                long timeout;
                /* deal with the server being asked to die */
                if (krxtimod_die) {
diff --git a/net/rxrpc/proc.c b/net/rxrpc/proc.c
index 3b5ecd8e2401..29975d99d864 100644
--- a/net/rxrpc/proc.c
+++ b/net/rxrpc/proc.c
@@ -361,7 +361,7 @@ static void rxrpc_proc_peers_stop(struct seq_file *p, void *v)
 static int rxrpc_proc_peers_show(struct seq_file *m, void *v)
 {
        struct rxrpc_peer *peer = list_entry(v, struct rxrpc_peer, proc_link);
-        signed long timeout;
+        long timeout;
        /* display header on line 1 */
        if (v == SEQ_START_TOKEN) {
@@ -373,8 +373,8 @@ static int rxrpc_proc_peers_show(struct seq_file *m, void *v)
        /* display one peer per line on subsequent lines */
        timeout = 0;
        if (!list_empty(&peer->timeout.link))
-                timeout = (signed long) peer->timeout.timo_jif -
+                timeout = (long) peer->timeout.timo_jif -
-                        (signed long) jiffies;
+                        (long) jiffies;
        seq_printf(m, "%5hu %08x %5d %5d %8ld %5Zu %7lu\n",
                   peer->trans->port,
@@ -468,7 +468,7 @@ static void rxrpc_proc_conns_stop(struct seq_file *p, void *v)
 static int rxrpc_proc_conns_show(struct seq_file *m, void *v)
 {
        struct rxrpc_connection *conn;
-        signed long timeout;
+        long timeout;
        conn = list_entry(v, struct rxrpc_connection, proc_link);
@@ -484,8 +484,8 @@ static int rxrpc_proc_conns_show(struct seq_file *m, void *v)
        /* display one conn per line on subsequent lines */
        timeout = 0;
        if (!list_empty(&conn->timeout.link))
-                timeout = (signed long) conn->timeout.timo_jif -
+                timeout = (long) conn->timeout.timo_jif -
-                        (signed long) jiffies;
+                        (long) jiffies;
        seq_printf(m,
                   "%5hu %08x %5hu %04hx %08x %-3.3s %08x %08x %5Zu %8ld\n",
diff --git a/net/sched/sch_prio.c b/net/sched/sch_prio.c
index 5b3a3e48ed92..1641db33a994 100644
--- a/net/sched/sch_prio.c
+++ b/net/sched/sch_prio.c
@@ -228,14 +228,13 @@ static int prio_tune(struct Qdisc *sch, struct rtattr *opt)
        }
        sch_tree_unlock(sch);
-        for (i=0; i<=TC_PRIO_MAX; i++) {
+        for (i=0; i<q->bands; i++) {
-                int band = q->prio2band[i];
+                if (q->queues[i] == &noop_qdisc) {
-                if (q->queues[band] == &noop_qdisc) {
                        struct Qdisc *child;
                        child = qdisc_create_dflt(sch->dev, &pfifo_qdisc_ops);
                        if (child) {
                                sch_tree_lock(sch);
-                                child = xchg(&q->queues[band], child);
+                                child = xchg(&q->queues[i], child);
                                if (child != &noop_qdisc)
                                        qdisc_destroy(child);
diff --git a/net/sched/sch_sfq.c b/net/sched/sch_sfq.c
index 8734bb7280e3..86d8da0cbd02 100644
--- a/net/sched/sch_sfq.c
+++ b/net/sched/sch_sfq.c
@@ -144,6 +144,8 @@ static unsigned sfq_hash(struct sfq_sched_data *q, struct sk_buff *skb)
                if (!(iph->frag_off&htons(IP_MF|IP_OFFSET)) &&
                    (iph->protocol == IPPROTO_TCP ||
                     iph->protocol == IPPROTO_UDP ||
+                     iph->protocol == IPPROTO_SCTP ||
+                     iph->protocol == IPPROTO_DCCP ||
                     iph->protocol == IPPROTO_ESP))
                        h2 ^= *(((u32*)iph) + iph->ihl);
                break;
@@ -155,6 +157,8 @@ static unsigned sfq_hash(struct sfq_sched_data *q, struct sk_buff *skb)
                h2 = iph->saddr.s6_addr32[3]^iph->nexthdr;
                if (iph->nexthdr == IPPROTO_TCP ||
                    iph->nexthdr == IPPROTO_UDP ||
+                    iph->nexthdr == IPPROTO_SCTP ||
+                    iph->nexthdr == IPPROTO_DCCP ||
                    iph->nexthdr == IPPROTO_ESP)
                        h2 ^= *(u32*)&iph[1];
                break;
diff --git a/net/sunrpc/auth_gss/svcauth_gss.c b/net/sunrpc/auth_gss/svcauth_gss.c
index e4ada15ed856..23632d84d8d7 100644
--- a/net/sunrpc/auth_gss/svcauth_gss.c
+++ b/net/sunrpc/auth_gss/svcauth_gss.c
@@ -420,7 +420,8 @@ static int rsc_parse(struct cache_detail *cd,
                        gss_mech_put(gm);
                        goto out;
                }
-                if (gss_import_sec_context(buf, len, gm, &rsci.mechctx)) {
+                status = gss_import_sec_context(buf, len, gm, &rsci.mechctx);
+                if (status) {
                        gss_mech_put(gm);
                        goto out;
                }
@@ -586,6 +587,20 @@ gss_verify_header(struct svc_rqst *rqstp, struct rsc *rsci,
 }
 static int
+gss_write_null_verf(struct svc_rqst *rqstp)
+{
+        u32     *p;
+        svc_putu32(rqstp->rq_res.head, htonl(RPC_AUTH_NULL));
+        p = rqstp->rq_res.head->iov_base + rqstp->rq_res.head->iov_len;
+        /* don't really need to check if head->iov_len > PAGE_SIZE ... */
+        *p++ = 0;
+        if (!xdr_ressize_check(rqstp, p))
+                return -1;
+        return 0;
+}
+static int
 gss_write_verf(struct svc_rqst *rqstp, struct gss_ctx *ctx_id, u32 seq)
 {
        u32                     xdr_seq;
@@ -741,6 +756,21 @@ svcauth_gss_set_client(struct svc_rqst *rqstp)
        return SVC_OK;
 }
+static inline int
+gss_write_init_verf(struct svc_rqst *rqstp, struct rsi *rsip)
+{
+        struct rsc *rsci;
+        if (rsip->major_status != GSS_S_COMPLETE)
+                return gss_write_null_verf(rqstp);
+        rsci = gss_svc_searchbyctx(&rsip->out_handle);
+        if (rsci == NULL) {
+                rsip->major_status = GSS_S_NO_CONTEXT;
+                return gss_write_null_verf(rqstp);
+        }
+        return gss_write_verf(rqstp, rsci->mechctx, GSS_SEQ_WIN);
+}
 /*
 * Accept an rpcsec packet.
 * If context establishment, punt to user space
@@ -876,11 +906,7 @@ svcauth_gss_accept(struct svc_rqst *rqstp, u32 *authp)
                case -ENOENT:
                        goto drop;
                case 0:
-                        rsci = gss_svc_searchbyctx(&rsip->out_handle);
+                        if (gss_write_init_verf(rqstp, rsip))
-                        if (!rsci) {
-                                goto drop;
-                        }
-                        if (gss_write_verf(rqstp, rsci->mechctx, GSS_SEQ_WIN))
                                goto drop;
                        if (resv->iov_len + 4 > PAGE_SIZE)
                                goto drop;
diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c
index e67613e4eb18..50580620e897 100644
--- a/net/sunrpc/svcsock.c
+++ b/net/sunrpc/svcsock.c
@@ -1527,6 +1527,7 @@ svc_defer(struct cache_req *req)
                dr->handle.owner = rqstp->rq_server;
                dr->prot = rqstp->rq_prot;
                dr->addr = rqstp->rq_addr;
+                dr->daddr = rqstp->rq_daddr;
                dr->argslen = rqstp->rq_arg.len >> 2;
                memcpy(dr->args, rqstp->rq_arg.head[0].iov_base-skip, dr->argslen<<2);
        }
@@ -1552,6 +1553,7 @@ static int svc_deferred_recv(struct svc_rqst *rqstp)
        rqstp->rq_arg.len = dr->argslen<<2;
        rqstp->rq_prot        = dr->prot;
        rqstp->rq_addr        = dr->addr;
+        rqstp->rq_daddr       = dr->daddr;
        return dr->argslen<<2;
 }
diff --git a/net/tipc/Kconfig b/net/tipc/Kconfig
index 05ab18e62dee..3891cc00087d 100644
--- a/net/tipc/Kconfig
+++ b/net/tipc/Kconfig
@@ -8,7 +8,12 @@ menu "TIPC Configuration (EXPERIMENTAL)"
 config TIPC
        tristate "The TIPC Protocol (EXPERIMENTAL)"
        ---help---
-          TBD.
+          The Transparent Inter Process Communication (TIPC) protocol is
+          specially designed for intra cluster communication. This protocol
+          originates from Ericsson where it has been used in carrier grade
+          cluster applications for many years.
+        
+          For more information about TIPC, see http://tipc.sourceforge.net.
          This protocol support is also available as a module ( = code which
          can be inserted in and removed from the running kernel whenever you
diff --git a/net/tipc/addr.c b/net/tipc/addr.c
index eca22260c98c..0be25e175b93 100644
--- a/net/tipc/addr.c
+++ b/net/tipc/addr.c
@@ -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));
 }
diff --git a/net/tipc/addr.h b/net/tipc/addr.h
index 02ca71783e2e..bcfebb3cbbf3 100644
--- a/net/tipc/addr.h
+++ b/net/tipc/addr.h
@@ -122,7 +122,7 @@ static inline char *addr_string_fill(char *string, u32 addr)
        return string;
 }
-int addr_domain_valid(u32);
+int tipc_addr_domain_valid(u32);
-int addr_node_valid(u32 addr);
+int tipc_addr_node_valid(u32 addr);
 #endif
diff --git a/net/tipc/bcast.c b/net/tipc/bcast.c
index 9713d622efb8..a7b04f397c12 100644
--- a/net/tipc/bcast.c
+++ b/net/tipc/bcast.c
@@ -82,7 +82,7 @@ struct bcbearer {
        struct bearer bearer;
        struct media media;
        struct bcbearer_pair bpairs[MAX_BEARERS];
-        struct bcbearer_pair bpairs_temp[TIPC_NUM_LINK_PRI];
+        struct bcbearer_pair bpairs_temp[TIPC_MAX_LINK_PRI + 1];
 };
 /**
@@ -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);
+                        tipc_node_lock(node);
-                        bclink_acknowledge(node, msg_bcast_ack(msg));
+                        tipc_bclink_acknowledge(node, msg_bcast_ack(msg));
-                        node_unlock(node);
+                        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);
+                        tipc_node_unlock(node);
-                        port_recv_mcast(buf, NULL);
+                        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);
+                        tipc_node_unlock(node);
-                        link_recv_bundle(buf);
+                        tipc_link_recv_bundle(buf);
                } else if (msg_user(msg) == MSG_FRAGMENTER) {
                        bcl->stats.recv_fragments++;
-                        if (link_recv_fragment(&node->bclink.defragm,
+                        if (tipc_link_recv_fragment(&node->bclink.defragm,
-                                               &buf, &msg))
+                                                    &buf, &msg))
                                bcl->stats.recv_fragmented++;
-                        node_unlock(node);
+                        tipc_node_unlock(node);
-                        net_route_msg(buf);
+                        tipc_net_route_msg(buf);
                } else {
-                        node_unlock(node);
+                        tipc_node_unlock(node);
-                        net_route_msg(buf);
+                        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,
+                if (tipc_link_defer_pkt(&node->bclink.deferred_head,
-                                   &node->bclink.deferred_tail,
+                                        &node->bclink.deferred_tail,
-                                   buf)) {
+                                        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,
+int tipc_bcbearer_send(struct sk_buff *buf,
-                  struct tipc_bearer *unused1,
+                       struct tipc_bearer *unused1,
-                  struct tipc_media_addr *unused2)
+                       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);
+                assert(tipc_cltr_bcast_nodes.count != 0);
-                bcbuf_set_acks(buf, cluster_bcast_nodes.count);
+                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;
@@ -630,7 +630,7 @@ void bcbearer_sort(void)
        bp_curr = bcbearer->bpairs;
        memset(bcbearer->bpairs, 0, sizeof(bcbearer->bpairs));
-        for (pri = (TIPC_NUM_LINK_PRI - 1); pri >= 0; pri--) {
+        for (pri = TIPC_MAX_LINK_PRI; pri >= 0; pri--) {
                if (!bp_temp[pri].primary)
                        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,
+                        if (tipc_nmap_equal(&bp_temp[pri].primary->nodes,
-                                       &bp_temp[pri].secondary->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;
diff --git a/net/tipc/bcast.h b/net/tipc/bcast.h
index 5430e524b4f9..0e3be2ab3307 100644
--- a/net/tipc/bcast.h
+++ b/net/tipc/bcast.h
@@ -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,
+static inline void tipc_nmap_diff(struct node_map *nm_a, struct node_map *nm_b,
-                             struct node_map *nm_diff)
+                                  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);
+int  tipc_bclink_init(void);
-void bclink_stop(void);
+void tipc_bclink_stop(void);
-void bclink_acknowledge(struct node *n_ptr, u32 acked);
+void tipc_bclink_acknowledge(struct node *n_ptr, u32 acked);
-int  bclink_send_msg(struct sk_buff *buf);
+int  tipc_bclink_send_msg(struct sk_buff *buf);
-void bclink_recv_pkt(struct sk_buff *buf);
+void tipc_bclink_recv_pkt(struct sk_buff *buf);
-u32  bclink_get_last_sent(void);
+u32  tipc_bclink_get_last_sent(void);
-u32  bclink_acks_missing(struct node *n_ptr);
+u32  tipc_bclink_acks_missing(struct node *n_ptr);
-void bclink_check_gap(struct node *n_ptr, u32 seqno);
+void tipc_bclink_check_gap(struct node *n_ptr, u32 seqno);
-int  bclink_stats(char *stats_buf, const u32 buf_size);
+int  tipc_bclink_stats(char *stats_buf, const u32 buf_size);
-int  bclink_reset_stats(void);
+int  tipc_bclink_reset_stats(void);
-int  bclink_set_queue_limits(u32 limit);
+int  tipc_bclink_set_queue_limits(u32 limit);
-void bcbearer_sort(void);
+void tipc_bcbearer_sort(void);
-void bcbearer_push(void);
+void tipc_bcbearer_push(void);
 #endif
diff --git a/net/tipc/bearer.c b/net/tipc/bearer.c
index 3dd19fdc5a2c..64dcb0f3a8b2 100644
--- a/net/tipc/bearer.c
+++ b/net/tipc/bearer.c
@@ -48,7 +48,7 @@
 static struct media *media_list = 0;
 static u32 media_count = 0;
-struct bearer *bearers = 0;
+struct bearer *tipc_bearers = 0;
 /**
 * media_name_valid - validate media name
@@ -107,7 +107,7 @@ int  tipc_register_media(u32 media_type,
        u32 i;
        int res = -EINVAL;
-        write_lock_bh(&net_lock);
+        write_lock_bh(&tipc_net_lock);
        if (!media_list)
                goto exit;
@@ -119,7 +119,8 @@ int  tipc_register_media(u32 media_type,
                warn("Media registration error: no broadcast address supplied\n");
                goto exit;
        }
-        if (bearer_priority >= TIPC_NUM_LINK_PRI) {
+        if ((bearer_priority < TIPC_MIN_LINK_PRI) &&
+            (bearer_priority > TIPC_MAX_LINK_PRI)) {
                warn("Media registration error: priority %u\n", bearer_priority);
                goto exit;
        }
@@ -164,15 +165,15 @@ int  tipc_register_media(u32 media_type,
        dbg("Media <%s> registered\n", name);
        res = 0;
 exit:
-        write_unlock_bh(&net_lock);
+        write_unlock_bh(&tipc_net_lock);
        return res;
 }
 /**
- * media_addr_printf - record media address in print buffer
+ * tipc_media_addr_printf - record media address in print buffer
 */
-void media_addr_printf(struct print_buf *pb, struct tipc_media_addr *a)
+void tipc_media_addr_printf(struct print_buf *pb, struct tipc_media_addr *a)
 {
        struct media *m_ptr;
        u32 media_type;
@@ -200,25 +201,25 @@ void media_addr_printf(struct print_buf *pb, struct tipc_media_addr *a)
 }
 /**
- * media_get_names - record names of registered media in buffer
+ * tipc_media_get_names - record names of registered media in buffer
 */
-struct sk_buff *media_get_names(void)
+struct sk_buff *tipc_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));
+        buf = tipc_cfg_reply_alloc(MAX_MEDIA * TLV_SPACE(TIPC_MAX_MEDIA_NAME));
        if (!buf)
                return NULL;
-        read_lock_bh(&net_lock);
+        read_lock_bh(&tipc_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, 
+                tipc_cfg_append_tlv(buf, TIPC_TLV_MEDIA_NAME, m_ptr->name, 
-                               strlen(m_ptr->name) + 1);
+                                    strlen(m_ptr->name) + 1);
        }
-        read_unlock_bh(&net_lock);
+        read_unlock_bh(&tipc_net_lock);
        return buf;
 }
@@ -282,7 +283,7 @@ 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++) {
+        for (i = 0, b_ptr = tipc_bearers; i < MAX_BEARERS; i++, b_ptr++) {
                if (b_ptr->active && (!strcmp(b_ptr->publ.name, name)))
                        return b_ptr;
        }
@@ -290,16 +291,16 @@ static struct bearer *bearer_find(const char *name)
 }
 /**
- * bearer_find - locates bearer object with matching interface name
+ * tipc_bearer_find_interface - locates bearer object with matching interface name
 */
-struct bearer *bearer_find_interface(const char *if_name)
+struct bearer *tipc_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++) {
+        for (i = 0, b_ptr = tipc_bearers; i < MAX_BEARERS; i++, b_ptr++) {
                if (!b_ptr->active)
                        continue;
                b_if_name = strchr(b_ptr->publ.name, ':') + 1;
@@ -310,54 +311,54 @@ struct bearer *bearer_find_interface(const char *if_name)
 }
 /**
- * bearer_get_names - record names of bearers in buffer
+ * tipc_bearer_get_names - record names of bearers in buffer
 */
-struct sk_buff *bearer_get_names(void)
+struct sk_buff *tipc_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));
+        buf = tipc_cfg_reply_alloc(MAX_BEARERS * TLV_SPACE(TIPC_MAX_BEARER_NAME));
        if (!buf)
                return NULL;
-        read_lock_bh(&net_lock);
+        read_lock_bh(&tipc_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];
+                        b_ptr = &tipc_bearers[j];
                        if (b_ptr->active && (b_ptr->media == m_ptr)) {
-                                cfg_append_tlv(buf, TIPC_TLV_BEARER_NAME, 
+                                tipc_cfg_append_tlv(buf, TIPC_TLV_BEARER_NAME, 
-                                               b_ptr->publ.name, 
+                                                    b_ptr->publ.name, 
-                                               strlen(b_ptr->publ.name) + 1);
+                                                    strlen(b_ptr->publ.name) + 1);
                        }
                }
        }
-        read_unlock_bh(&net_lock);
+        read_unlock_bh(&tipc_net_lock);
        return buf;
 }
-void bearer_add_dest(struct bearer *b_ptr, u32 dest)
+void tipc_bearer_add_dest(struct bearer *b_ptr, u32 dest)
 {
-        nmap_add(&b_ptr->nodes, dest);
+        tipc_nmap_add(&b_ptr->nodes, dest);
-        disc_update_link_req(b_ptr->link_req);
+        tipc_disc_update_link_req(b_ptr->link_req);
-        bcbearer_sort();
+        tipc_bcbearer_sort();
 }
-void bearer_remove_dest(struct bearer *b_ptr, u32 dest)
+void tipc_bearer_remove_dest(struct bearer *b_ptr, u32 dest)
 {
-        nmap_remove(&b_ptr->nodes, dest);
+        tipc_nmap_remove(&b_ptr->nodes, dest);
-        disc_update_link_req(b_ptr->link_req);
+        tipc_disc_update_link_req(b_ptr->link_req);
-        bcbearer_sort();
+        tipc_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
+ * 'tipc_net_lock' is read_locked when this function is called
 * bearer.lock must be taken before calling
 * Returns binary true(1) ore false(0)
 */
@@ -371,7 +372,7 @@ static int bearer_push(struct bearer *b_ptr)
        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);
+                        res = tipc_link_push_packet(ln);
                        if (res == PUSH_FAILED)
                                break;
                        if (res == PUSH_FINISHED)
@@ -381,7 +382,7 @@ static int bearer_push(struct bearer *b_ptr)
        return list_empty(&b_ptr->cong_links);
 }
-void bearer_lock_push(struct bearer *b_ptr)
+void tipc_bearer_lock_push(struct bearer *b_ptr)
 {
        int res;
@@ -389,7 +390,7 @@ void bearer_lock_push(struct bearer *b_ptr)
        res = bearer_push(b_ptr);
        spin_unlock_bh(&b_ptr->publ.lock);
        if (res)
-                bcbearer_push();
+                tipc_bcbearer_push();
 }
@@ -404,7 +405,7 @@ void tipc_continue(struct tipc_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);
+                tipc_k_signal((Handler)tipc_bearer_lock_push, (unsigned long)b_ptr);
        b_ptr->publ.blocked = 0;
        spin_unlock_bh(&b_ptr->publ.lock);
 }
@@ -413,11 +414,11 @@ void tipc_continue(struct tipc_bearer *tb_ptr)
 * 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
+ * the bearer is congested. 'tipc_net_lock' is in read_lock here
 * bearer.lock is busy
 */
-static void bearer_schedule_unlocked(struct bearer *b_ptr, struct link *l_ptr)
+static void tipc_bearer_schedule_unlocked(struct bearer *b_ptr, struct link *l_ptr)
 {
        list_move_tail(&l_ptr->link_list, &b_ptr->cong_links);
 }
@@ -426,24 +427,24 @@ static void bearer_schedule_unlocked(struct bearer *b_ptr, struct link *l_ptr)
 * 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,
+ * the bearer is congested. 'tipc_net_lock' is in read_lock here,
 * bearer.lock is free
 */
-void bearer_schedule(struct bearer *b_ptr, struct link *l_ptr)
+void tipc_bearer_schedule(struct bearer *b_ptr, struct link *l_ptr)
 {
        spin_lock_bh(&b_ptr->publ.lock);
-        bearer_schedule_unlocked(b_ptr, l_ptr);
+        tipc_bearer_schedule_unlocked(b_ptr, l_ptr);
        spin_unlock_bh(&b_ptr->publ.lock);
 }
 /*
- * bearer_resolve_congestion(): Check if there is bearer congestion,
+ * tipc_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
+ * 'tipc_net_lock' is read_locked when this function is called
 */
-int bearer_resolve_congestion(struct bearer *b_ptr, struct link *l_ptr)
+int tipc_bearer_resolve_congestion(struct bearer *b_ptr, struct link *l_ptr)
 {
        int res = 1;
@@ -451,7 +452,7 @@ int bearer_resolve_congestion(struct bearer *b_ptr, struct link *l_ptr)
                return 1;
        spin_lock_bh(&b_ptr->publ.lock);
        if (!bearer_push(b_ptr)) {
-                bearer_schedule_unlocked(b_ptr, l_ptr);
+                tipc_bearer_schedule_unlocked(b_ptr, l_ptr);
                res = 0;
        }
        spin_unlock_bh(&b_ptr->publ.lock);
@@ -476,14 +477,19 @@ int tipc_enable_bearer(const char *name, u32 bcast_scope, u32 priority)
        if (tipc_mode != TIPC_NET_MODE)
                return -ENOPROTOOPT;
        if (!bearer_name_validate(name, &b_name) ||
-            !addr_domain_valid(bcast_scope) ||
+            !tipc_addr_domain_valid(bcast_scope) ||
-            !in_scope(bcast_scope, tipc_own_addr) ||
+            !in_scope(bcast_scope, tipc_own_addr))
-            (priority > TIPC_NUM_LINK_PRI))
+                return -EINVAL;
+        if ((priority < TIPC_MIN_LINK_PRI ||
+             priority > TIPC_MAX_LINK_PRI) &&
+            (priority != TIPC_MEDIA_LINK_PRI))
                return -EINVAL;
-        write_lock_bh(&net_lock);
+        write_lock_bh(&tipc_net_lock);
-        if (!bearers)
+        if (!tipc_bearers)
                goto failed;
        m_ptr = media_find(b_name.media_name);
@@ -491,22 +497,23 @@ int tipc_enable_bearer(const char *name, u32 bcast_scope, u32 priority)
                warn("No media <%s>\n", b_name.media_name);
                goto failed;
        }
-        if (priority == TIPC_NUM_LINK_PRI)
+        if (priority == TIPC_MEDIA_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) {
+                if (!tipc_bearers[i].active) {
                        bearer_id = i;
                        continue;
                }
-                if (!strcmp(name, bearers[i].publ.name)) {
+                if (!strcmp(name, tipc_bearers[i].publ.name)) {
                        warn("Bearer <%s> already enabled\n", name);
                        goto failed;
                }
-                if ((bearers[i].priority == priority) &&
+                if ((tipc_bearers[i].priority == priority) &&
                    (++with_this_prio > 2)) {
                        if (priority-- == 0) {
                                warn("Third bearer <%s> with priority %u, unable to lower to %u\n",
@@ -523,7 +530,7 @@ restart:
                goto failed;
        }
-        b_ptr = &bearers[bearer_id];
+        b_ptr = &tipc_bearers[bearer_id];
        memset(b_ptr, 0, sizeof(struct bearer));
        strcpy(b_ptr->publ.name, name);
@@ -542,16 +549,16 @@ restart:
        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,
+                b_ptr->link_req = tipc_disc_init_link_req(b_ptr, &m_ptr->bcast_addr,
-                                                     bcast_scope, 2);
+                                                          bcast_scope, 2);
        }
        b_ptr->publ.lock = SPIN_LOCK_UNLOCKED;
-        write_unlock_bh(&net_lock);
+        write_unlock_bh(&tipc_net_lock);
-        info("Enabled bearer <%s>, discovery domain %s\n",
+        info("Enabled bearer <%s>, discovery domain %s, priority %u\n",
-             name, addr_string_fill(addr_string, bcast_scope));
+             name, addr_string_fill(addr_string, bcast_scope), priority);
        return 0;
 failed:
-        write_unlock_bh(&net_lock);
+        write_unlock_bh(&tipc_net_lock);
        return res;
 }
@@ -569,11 +576,11 @@ int tipc_block_bearer(const char *name)
        if (tipc_mode != TIPC_NET_MODE)
                return -ENOPROTOOPT;
-        read_lock_bh(&net_lock);
+        read_lock_bh(&tipc_net_lock);
        b_ptr = bearer_find(name);
        if (!b_ptr) {
                warn("Attempt to block unknown bearer <%s>\n", name);
-                read_unlock_bh(&net_lock);
+                read_unlock_bh(&tipc_net_lock);
                return -EINVAL;
        }
@@ -583,11 +590,11 @@ int tipc_block_bearer(const char *name)
                struct node *n_ptr = l_ptr->owner;
                spin_lock_bh(&n_ptr->lock);
-                link_reset(l_ptr);
+                tipc_link_reset(l_ptr);
                spin_unlock_bh(&n_ptr->lock);
        }
        spin_unlock_bh(&b_ptr->publ.lock);
-        read_unlock_bh(&net_lock);
+        read_unlock_bh(&tipc_net_lock);
        info("Blocked bearer <%s>\n", name);
        return TIPC_OK;
 }
@@ -595,7 +602,7 @@ int tipc_block_bearer(const char *name)
 /**
 * bearer_disable -
 * 
- * Note: This routine assumes caller holds net_lock.
+ * Note: This routine assumes caller holds tipc_net_lock.
 */
 static int bearer_disable(const char *name)
@@ -613,19 +620,19 @@ static int bearer_disable(const char *name)
                return -EINVAL;
        }
-        disc_stop_link_req(b_ptr->link_req);
+        tipc_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);
+                write_unlock_bh(&tipc_net_lock);
                b_ptr->media->disable_bearer(&b_ptr->publ);
-                write_lock_bh(&net_lock);
+                write_lock_bh(&tipc_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);
+                tipc_link_delete(l_ptr);
        }
        spin_unlock_bh(&b_ptr->publ.lock);
        info("Disabled bearer <%s>\n", name);
@@ -637,54 +644,54 @@ int tipc_disable_bearer(const char *name)
 {
        int res;
-        write_lock_bh(&net_lock);
+        write_lock_bh(&tipc_net_lock);
        res = bearer_disable(name);
-        write_unlock_bh(&net_lock);
+        write_unlock_bh(&tipc_net_lock);
        return res;
 }
-int bearer_init(void)
+int tipc_bearer_init(void)
 {
        int res;
-        write_lock_bh(&net_lock);
+        write_lock_bh(&tipc_net_lock);
-        bearers = kmalloc(MAX_BEARERS * sizeof(struct bearer), GFP_ATOMIC);
+        tipc_bearers = kmalloc(MAX_BEARERS * sizeof(struct bearer), GFP_ATOMIC);
        media_list = kmalloc(MAX_MEDIA * sizeof(struct media), GFP_ATOMIC);
-        if (bearers && media_list) {
+        if (tipc_bearers && media_list) {
-                memset(bearers, 0, MAX_BEARERS * sizeof(struct bearer));
+                memset(tipc_bearers, 0, MAX_BEARERS * sizeof(struct bearer));
                memset(media_list, 0, MAX_MEDIA * sizeof(struct media));
                res = TIPC_OK;
        } else {
-                kfree(bearers);
+                kfree(tipc_bearers);
                kfree(media_list);
-                bearers = 0;
+                tipc_bearers = 0;
                media_list = 0;
                res = -ENOMEM;
        }
-        write_unlock_bh(&net_lock);
+        write_unlock_bh(&tipc_net_lock);
        return res;
 }
-void bearer_stop(void)
+void tipc_bearer_stop(void)
 {
        u32 i;
-        if (!bearers)
+        if (!tipc_bearers)
                return;
        for (i = 0; i < MAX_BEARERS; i++) {
-                if (bearers[i].active)
+                if (tipc_bearers[i].active)
-                        bearers[i].publ.blocked = 1;
+                        tipc_bearers[i].publ.blocked = 1;
        }
        for (i = 0; i < MAX_BEARERS; i++) {
-                if (bearers[i].active)
+                if (tipc_bearers[i].active)
-                        bearer_disable(bearers[i].publ.name);
+                        bearer_disable(tipc_bearers[i].publ.name);
        }
-        kfree(bearers);
+        kfree(tipc_bearers);
        kfree(media_list);
-        bearers = 0;
+        tipc_bearers = 0;
        media_list = 0;
        media_count = 0;
 }
diff --git a/net/tipc/bearer.h b/net/tipc/bearer.h
index 21e63d3f0183..c4e7c1c3655b 100644
--- a/net/tipc/bearer.h
+++ b/net/tipc/bearer.h
@@ -37,7 +37,7 @@
 #ifndef _TIPC_BEARER_H
 #define _TIPC_BEARER_H
-#include <net/tipc/tipc_bearer.h>
+#include "core.h"
 #include "bcast.h"
 #define MAX_BEARERS 8
@@ -114,26 +114,24 @@ struct bearer_name {
 struct link;
-extern struct bearer *bearers;
+extern struct bearer *tipc_bearers;
-void media_addr_printf(struct print_buf *pb, struct tipc_media_addr *a);
+void tipc_media_addr_printf(struct print_buf *pb, struct tipc_media_addr *a);
-struct sk_buff *media_get_names(void);
+struct sk_buff *tipc_media_get_names(void);
-struct sk_buff *bearer_get_names(void);
+struct sk_buff *tipc_bearer_get_names(void);
-void bearer_add_dest(struct bearer *b_ptr, u32 dest);
+void tipc_bearer_add_dest(struct bearer *b_ptr, u32 dest);
-void bearer_remove_dest(struct bearer *b_ptr, u32 dest);
+void tipc_bearer_remove_dest(struct bearer *b_ptr, u32 dest);
-void bearer_schedule(struct bearer *b_ptr, struct link *l_ptr);
+void tipc_bearer_schedule(struct bearer *b_ptr, struct link *l_ptr);
-struct bearer *bearer_find_interface(const char *if_name);
+struct bearer *tipc_bearer_find_interface(const char *if_name);
-int bearer_resolve_congestion(struct bearer *b_ptr, struct link *l_ptr);
+int tipc_bearer_resolve_congestion(struct bearer *b_ptr, struct link *l_ptr);
-int bearer_init(void);
+int tipc_bearer_init(void);
-void bearer_stop(void);
+void tipc_bearer_stop(void);
-int bearer_broadcast(struct sk_buff *buf, struct tipc_bearer *b_ptr,
+void tipc_bearer_lock_push(struct bearer *b_ptr);
-                     struct tipc_media_addr *dest);
-void bearer_lock_push(struct bearer *b_ptr);
 /**
- * bearer_send- sends buffer to destination over bearer 
+ * tipc_bearer_send- sends buffer to destination over bearer 
 * 
 * Returns true (1) if successful, or false (0) if unable to send
 * 
@@ -150,23 +148,23 @@ void bearer_lock_push(struct bearer *b_ptr);
 * and let TIPC's link code deal with the undelivered message. 
 */
-static inline int bearer_send(struct bearer *b_ptr, struct sk_buff *buf,
+static inline int tipc_bearer_send(struct bearer *b_ptr, struct sk_buff *buf,
-                              struct tipc_media_addr *dest)
+                                   struct tipc_media_addr *dest)
 {
        return !b_ptr->media->send_msg(buf, &b_ptr->publ, dest);
 }
 /**
- * bearer_congested - determines if bearer is currently congested
+ * tipc_bearer_congested - determines if bearer is currently congested
 */
-static inline int bearer_congested(struct bearer *b_ptr, struct link *l_ptr)
+static inline int tipc_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);
+        return !tipc_bearer_resolve_congestion(b_ptr, l_ptr);
 }
 #endif
diff --git a/net/tipc/cluster.c b/net/tipc/cluster.c
index f0f7bac51d41..ab974ca19371 100644
--- a/net/tipc/cluster.c
+++ b/net/tipc/cluster.c
@@ -44,15 +44,15 @@
 #include "msg.h"
 #include "bearer.h"
-void cluster_multicast(struct cluster *c_ptr, struct sk_buff *buf, 
+void tipc_cltr_multicast(struct cluster *c_ptr, struct sk_buff *buf, 
-                       u32 lower, u32 upper);
+                         u32 lower, u32 upper);
-struct sk_buff *cluster_prepare_routing_msg(u32 data_size, u32 dest);
+struct sk_buff *tipc_cltr_prepare_routing_msg(u32 data_size, u32 dest);
-struct node **local_nodes = 0;
+struct node **tipc_local_nodes = 0;
-struct node_map cluster_bcast_nodes = {0,{0,}};
+struct node_map tipc_cltr_bcast_nodes = {0,{0,}};
-u32 highest_allowed_slave = 0;
+u32 tipc_highest_allowed_slave = 0;
-struct cluster *cluster_create(u32 addr)
+struct cluster *tipc_cltr_create(u32 addr)
 {
        struct _zone *z_ptr;
        struct cluster *c_ptr;
@@ -77,16 +77,16 @@ struct cluster *cluster_create(u32 addr)
        }
        memset(c_ptr->nodes, 0, alloc);  
        if (in_own_cluster(addr))
-                local_nodes = c_ptr->nodes;
+                tipc_local_nodes = c_ptr->nodes;
        c_ptr->highest_slave = LOWEST_SLAVE - 1;
        c_ptr->highest_node = 0;
        
-        z_ptr = zone_find(tipc_zone(addr));
+        z_ptr = tipc_zone_find(tipc_zone(addr));
        if (z_ptr == NULL) {
-                z_ptr = zone_create(addr);
+                z_ptr = tipc_zone_create(addr);
        }
        if (z_ptr != NULL) {
-                zone_attach_cluster(z_ptr, c_ptr);
+                tipc_zone_attach_cluster(z_ptr, c_ptr);
                c_ptr->owner = z_ptr;
        }
        else {
@@ -97,23 +97,23 @@ struct cluster *cluster_create(u32 addr)
        return c_ptr;
 }
-void cluster_delete(struct cluster *c_ptr)
+void tipc_cltr_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]);
+                tipc_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]);
+                tipc_node_delete(c_ptr->nodes[n_num]);
        }
        kfree(c_ptr->nodes);
        kfree(c_ptr);
 }
-u32 cluster_next_node(struct cluster *c_ptr, u32 addr)
+u32 tipc_cltr_next_node(struct cluster *c_ptr, u32 addr)
 {
        struct node *n_ptr;
        u32 n_num = tipc_node(addr) + 1;
@@ -122,24 +122,24 @@ u32 cluster_next_node(struct cluster *c_ptr, u32 addr)
                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))
+                if (n_ptr && tipc_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))
+                if (n_ptr && tipc_node_has_active_links(n_ptr))
                        return n_ptr->addr;
        }
        return 0;
 }
-void cluster_attach_node(struct cluster *c_ptr, struct node *n_ptr)
+void tipc_cltr_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;
+                max_n_num = tipc_highest_allowed_slave;
        assert(n_num > 0);
        assert(n_num <= max_n_num);
        assert(c_ptr->nodes[n_num] == 0);
@@ -149,12 +149,12 @@ void cluster_attach_node(struct cluster *c_ptr, struct node *n_ptr)
 }
 /**
- * cluster_select_router - select router to a cluster
+ * tipc_cltr_select_router - select router to a cluster
 * 
 * Uses deterministic and fair algorithm.
 */
-u32 cluster_select_router(struct cluster *c_ptr, u32 ref)
+u32 tipc_cltr_select_router(struct cluster *c_ptr, u32 ref)
 {
        u32 n_num;
        u32 ulim = c_ptr->highest_node;
@@ -174,29 +174,29 @@ u32 cluster_select_router(struct cluster *c_ptr, u32 ref)
        /* Lookup upwards with wrap-around */
        do {
-                if (node_is_up(c_ptr->nodes[n_num]))
+                if (tipc_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]))
+                        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 node_select_router(c_ptr->nodes[n_num], ref);
+        return tipc_node_select_router(c_ptr->nodes[n_num], ref);
 }
 /**
- * cluster_select_node - select destination node within a remote cluster
+ * tipc_cltr_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)
+struct node *tipc_cltr_select_node(struct cluster *c_ptr, u32 selector)
 {
        u32 n_num;
        u32 mask = tipc_max_nodes;
@@ -215,11 +215,11 @@ struct node *cluster_select_node(struct cluster *c_ptr, u32 selector)
        /* 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]))
+                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 (node_has_active_links(c_ptr->nodes[n_num]))
+                if (tipc_node_has_active_links(c_ptr->nodes[n_num]))
                        return c_ptr->nodes[n_num];
        }
        return 0;
@@ -229,7 +229,7 @@ struct node *cluster_select_node(struct cluster *c_ptr, u32 selector)
 *    Routing table management: See description in node.c
 */
-struct sk_buff *cluster_prepare_routing_msg(u32 data_size, u32 dest)
+struct sk_buff *tipc_cltr_prepare_routing_msg(u32 data_size, u32 dest)
 {
        u32 size = INT_H_SIZE + data_size;
        struct sk_buff *buf = buf_acquire(size);
@@ -243,39 +243,39 @@ struct sk_buff *cluster_prepare_routing_msg(u32 data_size, u32 dest)
        return buf;
 }
-void cluster_bcast_new_route(struct cluster *c_ptr, u32 dest,
+void tipc_cltr_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 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);
-                cluster_multicast(c_ptr, buf, lower, upper);
+                tipc_cltr_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,
+void tipc_cltr_bcast_lost_route(struct cluster *c_ptr, u32 dest,
-                              u32 lower, u32 upper)
+                                u32 lower, u32 upper)
 {
-        struct sk_buff *buf = cluster_prepare_routing_msg(0, c_ptr->addr);
+        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);
-                cluster_multicast(c_ptr, buf, lower, upper);
+                tipc_cltr_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)
+void tipc_cltr_send_slave_routes(struct cluster *c_ptr, u32 dest)
 {
        struct sk_buff *buf;
        struct tipc_msg *msg;
@@ -288,21 +288,21 @@ void cluster_send_slave_routes(struct cluster *c_ptr, u32 dest)
        assert(in_own_cluster(c_ptr->addr));
        if (highest <= LOWEST_SLAVE)
                return;
-        buf = cluster_prepare_routing_msg(highest - LOWEST_SLAVE + 1,
+        buf = tipc_cltr_prepare_routing_msg(highest - LOWEST_SLAVE + 1,
-                                          c_ptr->addr);
+                                            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])) {
+                            tipc_node_has_active_links(c_ptr->nodes[n_num])) {
                                send = 1;
                                msg_set_dataoctet(msg, n_num);
                        }
                }
                if (send)
-                        link_send(buf, dest, dest);
+                        tipc_link_send(buf, dest, dest);
                else
                        buf_discard(buf);
        } else {
@@ -310,7 +310,7 @@ void cluster_send_slave_routes(struct cluster *c_ptr, u32 dest)
        }
 }
-void cluster_send_ext_routes(struct cluster *c_ptr, u32 dest)
+void tipc_cltr_send_ext_routes(struct cluster *c_ptr, u32 dest)
 {
        struct sk_buff *buf;
        struct tipc_msg *msg;
@@ -323,20 +323,20 @@ void cluster_send_ext_routes(struct cluster *c_ptr, u32 dest)
        assert(!is_slave(dest));
        assert(in_own_cluster(dest));
        highest = c_ptr->highest_node;
-        buf = cluster_prepare_routing_msg(highest + 1, c_ptr->addr);
+        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] && 
-                            node_has_active_links(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)
-                        link_send(buf, dest, dest);
+                        tipc_link_send(buf, dest, dest);
                else
                        buf_discard(buf);
        } else {
@@ -344,7 +344,7 @@ void cluster_send_ext_routes(struct cluster *c_ptr, u32 dest)
        }
 }
-void cluster_send_local_routes(struct cluster *c_ptr, u32 dest)
+void tipc_cltr_send_local_routes(struct cluster *c_ptr, u32 dest)
 {
        struct sk_buff *buf;
        struct tipc_msg *msg;
@@ -354,20 +354,20 @@ void cluster_send_local_routes(struct cluster *c_ptr, u32 dest)
        assert(is_slave(dest));
        assert(in_own_cluster(c_ptr->addr));
-        buf = cluster_prepare_routing_msg(highest, c_ptr->addr);
+        buf = tipc_cltr_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])) {
+                            tipc_node_has_active_links(c_ptr->nodes[n_num])) {
                                send = 1;
                                msg_set_dataoctet(msg, n_num);
                        }
                }
                if (send)
-                        link_send(buf, dest, dest);
+                        tipc_link_send(buf, dest, dest);
                else
                        buf_discard(buf);
        } else {
@@ -375,7 +375,7 @@ void cluster_send_local_routes(struct cluster *c_ptr, u32 dest)
        }
 }
-void cluster_recv_routing_table(struct sk_buff *buf)
+void tipc_cltr_recv_routing_table(struct sk_buff *buf)
 {
        struct tipc_msg *msg = buf_msg(buf);
        struct cluster *c_ptr;
@@ -388,9 +388,9 @@ void cluster_recv_routing_table(struct sk_buff *buf)
        u32 c_num;
        u32 n_num;
-        c_ptr = cluster_find(rem_node);
+        c_ptr = tipc_cltr_find(rem_node);
        if (!c_ptr) {
-                c_ptr = cluster_create(rem_node);
+                c_ptr = tipc_cltr_create(rem_node);
                if (!c_ptr) {
                        buf_discard(buf);
                        return;
@@ -412,10 +412,10 @@ void cluster_recv_routing_table(struct sk_buff *buf)
                                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);
+                                        n_ptr = tipc_node_create(addr);
                                }
                                if (n_ptr)
-                                        node_add_router(n_ptr, router);
+                                        tipc_node_add_router(n_ptr, router);
                        }
                }
                break;
@@ -428,10 +428,10 @@ void cluster_recv_routing_table(struct sk_buff *buf)
                                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);
+                                        n_ptr = tipc_node_create(addr);
                                }
                                if (n_ptr)
-                                        node_add_router(n_ptr, router);
+                                        tipc_node_add_router(n_ptr, router);
                        }
                }
                break;
@@ -445,9 +445,9 @@ void cluster_recv_routing_table(struct sk_buff *buf)
                }
                n_ptr = c_ptr->nodes[tipc_node(rem_node)];
                if (!n_ptr)
-                        n_ptr = node_create(rem_node);
+                        n_ptr = tipc_node_create(rem_node);
                if (n_ptr)
-                        node_add_router(n_ptr, router);
+                        tipc_node_add_router(n_ptr, router);
                break;
        case ROUTE_REMOVAL:
                if (!is_slave(tipc_own_addr)) {
@@ -459,7 +459,7 @@ void cluster_recv_routing_table(struct sk_buff *buf)
                }
                n_ptr = c_ptr->nodes[tipc_node(rem_node)];
                if (n_ptr)
-                        node_remove_router(n_ptr, router);
+                        tipc_node_remove_router(n_ptr, router);
                break;
        default:
                assert(!"Illegal routing manager message received\n");
@@ -467,7 +467,7 @@ void cluster_recv_routing_table(struct sk_buff *buf)
        buf_discard(buf);
 }
-void cluster_remove_as_router(struct cluster *c_ptr, u32 router)
+void tipc_cltr_remove_as_router(struct cluster *c_ptr, u32 router)
 {
        u32 start_entry;
        u32 tstop;
@@ -486,17 +486,17 @@ void cluster_remove_as_router(struct cluster *c_ptr, u32 router)
        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);
+                        tipc_node_remove_router(c_ptr->nodes[n_num], router);
                }
        }
 }
 /**
- * cluster_multicast - multicast message to local nodes 
+ * tipc_cltr_multicast - multicast message to local nodes 
 */
-void cluster_multicast(struct cluster *c_ptr, struct sk_buff *buf, 
+void tipc_cltr_multicast(struct cluster *c_ptr, struct sk_buff *buf, 
-                       u32 lower, u32 upper)
+                         u32 lower, u32 upper)
 {
        struct sk_buff *buf_copy;
        struct node *n_ptr;
@@ -505,9 +505,9 @@ void cluster_multicast(struct cluster *c_ptr, struct sk_buff *buf,
        assert(lower <= upper);
        assert(((lower >= 1) && (lower <= tipc_max_nodes)) ||
-               ((lower >= LOWEST_SLAVE) && (lower <= highest_allowed_slave)));
+               ((lower >= LOWEST_SLAVE) && (lower <= tipc_highest_allowed_slave)));
        assert(((upper >= 1) && (upper <= tipc_max_nodes)) ||
-               ((upper >= LOWEST_SLAVE) && (upper <= highest_allowed_slave)));
+               ((upper >= LOWEST_SLAVE) && (upper <= tipc_highest_allowed_slave)));
        assert(in_own_cluster(c_ptr->addr));
        tstop = is_slave(upper) ? c_ptr->highest_slave : c_ptr->highest_node;
@@ -515,22 +515,22 @@ void cluster_multicast(struct cluster *c_ptr, struct sk_buff *buf,
                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)) {
+                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);
-                        link_send(buf_copy, n_ptr->addr, n_ptr->addr);
+                        tipc_link_send(buf_copy, n_ptr->addr, n_ptr->addr);
                }
        }
        buf_discard(buf);
 }
 /**
- * cluster_broadcast - broadcast message to all nodes within cluster
+ * tipc_cltr_broadcast - broadcast message to all nodes within cluster
 */
-void cluster_broadcast(struct sk_buff *buf)
+void tipc_cltr_broadcast(struct sk_buff *buf)
 {
        struct sk_buff *buf_copy;
        struct cluster *c_ptr;
@@ -541,7 +541,7 @@ void cluster_broadcast(struct sk_buff *buf)
        u32 node_type;
        if (tipc_mode == TIPC_NET_MODE) {
-                c_ptr = cluster_find(tipc_own_addr);
+                c_ptr = tipc_cltr_find(tipc_own_addr);
                assert(in_own_cluster(c_ptr->addr));    /* For now */
                /* Send to standard nodes, then repeat loop sending to slaves */
@@ -550,14 +550,14 @@ void cluster_broadcast(struct sk_buff *buf)
                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)) {
+                                if (n_ptr && tipc_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, 
+                                        tipc_link_send(buf_copy, n_ptr->addr, 
-                                                  n_ptr->addr);
+                                                       n_ptr->addr);
                                }
                        }
                        tstart = LOWEST_SLAVE;
@@ -568,9 +568,9 @@ exit:
        buf_discard(buf);
 }
-int cluster_init(void)
+int tipc_cltr_init(void)
 {
-        highest_allowed_slave = LOWEST_SLAVE + tipc_max_slaves;
+        tipc_highest_allowed_slave = LOWEST_SLAVE + tipc_max_slaves;
-        return cluster_create(tipc_own_addr) ? TIPC_OK : -ENOMEM;
+        return tipc_cltr_create(tipc_own_addr) ? TIPC_OK : -ENOMEM;
 }
diff --git a/net/tipc/cluster.h b/net/tipc/cluster.h
index 1ffb095991df..9963642e1058 100644
--- a/net/tipc/cluster.h
+++ b/net/tipc/cluster.h
@@ -60,29 +60,29 @@ struct cluster {
 };
-extern struct node **local_nodes;
+extern struct node **tipc_local_nodes;
-extern u32 highest_allowed_slave;
+extern u32 tipc_highest_allowed_slave;
-extern struct node_map cluster_bcast_nodes;
+extern struct node_map tipc_cltr_bcast_nodes;
-void cluster_remove_as_router(struct cluster *c_ptr, u32 router);
+void tipc_cltr_remove_as_router(struct cluster *c_ptr, u32 router);
-void cluster_send_ext_routes(struct cluster *c_ptr, u32 dest);
+void tipc_cltr_send_ext_routes(struct cluster *c_ptr, u32 dest);
-struct node *cluster_select_node(struct cluster *c_ptr, u32 selector);
+struct node *tipc_cltr_select_node(struct cluster *c_ptr, u32 selector);
-u32 cluster_select_router(struct cluster *c_ptr, u32 ref);
+u32 tipc_cltr_select_router(struct cluster *c_ptr, u32 ref);
-void cluster_recv_routing_table(struct sk_buff *buf);
+void tipc_cltr_recv_routing_table(struct sk_buff *buf);
-struct cluster *cluster_create(u32 addr);
+struct cluster *tipc_cltr_create(u32 addr);
-void cluster_delete(struct cluster *c_ptr);
+void tipc_cltr_delete(struct cluster *c_ptr);
-void cluster_attach_node(struct cluster *c_ptr, struct node *n_ptr);
+void tipc_cltr_attach_node(struct cluster *c_ptr, struct node *n_ptr);
-void cluster_send_slave_routes(struct cluster *c_ptr, u32 dest);
+void tipc_cltr_send_slave_routes(struct cluster *c_ptr, u32 dest);
-void cluster_broadcast(struct sk_buff *buf);
+void tipc_cltr_broadcast(struct sk_buff *buf);
-int cluster_init(void);
+int tipc_cltr_init(void);
-u32 cluster_next_node(struct cluster *c_ptr, u32 addr);
+u32 tipc_cltr_next_node(struct cluster *c_ptr, u32 addr);
-void cluster_bcast_new_route(struct cluster *c_ptr, u32 dest, u32 lo, u32 hi);
+void tipc_cltr_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 tipc_cltr_send_local_routes(struct cluster *c_ptr, u32 dest);
-void cluster_bcast_lost_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 *cluster_find(u32 addr)
+static inline struct cluster *tipc_cltr_find(u32 addr)
 {
-        struct _zone *z_ptr = zone_find(addr);
+        struct _zone *z_ptr = tipc_zone_find(addr);
        if (z_ptr)
                return z_ptr->clusters[1];
diff --git a/net/tipc/config.c b/net/tipc/config.c
index 8ddef4fce2c2..3c8e6740e5ae 100644
--- a/net/tipc/config.c
+++ b/net/tipc/config.c
@@ -70,13 +70,13 @@ 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)
+void tipc_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 *tipc_cfg_reply_alloc(int payload_size)
 {
        struct sk_buff *buf;
@@ -86,14 +86,14 @@ struct sk_buff *cfg_reply_alloc(int payload_size)
        return buf;
 }
-int cfg_append_tlv(struct sk_buff *buf, int tlv_type, 
+int tipc_cfg_append_tlv(struct sk_buff *buf, int tlv_type, 
-                   void *tlv_data, int tlv_data_size)
+                        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");
+                dbg("tipc_cfg_append_tlv unable to append TLV\n");
                return 0;
        }
        skb_put(buf, new_tlv_space);
@@ -104,28 +104,28 @@ int cfg_append_tlv(struct sk_buff *buf, int tlv_type,
        return 1;
 }
-struct sk_buff *cfg_reply_unsigned_type(u16 tlv_type, u32 value)
+struct sk_buff *tipc_cfg_reply_unsigned_type(u16 tlv_type, u32 value)
 {
        struct sk_buff *buf;
        u32 value_net;
-        buf = cfg_reply_alloc(TLV_SPACE(sizeof(value)));
+        buf = tipc_cfg_reply_alloc(TLV_SPACE(sizeof(value)));
        if (buf) {
                value_net = htonl(value);
-                cfg_append_tlv(buf, tlv_type, &value_net, 
+                tipc_cfg_append_tlv(buf, tlv_type, &value_net, 
-                               sizeof(value_net));
+                                    sizeof(value_net));
        }
        return buf;
 }
-struct sk_buff *cfg_reply_string_type(u16 tlv_type, char *string)
+struct sk_buff *tipc_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));
+        buf = tipc_cfg_reply_alloc(TLV_SPACE(string_len));
        if (buf)
-                cfg_append_tlv(buf, tlv_type, string, string_len);
+                tipc_cfg_append_tlv(buf, tlv_type, string, string_len);
        return buf;
 }
@@ -246,7 +246,7 @@ static void cfg_cmd_event(struct tipc_cmd_msg *msg,
        exit:
        rmsg.result_len = htonl(msg_sect[1].iov_len);
        rmsg.retval = htonl(rv);
-        cfg_respond(msg_sect, 2u, orig);
+        tipc_cfg_respond(msg_sect, 2u, orig);
 }
 #endif
@@ -255,26 +255,26 @@ 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);
+                return tipc_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 tipc_cfg_reply_error_string("unable to enable bearer");
-        return cfg_reply_none();
+        return tipc_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);
+                return tipc_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 tipc_cfg_reply_error_string("unable to disable bearer");
-        return cfg_reply_none();
+        return tipc_cfg_reply_none();
 }
 static struct sk_buff *cfg_set_own_addr(void)
@@ -282,25 +282,25 @@ 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);
+                return tipc_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();
+                return tipc_cfg_reply_none();
-        if (!addr_node_valid(addr))
+        if (!tipc_addr_node_valid(addr))
-                return cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
+                return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
-                                              " (node address)");
+                                                   " (node address)");
        if (tipc_own_addr)
-                return cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
+                return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
-                                              " (cannot change node address once assigned)");
+                                                   " (cannot change node address once assigned)");
        spin_unlock_bh(&config_lock);
-        stop_net();
+        tipc_core_stop_net();
        tipc_own_addr = addr;
-        start_net();
+        tipc_core_start_net();
        spin_lock_bh(&config_lock);
-        return cfg_reply_none();
+        return tipc_cfg_reply_none();
 }
 static struct sk_buff *cfg_set_remote_mng(void)
@@ -308,12 +308,12 @@ 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);
+                return tipc_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();
+        return tipc_cfg_reply_none();
 }
 static struct sk_buff *cfg_set_max_publications(void)
@@ -321,15 +321,15 @@ 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);
+                return tipc_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
+                return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
-                                              " (max publications must be 1-65535)");
+                                                   " (max publications must be 1-65535)");
        tipc_max_publications = value;
-        return cfg_reply_none();
+        return tipc_cfg_reply_none();
 }
 static struct sk_buff *cfg_set_max_subscriptions(void)
@@ -337,15 +337,15 @@ 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);
+                return tipc_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
+                return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
-                                              " (max subscriptions must be 1-65535");
+                                                   " (max subscriptions must be 1-65535");
        tipc_max_subscriptions = value;
-        return cfg_reply_none();
+        return tipc_cfg_reply_none();
 }
 static struct sk_buff *cfg_set_max_ports(void)
@@ -354,31 +354,31 @@ static struct sk_buff *cfg_set_max_ports(void)
        u32 value;
        if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
-                return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
+                return tipc_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
+                return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
-                                              " (max ports must be 127-65535)");
+                                                   " (max ports must be 127-65535)");
        if (value == tipc_max_ports)
-                return cfg_reply_none();
+                return tipc_cfg_reply_none();
        if (atomic_read(&tipc_user_count) > 2)
-                return cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
+                return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
-                                              " (cannot change max ports while TIPC users exist)");
+                                                   " (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();
+                tipc_core_stop_net();
-        stop_core();
+        tipc_core_stop();
        tipc_max_ports = value;
-        start_core();
+        tipc_core_start();
        if (orig_mode == TIPC_NET_MODE)
-                start_net();
+                tipc_core_start_net();
        spin_lock_bh(&config_lock);
-        return cfg_reply_none();
+        return tipc_cfg_reply_none();
 }
 static struct sk_buff *set_net_max(int value, int *parameter)
@@ -388,13 +388,13 @@ static struct sk_buff *set_net_max(int value, int *parameter)
        if (value != *parameter) {
                orig_mode = tipc_get_mode();
                if (orig_mode == TIPC_NET_MODE)
-                        stop_net();
+                        tipc_core_stop_net();
                *parameter = value;
                if (orig_mode == TIPC_NET_MODE)
-                        start_net();
+                        tipc_core_start_net();
        }
-        return cfg_reply_none();
+        return tipc_cfg_reply_none();
 }
 static struct sk_buff *cfg_set_max_zones(void)
@@ -402,12 +402,12 @@ 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);
+                return tipc_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
+                return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
-                                              " (max zones must be 1-255)");
+                                                   " (max zones must be 1-255)");
        return set_net_max(value, &tipc_max_zones);
 }
@@ -416,13 +416,13 @@ 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);
+                return tipc_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
+                return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
-                                              " (max clusters fixed at 1)");
+                                                   " (max clusters fixed at 1)");
-        return cfg_reply_none();
+        return tipc_cfg_reply_none();
 }
 static struct sk_buff *cfg_set_max_nodes(void)
@@ -430,12 +430,12 @@ 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);
+                return tipc_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
+                return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
-                                              " (max nodes must be 8-2047)");
+                                                   " (max nodes must be 8-2047)");
        return set_net_max(value, &tipc_max_nodes);
 }
@@ -444,13 +444,13 @@ 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);
+                return tipc_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
+                return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
-                                              " (max secondary nodes fixed at 0)");
+                                                   " (max secondary nodes fixed at 0)");
-        return cfg_reply_none();
+        return tipc_cfg_reply_none();
 }
 static struct sk_buff *cfg_set_netid(void)
@@ -458,22 +458,22 @@ 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);
+                return tipc_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
+                return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
-                                              " (network id must be 1-9999)");
+                                                   " (network id must be 1-9999)");
        if (tipc_own_addr)
-                return cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
+                return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
-                                              " (cannot change network id once part of network)");
+                                                   " (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,
+struct sk_buff *tipc_cfg_do_cmd(u32 orig_node, u16 cmd, const void *request_area,
-                           int request_space, int reply_headroom)
+                                int request_space, int reply_headroom)
 {
        struct sk_buff *rep_tlv_buf;
@@ -490,19 +490,19 @@ struct sk_buff *cfg_do_cmd(u32 orig_node, u16 cmd, const void *request_area,
        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
+                rep_tlv_buf = tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
-                                                     " (cannot be done remotely)");
+                                                          " (cannot be done remotely)");
                goto exit;
        } else if (!tipc_remote_management) {
-                rep_tlv_buf = cfg_reply_error_string(TIPC_CFG_NO_REMOTE);
+                rep_tlv_buf = tipc_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) ||
+                if ((tipc_nametbl_translate(TIPC_ZM_SRV, 0, &domain) == 0) ||
                    (domain != orig_node)) {
-                        rep_tlv_buf = cfg_reply_error_string(TIPC_CFG_NOT_ZONE_MSTR);
+                        rep_tlv_buf = tipc_cfg_reply_error_string(TIPC_CFG_NOT_ZONE_MSTR);
                        goto exit;
                }
        }
@@ -511,50 +511,50 @@ struct sk_buff *cfg_do_cmd(u32 orig_node, u16 cmd, const void *request_area,
        switch (cmd) {
        case TIPC_CMD_NOOP:
-                rep_tlv_buf = cfg_reply_none();
+                rep_tlv_buf = tipc_cfg_reply_none();
                break;
        case TIPC_CMD_GET_NODES:
-                rep_tlv_buf = node_get_nodes(req_tlv_area, req_tlv_space);
+                rep_tlv_buf = tipc_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);
+                rep_tlv_buf = tipc_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);
+                rep_tlv_buf = tipc_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);
+                rep_tlv_buf = tipc_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);
+                rep_tlv_buf = tipc_nametbl_get(req_tlv_area, req_tlv_space);
                break;
        case TIPC_CMD_GET_BEARER_NAMES:
-                rep_tlv_buf = bearer_get_names();
+                rep_tlv_buf = tipc_bearer_get_names();
                break;
        case TIPC_CMD_GET_MEDIA_NAMES:
-                rep_tlv_buf = media_get_names();
+                rep_tlv_buf = tipc_media_get_names();
                break;
        case TIPC_CMD_SHOW_PORTS:
-                rep_tlv_buf = port_get_ports();
+                rep_tlv_buf = tipc_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);
+                rep_tlv_buf = tipc_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);
+                rep_tlv_buf = tipc_log_resize(req_tlv_area, req_tlv_space);
                break;
        case TIPC_CMD_DUMP_LOG:
-                rep_tlv_buf = log_dump();
+                rep_tlv_buf = tipc_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);
+                rep_tlv_buf = tipc_link_cmd_config(req_tlv_area, req_tlv_space, cmd);
                break;
        case TIPC_CMD_ENABLE_BEARER:
                rep_tlv_buf = cfg_enable_bearer();
@@ -593,31 +593,31 @@ struct sk_buff *cfg_do_cmd(u32 orig_node, u16 cmd, const void *request_area,
                rep_tlv_buf = cfg_set_netid();
                break;
        case TIPC_CMD_GET_REMOTE_MNG:
-                rep_tlv_buf = cfg_reply_unsigned(tipc_remote_management);
+                rep_tlv_buf = tipc_cfg_reply_unsigned(tipc_remote_management);
                break;
        case TIPC_CMD_GET_MAX_PORTS:
-                rep_tlv_buf = cfg_reply_unsigned(tipc_max_ports);
+                rep_tlv_buf = tipc_cfg_reply_unsigned(tipc_max_ports);
                break;
        case TIPC_CMD_GET_MAX_PUBL:
-                rep_tlv_buf = cfg_reply_unsigned(tipc_max_publications);
+                rep_tlv_buf = tipc_cfg_reply_unsigned(tipc_max_publications);
                break;
        case TIPC_CMD_GET_MAX_SUBSCR:
-                rep_tlv_buf = cfg_reply_unsigned(tipc_max_subscriptions);
+                rep_tlv_buf = tipc_cfg_reply_unsigned(tipc_max_subscriptions);
                break;
        case TIPC_CMD_GET_MAX_ZONES:
-                rep_tlv_buf = cfg_reply_unsigned(tipc_max_zones);
+                rep_tlv_buf = tipc_cfg_reply_unsigned(tipc_max_zones);
                break;
        case TIPC_CMD_GET_MAX_CLUSTERS:
-                rep_tlv_buf = cfg_reply_unsigned(tipc_max_clusters);
+                rep_tlv_buf = tipc_cfg_reply_unsigned(tipc_max_clusters);
                break;
        case TIPC_CMD_GET_MAX_NODES:
-                rep_tlv_buf = cfg_reply_unsigned(tipc_max_nodes);
+                rep_tlv_buf = tipc_cfg_reply_unsigned(tipc_max_nodes);
                break;
        case TIPC_CMD_GET_MAX_SLAVES:
-                rep_tlv_buf = cfg_reply_unsigned(tipc_max_slaves);
+                rep_tlv_buf = tipc_cfg_reply_unsigned(tipc_max_slaves);
                break;
        case TIPC_CMD_GET_NETID:
-                rep_tlv_buf = cfg_reply_unsigned(tipc_net_id);
+                rep_tlv_buf = tipc_cfg_reply_unsigned(tipc_net_id);
                break;
        default:
                rep_tlv_buf = NULL;
@@ -655,11 +655,11 @@ static void cfg_named_msg_event(void *userdata,
        /* Generate reply for request (if can't, return request) */
-        rep_buf = cfg_do_cmd(orig->node,
+        rep_buf = tipc_cfg_do_cmd(orig->node,
-                             ntohs(req_hdr->tcm_type), 
+                                  ntohs(req_hdr->tcm_type), 
-                             msg + sizeof(*req_hdr),
+                                  msg + sizeof(*req_hdr),
-                             size - sizeof(*req_hdr),
+                                  size - sizeof(*req_hdr),
-                             BUF_HEADROOM + MAX_H_SIZE + sizeof(*rep_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;
@@ -675,7 +675,7 @@ static void cfg_named_msg_event(void *userdata,
        tipc_send_buf2port(port_ref, orig, rep_buf, rep_buf->len);
 }
-int cfg_init(void)
+int tipc_cfg_init(void)
 {
        struct tipc_name_seq seq;
        int res;
@@ -696,7 +696,7 @@ int cfg_init(void)
        seq.type = TIPC_CFG_SRV;
        seq.lower = seq.upper = tipc_own_addr;
-        res = nametbl_publish_rsv(mng.port_ref, TIPC_ZONE_SCOPE, &seq);
+        res = tipc_nametbl_publish_rsv(mng.port_ref, TIPC_ZONE_SCOPE, &seq);
        if (res)
                goto failed;
@@ -709,7 +709,7 @@ failed:
        return res;
 }
-void cfg_stop(void)
+void tipc_cfg_stop(void)
 {
        if (mng.user_ref) {
                tipc_detach(mng.user_ref);
diff --git a/net/tipc/config.h b/net/tipc/config.h
index 646377d40454..7a728f954d84 100644
--- a/net/tipc/config.h
+++ b/net/tipc/config.h
@@ -39,42 +39,41 @@
 /* ---------------------------------------------------------------------- */
-#include <linux/tipc.h>
+#include "core.h"
-#include <linux/tipc_config.h>
 #include "link.h"
-struct sk_buff *cfg_reply_alloc(int payload_size);
+struct sk_buff *tipc_cfg_reply_alloc(int payload_size);
-int cfg_append_tlv(struct sk_buff *buf, int tlv_type, 
+int tipc_cfg_append_tlv(struct sk_buff *buf, int tlv_type, 
-                   void *tlv_data, int tlv_data_size);
+                        void *tlv_data, int tlv_data_size);
-struct sk_buff *cfg_reply_unsigned_type(u16 tlv_type, u32 value);
+struct sk_buff *tipc_cfg_reply_unsigned_type(u16 tlv_type, u32 value);
-struct sk_buff *cfg_reply_string_type(u16 tlv_type, char *string);
+struct sk_buff *tipc_cfg_reply_string_type(u16 tlv_type, char *string);
-static inline struct sk_buff *cfg_reply_none(void)
+static inline struct sk_buff *tipc_cfg_reply_none(void)
 {
-        return cfg_reply_alloc(0);
+        return tipc_cfg_reply_alloc(0);
 }
-static inline struct sk_buff *cfg_reply_unsigned(u32 value)
+static inline struct sk_buff *tipc_cfg_reply_unsigned(u32 value)
 {
-        return cfg_reply_unsigned_type(TIPC_TLV_UNSIGNED, value);
+        return tipc_cfg_reply_unsigned_type(TIPC_TLV_UNSIGNED, value);
 }
-static inline struct sk_buff *cfg_reply_error_string(char *string)
+static inline struct sk_buff *tipc_cfg_reply_error_string(char *string)
 {
-        return cfg_reply_string_type(TIPC_TLV_ERROR_STRING, string);
+        return tipc_cfg_reply_string_type(TIPC_TLV_ERROR_STRING, string);
 }
-static inline struct sk_buff *cfg_reply_ultra_string(char *string)
+static inline struct sk_buff *tipc_cfg_reply_ultra_string(char *string)
 {
-        return cfg_reply_string_type(TIPC_TLV_ULTRA_STRING, string);
+        return tipc_cfg_reply_string_type(TIPC_TLV_ULTRA_STRING, string);
 }
-struct sk_buff *cfg_do_cmd(u32 orig_node, u16 cmd, 
+struct sk_buff *tipc_cfg_do_cmd(u32 orig_node, u16 cmd, 
-                           const void *req_tlv_area, int req_tlv_space, 
+                                const void *req_tlv_area, int req_tlv_space, 
-                           int headroom);
+                                int headroom);
-void cfg_link_event(u32 addr, char *name, int up);
+void tipc_cfg_link_event(u32 addr, char *name, int up);
-int  cfg_init(void);
+int  tipc_cfg_init(void);
-void cfg_stop(void);
+void tipc_cfg_stop(void);
 #endif
diff --git a/net/tipc/core.c b/net/tipc/core.c
index e83ac06e31ba..3d0a8ee4e1d3 100644
--- a/net/tipc/core.c
+++ b/net/tipc/core.c
@@ -37,7 +37,6 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
-#include <linux/version.h>
 #include <linux/random.h>
 #include "core.h"
@@ -49,14 +48,14 @@
 #include "subscr.h"
 #include "config.h"
-int  eth_media_start(void);
+int  tipc_eth_media_start(void);
-void eth_media_stop(void);
+void tipc_eth_media_stop(void);
-int  handler_start(void);
+int  tipc_handler_start(void);
-void handler_stop(void);
+void tipc_handler_stop(void);
-int  socket_init(void);
+int  tipc_socket_init(void);
-void socket_stop(void);
+void tipc_socket_stop(void);
-int  netlink_start(void);
+int  tipc_netlink_start(void);
-void netlink_stop(void);
+void tipc_netlink_stop(void);
 #define MOD_NAME "tipc_start: "
@@ -113,56 +112,56 @@ int tipc_get_mode(void)
 }
 /**
- * stop_net - shut down TIPC networking sub-systems
+ * tipc_core_stop_net - shut down TIPC networking sub-systems
 */
-void stop_net(void)
+void tipc_core_stop_net(void)
 {
-        eth_media_stop();
+        tipc_eth_media_stop();
-        tipc_stop_net();
+        tipc_net_stop();
 }
 /**
 * start_net - start TIPC networking sub-systems
 */
-int start_net(void)
+int tipc_core_start_net(void)
 {
        int res;
-        if ((res = tipc_start_net()) ||
+        if ((res = tipc_net_start()) ||
-            (res = eth_media_start())) {
+            (res = tipc_eth_media_start())) {
-                stop_net();
+                tipc_core_stop_net();
        }
        return res;
 }
 /**
- * stop_core - switch TIPC from SINGLE NODE to NOT RUNNING mode
+ * tipc_core_stop - switch TIPC from SINGLE NODE to NOT RUNNING mode
 */
-void stop_core(void)
+void tipc_core_stop(void)
 {
        if (tipc_mode != TIPC_NODE_MODE)
                return;
        tipc_mode = TIPC_NOT_RUNNING;
-        netlink_stop();
+        tipc_netlink_stop();
-        handler_stop();
+        tipc_handler_stop();
-        cfg_stop();
+        tipc_cfg_stop();
-        subscr_stop();
+        tipc_subscr_stop();
-        reg_stop();
+        tipc_reg_stop();
-        nametbl_stop();
+        tipc_nametbl_stop();
-        ref_table_stop();
+        tipc_ref_table_stop();
-        socket_stop();
+        tipc_socket_stop();
 }
 /**
- * start_core - switch TIPC from NOT RUNNING to SINGLE NODE mode
+ * tipc_core_start - switch TIPC from NOT RUNNING to SINGLE NODE mode
 */
-int start_core(void)
+int tipc_core_start(void)
 {
        int res;
@@ -172,16 +171,16 @@ int start_core(void)
        get_random_bytes(&tipc_random, sizeof(tipc_random));
        tipc_mode = TIPC_NODE_MODE;
-        if ((res = handler_start()) || 
+        if ((res = tipc_handler_start()) || 
-            (res = ref_table_init(tipc_max_ports + tipc_max_subscriptions,
+            (res = tipc_ref_table_init(tipc_max_ports + tipc_max_subscriptions,
-                                  tipc_random)) ||
+                                       tipc_random)) ||
-            (res = reg_start()) ||
+            (res = tipc_reg_start()) ||
-            (res = nametbl_init()) ||
+            (res = tipc_nametbl_init()) ||
-            (res = k_signal((Handler)subscr_start, 0)) ||
+            (res = tipc_k_signal((Handler)tipc_subscr_start, 0)) ||
-            (res = k_signal((Handler)cfg_init, 0)) || 
+            (res = tipc_k_signal((Handler)tipc_cfg_init, 0)) || 
-            (res = netlink_start()) ||
+            (res = tipc_netlink_start()) ||
-            (res = socket_init())) {
+            (res = tipc_socket_init())) {
-                stop_core();
+                tipc_core_stop();
        }
        return res;
 }
@@ -191,7 +190,7 @@ static int __init tipc_init(void)
 {
        int res;
-        log_reinit(CONFIG_TIPC_LOG);
+        tipc_log_reinit(CONFIG_TIPC_LOG);
        info("Activated (compiled " __DATE__ " " __TIME__ ")\n");
        tipc_own_addr = 0;
@@ -205,7 +204,7 @@ static int __init tipc_init(void)
        tipc_max_slaves = delimit(CONFIG_TIPC_SLAVE_NODES, 0, 2047);
        tipc_net_id = 4711;
-        if ((res = start_core()))
+        if ((res = tipc_core_start()))
                err("Unable to start in single node mode\n");
        else    
                info("Started in single node mode\n");
@@ -214,10 +213,10 @@ static int __init tipc_init(void)
 static void __exit tipc_exit(void)
 {
-        stop_net();
+        tipc_core_stop_net();
-        stop_core();
+        tipc_core_stop();
        info("Deactivated\n");
-        log_stop();
+        tipc_log_stop();
 }
 module_init(tipc_init);
diff --git a/net/tipc/core.h b/net/tipc/core.h
index b69b60b2cc86..1f2e8b27a13f 100644
--- a/net/tipc/core.h
+++ b/net/tipc/core.h
@@ -37,6 +37,11 @@
 #ifndef _TIPC_CORE_H
 #define _TIPC_CORE_H
+#include <linux/tipc.h>
+#include <linux/tipc_config.h>
+#include <net/tipc/tipc_msg.h>
+#include <net/tipc/tipc_port.h>
+#include <net/tipc/tipc_bearer.h>
 #include <net/tipc/tipc.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
@@ -60,9 +65,9 @@
 #define assert(i)  BUG_ON(!(i))
 struct tipc_msg;
-extern struct print_buf *CONS, *LOG;
+extern struct print_buf *TIPC_CONS, *TIPC_LOG;
-extern struct print_buf *TEE(struct print_buf *, struct print_buf *);
+extern struct print_buf *TIPC_TEE(struct print_buf *, struct print_buf *);
-void msg_print(struct print_buf*,struct tipc_msg *,const char*);
+void tipc_msg_print(struct print_buf*,struct tipc_msg *,const char*);
 void tipc_printf(struct print_buf *, const char *fmt, ...);
 void tipc_dump(struct print_buf*,const char *fmt, ...);
@@ -79,7 +84,7 @@ void tipc_dump(struct print_buf*,const char *fmt, ...);
 #define info(fmt, arg...) tipc_printf(TIPC_OUTPUT, KERN_NOTICE "TIPC: " fmt, ## arg)
 #define dbg(fmt, arg...)  do {if (DBG_OUTPUT) tipc_printf(DBG_OUTPUT, fmt, ## arg);} while(0)
-#define msg_dbg(msg, txt) do {if (DBG_OUTPUT) msg_print(DBG_OUTPUT, msg, txt);} while(0)
+#define msg_dbg(msg, txt) do {if (DBG_OUTPUT) tipc_msg_print(DBG_OUTPUT, msg, txt);} while(0)
 #define dump(fmt, arg...) do {if (DBG_OUTPUT) tipc_dump(DBG_OUTPUT, fmt, ##arg);} while(0)
@@ -89,15 +94,15 @@ void tipc_dump(struct print_buf*,const char *fmt, ...);
 * here, or on a per .c file basis, by redefining these symbols.  The following
 * print buffer options are available:
 *
- * NULL                 : Output to null print buffer (i.e. print nowhere)
+ * NULL                         : Output to null print buffer (i.e. print nowhere)
- * CONS                 : Output to system console
+ * TIPC_CONS                    : Output to system console
- * LOG                  : Output to TIPC log buffer 
+ * TIPC_LOG                     : Output to TIPC log buffer 
- * &buf                 : Output to user-defined buffer (struct print_buf *)
+ * &buf                         : Output to user-defined buffer (struct print_buf *)
- * TEE(&buf_a,&buf_b)   : Output to two print buffers (eg. TEE(CONS,LOG) )
+ * TIPC_TEE(&buf_a,&buf_b)      : Output to two print buffers (eg. TIPC_TEE(TIPC_CONS,TIPC_LOG) )
 */
 #ifndef TIPC_OUTPUT
-#define TIPC_OUTPUT TEE(CONS,LOG)
+#define TIPC_OUTPUT TIPC_TEE(TIPC_CONS,TIPC_LOG)
 #endif
 #ifndef DBG_OUTPUT
@@ -162,10 +167,10 @@ extern atomic_t tipc_user_count;
 * Routines available to privileged subsystems
 */
-extern int  start_core(void);
+extern int  tipc_core_start(void);
-extern void stop_core(void);
+extern void tipc_core_stop(void);
-extern int  start_net(void);
+extern int  tipc_core_start_net(void);
-extern void stop_net(void);
+extern void tipc_core_stop_net(void);
 static inline int delimit(int val, int min, int max)
 {
@@ -183,7 +188,7 @@ static inline int delimit(int val, int min, int max)
 typedef void (*Handler) (unsigned long);
-u32 k_signal(Handler routine, unsigned long argument);
+u32 tipc_k_signal(Handler routine, unsigned long argument);
 /**
 * k_init_timer - initialize a timer
diff --git a/net/tipc/dbg.c b/net/tipc/dbg.c
index 7ed60a1cfbb8..4f4beefa7830 100644
--- a/net/tipc/dbg.c
+++ b/net/tipc/dbg.c
@@ -44,10 +44,10 @@ static char print_string[MAX_STRING];
 static spinlock_t print_lock = SPIN_LOCK_UNLOCKED;
 static struct print_buf cons_buf = { NULL, 0, NULL, NULL };
-struct print_buf *CONS = &cons_buf;
+struct print_buf *TIPC_CONS = &cons_buf;
 static struct print_buf log_buf = { NULL, 0, NULL, NULL };
-struct print_buf *LOG = &log_buf;
+struct print_buf *TIPC_LOG = &log_buf;
 #define FORMAT(PTR,LEN,FMT) \
@@ -66,15 +66,15 @@ struct print_buf *LOG = &log_buf;
 *    simultaneous use of the print buffer(s) being manipulated.
 * 2) tipc_printf() uses 'print_lock' to prevent simultaneous use of
 *    'print_string' and to protect its print buffer(s).
- * 3) TEE() uses 'print_lock' to protect its print buffer(s).
+ * 3) TIPC_TEE() uses 'print_lock' to protect its print buffer(s).
- * 4) Routines of the form log_XXX() uses 'print_lock' to protect LOG.
+ * 4) Routines of the form log_XXX() uses 'print_lock' to protect TIPC_LOG.
 */
 /**
- * printbuf_init - initialize print buffer to empty
+ * tipc_printbuf_init - initialize print buffer to empty
 */
-void printbuf_init(struct print_buf *pb, char *raw, u32 sz)
+void tipc_printbuf_init(struct print_buf *pb, char *raw, u32 sz)
 {
        if (!pb || !raw || (sz < (MAX_STRING + 1)))
                return;
@@ -87,26 +87,26 @@ void printbuf_init(struct print_buf *pb, char *raw, u32 sz)
 }
 /**
- * printbuf_reset - reinitialize print buffer to empty state
+ * tipc_printbuf_reset - reinitialize print buffer to empty state
 */
-void printbuf_reset(struct print_buf *pb)
+void tipc_printbuf_reset(struct print_buf *pb)
 {
        if (pb && pb->buf)
-                printbuf_init(pb, pb->buf, pb->size);
+                tipc_printbuf_init(pb, pb->buf, pb->size);
 }
 /**
- * printbuf_empty - test if print buffer is in empty state
+ * tipc_printbuf_empty - test if print buffer is in empty state
 */
-int printbuf_empty(struct print_buf *pb)
+int tipc_printbuf_empty(struct print_buf *pb)
 {
        return (!pb || !pb->buf || (pb->crs == pb->buf));
 }
 /**
- * printbuf_validate - check for print buffer overflow
+ * tipc_printbuf_validate - check for print buffer overflow
 * 
 * Verifies that a print buffer has captured all data written to it. 
 * If data has been lost, linearize buffer and prepend an error message
@@ -114,7 +114,7 @@ int printbuf_empty(struct print_buf *pb)
 * Returns length of print buffer data string (including trailing NULL)
 */
-int printbuf_validate(struct print_buf *pb)
+int tipc_printbuf_validate(struct print_buf *pb)
 {
        char *err = "             *** PRINT BUFFER WRAPPED AROUND ***\n";
        char *cp_buf;
@@ -126,13 +126,13 @@ int printbuf_validate(struct print_buf *pb)
        if (pb->buf[pb->size - 1] == '\0') {
                cp_buf = kmalloc(pb->size, GFP_ATOMIC);
                if (cp_buf != NULL){
-                        printbuf_init(&cb, cp_buf, pb->size);
+                        tipc_printbuf_init(&cb, cp_buf, pb->size);
-                        printbuf_move(&cb, pb);
+                        tipc_printbuf_move(&cb, pb);
-                        printbuf_move(pb, &cb);
+                        tipc_printbuf_move(pb, &cb);
                        kfree(cp_buf);
                        memcpy(pb->buf, err, strlen(err));
                } else {
-                        printbuf_reset(pb);
+                        tipc_printbuf_reset(pb);
                        tipc_printf(pb, err);
                }
        }
@@ -140,13 +140,13 @@ int printbuf_validate(struct print_buf *pb)
 }
 /**
- * printbuf_move - move print buffer contents to another print buffer
+ * tipc_printbuf_move - move print buffer contents to another print buffer
 * 
 * Current contents of destination print buffer (if any) are discarded.
 * Source print buffer becomes empty if a successful move occurs.
 */
-void printbuf_move(struct print_buf *pb_to, struct print_buf *pb_from)
+void tipc_printbuf_move(struct print_buf *pb_to, struct print_buf *pb_from)
 {
        int len;
@@ -156,12 +156,12 @@ void printbuf_move(struct print_buf *pb_to, struct print_buf *pb_from)
                return;
        if (!pb_from || !pb_from->buf) {
-                printbuf_reset(pb_to);
+                tipc_printbuf_reset(pb_to);
                return;
        }
        if (pb_to->size < pb_from->size) {
-                printbuf_reset(pb_to);
+                tipc_printbuf_reset(pb_to);
                tipc_printf(pb_to, "*** PRINT BUFFER OVERFLOW ***");
                return;
        }
@@ -179,7 +179,7 @@ void printbuf_move(struct print_buf *pb_to, struct print_buf *pb_from)
        strcpy(pb_to->crs, pb_from->buf);
        pb_to->crs += len;
-        printbuf_reset(pb_from);
+        tipc_printbuf_reset(pb_from);
 }
 /**
@@ -199,7 +199,7 @@ void tipc_printf(struct print_buf *pb, const char *fmt, ...)
                strcpy(print_string, "*** STRING TOO LONG ***");
        while (pb) {
-                if (pb == CONS)
+                if (pb == TIPC_CONS)
                        printk(print_string);
                else if (pb->buf) {
                        chars_left = pb->buf + pb->size - pb->crs - 1;
@@ -223,10 +223,10 @@ void tipc_printf(struct print_buf *pb, const char *fmt, ...)
 }
 /**
- * TEE - perform next output operation on both print buffers  
+ * TIPC_TEE - perform next output operation on both print buffers  
 */
-struct print_buf *TEE(struct print_buf *b0, struct print_buf *b1)
+struct print_buf *TIPC_TEE(struct print_buf *b0, struct print_buf *b1)
 {
        struct print_buf *pb = b0;
@@ -294,96 +294,96 @@ void tipc_dump(struct print_buf *pb, const char *fmt, ...)
        int len;
        spin_lock_bh(&print_lock);
-        FORMAT(CONS->buf, len, fmt);
+        FORMAT(TIPC_CONS->buf, len, fmt);
-        printk(CONS->buf);
+        printk(TIPC_CONS->buf);
        for (; pb; pb = pb->next) {
-                if (pb == CONS)
+                if (pb == TIPC_CONS)
                        continue;
                printk("\n---- Start of dump,%s log ----\n\n", 
-                       (pb == LOG) ? "global" : "local");
+                       (pb == TIPC_LOG) ? "global" : "local");
                printbuf_dump(pb);
-                printbuf_reset(pb);
+                tipc_printbuf_reset(pb);
                printk("\n-------- End of dump --------\n");
        }
        spin_unlock_bh(&print_lock);
 }
 /**
- * log_stop - free up TIPC log print buffer 
+ * tipc_log_stop - free up TIPC log print buffer 
 */
-void log_stop(void)
+void tipc_log_stop(void)
 {
        spin_lock_bh(&print_lock);
-        if (LOG->buf) {
+        if (TIPC_LOG->buf) {
-                kfree(LOG->buf);
+                kfree(TIPC_LOG->buf);
-                LOG->buf = NULL;
+                TIPC_LOG->buf = NULL;
        }
        spin_unlock_bh(&print_lock);
 }
 /**
- * log_reinit - set TIPC log print buffer to specified size
+ * tipc_log_reinit - set TIPC log print buffer to specified size
 */
-void log_reinit(int log_size)
+void tipc_log_reinit(int log_size)
 {
-        log_stop();
+        tipc_log_stop();
        if (log_size) {
                if (log_size <= MAX_STRING)
                        log_size = MAX_STRING + 1;
                spin_lock_bh(&print_lock);
-                printbuf_init(LOG, kmalloc(log_size, GFP_ATOMIC), log_size);
+                tipc_printbuf_init(TIPC_LOG, kmalloc(log_size, GFP_ATOMIC), log_size);
                spin_unlock_bh(&print_lock);
        }
 }
 /**
- * log_resize - reconfigure size of TIPC log buffer
+ * tipc_log_resize - reconfigure size of TIPC log buffer
 */
-struct sk_buff *log_resize(const void *req_tlv_area, int req_tlv_space)
+struct sk_buff *tipc_log_resize(const void *req_tlv_area, int req_tlv_space)
 {
        u32 value;
        if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
-                return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
+                return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
        value = *(u32 *)TLV_DATA(req_tlv_area);
        value = ntohl(value);
        if (value != delimit(value, 0, 32768))
-                return cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
+                return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
-                                              " (log size must be 0-32768)");
+                                                   " (log size must be 0-32768)");
-        log_reinit(value);
+        tipc_log_reinit(value);
-        return cfg_reply_none();
+        return tipc_cfg_reply_none();
 }
 /**
- * log_dump - capture TIPC log buffer contents in configuration message
+ * tipc_log_dump - capture TIPC log buffer contents in configuration message
 */
-struct sk_buff *log_dump(void)
+struct sk_buff *tipc_log_dump(void)
 {
        struct sk_buff *reply;
        spin_lock_bh(&print_lock);
-        if (!LOG->buf)
+        if (!TIPC_LOG->buf)
-                reply = cfg_reply_ultra_string("log not activated\n");
+                reply = tipc_cfg_reply_ultra_string("log not activated\n");
-        else if (printbuf_empty(LOG))
+        else if (tipc_printbuf_empty(TIPC_LOG))
-                reply = cfg_reply_ultra_string("log is empty\n");
+                reply = tipc_cfg_reply_ultra_string("log is empty\n");
        else {
                struct tlv_desc *rep_tlv;
                struct print_buf pb;
                int str_len;
-                str_len = min(LOG->size, 32768u);
+                str_len = min(TIPC_LOG->size, 32768u);
-                reply = cfg_reply_alloc(TLV_SPACE(str_len));
+                reply = tipc_cfg_reply_alloc(TLV_SPACE(str_len));
                if (reply) {
                        rep_tlv = (struct tlv_desc *)reply->data;
-                        printbuf_init(&pb, TLV_DATA(rep_tlv), str_len);
+                        tipc_printbuf_init(&pb, TLV_DATA(rep_tlv), str_len);
-                        printbuf_move(&pb, LOG);
+                        tipc_printbuf_move(&pb, TIPC_LOG);
                        str_len = strlen(TLV_DATA(rep_tlv)) + 1;
                        skb_put(reply, TLV_SPACE(str_len));
                        TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
diff --git a/net/tipc/dbg.h b/net/tipc/dbg.h
index c6b2a64c224f..227f050d2a52 100644
--- a/net/tipc/dbg.h
+++ b/net/tipc/dbg.h
@@ -44,16 +44,16 @@ struct print_buf {
        struct print_buf *next;
 };
-void printbuf_init(struct print_buf *pb, char *buf, u32 sz);
+void tipc_printbuf_init(struct print_buf *pb, char *buf, u32 sz);
-void printbuf_reset(struct print_buf *pb);
+void tipc_printbuf_reset(struct print_buf *pb);
-int  printbuf_empty(struct print_buf *pb);
+int  tipc_printbuf_empty(struct print_buf *pb);
-int  printbuf_validate(struct print_buf *pb);
+int  tipc_printbuf_validate(struct print_buf *pb);
-void printbuf_move(struct print_buf *pb_to, struct print_buf *pb_from);
+void tipc_printbuf_move(struct print_buf *pb_to, struct print_buf *pb_from);
-void log_reinit(int log_size);
+void tipc_log_reinit(int log_size);
-void log_stop(void);
+void tipc_log_stop(void);
-struct sk_buff *log_resize(const void *req_tlv_area, int req_tlv_space);
+struct sk_buff *tipc_log_resize(const void *req_tlv_area, int req_tlv_space);
-struct sk_buff *log_dump(void);
+struct sk_buff *tipc_log_dump(void);
 #endif
diff --git a/net/tipc/discover.c b/net/tipc/discover.c
index b106ef1621cc..53ba4630c10d 100644
--- a/net/tipc/discover.c
+++ b/net/tipc/discover.c
@@ -93,7 +93,7 @@ int disc_create_link(const struct tipc_link_create *argv)
 * disc_lost_link(): A link has lost contact
 */
-void disc_link_event(u32 addr, char *name, int up) 
+void tipc_disc_link_event(u32 addr, char *name, int up) 
 {
        if (in_own_cluster(addr))
                return;
@@ -103,17 +103,17 @@ void disc_link_event(u32 addr, char *name, int up)
 }
 /** 
- * disc_init_msg - initialize a link setup message
+ * tipc_disc_init_msg - initialize a link setup message
 * @type: message type (request or response)
 * @req_links: number of links associated with message
 * @dest_domain: network domain of node(s) which should respond to message
 * @b_ptr: ptr to bearer issuing message
 */
-struct sk_buff *disc_init_msg(u32 type,
+struct sk_buff *tipc_disc_init_msg(u32 type,
-                              u32 req_links,
+                                   u32 req_links,
-                              u32 dest_domain,
+                                   u32 dest_domain,
-                              struct bearer *b_ptr)
+                                   struct bearer *b_ptr)
 {
        struct sk_buff *buf = buf_acquire(DSC_H_SIZE);
        struct tipc_msg *msg;
@@ -132,11 +132,11 @@ struct sk_buff *disc_init_msg(u32 type,
 }
 /**
- * disc_recv_msg - handle incoming link setup message (request or response)
+ * tipc_disc_recv_msg - handle incoming link setup message (request or response)
 * @buf: buffer containing message
 */
-void disc_recv_msg(struct sk_buff *buf)
+void tipc_disc_recv_msg(struct sk_buff *buf)
 {
        struct bearer *b_ptr = (struct bearer *)TIPC_SKB_CB(buf)->handle;
        struct link *link;
@@ -153,9 +153,9 @@ void disc_recv_msg(struct sk_buff *buf)
        if (net_id != tipc_net_id)
                return;
-        if (!addr_domain_valid(dest))
+        if (!tipc_addr_domain_valid(dest))
                return;
-        if (!addr_node_valid(orig))
+        if (!tipc_addr_node_valid(orig))
                return;
        if (orig == tipc_own_addr)
                return;
@@ -169,11 +169,11 @@ void disc_recv_msg(struct sk_buff *buf)
                /* Always accept link here */
                struct sk_buff *rbuf;
                struct tipc_media_addr *addr;
-                struct node *n_ptr = node_find(orig);
+                struct node *n_ptr = tipc_node_find(orig);
                int link_up;
                dbg(" in own cluster\n");
                if (n_ptr == NULL) {
-                        n_ptr = node_create(orig);
+                        n_ptr = tipc_node_create(orig);
                }
                if (n_ptr == NULL) {
                        warn("Memory squeeze; Failed to create node\n");
@@ -183,7 +183,7 @@ void disc_recv_msg(struct sk_buff *buf)
                link = n_ptr->links[b_ptr->identity];
                if (!link) {
                        dbg("creating link\n");
-                        link = link_create(b_ptr, orig, &media_addr);
+                        link = tipc_link_create(b_ptr, orig, &media_addr);
                        if (!link) {
                                spin_unlock_bh(&n_ptr->lock);                
                                return;
@@ -196,13 +196,13 @@ void disc_recv_msg(struct sk_buff *buf)
                        warn("New bearer address for %s\n", 
                             addr_string_fill(addr_string, orig));
                        memcpy(addr, &media_addr, sizeof(*addr));
-                        link_reset(link);     
+                        tipc_link_reset(link);     
                }
-                link_up = link_is_up(link);
+                link_up = tipc_link_is_up(link);
                spin_unlock_bh(&n_ptr->lock);                
                if ((type == DSC_RESP_MSG) || link_up)
                        return;
-                rbuf = disc_init_msg(DSC_RESP_MSG, 1, orig, b_ptr);
+                rbuf = tipc_disc_init_msg(DSC_RESP_MSG, 1, orig, b_ptr);
                if (rbuf != NULL) {
                        msg_dbg(buf_msg(rbuf),"SEND:");
                        b_ptr->media->send_msg(rbuf, &b_ptr->publ, &media_addr);
@@ -212,11 +212,11 @@ void disc_recv_msg(struct sk_buff *buf)
 }
 /**
- * disc_stop_link_req - stop sending periodic link setup requests
+ * tipc_disc_stop_link_req - stop sending periodic link setup requests
 * @req: ptr to link request structure
 */
-void disc_stop_link_req(struct link_req *req) 
+void tipc_disc_stop_link_req(struct link_req *req) 
 {
        if (!req)
                return;
@@ -228,11 +228,11 @@ void disc_stop_link_req(struct link_req *req)
 } 
 /**
- * disc_update_link_req - update frequency of periodic link setup requests
+ * tipc_disc_update_link_req - update frequency of periodic link setup requests
 * @req: ptr to link request structure
 */
-void disc_update_link_req(struct link_req *req) 
+void tipc_disc_update_link_req(struct link_req *req) 
 {
        if (!req)
                return;
@@ -282,7 +282,7 @@ static void disc_timeout(struct link_req *req)
 }
 /**
- * disc_init_link_req - start sending periodic link setup requests
+ * tipc_disc_init_link_req - start sending periodic link setup requests
 * @b_ptr: ptr to bearer issuing requests
 * @dest: destination address for request messages
 * @dest_domain: network domain of node(s) which should respond to message
@@ -291,10 +291,10 @@ static void disc_timeout(struct link_req *req)
 * Returns pointer to link request structure, or NULL if unable to create.
 */
-struct link_req *disc_init_link_req(struct bearer *b_ptr, 
+struct link_req *tipc_disc_init_link_req(struct bearer *b_ptr, 
-                                    const struct tipc_media_addr *dest,
+                                         const struct tipc_media_addr *dest,
-                                    u32 dest_domain,
+                                         u32 dest_domain,
-                                    u32 req_links) 
+                                         u32 req_links) 
 {
        struct link_req *req;
@@ -302,7 +302,7 @@ struct link_req *disc_init_link_req(struct bearer *b_ptr,
        if (!req)
                return NULL;
-        req->buf = disc_init_msg(DSC_REQ_MSG, req_links, dest_domain, b_ptr);
+        req->buf = tipc_disc_init_msg(DSC_REQ_MSG, req_links, dest_domain, b_ptr);
        if (!req->buf) {
                kfree(req);
                return NULL;
diff --git a/net/tipc/discover.h b/net/tipc/discover.h
index 2a6114d91626..0454fd1ae7f3 100644
--- a/net/tipc/discover.h
+++ b/net/tipc/discover.h
@@ -37,20 +37,20 @@
 #ifndef _TIPC_DISCOVER_H
 #define _TIPC_DISCOVER_H
-#include <linux/tipc.h>
+#include "core.h"
 struct link_req;
-struct link_req *disc_init_link_req(struct bearer *b_ptr, 
+struct link_req *tipc_disc_init_link_req(struct bearer *b_ptr, 
-                                    const struct tipc_media_addr *dest,
+                                         const struct tipc_media_addr *dest,
-                                    u32 dest_domain,
+                                         u32 dest_domain,
-                                    u32 req_links);
+                                         u32 req_links);
-void disc_update_link_req(struct link_req *req);
+void tipc_disc_update_link_req(struct link_req *req);
-void disc_stop_link_req(struct link_req *req);
+void tipc_disc_stop_link_req(struct link_req *req);
-void disc_recv_msg(struct sk_buff *buf);
+void tipc_disc_recv_msg(struct sk_buff *buf);
-void disc_link_event(u32 addr, char *name, int up);
+void tipc_disc_link_event(u32 addr, char *name, int up);
 #if 0
 int  disc_create_link(const struct tipc_link_create *argv);
 #endif
diff --git a/net/tipc/eth_media.c b/net/tipc/eth_media.c
index 34d0462db3aa..1f8d83b9c8b4 100644
--- a/net/tipc/eth_media.c
+++ b/net/tipc/eth_media.c
@@ -38,13 +38,11 @@
 #include <net/tipc/tipc_bearer.h>
 #include <net/tipc/tipc_msg.h>
 #include <linux/netdevice.h>
-#include <linux/version.h>
 #define MAX_ETH_BEARERS         2
-#define TIPC_PROTOCOL           0x88ca
+#define ETH_LINK_PRIORITY       TIPC_DEF_LINK_PRI
-#define ETH_LINK_PRIORITY       10
 #define ETH_LINK_TOLERANCE      TIPC_DEF_LINK_TOL
+#define ETH_LINK_WINDOW         TIPC_DEF_LINK_WIN
 /**
 * struct eth_bearer - Ethernet bearer data structure
@@ -78,7 +76,7 @@ static int send_msg(struct sk_buff *buf, struct tipc_bearer *tb_ptr,
                clone->nh.raw = clone->data;
                dev = ((struct eth_bearer *)(tb_ptr->usr_handle))->dev;
                clone->dev = dev;
-                dev->hard_header(clone, dev, TIPC_PROTOCOL, 
+                dev->hard_header(clone, dev, ETH_P_TIPC, 
                                 &dest->dev_addr.eth_addr,
                                 dev->dev_addr, clone->len);
                dev_queue_xmit(clone);
@@ -141,7 +139,7 @@ static int enable_bearer(struct tipc_bearer *tb_ptr)
                return -EDQUOT;
        if (!eb_ptr->dev) {
                eb_ptr->dev = dev;
-                eb_ptr->tipc_packet_type.type = __constant_htons(TIPC_PROTOCOL);
+                eb_ptr->tipc_packet_type.type = __constant_htons(ETH_P_TIPC);
                eb_ptr->tipc_packet_type.dev = dev;
                eb_ptr->tipc_packet_type.func = recv_msg;
                eb_ptr->tipc_packet_type.af_packet_priv = eb_ptr;
@@ -240,13 +238,13 @@ static char *eth_addr2str(struct tipc_media_addr *a, char *str_buf, int str_size
 }
 /**
- * eth_media_start - activate Ethernet bearer support
+ * tipc_eth_media_start - activate Ethernet bearer support
 *
 * Register Ethernet media type with TIPC bearer code.  Also register
 * with OS for notifications about device state changes.
 */
-int eth_media_start(void)
+int tipc_eth_media_start(void)
 {                       
        struct tipc_media_addr bcast_addr;
        int res;
@@ -260,7 +258,7 @@ int eth_media_start(void)
        res = tipc_register_media(TIPC_MEDIA_TYPE_ETH, "eth",
                                  enable_bearer, disable_bearer, send_msg, 
                                  eth_addr2str, &bcast_addr, ETH_LINK_PRIORITY, 
-                                  ETH_LINK_TOLERANCE, TIPC_DEF_LINK_WIN);
+                                  ETH_LINK_TOLERANCE, ETH_LINK_WINDOW);
        if (res)
                return res;
@@ -273,10 +271,10 @@ int eth_media_start(void)
 }
 /**
- * eth_media_stop - deactivate Ethernet bearer support
+ * tipc_eth_media_stop - deactivate Ethernet bearer support
 */
-void eth_media_stop(void)
+void tipc_eth_media_stop(void)
 {
        int i;
diff --git a/net/tipc/handler.c b/net/tipc/handler.c
index f320010f8a65..966f70a1b608 100644
--- a/net/tipc/handler.c
+++ b/net/tipc/handler.c
@@ -52,7 +52,7 @@ static void process_signal_queue(unsigned long dummy);
 static DECLARE_TASKLET_DISABLED(tipc_tasklet, process_signal_queue, 0);
-unsigned int k_signal(Handler routine, unsigned long argument)
+unsigned int tipc_k_signal(Handler routine, unsigned long argument)
 {
        struct queue_item *item;
@@ -93,7 +93,7 @@ static void process_signal_queue(unsigned long dummy)
        spin_unlock_bh(&qitem_lock);
 }
-int handler_start(void)
+int tipc_handler_start(void)
 {
        tipc_queue_item_cache = 
                kmem_cache_create("tipc_queue_items", sizeof(struct queue_item),
@@ -107,7 +107,7 @@ int handler_start(void)
        return 0;
 }
-void handler_stop(void)
+void tipc_handler_stop(void)
 {
        struct list_head *l, *n;
        struct queue_item *item; 
diff --git a/net/tipc/link.c b/net/tipc/link.c
index 7265f4be4766..511872afa459 100644
--- a/net/tipc/link.c
+++ b/net/tipc/link.c
@@ -148,12 +148,12 @@ static void link_print(struct link *l_ptr, struct print_buf *buf,
 #define LINK_LOG_BUF_SIZE 0
 #define dbg_link(fmt, arg...)  do {if (LINK_LOG_BUF_SIZE) tipc_printf(&l_ptr->print_buf, fmt, ## arg); } while(0)
-#define dbg_link_msg(msg, txt) do {if (LINK_LOG_BUF_SIZE) msg_print(&l_ptr->print_buf, msg, txt); } while(0)
+#define dbg_link_msg(msg, txt) do {if (LINK_LOG_BUF_SIZE) tipc_msg_print(&l_ptr->print_buf, msg, txt); } while(0)
 #define dbg_link_state(txt) do {if (LINK_LOG_BUF_SIZE) link_print(l_ptr, &l_ptr->print_buf, txt); } while(0)
 #define dbg_link_dump() do { \
        if (LINK_LOG_BUF_SIZE) { \
                tipc_printf(LOG, "\n\nDumping link <%s>:\n", l_ptr->name); \
-                printbuf_move(LOG, &l_ptr->print_buf); \
+                tipc_printbuf_move(LOG, &l_ptr->print_buf); \
        } \
 } while (0)
@@ -252,14 +252,14 @@ static inline u32 link_last_sent(struct link *l_ptr)
 *  Simple non-inlined link routines (i.e. referenced outside this file)
 */
-int link_is_up(struct link *l_ptr)
+int tipc_link_is_up(struct link *l_ptr)
 {
        if (!l_ptr)
                return 0;
        return (link_working_working(l_ptr) || link_working_unknown(l_ptr));
 }
-int link_is_active(struct link *l_ptr)
+int tipc_link_is_active(struct link *l_ptr)
 {
        return ((l_ptr->owner->active_links[0] == l_ptr) ||
                (l_ptr->owner->active_links[1] == l_ptr));
@@ -338,15 +338,15 @@ static int link_name_validate(const char *name, struct link_name *name_parts)
 * link_timeout - handle expiration of link timer
 * @l_ptr: pointer to link
 * 
- * This routine must not grab "net_lock" to avoid a potential deadlock conflict
+ * This routine must not grab "tipc_net_lock" to avoid a potential deadlock conflict
- * with link_delete().  (There is no risk that the node will be deleted by
+ * with tipc_link_delete().  (There is no risk that the node will be deleted by
- * another thread because link_delete() always cancels the link timer before
+ * another thread because tipc_link_delete() always cancels the link timer before
- * node_delete() is called.)
+ * tipc_node_delete() is called.)
 */
 static void link_timeout(struct link *l_ptr)
 {
-        node_lock(l_ptr->owner);
+        tipc_node_lock(l_ptr->owner);
        /* update counters used in statistical profiling of send traffic */
@@ -391,9 +391,9 @@ static void link_timeout(struct link *l_ptr)
        link_state_event(l_ptr, TIMEOUT_EVT);
        if (l_ptr->next_out)
-                link_push_queue(l_ptr);
+                tipc_link_push_queue(l_ptr);
-        node_unlock(l_ptr->owner);
+        tipc_node_unlock(l_ptr->owner);
 }
 static inline void link_set_timer(struct link *l_ptr, u32 time)
@@ -402,7 +402,7 @@ static inline void link_set_timer(struct link *l_ptr, u32 time)
 }
 /**
- * link_create - create a new link
+ * tipc_link_create - create a new link
 * @b_ptr: pointer to associated bearer
 * @peer: network address of node at other end of link
 * @media_addr: media address to use when sending messages over link
@@ -410,8 +410,8 @@ static inline void link_set_timer(struct link *l_ptr, u32 time)
 * Returns pointer to link.
 */
-struct link *link_create(struct bearer *b_ptr, const u32 peer,
+struct link *tipc_link_create(struct bearer *b_ptr, const u32 peer,
-                         const struct tipc_media_addr *media_addr)
+                              const struct tipc_media_addr *media_addr)
 {
        struct link *l_ptr;
        struct tipc_msg *msg;
@@ -449,7 +449,7 @@ struct link *link_create(struct bearer *b_ptr, const u32 peer,
        strcpy((char *)msg_data(msg), if_name);
        l_ptr->priority = b_ptr->priority;
-        link_set_queue_limits(l_ptr, b_ptr->media->window);
+        tipc_link_set_queue_limits(l_ptr, b_ptr->media->window);
        link_init_max_pkt(l_ptr);
@@ -458,7 +458,7 @@ struct link *link_create(struct bearer *b_ptr, const u32 peer,
        link_reset_statistics(l_ptr);
-        l_ptr->owner = node_attach_link(l_ptr);
+        l_ptr->owner = tipc_node_attach_link(l_ptr);
        if (!l_ptr->owner) {
                kfree(l_ptr);
                return NULL;
@@ -472,52 +472,52 @@ struct link *link_create(struct bearer *b_ptr, const u32 peer,
                        warn("Memory squeeze; Failed to create link\n");
                        return NULL;
                }
-                printbuf_init(&l_ptr->print_buf, pb, LINK_LOG_BUF_SIZE);
+                tipc_printbuf_init(&l_ptr->print_buf, pb, LINK_LOG_BUF_SIZE);
        }
-        k_signal((Handler)link_start, (unsigned long)l_ptr);
+        tipc_k_signal((Handler)tipc_link_start, (unsigned long)l_ptr);
-        dbg("link_create(): tolerance = %u,cont intv = %u, abort_limit = %u\n",
+        dbg("tipc_link_create(): tolerance = %u,cont intv = %u, abort_limit = %u\n",
            l_ptr->tolerance, l_ptr->continuity_interval, l_ptr->abort_limit);
        
        return l_ptr;
 }
 /** 
- * link_delete - delete a link
+ * tipc_link_delete - delete a link
 * @l_ptr: pointer to link
 * 
- * Note: 'net_lock' is write_locked, bearer is locked.
+ * Note: 'tipc_net_lock' is write_locked, bearer is locked.
 * This routine must not grab the node lock until after link timer cancellation
 * to avoid a potential deadlock situation.  
 */
-void link_delete(struct link *l_ptr)
+void tipc_link_delete(struct link *l_ptr)
 {
        if (!l_ptr) {
                err("Attempt to delete non-existent link\n");
                return;
        }
-        dbg("link_delete()\n");
+        dbg("tipc_link_delete()\n");
        k_cancel_timer(&l_ptr->timer);
        
-        node_lock(l_ptr->owner);
+        tipc_node_lock(l_ptr->owner);
-        link_reset(l_ptr);
+        tipc_link_reset(l_ptr);
-        node_detach_link(l_ptr->owner, l_ptr);
+        tipc_node_detach_link(l_ptr->owner, l_ptr);
-        link_stop(l_ptr);
+        tipc_link_stop(l_ptr);
        list_del_init(&l_ptr->link_list);
        if (LINK_LOG_BUF_SIZE)
                kfree(l_ptr->print_buf.buf);
-        node_unlock(l_ptr->owner);
+        tipc_node_unlock(l_ptr->owner);
        k_term_timer(&l_ptr->timer);
        kfree(l_ptr);
 }
-void link_start(struct link *l_ptr)
+void tipc_link_start(struct link *l_ptr)
 {
-        dbg("link_start %x\n", l_ptr);
+        dbg("tipc_link_start %x\n", l_ptr);
        link_state_event(l_ptr, STARTING_EVT);
 }
@@ -535,8 +535,8 @@ static int link_schedule_port(struct link *l_ptr, u32 origport, u32 sz)
 {
        struct port *p_ptr;
-        spin_lock_bh(&port_list_lock);
+        spin_lock_bh(&tipc_port_list_lock);
-        p_ptr = port_lock(origport);
+        p_ptr = tipc_port_lock(origport);
        if (p_ptr) {
                if (!p_ptr->wakeup)
                        goto exit;
@@ -548,13 +548,13 @@ static int link_schedule_port(struct link *l_ptr, u32 origport, u32 sz)
                list_add_tail(&p_ptr->wait_list, &l_ptr->waiting_ports);
                l_ptr->stats.link_congs++;
 exit:
-                port_unlock(p_ptr);
+                tipc_port_unlock(p_ptr);
        }
-        spin_unlock_bh(&port_list_lock);
+        spin_unlock_bh(&tipc_port_list_lock);
        return -ELINKCONG;
 }
-void link_wakeup_ports(struct link *l_ptr, int all)
+void tipc_link_wakeup_ports(struct link *l_ptr, int all)
 {
        struct port *p_ptr;
        struct port *temp_p_ptr;
@@ -564,7 +564,7 @@ void link_wakeup_ports(struct link *l_ptr, int all)
                win = 100000;
        if (win <= 0)
                return;
-        if (!spin_trylock_bh(&port_list_lock))
+        if (!spin_trylock_bh(&tipc_port_list_lock))
                return;
        if (link_congested(l_ptr))
                goto exit;
@@ -583,7 +583,7 @@ void link_wakeup_ports(struct link *l_ptr, int all)
        }
 exit:
-        spin_unlock_bh(&port_list_lock);
+        spin_unlock_bh(&tipc_port_list_lock);
 }
 /** 
@@ -606,11 +606,11 @@ static void link_release_outqueue(struct link *l_ptr)
 }
 /**
- * link_reset_fragments - purge link's inbound message fragments queue
+ * tipc_link_reset_fragments - purge link's inbound message fragments queue
 * @l_ptr: pointer to link
 */
-void link_reset_fragments(struct link *l_ptr)
+void tipc_link_reset_fragments(struct link *l_ptr)
 {
        struct sk_buff *buf = l_ptr->defragm_buf;
        struct sk_buff *next;
@@ -624,11 +624,11 @@ void link_reset_fragments(struct link *l_ptr)
 }
 /** 
- * link_stop - purge all inbound and outbound messages associated with link
+ * tipc_link_stop - purge all inbound and outbound messages associated with link
 * @l_ptr: pointer to link
 */
-void link_stop(struct link *l_ptr)
+void tipc_link_stop(struct link *l_ptr)
 {
        struct sk_buff *buf;
        struct sk_buff *next;
@@ -647,7 +647,7 @@ void link_stop(struct link *l_ptr)
                buf = next;
        }
-        link_reset_fragments(l_ptr);
+        tipc_link_reset_fragments(l_ptr);
        buf_discard(l_ptr->proto_msg_queue);
        l_ptr->proto_msg_queue = NULL;
@@ -677,7 +677,7 @@ static void link_send_event(void (*fcn)(u32 a, char *n, int up),
        ev->up = up;
        ev->fcn = fcn;
        memcpy(ev->name, l_ptr->name, TIPC_MAX_LINK_NAME);
-        k_signal((Handler)link_recv_event, (unsigned long)ev);
+        tipc_k_signal((Handler)link_recv_event, (unsigned long)ev);
 }
 #else
@@ -686,7 +686,7 @@ static void link_send_event(void (*fcn)(u32 a, char *n, int up),
 #endif
-void link_reset(struct link *l_ptr)
+void tipc_link_reset(struct link *l_ptr)
 {
        struct sk_buff *buf;
        u32 prev_state = l_ptr->state;
@@ -706,13 +706,13 @@ void link_reset(struct link *l_ptr)
        if ((prev_state == RESET_UNKNOWN) || (prev_state == RESET_RESET))
                return;
-        node_link_down(l_ptr->owner, l_ptr);
+        tipc_node_link_down(l_ptr->owner, l_ptr);
-        bearer_remove_dest(l_ptr->b_ptr, l_ptr->addr);
+        tipc_bearer_remove_dest(l_ptr->b_ptr, l_ptr->addr);
 #if 0
-        tipc_printf(CONS, "\nReset link <%s>\n", l_ptr->name);
+        tipc_printf(TIPC_CONS, "\nReset link <%s>\n", l_ptr->name);
        dbg_link_dump();
 #endif
-        if (node_has_active_links(l_ptr->owner) &&
+        if (tipc_node_has_active_links(l_ptr->owner) &&
            l_ptr->owner->permit_changeover) {
                l_ptr->reset_checkpoint = checkpoint;
                l_ptr->exp_msg_count = START_CHANGEOVER;
@@ -730,7 +730,7 @@ void link_reset(struct link *l_ptr)
                buf = next;
        }
        if (!list_empty(&l_ptr->waiting_ports))
-                link_wakeup_ports(l_ptr, 1);
+                tipc_link_wakeup_ports(l_ptr, 1);
        l_ptr->retransm_queue_head = 0;
        l_ptr->retransm_queue_size = 0;
@@ -747,20 +747,20 @@ void link_reset(struct link *l_ptr)
        l_ptr->stale_count = 0;
        link_reset_statistics(l_ptr);
-        link_send_event(cfg_link_event, l_ptr, 0);
+        link_send_event(tipc_cfg_link_event, l_ptr, 0);
        if (!in_own_cluster(l_ptr->addr))
-                link_send_event(disc_link_event, l_ptr, 0);
+                link_send_event(tipc_disc_link_event, l_ptr, 0);
 }
 static void link_activate(struct link *l_ptr)
 {
        l_ptr->next_in_no = 1;
-        node_link_up(l_ptr->owner, l_ptr);
+        tipc_node_link_up(l_ptr->owner, l_ptr);
-        bearer_add_dest(l_ptr->b_ptr, l_ptr->addr);
+        tipc_bearer_add_dest(l_ptr->b_ptr, l_ptr->addr);
-        link_send_event(cfg_link_event, l_ptr, 1);
+        link_send_event(tipc_cfg_link_event, l_ptr, 1);
        if (!in_own_cluster(l_ptr->addr))
-                link_send_event(disc_link_event, l_ptr, 1);
+                link_send_event(tipc_disc_link_event, l_ptr, 1);
 }
 /**
@@ -799,13 +799,13 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                        dbg_link("TIM ");
                        if (l_ptr->next_in_no != l_ptr->checkpoint) {
                                l_ptr->checkpoint = l_ptr->next_in_no;
-                                if (bclink_acks_missing(l_ptr->owner)) {
+                                if (tipc_bclink_acks_missing(l_ptr->owner)) {
-                                        link_send_proto_msg(l_ptr, STATE_MSG, 
+                                        tipc_link_send_proto_msg(l_ptr, STATE_MSG, 
-                                                            0, 0, 0, 0, 0);
+                                                                 0, 0, 0, 0, 0);
                                        l_ptr->fsm_msg_cnt++;
                                } else if (l_ptr->max_pkt < l_ptr->max_pkt_target) {
-                                        link_send_proto_msg(l_ptr, STATE_MSG, 
+                                        tipc_link_send_proto_msg(l_ptr, STATE_MSG, 
-                                                            1, 0, 0, 0, 0);
+                                                                 1, 0, 0, 0, 0);
                                        l_ptr->fsm_msg_cnt++;
                                }
                                link_set_timer(l_ptr, cont_intv);
@@ -814,16 +814,16 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                        dbg_link(" -> WU\n");
                        l_ptr->state = WORKING_UNKNOWN;
                        l_ptr->fsm_msg_cnt = 0;
-                        link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
+                        tipc_link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
                        l_ptr->fsm_msg_cnt++;
                        link_set_timer(l_ptr, cont_intv / 4);
                        break;
                case RESET_MSG:
                        dbg_link("RES -> RR\n");
-                        link_reset(l_ptr);
+                        tipc_link_reset(l_ptr);
                        l_ptr->state = RESET_RESET;
                        l_ptr->fsm_msg_cnt = 0;
-                        link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0);
+                        tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0);
                        l_ptr->fsm_msg_cnt++;
                        link_set_timer(l_ptr, cont_intv);
                        break;
@@ -844,10 +844,10 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                        break;
                case RESET_MSG:
                        dbg_link("RES -> RR\n");
-                        link_reset(l_ptr);
+                        tipc_link_reset(l_ptr);
                        l_ptr->state = RESET_RESET;
                        l_ptr->fsm_msg_cnt = 0;
-                        link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0);
+                        tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0);
                        l_ptr->fsm_msg_cnt++;
                        link_set_timer(l_ptr, cont_intv);
                        break;
@@ -858,9 +858,9 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                                l_ptr->state = WORKING_WORKING;
                                l_ptr->fsm_msg_cnt = 0;
                                l_ptr->checkpoint = l_ptr->next_in_no;
-                                if (bclink_acks_missing(l_ptr->owner)) {
+                                if (tipc_bclink_acks_missing(l_ptr->owner)) {
-                                        link_send_proto_msg(l_ptr, STATE_MSG,
+                                        tipc_link_send_proto_msg(l_ptr, STATE_MSG,
-                                                            0, 0, 0, 0, 0);
+                                                                 0, 0, 0, 0, 0);
                                        l_ptr->fsm_msg_cnt++;
                                }
                                link_set_timer(l_ptr, cont_intv);
@@ -868,18 +868,18 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                                dbg_link("Probing %u/%u,timer = %u ms)\n",
                                         l_ptr->fsm_msg_cnt, l_ptr->abort_limit,
                                         cont_intv / 4);
-                                link_send_proto_msg(l_ptr, STATE_MSG, 
+                                tipc_link_send_proto_msg(l_ptr, STATE_MSG, 
-                                                    1, 0, 0, 0, 0);
+                                                         1, 0, 0, 0, 0);
                                l_ptr->fsm_msg_cnt++;
                                link_set_timer(l_ptr, cont_intv / 4);
                        } else {        /* Link has failed */
                                dbg_link("-> RU (%u probes unanswered)\n",
                                         l_ptr->fsm_msg_cnt);
-                                link_reset(l_ptr);
+                                tipc_link_reset(l_ptr);
                                l_ptr->state = RESET_UNKNOWN;
                                l_ptr->fsm_msg_cnt = 0;
-                                link_send_proto_msg(l_ptr, RESET_MSG,
+                                tipc_link_send_proto_msg(l_ptr, RESET_MSG,
-                                                    0, 0, 0, 0, 0);
+                                                         0, 0, 0, 0, 0);
                                l_ptr->fsm_msg_cnt++;
                                link_set_timer(l_ptr, cont_intv);
                        }
@@ -904,7 +904,7 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                        l_ptr->state = WORKING_WORKING;
                        l_ptr->fsm_msg_cnt = 0;
                        link_activate(l_ptr);
-                        link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
+                        tipc_link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
                        l_ptr->fsm_msg_cnt++;
                        link_set_timer(l_ptr, cont_intv);
                        break;
@@ -913,7 +913,7 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                        dbg_link(" -> RR\n");
                        l_ptr->state = RESET_RESET;
                        l_ptr->fsm_msg_cnt = 0;
-                        link_send_proto_msg(l_ptr, ACTIVATE_MSG, 1, 0, 0, 0, 0);
+                        tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 1, 0, 0, 0, 0);
                        l_ptr->fsm_msg_cnt++;
                        link_set_timer(l_ptr, cont_intv);
                        break;
@@ -923,7 +923,7 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                        /* fall through */
                case TIMEOUT_EVT:
                        dbg_link("TIM \n");
-                        link_send_proto_msg(l_ptr, RESET_MSG, 0, 0, 0, 0, 0);
+                        tipc_link_send_proto_msg(l_ptr, RESET_MSG, 0, 0, 0, 0, 0);
                        l_ptr->fsm_msg_cnt++;
                        link_set_timer(l_ptr, cont_intv);
                        break;
@@ -947,7 +947,7 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                        l_ptr->state = WORKING_WORKING;
                        l_ptr->fsm_msg_cnt = 0;
                        link_activate(l_ptr);
-                        link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
+                        tipc_link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
                        l_ptr->fsm_msg_cnt++;
                        link_set_timer(l_ptr, cont_intv);
                        break;
@@ -956,7 +956,7 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                        break;
                case TIMEOUT_EVT:
                        dbg_link("TIM\n");
-                        link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0);
+                        tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0);
                        l_ptr->fsm_msg_cnt++;
                        link_set_timer(l_ptr, cont_intv);
                        dbg_link("fsm_msg_cnt %u\n", l_ptr->fsm_msg_cnt);
@@ -1023,12 +1023,12 @@ static inline void link_add_to_outqueue(struct link *l_ptr,
 }
 /* 
- * link_send_buf() is the 'full path' for messages, called from 
+ * tipc_link_send_buf() is the 'full path' for messages, called from 
 * inside TIPC when the 'fast path' in tipc_send_buf
 * has failed, and from link_send()
 */
-int link_send_buf(struct link *l_ptr, struct sk_buff *buf)
+int tipc_link_send_buf(struct link *l_ptr, struct sk_buff *buf)
 {
        struct tipc_msg *msg = buf_msg(buf);
        u32 size = msg_size(msg);
@@ -1051,7 +1051,7 @@ int link_send_buf(struct link *l_ptr, struct sk_buff *buf)
                buf_discard(buf);
                if (imp > CONN_MANAGER) {
                        warn("Resetting <%s>, send queue full", l_ptr->name);
-                        link_reset(l_ptr);
+                        tipc_link_reset(l_ptr);
                }
                return dsz;
        }
@@ -1059,21 +1059,21 @@ int link_send_buf(struct link *l_ptr, struct sk_buff *buf)
        /* Fragmentation needed ? */
        if (size > max_packet)
-                return link_send_long_buf(l_ptr, buf);
+                return tipc_link_send_long_buf(l_ptr, buf);
        /* Packet can be queued or sent: */
        if (queue_size > l_ptr->stats.max_queue_sz)
                l_ptr->stats.max_queue_sz = queue_size;
-        if (likely(!bearer_congested(l_ptr->b_ptr, l_ptr) && 
+        if (likely(!tipc_bearer_congested(l_ptr->b_ptr, l_ptr) && 
                   !link_congested(l_ptr))) {
                link_add_to_outqueue(l_ptr, buf, msg);
-                if (likely(bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr))) {
+                if (likely(tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr))) {
                        l_ptr->unacked_window = 0;
                } else {
-                        bearer_schedule(l_ptr->b_ptr, l_ptr);
+                        tipc_bearer_schedule(l_ptr->b_ptr, l_ptr);
                        l_ptr->stats.bearer_congs++;
                        l_ptr->next_out = buf;
                }
@@ -1088,7 +1088,7 @@ int link_send_buf(struct link *l_ptr, struct sk_buff *buf)
                if (l_ptr->next_out && 
                    link_bundle_buf(l_ptr, l_ptr->last_out, buf)) {
-                        bearer_resolve_congestion(l_ptr->b_ptr, l_ptr);
+                        tipc_bearer_resolve_congestion(l_ptr->b_ptr, l_ptr);
                        return dsz;
                }
@@ -1114,38 +1114,38 @@ int link_send_buf(struct link *l_ptr, struct sk_buff *buf)
        if (!l_ptr->next_out)
                l_ptr->next_out = buf;
        link_add_to_outqueue(l_ptr, buf, msg);
-        bearer_resolve_congestion(l_ptr->b_ptr, l_ptr);
+        tipc_bearer_resolve_congestion(l_ptr->b_ptr, l_ptr);
        return dsz;
 }
 /* 
- * link_send(): same as link_send_buf(), but the link to use has 
+ * tipc_link_send(): same as tipc_link_send_buf(), but the link to use has 
 * not been selected yet, and the the owner node is not locked
 * Called by TIPC internal users, e.g. the name distributor
 */
-int link_send(struct sk_buff *buf, u32 dest, u32 selector)
+int tipc_link_send(struct sk_buff *buf, u32 dest, u32 selector)
 {
        struct link *l_ptr;
        struct node *n_ptr;
        int res = -ELINKCONG;
-        read_lock_bh(&net_lock);
+        read_lock_bh(&tipc_net_lock);
-        n_ptr = node_select(dest, selector);
+        n_ptr = tipc_node_select(dest, selector);
        if (n_ptr) {
-                node_lock(n_ptr);
+                tipc_node_lock(n_ptr);
                l_ptr = n_ptr->active_links[selector & 1];
-                dbg("link_send: found link %x for dest %x\n", l_ptr, dest);
+                dbg("tipc_link_send: found link %x for dest %x\n", l_ptr, dest);
                if (l_ptr) {
-                        res = link_send_buf(l_ptr, buf);
+                        res = tipc_link_send_buf(l_ptr, buf);
                }
-                node_unlock(n_ptr);
+                tipc_node_unlock(n_ptr);
        } else {
                dbg("Attempt to send msg to unknown node:\n");
                msg_dbg(buf_msg(buf),">>>");
                buf_discard(buf);
        }
-        read_unlock_bh(&net_lock);
+        read_unlock_bh(&tipc_net_lock);
        return res;
 }
@@ -1166,14 +1166,14 @@ static inline int link_send_buf_fast(struct link *l_ptr, struct sk_buff *buf,
                if (likely(msg_size(msg) <= link_max_pkt(l_ptr))) {
                        if (likely(list_empty(&l_ptr->b_ptr->cong_links))) {
                                link_add_to_outqueue(l_ptr, buf, msg);
-                                if (likely(bearer_send(l_ptr->b_ptr, buf,
+                                if (likely(tipc_bearer_send(l_ptr->b_ptr, buf,
-                                                       &l_ptr->media_addr))) {
+                                                            &l_ptr->media_addr))) {
                                        l_ptr->unacked_window = 0;
                                        msg_dbg(msg,"SENT_FAST:");
                                        return res;
                                }
                                dbg("failed sent fast...\n");
-                                bearer_schedule(l_ptr->b_ptr, l_ptr);
+                                tipc_bearer_schedule(l_ptr->b_ptr, l_ptr);
                                l_ptr->stats.bearer_congs++;
                                l_ptr->next_out = buf;
                                return res;
@@ -1182,7 +1182,7 @@ static inline int link_send_buf_fast(struct link *l_ptr, struct sk_buff *buf,
                else
                        *used_max_pkt = link_max_pkt(l_ptr);
        }
-        return link_send_buf(l_ptr, buf);  /* All other cases */
+        return tipc_link_send_buf(l_ptr, buf);  /* All other cases */
 }
 /* 
@@ -1200,24 +1200,24 @@ int tipc_send_buf_fast(struct sk_buff *buf, u32 destnode)
        u32 dummy;
        if (destnode == tipc_own_addr)
-                return port_recv_msg(buf);
+                return tipc_port_recv_msg(buf);
-        read_lock_bh(&net_lock);
+        read_lock_bh(&tipc_net_lock);
-        n_ptr = node_select(destnode, selector);
+        n_ptr = tipc_node_select(destnode, selector);
        if (likely(n_ptr)) {
-                node_lock(n_ptr);
+                tipc_node_lock(n_ptr);
                l_ptr = n_ptr->active_links[selector];
                dbg("send_fast: buf %x selected %x, destnode = %x\n",
                    buf, l_ptr, destnode);
                if (likely(l_ptr)) {
                        res = link_send_buf_fast(l_ptr, buf, &dummy);
-                        node_unlock(n_ptr);
+                        tipc_node_unlock(n_ptr);
-                        read_unlock_bh(&net_lock);
+                        read_unlock_bh(&tipc_net_lock);
                        return res;
                }
-                node_unlock(n_ptr);
+                tipc_node_unlock(n_ptr);
        }
-        read_unlock_bh(&net_lock);
+        read_unlock_bh(&tipc_net_lock);
        res = msg_data_sz(buf_msg(buf));
        tipc_reject_msg(buf, TIPC_ERR_NO_NODE);
        return res;
@@ -1225,15 +1225,15 @@ int tipc_send_buf_fast(struct sk_buff *buf, u32 destnode)
 /* 
- * link_send_sections_fast: Entry for messages where the 
+ * tipc_link_send_sections_fast: Entry for messages where the 
 * destination processor is known and the header is complete,
 * except for total message length. 
 * Returns user data length or errno.
 */
-int link_send_sections_fast(struct port *sender, 
+int tipc_link_send_sections_fast(struct port *sender, 
-                            struct iovec const *msg_sect,
+                                 struct iovec const *msg_sect,
-                            const u32 num_sect, 
+                                 const u32 num_sect, 
-                            u32 destaddr)
+                                 u32 destaddr)
 {
        struct tipc_msg *hdr = &sender->publ.phdr;
        struct link *l_ptr;
@@ -1253,10 +1253,10 @@ again:
        res = msg_build(hdr, msg_sect, num_sect, sender->max_pkt,
                        !sender->user_port, &buf);
-        read_lock_bh(&net_lock);
+        read_lock_bh(&tipc_net_lock);
-        node = node_select(destaddr, selector);
+        node = tipc_node_select(destaddr, selector);
        if (likely(node)) {
-                node_lock(node);
+                tipc_node_lock(node);
                l_ptr = node->active_links[selector];
                if (likely(l_ptr)) {
                        if (likely(buf)) {
@@ -1265,8 +1265,8 @@ again:
                                if (unlikely(res < 0))
                                        buf_discard(buf);
 exit:
-                                node_unlock(node);
+                                tipc_node_unlock(node);
-                                read_unlock_bh(&net_lock);
+                                read_unlock_bh(&tipc_net_lock);
                                return res;
                        }
@@ -1290,8 +1290,8 @@ exit:
                         */
                        sender->max_pkt = link_max_pkt(l_ptr);
-                        node_unlock(node);
+                        tipc_node_unlock(node);
-                        read_unlock_bh(&net_lock);
+                        read_unlock_bh(&tipc_net_lock);
                        if ((msg_hdr_sz(hdr) + res) <= sender->max_pkt)
@@ -1300,17 +1300,17 @@ exit:
                        return link_send_sections_long(sender, msg_sect,
                                                       num_sect, destaddr);
                }
-                node_unlock(node);
+                tipc_node_unlock(node);
        }
-        read_unlock_bh(&net_lock);
+        read_unlock_bh(&tipc_net_lock);
        /* Couldn't find a link to the destination node */
        if (buf)
                return tipc_reject_msg(buf, TIPC_ERR_NO_NODE);
        if (res >= 0)
-                return port_reject_sections(sender, hdr, msg_sect, num_sect,
+                return tipc_port_reject_sections(sender, hdr, msg_sect, num_sect,
-                                            TIPC_ERR_NO_NODE);
+                                                 TIPC_ERR_NO_NODE);
        return res;
 }
@@ -1444,17 +1444,17 @@ error:
         * Now we have a buffer chain. Select a link and check
         * that packet size is still OK
         */
-        node = node_select(destaddr, sender->publ.ref & 1);
+        node = tipc_node_select(destaddr, sender->publ.ref & 1);
        if (likely(node)) {
-                node_lock(node);
+                tipc_node_lock(node);
                l_ptr = node->active_links[sender->publ.ref & 1];
                if (!l_ptr) {
-                        node_unlock(node);
+                        tipc_node_unlock(node);
                        goto reject;
                }
                if (link_max_pkt(l_ptr) < max_pkt) {
                        sender->max_pkt = link_max_pkt(l_ptr);
-                        node_unlock(node);
+                        tipc_node_unlock(node);
                        for (; buf_chain; buf_chain = buf) {
                                buf = buf_chain->next;
                                buf_discard(buf_chain);
@@ -1467,8 +1467,8 @@ reject:
                        buf = buf_chain->next;
                        buf_discard(buf_chain);
                }
-                return port_reject_sections(sender, hdr, msg_sect, num_sect,
+                return tipc_port_reject_sections(sender, hdr, msg_sect, num_sect,
-                                            TIPC_ERR_NO_NODE);
+                                                 TIPC_ERR_NO_NODE);
        }
        /* Append whole chain to send queue: */
@@ -1491,15 +1491,15 @@ reject:
        /* Send it, if possible: */
-        link_push_queue(l_ptr);
+        tipc_link_push_queue(l_ptr);
-        node_unlock(node);
+        tipc_node_unlock(node);
        return dsz;
 }
 /* 
- * link_push_packet: Push one unsent packet to the media
+ * tipc_link_push_packet: Push one unsent packet to the media
 */
-u32 link_push_packet(struct link *l_ptr)
+u32 tipc_link_push_packet(struct link *l_ptr)
 {
        struct sk_buff *buf = l_ptr->first_out;
        u32 r_q_size = l_ptr->retransm_queue_size;
@@ -1526,7 +1526,7 @@ u32 link_push_packet(struct link *l_ptr)
        if (r_q_size && buf && !skb_cloned(buf)) {
                msg_set_ack(buf_msg(buf), mod(l_ptr->next_in_no - 1));
                msg_set_bcast_ack(buf_msg(buf), l_ptr->owner->bclink.last_in); 
-                if (bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
+                if (tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
                        msg_dbg(buf_msg(buf), ">DEF-RETR>");
                        l_ptr->retransm_queue_head = mod(++r_q_head);
                        l_ptr->retransm_queue_size = --r_q_size;
@@ -1545,7 +1545,7 @@ u32 link_push_packet(struct link *l_ptr)
        if (buf) {
                msg_set_ack(buf_msg(buf), mod(l_ptr->next_in_no - 1));
                msg_set_bcast_ack(buf_msg(buf),l_ptr->owner->bclink.last_in); 
-                if (bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
+                if (tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
                        msg_dbg(buf_msg(buf), ">DEF-PROT>");
                        l_ptr->unacked_window = 0;
                        buf_discard(buf);
@@ -1569,7 +1569,7 @@ u32 link_push_packet(struct link *l_ptr)
                if (mod(next - first) < l_ptr->queue_limit[0]) {
                        msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
                        msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in); 
-                        if (bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
+                        if (tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
                                if (msg_user(msg) == MSG_BUNDLER)
                                        msg_set_type(msg, CLOSED_MSG);
                                msg_dbg(msg, ">PUSH-DATA>");
@@ -1589,29 +1589,29 @@ u32 link_push_packet(struct link *l_ptr)
 * push_queue(): push out the unsent messages of a link where
 *               congestion has abated. Node is locked
 */
-void link_push_queue(struct link *l_ptr)
+void tipc_link_push_queue(struct link *l_ptr)
 {
        u32 res;
-        if (bearer_congested(l_ptr->b_ptr, l_ptr))
+        if (tipc_bearer_congested(l_ptr->b_ptr, l_ptr))
                return;
        do {
-                res = link_push_packet(l_ptr);
+                res = tipc_link_push_packet(l_ptr);
        }
        while (res == TIPC_OK);
        if (res == PUSH_FAILED)
-                bearer_schedule(l_ptr->b_ptr, l_ptr);
+                tipc_bearer_schedule(l_ptr->b_ptr, l_ptr);
 }
-void link_retransmit(struct link *l_ptr, struct sk_buff *buf, 
+void tipc_link_retransmit(struct link *l_ptr, struct sk_buff *buf, 
-                     u32 retransmits)
+                          u32 retransmits)
 {
        struct tipc_msg *msg;
        dbg("Retransmitting %u in link %x\n", retransmits, l_ptr);
-        if (bearer_congested(l_ptr->b_ptr, l_ptr) && buf && !skb_cloned(buf)) {
+        if (tipc_bearer_congested(l_ptr->b_ptr, l_ptr) && buf && !skb_cloned(buf)) {
                msg_dbg(buf_msg(buf), ">NO_RETR->BCONG>");
                dbg_print_link(l_ptr, "   ");
                l_ptr->retransm_queue_head = msg_seqno(buf_msg(buf));
@@ -1622,15 +1622,15 @@ void link_retransmit(struct link *l_ptr, struct sk_buff *buf,
                msg = buf_msg(buf);
                msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
                msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in); 
-                if (bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
+                if (tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
                        /* Catch if retransmissions fail repeatedly: */
                        if (l_ptr->last_retransmitted == msg_seqno(msg)) {
                                if (++l_ptr->stale_count > 100) {
-                                        msg_print(CONS, buf_msg(buf), ">RETR>");
+                                        tipc_msg_print(TIPC_CONS, buf_msg(buf), ">RETR>");
                                        info("...Retransmitted %u times\n",
                                             l_ptr->stale_count);
-                                        link_print(l_ptr, CONS, "Resetting Link\n");;
+                                        link_print(l_ptr, TIPC_CONS, "Resetting Link\n");;
-                                        link_reset(l_ptr);
+                                        tipc_link_reset(l_ptr);
                                        break;
                                }
                        } else {
@@ -1643,7 +1643,7 @@ void link_retransmit(struct link *l_ptr, struct sk_buff *buf,
                        retransmits--;
                        l_ptr->stats.retransmitted++;
                } else {
-                        bearer_schedule(l_ptr->b_ptr, l_ptr);
+                        tipc_bearer_schedule(l_ptr->b_ptr, l_ptr);
                        l_ptr->stats.bearer_congs++;
                        l_ptr->retransm_queue_head = msg_seqno(buf_msg(buf));
                        l_ptr->retransm_queue_size = retransmits;
@@ -1663,9 +1663,9 @@ static void link_recv_non_seq(struct sk_buff *buf)
        struct tipc_msg *msg = buf_msg(buf);
        if (msg_user(msg) ==  LINK_CONFIG)
-                disc_recv_msg(buf);
+                tipc_disc_recv_msg(buf);
        else
-                bclink_recv_pkt(buf);
+                tipc_bclink_recv_pkt(buf);
 }
 /** 
@@ -1692,7 +1692,7 @@ static struct sk_buff *link_insert_deferred_queue(struct link *l_ptr,
 void tipc_recv_msg(struct sk_buff *head, struct tipc_bearer *tb_ptr)
 {
-        read_lock_bh(&net_lock);
+        read_lock_bh(&tipc_net_lock);
        while (head) {
                struct bearer *b_ptr;
                struct node *n_ptr;
@@ -1720,22 +1720,22 @@ void tipc_recv_msg(struct sk_buff *head, struct tipc_bearer *tb_ptr)
                        link_recv_non_seq(buf);
                        continue;
                }
-                n_ptr = node_find(msg_prevnode(msg));
+                n_ptr = tipc_node_find(msg_prevnode(msg));
                if (unlikely(!n_ptr))
                        goto cont;
-                node_lock(n_ptr);
+                tipc_node_lock(n_ptr);
                l_ptr = n_ptr->links[b_ptr->identity];
                if (unlikely(!l_ptr)) {
-                        node_unlock(n_ptr);
+                        tipc_node_unlock(n_ptr);
                        goto cont;
                }
                /* 
                 * Release acked messages 
                 */
                if (less(n_ptr->bclink.acked, msg_bcast_ack(msg))) {
-                        if (node_is_up(n_ptr) && n_ptr->bclink.supported)
+                        if (tipc_node_is_up(n_ptr) && n_ptr->bclink.supported)
-                                bclink_acknowledge(n_ptr, msg_bcast_ack(msg));
+                                tipc_bclink_acknowledge(n_ptr, msg_bcast_ack(msg));
                }
                crs = l_ptr->first_out;
@@ -1752,12 +1752,12 @@ void tipc_recv_msg(struct sk_buff *head, struct tipc_bearer *tb_ptr)
                        l_ptr->out_queue_size -= released;
                }
                if (unlikely(l_ptr->next_out))
-                        link_push_queue(l_ptr);
+                        tipc_link_push_queue(l_ptr);
                if (unlikely(!list_empty(&l_ptr->waiting_ports)))
-                        link_wakeup_ports(l_ptr, 0);
+                        tipc_link_wakeup_ports(l_ptr, 0);
                if (unlikely(++l_ptr->unacked_window >= TIPC_MIN_LINK_WIN)) {
                        l_ptr->stats.sent_acks++;
-                        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);
                }
 protocol_check:
@@ -1770,8 +1770,8 @@ protocol_check:
                                if (likely(msg_is_dest(msg, tipc_own_addr))) {
 deliver:
                                        if (likely(msg_isdata(msg))) {
-                                                node_unlock(n_ptr);
+                                                tipc_node_unlock(n_ptr);
-                                                port_recv_msg(buf);
+                                                tipc_port_recv_msg(buf);
                                                continue;
                                        }
                                        switch (msg_user(msg)) {
@@ -1779,34 +1779,32 @@ deliver:
                                                l_ptr->stats.recv_bundles++;
                                                l_ptr->stats.recv_bundled += 
                                                        msg_msgcnt(msg);
-                                                node_unlock(n_ptr);
+                                                tipc_node_unlock(n_ptr);
-                                                link_recv_bundle(buf);
+                                                tipc_link_recv_bundle(buf);
                                                continue;
                                        case ROUTE_DISTRIBUTOR:
-                                                node_unlock(n_ptr);
+                                                tipc_node_unlock(n_ptr);
-                                                cluster_recv_routing_table(buf);
+                                                tipc_cltr_recv_routing_table(buf);
                                                continue;
                                        case NAME_DISTRIBUTOR:
-                                                node_unlock(n_ptr);
+                                                tipc_node_unlock(n_ptr);
-                                                named_recv(buf);
+                                                tipc_named_recv(buf);
                                                continue;
                                        case CONN_MANAGER:
-                                                node_unlock(n_ptr);
+                                                tipc_node_unlock(n_ptr);
-                                                port_recv_proto_msg(buf);
+                                                tipc_port_recv_proto_msg(buf);
                                                continue;
                                        case MSG_FRAGMENTER:
                                                l_ptr->stats.recv_fragments++;
-                                                if (link_recv_fragment(
+                                                if (tipc_link_recv_fragment(&l_ptr->defragm_buf, 
-                                                        &l_ptr->defragm_buf, 
+                                                                            &buf, &msg)) {
-                                                        &buf, &msg)) {
                                                        l_ptr->stats.recv_fragmented++;
                                                        goto deliver;
                                                }
                                                break;
                                        case CHANGEOVER_PROTOCOL:
                                                type = msg_type(msg);
-                                                if (link_recv_changeover_msg(
+                                                if (link_recv_changeover_msg(&l_ptr, &buf)) {
-                                                        &l_ptr, &buf)) {
                                                        msg = buf_msg(buf);
                                                        seq_no = msg_seqno(msg);
                                                        TIPC_SKB_CB(buf)->handle 
@@ -1818,20 +1816,20 @@ deliver:
                                                break;
                                        }
                                }
-                                node_unlock(n_ptr);
+                                tipc_node_unlock(n_ptr);
-                                net_route_msg(buf);
+                                tipc_net_route_msg(buf);
                                continue;
                        }
                        link_handle_out_of_seq_msg(l_ptr, buf);
                        head = link_insert_deferred_queue(l_ptr, head);
-                        node_unlock(n_ptr);
+                        tipc_node_unlock(n_ptr);
                        continue;
                }
                if (msg_user(msg) == LINK_PROTOCOL) {
                        link_recv_proto_msg(l_ptr, buf);
                        head = link_insert_deferred_queue(l_ptr, head);
-                        node_unlock(n_ptr);
+                        tipc_node_unlock(n_ptr);
                        continue;
                }
                msg_dbg(msg,"NSEQ<REC<");
@@ -1842,14 +1840,14 @@ deliver:
                        msg_dbg(msg,"RECV-REINS:");
                        buf->next = head;
                        head = buf;
-                        node_unlock(n_ptr);
+                        tipc_node_unlock(n_ptr);
                        continue;
                }
-                node_unlock(n_ptr);
+                tipc_node_unlock(n_ptr);
 cont:
                buf_discard(buf);
        }
-        read_unlock_bh(&net_lock);
+        read_unlock_bh(&tipc_net_lock);
 }
 /* 
@@ -1858,9 +1856,9 @@ cont:
 * Returns the increase of the queue length,i.e. 0 or 1
 */
-u32 link_defer_pkt(struct sk_buff **head,
+u32 tipc_link_defer_pkt(struct sk_buff **head,
-                   struct sk_buff **tail,
+                        struct sk_buff **tail,
-                   struct sk_buff *buf)
+                        struct sk_buff *buf)
 {
        struct sk_buff *prev = 0;
        struct sk_buff *crs = *head;
@@ -1939,12 +1937,12 @@ static void link_handle_out_of_seq_msg(struct link *l_ptr,
                return;
        }
-        if (link_defer_pkt(&l_ptr->oldest_deferred_in,
+        if (tipc_link_defer_pkt(&l_ptr->oldest_deferred_in,
-                           &l_ptr->newest_deferred_in, buf)) {
+                                &l_ptr->newest_deferred_in, buf)) {
                l_ptr->deferred_inqueue_sz++;
                l_ptr->stats.deferred_recv++;
                if ((l_ptr->deferred_inqueue_sz % 16) == 1)
-                        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);
        } else
                l_ptr->stats.duplicates++;
 }
@@ -1952,8 +1950,8 @@ static void link_handle_out_of_seq_msg(struct link *l_ptr,
 /*
 * Send protocol message to the other endpoint.
 */
-void link_send_proto_msg(struct link *l_ptr, u32 msg_typ, int probe_msg,
+void tipc_link_send_proto_msg(struct link *l_ptr, u32 msg_typ, int probe_msg,
-                         u32 gap, u32 tolerance, u32 priority, u32 ack_mtu)
+                              u32 gap, u32 tolerance, u32 priority, u32 ack_mtu)
 {
        struct sk_buff *buf = 0;
        struct tipc_msg *msg = l_ptr->pmsg;
@@ -1964,12 +1962,12 @@ void link_send_proto_msg(struct link *l_ptr, u32 msg_typ, int probe_msg,
        msg_set_type(msg, msg_typ);
        msg_set_net_plane(msg, l_ptr->b_ptr->net_plane);
        msg_set_bcast_ack(msg, mod(l_ptr->owner->bclink.last_in)); 
-        msg_set_last_bcast(msg, bclink_get_last_sent());
+        msg_set_last_bcast(msg, tipc_bclink_get_last_sent());
        if (msg_typ == STATE_MSG) {
                u32 next_sent = mod(l_ptr->next_out_no);
-                if (!link_is_up(l_ptr))
+                if (!tipc_link_is_up(l_ptr))
                        return;
                if (l_ptr->next_out)
                        next_sent = msg_seqno(buf_msg(l_ptr->next_out));
@@ -2013,7 +2011,7 @@ void link_send_proto_msg(struct link *l_ptr, u32 msg_typ, int probe_msg,
                msg_set_max_pkt(msg, l_ptr->max_pkt_target);
        }
-        if (node_has_redundant_links(l_ptr->owner)) {
+        if (tipc_node_has_redundant_links(l_ptr->owner)) {
                msg_set_redundant_link(msg);
        } else {
                msg_clear_redundant_link(msg);
@@ -2026,7 +2024,7 @@ void link_send_proto_msg(struct link *l_ptr, u32 msg_typ, int probe_msg,
        /* Congestion? */
-        if (bearer_congested(l_ptr->b_ptr, l_ptr)) {
+        if (tipc_bearer_congested(l_ptr->b_ptr, l_ptr)) {
                if (!l_ptr->proto_msg_queue) {
                        l_ptr->proto_msg_queue =
                                buf_acquire(sizeof(l_ptr->proto_msg));
@@ -2050,14 +2048,14 @@ void link_send_proto_msg(struct link *l_ptr, u32 msg_typ, int probe_msg,
        memcpy(buf->data, (unchar *)msg, sizeof(l_ptr->proto_msg));
        msg_set_size(buf_msg(buf), msg_size);
-        if (bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
+        if (tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
                l_ptr->unacked_window = 0;
                buf_discard(buf);
                return;
        }
        /* New congestion */
-        bearer_schedule(l_ptr->b_ptr, l_ptr);
+        tipc_bearer_schedule(l_ptr->b_ptr, l_ptr);
        l_ptr->proto_msg_queue = buf;
        l_ptr->stats.bearer_congs++;
 }
@@ -2131,7 +2129,7 @@ static void link_recv_proto_msg(struct link *l_ptr, struct sk_buff *buf)
                l_ptr->peer_bearer_id = msg_bearer_id(msg);
                /* Synchronize broadcast sequence numbers */
-                if (!node_has_redundant_links(l_ptr->owner)) {
+                if (!tipc_node_has_redundant_links(l_ptr->owner)) {
                        l_ptr->owner->bclink.last_in = mod(msg_last_bcast(msg));
                }
                break;
@@ -2145,7 +2143,7 @@ static void link_recv_proto_msg(struct link *l_ptr, struct sk_buff *buf)
                        warn("Changing prio <%s>: %u->%u\n",
                             l_ptr->name, l_ptr->priority, msg_linkprio(msg));
                        l_ptr->priority = msg_linkprio(msg);
-                        link_reset(l_ptr); /* Enforce change to take effect */
+                        tipc_link_reset(l_ptr); /* Enforce change to take effect */
                        break;
                }
                link_state_event(l_ptr, TRAFFIC_MSG_EVT);
@@ -2176,17 +2174,17 @@ static void link_recv_proto_msg(struct link *l_ptr, struct sk_buff *buf)
                /* Protocol message before retransmits, reduce loss risk */
-                bclink_check_gap(l_ptr->owner, msg_last_bcast(msg));
+                tipc_bclink_check_gap(l_ptr->owner, msg_last_bcast(msg));
                if (rec_gap || (msg_probe(msg))) {
-                        link_send_proto_msg(l_ptr, STATE_MSG,
+                        tipc_link_send_proto_msg(l_ptr, STATE_MSG,
-                                            0, rec_gap, 0, 0, max_pkt_ack);
+                                                 0, rec_gap, 0, 0, max_pkt_ack);
                }
                if (msg_seq_gap(msg)) {
                        msg_dbg(msg, "With Gap:");
                        l_ptr->stats.recv_nacks++;
-                        link_retransmit(l_ptr, l_ptr->first_out,
+                        tipc_link_retransmit(l_ptr, l_ptr->first_out,
-                                        msg_seq_gap(msg));
+                                             msg_seq_gap(msg));
                }
                break;
        default:
@@ -2198,20 +2196,20 @@ exit:
 /*
- * link_tunnel(): Send one message via a link belonging to 
+ * tipc_link_tunnel(): Send one message via a link belonging to 
 * another bearer. Owner node is locked.
 */
-void link_tunnel(struct link *l_ptr, 
+void tipc_link_tunnel(struct link *l_ptr, 
-            struct tipc_msg *tunnel_hdr, 
+                      struct tipc_msg *tunnel_hdr, 
-            struct tipc_msg  *msg,
+                      struct tipc_msg  *msg,
-            u32 selector)
+                      u32 selector)
 {
        struct link *tunnel;
        struct sk_buff *buf;
        u32 length = msg_size(msg);
        tunnel = l_ptr->owner->active_links[selector & 1];
-        if (!link_is_up(tunnel))
+        if (!tipc_link_is_up(tunnel))
                return;
        msg_set_size(tunnel_hdr, length + INT_H_SIZE);
        buf = buf_acquire(length + INT_H_SIZE);
@@ -2222,7 +2220,7 @@ void link_tunnel(struct link *l_ptr,
        dbg("%c->%c:", l_ptr->b_ptr->net_plane, tunnel->b_ptr->net_plane);
        msg_dbg(buf_msg(buf), ">SEND>");
        assert(tunnel);
-        link_send_buf(tunnel, buf);
+        tipc_link_send_buf(tunnel, buf);
 }
@@ -2232,12 +2230,12 @@ void link_tunnel(struct link *l_ptr,
 *               Owner node is locked.
 */
-void link_changeover(struct link *l_ptr)
+void tipc_link_changeover(struct link *l_ptr)
 {
        u32 msgcount = l_ptr->out_queue_size;
        struct sk_buff *crs = l_ptr->first_out;
        struct link *tunnel = l_ptr->owner->active_links[0];
-        int split_bundles = node_has_redundant_links(l_ptr->owner);
+        int split_bundles = tipc_node_has_redundant_links(l_ptr->owner);
        struct tipc_msg tunnel_hdr;
        if (!tunnel)
@@ -2261,7 +2259,7 @@ void link_changeover(struct link *l_ptr)
                        dbg("%c->%c:", l_ptr->b_ptr->net_plane,
                            tunnel->b_ptr->net_plane);
                        msg_dbg(&tunnel_hdr, "EMPTY>SEND>");
-                        link_send_buf(tunnel, buf);
+                        tipc_link_send_buf(tunnel, buf);
                } else {
                        warn("Memory squeeze; link changeover failed\n");
                }
@@ -2277,20 +2275,20 @@ void link_changeover(struct link *l_ptr)
                        while (msgcount--) {
                                msg_set_seqno(m,msg_seqno(msg));
-                                link_tunnel(l_ptr, &tunnel_hdr, m,
+                                tipc_link_tunnel(l_ptr, &tunnel_hdr, m,
-                                            msg_link_selector(m));
+                                                 msg_link_selector(m));
                                pos += align(msg_size(m));
                                m = (struct tipc_msg *)pos;
                        }
                } else {
-                        link_tunnel(l_ptr, &tunnel_hdr, msg,
+                        tipc_link_tunnel(l_ptr, &tunnel_hdr, msg,
-                                    msg_link_selector(msg));
+                                         msg_link_selector(msg));
                }
                crs = crs->next;
        }
 }
-void link_send_duplicate(struct link *l_ptr, struct link *tunnel)
+void tipc_link_send_duplicate(struct link *l_ptr, struct link *tunnel)
 {
        struct sk_buff *iter;
        struct tipc_msg tunnel_hdr;
@@ -2320,8 +2318,8 @@ void link_send_duplicate(struct link *l_ptr, struct link *tunnel)
                dbg("%c->%c:", l_ptr->b_ptr->net_plane,
                    tunnel->b_ptr->net_plane);
                msg_dbg(buf_msg(outbuf), ">SEND>");
-                link_send_buf(tunnel, outbuf);
+                tipc_link_send_buf(tunnel, outbuf);
-                if (!link_is_up(l_ptr))
+                if (!tipc_link_is_up(l_ptr))
                        return;
                iter = iter->next;
        }
@@ -2393,9 +2391,9 @@ static int link_recv_changeover_msg(struct link **l_ptr,
        /* First original message ?: */
-        if (link_is_up(dest_link)) {
+        if (tipc_link_is_up(dest_link)) {
                msg_dbg(tunnel_msg, "UP/FIRST/<REC<");
-                link_reset(dest_link);
+                tipc_link_reset(dest_link);
                dest_link->exp_msg_count = msg_count;
                if (!msg_count)
                        goto exit;
@@ -2436,7 +2434,7 @@ exit:
 /*
 *  Bundler functionality:
 */
-void link_recv_bundle(struct sk_buff *buf)
+void tipc_link_recv_bundle(struct sk_buff *buf)
 {
        u32 msgcount = msg_msgcnt(buf_msg(buf));
        u32 pos = INT_H_SIZE;
@@ -2456,7 +2454,7 @@ void link_recv_bundle(struct sk_buff *buf)
                };
                pos += align(msg_size(buf_msg(obuf)));
                msg_dbg(buf_msg(obuf), "     /");
-                net_route_msg(obuf);
+                tipc_net_route_msg(obuf);
        }
        buf_discard(buf);
 }
@@ -2467,11 +2465,11 @@ void link_recv_bundle(struct sk_buff *buf)
 /* 
- * link_send_long_buf: Entry for buffers needing fragmentation.
+ * tipc_link_send_long_buf: Entry for buffers needing fragmentation.
 * The buffer is complete, inclusive total message length. 
 * Returns user data length.
 */
-int link_send_long_buf(struct link *l_ptr, struct sk_buff *buf)
+int tipc_link_send_long_buf(struct link *l_ptr, struct sk_buff *buf)
 {
        struct tipc_msg *inmsg = buf_msg(buf);
        struct tipc_msg fragm_hdr;
@@ -2521,8 +2519,8 @@ int link_send_long_buf(struct link *l_ptr, struct sk_buff *buf)
                /*  Send queued messages first, if any: */
                l_ptr->stats.sent_fragments++;
-                link_send_buf(l_ptr, fragm);
+                tipc_link_send_buf(l_ptr, fragm);
-                if (!link_is_up(l_ptr))
+                if (!tipc_link_is_up(l_ptr))
                        return dsz;
                msg_set_fragm_no(&fragm_hdr, ++fragm_no);
                rest -= fragm_sz;
@@ -2582,11 +2580,11 @@ static inline void incr_timer_cnt(struct sk_buff *buf)
 }
 /* 
- * link_recv_fragment(): Called with node lock on. Returns 
+ * tipc_link_recv_fragment(): Called with node lock on. Returns 
 * the reassembled buffer if message is complete.
 */
-int link_recv_fragment(struct sk_buff **pending, struct sk_buff **fb, 
+int tipc_link_recv_fragment(struct sk_buff **pending, struct sk_buff **fb, 
-                       struct tipc_msg **m)
+                            struct tipc_msg **m)
 {
        struct sk_buff *prev = 0;
        struct sk_buff *fbuf = *fb;
@@ -2714,7 +2712,7 @@ static void link_set_supervision_props(struct link *l_ptr, u32 tolerance)
 }
-void link_set_queue_limits(struct link *l_ptr, u32 window)
+void tipc_link_set_queue_limits(struct link *l_ptr, u32 window)
 {
        /* Data messages from this node, inclusive FIRST_FRAGM */
        l_ptr->queue_limit[DATA_LOW] = window;
@@ -2739,7 +2737,7 @@ void link_set_queue_limits(struct link *l_ptr, u32 window)
 * @name - ptr to link name string
 * @node - ptr to area to be filled with ptr to associated node
 * 
- * Caller must hold 'net_lock' to ensure node and bearer are not deleted;
+ * Caller must hold 'tipc_net_lock' to ensure node and bearer are not deleted;
 * this also prevents link deletion.
 * 
 * Returns pointer to link (or 0 if invalid link name).
@@ -2754,11 +2752,11 @@ static struct link *link_find_link(const char *name, struct node **node)
        if (!link_name_validate(name, &link_name_parts))
                return 0;
-        b_ptr = bearer_find_interface(link_name_parts.if_local);
+        b_ptr = tipc_bearer_find_interface(link_name_parts.if_local);
        if (!b_ptr)
                return 0;
-        *node = node_find(link_name_parts.addr_peer); 
+        *node = tipc_node_find(link_name_parts.addr_peer); 
        if (!*node)
                return 0;
@@ -2769,8 +2767,8 @@ static struct link *link_find_link(const char *name, struct node **node)
        return l_ptr;
 }
-struct sk_buff *link_cmd_config(const void *req_tlv_area, int req_tlv_space, 
+struct sk_buff *tipc_link_cmd_config(const void *req_tlv_area, int req_tlv_space, 
-                                u16 cmd)
+                                     u16 cmd)
 {
        struct tipc_link_config *args;
        u32 new_value;
@@ -2779,61 +2777,62 @@ struct sk_buff *link_cmd_config(const void *req_tlv_area, int req_tlv_space,
        int res;
        if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_CONFIG))
-                return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
+                return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
        args = (struct tipc_link_config *)TLV_DATA(req_tlv_area);
        new_value = ntohl(args->value);
-        if (!strcmp(args->name, bc_link_name)) {
+        if (!strcmp(args->name, tipc_bclink_name)) {
                if ((cmd == TIPC_CMD_SET_LINK_WINDOW) &&
-                    (bclink_set_queue_limits(new_value) == 0))
+                    (tipc_bclink_set_queue_limits(new_value) == 0))
-                        return cfg_reply_none();
+                        return tipc_cfg_reply_none();
-                return cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
+                return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
-                                              " (cannot change setting on broadcast link)");
+                                                   " (cannot change setting on broadcast link)");
        }
-        read_lock_bh(&net_lock);
+        read_lock_bh(&tipc_net_lock);
        l_ptr = link_find_link(args->name, &node); 
        if (!l_ptr) {
-                read_unlock_bh(&net_lock);
+                read_unlock_bh(&tipc_net_lock);
-                return cfg_reply_error_string("link not found");
+                return tipc_cfg_reply_error_string("link not found");
        }
-        node_lock(node);
+        tipc_node_lock(node);
        res = -EINVAL;
        switch (cmd) {
        case TIPC_CMD_SET_LINK_TOL: 
                if ((new_value >= TIPC_MIN_LINK_TOL) && 
                    (new_value <= TIPC_MAX_LINK_TOL)) {
                        link_set_supervision_props(l_ptr, new_value);
-                        link_send_proto_msg(l_ptr, STATE_MSG, 
+                        tipc_link_send_proto_msg(l_ptr, STATE_MSG, 
-                                            0, 0, new_value, 0, 0);
+                                                 0, 0, new_value, 0, 0);
                        res = TIPC_OK;
                }
                break;
        case TIPC_CMD_SET_LINK_PRI: 
-                if (new_value < TIPC_NUM_LINK_PRI) {
+                if ((new_value >= TIPC_MIN_LINK_PRI) &&
+                    (new_value <= TIPC_MAX_LINK_PRI)) {
                        l_ptr->priority = new_value;
-                        link_send_proto_msg(l_ptr, STATE_MSG, 
+                        tipc_link_send_proto_msg(l_ptr, STATE_MSG, 
-                                            0, 0, 0, new_value, 0);
+                                                 0, 0, 0, new_value, 0);
                        res = TIPC_OK;
                }
                break;
        case TIPC_CMD_SET_LINK_WINDOW: 
                if ((new_value >= TIPC_MIN_LINK_WIN) && 
                    (new_value <= TIPC_MAX_LINK_WIN)) {
-                        link_set_queue_limits(l_ptr, new_value);
+                        tipc_link_set_queue_limits(l_ptr, new_value);
                        res = TIPC_OK;
                }
                break;
        }
-        node_unlock(node);
+        tipc_node_unlock(node);
-        read_unlock_bh(&net_lock);
+        read_unlock_bh(&tipc_net_lock);
        if (res)
-                return cfg_reply_error_string("cannot change link setting");
+                return tipc_cfg_reply_error_string("cannot change link setting");
-        return cfg_reply_none();
+        return tipc_cfg_reply_none();
 }
 /**
@@ -2848,34 +2847,34 @@ static void link_reset_statistics(struct link *l_ptr)
        l_ptr->stats.recv_info = l_ptr->next_in_no;
 }
-struct sk_buff *link_cmd_reset_stats(const void *req_tlv_area, int req_tlv_space)
+struct sk_buff *tipc_link_cmd_reset_stats(const void *req_tlv_area, int req_tlv_space)
 {
        char *link_name;
        struct link *l_ptr; 
        struct node *node;
        if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_NAME))
-                return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
+                return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
        link_name = (char *)TLV_DATA(req_tlv_area);
-        if (!strcmp(link_name, bc_link_name)) {
+        if (!strcmp(link_name, tipc_bclink_name)) {
-                if (bclink_reset_stats())
+                if (tipc_bclink_reset_stats())
-                        return cfg_reply_error_string("link not found");
+                        return tipc_cfg_reply_error_string("link not found");
-                return cfg_reply_none();
+                return tipc_cfg_reply_none();
        }
-        read_lock_bh(&net_lock);
+        read_lock_bh(&tipc_net_lock);
        l_ptr = link_find_link(link_name, &node); 
        if (!l_ptr) {
-                read_unlock_bh(&net_lock);
+                read_unlock_bh(&tipc_net_lock);
-                return cfg_reply_error_string("link not found");
+                return tipc_cfg_reply_error_string("link not found");
        }
-        node_lock(node);
+        tipc_node_lock(node);
        link_reset_statistics(l_ptr);
-        node_unlock(node);
+        tipc_node_unlock(node);
-        read_unlock_bh(&net_lock);
+        read_unlock_bh(&tipc_net_lock);
-        return cfg_reply_none();
+        return tipc_cfg_reply_none();
 }
 /**
@@ -2888,7 +2887,7 @@ static u32 percent(u32 count, u32 total)
 }
 /**
- * link_stats - print link statistics
+ * tipc_link_stats - print link statistics
 * @name: link name
 * @buf: print buffer area
 * @buf_size: size of print buffer area
@@ -2896,7 +2895,7 @@ static u32 percent(u32 count, u32 total)
 * Returns length of print buffer data string (or 0 if error)
 */
-static int link_stats(const char *name, char *buf, const u32 buf_size)
+static int tipc_link_stats(const char *name, char *buf, const u32 buf_size)
 {
        struct print_buf pb;
        struct link *l_ptr; 
@@ -2904,22 +2903,22 @@ static int link_stats(const char *name, char *buf, const u32 buf_size)
        char *status;
        u32 profile_total = 0;
-        if (!strcmp(name, bc_link_name))
+        if (!strcmp(name, tipc_bclink_name))
-                return bclink_stats(buf, buf_size);
+                return tipc_bclink_stats(buf, buf_size);
-        printbuf_init(&pb, buf, buf_size);
+        tipc_printbuf_init(&pb, buf, buf_size);
-        read_lock_bh(&net_lock);
+        read_lock_bh(&tipc_net_lock);
        l_ptr = link_find_link(name, &node); 
        if (!l_ptr) {
-                read_unlock_bh(&net_lock);
+                read_unlock_bh(&tipc_net_lock);
                return 0;
        }
-        node_lock(node);
+        tipc_node_lock(node);
-        if (link_is_active(l_ptr))
+        if (tipc_link_is_active(l_ptr))
                status = "ACTIVE";
-        else if (link_is_up(l_ptr))
+        else if (tipc_link_is_up(l_ptr))
                status = "STANDBY";
        else
                status = "DEFUNCT";
@@ -2975,33 +2974,33 @@ static int link_stats(const char *name, char *buf, const u32 buf_size)
                    ? (l_ptr->stats.accu_queue_sz / l_ptr->stats.queue_sz_counts)
                    : 0);
-        node_unlock(node);
+        tipc_node_unlock(node);
-        read_unlock_bh(&net_lock);
+        read_unlock_bh(&tipc_net_lock);
-        return printbuf_validate(&pb);
+        return tipc_printbuf_validate(&pb);
 }
 #define MAX_LINK_STATS_INFO 2000
-struct sk_buff *link_cmd_show_stats(const void *req_tlv_area, int req_tlv_space)
+struct sk_buff *tipc_link_cmd_show_stats(const void *req_tlv_area, int req_tlv_space)
 {
        struct sk_buff *buf;
        struct tlv_desc *rep_tlv;
        int str_len;
        if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_NAME))
-                return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
+                return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
-        buf = cfg_reply_alloc(TLV_SPACE(MAX_LINK_STATS_INFO));
+        buf = tipc_cfg_reply_alloc(TLV_SPACE(MAX_LINK_STATS_INFO));
        if (!buf)
                return NULL;
        rep_tlv = (struct tlv_desc *)buf->data;
-        str_len = link_stats((char *)TLV_DATA(req_tlv_area),
+        str_len = tipc_link_stats((char *)TLV_DATA(req_tlv_area),
-                             (char *)TLV_DATA(rep_tlv), MAX_LINK_STATS_INFO);
+                                  (char *)TLV_DATA(rep_tlv), MAX_LINK_STATS_INFO);
        if (!str_len) {
                buf_discard(buf);
-                return cfg_reply_error_string("link not found");
+                return tipc_cfg_reply_error_string("link not found");
        }
        skb_put(buf, TLV_SPACE(str_len));
@@ -3020,20 +3019,20 @@ int link_control(const char *name, u32 op, u32 val)
        u32 a;
        a = link_name2addr(name, &bearer_id);
-        read_lock_bh(&net_lock);
+        read_lock_bh(&tipc_net_lock);
-        node = node_find(a);
+        node = tipc_node_find(a);
        if (node) {
-                node_lock(node);
+                tipc_node_lock(node);
                l_ptr = node->links[bearer_id];
                if (l_ptr) {
                        if (op == TIPC_REMOVE_LINK) {
                                struct bearer *b_ptr = l_ptr->b_ptr;
                                spin_lock_bh(&b_ptr->publ.lock);
-                                link_delete(l_ptr);
+                                tipc_link_delete(l_ptr);
                                spin_unlock_bh(&b_ptr->publ.lock);
                        }
                        if (op == TIPC_CMD_BLOCK_LINK) {
-                                link_reset(l_ptr);
+                                tipc_link_reset(l_ptr);
                                l_ptr->blocked = 1;
                        }
                        if (op == TIPC_CMD_UNBLOCK_LINK) {
@@ -3041,22 +3040,22 @@ int link_control(const char *name, u32 op, u32 val)
                        }
                        res = TIPC_OK;
                }
-                node_unlock(node);
+                tipc_node_unlock(node);
        }
-        read_unlock_bh(&net_lock);
+        read_unlock_bh(&tipc_net_lock);
        return res;
 }
 #endif
 /**
- * link_get_max_pkt - get maximum packet size to use when sending to destination
+ * tipc_link_get_max_pkt - get maximum packet size to use when sending to destination
 * @dest: network address of destination node
 * @selector: used to select from set of active links
 * 
 * If no active link can be found, uses default maximum packet size.
 */
-u32 link_get_max_pkt(u32 dest, u32 selector)
+u32 tipc_link_get_max_pkt(u32 dest, u32 selector)
 {
        struct node *n_ptr;
        struct link *l_ptr;
@@ -3065,16 +3064,16 @@ u32 link_get_max_pkt(u32 dest, u32 selector)
        if (dest == tipc_own_addr)
                return MAX_MSG_SIZE;
-        read_lock_bh(&net_lock);        
+        read_lock_bh(&tipc_net_lock);        
-        n_ptr = node_select(dest, selector);
+        n_ptr = tipc_node_select(dest, selector);
        if (n_ptr) {
-                node_lock(n_ptr);
+                tipc_node_lock(n_ptr);
                l_ptr = n_ptr->active_links[selector & 1];
                if (l_ptr)
                        res = link_max_pkt(l_ptr);
-                node_unlock(n_ptr);
+                tipc_node_unlock(n_ptr);
        }
-        read_unlock_bh(&net_lock);       
+        read_unlock_bh(&tipc_net_lock);       
        return res;
 }
diff --git a/net/tipc/link.h b/net/tipc/link.h
index c2553f073757..2d3c157f707d 100644
--- a/net/tipc/link.h
+++ b/net/tipc/link.h
@@ -221,44 +221,43 @@ struct link {
 struct port;
-struct link *link_create(struct bearer *b_ptr, const u32 peer,
+struct link *tipc_link_create(struct bearer *b_ptr, const u32 peer,
-                         const struct tipc_media_addr *media_addr);
+                              const struct tipc_media_addr *media_addr);
-void link_delete(struct link *l_ptr);
+void tipc_link_delete(struct link *l_ptr);
-void link_changeover(struct link *l_ptr);
+void tipc_link_changeover(struct link *l_ptr);
-void link_send_duplicate(struct link *l_ptr, struct link *dest);
+void tipc_link_send_duplicate(struct link *l_ptr, struct link *dest);
-void link_reset_fragments(struct link *l_ptr);
+void tipc_link_reset_fragments(struct link *l_ptr);
-int link_is_up(struct link *l_ptr);
+int tipc_link_is_up(struct link *l_ptr);
-int link_is_active(struct link *l_ptr);
+int tipc_link_is_active(struct link *l_ptr);
-void link_start(struct link *l_ptr);
+void tipc_link_start(struct link *l_ptr);
-u32 link_push_packet(struct link *l_ptr);
+u32 tipc_link_push_packet(struct link *l_ptr);
-void link_stop(struct link *l_ptr);
+void tipc_link_stop(struct link *l_ptr);
-struct sk_buff *link_cmd_config(const void *req_tlv_area, int req_tlv_space, u16 cmd);
+struct sk_buff *tipc_link_cmd_config(const void *req_tlv_area, int req_tlv_space, u16 cmd);
-struct sk_buff *link_cmd_show_stats(const void *req_tlv_area, int req_tlv_space);
+struct sk_buff *tipc_link_cmd_show_stats(const void *req_tlv_area, int req_tlv_space);
-struct sk_buff *link_cmd_reset_stats(const void *req_tlv_area, int req_tlv_space);
+struct sk_buff *tipc_link_cmd_reset_stats(const void *req_tlv_area, int req_tlv_space);
-void link_reset(struct link *l_ptr);
+void tipc_link_reset(struct link *l_ptr);
-int link_send(struct sk_buff *buf, u32 dest, u32 selector);
+int tipc_link_send(struct sk_buff *buf, u32 dest, u32 selector);
-int link_send_buf(struct link *l_ptr, struct sk_buff *buf);
+int tipc_link_send_buf(struct link *l_ptr, struct sk_buff *buf);
-u32 link_get_max_pkt(u32 dest,u32 selector);
+u32 tipc_link_get_max_pkt(u32 dest,u32 selector);
-int link_send_sections_fast(struct port* sender, 
+int tipc_link_send_sections_fast(struct port* sender, 
-                            struct iovec const *msg_sect,
+                                 struct iovec const *msg_sect,
-                            const u32 num_sect, 
+                                 const u32 num_sect, 
-                            u32 destnode);
+                                 u32 destnode);
+int tipc_link_send_long_buf(struct link *l_ptr, struct sk_buff *buf);
-int link_send_long_buf(struct link *l_ptr, struct sk_buff *buf);
+void tipc_link_tunnel(struct link *l_ptr, struct tipc_msg *tnl_hdr,
-void link_tunnel(struct link *l_ptr, struct tipc_msg *tnl_hdr,
+                      struct tipc_msg *msg, u32 selector);
-                 struct tipc_msg *msg, u32 selector);
+void tipc_link_recv_bundle(struct sk_buff *buf);
-void link_recv_bundle(struct sk_buff *buf);
+int  tipc_link_recv_fragment(struct sk_buff **pending,
-int  link_recv_fragment(struct sk_buff **pending,
+                             struct sk_buff **fb,
-                        struct sk_buff **fb,
+                             struct tipc_msg **msg);
-                        struct tipc_msg **msg);
+void tipc_link_send_proto_msg(struct link *l_ptr, u32 msg_typ, int prob, u32 gap, 
-void link_send_proto_msg(struct link *l_ptr, u32 msg_typ, int prob, u32 gap, 
+                              u32 tolerance, u32 priority, u32 acked_mtu);
-                         u32 tolerance, u32 priority, u32 acked_mtu);
+void tipc_link_push_queue(struct link *l_ptr);
-void link_push_queue(struct link *l_ptr);
+u32 tipc_link_defer_pkt(struct sk_buff **head, struct sk_buff **tail,
-u32 link_defer_pkt(struct sk_buff **head, struct sk_buff **tail,
                   struct sk_buff *buf);
-void link_wakeup_ports(struct link *l_ptr, int all);
+void tipc_link_wakeup_ports(struct link *l_ptr, int all);
-void link_set_queue_limits(struct link *l_ptr, u32 window);
+void tipc_link_set_queue_limits(struct link *l_ptr, u32 window);
-void link_retransmit(struct link *l_ptr, struct sk_buff *start, u32 retransmits);
+void tipc_link_retransmit(struct link *l_ptr, struct sk_buff *start, u32 retransmits);
 /*
 * Link sequence number manipulation routines (uses modulo 2**16 arithmetic)
diff --git a/net/tipc/msg.c b/net/tipc/msg.c
index 03dbc55cb04c..3bd345a344e5 100644
--- a/net/tipc/msg.c
+++ b/net/tipc/msg.c
@@ -41,18 +41,7 @@
 #include "bearer.h"
-void msg_set_media_addr(struct tipc_msg *m, struct tipc_media_addr *a)
+void tipc_msg_print(struct print_buf *buf, struct tipc_msg *msg, const char *str)
-{
-        memcpy(&((int *)m)[5], a, sizeof(*a));
-}
-void msg_get_media_addr(struct tipc_msg *m, struct tipc_media_addr *a)
-{
-        memcpy(a, &((int*)m)[5], sizeof(*a));
-}
-void msg_print(struct print_buf *buf, struct tipc_msg *msg, const char *str)
 {
        u32 usr = msg_user(msg);
        tipc_printf(buf, str);
@@ -318,7 +307,7 @@ void msg_print(struct print_buf *buf, struct tipc_msg *msg, const char *str)
                tipc_printf(buf, ":REQL(%u):", msg_req_links(msg));
                tipc_printf(buf, ":DDOM(%x):", msg_dest_domain(msg));
                tipc_printf(buf, ":NETID(%u):", msg_bc_netid(msg));
-                media_addr_printf(buf, orig);
+                tipc_media_addr_printf(buf, orig);
        }
        if (msg_user(msg) == BCAST_PROTOCOL) {
                tipc_printf(buf, "BCNACK:AFTER(%u):", msg_bcgap_after(msg));
@@ -326,9 +315,9 @@ void msg_print(struct print_buf *buf, struct tipc_msg *msg, const char *str)
        }
        tipc_printf(buf, "\n");
        if ((usr == CHANGEOVER_PROTOCOL) && (msg_msgcnt(msg))) {
-                msg_print(buf,msg_get_wrapped(msg),"      /");
+                tipc_msg_print(buf,msg_get_wrapped(msg),"      /");
        }
        if ((usr == MSG_FRAGMENTER) && (msg_type(msg) == FIRST_FRAGMENT)) {
-                msg_print(buf,msg_get_wrapped(msg),"      /");
+                tipc_msg_print(buf,msg_get_wrapped(msg),"      /");
        }
 }
diff --git a/net/tipc/msg.h b/net/tipc/msg.h
index 662c81862a0c..6699aaf7bd4c 100644
--- a/net/tipc/msg.h
+++ b/net/tipc/msg.h
@@ -37,7 +37,7 @@
 #ifndef _TIPC_MSG_H
 #define _TIPC_MSG_H
-#include <net/tipc/tipc_msg.h>
+#include "core.h"
 #define TIPC_VERSION              2
 #define DATA_LOW                  TIPC_LOW_IMPORTANCE
@@ -805,14 +805,14 @@ static inline int msg_build(struct tipc_msg *hdr,
        return -EFAULT;
 }
+static inline void msg_set_media_addr(struct tipc_msg *m, struct tipc_media_addr *a)
+{
+        memcpy(&((int *)m)[5], a, sizeof(*a));
+}
-struct tipc_media_addr;
+static inline void msg_get_media_addr(struct tipc_msg *m, struct tipc_media_addr *a)
+{
-extern void msg_set_media_addr(struct tipc_msg *m,
+        memcpy(a, &((int*)m)[5], sizeof(*a));
-                               struct tipc_media_addr *a);
+}
-extern void msg_get_media_addr(struct tipc_msg *m,
-                               struct tipc_media_addr *a);
 #endif
diff --git a/net/tipc/name_distr.c b/net/tipc/name_distr.c
index 41cbaf1a4a73..830f90999041 100644
--- a/net/tipc/name_distr.c
+++ b/net/tipc/name_distr.c
@@ -114,10 +114,10 @@ static struct sk_buff *named_prepare_buf(u32 type, u32 size, u32 dest)
 }
 /**
- * named_publish - tell other nodes about a new publication by this node
+ * tipc_named_publish - tell other nodes about a new publication by this node
 */
-void named_publish(struct publication *publ)
+void tipc_named_publish(struct publication *publ)
 {
        struct sk_buff *buf;
        struct distr_item *item;
@@ -133,15 +133,15 @@ void named_publish(struct publication *publ)
        item = (struct distr_item *)msg_data(buf_msg(buf));
        publ_to_item(item, publ);
-        dbg("named_withdraw: broadcasting publish msg\n");
+        dbg("tipc_named_withdraw: broadcasting publish msg\n");
-        cluster_broadcast(buf);
+        tipc_cltr_broadcast(buf);
 }
 /**
- * named_withdraw - tell other nodes about a withdrawn publication by this node
+ * tipc_named_withdraw - tell other nodes about a withdrawn publication by this node
 */
-void named_withdraw(struct publication *publ)
+void tipc_named_withdraw(struct publication *publ)
 {
        struct sk_buff *buf;
        struct distr_item *item;
@@ -157,15 +157,15 @@ void named_withdraw(struct publication *publ)
        item = (struct distr_item *)msg_data(buf_msg(buf));
        publ_to_item(item, publ);
-        dbg("named_withdraw: broadcasting withdraw msg\n");
+        dbg("tipc_named_withdraw: broadcasting withdraw msg\n");
-        cluster_broadcast(buf);
+        tipc_cltr_broadcast(buf);
 }
 /**
- * named_node_up - tell specified node about all publications by this node
+ * tipc_named_node_up - tell specified node about all publications by this node
 */
-void named_node_up(unsigned long node)
+void tipc_named_node_up(unsigned long node)
 {
        struct publication *publ;
        struct distr_item *item = 0;
@@ -175,7 +175,7 @@ void named_node_up(unsigned long node)
        u32 max_item_buf;
        assert(in_own_cluster(node));
-        read_lock_bh(&nametbl_lock); 
+        read_lock_bh(&tipc_nametbl_lock); 
        max_item_buf = TIPC_MAX_USER_MSG_SIZE / ITEM_SIZE;
        max_item_buf *= ITEM_SIZE;
        rest = publ_cnt * ITEM_SIZE;
@@ -196,15 +196,15 @@ void named_node_up(unsigned long node)
                left -= ITEM_SIZE;
                if (!left) {
                        msg_set_link_selector(buf_msg(buf), node);
-                        dbg("named_node_up: sending publish msg to "
+                        dbg("tipc_named_node_up: sending publish msg to "
                            "<%u.%u.%u>\n", tipc_zone(node), 
                            tipc_cluster(node), tipc_node(node));
-                        link_send(buf, node, node);
+                        tipc_link_send(buf, node, node);
                        buf = 0;
                }
        }
 exit:
-        read_unlock_bh(&nametbl_lock); 
+        read_unlock_bh(&tipc_nametbl_lock); 
 }
 /**
@@ -221,73 +221,73 @@ exit:
 static void node_is_down(struct publication *publ)
 {
        struct publication *p;
-        write_lock_bh(&nametbl_lock);
+        write_lock_bh(&tipc_nametbl_lock);
        dbg("node_is_down: withdrawing %u, %u, %u\n", 
            publ->type, publ->lower, publ->upper);
        publ->key += 1222345;
-        p = nametbl_remove_publ(publ->type, publ->lower, 
+        p = tipc_nametbl_remove_publ(publ->type, publ->lower, 
-                                publ->node, publ->ref, publ->key);
+                                     publ->node, publ->ref, publ->key);
        assert(p == publ);
-        write_unlock_bh(&nametbl_lock);
+        write_unlock_bh(&tipc_nametbl_lock);
        if (publ)
                kfree(publ);
 }
 /**
- * named_recv - process name table update message sent by another node
+ * tipc_named_recv - process name table update message sent by another node
 */
-void named_recv(struct sk_buff *buf)
+void tipc_named_recv(struct sk_buff *buf)
 {
        struct publication *publ;
        struct tipc_msg *msg = buf_msg(buf);
        struct distr_item *item = (struct distr_item *)msg_data(msg);
        u32 count = msg_data_sz(msg) / ITEM_SIZE;
-        write_lock_bh(&nametbl_lock); 
+        write_lock_bh(&tipc_nametbl_lock); 
        while (count--) {
                if (msg_type(msg) == PUBLICATION) {
-                        dbg("named_recv: got publication for %u, %u, %u\n", 
+                        dbg("tipc_named_recv: got publication for %u, %u, %u\n", 
                            ntohl(item->type), ntohl(item->lower),
                            ntohl(item->upper));
-                        publ = nametbl_insert_publ(ntohl(item->type), 
+                        publ = tipc_nametbl_insert_publ(ntohl(item->type), 
-                                                   ntohl(item->lower),
+                                                        ntohl(item->lower),
-                                                   ntohl(item->upper),
+                                                        ntohl(item->upper),
-                                                   TIPC_CLUSTER_SCOPE,
+                                                        TIPC_CLUSTER_SCOPE,
-                                                   msg_orignode(msg), 
+                                                        msg_orignode(msg), 
-                                                   ntohl(item->ref),
+                                                        ntohl(item->ref),
-                                                   ntohl(item->key));
+                                                        ntohl(item->key));
                        if (publ) {
-                                nodesub_subscribe(&publ->subscr, 
+                                tipc_nodesub_subscribe(&publ->subscr, 
-                                                  msg_orignode(msg), 
+                                                       msg_orignode(msg), 
-                                                  publ,
+                                                       publ,
-                                                  (net_ev_handler)node_is_down);
+                                                       (net_ev_handler)node_is_down);
                        }
                } else if (msg_type(msg) == WITHDRAWAL) {
-                        dbg("named_recv: got withdrawl for %u, %u, %u\n", 
+                        dbg("tipc_named_recv: got withdrawl for %u, %u, %u\n", 
                            ntohl(item->type), ntohl(item->lower),
                            ntohl(item->upper));
-                        publ = nametbl_remove_publ(ntohl(item->type),
+                        publ = tipc_nametbl_remove_publ(ntohl(item->type),
-                                                   ntohl(item->lower),
+                                                        ntohl(item->lower),
-                                                   msg_orignode(msg),
+                                                        msg_orignode(msg),
-                                                   ntohl(item->ref),
+                                                        ntohl(item->ref),
-                                                   ntohl(item->key));
+                                                        ntohl(item->key));
                        if (publ) {
-                                nodesub_unsubscribe(&publ->subscr);
+                                tipc_nodesub_unsubscribe(&publ->subscr);
                                kfree(publ);
                        }
                } else {
-                        warn("named_recv: unknown msg\n");
+                        warn("tipc_named_recv: unknown msg\n");
                }
                item++;
        }
-        write_unlock_bh(&nametbl_lock); 
+        write_unlock_bh(&tipc_nametbl_lock); 
        buf_discard(buf);
 }
 /**
- * named_reinit - re-initialize local publication list
+ * tipc_named_reinit - re-initialize local publication list
 * 
 * This routine is called whenever TIPC networking is (re)enabled.
 * All existing publications by this node that have "cluster" or "zone" scope
@@ -295,15 +295,15 @@ void named_recv(struct sk_buff *buf)
 * (If the node's address is unchanged, the update loop terminates immediately.)
 */
-void named_reinit(void)
+void tipc_named_reinit(void)
 {
        struct publication *publ;
-        write_lock_bh(&nametbl_lock); 
+        write_lock_bh(&tipc_nametbl_lock); 
        list_for_each_entry(publ, &publ_root, local_list) {
                if (publ->node == tipc_own_addr)
                        break;
                publ->node = tipc_own_addr;
        }
-        write_unlock_bh(&nametbl_lock); 
+        write_unlock_bh(&tipc_nametbl_lock); 
 }
diff --git a/net/tipc/name_distr.h b/net/tipc/name_distr.h
index a04bdeac84ea..843da0172f4e 100644
--- a/net/tipc/name_distr.h
+++ b/net/tipc/name_distr.h
@@ -39,10 +39,10 @@
 #include "name_table.h"
-void named_publish(struct publication *publ);
+void tipc_named_publish(struct publication *publ);
-void named_withdraw(struct publication *publ);
+void tipc_named_withdraw(struct publication *publ);
-void named_node_up(unsigned long node);
+void tipc_named_node_up(unsigned long node);
-void named_recv(struct sk_buff *buf);
+void tipc_named_recv(struct sk_buff *buf);
-void named_reinit(void);
+void tipc_named_reinit(void);
 #endif
diff --git a/net/tipc/name_table.c b/net/tipc/name_table.c
index 972c83eb83b4..3f4b23bd08f7 100644
--- a/net/tipc/name_table.c
+++ b/net/tipc/name_table.c
@@ -99,9 +99,9 @@ struct name_table {
        u32 local_publ_count;
 };
-struct name_table table = { NULL } ;
+static struct name_table table = { NULL } ;
 static atomic_t rsv_publ_ok = ATOMIC_INIT(0);
-rwlock_t nametbl_lock = RW_LOCK_UNLOCKED;
+rwlock_t tipc_nametbl_lock = RW_LOCK_UNLOCKED;
 static inline int hash(int x)
@@ -139,10 +139,10 @@ static struct publication *publ_create(u32 type, u32 lower, u32 upper,
 }
 /**
- * subseq_alloc - allocate a specified number of sub-sequence structures
+ * tipc_subseq_alloc - allocate a specified number of sub-sequence structures
 */
-struct sub_seq *subseq_alloc(u32 cnt)
+struct sub_seq *tipc_subseq_alloc(u32 cnt)
 {
        u32 sz = cnt * sizeof(struct sub_seq);
        struct sub_seq *sseq = (struct sub_seq *)kmalloc(sz, GFP_ATOMIC);
@@ -153,16 +153,16 @@ struct sub_seq *subseq_alloc(u32 cnt)
 }
 /**
- * nameseq_create - create a name sequence structure for the specified 'type'
+ * tipc_nameseq_create - create a name sequence structure for the specified 'type'
 * 
 * Allocates a single sub-sequence structure and sets it to all 0's.
 */
-struct name_seq *nameseq_create(u32 type, struct hlist_head *seq_head)
+struct name_seq *tipc_nameseq_create(u32 type, struct hlist_head *seq_head)
 {
        struct name_seq *nseq = 
                (struct name_seq *)kmalloc(sizeof(*nseq), GFP_ATOMIC);
-        struct sub_seq *sseq = subseq_alloc(1);
+        struct sub_seq *sseq = tipc_subseq_alloc(1);
        if (!nseq || !sseq) {
                warn("Memory squeeze; failed to create name sequence\n");
@@ -175,7 +175,7 @@ struct name_seq *nameseq_create(u32 type, struct hlist_head *seq_head)
        nseq->lock = SPIN_LOCK_UNLOCKED;
        nseq->type = type;
        nseq->sseqs = sseq;
-        dbg("nameseq_create() nseq = %x type %u, ssseqs %x, ff: %u\n",
+        dbg("tipc_nameseq_create() nseq = %x type %u, ssseqs %x, ff: %u\n",
            nseq, type, nseq->sseqs, nseq->first_free);
        nseq->alloc = 1;
        INIT_HLIST_NODE(&nseq->ns_list);
@@ -240,10 +240,10 @@ static u32 nameseq_locate_subseq(struct name_seq *nseq, u32 instance)
 }
 /**
- * nameseq_insert_publ - 
+ * tipc_nameseq_insert_publ - 
 */
-struct publication *nameseq_insert_publ(struct name_seq *nseq,
+struct publication *tipc_nameseq_insert_publ(struct name_seq *nseq,
                                        u32 type, u32 lower, u32 upper,
                                        u32 scope, u32 node, u32 port, u32 key)
 {
@@ -285,7 +285,7 @@ struct publication *nameseq_insert_publ(struct name_seq *nseq,
                if (nseq->first_free == nseq->alloc) {
                        struct sub_seq *sseqs = nseq->sseqs;
-                        nseq->sseqs = subseq_alloc(nseq->alloc * 2);
+                        nseq->sseqs = tipc_subseq_alloc(nseq->alloc * 2);
                        if (nseq->sseqs != NULL) {
                                memcpy(nseq->sseqs, sseqs,
                                       nseq->alloc * sizeof (struct sub_seq));
@@ -354,23 +354,23 @@ struct publication *nameseq_insert_publ(struct name_seq *nseq,
         */
        list_for_each_entry_safe(s, st, &nseq->subscriptions, nameseq_list) {
                dbg("calling report_overlap()\n");
-                subscr_report_overlap(s,
+                tipc_subscr_report_overlap(s,
-                                      publ->lower,
+                                           publ->lower,
-                                      publ->upper,
+                                           publ->upper,
-                                      TIPC_PUBLISHED,
+                                           TIPC_PUBLISHED,
-                                      publ->ref, 
+                                           publ->ref, 
-                                      publ->node,
+                                           publ->node,
-                                      created_subseq);
+                                           created_subseq);
        }
        return publ;
 }
 /**
- * nameseq_remove_publ -
+ * tipc_nameseq_remove_publ -
 */
-struct publication *nameseq_remove_publ(struct name_seq *nseq, u32 inst,
+struct publication *tipc_nameseq_remove_publ(struct name_seq *nseq, u32 inst,
-                                        u32 node, u32 ref, u32 key)
+                                             u32 node, u32 ref, u32 key)
 {
        struct publication *publ;
        struct publication *prev;
@@ -470,24 +470,24 @@ struct publication *nameseq_remove_publ(struct name_seq *nseq, u32 inst,
         * Any subscriptions waiting ? 
         */
        list_for_each_entry_safe(s, st, &nseq->subscriptions, nameseq_list) {
-                subscr_report_overlap(s,
+                tipc_subscr_report_overlap(s,
-                                      publ->lower,
+                                           publ->lower,
-                                      publ->upper,
+                                           publ->upper,
-                                      TIPC_WITHDRAWN, 
+                                           TIPC_WITHDRAWN, 
-                                      publ->ref, 
+                                           publ->ref, 
-                                      publ->node,
+                                           publ->node,
-                                      removed_subseq);
+                                           removed_subseq);
        }
        return publ;
 }
 /**
- * nameseq_subscribe: attach a subscription, and issue
+ * tipc_nameseq_subscribe: attach a subscription, and issue
 * the prescribed number of events if there is any sub-
 * sequence overlapping with the requested sequence
 */
-void nameseq_subscribe(struct name_seq *nseq, struct subscription *s)
+void tipc_nameseq_subscribe(struct name_seq *nseq, struct subscription *s)
 {
        struct sub_seq *sseq = nseq->sseqs;
@@ -498,18 +498,18 @@ void nameseq_subscribe(struct name_seq *nseq, struct subscription *s)
        while (sseq != &nseq->sseqs[nseq->first_free]) {
                struct publication *zl = sseq->zone_list;
-                if (zl && subscr_overlap(s,sseq->lower,sseq->upper)) {
+                if (zl && tipc_subscr_overlap(s,sseq->lower,sseq->upper)) {
                        struct publication *crs = zl;
                        int must_report = 1;
                        do {
-                                subscr_report_overlap(s, 
+                                tipc_subscr_report_overlap(s, 
-                                                       sseq->lower, 
+                                                           sseq->lower, 
-                                                       sseq->upper,
+                                                           sseq->upper,
-                                                       TIPC_PUBLISHED,
+                                                           TIPC_PUBLISHED,
-                                                       crs->ref,
+                                                           crs->ref,
-                                                       crs->node,
+                                                           crs->node,
-                                                       must_report);
+                                                           must_report);
                                must_report = 0;
                                crs = crs->zone_list_next;
                        } while (crs != zl);
@@ -538,8 +538,8 @@ static struct name_seq *nametbl_find_seq(u32 type)
        return 0;
 };
-struct publication *nametbl_insert_publ(u32 type, u32 lower, u32 upper,
+struct publication *tipc_nametbl_insert_publ(u32 type, u32 lower, u32 upper,
-                    u32 scope, u32 node, u32 port, u32 key)
+                                             u32 scope, u32 node, u32 port, u32 key)
 {
        struct name_seq *seq = nametbl_find_seq(type);
@@ -552,19 +552,19 @@ struct publication *nametbl_insert_publ(u32 type, u32 lower, u32 upper,
        dbg("Publishing <%u,%u,%u> from %x\n", type, lower, upper, node);
        if (!seq) {
-                seq = nameseq_create(type, &table.types[hash(type)]);
+                seq = tipc_nameseq_create(type, &table.types[hash(type)]);
-                dbg("nametbl_insert_publ: created %x\n", seq);
+                dbg("tipc_nametbl_insert_publ: created %x\n", seq);
        }
        if (!seq)
                return 0;
        assert(seq->type == type);
-        return nameseq_insert_publ(seq, type, lower, upper,
+        return tipc_nameseq_insert_publ(seq, type, lower, upper,
-                                   scope, node, port, key);
+                                        scope, node, port, key);
 }
-struct publication *nametbl_remove_publ(u32 type, u32 lower, 
+struct publication *tipc_nametbl_remove_publ(u32 type, u32 lower, 
-                                        u32 node, u32 ref, u32 key)
+                                             u32 node, u32 ref, u32 key)
 {
        struct publication *publ;
        struct name_seq *seq = nametbl_find_seq(type);
@@ -573,7 +573,7 @@ struct publication *nametbl_remove_publ(u32 type, u32 lower,
                return 0;
        dbg("Withdrawing <%u,%u> from %x\n", type, lower, node);
-        publ = nameseq_remove_publ(seq, lower, node, ref, key);
+        publ = tipc_nameseq_remove_publ(seq, lower, node, ref, key);
        if (!seq->first_free && list_empty(&seq->subscriptions)) {
                hlist_del_init(&seq->ns_list);
@@ -584,14 +584,14 @@ struct publication *nametbl_remove_publ(u32 type, u32 lower,
 }
 /*
- * nametbl_translate(): Translate tipc_name -> tipc_portid.
+ * tipc_nametbl_translate(): Translate tipc_name -> tipc_portid.
 *                      Very time-critical.
 *
 * Note: on entry 'destnode' is the search domain used during translation;
 *       on exit it passes back the node address of the matching port (if any)
 */
-u32 nametbl_translate(u32 type, u32 instance, u32 *destnode)
+u32 tipc_nametbl_translate(u32 type, u32 instance, u32 *destnode)
 {
        struct sub_seq *sseq;
        struct publication *publ = 0;
@@ -601,7 +601,7 @@ u32 nametbl_translate(u32 type, u32 instance, u32 *destnode)
        if (!in_scope(*destnode, tipc_own_addr))
                return 0;
-        read_lock_bh(&nametbl_lock);
+        read_lock_bh(&tipc_nametbl_lock);
        seq = nametbl_find_seq(type);
        if (unlikely(!seq))
                goto not_found;
@@ -619,7 +619,7 @@ found:
                        ref = publ->ref;
                        *destnode = publ->node;
                        spin_unlock_bh(&seq->lock);
-                        read_unlock_bh(&nametbl_lock);
+                        read_unlock_bh(&tipc_nametbl_lock);
                        return ref;
                }
                publ = sseq->cluster_list;
@@ -657,12 +657,12 @@ found:
        spin_unlock_bh(&seq->lock);
 not_found:
        *destnode = 0;
-        read_unlock_bh(&nametbl_lock);
+        read_unlock_bh(&tipc_nametbl_lock);
        return 0;
 }
 /**
- * nametbl_mc_translate - find multicast destinations
+ * tipc_nametbl_mc_translate - find multicast destinations
 * 
 * Creates list of all local ports that overlap the given multicast address;
 * also determines if any off-node ports overlap.
@@ -674,15 +674,15 @@ not_found:
 * Returns non-zero if any off-node ports overlap
 */
-int nametbl_mc_translate(u32 type, u32 lower, u32 upper, u32 limit,
+int tipc_nametbl_mc_translate(u32 type, u32 lower, u32 upper, u32 limit,
-                         struct port_list *dports)
+                              struct port_list *dports)
 {
        struct name_seq *seq;
        struct sub_seq *sseq;
        struct sub_seq *sseq_stop;
        int res = 0;
-        read_lock_bh(&nametbl_lock);
+        read_lock_bh(&tipc_nametbl_lock);
        seq = nametbl_find_seq(type);
        if (!seq)
                goto exit;
@@ -700,7 +700,7 @@ int nametbl_mc_translate(u32 type, u32 lower, u32 upper, u32 limit,
                if (publ && (publ->scope <= limit))
                        do {
                                if (publ->node == tipc_own_addr)
-                                        port_list_add(dports, publ->ref);
+                                        tipc_port_list_add(dports, publ->ref);
                                else
                                        res = 1;
                                publ = publ->cluster_list_next;
@@ -709,15 +709,15 @@ int nametbl_mc_translate(u32 type, u32 lower, u32 upper, u32 limit,
        spin_unlock_bh(&seq->lock);
 exit:
-        read_unlock_bh(&nametbl_lock);
+        read_unlock_bh(&tipc_nametbl_lock);
        return res;
 }
 /**
- * nametbl_publish_rsv - publish port name using a reserved name type
+ * tipc_nametbl_publish_rsv - publish port name using a reserved name type
 */
-int nametbl_publish_rsv(u32 ref, unsigned int scope, 
+int tipc_nametbl_publish_rsv(u32 ref, unsigned int scope, 
                        struct tipc_name_seq const *seq)
 {
        int res;
@@ -729,10 +729,10 @@ int nametbl_publish_rsv(u32 ref, unsigned int scope,
 }
 /**
- * nametbl_publish - add name publication to network name tables
+ * tipc_nametbl_publish - add name publication to network name tables
 */
-struct publication *nametbl_publish(u32 type, u32 lower, u32 upper, 
+struct publication *tipc_nametbl_publish(u32 type, u32 lower, u32 upper, 
                                    u32 scope, u32 port_ref, u32 key)
 {
        struct publication *publ;
@@ -748,77 +748,77 @@ struct publication *nametbl_publish(u32 type, u32 lower, u32 upper,
                return 0;
        }
-        write_lock_bh(&nametbl_lock);
+        write_lock_bh(&tipc_nametbl_lock);
        table.local_publ_count++;
-        publ = nametbl_insert_publ(type, lower, upper, scope,
+        publ = tipc_nametbl_insert_publ(type, lower, upper, scope,
                                   tipc_own_addr, port_ref, key);
        if (publ && (scope != TIPC_NODE_SCOPE)) {
-                named_publish(publ);
+                tipc_named_publish(publ);
        }
-        write_unlock_bh(&nametbl_lock);
+        write_unlock_bh(&tipc_nametbl_lock);
        return publ;
 }
 /**
- * nametbl_withdraw - withdraw name publication from network name tables
+ * tipc_nametbl_withdraw - withdraw name publication from network name tables
 */
-int nametbl_withdraw(u32 type, u32 lower, u32 ref, u32 key)
+int tipc_nametbl_withdraw(u32 type, u32 lower, u32 ref, u32 key)
 {
        struct publication *publ;
-        dbg("nametbl_withdraw:<%d,%d,%d>\n", type, lower, key);
+        dbg("tipc_nametbl_withdraw:<%d,%d,%d>\n", type, lower, key);
-        write_lock_bh(&nametbl_lock);
+        write_lock_bh(&tipc_nametbl_lock);
-        publ = nametbl_remove_publ(type, lower, tipc_own_addr, ref, key);
+        publ = tipc_nametbl_remove_publ(type, lower, tipc_own_addr, ref, key);
        if (publ) {
                table.local_publ_count--;
                if (publ->scope != TIPC_NODE_SCOPE)
-                        named_withdraw(publ);
+                        tipc_named_withdraw(publ);
-                write_unlock_bh(&nametbl_lock);
+                write_unlock_bh(&tipc_nametbl_lock);
                list_del_init(&publ->pport_list);
                kfree(publ);
                return 1;
        }
-        write_unlock_bh(&nametbl_lock);
+        write_unlock_bh(&tipc_nametbl_lock);
        return 0;
 }
 /**
- * nametbl_subscribe - add a subscription object to the name table
+ * tipc_nametbl_subscribe - add a subscription object to the name table
 */
 void
-nametbl_subscribe(struct subscription *s)
+tipc_nametbl_subscribe(struct subscription *s)
 {
        u32 type = s->seq.type;
        struct name_seq *seq;
-        write_lock_bh(&nametbl_lock);
+        write_lock_bh(&tipc_nametbl_lock);
        seq = nametbl_find_seq(type);
        if (!seq) {
-                seq = nameseq_create(type, &table.types[hash(type)]);
+                seq = tipc_nameseq_create(type, &table.types[hash(type)]);
        }
        if (seq){
                spin_lock_bh(&seq->lock);
-                dbg("nametbl_subscribe:found %x for <%u,%u,%u>\n",
+                dbg("tipc_nametbl_subscribe:found %x for <%u,%u,%u>\n",
                    seq, type, s->seq.lower, s->seq.upper);
                assert(seq->type == type);
-                nameseq_subscribe(seq, s);
+                tipc_nameseq_subscribe(seq, s);
                spin_unlock_bh(&seq->lock);
        }
-        write_unlock_bh(&nametbl_lock);
+        write_unlock_bh(&tipc_nametbl_lock);
 }
 /**
- * nametbl_unsubscribe - remove a subscription object from name table
+ * tipc_nametbl_unsubscribe - remove a subscription object from name table
 */
 void
-nametbl_unsubscribe(struct subscription *s)
+tipc_nametbl_unsubscribe(struct subscription *s)
 {
        struct name_seq *seq;
-        write_lock_bh(&nametbl_lock);
+        write_lock_bh(&tipc_nametbl_lock);
        seq = nametbl_find_seq(s->seq.type);
        if (seq != NULL){
                spin_lock_bh(&seq->lock);
@@ -830,7 +830,7 @@ nametbl_unsubscribe(struct subscription *s)
                        kfree(seq);
                }
        }
-        write_unlock_bh(&nametbl_lock);
+        write_unlock_bh(&tipc_nametbl_lock);
 }
@@ -983,17 +983,17 @@ static void nametbl_list(struct print_buf *buf, u32 depth_info,
        }
 }
-void nametbl_print(struct print_buf *buf, const char *str)
+void tipc_nametbl_print(struct print_buf *buf, const char *str)
 {
        tipc_printf(buf, str);
-        read_lock_bh(&nametbl_lock);
+        read_lock_bh(&tipc_nametbl_lock);
        nametbl_list(buf, 0, 0, 0, 0);
-        read_unlock_bh(&nametbl_lock);
+        read_unlock_bh(&tipc_nametbl_lock);
 }
 #define MAX_NAME_TBL_QUERY 32768
-struct sk_buff *nametbl_get(const void *req_tlv_area, int req_tlv_space)
+struct sk_buff *tipc_nametbl_get(const void *req_tlv_area, int req_tlv_space)
 {
        struct sk_buff *buf;
        struct tipc_name_table_query *argv;
@@ -1002,20 +1002,20 @@ struct sk_buff *nametbl_get(const void *req_tlv_area, int req_tlv_space)
        int str_len;
        if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NAME_TBL_QUERY))
-                return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
+                return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
-        buf = cfg_reply_alloc(TLV_SPACE(MAX_NAME_TBL_QUERY));
+        buf = tipc_cfg_reply_alloc(TLV_SPACE(MAX_NAME_TBL_QUERY));
        if (!buf)
                return NULL;
        rep_tlv = (struct tlv_desc *)buf->data;
-        printbuf_init(&b, TLV_DATA(rep_tlv), MAX_NAME_TBL_QUERY);
+        tipc_printbuf_init(&b, TLV_DATA(rep_tlv), MAX_NAME_TBL_QUERY);
        argv = (struct tipc_name_table_query *)TLV_DATA(req_tlv_area);
-        read_lock_bh(&nametbl_lock);
+        read_lock_bh(&tipc_nametbl_lock);
        nametbl_list(&b, ntohl(argv->depth), ntohl(argv->type), 
                     ntohl(argv->lowbound), ntohl(argv->upbound));
-        read_unlock_bh(&nametbl_lock);
+        read_unlock_bh(&tipc_nametbl_lock);
-        str_len = printbuf_validate(&b);
+        str_len = tipc_printbuf_validate(&b);
        skb_put(buf, TLV_SPACE(str_len));
        TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
@@ -1023,12 +1023,12 @@ struct sk_buff *nametbl_get(const void *req_tlv_area, int req_tlv_space)
        return buf;
 }
-void nametbl_dump(void)
+void tipc_nametbl_dump(void)
 {
-        nametbl_list(CONS, 0, 0, 0, 0);
+        nametbl_list(TIPC_CONS, 0, 0, 0, 0);
 }
-int nametbl_init(void)
+int tipc_nametbl_init(void)
 {
        int array_size = sizeof(struct hlist_head) * tipc_nametbl_size;
@@ -1036,14 +1036,14 @@ int nametbl_init(void)
        if (!table.types)
                return -ENOMEM;
-        write_lock_bh(&nametbl_lock);
+        write_lock_bh(&tipc_nametbl_lock);
        memset(table.types, 0, array_size);
        table.local_publ_count = 0;
-        write_unlock_bh(&nametbl_lock);
+        write_unlock_bh(&tipc_nametbl_lock);
        return 0;
 }
-void nametbl_stop(void)
+void tipc_nametbl_stop(void)
 {
        struct hlist_head *seq_head;
        struct hlist_node *seq_node;
@@ -1054,7 +1054,7 @@ void nametbl_stop(void)
        if (!table.types)
                return;
-        write_lock_bh(&nametbl_lock);
+        write_lock_bh(&tipc_nametbl_lock);
        for (i = 0; i < tipc_nametbl_size; i++) {
                seq_head = &table.types[i];
                hlist_for_each_entry_safe(seq, seq_node, tmp, seq_head, ns_list) {
@@ -1075,5 +1075,5 @@ void nametbl_stop(void)
        }
        kfree(table.types);
        table.types = NULL;
-        write_unlock_bh(&nametbl_lock);
+        write_unlock_bh(&tipc_nametbl_lock);
 }
diff --git a/net/tipc/name_table.h b/net/tipc/name_table.h
index f82693384f60..e8a3d71763ce 100644
--- a/net/tipc/name_table.h
+++ b/net/tipc/name_table.h
@@ -85,24 +85,24 @@ struct publication {
 };
-extern rwlock_t nametbl_lock;
+extern rwlock_t tipc_nametbl_lock;
-struct sk_buff *nametbl_get(const void *req_tlv_area, int req_tlv_space);
+struct sk_buff *tipc_nametbl_get(const void *req_tlv_area, int req_tlv_space);
-u32 nametbl_translate(u32 type, u32 instance, u32 *node);
+u32 tipc_nametbl_translate(u32 type, u32 instance, u32 *node);
-int nametbl_mc_translate(u32 type, u32 lower, u32 upper, u32 limit, 
+int tipc_nametbl_mc_translate(u32 type, u32 lower, u32 upper, u32 limit, 
                         struct port_list *dports);
-int nametbl_publish_rsv(u32 ref, unsigned int scope, 
+int tipc_nametbl_publish_rsv(u32 ref, unsigned int scope, 
                        struct tipc_name_seq const *seq);
-struct publication *nametbl_publish(u32 type, u32 lower, u32 upper,
+struct publication *tipc_nametbl_publish(u32 type, u32 lower, u32 upper,
                                    u32 scope, u32 port_ref, u32 key);
-int nametbl_withdraw(u32 type, u32 lower, u32 ref, u32 key);
+int tipc_nametbl_withdraw(u32 type, u32 lower, u32 ref, u32 key);
-struct publication *nametbl_insert_publ(u32 type, u32 lower, u32 upper,
+struct publication *tipc_nametbl_insert_publ(u32 type, u32 lower, u32 upper,
                                        u32 scope, u32 node, u32 ref, u32 key);
-struct publication *nametbl_remove_publ(u32 type, u32 lower, 
+struct publication *tipc_nametbl_remove_publ(u32 type, u32 lower, 
                                        u32 node, u32 ref, u32 key);
-void nametbl_subscribe(struct subscription *s);
+void tipc_nametbl_subscribe(struct subscription *s);
-void nametbl_unsubscribe(struct subscription *s);
+void tipc_nametbl_unsubscribe(struct subscription *s);
-int nametbl_init(void);
+int tipc_nametbl_init(void);
-void nametbl_stop(void);
+void tipc_nametbl_stop(void);
 #endif
diff --git a/net/tipc/net.c b/net/tipc/net.c
index 6826b493c1d6..074891ad4f09 100644
--- a/net/tipc/net.c
+++ b/net/tipc/net.c
@@ -58,25 +58,25 @@
 * 1: The routing hierarchy.
 *    Comprises the structures 'zone', 'cluster', 'node', 'link' 
 *    and 'bearer'. The whole hierarchy is protected by a big 
- *    read/write lock, net_lock, to enssure that nothing is added 
+ *    read/write lock, tipc_net_lock, to enssure that nothing is added 
 *    or removed while code is accessing any of these structures. 
 *    This layer must not be called from the two others while they 
 *    hold any of their own locks.
 *    Neither must it itself do any upcalls to the other two before
- *    it has released net_lock and other protective locks.
+ *    it has released tipc_net_lock and other protective locks.
 *
- *   Within the net_lock domain there are two sub-domains;'node' and 
+ *   Within the tipc_net_lock domain there are two sub-domains;'node' and 
 *   'bearer', where local write operations are permitted,
 *   provided that those are protected by individual spin_locks
- *   per instance. Code holding net_lock(read) and a node spin_lock 
+ *   per instance. Code holding tipc_net_lock(read) and a node spin_lock 
 *   is permitted to poke around in both the node itself and its
 *   subordinate links. I.e, it can update link counters and queues, 
 *   change link state, send protocol messages, and alter the 
 *   "active_links" array in the node; but it can _not_ remove a link 
 *   or a node from the overall structure.
 *   Correspondingly, individual bearers may change status within a 
- *   net_lock(read), protected by an individual spin_lock ber bearer 
+ *   tipc_net_lock(read), protected by an individual spin_lock ber bearer 
- *   instance, but it needs net_lock(write) to remove/add any bearers.
+ *   instance, but it needs tipc_net_lock(write) to remove/add any bearers.
 *     
 *
 *  2: The transport level of the protocol. 
@@ -97,91 +97,91 @@
 *       (Nobody is using read-only access to this, so it can just as 
 *       well be changed to a spin_lock)
 *     - A spin lock to protect the registry of kernel/driver users (reg.c)
- *     - A global spin_lock (port_lock), which only task is to ensure 
+ *     - A global spin_lock (tipc_port_lock), which only task is to ensure 
 *       consistency where more than one port is involved in an operation,
 *       i.e., whe a port is part of a linked list of ports.
 *       There are two such lists; 'port_list', which is used for management,
 *       and 'wait_list', which is used to queue ports during congestion.
 *     
 *  3: The name table (name_table.c, name_distr.c, subscription.c)
- *     - There is one big read/write-lock (nametbl_lock) protecting the 
+ *     - There is one big read/write-lock (tipc_nametbl_lock) protecting the 
 *       overall name table structure. Nothing must be added/removed to 
 *       this structure without holding write access to it.
 *     - There is one local spin_lock per sub_sequence, which can be seen
- *       as a sub-domain to the nametbl_lock domain. It is used only
+ *       as a sub-domain to the tipc_nametbl_lock domain. It is used only
 *       for translation operations, and is needed because a translation
 *       steps the root of the 'publication' linked list between each lookup.
- *       This is always used within the scope of a nametbl_lock(read).
+ *       This is always used within the scope of a tipc_nametbl_lock(read).
 *     - A local spin_lock protecting the queue of subscriber events.
 */
-rwlock_t net_lock = RW_LOCK_UNLOCKED;
+rwlock_t tipc_net_lock = RW_LOCK_UNLOCKED;
-struct network net = { 0 };
+struct network tipc_net = { 0 };
-struct node *net_select_remote_node(u32 addr, u32 ref) 
+struct node *tipc_net_select_remote_node(u32 addr, u32 ref) 
 {
-        return zone_select_remote_node(net.zones[tipc_zone(addr)], addr, ref);
+        return tipc_zone_select_remote_node(tipc_net.zones[tipc_zone(addr)], addr, ref);
 }
-u32 net_select_router(u32 addr, u32 ref)
+u32 tipc_net_select_router(u32 addr, u32 ref)
 {
-        return zone_select_router(net.zones[tipc_zone(addr)], addr, ref);
+        return tipc_zone_select_router(tipc_net.zones[tipc_zone(addr)], addr, ref);
 }
-u32 net_next_node(u32 a)
+u32 tipc_net_next_node(u32 a)
 {
-        if (net.zones[tipc_zone(a)])
+        if (tipc_net.zones[tipc_zone(a)])
-                return zone_next_node(a);
+                return tipc_zone_next_node(a);
        return 0;
 }
-void net_remove_as_router(u32 router)
+void tipc_net_remove_as_router(u32 router)
 {
        u32 z_num;
        for (z_num = 1; z_num <= tipc_max_zones; z_num++) {
-                if (!net.zones[z_num])
+                if (!tipc_net.zones[z_num])
                        continue;
-                zone_remove_as_router(net.zones[z_num], router);
+                tipc_zone_remove_as_router(tipc_net.zones[z_num], router);
        }
 }
-void net_send_external_routes(u32 dest)
+void tipc_net_send_external_routes(u32 dest)
 {
        u32 z_num;
        for (z_num = 1; z_num <= tipc_max_zones; z_num++) {
-                if (net.zones[z_num])
+                if (tipc_net.zones[z_num])
-                        zone_send_external_routes(net.zones[z_num], dest);
+                        tipc_zone_send_external_routes(tipc_net.zones[z_num], dest);
        }
 }
-int net_init(void)
+static int net_init(void)
 {
        u32 sz = sizeof(struct _zone *) * (tipc_max_zones + 1);
-        memset(&net, 0, sizeof(net));
+        memset(&tipc_net, 0, sizeof(tipc_net));
-        net.zones = (struct _zone **)kmalloc(sz, GFP_ATOMIC);
+        tipc_net.zones = (struct _zone **)kmalloc(sz, GFP_ATOMIC);
-        if (!net.zones) {
+        if (!tipc_net.zones) {
                return -ENOMEM;
        }
-        memset(net.zones, 0, sz);
+        memset(tipc_net.zones, 0, sz);
        return TIPC_OK;
 }
-void net_stop(void)
+static void net_stop(void)
 {
        u32 z_num;
-        if (!net.zones)
+        if (!tipc_net.zones)
                return;
        for (z_num = 1; z_num <= tipc_max_zones; z_num++) {
-                zone_delete(net.zones[z_num]);
+                tipc_zone_delete(tipc_net.zones[z_num]);
        }
-        kfree(net.zones);
+        kfree(tipc_net.zones);
-        net.zones = 0;
+        tipc_net.zones = 0;
 }
 static void net_route_named_msg(struct sk_buff *buf)
@@ -191,26 +191,26 @@ static void net_route_named_msg(struct sk_buff *buf)
        u32 dport;
        if (!msg_named(msg)) {
-                msg_dbg(msg, "net->drop_nam:");
+                msg_dbg(msg, "tipc_net->drop_nam:");
                buf_discard(buf);
                return;
        }
        dnode = addr_domain(msg_lookup_scope(msg));
-        dport = nametbl_translate(msg_nametype(msg), msg_nameinst(msg), &dnode);
+        dport = tipc_nametbl_translate(msg_nametype(msg), msg_nameinst(msg), &dnode);
-        dbg("net->lookup<%u,%u>-><%u,%x>\n",
+        dbg("tipc_net->lookup<%u,%u>-><%u,%x>\n",
            msg_nametype(msg), msg_nameinst(msg), dport, dnode);
        if (dport) {
                msg_set_destnode(msg, dnode);
                msg_set_destport(msg, dport);
-                net_route_msg(buf);
+                tipc_net_route_msg(buf);
                return;
        }
-        msg_dbg(msg, "net->rej:NO NAME: ");
+        msg_dbg(msg, "tipc_net->rej:NO NAME: ");
        tipc_reject_msg(buf, TIPC_ERR_NO_NAME);
 }
-void net_route_msg(struct sk_buff *buf)
+void tipc_net_route_msg(struct sk_buff *buf)
 {
        struct tipc_msg *msg;
        u32 dnode;
@@ -232,29 +232,29 @@ void net_route_msg(struct sk_buff *buf)
                return;
        }
-        msg_dbg(msg, "net->rout: ");
+        msg_dbg(msg, "tipc_net->rout: ");
        /* Handle message for this node */
        dnode = msg_short(msg) ? tipc_own_addr : msg_destnode(msg);
        if (in_scope(dnode, tipc_own_addr)) {
                if (msg_isdata(msg)) {
                        if (msg_mcast(msg)) 
-                                port_recv_mcast(buf, NULL);
+                                tipc_port_recv_mcast(buf, NULL);
                        else if (msg_destport(msg))
-                                port_recv_msg(buf);
+                                tipc_port_recv_msg(buf);
                        else
                                net_route_named_msg(buf);
                        return;
                }
                switch (msg_user(msg)) {
                case ROUTE_DISTRIBUTOR:
-                        cluster_recv_routing_table(buf);
+                        tipc_cltr_recv_routing_table(buf);
                        break;
                case NAME_DISTRIBUTOR:
-                        named_recv(buf);
+                        tipc_named_recv(buf);
                        break;
                case CONN_MANAGER:
-                        port_recv_proto_msg(buf);
+                        tipc_port_recv_proto_msg(buf);
                        break;
                default:
                        msg_dbg(msg,"DROP/NET/<REC<");
@@ -265,10 +265,10 @@ void net_route_msg(struct sk_buff *buf)
        /* Handle message for another node */
        msg_dbg(msg, "NET>SEND>: ");
-        link_send(buf, dnode, msg_link_selector(msg));
+        tipc_link_send(buf, dnode, msg_link_selector(msg));
 }
-int tipc_start_net(void)
+int tipc_net_start(void)
 {
        char addr_string[16];
        int res;
@@ -277,35 +277,35 @@ int tipc_start_net(void)
                return -ENOPROTOOPT;
        tipc_mode = TIPC_NET_MODE;
-        named_reinit();
+        tipc_named_reinit();
-        port_reinit();
+        tipc_port_reinit();
-        if ((res = bearer_init()) ||
+        if ((res = tipc_bearer_init()) ||
            (res = net_init()) ||
-            (res = cluster_init()) ||
+            (res = tipc_cltr_init()) ||
-            (res = bclink_init())) {
+            (res = tipc_bclink_init())) {
                return res;
        }
-        subscr_stop();
+        tipc_subscr_stop();
-        cfg_stop();
+        tipc_cfg_stop();
-        k_signal((Handler)subscr_start, 0);
+        tipc_k_signal((Handler)tipc_subscr_start, 0);
-        k_signal((Handler)cfg_init, 0);
+        tipc_k_signal((Handler)tipc_cfg_init, 0);
        info("Started in network mode\n");
        info("Own node address %s, network identity %u\n",
             addr_string_fill(addr_string, tipc_own_addr), tipc_net_id);
        return TIPC_OK;
 }
-void tipc_stop_net(void)
+void tipc_net_stop(void)
 {
        if (tipc_mode != TIPC_NET_MODE)
                return;
-        write_lock_bh(&net_lock);
+        write_lock_bh(&tipc_net_lock);
-        bearer_stop();
+        tipc_bearer_stop();
        tipc_mode = TIPC_NODE_MODE;
-        bclink_stop();
+        tipc_bclink_stop();
        net_stop();
-        write_unlock_bh(&net_lock);
+        write_unlock_bh(&tipc_net_lock);
        info("Left network mode \n");
 }
diff --git a/net/tipc/net.h b/net/tipc/net.h
index 948c6d42102c..f3e0b85e6475 100644
--- a/net/tipc/net.h
+++ b/net/tipc/net.h
@@ -49,18 +49,16 @@ struct network {
 };
-extern struct network net;
+extern struct network tipc_net;
-extern rwlock_t net_lock;
+extern rwlock_t tipc_net_lock;
-int net_init(void);
+void tipc_net_remove_as_router(u32 router);
-void net_stop(void);
+void tipc_net_send_external_routes(u32 dest);
-void net_remove_as_router(u32 router);
+void tipc_net_route_msg(struct sk_buff *buf);
-void net_send_external_routes(u32 dest);
+struct node *tipc_net_select_remote_node(u32 addr, u32 ref);
-void net_route_msg(struct sk_buff *buf);
+u32 tipc_net_select_router(u32 addr, u32 ref);
-struct node *net_select_remote_node(u32 addr, u32 ref);
-u32 net_select_router(u32 addr, u32 ref);
-int tipc_start_net(void);
+int tipc_net_start(void);
-void tipc_stop_net(void);
+void tipc_net_stop(void);
 #endif
diff --git a/net/tipc/netlink.c b/net/tipc/netlink.c
index 19b3f4022532..eb1bb4dce7af 100644
--- a/net/tipc/netlink.c
+++ b/net/tipc/netlink.c
@@ -47,13 +47,13 @@ static int handle_cmd(struct sk_buff *skb, struct genl_info *info)
        int hdr_space = NLMSG_SPACE(GENL_HDRLEN + TIPC_GENL_HDRLEN);
        if ((req_userhdr->cmd & 0xC000) && (!capable(CAP_NET_ADMIN)))
-                rep_buf = cfg_reply_error_string(TIPC_CFG_NOT_NET_ADMIN);
+                rep_buf = tipc_cfg_reply_error_string(TIPC_CFG_NOT_NET_ADMIN);
        else
-                rep_buf = cfg_do_cmd(req_userhdr->dest,
+                rep_buf = tipc_cfg_do_cmd(req_userhdr->dest,
-                                     req_userhdr->cmd,
+                                          req_userhdr->cmd,
-                                     NLMSG_DATA(req_nlh) + GENL_HDRLEN + TIPC_GENL_HDRLEN,
+                                          NLMSG_DATA(req_nlh) + GENL_HDRLEN + TIPC_GENL_HDRLEN,
-                                     NLMSG_PAYLOAD(req_nlh, GENL_HDRLEN + TIPC_GENL_HDRLEN),
+                                          NLMSG_PAYLOAD(req_nlh, GENL_HDRLEN + TIPC_GENL_HDRLEN),
-                                     hdr_space);
+                                          hdr_space);
        if (rep_buf) {
                skb_push(rep_buf, hdr_space);
@@ -81,7 +81,7 @@ static struct genl_ops ops = {
 static int family_registered = 0;
-int netlink_start(void)
+int tipc_netlink_start(void)
 {
@@ -103,7 +103,7 @@ int netlink_start(void)
        return -EFAULT;
 }
-void netlink_stop(void)
+void tipc_netlink_stop(void)
 {
        if (family_registered) {
                genl_unregister_family(&family);
diff --git a/net/tipc/node.c b/net/tipc/node.c
index 05688d01138b..6d65010e5fa1 100644
--- a/net/tipc/node.c
+++ b/net/tipc/node.c
@@ -45,17 +45,16 @@
 #include "port.h"
 #include "bearer.h"
 #include "name_distr.h"
-#include "net.h"
 void node_print(struct print_buf *buf, struct node *n_ptr, char *str);
 static void node_lost_contact(struct node *n_ptr);
 static void node_established_contact(struct node *n_ptr);
-struct node *nodes = NULL;      /* sorted list of nodes within cluster */
+struct node *tipc_nodes = NULL; /* sorted list of nodes within cluster */
 u32 tipc_own_tag = 0;
-struct node *node_create(u32 addr)
+struct node *tipc_node_create(u32 addr)
 {
        struct cluster *c_ptr;
        struct node *n_ptr;
@@ -68,16 +67,16 @@ struct node *node_create(u32 addr)
                n_ptr->lock =  SPIN_LOCK_UNLOCKED;      
                INIT_LIST_HEAD(&n_ptr->nsub);
        
-                c_ptr = cluster_find(addr);
+                c_ptr = tipc_cltr_find(addr);
                if (c_ptr == NULL)
-                        c_ptr = cluster_create(addr);
+                        c_ptr = tipc_cltr_create(addr);
                if (c_ptr != NULL) {
                        n_ptr->owner = c_ptr;
-                        cluster_attach_node(c_ptr, n_ptr);
+                        tipc_cltr_attach_node(c_ptr, n_ptr);
                        n_ptr->last_router = -1;
                        /* Insert node into ordered list */
-                        for (curr_node = &nodes; *curr_node; 
+                        for (curr_node = &tipc_nodes; *curr_node; 
                             curr_node = &(*curr_node)->next) {
                                if (addr < (*curr_node)->addr) {
                                        n_ptr->next = *curr_node;
@@ -93,13 +92,13 @@ struct node *node_create(u32 addr)
        return n_ptr;
 }
-void node_delete(struct node *n_ptr)
+void tipc_node_delete(struct node *n_ptr)
 {
        if (!n_ptr)
                return;
 #if 0
-        /* Not needed because links are already deleted via bearer_stop() */
+        /* Not needed because links are already deleted via tipc_bearer_stop() */
        u32 l_num;
@@ -114,12 +113,12 @@ void node_delete(struct node *n_ptr)
 /**
- * node_link_up - handle addition of link
+ * tipc_node_link_up - handle addition of link
 * 
 * Link becomes active (alone or shared) or standby, depending on its priority.
 */
-void node_link_up(struct node *n_ptr, struct link *l_ptr)
+void tipc_node_link_up(struct node *n_ptr, struct link *l_ptr)
 {
        struct link **active = &n_ptr->active_links[0];
@@ -136,7 +135,7 @@ void node_link_up(struct node *n_ptr, struct link *l_ptr)
                info("Link is standby\n");
                return;
        }
-        link_send_duplicate(active[0], l_ptr);
+        tipc_link_send_duplicate(active[0], l_ptr);
        if (l_ptr->priority == active[0]->priority) { 
                active[0] = l_ptr;
                return;
@@ -161,7 +160,7 @@ static void node_select_active_links(struct node *n_ptr)
        for (i = 0; i < MAX_BEARERS; i++) {
                struct link *l_ptr = n_ptr->links[i];
-                if (!l_ptr || !link_is_up(l_ptr) ||
+                if (!l_ptr || !tipc_link_is_up(l_ptr) ||
                    (l_ptr->priority < highest_prio))
                        continue;
@@ -175,14 +174,14 @@ static void node_select_active_links(struct node *n_ptr)
 }
 /**
- * node_link_down - handle loss of link
+ * tipc_node_link_down - handle loss of link
 */
-void node_link_down(struct node *n_ptr, struct link *l_ptr)
+void tipc_node_link_down(struct node *n_ptr, struct link *l_ptr)
 {
        struct link **active;
-        if (!link_is_active(l_ptr)) {
+        if (!tipc_link_is_active(l_ptr)) {
                info("Lost standby link <%s> on network plane %c\n",
                     l_ptr->name, l_ptr->b_ptr->net_plane);
                return;
@@ -197,40 +196,40 @@ void node_link_down(struct node *n_ptr, struct link *l_ptr)
                active[1] = active[0];
        if (active[0] == l_ptr)
                node_select_active_links(n_ptr);
-        if (node_is_up(n_ptr)) 
+        if (tipc_node_is_up(n_ptr)) 
-                link_changeover(l_ptr);
+                tipc_link_changeover(l_ptr);
        else 
                node_lost_contact(n_ptr);
 }
-int node_has_active_links(struct node *n_ptr)
+int tipc_node_has_active_links(struct node *n_ptr)
 {
        return (n_ptr && 
                ((n_ptr->active_links[0]) || (n_ptr->active_links[1])));
 }
-int node_has_redundant_links(struct node *n_ptr)
+int tipc_node_has_redundant_links(struct node *n_ptr)
 {
-        return (node_has_active_links(n_ptr) &&
+        return (tipc_node_has_active_links(n_ptr) &&
                (n_ptr->active_links[0] != n_ptr->active_links[1]));
 }
-int node_has_active_routes(struct node *n_ptr)
+int tipc_node_has_active_routes(struct node *n_ptr)
 {
        return (n_ptr && (n_ptr->last_router >= 0));
 }
-int node_is_up(struct node *n_ptr)
+int tipc_node_is_up(struct node *n_ptr)
 {
-        return (node_has_active_links(n_ptr) || node_has_active_routes(n_ptr));
+        return (tipc_node_has_active_links(n_ptr) || tipc_node_has_active_routes(n_ptr));
 }
-struct node *node_attach_link(struct link *l_ptr)
+struct node *tipc_node_attach_link(struct link *l_ptr)
 {
-        struct node *n_ptr = node_find(l_ptr->addr);
+        struct node *n_ptr = tipc_node_find(l_ptr->addr);
        if (!n_ptr)
-                n_ptr = node_create(l_ptr->addr);
+                n_ptr = tipc_node_create(l_ptr->addr);
        if (n_ptr) {
                u32 bearer_id = l_ptr->b_ptr->identity;
                char addr_string[16];
@@ -246,7 +245,7 @@ struct node *node_attach_link(struct link *l_ptr)
                if (!n_ptr->links[bearer_id]) {
                        n_ptr->links[bearer_id] = l_ptr;
-                        net.zones[tipc_zone(l_ptr->addr)]->links++;
+                        tipc_net.zones[tipc_zone(l_ptr->addr)]->links++;
                        n_ptr->link_cnt++;
                        return n_ptr;
                }
@@ -257,10 +256,10 @@ struct node *node_attach_link(struct link *l_ptr)
        return 0;
 }
-void node_detach_link(struct node *n_ptr, struct link *l_ptr)
+void tipc_node_detach_link(struct node *n_ptr, struct link *l_ptr)
 {
        n_ptr->links[l_ptr->b_ptr->identity] = 0;
-        net.zones[tipc_zone(l_ptr->addr)]->links--;
+        tipc_net.zones[tipc_zone(l_ptr->addr)]->links--;
        n_ptr->link_cnt--;
 }
@@ -315,45 +314,45 @@ static void node_established_contact(struct node *n_ptr)
        struct cluster *c_ptr;
        dbg("node_established_contact:-> %x\n", n_ptr->addr);
-        if (!node_has_active_routes(n_ptr)) { 
+        if (!tipc_node_has_active_routes(n_ptr)) { 
-                k_signal((Handler)named_node_up, n_ptr->addr);
+                tipc_k_signal((Handler)tipc_named_node_up, n_ptr->addr);
        }
        /* Syncronize broadcast acks */
-        n_ptr->bclink.acked = bclink_get_last_sent();
+        n_ptr->bclink.acked = tipc_bclink_get_last_sent();
        if (is_slave(tipc_own_addr))
                return;
        if (!in_own_cluster(n_ptr->addr)) {
                /* Usage case 1 (see above) */
-                c_ptr = cluster_find(tipc_own_addr);
+                c_ptr = tipc_cltr_find(tipc_own_addr);
                if (!c_ptr)
-                        c_ptr = cluster_create(tipc_own_addr);
+                        c_ptr = tipc_cltr_create(tipc_own_addr);
                if (c_ptr)
-                        cluster_bcast_new_route(c_ptr, n_ptr->addr, 1, 
+                        tipc_cltr_bcast_new_route(c_ptr, n_ptr->addr, 1, 
-                                                tipc_max_nodes);
+                                                  tipc_max_nodes);
                return;
        } 
        c_ptr = n_ptr->owner;
        if (is_slave(n_ptr->addr)) {
                /* Usage case 2 (see above) */
-                cluster_bcast_new_route(c_ptr, n_ptr->addr, 1, tipc_max_nodes);
+                tipc_cltr_bcast_new_route(c_ptr, n_ptr->addr, 1, tipc_max_nodes);
-                cluster_send_local_routes(c_ptr, n_ptr->addr);
+                tipc_cltr_send_local_routes(c_ptr, n_ptr->addr);
                return;
        }
        if (n_ptr->bclink.supported) {
-                nmap_add(&cluster_bcast_nodes, n_ptr->addr);
+                tipc_nmap_add(&tipc_cltr_bcast_nodes, n_ptr->addr);
                if (n_ptr->addr < tipc_own_addr)
                        tipc_own_tag++;
        }
        /* Case 3 (see above) */
-        net_send_external_routes(n_ptr->addr);
+        tipc_net_send_external_routes(n_ptr->addr);
-        cluster_send_slave_routes(c_ptr, n_ptr->addr);
+        tipc_cltr_send_slave_routes(c_ptr, n_ptr->addr);
-        cluster_bcast_new_route(c_ptr, n_ptr->addr, LOWEST_SLAVE,
+        tipc_cltr_bcast_new_route(c_ptr, n_ptr->addr, LOWEST_SLAVE,
-                                highest_allowed_slave);
+                                  tipc_highest_allowed_slave);
 }
 static void node_lost_contact(struct node *n_ptr)
@@ -375,39 +374,39 @@ static void node_lost_contact(struct node *n_ptr)
                n_ptr->bclink.defragm = NULL;
        }            
        if (in_own_cluster(n_ptr->addr) && n_ptr->bclink.supported) { 
-                bclink_acknowledge(n_ptr, mod(n_ptr->bclink.acked + 10000));
+                tipc_bclink_acknowledge(n_ptr, mod(n_ptr->bclink.acked + 10000));
        }
        /* Update routing tables */
        if (is_slave(tipc_own_addr)) {
-                net_remove_as_router(n_ptr->addr);
+                tipc_net_remove_as_router(n_ptr->addr);
        } else {
                if (!in_own_cluster(n_ptr->addr)) { 
                        /* Case 4 (see above) */
-                        c_ptr = cluster_find(tipc_own_addr);
+                        c_ptr = tipc_cltr_find(tipc_own_addr);
-                        cluster_bcast_lost_route(c_ptr, n_ptr->addr, 1,
+                        tipc_cltr_bcast_lost_route(c_ptr, n_ptr->addr, 1,
-                                                 tipc_max_nodes);
+                                                   tipc_max_nodes);
                } else {
                        /* Case 5 (see above) */
-                        c_ptr = cluster_find(n_ptr->addr);
+                        c_ptr = tipc_cltr_find(n_ptr->addr);
                        if (is_slave(n_ptr->addr)) {
-                                cluster_bcast_lost_route(c_ptr, n_ptr->addr, 1,
+                                tipc_cltr_bcast_lost_route(c_ptr, n_ptr->addr, 1,
-                                                         tipc_max_nodes);
+                                                           tipc_max_nodes);
                        } else {
                                if (n_ptr->bclink.supported) {
-                                        nmap_remove(&cluster_bcast_nodes, 
+                                        tipc_nmap_remove(&tipc_cltr_bcast_nodes, 
-                                                    n_ptr->addr);
+                                                         n_ptr->addr);
                                        if (n_ptr->addr < tipc_own_addr)
                                                tipc_own_tag--;
                                }
-                                net_remove_as_router(n_ptr->addr);
+                                tipc_net_remove_as_router(n_ptr->addr);
-                                cluster_bcast_lost_route(c_ptr, n_ptr->addr,
+                                tipc_cltr_bcast_lost_route(c_ptr, n_ptr->addr,
-                                                         LOWEST_SLAVE,
+                                                           LOWEST_SLAVE,
-                                                         highest_allowed_slave);
+                                                           tipc_highest_allowed_slave);
                        }
                }
        }
-        if (node_has_active_routes(n_ptr))
+        if (tipc_node_has_active_routes(n_ptr))
                return;
        info("Lost contact with %s\n", 
@@ -420,35 +419,35 @@ static void node_lost_contact(struct node *n_ptr)
                        continue;
                l_ptr->reset_checkpoint = l_ptr->next_in_no;
                l_ptr->exp_msg_count = 0;
-                link_reset_fragments(l_ptr);
+                tipc_link_reset_fragments(l_ptr);
        }
        /* Notify subscribers */
        list_for_each_entry_safe(ns, tns, &n_ptr->nsub, nodesub_list) {
                ns->node = 0;
                list_del_init(&ns->nodesub_list);
-                k_signal((Handler)ns->handle_node_down,
+                tipc_k_signal((Handler)ns->handle_node_down,
-                         (unsigned long)ns->usr_handle);
+                              (unsigned long)ns->usr_handle);
        }
 }
 /**
- * node_select_next_hop - find the next-hop node for a message
+ * tipc_node_select_next_hop - find the next-hop node for a message
 * 
 * Called by when cluster local lookup has failed.
 */
-struct node *node_select_next_hop(u32 addr, u32 selector)
+struct node *tipc_node_select_next_hop(u32 addr, u32 selector)
 {
        struct node *n_ptr;
        u32 router_addr;
-        if (!addr_domain_valid(addr))
+        if (!tipc_addr_domain_valid(addr))
                return 0;
        /* Look for direct link to destination processsor */
-        n_ptr = node_find(addr);
+        n_ptr = tipc_node_find(addr);
-        if (n_ptr && node_has_active_links(n_ptr))
+        if (n_ptr && tipc_node_has_active_links(n_ptr))
                return n_ptr;
        /* Cluster local system nodes *must* have direct links */
@@ -456,9 +455,9 @@ struct node *node_select_next_hop(u32 addr, u32 selector)
                return 0;
        /* Look for cluster local router with direct link to node */
-        router_addr = node_select_router(n_ptr, selector);
+        router_addr = tipc_node_select_router(n_ptr, selector);
        if (router_addr) 
-                return node_select(router_addr, selector);
+                return tipc_node_select(router_addr, selector);
        /* Slave nodes can only be accessed within own cluster via a 
           known router with direct link -- if no router was found,give up */
@@ -467,25 +466,25 @@ struct node *node_select_next_hop(u32 addr, u32 selector)
        /* Inter zone/cluster -- find any direct link to remote cluster */
        addr = tipc_addr(tipc_zone(addr), tipc_cluster(addr), 0);
-        n_ptr = net_select_remote_node(addr, selector);
+        n_ptr = tipc_net_select_remote_node(addr, selector);
-        if (n_ptr && node_has_active_links(n_ptr))
+        if (n_ptr && tipc_node_has_active_links(n_ptr))
                return n_ptr;
        /* Last resort -- look for any router to anywhere in remote zone */
-        router_addr =  net_select_router(addr, selector);
+        router_addr =  tipc_net_select_router(addr, selector);
        if (router_addr) 
-                return node_select(router_addr, selector);
+                return tipc_node_select(router_addr, selector);
        return 0;
 }
 /**
- * node_select_router - select router to reach specified node
+ * tipc_node_select_router - select router to reach specified node
 * 
 * Uses a deterministic and fair algorithm for selecting router node. 
 */
-u32 node_select_router(struct node *n_ptr, u32 ref)
+u32 tipc_node_select_router(struct node *n_ptr, u32 ref)
 {
        u32 ulim;
        u32 mask;
@@ -523,7 +522,7 @@ u32 node_select_router(struct node *n_ptr, u32 ref)
        return tipc_addr(own_zone(), own_cluster(), r);
 }
-void node_add_router(struct node *n_ptr, u32 router)
+void tipc_node_add_router(struct node *n_ptr, u32 router)
 {
        u32 r_num = tipc_node(router);
@@ -534,7 +533,7 @@ void node_add_router(struct node *n_ptr, u32 router)
               !n_ptr->routers[n_ptr->last_router]);
 }
-void node_remove_router(struct node *n_ptr, u32 router)
+void tipc_node_remove_router(struct node *n_ptr, u32 router)
 {
        u32 r_num = tipc_node(router);
@@ -547,7 +546,7 @@ void node_remove_router(struct node *n_ptr, u32 router)
        while ((--n_ptr->last_router >= 0) && 
               !n_ptr->routers[n_ptr->last_router]);
-        if (!node_is_up(n_ptr))
+        if (!tipc_node_is_up(n_ptr))
                node_lost_contact(n_ptr);
 }
@@ -572,16 +571,16 @@ u32 tipc_available_nodes(const u32 domain)
        struct node *n_ptr;
        u32 cnt = 0;
-        for (n_ptr = nodes; n_ptr; n_ptr = n_ptr->next) {
+        for (n_ptr = tipc_nodes; n_ptr; n_ptr = n_ptr->next) {
                if (!in_scope(domain, n_ptr->addr))
                        continue;
-                if (node_is_up(n_ptr))
+                if (tipc_node_is_up(n_ptr))
                        cnt++;
        }
        return cnt;
 }
-struct sk_buff *node_get_nodes(const void *req_tlv_area, int req_tlv_space)
+struct sk_buff *tipc_node_get_nodes(const void *req_tlv_area, int req_tlv_space)
 {
        u32 domain;
        struct sk_buff *buf;
@@ -589,40 +588,40 @@ struct sk_buff *node_get_nodes(const void *req_tlv_area, int req_tlv_space)
        struct tipc_node_info node_info;
        if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NET_ADDR))
-                return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
+                return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
        domain = *(u32 *)TLV_DATA(req_tlv_area);
        domain = ntohl(domain);
-        if (!addr_domain_valid(domain))
+        if (!tipc_addr_domain_valid(domain))
-                return cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
+                return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
-                                              " (network address)");
+                                                   " (network address)");
-        if (!nodes)
+        if (!tipc_nodes)
-                return cfg_reply_none();
+                return tipc_cfg_reply_none();
        /* For now, get space for all other nodes 
           (will need to modify this when slave nodes are supported */
-        buf = cfg_reply_alloc(TLV_SPACE(sizeof(node_info)) *
+        buf = tipc_cfg_reply_alloc(TLV_SPACE(sizeof(node_info)) *
-                            (tipc_max_nodes - 1));
+                                   (tipc_max_nodes - 1));
        if (!buf)
                return NULL;
        /* Add TLVs for all nodes in scope */
-        for (n_ptr = nodes; n_ptr; n_ptr = n_ptr->next) {
+        for (n_ptr = tipc_nodes; n_ptr; n_ptr = n_ptr->next) {
                if (!in_scope(domain, n_ptr->addr))
                        continue;
                node_info.addr = htonl(n_ptr->addr);
-                node_info.up = htonl(node_is_up(n_ptr));
+                node_info.up = htonl(tipc_node_is_up(n_ptr));
-                cfg_append_tlv(buf, TIPC_TLV_NODE_INFO, 
+                tipc_cfg_append_tlv(buf, TIPC_TLV_NODE_INFO, 
-                               &node_info, sizeof(node_info));
+                                    &node_info, sizeof(node_info));
        }
        return buf;
 }
-struct sk_buff *node_get_links(const void *req_tlv_area, int req_tlv_space)
+struct sk_buff *tipc_node_get_links(const void *req_tlv_area, int req_tlv_space)
 {
        u32 domain;
        struct sk_buff *buf;
@@ -630,22 +629,22 @@ struct sk_buff *node_get_links(const void *req_tlv_area, int req_tlv_space)
        struct tipc_link_info link_info;
        if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NET_ADDR))
-                return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
+                return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
        domain = *(u32 *)TLV_DATA(req_tlv_area);
        domain = ntohl(domain);
-        if (!addr_domain_valid(domain))
+        if (!tipc_addr_domain_valid(domain))
-                return cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
+                return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
-                                              " (network address)");
+                                                   " (network address)");
-        if (!nodes)
+        if (!tipc_nodes)
-                return cfg_reply_none();
+                return tipc_cfg_reply_none();
        /* For now, get space for 2 links to all other nodes + bcast link 
           (will need to modify this when slave nodes are supported */
-        buf = cfg_reply_alloc(TLV_SPACE(sizeof(link_info)) *
+        buf = tipc_cfg_reply_alloc(TLV_SPACE(sizeof(link_info)) *
-                            (2 * (tipc_max_nodes - 1) + 1));
+                                   (2 * (tipc_max_nodes - 1) + 1));
        if (!buf)
                return NULL;
@@ -654,12 +653,12 @@ struct sk_buff *node_get_links(const void *req_tlv_area, int req_tlv_space)
        link_info.dest = tipc_own_addr & 0xfffff00;
        link_info.dest = htonl(link_info.dest);
        link_info.up = htonl(1);
-        sprintf(link_info.str, bc_link_name);
+        sprintf(link_info.str, tipc_bclink_name);
-        cfg_append_tlv(buf, TIPC_TLV_LINK_INFO, &link_info, sizeof(link_info));
+        tipc_cfg_append_tlv(buf, TIPC_TLV_LINK_INFO, &link_info, sizeof(link_info));
        /* Add TLVs for any other links in scope */
-        for (n_ptr = nodes; n_ptr; n_ptr = n_ptr->next) {
+        for (n_ptr = tipc_nodes; n_ptr; n_ptr = n_ptr->next) {
                u32 i;
                if (!in_scope(domain, n_ptr->addr))
@@ -668,10 +667,10 @@ struct sk_buff *node_get_links(const void *req_tlv_area, int req_tlv_space)
                        if (!n_ptr->links[i]) 
                                continue;
                        link_info.dest = htonl(n_ptr->addr);
-                        link_info.up = htonl(link_is_up(n_ptr->links[i]));
+                        link_info.up = htonl(tipc_link_is_up(n_ptr->links[i]));
                        strcpy(link_info.str, n_ptr->links[i]->name);
-                        cfg_append_tlv(buf, TIPC_TLV_LINK_INFO, 
+                        tipc_cfg_append_tlv(buf, TIPC_TLV_LINK_INFO, 
-                                       &link_info, sizeof(link_info));
+                                            &link_info, sizeof(link_info));
                }
        }
diff --git a/net/tipc/node.h b/net/tipc/node.h
index b39442badccf..29f7ae6992d4 100644
--- a/net/tipc/node.h
+++ b/net/tipc/node.h
@@ -92,31 +92,31 @@ struct node {
        } bclink;
 };
-extern struct node *nodes;
+extern struct node *tipc_nodes;
 extern u32 tipc_own_tag;
-struct node *node_create(u32 addr);
+struct node *tipc_node_create(u32 addr);
-void node_delete(struct node *n_ptr);
+void tipc_node_delete(struct node *n_ptr);
-struct node *node_attach_link(struct link *l_ptr);
+struct node *tipc_node_attach_link(struct link *l_ptr);
-void node_detach_link(struct node *n_ptr, struct link *l_ptr);
+void tipc_node_detach_link(struct node *n_ptr, struct link *l_ptr);
-void node_link_down(struct node *n_ptr, struct link *l_ptr);
+void tipc_node_link_down(struct node *n_ptr, struct link *l_ptr);
-void node_link_up(struct node *n_ptr, struct link *l_ptr);
+void tipc_node_link_up(struct node *n_ptr, struct link *l_ptr);
-int node_has_active_links(struct node *n_ptr);
+int tipc_node_has_active_links(struct node *n_ptr);
-int node_has_redundant_links(struct node *n_ptr);
+int tipc_node_has_redundant_links(struct node *n_ptr);
-u32 node_select_router(struct node *n_ptr, u32 ref);
+u32 tipc_node_select_router(struct node *n_ptr, u32 ref);
-struct node *node_select_next_hop(u32 addr, u32 selector);
+struct node *tipc_node_select_next_hop(u32 addr, u32 selector);
-int node_is_up(struct node *n_ptr);
+int tipc_node_is_up(struct node *n_ptr);
-void node_add_router(struct node *n_ptr, u32 router);
+void tipc_node_add_router(struct node *n_ptr, u32 router);
-void node_remove_router(struct node *n_ptr, u32 router);
+void tipc_node_remove_router(struct node *n_ptr, u32 router);
-struct sk_buff *node_get_links(const void *req_tlv_area, int req_tlv_space);
+struct sk_buff *tipc_node_get_links(const void *req_tlv_area, int req_tlv_space);
-struct sk_buff *node_get_nodes(const void *req_tlv_area, int req_tlv_space);
+struct sk_buff *tipc_node_get_nodes(const void *req_tlv_area, int req_tlv_space);
-static inline struct node *node_find(u32 addr)
+static inline struct node *tipc_node_find(u32 addr)
 {
        if (likely(in_own_cluster(addr)))
-                return local_nodes[tipc_node(addr)];
+                return tipc_local_nodes[tipc_node(addr)];
-        else if (addr_domain_valid(addr)) {
+        else if (tipc_addr_domain_valid(addr)) {
-                struct cluster *c_ptr = cluster_find(addr);
+                struct cluster *c_ptr = tipc_cltr_find(addr);
                if (c_ptr)
                        return c_ptr->nodes[tipc_node(addr)];
@@ -124,19 +124,19 @@ static inline struct node *node_find(u32 addr)
        return 0;
 }
-static inline struct node *node_select(u32 addr, u32 selector)
+static inline struct node *tipc_node_select(u32 addr, u32 selector)
 {
        if (likely(in_own_cluster(addr)))
-                return local_nodes[tipc_node(addr)];
+                return tipc_local_nodes[tipc_node(addr)];
-        return node_select_next_hop(addr, selector);
+        return tipc_node_select_next_hop(addr, selector);
 }
-static inline void node_lock(struct node *n_ptr)
+static inline void tipc_node_lock(struct node *n_ptr)
 {
        spin_lock_bh(&n_ptr->lock);
 }
-static inline void node_unlock(struct node *n_ptr)
+static inline void tipc_node_unlock(struct node *n_ptr)
 {
        spin_unlock_bh(&n_ptr->lock);
 }
diff --git a/net/tipc/node_subscr.c b/net/tipc/node_subscr.c
index 79375927916f..afeea121d8be 100644
--- a/net/tipc/node_subscr.c
+++ b/net/tipc/node_subscr.c
@@ -41,39 +41,39 @@
 #include "addr.h"
 /**
- * nodesub_subscribe - create "node down" subscription for specified node
+ * tipc_nodesub_subscribe - create "node down" subscription for specified node
 */
-void nodesub_subscribe(struct node_subscr *node_sub, u32 addr, 
+void tipc_nodesub_subscribe(struct node_subscr *node_sub, u32 addr, 
                       void *usr_handle, net_ev_handler handle_down)
 {
        node_sub->node = 0;
        if (addr == tipc_own_addr)
                return;
-        if (!addr_node_valid(addr)) {
+        if (!tipc_addr_node_valid(addr)) {
                warn("node_subscr with illegal %x\n", addr);
                return;
        }
        node_sub->handle_node_down = handle_down;
        node_sub->usr_handle = usr_handle;
-        node_sub->node = node_find(addr);
+        node_sub->node = tipc_node_find(addr);
        assert(node_sub->node);
-        node_lock(node_sub->node);
+        tipc_node_lock(node_sub->node);
        list_add_tail(&node_sub->nodesub_list, &node_sub->node->nsub);
-        node_unlock(node_sub->node);
+        tipc_node_unlock(node_sub->node);
 }
 /**
- * nodesub_unsubscribe - cancel "node down" subscription (if any)
+ * tipc_nodesub_unsubscribe - cancel "node down" subscription (if any)
 */
-void nodesub_unsubscribe(struct node_subscr *node_sub)
+void tipc_nodesub_unsubscribe(struct node_subscr *node_sub)
 {
        if (!node_sub->node)
                return;
-        node_lock(node_sub->node);
+        tipc_node_lock(node_sub->node);
        list_del_init(&node_sub->nodesub_list);
-        node_unlock(node_sub->node);
+        tipc_node_unlock(node_sub->node);
 }
diff --git a/net/tipc/node_subscr.h b/net/tipc/node_subscr.h
index a3b87ac4859b..01751c4fbb43 100644
--- a/net/tipc/node_subscr.h
+++ b/net/tipc/node_subscr.h
@@ -56,8 +56,8 @@ struct node_subscr {
        struct list_head nodesub_list;
 };
-void nodesub_subscribe(struct node_subscr *node_sub, u32 addr,
+void tipc_nodesub_subscribe(struct node_subscr *node_sub, u32 addr,
-                       void *usr_handle, net_ev_handler handle_down);
+                            void *usr_handle, net_ev_handler handle_down);
-void nodesub_unsubscribe(struct node_subscr *node_sub);
+void tipc_nodesub_unsubscribe(struct node_subscr *node_sub);
 #endif
diff --git a/net/tipc/port.c b/net/tipc/port.c
index 66caca7abe92..72aae52bfec1 100644
--- a/net/tipc/port.c
+++ b/net/tipc/port.c
@@ -57,10 +57,10 @@
 static struct sk_buff *msg_queue_head = 0;
 static struct sk_buff *msg_queue_tail = 0;
-spinlock_t port_list_lock = SPIN_LOCK_UNLOCKED;
+spinlock_t tipc_port_list_lock = SPIN_LOCK_UNLOCKED;
 static spinlock_t queue_lock = SPIN_LOCK_UNLOCKED;
-LIST_HEAD(ports);
+static LIST_HEAD(ports);
 static void port_handle_node_down(unsigned long ref);
 static struct sk_buff* port_build_self_abort_msg(struct port *,u32 err);
 static struct sk_buff* port_build_peer_abort_msg(struct port *,u32 err);
@@ -107,7 +107,7 @@ int tipc_multicast(u32 ref, struct tipc_name_seq const *seq, u32 domain,
        struct sk_buff *buf;
        struct sk_buff *ibuf = NULL;
        struct port_list dports = {0, NULL, };
-        struct port *oport = port_deref(ref);
+        struct port *oport = tipc_port_deref(ref);
        int ext_targets;
        int res;
@@ -129,8 +129,8 @@ int tipc_multicast(u32 ref, struct tipc_name_seq const *seq, u32 domain,
        /* Figure out where to send multicast message */
-        ext_targets = nametbl_mc_translate(seq->type, seq->lower, seq->upper,
+        ext_targets = tipc_nametbl_mc_translate(seq->type, seq->lower, seq->upper,
-                                           TIPC_NODE_SCOPE, &dports);
+                                                TIPC_NODE_SCOPE, &dports);
        
        /* Send message to destinations (duplicate it only if necessary) */ 
@@ -138,12 +138,12 @@ int tipc_multicast(u32 ref, struct tipc_name_seq const *seq, u32 domain,
                if (dports.count != 0) {
                        ibuf = skb_copy(buf, GFP_ATOMIC);
                        if (ibuf == NULL) {
-                                port_list_free(&dports);
+                                tipc_port_list_free(&dports);
                                buf_discard(buf);
                                return -ENOMEM;
                        }
                }
-                res = bclink_send_msg(buf);
+                res = tipc_bclink_send_msg(buf);
                if ((res < 0) && (dports.count != 0)) {
                        buf_discard(ibuf);
                }
@@ -153,20 +153,20 @@ int tipc_multicast(u32 ref, struct tipc_name_seq const *seq, u32 domain,
        if (res >= 0) {
                if (ibuf)
-                        port_recv_mcast(ibuf, &dports);
+                        tipc_port_recv_mcast(ibuf, &dports);
        } else {
-                port_list_free(&dports);
+                tipc_port_list_free(&dports);
        }
        return res;
 }
 /**
- * port_recv_mcast - deliver multicast message to all destination ports
+ * tipc_port_recv_mcast - deliver multicast message to all destination ports
 * 
 * If there is no port list, perform a lookup to create one
 */
-void port_recv_mcast(struct sk_buff *buf, struct port_list *dp)
+void tipc_port_recv_mcast(struct sk_buff *buf, struct port_list *dp)
 {
        struct tipc_msg* msg;
        struct port_list dports = {0, NULL, };
@@ -179,7 +179,7 @@ void port_recv_mcast(struct sk_buff *buf, struct port_list *dp)
        /* Create destination port list, if one wasn't supplied */
        if (dp == NULL) {
-                nametbl_mc_translate(msg_nametype(msg),
+                tipc_nametbl_mc_translate(msg_nametype(msg),
                                     msg_namelower(msg),
                                     msg_nameupper(msg),
                                     TIPC_CLUSTER_SCOPE,
@@ -192,8 +192,8 @@ void port_recv_mcast(struct sk_buff *buf, struct port_list *dp)
        if (dp->count != 0) {
                if (dp->count == 1) {
                        msg_set_destport(msg, dp->ports[0]);
-                        port_recv_msg(buf);
+                        tipc_port_recv_msg(buf);
-                        port_list_free(dp);
+                        tipc_port_list_free(dp);
                        return;
                }
                for (; cnt < dp->count; cnt++) {
@@ -209,12 +209,12 @@ void port_recv_mcast(struct sk_buff *buf, struct port_list *dp)
                                item = item->next;
                        }
                        msg_set_destport(buf_msg(b),item->ports[index]);
-                        port_recv_msg(b);
+                        tipc_port_recv_msg(b);
                }
        }
 exit:
        buf_discard(buf);
-        port_list_free(dp);
+        tipc_port_list_free(dp);
 }
 /**
@@ -238,14 +238,14 @@ u32 tipc_createport_raw(void *usr_handle,
                return 0;
        }
        memset(p_ptr, 0, sizeof(*p_ptr));
-        ref = ref_acquire(p_ptr, &p_ptr->publ.lock);
+        ref = tipc_ref_acquire(p_ptr, &p_ptr->publ.lock);
        if (!ref) {
                warn("Reference Table Exhausted\n");
                kfree(p_ptr);
                return 0;
        }
-        port_lock(ref);
+        tipc_port_lock(ref);
        p_ptr->publ.ref = ref;
        msg = &p_ptr->publ.phdr;
        msg_init(msg, DATA_LOW, TIPC_NAMED_MSG, TIPC_OK, LONG_H_SIZE, 0);
@@ -264,12 +264,12 @@ u32 tipc_createport_raw(void *usr_handle,
        p_ptr->wakeup = wakeup;
        p_ptr->user_port = 0;
        k_init_timer(&p_ptr->timer, (Handler)port_timeout, ref);
-        spin_lock_bh(&port_list_lock);
+        spin_lock_bh(&tipc_port_list_lock);
        INIT_LIST_HEAD(&p_ptr->publications);
        INIT_LIST_HEAD(&p_ptr->port_list);
        list_add_tail(&p_ptr->port_list, &ports);
-        spin_unlock_bh(&port_list_lock);
+        spin_unlock_bh(&tipc_port_list_lock);
-        port_unlock(p_ptr);
+        tipc_port_unlock(p_ptr);
        return ref;
 }
@@ -279,31 +279,31 @@ int tipc_deleteport(u32 ref)
        struct sk_buff *buf = 0;
        tipc_withdraw(ref, 0, 0);
-        p_ptr = port_lock(ref);
+        p_ptr = tipc_port_lock(ref);
        if (!p_ptr) 
                return -EINVAL;
-        ref_discard(ref);
+        tipc_ref_discard(ref);
-        port_unlock(p_ptr);
+        tipc_port_unlock(p_ptr);
        k_cancel_timer(&p_ptr->timer);
        if (p_ptr->publ.connected) {
                buf = port_build_peer_abort_msg(p_ptr, TIPC_ERR_NO_PORT);
-                nodesub_unsubscribe(&p_ptr->subscription);
+                tipc_nodesub_unsubscribe(&p_ptr->subscription);
        }
        if (p_ptr->user_port) {
-                reg_remove_port(p_ptr->user_port);
+                tipc_reg_remove_port(p_ptr->user_port);
                kfree(p_ptr->user_port);
        }
-        spin_lock_bh(&port_list_lock);
+        spin_lock_bh(&tipc_port_list_lock);
        list_del(&p_ptr->port_list);
        list_del(&p_ptr->wait_list);
-        spin_unlock_bh(&port_list_lock);
+        spin_unlock_bh(&tipc_port_list_lock);
        k_term_timer(&p_ptr->timer);
        kfree(p_ptr);
        dbg("Deleted port %u\n", ref);
-        net_route_msg(buf);
+        tipc_net_route_msg(buf);
        return TIPC_OK;
 }
@@ -315,7 +315,7 @@ int tipc_deleteport(u32 ref)
 struct tipc_port *tipc_get_port(const u32 ref)
 {
-        return (struct tipc_port *)ref_deref(ref);
+        return (struct tipc_port *)tipc_ref_deref(ref);
 }
 /**
@@ -327,11 +327,11 @@ void *tipc_get_handle(const u32 ref)
        struct port *p_ptr;
        void * handle;
-        p_ptr = port_lock(ref);
+        p_ptr = tipc_port_lock(ref);
        if (!p_ptr)
                return 0;
        handle = p_ptr->publ.usr_handle;
-        port_unlock(p_ptr);
+        tipc_port_unlock(p_ptr);
        return handle;
 }
@@ -344,7 +344,7 @@ int tipc_portunreliable(u32 ref, unsigned int *isunreliable)
 {
        struct port *p_ptr;
        
-        p_ptr = port_lock(ref);
+        p_ptr = tipc_port_lock(ref);
        if (!p_ptr)
                return -EINVAL;
        *isunreliable = port_unreliable(p_ptr);
@@ -356,11 +356,11 @@ int tipc_set_portunreliable(u32 ref, unsigned int isunreliable)
 {
        struct port *p_ptr;
        
-        p_ptr = port_lock(ref);
+        p_ptr = tipc_port_lock(ref);
        if (!p_ptr)
                return -EINVAL;
        msg_set_src_droppable(&p_ptr->publ.phdr, (isunreliable != 0));
-        port_unlock(p_ptr);
+        tipc_port_unlock(p_ptr);
        return TIPC_OK;
 }
@@ -373,7 +373,7 @@ int tipc_portunreturnable(u32 ref, unsigned int *isunrejectable)
 {
        struct port *p_ptr;
        
-        p_ptr = port_lock(ref);
+        p_ptr = tipc_port_lock(ref);
        if (!p_ptr)
                return -EINVAL;
        *isunrejectable = port_unreturnable(p_ptr);
@@ -385,11 +385,11 @@ int tipc_set_portunreturnable(u32 ref, unsigned int isunrejectable)
 {
        struct port *p_ptr;
        
-        p_ptr = port_lock(ref);
+        p_ptr = tipc_port_lock(ref);
        if (!p_ptr)
                return -EINVAL;
        msg_set_dest_droppable(&p_ptr->publ.phdr, (isunrejectable != 0));
-        port_unlock(p_ptr);
+        tipc_port_unlock(p_ptr);
        return TIPC_OK;
 }
@@ -476,25 +476,25 @@ int tipc_reject_msg(struct sk_buff *buf, u32 err)
        /* send self-abort message when rejecting on a connected port */
        if (msg_connected(msg)) {
                struct sk_buff *abuf = 0;
-                struct port *p_ptr = port_lock(msg_destport(msg));
+                struct port *p_ptr = tipc_port_lock(msg_destport(msg));
                if (p_ptr) {
                        if (p_ptr->publ.connected)
                                abuf = port_build_self_abort_msg(p_ptr, err);
-                        port_unlock(p_ptr);
+                        tipc_port_unlock(p_ptr);
                }
-                net_route_msg(abuf);
+                tipc_net_route_msg(abuf);
        }
        /* send rejected message */
        buf_discard(buf);
-        net_route_msg(rbuf);
+        tipc_net_route_msg(rbuf);
        return data_sz;
 }
-int port_reject_sections(struct port *p_ptr, struct tipc_msg *hdr,
+int tipc_port_reject_sections(struct port *p_ptr, struct tipc_msg *hdr,
-                         struct iovec const *msg_sect, u32 num_sect,
+                              struct iovec const *msg_sect, u32 num_sect,
-                         int err)
+                              int err)
 {
        struct sk_buff *buf;
        int res;
@@ -509,7 +509,7 @@ int port_reject_sections(struct port *p_ptr, struct tipc_msg *hdr,
 static void port_timeout(unsigned long ref)
 {
-        struct port *p_ptr = port_lock(ref);
+        struct port *p_ptr = tipc_port_lock(ref);
        struct sk_buff *buf = 0;
        if (!p_ptr || !p_ptr->publ.connected)
@@ -532,21 +532,21 @@ static void port_timeout(unsigned long ref)
                p_ptr->probing_state = PROBING;
                k_start_timer(&p_ptr->timer, p_ptr->probing_interval);
        }
-        port_unlock(p_ptr);
+        tipc_port_unlock(p_ptr);
-        net_route_msg(buf);
+        tipc_net_route_msg(buf);
 }
 static void port_handle_node_down(unsigned long ref)
 {
-        struct port *p_ptr = port_lock(ref);
+        struct port *p_ptr = tipc_port_lock(ref);
        struct sk_buff* buf = 0;
        if (!p_ptr)
                return;
        buf = port_build_self_abort_msg(p_ptr, TIPC_ERR_NO_NODE);
-        port_unlock(p_ptr);
+        tipc_port_unlock(p_ptr);
-        net_route_msg(buf);
+        tipc_net_route_msg(buf);
 }
@@ -589,10 +589,10 @@ static struct sk_buff *port_build_peer_abort_msg(struct port *p_ptr, u32 err)
                                    0);
 }
-void port_recv_proto_msg(struct sk_buff *buf)
+void tipc_port_recv_proto_msg(struct sk_buff *buf)
 {
        struct tipc_msg *msg = buf_msg(buf);
-        struct port *p_ptr = port_lock(msg_destport(msg));
+        struct port *p_ptr = tipc_port_lock(msg_destport(msg));
        u32 err = TIPC_OK;
        struct sk_buff *r_buf = 0;
        struct sk_buff *abort_buf = 0;
@@ -615,11 +615,11 @@ void port_recv_proto_msg(struct sk_buff *buf)
                        }
                }
                if (msg_type(msg) == CONN_ACK) {
-                        int wakeup = port_congested(p_ptr) && 
+                        int wakeup = tipc_port_congested(p_ptr) && 
                                     p_ptr->publ.congested &&
                                     p_ptr->wakeup;
                        p_ptr->acked += msg_msgcnt(msg);
-                        if (port_congested(p_ptr))
+                        if (tipc_port_congested(p_ptr))
                                goto exit;
                        p_ptr->publ.congested = 0;
                        if (!wakeup)
@@ -659,9 +659,9 @@ void port_recv_proto_msg(struct sk_buff *buf)
        port_incr_out_seqno(p_ptr);
 exit:
        if (p_ptr)
-                port_unlock(p_ptr);
+                tipc_port_unlock(p_ptr);
-        net_route_msg(r_buf);
+        tipc_net_route_msg(r_buf);
-        net_route_msg(abort_buf);
+        tipc_net_route_msg(abort_buf);
        buf_discard(buf);
 }
@@ -704,7 +704,7 @@ static void port_print(struct port *p_ptr, struct print_buf *buf, int full_id)
 #define MAX_PORT_QUERY 32768
-struct sk_buff *port_get_ports(void)
+struct sk_buff *tipc_port_get_ports(void)
 {
        struct sk_buff *buf;
        struct tlv_desc *rep_tlv;
@@ -712,20 +712,20 @@ struct sk_buff *port_get_ports(void)
        struct port *p_ptr;
        int str_len;
-        buf = cfg_reply_alloc(TLV_SPACE(MAX_PORT_QUERY));
+        buf = tipc_cfg_reply_alloc(TLV_SPACE(MAX_PORT_QUERY));
        if (!buf)
                return NULL;
        rep_tlv = (struct tlv_desc *)buf->data;
-        printbuf_init(&pb, TLV_DATA(rep_tlv), MAX_PORT_QUERY);
+        tipc_printbuf_init(&pb, TLV_DATA(rep_tlv), MAX_PORT_QUERY);
-        spin_lock_bh(&port_list_lock);
+        spin_lock_bh(&tipc_port_list_lock);
        list_for_each_entry(p_ptr, &ports, port_list) {
                spin_lock_bh(p_ptr->publ.lock);
                port_print(p_ptr, &pb, 0);
                spin_unlock_bh(p_ptr->publ.lock);
        }
-        spin_unlock_bh(&port_list_lock);
+        spin_unlock_bh(&tipc_port_list_lock);
-        str_len = printbuf_validate(&pb);
+        str_len = tipc_printbuf_validate(&pb);
        skb_put(buf, TLV_SPACE(str_len));
        TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
@@ -752,22 +752,22 @@ struct sk_buff *port_show_stats(const void *req_tlv_area, int req_tlv_space)
        ref = *(u32 *)TLV_DATA(req_tlv_area);
        ref = ntohl(ref);
-        p_ptr = port_lock(ref);
+        p_ptr = tipc_port_lock(ref);
        if (!p_ptr)
                return cfg_reply_error_string("port not found");
-        buf = cfg_reply_alloc(TLV_SPACE(MAX_PORT_STATS));
+        buf = tipc_cfg_reply_alloc(TLV_SPACE(MAX_PORT_STATS));
        if (!buf) {
-                port_unlock(p_ptr);
+                tipc_port_unlock(p_ptr);
                return NULL;
        }
        rep_tlv = (struct tlv_desc *)buf->data;
-        printbuf_init(&pb, TLV_DATA(rep_tlv), MAX_PORT_STATS);
+        tipc_printbuf_init(&pb, TLV_DATA(rep_tlv), MAX_PORT_STATS);
        port_print(p_ptr, &pb, 1);
        /* NEED TO FILL IN ADDITIONAL PORT STATISTICS HERE */
-        port_unlock(p_ptr);
+        tipc_port_unlock(p_ptr);
-        str_len = printbuf_validate(&pb);
+        str_len = tipc_printbuf_validate(&pb);
        skb_put(buf, TLV_SPACE(str_len));
        TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
@@ -777,19 +777,19 @@ struct sk_buff *port_show_stats(const void *req_tlv_area, int req_tlv_space)
 #endif
-void port_reinit(void)
+void tipc_port_reinit(void)
 {
        struct port *p_ptr;
        struct tipc_msg *msg;
-        spin_lock_bh(&port_list_lock);
+        spin_lock_bh(&tipc_port_list_lock);
        list_for_each_entry(p_ptr, &ports, port_list) {
                msg = &p_ptr->publ.phdr;
                if (msg_orignode(msg) == tipc_own_addr)
                        break;
                msg_set_orignode(msg, tipc_own_addr);
        }
-        spin_unlock_bh(&port_list_lock);
+        spin_unlock_bh(&tipc_port_list_lock);
 }
@@ -820,7 +820,7 @@ static void port_dispatcher_sigh(void *dummy)
                struct tipc_msg *msg = buf_msg(buf);
                u32 dref = msg_destport(msg);
                
-                p_ptr = port_lock(dref);
+                p_ptr = tipc_port_lock(dref);
                if (!p_ptr) {
                        /* Port deleted while msg in queue */
                        tipc_reject_msg(buf, TIPC_ERR_NO_PORT);
@@ -976,7 +976,7 @@ static u32 port_dispatcher(struct tipc_port *dummy, struct sk_buff *buf)
                msg_queue_tail = buf;
        } else {
                msg_queue_tail = msg_queue_head = buf;
-                k_signal((Handler)port_dispatcher_sigh, 0);
+                tipc_k_signal((Handler)port_dispatcher_sigh, 0);
        }
        spin_unlock_bh(&queue_lock);
        return TIPC_OK;
@@ -994,14 +994,14 @@ static void port_wakeup_sh(unsigned long ref)
        tipc_continue_event cb = 0;
        void *uh = 0;
-        p_ptr = port_lock(ref);
+        p_ptr = tipc_port_lock(ref);
        if (p_ptr) {
                up_ptr = p_ptr->user_port;
                if (up_ptr) {
                        cb = up_ptr->continue_event_cb;
                        uh = up_ptr->usr_handle;
                }
-                port_unlock(p_ptr);
+                tipc_port_unlock(p_ptr);
        }
        if (cb)
                cb(uh, ref);
@@ -1010,7 +1010,7 @@ static void port_wakeup_sh(unsigned long ref)
 static void port_wakeup(struct tipc_port *p_ptr)
 {
-        k_signal((Handler)port_wakeup_sh, p_ptr->ref);
+        tipc_k_signal((Handler)port_wakeup_sh, p_ptr->ref);
 }
 void tipc_acknowledge(u32 ref, u32 ack)
@@ -1018,7 +1018,7 @@ void tipc_acknowledge(u32 ref, u32 ack)
        struct port *p_ptr;
        struct sk_buff *buf = 0;
-        p_ptr = port_lock(ref);
+        p_ptr = tipc_port_lock(ref);
        if (!p_ptr)
                return;
        if (p_ptr->publ.connected) {
@@ -1033,8 +1033,8 @@ void tipc_acknowledge(u32 ref, u32 ack)
                                           port_out_seqno(p_ptr),
                                           ack);
        }
-        port_unlock(p_ptr);
+        tipc_port_unlock(p_ptr);
-        net_route_msg(buf);
+        tipc_net_route_msg(buf);
 }
 /*
@@ -1063,7 +1063,7 @@ int tipc_createport(u32 user_ref,
                return -ENOMEM;
        }
        ref = tipc_createport_raw(0, port_dispatcher, port_wakeup, importance);
-        p_ptr = port_lock(ref);
+        p_ptr = tipc_port_lock(ref);
        if (!p_ptr) {
                kfree(up_ptr);
                return -ENOMEM;
@@ -1081,10 +1081,10 @@ int tipc_createport(u32 user_ref,
        up_ptr->conn_msg_cb = conn_msg_cb;
        up_ptr->continue_event_cb = continue_event_cb;
        INIT_LIST_HEAD(&up_ptr->uport_list);
-        reg_add_port(up_ptr);
+        tipc_reg_add_port(up_ptr);
        *portref = p_ptr->publ.ref;
        dbg(" tipc_createport: %x with ref %u\n", p_ptr, p_ptr->publ.ref);        
-        port_unlock(p_ptr);
+        tipc_port_unlock(p_ptr);
        return TIPC_OK;
 }
@@ -1099,7 +1099,7 @@ int tipc_portimportance(u32 ref, unsigned int *importance)
 {
        struct port *p_ptr;
        
-        p_ptr = port_lock(ref);
+        p_ptr = tipc_port_lock(ref);
        if (!p_ptr)
                return -EINVAL;
        *importance = (unsigned int)msg_importance(&p_ptr->publ.phdr);
@@ -1114,7 +1114,7 @@ int tipc_set_portimportance(u32 ref, unsigned int imp)
        if (imp > TIPC_CRITICAL_IMPORTANCE)
                return -EINVAL;
-        p_ptr = port_lock(ref);
+        p_ptr = tipc_port_lock(ref);
        if (!p_ptr)
                return -EINVAL;
        msg_set_importance(&p_ptr->publ.phdr, (u32)imp);
@@ -1130,7 +1130,7 @@ int tipc_publish(u32 ref, unsigned int scope, struct tipc_name_seq const *seq)
        u32 key;
        int res = -EINVAL;
-        p_ptr = port_lock(ref);
+        p_ptr = tipc_port_lock(ref);
        dbg("tipc_publ %u, p_ptr = %x, conn = %x, scope = %x, "
            "lower = %u, upper = %u\n",
            ref, p_ptr, p_ptr->publ.connected, scope, seq->lower, seq->upper);
@@ -1147,8 +1147,8 @@ int tipc_publish(u32 ref, unsigned int scope, struct tipc_name_seq const *seq)
                res = -EADDRINUSE;
                goto exit;
        }
-        publ = nametbl_publish(seq->type, seq->lower, seq->upper,
+        publ = tipc_nametbl_publish(seq->type, seq->lower, seq->upper,
-                               scope, p_ptr->publ.ref, key);
+                                    scope, p_ptr->publ.ref, key);
        if (publ) {
                list_add(&publ->pport_list, &p_ptr->publications);
                p_ptr->pub_count++;
@@ -1156,7 +1156,7 @@ int tipc_publish(u32 ref, unsigned int scope, struct tipc_name_seq const *seq)
                res = TIPC_OK;
        }
 exit:
-        port_unlock(p_ptr);
+        tipc_port_unlock(p_ptr);
        return res;
 }
@@ -1167,7 +1167,7 @@ int tipc_withdraw(u32 ref, unsigned int scope, struct tipc_name_seq const *seq)
        struct publication *tpubl;
        int res = -EINVAL;
        
-        p_ptr = port_lock(ref);
+        p_ptr = tipc_port_lock(ref);
        if (!p_ptr)
                return -EINVAL;
        if (!p_ptr->publ.published)
@@ -1175,8 +1175,8 @@ int tipc_withdraw(u32 ref, unsigned int scope, struct tipc_name_seq const *seq)
        if (!seq) {
                list_for_each_entry_safe(publ, tpubl, 
                                         &p_ptr->publications, pport_list) {
-                        nametbl_withdraw(publ->type, publ->lower, 
+                        tipc_nametbl_withdraw(publ->type, publ->lower, 
-                                         publ->ref, publ->key);
+                                              publ->ref, publ->key);
                }
                res = TIPC_OK;
        } else {
@@ -1190,8 +1190,8 @@ int tipc_withdraw(u32 ref, unsigned int scope, struct tipc_name_seq const *seq)
                                continue;
                        if (publ->upper != seq->upper)
                                break;
-                        nametbl_withdraw(publ->type, publ->lower, 
+                        tipc_nametbl_withdraw(publ->type, publ->lower, 
-                                         publ->ref, publ->key);
+                                              publ->ref, publ->key);
                        res = TIPC_OK;
                        break;
                }
@@ -1199,7 +1199,7 @@ int tipc_withdraw(u32 ref, unsigned int scope, struct tipc_name_seq const *seq)
        if (list_empty(&p_ptr->publications))
                p_ptr->publ.published = 0;
 exit:
-        port_unlock(p_ptr);
+        tipc_port_unlock(p_ptr);
        return res;
 }
@@ -1209,7 +1209,7 @@ int tipc_connect2port(u32 ref, struct tipc_portid const *peer)
        struct tipc_msg *msg;
        int res = -EINVAL;
-        p_ptr = port_lock(ref);
+        p_ptr = tipc_port_lock(ref);
        if (!p_ptr)
                return -EINVAL;
        if (p_ptr->publ.published || p_ptr->publ.connected)
@@ -1234,13 +1234,13 @@ int tipc_connect2port(u32 ref, struct tipc_portid const *peer)
        p_ptr->publ.connected = 1;
        k_start_timer(&p_ptr->timer, p_ptr->probing_interval);
-        nodesub_subscribe(&p_ptr->subscription,peer->node,
+        tipc_nodesub_subscribe(&p_ptr->subscription,peer->node,
                          (void *)(unsigned long)ref,
                          (net_ev_handler)port_handle_node_down);
        res = TIPC_OK;
 exit:
-        port_unlock(p_ptr);
+        tipc_port_unlock(p_ptr);
-        p_ptr->max_pkt = link_get_max_pkt(peer->node, ref);
+        p_ptr->max_pkt = tipc_link_get_max_pkt(peer->node, ref);
        return res;
 }
@@ -1254,16 +1254,16 @@ int tipc_disconnect(u32 ref)
        struct port *p_ptr;
        int res = -ENOTCONN;
-        p_ptr = port_lock(ref);
+        p_ptr = tipc_port_lock(ref);
        if (!p_ptr)
                return -EINVAL;
        if (p_ptr->publ.connected) {
                p_ptr->publ.connected = 0;
                /* let timer expire on it's own to avoid deadlock! */
-                nodesub_unsubscribe(&p_ptr->subscription);
+                tipc_nodesub_unsubscribe(&p_ptr->subscription);
                res = TIPC_OK;
        }
-        port_unlock(p_ptr);
+        tipc_port_unlock(p_ptr);
        return res;
 }
@@ -1275,7 +1275,7 @@ int tipc_shutdown(u32 ref)
        struct port *p_ptr;
        struct sk_buff *buf = 0;
-        p_ptr = port_lock(ref);
+        p_ptr = tipc_port_lock(ref);
        if (!p_ptr)
                return -EINVAL;
@@ -1293,8 +1293,8 @@ int tipc_shutdown(u32 ref)
                                           port_out_seqno(p_ptr),
                                           0);
        }
-        port_unlock(p_ptr);
+        tipc_port_unlock(p_ptr);
-        net_route_msg(buf);
+        tipc_net_route_msg(buf);
        return tipc_disconnect(ref);
 }
@@ -1302,11 +1302,11 @@ int tipc_isconnected(u32 ref, int *isconnected)
 {
        struct port *p_ptr;
        
-        p_ptr = port_lock(ref);
+        p_ptr = tipc_port_lock(ref);
        if (!p_ptr)
                return -EINVAL;
        *isconnected = p_ptr->publ.connected;
-        port_unlock(p_ptr);
+        tipc_port_unlock(p_ptr);
        return TIPC_OK;
 }
@@ -1315,7 +1315,7 @@ int tipc_peer(u32 ref, struct tipc_portid *peer)
        struct port *p_ptr;
        int res;
         
-        p_ptr = port_lock(ref);
+        p_ptr = tipc_port_lock(ref);
        if (!p_ptr)
                return -EINVAL;
        if (p_ptr->publ.connected) {
@@ -1324,23 +1324,23 @@ int tipc_peer(u32 ref, struct tipc_portid *peer)
                res = TIPC_OK;
        } else
                res = -ENOTCONN;
-        port_unlock(p_ptr);
+        tipc_port_unlock(p_ptr);
        return res;
 }
 int tipc_ref_valid(u32 ref)
 {
        /* Works irrespective of type */
-        return !!ref_deref(ref);
+        return !!tipc_ref_deref(ref);
 }
 /*
- *  port_recv_sections(): Concatenate and deliver sectioned
+ *  tipc_port_recv_sections(): Concatenate and deliver sectioned
 *                        message for this node.
 */
-int port_recv_sections(struct port *sender, unsigned int num_sect,
+int tipc_port_recv_sections(struct port *sender, unsigned int num_sect,
                       struct iovec const *msg_sect)
 {
        struct sk_buff *buf;
@@ -1349,7 +1349,7 @@ int port_recv_sections(struct port *sender, unsigned int num_sect,
        res = msg_build(&sender->publ.phdr, msg_sect, num_sect,
                        MAX_MSG_SIZE, !sender->user_port, &buf);
        if (likely(buf))
-                port_recv_msg(buf);
+                tipc_port_recv_msg(buf);
        return res;
 }
@@ -1363,18 +1363,18 @@ int tipc_send(u32 ref, unsigned int num_sect, struct iovec const *msg_sect)
        u32 destnode;
        int res;
-        p_ptr = port_deref(ref);
+        p_ptr = tipc_port_deref(ref);
        if (!p_ptr || !p_ptr->publ.connected)
                return -EINVAL;
        p_ptr->publ.congested = 1;
-        if (!port_congested(p_ptr)) {
+        if (!tipc_port_congested(p_ptr)) {
                destnode = port_peernode(p_ptr);
                if (likely(destnode != tipc_own_addr))
-                        res = link_send_sections_fast(p_ptr, msg_sect, num_sect,
+                        res = tipc_link_send_sections_fast(p_ptr, msg_sect, num_sect,
-                                                      destnode);
+                                                           destnode);
                else
-                        res = port_recv_sections(p_ptr, num_sect, msg_sect);
+                        res = tipc_port_recv_sections(p_ptr, num_sect, msg_sect);
                if (likely(res != -ELINKCONG)) {
                        port_incr_out_seqno(p_ptr);
@@ -1404,7 +1404,7 @@ int tipc_send_buf(u32 ref, struct sk_buff *buf, unsigned int dsz)
        u32 sz;
        u32 res;
         
-        p_ptr = port_deref(ref);
+        p_ptr = tipc_port_deref(ref);
        if (!p_ptr || !p_ptr->publ.connected)
                return -EINVAL;
@@ -1419,11 +1419,11 @@ int tipc_send_buf(u32 ref, struct sk_buff *buf, unsigned int dsz)
        memcpy(buf->data, (unchar *)msg, hsz);
        destnode = msg_destnode(msg);
        p_ptr->publ.congested = 1;
-        if (!port_congested(p_ptr)) {
+        if (!tipc_port_congested(p_ptr)) {
                if (likely(destnode != tipc_own_addr))
                        res = tipc_send_buf_fast(buf, destnode);
                else {
-                        port_recv_msg(buf);
+                        tipc_port_recv_msg(buf);
                        res = sz;
                }
                if (likely(res != -ELINKCONG)) {
@@ -1458,7 +1458,7 @@ int tipc_forward2name(u32 ref,
        u32 destport = 0;
        int res;
-        p_ptr = port_deref(ref);
+        p_ptr = tipc_port_deref(ref);
        if (!p_ptr || p_ptr->publ.connected)
                return -EINVAL;
@@ -1472,16 +1472,16 @@ int tipc_forward2name(u32 ref,
        msg_set_lookup_scope(msg, addr_scope(domain));
        if (importance <= TIPC_CRITICAL_IMPORTANCE)
                msg_set_importance(msg,importance);
-        destport = nametbl_translate(name->type, name->instance, &destnode);
+        destport = tipc_nametbl_translate(name->type, name->instance, &destnode);
        msg_set_destnode(msg, destnode);
        msg_set_destport(msg, destport);
        if (likely(destport || destnode)) {
                p_ptr->sent++;
                if (likely(destnode == tipc_own_addr))
-                        return port_recv_sections(p_ptr, num_sect, msg_sect);
+                        return tipc_port_recv_sections(p_ptr, num_sect, msg_sect);
-                res = link_send_sections_fast(p_ptr, msg_sect, num_sect, 
+                res = tipc_link_send_sections_fast(p_ptr, msg_sect, num_sect, 
-                                              destnode);
+                                                   destnode);
                if (likely(res != -ELINKCONG))
                        return res;
                if (port_unreliable(p_ptr)) {
@@ -1490,8 +1490,8 @@ int tipc_forward2name(u32 ref,
                }
                return -ELINKCONG;
        }
-        return port_reject_sections(p_ptr, msg, msg_sect, num_sect, 
+        return tipc_port_reject_sections(p_ptr, msg, msg_sect, num_sect, 
-                                    TIPC_ERR_NO_NAME);
+                                         TIPC_ERR_NO_NAME);
 }
 /**
@@ -1530,7 +1530,7 @@ int tipc_forward_buf2name(u32 ref,
        u32 destport = 0;
        int res;
-        p_ptr = (struct port *)ref_deref(ref);
+        p_ptr = (struct port *)tipc_ref_deref(ref);
        if (!p_ptr || p_ptr->publ.connected)
                return -EINVAL;
@@ -1545,7 +1545,7 @@ int tipc_forward_buf2name(u32 ref,
        msg_set_lookup_scope(msg, addr_scope(domain));
        msg_set_hdr_sz(msg, LONG_H_SIZE);
        msg_set_size(msg, LONG_H_SIZE + dsz);
-        destport = nametbl_translate(name->type, name->instance, &destnode);
+        destport = tipc_nametbl_translate(name->type, name->instance, &destnode);
        msg_set_destnode(msg, destnode);
        msg_set_destport(msg, destport);
        msg_dbg(msg, "forw2name ==> ");
@@ -1557,7 +1557,7 @@ int tipc_forward_buf2name(u32 ref,
        if (likely(destport || destnode)) {
                p_ptr->sent++;
                if (destnode == tipc_own_addr)
-                        return port_recv_msg(buf);
+                        return tipc_port_recv_msg(buf);
                res = tipc_send_buf_fast(buf, destnode);
                if (likely(res != -ELINKCONG))
                        return res;
@@ -1601,7 +1601,7 @@ int tipc_forward2port(u32 ref,
        struct tipc_msg *msg;
        int res;
-        p_ptr = port_deref(ref);
+        p_ptr = tipc_port_deref(ref);
        if (!p_ptr || p_ptr->publ.connected)
                return -EINVAL;
@@ -1616,8 +1616,8 @@ int tipc_forward2port(u32 ref,
                msg_set_importance(msg, importance);
        p_ptr->sent++;
        if (dest->node == tipc_own_addr)
-                return port_recv_sections(p_ptr, num_sect, msg_sect);
+                return tipc_port_recv_sections(p_ptr, num_sect, msg_sect);
-        res = link_send_sections_fast(p_ptr, msg_sect, num_sect, dest->node);
+        res = tipc_link_send_sections_fast(p_ptr, msg_sect, num_sect, dest->node);
        if (likely(res != -ELINKCONG))
                return res;
        if (port_unreliable(p_ptr)) {
@@ -1658,7 +1658,7 @@ int tipc_forward_buf2port(u32 ref,
        struct tipc_msg *msg;
        int res;
-        p_ptr = (struct port *)ref_deref(ref);
+        p_ptr = (struct port *)tipc_ref_deref(ref);
        if (!p_ptr || p_ptr->publ.connected)
                return -EINVAL;
@@ -1680,7 +1680,7 @@ int tipc_forward_buf2port(u32 ref,
        msg_dbg(msg, "buf2port: ");
        p_ptr->sent++;
        if (dest->node == tipc_own_addr)
-                return port_recv_msg(buf);
+                return tipc_port_recv_msg(buf);
        res = tipc_send_buf_fast(buf, dest->node);
        if (likely(res != -ELINKCONG))
                return res;
diff --git a/net/tipc/port.h b/net/tipc/port.h
index e829a99d3b7f..839f100da646 100644
--- a/net/tipc/port.h
+++ b/net/tipc/port.h
@@ -37,7 +37,7 @@
 #ifndef _TIPC_PORT_H
 #define _TIPC_PORT_H
-#include <net/tipc/tipc_port.h>
+#include "core.h"
 #include "ref.h"
 #include "net.h"
 #include "msg.h"
@@ -110,65 +110,65 @@ struct port {
        struct node_subscr subscription;
 };
-extern spinlock_t port_list_lock;
+extern spinlock_t tipc_port_list_lock;
 struct port_list;
-int port_recv_sections(struct port *p_ptr, u32 num_sect, 
+int tipc_port_recv_sections(struct port *p_ptr, u32 num_sect, 
-                       struct iovec const *msg_sect);
+                            struct iovec const *msg_sect);
-int port_reject_sections(struct port *p_ptr, struct tipc_msg *hdr,
+int tipc_port_reject_sections(struct port *p_ptr, struct tipc_msg *hdr,
-                         struct iovec const *msg_sect, u32 num_sect,
+                              struct iovec const *msg_sect, u32 num_sect,
-                         int err);
+                              int err);
-struct sk_buff *port_get_ports(void);
+struct sk_buff *tipc_port_get_ports(void);
 struct sk_buff *port_show_stats(const void *req_tlv_area, int req_tlv_space);
-void port_recv_proto_msg(struct sk_buff *buf);
+void tipc_port_recv_proto_msg(struct sk_buff *buf);
-void port_recv_mcast(struct sk_buff *buf, struct port_list *dp);
+void tipc_port_recv_mcast(struct sk_buff *buf, struct port_list *dp);
-void port_reinit(void);
+void tipc_port_reinit(void);
 /**
- * port_lock - lock port instance referred to and return its pointer
+ * tipc_port_lock - lock port instance referred to and return its pointer
 */
-static inline struct port *port_lock(u32 ref)
+static inline struct port *tipc_port_lock(u32 ref)
 {
-        return (struct port *)ref_lock(ref);
+        return (struct port *)tipc_ref_lock(ref);
 }
 /** 
- * port_unlock - unlock a port instance
+ * tipc_port_unlock - unlock a port instance
 * 
- * Can use pointer instead of ref_unlock() since port is already locked.
+ * Can use pointer instead of tipc_ref_unlock() since port is already locked.
 */
-static inline void port_unlock(struct port *p_ptr)
+static inline void tipc_port_unlock(struct port *p_ptr)
 {
        spin_unlock_bh(p_ptr->publ.lock);
 }
-static inline struct port* port_deref(u32 ref)
+static inline struct port* tipc_port_deref(u32 ref)
 {
-        return (struct port *)ref_deref(ref);
+        return (struct port *)tipc_ref_deref(ref);
 }
-static inline u32 peer_port(struct port *p_ptr)
+static inline u32 tipc_peer_port(struct port *p_ptr)
 {
        return msg_destport(&p_ptr->publ.phdr);
 }
-static inline u32 peer_node(struct port *p_ptr)
+static inline u32 tipc_peer_node(struct port *p_ptr)
 {
        return msg_destnode(&p_ptr->publ.phdr);
 }
-static inline int port_congested(struct port *p_ptr)
+static inline int tipc_port_congested(struct port *p_ptr)
 {
        return((p_ptr->sent - p_ptr->acked) >= (TIPC_FLOW_CONTROL_WIN * 2));
 }
 /** 
- * port_recv_msg - receive message from lower layer and deliver to port user
+ * tipc_port_recv_msg - receive message from lower layer and deliver to port user
 */
-static inline int port_recv_msg(struct sk_buff *buf)
+static inline int tipc_port_recv_msg(struct sk_buff *buf)
 {
        struct port *p_ptr;
        struct tipc_msg *msg = buf_msg(buf);
@@ -178,24 +178,24 @@ static inline int port_recv_msg(struct sk_buff *buf)
        
        /* forward unresolved named message */
        if (unlikely(!destport)) {
-                net_route_msg(buf);
+                tipc_net_route_msg(buf);
                return dsz;
        }
        /* validate destination & pass to port, otherwise reject message */
-        p_ptr = port_lock(destport);
+        p_ptr = tipc_port_lock(destport);
        if (likely(p_ptr)) {
                if (likely(p_ptr->publ.connected)) {
-                        if ((unlikely(msg_origport(msg) != peer_port(p_ptr))) ||
+                        if ((unlikely(msg_origport(msg) != tipc_peer_port(p_ptr))) ||
-                            (unlikely(msg_orignode(msg) != peer_node(p_ptr))) ||
+                            (unlikely(msg_orignode(msg) != tipc_peer_node(p_ptr))) ||
                            (unlikely(!msg_connected(msg)))) {
                                err = TIPC_ERR_NO_PORT;
-                                port_unlock(p_ptr);
+                                tipc_port_unlock(p_ptr);
                                goto reject;
                        }
                }
                err = p_ptr->dispatcher(&p_ptr->publ, buf);
-                port_unlock(p_ptr);
+                tipc_port_unlock(p_ptr);
                if (likely(!err))
                        return dsz;
        } else {
diff --git a/net/tipc/ref.c b/net/tipc/ref.c
index 944093fe246f..5a13c2defe4a 100644
--- a/net/tipc/ref.c
+++ b/net/tipc/ref.c
@@ -61,15 +61,15 @@
 * because entry 0's reference field has the form XXXX|1--1.
 */
-struct ref_table ref_table = { 0 };
+struct ref_table tipc_ref_table = { 0 };
-rwlock_t reftbl_lock = RW_LOCK_UNLOCKED;
+static rwlock_t ref_table_lock = RW_LOCK_UNLOCKED;
 /**
- * ref_table_init - create reference table for objects
+ * tipc_ref_table_init - create reference table for objects
 */
-int ref_table_init(u32 requested_size, u32 start)
+int tipc_ref_table_init(u32 requested_size, u32 start)
 {
        struct reference *table;
        u32 sz = 1 << 4;
@@ -83,43 +83,43 @@ int ref_table_init(u32 requested_size, u32 start)
        if (table == NULL)
                return -ENOMEM;
-        write_lock_bh(&reftbl_lock);
+        write_lock_bh(&ref_table_lock);
        index_mask = sz - 1;
        for (i = sz - 1; i >= 0; i--) {
                table[i].object = 0;
                table[i].lock = SPIN_LOCK_UNLOCKED;
                table[i].data.next_plus_upper = (start & ~index_mask) + i - 1;
        }
-        ref_table.entries = table;
+        tipc_ref_table.entries = table;
-        ref_table.index_mask = index_mask;
+        tipc_ref_table.index_mask = index_mask;
-        ref_table.first_free = sz - 1;
+        tipc_ref_table.first_free = sz - 1;
-        ref_table.last_free = 1;
+        tipc_ref_table.last_free = 1;
-        write_unlock_bh(&reftbl_lock);
+        write_unlock_bh(&ref_table_lock);
        return TIPC_OK;
 }
 /**
- * ref_table_stop - destroy reference table for objects
+ * tipc_ref_table_stop - destroy reference table for objects
 */
-void ref_table_stop(void)
+void tipc_ref_table_stop(void)
 {
-        if (!ref_table.entries)
+        if (!tipc_ref_table.entries)
                return;
-        vfree(ref_table.entries);
+        vfree(tipc_ref_table.entries);
-        ref_table.entries = 0;
+        tipc_ref_table.entries = 0;
 }
 /**
- * ref_acquire - create reference to an object
+ * tipc_ref_acquire - create reference to an object
 * 
 * Return a unique reference value which can be translated back to the pointer
 * 'object' at a later time.  Also, pass back a pointer to the lock protecting 
 * the object, but without locking it.
 */
-u32 ref_acquire(void *object, spinlock_t **lock)
+u32 tipc_ref_acquire(void *object, spinlock_t **lock)
 {
        struct reference *entry;
        u32 index;
@@ -127,17 +127,17 @@ u32 ref_acquire(void *object, spinlock_t **lock)
        u32 next_plus_upper;
        u32 reference = 0;
-        assert(ref_table.entries && object);
+        assert(tipc_ref_table.entries && object);
-        write_lock_bh(&reftbl_lock);
+        write_lock_bh(&ref_table_lock);
-        if (ref_table.first_free) {
+        if (tipc_ref_table.first_free) {
-                index = ref_table.first_free;
+                index = tipc_ref_table.first_free;
-                entry = &(ref_table.entries[index]);
+                entry = &(tipc_ref_table.entries[index]);
-                index_mask = ref_table.index_mask;
+                index_mask = tipc_ref_table.index_mask;
                /* take lock in case a previous user of entry still holds it */ 
                spin_lock_bh(&entry->lock);  
                next_plus_upper = entry->data.next_plus_upper;
-                ref_table.first_free = next_plus_upper & index_mask;
+                tipc_ref_table.first_free = next_plus_upper & index_mask;
                reference = (next_plus_upper & ~index_mask) + index;
                entry->data.reference = reference;
                entry->object = object;
@@ -145,45 +145,45 @@ u32 ref_acquire(void *object, spinlock_t **lock)
                        *lock = &entry->lock;
                spin_unlock_bh(&entry->lock);
        }
-        write_unlock_bh(&reftbl_lock);
+        write_unlock_bh(&ref_table_lock);
        return reference;
 }
 /**
- * ref_discard - invalidate references to an object
+ * tipc_ref_discard - invalidate references to an object
 * 
 * Disallow future references to an object and free up the entry for re-use.
 * Note: The entry's spin_lock may still be busy after discard
 */
-void ref_discard(u32 ref)
+void tipc_ref_discard(u32 ref)
 {
        struct reference *entry;
        u32 index; 
        u32 index_mask;
-        assert(ref_table.entries);
+        assert(tipc_ref_table.entries);
        assert(ref != 0);
-        write_lock_bh(&reftbl_lock);
+        write_lock_bh(&ref_table_lock);
-        index_mask = ref_table.index_mask;
+        index_mask = tipc_ref_table.index_mask;
        index = ref & index_mask;
-        entry = &(ref_table.entries[index]);
+        entry = &(tipc_ref_table.entries[index]);
        assert(entry->object != 0);
        assert(entry->data.reference == ref);
        /* mark entry as unused */
        entry->object = 0;
-        if (ref_table.first_free == 0)
+        if (tipc_ref_table.first_free == 0)
-                ref_table.first_free = index;
+                tipc_ref_table.first_free = index;
        else
                /* next_plus_upper is always XXXX|0--0 for last free entry */
-                ref_table.entries[ref_table.last_free].data.next_plus_upper 
+                tipc_ref_table.entries[tipc_ref_table.last_free].data.next_plus_upper 
                        |= index;
-        ref_table.last_free = index;
+        tipc_ref_table.last_free = index;
        /* increment upper bits of entry to invalidate subsequent references */
        entry->data.next_plus_upper = (ref & ~index_mask) + (index_mask + 1);
-        write_unlock_bh(&reftbl_lock);
+        write_unlock_bh(&ref_table_lock);
 }
diff --git a/net/tipc/ref.h b/net/tipc/ref.h
index 429cde57228a..4f8f9f40dcac 100644
--- a/net/tipc/ref.h
+++ b/net/tipc/ref.h
@@ -54,7 +54,7 @@ struct reference {
 };
 /**
- * struct ref_table - table of TIPC object reference entries
+ * struct tipc_ref_table - table of TIPC object reference entries
 * @entries: pointer to array of reference entries
 * @index_mask: bitmask for array index portion of reference values
 * @first_free: array index of first unused object reference entry
@@ -68,24 +68,24 @@ struct ref_table {
        u32 last_free;
 };
-extern struct ref_table ref_table;
+extern struct ref_table tipc_ref_table;
-int ref_table_init(u32 requested_size, u32 start);
+int tipc_ref_table_init(u32 requested_size, u32 start);
-void ref_table_stop(void);
+void tipc_ref_table_stop(void);
-u32 ref_acquire(void *object, spinlock_t **lock);
+u32 tipc_ref_acquire(void *object, spinlock_t **lock);
-void ref_discard(u32 ref);
+void tipc_ref_discard(u32 ref);
 /**
- * ref_lock - lock referenced object and return pointer to it
+ * tipc_ref_lock - lock referenced object and return pointer to it
 */
-static inline void *ref_lock(u32 ref)
+static inline void *tipc_ref_lock(u32 ref)
 {
-        if (likely(ref_table.entries)) {
+        if (likely(tipc_ref_table.entries)) {
                struct reference *r =
-                        &ref_table.entries[ref & ref_table.index_mask];
+                        &tipc_ref_table.entries[ref & tipc_ref_table.index_mask];
                spin_lock_bh(&r->lock);
                if (likely(r->data.reference == ref))
@@ -96,31 +96,31 @@ static inline void *ref_lock(u32 ref)
 }
 /**
- * ref_unlock - unlock referenced object 
+ * tipc_ref_unlock - unlock referenced object 
 */
-static inline void ref_unlock(u32 ref)
+static inline void tipc_ref_unlock(u32 ref)
 {
-        if (likely(ref_table.entries)) {
+        if (likely(tipc_ref_table.entries)) {
                struct reference *r =
-                        &ref_table.entries[ref & ref_table.index_mask];
+                        &tipc_ref_table.entries[ref & tipc_ref_table.index_mask];
                if (likely(r->data.reference == ref))
                        spin_unlock_bh(&r->lock);
                else
-                        err("ref_unlock() invoked using obsolete reference\n");
+                        err("tipc_ref_unlock() invoked using obsolete reference\n");
        }
 }
 /**
- * ref_deref - return pointer referenced object (without locking it)
+ * tipc_ref_deref - return pointer referenced object (without locking it)
 */
-static inline void *ref_deref(u32 ref)
+static inline void *tipc_ref_deref(u32 ref)
 {
-        if (likely(ref_table.entries)) {
+        if (likely(tipc_ref_table.entries)) {
                struct reference *r = 
-                        &ref_table.entries[ref & ref_table.index_mask];
+                        &tipc_ref_table.entries[ref & tipc_ref_table.index_mask];
                if (likely(r->data.reference == ref))
                        return r->object;
diff --git a/net/tipc/socket.c b/net/tipc/socket.c
index d21f8c0cd25a..67253bfcd702 100644
--- a/net/tipc/socket.c
+++ b/net/tipc/socket.c
@@ -42,9 +42,7 @@
 #include <linux/mm.h>
 #include <linux/slab.h>
 #include <linux/poll.h>
-#include <linux/version.h>
 #include <linux/fcntl.h>
-#include <linux/version.h>
 #include <asm/semaphore.h>
 #include <asm/string.h>
 #include <asm/atomic.h>
@@ -1185,7 +1183,7 @@ static u32 dispatch(struct tipc_port *tport, struct sk_buff *buf)
        if (unlikely(msg_errcode(msg) && (sock->state == SS_CONNECTED))) {
                sock->state = SS_DISCONNECTING;
                /* Note: Use signal since port lock is already taken! */
-                k_signal((Handler)async_disconnect, tport->ref);
+                tipc_k_signal((Handler)async_disconnect, tport->ref);
        }
        /* Enqueue message (finally!) */
@@ -1685,11 +1683,11 @@ static struct proto tipc_proto = {
 };
 /**
- * socket_init - initialize TIPC socket interface
+ * tipc_socket_init - initialize TIPC socket interface
 * 
 * Returns 0 on success, errno otherwise
 */
-int socket_init(void)
+int tipc_socket_init(void)
 {
        int res;
@@ -1712,9 +1710,9 @@ int socket_init(void)
 }
 /**
- * sock_stop - stop TIPC socket interface
+ * tipc_socket_stop - stop TIPC socket interface
 */
-void socket_stop(void)
+void tipc_socket_stop(void)
 {
        if (!sockets_enabled)
                return;
diff --git a/net/tipc/subscr.c b/net/tipc/subscr.c
index 80e219ba527d..5ff38b9f3194 100644
--- a/net/tipc/subscr.c
+++ b/net/tipc/subscr.c
@@ -118,14 +118,14 @@ static void subscr_send_event(struct subscription *sub,
 }
 /**
- * subscr_overlap - test for subscription overlap with the given values
+ * tipc_subscr_overlap - test for subscription overlap with the given values
 *
 * Returns 1 if there is overlap, otherwise 0.
 */
-int subscr_overlap(struct subscription *sub, 
+int tipc_subscr_overlap(struct subscription *sub, 
-                   u32 found_lower, 
+                        u32 found_lower, 
-                   u32 found_upper)
+                        u32 found_upper)
 {
        if (found_lower < sub->seq.lower)
@@ -138,22 +138,22 @@ int subscr_overlap(struct subscription *sub,
 }
 /**
- * subscr_report_overlap - issue event if there is subscription overlap
+ * tipc_subscr_report_overlap - issue event if there is subscription overlap
 * 
 * Protected by nameseq.lock in name_table.c
 */
-void subscr_report_overlap(struct subscription *sub, 
+void tipc_subscr_report_overlap(struct subscription *sub, 
-                           u32 found_lower, 
+                                u32 found_lower, 
-                           u32 found_upper,
+                                u32 found_upper,
-                           u32 event, 
+                                u32 event, 
-                           u32 port_ref, 
+                                u32 port_ref, 
-                           u32 node,
+                                u32 node,
-                           int must)
+                                int must)
 {
        dbg("Rep overlap %u:%u,%u<->%u,%u\n", sub->seq.type, sub->seq.lower,
            sub->seq.upper, found_lower, found_upper);
-        if (!subscr_overlap(sub, found_lower, found_upper))
+        if (!tipc_subscr_overlap(sub, found_lower, found_upper))
                return;
        if (!must && (sub->filter != TIPC_SUB_PORTS))
                return;
@@ -172,13 +172,13 @@ static void subscr_timeout(struct subscription *sub)
        /* Validate subscriber reference (in case subscriber is terminating) */
        subscriber_ref = sub->owner->ref;
-        subscriber = (struct subscriber *)ref_lock(subscriber_ref);
+        subscriber = (struct subscriber *)tipc_ref_lock(subscriber_ref);
        if (subscriber == NULL)
                return;
        /* Unlink subscription from name table */
-        nametbl_unsubscribe(sub);
+        tipc_nametbl_unsubscribe(sub);
        /* Notify subscriber of timeout, then unlink subscription */
@@ -192,7 +192,7 @@ static void subscr_timeout(struct subscription *sub)
        /* Now destroy subscription */
-        ref_unlock(subscriber_ref);
+        tipc_ref_unlock(subscriber_ref);
        k_term_timer(&sub->timer);
        kfree(sub);
        atomic_dec(&topsrv.subscription_count);
@@ -216,7 +216,7 @@ static void subscr_terminate(struct subscriber *subscriber)
        /* Invalidate subscriber reference */
-        ref_discard(subscriber->ref);
+        tipc_ref_discard(subscriber->ref);
        spin_unlock_bh(subscriber->lock);
        /* Destroy any existing subscriptions for subscriber */
@@ -227,7 +227,7 @@ static void subscr_terminate(struct subscriber *subscriber)
                        k_cancel_timer(&sub->timer);
                        k_term_timer(&sub->timer);
                }
-                nametbl_unsubscribe(sub);
+                tipc_nametbl_unsubscribe(sub);
                list_del(&sub->subscription_list);
                dbg("Term: Removed sub %u,%u,%u from subscriber %x list\n",
                    sub->seq.type, sub->seq.lower, sub->seq.upper, subscriber);
@@ -315,7 +315,7 @@ static void subscr_subscribe(struct tipc_subscr *s,
                k_start_timer(&sub->timer, sub->timeout);
        }
        sub->owner = subscriber;
-        nametbl_subscribe(sub);
+        tipc_nametbl_subscribe(sub);
 }
 /**
@@ -332,7 +332,7 @@ static void subscr_conn_shutdown_event(void *usr_handle,
        struct subscriber *subscriber;
        spinlock_t *subscriber_lock;
-        subscriber = ref_lock((u32)(unsigned long)usr_handle);
+        subscriber = tipc_ref_lock((u32)(unsigned long)usr_handle);
        if (subscriber == NULL)
                return;
@@ -354,7 +354,7 @@ static void subscr_conn_msg_event(void *usr_handle,
        struct subscriber *subscriber;
        spinlock_t *subscriber_lock;
-        subscriber = ref_lock((u32)(unsigned long)usr_handle);
+        subscriber = tipc_ref_lock((u32)(unsigned long)usr_handle);
        if (subscriber == NULL)
                return;
@@ -401,7 +401,7 @@ static void subscr_named_msg_event(void *usr_handle,
        memset(subscriber, 0, sizeof(struct subscriber));
        INIT_LIST_HEAD(&subscriber->subscription_list);
        INIT_LIST_HEAD(&subscriber->subscriber_list);
-        subscriber->ref = ref_acquire(subscriber, &subscriber->lock);
+        subscriber->ref = tipc_ref_acquire(subscriber, &subscriber->lock);
        if (subscriber->ref == 0) {
                warn("Failed to acquire subscriber reference\n");
                kfree(subscriber);
@@ -423,7 +423,7 @@ static void subscr_named_msg_event(void *usr_handle,
                        &subscriber->port_ref);
        if (subscriber->port_ref == 0) {
                warn("Memory squeeze; failed to create subscription port\n");
-                ref_discard(subscriber->ref);
+                tipc_ref_discard(subscriber->ref);
                kfree(subscriber);
                return;
        }
@@ -432,7 +432,7 @@ static void subscr_named_msg_event(void *usr_handle,
        /* Add subscriber to topology server's subscriber list */
-        ref_lock(subscriber->ref);
+        tipc_ref_lock(subscriber->ref);
        spin_lock_bh(&topsrv.lock);
        list_add(&subscriber->subscriber_list, &topsrv.subscriber_list);
        spin_unlock_bh(&topsrv.lock);
@@ -451,7 +451,7 @@ static void subscr_named_msg_event(void *usr_handle,
        spin_unlock_bh(subscriber_lock);
 }
-int subscr_start(void)
+int tipc_subscr_start(void)
 {
        struct tipc_name_seq seq = {TIPC_TOP_SRV, TIPC_TOP_SRV, TIPC_TOP_SRV};
        int res = -1;
@@ -481,7 +481,7 @@ int subscr_start(void)
        if (res)
                goto failed;
-        res = nametbl_publish_rsv(topsrv.setup_port, TIPC_NODE_SCOPE, &seq);
+        res = tipc_nametbl_publish_rsv(topsrv.setup_port, TIPC_NODE_SCOPE, &seq);
        if (res)
                goto failed;
@@ -496,7 +496,7 @@ failed:
        return res;
 }
-void subscr_stop(void)
+void tipc_subscr_stop(void)
 {
        struct subscriber *subscriber;
        struct subscriber *subscriber_temp;
@@ -507,7 +507,7 @@ void subscr_stop(void)
                list_for_each_entry_safe(subscriber, subscriber_temp, 
                                         &topsrv.subscriber_list,
                                         subscriber_list) {
-                        ref_lock(subscriber->ref);
+                        tipc_ref_lock(subscriber->ref);
                        subscriber_lock = subscriber->lock;
                        subscr_terminate(subscriber);
                        spin_unlock_bh(subscriber_lock);
@@ -522,6 +522,6 @@ int tipc_ispublished(struct tipc_name const *name)
 {
        u32 domain = 0;
-        return(nametbl_translate(name->type, name->instance,&domain) != 0);
+        return(tipc_nametbl_translate(name->type, name->instance,&domain) != 0);
 }
diff --git a/net/tipc/subscr.h b/net/tipc/subscr.h
index ccff4efcb755..1e5090465d2e 100644
--- a/net/tipc/subscr.h
+++ b/net/tipc/subscr.h
@@ -60,21 +60,21 @@ struct subscription {
        struct subscriber *owner;
 };
-int subscr_overlap(struct subscription * sub, 
+int tipc_subscr_overlap(struct subscription * sub, 
-                   u32 found_lower, 
+                        u32 found_lower, 
-                   u32 found_upper);
+                        u32 found_upper);
-void subscr_report_overlap(struct subscription * sub, 
+void tipc_subscr_report_overlap(struct subscription * sub, 
-                           u32 found_lower, 
+                                u32 found_lower, 
-                           u32 found_upper,
+                                u32 found_upper,
-                           u32 event, 
+                                u32 event, 
-                           u32 port_ref, 
+                                u32 port_ref, 
-                           u32 node,
+                                u32 node,
-                           int must_report);
+                                int must_report);
-int subscr_start(void);
+int tipc_subscr_start(void);
-void subscr_stop(void);
+void tipc_subscr_stop(void);
 #endif
diff --git a/net/tipc/user_reg.c b/net/tipc/user_reg.c
index 35ec7dc8211d..106200d76587 100644
--- a/net/tipc/user_reg.c
+++ b/net/tipc/user_reg.c
@@ -114,10 +114,10 @@ static void reg_callback(struct tipc_user *user_ptr)
 }
 /**
- * reg_start - activate TIPC user registry
+ * tipc_reg_start - activate TIPC user registry
 */
-int reg_start(void)
+int tipc_reg_start(void)
 {
        u32 u;
        int res;
@@ -127,17 +127,17 @@ int reg_start(void)
        for (u = 1; u <= MAX_USERID; u++) {
                if (users[u].callback)
-                        k_signal((Handler)reg_callback,
+                        tipc_k_signal((Handler)reg_callback,
-                                 (unsigned long)&users[u]);
+                                      (unsigned long)&users[u]);
        }
        return TIPC_OK;
 }
 /**
- * reg_stop - shut down & delete TIPC user registry
+ * tipc_reg_stop - shut down & delete TIPC user registry
 */
-void reg_stop(void)
+void tipc_reg_stop(void)
 {               
        int id;
@@ -184,7 +184,7 @@ int tipc_attach(u32 *userid, tipc_mode_event cb, void *usr_handle)
        atomic_inc(&tipc_user_count);
        
        if (cb && (tipc_mode != TIPC_NOT_RUNNING))
-                k_signal((Handler)reg_callback, (unsigned long)user_ptr);
+                tipc_k_signal((Handler)reg_callback, (unsigned long)user_ptr);
        return TIPC_OK;
 }
@@ -223,10 +223,10 @@ void tipc_detach(u32 userid)
 }
 /**
- * reg_add_port - register a user's driver port
+ * tipc_reg_add_port - register a user's driver port
 */
-int reg_add_port(struct user_port *up_ptr)
+int tipc_reg_add_port(struct user_port *up_ptr)
 {
        struct tipc_user *user_ptr;
@@ -245,10 +245,10 @@ int reg_add_port(struct user_port *up_ptr)
 }
 /**
- * reg_remove_port - deregister a user's driver port
+ * tipc_reg_remove_port - deregister a user's driver port
 */
-int reg_remove_port(struct user_port *up_ptr)
+int tipc_reg_remove_port(struct user_port *up_ptr)
 {
        if (up_ptr->user_ref == 0)
                return TIPC_OK;
diff --git a/net/tipc/user_reg.h b/net/tipc/user_reg.h
index 122ca9be3671..d0e88794ed1b 100644
--- a/net/tipc/user_reg.h
+++ b/net/tipc/user_reg.h
@@ -39,10 +39,10 @@
 #include "port.h"
-int reg_start(void);
+int tipc_reg_start(void);
-void reg_stop(void);
+void tipc_reg_stop(void);
-int reg_add_port(struct user_port *up_ptr);
+int tipc_reg_add_port(struct user_port *up_ptr);
-int reg_remove_port(struct user_port *up_ptr);
+int tipc_reg_remove_port(struct user_port *up_ptr);
 #endif
diff --git a/net/tipc/zone.c b/net/tipc/zone.c
index 4eaef662d568..7c11f7f83a21 100644
--- a/net/tipc/zone.c
+++ b/net/tipc/zone.c
@@ -42,12 +42,12 @@
 #include "cluster.h"
 #include "node.h"
-struct _zone *zone_create(u32 addr)
+struct _zone *tipc_zone_create(u32 addr)
 {
        struct _zone *z_ptr = 0;
        u32 z_num;
-        if (!addr_domain_valid(addr))
+        if (!tipc_addr_domain_valid(addr))
                return 0;
        z_ptr = (struct _zone *)kmalloc(sizeof(*z_ptr), GFP_ATOMIC);
@@ -55,24 +55,24 @@ struct _zone *zone_create(u32 addr)
                memset(z_ptr, 0, sizeof(*z_ptr));
                z_num = tipc_zone(addr);
                z_ptr->addr = tipc_addr(z_num, 0, 0);
-                net.zones[z_num] = z_ptr;
+                tipc_net.zones[z_num] = z_ptr;
        }
        return z_ptr;
 }
-void zone_delete(struct _zone *z_ptr)
+void tipc_zone_delete(struct _zone *z_ptr)
 {
        u32 c_num;
        if (!z_ptr)
                return;
        for (c_num = 1; c_num <= tipc_max_clusters; c_num++) {
-                cluster_delete(z_ptr->clusters[c_num]);
+                tipc_cltr_delete(z_ptr->clusters[c_num]);
        }
        kfree(z_ptr);
 }
-void zone_attach_cluster(struct _zone *z_ptr, struct cluster *c_ptr)
+void tipc_zone_attach_cluster(struct _zone *z_ptr, struct cluster *c_ptr)
 {
        u32 c_num = tipc_cluster(c_ptr->addr);
@@ -82,19 +82,19 @@ void zone_attach_cluster(struct _zone *z_ptr, struct cluster *c_ptr)
        z_ptr->clusters[c_num] = c_ptr;
 }
-void zone_remove_as_router(struct _zone *z_ptr, u32 router)
+void tipc_zone_remove_as_router(struct _zone *z_ptr, u32 router)
 {
        u32 c_num;
        for (c_num = 1; c_num <= tipc_max_clusters; c_num++) {
                if (z_ptr->clusters[c_num]) {
-                        cluster_remove_as_router(z_ptr->clusters[c_num], 
+                        tipc_cltr_remove_as_router(z_ptr->clusters[c_num], 
-                                                 router);
+                                                   router);
                }
        }
 }
-void zone_send_external_routes(struct _zone *z_ptr, u32 dest)
+void tipc_zone_send_external_routes(struct _zone *z_ptr, u32 dest)
 {
        u32 c_num;
@@ -102,12 +102,12 @@ void zone_send_external_routes(struct _zone *z_ptr, u32 dest)
                if (z_ptr->clusters[c_num]) {
                        if (in_own_cluster(z_ptr->addr))
                                continue;
-                        cluster_send_ext_routes(z_ptr->clusters[c_num], dest);
+                        tipc_cltr_send_ext_routes(z_ptr->clusters[c_num], dest);
                }
        }
 }
-struct node *zone_select_remote_node(struct _zone *z_ptr, u32 addr, u32 ref)
+struct node *tipc_zone_select_remote_node(struct _zone *z_ptr, u32 addr, u32 ref)
 {
        struct cluster *c_ptr;
        struct node *n_ptr;
@@ -118,7 +118,7 @@ struct node *zone_select_remote_node(struct _zone *z_ptr, u32 addr, u32 ref)
        c_ptr = z_ptr->clusters[tipc_cluster(addr)];
        if (!c_ptr)
                return 0;
-        n_ptr = cluster_select_node(c_ptr, ref);
+        n_ptr = tipc_cltr_select_node(c_ptr, ref);
        if (n_ptr)
                return n_ptr;
@@ -127,14 +127,14 @@ struct node *zone_select_remote_node(struct _zone *z_ptr, u32 addr, u32 ref)
                c_ptr = z_ptr->clusters[c_num];
                if (!c_ptr)
                        return 0;
-                n_ptr = cluster_select_node(c_ptr, ref);
+                n_ptr = tipc_cltr_select_node(c_ptr, ref);
                if (n_ptr)
                        return n_ptr;
        }
        return 0;
 }
-u32 zone_select_router(struct _zone *z_ptr, u32 addr, u32 ref)
+u32 tipc_zone_select_router(struct _zone *z_ptr, u32 addr, u32 ref)
 {
        struct cluster *c_ptr;
        u32 c_num;
@@ -143,14 +143,14 @@ u32 zone_select_router(struct _zone *z_ptr, u32 addr, u32 ref)
        if (!z_ptr)
                return 0;
        c_ptr = z_ptr->clusters[tipc_cluster(addr)];
-        router = c_ptr ? cluster_select_router(c_ptr, ref) : 0;
+        router = c_ptr ? tipc_cltr_select_router(c_ptr, ref) : 0;
        if (router)
                return router;
        /* Links to any other clusters within the zone? */
        for (c_num = 1; c_num <= tipc_max_clusters; c_num++) {
                c_ptr = z_ptr->clusters[c_num];
-                router = c_ptr ? cluster_select_router(c_ptr, ref) : 0;
+                router = c_ptr ? tipc_cltr_select_router(c_ptr, ref) : 0;
                if (router)
                        return router;
        }
@@ -158,12 +158,12 @@ u32 zone_select_router(struct _zone *z_ptr, u32 addr, u32 ref)
 }
-u32 zone_next_node(u32 addr)
+u32 tipc_zone_next_node(u32 addr)
 {
-        struct cluster *c_ptr = cluster_find(addr);
+        struct cluster *c_ptr = tipc_cltr_find(addr);
        if (c_ptr)
-                return cluster_next_node(c_ptr, addr);
+                return tipc_cltr_next_node(c_ptr, addr);
        return 0;
 }
diff --git a/net/tipc/zone.h b/net/tipc/zone.h
index 4326f78d8292..267999c5a240 100644
--- a/net/tipc/zone.h
+++ b/net/tipc/zone.h
@@ -54,18 +54,18 @@ struct _zone {
        u32 links;
 };
-struct node *zone_select_remote_node(struct _zone *z_ptr, u32 addr, u32 ref);
+struct node *tipc_zone_select_remote_node(struct _zone *z_ptr, u32 addr, u32 ref);
-u32 zone_select_router(struct _zone *z_ptr, u32 addr, u32 ref);
+u32 tipc_zone_select_router(struct _zone *z_ptr, u32 addr, u32 ref);
-void zone_remove_as_router(struct _zone *z_ptr, u32 router);
+void tipc_zone_remove_as_router(struct _zone *z_ptr, u32 router);
-void zone_send_external_routes(struct _zone *z_ptr, u32 dest);
+void tipc_zone_send_external_routes(struct _zone *z_ptr, u32 dest);
-struct _zone *zone_create(u32 addr);
+struct _zone *tipc_zone_create(u32 addr);
-void zone_delete(struct _zone *z_ptr);
+void tipc_zone_delete(struct _zone *z_ptr);
-void zone_attach_cluster(struct _zone *z_ptr, struct cluster *c_ptr);
+void tipc_zone_attach_cluster(struct _zone *z_ptr, struct cluster *c_ptr);
-u32 zone_next_node(u32 addr);
+u32 tipc_zone_next_node(u32 addr);
-static inline struct _zone *zone_find(u32 addr)
+static inline struct _zone *tipc_zone_find(u32 addr)
 {
-        return net.zones[tipc_zone(addr)];
+        return tipc_net.zones[tipc_zone(addr)];
 }
 #endif