Provided by: erlang-manpages_18.3-dfsg-1ubuntu3_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

         * error_logger_format_depth

         * 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(5)
       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.

         error_logger_format_depth = Depth:

           This parameter can be used to limit the size of the formatted output  from  the  error
           logger event handlers.

     Note:
         This  configuration  parameter was introduced in OTP 18.1. It is currently experimental.
         Based on user feedback it may be changed or improved in future releases, for example  to
         gain better control over how to limit the size of the formatted output. We have no plans
         to entirely remove this new feature, unless it turns out to be  completely  useless.  In
         OTP 19, the default may be changed to limit the formatted output.

           Depth  is  a  positive integer that is the maximum depth to which terms are printed by
           the error logger event handlers included in OTP. Specifically, the two event  handlers
           defined  by  the Kernel application and the two event handlers in the SASL application
           will use this  configuration  parameter.  (If  you  have  implemented  you  own  error
           handlers, this configuration parameter will have no effect on them.)

           The way Depth is used, is that format strings string passed to the event handlers will
           be rewritten. The "~p" and "~w" format controls will be replaced with "~P"  and  "~W",
           respectively, and Depth will be used as the depth parameter. See io:format/2.

     Note:
         A  reasonable starting value for Depth is 30. You should test crashing various processes
         in your application and examine the logs from the crashes, and then either  increase  or
         decrease the value.

         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_dist_listen_options, Opts}:
           Define a list of extra socket options to be used when opening the listening socket for
           a distributed Erlang node. See gen_tcp:listen/2

         {inet_dist_connect_options, Opts}:
           Define a list of extra socket options to be used when connecting to other  distributed
           Erlang nodes. See gen_tcp:connect/4

         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), timer(3erl), user(3erl)