日志标签 ‘内存管理’

Linux页框分配函数的实现(1)-主体分配函数

2012年1月11日

内核中有六个基本的页框分配函数,它们内部经过封装,最终都会调用alloc_pages_node()。这个函数的参数比alloc_pages()多了一个nid,它用来指定节点id,如果nid小于0,则说明在当前节点上分配页框。正确获取到节点id后,接下来调用__alloc_pages()。

static inline struct page *alloc_pages_node(int nid, gfp_t gfp_mask, unsigned int order)
{
        if (nid < 0)
                nid = numa_node_id();

        return __alloc_pages(gfp_mask, order, node_zonelist(nid, gfp_mask));
}

__alloc_pages()第三个参数根据nid和gfp_mask得到适当的zonelist链表,该过程通过node_zonelist()完成。该函数的实现比较简单,其中NODE_DATA()根据nid返回对应的内存节点描述符,而gfp_zonelist()根据flags标志选取对应的内存管理区链表。其实node_zonelist()就是根据flags在相应内存节点的node_zonelists数组中选择一个何时的内存管理区链表zonelist。

static inline int gfp_zonelist(gfp_t flags)
{
        if (NUMA_BUILD && unlikely(flags & __GFP_THISNODE))
                return 1;

        return 0;
}

由于node_zonelists数组的元素个数最大为2,因此gfp_zonelist()返回0或者1。如果flags中设置了__GFP_THISNODE并且NUMA被设置,则表明使用当前节点对应的zonelist,返回1。否则使用备用zonelist,也就是说当本地节点中zone不足时,在其他节点中申请页框。

static inline int gfp_zonelist(gfp_t flags)
{
        if (NUMA_BUILD && unlikely(flags & __GFP_THISNODE))
                return 1;

        return 0;
}

__alloc_pages()内部再次封装__alloc_pages_nodemask()。

static inline struct page *
__alloc_pages(gfp_t gfp_mask, unsigned int order, struct zonelist *zonelist)
{
        return __alloc_pages_nodemask(gfp_mask, order, zonelist, NULL);
}

1. 主体分配函数

现在进入__alloc_pages_nodemask(),它作为页框分配函数的核心部分。该函数可以通过get_page_from_freelist()快速分配所请求的内存,但是大多数情况下调用该函数都会失败,因为通常物理内存的使用情况都比较紧张,这一点从其后if语句中的unlikely就可以看出。

struct page *
__alloc_pages_nodemask(gfp_t gfp_mask, unsigned int order,struct zonelist *zonelist, nodemask_t *nodemask)
{
        enum zone_type high_zoneidx = gfp_zone(gfp_mask);
        struct zone *preferred_zone;
        struct page *page;
        int migratetype = allocflags_to_migratetype(gfp_mask);

        gfp_mask &= gfp_allowed_mask;

        lockdep_trace_alloc(gfp_mask);

        might_sleep_if(gfp_mask & __GFP_WAIT);

        if (should_fail_alloc_page(gfp_mask, order))
                return NULL; 

        if (unlikely(!zonelist->_zonerefs->zone))
                return NULL;            

        first_zones_zonelist(zonelist, high_zoneidx, nodemask, &preferred_zone);
        if (!preferred_zone)
                return NULL;

        page = get_page_from_freelist(gfp_mask|__GFP_HARDWALL, nodemask, order,
                        zonelist, high_zoneidx, ALLOC_WMARK_LOW|ALLOC_CPUSET,
                        preferred_zone, migratetype);
        if (unlikely(!page))
                page = __alloc_pages_slowpath(gfp_mask, order,
                                zonelist, high_zoneidx, nodemask,
                                preferred_zone, migratetype);

        trace_mm_page_alloc(page, order, gfp_mask, migratetype);
        return page;
}

首先,gfp_zone()根据gfp_mask选取适当类型的zone。在经过几项参数检查后,该函数通过zonelist->_zonerefs->zone判断zonelist是否为空,既至少需要一个zone可用。接着根据一开始选取的zone类型high_zoneidx,通过first_zones_zonelist()确定优先分配内存的内存管理区。

如果一切顺利,将会进入get_page_from_freelist(),这个函数可以看作是伙伴算法的前置函数,它通过分配标志和分配阶判断是否能进行此次内存分配。如果可以分配,则它进行实际的内存分配工作,既利用伙伴算法进行分配内存。否则,进入__alloc_pages_slowpath(),此时内核需要放宽一些分配条件,或回收一些系统的内存,然后再调用几次get_page_from_freelist()以申请所需内存。

与虚拟内存区域有关的操作(2)-合并内存区域

2011年12月16日

合并内存区域

Linux的内存管理模块以虚拟内存区域为单位管理进程的虚拟内存,一个进程的所有内存区域分别以链表和树形结构进行组织。当一个新建的区域加入进程时,内核会试图将这个新区域与已存在的区域进行合并。区域合并的首要条件就是检查新区域之前的prve区域终止地址是否与新区域起始地址重合,或新区域的结束地址是否与其之后的next区域起始地址重合;接着再检查将要合并的区域是否有相同的标志。如果合并区域均映射了磁盘文件,则还要检查其映射文件是否相同,以及文件内的偏移量是否连续。

上述提及的一系列条件检查是在vma_merge()中完成的,根据新区域和它前后两个内存区域之间的位置关系,区域合并分为8种情况。由于合并条件的复杂性,该函数包含好几个参数,分别对上述说明的合并条件进行检测。

mm描述要添加新区域进程的内存空间,prev指向当前区域之前的一个内存区域,addr表示新区域的起始地址,end为新区域的结束地址,vm_flags表示该区域的标志。如果该新区域映射了一个磁盘文件,则file结构表示该文件,pgoff表示该文件映射的偏移量。

struct vm_area_struct *vma_merge(struct mm_struct *mm,
                        struct vm_area_struct *prev, unsigned long addr,
                        unsigned long end, unsigned long vm_flags,
                        struct anon_vma *anon_vma, struct file *file,
                        pgoff_t pgoff, struct mempolicy *policy)

合并函数首先通过起始地址和终止地址计算新区域的长度,接下来判断新区域是否设置了VM_SPECIAL,这个标志指定了该区域不能和其他区域合并,因此立即返回NULL。

        pgoff_t pglen = (end - addr) >> PAGE_SHIFT;
        struct vm_area_struct *area, *next;
        int err;

        if (vm_flags & VM_SPECIAL)
                return NULL;

        if (prev)
                next = prev->vm_next;
        else
                next = mm->mmap;
        area = next;
        if (next && next->vm_end == end)                /* cases 6, 7, 8 */
                next = next->vm_next;

接着,通过prev获得下一个内存区域的描述符next,如图1。如果新区域的终止地址与next区域的终止地址重合,则next再向前移动一个区域,如图2。为了便于说明,在图2所示的情况下,next‘表示紧邻prev的那个区域,而next表示紧邻next‘的区域。图中每个不同的内存区域都使用不同的颜色标示。

接下来开始真正的合并工作,合并分为两大类,第一大类为新区域的起始地址和prev区域的终止地址重合,第二种情况为新区域的终止地址和next区域的起始地址重合。

我们首先分析第一种情况,即便addr和prev的终止地址重合还不足以将其合并,还应通过can_vma_merge_after()判断两者的标志和映射文件等是否相同。如果都满足条件,那么合并此时就应该可以开始了。不过合并函数力求每次合并程度达到最大化,它再继续检查end是否恰好与next区域的起始地址重合。

在这样的判断条件下,会出现5种不同的合并情况(分别为case1,6,2,5,7)。每种合并情况最终都会调用vma_adjust(),它通过修改vma结构中的字段对区域进行适当调整,也就是说真正的合并是在这个函数中完成的。可以看出vma_merge()本质上是一个“分流”函数,它将区域合并细化,根据不同的合并情况向vma_adjust()传递不同的参数。

        if (prev && prev->vm_end == addr &&
                        mpol_equal(vma_policy(prev), policy) &&
                        can_vma_merge_after(prev, vm_flags,
                                                anon_vma, file, pgoff)) {
                if (next && end == next->vm_start &&
                                mpol_equal(policy, vma_policy(next)) &&
                                can_vma_merge_before(next, vm_flags,
                                        anon_vma, file, pgoff+pglen) &&
                                is_mergeable_anon_vma(prev->anon_vma,
                                                      next->anon_vma)) {
                                                        /* cases 1, 6 */
                        err = vma_adjust(prev, prev->vm_start,
                                next->vm_end, prev->vm_pgoff, NULL);
                } else                                  /* cases 2, 5, 7 */
                        err = vma_adjust(prev, prev->vm_start,
                                end, prev->vm_pgoff, NULL);
                if (err)
                        return NULL;
                return prev;
        }

从上面的分析以及源码可以看出,case1和case6既满足addr与prev终止地址重合,又满足end与next起始地址重合,但是他们的next(如图1,2)却指向不同的区域。case1可参考下图,它实际上是填充了prev和next之间的“空洞”,也就是说三个区域合为一个区域,vma_adjust()会删除next区域同时扩大prev区域。

case6也可以看作是填充prev和next区域之间的空洞,不过它会将next‘区域进行“覆盖”。通过代码可以发现,next‘和next区域事实上是连续的,不过由于其他原因,比如标志不同,造成它们是两个不同的区域。尽管地址连续,但是组织的时候仍然通过链表链接。这里为了定量的表示区域之间的关系,省去了next‘和next之间的链接箭头。

如果end与next的起始地址不重合,那么会出现case2,case5,case7三种情况。这三种情况的差异会在vma_adjust()中被进一步区分,而在当前函数中,它们被看作是一种情况,即addr与prev终止地址重合而end与next起始地址不重合。

如果end小于next区域的起始地址,则为case2。

 

如果end大于next区域的起始地址,则为case5。在这种情况下,next会被一分为二,一部分加入prev,而另一部分则继续保留在原始区域中。

case7也是一种扩大prev的情况,它会将next‘覆盖,而next则保持不变。

当上述情况都不符合时,进入第二大类合并,即end与next的起始地址重合。在这种情形下涉及三种合并模型,它们的图示分别如下所示。

        if (next && end == next->vm_start &&
                        mpol_equal(policy, vma_policy(next)) &&
                        can_vma_merge_before(next, vm_flags,
                                        anon_vma, file, pgoff+pglen)) {
                if (prev && addr < prev->vm_end)        /* case 4 */
                        err = vma_adjust(prev, prev->vm_start,
                                addr, prev->vm_pgoff, NULL);
                else                                    /* cases 3, 8 */
                        err = vma_adjust(area, addr, next->vm_end,
                                next->vm_pgoff - pglen, NULL);
                if (err)
                        return NULL;
                return area;
        }

        return NULL;

如果addr大于prev的终止地址,则属于case4。这种情况下缩小prev,扩充next。

如果addr小于prev区域的终止地址,则属于case3。这种情况下prev不做改变,扩充next。

case8与case3比较类似,不过它会覆盖已存在的next‘。

从源码的条件判断语句可以看出,上述8种合并情况可以规划为四类,通过向vma_adjust()传递不同的参数可以为每种情况调节内存区域。

vmalloc()的基本实现

2011年11月21日

每个进程都拥有一段连续而且平坦的虚拟地址空间,这段连续的空间被划分为两大部分:用户空间和内核空间。在x86-32架构下,用户空间占据最低端的3G,内核空间占据最高的1G。事实上,每个进程并不会同时使用掉整个3G的地址空间,因此整个用户空间又进一步被划分为若干个虚拟内存区域(struct vm_area_struct),每个内存区域都有相应的访问权限,并且针对当前的内存区域还有具体的操作函数。

对于内核空间而言,根据不同的映射规则,整个内核空间划分为四大部分:物理内存映射区、vmalloc区、永久内核映射区和固定映射的线性地址区域。内核空间的映射情况如下图所示:

其中vmalloc区(struct vm_struct)跟用户空间的虚拟内存区域有些类似,它们都是利用分散的物理页框构建连续的虚拟地址区间。

非连续内存区的数据结构

vmalloc区也被称为非连续内存区域,整个非连续内存区的起始地址定义为VMALLOC_START宏,结束地址定义为VMALLOC_END宏。它由若干个vmalloc区组成,每个vmalloc区之间间隔4KB,这是为了防止非法的内存访问。内核中使用vm_struct结构来表示每个vmalloc区,也就是说,每次调用vmalloc()函数在内核中申请一段连续的内存后,都对应着一个vm_struct,系统中所有的vmalloc区组成一个链表,链表头指针为vmlist。vm_sttruct结构在最新内核源码的描述如下(本文所涉及的内核源码均来自v3.0.4):

struct vm_struct {
        struct vm_struct        *next;
        void                    *addr;
        unsigned long           size;
        unsigned long           flags;
        struct page             **pages;
        unsigned int            nr_pages;
        unsigned long           phys_addr;
        void                    *caller;
};

下面是这个结构中各个字段的解释:

next:所有的vm_struct结构组成一个vmlist链表,该字段指向下一个节点;

addr:vmalloc()最终是在内核空间中申请一个内存区域,addr代表这段子区域的起始地址;

size:表示子区域的大小;

flags:表示该非连续内存区的类型,VM_ALLOC表示由vmalloc()映射的内存区,VM_MAP表示通过vmap()映射的内存区,VM_IOREMAP表示通过ioremap()将硬件设备的内存映射到内核的一段内存区;

pages:指针数组,该数组的成员是struct page*类型的指针,每个成员都关联一个映射到该虚拟内存区的物理页框;

nr_pages:pages数组中page结构的总数;

phys_addr:通常为0,当使用ioremap()映射一个硬件设备的物理内存时才填充此字段;

caller:表示一个返回地址;

vmalloc()的实现

vmalloc()内部封装了__vmalloc_node(),该函数的原型和调用如下代码所示。其中,size表示要分配子内存区的大小,它通过vmalloc()传递过来的;align表示将所申请长度的内存区分为几部分,1表示将size大小的虚拟内存区作为一个整体;gfp_mask描述页面分配的标志,GFP_KERNEL|__GFP_HIGHMEM表明内存管理子系统将从高端内存区(ZONE_HIGHMEM)中分配内存空间;prot描述当前页的保护标志;node表示在哪个节点(struct pg_data_t)上为这段子内存区分配空间,-1表明在当前节点中分配;caller表示该函数的返回地址。

static void *__vmalloc_node(unsigned long size, unsigned long align,
                            gfp_t gfp_mask, pgprot_t prot,
                            int node, void *caller)
void *vmalloc(unsigned long size)
{
        return __vmalloc_node(size, 1, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL,
                                        -1, __builtin_return_address(0));
}

__vmalloc_node函数的主要功能分为两部分:

1.在非连续内存区的起始和终止地址之间查找一个空闲的内存区域,这部分由__get_vm_area_node()完成。

2.为该子内存区分配物理页框,并将分散的物理页框分别映射到连续的vmalloc区中,这部分由__vmalloc_area_node()完成。

__vmalloc_node()一开始会先修正一下自内存取的大小,PAGE_ALIGN将size的大小修改成页大小的倍数。假如要申请1KB的内存区,那么事实上分配的是4KB大小(一个页大小)的区域。接着进行size合法性的检查,如果size为0,或者size所占页框数大于系统当前空闲的页框数(totalram_pages),将返回NULL,既申请失败。

如果子内存区大小合法,__get_vm_area_node()将在整个非连续内存区中查找一个size大小的子内存区。该函数先遍历整个vmlist链表,依次比对每个vmalloc区,直到找到满足要求的子内存区为止。接着为这个子内存区建立一个vm_struct结构,再将这个结构插入到整个vmlist链表中。该函数的详细实现过程本文不做分析。

static void *__vmalloc_node(unsigned long size, unsigned long align,
                            gfp_t gfp_mask, pgprot_t prot,
                            int node, void *caller)
{
        struct vm_struct *area;
        void *addr;
        unsigned long real_size = size;

        size = PAGE_ALIGN(size);
        if (!size || (size >> PAGE_SHIFT) > totalram_pages)
                return NULL;

        area = __get_vm_area_node(size, align, VM_ALLOC, VMALLOC_START,
                                  VMALLOC_END, node, gfp_mask, caller);

        if (!area)
                return NULL;

        addr = __vmalloc_area_node(area, gfp_mask, prot, node, caller);

        kmemleak_alloc(addr, real_size, 3, gfp_mask);

        return addr;
}

__vmalloc_area_node()的实现

当__get_vm_area_node()创建了一个新的vm_struct结构后,接下来就要通过__vmalloc_area_node()为这个子内存区分配真正的物理页。
首先计算通过右移PAGE_SHIFT位来计算nr_pages,它表示这个子内存区映射的页数。接着根据子内存区所映射的页框数计算pages数组的大小,这个数组的元素为struct page*型,每个元素都指向一个用来描述物理页框的page结构。

static void *__vmalloc_area_node(struct vm_struct *area, gfp_t gfp_mask,
                                 pgprot_t prot, int node, void *caller)
{
        struct page **pages;
        unsigned int nr_pages, array_size, i;
        gfp_t nested_gfp = (gfp_mask & GFP_RECLAIM_MASK) | __GFP_ZERO;

        nr_pages = (area->size - PAGE_SIZE) >> PAGE_SHIFT;
        array_size = (nr_pages * sizeof(struct page *));

        area->nr_pages = nr_pages;

接着,__vmalloc_area_node()为页描述符指针数组分配空间。如果这个指针数组的大小超过一个页的大小,那么递归调用__vmalloc_node()为其分配空间,也就是说pages数组本身就采用vmalloc区来存储;否则,通过kmalloc_node()为pages数组分配一段连续的空间,这段空间既位于内核空间的物理内存线性映射区。

接下来用刚才的局部变量pages更新area中的pages。如果pages数组分配失败,则调用remove_vm_area()将__get_vm_area_node()的到的vm_struct结构从vmlist中移除,并返回NULL,表示vmalloc()申请失败。

        if (array_size > PAGE_SIZE) {
                pages = __vmalloc_node(array_size, 1, nested_gfp|__GFP_HIGHMEM,
                                PAGE_KERNEL, node, caller);
                area->flags |= VM_VPAGES;
        } else {
                pages = kmalloc_node(array_size, nested_gfp, node);
        }
        area->pages = pages;
        area->caller = caller;
        if (!area->pages) {
                remove_vm_area(area->addr);
                kfree(area);
                return NULL;
        }

现在到了最关键的时刻,通过一个循环依次为pages数组中的每个页面描述符分配真正的物理页框。需要注意的是page结构并不是代表一个具体的物理页框,只是用来描述物理页框的数据结构而已。如果node小于0,也就是未指定物理内存所在节点,那么使用alloc_page()分配一个页框,并将该页框对应的页描述符指针赋值给page临时变量;否则通过alloc_pages_node()在指定的节点上分配物理页框。接着将刚刚分配的物理页框对应的页描述符赋值给pages数组的第i个元素。一旦某个物理页框分配失败则直接返回NULL,表示本次vmalloc()操作失败。

        for (i = 0; i < area->nr_pages; i++) {
                struct page *page;
                if (node < 0)
                        page = alloc_page(gfp_mask);
                else
                        page = alloc_pages_node(node, gfp_mask, 0);

                if (unlikely(!page)) {
                        area->nr_pages = i;
                        goto fail;
                }
                area->pages[i] = page;
        }

        if (map_vm_area(area, prot, &pages))
                goto fail;
        return area->addr;

fail:
        vfree(area->addr);
        return NULL;
}

到目前为止,__vmalloc_area_node()已经分配了所需的物理页框,但是这些分散的页框并没有映射到area所代表的那个连续vmalloc区中。map_vm_area()将完成映射工作,它依次修改内核使用的页表项,将pages数组中的每个页框分别映射到连续的vmalloc区中。

Linux内存管理实践-虚拟地址转换物理地址

2011年11月1日

Linux内核中采用了通用的四级分页模型,这种模型不仅适合32位系统也适合64位系统。分页单元是MMU(内存管理单元)中的一部分,它将线性地址转换为物理地址。本文通过一个内核模块程序模拟内核中虚拟地址转换为物理地址的过程,有关分页机制的原理可以参见这里的文章。

static void get_pgtable_macro(void)
{
	printk("PAGE_OFFSET = 0x%lx\n", PAGE_OFFSET);
	printk("PGDIR_SHIFT = %d\n", PGDIR_SHIFT);
	printk("PUD_SHIFT = %d\n", PUD_SHIFT);
	printk("PMD_SHIFT = %d\n", PMD_SHIFT);
	printk("PAGE_SHIFT = %d\n", PAGE_SHIFT);

	printk("PTRS_PER_PGD = %d\n", PTRS_PER_PGD);
	printk("PTRS_PER_PUD = %d\n", PTRS_PER_PUD);
	printk("PTRS_PER_PMD = %d\n", PTRS_PER_PMD);
	printk("PTRS_PER_PTE = %d\n", PTRS_PER_PTE);

	printk("PAGE_MASK = 0x%lx\n", PAGE_MASK);
}

static unsigned long vaddr2paddr(unsigned long vaddr)
{
	pgd_t *pgd;
	pud_t *pud;
	pmd_t *pmd;
	pte_t *pte;
	unsigned long paddr = 0;
        unsigned long page_addr = 0;
	unsigned long page_offset = 0;

	pgd = pgd_offset(current->mm, vaddr);
	printk("pgd_val = 0x%lx\n", pgd_val(*pgd));
	printk("pgd_index = %lu\n", pgd_index(vaddr));
	if (pgd_none(*pgd)) {
		printk("not mapped in pgd\n");
		return -1;
	}

	pud = pud_offset(pgd, vaddr);
	printk("pud_val = 0x%lx\n", pud_val(*pud));
	if (pud_none(*pud)) {
		printk("not mapped in pud\n");
		return -1;
	}

	pmd = pmd_offset(pud, vaddr);
	printk("pmd_val = 0x%lx\n", pmd_val(*pmd));
	printk("pmd_index = %lu\n", pmd_index(vaddr));
	if (pmd_none(*pmd)) {
		printk("not mapped in pmd\n");
		return -1;
	}

	pte = pte_offset_kernel(pmd, vaddr);
	printk("pte_val = 0x%lx\n", pte_val(*pte));
	printk("pte_index = %lu\n", pte_index(vaddr));
	if (pte_none(*pte)) {
		printk("not mapped in pte\n");
		return -1;
	}

	//页框物理地址机制 | 偏移量
	page_addr = pte_val(*pte) & PAGE_MASK;
	page_offset = vaddr & ~PAGE_MASK;
	paddr = page_addr | page_offset;
	printk("page_addr = %lx, page_offset = %lx\n", page_addr, page_offset);
        printk("vaddr = %lx, paddr = %lx\n", vaddr, paddr);

	return paddr;
}

static int __init v2p_init(void)
{
	unsigned long vaddr = 0;

	printk("vaddr to paddr module is running..\n");
	get_pgtable_macro();
	printk("\n");

	vaddr = (unsigned long)vmalloc(1000 * sizeof(char));
	if (vaddr == 0) {
		printk("vmalloc failed..\n");
		return 0;
	}
	printk("vmalloc_vaddr=0x%lx\n", vaddr);
	vaddr2paddr(vaddr);

	printk("\n\n");
	vaddr = __get_free_page(GFP_KERNEL);
	if (vaddr == 0) {
		printk("__get_free_page failed..\n");
		return 0;
	}
	printk("get_page_vaddr=0x%lx\n", vaddr);
	vaddr2paddr(vaddr);

	return 0;
}

static void __exit v2p_exit(void)
{
	printk("vaddr to paddr module is leaving..\n");
        vfree((void *)vaddr);
        free_page(vaddr);
}

整个程序的结构如下:

1.get_pgtable_macro()打印当前系统分页机制中的一些宏。

2.通过vmalloc()在内核空间中分配内存,调用vaddr2paddr()将虚拟地址转化成物理地址。

3.通过__get_free_pages()在内核空间中分配页框,调用vaddr2paddr()将虚拟地址转化成物理地址。

4.分别通过vfree()和free_page()释放申请的内存空间。

vaddr2paddr()的执行过程如下:

1.通过pgd_offset计算页全局目录项的线性地址pgd,传入的参数为内存描述符mm和线性地址vaddr。接着打印pgd所指的页全局目录项。

2.通过pud_offset计算页上级目录项的线性地址pud,传入的参数为页全局目录项的线性地址pgd和线性地址vaddr。接着打印pud所指的页上级目录项。

3.通过pmd_offset计算页中间目录项的线性地址pmd,传入的参数为页上级目录项的线性地址pud和线性地址vaddr。接着打印pmd所指的页中间目录项。

4.通过pte_offset_kernel计算页表项的线性地址pte,传入的参数为页中间目录项的线性地址pmd和线性地址vaddr。接着打印pte所指的页表项。

5.pte_val(*pte)先取出页表项,与PAGE_MASK相与的结果是得到要访问页的物理地址;vaddr&~PAGE_MASK用来得到线性地址offset字段;两者或运算得到最终的物理地址。

6.打印物理地址。

windows 7 ultimate product key

windows 7 ultimate product key

winrar download free

winrar download free

winzip registration code

winzip registration code

winzip free download

winzip free download

winzip activation code

winzip activation code

windows 7 key generator

windows 7 key generator

winzip freeware

winzip freeware

winzip free download full version

winzip free download full version

free winrar download

free winrar download

free winrar

free winrar

windows 7 crack

windows 7 crack

windows xp product key

windows xp product key

windows 7 activation crack

windows7 activation crack

free winzip

free winzip

winrar free download

winrar free download

winrar free

winrar free

download winrar free

download winrar free

windows 7 product key

windows 7 product key