X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=libcfs%2Flibcfs%2Fworkitem.c;h=7768e5c9eb38a13dbf5652ee82c6d076a762eef7;hp=776a6563645a8c5f1a9b8c90bb1ac9434fe36a37;hb=037840fb6b86d6083d55f3da5ad70d19d34cc5a5;hpb=e089a515efae3391709b997be889ebe0f3306e9d diff --git a/libcfs/libcfs/workitem.c b/libcfs/libcfs/workitem.c index 776a656..7768e5c 100644 --- a/libcfs/libcfs/workitem.c +++ b/libcfs/libcfs/workitem.c @@ -15,11 +15,7 @@ * * You should have received a copy of the GNU General Public License * version 2 along with this program; If not, see - * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf - * - * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, - * CA 95054 USA or visit www.sun.com if you need additional information or - * have any questions. + * http://www.gnu.org/licenses/gpl-2.0.html * * GPL HEADER END */ @@ -27,7 +23,7 @@ * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2012, Intel Corporation. + * Copyright (c) 2011, 2013, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -41,26 +37,25 @@ #define DEBUG_SUBSYSTEM S_LNET +#include #include #define CFS_WS_NAME_LEN 16 -typedef struct cfs_wi_sched { - cfs_list_t ws_list; /* chain on global list */ -#ifdef __KERNEL__ +struct cfs_wi_sched { + struct list_head ws_list; /* chain on global list */ /** serialised workitems */ - spinlock_t ws_lock; + spinlock_t ws_lock; /** where schedulers sleep */ wait_queue_head_t ws_waitq; -#endif /** concurrent workitems */ - cfs_list_t ws_runq; + struct list_head ws_runq; /** rescheduled running-workitems, a workitem can be rescheduled * while running in wi_action(), but we don't to execute it again * unless it returns from wi_action(), so we put it on ws_rerunq * while rescheduling, and move it to runq after it returns * from wi_action() */ - cfs_list_t ws_rerunq; + struct list_head ws_rerunq; /** CPT-table for this scheduler */ struct cfs_cpt_table *ws_cptab; /** CPT id for affinity */ @@ -75,94 +70,62 @@ typedef struct cfs_wi_sched { unsigned int ws_starting:1; /** scheduler name */ char ws_name[CFS_WS_NAME_LEN]; -} cfs_wi_sched_t; +}; -struct cfs_workitem_data { +static struct cfs_workitem_data { /** serialize */ spinlock_t wi_glock; /** list of all schedulers */ - cfs_list_t 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; -#ifdef __KERNEL__ -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); - return 0; - } - - if (!cfs_list_empty(&sched->ws_runq)) { - cfs_wi_sched_unlock(sched); - return 0; - } - cfs_wi_sched_unlock(sched); - return 1; -} - -#else /* !__KERNEL__ */ - -static inline void -cfs_wi_sched_lock(cfs_wi_sched_t *sched) -{ - spin_lock(&cfs_wi_data.wi_glock); -} + spin_unlock(&sched->ws_lock); + return 0; + } -static inline void -cfs_wi_sched_unlock(cfs_wi_sched_t *sched) -{ - spin_unlock(&cfs_wi_data.wi_glock); + if (!list_empty(&sched->ws_runq)) { + spin_unlock(&sched->ws_lock); + return 0; + } + spin_unlock(&sched->ws_lock); + return 1; } -#endif /* __KERNEL__ */ - /* XXX: * 0. it only works when called from wi->wi_action. * 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(!cfs_in_interrupt()); /* because we use plain spinlock */ + LASSERT(!in_interrupt()); /* because we use plain spinlock */ LASSERT(!sched->ws_stopping); - cfs_wi_sched_lock(sched); + spin_lock(&sched->ws_lock); -#ifdef __KERNEL__ LASSERT(wi->wi_running); -#endif + if (wi->wi_scheduled) { /* cancel pending schedules */ - LASSERT(!cfs_list_empty(&wi->wi_list)); - cfs_list_del_init(&wi->wi_list); + LASSERT(!list_empty(&wi->wi_list)); + list_del_init(&wi->wi_list); LASSERT(sched->ws_nscheduled > 0); sched->ws_nscheduled--; } - LASSERT(cfs_list_empty(&wi->wi_list)); + LASSERT(list_empty(&wi->wi_list)); wi->wi_scheduled = 1; /* LBUG future schedule attempts */ - cfs_wi_sched_unlock(sched); - - return; + spin_unlock(&sched->ws_lock); } EXPORT_SYMBOL(cfs_wi_exit); @@ -170,11 +133,11 @@ 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; - LASSERT(!cfs_in_interrupt()); /* because we use plain spinlock */ + LASSERT(!in_interrupt()); /* because we use plain spinlock */ LASSERT(!sched->ws_stopping); /* @@ -182,24 +145,24 @@ 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); if (wi->wi_scheduled) { /* cancel pending schedules */ - LASSERT(!cfs_list_empty(&wi->wi_list)); - cfs_list_del_init(&wi->wi_list); + LASSERT(!list_empty(&wi->wi_list)); + list_del_init(&wi->wi_list); LASSERT(sched->ws_nscheduled > 0); sched->ws_nscheduled--; - wi->wi_scheduled = 0; - } + wi->wi_scheduled = 0; + } - LASSERT (cfs_list_empty(&wi->wi_list)); + LASSERT (list_empty(&wi->wi_list)); - cfs_wi_sched_unlock(sched); - return rc; + spin_unlock(&sched->ws_lock); + return rc; } EXPORT_SYMBOL(cfs_wi_deschedule); @@ -211,47 +174,42 @@ 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(!cfs_in_interrupt()); /* because we use plain spinlock */ + 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 (cfs_list_empty(&wi->wi_list)); + LASSERT (list_empty(&wi->wi_list)); wi->wi_scheduled = 1; sched->ws_nscheduled++; if (!wi->wi_running) { - cfs_list_add_tail(&wi->wi_list, &sched->ws_runq); -#ifdef __KERNEL__ + list_add_tail(&wi->wi_list, &sched->ws_runq); wake_up(&sched->ws_waitq); -#endif } else { - cfs_list_add(&wi->wi_list, &sched->ws_rerunq); + list_add(&wi->wi_list, &sched->ws_rerunq); } } - LASSERT (!cfs_list_empty(&wi->wi_list)); - cfs_wi_sched_unlock(sched); - return; + LASSERT (!list_empty(&wi->wi_list)); + spin_unlock(&sched->ws_lock); } EXPORT_SYMBOL(cfs_wi_schedule); -#ifdef __KERNEL__ - 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(); /* CPT affinity scheduler? */ if (sched->ws_cptab != NULL) if (cfs_cpt_bind(sched->ws_cptab, sched->ws_cpt) != 0) - CWARN("Failed to bind %s on CPT %d\n", + CWARN("Unable to bind %s on CPU partition %d\n", sched->ws_name, sched->ws_cpt); spin_lock(&cfs_wi_data.wi_glock); @@ -262,20 +220,20 @@ 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; - - while (!cfs_list_empty(&sched->ws_runq) && - nloops < CFS_WI_RESCHED) { - wi = cfs_list_entry(sched->ws_runq.next, - cfs_workitem_t, wi_list); + int nloops = 0; + int rc; + struct cfs_workitem *wi; + + while (!list_empty(&sched->ws_runq) && + nloops < CFS_WI_RESCHED) { + wi = list_entry(sched->ws_runq.next, + struct cfs_workitem, wi_list); LASSERT(wi->wi_scheduled && !wi->wi_running); - cfs_list_del_init(&wi->wi_list); + list_del_init(&wi->wi_list); LASSERT(sched->ws_nscheduled > 0); sched->ws_nscheduled--; @@ -283,42 +241,41 @@ 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; - wi->wi_running = 0; - if (cfs_list_empty(&wi->wi_list)) + wi->wi_running = 0; + if (list_empty(&wi->wi_list)) continue; LASSERT(wi->wi_scheduled); - /* wi is rescheduled, should be on rerunq now, we - * move it to runq so it can run action now */ - cfs_list_move_tail(&wi->wi_list, &sched->ws_runq); + /* wi is rescheduled, should be on rerunq now, we + * move it to runq so it can run action now */ + list_move_tail(&wi->wi_list, &sched->ws_runq); } - if (!cfs_list_empty(&sched->ws_runq)) { - cfs_wi_sched_unlock(sched); + if (!list_empty(&sched->ws_runq)) { + 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--; @@ -327,55 +284,6 @@ cfs_wi_scheduler (void *arg) return 0; } -#else /* __KERNEL__ */ - -int -cfs_wi_check_events (void) -{ - int n = 0; - cfs_workitem_t *wi; - - spin_lock(&cfs_wi_data.wi_glock); - - for (;;) { - struct cfs_wi_sched *sched = NULL; - struct cfs_wi_sched *tmp; - - /** rerunq is always empty for userspace */ - cfs_list_for_each_entry(tmp, - &cfs_wi_data.wi_scheds, ws_list) { - if (!cfs_list_empty(&tmp->ws_runq)) { - sched = tmp; - break; - } - } - - if (sched == NULL) - break; - - wi = cfs_list_entry(sched->ws_runq.next, - cfs_workitem_t, wi_list); - cfs_list_del_init(&wi->wi_list); - - LASSERT(sched->ws_nscheduled > 0); - sched->ws_nscheduled--; - - LASSERT(wi->wi_scheduled); - wi->wi_scheduled = 0; - spin_unlock(&cfs_wi_data.wi_glock); - - n++; - (*wi->wi_action) (wi); - - spin_lock(&cfs_wi_data.wi_glock); - } - - spin_unlock(&cfs_wi_data.wi_glock); - return n; -} - -#endif - void cfs_wi_sched_destroy(struct cfs_wi_sched *sched) { @@ -390,12 +298,11 @@ cfs_wi_sched_destroy(struct cfs_wi_sched *sched) return; } - LASSERT(!cfs_list_empty(&sched->ws_list)); + LASSERT(!list_empty(&sched->ws_list)); sched->ws_stopping = 1; spin_unlock(&cfs_wi_data.wi_glock); -#ifdef __KERNEL__ wake_up_all(&sched->ws_waitq); spin_lock(&cfs_wi_data.wi_glock); @@ -403,21 +310,21 @@ cfs_wi_sched_destroy(struct cfs_wi_sched *sched) int i = 2; while (sched->ws_nthreads > 0) { - CDEBUG(IS_PO2(++i) ? D_WARNING : D_NET, - "waiting for %d threads of WI sched[%s] to " - "terminate\n", sched->ws_nthreads, - sched->ws_name); + CDEBUG(is_power_of_2(++i / 20) ? D_WARNING : D_NET, + "waiting %us for %d %s worker threads to exit\n", + i / 20, sched->ws_nthreads, sched->ws_name); spin_unlock(&cfs_wi_data.wi_glock); - cfs_pause(cfs_time_seconds(1) / 20); + set_current_state(TASK_UNINTERRUPTIBLE); + schedule_timeout(cfs_time_seconds(1) / 20); spin_lock(&cfs_wi_data.wi_glock); } } - cfs_list_del(&sched->ws_list); + list_del(&sched->ws_list); spin_unlock(&cfs_wi_data.wi_glock); -#endif + LASSERT(sched->ws_nscheduled == 0); LIBCFS_FREE(sched, sizeof(*sched)); @@ -439,22 +346,25 @@ cfs_wi_sched_create(char *name, struct cfs_cpt_table *cptab, if (sched == NULL) return -ENOMEM; - strncpy(sched->ws_name, name, CFS_WS_NAME_LEN); + if (strlen(name) > sizeof(sched->ws_name)-1) { + LIBCFS_FREE(sched, sizeof(*sched)); + return -E2BIG; + } + strlcpy(sched->ws_name, name, sizeof(sched->ws_name)); + sched->ws_cptab = cptab; sched->ws_cpt = cpt; -#ifdef __KERNEL__ spin_lock_init(&sched->ws_lock); init_waitqueue_head(&sched->ws_waitq); -#endif - CFS_INIT_LIST_HEAD(&sched->ws_runq); - CFS_INIT_LIST_HEAD(&sched->ws_rerunq); - CFS_INIT_LIST_HEAD(&sched->ws_list); -#ifdef __KERNEL__ + INIT_LIST_HEAD(&sched->ws_runq); + INIT_LIST_HEAD(&sched->ws_rerunq); + INIT_LIST_HEAD(&sched->ws_list); + for (; nthrs > 0; nthrs--) { - char name[16]; - cfs_task_t *task; + char name[16]; + struct task_struct *task; spin_lock(&cfs_wi_data.wi_glock); while (sched->ws_starting > 0) { @@ -485,7 +395,7 @@ cfs_wi_sched_create(char *name, struct cfs_cpt_table *cptab, spin_lock(&cfs_wi_data.wi_glock); /* make up for cfs_wi_sched_destroy */ - cfs_list_add(&sched->ws_list, &cfs_wi_data.wi_scheds); + list_add(&sched->ws_list, &cfs_wi_data.wi_scheds); sched->ws_starting--; spin_unlock(&cfs_wi_data.wi_glock); @@ -494,9 +404,9 @@ cfs_wi_sched_create(char *name, struct cfs_cpt_table *cptab, return rc; } } -#endif + spin_lock(&cfs_wi_data.wi_glock); - cfs_list_add(&sched->ws_list, &cfs_wi_data.wi_scheds); + list_add(&sched->ws_list, &cfs_wi_data.wi_scheds); spin_unlock(&cfs_wi_data.wi_glock); *sched_pp = sched; @@ -507,10 +417,10 @@ 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); - CFS_INIT_LIST_HEAD(&cfs_wi_data.wi_scheds); + INIT_LIST_HEAD(&cfs_wi_data.wi_scheds); cfs_wi_data.wi_init = 1; return 0; @@ -525,28 +435,28 @@ cfs_wi_shutdown (void) cfs_wi_data.wi_stopping = 1; spin_unlock(&cfs_wi_data.wi_glock); -#ifdef __KERNEL__ /* nobody should contend on this list */ - cfs_list_for_each_entry(sched, &cfs_wi_data.wi_scheds, ws_list) { + list_for_each_entry(sched, &cfs_wi_data.wi_scheds, ws_list) { sched->ws_stopping = 1; wake_up_all(&sched->ws_waitq); } - cfs_list_for_each_entry(sched, &cfs_wi_data.wi_scheds, ws_list) { + list_for_each_entry(sched, &cfs_wi_data.wi_scheds, ws_list) { spin_lock(&cfs_wi_data.wi_glock); while (sched->ws_nthreads != 0) { spin_unlock(&cfs_wi_data.wi_glock); - cfs_pause(cfs_time_seconds(1) / 20); + set_current_state(TASK_UNINTERRUPTIBLE); + schedule_timeout(cfs_time_seconds(1) / 20); spin_lock(&cfs_wi_data.wi_glock); } spin_unlock(&cfs_wi_data.wi_glock); } -#endif - while (!cfs_list_empty(&cfs_wi_data.wi_scheds)) { - sched = cfs_list_entry(cfs_wi_data.wi_scheds.next, + + while (!list_empty(&cfs_wi_data.wi_scheds)) { + sched = list_entry(cfs_wi_data.wi_scheds.next, struct cfs_wi_sched, ws_list); - cfs_list_del(&sched->ws_list); + list_del(&sched->ws_list); LIBCFS_FREE(sched, sizeof(*sched)); }