|
A20 gate
On x86-based systems, a hardware component that
forces the A20 address line on the bus to zero, regardless of the actual setting of the A20 address
line on the processor. This component is in place to support legacy systems, but Neutrino doesn't
require any such hardware. Note that some processors, such as the 386EX, have the A20 gate hardware
built right into the processor itself - the Neutrino IPL will disable the A20 gate as soon as
possible after startup.
atomic
Of or relating to atoms. :-)
In realtime systems, this refers to the requirement
that an operation, or sequence of operations, be considered indivisible. For example, a
thread may need to move a file descriptor to a given location and read data. These operations must be
performed in an atomic manner; otherwise, another thread could preempt the original thread and move
the file descriptor to a different location, thus causing the original thread to read data from the
second thread's position.
attributes structure
Structure containing information used on a
per-resource basis (as opposed to the OCB, which is used on a per-open basis).
This structure is also known as a handle. The
structure definition is fixed (iofunc_attr_t), but may be extended. See also mount
structure.
bank-switched
A term indicating that a certain memory component
(usually the device holding an image) isn't entirely addressable by the processor. In this
case, a hardware component manifests a small portion (or "window") of the device onto the processor's
address bus. Special commands have to be issued to the hardware to move the window to different
locations in the device. See also linearly mapped.
base layer calls
Convenient set of library calls for writing resource
managers. These calls all start with resmgr_*(). Note that while some base layer calls are
unavoidable (e.g. resmgr_pathname_attach()), we recommend that you use the POSIX layer
calls where possible.
BIOS/ROM Monitor extension signature
A certain sequence of bytes indicating to the BIOS
or ROM Monitor that the device is to be considered an "extension" to the BIOS or ROM Monitor -
control is to be transferred to the device by the BIOS or ROM Monitor, with the expectation that the
device will perform additional initializations.
On the x86 architecture, the two bytes 0x55 and 0xAA
must be present (in that order) as the first two bytes in the device, with control being transferred
to offset 0x0003.
block-integral
The requirement that data be transferred such that
individual structure components are transferred in their entirety - no partial structure component
transfers are allowed.
In a resource manager, directory data must be
returned to a client as block-integral data. This means that only complete
struct direct structures can be returned - it's inappropriate to
return partial structures, assuming that the next _IO_READ request will "pick up" where the previous
one left off.
bootable
A Neutrino image can be either bootable or
nonbootable. A bootable image is one that contains the startup code that the IPL can transfer
control
buildfile
A text file containing instructions for
mkifs specifying the contents and other details of an
image.
canonical mode
Also called edited mode or "cooked" mode. In this
mode the character device library performs line-editing operations on each received character. Only
when a line is "completely entered" - typically when a carriage return (CR) is received - will the
line of data be made available to application processes.
channel
A kernel object used with message
passing.
In Neutrino, message passing is directed towards
connections (made to channels), and threads can receive messages from channels. A thread that
wishes to receive messages creates a channel (see ChannelCreate()), and then receives messages
from that channel (see MsgReceivev()). Another thread that wishes to send a message to the
first thread must make a connection to that channel by "attaching" to the channel (see
ConnectAttach()) and then sending data (see MsgSendv()).
Common Internet File System (aka SMB) - protocol
that allows a client workstation to perform transparent file access over a network to a Windows
95/98/NT server. Client file access calls are converted to CIFS protocol requests and are sent to the
server over the network. The server receives the request, performs the actual filesystem operation,
and sends a response back to the client.
CIS
Card Information Structure - a data block that
maintains information about flash configuration. The CIS description includes the types of memory
devices in the regions, the physical geometry of these devices, and the partitions located on the
flash.
combine message
A resource manager message that consists of two or
more messages. The messages are constructed as combine message by the client's C library (e.g.
stat(), readblock()), and are then handled as individual messages by the resource
manager.
Combine messages exist in order to conserve network
bandwidth and/or to provide support for atomic operations. See also connect message and I/O
message.
connect message
In a resource manager, a message issued by the
client to perform an operation based on a pathname (e.g. an io_open
message). Depending upon the type of connect message sent, a context block (see OCB) may be
associated with the request and will be passed to subsequent I/O messages. See also combine
message and I/O message.
connection
A kernel object used with message
passing.
Created by client threads to "connect" to the
channels made available by servers. Once connections are established, clients can MsgSendv()
messages over them. If a number of threads in a process all attach to the same channel, then the one
connection is shared between all the threads. Channels and connections are identified within a
process by a small integer. See also channel.
The key thing to note is that connections
and file descriptors are one and the same object under Neutrino.
context
Information retained between invocations of
functionality.
When using a resource manager, the client sets up an
association or context within the resource manager by issuing an open() call and
getting back a file descriptor. The resource manager is responsible for storing the information
required by the context (see OCB). When the client issues further file-descriptor based
messages, the resource manager uses the OCB to determine the context for interpretation of the
client's messages.
cooked mode
See canonical mode.
critical section
A code passage that must be executed
"serially" (i.e. by only one thread at a time). The simplest from of critical section enforcement is
via a mutex.
deadlock
A condition in which one or more threads are unable
to continue due to resource contention. A common form of deadlock can occur when one thread sends a
message to another, while the other thread sends a message to the first. Both threads are now waiting
for each other to reply to the message. Deadlock can be avoided by good design practices or massive
kludges - we recommend the good design approach.
device driver
A process that allows the OS and application
programs to make use of the underlying hardware in a generic way (e.g. a disk drive, a network
interface). Unlike OSs that require device drivers to be tightly bound into the OS itself, device
drivers for QNX® Neutrino are standard processes that can be started and stopped dynamically. As a
result, adding device drivers doesn't affect any other part of the OS - drivers can be developed and
debugged like any other application. Also, device drivers are in their own protected address space,
so a bug in a device driver won't cause the entire OS to shut down.
dynamic linking
The process whereby you link your modules in such a
way that the Process Manager will link them to the library modules before your program runs. The word
"dynamic" here means that the association between your program and the library modules that it uses
is done at load time, not at linktime. Contrast static linking. See also runtime
loading.
dynamic bootfile
A Neutrino image built on the fly. Contrast
static bootfile.
edge-sensitive
One of two ways in which a PIC (Programmable
Interrupt Controller) can be programmed to respond to interrupts. In edge-sensitive mode, the
interrupt is "noticed" only when the interrupt line transits from clear to asserted. Contrast with
level-sensitive.
edited mode
See canonical mode.
EPROM
Erasable Programmable Read-Only Memory - a memory
technology that allows the device to be programmed (typically with higher-than-operating voltages,
e.g. 12V), with the characteristic that any bit (or bits) may be individually programmed from a 1
state to a 0 state. To change a bit from a 0 state into a 1 state can only be accomplished by erasing
the entire device, setting all of the bits to a 1 state. Erasing is accomplished by
shining an ultraviolet light through the erase window of the device for a fixed period of time
(typically 10-20 minutes). The device is further characterized by having a limited number of erase
cycles (typically 10e5 - 10e6). Contrast with flash and RAM
EOI
End Of Interrupt - a command that the OS sends to
the PIC after processing all Interrupt Service Routines (ISR) for that particular interrupt source so
that the PIC can reset the processor's In Service Register. See also PIC and
ISR.
event
A notification scheme used to inform a thread that a
particular condition has occurred. Events can be signals or pulses in the general case; they can also
be unblocking events or interrupt events in the case of kernel timeouts and interrupt service
routines. An event is delivered by a thread, a timer, the kernel, or an interrupt service routine
when appropriate to the requestor of the event.
FD
File Descriptor - a client must open a file
descriptor to a resource manager via the open() function call. The file descriptor then serves
as a handle for the client to use in subsequent messages. Note that a file descriptor is the exact
same object as a connection ID (coid, returned by ConnectAttach()).
FIFO
First In First Out - a scheduling algorithm whereby
a thread is able to consume CPU at its priority level without bounds (contrast round
robin).
flash memory
A memory technology similar in characteristics to
EPROM memory, with the exception that erasing is performed electrically instead of via
ultraviolet light, and, depending upon the organization of the flash memory device, erasing may be
accomplished in blocks (typically 64k bytes at a time) instead of the entire device. Contrast with
EPROM and RAM
garbage collection
AKA space reclamation, the process whereby a
filesystem manager recovers the space occupied by deleted files and directories.
handle
A pointer that the resource manager base library
binds to the pathname registered via resmgr_pathname_attach(). This handle is typically used
to associate some kind of per-device information. Note that if you use the iofunc_*() POSIX
layer calls, you must use a particular type of handle - in this case called an
attributes structure.
image
In the embedded Neutrino world, an "image" can mean
either a structure that contains files (i.e. a Neutrino image) or a structure that can be used in a
read-only, read/write, or read/write/reclaim FFS-2-compatible filesystem (i.e. a flash filesystem
image).
interrupt
An event (usually caused by hardware) that
interrupts whatever the processor was doing and asks it do something else. The hardware will generate
an interrupt whenever it has reached some state where software intervention is
required.
interrupt handler
See ISR.
interrupt latency
The amount of elapsed time between the generation of
a hardware interrupt and the first instruction executed by the relevant interrupt service routine.
Also designated as "Til". Contrast with scheduling latency.
interrupt service routine
See ISR.
interrupt service thread
A thread that is responsible for performing
thread-level servicing of an interrupt.
Since the number of functions that an ISR can
call is very limited, and the amount of time spent in an ISR should be kept to a minimum, it
is generally desirable to have the bulk of the interrupt servicing work done by a thread. The thread
attaches the interrupt (via InterruptAttach()) and then blocks (via InterruptWait()),
waiting for the ISR to tell it to do something (by returning an event of type SIGEV_INTR). To aid in
minimizing scheduling latency, the interrupt service thread should raise its priority
appropriately.
I/O message
A message that relies on an existing binding between
the client and the resource manager. For example, an _IO_READ message depends on the client's having
previously established an association (or context) with the resource manager by issuing an
open() and getting back a file descriptor. See also connect message, context,
and combine message.
I/O Privity
A particular x86 processor-specific privilege, that,
if enabled for a given thread, allows the thread to perform I/O instructions (the x86 assembler
in and out instructions). By default,
I/O Privity is disabled, because a program with it enabled can wreak havoc on a system. To enable it,
the thread must be running as root, and call
ThreadCtl().
IPC
Interprocess Communication - the ability for two
processes (or threads) to communicate. Neutrino offers several forms of IPC, most notably native
messaging (synchronous, client/server relationship), POSIX message queues and pipes (asynchronous),
as well as signals.
IPL
Initial Program Loader - the software component
that either takes control at the processor's reset vector (e.g. location 0xFFFFFFF0 on the x86), or
is a BIOS extension. This component is responsible for setting up the machine into a usable state,
such that the startup program can then perform further initializations. The IPL is written in
assembler. See also BIOS extension signature and startup code.
IRQ
Interrupt Request - a hardware request line asserted
by a peripheral to indicate that it requires servicing by software. The IRQ is handled by the
PIC, which then interrupts the processor, usually causing the processor to execute an
Interrupt Service Routine (ISR).
ISR
Interrupt Service Routine - a routine responsible
for servicing hardware (e.g. reading and/or writing some device ports), for updating some data
structures shared between the ISR and the thread(s) running in the application, and for signalling
the thread that some kind of event has occurred.
level-sensitive
One of two ways in which a PIC (Programmable
Interrupt Controller) can be programmed to respond to interrupts. If the PIC is operating in
level-sensitive mode, the IRQ is considered active whenever the corresponding hardware line is
active. Contrast edge-sensitive.
linearly mapped
A term indicating that a certain memory component is
entirely addressable by the processor. Contrast bank-switched.
mount structure
A optional, well-defined data structure (of type
iofunc_mount_t) within an iofunc_*() structure, which contains
information used on a per-mountpoint basis (generally used only for filesystem resource managers).
See also attributes structure and OCB.
mountpoint
The location in the pathname space where a resource
manager has "registered" itself. For example, the serial port resource manager registers mountpoints
for each serial device (/dev/ser1,
/dev/ser2, etc.), and a CD-ROM filesystem may register a single
mountpoint of /cdrom.
mutex
Mutual exclusion lock, a simple synchronization
service used to ensure exclusive access to data shared between threads. It is typically acquired
(pthread_mutex_lock()) and released (pthread_mutex_unlock()) around the code that
accesses the shared data (usually a critical section). See also critical
section.
NMI
Nonmaskable Interrupt - an interrupt that cannot be
masked by the processor.
nonbootable
A nonbootable Neutrino image is usually provided for
larger embedded systems or for small embedded systems where a separate, configuration-dependent setup
may be required. Think of it as a second "filesystem" that has some additional files on it. Since
it's non-bootable, it typically won't contain the OS, startup file, etc.
OCB
Open Control Block (or Open Context Block) - a block
of data established by a resource manager during its handling of the client's open() function.
This context block is bound by the resource manager to this particular request, and is then
automatically passed to all subsequent I/O functions generated by the client on the file descriptor
returned by the client's open().
pathname prefix
See mountpoint.
pathname space mapping
The process whereby the Process Manager maintains an
association between resource managers and entries in the pathname space.
persistent
When applied to storage media, the ability for the
medium to retain information across a power-cycle. For example, a hard disk is a persistent storage
medium, whereas a ramdisk is not, because the data is lost when power is lost.
PIC
Programmable Interrupt Controller - hardware
component that handles IRQs. See also edge-sensitive, level-sensitive, and
ISR.
POSIX
An IEEE/ISO standard. The term is an acronym (of
sorts) for Portable Operating System Interface - the "X" alludes to "UNIX", on which the interface is
based.
POSIX layer calls
Convenient set of library calls for writing resource
managers. The POSIX layer calls can handle even more of the common-case messages and functions than
the base layer calls. These calls are identified by the iofunc_*() prefix. In order to
use these (and we strongly recommend that you do), you must also use the well-defined POSIX-layer
attributes (iofunc_attr_t), OCB
(iofunc_ocb_t), and (optionally) mount
(iofunc_mount_t) structures.
preemption
The act of suspending the execution of one thread
and starting (or resuming) another. The suspended thread is said to have been "preempted" by the new
thread. In Neutrino, whenever a lower-priority thread is actively consuming the CPU, and a
higher-priority thread becomes READY, the lower-priority thread is immediately preempted by the
higher-priority thread.
prefix tree
The internal representation used by the Process
Manager to store the pathname table.
priority inheritance
The characteristic of a thread that causes its
priority to be raised or lowered to that of the thread that sent it a message. Also used with
mutexes. Priority inheritance is a method used to prevent priority inversion.
priority inversion
A condition that can occur when a low-priority
thread consumes CPU at a higher priority than it should. This can be caused by not supporting
priority inheritance, such that when the lower-priority thread sends a message to a higher-priority
thread, the higher-priority thread consumes CPU on behalf of the lower-priority thread. This
is solved by having the higher-priority thread inherit the priority of the thread on whose behalf
it's working.
process
A non-schedulable entity, which defines the address
space and a few data areas. In Neutrino, a process must have at least one thread running in it
- this thread is then called the main thread.
pty
Pseudo-TTY - a character-based device that has two
"ends": a master end and a slave end. Data written to the master end shows up on the slave end, and
vice versa. These devices are typically used to interface between a program that expects a character
device and another program that wishes to use that device (e.g. the shell and the
telnet daemon process, used for logging in to a system over the
Internet).
pulses
In addition to the synchronous Send/Receive/Reply
services, Neutrino also supports fixed-size, non-blocking messages known as pulses. These
carry a small payload (four bytes of data plus a single byte code). A pulse is also one form of
event that can be returned from an ISR or a timer. See MsgDeliverEvent() for more
information.
RAM
Random Access Memory - a memory technology
characterized by the ability to read and write any location in the device without limitation.
Contrast with flash and EPROM.
raw mode
In raw input mode, the character device library
performs no editing on received characters. This reduces the processing done on each character to a
minimum and provides the highest performance interface for reading data. Also, raw mode is used with
devices that typically generate binary data - you don't want any translations of the raw binary
stream between the device and the application.
reset vector
The address at which the processor begins executing
instructions after the processor's reset line has been activated. On the x86, for example, this is
the address 0xFFFFFFF0.
resource manager
See device driver.
round robin
Scheduling algorithm whereby a thread is given a
certain period of time to run. Should the thread consume CPU for the entire period of its timeslice,
the thread will be placed at the end of the ready queue for its priority, and the next available
thread will be made READY. If a thread is the only thread READY at its priority level, it will be
able to consume CPU again immediately.
runtime loading
The process whereby a program decides while it's
actually running that it wishes to load a particular function from a library. Contrast static
linking.
scheduling latency
The amount of time that elapses between one thread
making another thread READY and the other thread actually getting some CPU time. Note that this
latency is almost always at the control of the system designer.
Also designated as "Tsl". Contrast with
interrupt latency.
software interrupts
Similar to a hardware interrupt (see
interrupt), except that the source of the interrupt is software.
startup code
The software component that gains control after the
IPL code has performed the minimum necessary amount of initialization. After gathering information
about the system, the startup code loads the OS and transfers control.
static bootfile
An image created at one time and then transmitted
whenever a node boots. Contrast dynamic bootfile.
static linking
The process whereby you combine your modules with
the modules from the library to form a single executable that's entirely self-contained. The word
"static" implies that it's not going to change - all the required modules are already
combined into one executable. Contrast dynamic linking.
system page area
An area in the kernel that is filled by the startup
code and contains information about the system (number of bytes of memory, location of serial ports,
etc.) This is also called the SYSPAGE area.
timer
A kernel object used in conjunction with time-based
functions. A timer is created via timer_create() and armed via timer_settime(). A timer
can then deliver an event, either periodically or on a one-shot basis.
timeslice
A period of time assigned to a round-robin
scheduled thread. This period of time is small (on the order of tens of milliseconds); the actual
value shouldn't be relied upon by any program (it's considered bad design).
thread
The schedulable entity under Neutrino. A thread is a
flow of execution; it exists within the context of a process.
<<
Previous | Index
|
