专题：Linux内存管理专题

关键词：mm、vaddr、VMA、page、pfn、pte、paddr、pg_data、zone、mem_map[]。

1. 内存管理数据结构的关系图

在大部分Linux系统中，内存设备的初始化一般是在BIOS或bootloader中，然后把DDR的大小传递给Linux内核。因此从Linux内核角度来看DDR，其实就是一段物理内存空间。

1.1 由mm数据结构和虚拟地址vaddr找到对应的VMA

  1. extern struct vm_area_struct * find_vma(struct mm_struct * mm, unsigned long addr);
  2. extern struct vm_area_struct * find_vma_prev(struct mm_struct * mm, unsigned long addr,
  3.                          struct vm_area_struct **pprev);
  4. static inline struct vm_area_struct * find_vma_intersection(struct mm_struct * mm, unsigned long start_addr, unsigned long end_addr)
  5. {
  6.     struct vm_area_struct * vma = find_vma(mm,start_addr);
  7.  
  8.     if (vma && end_addr <= vma->vm_start)
  9.         vma = NULL;
  10.     return vma;
  11. }

由VMA得出mm数据结构，struct vm_area_struct数据结构有一个指针指向struct mm_struct。

  1. struct mm_struct {
  2.     struct vm_area_struct *mmap;        /* list of VMAs */
  3.     struct rb_root mm_rb;
  4.     u32 vmacache_seqnum;                   /* per-thread vmacache */...
  5. };
  6.  
  7. struct vm_area_struct {
  8.     /* The first cache line has the info for VMA tree walking. */
  9.  
  10.     unsigned long vm_start;        /* Our start address within vm_mm. */
  11.     unsigned long vm_end;        /* The first byte after our end address
  12.                        within vm_mm. */
  13. ...
  14.     struct rb_node vm_rb;
  15. ...
  16.     struct mm_struct *vm_mm;    /* The address space we belong to. */...
  17. }

find_vma()根据mm_struct和addr找到vma。

find_vma()首先在当前进程current->vmacache[]中查找addr对应的vma；如果未找到，则遍历mm->mm_rb，通过rb_node找到对应的vma，然后判断是否和addr吻合。

  1. struct vm_area_struct *find_vma(struct mm_struct *mm, unsigned long addr)
  2. {
  3.     struct rb_node *rb_node;
  4.     struct vm_area_struct *vma;
  5.  
  6.     /* Check the cache first. */
  7.     vma = vmacache_find(mm, addr);--------------------------------在task_struct->vmacache[]中查找，看能否命中。
  8.     if (likely(vma))
  9.         return vma;
  10.  
  11.     rb_node = mm->mm_rb.rb_node;----------------------------------找到当前mm的第一个rb_node节点。
  12.     vma = NULL;
  13.  
  14.     while (rb_node) {---------------------------------------------遍历当前mm空间的所有rb_node。
  15.         struct vm_area_struct *tmp;
  16.  
  17.         tmp = rb_entry(rb_node, struct vm_area_struct, vm_rb);----通过rb_node找到对应的vma
  18.  
  19.         if (tmp->vm_end > addr) {
  20.             vma = tmp;
  21.             if (tmp->vm_start <= addr)
  22.                 break;--------------------------------------------找到合适的vma，退出。
  23.             rb_node = rb_node->rb_left;
  24.         } else
  25.             rb_node = rb_node->rb_right;
  26.     }
  27.  
  28.     if (vma)
  29.         vmacache_update(addr, vma);-------------------------------将当前vma放到vmacache[]中。
  30.     return vma;
  31. }

1.2 由page和VMA找到虚拟地址vaddr

vma_address()只针对匿名页面：

  1. inline unsigned long
  2. vma_address(struct page *page, struct vm_area_struct *vma)
  3. {
  4.     unsigned long address = __vma_address(page, vma);
  5.  
  6.     /* page should be within @vma mapping range */
  7.     VM_BUG_ON_VMA(address < vma->vm_start || address >= vma->vm_end, vma);
  8.  
  9.     return address;
  10. }
  11.  
  12. static inline unsigned long
  13. __vma_address(struct page *page, struct vm_area_struct *vma)
  14. {
  15.     pgoff_t pgoff = page_to_pgoff(page);
  16.     return vma->vm_start + ((pgoff - vma->vm_pgoff) << PAGE_SHIFT);-------------根据page->index计算当前vma的偏移地址。
  17. }
  18.  
  19. static inline pgoff_t page_to_pgoff(struct page *page)
  20. {
  21.     if (unlikely(PageHeadHuge(page)))
  22.         return page->index << compound_order(page);
  23.     else
  24.         return page->index << (PAGE_CACHE_SHIFT - PAGE_SHIFT);------------------page->index表示在一个vma中page的index。
  25. }

1.3 由page找到所有映射的VMA

通过反向映射rmap系统rmap_walk()来实现，对于匿名页面来说是rmap_walk_anon()。

  1. static int rmap_walk_anon(struct page *page, struct rmap_walk_control *rwc)
  2. {
  3.     struct anon_vma *anon_vma;
  4.     pgoff_t pgoff;
  5.     struct anon_vma_chain *avc;
  6.     int ret = SWAP_AGAIN;
  7.  
  8.     anon_vma = rmap_walk_anon_lock(page, rwc);-----------------------------------由page->mapping找到anon_vma数据结构。
  9.     if (!anon_vma)
  10.         return ret;
  11.  
  12.     pgoff = page_to_pgoff(page);
  13.     anon_vma_interval_tree_foreach(avc, &anon_vma->rb_root, pgoff, pgoff) {-----遍历anon_vma->rb_root红黑树，取出avc数据结构。
  14.         struct vm_area_struct *vma = avc->vma;----------------------------------每个avc数据结构指向每个映射的vma
  15.         unsigned long address = vma_address(page, vma);
  16.  
  17.         if (rwc->invalid_vma && rwc->invalid_vma(vma, rwc->arg))
  18.             continue;
  19.  
  20.         ret = rwc->rmap_one(page, vma, address, rwc->arg);
  21.         if (ret != SWAP_AGAIN)
  22.             break;
  23.         if (rwc->done && rwc->done(page))
  24.             break;
  25.     }
  26.     anon_vma_unlock_read(anon_vma);
  27.     return ret;
  28. }

由vma和虚拟地址vaddr找出相应的page数据结构，可以通过follow_page()。

  1. static inline struct page *follow_page(struct vm_area_struct *vma,
  2.         unsigned long address, unsigned int foll_flags)

follow_page()由虚拟地址vaddr通过查询页表找出pte。

由pte找出页帧号pfn，然后在mem_map[]找到相应的struct page结构。

1.4 page和pfn之间的互换

page_to_pfn()和pfn_to_page()定义在linux/include/asm-generic/memory_mode.h中定义。

具体的实现方式跟memory models有关，这里定义了CONFIG_FLATMEM。

  1. #define page_to_pfn __page_to_pfn
  2. #define pfn_to_page __pfn_to_page
  3.  
  4. #define __pfn_to_page(pfn)    (mem_map + ((pfn) - ARCH_PFN_OFFSET))-----------------------------pfn减去ARCH_PFN_OFFSET得到page相对于mem_map的偏移。
  5. #define __page_to_pfn(page)    ((unsigned long)((page) - mem_map) + \
  6.                  ARCH_PFN_OFFSET)---------------------------------------------------------------page到mem_map的偏移加上ARCH_PFN_OFFSET得到当前page对应的pfn号。

在linux内核中，所有的物理内存都用struct page结构来描述，这些对象以数组形式存放，而这个数组的地址就是mem_map。

内核以节点node为单位，每个node下的物理内存统一管理，也就是说在表示内存node的描述类型struct pglist_data中，有node_mem_map这个成员。

也就是说，每个内存节点node下，成员node_mem_map是此node下所有内存以struct page描述后，所有这些对象的基地址，这些对象以数组形式存放。

1.5 pfn/page和paddr之间的互换

物理地址paddr和pfn的互换通过位移PAGE_SHIFT可以简单的得到。

page和paddr的呼唤可以通过pfn中间来实现。

  1. /*
  2.  * Convert a physical address to a Page Frame Number and back
  3.  */
  4. #define    __phys_to_pfn(paddr)    ((unsigned long)((paddr) >> PAGE_SHIFT))
  5. #define    __pfn_to_phys(pfn)    ((phys_addr_t)(pfn) << PAGE_SHIFT)
  6.  
  7. /*
  8.  * Convert a page to/from a physical address
  9.  */
  10. #define page_to_phys(page)    (__pfn_to_phys(page_to_pfn(page)))
  11. #define phys_to_page(phys)    (pfn_to_page(__phys_to_pfn(phys)))

1.6 page和pte之间的互换

先由page到pfn，然后由pfn到pte，可以实现page到pte的转换。

  1. #define pfn_pte(pfn,prot)    __pte(__pfn_to_phys(pfn) | pgprot_val(prot))
  2.  
  3. #define __page_to_pfn(page)    ((unsigned long)((page) - mem_map) + \
  4.                  ARCH_PFN_OFFSET)

由pte到page，通过pte_pfn()找到对应的pfn号，再由pfn号找到对应的page。

  1. #define pte_page(pte)        pfn_to_page(pte_pfn(pte))
  2.  
  3. #define pte_pfn(pte)        ((pte_val(pte) & PHYS_MASK) >> PAGE_SHIFT)

1.7 zone和page之间的互换

由zone到page的转换：zone数据结构有zone->start_pfn指向zone的起始页面，然后由pfn找到page的数据结构。

由page到zone的转换：page_zone()函数返回page所属的zone，通过page->flags布局实现。

1.8 zone和pg_data之间的互换

由pg_data到zone：pg_data_t->node_zones。

由zone到pg_data：zone->zone_pgdat。

2. 内存管理中常用API

内存管理错综复杂，不仅要从用户态的相关API来窥探和理解Linux内核内存是如何运作，还要总结Linux内核中常用的内存管理相关的API。

2.1 页表相关

页表相关的API可以概括为如下4类：页表查询、判断页表项的状态位、修改页表、page和pfn的关系。

  1. //查询页表
  2. #define pgd_offset_k(addr)    pgd_offset(&init_mm, addr)
  3. #define pgd_index(addr)        ((addr) >> PGDIR_SHIFT)
  4. #define pgd_offset(mm, addr)    ((mm)->pgd + pgd_index(addr))
  5.  
  6. #define pte_index(addr)        (((addr) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1))
  7. #define pte_offset_kernel(pmd,addr)    (pmd_page_vaddr(*(pmd)) + pte_index(addr))
  8. #define pte_offset_map(pmd,addr)    (__pte_map(pmd) + pte_index(addr))
  9. #define pte_unmap(pte)            __pte_unmap(pte)
  10.  
  11. //判断页表项的状态位
  12. #define pte_none(pte)        (!pte_val(pte))
  13. #define pte_present(pte)    (pte_isset((pte), L_PTE_PRESENT))
  14. #define pte_valid(pte)        (pte_isset((pte), L_PTE_VALID))
  15. #define pte_accessible(mm, pte)    (mm_tlb_flush_pending(mm) ? pte_present(pte) : pte_valid(pte))
  16. #define pte_write(pte)        (pte_isclear((pte), L_PTE_RDONLY))
  17. #define pte_dirty(pte)        (pte_isset((pte), L_PTE_DIRTY))
  18. #define pte_young(pte)        (pte_isset((pte), L_PTE_YOUNG))
  19. #define pte_exec(pte)        (pte_isclear((pte), L_PTE_XN))
  20.  
  21. //修改页表
  22. #define mk_pte(page,prot)    pfn_pte(page_to_pfn(page), prot)
  23. static inline pte_t pte_wrprotect(pte_t pte)
  24. {
  25.     return set_pte_bit(pte, __pgprot(L_PTE_RDONLY));
  26. }
  27.  
  28. static inline pte_t pte_mkwrite(pte_t pte)
  29. {
  30.     return clear_pte_bit(pte, __pgprot(L_PTE_RDONLY));
  31. }
  32.  
  33. static inline pte_t pte_mkclean(pte_t pte)
  34. {
  35.     return clear_pte_bit(pte, __pgprot(L_PTE_DIRTY));
  36. }
  37.  
  38. static inline pte_t pte_mkdirty(pte_t pte)
  39. {
  40.     return set_pte_bit(pte, __pgprot(L_PTE_DIRTY));
  41. }
  42.  
  43. static inline pte_t pte_mkold(pte_t pte)
  44. {
  45.     return clear_pte_bit(pte, __pgprot(L_PTE_YOUNG));
  46. }
  47.  
  48. static inline pte_t pte_mkyoung(pte_t pte)
  49. {
  50.     return set_pte_bit(pte, __pgprot(L_PTE_YOUNG));
  51. }
  52.  
  53. static inline pte_t pte_mkexec(pte_t pte)
  54. {
  55.     return clear_pte_bit(pte, __pgprot(L_PTE_XN));
  56. }
  57.  
  58. static inline pte_t pte_mknexec(pte_t pte)
  59. {
  60.     return set_pte_bit(pte, __pgprot(L_PTE_XN));
  61. }
  62.  
  63. static inline void set_pte_at(struct mm_struct *mm, unsigned long addr,
  64.                   pte_t *ptep, pte_t pteval)
  65. {
  66.     unsigned long ext = ;
  67.  
  68.     if (addr < TASK_SIZE && pte_valid_user(pteval)) {
  69.         if (!pte_special(pteval))
  70.             __sync_icache_dcache(pteval);
  71.         ext |= PTE_EXT_NG;
  72.     }
  73.  
  74.     set_pte_ext(ptep, pteval, ext);
  75. }
  76.  
  77. static inline pte_t clear_pte_bit(pte_t pte, pgprot_t prot)
  78. {
  79.     pte_val(pte) &= ~pgprot_val(prot);
  80.     return pte;
  81. }
  82.  
  83. static inline pte_t set_pte_bit(pte_t pte, pgprot_t prot)
  84. {
  85.     pte_val(pte) |= pgprot_val(prot);
  86.     return pte;
  87. }
  88.  
  89. int ptep_set_access_flags(struct vm_area_struct *vma,
  90.               unsigned long address, pte_t *ptep,
  91.               pte_t entry, int dirty)
  92. {
  93.     int changed = !pte_same(*ptep, entry);
  94.     if (changed) {
  95.         set_pte_at(vma->vm_mm, address, ptep, entry);
  96.         flush_tlb_fix_spurious_fault(vma, address);
  97.     }
  98.     return changed;
  99. }
  100.  
  101. //page和pfn的关系
  102. #define pte_pfn(pte)        ((pte_val(pte) & PHYS_MASK) >> PAGE_SHIFT)
  103. #define pfn_pte(pfn,prot)    __pte(__pfn_to_phys(pfn) | pgprot_val(prot))

2.2 内存分配

内核中常用的内存分配API如下。

分配和释放页面：

  1. #define alloc_pages(gfp_mask, order) \
  2.         alloc_pages_node(numa_node_id(), gfp_mask, order)
  3.  
  4. static inline struct page *
  5. __alloc_pages(gfp_t gfp_mask, unsigned int order,
  6.         struct zonelist *zonelist)
  7. {
  8.     return __alloc_pages_nodemask(gfp_mask, order, zonelist, NULL);
  9. }
  10.  
  11. unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order)
  12. {
  13.     struct page *page;
  14.  
  15.     /*
  16.      * __get_free_pages() returns a 32-bit address, which cannot represent
  17.      * a highmem page
  18.      */
  19.     VM_BUG_ON((gfp_mask & __GFP_HIGHMEM) != );
  20.  
  21.     page = alloc_pages(gfp_mask, order);
  22.     if (!page)
  23.         return ;
  24.     return (unsigned long) page_address(page);
  25. }
  26.  
  27. void free_pages(unsigned long addr, unsigned int order)
  28. {
  29.     if (addr != ) {
  30.         VM_BUG_ON(!virt_addr_valid((void *)addr));
  31.         __free_pages(virt_to_page((void *)addr), order);
  32.     }
  33. }
  34.  
  35. void __free_pages(struct page *page, unsigned int order)
  36. {
  37.     if (put_page_testzero(page)) {
  38.         if (order == )
  39.             free_hot_cold_page(page, false);
  40.         else
  41.             __free_pages_ok(page, order);
  42.     }
  43. }

slab分配器：

  1. struct kmem_cache *kmem_cache_create(const char *, size_t, size_t,
  2.             unsigned long,
  3.             void (*)(void *));
  4. void kmem_cache_destroy(struct kmem_cache *);
  5. void *kmem_cache_alloc(struct kmem_cache *, gfp_t flags);
  6. void kmem_cache_free(struct kmem_cache *, void *);
  7. static __always_inline void *kmalloc(size_t size, gfp_t flags)
  8. static inline void kfree(void *p)

vmalloc相关：

  1. extern void *vmalloc(unsigned long size);
  2. extern void *vzalloc(unsigned long size);
  3. extern void *vmalloc_user(unsigned long size);
  4. extern void vfree(const void *addr);
  5. extern void *vmap(struct page **pages, unsigned int count,
  6.             unsigned long flags, pgprot_t prot);
  7. extern void vunmap(const void *addr);

2.3 VMA操作相关

  1. extern struct vm_area_struct * find_vma(struct mm_struct * mm, unsigned long addr);
  2. extern struct vm_area_struct * find_vma_prev(struct mm_struct * mm, unsigned long addr,
  3.                          struct vm_area_struct **pprev);
  4. static inline struct vm_area_struct * find_vma_intersection(struct mm_struct * mm, unsigned long start_addr, unsigned long end_addr)
  5. {
  6.     struct vm_area_struct * vma = find_vma(mm,start_addr);
  7.  
  8.     if (vma && end_addr <= vma->vm_start)
  9.         vma = NULL;
  10.     return vma;
  11. }
  12. static inline unsigned long vma_pages(struct vm_area_struct *vma)
  13. {
  14.     return (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
  15. }

2.4 页面相关

内存管理的复杂之处是和页面相关的操作，内核中常用的API函数归纳如下：PG_XXX标志位操作、page引用计数操作、匿名页面和KSM页面、页面操作、页面映射、缺页中断、LRU和页面回收。

PG_XXX标志位操作：

  1. PageXXX()
  2. SetPageXXX()
  3. ClearPageXXX()
  4. TestSetPageXXX()
  5. TestClearPageXXX()
  6.  
  7. static inline void lock_page(struct page *page)
  8. {
  9.     might_sleep();
  10.     if (!trylock_page(page))
  11.         __lock_page(page);
  12. }
  13.  
  14. static inline int trylock_page(struct page *page)
  15. {
  16.     return (likely(!test_and_set_bit_lock(PG_locked, &page->flags)));
  17. }
  18.  
  19. void __lock_page(struct page *page)
  20. {
  21.     DEFINE_WAIT_BIT(wait, &page->flags, PG_locked);
  22.  
  23.     __wait_on_bit_lock(page_waitqueue(page), &wait, bit_wait_io,
  24.                             TASK_UNINTERRUPTIBLE);
  25. }
  26.  
  27. void wait_on_page_bit(struct page *page, int bit_nr);
  28. void wake_up_page(struct page *page, int bit)
  29. static inline void wait_on_page_locked(struct page *page)
  30. static inline void wait_on_page_writeback(struct page *page)

page引用计数操作：

  1. static inline void get_page(struct page *page)
  2. void put_page(struct page *page);
  3. #define page_cache_get(page)        get_page(page)
  4. #define page_cache_release(page)    put_page(page)
  5.  
  6. static inline int page_count(struct page *page)
  7. {
  8.     return atomic_read(&compound_head(page)->_count);
  9. }
  10.  
  11. static inline int page_mapcount(struct page *page)
  12. {
  13.     VM_BUG_ON_PAGE(PageSlab(page), page);
  14.     return atomic_read(&page->_mapcount) + ;
  15. }
  16.  
  17. static inline int page_mapped(struct page *page)
  18. {
  19.     return atomic_read(&(page)->_mapcount) >= ;
  20. }
  21.  
  22. static inline int put_page_testzero(struct page *page)
  23. {
  24.     VM_BUG_ON_PAGE(atomic_read(&page->_count) == , page);
  25.     return atomic_dec_and_test(&page->_count);
  26. }

匿名页面和KSM页面：

  1. static inline int PageAnon(struct page *page)
  2. {
  3.     return ((unsigned long)page->mapping & PAGE_MAPPING_ANON) != ;
  4. }
  5.  
  6. static inline int PageKsm(struct page *page)
  7. {
  8.     return ((unsigned long)page->mapping & PAGE_MAPPING_FLAGS) ==
  9.                 (PAGE_MAPPING_ANON | PAGE_MAPPING_KSM);
  10. }
  11.  
  12. struct address_space *page_mapping(struct page *page);
  13. static inline void *page_rmapping(struct page *page)
  14. {
  15.     return (void *)((unsigned long)page->mapping & ~PAGE_MAPPING_FLAGS);
  16. }
  17.  
  18. void page_add_new_anon_rmap(struct page *, struct vm_area_struct *, unsigned long);
  19. void page_add_file_rmap(struct page *);
  20. void page_remove_rmap(struct page *);

页面操作：

  1. static inline struct page *follow_page(struct vm_area_struct *vma,
  2.         unsigned long address, unsigned int foll_flags)
  3.  
  4. struct page *vm_normal_page(struct vm_area_struct *vma, unsigned long addr,
  5.         pte_t pte);
  6.  
  7. long get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
  8.             unsigned long start, unsigned long nr_pages,
  9.             int write, int force, struct page **pages,
  10.             struct vm_area_struct **vmas);
  11. long get_user_pages_locked(struct task_struct *tsk, struct mm_struct *mm,
  12.             unsigned long start, unsigned long nr_pages,
  13.             int write, int force, struct page **pages,
  14.             int *locked);
  15.  
  16. struct page *vm_normal_page(struct vm_area_struct *vma, unsigned long addr,
  17.         pte_t pte);

页面映射：

  1. unsigned long do_mmap_pgoff(struct file *file, unsigned long addr,
  2.     unsigned long len, unsigned long prot, unsigned long flags,
  3.     unsigned long pgoff, unsigned long *populate);
  4.  
  5. int do_munmap(struct mm_struct *, unsigned long, size_t);
  6.  
  7. int remap_pfn_range(struct vm_area_struct *, unsigned long addr,
  8.             unsigned long pfn, unsigned long size, pgprot_t);

缺页中断：

  1. static int __kprobes do_page_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
  2.  
  3. static int handle_pte_fault(struct mm_struct *mm,
  4.              struct vm_area_struct *vma, unsigned long address,
  5.              pte_t *pte, pmd_t *pmd, unsigned int flags)
  6.  
  7. static int do_anonymous_page(struct mm_struct *mm, struct vm_area_struct *vma,
  8.         unsigned long address, pte_t *page_table, pmd_t *pmd,
  9.         unsigned int flags)
  10.  
  11. static int do_wp_page(struct mm_struct *mm, struct vm_area_struct *vma,
  12.         unsigned long address, pte_t *page_table, pmd_t *pmd,
  13.         spinlock_t *ptl, pte_t orig_pte)

LRU和页面回收：

  1. void lru_cache_add(struct page *);
  2. #define lru_to_page(_head) (list_entry((_head)->prev, struct page, lru))
  3. bool zone_watermark_ok(struct zone *z, unsigned int order,
  4.         unsigned long mark, int classzone_idx, int alloc_flags);
  5. bool zone_watermark_ok_safe(struct zone *z, unsigned int order,
  6.         unsigned long mark, int classzone_idx, int alloc_flags);

Linux内存管理 (19)总结内存管理数据结构和API的更多相关文章

  1. Linux mem 2.4 Buddy 内存管理机制

    文章目录 1. Buddy 简介 2. Buddy 初始化 2.1 Struct Page 初始化 2.2 Buddy 初始化 3. 内存释放 4. 内存分配 4.1 gfp_mask 4.2 nod ...

  2. Linux内核学习笔记——内核内存管理方式

    一 页 内核把物理页作为内存管理的基本单位:内存管理单元(MMU)把虚拟地址转换为物理 地址,通常以页为单位进行处理.MMU以页大小为单位来管理系统中的也表. 32位系统:页大小4KB 64位系统:页 ...

  3. linux内存管理--伙伴系统和内存分配器

    3.1页框的管理 所有的页框描述符都存放在mem_map数组中. 3.1.1page数据结构 struct page { page_flags_t flags; //标志 atomic_t _coun ...

  4. Linux内核入门到放弃-内存管理-《深入Linux内核架构》笔记

    概述 内存管理的实现涵盖了许多领域: 内存中的物理内存页管理 分配大块内存的伙伴系统 分配较小内存块的slab.slub和slob分配器 分配非连续内存块的vmalloc机制 进程的地址空间 在IA- ...

  5. Linux中的Buffer Cache和Page Cache echo 3 > /proc/sys/vm/drop_caches Slab内存管理机制 SLUB内存管理机制

    Linux中的Buffer Cache和Page Cache echo 3 > /proc/sys/vm/drop_caches   Slab内存管理机制 SLUB内存管理机制 http://w ...

  6. Linux内核设计笔记12——内存管理

    内存管理学习笔记 页 页是内核管理内存的基本单位,内存管理单元(MMU,管理内存并把虚拟地址转化为物理地址的硬件)通常以页为单位进行处理,从虚拟内存的角度看,页就是最小单位. struct page{ ...

  7. linux kernel学习笔记-5内存管理_转

    void * kmalloc(size_t size, gfp_t gfp_mask); kmalloc()第一个参数是要分配的块的大小,第一个参数为分配标志,用于控制kmalloc()的行为. km ...

  8. Linux高级调试与优化——内存管理

    1.物理地址和虚拟地址 Linux采用页表机制管理内存,32位系统中页大小一般为4KB,物理内存被划分为连续的页,每一个页都有一个唯一的页号. 为了程序的的可移植性,进程往往需要运行在flat mem ...

  9. Linux内存管理 (3)内核内存的布局图

    专题:Linux内存管理专题 关键词:内核内存布局图.lowmem线性映射区.kernel image.ZONE_NORMAL.ZONE_HIGHMEM.swapper_pg_dir.fixmap.v ...

随机推荐

  1. [十六]基础类型BigInteger简介

        BigInteger和BigDecimal都是Java针对大数提供的类 超出了java的表示范围   属性简介 借助于signum和mag 来实现数据的符号位和实际数据的保存 final in ...

  2. MySQL 笔记整理（6） --全局锁和表锁：给表加个字段怎么有这么多阻碍

    笔记记录自林晓斌(丁奇)老师的<MySQL实战45讲> 6) --全局锁和表锁:给表加个字段怎么有这么多阻碍 数据库锁设计的初衷是处理并发问题.作为多用户共享的资源,当出现并发访问的时候, ...

  3. python之编码与解码

    编码 字符串被当作url提交时会被自动进行url编码处理,在python里也有个urllib.urlencode的方法,可以很方便的把字典形式的参数进行url编码.当url地址含有中文或者“/”的时候 ...

  4. java_List集合及其实现类

    第一章:List集合_List接口介绍 1).特点       1).有序的: 2).可以存储重复元素: 3).可以通过索引访问: List<String> list = new Arra ...

  5. 【开源】SpringBootNetty聊天室V1.2.0升级版本介绍

    前言 SpringBoot!微服务微架构的基础,Netty通信框架的元老级别框架,即之前的SpringBoot与Netty的实现聊天室的功能后已经过了不到一周的时间啦,今天我们更新了项目版本从V1.0 ...

  6. 有关mysql实现oracle分析函数功能的方法

    目前公司erp开发有一个脚本需求:对于收款合同审批单和收款合同(n:1),需要获取收款审批单中最新的一条审批记录来更新其对应的收款合同的相关信息. 难点主要在对相同类别的属性进行分组然后组内排序(分组 ...

  7. Python学习基础笔记（全）

    换博客了,还是csdn好一些. Python学习基础笔记 1.Python学习-linux下Python3的安装 2.Python学习-数据类型.运算符.条件语句 3.Python学习-循环语句 4. ...

  8. 从.Net到Java学习第一篇——开篇

    以前我常说,公司用什么技术我就学什么.可是对于java,我曾经一度以为“学java是不可能的,这辈子不可能学java的.”结果,一遇到公司转java,我就不得不跑路了,于是乎,回头一看N家公司交过社保 ...

  9. springboot 学习之路 8 (整合websocket(1))

    目录:[持续更新.....] spring 部分常用注解 spring boot 学习之路1(简单入门) spring boot 学习之路2(注解介绍) spring boot 学习之路3( 集成my ...

  10. log4j详细配置

    参考博客:https://blog.csdn.net/sinat_30185177/article/details/73550377 log4j..很简单好用的一个记录日志的东东,正因为好用,本人从来 ...