LCOV - code coverage report
Current view: top level - include/linux - kthread.h (source / functions) Hit Total Coverage
Test: landlock.info Lines: 0 1 0.0 %
Date: 2021-04-22 12:43:58 Functions: 0 0 -

          Line data    Source code
       1             : /* SPDX-License-Identifier: GPL-2.0 */
       2             : #ifndef _LINUX_KTHREAD_H
       3             : #define _LINUX_KTHREAD_H
       4             : /* Simple interface for creating and stopping kernel threads without mess. */
       5             : #include <linux/err.h>
       6             : #include <linux/sched.h>
       7             : 
       8             : struct mm_struct;
       9             : 
      10             : __printf(4, 5)
      11             : struct task_struct *kthread_create_on_node(int (*threadfn)(void *data),
      12             :                                            void *data,
      13             :                                            int node,
      14             :                                            const char namefmt[], ...);
      15             : 
      16             : /**
      17             :  * kthread_create - create a kthread on the current node
      18             :  * @threadfn: the function to run in the thread
      19             :  * @data: data pointer for @threadfn()
      20             :  * @namefmt: printf-style format string for the thread name
      21             :  * @arg...: arguments for @namefmt.
      22             :  *
      23             :  * This macro will create a kthread on the current node, leaving it in
      24             :  * the stopped state.  This is just a helper for kthread_create_on_node();
      25             :  * see the documentation there for more details.
      26             :  */
      27             : #define kthread_create(threadfn, data, namefmt, arg...) \
      28             :         kthread_create_on_node(threadfn, data, NUMA_NO_NODE, namefmt, ##arg)
      29             : 
      30             : 
      31             : struct task_struct *kthread_create_on_cpu(int (*threadfn)(void *data),
      32             :                                           void *data,
      33             :                                           unsigned int cpu,
      34             :                                           const char *namefmt);
      35             : 
      36             : void kthread_set_per_cpu(struct task_struct *k, int cpu);
      37             : bool kthread_is_per_cpu(struct task_struct *k);
      38             : 
      39             : /**
      40             :  * kthread_run - create and wake a thread.
      41             :  * @threadfn: the function to run until signal_pending(current).
      42             :  * @data: data ptr for @threadfn.
      43             :  * @namefmt: printf-style name for the thread.
      44             :  *
      45             :  * Description: Convenient wrapper for kthread_create() followed by
      46             :  * wake_up_process().  Returns the kthread or ERR_PTR(-ENOMEM).
      47             :  */
      48             : #define kthread_run(threadfn, data, namefmt, ...)                          \
      49             : ({                                                                         \
      50             :         struct task_struct *__k                                            \
      51             :                 = kthread_create(threadfn, data, namefmt, ## __VA_ARGS__); \
      52             :         if (!IS_ERR(__k))                                                  \
      53             :                 wake_up_process(__k);                                      \
      54             :         __k;                                                               \
      55             : })
      56             : 
      57             : void free_kthread_struct(struct task_struct *k);
      58             : void kthread_bind(struct task_struct *k, unsigned int cpu);
      59             : void kthread_bind_mask(struct task_struct *k, const struct cpumask *mask);
      60             : int kthread_stop(struct task_struct *k);
      61             : bool kthread_should_stop(void);
      62             : bool kthread_should_park(void);
      63             : bool __kthread_should_park(struct task_struct *k);
      64             : bool kthread_freezable_should_stop(bool *was_frozen);
      65             : void *kthread_func(struct task_struct *k);
      66             : void *kthread_data(struct task_struct *k);
      67             : void *kthread_probe_data(struct task_struct *k);
      68             : int kthread_park(struct task_struct *k);
      69             : void kthread_unpark(struct task_struct *k);
      70             : void kthread_parkme(void);
      71             : 
      72             : int kthreadd(void *unused);
      73             : extern struct task_struct *kthreadd_task;
      74             : extern int tsk_fork_get_node(struct task_struct *tsk);
      75             : 
      76             : /*
      77             :  * Simple work processor based on kthread.
      78             :  *
      79             :  * This provides easier way to make use of kthreads.  A kthread_work
      80             :  * can be queued and flushed using queue/kthread_flush_work()
      81             :  * respectively.  Queued kthread_works are processed by a kthread
      82             :  * running kthread_worker_fn().
      83             :  */
      84             : struct kthread_work;
      85             : typedef void (*kthread_work_func_t)(struct kthread_work *work);
      86             : void kthread_delayed_work_timer_fn(struct timer_list *t);
      87             : 
      88             : enum {
      89             :         KTW_FREEZABLE           = 1 << 0, /* freeze during suspend */
      90             : };
      91             : 
      92             : struct kthread_worker {
      93             :         unsigned int            flags;
      94             :         raw_spinlock_t          lock;
      95             :         struct list_head        work_list;
      96             :         struct list_head        delayed_work_list;
      97             :         struct task_struct      *task;
      98             :         struct kthread_work     *current_work;
      99             : };
     100             : 
     101             : struct kthread_work {
     102             :         struct list_head        node;
     103             :         kthread_work_func_t     func;
     104             :         struct kthread_worker   *worker;
     105             :         /* Number of canceling calls that are running at the moment. */
     106             :         int                     canceling;
     107             : };
     108             : 
     109             : struct kthread_delayed_work {
     110             :         struct kthread_work work;
     111             :         struct timer_list timer;
     112             : };
     113             : 
     114             : #define KTHREAD_WORKER_INIT(worker)     {                               \
     115             :         .lock = __RAW_SPIN_LOCK_UNLOCKED((worker).lock),                \
     116             :         .work_list = LIST_HEAD_INIT((worker).work_list),                \
     117             :         .delayed_work_list = LIST_HEAD_INIT((worker).delayed_work_list),\
     118             :         }
     119             : 
     120             : #define KTHREAD_WORK_INIT(work, fn)     {                               \
     121             :         .node = LIST_HEAD_INIT((work).node),                            \
     122             :         .func = (fn),                                                   \
     123             :         }
     124             : 
     125             : #define KTHREAD_DELAYED_WORK_INIT(dwork, fn) {                          \
     126             :         .work = KTHREAD_WORK_INIT((dwork).work, (fn)),                  \
     127             :         .timer = __TIMER_INITIALIZER(kthread_delayed_work_timer_fn,\
     128             :                                      TIMER_IRQSAFE),                    \
     129             :         }
     130             : 
     131             : #define DEFINE_KTHREAD_WORKER(worker)                                   \
     132             :         struct kthread_worker worker = KTHREAD_WORKER_INIT(worker)
     133             : 
     134             : #define DEFINE_KTHREAD_WORK(work, fn)                                   \
     135             :         struct kthread_work work = KTHREAD_WORK_INIT(work, fn)
     136             : 
     137             : #define DEFINE_KTHREAD_DELAYED_WORK(dwork, fn)                          \
     138             :         struct kthread_delayed_work dwork =                             \
     139             :                 KTHREAD_DELAYED_WORK_INIT(dwork, fn)
     140             : 
     141             : /*
     142             :  * kthread_worker.lock needs its own lockdep class key when defined on
     143             :  * stack with lockdep enabled.  Use the following macros in such cases.
     144             :  */
     145             : #ifdef CONFIG_LOCKDEP
     146             : # define KTHREAD_WORKER_INIT_ONSTACK(worker)                            \
     147             :         ({ kthread_init_worker(&worker); worker; })
     148             : # define DEFINE_KTHREAD_WORKER_ONSTACK(worker)                          \
     149             :         struct kthread_worker worker = KTHREAD_WORKER_INIT_ONSTACK(worker)
     150             : #else
     151             : # define DEFINE_KTHREAD_WORKER_ONSTACK(worker) DEFINE_KTHREAD_WORKER(worker)
     152             : #endif
     153             : 
     154             : extern void __kthread_init_worker(struct kthread_worker *worker,
     155             :                         const char *name, struct lock_class_key *key);
     156             : 
     157             : #define kthread_init_worker(worker)                                     \
     158             :         do {                                                            \
     159             :                 static struct lock_class_key __key;                     \
     160             :                 __kthread_init_worker((worker), "("#worker")->lock", &__key); \
     161             :         } while (0)
     162             : 
     163             : #define kthread_init_work(work, fn)                                     \
     164             :         do {                                                            \
     165             :                 memset((work), 0, sizeof(struct kthread_work));         \
     166             :                 INIT_LIST_HEAD(&(work)->node);                           \
     167             :                 (work)->func = (fn);                                 \
     168             :         } while (0)
     169             : 
     170             : #define kthread_init_delayed_work(dwork, fn)                            \
     171             :         do {                                                            \
     172             :                 kthread_init_work(&(dwork)->work, (fn));         \
     173             :                 timer_setup(&(dwork)->timer,                             \
     174             :                              kthread_delayed_work_timer_fn,             \
     175             :                              TIMER_IRQSAFE);                            \
     176             :         } while (0)
     177             : 
     178             : int kthread_worker_fn(void *worker_ptr);
     179             : 
     180             : __printf(2, 3)
     181             : struct kthread_worker *
     182             : kthread_create_worker(unsigned int flags, const char namefmt[], ...);
     183             : 
     184             : __printf(3, 4) struct kthread_worker *
     185             : kthread_create_worker_on_cpu(int cpu, unsigned int flags,
     186             :                              const char namefmt[], ...);
     187             : 
     188             : bool kthread_queue_work(struct kthread_worker *worker,
     189             :                         struct kthread_work *work);
     190             : 
     191             : bool kthread_queue_delayed_work(struct kthread_worker *worker,
     192             :                                 struct kthread_delayed_work *dwork,
     193             :                                 unsigned long delay);
     194             : 
     195             : bool kthread_mod_delayed_work(struct kthread_worker *worker,
     196             :                               struct kthread_delayed_work *dwork,
     197             :                               unsigned long delay);
     198             : 
     199             : void kthread_flush_work(struct kthread_work *work);
     200             : void kthread_flush_worker(struct kthread_worker *worker);
     201             : 
     202             : bool kthread_cancel_work_sync(struct kthread_work *work);
     203             : bool kthread_cancel_delayed_work_sync(struct kthread_delayed_work *work);
     204             : 
     205             : void kthread_destroy_worker(struct kthread_worker *worker);
     206             : 
     207             : void kthread_use_mm(struct mm_struct *mm);
     208             : void kthread_unuse_mm(struct mm_struct *mm);
     209             : 
     210             : struct cgroup_subsys_state;
     211             : 
     212             : #ifdef CONFIG_BLK_CGROUP
     213             : void kthread_associate_blkcg(struct cgroup_subsys_state *css);
     214             : struct cgroup_subsys_state *kthread_blkcg(void);
     215             : #else
     216           0 : static inline void kthread_associate_blkcg(struct cgroup_subsys_state *css) { }
     217             : static inline struct cgroup_subsys_state *kthread_blkcg(void)
     218             : {
     219             :         return NULL;
     220             : }
     221             : #endif
     222             : #endif /* _LINUX_KTHREAD_H */

Generated by: LCOV version 1.14