blob: e9580104b6ba477894b60c6bb3e69839c5677d2f [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 Sesterhenn4b4d1cc72006-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:
David Woodhouseb27cf882008-10-31 14:52:24 +000088 spin_lock(&c->erase_completion_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 if (!jffs2_thread_should_wake(c)) {
90 set_current_state (TASK_INTERRUPTIBLE);
David Woodhouseb27cf882008-10-31 14:52:24 +000091 spin_unlock(&c->erase_completion_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread sleeping...\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 schedule();
David Woodhouseb27cf882008-10-31 14:52:24 +000094 } else
95 spin_unlock(&c->erase_completion_lock);
96
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
Andres Salomonefab0b52009-02-11 13:27:02 -080098 /* 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));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000110 /* Put_super will send a SIGKILL and then wait on the sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 */
Rafael J. Wysockie136e762007-12-04 01:11:09 +0100112 while (signal_pending(current) || freezing(current)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 siginfo_t info;
114 unsigned long signr;
115
David Woodhousee716dd32007-06-28 19:49:36 +0100116 if (try_to_freeze())
117 goto again;
118
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 signr = dequeue_signal_lock(current, &current->blocked, &info);
120
121 switch(signr) {
122 case SIGSTOP:
123 D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): SIGSTOP received.\n"));
124 set_current_state(TASK_STOPPED);
125 schedule();
126 break;
127
128 case SIGKILL:
129 D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): SIGKILL received.\n"));
130 goto die;
131
132 case SIGHUP:
133 D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): SIGHUP received.\n"));
134 break;
135 default:
136 D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): signal %ld received\n", signr));
137 }
138 }
139 /* We don't want SIGHUP to interrupt us. STOP and KILL are OK though. */
140 disallow_signal(SIGHUP);
141
142 D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): pass\n"));
143 if (jffs2_garbage_collect_pass(c) == -ENOSPC) {
144 printk(KERN_NOTICE "No space for garbage collection. Aborting GC thread\n");
145 goto die;
146 }
147 }
148 die:
149 spin_lock(&c->erase_completion_lock);
150 c->gc_task = NULL;
151 spin_unlock(&c->erase_completion_lock);
152 complete_and_exit(&c->gc_thread_exit, 0);
153}