2 Unix SMB/CIFS implementation.
6 Copyright (C) Andrew Tridgell 2007
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "torture/torture.h"
24 #include "libcli/raw/libcliraw.h"
25 #include "libcli/raw/raw_proto.h"
26 #include "system/time.h"
27 #include "system/filesys.h"
28 #include "libcli/libcli.h"
29 #include "torture/util.h"
30 #include "lib/events/events.h"
31 #include "lib/cmdline/popt_common.h"
32 #include "libcli/composite/composite.h"
33 #include "libcli/smb_composite/smb_composite.h"
34 #include "libcli/resolve/resolve.h"
35 #include "param/param.h"
37 #define BASEDIR "\\benchopen"
40 static int open_failed
;
41 static int close_failed
;
43 static int num_connected
;
44 static struct tevent_timer
*report_te
;
46 struct benchopen_state
{
47 struct torture_context
*tctx
;
49 struct tevent_context
*ev
;
50 struct smbcli_state
*cli
;
51 struct smbcli_tree
*tree
;
61 union smb_open open_parms
;
63 union smb_close close_parms
;
64 struct smbcli_request
*req_open
;
65 struct smbcli_request
*req_close
;
66 struct smb_composite_connect reconnect
;
67 struct tevent_timer
*te
;
69 /* these are used for reconnections */
70 const char **dest_ports
;
71 const char *dest_host
;
72 const char *called_name
;
73 const char *service_type
;
76 static void next_open(struct benchopen_state
*state
);
77 static void reopen_connection(struct tevent_context
*ev
, struct tevent_timer
*te
,
78 struct timeval t
, void *private_data
);
82 complete an async reconnect
84 static void reopen_connection_complete(struct composite_context
*ctx
)
86 struct benchopen_state
*state
= (struct benchopen_state
*)ctx
->async
.private_data
;
88 struct smb_composite_connect
*io
= &state
->reconnect
;
90 status
= smb_composite_connect_recv(ctx
, state
->mem_ctx
);
91 if (!NT_STATUS_IS_OK(status
)) {
92 talloc_free(state
->te
);
93 state
->te
= event_add_timed(state
->ev
, state
->mem_ctx
,
94 timeval_current_ofs(1,0),
95 reopen_connection
, state
);
99 state
->tree
= io
->out
.tree
;
103 DEBUG(0,("[%u] reconnect to %s finished (%u connected)\n",
104 state
->client_num
, state
->dest_host
, num_connected
));
106 state
->open_fnum
= -1;
107 state
->close_fnum
= -1;
116 static void reopen_connection(struct tevent_context
*ev
, struct tevent_timer
*te
,
117 struct timeval t
, void *private_data
)
119 struct benchopen_state
*state
= (struct benchopen_state
*)private_data
;
120 struct composite_context
*ctx
;
121 struct smb_composite_connect
*io
= &state
->reconnect
;
126 if (!torture_get_conn_index(state
->client_num
, state
->mem_ctx
, state
->tctx
, &host
, &share
)) {
127 DEBUG(0,("Can't find host/share for reconnect?!\n"));
131 io
->in
.dest_host
= state
->dest_host
;
132 io
->in
.dest_ports
= state
->dest_ports
;
133 io
->in
.socket_options
= lp_socket_options(state
->tctx
->lp_ctx
);
134 io
->in
.called_name
= state
->called_name
;
135 io
->in
.service
= share
;
136 io
->in
.service_type
= state
->service_type
;
137 io
->in
.credentials
= cmdline_credentials
;
138 io
->in
.fallback_to_anonymous
= false;
139 io
->in
.workgroup
= lp_workgroup(state
->tctx
->lp_ctx
);
140 io
->in
.gensec_settings
= lp_gensec_settings(state
->mem_ctx
, state
->tctx
->lp_ctx
);
141 lp_smbcli_options(state
->tctx
->lp_ctx
, &io
->in
.options
);
142 lp_smbcli_session_options(state
->tctx
->lp_ctx
, &io
->in
.session_options
);
144 /* kill off the remnants of the old connection */
145 talloc_free(state
->tree
);
147 state
->open_fnum
= -1;
148 state
->close_fnum
= -1;
150 ctx
= smb_composite_connect_send(io
, state
->mem_ctx
,
151 lp_resolve_context(state
->tctx
->lp_ctx
),
154 DEBUG(0,("Failed to setup async reconnect\n"));
158 ctx
->async
.fn
= reopen_connection_complete
;
159 ctx
->async
.private_data
= state
;
162 static void open_completed(struct smbcli_request
*req
);
163 static void close_completed(struct smbcli_request
*req
);
166 static void next_open(struct benchopen_state
*state
)
170 state
->pending_file_num
= state
->next_file_num
;
171 state
->next_file_num
= (state
->next_file_num
+1) % (3*nprocs
);
173 DEBUG(2,("[%d] opening %u\n", state
->client_num
, state
->pending_file_num
));
174 state
->open_parms
.ntcreatex
.level
= RAW_OPEN_NTCREATEX
;
175 state
->open_parms
.ntcreatex
.in
.flags
= 0;
176 state
->open_parms
.ntcreatex
.in
.root_fid
= 0;
177 state
->open_parms
.ntcreatex
.in
.access_mask
= SEC_RIGHTS_FILE_ALL
;
178 state
->open_parms
.ntcreatex
.in
.file_attr
= FILE_ATTRIBUTE_NORMAL
;
179 state
->open_parms
.ntcreatex
.in
.alloc_size
= 0;
180 state
->open_parms
.ntcreatex
.in
.share_access
= 0;
181 state
->open_parms
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_OVERWRITE_IF
;
182 state
->open_parms
.ntcreatex
.in
.create_options
= 0;
183 state
->open_parms
.ntcreatex
.in
.impersonation
= 0;
184 state
->open_parms
.ntcreatex
.in
.security_flags
= 0;
185 state
->open_parms
.ntcreatex
.in
.fname
= fnames
[state
->pending_file_num
];
187 state
->req_open
= smb_raw_open_send(state
->tree
, &state
->open_parms
);
188 state
->req_open
->async
.fn
= open_completed
;
189 state
->req_open
->async
.private_data
= state
;
193 static void next_close(struct benchopen_state
*state
)
195 if (state
->close_fnum
== -1) {
198 DEBUG(2,("[%d] closing %d (fnum[%d])\n",
199 state
->client_num
, state
->close_file_num
, state
->close_fnum
));
200 state
->close_parms
.close
.level
= RAW_CLOSE_CLOSE
;
201 state
->close_parms
.close
.in
.file
.fnum
= state
->close_fnum
;
202 state
->close_parms
.close
.in
.write_time
= 0;
204 state
->req_close
= smb_raw_close_send(state
->tree
, &state
->close_parms
);
205 state
->req_close
->async
.fn
= close_completed
;
206 state
->req_close
->async
.private_data
= state
;
210 called when a open completes
212 static void open_completed(struct smbcli_request
*req
)
214 struct benchopen_state
*state
= (struct benchopen_state
*)req
->async
.private_data
;
215 TALLOC_CTX
*tmp_ctx
= talloc_new(state
->mem_ctx
);
218 status
= smb_raw_open_recv(req
, tmp_ctx
, &state
->open_parms
);
220 talloc_free(tmp_ctx
);
222 state
->req_open
= NULL
;
224 if (NT_STATUS_EQUAL(status
, NT_STATUS_END_OF_FILE
) ||
225 NT_STATUS_EQUAL(status
, NT_STATUS_LOCAL_DISCONNECT
)) {
226 talloc_free(state
->tree
);
227 talloc_free(state
->cli
);
231 DEBUG(0,("[%u] reopening connection to %s\n",
232 state
->client_num
, state
->dest_host
));
233 talloc_free(state
->te
);
234 state
->te
= event_add_timed(state
->ev
, state
->mem_ctx
,
235 timeval_current_ofs(1,0),
236 reopen_connection
, state
);
240 if (NT_STATUS_EQUAL(status
, NT_STATUS_SHARING_VIOLATION
)) {
241 DEBUG(2,("[%d] retrying open %d\n",
242 state
->client_num
, state
->pending_file_num
));
243 state
->open_retries
++;
244 state
->req_open
= smb_raw_open_send(state
->tree
, &state
->open_parms
);
245 state
->req_open
->async
.fn
= open_completed
;
246 state
->req_open
->async
.private_data
= state
;
250 if (!NT_STATUS_IS_OK(status
)) {
252 DEBUG(0,("[%u] open failed %d - %s\n",
253 state
->client_num
, state
->pending_file_num
,
258 state
->close_file_num
= state
->open_file_num
;
259 state
->close_fnum
= state
->open_fnum
;
260 state
->open_file_num
= state
->pending_file_num
;
261 state
->open_fnum
= state
->open_parms
.ntcreatex
.out
.file
.fnum
;
263 DEBUG(2,("[%d] open completed %d (fnum[%d])\n",
264 state
->client_num
, state
->open_file_num
, state
->open_fnum
));
266 if (state
->close_fnum
!= -1) {
274 called when a close completes
276 static void close_completed(struct smbcli_request
*req
)
278 struct benchopen_state
*state
= (struct benchopen_state
*)req
->async
.private_data
;
279 NTSTATUS status
= smbcli_request_simple_recv(req
);
281 state
->req_close
= NULL
;
283 if (NT_STATUS_EQUAL(status
, NT_STATUS_END_OF_FILE
) ||
284 NT_STATUS_EQUAL(status
, NT_STATUS_LOCAL_DISCONNECT
)) {
285 talloc_free(state
->tree
);
286 talloc_free(state
->cli
);
290 DEBUG(0,("[%u] reopening connection to %s\n",
291 state
->client_num
, state
->dest_host
));
292 talloc_free(state
->te
);
293 state
->te
= event_add_timed(state
->ev
, state
->mem_ctx
,
294 timeval_current_ofs(1,0),
295 reopen_connection
, state
);
299 if (!NT_STATUS_IS_OK(status
)) {
301 DEBUG(0,("[%u] close failed %d (fnum[%d]) - %s\n",
302 state
->client_num
, state
->close_file_num
,
308 DEBUG(2,("[%d] close completed %d (fnum[%d])\n",
309 state
->client_num
, state
->close_file_num
,
313 static void echo_completion(struct smbcli_request
*req
)
315 struct benchopen_state
*state
= (struct benchopen_state
*)req
->async
.private_data
;
316 NTSTATUS status
= smbcli_request_simple_recv(req
);
317 if (NT_STATUS_EQUAL(status
, NT_STATUS_END_OF_FILE
) ||
318 NT_STATUS_EQUAL(status
, NT_STATUS_LOCAL_DISCONNECT
)) {
319 talloc_free(state
->tree
);
322 DEBUG(0,("[%u] reopening connection to %s\n",
323 state
->client_num
, state
->dest_host
));
324 talloc_free(state
->te
);
325 state
->te
= event_add_timed(state
->ev
, state
->mem_ctx
,
326 timeval_current_ofs(1,0),
327 reopen_connection
, state
);
331 static void report_rate(struct tevent_context
*ev
, struct tevent_timer
*te
,
332 struct timeval t
, void *private_data
)
334 struct benchopen_state
*state
= talloc_get_type(private_data
,
335 struct benchopen_state
);
337 for (i
=0;i
<nprocs
;i
++) {
338 printf("%5u ", (unsigned)(state
[i
].count
- state
[i
].lastcount
));
339 state
[i
].lastcount
= state
[i
].count
;
343 report_te
= event_add_timed(ev
, state
, timeval_current_ofs(1, 0),
346 /* send an echo on each interface to ensure it stays alive - this helps
348 for (i
=0;i
<nprocs
;i
++) {
350 struct smbcli_request
*req
;
352 if (!state
[i
].tree
) {
356 p
.in
.repeat_count
= 1;
359 req
= smb_raw_echo_send(state
[i
].tree
->session
->transport
, &p
);
360 req
->async
.private_data
= &state
[i
];
361 req
->async
.fn
= echo_completion
;
368 bool torture_bench_open(struct torture_context
*torture
)
371 TALLOC_CTX
*mem_ctx
= talloc_new(torture
);
373 int timelimit
= torture_setting_int(torture
, "timelimit", 10);
375 struct benchopen_state
*state
;
377 int total_retries
= 0;
381 progress
= torture_setting_bool(torture
, "progress", true);
383 nprocs
= torture_setting_int(torture
, "nprocs", 4);
385 state
= talloc_zero_array(mem_ctx
, struct benchopen_state
, nprocs
);
387 printf("Opening %d connections\n", nprocs
);
388 for (i
=0;i
<nprocs
;i
++) {
389 state
[i
].tctx
= torture
;
390 state
[i
].mem_ctx
= talloc_new(state
);
391 state
[i
].client_num
= i
;
392 state
[i
].ev
= torture
->ev
;
393 if (!torture_open_connection_ev(&state
[i
].cli
, i
, torture
, torture
->ev
)) {
396 talloc_steal(mem_ctx
, state
);
397 state
[i
].tree
= state
[i
].cli
->tree
;
398 state
[i
].dest_host
= talloc_strdup(state
[i
].mem_ctx
,
399 state
[i
].cli
->tree
->session
->transport
->socket
->hostname
);
400 state
[i
].dest_ports
= talloc_array(state
[i
].mem_ctx
,
402 state
[i
].dest_ports
[0] = talloc_asprintf(state
[i
].dest_ports
,
403 "%u", state
[i
].cli
->tree
->session
->transport
->socket
->port
);
404 state
[i
].dest_ports
[1] = NULL
;
405 state
[i
].called_name
= talloc_strdup(state
[i
].mem_ctx
,
406 state
[i
].cli
->tree
->session
->transport
->called
.name
);
407 state
[i
].service_type
= talloc_strdup(state
[i
].mem_ctx
,
408 state
[i
].cli
->tree
->device
);
413 if (!torture_setup_dir(state
[0].cli
, BASEDIR
)) {
417 fnames
= talloc_array(mem_ctx
, char *, 3*nprocs
);
418 for (i
=0;i
<3*nprocs
;i
++) {
419 fnames
[i
] = talloc_asprintf(fnames
, "%s\\file%d.dat", BASEDIR
, i
);
422 for (i
=0;i
<nprocs
;i
++) {
423 /* all connections start with the same file */
424 state
[i
].next_file_num
= 0;
425 state
[i
].open_fnum
= -1;
426 state
[i
].close_fnum
= -1;
427 next_open(&state
[i
]);
430 tv
= timeval_current();
433 report_te
= event_add_timed(torture
->ev
, state
, timeval_current_ofs(1, 0),
437 printf("Running for %d seconds\n", timelimit
);
438 while (timeval_elapsed(&tv
) < timelimit
) {
439 event_loop_once(torture
->ev
);
442 DEBUG(0,("open failed\n"));
446 DEBUG(0,("open failed\n"));
451 talloc_free(report_te
);
453 for (i
=0;i
<nprocs
;i
++) {
459 minops
= state
[0].count
;
460 for (i
=0;i
<nprocs
;i
++) {
461 total
+= state
[i
].count
;
462 total_retries
+= state
[i
].open_retries
;
463 printf("[%d] %u ops (%u retries)\n",
464 i
, state
[i
].count
, state
[i
].open_retries
);
465 if (state
[i
].count
< minops
) minops
= state
[i
].count
;
467 printf("%.2f ops/second (%d retries)\n",
468 total
/timeval_elapsed(&tv
), total_retries
);
469 if (minops
< 0.5*total
/nprocs
) {
470 printf("Failed: unbalanced open\n");
474 for (i
=0;i
<nprocs
;i
++) {
475 talloc_free(state
[i
].req_open
);
476 talloc_free(state
[i
].req_close
);
477 smb_raw_exit(state
[i
].tree
->session
);
480 smbcli_deltree(state
[0].tree
, BASEDIR
);
481 talloc_free(mem_ctx
);
485 talloc_free(mem_ctx
);