LU-6142 lnet: replace white spaces with tabs for LNet core

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

diff --git a/lnet/lnet/lib-eq.c b/lnet/lnet/lib-eq.c
index 8e95154..8d862fe 100644 (file)
--- a/lnet/lnet/lib-eq.c
+++ b/lnet/lnet/lib-eq.c
@@ -60,7 +60,7 @@
  * \param handle On successful return, this location will hold a handle for
  * the newly created EQ.
  *
- * \retval 0       On success.
+ * \retval 0      On success.
  * \retval -EINVAL If an parameter is not valid.
  * \retval -ENOMEM If memory for the EQ can't be allocated.
  *
@@ -68,15 +68,15 @@
  */
 int
 LNetEQAlloc(unsigned int count, lnet_eq_handler_t callback,
-            lnet_handle_eq_t *handle)
+           lnet_handle_eq_t *handle)
 {
-        lnet_eq_t     *eq;
+       lnet_eq_t     *eq;
 
-        LASSERT (the_lnet.ln_refcount > 0);
+       LASSERT(the_lnet.ln_refcount > 0);
 
-        /* We need count to be a power of 2 so that when eq_{enq,deq}_seq
-         * overflow, they don't skip entries, so the queue has the same
-         * apparent capacity at all times */
+       /* We need count to be a power of 2 so that when eq_{enq,deq}_seq
+        * overflow, they don't skip entries, so the queue has the same
+        * apparent capacity at all times */
 
        if (count)
                count = roundup_pow_of_two(count);
@@ -105,10 +105,10 @@ LNetEQAlloc(unsigned int count, lnet_eq_handler_t callback,
                 * so all them should be earlier than eq_deq_seq */
        }
 
-        eq->eq_deq_seq = 1;
-        eq->eq_enq_seq = 1;
-        eq->eq_size = count;
-        eq->eq_callback = callback;
+       eq->eq_deq_seq = 1;
+       eq->eq_enq_seq = 1;
+       eq->eq_size = count;
+       eq->eq_callback = callback;
 
        eq->eq_refs = cfs_percpt_alloc(lnet_cpt_table(),
                                       sizeof(*eq->eq_refs[0]));
@@ -255,19 +255,19 @@ lnet_eq_dequeue_event(lnet_eq_t *eq, lnet_event_t *ev)
        CDEBUG(D_INFO, "event: %p, sequence: %lu, eq->size: %u\n",
               new_event, eq->eq_deq_seq, eq->eq_size);
 
-        /* ...but did it overwrite an event we've not seen yet? */
-        if (eq->eq_deq_seq == new_event->sequence) {
-                rc = 1;
-        } else {
-                /* don't complain with CERROR: some EQs are sized small
-                 * anyway; if it's important, the caller should complain */
-                CDEBUG(D_NET, "Event Queue Overflow: eq seq %lu ev seq %lu\n",
-                       eq->eq_deq_seq, new_event->sequence);
-                rc = -EOVERFLOW;
-        }
-
-        eq->eq_deq_seq = new_event->sequence + 1;
-        RETURN(rc);
+       /* ...but did it overwrite an event we've not seen yet? */
+       if (eq->eq_deq_seq == new_event->sequence) {
+               rc = 1;
+       } else {
+               /* don't complain with CERROR: some EQs are sized small
+                * anyway; if it's important, the caller should complain */
+               CDEBUG(D_NET, "Event Queue Overflow: eq seq %lu ev seq %lu\n",
+                      eq->eq_deq_seq, new_event->sequence);
+               rc = -EOVERFLOW;
+       }
+
+       eq->eq_deq_seq = new_event->sequence + 1;
+       RETURN(rc);
 }
 
 /**
@@ -279,8 +279,8 @@ lnet_eq_dequeue_event(lnet_eq_t *eq, lnet_event_t *ev)
  * \param event On successful return (1 or -EOVERFLOW), this location will
  * hold the next event in the EQ.
  *
- * \retval 0          No pending event in the EQ.
- * \retval 1          Indicates success.
+ * \retval 0         No pending event in the EQ.
+ * \retval 1         Indicates success.
  * \retval -ENOENT    If \a eventq does not point to a valid EQ.
  * \retval -EOVERFLOW Indicates success (i.e., an event is returned) and that
  * at least one event between this event and the last event obtained from the
@@ -289,10 +289,10 @@ lnet_eq_dequeue_event(lnet_eq_t *eq, lnet_event_t *ev)
 int
 LNetEQGet (lnet_handle_eq_t eventq, lnet_event_t *event)
 {
-        int which;
+       int which;
 
-        return LNetEQPoll(&eventq, 1, 0,
-                         event, &which);
+       return LNetEQPoll(&eventq, 1, 0,
+                        event, &which);
 }
 EXPORT_SYMBOL(LNetEQGet);
 
@@ -306,7 +306,7 @@ EXPORT_SYMBOL(LNetEQGet);
  * \param event On successful return (1 or -EOVERFLOW), this location will
  * hold the next event in the EQ.
  *
- * \retval 1          Indicates success.
+ * \retval 1         Indicates success.
  * \retval -ENOENT    If \a eventq does not point to a valid EQ.
  * \retval -EOVERFLOW Indicates success (i.e., an event is returned) and that
  * at least one event between this event and the last event obtained from the
@@ -315,10 +315,10 @@ EXPORT_SYMBOL(LNetEQGet);
 int
 LNetEQWait (lnet_handle_eq_t eventq, lnet_event_t *event)
 {
-        int which;
+       int which;
 
-        return LNetEQPoll(&eventq, 1, LNET_TIME_FOREVER,
-                         event, &which);
+       return LNetEQPoll(&eventq, 1, LNET_TIME_FOREVER,
+                        event, &which);
 }
 EXPORT_SYMBOL(LNetEQWait);
 
@@ -329,7 +329,7 @@ __must_hold(&the_lnet.ln_eq_wait_lock)
        int             tms = *timeout_ms;
        int             wait;
        wait_queue_t    wl;
-       cfs_time_t      now;
+       cfs_time_t      now;
 
        if (tms == 0)
                return -ENXIO; /* don't want to wait and no new event */
@@ -381,8 +381,8 @@ __must_hold(&the_lnet.ln_eq_wait_lock)
  * hold the next event in the EQs, and \a which will contain the index of the
  * EQ from which the event was taken.
  *
- * \retval 0          No pending event in the EQs after timeout.
- * \retval 1          Indicates success.
+ * \retval 0         No pending event in the EQs after timeout.
+ * \retval 1         Indicates success.
  * \retval -EOVERFLOW Indicates success (i.e., an event is returned) and that
  * at least one event between this event and the last event obtained from the
  * EQ indicated by \a which has been dropped due to limited space in the EQ.
@@ -395,12 +395,12 @@ LNetEQPoll(lnet_handle_eq_t *eventqs, int neq, int timeout_ms,
        int     wait = 1;
        int     rc;
        int     i;
-        ENTRY;
+       ENTRY;
 
-        LASSERT (the_lnet.ln_refcount > 0);
+       LASSERT(the_lnet.ln_refcount > 0);
 
-        if (neq < 1)
-                RETURN(-ENOENT);
+       if (neq < 1)
+               RETURN(-ENOENT);
 
        lnet_eq_wait_lock();
 
@@ -429,7 +429,7 @@ LNetEQPoll(lnet_handle_eq_t *eventqs, int neq, int timeout_ms,
                 * -1 : did nothing and it's sure no new event
                 *  1 : sleep inside and wait until new event
                 *  0 : don't want to wait anymore, but might have new event
-                *      so need to call dequeue again
+                *      so need to call dequeue again
                 */
                wait = lnet_eq_wait_locked(&timeout_ms);
                if (wait < 0) /* no new event */