source4/torture/raw/tconrate.c

   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 static void * map_count_buffer(unsigned nelem, size_t elemsz)
  36 {
  37         void * buf;
  38         size_t bufsz;
  39         size_t pagesz = getpagesize();
  40
  41         bufsz = nelem * elemsz;
  42         bufsz = (bufsz + pagesz) % pagesz; /* round up to pagesz */
  43
  44 #ifdef MAP_ANON
  45         /* BSD */
  46         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         if (buf == MAP_FAILED) {
  54                 printf("failed to map count buffer: %s\n",
  55                                 strerror(errno));
  56                 return NULL;
  57         }
  58
  59         return buf;
  60
  61 }
  62
  63 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         pid_t child;
  68         struct smbcli_state *cli;
  69         struct timeval end;
  70         struct timeval now;
  71         struct smbcli_options options;
  72         struct smbcli_session_options session_options;
  73
  74         lpcfg_smbcli_options(tctx->lp_ctx, &options);
  75         lpcfg_smbcli_session_options(tctx->lp_ctx, &session_options);
  76
  77         child = fork();
  78         if (child == -1) {
  79                 printf("failed to fork child: %s\n,", strerror(errno));
  80                 return -1;
  81         } else if (child != 0) {
  82                 /* Parent, just return. */
  83                 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         end = timeval_current();
  94         now = timeval_current();
  95         end.tv_sec += tcon_timelimit;
  96         *tcon_count = 0;
  97
  98         while (timeval_compare(&now, &end) == -1) {
  99                 NTSTATUS status;
 100
 101                 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                 if (!NT_STATUS_IS_OK(status)) {
 110                         printf("failed to connect to //%s/%s: %s\n",
 111                                 host, share, nt_errstr(status));
 112                         goto done;
 113                 }
 114
 115                 smbcli_tdis(cli);
 116                 talloc_free(cli);
 117
 118                 *tcon_count = *tcon_count + 1;
 119                 now = timeval_current();
 120         }
 121
 122 done:
 123         exit(0);
 124 }
 125
 126 static bool children_remain(void)
 127 {
 128         bool res;
 129
 130         /* Reap as many children as possible. */
 131         for (;;) {
 132                 pid_t ret = waitpid(-1, NULL, WNOHANG);
 133                 if (ret == 0) {
 134                         /* no children ready */
 135                         res = true;
 136                         break;
 137                 }
 138                 if (ret == -1) {
 139                         /* no children left. maybe */
 140                         res = errno != ECHILD;
 141                         break;
 142                 }
 143         }
 144         return res;
 145 }
 146
 147 static double rate_convert_secs(unsigned count,
 148                 const struct timeval *start, const struct timeval *end)
 149 {
 150         return (double)count /
 151                 usec_to_sec((double)usec_time_diff(end, start));
 152 }
 153
 154 /* Test the rate at which the server will accept connections.  */
 155 bool torture_bench_treeconnect(struct torture_context *tctx)
 156 {
 157         const char *host = torture_setting_string(tctx, "host", NULL);
 158         const char *share = torture_setting_string(tctx, "share", NULL);
 159
 160         int timelimit = torture_setting_int(tctx, "timelimit",
 161                                         TIME_LIMIT_SECS);
 162         int nprocs = torture_setting_int(tctx, "nprocs", 4);
 163
 164         int *curr_counts = map_count_buffer(nprocs, sizeof(int));
 165         int *last_counts = talloc_zero_array(tctx, int, nprocs);
 166
 167         struct timeval now, last, start;
 168         int i, delta;
 169
 170         torture_assert(tctx, nprocs > 0, "bad proc count");
 171         torture_assert(tctx, timelimit > 0, "bad timelimit");
 172         torture_assert(tctx, curr_counts, "allocation failure");
 173         torture_assert(tctx, last_counts, "allocation failure");
 174
 175         start = last = timeval_current();
 176         for (i = 0; i < nprocs; ++i) {
 177                 fork_tcon_client(tctx, &curr_counts[i], timelimit, host, share);
 178         }
 179
 180         while (children_remain()) {
 181
 182                 sleep(1);
 183                 now = timeval_current();
 184
 185                 for (i = 0, delta = 0; i < nprocs; ++i) {
 186                         delta += curr_counts[i] - last_counts[i];
 187                 }
 188
 189                 printf("%u connections/sec\n",
 190                         (unsigned)rate_convert_secs(delta, &last, &now));
 191
 192                 memcpy(last_counts, curr_counts, nprocs * sizeof(int));
 193                 last = timeval_current();
 194         }
 195
 196         now = timeval_current();
 197
 198         for (i = 0, delta = 0; i < nprocs; ++i) {
 199                 delta += curr_counts[i];
 200         }
 201
 202         printf("TOTAL: %u connections/sec over %u secs\n",
 203                         (unsigned)rate_convert_secs(delta, &start, &now),
 204                         timelimit);
 205         return true;
 206 }
 207
 208 /* vim: set sts=8 sw=8 : */