mmupro36lib.c

VXWORKS源代码

    mmuCurrentSet
    };


/******************************************************************************
*
* mmuPro36LibInit - initialize module
*
* Build a dummy translation table that will hold the page table entries
* for the global translation table.  The mmu remains disabled upon
* completion.
*
* RETURNS: OK if no error, ERROR otherwise
*
* ERRNO: S_mmuLib_INVALID_PAGE_SIZE
*/

STATUS mmuPro36LibInit 
    (
    int pageSize	/* system pageSize (must be 4KB or 2MB) */
    )
    {
    PTE * pDirectoryPtrTable;
    PTE * pDirectoryTable;
    INT32 ix;

    /* check if the PSE and PAE are supported */

    if ((sysCpuId.featuresEdx & (CPUID_PAE | CPUID_PSE)) !=
        (CPUID_PAE | CPUID_PSE))
        return (ERROR);

    /* initialize the data objects that are shared with vmLib.c */

    mmuStateTransArray = &mmuStateTransArrayLocal [0];

    mmuStateTransArraySize =
          sizeof (mmuStateTransArrayLocal) / sizeof (STATE_TRANS_TUPLE);

    mmuLibFuncs = mmuLibFuncsLocal;

    mmuPageBlockSize = PAGE_BLOCK_SIZE;

    /* we assume a 4KB or 2MB page size */

    if ((pageSize != PAGE_SIZE_4KB) && (pageSize != PAGE_SIZE_2MB))
	{
	errno = S_mmuLib_INVALID_PAGE_SIZE;
	return (ERROR);
	}

    mmuPro36Enabled = FALSE;

    mmuPageSize = pageSize;

    /* 
     * set number of pages for the page directory table
     * 2048 (4 * 512) PDEs * 8 byte = 16384 byte
     */

    nDirPages = (mmuPageSize == PAGE_SIZE_4KB) ? 4 : 1;

    /* 
     * allocate the global page block array to keep track of which parts
     * of virtual memory are handled by the global translation tables.
     * Allocate on page boundary so we can write protect it.
     */

    globalPageBlock = (UINT8 *) memalign (mmuPageSize, mmuPageSize);

    if (globalPageBlock == NULL)
	return (ERROR);

    bzero ((char *) globalPageBlock, mmuPageSize);

    /*
     * build a dummy translation table which will hold the PTE's for
     * global memory.  All real translation tables will point to this
     * one for controlling the state of the global virtual memory  
     */

    /* allocate pages to hold the directory table */

    pDirectoryTable = (PTE *) memalign (mmuPageSize, mmuPageSize * nDirPages);

    if (pDirectoryTable == NULL)
	{
	free (globalPageBlock);
	return (ERROR);
	}

    /* allocate a page to hold the directory pointer table */

    mmuGlobalTransTbl.pDirectoryTable = pDirectoryPtrTable = 
        (PTE *) memalign (mmuPageSize, mmuPageSize);

    if (pDirectoryPtrTable == NULL)
	{
	free (globalPageBlock);
	free (pDirectoryTable);
	return (ERROR);
	}

    bzero ((char *) pDirectoryPtrTable, mmuPageSize);

    /* validate all the directory pointer table entries */

    for (ix = 0; ix < mmuPdpTableNumEnt; ix++)
	{
        pDirectoryPtrTable[ix].bits[0]		= (UINT)pDirectoryTable + 
						  (PD_SIZE * ix);
        pDirectoryPtrTable[ix].bits[1]		= 0;
        pDirectoryPtrTable[ix].field.present	= 1;
        pDirectoryPtrTable[ix].field.pwt	= 0;
        pDirectoryPtrTable[ix].field.pcd	= 0;
	}

    /* invalidate all the directory table entries */

    for (ix = 0; ix < ((PD_SIZE * 4) / sizeof(PTE)); ix++)
	{
	pDirectoryTable[ix].field.present	= 0;
	pDirectoryTable[ix].field.rw		= 0;
	pDirectoryTable[ix].field.us		= 0;
	pDirectoryTable[ix].field.pwt		= 0;
	pDirectoryTable[ix].field.pcd		= 0;
	pDirectoryTable[ix].field.access	= 0;
	pDirectoryTable[ix].field.dirty		= 0;
	if (pageSize == PAGE_SIZE_4KB)
	    pDirectoryTable[ix].field.pagesize	= 0;
	else
	    pDirectoryTable[ix].field.pagesize	= 1;
	pDirectoryTable[ix].field.global	= 0;
	pDirectoryTable[ix].field.avail		= 0;
	pDirectoryTable[ix].field.page		= -1;
	pDirectoryTable[ix].field.page36	= 0;
	pDirectoryTable[ix].field.reserved	= 0;
	}

    /* set CR4 register: PAE=1 PSE=0/1 PGE=1 */

    if (pageSize == PAGE_SIZE_4KB)
        vxCr4Set ((vxCr4Get() & ~CR4_PSE) | (CR4_PAE | CR4_PGE));
    else
        vxCr4Set (vxCr4Get() | (CR4_PSE | CR4_PAE | CR4_PGE));

    return (OK);
    }

/******************************************************************************
*
* mmuPteGet - get the PTE for a given page
*
* mmuPteGet traverses a translation table and returns the (physical) address of
* the PTE for the given virtual address.
*
* RETURNS: OK or ERROR if there is no virtual space for the given address 
*
*/

LOCAL STATUS mmuPteGet 
    (
    MMU_TRANS_TBL *pTransTbl, 	/* translation table */
    void *virtAddr,		/* virtual address */ 
    PTE **result		/* result is returned here */
    )
    {
    PTE * pDte;			/* directory table entry */
    PTE * pDirectoryTable;	/* directory table */
    PTE * pPageTable;		/* page table */

    pDirectoryTable = (PTE *) (pTransTbl->pDirectoryTable->bits[0] & PDP_TO_ADDR);

    pDte = &pDirectoryTable 
	   [((UINT) virtAddr & (DIR_PTR_BITS | DIR_BITS)) >> DIR_INDEX];

    if (mmuPageSize == PAGE_SIZE_4KB)
	{
        pPageTable = (PTE *) (pDte->bits[0] & PTE_TO_ADDR_4KB); 

        if ((UINT) pPageTable == (0xffffffff & PTE_TO_ADDR_4KB))
	    return (ERROR);

        *result = &pPageTable [((UINT) virtAddr & TBL_BITS) >> TBL_INDEX];
	}
    else
	{
        if ((UINT) pDte == (0xffffffff & PTE_TO_ADDR_2MB))
	    return (ERROR);

        *result = pDte;
	}

    return (OK);
    }

/******************************************************************************
*
* mmuTransTblCreate - create a new translation table.
*
* create a i86 translation table.  Allocates space for the MMU_TRANS_TBL
* data structure and calls mmuTransTblInit on that object.  
*
* RETURNS: address of new object or NULL if allocation failed,
*          or NULL if initialization failed.
*/

LOCAL MMU_TRANS_TBL *mmuTransTblCreate 
    (
    )
    {
    MMU_TRANS_TBL * newTransTbl;
    INT32 oldIntLev = 0;
    BOOL wasEnabled;

    MMU_UNLOCK (wasEnabled, oldIntLev);
    newTransTbl = (MMU_TRANS_TBL *) malloc (sizeof (MMU_TRANS_TBL));
    MMU_LOCK (wasEnabled, oldIntLev);

    if (newTransTbl == NULL)
	return (NULL);

    if (mmuTransTblInit (newTransTbl) == ERROR)
	{
	free ((char *) newTransTbl);
	return (NULL);
	}

    return (newTransTbl);
    }

/******************************************************************************
*
* mmuTransTblInit - initialize a new translation table 
*
* Initialize a new translation table.  The directory table is copied from the
* global translation mmuGlobalTransTbl, so that we will share the global 
* virtual memory with all other translation tables.
* 
* RETURNS: OK or ERROR if unable to allocate memory for directory table.
*/

LOCAL STATUS mmuTransTblInit 
    (
    MMU_TRANS_TBL *newTransTbl		/* translation table to be inited */
    )
    {
    PTE * pDirectoryPtrTable;	/* directory pointer table */
    PTE * pDirectoryTable;	/* directory table */
    INT32 oldIntLev = 0;
    BOOL wasEnabled;
    INT32 ix;

    /* allocate a page to hold the directory pointer table */

    MMU_UNLOCK (wasEnabled, oldIntLev);
    newTransTbl->pDirectoryTable = pDirectoryPtrTable = 
	(PTE *) memalign (mmuPageSize, mmuPageSize);
    MMU_LOCK (wasEnabled, oldIntLev);

    if (pDirectoryPtrTable == NULL)
	return (ERROR);

    /* allocate pages to hold the directory table */

    MMU_UNLOCK (wasEnabled, oldIntLev);
    pDirectoryTable = (PTE *) memalign (mmuPageSize, mmuPageSize * nDirPages);
    MMU_LOCK (wasEnabled, oldIntLev);

    if (pDirectoryTable == NULL)
	{
	free (pDirectoryPtrTable);
	return (ERROR);
	}

    /* setup the directory pointer table */

    for (ix = 0; ix < mmuPdpTableNumEnt; ix++)
	{
        pDirectoryPtrTable[ix].bits[0]		= (UINT)pDirectoryTable +
					 	  (PD_SIZE * ix);
        pDirectoryPtrTable[ix].bits[1]		= 0;
        pDirectoryPtrTable[ix].field.present	= 1;
        pDirectoryPtrTable[ix].field.pwt	= 0;
        pDirectoryPtrTable[ix].field.pcd	= 0;
	}

    /* 
     * copy the directory table from the mmuGlobalTransTbl, 
     * so we get the global virtual memory 
     */

    bcopy ((char *) (mmuGlobalTransTbl.pDirectoryTable->bits[0] & PDP_TO_ADDR), 
	   (char *) pDirectoryTable, PD_SIZE * 4);

    /* 
     * write protect virtual memory pointing to the directory pointer table 
     * and the directory table in the global translation table to insure 
     * that it can't be corrupted 
     */

    for (ix = 0; ix < nDirPages; ix++)
	{
        mmuStateSet (&mmuGlobalTransTbl, 
		     (void *) ((UINT)pDirectoryTable + (mmuPageSize * ix)),
		     MMU_STATE_MASK_WRITABLE, MMU_STATE_WRITABLE_NOT);
	}

    mmuStateSet (&mmuGlobalTransTbl, (void *) pDirectoryPtrTable, 
		 MMU_STATE_MASK_WRITABLE, MMU_STATE_WRITABLE_NOT);

    return (OK);
    }

/******************************************************************************
*
* mmuTransTblDelete - delete a translation table.
* 
* mmuTransTblDelete deallocates all the memory used to store the translation
* table entries.  It does not deallocate physical pages mapped into the
* virtual memory space.
*
* RETURNS: OK
*
*/

LOCAL STATUS mmuTransTblDelete 
    (
    MMU_TRANS_TBL *transTbl		/* translation table to be deleted */
    )
    {
    PTE * pDte;
    PTE * pDirectoryTable;	/* directory table */
    PTE * pPageTable;
    INT32 ix;

    /* write enable the physical page containing the directory ptr table */

    mmuStateSet (&mmuGlobalTransTbl, transTbl->pDirectoryTable,
		 MMU_STATE_MASK_WRITABLE, MMU_STATE_WRITABLE);

    /* write enable the physical page containing the directory table */

    pDirectoryTable = (PTE *)(transTbl->pDirectoryTable->bits[0] & PDP_TO_ADDR);
    for (ix = 0; ix < nDirPages; ix++)
	{
	pDte = (PTE *)((UINT)pDirectoryTable + (mmuPageSize * ix));
        mmuStateSet (&mmuGlobalTransTbl, pDte, 
		      MMU_STATE_MASK_WRITABLE, MMU_STATE_WRITABLE);
	}

    /* deallocate only non-global page blocks */

    pDte = pDirectoryTable;
    if (mmuPageSize == PAGE_SIZE_4KB)
        for (ix = 0; ix < ((PD_SIZE * 4) / sizeof(PTE)); ix++, pDte++)
	    if ((pDte->field.present == 1) && !globalPageBlock[ix]) 
	        {
	        pPageTable = (PTE *) (pDte->bits[0] & PTE_TO_ADDR_4KB);
	        mmuStateSet (&mmuGlobalTransTbl, pPageTable,
		             MMU_STATE_MASK_WRITABLE, MMU_STATE_WRITABLE);
	        free (pPageTable);
	        }

    /* free the pages holding the directory table */

    free ((void *) (transTbl->pDirectoryTable->bits[0] & PDP_TO_ADDR));

    /* free the page holding the directory pointer table */

    free (transTbl->pDirectoryTable);

    /* free the translation table data structure */

    free (transTbl);
    
    return (OK);
    }

/******************************************************************************
*
* mmuVirtualPageCreate - set up translation tables for a virtual page
*
* simply check if there's already a page table that has a
* PTE for the given virtual page.  If there isn't, create one.
* this routine is called only if the page size is 4KB, since a page table
* is not necessary for 2MB or 4MB page sizes.
*
* RETURNS OK or ERROR if couldn't allocate space for a page table.
*/

LOCAL STATUS mmuVirtualPageCreate 
    (
    MMU_TRANS_TBL *thisTbl, 		/* translation table */
    void *virtPageAddr			/* virtual addr to create */
    )
    {
    PTE * pDirectoryTable;	/* directory table */
    PTE * pPageTable;		/* page table */
    PTE * pDte;			/* directory table entry */
    PTE * dummy;
    INT32 oldIntLev = 0;
    BOOL wasEnabled;
    UINT ix;

    if (mmuPteGet (thisTbl, virtPageAddr, &dummy) == OK)
	return (OK);

    MMU_UNLOCK (wasEnabled, oldIntLev);
    pPageTable = (PTE *) memalign (mmuPageSize, mmuPageSize);
    MMU_LOCK (wasEnabled, oldIntLev);

    if (pPageTable == NULL)
	return (ERROR);

    /* invalidate every page in the new page block */

    for (ix = 0; ix < (PT_SIZE / sizeof(PTE)); ix++)
	{
	pPageTable[ix].field.present	= 0;
	pPageTable[ix].field.rw		= 0;
	pPageTable[ix].field.us		= 0;
	pPageTable[ix].field.pwt	= 0;
	pPageTable[ix].field.pcd	= 0;
	pPageTable[ix].field.access	= 0;
	pPageTable[ix].field.dirty	= 0;
	pPageTable[ix].field.pagesize	= 0;
	pPageTable[ix].field.global	= 0;
	pPageTable[ix].field.avail	= 0;
	pPageTable[ix].field.page	= -1;
	pPageTable[ix].field.page36	= 0;
	pPageTable[ix].field.reserved	= 0;
	}

    /* 
     * write protect the new physical page containing the PTE's
     * for this new page block 
     */

    mmuStateSet (&mmuGlobalTransTbl, pPageTable, 
	         MMU_STATE_MASK_WRITABLE, MMU_STATE_WRITABLE_NOT); 

    /* 
     * unlock the physical page containing the directory pointer table
     * and the directory table, so we can modify it 
     */

    pDirectoryTable = (PTE *) (thisTbl->pDirectoryTable->bits[0] & PDP_TO_ADDR);

    for (ix = 0; ix < nDirPages; ix++)
	{
        mmuStateSet (&mmuGlobalTransTbl, 
		     (void *) ((UINT32)pDirectoryTable + (mmuPageSize * ix)),
		     MMU_STATE_MASK_WRITABLE, MMU_STATE_WRITABLE);
	}