source3/torture/nbio.c

   1 #define NBDEBUG 0
   2
   3 /*
   4    Unix SMB/CIFS implementation.
   5    SMB torture tester
   6    Copyright (C) Andrew Tridgell 1997-1998
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "torture/proto.h"
  24 #include "../libcli/security/security.h"
  25 #include "libsmb/libsmb.h"
  26 #include "libsmb/clirap.h"
  27
  28 #define MAX_FILES 1000
  29
  30 static char buf[70000];
  31 extern int line_count;
  32 extern int nbio_id;
  33 static int nprocs;
  34 static struct timeval nb_start;
  35
  36 static struct {
  37         int fd;
  38         int handle;
  39 } ftable[MAX_FILES];
  40
  41 static struct children {
  42         double bytes_in, bytes_out;
  43         int line;
  44         int done;
  45 } *children;
  46
  47 double nbio_total(void)
  48 {
  49         int i;
  50         double total = 0;
  51         for (i=0;i<nprocs;i++) {
  52                 total += children[i].bytes_out + children[i].bytes_in;
  53         }
  54         return total;
  55 }
  56
  57 void nb_alarm(int ignore)
  58 {
  59         int i;
  60         int lines=0, num_clients=0;
  61         if (nbio_id != -1) return;
  62
  63         for (i=0;i<nprocs;i++) {
  64                 lines += children[i].line;
  65                 if (!children[i].done) num_clients++;
  66         }
  67
  68         printf("%4d  %8d  %.2f MB/sec\r",
  69                num_clients, lines/nprocs,
  70                1.0e-6 * nbio_total() / timeval_elapsed(&nb_start));
  71
  72         signal(SIGALRM, nb_alarm);
  73         alarm(1);
  74 }
  75
  76 void nbio_shmem(int n)
  77 {
  78         nprocs = n;
  79         children = (struct children *)shm_setup(sizeof(*children) * nprocs);
  80         if (!children) {
  81                 printf("Failed to setup shared memory!\n");
  82                 exit(1);
  83         }
  84 }
  85
  86 #if 0
  87 static int ne_find_handle(int handle)
  88 {
  89         int i;
  90         children[nbio_id].line = line_count;
  91         for (i=0;i<MAX_FILES;i++) {
  92                 if (ftable[i].handle == handle) return i;
  93         }
  94         return -1;
  95 }
  96 #endif
  97
  98 static int find_handle(int handle)
  99 {
 100         int i;
 101         children[nbio_id].line = line_count;
 102         for (i=0;i<MAX_FILES;i++) {
 103                 if (ftable[i].handle == handle) return i;
 104         }
 105         printf("(%d) ERROR: handle %d was not found\n",
 106                line_count, handle);
 107         exit(1);
 108
 109         return -1;              /* Not reached */
 110 }
 111
 112
 113 static struct cli_state *c;
 114
 115 static void sigsegv(int sig)
 116 {
 117         char line[200];
 118         printf("segv at line %d\n", line_count);
 119         slprintf(line, sizeof(line), "/usr/X11R6/bin/xterm -e gdb /proc/%d/exe %d",
 120                 (int)getpid(), (int)getpid());
 121         if (system(line) == -1) {
 122                 printf("system() failed\n");
 123         }
 124         exit(1);
 125 }
 126
 127 void nb_setup(struct cli_state *cli)
 128 {
 129         signal(SIGSEGV, sigsegv);
 130         c = cli;
 131         nb_start = timeval_current();
 132         children[nbio_id].done = 0;
 133 }
 134
 135
 136 void nb_unlink(const char *fname)
 137 {
 138         NTSTATUS status;
 139
 140         status = cli_unlink(c, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 141         if (!NT_STATUS_IS_OK(status)) {
 142 #if NBDEBUG
 143                 printf("(%d) unlink %s failed (%s)\n",
 144                        line_count, fname, nt_errstr(status));
 145 #endif
 146         }
 147 }
 148
 149
 150 void nb_createx(const char *fname,
 151                 unsigned create_options, unsigned create_disposition, int handle)
 152 {
 153         uint16_t fd = (uint16_t)-1;
 154         int i;
 155         NTSTATUS status;
 156         uint32 desired_access;
 157
 158         if (create_options & FILE_DIRECTORY_FILE) {
 159                 desired_access = FILE_READ_DATA;
 160         } else {
 161                 desired_access = FILE_READ_DATA | FILE_WRITE_DATA;
 162         }
 163
 164         status = cli_ntcreate(c, fname, 0,
 165                                 desired_access,
 166                                 0x0,
 167                                 FILE_SHARE_READ|FILE_SHARE_WRITE,
 168                                 create_disposition,
 169                                 create_options, 0, &fd);
 170         if (!NT_STATUS_IS_OK(status) && handle != -1) {
 171                 printf("ERROR: cli_ntcreate failed for %s - %s\n",
 172                        fname, nt_errstr(status));
 173                 exit(1);
 174         }
 175         if (NT_STATUS_IS_OK(status) && handle == -1) {
 176                 printf("ERROR: cli_ntcreate succeeded for %s\n", fname);
 177                 exit(1);
 178         }
 179         if (fd == (uint16_t)-1) return;
 180
 181         for (i=0;i<MAX_FILES;i++) {
 182                 if (ftable[i].handle == 0) break;
 183         }
 184         if (i == MAX_FILES) {
 185                 printf("(%d) file table full for %s\n", line_count,
 186                        fname);
 187                 exit(1);
 188         }
 189         ftable[i].handle = handle;
 190         ftable[i].fd = fd;
 191 }
 192
 193 void nb_writex(int handle, int offset, int size, int ret_size)
 194 {
 195         int i;
 196         NTSTATUS status;
 197
 198         if (buf[0] == 0) memset(buf, 1, sizeof(buf));
 199
 200         i = find_handle(handle);
 201         status = cli_writeall(c, ftable[i].fd, 0, (uint8_t *)buf, offset, size,
 202                               NULL);
 203         if (!NT_STATUS_IS_OK(status)) {
 204                 printf("(%d) ERROR: write failed on handle %d, fd %d "
 205                        "error %s\n", line_count, handle, ftable[i].fd,
 206                        nt_errstr(status));
 207                 exit(1);
 208         }
 209
 210         children[nbio_id].bytes_out += ret_size;
 211 }
 212
 213 void nb_readx(int handle, int offset, int size, int ret_size)
 214 {
 215         int i, ret;
 216
 217         i = find_handle(handle);
 218         if ((ret=cli_read_old(c, ftable[i].fd, buf, offset, size)) != ret_size) {
 219                 printf("(%d) ERROR: read failed on handle %d ofs=%d size=%d res=%d fd %d errno %d (%s)\n",
 220                         line_count, handle, offset, size, ret, ftable[i].fd, errno, strerror(errno));
 221                 exit(1);
 222         }
 223         children[nbio_id].bytes_in += ret_size;
 224 }
 225
 226 void nb_close(int handle)
 227 {
 228         int i;
 229         i = find_handle(handle);
 230         if (!NT_STATUS_IS_OK(cli_close(c, ftable[i].fd))) {
 231                 printf("(%d) close failed on handle %d\n", line_count, handle);
 232                 exit(1);
 233         }
 234         ftable[i].handle = 0;
 235 }
 236
 237 void nb_rmdir(const char *fname)
 238 {
 239         NTSTATUS status;
 240
 241         status = cli_rmdir(c, fname);
 242         if (!NT_STATUS_IS_OK(status)) {
 243                 printf("ERROR: rmdir %s failed (%s)\n",
 244                        fname, nt_errstr(status));
 245                 exit(1);
 246         }
 247 }
 248
 249 void nb_rename(const char *oldname, const char *newname)
 250 {
 251         NTSTATUS status;
 252
 253         status = cli_rename(c, oldname, newname);
 254         if (!NT_STATUS_IS_OK(status)) {
 255                 printf("ERROR: rename %s %s failed (%s)\n",
 256                        oldname, newname, nt_errstr(status));
 257                 exit(1);
 258         }
 259 }
 260
 261
 262 void nb_qpathinfo(const char *fname)
 263 {
 264         cli_qpathinfo1(c, fname, NULL, NULL, NULL, NULL, NULL);
 265 }
 266
 267 void nb_qfileinfo(int fnum)
 268 {
 269         int i;
 270         i = find_handle(fnum);
 271         cli_qfileinfo_basic(c, ftable[i].fd, NULL, NULL, NULL, NULL, NULL,
 272                             NULL, NULL);
 273 }
 274
 275 void nb_qfsinfo(int level)
 276 {
 277         int bsize, total, avail;
 278         /* this is not the right call - we need cli_qfsinfo() */
 279         cli_dskattr(c, &bsize, &total, &avail);
 280 }
 281
 282 static NTSTATUS find_fn(const char *mnt, struct file_info *finfo, const char *name,
 283                     void *state)
 284 {
 285         /* noop */
 286         return NT_STATUS_OK;
 287 }
 288
 289 void nb_findfirst(const char *mask)
 290 {
 291         cli_list(c, mask, 0, find_fn, NULL);
 292 }
 293
 294 void nb_flush(int fnum)
 295 {
 296         int i;
 297         i = find_handle(fnum);
 298         /* hmmm, we don't have cli_flush() yet */
 299 }
 300
 301 static int total_deleted;
 302
 303 static NTSTATUS delete_fn(const char *mnt, struct file_info *finfo,
 304                       const char *name, void *state)
 305 {
 306         NTSTATUS status;
 307         char *s, *n;
 308         if (finfo->name[0] == '.') {
 309                 return NT_STATUS_OK;
 310         }
 311
 312         n = SMB_STRDUP(name);
 313         n[strlen(n)-1] = 0;
 314         if (asprintf(&s, "%s%s", n, finfo->name) == -1) {
 315                 printf("asprintf failed\n");
 316                 return NT_STATUS_NO_MEMORY;
 317         }
 318         if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
 319                 char *s2;
 320                 if (asprintf(&s2, "%s\\*", s) == -1) {
 321                         printf("asprintf failed\n");
 322                         return NT_STATUS_NO_MEMORY;
 323                 }
 324                 status = cli_list(c, s2, FILE_ATTRIBUTE_DIRECTORY, delete_fn, NULL);
 325                 if (!NT_STATUS_IS_OK(status)) {
 326                         free(n);
 327                         free(s2);
 328                         return status;
 329                 }
 330                 nb_rmdir(s);
 331         } else {
 332                 total_deleted++;
 333                 nb_unlink(s);
 334         }
 335         free(s);
 336         free(n);
 337         return NT_STATUS_OK;
 338 }
 339
 340 void nb_deltree(const char *dname)
 341 {
 342         char *mask;
 343         if (asprintf(&mask, "%s\\*", dname) == -1) {
 344                 printf("asprintf failed\n");
 345                 return;
 346         }
 347
 348         total_deleted = 0;
 349         cli_list(c, mask, FILE_ATTRIBUTE_DIRECTORY, delete_fn, NULL);
 350         free(mask);
 351         cli_rmdir(c, dname);
 352
 353         if (total_deleted) printf("WARNING: Cleaned up %d files\n", total_deleted);
 354 }
 355
 356
 357 void nb_cleanup(void)
 358 {
 359         cli_rmdir(c, "clients");
 360         children[nbio_id].done = 1;
 361 }