Line data Source code
1 : /*
2 : SMB tree connection rate test
3 :
4 : Copyright (C) 2006-2007 James Peach
5 :
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.
10 :
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.
15 :
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/>.
18 : */
19 :
20 : #include "includes.h"
21 : #include "libcli/libcli.h"
22 : #include "libcli/resolve/resolve.h"
23 : #include "torture/smbtorture.h"
24 : #include "lib/cmdline/cmdline.h"
25 : #include "param/param.h"
26 :
27 : #include "system/filesys.h"
28 : #include "system/shmem.h"
29 : #include "torture/raw/proto.h"
30 :
31 : #define TIME_LIMIT_SECS 30
32 : #define usec_to_sec(s) ((s) / 1000000)
33 :
34 : /* Map a shared memory buffer of at least nelem counters. */
35 0 : static void * map_count_buffer(unsigned nelem, size_t elemsz)
36 : {
37 0 : void * buf;
38 0 : size_t bufsz;
39 0 : size_t pagesz = getpagesize();
40 :
41 0 : bufsz = nelem * elemsz;
42 0 : bufsz = (bufsz + pagesz) % pagesz; /* round up to pagesz */
43 :
44 : #ifdef MAP_ANON
45 : /* BSD */
46 0 : buf = mmap(NULL, bufsz, PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED,
47 : -1 /* fd */, 0 /* offset */);
48 : #else
49 : buf = mmap(NULL, bufsz, PROT_READ|PROT_WRITE, MAP_FILE|MAP_SHARED,
50 : open("/dev/zero", O_RDWR), 0 /* offset */);
51 : #endif
52 :
53 0 : if (buf == MAP_FAILED) {
54 0 : printf("failed to map count buffer: %s\n",
55 0 : strerror(errno));
56 0 : return NULL;
57 : }
58 :
59 0 : return buf;
60 :
61 : }
62 :
63 0 : static int fork_tcon_client(struct torture_context *tctx,
64 : int *tcon_count, unsigned tcon_timelimit,
65 : const char *host, const char *share)
66 : {
67 0 : pid_t child;
68 0 : struct smbcli_state *cli;
69 0 : struct timeval end;
70 0 : struct timeval now;
71 0 : struct smbcli_options options;
72 0 : struct smbcli_session_options session_options;
73 :
74 0 : lpcfg_smbcli_options(tctx->lp_ctx, &options);
75 0 : lpcfg_smbcli_session_options(tctx->lp_ctx, &session_options);
76 :
77 0 : child = fork();
78 0 : if (child == -1) {
79 0 : printf("failed to fork child: %s\n,", strerror(errno));
80 0 : return -1;
81 0 : } else if (child != 0) {
82 : /* Parent, just return. */
83 0 : return 0;
84 : }
85 :
86 : /* Child. Just make as many connections as possible within the
87 : * time limit. Don't bother synchronising the child start times
88 : * because it's probably not work the effort, and a bit of startup
89 : * jitter is probably a more realistic test.
90 : */
91 :
92 :
93 0 : end = timeval_current();
94 0 : now = timeval_current();
95 0 : end.tv_sec += tcon_timelimit;
96 0 : *tcon_count = 0;
97 :
98 0 : while (timeval_compare(&now, &end) == -1) {
99 0 : NTSTATUS status;
100 :
101 0 : status = smbcli_full_connection(NULL, &cli,
102 : host, lpcfg_smb_ports(tctx->lp_ctx), share,
103 : NULL, lpcfg_socket_options(tctx->lp_ctx),
104 : samba_cmdline_get_creds(),
105 : lpcfg_resolve_context(tctx->lp_ctx),
106 : tctx->ev, &options, &session_options,
107 : lpcfg_gensec_settings(tctx, tctx->lp_ctx));
108 :
109 0 : if (!NT_STATUS_IS_OK(status)) {
110 0 : printf("failed to connect to //%s/%s: %s\n",
111 : host, share, nt_errstr(status));
112 0 : goto done;
113 : }
114 :
115 0 : smbcli_tdis(cli);
116 0 : talloc_free(cli);
117 :
118 0 : *tcon_count = *tcon_count + 1;
119 0 : now = timeval_current();
120 : }
121 :
122 0 : done:
123 0 : exit(0);
124 : }
125 :
126 0 : static bool children_remain(void)
127 : {
128 0 : bool res;
129 :
130 : /* Reap as many children as possible. */
131 0 : for (;;) {
132 0 : pid_t ret = waitpid(-1, NULL, WNOHANG);
133 0 : if (ret == 0) {
134 : /* no children ready */
135 0 : res = true;
136 0 : break;
137 : }
138 0 : if (ret == -1) {
139 : /* no children left. maybe */
140 0 : res = errno != ECHILD;
141 0 : break;
142 : }
143 : }
144 0 : return res;
145 : }
146 :
147 0 : static double rate_convert_secs(unsigned count,
148 : const struct timeval *start, const struct timeval *end)
149 : {
150 0 : return (double)count /
151 0 : usec_to_sec((double)usec_time_diff(end, start));
152 : }
153 :
154 : /* Test the rate at which the server will accept connections. */
155 0 : bool torture_bench_treeconnect(struct torture_context *tctx)
156 : {
157 0 : const char *host = torture_setting_string(tctx, "host", NULL);
158 0 : const char *share = torture_setting_string(tctx, "share", NULL);
159 :
160 0 : int timelimit = torture_setting_int(tctx, "timelimit",
161 : TIME_LIMIT_SECS);
162 0 : int nprocs = torture_setting_int(tctx, "nprocs", 4);
163 :
164 0 : int *curr_counts = map_count_buffer(nprocs, sizeof(int));
165 0 : int *last_counts = talloc_zero_array(tctx, int, nprocs);
166 :
167 0 : struct timeval now, last, start;
168 0 : int i, delta;
169 :
170 0 : torture_assert(tctx, nprocs > 0, "bad proc count");
171 0 : torture_assert(tctx, timelimit > 0, "bad timelimit");
172 0 : torture_assert(tctx, curr_counts, "allocation failure");
173 0 : torture_assert(tctx, last_counts, "allocation failure");
174 :
175 0 : start = last = timeval_current();
176 0 : for (i = 0; i < nprocs; ++i) {
177 0 : fork_tcon_client(tctx, &curr_counts[i], timelimit, host, share);
178 : }
179 :
180 0 : while (children_remain()) {
181 :
182 0 : sleep(1);
183 0 : now = timeval_current();
184 :
185 0 : for (i = 0, delta = 0; i < nprocs; ++i) {
186 0 : delta += curr_counts[i] - last_counts[i];
187 : }
188 :
189 0 : printf("%u connections/sec\n",
190 0 : (unsigned)rate_convert_secs(delta, &last, &now));
191 :
192 0 : memcpy(last_counts, curr_counts, nprocs * sizeof(int));
193 0 : last = timeval_current();
194 : }
195 :
196 0 : now = timeval_current();
197 :
198 0 : for (i = 0, delta = 0; i < nprocs; ++i) {
199 0 : delta += curr_counts[i];
200 : }
201 :
202 0 : printf("TOTAL: %u connections/sec over %u secs\n",
203 0 : (unsigned)rate_convert_secs(delta, &start, &now),
204 : timelimit);
205 0 : return true;
206 : }
207 :
208 : /* vim: set sts=8 sw=8 : */
|
