blob: ff2a872e80e78677de43baaf8acc758299106ec0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 *
Thomas Gleixnere2d48b12005-05-20 22:37:15 +010010 * $Id: background.c,v 1.54 2005/05/20 21:37:12 gleixner Exp $
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 *
12 */
13
14#include <linux/kernel.h>
15#include <linux/jffs2.h>
16#include <linux/mtd/mtd.h>
17#include <linux/completion.h>
Tim Schmielau4e57b682005-10-30 15:03:48 -080018#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include "nodelist.h"
20
21
22static int jffs2_garbage_collect_thread(void *);
23
24void jffs2_garbage_collect_trigger(struct jffs2_sb_info *c)
25{
26 spin_lock(&c->erase_completion_lock);
27 if (c->gc_task && jffs2_thread_should_wake(c))
28 send_sig(SIGHUP, c->gc_task, 1);
29 spin_unlock(&c->erase_completion_lock);
30}
31
32/* This must only ever be called when no GC thread is currently running */
33int jffs2_start_garbage_collect_thread(struct jffs2_sb_info *c)
34{
35 pid_t pid;
36 int ret = 0;
37
Eric Sesterhenn4b4d1cc72006-04-01 01:15:35 +020038 BUG_ON(c->gc_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
Thomas Gleixnerfff7afd2005-05-19 17:18:11 +010040 init_completion(&c->gc_thread_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 init_completion(&c->gc_thread_exit);
42
43 pid = kernel_thread(jffs2_garbage_collect_thread, c, CLONE_FS|CLONE_FILES);
44 if (pid < 0) {
45 printk(KERN_WARNING "fork failed for JFFS2 garbage collect thread: %d\n", -pid);
46 complete(&c->gc_thread_exit);
47 ret = pid;
48 } else {
49 /* Wait for it... */
50 D1(printk(KERN_DEBUG "JFFS2: Garbage collect thread is pid %d\n", pid));
Thomas Gleixnerfff7afd2005-05-19 17:18:11 +010051 wait_for_completion(&c->gc_thread_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +000053
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 return ret;
55}
56
57void jffs2_stop_garbage_collect_thread(struct jffs2_sb_info *c)
58{
Thomas Gleixnere2d48b12005-05-20 22:37:15 +010059 int wait = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 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);
Thomas Gleixnere2d48b12005-05-20 22:37:15 +010064 wait = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 }
66 spin_unlock(&c->erase_completion_lock);
Thomas Gleixnere2d48b12005-05-20 22:37:15 +010067 if (wait)
68 wait_for_completion(&c->gc_thread_exit);
Linus Torvalds1da177e2005-04-16 15:20:36 -070069}
70
71static int jffs2_garbage_collect_thread(void *_c)
72{
73 struct jffs2_sb_info *c = _c;
74
75 daemonize("jffs2_gcd_mtd%d", c->mtd->index);
76 allow_signal(SIGKILL);
77 allow_signal(SIGSTOP);
78 allow_signal(SIGCONT);
79
80 c->gc_task = current;
Thomas Gleixnerfff7afd2005-05-19 17:18:11 +010081 complete(&c->gc_thread_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
83 set_user_nice(current, 10);
84
85 for (;;) {
86 allow_signal(SIGHUP);
87
88 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
Andrew Morton34f18a92005-06-26 03:27:20 -070098 if (try_to_freeze())
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 continue;
100
101 cond_resched();
102
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000103 /* Put_super will send a SIGKILL and then wait on the sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 */
105 while (signal_pending(current)) {
106 siginfo_t info;
107 unsigned long signr;
108
109 signr = dequeue_signal_lock(current, &current->blocked, &info);
110
111 switch(signr) {
112 case SIGSTOP:
113 D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): SIGSTOP received.\n"));
114 set_current_state(TASK_STOPPED);
115 schedule();
116 break;
117
118 case SIGKILL:
119 D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): SIGKILL received.\n"));
120 goto die;
121
122 case SIGHUP:
123 D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): SIGHUP received.\n"));
124 break;
125 default:
126 D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): signal %ld received\n", signr));
127 }
128 }
129 /* We don't want SIGHUP to interrupt us. STOP and KILL are OK though. */
130 disallow_signal(SIGHUP);
131
132 D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): pass\n"));
133 if (jffs2_garbage_collect_pass(c) == -ENOSPC) {
134 printk(KERN_NOTICE "No space for garbage collection. Aborting GC thread\n");
135 goto die;
136 }
137 }
138 die:
139 spin_lock(&c->erase_completion_lock);
140 c->gc_task = NULL;
141 spin_unlock(&c->erase_completion_lock);
142 complete_and_exit(&c->gc_thread_exit, 0);
143}