/*! * Create new thread (params on user stack!) * \param thread User level thread descriptor * \param attr Thread attributes * \param start_routine Starting function for new thread * \param arg Parameter sent to starting function * (parameters are on calling thread stack) */ int sys__pthread_create ( pthread_t *thread, pthread_attr_t *attr, void *(*start_routine) (void *), void *arg ) { kthread_t *kthread; uint flags = 0; int sched_policy = SCHED_FIFO; int sched_priority = THREAD_DEF_PRIO; void *stackaddr = NULL; size_t stacksize = 0; SYS_ENTRY(); if ( attr ) { flags = attr->flags; sched_policy = attr->sched_policy; sched_priority = attr->sched_params.sched_priority; stackaddr = attr->stackaddr; stacksize = attr->stacksize; ASSERT_ERRNO_AND_EXIT ( sched_policy == SCHED_FIFO, ENOTSUP ); ASSERT_ERRNO_AND_EXIT ( sched_priority >= THREAD_MIN_PRIO && sched_priority <= THREAD_MAX_PRIO, ENOMEM ); /* if ( flags & SOMETHING ) change attributes ... */ } kthread = kthread_create ( start_routine, arg, flags, sched_policy, sched_priority, stackaddr, stacksize ); ASSERT_ERRNO_AND_EXIT ( kthread, ENOMEM ); if ( thread ) { thread->ptr = kthread; thread->id = kthread_get_id (kthread); } kthreads_schedule (); SYS_EXIT ( EXIT_SUCCESS, EXIT_SUCCESS ); }
int vcons_init(struct vcons_data *vd, void *cookie, struct wsscreen_descr *def, struct wsdisplay_accessops *ao) { /* zero out everything so we can rely on untouched fields being 0 */ memset(vd, 0, sizeof(struct vcons_data)); vd->cookie = cookie; vd->init_screen = vcons_dummy_init_screen; vd->show_screen_cb = NULL; /* keep a copy of the accessops that we replace below with our * own wrappers */ vd->ioctl = ao->ioctl; /* configure the accessops */ ao->ioctl = vcons_ioctl; ao->alloc_screen = vcons_alloc_screen; ao->free_screen = vcons_free_screen; ao->show_screen = vcons_show_screen; #ifdef WSDISPLAY_SCROLLSUPPORT ao->scroll = vcons_scroll; #endif LIST_INIT(&vd->screens); vd->active = NULL; vd->wanted = NULL; vd->currenttype = def; callout_init(&vd->switch_callout, 0); callout_setfunc(&vd->switch_callout, vcons_do_switch, vd); /* * a lock to serialize access to the framebuffer. * when switching screens we need to make sure there's no rasops * operation in progress */ #ifdef DIAGNOSTIC vd->switch_poll_count = 0; #endif #ifdef VCONS_SWITCH_ASYNC kthread_create(PRI_NONE, 0, NULL, vcons_kthread, vd, &vd->redraw_thread, "vcons_draw"); #endif return 0; }
void create_dma_threads() { struct task_struct *p[MAX_THREADS]; int t_count; for (t_count = 0; t_count < MAX_THREADS; t_count++) { p[t_count] = kthread_create(dma_chain_thread_entry, &cht[t_count], "dma_chain_thread"); kthread_bind(p[t_count], t_count); } /* Start all the threads at a time */ for (t_count = 0; t_count < MAX_THREADS; t_count++) { wake_up_process(p[t_count]); } return; }
/* * Create per-filesystem syncer process */ void vn_syncer_thr_create(struct mount *mp) { struct syncer_ctx *ctx; static int syncalloc = 0; ctx = kmalloc(sizeof(struct syncer_ctx), M_TEMP, M_WAITOK | M_ZERO); ctx->sc_mp = mp; ctx->sc_flags = 0; ctx->syncer_workitem_pending = hashinit(SYNCER_MAXDELAY, M_DEVBUF, &ctx->syncer_mask); ctx->syncer_delayno = 0; lwkt_token_init(&ctx->sc_token, "syncer"); mp->mnt_syncer_ctx = ctx; kthread_create(syncer_thread, ctx, &ctx->sc_thread, "syncer%d", ++syncalloc & 0x7FFFFFFF); }
static int AVL6211_Blindscan_Scan(struct dvb_frontend* fe, struct dvbsx_blindscanpara *pbspara) { printk(KERN_INFO "AVL6211_Blindscan_Scan printk\n"); AVL_DVBSx_IBSP_WaitSemaphore(&blindscanSem); fe_use = fe; blindstart=1; AVL_DVBSx_IBSP_ReleaseSemaphore(&blindscanSem); dvbs2_task = kthread_create(dvbs2_blindscan_task, pbspara, "dvbs2_task"); if(!dvbs2_task){ printk("Unable to start dvbs2 thread.\n"); dvbs2_task = NULL; return -1; } wake_up_process(dvbs2_task); return 0; }
static int exynos_dm_hotplug_notifier(struct notifier_block *notifier, unsigned long pm_event, void *v) { switch (pm_event) { case PM_SUSPEND_PREPARE: mutex_lock(&thread_lock); in_suspend_prepared = true; if(nr_sleep_prepare_cpus > 1) { pr_info("%s, %d : dynamic_hotplug CMD_SLEEP_PREPARE\n", __func__, __LINE__); if (!dynamic_hotplug(CMD_SLEEP_PREPARE)) prev_cmd = CMD_LOW_POWER; } else { if (!dynamic_hotplug(CMD_LOW_POWER)) prev_cmd = CMD_LOW_POWER; } exynos_dm_hotplug_disable(); if (dm_hotplug_task) { kthread_stop(dm_hotplug_task); dm_hotplug_task = NULL; } mutex_unlock(&thread_lock); break; case PM_POST_SUSPEND: mutex_lock(&thread_lock); exynos_dm_hotplug_enable(); dm_hotplug_task = kthread_create(on_run, NULL, "thread_hotplug"); if (IS_ERR(dm_hotplug_task)) { mutex_unlock(&thread_lock); pr_err("Failed in creation of thread.\n"); return -EINVAL; } in_suspend_prepared = false; wake_up_process(dm_hotplug_task); mutex_unlock(&thread_lock); break; } return NOTIFY_OK; }
static void ddump_percpu_thread_create(void) { // struct task_struct *ddump_thread_helper; int index = 0, order = 1; int cpu = 0; // need to figure out how to bind CPU struct task_struct *tmp_thread; for (; index < HELPERS ; index++, cpu++, order++) { // if we have used all cpus, stop if (cpu == ddump_nr_cpus) { break; } // we don't want to assign any helper to the current cpu if (cpu == ddump_current_cpu) { cpu++; } tmp_thread = kthread_create(ddump_percpu_thread, (void *)(long)index, "ddump_helper/%d", cpu); printk("James kthread %p\n", tmp_thread); ddump_thread_helper[index].cp_thread = tmp_thread; ddump_thread_helper[index].cp_order = order; // bind thread to the cpu if (likely(!IS_ERR(ddump_thread_helper[index].cp_thread))) { ddump_thread_helper[index].cp_cpu = cpu; //kthread_bind(tmp_thread, cpu); } else { // cant create thread // in real case, do single thread panic("CANT create ddump helper\n"); } wake_up_process(tmp_thread); } max_helpers = index; }
/** * This function, called by the idle process (within 'idleproc_run'), creates the * process commonly refered to as the "init" process, which should have PID 1. * * The init process should contain a thread which begins execution in * initproc_run(). * * @return a pointer to a newly created thread which will execute * initproc_run when it begins executing */ static kthread_t * initproc_create(void) { proc_t *process1=proc_create("Init_process"); KASSERT(process1!=NULL); dbg(DBG_INIT,"(GRADING1 1.b) Init Process created successfully\n" ); kthread_t *thread1=kthread_create(process1,initproc_run,1,(void*)1); KASSERT(PID_INIT == process1->p_pid); dbg(DBG_INIT,"(GRADING1 1.b) Init process's pid assigned properly\n"); KASSERT(thread1 != NULL); dbg(DBG_INIT,"(GRADING1 1.b) Init process's thread created successfully\n"); /* dbg(DBG_INIT,"thread1_returned");*/ return thread1; }
/** * This function is called from kmain, however it is not running in a * thread context yet. It should create the idle process which will * start executing idleproc_run() in a real thread context. To start * executing in the new process's context call context_make_active(), * passing in the appropriate context. This function should _NOT_ * return. * * Note: Don't forget to set curproc and curthr appropriately. * * @param arg1 the first argument (unused) * @param arg2 the second argument (unused) */ static void * bootstrap(int arg1, void *arg2) { /* necessary to finalize page table information */ pt_template_init(); /* Create idle process and idle thread */ curproc = proc_create("idle"); curthr = kthread_create(curproc, (kthread_func_t) idleproc_run, NULL, NULL); dbg_print("Created idle proc and thread\n"); /* Make idle thread the active context */ context_make_active(&curthr->kt_ctx); /* NOT_YET_IMPLEMENTED("PROCS: bootstrap"); */ panic("weenix returned to bootstrap()!!! BAD!!!\n"); return NULL; }
static void htckovsky_oj_start_polling(void) { struct task_struct *nthread; mutex_lock(&htckovsky_oj.lock); if (htckovsky_oj.task) { goto done; } nthread = kthread_create(htckovsky_oj_thread, NULL, "oj_thread"); if (!nthread) { pr_err(MODULE_NAME": failed to start OJ refresh thread\n"); goto done; } wake_up_process(nthread); htckovsky_oj.task = nthread; done: mutex_unlock(&htckovsky_oj.lock); }
/** * This function is called from kmain, however it is not running in a * thread context yet. It should create the idle process which will * start executing idleproc_run() in a real thread context. To start * executing in the new process's context call context_make_active(), * passing in the appropriate context. This function should _NOT_ * return. * * Note: Don't forget to set curproc and curthr appropriately. * * @param arg1 the first argument (unused) * @param arg2 the second argument (unused) */ static void *bootstrap(int arg1, void *arg2) { /* necessary to finalize page table information */ pt_template_init(); char name[]="IDLE"; curproc=proc_create(name); KASSERT(curproc != NULL && "Could not create Idle process"); /* make sure that the "idle" process has been created successfully */ KASSERT(curproc->p_pid == PID_IDLE); KASSERT(PID_IDLE == curproc->p_pid && "Process created is not Idle"); curthr=kthread_create(curproc,idleproc_run,arg1,arg2); KASSERT(curthr != NULL && "Could not create thread for Idle process"); context_make_active(&(curthr->kt_ctx)); NOT_YET_IMPLEMENTED("PROCS: bootstrap"); panic("weenix returned to bootstrap()!!! BAD!!!\n"); return NULL; }
/* begin: add by wufan w00163571 for use kernel thread kick watchdog 20121201 */ static int k3_wdt_kick_start_oncpu(int cpu) { int err = 0; struct task_struct *p = per_cpu(k3wdt_kick_watchdog_task, cpu); if (!p) { p = kthread_create(k3wdt_kick_threadfunc, (void *)(unsigned long)cpu, "k3wdt_kicktask/%d", cpu); if (IS_ERR(p)) { printk(KERN_ERR "softlockup watchdog for %i failed\n", cpu); err = PTR_ERR(p); goto out; } kthread_bind(p, cpu); per_cpu(k3wdt_kick_watchdog_task, cpu) = p; wake_up_process(p); } out: return err; }
int ep952_thread_enable(void) { int err; if(ep952_task) return 0; ep952_task = kthread_create(ep952_thread, NULL, "ep952_task"); if(IS_ERR(ep952_task)){ printk("Unable to start kernel thread./n"); err = PTR_ERR(ep952_task); ep952_task = NULL; return err; } else { wake_up_process(ep952_task); } return 0; }
/* returns 0 for failure, 1 for success */ int uisthread_start(struct uisthread_info *thrinfo, int (*threadfn)(void *), void *thrcontext, char *name) { thrinfo->should_stop = 0; /* used to stop the thread */ init_completion(&thrinfo->has_stopped); thrinfo->task = kthread_create(threadfn, thrcontext, name, NULL); if (IS_ERR(thrinfo->task)) { thrinfo->id = 0; return 0; /* failure */ } thrinfo->id = thrinfo->task->pid; wake_up_process(thrinfo->task); LOGINF("started thread pid:%d\n", thrinfo->id); return 1; }
int vc_start_streaming( struct vb2_queue * q, unsigned int count ) { struct vc_device * dev; PRINT_DEBUG( "start streaming vb called, count = %d\n", count); dev = q->drv_priv; //Try to start kernel thread dev->sub_thr_id = kthread_create( submitter_thread, dev, "vcam_submitter"); if( !dev->sub_thr_id ){ PRINT_ERROR("Failed to create kernel thread\n"); return -ECANCELED; } wake_up_process(dev->sub_thr_id); return 0; }
static int __init init_thread(void) { printk(KERN_INFO "thread-1: Creating Thread\n"); thread_st = kthread_create(thread_fn, NULL, "thread-1"); if (thread_st) { /* * Thread created and not in running state. * Call wake_up_process to run it. */ printk(KERN_INFO "thread-1: Thread Created successfully\n"); } else { printk(KERN_ERR "thread-1: Thread creation failed\n"); } return 0; }
VCOS_STATUS_T vcos_thread_create(VCOS_THREAD_T *thread, const char *name, VCOS_THREAD_ATTR_T *attrs, VCOS_THREAD_ENTRY_FN_T entry, void *arg) { VCOS_STATUS_T st; struct task_struct *kthread; memset(thread, 0, sizeof(*thread)); thread->magic = VCOS_THREAD_MAGIC; strlcpy( thread->name, name, sizeof( thread->name )); thread->legacy = attrs ? attrs->legacy : 0; thread->entry = entry; thread->arg = arg; if (!name) { vcos_assert(0); return VCOS_EINVAL; } st = vcos_semaphore_create(&thread->wait, NULL, 0); if (st != VCOS_SUCCESS) { return st; } st = vcos_semaphore_create(&thread->suspend, NULL, 0); if (st != VCOS_SUCCESS) { return st; } /*required for event groups */ vcos_timer_create(&thread->_timer.timer, thread->name, NULL, NULL); kthread = kthread_create((int (*)(void *))vcos_thread_wrapper, (void*)thread, name); vcos_assert(kthread != NULL); set_user_nice(kthread, attrs->ta_priority); thread->thread.thread = kthread; wake_up_process(kthread); return VCOS_SUCCESS; }
void taskq_create_thread(void *arg) { struct taskq *tq = arg; int rv; mtx_enter(&tq->tq_mtx); switch (tq->tq_state) { case TQ_S_DESTROYED: mtx_leave(&tq->tq_mtx); free(tq, M_DEVBUF, sizeof(*tq)); return; case TQ_S_CREATED: tq->tq_state = TQ_S_RUNNING; break; default: panic("unexpected %s tq state %d", tq->tq_name, tq->tq_state); } do { tq->tq_running++; mtx_leave(&tq->tq_mtx); rv = kthread_create(taskq_thread, tq, NULL, tq->tq_name); mtx_enter(&tq->tq_mtx); if (rv != 0) { printf("unable to create thread for \"%s\" taskq\n", tq->tq_name); tq->tq_running--; /* could have been destroyed during kthread_create */ if (tq->tq_state == TQ_S_DESTROYED && tq->tq_running == 0) wakeup_one(&tq->tq_running); break; } } while (tq->tq_running < tq->tq_nthreads); mtx_leave(&tq->tq_mtx); }
static int __init tfw_bmb_init(void) { long i; volatile unsigned long ts_start; struct task_struct *task; int r = 0; if (tfw_addr_pton(&TFW_STR_FROM(server), &bmb_server_address)) { TFW_ERR("Unable to parse server's address: %s", server); return -EINVAL; } TFW_LOG("Started bomber module, server's address is %s\n", server); if (tfw_bmb_alloc()) return -ENOMEM; ts_start = jiffies; for (i = 0; i < nthreads; i++) { task = kthread_create(tfw_bmb_worker, (void *)i, "worker"); if (IS_ERR_OR_NULL(task)) { TFW_ERR("Unable to create worker\n"); r = -EINVAL; goto stop_threads; } bmb_task[i].task_struct = task; } atomic_set(&bmb_threads, nthreads); for (i = 0; i < nthreads; i++) wake_up_process(bmb_task[i].task_struct); wait_event_interruptible(bmb_task_wq, !atomic_read(&bmb_threads)); tfw_bmb_report(ts_start); stop_threads: tfw_bmb_stop_threads(); tfw_bmb_free(); return r; }
/*! initialize thread structures and create idle thread */ void kthreads_init () { list_init ( &all_threads ); list_init ( &procs ); active_thread = NULL; ksched_init (); /* initially create 'idle thread' */ kernel_proc.prog = NULL; kernel_proc.stack_pool = NULL; /* use kernel pool */ kernel_proc.m.start = NULL; kernel_proc.m.size = (size_t) 0xffffffff; (void) kthread_create ( idle_thread, NULL, 0, SCHED_FIFO, 0, NULL, NULL, 0, &kernel_proc ); kthreads_schedule (); }
int do_faber(kshell_t *kshell, int argc, char **argv) { /* * Shouldn't call a test function directly. * It's best to invoke it in a separate kernel process. */ proc_t *new_proc; kthread_t *new_thr; new_proc = proc_create("new"); new_thr = kthread_create(new_proc, faber_thread_test, 0, NULL); sched_make_runnable(new_thr); int status; pid_t child = do_waitpid(-1, 0, &status); return 0; }
int disp_init_irq(void) { static char * device_name="mtk_disp"; if(irq_init) return 0; irq_init = 1; DDPMSG("disp_init_irq\n"); //create irq log thread init_waitqueue_head(&disp_irq_log_wq); disp_irq_log_task = kthread_create(disp_irq_log_kthread_func, NULL, "ddp_irq_log_kthread"); if (IS_ERR(disp_irq_log_task)) { DDPERR(" can not create disp_irq_log_task kthread\n"); } //wake_up_process(disp_irq_log_task); return 0; }
int hang_detect_init(void) { struct task_struct *hd_thread ; //struct proc_dir_entry *de = create_proc_entry(HD_PROC, 0664, 0); unsigned char *name = "hang_detect" ; printk("[Hang_Detect] Initialize proc\n"); //de->read_proc = hd_proc_cmd_read; //de->write_proc = hd_proc_cmd_write; printk("[Hang_Detect] create hang_detect thread\n"); hd_thread = kthread_create(hang_detect_thread, NULL, name); wake_up_process(hd_thread); return 0 ; }
void inline GetElapsedTime(void) { int i; void* data = NULL; for (i = 0; i < ITERATIONS; i++) { // Data required for thread creation. static struct task_struct *thread; char our_thread[8]="thread"; struct timespec ts_start; getnstimeofday(&ts_start); data = &ts_start; printk(KERN_CRIT "Thread create\n"); thread = kthread_create(thread_fn,data,our_thread); if(thread) { wake_up_process(thread); } kthread_stop(thread); } return; }
DECLHIDDEN(int) rtThreadNativeCreate(PRTTHREADINT pThreadInt, PRTNATIVETHREAD pNativeThread) { int rc; struct proc *pProc; #if __FreeBSD_version >= 800002 rc = kproc_create(rtThreadNativeMain, pThreadInt, &pProc, RFHIGHPID, 0, "%s", pThreadInt->szName); #else rc = kthread_create(rtThreadNativeMain, pThreadInt, &pProc, RFHIGHPID, 0, "%s", pThreadInt->szName); #endif if (!rc) { *pNativeThread = (RTNATIVETHREAD)FIRST_THREAD_IN_PROC(pProc); rc = VINF_SUCCESS; } else rc = RTErrConvertFromErrno(rc); return rc; }
static int start_kicker(void) { int i; wk_cpu_update_bit_flag(0, 1); for (i = 0; i < CPU_NR; i++) { wk_tsk[i] = kthread_create(kwdt_thread, (void *)(unsigned long)i, "wdtk-%d", i); if (IS_ERR(wk_tsk[i])) { int ret = PTR_ERR(wk_tsk[i]); wk_tsk[i] = NULL; return ret; } /* wk_cpu_update_bit_flag(i,1); */ wk_start_kick_cpu(i); } g_kicker_init = 1; printk("[WDK] WDT start kicker done\n"); return 0; }
static void pagezero_start(void __unused *arg) { int error; error = kthread_create(vm_pagezero, NULL, &pagezero_proc, RFSTOPPED, 0, "pagezero"); if (error) panic("pagezero_start: error %d\n", error); /* * We're an idle task, don't count us in the load. */ PROC_LOCK(pagezero_proc); pagezero_proc->p_flag |= P_NOLOAD; PROC_UNLOCK(pagezero_proc); mtx_lock_spin(&sched_lock); setrunqueue(FIRST_THREAD_IN_PROC(pagezero_proc), SRQ_BORING); mtx_unlock_spin(&sched_lock); }
int blockdev_register(struct inode *node, struct blockctl *ctl) { struct blockdev *bd = kmalloc(sizeof(struct blockdev)); mutex_create(&ctl->cachelock, 0); hash_create(&ctl->cache, 0, 0x4000); mpscq_create(&ctl->queue, 1000); bd->ctl = ctl; int num = atomic_fetch_add(&next_minor, 1); node->devdata = bd; node->phys_dev = GETDEV(block_major, num); node->kdev = dm_device_get(block_major); kthread_create(&ctl->elevator, "[kelevator]", 0, block_elevator_main, node); char name[64]; snprintf(name, 64, "/dev/bcache-%d", num); kerfs_register_parameter(name, ctl, 0, 0, kerfs_block_cache_report); return num; }
void rumptest_tsleep() { struct lwp *notbigl[NTHREADS]; int rv, i; mutex_init(&mymtx, MUTEX_DEFAULT, IPL_NONE); for (i = 0; i < NTHREADS; i++) { rv = kthread_create(PRI_NONE, KTHREAD_MUSTJOIN| KTHREAD_MPSAFE, NULL, tinythread, (void *)(uintptr_t)i, ¬bigl[i], "nb"); if (rv) panic("thread create failed: %d", rv); } for (i = 0; i < NTHREADS; i++) { kthread_join(notbigl[i]); } }
static int completion_load(void) { pr_info("%s\n", __func__); my_thread = kthread_create(kthread_func, NULL, "%s", "udemy kthread"); if (IS_ERR(my_thread)) { pr_info("%s: cannot create kernel thread\n", __func__); return PTR_ERR(my_thread); } /* Protect my_thread from being freed by the kernel */ get_task_struct(my_thread); /* Kick the thread */ wake_up_process(my_thread); return 0; }