Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * JFFS2 -- Journalling Flash File System, Version 2. | |
3 | * | |
4 | * Copyright (C) 2001-2003 Red Hat, Inc. | |
5 | * | |
6 | * Created by David Woodhouse <dwmw2@infradead.org> | |
7 | * | |
8 | * For licensing information, see the file 'LICENCE' in this directory. | |
9 | * | |
e2d48b1a | 10 | * $Id: background.c,v 1.54 2005/05/20 21:37:12 gleixner Exp $ |
1da177e4 LT |
11 | * |
12 | */ | |
13 | ||
14 | #include <linux/kernel.h> | |
15 | #include <linux/jffs2.h> | |
16 | #include <linux/mtd/mtd.h> | |
17 | #include <linux/completion.h> | |
4e57b681 | 18 | #include <linux/sched.h> |
7dfb7103 | 19 | #include <linux/freezer.h> |
1da177e4 LT |
20 | #include "nodelist.h" |
21 | ||
22 | ||
23 | static int jffs2_garbage_collect_thread(void *); | |
24 | ||
25 | void jffs2_garbage_collect_trigger(struct jffs2_sb_info *c) | |
26 | { | |
27 | spin_lock(&c->erase_completion_lock); | |
28 | if (c->gc_task && jffs2_thread_should_wake(c)) | |
29 | send_sig(SIGHUP, c->gc_task, 1); | |
30 | spin_unlock(&c->erase_completion_lock); | |
31 | } | |
32 | ||
33 | /* This must only ever be called when no GC thread is currently running */ | |
34 | int jffs2_start_garbage_collect_thread(struct jffs2_sb_info *c) | |
35 | { | |
36 | pid_t pid; | |
37 | int ret = 0; | |
38 | ||
4b4d1cc7 | 39 | BUG_ON(c->gc_task); |
1da177e4 | 40 | |
fff7afd7 | 41 | init_completion(&c->gc_thread_start); |
1da177e4 LT |
42 | init_completion(&c->gc_thread_exit); |
43 | ||
44 | pid = kernel_thread(jffs2_garbage_collect_thread, c, CLONE_FS|CLONE_FILES); | |
45 | if (pid < 0) { | |
46 | printk(KERN_WARNING "fork failed for JFFS2 garbage collect thread: %d\n", -pid); | |
47 | complete(&c->gc_thread_exit); | |
48 | ret = pid; | |
49 | } else { | |
50 | /* Wait for it... */ | |
51 | D1(printk(KERN_DEBUG "JFFS2: Garbage collect thread is pid %d\n", pid)); | |
fff7afd7 | 52 | wait_for_completion(&c->gc_thread_start); |
1da177e4 | 53 | } |
182ec4ee | 54 | |
1da177e4 LT |
55 | return ret; |
56 | } | |
57 | ||
58 | void jffs2_stop_garbage_collect_thread(struct jffs2_sb_info *c) | |
59 | { | |
e2d48b1a | 60 | int wait = 0; |
1da177e4 LT |
61 | spin_lock(&c->erase_completion_lock); |
62 | if (c->gc_task) { | |
63 | D1(printk(KERN_DEBUG "jffs2: Killing GC task %d\n", c->gc_task->pid)); | |
64 | send_sig(SIGKILL, c->gc_task, 1); | |
e2d48b1a | 65 | wait = 1; |
1da177e4 LT |
66 | } |
67 | spin_unlock(&c->erase_completion_lock); | |
e2d48b1a TG |
68 | if (wait) |
69 | wait_for_completion(&c->gc_thread_exit); | |
1da177e4 LT |
70 | } |
71 | ||
72 | static int jffs2_garbage_collect_thread(void *_c) | |
73 | { | |
74 | struct jffs2_sb_info *c = _c; | |
75 | ||
76 | daemonize("jffs2_gcd_mtd%d", c->mtd->index); | |
77 | allow_signal(SIGKILL); | |
78 | allow_signal(SIGSTOP); | |
79 | allow_signal(SIGCONT); | |
80 | ||
81 | c->gc_task = current; | |
fff7afd7 | 82 | complete(&c->gc_thread_start); |
1da177e4 LT |
83 | |
84 | set_user_nice(current, 10); | |
85 | ||
86 | for (;;) { | |
87 | allow_signal(SIGHUP); | |
88 | ||
89 | if (!jffs2_thread_should_wake(c)) { | |
90 | set_current_state (TASK_INTERRUPTIBLE); | |
91 | D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread sleeping...\n")); | |
92 | /* Yes, there's a race here; we checked jffs2_thread_should_wake() | |
93 | before setting current->state to TASK_INTERRUPTIBLE. But it doesn't | |
94 | matter - We don't care if we miss a wakeup, because the GC thread | |
95 | is only an optimisation anyway. */ | |
96 | schedule(); | |
97 | } | |
98 | ||
34f18a98 | 99 | if (try_to_freeze()) |
1da177e4 LT |
100 | continue; |
101 | ||
102 | cond_resched(); | |
103 | ||
182ec4ee | 104 | /* Put_super will send a SIGKILL and then wait on the sem. |
1da177e4 LT |
105 | */ |
106 | while (signal_pending(current)) { | |
107 | siginfo_t info; | |
108 | unsigned long signr; | |
109 | ||
110 | signr = dequeue_signal_lock(current, ¤t->blocked, &info); | |
111 | ||
112 | switch(signr) { | |
113 | case SIGSTOP: | |
114 | D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): SIGSTOP received.\n")); | |
115 | set_current_state(TASK_STOPPED); | |
116 | schedule(); | |
117 | break; | |
118 | ||
119 | case SIGKILL: | |
120 | D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): SIGKILL received.\n")); | |
121 | goto die; | |
122 | ||
123 | case SIGHUP: | |
124 | D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): SIGHUP received.\n")); | |
125 | break; | |
126 | default: | |
127 | D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): signal %ld received\n", signr)); | |
128 | } | |
129 | } | |
130 | /* We don't want SIGHUP to interrupt us. STOP and KILL are OK though. */ | |
131 | disallow_signal(SIGHUP); | |
132 | ||
133 | D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): pass\n")); | |
134 | if (jffs2_garbage_collect_pass(c) == -ENOSPC) { | |
135 | printk(KERN_NOTICE "No space for garbage collection. Aborting GC thread\n"); | |
136 | goto die; | |
137 | } | |
138 | } | |
139 | die: | |
140 | spin_lock(&c->erase_completion_lock); | |
141 | c->gc_task = NULL; | |
142 | spin_unlock(&c->erase_completion_lock); | |
143 | complete_and_exit(&c->gc_thread_exit, 0); | |
144 | } |