tipc: clean up socket timer function

The last remaining BH upcall to the socket, apart for the message
reception function tipc_sk_rcv(), is the timer function.

We prefer to let this function continue executing in BH, since it only
does read-acces to semi-permanent data, but we make three changes to it:

1) We introduce a bh_lock_sock()/bh_unlock_sock() inside the scope
   of port_lock.  This is a preparation for replacing port_lock with
   bh_lock_sock() at the locations where it is still used.

2) We move the function from port.c to socket.c, as a further step
   of eliminating the port code level altogether.

3) We let it make use of the newly introduced tipc_msg_create()
   function. This enables us to get rid of three context specific
   functions (port_create_self_abort_msg() etc.) in port.c

Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/net/tipc/port.c b/net/tipc/port.c
index edbd83d223c5e846e352d7fbdb9c2690bac985af..6de79f26981e30fa70adb66c2e8fc52e10907469 100644 (file)
--- a/net/tipc/port.c
+++ b/net/tipc/port.c
@@ -48,9 +48,6 @@
 DEFINE_SPINLOCK(tipc_port_list_lock);
 
 static LIST_HEAD(ports);
-static struct sk_buff *port_build_self_abort_msg(struct tipc_port *, u32 err);
-static struct sk_buff *port_build_peer_abort_msg(struct tipc_port *, u32 err);
-static void port_timeout(unsigned long ref);
 
 /**
  * tipc_port_peer_msg - verify message was sent by connected port's peer
@@ -92,7 +89,6 @@ u32 tipc_port_init(struct tipc_port *p_ptr,
        p_ptr->max_pkt = MAX_PKT_DEFAULT;
        p_ptr->ref = ref;
        INIT_LIST_HEAD(&p_ptr->subscription.nodesub_list);
-       k_init_timer(&p_ptr->timer, (Handler)port_timeout, ref);
        INIT_LIST_HEAD(&p_ptr->publications);
        INIT_LIST_HEAD(&p_ptr->port_list);
 
@@ -114,7 +110,7 @@ void tipc_port_destroy(struct tipc_port *p_ptr)
 {
        struct sk_buff *buf = NULL;
        struct tipc_msg *msg = NULL;
-       u32 peer;
+       u32 peer_node;
 
        tipc_withdraw(p_ptr, 0, NULL);
 
@@ -124,11 +120,16 @@ void tipc_port_destroy(struct tipc_port *p_ptr)
 
        k_cancel_timer(&p_ptr->timer);
        if (p_ptr->connected) {
-               buf = port_build_peer_abort_msg(p_ptr, TIPC_ERR_NO_PORT);
-               msg = buf_msg(buf);
-               peer = msg_destnode(msg);
-               tipc_link_xmit(buf, peer, msg_link_selector(msg));
-               tipc_node_remove_conn(peer, p_ptr->ref);
+               peer_node = tipc_port_peernode(p_ptr);
+               buf = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, TIPC_CONN_MSG,
+                                     SHORT_H_SIZE, 0, peer_node,
+                                     tipc_own_addr, tipc_port_peerport(p_ptr),
+                                     p_ptr->ref, TIPC_ERR_NO_PORT);
+               if (buf) {
+                       msg = buf_msg(buf);
+                       tipc_link_xmit(buf, peer_node, msg_link_selector(msg));
+               }
+               tipc_node_remove_conn(peer_node, p_ptr->ref);
        }
        spin_lock_bh(&tipc_port_list_lock);
        list_del(&p_ptr->port_list);
@@ -136,94 +137,6 @@ void tipc_port_destroy(struct tipc_port *p_ptr)
        k_term_timer(&p_ptr->timer);
 }
 
-/*
- * port_build_proto_msg(): create connection protocol message for port
- *
- * On entry the port must be locked and connected.
- */
-static struct sk_buff *port_build_proto_msg(struct tipc_port *p_ptr,
-                                           u32 type, u32 ack)
-{
-       struct sk_buff *buf;
-       struct tipc_msg *msg;
-
-       buf = tipc_buf_acquire(INT_H_SIZE);
-       if (buf) {
-               msg = buf_msg(buf);
-               tipc_msg_init(msg, CONN_MANAGER, type, INT_H_SIZE,
-                             tipc_port_peernode(p_ptr));
-               msg_set_destport(msg, tipc_port_peerport(p_ptr));
-               msg_set_origport(msg, p_ptr->ref);
-               msg_set_msgcnt(msg, ack);
-               buf->next = NULL;
-       }
-       return buf;
-}
-
-static void port_timeout(unsigned long ref)
-{
-       struct tipc_port *p_ptr = tipc_port_lock(ref);
-       struct sk_buff *buf = NULL;
-       struct tipc_msg *msg = NULL;
-
-       if (!p_ptr)
-               return;
-
-       if (!p_ptr->connected) {
-               tipc_port_unlock(p_ptr);
-               return;
-       }
-
-       /* Last probe answered ? */
-       if (p_ptr->probing_state == TIPC_CONN_PROBING) {
-               buf = port_build_self_abort_msg(p_ptr, TIPC_ERR_NO_PORT);
-       } else {
-               buf = port_build_proto_msg(p_ptr, CONN_PROBE, 0);
-               p_ptr->probing_state = TIPC_CONN_PROBING;
-               k_start_timer(&p_ptr->timer, p_ptr->probing_interval);
-       }
-       tipc_port_unlock(p_ptr);
-       msg = buf_msg(buf);
-       tipc_link_xmit(buf, msg_destnode(msg),  msg_link_selector(msg));
-}
-
-static struct sk_buff *port_build_self_abort_msg(struct tipc_port *p_ptr, u32 err)
-{
-       struct sk_buff *buf = port_build_peer_abort_msg(p_ptr, err);
-
-       if (buf) {
-               struct tipc_msg *msg = buf_msg(buf);
-               msg_swap_words(msg, 4, 5);
-               msg_swap_words(msg, 6, 7);
-               buf->next = NULL;
-       }
-       return buf;
-}
-
-static struct sk_buff *port_build_peer_abort_msg(struct tipc_port *p_ptr, u32 err)
-{
-       struct sk_buff *buf;
-       struct tipc_msg *msg;
-       u32 imp;
-
-       if (!p_ptr->connected)
-               return NULL;
-
-       buf = tipc_buf_acquire(BASIC_H_SIZE);
-       if (buf) {
-               msg = buf_msg(buf);
-               memcpy(msg, &p_ptr->phdr, BASIC_H_SIZE);
-               msg_set_hdr_sz(msg, BASIC_H_SIZE);
-               msg_set_size(msg, BASIC_H_SIZE);
-               imp = msg_importance(msg);
-               if (imp < TIPC_CRITICAL_IMPORTANCE)
-                       msg_set_importance(msg, ++imp);
-               msg_set_errcode(msg, err);
-               buf->next = NULL;
-       }
-       return buf;
-}
-
 static int port_print(struct tipc_port *p_ptr, char *buf, int len, int full_id)
 {
        struct publication *publ;
@@ -321,12 +234,15 @@ void tipc_acknowledge(u32 ref, u32 ack)
        if (!p_ptr)
                return;
        if (p_ptr->connected)
-               buf = port_build_proto_msg(p_ptr, CONN_ACK, ack);
-
+               buf = tipc_msg_create(CONN_MANAGER, CONN_ACK, INT_H_SIZE,
+                                     0, tipc_port_peernode(p_ptr),
+                                     tipc_own_addr, tipc_port_peerport(p_ptr),
+                                     p_ptr->ref, TIPC_OK);
        tipc_port_unlock(p_ptr);
        if (!buf)
                return;
        msg = buf_msg(buf);
+       msg_set_msgcnt(msg, ack);
        tipc_link_xmit(buf, msg_destnode(msg),  msg_link_selector(msg));
 }
 
@@ -478,14 +394,18 @@ int tipc_port_shutdown(u32 ref)
        struct tipc_msg *msg;
        struct tipc_port *p_ptr;
        struct sk_buff *buf = NULL;
+       u32 peer_node;
 
        p_ptr = tipc_port_lock(ref);
        if (!p_ptr)
                return -EINVAL;
-
-       buf = port_build_peer_abort_msg(p_ptr, TIPC_CONN_SHUTDOWN);
+       peer_node = tipc_port_peernode(p_ptr);
+       buf = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, TIPC_CONN_MSG,
+                             SHORT_H_SIZE, 0, peer_node,
+                             tipc_own_addr, tipc_port_peerport(p_ptr),
+                             p_ptr->ref, TIPC_CONN_SHUTDOWN);
        tipc_port_unlock(p_ptr);
        msg = buf_msg(buf);
-       tipc_link_xmit(buf, msg_destnode(msg),  msg_link_selector(msg));
+       tipc_link_xmit(buf, peer_node,  msg_link_selector(msg));
        return tipc_port_disconnect(ref);
 }

diff --git a/net/tipc/socket.c b/net/tipc/socket.c
index a8be4d2001f7adfa2e6aec773bd6bd4a0a97a71c..5f8376e8da2a417228ed4fbf1b97316f6b773406 100644 (file)
--- a/net/tipc/socket.c
+++ b/net/tipc/socket.c
@@ -53,6 +53,7 @@ static void tipc_write_space(struct sock *sk);
 static int tipc_release(struct socket *sock);
 static int tipc_accept(struct socket *sock, struct socket *new_sock, int flags);
 static int tipc_wait_for_sndmsg(struct socket *sock, long *timeo_p);
+static void tipc_sk_timeout(unsigned long ref);
 
 static const struct proto_ops packet_ops;
 static const struct proto_ops stream_ops;
@@ -202,6 +203,7 @@ static int tipc_sk_create(struct net *net, struct socket *sock,
        sock->state = state;
 
        sock_init_data(sock, sk);
+       k_init_timer(&port->timer, (Handler)tipc_sk_timeout, ref);
        sk->sk_backlog_rcv = tipc_backlog_rcv;
        sk->sk_rcvbuf = sysctl_tipc_rmem[1];
        sk->sk_data_ready = tipc_data_ready;
@@ -1946,6 +1948,50 @@ restart:
        return res;
 }
 
+static void tipc_sk_timeout(unsigned long ref)
+{
+       struct tipc_port *port = tipc_port_lock(ref);
+       struct tipc_sock *tsk;
+       struct sock *sk;
+       struct sk_buff *buf = NULL;
+       struct tipc_msg *msg = NULL;
+       u32 peer_port, peer_node;
+
+       if (!port)
+               return;
+
+       if (!port->connected) {
+               tipc_port_unlock(port);
+               return;
+       }
+       tsk = tipc_port_to_sock(port);
+       sk = &tsk->sk;
+       bh_lock_sock(sk);
+       peer_port = tipc_port_peerport(port);
+       peer_node = tipc_port_peernode(port);
+
+       if (port->probing_state == TIPC_CONN_PROBING) {
+               /* Previous probe not answered -> self abort */
+               buf = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, TIPC_CONN_MSG,
+                                     SHORT_H_SIZE, 0, tipc_own_addr,
+                                     peer_node, ref, peer_port,
+                                     TIPC_ERR_NO_PORT);
+       } else {
+               buf = tipc_msg_create(CONN_MANAGER, CONN_PROBE, INT_H_SIZE,
+                                     0, peer_node, tipc_own_addr,
+                                     peer_port, ref, TIPC_OK);
+               port->probing_state = TIPC_CONN_PROBING;
+               k_start_timer(&port->timer, port->probing_interval);
+       }
+       bh_unlock_sock(sk);
+       tipc_port_unlock(port);
+       if (!buf)
+               return;
+
+       msg = buf_msg(buf);
+       tipc_link_xmit(buf, msg_destnode(msg),  msg_link_selector(msg));
+}
+
 /**
  * tipc_setsockopt - set socket option
  * @sock: socket structure