6 files changed, 133 insertions, 133 deletions

diff --git a/net/tipc/bearer.c b/net/tipc/bearer.c
index 648f2a67f314..802ffad3200d 100644
--- a/net/tipc/bearer.c
+++ b/net/tipc/bearer.c
@@ -71,7 +71,7 @@ static const struct nla_policy tipc_nl_media_policy[TIPC_NLA_MEDIA_MAX + 1] = {
         [TIPC_NLA_MEDIA_PROP]           = { .type = NLA_NESTED }
 };
 
-static void bearer_disable(struct net *net, struct tipc_bearer *b_ptr);
+static void bearer_disable(struct net *net, struct tipc_bearer *b);
 
 /**
  * tipc_media_find - locates specified media object by name
@@ -107,13 +107,13 @@ static struct tipc_media *media_find_id(u8 type)
 void tipc_media_addr_printf(char *buf, int len, struct tipc_media_addr *a)
 {
         char addr_str[MAX_ADDR_STR];
-        struct tipc_media *m_ptr;
+        struct tipc_media *m;
         int ret;
 
-        m_ptr = media_find_id(a->media_id);
+        m = media_find_id(a->media_id);
 
-        if (m_ptr && !m_ptr->addr2str(a, addr_str, sizeof(addr_str)))
-                ret = scnprintf(buf, len, "%s(%s)", m_ptr->name, addr_str);
+        if (m && !m->addr2str(a, addr_str, sizeof(addr_str)))
+                ret = scnprintf(buf, len, "%s(%s)", m->name, addr_str);
         else {
                 u32 i;
 
@@ -175,13 +175,13 @@ static int bearer_name_validate(const char *name,
 struct tipc_bearer *tipc_bearer_find(struct net *net, const char *name)
 {
         struct tipc_net *tn = net_generic(net, tipc_net_id);
-        struct tipc_bearer *b_ptr;
+        struct tipc_bearer *b;
         u32 i;
 
         for (i = 0; i < MAX_BEARERS; i++) {
-                b_ptr = rtnl_dereference(tn->bearer_list[i]);
-                if (b_ptr && (!strcmp(b_ptr->name, name)))
-                        return b_ptr;
+                b = rtnl_dereference(tn->bearer_list[i]);
+                if (b && (!strcmp(b->name, name)))
+                        return b;
         }
         return NULL;
 }
@@ -189,24 +189,24 @@ struct tipc_bearer *tipc_bearer_find(struct net *net, const char *name)
 void tipc_bearer_add_dest(struct net *net, u32 bearer_id, u32 dest)
 {
         struct tipc_net *tn = net_generic(net, tipc_net_id);
-        struct tipc_bearer *b_ptr;
+        struct tipc_bearer *b;
 
         rcu_read_lock();
-        b_ptr = rcu_dereference_rtnl(tn->bearer_list[bearer_id]);
-        if (b_ptr)
-                tipc_disc_add_dest(b_ptr->link_req);
+        b = rcu_dereference_rtnl(tn->bearer_list[bearer_id]);
+        if (b)
+                tipc_disc_add_dest(b->link_req);
         rcu_read_unlock();
 }
 
 void tipc_bearer_remove_dest(struct net *net, u32 bearer_id, u32 dest)
 {
         struct tipc_net *tn = net_generic(net, tipc_net_id);
-        struct tipc_bearer *b_ptr;
+        struct tipc_bearer *b;
 
         rcu_read_lock();
-        b_ptr = rcu_dereference_rtnl(tn->bearer_list[bearer_id]);
-        if (b_ptr)
-                tipc_disc_remove_dest(b_ptr->link_req);
+        b = rcu_dereference_rtnl(tn->bearer_list[bearer_id]);
+        if (b)
+                tipc_disc_remove_dest(b->link_req);
         rcu_read_unlock();
 }
 
@@ -218,8 +218,8 @@ static int tipc_enable_bearer(struct net *net, const char *name,
                               struct nlattr *attr[])
 {
         struct tipc_net *tn = net_generic(net, tipc_net_id);
-        struct tipc_bearer *b_ptr;
-        struct tipc_media *m_ptr;
+        struct tipc_bearer *b;
+        struct tipc_media *m;
         struct tipc_bearer_names b_names;
         char addr_string[16];
         u32 bearer_id;
@@ -255,31 +255,31 @@ static int tipc_enable_bearer(struct net *net, const char *name,
                 return -EINVAL;
         }
 
-        m_ptr = tipc_media_find(b_names.media_name);
-        if (!m_ptr) {
+        m = tipc_media_find(b_names.media_name);
+        if (!m) {
                 pr_warn("Bearer <%s> rejected, media <%s> not registered\n",
                         name, b_names.media_name);
                 return -EINVAL;
         }
 
         if (priority == TIPC_MEDIA_LINK_PRI)
-                priority = m_ptr->priority;
+                priority = m->priority;
 
 restart:
         bearer_id = MAX_BEARERS;
         with_this_prio = 1;
         for (i = MAX_BEARERS; i-- != 0; ) {
-                b_ptr = rtnl_dereference(tn->bearer_list[i]);
-                if (!b_ptr) {
+                b = rtnl_dereference(tn->bearer_list[i]);
+                if (!b) {
                         bearer_id = i;
                         continue;
                 }
-                if (!strcmp(name, b_ptr->name)) {
+                if (!strcmp(name, b->name)) {
                         pr_warn("Bearer <%s> rejected, already enabled\n",
                                 name);
                         return -EINVAL;
                 }
-                if ((b_ptr->priority == priority) &&
+                if ((b->priority == priority) &&
                     (++with_this_prio > 2)) {
                         if (priority-- == 0) {
                                 pr_warn("Bearer <%s> rejected, duplicate priority\n",
@@ -297,35 +297,35 @@ restart:
                 return -EINVAL;
         }
 
-        b_ptr = kzalloc(sizeof(*b_ptr), GFP_ATOMIC);
-        if (!b_ptr)
+        b = kzalloc(sizeof(*b), GFP_ATOMIC);
+        if (!b)
                 return -ENOMEM;
 
-        strcpy(b_ptr->name, name);
-        b_ptr->media = m_ptr;
-        res = m_ptr->enable_media(net, b_ptr, attr);
+        strcpy(b->name, name);
+        b->media = m;
+        res = m->enable_media(net, b, attr);
         if (res) {
                 pr_warn("Bearer <%s> rejected, enable failure (%d)\n",
                         name, -res);
                 return -EINVAL;
         }
 
-        b_ptr->identity = bearer_id;
-        b_ptr->tolerance = m_ptr->tolerance;
-        b_ptr->window = m_ptr->window;
-        b_ptr->domain = disc_domain;
-        b_ptr->net_plane = bearer_id + 'A';
-        b_ptr->priority = priority;
+        b->identity = bearer_id;
+        b->tolerance = m->tolerance;
+        b->window = m->window;
+        b->domain = disc_domain;
+        b->net_plane = bearer_id + 'A';
+        b->priority = priority;
 
-        res = tipc_disc_create(net, b_ptr, &b_ptr->bcast_addr);
+        res = tipc_disc_create(net, b, &b->bcast_addr);
         if (res) {
-                bearer_disable(net, b_ptr);
+                bearer_disable(net, b);
                 pr_warn("Bearer <%s> rejected, discovery object creation failed\n",
                         name);
                 return -EINVAL;
         }
 
-        rcu_assign_pointer(tn->bearer_list[bearer_id], b_ptr);
+        rcu_assign_pointer(tn->bearer_list[bearer_id], b);
 
         pr_info("Enabled bearer <%s>, discovery domain %s, priority %u\n",
                 name,
@@ -336,11 +336,11 @@ restart:
 /**
  * tipc_reset_bearer - Reset all links established over this bearer
  */
-static int tipc_reset_bearer(struct net *net, struct tipc_bearer *b_ptr)
+static int tipc_reset_bearer(struct net *net, struct tipc_bearer *b)
 {
-        pr_info("Resetting bearer <%s>\n", b_ptr->name);
-        tipc_node_delete_links(net, b_ptr->identity);
-        tipc_disc_reset(net, b_ptr);
+        pr_info("Resetting bearer <%s>\n", b->name);
+        tipc_node_delete_links(net, b->identity);
+        tipc_disc_reset(net, b);
         return 0;
 }
 
@@ -349,26 +349,26 @@ static int tipc_reset_bearer(struct net *net, struct tipc_bearer *b_ptr)
  *
  * Note: This routine assumes caller holds RTNL lock.
  */
-static void bearer_disable(struct net *net, struct tipc_bearer *b_ptr)
+static void bearer_disable(struct net *net, struct tipc_bearer *b)
 {
         struct tipc_net *tn = net_generic(net, tipc_net_id);
         u32 i;
 
-        pr_info("Disabling bearer <%s>\n", b_ptr->name);
-        b_ptr->media->disable_media(b_ptr);
+        pr_info("Disabling bearer <%s>\n", b->name);
+        b->media->disable_media(b);
 
-        tipc_node_delete_links(net, b_ptr->identity);
-        RCU_INIT_POINTER(b_ptr->media_ptr, NULL);
-        if (b_ptr->link_req)
-                tipc_disc_delete(b_ptr->link_req);
+        tipc_node_delete_links(net, b->identity);
+        RCU_INIT_POINTER(b->media_ptr, NULL);
+        if (b->link_req)
+                tipc_disc_delete(b->link_req);
 
         for (i = 0; i < MAX_BEARERS; i++) {
-                if (b_ptr == rtnl_dereference(tn->bearer_list[i])) {
+                if (b == rtnl_dereference(tn->bearer_list[i])) {
                         RCU_INIT_POINTER(tn->bearer_list[i], NULL);
                         break;
                 }
         }
-        kfree_rcu(b_ptr, rcu);
+        kfree_rcu(b, rcu);
 }
 
 int tipc_enable_l2_media(struct net *net, struct tipc_bearer *b,
@@ -411,7 +411,7 @@ void tipc_disable_l2_media(struct tipc_bearer *b)
 /**
  * tipc_l2_send_msg - send a TIPC packet out over an L2 interface
  * @buf: the packet to be sent
- * @b_ptr: the bearer through which the packet is to be sent
+ * @b: the bearer through which the packet is to be sent
  * @dest: peer destination address
  */
 int tipc_l2_send_msg(struct net *net, struct sk_buff *skb,
@@ -532,14 +532,14 @@ void tipc_bearer_bc_xmit(struct net *net, u32 bearer_id,
 static int tipc_l2_rcv_msg(struct sk_buff *buf, struct net_device *dev,
                            struct packet_type *pt, struct net_device *orig_dev)
 {
-        struct tipc_bearer *b_ptr;
+        struct tipc_bearer *b;
 
         rcu_read_lock();
-        b_ptr = rcu_dereference_rtnl(dev->tipc_ptr);
-        if (likely(b_ptr)) {
+        b = rcu_dereference_rtnl(dev->tipc_ptr);
+        if (likely(b)) {
                 if (likely(buf->pkt_type <= PACKET_BROADCAST)) {
                         buf->next = NULL;
-                        tipc_rcv(dev_net(dev), buf, b_ptr);
+                        tipc_rcv(dev_net(dev), buf, b);
                         rcu_read_unlock();
                         return NET_RX_SUCCESS;
                 }
@@ -564,13 +564,13 @@ static int tipc_l2_device_event(struct notifier_block *nb, unsigned long evt,
 {
         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
         struct net *net = dev_net(dev);
-        struct tipc_bearer *b_ptr;
+        struct tipc_bearer *b;
 
-        b_ptr = rtnl_dereference(dev->tipc_ptr);
-        if (!b_ptr)
+        b = rtnl_dereference(dev->tipc_ptr);
+        if (!b)
                 return NOTIFY_DONE;
 
-        b_ptr->mtu = dev->mtu;
+        b->mtu = dev->mtu;
 
         switch (evt) {
         case NETDEV_CHANGE:
@@ -578,16 +578,16 @@ static int tipc_l2_device_event(struct notifier_block *nb, unsigned long evt,
                         break;
         case NETDEV_GOING_DOWN:
         case NETDEV_CHANGEMTU:
-                tipc_reset_bearer(net, b_ptr);
+                tipc_reset_bearer(net, b);
                 break;
         case NETDEV_CHANGEADDR:
-                b_ptr->media->raw2addr(b_ptr, &b_ptr->addr,
+                b->media->raw2addr(b, &b->addr,
                                        (char *)dev->dev_addr);
-                tipc_reset_bearer(net, b_ptr);
+                tipc_reset_bearer(net, b);
                 break;
         case NETDEV_UNREGISTER:
         case NETDEV_CHANGENAME:
-                bearer_disable(dev_net(dev), b_ptr);
+                bearer_disable(dev_net(dev), b);
                 break;
         }
         return NOTIFY_OK;
@@ -623,13 +623,13 @@ void tipc_bearer_cleanup(void)
 void tipc_bearer_stop(struct net *net)
 {
         struct tipc_net *tn = net_generic(net, tipc_net_id);
-        struct tipc_bearer *b_ptr;
+        struct tipc_bearer *b;
         u32 i;
 
         for (i = 0; i < MAX_BEARERS; i++) {
-                b_ptr = rtnl_dereference(tn->bearer_list[i]);
-                if (b_ptr) {
-                        bearer_disable(net, b_ptr);
+                b = rtnl_dereference(tn->bearer_list[i]);
+                if (b) {
+                        bearer_disable(net, b);
                         tn->bearer_list[i] = NULL;
                 }
         }
diff --git a/net/tipc/bearer.h b/net/tipc/bearer.h
index 552185bc4773..e31820516774 100644
--- a/net/tipc/bearer.h
+++ b/net/tipc/bearer.h
@@ -103,11 +103,11 @@ struct tipc_bearer;
  */
 struct tipc_media {
         int (*send_msg)(struct net *net, struct sk_buff *buf,
-                        struct tipc_bearer *b_ptr,
+                        struct tipc_bearer *b,
                         struct tipc_media_addr *dest);
-        int (*enable_media)(struct net *net, struct tipc_bearer *b_ptr,
+        int (*enable_media)(struct net *net, struct tipc_bearer *b,
                             struct nlattr *attr[]);
-        void (*disable_media)(struct tipc_bearer *b_ptr);
+        void (*disable_media)(struct tipc_bearer *b);
         int (*addr2str)(struct tipc_media_addr *addr,
                         char *strbuf,
                         int bufsz);
@@ -176,7 +176,7 @@ struct tipc_bearer_names {
  * TIPC routines available to supported media types
  */
 
-void tipc_rcv(struct net *net, struct sk_buff *skb, struct tipc_bearer *b_ptr);
+void tipc_rcv(struct net *net, struct sk_buff *skb, struct tipc_bearer *b);
 
 /*
  * Routines made available to TIPC by supported media types
diff --git a/net/tipc/discover.c b/net/tipc/discover.c
index afe8c47c4085..f1e738e80535 100644
--- a/net/tipc/discover.c
+++ b/net/tipc/discover.c
@@ -75,14 +75,14 @@ struct tipc_link_req {
  * tipc_disc_init_msg - initialize a link setup message
  * @net: the applicable net namespace
  * @type: message type (request or response)
- * @b_ptr: ptr to bearer issuing message
+ * @b: ptr to bearer issuing message
  */
 static void tipc_disc_init_msg(struct net *net, struct sk_buff *buf, u32 type,
-                               struct tipc_bearer *b_ptr)
+                               struct tipc_bearer *b)
 {
         struct tipc_net *tn = net_generic(net, tipc_net_id);
         struct tipc_msg *msg;
-        u32 dest_domain = b_ptr->domain;
+        u32 dest_domain = b->domain;
 
         msg = buf_msg(buf);
         tipc_msg_init(tn->own_addr, msg, LINK_CONFIG, type,
@@ -92,16 +92,16 @@ static void tipc_disc_init_msg(struct net *net, struct sk_buff *buf, u32 type,
         msg_set_node_capabilities(msg, TIPC_NODE_CAPABILITIES);
         msg_set_dest_domain(msg, dest_domain);
         msg_set_bc_netid(msg, tn->net_id);
-        b_ptr->media->addr2msg(msg_media_addr(msg), &b_ptr->addr);
+        b->media->addr2msg(msg_media_addr(msg), &b->addr);
 }
 
 /**
  * disc_dupl_alert - issue node address duplication alert
- * @b_ptr: pointer to bearer detecting duplication
+ * @b: pointer to bearer detecting duplication
  * @node_addr: duplicated node address
  * @media_addr: media address advertised by duplicated node
  */
-static void disc_dupl_alert(struct tipc_bearer *b_ptr, u32 node_addr,
+static void disc_dupl_alert(struct tipc_bearer *b, u32 node_addr,
                             struct tipc_media_addr *media_addr)
 {
         char node_addr_str[16];
@@ -111,7 +111,7 @@ static void disc_dupl_alert(struct tipc_bearer *b_ptr, u32 node_addr,
         tipc_media_addr_printf(media_addr_str, sizeof(media_addr_str),
                                media_addr);
         pr_warn("Duplicate %s using %s seen on <%s>\n", node_addr_str,
-                media_addr_str, b_ptr->name);
+                media_addr_str, b->name);
 }
 
 /**
@@ -261,13 +261,13 @@ exit:
 /**
  * tipc_disc_create - create object to send periodic link setup requests
  * @net: the applicable net namespace
- * @b_ptr: ptr to bearer issuing requests
+ * @b: ptr to bearer issuing requests
  * @dest: destination address for request messages
  * @dest_domain: network domain to which links can be established
  *
  * Returns 0 if successful, otherwise -errno.
  */
-int tipc_disc_create(struct net *net, struct tipc_bearer *b_ptr,
+int tipc_disc_create(struct net *net, struct tipc_bearer *b,
                      struct tipc_media_addr *dest)
 {
         struct tipc_link_req *req;
@@ -282,17 +282,17 @@ int tipc_disc_create(struct net *net, struct tipc_bearer *b_ptr,
                 return -ENOMEM;
         }
 
-        tipc_disc_init_msg(net, req->buf, DSC_REQ_MSG, b_ptr);
+        tipc_disc_init_msg(net, req->buf, DSC_REQ_MSG, b);
         memcpy(&req->dest, dest, sizeof(*dest));
         req->net = net;
-        req->bearer_id = b_ptr->identity;
-        req->domain = b_ptr->domain;
+        req->bearer_id = b->identity;
+        req->domain = b->domain;
         req->num_nodes = 0;
         req->timer_intv = TIPC_LINK_REQ_INIT;
         spin_lock_init(&req->lock);
         setup_timer(&req->timer, disc_timeout, (unsigned long)req);
         mod_timer(&req->timer, jiffies + req->timer_intv);
-        b_ptr->link_req = req;
+        b->link_req = req;
         skb = skb_clone(req->buf, GFP_ATOMIC);
         if (skb)
                 tipc_bearer_xmit_skb(net, req->bearer_id, skb, &req->dest);
@@ -313,19 +313,19 @@ void tipc_disc_delete(struct tipc_link_req *req)
 /**
  * tipc_disc_reset - reset object to send periodic link setup requests
  * @net: the applicable net namespace
- * @b_ptr: ptr to bearer issuing requests
+ * @b: ptr to bearer issuing requests
  * @dest_domain: network domain to which links can be established
  */
-void tipc_disc_reset(struct net *net, struct tipc_bearer *b_ptr)
+void tipc_disc_reset(struct net *net, struct tipc_bearer *b)
 {
-        struct tipc_link_req *req = b_ptr->link_req;
+        struct tipc_link_req *req = b->link_req;
         struct sk_buff *skb;
 
         spin_lock_bh(&req->lock);
-        tipc_disc_init_msg(net, req->buf, DSC_REQ_MSG, b_ptr);
+        tipc_disc_init_msg(net, req->buf, DSC_REQ_MSG, b);
         req->net = net;
-        req->bearer_id = b_ptr->identity;
-        req->domain = b_ptr->domain;
+        req->bearer_id = b->identity;
+        req->domain = b->domain;
         req->num_nodes = 0;
         req->timer_intv = TIPC_LINK_REQ_INIT;
         mod_timer(&req->timer, jiffies + req->timer_intv);
diff --git a/net/tipc/link.c b/net/tipc/link.c
index 4380eb119796..b11afe71dfc1 100644
--- a/net/tipc/link.c
+++ b/net/tipc/link.c
@@ -245,7 +245,7 @@ static int tipc_link_proto_rcv(struct tipc_link *l, struct sk_buff *skb,
 static void tipc_link_build_proto_msg(struct tipc_link *l, int mtyp, bool probe,
                                       u16 rcvgap, int tolerance, int priority,
                                       struct sk_buff_head *xmitq);
-static void link_print(struct tipc_link *l_ptr, const char *str);
+static void link_print(struct tipc_link *l, const char *str);
 static void tipc_link_build_nack_msg(struct tipc_link *l,
                                      struct sk_buff_head *xmitq);
 static void tipc_link_build_bc_init_msg(struct tipc_link *l,
@@ -1707,7 +1707,7 @@ void tipc_link_set_queue_limits(struct tipc_link *l, u32 win)
 
 /**
  * link_reset_stats - reset link statistics
- * @l_ptr: pointer to link
+ * @l: pointer to link
  */
 void tipc_link_reset_stats(struct tipc_link *l)
 {
diff --git a/net/tipc/link.h b/net/tipc/link.h
index 616fc808f23a..b2ae0f4276af 100644
--- a/net/tipc/link.h
+++ b/net/tipc/link.h
@@ -99,7 +99,7 @@ bool tipc_link_is_synching(struct tipc_link *l);
 bool tipc_link_is_failingover(struct tipc_link *l);
 bool tipc_link_is_blocked(struct tipc_link *l);
 void tipc_link_set_active(struct tipc_link *l, bool active);
-void tipc_link_reset(struct tipc_link *l_ptr);
+void tipc_link_reset(struct tipc_link *l);
 void tipc_link_reset_stats(struct tipc_link *l);
 int tipc_link_xmit(struct tipc_link *link, struct sk_buff_head *list,
                    struct sk_buff_head *xmitq);
diff --git a/net/tipc/node.c b/net/tipc/node.c
index 82c05e9dd0ee..3f7a4ed71990 100644
--- a/net/tipc/node.c
+++ b/net/tipc/node.c
@@ -319,62 +319,62 @@ static void tipc_node_write_unlock(struct tipc_node *n)
 struct tipc_node *tipc_node_create(struct net *net, u32 addr, u16 capabilities)
 {
         struct tipc_net *tn = net_generic(net, tipc_net_id);
-        struct tipc_node *n_ptr, *temp_node;
+        struct tipc_node *n, *temp_node;
         int i;
 
         spin_lock_bh(&tn->node_list_lock);
-        n_ptr = tipc_node_find(net, addr);
-        if (n_ptr)
+        n = tipc_node_find(net, addr);
+        if (n)
                 goto exit;
-        n_ptr = kzalloc(sizeof(*n_ptr), GFP_ATOMIC);
-        if (!n_ptr) {
+        n = kzalloc(sizeof(*n), GFP_ATOMIC);
+        if (!n) {
                 pr_warn("Node creation failed, no memory\n");
                 goto exit;
         }
-        n_ptr->addr = addr;
-        n_ptr->net = net;
-        n_ptr->capabilities = capabilities;
-        kref_init(&n_ptr->kref);
-        rwlock_init(&n_ptr->lock);
-        INIT_HLIST_NODE(&n_ptr->hash);
-        INIT_LIST_HEAD(&n_ptr->list);
-        INIT_LIST_HEAD(&n_ptr->publ_list);
-        INIT_LIST_HEAD(&n_ptr->conn_sks);
-        skb_queue_head_init(&n_ptr->bc_entry.namedq);
-        skb_queue_head_init(&n_ptr->bc_entry.inputq1);
-        __skb_queue_head_init(&n_ptr->bc_entry.arrvq);
-        skb_queue_head_init(&n_ptr->bc_entry.inputq2);
+        n->addr = addr;
+        n->net = net;
+        n->capabilities = capabilities;
+        kref_init(&n->kref);
+        rwlock_init(&n->lock);
+        INIT_HLIST_NODE(&n->hash);
+        INIT_LIST_HEAD(&n->list);
+        INIT_LIST_HEAD(&n->publ_list);
+        INIT_LIST_HEAD(&n->conn_sks);
+        skb_queue_head_init(&n->bc_entry.namedq);
+        skb_queue_head_init(&n->bc_entry.inputq1);
+        __skb_queue_head_init(&n->bc_entry.arrvq);
+        skb_queue_head_init(&n->bc_entry.inputq2);
         for (i = 0; i < MAX_BEARERS; i++)
-                spin_lock_init(&n_ptr->links[i].lock);
-        hlist_add_head_rcu(&n_ptr->hash, &tn->node_htable[tipc_hashfn(addr)]);
+                spin_lock_init(&n->links[i].lock);
+        hlist_add_head_rcu(&n->hash, &tn->node_htable[tipc_hashfn(addr)]);
         list_for_each_entry_rcu(temp_node, &tn->node_list, list) {
-                if (n_ptr->addr < temp_node->addr)
+                if (n->addr < temp_node->addr)
                         break;
         }
-        list_add_tail_rcu(&n_ptr->list, &temp_node->list);
-        n_ptr->state = SELF_DOWN_PEER_LEAVING;
-        n_ptr->signature = INVALID_NODE_SIG;
-        n_ptr->active_links[0] = INVALID_BEARER_ID;
-        n_ptr->active_links[1] = INVALID_BEARER_ID;
-        if (!tipc_link_bc_create(net, tipc_own_addr(net), n_ptr->addr,
+        list_add_tail_rcu(&n->list, &temp_node->list);
+        n->state = SELF_DOWN_PEER_LEAVING;
+        n->signature = INVALID_NODE_SIG;
+        n->active_links[0] = INVALID_BEARER_ID;
+        n->active_links[1] = INVALID_BEARER_ID;
+        if (!tipc_link_bc_create(net, tipc_own_addr(net), n->addr,
                                  U16_MAX,
                                  tipc_link_window(tipc_bc_sndlink(net)),
-                                 n_ptr->capabilities,
-                                 &n_ptr->bc_entry.inputq1,
-                                 &n_ptr->bc_entry.namedq,
+                                 n->capabilities,
+                                 &n->bc_entry.inputq1,
+                                 &n->bc_entry.namedq,
                                  tipc_bc_sndlink(net),
-                                 &n_ptr->bc_entry.link)) {
+                                 &n->bc_entry.link)) {
                 pr_warn("Broadcast rcv link creation failed, no memory\n");
-                kfree(n_ptr);
-                n_ptr = NULL;
+                kfree(n);
+                n = NULL;
                 goto exit;
         }
-        tipc_node_get(n_ptr);
-        setup_timer(&n_ptr->timer, tipc_node_timeout, (unsigned long)n_ptr);
-        n_ptr->keepalive_intv = U32_MAX;
+        tipc_node_get(n);
+        setup_timer(&n->timer, tipc_node_timeout, (unsigned long)n);
+        n->keepalive_intv = U32_MAX;
 exit:
         spin_unlock_bh(&tn->node_list_lock);
-        return n_ptr;
+        return n;
 }
 
 static void tipc_node_calculate_timer(struct tipc_node *n, struct tipc_link *l)