michaelh/zephyr
1
0
Fork 0
Code Releases Activity

sysgen: build for unified kernel only

Browse source 
sysgen will also now re-run if the build system detects that
the script itself has changed.

Change-Id: I2bf5c4893da088fa27729bc6337bc66cc4cee341
Signed-off-by: Andrew Boie <andrew.p.boie@intel.com>
This commit is contained in:
Andrew Boie 2016-11-03 12:09:00 -07:00
commit b4cc4c9bea
2 changed files with 119 additions and 643 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Kbuild
View file

@ -49,12 +49,10 @@ sysgen_cmd=$(strip \
$(PYTHON) $(srctree)/scripts/sysgen \ $(PYTHON) $(srctree)/scripts/sysgen \
-i $(CURDIR)/misc/generated/sysgen/prj.mdef \ -i $(CURDIR)/misc/generated/sysgen/prj.mdef \
-o $(CURDIR)/misc/generated/sysgen/ \ -o $(CURDIR)/misc/generated/sysgen/ \
-k $(if $(CONFIG_KERNEL_V2),unified,micro) \
) )
misc/generated/sysgen/kernel_main.c: misc/generated/sysgen/prj.mdef \ misc/generated/sysgen/kernel_main.c: misc/generated/sysgen/prj.mdef \
kernel/microkernel/include/micro_private_types.h \ $(srctree)/scripts/sysgen
kernel/microkernel/include/kernel_main.h
$(Q)$(sysgen_cmd) $(Q)$(sysgen_cmd)
define filechk_configs.c define filechk_configs.c

758
scripts/sysgen
View file

@ -78,18 +78,15 @@ copyright = \
output_dir = "" output_dir = ""
input_mdef_file = "" input_mdef_file = ""
kernel_type = 'micro'
def get_cmdline_args(): def get_cmdline_args():
""" Handle optional output directory argument """ """ Handle optional output directory argument """
global input_mdef_file global input_mdef_file
global output_dir global output_dir
global kernel_type
output_dir_help='output directory for kernel_main.*, sysgen.h, etc' output_dir_help='output directory for kernel_main.*, sysgen.h, etc'
input_mdef_file_help='input MDEF file' input_mdef_file_help='input MDEF file'
kernel_type_help="'micro' or 'unified'"
parser = argparse.ArgumentParser() parser = argparse.ArgumentParser()
@ -97,8 +94,6 @@ def get_cmdline_args():
required=True, help=input_mdef_file_help) required=True, help=input_mdef_file_help)
parser.add_argument('-o', '--output-dir', action='store', parser.add_argument('-o', '--output-dir', action='store',
help=output_dir_help) help=output_dir_help)
parser.add_argument('-k', '--kernel-type', action='store',
help=kernel_type_help)
args = parser.parse_args() args = parser.parse_args()
@ -107,9 +102,6 @@ def get_cmdline_args():
if (args.output_dir != None): if (args.output_dir != None):
output_dir = args.output_dir output_dir = args.output_dir
if (args.kernel_type != None):
kernel_type = args.kernel_type
def write_file(filename, contents): def write_file(filename, contents):
""" Create file using specified name and contents """ """ Create file using specified name and contents """
@ -172,34 +164,27 @@ def mdef_parse():
continue continue
if (words[0] == "TASK"): if (words[0] == "TASK"):
if kernel_type == 'micro': if len(words) < 6 and len(words) > 10:
if (len(words) != 6): error_arg_count(line)
error_arg_count(line)
task_list.append((words[1], int(words[2]), words[3],
int(words[4]), words[5]))
continue
elif (kernel_type == 'unified'):
if len(words) < 6 and len(words) > 10:
error_arg_count(line)
p1 = 0 p1 = 0
p2 = 0 p2 = 0
p3 = 0 p3 = 0
if len(words) >= 7: if len(words) >= 7:
p1 = words[6] p1 = words[6]
if len(words) >= 8: if len(words) >= 8:
p2 = words[7] p2 = words[7]
if len(words) == 9: if len(words) == 9:
p3 = words[8] p3 = words[8]
abort = 0 abort = 0
if len(words) == 10: if len(words) == 10:
abort = words[9] abort = words[9]
task_list.append((words[1], int(words[2]), words[3], task_list.append((words[1], int(words[2]), words[3],
int(words[4]), words[5], p1, p2, p3, abort)) int(words[4]), words[5], p1, p2, p3, abort))
continue continue
if (words[0] == "TASKGROUP"): if (words[0] == "TASKGROUP"):
if (len(words) != 2): if (len(words) != 2):
@ -218,21 +203,15 @@ def mdef_parse():
continue continue
if (words[0] == "SEMA"): if (words[0] == "SEMA"):
if (kernel_type == "micro"): if len(words) < 2 and len(words) > 4:
if (len(words) != 2): error_arg_count(line)
error_arg_count(line) if len(words) == 2:
sema_list.append((words[1],)) sema_list.append((words[1], 0, 0xffffffff))
continue elif len(words) == 3:
elif (kernel_type == "unified"): sema_list.append((words[1], int(words[2]), 0xffffffff))
if len(words) < 2 and len(words) > 4: else:
error_arg_count(line) sema_list.append((words[1], int(words[2]), int(words[3])))
if len(words) == 2: continue
sema_list.append((words[1], 0, 0xffffffff))
elif len(words) == 3:
sema_list.append((words[1], int(words[2]), 0xffffffff))
else:
sema_list.append((words[1], int(words[2]), int(words[3])))
continue
if (words[0] == "MUTEX"): if (words[0] == "MUTEX"):
if (len(words) != 2): if (len(words) != 2):
@ -292,7 +271,7 @@ def mdef_parse():
kernel_main_c_data = "" kernel_main_c_data = ""
kernel_main_c_filename_str = \ kernel_main_c_filename_str = \
"/* kernel_main.c - microkernel objects */\n\n" "/* kernel_main.c - kernel objects */\n\n"
def kernel_main_c_out(string): def kernel_main_c_out(string):
@ -305,84 +284,17 @@ def kernel_main_c_out(string):
def kernel_main_c_header(): def kernel_main_c_header():
""" Generate initial portion of kernel_main.c """ """ Generate initial portion of kernel_main.c """
if kernel_type == 'micro':
kernel_main_c_out(
kernel_main_c_filename_str +
copyright +
do_not_edit_warning +
"\n" +
"#include <sysgen.h>\n" +
"#include <misc/debug/object_tracing_common.h>\n" +
"#include <micro_private_types.h>\n" +
"#include <kernel_main.h>\n" +
"#include <toolchain.h>\n" +
"#include <sections.h>\n")
else:
kernel_main_c_out(
kernel_main_c_filename_str +
copyright +
do_not_edit_warning +
"\n" +
"#include <sysgen.h>\n" +
"#include <misc/debug/object_tracing_common.h>\n" +
"#include <kernel.h>\n" +
"#include <toolchain.h>\n" +
"#include <sections.h>\n")
def kernel_main_c_kargs():
""" Generate command packet variables """
# command packets
kernel_main_c_out("\n" +
"struct k_args _k_server_command_packets[%s] =\n" % (num_kargs) +
"{\n" +
" {NULL, NULL, 0, 0, _K_SVC_UNDEFINED},\n")
for i in range(1, num_kargs - 1):
kernel_main_c_out(
" {&_k_server_command_packets[%d], " % (i - 1) +
"NULL, 0, 0, _K_SVC_UNDEFINED},\n")
kernel_main_c_out( kernel_main_c_out(
" {&_k_server_command_packets[%d], " % (num_kargs - 2) + kernel_main_c_filename_str +
"NULL, 0, 0, _K_SVC_UNDEFINED}\n" + copyright +
"};\n") do_not_edit_warning +
"\n" +
"#include <sysgen.h>\n" +
"#include <misc/debug/object_tracing_common.h>\n" +
"#include <kernel.h>\n" +
"#include <toolchain.h>\n" +
"#include <sections.h>\n")
# linked list of free command packets
kernel_main_c_out("\n" +
"struct nano_lifo _k_server_command_packet_free = " +
"{{NULL, &_k_server_command_packet_free.wait_q.head}, " +
"(void *) &_k_server_command_packets[%d]};\n" % (num_kargs - 1))
def kernel_main_c_timers():
""" Generate timer system variables """
if (num_timers == 0):
return
# timer descriptors
kernel_main_c_out("\n" +
"struct k_timer _k_timer_blocks[%d] =\n" % (num_timers) +
"{\n" +
" {NULL, NULL, 0, 0, (struct k_args *)0xffffffff},\n")
for i in range(1, num_timers - 1):
kernel_main_c_out(
" {&_k_timer_blocks[%d], " % (i - 1) +
"NULL, 0, 0, (struct k_args *)0xffffffff},\n")
kernel_main_c_out(
" {&_k_timer_blocks[%d], " % (num_timers - 2) +
"NULL, 0, 0, (struct k_args *)0xffffffff}\n" +
"};\n")
# linked list of free timers
kernel_main_c_out("\n" +
"struct nano_lifo _k_timer_free = " +
"{{NULL, &_k_timer_free.wait_q.head}, " +
"(void *) &_k_timer_blocks[%d]};\n" % (num_timers - 1))
def get_group_bitmask(group_str): def get_group_bitmask(group_str):
@ -413,7 +325,7 @@ def is_int(x):
def is_number(x): def is_number(x):
return is_float(x) or is_int(x) return is_float(x) or is_int(x)
def kernel_main_c_tasks_unified(): def kernel_main_c_tasks():
global num_prios global num_prios
kernel_main_c_out("\n") kernel_main_c_out("\n")
@ -464,146 +376,13 @@ def kernel_main_c_tasks_unified():
abort, int(prio), int(groups))) abort, int(prio), int(groups)))
def kernel_main_c_tasks_micro():
global num_prios
# task stack areas
kernel_main_c_out("\n")
for task in task_list:
kernel_main_c_out("char __noinit __stack __%s_stack[%d];\n" %
(task[0], task[3]))
kernel_main_c_out("extern char main_task_stack[CONFIG_MAIN_STACK_SIZE];\n")
# declare task entry points
kernel_main_c_out("\n")
for task in task_list:
kernel_main_c_out("EXTERN_C void %s(void);\n" % task[2])
# task descriptors (including one for idle task)
#
# compiler puts these objects into the section as if
# it is a stack. hence the need to reverse the list.
# this is to preseve the order defined in MDEF file.
kernel_main_c_out("\n")
for task in reversed(task_list):
name = task[0]
prio = task[1]
entry = task[2]
size = task[3]
obj_name = "_k_task_obj_%s" % (name)
stack = "__" + task[0] + "_stack"
# create bitmask of group(s) task belongs to
group_bitmask = get_group_bitmask(task[4])
# invert bitmask to convert SYS indication to non-SYS indication
#
# NOTE: There actually is no SYS group; instead, there is a non-SYS
# group that all tasks belong to unless they specify the 'SYS' name.
# This approach allows the kernel to easily suspend all non-SYS tasks
# during debugging, while minimizing the number of task entries that
# have to explicitly indicate their SYS/non-SYS status.
group_bitmask ^= group_dictionary['SYS']
kernel_main_c_out(
"struct k_task %s " % (obj_name)+
"__in_section(_k_task_list, public, task) =\n" +
" {NULL, NULL, %d, (ktask_t)&%s,\n" % (prio, obj_name) +
" 0x00000001, %#010x,\n" % (group_bitmask) +
" %s, %s, %d,\n" % (entry, stack, size) +
" (taskabortfunction)NULL, NULL};\n" +
"ktask_t _k_task_ptr_%s " % (name) +
" __in_section(_k_task_ptr, public, task) = " +
" (ktask_t)&%s;\n" % (obj_name))
kernel_main_c_out(
"struct k_task _k_task_idle " +
"__in_section(_k_task_list, idle, task) =\n" +
" {NULL, NULL, %d, 0x00000000,\n" % (num_prios - 1) +
" 0x00000000, 0x00000000,\n" +
" (taskstartfunction)NULL, main_task_stack,\n"
" CONFIG_MAIN_STACK_SIZE,\n" +
" (taskabortfunction)NULL, NULL};\n" +
"ktask_t _k_task_ptr_idle " +
" __in_section(_k_task_ptr, idle, task) = " +
" (ktask_t)&_k_task_idle;\n")
# currently scheduled task (idle task)
kernel_main_c_out("\n" +
"struct k_task * _k_current_task = &_k_task_idle;\n")
def kernel_main_c_tasks():
""" Generate task variables """
if kernel_type == 'micro':
kernel_main_c_tasks_micro()
else:
kernel_main_c_tasks_unified()
def kernel_main_c_priorities():
""" Generate task scheduling variables """
global num_prios
total_tasks = len(task_list) + 1
# priority queue descriptors (lowest priority queue contains idle task)
kernel_main_c_out("\n" +
"struct k_tqhd _k_task_priority_list[%d] =\n" % (num_prios) +
"{\n")
for i in range(1, num_prios):
kernel_main_c_out(
" {NULL, (struct k_task *)&_k_task_priority_list[%d]},\n" %
(i - 1))
kernel_main_c_out(
" {&_k_task_idle, &_k_task_idle}\n" +
"};\n")
# active priority queue (idle task's queue)
kernel_main_c_out("\n" +
"struct k_tqhd * K_Prio = &_k_task_priority_list[%d];\n" %
(num_prios - 1))
# priority queue bit map (indicates which priority queues are non-empty;
# initially only the idle task's queue has a runnable task)
num_bit_maps = ((num_prios + 31) // 32)
kernel_main_c_out("\n" +
"uint32_t _k_task_priority_bitmap[%d] = {" % (num_bit_maps))
for i in range(1, num_bit_maps):
kernel_main_c_out("0, ")
kernel_main_c_out("(1u << %d)};\n" % ((num_prios - 1) & 0x1f))
def kernel_main_c_events(): def kernel_main_c_events():
""" Generate event variables """ """ Generate event variables """
if kernel_type == 'micro': event_type = 'struct k_alert *'
event_type = 'int'
else:
event_type = 'struct k_alert *'
# event descriptors # event descriptors
# pre-defined event for timer
if kernel_type == 'micro':
if (num_timers > 0):
kernel_main_c_out("DEFINE_EVENT(TICK_EVENT, _k_ticker);\n")
else:
kernel_main_c_out("DEFINE_EVENT(TICK_EVENT, NULL);\n")
# project-specific events # project-specific events
for event in event_list: for event in event_list:
@ -616,11 +395,8 @@ def kernel_main_c_events():
kernel_main_c_out("extern int %s(%s event);\n" % kernel_main_c_out("extern int %s(%s event);\n" %
(event[1], event_type)) (event[1], event_type))
if kernel_type == 'micro': kernel_main_c_out("K_ALERT_DEFINE(_k_event_obj_%s, %s, 1);\n" %
kernel_main_c_out("DEFINE_EVENT(%s, %s);\n" % (event[0], event[1])) (event[0], event[1]))
else:
kernel_main_c_out("K_ALERT_DEFINE(_k_event_obj_%s, %s, 1);\n" %
(event[0], event[1]))
def kernel_main_c_mutexes(): def kernel_main_c_mutexes():
""" Generate mutex variables """ """ Generate mutex variables """
@ -635,11 +411,7 @@ def kernel_main_c_mutexes():
kernel_main_c_out("\n") kernel_main_c_out("\n")
for mutex in mutex_list: for mutex in mutex_list:
name = mutex[0] name = mutex[0]
if kernel_type == 'micro': kernel_main_c_out("K_MUTEX_DEFINE(_k_mutex_obj_%s);\n" % (name))
kernel_main_c_out("struct _k_mutex_struct _k_mutex_obj_%s = " %
(name) + "__MUTEX_DEFAULT;\n")
else:
kernel_main_c_out("K_MUTEX_DEFINE(_k_mutex_obj_%s);\n" % (name))
def kernel_main_c_semas(): def kernel_main_c_semas():
@ -655,14 +427,10 @@ def kernel_main_c_semas():
kernel_main_c_out("\n") kernel_main_c_out("\n")
for semaphore in sema_list: for semaphore in sema_list:
name = semaphore[0] name = semaphore[0]
if kernel_type == 'micro': initial_count = semaphore[1]
kernel_main_c_out("struct _k_sem_struct _k_sem_obj_%s = " % limit = semaphore[2]
(name) + "__K_SEMAPHORE_DEFAULT;\n") kernel_main_c_out("K_SEM_DEFINE(_k_sem_obj_%s, %s, %s);\n" %
else: (name, initial_count, limit))
initial_count = semaphore[1]
limit = semaphore[2]
kernel_main_c_out("K_SEM_DEFINE(_k_sem_obj_%s, %s, %s);\n" %
(name, initial_count, limit))
def kernel_main_c_fifos(): def kernel_main_c_fifos():
@ -675,28 +443,13 @@ def kernel_main_c_fifos():
kernel_main_c_out("\n") kernel_main_c_out("\n")
if kernel_type == 'micro': # message queue objects
# FIFO buffers and descriptors for fifo in fifo_list:
name = fifo[0]
for fifo in fifo_list: depth = fifo[1]
name = fifo[0] width = fifo[2]
depth = fifo[1] kernel_main_c_out("K_MSGQ_DEFINE(_k_fifo_obj_%s, %s, %s, 4);\n" %
width = fifo[2] (name, width, depth))
buffer = "__" + name + "_buffer"
kernel_main_c_out("char __noinit %s[%d];\n" %
(buffer, depth * width))
kernel_main_c_out(
"struct _k_fifo_struct _k_fifo_obj_%s = " % (name) +
"__K_FIFO_DEFAULT(%d, %d, %s);\n" % (depth, width, buffer))
else:
# message queue objects
for fifo in fifo_list:
name = fifo[0]
depth = fifo[1]
width = fifo[2]
kernel_main_c_out("K_MSGQ_DEFINE(_k_fifo_obj_%s, %s, %s, 4);\n" %
(name, width, depth))
def kernel_main_c_pipes(): def kernel_main_c_pipes():
@ -711,32 +464,12 @@ def kernel_main_c_pipes():
kernel_main_c_out("\n") kernel_main_c_out("\n")
if kernel_type == 'micro': # pipe objects
for pipe in pipe_list: for pipe in pipe_list:
kernel_main_c_out( name = pipe[0]
"char __noinit __%s_buffer[%d];\n" % (pipe[0], pipe[1])) size = pipe[1]
kernel_main_c_out("K_PIPE_DEFINE(_k_pipe_obj_%s, %d, 4);\n" %
# pipe descriptors (name, size))
for pipe in pipe_list:
name = pipe[0]
size = pipe[1]
buffer = "__" + pipe[0] + "_buffer"
kernel_main_c_out("struct _k_pipe_struct _k_pipe_obj_%s = "
% (name) +
" __K_PIPE_INITIALIZER(%d, %s);\n" % (size, buffer) +
"kpipe_t _k_pipe_ptr_%s " % (name) +
" __in_section(_k_pipe_ptr, public, pipe) =\n" +
" (kpipe_t)&_k_pipe_obj_%s;\n" % (name))
else:
# pipe objects
for pipe in pipe_list:
name = pipe[0]
size = pipe[1]
kernel_main_c_out("K_PIPE_DEFINE(_k_pipe_obj_%s, %d, 4);\n" %
(name, size))
def kernel_main_c_mailboxes(): def kernel_main_c_mailboxes():
@ -749,20 +482,10 @@ def kernel_main_c_mailboxes():
kernel_main_c_out("\n") kernel_main_c_out("\n")
if kernel_type == 'micro': # mailbox objects
# mailbox descriptors for mbx in mbx_list:
name = mbx[0]
for mbx in mbx_list: kernel_main_c_out("K_MBOX_DEFINE(_k_mbox_obj_%s);\n" % (name))
name = mbx[0]
kernel_main_c_out(
"struct _k_mbox_struct _k_mbox_obj_%s = " % (name) +
"__K_MAILBOX_DEFAULT;\n")
else:
# mailbox objects
for mbx in mbx_list:
name = mbx[0]
kernel_main_c_out("K_MBOX_DEFINE(_k_mbox_obj_%s);\n" % (name))
def kernel_main_c_maps(): def kernel_main_c_maps():
@ -775,32 +498,13 @@ def kernel_main_c_maps():
kernel_main_c_out("\n") kernel_main_c_out("\n")
if kernel_type == 'micro': # memory map objects
# memory map buffers and descriptors for map in map_list:
name = map[0]
for map in map_list: blocks = map[1]
name = map[0] block_size = map[2]
blocks = map[1] kernel_main_c_out("K_MEM_SLAB_DEFINE(_k_mem_map_obj_%s, %s, %s, 4);\n" %
block_size = map[2] (name, block_size, blocks))
kernel_main_c_out("char __noinit __MAP_%s_buffer[%d];\n" %
(map[0], blocks * block_size))
kernel_main_c_out(
"struct _k_mem_map_struct _k_mem_map_obj_%s = " % (name) +
"__K_MEM_MAP_INITIALIZER(%d, %d, __MAP_%s_buffer);\n" %
(blocks, block_size, map[0]))
kernel_main_c_out(
"kmemory_map_t _k_mem_map_ptr_%s " % (name) +
" __in_section(_k_mem_map_ptr, public, mem_map) =\n" +
" (kmemory_map_t)&_k_mem_map_obj_%s;\n" % (name))
else:
# memory map objects
for map in map_list:
name = map[0]
blocks = map[1]
block_size = map[2]
kernel_main_c_out("K_MEM_SLAB_DEFINE(_k_mem_map_obj_%s, %s, %s, 4);\n" %
(name, block_size, blocks))
def kernel_main_c_pools(): def kernel_main_c_pools():
@ -813,172 +517,23 @@ def kernel_main_c_pools():
kernel_main_c_out("\nint _k_mem_pool_count = %d;\n" % (total_pools)) kernel_main_c_out("\nint _k_mem_pool_count = %d;\n" % (total_pools))
if kernel_type == 'micro': pool_descriptors = ""
if (total_pools == 0): for pool in pool_list:
kernel_main_c_out("\nstruct pool_struct * _k_mem_pool_list = NULL;\n") kernel_main_c_out("\n")
return min_block_size = pool[1]
# Heap pool if present can be indexed using the below variable max_block_size = pool[2]
if (heap_pos_in_pool_list != -1): num_maximal_blocks = pool[3]
kernel_main_c_out("\nconst kmemory_pool_t _heap_mem_pool_id = %d;\n" \ pool_descriptors += "K_MEM_POOL_DEFINE(_k_mem_pool_obj_%s, %d, %d, %d, 4);\n" % \
%(heap_pos_in_pool_list)) (pool[0], min_block_size, max_block_size,
num_maximal_blocks)
# start accumulating memory pool descriptor info if (heap_pos_in_pool_list != -1):
kernel_main_c_out(
pool_descriptors = "\nstruct pool_struct _k_mem_pool_list[%d] =\n{\n" % \ "\nkmemory_pool_t _heap_mem_pool_ptr = " +
(total_pools) "&_k_mem_pool_obj__HEAP_MEM_POOL;\n")
ident = 0x00010000
for pool in pool_list:
kernel_main_c_out("\n")
# create local variables relating to current pool
min_block_size = pool[1]
max_block_size = pool[2]
num_maximal_blocks = pool[3]
total_memory = max_block_size * num_maximal_blocks
buffer = "__" + pool[0] + "_buffer"
frag_table = "block_sets_%#010x" % ident
# determine block sizes used by pool (including actual minimum size)
block_size_list = [max_block_size]
while (ident != 0): # loop forever
min_block_size_actual = block_size_list[len(block_size_list) - 1]
min_block_size_proposed = min_block_size_actual / 4
if (min_block_size_proposed < min_block_size):
break
block_size_list.append(min_block_size_proposed)
frag_levels = len(block_size_list)
# determine size of quad-block arrays,
# from the largest block size to the smallest block size
# - each array must be big enough to track the status of
# the entire memory pool buffer
# - each array entry tracks the status of 4 consecutive blocks
# - need to do rounding up with array for largest block size
# in case the # of largest size blocks isn't a multiple of 4
# (i.e. it's final array entry may be partly unused)
quad_block_sizes = [(num_maximal_blocks + 3) / 4]
quad_block_size_to_use = num_maximal_blocks
for index in range(1, frag_levels):
quad_block_sizes.append(quad_block_size_to_use)
quad_block_size_to_use *= 4
# generate array of quad-blocks for each block set
for index in range(0, frag_levels):
kernel_main_c_out(
"struct pool_quad_block quad_blocks_%#010x_%d[%d];\n" %
(ident, index, quad_block_sizes[index]))
# generate array of block sets for memory pool
kernel_main_c_out("\nstruct pool_block_set %s[%d] =\n{\n" %
(frag_table, frag_levels))
for index in range(0, frag_levels):
kernel_main_c_out(" { %d, %d, quad_blocks_%#010x_%d},\n" %
(block_size_list[index], quad_block_sizes[index],
ident, index))
kernel_main_c_out("};\n")
# generate memory pool buffer
kernel_main_c_out("\nchar __noinit %s[%d];\n" % (buffer, total_memory))
# append memory pool descriptor info
pool_descriptors += " {%d, %d, %d, %d, NULL, %s, %s},\n" % \
(max_block_size, min_block_size_actual,
num_maximal_blocks, frag_levels, frag_table, buffer)
ident += 1
# generate memory pool descriptor info
pool_descriptors += "};\n"
elif kernel_type == 'unified':
pool_descriptors = ""
for pool in pool_list:
kernel_main_c_out("\n")
min_block_size = pool[1]
max_block_size = pool[2]
num_maximal_blocks = pool[3]
pool_descriptors += "K_MEM_POOL_DEFINE(_k_mem_pool_obj_%s, %d, %d, %d, 4);\n" % \
(pool[0], min_block_size, max_block_size,
num_maximal_blocks)
if (heap_pos_in_pool_list != -1):
kernel_main_c_out(
"\nkmemory_pool_t _heap_mem_pool_ptr = " +
"&_k_mem_pool_obj__HEAP_MEM_POOL;\n")
kernel_main_c_out(pool_descriptors) kernel_main_c_out(pool_descriptors)
def kernel_main_c_node_init():
""" Generate node initialization routine """
kernel_main_c_out("\n" +
"void _k_init_dynamic(void)\n{\n")
kernel_main_c_out(" _k_pipe_init();\n")
kernel_main_c_out(" _k_mem_map_init();\n")
if (len(pool_list) > 0):
kernel_main_c_out(" _k_mem_pool_init();\n")
kernel_main_c_out("#ifdef CONFIG_DEBUG_TRACING_KERNEL_OBJECTS\n")
# mutex object ids
for mutex in mutex_list:
name = mutex[0]
kernel_main_c_out("\tSYS_TRACING_OBJ_INIT(micro_mutex, " +
"&_k_mutex_obj_%s);\n" % (name))
# semaphore object ids
for semaphore in sema_list:
name = semaphore[0]
kernel_main_c_out("\tSYS_TRACING_OBJ_INIT(micro_sem, " +
"&_k_sem_obj_%s);\n" % (name))
# fifo object ids
for fifo in fifo_list:
name = fifo[0]
kernel_main_c_out("\tSYS_TRACING_OBJ_INIT(micro_fifo, " +
"&_k_fifo_obj_%s);\n" % (name))
# mailbox object ids
for mbx in mbx_list:
name = mbx[0]
kernel_main_c_out("\tSYS_TRACING_OBJ_INIT(micro_mbox, " +
"&_k_mbox_obj_%s);\n" % (name))
# pipe object id
for pipe in pipe_list:
name = pipe[0];
kernel_main_c_out("\tSYS_TRACING_OBJ_INIT(micro_pipe, " +
"&_k_pipe_obj_%s);\n" % (name))
# memory map object id
for map in map_list:
name = map[0];
kernel_main_c_out("\tSYS_TRACING_OBJ_INIT(micro_mem_map, " +
"&_k_mem_map_obj_%s);\n" % (name))
# memory pool object id
pool_count = 0;
total_pools = len(pool_list);
while (pool_count < total_pools):
kernel_main_c_out("\tSYS_TRACING_OBJ_INIT(micro_mem_pool, " +
"&(_k_mem_pool_list[%d]));\n" % (pool_count))
pool_count = pool_count + 1;
# event map object id
for event in event_list:
# no need to expose the irq task events
if not (event[0].startswith("_TaskIrqEvt")):
name = event[0];
kernel_main_c_out("\tSYS_TRACING_OBJ_INIT(micro_event, " +
"&_k_event_obj_%s);\n" % (name))
kernel_main_c_out("#endif\n")
kernel_main_c_out("}\n")
def kernel_main_c_generate(): def kernel_main_c_generate():
""" Generate kernel_main.c file """ """ Generate kernel_main.c file """
@ -996,50 +551,9 @@ def kernel_main_c_generate():
kernel_main_c_pipes() kernel_main_c_pipes()
kernel_main_c_pools() kernel_main_c_pools()
if kernel_type == 'micro':
kernel_main_c_kargs()
kernel_main_c_timers()
kernel_main_c_node_init()
kernel_main_c_priorities()
write_file(output_dir + 'kernel_main.c', kernel_main_c_data) write_file(output_dir + 'kernel_main.c', kernel_main_c_data)
#
# GENERATE kernel_main.h FILE
#
def kernel_main_h_generate():
""" Generate kernel_main.h file """
global output_dir
subprocess.check_call([
"cp",
"-f",
os.environ["ZEPHYR_BASE"] +
"/kernel/microkernel/include/kernel_main.h",
output_dir])
#
# GENERATE micro_private_types.h FILE
#
def micro_private_types_h_generate():
""" Generate micro_private_types.h file """
global output_dir
subprocess.check_call([
"cp",
"-f",
os.environ["ZEPHYR_BASE"] +
"/kernel/microkernel/include/micro_private_types.h",
output_dir])
# #
# GENERATE sysgen.h FILE # GENERATE sysgen.h FILE
@ -1049,7 +563,7 @@ def micro_private_types_h_generate():
sysgen_h_data = "" sysgen_h_data = ""
sysgen_h_filename_str = \ sysgen_h_filename_str = \
"/* sysgen.h - system generated microkernel definitions */\n\n" "/* sysgen.h - system generated kernel definitions */\n\n"
sysgen_h_include_guard = "_SYSGEN__H_" sysgen_h_include_guard = "_SYSGEN__H_"
@ -1062,10 +576,7 @@ def generate_sysgen_h_header():
global sysgen_h_data global sysgen_h_data
if kernel_type == 'micro': kernel_api_file = "#include <kernel.h>\n"
kernel_api_file = "#include <microkernel.h>\n"
else:
kernel_api_file = "#include <kernel.h>\n"
sysgen_h_data += \ sysgen_h_data += \
sysgen_h_filename_str + \ sysgen_h_filename_str + \
@ -1115,37 +626,21 @@ def generate_sysgen_h_obj_ids():
global sysgen_h_data global sysgen_h_data
if kernel_type == 'micro': mutex_struct = 'k_mutex'
mutex_struct = '_k_mutex_struct' mutex_type = 'struct k_mutex *'
mutex_type = 'kmutex_t' sem_struct = 'k_sem'
sem_struct = '_k_sem_struct' sem_type = 'struct k_sem *'
sem_type = 'ksem_t' pipe_struct = 'k_pipe'
pipe_struct = '_k_pipe_struct' pipe_type = 'struct k_pipe *'
pipe_type = 'kpipe_t' map_struct = 'k_mem_slab'
map_struct = '_k_mem_map_struct' map_type = 'struct k_mem_slab *'
map_type = 'kmemory_map_t' fifo_struct = 'k_msgq'
fifo_struct = '_k_fifo_struct' fifo_type = 'struct k_msgq *'
fifo_type = 'kfifo_t' mbox_struct = 'k_mbox'
mbox_struct = '_k_mbox_struct' mbox_type = 'struct k_mbox *'
mbox_type = 'kmbox_t' event_type = 'struct k_alert *'
event_type = 'kevent_t' mem_pool_type = 'struct k_mem_pool'
# add missing object types # add missing object types
else:
mutex_struct = 'k_mutex'
mutex_type = 'struct k_mutex *'
sem_struct = 'k_sem'
sem_type = 'struct k_sem *'
pipe_struct = 'k_pipe'
pipe_type = 'struct k_pipe *'
map_struct = 'k_mem_slab'
map_type = 'struct k_mem_slab *'
fifo_struct = 'k_msgq'
fifo_type = 'struct k_msgq *'
mbox_struct = 'k_mbox'
mbox_type = 'struct k_mbox *'
event_type = 'struct k_alert *'
mem_pool_type = 'struct k_mem_pool'
# add missing object types
# mutex object ids # mutex object ids
@ -1216,21 +711,16 @@ def generate_sysgen_h_obj_ids():
entry = task[2] entry = task[2]
stack_size = task[3] stack_size = task[3]
if kernel_type == 'micro': if entry == "main":
# Special case: if the MDEF defines a main() thread,
# re-purpose the already existing main_thread for it.
sysgen_h_data += \ sysgen_h_data += \
"extern struct k_task _k_task_obj_%s;\n" % (name) + \ "#define MDEF_MAIN_STACK_SIZE %d\n" % stack_size
"#define %s ((ktask_t)&_k_task_obj_%s)\n" % (name, name) sysgen_h_data += \
elif (kernel_type == 'unified'): "#define MDEF_MAIN_THREAD_PRIORITY %d\n" % prio
if entry == "main": else:
# Special case: if the MDEF defines a main() thread, sysgen_h_data += \
# re-purpose the already existing main_thread for it. "extern char _k_thread_obj_%s[];\n" % (name) + \
sysgen_h_data += \
"#define MDEF_MAIN_STACK_SIZE %d\n" % stack_size
sysgen_h_data += \
"#define MDEF_MAIN_THREAD_PRIORITY %d\n" % prio
else:
sysgen_h_data += \
"extern char _k_thread_obj_%s[];\n" % (name) + \
"#define %s ((k_tid_t)_k_thread_obj_%s)\n" % (name, name) "#define %s ((k_tid_t)_k_thread_obj_%s)\n" % (name, name)
# event object ids # event object ids
@ -1240,28 +730,19 @@ def generate_sysgen_h_obj_ids():
# no need to expose the irq task events # no need to expose the irq task events
if not (event[0].startswith("_TaskIrqEvt")): if not (event[0].startswith("_TaskIrqEvt")):
name = event[0]; name = event[0];
if kernel_type == 'micro': sysgen_h_data += \
sysgen_h_data += "extern const %s %s;\n" % (event_type, name) "extern struct k_alert _k_event_obj_%s;\n" % (name)
elif (kernel_type == 'unified'): sysgen_h_data += \
sysgen_h_data += \ "#define %s (&_k_event_obj_%s)\n\n" % (name, name)
"extern struct k_alert _k_event_obj_%s;\n" % (name)
sysgen_h_data += \
"#define %s (&_k_event_obj_%s)\n\n" % (name, name)
# memory pool object ids # memory pool object ids
if kernel_type == 'micro': for mem_pool in pool_list:
obj_types = [ name = mem_pool[0];
[pool_list, 0], sysgen_h_data += \
] "extern %s _k_mem_pool_obj_%s;\n" % (mem_pool_type, name)
sysgen_h_data += generate_obj_id_lines(obj_types) sysgen_h_data += \
elif (kernel_type == 'unified'): "#define %s ((%s *)&_k_mem_pool_obj_%s)\n" % (name, mem_pool_type, name)
for mem_pool in pool_list:
name = mem_pool[0];
sysgen_h_data += \
"extern %s _k_mem_pool_obj_%s;\n" % (mem_pool_type, name)
sysgen_h_data += \
"#define %s ((%s *)&_k_mem_pool_obj_%s)\n" % (name, mem_pool_type, name)
# all other object ids # all other object ids
@ -1295,7 +776,4 @@ def sysgen_h_generate():
get_cmdline_args() get_cmdline_args()
mdef_parse() mdef_parse()
kernel_main_c_generate() kernel_main_c_generate()
if kernel_type == 'micro':
kernel_main_h_generate()
micro_private_types_h_generate()
sysgen_h_generate() sysgen_h_generate()