Provided by: erlang-manpages_16.b.3-dfsg-1ubuntu2.2_all 
NAME
kernel - The Kernel Application
DESCRIPTION
The Kernel application is the first application started. It is mandatory in the sense that
the minimal system based on Erlang/OTP consists of Kernel and STDLIB. The Kernel
application contains the following services:
* application controller, see application(3erl)
* code
* disk_log
* dist_ac, distributed application controller
* erl_boot_server
* erl_ddll
* error_logger
* file
* global
* global_group
* heart
* inet
* net_kernel
* os
* pg2
* rpc
* seq_trace
* user
ERROR LOGGER EVENT HANDLERS
Two standard error logger event handlers are defined in the Kernel application. These are
described in error_logger(3erl).
CONFIGURATION
The following configuration parameters are defined for the Kernel application. See
app(3erl) for more information about configuration parameters.
browser_cmd = string() | {M,F,A}:
When pressing the Help button in a tool such as Debugger or TV, the help text (an HTML
file File) is by default displayed in a Netscape browser which is required to be up
and running. This parameter can be used to change the command for how to display the
help text if another browser than Netscape is preferred, or another platform than Unix
or Windows is used.
If set to a string Command, the command "Command File" will be evaluated using
os:cmd/1.
If set to a module-function-args tuple {M,F,A}, the call apply(M,F,[File|A]) will be
evaluated.
distributed = [Distrib]:
Specifies which applications are distributed and on which nodes they may execute. In
this parameter:
* Distrib = {App,Nodes} | {App,Time,Nodes}
* App = atom()
* Time = integer()>0
* Nodes = [node() | {node(),...,node()}]
The parameter is described in application(3erl), function load/2.
dist_auto_connect = Value:
Specifies when nodes will be automatically connected. If this parameter is not
specified, a node is always automatically connected, e.g when a message is to be sent
to that node. Value is one of:
never:
Connections are never automatically established, they must be explicitly connected.
See net_kernel(3erl).
once:
Connections will be established automatically, but only once per node. If a node
goes down, it must thereafter be explicitly connected. See net_kernel(3erl).
permissions = [Perm]:
Specifies the default permission for applications when they are started. In this
parameter:
* Perm = {ApplName,Bool}
* ApplName = atom()
* Bool = boolean()
Permissions are described in application(3erl), function permit/2.
error_logger = Value:
Value is one of:
tty:
Installs the standard event handler which prints error reports to stdio. This is the
default option.
{file, FileName}:
Installs the standard event handler which prints error reports to the file FileName,
where FileName is a string.
false:
No standard event handler is installed, but the initial, primitive event handler is
kept, printing raw event messages to tty.
silent:
Error logging is turned off.
global_groups = [GroupTuple]:
Defines global groups, see global_group(3erl).
* GroupTuple = {GroupName, [Node]} | {GroupName, PublishType, [Node]}
* GroupName = atom()
* PublishType = normal | hidden
* Node = node()
inet_default_connect_options = [{Opt, Val}]:
Specifies default options for connect sockets, see inet(3erl).
inet_default_listen_options = [{Opt, Val}]:
Specifies default options for listen (and accept) sockets, see inet(3erl).
{inet_dist_use_interface, ip_address()}:
If the host of an Erlang node has several network interfaces, this parameter specifies
which one to listen on. See inet(3erl) for the type definition of ip_address().
{inet_dist_listen_min, First}:
See below.
{inet_dist_listen_max, Last}:
Define the First..Last port range for the listener socket of a distributed Erlang
node.
inet_parse_error_log = silent:
If this configuration parameter is set, no error_logger messages are generated when
erroneous lines are found and skipped in the various Inet configuration files.
inetrc = Filename:
The name (string) of an Inet user configuration file. See ERTS User's Guide, Inet
configuration.
net_setuptime = SetupTime:
SetupTime must be a positive integer or floating point number, and will be interpreted
as the maximally allowed time for each network operation during connection setup to
another Erlang node. The maximum allowed value is 120; if higher values are given, 120
will be used. The default value if the variable is not given, or if the value is
incorrect (e.g. not a number), is 7 seconds.
Note that this value does not limit the total connection setup time, but rather each
individual network operation during the connection setup and handshake.
net_ticktime = TickTime:
Specifies the net_kernel tick time. TickTime is given in seconds. Once every
TickTime/4 second, all connected nodes are ticked (if anything else has been written
to a node) and if nothing has been received from another node within the last four (4)
tick times that node is considered to be down. This ensures that nodes which are not
responding, for reasons such as hardware errors, are considered to be down.
The time T, in which a node that is not responding is detected, is calculated as: MinT
< T < MaxT where:
MinT = TickTime - TickTime / 4
MaxT = TickTime + TickTime / 4
TickTime is by default 60 (seconds). Thus, 45 < T < 75 seconds.
Note: All communicating nodes should have the same TickTime value specified.
Note: Normally, a terminating node is detected immediately.
shutdown_timeout = integer() | infinity:
Specifies the time application_controller will wait for an application to terminate
during node shutdown. If the timer expires, application_controller will brutally kill
application_master of the hanging application. If this parameter is undefined, it
defaults to infinity.
sync_nodes_mandatory = [NodeName]:
Specifies which other nodes must be alive in order for this node to start properly. If
some node in the list does not start within the specified time, this node will not
start either. If this parameter is undefined, it defaults to [].
sync_nodes_optional = [NodeName]:
Specifies which other nodes can be alive in order for this node to start properly. If
some node in this list does not start within the specified time, this node starts
anyway. If this parameter is undefined, it defaults to the empty list.
sync_nodes_timeout = integer() | infinity:
Specifies the amount of time (in milliseconds) this node will wait for the mandatory
and optional nodes to start. If this parameter is undefined, no node synchronization
is performed. This option also makes sure that global is synchronized.
start_dist_ac = true | false:
Starts the dist_ac server if the parameter is true. This parameter should be set to
true for systems that use distributed applications.
The default value is false. If this parameter is undefined, the server is started if
the parameter distributed is set.
start_boot_server = true | false:
Starts the boot_server if the parameter is true (see erl_boot_server(3erl)). This
parameter should be set to true in an embedded system which uses this service.
The default value is false.
boot_server_slaves = [SlaveIP]:
If the start_boot_server configuration parameter is true, this parameter can be used
to initialize boot_server with a list of slave IP addresses. SlaveIP = string() | atom
| {integer(),integer(),integer(),integer()}
where 0 <= integer() <=255.
Examples of SlaveIP in atom, string and tuple form are:
'150.236.16.70', "150,236,16,70", {150,236,16,70}.
The default value is [].
start_disk_log = true | false:
Starts the disk_log_server if the parameter is true (see disk_log(3erl)). This
parameter should be set to true in an embedded system which uses this service.
The default value is false.
start_pg2 = true | false:
Starts the pg2 server (see pg2(3erl)) if the parameter is true. This parameter should
be set to true in an embedded system which uses this service.
The default value is false.
start_timer = true | false:
Starts the timer_server if the parameter is true (see timer(3erl)). This parameter
should be set to true in an embedded system which uses this service.
The default value is false.
shutdown_func = {Mod, Func}:
Where:
* Mod = atom()
* Func = atom()
Sets a function that application_controller calls when it starts to terminate. The
function is called as: Mod:Func(Reason), where Reason is the terminate reason for
application_controller, and it must return as soon as possible for
application_controller to terminate properly.
SEE ALSO
app(5), application(3erl), code(3erl), disk_log(3erl), erl_boot_server(3erl),
erl_ddll(3erl), error_logger(3erl), file(3erl), global(3erl), global_group(3erl),
heart(3erl), inet(3erl), net_kernel(3erl), os(3erl), pg2(3erl), rpc(3erl),
seq_trace(3erl), user(3erl)