tipc: remove unnecessary wrapper functions of kernel timer APIs
authorYing Xue <ying.xue@windriver.com>
Fri, 9 Jan 2015 07:27:00 +0000 (15:27 +0800)
committerDavid S. Miller <davem@davemloft.net>
Mon, 12 Jan 2015 21:24:31 +0000 (16:24 -0500)
Not only some wrapper function like k_term_timer() is empty, but also
some others including k_start_timer() and k_cancel_timer() don't return
back any value to its caller, what's more, there is no any component
in the kernel world to do such thing. Therefore, these timer interfaces
defined in tipc module should be purged.

Signed-off-by: Ying Xue <ying.xue@windriver.com>
Tested-by: Tero Aho <Tero.Aho@coriant.com>
Reviewed-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
net/tipc/core.h
net/tipc/discover.c
net/tipc/link.c
net/tipc/link.h
net/tipc/msg.h
net/tipc/socket.c
net/tipc/subscr.c
net/tipc/subscr.h

index 56fe4229fc5e4de044d19a41eb128297da87a670..d57068961d4c00f67202a53c7cf30c427d0979b9 100644 (file)
@@ -106,73 +106,6 @@ void tipc_unregister_sysctl(void);
 #define tipc_unregister_sysctl()
 #endif
 
-/*
- * TIPC timer code
- */
-typedef void (*Handler) (unsigned long);
-
-/**
- * k_init_timer - initialize a timer
- * @timer: pointer to timer structure
- * @routine: pointer to routine to invoke when timer expires
- * @argument: value to pass to routine when timer expires
- *
- * Timer must be initialized before use (and terminated when no longer needed).
- */
-static inline void k_init_timer(struct timer_list *timer, Handler routine,
-                               unsigned long argument)
-{
-       setup_timer(timer, routine, argument);
-}
-
-/**
- * k_start_timer - start a timer
- * @timer: pointer to timer structure
- * @msec: time to delay (in ms)
- *
- * Schedules a previously initialized timer for later execution.
- * If timer is already running, the new timeout overrides the previous request.
- *
- * To ensure the timer doesn't expire before the specified delay elapses,
- * the amount of delay is rounded up when converting to the jiffies
- * then an additional jiffy is added to account for the fact that
- * the starting time may be in the middle of the current jiffy.
- */
-static inline void k_start_timer(struct timer_list *timer, unsigned long msec)
-{
-       mod_timer(timer, jiffies + msecs_to_jiffies(msec) + 1);
-}
-
-/**
- * k_cancel_timer - cancel a timer
- * @timer: pointer to timer structure
- *
- * Cancels a previously initialized timer.
- * Can be called safely even if the timer is already inactive.
- *
- * WARNING: Must not be called when holding locks required by the timer's
- *          timeout routine, otherwise deadlock can occur on SMP systems!
- */
-static inline void k_cancel_timer(struct timer_list *timer)
-{
-       del_timer_sync(timer);
-}
-
-/**
- * k_term_timer - terminate a timer
- * @timer: pointer to timer structure
- *
- * Prevents further use of a previously initialized timer.
- *
- * WARNING: Caller must ensure timer isn't currently running.
- *
- * (Do not "enhance" this routine to automatically cancel an active timer,
- * otherwise deadlock can arise when a timeout routine calls k_term_timer.)
- */
-static inline void k_term_timer(struct timer_list *timer)
-{
-}
-
 /*
  * TIPC message buffer code
  *
index aa722a42ef8b03b4d840e31bbf7582d51948fbae..1a3a985820342a41618091163f1da84fd85d798c 100644 (file)
 #include "link.h"
 #include "discover.h"
 
-#define TIPC_LINK_REQ_INIT     125     /* min delay during bearer start up */
-#define TIPC_LINK_REQ_FAST     1000    /* max delay if bearer has no links */
-#define TIPC_LINK_REQ_SLOW     60000   /* max delay if bearer has links */
-#define TIPC_LINK_REQ_INACTIVE 0xffffffff /* indicates no timer in use */
+/* min delay during bearer start up */
+#define TIPC_LINK_REQ_INIT     msecs_to_jiffies(125)
+/* max delay if bearer has no links */
+#define TIPC_LINK_REQ_FAST     msecs_to_jiffies(1000)
+/* max delay if bearer has links */
+#define TIPC_LINK_REQ_SLOW     msecs_to_jiffies(60000)
+/* indicates no timer in use */
+#define TIPC_LINK_REQ_INACTIVE 0xffffffff
 
 
 /**
@@ -63,7 +67,7 @@ struct tipc_link_req {
        spinlock_t lock;
        struct sk_buff *buf;
        struct timer_list timer;
-       unsigned int timer_intv;
+       unsigned long timer_intv;
 };
 
 /**
@@ -265,7 +269,7 @@ static void disc_update(struct tipc_link_req *req)
                if ((req->timer_intv == TIPC_LINK_REQ_INACTIVE) ||
                    (req->timer_intv > TIPC_LINK_REQ_FAST)) {
                        req->timer_intv = TIPC_LINK_REQ_INIT;
-                       k_start_timer(&req->timer, req->timer_intv);
+                       mod_timer(&req->timer, jiffies + req->timer_intv);
                }
        }
 }
@@ -295,12 +299,13 @@ void tipc_disc_remove_dest(struct tipc_link_req *req)
 
 /**
  * disc_timeout - send a periodic link setup request
- * @req: ptr to link request structure
+ * @data: ptr to link request structure
  *
  * Called whenever a link setup request timer associated with a bearer expires.
  */
-static void disc_timeout(struct tipc_link_req *req)
+static void disc_timeout(unsigned long data)
 {
+       struct tipc_link_req *req = (struct tipc_link_req *)data;
        int max_delay;
 
        spin_lock_bh(&req->lock);
@@ -329,7 +334,7 @@ static void disc_timeout(struct tipc_link_req *req)
        if (req->timer_intv > max_delay)
                req->timer_intv = max_delay;
 
-       k_start_timer(&req->timer, req->timer_intv);
+       mod_timer(&req->timer, jiffies + req->timer_intv);
 exit:
        spin_unlock_bh(&req->lock);
 }
@@ -363,8 +368,8 @@ int tipc_disc_create(struct tipc_bearer *b_ptr, struct tipc_media_addr *dest)
        req->num_nodes = 0;
        req->timer_intv = TIPC_LINK_REQ_INIT;
        spin_lock_init(&req->lock);
-       k_init_timer(&req->timer, (Handler)disc_timeout, (unsigned long)req);
-       k_start_timer(&req->timer, req->timer_intv);
+       setup_timer(&req->timer, disc_timeout, (unsigned long)req);
+       mod_timer(&req->timer, jiffies + req->timer_intv);
        b_ptr->link_req = req;
        tipc_bearer_send(req->bearer_id, req->buf, &req->dest);
        return 0;
@@ -376,8 +381,7 @@ int tipc_disc_create(struct tipc_bearer *b_ptr, struct tipc_media_addr *dest)
  */
 void tipc_disc_delete(struct tipc_link_req *req)
 {
-       k_cancel_timer(&req->timer);
-       k_term_timer(&req->timer);
+       del_timer_sync(&req->timer);
        kfree_skb(req->buf);
        kfree(req);
 }
@@ -397,7 +401,7 @@ void tipc_disc_reset(struct tipc_bearer *b_ptr)
        req->domain = b_ptr->domain;
        req->num_nodes = 0;
        req->timer_intv = TIPC_LINK_REQ_INIT;
-       k_start_timer(&req->timer, req->timer_intv);
+       mod_timer(&req->timer, jiffies + req->timer_intv);
        tipc_bearer_send(req->bearer_id, req->buf, &req->dest);
        spin_unlock_bh(&req->lock);
 }
index 082c3b5b32a12094806db13c46a93994781379d0..f2531a8efa54f479d97700b6c24fedd77def52b0 100644 (file)
@@ -106,7 +106,7 @@ static void link_handle_out_of_seq_msg(struct tipc_link *l_ptr,
 static void tipc_link_proto_rcv(struct tipc_link *l_ptr, struct sk_buff *buf);
 static int  tipc_link_tunnel_rcv(struct tipc_node *n_ptr,
                                 struct sk_buff **buf);
-static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tolerance);
+static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tol);
 static void link_state_event(struct tipc_link *l_ptr, u32 event);
 static void link_reset_statistics(struct tipc_link *l_ptr);
 static void link_print(struct tipc_link *l_ptr, const char *str);
@@ -169,8 +169,9 @@ int tipc_link_is_active(struct tipc_link *l_ptr)
  * link_timeout - handle expiration of link timer
  * @l_ptr: pointer to link
  */
-static void link_timeout(struct tipc_link *l_ptr)
+static void link_timeout(unsigned long data)
 {
+       struct tipc_link *l_ptr = (struct tipc_link *)data;
        struct sk_buff *skb;
 
        tipc_node_lock(l_ptr->owner);
@@ -217,9 +218,9 @@ static void link_timeout(struct tipc_link *l_ptr)
        tipc_node_unlock(l_ptr->owner);
 }
 
-static void link_set_timer(struct tipc_link *l_ptr, u32 time)
+static void link_set_timer(struct tipc_link *link, unsigned long time)
 {
-       k_start_timer(&l_ptr->timer, time);
+       mod_timer(&link->timer, jiffies + time);
 }
 
 /**
@@ -299,8 +300,7 @@ struct tipc_link *tipc_link_create(struct tipc_node *n_ptr,
 
        tipc_node_attach_link(n_ptr, l_ptr);
 
-       k_init_timer(&l_ptr->timer, (Handler)link_timeout,
-                    (unsigned long)l_ptr);
+       setup_timer(&l_ptr->timer, link_timeout, (unsigned long)l_ptr);
 
        link_state_event(l_ptr, STARTING_EVT);
 
@@ -479,7 +479,7 @@ static void link_activate(struct tipc_link *l_ptr)
 static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
 {
        struct tipc_link *other;
-       u32 cont_intv = l_ptr->continuity_interval;
+       unsigned long cont_intv = l_ptr->cont_intv;
 
        if (l_ptr->flags & LINK_STOPPED)
                return;
@@ -1880,15 +1880,16 @@ void tipc_link_bundle_rcv(struct sk_buff *buf)
        kfree_skb(buf);
 }
 
-static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tolerance)
+static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tol)
 {
-       if ((tolerance < TIPC_MIN_LINK_TOL) || (tolerance > TIPC_MAX_LINK_TOL))
+       unsigned long intv = ((tol / 4) > 500) ? 500 : tol / 4;
+
+       if ((tol < TIPC_MIN_LINK_TOL) || (tol > TIPC_MAX_LINK_TOL))
                return;
 
-       l_ptr->tolerance = tolerance;
-       l_ptr->continuity_interval =
-               ((tolerance / 4) > 500) ? 500 : tolerance / 4;
-       l_ptr->abort_limit = tolerance / (l_ptr->continuity_interval / 4);
+       l_ptr->tolerance = tol;
+       l_ptr->cont_intv = msecs_to_jiffies(intv);
+       l_ptr->abort_limit = tol / (jiffies_to_msecs(l_ptr->cont_intv) / 4);
 }
 
 void tipc_link_set_queue_limits(struct tipc_link *l_ptr, u32 window)
index 55812e87ca1e2a4b6cb460e067599edc9bbf158d..15ca850391df9fce41499dfae2c8be394a1a1e06 100644 (file)
@@ -105,7 +105,7 @@ struct tipc_stats {
  * @peer_bearer_id: bearer id used by link's peer endpoint
  * @bearer_id: local bearer id used by link
  * @tolerance: minimum link continuity loss needed to reset link [in ms]
- * @continuity_interval: link continuity testing interval [in ms]
+ * @cont_intv: link continuity testing interval
  * @abort_limit: # of unacknowledged continuity probes needed to reset link
  * @state: current state of link FSM
  * @fsm_msg_cnt: # of protocol messages link FSM has sent in current state
@@ -146,7 +146,7 @@ struct tipc_link {
        u32 peer_bearer_id;
        u32 bearer_id;
        u32 tolerance;
-       u32 continuity_interval;
+       unsigned long cont_intv;
        u32 abort_limit;
        int state;
        u32 fsm_msg_cnt;
index d5c83d7ecb479f30de9fe9b8f8aadbac5aa0c64b..1a52f7cf3cd3664a1b515d99657129e0df772b18 100644 (file)
 
 #define TIPC_MEDIA_ADDR_OFFSET 5
 
-
 struct tipc_msg {
        __be32 hdr[15];
 };
 
-
 static inline u32 msg_word(struct tipc_msg *m, u32 pos)
 {
        return ntohl(m->hdr[pos]);
index 701f31bbbbfb727202e2cc72e9a5a940c7014bc5..e16197eb7b9ff52af6a58abb68ebc67cb2553630 100644 (file)
@@ -47,7 +47,7 @@
 #define SS_READY               -2      /* socket is connectionless */
 
 #define CONN_TIMEOUT_DEFAULT   8000    /* default connect timeout = 8s */
-#define CONN_PROBING_INTERVAL  3600000 /* [ms] => 1 h */
+#define CONN_PROBING_INTERVAL  msecs_to_jiffies(3600000)  /* [ms] => 1 h */
 #define TIPC_FWD_MSG           1
 #define TIPC_CONN_OK           0
 #define TIPC_CONN_PROBING      1
@@ -68,7 +68,7 @@
  * @publications: list of publications for port
  * @pub_count: total # of publications port has made during its lifetime
  * @probing_state:
- * @probing_interval:
+ * @probing_intv:
  * @timer:
  * @port: port - interacts with 'sk' and with the rest of the TIPC stack
  * @peer_name: the peer of the connection, if any
@@ -93,7 +93,7 @@ struct tipc_sock {
        struct list_head publications;
        u32 pub_count;
        u32 probing_state;
-       u32 probing_interval;
+       unsigned long probing_intv;
        struct timer_list timer;
        uint conn_timeout;
        atomic_t dupl_rcvcnt;
@@ -361,7 +361,7 @@ static int tipc_sk_create(struct net *net, struct socket *sock,
                return -EINVAL;
        }
        msg_set_origport(msg, tsk->portid);
-       k_init_timer(&tsk->timer, (Handler)tipc_sk_timeout, tsk->portid);
+       setup_timer(&tsk->timer, tipc_sk_timeout, tsk->portid);
        sk->sk_backlog_rcv = tipc_backlog_rcv;
        sk->sk_rcvbuf = sysctl_tipc_rmem[1];
        sk->sk_data_ready = tipc_data_ready;
@@ -511,7 +511,7 @@ static int tipc_release(struct socket *sock)
        }
 
        tipc_sk_withdraw(tsk, 0, NULL);
-       k_cancel_timer(&tsk->timer);
+       del_timer_sync(&tsk->timer);
        tipc_sk_remove(tsk);
        if (tsk->connected) {
                skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, TIPC_CONN_MSG,
@@ -522,7 +522,6 @@ static int tipc_release(struct socket *sock)
                        tipc_link_xmit_skb(skb, dnode, tsk->portid);
                tipc_node_remove_conn(dnode, tsk->portid);
        }
-       k_term_timer(&tsk->timer);
 
        /* Discard any remaining (connection-based) messages in receive queue */
        __skb_queue_purge(&sk->sk_receive_queue);
@@ -1139,10 +1138,10 @@ static void tipc_sk_finish_conn(struct tipc_sock *tsk, u32 peer_port,
        msg_set_lookup_scope(msg, 0);
        msg_set_hdr_sz(msg, SHORT_H_SIZE);
 
-       tsk->probing_interval = CONN_PROBING_INTERVAL;
+       tsk->probing_intv = CONN_PROBING_INTERVAL;
        tsk->probing_state = TIPC_CONN_OK;
        tsk->connected = 1;
-       k_start_timer(&tsk->timer, tsk->probing_interval);
+       mod_timer(&tsk->timer, jiffies + tsk->probing_intv);
        tipc_node_add_conn(peer_node, tsk->portid, peer_port);
        tsk->max_pkt = tipc_node_get_mtu(peer_node, tsk->portid);
 }
@@ -2128,7 +2127,7 @@ static void tipc_sk_timeout(unsigned long portid)
                                      0, peer_node, tipc_own_addr,
                                      peer_port, portid, TIPC_OK);
                tsk->probing_state = TIPC_CONN_PROBING;
-               k_start_timer(&tsk->timer, tsk->probing_interval);
+               mod_timer(&tsk->timer, jiffies + tsk->probing_intv);
        }
        bh_unlock_sock(sk);
        if (skb)
index 0344206b984f7f168a742726e8ad853940ff9cec..e6cb959371dc43458ef2344a1db0475f2c0836b9 100644 (file)
@@ -141,8 +141,9 @@ void tipc_subscr_report_overlap(struct tipc_subscription *sub, u32 found_lower,
        subscr_send_event(sub, found_lower, found_upper, event, port_ref, node);
 }
 
-static void subscr_timeout(struct tipc_subscription *sub)
+static void subscr_timeout(unsigned long data)
 {
+       struct tipc_subscription *sub = (struct tipc_subscription *)data;
        struct tipc_subscriber *subscriber = sub->subscriber;
 
        /* The spin lock per subscriber is used to protect its members */
@@ -167,7 +168,6 @@ static void subscr_timeout(struct tipc_subscription *sub)
                          TIPC_SUBSCR_TIMEOUT, 0, 0);
 
        /* Now destroy subscription */
-       k_term_timer(&sub->timer);
        kfree(sub);
        atomic_dec(&subscription_count);
 }
@@ -207,8 +207,7 @@ static void subscr_release(struct tipc_subscriber *subscriber)
                                 subscription_list) {
                if (sub->timeout != TIPC_WAIT_FOREVER) {
                        spin_unlock_bh(&subscriber->lock);
-                       k_cancel_timer(&sub->timer);
-                       k_term_timer(&sub->timer);
+                       del_timer_sync(&sub->timer);
                        spin_lock_bh(&subscriber->lock);
                }
                subscr_del(sub);
@@ -250,8 +249,7 @@ static void subscr_cancel(struct tipc_subscr *s,
        if (sub->timeout != TIPC_WAIT_FOREVER) {
                sub->timeout = TIPC_WAIT_FOREVER;
                spin_unlock_bh(&subscriber->lock);
-               k_cancel_timer(&sub->timer);
-               k_term_timer(&sub->timer);
+               del_timer_sync(&sub->timer);
                spin_lock_bh(&subscriber->lock);
        }
        subscr_del(sub);
@@ -296,7 +294,7 @@ static int subscr_subscribe(struct tipc_subscr *s,
        sub->seq.type = htohl(s->seq.type, swap);
        sub->seq.lower = htohl(s->seq.lower, swap);
        sub->seq.upper = htohl(s->seq.upper, swap);
-       sub->timeout = htohl(s->timeout, swap);
+       sub->timeout = msecs_to_jiffies(htohl(s->timeout, swap));
        sub->filter = htohl(s->filter, swap);
        if ((!(sub->filter & TIPC_SUB_PORTS) ==
             !(sub->filter & TIPC_SUB_SERVICE)) ||
@@ -311,9 +309,8 @@ static int subscr_subscribe(struct tipc_subscr *s,
        memcpy(&sub->evt.s, s, sizeof(struct tipc_subscr));
        atomic_inc(&subscription_count);
        if (sub->timeout != TIPC_WAIT_FOREVER) {
-               k_init_timer(&sub->timer,
-                            (Handler)subscr_timeout, (unsigned long)sub);
-               k_start_timer(&sub->timer, sub->timeout);
+               setup_timer(&sub->timer, subscr_timeout, (unsigned long)sub);
+               mod_timer(&sub->timer, jiffies + sub->timeout);
        }
        *sub_p = sub;
        return 0;
index 393e417bee3f51f8703047cdf6ac6a2a6b8654be..ab01713bfe32707693dc3be368c2eff85ad90fca 100644 (file)
@@ -58,7 +58,7 @@ struct tipc_subscriber;
 struct tipc_subscription {
        struct tipc_subscriber *subscriber;
        struct tipc_name_seq seq;
-       u32 timeout;
+       unsigned long timeout;
        u32 filter;
        struct timer_list timer;
        struct list_head nameseq_list;