580 lines
17 KiB
Plaintext
580 lines
17 KiB
Plaintext
# Kconfig - kernel configuration options
|
|
|
|
#
|
|
# Copyright (c) 2014-2015 Wind River Systems, Inc.
|
|
#
|
|
# SPDX-License-Identifier: Apache-2.0
|
|
#
|
|
|
|
|
|
menu "General Kernel Options"
|
|
|
|
config HAS_DTS
|
|
bool "Uses Device Tree"
|
|
help
|
|
This option specifies that the target platform supports device tree
|
|
configuration.
|
|
|
|
config MULTITHREADING
|
|
bool
|
|
prompt "Multi-threading"
|
|
default y
|
|
help
|
|
If disabled, only the main thread is available, so a main() function
|
|
must be provided. Interrupts are available. Kernel objects will most
|
|
probably not behave as expected, especially with regards to pending,
|
|
since the main thread cannot pend, it being the only thread in the
|
|
system.
|
|
|
|
Many drivers and subsystems will not work with this option; use only
|
|
when you REALLY know what you are doing.
|
|
|
|
config NUM_COOP_PRIORITIES
|
|
int
|
|
prompt "Number of coop priorities" if MULTITHREADING
|
|
default 16
|
|
default 1 if !MULTITHREADING
|
|
range 0 128
|
|
help
|
|
Number of cooperative priorities configured in the system. Gives access
|
|
to priorities:
|
|
|
|
K_PRIO_COOP(0) to K_PRIO_COOP(CONFIG_NUM_COOP_PRIORITIES - 1)
|
|
|
|
or seen another way, priorities:
|
|
|
|
-CONFIG_NUM_COOP_PRIORITIES to -1
|
|
|
|
This can be set to zero to disable cooperative scheduling. Cooperative
|
|
threads always preempt preemptible threads.
|
|
|
|
Each priority requires an extra 8 bytes of RAM. Each set of 32 extra
|
|
total priorities require an extra 4 bytes and add one possible
|
|
iteration to loops that search for the next thread to run.
|
|
|
|
The total number of priorities is
|
|
|
|
NUM_COOP_PRIORITIES + NUM_PREEMPT_PRIORITIES + 1
|
|
|
|
The extra one is for the idle thread, which must run at the lowest
|
|
priority, and be the only thread at that priority.
|
|
|
|
config NUM_PREEMPT_PRIORITIES
|
|
int
|
|
prompt "Number of preemptible priorities" if MULTITHREADING
|
|
default 15
|
|
default 0 if !MULTITHREADING
|
|
range 0 128
|
|
help
|
|
Number of preemptible priorities available in the system. Gives access
|
|
to priorities 0 to CONFIG_NUM_PREEMPT_PRIORITIES - 1.
|
|
|
|
This can be set to 0 to disable preemptible scheduling.
|
|
|
|
Each priority requires an extra 8 bytes of RAM. Each set of 32 extra
|
|
total priorities require an extra 4 bytes and add one possible
|
|
iteration to loops that search for the next thread to run.
|
|
|
|
The total number of priorities is
|
|
|
|
NUM_COOP_PRIORITIES + NUM_PREEMPT_PRIORITIES + 1
|
|
|
|
The extra one is for the idle thread, which must run at the lowest
|
|
priority, and be the only thread at that priority.
|
|
|
|
config MAIN_THREAD_PRIORITY
|
|
int
|
|
prompt "Priority of initialization/main thread"
|
|
default 0
|
|
default -2 if !PREEMPT_ENABLED
|
|
help
|
|
Priority at which the initialization thread runs, including the start
|
|
of the main() function. main() can then change its priority if desired.
|
|
|
|
config COOP_ENABLED
|
|
bool
|
|
default y
|
|
default n if (NUM_COOP_PRIORITIES = 0)
|
|
|
|
config PREEMPT_ENABLED
|
|
bool
|
|
default y
|
|
default n if (NUM_PREEMPT_PRIORITIES = 0)
|
|
|
|
config PRIORITY_CEILING
|
|
int
|
|
prompt "Priority inheritance ceiling"
|
|
default 0
|
|
|
|
config MAIN_STACK_SIZE
|
|
int
|
|
prompt "Size of stack for initialization and main thread"
|
|
default 1024
|
|
help
|
|
When the intitialization is complete, the thread executing it then
|
|
executes the main() routine, so as to reuse the stack used by the
|
|
initialization, which would be wasted RAM otherwise.
|
|
|
|
After initialization is complete, the thread runs main().
|
|
|
|
config IDLE_STACK_SIZE
|
|
int
|
|
prompt "Size of stack for idle thread"
|
|
default 256
|
|
default 320 if ARC
|
|
default 512 if RISCV32
|
|
default 1024 if XTENSA
|
|
help
|
|
Depending on the work that the idle task must do, most likely due to
|
|
power management but possibly to other features like system event
|
|
logging (e.g. logging when the system goes to sleep), the idle thread
|
|
may need more stack space than the default value.
|
|
|
|
config ISR_STACK_SIZE
|
|
int
|
|
prompt "ISR and initialization stack size (in bytes)"
|
|
default 2048
|
|
help
|
|
This option specifies the size of the stack used by interrupt
|
|
service routines (ISRs), and during kernel initialization.
|
|
|
|
config THREAD_CUSTOM_DATA
|
|
bool
|
|
prompt "Thread custom data"
|
|
default n
|
|
help
|
|
This option allows each thread to store 32 bits of custom data,
|
|
which can be accessed using the k_thread_custom_data_xxx() APIs.
|
|
|
|
config NUM_DYNAMIC_TIMERS
|
|
int
|
|
prompt "Number of timers available for dynamic allocation"
|
|
default 0
|
|
depends on NANO_TIMERS
|
|
help
|
|
Number of timers available for dynamic allocation via the
|
|
k_timer_alloc()/k_timer_free() API.
|
|
|
|
config ERRNO
|
|
bool
|
|
prompt "Enable errno support"
|
|
default y
|
|
help
|
|
Enable per-thread errno in the kernel. Application and library code must
|
|
include errno.h provided by the C library (libc) to use the errno
|
|
symbol. The C library must access the per-thread errno via the
|
|
_get_errno() symbol.
|
|
|
|
menu "Kernel Debugging and Metrics"
|
|
config KERNEL_DEBUG
|
|
bool
|
|
prompt "Kernel debugging"
|
|
default n
|
|
select INIT_STACKS
|
|
help
|
|
Enable kernel debugging.
|
|
|
|
Note that debugging the kernel internals can be very verbose.
|
|
|
|
config BOOT_BANNER
|
|
bool
|
|
prompt "Boot banner"
|
|
default n
|
|
depends on CONSOLE_HAS_DRIVER
|
|
select PRINTK
|
|
select EARLY_CONSOLE
|
|
help
|
|
This option outputs a banner to the console device during boot up. It
|
|
also embeds a date & time stamp in the kernel and in each USAP image.
|
|
|
|
config BUILD_TIMESTAMP
|
|
bool
|
|
prompt "Build Timestamp"
|
|
help
|
|
Build timestamp and add it to the boot banner.
|
|
|
|
config INT_LATENCY_BENCHMARK
|
|
bool
|
|
prompt "Interrupt latency metrics [EXPERIMENTAL]"
|
|
default n
|
|
depends on ARCH="x86"
|
|
help
|
|
This option enables the tracking of interrupt latency metrics;
|
|
the exact set of metrics being tracked is board-dependent.
|
|
Tracking begins when int_latency_init() is invoked by an application.
|
|
The metrics are displayed (and a new sampling interval is started)
|
|
each time int_latency_show() is called thereafter.
|
|
|
|
config THREAD_MONITOR
|
|
bool
|
|
prompt "Thread monitoring [EXPERIMENTAL]"
|
|
default n
|
|
help
|
|
This option instructs the kernel to maintain a list of all threads
|
|
(excluding those that have not yet started or have already
|
|
terminated).
|
|
endmenu
|
|
|
|
menu "Work Queue Options"
|
|
config SYSTEM_WORKQUEUE_STACK_SIZE
|
|
int "System workqueue stack size"
|
|
default 1024
|
|
|
|
config SYSTEM_WORKQUEUE_PRIORITY
|
|
int "System workqueue priority"
|
|
default -1
|
|
default 0 if !COOP_ENABLED
|
|
default -2 if COOP_ENABLED && !PREEMPT_ENABLED
|
|
|
|
config OFFLOAD_WORKQUEUE_STACK_SIZE
|
|
int "Workqueue stack size for thread offload requests"
|
|
default 1024
|
|
|
|
config OFFLOAD_WORKQUEUE_PRIORITY
|
|
int "Offload requests workqueue priority"
|
|
default -1
|
|
|
|
endmenu
|
|
|
|
menu "Atomic Operations"
|
|
config ATOMIC_OPERATIONS_BUILTIN
|
|
bool
|
|
help
|
|
Use the compiler builtin functions for atomic operations. This is
|
|
the preferred method. However, support for all arches in GCC is
|
|
incomplete.
|
|
|
|
config ATOMIC_OPERATIONS_CUSTOM
|
|
bool
|
|
help
|
|
Use when there isn't support for compiler built-ins, but you have
|
|
written optimized assembly code under arch/ which implements these.
|
|
|
|
config ATOMIC_OPERATIONS_C
|
|
bool
|
|
help
|
|
Use atomic operations routines that are implemented entirely
|
|
in C by locking interrupts. Selected by architectures which either
|
|
do not have support for atomic operations in their instruction
|
|
set, or haven't been implemented yet during bring-up, and also
|
|
the compiler does not have support for the atomic __sync_* builtins.
|
|
endmenu
|
|
|
|
menu "Timer API Options"
|
|
|
|
config TIMESLICING
|
|
bool "Thread time slicing"
|
|
default y
|
|
depends on SYS_CLOCK_EXISTS && (NUM_PREEMPT_PRIORITIES != 0)
|
|
help
|
|
This option enables time slicing between preemptible threads of
|
|
equal priority.
|
|
|
|
config TIMESLICE_SIZE
|
|
int "Time slice size (in ms)"
|
|
default 0
|
|
range 0 2147483647
|
|
depends on TIMESLICING
|
|
help
|
|
This option specifies the maximum amount of time a thread can execute
|
|
before other threads of equal priority are given an opportunity to run.
|
|
A time slice size of zero means "no limit" (i.e. an infinitely large
|
|
time slice).
|
|
|
|
config TIMESLICE_PRIORITY
|
|
int "Time slicing thread priority ceiling"
|
|
default 0
|
|
range 0 NUM_PREEMPT_PRIORITIES
|
|
depends on TIMESLICING
|
|
help
|
|
This option specifies the thread priority level at which time slicing
|
|
takes effect; threads having a higher priority than this ceiling are
|
|
not subject to time slicing.
|
|
|
|
config POLL
|
|
bool
|
|
prompt "async I/O framework"
|
|
default n
|
|
help
|
|
Asynchronous notification framework. Enable the k_poll() and
|
|
k_poll_signal() APIs. The former can wait on multiple events
|
|
concurrently, which can be either directly triggered or triggered by
|
|
the availability of some kernel objects (semaphores and fifos).
|
|
|
|
endmenu
|
|
|
|
menu "Other Kernel Object Options"
|
|
|
|
config SEMAPHORE_GROUPS
|
|
bool "Enable semaphore groups"
|
|
default y if LEGACY_KERNEL
|
|
help
|
|
This option enables support for semaphore groups. Threads that use
|
|
semaphore groups require more stack space. Disabling this option will
|
|
both decrease the footprint as well as improve the performance of
|
|
the k_sem_give() routine.
|
|
|
|
config NUM_MBOX_ASYNC_MSGS
|
|
int "Maximum number of in-flight asynchronous mailbox messages"
|
|
default 10
|
|
help
|
|
This option specifies the total number of asynchronous mailbox
|
|
messages that can exist simultaneously, across all mailboxes
|
|
in the system.
|
|
|
|
Setting this option to 0 disables support for asynchronous
|
|
mailbox messages.
|
|
|
|
config NUM_PIPE_ASYNC_MSGS
|
|
int "Maximum number of in-flight asynchronous pipe messages"
|
|
default 10
|
|
help
|
|
This option specifies the total number of asynchronous pipe
|
|
messages that can exist simultaneously, across all pipes in
|
|
the system.
|
|
|
|
Setting this option to 0 disables support for asynchronous
|
|
pipe messages.
|
|
endmenu
|
|
|
|
menu "Memory Pool Options"
|
|
choice
|
|
prompt "Memory pool block allocation policy"
|
|
default MEM_POOL_SPLIT_BEFORE_DEFRAG
|
|
help
|
|
This option specifies how a memory pool reacts if an unused memory
|
|
block of the required size is not available.
|
|
|
|
config MEM_POOL_SPLIT_BEFORE_DEFRAG
|
|
bool "Split a larger block before merging smaller blocks"
|
|
help
|
|
This option instructs a memory pool to try splitting a larger unused
|
|
block if an unused block of the required size is not available; only
|
|
if no such blocks exist will the memory pool try merging smaller unused
|
|
blocks. This policy attempts to limit the cost of performing automatic
|
|
partial defragmention of the memory pool, at the cost of fragmenting
|
|
the memory pool's larger blocks.
|
|
|
|
config MEM_POOL_DEFRAG_BEFORE_SPLIT
|
|
bool "Merge smaller blocks before splitting a larger block"
|
|
help
|
|
This option instructs a memory pool to try merging smaller unused
|
|
blocks if an unused block of the required size is not available; only
|
|
if this does not generate a sufficiently large block will the memory
|
|
pool try splitting a larger unused block. This policy attempts to
|
|
preserve the memory pool's larger blocks, at the cost of performing
|
|
automatic partial defragmentations more frequently.
|
|
|
|
config MEM_POOL_SPLIT_ONLY
|
|
bool "Split a larger block, but never merge smaller blocks"
|
|
help
|
|
This option instructs a memory pool to try splitting a larger unused
|
|
block if an unused block of the required size is not available; if no
|
|
such blocks exist the block allocation operation fails. This policy
|
|
attempts to limit the cost of defragmenting the memory pool by avoiding
|
|
automatic partial defragmentation, at the cost of requiring the
|
|
application to explicitly request a full defragmentation of the memory
|
|
pool when an allocation fails. Depending on how a memory pool is used,
|
|
it may be more efficient for a memory pool to perform an occasional
|
|
full defragmentation than to perform frequent partial defragmentations.
|
|
|
|
endchoice
|
|
|
|
config HEAP_MEM_POOL_SIZE
|
|
int
|
|
prompt "Heap memory pool size (in bytes)"
|
|
default 0
|
|
help
|
|
This option specifies the size of the heap memory pool used when
|
|
dynamically allocating memory using k_malloc(). Supported values
|
|
are: 256, 1024, 4096, and 16384. A size of zero means that no
|
|
heap memory pool is defined.
|
|
endmenu
|
|
|
|
|
|
config ARCH_HAS_CUSTOM_SWAP_TO_MAIN
|
|
bool
|
|
# hidden
|
|
default n
|
|
help
|
|
It's possible that an architecture port cannot use _Swap() to swap to
|
|
the _main() thread, but instead must do something custom. It must
|
|
enable this option in that case.
|
|
|
|
config SYS_CLOCK_TICKS_PER_SEC
|
|
int
|
|
prompt "System tick frequency (in ticks/second)"
|
|
default 100
|
|
help
|
|
This option specifies the frequency of the system clock in Hz.
|
|
|
|
Depending on the choice made, an amount of possibly expensive math must
|
|
occur when converting ticks to milliseconds and vice-versa. Some values
|
|
are optimized, and yield significantly less math.
|
|
|
|
The optimal values from a computational point-of-view are 1000, 500,
|
|
250 and 125, since in these cases there is either no computation
|
|
required, or it is all done via bit-shifting. These also give a
|
|
granularity from 1ms to 8ms.
|
|
|
|
Other good values are 100, 50, 25, 20 and 10. In this case, some math
|
|
is required but is minimized. These are also values that necessitate a
|
|
reduced number of clock interrupts per second, at the cost of
|
|
granularity (10ms to 100ms).
|
|
|
|
All other values require some extensive 64-bit math, and in some
|
|
configurations even require calls to compiler built-in functions, and
|
|
can require a non-trivial extra amount of stack space (e.g. around 80
|
|
bytes on x86).
|
|
|
|
Using the legacy API also incurs an extra penalty, since when asking
|
|
for a timeout, a translation is made from ticks to milliseconds to call
|
|
the native kernel APIs, and then another translation is made back to
|
|
ticks, since the kernel is tick-based.
|
|
|
|
config SYS_CLOCK_HW_CYCLES_PER_SEC
|
|
int "System clock's h/w timer frequency"
|
|
help
|
|
This option specifies the frequency of the hardware timer used for the
|
|
system clock (in Hz). This option is set by the board's Kconfig file
|
|
and the user should generally avoid modifying it via the menu configuration.
|
|
|
|
config SYS_CLOCK_EXISTS
|
|
bool
|
|
# omit prompt to signify a "hidden" option
|
|
default y
|
|
default n if (SYS_CLOCK_TICKS_PER_SEC = 0)
|
|
help
|
|
This option specifies that the kernel lacks timer support.
|
|
|
|
config INIT_STACKS
|
|
bool
|
|
prompt "Initialize stack areas"
|
|
default n
|
|
help
|
|
This option instructs the kernel to initialize stack areas with a
|
|
known value (0xaa) before they are first used, so that the high
|
|
water mark can be easily determined. This applies to the stack areas
|
|
for threads.
|
|
|
|
config XIP
|
|
bool
|
|
prompt "Execute in place"
|
|
help
|
|
This option allows the kernel to operate with its text and read-only
|
|
sections residing in ROM (or similar read-only memory). Not all boards
|
|
support this option so it must be used with care; you must also
|
|
supply a linker command file when building your image. Enabling this
|
|
option increases both the code and data footprint of the image.
|
|
|
|
config RING_BUFFER
|
|
bool
|
|
prompt "Enable ring buffers"
|
|
default n
|
|
help
|
|
Enable usage of ring buffers. This is similar to kernel FIFOs but ring
|
|
buffers manage their own buffer memory and can store arbitrary data.
|
|
For optimal performance, use buffer sizes that are a power of 2.
|
|
|
|
menu "Initialization Priorities"
|
|
|
|
config KERNEL_INIT_PRIORITY_OBJECTS
|
|
int
|
|
prompt "Kernel objects initialization priority"
|
|
default 30
|
|
help
|
|
Kernel objects use this priority for initialization. This
|
|
priority needs to be higher than minimal default initialization
|
|
priority.
|
|
|
|
config KERNEL_INIT_PRIORITY_DEFAULT
|
|
int
|
|
prompt "Default init priority"
|
|
default 40
|
|
help
|
|
Defaut minimal init priority for each init level.
|
|
|
|
config KERNEL_INIT_PRIORITY_DEVICE
|
|
int
|
|
prompt "Default init priority for device drivers"
|
|
default 50
|
|
help
|
|
Device driver, that depends on common components, such as
|
|
interrupt controller, but does not depend on other devices,
|
|
uses this init priority.
|
|
|
|
config APPLICATION_INIT_PRIORITY
|
|
int
|
|
prompt "Default init priority for application level drivers"
|
|
default 90
|
|
help
|
|
This priority level is for end-user drivers such as sensors and display
|
|
which have no inward dependencies.
|
|
endmenu
|
|
|
|
menu "Security Options"
|
|
|
|
config STACK_CANARIES
|
|
bool
|
|
prompt "Compiler stack canaries"
|
|
default n
|
|
help
|
|
This option enables compiler stack canaries support kernel functions.
|
|
|
|
If stack canaries are supported by the compiler, it will emit
|
|
extra code that inserts a canary value into the stack frame when
|
|
a function is entered and validates this value upon exit.
|
|
Stack corruption (such as that caused by buffer overflow) results
|
|
in a fatal error condition for the running entity.
|
|
Enabling this option can result in a significant increase
|
|
in footprint and an associated decrease in performance.
|
|
|
|
If stack canaries are not supported by the compiler, enabling this
|
|
option has no effect.
|
|
endmenu
|
|
|
|
menu "Legacy Kernel Options"
|
|
|
|
config LEGACY_KERNEL
|
|
bool "Legacy Kernel Options"
|
|
default y
|
|
help
|
|
Enable legacy kernel features.
|
|
|
|
config MDEF
|
|
bool
|
|
prompt "Use MDEF files for statically configured kernel objects"
|
|
default y if LEGACY_KERNEL
|
|
help
|
|
Using an MDEF file can help the startup time of the application since
|
|
the objects it lists are statically allocated and initialized, and may
|
|
also reduce code size if no subsystem uses the initialization routines.
|
|
|
|
Disabling this option can reduce the compilation time slightly.
|
|
|
|
In doubt, select 'y'.
|
|
|
|
config NANO_TIMEOUTS
|
|
bool
|
|
default y if LEGACY_KERNEL
|
|
depends on SYS_CLOCK_EXISTS
|
|
help
|
|
Only here for common (ie. non-unified kernel) code that rely on this.
|
|
Unified kernel uses SYS_CLOCK_EXISTS everywhere instead.
|
|
|
|
config NANO_TIMERS
|
|
bool
|
|
default y if LEGACY_KERNEL
|
|
depends on SYS_CLOCK_EXISTS
|
|
help
|
|
Only here for common (ie. non-unified kernel) code that rely on this.
|
|
Unified kernel uses SYS_CLOCK_EXISTS everywhere instead.
|
|
|
|
endmenu
|
|
|
|
source "kernel/Kconfig.event_logger"
|
|
|
|
source "kernel/Kconfig.power_mgmt"
|
|
|
|
endmenu
|