libsel4camkes,dma: Support different cache attribs

Support registering DMA memory that is both cached and uncached and then
return memory with correct cache attributes when alloc is called.

trivial: fix style

component.common.c: Use correct label for dma pool

The default label is calculated assuming that the context is a
connection end. When calling register_shared_variable from a component
context then the label needs to be provided.

trivial: Fix incorrect name lookup

The effect of this were some objects being named None in the capdl spec.

trivial: Fix aarch64 compile warnings

These variables should already be intialized to zero.

component.common.c: Support additional DMA setting

Allow setting the cache and base paddr value of the DMA pool.

The base paddr value is necessary as some devices can't access memory
located at certain addresses.

component.common.c: Move init() to C constructor

Connectors that don't use threads use runtime constructors for their
initialization. This function previously was called immediately after
the runtime constructors were. Now it is called earlier with a higher
runtime constructor priority than other connectors.

templates: recognize tcb_pool_domains option

Assign domain IDs for TCBs in the thread pool based on values provided
by the config option array values.

eg:
receiver.tcb_pool = 2;
receiver.tcb_pool_domains = [1, 1];

templates: Correctly support TCB pool allocations

Set `resume` attribute on TCB object to false so that the loader leaves
the TCB object suspended. Also correct arguments to camkes_provide so
that the TCB object can be correctly registered with the allocator.

templates: Fixes related to passive threads

Line 428: Missing a ``not''
Line 536: Changed to a more meaningful variable name
Line 818: Fixed the inconsistent format of thread names

component.common.c: Add missing sc_control def

This definition was removed in an earlier commit during code refactor.

templates: add missing return statement

component.common.c: Don't call exit() from threads

When any camkes threads finish executing they call exit(). This is not
the right approach as even if the threads themselves are finished the
intention isn't to exit the process. Instead get the threads to block on
their initialisation semaphores so they become inactive.

Update FrameFill declarations to match new api

FrameFills in the capDL spec have been updated to always require
destination_offset and size parameters before the FrameFill subtype
specific parameters.

mcs: Rename CONFIG_KERNEL_RT to CONFIG_KERNEL_MCS

This is to be consistent with the name defined in the kernel.

templates: Fix DTB passthrough template code

Previously, this functionality was only tested on the CAmkES VM projects
and while it worked there, it did not work on the normal CAmkES
applications. This commit fixes the functionality to make it work with
the normal CAmkES applications.

camkes-tool: explicitly include gen_config.h

explicitly include gen_config.h since there is going to be
no more global configuration lib

templates: Use ROUND_UP for calculating DTB size

Previously, we used next_page_multiple, but this had a tendency to
allocate more pages than needed. We change this instead of that macro
because it's still needed to keep register mappings aligned.

camkes/templates: remove unused TLS region

This region was used for TLS before actual TLS became available. It is
no longer required.

camkes/templates: provide initial static tls regions

This allows components to have multiple threads without needing a heap.

Exit, don't exit the runtime

Camkes threads should use their own exit, rather than the runtimes, as
camkes threads don't expect the whole process to be killed on exit.

Use new TLS and sel4runtime support

- minimal crt0.S: construct environment in start.c and via the runtime
- update tls init to be compatible with runtime and move initialisation
to after the runtime is initialised
- wait runtime to be initialised in fault handlers

component.common.c: move tcb_control definition

This needs to be used earlier in the file on a future commit.

component.common.c: more thread naming

This prepares for a change where thread naming must be done after
TLS is set up, as prior to TLS initialisation the thread does have
access to its IPC buffer and therefore cannot set its name.

templates: move function definition

This needs to be used earlier in the file

templates: Copy the DTB to a CAmkES managed buffer

Using the new register_fill_frames function, we ask the loader to copy
the DTB that's exposed by the kernel into a buffer. This buffer is
intended to be exposed to userland via libsel4camkes.

templates: Remove camkes_io_port functions

libsel4camkes no longer call the IO port functions in the CAmkES common
component.

templates: Update DMA init call in common template

This commit updates the common component template to call the DMA init
function properly.

libsel4camkes: Move DMA paddr and cptr functions

This commit moves the dma_get_paddr() and get_cptr() functions from the
CAmkES common template over to libsel4camkes. The new functions in
libsel4camkes iterate over the exposed DMA frames. A new helper function
has also been added. This function just returns the size of the pages
that are backing the DMA pool.

templates: Expose the frames backing the DMA pool

This commit exposes the DMA frames that are backing the DMA pool into a
section in an ELF file.

libsel4camkes: Move io map func into libsel4camkes

Instead of relying on the dataport paddr translation functions in the
dataport related connector templates, we use the exposed dataport frame
structures instead. Thus, this allows us to move this functionality away
from the CAmkES templates and into a shared library.

Call capdl_linker for final capdl spec generation

The Camkes tool is invoked in 3 or 4 phases (the extra last phase is for
integity refinement and is currently optional). The first 2 phases,
parsing the AST and then generating all of the templates are both very
camkes specific. The 3rd phase takes the ELF files for all components
and a record of all objects and caps currently allocated
(AllocatorState) and generates a capdl spec after constructing paging
objects described by the ELF files. This is pretty generic and is also
performed by non-camkes capDL projects, such as the tutorials. Using
capdl_linker.py allows more capdl internals to be transparent to the
camkes runner and reduces its complexity while also allowing the
functionality to be used in other non-camkes applications.

templates: Fix camkes_io_map logic

The last comparator should be '>' and not '>=', we want to find a region
with a paddr greater than the desired one and not one whose paddr and
size equals the desired paddr.

cmake: Move config definitions to correct location

Define ones that are passed to the camkes tool in camkes.cmake and
define the ones that are used in autoconf.h in libsel4camkes. This is to
reduce the chances of the camkes tool handling a config option
differently from the code if it is present as both a cmdline option and
as an autoconfig.h variable.

templates: Allow camkes_io_map to find resources from seL4DTBHardware

Filters: Set scheduling properties in templates

These properties can be set when the objects are created.

Filters: Remove two more filters

- set_tcb_caps: This filter sets a thread's VSpace and CSpace caps and
sets a threads CNode size based on a config value or how many slots have
been allocated.
- guard_cnode_caps: Sets the correct guard value on any Caps to CNodes.

As the CNode object supports updating Caps that have been registered to
it whenever finalise_size() is called on it, we can call this when
finalising the total spec, and the TCB caps can be set in the template
when the TCB is created.

Filters: Remove set_tcb_info filter

This filter set the following properties on a TCB:
- elf: the name of the ELF file describing the threads address space
- ip: The program counter of the thread when it is started
- sp: The stack pointer of the thread when it is started
- addr: The address of the IPC buffer for the thread
- init: An array of arguments that are given to the thread.
- sc_slot: A cap to the scheduling context of the thread if it is not
'passive'

These properties are all mostly known when the TCB objects are created
in the templates and we don't need to set them in a filter. The only
special cases are the ip, sp, and addr values that need to be set based
on the virtual address of the symbol in the ELF file. We use simpleeval
to allow the template to save a query that calculates an offset of a
virtual address corresponding to a symbol name so that the values can be
easily calculated once the ELF files are built, but the policy for what
offset into the symbol (e.g. to allow for page guards) can still be
controlled by the template. This mechanism is not Camkes specific and
could be moved into the python-capdl-tool library at a future date.

templates: Refactor TCB creation for components

Create thread stacks, ipc buffers, scheduling contexts, and properties
in one place. Previously having this allocation occuring within a switch
statement made it very hard to understand and maintain.

Now macros.threads() returns an array of all the threads for a component
containing properties for each thread:
- name: The name used for creating objects
- interface: If the thread is an interface thread, what interface it is
for
- intra_index: Index of the thread within an interface that has more
than one thread. 0 if not an interface thread.
- stack_symbol: Name of the stack for this thread
- stack_size: Size of the stack
- ipc_symbol: Name of the ipc buffer symbol for this thread.

The template can then create resources for each thread based on the
contents of this array.

camkes_version: Remove camkes_release symbol

This symbol is statically initialised to a hash of all camkes sources.
It is being removed as it no longer refers to the actual camkes version,
and there isn't a strong need to read the version from every component.

templates: don't request cap rights for object types that don't have them

ps_io_map: Require mappings to be 4KiB aligned.

This should make it easier to catch mistakes.

templates: Don't use c_symbol for private symbols

Many uses of c_symbol are no longer needed due to historical
refactorings. Removing them should improve readability and rendering
performance.

Remove --fsupport-init flag support

This flag was mostly redundant as it is used by default and there are
no longer any motivating uses for not providing init support.

templates: update grant to grantreply on endpoints

Endpoints no longer require grant to generate reply caps on call. Add
the new reduced right 'grantreply'.

templates: remove redundant grant=False

Cap rights default to False

Change Camkes alignment and section linking policy

There are now special sections created by the Camkes linker script that
are aligned to each of the architecture page sizes. Symbols that require
a certain alignment in order to be backed by an underlying seL4 frame of
a certain size should declare to be in the section of that size. The
purpose of this is to drastically simplify the linking policy shared
between Camkes and the capdl python scripts that would create the
address space objects.

The linker script requirement is because a compiler/assembler is not required to
respect the `align` attribute above a certain small size and any
alignment requirements on the order of page sizes needs to be specified
by a linker script.

These changes make it possible to remove some architecture special cases
that exist in Camkes templates, which is why they are removed.

It is assumed that any of the special policy associated with the special
section names: guarded, shared_*, ignore_* and persistent can still be
implemented by using the new section name with the same alignment, eg
align_12bit for all symbols that require 4k guard pages.

Use AddressSpaceAllocator for dma_pools

This removes the need for the replace_dma_frames filter. We also remove
the symbol rename in the objcopy phase as the symbol is private and
won't collide with anything else. This also means
we can remove the dma_pool_symbol entry from the filter NameMangling
list.

Use AddressSpaceAllocator for creating guard pages

Stacks and ipc buffers have guard pages that were implemented by running
a filter over the address space objects and deleting the frame before
and after the address regions. This way uses the AddressSpaceAllocator
to explicitly create the guarded sections when the C symbols are
defined. This remove the need for the more complex filter.

camkes: Pass default-stack-size through camkes

This makes it possible for camkes to know the default stack size without
having to build the component into an ELF file.

Fix type error for notification_pools

Move component init interfaces to libsel4camkes

These functions are constant and will always be defined by all components and so there is need
for them to be templated. Removing them specifically from the component header also removes the
implication that they should be called by component code when they are intended for internal use
by CAmkES only.

Finally putting these definitions in a library allows them to be used by other library code in
the future, as libraries cannot include per component templates.

Add missing returns values

These functions should return 0 on success, and if they reach the end without returning
early then they have succeeded.

Refactor component.template.c into multiple files

Prepares the way for supporting different environments by moving the C specific environment
code into a separate file.