arm linux启动流程四

3180阅读　0评论2014-08-18　wangbaolin719
分类：LINUX


  1. 一、概述
  2. debug_objects_early_init()函数用于内核的对象调试。依赖配置CONFIG_DEBUG_OBJECTS。

  4. 二、相关结构体
  5. struct debug_bucket {
  6.     struct hlist_head    list;    //挂载的是当前debug_obj对象
  7.     raw_spinlock_t        lock;
  8. };

  10. struct debug_obj {
  11.     struct hlist_node node;    //链接跟踪器列表中的对象
  12.     enum debug_obj_state state;    //跟踪的对象状态
  13.     unsigned int astate;    //当前active状态
  14.     void *object;//对实际对象的指针
  15.     struct debug_obj_descr *descr;    //用于调试的描述符结构体指针
  16. };

  18. enum debug_obj_state {
  19.     ODEBUG_STATE_NONE,
  20.     ODEBUG_STATE_INIT,
  21.     ODEBUG_STATE_INACTIVE,
  22.     ODEBUG_STATE_ACTIVE,
  23.     ODEBUG_STATE_DESTROYED,
  24.     ODEBUG_STATE_NOTAVAILABLE,
  25.     ODEBUG_STATE_MAX,
  26. };

  28. struct debug_obj_descr {
  29.     const char *name;
  30.     void *(*debug_hint) (void *addr);
  31.     int (*fixup_init) (void *addr, enum debug_obj_state state);
  32.     int (*fixup_activate) (void *addr, enum debug_obj_state state);
  33.     int (*fixup_destroy) (void *addr, enum debug_obj_state state);
  34.     int (*fixup_free) (void *addr, enum debug_obj_state state);
  35.     int (*fixup_assert_init)(void *addr, enum debug_obj_state state);
  36. };

  38. 二、代码
  39. //../lib/debugobjects.c
  40. static struct debug_bucket    obj_hash[ODEBUG_HASH_SIZE];
  41. static HLIST_HEAD(obj_pool);
  42. static struct debug_obj        obj_static_pool[ODEBUG_POOL_SIZE] __initdata;
  43. void __init debug_objects_early_init(void)
  44. {
  45.     int i;
  46.     
  47.     //初始化spin lock
  48.     for (i = 0; i < ODEBUG_HASH_SIZE; i++)
  49.         raw_spin_lock_init(&obj_hash[i].lock);

  51.     //将obj_static_pool数组都挂入obj_pool链表头
  52.     for (i = 0; i < ODEBUG_POOL_SIZE; i++)
  53.         hlist_add_head(&obj_static_pool[i].node, &obj_pool);
  54. }

  56. start_kernel后面在slab机制创建后，还会有debug初始化操作:
  57. void __init debug_objects_mem_init(void)
  58. {
  59.     if (!debug_objects_enabled)
  60.         return;
  61.     
  62.     //创建debug_obj的slab高速缓存
  63.     obj_cache = kmem_cache_create("debug_objects_cache",sizeof (struct debug_obj), 0,SLAB_DEBUG_OBJECTS, NULL);

  65.     //obj_cache创建成功则调用debug_objects_replace_static_objects函数
  66.     if (!obj_cache || debug_objects_replace_static_objects()) {
  67.         debug_objects_enabled = 0;
  68.         if (obj_cache)
  69.             kmem_cache_destroy(obj_cache);
  70.         pr_warn("out of memory.\n");
  71.     } else
  72.     debug_objects_selftest();    //debug_obj对象自测
  73. }

  75. static int __init debug_objects_replace_static_objects(void)
  76. {
  77.     struct debug_bucket *db = obj_hash;
  78.     struct hlist_node *tmp;
  79.      struct debug_obj *obj, *new;
  80.     HLIST_HEAD(objects);
  81.     int i, cnt = 0;
  82.     
  83.     //从高速缓存中分配debug_obj对象挂载到全局链表objects
  84.     for (i = 0; i < ODEBUG_POOL_SIZE; i++) {
  85.         obj = kmem_cache_zalloc(obj_cache, GFP_KERNEL);
  86.         if (!obj)
  87.             goto free;
  88.         hlist_add_head(&obj->node, &objects);
  89.     }
  90.  
  91.     //此时只有一个cpu在运行，关中断即进入临界区。是为了防止lockdep hell of lock ordering
  92.     local_irq_disable();
  93.  
  94.     //从obj_pool中移除静态的debug_obj对象
  95.     hlist_for_each_entry_safe(obj, tmp, &obj_pool, node)
  96.         hlist_del(&obj->node);

  98.     //将刚分配的动态debug_obj对象链入obj_pool
  99.     hlist_move_list(&objects, &obj_pool);
  100.  
  101.     for (i = 0; i < ODEBUG_HASH_SIZE; i++, db++) {
  102.         //将obj_hash中的debug_bucket对象上的list节点挂载的debug_obj对象链入objects链表
  103.         hlist_move_list(&db->list, &objects);
  104.         
  105.         //然后遍历objects链表中的debug_obj对象
  106.         hlist_for_each_entry(obj, &objects, node) {
  107.             //从obj_pool取出一个debug_obj对象
  108.             new = hlist_entry(obj_pool.first, typeof(*obj), node);
  109.             //将该debug_obj对象从obj_pool链表删除
  110.             hlist_del(&new->node);    
  111.             //拷贝debug_obj对象
  112.             *new = *obj;
  113.             //将该新debug_obj对象链入到objects链表中的debug_bucket对象上的list节点
  114.             hlist_add_head(&new->node, &db->list);
  115.             cnt++;
  116.         }
  117.     }
  118.     local_irq_enable();
  119.         
  120.     pr_debug("%d of %d active objects replaced\n",cnt, obj_pool_used);
  121.     return 0;
  122. free:
  123.     hlist_for_each_entry_safe(obj, tmp, &objects, node) {
  124.         hlist_del(&obj->node);
  125.         kmem_cache_free(obj_cache, obj);
  126.     }
  127.     return -ENOMEM;
  128. }

  130. 三、debug使用
  131. 1. 定义自己用于调试的描述符结构体指针
  132. static __initdata struct debug_obj_descr descr_type_test = {
  133.     .name = "selftest",
  134.     .fixup_init = fixup_init,
  135.     .fixup_activate = fixup_activate,
  136.     .fixup_destroy = fixup_destroy,
  137.     .fixup_free = fixup_free,
  138. };

  140. 2. 初始化
  141. void debug_object_init(void *addr, struct debug_obj_descr *descr)
  142. {
  143.     if (!debug_objects_enabled)
  144.         return;
  145.         
  146.     __debug_object_init(addr, descr, 0);
  147. }

  149. static void __debug_object_init(void *addr, struct debug_obj_descr *descr, int onstack)
  150. {
  151.     enum debug_obj_state state;
  152.     struct debug_bucket *db;
  153.     struct debug_obj *obj;
  154.     unsigned long flags;
  155.     
  156.     //检测obj_pool是否需要添加新的debug_obj对象    
  157.     fill_pool();
  158.     
  159.     //根据要debug的地址通过hash算法得到debug_bucket对象
  160.     db = get_bucket((unsigned long) addr);
  161.         
  162.     raw_spin_lock_irqsave(&db->lock, flags);
  163.     
  164.     //根据debug地址到obj_pool查找一个debug_obj对象
  165.     obj = lookup_object(addr, db);
  166.     //没找到则通过obj_pool分配一个debug_obj对象
  167.     if (!obj) {
  168.         obj = alloc_object(addr, db, descr);
  169.         if (!obj) {
  170.             debug_objects_enabled = 0;
  171.             raw_spin_unlock_irqrestore(&db->lock, flags);
  172.             debug_objects_oom();
  173.             return;
  174.         }
  175.         //安全检查
  176.         debug_object_is_on_stack(addr, onstack);
  177.     }
  178.     
  179.     //设置debug_obj对象状态，如果是通过alloc_object分配的对象，则状态为ODEBUG_STATE_NONE，然后通过下边设置为ODEBUG_STATE_INIT
  180.     switch (obj->state) {
  181.         case ODEBUG_STATE_NONE:
  182.         case ODEBUG_STATE_INIT:
  183.         case ODEBUG_STATE_INACTIVE:
  184.             obj->state = ODEBUG_STATE_INIT;
  185.             break;
  186.         
  187.         case ODEBUG_STATE_ACTIVE:
  188.             debug_print_object(obj, "init");
  189.             state = obj->state;
  190.             raw_spin_unlock_irqrestore(&db->lock, flags);
  191.             debug_object_fixup(descr->fixup_init, addr, state);
  192.             return;
  193.         
  194.         case ODEBUG_STATE_DESTROYED:
  195.             debug_print_object(obj, "init");
  196.             break;
  197.         default:
  198.             break;
  199.     }
  200.     
  201.     raw_spin_unlock_irqrestore(&db->lock, flags);
  202. }

  204. static void fill_pool(void)
  205. {
  206.     gfp_t gfp = GFP_ATOMIC | __GFP_NORETRY | __GFP_NOWARN;
  207.     struct debug_obj *new;
  208.     unsigned long flags;
  209.     
  210.     //obj_pool中的空闲debug_obj对象足够则返回
  211.     if (likely(obj_pool_free >= ODEBUG_POOL_MIN_LEVEL))
  212.         return;
  213.     
  214.     //若没创建高速缓存则返回
  215.     if (unlikely(!obj_cache))
  216.         return;

  218.     //若空闲对象少于最低阀值，则创建新对象链入obj_pool链表中
  219.     while (obj_pool_free < ODEBUG_POOL_MIN_LEVEL) {    
  220.         new = kmem_cache_zalloc(obj_cache, gfp);
  221.         if (!new)
  222.             return;
  223.         
  224.         raw_spin_lock_irqsave(&pool_lock, flags);
  225.         hlist_add_head(&new->node, &obj_pool);
  226.         obj_pool_free++;
  227.         raw_spin_unlock_irqrestore(&pool_lock, flags);
  228.     }
  229. }

  231. static struct debug_bucket *get_bucket(unsigned long addr)
  232. {
  233.     unsigned long hash;
  234.         
  235.     hash = hash_long((addr >> ODEBUG_CHUNK_SHIFT), ODEBUG_HASH_BITS);
  236.     return &obj_hash[hash];
  237. }

  239. static struct debug_obj *lookup_object(void *addr, struct debug_bucket *b)
  240. {
  241.     struct debug_obj *obj;
  242.     int cnt = 0;
  243.     
  244.     //遍历该debug_bucket对象上挂载的debug_obj对象
  245.     hlist_for_each_entry(obj, &b->list, node) {
  246.         cnt++;
  247.         //地址相等即找到相应的debug_obj对象
  248.         if (obj->object == addr)
  249.             return obj;
  250.     }
  251.     
  252.     //更新debug_bucket对象上挂载的debug_obj对象最大值
  253.     if (cnt > debug_objects_maxchain)
  254.         debug_objects_maxchain = cnt;
  255.         
  256.     return NULL;
  257. }

  259. static struct debug_obj *alloc_object(void *addr, struct debug_bucket *b, struct debug_obj_descr *descr)
  260. {
  261.     struct debug_obj *obj = NULL;
  262.         
  263.     raw_spin_lock(&pool_lock);
  264.     if (obj_pool.first) {
  265.         //从obj_pool链表中取出一个debug_obj对象
  266.         obj    = hlist_entry(obj_pool.first, typeof(*obj), node);
  267.         
  268.         //对该对象初始化
  269.         obj->object = addr;    //debug的地址
  270.         obj->descr = descr;//调试的描述符结构体
  271.         obj->state = ODEBUG_STATE_NONE;//设置状态
  272.         obj->astate = 0;
  273.         //从obj_pool链表中删除
  274.         hlist_del(&obj->node);
  275.         //链入debug_bucket对象的list节点
  276.         hlist_add_head(&obj->node, &b->list);
  277.         
  278.         //更新一些变量
  279.         obj_pool_used++;
  280.         if (obj_pool_used > obj_pool_max_used)
  281.             obj_pool_max_used = obj_pool_used;
  282.         
  283.         obj_pool_free--;
  284.         if (obj_pool_free < obj_pool_min_free)
  285.             obj_pool_min_free = obj_pool_free;
  286.     }
  287.     raw_spin_unlock(&pool_lock);
  288.         
  289.     return obj;
  290. }

  292. 3. 使能addr对应的debug_obj
  293. int debug_object_activate(void *addr, struct debug_obj_descr *descr)
  294. {
  295.     enum debug_obj_state state;
  296.     struct debug_bucket *db;
  297.     struct debug_obj *obj;
  298.     unsigned long flags;
  299.     int ret;
  300.     struct debug_obj o = {    .object = addr,
  301.                             .state = ODEBUG_STATE_NOTAVAILABLE,
  302.                             .descr = descr };
  303.     
  304.     //没有使能debug功能则返回    
  305.     if (!debug_objects_enabled)
  306.         return 0;
  307.     //根据要debug的地址通过hash算法得到debug_bucket对象
  308.     db = get_bucket((unsigned long) addr);    
  309.     raw_spin_lock_irqsave(&db->lock, flags);

  311.     //根据debug地址到obj_pool查找一个debug_obj对象        
  312.     obj = lookup_object(addr, db);

  314.     //将debug_obj对象状态设置为ODEBUG_STATE_ACTIVE
  315.     if (obj) {
  316.         switch (obj->state) {
  317.         case ODEBUG_STATE_INIT:
  318.         case ODEBUG_STATE_INACTIVE:
  319.             obj->state = ODEBUG_STATE_ACTIVE;
  320.             ret = 0;
  321.             break;
  322.         
  323.         case ODEBUG_STATE_ACTIVE:
  324.             debug_print_object(obj, "activate");
  325.             state = obj->state;
  326.             raw_spin_unlock_irqrestore(&db->lock, flags);
  327.             ret = debug_object_fixup(descr->fixup_activate, addr, state);
  328.             return ret ? -EINVAL : 0;
  329.         
  330.         case ODEBUG_STATE_DESTROYED:
  331.             debug_print_object(obj, "activate");
  332.             ret = -EINVAL;
  333.             break;
  334.         default:
  335.             ret = 0;
  336.             break;
  337.         }
  338.         raw_spin_unlock_irqrestore(&db->lock, flags);
  339.         return ret;
  340.     }

  342.     raw_spin_unlock_irqrestore(&db->lock, flags);

  344.     if (debug_object_fixup(descr->fixup_activate, addr,ODEBUG_STATE_NOTAVAILABLE)) {
  345.         debug_print_object(&o, "activate");
  346.         return -EINVAL;
  347.     }
  348.     return 0;
  349. }


  352. 4. 用于检查addr对应的debug_obj对象的状态是否正确
  353. static int __init check_results(void *addr, enum debug_obj_state state, int fixups, int warnings)；


上一篇：arm linux启动流程三
下一篇：arm linux启动流程五