kernel/kthread.c

   1 /* Kernel thread helper functions.
   2  *   Copyright (C) 2004 IBM Corporation, Rusty Russell.
   3  *
   4  * Creation is done via kthreadd, so that we get a clean environment
   5  * even if we're invoked from userspace (think modprobe, hotplug cpu,
   6  * etc.).
   7  */
   8 #include <uapi/linux/sched/types.h>
   9 #include <linux/sched.h>
  10 #include <linux/sched/task.h>
  11 #include <linux/kthread.h>
  12 #include <linux/completion.h>
  13 #include <linux/err.h>
  14 #include <linux/cpuset.h>
  15 #include <linux/unistd.h>
  16 #include <linux/file.h>
  17 #include <linux/export.h>
  18 #include <linux/mutex.h>
  19 #include <linux/slab.h>
  20 #include <linux/freezer.h>
  21 #include <linux/ptrace.h>
  22 #include <linux/uaccess.h>
  23 #include <linux/numa.h>
  24 #include <trace/events/sched.h>
  25
  26 static DEFINE_SPINLOCK(kthread_create_lock);
  27 static LIST_HEAD(kthread_create_list);
  28 struct task_struct *kthreadd_task;
  29
  30 struct kthread_create_info
  31 {
  32         /* Information passed to kthread() from kthreadd. */
  33         int (*threadfn)(void *data);
  34         void *data;
  35         int node;
  36
  37         /* Result passed back to kthread_create() from kthreadd. */
  38         struct task_struct *result;
  39         struct completion *done;
  40
  41         struct list_head list;
  42 };
  43
  44 struct kthread {
  45         unsigned long flags;
  46         unsigned int cpu;
  47         void *data;
  48         struct completion parked;
  49         struct completion exited;
  50 #ifdef CONFIG_BLK_CGROUP
  51         struct cgroup_subsys_state *blkcg_css;
  52 #endif
  53 };
  54
  55 enum KTHREAD_BITS {
  56         KTHREAD_IS_PER_CPU = 0,
  57         KTHREAD_SHOULD_STOP,
  58         KTHREAD_SHOULD_PARK,
  59 };
  60
  61 static inline void set_kthread_struct(void *kthread)
  62 {
  63         /*
  64          * We abuse ->set_child_tid to avoid the new member and because it
  65          * can't be wrongly copied by copy_process(). We also rely on fact
  66          * that the caller can't exec, so PF_KTHREAD can't be cleared.
  67          */
  68         current->set_child_tid = (__force void __user *)kthread;
  69 }
  70
  71 static inline struct kthread *to_kthread(struct task_struct *k)
  72 {
  73         WARN_ON(!(k->flags & PF_KTHREAD));
  74         return (__force void *)k->set_child_tid;
  75 }
  76
  77 void free_kthread_struct(struct task_struct *k)
  78 {
  79         struct kthread *kthread;
  80
  81         /*
  82          * Can be NULL if this kthread was created by kernel_thread()
  83          * or if kmalloc() in kthread() failed.
  84          */
  85         kthread = to_kthread(k);
  86 #ifdef CONFIG_BLK_CGROUP
  87         WARN_ON_ONCE(kthread && kthread->blkcg_css);
  88 #endif
  89         kfree(kthread);
  90 }
  91
  92 /**
  93  * kthread_should_stop - should this kthread return now?
  94  *
  95  * When someone calls kthread_stop() on your kthread, it will be woken
  96  * and this will return true.  You should then return, and your return
  97  * value will be passed through to kthread_stop().
  98  */
  99 bool kthread_should_stop(void)
 100 {
 101         return test_bit(KTHREAD_SHOULD_STOP, &to_kthread(current)->flags);
 102 }
 103 EXPORT_SYMBOL(kthread_should_stop);
 104
 105 bool __kthread_should_park(struct task_struct *k)
 106 {
 107         return test_bit(KTHREAD_SHOULD_PARK, &to_kthread(k)->flags);
 108 }
 109 EXPORT_SYMBOL_GPL(__kthread_should_park);
 110
 111 /**
 112  * kthread_should_park - should this kthread park now?
 113  *
 114  * When someone calls kthread_park() on your kthread, it will be woken
 115  * and this will return true.  You should then do the necessary
 116  * cleanup and call kthread_parkme()
 117  *
 118  * Similar to kthread_should_stop(), but this keeps the thread alive
 119  * and in a park position. kthread_unpark() "restarts" the thread and
 120  * calls the thread function again.
 121  */
 122 bool kthread_should_park(void)
 123 {
 124         return __kthread_should_park(current);
 125 }
 126 EXPORT_SYMBOL_GPL(kthread_should_park);
 127
 128 /**
 129  * kthread_freezable_should_stop - should this freezable kthread return now?
 130  * @was_frozen: optional out parameter, indicates whether %current was frozen
 131  *
 132  * kthread_should_stop() for freezable kthreads, which will enter
 133  * refrigerator if necessary.  This function is safe from kthread_stop() /
 134  * freezer deadlock and freezable kthreads should use this function instead
 135  * of calling try_to_freeze() directly.
 136  */
 137 bool kthread_freezable_should_stop(bool *was_frozen)
 138 {
 139         bool frozen = false;
 140
 141         might_sleep();
 142
 143         if (unlikely(freezing(current)))
 144                 frozen = __refrigerator(true);
 145
 146         if (was_frozen)
 147                 *was_frozen = frozen;
 148
 149         return kthread_should_stop();
 150 }
 151 EXPORT_SYMBOL_GPL(kthread_freezable_should_stop);
 152
 153 /**
 154  * kthread_data - return data value specified on kthread creation
 155  * @task: kthread task in question
 156  *
 157  * Return the data value specified when kthread @task was created.
 158  * The caller is responsible for ensuring the validity of @task when
 159  * calling this function.
 160  */
 161 void *kthread_data(struct task_struct *task)
 162 {
 163         return to_kthread(task)->data;
 164 }
 165
 166 /**
 167  * kthread_probe_data - speculative version of kthread_data()
 168  * @task: possible kthread task in question
 169  *
 170  * @task could be a kthread task.  Return the data value specified when it
 171  * was created if accessible.  If @task isn't a kthread task or its data is
 172  * inaccessible for any reason, %NULL is returned.  This function requires
 173  * that @task itself is safe to dereference.
 174  */
 175 void *kthread_probe_data(struct task_struct *task)
 176 {
 177         struct kthread *kthread = to_kthread(task);
 178         void *data = NULL;
 179
 180         probe_kernel_read(&data, &kthread->data, sizeof(data));
 181         return data;
 182 }
 183
 184 static void __kthread_parkme(struct kthread *self)
 185 {
 186         for (;;) {
 187                 /*
 188                  * TASK_PARKED is a special state; we must serialize against
 189                  * possible pending wakeups to avoid store-store collisions on
 190                  * task->state.
 191                  *
 192                  * Such a collision might possibly result in the task state
 193                  * changin from TASK_PARKED and us failing the
 194                  * wait_task_inactive() in kthread_park().
 195                  */
 196                 set_special_state(TASK_PARKED);
 197                 if (!test_bit(KTHREAD_SHOULD_PARK, &self->flags))
 198                         break;
 199
 200                 complete(&self->parked);
 201                 schedule();
 202         }
 203         __set_current_state(TASK_RUNNING);
 204 }
 205
 206 void kthread_parkme(void)
 207 {
 208         __kthread_parkme(to_kthread(current));
 209 }
 210 EXPORT_SYMBOL_GPL(kthread_parkme);
 211
 212 static int kthread(void *_create)
 213 {
 214         /* Copy data: it's on kthread's stack */
 215         struct kthread_create_info *create = _create;
 216         int (*threadfn)(void *data) = create->threadfn;
 217         void *data = create->data;
 218         struct completion *done;
 219         struct kthread *self;
 220         int ret;
 221
 222         self = kzalloc(sizeof(*self), GFP_KERNEL);
 223         set_kthread_struct(self);
 224
 225         /* If user was SIGKILLed, I release the structure. */
 226         done = xchg(&create->done, NULL);
 227         if (!done) {
 228                 kfree(create);
 229                 do_exit(-EINTR);
 230         }
 231
 232         if (!self) {
 233                 create->result = ERR_PTR(-ENOMEM);
 234                 complete(done);
 235                 do_exit(-ENOMEM);
 236         }
 237
 238         self->data = data;
 239         init_completion(&self->exited);
 240         init_completion(&self->parked);
 241         current->vfork_done = &self->exited;
 242
 243         /* OK, tell user we're spawned, wait for stop or wakeup */
 244         __set_current_state(TASK_UNINTERRUPTIBLE);
 245         create->result = current;
 246         complete(done);
 247         schedule();
 248
 249         ret = -EINTR;
 250         if (!test_bit(KTHREAD_SHOULD_STOP, &self->flags)) {
 251                 cgroup_kthread_ready();
 252                 __kthread_parkme(self);
 253                 ret = threadfn(data);
 254         }
 255         do_exit(ret);
 256 }
 257
 258 /* called from do_fork() to get node information for about to be created task */
 259 int tsk_fork_get_node(struct task_struct *tsk)
 260 {
 261 #ifdef CONFIG_NUMA
 262         if (tsk == kthreadd_task)
 263                 return tsk->pref_node_fork;
 264 #endif
 265         return NUMA_NO_NODE;
 266 }
 267
 268 static void create_kthread(struct kthread_create_info *create)
 269 {
 270         int pid;
 271
 272 #ifdef CONFIG_NUMA
 273         current->pref_node_fork = create->node;
 274 #endif
 275         /* We want our own signal handler (we take no signals by default). */
 276         pid = kernel_thread(kthread, create, CLONE_FS | CLONE_FILES | SIGCHLD);
 277         if (pid < 0) {
 278                 /* If user was SIGKILLed, I release the structure. */
 279                 struct completion *done = xchg(&create->done, NULL);
 280
 281                 if (!done) {
 282                         kfree(create);
 283                         return;
 284                 }
 285                 create->result = ERR_PTR(pid);
 286                 complete(done);
 287         }
 288 }
 289
 290 static __printf(4, 0)
 291 struct task_struct *__kthread_create_on_node(int (*threadfn)(void *data),
 292                                                     void *data, int node,
 293                                                     const char namefmt[],
 294                                                     va_list args)
 295 {
 296         DECLARE_COMPLETION_ONSTACK(done);
 297         struct task_struct *task;
 298         struct kthread_create_info *create = kmalloc(sizeof(*create),
 299                                                      GFP_KERNEL);
 300
 301         if (!create)
 302                 return ERR_PTR(-ENOMEM);
 303         create->threadfn = threadfn;
 304         create->data = data;
 305         create->node = node;
 306         create->done = &done;
 307
 308         spin_lock(&kthread_create_lock);
 309         list_add_tail(&create->list, &kthread_create_list);
 310         spin_unlock(&kthread_create_lock);
 311
 312         wake_up_process(kthreadd_task);
 313         /*
 314          * Wait for completion in killable state, for I might be chosen by
 315          * the OOM killer while kthreadd is trying to allocate memory for
 316          * new kernel thread.
 317          */
 318         if (unlikely(wait_for_completion_killable(&done))) {
 319                 /*
 320                  * If I was SIGKILLed before kthreadd (or new kernel thread)
 321                  * calls complete(), leave the cleanup of this structure to
 322                  * that thread.
 323                  */
 324                 if (xchg(&create->done, NULL))
 325                         return ERR_PTR(-EINTR);
 326                 /*
 327                  * kthreadd (or new kernel thread) will call complete()
 328                  * shortly.
 329                  */
 330                 wait_for_completion(&done);
 331         }
 332         task = create->result;
 333         if (!IS_ERR(task)) {
 334                 static const struct sched_param param = { .sched_priority = 0 };
 335                 char name[TASK_COMM_LEN];
 336
 337                 /*
 338                  * task is already visible to other tasks, so updating
 339                  * COMM must be protected.
 340                  */
 341                 vsnprintf(name, sizeof(name), namefmt, args);
 342                 set_task_comm(task, name);
 343                 /*
 344                  * root may have changed our (kthreadd's) priority or CPU mask.
 345                  * The kernel thread should not inherit these properties.
 346                  */
 347                 sched_setscheduler_nocheck(task, SCHED_NORMAL, &param);
 348                 set_cpus_allowed_ptr(task, cpu_all_mask);
 349         }
 350         kfree(create);
 351         return task;
 352 }
 353
 354 /**
 355  * kthread_create_on_node - create a kthread.
 356  * @threadfn: the function to run until signal_pending(current).
 357  * @data: data ptr for @threadfn.
 358  * @node: task and thread structures for the thread are allocated on this node
 359  * @namefmt: printf-style name for the thread.
 360  *
 361  * Description: This helper function creates and names a kernel
 362  * thread.  The thread will be stopped: use wake_up_process() to start
 363  * it.  See also kthread_run().  The new thread has SCHED_NORMAL policy and
 364  * is affine to all CPUs.
 365  *
 366  * If thread is going to be bound on a particular cpu, give its node
 367  * in @node, to get NUMA affinity for kthread stack, or else give NUMA_NO_NODE.
 368  * When woken, the thread will run @threadfn() with @data as its
 369  * argument. @threadfn() can either call do_exit() directly if it is a
 370  * standalone thread for which no one will call kthread_stop(), or
 371  * return when 'kthread_should_stop()' is true (which means
 372  * kthread_stop() has been called).  The return value should be zero
 373  * or a negative error number; it will be passed to kthread_stop().
 374  *
 375  * Returns a task_struct or ERR_PTR(-ENOMEM) or ERR_PTR(-EINTR).
 376  */
 377 struct task_struct *kthread_create_on_node(int (*threadfn)(void *data),
 378                                            void *data, int node,
 379                                            const char namefmt[],
 380                                            ...)
 381 {
 382         struct task_struct *task;
 383         va_list args;
 384
 385         va_start(args, namefmt);
 386         task = __kthread_create_on_node(threadfn, data, node, namefmt, args);
 387         va_end(args);
 388
 389         return task;
 390 }
 391 EXPORT_SYMBOL(kthread_create_on_node);
 392
 393 static void __kthread_bind_mask(struct task_struct *p, const struct cpumask *mask, long state)
 394 {
 395         unsigned long flags;
 396
 397         if (!wait_task_inactive(p, state)) {
 398                 WARN_ON(1);
 399                 return;
 400         }
 401
 402         /* It's safe because the task is inactive. */
 403         raw_spin_lock_irqsave(&p->pi_lock, flags);
 404         do_set_cpus_allowed(p, mask);
 405         p->flags |= PF_NO_SETAFFINITY;
 406         raw_spin_unlock_irqrestore(&p->pi_lock, flags);
 407 }
 408
 409 static void __kthread_bind(struct task_struct *p, unsigned int cpu, long state)
 410 {
 411         __kthread_bind_mask(p, cpumask_of(cpu), state);
 412 }
 413
 414 void kthread_bind_mask(struct task_struct *p, const struct cpumask *mask)
 415 {
 416         __kthread_bind_mask(p, mask, TASK_UNINTERRUPTIBLE);
 417 }
 418
 419 /**
 420  * kthread_bind - bind a just-created kthread to a cpu.
 421  * @p: thread created by kthread_create().
 422  * @cpu: cpu (might not be online, must be possible) for @k to run on.
 423  *
 424  * Description: This function is equivalent to set_cpus_allowed(),
 425  * except that @cpu doesn't need to be online, and the thread must be
 426  * stopped (i.e., just returned from kthread_create()).
 427  */
 428 void kthread_bind(struct task_struct *p, unsigned int cpu)
 429 {
 430         __kthread_bind(p, cpu, TASK_UNINTERRUPTIBLE);
 431 }
 432 EXPORT_SYMBOL(kthread_bind);
 433
 434 /**
 435  * kthread_create_on_cpu - Create a cpu bound kthread
 436  * @threadfn: the function to run until signal_pending(current).
 437  * @data: data ptr for @threadfn.
 438  * @cpu: The cpu on which the thread should be bound,
 439  * @namefmt: printf-style name for the thread. Format is restricted
 440  *           to "name.*%u". Code fills in cpu number.
 441  *
 442  * Description: This helper function creates and names a kernel thread
 443  * The thread will be woken and put into park mode.
 444  */
 445 struct task_struct *kthread_create_on_cpu(int (*threadfn)(void *data),
 446                                           void *data, unsigned int cpu,
 447                                           const char *namefmt)
 448 {
 449         struct task_struct *p;
 450
 451         p = kthread_create_on_node(threadfn, data, cpu_to_node(cpu), namefmt,
 452                                    cpu);
 453         if (IS_ERR(p))
 454                 return p;
 455         kthread_bind(p, cpu);
 456         /* CPU hotplug need to bind once again when unparking the thread. */
 457         set_bit(KTHREAD_IS_PER_CPU, &to_kthread(p)->flags);
 458         to_kthread(p)->cpu = cpu;
 459         return p;
 460 }
 461
 462 /**
 463  * kthread_unpark - unpark a thread created by kthread_create().
 464  * @k:          thread created by kthread_create().
 465  *
 466  * Sets kthread_should_park() for @k to return false, wakes it, and
 467  * waits for it to return. If the thread is marked percpu then its
 468  * bound to the cpu again.
 469  */
 470 void kthread_unpark(struct task_struct *k)
 471 {
 472         struct kthread *kthread = to_kthread(k);
 473
 474         /*
 475          * Newly created kthread was parked when the CPU was offline.
 476          * The binding was lost and we need to set it again.
 477          */
 478         if (test_bit(KTHREAD_IS_PER_CPU, &kthread->flags))
 479                 __kthread_bind(k, kthread->cpu, TASK_PARKED);
 480
 481         clear_bit(KTHREAD_SHOULD_PARK, &kthread->flags);
 482         /*
 483          * __kthread_parkme() will either see !SHOULD_PARK or get the wakeup.
 484          */
 485         wake_up_state(k, TASK_PARKED);
 486 }
 487 EXPORT_SYMBOL_GPL(kthread_unpark);
 488
 489 /**
 490  * kthread_park - park a thread created by kthread_create().
 491  * @k: thread created by kthread_create().
 492  *
 493  * Sets kthread_should_park() for @k to return true, wakes it, and
 494  * waits for it to return. This can also be called after kthread_create()
 495  * instead of calling wake_up_process(): the thread will park without
 496  * calling threadfn().
 497  *
 498  * Returns 0 if the thread is parked, -ENOSYS if the thread exited.
 499  * If called by the kthread itself just the park bit is set.
 500  */
 501 int kthread_park(struct task_struct *k)
 502 {
 503         struct kthread *kthread = to_kthread(k);
 504
 505         if (WARN_ON(k->flags & PF_EXITING))
 506                 return -ENOSYS;
 507
 508         if (WARN_ON_ONCE(test_bit(KTHREAD_SHOULD_PARK, &kthread->flags)))
 509                 return -EBUSY;
 510
 511         set_bit(KTHREAD_SHOULD_PARK, &kthread->flags);
 512         if (k != current) {
 513                 wake_up_process(k);
 514                 /*
 515                  * Wait for __kthread_parkme() to complete(), this means we
 516                  * _will_ have TASK_PARKED and are about to call schedule().
 517                  */
 518                 wait_for_completion(&kthread->parked);
 519                 /*
 520                  * Now wait for that schedule() to complete and the task to
 521                  * get scheduled out.
 522                  */
 523                 WARN_ON_ONCE(!wait_task_inactive(k, TASK_PARKED));
 524         }
 525
 526         return 0;
 527 }
 528 EXPORT_SYMBOL_GPL(kthread_park);
 529
 530 /**
 531  * kthread_stop - stop a thread created by kthread_create().
 532  * @k: thread created by kthread_create().
 533  *
 534  * Sets kthread_should_stop() for @k to return true, wakes it, and
 535  * waits for it to exit. This can also be called after kthread_create()
 536  * instead of calling wake_up_process(): the thread will exit without
 537  * calling threadfn().
 538  *
 539  * If threadfn() may call do_exit() itself, the caller must ensure
 540  * task_struct can't go away.
 541  *
 542  * Returns the result of threadfn(), or %-EINTR if wake_up_process()
 543  * was never called.
 544  */
 545 int kthread_stop(struct task_struct *k)
 546 {
 547         struct kthread *kthread;
 548         int ret;
 549
 550         trace_sched_kthread_stop(k);
 551
 552         get_task_struct(k);
 553         kthread = to_kthread(k);
 554         set_bit(KTHREAD_SHOULD_STOP, &kthread->flags);
 555         kthread_unpark(k);
 556         wake_up_process(k);
 557         wait_for_completion(&kthread->exited);
 558         ret = k->exit_code;
 559         put_task_struct(k);
 560
 561         trace_sched_kthread_stop_ret(ret);
 562         return ret;
 563 }
 564 EXPORT_SYMBOL(kthread_stop);
 565
 566 int kthreadd(void *unused)
 567 {
 568         struct task_struct *tsk = current;
 569
 570         /* Setup a clean context for our children to inherit. */
 571         set_task_comm(tsk, "kthreadd");
 572         ignore_signals(tsk);
 573         set_cpus_allowed_ptr(tsk, cpu_all_mask);
 574         set_mems_allowed(node_states[N_MEMORY]);
 575
 576         current->flags |= PF_NOFREEZE;
 577         cgroup_init_kthreadd();
 578
 579         for (;;) {
 580                 set_current_state(TASK_INTERRUPTIBLE);
 581                 if (list_empty(&kthread_create_list))
 582                         schedule();
 583                 __set_current_state(TASK_RUNNING);
 584
 585                 spin_lock(&kthread_create_lock);
 586                 while (!list_empty(&kthread_create_list)) {
 587                         struct kthread_create_info *create;
 588
 589                         create = list_entry(kthread_create_list.next,
 590                                             struct kthread_create_info, list);
 591                         list_del_init(&create->list);
 592                         spin_unlock(&kthread_create_lock);
 593
 594                         create_kthread(create);
 595
 596                         spin_lock(&kthread_create_lock);
 597                 }
 598                 spin_unlock(&kthread_create_lock);
 599         }
 600
 601         return 0;
 602 }
 603
 604 void __kthread_init_worker(struct kthread_worker *worker,
 605                                 const char *name,
 606                                 struct lock_class_key *key)
 607 {
 608         memset(worker, 0, sizeof(struct kthread_worker));
 609         raw_spin_lock_init(&worker->lock);
 610         lockdep_set_class_and_name(&worker->lock, key, name);
 611         INIT_LIST_HEAD(&worker->work_list);
 612         INIT_LIST_HEAD(&worker->delayed_work_list);
 613 }
 614 EXPORT_SYMBOL_GPL(__kthread_init_worker);
 615
 616 /**
 617  * kthread_worker_fn - kthread function to process kthread_worker
 618  * @worker_ptr: pointer to initialized kthread_worker
 619  *
 620  * This function implements the main cycle of kthread worker. It processes
 621  * work_list until it is stopped with kthread_stop(). It sleeps when the queue
 622  * is empty.
 623  *
 624  * The works are not allowed to keep any locks, disable preemption or interrupts
 625  * when they finish. There is defined a safe point for freezing when one work
 626  * finishes and before a new one is started.
 627  *
 628  * Also the works must not be handled by more than one worker at the same time,
 629  * see also kthread_queue_work().
 630  */
 631 int kthread_worker_fn(void *worker_ptr)
 632 {
 633         struct kthread_worker *worker = worker_ptr;
 634         struct kthread_work *work;
 635
 636         /*
 637          * FIXME: Update the check and remove the assignment when all kthread
 638          * worker users are created using kthread_create_worker*() functions.
 639          */
 640         WARN_ON(worker->task && worker->task != current);
 641         worker->task = current;
 642
 643         if (worker->flags & KTW_FREEZABLE)
 644                 set_freezable();
 645
 646 repeat:
 647         set_current_state(TASK_INTERRUPTIBLE);  /* mb paired w/ kthread_stop */
 648
 649         if (kthread_should_stop()) {
 650                 __set_current_state(TASK_RUNNING);
 651                 raw_spin_lock_irq(&worker->lock);
 652                 worker->task = NULL;
 653                 raw_spin_unlock_irq(&worker->lock);
 654                 return 0;
 655         }
 656
 657         work = NULL;
 658         raw_spin_lock_irq(&worker->lock);
 659         if (!list_empty(&worker->work_list)) {
 660                 work = list_first_entry(&worker->work_list,
 661                                         struct kthread_work, node);
 662                 list_del_init(&work->node);
 663         }
 664         worker->current_work = work;
 665         raw_spin_unlock_irq(&worker->lock);
 666
 667         if (work) {
 668                 __set_current_state(TASK_RUNNING);
 669                 work->func(work);
 670         } else if (!freezing(current))
 671                 schedule();
 672
 673         try_to_freeze();
 674         cond_resched();
 675         goto repeat;
 676 }
 677 EXPORT_SYMBOL_GPL(kthread_worker_fn);
 678
 679 static __printf(3, 0) struct kthread_worker *
 680 __kthread_create_worker(int cpu, unsigned int flags,
 681                         const char namefmt[], va_list args)
 682 {
 683         struct kthread_worker *worker;
 684         struct task_struct *task;
 685         int node = NUMA_NO_NODE;
 686
 687         worker = kzalloc(sizeof(*worker), GFP_KERNEL);
 688         if (!worker)
 689                 return ERR_PTR(-ENOMEM);
 690
 691         kthread_init_worker(worker);
 692
 693         if (cpu >= 0)
 694                 node = cpu_to_node(cpu);
 695
 696         task = __kthread_create_on_node(kthread_worker_fn, worker,
 697                                                 node, namefmt, args);
 698         if (IS_ERR(task))
 699                 goto fail_task;
 700
 701         if (cpu >= 0)
 702                 kthread_bind(task, cpu);
 703
 704         worker->flags = flags;
 705         worker->task = task;
 706         wake_up_process(task);
 707         return worker;
 708
 709 fail_task:
 710         kfree(worker);
 711         return ERR_CAST(task);
 712 }
 713
 714 /**
 715  * kthread_create_worker - create a kthread worker
 716  * @flags: flags modifying the default behavior of the worker
 717  * @namefmt: printf-style name for the kthread worker (task).
 718  *
 719  * Returns a pointer to the allocated worker on success, ERR_PTR(-ENOMEM)
 720  * when the needed structures could not get allocated, and ERR_PTR(-EINTR)
 721  * when the worker was SIGKILLed.
 722  */
 723 struct kthread_worker *
 724 kthread_create_worker(unsigned int flags, const char namefmt[], ...)
 725 {
 726         struct kthread_worker *worker;
 727         va_list args;
 728
 729         va_start(args, namefmt);
 730         worker = __kthread_create_worker(-1, flags, namefmt, args);
 731         va_end(args);
 732
 733         return worker;
 734 }
 735 EXPORT_SYMBOL(kthread_create_worker);
 736
 737 /**
 738  * kthread_create_worker_on_cpu - create a kthread worker and bind it
 739  *      it to a given CPU and the associated NUMA node.
 740  * @cpu: CPU number
 741  * @flags: flags modifying the default behavior of the worker
 742  * @namefmt: printf-style name for the kthread worker (task).
 743  *
 744  * Use a valid CPU number if you want to bind the kthread worker
 745  * to the given CPU and the associated NUMA node.
 746  *
 747  * A good practice is to add the cpu number also into the worker name.
 748  * For example, use kthread_create_worker_on_cpu(cpu, "helper/%d", cpu).
 749  *
 750  * Returns a pointer to the allocated worker on success, ERR_PTR(-ENOMEM)
 751  * when the needed structures could not get allocated, and ERR_PTR(-EINTR)
 752  * when the worker was SIGKILLed.
 753  */
 754 struct kthread_worker *
 755 kthread_create_worker_on_cpu(int cpu, unsigned int flags,
 756                              const char namefmt[], ...)
 757 {
 758         struct kthread_worker *worker;
 759         va_list args;
 760
 761         va_start(args, namefmt);
 762         worker = __kthread_create_worker(cpu, flags, namefmt, args);
 763         va_end(args);
 764
 765         return worker;
 766 }
 767 EXPORT_SYMBOL(kthread_create_worker_on_cpu);
 768
 769 /*
 770  * Returns true when the work could not be queued at the moment.
 771  * It happens when it is already pending in a worker list
 772  * or when it is being cancelled.
 773  */
 774 static inline bool queuing_blocked(struct kthread_worker *worker,
 775                                    struct kthread_work *work)
 776 {
 777         lockdep_assert_held(&worker->lock);
 778
 779         return !list_empty(&work->node) || work->canceling;
 780 }
 781
 782 static void kthread_insert_work_sanity_check(struct kthread_worker *worker,
 783                                              struct kthread_work *work)
 784 {
 785         lockdep_assert_held(&worker->lock);
 786         WARN_ON_ONCE(!list_empty(&work->node));
 787         /* Do not use a work with >1 worker, see kthread_queue_work() */
 788         WARN_ON_ONCE(work->worker && work->worker != worker);
 789 }
 790
 791 /* insert @work before @pos in @worker */
 792 static void kthread_insert_work(struct kthread_worker *worker,
 793                                 struct kthread_work *work,
 794                                 struct list_head *pos)
 795 {
 796         kthread_insert_work_sanity_check(worker, work);
 797
 798         list_add_tail(&work->node, pos);
 799         work->worker = worker;
 800         if (!worker->current_work && likely(worker->task))
 801                 wake_up_process(worker->task);
 802 }
 803
 804 /**
 805  * kthread_queue_work - queue a kthread_work
 806  * @worker: target kthread_worker
 807  * @work: kthread_work to queue
 808  *
 809  * Queue @work to work processor @task for async execution.  @task
 810  * must have been created with kthread_worker_create().  Returns %true
 811  * if @work was successfully queued, %false if it was already pending.
 812  *
 813  * Reinitialize the work if it needs to be used by another worker.
 814  * For example, when the worker was stopped and started again.
 815  */
 816 bool kthread_queue_work(struct kthread_worker *worker,
 817                         struct kthread_work *work)
 818 {
 819         bool ret = false;
 820         unsigned long flags;
 821
 822         raw_spin_lock_irqsave(&worker->lock, flags);
 823         if (!queuing_blocked(worker, work)) {
 824                 kthread_insert_work(worker, work, &worker->work_list);
 825                 ret = true;
 826         }
 827         raw_spin_unlock_irqrestore(&worker->lock, flags);
 828         return ret;
 829 }
 830 EXPORT_SYMBOL_GPL(kthread_queue_work);
 831
 832 /**
 833  * kthread_delayed_work_timer_fn - callback that queues the associated kthread
 834  *      delayed work when the timer expires.
 835  * @t: pointer to the expired timer
 836  *
 837  * The format of the function is defined by struct timer_list.
 838  * It should have been called from irqsafe timer with irq already off.
 839  */
 840 void kthread_delayed_work_timer_fn(struct timer_list *t)
 841 {
 842         struct kthread_delayed_work *dwork = from_timer(dwork, t, timer);
 843         struct kthread_work *work = &dwork->work;
 844         struct kthread_worker *worker = work->worker;
 845         unsigned long flags;
 846
 847         /*
 848          * This might happen when a pending work is reinitialized.
 849          * It means that it is used a wrong way.
 850          */
 851         if (WARN_ON_ONCE(!worker))
 852                 return;
 853
 854         raw_spin_lock_irqsave(&worker->lock, flags);
 855         /* Work must not be used with >1 worker, see kthread_queue_work(). */
 856         WARN_ON_ONCE(work->worker != worker);
 857
 858         /* Move the work from worker->delayed_work_list. */
 859         WARN_ON_ONCE(list_empty(&work->node));
 860         list_del_init(&work->node);
 861         kthread_insert_work(worker, work, &worker->work_list);
 862
 863         raw_spin_unlock_irqrestore(&worker->lock, flags);
 864 }
 865 EXPORT_SYMBOL(kthread_delayed_work_timer_fn);
 866
 867 void __kthread_queue_delayed_work(struct kthread_worker *worker,
 868                                   struct kthread_delayed_work *dwork,
 869                                   unsigned long delay)
 870 {
 871         struct timer_list *timer = &dwork->timer;
 872         struct kthread_work *work = &dwork->work;
 873
 874         WARN_ON_ONCE(timer->function != kthread_delayed_work_timer_fn);
 875
 876         /*
 877          * If @delay is 0, queue @dwork->work immediately.  This is for
 878          * both optimization and correctness.  The earliest @timer can
 879          * expire is on the closest next tick and delayed_work users depend
 880          * on that there's no such delay when @delay is 0.
 881          */
 882         if (!delay) {
 883                 kthread_insert_work(worker, work, &worker->work_list);
 884                 return;
 885         }
 886
 887         /* Be paranoid and try to detect possible races already now. */
 888         kthread_insert_work_sanity_check(worker, work);
 889
 890         list_add(&work->node, &worker->delayed_work_list);
 891         work->worker = worker;
 892         timer->expires = jiffies + delay;
 893         add_timer(timer);
 894 }
 895
 896 /**
 897  * kthread_queue_delayed_work - queue the associated kthread work
 898  *      after a delay.
 899  * @worker: target kthread_worker
 900  * @dwork: kthread_delayed_work to queue
 901  * @delay: number of jiffies to wait before queuing
 902  *
 903  * If the work has not been pending it starts a timer that will queue
 904  * the work after the given @delay. If @delay is zero, it queues the
 905  * work immediately.
 906  *
 907  * Return: %false if the @work has already been pending. It means that
 908  * either the timer was running or the work was queued. It returns %true
 909  * otherwise.
 910  */
 911 bool kthread_queue_delayed_work(struct kthread_worker *worker,
 912                                 struct kthread_delayed_work *dwork,
 913                                 unsigned long delay)
 914 {
 915         struct kthread_work *work = &dwork->work;
 916         unsigned long flags;
 917         bool ret = false;
 918
 919         raw_spin_lock_irqsave(&worker->lock, flags);
 920
 921         if (!queuing_blocked(worker, work)) {
 922                 __kthread_queue_delayed_work(worker, dwork, delay);
 923                 ret = true;
 924         }
 925
 926         raw_spin_unlock_irqrestore(&worker->lock, flags);
 927         return ret;
 928 }
 929 EXPORT_SYMBOL_GPL(kthread_queue_delayed_work);
 930
 931 struct kthread_flush_work {
 932         struct kthread_work     work;
 933         struct completion       done;
 934 };
 935
 936 static void kthread_flush_work_fn(struct kthread_work *work)
 937 {
 938         struct kthread_flush_work *fwork =
 939                 container_of(work, struct kthread_flush_work, work);
 940         complete(&fwork->done);
 941 }
 942
 943 /**
 944  * kthread_flush_work - flush a kthread_work
 945  * @work: work to flush
 946  *
 947  * If @work is queued or executing, wait for it to finish execution.
 948  */
 949 void kthread_flush_work(struct kthread_work *work)
 950 {
 951         struct kthread_flush_work fwork = {
 952                 KTHREAD_WORK_INIT(fwork.work, kthread_flush_work_fn),
 953                 COMPLETION_INITIALIZER_ONSTACK(fwork.done),
 954         };
 955         struct kthread_worker *worker;
 956         bool noop = false;
 957
 958         worker = work->worker;
 959         if (!worker)
 960                 return;
 961
 962         raw_spin_lock_irq(&worker->lock);
 963         /* Work must not be used with >1 worker, see kthread_queue_work(). */
 964         WARN_ON_ONCE(work->worker != worker);
 965
 966         if (!list_empty(&work->node))
 967                 kthread_insert_work(worker, &fwork.work, work->node.next);
 968         else if (worker->current_work == work)
 969                 kthread_insert_work(worker, &fwork.work,
 970                                     worker->work_list.next);
 971         else
 972                 noop = true;
 973
 974         raw_spin_unlock_irq(&worker->lock);
 975
 976         if (!noop)
 977                 wait_for_completion(&fwork.done);
 978 }
 979 EXPORT_SYMBOL_GPL(kthread_flush_work);
 980
 981 /*
 982  * This function removes the work from the worker queue. Also it makes sure
 983  * that it won't get queued later via the delayed work's timer.
 984  *
 985  * The work might still be in use when this function finishes. See the
 986  * current_work proceed by the worker.
 987  *
 988  * Return: %true if @work was pending and successfully canceled,
 989  *      %false if @work was not pending
 990  */
 991 static bool __kthread_cancel_work(struct kthread_work *work, bool is_dwork,
 992                                   unsigned long *flags)
 993 {
 994         /* Try to cancel the timer if exists. */
 995         if (is_dwork) {
 996                 struct kthread_delayed_work *dwork =
 997                         container_of(work, struct kthread_delayed_work, work);
 998                 struct kthread_worker *worker = work->worker;
 999
1000                 /*
1001                  * del_timer_sync() must be called to make sure that the timer
1002                  * callback is not running. The lock must be temporary released
1003                  * to avoid a deadlock with the callback. In the meantime,
1004                  * any queuing is blocked by setting the canceling counter.
1005                  */
1006                 work->canceling++;
1007                 raw_spin_unlock_irqrestore(&worker->lock, *flags);
1008                 del_timer_sync(&dwork->timer);
1009                 raw_spin_lock_irqsave(&worker->lock, *flags);
1010                 work->canceling--;
1011         }
1012
1013         /*
1014          * Try to remove the work from a worker list. It might either
1015          * be from worker->work_list or from worker->delayed_work_list.
1016          */
1017         if (!list_empty(&work->node)) {
1018                 list_del_init(&work->node);
1019                 return true;
1020         }
1021
1022         return false;
1023 }
1024
1025 /**
1026  * kthread_mod_delayed_work - modify delay of or queue a kthread delayed work
1027  * @worker: kthread worker to use
1028  * @dwork: kthread delayed work to queue
1029  * @delay: number of jiffies to wait before queuing
1030  *
1031  * If @dwork is idle, equivalent to kthread_queue_delayed_work(). Otherwise,
1032  * modify @dwork's timer so that it expires after @delay. If @delay is zero,
1033  * @work is guaranteed to be queued immediately.
1034  *
1035  * Return: %true if @dwork was pending and its timer was modified,
1036  * %false otherwise.
1037  *
1038  * A special case is when the work is being canceled in parallel.
1039  * It might be caused either by the real kthread_cancel_delayed_work_sync()
1040  * or yet another kthread_mod_delayed_work() call. We let the other command
1041  * win and return %false here. The caller is supposed to synchronize these
1042  * operations a reasonable way.
1043  *
1044  * This function is safe to call from any context including IRQ handler.
1045  * See __kthread_cancel_work() and kthread_delayed_work_timer_fn()
1046  * for details.
1047  */
1048 bool kthread_mod_delayed_work(struct kthread_worker *worker,
1049                               struct kthread_delayed_work *dwork,
1050                               unsigned long delay)
1051 {
1052         struct kthread_work *work = &dwork->work;
1053         unsigned long flags;
1054         int ret = false;
1055
1056         raw_spin_lock_irqsave(&worker->lock, flags);
1057
1058         /* Do not bother with canceling when never queued. */
1059         if (!work->worker)
1060                 goto fast_queue;
1061
1062         /* Work must not be used with >1 worker, see kthread_queue_work() */
1063         WARN_ON_ONCE(work->worker != worker);
1064
1065         /* Do not fight with another command that is canceling this work. */
1066         if (work->canceling)
1067                 goto out;
1068
1069         ret = __kthread_cancel_work(work, true, &flags);
1070 fast_queue:
1071         __kthread_queue_delayed_work(worker, dwork, delay);
1072 out:
1073         raw_spin_unlock_irqrestore(&worker->lock, flags);
1074         return ret;
1075 }
1076 EXPORT_SYMBOL_GPL(kthread_mod_delayed_work);
1077
1078 static bool __kthread_cancel_work_sync(struct kthread_work *work, bool is_dwork)
1079 {
1080         struct kthread_worker *worker = work->worker;
1081         unsigned long flags;
1082         int ret = false;
1083
1084         if (!worker)
1085                 goto out;
1086
1087         raw_spin_lock_irqsave(&worker->lock, flags);
1088         /* Work must not be used with >1 worker, see kthread_queue_work(). */
1089         WARN_ON_ONCE(work->worker != worker);
1090
1091         ret = __kthread_cancel_work(work, is_dwork, &flags);
1092
1093         if (worker->current_work != work)
1094                 goto out_fast;
1095
1096         /*
1097          * The work is in progress and we need to wait with the lock released.
1098          * In the meantime, block any queuing by setting the canceling counter.
1099          */
1100         work->canceling++;
1101         raw_spin_unlock_irqrestore(&worker->lock, flags);
1102         kthread_flush_work(work);
1103         raw_spin_lock_irqsave(&worker->lock, flags);
1104         work->canceling--;
1105
1106 out_fast:
1107         raw_spin_unlock_irqrestore(&worker->lock, flags);
1108 out:
1109         return ret;
1110 }
1111
1112 /**
1113  * kthread_cancel_work_sync - cancel a kthread work and wait for it to finish
1114  * @work: the kthread work to cancel
1115  *
1116  * Cancel @work and wait for its execution to finish.  This function
1117  * can be used even if the work re-queues itself. On return from this
1118  * function, @work is guaranteed to be not pending or executing on any CPU.
1119  *
1120  * kthread_cancel_work_sync(&delayed_work->work) must not be used for
1121  * delayed_work's. Use kthread_cancel_delayed_work_sync() instead.
1122  *
1123  * The caller must ensure that the worker on which @work was last
1124  * queued can't be destroyed before this function returns.
1125  *
1126  * Return: %true if @work was pending, %false otherwise.
1127  */
1128 bool kthread_cancel_work_sync(struct kthread_work *work)
1129 {
1130         return __kthread_cancel_work_sync(work, false);
1131 }
1132 EXPORT_SYMBOL_GPL(kthread_cancel_work_sync);
1133
1134 /**
1135  * kthread_cancel_delayed_work_sync - cancel a kthread delayed work and
1136  *      wait for it to finish.
1137  * @dwork: the kthread delayed work to cancel
1138  *
1139  * This is kthread_cancel_work_sync() for delayed works.
1140  *
1141  * Return: %true if @dwork was pending, %false otherwise.
1142  */
1143 bool kthread_cancel_delayed_work_sync(struct kthread_delayed_work *dwork)
1144 {
1145         return __kthread_cancel_work_sync(&dwork->work, true);
1146 }
1147 EXPORT_SYMBOL_GPL(kthread_cancel_delayed_work_sync);
1148
1149 /**
1150  * kthread_flush_worker - flush all current works on a kthread_worker
1151  * @worker: worker to flush
1152  *
1153  * Wait until all currently executing or pending works on @worker are
1154  * finished.
1155  */
1156 void kthread_flush_worker(struct kthread_worker *worker)
1157 {
1158         struct kthread_flush_work fwork = {
1159                 KTHREAD_WORK_INIT(fwork.work, kthread_flush_work_fn),
1160                 COMPLETION_INITIALIZER_ONSTACK(fwork.done),
1161         };
1162
1163         kthread_queue_work(worker, &fwork.work);
1164         wait_for_completion(&fwork.done);
1165 }
1166 EXPORT_SYMBOL_GPL(kthread_flush_worker);
1167
1168 /**
1169  * kthread_destroy_worker - destroy a kthread worker
1170  * @worker: worker to be destroyed
1171  *
1172  * Flush and destroy @worker.  The simple flush is enough because the kthread
1173  * worker API is used only in trivial scenarios.  There are no multi-step state
1174  * machines needed.
1175  */
1176 void kthread_destroy_worker(struct kthread_worker *worker)
1177 {
1178         struct task_struct *task;
1179
1180         task = worker->task;
1181         if (WARN_ON(!task))
1182                 return;
1183
1184         kthread_flush_worker(worker);
1185         kthread_stop(task);
1186         WARN_ON(!list_empty(&worker->work_list));
1187         kfree(worker);
1188 }
1189 EXPORT_SYMBOL(kthread_destroy_worker);
1190
1191 #ifdef CONFIG_BLK_CGROUP
1192 /**
1193  * kthread_associate_blkcg - associate blkcg to current kthread
1194  * @css: the cgroup info
1195  *
1196  * Current thread must be a kthread. The thread is running jobs on behalf of
1197  * other threads. In some cases, we expect the jobs attach cgroup info of
1198  * original threads instead of that of current thread. This function stores
1199  * original thread's cgroup info in current kthread context for later
1200  * retrieval.
1201  */
1202 void kthread_associate_blkcg(struct cgroup_subsys_state *css)
1203 {
1204         struct kthread *kthread;
1205
1206         if (!(current->flags & PF_KTHREAD))
1207                 return;
1208         kthread = to_kthread(current);
1209         if (!kthread)
1210                 return;
1211
1212         if (kthread->blkcg_css) {
1213                 css_put(kthread->blkcg_css);
1214                 kthread->blkcg_css = NULL;
1215         }
1216         if (css) {
1217                 css_get(css);
1218                 kthread->blkcg_css = css;
1219         }
1220 }
1221 EXPORT_SYMBOL(kthread_associate_blkcg);
1222
1223 /**
1224  * kthread_blkcg - get associated blkcg css of current kthread
1225  *
1226  * Current thread must be a kthread.
1227  */
1228 struct cgroup_subsys_state *kthread_blkcg(void)
1229 {
1230         struct kthread *kthread;
1231
1232         if (current->flags & PF_KTHREAD) {
1233                 kthread = to_kthread(current);
1234                 if (kthread)
1235                         return kthread->blkcg_css;
1236         }
1237         return NULL;
1238 }
1239 EXPORT_SYMBOL(kthread_blkcg);
1240 #endif