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