Provided by: erlang-manpages_13.b-1_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(4),      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)