2 SMB tree connection rate test
4 Copyright (C) 2006-2007 James Peach
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 #include "libcli/libcli.h"
22 #include "libcli/resolve/resolve.h"
23 #include "torture/smbtorture.h"
24 #include "lib/cmdline/popt_common.h"
25 #include "param/param.h"
27 #include "system/filesys.h"
28 #include "system/shmem.h"
30 #define TIME_LIMIT_SECS 30
31 #define usec_to_sec(s) ((s) / 1000000)
33 /* Map a shared memory buffer of at least nelem counters. */
34 static void * map_count_buffer(unsigned nelem
, size_t elemsz
)
38 size_t pagesz
= getpagesize();
40 bufsz
= nelem
* elemsz
;
41 bufsz
= (bufsz
+ pagesz
) % pagesz
; /* round up to pagesz */
45 buf
= mmap(NULL
, bufsz
, PROT_READ
|PROT_WRITE
, MAP_ANON
|MAP_SHARED
,
46 -1 /* fd */, 0 /* offset */);
48 buf
= mmap(NULL
, bufsz
, PROT_READ
|PROT_WRITE
, MAP_FILE
|MAP_SHARED
,
49 open("/dev/zero", O_RDWR
), 0 /* offset */);
52 if (buf
== MAP_FAILED
) {
53 printf("failed to map count buffer: %s\n",
62 static int fork_tcon_client(struct torture_context
*tctx
,
63 int *tcon_count
, unsigned tcon_timelimit
,
64 const char *host
, const char *share
)
67 struct smbcli_state
*cli
;
70 struct smbcli_options options
;
71 struct smbcli_session_options session_options
;
73 lpcfg_smbcli_options(tctx
->lp_ctx
, &options
);
74 lpcfg_smbcli_session_options(tctx
->lp_ctx
, &session_options
);
78 printf("failed to fork child: %s\n,", strerror(errno
));
80 } else if (child
!= 0) {
81 /* Parent, just return. */
85 /* Child. Just make as many connections as possible within the
86 * time limit. Don't bother synchronising the child start times
87 * because it's probably not work the effort, and a bit of startup
88 * jitter is probably a more realistic test.
92 end
= timeval_current();
93 now
= timeval_current();
94 end
.tv_sec
+= tcon_timelimit
;
97 while (timeval_compare(&now
, &end
) == -1) {
100 status
= smbcli_full_connection(NULL
, &cli
,
101 host
, lpcfg_smb_ports(tctx
->lp_ctx
), share
,
102 NULL
, lpcfg_socket_options(tctx
->lp_ctx
), cmdline_credentials
,
103 lpcfg_resolve_context(tctx
->lp_ctx
),
104 tctx
->ev
, &options
, &session_options
,
105 lpcfg_gensec_settings(tctx
, tctx
->lp_ctx
));
107 if (!NT_STATUS_IS_OK(status
)) {
108 printf("failed to connect to //%s/%s: %s\n",
109 host
, share
, nt_errstr(status
));
116 *tcon_count
= *tcon_count
+ 1;
117 now
= timeval_current();
124 static bool children_remain(void)
128 /* Reap as many children as possible. */
130 pid_t ret
= waitpid(-1, NULL
, WNOHANG
);
132 /* no children ready */
137 /* no children left. maybe */
138 res
= errno
!= ECHILD
;
145 static double rate_convert_secs(unsigned count
,
146 const struct timeval
*start
, const struct timeval
*end
)
148 return (double)count
/
149 usec_to_sec((double)usec_time_diff(end
, start
));
152 /* Test the rate at which the server will accept connections. */
153 bool torture_bench_treeconnect(struct torture_context
*tctx
)
155 const char *host
= torture_setting_string(tctx
, "host", NULL
);
156 const char *share
= torture_setting_string(tctx
, "share", NULL
);
158 int timelimit
= torture_setting_int(tctx
, "timelimit",
160 int nprocs
= torture_setting_int(tctx
, "nprocs", 4);
162 int *curr_counts
= map_count_buffer(nprocs
, sizeof(int));
163 int *last_counts
= talloc_array(NULL
, int, nprocs
);
165 struct timeval now
, last
, start
;
168 torture_assert(tctx
, nprocs
> 0, "bad proc count");
169 torture_assert(tctx
, timelimit
> 0, "bad timelimit");
170 torture_assert(tctx
, curr_counts
, "allocation failure");
171 torture_assert(tctx
, last_counts
, "allocation failure");
173 start
= last
= timeval_current();
174 for (i
= 0; i
< nprocs
; ++i
) {
175 fork_tcon_client(tctx
, &curr_counts
[i
], timelimit
, host
, share
);
178 while (children_remain()) {
181 now
= timeval_current();
183 for (i
= 0, delta
= 0; i
< nprocs
; ++i
) {
184 delta
+= curr_counts
[i
] - last_counts
[i
];
187 printf("%u connections/sec\n",
188 (unsigned)rate_convert_secs(delta
, &last
, &now
));
190 memcpy(last_counts
, curr_counts
, nprocs
* sizeof(int));
191 last
= timeval_current();
194 now
= timeval_current();
196 for (i
= 0, delta
= 0; i
< nprocs
; ++i
) {
197 delta
+= curr_counts
[i
];
200 printf("TOTAL: %u connections/sec over %u secs\n",
201 (unsigned)rate_convert_secs(delta
, &start
, &now
),
206 /* vim: set sts=8 sw=8 : */