Provided by: erlang-manpages_13.b.3-dfsg-2ubuntu2_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: .br
             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)