nufp.c

嵌入式操作系统Nucleus Plus中使用的文件系统

/*  CALLED FROM                                                         */
/*                                                                      */
/*      Application_Initialize      The function called by the Nucleus  */
/*                                  PLUS kernel to begin the tasking    */
/*                                  environment.                        */
/*                                                                      */
/*  ROUTINES CALLED                                                     */
/*                                                                      */
/*                                                                      */
/*                                                                      */
/*  INPUTS                                                              */
/*                                                                      */
/*  OUTPUTS                                                             */
/*                                                                      */
/* HISTORY                                                              */
/*                                                                      */
/*         NAME            DATE                    REMARKS              */
/*                                                                      */
/*      L. Hardin       05-02-1996      Added "return(0);" for the non  */
/*                                      error case. (SPR126)            */
/*                                                                      */
/************************************************************************/
int NUFP_Initialize(void)
{
    void            *pointer;
    unsigned int    event_id;
    int             part_status;
#if (RAMDISK)
#if (RAMDISK_FROMPOOL)
    VOID            *partition_ptr;
#endif
#endif

    /***********  Initialize all of the Fixed Partitions.  ***************/

    /*  Create the User Partition. */
    if (NU_Allocate_Memory(&System_Memory, &pointer, NUF_USER_PARTITION_SIZE +
                                PARTITION_SIZE + ALLOC_SIZE,
                                NU_NO_SUSPEND) != NU_SUCCESS)
        return(-1);
    part_status = NU_Create_Partition_Pool(&NUF_USER_PARTITION, "USER", pointer,
                                NUF_USER_PARTITION_SIZE + PARTITION_SIZE,
                                NUF_USER_PARTITION_SIZE,
                                NU_FIFO);
    if (part_status != NU_SUCCESS)
        return(-2);

    /*  Create teh Drive Partition. */
    if (NU_Allocate_Memory(&System_Memory, &pointer, NUF_DRIVE_PARTITION_SIZE +
                                PARTITION_SIZE + ALLOC_SIZE,
                                NU_NO_SUSPEND) != NU_SUCCESS)
        return(-1);
    if (NU_Create_Partition_Pool(&NUF_DRIVE_PARTITION, "DRIVE", pointer,
                                NUF_DRIVE_PARTITION_SIZE + PARTITION_SIZE,
                                NUF_DRIVE_PARTITION_SIZE,
                                NU_FIFO) != NU_SUCCESS)
        return(-2);



    /*  Create the File Partition. */
    if (NU_Allocate_Memory(&System_Memory, &pointer, NUF_FILE_PARTITION_SIZE +
                                PARTITION_SIZE + ALLOC_SIZE,
                                NU_NO_SUSPEND) != NU_SUCCESS)
        return(-1);
    if (NU_Create_Partition_Pool(&NUF_FILE_PARTITION, "FILE", pointer,
                                NUF_FILE_PARTITION_SIZE + PARTITION_SIZE,
                                NUF_FILE_PARTITION_SIZE,
                                NU_FIFO) != NU_SUCCESS)
        return(-2);


    /*  Create the Block Partition. */
    if (NU_Allocate_Memory(&System_Memory, &pointer, NUF_BLOCK_PARTITION_SIZE +
                                PARTITION_SIZE + ALLOC_SIZE,
                                NU_NO_SUSPEND) != NU_SUCCESS)
        return(-1);
    if (NU_Create_Partition_Pool(&NUF_BLOCK_PARTITION, "BLOCK", pointer,
                                NUF_BLOCK_PARTITION_SIZE + PARTITION_SIZE,
                                NUF_BLOCK_PARTITION_SIZE,
                                NU_FIFO) != NU_SUCCESS)
        return(-2);



    /*  Create the DROBJ Partition. */
    if (NU_Allocate_Memory(&System_Memory, &pointer, NUF_DROBJ_PARTITION_SIZE +
                                PARTITION_SIZE + ALLOC_SIZE,
                                NU_NO_SUSPEND) != NU_SUCCESS)
        return(-1);
    if (NU_Create_Partition_Pool(&NUF_DROBJ_PARTITION, "DROBJ", pointer,
                                NUF_DROBJ_PARTITION_SIZE + PARTITION_SIZE,
                                NUF_DROBJ_PARTITION_SIZE,
                                NU_FIFO) != NU_SUCCESS)
        return(-2);



    /*  Create the FINODE Partition. */
    if (NU_Allocate_Memory(&System_Memory, &pointer, NUF_FINODE_PARTITION_SIZE +
                                PARTITION_SIZE + ALLOC_SIZE,
                                NU_NO_SUSPEND) != NU_SUCCESS)
        return(-1);
    if (NU_Create_Partition_Pool(&NUF_FINODE_PARTITION, "FINODE", pointer,
                                NUF_FINODE_PARTITION_SIZE + PARTITION_SIZE,
                                NUF_FINODE_PARTITION_SIZE,
                                NU_FIFO) != NU_SUCCESS)
        return(-2);


    /*  Create the Fat Partition A Partition.  */
    if (NU_Allocate_Memory(&System_Memory, &pointer, NUF_FAT_PARTITION_A_SIZE +
                                PARTITION_SIZE + ALLOC_SIZE,
                                NU_NO_SUSPEND) != NU_SUCCESS)
        return(-1);
    if (NU_Create_Partition_Pool(&NUF_FAT_PARTITION_A, "FAT", pointer,
                                NUF_FAT_PARTITION_A_SIZE + PARTITION_SIZE,
                                NUF_FAT_PARTITION_A_SIZE,
                                NU_FIFO) != NU_SUCCESS)
        return(-2);



    /*  Create the Fat Partition B Partition.  */
    if (NU_Allocate_Memory(&System_Memory, &pointer, NUF_FAT_PARTITION_B_SIZE +
                                PARTITION_SIZE + ALLOC_SIZE,
                                NU_NO_SUSPEND) != NU_SUCCESS)
        return(-1);
    if (NU_Create_Partition_Pool(&NUF_FAT_PARTITION_B, "FAT", pointer,
                                NUF_FAT_PARTITION_B_SIZE + PARTITION_SIZE,
                                NUF_FAT_PARTITION_B_SIZE,
                                NU_FIFO) != NU_SUCCESS)
        return(-2);



    /*  Create the Fat Partition C Partition.  */
    if (NU_Allocate_Memory(&System_Memory, &pointer, NUF_FAT_PARTITION_C_SIZE +
                                PARTITION_SIZE + ALLOC_SIZE,
                                NU_NO_SUSPEND) != NU_SUCCESS)
        return(-1);
    if (NU_Create_Partition_Pool(&NUF_FAT_PARTITION_C, "FAT", pointer,
                                NUF_FAT_PARTITION_C_SIZE + PARTITION_SIZE,
                                NUF_FAT_PARTITION_C_SIZE,
                                NU_FIFO) != NU_SUCCESS)
        return(-2);



    /*  Create the Fat Partition D Partition.  */
    if (NU_Allocate_Memory(&System_Memory, &pointer, NUF_FAT_PARTITION_D_SIZE +
                                PARTITION_SIZE + ALLOC_SIZE,
                                NU_NO_SUSPEND) != NU_SUCCESS)
        return(-1);
    if (NU_Create_Partition_Pool(&NUF_FAT_PARTITION_D, "FAT", pointer,
                                NUF_FAT_PARTITION_D_SIZE + PARTITION_SIZE,
                                NUF_FAT_PARTITION_D_SIZE,
                                NU_FIFO) != NU_SUCCESS)
        return(-2);


#if (RAMDISK)
    /*  Create the Fat Partition E Partition.  */
    if (NU_Allocate_Memory(&System_Memory, &pointer, NUF_FAT_PARTITION_E_SIZE +
                                PARTITION_SIZE + ALLOC_SIZE,
                                NU_NO_SUSPEND) != NU_SUCCESS)
        return(-1);
    if (NU_Create_Partition_Pool(&NUF_FAT_PARTITION_E, "FAT", pointer,
                                NUF_FAT_PARTITION_E_SIZE + PARTITION_SIZE,
                                NUF_FAT_PARTITION_E_SIZE,
                                NU_FIFO) != NU_SUCCESS)
        return(-2);


#if (RAMDISK_FROMPOOL)
    /*  Create the RAMDISK Partition. */
/* BobB 2/19/99 - defined POOL_SIZE */
#define POOL_SIZE \
    ((unsigned)(((unsigned)NUM_RAMDISK_PAGES) * \
                (((unsigned)NUF_RAMDISK_PARTITION_SIZE) + \
                 ((unsigned)PARTITION_SIZE))))

    if (NU_Allocate_Memory(&System_Memory, &partition_ptr,
                           POOL_SIZE + ALLOC_SIZE,
                           NU_NO_SUSPEND) != NU_SUCCESS)
        return(-1);

    if (NU_Create_Partition_Pool(&NUF_RAMDISK_PARTITION, "RAMDISK",
                                partition_ptr, POOL_SIZE,
                                NUF_RAMDISK_PARTITION_SIZE,
                                NU_FIFO) != NU_SUCCESS)
        return(-2);
#endif
#endif

    /*  Initialize all of the Events.  We don't know how many events the
        user is going to define because he may or may not use the IDE,
        FLOPPY, or RAMDISK drivers. */
    for (event_id = 0; event_id < NUF_NUM_EVENTS; event_id++)
    {

        /*  Create the Event Group. */
        if (NU_Create_Event_Group(&NUFP_RTX_To_PLUS_Events[event_id],
                                    "EVENT") != NU_SUCCESS)
            return(-2);

    }

    /*  Initialize all of the Semaphores.  */
    if (NU_Create_Semaphore(&NUF_FILE_SYSTEM_MUTEX, "SEM 0", 1,
                                    NU_FIFO) != NU_SUCCESS)
        return(-2);

    /*  If we got here, all went well. (SPR126) */
    return(0);

}   /*  End of NUFP_Initialize.  */