blob: 8adebd3e43c690fbf0469cf9b235279998c252c8 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * JFFS2 -- Journalling Flash File System, Version 2.
3 *
David Woodhousec00c3102007-04-25 14:16:47 +01004 * Copyright © 2001-2007 Red Hat, Inc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
6 * Created by David Woodhouse <dwmw2@infradead.org>
7 *
8 * For licensing information, see the file 'LICENCE' in this directory.
9 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 */
11
12#include <linux/kernel.h>
13#include <linux/jffs2.h>
14#include <linux/mtd/mtd.h>
15#include <linux/completion.h>
Tim Schmielau4e57b682005-10-30 15:03:48 -080016#include <linux/sched.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080017#include <linux/freezer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include "nodelist.h"
19
20
21static int jffs2_garbage_collect_thread(void *);
22
23void jffs2_garbage_collect_trigger(struct jffs2_sb_info *c)
24{
25 spin_lock(&c->erase_completion_lock);
David Woodhouseef53cb02007-07-10 10:01:22 +010026 if (c->gc_task && jffs2_thread_should_wake(c))
27 send_sig(SIGHUP, c->gc_task, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -070028 spin_unlock(&c->erase_completion_lock);
29}
30
31/* This must only ever be called when no GC thread is currently running */
32int jffs2_start_garbage_collect_thread(struct jffs2_sb_info *c)
33{
34 pid_t pid;
35 int ret = 0;
36
Eric Sesterhenn4b4d1cc2006-04-01 01:15:35 +020037 BUG_ON(c->gc_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
Thomas Gleixnerfff7afd2005-05-19 17:18:11 +010039 init_completion(&c->gc_thread_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 init_completion(&c->gc_thread_exit);
41
42 pid = kernel_thread(jffs2_garbage_collect_thread, c, CLONE_FS|CLONE_FILES);
43 if (pid < 0) {
44 printk(KERN_WARNING "fork failed for JFFS2 garbage collect thread: %d\n", -pid);
45 complete(&c->gc_thread_exit);
46 ret = pid;
47 } else {
48 /* Wait for it... */
49 D1(printk(KERN_DEBUG "JFFS2: Garbage collect thread is pid %d\n", pid));
Thomas Gleixnerfff7afd2005-05-19 17:18:11 +010050 wait_for_completion(&c->gc_thread_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +000052
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 return ret;
54}
55
56void jffs2_stop_garbage_collect_thread(struct jffs2_sb_info *c)
57{
Thomas Gleixnere2d48b12005-05-20 22:37:15 +010058 int wait = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 spin_lock(&c->erase_completion_lock);
60 if (c->gc_task) {
61 D1(printk(KERN_DEBUG "jffs2: Killing GC task %d\n", c->gc_task->pid));
62 send_sig(SIGKILL, c->gc_task, 1);
Thomas Gleixnere2d48b12005-05-20 22:37:15 +010063 wait = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 }
65 spin_unlock(&c->erase_completion_lock);
Thomas Gleixnere2d48b12005-05-20 22:37:15 +010066 if (wait)
67 wait_for_completion(&c->gc_thread_exit);
Linus Torvalds1da177e2005-04-16 15:20:36 -070068}
69
70static int jffs2_garbage_collect_thread(void *_c)
71{
72 struct jffs2_sb_info *c = _c;
73
74 daemonize("jffs2_gcd_mtd%d", c->mtd->index);
75 allow_signal(SIGKILL);
76 allow_signal(SIGSTOP);
77 allow_signal(SIGCONT);
78
79 c->gc_task = current;
Thomas Gleixnerfff7afd2005-05-19 17:18:11 +010080 complete(&c->gc_thread_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -070081
82 set_user_nice(current, 10);
83
Rafael J. Wysocki83144182007-07-17 04:03:35 -070084 set_freezable();
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 for (;;) {
86 allow_signal(SIGHUP);
David Woodhousee716dd32007-06-28 19:49:36 +010087 again:
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 if (!jffs2_thread_should_wake(c)) {
89 set_current_state (TASK_INTERRUPTIBLE);
90 D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread sleeping...\n"));
91 /* Yes, there's a race here; we checked jffs2_thread_should_wake()
92 before setting current->state to TASK_INTERRUPTIBLE. But it doesn't
93 matter - We don't care if we miss a wakeup, because the GC thread
94 is only an optimisation anyway. */
95 schedule();
96 }
97
David Woodhousef8a922c2007-03-08 10:28:30 +000098 /* This thread is purely an optimisation. But if it runs when
99 other things could be running, it actually makes things a
100 lot worse. Use yield() and put it at the back of the runqueue
101 every time. Especially during boot, pulling an inode in
102 with read_inode() is much preferable to having the GC thread
103 get there first. */
104 yield();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000106 /* Put_super will send a SIGKILL and then wait on the sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 */
Rafael J. Wysockie136e762007-12-04 01:11:09 +0100108 while (signal_pending(current) || freezing(current)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 siginfo_t info;
110 unsigned long signr;
111
David Woodhousee716dd32007-06-28 19:49:36 +0100112 if (try_to_freeze())
113 goto again;
114
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 signr = dequeue_signal_lock(current, &current->blocked, &info);
116
117 switch(signr) {
118 case SIGSTOP:
119 D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): SIGSTOP received.\n"));
120 set_current_state(TASK_STOPPED);
121 schedule();
122 break;
123
124 case SIGKILL:
125 D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): SIGKILL received.\n"));
126 goto die;
127
128 case SIGHUP:
129 D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): SIGHUP received.\n"));
130 break;
131 default:
132 D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): signal %ld received\n", signr));
133 }
134 }
135 /* We don't want SIGHUP to interrupt us. STOP and KILL are OK though. */
136 disallow_signal(SIGHUP);
137
138 D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): pass\n"));
139 if (jffs2_garbage_collect_pass(c) == -ENOSPC) {
140 printk(KERN_NOTICE "No space for garbage collection. Aborting GC thread\n");
141 goto die;
142 }
143 }
144 die:
145 spin_lock(&c->erase_completion_lock);
146 c->gc_task = NULL;
147 spin_unlock(&c->erase_completion_lock);
148 complete_and_exit(&c->gc_thread_exit, 0);
149}