mirror of
https://git.proxmox.com/git/mirror_zfs.git
synced 2024-12-28 20:09:35 +03:00
968eccd1d1
We need to use kthread_create() here for a few reasons. First off to old kernel_thread() API functioin will be going away. Secondly, and more importantly if I use kthread_create() we can then properly implement a thread_exit() function which terminates the kernel thread at any point with do_exit(). This fixes our cleanup bug which was caused by dropping a mutex twice after thread_exit() didn't really exit. git-svn-id: https://outreach.scidac.gov/svn/spl/trunk@66 7e1ea52c-4ff2-0310-8f11-9dd32ca42a1c
113 lines
3.1 KiB
C
113 lines
3.1 KiB
C
#include <sys/thread.h>
|
|
|
|
/*
|
|
* Thread interfaces
|
|
*/
|
|
typedef struct thread_priv_s {
|
|
unsigned long tp_magic; /* Magic */
|
|
void (*tp_func)(void *); /* Registered function */
|
|
void *tp_args; /* Args to be passed to function */
|
|
size_t tp_len; /* Len to be passed to function */
|
|
int tp_state; /* State to start thread at */
|
|
pri_t tp_pri; /* Priority to start threat at */
|
|
volatile kthread_t *tp_task; /* Task pointer for new thread */
|
|
spinlock_t tp_lock; /* Syncronization lock */
|
|
wait_queue_head_t tp_waitq; /* Syncronization wait queue */
|
|
} thread_priv_t;
|
|
|
|
static int
|
|
thread_generic_wrapper(void *arg)
|
|
{
|
|
thread_priv_t *tp = (thread_priv_t *)arg;
|
|
void (*func)(void *);
|
|
void *args;
|
|
|
|
spin_lock(&tp->tp_lock);
|
|
BUG_ON(tp->tp_magic != TP_MAGIC);
|
|
func = tp->tp_func;
|
|
args = tp->tp_args;
|
|
tp->tp_task = get_current();
|
|
set_current_state(tp->tp_state);
|
|
set_user_nice((kthread_t *)tp->tp_task, PRIO_TO_NICE(tp->tp_pri));
|
|
|
|
spin_unlock(&tp->tp_lock);
|
|
wake_up(&tp->tp_waitq);
|
|
|
|
/* DO NOT USE 'ARG' AFTER THIS POINT, EVER, EVER, EVER!
|
|
* Local variables are used here because after the calling thread
|
|
* has been woken up it will exit and this memory will no longer
|
|
* be safe to access since it was declared on the callers stack. */
|
|
if (func)
|
|
func(args);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
__thread_exit(void)
|
|
{
|
|
do_exit(0);
|
|
return;
|
|
}
|
|
EXPORT_SYMBOL(__thread_exit);
|
|
|
|
/* thread_create() may block forever if it cannot create a thread or
|
|
* allocate memory. This is preferable to returning a NULL which Solaris
|
|
* style callers likely never check for... since it can't fail. */
|
|
kthread_t *
|
|
__thread_create(caddr_t stk, size_t stksize, thread_func_t func,
|
|
const char *name, void *args, size_t len, int *pp,
|
|
int state, pri_t pri)
|
|
{
|
|
thread_priv_t tp;
|
|
DEFINE_WAIT(wait);
|
|
struct task_struct *tsk;
|
|
|
|
/* Option pp is simply ignored */
|
|
/* Variable stack size unsupported */
|
|
BUG_ON(stk != NULL);
|
|
BUG_ON(stk != 0);
|
|
|
|
/* Variable tp is located on the stack and not the heap because I want
|
|
* to minimize any chance of a failure, since the Solaris code is designed
|
|
* such that this function cannot fail. This is a little dangerous since
|
|
* we're passing a stack address to a new thread but correct locking was
|
|
* added to ensure the callee can use the data safely until wake_up(). */
|
|
tp.tp_magic = TP_MAGIC;
|
|
tp.tp_func = func;
|
|
tp.tp_args = args;
|
|
tp.tp_len = len;
|
|
tp.tp_state = state;
|
|
tp.tp_pri = pri;
|
|
tp.tp_task = NULL;
|
|
spin_lock_init(&tp.tp_lock);
|
|
init_waitqueue_head(&tp.tp_waitq);
|
|
|
|
spin_lock(&tp.tp_lock);
|
|
|
|
tsk = kthread_create(thread_generic_wrapper, (void *)&tp, "%s", name);
|
|
if (IS_ERR(tsk)) {
|
|
printk("spl: Failed to create thread: %ld\n", PTR_ERR(tsk));
|
|
return NULL;
|
|
}
|
|
|
|
wake_up_process(tsk);
|
|
|
|
/* All signals are ignored due to sleeping TASK_UNINTERRUPTIBLE */
|
|
for (;;) {
|
|
prepare_to_wait(&tp.tp_waitq, &wait, TASK_UNINTERRUPTIBLE);
|
|
if (tp.tp_task != NULL)
|
|
break;
|
|
|
|
spin_unlock(&tp.tp_lock);
|
|
schedule();
|
|
spin_lock(&tp.tp_lock);
|
|
}
|
|
|
|
BUG_ON(tsk != tp.tp_task); /* Extra paranoia */
|
|
spin_unlock(&tp.tp_lock);
|
|
|
|
return (kthread_t *)tp.tp_task;
|
|
}
|
|
EXPORT_SYMBOL(__thread_create);
|