LU-9019 lnet: simplify lnet_eq_wait_locked

[fs/lustre-release.git] / lnet / lnet / lib-eq.c

diff --git a/lnet/lnet/lib-eq.c b/lnet/lnet/lib-eq.c
index 665b84b..4ff2ba6 100644 (file)
--- a/lnet/lnet/lib-eq.c
+++ b/lnet/lnet/lib-eq.c
@@ -313,44 +313,30 @@ LNetEQWait (lnet_handle_eq_t eventq, lnet_event_t *event)
 {
        int which;
 
-       return LNetEQPoll(&eventq, 1, LNET_TIME_FOREVER,
-                        event, &which);
+       return LNetEQPoll(&eventq, 1, MAX_SCHEDULE_TIMEOUT,
+                         event, &which);
 }
 EXPORT_SYMBOL(LNetEQWait);
 
 static int
-lnet_eq_wait_locked(int *timeout_ms)
+lnet_eq_wait_locked(signed long *timeout)
 __must_hold(&the_lnet.ln_eq_wait_lock)
 {
-       int             tms = *timeout_ms;
-       int             wait;
-       wait_queue_t    wl;
-       cfs_time_t      now;
+       signed long tms = *timeout;
+       wait_queue_t wl;
+       int wait;
 
        if (tms == 0)
                return -ENXIO; /* don't want to wait and no new event */
 
        init_waitqueue_entry(&wl, current);
-       set_current_state(TASK_INTERRUPTIBLE);
        add_wait_queue(&the_lnet.ln_eq_waitq, &wl);
 
        lnet_eq_wait_unlock();
 
-       if (tms < 0) {
-               schedule();
-       } else {
-               struct timeval tv;
-
-               now = cfs_time_current();
-               schedule_timeout(cfs_time_seconds(tms) / 1000);
-               cfs_duration_usec(cfs_time_sub(cfs_time_current(), now), &tv);
-               tms -= (int)(tv.tv_sec * 1000 + tv.tv_usec / 1000);
-               if (tms < 0) /* no more wait but may have new event */
-                       tms = 0;
-       }
-
+       tms = schedule_timeout_interruptible(tms);
        wait = tms != 0; /* might need to call here again */
-       *timeout_ms = tms;
+       *timeout = tms;
 
        lnet_eq_wait_lock();
        remove_wait_queue(&the_lnet.ln_eq_waitq, &wl);
@@ -370,8 +356,8 @@ __must_hold(&the_lnet.ln_eq_wait_lock)
  * fixed period, or block indefinitely.
  *
  * \param eventqs,neq An array of EQ handles, and size of the array.
- * \param timeout_ms Time in milliseconds to wait for an event to occur on
- * one of the EQs. The constant LNET_TIME_FOREVER can be used to indicate an
+ * \param timeout Time in jiffies to wait for an event to occur on
+ * one of the EQs. The constant MAX_SCHEDULE_TIMEOUT can be used to indicate an
  * infinite timeout.
  * \param event,which On successful return (1 or -EOVERFLOW), \a event will
  * hold the next event in the EQs, and \a which will contain the index of the
@@ -385,7 +371,7 @@ __must_hold(&the_lnet.ln_eq_wait_lock)
  * \retval -ENOENT    If there's an invalid handle in \a eventqs.
  */
 int
-LNetEQPoll(lnet_handle_eq_t *eventqs, int neq, int timeout_ms,
+LNetEQPoll(lnet_handle_eq_t *eventqs, int neq, signed long timeout,
           lnet_event_t *event, int *which)
 {
        int     wait = 1;
@@ -427,7 +413,7 @@ LNetEQPoll(lnet_handle_eq_t *eventqs, int neq, int timeout_ms,
                 *  0 : don't want to wait anymore, but might have new event
                 *      so need to call dequeue again
                 */
-               wait = lnet_eq_wait_locked(&timeout_ms);
+               wait = lnet_eq_wait_locked(&timeout);
                if (wait < 0) /* no new event */
                        break;
        }