diff --git a/sched/wqueue/Make.defs b/sched/wqueue/Make.defs index 5e8bd86cb3..bc31d536fd 100644 --- a/sched/wqueue/Make.defs +++ b/sched/wqueue/Make.defs @@ -23,21 +23,11 @@ ifeq ($(CONFIG_SCHED_WORKQUEUE),y) CSRCS += kwork_queue.c kwork_process.c kwork_cancel.c kwork_signal.c +CSRCS += kwork_thread.c -# Add high priority work queue files - -ifeq ($(CONFIG_SCHED_HPWORK),y) -CSRCS += kwork_hpthread.c -endif - -# Add low priority work queue files - -ifeq ($(CONFIG_SCHED_LPWORK),y) -CSRCS += kwork_lpthread.c ifeq ($(CONFIG_PRIORITY_INHERITANCE),y) CSRCS += kwork_inherit.c endif # CONFIG_PRIORITY_INHERITANCE -endif # CONFIG_SCHED_LPWORK # Add work queue notifier support diff --git a/sched/wqueue/kwork_lpthread.c b/sched/wqueue/kwork_lpthread.c deleted file mode 100644 index 0cea4a3079..0000000000 --- a/sched/wqueue/kwork_lpthread.c +++ /dev/null @@ -1,171 +0,0 @@ -/**************************************************************************** - * sched/wqueue/kwork_lpthread.c - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. The - * ASF licenses this file to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance with the - * License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations - * under the License. - * - ****************************************************************************/ - -/**************************************************************************** - * Included Files - ****************************************************************************/ - -#include - -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include - -#include "wqueue/wqueue.h" - -#ifdef CONFIG_SCHED_LPWORK - -/**************************************************************************** - * Public Data - ****************************************************************************/ - -/* The state of the kernel mode, low priority work queue(s). */ - -struct lp_wqueue_s g_lpwork; - -/**************************************************************************** - * Private Functions - ****************************************************************************/ - -/**************************************************************************** - * Name: work_lpthread - * - * Description: - * These are the worker thread(s) that performs the actions placed on the - * low priority work queue. - * - * These, along with the higher priority worker thread are the kernel mode - * work queues (also build in the flat build). - * - * All kernel mode worker threads are started by the OS during normal - * bring up. This entry point is referenced by OS internally and should - * not be accessed by application logic. - * - * Input Parameters: - * argc, argv (not used) - * - * Returned Value: - * Does not return - * - ****************************************************************************/ - -static int work_lpthread(int argc, char *argv[]) -{ - int wndx = 0; -#if CONFIG_SCHED_LPNTHREADS > 1 - pid_t me = getpid(); - int i; - - /* Find out thread index by search the workers in g_lpwork */ - - for (wndx = 0, i = 0; i < CONFIG_SCHED_LPNTHREADS; i++) - { - if (g_lpwork.worker[i].pid == me) - { - wndx = i; - break; - } - } - - DEBUGASSERT(i < CONFIG_SCHED_LPNTHREADS); -#endif - - /* Loop forever */ - - for (; ; ) - { - /* Then process queued work. work_process will not return until: - * (1) there is no further work in the work queue, and (2) signal is - * triggered, or delayed work expires. - */ - - work_process((FAR struct kwork_wqueue_s *)&g_lpwork, wndx); - } - - return OK; /* To keep some compilers happy */ -} - -/**************************************************************************** - * Public Functions - ****************************************************************************/ - -/**************************************************************************** - * Name: work_start_lowpri - * - * Description: - * Start the low-priority, kernel-mode worker thread(s) - * - * Input Parameters: - * None - * - * Returned Value: - * The task ID of the worker thread is returned on success. A negated - * errno value is returned on failure. - * - ****************************************************************************/ - -int work_start_lowpri(void) -{ - pid_t pid; - int wndx; - - /* Don't permit any of the threads to run until we have fully initialized - * g_lpwork. - */ - - sched_lock(); - - /* Start the low-priority, kernel mode worker thread(s) */ - - sinfo("Starting low-priority kernel worker thread(s)\n"); - - for (wndx = 0; wndx < CONFIG_SCHED_LPNTHREADS; wndx++) - { - pid = kthread_create(LPWORKNAME, CONFIG_SCHED_LPWORKPRIORITY, - CONFIG_SCHED_LPWORKSTACKSIZE, - (main_t)work_lpthread, - (FAR char * const *)NULL); - - DEBUGASSERT(pid > 0); - if (pid < 0) - { - serr("ERROR: kthread_create %d failed: %d\n", wndx, (int)pid); - sched_unlock(); - return (int)pid; - } - - g_lpwork.worker[wndx].pid = pid; - g_lpwork.worker[wndx].busy = true; - } - - sched_unlock(); - return g_lpwork.worker[0].pid; -} - -#endif /* CONFIG_SCHED_LPWORK */ diff --git a/sched/wqueue/kwork_notifier.c b/sched/wqueue/kwork_notifier.c index 012e3bbe0f..09cb1a683b 100644 --- a/sched/wqueue/kwork_notifier.c +++ b/sched/wqueue/kwork_notifier.c @@ -33,7 +33,6 @@ #include #include -#include #include #include "wqueue/wqueue.h" diff --git a/sched/wqueue/kwork_hpthread.c b/sched/wqueue/kwork_thread.c similarity index 53% rename from sched/wqueue/kwork_hpthread.c rename to sched/wqueue/kwork_thread.c index e44efe8758..3c3b7eb21d 100644 --- a/sched/wqueue/kwork_hpthread.c +++ b/sched/wqueue/kwork_thread.c @@ -1,5 +1,5 @@ /**************************************************************************** - * sched/wqueue/kwork_hpthread.c + * sched/wqueue/kwork_thread.c * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with @@ -26,7 +26,9 @@ #include #include +#include #include +#include #include #include #include @@ -34,27 +36,33 @@ #include #include -#include -#include #include "wqueue/wqueue.h" -#ifdef CONFIG_SCHED_HPWORK +#if defined(CONFIG_SCHED_WORKQUEUE) /**************************************************************************** * Public Data ****************************************************************************/ +#if defined(CONFIG_SCHED_HPWORK) /* The state of the kernel mode, high priority work queue(s). */ struct hp_wqueue_s g_hpwork; +#endif /* CONFIG_SCHED_HPWORK */ + +#if defined(CONFIG_SCHED_LPWORK) +/* The state of the kernel mode, low priority work queue(s). */ + +struct lp_wqueue_s g_lpwork; +#endif /* CONFIG_SCHED_LPWORK */ /**************************************************************************** * Private Functions ****************************************************************************/ /**************************************************************************** - * Name: work_hpthread + * Name: work_thread * * Description: * These are the worker threads that performs the actions placed on the @@ -75,26 +83,14 @@ struct hp_wqueue_s g_hpwork; * ****************************************************************************/ -static int work_hpthread(int argc, char *argv[]) +static int work_thread(int argc, char *argv[]) { - int wndx = 0; -#if CONFIG_SCHED_HPNTHREADS > 1 - pid_t me = getpid(); - int i; + FAR struct kwork_wqueue_s *queue; + int wndx; - /* Find out thread index by search the workers in g_hpwork */ - - for (wndx = 0, i = 0; i < CONFIG_SCHED_HPNTHREADS; i++) - { - if (g_hpwork.worker[i].pid == me) - { - wndx = i; - break; - } - } - - DEBUGASSERT(i < CONFIG_SCHED_HPNTHREADS); -#endif + queue = (FAR struct kwork_wqueue_s *) + ((uintptr_t)strtoul(argv[1], NULL, 0)); + wndx = atoi(argv[2]); /* Loop forever */ @@ -105,12 +101,76 @@ static int work_hpthread(int argc, char *argv[]) * triggered, or delayed work expires. */ - work_process((FAR struct kwork_wqueue_s *)&g_hpwork, wndx); + work_process(queue, wndx); } return OK; /* To keep some compilers happy */ } +/**************************************************************************** + * Name: work_thread_create + * + * Description: + * This function creates and activates a work thread task with kernel- + * mode privileges. + * + * Input Parameters: + * name - Name of the new task + * priority - Priority of the new task + * stack_size - size (in bytes) of the stack needed + * nthread - Number of work thread should be created + * wqueue - Work queue instance + * + * Returned Value: + * A negated errno value is returned on failure. + * + ****************************************************************************/ + +static int work_thread_create(FAR const char *name, int priority, + int stack_size, int nthread, + FAR struct kwork_wqueue_s *wqueue) +{ + FAR char *argv[3]; + char args[2][16]; + int wndx; + int pid; + + snprintf(args[0], 16, "0x%" PRIxPTR, (uintptr_t)wqueue); + argv[0] = args[0]; + argv[2] = NULL; + + /* Don't permit any of the threads to run until we have fully initialized + * g_hpwork and g_lpwork. + */ + + sched_lock(); + + for (wndx = 0; wndx < nthread; wndx++) + { + snprintf(args[1], 16, "%d", wndx); + argv[1] = args[1]; + + pid = kthread_create(name, priority, stack_size, + (main_t)work_thread, argv); + + DEBUGASSERT(pid > 0); + if (pid < 0) + { + serr("ERROR: work_thread_create %d failed: %d\n", wndx, pid); + sched_unlock(); + return pid; + } + +#ifdef CONFIG_PRIORITY_INHERITANCE + wqueue->worker[wndx].pid = pid; +#endif + wqueue->worker[wndx].busy = true; + } + + sched_unlock(); + return OK; +} + /**************************************************************************** * Public Functions ****************************************************************************/ @@ -125,47 +185,50 @@ static int work_hpthread(int argc, char *argv[]) * None * * Returned Value: - * The task ID of the worker thread is returned on success. A negated - * errno value is returned on failure. + * A negated errno value is returned on failure. * ****************************************************************************/ +#if defined(CONFIG_SCHED_HPWORK) int work_start_highpri(void) { - pid_t pid; - int wndx; - - /* Don't permit any of the threads to run until we have fully initialized - * g_hpwork. - */ - - sched_lock(); - /* Start the high-priority, kernel mode worker thread(s) */ sinfo("Starting high-priority kernel worker thread(s)\n"); - for (wndx = 0; wndx < CONFIG_SCHED_HPNTHREADS; wndx++) - { - pid = kthread_create(HPWORKNAME, CONFIG_SCHED_HPWORKPRIORITY, - CONFIG_SCHED_HPWORKSTACKSIZE, - (main_t)work_hpthread, - (FAR char * const *)NULL); - - DEBUGASSERT(pid > 0); - if (pid < 0) - { - serr("ERROR: kthread_create %d failed: %d\n", wndx, (int)pid); - sched_unlock(); - return (int)pid; - } - - g_hpwork.worker[wndx].pid = pid; - g_hpwork.worker[wndx].busy = true; - } - - sched_unlock(); - return g_hpwork.worker[0].pid; + return work_thread_create(HPWORKNAME, CONFIG_SCHED_HPWORKPRIORITY, + CONFIG_SCHED_HPWORKSTACKSIZE, + CONFIG_SCHED_HPNTHREADS, + (FAR struct kwork_wqueue_s *)&g_hpwork); } - #endif /* CONFIG_SCHED_HPWORK */ + +/**************************************************************************** + * Name: work_start_lowpri + * + * Description: + * Start the low-priority, kernel-mode worker thread(s) + * + * Input Parameters: + * None + * + * Returned Value: + * A negated errno value is returned on failure. + * + ****************************************************************************/ + +#if defined(CONFIG_SCHED_LPWORK) +int work_start_lowpri(void) +{ + /* Start the low-priority, kernel mode worker thread(s) */ + + sinfo("Starting low-priority kernel worker thread(s)\n"); + + return work_thread_create(LPWORKNAME, CONFIG_SCHED_LPWORKPRIORITY, + CONFIG_SCHED_LPWORKSTACKSIZE, + CONFIG_SCHED_LPNTHREADS, + (FAR struct kwork_wqueue_s *)&g_lpwork); +} +#endif /* CONFIG_SCHED_LPWORK */ + +#endif /* CONFIG_SCHED_WORKQUEUE */