Merge branch 'maint'

Conflicts:
	lib/ssl/test/ssl_dist_bench_SUITE.erl

6 files changed, 310 insertions, 87 deletions

diff --git a/lib/ssl/src/ssl_connection.erl b/lib/ssl/src/ssl_connection.erl
index 8b752f0fda..5d5fd6e450 100644
--- a/lib/ssl/src/ssl_connection.erl
+++ b/lib/ssl/src/ssl_connection.erl
@@ -52,8 +52,8 @@
 
 %% Alert and close handling
 -export([handle_own_alert/4, handle_alert/3, 
-	 handle_normal_shutdown/3, stop/2, stop_and_reply/3
-	]).
+	 handle_normal_shutdown/3, stop/2, stop_and_reply/3,
+         handle_trusted_certs_db/1]).
 
 %% Data handling
 -export([read_application_data/2, internal_renegotiation/2]).
@@ -1103,6 +1103,12 @@ downgrade(internal, #alert{description = ?CLOSE_NOTIFY},
 downgrade(timeout, downgrade, #state{downgrade = {_, From}} = State, _) ->
     gen_statem:reply(From, {error, timeout}),
     stop(normal, State);
+downgrade(
+  info, {CloseTag, Socket},
+  #state{socket = Socket, close_tag = CloseTag, downgrade = {_, From}} =
+      State, _) ->
+    gen_statem:reply(From, {error, CloseTag}),
+    stop(normal, State);
 downgrade(Type, Event, State, Connection) ->
     handle_common_event(Type, Event, ?FUNCTION_NAME, State, Connection).
 
diff --git a/lib/ssl/src/tls_connection.erl b/lib/ssl/src/tls_connection.erl
index 296a68e8f3..ae784380c8 100644
--- a/lib/ssl/src/tls_connection.erl
+++ b/lib/ssl/src/tls_connection.erl
@@ -406,13 +406,11 @@ send_alert_in_connection(#alert{description = ?CLOSE_NOTIFY} = Alert, State) ->
 send_alert_in_connection(Alert,
                          #state{protocol_specific = #{sender := Sender}}) ->
     tls_sender:send_alert(Sender, Alert).
-send_sync_alert(Alert, #state{protocol_specific = #{sender := Sender}}= State) ->
-    tls_sender:send_and_ack_alert(Sender, Alert),
-    receive
-        {Sender, ack_alert} ->
-            ok
-    after ?DEFAULT_TIMEOUT ->
-            %% Sender is blocked terminate anyway
+send_sync_alert(
+  Alert, #state{protocol_specific = #{sender := Sender}} = State) ->
+    try tls_sender:send_and_ack_alert(Sender, Alert)
+    catch
+        _:_ ->
             throw({stop, {shutdown, own_alert}, State})
     end.
 
@@ -808,6 +806,12 @@ wait_sh(Type, Event, State) ->
 callback_mode() ->
     state_functions.
 
+
+terminate(
+  {shutdown, sender_died, Reason}, _StateName,
+  #state{socket = Socket, transport_cb = Transport} = State) ->
+    ssl_connection:handle_trusted_certs_db(State),
+    close(Reason, Socket, Transport, undefined, undefined);
 terminate(Reason, StateName, State) ->
     catch ssl_connection:terminate(Reason, StateName, State),
     ensure_sender_terminate(Reason, State).
diff --git a/lib/ssl/src/tls_record.erl b/lib/ssl/src/tls_record.erl
index 50fad2e680..ed7b475619 100644
--- a/lib/ssl/src/tls_record.erl
+++ b/lib/ssl/src/tls_record.erl
@@ -116,7 +116,7 @@ encode_handshake(Frag, Version,
 		     ConnectionStates) ->
     case iolist_size(Frag) of
 	N  when N > ?MAX_PLAIN_TEXT_LENGTH ->
-	    Data = split_bin(iolist_to_binary(Frag), ?MAX_PLAIN_TEXT_LENGTH, Version, BCA, BeastMitigation),
+	    Data = split_bin(iolist_to_binary(Frag), Version, BCA, BeastMitigation),
 	    encode_iolist(?HANDSHAKE, Data, Version, ConnectionStates);
 	_  ->
 	    encode_plain_text(?HANDSHAKE, Version, Frag, ConnectionStates)
@@ -157,7 +157,7 @@ encode_data(Frag, Version,
 				 security_parameters :=
 				     #security_parameters{bulk_cipher_algorithm = BCA}}} =
 		ConnectionStates) ->
-    Data = split_bin(Frag, ?MAX_PLAIN_TEXT_LENGTH, Version, BCA, BeastMitigation),
+    Data = split_bin(Frag, Version, BCA, BeastMitigation),
     encode_iolist(?APPLICATION_DATA, Data, Version, ConnectionStates).
 
 %%====================================================================
@@ -526,27 +526,26 @@ start_additional_data(Type, {MajVer, MinVer},
 
 %% 1/n-1 splitting countermeasure Rizzo/Duong-Beast, RC4 chiphers are
 %% not vulnerable to this attack.
-split_bin(<<FirstByte:8, Rest/binary>>, ChunkSize, Version, BCA, one_n_minus_one) when
+split_bin(<<FirstByte:8, Rest/binary>>, Version, BCA, one_n_minus_one) when
       BCA =/= ?RC4 andalso ({3, 1} == Version orelse
 			    {3, 0} == Version) ->
-    do_split_bin(Rest, ChunkSize, [[FirstByte]]);
+    [[FirstByte]|do_split_bin(Rest)];
 %% 0/n splitting countermeasure for clients that are incompatible with 1/n-1
 %% splitting.
-split_bin(Bin, ChunkSize, Version, BCA, zero_n) when
+split_bin(Bin, Version, BCA, zero_n) when
       BCA =/= ?RC4 andalso ({3, 1} == Version orelse
 			    {3, 0} == Version) ->
-    do_split_bin(Bin, ChunkSize, [[<<>>]]);
-split_bin(Bin, ChunkSize, _, _, _) ->
-    do_split_bin(Bin, ChunkSize, []).
+    [<<>>|do_split_bin(Bin)];
+split_bin(Bin, _, _, _) ->
+    do_split_bin(Bin).
 
-do_split_bin(<<>>, _, Acc) ->
-    lists:reverse(Acc);
-do_split_bin(Bin, ChunkSize, Acc) ->
+do_split_bin(<<>>) -> [];
+do_split_bin(Bin) ->
     case Bin of
-        <<Chunk:ChunkSize/binary, Rest/binary>> ->
-            do_split_bin(Rest, ChunkSize, [Chunk | Acc]);
+        <<Chunk:?MAX_PLAIN_TEXT_LENGTH/binary, Rest/binary>> ->
+            [Chunk|do_split_bin(Rest)];
         _ ->
-            lists:reverse(Acc, [Bin])
+            [Bin]
     end.
 %%--------------------------------------------------------------------
 lowest_list_protocol_version(Ver, []) ->
diff --git a/lib/ssl/src/tls_sender.erl b/lib/ssl/src/tls_sender.erl
index 75409143a8..0631ed808a 100644
--- a/lib/ssl/src/tls_sender.erl
+++ b/lib/ssl/src/tls_sender.erl
@@ -103,7 +103,7 @@ send_alert(Pid, Alert) ->
 %% in the connection state and recive an ack.
 %%--------------------------------------------------------------------
 send_and_ack_alert(Pid, Alert) ->
-    gen_statem:cast(Pid, {ack_alert, Alert}).
+    gen_statem:call(Pid, {ack_alert, Alert}, ?DEFAULT_TIMEOUT).
 %%--------------------------------------------------------------------
 -spec setopts(pid(), [{packet, integer() | atom()}]) -> ok | {error, term()}.
 %%  Description: Send application data
@@ -203,8 +203,9 @@ connection({call, From}, renegotiate,
            #data{connection_states = #{current_write := Write}} = StateData) ->
     {next_state, handshake, StateData, [{reply, From, {ok, Write}}]};
 connection({call, From}, {application_data, AppData}, 
-           #data{socket_options = SockOpts} = StateData) ->                   
-    case encode_packet(AppData, SockOpts) of
+           #data{socket_options = #socket_options{packet = Packet}} =
+               StateData) ->
+    case encode_packet(Packet, AppData) of
         {error, _} = Error ->
             {next_state, ?FUNCTION_NAME, StateData, [{reply, From, Error}]};
         Data ->
@@ -220,17 +221,30 @@ connection({call, From}, dist_get_tls_socket,
                  tracker = Tracker} = StateData) ->
     TLSSocket = Connection:socket([Pid, self()], Transport, Socket, Connection, Tracker),
     {next_state, ?FUNCTION_NAME, StateData, [{reply, From, {ok, TLSSocket}}]};
-connection({call, From}, {dist_handshake_complete, _Node, DHandle}, #data{connection_pid = Pid} = StateData) ->
+connection({call, From}, {dist_handshake_complete, _Node, DHandle},
+           #data{connection_pid = Pid,
+                 socket_options = #socket_options{packet = Packet}} =
+               StateData) ->
     ok = erlang:dist_ctrl_input_handler(DHandle, Pid),
     ok = ssl_connection:dist_handshake_complete(Pid, DHandle),
     %% From now on we execute on normal priority
     process_flag(priority, normal),
-    Events = dist_data_events(DHandle, []),
-    {next_state, ?FUNCTION_NAME, StateData#data{dist_handle = DHandle}, [{reply, From, ok} | Events]};
-connection(cast, {ack_alert, #alert{} = Alert}, #data{connection_pid = Pid} =StateData0) ->
+    {next_state, ?FUNCTION_NAME, StateData#data{dist_handle = DHandle},
+     [{reply, From, ok}
+      | case dist_data(DHandle, Packet) of
+            [] ->
+                [];
+            Data ->
+                [{next_event, internal,
+                  {application_packets,{self(),undefined},Data}}]
+        end]};
+connection({call, From}, {ack_alert, #alert{} = Alert}, StateData0) ->
     StateData = send_tls_alert(Alert, StateData0),
-    Pid ! {self(), ack_alert},
-    {next_state, ?FUNCTION_NAME, StateData};
+    {next_state, ?FUNCTION_NAME, StateData,
+     [{reply,From,ok}]};
+connection(internal, {application_packets, From, Data}, StateData) ->
+    send_application_data(Data, From, ?FUNCTION_NAME, StateData);
+%%
 connection(cast, #alert{} = Alert, StateData0) ->
     StateData = send_tls_alert(Alert, StateData0),
     {next_state, ?FUNCTION_NAME, StateData};
@@ -240,9 +254,19 @@ connection(cast, {new_write, WritesState, Version},
      StateData#data{connection_states = 
                         ConnectionStates0#{current_write => WritesState},
                     negotiated_version = Version}};
-connection(info, dist_data, #data{dist_handle = DHandle} = StateData) ->  
-    Events = dist_data_events(DHandle, []),
-    {next_state, ?FUNCTION_NAME, StateData, Events};
+%%
+connection(info, dist_data,
+           #data{dist_handle = DHandle,
+                 socket_options = #socket_options{packet = Packet}} =
+               StateData) ->
+    {next_state, ?FUNCTION_NAME, StateData,
+      case dist_data(DHandle, Packet) of
+          [] ->
+              [];
+          Data ->
+              [{next_event, internal,
+               {application_packets,{self(),undefined},Data}}]
+      end};
 connection(info, tick, StateData) ->  
     consume_ticks(),
     {next_state, ?FUNCTION_NAME, StateData, 
@@ -275,6 +299,8 @@ handshake(cast, {new_write, WritesState, Version},
      StateData#data{connection_states = 
                         ConnectionStates0#{current_write => WritesState},
                    negotiated_version = Version}};
+handshake(internal, {application_packets,_,_}, _) ->
+    {keep_state_and_data, [postpone]};
 handshake(info, Msg, StateData) -> 
     handle_info(Msg, ?FUNCTION_NAME, StateData).
 
@@ -351,12 +377,13 @@ send_application_data(Data, From, StateName,
                              log_level = LogLevel} = StateData0) ->
     case time_to_renegotiate(Data, ConnectionStates0, RenegotiateAt) of
 	true ->
-	    ssl_connection:internal_renegotiation(Pid, ConnectionStates0), 
+	    ssl_connection:internal_renegotiation(Pid, ConnectionStates0),
             {next_state, handshake, StateData0, 
-             [{next_event, {call, From}, {application_data, Data}}]};
+             [{next_event, internal, {application_packets, From, Data}}]};
 	false ->
 	    {Msgs, ConnectionStates} =
-                Connection:encode_data(Data, Version, ConnectionStates0),
+                Connection:encode_data(
+                  iolist_to_binary(Data), Version, ConnectionStates0),
             StateData = StateData0#data{connection_states = ConnectionStates},
 	    case Connection:send(Transport, Socket, Msgs) of
                 ok when DistHandle =/=  undefined ->
@@ -378,21 +405,18 @@ send_application_data(Data, From, StateName,
             end
     end.
 
-encode_packet(Data, #socket_options{packet=Packet}) ->
+-compile({inline, encode_packet/2}).
+encode_packet(Packet, Data) ->
+    Len = iolist_size(Data),
     case Packet of
-	1 -> encode_size_packet(Data, 8,  (1 bsl 8) - 1);
-	2 -> encode_size_packet(Data, 16, (1 bsl 16) - 1);
-	4 -> encode_size_packet(Data, 32, (1 bsl 32) - 1);
-	_ -> Data
-    end.
-
-encode_size_packet(Bin, Size, Max) ->
-    Len = erlang:byte_size(Bin),
-    case Len > Max of
-	true  -> 
-            {error, {badarg, {packet_to_large, Len, Max}}};
-        false -> 
-            <<Len:Size, Bin/binary>>
+        1 when Len < (1 bsl 8) ->  [<<Len:8>>,Data];
+        2 when Len < (1 bsl 16) -> [<<Len:16>>,Data];
+        4 when Len < (1 bsl 32) -> [<<Len:32>>,Data];
+        N when N =:= 1; N =:= 2; N =:= 4 ->
+            {error,
+             {badarg, {packet_to_large, Len, (1 bsl (Packet bsl 3)) - 1}}};
+        _ ->
+            Data
     end.
 
 set_opts(SocketOptions, [{packet, N}]) ->
@@ -426,14 +450,18 @@ call(FsmPid, Event) ->
 
 %%---------------Erlang distribution --------------------------------------
 
-dist_data_events(DHandle, Events) ->
+dist_data(DHandle, Packet) ->
     case erlang:dist_ctrl_get_data(DHandle) of
         none ->
             erlang:dist_ctrl_get_data_notification(DHandle),
-            lists:reverse(Events);
+            [];
         Data ->
-            Event = {next_event, {call, {self(), undefined}}, {application_data, Data}},
-            dist_data_events(DHandle, [Event | Events])
+            %% This is encode_packet(4, Data) without Len check
+            %% since the emulator will always deliver a Data
+            %% smaller than 4 GB, and the distribution will
+            %% therefore always have to use {packet,4}
+            Len = iolist_size(Data),
+            [<<Len:32>>,Data|dist_data(DHandle, Packet)]
     end.
 
 consume_ticks() ->
diff --git a/lib/ssl/test/ssl_dist_bench_SUITE.erl b/lib/ssl/test/ssl_dist_bench_SUITE.erl
index daedd254d7..d9d9c4e473 100644
--- a/lib/ssl/test/ssl_dist_bench_SUITE.erl
+++ b/lib/ssl/test/ssl_dist_bench_SUITE.erl
@@ -33,6 +33,8 @@
    [setup/1,
     roundtrip/1,
     sched_utilization/1,
+    throughput_0/1,
+    throughput_64/1,
     throughput_1024/1,
     throughput_4096/1,
     throughput_16384/1,
@@ -57,7 +59,9 @@ groups() ->
      {roundtrip, [{repeat, 1}], [roundtrip]},
      {sched_utilization,[{repeat, 1}], [sched_utilization]},
      {throughput, [{repeat, 1}],
-      [throughput_1024,
+      [throughput_0,
+       throughput_64,
+       throughput_1024,
        throughput_4096,
        throughput_16384,
        throughput_65536,
@@ -251,8 +255,9 @@ setup(A, B, Prefix, HA, HB) ->
     [] = ssl_apply(HB, erlang, nodes, []),
     {SetupTime, CycleTime} =
         ssl_apply(HA, fun () -> setup_runner(A, B, Rounds) end),
-    [] = ssl_apply(HA, erlang, nodes, []),
-    [] = ssl_apply(HB, erlang, nodes, []),
+    ok = ssl_apply(HB, fun () -> setup_wait_nodedown(A, 10000) end),
+    %% [] = ssl_apply(HA, erlang, nodes, []),
+    %% [] = ssl_apply(HB, erlang, nodes, []),
     SetupSpeed = round((Rounds*1000000*1000) / SetupTime),
     CycleSpeed = round((Rounds*1000000*1000) / CycleTime),
     _ = report(Prefix++" Setup", SetupSpeed, "setups/1000s"),
@@ -279,6 +284,22 @@ setup_loop(A, B, T, N) ->
             setup_loop(A, B, Time + T, N - 1)
     end.
 
+setup_wait_nodedown(A, Time) ->
+    ok = net_kernel:monitor_nodes(true),
+    case nodes() of
+        [] ->
+            ok;
+        [A] ->
+            receive
+                {nodedown,A} ->
+                    ok;
+                Unexpected ->
+                    {error,{unexpected,Unexpected}}
+            after Time ->
+                    {error,timeout}
+            end
+    end.
+
 
 %%----------------
 %% Roundtrip speed
@@ -386,14 +407,15 @@ sched_util_runner(A, B, Senders) ->
                           Pid ! {ServerPid,msacc:stats()}
                   end
           end),
-    ServerMon = erlang:monitor(process, ServerPid),
-    ClientPid =
-        spawn_link(fun() ->
-                           %% We spawn 250 senders which should mean that we
-                           %% have a load of 250 msgs/msec
-                           [spawn_link(fun() -> throughput_client(ServerPid,Payload) end) ||
-                               _ <- lists:seq(1, Senders)]
-                   end),
+    spawn_link(
+      fun() ->
+              %% We spawn 250 senders which should mean that we
+              %% have a load of 250 msgs/msec
+              [spawn_link(
+                 fun() ->
+                         throughput_client(ServerPid,Payload)
+                 end) || _ <- lists:seq(1, Senders)]
+      end),
 
     erlang:system_monitor(self(),[busy_dist_port]),
     ServerMsacc ! {start,self()},
@@ -430,6 +452,18 @@ throughput_client(Pid, Payload) ->
 %%-----------------
 %% Throughput speed
 
+throughput_0(Config) ->
+    run_nodepair_test(
+      fun (A, B, Prefix, HA, HB) ->
+              throughput(A, B, Prefix, HA, HB, 500000, 0)
+      end, Config).
+
+throughput_64(Config) ->
+    run_nodepair_test(
+      fun (A, B, Prefix, HA, HB) ->
+              throughput(A, B, Prefix, HA, HB, 500000, 64)
+      end, Config).
+
 throughput_1024(Config) ->
     run_nodepair_test(
       fun (A, B, Prefix, HA, HB) ->
@@ -469,45 +503,198 @@ throughput_1048576(Config) ->
 throughput(A, B, Prefix, HA, HB, Packets, Size) ->
     [] = ssl_apply(HA, erlang, nodes, []),
     [] = ssl_apply(HB, erlang, nodes, []),
-    Time =
+    #{time := Time,
+      dist_stats := DistStats,
+      client_msacc_stats := ClientMsaccStats,
+      client_prof := ClientProf,
+      server_msacc_stats := ServerMsaccStats,
+      server_prof := ServerProf} =
         ssl_apply(HA, fun () -> throughput_runner(A, B, Packets, Size) end),
     [B] = ssl_apply(HA, erlang, nodes, []),
     [A] = ssl_apply(HB, erlang, nodes, []),
-    Speed = round((Packets*Size*1000000) / (1024*Time)),
+    ClientMsaccStats =:= undefined orelse
+        msacc:print(ClientMsaccStats),
+    io:format("DistStats: ~p~n", [DistStats]),
+    Overhead =
+        50 % Distribution protocol headers (empirical) (TLS+=54)
+        + byte_size(erlang:term_to_binary([0|<<>>])), % Benchmark overhead
+    Bytes = Packets * (Size + Overhead),
+    io:format("~w bytes, ~.4g s~n", [Bytes,Time/1000000]),
+    ClientMsaccStats =:= undefined orelse
+        io:format(
+          "Sender core usage ratio: ~.4g ns/byte~n",
+          [msacc:stats(system_runtime, ClientMsaccStats)*1000/Bytes]),
+    ServerMsaccStats =:= undefined orelse
+        begin
+            io:format(
+              "Receiver core usage ratio: ~.4g ns/byte~n",
+              [msacc:stats(system_runtime, ServerMsaccStats)*1000/Bytes]),
+            msacc:print(ServerMsaccStats)
+        end,
+    io:format("******* ClientProf:~n", []), prof_print(ClientProf),
+    io:format("******* ServerProf:~n", []), prof_print(ServerProf),
+    Speed = round((Bytes * 1000000) / (1024 * Time)),
     report(Prefix++" Throughput_"++integer_to_list(Size), Speed, "kB/s").
 
 %% Runs on node A and spawns a server on node B
 throughput_runner(A, B, Rounds, Size) ->
     Payload = payload(Size),
-    ClientPid = self(),
     [A] = rpc:call(B, erlang, nodes, []),
+    ClientPid = self(),
     ServerPid =
         erlang:spawn(
           B,
           fun () -> throughput_server(ClientPid, Rounds) end),
     ServerMon = erlang:monitor(process, ServerPid),
-    microseconds(
-      throughput_client(
-        ServerPid, ServerMon, Payload, start_time(), Rounds)).
+    msacc:available() andalso
+        begin
+            msacc:stop(),
+            msacc:reset(),
+            msacc:start(),
+            ok
+        end,
+    prof_start(),
+    {Time,ServerMsaccStats,ServerProf} =
+        throughput_client(ServerPid, ServerMon, Payload, Rounds),
+    prof_stop(),
+    ClientMsaccStats =
+        case msacc:available() of
+            true ->
+                MStats = msacc:stats(),
+                msacc:stop(),
+                MStats;
+            false ->
+                undefined
+        end,
+    ClientProf = prof_end(),
+    [{_Node,Socket}] = dig_dist_node_sockets(),
+    DistStats = inet:getstat(Socket),
+    #{time => microseconds(Time),
+      dist_stats => DistStats,
+      client_msacc_stats => ClientMsaccStats,
+      client_prof => ClientProf,
+      server_msacc_stats => ServerMsaccStats,
+      server_prof => ServerProf}.
+
+dig_dist_node_sockets() ->
+    [case DistCtrl of
+         {_Node,Socket} = NodeSocket when is_port(Socket) ->
+             NodeSocket;
+         {Node,DistCtrlPid} when is_pid(DistCtrlPid) ->
+             [{links,DistCtrlLinks}] = process_info(DistCtrlPid, [links]),
+             case [S || S <- DistCtrlLinks, is_port(S)] of
+                 [Socket] ->
+                     {Node,Socket};
+                 [] ->
+                     [{monitors,[{process,DistSenderPid}]}] =
+                         process_info(DistCtrlPid, [monitors]),
+                     [{links,DistSenderLinks}] =
+                         process_info(DistSenderPid, [links]),
+                     [Socket] = [S || S <- DistSenderLinks, is_port(S)],
+                     {Node,Socket}
+             end
+     end || DistCtrl <- erlang:system_info(dist_ctrl)].
+
 
-throughput_server(_Pid, 0) ->
-    ok;
 throughput_server(Pid, N) ->
+    msacc:available() andalso
+        begin
+            msacc:stop(),
+            msacc:reset(),
+            msacc:start(),
+            ok
+        end,
+    prof_start(),
+    throughput_server_loop(Pid, N).
+
+throughput_server_loop(_Pid, 0) ->
+    prof_stop(),
+    MsaccStats =
+        case msacc:available() of
+            true ->
+                msacc:stop(),
+                MStats = msacc:stats(),
+                msacc:reset(),
+                MStats;
+            false ->
+                undefined
+        end,
+    Prof = prof_end(),
+    exit({ok,MsaccStats,Prof});
+throughput_server_loop(Pid, N) ->
     receive
-        [N|_] ->
-            throughput_server(Pid, N-1)
+        {Pid, N, _} ->
+            throughput_server_loop(Pid, N-1)
     end.
 
-throughput_client(_Pid, Mon, _Payload, StartTime, 0) ->
+throughput_client(Pid, Mon, Payload, N) ->
+    throughput_client_loop(Pid, Mon, Payload, N, start_time()).
+
+throughput_client_loop(_Pid, Mon, _Payload, 0, StartTime) ->
     receive
-        {'DOWN', Mon, _, _, normal} ->
-            elapsed_time(StartTime);
+        {'DOWN', Mon, _, _, {ok,MsaccStats,Prof}} ->
+            {elapsed_time(StartTime),MsaccStats,Prof};
         {'DOWN', Mon, _, _, Other} ->
             exit(Other)
     end;
-throughput_client(Pid, Mon, Payload, StartTime, N) ->
-    Pid ! [N|Payload],
-    throughput_client(Pid, Mon, Payload, StartTime, N - 1).
+throughput_client_loop(Pid, Mon, Payload, N, StartTime) ->
+    Pid ! {self(), N, Payload},
+    throughput_client_loop(Pid, Mon, Payload, N - 1, StartTime).
+
+
+-define(prof, none). % none | cprof | eprof
+
+-if(?prof =:= cprof).
+prof_start() ->
+    cprof:stop(),
+    cprof:start(),
+    ok.
+-elif(?prof =:= eprof).
+prof_start() ->
+    {ok,_} = eprof:start(),
+    profiling = eprof:start_profiling(processes()),
+    ok.
+-elif(?prof =:= none).
+prof_start() ->
+    ok.
+-endif.
+
+-if(?prof =:= cprof).
+prof_stop() ->
+    cprof:pause(),
+    ok.
+-elif(?prof =:= eprof).
+prof_stop() ->
+    _ = eprof:stop_profiling(),
+    ok.
+-elif(?prof =:= none).
+prof_stop() ->
+    ok.
+-endif.
+
+-if(?prof =:= cprof).
+prof_end() ->
+    Prof = cprof:analyse(),
+    cprof:stop(),
+    Prof.
+-elif(?prof =:= eprof).
+prof_end() ->
+    eprof:dump_data().
+-elif(?prof =:= none).
+prof_end() ->
+    [].
+-endif.
+
+-if(?prof =:= cprof).
+prof_print(Prof) ->
+    io:format("~p.~n", [Prof]).
+-elif(?prof =:= eprof).
+prof_print(Dump) ->
+    eprof:analyze(undefined, total, [], Dump).
+-elif(?prof =:= none).
+prof_print([]) ->
+    ok.
+-endif.
 
 %%%-------------------------------------------------------------------
 %%% Test cases helpers
diff --git a/lib/ssl/test/ssl_test_lib.erl b/lib/ssl/test/ssl_test_lib.erl
index 8a2f0824fb..a8d62d6c4e 100644
--- a/lib/ssl/test/ssl_test_lib.erl
+++ b/lib/ssl/test/ssl_test_lib.erl
@@ -26,6 +26,7 @@
 
 %% Note: This directive should only be used in test suites.
 -compile(export_all).
+-compile(nowarn_export_all).
 
 -record(sslsocket, { fd = nil, pid = nil}).
 -define(SLEEP, 1000).
@@ -1706,10 +1707,10 @@ openssl_dsa_support() ->
             true;
         "LibreSSL"  ++ _ ->
             false;
-        "OpenSSL 1.1" ++ Rest ->
+        "OpenSSL 1.1" ++ _Rest ->
             false;
         "OpenSSL 1.0.1" ++ Rest ->
-            hd(Rest) >= s;
+            hd(Rest) >= $s;
         _ ->
             true
     end.
@@ -1746,8 +1747,6 @@ openssl_sane_client_cert() ->
             false; 
          "LibreSSL 2.0" ++ _ ->
             false; 
-         "LibreSSL 2.0" ++ _ ->
-            false; 
         "OpenSSL 1.0.1s-freebsd" ->
             false;
         "OpenSSL 1.0.0" ++ _ ->