list_add_tail_rcu
        list_del_rcu
        list_replace_rcu
-       hlist_add_after_rcu
+       hlist_add_behind_rcu
        hlist_add_before_rcu
        hlist_add_head_rcu
        hlist_del_rcu
 
                parent = &entry->head;
        }
        if (parent) {
-               hlist_add_after_rcu(parent, &item->head);
+               hlist_add_behind_rcu(&item->head, parent);
        } else {
                hlist_add_head_rcu(&item->head, h_list);
        }
 
 
        /* add filter to the list */
        if (parent)
-               hlist_add_after(&parent->fdir_node, &input->fdir_node);
+               hlist_add_behind(&input->fdir_node, &parent->fdir_node);
        else
                hlist_add_head(&input->fdir_node,
                               &pf->fdir_filter_list);
 
 
        /* add filter to the list */
        if (parent)
-               hlist_add_after(&parent->fdir_node, &input->fdir_node);
+               hlist_add_behind(&input->fdir_node, &parent->fdir_node);
        else
                hlist_add_head(&input->fdir_node,
                               &adapter->fdir_filter_list);
 
                                            cfs_hash_dhead_t, dh_head);
 
        if (dh->dh_tail != NULL) /* not empty */
-               hlist_add_after(dh->dh_tail, hnode);
+               hlist_add_behind(hnode, dh->dh_tail);
        else /* empty list */
                hlist_add_head(hnode, &dh->dh_head);
        dh->dh_tail = hnode;
                                                cfs_hash_dhead_dep_t, dd_head);
 
        if (dh->dd_tail != NULL) /* not empty */
-               hlist_add_after(dh->dd_tail, hnode);
+               hlist_add_behind(hnode, dh->dd_tail);
        else /* empty list */
                hlist_add_head(hnode, &dh->dd_head);
        dh->dd_tail = hnode;
 
        list_splice(&head, n->list.prev);
 
        if (shadows)
-               hlist_add_after_rcu(&shadows->mnt_hash, &mnt->mnt_hash);
+               hlist_add_behind_rcu(&mnt->mnt_hash, &shadows->mnt_hash);
        else
                hlist_add_head_rcu(&mnt->mnt_hash,
                                m_hash(&parent->mnt, mnt->mnt_mountpoint));
 
 
        BUG_ON(last == NULL);
        /* mark should be the last entry.  last is the current last entry */
-       hlist_add_after_rcu(&last->i.i_list, &mark->i.i_list);
+       hlist_add_behind_rcu(&mark->i.i_list, &last->i.i_list);
 out:
        fsnotify_recalc_inode_mask_locked(inode);
        spin_unlock(&inode->i_lock);
 
 
        BUG_ON(last == NULL);
        /* mark should be the last entry.  last is the current last entry */
-       hlist_add_after_rcu(&last->m.m_list, &mark->m.m_list);
+       hlist_add_behind_rcu(&mark->m.m_list, &last->m.m_list);
 out:
        fsnotify_recalc_vfsmount_mask_locked(mnt);
        spin_unlock(&mnt->mnt_root->d_lock);
 
        *(n->pprev) = n;
 }
 
-static inline void hlist_add_after(struct hlist_node *prev,
-                                  struct hlist_node *n)
+static inline void hlist_add_behind(struct hlist_node *n,
+                                   struct hlist_node *prev)
 {
        n->next = prev->next;
        prev->next = n;
 
 }
 
 /**
- * hlist_add_after_rcu
- * @prev: the existing element to add the new element after.
+ * hlist_add_behind_rcu
  * @n: the new element to add to the hash list.
+ * @prev: the existing element to add the new element after.
  *
  * Description:
  * Adds the specified element to the specified hlist
  * hlist_for_each_entry_rcu(), used to prevent memory-consistency
  * problems on Alpha CPUs.
  */
-static inline void hlist_add_after_rcu(struct hlist_node *prev,
-                                      struct hlist_node *n)
+static inline void hlist_add_behind_rcu(struct hlist_node *n,
+                                       struct hlist_node *prev)
 {
        n->next = prev->next;
        n->pprev = &prev->next;
 
 
        /* Reached the end of the list, so insert after 'frag_entry_last'. */
        if (likely(frag_entry_last)) {
-               hlist_add_after(&frag_entry_last->list, &frag_entry_new->list);
+               hlist_add_behind(&frag_entry_last->list, &frag_entry_new->list);
                chain->size += skb->len - hdr_size;
                chain->timestamp = jiffies;
                ret = true;
 
        }
 
        if (slot)
-               hlist_add_after_rcu(slot, &port->rlist);
+               hlist_add_behind_rcu(&port->rlist, slot);
        else
                hlist_add_head_rcu(&port->rlist, &br->router_list);
 }
 
                        last = li;
                }
                if (last)
-                       hlist_add_after_rcu(&last->hlist, &new->hlist);
+                       hlist_add_behind_rcu(&new->hlist, &last->hlist);
                else
                        hlist_add_before_rcu(&new->hlist, &li->hlist);
        }
 
                last = p;
        }
        if (last)
-               hlist_add_after_rcu(&last->list, &newp->list);
+               hlist_add_behind_rcu(&newp->list, &last->list);
        else
                hlist_add_head_rcu(&newp->list, &ip6addrlbl_table.head);
 out:
 
                        if (h != h0)
                                continue;
                        hlist_del(&pol->bydst);
-                       hlist_add_after(entry0, &pol->bydst);
+                       hlist_add_behind(&pol->bydst, entry0);
                }
                entry0 = &pol->bydst;
        }
                        break;
        }
        if (newpos)
-               hlist_add_after(newpos, &policy->bydst);
+               hlist_add_behind(&policy->bydst, newpos);
        else
                hlist_add_head(&policy->bydst, chain);
        xfrm_pol_hold(policy);