Kernel Developer Guide

Note

This feature requires the TrustAPP Software Component. Please ensure that your production license enables its deployment.

• Overview
  • Introduction
  • Terms and Definitions
  • Overall Architecture
  • Input and Output Artifacts
  • Kernel Build Flow
  • Kernel Implementation Libraries
  • Getting started
• Considerations for Developing a Kernel
  • Prerequisites
  • Glossary
  • Application Installation Flow
    • Communication Channel
    • Application Code Storage and Execution Strategies
    • Application Compatibility
    • Preinstalled Applications
    • Memory Layout
    • Security
  • Kernel Services
    • Ecosystem APIs
    • Runtime Policy
  • Opening Ecosystem to Third-Party Developers
    • IP Considerations
    • Customer SDK
    • Application Moderation
• Kernel & Features Specification (KF)
  • Introduction
    • Specification Summary
    • Comments
    • Basic Concepts
    • First Example
  • Ownership Rules
    • Type
    • Object
    • Execution Context
    • Kernel Mode
  • Execution Rules
    • Type References
    • Method References
    • Field References
    • Object References
    • Local References
    • Monitor Access
    • Native Method Declaration
    • Reflective Operations
  • Feature Lifecycle
    • Entry point
    • States
    • Installation
    • Start
    • Stop
    • Uninstallation
  • Class Spaces
    • Overview
    • Private Types
    • Kernel API Types
    • Precedence Rules
  • Resource Control Manager
    • CPU Control: Quotas
    • RAM Control: Managed Heap Configuration
    • RAM Control: Feature Criticality
    • Time-out Control: Watchdog
    • Native Resource Control: Security Manager
  • Communication Between Features
    • Method Binding
    • Object Binding
    • Kernel Type Converters
  • Configuration Files
    • Kernel and Features Declaration
    • Kernel API Definition
    • Identification
    • Shared Interface Declaration
    • Kernel Advanced Configuration
    • Context Local Storage Static Field Configuration
• Kernel Creation
  • Create a new Project
  • Configure a VEE Port
  • Build the Executable and Virtual Device
    • Build the Executable in the Workspace
  • Expose APIs
  • Implement a Security Policy
  • Add Pre-installed Applications
  • Kernel Application Configuration with SDK 5
    • Module Configuration
    • Build Options
    • Build only a Virtual Device with a pre-existing Kernel
• Kernel APIs
  • Kernel API Definition
  • Writing Kernel APIs
    • Default Kernel APIs Derivation
    • Kernel API Generator
• Runtime Environment
  • Principle
  • Create a new Runtime Environment Module
    • Kernel APIs as Dependencies
    • Kernel APIs as Project File
    • Add Add-On Processors
  • Use a Runtime Environment in an Application
  • Extend a Runtime Environment
• Module UID
• Sandboxed Application Lifecycle
• Define a Security Policy
  • Register a Security Manager
  • Implement a Security Manager
    • Security Manager with Application Declared Permissions
    • Security Manager with Permission Dispatch
• Resource Manager
  • Principle
  • Policy File Format
    • Attributes
  • Kernel Implementation
• Kernel and Features Communication
  • Shared Services
  • Communication between Features
    • Register a Service
    • Get a Service
  • Communication between Kernel and Feature
    • Register a Service
    • Get a Service
  • Implement a Registry
  • Kernel Types Converter
    • Implement a Kernel Type Converter
• Multi-Sandbox Enabled Libraries
  • Manage Internal Global State
    • Declare a Static Field Local to the Feature
    • Allow a Field Assignment in Kernel Mode
    • Use Existing Multi-Sandbox Enabled Data Structures
  • Implement a Security Manager Permission Check
  • Known Foundation Libraries Behavior
    • MicroUI
    • BON
    • Event Queue
    • FS
    • NET
    • SSL
• Setup a KF Testsuite
  • Enable the Testsuite
  • Add a KF Test
  • Write the Kernel Main Class
  • Improve Development Experience
  • Add Assertions
  • Run a KF Testsuite
  • KF Testsuite Options (SDK 5 only)
• Kernel Linking
  • Link Flow
  • Kernel Metadata Generation
  • Feature Portability Control
    • Principle
    • Enable
    • Portability Rules
    • Typical Development Workflow
• Application Linking
  • SOAR Build Phases
  • Feature Build Off Board
  • Feature Build On Device
    • Full Mode
    • Partial Mode
  • FSO Compatibility
  • Feature Portability
• FAQ
  • Glossary
  • Security & Sandboxing
    • How is Applications’ code isolated from the rest of the device code?
    • How do we protect against malicious code injection in the App?
    • Can you outline what the Application integrity check does?
    • Are the Apps Signed?
    • I want to open app development to 3rd parties. How can I control API access from Apps?
    • Any recommendation about app deployment?
    • What kind of isolation exists between applications?
  • Inter-App Communication & APIs
    • How can Applications communicate with each other?
    • How can we get and differentiate installed applications?
    • How can I implement specific Kernel Policies depending on the calling Application?
    • Is there a way to extend Kernel APIs? (provide new APIs in new libraries dynamically)
  • Scheduling & Resource Management
    • What is the behavior of the scheduler when several apps are running?
  • App Deployment & Compatibility
    • How is Application compatibility ensured to prevent runtime linking errors?
    • What happens if a .fo is found to be incompatible? Is there an event or programmatic way to detect this?
    • My Kernel exposes the widget library as a Kernel API. My application has a dependency on the widget library. Will the code of the library be embedded into my app?
    • Can I pre-install applications in my device firmware?
    • Can the Kernel access the app’s resources before they are started?
    • How to access application metadata before installing it? (e.g. name, version, description)
    • Can I stop an Application at any time?
    • Can applications be used across different manufacturers?