万字解读鸿蒙轻内核物理内存模块

转x33g5p2x  于2021-11-11 转载在 其他  
字(22.6k)|赞(0)|评价(0)|浏览(663)

**摘要：**本文首先了解了物理内存管理的结构体，接着阅读了物理内存如何初始化，然后分析了物理内存的申请、释放和查询等操作接口的源代码。

本文分享自华为云社区《鸿蒙轻内核A核源码分析系列三 物理内存》，作者： zhushy。

物理内存（Physical memory）是指通过物理内存条而获得的内存空间，相对应的概念是虚拟内存（Virtual memory）。虚拟内存使得应用进程认为它拥有一个连续完整的内存地址空间，而通常是通过虚拟内存和物理内存的映射对应着多个物理内存页。本文我们先来熟悉下OpenHarmony鸿蒙轻内核提供的物理内存（Physical memory）管理模块。

本文中所涉及的源码，以OpenHarmony LiteOS-A内核为例，均可以在开源站点kernel_liteos_a: LiteOS kernel for embedded devices with rich resources | 适用于资源较丰富嵌入式设备的LiteOS内核 获取。如果涉及开发板，则默认以hispark_taurus为例。

我们首先了解了物理内存管理的结构体，接着阅读了物理内存如何初始化，然后分析了物理内存的申请、释放和查询等操作接口的源代码。

1、物理内存结构体介绍

1.1、物理内存页LosVmPage

鸿蒙轻内核A核的物理内存采用了段页式管理，每个物理内存段被分割为物理内存页。在头文件kernel/base/include/los_vm_page.h中定义了物理内存页结构体，以及内存页数组g_vmPageArray及数组大小g_vmPageArraySize。物理内存页结构体LosVmPage可以和物理内存页一一对应，也可以对应多个连续的内存页，此时使用nPages指定内存页的数量。

  1. typedef struct VmPage {
  2.     LOS_DL_LIST         node;        /**< 物理内存页节点，挂在VmFreeList空闲内存页链表上 */
  3.     PADDR_T             physAddr;    /**< 物理内存页内存开始地址*/
  4.     Atomic              refCounts;   /**< 物理内存页引用计数 */
  5.     UINT32              flags;       /**< 物理内存页标记 */
  6.     UINT8               order;       /**< 物理内存页所在的链表数组的索引，总共有9个链表 */
  7.     UINT8               segID;       /**< 物理内存页所在的物理内存段的编号 */
  8.     UINT16              nPages;      /**< 连续物理内存页的数量 */
  9. } LosVmPage;
  11. extern LosVmPage *g_vmPageArray;
  12. extern size_t g_vmPageArraySize;

在文件kernel\base\include\los_vm_common.h中定义了内存页的大小、掩码和逻辑位移值，可以看出每个内存页的大小为4KiB。

  1. #ifndef PAGE_SIZE
  2. #define PAGE_SIZE                        (0x1000U)
  3. #endif
  4. #define PAGE_MASK                        (~(PAGE_SIZE - 1))
  5. #define PAGE_SHIFT                       (12)

1.2、物理内存段LosVmPhysSeg

在文件kernel/base/include/los_vm_phys.h中定义了物理内存段LosVmPhysSeg等几个结构体。该文件的部分代码如下所示。⑴处的宏是物理内存伙伴算法中空闲内存页节点链表数组的大小，VM_PHYS_SEG_MAX表示系统支持的物理内存段的数量。⑵处的结构体用于伙伴算法中空闲内存页节点链表数组的元素类型，除了记录双向链表，还维护链表上节点数量。⑶就是我们要介绍的物理内存段，包含开始地址，大小，内存页基地址，空闲内存页节点链表数组，LRU链表数组等成员。

  1. ⑴  #define VM_LIST_ORDER_MAX    9
  2.     #define VM_PHYS_SEG_MAX    32
  4. ⑵  struct VmFreeList {
  5.         LOS_DL_LIST node;   // 空闲物理内存页节点
  6.         UINT32 listCnt;     // 空闲物理内存页节点数量
  7.     };
  9. ⑶  typedef struct VmPhysSeg {
  10.         PADDR_T start;            /* 物理内存段的开始地址 */
  11.         size_t size;              /* 物理内存段的大小，bytes */
  12.         LosVmPage *pageBase;      /* 物理内存段第一个物理内存页结构体地址 */
  14.         SPIN_LOCK_S freeListLock; /* 伙伴算法双向链表自旋锁 */
  15.         struct VmFreeList freeList[VM_LIST_ORDER_MAX];  /* 空闲物理内存页的伙伴双向链表 */
  17.         SPIN_LOCK_S lruLock;  /* LRU双向链表自旋锁 */
  18.         size_t lruSize[VM_NR_LRU_LISTS];  /* LRU大小 */
  19.         LOS_DL_LIST lruList[VM_NR_LRU_LISTS];/* LRU双向链表 */
  20.     } LosVmPhysSeg;
  22.     struct VmPhysArea {
  23.         PADDR_T start;  // 物理内存区开始地址
  24.         size_t size;    // 物理内存区大小
  25.     };

在kernel/base/vm/los_vm_phys.c文件中定义了物理内存区数组g_physArea[]，如下代码所示，其中SYS_MEM_BASE为DDR_MEM_ADDR的宏名称，DDR_MEM_ADDR和SYS_MEM_SIZE_DEFAULT定义在文件./device/hisilicon/hispark_taurus/sdk_liteos/board/target_config.h中，表示开发板相关的物理内存地址和大小。

  1. STATIC struct VmPhysArea g_physArea[] = {
  2.     {
  3.         .start = SYS_MEM_BASE,
  4.         .size = SYS_MEM_SIZE_DEFAULT,
  5.     },
  6. };

看下物理内存区VmPhysArea和物理内存段的LosVmPhysSeg区别，前者信息教少，主要记录开始地址和大小，为一块物理内存的最简单描述；后者除了物理内存块开始地址和大小，还维护物理页开始地址，空闲物理页伙伴链表，LRU链表，相应的自旋锁等信息。

上面提到了伙伴算法，先看下伙伴算法的示意图，如下。每个物理内存段都分割为一个一个的内存页，空闲的内存页挂载在空闲内存页节点链表上。共有9个空闲内存页节点链表，这些链表组成链表数组。第一个链表上的内存页节点大小为1个内存页，第二个链表上的内存页节点大小为2个内存页，第三个链表上的内存页节点大小为4个内存页，依次下去，第9个链表上的内存页节点大小为2^8个内存页。申请内存、释放内存时会操作这些空闲内存页节点链表，后文详细分析。

2、物理内存管理模块初始化

本节主要讲解物理内存管理模块是如何初始化的，核心函数是OsVmPageStartup()。在讲解之前，会先看下物理内存初始化过程中的一些内部函数。

2.1 物理内存管理初始化内部函数

2.1.1 函数OsVmPhysSegCreate

函数OsVmPhysSegCreate用于把指定的一个物理内存区VmPhysArea转换为物理内存段LosVmPhysSeg。传入的2个参数分别为物理内存区的开始内存地址和大小。⑴处表示系统支持的物理内存段的数量为32个，超过则转换错误。⑵处从物理内存段全局数组g_vmPhysSeg中获取一个可用的物理内存段。⑶处如果物理内存段seg为数组g_vmPhysSeg中的第一个元素，则跳过循环体直接执行⑸设置物理内存段的开始地址和大小。如果不为第一个元素，并且前一个物理内存段的开始地址在要转换的物理内存段的结束地址之后，则执行⑷处代码覆盖前一个物理内存段。在配置物理内存区的时候，需要注意这里的影响。

  1. STATIC INT32 OsVmPhysSegCreate(paddr_t start, size_t size)
  2. {
  3.     struct VmPhysSeg *seg = NULL;
  5. ⑴  if (g_vmPhysSegNum >= VM_PHYS_SEG_MAX) {
  6.         return -1;
  7.     }
  9. ⑵  seg = &g_vmPhysSeg[g_vmPhysSegNum++];
  10. ⑶  for (; (seg > g_vmPhysSeg) && ((seg - 1)->start > (start + size)); seg--) {
  11. ⑷      *seg = *(seg - 1);
  12.     }
  13. ⑸  seg->start = start;
  14.     seg->size = size;
  16.     return 0;
  17. }

函数OsVmPhysSegAdd调用上述函数OsVmPhysSegCreate依次把配置的多个物理内存区一一进行转换，对于开发板hispark_taurus只配置了一块物理内存区域。

  1. VOID OsVmPhysSegAdd(VOID)
  2. {
  3.     INT32 i, ret;
  5.     LOS_ASSERT(g_vmPhysSegNum < VM_PHYS_SEG_MAX);
  7.     for (i = 0; i < (sizeof(g_physArea) / sizeof(g_physArea[0])); i++) {
  8.         ret = OsVmPhysSegCreate(g_physArea[i].start, g_physArea[i].size);
  9.         if (ret != 0) {
  10.             VM_ERR("create phys seg failed");
  11.         }
  12.     }
  13. }

2.1.2 函数OsVmPhysInit

函数OsVmPhysInit继续初始化物理内存段信息。⑴处循环物理内存段数组，这里不是循环32次，而是多少个物理段就循环遍历多少次。遍历到每一个物理内存段，然后执行⑵设置当前物理内存段的第一个物理页结构体的地址，每一个物理内存页都有自己的结构体LosVmPage，这些结构体维护在通过malloc内存堆申请的g_vmPageArray数组里，后文会详细讲述。⑶处seg->size >> PAGE_SHIFT计算当前内存段对于的内存页数量，然后更新nPages，这是后续物理内存段第一个内存页对应的的物理内存页结构体在数组g_vmPageArray中索引。⑷处开始的函数OsVmPhysFreeListInit和OsVmPhysLruInit初始化伙伴双向链表和LRU双向链表，后续分析这2个函数。

  1. VOID OsVmPhysInit(VOID)
  2. {
  3.     struct VmPhysSeg *seg = NULL;
  4.     UINT32 nPages = 0;
  5.     int i;
  7.     for (i = 0; i < g_vmPhysSegNum; i++) {
  8. ⑴      seg = &g_vmPhysSeg[i];
  9. ⑵      seg->pageBase = &g_vmPageArray[nPages];
  10. ⑶      nPages += seg->size >> PAGE_SHIFT;
  11. ⑷      OsVmPhysFreeListInit(seg);
  12.         OsVmPhysLruInit(seg);
  13.     }
  14. }

2.1.3 函数OsVmPhysFreeListInit

每个物理内存段使用9个空闲物理内存页节点链表来维护空闲物理内存页。OsVmPhysFreeListInit函数用于初始化指定物理内存段的空闲物理内存页节点链表。操作前后需要开启、关闭空闲链表自旋锁。⑴处遍历空闲物理内存页节点链表数组，然后执行⑵初始化每个双向链表。⑶处把每个链表中的空闲物理内存页的数量初始化为0。

  1. STATIC INLINE VOID OsVmPhysFreeListInit(struct VmPhysSeg *seg)
  2. {
  3.     int i;
  4.     UINT32 intSave;
  5.     struct VmFreeList *list = NULL;
  7.     LOS_SpinInit(&seg->freeListLock);
  9.     LOS_SpinLockSave(&seg->freeListLock, &intSave);
  10.     for (i = 0; i < VM_LIST_ORDER_MAX; i++) {
  11. ⑴      list = &seg->freeList[i];
  12. ⑵      LOS_ListInit(&list->node);
  13. ⑶      list->listCnt = 0;
  14.     }
  15.     LOS_SpinUnlockRestore(&seg->freeListLock, intSave);
  16. }

2.1.4 函数OsVmPhysLruInit

和上个函数类似，函数OsVmPhysLruInit初始化指定物理内存段的LRU链表数组中的LRU链表。LRU链表分五类，由枚举类型enum OsLruList定义。代码较简单，读者自行阅读代码即可。

  1. STATIC VOID OsVmPhysLruInit(struct VmPhysSeg *seg)
  2. {
  3.     INT32 i;
  4.     UINT32 intSave;
  5.     LOS_SpinInit(&seg->lruLock);
  7.     LOS_SpinLockSave(&seg->lruLock, &intSave);
  8.     for (i = 0; i < VM_NR_LRU_LISTS; i++) {
  9.         seg->lruSize[i] = 0;
  10.         LOS_ListInit(&seg->lruList[i]);
  11.     }
  12.     LOS_SpinUnlockRestore(&seg->lruLock, intSave);
  13. }

2.1.5 函数OsVmPageInit

函数OsVmPageInit用于初始化物理内存页的初始值，该函数需要3个参数，分别是物理内存页结构体地址，物理内存页的开始地址，物理内存段编号。⑴处初始化内存页的链表节点，这个链表节点通常会挂载在伙伴算法的空闲内存页节点链表上。⑵处设置内存页标记为空闲内存页FILE_PAGE_FREE，该值由枚举类型enum OsPageFlags定义。⑶处设置内存页的引用计数为0。⑷处设置内存页的开始地址。⑸处设置内存页所在的物理内存段的编号。⑹处设置内存页顺序order初始值，此时不属于任何空闲内存页节点链表。⑺处设置内存页的nPages数值为0。⑻处的宏VMPAGEINIT调用函数OsVmPageInit并自动增加内存页结构体page地址和内存页pa地址。

  1. STATIC VOID OsVmPageInit(LosVmPage *page, paddr_t pa, UINT8 segID)
  2. {
  3. ⑴  LOS_ListInit(&page->node);
  4. ⑵  page->flags = FILE_PAGE_FREE;
  5. ⑶  LOS_AtomicSet(&page->refCounts, 0);
  6. ⑷  page->physAddr = pa;
  7. ⑸  page->segID = segID;
  8. ⑹  page->order = VM_LIST_ORDER_MAX;
  9. ⑺  page->nPages = 0;
  10. }
  12. ...
  13.  
  14. #define VMPAGEINIT(page, pa, segID) do {    \
  15. ⑻   OsVmPageInit(page, pa, segID);         \
  16.     (page)++;                               \
  17.     (pa) += PAGE_SIZE;                      \
  18. } while (0)

2.2 物理内存页初始化函数VOID OsVmPageStartup(VOID)

了解上述几个内部函数后，我们正式开始阅读物理内存页初始化函数VOID OsVmPageStartup(VOID)。系统在启动时，该函数用于初始化物理内存，把物理内存段划分割为为物理内存页。该函数被kernel/base/vm/los_vm_boot.c中的UINT32 OsSysMemInit(VOID)调用，进一步被文件platform/los_config.c中的INT32 OsMain(VOID)函数调用。下面详细分析下函数的代码。

⑴处的g_vmBootMemBase初始值为(UINTPTR)&__bss_end，表示系统可用内存在bss段之后；ROUNDUP用于内存向上对齐。函数OsVmPhysAreaSizeAdjust()用于调整物理区的开始地址和大小。⑵处的 OsVmPhysPageNumGet()计算物理内存段可以划分多少物理内存页，此行代码重新计算物理内存页数目，此时每个物理页对应一个物理页结构体，相应结构体也占用内存空间。 ⑶处计算物理页结构体数组的大小，数组的每个元素对应每个物理页结构体LosVmPage。接下来一行调用函数OsVmBootMemAlloc为物理页结构体数组g_vmPageArray申请内存空间，申请的内存空间从地址g_vmBootMemBase截取指定的长度。⑷处再次调用函数OsVmPhysAreaSizeAdjust()用于调整物理内存区的开始地址和大小，确保基于内存页对齐。⑸处调用函数OsVmPhysSegAdd()转换为物理内存段，⑹处调用OsVmPhysInit函数初始化物理内存段的空闲物理内存页节点链表和LRU链表。上文分析过这几个内部函数。⑺处遍历每个物理内存段，获取遍历到的物理内存段的总页数nPage。⑻处为提升初始化物理内存页的性能，把页数分为8份，count为每份的内存页的数目，left为等分为8份后剩余的内存页数。⑼处循环初始化物理内存页，⑽处初始化剩余的物理内存页。⑾处的函数OsVmPageOrderListInit把物理内存页插入到空闲内存页节点链表，该函数进一步调用OsVmPhysPagesFreeContiguous函数，后续再分析该函数。初始化完成后，物理内存段上的内存页都挂载到空闲内存页节点链表上了。

  1. VOID OsVmPageStartup(VOID)
  2. {
  3.     struct VmPhysSeg *seg = NULL;
  4.     LosVmPage *page = NULL;
  5.     paddr_t pa;
  6.     UINT32 nPage;
  7.     INT32 segID;
  9. ⑴  OsVmPhysAreaSizeAdjust(ROUNDUP((g_vmBootMemBase - KERNEL_ASPACE_BASE), PAGE_SIZE));
  11.     /*
  12.      * Pages getting from OsVmPhysPageNumGet() interface here contain the memory
  13.      * struct LosVmPage occupied, which satisfies the equation:
  14.      * nPage * sizeof(LosVmPage) + nPage * PAGE_SIZE = OsVmPhysPageNumGet() * PAGE_SIZE.
  15.      */
  16. ⑵  nPage = OsVmPhysPageNumGet() * PAGE_SIZE / (sizeof(LosVmPage) + PAGE_SIZE);
  17. ⑶  g_vmPageArraySize = nPage * sizeof(LosVmPage);
  18.     g_vmPageArray = (LosVmPage *)OsVmBootMemAlloc(g_vmPageArraySize);
  20. ⑷  OsVmPhysAreaSizeAdjust(ROUNDUP(g_vmPageArraySize, PAGE_SIZE));
  22. ⑸  OsVmPhysSegAdd();
  23. ⑹  OsVmPhysInit();
  25.     for (segID = 0; segID < g_vmPhysSegNum; segID++) {
  26. ⑺      seg = &g_vmPhysSeg[segID];
  27.         nPage = seg->size >> PAGE_SHIFT;
  28. ⑻      UINT32 count = nPage >> 3; /* 3: 2 ^ 3, nPage / 8, cycle count */
  29.         UINT32 left = nPage & 0x7; /* 0x7: nPage % 8, left page */
  31. ⑼      for (page = seg->pageBase, pa = seg->start; count > 0; count--) {
  32.             /* note: process large amount of data, optimize performance */
  33.             VMPAGEINIT(page, pa, segID);
  34.             VMPAGEINIT(page, pa, segID);
  35.             VMPAGEINIT(page, pa, segID);
  36.             VMPAGEINIT(page, pa, segID);
  37.             VMPAGEINIT(page, pa, segID);
  38.             VMPAGEINIT(page, pa, segID);
  39.             VMPAGEINIT(page, pa, segID);
  40.             VMPAGEINIT(page, pa, segID);
  41.         }
  42.         for (; left > 0; left--) {
  43. ⑽          VMPAGEINIT(page, pa, segID);
  44.         }
  45. ⑾      OsVmPageOrderListInit(seg->pageBase, nPage);
  46.     }
  47. }

3、物理内存管理模块接口

学习过物理内存初始化后，接下来我们会分析物理内存管理模块的接口函数，包含申请、释放、查询等功能接口。

3.1 申请物理内存页接口

3.1.1 申请物理内存页接口介绍

申请物理内存页的接口有3个，分别用于满足不同的申请需求。LOS_PhysPagesAllocContiguous函数的传入参数为要申请物理内存页的数目，返回值为申请到的物理内存页对应的内核虚拟地址空间中的虚拟内存地址。⑴处调用函数OsVmPhysPagesGet申请指定数目的物理内存页，然后⑵处调用函数OsVmPageToVaddr转换为内核虚拟内存地址。函数LOS_PhysPageAlloc申请一个物理内存页，返回值为申请到的物理页对应的物理页结构体地址。代码比较简单，见⑶处，调用函数OsVmPageToVaddr传入ONE_PAGE参数申请1个物理内存页。函数LOS_PhysPagesAlloc用于申请nPages个物理内存页，并挂在双向链表list上，返回值为实际申请到的物理页数目。⑷处循环调用函数OsVmPhysPagesGet()申请一个物理内存页，如果申请成功不为空，则插入到双向链表，申请成功的物理页的数目加1；如果申请失败则跳出循环。⑹返回实际申请到的物理页的数目。

  1. VOID *LOS_PhysPagesAllocContiguous(size_t nPages)
  2. {
  3.     LosVmPage *page = NULL;
  5.     if (nPages == 0) {
  6.         return NULL;
  7.     }
  9. ⑴  page = OsVmPhysPagesGet(nPages);
  10.     if (page == NULL) {
  11.         return NULL;
  12.     }
  14. ⑵   return OsVmPageToVaddr(page);
  15. }
  16. ......
  17.  
  18. LosVmPage *LOS_PhysPageAlloc(VOID)
  19. {
  20. ⑶   return OsVmPhysPagesGet(ONE_PAGE);
  21. }
  23. size_t LOS_PhysPagesAlloc(size_t nPages, LOS_DL_LIST *list)
  24. {
  25.     LosVmPage *page = NULL;
  26.     size_t count = 0;
  28.     if ((list == NULL) || (nPages == 0)) {
  29.         return 0;
  30.     }
  32.     while (nPages--) {
  33. ⑷      page = OsVmPhysPagesGet(ONE_PAGE);
  34.         if (page == NULL) {
  35.             break;
  36.         }
  37. ⑸      LOS_ListTailInsert(list, &page->node);
  38.         count++;
  39.     }
  41. ⑹   return count;
  42. }

3.1.2 申请物理内存页内部接口实现

3个内存页申请函数都调用了函数OsVmPhysPagesGet，下文会详细分析申请物理内存页内部接口实现。

3.1.2.1 函数OsVmPhysPagesGet

函数OsVmPhysPagesGet用于申请指定数量的物理内存页，返回值为物理内存页结构体地址。⑴处遍历物理内存段数组，对遍历到的物理内存段执行⑵处代码，调用函数OsVmPhysPagesAlloc()从指定的内存段中申请指定数目的物理内存页。如果申请成功，则执行⑶把内存页的引用计数初始化为0，根据注释，如果是连续的内存页，则第一个内存页持有引用计数数值。接下来以后更新内存页的数量，并返回申请到的内存页的结构体地址；如果申请失败则继续循环申请或者返回NULL。

  1. STATIC LosVmPage *OsVmPhysPagesGet(size_t nPages)
  2. {
  3.     UINT32 intSave;
  4.     struct VmPhysSeg *seg = NULL;
  5.     LosVmPage *page = NULL;
  6.     UINT32 segID;
  8.     for (segID = 0; segID < g_vmPhysSegNum; segID++) {
  9. ⑴      seg = &g_vmPhysSeg[segID];
  10.         LOS_SpinLockSave(&seg->freeListLock, &intSave);
  11. ⑵      page = OsVmPhysPagesAlloc(seg, nPages);
  12.         if (page != NULL) {
  13.             /* the first page of continuous physical addresses holds refCounts */
  14. ⑶          LOS_AtomicSet(&page->refCounts, 0);
  15.             page->nPages = nPages;
  16.             LOS_SpinUnlockRestore(&seg->freeListLock, intSave);
  17.             return page;
  18.         }
  19.         LOS_SpinUnlockRestore(&seg->freeListLock, intSave);
  20.     }
  21.     return NULL;
  22. }

3.1.2.2 函数OsVmPhysPagesAlloc

从上文的介绍，我们知道物理内存段包含一个空闲内存页节点链表数组，数组大小为9。数组中的每个链表上的内存页节点的大小等于2的幂次方个内存页，例如：第0个链表上挂载的空闲内存节点的大小为2的0次方个内存页，即1个内存页；第8个链表上挂载的内存页节点的大小为2的8次方个内存页，即256个内存页。相同大小的内存块挂在同一个链表上进行管理。

分析函数OsVmPhysPagesAlloc之前，先看下函数OsVmPagesToOrder，该函数根据指定的物理页的数目计算属于空闲内存页节点链表数组中的第几个双向链表。当nPages为最小1时，order取值为0；当为2时，order取值1…等于取底为2的对数Log2(nPages)。

  1. #define VM_ORDER_TO_PAGES(order) (1 << (order))
  2. ......
  3. UINT32 OsVmPagesToOrder(size_t nPages)
  4. {
  5.     UINT32 order;
  7.     for (order = 0; VM_ORDER_TO_PAGES(order) < nPages; order++);
  9.     return order;
  10. }

继续分析下函数OsVmPhysPagesAlloc()，该函数基于传入参数从指定的内存段申请指定数目的内存页。⑴处调用的函数上文已经讲述，根据内存页数目计算出链表数组索引值。如果索引值小于链表最大索引值VM_LIST_ORDER_MAX，则执行⑵从小内存页节点向大内存页节点循环各个双向链表。⑶处获取双向链表，如果空闲链表为空则继续循环；如果不为空，则执行⑷获取链表上的空闲内存页结构体。

如果根据内存页数计算出的数组索引值大于等于链表最大索引值VM_LIST_ORDER_MAX，说明空闲链表上并没有这么大块的内存页节点，需要从物理内存段上申请，需要执行⑸调用函数OsVmPhysLargeAlloc()申请大的内存页。如果申请不到内存页则申请失败，返回NULL；如果申请到合适的内存页，则继续执行后续DONE标签代码。这些代码从空闲链表中删除，拆分，多余的空闲内存页插入空闲链表等，后文继续分析调用的这些函数。先看下这些参数的实际传入参数，order为要申请的内存页对应的链表数组索引，newOrder为实际申请的内存页对应的链表数组索引。⑹处的for循环条件中，&page[nPages]为需要申请的内存页结构体的结束地址，&tmp[1 << newOrder]表示伙伴算法中空闲内存页节点链表上的内存块的结束地址。这里为啥使用for循环呢，上面申请内存时，应该申请了多个内存节点拼接起来了。看下⑺处的函数的传入参数，&page[nPages]为需要申请的内存页结构体的结束地址，往后的部分被拆分放入空闲链表。(1 << min(order, newOrder))表示实际申请的内存页的数目。

  1. STATIC LosVmPage *OsVmPhysPagesAlloc(struct VmPhysSeg *seg, size_t nPages)
  2. {
  3.     struct VmFreeList *list = NULL;
  4.     LosVmPage *page = NULL;
  5.     LosVmPage *tmp = NULL;
  6.     UINT32 order;
  7.     UINT32 newOrder;
  9. ⑴  order = OsVmPagesToOrder(nPages);
  10.     if (order < VM_LIST_ORDER_MAX) {
  11. ⑵      for (newOrder = order; newOrder < VM_LIST_ORDER_MAX; newOrder++) {
  12. ⑶          list = &seg->freeList[newOrder];
  13.             if (LOS_ListEmpty(&list->node)) {
  14.                 continue;
  15.             }
  16. ⑷          page = LOS_DL_LIST_ENTRY(LOS_DL_LIST_FIRST(&list->node), LosVmPage, node);
  17.             goto DONE;
  18.         }
  19.     } else {
  20.         newOrder = VM_LIST_ORDER_MAX - 1;
  21. ⑸      page = OsVmPhysLargeAlloc(seg, nPages);
  22.         if (page != NULL) {
  23.             goto DONE;
  24.         }
  25.     }
  26.     return NULL;
  27. DONE:
  29.     for (tmp = page; tmp < &page[nPages]; tmp = &tmp[1 << newOrder]) {
  30. ⑹       OsVmPhysFreeListDelUnsafe(tmp);
  31.     }
  32.     OsVmPhysPagesSpiltUnsafe(page, order, newOrder);
  33. ⑺  OsVmRecycleExtraPages(&page[nPages], nPages, ROUNDUP(nPages, (1 << min(order, newOrder))));
  35.     return page;
  36. }

3.1.2.3 函数OsVmPhysLargeAlloc

当执行到这个函数时，说明空闲链表上的单个内存页节点的大小已经不能满足要求，超过了第9个链表上的内存页节点的大小了。⑴处计算需要申请的内存大小。⑵从最大的链表上进行遍历每一个内存页节点。⑶根据每个内存页的开始内存地址，计算需要的内存的结束地址，如果超过内存段的大小，则继续遍历下一个内存页节点。

⑷处此时paStart表示当前内存页的结束地址，接下来paStart >= paEnd表示当前内存页的大小满足申请的需求；paStart < seg->start和paStart >= (seg->start + seg->size)发生溢出错误，内存页结束地址不在内存段的地址范围内。⑸处表示当前内存页的下一个内存页结构体，如果该结构体不在空闲链表上，则break跳出循环。如果在空闲链表上，表示连续的空闲内存页会拼接起来，满足大内存申请的需要。⑹表示一个或者多个连续的内存页的大小满足申请需求。

  1. STATIC LosVmPage *OsVmPhysLargeAlloc(struct VmPhysSeg *seg, size_t nPages)
  2. {
  3.     struct VmFreeList *list = NULL;
  4.     LosVmPage *page = NULL;
  5.     LosVmPage *tmp = NULL;
  6.     PADDR_T paStart;
  7.     PADDR_T paEnd;
  8. ⑴  size_t size = nPages << PAGE_SHIFT;
  10. ⑵  list = &seg->freeList[VM_LIST_ORDER_MAX - 1];
  11.     LOS_DL_LIST_FOR_EACH_ENTRY(page, &list->node, LosVmPage, node) {
  12. ⑶      paStart = page->physAddr;
  13.         paEnd = paStart + size;
  14.         if (paEnd > (seg->start + seg->size)) {
  15.             continue;
  16.         }
  18.         for (;;) {
  19. ⑷          paStart += PAGE_SIZE << (VM_LIST_ORDER_MAX - 1);
  20.             if ((paStart >= paEnd) || (paStart < seg->start) ||
  21.                 (paStart >= (seg->start + seg->size))) {
  22.                 break;
  23.             }
  24. ⑸          tmp = &seg->pageBase[(paStart - seg->start) >> PAGE_SHIFT];
  25.             if (tmp->order != (VM_LIST_ORDER_MAX - 1)) {
  26.                 break;
  27.             }
  28.         }
  29. ⑹      if (paStart >= paEnd) {
  30.             return page;
  31.         }
  32.     }
  34.     return NULL;
  35. }

3.1.2.4 函数OsVmPhysFreeListDelUnsafe和OsVmPhysFreeListAddUnsafe

内部函数OsVmPhysFreeListDelUnsafe用于从空闲内存页节点链表上删除一个内存页节点，名称中有Unsafe字样，是因为函数体内并没有对链表操作加自旋锁，安全性由外部调用函数保证。⑴处进行校验，确保内存段和空闲链表索引符合要求。⑵处获取内存段和空闲链表，⑶处空闲链表上内存页节点数目减1，并把内存块从空闲链表上删除。⑷处设置内存页的order索引值为最大值来标记非空闲内存页。

  1. STATIC VOID OsVmPhysFreeListDelUnsafe(LosVmPage *page)
  2. {
  3.     struct VmPhysSeg *seg = NULL;
  4.     struct VmFreeList *list = NULL;
  6. ⑴  if ((page->segID >= VM_PHYS_SEG_MAX) || (page->order >= VM_LIST_ORDER_MAX)) {
  7.         LOS_Panic("The page segment id(%u) or order(%u) is invalid\n", page->segID, page->order);
  8.     }
  10. ⑵  seg = &g_vmPhysSeg[page->segID];
  11.     list = &seg->freeList[page->order];
  12. ⑶  list->listCnt--;
  13.     LOS_ListDelete(&page->node);
  14. ⑷  page->order = VM_LIST_ORDER_MAX;
  15. }

和空闲链表上删除对应的函数是空闲链表上插入空闲内存页节点函数OsVmPhysFreeListAddUnsafe。⑴处更新内存页的要挂载的空闲链表的索引值，然后获取内存页所在的内存段seg，并获取索引值对应的空闲链表。执行⑵把空闲内存页节点插入到空闲链表并更新节点数目。

  1. STATIC VOID OsVmPhysFreeListAddUnsafe(LosVmPage *page, UINT8 order)
  2. {
  3.     struct VmPhysSeg *seg = NULL;
  4.     struct VmFreeList *list = NULL;
  6.     if (page->segID >= VM_PHYS_SEG_MAX) {
  7.         LOS_Panic("The page segment id(%d) is invalid\n", page->segID);
  8.     }
  10. ⑴  page->order = order;
  11.     seg = &g_vmPhysSeg[page->segID];
  13.     list = &seg->freeList[order];
  14. ⑵   LOS_ListTailInsert(&list->node, &page->node);
  15.     list->listCnt++;
  16. }

3.1.2.5 函数OsVmPhysPagesSpiltUnsafe

函数OsVmPhysPagesSpiltUnsafe用于分割内存块，参数中oldOrder表示需要申请的内存页节点对应的链表索引，newOrder表示实际申请的内存页节点对应的链表索引。如果索引值相等，则不需要拆分，不会执行for循环块的代码。由于伙伴算法中的链表数组中元素的特点，即每个链表中的内存页节点的大小等于2的幂次方个内存页。在拆分时，依次从高索引newOrder往低索引oldOrder遍历，拆分一个内存页节点作为空闲内存页节点挂载到对应的空闲链表上。⑴处开始循环从高索引到低索引，索引值减1，然后执行⑵获取伙伴内存页节点，可以看出，申请的内存块大于需求时，会把后半部分的高地址部分放入空闲链表，保留前半部分的低地址部分。⑶处的断言确保伙伴内存页节点索引值是最大值，表示属于空闲内存页节点。⑷处调用函数把内存页节点放入空闲链表。

  1. STATIC VOID OsVmPhysPagesSpiltUnsafe(LosVmPage *page, UINT8 oldOrder, UINT8 newOrder)
  2. {
  3.     UINT32 order;
  4.     LosVmPage *buddyPage = NULL;
  6.     for (order = newOrder; order > oldOrder;) {
  7. ⑴      order--;
  8. ⑵      buddyPage = &page[VM_ORDER_TO_PAGES(order)];
  9. ⑶      LOS_ASSERT(buddyPage->order == VM_LIST_ORDER_MAX);
  10. ⑷      OsVmPhysFreeListAddUnsafe(buddyPage, order);
  11.     }
  12. }

这里有必要放这一张图，直观演示一下。假如我们需要申请8个内存页大小的内存节点，但是只有freeList[7]链表上才有空闲节点。申请成功后，超过了应用需要的大小，需要进行拆分。把2^7个内存页分为2份大小为2^6个内存页的节点，第一份继续拆分，第二份挂载到freeList[6]链表上。然后把第一份2^6个内存页拆分为2个2^5个内存页节点，第一份继续拆分，第二份挂载到freeList[5]链表上。依次进行下去，最后拆分为2份2^3个内存页大小的内存页节点，第一份作为实际申请的内存页返回，第二份挂载到freeList[3]链表上。如下图红色部分所示。

另外，函数OsVmRecycleExtraPages会调用OsVmPhysPagesFreeContiguous来回收申请的多余的内存页，后文再分析。

3.2 释放物理内存页接口

3.2.1 释放物理内存页接口介绍

和申请物理内存页接口相对应着，释放物理内存页的接口有3个，分别用于满足不同的释放内存页需求。函数LOS_PhysPagesFreeContiguous的传入参数为要释放物理页对应的内核虚拟地址空间中的虚拟内存地址和内存页数目。⑴处调用函数OsVmVaddrToPage把虚拟内存地址转换为物理内存页结构体地址，然后⑵处把内存页的连续内存页数目设置为0。⑶处调用函数OsVmPhysPagesFreeContiguous()释放物理内存页。函数LOS_PhysPageFree用于释放一个物理内存页，传入参数为要释放的物理页对应的物理页结构体地址。⑷处对引用计数自减，当小于等于0，表示没有其他引用时才进一步执行释放操作。该函数同样会调用函数OsVmPhysPagesFreeContiguous()释放物理内存页。函数LOS_PhysPagesFree用于释放挂在双向链表上的多个物理内存页，返回值为实际释放的物理页数目。⑸处遍历内存页双向链表，从链表上移除要释放的内存页节点。⑹处代码和释放一个内存页的函数代码相同。⑺处计算遍历的内存页的数目，函数最后会返回该值。

  1. VOID LOS_PhysPagesFreeContiguous(VOID *ptr, size_t nPages)
  2. {
  3.     UINT32 intSave;
  4.     struct VmPhysSeg *seg = NULL;
  5.     LosVmPage *page = NULL;
  7.     if (ptr == NULL) {
  8.         return;
  9.     }
  11. ⑴   page = OsVmVaddrToPage(ptr);
  12.     if (page == NULL) {
  13.         VM_ERR("vm page of ptr(%#x) is null", ptr);
  14.         return;
  15.     }
  16. ⑵  page->nPages = 0;
  18.     seg = &g_vmPhysSeg[page->segID];
  19.     LOS_SpinLockSave(&seg->freeListLock, &intSave);
  21. ⑶   OsVmPhysPagesFreeContiguous(page, nPages);
  23.     LOS_SpinUnlockRestore(&seg->freeListLock, intSave);
  24. }
  26. ......
  27.  
  28. VOID LOS_PhysPageFree(LosVmPage *page)
  29. {
  30.     UINT32 intSave;
  31.     struct VmPhysSeg *seg = NULL;
  33.     if (page == NULL) {
  34.         return;
  35.     }
  37. ⑷  if (LOS_AtomicDecRet(&page->refCounts) <= 0) {
  38.         seg = &g_vmPhysSeg[page->segID];
  39.         LOS_SpinLockSave(&seg->freeListLock, &intSave);
  41.         OsVmPhysPagesFreeContiguous(page, ONE_PAGE);
  42.         LOS_AtomicSet(&page->refCounts, 0);
  44.         LOS_SpinUnlockRestore(&seg->freeListLock, intSave);
  45.     }
  46. }
  47. ······
  48. size_t LOS_PhysPagesFree(LOS_DL_LIST *list)
  49. {
  50.     UINT32 intSave;
  51.     LosVmPage *page = NULL;
  52.     LosVmPage *nPage = NULL;
  53.     LosVmPhysSeg *seg = NULL;
  54.     size_t count = 0;
  56.     if (list == NULL) {
  57.         return 0;
  58.     }
  60.     LOS_DL_LIST_FOR_EACH_ENTRY_SAFE(page, nPage, list, LosVmPage, node) {
  61. ⑸      LOS_ListDelete(&page->node);
  62. ⑹      if (LOS_AtomicDecRet(&page->refCounts) <= 0) {
  63.             seg = &g_vmPhysSeg[page->segID];
  64.             LOS_SpinLockSave(&seg->freeListLock, &intSave);
  65.             OsVmPhysPagesFreeContiguous(page, ONE_PAGE);
  66.             LOS_AtomicSet(&page->refCounts, 0);
  67.             LOS_SpinUnlockRestore(&seg->freeListLock, intSave);
  68.         }
  69. ⑺      count++;
  70.     }
  72.     return count;
  73. }

3.2.2 释放物理内存页内部接口实现

3.2.2.1 函数OsVmVaddrToPage

函数OsVmVaddrToPage把虚拟内存地址转换为物理页结构体地址。⑴处调用函数LOS_PaddrQuery()把虚拟地址转为物理地址，该函数在虚实映射部分会详细讲述。⑵处遍历物理内存段，如果物理内存地址处于物理内存段的地址范围，则可以返回该物理地址对应的物理页结构体地址。

  1. LosVmPage *OsVmVaddrToPage(VOID *ptr)
  2. {
  3.     struct VmPhysSeg *seg = NULL;
  4. ⑴  PADDR_T pa = LOS_PaddrQuery(ptr);
  5.     UINT32 segID;
  7.     for (segID = 0; segID < g_vmPhysSegNum; segID++) {
  8.         seg = &g_vmPhysSeg[segID];
  9. ⑵      if ((pa >= seg->start) && (pa < (seg->start + seg->size))) {
  10.             return seg->pageBase + ((pa - seg->start) >> PAGE_SHIFT);
  11.         }
  12.     }
  14.     return NULL;
  15. }

3.2.2.2 函数OsVmPhysPagesFreeContiguous

函数OsVmPhysPagesFreeContiguous()用于释放指定数量的连续物理内存页。⑴处根据物理内存页获取对应的物理内存地址。⑵处根据物理内存地址获取空闲内存页链表数组索引数值(TODO为什么物理内存地址和索引有对应关系？)，⑶处获取索引值对应的链表上的内存页节点的内存页数目。⑷处如果要释放的内存页数nPages小于当前链表上的内存页节点的数目，则跳出循环执行⑹处代码，去释放到小索引的双向链表上。⑸处调用函数OsVmPhysPagesFree()释放指定链表上的内存页，然后更新内存页数量和内存页结构体地址。

⑹处根据内存页数量计算对应的链表索引，根据索引值计算链表上内存页节点的大小。⑺处调用函数OsVmPhysPagesFree()释放指定链表上的内存页，然后更新内存页数量和内存页结构体地址。

  1. VOID OsVmPhysPagesFreeContiguous(LosVmPage *page, size_t nPages)
  2. {
  3.     paddr_t pa;
  4.     UINT32 order;
  5.     size_t n;
  7.     while (TRUE) {
  8. ⑴      pa = VM_PAGE_TO_PHYS(page);
  9. ⑵      order = VM_PHYS_TO_ORDER(pa);
  10. ⑶      n = VM_ORDER_TO_PAGES(order);
  11. ⑷      if (n > nPages) {
  12.             break;
  13.         }
  14. ⑸      OsVmPhysPagesFree(page, order);
  15.         nPages -= n;
  16.         page += n;
  17.     }
  19.     while (nPages > 0) {
  20. ⑹      order = LOS_HighBitGet(nPages);
  21.         n = VM_ORDER_TO_PAGES(order);
  22. ⑺      OsVmPhysPagesFree(page, order);
  23.         nPages -= n;
  24.         page += n;
  25.     }
  26. }

3.2.2.3 函数OsVmPhysPagesFree

函数OsVmPhysPagesFree()释放内存页到对应的空闲内存页链表。⑴做传入参数校验。⑵处需要至少是倒数第二个链表，这样内存页节点可以和大索引链表上的节点合并。⑶处获取内存页对应的物理内存地址。⑷处的VM_ORDER_TO_PHYS(order)计算出链表索引值对应的物理地址，然后进行异或运算计算出伙伴页的物理内存地址。⑸处物理地址转换为内存页结构体，进一步判断如果内存页不存在或者不在空闲链表上，则跳出循环while循环。否则执行⑹把伙伴页从链表上移除，然后索引值加1。⑺处更新物理地址及其对齐的内存页（TODO 没有看懂）。当索引order为8，要插入到最后一个链表上时，则直接执行⑻插入内存页到链表上。

  1. VOID OsVmPhysPagesFree(LosVmPage *page, UINT8 order)
  2. {
  3.     paddr_t pa;
  4.     LosVmPage *buddyPage = NULL;
  6. ⑴  if ((page == NULL) || (order >= VM_LIST_ORDER_MAX)) {
  7.         return;
  8.     }
  10. ⑵  if (order < VM_LIST_ORDER_MAX - 1) {
  11. ⑶        pa = VM_PAGE_TO_PHYS(page);        
  12.         do {
  13. ⑷          pa ^= VM_ORDER_TO_PHYS(order);
  14. ⑸          buddyPage = OsVmPhysToPage(pa, page->segID);
  15.             if ((buddyPage == NULL) || (buddyPage->order != order)) {
  16.                 break;
  17.             }
  18. ⑹          OsVmPhysFreeListDel(buddyPage);
  19.             order++;
  20. ⑺          pa &= ~(VM_ORDER_TO_PHYS(order) - 1);
  21.             page = OsVmPhysToPage(pa, page->segID);
  22.         } while (order < VM_LIST_ORDER_MAX - 1);
  23.     }
  25. ⑻  OsVmPhysFreeListAdd(page, order);
  26. }

3.3 查询物理页地址接口

3.3.1 函数LOS_VmPageGet()

函数LOS_VmPageGet用于根据物理内存地址参数计算对应的物理内存页结构体地址。⑴处遍历物理内存段，调用函数OsVmPhysToPage根据物理内存地址和内存段编号计算物理内存页结构体，该函数后文再分析。⑵处如果获取的物理内存页结构体不为空，则跳出循环，返回物理内存页结构体指针。

  1. LosVmPage *LOS_VmPageGet(PADDR_T paddr)
  2. {
  3.     INT32 segID;
  4.     LosVmPage *page = NULL;
  6.     for (segID = 0; segID < g_vmPhysSegNum; segID++) {
  7. ⑴      page = OsVmPhysToPage(paddr, segID);
  8. ⑵      if (page != NULL) {
  9.             break;
  10.         }
  11.     }
  13.     return page;
  14. }

继续看下函数OsVmPhysToPage的代码。⑴处如果参数传入的物理内存地址不在指定的物理内存段的地址范围之内则返回NULL。⑵处计算物理内存地址相对内存段开始地址的偏移值。⑶处根据偏移值计算出偏移的内存页的数目，然后返回物理内存地址对应的物理页结构体的地址。

  1. LosVmPage *OsVmPhysToPage(paddr_t pa, UINT8 segID)
  2. {
  3.     struct VmPhysSeg *seg = NULL;
  4.     paddr_t offset;
  6.     if (segID >= VM_PHYS_SEG_MAX) {
  7.         LOS_Panic("The page segment id(%d) is invalid\n", segID);
  8.     }
  9.     seg = &g_vmPhysSeg[segID];
  10. ⑴  if ((pa < seg->start) || (pa >= (seg->start + seg->size))) {
  11.         return NULL;
  12.     }
  14. ⑵  offset = pa - seg->start;
  15. ⑶  return (seg->pageBase + (offset >> PAGE_SHIFT));
  16. }

3.3.2 函数LOS_PaddrToKVaddr

函数LOS_PaddrToKVaddr根据物理地址获取其对应的内核虚拟地址。⑴处遍历物理内存段数组，然后在⑵处判断如果物理地址处于遍历到的物理内存段的地址范围内，则执行⑶，传入的物理内存地址相对物理内存开始地址的偏移加上内核态虚拟地址空间的开始地址就是物理地址对应的内核虚拟地址。

  1. VADDR_T *LOS_PaddrToKVaddr(PADDR_T paddr)
  2. {
  3.     struct VmPhysSeg *seg = NULL;
  4.     UINT32 segID;
  6.     for (segID = 0; segID < g_vmPhysSegNum; segID++) {
  7.  ⑴     seg = &g_vmPhysSeg[segID];
  8.  ⑵     if ((paddr >= seg->start) && (paddr < (seg->start + seg->size))) {
  9.  ⑶          return (VADDR_T *)(UINTPTR)(paddr - SYS_MEM_BASE + KERNEL_ASPACE_BASE);
  10.         }
  11.     }
  13.     return (VADDR_T *)(UINTPTR)(paddr - SYS_MEM_BASE + KERNEL_ASPACE_BASE);
  14. }

3.4 其他函数

3.4.1 函数OsPhysSharePageCopy

函数OsPhysSharePageCopy用于复制共享内存页。 ⑴处进行参数校验， ⑵处获取老内存页， ⑶处获取内存段。⑷处如果老内存页引用计数为1，则把老物理内存地址直接赋值给新物理内存地址。⑸处如果内存页有多个引用，则先转化为虚拟内存地址，然后执行⑹进行内存页的内容复制。⑺刷新新老内存页的引用计数。

  1. VOID OsPhysSharePageCopy(PADDR_T oldPaddr, PADDR_T *newPaddr, LosVmPage *newPage)
  2. {
  3.     UINT32 intSave;
  4.     LosVmPage *oldPage = NULL;
  5.     VOID *newMem = NULL;
  6.     VOID *oldMem = NULL;
  7.     LosVmPhysSeg *seg = NULL;
  9.  ⑴  if ((newPage == NULL) || (newPaddr == NULL)) {
  10.         VM_ERR("new Page invalid");
  11.         return;
  12.     }
  14.  ⑵  oldPage = LOS_VmPageGet(oldPaddr);
  15.     if (oldPage == NULL) {
  16.         VM_ERR("invalid oldPaddr %p", oldPaddr);
  17.         return;
  18.     }
  20.  ⑶  seg = &g_vmPhysSeg[oldPage->segID];
  21.     LOS_SpinLockSave(&seg->freeListLock, &intSave);
  22. ⑷  if (LOS_AtomicRead(&oldPage->refCounts) == 1) {
  23.         *newPaddr = oldPaddr;
  24.     } else {
  25. ⑸      newMem = LOS_PaddrToKVaddr(*newPaddr);
  26.         oldMem = LOS_PaddrToKVaddr(oldPaddr);
  27.         if ((newMem == NULL) || (oldMem == NULL)) {
  28.             LOS_SpinUnlockRestore(&seg->freeListLock, intSave);
  29.             return;
  30.         }
  31. ⑹      if (memcpy_s(newMem, PAGE_SIZE, oldMem, PAGE_SIZE) != EOK) {
  32.             VM_ERR("memcpy_s failed");
  33.         }
  35. ⑺      LOS_AtomicInc(&newPage->refCounts);
  36.         LOS_AtomicDec(&oldPage->refCounts);
  37.     }
  38.     LOS_SpinUnlockRestore(&seg->freeListLock, intSave);
  39.     return;
  40. }

总结

本文首先了解了物理内存管理的结构体，接着阅读了物理内存如何初始化，然后分析了物理内存的申请、释放和查询等操作接口的源代码。后续也会陆续推出更多的分享文章，敬请期待，有任何问题、建议，都可以留言给我。谢谢。

点击关注，第一时间了解华为云新鲜技术~

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/devcloud/article/details/121162566

内容来源于网络，如有侵权，请联系作者删除！

harmonyos内存管理开源社区华为虚拟内存

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多

    目录

    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com