JFS: Use the kthread_ API

Use the kthread_ API instead of opencoding lots of hairy code for kernel
thread creation and teardown.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dave Kleikamp <shaggy@austin.ibm.com>

diff --git a/fs/jfs/jfs_logmgr.c b/fs/jfs/jfs_logmgr.c
index 06bded6c12b9b2fe7180312bb86f8666ff734d59..3113ff53bd55fcb120caad3b6cf23bd59e44684c 100644 (file)
--- a/fs/jfs/jfs_logmgr.c
+++ b/fs/jfs/jfs_logmgr.c
@@ -64,6 +64,7 @@
 #include <linux/interrupt.h>
 #include <linux/smp_lock.h>
 #include <linux/completion.h>
+#include <linux/kthread.h>
 #include <linux/buffer_head.h>         /* for sync_blockdev() */
 #include <linux/bio.h>
 #include <linux/suspend.h>
@@ -81,7 +82,6 @@
  */
 static struct lbuf *log_redrive_list;
 static DEFINE_SPINLOCK(log_redrive_lock);
-DECLARE_WAIT_QUEUE_HEAD(jfs_IO_thread_wait);
 
 
 /*
@@ -1980,7 +1980,7 @@ static inline void lbmRedrive(struct lbuf *bp)
        log_redrive_list = bp;
        spin_unlock_irqrestore(&log_redrive_lock, flags);
 
-       wake_up(&jfs_IO_thread_wait);
+       wake_up_process(jfsIOthread);
 }
 
 
@@ -2347,13 +2347,7 @@ int jfsIOWait(void *arg)
 {
        struct lbuf *bp;
 
-       daemonize("jfsIO");
-
-       complete(&jfsIOwait);
-
        do {
-               DECLARE_WAITQUEUE(wq, current);
-
                spin_lock_irq(&log_redrive_lock);
                while ((bp = log_redrive_list) != 0) {
                        log_redrive_list = bp->l_redrive_next;
@@ -2362,21 +2356,19 @@ int jfsIOWait(void *arg)
                        lbmStartIO(bp);
                        spin_lock_irq(&log_redrive_lock);
                }
+               spin_unlock_irq(&log_redrive_lock);
+
                if (freezing(current)) {
-                       spin_unlock_irq(&log_redrive_lock);
                        refrigerator();
                } else {
-                       add_wait_queue(&jfs_IO_thread_wait, &wq);
                        set_current_state(TASK_INTERRUPTIBLE);
-                       spin_unlock_irq(&log_redrive_lock);
                        schedule();
                        current->state = TASK_RUNNING;
-                       remove_wait_queue(&jfs_IO_thread_wait, &wq);
                }
-       } while (!jfs_stop_threads);
+       } while (!kthread_should_stop());
 
        jfs_info("jfsIOWait being killed!");
-       complete_and_exit(&jfsIOwait, 0);
+       return 0;
 }
 
 /*

diff --git a/fs/jfs/jfs_superblock.h b/fs/jfs/jfs_superblock.h
index fcf781bf31cbf9e399043953fb6857d2c27b93aa..682cf1a68a185ae3a7f22c954a86de1b35c2d339 100644 (file)
--- a/fs/jfs/jfs_superblock.h
+++ b/fs/jfs/jfs_superblock.h
@@ -113,12 +113,9 @@ extern int jfs_mount(struct super_block *);
 extern int jfs_mount_rw(struct super_block *, int);
 extern int jfs_umount(struct super_block *);
 extern int jfs_umount_rw(struct super_block *);
-
-extern int jfs_stop_threads;
-extern struct completion jfsIOwait;
-extern wait_queue_head_t jfs_IO_thread_wait;
-extern wait_queue_head_t jfs_commit_thread_wait;
-extern wait_queue_head_t jfs_sync_thread_wait;
 extern int jfs_extendfs(struct super_block *, s64, int);
 
+extern struct task_struct *jfsIOthread;
+extern struct task_struct *jfsSyncThread;
+
 #endif /*_H_JFS_SUPERBLOCK */

diff --git a/fs/jfs/jfs_txnmgr.c b/fs/jfs/jfs_txnmgr.c
index d38f605d948144959603aa179f28b45e83bbe9e9..ac3d66948e8ceae440e77d944bd2667f9a9e8e76 100644 (file)
--- a/fs/jfs/jfs_txnmgr.c
+++ b/fs/jfs/jfs_txnmgr.c
@@ -49,6 +49,7 @@
 #include <linux/suspend.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
+#include <linux/kthread.h>
 #include "jfs_incore.h"
 #include "jfs_inode.h"
 #include "jfs_filsys.h"
@@ -121,8 +122,7 @@ static DEFINE_SPINLOCK(jfsTxnLock);
 #define LAZY_LOCK(flags)       spin_lock_irqsave(&TxAnchor.LazyLock, flags)
 #define LAZY_UNLOCK(flags) spin_unlock_irqrestore(&TxAnchor.LazyLock, flags)
 
-DECLARE_WAIT_QUEUE_HEAD(jfs_sync_thread_wait);
-DECLARE_WAIT_QUEUE_HEAD(jfs_commit_thread_wait);
+static DECLARE_WAIT_QUEUE_HEAD(jfs_commit_thread_wait);
 static int jfs_commit_thread_waking;
 
 /*
@@ -207,7 +207,7 @@ static lid_t txLockAlloc(void)
        if ((++TxAnchor.tlocksInUse > TxLockHWM) && (jfs_tlocks_low == 0)) {
                jfs_info("txLockAlloc tlocks low");
                jfs_tlocks_low = 1;
-               wake_up(&jfs_sync_thread_wait);
+               wake_up_process(jfsSyncThread);
        }
 
        return lid;
@@ -2743,10 +2743,6 @@ int jfs_lazycommit(void *arg)
        unsigned long flags;
        struct jfs_sb_info *sbi;
 
-       daemonize("jfsCommit");
-
-       complete(&jfsIOwait);
-
        do {
                LAZY_LOCK(flags);
                jfs_commit_thread_waking = 0;   /* OK to wake another thread */
@@ -2806,13 +2802,13 @@ int jfs_lazycommit(void *arg)
                        current->state = TASK_RUNNING;
                        remove_wait_queue(&jfs_commit_thread_wait, &wq);
                }
-       } while (!jfs_stop_threads);
+       } while (!kthread_should_stop());
 
        if (!list_empty(&TxAnchor.unlock_queue))
                jfs_err("jfs_lazycommit being killed w/pending transactions!");
        else
                jfs_info("jfs_lazycommit being killed\n");
-       complete_and_exit(&jfsIOwait, 0);
+       return 0;
 }
 
 void txLazyUnlock(struct tblock * tblk)
@@ -2932,10 +2928,6 @@ int jfs_sync(void *arg)
        int rc;
        tid_t tid;
 
-       daemonize("jfsSync");
-
-       complete(&jfsIOwait);
-
        do {
                /*
                 * write each inode on the anonymous inode list
@@ -2996,19 +2988,15 @@ int jfs_sync(void *arg)
                        TXN_UNLOCK();
                        refrigerator();
                } else {
-                       DECLARE_WAITQUEUE(wq, current);
-
-                       add_wait_queue(&jfs_sync_thread_wait, &wq);
                        set_current_state(TASK_INTERRUPTIBLE);
                        TXN_UNLOCK();
                        schedule();
                        current->state = TASK_RUNNING;
-                       remove_wait_queue(&jfs_sync_thread_wait, &wq);
                }
-       } while (!jfs_stop_threads);
+       } while (!kthread_should_stop());
 
        jfs_info("jfs_sync being killed");
-       complete_and_exit(&jfsIOwait, 0);
+       return 0;
 }
 
 #if defined(CONFIG_PROC_FS) && defined(CONFIG_JFS_DEBUG)

diff --git a/fs/jfs/super.c b/fs/jfs/super.c
index 1639d2cd371fb62356fea050d66270b4d1b178d0..bd6720d807a68ed5b66df129292f306f57bd8b54 100644 (file)
--- a/fs/jfs/super.c
+++ b/fs/jfs/super.c
@@ -25,6 +25,7 @@
 #include <linux/vfs.h>
 #include <linux/mount.h>
 #include <linux/moduleparam.h>
+#include <linux/kthread.h>
 #include <linux/posix_acl.h>
 #include <asm/uaccess.h>
 #include <linux/seq_file.h>
@@ -54,11 +55,9 @@ static int commit_threads = 0;
 module_param(commit_threads, int, 0);
 MODULE_PARM_DESC(commit_threads, "Number of commit threads");
 
-int jfs_stop_threads;
-static pid_t jfsIOthread;
-static pid_t jfsCommitThread[MAX_COMMIT_THREADS];
-static pid_t jfsSyncThread;
-DECLARE_COMPLETION(jfsIOwait);
+static struct task_struct *jfsCommitThread[MAX_COMMIT_THREADS];
+struct task_struct *jfsIOthread;
+struct task_struct *jfsSyncThread;
 
 #ifdef CONFIG_JFS_DEBUG
 int jfsloglevel = JFS_LOGLEVEL_WARN;
@@ -661,12 +660,12 @@ static int __init init_jfs_fs(void)
        /*
         * I/O completion thread (endio)
         */
-       jfsIOthread = kernel_thread(jfsIOWait, NULL, CLONE_KERNEL);
-       if (jfsIOthread < 0) {
-               jfs_err("init_jfs_fs: fork failed w/rc = %d", jfsIOthread);
+       jfsIOthread = kthread_run(jfsIOWait, NULL, "jfsIO");
+       if (IS_ERR(jfsIOthread)) {
+               rc = PTR_ERR(jfsIOthread);
+               jfs_err("init_jfs_fs: fork failed w/rc = %d", rc);
                goto end_txmngr;
        }
-       wait_for_completion(&jfsIOwait);        /* Wait until thread starts */
 
        if (commit_threads < 1)
                commit_threads = num_online_cpus();
@@ -674,24 +673,21 @@ static int __init init_jfs_fs(void)
                commit_threads = MAX_COMMIT_THREADS;
 
        for (i = 0; i < commit_threads; i++) {
-               jfsCommitThread[i] = kernel_thread(jfs_lazycommit, NULL,
-                                                  CLONE_KERNEL);
-               if (jfsCommitThread[i] < 0) {
-                       jfs_err("init_jfs_fs: fork failed w/rc = %d",
-                               jfsCommitThread[i]);
+               jfsCommitThread[i] = kthread_run(jfs_lazycommit, NULL, "jfsCommit");
+               if (IS_ERR(jfsCommitThread[i])) {
+                       rc = PTR_ERR(jfsCommitThread[i]);
+                       jfs_err("init_jfs_fs: fork failed w/rc = %d", rc);
                        commit_threads = i;
                        goto kill_committask;
                }
-               /* Wait until thread starts */
-               wait_for_completion(&jfsIOwait);
        }
 
-       jfsSyncThread = kernel_thread(jfs_sync, NULL, CLONE_KERNEL);
-       if (jfsSyncThread < 0) {
-               jfs_err("init_jfs_fs: fork failed w/rc = %d", jfsSyncThread);
+       jfsSyncThread = kthread_run(jfs_sync, NULL, "jfsSync");
+       if (IS_ERR(jfsSyncThread)) {
+               rc = PTR_ERR(jfsSyncThread);
+               jfs_err("init_jfs_fs: fork failed w/rc = %d", rc);
                goto kill_committask;
        }
-       wait_for_completion(&jfsIOwait);        /* Wait until thread starts */
 
 #ifdef PROC_FS_JFS
        jfs_proc_init();
@@ -700,13 +696,9 @@ static int __init init_jfs_fs(void)
        return register_filesystem(&jfs_fs_type);
 
 kill_committask:
-       jfs_stop_threads = 1;
-       wake_up_all(&jfs_commit_thread_wait);
        for (i = 0; i < commit_threads; i++)
-               wait_for_completion(&jfsIOwait);
-
-       wake_up(&jfs_IO_thread_wait);
-       wait_for_completion(&jfsIOwait);        /* Wait for thread exit */
+               kthread_stop(jfsCommitThread[i]);
+       kthread_stop(jfsIOthread);
 end_txmngr:
        txExit();
 free_metapage:
@@ -722,16 +714,13 @@ static void __exit exit_jfs_fs(void)
 
        jfs_info("exit_jfs_fs called");
 
-       jfs_stop_threads = 1;
        txExit();
        metapage_exit();
-       wake_up(&jfs_IO_thread_wait);
-       wait_for_completion(&jfsIOwait);        /* Wait until IO thread exits */
-       wake_up_all(&jfs_commit_thread_wait);
+
+       kthread_stop(jfsIOthread);
        for (i = 0; i < commit_threads; i++)
-               wait_for_completion(&jfsIOwait);
-       wake_up(&jfs_sync_thread_wait);
-       wait_for_completion(&jfsIOwait);        /* Wait until Sync thread exits */
+               kthread_stop(jfsCommitThread[i]);
+       kthread_stop(jfsSyncThread);
 #ifdef PROC_FS_JFS
        jfs_proc_clean();
 #endif