Glossary of ChorusOS 5.0 related terms

absolute binary

A binary file where all addresses have been resolved and computed.

actor

See ChorusOS actor.

ADMIN

The ADMIN actor administers high-level operating system services.

See also C_OS.

application

A generic term to describe code running on ChorusOS (either a process or an actor).

asynchronous communication mode

The sender of an asynchronous message is only blocked for the time taken for the system to process the message locally. There is no guarantee that the message has been deposited at the destination.

See also synchronous communication mode.

basic profile

A lightweight configuration of the ChorusOS operating system. This configuration is pre-built and part of the binary delivery. The configurator utility can be used to change the profile.

See also configurator, and extended profile.

binary delivery

The binary delivery of Sun Embedded Workshop includes the development environment for ChorusOS and the ChorusOS operating system in binary, along with the BSPs for the reference target boards in the supported target family.

See also source delivery.

black box

Black box provides a means for tracing the activity of the system and applications using multiple in-memory buffers managed by the system.

board

See target board.

Board Support Package

The BSP (Board Support Package) is the set of files that can be customized to run ChorusOS on specific board architectures. It is provided in source with the binary product, allowing you to port to another board within the same target family. The BSP contains the boot and the generic and processor specific drivers required for your board.

boot

The boot provides system boot, system reboot, and debug services.

boot kernel interface (BKI)

The BKI is the interface between the microkernel and the boot. It is a set of rules used when the microkernel is launched. It is split into a generic part that is common to all target families and a specific part that applies to a single target family.

bootMonitor

See initial loader.

BSP

See Board Support Package.

c_actor

No longer used. See POSIX process.

C_INIT

The command interpreter of the ChorusOS operating system invoked by the system when it is loaded. C_INIT can be accessed by RSH or LOCAL_CONSOLE.

C_OS

An actor that manages input/output and provides the POSIX interface to applications. C_OS also manages file system, networking, and shared memory.

CBDI

See Common Bus Driver Interface (CBDI).

CDC

Connected Device Configuration, is part of J2ME. See J2ME.

ChorusOS actor

A unit of execution for an application. Serves as the encapsulation unit to associate all system resources used by the application and the threads running within the actor. ChorusOS actors are restricted to the microkernel API, that is, the APIs exported by the microkernel to run either:

• The "system" software, that is, hardware-related software (BSPs), or software related to OS services (networking, file administration, and so on).

• Services provided by the ChorusOS microkernel that cannot be used by POSIX processes. Exceptions are IPC, MIPC, and LAP, which can be used by both ChorusOS actors and POSIX processes.

ChorusOS actors can be user and supervisor, or trusted and non-trusted.

See also POSIX process, ChorusOS 4.x legacy application, user actor, supervisor actor.

ChorusOS 4.x legacy application

Applications developed for 4.x releases of the ChorusOS operating system. ChorusOS 5.0 fully supports 4.x legacy applications to help 4.x users transition to 5.x, but users are not encouraged to develop new 4.x legacy applications since no compatibility is planned beyond ChorusOS 5.0.

See also POSIX process, and ChorusOS actor.

Common Bus Driver Interface (CBDI)

An interface that is independent of bus type, offering a set of services common for all bus classes.

component

The ChorusOS operating system is made up of several components that can be specified when building the system image. Some components are mandatory for the system, such as the kernel, DRV, and the bsp components. Other components include, os, tools, the X11 libraries, and the examples.

configurator

A command-line tool used to configure the ChorusOS system image.

See also Ews, and configuring a system image.

configure

A tool to configure your build directory with the paths of the components to be included in your system image.

configuring a system image

This refers to including optional components in your system image, turning features on or off, and changing the value of tunable parameters and environment variables in your ChorusOS system image. This can be carried out using different tools, including configure, configurator, Ews. The configuration is stored in a number of different ECML files.

core dump

Core dump allows offline, post-mortem, analysis of actors or processes that are killed by exceptions.

core executive

The core executive provides essential services to support real-time applications. It supports multiple, multi-applications running in both user and supervisor memory space.

It implements the basic ChorusOS execution model and provides the framework for all other features that can be configured. Every system includes a core executive.

The core executive exports the basic set of microkernel abstractions and services:

• The unit of application modularization (actor)

• The unit of execution (thread)

• Thread control operations

• Exception management services

• A minimal interrupt management service

No synchronization, scheduling, time, communication, or memory management policies are provided by the core executive. These policies and services are provided by additional features, which the user may select depending on particular hardware and software requirements.

CVM

CVM (C Virtual Machine), is a compact Java virtual machine, part of the J2ME provided with ChorusOS. It allows you to implement Java applications on a ChorusOS system.

See also J2ME.

device driver framework

A framework that is provided with ChorusOS that allows programmers to develop device drivers on top of a binary distribution of the ChorusOS operating system. The device driver framework provides a structured and easy-to-use environment to develop both new drivers and client applications for existing drivers.

device driver interface (DDI)

The device driver interface defines the interfaces between different layers of device drivers in the driver hierarchy. Typically, an API is defined for each class of device or bus, as a part of the DDI.

device kernel interface (DKI)

The device kernel interface defines all services provided by the microkernel to driver components. Following a layered interface model, all services implemented by the DKI are called by the drivers, and take place in the microkernel.

device tree

The ChorusOS device tree is a data structure that describes hardware topology and device properties. It is constructed in terms of parent/child relationships between devices. Device properties are specific to each device and defined in name/value pairs.

The initial device tree is built by the bootstrap program using the DKI tree browsing API.

DHCP

See Dynamic Host Configuration Protocol.

DNS

See Domain Name Service (DNS).

Domain Name Service (DNS)

Standard naming architecture used for naming on the Internet Protocol (IP).

DRV

DRV is the ChorusOS component that contains all generic microkernel drivers and all board specific drivers.

dynamic loading

On actor start-up, the runtime linker loads the actor or process and performs the necessary relocations. It also loads and links the actor dependencies (the required dynamic libraries).

dynamic and static identifiers

See static and dynamic identifiers.

Dynamic Host Configuration Protocol

A communications protocol that lets network administrators manage centrally and automate the assignment of Internet Protocol (IP) addresses in an organization's network.

embedded actor

An actor can be embedded, which means that it becomes part of the system image and is launched at boot time. Embedded actors that are not boot actors can be loaded by other embedded actors using the afexec() system call.

Typically, drivers are embedded actors. Drivers do not require the services of the POSIX subsystem and can be started dynamically through the afexec() system call.

Embedded Component Mark Language (ECML)

The Embedded Component Mark Language provides a unique interface to the configurable information of the ChorusOS operating system. ECML is defined using XML syntax, making it benefit from existing XML tools, especially browsers and parsers. The configuration of ChorusOS is defined in a number of EMCL files that can be edited using the configurator and Ews tools.

Ews

A graphical configuration tool used to view and modify the configuration of a ChorusOS operating system through a set of ECML configuration files.

See also configuring a system image, Embedded Component Mark Language (ECML), configurator.

execution actor

The actor on behalf of which the thread currently executes. Any thread has the right to access and manage the resources of its execution actor.

See also home actor, and ChorusOS actor.

extended profile

A full configuration of the ChorusOS operating system, selected at installation.

See also basic profile.

feature

Services that can be selected when you configure your system image. You can configure features using either the command-line utility, configurator, or the graphical utility, Ews. Some features have tunable parameters associated with them.

See also configurator, Ews, and tunable parameter.

flat memory

Simple memory allocation service. The microkernel and all applications run in one unique, unprotected address space. Virtual addresses match physical addresses directly. This is used for systems without an MMU or when the MMU is bypassed.

home actor

The actor in which the thread was created. The home actor of a thread is constant over the life of the thread. Also called owning actor.

host

A machine running the Solaris operating environment that hosts the development environment, Sun Embedded Workshop, for building and configuring a ChorusOS system image and applications that run on it.

See also Sun Embedded Workshop software (SEW).

hot restart

Mechanism for restarting applications or entire systems if a serious error or failure occurs. This feature addresses the high-availability requirements of the operating system, reducing the time taken for a failed system or component to return to service.

See also Hot Restart Controller (HR_CTRL).

Hot Restart Controller (HR_CTRL)

An actor that monitors restartable actors to detect abnormal termination and automatically take the appropriate restart action. Abnormal termination includes unrecoverable errors, such as, division by zero, a segmentation fault, unresolved page fault, or invalid operation code.

See also hot restart, restartable actors, and persistent memory.

hot swap

A ChorusOS feature that allows you to remove and replace a board from an instance of the ChorusOS operating system without having to shut down the system.

See also Hot Swap Controller (HSC).

Hot Swap Controller (HSC)

A board-dependent layer that handles the ENUM# signal, which notifies the system of an insertion or removal event specified by cPCI hot swap.

See also hot swap, and PCI.

HR_CTRL

See Hot Restart Controller (HR_CTRL).

ICMPv6

See Internet Control Message Protocol.

Industry Standard Architecture (ISA)

Industry Standard Architecture is a standard bus (computer interconnection) architecture that is associated with the IBM AT motherboard.

initial loader

The initial loader enables a system image to be located on the network or local device, booted on the target board. The initial loader provided by ChorusOS is bootMonitor. This functionality is also provided by the target firmware (depending on your target).

Internet Control Message Protocol

ICMP is a message control and error-reporting protocol between a host server and a gateway to the Internet. ICMP uses Internet Protocol (IP) datagrams, but the messages are processed by the IP software and are not directly apparent to the application user.

inter-process communication (IPC)

IPC provides synchronous (RPC) and asynchronous communication features allowing threads to communicate and synchronize when they do not share memory. Communications rely on the exchange of messages through ports.

See also Remote Procedure Call (RPC), asynchronous communication mode, static and dynamic identifiers, and MIPC.

IPC

See inter-process communication (IPC).

IPv4 and IPv6

Internet Protocol versions 4 and 6.

ISA

See Industry Standard Architecture (ISA).

J2ME

Java 2 Platform Micro Edition technology covers the range of embedded devices. The ChorusOS port of this technology includes the Foundation profile and the Connected Device Configuration (CDC), which provides a virtual machine and basic class libraries to support Java language applications on consumer electronic and embedded devices.

JNI

Java Native Interface

JPDA

Java Platform Debugger Architecture

JVMDI

Java Virtual Machine Debug Interface

JDWP

Java Debug Wire Protocol

LAP

See Local Access Point (LAP).

Lightweight Directory Access Protocol (LDAP)

LDAP in ChorusOS provides access to X.500 directory services. These services can be a standalone part of a distribution service. An LDAP client library is available with ChorusOS that provides programmatic access to the LDAP.

Local Access Point (LAP)

A generic software interface for microkernel-mediated calls from one actor to another on the local site. A LAP is a microkernel object that represents a handler function that has been exported by a supervisor actor for invocation by client actors. It is a super-fast inter-actor communication facility provided by the operating system.

makefile target

An optional argument supplied to the make command that corresponds to a set of commands in the makefile. This enables you to specify more than one set of actions in a single makefile. For example, the make kernonly command allows you to build a system image containing just the microkernel and some OS services.

Management Information Base (MIB)

The Management Information Base is the language to describe the parameters managed through the SNMP protocol.

message handlers

Message handlers are an alternative to threads. Instead of creating threads explicitly, an actor can attach a handler (a routine in its address space) to the port. When a message is delivered to the port, the handler is executed in the context of a thread provided by the microkernel.

microkernel

The microkernel is the core of the ChorusOS operating system. It provides a minimum set of interfaces that are used by the remainder of the operating system. You must always include the microkernel in your system image.

mini profile

A profile containing the absolute minimum features for a bootMonitor image.

See also basic profile, and extended profile.

MIPC

The MIPC provides a fast communication facility based on exchange of messages through shared mailboxes.

See also inter-process communication (IPC).

monitor

A monitor is a set of instructions in which only one thread may execute at a time.

MSDOSFS

MS-DOS File System.

mutex

Sleep locks provided in the form of mutual exclusion locks. These are data structures allocated in the client actors' address spaces.

netboot

Application management utility used to boot a ChorusOS system image using TFTP when the target does not provide an embedded booting facility.

Network Information Service (NIS)

A network naming and administration system for small networks. Using NIS, each host client or server computer in the system has knowledge about the entire system. A user at any host can get access to files or applications on any host in the network with a single user identification and password. NIS is similar to the Internet's domain name system (DNS) but somewhat simpler and designed for a smaller network.

NTP

Network Time Protocol

operating system

The ChorusOS operating system provides a set of interfaces that enables you to run applications on various hardware configurations. The ChorusOS operating system contains the microkernel, board support package and higher level services, including I/O and file system support.

owning actor

See home actor.

patting

The process of resetting a watchdog timer. This process is usually managed by a dedicated user-level process. If not, an interrupt handler provided by the system is invoked.

See also watchdog timer.

PCI

Peripheral Component Interconnect (personal computer bus)

PD

The PD (Private Data manager) implements the per thread data interface between the microkernel subsystems, such as the the C_OS subsystem.

persistent memory

The hot restart mechanism relies on persistent memory to store data that can persist across an actor or site restart. It is used internally by the system to store on the RAM the actor image (text and data) from which a hot restartable actor can be reconstructed.

See also Persistent Memory Manager (PMM).

Persistent Memory Manager (PMM)

The PMM (Persistent Memory Manager) implements the persistent memory interface. It is a ChorusOS actor that manages the allocation and freeing of persistent memory blocks. The PMM is automatically included in the system image when the HOT_RESTART feature is activated.

See also persistent memory.

platform

See target board.

Point-to-Point Protocol (PPP)

A protocol for communication between two computers using a serial interface, typically a personal computer connected by phone line to a server. Essentially, it packages your computer's TCP/IP packets and forwards them to the server where they can actually be put on the Internet.

Portable Operating System Interface (POSIX)

A standard set of APIs for portable multithreaded programming.

ports

An address to which messages can be sent and that has a queue holding the messages received by the port but not yet consumed by the threads. Ports are attached to actors. Ports can be assembled into groups adding a multicast facility.

See also message handlers.

POSIX process

ChorusOS 5.0 provides a complete set of POSIX APIs and allows you to create POSIX-compatible applications. These applications are called POSIX processes. A process is the unit of encapsulation of the POSIX subsystem. Processes can be either user or supervisor.

See also ChorusOS actor, and ChorusOS 4.x legacy application.

PPP

See Point-to-Point Protocol (PPP).

process

See POSIX process.

process dump

pdump is a C_INIT built-in command which dumps a core image of one or more processes as an ELF format file.

See also C_INIT.

profile

The ChorusOS operating system provides profiles that are used to set up an initial configuration. The profiles are called basic, extended, and mini. These profiles include or remove certain features in the system. You can use one of these configuration profiles as the initial configuration for your system, and add or remove specific feature options using the configurator utility.

See also basic profile, extended profile, mini profile, and configurator.

protected memory

Memory allocation service supporting multiple address spaces and region sharing between different address spaces. Targeted at critical and non-critical real-time applications where memory protection is mandatory. This is used for systems with MMU, address translation, and where applications benefit from the flexibility and protection of separate address spaces.

protection identifier

The IPC allocates a protection identifier to each actor and to each port. The structure of the protection identifier is fixed, but IPC does not associate any semantics to their values.

relocatable actor

On actor start-up, the runtime linker loads the actor and performs the necessary relocations. In ChorusOS 5.0, all dynamic actors are relocatable.

relocatable binary

A binary file that can be loaded or relocated at any address.

Remote Procedure Call (RPC)

This protocol allows the construction of client-server applications using a demand/response protocol with management of transactions. The client is blocked until a response is returned from the server, or a user-defined optional timeout occurs. RPC guarantees at-most-once semantics for the delivery of the request.

See also inter-process communication (IPC), and asynchronous communication mode.

restartable actors

Any actor that can be restarted rapidly without accessing stable storage, when it terminates abnormally. A restartable actor is restarted from an actor image that comprises the actor's text and initialized data regions, stored in persistent memory. See also restart group, hot restart, hot restart controller, and persistent memory.

restart groups

A group of cooperating restartable actors that can be restarted in the event of the failure or abnormal termination of one or more actors within the group. When one actor in the group fails, all actors in the group are stopped and then restarted either directly by the system or indirectly by spawning. These groups are usually mutually exclusive. A restart group is created dynamically in ChorusOS when a direct actor is declared to be a member of the group. Therefore, each group contains at least one direct actor. An indirect actor is always a member of the same group as the actor that spawned it. This applies only when the HOT_RESTART feature is applied.

RPC

See Remote Procedure Call (RPC).

scheduler

A scheduler provides scheduling policies, which are rules, procedures, or criteria used in making process scheduling decisions. The scheduling policies available in the ChorusOS operating system include FIFO (first-in-first-out) and RR (round robin).

semaphore

An integer counter and an associated thread-wait queue. When initialized, the semaphore counter receives a user-defined positive or null value.

SEW

See Sun Embedded Workshop software (SEW).

software interrupts

Interrupts supported by the DKI and DDI. These are not initiated by a hardware device, but rather by the software. Handlers for these must be added to and removed from the system. Software interrupt handlers run in the interrupt context and therefore can be used to do many of the tasks that belong to the interrupt handler.

source delivery

The source delivery of the Sun Embedded Workshop includes the ChorusOS operating system in source files. Note that the development tools are delivered in binary.

See also binary delivery.

static and dynamic identifiers

These are communication entities that are part of the uniform global naming scheme of inter-process communication (IPC). Static identifiers are provided to the system by the application. Dynamic identifiers are returned by the system to the application.

See also inter-process communication (IPC).

Sun Embedded Workshop software (SEW)

The development environment for the ChorusOS operating system. This software includes the tools necessary to configure and build a ChorusOS operating system and the applications to run on it.

See also host.

supervisor actor

This is a type of actor that shares a common but partitioned address space with other supervisor actors. These actors can execute privileged hardware instructions depending on the underlying hardware.

See also ChorusOS actor, and user actor

supervisor process

A POSIX process that shares a common supervisor address space with other processes, which themselves are necessarily supervisor processes.

See also user process.

synchronous communication mode

The sender of a synchronous message is blocked until its request message has been received, answered, replied to, and the reply has been received. The whole loop is guaranteed to perform and errors or failures are detected and reported. The synchronous communication mode is sometimes called RPC (Remote Procedure Call).

See also Remote Procedure Call (RPC), and asynchronous communication mode

sysadm.ini file

A script file embedded in the file system boot image. This file is executed as the last step of the system initialization and is used by C_INIT after the system is initialized. You can customize it to run selected applications directly on system start-up.

system dump

Enables the system to collect data in case of a system failure. Data collection is defined as the content of the black box buffers. On a system crash, this data is copied to a persistent memory area, or dump area, based on the hot restart feature of the ChorusOS operating system.

See also black box.

system image

A system image is an instance of the ChorusOS operating system. It is made up of binary or executable files that define the operating system and initial application processes. After you have built and booted your system image, you are ready to start using the ChorusOS operating system.

target

See target board.

target board

The physical hardware board on which a ChorusOS system will run. The board must be in one of the supported target families to be able to run a ChorusOS system.

See also target family.

target family

A set of target boards with processors that are electronically different but are identical in their interactions with the operating system. The target families supported by the ChorusOS operating system are as follows:

• UltraSPARC IIi/IIe

• Intel x86/Pentium

• Motorola PowerPC 750/765/74x0 processors and PowerQUICC II (mpc8260) microcontrollers

• Motorola PowerQUICC I (mpc8xx) microcontrollers

When porting a ChorusOS system, you will be porting it to a new board in a supported target family.

See also target board.

TCK

Java Technology Conformance Kit

timer (general interval timer)

High-level timer service for both user and supervisor actors. This feature uses the concept of a timer object in the actor environment. Timers are created and deleted dynamically. All high-level timer operations such as setting, modifying, querying, or canceling pending timeouts, refer to timer objects.

tunable parameter

Tunables are parameters that you configure in your ChorusOS system image by setting an integer value. For example, timeout delays or maximum file sizes. Some tunable parameters are linked to a feature and are therefore only configurable if the feature is on. These are called static tunable parameters. In addition, there are system environment variables or dynamic tunable parameters that allow you to set the environment, a set of VARIABLE=value character strings defining the values for environment variables (for example, the IP address) read by the applications.

See also feature.

user actor

This is a type of actor that has separate and protected address spaces.

See also ChorusOS actor, and supervisor actor

user process

A POSIX process that runs in its own private protected address space.

See also supervisor process.

virtual memory

Memory allocation service supporting multiple, protected address spaces. On systems with secondary storage, applications can use much more virtual memory than the memory physically available. This module is specifically designed to implement distributed UNIX subsystems on top of the microkernel.

virtual timer

A virtual timer is responsible for all functions pertaining to measurement and timing of thread execution. It exports a number of functions used typically by higher-level operating systems such as UNIX.

watchdog timer

Mechanism provided with the ChorusOS operating system to detect hardware and operating system failures. Note that this feature relies on the hardware watchdog device available on modern boards.

See also patting.