fix a debug statement to print also the directory name (and not
[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
30 #define SCSI_TIMEOUT 5000 /* ms */
31
32 #define discard_const(ptr) ((void *)((intptr_t)(ptr)))
33
34 struct scsi_device {
35        int fd;
36 };
37
38 static void scsi_setup(struct child_struct *child)
39 {
40         int vers;
41         struct scsi_device *sd;
42
43         sd = malloc(sizeof(struct scsi_device));
44         if (sd == NULL) {
45                 printf("Failed to allocate scsi device structure\n");
46                         exit(10);
47         }
48         child->private=sd;
49         if((sd->fd=open(options.scsi_dev, O_RDWR))<0){
50                 printf("Failed to open scsi device node : %s\n", options.scsi_dev);
51                 free(sd);
52                 exit(10);
53         }
54         if ((ioctl(sd->fd, SG_GET_VERSION_NUM, &vers) < 0) || (vers < 30000)) {
55                 printf("%s is not a SCSI device node\n", options.scsi_dev);
56                 close(sd->fd);
57                 free(sd);
58                 exit(10);
59         }
60 }
61
62 static void scsi_cleanup(struct child_struct *child)
63 {
64         struct scsi_device *sd;
65
66         sd=child->private;
67         close(sd->fd);
68         sd->fd=-1;
69         free(sd);
70 }
71
72
73 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)
74 {
75         sg_io_hdr_t io_hdr;
76         unsigned int sense_len=32;
77         unsigned char sense[sense_len];
78
79         *sc = 0;
80
81         memset(&io_hdr, 0, sizeof(sg_io_hdr_t));
82         io_hdr.interface_id = 'S';
83
84         /* CDB */
85         io_hdr.cmdp = cdb;
86         io_hdr.cmd_len = cdb_size;
87
88         /* Where to store the sense_data, if there was an error */
89         io_hdr.sbp = sense;
90         io_hdr.mx_sb_len = sense_len;
91         sense_len=0;
92
93         /* Transfer direction, either in or out. Linux does not yet
94            support bidirectional SCSI transfers ?
95          */
96         io_hdr.dxfer_direction = xfer_dir;
97
98         /* Where to store the DATA IN/OUT from the device and how big the
99            buffer is
100          */
101         io_hdr.dxferp = data;
102         io_hdr.dxfer_len = *data_size;
103
104         /* SCSI timeout in ms */
105         io_hdr.timeout = SCSI_TIMEOUT;
106
107
108         if(ioctl(fd, SG_IO, &io_hdr) < 0){
109                 perror("SG_IO ioctl failed");
110                 return -1;
111         }
112
113         /* now for the error processing */
114         if((io_hdr.info & SG_INFO_OK_MASK) != SG_INFO_OK){
115                 if(io_hdr.sb_len_wr > 0){
116                         sense_len=io_hdr.sb_len_wr;
117                         *sc=sense[2]&0x0f;
118                         return 0;
119                 }
120         }
121         if(io_hdr.masked_status){
122                 printf("SCSI status=0x%x\n", io_hdr.status);
123                 printf("SCSI masked_status=0x%x\n", io_hdr.masked_status);
124                 return -2;
125         }
126         if(io_hdr.host_status){
127                 printf("SCSI host_status=0x%x\n", io_hdr.host_status);
128                 return -3;
129         }
130         if(io_hdr.driver_status){
131                 printf("driver_status=0x%x\n", io_hdr.driver_status);
132                 return -4;
133         }
134
135         return 0;
136 }
137
138
139 static int check_sense(unsigned char sc, const char *expected)
140 {
141         if (strcmp(expected, "*") == 0){
142                 return 1;
143         }
144         if (strncmp(expected, "0x", 2) == 0) {
145                 return sc == strtol(expected, NULL, 16);
146         }
147         return 0;
148 }
149
150 static void failed(struct child_struct *child)
151 {
152         child->failed = 1;
153         printf("ERROR: child %d failed at line %d\n", child->id, child->line);
154         exit(1);
155 }
156
157 static void scsi_testunitready(struct dbench_op *op)
158 {
159         struct scsi_device *sd;
160         unsigned char cdb[]={0,0,0,0,0,0};
161         int res;
162         unsigned char sc;
163         unsigned int data_size=200;
164         char data[data_size];
165
166         sd = op->child->private;
167
168         res=scsi_io(sd->fd, cdb, sizeof(cdb), SG_DXFER_FROM_DEV, &data_size, data, &sc);
169         if(res){
170                 printf("SCSI_IO failed\n");
171                 failed(op->child);
172         }
173         if (!check_sense(sc, op->status)) {
174                 printf("[%d] TESTUNITREADY \"%s\" failed (0x%02x) - expected %s\n", 
175                        op->child->line, op->fname, sc, op->status);
176                 failed(op->child);
177         }
178
179         return;
180 }
181
182
183 static void scsi_read6(struct dbench_op *op)
184 {
185         struct scsi_device *sd;
186         unsigned char cdb[]={0x08,0,0,0,0,0};
187         int res;
188         int lba = op->params[0];
189         int xferlen = op->params[1];
190         unsigned int data_size=1024*1024;
191         char data[data_size];
192         unsigned char sc;
193
194         cdb[1] = (lba>>16)&0x1f;
195         cdb[2] = (lba>> 8)&0xff;
196         cdb[3] = (lba    )&0xff;
197
198         cdb[4] = xferlen&0xff;
199         data_size = xferlen*512;
200
201         sd = op->child->private;
202
203         res=scsi_io(sd->fd, cdb, sizeof(cdb), SG_DXFER_FROM_DEV, &data_size, data, &sc);
204         if(res){
205                 printf("SCSI_IO failed\n");
206                 failed(op->child);
207         }
208         if (!check_sense(sc, op->status)) {
209                 printf("[%d] READ6 \"%s\" failed (0x%02x) - expected %s\n", 
210                        op->child->line, op->fname, sc, op->status);
211                 failed(op->child);
212         }
213
214         op->child->bytes += xferlen*512;
215 }
216
217 static void scsi_read10(struct dbench_op *op)
218 {
219         struct scsi_device *sd;
220         unsigned char cdb[]={0x28,0,0,0,0,0,0,0,0,0};
221         int res;
222         int lba = op->params[0];
223         int xferlen = op->params[1];
224         int rd = op->params[2];
225         int grp = op->params[3];
226         unsigned int data_size=1024*1024;
227         char data[data_size];
228         unsigned char sc;
229
230         cdb[1] = rd;
231
232         cdb[2] = (lba>>24)&0xff;
233         cdb[3] = (lba>>16)&0xff;
234         cdb[4] = (lba>> 8)&0xff;
235         cdb[5] = (lba    )&0xff;
236
237         cdb[6] = grp&0x1f;
238
239         cdb[7] = (xferlen>>8)&0xff;
240         cdb[8] = xferlen&0xff;
241         data_size = xferlen*512;
242
243         sd = op->child->private;
244
245         res=scsi_io(sd->fd, cdb, sizeof(cdb), SG_DXFER_FROM_DEV, &data_size, data, &sc);
246         if(res){
247                 printf("SCSI_IO failed\n");
248                 failed(op->child);
249         }
250         if (!check_sense(sc, op->status)) {
251                 printf("[%d] READ10 \"%s\" failed (0x%02x) - expected %s\n", 
252                        op->child->line, op->fname, sc, op->status);
253                 failed(op->child);
254         }
255
256         op->child->bytes += xferlen*512;
257 }
258
259 static void scsi_readcapacity10(struct dbench_op *op)
260 {
261         struct scsi_device *sd;
262         unsigned char cdb[]={0x25,0,0,0,0,0,0,0,0,0};
263         int res;
264         int lba = op->params[0];
265         int pmi = op->params[1];
266         unsigned int data_size=8;
267         char data[data_size];
268         unsigned char sc;
269
270         cdb[2] = (lba>>24)&0xff;
271         cdb[3] = (lba>>16)&0xff;
272         cdb[4] = (lba>> 8)&0xff;
273         cdb[5] = (lba    )&0xff;
274
275         cdb[8] = (pmi?1:0);
276
277         sd = op->child->private;
278
279         res=scsi_io(sd->fd, cdb, sizeof(cdb), SG_DXFER_FROM_DEV, &data_size, data, &sc);
280         if(res){
281                 printf("SCSI_IO failed\n");
282                 failed(op->child);
283         }
284         if (!check_sense(sc, op->status)) {
285                 printf("[%d] READCAPACITY10 \"%s\" failed (0x%02x) - expected %s\n", 
286                        op->child->line, op->fname, sc, op->status);
287                 failed(op->child);
288         }
289 }
290
291 static struct backend_op ops[] = {
292         { "READ6",            scsi_read6 },
293         { "READ10",           scsi_read10 },
294         { "READCAPACITY10",   scsi_readcapacity10 },
295         { "TESTUNITREADY",    scsi_testunitready },
296         { NULL, NULL}
297 };
298
299 struct nb_operations scsi_ops = {
300         .backend_name = "scsibench",
301         .setup        = scsi_setup,
302         .cleanup      = scsi_cleanup,
303         .ops          = ops
304 };
305
306 #endif /* HAVE_LINUX_SCSI_SG */