Zephyr System Requirements

UID:

VERSION:

CLASSIFICATION:

PREFIX:

ZEP-SYRS-

Type	Level	UID	STATUS	TYPE	COMPONENT	REFS	Title	Statement	USER_STORY
TEXT								SPDX-License-Identifier: Apache-2.0
SECTION	1						Atomic Service
REQUIREMENT	1.1	ZEP-SYRS-26	Draft	Functional	Atomic Service	Children: ZEP-SRS-26-1 Atomic variable ZEP-SRS-26-2 Atomic value ZEP-SRS-26-3 Tearing freedom ZEP-SRS-26-4 Cross-CPU visibility ZEP-SRS-26-5 Indivisibility ZEP-SRS-26-6 Memory ordering ZEP-SRS-26-7 Software implementation fallback ZEP-SRS-26-8 Native atomic instructions ZEP-SRS-26-9 Compute size of atomic variables ZEP-SRS-26-10 Define an array of atomic variables ZEP-SRS-26-11 Initialize atomic variable ZEP-SRS-26-12 Set atomic variable ZEP-SRS-26-13 Get atomic variable ZEP-SRS-26-14 Atomic bitwise operations ZEP-SRS-26-19 Atomic addition ZEP-SRS-26-21 Atomic subtraction ZEP-SRS-26-23 Atomic compare and set ZEP-SRS-26-24 Atomic clear ZEP-SRS-26-25 Atomic bit operations ZEP-SRS-26-32 Atomic pointer ZEP-SRS-26-33 Atomic pointer value ZEP-SRS-26-34 Initialize atomic pointer ZEP-SRS-26-35 Atomic pointer operations ZEP-SRS-26-40 Usable from threads and interrupt service routines	ZEP-SYRS-26 Atomic Service	The Zephyr RTOS shall provide an interface to perform atomic operations on variables, guaranteeing that all reads and writes are free from tearing across all processors.
REQUIREMENT	2	ZEP-SYRS-3	Draft	Functional	C Library	Children: ZEP-SRS-18-1 Formatted output ZEP-SRS-18-2 Floating Point Math Support ZEP-SRS-18-3 Boolean Primitives Support ZEP-SRS-18-4 Standard Unix time interface ZEP-SRS-18-5 Strings support ZEP-SRS-18-6 Moving/copying regions of memory ZEP-SRS-18-7 I/O based interface ZEP-SRS-18-8 C99 integer types ZEP-SRS-18-9 Standard System Error Numbers (IEEE Std 1003.1-2017) ZEP-SRS-18-10 Document set of Zephyr OS required C library functions in Safety Manual ZEP-SRS-18-11 Support external C libraries documentation in Zephyr Safety Manual	ZEP-SYRS-3 Support Subset of Standard C Library	The Zephyr RTOS shall support a subset of the standard C library.	As a Zephyr RTOS user I want to have a selection of standard C library implementations e.g. a full extend and a minimal with a smaller footprint or a particular fast executing implementation.
SECTION	3						Condition Variables
REQUIREMENT	3.1	ZEP-SYRS-21	Draft	Non-Functional	Condition Variables	Children: ZEP-SRS-21-1 Dynamic initialization of condition variables ZEP-SRS-21-2 Static initialization of condition variables ZEP-SRS-21-3 Signal one waiting thread ZEP-SRS-21-4 Signal multiple waiting threads ZEP-SRS-21-5 Wait on a condition variable ZEP-SRS-21-6 Wait timeout on a condition variable ZEP-SRS-21-7 Wait timeout occurence ZEP-SRS-21-8 Release mutex on wait ZEP-SRS-21-9 Unblock a waiting thread	ZEP-SYRS-21 Condition Variables	The Zephyr RTOS shall provide a framework to synchronize threads based on a condition variable.
REQUIREMENT	4	ZEP-SYRS-4	Draft	Functional	Device Drivers	Children: ZEP-SRS-14-1 Device Driver Abstraction ZEP-SRS-14-2 Expose kernel to hardware interrupts	ZEP-SYRS-4 Device Driver Abstraction	The Zephyr RTOS shall provide a framework for managing device drivers and peripherals.	As a Zephyr RTOS user I want my application to be portable between different MCU architectures (ARM Cortex-M/A, Intel x86, RISCV etc.) and MCU vendors (STM, NXP, Intel, etc.) without having to change the MCU peripherals access.
REQUIREMENT	5	ZEP-SYRS-5	Draft	Functional	Exception and Error Handling	Children: ZEP-SRS-16-1 Fatal Exception Error Handler ZEP-SRS-16-2 Default handler for fatal errors ZEP-SRS-16-3 Assigning a specific handler ZEP-SRS-16-4 Assigning a specific handler for a fatal error	ZEP-SYRS-5 Fatal error and exception handling	The Zephyr RTOS shall provide a framework for error and exception handling.	As a Zephyr RTOS user I want errors and exceptions to handled and react according to my applications requirements (e.g. reach/establish the applications safety state).
SECTION	6						Events
REQUIREMENT	6.1	ZEP-SYRS-27	Draft	Functional	Events	Children: ZEP-SRS-27-1 Event object definition at compile time ZEP-SRS-27-2 Event object definition at run time ZEP-SRS-27-3 Number of distinct events ZEP-SRS-27-4 Posting events ZEP-SRS-27-5 Setting events ZEP-SRS-27-6 Setting and clearing events using a mask ZEP-SRS-27-7 Clearing events ZEP-SRS-27-8 Reporting the previous events ZEP-SRS-27-9 Unpending threads whose conditions are met ZEP-SRS-27-10 Waiting for any of a set of events ZEP-SRS-27-11 Waiting for all of a set of events ZEP-SRS-27-12 Event wait timeout ZEP-SRS-27-13 Event wait timeout expiry ZEP-SRS-27-14 Reporting matching events on wait completion ZEP-SRS-27-15 Resetting events before waiting	ZEP-SYRS-27 Events	The Zephyr RTOS shall provide a mechanism to synchronize threads based on a set of events.	As a Zephyr RTOS user I want a thread to wait until one or more application-defined events have occurred so that it can coordinate its execution with other threads and ISRs.
SECTION	7						FIFOs
REQUIREMENT	7.1	ZEP-SYRS-24	Draft	Functional	FIFOs	Children: ZEP-SRS-24-1 FIFO definition at compile time ZEP-SRS-24-2 FIFO cancel waiting thread ZEP-SRS-24-3 FIFO enqueue item to the back ZEP-SRS-24-4 FIFO implicit memory allocation ZEP-SRS-24-5 FIFO append item list to the back ZEP-SRS-24-6 FIFO append and empty item list to the back ZEP-SRS-24-7 FIFO get and dequeue item from front ZEP-SRS-24-8 FIFO empty check ZEP-SRS-24-9 FIFO peek item at front ZEP-SRS-24-10 FIFO peek item at back	ZEP-SYRS-24 FIFOs data passing	The Zephyr RTOS shall implement FIFOs which can be used to pass data between threads and interrupt service routines.
REQUIREMENT	8	ZEP-SYRS-6	Draft	Functional	File Systems	Children: ZEP-SRS-17-1 Create file ZEP-SRS-17-2 Open files ZEP-SRS-17-3 Read files ZEP-SRS-17-4 Write to files ZEP-SRS-17-5 Close file ZEP-SRS-17-6 Move file ZEP-SRS-17-7 Delete file	ZEP-SYRS-6 Common File system operation support	The Zephyr RTOS shall provide a framework for managing file system access.	As a Zephyr RTOS user I want a posix / c like file system access to store data.
REQUIREMENT	9	ZEP-SYRS-1	Draft	Functional	Hardware Architecture Interface	Children: ZEP-SRS-19-1 Atomic Operations ZEP-SRS-19-2 Thread Context Switching ZEP-SRS-19-3 Software Exceptions ZEP-SRS-19-4 Processor Mode Support ZEP-SYRS-2 Support multiprocessor management	ZEP-SYRS-1 Architecture Layer Interface	The Zephyr RTOS shall provide a framework to communicate with a set of hardware architectural services.	As a Zephyr RTOS user I want to be able to easily switch my application to a different MCU architecture (x86, ARM Cortex-M/A, RISCV etc.).
REQUIREMENT	10	ZEP-SYRS-2	Draft	Functional	Hardware Architecture Interface	Parents: ZEP-SYRS-1 Architecture Layer Interface	ZEP-SYRS-2 Support multiprocessor management	The Zephyr RTOS shall support symmetric multiprocessing on multiple cores.	As a Zephyr RTOS user I want to use Zephyr OS on multi core (SMP-)MCUs/MPUs.
REQUIREMENT	11	ZEP-SYRS-7	Draft	Functional	Interrupts	Children: ZEP-SRS-7-1 Installing static IRQ service routines (ISR). ZEP-SRS-7-2 Static IRQ initial status. ZEP-SRS-7-3 Installing direct IRQ service routines (ISR). ZEP-SRS-7-4 Direct IRQ initial status. ZEP-SRS-7-5 Installing dynamic IRQ service routines (ISR). ZEP-SRS-7-6 Dynamic IRQ initial status. ZEP-SRS-7-7 Uninstalling dynamic IRQ service routines (ISR). ZEP-SRS-7-8 Global IRQ disable ZEP-SRS-7-9 Global IRQ enable ZEP-SRS-7-10 Specific IRQ disable ZEP-SRS-7-11 Specific IRQ enable ZEP-SRS-7-12 IRQ Enabled status ZEP-SRS-7-13 ISR Context status ZEP-SRS-7-14 Multi-level interrupts ZEP-SRS-7-15 Interrupt service routine invocation ZEP-SRS-7-16 Interrupt service routine parameter ZEP-SYRS-20 Direct ISR, Platform Specific helpers.	ZEP-SYRS-7 Interrupt Management	The Zephyr RTOS shall provide a framework for interrupt and interrupt service routine management.	As the Zephyr RTOS user I want the Kernel to provide abstracted interfaces to the platform enabling me to implement standard interrupts interrupt service routines without detailed knowledge of the platform architecture and programming model.
REQUIREMENT	12	ZEP-SYRS-20	Draft	Functional	Interrupts	Parents: ZEP-SYRS-7 Interrupt Management	ZEP-SYRS-20 Direct ISR, Platform Specific helpers.	Zephyr RTOS shall support development of direct ISRs by providing platform specific code fragments and factory functions including, minimal header instructions, minimal footer instructions, low power termination, and ISR construction.	As the Zephyr RTOS user I want the Kernel to provide support for implementing standard low latency and low power interrupt service routines without detailed knowledge of the platform architecture and programming model.
SECTION	13						Kernel Timing
REQUIREMENT	13.1	ZEP-SYRS-28	Draft	Functional	Kernel Timing	Children: ZEP-SRS-28-1 System uptime in milliseconds ZEP-SRS-28-2 System uptime in system ticks ZEP-SRS-28-3 System uptime in seconds ZEP-SRS-28-4 Elapsed time relative to a reference ZEP-SRS-28-5 Hardware clock cycle count ZEP-SRS-28-6 64-bit hardware clock cycle count ZEP-SRS-28-7 Conversion between time units	ZEP-SYRS-28 Time measurement	The Zephyr RTOS shall provide services to measure the passage of time.	As a Zephyr RTOS user I want to measure elapsed time so that I can implement time-dependent application behavior.
REQUIREMENT	13.2	ZEP-SYRS-34	Draft	Functional	Kernel Timing	Children: ZEP-SRS-28-8 Suspending a thread for a duration ZEP-SRS-28-9 Suspending a thread with microsecond resolution ZEP-SRS-28-10 Thread readiness after sleep ZEP-SRS-28-11 Waking a sleeping thread ZEP-SRS-28-12 Reporting remaining time on premature wake ZEP-SRS-28-15 Reporting remaining time on premature wake with microsecond resolution ZEP-SRS-28-13 Busy waiting	ZEP-SYRS-34 Delaying thread execution	The Zephyr RTOS shall provide services to delay the execution of a thread for a period of time.	As a Zephyr RTOS user I want to delay a thread for a defined period so that I can pace my application against the passage of real time.
REQUIREMENT	13.3	ZEP-SYRS-35	Draft	Functional	Kernel Timing	Children: ZEP-SRS-28-14 Absolute timeouts	ZEP-SYRS-35 Timeout specification	The Zephyr RTOS shall provide a means to specify the timeout of a kernel operation as a relative duration or as an absolute point in time.	As a Zephyr RTOS user I want to express when a kernel operation times out either as a delay from the current time or as a fixed point in time so that recurring operations do not accumulate drift.
SECTION	14						LIFOs
REQUIREMENT	14.1	ZEP-SYRS-23	Draft	Functional	LIFOs	Children: ZEP-SRS-23-1 LIFO definition at compile time ZEP-SRS-23-2 LIFO enqueue item to the back ZEP-SRS-23-3 LIFO implicit memory allocation ZEP-SRS-23-4 LIFO get and dequeue item from front	ZEP-SYRS-23 LIFOs data passing	The Zephyr RTOS shall implement a LIFOs which can be used to pass data between threads and interrupt service routines.
REQUIREMENT	15	ZEP-SYRS-8	Draft	Functional	Logging	Children: ZEP-SRS-11-1 Dedicated Logging Thread Support ZEP-SRS-11-2 Logs available for post processing ZEP-SRS-11-3 Formatting log messages ZEP-SRS-11-4 Logging Filtering Support ZEP-SRS-11-5 Multiple Backend Logging Support ZEP-SRS-11-6 Deferred Logging Support	ZEP-SYRS-8 Logging	The Zephyr RTOS shall provide a framework for logging events.	As a Zephyr RTOS user I want to be able to log application defined events as well as framework exceptions.
SECTION	16						Mailboxes
REQUIREMENT	16.1	ZEP-SYRS-25	Draft	Functional	Mailboxes	Children: ZEP-SRS-25-1 Mailbox Initialization At Run Time ZEP-SRS-25-2 Mailbox Initialization At Compile Time ZEP-SRS-25-3 Message Size Support ZEP-SRS-25-4 Mailbox Data Transfer ZEP-SRS-25-5 Synchronous Message Sending ZEP-SRS-25-6 Synchronous Send Timeout Handling ZEP-SRS-25-7 Asynchronous Message Sending ZEP-SRS-25-8 Asynchronous Completion Signaling ZEP-SRS-25-9 Message Reception ZEP-SRS-25-10 Message Data Retrieval ZEP-SRS-25-11 Message Reception Blocking ZEP-SRS-25-12 Message Reception Timeout Handling ZEP-SRS-25-13 Non-Anonymous Messaging ZEP-SRS-25-14 Priority-Based Message Delivery ZEP-SRS-25-15 Priority-Based Message Delivery ZEP-SRS-25-16 Mailbox Quantity Support ZEP-SRS-25-17 Invalid Parameter Handling	ZEP-SYRS-25 Mailboxes	The Zephyr RTOS shall provide a framework to pass messages of arbitrary size between threads.
REQUIREMENT	17	ZEP-SYRS-9	Draft	Functional	Memory Management	Children: ZEP-SRS-9-1 Dynamic Memory Allocation ZEP-SRS-9-2 Memory Slab Object ZEP-SRS-9-3 Heap definition at compile time ZEP-SRS-9-4 Heap initialization at run time ZEP-SRS-9-5 Heap allocation ZEP-SRS-9-6 Heap aligned allocation ZEP-SRS-9-7 Heap allocation timeout ZEP-SRS-9-8 Heap allocation failure ZEP-SRS-9-9 Heap reallocation ZEP-SRS-9-10 Heap free ZEP-SRS-9-11 System heap allocation and release ZEP-SRS-9-12 Memory slab definition at compile time ZEP-SRS-9-13 Memory slab initialization at run time ZEP-SRS-9-14 Memory slab block allocation ZEP-SRS-9-15 Memory slab allocation timeout expiry ZEP-SRS-9-16 Memory slab block free ZEP-SRS-9-17 Memory slab usage statistics ZEP-SRS-9-18 Enumerating defined heaps ZEP-SRS-8-1 Memory Protection ZEP-SRS-8-2 Granting access to kernel objects ZEP-SRS-8-3 Separation between user and kernel threads for memory access ZEP-SRS-8-4 Safely handle unimplemented calls or invalid system calls ZEP-SRS-8-5 Response to invalid system call IDs ZEP-SRS-8-6 Prevent user threads creating higher priority threads ZEP-SRS-8-7 Revoking threads permissions on a kernel object ZEP-SRS-8-8 Prevent user threads creating supervisor threads ZEP-SRS-8-9 Reduced Privilege Level Threads ZEP-SRS-8-10 User Mode Threads Performing Privileged Operations ZEP-SRS-8-11 User mode handling of detected stack overflow ZEP-SRS-8-12 Stack Overflow Detection ZEP-SRS-8-13 Boot Time Memory Access Policy ZEP-SRS-8-14 System Call Handler Functions ZEP-SRS-8-15 System Call C strings in user mode ZEP-SRS-8-16 Tracking kernel objects in used by user mode threads ZEP-SRS-8-17 Granting threads access to specific memory ZEP-SRS-8-18 Assigning memory pools to act as a thread resource pool	ZEP-SYRS-9 Memory Management framework	The Zephyr RTOS shall support a memory management framework.	As a Zephyr RTOS user I want memory to be allocated and protected to my application threads preventing mistakenly access to foreign memory as far as the hardware allows.
SECTION	18						Message Queues
REQUIREMENT	18.1	ZEP-SYRS-31	Draft	Functional	Message Queues	Children: ZEP-SRS-31-1 Message queue definition at compile time ZEP-SRS-31-2 Message queue initialization at run time ZEP-SRS-31-3 Message queue initialization at run time with a dynamically allocated buffer ZEP-SRS-31-4 Sending a message to the back ZEP-SRS-31-5 Sending a message to the front ZEP-SRS-31-6 Send timeout ZEP-SRS-31-7 Send timeout expiry ZEP-SRS-31-8 Receiving a message ZEP-SRS-31-9 Message retrieval order ZEP-SRS-31-10 Receive timeout ZEP-SRS-31-11 Receive timeout expiry ZEP-SRS-31-12 Peeking at a message ZEP-SRS-31-13 Peeking at a message by index ZEP-SRS-31-14 Purging a message queue ZEP-SRS-31-19 Purging with blocked senders ZEP-SRS-31-15 Querying used message count ZEP-SRS-31-16 Querying free message count ZEP-SRS-31-21 Querying message queue attributes ZEP-SRS-31-17 Releasing a dynamically allocated message queue buffer ZEP-SRS-31-20 Releasing a buffer with waiting threads	ZEP-SYRS-31 Message Queues	The Zephyr RTOS shall provide a mechanism for threads and interrupt service routines to asynchronously exchange fixed-size data items.
SECTION	19						Multi core and SMP
REQUIREMENT	19.1	ZEP-SYRS-11	Draft	Functional	SMP and Multi core		ZEP-SYRS-11 Multiple CPU scheduling	The Zephyr RTOS shall support scheduling of threads on multiple hardware CPUs.	As a Zephyr RTOS user I want Zephyr OS to run on MCUs/CPUs with one or more CPU cores.
REQUIREMENT	19.2	ZEP-SYRS-12	Draft	Functional	SMP and Multi core		ZEP-SYRS-12 Scheduling	The Zephyr RTOS shall provide an interface to assign a thread to a specific CPU.	As a Zephyr RTOS user, I want to be able to control which thread will run on which CPU.
REQUIREMENT	20	ZEP-SYRS-10	Draft	Functional	Power Management	Children: ZEP-SRS-13-1 Power State Control ZEP-SRS-13-2 Power Management ZEP-SRS-13-3 Notification of changes to system power states	ZEP-SYRS-10 Power Management	The Zephyr RTOS shall provide an interface to control hardware power states.	As a Zephyr RTOS user I want to be able to control the power mode of the MCU and its peripherals to take advantage of the hardware features and to be able to implement low power or battery driven long life applications.
SECTION	21						Pipes
REQUIREMENT	21.1	ZEP-SYRS-32	Draft	Functional	Pipes	Children: ZEP-SRS-32-1 Pipe definition at compile time ZEP-SRS-32-2 Pipe initialization at run time ZEP-SRS-32-3 Writing data to a pipe ZEP-SRS-32-4 Reading data from a pipe ZEP-SRS-32-5 Pipe write timeout ZEP-SRS-32-11 Pipe write timeout expiry ZEP-SRS-32-6 Pipe read timeout ZEP-SRS-32-12 Pipe read timeout expiry ZEP-SRS-32-7 Resetting a pipe ZEP-SRS-32-8 Closing a pipe ZEP-SRS-32-9 Operations on a closed pipe ZEP-SRS-32-10 Operations interrupted by a reset	ZEP-SYRS-32 Pipes	The Zephyr RTOS shall provide a mechanism to transfer a stream of bytes between threads.
SECTION	22						Polling
REQUIREMENT	22.1	ZEP-SYRS-33	Draft	Functional	Polling	Children: ZEP-SRS-33-1 Waiting for any of multiple poll events ZEP-SRS-33-2 Supported poll event conditions ZEP-SRS-33-11 Poll event initialization ZEP-SRS-33-3 Poll wait timeout ZEP-SRS-33-4 Reporting ready poll events ZEP-SRS-33-5 Poll signal object ZEP-SRS-33-6 Poll signal initialization ZEP-SRS-33-7 Raising a poll signal ZEP-SRS-33-8 Persistence of a raised poll signal ZEP-SRS-33-9 Resetting a poll signal ZEP-SRS-33-10 Querying a poll signal	ZEP-SYRS-33 Polling	The Zephyr RTOS shall provide a mechanism for a thread to wait concurrently for any one of multiple conditions to be satisfied.
SECTION	23						Queues
REQUIREMENT	23.1	ZEP-SYRS-22	Draft	Functional	Queues	Children: ZEP-SRS-20-1 Queue definition at compile time ZEP-SRS-20-2 Queue definition at run time. ZEP-SRS-20-3 Queue enqueue item to the back ZEP-SRS-20-4 Queue enqueue item to the front ZEP-SRS-20-5 Queue remove item ZEP-SRS-20-6 Queue get and dequeue item from front ZEP-SRS-20-7 Queue empty check ZEP-SRS-20-8 Queue peek item at back ZEP-SRS-20-9 Queue peek item at front ZEP-SRS-20-10 Queue insert ZEP-SRS-20-11 Queue append item list to the back ZEP-SRS-20-12 Queue append and empty item list to the back ZEP-SRS-20-13 Queue append unique data item ZEP-SRS-20-14 Queue implicit memory allocation	ZEP-SYRS-22 Queues data passing	The Zephyr RTOS shall implement a queue which can be used to pass data between threads and interrupt service routines.
SECTION	24						Stacks
REQUIREMENT	24.1	ZEP-SYRS-30	Draft	Functional	Stacks	Children: ZEP-SRS-30-1 Stack definition at compile time ZEP-SRS-30-2 Stack initialization at run time with an user-defined memory area ZEP-SRS-30-3 Stack initialization at run time with automatically allocated memory area ZEP-SRS-30-4 Releasing a dynamically allocated stack buffer ZEP-SRS-30-5 Push an item to the stack ZEP-SRS-30-6 Pop an item from the stack ZEP-SRS-30-7 Pushing onto a full stack ZEP-SRS-30-8 Concurrent access protection ZEP-SRS-30-9 Stack data retrieval with timeout ZEP-SRS-30-11 Stack pop timeout expiry	ZEP-SYRS-30 Stacks	The Zephyr RTOS shall implement a stack which can be used to pass data between threads and interrupt service routines.
SECTION	25						Thread Synchronization
REQUIREMENT	25.1	ZEP-SYRS-13	Draft	Functional	Mutex	Children: ZEP-SRS-6-1 Mutex Kernel Object ZEP-SRS-6-2 Mutex definition at compile time ZEP-SRS-6-3 Mutex definition at run time ZEP-SRS-6-4 Locking a mutex ZEP-SRS-6-5 Locking an unowned mutex ZEP-SRS-6-6 Locking a mutex owned by another thread ZEP-SRS-6-7 Mutex lock timeout ZEP-SRS-6-8 Mutex lock timeout expiry ZEP-SRS-6-9 Recursive mutex locking ZEP-SRS-6-10 Unlocking a mutex ZEP-SRS-6-11 Unlocking by a non-owner ZEP-SRS-6-12 Priority inheritance	ZEP-SYRS-13 Mutex	The Zephyr RTOS shall provide an interface for managing communication between threads.	As a Zephyr RTOS user I want to able to exchange information between threads in a thread-safe manner guaranteeing data consistence.
REQUIREMENT	25.2	ZEP-SYRS-14	Draft	Functional	Semaphore	Children: ZEP-SRS-5-1 Counting Semaphore Definition At Compile Time ZEP-SRS-5-2 Counting Semaphore Definition At Run Time ZEP-SRS-5-3 Maximum limit of a semaphore ZEP-SRS-5-4 Initialialization with maximum count value ZEP-SRS-5-5 Initial semaphore value ZEP-SRS-5-6 Semaphore acquisition mechanism ZEP-SRS-5-7 Semaphore acquisition with count greater than zero ZEP-SRS-5-8 Semaphore acquisition with zero count ZEP-SRS-5-9 Semaphore acquisition timeout ZEP-SRS-5-10 Semaphore acquisition timeout error handling ZEP-SRS-5-11 Semaphore acquisition no wait error handling ZEP-SRS-5-12 Semaphore release ZEP-SRS-5-13 Semaphore count increment on release ZEP-SRS-5-14 Highest-priority waiter unblocked on release ZEP-SRS-5-15 Checking semaphore count ZEP-SRS-5-16 Semaphore reset ZEP-SRS-5-17 Semaphore acquisitions abort after reset ZEP-SRS-5-18 Semaphore Initialization Option Validation ZEP-SRS-5-19 Semaphore release at maximum count ZEP-SRS-5-20 Semaphore operations from interrupt context	ZEP-SYRS-14 Counting Semaphore	The system shall implement a semaphore synchronization primitive for coordinating access to shared resources among multiple threads.
SECTION	26						Threads
REQUIREMENT	26.1	ZEP-SYRS-15	Draft	Functional	Threads	Children: ZEP-SRS-2-4 Scheduling a thread based on an event ZEP-SRS-1-1 Creating threads ZEP-SRS-1-3 Suspending a thread ZEP-SRS-1-4 Resuming a suspended thread ZEP-SRS-1-5 Resuming a suspended thread after a timeout ZEP-SRS-1-6 Deleting a thread ZEP-SRS-1-7 Thread states ZEP-SRS-1-8 Thread stack objects ZEP-SRS-1-9 Thread privileges ZEP-SRS-1-11 Thread Options ZEP-SRS-1-12 Thread Custom Data ZEP-SRS-38-1 Work queue initialization ZEP-SRS-38-29 Work queue start	ZEP-SYRS-15 Thread support	The Zephyr RTOS shall support threads.	As a Zephyr RTOS user, I want to be able to have support for the kernel objects named threads for processing work.
REQUIREMENT	26.2	ZEP-SYRS-16	Draft	Functional	Threads	Children: ZEP-SRS-1-1 Creating threads ZEP-SRS-1-3 Suspending a thread ZEP-SRS-1-4 Resuming a suspended thread ZEP-SRS-1-5 Resuming a suspended thread after a timeout ZEP-SRS-1-6 Deleting a thread ZEP-SRS-1-7 Thread states ZEP-SRS-1-8 Thread stack objects ZEP-SRS-1-9 Thread privileges ZEP-SRS-1-10 Scheduling multiple threads ZEP-SRS-1-11 Thread Options ZEP-SRS-1-12 Thread Custom Data	ZEP-SYRS-16 Thread management	The Zephyr RTOS shall provide a framework for managing multiple threads of execution.	As a Zephyr RTOS user, I want to be able to manage the execute of multiple threads with different priorities.
REQUIREMENT	26.3	ZEP-SYRS-17	Draft	Functional	Threads	Children: ZEP-SRS-1-2 Setting thread priority	ZEP-SYRS-17 Thread priority	Threads shall have a priority.	As a Zephyr RTOS user, I want to be able to give my threads different priorities for execution.
REQUIREMENT	27	ZEP-SYRS-18	Draft	Functional	Timers	Children: ZEP-SRS-4-1 Timer definition at compile time ZEP-SRS-4-2 Timer expiry function ZEP-SRS-4-3 Timer stop function ZEP-SRS-4-4 Timer definition at run time ZEP-SRS-4-5 Timer start ZEP-SRS-4-6 Timer stop ZEP-SRS-4-7 Timer status ZEP-SRS-4-8 Timer status reinitialization ZEP-SRS-4-9 Timer thread synchronization ZEP-SRS-4-10 Timer next expiration time in system ticks ZEP-SRS-4-11 Timer remaining time until expiration in system ticks ZEP-SRS-4-12 Timer remaining time until expiration in milliseconds ZEP-SRS-4-13 Timer set user data ZEP-SRS-4-14 Timer get user data ZEP-SRS-4-15 Timer expire functions in interrupt context ZEP-SRS-4-16 Timer resource cleanup ZEP-SRS-4-17 Timer cleanup with pending threads ZEP-SRS-4-18 Observing timer lifecycle events	ZEP-SYRS-18 Timers	The Zephyr RTOS shall provide a framework for managing time-based events.	As a Zephyr RTOS user, I want to start, suspend, resume and stop timers which shall trigger an event on a set expiration time.
REQUIREMENT	28	ZEP-SYRS-19	Draft	Functional	Tracing	Children: ZEP-SRS-10-1 Initializing a trace ZEP-SRS-10-2 Triggering a trace ZEP-SRS-10-3 Dumping trace results ZEP-SRS-10-4 Removing trace data ZEP-SRS-10-5 Tracing Object Identification ZEP-SRS-10-6 Tracing Non-Interference	ZEP-SYRS-19 Tracing	Zepyhr shall provide a framework mechanism for tracing low level system operations (NOTE: system calls, interrupts, kernel calls, thread, synchronization, etc.).	As a Zephyr RTOS user, I want to be able to trace different OS operations.
SECTION	29						Work Queues
REQUIREMENT	29.1	ZEP-SYRS-37	Draft	Functional	Work Queues	Children: ZEP-SRS-38-1 Work queue initialization ZEP-SRS-38-29 Work queue start ZEP-SRS-38-41 Processing a work queue in the calling thread ZEP-SRS-38-2 Work queue thread priority ZEP-SRS-38-30 Work queue thread naming ZEP-SRS-38-31 Work queue essential thread ZEP-SRS-38-3 Work item processing order ZEP-SRS-38-4 Work queue thread yielding ZEP-SRS-38-44 Work queue thread yielding disabled ZEP-SRS-38-5 Work queue draining ZEP-SRS-38-32 Work item submission while draining ZEP-SRS-38-6 Work queue submission blocking on drain ZEP-SRS-38-7 Work queue submission unblocking ZEP-SRS-38-8 Work queue stop ZEP-SRS-38-45 Work queue stop timeout ZEP-SRS-38-53 Work queue stop timeout expiry ZEP-SRS-38-46 Work queue stop with an essential thread ZEP-SRS-38-9 Work item initialization at run time ZEP-SRS-38-34 Work item definition at compile time ZEP-SRS-38-33 System work queue ZEP-SRS-38-10 Work item submission to the system work queue ZEP-SRS-38-11 Work item submission to a specified work queue ZEP-SRS-38-12 Work item submission from threads and interrupt service routines ZEP-SRS-38-13 Work item handler invocation ZEP-SRS-38-14 Resubmission of an already queued work item ZEP-SRS-38-47 Resubmission of a running work item ZEP-SRS-38-48 Resubmission of a running work item to a different work queue ZEP-SRS-38-15 Waiting for a work item to complete ZEP-SRS-38-16 Work item pending status ZEP-SRS-38-17 Cancellation of a queued work item ZEP-SRS-38-18 Cancellation of a running work item handler ZEP-SRS-38-19 Cancellation with wait for completion ZEP-SRS-38-20 Delayable work item initialization at run time ZEP-SRS-38-35 Delayable work item definition at compile time ZEP-SRS-38-21 Scheduling a delayable work item on a specified work queue ZEP-SRS-38-36 Scheduling a delayable work item on the system work queue ZEP-SRS-38-22 Submission of a delayable work item on delay expiry ZEP-SRS-38-23 Rescheduling a delayable work item ZEP-SRS-38-49 Rescheduling a queued or running delayable work item ZEP-SRS-38-24 Cancellation of a delayable work item ZEP-SRS-38-42 Waiting for a delayable work item to complete ZEP-SRS-38-50 Waiting for a scheduled delayable work item to complete ZEP-SRS-38-43 Cancellation of a delayable work item with wait for completion ZEP-SRS-38-25 Querying the remaining delay of a delayable work item ZEP-SRS-38-26 Work item timeout monitoring ZEP-SRS-38-51 Triggered work item initialization ZEP-SRS-38-27 Submitting a triggered work item ZEP-SRS-38-52 Resubmission of a waiting triggered work item ZEP-SRS-38-28 Cancelling a triggered work item ZEP-SRS-38-37 User work item initialization at run time ZEP-SRS-38-38 User work item definition at compile time ZEP-SRS-38-39 User work queue start ZEP-SRS-38-40 User work item submission	ZEP-SYRS-37 Work Queues	The Zephyr RTOS shall provide a framework to offload the processing of work items to a dedicated thread.	As a Zephyr RTOS user I want an ISR or a high-priority thread to defer non-urgent processing to a lower-priority thread so that time-sensitive processing is not impacted.