source: trunk/server/source4/torture/nbench/nbio.c

Last change on this file was 745, checked in by Silvan Scherrer, 13 years ago

Samba Server: updated trunk to 3.6.0
File size: 21.9 KB
Line 
1/*
2 TODO: add splitting of writes for servers with signing
3*/
4
5
6/*
7 Unix SMB/CIFS implementation.
8 SMB torture tester
9 Copyright (C) Andrew Tridgell 1997-1998
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>.
23*/
24
25#include "includes.h"
26#include "system/time.h"
27#include "system/filesys.h"
28#include "../lib/util/dlinklist.h"
29#include "libcli/libcli.h"
30#include "torture/util.h"
31#include "torture/nbench/proto.h"
32
33extern int nbench_line_count;
34static int nbio_id = -1;
35static int nprocs;
36static bool bypass_io;
37static struct timeval tv_start, tv_end;
38static int warmup, timelimit;
39static int in_cleanup;
40
41struct lock_info {
42 struct lock_info *next, *prev;
43 off_t offset;
44 int size;
45};
46
47struct createx_params {
48 char *fname;
49 unsigned int create_options;
50 unsigned int create_disposition;
51 int handle;
52};
53
54struct ftable {
55 struct ftable *next, *prev;
56 int fd; /* the fd that we got back from the server */
57 int handle; /* the handle in the load file */
58 struct createx_params cp;
59 struct lock_info *locks;
60};
61
62static struct ftable *ftable;
63
64static struct {
65 double bytes, warmup_bytes;
66 int line;
67 int done;
68 bool connected;
69 double max_latency;
70 struct timeval starttime;
71} *children;
72
73static bool nb_do_createx(struct ftable *f,
74 const char *fname,
75 unsigned int create_options,
76 unsigned int create_disposition,
77 int handle,
78 NTSTATUS status,
79 bool retry);
80
81static bool nb_do_lockx(bool relock, int handle, off_t offset, int size, NTSTATUS status);
82
83static void nb_set_createx_params(struct ftable *f,
84 const char *fname,
85 unsigned int create_options,
86 unsigned int create_disposition,
87 int handle)
88{
89 struct createx_params *cp = &f->cp;
90
91 if (fname != NULL) {
92 cp->fname = talloc_strdup(f, fname);
93 if (cp->fname == NULL) {
94 perror("nb_set_createx_params: strdup");
95 nb_exit(1);
96 }
97 } else {
98 cp->fname = NULL;
99 }
100
101 cp->create_options = create_options;
102 cp->create_disposition = create_disposition;
103 cp->handle = handle;
104}
105
106static bool nb_reestablish_locks(struct ftable *f)
107{
108 struct lock_info *linfo = f->locks;
109
110 while (linfo != NULL) {
111 DEBUG(1,("nb_reestablish_locks: lock for file %d at %lu\n",
112 f->handle, (unsigned long) linfo->offset));
113
114 if (!nb_do_lockx(true, f->handle, linfo->offset, linfo->size, NT_STATUS_OK)) {
115 printf("nb_reestablish_locks: failed to get lock for file %s at %lu\n",
116 f->cp.fname, (unsigned long) linfo->offset);
117 return false;
118 }
119
120 linfo = linfo->next;
121 }
122
123 return true;
124}
125
126static bool nb_reopen_all_files(void)
127{
128 struct ftable *f = ftable;
129
130 while (f != NULL) {
131 DEBUG(1,("-- nb_reopen_all_files: opening %s (handle %d)\n",
132 f->cp.fname, f->cp.handle));
133
134 if (!nb_do_createx(f,
135 f->cp.fname,
136 f->cp.create_options,
137 f->cp.create_disposition,
138 f->cp.handle,
139 NT_STATUS_OK,
140 true))
141 {
142 printf("-- nb_reopen_all_files: failed to open file %s\n", f->cp.fname);
143 return false;
144 }
145
146 if (!nb_reestablish_locks(f)) {
147 printf("--nb_reopen_all_files: failed to reestablish locks\n");
148 return false;
149 }
150
151 f = f->next;
152 }
153
154 return true;
155}
156
157bool nb_reconnect(struct smbcli_state **cli, struct torture_context *tctx, int client)
158{
159 children[client].connected = false;
160
161 if (*cli != NULL) {
162 talloc_free(*cli);
163 }
164
165 if (!torture_open_connection(cli, tctx, client)) {
166 printf("nb_reconnect: failed to connect\n");
167 *cli = NULL;
168 return false;
169 }
170
171 nb_setup(*cli, client);
172
173 if (!nb_reopen_all_files()) {
174 printf("nb_reconnect: failed to reopen files in client %d\n", client);
175 return false;
176 }
177
178 return true;
179}
180
181void nbio_target_rate(double rate)
182{
183 static double last_bytes;
184 static struct timeval last_time;
185 double tdelay;
186
187 if (last_bytes == 0) {
188 last_bytes = children[nbio_id].bytes;
189 last_time = timeval_current();
190 return;
191 }
192
193 tdelay = (children[nbio_id].bytes - last_bytes)/(1.0e6*rate) - timeval_elapsed(&last_time);
194 if (tdelay > 0) {
195 smb_msleep(tdelay*1000);
196 } else {
197 children[nbio_id].max_latency = MAX(children[nbio_id].max_latency, -tdelay);
198 }
199
200 last_time = timeval_current();
201 last_bytes = children[nbio_id].bytes;
202}
203
204void nbio_time_reset(void)
205{
206 children[nbio_id].starttime = timeval_current();
207}
208
209void nbio_time_delay(double targett)
210{
211 double elapsed = timeval_elapsed(&children[nbio_id].starttime);
212 if (targett > elapsed) {
213 smb_msleep(1000*(targett - elapsed));
214 } else if (elapsed - targett > children[nbio_id].max_latency) {
215 children[nbio_id].max_latency = MAX(elapsed - targett, children[nbio_id].max_latency);
216 }
217}
218
219double nbio_result(void)
220{
221 int i;
222 double total = 0;
223 for (i=0;i<nprocs;i++) {
224 total += children[i].bytes - children[i].warmup_bytes;
225 }
226 return 1.0e-6 * total / timeval_elapsed2(&tv_start, &tv_end);
227}
228
229double nbio_latency(void)
230{
231 int i;
232 double max_latency = 0;
233 for (i=0;i<nprocs;i++) {
234 if (children[i].max_latency > max_latency) {
235 max_latency = children[i].max_latency;
236 children[i].max_latency = 0;
237 }
238 }
239 return max_latency;
240}
241
242bool nb_tick(void)
243{
244 return children[nbio_id].done;
245}
246
247
248void nb_alarm(int sig)
249{
250 int i;
251 int lines=0;
252 double t;
253 int in_warmup = 0;
254 int num_connected = 0;
255
256 if (nbio_id != -1) return;
257
258 for (i=0;i<nprocs;i++) {
259 if (children[i].connected) {
260 num_connected++;
261 }
262 if (children[i].bytes == 0) {
263 in_warmup = 1;
264 }
265 lines += children[i].line;
266 }
267
268 t = timeval_elapsed(&tv_start);
269
270 if (!in_warmup && warmup>0 && t > warmup) {
271 tv_start = timeval_current();
272 warmup = 0;
273 for (i=0;i<nprocs;i++) {
274 children[i].warmup_bytes = children[i].bytes;
275 }
276 goto next;
277 }
278 if (t < warmup) {
279 in_warmup = 1;
280 } else if (!in_warmup && !in_cleanup && t > timelimit) {
281 for (i=0;i<nprocs;i++) {
282 children[i].done = 1;
283 }
284 tv_end = timeval_current();
285 in_cleanup = 1;
286 }
287 if (t < 1) {
288 goto next;
289 }
290 if (!in_cleanup) {
291 tv_end = timeval_current();
292 }
293
294 if (in_warmup) {
295 printf("%4d %8d %.2f MB/sec warmup %.0f sec \n",
296 num_connected, lines/nprocs,
297 nbio_result(), t);
298 } else if (in_cleanup) {
299 printf("%4d %8d %.2f MB/sec cleanup %.0f sec \n",
300 num_connected, lines/nprocs,
301 nbio_result(), t);
302 } else {
303 printf("%4d %8d %.2f MB/sec execute %.0f sec latency %.2f msec \n",
304 num_connected, lines/nprocs,
305 nbio_result(), t, nbio_latency() * 1.0e3);
306 }
307
308 fflush(stdout);
309next:
310 signal(SIGALRM, nb_alarm);
311 alarm(1);
312}
313
314void nbio_shmem(int n, int t_timelimit, int t_warmup)
315{
316 nprocs = n;
317 children = shm_setup(sizeof(*children) * nprocs);
318 if (!children) {
319 printf("Failed to setup shared memory!\n");
320 nb_exit(1);
321 }
322 memset(children, 0, sizeof(*children) * nprocs);
323 timelimit = t_timelimit;
324 warmup = t_warmup;
325 in_cleanup = 0;
326 tv_start = timeval_current();
327}
328
329static struct lock_info* find_lock(struct lock_info *linfo, off_t offset, int size)
330{
331 while (linfo != NULL) {
332 if (linfo->offset == offset &&
333 linfo->size == size)
334 {
335 return linfo;
336 }
337
338 linfo = linfo->next;
339 }
340
341 return NULL;
342}
343
344static struct ftable *find_ftable(int handle)
345{
346 struct ftable *f;
347
348 for (f=ftable;f;f=f->next) {
349 if (f->handle == handle) return f;
350 }
351 return NULL;
352}
353
354static int find_handle(int handle, struct ftable **f_ret)
355{
356 struct ftable *f;
357
358 if (f_ret != NULL)
359 *f_ret = NULL;
360
361 children[nbio_id].line = nbench_line_count;
362
363 f = find_ftable(handle);
364 if (f) {
365 if (f_ret != NULL)
366 *f_ret = f;
367 return f->fd;
368 }
369 printf("(%d) ERROR: handle %d was not found\n",
370 nbench_line_count, handle);
371 nb_exit(1);
372
373 return -1; /* Not reached */
374}
375
376
377
378static struct smbcli_state *c;
379
380/*
381 a handler function for oplock break requests
382*/
383static bool oplock_handler(struct smbcli_transport *transport, uint16_t tid,
384 uint16_t fnum, uint8_t level, void *private_data)
385{
386 struct smbcli_tree *tree = (struct smbcli_tree *)private_data;
387 return smbcli_oplock_ack(tree, fnum, OPLOCK_BREAK_TO_NONE);
388}
389
390void nb_setup(struct smbcli_state *cli, int id)
391{
392 nbio_id = id;
393 c = cli;
394 if (bypass_io)
395 printf("skipping I/O\n");
396
397 if (cli) {
398 smbcli_oplock_handler(cli->transport, oplock_handler, cli->tree);
399 }
400
401 children[id].connected = true;
402}
403
404
405static bool check_status(const char *op, NTSTATUS status, NTSTATUS ret)
406{
407 if ((NT_STATUS_EQUAL(ret, NT_STATUS_END_OF_FILE) ||
408 NT_STATUS_EQUAL(ret, NT_STATUS_NET_WRITE_FAULT) ||
409 NT_STATUS_EQUAL(ret, NT_STATUS_CONNECTION_RESET))
410 && !NT_STATUS_EQUAL (status, ret))
411 {
412 return false;
413 }
414
415 if (!NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(ret)) {
416 printf("[%d] Error: %s should have failed with %s\n",
417 nbench_line_count, op, nt_errstr(status));
418 nb_exit(1);
419 }
420
421 if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(ret)) {
422 printf("[%d] Error: %s should have succeeded - %s\n",
423 nbench_line_count, op, nt_errstr(ret));
424 nb_exit(1);
425 }
426
427 if (!NT_STATUS_EQUAL(status, ret)) {
428 printf("[%d] Warning: got status %s but expected %s\n",
429 nbench_line_count, nt_errstr(ret), nt_errstr(status));
430 }
431
432 return true;
433}
434
435
436bool nb_unlink(const char *fname, int attr, NTSTATUS status, bool retry)
437{
438 union smb_unlink io;
439 NTSTATUS ret;
440
441 io.unlink.in.pattern = fname;
442
443 io.unlink.in.attrib = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
444 if (strchr(fname, '*') == 0) {
445 io.unlink.in.attrib |= FILE_ATTRIBUTE_DIRECTORY;
446 }
447
448 ret = smb_raw_unlink(c->tree, &io);
449
450 if (!retry)
451 return check_status("Unlink", status, ret);
452
453 return true;
454}
455
456static bool nb_do_createx(struct ftable *f,
457 const char *fname,
458 unsigned int create_options,
459 unsigned int create_disposition,
460 int handle,
461 NTSTATUS status,
462 bool retry)
463{
464 union smb_open io;
465 uint32_t desired_access;
466 NTSTATUS ret;
467 TALLOC_CTX *mem_ctx;
468 unsigned int flags = 0;
469
470 mem_ctx = talloc_init("raw_open");
471
472 if (create_options & NTCREATEX_OPTIONS_DIRECTORY) {
473 desired_access = SEC_FILE_READ_DATA;
474 } else {
475 desired_access =
476 SEC_FILE_READ_DATA |
477 SEC_FILE_WRITE_DATA |
478 SEC_FILE_READ_ATTRIBUTE |
479 SEC_FILE_WRITE_ATTRIBUTE;
480 flags = NTCREATEX_FLAGS_EXTENDED |
481 NTCREATEX_FLAGS_REQUEST_OPLOCK |
482 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
483 }
484
485 io.ntcreatex.level = RAW_OPEN_NTCREATEX;
486 io.ntcreatex.in.flags = flags;
487 io.ntcreatex.in.root_fid.fnum = 0;
488 io.ntcreatex.in.access_mask = desired_access;
489 io.ntcreatex.in.file_attr = 0;
490 io.ntcreatex.in.alloc_size = 0;
491 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE;
492 io.ntcreatex.in.open_disposition = create_disposition;
493 io.ntcreatex.in.create_options = create_options;
494 io.ntcreatex.in.impersonation = 0;
495 io.ntcreatex.in.security_flags = 0;
496 io.ntcreatex.in.fname = fname;
497
498 if (retry) {
499 /* Reopening after a disconnect. */
500 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
501 } else
502 if (f != NULL &&
503 f->cp.create_disposition == NTCREATEX_DISP_CREATE &&
504 NT_STATUS_IS_OK(status))
505 {
506 /* Reopening after nb_createx() error. */
507 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
508 }
509
510 ret = smb_raw_open(c->tree, mem_ctx, &io);
511
512 talloc_free(mem_ctx);
513
514 if (!check_status("NTCreateX", status, ret))
515 return false;
516
517 if (!NT_STATUS_IS_OK(ret))
518 return true;
519
520 if (f == NULL) {
521 f = talloc (NULL, struct ftable);
522 f->locks = NULL;
523 nb_set_createx_params(f, fname, create_options, create_disposition, handle);
524 DLIST_ADD_END(ftable, f, struct ftable *);
525 }
526
527 f->handle = handle;
528 f->fd = io.ntcreatex.out.file.fnum;
529
530 return true;
531}
532
533bool nb_createx(const char *fname,
534 unsigned int create_options, unsigned int create_disposition, int handle,
535 NTSTATUS status)
536{
537 return nb_do_createx(NULL, fname, create_options, create_disposition, handle, status, false);
538}
539
540bool nb_writex(int handle, off_t offset, int size, int ret_size, NTSTATUS status)
541{
542 union smb_write io;
543 int i;
544 NTSTATUS ret;
545 uint8_t *buf;
546
547 i = find_handle(handle, NULL);
548
549 if (bypass_io)
550 return true;
551
552 buf = malloc(size);
553 memset(buf, 0xab, size);
554
555 io.writex.level = RAW_WRITE_WRITEX;
556 io.writex.in.file.fnum = i;
557 io.writex.in.wmode = 0;
558 io.writex.in.remaining = 0;
559 io.writex.in.offset = offset;
560 io.writex.in.count = size;
561 io.writex.in.data = buf;
562
563 ret = smb_raw_write(c->tree, &io);
564
565 free(buf);
566
567 if (!check_status("WriteX", status, ret))
568 return false;
569
570 if (NT_STATUS_IS_OK(ret) && io.writex.out.nwritten != ret_size) {
571 printf("[%d] Warning: WriteX got count %d expected %d\n",
572 nbench_line_count,
573 io.writex.out.nwritten, ret_size);
574 }
575
576 children[nbio_id].bytes += ret_size;
577
578 return true;
579}
580
581bool nb_write(int handle, off_t offset, int size, int ret_size, NTSTATUS status)
582{
583 union smb_write io;
584 int i;
585 NTSTATUS ret;
586 uint8_t *buf;
587
588 i = find_handle(handle, NULL);
589
590 if (bypass_io)
591 return true;
592
593 buf = malloc(size);
594
595 memset(buf, 0x12, size);
596
597 io.write.level = RAW_WRITE_WRITE;
598 io.write.in.file.fnum = i;
599 io.write.in.remaining = 0;
600 io.write.in.offset = offset;
601 io.write.in.count = size;
602 io.write.in.data = buf;
603
604 ret = smb_raw_write(c->tree, &io);
605
606 free(buf);
607
608 if (!check_status("Write", status, ret))
609 return false;
610
611 if (NT_STATUS_IS_OK(ret) && io.write.out.nwritten != ret_size) {
612 printf("[%d] Warning: Write got count %d expected %d\n",
613 nbench_line_count,
614 io.write.out.nwritten, ret_size);
615 }
616
617 children[nbio_id].bytes += ret_size;
618
619 return true;
620}
621
622static bool nb_do_lockx(bool relock, int handle, off_t offset, int size, NTSTATUS status)
623{
624 union smb_lock io;
625 int i;
626 NTSTATUS ret;
627 struct smb_lock_entry lck;
628 struct ftable *f;
629
630 i = find_handle(handle, &f);
631
632 lck.pid = getpid();
633 lck.offset = offset;
634 lck.count = size;
635
636 io.lockx.level = RAW_LOCK_LOCKX;
637 io.lockx.in.file.fnum = i;
638 io.lockx.in.mode = 0;
639 io.lockx.in.timeout = 0;
640 io.lockx.in.ulock_cnt = 0;
641 io.lockx.in.lock_cnt = 1;
642 io.lockx.in.locks = &lck;
643
644 ret = smb_raw_lock(c->tree, &io);
645
646 if (!check_status("LockX", status, ret))
647 return false;
648
649 if (f != NULL &&
650 !relock)
651 {
652 struct lock_info *linfo;
653 linfo = talloc (f, struct lock_info);
654 linfo->offset = offset;
655 linfo->size = size;
656 DLIST_ADD_END(f->locks, linfo, struct lock_info *);
657 }
658
659 return true;
660}
661
662bool nb_lockx(int handle, off_t offset, int size, NTSTATUS status)
663{
664 return nb_do_lockx(false, handle, offset, size, status);
665}
666
667bool nb_unlockx(int handle, unsigned int offset, int size, NTSTATUS status)
668{
669 union smb_lock io;
670 int i;
671 NTSTATUS ret;
672 struct smb_lock_entry lck;
673 struct ftable *f;
674
675 i = find_handle(handle, &f);
676
677 lck.pid = getpid();
678 lck.offset = offset;
679 lck.count = size;
680
681 io.lockx.level = RAW_LOCK_LOCKX;
682 io.lockx.in.file.fnum = i;
683 io.lockx.in.mode = 0;
684 io.lockx.in.timeout = 0;
685 io.lockx.in.ulock_cnt = 1;
686 io.lockx.in.lock_cnt = 0;
687 io.lockx.in.locks = &lck;
688
689 ret = smb_raw_lock(c->tree, &io);
690
691 if (!check_status("UnlockX", status, ret))
692 return false;
693
694 if (f != NULL) {
695 struct lock_info *linfo;
696 linfo = find_lock(f->locks, offset, size);
697 if (linfo != NULL)
698 DLIST_REMOVE(f->locks, linfo);
699 else
700 printf("nb_unlockx: unknown lock (%d)\n", handle);
701 }
702
703 return true;
704}
705
706bool nb_readx(int handle, off_t offset, int size, int ret_size, NTSTATUS status)
707{
708 union smb_read io;
709 int i;
710 NTSTATUS ret;
711 uint8_t *buf;
712
713 i = find_handle(handle, NULL);
714
715 if (bypass_io)
716 return true;
717
718 buf = malloc(size);
719
720 io.readx.level = RAW_READ_READX;
721 io.readx.in.file.fnum = i;
722 io.readx.in.offset = offset;
723 io.readx.in.mincnt = size;
724 io.readx.in.maxcnt = size;
725 io.readx.in.remaining = 0;
726 io.readx.in.read_for_execute = false;
727 io.readx.out.data = buf;
728
729 ret = smb_raw_read(c->tree, &io);
730
731 free(buf);
732
733 if (!check_status("ReadX", status, ret))
734 return false;
735
736 if (NT_STATUS_IS_OK(ret) && io.readx.out.nread != ret_size) {
737 printf("[%d] ERROR: ReadX got count %d expected %d\n",
738 nbench_line_count,
739 io.readx.out.nread, ret_size);
740 nb_exit(1);
741 }
742
743 children[nbio_id].bytes += ret_size;
744
745 return true;
746}
747
748bool nb_close(int handle, NTSTATUS status)
749{
750 NTSTATUS ret;
751 union smb_close io;
752 int i;
753
754 i = find_handle(handle, NULL);
755
756 io.close.level = RAW_CLOSE_CLOSE;
757 io.close.in.file.fnum = i;
758 io.close.in.write_time = 0;
759
760 ret = smb_raw_close(c->tree, &io);
761
762 if (!check_status("Close", status, ret))
763 return false;
764
765 if (NT_STATUS_IS_OK(ret)) {
766 struct ftable *f = find_ftable(handle);
767 DLIST_REMOVE(ftable, f);
768 talloc_free(f);
769 }
770
771 return true;
772}
773
774bool nb_rmdir(const char *dname, NTSTATUS status, bool retry)
775{
776 NTSTATUS ret;
777 struct smb_rmdir io;
778
779 io.in.path = dname;
780
781 ret = smb_raw_rmdir(c->tree, &io);
782
783 if (!retry)
784 return check_status("Rmdir", status, ret);
785
786 return true;
787}
788
789bool nb_mkdir(const char *dname, NTSTATUS status, bool retry)
790{
791 union smb_mkdir io;
792
793 io.mkdir.level = RAW_MKDIR_MKDIR;
794 io.mkdir.in.path = dname;
795
796 /* NOTE! no error checking. Used for base fileset creation */
797 smb_raw_mkdir(c->tree, &io);
798
799 return true;
800}
801
802bool nb_rename(const char *o, const char *n, NTSTATUS status, bool retry)
803{
804 NTSTATUS ret;
805 union smb_rename io;
806
807 io.generic.level = RAW_RENAME_RENAME;
808 io.rename.in.attrib = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY;
809 io.rename.in.pattern1 = o;
810 io.rename.in.pattern2 = n;
811
812 ret = smb_raw_rename(c->tree, &io);
813
814 if (!retry)
815 return check_status("Rename", status, ret);
816
817 return true;
818}
819
820
821bool nb_qpathinfo(const char *fname, int level, NTSTATUS status)
822{
823 union smb_fileinfo io;
824 TALLOC_CTX *mem_ctx;
825 NTSTATUS ret;
826
827 mem_ctx = talloc_init("nb_qpathinfo");
828
829 io.generic.level = level;
830 io.generic.in.file.path = fname;
831
832 ret = smb_raw_pathinfo(c->tree, mem_ctx, &io);
833
834 talloc_free(mem_ctx);
835
836 return check_status("Pathinfo", status, ret);
837}
838
839
840bool nb_qfileinfo(int fnum, int level, NTSTATUS status)
841{
842 union smb_fileinfo io;
843 TALLOC_CTX *mem_ctx;
844 NTSTATUS ret;
845 int i;
846
847 i = find_handle(fnum, NULL);
848
849 mem_ctx = talloc_init("nb_qfileinfo");
850
851 io.generic.level = level;
852 io.generic.in.file.fnum = i;
853
854 ret = smb_raw_fileinfo(c->tree, mem_ctx, &io);
855
856 talloc_free(mem_ctx);
857
858 return check_status("Fileinfo", status, ret);
859}
860
861bool nb_sfileinfo(int fnum, int level, NTSTATUS status)
862{
863 union smb_setfileinfo io;
864 NTSTATUS ret;
865 int i;
866
867 if (level != RAW_SFILEINFO_BASIC_INFORMATION) {
868 printf("[%d] Warning: setfileinfo level %d not handled\n", nbench_line_count, level);
869 return true;
870 }
871
872 ZERO_STRUCT(io);
873
874 i = find_handle(fnum, NULL);
875
876 io.generic.level = level;
877 io.generic.in.file.fnum = i;
878 unix_to_nt_time(&io.basic_info.in.create_time, time(NULL));
879 unix_to_nt_time(&io.basic_info.in.access_time, 0);
880 unix_to_nt_time(&io.basic_info.in.write_time, 0);
881 unix_to_nt_time(&io.basic_info.in.change_time, 0);
882 io.basic_info.in.attrib = 0;
883
884 ret = smb_raw_setfileinfo(c->tree, &io);
885
886 return check_status("Setfileinfo", status, ret);
887}
888
889bool nb_qfsinfo(int level, NTSTATUS status)
890{
891 union smb_fsinfo io;
892 TALLOC_CTX *mem_ctx;
893 NTSTATUS ret;
894
895 mem_ctx = talloc_init("smbcli_dskattr");
896
897 io.generic.level = level;
898 ret = smb_raw_fsinfo(c->tree, mem_ctx, &io);
899
900 talloc_free(mem_ctx);
901
902 return check_status("Fsinfo", status, ret);
903}
904
905/* callback function used for trans2 search */
906static bool findfirst_callback(void *private_data, const union smb_search_data *file)
907{
908 return true;
909}
910
911bool nb_findfirst(const char *mask, int level, int maxcnt, int count, NTSTATUS status)
912{
913 union smb_search_first io;
914 TALLOC_CTX *mem_ctx;
915 NTSTATUS ret;
916
917 mem_ctx = talloc_init("smbcli_dskattr");
918
919 io.t2ffirst.level = RAW_SEARCH_TRANS2;
920 io.t2ffirst.data_level = level;
921 io.t2ffirst.in.max_count = maxcnt;
922 io.t2ffirst.in.search_attrib = FILE_ATTRIBUTE_DIRECTORY;
923 io.t2ffirst.in.pattern = mask;
924 io.t2ffirst.in.flags = FLAG_TRANS2_FIND_CLOSE;
925 io.t2ffirst.in.storage_type = 0;
926
927 ret = smb_raw_search_first(c->tree, mem_ctx, &io, NULL, findfirst_callback);
928
929 talloc_free(mem_ctx);
930
931 if (!check_status("Search", status, ret))
932 return false;
933
934 if (NT_STATUS_IS_OK(ret) && io.t2ffirst.out.count != count) {
935 printf("[%d] Warning: got count %d expected %d\n",
936 nbench_line_count,
937 io.t2ffirst.out.count, count);
938 }
939
940 return true;
941}
942
943bool nb_flush(int fnum, NTSTATUS status)
944{
945 union smb_flush io;
946 NTSTATUS ret;
947 int i;
948 i = find_handle(fnum, NULL);
949
950 io.flush.level = RAW_FLUSH_FLUSH;
951 io.flush.in.file.fnum = i;
952
953 ret = smb_raw_flush(c->tree, &io);
954
955 return check_status("Flush", status, ret);
956}
957
958void nb_sleep(int usec, NTSTATUS status)
959{
960 usleep(usec);
961}
962
963bool nb_deltree(const char *dname, bool retry)
964{
965 int total_deleted;
966
967 smb_raw_exit(c->session);
968
969 while (ftable) {
970 struct ftable *f = ftable;
971 DLIST_REMOVE(ftable, f);
972 talloc_free (f);
973 }
974
975 total_deleted = smbcli_deltree(c->tree, dname);
976
977 if (total_deleted == -1) {
978 printf("Failed to cleanup tree %s - exiting\n", dname);
979 nb_exit(1);
980 }
981
982 smbcli_rmdir(c->tree, dname);
983
984 return true;
985}
986
987
988void nb_exit(int status)
989{
990 children[nbio_id].connected = false;
991 printf("[%d] client %d exiting with status %d\n",
992 nbench_line_count, nbio_id, status);
993 exit(status);
994}
Note: See TracBrowser for help on using the repository browser.