Revision f7897430 module.c
b/module.c | ||
---|---|---|
22 | 22 |
TAILQ_ENTRY(ModuleEntry) node; |
23 | 23 |
} ModuleEntry; |
24 | 24 |
|
25 |
typedef struct ModuleTypeList |
|
26 |
{ |
|
27 |
module_init_type type; |
|
28 |
TAILQ_HEAD(, ModuleEntry) entry_list; |
|
29 |
TAILQ_ENTRY(ModuleTypeList) node; |
|
30 |
} ModuleTypeList; |
|
25 |
typedef TAILQ_HEAD(, ModuleEntry) ModuleTypeList; |
|
31 | 26 |
|
32 |
static TAILQ_HEAD(, ModuleTypeList) init_type_list;
|
|
27 |
static ModuleTypeList init_type_list[MODULE_INIT_MAX];
|
|
33 | 28 |
|
34 |
static ModuleTypeList *find_type_or_alloc(module_init_type type, int alloc)
|
|
29 |
static void init_types(void)
|
|
35 | 30 |
{ |
36 |
ModuleTypeList *n; |
|
31 |
static int inited; |
|
32 |
int i; |
|
37 | 33 |
|
38 |
TAILQ_FOREACH(n, &init_type_list, node) { |
|
39 |
if (type >= n->type) |
|
40 |
break; |
|
34 |
if (inited) { |
|
35 |
return; |
|
41 | 36 |
} |
42 | 37 |
|
43 |
if (!n || n->type != type) { |
|
44 |
ModuleTypeList *o; |
|
38 |
for (i = 0; i < MODULE_INIT_MAX; i++) { |
|
39 |
TAILQ_INIT(&init_type_list[i]); |
|
40 |
} |
|
45 | 41 |
|
46 |
if (!alloc)
|
|
47 |
return NULL;
|
|
42 |
inited = 1;
|
|
43 |
}
|
|
48 | 44 |
|
49 |
o = qemu_mallocz(sizeof(*o)); |
|
50 |
o->type = type; |
|
51 |
TAILQ_INIT(&o->entry_list); |
|
52 | 45 |
|
53 |
if (n) { |
|
54 |
TAILQ_INSERT_AFTER(&init_type_list, n, o, node); |
|
55 |
} else { |
|
56 |
TAILQ_INSERT_HEAD(&init_type_list, o, node); |
|
57 |
} |
|
46 |
static ModuleTypeList *find_type(module_init_type type) |
|
47 |
{ |
|
48 |
ModuleTypeList *l; |
|
58 | 49 |
|
59 |
n = o; |
|
60 |
} |
|
50 |
init_types(); |
|
51 |
|
|
52 |
l = &init_type_list[type]; |
|
61 | 53 |
|
62 |
return n;
|
|
54 |
return l;
|
|
63 | 55 |
} |
64 | 56 |
|
65 | 57 |
void register_module_init(void (*fn)(void), module_init_type type) |
... | ... | |
70 | 62 |
e = qemu_mallocz(sizeof(*e)); |
71 | 63 |
e->init = fn; |
72 | 64 |
|
73 |
l = find_type_or_alloc(type, 1);
|
|
65 |
l = find_type(type);
|
|
74 | 66 |
|
75 |
TAILQ_INSERT_TAIL(&l->entry_list, e, node);
|
|
67 |
TAILQ_INSERT_TAIL(l, e, node);
|
|
76 | 68 |
} |
77 | 69 |
|
78 | 70 |
void module_call_init(module_init_type type) |
... | ... | |
80 | 72 |
ModuleTypeList *l; |
81 | 73 |
ModuleEntry *e; |
82 | 74 |
|
83 |
l = find_type_or_alloc(type, 0); |
|
84 |
if (!l) { |
|
85 |
return; |
|
86 |
} |
|
75 |
l = find_type(type); |
|
87 | 76 |
|
88 |
TAILQ_FOREACH(e, &l->entry_list, node) {
|
|
77 |
TAILQ_FOREACH(e, l, node) {
|
|
89 | 78 |
e->init(); |
90 | 79 |
} |
91 | 80 |
} |
Also available in: Unified diff