portkern.c

ertfs文件系统里面既有完整ucos程序

/* POLLOS does not need semaphores */
#else
#error Implement semaphore claim and release for your kernel
#endif
}

void ks_release_logdrive(int driveno)
{
#if (defined(PLUS))
    NU_Release_Semaphore(&fs_drivesem[driveno]);
#elif (defined(RTPX))
    px_mutex_set(fs_drivesem[driveno]);
#elif (defined(CMX))
    K_Resource_Release(fs_drivesem[driveno]);
#elif (defined(UCOS))
    OSSemPost(fs_drivesem[driveno]);    
#elif (defined(__PSOS__))
    sm_v(fs_drivesem[driveno]);
#elif (defined(POLLOS))
/* POLLOS does not need semaphores */
#else
#error Implement semaphore claim and release for your kernel
#endif
}

void ks_claim_fscritical(void)
{
#if (defined(PLUS))
    NU_Obtain_Semaphore(&fs_critsem,NU_SUSPEND);
#elif (defined(RTPX))
    px_mutex_wait(fs_critsem, RTPX_INF);
#elif (defined(CMX))
    K_I_Resource_Common(fs_critsem,0,0);
#elif (defined(UCOS))
byte err;
    OSSemPend(fs_critsem, 0, &err); 
#elif (defined(__PSOS__))
    sm_p(fs_critsem,SM_WAIT, 0);
#elif (defined(POLLOS))
/* POLLOS does not need semaphores */
#else
#error Implement semaphore claim and release for your kernel
#endif
}
void ks_release_fscritical(void)
{
#if (defined(PLUS))
    NU_Release_Semaphore(&fs_critsem);
#elif (defined(RTPX))
    px_mutex_set(fs_critsem);
#elif (defined(CMX))
    K_Resource_Release(fs_critsem);
#elif (defined(UCOS))
    OSSemPost(fs_critsem);  
#elif (defined(__PSOS__))
    sm_v(fs_critsem);
#elif (defined(POLLOS))
/* POLLOS does not need semaphores */
#else
#error Implement semaphore claim and release for your kernel
#endif
}

void ks_claim_drive_io(int driveno)
{
#if (defined(PLUS))
    NU_Obtain_Semaphore(&fs_iosem[driveno],NU_SUSPEND);
#elif (defined(RTPX))
    px_mutex_wait(fs_iosem[driveno], RTPX_INF);
#elif (defined(CMX))
    K_I_Resource_Common(fs_iosem[driveno],0,0);
#elif (defined(UCOS))
byte err;
    OSSemPend(fs_iosem[driveno], 0, &err);  
#elif (defined(__PSOS__))
    sm_p(fs_iosem[driveno],SM_WAIT, 0);
#elif (defined(POLLOS))
/* POLLOS does not need semaphores */
#else
#error Implement semaphore claim and release for your kernel
#endif
}
void ks_release_drive_io(int driveno)
{
#if (defined(PLUS))
    NU_Release_Semaphore(&fs_iosem[driveno]);
#elif (defined(RTPX))
    px_mutex_set(fs_iosem[driveno]);
#elif (defined(CMX))
    K_Resource_Release(fs_iosem[driveno]);
#elif (defined(UCOS))
    OSSemPost(fs_iosem[driveno]);   
#elif (defined(__PSOS__))
    sm_v(fs_iosem[driveno]);
#elif (defined(POLLOS))
/* POLLOS does not need semaphores */
#else
#error Implement semaphore claim and release for your kernel
#endif
}


#if (defined(POLLOS))
// Poolos signal test
// ********************************************************************
// Test for a signal
BOOLEAN pollos_test(int *psig, word timeout)             /* __fn__*/
{
dword last_time, end_time, curr_time;
    if (timeout)
    {
        last_time = end_time = 0;       // keep compiler happy
        curr_time = ks_get_ticks();    
        end_time = curr_time + (dword) timeout;
        // Check for a wrap
        if (end_time < curr_time)
            end_time = (dword) 0xffffffffL;
        last_time = curr_time;
        do
        {
            // See if we timed out 
            curr_time = ks_get_ticks();    
            if (curr_time > end_time)
                break;
            // if wrap or clearing of clock then start count over
            if (curr_time < last_time)      
                end_time = curr_time + (dword) timeout;
            last_time = curr_time;
        } while (*psig == 0);
    }
    if (*psig)
    {
        *psig -= 1;
        return(TRUE);
    }
    else
    {
       return(FALSE);
    }
}
#endif


#if (defined(__PSOS__))
#define KS_SIGNAL_CLEAR(SIGNAL) while( sm_p(SIGNAL,SM_NOWAIT,0) ==0 )
#define KS_SIGNAL_SET(SIGNAL)   sm_v(SIGNAL)
#define KS_SIGNAL_GET(SIGNAL,T) (sm_p(SIGNAL, (T==0 ? SM_NOWAIT :  SM_WAIT),  (T==RTIP_INF ? 0 :  T ) )==0)
#endif

#if (USE_FLOPPY)
/* clear set and test routines for the floppy signal */
void ks_clear_floppy_signal(void)
{
#if (defined(PLUS))
    while(NU_Obtain_Semaphore(&floppy_signal, 0) == NU_SUCCESS)
            ;
#elif (defined(RTPX))
    px_semaphore_clear(floppy_signal);

#elif (defined(CMX))
    while (K_Semaphore_Get(floppy_signal)==K_OK);

#elif (defined(UCOS))
    while(ks_test_floppy_signal(0))
        ;
#elif (defined(__PSOS__))
    KS_SIGNAL_CLEAR(floppy_signal);
#elif (defined(POLLOS))
    floppy_signal = 0;
#else
#error Implement counting semaphore clear for your kernel
#endif
}
void ks_set_floppy_signal(void)
{
#if (defined(PLUS))
    NU_Release_Semaphore(&floppy_signal);
#elif (defined(RTPX))
    px_semaphore_set(floppy_signal);
#elif (defined(CMX))
    K_Intrp_Semaphore_Post(floppy_signal);
#elif (defined(UCOS))
    OSSemPost(floppy_signal);
#elif (defined(__PSOS__))
    KS_SIGNAL_SET(floppy_signal);
#elif (defined(POLLOS))
    floppy_signal += 1;
#else
#error Implement counting semaphore increment for your kernel
#endif
}

BOOLEAN ks_test_floppy_signal(word ticks)
{
#if (defined(PLUS))
    return(NU_Obtain_Semaphore(&floppy_signal, ticks) == NU_SUCCESS);
#elif (defined(RTPX))
    return(px_semaphore_wait(floppy_signal, ticks));
#elif (defined(CMX))
    return(K_Semaphore_Wait(floppy_signal, ticks)==K_OK);
#elif (defined(UCOS))
{
byte err;
        if (ticks == 0)
        {
            /* For zero timeout - first check the internal counter
               and fall through into the blocking routine if we know 
               that it won't block */
            if (!floppy_signal->OSEventCnt)
                return(FALSE);
        }
        OSSemPend(floppy_signal, ticks, &err);  
        return(err == OS_NO_ERR);
}
#elif (defined(__PSOS__))
        return(KS_SIGNAL_GET(floppy_signal, ticks));
#elif (defined(POLLOS))
    return(pollos_test(&floppy_signal, ticks));
#else
#error Implement counting semaphore test for your kernel
#endif

}
#endif

#if (USE_ATA)
/* clear set and test routines for the ide signal */
void ks_clear_ide_signal(int controller)
{
#if (defined(PLUS))
    while(NU_Obtain_Semaphore(&ide_signal[controller], 0) == NU_SUCCESS)
        ;
#elif (defined(RTPX))
    px_semaphore_clear(ide_signal[controller]);

#elif (defined(CMX))
    while (K_Semaphore_Get(ide_signal[controller])==K_OK);

#elif (defined(UCOS))
    while(ks_test_ide_signal(controller, 0))
        ;
#elif (defined(__PSOS__))
    KS_SIGNAL_CLEAR(ide_signal[controller]);
#elif (defined(POLLOS))
    ide_signal[controller] = 0;
#else
#error Implement counting semaphore clear for your kernel
#endif
}

void ks_set_ide_signal(int controller)
{
#if (defined(PLUS))
    NU_Release_Semaphore(&ide_signal[controller]);
#elif (defined(RTPX))
    px_semaphore_set(ide_signal[controller]);
#elif (defined(CMX))
    K_Intrp_Semaphore_Post(ide_signal[controller]);
#elif (defined(UCOS))
    OSSemPost(ide_signal[controller]);  
#elif (defined(__PSOS__))
    KS_SIGNAL_SET(ide_signal[controller]);
#elif (defined(POLLOS))
    ide_signal[controller] += 1;
#else
#error Implement counting semaphore increment for your kernel
#endif
}

BOOLEAN ks_test_ide_signal(int controller, word timeout)
{
#if (defined(PLUS))
    return(NU_Obtain_Semaphore(&ide_signal[controller], timeout) == NU_SUCCESS);
#elif (defined(RTPX))
    return(px_semaphore_wait(ide_signal[controller], timeout));
#elif (defined(CMX))
    return(K_Semaphore_Wait(ide_signal[controller], timeout)==K_OK);
#elif (defined(UCOS))
{
byte err;
        if (timeout == 0)
        {
            /* For zero timeout - first check the internal counter
               and fall through into the blocking routine if we know 
               that it won't block */
            if (!ide_signal[controller]->OSEventCnt)
                return(FALSE);
        }
        OSSemPend(ide_signal[controller], timeout, &err);   
        return(err == OS_NO_ERR);
}
#elif (defined(__PSOS__))
        return(KS_SIGNAL_GET(ide_signal[controller], timeout));
#elif (defined(POLLOS))
    return(pollos_test(&ide_signal[controller], timeout));
#else
#error Implement counting semaphore test for your kernel
#endif
}
#endif


/* Timer management functions */
// ********************************************************************
// ks_get_ticks() - get period since system startup
//
//   Returns number of ticks since system startup
//

#if (defined(CMX))
extern word32 cmx_tick_count;   /* total number of CMX system ticks accumulated */
#endif
#if (MC68K)
// MARKMARK - This is phoney need a real clock ISR
dword timer_tick;
#endif


dword ks_get_ticks(void)
{
#if (defined(PLUS))
    return(NU_Retrieve_Clock());
#elif (defined(RTPX))
  return((dword)px_get_ticks());
#elif (defined(CMX))
    return(cmx_tick_count);
#elif (defined(UCOS))
     return(OSTimeGet());
#elif (defined(__PSOS__))
#error - Need get ticks function for PSOS
#elif (defined(POLLOS))
#if (IS_386_PM)
// warning Phoney implementation of gettick to compile library in unspecified 386 environment
static dword tick = 0;
    tick += 1;
#elif(MC68K)
// Return MARKMARK - This is phoney need a real clock ISR
dword tick = timer_tick++;
#else
dword tick;
    _bios_timeofday(_TIME_GETCLOCK, (long *)&tick);    
#endif
    return((dword)tick);
#else
#error - implement ks_get_ticks for your kernel
#endif

}

// ********************************************************************
// ks_ticks_p_sec(void) - ticks per second
//
//   Returns number of ticks per second
//
word ks_ticks_p_sec(void)
{
#if (CMXD860)
    return(50); //set by decrementer exception in initppc.c
#elif(MC68K)
// MARKMARK - This is phoney need a real clock ISR
    return(50);
#elif (defined(__PSOS__))
#error - Need ks_ticks_p_sec function for PSOS
#else
    return(18);
#endif
}

// ks_msec_p_tick() - milliseconds per tick
//
//   Returns number of milliseconds per tick
//
word ks_msec_p_tick()       /*__fn__*/
{
#if (CMXD860)
    return(20); //set by decrementer exception in initppc.c
#elif(MC68K)
// MARKMARK - This is phoney need a real clock ISR
    return(20);
#elif (defined(__PSOS__))
#error - Need ks_msec_p_tick function for PSOS
#else
    return(55);
#endif
}

// ********************************************************************
// ks_sleep() - sleep number of ticks
//
//   Seeps number of ticks specified.  If ticks is 0, task yields.
//
//   Returns nothing
//
void ks_sleep(word no_ticks)
{
#if (defined(PLUS))
    NU_Sleep(no_ticks);
#elif (defined(RTPX))
    px_sleep(no_ticks);
#elif (defined(CMX))
    K_Task_Wait((word16) no_ticks);
#elif (defined(UCOS))
    OSTimeDly(no_ticks);
#elif (defined(__PSOS__))
    tm_wkafter(no_ticks);
#elif (defined(POLLOS))
int dummy = 0;
    /* test a signal that will never be set */
    pollos_test(&dummy, no_ticks);
#else
#error define ks_sleep for your kernel
#endif

}

SYSTEM_USER user_table[NUM_USERS];

void init_user_table(void)
{
    tc_memset((PFBYTE)user_table, 0, sizeof(user_table));
}


PSYSTEM_USER get_system_user(void)
{
int i;
#if (defined(PLUS))
NU_TASK *t;
    t = NU_Current_Task_Pointer();
#elif (defined(RTPX))
    TASK t;
    t = px_current_task();
#elif (defined(CMX))
    byte t = K_OS_Task_Slot_Get();
#elif (defined(UCOS))
byte t;
    t = OSTCBCur->OSTCBPrio;
#elif (defined(__PSOS__))
KS_TASK_HANDLE t;
    t_ident( (char*)0, 0, &t);
#elif (defined(POLLOS))
int t;
    t = 1;
#else
#error - Get current task id for you kernel and match against user table
#endif
    for (i = 0; i < NUM_USERS; i++)
    {
        if (t == user_table[i].task_handle)
            return(&user_table[i]);
    }
    /* Didn't find one.. so assign one from between 1 and n */
    for (i = 1; i < NUM_USERS; i++)
    {
        if (!user_table[i].task_handle)
        {
return_it:
            tc_memset((PFBYTE)&user_table[i], 0, sizeof(user_table[i]));
            user_table[i].task_handle = t;