本文分析虚拟内存模块源码整个内存从哪到哪是属于什么段

本文分析虚拟内存模块源码初始化整个内存

从 main() 跟踪可以看出，内存部分的初始化是在 OsSysMemInit() 中完成的。

UINT32 OsSysMemInit(VOID)
{
  STATUS_T ret;
  OsKSpaceInit();//内核空间初始化
  ret = OsKHeapInit(OS_KHEAP_BLOCK_SIZE);// 内核动态内存初始化 512K 
  if (ret != LOS_OK) {
    VM_ERR("OsKHeapInit fail");
    return LOS_NOK;
  }
  OsVmPageStartup();// page初始化
  OsInitMappingStartUp();// 映射初始化
  ret = ShmInit();// 共享内存初始化
  if (ret < 0) {
        VM_ERR("ShmInit fail");  
        return LOS_NOK;
    }
    return LOS_OK;
}

鸿蒙虚拟内存整体布局

// HarmonyOS 内核空间包含以下各段:
extern CHAR __int_stack_start; // 运行系统函数栈的开始地址
extern CHAR __rodata_start;  // ROM开始地址 只读
extern CHAR __rodata_end;  // ROM结束地址
extern CHAR __bss_start;  // bss开始地址
extern CHAR __bss_end;   // bss结束地址
extern CHAR __text_start;  // 代码区开始地址
extern CHAR __text_end;   // 代码区结束地址
extern CHAR __ram_data_start; // RAM开始地址 可读可写
extern CHAR __ram_data_end;  // RAM结束地址
extern UINT32 __heap_start;  // 堆区开始地址
extern UINT32 __heap_end;  // 堆区结束地址

记忆的开始，一张白纸，这些externs就是为它画一个很大的界限，从哪里到哪里它属于什么段。这些值的大小取决于实际项目记忆棒的大小。不同的记忆棒肯定有不同的地址，所以必须外提供。鸿蒙内核采用Linux段管理方式。结合上图，对比下面的解释，自行理解定位。

BSS段（bss segment）通常是指程序中用来存放未初始化的全局变量的内存区域。BSS是英文Block Started by Symbol的缩写。BSS 段属于静态内存分配。该段用于存放未初始化的全局变量或默认初始化为0的全局变量。它不占用程序文件的大小，而是在程序运行时占用内存空间。

数据段 该段用于存储已初始化的全局变量。由于编译优化策略，初始化为 0 的全局变量仍然存储在 BSS 段中。

细心的读者可能会发现，鸿蒙内核中几乎所有的全局变量都没有赋值初始化值或者NULL。这些变量编译后放在BSS段中，在运行时占用内存空间，所以编译出来的ELF包变小了。.

.rodata段段友sdk初始化失败，也叫常量区，用于存放常量数据，ro表示只读。

文本段用于存储程序代码，在编译时确定，只读。此外，它存储处理器的机器指令。当每个源文件单独编译时，会生成一个目标文件，每个目标文件由链接器链接，并解决每个源文件之间的函数引用。同时，必须转换所有目标文件。中的 .text 部分。

栈段是负责申请释放的系统，用于存放参数变量和局部变量以及函数的执行。

堆段由用户申请和释放。申请时至少分配虚拟内存，实际存储数据时分配相应的实内存。当它被释放时，真正的内存不会立即被释放，而是可能被重用。

内核空间是如何初始化的？

LosMux g_vmSpaceListMux;//虚拟空间互斥锁,一般和g_vmSpaceList配套使用
LOS_DL_LIST_HEAD(g_vmSpaceList);//g_vmSpaceList把所有虚拟空间挂在一起,
LosVmSpace g_kVmSpace; //内核空间地址
LosVmSpace g_vMallocSpace;//虚拟分配空间地址
//鸿蒙内核空间有两个(内核进程空间和内核动态分配空间),共用一张L1页表
VOID OsKSpaceInit(VOID)
{
  OsVmMapInit();// 初始化互斥量
  OsKernVmSpaceInit(&g_kVmSpace, OsGFirstTableGet());// 初始化内核虚拟空间，OsGFirstTableGet 为L1表基地址
  OsVMallocSpaceInit(&g_vMallocSpace, OsGFirstTableGet());// 初始化动态分配区虚拟空间，OsGFirstTableGet 为L1表基地址
}//g_kVmSpace g_vMallocSpace 共用一个L1页表
//初始化内核堆空间
STATUS_T OsKHeapInit(size_t size)
{
  STATUS_T ret;
  VOID *ptr = NULL;
  /*
  * roundup to MB aligned in order to set kernel attributes. kernel text/code/data attributes
  * should page mapping, remaining region should section mapping. so the boundary should be
  * MB aligned.
  */
  //向上舍入到MB对齐是为了设置内核属性。内核文本/代码/数据属性应该是页映射，其余区域应该是段映射,所以边界应该对齐。
  UINTPTR end = ROUNDUP(g_vmBootMemBase + size, MB);//用M是因为采用section mapping 鸿蒙内核源码分析(内存映射篇)有阐述
  size = end - g_vmBootMemBase;
 //ROUNDUP(0x00000200+512,1024) = 1024 ROUNDUP(0x00000201+512,1024) = 2048 此处需细品!
  ptr = OsVmBootMemAlloc(size);//因刚开机，使用引导分配器分配
  if (!ptr) {
    PRINT_ERR("vmm_kheap_init boot_alloc_mem failed! %d\n", size);
    return -1;
  }
  m_aucSysMem0 = m_aucSysMem1 = ptr;//内存池基地址，取名auc还用0和1来标识有何深意,一直没整明白, 哪位大神能告诉下?
  ret = LOS_MemInit(m_aucSysMem0, size);//初始化内存池
  if (ret != LOS_OK) {
    PRINT_ERR("vmm_kheap_init LOS_MemInit failed!\n");
    g_vmBootMemBase -= size;//分配失败时需归还size, g_vmBootMemBase是很野蛮粗暴的
    return ret;
  }
  LOS_MemExpandEnable(OS_SYS_MEM_ADDR);//地址可扩展
  return LOS_OK;
}

内核空间使用了三个全局变量，其中一个是互斥LosMux，在IPC部分会详细讨论，这里不再展开。更有趣的是 LOS_DL_LIST_HEAD。在阅读内核源代码的过程中，我经常对这样的代码点头称赞，会心一笑。像！

#define LOS_DL_LIST_HEAD(list) LOS_DL_LIST list = { &(list), &(list) }

Page是如何初始化的？

页是映射的最小单位，是物理地址虚拟地址映射数据结构的基础

// page初始化
VOID OsVmPageStartup(VOID)
{
  struct VmPhysSeg *seg = NULL;
  LosVmPage *page = NULL;
  paddr_t pa;
  UINT32 nPage;
  INT32 segID;
  OsVmPhysAreaSizeAdjust(ROUNDUP((g_vmBootMemBase - KERNEL_ASPACE_BASE), PAGE_SIZE));//校正 g_physArea size
  nPage = OsVmPhysPageNumGet();//得到 g_physArea 总页数
  g_vmPageArraySize = nPage * sizeof(LosVmPage);//页表总大小
  g_vmPageArray = (LosVmPage *)OsVmBootMemAlloc(g_vmPageArraySize);//申请页表存放区域
  OsVmPhysAreaSizeAdjust(ROUNDUP(g_vmPageArraySize, PAGE_SIZE));// g_physArea 变小
  OsVmPhysSegAdd();// 段页绑定
  OsVmPhysInit();// 加入空闲链表和设置置换算法,LRU(最近最久未使用)算法
  for (segID = 0; segID < g_vmPhysSegNum; segID++) {
        seg = &g_vmPhysSeg[segID];
        nPage = seg->size >> PAGE_SHIFT;
    for (page = seg->pageBase, pa = seg->start; page <= seg->pageBase + nPage;
      page++, pa += PAGE_SIZE) {
      OsVmPageInit(page, pa, segID);//page初始化
    }
    OsVmPageOrderListInit(seg->pageBase, nPage);// 页面分配的排序
  }
}

进程如何请求内存？

进程的主体来自进程池，进程池是统一分配的。如何创建进程池看系列文章，所以创建进程时只需要分配虚拟内存LosVmSpace，分为内核态和用户态。的申请。

//初始化进程的 用户空间 或 内核空间
//初始化PCB块
STATIC UINT32 OsInitPCB(LosProcessCB *processCB, UINT32 mode, UINT16 priority, UINT16 policy, const CHAR *name)
{
  UINT32 count;
  LosVmSpace *space = NULL;
  LosVmPage *vmPage = NULL;
  status_t status;
  BOOL retVal = FALSE;
  processCB->processMode = mode;//用户态进程还是内核态进程
  processCB->processStatus = OS_PROCESS_STATUS_INIT;//进程初始状态
  processCB->parentProcessID = OS_INVALID_VALUE;//爸爸进程，外面指定
  processCB->threadGroupID = OS_INVALID_VALUE;//所属线程组
  processCB->priority = priority;//优先级
  processCB->policy = policy;//调度算法 LOS_SCHED_RR
  processCB->umask = OS_PROCESS_DEFAULT_UMASK;//掩码
  processCB->timerID = (timer_t)(UINTPTR)MAX_INVALID_TIMER_VID;
  LOS_ListInit(&processCB->threadSiblingList);//初始化任务/线程链表
  LOS_ListInit(&processCB->childrenList);  //初始化孩子链表
  LOS_ListInit(&processCB->exitChildList); //初始化记录哪些孩子退出了的链表 
  LOS_ListInit(&(processCB->waitList));  //初始化等待链表
  for (count = 0; count < OS_PRIORITY_QUEUE_NUM; ++count) { //根据 priority数 创建对应个数的队列
        LOS_ListInit(&processCB->threadPriQueueList[count]); 
  }
  if (OsProcessIsUserMode(processCB)) {// 是否为用户态进程
    space = LOS_MemAlloc(m_aucSysMem0, sizeof(LosVmSpace));
    if (space == NULL) {
      PRINT_ERR("%s %d, alloc space failed\n", __FUNCTION__, __LINE__);
      return LOS_ENOMEM;
    }
    VADDR_T *ttb = LOS_PhysPagesAllocContiguous(1);//分配一个物理页用于存储L1页表 4G虚拟内存分成 （4096*1M）
    if (ttb == NULL) {//这里直接获取物理页ttb
      PRINT_ERR("%s %d, alloc ttb or space failed\n", __FUNCTION__, __LINE__);
      (VOID)LOS_MemFree(m_aucSysMem0, space);
      return LOS_ENOMEM;
    }
    (VOID)memset_s(ttb, PAGE_SIZE, 0, PAGE_SIZE);
    retVal = OsUserVmSpaceInit(space, ttb);//初始化虚拟空间和本进程 mmu
    vmPage = OsVmVaddrToPage(ttb);//通过虚拟地址拿到page
    if ((retVal == FALSE) || (vmPage == NULL)) {//异常处理
      PRINT_ERR("create space failed! ret: %d, vmPage: %#x\n", retVal, vmPage);
      processCB->processStatus = OS_PROCESS_FLAG_UNUSED;//进程未使用,干净
      (VOID)LOS_MemFree(m_aucSysMem0, space);//释放虚拟空间
      LOS_PhysPagesFreeContiguous(ttb, 1);//释放物理页,4K
      return LOS_EAGAIN;
    }
    processCB->vmSpace = space;//设为进程虚拟空间
    LOS_ListAdd(&processCB->vmSpace->archMmu.ptList, &(vmPage->node));//将空间映射页表挂在 空间的mmu L1页表, L1为表头
  } else {
    processCB->vmSpace = LOS_GetKVmSpace();//内核共用一个虚拟空间,内核进程 常驻内存
  }
#ifdef LOSCFG_SECURITY_VID
  status = VidMapListInit(processCB);
  if (status != LOS_OK) {
    PRINT_ERR("VidMapListInit failed!\n");
    return LOS_ENOMEM;
  }
#endif
#ifdef LOSCFG_SECURITY_CAPABILITY
  OsInitCapability(processCB);
#endif
  if (OsSetProcessName(processCB, name) != LOS_OK) {
    return LOS_ENOMEM;
  }
  return LOS_OK;
}
LosVmSpace *LOS_GetKVmSpace(VOID)
{
    return &g_kVmSpace;
}

从代码中可以看出，内核空间只有一个g_kVmSpace，每个用户进程的虚拟内存空间是独立的。请仔细检查！

任务如何申请内存？

任务主体来自进程池，任务池统一分配。如何创建任务池请参阅系列文章。这里任务只需要申请栈空间，或者直接看源码。使用 OsUserInitProcess 函数查看应用程序的 main() 是如何由内核创建和运行的。

//所有的用户进程都是使用同一个用户代码段描述符和用户数据段描述符，它们是__USER_CS和__USER_DS，也就是每个进程处于用户态时，它们的CS寄存器和DS寄存器中的值是相同的。当任何进程或者中断异常进入内核后，都是使用相同的内核代码段描述符和内核数据段描述符，它们是__KERNEL_CS和__KERNEL_DS。这里要明确记得，内核数据段实际上就是内核态堆栈段。
LITE_OS_SEC_TEXT_INIT UINT32 OsUserInitProcess(VOID)
{
  INT32 ret;
  UINT32 size;
  TSK_INIT_PARAM_S param = { 0 };
  VOID *stack = NULL;
  VOID *userText = NULL;
  CHAR *userInitTextStart = (CHAR *)&__user_init_entry;//代码区开始位置 ,所有进程
  CHAR *userInitBssStart = (CHAR *)&__user_init_bss;// 未初始化数据区（BSS）。在运行时改变其值
  CHAR *userInitEnd = (CHAR *)&__user_init_end;// 结束地址
  UINT32 initBssSize = userInitEnd - userInitBssStart;
  UINT32 initSize = userInitEnd - userInitTextStart;
  LosProcessCB *processCB = OS_PCB_FROM_PID(g_userInitProcess);
  ret = OsProcessCreateInit(processCB, OS_USER_MODE, "Init", OS_PROCESS_USERINIT_PRIORITY);// 初始化用户进程,它将是所有应用程序的父进程
  if (ret != LOS_OK) {
    return ret;
  }
  userText = LOS_PhysPagesAllocContiguous(initSize >> PAGE_SHIFT);// 分配连续的物理页
  if (userText == NULL) {
    ret = LOS_NOK;
    goto ERROR;
  }
  (VOID)memcpy_s(userText, initSize, (VOID *)&__user_init_load_addr, initSize);// 安全copy 经加载器load的结果 __user_init_load_addr -> userText
  ret = LOS_VaddrToPaddrMmap(processCB->vmSpace, (VADDR_T)(UINTPTR)userInitTextStart, LOS_PaddrQuery(userText),
               initSize, VM_MAP_REGION_FLAG_PERM_READ | VM_MAP_REGION_FLAG_PERM_WRITE |
               VM_MAP_REGION_FLAG_PERM_EXECUTE | VM_MAP_REGION_FLAG_PERM_USER);// 虚拟地址与物理地址的映射
  if (ret < 0) {
        goto ERROR;
    }
    (VOID)memset_s((VOID *)((UINTPTR)userText + userInitBssStart - userInitTextStart), initBssSize, 0, initBssSize);// 除了代码段，其余都清0
    stack = OsUserInitStackAlloc(g_userInitProcess, &size);// 初始化堆栈区
    if (stack == NULL) {
        PRINTK("user init process malloc user stack failed!\n");
        ret = LOS_NOK;
        goto ERROR;
    }
    param.pfnTaskEntry = (TSK_ENTRY_FUNC)userInitTextStart;// 从代码区开始执行，也就是应用程序main 函数的位置
    param.userParam.userSP = (UINTPTR)stack + size;// 指向栈底
    param.userParam.userMapBase = (UINTPTR)stack;// 栈顶
    param.userParam.userMapSize = size;// 栈大小
    param.uwResved = OS_TASK_FLAG_PTHREAD_JOIN;// 可结合的（joinable）能够被其他线程收回其资源和杀死
    ret = OsUserInitProcessStart(g_userInitProcess, &param);// 创建一个任务，来运行main函数
    if (ret != LOS_OK) {
        (VOID)OsUnMMap(processCB->vmSpace, param.userParam.userMapBase, param.userParam.userMapSize);
    goto ERROR;
  }
  return LOS_OK;
ERROR:
  (VOID)LOS_PhysPagesFreeContiguous(userText, initSize >> PAGE_SHIFT);//释放物理内存块
  OsDeInitPCB(processCB);//删除PCB块
  return ret;
}

所有用户进程都来自 init 进程的分支。可以看到在创建流程的时候创建了一个任务。入口函数是代码区的第一条指令，是应用程序的主要函数。我们在这里谈谈堆栈的大小。不同空间的任务栈空间不同。鸿蒙内核中有三种栈空间大小段友sdk初始化失败，如下

#define LOSCFG_BASE_CORE_TSK_IDLE_STACK_SIZE SIZE(0x800)//内核进程，运行在内核空间2K
#define OS_USER_TASK_SYSCALL_SATCK_SIZE 0x3000 //用户进程，通过系统调用创建的task运行在内核空间的 12K
#define OS_USER_TASK_STACK_SIZE         0x100000//用户进程运行在用户空间的1M