LInux中的物理内存管理

            struct
             zone{
...
         
            struct
             free_area free_area[MAX_ORDER]  
...
}
        

            struct
             free_area{
         
            struct
             list_head free_list[MIGRATE_TYPES];
          unsigned 
            long
             nr_free;           

} 
        

            enum
             {
    MIGRATE_UNMOVABLE,
    MIGRATE_RECLAIMABLE,
    MIGRATE_MOVABLE,
    MIGRATE_PCPTYPES,    
            /*
             the number of types on the pcp lists 
            */
            
    MIGRATE_RESERVE = MIGRATE_PCPTYPES,
#ifdef CONFIG_CMA
    /*
     * MIGRATE_CMA migration type is designed to mimic the way
     * ZONE_MOVABLE works.  Only movable pages can be allocated
     * from MIGRATE_CMA pageblocks and page allocator never
     * implicitly change migration type of MIGRATE_CMA pageblock.
     *
     * The way to use it is to change migratetype of a range of
     * pageblocks to MIGRATE_CMA which can be done by
     * __free_pageblock_cma() function.  What is important though
     * is that a range of pageblocks must be aligned to
     * MAX_ORDER_NR_PAGES should biggest page be bigger then
     * a single pageblock.
     */
    MIGRATE_CMA,
#endif
#ifdef CONFIG_MEMORY_ISOLATION
    MIGRATE_ISOLATE,    /* can‘t allocate from here */#endif
    MIGRATE_TYPES
};

            struct
             kmem_cache {

            /*
             1) Cache tunables. Protected by cache_chain_mutex 
            */
            
    unsigned 
            int
             batchcount;
    unsigned 
            int
             limit; 
    unsigned 
            int
             shared;

    unsigned 
            int
             size;
    u32 reciprocal_buffer_size;

            /*
             2) touched by every alloc & free from the backend 
            */
            

    unsigned 
            int flags;        /* constant flags */
    unsigned int num;        /* # of objs per slab *//* 3) cache_grow/shrink *//* order of pgs per slab (2^n) */
    unsigned int gfporder;

    /* force GFP flags, e.g. GFP_DMA */
    gfp_t allocflags;

    size_t colour;            /* cache colouring range */
    unsigned int colour_off;    /* colour offset */struct kmem_cache *slabp_cache;
    unsigned int slab_size;

    /* constructor func */void (*ctor)(void *obj);

/* 4) cache creation/removal */constchar *name;
    struct list_head list;
    int refcount;
    int object_size;
    int align;

/* 5) statistics */
#ifdef CONFIG_DEBUG_SLAB
    unsigned long num_active;
    unsigned long num_allocations;
    unsigned long high_mark;
    unsigned long grown;
    unsigned long reaped;
    unsigned long errors;
    unsigned long max_freeable;
    unsigned long node_allocs;
    unsigned long node_frees;
    unsigned long node_overflow;
    atomic_t allochit;
    atomic_t allocmiss;
    atomic_t freehit;
    atomic_t freemiss;

    /*
     * If debugging is enabled, then the allocator can add additional
     * fields and/or padding to every object. size contains the total
     * object size including these internal fields, the following two
     * variables contain the offset to the user object and its size.
     */int obj_offset;
#endif /* CONFIG_DEBUG_SLAB */
#ifdef CONFIG_MEMCG_KMEM
    struct memcg_cache_params *memcg_params;
#endif/* 6) per-cpu/per-node data, touched during every alloc/free *//*
     * We put array[] at the end of kmem_cache, because we want to size
     * this array to nr_cpu_ids slots instead of NR_CPUS
     * (see kmem_cache_init())
     * We still use [NR_CPUS] and not [1] or [0] because cache_cache
     * is statically defined, so we reserve the max number of cpus.
     *
     * We also need to guarantee that the list is able to accomodate a
     * pointer for each node since "nodelists" uses the remainder of
     * available pointers.
     */struct kmem_cache_node **node;
    struct array_cache *array[NR_CPUS + MAX_NUMNODES];
    /*
     * Do not add fields after array[]
     */
};

            struct
             array_cache {
    unsigned 
            int avail;//可用对象的数目
    unsigned int limit;//可拥有的最大对象的数目
    unsigned int batchcount;//
    unsigned int touched;
    spinlock_t lock;
    void *entry[];    /*主要是为了访问后面的对象
             * Must have this definition in here for the proper
             * alignment of array_cache. Also simplifies accessing
             * the entries.
             *
             * Entries should not be directly dereferenced as
             * entries belonging to slabs marked pfmemalloc will
             * have the lower bits set SLAB_OBJ_PFMEMALLOC
             */
};

            struct
             slab {
    union {
        
            struct
             {
            
            struct
             list_head list;
            unsigned 
            long colouroff; //slab第一个对象的偏移void *s_mem;        /* including colour offset 第一个对象的地址*/
            unsigned int inuse;    /* num of objs active in slab 被使用对象的数目*/
            kmem_bufctl_t free;//下一个空闲对象的下标
            unsigned short nodeid;///用于寻址具体CPU高速缓存        };
        struct slab_rcu __slab_cover_slab_rcu;
    };
};