Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * JFFS2 -- Journalling Flash File System, Version 2. | |
3 | * | |
c00c310e | 4 | * Copyright © 2001-2007 Red Hat, Inc. |
1da177e4 LT |
5 | * |
6 | * Created by David Woodhouse <dwmw2@infradead.org> | |
7 | * | |
8 | * For licensing information, see the file 'LICENCE' in this directory. | |
9 | * | |
1da177e4 LT |
10 | */ |
11 | ||
12 | #include <linux/kernel.h> | |
13 | #include <linux/jffs2.h> | |
14 | #include <linux/mtd/mtd.h> | |
15 | #include <linux/completion.h> | |
4e57b681 | 16 | #include <linux/sched.h> |
7dfb7103 | 17 | #include <linux/freezer.h> |
91e0955b | 18 | #include <linux/kthread.h> |
1da177e4 LT |
19 | #include "nodelist.h" |
20 | ||
21 | ||
22 | static int jffs2_garbage_collect_thread(void *); | |
23 | ||
24 | void jffs2_garbage_collect_trigger(struct jffs2_sb_info *c) | |
25 | { | |
acb64a43 | 26 | assert_spin_locked(&c->erase_completion_lock); |
ef53cb02 DW |
27 | if (c->gc_task && jffs2_thread_should_wake(c)) |
28 | send_sig(SIGHUP, c->gc_task, 1); | |
1da177e4 LT |
29 | } |
30 | ||
31 | /* This must only ever be called when no GC thread is currently running */ | |
32 | int jffs2_start_garbage_collect_thread(struct jffs2_sb_info *c) | |
33 | { | |
91e0955b | 34 | struct task_struct *tsk; |
1da177e4 LT |
35 | int ret = 0; |
36 | ||
4b4d1cc7 | 37 | BUG_ON(c->gc_task); |
1da177e4 | 38 | |
fff7afd7 | 39 | init_completion(&c->gc_thread_start); |
1da177e4 LT |
40 | init_completion(&c->gc_thread_exit); |
41 | ||
91e0955b GL |
42 | tsk = kthread_run(jffs2_garbage_collect_thread, c, "jffs2_gcd_mtd%d", c->mtd->index); |
43 | if (IS_ERR(tsk)) { | |
44 | printk(KERN_WARNING "fork failed for JFFS2 garbage collect thread: %ld\n", -PTR_ERR(tsk)); | |
1da177e4 | 45 | complete(&c->gc_thread_exit); |
91e0955b | 46 | ret = PTR_ERR(tsk); |
1da177e4 LT |
47 | } else { |
48 | /* Wait for it... */ | |
91e0955b | 49 | D1(printk(KERN_DEBUG "JFFS2: Garbage collect thread is pid %d\n", tsk->pid)); |
fff7afd7 | 50 | wait_for_completion(&c->gc_thread_start); |
91e0955b | 51 | ret = tsk->pid; |
1da177e4 | 52 | } |
182ec4ee | 53 | |
1da177e4 LT |
54 | return ret; |
55 | } | |
56 | ||
57 | void jffs2_stop_garbage_collect_thread(struct jffs2_sb_info *c) | |
58 | { | |
e2d48b1a | 59 | int wait = 0; |
1da177e4 LT |
60 | spin_lock(&c->erase_completion_lock); |
61 | if (c->gc_task) { | |
62 | D1(printk(KERN_DEBUG "jffs2: Killing GC task %d\n", c->gc_task->pid)); | |
63 | send_sig(SIGKILL, c->gc_task, 1); | |
e2d48b1a | 64 | wait = 1; |
1da177e4 LT |
65 | } |
66 | spin_unlock(&c->erase_completion_lock); | |
e2d48b1a TG |
67 | if (wait) |
68 | wait_for_completion(&c->gc_thread_exit); | |
1da177e4 LT |
69 | } |
70 | ||
71 | static int jffs2_garbage_collect_thread(void *_c) | |
72 | { | |
73 | struct jffs2_sb_info *c = _c; | |
74 | ||
1da177e4 LT |
75 | allow_signal(SIGKILL); |
76 | allow_signal(SIGSTOP); | |
77 | allow_signal(SIGCONT); | |
78 | ||
79 | c->gc_task = current; | |
fff7afd7 | 80 | complete(&c->gc_thread_start); |
1da177e4 LT |
81 | |
82 | set_user_nice(current, 10); | |
83 | ||
83144186 | 84 | set_freezable(); |
1da177e4 LT |
85 | for (;;) { |
86 | allow_signal(SIGHUP); | |
e716dd36 | 87 | again: |
b27cf88e | 88 | spin_lock(&c->erase_completion_lock); |
1da177e4 LT |
89 | if (!jffs2_thread_should_wake(c)) { |
90 | set_current_state (TASK_INTERRUPTIBLE); | |
b27cf88e | 91 | spin_unlock(&c->erase_completion_lock); |
1da177e4 | 92 | D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread sleeping...\n")); |
1da177e4 | 93 | schedule(); |
b27cf88e DW |
94 | } else |
95 | spin_unlock(&c->erase_completion_lock); | |
96 | ||
1da177e4 | 97 | |
efab0b5d AS |
98 | /* Problem - immediately after bootup, the GCD spends a lot |
99 | * of time in places like jffs2_kill_fragtree(); so much so | |
100 | * that userspace processes (like gdm and X) are starved | |
101 | * despite plenty of cond_resched()s and renicing. Yield() | |
102 | * doesn't help, either (presumably because userspace and GCD | |
103 | * are generally competing for a higher latency resource - | |
104 | * disk). | |
105 | * This forces the GCD to slow the hell down. Pulling an | |
106 | * inode in with read_inode() is much preferable to having | |
107 | * the GC thread get there first. */ | |
108 | schedule_timeout_interruptible(msecs_to_jiffies(50)); | |
1da177e4 | 109 | |
91e0955b GL |
110 | if (kthread_should_stop()) { |
111 | D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): kthread_stop() called.\n")); | |
112 | goto die; | |
113 | } | |
114 | ||
182ec4ee | 115 | /* Put_super will send a SIGKILL and then wait on the sem. |
1da177e4 | 116 | */ |
e136e769 | 117 | while (signal_pending(current) || freezing(current)) { |
1da177e4 LT |
118 | siginfo_t info; |
119 | unsigned long signr; | |
120 | ||
e716dd36 DW |
121 | if (try_to_freeze()) |
122 | goto again; | |
123 | ||
1da177e4 LT |
124 | signr = dequeue_signal_lock(current, ¤t->blocked, &info); |
125 | ||
126 | switch(signr) { | |
127 | case SIGSTOP: | |
128 | D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): SIGSTOP received.\n")); | |
129 | set_current_state(TASK_STOPPED); | |
130 | schedule(); | |
131 | break; | |
132 | ||
133 | case SIGKILL: | |
134 | D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): SIGKILL received.\n")); | |
135 | goto die; | |
136 | ||
137 | case SIGHUP: | |
138 | D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): SIGHUP received.\n")); | |
139 | break; | |
140 | default: | |
141 | D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): signal %ld received\n", signr)); | |
142 | } | |
143 | } | |
144 | /* We don't want SIGHUP to interrupt us. STOP and KILL are OK though. */ | |
145 | disallow_signal(SIGHUP); | |
146 | ||
147 | D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): pass\n")); | |
148 | if (jffs2_garbage_collect_pass(c) == -ENOSPC) { | |
149 | printk(KERN_NOTICE "No space for garbage collection. Aborting GC thread\n"); | |
150 | goto die; | |
151 | } | |
152 | } | |
153 | die: | |
154 | spin_lock(&c->erase_completion_lock); | |
155 | c->gc_task = NULL; | |
156 | spin_unlock(&c->erase_completion_lock); | |
157 | complete_and_exit(&c->gc_thread_exit, 0); | |
158 | } |