add experimental fix for OCF on 2.6.27.y (closes #4184)
authorGabor Juhos <juhosg@openwrt.org>
Mon, 24 Nov 2008 20:20:41 +0000 (20:20 +0000)
committerGabor Juhos <juhosg@openwrt.org>
Mon, 24 Nov 2008 20:20:41 +0000 (20:20 +0000)
SVN-Revision: 13341

target/linux/generic-2.6/patches-2.6.27/973-ocf_2.6.27_fix.patch [new file with mode: 0644]

diff --git a/target/linux/generic-2.6/patches-2.6.27/973-ocf_2.6.27_fix.patch b/target/linux/generic-2.6/patches-2.6.27/973-ocf_2.6.27_fix.patch
new file mode 100644 (file)
index 0000000..6ffce01
--- /dev/null
@@ -0,0 +1,197 @@
+--- a/crypto/ocf/random.c
++++ b/crypto/ocf/random.c
+@@ -49,6 +49,7 @@
+ #include <linux/unistd.h>
+ #include <linux/poll.h>
+ #include <linux/random.h>
++#include <linux/kthread.h>
+ #include <cryptodev.h>
+ #ifdef CONFIG_OCF_FIPS
+@@ -81,7 +82,7 @@ struct random_op {
+ static int random_proc(void *arg);
+-static pid_t          randomproc = (pid_t) -1;
++static struct task_struct *random_task;
+ static spinlock_t     random_lock;
+ /*
+@@ -141,13 +142,18 @@ crypto_rregister(
+       spin_lock_irqsave(&random_lock, flags);
+       list_add_tail(&rops->random_list, &random_ops);
+       if (!started) {
+-              randomproc = kernel_thread(random_proc, NULL, CLONE_FS|CLONE_FILES);
+-              if (randomproc < 0) {
+-                      ret = randomproc;
++              struct task_struct *t;
++
++              t = kthread_create(random_proc, NULL, "ocf-random");
++              if (IS_ERR(t)) {
+                       printk("crypto: crypto_rregister cannot start random thread; "
+                                       "error %d", ret);
+-              } else
++                      ret = PTR_ERR(t);
++              } else {
++                      random_task = t;
++                      wake_up_process(t);
+                       started = 1;
++              }
+       }
+       spin_unlock_irqrestore(&random_lock, flags);
+@@ -172,7 +178,7 @@ crypto_runregister_all(u_int32_t driveri
+       spin_lock_irqsave(&random_lock, flags);
+       if (list_empty(&random_ops) && started)
+-              kill_proc(randomproc, SIGKILL, 1);
++              send_sig(SIGKILL, random_task, 1);
+       spin_unlock_irqrestore(&random_lock, flags);
+       return(0);
+ }
+@@ -308,7 +314,7 @@ random_proc(void *arg)
+ bad_alloc:
+       spin_lock_irq(&random_lock);
+-      randomproc = (pid_t) -1;
++      random_task = NULL;
+       started = 0;
+       spin_unlock_irq(&random_lock);
+--- a/crypto/ocf/crypto.c
++++ b/crypto/ocf/crypto.c
+@@ -74,6 +74,7 @@ __FBSDID("$FreeBSD: src/sys/opencrypto/c
+ #include <linux/sched.h>
+ #include <linux/spinlock.h>
+ #include <linux/version.h>
++#include <linux/kthread.h>
+ #include <cryptodev.h>
+ /*
+@@ -255,10 +256,10 @@ module_param(crypto_devallowsoft, int, 0
+ MODULE_PARM_DESC(crypto_devallowsoft,
+          "Enable/disable use of software crypto support");
+-static pid_t  cryptoproc = (pid_t) -1;
++static struct task_struct *crypto_task;
+ static struct completion cryptoproc_exited;
+ static DECLARE_WAIT_QUEUE_HEAD(cryptoproc_wait);
+-static pid_t  cryptoretproc = (pid_t) -1;
++static struct task_struct *cryptoret_task;
+ static struct completion cryptoretproc_exited;
+ static DECLARE_WAIT_QUEUE_HEAD(cryptoretproc_wait);
+@@ -1401,7 +1402,7 @@ crypto_proc(void *arg)
+                       wait_event_interruptible(cryptoproc_wait,
+                                       !(list_empty(&crp_q) || crypto_all_qblocked) ||
+                                       !(list_empty(&crp_kq) || crypto_all_kqblocked) ||
+-                                      cryptoproc == (pid_t) -1);
++                                      crypto_task == NULL);
+                       crp_sleep = 0;
+                       if (signal_pending (current)) {
+ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
+@@ -1414,7 +1415,7 @@ crypto_proc(void *arg)
+                       }
+                       CRYPTO_Q_LOCK();
+                       dprintk("%s - awake\n", __FUNCTION__);
+-                      if (cryptoproc == (pid_t) -1)
++                      if (crypto_task == NULL)
+                               break;
+                       cryptostats.cs_intrs++;
+               }
+@@ -1470,7 +1471,7 @@ crypto_ret_proc(void *arg)
+                       dprintk("%s - sleeping\n", __FUNCTION__);
+                       CRYPTO_RETQ_UNLOCK();
+                       wait_event_interruptible(cryptoretproc_wait,
+-                                      cryptoretproc == (pid_t) -1 ||
++                                      cryptoret_task == NULL ||
+                                       !list_empty(&crp_ret_q) ||
+                                       !list_empty(&crp_ret_kq));
+                       if (signal_pending (current)) {
+@@ -1484,7 +1485,7 @@ crypto_ret_proc(void *arg)
+                       }
+                       CRYPTO_RETQ_LOCK();
+                       dprintk("%s - awake\n", __FUNCTION__);
+-                      if (cryptoretproc == (pid_t) -1) {
++                      if (cryptoret_task == NULL) {
+                               dprintk("%s - EXITING!\n", __FUNCTION__);
+                               break;
+                       }
+@@ -1597,6 +1598,7 @@ DB_SHOW_COMMAND(kcrypto, db_show_kcrypto
+ static int
+ crypto_init(void)
+ {
++      struct task_struct *t;
+       int error;
+       dprintk("%s(0x%x)\n", __FUNCTION__, (int) crypto_init);
+@@ -1643,23 +1645,27 @@ crypto_init(void)
+       init_completion(&cryptoproc_exited);
+       init_completion(&cryptoretproc_exited);
+-      cryptoproc = 0; /* to avoid race condition where proc runs first */
+-      cryptoproc = kernel_thread(crypto_proc, NULL, CLONE_FS|CLONE_FILES);
+-      if (cryptoproc < 0) {
+-              error = cryptoproc;
++      crypto_task = NULL; /* to avoid race condition where proc runs first */
++      t = kthread_create(crypto_proc, NULL, "ocf-crypto");
++      if (IS_ERR(t)) {
++              error = PTR_ERR(t);
+               printk("crypto: crypto_init cannot start crypto thread; error %d",
+                       error);
+               goto bad;
+       }
++      wake_up_process(t);
++      crypto_task = t;
+-      cryptoretproc = 0; /* to avoid race condition where proc runs first */
+-      cryptoretproc = kernel_thread(crypto_ret_proc, NULL, CLONE_FS|CLONE_FILES);
+-      if (cryptoretproc < 0) {
+-              error = cryptoretproc;
++      cryptoret_task = NULL; /* to avoid race condition where proc runs first */
++      t = kthread_create(crypto_ret_proc, NULL, "ocf-cryptoret");
++      if (IS_ERR(t)) {
++              error = PTR_ERR(t);
+               printk("crypto: crypto_init cannot start cryptoret thread; error %d",
+                               error);
+               goto bad;
+       }
++      wake_up_process(t);
++      cryptoret_task = t;
+       return 0;
+ bad:
+@@ -1671,7 +1677,7 @@ bad:
+ static void
+ crypto_exit(void)
+ {
+-      pid_t p;
++      struct task_struct *t;
+       unsigned long d_flags;
+       dprintk("%s()\n", __FUNCTION__);
+@@ -1681,18 +1687,18 @@ crypto_exit(void)
+        */
+       CRYPTO_DRIVER_LOCK();
+-      p = cryptoproc;
+-      cryptoproc = (pid_t) -1;
+-      kill_proc(p, SIGTERM, 1);
++      t = crypto_task;
++      crypto_task = NULL;
++      send_sig(SIGTERM, t, 1);
+       wake_up_interruptible(&cryptoproc_wait);
+       CRYPTO_DRIVER_UNLOCK();
+       wait_for_completion(&cryptoproc_exited);
+       CRYPTO_DRIVER_LOCK();
+-      p = cryptoretproc;
+-      cryptoretproc = (pid_t) -1;
+-      kill_proc(p, SIGTERM, 1);
++      t = cryptoret_task;
++      cryptoret_task = NULL;
++      send_sig(SIGTERM, t, 1);
+       wake_up_interruptible(&cryptoretproc_wait);
+       CRYPTO_DRIVER_UNLOCK();