예제 #1
0
/*
** Usage: thread_result  ID
**
** Wait on the most recent operation to complete, then return the
** result code from that operation.
*/
static int tcl_thread_result(
  void *NotUsed,
  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
  int argc,              /* Number of arguments */
  const char **argv      /* Text of each argument */
){
  int i;
  const char *zName;

  if( argc!=2 ){
    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
       " ID", 0);
    return TCL_ERROR;
  }
  i = parse_thread_id(interp, argv[1]);
  if( i<0 ) return TCL_ERROR;
  if( !threadset[i].busy ){
    Tcl_AppendResult(interp, "no such thread", 0);
    return TCL_ERROR;
  }
  thread_wait(&threadset[i]);
  switch( threadset[i].rc ){
    case SQLITE_OK:         zName = "SQLITE_OK";          break;
    case SQLITE_ERROR:      zName = "SQLITE_ERROR";       break;
    case SQLITE_PERM:       zName = "SQLITE_PERM";        break;
    case SQLITE_ABORT:      zName = "SQLITE_ABORT";       break;
    case SQLITE_BUSY:       zName = "SQLITE_BUSY";        break;
    case SQLITE_LOCKED:     zName = "SQLITE_LOCKED";      break;
    case SQLITE_NOMEM:      zName = "SQLITE_NOMEM";       break;
    case SQLITE_READONLY:   zName = "SQLITE_READONLY";    break;
    case SQLITE_INTERRUPT:  zName = "SQLITE_INTERRUPT";   break;
    case SQLITE_IOERR:      zName = "SQLITE_IOERR";       break;
    case SQLITE_CORRUPT:    zName = "SQLITE_CORRUPT";     break;
    case SQLITE_FULL:       zName = "SQLITE_FULL";        break;
    case SQLITE_CANTOPEN:   zName = "SQLITE_CANTOPEN";    break;
    case SQLITE_PROTOCOL:   zName = "SQLITE_PROTOCOL";    break;
    case SQLITE_EMPTY:      zName = "SQLITE_EMPTY";       break;
    case SQLITE_SCHEMA:     zName = "SQLITE_SCHEMA";      break;
    case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT";  break;
    case SQLITE_MISMATCH:   zName = "SQLITE_MISMATCH";    break;
    case SQLITE_MISUSE:     zName = "SQLITE_MISUSE";      break;
    case SQLITE_NOLFS:      zName = "SQLITE_NOLFS";       break;
    case SQLITE_AUTH:       zName = "SQLITE_AUTH";        break;
    case SQLITE_FORMAT:     zName = "SQLITE_FORMAT";      break;
    case SQLITE_RANGE:      zName = "SQLITE_RANGE";       break;
    case SQLITE_ROW:        zName = "SQLITE_ROW";         break;
    case SQLITE_DONE:       zName = "SQLITE_DONE";        break;
    default:                zName = "SQLITE_Unknown";     break;
  }
  Tcl_AppendResult(interp, zName, 0);
  return TCL_OK;
}
예제 #2
0
static int relayTee(Connection *Conn,int fcbsize,int fsbsize,int server){
	int scerr,cserr;
	XFlash Xf;

	fprintf(stderr,"---relayTee\n");
	Xf.xf_Conn = Conn;
	Xf.xf_xfsockfd = -1;
	Xf.xf_xfsockfp = 0;

	if( server ){
		Xf.xf_cstid = thread_fork(0,0,"XFlash-CS",(IFUNCP)XCS,&Xf);
		Xf.xf_sctid = thread_fork(0,0,"XFlash-SC",(IFUNCP)XSC,&Xf,fsbsize);
		Xf.xf_fptid = thread_fork(0,0,"XFlash-Player",(IFUNCP)XFP,&Xf,server);
		cserr = thread_wait(Xf.xf_cstid,0);
		scerr = thread_wait(Xf.xf_sctid,1);
		sv1log("---- XFinished %X/%d %X/%d\n",
			PRTID(Xf.xf_cstid),cserr,PRTID(Xf.xf_sctid),scerr);
	}else{
		XFP(&Xf,server);
	}
	return 0;
}
예제 #3
0
int main()
{
    /*用默认属性初始化互斥锁*/
    pthread_mutex_init(&mut,NULL);
    printf("我是主函数哦,我正在创建线程,呵呵\n");
    thread_create();
    printf("我是主函数哦,我正在等待线程完成任务阿,呵呵\n");
    thread_wait();
    printf("两个线程已经结束\n");
    sleep(5);
    printf("结束\n");
    return 0;
}
예제 #4
0
static void*
event_loop(void* arg) {
	event_block_t* block;
	event_t* event = 0;
	FOUNDATION_UNUSED(arg);

	event_stream_set_beacon(system_event_stream(), &thread_self()->beacon);

	while (!_test_should_terminate) {
		block = event_stream_process(system_event_stream());
		event = 0;
		while ((event = event_next(block, event))) {
			switch (event->id) {
			case FOUNDATIONEVENT_START:
#if FOUNDATION_PLATFORM_IOS || FOUNDATION_PLATFORM_ANDROID || FOUNDATION_PLATFORM_PNACL
				log_debug(HASH_TEST, STRING_CONST("Application start event received"));
				_test_should_start = true;
#endif
				break;

			case FOUNDATIONEVENT_TERMINATE:
#if FOUNDATION_PLATFORM_IOS || FOUNDATION_PLATFORM_ANDROID || FOUNDATION_PLATFORM_PNACL
				log_debug(HASH_TEST, STRING_CONST("Application stop/terminate event received"));
				_test_should_terminate = true;
				break;
#else
				log_warn(HASH_TEST, WARNING_SUSPICIOUS, STRING_CONST("Terminating tests due to event"));
				process_exit(-2);
#endif

			case FOUNDATIONEVENT_FOCUS_GAIN:
				_test_have_focus = true;
				break;

			case FOUNDATIONEVENT_FOCUS_LOST:
				_test_have_focus = false;
				break;

			default:
				break;
			}

			test_event(event);
		}
		thread_wait();
	}

	log_debug(HASH_TEST, STRING_CONST("Application event thread exiting"));

	return 0;
}
예제 #5
0
파일: eclBarr.cpp 프로젝트: GMAC-lib/gmac
int main(int argc, char *argv[])
{
	thread_t *nThread;
	unsigned n = 0;
	gmactime_t st, en;

	setParam<unsigned>(&nIter, nIterStr, nIterDefault);
	setParam<unsigned>(&vecSize, vecSizeStr, vecSizeDefault);

	barrier_init(&barr, nIter + 1);

	assert(eclCompileSource(kernel) == eclSuccess);

	nThread = (thread_t *)malloc(nIter * sizeof(thread_t));
	unsigned *ids = (unsigned *)malloc(nIter * sizeof(unsigned));

	getTime(&st);
	for(n = 0; n < nIter; n++) {
		ids[n] = n;
		nThread[n] = thread_create(check, &ids[n]);
	}

	// Alloc & init input data
	ecl_error ret = eclMalloc((void **)&a, vecSize * sizeof(float));
	assert(ret == eclSuccess);

	for(n = 0; n < 32; n++) {
		// Call the kernel
		size_t globalSize = vecSize;
		ecl_kernel kernel;
		assert(eclGetKernel("accum", &kernel) == eclSuccess);
		assert(eclSetKernelArgPtr(kernel, 0, a) == eclSuccess);
		assert(eclCallNDRange(kernel, 1, NULL, &globalSize, NULL) == eclSuccess);
		barrier_wait(&barr);

		// Wait for the threads to do stuff
		barrier_wait(&barr);
	}

	for(n = 0; n < nIter; n++) {
		thread_wait(nThread[n]);
	}

	getTime(&en);
	printTime(&st, &en, "Total: ", "\n");

	free(ids);
	free(nThread);

	return 0;
}
예제 #6
0
void *sensor_thread(void *args)
{
    while(true) {
    	thread_wait(5000);
    	/*
    	 * read_and_send_sensor_event executes a command
    	 * (default here is a filtered output of lm-sensors)
    	 * then sends its output as a port event message
    	 */
    	if (sensor_active)
    		read_and_send_sensor_event();
    }
    return NULL;
}
예제 #7
0
파일: kozos.c 프로젝트: forest1040/kozos
static void call_functions(kz_syscall_type_t type, kz_syscall_param_t *p)
{
  /* システム・コールの実行中にcurrentが書き換わるので注意 */
  switch (type) {
  case KZ_SYSCALL_TYPE_RUN: /* kz_run() */
    p->un.run.ret = thread_run(p->un.run.func, p->un.run.name,
			       p->un.run.priority, p->un.run.stacksize,
			       p->un.run.argc, p->un.run.argv);
    break;
  case KZ_SYSCALL_TYPE_EXIT: /* kz_exit() */
    /* TCBが消去されるので,戻り値を書き込んではいけない */
    thread_exit();
    break;
  case KZ_SYSCALL_TYPE_WAIT: /* kz_wait() */
    p->un.wait.ret = thread_wait();
    break;
  case KZ_SYSCALL_TYPE_SLEEP: /* kz_sleep() */
    p->un.sleep.ret = thread_sleep();
    break;
  case KZ_SYSCALL_TYPE_WAKEUP: /* kz_wakeup() */
    p->un.wakeup.ret = thread_wakeup(p->un.wakeup.id);
    break;
  case KZ_SYSCALL_TYPE_GETID: /* kz_getid() */
    p->un.getid.ret = thread_getid();
    break;
  case KZ_SYSCALL_TYPE_CHPRI: /* kz_chpri() */
    p->un.chpri.ret = thread_chpri(p->un.chpri.priority);
    break;
  case KZ_SYSCALL_TYPE_KMALLOC: /* kz_kmalloc() */
    p->un.kmalloc.ret = thread_kmalloc(p->un.kmalloc.size);
    break;
  case KZ_SYSCALL_TYPE_KMFREE: /* kz_kmfree() */
    p->un.kmfree.ret = thread_kmfree(p->un.kmfree.p);
    break;
  case KZ_SYSCALL_TYPE_SEND: /* kz_send() */
    p->un.send.ret = thread_send(p->un.send.id,
				 p->un.send.size, p->un.send.p);
    break;
  case KZ_SYSCALL_TYPE_RECV: /* kz_recv() */
    p->un.recv.ret = thread_recv(p->un.recv.id,
				 p->un.recv.sizep, p->un.recv.pp);
    break;
  case KZ_SYSCALL_TYPE_SETINTR: /* kz_setintr() */
    p->un.setintr.ret = thread_setintr(p->un.setintr.type,
				       p->un.setintr.handler);
    break;
  default:
    break;
  }
}
예제 #8
0
파일: serv.c 프로젝트: 130B848/JOS-labs
net_timer(uint32_t arg)
{
	struct timer_thread *t = (struct timer_thread *) arg;

	for (;;) {
		uint32_t cur = sys_time_msec();

		lwip_core_lock();
		t->func();
		lwip_core_unlock();

		thread_wait(0, 0, cur + t->msec);
	}
}
예제 #9
0
int main() {
    int arg = 100;
    printf(1, "Chillin' for %d tics.\n", arg);
    thread_create(&chill, (void *)&arg);
 
    int toc;
    int tic = tim();
    while((toc = tim()) < tic + 50);
 
    printf(1, "Just kidding! Chillin' for %d tics.\n", (arg = 500));
    thread_wait();
    printf(1, "\nChillin' complete.\n");
    exit();
}
예제 #10
0
파일: fncall.c 프로젝트: Jarlene/ADBI-1
/* Run given thread until it reaches address stopat. */
bool fncall_runtil(thread_t * thread, address_t stopat) {

    /* TODO: Be more verbose about errors. */
    insn_t          insn;
    insn_kind_t     kind;
    
    assert(!thread->state.slavemode);
    
    info("Running thread %s until it reaches %p (runtil).", str_thread(thread), (void *) stopat);
    
    thread->state.slavemode = true;
    
    kind = (stopat & 0x1) ? INSN_KIND_THUMB : INSN_KIND_ARM;
    if (!patch_read_insn_detect_kind(thread, stopat, &insn, &kind))
        goto fail;
        
    /* Patch instruction. */
    if (!patch_insn(thread, stopat, kind, get_breakpoint_insn(kind)))
        goto fail;
        
    thread_continue(thread, 0);
    
    while (1) {
        thread_wait(thread, false);
        
        if (thread->state.dead)
            goto fail;
            
        if ((thread->state.signo == SIGSEGV) || (thread->state.signo == SIGTRAP) || (thread->state.signo == SIGBUS)) {
            struct pt_regs regs;
            thread_get_regs(thread, &regs);
            if (arch_get_pc(&regs) == (stopat & 0xfffffffe)) {
                /* This is the signal we were waiting for. */
                break;
            }
        }
        
        warning("Unexpected signal %s received during runtil in thread %s. The signal will be delivered.",
                str_signal(thread->state.signo), str_thread(thread));

        dump_thread(thread);
        void callback(segment_t * segment) {
            verbose("%s\n", str_segment(segment));
        }
        segment_iter(thread->process, callback);

        /* Deliver the signal. */
        thread_continue(thread, 0);
    }
예제 #11
0
void fork_handler(int sig)
{
        change_sig(SIGUSR1, 1);
 	thread_wait(&current->thread.mode.skas.switch_buf, 
		    current->thread.mode.skas.fork_buf);
  	
	force_flush_all();
	if(current->thread.prev_sched == NULL)
		panic("blech");

	schedule_tail(current->thread.prev_sched);
	current->thread.prev_sched = NULL;

	userspace(&current->thread.regs.regs);
}
예제 #12
0
int main()
{
    /*用默认属性初始化互斥锁*/
    // int a=1;long int b=2;//linux 32下int与long int均为4字节
    // printf("%d\n", sizeof(a));
    // printf("%d\n", sizeof(b));
    pthread_mutex_init(&mut,NULL);

    printf("我是主函数哦,我正在创建线程,呵呵\n");
    thread_create();
    printf("我是主函数哦,我正在等待线程完成任务阿,呵呵\n");
    thread_wait();

    return 0;
}
예제 #13
0
void usb_close(void)
{
    unsigned int thread = usb_thread_entry;
    usb_thread_entry = 0;

    if (thread == 0)
        return;

#ifndef USB_STATUS_BY_EVENT
    tick_remove_task(usb_tick);
#endif
    usb_monitor_enabled = false;

    queue_post(&usb_queue, USB_QUIT, 0);
    thread_wait(thread);
}
예제 #14
0
파일: wchan.c 프로젝트: plurmiscuous/JinxOS
/*
 * Yield the cpu to another process, and go to sleep, on the specified
 * wait channel WC, whose associated spinlock is LK. Calling wakeup on
 * the channel will make the thread runnable again. The spinlock must
 * be locked. The call to thread_switch unlocks it; we relock it
 * before returning.
 */
void
wchan_sleep(struct wchan* wc, struct spinlock* lk) {
    asm volatile ("mfence" ::: "memory");
    /* may not sleep in an interrupt handler */
    assert(!thisthread->in_interrupt);

    /* must hold the spinlock */
    assert(spinlock_held(lk));

    /* must not hold other spinlocks */
    assert(thiscpu->spinlocks == 1);

    thread_wait(wc, lk);

    spinlock_acquire(lk);
}
예제 #15
0
파일: kozos.c 프로젝트: yku/EmbeddedOS
static void call_functions(kz_syscall_type_t type, kz_syscall_param_t *p)
{
    switch(type){
        case KZ_SYSCALL_TYPE_RUN:
            p->un.run.ret = thread_run(p->un.run.func, p->un.run.name,
                                       p->un.run.priority,
                                       p->un.run.stacksize,
                                       p->un.run.argc, p->un.run.argv);
            break;
        case KZ_SYSCALL_TYPE_EXIT:
            thread_exit();
            break;
        case KZ_SYSCALL_TYPE_WAIT:
            p->un.wait.ret = thread_wait();
            break;
        case KZ_SYSCALL_TYPE_SLEEP:
            p->un.sleep.ret = thread_sleep();
            break;
        case KZ_SYSCALL_TYPE_WAKEUP:
            p->un.wakeup.ret = thread_wakeup(p->un.wakeup.id);
            break;
        case KZ_SYSCALL_TYPE_GETID:
            p->un.getid.ret = thread_getid();
            break;
        case KZ_SYSCALL_TYPE_CHPRI:
            p->un.chpri.ret = thread_chpri(p->un.chpri.priority);
            break;
        case KZ_SYSCALL_TYPE_KMALLOC:
            p->un.kmalloc.ret = thread_kmalloc(p->un.kmalloc.size);
            break;
        case KZ_SYSCALL_TYPE_KMFREE:
            p->un.kmfree.ret = thread_kmfree(p->un.kmfree.p);
            break;
        case KZ_SYSCALL_TYPE_SEND:
            p->un.send.ret = thread_send(p->un.send.id,
                                         p->un.send.size,
                                         p->un.send.p);
            break;
        case KZ_SYSCALL_TYPE_RECV:
            p->un.recv.ret = thread_recv(p->un.recv.id,
                                         p->un.recv.sizep,
                                         p->un.recv.pp);
            break;
        default:
            break;
    }
}
예제 #16
0
int main (void) {

  mutex_init(&lock);
  int i, rc;
  int arg[10] = {100,200,300,400,500,600,700,800,900,1000};
  for (i=0; i<1; i++) {
    rc = thread_create (&thread_func, (void*)  (arg));
    mutex_lock(&lock);
    printf (1, "created thread with pid %d\n", rc);
    mutex_unlock(&lock);
  }

  thread_wait();

  printf(1,"parent exiting\n");
  exit();
}
예제 #17
0
int waitthreads(){
	int ix;
	int tid;
	int fin = 0;
	int mytid = getthreadid();

	for( ix = 0; ix < elnumof(threads); ix++ ){
		if( tid = threads[ix].t_id ){
			if( tid != mytid ){
				if( thread_wait(tid,1) == 0 ){
					fin++;
				}
			}
		}
	}
	return fin;
}
예제 #18
0
파일: mem.c 프로젝트: treewojima/geekos
/*
 * Allocate a buffer in the kernel heap.
 * Suspends calling thread until enough memory
 * is available to satisfy the request.
 * The returned buffer is filled with zeroes.
 *
 * Parameters:
 *   size - size in bytes of buffer to allocate
 *
 * Returns:
 *   pointer to allocated, zero-filled buffer
 */
void *mem_alloc(size_t size)
{
    extern void *malloc(size_t);
    void *buf;
    bool iflag;

    iflag = int_begin_atomic();
    while ((buf = malloc(size)) == 0) {
        thread_wait(&s_heap_waitqueue);
    }
    int_end_atomic(iflag);

    /* fill buffer with zeroes */
    memset(buf, '\0', size);

    return buf;
}
예제 #19
0
void fork_handler(int sig)
{
        change_sig(SIGUSR1, 1);
 	thread_wait(&current->thread.mode.skas.switch_buf, 
		    current->thread.mode.skas.fork_buf);
  	
	force_flush_all();
	if(current->thread.prev_sched == NULL)
		panic("blech");

	schedule_tail(current->thread.prev_sched);
	current->thread.prev_sched = NULL;

	/* Handle any immediate reschedules or signals */
	interrupt_end();
	userspace(&current->thread.regs.regs);
}
예제 #20
0
파일: ipc_target.c 프로젝트: 0xffea/gnumach
struct Act *
ipc_target_block(struct ipc_target *ipt)
{
	struct Act *act;

	ipt_lock(ipt);
	while ((act = ipt->ipt_acts) == 0) {
		/* XXX mp unsafe */
		ipt->ipt_waiting = 1;
		ipt_unlock(ipt);
		thread_wait((int)&ipt->ipt_acts, FALSE);
		ipt_lock(ipt);
	}
	ipt->ipt_acts = act->ipt_next;
	ipt_unlock(ipt);

	return act;
}
예제 #21
0
void* thread_func (void *arg) {
  int j;
  int *ptr;
  ptr = (int *) arg;
  mutex_lock(&lock);
  printf(1, "I am thread with pid %d and now I'll create 10 more threads and pass the array\n", getpid());
  mutex_unlock(&lock);
  for (j=0; j<10; j++) {
    int rc = thread_create (&thread2_func, (void *)(ptr+j));
    mutex_lock(&lock);
    printf (1, "created thread with pid %d\n", rc);
    mutex_unlock(&lock);
  }
  thread_wait();
  mutex_lock(&lock);
  printf(1, "exiting from thread_func\n");
  mutex_unlock(&lock);
  exit();
}
예제 #22
0
파일: mem.c 프로젝트: treewojima/geekos
/*
 * Allocate a physical memory frame.
 * Suspends calling thread until a frame is available.
 */
struct frame *mem_alloc_frame(frame_state_t initial_state, int initial_refcount)
{
    struct frame *frame;
    bool iflag;

    iflag = int_begin_atomic();

    while (frame_list_is_empty(&s_freelist)) {
        thread_wait(&s_frame_waitqueue);
    }

    frame = frame_list_remove_first(&s_freelist);
    frame->state = initial_state;
    frame->refcount = initial_refcount;

    int_end_atomic(iflag);

    return frame;
}
예제 #23
0
파일: cvtest.c 프로젝트: jakefriedman/cs637
void main() {
    loops = 5;
    numconsumers = 3;

    mutex_init(&mutex);
    cond_init(&fill);
    cond_init(&empty);
//printf(1,"lock after init %d\n",(&mutex)->lock);
    int cons[numconsumers];
    int * arg = malloc(sizeof(int));
    *arg = 1; 
    // create threads (producer and consumers)
    int prod = thread_create(producer, arg);
    int i;
    for (i = 0; i < numconsumers; i++)
	*arg = i;
        cons[i] = thread_create(consumer, arg);
    // wait for producer and consumers to finish
    thread_wait();
    exit();
}
예제 #24
0
void net_client_destroy (NetClient *client)
{
        if (!client) {
                error (InvalidArgument);
                return;
        }
        if (client->epoll) {
                if (!net_client_epoll_stop (client->epoll)) {
                        error (FunctionCall);
                        return;
                }
        }
        if (client->thread) {
                thread_wait (client->thread);
                thread_destroy (client->thread);
        }
        if (client->epoll) {
                net_client_epoll_deallocate (client->epoll);
        }
        memory_destroy (client);
}
예제 #25
0
파일: wait.c 프로젝트: chenpoyang/icedy
int main(int argc, char *argv[])
{
	struct tm *cur_time;
	time_t begin, end;

	/* begin: time interval from 1970-01-01::00:00:00 */
	begin = time(&begin);
	cur_time = localtime(&begin);
	printf("begin time is %d:%d:%d\r\n", 
			cur_time->tm_hour, cur_time->tm_min, cur_time->tm_sec);

	/* wait for a while */
	thread_wait(5);

	/* end: time interval from 1970-01-01::00:00:00 */
	end = time(&end);
	cur_time = localtime(&end);
	printf("end time is %d:%d:%d\r\n", 
			cur_time->tm_hour, cur_time->tm_min, cur_time->tm_sec);

	return 0;
}
예제 #26
0
파일: test4.c 프로젝트: 1018824313/sqlite
/*
** Usage:  thread_wait ID
**
** Wait on thread ID to reach its idle state.
*/
static int tcl_thread_wait(
  void *NotUsed,
  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
  int argc,              /* Number of arguments */
  const char **argv      /* Text of each argument */
){
  int i;

  if( argc!=2 ){
    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
       " ID", 0);
    return TCL_ERROR;
  }
  i = parse_thread_id(interp, argv[1]);
  if( i<0 ) return TCL_ERROR;
  if( !threadset[i].busy ){
    Tcl_AppendResult(interp, "no such thread", 0);
    return TCL_ERROR;
  }
  thread_wait(&threadset[i]);
  return TCL_OK;
}
예제 #27
0
파일: linux.c 프로젝트: Laukien/test
int main() {
	THREAD *t = thread_new();
	thread_setFunction(t, sub, NULL);
	thread_run(t);

	int i;
	for (i = 0; i < 10; ++i) {
		if (thread_isRunning(t)) {
			printf ("Thread 1 is still running\n");
			sleep(1);
		}
	}

	thread_wait(t);

	printf("Thread 1 has the status %d\n", thread_getStatus(t));

	printf("Thread 1 has the exit-code %d\n", thread_getExit(t));

	thread_free(t);
	return EXIT_SUCCESS;
}
예제 #28
0
void new_thread_handler(int sig)
{
	int (*fn)(void *), n;
	void *arg;

	fn = current->thread.request.u.thread.proc;
	arg = current->thread.request.u.thread.arg;
	change_sig(SIGUSR1, 1);
	thread_wait(&current->thread.mode.skas.switch_buf, 
		    current->thread.mode.skas.fork_buf);

	if(current->thread.prev_sched != NULL)
		schedule_tail(current->thread.prev_sched);
	current->thread.prev_sched = NULL;

	/* The return value is 1 if the kernel thread execs a process,
	 * 0 if it just exits
	 */
	n = run_kernel_thread(fn, arg, &current->thread.exec_buf);
	if(n == 1)
		userspace(&current->thread.regs.regs);
	else do_exit(0);
}
예제 #29
0
/**
 * The entry point for the imap thread. It just go into the wait state and
 * then frees all resources when finished
 *
 * @param test
 */
static void imap_thread_entry(void *test)
{
	if (thread_parent_task_can_contiue())
	{
		thread_wait(NULL,NULL,NULL,0);

		imap_free(imap_server);
		free(imap_folder);
		free(imap_local_path);

		if (imap_connection)
		{
			tcp_disconnect(imap_connection);
			imap_connection = NULL;
		}

		if (imap_socket_lib_open)
		{
			close_socket_lib();
			imap_socket_lib_open = 0;
		}
	}
}
예제 #30
0
파일: main.cpp 프로젝트: def-/ServerStatus
int CMain::Run()
{
	if(m_Server.Init(this, m_Config.m_aBindAddr, m_Config.m_Port))
		return 1;

	if(ReadConfig())
		return 1;

	// Start JSON Update Thread
	m_JSONUpdateThreadData.m_ReloadRequired = 2;
	m_JSONUpdateThreadData.pClients = m_aClients;
	m_JSONUpdateThreadData.pConfig = &m_Config;
	void *LoadThread = thread_create(JSONUpdateThread, &m_JSONUpdateThreadData);
	//thread_detach(LoadThread);

	while(gs_Running)
	{
		if(gs_ReloadConfig)
		{
			if(ReadConfig())
				return 1;
			m_Server.NetBan()->UnbanAll();
			gs_ReloadConfig = 0;
		}

		m_Server.Update();

		// wait for incomming data
		net_socket_read_wait(*m_Server.Network()->Socket(), 10);
	}

	dbg_msg("server", "Closing.");
	m_Server.Network()->Close();
	thread_wait(LoadThread);

	return 0;
}