LU-8100 tests: Test the correctness of target_obd

[fs/lustre-release.git] / libcfs / libcfs / workitem.c

diff --git a/libcfs/libcfs/workitem.c b/libcfs/libcfs/workitem.c
index 1a4ca46..168fea5 100644 (file)
--- a/libcfs/libcfs/workitem.c
+++ b/libcfs/libcfs/workitem.c
@@ -46,7 +46,7 @@
 
 #define CFS_WS_NAME_LEN         16
 
-typedef struct cfs_wi_sched {
+struct cfs_wi_sched {
        struct list_head                ws_list;        /* chain on global list */
        /** serialised workitems */
        spinlock_t                      ws_lock;
@@ -74,45 +74,33 @@ typedef struct cfs_wi_sched {
        unsigned int            ws_starting:1;
        /** scheduler name */
        char                    ws_name[CFS_WS_NAME_LEN];
-} cfs_wi_sched_t;
+};
 
 static struct cfs_workitem_data {
        /** serialize */
        spinlock_t              wi_glock;
        /** list of all schedulers */
-       struct list_head                wi_scheds;
+       struct list_head        wi_scheds;
        /** WI module is initialized */
        int                     wi_init;
        /** shutting down the whole WI module */
        int                     wi_stopping;
 } cfs_wi_data;
 
-static inline void
-cfs_wi_sched_lock(cfs_wi_sched_t *sched)
-{
-       spin_lock(&sched->ws_lock);
-}
-
-static inline void
-cfs_wi_sched_unlock(cfs_wi_sched_t *sched)
-{
-       spin_unlock(&sched->ws_lock);
-}
-
 static inline int
-cfs_wi_sched_cansleep(cfs_wi_sched_t *sched)
+cfs_wi_sched_cansleep(struct cfs_wi_sched *sched)
 {
-       cfs_wi_sched_lock(sched);
+       spin_lock(&sched->ws_lock);
        if (sched->ws_stopping) {
-               cfs_wi_sched_unlock(sched);
+               spin_unlock(&sched->ws_lock);
                return 0;
        }
 
        if (!list_empty(&sched->ws_runq)) {
-               cfs_wi_sched_unlock(sched);
+               spin_unlock(&sched->ws_lock);
                return 0;
        }
-       cfs_wi_sched_unlock(sched);
+       spin_unlock(&sched->ws_lock);
        return 1;
 }
 
@@ -121,12 +109,12 @@ cfs_wi_sched_cansleep(cfs_wi_sched_t *sched)
  * 1. when it returns no one shall try to schedule the workitem.
  */
 void
-cfs_wi_exit(struct cfs_wi_sched *sched, cfs_workitem_t *wi)
+cfs_wi_exit(struct cfs_wi_sched *sched, struct cfs_workitem *wi)
 {
        LASSERT(!in_interrupt()); /* because we use plain spinlock */
        LASSERT(!sched->ws_stopping);
 
-       cfs_wi_sched_lock(sched);
+       spin_lock(&sched->ws_lock);
 
        LASSERT(wi->wi_running);
 
@@ -141,7 +129,7 @@ cfs_wi_exit(struct cfs_wi_sched *sched, cfs_workitem_t *wi)
        LASSERT(list_empty(&wi->wi_list));
 
        wi->wi_scheduled = 1; /* LBUG future schedule attempts */
-       cfs_wi_sched_unlock(sched);
+       spin_unlock(&sched->ws_lock);
 
        return;
 }
@@ -151,7 +139,7 @@ EXPORT_SYMBOL(cfs_wi_exit);
  * cancel schedule request of workitem \a wi
  */
 int
-cfs_wi_deschedule(struct cfs_wi_sched *sched, cfs_workitem_t *wi)
+cfs_wi_deschedule(struct cfs_wi_sched *sched, struct cfs_workitem *wi)
 {
        int     rc;
 
@@ -163,7 +151,7 @@ cfs_wi_deschedule(struct cfs_wi_sched *sched, cfs_workitem_t *wi)
          * means the workitem will not be scheduled and will not have
          * any race with wi_action.
          */
-       cfs_wi_sched_lock(sched);
+       spin_lock(&sched->ws_lock);
 
        rc = !(wi->wi_running);
 
@@ -179,7 +167,7 @@ cfs_wi_deschedule(struct cfs_wi_sched *sched, cfs_workitem_t *wi)
 
        LASSERT (list_empty(&wi->wi_list));
 
-       cfs_wi_sched_unlock(sched);
+       spin_unlock(&sched->ws_lock);
        return rc;
 }
 EXPORT_SYMBOL(cfs_wi_deschedule);
@@ -192,12 +180,12 @@ EXPORT_SYMBOL(cfs_wi_deschedule);
  * be added, and even dynamic creation of serialised queues might be supported.
  */
 void
-cfs_wi_schedule(struct cfs_wi_sched *sched, cfs_workitem_t *wi)
+cfs_wi_schedule(struct cfs_wi_sched *sched, struct cfs_workitem *wi)
 {
        LASSERT(!in_interrupt()); /* because we use plain spinlock */
        LASSERT(!sched->ws_stopping);
 
-       cfs_wi_sched_lock(sched);
+       spin_lock(&sched->ws_lock);
 
        if (!wi->wi_scheduled) {
                LASSERT (list_empty(&wi->wi_list));
@@ -213,15 +201,15 @@ cfs_wi_schedule(struct cfs_wi_sched *sched, cfs_workitem_t *wi)
        }
 
        LASSERT (!list_empty(&wi->wi_list));
-       cfs_wi_sched_unlock(sched);
+       spin_unlock(&sched->ws_lock);
        return;
 }
 EXPORT_SYMBOL(cfs_wi_schedule);
 
 static int
-cfs_wi_scheduler (void *arg)
+cfs_wi_scheduler(void *arg)
 {
-       struct cfs_wi_sched     *sched = (cfs_wi_sched_t *)arg;
+       struct cfs_wi_sched *sched = (struct cfs_wi_sched *)arg;
 
        cfs_block_allsigs();
 
@@ -239,17 +227,17 @@ cfs_wi_scheduler (void *arg)
 
        spin_unlock(&cfs_wi_data.wi_glock);
 
-       cfs_wi_sched_lock(sched);
+       spin_lock(&sched->ws_lock);
 
        while (!sched->ws_stopping) {
                int             nloops = 0;
                int             rc;
-               cfs_workitem_t *wi;
+               struct cfs_workitem *wi;
 
                while (!list_empty(&sched->ws_runq) &&
                       nloops < CFS_WI_RESCHED) {
                        wi = list_entry(sched->ws_runq.next,
-                                           cfs_workitem_t, wi_list);
+                                       struct cfs_workitem, wi_list);
                        LASSERT(wi->wi_scheduled && !wi->wi_running);
 
                        list_del_init(&wi->wi_list);
@@ -260,13 +248,12 @@ cfs_wi_scheduler (void *arg)
                         wi->wi_running   = 1;
                         wi->wi_scheduled = 0;
 
-
-                        cfs_wi_sched_unlock(sched);
+                       spin_unlock(&sched->ws_lock);
                         nloops++;
 
                         rc = (*wi->wi_action) (wi);
 
-                        cfs_wi_sched_lock(sched);
+                       spin_lock(&sched->ws_lock);
                         if (rc != 0) /* WI should be dead, even be freed! */
                                 continue;
 
@@ -281,21 +268,21 @@ cfs_wi_scheduler (void *arg)
                 }
 
                if (!list_empty(&sched->ws_runq)) {
-                       cfs_wi_sched_unlock(sched);
+                       spin_unlock(&sched->ws_lock);
                        /* don't sleep because some workitems still
                         * expect me to come back soon */
                        cond_resched();
-                       cfs_wi_sched_lock(sched);
+                       spin_lock(&sched->ws_lock);
                        continue;
                }
 
-               cfs_wi_sched_unlock(sched);
+               spin_unlock(&sched->ws_lock);
                rc = wait_event_interruptible_exclusive(sched->ws_waitq,
                                !cfs_wi_sched_cansleep(sched));
-               cfs_wi_sched_lock(sched);
+               spin_lock(&sched->ws_lock);
         }
 
-        cfs_wi_sched_unlock(sched);
+       spin_unlock(&sched->ws_lock);
 
        spin_lock(&cfs_wi_data.wi_glock);
        sched->ws_nthreads--;
@@ -438,7 +425,7 @@ EXPORT_SYMBOL(cfs_wi_sched_create);
 int
 cfs_wi_startup(void)
 {
-       memset(&cfs_wi_data, 0, sizeof(cfs_wi_data));
+       memset(&cfs_wi_data, 0, sizeof(struct cfs_workitem_data));
 
        spin_lock_init(&cfs_wi_data.wi_glock);
        INIT_LIST_HEAD(&cfs_wi_data.wi_scheds);