Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next

Pull networking updates from David Miller:
 "Here is my initial pull request for the networking subsystem during
  this merge window:

   1) Support for ESN in AH (RFC 4302) from Fan Du.

   2) Add full kernel doc for ethtool command structures, from Ben
      Hutchings.

   3) Add BCM7xxx PHY driver, from Florian Fainelli.

   4) Export computed TCP rate information in netlink socket dumps, from
      Eric Dumazet.

   5) Allow IPSEC SA to be dumped partially using a filter, from Nicolas
      Dichtel.

   6) Convert many drivers to pci_enable_msix_range(), from Alexander
      Gordeev.

   7) Record SKB timestamps more efficiently, from Eric Dumazet.

   8) Switch to microsecond resolution for TCP round trip times, also
      from Eric Dumazet.

   9) Clean up and fix 6lowpan fragmentation handling by making use of
      the existing inet_frag api for it's implementation.

  10) Add TX grant mapping to xen-netback driver, from Zoltan Kiss.

  11) Auto size SKB lengths when composing netlink messages based upon
      past message sizes used, from Eric Dumazet.

  12) qdisc dumps can take a long time, add a cond_resched(), From Eric
      Dumazet.

  13) Sanitize netpoll core and drivers wrt.  SKB handling semantics.
      Get rid of never-used-in-tree netpoll RX handling.  From Eric W
      Biederman.

  14) Support inter-address-family and namespace changing in VTI tunnel
      driver(s).  From Steffen Klassert.

  15) Add Altera TSE driver, from Vince Bridgers.

  16) Optimizing csum_replace2() so that it doesn't adjust the checksum
      by checksumming the entire header, from Eric Dumazet.

  17) Expand BPF internal implementation for faster interpreting, more
      direct translations into JIT'd code, and much cleaner uses of BPF
      filtering in non-socket ocntexts.  From Daniel Borkmann and Alexei
      Starovoitov"

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next: (1976 commits)
  netpoll: Use skb_irq_freeable to make zap_completion_queue safe.
  net: Add a test to see if a skb is freeable in irq context
  qlcnic: Fix build failure due to undefined reference to `vxlan_get_rx_port'
  net: ptp: move PTP classifier in its own file
  net: sxgbe: make "core_ops" static
  net: sxgbe: fix logical vs bitwise operation
  net: sxgbe: sxgbe_mdio_register() frees the bus
  Call efx_set_channels() before efx->type->dimension_resources()
  xen-netback: disable rogue vif in kthread context
  net/mlx4: Set proper build dependancy with vxlan
  be2net: fix build dependency on VxLAN
  mac802154: make csma/cca parameters per-wpan
  mac802154: allow only one WPAN to be up at any given time
  net: filter: minor: fix kdoc in __sk_run_filter
  netlink: don't compare the nul-termination in nla_strcmp
  can: c_can: Avoid led toggling for every packet.
  can: c_can: Simplify TX interrupt cleanup
  can: c_can: Store dlc private
  can: c_can: Reduce register access
  can: c_can: Make the code readable
  ...

1 files changed, 200 insertions, 214 deletions

diff --git a/net/tipc/socket.c b/net/tipc/socket.c
index 0ed0eaa62f29..29b7f26a12cf 100644
--- a/net/tipc/socket.c
+++ b/net/tipc/socket.c
@@ -1,7 +1,7 @@
 /*
  * net/tipc/socket.c: TIPC socket API
  *
- * Copyright (c) 2001-2007, 2012 Ericsson AB
+ * Copyright (c) 2001-2007, 2012-2014, Ericsson AB
  * Copyright (c) 2004-2008, 2010-2013, Wind River Systems
  * All rights reserved.
  *
@@ -38,30 +38,17 @@
 #include "port.h"
 
 #include <linux/export.h>
-#include <net/sock.h>
 
 #define SS_LISTENING    -1      /* socket is listening */
 #define SS_READY        -2      /* socket is connectionless */
 
 #define CONN_TIMEOUT_DEFAULT    8000    /* default connect timeout = 8s */
 
-struct tipc_sock {
-        struct sock sk;
-        struct tipc_port *p;
-        struct tipc_portid peer_name;
-        unsigned int conn_timeout;
-};
-
-#define tipc_sk(sk) ((struct tipc_sock *)(sk))
-#define tipc_sk_port(sk) (tipc_sk(sk)->p)
-
 static int backlog_rcv(struct sock *sk, struct sk_buff *skb);
-static u32 dispatch(struct tipc_port *tport, struct sk_buff *buf);
-static void wakeupdispatch(struct tipc_port *tport);
 static void tipc_data_ready(struct sock *sk, int len);
 static void tipc_write_space(struct sock *sk);
-static int release(struct socket *sock);
-static int accept(struct socket *sock, struct socket *new_sock, int flags);
+static int tipc_release(struct socket *sock);
+static int tipc_accept(struct socket *sock, struct socket *new_sock, int flags);
 
 static const struct proto_ops packet_ops;
 static const struct proto_ops stream_ops;
@@ -115,6 +102,8 @@ static struct proto tipc_proto_kern;
  *   - port reference
  */
 
+#include "socket.h"
+
 /**
  * advance_rx_queue - discard first buffer in socket receive queue
  *
@@ -150,13 +139,15 @@ static void reject_rx_queue(struct sock *sk)
  *
  * Returns 0 on success, errno otherwise
  */
-static int tipc_sk_create(struct net *net, struct socket *sock, int protocol,
-                          int kern)
+static int tipc_sk_create(struct net *net, struct socket *sock,
+                          int protocol, int kern)
 {
         const struct proto_ops *ops;
         socket_state state;
         struct sock *sk;
-        struct tipc_port *tp_ptr;
+        struct tipc_sock *tsk;
+        struct tipc_port *port;
+        u32 ref;
 
         /* Validate arguments */
         if (unlikely(protocol != 0))
@@ -189,10 +180,12 @@ static int tipc_sk_create(struct net *net, struct socket *sock, int protocol,
         if (sk == NULL)
                 return -ENOMEM;
 
-        /* Allocate TIPC port for socket to use */
-        tp_ptr = tipc_createport(sk, &dispatch, &wakeupdispatch,
-                                 TIPC_LOW_IMPORTANCE);
-        if (unlikely(!tp_ptr)) {
+        tsk = tipc_sk(sk);
+        port = &tsk->port;
+
+        ref = tipc_port_init(port, TIPC_LOW_IMPORTANCE);
+        if (!ref) {
+                pr_warn("Socket registration failed, ref. table exhausted\n");
                 sk_free(sk);
                 return -ENOMEM;
         }
@@ -206,17 +199,14 @@ static int tipc_sk_create(struct net *net, struct socket *sock, int protocol,
         sk->sk_rcvbuf = sysctl_tipc_rmem[1];
         sk->sk_data_ready = tipc_data_ready;
         sk->sk_write_space = tipc_write_space;
-        tipc_sk(sk)->p = tp_ptr;
         tipc_sk(sk)->conn_timeout = CONN_TIMEOUT_DEFAULT;
-
-        spin_unlock_bh(tp_ptr->lock);
+        tipc_port_unlock(port);
 
         if (sock->state == SS_READY) {
-                tipc_set_portunreturnable(tp_ptr->ref, 1);
+                tipc_port_set_unreturnable(port, true);
                 if (sock->type == SOCK_DGRAM)
-                        tipc_set_portunreliable(tp_ptr->ref, 1);
+                        tipc_port_set_unreliable(port, true);
         }
-
         return 0;
 }
 
@@ -254,7 +244,7 @@ int tipc_sock_create_local(int type, struct socket **res)
  */
 void tipc_sock_release_local(struct socket *sock)
 {
-        release(sock);
+        tipc_release(sock);
         sock->ops = NULL;
         sock_release(sock);
 }
@@ -280,7 +270,7 @@ int tipc_sock_accept_local(struct socket *sock, struct socket **newsock,
         if (ret < 0)
                 return ret;
 
-        ret = accept(sock, *newsock, flags);
+        ret = tipc_accept(sock, *newsock, flags);
         if (ret < 0) {
                 sock_release(*newsock);
                 return ret;
@@ -290,7 +280,7 @@ int tipc_sock_accept_local(struct socket *sock, struct socket **newsock,
 }
 
 /**
- * release - destroy a TIPC socket
+ * tipc_release - destroy a TIPC socket
  * @sock: socket to destroy
  *
  * This routine cleans up any messages that are still queued on the socket.
@@ -305,10 +295,11 @@ int tipc_sock_accept_local(struct socket *sock, struct socket **newsock,
  *
  * Returns 0 on success, errno otherwise
  */
-static int release(struct socket *sock)
+static int tipc_release(struct socket *sock)
 {
         struct sock *sk = sock->sk;
-        struct tipc_port *tport;
+        struct tipc_sock *tsk;
+        struct tipc_port *port;
         struct sk_buff *buf;
         int res;
 
@@ -319,7 +310,8 @@ static int release(struct socket *sock)
         if (sk == NULL)
                 return 0;
 
-        tport = tipc_sk_port(sk);
+        tsk = tipc_sk(sk);
+        port = &tsk->port;
         lock_sock(sk);
 
         /*
@@ -336,17 +328,16 @@ static int release(struct socket *sock)
                         if ((sock->state == SS_CONNECTING) ||
                             (sock->state == SS_CONNECTED)) {
                                 sock->state = SS_DISCONNECTING;
-                                tipc_disconnect(tport->ref);
+                                tipc_port_disconnect(port->ref);
                         }
                         tipc_reject_msg(buf, TIPC_ERR_NO_PORT);
                 }
         }
 
-        /*
-         * Delete TIPC port; this ensures no more messages are queued
-         * (also disconnects an active connection & sends a 'FIN-' to peer)
+        /* Destroy TIPC port; also disconnects an active connection and
+         * sends a 'FIN-' to peer.
          */
-        res = tipc_deleteport(tport);
+        tipc_port_destroy(port);
 
         /* Discard any remaining (connection-based) messages in receive queue */
         __skb_queue_purge(&sk->sk_receive_queue);
@@ -362,7 +353,7 @@ static int release(struct socket *sock)
 }
 
 /**
- * bind - associate or disassocate TIPC name(s) with a socket
+ * tipc_bind - associate or disassocate TIPC name(s) with a socket
  * @sock: socket structure
  * @uaddr: socket address describing name(s) and desired operation
  * @uaddr_len: size of socket address data structure
@@ -376,16 +367,17 @@ static int release(struct socket *sock)
  * NOTE: This routine doesn't need to take the socket lock since it doesn't
  *       access any non-constant socket information.
  */
-static int bind(struct socket *sock, struct sockaddr *uaddr, int uaddr_len)
+static int tipc_bind(struct socket *sock, struct sockaddr *uaddr,
+                     int uaddr_len)
 {
         struct sock *sk = sock->sk;
         struct sockaddr_tipc *addr = (struct sockaddr_tipc *)uaddr;
-        struct tipc_port *tport = tipc_sk_port(sock->sk);
+        struct tipc_sock *tsk = tipc_sk(sk);
         int res = -EINVAL;
 
         lock_sock(sk);
         if (unlikely(!uaddr_len)) {
-                res = tipc_withdraw(tport, 0, NULL);
+                res = tipc_withdraw(&tsk->port, 0, NULL);
                 goto exit;
         }
 
@@ -413,15 +405,15 @@ static int bind(struct socket *sock, struct sockaddr *uaddr, int uaddr_len)
         }
 
         res = (addr->scope > 0) ?
-                tipc_publish(tport, addr->scope, &addr->addr.nameseq) :
-                tipc_withdraw(tport, -addr->scope, &addr->addr.nameseq);
+                tipc_publish(&tsk->port, addr->scope, &addr->addr.nameseq) :
+                tipc_withdraw(&tsk->port, -addr->scope, &addr->addr.nameseq);
 exit:
         release_sock(sk);
         return res;
 }
 
 /**
- * get_name - get port ID of socket or peer socket
+ * tipc_getname - get port ID of socket or peer socket
  * @sock: socket structure
  * @uaddr: area for returned socket address
  * @uaddr_len: area for returned length of socket address
@@ -433,21 +425,21 @@ exit:
  *       accesses socket information that is unchanging (or which changes in
  *       a completely predictable manner).
  */
-static int get_name(struct socket *sock, struct sockaddr *uaddr,
-                    int *uaddr_len, int peer)
+static int tipc_getname(struct socket *sock, struct sockaddr *uaddr,
+                        int *uaddr_len, int peer)
 {
         struct sockaddr_tipc *addr = (struct sockaddr_tipc *)uaddr;
-        struct tipc_sock *tsock = tipc_sk(sock->sk);
+        struct tipc_sock *tsk = tipc_sk(sock->sk);
 
         memset(addr, 0, sizeof(*addr));
         if (peer) {
                 if ((sock->state != SS_CONNECTED) &&
                         ((peer != 2) || (sock->state != SS_DISCONNECTING)))
                         return -ENOTCONN;
-                addr->addr.id.ref = tsock->peer_name.ref;
-                addr->addr.id.node = tsock->peer_name.node;
+                addr->addr.id.ref = tipc_port_peerport(&tsk->port);
+                addr->addr.id.node = tipc_port_peernode(&tsk->port);
         } else {
-                addr->addr.id.ref = tsock->p->ref;
+                addr->addr.id.ref = tsk->port.ref;
                 addr->addr.id.node = tipc_own_addr;
         }
 
@@ -461,7 +453,7 @@ static int get_name(struct socket *sock, struct sockaddr *uaddr,
 }
 
 /**
- * poll - read and possibly block on pollmask
+ * tipc_poll - read and possibly block on pollmask
  * @file: file structure associated with the socket
  * @sock: socket for which to calculate the poll bits
  * @wait: ???
@@ -500,22 +492,23 @@ static int get_name(struct socket *sock, struct sockaddr *uaddr,
  * imply that the operation will succeed, merely that it should be performed
  * and will not block.
  */
-static unsigned int poll(struct file *file, struct socket *sock,
-                         poll_table *wait)
+static unsigned int tipc_poll(struct file *file, struct socket *sock,
+                              poll_table *wait)
 {
         struct sock *sk = sock->sk;
+        struct tipc_sock *tsk = tipc_sk(sk);
         u32 mask = 0;
 
         sock_poll_wait(file, sk_sleep(sk), wait);
 
         switch ((int)sock->state) {
         case SS_UNCONNECTED:
-                if (!tipc_sk_port(sk)->congested)
+                if (!tsk->port.congested)
                         mask |= POLLOUT;
                 break;
         case SS_READY:
         case SS_CONNECTED:
-                if (!tipc_sk_port(sk)->congested)
+                if (!tsk->port.congested)
                         mask |= POLLOUT;
                 /* fall thru' */
         case SS_CONNECTING:
@@ -565,7 +558,7 @@ static int dest_name_check(struct sockaddr_tipc *dest, struct msghdr *m)
 static int tipc_wait_for_sndmsg(struct socket *sock, long *timeo_p)
 {
         struct sock *sk = sock->sk;
-        struct tipc_port *tport = tipc_sk_port(sk);
+        struct tipc_sock *tsk = tipc_sk(sk);
         DEFINE_WAIT(wait);
         int done;
 
@@ -581,14 +574,15 @@ static int tipc_wait_for_sndmsg(struct socket *sock, long *timeo_p)
                         return sock_intr_errno(*timeo_p);
 
                 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
-                done = sk_wait_event(sk, timeo_p, !tport->congested);
+                done = sk_wait_event(sk, timeo_p, !tsk->port.congested);
                 finish_wait(sk_sleep(sk), &wait);
         } while (!done);
         return 0;
 }
 
+
 /**
- * send_msg - send message in connectionless manner
+ * tipc_sendmsg - send message in connectionless manner
  * @iocb: if NULL, indicates that socket lock is already held
  * @sock: socket structure
  * @m: message to send
@@ -601,11 +595,12 @@ static int tipc_wait_for_sndmsg(struct socket *sock, long *timeo_p)
  *
  * Returns the number of bytes sent on success, or errno otherwise
  */
-static int send_msg(struct kiocb *iocb, struct socket *sock,
-                    struct msghdr *m, size_t total_len)
+static int tipc_sendmsg(struct kiocb *iocb, struct socket *sock,
+                        struct msghdr *m, size_t total_len)
 {
         struct sock *sk = sock->sk;
-        struct tipc_port *tport = tipc_sk_port(sk);
+        struct tipc_sock *tsk = tipc_sk(sk);
+        struct tipc_port *port = &tsk->port;
         DECLARE_SOCKADDR(struct sockaddr_tipc *, dest, m->msg_name);
         int needs_conn;
         long timeo;
@@ -632,13 +627,13 @@ static int send_msg(struct kiocb *iocb, struct socket *sock,
                         res = -EISCONN;
                         goto exit;
                 }
-                if (tport->published) {
+                if (tsk->port.published) {
                         res = -EOPNOTSUPP;
                         goto exit;
                 }
                 if (dest->addrtype == TIPC_ADDR_NAME) {
-                        tport->conn_type = dest->addr.name.name.type;
-                        tport->conn_instance = dest->addr.name.name.instance;
+                        tsk->port.conn_type = dest->addr.name.name.type;
+                        tsk->port.conn_instance = dest->addr.name.name.instance;
                 }
 
                 /* Abort any pending connection attempts (very unlikely) */
@@ -651,13 +646,13 @@ static int send_msg(struct kiocb *iocb, struct socket *sock,
                         res = dest_name_check(dest, m);
                         if (res)
                                 break;
-                        res = tipc_send2name(tport->ref,
+                        res = tipc_send2name(port,
                                              &dest->addr.name.name,
                                              dest->addr.name.domain,
                                              m->msg_iov,
                                              total_len);
                 } else if (dest->addrtype == TIPC_ADDR_ID) {
-                        res = tipc_send2port(tport->ref,
+                        res = tipc_send2port(port,
                                              &dest->addr.id,
                                              m->msg_iov,
                                              total_len);
@@ -669,10 +664,10 @@ static int send_msg(struct kiocb *iocb, struct socket *sock,
                         res = dest_name_check(dest, m);
                         if (res)
                                 break;
-                        res = tipc_multicast(tport->ref,
-                                             &dest->addr.nameseq,
-                                             m->msg_iov,
-                                             total_len);
+                        res = tipc_port_mcast_xmit(port,
+                                                   &dest->addr.nameseq,
+                                                   m->msg_iov,
+                                                   total_len);
                 }
                 if (likely(res != -ELINKCONG)) {
                         if (needs_conn && (res >= 0))
@@ -693,7 +688,8 @@ exit:
 static int tipc_wait_for_sndpkt(struct socket *sock, long *timeo_p)
 {
         struct sock *sk = sock->sk;
-        struct tipc_port *tport = tipc_sk_port(sk);
+        struct tipc_sock *tsk = tipc_sk(sk);
+        struct tipc_port *port = &tsk->port;
         DEFINE_WAIT(wait);
         int done;
 
@@ -712,14 +708,14 @@ static int tipc_wait_for_sndpkt(struct socket *sock, long *timeo_p)
 
                 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
                 done = sk_wait_event(sk, timeo_p,
-                                     (!tport->congested || !tport->connected));
+                                     (!port->congested || !port->connected));
                 finish_wait(sk_sleep(sk), &wait);
         } while (!done);
         return 0;
 }
 
 /**
- * send_packet - send a connection-oriented message
+ * tipc_send_packet - send a connection-oriented message
  * @iocb: if NULL, indicates that socket lock is already held
  * @sock: socket structure
  * @m: message to send
@@ -729,18 +725,18 @@ static int tipc_wait_for_sndpkt(struct socket *sock, long *timeo_p)
  *
  * Returns the number of bytes sent on success, or errno otherwise
  */
-static int send_packet(struct kiocb *iocb, struct socket *sock,
-                       struct msghdr *m, size_t total_len)
+static int tipc_send_packet(struct kiocb *iocb, struct socket *sock,
+                            struct msghdr *m, size_t total_len)
 {
         struct sock *sk = sock->sk;
-        struct tipc_port *tport = tipc_sk_port(sk);
+        struct tipc_sock *tsk = tipc_sk(sk);
         DECLARE_SOCKADDR(struct sockaddr_tipc *, dest, m->msg_name);
         int res = -EINVAL;
         long timeo;
 
         /* Handle implied connection establishment */
         if (unlikely(dest))
-                return send_msg(iocb, sock, m, total_len);
+                return tipc_sendmsg(iocb, sock, m, total_len);
 
         if (total_len > TIPC_MAX_USER_MSG_SIZE)
                 return -EMSGSIZE;
@@ -758,7 +754,7 @@ static int send_packet(struct kiocb *iocb, struct socket *sock,
 
         timeo = sock_sndtimeo(sk, m->msg_flags & MSG_DONTWAIT);
         do {
-                res = tipc_send(tport->ref, m->msg_iov, total_len);
+                res = tipc_send(&tsk->port, m->msg_iov, total_len);
                 if (likely(res != -ELINKCONG))
                         break;
                 res = tipc_wait_for_sndpkt(sock, &timeo);
@@ -772,7 +768,7 @@ exit:
 }
 
 /**
- * send_stream - send stream-oriented data
+ * tipc_send_stream - send stream-oriented data
  * @iocb: (unused)
  * @sock: socket structure
  * @m: data to send
@@ -783,11 +779,11 @@ exit:
  * Returns the number of bytes sent on success (or partial success),
  * or errno if no data sent
  */
-static int send_stream(struct kiocb *iocb, struct socket *sock,
-                       struct msghdr *m, size_t total_len)
+static int tipc_send_stream(struct kiocb *iocb, struct socket *sock,
+                            struct msghdr *m, size_t total_len)
 {
         struct sock *sk = sock->sk;
-        struct tipc_port *tport = tipc_sk_port(sk);
+        struct tipc_sock *tsk = tipc_sk(sk);
         struct msghdr my_msg;
         struct iovec my_iov;
         struct iovec *curr_iov;
@@ -804,7 +800,7 @@ static int send_stream(struct kiocb *iocb, struct socket *sock,
         /* Handle special cases where there is no connection */
         if (unlikely(sock->state != SS_CONNECTED)) {
                 if (sock->state == SS_UNCONNECTED)
-                        res = send_packet(NULL, sock, m, total_len);
+                        res = tipc_send_packet(NULL, sock, m, total_len);
                 else
                         res = sock->state == SS_DISCONNECTING ? -EPIPE : -ENOTCONN;
                 goto exit;
@@ -835,21 +831,22 @@ static int send_stream(struct kiocb *iocb, struct socket *sock,
         my_msg.msg_name = NULL;
         bytes_sent = 0;
 
-        hdr_size = msg_hdr_sz(&tport->phdr);
+        hdr_size = msg_hdr_sz(&tsk->port.phdr);
 
         while (curr_iovlen--) {
                 curr_start = curr_iov->iov_base;
                 curr_left = curr_iov->iov_len;
 
                 while (curr_left) {
-                        bytes_to_send = tport->max_pkt - hdr_size;
+                        bytes_to_send = tsk->port.max_pkt - hdr_size;
                         if (bytes_to_send > TIPC_MAX_USER_MSG_SIZE)
                                 bytes_to_send = TIPC_MAX_USER_MSG_SIZE;
                         if (curr_left < bytes_to_send)
                                 bytes_to_send = curr_left;
                         my_iov.iov_base = curr_start;
                         my_iov.iov_len = bytes_to_send;
-                        res = send_packet(NULL, sock, &my_msg, bytes_to_send);
+                        res = tipc_send_packet(NULL, sock, &my_msg,
+                                               bytes_to_send);
                         if (res < 0) {
                                 if (bytes_sent)
                                         res = bytes_sent;
@@ -870,27 +867,25 @@ exit:
 
 /**
  * auto_connect - complete connection setup to a remote port
- * @sock: socket structure
+ * @tsk: tipc socket structure
  * @msg: peer's response message
  *
  * Returns 0 on success, errno otherwise
  */
-static int auto_connect(struct socket *sock, struct tipc_msg *msg)
+static int auto_connect(struct tipc_sock *tsk, struct tipc_msg *msg)
 {
-        struct tipc_sock *tsock = tipc_sk(sock->sk);
-        struct tipc_port *p_ptr;
+        struct tipc_port *port = &tsk->port;
+        struct socket *sock = tsk->sk.sk_socket;
+        struct tipc_portid peer;
 
-        tsock->peer_name.ref = msg_origport(msg);
-        tsock->peer_name.node = msg_orignode(msg);
-        p_ptr = tipc_port_deref(tsock->p->ref);
-        if (!p_ptr)
-                return -EINVAL;
+        peer.ref = msg_origport(msg);
+        peer.node = msg_orignode(msg);
 
-        __tipc_connect(tsock->p->ref, p_ptr, &tsock->peer_name);
+        __tipc_port_connect(port->ref, port, &peer);
 
         if (msg_importance(msg) > TIPC_CRITICAL_IMPORTANCE)
                 return -EINVAL;
-        msg_set_importance(&p_ptr->phdr, (u32)msg_importance(msg));
+        msg_set_importance(&port->phdr, (u32)msg_importance(msg));
         sock->state = SS_CONNECTED;
         return 0;
 }
@@ -1021,7 +1016,7 @@ static int tipc_wait_for_rcvmsg(struct socket *sock, long timeo)
 }
 
 /**
- * recv_msg - receive packet-oriented message
+ * tipc_recvmsg - receive packet-oriented message
  * @iocb: (unused)
  * @m: descriptor for message info
  * @buf_len: total size of user buffer area
@@ -1032,11 +1027,12 @@ static int tipc_wait_for_rcvmsg(struct socket *sock, long timeo)
  *
  * Returns size of returned message data, errno otherwise
  */
-static int recv_msg(struct kiocb *iocb, struct socket *sock,
-                    struct msghdr *m, size_t buf_len, int flags)
+static int tipc_recvmsg(struct kiocb *iocb, struct socket *sock,
+                        struct msghdr *m, size_t buf_len, int flags)
 {
         struct sock *sk = sock->sk;
-        struct tipc_port *tport = tipc_sk_port(sk);
+        struct tipc_sock *tsk = tipc_sk(sk);
+        struct tipc_port *port = &tsk->port;
         struct sk_buff *buf;
         struct tipc_msg *msg;
         long timeo;
@@ -1079,7 +1075,7 @@ restart:
         set_orig_addr(m, msg);
 
         /* Capture ancillary data (optional) */
-        res = anc_data_recv(m, msg, tport);
+        res = anc_data_recv(m, msg, port);
         if (res)
                 goto exit;
 
@@ -1105,8 +1101,8 @@ restart:
         /* Consume received message (optional) */
         if (likely(!(flags & MSG_PEEK))) {
                 if ((sock->state != SS_READY) &&
-                    (++tport->conn_unacked >= TIPC_FLOW_CONTROL_WIN))
-                        tipc_acknowledge(tport->ref, tport->conn_unacked);
+                    (++port->conn_unacked >= TIPC_FLOW_CONTROL_WIN))
+                        tipc_acknowledge(port->ref, port->conn_unacked);
                 advance_rx_queue(sk);
         }
 exit:
@@ -1115,7 +1111,7 @@ exit:
 }
 
 /**
- * recv_stream - receive stream-oriented data
+ * tipc_recv_stream - receive stream-oriented data
  * @iocb: (unused)
  * @m: descriptor for message info
  * @buf_len: total size of user buffer area
@@ -1126,11 +1122,12 @@ exit:
  *
  * Returns size of returned message data, errno otherwise
  */
-static int recv_stream(struct kiocb *iocb, struct socket *sock,
-                       struct msghdr *m, size_t buf_len, int flags)
+static int tipc_recv_stream(struct kiocb *iocb, struct socket *sock,
+                            struct msghdr *m, size_t buf_len, int flags)
 {
         struct sock *sk = sock->sk;
-        struct tipc_port *tport = tipc_sk_port(sk);
+        struct tipc_sock *tsk = tipc_sk(sk);
+        struct tipc_port *port = &tsk->port;
         struct sk_buff *buf;
         struct tipc_msg *msg;
         long timeo;
@@ -1175,7 +1172,7 @@ restart:
         /* Optionally capture sender's address & ancillary data of first msg */
         if (sz_copied == 0) {
                 set_orig_addr(m, msg);
-                res = anc_data_recv(m, msg, tport);
+                res = anc_data_recv(m, msg, port);
                 if (res)
                         goto exit;
         }
@@ -1213,8 +1210,8 @@ restart:
 
         /* Consume received message (optional) */
         if (likely(!(flags & MSG_PEEK))) {
-                if (unlikely(++tport->conn_unacked >= TIPC_FLOW_CONTROL_WIN))
-                        tipc_acknowledge(tport->ref, tport->conn_unacked);
+                if (unlikely(++port->conn_unacked >= TIPC_FLOW_CONTROL_WIN))
+                        tipc_acknowledge(port->ref, port->conn_unacked);
                 advance_rx_queue(sk);
         }
 
@@ -1266,17 +1263,19 @@ static void tipc_data_ready(struct sock *sk, int len)
 
 /**
  * filter_connect - Handle all incoming messages for a connection-based socket
- * @tsock: TIPC socket
+ * @tsk: TIPC socket
  * @msg: message
  *
  * Returns TIPC error status code and socket error status code
  * once it encounters some errors
  */
-static u32 filter_connect(struct tipc_sock *tsock, struct sk_buff **buf)
+static u32 filter_connect(struct tipc_sock *tsk, struct sk_buff **buf)
 {
-        struct socket *sock = tsock->sk.sk_socket;
+        struct sock *sk = &tsk->sk;
+        struct tipc_port *port = &tsk->port;
+        struct socket *sock = sk->sk_socket;
         struct tipc_msg *msg = buf_msg(*buf);
-        struct sock *sk = &tsock->sk;
+
         u32 retval = TIPC_ERR_NO_PORT;
         int res;
 
@@ -1286,10 +1285,10 @@ static u32 filter_connect(struct tipc_sock *tsock, struct sk_buff **buf)
         switch ((int)sock->state) {
         case SS_CONNECTED:
                 /* Accept only connection-based messages sent by peer */
-                if (msg_connected(msg) && tipc_port_peer_msg(tsock->p, msg)) {
+                if (msg_connected(msg) && tipc_port_peer_msg(port, msg)) {
                         if (unlikely(msg_errcode(msg))) {
                                 sock->state = SS_DISCONNECTING;
-                                __tipc_disconnect(tsock->p);
+                                __tipc_port_disconnect(port);
                         }
                         retval = TIPC_OK;
                 }
@@ -1306,7 +1305,7 @@ static u32 filter_connect(struct tipc_sock *tsock, struct sk_buff **buf)
                 if (unlikely(!msg_connected(msg)))
                         break;
 
-                res = auto_connect(sock, msg);
+                res = auto_connect(tsk, msg);
                 if (res) {
                         sock->state = SS_DISCONNECTING;
                         sk->sk_err = -res;
@@ -1385,6 +1384,7 @@ static unsigned int rcvbuf_limit(struct sock *sk, struct sk_buff *buf)
 static u32 filter_rcv(struct sock *sk, struct sk_buff *buf)
 {
         struct socket *sock = sk->sk_socket;
+        struct tipc_sock *tsk = tipc_sk(sk);
         struct tipc_msg *msg = buf_msg(buf);
         unsigned int limit = rcvbuf_limit(sk, buf);
         u32 res = TIPC_OK;
@@ -1397,7 +1397,7 @@ static u32 filter_rcv(struct sock *sk, struct sk_buff *buf)
                 if (msg_connected(msg))
                         return TIPC_ERR_NO_PORT;
         } else {
-                res = filter_connect(tipc_sk(sk), &buf);
+                res = filter_connect(tsk, &buf);
                 if (res != TIPC_OK || buf == NULL)
                         return res;
         }
@@ -1435,17 +1435,16 @@ static int backlog_rcv(struct sock *sk, struct sk_buff *buf)
 }
 
 /**
- * dispatch - handle incoming message
- * @tport: TIPC port that received message
+ * tipc_sk_rcv - handle incoming message
+ * @sk:  socket receiving message
  * @buf: message
  *
  * Called with port lock already taken.
  *
  * Returns TIPC error status code (TIPC_OK if message is not to be rejected)
  */
-static u32 dispatch(struct tipc_port *tport, struct sk_buff *buf)
+u32 tipc_sk_rcv(struct sock *sk, struct sk_buff *buf)
 {
-        struct sock *sk = tport->sk;
         u32 res;
 
         /*
@@ -1468,19 +1467,6 @@ static u32 dispatch(struct tipc_port *tport, struct sk_buff *buf)
         return res;
 }
 
-/**
- * wakeupdispatch - wake up port after congestion
- * @tport: port to wakeup
- *
- * Called with port lock already taken.
- */
-static void wakeupdispatch(struct tipc_port *tport)
-{
-        struct sock *sk = tport->sk;
-
-        sk->sk_write_space(sk);
-}
-
 static int tipc_wait_for_connect(struct socket *sock, long *timeo_p)
 {
         struct sock *sk = sock->sk;
@@ -1504,7 +1490,7 @@ static int tipc_wait_for_connect(struct socket *sock, long *timeo_p)
 }
 
 /**
- * connect - establish a connection to another TIPC port
+ * tipc_connect - establish a connection to another TIPC port
  * @sock: socket structure
  * @dest: socket address for destination port
  * @destlen: size of socket address data structure
@@ -1512,8 +1498,8 @@ static int tipc_wait_for_connect(struct socket *sock, long *timeo_p)
  *
  * Returns 0 on success, errno otherwise
  */
-static int connect(struct socket *sock, struct sockaddr *dest, int destlen,
-                   int flags)
+static int tipc_connect(struct socket *sock, struct sockaddr *dest,
+                        int destlen, int flags)
 {
         struct sock *sk = sock->sk;
         struct sockaddr_tipc *dst = (struct sockaddr_tipc *)dest;
@@ -1554,7 +1540,7 @@ static int connect(struct socket *sock, struct sockaddr *dest, int destlen,
                 if (!timeout)
                         m.msg_flags = MSG_DONTWAIT;
 
-                res = send_msg(NULL, sock, &m, 0);
+                res = tipc_sendmsg(NULL, sock, &m, 0);
                 if ((res < 0) && (res != -EWOULDBLOCK))
                         goto exit;
 
@@ -1585,13 +1571,13 @@ exit:
 }
 
 /**
- * listen - allow socket to listen for incoming connections
+ * tipc_listen - allow socket to listen for incoming connections
  * @sock: socket structure
  * @len: (unused)
  *
  * Returns 0 on success, errno otherwise
  */
-static int listen(struct socket *sock, int len)
+static int tipc_listen(struct socket *sock, int len)
 {
         struct sock *sk = sock->sk;
         int res;
@@ -1646,20 +1632,20 @@ static int tipc_wait_for_accept(struct socket *sock, long timeo)
 }
 
 /**
- * accept - wait for connection request
+ * tipc_accept - wait for connection request
  * @sock: listening socket
  * @newsock: new socket that is to be connected
  * @flags: file-related flags associated with socket
  *
  * Returns 0 on success, errno otherwise
  */
-static int accept(struct socket *sock, struct socket *new_sock, int flags)
+static int tipc_accept(struct socket *sock, struct socket *new_sock, int flags)
 {
         struct sock *new_sk, *sk = sock->sk;
         struct sk_buff *buf;
-        struct tipc_sock *new_tsock;
-        struct tipc_port *new_tport;
+        struct tipc_port *new_port;
         struct tipc_msg *msg;
+        struct tipc_portid peer;
         u32 new_ref;
         long timeo;
         int res;
@@ -1670,7 +1656,6 @@ static int accept(struct socket *sock, struct socket *new_sock, int flags)
                 res = -EINVAL;
                 goto exit;
         }
-
         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
         res = tipc_wait_for_accept(sock, timeo);
         if (res)
@@ -1683,9 +1668,8 @@ static int accept(struct socket *sock, struct socket *new_sock, int flags)
                 goto exit;
 
         new_sk = new_sock->sk;
-        new_tsock = tipc_sk(new_sk);
-        new_tport = new_tsock->p;
-        new_ref = new_tport->ref;
+        new_port = &tipc_sk(new_sk)->port;
+        new_ref = new_port->ref;
         msg = buf_msg(buf);
 
         /* we lock on new_sk; but lockdep sees the lock on sk */
@@ -1698,15 +1682,15 @@ static int accept(struct socket *sock, struct socket *new_sock, int flags)
         reject_rx_queue(new_sk);
 
         /* Connect new socket to it's peer */
-        new_tsock->peer_name.ref = msg_origport(msg);
-        new_tsock->peer_name.node = msg_orignode(msg);
-        tipc_connect(new_ref, &new_tsock->peer_name);
+        peer.ref = msg_origport(msg);
+        peer.node = msg_orignode(msg);
+        tipc_port_connect(new_ref, &peer);
         new_sock->state = SS_CONNECTED;
 
-        tipc_set_portimportance(new_ref, msg_importance(msg));
+        tipc_port_set_importance(new_port, msg_importance(msg));
         if (msg_named(msg)) {
-                new_tport->conn_type = msg_nametype(msg);
-                new_tport->conn_instance = msg_nameinst(msg);
+                new_port->conn_type = msg_nametype(msg);
+                new_port->conn_instance = msg_nameinst(msg);
         }
 
         /*
@@ -1717,21 +1701,20 @@ static int accept(struct socket *sock, struct socket *new_sock, int flags)
                 struct msghdr m = {NULL,};
 
                 advance_rx_queue(sk);
-                send_packet(NULL, new_sock, &m, 0);
+                tipc_send_packet(NULL, new_sock, &m, 0);
         } else {
                 __skb_dequeue(&sk->sk_receive_queue);
                 __skb_queue_head(&new_sk->sk_receive_queue, buf);
                 skb_set_owner_r(buf, new_sk);
         }
         release_sock(new_sk);
-
 exit:
         release_sock(sk);
         return res;
 }
 
 /**
- * shutdown - shutdown socket connection
+ * tipc_shutdown - shutdown socket connection
  * @sock: socket structure
  * @how: direction to close (must be SHUT_RDWR)
  *
@@ -1739,10 +1722,11 @@ exit:
  *
  * Returns 0 on success, errno otherwise
  */
-static int shutdown(struct socket *sock, int how)
+static int tipc_shutdown(struct socket *sock, int how)
 {
         struct sock *sk = sock->sk;
-        struct tipc_port *tport = tipc_sk_port(sk);
+        struct tipc_sock *tsk = tipc_sk(sk);
+        struct tipc_port *port = &tsk->port;
         struct sk_buff *buf;
         int res;
 
@@ -1763,10 +1747,10 @@ restart:
                                 kfree_skb(buf);
                                 goto restart;
                         }
-                        tipc_disconnect(tport->ref);
+                        tipc_port_disconnect(port->ref);
                         tipc_reject_msg(buf, TIPC_CONN_SHUTDOWN);
                 } else {
-                        tipc_shutdown(tport->ref);
+                        tipc_port_shutdown(port->ref);
                 }
 
                 sock->state = SS_DISCONNECTING;
@@ -1792,7 +1776,7 @@ restart:
 }
 
 /**
- * setsockopt - set socket option
+ * tipc_setsockopt - set socket option
  * @sock: socket structure
  * @lvl: option level
  * @opt: option identifier
@@ -1804,11 +1788,12 @@ restart:
  *
  * Returns 0 on success, errno otherwise
  */
-static int setsockopt(struct socket *sock, int lvl, int opt, char __user *ov,
-                      unsigned int ol)
+static int tipc_setsockopt(struct socket *sock, int lvl, int opt,
+                           char __user *ov, unsigned int ol)
 {
         struct sock *sk = sock->sk;
-        struct tipc_port *tport = tipc_sk_port(sk);
+        struct tipc_sock *tsk = tipc_sk(sk);
+        struct tipc_port *port = &tsk->port;
         u32 value;
         int res;
 
@@ -1826,16 +1811,16 @@ static int setsockopt(struct socket *sock, int lvl, int opt, char __user *ov,
 
         switch (opt) {
         case TIPC_IMPORTANCE:
-                res = tipc_set_portimportance(tport->ref, value);
+                tipc_port_set_importance(port, value);
                 break;
         case TIPC_SRC_DROPPABLE:
                 if (sock->type != SOCK_STREAM)
-                        res = tipc_set_portunreliable(tport->ref, value);
+                        tipc_port_set_unreliable(port, value);
                 else
                         res = -ENOPROTOOPT;
                 break;
         case TIPC_DEST_DROPPABLE:
-                res = tipc_set_portunreturnable(tport->ref, value);
+                tipc_port_set_unreturnable(port, value);
                 break;
         case TIPC_CONN_TIMEOUT:
                 tipc_sk(sk)->conn_timeout = value;
@@ -1851,7 +1836,7 @@ static int setsockopt(struct socket *sock, int lvl, int opt, char __user *ov,
 }
 
 /**
- * getsockopt - get socket option
+ * tipc_getsockopt - get socket option
  * @sock: socket structure
  * @lvl: option level
  * @opt: option identifier
@@ -1863,11 +1848,12 @@ static int setsockopt(struct socket *sock, int lvl, int opt, char __user *ov,
  *
  * Returns 0 on success, errno otherwise
  */
-static int getsockopt(struct socket *sock, int lvl, int opt, char __user *ov,
-                      int __user *ol)
+static int tipc_getsockopt(struct socket *sock, int lvl, int opt,
+                           char __user *ov, int __user *ol)
 {
         struct sock *sk = sock->sk;
-        struct tipc_port *tport = tipc_sk_port(sk);
+        struct tipc_sock *tsk = tipc_sk(sk);
+        struct tipc_port *port = &tsk->port;
         int len;
         u32 value;
         int res;
@@ -1884,13 +1870,13 @@ static int getsockopt(struct socket *sock, int lvl, int opt, char __user *ov,
 
         switch (opt) {
         case TIPC_IMPORTANCE:
-                res = tipc_portimportance(tport->ref, &value);
+                value = tipc_port_importance(port);
                 break;
         case TIPC_SRC_DROPPABLE:
-                res = tipc_portunreliable(tport->ref, &value);
+                value = tipc_port_unreliable(port);
                 break;
         case TIPC_DEST_DROPPABLE:
-                res = tipc_portunreturnable(tport->ref, &value);
+                value = tipc_port_unreturnable(port);
                 break;
         case TIPC_CONN_TIMEOUT:
                 value = tipc_sk(sk)->conn_timeout;
@@ -1925,20 +1911,20 @@ static int getsockopt(struct socket *sock, int lvl, int opt, char __user *ov,
 static const struct proto_ops msg_ops = {
         .owner          = THIS_MODULE,
         .family         = AF_TIPC,
-        .release        = release,
-        .bind           = bind,
-        .connect        = connect,
+        .release        = tipc_release,
+        .bind           = tipc_bind,
+        .connect        = tipc_connect,
         .socketpair     = sock_no_socketpair,
         .accept         = sock_no_accept,
-        .getname        = get_name,
-        .poll           = poll,
+        .getname        = tipc_getname,
+        .poll           = tipc_poll,
         .ioctl          = sock_no_ioctl,
         .listen         = sock_no_listen,
-        .shutdown       = shutdown,
-        .setsockopt     = setsockopt,
-        .getsockopt     = getsockopt,
-        .sendmsg        = send_msg,
-        .recvmsg        = recv_msg,
+        .shutdown       = tipc_shutdown,
+        .setsockopt     = tipc_setsockopt,
+        .getsockopt     = tipc_getsockopt,
+        .sendmsg        = tipc_sendmsg,
+        .recvmsg        = tipc_recvmsg,
         .mmap           = sock_no_mmap,
         .sendpage       = sock_no_sendpage
 };
@@ -1946,20 +1932,20 @@ static const struct proto_ops msg_ops = {
 static const struct proto_ops packet_ops = {
         .owner          = THIS_MODULE,
         .family         = AF_TIPC,
-        .release        = release,
-        .bind           = bind,
-        .connect        = connect,
+        .release        = tipc_release,
+        .bind           = tipc_bind,
+        .connect        = tipc_connect,
         .socketpair     = sock_no_socketpair,
-        .accept         = accept,
-        .getname        = get_name,
-        .poll           = poll,
+        .accept         = tipc_accept,
+        .getname        = tipc_getname,
+        .poll           = tipc_poll,
         .ioctl          = sock_no_ioctl,
-        .listen         = listen,
-        .shutdown       = shutdown,
-        .setsockopt     = setsockopt,
-        .getsockopt     = getsockopt,
-        .sendmsg        = send_packet,
-        .recvmsg        = recv_msg,
+        .listen         = tipc_listen,
+        .shutdown       = tipc_shutdown,
+        .setsockopt     = tipc_setsockopt,
+        .getsockopt     = tipc_getsockopt,
+        .sendmsg        = tipc_send_packet,
+        .recvmsg        = tipc_recvmsg,
         .mmap           = sock_no_mmap,
         .sendpage       = sock_no_sendpage
 };
@@ -1967,20 +1953,20 @@ static const struct proto_ops packet_ops = {
 static const struct proto_ops stream_ops = {
         .owner          = THIS_MODULE,
         .family         = AF_TIPC,
-        .release        = release,
-        .bind           = bind,
-        .connect        = connect,
+        .release        = tipc_release,
+        .bind           = tipc_bind,
+        .connect        = tipc_connect,
         .socketpair     = sock_no_socketpair,
-        .accept         = accept,
-        .getname        = get_name,
-        .poll           = poll,
+        .accept         = tipc_accept,
+        .getname        = tipc_getname,
+        .poll           = tipc_poll,
         .ioctl          = sock_no_ioctl,
-        .listen         = listen,
-        .shutdown       = shutdown,
-        .setsockopt     = setsockopt,
-        .getsockopt     = getsockopt,
-        .sendmsg        = send_stream,
-        .recvmsg        = recv_stream,
+        .listen         = tipc_listen,
+        .shutdown       = tipc_shutdown,
+        .setsockopt     = tipc_setsockopt,
+        .getsockopt     = tipc_getsockopt,
+        .sendmsg        = tipc_send_stream,
+        .recvmsg        = tipc_recv_stream,
         .mmap           = sock_no_mmap,
         .sendpage       = sock_no_sendpage
 };