fix bug when setting default port for iscsi
[tridge/dbench.git] / linux_scsi.c
1 /* 
2    Copyright (C) by Ronnie Sahlberg <sahlberg@samba.org> 2008
3    
4    This program is free software; you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation; either version 3 of the License, or
7    (at your option) any later version.
8    
9    This program is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12    GNU General Public License for more details.
13    
14    You should have received a copy of the GNU General Public License
15    along with this program; if not, see <http://www.gnu.org/licenses/>.
16 */
17
18 #define _GNU_SOURCE
19 #include <stdio.h>
20 #undef _GNU_SOURCE
21
22 #include "dbench.h"
23
24 #ifdef HAVE_LINUX_SCSI_SG
25
26 #include <fcntl.h>
27 #include <sys/ioctl.h>
28 #include <scsi/sg.h>
29 #include <stdint.h>
30
31 #define SCSI_TIMEOUT 5000 /* ms */
32
33 #define discard_const(ptr) ((void *)((intptr_t)(ptr)))
34
35 struct scsi_device {
36         int fd;
37         uint32_t blocks;
38 };
39
40 static int check_sense(unsigned char sc, const char *expected);
41 static int scsi_io(int fd, unsigned char *cdb, unsigned char cdb_size, int xfer_dir, unsigned int *data_size, char *data, unsigned char *sc);
42
43 static void num_device_blocks(struct scsi_device *sd)
44 {
45         unsigned char cdb[]={0x25,0,0,0,0,0,0,0,0,0};
46         int res;
47         unsigned int data_size=8;
48         char data[data_size];
49         unsigned char sc;
50
51         res=scsi_io(sd->fd, cdb, sizeof(cdb), SG_DXFER_FROM_DEV, &data_size, data, &sc);
52         if(res){
53                 printf("SCSI_IO failed when reading disk capacity\n");
54                 exit(10);
55         }
56         if (!check_sense(sc, "0x00")) {
57                 printf("READCAPACITY10 failed (0x%02x) - expected 0x00\n", sc);
58                 exit(10);
59         }
60
61         sd->blocks = (0xff & data[0]);
62         sd->blocks = (sd->blocks<<8) | (0xff & data[1]);
63         sd->blocks = (sd->blocks<<8) | (0xff & data[2]);
64         sd->blocks = (sd->blocks<<8) | (0xff & data[3]);
65
66         sd->blocks++;
67 }
68
69 static void scsi_setup(struct child_struct *child)
70 {
71         int vers;
72         struct scsi_device *sd;
73
74         sd = malloc(sizeof(struct scsi_device));
75         if (sd == NULL) {
76                 printf("Failed to allocate scsi device structure\n");
77                         exit(10);
78         }
79         child->private=sd;
80         if((sd->fd=open(options.scsi_dev, O_RDWR))<0){
81                 printf("Failed to open scsi device node : %s\n", options.scsi_dev);
82                 free(sd);
83                 exit(10);
84         }
85         if ((ioctl(sd->fd, SG_GET_VERSION_NUM, &vers) < 0) || (vers < 30000)) {
86                 printf("%s is not a SCSI device node\n", options.scsi_dev);
87                 close(sd->fd);
88                 free(sd);
89                 exit(10);
90         }
91
92         /* read disk capacity */
93         num_device_blocks(sd);
94 }
95
96 static void scsi_cleanup(struct child_struct *child)
97 {
98         struct scsi_device *sd;
99
100         sd=child->private;
101         close(sd->fd);
102         sd->fd=-1;
103         free(sd);
104 }
105
106
107 static int scsi_io(int fd, unsigned char *cdb, unsigned char cdb_size, int xfer_dir, unsigned int *data_size, char *data, unsigned char *sc)
108 {
109         sg_io_hdr_t io_hdr;
110         unsigned int sense_len=32;
111         unsigned char sense[sense_len];
112
113         *sc = 0;
114
115         memset(&io_hdr, 0, sizeof(sg_io_hdr_t));
116         io_hdr.interface_id = 'S';
117
118         /* CDB */
119         io_hdr.cmdp = cdb;
120         io_hdr.cmd_len = cdb_size;
121
122         /* Where to store the sense_data, if there was an error */
123         io_hdr.sbp = sense;
124         io_hdr.mx_sb_len = sense_len;
125         sense_len=0;
126
127         /* Transfer direction, either in or out. Linux does not yet
128            support bidirectional SCSI transfers ?
129          */
130         io_hdr.dxfer_direction = xfer_dir;
131
132         /* Where to store the DATA IN/OUT from the device and how big the
133            buffer is
134          */
135         io_hdr.dxferp = data;
136         io_hdr.dxfer_len = *data_size;
137
138         /* SCSI timeout in ms */
139         io_hdr.timeout = SCSI_TIMEOUT;
140
141
142         if(ioctl(fd, SG_IO, &io_hdr) < 0){
143                 perror("SG_IO ioctl failed");
144                 return -1;
145         }
146
147         /* now for the error processing */
148         if((io_hdr.info & SG_INFO_OK_MASK) != SG_INFO_OK){
149                 if(io_hdr.sb_len_wr > 0){
150                         sense_len=io_hdr.sb_len_wr;
151                         *sc=sense[2]&0x0f;
152                         return 0;
153                 }
154         }
155         if(io_hdr.masked_status){
156                 printf("SCSI status=0x%x\n", io_hdr.status);
157                 printf("SCSI masked_status=0x%x\n", io_hdr.masked_status);
158                 return -2;
159         }
160         if(io_hdr.host_status){
161                 printf("SCSI host_status=0x%x\n", io_hdr.host_status);
162                 return -3;
163         }
164         if(io_hdr.driver_status){
165                 printf("driver_status=0x%x\n", io_hdr.driver_status);
166                 return -4;
167         }
168
169         return 0;
170 }
171
172
173 static int check_sense(unsigned char sc, const char *expected)
174 {
175         if (strcmp(expected, "*") == 0){
176                 return 1;
177         }
178         if (strncmp(expected, "0x", 2) == 0) {
179                 return sc == strtol(expected, NULL, 16);
180         }
181         return 0;
182 }
183
184 static void failed(struct child_struct *child)
185 {
186         child->failed = 1;
187         printf("ERROR: child %d failed at line %d\n", child->id, child->line);
188         exit(1);
189 }
190
191 static void scsi_testunitready(struct dbench_op *op)
192 {
193         struct scsi_device *sd;
194         unsigned char cdb[]={0,0,0,0,0,0};
195         int res;
196         unsigned char sc;
197         unsigned int data_size=200;
198         char data[data_size];
199
200         sd = op->child->private;
201
202         res=scsi_io(sd->fd, cdb, sizeof(cdb), SG_DXFER_FROM_DEV, &data_size, data, &sc);
203         if(res){
204                 printf("SCSI_IO failed\n");
205                 failed(op->child);
206         }
207         if (!check_sense(sc, op->status)) {
208                 printf("[%d] TESTUNITREADY \"%s\" failed (0x%02x) - expected %s\n", 
209                        op->child->line, op->fname, sc, op->status);
210                 failed(op->child);
211         }
212
213         return;
214 }
215
216
217 static void scsi_read6(struct dbench_op *op)
218 {
219         struct scsi_device *sd=op->child->private;
220         unsigned char cdb[]={0x08,0,0,0,0,0};
221         int res;
222         uint32_t lba = op->params[0];
223         uint32_t xferlen = op->params[1];
224         unsigned int data_size=1024*1024;
225         char data[data_size];
226         unsigned char sc;
227
228         if (lba == 0xffffffff) {
229                 lba = random();
230                 lba = (lba / xferlen) * xferlen;
231         }
232
233         /* we only have 24 bit addresses in read 6 */
234         if (lba > 0x00ffffff) {
235                 lba &= 0x00ffffff;
236         }
237
238         /* make sure we wrap properly instead of failing if the loadfile
239            is bigger than our device
240         */
241         if (sd->blocks <= lba) {
242                 lba = lba%sd->blocks;
243         }
244         if (sd->blocks <= lba+xferlen) {
245                 xferlen=1;
246         }
247
248         cdb[1] = (lba>>16)&0x1f;
249         cdb[2] = (lba>> 8)&0xff;
250         cdb[3] = (lba    )&0xff;
251
252         cdb[4] = xferlen&0xff;
253         data_size = xferlen*512;
254
255         res=scsi_io(sd->fd, cdb, sizeof(cdb), SG_DXFER_FROM_DEV, &data_size, data, &sc);
256         if(res){
257                 printf("SCSI_IO failed\n");
258                 failed(op->child);
259         }
260         if (!check_sense(sc, op->status)) {
261                 printf("[%d] READ6 \"%s\" failed (0x%02x) - expected %s\n", 
262                        op->child->line, op->fname, sc, op->status);
263                 failed(op->child);
264         }
265
266         op->child->bytes += xferlen*512;
267 }
268
269 static void scsi_read10(struct dbench_op *op)
270 {
271         struct scsi_device *sd=op->child->private;
272         unsigned char cdb[]={0x28,0,0,0,0,0,0,0,0,0};
273         int res;
274         uint32_t lba = op->params[0];
275         uint32_t xferlen = op->params[1];
276         int rd = op->params[2];
277         int grp = op->params[3];
278         unsigned int data_size=1024*1024;
279         char data[data_size];
280         unsigned char sc;
281
282         if (lba == 0xffffffff) {
283                 lba = random();
284                 lba = (lba / xferlen) * xferlen;
285         }
286
287         /* make sure we wrap properly instead of failing if the loadfile
288            is bigger than our device
289         */
290         if (sd->blocks <= lba) {
291                 lba = lba%sd->blocks;
292         }
293         if (sd->blocks <= lba+xferlen) {
294                 xferlen=1;
295         }
296
297         cdb[1] = rd;
298
299         cdb[2] = (lba>>24)&0xff;
300         cdb[3] = (lba>>16)&0xff;
301         cdb[4] = (lba>> 8)&0xff;
302         cdb[5] = (lba    )&0xff;
303
304         cdb[6] = grp&0x1f;
305
306         cdb[7] = (xferlen>>8)&0xff;
307         cdb[8] = xferlen&0xff;
308         data_size = xferlen*512;
309
310         res=scsi_io(sd->fd, cdb, sizeof(cdb), SG_DXFER_FROM_DEV, &data_size, data, &sc);
311         if(res){
312                 printf("SCSI_IO failed\n");
313                 failed(op->child);
314         }
315         if (!check_sense(sc, op->status)) {
316                 printf("[%d] READ10 \"%s\" failed (0x%02x) - expected %s\n", 
317                        op->child->line, op->fname, sc, op->status);
318                 failed(op->child);
319         }
320
321         op->child->bytes += xferlen*512;
322 }
323
324 static void scsi_write10(struct dbench_op *op)
325 {
326         struct scsi_device *sd=op->child->private;
327         unsigned char cdb[]={0x2a,0,0,0,0,0,0,0,0,0};
328         int res;
329         uint32_t lba = op->params[0];
330         uint32_t xferlen = op->params[1];
331         int rd = op->params[2];
332         int fua = op->params[3];
333         unsigned int data_size=1024*1024;
334         char data[data_size];
335         unsigned char sc;
336
337         if (!options.allow_scsi_writes) {
338                 printf("Ignoring SCSI write\n");
339                 return;
340         }
341
342         if (lba == 0xffffffff) {
343                 lba = random();
344                 lba = (lba / xferlen) * xferlen;
345         }
346
347         /* make sure we wrap properly instead of failing if the loadfile
348            is bigger than our device
349         */
350         if (sd->blocks <= lba) {
351                 lba = lba%sd->blocks;
352         }
353         if (sd->blocks <= lba+xferlen) {
354                 xferlen=1;
355         }
356
357         cdb[1] = rd;
358
359         cdb[2] = (lba>>24)&0xff;
360         cdb[3] = (lba>>16)&0xff;
361         cdb[4] = (lba>> 8)&0xff;
362         cdb[5] = (lba    )&0xff;
363
364         cdb[6] = fua;
365
366         cdb[7] = (xferlen>>8)&0xff;
367         cdb[8] = xferlen&0xff;
368         data_size = xferlen*512;
369
370         res=scsi_io(sd->fd, cdb, sizeof(cdb), SG_DXFER_TO_DEV, &data_size, data, &sc);
371         if(res){
372                 printf("SCSI_IO failed\n");
373                 failed(op->child);
374         }
375         if (!check_sense(sc, op->status)) {
376                 printf("[%d] READ10 \"%s\" failed (0x%02x) - expected %s\n", 
377                        op->child->line, op->fname, sc, op->status);
378                 failed(op->child);
379         }
380
381         op->child->bytes += xferlen*512;
382 }
383
384 static void scsi_readcapacity10(struct dbench_op *op)
385 {
386         struct scsi_device *sd;
387         unsigned char cdb[]={0x25,0,0,0,0,0,0,0,0,0};
388         int res;
389         int lba = op->params[0];
390         int pmi = op->params[1];
391         unsigned int data_size=8;
392         char data[data_size];
393         unsigned char sc;
394
395         cdb[2] = (lba>>24)&0xff;
396         cdb[3] = (lba>>16)&0xff;
397         cdb[4] = (lba>> 8)&0xff;
398         cdb[5] = (lba    )&0xff;
399
400         cdb[8] = (pmi?1:0);
401
402         sd = op->child->private;
403
404         res=scsi_io(sd->fd, cdb, sizeof(cdb), SG_DXFER_FROM_DEV, &data_size, data, &sc);
405         if(res){
406                 printf("SCSI_IO failed\n");
407                 failed(op->child);
408         }
409         if (!check_sense(sc, op->status)) {
410                 printf("[%d] READCAPACITY10 \"%s\" failed (0x%02x) - expected %s\n", 
411                        op->child->line, op->fname, sc, op->status);
412                 failed(op->child);
413         }
414 }
415
416 static struct backend_op ops[] = {
417         { "READ6",            scsi_read6 },
418         { "READ10",           scsi_read10 },
419         { "READCAPACITY10",   scsi_readcapacity10 },
420         { "TESTUNITREADY",    scsi_testunitready },
421         { "WRITE10",          scsi_write10 },
422         { NULL, NULL}
423 };
424
425 struct nb_operations scsi_ops = {
426         .backend_name = "scsibench",
427         .setup        = scsi_setup,
428         .cleanup      = scsi_cleanup,
429         .ops          = ops
430 };
431
432 #endif /* HAVE_LINUX_SCSI_SG */