ia64/linux-2.6.18-xen.hg

view fs/jffs2/background.c @ 524:7f8b544237bf

netfront: Allow netfront in domain 0.

This is useful if your physical network device is in a utility domain.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Tue Apr 15 15:18:58 2008 +0100 (2008-04-15)
parents 831230e53067
children
line source
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 *
10 * $Id: background.c,v 1.54 2005/05/20 21:37:12 gleixner Exp $
11 *
12 */
14 #include <linux/kernel.h>
15 #include <linux/jffs2.h>
16 #include <linux/mtd/mtd.h>
17 #include <linux/completion.h>
18 #include <linux/sched.h>
19 #include "nodelist.h"
22 static int jffs2_garbage_collect_thread(void *);
24 void 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 }
32 /* This must only ever be called when no GC thread is currently running */
33 int jffs2_start_garbage_collect_thread(struct jffs2_sb_info *c)
34 {
35 pid_t pid;
36 int ret = 0;
38 BUG_ON(c->gc_task);
40 init_completion(&c->gc_thread_start);
41 init_completion(&c->gc_thread_exit);
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));
51 wait_for_completion(&c->gc_thread_start);
52 }
54 return ret;
55 }
57 void jffs2_stop_garbage_collect_thread(struct jffs2_sb_info *c)
58 {
59 int wait = 0;
60 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);
64 wait = 1;
65 }
66 spin_unlock(&c->erase_completion_lock);
67 if (wait)
68 wait_for_completion(&c->gc_thread_exit);
69 }
71 static int jffs2_garbage_collect_thread(void *_c)
72 {
73 struct jffs2_sb_info *c = _c;
75 daemonize("jffs2_gcd_mtd%d", c->mtd->index);
76 allow_signal(SIGKILL);
77 allow_signal(SIGSTOP);
78 allow_signal(SIGCONT);
80 c->gc_task = current;
81 complete(&c->gc_thread_start);
83 set_user_nice(current, 10);
85 for (;;) {
86 allow_signal(SIGHUP);
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 }
98 if (try_to_freeze())
99 continue;
101 cond_resched();
103 /* Put_super will send a SIGKILL and then wait on the sem.
104 */
105 while (signal_pending(current)) {
106 siginfo_t info;
107 unsigned long signr;
109 signr = dequeue_signal_lock(current, &current->blocked, &info);
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;
118 case SIGKILL:
119 D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): SIGKILL received.\n"));
120 goto die;
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);
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 }