X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lnet%2Flnet%2Flib-eq.c;h=50ac435e9ed8c7f6fde92aa65c4dcf4911d64d05;hp=dde4f45de2c2d518ccddcb6c2442b51c8fd6a546;hb=48a0697d79101ad3ff7651779808dcf002a68890;hpb=279bbc81e03dc74d273ec12b4d9e703ca94404c4

diff --git a/lnet/lnet/lib-eq.c b/lnet/lnet/lib-eq.c
index dde4f45..50ac435 100644
--- 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 */
@@ -243,7 +247,7 @@ lnet_eq_enqueue_event(lnet_eq_t *eq, lnet_event_t *ev)
 	lnet_eq_wait_unlock();
 }
 
-int
+static int
 lnet_eq_dequeue_event(lnet_eq_t *eq, lnet_event_t *ev)
 {
 	int		new_index = eq->eq_deq_seq & (eq->eq_size - 1);
@@ -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();