Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294/* SPDX-License-Identifier: GPL-2.0 */#ifndef _LINUX_KTHREAD_H#define _LINUX_KTHREAD_H/* Simple interface for creating and stopping kernel threads without mess. */#include <linux/err.h>#include <linux/sched.h>
struct mm_struct;
/* opaque kthread data */struct kthread;
/* * When "(p->flags & PF_KTHREAD)" is set the task is a kthread and will * always remain a kthread. For kthreads p->worker_private always * points to a struct kthread. For tasks that are not kthreads * p->worker_private is used to point to other things. * * Return NULL for any task that is not a kthread. */static inline struct kthread *tsk_is_kthread(struct task_struct *p){ if (p->flags & PF_KTHREAD) return p->worker_private; return NULL;}
__printf(4, 5)struct task_struct *kthread_create_on_node(int (*threadfn)(void *data), void *data, int node, const char namefmt[], ...);
/** * kthread_create - create a kthread on the current node * @threadfn: the function to run in the thread * @data: data pointer for @threadfn() * @namefmt: printf-style format string for the thread name * @arg: arguments for @namefmt. * * This macro will create a kthread on the current node, leaving it in * the stopped state. This is just a helper for kthread_create_on_node(); * see the documentation there for more details. */#define kthread_create(threadfn, data, namefmt, arg...) \ kthread_create_on_node(threadfn, data, NUMA_NO_NODE, namefmt, ##arg)
struct task_struct *kthread_create_on_cpu(int (*threadfn)(void *data), void *data, unsigned int cpu, const char *namefmt);
void get_kthread_comm(char *buf, size_t buf_size, struct task_struct *tsk);bool set_kthread_struct(struct task_struct *p);
void kthread_set_per_cpu(struct task_struct *k, int cpu);bool kthread_is_per_cpu(struct task_struct *k);
/** * kthread_run - create and wake a thread. * @threadfn: the function to run until signal_pending(current). * @data: data ptr for @threadfn. * @namefmt: printf-style name for the thread. * * Description: Convenient wrapper for kthread_create() followed by * wake_up_process(). Returns the kthread or ERR_PTR(-ENOMEM). */#define kthread_run(threadfn, data, namefmt, ...) \({ \ struct task_struct *__k \ = kthread_create(threadfn, data, namefmt, ## __VA_ARGS__); \ if (!IS_ERR(__k)) \ wake_up_process(__k); \ __k; \})
/** * kthread_run_on_cpu - create and wake a cpu bound thread. * @threadfn: the function to run until signal_pending(current). * @data: data ptr for @threadfn. * @cpu: The cpu on which the thread should be bound, * @namefmt: printf-style name for the thread. Format is restricted * to "name.*%u". Code fills in cpu number. * * Description: Convenient wrapper for kthread_create_on_cpu() * followed by wake_up_process(). Returns the kthread or * ERR_PTR(-ENOMEM). */static inline struct task_struct *kthread_run_on_cpu(int (*threadfn)(void *data), void *data, unsigned int cpu, const char *namefmt){ struct task_struct *p;
p = kthread_create_on_cpu(threadfn, data, cpu, namefmt); if (!IS_ERR(p)) wake_up_process(p);
return p;}
void free_kthread_struct(struct task_struct *k);void kthread_bind(struct task_struct *k, unsigned int cpu);void kthread_bind_mask(struct task_struct *k, const struct cpumask *mask);int kthread_affine_preferred(struct task_struct *p, const struct cpumask *mask);int kthread_stop(struct task_struct *k);int kthread_stop_put(struct task_struct *k);bool kthread_should_stop(void);bool kthread_should_park(void);bool kthread_should_stop_or_park(void);bool kthread_freezable_should_stop(bool *was_frozen);void *kthread_func(struct task_struct *k);void *kthread_data(struct task_struct *k);void *kthread_probe_data(struct task_struct *k);int kthread_park(struct task_struct *k);void kthread_unpark(struct task_struct *k);void kthread_parkme(void);#define kthread_exit(result) do_exit(result)void kthread_complete_and_exit(struct completion *, long) __noreturn;int kthreads_update_housekeeping(void);void kthread_do_exit(struct kthread *, long);
int kthreadd(void *unused);extern struct task_struct *kthreadd_task;extern int tsk_fork_get_node(struct task_struct *tsk);
/* * Simple work processor based on kthread. * * This provides easier way to make use of kthreads. A kthread_work * can be queued and flushed using queue/kthread_flush_work() * respectively. Queued kthread_works are processed by a kthread * running kthread_worker_fn(). */struct kthread_work;typedef void (*kthread_work_func_t)(struct kthread_work *work);void kthread_delayed_work_timer_fn(struct timer_list *t);
enum { KTW_FREEZABLE = 1 << 0, /* freeze during suspend */};
struct kthread_worker { unsigned int flags; raw_spinlock_t lock; struct list_head work_list; struct list_head delayed_work_list; struct task_struct *task; struct kthread_work *current_work;};
struct kthread_work { struct list_head node; kthread_work_func_t func; struct kthread_worker *worker; /* Number of canceling calls that are running at the moment. */ int canceling;};
struct kthread_delayed_work { struct kthread_work work; struct timer_list timer;};
#define KTHREAD_WORK_INIT(work, fn) { \ .node = LIST_HEAD_INIT((work).node), \ .func = (fn), \ }
#define KTHREAD_DELAYED_WORK_INIT(dwork, fn) { \ .work = KTHREAD_WORK_INIT((dwork).work, (fn)), \ .timer = __TIMER_INITIALIZER(kthread_delayed_work_timer_fn,\ TIMER_IRQSAFE), \ }
#define DEFINE_KTHREAD_WORK(work, fn) \ struct kthread_work work = KTHREAD_WORK_INIT(work, fn)
#define DEFINE_KTHREAD_DELAYED_WORK(dwork, fn) \ struct kthread_delayed_work dwork = \ KTHREAD_DELAYED_WORK_INIT(dwork, fn)
extern void __kthread_init_worker(struct kthread_worker *worker, const char *name, struct lock_class_key *key);
#define kthread_init_worker(worker) \ do { \ static struct lock_class_key __key; \ __kthread_init_worker((worker), "("#worker")->lock", &__key); \ } while (0)
#define kthread_init_work(work, fn) \ do { \ memset((work), 0, sizeof(struct kthread_work)); \ INIT_LIST_HEAD(&(work)->node); \ (work)->func = (fn); \ } while (0)
#define kthread_init_delayed_work(dwork, fn) \ do { \ kthread_init_work(&(dwork)->work, (fn)); \ timer_setup(&(dwork)->timer, \ kthread_delayed_work_timer_fn, \ TIMER_IRQSAFE); \ } while (0)
int kthread_worker_fn(void *worker_ptr);
__printf(3, 4)struct kthread_worker *kthread_create_worker_on_node(unsigned int flags, int node, const char namefmt[], ...);
#define kthread_create_worker(flags, namefmt, ...) \ kthread_create_worker_on_node(flags, NUMA_NO_NODE, namefmt, ## __VA_ARGS__);
/** * kthread_run_worker - create and wake a kthread worker. * @flags: flags modifying the default behavior of the worker * @namefmt: printf-style name for the thread. * * Description: Convenient wrapper for kthread_create_worker() followed by * wake_up_process(). Returns the kthread_worker or ERR_PTR(-ENOMEM). */#define kthread_run_worker(flags, namefmt, ...) \({ \ struct kthread_worker *__kw \ = kthread_create_worker(flags, namefmt, ## __VA_ARGS__); \ if (!IS_ERR(__kw)) \ wake_up_process(__kw->task); \ __kw; \})
struct kthread_worker *kthread_create_worker_on_cpu(int cpu, unsigned int flags, const char namefmt[]);
/** * kthread_run_worker_on_cpu - create and wake a cpu bound kthread worker. * @cpu: CPU number * @flags: flags modifying the default behavior of the worker * @namefmt: printf-style name for the thread. Format is restricted * to "name.*%u". Code fills in cpu number. * * Description: Convenient wrapper for kthread_create_worker_on_cpu() * followed by wake_up_process(). Returns the kthread_worker or * ERR_PTR(-ENOMEM). */static inline struct kthread_worker *kthread_run_worker_on_cpu(int cpu, unsigned int flags, const char namefmt[]){ struct kthread_worker *kw;
kw = kthread_create_worker_on_cpu(cpu, flags, namefmt); if (!IS_ERR(kw)) wake_up_process(kw->task);
return kw;}
bool kthread_queue_work(struct kthread_worker *worker, struct kthread_work *work);
bool kthread_queue_delayed_work(struct kthread_worker *worker, struct kthread_delayed_work *dwork, unsigned long delay);
bool kthread_mod_delayed_work(struct kthread_worker *worker, struct kthread_delayed_work *dwork, unsigned long delay);
void kthread_flush_work(struct kthread_work *work);void kthread_flush_worker(struct kthread_worker *worker);
bool kthread_cancel_work_sync(struct kthread_work *work);bool kthread_cancel_delayed_work_sync(struct kthread_delayed_work *work);
void kthread_destroy_worker(struct kthread_worker *worker);
void kthread_use_mm(struct mm_struct *mm);void kthread_unuse_mm(struct mm_struct *mm);
struct cgroup_subsys_state;
#ifdef CONFIG_BLK_CGROUPvoid kthread_associate_blkcg(struct cgroup_subsys_state *css);struct cgroup_subsys_state *kthread_blkcg(void);#elsestatic inline void kthread_associate_blkcg(struct cgroup_subsys_state *css) { }#endif#endif /* _LINUX_KTHREAD_H */