👤
Home Man
Search
Today's Posts
Register

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:
Select Section of Man Page:
Select Man Page Repository:

Linux 2.6 - man page for kernel (linux section 7)

kernel(7)			  Erlang Application Definition 			kernel(7)

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  applica-
       tion 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  speci-
	   fied,  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 con-
	   figuration.

	 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 Tick-
	   Time/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 any-
	   way. 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 param-
	   eter 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_con-
	   troller 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)

Ericsson AB				  kernel 2.14.3 				kernel(7)


All times are GMT -4. The time now is 05:31 AM.

Unix & Linux Forums Content Copyrightę1993-2018. All Rights Reserved.
×
UNIX.COM Login
Username:
Password:  
Show Password