LCOV - code coverage report
Current view: top level - source4/torture/raw - lookuprate.c (source / functions) Hit Total Coverage
Test: coverage report for master 2b515b7d Lines: 0 124 0.0 %
Date: 2024-02-28 12:06:22 Functions: 0 8 0.0 %

          Line data    Source code
       1             : /*
       2             :    File lookup rate test.
       3             : 
       4             :    Copyright (C) James Peach 2006
       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 "system/filesys.h"
      22             : #include "torture/smbtorture.h"
      23             : #include "libcli/libcli.h"
      24             : #include "torture/util.h"
      25             : #include "torture/raw/proto.h"
      26             : 
      27             : #define BASEDIR "\\lookuprate"
      28             : #define MISSINGNAME BASEDIR "\\foo"
      29             : 
      30             : #define FUZZ_PERCENT 10
      31             : 
      32             : #define usec_to_sec(s) ((s) / 1000000)
      33             : #define sec_to_usec(s) ((s) * 1000000)
      34             : 
      35             : struct rate_record
      36             : {
      37             :     unsigned    dirent_count;
      38             :     unsigned    querypath_persec;
      39             :     unsigned    findfirst_persec;
      40             : };
      41             : 
      42             : static struct rate_record records[] =
      43             : {
      44             :     { 0, 0, 0 },        /* Base (optimal) lookup rate. */
      45             :     { 100, 0, 0},
      46             :     { 1000, 0, 0},
      47             :     { 10000, 0, 0},
      48             :     { 100000, 0, 0}
      49             : };
      50             : 
      51             : typedef NTSTATUS lookup_function(struct smbcli_tree *tree, const char * path);
      52             : 
      53             : /* Test whether rhs is within fuzz% of lhs. */
      54           0 : static bool fuzzily_equal(unsigned lhs, unsigned rhs, int percent)
      55             : {
      56           0 :         double fuzz = (double)lhs * (double)percent/100.0;
      57             : 
      58           0 :         if (((double)rhs >= ((double)lhs - fuzz)) &&
      59           0 :             ((double)rhs <= ((double)lhs + fuzz))) {
      60           0 :                 return true;
      61             :         }
      62             : 
      63           0 :         return false;
      64             : 
      65             : }
      66             : 
      67           0 : static NTSTATUS fill_directory(struct smbcli_tree *tree,
      68             :             const char * path, unsigned count)
      69             : {
      70           0 :         NTSTATUS        status;
      71           0 :         char            *fname = NULL;
      72           0 :         unsigned        i;
      73           0 :         unsigned        current;
      74             : 
      75           0 :         struct timeval start;
      76           0 :         struct timeval now;
      77             : 
      78           0 :         status = smbcli_mkdir(tree, path);
      79           0 :         if (!NT_STATUS_IS_OK(status)) {
      80           0 :                 return status;
      81             :         }
      82             : 
      83           0 :         printf("filling directory %s with %u files... ", path, count);
      84           0 :         fflush(stdout);
      85             : 
      86           0 :         current = random();
      87           0 :         start = timeval_current();
      88             : 
      89           0 :         for (i = 0; i < count; ++i) {
      90           0 :                 int fnum;
      91             : 
      92           0 :                 ++current;
      93           0 :                 fname = talloc_asprintf(NULL, "%s\\fill%u",
      94             :                                     path, current);
      95             : 
      96           0 :                 fnum = smbcli_open(tree, fname, O_RDONLY|O_CREAT,
      97             :                                 DENY_NONE);
      98           0 :                 if (fnum < 0) {
      99           0 :                         talloc_free(fname);
     100           0 :                         return smbcli_nt_error(tree);
     101             :                 }
     102             : 
     103           0 :                 smbcli_close(tree, fnum);
     104           0 :                 talloc_free(fname);
     105             :         }
     106             : 
     107           0 :         if (count) {
     108           0 :                 double rate;
     109           0 :                 now = timeval_current();
     110           0 :                 rate = (double)count / usec_to_sec((double)usec_time_diff(&now, &start));
     111           0 :                 printf("%u/sec\n", (unsigned)rate);
     112             :         } else {
     113           0 :                 printf("done\n");
     114             :         }
     115             : 
     116           0 :         return NT_STATUS_OK;
     117             : }
     118             : 
     119           0 : static NTSTATUS squash_lookup_error(NTSTATUS status)
     120             : {
     121           0 :         if (NT_STATUS_IS_OK(status)) {
     122           0 :                 return NT_STATUS_OK;
     123             :         }
     124             : 
     125             :         /* We don't care if the file isn't there. */
     126           0 :         if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_NOT_FOUND)) {
     127           0 :                 return NT_STATUS_OK;
     128             :         }
     129             : 
     130           0 :         if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
     131           0 :                 return NT_STATUS_OK;
     132             :         }
     133             : 
     134           0 :         if (NT_STATUS_EQUAL(status, NT_STATUS_NO_SUCH_FILE)) {
     135           0 :                 return NT_STATUS_OK;
     136             :         }
     137             : 
     138           0 :         return status;
     139             : }
     140             : 
     141             : /* Look up a pathname using TRANS2_QUERY_PATH_INFORMATION. */
     142           0 : static NTSTATUS querypath_lookup(struct smbcli_tree *tree, const char * path)
     143             : {
     144           0 :         NTSTATUS        status;
     145           0 :         time_t          ftimes[3];
     146           0 :         size_t          fsize;
     147           0 :         uint16_t        fmode;
     148             : 
     149           0 :         status = smbcli_qpathinfo(tree, path, &ftimes[0], &ftimes[1], &ftimes[2],
     150             :                         &fsize, &fmode);
     151             : 
     152           0 :         return squash_lookup_error(status);
     153             : }
     154             : 
     155             : /* Look up a pathname using TRANS2_FIND_FIRST2. */
     156           0 : static NTSTATUS findfirst_lookup(struct smbcli_tree *tree, const char * path)
     157             : {
     158           0 :         NTSTATUS status = NT_STATUS_OK;
     159             : 
     160           0 :         if (smbcli_list(tree, path, 0, NULL, NULL) < 0) {
     161           0 :                 status = smbcli_nt_error(tree);
     162             :         }
     163             : 
     164           0 :         return squash_lookup_error(status);
     165             : }
     166             : 
     167           0 : static NTSTATUS lookup_rate_convert(struct smbcli_tree *tree,
     168             :         lookup_function lookup, const char * path, unsigned * rate)
     169             : {
     170           0 :         NTSTATUS        status;
     171             : 
     172           0 :         struct timeval  start;
     173           0 :         struct timeval  now;
     174           0 :         unsigned        count = 0;
     175           0 :         int64_t         elapsed = 0;
     176             : 
     177             : #define LOOKUP_PERIOD_SEC (2)
     178             : 
     179           0 :         start = timeval_current();
     180           0 :         while (elapsed < sec_to_usec(LOOKUP_PERIOD_SEC)) {
     181             : 
     182           0 :                 status = lookup(tree, path);
     183           0 :                 if (!NT_STATUS_IS_OK(status)) {
     184           0 :                         return status;
     185             :                 }
     186             : 
     187           0 :                 ++count;
     188           0 :                 now = timeval_current();
     189           0 :                 elapsed = usec_time_diff(&now, &start);
     190             :         }
     191             : 
     192             : #undef LOOKUP_PERIOD_SEC
     193             : 
     194           0 :         *rate = (unsigned)((double)count / (double)usec_to_sec(elapsed));
     195           0 :         return NT_STATUS_OK;
     196             : }
     197             : 
     198           0 : static bool remove_working_directory(struct smbcli_tree *tree,
     199             :                 const char * path)
     200             : {
     201           0 :         int tries;
     202             : 
     203             :         /* Using smbcli_deltree to delete a very large number of files
     204             :          * doesn't work against all servers. Work around this by
     205             :          * retrying.
     206             :          */
     207           0 :         for (tries = 0; tries < 5; ) {
     208           0 :                 int ret;
     209             : 
     210           0 :                 ret = smbcli_deltree(tree, BASEDIR);
     211           0 :                 if (ret == -1) {
     212           0 :                         tries++;
     213           0 :                         printf("(%s) failed to deltree %s: %s\n",
     214             :                                 __location__, BASEDIR,
     215             :                                 smbcli_errstr(tree));
     216           0 :                         continue;
     217             :                 }
     218             : 
     219           0 :                 return true;
     220             :         }
     221             : 
     222           0 :         return false;
     223             : 
     224             : }
     225             : 
     226             : /* Verify that looking up a file name takes constant time.
     227             :  *
     228             :  * This test samples the lookup rate for a non-existent filename in a
     229             :  * directory, while varying the number of files in the directory. The
     230             :  * lookup rate should continue to approximate the lookup rate for the
     231             :  * empty directory case.
     232             :  */
     233           0 : bool torture_bench_lookup(struct torture_context *torture)
     234             : {
     235           0 :         NTSTATUS        status;
     236           0 :         bool            result = false;
     237             : 
     238           0 :         int i;
     239           0 :         struct smbcli_state *cli = NULL;
     240             : 
     241           0 :         if (!torture_open_connection(&cli, torture, 0)) {
     242           0 :                 goto done;
     243             :         }
     244             : 
     245           0 :         remove_working_directory(cli->tree, BASEDIR);
     246             : 
     247           0 :         for (i = 0; i < ARRAY_SIZE(records); ++i) {
     248           0 :                 printf("Testing lookup rate with %u directory entries\n",
     249             :                                 records[i].dirent_count);
     250             : 
     251           0 :                 status = fill_directory(cli->tree, BASEDIR,
     252             :                                 records[i].dirent_count);
     253           0 :                 if (!NT_STATUS_IS_OK(status)) {
     254           0 :                         printf("failed to fill directory: %s\n", nt_errstr(status));
     255           0 :                         goto done;
     256             :                 }
     257             : 
     258           0 :                 status = lookup_rate_convert(cli->tree, querypath_lookup,
     259             :                         MISSINGNAME, &records[i].querypath_persec);
     260           0 :                 if (!NT_STATUS_IS_OK(status)) {
     261           0 :                         printf("querypathinfo of %s failed: %s\n",
     262             :                                 MISSINGNAME, nt_errstr(status));
     263           0 :                         goto done;
     264             :                 }
     265             : 
     266           0 :                 status = lookup_rate_convert(cli->tree, findfirst_lookup,
     267             :                         MISSINGNAME, &records[i].findfirst_persec);
     268           0 :                 if (!NT_STATUS_IS_OK(status)) {
     269           0 :                         printf("findfirst of %s failed: %s\n",
     270             :                                 MISSINGNAME, nt_errstr(status));
     271           0 :                         goto done;
     272             :                 }
     273             : 
     274           0 :                 printf("entries = %u, querypath = %u/sec, findfirst = %u/sec\n",
     275             :                                 records[i].dirent_count,
     276             :                                 records[i].querypath_persec,
     277             :                                 records[i].findfirst_persec);
     278             : 
     279           0 :                 if (!remove_working_directory(cli->tree, BASEDIR)) {
     280           0 :                         goto done;
     281             :                 }
     282             :         }
     283             : 
     284             :         /* Ok. We have run all our tests. Walk through the records we
     285             :          * accumulated and figure out whether the lookups took constant
     286             :          * time or not.
     287             :          */
     288           0 :         result = true;
     289           0 :         for (i = 0; i < ARRAY_SIZE(records); ++i) {
     290           0 :                 if (!fuzzily_equal(records[0].querypath_persec,
     291             :                                     records[i].querypath_persec,
     292             :                                     FUZZ_PERCENT)) {
     293           0 :                         printf("querypath rate for %d entries differed by "
     294             :                                 "more than %d%% from base rate\n",
     295             :                                 records[i].dirent_count, FUZZ_PERCENT);
     296           0 :                         result = false;
     297             :                 }
     298             : 
     299           0 :                 if (!fuzzily_equal(records[0].findfirst_persec,
     300             :                                     records[i].findfirst_persec,
     301             :                                     FUZZ_PERCENT)) {
     302           0 :                         printf("findfirst rate for %d entries differed by "
     303             :                                 "more than %d%% from base rate\n",
     304             :                                 records[i].dirent_count, FUZZ_PERCENT);
     305           0 :                         result = false;
     306             :                 }
     307             :         }
     308             : 
     309           0 : done:
     310           0 :         if (cli) {
     311           0 :                 remove_working_directory(cli->tree, BASEDIR);
     312           0 :                 talloc_free(cli);
     313             :         }
     314             : 
     315           0 :         return result;
     316             : }
     317             : 
     318             : /* vim: set sts=8 sw=8 : */

Generated by: LCOV version 1.14