blob: 6eb3daebd56354ca4973093c9d5966c7e148ae0a [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>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080019#include <linux/freezer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "nodelist.h"
21
22
23static int jffs2_garbage_collect_thread(void *);
24
25void 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 */
34int jffs2_start_garbage_collect_thread(struct jffs2_sb_info *c)
35{
36 pid_t pid;
37 int ret = 0;
38
Eric Sesterhenn4b4d1cc2006-04-01 01:15:35 +020039 BUG_ON(c->gc_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -070040
Thomas Gleixnerfff7afd2005-05-19 17:18:11 +010041 init_completion(&c->gc_thread_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 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));
Thomas Gleixnerfff7afd2005-05-19 17:18:11 +010052 wait_for_completion(&c->gc_thread_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +000054
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 return ret;
56}
57
58void jffs2_stop_garbage_collect_thread(struct jffs2_sb_info *c)
59{
Thomas Gleixnere2d48b12005-05-20 22:37:15 +010060 int wait = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 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);
Thomas Gleixnere2d48b12005-05-20 22:37:15 +010065 wait = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 }
67 spin_unlock(&c->erase_completion_lock);
Thomas Gleixnere2d48b12005-05-20 22:37:15 +010068 if (wait)
69 wait_for_completion(&c->gc_thread_exit);
Linus Torvalds1da177e2005-04-16 15:20:36 -070070}
71
72static 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;
Thomas Gleixnerfff7afd2005-05-19 17:18:11 +010082 complete(&c->gc_thread_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
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
Andrew Morton34f18a92005-06-26 03:27:20 -070099 if (try_to_freeze())
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 continue;
101
102 cond_resched();
103
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000104 /* Put_super will send a SIGKILL and then wait on the sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 */
106 while (signal_pending(current)) {
107 siginfo_t info;
108 unsigned long signr;
109
110 signr = dequeue_signal_lock(current, &current->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}