2 Unix SMB/CIFS implementation.
6 Copyright (C) Ronnie Sahlberg 2007
8 Significantly based on and borrowed from lockbench.c by
9 Copyright (C) Andrew Tridgell 2006
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.
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.
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/>.
26 filename is specified by
27 --option=torture:filename=...
29 number of locks is specified by
30 --option=torture:num_locks=...
32 locktimeout is specified in ms by
33 --option=torture:locktimeout=...
35 default is 100 seconds
36 if set to 0 pingpong will instead loop trying the lock operation
37 over and over until it completes.
39 reading from the file can be enabled with
40 --option=torture:read=True
42 writing to the file can be enabled with
43 --option=torture:write=True
47 #include "torture/torture.h"
48 #include "libcli/raw/libcliraw.h"
49 #include "system/time.h"
50 #include "system/filesys.h"
51 #include "libcli/libcli.h"
52 #include "torture/util.h"
53 #include "param/param.h"
58 void lock_byte(struct smbcli_state *cli, int fd, int offset, int lock_timeout)
61 struct smb_lock_entry lock;
66 io.lockx.in.ulock_cnt = 0;
67 io.lockx.in.lock_cnt = 1;
71 lock.pid = cli->tree->session->pid;
72 io.lockx.level = RAW_LOCK_LOCKX;
73 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
74 io.lockx.in.timeout = lock_timeout;
75 io.lockx.in.locks = &lock;
76 io.lockx.in.file.fnum = fd;
78 status = smb_raw_lock(cli->tree, &io);
80 /* If we dont use timeouts and we got file lock conflict
81 just try the lock again.
83 if (lock_timeout==0) {
84 if ( (NT_STATUS_EQUAL(NT_STATUS_FILE_LOCK_CONFLICT, status))
85 ||(NT_STATUS_EQUAL(NT_STATUS_LOCK_NOT_GRANTED, status)) ) {
90 if (!NT_STATUS_IS_OK(status)) {
91 DEBUG(0,("Lock failed\n"));
96 void unlock_byte(struct smbcli_state *cli, int fd, int offset)
99 struct smb_lock_entry lock;
103 io.lockx.in.ulock_cnt = 1;
104 io.lockx.in.lock_cnt = 0;
107 lock.offset = offset;
108 lock.pid = cli->tree->session->pid;
109 io.lockx.level = RAW_LOCK_LOCKX;
110 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
111 io.lockx.in.timeout = 100000;
112 io.lockx.in.locks = &lock;
113 io.lockx.in.file.fnum = fd;
115 status = smb_raw_lock(cli->tree, &io);
117 if (!NT_STATUS_IS_OK(status)) {
118 DEBUG(0,("Unlock failed\n"));
123 void write_byte(struct smbcli_state *cli, int fd, uint8_t c, int offset)
128 io.generic.level = RAW_WRITE_WRITEX;
129 io.writex.in.file.fnum = fd;
130 io.writex.in.offset = offset;
131 io.writex.in.wmode = 0;
132 io.writex.in.remaining = 0;
133 io.writex.in.count = 1;
134 io.writex.in.data = &c;
136 status = smb_raw_write(cli->tree, &io);
137 if (!NT_STATUS_IS_OK(status)) {
138 printf("write failed\n");
143 void read_byte(struct smbcli_state *cli, int fd, uint8_t *c, int offset)
148 io.generic.level = RAW_READ_READX;
149 io.readx.in.file.fnum = fd;
150 io.readx.in.mincnt = 1;
151 io.readx.in.maxcnt = 1;
152 io.readx.in.offset = offset;
153 io.readx.in.remaining = 0;
154 io.readx.in.read_for_execute = False;
155 io.readx.out.data = c;
157 status = smb_raw_read(cli->tree, &io);
158 if (!NT_STATUS_IS_OK(status)) {
159 printf("read failed\n");
165 static struct timeval tp1, tp2;
167 static void start_timer(void)
169 gettimeofday(&tp1, NULL);
172 static double end_timer(void)
174 gettimeofday(&tp2, NULL);
175 return (tp2.tv_sec + (tp2.tv_usec*1.0e-6)) -
176 (tp1.tv_sec + (tp1.tv_usec*1.0e-6));
182 BOOL torture_ping_pong(struct torture_context *torture)
186 TALLOC_CTX *mem_ctx = talloc_new(torture);
187 static BOOL do_reads;
188 static BOOL do_writes;
191 struct smbcli_state *cli;
193 uint8_t incr=0, last_incr=0;
197 fn = lp_parm_string(-1, "torture", "filename");
199 DEBUG(0,("You must specify the filename using --option=torture:filename=...\n"));
203 num_locks = lp_parm_int(-1, "torture", "num_locks", -1);
204 if (num_locks == -1) {
205 DEBUG(0,("You must specify num_locks using --option=torture:num_locks=...\n"));
209 do_reads = lp_parm_bool(-1, "torture", "read", False);
210 do_writes = lp_parm_bool(-1, "torture", "write", False);
211 lock_timeout = lp_parm_int(-1, "torture", "lock_timeout", 100000);
213 if (!torture_open_connection(&cli, 0)) {
214 DEBUG(0,("Could not open connection\n"));
218 fd = smbcli_open(cli->tree, fn, O_RDWR|O_CREAT, DENY_NONE);
220 printf("Failed to open %s\n", fn);
224 write_byte(cli, fd, 0, num_locks);
225 lock_byte(cli, fd, 0, lock_timeout);
229 val = talloc_zero_array(mem_ctx, uint8_t, num_locks);
234 lock_byte(cli, fd, (i+1)%num_locks, lock_timeout);
238 read_byte(cli, fd, &c, i);
244 uint8_t c = val[i] + 1;
245 write_byte(cli, fd, c, i);
248 unlock_byte(cli, fd, i);
252 if (loops>num_locks && incr!=last_incr) {
254 printf("data increment = %u\n", incr);
257 if (end_timer() > 1.0) {
258 printf("%8u locks/sec\r",
259 (unsigned)(2*count/end_timer()));
267 talloc_free(mem_ctx);