Provided by: erlang-manpages_14.b.4-dfsg-1ubuntu1_all bug

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 connected, 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.

         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)