History

kthread: add kthread_create_worker*()

Kthread workers are currently created using the classic kthread API, namely kthread_run(). kthread_worker_fn() is passed as the @threadfn parameter. This patch defines kthread_create_worker() and kthread_create_worker_on_cpu() functions that hide implementation details. They enforce using kthread_worker_fn() for the main thread. But I doubt that there are any plans to create any alternative. In fact, I think that we do not want any alternative main thread because it would be hard to support consistency with the rest of the kthread worker API. The naming and function of kthread_create_worker() is inspired by the workqueues API like the rest of the kthread worker API. The kthread_create_worker_on_cpu() variant is motivated by the original kthread_create_on_cpu(). Note that we need to bind per-CPU kthread workers already when they are created. It makes the life easier. kthread_bind() could not be used later for an already running worker. This patch does _not_ convert existing kthread workers. The kthread worker API need more improvements first, e.g. a function to destroy the worker. IMPORTANT: kthread_create_worker_on_cpu() allows to use any format of the worker name, in compare with kthread_create_on_cpu(). The good thing is that it is more generic. The bad thing is that most users will need to pass the cpu number in two parameters, e.g. kthread_create_worker_on_cpu(cpu, "helper/%d", cpu). To be honest, the main motivation was to avoid the need for an empty va_list. The only legal way was to create a helper function that would be called with an empty list. Other attempts caused compilation warnings or even errors on different architectures. There were also other alternatives, for example, using #define or splitting __kthread_create_worker(). The used solution looked like the least ugly.

Petr Mladek committed 10 years ago

Commit fbae2d41 parent 255451e2 files · +110 −10Browse files

Showing the changes to kernel (1 of 2 files). Show all

Unified · Split

kernel/kthread.c+103−10
@@ -571,23 +571,24 @@ EXPORT_SYMBOL_GPL(__kthread_init_worker); · 570 unmodified lines
571 * kthread_worker_fn - kthread function to process kthread_worker571 * kthread_worker_fn - kthread function to process kthread_worker
572 * @worker_ptr: pointer to initialized kthread_worker572 * @worker_ptr: pointer to initialized kthread_worker
573 *573 *
574 * This function can be used as @threadfn to kthread_create() or574 * This function implements the main cycle of kthread worker. It processes
575 * kthread_run() with @worker_ptr argument pointing to an initialized575 * work_list until it is stopped with kthread_stop(). It sleeps when the queue
576 * kthread_worker. The started kthread will process work_list until576 * is empty.
577 * the it is stopped with kthread_stop(). A kthread can also call
578 * this function directly after extra initialization.
579 *577 *
580 * Different kthreads can be used for the same kthread_worker as long578 * The works are not allowed to keep any locks, disable preemption or interrupts
581 * as there's only one kthread attached to it at any given time. A579 * when they finish. There is defined a safe point for freezing when one work
582 * kthread_worker without an attached kthread simply collects queued580 * finishes and before a new one is started.
583 * kthread_works.
584 */581 */
585int kthread_worker_fn(void *worker_ptr)582int kthread_worker_fn(void *worker_ptr)
586{583{
587 struct kthread_worker *worker = worker_ptr;584 struct kthread_worker *worker = worker_ptr;
588 struct kthread_work *work;585 struct kthread_work *work;
589 586
590 WARN_ON(worker->task);587 /*
588 * FIXME: Update the check and remove the assignment when all kthread
589 * worker users are created using kthread_create_worker*() functions.
590 */
591 WARN_ON(worker->task && worker->task != current);
591 worker->task = current;592 worker->task = current;
592repeat:593repeat:
593 set_current_state(TASK_INTERRUPTIBLE); /* mb paired w/ kthread_stop */594 set_current_state(TASK_INTERRUPTIBLE); /* mb paired w/ kthread_stop */
@@ -621,6 +622,98 @@ repeat: · 27 unmodified lines
621}622}
622EXPORT_SYMBOL_GPL(kthread_worker_fn);623EXPORT_SYMBOL_GPL(kthread_worker_fn);
623 624
625static struct kthread_worker *
626__kthread_create_worker(int cpu, const char namefmt[], va_list args)
627{
628 struct kthread_worker *worker;
629 struct task_struct *task;
630
631 worker = kzalloc(sizeof(*worker), GFP_KERNEL);
632 if (!worker)
633 return ERR_PTR(-ENOMEM);
634
635 kthread_init_worker(worker);
636
637 if (cpu >= 0) {
638 char name[TASK_COMM_LEN];
639
640 /*
641 * kthread_create_worker_on_cpu() allows to pass a generic
642 * namefmt in compare with kthread_create_on_cpu. We need
643 * to format it here.
644 */
645 vsnprintf(name, sizeof(name), namefmt, args);
646 task = kthread_create_on_cpu(kthread_worker_fn, worker,
647 cpu, name);
648 } else {
649 task = __kthread_create_on_node(kthread_worker_fn, worker,
650 -1, namefmt, args);
651 }
652
653 if (IS_ERR(task))
654 goto fail_task;
655
656 worker->task = task;
657 wake_up_process(task);
658 return worker;
659
660fail_task:
661 kfree(worker);
662 return ERR_CAST(task);
663}
664
665/**
666 * kthread_create_worker - create a kthread worker
667 * @namefmt: printf-style name for the kthread worker (task).
668 *
669 * Returns a pointer to the allocated worker on success, ERR_PTR(-ENOMEM)
670 * when the needed structures could not get allocated, and ERR_PTR(-EINTR)
671 * when the worker was SIGKILLed.
672 */
673struct kthread_worker *
674kthread_create_worker(const char namefmt[], ...)
675{
676 struct kthread_worker *worker;
677 va_list args;
678
679 va_start(args, namefmt);
680 worker = __kthread_create_worker(-1, namefmt, args);
681 va_end(args);
682
683 return worker;
684}
685EXPORT_SYMBOL(kthread_create_worker);
686
687/**
688 * kthread_create_worker_on_cpu - create a kthread worker and bind it
689 * it to a given CPU and the associated NUMA node.
690 * @cpu: CPU number
691 * @namefmt: printf-style name for the kthread worker (task).
692 *
693 * Use a valid CPU number if you want to bind the kthread worker
694 * to the given CPU and the associated NUMA node.
695 *
696 * A good practice is to add the cpu number also into the worker name.
697 * For example, use kthread_create_worker_on_cpu(cpu, "helper/%d", cpu).
698 *
699 * Returns a pointer to the allocated worker on success, ERR_PTR(-ENOMEM)
700 * when the needed structures could not get allocated, and ERR_PTR(-EINTR)
701 * when the worker was SIGKILLed.
702 */
703struct kthread_worker *
704kthread_create_worker_on_cpu(int cpu, const char namefmt[], ...)
705{
706 struct kthread_worker *worker;
707 va_list args;
708
709 va_start(args, namefmt);
710 worker = __kthread_create_worker(cpu, namefmt, args);
711 va_end(args);
712
713 return worker;
714}
715EXPORT_SYMBOL(kthread_create_worker_on_cpu);
716
624/* insert @work before @pos in @worker */717/* insert @work before @pos in @worker */
625static void kthread_insert_work(struct kthread_worker *worker,718static void kthread_insert_work(struct kthread_worker *worker,
626 struct kthread_work *work,719 struct kthread_work *work,