From d01db89d905eb85b014e2d9b701a507d41cd2dff Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 22 Sep 2022 15:02:04 +0200 Subject: [PATCH] s4:torture/smb2: move benchmarking tests to bench.c I'll add more tests there soon Signed-off-by: Stefan Metzmacher Reviewed-by: Volker Lendecke --- source4/torture/smb2/bench.c | 941 +++++++++++++++++++++++++++++++++++++ source4/torture/smb2/create.c | 813 -------------------------------- source4/torture/smb2/wscript_build | 1 + 3 files changed, 942 insertions(+), 813 deletions(-) create mode 100644 source4/torture/smb2/bench.c diff --git a/source4/torture/smb2/bench.c b/source4/torture/smb2/bench.c new file mode 100644 index 00000000000..2793b50fb4c --- /dev/null +++ b/source4/torture/smb2/bench.c @@ -0,0 +1,941 @@ +/* + Unix SMB/CIFS implementation. + + SMB2 bench test suite + + Copyright (C) Stefan Metzmacher 2022 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "libcli/smb2/smb2.h" +#include "libcli/smb2/smb2_calls.h" +#include "libcli/smb/smbXcli_base.h" +#include "torture/torture.h" +#include "torture/util.h" +#include "torture/smb2/proto.h" +#include "librpc/gen_ndr/ndr_security.h" +#include "libcli/security/security.h" + +#include "system/filesys.h" +#include "auth/credentials/credentials.h" +#include "lib/cmdline/cmdline.h" +#include "librpc/gen_ndr/security.h" +#include "lib/events/events.h" + +#define FNAME "test_create.dat" +#define DNAME "smb2_open" + +#define CHECK_STATUS(status, correct) do { \ + if (!NT_STATUS_EQUAL(status, correct)) { \ + torture_result(tctx, TORTURE_FAIL, \ + "(%s) Incorrect status %s - should be %s\n", \ + __location__, nt_errstr(status), nt_errstr(correct)); \ + return false; \ + }} while (0) + +#define CHECK_EQUAL(v, correct) do { \ + if (v != correct) { \ + torture_result(tctx, TORTURE_FAIL, \ + "(%s) Incorrect value for %s 0x%08llx - " \ + "should be 0x%08llx\n", \ + __location__, #v, \ + (unsigned long long)v, \ + (unsigned long long)correct); \ + return false; \ + }} while (0) + +#define CHECK_TIME(t, field) do { \ + time_t t1, t2; \ + finfo.all_info.level = RAW_FILEINFO_ALL_INFORMATION; \ + finfo.all_info.in.file.handle = h1; \ + status = smb2_getinfo_file(tree, tctx, &finfo); \ + CHECK_STATUS(status, NT_STATUS_OK); \ + t1 = t & ~1; \ + t2 = nt_time_to_unix(finfo.all_info.out.field) & ~1; \ + if (abs(t1-t2) > 2) { \ + torture_result(tctx, TORTURE_FAIL, \ + "(%s) wrong time for field %s %s - %s\n", \ + __location__, #field, \ + timestring(tctx, t1), \ + timestring(tctx, t2)); \ + dump_all_info(tctx, &finfo); \ + ret = false; \ + }} while (0) + +#define CHECK_NTTIME(t, field) do { \ + NTTIME t2; \ + finfo.all_info.level = RAW_FILEINFO_ALL_INFORMATION; \ + finfo.all_info.in.file.handle = h1; \ + status = smb2_getinfo_file(tree, tctx, &finfo); \ + CHECK_STATUS(status, NT_STATUS_OK); \ + t2 = finfo.all_info.out.field; \ + if (llabs((int64_t)(t-t2)) > 20000) { \ + torture_result(tctx, TORTURE_FAIL, \ + "(%s) wrong time for field %s %s - %s\n", \ + __location__, #field, \ + nt_time_string(tctx, t), \ + nt_time_string(tctx, t2)); \ + dump_all_info(tctx, &finfo); \ + ret = false; \ + }} while (0) + +#define CHECK_ALL_INFO(v, field) do { \ + finfo.all_info.level = RAW_FILEINFO_ALL_INFORMATION; \ + finfo.all_info.in.file.handle = h1; \ + status = smb2_getinfo_file(tree, tctx, &finfo); \ + CHECK_STATUS(status, NT_STATUS_OK); \ + if ((v) != (finfo.all_info.out.field)) { \ + torture_result(tctx, TORTURE_FAIL, \ + "(%s) wrong value for field %s 0x%x - 0x%x\n", \ + __location__, #field, (int)v,\ + (int)(finfo.all_info.out.field)); \ + dump_all_info(tctx, &finfo); \ + ret = false; \ + }} while (0) + +#define CHECK_VAL(v, correct) do { \ + if ((v) != (correct)) { \ + torture_result(tctx, TORTURE_FAIL, \ + "(%s) wrong value for %s 0x%x - should be 0x%x\n", \ + __location__, #v, (int)(v), (int)correct); \ + ret = false; \ + }} while (0) + +#define SET_ATTRIB(sattrib) do { \ + union smb_setfileinfo sfinfo; \ + ZERO_STRUCT(sfinfo.basic_info.in); \ + sfinfo.basic_info.level = RAW_SFILEINFO_BASIC_INFORMATION; \ + sfinfo.basic_info.in.file.handle = h1; \ + sfinfo.basic_info.in.attrib = sattrib; \ + status = smb2_setinfo_file(tree, &sfinfo); \ + if (!NT_STATUS_IS_OK(status)) { \ + torture_comment(tctx, \ + "(%s) Failed to set attrib 0x%x on %s\n", \ + __location__, (unsigned int)(sattrib), fname); \ + }} while (0) + +/* + stress testing keepalive iops + */ + +struct test_smb2_bench_echo_conn; +struct test_smb2_bench_echo_loop; + +struct test_smb2_bench_echo_state { + struct torture_context *tctx; + size_t num_conns; + struct test_smb2_bench_echo_conn *conns; + size_t num_loops; + struct test_smb2_bench_echo_loop *loops; + struct timeval starttime; + int timecount; + int timelimit; + uint64_t num_finished; + double total_latency; + double min_latency; + double max_latency; + bool ok; + bool stop; +}; + +struct test_smb2_bench_echo_conn { + struct test_smb2_bench_echo_state *state; + int idx; + struct smb2_tree *tree; +}; + +struct test_smb2_bench_echo_loop { + struct test_smb2_bench_echo_state *state; + struct test_smb2_bench_echo_conn *conn; + int idx; + struct tevent_immediate *im; + struct tevent_req *req; + struct timeval starttime; + uint64_t num_started; + uint64_t num_finished; + double total_latency; + double min_latency; + double max_latency; + NTSTATUS error; +}; + +static void test_smb2_bench_echo_loop_do( + struct test_smb2_bench_echo_loop *loop); + +static void test_smb2_bench_echo_loop_start(struct tevent_context *ctx, + struct tevent_immediate *im, + void *private_data) +{ + struct test_smb2_bench_echo_loop *loop = + (struct test_smb2_bench_echo_loop *) + private_data; + + test_smb2_bench_echo_loop_do(loop); +} + +static void test_smb2_bench_echo_loop_done(struct tevent_req *req); + +static void test_smb2_bench_echo_loop_do( + struct test_smb2_bench_echo_loop *loop) +{ + struct test_smb2_bench_echo_state *state = loop->state; + + loop->num_started += 1; + loop->starttime = timeval_current(); + loop->req = smb2cli_echo_send(state->loops, + state->tctx->ev, + loop->conn->tree->session->transport->conn, + 1000); + torture_assert_goto(state->tctx, loop->req != NULL, + state->ok, asserted, "smb2_create_send"); + + tevent_req_set_callback(loop->req, + test_smb2_bench_echo_loop_done, + loop); + return; +asserted: + state->stop = true; +} + +static void test_smb2_bench_echo_loop_done(struct tevent_req *req) +{ + struct test_smb2_bench_echo_loop *loop = + (struct test_smb2_bench_echo_loop *) + _tevent_req_callback_data(req); + struct test_smb2_bench_echo_state *state = loop->state; + double latency = timeval_elapsed(&loop->starttime); + TALLOC_CTX *frame = talloc_stackframe(); + + torture_assert_goto(state->tctx, loop->req == req, + state->ok, asserted, __location__); + loop->error = smb2cli_echo_recv(req); + torture_assert_ntstatus_ok_goto(state->tctx, loop->error, + state->ok, asserted, __location__); + SMB_ASSERT(latency >= 0.000001); + + if (loop->num_finished == 0) { + /* first round */ + loop->min_latency = latency; + loop->max_latency = latency; + } + + loop->num_finished += 1; + loop->total_latency += latency; + + if (latency < loop->min_latency) { + loop->min_latency = latency; + } + + if (latency > loop->max_latency) { + loop->max_latency = latency; + } + + TALLOC_FREE(frame); + test_smb2_bench_echo_loop_do(loop); + return; +asserted: + state->stop = true; + TALLOC_FREE(frame); +} + +static void test_smb2_bench_echo_progress(struct tevent_context *ev, + struct tevent_timer *te, + struct timeval current_time, + void *private_data) +{ + struct test_smb2_bench_echo_state *state = + (struct test_smb2_bench_echo_state *)private_data; + uint64_t num_echos = 0; + double total_echo_latency = 0; + double min_echo_latency = 0; + double max_echo_latency = 0; + double avs_echo_latency = 0; + size_t i; + + state->timecount += 1; + + for (i=0;inum_loops;i++) { + struct test_smb2_bench_echo_loop *loop = + &state->loops[i]; + + num_echos += loop->num_finished; + total_echo_latency += loop->total_latency; + if (min_echo_latency == 0.0 && loop->min_latency != 0.0) { + min_echo_latency = loop->min_latency; + } + if (loop->min_latency < min_echo_latency) { + min_echo_latency = loop->min_latency; + } + if (max_echo_latency == 0.0) { + max_echo_latency = loop->max_latency; + } + if (loop->max_latency > max_echo_latency) { + max_echo_latency = loop->max_latency; + } + loop->num_finished = 0; + loop->total_latency = 0.0; + } + + state->num_finished += num_echos; + state->total_latency += total_echo_latency; + if (state->min_latency == 0.0 && min_echo_latency != 0.0) { + state->min_latency = min_echo_latency; + } + if (min_echo_latency < state->min_latency) { + state->min_latency = min_echo_latency; + } + if (state->max_latency == 0.0) { + state->max_latency = max_echo_latency; + } + if (max_echo_latency > state->max_latency) { + state->max_latency = max_echo_latency; + } + + if (state->timecount < state->timelimit) { + te = tevent_add_timer(state->tctx->ev, + state, + timeval_current_ofs(1, 0), + test_smb2_bench_echo_progress, + state); + torture_assert_goto(state->tctx, te != NULL, + state->ok, asserted, "tevent_add_timer"); + + if (!torture_setting_bool(state->tctx, "progress", true)) { + return; + } + + avs_echo_latency = total_echo_latency / num_echos; + + torture_comment(state->tctx, + "%.2f second: " + "echo[num/s=%llu,avslat=%.6f,minlat=%.6f,maxlat=%.6f] \r", + timeval_elapsed(&state->starttime), + (unsigned long long)num_echos, + avs_echo_latency, + min_echo_latency, + max_echo_latency); + return; + } + + avs_echo_latency = state->total_latency / state->num_finished; + num_echos = state->num_finished / state->timelimit; + + torture_comment(state->tctx, + "%.2f second: " + "echo[num/s=%llu,avslat=%.6f,minlat=%.6f,maxlat=%.6f]\n", + timeval_elapsed(&state->starttime), + (unsigned long long)num_echos, + avs_echo_latency, + state->min_latency, + state->max_latency); + +asserted: + state->stop = true; +} + +static bool test_smb2_bench_echo(struct torture_context *tctx, + struct smb2_tree *tree) +{ + struct test_smb2_bench_echo_state *state = NULL; + bool ret = true; + int torture_nprocs = torture_setting_int(tctx, "nprocs", 4); + int torture_qdepth = torture_setting_int(tctx, "qdepth", 1); + size_t i; + size_t li = 0; + int timelimit = torture_setting_int(tctx, "timelimit", 10); + struct tevent_timer *te = NULL; + uint32_t timeout_msec; + + state = talloc_zero(tctx, struct test_smb2_bench_echo_state); + torture_assert(tctx, state != NULL, __location__); + state->tctx = tctx; + state->num_conns = torture_nprocs; + state->conns = talloc_zero_array(state, + struct test_smb2_bench_echo_conn, + state->num_conns); + torture_assert(tctx, state->conns != NULL, __location__); + state->num_loops = torture_nprocs * torture_qdepth; + state->loops = talloc_zero_array(state, + struct test_smb2_bench_echo_loop, + state->num_loops); + torture_assert(tctx, state->loops != NULL, __location__); + state->ok = true; + state->timelimit = MAX(timelimit, 1); + + timeout_msec = tree->session->transport->options.request_timeout * 1000; + + torture_comment(tctx, "Opening %zu connections\n", state->num_conns); + + for (i=0;inum_conns;i++) { + struct smb2_tree *ct = NULL; + DATA_BLOB out_input_buffer = data_blob_null; + DATA_BLOB out_output_buffer = data_blob_null; + size_t pcli; + + state->conns[i].state = state; + state->conns[i].idx = i; + + if (!torture_smb2_connection(tctx, &ct)) { + torture_comment(tctx, "Failed opening %zu/%zu connections\n", i, state->num_conns); + return false; + } + state->conns[i].tree = talloc_steal(state->conns, ct); + + smb2cli_conn_set_max_credits(ct->session->transport->conn, 8192); + smb2cli_ioctl(ct->session->transport->conn, + timeout_msec, + ct->session->smbXcli, + ct->smbXcli, + UINT64_MAX, /* in_fid_persistent */ + UINT64_MAX, /* in_fid_volatile */ + UINT32_MAX, + 0, /* in_max_input_length */ + NULL, /* in_input_buffer */ + 1, /* in_max_output_length */ + NULL, /* in_output_buffer */ + SMB2_IOCTL_FLAG_IS_FSCTL, + ct, + &out_input_buffer, + &out_output_buffer); + torture_assert(tctx, + smbXcli_conn_is_connected(ct->session->transport->conn), + "smbXcli_conn_is_connected"); + + for (pcli = 0; pcli < torture_qdepth; pcli++) { + struct test_smb2_bench_echo_loop *loop = &state->loops[li]; + + loop->idx = li++; + loop->state = state; + loop->conn = &state->conns[i]; + loop->im = tevent_create_immediate(state->loops); + torture_assert(tctx, loop->im != NULL, __location__); + + tevent_schedule_immediate(loop->im, + tctx->ev, + test_smb2_bench_echo_loop_start, + loop); + } + } + + torture_comment(tctx, "Opened %zu connections with qdepth=%d => %zu loops\n", + state->num_conns, torture_qdepth, state->num_loops); + + torture_comment(tctx, "Running for %d seconds\n", state->timelimit); + + state->starttime = timeval_current(); + + te = tevent_add_timer(tctx->ev, + state, + timeval_current_ofs(1, 0), + test_smb2_bench_echo_progress, + state); + torture_assert(tctx, te != NULL, __location__); + + while (!state->stop) { + int rc = tevent_loop_once(tctx->ev); + torture_assert_int_equal(tctx, rc, 0, "tevent_loop_once"); + } + + torture_comment(tctx, "%.2f seconds\n", timeval_elapsed(&state->starttime)); + TALLOC_FREE(state); + return ret; +} + +/* + stress testing path base operations + e.g. contention on lockting.tdb records + */ + +struct test_smb2_bench_path_contention_shared_conn; +struct test_smb2_bench_path_contention_shared_loop; + +struct test_smb2_bench_path_contention_shared_state { + struct torture_context *tctx; + size_t num_conns; + struct test_smb2_bench_path_contention_shared_conn *conns; + size_t num_loops; + struct test_smb2_bench_path_contention_shared_loop *loops; + struct timeval starttime; + int timecount; + int timelimit; + struct { + uint64_t num_finished; + double total_latency; + double min_latency; + double max_latency; + } opens; + struct { + uint64_t num_finished; + double total_latency; + double min_latency; + double max_latency; + } closes; + bool ok; + bool stop; +}; + +struct test_smb2_bench_path_contention_shared_conn { + struct test_smb2_bench_path_contention_shared_state *state; + int idx; + struct smb2_tree *tree; +}; + +struct test_smb2_bench_path_contention_shared_loop { + struct test_smb2_bench_path_contention_shared_state *state; + struct test_smb2_bench_path_contention_shared_conn *conn; + int idx; + struct tevent_immediate *im; + struct { + struct smb2_create io; + struct smb2_request *req; + struct timeval starttime; + uint64_t num_started; + uint64_t num_finished; + double total_latency; + double min_latency; + double max_latency; + } opens; + struct { + struct smb2_close io; + struct smb2_request *req; + struct timeval starttime; + uint64_t num_started; + uint64_t num_finished; + double total_latency; + double min_latency; + double max_latency; + } closes; + NTSTATUS error; +}; + +static void test_smb2_bench_path_contention_loop_open( + struct test_smb2_bench_path_contention_shared_loop *loop); + +static void test_smb2_bench_path_contention_loop_start(struct tevent_context *ctx, + struct tevent_immediate *im, + void *private_data) +{ + struct test_smb2_bench_path_contention_shared_loop *loop = + (struct test_smb2_bench_path_contention_shared_loop *) + private_data; + + test_smb2_bench_path_contention_loop_open(loop); +} + +static void test_smb2_bench_path_contention_loop_opened(struct smb2_request *req); + +static void test_smb2_bench_path_contention_loop_open( + struct test_smb2_bench_path_contention_shared_loop *loop) +{ + struct test_smb2_bench_path_contention_shared_state *state = loop->state; + + loop->opens.num_started += 1; + loop->opens.starttime = timeval_current(); + loop->opens.req = smb2_create_send(loop->conn->tree, &loop->opens.io); + torture_assert_goto(state->tctx, loop->opens.req != NULL, + state->ok, asserted, "smb2_create_send"); + + loop->opens.req->async.fn = test_smb2_bench_path_contention_loop_opened; + loop->opens.req->async.private_data = loop; + return; +asserted: + state->stop = true; +} + +static void test_smb2_bench_path_contention_loop_close( + struct test_smb2_bench_path_contention_shared_loop *loop); + +static void test_smb2_bench_path_contention_loop_opened(struct smb2_request *req) +{ + struct test_smb2_bench_path_contention_shared_loop *loop = + (struct test_smb2_bench_path_contention_shared_loop *) + req->async.private_data; + struct test_smb2_bench_path_contention_shared_state *state = loop->state; + double latency = timeval_elapsed(&loop->opens.starttime); + TALLOC_CTX *frame = talloc_stackframe(); + + torture_assert_goto(state->tctx, loop->opens.req == req, + state->ok, asserted, __location__); + loop->error = smb2_create_recv(req, frame, &loop->opens.io); + torture_assert_ntstatus_ok_goto(state->tctx, loop->error, + state->ok, asserted, __location__); + ZERO_STRUCT(loop->opens.io.out.blobs); + SMB_ASSERT(latency >= 0.000001); + + if (loop->opens.num_finished == 0) { + /* first round */ + loop->opens.min_latency = latency; + loop->opens.max_latency = latency; + } + + loop->opens.num_finished += 1; + loop->opens.total_latency += latency; + + if (latency < loop->opens.min_latency) { + loop->opens.min_latency = latency; + } + + if (latency > loop->opens.max_latency) { + loop->opens.max_latency = latency; + } + + TALLOC_FREE(frame); + test_smb2_bench_path_contention_loop_close(loop); + return; +asserted: + state->stop = true; + TALLOC_FREE(frame); +} + +static void test_smb2_bench_path_contention_loop_closed(struct smb2_request *req); + +static void test_smb2_bench_path_contention_loop_close( + struct test_smb2_bench_path_contention_shared_loop *loop) +{ + struct test_smb2_bench_path_contention_shared_state *state = loop->state; + + loop->closes.num_started += 1; + loop->closes.starttime = timeval_current(); + loop->closes.io.in.file = loop->opens.io.out.file; + loop->closes.req = smb2_close_send(loop->conn->tree, &loop->closes.io); + torture_assert_goto(state->tctx, loop->closes.req != NULL, + state->ok, asserted, "smb2_close_send"); + + loop->closes.req->async.fn = test_smb2_bench_path_contention_loop_closed; + loop->closes.req->async.private_data = loop; + return; +asserted: + state->stop = true; +} + +static void test_smb2_bench_path_contention_loop_closed(struct smb2_request *req) +{ + struct test_smb2_bench_path_contention_shared_loop *loop = + (struct test_smb2_bench_path_contention_shared_loop *) + req->async.private_data; + struct test_smb2_bench_path_contention_shared_state *state = loop->state; + double latency = timeval_elapsed(&loop->closes.starttime); + + torture_assert_goto(state->tctx, loop->closes.req == req, + state->ok, asserted, __location__); + loop->error = smb2_close_recv(req, &loop->closes.io); + torture_assert_ntstatus_ok_goto(state->tctx, loop->error, + state->ok, asserted, __location__); + SMB_ASSERT(latency >= 0.000001); + if (loop->closes.num_finished == 0) { + /* first round */ + loop->closes.min_latency = latency; + loop->closes.max_latency = latency; + } + loop->closes.num_finished += 1; + + loop->closes.total_latency += latency; + + if (latency < loop->closes.min_latency) { + loop->closes.min_latency = latency; + } + + if (latency > loop->closes.max_latency) { + loop->closes.max_latency = latency; + } + + test_smb2_bench_path_contention_loop_open(loop); + return; +asserted: + state->stop = true; +} + +static void test_smb2_bench_path_contention_progress(struct tevent_context *ev, + struct tevent_timer *te, + struct timeval current_time, + void *private_data) +{ + struct test_smb2_bench_path_contention_shared_state *state = + (struct test_smb2_bench_path_contention_shared_state *)private_data; + uint64_t num_opens = 0; + double total_open_latency = 0; + double min_open_latency = 0; + double max_open_latency = 0; + double avs_open_latency = 0; + uint64_t num_closes = 0; + double total_close_latency = 0; + double min_close_latency = 0; + double max_close_latency = 0; + double avs_close_latency = 0; + size_t i; + + state->timecount += 1; + + for (i=0;inum_loops;i++) { + struct test_smb2_bench_path_contention_shared_loop *loop = + &state->loops[i]; + + num_opens += loop->opens.num_finished; + total_open_latency += loop->opens.total_latency; + if (min_open_latency == 0.0 && loop->opens.min_latency != 0.0) { + min_open_latency = loop->opens.min_latency; + } + if (loop->opens.min_latency < min_open_latency) { + min_open_latency = loop->opens.min_latency; + } + if (max_open_latency == 0.0) { + max_open_latency = loop->opens.max_latency; + } + if (loop->opens.max_latency > max_open_latency) { + max_open_latency = loop->opens.max_latency; + } + loop->opens.num_finished = 0; + loop->opens.total_latency = 0.0; + + num_closes += loop->closes.num_finished; + total_close_latency += loop->closes.total_latency; + if (min_close_latency == 0.0 && loop->closes.min_latency != 0.0) { + min_close_latency = loop->closes.min_latency; + } + if (loop->closes.min_latency < min_close_latency) { + min_close_latency = loop->closes.min_latency; + } + if (max_close_latency == 0.0) { + max_close_latency = loop->closes.max_latency; + } + if (loop->closes.max_latency > max_close_latency) { + max_close_latency = loop->closes.max_latency; + } + loop->closes.num_finished = 0; + loop->closes.total_latency = 0.0; + } + + state->opens.num_finished += num_opens; + state->opens.total_latency += total_open_latency; + if (state->opens.min_latency == 0.0 && min_open_latency != 0.0) { + state->opens.min_latency = min_open_latency; + } + if (min_open_latency < state->opens.min_latency) { + state->opens.min_latency = min_open_latency; + } + if (state->opens.max_latency == 0.0) { + state->opens.max_latency = max_open_latency; + } + if (max_open_latency > state->opens.max_latency) { + state->opens.max_latency = max_open_latency; + } + + state->closes.num_finished += num_closes; + state->closes.total_latency += total_close_latency; + if (state->closes.min_latency == 0.0 && min_close_latency != 0.0) { + state->closes.min_latency = min_close_latency; + } + if (min_close_latency < state->closes.min_latency) { + state->closes.min_latency = min_close_latency; + } + if (state->closes.max_latency == 0.0) { + state->closes.max_latency = max_close_latency; + } + if (max_close_latency > state->closes.max_latency) { + state->closes.max_latency = max_close_latency; + } + + if (state->timecount < state->timelimit) { + te = tevent_add_timer(state->tctx->ev, + state, + timeval_current_ofs(1, 0), + test_smb2_bench_path_contention_progress, + state); + torture_assert_goto(state->tctx, te != NULL, + state->ok, asserted, "tevent_add_timer"); + + if (!torture_setting_bool(state->tctx, "progress", true)) { + return; + } + + avs_open_latency = total_open_latency / num_opens; + avs_close_latency = total_close_latency / num_closes; + + torture_comment(state->tctx, + "%.2f second: " + "open[num/s=%llu,avslat=%.6f,minlat=%.6f,maxlat=%.6f] " + "close[num/s=%llu,avslat=%.6f,minlat=%.6f,maxlat=%.6f] \r", + timeval_elapsed(&state->starttime), + (unsigned long long)num_opens, + avs_open_latency, + min_open_latency, + max_open_latency, + (unsigned long long)num_closes, + avs_close_latency, + min_close_latency, + max_close_latency); + return; + } + + avs_open_latency = state->opens.total_latency / state->opens.num_finished; + avs_close_latency = state->closes.total_latency / state->closes.num_finished; + num_opens = state->opens.num_finished / state->timelimit; + num_closes = state->closes.num_finished / state->timelimit; + + torture_comment(state->tctx, + "%.2f second: " + "open[num/s=%llu,avslat=%.6f,minlat=%.6f,maxlat=%.6f] " + "close[num/s=%llu,avslat=%.6f,minlat=%.6f,maxlat=%.6f]\n", + timeval_elapsed(&state->starttime), + (unsigned long long)num_opens, + avs_open_latency, + state->opens.min_latency, + state->opens.max_latency, + (unsigned long long)num_closes, + avs_close_latency, + state->closes.min_latency, + state->closes.max_latency); + +asserted: + state->stop = true; +} + +bool test_smb2_bench_path_contention_shared(struct torture_context *tctx, + struct smb2_tree *tree) +{ + struct test_smb2_bench_path_contention_shared_state *state = NULL; + bool ret = true; + int torture_nprocs = torture_setting_int(tctx, "nprocs", 4); + int torture_qdepth = torture_setting_int(tctx, "qdepth", 1); + size_t i; + size_t li = 0; + int timelimit = torture_setting_int(tctx, "timelimit", 10); + const char *path = torture_setting_string(tctx, "bench_path", ""); + struct smb2_create open_io = { .level = RAW_OPEN_SMB2, }; + struct smb2_close close_io = { .level = RAW_CLOSE_SMB2, }; + struct tevent_timer *te = NULL; + uint32_t timeout_msec; + + state = talloc_zero(tctx, struct test_smb2_bench_path_contention_shared_state); + torture_assert(tctx, state != NULL, __location__); + state->tctx = tctx; + state->num_conns = torture_nprocs; + state->conns = talloc_zero_array(state, + struct test_smb2_bench_path_contention_shared_conn, + state->num_conns); + torture_assert(tctx, state->conns != NULL, __location__); + state->num_loops = torture_nprocs * torture_qdepth; + state->loops = talloc_zero_array(state, + struct test_smb2_bench_path_contention_shared_loop, + state->num_loops); + torture_assert(tctx, state->loops != NULL, __location__); + state->ok = true; + state->timelimit = MAX(timelimit, 1); + + open_io.in.desired_access = SEC_DIR_READ_ATTRIBUTE; + open_io.in.alloc_size = 0; + open_io.in.file_attributes = 0; + open_io.in.share_access = FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE; + open_io.in.create_disposition = FILE_OPEN; + open_io.in.create_options = FILE_OPEN_REPARSE_POINT; + open_io.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS; + open_io.in.security_flags = 0; + open_io.in.fname = path; + open_io.in.create_flags = NTCREATEX_FLAGS_EXTENDED; + open_io.in.oplock_level = SMB2_OPLOCK_LEVEL_NONE; + + timeout_msec = tree->session->transport->options.request_timeout * 1000; + + torture_comment(tctx, "Opening %zd connections\n", state->num_conns); + + for (i=0;inum_conns;i++) { + struct smb2_tree *ct = NULL; + DATA_BLOB out_input_buffer = data_blob_null; + DATA_BLOB out_output_buffer = data_blob_null; + size_t pcli; + + state->conns[i].state = state; + state->conns[i].idx = i; + + if (!torture_smb2_connection(tctx, &ct)) { + torture_comment(tctx, "Failed opening %zd/%zd connections\n", i, state->num_conns); + return false; + } + state->conns[i].tree = talloc_steal(state->conns, ct); + + smb2cli_conn_set_max_credits(ct->session->transport->conn, 8192); + smb2cli_ioctl(ct->session->transport->conn, + timeout_msec, + ct->session->smbXcli, + ct->smbXcli, + UINT64_MAX, /* in_fid_persistent */ + UINT64_MAX, /* in_fid_volatile */ + UINT32_MAX, + 0, /* in_max_input_length */ + NULL, /* in_input_buffer */ + 1, /* in_max_output_length */ + NULL, /* in_output_buffer */ + SMB2_IOCTL_FLAG_IS_FSCTL, + ct, + &out_input_buffer, + &out_output_buffer); + torture_assert(tctx, + smbXcli_conn_is_connected(ct->session->transport->conn), + "smbXcli_conn_is_connected"); + for (pcli = 0; pcli < torture_qdepth; pcli++) { + struct test_smb2_bench_path_contention_shared_loop *loop = &state->loops[li]; + + loop->idx = li++; + loop->state = state; + loop->conn = &state->conns[i]; + loop->im = tevent_create_immediate(state->loops); + torture_assert(tctx, loop->im != NULL, __location__); + loop->opens.io = open_io; + loop->closes.io = close_io; + + tevent_schedule_immediate(loop->im, + tctx->ev, + test_smb2_bench_path_contention_loop_start, + loop); + } + } + + torture_comment(tctx, "Opened %zu connections with qdepth=%d => %zu loops\n", + state->num_conns, torture_qdepth, state->num_loops); + + torture_comment(tctx, "Running for %d seconds\n", state->timelimit); + + state->starttime = timeval_current(); + + te = tevent_add_timer(tctx->ev, + state, + timeval_current_ofs(1, 0), + test_smb2_bench_path_contention_progress, + state); + torture_assert(tctx, te != NULL, __location__); + + while (!state->stop) { + int rc = tevent_loop_once(tctx->ev); + torture_assert_int_equal(tctx, rc, 0, "tevent_loop_once"); + } + + torture_comment(tctx, "%.2f seconds\n", timeval_elapsed(&state->starttime)); + TALLOC_FREE(state); + return ret; +} + +struct torture_suite *torture_smb2_bench_init(TALLOC_CTX *ctx) +{ + struct torture_suite *suite = torture_suite_create(ctx, "bench"); + + torture_suite_add_1smb2_test(suite, "oplock1", test_smb2_bench_oplock); + torture_suite_add_1smb2_test(suite, "path-contention-shared", test_smb2_bench_path_contention_shared); + torture_suite_add_1smb2_test(suite, "echo", test_smb2_bench_echo); + + suite->description = talloc_strdup(suite, "SMB2-BENCH tests"); + + return suite; +} diff --git a/source4/torture/smb2/create.c b/source4/torture/smb2/create.c index d9fa2217953..bee5d8961a3 100644 --- a/source4/torture/smb2/create.c +++ b/source4/torture/smb2/create.c @@ -128,333 +128,6 @@ }} while (0) /* - stress testing keepalive iops - */ - -struct test_smb2_bench_echo_conn; -struct test_smb2_bench_echo_loop; - -struct test_smb2_bench_echo_state { - struct torture_context *tctx; - size_t num_conns; - struct test_smb2_bench_echo_conn *conns; - size_t num_loops; - struct test_smb2_bench_echo_loop *loops; - struct timeval starttime; - int timecount; - int timelimit; - uint64_t num_finished; - double total_latency; - double min_latency; - double max_latency; - bool ok; - bool stop; -}; - -struct test_smb2_bench_echo_conn { - struct test_smb2_bench_echo_state *state; - int idx; - struct smb2_tree *tree; -}; - -struct test_smb2_bench_echo_loop { - struct test_smb2_bench_echo_state *state; - struct test_smb2_bench_echo_conn *conn; - int idx; - struct tevent_immediate *im; - struct tevent_req *req; - struct timeval starttime; - uint64_t num_started; - uint64_t num_finished; - double total_latency; - double min_latency; - double max_latency; - NTSTATUS error; -}; - -static void test_smb2_bench_echo_loop_do( - struct test_smb2_bench_echo_loop *loop); - -static void test_smb2_bench_echo_loop_start(struct tevent_context *ctx, - struct tevent_immediate *im, - void *private_data) -{ - struct test_smb2_bench_echo_loop *loop = - (struct test_smb2_bench_echo_loop *) - private_data; - - test_smb2_bench_echo_loop_do(loop); -} - -static void test_smb2_bench_echo_loop_done(struct tevent_req *req); - -static void test_smb2_bench_echo_loop_do( - struct test_smb2_bench_echo_loop *loop) -{ - struct test_smb2_bench_echo_state *state = loop->state; - - loop->num_started += 1; - loop->starttime = timeval_current(); - loop->req = smb2cli_echo_send(state->loops, - state->tctx->ev, - loop->conn->tree->session->transport->conn, - 1000); - torture_assert_goto(state->tctx, loop->req != NULL, - state->ok, asserted, "smb2_create_send"); - - tevent_req_set_callback(loop->req, - test_smb2_bench_echo_loop_done, - loop); - return; -asserted: - state->stop = true; -} - -static void test_smb2_bench_echo_loop_done(struct tevent_req *req) -{ - struct test_smb2_bench_echo_loop *loop = - (struct test_smb2_bench_echo_loop *) - _tevent_req_callback_data(req); - struct test_smb2_bench_echo_state *state = loop->state; - double latency = timeval_elapsed(&loop->starttime); - TALLOC_CTX *frame = talloc_stackframe(); - - torture_assert_goto(state->tctx, loop->req == req, - state->ok, asserted, __location__); - loop->error = smb2cli_echo_recv(req); - torture_assert_ntstatus_ok_goto(state->tctx, loop->error, - state->ok, asserted, __location__); - SMB_ASSERT(latency >= 0.000001); - - if (loop->num_finished == 0) { - /* first round */ - loop->min_latency = latency; - loop->max_latency = latency; - } - - loop->num_finished += 1; - loop->total_latency += latency; - - if (latency < loop->min_latency) { - loop->min_latency = latency; - } - - if (latency > loop->max_latency) { - loop->max_latency = latency; - } - - TALLOC_FREE(frame); - test_smb2_bench_echo_loop_do(loop); - return; -asserted: - state->stop = true; - TALLOC_FREE(frame); -} - -static void test_smb2_bench_echo_progress(struct tevent_context *ev, - struct tevent_timer *te, - struct timeval current_time, - void *private_data) -{ - struct test_smb2_bench_echo_state *state = - (struct test_smb2_bench_echo_state *)private_data; - uint64_t num_echos = 0; - double total_echo_latency = 0; - double min_echo_latency = 0; - double max_echo_latency = 0; - double avs_echo_latency = 0; - size_t i; - - state->timecount += 1; - - for (i=0;inum_loops;i++) { - struct test_smb2_bench_echo_loop *loop = - &state->loops[i]; - - num_echos += loop->num_finished; - total_echo_latency += loop->total_latency; - if (min_echo_latency == 0.0 && loop->min_latency != 0.0) { - min_echo_latency = loop->min_latency; - } - if (loop->min_latency < min_echo_latency) { - min_echo_latency = loop->min_latency; - } - if (max_echo_latency == 0.0) { - max_echo_latency = loop->max_latency; - } - if (loop->max_latency > max_echo_latency) { - max_echo_latency = loop->max_latency; - } - loop->num_finished = 0; - loop->total_latency = 0.0; - } - - state->num_finished += num_echos; - state->total_latency += total_echo_latency; - if (state->min_latency == 0.0 && min_echo_latency != 0.0) { - state->min_latency = min_echo_latency; - } - if (min_echo_latency < state->min_latency) { - state->min_latency = min_echo_latency; - } - if (state->max_latency == 0.0) { - state->max_latency = max_echo_latency; - } - if (max_echo_latency > state->max_latency) { - state->max_latency = max_echo_latency; - } - - if (state->timecount < state->timelimit) { - te = tevent_add_timer(state->tctx->ev, - state, - timeval_current_ofs(1, 0), - test_smb2_bench_echo_progress, - state); - torture_assert_goto(state->tctx, te != NULL, - state->ok, asserted, "tevent_add_timer"); - - if (!torture_setting_bool(state->tctx, "progress", true)) { - return; - } - - avs_echo_latency = total_echo_latency / num_echos; - - torture_comment(state->tctx, - "%.2f second: " - "echo[num/s=%llu,avslat=%.6f,minlat=%.6f,maxlat=%.6f] \r", - timeval_elapsed(&state->starttime), - (unsigned long long)num_echos, - avs_echo_latency, - min_echo_latency, - max_echo_latency); - return; - } - - avs_echo_latency = state->total_latency / state->num_finished; - num_echos = state->num_finished / state->timelimit; - - torture_comment(state->tctx, - "%.2f second: " - "echo[num/s=%llu,avslat=%.6f,minlat=%.6f,maxlat=%.6f]\n", - timeval_elapsed(&state->starttime), - (unsigned long long)num_echos, - avs_echo_latency, - state->min_latency, - state->max_latency); - -asserted: - state->stop = true; -} - -static bool test_smb2_bench_echo(struct torture_context *tctx, - struct smb2_tree *tree) -{ - struct test_smb2_bench_echo_state *state = NULL; - bool ret = true; - int torture_nprocs = torture_setting_int(tctx, "nprocs", 4); - int torture_qdepth = torture_setting_int(tctx, "qdepth", 1); - size_t i; - size_t li = 0; - int timelimit = torture_setting_int(tctx, "timelimit", 10); - struct tevent_timer *te = NULL; - uint32_t timeout_msec; - - state = talloc_zero(tctx, struct test_smb2_bench_echo_state); - torture_assert(tctx, state != NULL, __location__); - state->tctx = tctx; - state->num_conns = torture_nprocs; - state->conns = talloc_zero_array(state, - struct test_smb2_bench_echo_conn, - state->num_conns); - torture_assert(tctx, state->conns != NULL, __location__); - state->num_loops = torture_nprocs * torture_qdepth; - state->loops = talloc_zero_array(state, - struct test_smb2_bench_echo_loop, - state->num_loops); - torture_assert(tctx, state->loops != NULL, __location__); - state->ok = true; - state->timelimit = MAX(timelimit, 1); - - timeout_msec = tree->session->transport->options.request_timeout * 1000; - - torture_comment(tctx, "Opening %zu connections\n", state->num_conns); - - for (i=0;inum_conns;i++) { - struct smb2_tree *ct = NULL; - DATA_BLOB out_input_buffer = data_blob_null; - DATA_BLOB out_output_buffer = data_blob_null; - size_t pcli; - - state->conns[i].state = state; - state->conns[i].idx = i; - - if (!torture_smb2_connection(tctx, &ct)) { - torture_comment(tctx, "Failed opening %zu/%zu connections\n", i, state->num_conns); - return false; - } - state->conns[i].tree = talloc_steal(state->conns, ct); - - smb2cli_conn_set_max_credits(ct->session->transport->conn, 8192); - smb2cli_ioctl(ct->session->transport->conn, - timeout_msec, - ct->session->smbXcli, - ct->smbXcli, - UINT64_MAX, /* in_fid_persistent */ - UINT64_MAX, /* in_fid_volatile */ - UINT32_MAX, - 0, /* in_max_input_length */ - NULL, /* in_input_buffer */ - 1, /* in_max_output_length */ - NULL, /* in_output_buffer */ - SMB2_IOCTL_FLAG_IS_FSCTL, - ct, - &out_input_buffer, - &out_output_buffer); - torture_assert(tctx, - smbXcli_conn_is_connected(ct->session->transport->conn), - "smbXcli_conn_is_connected"); - - for (pcli = 0; pcli < torture_qdepth; pcli++) { - struct test_smb2_bench_echo_loop *loop = &state->loops[li]; - - loop->idx = li++; - loop->state = state; - loop->conn = &state->conns[i]; - loop->im = tevent_create_immediate(state->loops); - torture_assert(tctx, loop->im != NULL, __location__); - - tevent_schedule_immediate(loop->im, - tctx->ev, - test_smb2_bench_echo_loop_start, - loop); - } - } - - torture_comment(tctx, "Opened %zu connections with qdepth=%d => %zu loops\n", - state->num_conns, torture_qdepth, state->num_loops); - - torture_comment(tctx, "Running for %d seconds\n", state->timelimit); - - state->starttime = timeval_current(); - - te = tevent_add_timer(tctx->ev, - state, - timeval_current_ofs(1, 0), - test_smb2_bench_echo_progress, - state); - torture_assert(tctx, te != NULL, __location__); - - while (!state->stop) { - int rc = tevent_loop_once(tctx->ev); - torture_assert_int_equal(tctx, rc, 0, "tevent_loop_once"); - } - - torture_comment(tctx, "%.2f seconds\n", timeval_elapsed(&state->starttime)); - TALLOC_FREE(state); - return ret; -} - -/* test some interesting combinations found by gentest */ static bool test_create_gentest(struct torture_context *tctx, struct smb2_tree *tree) @@ -3479,479 +3152,6 @@ done: return ret; } -/* - stress testing path base operations - e.g. contention on lockting.tdb records - */ - -struct test_smb2_bench_path_contention_shared_conn; -struct test_smb2_bench_path_contention_shared_loop; - -struct test_smb2_bench_path_contention_shared_state { - struct torture_context *tctx; - size_t num_conns; - struct test_smb2_bench_path_contention_shared_conn *conns; - size_t num_loops; - struct test_smb2_bench_path_contention_shared_loop *loops; - struct timeval starttime; - int timecount; - int timelimit; - struct { - uint64_t num_finished; - double total_latency; - double min_latency; - double max_latency; - } opens; - struct { - uint64_t num_finished; - double total_latency; - double min_latency; - double max_latency; - } closes; - bool ok; - bool stop; -}; - -struct test_smb2_bench_path_contention_shared_conn { - struct test_smb2_bench_path_contention_shared_state *state; - int idx; - struct smb2_tree *tree; -}; - -struct test_smb2_bench_path_contention_shared_loop { - struct test_smb2_bench_path_contention_shared_state *state; - struct test_smb2_bench_path_contention_shared_conn *conn; - int idx; - struct tevent_immediate *im; - struct { - struct smb2_create io; - struct smb2_request *req; - struct timeval starttime; - uint64_t num_started; - uint64_t num_finished; - double total_latency; - double min_latency; - double max_latency; - } opens; - struct { - struct smb2_close io; - struct smb2_request *req; - struct timeval starttime; - uint64_t num_started; - uint64_t num_finished; - double total_latency; - double min_latency; - double max_latency; - } closes; - NTSTATUS error; -}; - -static void test_smb2_bench_path_contention_loop_open( - struct test_smb2_bench_path_contention_shared_loop *loop); - -static void test_smb2_bench_path_contention_loop_start(struct tevent_context *ctx, - struct tevent_immediate *im, - void *private_data) -{ - struct test_smb2_bench_path_contention_shared_loop *loop = - (struct test_smb2_bench_path_contention_shared_loop *) - private_data; - - test_smb2_bench_path_contention_loop_open(loop); -} - -static void test_smb2_bench_path_contention_loop_opened(struct smb2_request *req); - -static void test_smb2_bench_path_contention_loop_open( - struct test_smb2_bench_path_contention_shared_loop *loop) -{ - struct test_smb2_bench_path_contention_shared_state *state = loop->state; - - loop->opens.num_started += 1; - loop->opens.starttime = timeval_current(); - loop->opens.req = smb2_create_send(loop->conn->tree, &loop->opens.io); - torture_assert_goto(state->tctx, loop->opens.req != NULL, - state->ok, asserted, "smb2_create_send"); - - loop->opens.req->async.fn = test_smb2_bench_path_contention_loop_opened; - loop->opens.req->async.private_data = loop; - return; -asserted: - state->stop = true; -} - -static void test_smb2_bench_path_contention_loop_close( - struct test_smb2_bench_path_contention_shared_loop *loop); - -static void test_smb2_bench_path_contention_loop_opened(struct smb2_request *req) -{ - struct test_smb2_bench_path_contention_shared_loop *loop = - (struct test_smb2_bench_path_contention_shared_loop *) - req->async.private_data; - struct test_smb2_bench_path_contention_shared_state *state = loop->state; - double latency = timeval_elapsed(&loop->opens.starttime); - TALLOC_CTX *frame = talloc_stackframe(); - - torture_assert_goto(state->tctx, loop->opens.req == req, - state->ok, asserted, __location__); - loop->error = smb2_create_recv(req, frame, &loop->opens.io); - torture_assert_ntstatus_ok_goto(state->tctx, loop->error, - state->ok, asserted, __location__); - ZERO_STRUCT(loop->opens.io.out.blobs); - SMB_ASSERT(latency >= 0.000001); - - if (loop->opens.num_finished == 0) { - /* first round */ - loop->opens.min_latency = latency; - loop->opens.max_latency = latency; - } - - loop->opens.num_finished += 1; - loop->opens.total_latency += latency; - - if (latency < loop->opens.min_latency) { - loop->opens.min_latency = latency; - } - - if (latency > loop->opens.max_latency) { - loop->opens.max_latency = latency; - } - - TALLOC_FREE(frame); - test_smb2_bench_path_contention_loop_close(loop); - return; -asserted: - state->stop = true; - TALLOC_FREE(frame); -} - -static void test_smb2_bench_path_contention_loop_closed(struct smb2_request *req); - -static void test_smb2_bench_path_contention_loop_close( - struct test_smb2_bench_path_contention_shared_loop *loop) -{ - struct test_smb2_bench_path_contention_shared_state *state = loop->state; - - loop->closes.num_started += 1; - loop->closes.starttime = timeval_current(); - loop->closes.io.in.file = loop->opens.io.out.file; - loop->closes.req = smb2_close_send(loop->conn->tree, &loop->closes.io); - torture_assert_goto(state->tctx, loop->closes.req != NULL, - state->ok, asserted, "smb2_close_send"); - - loop->closes.req->async.fn = test_smb2_bench_path_contention_loop_closed; - loop->closes.req->async.private_data = loop; - return; -asserted: - state->stop = true; -} - -static void test_smb2_bench_path_contention_loop_closed(struct smb2_request *req) -{ - struct test_smb2_bench_path_contention_shared_loop *loop = - (struct test_smb2_bench_path_contention_shared_loop *) - req->async.private_data; - struct test_smb2_bench_path_contention_shared_state *state = loop->state; - double latency = timeval_elapsed(&loop->closes.starttime); - - torture_assert_goto(state->tctx, loop->closes.req == req, - state->ok, asserted, __location__); - loop->error = smb2_close_recv(req, &loop->closes.io); - torture_assert_ntstatus_ok_goto(state->tctx, loop->error, - state->ok, asserted, __location__); - SMB_ASSERT(latency >= 0.000001); - if (loop->closes.num_finished == 0) { - /* first round */ - loop->closes.min_latency = latency; - loop->closes.max_latency = latency; - } - loop->closes.num_finished += 1; - - loop->closes.total_latency += latency; - - if (latency < loop->closes.min_latency) { - loop->closes.min_latency = latency; - } - - if (latency > loop->closes.max_latency) { - loop->closes.max_latency = latency; - } - - test_smb2_bench_path_contention_loop_open(loop); - return; -asserted: - state->stop = true; -} - -static void test_smb2_bench_path_contention_progress(struct tevent_context *ev, - struct tevent_timer *te, - struct timeval current_time, - void *private_data) -{ - struct test_smb2_bench_path_contention_shared_state *state = - (struct test_smb2_bench_path_contention_shared_state *)private_data; - uint64_t num_opens = 0; - double total_open_latency = 0; - double min_open_latency = 0; - double max_open_latency = 0; - double avs_open_latency = 0; - uint64_t num_closes = 0; - double total_close_latency = 0; - double min_close_latency = 0; - double max_close_latency = 0; - double avs_close_latency = 0; - size_t i; - - state->timecount += 1; - - for (i=0;inum_loops;i++) { - struct test_smb2_bench_path_contention_shared_loop *loop = - &state->loops[i]; - - num_opens += loop->opens.num_finished; - total_open_latency += loop->opens.total_latency; - if (min_open_latency == 0.0 && loop->opens.min_latency != 0.0) { - min_open_latency = loop->opens.min_latency; - } - if (loop->opens.min_latency < min_open_latency) { - min_open_latency = loop->opens.min_latency; - } - if (max_open_latency == 0.0) { - max_open_latency = loop->opens.max_latency; - } - if (loop->opens.max_latency > max_open_latency) { - max_open_latency = loop->opens.max_latency; - } - loop->opens.num_finished = 0; - loop->opens.total_latency = 0.0; - - num_closes += loop->closes.num_finished; - total_close_latency += loop->closes.total_latency; - if (min_close_latency == 0.0 && loop->closes.min_latency != 0.0) { - min_close_latency = loop->closes.min_latency; - } - if (loop->closes.min_latency < min_close_latency) { - min_close_latency = loop->closes.min_latency; - } - if (max_close_latency == 0.0) { - max_close_latency = loop->closes.max_latency; - } - if (loop->closes.max_latency > max_close_latency) { - max_close_latency = loop->closes.max_latency; - } - loop->closes.num_finished = 0; - loop->closes.total_latency = 0.0; - } - - state->opens.num_finished += num_opens; - state->opens.total_latency += total_open_latency; - if (state->opens.min_latency == 0.0 && min_open_latency != 0.0) { - state->opens.min_latency = min_open_latency; - } - if (min_open_latency < state->opens.min_latency) { - state->opens.min_latency = min_open_latency; - } - if (state->opens.max_latency == 0.0) { - state->opens.max_latency = max_open_latency; - } - if (max_open_latency > state->opens.max_latency) { - state->opens.max_latency = max_open_latency; - } - - state->closes.num_finished += num_closes; - state->closes.total_latency += total_close_latency; - if (state->closes.min_latency == 0.0 && min_close_latency != 0.0) { - state->closes.min_latency = min_close_latency; - } - if (min_close_latency < state->closes.min_latency) { - state->closes.min_latency = min_close_latency; - } - if (state->closes.max_latency == 0.0) { - state->closes.max_latency = max_close_latency; - } - if (max_close_latency > state->closes.max_latency) { - state->closes.max_latency = max_close_latency; - } - - if (state->timecount < state->timelimit) { - te = tevent_add_timer(state->tctx->ev, - state, - timeval_current_ofs(1, 0), - test_smb2_bench_path_contention_progress, - state); - torture_assert_goto(state->tctx, te != NULL, - state->ok, asserted, "tevent_add_timer"); - - if (!torture_setting_bool(state->tctx, "progress", true)) { - return; - } - - avs_open_latency = total_open_latency / num_opens; - avs_close_latency = total_close_latency / num_closes; - - torture_comment(state->tctx, - "%.2f second: " - "open[num/s=%llu,avslat=%.6f,minlat=%.6f,maxlat=%.6f] " - "close[num/s=%llu,avslat=%.6f,minlat=%.6f,maxlat=%.6f] \r", - timeval_elapsed(&state->starttime), - (unsigned long long)num_opens, - avs_open_latency, - min_open_latency, - max_open_latency, - (unsigned long long)num_closes, - avs_close_latency, - min_close_latency, - max_close_latency); - return; - } - - avs_open_latency = state->opens.total_latency / state->opens.num_finished; - avs_close_latency = state->closes.total_latency / state->closes.num_finished; - num_opens = state->opens.num_finished / state->timelimit; - num_closes = state->closes.num_finished / state->timelimit; - - torture_comment(state->tctx, - "%.2f second: " - "open[num/s=%llu,avslat=%.6f,minlat=%.6f,maxlat=%.6f] " - "close[num/s=%llu,avslat=%.6f,minlat=%.6f,maxlat=%.6f]\n", - timeval_elapsed(&state->starttime), - (unsigned long long)num_opens, - avs_open_latency, - state->opens.min_latency, - state->opens.max_latency, - (unsigned long long)num_closes, - avs_close_latency, - state->closes.min_latency, - state->closes.max_latency); - -asserted: - state->stop = true; -} - -static bool test_smb2_bench_path_contention_shared(struct torture_context *tctx, - struct smb2_tree *tree) -{ - struct test_smb2_bench_path_contention_shared_state *state = NULL; - bool ret = true; - int torture_nprocs = torture_setting_int(tctx, "nprocs", 4); - int torture_qdepth = torture_setting_int(tctx, "qdepth", 1); - size_t i; - size_t li = 0; - int timelimit = torture_setting_int(tctx, "timelimit", 10); - const char *path = torture_setting_string(tctx, "bench_path", ""); - struct smb2_create open_io = { .level = RAW_OPEN_SMB2, }; - struct smb2_close close_io = { .level = RAW_CLOSE_SMB2, }; - struct tevent_timer *te = NULL; - uint32_t timeout_msec; - - state = talloc_zero(tctx, struct test_smb2_bench_path_contention_shared_state); - torture_assert(tctx, state != NULL, __location__); - state->tctx = tctx; - state->num_conns = torture_nprocs; - state->conns = talloc_zero_array(state, - struct test_smb2_bench_path_contention_shared_conn, - state->num_conns); - torture_assert(tctx, state->conns != NULL, __location__); - state->num_loops = torture_nprocs * torture_qdepth; - state->loops = talloc_zero_array(state, - struct test_smb2_bench_path_contention_shared_loop, - state->num_loops); - torture_assert(tctx, state->loops != NULL, __location__); - state->ok = true; - state->timelimit = MAX(timelimit, 1); - - open_io.in.desired_access = SEC_DIR_READ_ATTRIBUTE; - open_io.in.alloc_size = 0; - open_io.in.file_attributes = 0; - open_io.in.share_access = FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE; - open_io.in.create_disposition = FILE_OPEN; - open_io.in.create_options = FILE_OPEN_REPARSE_POINT; - open_io.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS; - open_io.in.security_flags = 0; - open_io.in.fname = path; - open_io.in.create_flags = NTCREATEX_FLAGS_EXTENDED; - open_io.in.oplock_level = SMB2_OPLOCK_LEVEL_NONE; - - timeout_msec = tree->session->transport->options.request_timeout * 1000; - - torture_comment(tctx, "Opening %zd connections\n", state->num_conns); - - for (i=0;inum_conns;i++) { - struct smb2_tree *ct = NULL; - DATA_BLOB out_input_buffer = data_blob_null; - DATA_BLOB out_output_buffer = data_blob_null; - size_t pcli; - - state->conns[i].state = state; - state->conns[i].idx = i; - - if (!torture_smb2_connection(tctx, &ct)) { - torture_comment(tctx, "Failed opening %zd/%zd connections\n", i, state->num_conns); - return false; - } - state->conns[i].tree = talloc_steal(state->conns, ct); - - smb2cli_conn_set_max_credits(ct->session->transport->conn, 8192); - smb2cli_ioctl(ct->session->transport->conn, - timeout_msec, - ct->session->smbXcli, - ct->smbXcli, - UINT64_MAX, /* in_fid_persistent */ - UINT64_MAX, /* in_fid_volatile */ - UINT32_MAX, - 0, /* in_max_input_length */ - NULL, /* in_input_buffer */ - 1, /* in_max_output_length */ - NULL, /* in_output_buffer */ - SMB2_IOCTL_FLAG_IS_FSCTL, - ct, - &out_input_buffer, - &out_output_buffer); - torture_assert(tctx, - smbXcli_conn_is_connected(ct->session->transport->conn), - "smbXcli_conn_is_connected"); - for (pcli = 0; pcli < torture_qdepth; pcli++) { - struct test_smb2_bench_path_contention_shared_loop *loop = &state->loops[li]; - - loop->idx = li++; - loop->state = state; - loop->conn = &state->conns[i]; - loop->im = tevent_create_immediate(state->loops); - torture_assert(tctx, loop->im != NULL, __location__); - loop->opens.io = open_io; - loop->closes.io = close_io; - - tevent_schedule_immediate(loop->im, - tctx->ev, - test_smb2_bench_path_contention_loop_start, - loop); - } - } - - torture_comment(tctx, "Opened %zu connections with qdepth=%d => %zu loops\n", - state->num_conns, torture_qdepth, state->num_loops); - - torture_comment(tctx, "Running for %d seconds\n", state->timelimit); - - state->starttime = timeval_current(); - - te = tevent_add_timer(tctx->ev, - state, - timeval_current_ofs(1, 0), - test_smb2_bench_path_contention_progress, - state); - torture_assert(tctx, te != NULL, __location__); - - while (!state->stop) { - int rc = tevent_loop_once(tctx->ev); - torture_assert_int_equal(tctx, rc, 0, "tevent_loop_once"); - } - - torture_comment(tctx, "%.2f seconds\n", timeval_elapsed(&state->starttime)); - TALLOC_FREE(state); - return ret; -} - /** Find Maximum Path Length */ @@ -4141,19 +3341,6 @@ struct torture_suite *torture_smb2_fileid_init(TALLOC_CTX *ctx) return suite; } -struct torture_suite *torture_smb2_bench_init(TALLOC_CTX *ctx) -{ - struct torture_suite *suite = torture_suite_create(ctx, "bench"); - - torture_suite_add_1smb2_test(suite, "oplock1", test_smb2_bench_oplock); - torture_suite_add_1smb2_test(suite, "path-contention-shared", test_smb2_bench_path_contention_shared); - torture_suite_add_1smb2_test(suite, "echo", test_smb2_bench_echo); - - suite->description = talloc_strdup(suite, "SMB2-BENCH tests"); - - return suite; -} - static bool test_no_stream(struct torture_context *tctx, struct smb2_tree *tree) { diff --git a/source4/torture/smb2/wscript_build b/source4/torture/smb2/wscript_build index 93434268c6f..533639c92e3 100644 --- a/source4/torture/smb2/wscript_build +++ b/source4/torture/smb2/wscript_build @@ -5,6 +5,7 @@ bld.SAMBA_MODULE('TORTURE_SMB2', acls.c attr.c block.c + bench.c charset.c compound.c connect.c -- 2.11.4.GIT