Ejemplo n.º 1
0
interrupt(TIMER0_A0_VECTOR) __attribute__ ((naked)) timer0_a0_isr(void) {
    __enter_isr();
	
    TA0_unset(0); 
    int_handler(0);
    __exit_isr();
}
Ejemplo n.º 2
0
void *thrad_1(void *dummy) {
    (void)dummy;
    int sig, status, *status_ptr = &status;
    sigset_t sigmask;

    // blocking no signal
    sigfillset(&sigmask);
    pthread_sigmask(SIG_UNBLOCK, &sigmask, (sigset_t*)0);
    sigwait(&sigmask, &sig);
    
    switch (sig) {
        case SIGINT: int_handler(sig); break;
        default: break;
    }
    
    // blocked by tid2
    printf("Thread %ld: sende SIGINT and %ld\n", (long)pthread_self(), (long)tid2);
    pthread_kill(tid2, SIGINT);
    
    // not blocked by tid2
    printf("Thread %ld: sende SIGUSR1 and %ld\n", (long)pthread_self(), (long)tid2);
    pthread_kill(tid2, SIGUSR1);

    pthread_join(tid2, (void**)status_ptr);
    printf("Thread %ld: Exit-Status = %d\n",(long)tid2, status);
    
    printf("Thread %ld: wird beendet\n", (long)pthread_self());
    pthread_exit(NULL);
    
}
Ejemplo n.º 3
0
Archivo: config.c Proyecto: nicb/psOSCd
static int
num_markers_handler(const config_t *c, const char *p, ConfigVar *v)
{
    int result = int_handler(c, p, v);
    phasespace_switch_to_marker_tracking();
    return result;
}
Ejemplo n.º 4
0
static int
do_vm86(xf86Int10InfoPtr pInt)
{
    int retval, signo;

    xf86InterceptSignals(&signo);
    retval = vm86_rep(VM86S);
    xf86InterceptSignals(NULL);

    if (signo >= 0) {
	xf86DrvMsg(pInt->scrnIndex, X_ERROR,
	    "vm86() syscall generated signal %d.\n", signo);
	dump_registers(pInt);
	dump_code(pInt);
	stack_trace(pInt);
	return 0;
    }

    switch (VM86_TYPE(retval)) {
    case VM86_UNKNOWN:
	if (!vm86_GP_fault(pInt)) return 0;
	break;
    case VM86_STI:
	xf86DrvMsg(pInt->scrnIndex, X_ERROR, "vm86_sti :-((\n");
	dump_registers(pInt);
	dump_code(pInt);
	stack_trace(pInt);
	return 0;
    case VM86_INTx:
	pInt->num = VM86_ARG(retval);
	if (!int_handler(pInt)) {
	    xf86DrvMsg(pInt->scrnIndex, X_ERROR,
		"Unknown vm86_int: 0x%X\n\n", VM86_ARG(retval));
	    dump_registers(pInt);
	    dump_code(pInt);
	    stack_trace(pInt);
	    return 0;
	}
	/* I'm not sure yet what to do if we can handle ints */
	break;
    case VM86_SIGNAL:
	return 1;
	/*
	 * we used to warn here and bail out - but now the sigio stuff
	 * always fires signals at us. So we just ignore them for now.
	 */
	xf86DrvMsg(pInt->scrnIndex, X_WARNING, "received signal\n");
	return 0;
    default:
	xf86DrvMsg(pInt->scrnIndex, X_ERROR, "unknown type(0x%x)=0x%x\n",
		VM86_ARG(retval), VM86_TYPE(retval));
	dump_registers(pInt);
	dump_code(pInt);
	stack_trace(pInt);
	return 0;
    }

    return 1;
}
Ejemplo n.º 5
0
static void
x86emu_do_int(int num)
{
    Int10Current->num = num;

    if (!int_handler(Int10Current)) {
	X86EMU_halt_sys();
    }
}
Ejemplo n.º 6
0
void
xf86ExecX86int10(xf86Int10InfoPtr pInt)
{
    int sig = setup_int(pInt);

    if (int_handler(pInt))
	while(do_vm86(pInt)) {};

    finish_int(pInt, sig);
}
Ejemplo n.º 7
0
interrupt(TIMERA0_VECTOR) __attribute__((naked)) timer_isr_ccr0(void)
{
    __enter_isr();

    if (overflow_interrupt[0] == timer_round) {
        timer_unset(0);
        int_handler(0);
    }

    __exit_isr();
}
Ejemplo n.º 8
0
void NMI_HandlerC(unsigned long *exception_args)
{
    if (int_handler)
    {
        int_handler(exception_args);
    }
    else
    {
        hw_watchdog_handle_int(exception_args);
    }
}
Ejemplo n.º 9
0
void
xf86ExecX86int10(xf86Int10InfoPtr pInt)
{
    int sig = setup_int(pInt);

    if (sig < 0)
	return;

    if (int_handler(pInt)) {
	X86EMU_exec();
    }

    finish_int(pInt, sig);
}
Ejemplo n.º 10
0
interrupt(TIMER0_A1_VECTOR) __attribute__ ((naked)) timer0_a1_5_isr(void) {
    __enter_isr();
    
    short taiv = TA0IV;
    short timer;

    if (taiv & TAIFG) {
        DEBUG("Overflow\n");
    }
    else {
        timer = (taiv/2);
        TA0_unset(timer);
        int_handler(timer);
	}
	
    __exit_isr();
}
Ejemplo n.º 11
0
/**
 * native timer signal handler
 *
 * set new system timer, call timer interrupt handler
 */
void hwtimer_isr_timer()
{
    int i;

    DEBUG("hwtimer_isr_timer()\n");

    i = next_timer;
    native_hwtimer_isset[next_timer] = 0;
    schedule_timer();

    if (native_hwtimer_irq[i] == 1) {
        DEBUG("hwtimer_isr_timer(): calling hwtimer.int_handler(%i)\n", i);
        int_handler(i);
    }
    else {
        DEBUG("hwtimer_isr_timer(): this should not have happened");
    }
}
Ejemplo n.º 12
0
/**
 * native timer signal handler
 *
 * set new system timer, call timer interrupt handler
 */
void hwtimer_isr_timer(void)
{
    DEBUG("hwtimer_isr_timer()\n");

    if (next_timer == -1) {
        DEBUG("hwtimer_isr_timer(): next_timer is invalid\n");
        return;
    }

    if (native_hwtimer_isset[next_timer] == 1) {
        native_hwtimer_isset[next_timer] = 0;
        DEBUG("hwtimer_isr_timer(): calling hwtimer.int_handler(%i)\n", next_timer);
        int_handler(next_timer);
    }
    else {
        DEBUG("hwtimer_isr_timer(): this should not have happened\n");
    }

    schedule_timer();
}
Ejemplo n.º 13
0
interrupt(TIMERA1_VECTOR) __attribute__((naked)) timer_isr(void)
{
    __enter_isr();

    short taiv_reg = TAIV;
    if (taiv_reg == 0x0A) {
        /* TAIV = 0x0A means overflow */
        DEBUG("Overflow\n");
        timer_round++;
    }
    else {
        short timer = taiv_reg >> 1;
        /* check which CCR has been hit and if the overflow counter
           for this timer has been reached (or exceeded);
            there is indeed a race condition where an hwtimer
            due to fire in the next round can be set after
            the timer's counter has overflowed but *before*
            timer_round incrementation has occured (when
            interrupts are disabled for any reason), thus
            effectively setting the timer one round in the past! */
        int16_t round_delta = overflow_interrupt[timer] - timer_round;
        /* in order to correctly handle timer_round overflow,
           we must fire the timer when, for example,
           timer_round == 0 and overflow_interrupt[timer] == 65535;
           to that end, we compute the difference between the two
           on a 16-bit signed integer: any difference >= +32768 will
           thus overload to a negative number; we should then
           correctly fire "overdue" timers whenever the case */
        if (round_delta <= 0) {
            timer_unset(timer);
            int_handler(timer);
        }
    }

    __exit_isr();
}