- administrator
- See
superuser.
- alias
- A shell feature that lets you create new commands or specify your
favorite options.
For example, alias my_ls='ls -F' creates an alias called
my_ls that the shell replaces with ls -F.
- atomic
- Of or relating to atoms. :-)
In operating 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 position 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 position to a different location, thus causing
the original thread to read data from the second thread's
position.
- 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.
- budget
- In
sporadic
scheduling, the amount of time a
thread is permitted to execute at its normal priority before
being dropped to its low priority.
- buildfile
- A text file containing instructions for mkifs
specifying the contents and other details of an
image,
or for mkefs specifying the
contents and other details of an embedded filesystem 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. Contrast
raw mode.
- channel
- A kernel object used with message passing.
In Neutrino, message passing is directed towards
a
connection
(made to a channel); threads
can receive messages from channels.
A thread that wishes to receive messages creates a channel (using ChannelCreate()), and
then receives messages from that channel (using MsgReceive()).
Another thread that wishes to send a message to the first thread must make
a connection to that channel by “attaching” to
the channel (using ConnectAttach()) and then sending data
(using MsgSend()).
- CIFS
- Common Internet File System (aka SMB) — a protocol that allows
a client workstation to perform transparent file access over
a network to a Windows 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.
- command completion
- A shell feature that saves typing;
type enough of the command's name to identify it
uniquely, and then press Esc twice.
If possible, the shell fills in the rest of the name.
- command interpreter
- A process that parses what you type on the command line; also known
as a
shell.
- compound command
- A command that includes a shell's reserved words, grouping constructs,
and function definitions (e.g. ls -al | less).
Contrast
simple command.
- configurable limit
- A special variable that stores system information.
Some (e.g. _PC_NAME_MAX) depend on the filesystem and
are associated with a path;
others (e.g. _SC_ARG_MAX) are independent of paths.
- configuration string
- A system variable that's like an environment variable, but is more dynamic.
When you set an environment variable, the new value affects only the
current instance of the shell and any of its children that you create
after setting the variable;
when you set a configuration string, its new value is immediately available
to the entire system.
- connection
- A kernel object used with message passing.
Connections are created by client threads to “connect” to
the channels made available by servers. Once connections are
established, clients can MsgSend() messages over
them.
- console
- The display adapter, the screen, and the system keyboard are collectively
referred to as the physical console.
A virtual console emulates a physical console and lets you
run more than one terminal session at a time on a machine.
- cooked mode
- See
canonical mode.
- core dump
- A file describing the state of a process that terminated abnormally.
- 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.
- 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 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.
- DNS
- Domain Name Service —
an Internet protocol used to convert ASCII domain names
into IP addresses. In QNX native networking, dns
is one of
Qnet's
builtin resolvers.
- 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” upon a transition to/from the
rising/falling edge of a pulse. Contrast
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
EEPROM,
flash,
and
RAM.
- EEPROM
- Electrically Erasable Programmable Read-Only Memory —
a memory technology that's similar to
EPROM, but you can
erase the entire device electrically instead of via ultraviolet light.
Contrast
flash
and
RAM.
- 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 requester of the event.
- extent
- A contiguous sequence of blocks on a disk.
- 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.
- FIFO
- First In First Out — a scheduling algorithm
whereby a thread is able to consume CPU at its priority
level without bounds. See also
round robin
and
sporadic.
- filename completion
- A shell feature that saves typing;
type enough of the file's name to identify it
uniquely, and then press Esc twice.
If possible, the shell fills in the rest of the name.
- filter
- A program that reads from standard input and writes to standard output,
such as
grep,
sort,
and
wc.
You can use a pipe (|) to combine filters.
- flash memory
- A memory technology similar in characteristics to
EEPROM
memory, with the exception that erasing is
performed electrically,
and, depending upon the organization of the flash memory
device, erasing may be accomplished in blocks (typically 64 KB
bytes at a time) instead of the entire device. Contrast
EPROM
and
RAM.
- FQNN
- Fully Qualified Node Name —
a unique name that identifies a Neutrino node
on a network. The FQNN consists of the
nodename plus the node domain tacked together.
- garbage collection
- The process whereby a filesystem
manager recovers the space occupied by deleted files and
directories.
Also known as space reclamation.
- group
- A collection of users who share similar file permissions.
- HA
- High Availability — in telecommunications and
other industries, HA describes a system's ability to remain
up and running without interruption for extended periods of
time.
- hard link
- See
link.
- hidden file
- A file whose name starts with a dot (.), such as
.profile.
Commands such as ls don't operate on hidden files unless you
explicitly say to.
- image
- In the context of embedded Neutrino systems, an “image”
can mean either a structure that contains files
(i.e. an OS image) or a structure that can be used in a
read-only, read/write, or read/write/reclaim filesystem
(i.e. a flash filesystem image).
- inode
- Information node — a storage table that holds information about
files, other than the files' names.
In order to support links for each file, the filename is
separated from the other information that describes a file.
- 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 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
scheduling latency.
- 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 and C. See also
BIOS/ROM Monitor 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.
- kernel
- See
microkernel.
- 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.
- link
- A filename; a pointer to the file's contents.
Contrast
symbolic link.
- message
- A parcel of bytes passed from one process to another.
The OS attaches no special meaning to the content of a message —
the data in a message has meaning for the
sender of the message and for its receiver, but for no one else.
Message passing not only allows processes to pass data to each
other, but also provides a means of synchronizing the execution of
several processes. As they send, receive, and reply to messages,
processes undergo various “changes of state” that affect when, and for
how long, they may run.
- metadata
- Data about data; for a filesystem, metadata includes all the overhead
and attributes involved in storing the user data itself, such as the name
of a file, the physical blocks it uses, modification and access timestamps,
and so on.
- microkernel
- A part of the operating system that provides the minimal services used
by a team of optional cooperating processes, which in turn provide the
higher-level OS functionality.
The microkernel itself lacks filesystems and many other
services normally expected of an OS; those services are provided by
optional processes.
- mountpoint
- The location in the pathname space where a resource
manager has “registered” itself. For example,
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).
- name resolution
- In a Neutrino network, the process by which the
Qnet
network manager converts an
FQNN to a list of destination
addresses that the transport layer knows how to get to.
- name resolver
- Program code that attempts to convert an
FQNN
to a destination address.
- NDP
- Node Discovery Protocol — proprietary QNX Software Systems
protocol for broadcasting name resolution requests on a
Neutrino LAN.
- network directory
- A directory in the pathname space that's
implemented by the
Qnet
network manager.
- Neutrino
- Product name of the RTOS developed by QNX Software Systems.
- NFS
- Network FileSystem — a TCP/IP application that lets you graft
remote filesystems (or portions of them) onto your local namespace.
Directories on the remote systems appear as part of
your local filesystem and all the utilities you use for listing and managing
files (e.g. ls, cp, mv) operate on the
remote files exactly as they do on your local files.
- Node Discovery Protocol
- See
NDP.
- node domain
- A character string that the
Qnet
network manager tacks onto the nodename to form an
FQNN.
- nodename
- A unique name consisting of a character string that
identifies a node on a network.
- package
- A directory tree of files laid out in a structure that matches
where they would be if they were transported to the root of some
filesystem.
- package filesystem
- A virtual filesystem manager that presents a customized view of a set
of files and directories to a client.
The “real” files are present on some media;
the package filesystem presents
a virtual view of selected files to the client.
|
Neutrino doesn't start the package filesystem by default.
|
- 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
media to retain information across a power-cycle. For
example, a hard disk is a persistent storage media, whereas
a ramdisk is not, because the data is lost when power is
lost.
- Photon microGUI
- The proprietary graphical user interface built by QNX Software Systems.
- PIC
- Programmable Interrupt Controller — a hardware
component that handles IRQs.
- PID
- Process ID. Also often pid (e.g. as an
argument in a function call). See also
process ID.
- 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.
- 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.
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 nonschedulable entity, which defines the address
space and a few data areas. A process must
have at least one
thread
running in it.
- process group
- A collection of processes that permits the signalling of
related processes. Each process in the system is a member of
a process group identified by a process group ID. A newly
created process joins the process group of its creator.
- process group ID
- The unique identifier representing a process group during
its lifetime. A process group ID is a positive integer. The
system may reuse a process group ID after the process group
dies.
- process group leader
- A process whose ID is the same as its process group ID.
- process ID (PID)
- The unique identifier representing a process. A PID is a
positive integer. The system may reuse a process ID after
the process dies, provided no existing process group has the
same ID. Only the Process Manager can have a process ID of
1.
- 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.
You typically use these devices
when a program requires a terminal for standard input and
output, and one doesn't exist, for example as with sockets.
- Qnet
- The native network manager in Neutrino.
- QNX
- Name of an earlier-generation RTOS created by QNX
Software Systems. Also, short form of the company's name.
- QoS
- Quality of Service — a policy (e.g. loadbalance) used to connect nodes in a network in
order to ensure highly dependable transmission. QoS is an
issue that often arises in high-availability
(HA)
networks as
well as realtime control systems.
- QSS
- QNX Software Systems.
- quoting
- A method of forcing a shell's special characters to be treated as simple
characters instead of being interpreted in a special way by the shell.
For example, less "my file name" escapes the special meaning of
the spaces in a filename.
- RAM
- Random Access Memory — a memory technology characterized
by the ability to read and write any location in the device without
limitation.
Contrast
flash,
EPROM,
and
EEPROM.
- 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.
Contrast
canonical mode.
- remote execution
- Running commands on a machine other than your own over a network.
- replenishment
- In
sporadic
scheduling, the period of time during which
a thread is allowed to consume its execution
budget.
- 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
- A user-level server program that accepts messages from
other programs and, optionally, communicates with hardware.
Neutrino resource managers are responsible for presenting an
interface to various types of devices, whether actual (e.g.
serial ports, parallel ports, network cards, disk drives) or
virtual (e.g. /dev/null, a network
filesystem, and pseudo-ttys).
In other operating systems, this functionality is
traditionally associated with
device drivers.
But
unlike device drivers, Neutrino resource managers don't require
any special arrangements with the kernel. In fact, a
resource manager looks just like any other user-level
program. See also device driver.
- root
- The superuser, which can do anything on your system.
The superuser has what Windows calls administrator's rights.
- round robin
- Scheduling algorithm whereby a thread is given a
certain period of time (the
timeslice)
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. See also
FIFO
and
sporadic.
- RTOS
- Realtime operating system.
- 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 the point when
one thread makes another thread READY and when the other
thread actually gets some CPU time. Note that this latency
is almost always at the control of the system designer.
Also designated as “Tsl”.
Contrast
interrupt latency.
- session
- A collection of process groups established for job-control purposes.
Each process group is a member of a
session. A process belongs to the session that its process
group belongs to. A newly created process joins the session
of its creator. A process can alter its session membership
via setsid(). A session can contain multiple
process groups.
- session leader
- A process whose death causes all processes within its
process group to receive a SIGHUP signal.
- shell
- A process that parses what you type on the command line; also known
as a
command interpreter.
- shell script
- A file that contains shell commands.
- simple command
- A command line that contains a single command, usually a program that you
want to run (e.g. less my_file).
Contrast
compound command.
- socket
- A logical drive in a flash filesystem,
consisting of a contiguous and homogeneous region of flash memory.
- socket
- In TCP/IP, a combination of an IP address and a port number that
uniquely identifies a single network process.
- software interrupt
- Similar to a hardware interrupt (see
interrupt),
except that the source of the
interrupt is software.
- spilling
- What happens when you try to change a file that the package filesystem
manages (if you're using it):
a copy of the file is transferred to the spill directory.
- sporadic
- Scheduling algorithm whereby a thread's priority can
oscillate dynamically between a “foreground” or
normal priority and a “background” or low
priority. A thread is given an execution
budget
of time to be consumed within a certain
replenishment
period. See also
FIFO
and
round robin.
- 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 transfers control to the OS.
- static linking
- The process whereby you combine your programs 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.
Contrast
runtime loading.
- superuser
- The root user, which can do anything on your system.
The superuser has what Windows calls administrator's rights.
- symbolic link
- A special file that usually has a pathname as its data.
Symbolic links are a flexible means of pathname indirection
and are often used to provide multiple paths to a single file.
Unlike hard links, symbolic links can cross
filesystems and can also create links to directories.
- 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.
- thread
- The schedulable entity under Neutrino. A thread is a
flow of execution; it exists within the context of a
process.
- 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 (four times the clock period in Neutrino);
programs shouldn't rely on the actual value (doing so is considered bad
design).