%% %% %CopyrightBegin% %% %% Copyright Ericsson AB 1996-2010. All Rights Reserved. %% %% The contents of this file are subject to the Erlang Public License, %% Version 1.1, (the "License"); you may not use this file except in %% compliance with the License. You should have received a copy of the %% Erlang Public License along with this software. If not, it can be %% retrieved online at http://www.erlang.org/. %% %% Software distributed under the License is distributed on an "AS IS" %% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See %% the License for the specific language governing rights and limitations %% under the License. %% %% %CopyrightEnd% %% -module(kernel). -behaviour(supervisor). %% External exports -export([start/2, init/1, stop/1]). -export([config_change/3]). %%%----------------------------------------------------------------- %%% The kernel is the first application started. %%% Callback functions for the kernel application. %%%----------------------------------------------------------------- start(_, []) -> case supervisor:start_link({local, kernel_sup}, kernel, []) of {ok, Pid} -> Type = get_error_logger_type(), error_logger:swap_handler(Type), {ok, Pid, []}; Error -> Error end. stop(_State) -> ok. %%------------------------------------------------------------------- %% Some configuration parameters for kernel are changed %%------------------------------------------------------------------- config_change(Changed, New, Removed) -> do_distribution_change(Changed, New, Removed), do_global_groups_change(Changed, New, Removed), ok. get_error_logger_type() -> case application:get_env(kernel, error_logger) of {ok, tty} -> tty; {ok, {file, File}} when is_list(File) -> {logfile, File}; {ok, false} -> false; {ok, silent} -> silent; undefined -> tty; % default value {ok, Bad} -> exit({bad_config, {kernel, {error_logger, Bad}}}) end. %%%----------------------------------------------------------------- %%% The process structure in kernel is as shown in the figure. %%% %%% --------------- %%% | kernel_sup (A)| %%% --------------- %%% | %%% ------------------------------- %%% | | | %%% <std services> ------------- ------------- %%% (file,code, | erl_dist (A)| | safe_sup (1)| %%% rpc, ...) ------------- ------------- %%% | | %%% (net_kernel, (disk_log, pg2, %%% auth, ...) ...) %%% %%% The rectangular boxes are supervisors. All supervisors except %%% for kernel_safe_sup terminates the enitre erlang node if any of %%% their children dies. Any child that can't be restarted in case %%% of failure must be placed under one of these supervisors. Any %%% other child must be placed under safe_sup. These children may %%% be restarted. Be aware that if a child is restarted the old state %%% and all data will be lost. %%%----------------------------------------------------------------- %%% Callback functions for the kernel_sup supervisor. %%%----------------------------------------------------------------- init([]) -> SupFlags = {one_for_all, 0, 1}, Config = {kernel_config, {kernel_config, start_link, []}, permanent, 2000, worker, [kernel_config]}, Code = {code_server, {code, start_link, get_code_args()}, permanent, 2000, worker, [code]}, File = {file_server_2, {file_server, start_link, []}, permanent, 2000, worker, [file, file_server, file_io_server, prim_file]}, StdError = {standard_error, {standard_error, start_link, []}, temporary, 2000, supervisor, [user_sup]}, User = {user, {user_sup, start, []}, temporary, 2000, supervisor, [user_sup]}, case init:get_argument(mode) of {ok, [["minimal"]]} -> SafeSupervisor = {kernel_safe_sup, {supervisor, start_link, [{local, kernel_safe_sup}, ?MODULE, safe]}, permanent, infinity, supervisor, [?MODULE]}, {ok, {SupFlags, [File, Code, StdError, User, Config, SafeSupervisor]}}; _ -> Rpc = {rex, {rpc, start_link, []}, permanent, 2000, worker, [rpc]}, Global = {global_name_server, {global, start_link, []}, permanent, 2000, worker, [global]}, Glo_grp = {global_group, {global_group,start_link,[]}, permanent, 2000, worker, [global_group]}, InetDb = {inet_db, {inet_db, start_link, []}, permanent, 2000, worker, [inet_db]}, NetSup = {net_sup, {erl_distribution, start_link, []}, permanent, infinity, supervisor,[erl_distribution]}, DistAC = start_dist_ac(), Timer = start_timer(), SafeSupervisor = {kernel_safe_sup, {supervisor, start_link, [{local, kernel_safe_sup}, ?MODULE, safe]}, permanent, infinity, supervisor, [?MODULE]}, {ok, {SupFlags, [Rpc, Global, InetDb | DistAC] ++ [NetSup, Glo_grp, File, Code, StdError, User, Config, SafeSupervisor] ++ Timer}} end; init(safe) -> SupFlags = {one_for_one, 4, 3600}, Boot = start_boot_server(), DiskLog = start_disk_log(), Pg2 = start_pg2(), %% Run the on_load handlers for all modules that have been %% loaded so far. Running them at this point means that %% on_load handlers can safely call kernel processes %% (and in particular call code:priv_dir/1 or code:lib_dir/1). init:run_on_load_handlers(), {ok, {SupFlags, Boot ++ DiskLog ++ Pg2}}. get_code_args() -> case init:get_argument(nostick) of {ok, [[]]} -> [[nostick]]; _ -> [] end. start_dist_ac() -> Spec = [{dist_ac,{dist_ac,start_link,[]},permanent,2000,worker,[dist_ac]}], case application:get_env(kernel, start_dist_ac) of {ok, true} -> Spec; {ok, false} -> []; undefined -> case application:get_env(kernel, distributed) of {ok, _} -> Spec; _ -> [] end end. start_boot_server() -> case application:get_env(kernel, start_boot_server) of {ok, true} -> Args = get_boot_args(), [{boot_server, {erl_boot_server, start_link, [Args]}, permanent, 1000, worker, [erl_boot_server]}]; _ -> [] end. get_boot_args() -> case application:get_env(kernel, boot_server_slaves) of {ok, Slaves} -> Slaves; _ -> [] end. start_disk_log() -> case application:get_env(kernel, start_disk_log) of {ok, true} -> [{disk_log_server, {disk_log_server, start_link, []}, permanent, 2000, worker, [disk_log_server]}, {disk_log_sup, {disk_log_sup, start_link, []}, permanent, 1000, supervisor, [disk_log_sup]}]; _ -> [] end. start_pg2() -> case application:get_env(kernel, start_pg2) of {ok, true} -> [{pg2, {pg2, start_link, []}, permanent, 1000, worker, [pg2]}]; _ -> [] end. start_timer() -> case application:get_env(kernel, start_timer) of {ok, true} -> [{timer_server, {timer, start_link, []}, permanent, 1000, worker, [timer]}]; _ -> [] end. %%----------------------------------------------------------------- %% The change of the distributed parameter is taken care of here %%----------------------------------------------------------------- do_distribution_change(Changed, New, Removed) -> %% check if the distributed parameter is changed. It is not allowed %% to make a local application to a distributed one, or vice versa. case is_dist_changed(Changed, New, Removed) of %%{changed, new, removed} {false, false, false} -> ok; {C, false, false} -> %% At last, update the parameter. gen_server:call(dist_ac, {distribution_changed, C}, infinity); {false, _, false} -> error_logger:error_report("Distribution not changed: " "Not allowed to add the 'distributed' " "parameter."), {error, {distribution_not_changed, "Not allowed to add the " "'distributed' parameter"}}; {false, false, _} -> error_logger:error_report("Distribution not changed: " "Not allowed to remove the " "distribution parameter."), {error, {distribution_not_changed, "Not allowed to remove the " "'distributed' parameter"}} end. %%----------------------------------------------------------------- %% Check if distribution is changed in someway. %%----------------------------------------------------------------- is_dist_changed(Changed, New, Removed) -> C = case lists:keyfind(distributed, 1, Changed) of false -> false; {distributed, NewDistC} -> NewDistC end, N = case lists:keyfind(distributed, 1, New) of false -> false; {distributed, NewDistN} -> NewDistN end, R = lists:member(distributed, Removed), {C, N, R}. %%----------------------------------------------------------------- %% The change of the global_groups parameter is taken care of here %%----------------------------------------------------------------- do_global_groups_change(Changed, New, Removed) -> %% check if the global_groups parameter is changed. case is_gg_changed(Changed, New, Removed) of %%{changed, new, removed} {false, false, false} -> ok; {C, false, false} -> %% At last, update the parameter. global_group:global_groups_changed(C); {false, N, false} -> global_group:global_groups_added(N); {false, false, R} -> global_group:global_groups_removed(R) end. %%----------------------------------------------------------------- %% Check if global_groups is changed in someway. %%----------------------------------------------------------------- is_gg_changed(Changed, New, Removed) -> C = case lists:keyfind(global_groups, 1, Changed) of false -> false; {global_groups, NewDistC} -> NewDistC end, N = case lists:keyfind(global_groups, 1, New) of false -> false; {global_groups, NewDistN} -> NewDistN end, R = lists:member(global_groups, Removed), {C, N, R}.