linux内存管理之kmalloc

最新推荐文章于 2024-04-26 16:31:32 发布
最新推荐文章于 2024-04-26 16:31:32 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： Linux 文章标签： linux

http://blog.chinaunix.net/uid-20786208-id-4783115.html

   这里只说物理内存管理 linux内核的，看了很多讲解的内存的东西，但是自己总结的时候总感觉无从下手，这里就从实际物理内存分配接口开始吧。

Kmalloc  它分配连续的物理内存空间 ，它不负责把分配的内存空间清零，它能分配多大的呢？并且它只能分配ZONE_NORMAL的不能分配dma和high里的，也就是只分配低端内存.一般情况下内存被分为三个zone：NORMAL、DMA、HIGH.

这个函数是建立在slab分配器的基础上的,通过cache 而cache有通过slab 分配obj 。
在开始分析kmalloc函数之前，我们需要说明一下linux内核物理内存的分配函数API：
__get_free_pages它会调用alloc_pages，它的特点是不能从HIGHMEM分配内存，分配2的幂个连续物理页面。它有简化模式（只分配一page）
__get_free_page,而get_zeroed_page接口分配的页面内容对应填充为0. 从dma分配可以调用__get_dma_pages(它本质也是调用__get_free_pages）
 那么终极接口alloc_pages它可以从任何zone里申请内存，当然前提设置对应的flags.
参考内核：linux3.18.13  
参考书籍:《linux内核设计与实现》《linux设备驱动程序》《深入理解linux设备驱动内核机制》
下面我们就说说kmalloc：（关于分配时候的flags这里不讨论，具体可以参考资料）
我们先看头文件

#include 

而关于它的具体实现我们看slab.h中


点击(此处)折叠或打开

  1. #ifdef CONFIG_SLUB
  2. #include <linux/slub_def.h>
  3. #elif defined(CONFIG_SLOB)
  4. #include <linux/slob_def.h>
  5. #else
  6. #include <linux/slab_def.h>
  7. #endif


一般系统默认#include 

点击(此处)折叠或打开

  1. static __always_inline void *kmalloc(size_t size, gfp_t flags)
  2. {
  3.     struct kmem_cache *cachep;
  4.     void *ret;

  6.     if (__builtin_constant_p(size)) {
  7.         int i = 0;

  9.         if (!size)
  10.             return ZERO_SIZE_PTR;

  12. #define CACHE(x) \
  13.         if (size <= x) \
  14.             goto found; \
  15.         else \
  16.             i++;
  17. #include <linux/kmalloc_sizes.h> //这里查询申请的size在哪个范围 从32乘2递增。I每次加1.
  18. #undef CACHE
  19.         return NULL;
  20. found:
  21. #ifdef CONFIG_ZONE_DMA
  22.         if (flags & GFP_DMA)
  23.             cachep = malloc_sizes[i].cs_dmacachep; //很明显如果定义了dma，并且设置了dma标志则优先从dma cache里申请。malloc_sizes的初始化在slab.c里。可以具体分析一下。
  24.         else
  25. #endif
  26.             cachep = malloc_sizes[i].cs_cachep; //从指定的cache链表分配内存，不浪费空间。

  28.         ret = kmem_cache_alloc_trace(cachep, flags, size);

  30.         return ret;
  31.     }
  32.     return __kmalloc(size, flags);
  33. }
这里可以补充下代码关于 kmalloc_sizes . h

点击(此处)折叠或打开

  1. #if (PAGE_SIZE == 4096)
  2.     CACHE(32)
  3. #endif
  4.     CACHE(64)
  5. #if L1_CACHE_BYTES < 64
  6.     CACHE(96)
  7. #endif
  8.     CACHE(128)
  9. #if L1_CACHE_BYTES < 128
  10.     CACHE(192)
  11. #endif
  12.     CACHE(256)
  13.     CACHE(512)
  14.     CACHE(1024)
  15.     CACHE(2048)
  16.     CACHE(4096)
  17.     CACHE(8192)
  18.     CACHE(16384)
  19.     CACHE(32768)
  20.     CACHE(65536)
  21.     CACHE(131072)
  22. #if KMALLOC_MAX_SIZE >= 262144
  23.     CACHE(262144)
  24. #endif
  25. #if KMALLOC_MAX_SIZE >= 524288
  26.     CACHE(524288)
  27. #endif
  28. #if KMALLOC_MAX_SIZE >= 1048576
  29.     CACHE(1048576)
  30. #endif
  31. #if KMALLOC_MAX_SIZE >= 2097152
  32.     CACHE(2097152)
  33. #endif
  34. #if KMALLOC_MAX_SIZE >= 4194304
  35.     CACHE(4194304)
  36. #endif
  37. #if KMALLOC_MAX_SIZE >= 8388608
  38.     CACHE(8388608)
  39. #endif
  40. #if KMALLOC_MAX_SIZE >= 16777216
  41.     CACHE(16777216)
  42. #endif
  43. #if KMALLOC_MAX_SIZE >= 33554432
  44.     CACHE(33554432)
  45. #endif
我们看到函数开头需要说明一下：
__builtin_constant_p 是编译器gcc内置函数，用于判断一个值是否为编译时常量，如果是常数，函数返回1 ，否则返回0。此内置函数的典型用法是在宏中用于手动编译时优化显然如果size为常数 则用__kmalloc(size, flags);申请内存.
它查询需要分配的内存在哪个系统cache然后调用

点击(此处)折叠或打开

  1. #ifdef CONFIG_TRACING
  2. extern void *kmem_cache_alloc_trace(struct kmem_cache *, gfp_t, size_t);
  3. #else
  4. static __always_inline void *
  5. kmem_cache_alloc_trace(struct kmem_cache *cachep, gfp_t flags, size_t size)
  6. {
  7.     return kmem_cache_alloc(cachep, flags);
  8. }
  9. #endif
我们看具体代码：

点击(此处)折叠或打开

  1. /**
  2.  * kmem_cache_alloc - Allocate an object
  3.  * @cachep: The cache to allocate from.
  4.  * @flags: See kmalloc().
  5.  *
  6.  * Allocate an object from this cache. The flags are only relevant
  7.  * if the cache has no available objects.
  8.  */
  9. void *kmem_cache_alloc(struct kmem_cache *cachep, gfp_t flags)
  10. {
  11.     void *ret = slab_alloc(cachep, flags, _RET_IP_);

  13.     trace_kmem_cache_alloc(_RET_IP_, ret,                    // 跟踪调试会用到
  14.              cachep->object_size, cachep->size, flags);

  16.     return ret;
  17. }
它实际的分配是slab_alloc：

点击(此处)折叠或打开

  1. static __always_inline void *
  2. slab_alloc(struct kmem_cache *cachep, gfp_t flags, unsigned long caller)
  3. {
  4.     unsigned long save_flags;
  5.     void *objp;

  7.     flags &= gfp_allowed_mask;   //  说明在gfp.h中 ，如下

    点击(此处)折叠或打开

    1. /*
    2.  * gfp_allowed_mask is set to GFP_BOOT_MASK during early boot to restrict what
    3.  * GFP flags are used before interrupts are enabled. Once interrupts are
    4.  * enabled, it is set to __GFP_BITS_MASK while the system is running. During
    5.  * hibernation, it is used by PM to avoid I/O during memory allocation while
    6.  * devices are suspended.
    7.  */
    8. extern gfp_t gfp_allowed_mask;



  9.     lockdep_trace_alloc(flags);  // 调试用

  11.     if (slab_should_failslab(cachep, flags))
  12.         return NULL;

  14.     cachep = memcg_kmem_get_cache(cachep, flags);

  16.     cache_alloc_debugcheck_before(cachep, flags);
  17.     local_irq_save(save_flags);
  18.     objp = __do_cache_alloc(cachep, flags);
  19.     local_irq_restore(save_flags);
  20.     objp = cache_alloc_debugcheck_after(cachep, flags, objp, caller);
  21.     kmemleak_alloc_recursive(objp, cachep->object_size, 1, cachep->flags,
  22.                  flags);
  23.     prefetchw(objp);

  25.     if (likely(objp))
  26.         kmemcheck_slab_alloc(cachep, flags, objp, cachep->object_size);

  28.     if (unlikely((flags & __GFP_ZERO) && objp))
  29.         memset(objp, 0, cachep->object_size);

  31.     return objp;
  32. }

它调用objp = __do_cache_alloc(cachep, flags); 除了检查一些标志等继续调用

____cache_alloc(cachep, flags);

它是一个统一的接口 （有检测numa和uma ，linux默认是uma 除非指定了numa）

点击(此处)折叠或打开

  1. static inline void *____cache_alloc(struct kmem_cache *cachep, gfp_t flags)
  2. {
  3.     void *objp;
  4.     struct array_cache *ac;
  5.     bool force_refill = false;

  7.     check_irq_off();

  9.     ac = cpu_cache_get(cachep);
  10.     if (likely(ac->avail)) {
  11.         ac->touched = 1;
  12.         objp = ac_get_obj(cachep, ac, flags, false);

  14.         /*
  15.          * Allow for the possibility all avail objects are not allowed
  16.          * by the current flags
  17.          */
  18.         if (objp) {
  19.             STATS_INC_ALLOCHIT(cachep);
  20.             goto out;
  21.         }
  22.         force_refill = true;
  23.     }

  25.     STATS_INC_ALLOCMISS(cachep);
  26.     objp = cache_alloc_refill(cachep, flags, force_refill);
  27.     /*
  28.      * the 'ac' may be updated by cache_alloc_refill(),
  29.      * and kmemleak_erase() requires its correct value.
  30.      */
  31.     ac = cpu_cache_get(cachep);

  33. out:
  34.     /*
  35.      * To avoid a false negative, if an object that is in one of the
  36.      * per-CPU caches is leaked, we need to make sure kmemleak doesn't
  37.      * treat the array pointers as a reference to the object.
  38.      */
  39.     if (objp)
  40.         kmemleak_erase(&ac->entry[ac->avail]);
  41.     return objp;
  42. }
这里我们假定是第一次使用分配内存，那么根据在kmem_cache_init中的malloc_sizes[]的初始化，在kmalloc的时候返回的kmalloc_cache指针指向的cache中用到这样个函数：

点击(此处)折叠或打开

  1. static int __init_refok setup_cpu_cache(struct kmem_cache *cachep, gfp_t gfp)
  2. {
  3.     if (slab_state >= FULL)
  4.         return enable_cpucache(cachep, gfp);

  6.     if (slab_state == DOWN) {
  7.         /*
  8.          * Note: Creation of first cache (kmem_cache).
  9.          * The setup_list3s is taken care
  10.          * of by the caller of __kmem_cache_create
  11.          */
  12.         cachep->array[smp_processor_id()] = &initarray_generic.cache;
  13.         slab_state = PARTIAL;
  14.     } else if (slab_state == PARTIAL) {
  15.         /*
  16.          * Note: the second kmem_cache_create must create the cache
  17.          * that's used by kmalloc(24), otherwise the creation of
  18.          * further caches will BUG().
  19.          */
  20.         cachep->array[smp_processor_id()] = &initarray_generic.cache;

  22.         /*
  23.          * If the cache that's used by kmalloc(sizeof(kmem_list3)) is
  24.          * the second cache, then we need to set up all its list3s,
  25.          * otherwise the creation of further caches will BUG().
  26.          */
  27.         set_up_list3s(cachep, SIZE_AC);
  28.         if (INDEX_AC == INDEX_L3)
  29.             slab_state = PARTIAL_L3;
  30.         else
  31.             slab_state = PARTIAL_ARRAYCACHE;
  32.     } else {
  33.         /* Remaining boot caches */
  34.         cachep->array[smp_processor_id()] =
  35.             kmalloc(sizeof(struct arraycache_init), gfp);

  37.         if (slab_state == PARTIAL_ARRAYCACHE) {
  38.             set_up_list3s(cachep, SIZE_L3);
  39.             slab_state = PARTIAL_L3;
  40.         } else {
  41.             int node;
  42.             for_each_online_node(node) {
  43.                 cachep->nodelists[node] =
  44.                  kmalloc_node(sizeof(struct kmem_list3),
  45.                         gfp, node);
  46.                 BUG_ON(!cachep->nodelists[node]);
  47.                 kmem_list3_init(cachep->nodelists[node]);
  48.             }
  49.         }
  50.     }
  51.     cachep->nodelists[numa_mem_id()]->next_reap =
  52.             jiffies + REAPTIMEOUT_LIST3 +
  53.             ((unsigned long)cachep) % REAPTIMEOUT_LIST3;

  55.     cpu_cache_get(cachep)->avail = 0;
  56.     cpu_cache_get(cachep)->limit = BOOT_CPUCACHE_ENTRIES;   // 1
  57.     cpu_cache_get(cachep)->batchcount = 1;
  58.     cpu_cache_get(cachep)->touched = 0;
  59.     cachep->batchcount = 1;
  60.     cachep->limit = BOOT_CPUCACHE_ENTRIES;
  61.     return 0;
  62. }
我们知道不论array被赋了什么值，最后都要初始化avail等值.
所以如果array不可用，那么就会调用；当然如果array可用那么直接返回申请的obj的内存指针.

点击(此处)折叠或打开

  1. static void *cache_alloc_refill(struct kmem_cache *cachep, gfp_t flags,
  2.                             bool force_refill)
  3. {
  4.     int batchcount;
  5.     struct kmem_list3 *l3;
  6.     struct array_cache *ac;
  7.     int node;

  9.     check_irq_off();
  10.     node = numa_mem_id();
  11.     if (unlikely(force_refill))
  12.         goto force_grow;
  13. retry:
  14.     ac = cpu_cache_get(cachep);
  15.     batchcount = ac->batchcount;
  16.     if (!ac->touched && batchcount > BATCHREFILL_LIMIT) {
  17.         /*
  18.          * If there was little recent activity on this cache, then
  19.          * perform only a partial refill. Otherwise we could generate
  20.          * refill bouncing.
  21.          */
  22.         batchcount = BATCHREFILL_LIMIT;
  23.     }
  24.     l3 = cachep->nodelists[node];

  26.     BUG_ON(ac->avail > 0 || !l3);
  27.     spin_lock(&l3->list_lock);

  29.     /* See if we can refill from the shared array */
  30.     if (l3->shared && transfer_objects(ac, l3->shared, batchcount)) {
  31.         l3->shared->touched = 1;
  32.         goto alloc_done;
  33.     }

  35.     while (batchcount > 0) {
  36.         struct list_head *entry;
  37.         struct slab *slabp;
  38.         /* Get slab alloc is to come from. */
  39.         entry = l3->slabs_partial.next;
  40.         if (entry == &l3->slabs_partial) {
  41.             l3->free_touched = 1;
  42.             entry = l3->slabs_free.next;
  43.             if (entry == &l3->slabs_free)
  44.                 goto must_grow;
  45.         }

  47.         slabp = list_entry(entry, struct slab, list);
  48.         check_slabp(cachep, slabp);
  49.         check_spinlock_acquired(cachep);

  51.         /*
  52.          * The slab was either on partial or free list so
  53.          * there must be at least one object available for
  54.          * allocation.
  55.          */
  56.         BUG_ON(slabp->inuse >= cachep->num);

  58.         while (slabp->inuse < cachep->num && batchcount--) {
  59.             STATS_INC_ALLOCED(cachep);
  60.             STATS_INC_ACTIVE(cachep);
  61.             STATS_SET_HIGH(cachep);

  63.             ac_put_obj(cachep, ac, slab_get_obj(cachep, slabp,
  64.                                     node));
  65.         }
  66.         check_slabp(cachep, slabp);

  68.         /* move slabp to correct slabp list: */
  69.         list_del(&slabp->list);
  70.         if (slabp->free == BUFCTL_END)
  71.             list_add(&slabp->list, &l3->slabs_full);
  72.         else
  73.             list_add(&slabp->list, &l3->slabs_partial);
  74.     }

  76. must_grow:
  77.     l3->free_objects -= ac->avail;
  78. alloc_done:
  79.     spin_unlock(&l3->list_lock);

  81.     if (unlikely(!ac->avail)) {
  82.         int x;
  83. force_grow:
  84.         x = cache_grow(cachep, flags | GFP_THISNODE, node, NULL);   //  grow成功返回 1 

  86.         /* cache_grow can reenable interrupts, then ac could change. */
  87.         ac = cpu_cache_get(cachep);
  88.         node = numa_mem_id();

  90.         /* no objects in sight? abort */
  91.         if (!x && (ac->avail == 0 || force_refill))
  92.             return NULL;

  94.         if (!ac->avail)        /* objects refilled by interrupt? */
  95.             goto retry;
  96.     }
  97.     ac->touched = 1;

  99.     return ac_get_obj(cachep, ac, flags, force_refill);
  100. }
由于第一次使用nodelist上slab链表都为空，所以must_grow
它调用cache_grow，这个函数首先计算了slab着色处理。然后调用kmem_getpages申请page，大小根据cache->gfporder，它返回申请pages的虚拟地址.

点击(此处)折叠或打开

  1. /*
  2.  * Grow (by 1) the number of slabs within a cache. This is called by
  3.  * kmem_cache_alloc() when there are no active objs left in a cache.
  4.  */
  5. static int cache_grow(struct kmem_cache *cachep,
  6.         gfp_t flags, int nodeid, void *objp)
  7. {
  8.     struct slab *slabp;
  9.     size_t offset;
  10.     gfp_t local_flags;
  11.     struct kmem_list3 *l3;

  13.     /*
  14.      * Be lazy and only check for valid flags here, keeping it out of the
  15.      * critical path in kmem_cache_alloc().
  16.      */
  17.     BUG_ON(flags & GFP_SLAB_BUG_MASK);
  18.     local_flags = flags & (GFP_CONSTRAINT_MASK|GFP_RECLAIM_MASK);

  20.     /* Take the l3 list lock to change the colour_next on this node */
  21.     check_irq_off();
  22.     l3 = cachep->nodelists[nodeid];
  23.     spin_lock(&l3->list_lock);

  25.     /* Get colour for the slab, and cal the next value. */
  26.     offset = l3->colour_next; // default 0 
  27.     l3->colour_next++;
  28.     if (l3->colour_next >= cachep->colour)
  29.         l3->colour_next = 0;
  30.     spin_unlock(&l3->list_lock);

  32.     offset *= cachep->colour_off; // first time ,offset is 0 ; 

  34.     if (local_flags & __GFP_WAIT)
  35.         local_irq_enable();

  37.     /*
  38.      * The test for missing atomic flag is performed here, rather than
  39.      * the more obvious place, simply to reduce the critical path length
  40.      * in kmem_cache_alloc(). If a caller is seriously mis-behaving they
  41.      * will eventually be caught here (where it matters).
  42.      */
  43.     kmem_flagcheck(cachep, flags);

  45.     /*
  46.      * Get mem for the objs. Attempt to allocate a physical page from
  47.      * 'nodeid'.
  48.      */
  49.     if (!objp)
  50.         objp = kmem_getpages(cachep, local_flags, nodeid);
  51.     if (!objp)
  52.         goto failed;

  54.     /* Get slab management. */
  55.     slabp = alloc_slabmgmt(cachep, objp, offset,
  56.             local_flags & ~GFP_CONSTRAINT_MASK, nodeid);
  57.     if (!slabp)
  58.         goto opps1;

  60.     slab_map_pages(cachep, slabp, objp);

  62.     cache_init_objs(cachep, slabp);

  64.     if (local_flags & __GFP_WAIT)
  65.         local_irq_disable();
  66.     check_irq_off();
  67.     spin_lock(&l3->list_lock);

  69.     /* Make slab active. */
  70.     list_add_tail(&slabp->list, &(l3->slabs_free));  //  把新申请的slab添加到nodelist的slabs_free链表。
  71.     STATS_INC_GROWN(cachep);
  72.     l3->free_objects += cachep->num;                    //初始化可用的对象即每个slab可以包含的obj数目
  73.     spin_unlock(&l3->list_lock);
  74.     return 1;
  75. opps1:
  76.     kmem_freepages(cachep, objp);
  77. failed:
  78.     if (local_flags & __GFP_WAIT)
  79.         local_irq_disable();
  80.     return 0;
  81. }
而关于slab着色跟硬件缓冲有关，为了尽量避免缓存冲突不命中问题，提高效率（cache_line问题）。可以参考《深入理解计算机系统》。

具体操作见：

点击(此处)折叠或打开

  1. /*
  2.  * Get the memory for a slab management obj.
  3.  * For a slab cache when the slab descriptor is off-slab, slab descriptors
  4.  * always come from malloc_sizes caches. The slab descriptor cannot
  5.  * come from the same cache which is getting created because,
  6.  * when we are searching for an appropriate cache for these
  7.  * descriptors in kmem_cache_create, we search through the malloc_sizes array.
  8.  * If we are creating a malloc_sizes cache here it would not be visible to
  9.  * kmem_find_general_cachep till the initialization is complete.
  10.  * Hence we cannot have slabp_cache same as the original cache.
  11.  */
  12. static struct slab *alloc_slabmgmt(struct kmem_cache *cachep, void *objp,
  13.                  int colour_off, gfp_t local_flags,
  14.                  int nodeid)
  15. {
  16.     struct slab *slabp;

  18.     if (OFF_SLAB(cachep)) {     
  19.    //  关于OFF_SLAB问题 可以看代码：
  20.         

    点击(此处)折叠或打开

    1. CFLGS_OFF_SLAB 在__kmem_cache_create
    2.     /*
    3.      * Determine if the slab management is 'on' or 'off' slab.
    4.      * (bootstrapping cannot cope with offslab caches so don't do
    5.      * it too early on. Always use on-slab management when
    6.      * SLAB_NOLEAKTRACE to avoid recursive calls into kmemleak)
    7.      */
    8.     if ((size >= (PAGE_SIZE >> 3)) && !slab_early_init &&
    9.      !(flags & SLAB_NOLEAKTRACE))
    10.         /*
    11.          * Size is large, assume best to place the slab management obj
    12.          * off-slab (should allow better packing of objs).
    13.          */
    14.         flags |= CFLGS_OFF_SLAB;


  21.             
  22.         /* Slab management obj is off-slab. */
  23.         slabp = kmem_cache_alloc_node(cachep->slabp_cache,
  24.                      local_flags, nodeid);
  25.         /*
  26.          * If the first object in the slab is leaked (it's allocated
  27.          * but no one has a reference to it), we want to make sure
  28.          * kmemleak does not treat the ->s_mem pointer as a reference
  29.          * to the object. Otherwise we will not report the leak.
  30.          */
  31.         kmemleak_scan_area(&slabp->list, sizeof(struct list_head),
  32.                  local_flags);
  33.         if (!slabp)
  34.             return NULL;
  35.     } else {
  36.         slabp = objp + colour_off;    //   在__kmem_cache_create中cachep->colour_off = cache_line_size();
  37.                                        // 在cache.h中#define cache_line_size() L1_CACHE_BYTES；  一般为32B 大小.
  38.                                         // cachep->colour = left_over / cachep->colour_off;
  39.         colour_off += cachep->slab_size;
  40.     }
  41.     slabp->inuse = 0;                    // num of objs active in slab
  42.     slabp->colouroff = colour_off;   //第一个obj相对page地址的偏移
  43.     slabp->s_mem = objp + colour_off;  //第一个obj的地址
  44.     slabp->nodeid = nodeid;
  45.     slabp->free = 0;                    
  46.     return slabp;
  47. }
我们看看另外一个很重要的操作：

点击(此处)折叠或打开

  1. static void cache_init_objs(struct kmem_cache *cachep,
  2.              struct slab *slabp)
  3. {
  4.     int i;

  6.     for (i = 0; i < cachep->num; i++) {
  7.         void *objp = index_to_obj(cachep, slabp, i);
  8. #if DEBUG
  9.         /* need to poison the objs? */
  10.         if (cachep->flags & SLAB_POISON)
  11.             poison_obj(cachep, objp, POISON_FREE);
  12.         if (cachep->flags & SLAB_STORE_USER)
  13.             *dbg_userword(cachep, objp) = NULL;

  15.         if (cachep->flags & SLAB_RED_ZONE) {
  16.             *dbg_redzone1(cachep, objp) = RED_INACTIVE;
  17.             *dbg_redzone2(cachep, objp) = RED_INACTIVE;
  18.         }
  19.         /*
  20.          * Constructors are not allowed to allocate memory from the same
  21.          * cache which they are a constructor for. Otherwise, deadlock.
  22.          * They must also be threaded.
  23.          */
  24.         if (cachep->ctor && !(cachep->flags & SLAB_POISON))
  25.             cachep->ctor(objp + obj_offset(cachep));

  27.         if (cachep->flags & SLAB_RED_ZONE) {
  28.             if (*dbg_redzone2(cachep, objp) != RED_INACTIVE)
  29.                 slab_error(cachep, "constructor overwrote the"
  30.                      " end of an object");
  31.             if (*dbg_redzone1(cachep, objp) != RED_INACTIVE)
  32.                 slab_error(cachep, "constructor overwrote the"
  33.                      " start of an object");
  34.         }
  35.         if ((cachep->size % PAGE_SIZE) == 0 &&
  36.              OFF_SLAB(cachep) && cachep->flags & SLAB_POISON)
  37.             kernel_map_pages(virt_to_page(objp),
  38.                      cachep->size / PAGE_SIZE, 0);
  39. #else
  40.         if (cachep->ctor)
  41.             cachep->ctor(objp); //  根据构造函数初始化对象
  42. #endif
  43.         slab_bufctl(slabp)[i] = i + 1;  //  init  bufctl数组 1、2、3、4 .....  最后一个设置成为BUFCTL_END
  44.     }
  45.     slab_bufctl(slabp)[i - 1] = BUFCTL_END;
  46. }
zdy0_2004
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[内存管理] linux kernel内存映射实例分析
crazyjiang的专栏
08-24 1万+
作者：JHJ([email protected]) 日期：2012/08/24 欢迎转载，请注明出处   引子 现在android智能手机市场异常火热，硬件升级非常迅猛，arm cortex A9 + 1GB DDR似乎已经跟不上主流配置了。虽说硬件是王道，可我们还是不禁还怀疑这么强大的硬件配置得到充分利用了吗？因此以后我都会正对ARM平台分析kernel的内容。  正文
kmalloc fail导致系统异常
chrovery的专栏
03-29 2332
如果在中断ISR中间有作memory alloc的动作，有可能会遇到如下的BUG log信息，分析如下： 1  ISR中不能存在任何可调度的动作，如sleep等 2  在ISR中申请memory时，最好尽量使用 kmalloc(xxx, GFP_ATOMIC), 而不要使用kmalloc(xxx, GFP_KERNEL), 因为GFP_KERNEL是可以被打断的，如果因memory not e
Linux内存管理之malloc、vmalloc、kmalloc
10-31
Linux内存管理之malloc、vmalloc、kmalloc， 区别，相似之处
linux内存管理（八）-不连续页分配
jianjian的博客
06-17 1450
一、不连续页 1.不连续页的接口函数 a.用户台接口函数 //分配不连续的物理页并且把物理页映射到连续的虚拟地址空间； void *vmalloc(unsigned long size); //释放vma I loc分配的物理页和虚拟地址空间; void vfree (const void * addr); //把已经分配的不连续物理而映射到连续的虚拟地址空间； void *vmap(struct type **pages / unsigned int count,unsigned long flags
linux kmalloc fail info
shenhuxi_yu的专栏
11-22 692
Decoding the Linux kernel's page allocation failure messages June 16, 2012 One of our machines has recently started logging cryptic but verbose kernel messages about page allocation failures. Natura
kmalloc使用不当导致内存分配失败问题
lunhui2016的博客
05-15 2486
#1. 介绍 本文记录分析驱动模块kmalloc接口的flags参数使用不当，导致分配内存失败的问题，主要记录了分析过程和给出的解决方法。 #1.1 背景介绍 在对spi nand flash进行读写老化，因此在用户态通过rwcheck工具对flash进行读写老化，在读写老化过程中，高概率出现内核oom现象，具体板级信息说明如下： 内存大小：128M CPU：双核A7 #2. log分析 在读写测试时，oom log如下所示： remove : /mnt/UDISK/rwcheck.tmp.36 ...
linux kmalloc 函数
yongjong的专栏
07-15 2500
异同点kmalloc分配的物理内存是连续的，vmalloc分配的物理内存可以不连续，但是虚拟地址空间连续。kmalloc既支持大块内存分配也支持小块内存分配，大块内存使用页面分配器，小内存使用slab分配器，而vmalloc用于大块内存分配器，并且最好分配内存大小是整页级的，否则会导致内存空间浪费。测试结果如下图所示，插入内核模块分配一块4M（阶数为10）大小的物理内存块，对应的阶数为10，阶数为10的内存块从548减少为547，删除内核模块回收内存块，阶数为10的内存块数量增加一，变为548。...
kmalloc_array 和 kcalloc 申请数组
jason的笔记
04-13 5630
vma_filesz = kmalloc_array(segs - 1, sizeof(*vma_filesz), GFP_KERNEL); kmalloc_array 用来申请一个数组 static inline void *kmalloc_array(size_t n, size_t size, gfp_t flags) {     if (size != 0 && n > SIZ
【Linux内核】kmalloc分配内存大小(非常详细)
07-20 6567
基于linux-5.15分析。
Linux 内存管理内幕
09-21
Linux内存管理技术，详细讲解了kmalloc、page，以及buddy算法的相关知识，若是想了解Linux内核中的内存分配、释放，一致性细节，本文档将是不可多得的选择
linux内存分配实例
10-22
可见分配的内存的虚拟地址符合预期，__get_fre_page和kmalloc分配的内存在线性映射区，vmalloc分配的内存在非连续内存区
linux 内核 内存泄露检测
09-11
linux 内核 内存泄露检测 linux 内核 内存泄露检测 linux 内核 内存泄露检测 linux 内核 内存泄露检测 linux 内核 内存泄露检测 linux 内核 内存泄露检测 linux 内核 内存泄露检测
memory_map_kmalloc.c
10-22
vmalloc分配的内存虚拟地址连续但物理地址不连续，所以只能在缺页异常中逐页建立映射 下面给出使用kmalloc分配内存，并在mmap函数中一次性建立映射的示例
Linux多进程(五) 进程池 C++实现
最新发布
Lyajpunov的博客
04-26 489
进程池是一种并发编程模式，用于管理和重用多个处理任务的进程。它通常用于需要频繁创建和销毁进程的情况，以避免因此产生的开销。减少进程创建销毁的开销：避免频繁创建和销毁进程所带来的系统资源开销。提高系统响应速度：由于进程已经初始化并且一直保持在内存中，可以立即分配执行任务，减少了任务等待时间。控制资源使用：通过限制进程池中的进程数量，可以控制系统资源的使用情况，避免资源过度消耗。
Linux报错处理：‘abrt-cli status’ timed out
Rita_rr的博客
04-23 461
abrt-cli是ABRT(Automated Bug Reporting Tool)的命令行接口，用于在Linux系统中处理和报告程序崩溃。 如果abrt-cli status命令超时，这可能是由于多种原因，包括但不限于系统资源不足、ABRT服务未正常运行、网络问题或配置错误。
linux18：进程等待
m0_73919066的博客
04-20 1080
1：子进程创建的目的是要完成父进程指派的某个任务，当子进程运行完毕退出时，父进程需要通过进程等待的方式，回收子进程资源，获取子进程退出信息（子进程有无异常？没有异常结果是否正确？检查退出码查看错误原因）2：父进程如果一直不回收，就可能造成子进程‘僵尸进程’的问题，子进程一直得不到父进程的回收，进而造成内存泄漏。3：子进程一旦变成僵尸状态，那就刀枪不入，“杀人不眨眼”的kill -9 也无能为力杀死一个已经死去的进程。只能通过进程等待将他进行回收。
arm架构Linux5.0内核连接脚本文件vmlinux.lds.S分析
jianjian的博客
04-23 916
vmlinux.lds.S 是 Linux 内核中用于链接的脚本文件，用于定义内核对象文件的内存布局，即它告诉链接器如何将不同的内核代码段和数据段组合成一个最终的内核映像 vmlinux。编译内核源码生成内核文件的过程分两步，一个是“编译”，另一个是“链接”的过程，vmlinux.lds.S要做的就是告诉编译器如何链接编译好的各个内核.o文件，从而生成vmlinux文件。
Linux——权限
2303_79015671的博客
04-26 753
带你了解Linux的权限
Linux kmalloc/kfree 源码解读
05-31
kmalloc和kfree是Linux内核中用于动态内存分配和释放的函数。 kmalloc函数的定义如下...另外，kmalloc和kfree函数的实现是非常复杂的，涉及到很多底层内存管理的细节，建议有兴趣的读者可以详细阅读内核源码进行学习。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值