Loading...
1/*
2 * Copyright (C) 2007 Oracle. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
17 */
18
19#include <linux/kthread.h>
20#include <linux/slab.h>
21#include <linux/list.h>
22#include <linux/spinlock.h>
23#include <linux/freezer.h>
24#include "async-thread.h"
25
26#define WORK_QUEUED_BIT 0
27#define WORK_DONE_BIT 1
28#define WORK_ORDER_DONE_BIT 2
29#define WORK_HIGH_PRIO_BIT 3
30
31/*
32 * container for the kthread task pointer and the list of pending work
33 * One of these is allocated per thread.
34 */
35struct btrfs_worker_thread {
36 /* pool we belong to */
37 struct btrfs_workers *workers;
38
39 /* list of struct btrfs_work that are waiting for service */
40 struct list_head pending;
41 struct list_head prio_pending;
42
43 /* list of worker threads from struct btrfs_workers */
44 struct list_head worker_list;
45
46 /* kthread */
47 struct task_struct *task;
48
49 /* number of things on the pending list */
50 atomic_t num_pending;
51
52 /* reference counter for this struct */
53 atomic_t refs;
54
55 unsigned long sequence;
56
57 /* protects the pending list. */
58 spinlock_t lock;
59
60 /* set to non-zero when this thread is already awake and kicking */
61 int working;
62
63 /* are we currently idle */
64 int idle;
65};
66
67/*
68 * btrfs_start_workers uses kthread_run, which can block waiting for memory
69 * for a very long time. It will actually throttle on page writeback,
70 * and so it may not make progress until after our btrfs worker threads
71 * process all of the pending work structs in their queue
72 *
73 * This means we can't use btrfs_start_workers from inside a btrfs worker
74 * thread that is used as part of cleaning dirty memory, which pretty much
75 * involves all of the worker threads.
76 *
77 * Instead we have a helper queue who never has more than one thread
78 * where we scheduler thread start operations. This worker_start struct
79 * is used to contain the work and hold a pointer to the queue that needs
80 * another worker.
81 */
82struct worker_start {
83 struct btrfs_work work;
84 struct btrfs_workers *queue;
85};
86
87static void start_new_worker_func(struct btrfs_work *work)
88{
89 struct worker_start *start;
90 start = container_of(work, struct worker_start, work);
91 btrfs_start_workers(start->queue, 1);
92 kfree(start);
93}
94
95static int start_new_worker(struct btrfs_workers *queue)
96{
97 struct worker_start *start;
98 int ret;
99
100 start = kzalloc(sizeof(*start), GFP_NOFS);
101 if (!start)
102 return -ENOMEM;
103
104 start->work.func = start_new_worker_func;
105 start->queue = queue;
106 ret = btrfs_queue_worker(queue->atomic_worker_start, &start->work);
107 if (ret)
108 kfree(start);
109 return ret;
110}
111
112/*
113 * helper function to move a thread onto the idle list after it
114 * has finished some requests.
115 */
116static void check_idle_worker(struct btrfs_worker_thread *worker)
117{
118 if (!worker->idle && atomic_read(&worker->num_pending) <
119 worker->workers->idle_thresh / 2) {
120 unsigned long flags;
121 spin_lock_irqsave(&worker->workers->lock, flags);
122 worker->idle = 1;
123
124 /* the list may be empty if the worker is just starting */
125 if (!list_empty(&worker->worker_list)) {
126 list_move(&worker->worker_list,
127 &worker->workers->idle_list);
128 }
129 spin_unlock_irqrestore(&worker->workers->lock, flags);
130 }
131}
132
133/*
134 * helper function to move a thread off the idle list after new
135 * pending work is added.
136 */
137static void check_busy_worker(struct btrfs_worker_thread *worker)
138{
139 if (worker->idle && atomic_read(&worker->num_pending) >=
140 worker->workers->idle_thresh) {
141 unsigned long flags;
142 spin_lock_irqsave(&worker->workers->lock, flags);
143 worker->idle = 0;
144
145 if (!list_empty(&worker->worker_list)) {
146 list_move_tail(&worker->worker_list,
147 &worker->workers->worker_list);
148 }
149 spin_unlock_irqrestore(&worker->workers->lock, flags);
150 }
151}
152
153static void check_pending_worker_creates(struct btrfs_worker_thread *worker)
154{
155 struct btrfs_workers *workers = worker->workers;
156 unsigned long flags;
157
158 rmb();
159 if (!workers->atomic_start_pending)
160 return;
161
162 spin_lock_irqsave(&workers->lock, flags);
163 if (!workers->atomic_start_pending)
164 goto out;
165
166 workers->atomic_start_pending = 0;
167 if (workers->num_workers + workers->num_workers_starting >=
168 workers->max_workers)
169 goto out;
170
171 workers->num_workers_starting += 1;
172 spin_unlock_irqrestore(&workers->lock, flags);
173 start_new_worker(workers);
174 return;
175
176out:
177 spin_unlock_irqrestore(&workers->lock, flags);
178}
179
180static noinline int run_ordered_completions(struct btrfs_workers *workers,
181 struct btrfs_work *work)
182{
183 if (!workers->ordered)
184 return 0;
185
186 set_bit(WORK_DONE_BIT, &work->flags);
187
188 spin_lock(&workers->order_lock);
189
190 while (1) {
191 if (!list_empty(&workers->prio_order_list)) {
192 work = list_entry(workers->prio_order_list.next,
193 struct btrfs_work, order_list);
194 } else if (!list_empty(&workers->order_list)) {
195 work = list_entry(workers->order_list.next,
196 struct btrfs_work, order_list);
197 } else {
198 break;
199 }
200 if (!test_bit(WORK_DONE_BIT, &work->flags))
201 break;
202
203 /* we are going to call the ordered done function, but
204 * we leave the work item on the list as a barrier so
205 * that later work items that are done don't have their
206 * functions called before this one returns
207 */
208 if (test_and_set_bit(WORK_ORDER_DONE_BIT, &work->flags))
209 break;
210
211 spin_unlock(&workers->order_lock);
212
213 work->ordered_func(work);
214
215 /* now take the lock again and call the freeing code */
216 spin_lock(&workers->order_lock);
217 list_del(&work->order_list);
218 work->ordered_free(work);
219 }
220
221 spin_unlock(&workers->order_lock);
222 return 0;
223}
224
225static void put_worker(struct btrfs_worker_thread *worker)
226{
227 if (atomic_dec_and_test(&worker->refs))
228 kfree(worker);
229}
230
231static int try_worker_shutdown(struct btrfs_worker_thread *worker)
232{
233 int freeit = 0;
234
235 spin_lock_irq(&worker->lock);
236 spin_lock(&worker->workers->lock);
237 if (worker->workers->num_workers > 1 &&
238 worker->idle &&
239 !worker->working &&
240 !list_empty(&worker->worker_list) &&
241 list_empty(&worker->prio_pending) &&
242 list_empty(&worker->pending) &&
243 atomic_read(&worker->num_pending) == 0) {
244 freeit = 1;
245 list_del_init(&worker->worker_list);
246 worker->workers->num_workers--;
247 }
248 spin_unlock(&worker->workers->lock);
249 spin_unlock_irq(&worker->lock);
250
251 if (freeit)
252 put_worker(worker);
253 return freeit;
254}
255
256static struct btrfs_work *get_next_work(struct btrfs_worker_thread *worker,
257 struct list_head *prio_head,
258 struct list_head *head)
259{
260 struct btrfs_work *work = NULL;
261 struct list_head *cur = NULL;
262
263 if(!list_empty(prio_head))
264 cur = prio_head->next;
265
266 smp_mb();
267 if (!list_empty(&worker->prio_pending))
268 goto refill;
269
270 if (!list_empty(head))
271 cur = head->next;
272
273 if (cur)
274 goto out;
275
276refill:
277 spin_lock_irq(&worker->lock);
278 list_splice_tail_init(&worker->prio_pending, prio_head);
279 list_splice_tail_init(&worker->pending, head);
280
281 if (!list_empty(prio_head))
282 cur = prio_head->next;
283 else if (!list_empty(head))
284 cur = head->next;
285 spin_unlock_irq(&worker->lock);
286
287 if (!cur)
288 goto out_fail;
289
290out:
291 work = list_entry(cur, struct btrfs_work, list);
292
293out_fail:
294 return work;
295}
296
297/*
298 * main loop for servicing work items
299 */
300static int worker_loop(void *arg)
301{
302 struct btrfs_worker_thread *worker = arg;
303 struct list_head head;
304 struct list_head prio_head;
305 struct btrfs_work *work;
306
307 INIT_LIST_HEAD(&head);
308 INIT_LIST_HEAD(&prio_head);
309
310 do {
311again:
312 while (1) {
313
314
315 work = get_next_work(worker, &prio_head, &head);
316 if (!work)
317 break;
318
319 list_del(&work->list);
320 clear_bit(WORK_QUEUED_BIT, &work->flags);
321
322 work->worker = worker;
323
324 work->func(work);
325
326 atomic_dec(&worker->num_pending);
327 /*
328 * unless this is an ordered work queue,
329 * 'work' was probably freed by func above.
330 */
331 run_ordered_completions(worker->workers, work);
332
333 check_pending_worker_creates(worker);
334
335 }
336
337 spin_lock_irq(&worker->lock);
338 check_idle_worker(worker);
339
340 if (freezing(current)) {
341 worker->working = 0;
342 spin_unlock_irq(&worker->lock);
343 refrigerator();
344 } else {
345 spin_unlock_irq(&worker->lock);
346 if (!kthread_should_stop()) {
347 cpu_relax();
348 /*
349 * we've dropped the lock, did someone else
350 * jump_in?
351 */
352 smp_mb();
353 if (!list_empty(&worker->pending) ||
354 !list_empty(&worker->prio_pending))
355 continue;
356
357 /*
358 * this short schedule allows more work to
359 * come in without the queue functions
360 * needing to go through wake_up_process()
361 *
362 * worker->working is still 1, so nobody
363 * is going to try and wake us up
364 */
365 schedule_timeout(1);
366 smp_mb();
367 if (!list_empty(&worker->pending) ||
368 !list_empty(&worker->prio_pending))
369 continue;
370
371 if (kthread_should_stop())
372 break;
373
374 /* still no more work?, sleep for real */
375 spin_lock_irq(&worker->lock);
376 set_current_state(TASK_INTERRUPTIBLE);
377 if (!list_empty(&worker->pending) ||
378 !list_empty(&worker->prio_pending)) {
379 spin_unlock_irq(&worker->lock);
380 set_current_state(TASK_RUNNING);
381 goto again;
382 }
383
384 /*
385 * this makes sure we get a wakeup when someone
386 * adds something new to the queue
387 */
388 worker->working = 0;
389 spin_unlock_irq(&worker->lock);
390
391 if (!kthread_should_stop()) {
392 schedule_timeout(HZ * 120);
393 if (!worker->working &&
394 try_worker_shutdown(worker)) {
395 return 0;
396 }
397 }
398 }
399 __set_current_state(TASK_RUNNING);
400 }
401 } while (!kthread_should_stop());
402 return 0;
403}
404
405/*
406 * this will wait for all the worker threads to shutdown
407 */
408int btrfs_stop_workers(struct btrfs_workers *workers)
409{
410 struct list_head *cur;
411 struct btrfs_worker_thread *worker;
412 int can_stop;
413
414 spin_lock_irq(&workers->lock);
415 list_splice_init(&workers->idle_list, &workers->worker_list);
416 while (!list_empty(&workers->worker_list)) {
417 cur = workers->worker_list.next;
418 worker = list_entry(cur, struct btrfs_worker_thread,
419 worker_list);
420
421 atomic_inc(&worker->refs);
422 workers->num_workers -= 1;
423 if (!list_empty(&worker->worker_list)) {
424 list_del_init(&worker->worker_list);
425 put_worker(worker);
426 can_stop = 1;
427 } else
428 can_stop = 0;
429 spin_unlock_irq(&workers->lock);
430 if (can_stop)
431 kthread_stop(worker->task);
432 spin_lock_irq(&workers->lock);
433 put_worker(worker);
434 }
435 spin_unlock_irq(&workers->lock);
436 return 0;
437}
438
439/*
440 * simple init on struct btrfs_workers
441 */
442void btrfs_init_workers(struct btrfs_workers *workers, char *name, int max,
443 struct btrfs_workers *async_helper)
444{
445 workers->num_workers = 0;
446 workers->num_workers_starting = 0;
447 INIT_LIST_HEAD(&workers->worker_list);
448 INIT_LIST_HEAD(&workers->idle_list);
449 INIT_LIST_HEAD(&workers->order_list);
450 INIT_LIST_HEAD(&workers->prio_order_list);
451 spin_lock_init(&workers->lock);
452 spin_lock_init(&workers->order_lock);
453 workers->max_workers = max;
454 workers->idle_thresh = 32;
455 workers->name = name;
456 workers->ordered = 0;
457 workers->atomic_start_pending = 0;
458 workers->atomic_worker_start = async_helper;
459}
460
461/*
462 * starts new worker threads. This does not enforce the max worker
463 * count in case you need to temporarily go past it.
464 */
465static int __btrfs_start_workers(struct btrfs_workers *workers,
466 int num_workers)
467{
468 struct btrfs_worker_thread *worker;
469 int ret = 0;
470 int i;
471
472 for (i = 0; i < num_workers; i++) {
473 worker = kzalloc(sizeof(*worker), GFP_NOFS);
474 if (!worker) {
475 ret = -ENOMEM;
476 goto fail;
477 }
478
479 INIT_LIST_HEAD(&worker->pending);
480 INIT_LIST_HEAD(&worker->prio_pending);
481 INIT_LIST_HEAD(&worker->worker_list);
482 spin_lock_init(&worker->lock);
483
484 atomic_set(&worker->num_pending, 0);
485 atomic_set(&worker->refs, 1);
486 worker->workers = workers;
487 worker->task = kthread_run(worker_loop, worker,
488 "btrfs-%s-%d", workers->name,
489 workers->num_workers + i);
490 if (IS_ERR(worker->task)) {
491 ret = PTR_ERR(worker->task);
492 kfree(worker);
493 goto fail;
494 }
495 spin_lock_irq(&workers->lock);
496 list_add_tail(&worker->worker_list, &workers->idle_list);
497 worker->idle = 1;
498 workers->num_workers++;
499 workers->num_workers_starting--;
500 WARN_ON(workers->num_workers_starting < 0);
501 spin_unlock_irq(&workers->lock);
502 }
503 return 0;
504fail:
505 btrfs_stop_workers(workers);
506 return ret;
507}
508
509int btrfs_start_workers(struct btrfs_workers *workers, int num_workers)
510{
511 spin_lock_irq(&workers->lock);
512 workers->num_workers_starting += num_workers;
513 spin_unlock_irq(&workers->lock);
514 return __btrfs_start_workers(workers, num_workers);
515}
516
517/*
518 * run through the list and find a worker thread that doesn't have a lot
519 * to do right now. This can return null if we aren't yet at the thread
520 * count limit and all of the threads are busy.
521 */
522static struct btrfs_worker_thread *next_worker(struct btrfs_workers *workers)
523{
524 struct btrfs_worker_thread *worker;
525 struct list_head *next;
526 int enforce_min;
527
528 enforce_min = (workers->num_workers + workers->num_workers_starting) <
529 workers->max_workers;
530
531 /*
532 * if we find an idle thread, don't move it to the end of the
533 * idle list. This improves the chance that the next submission
534 * will reuse the same thread, and maybe catch it while it is still
535 * working
536 */
537 if (!list_empty(&workers->idle_list)) {
538 next = workers->idle_list.next;
539 worker = list_entry(next, struct btrfs_worker_thread,
540 worker_list);
541 return worker;
542 }
543 if (enforce_min || list_empty(&workers->worker_list))
544 return NULL;
545
546 /*
547 * if we pick a busy task, move the task to the end of the list.
548 * hopefully this will keep things somewhat evenly balanced.
549 * Do the move in batches based on the sequence number. This groups
550 * requests submitted at roughly the same time onto the same worker.
551 */
552 next = workers->worker_list.next;
553 worker = list_entry(next, struct btrfs_worker_thread, worker_list);
554 worker->sequence++;
555
556 if (worker->sequence % workers->idle_thresh == 0)
557 list_move_tail(next, &workers->worker_list);
558 return worker;
559}
560
561/*
562 * selects a worker thread to take the next job. This will either find
563 * an idle worker, start a new worker up to the max count, or just return
564 * one of the existing busy workers.
565 */
566static struct btrfs_worker_thread *find_worker(struct btrfs_workers *workers)
567{
568 struct btrfs_worker_thread *worker;
569 unsigned long flags;
570 struct list_head *fallback;
571
572again:
573 spin_lock_irqsave(&workers->lock, flags);
574 worker = next_worker(workers);
575
576 if (!worker) {
577 if (workers->num_workers + workers->num_workers_starting >=
578 workers->max_workers) {
579 goto fallback;
580 } else if (workers->atomic_worker_start) {
581 workers->atomic_start_pending = 1;
582 goto fallback;
583 } else {
584 workers->num_workers_starting++;
585 spin_unlock_irqrestore(&workers->lock, flags);
586 /* we're below the limit, start another worker */
587 __btrfs_start_workers(workers, 1);
588 goto again;
589 }
590 }
591 goto found;
592
593fallback:
594 fallback = NULL;
595 /*
596 * we have failed to find any workers, just
597 * return the first one we can find.
598 */
599 if (!list_empty(&workers->worker_list))
600 fallback = workers->worker_list.next;
601 if (!list_empty(&workers->idle_list))
602 fallback = workers->idle_list.next;
603 BUG_ON(!fallback);
604 worker = list_entry(fallback,
605 struct btrfs_worker_thread, worker_list);
606found:
607 /*
608 * this makes sure the worker doesn't exit before it is placed
609 * onto a busy/idle list
610 */
611 atomic_inc(&worker->num_pending);
612 spin_unlock_irqrestore(&workers->lock, flags);
613 return worker;
614}
615
616/*
617 * btrfs_requeue_work just puts the work item back on the tail of the list
618 * it was taken from. It is intended for use with long running work functions
619 * that make some progress and want to give the cpu up for others.
620 */
621int btrfs_requeue_work(struct btrfs_work *work)
622{
623 struct btrfs_worker_thread *worker = work->worker;
624 unsigned long flags;
625 int wake = 0;
626
627 if (test_and_set_bit(WORK_QUEUED_BIT, &work->flags))
628 goto out;
629
630 spin_lock_irqsave(&worker->lock, flags);
631 if (test_bit(WORK_HIGH_PRIO_BIT, &work->flags))
632 list_add_tail(&work->list, &worker->prio_pending);
633 else
634 list_add_tail(&work->list, &worker->pending);
635 atomic_inc(&worker->num_pending);
636
637 /* by definition we're busy, take ourselves off the idle
638 * list
639 */
640 if (worker->idle) {
641 spin_lock(&worker->workers->lock);
642 worker->idle = 0;
643 list_move_tail(&worker->worker_list,
644 &worker->workers->worker_list);
645 spin_unlock(&worker->workers->lock);
646 }
647 if (!worker->working) {
648 wake = 1;
649 worker->working = 1;
650 }
651
652 if (wake)
653 wake_up_process(worker->task);
654 spin_unlock_irqrestore(&worker->lock, flags);
655out:
656
657 return 0;
658}
659
660void btrfs_set_work_high_prio(struct btrfs_work *work)
661{
662 set_bit(WORK_HIGH_PRIO_BIT, &work->flags);
663}
664
665/*
666 * places a struct btrfs_work into the pending queue of one of the kthreads
667 */
668int btrfs_queue_worker(struct btrfs_workers *workers, struct btrfs_work *work)
669{
670 struct btrfs_worker_thread *worker;
671 unsigned long flags;
672 int wake = 0;
673
674 /* don't requeue something already on a list */
675 if (test_and_set_bit(WORK_QUEUED_BIT, &work->flags))
676 goto out;
677
678 worker = find_worker(workers);
679 if (workers->ordered) {
680 /*
681 * you're not allowed to do ordered queues from an
682 * interrupt handler
683 */
684 spin_lock(&workers->order_lock);
685 if (test_bit(WORK_HIGH_PRIO_BIT, &work->flags)) {
686 list_add_tail(&work->order_list,
687 &workers->prio_order_list);
688 } else {
689 list_add_tail(&work->order_list, &workers->order_list);
690 }
691 spin_unlock(&workers->order_lock);
692 } else {
693 INIT_LIST_HEAD(&work->order_list);
694 }
695
696 spin_lock_irqsave(&worker->lock, flags);
697
698 if (test_bit(WORK_HIGH_PRIO_BIT, &work->flags))
699 list_add_tail(&work->list, &worker->prio_pending);
700 else
701 list_add_tail(&work->list, &worker->pending);
702 check_busy_worker(worker);
703
704 /*
705 * avoid calling into wake_up_process if this thread has already
706 * been kicked
707 */
708 if (!worker->working)
709 wake = 1;
710 worker->working = 1;
711
712 if (wake)
713 wake_up_process(worker->task);
714 spin_unlock_irqrestore(&worker->lock, flags);
715
716out:
717 return 0;
718}
1/*
2 * Copyright (C) 2007 Oracle. All rights reserved.
3 * Copyright (C) 2014 Fujitsu. All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public
7 * License v2 as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public
15 * License along with this program; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 021110-1307, USA.
18 */
19
20#include <linux/kthread.h>
21#include <linux/slab.h>
22#include <linux/list.h>
23#include <linux/spinlock.h>
24#include <linux/freezer.h>
25#include "async-thread.h"
26#include "ctree.h"
27
28#define WORK_DONE_BIT 0
29#define WORK_ORDER_DONE_BIT 1
30#define WORK_HIGH_PRIO_BIT 2
31
32#define NO_THRESHOLD (-1)
33#define DFT_THRESHOLD (32)
34
35struct __btrfs_workqueue {
36 struct workqueue_struct *normal_wq;
37
38 /* File system this workqueue services */
39 struct btrfs_fs_info *fs_info;
40
41 /* List head pointing to ordered work list */
42 struct list_head ordered_list;
43
44 /* Spinlock for ordered_list */
45 spinlock_t list_lock;
46
47 /* Thresholding related variants */
48 atomic_t pending;
49
50 /* Up limit of concurrency workers */
51 int limit_active;
52
53 /* Current number of concurrency workers */
54 int current_active;
55
56 /* Threshold to change current_active */
57 int thresh;
58 unsigned int count;
59 spinlock_t thres_lock;
60};
61
62struct btrfs_workqueue {
63 struct __btrfs_workqueue *normal;
64 struct __btrfs_workqueue *high;
65};
66
67static void normal_work_helper(struct btrfs_work *work);
68
69#define BTRFS_WORK_HELPER(name) \
70void btrfs_##name(struct work_struct *arg) \
71{ \
72 struct btrfs_work *work = container_of(arg, struct btrfs_work, \
73 normal_work); \
74 normal_work_helper(work); \
75}
76
77struct btrfs_fs_info *
78btrfs_workqueue_owner(struct __btrfs_workqueue *wq)
79{
80 return wq->fs_info;
81}
82
83struct btrfs_fs_info *
84btrfs_work_owner(struct btrfs_work *work)
85{
86 return work->wq->fs_info;
87}
88
89bool btrfs_workqueue_normal_congested(struct btrfs_workqueue *wq)
90{
91 /*
92 * We could compare wq->normal->pending with num_online_cpus()
93 * to support "thresh == NO_THRESHOLD" case, but it requires
94 * moving up atomic_inc/dec in thresh_queue/exec_hook. Let's
95 * postpone it until someone needs the support of that case.
96 */
97 if (wq->normal->thresh == NO_THRESHOLD)
98 return false;
99
100 return atomic_read(&wq->normal->pending) > wq->normal->thresh * 2;
101}
102
103BTRFS_WORK_HELPER(worker_helper);
104BTRFS_WORK_HELPER(delalloc_helper);
105BTRFS_WORK_HELPER(flush_delalloc_helper);
106BTRFS_WORK_HELPER(cache_helper);
107BTRFS_WORK_HELPER(submit_helper);
108BTRFS_WORK_HELPER(fixup_helper);
109BTRFS_WORK_HELPER(endio_helper);
110BTRFS_WORK_HELPER(endio_meta_helper);
111BTRFS_WORK_HELPER(endio_meta_write_helper);
112BTRFS_WORK_HELPER(endio_raid56_helper);
113BTRFS_WORK_HELPER(endio_repair_helper);
114BTRFS_WORK_HELPER(rmw_helper);
115BTRFS_WORK_HELPER(endio_write_helper);
116BTRFS_WORK_HELPER(freespace_write_helper);
117BTRFS_WORK_HELPER(delayed_meta_helper);
118BTRFS_WORK_HELPER(readahead_helper);
119BTRFS_WORK_HELPER(qgroup_rescan_helper);
120BTRFS_WORK_HELPER(extent_refs_helper);
121BTRFS_WORK_HELPER(scrub_helper);
122BTRFS_WORK_HELPER(scrubwrc_helper);
123BTRFS_WORK_HELPER(scrubnc_helper);
124BTRFS_WORK_HELPER(scrubparity_helper);
125
126static struct __btrfs_workqueue *
127__btrfs_alloc_workqueue(struct btrfs_fs_info *fs_info, const char *name,
128 unsigned int flags, int limit_active, int thresh)
129{
130 struct __btrfs_workqueue *ret = kzalloc(sizeof(*ret), GFP_KERNEL);
131
132 if (!ret)
133 return NULL;
134
135 ret->fs_info = fs_info;
136 ret->limit_active = limit_active;
137 atomic_set(&ret->pending, 0);
138 if (thresh == 0)
139 thresh = DFT_THRESHOLD;
140 /* For low threshold, disabling threshold is a better choice */
141 if (thresh < DFT_THRESHOLD) {
142 ret->current_active = limit_active;
143 ret->thresh = NO_THRESHOLD;
144 } else {
145 /*
146 * For threshold-able wq, let its concurrency grow on demand.
147 * Use minimal max_active at alloc time to reduce resource
148 * usage.
149 */
150 ret->current_active = 1;
151 ret->thresh = thresh;
152 }
153
154 if (flags & WQ_HIGHPRI)
155 ret->normal_wq = alloc_workqueue("%s-%s-high", flags,
156 ret->current_active, "btrfs",
157 name);
158 else
159 ret->normal_wq = alloc_workqueue("%s-%s", flags,
160 ret->current_active, "btrfs",
161 name);
162 if (!ret->normal_wq) {
163 kfree(ret);
164 return NULL;
165 }
166
167 INIT_LIST_HEAD(&ret->ordered_list);
168 spin_lock_init(&ret->list_lock);
169 spin_lock_init(&ret->thres_lock);
170 trace_btrfs_workqueue_alloc(ret, name, flags & WQ_HIGHPRI);
171 return ret;
172}
173
174static inline void
175__btrfs_destroy_workqueue(struct __btrfs_workqueue *wq);
176
177struct btrfs_workqueue *btrfs_alloc_workqueue(struct btrfs_fs_info *fs_info,
178 const char *name,
179 unsigned int flags,
180 int limit_active,
181 int thresh)
182{
183 struct btrfs_workqueue *ret = kzalloc(sizeof(*ret), GFP_KERNEL);
184
185 if (!ret)
186 return NULL;
187
188 ret->normal = __btrfs_alloc_workqueue(fs_info, name,
189 flags & ~WQ_HIGHPRI,
190 limit_active, thresh);
191 if (!ret->normal) {
192 kfree(ret);
193 return NULL;
194 }
195
196 if (flags & WQ_HIGHPRI) {
197 ret->high = __btrfs_alloc_workqueue(fs_info, name, flags,
198 limit_active, thresh);
199 if (!ret->high) {
200 __btrfs_destroy_workqueue(ret->normal);
201 kfree(ret);
202 return NULL;
203 }
204 }
205 return ret;
206}
207
208/*
209 * Hook for threshold which will be called in btrfs_queue_work.
210 * This hook WILL be called in IRQ handler context,
211 * so workqueue_set_max_active MUST NOT be called in this hook
212 */
213static inline void thresh_queue_hook(struct __btrfs_workqueue *wq)
214{
215 if (wq->thresh == NO_THRESHOLD)
216 return;
217 atomic_inc(&wq->pending);
218}
219
220/*
221 * Hook for threshold which will be called before executing the work,
222 * This hook is called in kthread content.
223 * So workqueue_set_max_active is called here.
224 */
225static inline void thresh_exec_hook(struct __btrfs_workqueue *wq)
226{
227 int new_current_active;
228 long pending;
229 int need_change = 0;
230
231 if (wq->thresh == NO_THRESHOLD)
232 return;
233
234 atomic_dec(&wq->pending);
235 spin_lock(&wq->thres_lock);
236 /*
237 * Use wq->count to limit the calling frequency of
238 * workqueue_set_max_active.
239 */
240 wq->count++;
241 wq->count %= (wq->thresh / 4);
242 if (!wq->count)
243 goto out;
244 new_current_active = wq->current_active;
245
246 /*
247 * pending may be changed later, but it's OK since we really
248 * don't need it so accurate to calculate new_max_active.
249 */
250 pending = atomic_read(&wq->pending);
251 if (pending > wq->thresh)
252 new_current_active++;
253 if (pending < wq->thresh / 2)
254 new_current_active--;
255 new_current_active = clamp_val(new_current_active, 1, wq->limit_active);
256 if (new_current_active != wq->current_active) {
257 need_change = 1;
258 wq->current_active = new_current_active;
259 }
260out:
261 spin_unlock(&wq->thres_lock);
262
263 if (need_change) {
264 workqueue_set_max_active(wq->normal_wq, wq->current_active);
265 }
266}
267
268static void run_ordered_work(struct __btrfs_workqueue *wq)
269{
270 struct list_head *list = &wq->ordered_list;
271 struct btrfs_work *work;
272 spinlock_t *lock = &wq->list_lock;
273 unsigned long flags;
274
275 while (1) {
276 void *wtag;
277
278 spin_lock_irqsave(lock, flags);
279 if (list_empty(list))
280 break;
281 work = list_entry(list->next, struct btrfs_work,
282 ordered_list);
283 if (!test_bit(WORK_DONE_BIT, &work->flags))
284 break;
285
286 /*
287 * we are going to call the ordered done function, but
288 * we leave the work item on the list as a barrier so
289 * that later work items that are done don't have their
290 * functions called before this one returns
291 */
292 if (test_and_set_bit(WORK_ORDER_DONE_BIT, &work->flags))
293 break;
294 trace_btrfs_ordered_sched(work);
295 spin_unlock_irqrestore(lock, flags);
296 work->ordered_func(work);
297
298 /* now take the lock again and drop our item from the list */
299 spin_lock_irqsave(lock, flags);
300 list_del(&work->ordered_list);
301 spin_unlock_irqrestore(lock, flags);
302
303 /*
304 * We don't want to call the ordered free functions with the
305 * lock held though. Save the work as tag for the trace event,
306 * because the callback could free the structure.
307 */
308 wtag = work;
309 work->ordered_free(work);
310 trace_btrfs_all_work_done(wq->fs_info, wtag);
311 }
312 spin_unlock_irqrestore(lock, flags);
313}
314
315static void normal_work_helper(struct btrfs_work *work)
316{
317 struct __btrfs_workqueue *wq;
318 void *wtag;
319 int need_order = 0;
320
321 /*
322 * We should not touch things inside work in the following cases:
323 * 1) after work->func() if it has no ordered_free
324 * Since the struct is freed in work->func().
325 * 2) after setting WORK_DONE_BIT
326 * The work may be freed in other threads almost instantly.
327 * So we save the needed things here.
328 */
329 if (work->ordered_func)
330 need_order = 1;
331 wq = work->wq;
332 /* Safe for tracepoints in case work gets freed by the callback */
333 wtag = work;
334
335 trace_btrfs_work_sched(work);
336 thresh_exec_hook(wq);
337 work->func(work);
338 if (need_order) {
339 set_bit(WORK_DONE_BIT, &work->flags);
340 run_ordered_work(wq);
341 }
342 if (!need_order)
343 trace_btrfs_all_work_done(wq->fs_info, wtag);
344}
345
346void btrfs_init_work(struct btrfs_work *work, btrfs_work_func_t uniq_func,
347 btrfs_func_t func,
348 btrfs_func_t ordered_func,
349 btrfs_func_t ordered_free)
350{
351 work->func = func;
352 work->ordered_func = ordered_func;
353 work->ordered_free = ordered_free;
354 INIT_WORK(&work->normal_work, uniq_func);
355 INIT_LIST_HEAD(&work->ordered_list);
356 work->flags = 0;
357}
358
359static inline void __btrfs_queue_work(struct __btrfs_workqueue *wq,
360 struct btrfs_work *work)
361{
362 unsigned long flags;
363
364 work->wq = wq;
365 thresh_queue_hook(wq);
366 if (work->ordered_func) {
367 spin_lock_irqsave(&wq->list_lock, flags);
368 list_add_tail(&work->ordered_list, &wq->ordered_list);
369 spin_unlock_irqrestore(&wq->list_lock, flags);
370 }
371 trace_btrfs_work_queued(work);
372 queue_work(wq->normal_wq, &work->normal_work);
373}
374
375void btrfs_queue_work(struct btrfs_workqueue *wq,
376 struct btrfs_work *work)
377{
378 struct __btrfs_workqueue *dest_wq;
379
380 if (test_bit(WORK_HIGH_PRIO_BIT, &work->flags) && wq->high)
381 dest_wq = wq->high;
382 else
383 dest_wq = wq->normal;
384 __btrfs_queue_work(dest_wq, work);
385}
386
387static inline void
388__btrfs_destroy_workqueue(struct __btrfs_workqueue *wq)
389{
390 destroy_workqueue(wq->normal_wq);
391 trace_btrfs_workqueue_destroy(wq);
392 kfree(wq);
393}
394
395void btrfs_destroy_workqueue(struct btrfs_workqueue *wq)
396{
397 if (!wq)
398 return;
399 if (wq->high)
400 __btrfs_destroy_workqueue(wq->high);
401 __btrfs_destroy_workqueue(wq->normal);
402 kfree(wq);
403}
404
405void btrfs_workqueue_set_max(struct btrfs_workqueue *wq, int limit_active)
406{
407 if (!wq)
408 return;
409 wq->normal->limit_active = limit_active;
410 if (wq->high)
411 wq->high->limit_active = limit_active;
412}
413
414void btrfs_set_work_high_priority(struct btrfs_work *work)
415{
416 set_bit(WORK_HIGH_PRIO_BIT, &work->flags);
417}