- . (dot)
A special file name that refers to the
current directory.
It can be used alone or
at the beginning of a directory path name.
See also
path name resolution.
The
dot
also functions as a special command in the
Bourne and Korn shells, and has special meaning in
text editors and formatters, in parsing regular
expressions and in designating file names.
- .. (dot-dot)
A special file name that refers to the
parent directory.
If it begins a
path name,
dot-dot
refers to the parent of the current directory.
If it occurs in a path name,
dot-dot
refers to the parent directory of the directory preceding
dot-dot
in the path name string.
As a special case,
dot-dot
refers to the current directory in any directory
that has no parent (most often, the
root directory).
See also
path name resolution.
- .o (dot-oh)
The suffix customarily given to a relocatable object file.
The term
dot-oh file
is sometimes used to refer to a relocatable object file.
The format of such files is sometimes called
dot-oh format.
See
a.out(4).
- a.out
The name customarily given to an executable object code file on HP-UX.
The format is machine-dependent, and is described in
a.out(4)
for each implementation.
Object code that is not yet linked has the same format,
but is referred to as a
.o
(dot-oh)
file.
a.out
is also the default output file name used by the linker,
ld(1).
- absolute path name
A path name beginning with a slash
(/).
It indicates that the file's location is given relative to the
root directory
(/),
and that the search begins there.
- access
The process of obtaining data from or placing data in storage,
or the right to use system resources.
Accessibility is governed by three process characteristics:
the effective user ID,
the effective group ID,
and the group access list.
The
access(2)
system call determines accessibility of a file according
to the bit pattern contained in its
amode
parameter, which is constructed to read, write, execute or
check the existence of a file.
The
access(2)
system call uses the
real user ID
instead of the
effective user ID
and the
real group ID
instead of the
effective group ID.
- access groups
The group access list is a set of
supplementary group IDs
used in determining resource accessibility.
Access checks
are performed as described below in
file access permissions.
- access mode
An access mode is a form of access permitted to a file.
Each implementation provides separate read, write, and
execute/search access modes.
- address
A number used in information storage or retrieval to
specify and identify memory location.
An
address
is used to mark, direct,
indicate destination, instruct or otherwise communicate
with computer elements.
In mail,
address
is a data structure whose format can be recognized by all
elements involved in transmitting information.
On a local
system, this might be as simple as the user's
login
name,
while in a networked system,
address
specifies the location of the resource to the
network software.
In
a text editor (such as
vi,
ex,
ed,
or
sed),
an
address
locates the line in a file on which a given instruction is
intended.
For
adb,
the
address
specifies at what assembly-language instruction to execute
a given command.
In disk utilities such as
fsdb,
address
might refer to a raw or
block special file,
the
inode
number,
volume header,
or other file attribute.
In the context of peripheral devices,
address
refers to
a set of values that specify
the location of an I/O device to the computer.
The exact details of the formation of an address differ between systems.
On Series 700 systems, the address consists of
up to two elements: the
select code,
and the
function number.
- address space
The range of memory locations to which a process can refer.
- affiliation
See
terminal affiliation.
- appropriate privileges
Each implementation provides a means of
associating privileges with a process
for function calls and function call options requiring special privileges.
In the HP-UX system,
appropriate privileges
refers either to superuser status or to a privilege
associated with privilege groups (see
setprivgrp(1M)).
- archive
A file comprised of the contents of other files, such as a group
of object files (that is,
.o)
used by the linker,
ld(1)).
An archive file is created and maintained by
ar(1)
or similar programs, such as
tar(1)
or
cpio(1).
An
archive
is often called a
library.
- ASCII
An acronym for American Standard Code for Information Interchange.
ASCII is the traditional
System V coded character set and defines 128 characters,
including both control characters and graphic characters,
each of which is
represented by 7-bit binary values ranging from 0 through 127 decimal.
- background process group
Any process group that is a member of a session which has
established a connection with a controlling terminal that is
not in the foreground process group.
- backup
The process of making a copy of all or part of the file system
in order to preserve it, in case a system crash occurs (usually due to
a power failure, hardware error, etc.).
This is a highly recommended
practice.
- block
(1) The fundamental unit of information HP-UX
uses for access and storage allocation on a mass storage medium.
The size of a block varies between implementations and between
file systems.
In order to present a more uniform interface to the user,
most system calls and utilities use
block
to mean 512 bytes,
independent of the actual block size of the medium.
This is the
meaning of
block
unless otherwise specified in the manual entry.
(2) On media such as 9-track tape that write variable length
strings of data, the size of those strings.
Block
is often
used to distinguish from
record;
a block contains several records, whereas the number of records
denotes the blocking factor.
- block special file
A special file associated with a mass storage device (such as a
hard disk or
tape cartridge drive) that transfers data in
multiple-byte blocks, rather than by series of individual
bytes (see
character special file).
Block special files
can be mounted.
A
block special file
provides access to the device where
hardware characteristics of the device are not visible.
- boot, boot-up
The process of loading, initializing, and running an operating system.
- boot area
A portion of a mass storage medium
on which the volume header and a ``bootstrap'' program used in
booting the operating system reside.
The
boot area
is reserved exclusively for use by HP-UX.
- boot ROM
A program residing in ROM (Read-Only Memory)
that executes each time the computer is powered up
and is designed to bring the computer to a desired state by
means of its own action.
The first few instructions of a
bootstrap program are
sufficient to bring the remainder of the program into the
computer from an input device and initiate functions
necessary for computation.
The function
of the boot ROM is to run tests on the computer's hardware, find
all devices accessible through the computer, and then load either
a specified operating system or the first operating system found
according to a specific search algorithm.
- bus address
A number which makes up part of the address HP-UX uses to locate
a particular device.
The
bus address
is determined by a switch setting on a peripheral device
which allows the computer to distinguish between two devices
connected to the same interface.
A
bus address
is sometimes called a ``device address''.
- character
An element used for the organization, control, or
representation of text.
Characters include
graphic characters
and
control characters.
- character set
A set of characters used to communicate
in a native or computer language.
- character special file
A special file
associated with I/O devices
that transfer data
byte-by-byte.
Other byte-mode I/O
devices include printers, nine-track
magnetic tape drives, and disk drives when accessed
in ``raw'' mode (see
raw disk).
A
character special file
has no predefined structure.
- child process
A new process created by a pre-existing process via the
fork(2)
system call.
The new process is thereafter known to the pre-existing
process as its
child process.
The pre-existing process is the
parent process
of the new process.
See
parent process
and
fork.
- clock tick
A rate used within the system for scheduling and accounting.
It consists of the number of intervals per second as defined by
CLK_TCK
that is used to express the value in type
clock_t.
CLK_TCK
was previously known as the defined constant
HZ.
- coded character set
A set of unambiguous rules that establishes a character set
and the one-to-one relationship between each character of the set
and its corresponding bit representation.
ASCII
is a
coded character set.
- collating element
The smallest entity used in collation to determine the
logical ordering of strings (that is, the
collation sequence).
To accommodate native languages, a collating element consists
of either a single character, or two or more characters
collating as a single entity.
The current value of the
LANG
environment variable determines the current set of collating elements.
- collation
The logical ordering of strings in a predefined sequence
according to rules established by precedence.
These rules
identify a collation sequence among the collating elements
and also govern the ordering of strings consisting of multiple
collating elements, to accommodate native languages.
- collation sequence
The ordering sequence applied to
collating elements
when they are sorted.
To accommodate native languages,
collation sequence
can be thought of as the
relative order of
collating elements
as set by the current value of the
LANG
environment variable.
Characters can be omitted from the collation sequence, or
two or more collating elements can be given the same
relative order (see
string(3C)).
- command
A directive to perform a particular task.
HP-UX commands are executed through a
command interpreter
called a
shell.
HP-UX supports several shells, including the Bourne shell
(
sh-bourne(1)),
the POSIX shell
(
sh-posix(1)),
the C shell
(
csh(1)),
and
the Korn shell
(
ksh(1)).
See
sh(1)
for more information about supported shells.
Most commands are carried out by an executable file, called a
utility,
which might take the form of a stand-alone unit of executable object code
(a program) or a file containing a list of other programs to execute
in a given order (a shell script).
Scripts can contain references to other scripts,
as well as to object-code programs.
A typical
command
consists of the utility name followed by
arguments that are passed to the utility.
For example, in the command, ``ls mydirectory'', ``ls'' is the
utility name and ``mydirectory'' is an argument passed to the
``ls'' utility.
- command interpreter
A program which reads lines of text from standard input
(typed at the keyboard or read from
a file), and interprets them as requests to execute other programs.
A command interpreter for HP-UX is called a
shell.
See
sh(1)
and related manual entries.
- Command Set 1980
See
CS/80.
- composite graphic symbol
A graphic symbol consisting of a combination of two or more
other graphic symbols in a single character position,
such as a diacritical mark and a basic letter.
- control character
A character other than a graphic character
that affects the recording,
processing, transmission, or interpretation of text.
In the
ASCII
character set,
control characters
are those in the range 0 through 31, and 127.
Control characters can be generated by holding down the control key
(which may be labeled CTRL, CONTROL, or CNTL depending on your terminal),
and pressing a character key (as you would use SHIFT).
These two-key sequences are often written as, for example,
Control-D,
Ctrl-D,
or
^D,
where
^
stands for the control key.
- controlling process
The session leader that establishes the connection
to the
controlling terminal.
Should the terminal subsequently cease to be a controlling terminal
for this session, the session leader ceases to be the controlling
process.
- controlling terminal
A terminal that is associated with a session.
Each session can have at most one controlling terminal
associated with it and a controlling terminal is
associated with exactly one session.
Certain input sequences from the controlling terminal
cause signals to be sent to all processes in the foreground
process group associated with the controlling terminal.
- Coordinated Universal Time (UTC)
See
Epoch.
- CS/80, CS-80
A family of mass storage devices that communicate
with the controlling computer by means of a series
of commands and data transfer protocol referred to as the
CS/80
(Command Set 1980) command set.
This command set was implemented in order to provide
better forward/backward compatibility between models
and generations of mass storage devices as technological advances develop.
Some mass storage devices support only a subset of the full
CS/80
command set, and are usually referred to as
SS/80
(Subset 1980)
devices.
- crash
The unexpected shutdown of a program or system.
If the operating system crashes,
this is a ``system crash'', and requires the system to be re-booted.
- current directory
See
working directory.
- current working directory
See
working directory.
- daemon
A process which runs in the background, and which is usually immune to
termination instructions from a terminal.
Its purpose is to perform various scheduling, clean-up, and maintenance
jobs.
lpsched(1M)
is an example of a
daemon.
It exists to perform these functions for line printer jobs queued by
lp(1).
An example of a permanent
daemon
(that is, one that should never die) is
cron(1M).
- data encryption
A method for encoding information in order to protect sensitive or
proprietary data.
For example,
HP-UX automatically encrypts all users' passwords.
The encryption method used by HP-UX converts
ASCII text into a base-64 representation using the alphabet
.,
/,
0-9,
A-Z,
a-z.
See
passwd(4)
for the numerical equivalents associated with this alphabet.
- default search path
The sequence of directory prefixes that
sh(1),
time(1),
and other HP-UX commands apply in searching for a file
known by an relative path name
(that is, a path name not beginning with a
slash
(/)).
It is defined by the environment variable
PATH
(see
environ(5)).
login(1)
sets
PATH
equal to
:/usr/bin,
which means that your working directory is the first directory searched,
followed by
/usr/bin.
The search path can be redefined by modifying the value of
PATH.
This is usually done in
/etc/profile,
and/or in the
.profile
file found in the home directory.
- delta
A term used in the
Source Code Control System
(SCCS) to describe a unit of one or more textual changes to an
SCCS file.
Each time an SCCS file is edited,
changes made to the file are stored separately as a
delta.
The
get(1)
command is then used to specify which deltas are to be applied to
or excluded from the SCCS file,
thus yielding a particular version of the file.
Contrast this with the
vi
or
ed
editor, which incorporates changes into the file immediately,
eliminating any possibility of obtaining a previous version of that file.
A similar capability is provided by RCS files (see
rcsintro(5)).
- demon
Improper spelling of the UNIX word
daemon.
- device
A computer peripheral or an object that appears to an
application as such.
- device address
See
bus address.
- device file
See
special file.
- directory
A file that provides the mapping between the names of files
and their contents, and is manipulated by the operating system alone.
For every file name contained in a directory,
that directory contains a pointer to the file's
inode;
The pointer is called a
link.
A file can have several links appearing anywhere on the same file system.
Each user is free to create as many directories as needed (using
mkdir(1)),
provided that the
parent directory
of the new directory gives the permission to do so.
Once a directory has been created,
it is ready to contain ordinary files and other directories.
An HP-UX directory is named and behaves exactly like an ordinary file,
with one exception:
no user (including the superuser) is allowed to
write data on the directory itself; this privilege is reserved for the
HP-UX operating system.
By convention, a directory contains at least two links,
.
and
..,
referred to as
dot
and
dot-dot
respectively.
Dot
refers to the directory itself and
dot-dot
refers to its
parent directory.
A directory containing only
.
and
..
is considered empty.
- dot
See
.
(dot).
- dot-dot
See
..
(dot-dot).
- dot-oh
See
.o
(dot-oh).
- dot-oh file
See
.o
(dot-oh).
- dot-oh format
See
.o
(dot-oh).
- downshifting
The conversion of an uppercase character
to its lowercase representation.
- dynamic loader
A routine invoked at process startup time
that loads shared libraries into a process' address space.
The dynamic loader also resolves symbolic references
between a program and the shared libraries,
and initializes the shared libraries' linkage tables.
See
dld.sl(5)
for details.
- effective group ID
Every process has an
effective group ID
that is used to determine
file access permissions.
A process's
effective group ID
is determined by the file (command) that process is executing.
If that file's set-group-ID bit is set
(located in the mode of the file, see
mode),
the process's
effective group ID
is set equal to the file's group ID.
This makes the process appear to belong to the file's group,
perhaps enabling the process to access files
that must be accessed in order for the program to execute successfully.
If the file's set-group-ID bit is not set, the process's
effective group ID
is inherited from the process's parent.
The setting of the process's
effective group ID
lasts only as long as
the program is being executed, after which the process's effective group ID
is set equal to its real group ID.
See
group,
real group ID,
and
set-group-ID bit.
- effective user ID
A process has an
effective user ID
that is used to determine
file access permissions
(and other permissions with respect to system
calls, if the effective user ID is 0, which means superuser).
A process's effective user ID is determined by the file (command)
that process is executing.
If that file's set-user-ID bit is set (located
in the mode of the file, see
mode),
the process's effective user ID is set equal to the file's user ID.
This makes the process appear to be the file's owner,
enabling the process to access files which must be accessed
in order for the program to execute successfully.
(Many HP-UX commands which are owned by
root,
such as
mkdir
and
mail,
have their set-user-ID bit set so other users can execute these commands.)
If the file's set-user-ID bit is not set, the process's effective
user ID is inherited from that process's parent.
See
real user ID
and
set-user-ID bit.
- end-of-file (EOF)
(1)
The data returned when attempting to read past the
logical end of a file via
stdio(3S)
routines.
In this case, end-of-file is not properly a character.
(2)
The ASCII character
Ctrl-D.
(3)
A character defined by
stty(1)
or
ioctl(2)
(see
termio(7))
to act as end-of-file on your terminal.
Usually this is
Ctrl-D.
(4)
The return value from
read(2)
that indicates end of data.
- environment
The set of defined shell variables (such as
EXINIT,
HOME,
PATH,
SHELL,
TERM,
and others) that define the conditions under which user commands run.
These conditions can include user terminal characteristics,
home directory, and default search path.
Each shell variable setting in the current process is passed on to all
child processes
that are created, provided that each shell variable setting
has been exported via the
export
command (see
sh(1)).
Unexported shell variable settings are meaningful only to the current
process, and any child processes created get the default settings
of certain shell variables by executing
/etc/profile,
$HOME/.profile,
or
$HOME/.login.
- EOF
See
end-of-file.
- Epoch
The time period beginning at 0 hours, 0 minutes, 0 seconds,
Coordinated Universal Time
(UTC)
on January 1, 1970.
Increments quantify the amount of time elapsed from
the Epoch to the referenced time.
Leap seconds, which occur at irregular intervals,
are not reflected in the count of seconds between
the Epoch and the referenced time.
(Fourteen leap seconds occurred in the years 1970 through 1988.)
- FIFO special file
A type of
file.
Data written to a
FIFO
is read on a first-in-first-out basis.
Other characteristics are described in
open(2),
read(2),
write(2)
and
lseek(2).
- file
A stream of bytes that can be written to and/or read from.
A
file
has certain attributes, including permissions and type.
File types include
regular file,
character special file,
block special file,
FIFO special file,
network special file,
directory,
and
symbolic link.
Every file must have a
file name
that enables the user (and many of the HP-UX commands)
to refer to the contents of the file.
The system imposes no particular
structure on the contents of a file, although some programs do.
Files can be accessed serially or randomly
(indexed by byte offset).
The interpretation of file contents
and structure is up to the programs that access the file.
- file access mode
A characteristic of an
open file description
that determines whether the described file is open for
reading, writing, or both.
(See
open(2).)
- file access permissions
Every file in the
file hierarchy
has a set of access permissions.
These permissions are used in determining
whether a process can perform a requested operation on
the file (such as opening a file for writing).
Access
permissions are established when a file is
created via the
open(2)
or
creat(2)
system calls, and
can be changed subsequently
through the
chmod(2)
call.
These permissions are read by
stat(2)
or
fstat(2).
File access controls whether a file
can be read, written, or executed.
Directory files
use the execute permission to control whether or not the directory
can be searched.
File access permissions
are interpreted by the system
as they apply to three different classes of users: the
owner
of the file, the users in the file's
group,
and
anyone else (``other'').
Every file has an independent set of
access permissions for each of these classes.
When an
access check is made, the system decides if permission
should be granted by checking the access information
applicable to the caller.
Read, write, and execute/search permissions on a file
are granted to a process if any of the following
conditions are met:
The process's
effective user ID
is superuser.
The process's
effective user ID
matches the user ID
of the owner of the file
and the appropriate access bit of the
owner
portion (0700) of the file mode is set.
The process's
effective user ID
does not match the user ID
of the owner of the file,
and either the process's
effective group ID
matches the group ID
of the file, or the group ID
of the file is in the process's group access list,
and the appropriate access bit of the
group
portion (070) of the file mode is set.
The process's
effective user ID
does not match the user ID
of the owner of the file,
and the process's
effective group ID
does not match the group ID
of the file,
and the group ID
of the file is not in the process's group access list,
and the appropriate access bit of the ``other'' portion (07) of the
file mode is set.
Otherwise, the corresponding permissions are denied.
- file descriptor
A small
unique, per-process, nonnegative
integer identifier
that is used to refer to a file opened for reading and/or writing.
Each
file descriptor
refers to exactly one
open file description.
A
file descriptor
is obtained
through system calls such as
creat(2),
fcntl(2),
open(2),
pipe(2),
or
dup(2).
The
file descriptor
is used as an argument by calls such as
read(2),
write(2),
ioctl(2),
and
close(2).
The value of a
file descriptor
has a range from 0 to one less than the system-defined maximum.
The system-defined maximum is the value
NOFILE
in
<sys/param.h>.
- file group class
A process is in the
file group class
of a file if the process is not the
file owner class
and if the
effective group ID
or one of the
supplementary group IDs
of the process matches the group ID associated with the file.
- file hierarchy
The collection of one or more
file systems
available on a system.
All
files
in these
file systems
are organized in a single hierarchical structure
in which all of the nonterminal nodes are
directories.
Because multiple
links
can refer to the same
file,
the directory is properly described as a directed graph.
- file name
A string of up to 14 bytes
(or 255 bytes on file systems that support long file names)
used to refer to an ordinary file, special file, or directory.
The byte values NUL (null)
and slash
(/)
cannot be used as characters in a file name.
Note that it is generally unwise to use
*,
?,
,,
[,
or
]
as part of file names because the shell attaches
special meaning to these characters (see
sh(1),
csh(1),
or
ksh(1)).
Avoid beginning a file name with
-,
+,
or
=,
because to some programs,
these characters signify that a command argument follows.
A file name is sometimes called a path name component.
Although permitted, it is inadvisable to use characters
that do not have a printable graphic on the hardware
you commonly use, or that are likely to confuse your terminal.
- file name portability
File names should be constructed from the
portable file name character set
because the use of other characters can
be confusing or ambiguous in certain contexts.
- file offset
The file offset specifies the position in the file where
the next I/O operation begins.
Each
open file description
associated with either a regular file or special file has a
file offset.
There is no file offset specified for a
pipe
or
FIFO.
- file other class
A process is in the
file other class
if the process is not in the
file owner class
or
file group class.
- file owner class
A process is in the
file owner class
if the
effective user ID
of the process matches the user ID of the file.
- file permission bits
See
permission bits.
- file pointer
A data element obtained through any of the
fopen(3S)
standard I/O library routines
that ``points to'' (refers to) a file opened for reading
and/or writing, and which keeps track of where the next
I/O operation will take place in the file
(in the form of a byte offset relative to the beginning of the file).
After obtaining the file pointer, it must thereafter be used to
refer to the open file when using any of the standard
I/O library routines.
(See
stdio(3S)
for a list of these routines.)
- file serial number
A file-system-unique identifier for a given file,
also known as the file's
inode number.
Each
file serial number
identifies exactly one
inode.
File serial numbers
are not necessarily unique across
file systems
in the
file hierarchy.
- file status flags
Part of an
open file description.
These flags can be used to modify the behavior of system calls
that access the file described by the
open file description.
- file system
A collection of
files
and supporting data structures residing on a mass storage volume.
A file system provides a name space for
file serial numbers
referring to those files.
Refer to the System Administrator manuals
supplied with your system for details
concerning file system implementation and maintenance.
- file times update
Each file has three associated time values that are
updated when file data is accessed or
modified, or when the file status is changed.
These values are returned in the file
characteristics structure, as described in
<sys/stat.h>.
For each function in HP-UX
that reads or writes file data or changes the file status, the appropriate
time-related files are noted as ``marked-for-update''.
When an update point occurs, any marked fields are set to the
current time and the update marks are cleared.
One such update point occurs when the file
is no longer open for any process.
Updates are not performed for files on
read-only file systems.
- filter
A command that reads data from the standard input, performs a
transformation on the data, and writes it to the standard output.
- foreground process group
Each session that has established a connection with a
controlling terminal has exactly one process group of the session
as a foreground process group of that controlling terminal.
The foreground process group has certain privileges
when accessing its controlling terminal that are denied to
background process groups.
See
read(2)
and
write(2).
- foreground process group ID
The process group ID of the foreground process group.
- fork
An HP-UX
system call (see
fork(2)),
which, when invoked by an existing process, causes a new process to
be created.
The new process is called the
child process;
the existing process is called the
parent process.
The child process is created by making an exact copy of the parent process.
The parent and child processes are able to identify themselves
by the value returned by their corresponding
fork
call (see
fork(2)
for details).
- function number
On Series 700 systems,
when two or more interfaces reside on a single interface card,
each interface is treated as a separate
function
and is assigned a corresponding unique function number.
- graphic character
A character other than a control character
that has a visual representation when hand-written, printed,
or displayed.
- group
See
group ID.
- group ID
Associates zero or more users
who must all be permitted to access the same set of files.
The members of a group are defined in the files
/etc/passwd
and
/etc/logingroup
(if it exists) via a numerical group ID
that must be between zero and
UID_MAX,
inclusive.
Users with identical group IDs
are members of the same group.
An ASCII group name is associated with each group ID in the file
/etc/group.
A group ID is also associated with every file in the
file hierarchy,
and the mode of each file contains a set of permission bits
that apply only to this group.
Thus, if you belong to a group that is associated with a file,
and if the appropriate permissions are granted to your group in the
file's mode, you can access the file.
When the identity of a group is associated with a process,
a group ID value is referred to as
a
real group ID,
an
effective group ID,
a
supplementary group ID,
or a
saved group ID.
See also
privileged group
and
set-group-ID bit.
- group access list
A set of
supplementary group IDs
used in determining resource accessibility.
Access checks are performed as described in
file access permissions.
- hierarchical directory
A directory (or file system)
structure in which each directory can contain other directories
as well as files.
- home directory
The directory name given by the value of the environment variable
HOME.
When you first log in,
login(1)
automatically sets
HOME
to your
login directory.
You can change its value at any time.
This is usually done in the
.profile
file contained in your
login directory.
Setting
HOME
does not affect your
login directory;
it simply gives you a convenient way of referring to
what is probably your most commonly used directory.
- host name
An ASCII string of at most 8 characters
(of which only 6 are supported by all the various manufacturers'
UNIX-like operating systems)
which uniquely identifies an HP-UX system on a
uucp(1)
network.
The
host name
for your system can be viewed and/or set with the
hostname(1)
command.
Systems without a defined host name are described as ``unknown'' on the
uucp(1)
network.
Do not confuse a host name with a
node name,
which is a string that uniquely identifies an HP-UX
system on a Local Area Network (LAN).
Although your host and node names may be identical,
they are set and used by totally different software.
See
node name.
- image
The current state of your computer (or your portion of the computer,
on a multiuser system) during the execution of a command.
Often thought of as a ``snapshot'' of the state of the machine at any
particular moment during execution.
- init
A
system process
that performs initialization,
is the ancestor of every other process in the system,
and is used to start
login
processes.
init
usually has a
process ID
of
1.
See
init(1M).
- interleave factor
A number that determines the order in which sectors on a mass storage medium
are accessed.
It can be optimized to make data acquisition more efficient.
- inode
An
inode
is a structure that describes a file
and is identified in the system by a
file serial number.
Every file or directory has associated
with it an
inode.
Permissions that specify who can access the
file and how are kept in a 9-bit field that is part of the
inode.
The
inode
also contains the file size, the user and group ID of the
file,
the number of links, and pointers to the disk blocks where
the file's contents can be found.
Each connection between
an
inode
and its entry in one or more directories is called a
link.
- inode number
See
file serial number.
- Internal Terminal Emulator (ITE)
The ``device driver'' code contained in the HP-UX
kernel that is associated with the computer's built-in keyboard and display
or with a particular keyboard and display connected to the computer,
depending on the Series and Model of system processor.
See
system console
and the System Administrator manuals supplied with your system for details.
- internationalization
The concept of providing software with the ability to support
the
native language,
local customs,
and
coded character set
of the user.
- interrupt signal
The signal sent by
SIGINT
(see
signal(2)).
This signal generally terminates whatever program you are running.
The key which sends this signal can be redefined with
ioctl(2)
or
stty(1)
(see
termio(7)).
It is often the ASCII DEL (rubout) character (the DEL key) or the BREAK key.
Ctrl-C
is often used instead.
- intrinsic
See
system call.
- I/O redirection
A mechanism provided by the HP-UX
shell for changing the source of data for standard input
and/or the destination of data for standard output and standard error.
See
sh(1).
- ITE
See
Internal Terminal Emulator.
- job control
Job control allows users to selectively stop (suspend)
execution of processes and continue (resume) their execution at a later time.
The user employs this facility via the interactive interface
jointly supplied by the system terminal driver and certain shells (see
sh(1)).
The terminal driver recognizes a user-defined ``suspend character'',
which causes the current foreground process group to stop
and the user's job control shell to resume.
The job control shell provides commands that continue
stopped process groups in either the foreground or background.
The terminal driver also stops a background process group
when any member of the background process group
attempts to read from or write to the user's terminal.
This allows the user to finish or suspend the
foreground process group
without interruption and continue the stopped
background process group
at a more convenient time.
See
stty(1),
sh(1),
and related shell entries for usage and installation details, and
the shell entries plus
signal(2)
and
termio(7)
for implementation details.
- kernel
The HP-UX operating system.
The kernel is the executable code
responsible for managing the computer's resources,
such as allocating memory, creating processes,
and scheduling programs for execution.
The kernel resides in RAM (random access memory) whenever HP-UX is running.
- LANG
An environment variable
used to inform a computer process of the user's requirements for
native language,
local customs,
and
coded character set.
- library
A file containing a set of subroutines and variables
that can be accessed by user programs.
Libraries can be either archives or shared libraries.
For example,
/usr/lib/libc.a
and
/usr/lib/libc.sl
are libraries containings all functions of Section 2
and all functions of Section 3 that are marked (3C) and (3S) in the
HP-UX Reference Manual.
Similarly,
/usr/lib/libm.a
and
/usr/lib/libm.sl
are libraries containing all functions in Section 3
that are marked (3M) in the
HP-UX Reference Manual.
See
intro(2)
and
intro(3).
- LIF
See
Logical Interchange Format.
- line
A sequence of text characters consisting of zero or more
nonnewline characters plus a terminating newline character.
- link
Link
is a synonym for
directory entry.
It is an object that associates a file name with any type of file.
The information constituting a
link
includes the name of the file and where the contents of that file
can be found on a mass storage medium.
One physical file can have several links to it.
Several directory entries can associate names with a given file.
If the links appear in different directories,
the file may or may not have the same name in each.
However, if the links appear in one directory,
each link must have a unique name in that directory.
Multiple links to directories are not allowed
(except as created by a user with appropriate privileges).
See
ln(1),
link(2),
unlink(2),
and
symbolic link.
Also, to prepare a program for execution; see
linker.
- link count
The number of directory entries that refer to a particular file.
- linker
A program that combines one or more object programs into one program,
searches libraries to resolve user program references,
and builds an executable file in
a.out
format.
This executable file is ready to be executed through the program loader,
exec(2).
The linker is invoked with the
ld(1)
command.
The linker is often called a
link editor.
- local customs
The conventions of a geographical area or territory
for such things as date, time and currency formats.
- localization
The process of adapting existing software to meet the
local language, customs, and character set requirements of a particular
geographical area.
- Logical Interchange Format (LIF)
A standard format for mass storage
implemented on many Hewlett-Packard computers
to aid in media transportability.
The
lif*(1)
commands are used to perform various LIF functions.
- login
The process of gaining access to HP-UX.
This consists of successful execution of the
login
sequence defined by
login(1),
which varies depending on the system configuration.
It requests a
login
name and possibly one or more passwords.
- login directory
The directory in which you are placed immediately after you log in.
This directory is defined for each user in the file
/etc/passwd.
The shell variable
HOME
is set automatically to your
login directory
by
login(1)
immediately after you log in.
See
home directory.
- magic number
The first word of an
a.out-format
or archive file.
This word contains the system ID, which states what machine
(hardware) the file will run on, and the file type (executable,
sharable executable, archive, etc.).
- major number
A number used exclusively to create special files that enable I/O
to or from specific devices.
This number indicates which device driver
to use for the device.
Refer to
mknod(2)
and the System Administrator manual supplied with your system for details.
- message catalog
Program strings, such as program messages and prompts, are stored in a
message catalog
corresponding to a particular geographical area.
Retrieval of a string from a
message catalog
is based on the value of the user's
LANG
environment variable (see
LANG).
- message queue identifier (msqid)
A unique positive integer created by a
msgget(2)
system call.
Each
msqid
has a message queue and a data structure associated with it.
The data structure is referred to as
msqid_ds
and contains the following members:
struct ipc_perm msg_perm; /* operation permission */
ushort msg_qnum; /* number of msgs on q */
ushort msg_qbytes; /* max number of bytes on q */
ushort msg_lspid; /* pid of last msgsnd operation */
ushort msg_lrpid; /* pid of last msgrcv operation */
time_t msg_stime; /* last msgsnd time */
time_t msg_rtime; /* last msgrcv time */
time_t msg_ctime; /* last change time */
/* Times measured in secs since */
/* 00:00:00 GMT, Jan. 1, 1970 */
Message queue identifiers can be created using
ftok(3C).
msg_perm
is a
ipc_perm
structure that specifies the message operation permission (see below).
This structure includes the following members:
ushort cuid; /* creator user id */
ushort cgid; /* creator group id */
ushort uid; /* user id */
ushort gid; /* group id */
ushort mode; /* r/w permission */
msg_qnum
is the number of messages currently on the queue.
msg_qbytes
is the maximum number of bytes allowed on the queue.
msg_lspid
is the process id of the last process that performed a
msgsnd
operation.
msg_lrpid
is the process id of the last process that performed a
msgrcv
operation.
msg_stime
is the time of the last
msgsnd
operation,
msg_rtime
is the time of the last
msgrcv
operation, and
msg_ctime
is the time of the last
msgctl(2)
operation that changed a member of the above structure.
- message operation permissions
In the
msgop(2)
and
msgctl(2)
system call descriptions, the permission required for an operation
is indicated for each operation.
Whether a particular process has these permissions for an object
is determined by the object's permission mode bits as follows:
00060
Read, Write by group
00006
Read, Write by others
Read and Write permissions on a
msqid
are granted to a process if one or more of the following are true:
The process's effective user ID is superuser.
The process's effective user ID matches
msg_perm.[c]uid
in the data structure associated with
msqid
and the appropriate bit of the ``user'' portion (0600) of
msg_perm.mode
is set.
The process's effective user ID does not match
msg_perm.[c]uid
and either the process's effective group ID matches
msg_perm.[c]gid
or one of
msg_perm.[c]gid
is in the process's group access list
and the appropriate bit of the ``group'' portion
(00060) of
msg_perm.mode
is set.
The process's effective user ID does not match
msg_perm.[c]uid
and the process's effective group ID does not match
msg_perm.[c]gid
and neither of
msg_perm.[c]gid
is in the process's group access list
and the appropriate bit of the ``other'' portion (06) of
msg_perm.mode
is set.
Otherwise, the corresponding permissions are denied.
- metacharacter
A character that has special meaning to the HP-UX shell,
as well as to commands such as
ed,
find,
and
grep
(see
ed(1),
find(1),
and
grep(1)).
The set of metacharacters includes:
!,
"
,
&,
',
*,
;,
<,
>,
?,
[,
],
`,
and
|.
Refer to
sh(1)
and the related shell manual entries
for the meaning associated with each.
See also
regular expression.
- minor number
A number that is an attribute of special files,
specified during their creation and used whenever they are
accessed, to enable I/O to or from specific devices.
This number is passed to the device driver and is used to select which
device in a family of devices is to be used, and possibly some operational
modes.
The exact format and meaning of the
minor number
is both system and
driver dependent.
Refer to the System Administrator manuals supplied with your
system for details.
On Series 700 systems, a
minor number
indicates the device address, function number,
and driver-dependent bits.
On Series 800 systems, a
minor number
is an index into a table in the
kernel.
- mode
A 16-bit word associated with every file in the file system,
stored in the
inode.
The least-significant 12 bits of
the
mode
determine the read, write, and execute permissions for the file owner,
file group, and all others, and contain the set-user-ID, set-group-ID,
and ``sticky'' (save text image after execution) bits.
The least-significant 12 bits can be set by the
chmod(1)
command if you are the file's owner or the superuser.
The sticky bit on a regular file can only be set by the superuser.
These 12 bits are sometimes referred to as
permission bits.
The most-significant 4 bits specify the file type for the associated
file and are set as the result of
open(2)
or
mknod(2)
system calls.
- mountable file system
A removable blocked file system contained on some mass storage medium
with its own root directory
and an independent hierarchy of directories and files.
See
block special file
and
mount(1M).
- msqid
See
message queue identifier.
- multiuser state
The condition of the HP-UX operating system in which terminals
(in addition to the system console)
allow communication between the system and its users.
By convention, multiuser run level is set at state 2,
which is usually defined to contain all the terminal processes and
daemons
needed in a multiuser environment.
Run levels are table driven, and are specified by
init(1M),
which sets the run level by looking at the file
/etc/inittab.
Do not confuse the multiuser system with the multiuser state.
A multiuser system is a system which can have more than one
user actively communicating with the system when it is in the
multiuser state.
The multiuser state removes the single-user
restriction imposed by the single-user state (see
single-user state,
inittab(4)).
- native language
A computer user's spoken or written language, such as
Chinese,
Dutch,
English,
French,
German,
Greek,
Italian,
Katakana,
Korean,
Spanish,
Swedish,
Turkish,
etc.
- Native Language Support (NLS)
A feature of HP-UX that provides the user with
internationalized software and the application programmer
with tools to develop this software.
- newline character
The character with an ASCII value of 10 (line feed)
used to separate lines of characters.
It is represented by
\n
in the C language and in various utilities.
The terminal driver
normally interprets a carriage-return/line-feed sequence
sent by a terminal as a single newline character
(but see
tty(7)
for full details)
- NLS
See
Native Language Support.
- NLSPATH
An environment variable used to indicate the search path for
message catalogs (see
message catalog).
- node name
A string of up to 31 characters, not including control characters or
spaces, that uniquely identifies a node on a Local Area Network (LAN).
The
node name
for each system is set by the
npowerup
command, which is one of the commands supplied
with optional LAN/9000 products.
Do not confuse a node name with a
host name,
which is a string that uniquely identifies an HP-UX system on a UUCP network.
Your node and host names can be identical,
but they are used and set by totally different software.
See
host name,
LAN/9000 User's Guide,
and
LAN/9000 Node Manager's Guide.
- nonspacing characters
Characters, such as a diacritical mark or accents,
that are used in combination with other characters
to form composite graphic symbols commonly found in non-English languages.
- open file
A file that is currently associated with a file descriptor.
- open file description
A record of how a process or a group of processes is accessing a file.
Each
file descriptor
refers to exactly one
open file description,
but an
open file description
can be referred to by more than one file descriptor.
The
file offset,
file status flags,
and
file access modes
are attributes of an
open file description.
- ordinary file
A type of HP-UX file containing
ASCII text (e.g., program source),
binary data (e.g., executable code), etc.
Ordinary files can be created by the user through I/O redirection,
editors, or HP-UX commands.
- orphan process
A
child process
that is left behind when a
parent process
terminates for any reason.
The
init
process (see
init(1M))
inherits (that is, becomes the effective parent of) all orphan processes.
- orphaned process group
A process group in which the parent of every member is either
itself a member of the group or is not a member of the group's session.
- owner
The owner of a file is usually the creator of that file.
However, the ownership of a file can be changed
by the superuser or the current owner with the
chown(1)
command or the
chown(2)
system call.
The file owner is able to do whatever he wants with his files,
including remove them, copy them, move them, change their contents, etc.
The owner can also change the files' modes.
- parent directory
The directory one level above a directory in
the
file hierarchy.
All directories except the
root directory
(/)
have one (and only one)
parent directory.
The
root directory
has no parent.
See also
dot
and
dot-dot.
- parent process
Whenever a new process is created by a currently-existing process
(via
fork(2)),
the currently existing process is said to be the parent process of
the newly created process.
Every process has exactly one parent
process (except the
init
process, see
init),
but each process
can create several new processes with the
fork(2)
system call.
The parent process ID of any process is the
process ID
of its creator.
- parent process ID
A new process is created by a currently active process.
The
parent process ID
of a process is the process ID of
its creator for the lifetime of the creator.
After the creator's lifetime has ended, the
parent process ID
is the process ID of
init.
- password
A string of ASCII characters used to verify the identity of a user.
Passwords can be associated with users and groups.
If a user has a password, it is automatically encrypted
and entered in the second field of that user's line in the
/etc/passwd
file.
A user can create or change his or her own password by using the
passwd(1)
command.
- path name
A sequence of directory names separated by slashes, and ending with any
file name.
All file names except the last in the sequence
must
be directories.
If a path name begins with a
slash
(/),
it is an
absolute path name;
otherwise, it is a
relative path name.
A path name defines the path to be followed through the hierarchical
file system in order to find a particular file.
More precisely, a path name is a null-terminated character string
constructed as follows:
<path-name>::=<file-name>|<path-prefix><file-name>|/
<path-prefix>::=<rtprefix>|/<rtprefix>
<rtprefix>::=<dirname>/|<rtprefix><dirname>/
where <file-name> is a string of one or more characters other than the
ASCII slash and null, and <dirname> is a string of one or more characters
(other than the ASCII slash and null) that names a directory.
File and directory names can consist of up to 14 characters on systems
supporting short file names and up to 255 characters on systems supporting
long file names.
A
slash
(/)
by itself names the
root directory.
Two or more slashes in succession
(////...)
are treated as a single slash.
Unless specifically stated otherwise, the null or zero-length path name
is treated as though it named a nonexistent file.
- path name resolution
The process that resolves a path name to a particular file in a
file hierarchy.
Multiple path names can resolve to the same file,
depending on whether resolution is sought in
absolute or relative terms (see below).
Each file name in the path name is located in the directory
specified by its predecessor (for example, in the path name fragment
a/b,
file
b
is located in directory
a).
Path name resolution
fails if this cannot be accomplished.
If the path name begins with a slash,
the predecessor of the first file name in the path name
is understood to be the
root directory
of the process, and the path name is referred to as an
absolute path name.
If the path name does not begin with a slash,
the predecessor of the first file name of the path name is understood
to be the current working directory of the process,
and the path name is referred to as a
relative path name.
A path name consisting of a single slash
resolves to the root directory of the process.
- path prefix
A
path name
with an optional ending
slash
that refers to a
directory.
- permission bits
The nine least-significant bits
of a file's
mode
are referred to as file
permission bits.
These bits determine read, write,
and execute permissions for the file's
owner,
the file's
group,
and
all others.
The bits are divided into three parts: owner, group and
other.
Each part is used with the corresponding file
class of processes.
The bits are contained in the file
mode, as described in
stat(5).
The detailed
usage of the file permission bits in access decisions is
described in
file access permissions.
- PIC
See
position-independent code.
- pipe
An interprocess I/O channel used to pass data between two processes.
It is commonly used by the
shell
to transfer data from the standard output of one process
to the standard input of another.
On a command line, a pipe is signaled by a vertical bar
(|).
Output from the command to the left of the vertical bar
is channeled directly into the standard input
of the command on the right.
- portable file name character set
The following set of graphical characters are
portable across conforming implementations of
IEEE Standard P1003.1:
ABCDEFGHIJKLMNOPQRSTUVWXYZ
abcdefghijklmnopqrstuvwxyz
01234567890._-
The last three characters are the dot, underscore and
hyphen characters, respectively.
The hyphen should not be
used as the first character of a portable file name.
- position-independent code (PIC)
Object code that can run unmodified at any virtual address.
Position-independent code can use PC-relative addressing modes
and/or linkage tables.
It is most often used in shared libraries,
in which case the linkage tables are initialized by the dynamic loader.
Position-independent code is generated when the
+z
or
+Z
compiler option is specified.
- privileged groups
A
privileged group
is a group that has had a
setprivgrp
(see
getprivgrp(2))
operation performed on it, giving it access to some system calls
otherwise reserved for the superuser.
See
appropriate privileges.
- process
An invocation of a program, or the execution of an image (see
image).
Although all commands and utilities are executed within processes,
not all commands or utilities have a one-to-one correspondence with processes.
Some commands (such as
cd)
execute within a process, but do not create any new processes.
Others (such as in the case of
ls | wc -l)
create multiple processes.
Several processes can be running the same program,
but each can be different data and be in different stages of execution.
A process can also be thought of as an
address space
and single thread of control that executes within that address space
and its required system resources.
A
process
is created by another process issuing the
fork(2)
function.
The process that issues
fork(2)
is known as the
parent process
and the new process created by the
fork(2)
as the
child process.
- process 1
See
init.
- process group
Each process in the system is a member of a
process group.
This grouping permits the signaling of related processes.
A newly created process joins the process group of its creator.
- process group ID
Each process group in the system is uniquely identified
during its lifetime by a
process group ID,
a positive integer less than or equal to
PIC_MAX.
A
process group ID
cannot be reused by the system until the process group lifetime ends.
- process group leader
A
process group leader
is a process whose process ID
is the same as its process group ID.
- process group lifetime
A period of time that begins when a
process group
is created and ends when the last remaining process in the group
leaves the group, either due to process termination or by calling the
setsid(2)
or
setpgid(2)
functions.
- process ID
Each active process in the system is uniquely identified
during its lifetime by a positive integer less than or
equal to
PID_MAX
called a
process ID.
A process ID cannot
be reused by the system until after the process lifetime ends.
In addition, if there exists a process group whose
process group ID is equal to that process ID,
the process ID cannot be reused by the system until
the process group lifetime ends.
A process that is not a system process
shall not have a process ID of 1.
- process lifetime
After a process is created with a
fork(2)
function, it is considered active.
Its thread of control and
address space
exist until it terminates.
It then enters an inactive state where certain resources
may be returned to the system, although some resources,
such as the
process ID
are still in use.
When another process executes a
wait(),
wait3(),
or
waitpid()
function (see
wait(2))
for an inactive process,
the remaining resources are returned to the system.
The last resource to be returned to the system is the process ID.
At this time, the lifetime of the process ends.
- program
A sequence of instructions to the computer in the form of binary code
(resulting from the compilation and assembly of program source).
- prompt
The characters displayed by the
shell
on the terminal indicating that the system is ready for a command.
The prompt is usually a dollar sign
($)
for ordinary users
(%
in the C shell)
and a pound sign
(#)
for the superuser,
but you can redefine it to be any string
by setting the appropriate shell variable
(see
sh(1)
and related entries).
See also
secondary prompt.
- quit signal
The
SIGQUIT
signal (see
signal(2).
The quit signal is generated by typing the
character defined by the teletype handler as your quit signal.
(See
stty(1),
ioctl(2),
and
termio(7).)
The default is the ASCII FS character (ASCII value 28)
generated by typing
Ctrl-\.
This signal usually causes a running program to terminate
and generates a file containing the ``core image''
of the terminated process.
The core image is useful for debugging purposes.
(Some systems do not support core images,
and on those systems no such file is generated.)
- radix character
The character that separates the integer part of a number
from the fractional part.
For example, in American usage, the
radix character
is a decimal point, while in Europe, a comma is used.
- raw disk
The name given to a disk for which there exists a
character special file
that allows direct transmission between the disk
and the user's read or write buffer.
A single read or write call results in exactly one I/O call.
- read-only file system
A characteristic of a
file system
that prevents file system modifications.
- real group ID
A positive integer which is assigned to every user on the system.
The association of a user and his or her
real group ID
is done in the file
/etc/passwd.
The modifier ``real'' is used because a user can also have an
effective group ID.
The real group ID can then be mapped to a group name in the file
/etc/group,
although it need not be.
Thus, every user is a member of some group (which can be nameless),
even if that group has only one member.
Every time a process creates a child process (via
fork(2)),
that process has a real group ID equal to the parent process's real group ID.
This is useful for determining file access privileges within the process.
- real user ID
A positive integer which is assigned to every user on the system.
A real user ID is assigned to every valid
login
name in the file
/etc/passwd.
The modifier ``real'' is used because a user can also have an
effective user ID
(see
effective user ID).
Every time a process creates a child process (via
fork(2)),
that process has a real user ID equal to the parent process's real user ID.
This is useful for determining file access privileges within the process.
- regular expression
A string of zero or more characters that selects text.
All the characters contained in the string might be literal,
meaning that the regular expression matches itself only;
or one or more of the characters might be a
metacharacter,
meaning that a single regular expression could match several literal strings.
Regular expressions are most often encountered in text editors (such as
ed(1),
ex(1),
or
vi(1)),
where searches are performed for a specific piece of text,
or in commands that were created to search for a particular
string in a file (most notably
grep(1)).
Regular expressions are also encountered in the shell,
especially when referring to file names on command lines.
- regular file
A type of
file
that is a randomly accessible sequence of bytes,
with no further structure imposed by the system.
Its size can be extended.
A regular file is also called an
ordinary file.
- relative path name
A
path name
that does not begin with a
slash
(/).
It indicates that a file's location is given relative to your current
working directory,
and that the search begins there (instead of at the
root directory).
For example,
dir1/file2
searches for the directory
dir1
in your current working directory; then
dir1
is searched for the file
file2.
- root directory
(1) The highest level directory of the hierarchical file system,
from which all other files branch.
In HP-UX, the
slash
(/)
character refers to the
root directory.
The root directory is the only directory in the file system that is its own
parent directory.
(2)
Each process has associated with it a concept of a root directory
for the purpose of resolving path name searches
for those paths beginning with
slash
(/).
A process's root directory need not be the root directory
of the root file system, and can be changed by the
chroot(1M)
command or
chroot(2)
system call.
Such a directory appears to the process involved to be
its own parent directory.
- root volume
The mass storage volume which contains
the boot area (which contains the HP-UX kernel)
and the
root directory
of the HP-UX file system.
- saved group ID
Every process has a saved group ID that retains the process's
effective group ID
from the last successful
exec(2)
or
setresgid()
(see
setresuid(2)),
or from
the last superuser call to
setgid()
(see
setuid(2))
or
setresuid(2).
setgid()
permits a process to set its effective group ID to this remembered value.
Consequently, a process that executes a program with the set-group-ID
bit set and with a group ID of 5 (for example)
can set its effective group ID to 5
at any time until the program terminates.
See
exec(2),
setuid(2),
saved user ID,
effective group ID,
and
set-group-ID bit.
The saved group ID is also known as the
saved set-group-ID.
- saved process group ID
Every process has a saved process group ID that retains
the process's group ID from the last successful
exec(2).
See
setpgrp(2),
termio(7),
and
process group ID.
- saved user ID
Every process has a
saved user ID
that retains the process's
effective user ID
from the last successful
exec(2)
or
setresuid(2),
or from the last superuser call to
setuid(2).
setuid(2)
permits a process to set its effective user ID to this remembered value.
Consequently, a process which executes a program with the set-user-ID
bit set and with an owner ID of 5 (for example) can set its effective
user ID to 5 at any time until the program terminates.
See
exec(2),
setuid(2),
saved group ID,
effective user ID,
and
set-user-ID bit.
The saved user ID is also known as the
saved set-user-ID.
- saved set-group-ID
See
saved group ID.
- saved set-user-ID
See
saved user ID.
- SCCS
See
Source Code Control System.
- Source Code Control System (SCCS)
A set of HP-UX commands that enables you to store changes to an
SCCS file
as separate ``units'' (called
deltas).
These units, each of which contains one or more textual changes to the file,
can then be applied to or excluded from the SCCS file
to obtain different versions of the file.
The commands that make up SCCS are
admin(1),
cdc(1),
delta(1),
get(1),
prs(1),
rmdel(1),
sact(1),
sccsdiff(1),
unget(1),
val(1),
and
what(1).
- SCCS file
An ordinary text file that has been modified so the
Source Code Control System
(SCCS)
can be used with it.
This modification is done automatically by the
admin(1)
command.
See also
delta.
- secondary prompt
One or more characters that the shell prints on the display,
indicating that more input is needed.
This prompt is not encountered nearly as frequently as
the shell's primary prompt (see
prompt).
When it occurs, it is usually caused by an omitted right quote on a string
(which confuses the shell),
or when you enter a shell programming language control-flow construct
(such as a
for
construct) from the command line.
By default, the shell's secondary prompt is the greater-than sign
(>),
but you can re-define it by setting the shell variable
PS2
appropriately in your
.profile
file.
(The C shell has no secondary prompt.)
- select code
On Series 700 systems, part of an
address
used for devices.
Multiple peripherals connected to the same interface card
share the same select code.
On Series 700 systems,
select code
consists of the bus and slot numbers for a device,
both of which are determined by the particular I/O slot
in which the I/O card resides.
All functions on a multifunction card share the same select code.
- semaphore identifier (semid)
A unique positive integer created by a
semget(2)
system call.
Each
semid
has a set of semaphores and a data structure associated with it.
The data structure is referred to as
semid_ds
and contains the following members:
struct ipc_perm sem_perm; /* operation permission */
ushort sem_nsems; /* number of sems in set */
time_t sem_otime; /* last operation time */
time_t sem_ctime; /* last change time */
/* Times measured in secs since */
/* 00:00:00 GMT, Jan. 1, 1970 */
Semaphore identifiers can be created using
ftok(3C).
sem_perm
is a ipc_perm structure that
specifies the semaphore operation permission (see below).
This structure includes the following members:
ushort cuid; /* creator user id */
ushort cgid; /* creator group id */
ushort uid; /* user id */
ushort gid; /* group id */
ushort mode; /* r/a permission */
The value of
sem_nsems
is equal to the number of semaphores in the set.
Each semaphore in the set is referenced by a positive integer
referred to as a
sem_num.
sem_num
values run sequentially from 0 to the value of sem_nsems minus 1.
sem_otime
is the time of the last
semop(2)
operation, and
sem_ctime
is the time of the last
semctl(2)
operation that changed a member of the above structure.
A semaphore is a data structure that contains the following members:
ushort semval; /* semaphore value */
short sempid; /* pid of last operation */
ushort semncnt; /* # awaiting semval > cval */
ushort semzcnt; /* # awaiting semval = 0 */
semval
is a nonnegative integer.
sempid
is equal to the process ID
of the last process that performed a semaphore operation on this semaphore.
semncnt
is a count of the number of processes that are currently suspended
awaiting this semaphore's
semval
to become greater than its current value.
semzcnt
is a count of the number of processes that are currently suspended
awaiting this semaphore's
semval
to become zero.
- semaphore operation permissions
In the
semop(2)
and
semctl(2)
system call descriptions, the permission required for an operation
is indicated for each operation.
Whether a particular process has these permissions for an object
is determined by the object's permission mode bits as follows:
00060
Read, Alter by group
00006
Read, Alter by others
Read and Alter permissions on a
semid
are granted to a process if one or more of the following are true:
The process's effective user ID is superuser.
The process's effective user ID matches
sem_perm.[c]uid
in the data structure associated with
semid
and the appropriate bit of the ``user'' portion (0600) of
sem_perm.mode
is set.
The process's effective user ID does not match
sem_perm.[c]uid
and the appropriate bit of the ``group'' portion (060) of
sem_perm.mode
is set.
The process's effective user ID does not match
sem_perm.[c]uid
and the process's effective group ID does not match
sem_perm.[c]gid
and neither of
sem_perm.[c]gid
is in the process's group access list
and the appropriate bit of the ``other'' portion (06) of
sem_perm.mode
is set.
Otherwise, the corresponding permissions are denied.
- semid
See
semaphore identifier.
- session
Each process group is a member of a session.
A process is considered to be a member of
the session of which its process group is a member.
A newly created process joins the session of its creator.
A process can alter its session membership (see
setsid(2)).
A session can have multiple process groups (see
setpgid(2)).
- session leader
A process that has created a session (see
setsid(2)).
- session lifetime
The period between when a session is created and the end of
the lifetime of all process groups that remain as members
of the session.
- set-group-ID bit
A single bit in the mode of every file in the file system.
If a file is executed whose
set-group-ID bit
is set, the
effective group ID
of the process which executed the file
is set equal to the
real group ID
of the owner of the file.
See also
group.
- set-user-ID bit
A single bit in the mode of every file in the file system.
If a file is executed whose
set-user-ID bit
is set, the
effective user ID
of the process that executed the file is set equal to the
real user ID
of the owner of the file.
- shared library
An executable file that can be shared
between several different programs.
Code from a shared library is not linked into the program by
ld(1),
but is instead mapped into the process' address space at run time
by the dynamic loader.
Shared libraries must contain position-independent code,
and are created by
ld(1).
They typically have the file name suffix
.sl.
- shared memory identifier (shmid)
A unique positive integer created by a
shmget(2)
system call.
Each
shmid
has a segment of memory (referred to as a shared memory segment)
and a data structure associated with it.
The data structure is referred to as
shmid_ds
and contains the following members:
struct ipc_perm shm_perm; /* operation permission struct */
int shm_segsz; /* size of segment */
ushort shm_cpid; /* creator pid */
ushort shm_lpid; /* pid of last operation */
short shm_nattch; /* number of current attaches */
time_t shm_atime; /* last attach time */
time_t shm_dtime; /* last detach time */
time_t shm_ctime; /* last change time */
/* Times measured in secs since */
/* 00:00:00 GMT, Jan. 1, 1970 */
Shared memory identifiers can be created using
ftok(3C).
shm_perm
is a
ipc_perm
structure that specifies the permission for a
shmop(2)
or
shmctl(2)
operation (see below).
This structure includes the following members:
ushort cuid; /* creator user id */
ushort cgid; /* creator group id */
ushort uid; /* user id */
ushort gid; /* group id */
ushort mode; /* r/w permission */
shm_segsz
specifies the size of the shared memory segment.
shm_cpid
is the process id of the process that created the shared memory identifier.
shm_lpid
is the process id of the last process that performed a
shmop(2)
operation.
shm_nattch
is the number of processes that currently have this segment attached.
shm_atime
is the time of the last
shmat
operation,
shm_dtime
is the time of the last
shmdt
operation,
and
shm_ctime
is the time of the last
shmctl(2)
operation that changed one of the members of the above structure.
- shared memory operation permissions
In the
shmop(2)
and
shmctl(2)
system call descriptions, the permission required for an operation
is indicated for each operation.
Whether a particular process has the permission to perform a
shmop(2)
or
shmctl(2)
operation on an object
is determined by the object's permission mode bits as follows:
00060
Read, Write by group
00006
Read, Write by others
Read and Write permissions for a
shmop(2)
or
shmctl(2)
operation on a
shared memory identifier
(shmid)
are granted to a process if one or more of the following are true:
The process's effective user ID is superuser.
The process's effective user ID matches
shm_perm.[c]uid
in the data structure associated with the
shmid
and the appropriate bit of the ``user'' portion (0600) of
shm_perm.mode
is set.
The process's effective user ID does not match
shm_perm.[c]uid
and either the process's effective group ID matches
shm_perm.[c]gid
or one of
shm_perm.[c]gid
is in the process's group access list and the appropriate bit
of the ``group'' portion (060) of
shm_perm.mode
is set.
The process's effective user ID does not match
shm_perm.[c]uid
and the process's effective group ID does not match
shm_perm.[c]gid
and neither of
shm_perm.[c]gid
is in the process's group access list
and the appropriate bit of the ``other'' portion (06) of
shm_perm.mode
is set.
Otherwise, the corresponding permissions are denied.
- shell
A user interface to the HP-UX operating system.
A shell often functions as both a command interpreter and
an interpretive programming language.
A shell is automatically invoked for every user who logs in.
See
sh(1)
and its related manual entries plus the tutorials
supplied with your system for details.
- shell program
See
shell script.
- shell script
A sequence of shell commands and shell programming language constructs
stored in a file and invoked as a user command (program).
No compilation is needed prior to execution
because the shell recognizes the commands and constructs
that make up the shell programming language.
A shell script is often called a
shell program
or a
command file.
See the
Shells User Guide.
- shmid
See
shared memory identifier.
- signal
A software interrupt sent to a process,
informing it of special situations or events.
Also, the event itself.
See
signal(2).
- single-user state
A condition of the HP-UX operating system
in which the system console provides
the only communication mechanism between the system and its user.
By convention, single-user state is usually specified by
init(1M)
as run-level
S
or
s.
Do not confuse
single-user state,
in which the software is limiting a multiuser system
to a single-user communication,
with a single-user system,
which can never communicate with more than one fixed terminal.
See also
multiuser state.
- slash
The literal character
/.
A
path name
consisting of a single slash resolves to the
root directory
of the process.
See also
path name resolution.
- solidus
See
slash.
- source code
The fundamental high-level information (program)
written in the syntax of a specified computer language.
Object (machine-language) code is derived from source code.
When dealing with an HP-UX shell command language,
source code
is input to the command language interpreter.
The term
shell script
is synonymous with this meaning.
When dealing with the C Language,
source code
is input to the
cc(1)
command.
Source code
can also refer to a collection of sources meeting
any of the above conditions.
- special file
A file associated with an I/O device.
Often called a
device file.
Special files are read and written the same as
ordinary files,
but requests to read or write result in activation of the associated device.
Due to convention and consistency,
these files should always reside in the
/dev
directory.
See also
file.
- special processes
Processes with certain (small) process IDs are special.
On a typical system, the IDs of 0, 1, and 2 are assigned
as follows:
Process 0 is the scheduler.
Process 1 is the initialization process
init,
and is the ancestor of every other process in the system.
It is used to control the process structure.
On paging systems with virtual memory, process 2 is the paging daemon.
- SS/80
See
CS/80.
- standard error
The destination of error and special messages from a program,
intended to be used for diagnostic messages.
The standard error output is often called
stderr,
and is automatically opened for writing on file descriptor 2
for every command invoked.
By default, the user's terminal is the destination of all data written to
stderr,
but it can be redirected elsewhere.
Unlike standard input and standard output,
which are never used for data transfer in the ``wrong'' direction,
standard error is occasionally read.
This is not recommended practice, since I/O
redirection is likely to break a program doing this.
- standard input
The source of input data for a program.
The standard input file is often called
stdin,
and is automatically opened for reading on file descriptor 0 for every
command invoked.
By default, the user's terminal is the source of all data read from
stdin,
but it can be redirected from another source.
- standard output
The destination of output data from a program.
The standard output file is often called
stdout,
and is automatically opened for writing on file descriptor 1
for every command invoked.
By default, the user's terminal is the destination of all data written to
stdout,
but it can be redirected elsewhere.
- stderr
See
standard error.
- stdin
See
standard input.
- stdout
See
standard output.
- stream
A term most often used in conjunction with the standard I/O
library routines documented in Section 3 of this manual.
A stream is simply a file pointer (declared as
FILE *stream)
returned by the
fopen(3S)
library routines.
It may or may not have buffering associated with it (by default,
buffering is assigned, but this can be modified with
setbuf(3S)).
- sticky bit
A single bit in the mode of every file in the file system.
If set on a
regular file,
the contents of the file stay permanently in memory
instead of being swapped back out to disk
when the file has finished executing.
Only
superuser
can set the sticky bit on a
regular file.
The sticky bit is read each time the file is executed (via
exec(2)).
If set on a directory,
the files in that directory can be removed or renamed only by
the owner of the file,
the owner of the directory containing the file,
or superuser.
See also
chmod(2),
rename(2),
rmdir(2),
and
unlink(2).
- subdirectory
A directory that is one or more levels lower in the file
system hierarchy than a given directory.
Sometimes called a
subordinate directory.
- subordinate directory
See
subdirectory.
- Subset 1980
See
CS/80.
- superblock
A block on each file system's mass storage medium
which describes the file system.
The contents of the superblock vary between implementations.
Refer to the
System Administrator manuals supplied with your system, and the appropriate
fs(4)
entry for details.
- superuser
The HP-UX system administrator.
This user has access to all files, and can perform privileged operations.
superuser
has a
real user ID
and
effective user ID
of 0, and, by convention,
the user name of
root.
- superior directory
See
parent directory.
- supplementary group ID
A process has up to
NGROUPS_MAX
supplementary group IDs used in determining file access permissions,
in addition to the effective group ID.
The supplementary group IDs of a process are set
to the supplementary group IDs of the parent process
when the process is created.
- symbolic link
A type of file that indirectly refers to a path name.
See
symlink(4).
- system
The HP-UX operating system.
See also
kernel.
- system asynchronous I/O
A method of performing I/O
whereby a process informs a driver or subsystem
that it wants to know when data has arrived
or when it is possible to perform a write request.
The driver or subsystem maintains a set of buffers
through which the process performs I/O.
See
ioctl(2),
read(2),
select(2),
and
write(2)
for more information.
- system call
An HP-UX operating system kernel function available to the user
through a high-level language (such as FORTRAN, Pascal, or C).
Also called an ``intrinsic'' or a ``system intrinsic.''
The available system calls are documented in Section 2 of the
HP-UX Reference Manual.
- system console
A keyboard and display (or terminal) given a unique status by HP-UX
and associated with the special file
/dev/console.
All boot ROM error messages,
HP-UX system error messages, and certain system status messages
are sent to the system console.
Under certain conditions (such as the single-user state),
the system console provides the only mechanism for communicating with HP-UX.
See the System Administrator manuals and user guides
provided with your system for details
on configuration and use of the system console.
- system process
A
system process
is a process that runs on behalf of the system.
It may have special implementation-defined characteristics.
- terminal
A
character special file
that obeys the specifications of
termio(7).
- terminal affiliation
The process by which a process group leader
establishes an association between itself and a particular terminal.
A terminal becomes affiliated with a process group leader
(and subsequently all processes created by
the process group leader, see
terminal group)
whenever the process group leader executes
(either directly or indirectly) an
open(2)
or
creat(2)
system call to open a terminal.
Then,
if
the process which is executing
open(2)
or
creat(2)
is a process group leader, and
if
that process group leader is not yet affiliated with a terminal,
and
if
the terminal being opened is not yet affiliated with a process group,
the affiliation is established
(however, see
open(2)
description of
O_NOCTTY).
An affiliated terminal keeps track of its process group affiliation
by storing the process group's process group ID in an internal structure.
Two benefits are realized by terminal affiliation.
First, all signals sent from the terminal
are sent to all processes in the terminal group.
Second, all processes in the terminal group can perform I/O
to/from the generic terminal driver
/dev/tty,
which automatically selects the affiliated terminal.
Terminal affiliation is broken with a terminal group
when the process group leader terminates,
after which the hangup signal is sent to
all processes remaining in the process group.
Also, if a process (which is not a process group leader)
in the terminal group becomes a process group leader via the
setpgrp(2)
system call, its terminal affiliation is broken.
See
process group,
process group leader,
terminal group,
and
setpgrp(2).
- terminal device
See
terminal.
- text file
A file that contains characters organized into one or more lines.
The lines cannot contain NUL characters, and none can exceed
LINE_MAX
bytes in length including the terminating newline character.
Although neither the kernel nor the C language implementation
distinguishes between text files and binary files
(see ANSI C Standard X3-159-19xx),
many utilities behave predictably only when operating on text files.
- tty
Originally, an abbreviation for teletypewriter;
now, generally, a
terminal.
- upshifting
The conversion of a lowercase character to its uppercase representation.
- user ID
Each system user is identified by an integer known as a
user ID,
which is in the range of zero to
UID_MAX,
inclusive.
Depending on how the user is identified with a process, a
user ID
value is referred to as a
real user ID,
an
effective user ID,
or a
saved user ID.
- UTC
See
Epoch.
- utility
An executable file, which might contain executable object code (that is, a
program),
or a list of
commands
to execute in a given order (that is, a
shell script).
You can write your own utilities, either as executable programs
or shell scripts (which are written in the shell programming language).
- volume number
Part of an address used for devices.
A number whose meaning is software- and device-dependent,
but which is often used to specify a particular volume
on a multivolume disk drive.
See the
System Administrator
manuals supplied with your system for details.
- whitespace
One or more characters which, when displayed,
cause a movement of the cursor or print head,
but do not result in the display of any visible graphic.
The whitespace characters in the ASCII code set are
space, tab, newline, form feed, carriage return, and vertical tab.
A particular command or routine might interpret some,
but not necessarily all, whitespace characters
as delimiting fields, words, or command options.
- working directory
Each process has associated with it the concept of a current working
directory.
For a shell, this appears as the directory in which you
currently ``reside''.
This is the directory in which relative path name
(i.e., a path name that does not begin with
/)
searches begin.
It is sometimes referred to as the
current directory,
or the
current working directory.
- zombie process
The name given to a process which terminates for any reason,
but whose parent process has not yet waited for it to terminate (via
wait(2)).
The process which terminated continues to occupy a slot
in the process table until its parent process waits for it.
Because it has terminated, however,
there is no other space allocated to it either in user or kernel space.
It is therefore a relatively harmless occurrence
which will rectify itself the next time its parent process waits.
The
ps(1)
command lists zombie processes as
defunct.