LU-3963 libcfs: remove proc handler wrappers

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

diff --git a/lnet/lnet/lib-eq.c b/lnet/lnet/lib-eq.c
index dde4f45..1e6b9af 100644 (file)
--- a/lnet/lnet/lib-eq.c
+++ b/lnet/lnet/lib-eq.c
@@ -26,6 +26,8 @@
 /*
  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
+ *
+ * Copyright (c) 2012, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -120,7 +122,7 @@ LNetEQAlloc(unsigned int count, lnet_eq_handler_t callback,
        lnet_eq_wait_lock();
 
        lnet_res_lh_initialize(&the_lnet.ln_eq_container, &eq->eq_lh);
-       cfs_list_add(&eq->eq_list, &the_lnet.ln_eq_container.rec_active);
+       list_add(&eq->eq_list, &the_lnet.ln_eq_container.rec_active);
 
        lnet_eq_wait_unlock();
        lnet_res_unlock(LNET_LOCK_EX);
@@ -138,6 +140,7 @@ failed:
        lnet_eq_free(eq);
        return -ENOMEM;
 }
+EXPORT_SYMBOL(LNetEQAlloc);
 
 /**
  * Release the resources associated with an event queue if it's idle;
@@ -191,7 +194,7 @@ LNetEQFree(lnet_handle_eq_t eqh)
        refs    = eq->eq_refs;
 
        lnet_res_lh_invalidate(&eq->eq_lh);
-       cfs_list_del(&eq->eq_list);
+       list_del(&eq->eq_list);
        lnet_eq_free_locked(eq);
  out:
        lnet_eq_wait_unlock();
@@ -204,6 +207,7 @@ LNetEQFree(lnet_handle_eq_t eqh)
 
        return rc;
 }
+EXPORT_SYMBOL(LNetEQFree);
 
 void
 lnet_eq_enqueue_event(lnet_eq_t *eq, lnet_event_t *ev)
@@ -230,8 +234,8 @@ lnet_eq_enqueue_event(lnet_eq_t *eq, lnet_event_t *ev)
 
 #ifdef __KERNEL__
        /* Wake anyone waiting in LNetEQPoll() */
-       if (cfs_waitq_active(&the_lnet.ln_eq_waitq))
-               cfs_waitq_broadcast(&the_lnet.ln_eq_waitq);
+       if (waitqueue_active(&the_lnet.ln_eq_waitq))
+               wake_up_all(&the_lnet.ln_eq_waitq);
 #else
 # ifndef HAVE_LIBPTHREAD
        /* LNetEQPoll() calls into _the_ LND to wait for action */
@@ -255,8 +259,8 @@ lnet_eq_dequeue_event(lnet_eq_t *eq, lnet_event_t *ev)
        if (LNET_SEQ_GT(eq->eq_deq_seq, new_event->sequence))
                RETURN(0);
 
-        /* We've got a new event... */
-        *ev = *new_event;
+       /* We've got a new event... */
+       *ev = *new_event;
 
        CDEBUG(D_INFO, "event: %p, sequence: %lu, eq->size: %u\n",
               new_event, eq->eq_deq_seq, eq->eq_size);
@@ -300,6 +304,7 @@ LNetEQGet (lnet_handle_eq_t eventq, lnet_event_t *event)
         return LNetEQPoll(&eventq, 1, 0,
                          event, &which);
 }
+EXPORT_SYMBOL(LNetEQGet);
 
 /**
  * Block the calling process until there is an event in the EQ.
@@ -325,34 +330,36 @@ LNetEQWait (lnet_handle_eq_t eventq, lnet_event_t *event)
         return LNetEQPoll(&eventq, 1, LNET_TIME_FOREVER,
                          event, &which);
 }
+EXPORT_SYMBOL(LNetEQWait);
 
 #ifdef __KERNEL__
 
 static int
 lnet_eq_wait_locked(int *timeout_ms)
+__must_hold(&the_lnet.ln_eq_wait_lock)
 {
-       int              tms = *timeout_ms;
-       int              wait;
-       cfs_waitlink_t   wl;
-       cfs_time_t       now;
+       int             tms = *timeout_ms;
+       int             wait;
+       wait_queue_t  wl;
+       cfs_time_t      now;
 
        if (tms == 0)
                return -1; /* don't want to wait and no new event */
 
-       cfs_waitlink_init(&wl);
-       cfs_set_current_state(CFS_TASK_INTERRUPTIBLE);
-       cfs_waitq_add(&the_lnet.ln_eq_waitq, &wl);
+       init_waitqueue_entry_current(&wl);
+       set_current_state(TASK_INTERRUPTIBLE);
+       add_wait_queue(&the_lnet.ln_eq_waitq, &wl);
 
        lnet_eq_wait_unlock();
 
        if (tms < 0) {
-               cfs_waitq_wait(&wl, CFS_TASK_INTERRUPTIBLE);
+               waitq_wait(&wl, TASK_INTERRUPTIBLE);
 
        } else {
                struct timeval tv;
 
                now = cfs_time_current();
-               cfs_waitq_timedwait(&wl, CFS_TASK_INTERRUPTIBLE,
+               waitq_timedwait(&wl, TASK_INTERRUPTIBLE,
                                    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);
@@ -364,7 +371,7 @@ lnet_eq_wait_locked(int *timeout_ms)
        *timeout_ms = tms;
 
        lnet_eq_wait_lock();
-       cfs_waitq_del(&the_lnet.ln_eq_waitq, &wl);
+       remove_wait_queue(&the_lnet.ln_eq_waitq, &wl);
 
        return wait;
 }
@@ -388,28 +395,28 @@ lnet_eq_cond_wait(struct timespec *ts)
 static int
 lnet_eq_wait_locked(int *timeout_ms)
 {
-       lnet_ni_t         *eq_waitni = NULL;
-       int                tms = *timeout_ms;
-       int                wait;
-       struct timeval     then;
-       struct timeval     now;
+       lnet_ni_t       *eq_waitni = NULL;
+       int             tms = *timeout_ms;
+       int             wait;
+       struct timeval  then;
+       struct timeval  now;
 
        if (the_lnet.ln_eq_waitni != NULL) {
                /* I have a single NI that I have to call into, to get
                 * events queued, or to block. */
                lnet_eq_wait_unlock();
 
-               LNET_LOCK();
+               lnet_net_lock(0);
                eq_waitni = the_lnet.ln_eq_waitni;
                if (unlikely(eq_waitni == NULL)) {
-                       LNET_UNLOCK();
+                       lnet_net_unlock(0);
 
                        lnet_eq_wait_lock();
                        return -1;
                }
 
-               lnet_ni_addref_locked(eq_waitni);
-               LNET_UNLOCK();
+               lnet_ni_addref_locked(eq_waitni, 0);
+               lnet_net_unlock(0);
 
                if (tms <= 0) { /* even for tms == 0 */
                        (eq_waitni->ni_lnd->lnd_wait)(eq_waitni, tms);
@@ -501,8 +508,8 @@ lnet_eq_wait_locked(int *timeout_ms)
  * \retval -ENOENT    If there's an invalid handle in \a eventqs.
  */
 int
-LNetEQPoll (lnet_handle_eq_t *eventqs, int neq, int timeout_ms,
-            lnet_event_t *event, int *which)
+LNetEQPoll(lnet_handle_eq_t *eventqs, int neq, int timeout_ms,
+          lnet_event_t *event, int *which)
 {
        int     wait = 1;
        int     rc;
@@ -517,7 +524,7 @@ LNetEQPoll (lnet_handle_eq_t *eventqs, int neq, int timeout_ms,
 
        lnet_eq_wait_lock();
 
-        for (;;) {
+       for (;;) {
 #ifndef __KERNEL__
                lnet_eq_wait_unlock();