程序博客网 > c语言标准库函数表格

Linux启动内存分配器

来源：互联网 发布：c语言标准库函数表格 编辑：程序博客网 时间：2024/05/29 14:06

Linux启动内存分配器是在伙伴系统、slab机制实现之前，为满足内核中内存的分配而建立的。本身的机制比较简单，使用位图来进行标志分配和释放。

一、数据结构介绍

1，保留区间

因为在建立启动内存分配器的时候，会涉及保留内存。也就是说，之前保留给页表、分配器本身（用于映射的位图）、io等得内存在分配器建立后，当用它来分配内存空间时，保留出来的那些部分就不能再分配了。linux中对保留内存空间的部分用下列数据结构表示

[cpp]
  1. /* 
  2.  * Early reserved memory areas. 
  3.  */  
  4. #define MAX_EARLY_RES 20/*保留空间最大块数*/   
  5.   
  6. struct early_res {/*保留空间结构*/  
  7.     u64 start, end;  
  8.     char name[16];  
  9.     char overlap_ok;  
  10. };  
  11. /*保留内存空间全局变量*/  
  12. static struct early_res early_res[MAX_EARLY_RES] __initdata = {  
  13.     { 0, PAGE_SIZE, "BIOS data page" }, /* BIOS data page */  
  14.     {}  
  15. };  
2，bootmem分配器

[cpp]
  1. /* 
  2.  * node_bootmem_map is a map pointer - the bits represent all physical  
  3.  * memory pages (including holes) on the node. 
  4.  */  
  5.  /*用于bootmem分配器的节点数据结构*/  
  6. typedef struct bootmem_data {  
  7.     unsigned long node_min_pfn;/*存放bootmem位图的第一个页面（即内核映象结束处的第一个页面）。*/  
  8.     unsigned long node_low_pfn;/*物理内存的顶点，最高不超过896MB。*/  
  9.     void *node_bootmem_map;  
  10.     unsigned long last_end_off;/*用来存放在前一次分配中所分配的最后一个字节相对于last_pos的位移量*/  
  11.     unsigned long hint_idx;/*存放前一次分配的最后一个页面号*/  
  12.     struct list_head list;  
  13. } bootmem_data_t;  

全局链表

二、启动分配器的建立

启动分配器的建立主要的流程为初始化映射位图、活动内存区的映射位置0（表示可用）、保留内存区域处理，其中保留区存放在上面介绍的全局数组中，这里只是将分配器中对应映射位图值1，表示已经分配。

下面我们看内核中具体的初始化流程。

start_kernel()->setup_arch()->initmem_init()

[html]
  1. void __init setup_arch(char **cmdline_p)  
  2. {  
  3.           .......  
  4. /*此函数在开始对bootmem分配制度建立做些准备工作  
  5.     然后调用相关函数建立bootmem分配制度*/  
  6.     initmem_init(0, max_pfn);  
  7.           .......  
  8. }              
[html]
  1. void __init initmem_init(unsigned long start_pfn,  
  2.                   unsigned long end_pfn)  
  3. {  
  4. #ifdef CONFIG_HIGHMEM  
  5.     highstart_pfn = highend_pfn = max_pfn;  
  6.     if (max_pfn > max_low_pfn)  
  7.         highstart_pfn = max_low_pfn;  
  8.     /*将活动内存放到early_node_map中,前面已经分析过了*/  
  9.     e820_register_active_regions(0, 0, highend_pfn);  
  10.     /*设置上面变量中的内存为当前，在这里没有  
  11.     设置相关的宏*/  
  12.     sparse_memory_present_with_active_regions(0);  
  13.     printk(KERN_NOTICE "%ldMB HIGHMEM available.\n",  
  14.         pages_to_mb(highend_pfn - highstart_pfn));  
  15.     num_physpages = highend_pfn;  
  16.     /*高端内存开始地址物理*/  
  17.     high_memory = (void *) __va(highstart_pfn * PAGE_SIZE - 1) + 1;  
  18. #else  
  19.     e820_register_active_regions(0, 0, max_low_pfn);  
  20.     sparse_memory_present_with_active_regions(0);  
  21.     num_physpages = max_low_pfn;  
  22.     high_memory = (void *) __va(max_low_pfn * PAGE_SIZE - 1) + 1;  
  23. #endif  
  24. #ifdef CONFIG_FLATMEM  
  25.     max_mapnr = num_physpages;  
  26. #endif  
  27.     __vmalloc_start_set = true;  
  28.   
  29.     printk(KERN_NOTICE "%ldMB LOWMEM available.\n",  
  30.             pages_to_mb(max_low_pfn));  
  31.     /*安装bootmem分配器，此分配器在伙伴系统起来之前  
  32.     用来进行承担内存的分配等管理*/  
  33.     setup_bootmem_allocator();  
  34. }  
[cpp]
  1. void __init setup_bootmem_allocator(void)  
  2. {  
  3.     int nodeid;  
  4.     unsigned long bootmap_size, bootmap;  
  5.     /* 
  6.      * Initialize the boot-time allocator (with low memory only): 
  7.      */  
  8.      /*计算所需要的映射页面大小一个字节一位， 
  9.      所以需要对总的页面大小除以8*/  
  10.     bootmap_size = bootmem_bootmap_pages(max_low_pfn)<<PAGE_SHIFT;  
  11.     /*直接中e820中找到一个大小合适的内存块，返回基址*/  
  12.     bootmap = find_e820_area(0, max_pfn_mapped<<PAGE_SHIFT, bootmap_size,  
  13.                  PAGE_SIZE);  
  14.     if (bootmap == -1L)  
  15.         panic("Cannot find bootmem map of size %ld\n", bootmap_size);  
  16.     /*将用于位图映射的页面保留*/  
  17.     reserve_early(bootmap, bootmap + bootmap_size, "BOOTMAP");  
  18.   
  19.     printk(KERN_INFO "  mapped low ram: 0 - %08lx\n",  
  20.          max_pfn_mapped<<PAGE_SHIFT);  
  21.     printk(KERN_INFO "  low ram: 0 - %08lx\n", max_low_pfn<<PAGE_SHIFT);  
  22.     /*对每一个在线的node*/  
  23.     for_each_online_node(nodeid) {  
  24.          unsigned long start_pfn, end_pfn;  
  25.   
  26. #ifdef CONFIG_NEED_MULTIPLE_NODES/*not set*/   
  27.         start_pfn = node_start_pfn[nodeid];  
  28.         end_pfn = node_end_pfn[nodeid];  
  29.         if (start_pfn > max_low_pfn)  
  30.             continue;  
  31.         if (end_pfn > max_low_pfn)  
  32.             end_pfn = max_low_pfn;  
  33. #else   
  34.         start_pfn = 0;  
  35.         end_pfn = max_low_pfn;  
  36. #endif   
  37.         /*对指定节点安装启动分配器*/  
  38.         bootmap = setup_node_bootmem(nodeid, start_pfn, end_pfn,  
  39.                          bootmap);  
  40.     }  
  41.     /*bootmem的分配制度到这里就已经建立完成，把after_bootmem 
  42.     变量置成1，标识*/  
  43.     after_bootmem = 1;  
  44. }  
[cpp]
  1. static unsigned long __init setup_node_bootmem(int nodeid,  
  2.                  unsigned long start_pfn,  
  3.                  unsigned long end_pfn,  
  4.                  unsigned long bootmap)  
  5. {  
  6.     unsigned long bootmap_size;  
  7.   
  8.     /* don't touch min_low_pfn */  
  9.     /*初始化映射位图，将位图中的所有位置1*/  
  10.     bootmap_size = init_bootmem_node(NODE_DATA(nodeid),  
  11.                      bootmap >> PAGE_SHIFT,  
  12.                      start_pfn, end_pfn);  
  13.     printk(KERN_INFO "  node %d low ram: %08lx - %08lx\n",  
  14.         nodeid, start_pfn<<PAGE_SHIFT, end_pfn<<PAGE_SHIFT);  
  15.     printk(KERN_INFO "  node %d bootmap %08lx - %08lx\n",  
  16.          nodeid, bootmap, bootmap + bootmap_size);  
  17.     /*将活动内存区对应位图相关位置0，表示可被分配的*/  
  18.     free_bootmem_with_active_regions(nodeid, end_pfn);  
  19.     /*对置保留位的相关页面对应的位图设置为1，表示已经分配 
  20.     或者不可用(不能被分配)*/  
  21.     early_res_to_bootmem(start_pfn<<PAGE_SHIFT, end_pfn<<PAGE_SHIFT);  
  22.     /*返回映射页面的最后地址，下次映射即可以从这里开始*/  
  23.     return bootmap + bootmap_size;  
  24. }  
对于初始化映射位图，最终调用init_bootmem_core()
[cpp]
  1. /* 
  2.  * Called once to set up the allocator itself. 
  3.  */  
  4. static unsigned long __init init_bootmem_core(bootmem_data_t *bdata,  
  5.     unsigned long mapstart, unsigned long start, unsigned long end)  
  6. {  
  7.     unsigned long mapsize;  
  8.   
  9.     mminit_validate_memmodel_limits(&start, &end);  
  10.     bdata->node_bootmem_map = phys_to_virt(PFN_PHYS(mapstart));  
  11.     bdata->node_min_pfn = start;  
  12.     bdata->node_low_pfn = end;  
  13.     /*添加bdata变量到链表中*/  
  14.     link_bootmem(bdata);  
  15.   
  16.     /* 
  17.      * Initially all pages are reserved - setup_arch() has to 
  18.      * register free RAM areas explicitly. 
  19.      */  
  20.      /*计算本bdata的mapsize，也就是内存页面大小的1/8*/  
  21.     mapsize = bootmap_bytes(end - start);  
  22.     /*将所有map置1*/  
  23.     memset(bdata->node_bootmem_map, 0xff, mapsize);  
  24.   
  25.     bdebug("nid=%td start=%lx map=%lx end=%lx mapsize=%lx\n",  
  26.         bdata - bootmem_node_data, start, mapstart, end, mapsize);  
  27.   
  28.     return mapsize;  
  29. }  
[cpp]
  1. /* 
  2.  * link bdata in order 
  3.  */  
  4.  /*添加到链表，由添加的代码可知 
  5.  链表中的数据开始位置为递增的*/  
  6. static void __init link_bootmem(bootmem_data_t *bdata)  
  7. {  
  8.     struct list_head *iter;  
  9.     /*添加到全局链表bdata_list中*/  
  10.     list_for_each(iter, &bdata_list) {  
  11.         bootmem_data_t *ent;  
  12.   
  13.         ent = list_entry(iter, bootmem_data_t, list);  
  14.         if (bdata->node_min_pfn < ent->node_min_pfn)  
  15.             break;  
  16.     }  
  17.     list_add_tail(&bdata->list, iter);  
  18. }  
[cpp]
  1. /** 
  2.  * free_bootmem_with_active_regions - Call free_bootmem_node for each active range 
  3.  * @nid: The node to free memory on. If MAX_NUMNODES, all nodes are freed. 
  4.  * @max_low_pfn: The highest PFN that will be passed to free_bootmem_node 
  5.  * 
  6.  * If an architecture guarantees that all ranges registered with 
  7.  * add_active_ranges() contain no holes and may be freed, this 
  8.  * this function may be used instead of calling free_bootmem() manually. 
  9.  */  
  10.  /*用active_region来初始化bootmem分配器，基于低端内存区*/  
  11. void __init free_bootmem_with_active_regions(int nid,  
  12.                         unsigned long max_low_pfn)  
  13. {  
  14.     int i;  
  15.     /*对每个节点上得活动内存区*/  
  16.     for_each_active_range_index_in_nid(i, nid) {  
  17.         unsigned long size_pages = 0;  
  18.         unsigned long end_pfn = early_node_map[i].end_pfn;  
  19.   
  20.         if (early_node_map[i].start_pfn >= max_low_pfn)  
  21.             continue;  
  22.   
  23.         if (end_pfn > max_low_pfn)  
  24.             end_pfn = max_low_pfn;  
  25.         /*计算活动区的页面数*/  
  26.         size_pages = end_pfn - early_node_map[i].start_pfn;  
  27.         /*释放这部分内存，起始就是对应位图值0*/  
  28.         free_bootmem_node(NODE_DATA(early_node_map[i].nid),  
  29.                 PFN_PHYS(early_node_map[i].start_pfn),  
  30.                 size_pages << PAGE_SHIFT);  
  31.     }  
  32. }  
[cpp]
  1. /** 
  2.  * free_bootmem_node - mark a page range as usable 
  3.  * @pgdat: node the range resides on 
  4.  * @physaddr: starting address of the range 
  5.  * @size: size of the range in bytes 
  6.  * 
  7.  * Partial pages will be considered reserved and left as they are. 
  8.  * 
  9.  * The range must reside completely on the specified node. 
  10.  */  
  11. void __init free_bootmem_node(pg_data_t *pgdat, unsigned long physaddr,  
  12.                   unsigned long size)  
  13. {  
  14.     unsigned long start, end;  
  15.     /*相关宏进行控制,调试用*/  
  16.     kmemleak_free_part(__va(physaddr), size);  
  17.   
  18.     start = PFN_UP(physaddr);/*取上界*/  
  19.     end = PFN_DOWN(physaddr + size);/*取下界*/  
  20.   
  21.       
  22.     /*调用此函数对相关bit位清0，表示没有分配，这里保留位为0*/  
  23.     mark_bootmem_node(pgdat->bdata, start, end, 0, 0);  
  24. }  
[cpp]
  1. static int __init mark_bootmem_node(bootmem_data_t *bdata,  
  2.                 unsigned long start, unsigned long end,  
  3.                 int reserve, int flags)  
  4. {  
  5.     unsigned long sidx, eidx;  
  6.   
  7.     bdebug("nid=%td start=%lx end=%lx reserve=%d flags=%x\n",  
  8.         bdata - bootmem_node_data, start, end, reserve, flags);  
  9.   
  10.     BUG_ON(start < bdata->node_min_pfn);  
  11.     BUG_ON(end > bdata->node_low_pfn);  
  12.     /*此两个变量为到节点最小内存页面的偏移量*/  
  13.     sidx = start - bdata->node_min_pfn;  
  14.     eidx = end - bdata->node_min_pfn;  
  15.   
  16.     if (reserve)/*如果设置了保留位*/  
  17.         return __reserve(bdata, sidx, eidx, flags);  
  18.     else/*相关的map位清0*/  
  19.         __free(bdata, sidx, eidx);  
  20.     return 0;  
  21. }  
[cpp]
  1. /*bootmem分配器的保留操作*/  
  2. static int __init __reserve(bootmem_data_t *bdata, unsigned long sidx,  
  3.             unsigned long eidx, int flags)  
  4. {  
  5.     unsigned long idx;  
  6.     int exclusive = flags & BOOTMEM_EXCLUSIVE;  
  7.   
  8.     bdebug("nid=%td start=%lx end=%lx flags=%x\n",  
  9.         bdata - bootmem_node_data,  
  10.         sidx + bdata->node_min_pfn,  
  11.         eidx + bdata->node_min_pfn,  
  12.         flags);  
  13.     /*对连续的几个页面设置为保留*/  
  14.     for (idx = sidx; idx < eidx; idx++)  
  15.         if (test_and_set_bit(idx, bdata->node_bootmem_map)) {  
  16.             if (exclusive) {  
  17.                 __free(bdata, sidx, idx);  
  18.                 return -EBUSY;  
  19.             }  
  20.             bdebug("silent double reserve of PFN %lx\n",  
  21.                 idx + bdata->node_min_pfn);  
  22.         }  
  23.     return 0;  
  24. }  
[cpp]
  1. /*bootmem分配器中释放内存*/  
  2. static void __init __free(bootmem_data_t *bdata,  
  3.             unsigned long sidx, unsigned long eidx)  
  4. {  
  5.     unsigned long idx;  
  6.   
  7.     bdebug("nid=%td start=%lx end=%lx\n", bdata - bootmem_node_data,  
  8.         sidx + bdata->node_min_pfn,  
  9.         eidx + bdata->node_min_pfn);  
  10.   
  11.     if (bdata->hint_idx > sidx)  
  12.         bdata->hint_idx = sidx;/*更新变量hint_idx，用于分配*/  
  13.   
  14.     for (idx = sidx; idx < eidx; idx++)/*对应位清0*/  
  15.         if (!test_and_clear_bit(idx, bdata->node_bootmem_map))  
  16.             BUG();  
  17. }  
[cpp]
  1. void __init early_res_to_bootmem(u64 start, u64 end)  
  2. {  
  3.     int i, count;  
  4.     u64 final_start, final_end;  
  5.   
  6.     count  = 0;  
  7.     for (i = 0; i < MAX_EARLY_RES && early_res[i].end; i++)  
  8.         count++;/*计算保留块的个数*/  
  9.   
  10.     printk(KERN_INFO "(%d early reservations) ==> bootmem [%010llx - %010llx]\n",  
  11.              count, start, end);  
  12.     for (i = 0; i < count; i++) {  
  13.         struct early_res *r = &early_res[i];  
  14.         printk(KERN_INFO "  #%d [%010llx - %010llx] %16s", i,  
  15.             r->start, r->end, r->name);  
  16.         final_start = max(start, r->start);  
  17.         final_end = min(end, r->end);  
  18.         if (final_start >= final_end) {  
  19.             printk(KERN_CONT "\n");  
  20.             continue;  
  21.         }  
  22.         printk(KERN_CONT " ==> [%010llx - %010llx]\n",  
  23.             final_start, final_end);  
  24.         /*将指定区间置为保留*/  
  25.         reserve_bootmem_generic(final_start, final_end - final_start,  
  26.                 BOOTMEM_DEFAULT);  
  27.     }  
  28. }  
上面的保留指定区间reserve_bootmem_generic()函数最终调用如下函数
[cpp]
  1. /** 
  2.  * reserve_bootmem - mark a page range as usable 
  3.  * @addr: starting address of the range 
  4.  * @size: size of the range in bytes 
  5.  * @flags: reservation flags (see linux/bootmem.h) 
  6.  * 
  7.  * Partial pages will be reserved. 
  8.  * 
  9.  * The range must be contiguous but may span node boundaries. 
  10.  */  
  11. int __init reserve_bootmem(unsigned long addr, unsigned long size,  
  12.                 int flags)  
  13. {  
  14.     unsigned long start, end;  
  15.   
  16.     start = PFN_DOWN(addr);/*下界*/  
  17.     end = PFN_UP(addr + size);/*上界*/  
  18.   
  19.     return mark_bootmem(start, end, 1, flags);  
  20. }  
[cpp]
  1. /*保留指定内存区间*/  
  2. static int __init mark_bootmem(unsigned long start, unsigned long end,  
  3.                 int reserve, int flags)  
  4. {  
  5.     unsigned long pos;  
  6.     bootmem_data_t *bdata;  
  7.   
  8.     pos = start;  
  9.     /*通过bdata_list链表找到在指定区间的bdata*/  
  10.     list_for_each_entry(bdata, &bdata_list, list) {  
  11.         int err;  
  12.         unsigned long max;  
  13.   
  14.         if (pos < bdata->node_min_pfn ||  
  15.             pos >= bdata->node_low_pfn) {  
  16.             BUG_ON(pos != start);  
  17.             continue;  
  18.         }  
  19.   
  20.         max = min(bdata->node_low_pfn, end);  
  21.         /*设置为保留*/  
  22.         err = mark_bootmem_node(bdata, pos, max, reserve, flags);  
  23.         if (reserve && err) {/*如果出错，递归调用*/  
  24.             mark_bootmem(start, pos, 0, 0);  
  25.             return err;  
  26.         }  
  27.   
  28.         if (max == end)  
  29.             return 0;  
  30.         pos = bdata->node_low_pfn;  
  31.     }  
  32.     BUG();  
  33. }  
三、内存的分配和释放
介绍了上面的初始化流程，对于分配和释放就简单了，分配就是将分配器映射位图中对应的位置1，释放过程相反。
[cpp]
  1. /*分配size大小的空间*/  
  2. static void * __init alloc_bootmem_core(struct bootmem_data *bdata,  
  3.                     unsigned long size, unsigned long align,  
  4.                     unsigned long goal, unsigned long limit)  
  5. {  
  6.     unsigned long fallback = 0;  
  7.     unsigned long min, max, start, sidx, midx, step;  
  8.   
  9.     bdebug("nid=%td size=%lx [%lu pages] align=%lx goal=%lx limit=%lx\n",  
  10.         bdata - bootmem_node_data, size, PAGE_ALIGN(size) >> PAGE_SHIFT,  
  11.         align, goal, limit);  
  12.   
  13.     BUG_ON(!size);  
  14.     BUG_ON(align & (align - 1));  
  15.     BUG_ON(limit && goal + size > limit);  
  16.     /*如果没有映射位图返回空，分配失败*/  
  17.     if (!bdata->node_bootmem_map)  
  18.         return NULL;  
  19.   
  20.     min = bdata->node_min_pfn;  
  21.     max = bdata->node_low_pfn;  
  22.   
  23.     goal >>= PAGE_SHIFT;  
  24.     limit >>= PAGE_SHIFT;  
  25.   
  26.     if (limit && max > limit)  
  27.         max = limit;  
  28.     if (max <= min)  
  29.         return NULL;  
  30.     /*step为需要对齐于页面数*/  
  31.     step = max(align >> PAGE_SHIFT, 1UL);  
  32.     /*计算起始页面*/  
  33.     if (goal && min < goal && goal < max)  
  34.         start = ALIGN(goal, step);  
  35.     else  
  36.         start = ALIGN(min, step);  
  37.     /*计算分配页面区间*/  
  38.     sidx = start - bdata->node_min_pfn;  
  39.     midx = max - bdata->node_min_pfn;  
  40.     /*前一次分配的页号比这次开始分配的页面号大 
  41.     那么，如果第一次没有分配到，回退到这次的 
  42.     开始重新试，因为第一次分配是从上一次分配 
  43.     的位置开始的*/  
  44.     if (bdata->hint_idx > sidx) {       
  45.          * Handle the valid case of sidx being zero and still  
  46.          * catch the fallback below.  
  47.          */  
  48.         fallback = sidx + 1;  
  49.         /*从上一次分配的位置开始，对齐与页面*/  
  50.         sidx = align_idx(bdata, bdata->hint_idx, step);  
  51.     }  
  52.   
  53.     while (1) {  
  54.         int merge;  
  55.         void *region;  
  56.         unsigned long eidx, i, start_off, end_off;  
  57. find_block:  
  58.         /*查找第一个为0的位*/  
  59.         sidx = find_next_zero_bit(bdata->node_bootmem_map, midx, sidx);  
  60.         sidx = align_idx(bdata, sidx, step);  
  61.         eidx = sidx + PFN_UP(size);/*结束位置*/  
  62.   
  63.         if (sidx >= midx || eidx > midx)/*找到结束了*/  
  64.             break;  
  65.   
  66.         for (i = sidx; i < eidx; i++)/*检查这段区域是否空闲*/  
  67.             if (test_bit(i, bdata->node_bootmem_map)) {/*如果不是，将跳过这段继续查找*/  
  68.                 sidx = align_idx(bdata, i, step);  
  69.                 if (sidx == i)  
  70.                     sidx += step;  
  71.                 goto find_block;  
  72.             }  
  73.   
  74.         if (bdata->last_end_off & (PAGE_SIZE - 1) &&/*如果为相邻的页面，也就是说上次分配的页面和这次分配的开始页面为相邻的*/  
  75.                 PFN_DOWN(bdata->last_end_off) + 1 == sidx)  
  76.             start_off = align_off(bdata, bdata->last_end_off, align);  
  77.         else  
  78.             start_off = PFN_PHYS(sidx);  
  79.   
  80.         /*merge==1表示上次结束和这次开始不在同一个页面上*/  
  81.         merge = PFN_DOWN(start_off) < sidx;  
  82.         end_off = start_off + size;  
  83.         /*更新数据*/  
  84.         bdata->last_end_off = end_off;  
  85.         bdata->hint_idx = PFN_UP(end_off);  
  86.   
  87.         /* 
  88.          * Reserve the area now: 
  89.          */  
  90.          /*设定新加入的页面为保留,就是将对应的映射位置1*/  
  91.         if (__reserve(bdata, PFN_DOWN(start_off) + merge,  
  92.                 PFN_UP(end_off), BOOTMEM_EXCLUSIVE))  
  93.             BUG();  
  94.         /*对应开始地址的虚拟地址返回*/  
  95.         region = phys_to_virt(PFN_PHYS(bdata->node_min_pfn) +  
  96.                 start_off);  
  97.         memset(region, 0, size);/*分配的大小*/  
  98.         /* 
  99.          * The min_count is set to 0 so that bootmem allocated blocks 
  100.          * are never reported as leaks. 
  101.          */  
  102.          /*调试用*/  
  103.         kmemleak_alloc(region, size, 0, 0);  
  104.         return region;  
  105.     }  
  106.   
  107.     if (fallback) {/*回退，重新查看*/  
  108.         sidx = align_idx(bdata, fallback - 1, step);  
  109.         fallback = 0;  
  110.         goto find_block;  
  111.     }  
  112.   
  113.     return NULL;  
  114. }  

                                             
        0        0           
	
				
		









 c语言标准库函数表格
    		c语言标准库函数表格



原创粉丝点击



		

热门IT博客


卖家如何找淘宝客卖家如何找淘宝客




淘宝店铺怎么修改照片淘宝店铺怎么修改照片




qt5编程入门pdf




js获取页面所有元素




js new video




互联网数据开发是什么




天涯明月刀网络延迟




黑帽seo技术到哪里学




雅思大作文 知乎




上海开票软件 网络配置




吴敬中 知乎




java就业指导




淘宝被恶意投诉售假




c语言多文件编程 例子




linux pwd命令




vb中的len是什么意思




淘宝怎么分卖家买家




aris软件官方下载




flv转mp4 for mac




阿里云系统机顶盒root



		

热门问题
    老师的惩罚
    人脸识别
    我在镇武司摸鱼那些年
    重生之率土为王
    我在大康的咸鱼生活
    盘龙之生命进化
    天生仙种
    凡人之先天五行
    春回大明朝
    姑娘不必设防，我是瞎子
    斯巴鲁森林人性价比
    斯巴鲁森林人口碑
    超级维特拉 森林人
    斯巴鲁森林人2013
    斯巴鲁森林人生产厂家
    斯巴鲁森林人装饰件
    斯巴鲁森林人刹车片
    斯巴鲁森林人蓝色
    斯巴鲁森林人排量
    斯巴鲁森林人7座
    斯巴鲁森林人促销
    斯巴鲁森林人保养
    2015斯巴鲁森林人
    日产森林人
    斯巴鲁森林人颜色
    斯巴鲁森林人进口
    斯巴鲁森林人发动机
    斯巴鲁森林人的缺点
    斯巴鲁森林人国产
    斯巴鲁森林人评价
    suv斯巴鲁森林人
    黑色斯巴鲁森林人
    新森林人报价
    森林人越野
    斯巴鲁森林人评测
    森林人好不好
    斯巴鲁森林人运动版
    斯巴鲁森林人专修
    斯巴鲁森林人安全性
    斯巴鲁森林人改装
    斯巴鲁森林人养护
    斯巴鲁 森林人 价格
    森林人优惠
    斯巴鲁森林人销量
    斯巴鲁森林人2.0价格
    森林人机油
    斯巴鲁森林人变速箱
    斯巴鲁森林人银色
    15款斯巴鲁森林人
    斯巴鲁森林人机油
    斯巴鲁森林人2014报价


	










程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里