| /* |
| * Copyright 2020, Data61, ABN 41 687 119 230. |
| * |
| * SPDX-License-Identifier: BSD-2-Clause |
| */ |
| |
| #include <platsupport/io.h> |
| #include <platsupport/driver_module.h> |
| #include <camkes.h> |
| #include <camkes/io.h> |
| #include <utils/util.h> |
| #include <camkes/tls.h> |
| #include <camkes/irq.h> |
| #include <sel4bench/sel4bench.h> |
| /*- from 'global-endpoint.template.c' import allocate_cap_instance, allocate_rpc_cap_instance with context -*/ |
| |
| /* Force the init sections to be created even if no modules are defined. */ |
| static USED SECTION("_env_init") struct {} dummy_env_init_module; |
| static USED SECTION("_pre_init") struct {} dummy_pre_init_module; |
| static USED SECTION("_post_init") struct {} dummy_post_init_module; |
| /* Definitions so that we can find the list of hardware modules that we need to initialise */ |
| |
| extern camkes_module_init_fn_t __start__env_init[]; |
| extern camkes_module_init_fn_t __stop__env_init[]; |
| extern camkes_module_init_fn_t __start__pre_init[]; |
| extern camkes_module_init_fn_t __stop__pre_init[]; |
| extern camkes_module_init_fn_t __start__post_init[]; |
| extern camkes_module_init_fn_t __stop__post_init[]; |
| |
| static ps_io_ops_t io_ops; |
| |
| |
| void pre_init(void) { |
| int err = camkes_io_ops(&io_ops); |
| if (err) { |
| ZF_LOGE("Failed to initialize io_ops"); |
| } |
| for (camkes_module_init_fn_t * init_fun = __start__env_init; init_fun < __stop__env_init; init_fun++) { |
| err = (*init_fun)(&io_ops); |
| if (err) { |
| ZF_LOGE("Failed to initialize %p", init_fun); |
| } |
| |
| } |
| for (camkes_module_init_fn_t * init_fun = __start__pre_init; init_fun < __stop__pre_init; init_fun++) { |
| err = (*init_fun)(&io_ops); |
| if (err) { |
| ZF_LOGE("Failed to initialize %p", init_fun); |
| } |
| |
| } |
| err = camkes_call_hardware_init_modules(&io_ops); |
| if (err) { |
| ZF_LOGE("Failed to initialize hardware init modules"); |
| } |
| for (camkes_module_init_fn_t *init_fun = __start__post_init; init_fun < __stop__post_init; init_fun++) { |
| err = (*init_fun)(&io_ops); |
| if (err) { |
| ZF_LOGE("Failed to initialize %p", init_fun); |
| } |
| |
| } |
| } |
| |
| |
| /*- do allocate_cap_instance(me) -*/ |
| /*- set notification = pop('notification') -*/ |
| /*- do allocate_rpc_cap_instance(me) -*/ |
| /*- set endpoint = pop('endpoint') -*/ |
| |
| /*# Allocate reply cap #*/ |
| /*- if options.realtime -*/ |
| /*- set reply_cap_slot = alloc('reply_cap_slot', seL4_RTReplyObject) -*/ |
| /*- else -*/ |
| /*# We're going to need a CNode cap in order to save our pending reply |
| * caps in the future. |
| #*/ |
| /*- set cnode = alloc_cap('cnode', my_cnode) -*/ |
| /*- set reply_cap_slot = alloc_cap('reply_cap_slot', None) -*/ |
| /*- endif -*/ |
| |
| |
| struct handlers { |
| seL4_Word badge; |
| void (*callback_handler)(seL4_Word, void *); |
| void * cookie; |
| const char* name; |
| }; |
| |
| static struct handlers *reg_handlers; |
| static int num_handlers = 0; |
| int single_threaded_component_register_handler(seL4_Word badge, const char* name, void (*callback_handler)(seL4_Word, void *), void * cookie) { |
| reg_handlers = realloc(reg_handlers, (num_handlers+1) * sizeof(*reg_handlers)); |
| if (!reg_handlers) { |
| ZF_LOGF("Failed to allocate handlers"); |
| } |
| reg_handlers[num_handlers] = (struct handlers) {.badge = badge, .callback_handler = callback_handler, .cookie = cookie, .name = name}; |
| num_handlers++; |
| return 0; |
| } |
| |
| |
| /*- if configuration[me.name].get("enable_tracing", 0) == 1 -*/ |
| #define NUM_TRACES /*? configuration[me.name].get("number_tracepoints", 10) ?*/ |
| |
| #define START_INDEX 0 |
| #define SUM_INDEX 1 |
| #define COUNT_INDEX 2 |
| |
| uint64_t trace_points[NUM_TRACES][3]; |
| |
| #define TRACE_START(num) do { \ |
| if (num < NUM_TRACES) { \ |
| ccnt_t val; \ |
| SEL4BENCH_READ_CCNT(val); \ |
| trace_points[num][START_INDEX] = val; \ |
| } \ |
| } while (0) |
| |
| #define TRACE_END_COUNT(num, count) do { \ |
| if (num < NUM_TRACES) { \ |
| ccnt_t val; \ |
| SEL4BENCH_READ_CCNT(val); \ |
| trace_points[num][SUM_INDEX] += val - trace_points[num][START_INDEX]; \ |
| trace_points[num][COUNT_INDEX] += count; \ |
| } \ |
| } while (0) |
| |
| #define TRACE_END(num) TRACE_END_COUNT(num, 1) |
| |
| |
| void trace_start(void *_arg) { |
| for (int i = 0; i < NUM_TRACES; i++) { |
| trace_points[i][SUM_INDEX] = 0; |
| trace_points[i][COUNT_INDEX] = 0; |
| } |
| int res = trace_start_reg_callback(trace_start, NULL); |
| if (res) { |
| ZF_LOGE("Failed to register trace callback"); |
| } |
| |
| } |
| |
| void trace_stop(void *_arg) { |
| printf("traces:%s\n", get_instance_name()); |
| for (int i = 0; i < MIN(NUM_TRACES, num_handlers+3); i++) { |
| if (i == 0) { |
| printf("total_endpoint_calls,"); |
| } else if (i == 1) { |
| printf("total_notifications,"); |
| } else if (i == 2) { |
| printf("irq_handlers,"); |
| } else if(i >= 3 && reg_handlers[i-3].name) { |
| printf("%s,", reg_handlers[i-3].name); |
| } else { |
| break; |
| } |
| printf("%ld\ncycles,%ld\n", trace_points[i][COUNT_INDEX], trace_points[i][SUM_INDEX]); |
| } |
| int res = trace_stop_reg_callback(trace_stop, NULL); |
| if (res) { |
| ZF_LOGE("Failed to register trace callback"); |
| } |
| |
| } |
| |
| /*- else -*/ |
| #define TRACE_START(num) |
| #define TRACE_END(num) |
| #define TRACE_END_COUNT(num, count) |
| void trace_start(void *_arg) {} |
| void trace_stop(void *_arg) {} |
| |
| /*- endif -*/ |
| |
| |
| seL4_CPtr signal_to_send = 0; |
| |
| int run(void) { |
| int res = trace_start_reg_callback ? trace_start_reg_callback(trace_start, NULL): 0; |
| if (res) { |
| ZF_LOGE("Failed to register trace callback"); |
| } |
| res = trace_stop_reg_callback ? trace_stop_reg_callback(trace_stop, NULL): 0; |
| if (res) { |
| ZF_LOGE("Failed to register trace callback"); |
| } |
| |
| /* Now poll for events and handle them */ |
| seL4_Word badge; |
| seL4_Word notification_base = /*? configuration[me.name].get("global_endpoint_base", 1) ?*/; |
| seL4_Word endpoint_base = /*? configuration[me.name].get("global_rpc_endpoint_base", 0) ?*/; |
| if (notification_base == endpoint_base) { |
| ZF_LOGE("Notification and Endpoint badge values share the same base bitfield.\n" |
| "This means that they cannot be distinguished from each other.\n" |
| "This may result in instability."); |
| } |
| seL4_TCB_BindNotification(camkes_get_tls()->tcb_cap, /*? notification ?*/); |
| /*- if not options.realtime -*/ |
| camkes_get_tls()->cnode_cap = /*? cnode ?*/; |
| /*- endif -*/ |
| seL4_MessageInfo_t info = /*? generate_seL4_Recv(options, endpoint, |
| '&badge', |
| reply_cap_slot) ?*/; |
| while (1) { |
| |
| if ((badge & endpoint_base) == endpoint_base) { |
| int result = 0; |
| TRACE_START(0); |
| switch (badge) { |
| #define X(b) \ |
| case (b): |
| /*- for conn in composition.connections -*/ |
| /*- if conn.type.get_attribute("to_global_rpc_endpoint") and conn.type.get_attribute("to_global_rpc_endpoint").default and conn.to_ends[0].instance == me -*/ |
| |
| /*? conn.to_end.interface.name ?*/_BADGES_MACRO_X_ITERATOR() |
| /*- if not options.realtime -*/ |
| /*# We need to save the reply cap because the user's implementation may |
| * perform operations that overwrite or discard it. |
| #*/ |
| camkes_declare_reply_cap(/*? reply_cap_slot ?*/); |
| /*- endif -*/ |
| |
| result = /*? conn.to_end.interface.name ?*/_handle_message(&info, badge); |
| break; |
| /*- endif -*/ |
| /*- endfor -*/ |
| #undef X |
| default: |
| // Fall through below |
| result = -1; |
| } |
| |
| if (result == 1) { |
| TRACE_END(0); |
| /* Send the response */ |
| /*-- if not options.realtime -*/ |
| camkes_tls_t * tls = camkes_get_tls(); |
| assert(tls != NULL); |
| if (tls->reply_cap_in_tcb) { |
| tls->reply_cap_in_tcb = false; |
| info = /*? generate_seL4_ReplyRecv(options, endpoint, |
| 'info', |
| '&badge', |
| reply_cap_slot) ?*/; |
| } else { |
| camkes_unprotect_reply_cap(); |
| seL4_Send(/*? reply_cap_slot ?*/, info); |
| info = /*? generate_seL4_Recv(options, endpoint, |
| '&badge', |
| reply_cap_slot) ?*/; |
| } |
| /*-- else -*/ |
| info = /*? generate_seL4_ReplyRecv(options, endpoint, |
| 'info', |
| '&badge', |
| reply_cap_slot) ?*/; |
| /*-- endif -*/ |
| continue; |
| } else if (result == 0) { |
| TRACE_END(0); |
| /* Don't reply to the caller */ |
| info = /*? generate_seL4_Recv(options, endpoint, |
| '&badge', |
| reply_cap_slot) ?*/; |
| continue; |
| } else { |
| TRACE_END(0); |
| } |
| |
| } |
| TRACE_START(1); |
| if ((badge & notification_base) == notification_base) { |
| TRACE_START(2); |
| int UNUSED num_handlers_called = camkes_handle_global_endpoint_irq(badge); |
| TRACE_END_COUNT(2, num_handlers_called); |
| for (int i = 0; i < num_handlers; i++) { |
| seL4_Word b = reg_handlers[i].badge; |
| if ((badge & b) == b) { |
| TRACE_START(i + 3); |
| reg_handlers[i].callback_handler(b, reg_handlers[i].cookie); |
| TRACE_END(i + 3); |
| } |
| } |
| } |
| TRACE_END(1); |
| if (signal_to_send) { |
| /*? generate_seL4_SignalRecv(options, 'info', 'signal_to_send', 'info', endpoint, '&badge', reply_cap_slot) ?*/; |
| signal_to_send = 0; |
| } else { |
| |
| info = /*? generate_seL4_Recv(options, endpoint, |
| '&badge', |
| reply_cap_slot) ?*/; |
| |
| } |
| |
| } |
| |
| } |
