Esempio n. 1
0
void multiboot_save(multiboot_info_t *mb)
{
        /* Check we have a virtual adress */
        if (((uint32_t)mb & KERNEL_BASE) != KERNEL_BASE) {
                printf("%s\n", "multiboot: multiboot_info_t pointer is not a valid virtual address");
                return;
        }

        /* Save the main structure */
        memcpy(&mb_info, mb, sizeof(multiboot_info_t));

        /* Bootloader name */
        if ((mb_info.flags & MULTIBOOT_INFO_BOOT_LOADER_NAME)
            == MULTIBOOT_INFO_BOOT_LOADER_NAME) {
                strncpy(bootloader_name, (const char *)PHY_TO_VIRT(mb_info.boot_loader_name), 256);
        } else {
                bootloader_name[0] = '\0';
        }

        /* Command line arguments */
        if ((mb_info.flags & MULTIBOOT_INFO_CMDLINE) == MULTIBOOT_INFO_CMDLINE) {
                strncpy(cmdline_args, (const char *)PHY_TO_VIRT(mb_info.cmdline), 1024);
        } else {
                cmdline_args[0] = '\0';
        }
}
Esempio n. 2
0
s32 bsp_mem_dump_alloc_list(u32 u32Size, u32 u32PoolType)
{
    u32 u32Item;
    u32 u32MostUsedItem;
    void* pCurAddr;
    u32 u32Num = 0;
    MEM_ALLOC_INFO* pAllocInfo;

    if (u32PoolType >= MEM_POOL_MAX)
    {
        printk("invalid pool type:%d\n", u32PoolType);
        return ERROR;
    }
    pAllocInfo = MEM_GET_ALLOC_INFO(u32PoolType);
    u32MostUsedItem = pAllocInfo->mostUsedItem;
    MEM_FIND_RIGHT_ITEM(u32Item, u32Size, u32MostUsedItem);

    if (u32Item >= MEM_ALLOC_LIST_NUM)
    {
        printk("invalid size:%d\n", u32Size);
        return -1;
    }

    printk("dump alloc list beg:\n");

    pCurAddr = (void*)PHY_TO_VIRT((unsigned int)pAllocInfo->allocList[u32Item]);
    for (;NULL != pCurAddr; pCurAddr = (void*)MEM_ITEM_NEXT(pCurAddr))
    {
        (void)bsp_mem_dump_block((u32)pCurAddr);
        u32Num++;
    }

    printk("dump alloc list end, num:%d\n", u32Num);
    return 0;
}
Esempio n. 3
0
void* bsp_get_item(MEM_ALLOC_INFO* pAllocInfo, u32 cnt, u32 u32PoolType, u32 u32Size)
{
    void *pItem;
    void **ppHead = &(pAllocInfo->allocList[cnt]);

    /* 如果链表中没有节点,则从内存池中分配 */
    if (!*ppHead)
    {
        /* 判断是否达到最大个数 */
        if((u32PoolType != MEM_ICC_DDR_POOL) || (pAllocInfo->allocNum[cnt] < sg_AllocMaxNum[cnt]))
        {
	        /* 注意从内存池中分配的尺寸要额外包含 MGR 的部分 */
	        pItem = bsp_pool_alloc(pAllocInfo, u32Size+pAllocInfo->memPoolInfo.u32MgrSize);
	        if (NULL == pItem)
	        {
	            pAllocInfo->u32AllocFailCnt++;
	            return NULL;
	        }
	        MEM_ITEM_MAGIC(pItem) = (u32)MEM_MAGIC_NUM;
	        MEM_ITEM_SIZE(pItem) = u32Size;
	        MEM_ITEM_FLAGS(pItem) = u32PoolType;
            if(MEM_ICC_DDR_POOL == u32PoolType)
            {
                pAllocInfo->allocNum[cnt]++;
            }

	 #ifdef __BSP_MEM_DEBUG__
	        MEM_ITEM_FILE_NAME(pItem) = 0;
	        MEM_ITEM_LINE(pItem) = 0;
	 #endif
        }
        else
        {
            pAllocInfo->u32AllocFailCnt++;
            return NULL;
        }
    }
    /* 从链表中取出节点 */
    else
    {
	    pItem = (void*)PHY_TO_VIRT((unsigned int)*ppHead);

        /* Invalid Cache */
        MEM_INVALID_CACHE_BY_TYPE(MEM_GET_ALLOC_ADDR(pItem), MEM_MGR_SIZE_FOR_CACHE, u32PoolType);
        *ppHead = (void*)MEM_ITEM_NEXT(pItem);
    }
    return pItem;
}