[snmp/agent] backup

8 files changed, 1172 insertions, 37 deletions

diff --git a/lib/snmp/doc/src/snmp_app.xml b/lib/snmp/doc/src/snmp_app.xml
index c7a74f0ca6..9cdbcc91c5 100644
--- a/lib/snmp/doc/src/snmp_app.xml
+++ b/lib/snmp/doc/src/snmp_app.xml
@@ -312,29 +312,31 @@
       </item>
 
       <marker id="agent_mib_storage"></marker>
-      <tag><c><![CDATA[mib_storage() = ets | {ets, Dir} | {ets, Dir, Action} | dets | {dets, Dir} | {dets, Dir, Action} | mnesia | {mnesia, Nodes} | {mnesia, Nodes, Action} <optional>]]></c></tag>
-      <item>
-        <p>Specifies how info retrieved from the mibs will be stored.</p>
-        <p>If <c>mib_storage</c> is <c>{ets, Dir}</c>, the table will also be 
-          stored on file. If <c>Dir</c> is <c>default</c>, then <c>db_dir</c> 
-          will be used.</p>
-        <p>If <c>mib_storage</c> is <c>dets</c> or if <c>Dir</c> is 
-          <c>default</c>, then <c>db_dir</c> will be used for <c>Dir</c>.</p>
-        <p>If <c>mib_storage</c> is <c>mnesia</c> then <c>erlang:nodes()</c>
-          will be used for <c>Nodes</c>.</p>
-        <p>Default is <c>ets</c>. </p>
-        <p><c>Dir = default | string()</c>. Dir is the directory where the 
-          files will be stored. If <c>default</c>, then <c>db_dir</c> will be 
-          used.</p>
-        <p><c>Nodes = visible | connected | [node()]</c>. 
-          <c>Nodes = visible</c> is translated to 
-          <c>erlang:nodes(visible)</c>. 
-          <c>Nodes = connected</c> is translated to 
-          <c>erlang:nodes(connected)</c>. 
-          If <c>Nodes = []</c> then the own node is assumed.</p>
-        <p><c>Action = clear | keep</c>. Default is <c>keep</c>.
-          <c>Action</c> is used to specify what shall be done if the 
-          mnesia/dets table already exist.</p>
+      <tag><c><![CDATA[mib_storage() = [mib_storage_opt()]]]></c></tag>
+      <item>
+        <p><c>mib_storage_opt() = {module, mib_storage_module()} |  {options, list()}</c></p>
+        <p>This option specifies how basic mib data is stored. 
+	This option is used by two parts of the snmp agent: 
+	The mib-server and the symbolic-store. </p>
+        <p>Default is <c>[{module, snmpa_mib_storage_ets}]</c>. </p>
+      </item>
+
+       <marker id="agent_mst_module"></marker>
+      <tag><c><![CDATA[mib_storage_module() = snmpa_mib_data_ets | snmpa_mib_data_dets | snmpa_mib_data_mnesia | module() <optional>]]></c></tag>
+      <item>
+        <p>Defines the callback mib data storage module of the 
+	SNMP agent mib-server as defined by the 
+	<seealso marker="snmpa_mib_data">snmpa_mib_data</seealso> 
+	behaviour. </p>
+	<p>At present only the default module is provided with the agent,  
+	<c>snmpa_mib_data_tttn</c>. </p>
+<!--
+	<p>Two modules is provided with the agent 
+	<c>snmpa_mib_data_tttn</c> (this is the old implementation) and 
+	<c>snmpa_mib_data_ttln</c> (for a mib tree with many holes, 
+	this algorithm can be more price efficient). </p>
+-->
+        <p>Default module is <c>snmpa_mib_data_tttn</c>. </p>
       </item>
 
       <marker id="agent_mib_server"></marker>
diff --git a/lib/snmp/src/agent/depend.mk b/lib/snmp/src/agent/depend.mk
index 096182a626..283de54078 100644
--- a/lib/snmp/src/agent/depend.mk
+++ b/lib/snmp/src/agent/depend.mk
@@ -88,6 +88,18 @@ $(EBIN)/snmpa_local_db.$(EMULATOR): \
 	../../include/snmp_types.hrl \
 	../../include/STANDARD-MIB.hrl
 
+$(EBIN)/snmpa_mib_storage.$(EMULATOR): \
+	snmpa_mib_storage.erl
+
+$(EBIN)/snmpa_mib_storage_ets.$(EMULATOR): \
+	snmpa_mib_storage_ets.erl
+
+$(EBIN)/snmpa_mib_storage_dets.$(EMULATOR): \
+	snmpa_mib_storage_dets.erl
+
+$(EBIN)/snmpa_mib_storage_mnesia.$(EMULATOR): \
+	snmpa_mib_storage_mnesia.erl
+
 $(EBIN)/snmpa_mib.$(EMULATOR): \
 	snmpa_mib.erl \
 	../misc/snmp_debug.hrl \
diff --git a/lib/snmp/src/agent/modules.mk b/lib/snmp/src/agent/modules.mk
index da9f6d6b4c..e8d1593a79 100644
--- a/lib/snmp/src/agent/modules.mk
+++ b/lib/snmp/src/agent/modules.mk
@@ -21,6 +21,7 @@ BEHAVIOUR_MODULES = \
 	snmpa_authentication_service \
 	snmpa_discovery_handler \
 	snmpa_error_report \
+	snmpa_mib_storage \
 	snmpa_mib_data \
 	snmpa_network_interface \
 	snmpa_network_interface_filter \
@@ -45,6 +46,9 @@ MODULES = \
 	snmpa_error_logger \
 	snmpa_general_db \
 	snmpa_local_db \
+	snmpa_mib_storage_ets \
+	snmpa_mib_storage_dets \
+	snmpa_mib_storage_mnesia \
 	snmpa_mib \
 	snmpa_mib_data_tttn \
 	snmpa_mib_lib \
diff --git a/lib/snmp/src/agent/snmpa_mib_storage.erl b/lib/snmp/src/agent/snmpa_mib_storage.erl
new file mode 100644
index 0000000000..bbb9516ecb
--- /dev/null
+++ b/lib/snmp/src/agent/snmpa_mib_storage.erl
@@ -0,0 +1,181 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2013-2013. 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(snmpa_mib_storage).
+
+-export_type([
+	      mib_storage_fields/0, 
+	      mib_storage_table_type/0, 
+	      mib_storage_table_id/0, 
+
+	      void/0
+	     ]).
+
+
+%%% ----------------------------------------------------------------
+%%% This behaviour module defines the API for the mib-storage. 
+%%% This is how the agent stores its internal mib-data 
+%%% (symbolic-store and mib-server). 
+%%%-----------------------------------------------------------------
+
+-type mib_storage_fields()     :: [atom()].
+-type mib_storage_table_type() :: set | bag. 
+-type mib_storage_table_id()   :: term().
+-type void()                   :: term().
+
+
+%% ---------------------------------------------------------------
+%% open
+%% 
+%% Open or create a mib-storage table. 
+%% If any extra info needs to be communicated to the implementor
+%% (of the behaviour), this is done using the *Options* argument. 
+%% ---------------------------------------------------------------
+
+%% Options is callback module dependant
+
+-callback open(Name    :: atom(), 
+	       RecName :: atom(), 
+	       Fields  :: mib_storage_fields(), 
+	       Type    :: mib_storage_table_type(), 
+	       Options :: list()) ->
+    {ok, TabId :: mib_storage_table_id()} | {error, Reason :: term()}.
+
+
+%% ---------------------------------------------------------------
+%% close
+%% 
+%% Close the mib-storage table. What this does is up to the 
+%% implementor (when using mnesia it may be a no-op but for ets 
+%% it may actually delete the table). 
+%% ---------------------------------------------------------------
+
+-callback close(TabId :: mib_storage_table_id()) ->
+    term().
+
+
+%% ---------------------------------------------------------------
+%% read/2
+%% 
+%% Retrieve a record from the mib-storage table.
+%% ---------------------------------------------------------------
+
+-callback read(TabId :: mib_storage_table_id(), 
+	       Key   :: term()) ->
+    false | {value, Record :: tuple()}.
+
+
+%% ---------------------------------------------------------------
+%% write/2
+%% 
+%% Write a record to the mib-storage table.
+%% ---------------------------------------------------------------
+
+-callback write(TabId  :: mib_storage_table_id(), 
+		Record :: tuple()) ->
+    ok | {error, Reason :: term()}.
+
+
+%% ---------------------------------------------------------------
+%% delete/1
+%% 
+%% Delete the mib-storage table. 
+%% ---------------------------------------------------------------
+
+-callback delete(TabId :: mib_storage_table_id()) ->
+    void().
+
+
+%% ---------------------------------------------------------------
+%% delete/2
+%% 
+%% Delete a record from the mib-storage table.
+%% ---------------------------------------------------------------
+
+-callback delete(TabId :: mib_storage_table_id(), 
+		 Key   :: term()) ->
+    ok | {error, Reason :: term()}.
+
+
+%% ---------------------------------------------------------------
+%% match_object
+%% 
+%% Search the mib-storage table for records which matches 
+%% the pattern.
+%% ---------------------------------------------------------------
+
+-callback match_object(TabId   :: mib_storage_table_id(), 
+		       Pattern :: ets:match_pattern()) ->
+    {ok, Recs :: [tuple()]} | {error, Reason :: term()}.
+
+
+%% ---------------------------------------------------------------
+%% match_delete
+%% 
+%% Search the mib-storage table for records which matches the 
+%% pattern and deletes them from the database and return the 
+%5 deleted records.
+%% ---------------------------------------------------------------
+
+-callback match_delete(TabId   :: mib_storage_table_id(), 
+		       Pattern :: ets:match_pattern()) ->
+    {ok, Recs :: [tuple()]} | {error, Reason :: term()}.
+
+
+%% ---------------------------------------------------------------
+%% tab2list
+%% 
+%% Return all records in the table in the form of a list.
+%% ---------------------------------------------------------------
+
+-callback tab2list(TabId :: mib_storage_table_id()) ->
+    [tuple()].
+
+
+%% ---------------------------------------------------------------
+%% info
+%% 
+%% Retrieve implementation dependent mib-storage table 
+%% information.
+%% ---------------------------------------------------------------
+
+-callback info(TabId :: mib_storage_table_id()) ->
+    {ok, Info :: term()} | {error, Reason :: term()}.
+
+
+%% ---------------------------------------------------------------
+%% sync
+%% 
+%% Dump mib-storage table to disc (if it has a disk component). 
+%% ---------------------------------------------------------------
+
+-callback sync(TabId :: mib_storage_table_id()) ->
+    ok.
+
+
+%% ---------------------------------------------------------------
+%% backup
+%% 
+%% Make a backup copy of the mib-storage table. 
+%% ---------------------------------------------------------------
+
+-callback backup(TabId :: mib_storage_table_id(), 
+		 Dir   :: file:filename()) ->
+    ok | {error, Reason :: term()}.
+
diff --git a/lib/snmp/src/agent/snmpa_mib_storage_dets.erl b/lib/snmp/src/agent/snmpa_mib_storage_dets.erl
new file mode 100644
index 0000000000..6062f4327e
--- /dev/null
+++ b/lib/snmp/src/agent/snmpa_mib_storage_dets.erl
@@ -0,0 +1,298 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2013-2013. 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(snmpa_mib_storage_dets).
+
+-behaviour(snmpa_mib_storage).
+
+
+%%%-----------------------------------------------------------------
+%%% This module implements the snmpa_mib_storage behaviour. 
+%%% It uses dets for storage. 
+%%%-----------------------------------------------------------------
+
+-export([
+	 open/5, 
+	 close/1, 
+	 read/2, 
+	 write/2, 
+	 delete/1, 
+	 delete/2, 
+	 sync/1, 
+	 backup/2, 
+	 match_object/2, 
+	 match_delete/2, 
+	 tab2list/1, 
+	 info/1
+	]).
+
+
+-define(VMODULE, "MS-DETS").
+-include("snmp_verbosity.hrl").
+
+-record(tab, {id}).
+
+
+%% ---------------------------------------------------------------
+%% open
+%% 
+%% Open or create a mib-storage (dets) table. 
+%% 
+%% Opts - A list of implementation dependent options
+%%        dets_open_options() = [dets_open_option()]
+%%        dets_open_option()  = {dir,       filename()} | 
+%%                              {action,    keep | clear} | 
+%%                              {auto_save, default | pos_integer()} |
+%%                              {repair,    force | boolean()}
+%%                              
+%% ---------------------------------------------------------------
+
+open(Name, _RecName, _Fields, Type, Opts) ->
+    Dir      = snmp_misc:get_option(dir,       Opts), 
+    Action   = snmp_misc:get_option(action,    Opts, keep), 
+    AutoSave = snmp_misc:get_option(auto_save, Opts, default), 
+    Repair   = snmp_misc:get_option(repair,    Opts, false), 
+    File     = dets_filename(Name, Dir), 
+    OpenOpts = [{file,   File}, 
+		{type,   Type}, 
+		{keypos, 2}, 
+		{repair, Repair}] ++ 
+	case AutoSave of
+	    default ->
+		[];
+	    _ ->
+		[{auto_save, AutoSave}]
+	end,
+    case dets:open_file(Name, OpenOpts) of
+	{ok, ID} when (Action =:= keep) ->
+	    {ok, #tab{id = ID}};
+	{ok, ID} when (Action =:= clear) ->
+	    dets:match_delete(ID, '_'),
+	    {ok, #tab{id = ID}};
+	{error, Reason} ->
+	    {error, {dets_open, Reason}}
+    end.
+
+dets_filename(Name, Dir) ->
+    Dir1 = dets_filename1(Dir),
+    Dir2 = string:strip(Dir1, right, $/),
+    io_lib:format("~s/~p.dat", [Dir2, Name]).
+    
+dets_filename1([])  -> ".";
+dets_filename1(Dir) -> Dir.
+
+
+%% ---------------------------------------------------------------
+%% close
+%% 
+%% Close the table. 
+%% ---------------------------------------------------------------
+
+close(#tab{id = ID}) ->
+    ?vtrace("close database ~p", [ID]),
+    dets:close(ID).
+
+
+%% ---------------------------------------------------------------
+%% read
+%% 
+%% Retrieve a record from the database table.
+%% ---------------------------------------------------------------
+
+read(#tab{id = ID}, Key) ->
+    ?vtrace("read from table ~p: ~p", [ID, Key]),
+    case dets:lookup(ID, Key) of
+	[Rec|_] -> {value, Rec};
+	_ -> false
+    end.
+    
+
+%% ---------------------------------------------------------------
+%% write
+%% 
+%% Write a record to the database table.
+%% ---------------------------------------------------------------
+
+write(#tab{id = ID}, Rec) ->
+    ?vtrace("write to table ~p", [ID]),
+    dets:insert(ID, Rec).
+
+
+%% ---------------------------------------------------------------
+%% delete
+%% 
+%% Delete the database table. 
+%% ---------------------------------------------------------------
+
+delete(#tab{id = ID}) ->
+    ?vtrace("delete database ~p", [ID]),
+    File = dets:info(ID, filename),
+    case dets:close(ID) of
+	ok ->
+	    file:delete(File);
+	Error ->
+	    Error
+    end.
+
+
+%% ---------------------------------------------------------------
+%% delete
+%% 
+%% Delete a record from the database table.
+%% ---------------------------------------------------------------
+
+delete(#tab{id = ID}, Key) ->
+    ?vtrace("delete from table ~p: ~p", [ID, Key]),
+    dets:delete(ID, Key).
+
+
+%% ---------------------------------------------------------------
+%% match_object
+%% 
+%% Search the database table for records witch matches the pattern.
+%% ---------------------------------------------------------------
+
+match_object(#tab{id = ID}, Pattern) ->
+    ?vtrace("match_object in ~p of ~p", [ID, Pattern]),
+    dets:match_object(ID, Pattern).
+    
+
+%% ---------------------------------------------------------------
+%% match_delete
+%% 
+%% Search the database table for records witch matches the 
+%% pattern and deletes them from the database table.
+%% ---------------------------------------------------------------
+
+match_delete(#tab{id = ID}, Pattern) -> 
+    ?vtrace("match_delete in ~p with pattern ~p", [ID, Pattern]),
+    Recs = dets:match_object(ID, Pattern),
+    dets:match_delete(ID, Pattern),
+    Recs.
+
+
+%% ---------------------------------------------------------------
+%% tab2list
+%% 
+%% Return all records in the table in the form of a list.
+%% ---------------------------------------------------------------
+
+tab2list(#tab{id = ID} = Tab) ->
+    ?vtrace("tab2list -> list of ~p", [ID]),
+    match_object(Tab, '_').
+
+
+%% ---------------------------------------------------------------
+%% info
+%% 
+%% Retrieve implementation dependent mib-storage table 
+%% information.
+%% ---------------------------------------------------------------
+
+info(#tab{id = ID}) ->
+    ?vtrace("info -> info of ~p", [ID]),
+    dets:info(ID).
+
+
+%% ---------------------------------------------------------------
+%% sync
+%% 
+%% Dump mib-storage table to disc (if it has a disk component)
+%% ---------------------------------------------------------------
+
+sync(#tab{id = ID}) ->
+    ?vtrace("sync -> sync ~p", [ID]),
+    dets:sync(ID).
+
+
+%% ---------------------------------------------------------------
+%% backup
+%% 
+%% Make a backup copy of the mib-storage table. 
+%% ---------------------------------------------------------------
+
+backup(#tab{id = ID}, BackupDir) ->
+    ?vtrace("backup -> backup of ~p to ~p", [ID, BackupDir]),
+    case dets:info(ID, filename) of
+	undefined ->
+	    {error, no_file};
+	Filename ->
+	    case filename:dirname(Filename) of
+		BackupDir ->
+		    {error, db_dir};
+		_ ->
+		    Type = dets:info(ID, type),
+		    KP   = dets:info(ID, keypos),
+		    dets_backup(ID, 
+				filename:basename(Filename), 
+				BackupDir, Type, KP)
+	    end
+    end.
+
+	      
+dets_backup(ID, Filename, BackupDir, Type, KP) ->
+    ?vtrace("dets_backup -> entry with"
+	    "~n   ID:        ~p"
+	    "~n   Filename:  ~p"
+	    "~n   BackupDir: ~p"
+	    "~n   Type:      ~p"
+	    "~n   KP:        ~p", [ID, Filename, BackupDir, Type, KP]),
+    BackupFile = filename:join(BackupDir, Filename),
+    ?vtrace("dets_backup -> "
+	    "~n   BackupFile: ~p", [BackupFile]),
+    Backup = list_to_atom(atom_to_list(ID) ++ "_backup"),
+    Opts   = [{file, BackupFile}, {type, Type}, {keypos, KP}], 
+    case dets:open_file(Backup, Opts) of
+	{ok, B} ->
+	    ?vtrace("dets_backup -> create fun", []),
+	    F = fun(Arg) -> 
+			dets_backup(Arg, start, ID, B)
+		end,
+	    dets:safe_fixtable(ID, true),
+	    Res = dets:init_table(Backup, F, [{format, bchunk}]),
+	    dets:safe_fixtable(ID, false),
+	    ?vtrace("dets_backup -> Res: ~p", [Res]),
+	    Res;
+	Error ->
+	    ?vinfo("dets_backup -> open_file failed: "
+		   "~n   ~p", [Error]),
+	    Error
+    end.
+
+dets_backup(close, _Cont, _ID, B) ->
+    dets:close(B),
+    ok;
+dets_backup(read, Cont1, ID, B) ->
+    case dets:bchunk(ID, Cont1) of
+	{Cont2, Data} ->
+	    F = fun(Arg) ->
+			dets_backup(Arg, Cont2, ID, B)
+		end,
+	    {Data, F};
+	'$end_of_table' ->
+	    dets:close(B),
+	    end_of_input;
+	Error ->
+	    Error
+    end.
+
+
+%%----------------------------------------------------------------------
+
+%% user_err(F, A) ->
+%%     snmpa_error:user_err(F, A).
diff --git a/lib/snmp/src/agent/snmpa_mib_storage_ets.erl b/lib/snmp/src/agent/snmpa_mib_storage_ets.erl
new file mode 100644
index 0000000000..fcf5e12043
--- /dev/null
+++ b/lib/snmp/src/agent/snmpa_mib_storage_ets.erl
@@ -0,0 +1,298 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2013-2013. 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(snmpa_mib_storage_ets).
+
+-behaviour(snmpa_mib_storage).
+
+%%%-----------------------------------------------------------------
+%%% This module implements the snmpa_mib_storage behaviour. 
+%%% It uses ets for storage. 
+%%%-----------------------------------------------------------------
+
+-export([
+	 open/5, 
+	 close/1, 
+	 read/2, 
+	 write/2, 
+	 delete/1, 
+	 delete/2, 
+	 sync/1, 
+	 backup/2, 
+	 match_object/2, 
+	 match_delete/2, 
+	 tab2list/1, 
+	 info/1
+	]).
+
+
+-define(VMODULE,"MS-ETS").
+-include("snmp_verbosity.hrl").
+
+-record(tab, {id, file, checksum = false}).
+
+
+%% ---------------------------------------------------------------
+%% open
+%% 
+%% Open or create an ets table. 
+%% Possibly also read data from a (specified) file (mirror) and 
+%% populate the table from that (the dir option). 
+%% 
+%% Opts    - A list of implementation dependent options
+%%           ets_open_options() = [ets_open_option()]
+%%           ets_open_option()  = {dir,      filename()} | 
+%%                                {action,   keep | clear} | 
+%%                                {checksum, boolean()}
+%% 
+%% The RecName and Fields arguments are not used in this 
+%% implementation. 
+%% 
+%% ---------------------------------------------------------------
+
+%% This function creates the ets table 
+open(Name, _RecName, _Fields, Type, Opts) ->
+    ?vtrace("open table ~p", [Name]),
+    case lists:keysearch(dir, 1, Opts) of
+	{value, {dir, Dir}} ->
+	    Action   = snmp_misc:get_option(action,   Opts, keep),
+	    Checksum = snmp_misc:get_option(checksum, Opts, false),
+	    ?vtrace("open ~p database ~p", [Type, Name]),
+	    File = filename:join(Dir, atom_to_list(Name) ++ ".db"),
+	    case file:read_file_info(File) of
+		{ok, _} ->
+		    case ets:file2tab(File, [{verify, Checksum}]) of
+			{ok, ID} ->
+			    {ok, #tab{id       = ID, 
+				      file     = File, 
+				      checksum = Checksum}};
+			{error, Reason} when (Action =:= keep) ->
+			    {error, {file2tab, Reason}};
+			{error, Reason} ->
+			    user_err("Warning: could not read file - "
+				     "create new (empty): "
+				     "~n   File:   ~p"
+				     "~n   Reason: ~p", [File, Reason]), 
+			    ID = ets:new(Name, [Type, protected, {keypos, 2}]),
+			    write_ets_file(ID, File, Checksum), 
+			    {ok, #tab{id       = ID, 
+				      file     = File, 
+				      checksum = Checksum}}
+		    end;
+		{error, Reason} when (Action =:= keep) ->
+		    {error, {read_file_info, Reason}};
+		{error, Reason} ->
+		    user_err("Warning: could not read file info - "
+			     "create new: "
+			     "~n   File:   ~p"
+			     "~n   Reason: ~p", [File, Reason]), 
+		    ID = ets:new(Name, [Type, protected, {keypos, 2}]),
+		    write_ets_file(ID, File, Checksum), 
+		    {ok, #tab{id       = ID, 
+			      file     = File, 
+			      checksum = Checksum}}
+	    end;
+	false ->
+	    ID = ets:new(Name, [Type, protected, {keypos, 2}]),
+	    {ok, #tab{id = ID}}
+    end.
+
+
+%% ---------------------------------------------------------------
+%% close
+%% 
+%% Close the mib-storage table. 
+%% We will delete the table and if there is a file component, 
+%% will also be written to file. 
+%% ---------------------------------------------------------------
+close(#tab{id = ID, file = undefined}) ->
+    ?vtrace("close (delete) table ~p", [ID]),
+    ets:delete(ID);
+close(#tab{id = ID, file = File, checksum = Checksum}) ->
+    ?vtrace("close (delete) table ~p", [ID]),
+    write_ets_file(ID, File, Checksum),
+    ets:delete(ID).
+
+
+%% ---------------------------------------------------------------
+%% read
+%% 
+%% Retrieve a record from the mib-storage table.
+%% ---------------------------------------------------------------
+
+read(#tab{id = ID}, Key) ->
+    ?vtrace("read from table ~p: ~p", [ID, Key]),
+    case ets:lookup(ID, Key) of
+	[Rec|_] -> {value, Rec};
+	_ -> false
+    end.
+    
+
+%% ---------------------------------------------------------------
+%% write
+%% 
+%% Write a record to the mib-storage table.
+%% ---------------------------------------------------------------
+
+write(#tab{id = ID}, Rec) ->
+    ?vtrace("write to table ~p", [ID]),
+    ets:insert(ID, Rec).
+
+
+%% ---------------------------------------------------------------
+%% delete
+%% 
+%% Delete the mib-storage table. 
+%% ---------------------------------------------------------------
+delete(#tab{id = ID, file = undefined}) ->
+    ?vtrace("delete table ~p", [ID]),
+    ets:delete(ID);
+delete(#tab{id = ID, file = File}) ->
+    ?vtrace("delete table ~p", [ID]),
+    file:delete(File),
+    ets:delete(ID).
+
+
+%% ---------------------------------------------------------------
+%% delete
+%% 
+%% Delete a record from the mib-storage table.
+%% ---------------------------------------------------------------
+delete(#tab{id = ID}, Key) ->
+    ?vtrace("delete from table ~p: ~p", [ID, Key]),
+    ets:delete(ID, Key).
+
+
+%% ---------------------------------------------------------------
+%% match_object
+%% 
+%% Search the mib-storage table for records witch matches 
+%% the pattern.
+%% ---------------------------------------------------------------
+
+match_object(#tab{id = ID}, Pattern) ->
+    ?vtrace("match_object in ~p of ~p", [ID, Pattern]),
+    ets:match_object(ID, Pattern).
+    
+
+%% ---------------------------------------------------------------
+%% match_delete
+%% 
+%% Search the mib-storage table for records witch matches 
+%% the pattern and deletes them from the table.
+%% ---------------------------------------------------------------
+ 
+match_delete(#tab{id = ID}, Pattern) -> 
+    ?vtrace("match_delete in ~p with pattern ~p", [ID, Pattern]),
+    Recs = ets:match_object(ID, Pattern),
+    ets:match_delete(ID, Pattern),
+    Recs.
+
+
+%% ---------------------------------------------------------------
+%% tab2list
+%% 
+%% Return all records in the mib-storage table in the form 
+%% of a list.
+%% ---------------------------------------------------------------
+
+tab2list(#tab{id = ID}) ->
+    ?vtrace("tab2list -> list of ~p", [ID]),
+    ets:tab2list(ID).
+
+
+
+%% ---------------------------------------------------------------
+%% info
+%% 
+%% Retrieve implementation dependent mib-storage table 
+%% information.
+%% ---------------------------------------------------------------
+info(#tab{id = ID}) ->
+    ?vtrace("info on ~p", [ID]),
+    case ets:info(ID) of
+	undefined ->
+	    [];
+	L ->
+	    L
+    end.
+
+
+%% ---------------------------------------------------------------
+%% sync
+%% 
+%% Dump mib-storage table to disc (if there is a file compionent)
+%% ---------------------------------------------------------------
+
+sync(#tab{file = undefined}) ->
+    ok;
+sync(#tab{id = ID, file = File, checksum = Checksum}) ->
+    ?vtrace("sync ~p", [ID]),
+    write_ets_file(ID, File, Checksum).
+
+
+%% ---------------------------------------------------------------
+%% backup
+%% 
+%% Make a backup copy of the mib-storage table. Only valid id
+%% there is a file component. 
+%% ---------------------------------------------------------------
+
+backup(#tab{file = undefined}, _BackupDir) ->
+    ok;
+backup(#tab{id = ID, file = File, checksum = Checksum}, BackupDir) ->
+    ?vtrace("backup ~p to ~p", [ID, BackupDir]),
+    Filename = filename:basename(File),
+    case filename:join(BackupDir, Filename) of
+	File ->
+	    %% Oups: backup-dir and db-dir the same
+	    {error, db_dir};
+	BackupFile ->
+	    write_ets_file(ID, BackupFile, Checksum)
+    end.
+
+	      
+%%----------------------------------------------------------------------
+
+write_ets_file(ID, File, Checksum) when (Checksum =:= true) ->
+    do_write_ets_file(ID, File, [{extended_info, [md5sum]}]);
+write_ets_file(ID, File, Checksum) when (Checksum =:= false) ->
+    do_write_ets_file(ID, File, []).
+
+do_write_ets_file(ID, File, Options) ->
+    TmpFile = File ++ ".tmp",
+    case ets:tab2file(ID, TmpFile, Options) of
+	ok ->
+	    case file:rename(TmpFile, File) of
+		ok ->
+		    ok;
+		Else ->
+		    user_err("Warning: could not move file ~p"
+			     " (~p)", [File, Else])
+	    end;
+	{error, Reason} ->
+	    user_err("Warning: could not save file ~p (~p)",
+		     [File, Reason])
+    end.
+
+
+%%----------------------------------------------------------------------
+
+user_err(F, A) ->
+    snmpa_error:user_err(F, A).
diff --git a/lib/snmp/src/agent/snmpa_mib_storage_mnesia.erl b/lib/snmp/src/agent/snmpa_mib_storage_mnesia.erl
new file mode 100644
index 0000000000..aee2192b24
--- /dev/null
+++ b/lib/snmp/src/agent/snmpa_mib_storage_mnesia.erl
@@ -0,0 +1,265 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2013-2013. 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(snmpa_mib_storage_mnesia).
+
+
+-behaviour(snmpa_mib_storage).
+
+%%%-----------------------------------------------------------------
+%%% This module implements the snmpa_mib_storage behaviour. 
+%%% It uses mnesia for storage. 
+%%%-----------------------------------------------------------------
+
+-export([
+	 open/5, 
+	 close/1, 
+	 read/2, 
+	 write/2, 
+	 delete/1, 
+	 delete/2, 
+	 sync/1, 
+	 backup/2, 
+	 match_object/2, 
+	 match_delete/2, 
+	 tab2list/1, 
+	 info/1
+	]).
+
+
+-define(VMODULE,"MS-MNESIA").
+-include("snmp_verbosity.hrl").
+
+-record(tab, {id}).
+
+
+%% ---------------------------------------------------------------
+%% open
+%% 
+%% Open or create a mnesia table. 
+%% 
+%% Opts    - A list of implementation dependent options
+%%           mnesia_open_options() = [mnesia_open_option()]
+%%           mnesia_open_option()  = {action, keep | clear} | 
+%%                                   {nodes,  [node()]}
+%% 
+%% ---------------------------------------------------------------
+
+open(Name, RecName, Fields, Type, Opts) ->
+    ?vtrace("open ~p table ~p for record ~p",
+	    [Type, Name, RecName]),
+    Action  = snmp_misc:get_option(action, Opts, keep), 
+    Nodes   = snmp_misc:get_option(nodes,  Opts, [node()]), 
+    case table_exists(Name) of
+	true when (Action =:= keep) -> 
+	    {ok, #tab{id = Name}};
+	true when (Action =:= clear) -> 
+	    F = fun() -> mnesia:clear_table(Name) end,
+	    case mnesia:transaction(F) of
+		{aborted, Reason} ->
+		    {error, {clear, Reason}};
+		{atomic, _} ->
+		    {ok, #tab{id = Name}}
+	    end;
+	false ->
+	    Args = [{record_name, RecName}, 
+		    {attributes,  Fields},
+		    {type,        Type}, 
+		    {disc_copies, Nodes}],
+	    case mnesia:create_table(Name, Args) of
+		{atomic, ok} ->
+		    {ok, #tab{id = Name}};
+		{aborted, Reason} ->
+		    {error, {create, Reason}}
+	    end
+    end.
+
+table_exists(Name) ->
+    case (catch mnesia:table_info(Name, type)) of
+	{'EXIT', _Reason} ->
+	    false;
+	_ ->
+	    true
+    end.
+   
+
+%% ---------------------------------------------------------------
+%% close
+%% 
+%% Close the mib-storage table. 
+%% This does nothing in the mnesia case.
+%% ---------------------------------------------------------------
+
+close(_) ->
+    ?vtrace("close mib-storage - ignore",[]),
+    ok.
+
+
+%% ---------------------------------------------------------------
+%% read
+%% 
+%% Retrieve a record from the mib-storage table.
+%% ---------------------------------------------------------------
+
+read(#tab{id = ID}, Key) ->
+    ?vtrace("read (dirty) from database ~p: ~p", [ID, Key]),
+    case (catch mnesia:dirty_read(ID, Key)) of
+	[Rec|_] -> {value,Rec};
+	_ -> false
+    end.
+    
+
+%% ---------------------------------------------------------------
+%% write
+%% 
+%% Write a record to the mib-storage table.
+%% ---------------------------------------------------------------
+
+write(#tab{id = ID}, Rec) -> 
+    ?vtrace("write to database ~p", [ID]),
+    F = fun() -> mnesia:write(ID, Rec, write) end,
+    case mnesia:transaction(F) of
+	{aborted, _Reason} = ABORTED ->
+	    {error, ABORTED};
+	{atomic,_} ->
+	    ok
+    end.
+
+
+%% ---------------------------------------------------------------
+%% delete
+%% 
+%% Delete the mib-storage table. 
+%% ---------------------------------------------------------------
+
+delete(#tab{id = ID}) ->
+    ?vtrace("delete database: ~p", [ID]),
+    mnesia:delete_table(ID).
+
+
+%% ---------------------------------------------------------------
+%% delete
+%% 
+%% Delete a record from the mib-storage table.
+%% ---------------------------------------------------------------
+
+delete(#tab{id = ID}, Key) -> 
+    ?vtrace("delete from database ~p: ~p", [ID, Key]),
+    F = fun() -> mnesia:delete(ID, Key, write) end,
+    case mnesia:transaction(F) of
+	{aborted, _Reason} = ABORTED ->
+	    {error, ABORTED};
+	{atomic, _} ->
+	    ok
+    end.
+
+
+%% ---------------------------------------------------------------
+%% match_object
+%% 
+%% Search the mib-storage table for records witch matches 
+%% the pattern.
+%% ---------------------------------------------------------------
+
+match_object(#tab{id = ID}, Pattern) ->
+    ?vtrace("match_object in ~p of ~p", [ID, Pattern]),
+    F = fun() -> mnesia:match_object(ID, Pattern, read) end,
+    case mnesia:transaction(F) of
+	{aborted, _Reason} = ABORTED ->
+	    {error, ABORTED};
+	{atomic, Rs} ->
+	    Rs
+    end.
+    
+
+%% ---------------------------------------------------------------
+%% match_delete
+%% 
+%% Search the mib-storage table for records witch matches 
+%% the pattern and deletes them from the table.
+%% ---------------------------------------------------------------
+
+match_delete(#tab{id = ID}, Pattern) -> 
+    ?vtrace("match_delete in ~p with pattern ~p", [ID, Pattern]),
+    F = fun() -> 
+		Recs = mnesia:match_object(ID, Pattern, read),
+		lists:foreach(fun(Rec) -> 
+				      mnesia:delete_object(ID, Rec, write)
+			      end, Recs),
+		Recs
+	end,
+    case mnesia:transaction(F) of
+	{aborted, _Reason} = ABORTED ->
+	    {error, ABORTED};
+	{atomic, Rs} ->
+	    Rs
+    end.
+
+
+%% ---------------------------------------------------------------
+%% tab2list
+%% 
+%% Return all records in the mib-storage table in the form of 
+%% a list.
+%% ---------------------------------------------------------------
+
+tab2list(#tab{id = ID} = Tab) ->
+    ?vtrace("tab2list -> list of ~p", [ID]),
+    match_object(Tab, mnesia:table_info(ID, wild_pattern)).
+
+
+%% ---------------------------------------------------------------
+%% info
+%% 
+%% Retrieve implementation dependent mib-storage table 
+%% information.
+%% ---------------------------------------------------------------
+
+info(#tab{id = ID}) ->
+    case (catch mnesia:table_info(ID, all)) of
+	Info when is_list(Info) ->
+	    Info;
+	{'EXIT', {aborted, Reason}} ->
+	    {error, Reason}
+    end.
+
+
+%% ---------------------------------------------------------------
+%% sync
+%% 
+%% Ignore
+%% ---------------------------------------------------------------
+
+sync(_) ->
+    ok.
+
+
+%% ---------------------------------------------------------------
+%% backup
+%% 
+%% Ignore. Mnesia handles its own backups. 
+%% ---------------------------------------------------------------
+
+backup(_, _) ->
+    ok.
+
+	      
+%%----------------------------------------------------------------------
+
+%% user_err(F, A) ->
+%%     snmpa_error:user_err(F, A).
diff --git a/lib/snmp/src/agent/snmpa_supervisor.erl b/lib/snmp/src/agent/snmpa_supervisor.erl
index 886fd074bc..1c8db7ff07 100644
--- a/lib/snmp/src/agent/snmpa_supervisor.erl
+++ b/lib/snmp/src/agent/snmpa_supervisor.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 1996-2012. All Rights Reserved.
+%% Copyright Ericsson AB 1996-2013. 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
@@ -224,25 +224,100 @@ init([AgentType, Opts]) ->
     ets:insert(snmp_agent_table, {error_report_mod, ErrorReportMod}),
 
     %% -- mib storage --
+    %% MibStorage has only one mandatory part: module
+    %% Everything else is module dependent and therefor 
+    %% put in a special option: options
     MibStorage = 
-	case get_opt(mib_storage, Opts, ets) of
+	case get_opt(mib_storage, Opts, [{module, snmpa_mib_storage_ets}]) of
+
+	    %% --- ETS wrappers ---
+
+	    ets ->
+		[{module, snmpa_mib_storage_ets}];
+	    {ets, default} ->
+		[{module,  snmpa_mib_storage_ets}, 
+		 {options, [{dir,    filename:join([DbDir])}, 
+			    {action, keep}]}];
+	    {ets, Dir} when is_list(Dir) ->
+		[{module,  snmpa_mib_storage_ets}, 
+		 {options, [{dir,    filename:join([Dir])}, 
+			    {action, keep}]}];
+	    {ets, default, Action} when ((Action =:= keep) orelse 
+					 (Action =:= clear)) ->
+		[{module,  snmpa_mib_storage_ets}, 
+		 {options, [{dir,    filename:join([DbDir])}, 
+			    {action, Action}]}];
+	    {ets, Dir, Action} when is_list(Dir) andalso 
+				    ((Action =:= keep) orelse 
+				     (Action =:= clear)) ->
+		[{module,  snmpa_mib_storage_ets}, 
+		 {options, [{dir,    filename:join([Dir])}, 
+			    {action, Action}]}];
+
+	    %% --- DETS wrappers ---
+
 	    dets ->
-		{dets, DbDir};
+		[{module,  snmpa_mib_storage_dets}, 
+		 {options, [{dir,    filename:join([DbDir])}, 
+			    {action, keep}]}];
 	    {dets, default} ->
-		{dets, DbDir};
-	    {dets, default, Act} ->
-		{dets, DbDir, Act};
-	    {ets, default} ->
-		{ets, DbDir};
+		[{module,  snmpa_mib_storage_dets}, 
+		 {options, [{dir,    filename:join([DbDir])}, 
+			    {action, keep}]}];
+	    {dets, default, Action} when ((Action =:= keep) orelse 
+					  (Action =:= clear)) ->
+		[{module,  snmpa_mib_storage_dets}, 
+		 {options, [{dir,    filename:join([DbDir])}, 
+			    {action, Action}]}];
+	    {dets, Dir, Action} when is_list(Dir) andalso 
+				     ((Action =:= keep) orelse 
+				      (Action =:= clear)) ->
+		[{module,  snmpa_mib_storage_dets}, 
+		 {options, [{dir,    filename:join([Dir])}, 
+			    {action, Action}]}];
+
+	    %% --- Mnesia wrappers ---
+
 	    mnesia ->
-		{mnesia, erlang:nodes()};
-	    {mnesia, visible} ->
-		{mnesia, erlang:nodes(visible)};
-	    {mnesia, connected} ->
-		{mnesia, erlang:nodes(connected)};
-	    Other ->
+		[{module,  snmpa_mib_storage_mnesia}, 
+		 {options, [{nodes,  erlang:nodes()}, 
+			    {action, keep}]}];
+	    {mnesia, Nodes0} ->
+		Nodes = 
+		    if
+			Nodes0 =:= visible ->
+			    erlang:nodes(visible);
+			Nodes0 =:= connected ->
+			    erlang:nodes(connected);
+			Nodes0 =:= [] ->
+			    [node()];
+			true ->
+			    Nodes0
+		    end,
+		[{module, snmpa_mib_storage_mnesia}, 
+		 {options, [{nodes,  Nodes}, 
+			    {action, keep}]}];
+	    {mnesia, Nodes0, Action} when ((Action =:= keep) orelse 
+					   (Action =:= clear)) ->
+		Nodes = 
+		    if
+			Nodes0 =:= visible ->
+			    erlang:nodes(visible);
+			Nodes0 =:= connected ->
+			    erlang:nodes(connected);
+			Nodes0 =:= [] ->
+			    [node()];
+			true ->
+			    Nodes0
+		    end,
+		[{module,  snmpa_mib_storage_mnesia}, 
+		 {options, [{nodes,  Nodes}, 
+			    {action, Action}]}];
+
+	    Other when is_list(Other) ->
 		Other
 	end,
+
     ?vdebug("[agent table] store mib storage: ~w",[MibStorage]),
     ets:insert(snmp_agent_table, {mib_storage, MibStorage}),