LCOV - code coverage report
Current view: top level - source4/torture/raw - tconrate.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 0 76 0.0 %
Date: 2021-09-23 10:06:22 Functions: 0 5 0.0 %

          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             :         void * buf;
      38             :         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             :         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           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             :                 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             :         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             :         struct timeval now, last, start;
     168             :         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 : */

Generated by: LCOV version 1.13