Eric Lee / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit ac6b91b8035bd269a1fd42474f907d107c074805

Authored by FUJITA Tomonori
Committed by Jens Axboe
1 parent 3d6392cfbd

block: changes for blk_rq_unmap_user new API 

This converts block/scsi_ioctl.c use blk_rq_unmap_user new
API. blk_unmap_sghdr_rq is too simple and it might be better to remove
it.

Signed-off-by: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>

Showing 1 changed file with 1 additions and 12 deletions Inline Diff

1 /* 1 /*
2 * Copyright (C) 2001 Jens Axboe <axboe@suse.de> 2 * Copyright (C) 2001 Jens Axboe <axboe@suse.de>
3 * 3 *
4 * This program is free software; you can redistribute it and/or modify 4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as 5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation. 6 * published by the Free Software Foundation.
7 * 7 *
8 * This program is distributed in the hope that it will be useful, 8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * 10 *
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details. 12 * GNU General Public License for more details.
13 * 13 *
14 * You should have received a copy of the GNU General Public Licens 14 * You should have received a copy of the GNU General Public Licens
15 * along with this program; if not, write to the Free Software 15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111- 16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-
17 * 17 *
18 */ 18 */
19 #include <linux/kernel.h> 19 #include <linux/kernel.h>
20 #include <linux/errno.h> 20 #include <linux/errno.h>
21 #include <linux/string.h> 21 #include <linux/string.h>
22 #include <linux/module.h> 22 #include <linux/module.h>
23 #include <linux/blkdev.h> 23 #include <linux/blkdev.h>
24 #include <linux/capability.h> 24 #include <linux/capability.h>
25 #include <linux/completion.h> 25 #include <linux/completion.h>
26 #include <linux/cdrom.h> 26 #include <linux/cdrom.h>
27 #include <linux/slab.h> 27 #include <linux/slab.h>
28 #include <linux/times.h> 28 #include <linux/times.h>
29 #include <asm/uaccess.h> 29 #include <asm/uaccess.h>
30 30
31 #include <scsi/scsi.h> 31 #include <scsi/scsi.h>
32 #include <scsi/scsi_ioctl.h> 32 #include <scsi/scsi_ioctl.h>
33 #include <scsi/scsi_cmnd.h> 33 #include <scsi/scsi_cmnd.h>
34 34
35 /* Command group 3 is reserved and should never be used. */ 35 /* Command group 3 is reserved and should never be used. */
36 const unsigned char scsi_command_size[8] = 36 const unsigned char scsi_command_size[8] =
37 { 37 {
38 6, 10, 10, 12, 38 6, 10, 10, 12,
39 16, 12, 10, 10 39 16, 12, 10, 10
40 }; 40 };
41 41
42 EXPORT_SYMBOL(scsi_command_size); 42 EXPORT_SYMBOL(scsi_command_size);
43 43
44 #include <scsi/sg.h> 44 #include <scsi/sg.h>
45 45
46 static int sg_get_version(int __user *p) 46 static int sg_get_version(int __user *p)
47 { 47 {
48 static const int sg_version_num = 30527; 48 static const int sg_version_num = 30527;
49 return put_user(sg_version_num, p); 49 return put_user(sg_version_num, p);
50 } 50 }
51 51
52 static int scsi_get_idlun(request_queue_t *q, int __user *p) 52 static int scsi_get_idlun(request_queue_t *q, int __user *p)
53 { 53 {
54 return put_user(0, p); 54 return put_user(0, p);
55 } 55 }
56 56
57 static int scsi_get_bus(request_queue_t *q, int __user *p) 57 static int scsi_get_bus(request_queue_t *q, int __user *p)
58 { 58 {
59 return put_user(0, p); 59 return put_user(0, p);
60 } 60 }
61 61
62 static int sg_get_timeout(request_queue_t *q) 62 static int sg_get_timeout(request_queue_t *q)
63 { 63 {
64 return q->sg_timeout / (HZ / USER_HZ); 64 return q->sg_timeout / (HZ / USER_HZ);
65 } 65 }
66 66
67 static int sg_set_timeout(request_queue_t *q, int __user *p) 67 static int sg_set_timeout(request_queue_t *q, int __user *p)
68 { 68 {
69 int timeout, err = get_user(timeout, p); 69 int timeout, err = get_user(timeout, p);
70 70
71 if (!err) 71 if (!err)
72 q->sg_timeout = timeout * (HZ / USER_HZ); 72 q->sg_timeout = timeout * (HZ / USER_HZ);
73 73
74 return err; 74 return err;
75 } 75 }
76 76
77 static int sg_get_reserved_size(request_queue_t *q, int __user *p) 77 static int sg_get_reserved_size(request_queue_t *q, int __user *p)
78 { 78 {
79 unsigned val = min(q->sg_reserved_size, q->max_sectors << 9); 79 unsigned val = min(q->sg_reserved_size, q->max_sectors << 9);
80 80
81 return put_user(val, p); 81 return put_user(val, p);
82 } 82 }
83 83
84 static int sg_set_reserved_size(request_queue_t *q, int __user *p) 84 static int sg_set_reserved_size(request_queue_t *q, int __user *p)
85 { 85 {
86 int size, err = get_user(size, p); 86 int size, err = get_user(size, p);
87 87
88 if (err) 88 if (err)
89 return err; 89 return err;
90 90
91 if (size < 0) 91 if (size < 0)
92 return -EINVAL; 92 return -EINVAL;
93 if (size > (q->max_sectors << 9)) 93 if (size > (q->max_sectors << 9))
94 size = q->max_sectors << 9; 94 size = q->max_sectors << 9;
95 95
96 q->sg_reserved_size = size; 96 q->sg_reserved_size = size;
97 return 0; 97 return 0;
98 } 98 }
99 99
100 /* 100 /*
101 * will always return that we are ATAPI even for a real SCSI drive, I'm not 101 * will always return that we are ATAPI even for a real SCSI drive, I'm not
102 * so sure this is worth doing anything about (why would you care??) 102 * so sure this is worth doing anything about (why would you care??)
103 */ 103 */
104 static int sg_emulated_host(request_queue_t *q, int __user *p) 104 static int sg_emulated_host(request_queue_t *q, int __user *p)
105 { 105 {
106 return put_user(1, p); 106 return put_user(1, p);
107 } 107 }
108 108
109 #define CMD_READ_SAFE 0x01 109 #define CMD_READ_SAFE 0x01
110 #define CMD_WRITE_SAFE 0x02 110 #define CMD_WRITE_SAFE 0x02
111 #define CMD_WARNED 0x04 111 #define CMD_WARNED 0x04
112 #define safe_for_read(cmd) [cmd] = CMD_READ_SAFE 112 #define safe_for_read(cmd) [cmd] = CMD_READ_SAFE
113 #define safe_for_write(cmd) [cmd] = CMD_WRITE_SAFE 113 #define safe_for_write(cmd) [cmd] = CMD_WRITE_SAFE
114 114
115 static int verify_command(unsigned char *cmd, int has_write_perm) 115 static int verify_command(unsigned char *cmd, int has_write_perm)
116 { 116 {
117 static unsigned char cmd_type[256] = { 117 static unsigned char cmd_type[256] = {
118 118
119 /* Basic read-only commands */ 119 /* Basic read-only commands */
120 safe_for_read(TEST_UNIT_READY), 120 safe_for_read(TEST_UNIT_READY),
121 safe_for_read(REQUEST_SENSE), 121 safe_for_read(REQUEST_SENSE),
122 safe_for_read(READ_6), 122 safe_for_read(READ_6),
123 safe_for_read(READ_10), 123 safe_for_read(READ_10),
124 safe_for_read(READ_12), 124 safe_for_read(READ_12),
125 safe_for_read(READ_16), 125 safe_for_read(READ_16),
126 safe_for_read(READ_BUFFER), 126 safe_for_read(READ_BUFFER),
127 safe_for_read(READ_DEFECT_DATA), 127 safe_for_read(READ_DEFECT_DATA),
128 safe_for_read(READ_LONG), 128 safe_for_read(READ_LONG),
129 safe_for_read(INQUIRY), 129 safe_for_read(INQUIRY),
130 safe_for_read(MODE_SENSE), 130 safe_for_read(MODE_SENSE),
131 safe_for_read(MODE_SENSE_10), 131 safe_for_read(MODE_SENSE_10),
132 safe_for_read(LOG_SENSE), 132 safe_for_read(LOG_SENSE),
133 safe_for_read(START_STOP), 133 safe_for_read(START_STOP),
134 safe_for_read(GPCMD_VERIFY_10), 134 safe_for_read(GPCMD_VERIFY_10),
135 safe_for_read(VERIFY_16), 135 safe_for_read(VERIFY_16),
136 136
137 /* Audio CD commands */ 137 /* Audio CD commands */
138 safe_for_read(GPCMD_PLAY_CD), 138 safe_for_read(GPCMD_PLAY_CD),
139 safe_for_read(GPCMD_PLAY_AUDIO_10), 139 safe_for_read(GPCMD_PLAY_AUDIO_10),
140 safe_for_read(GPCMD_PLAY_AUDIO_MSF), 140 safe_for_read(GPCMD_PLAY_AUDIO_MSF),
141 safe_for_read(GPCMD_PLAY_AUDIO_TI), 141 safe_for_read(GPCMD_PLAY_AUDIO_TI),
142 safe_for_read(GPCMD_PAUSE_RESUME), 142 safe_for_read(GPCMD_PAUSE_RESUME),
143 143
144 /* CD/DVD data reading */ 144 /* CD/DVD data reading */
145 safe_for_read(GPCMD_READ_BUFFER_CAPACITY), 145 safe_for_read(GPCMD_READ_BUFFER_CAPACITY),
146 safe_for_read(GPCMD_READ_CD), 146 safe_for_read(GPCMD_READ_CD),
147 safe_for_read(GPCMD_READ_CD_MSF), 147 safe_for_read(GPCMD_READ_CD_MSF),
148 safe_for_read(GPCMD_READ_DISC_INFO), 148 safe_for_read(GPCMD_READ_DISC_INFO),
149 safe_for_read(GPCMD_READ_CDVD_CAPACITY), 149 safe_for_read(GPCMD_READ_CDVD_CAPACITY),
150 safe_for_read(GPCMD_READ_DVD_STRUCTURE), 150 safe_for_read(GPCMD_READ_DVD_STRUCTURE),
151 safe_for_read(GPCMD_READ_HEADER), 151 safe_for_read(GPCMD_READ_HEADER),
152 safe_for_read(GPCMD_READ_TRACK_RZONE_INFO), 152 safe_for_read(GPCMD_READ_TRACK_RZONE_INFO),
153 safe_for_read(GPCMD_READ_SUBCHANNEL), 153 safe_for_read(GPCMD_READ_SUBCHANNEL),
154 safe_for_read(GPCMD_READ_TOC_PMA_ATIP), 154 safe_for_read(GPCMD_READ_TOC_PMA_ATIP),
155 safe_for_read(GPCMD_REPORT_KEY), 155 safe_for_read(GPCMD_REPORT_KEY),
156 safe_for_read(GPCMD_SCAN), 156 safe_for_read(GPCMD_SCAN),
157 safe_for_read(GPCMD_GET_CONFIGURATION), 157 safe_for_read(GPCMD_GET_CONFIGURATION),
158 safe_for_read(GPCMD_READ_FORMAT_CAPACITIES), 158 safe_for_read(GPCMD_READ_FORMAT_CAPACITIES),
159 safe_for_read(GPCMD_GET_EVENT_STATUS_NOTIFICATION), 159 safe_for_read(GPCMD_GET_EVENT_STATUS_NOTIFICATION),
160 safe_for_read(GPCMD_GET_PERFORMANCE), 160 safe_for_read(GPCMD_GET_PERFORMANCE),
161 safe_for_read(GPCMD_SEEK), 161 safe_for_read(GPCMD_SEEK),
162 safe_for_read(GPCMD_STOP_PLAY_SCAN), 162 safe_for_read(GPCMD_STOP_PLAY_SCAN),
163 163
164 /* Basic writing commands */ 164 /* Basic writing commands */
165 safe_for_write(WRITE_6), 165 safe_for_write(WRITE_6),
166 safe_for_write(WRITE_10), 166 safe_for_write(WRITE_10),
167 safe_for_write(WRITE_VERIFY), 167 safe_for_write(WRITE_VERIFY),
168 safe_for_write(WRITE_12), 168 safe_for_write(WRITE_12),
169 safe_for_write(WRITE_VERIFY_12), 169 safe_for_write(WRITE_VERIFY_12),
170 safe_for_write(WRITE_16), 170 safe_for_write(WRITE_16),
171 safe_for_write(WRITE_LONG), 171 safe_for_write(WRITE_LONG),
172 safe_for_write(WRITE_LONG_2), 172 safe_for_write(WRITE_LONG_2),
173 safe_for_write(ERASE), 173 safe_for_write(ERASE),
174 safe_for_write(GPCMD_MODE_SELECT_10), 174 safe_for_write(GPCMD_MODE_SELECT_10),
175 safe_for_write(MODE_SELECT), 175 safe_for_write(MODE_SELECT),
176 safe_for_write(LOG_SELECT), 176 safe_for_write(LOG_SELECT),
177 safe_for_write(GPCMD_BLANK), 177 safe_for_write(GPCMD_BLANK),
178 safe_for_write(GPCMD_CLOSE_TRACK), 178 safe_for_write(GPCMD_CLOSE_TRACK),
179 safe_for_write(GPCMD_FLUSH_CACHE), 179 safe_for_write(GPCMD_FLUSH_CACHE),
180 safe_for_write(GPCMD_FORMAT_UNIT), 180 safe_for_write(GPCMD_FORMAT_UNIT),
181 safe_for_write(GPCMD_REPAIR_RZONE_TRACK), 181 safe_for_write(GPCMD_REPAIR_RZONE_TRACK),
182 safe_for_write(GPCMD_RESERVE_RZONE_TRACK), 182 safe_for_write(GPCMD_RESERVE_RZONE_TRACK),
183 safe_for_write(GPCMD_SEND_DVD_STRUCTURE), 183 safe_for_write(GPCMD_SEND_DVD_STRUCTURE),
184 safe_for_write(GPCMD_SEND_EVENT), 184 safe_for_write(GPCMD_SEND_EVENT),
185 safe_for_write(GPCMD_SEND_KEY), 185 safe_for_write(GPCMD_SEND_KEY),
186 safe_for_write(GPCMD_SEND_OPC), 186 safe_for_write(GPCMD_SEND_OPC),
187 safe_for_write(GPCMD_SEND_CUE_SHEET), 187 safe_for_write(GPCMD_SEND_CUE_SHEET),
188 safe_for_write(GPCMD_SET_SPEED), 188 safe_for_write(GPCMD_SET_SPEED),
189 safe_for_write(GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL), 189 safe_for_write(GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL),
190 safe_for_write(GPCMD_LOAD_UNLOAD), 190 safe_for_write(GPCMD_LOAD_UNLOAD),
191 safe_for_write(GPCMD_SET_STREAMING), 191 safe_for_write(GPCMD_SET_STREAMING),
192 }; 192 };
193 unsigned char type = cmd_type[cmd[0]]; 193 unsigned char type = cmd_type[cmd[0]];
194 194
195 /* Anybody who can open the device can do a read-safe command */ 195 /* Anybody who can open the device can do a read-safe command */
196 if (type & CMD_READ_SAFE) 196 if (type & CMD_READ_SAFE)
197 return 0; 197 return 0;
198 198
199 /* Write-safe commands just require a writable open.. */ 199 /* Write-safe commands just require a writable open.. */
200 if ((type & CMD_WRITE_SAFE) && has_write_perm) 200 if ((type & CMD_WRITE_SAFE) && has_write_perm)
201 return 0; 201 return 0;
202 202
203 /* And root can do any command.. */ 203 /* And root can do any command.. */
204 if (capable(CAP_SYS_RAWIO)) 204 if (capable(CAP_SYS_RAWIO))
205 return 0; 205 return 0;
206 206
207 if (!type) { 207 if (!type) {
208 cmd_type[cmd[0]] = CMD_WARNED; 208 cmd_type[cmd[0]] = CMD_WARNED;
209 printk(KERN_WARNING "scsi: unknown opcode 0x%02x\n", cmd[0]); 209 printk(KERN_WARNING "scsi: unknown opcode 0x%02x\n", cmd[0]);
210 } 210 }
211 211
212 /* Otherwise fail it with an "Operation not permitted" */ 212 /* Otherwise fail it with an "Operation not permitted" */
213 return -EPERM; 213 return -EPERM;
214 } 214 }
215 215
216 int blk_fill_sghdr_rq(request_queue_t *q, struct request *rq, 216 int blk_fill_sghdr_rq(request_queue_t *q, struct request *rq,
217 struct sg_io_hdr *hdr, int has_write_perm) 217 struct sg_io_hdr *hdr, int has_write_perm)
218 { 218 {
219 memset(rq->cmd, 0, BLK_MAX_CDB); /* ATAPI hates garbage after CDB */ 219 memset(rq->cmd, 0, BLK_MAX_CDB); /* ATAPI hates garbage after CDB */
220 220
221 if (copy_from_user(rq->cmd, hdr->cmdp, hdr->cmd_len)) 221 if (copy_from_user(rq->cmd, hdr->cmdp, hdr->cmd_len))
222 return -EFAULT; 222 return -EFAULT;
223 if (verify_command(rq->cmd, has_write_perm)) 223 if (verify_command(rq->cmd, has_write_perm))
224 return -EPERM; 224 return -EPERM;
225 225
226 /* 226 /*
227 * fill in request structure 227 * fill in request structure
228 */ 228 */
229 rq->cmd_len = hdr->cmd_len; 229 rq->cmd_len = hdr->cmd_len;
230 rq->cmd_type = REQ_TYPE_BLOCK_PC; 230 rq->cmd_type = REQ_TYPE_BLOCK_PC;
231 231
232 rq->timeout = (hdr->timeout * HZ) / 1000; 232 rq->timeout = (hdr->timeout * HZ) / 1000;
233 if (!rq->timeout) 233 if (!rq->timeout)
234 rq->timeout = q->sg_timeout; 234 rq->timeout = q->sg_timeout;
235 if (!rq->timeout) 235 if (!rq->timeout)
236 rq->timeout = BLK_DEFAULT_SG_TIMEOUT; 236 rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
237 237
238 return 0; 238 return 0;
239 } 239 }
240 EXPORT_SYMBOL_GPL(blk_fill_sghdr_rq); 240 EXPORT_SYMBOL_GPL(blk_fill_sghdr_rq);
241 241
242 /* 242 /*
243 * unmap a request that was previously mapped to this sg_io_hdr. handles 243 * unmap a request that was previously mapped to this sg_io_hdr. handles
244 * both sg and non-sg sg_io_hdr. 244 * both sg and non-sg sg_io_hdr.
245 */ 245 */
246 int blk_unmap_sghdr_rq(struct request *rq, struct sg_io_hdr *hdr) 246 int blk_unmap_sghdr_rq(struct request *rq, struct sg_io_hdr *hdr)
247 { 247 {
248 struct bio *bio = rq->bio; 248 blk_rq_unmap_user(rq->bio);
249
250 /*
251 * also releases request
252 */
253 if (!hdr->iovec_count)
254 return blk_rq_unmap_user(bio, hdr->dxfer_len);
255
256 rq_for_each_bio(bio, rq)
257 bio_unmap_user(bio);
258
259 blk_put_request(rq); 249 blk_put_request(rq);
260 return 0; 250 return 0;
261 } 251 }
262 EXPORT_SYMBOL_GPL(blk_unmap_sghdr_rq); 252 EXPORT_SYMBOL_GPL(blk_unmap_sghdr_rq);
263 253
264 int blk_complete_sghdr_rq(struct request *rq, struct sg_io_hdr *hdr, 254 int blk_complete_sghdr_rq(struct request *rq, struct sg_io_hdr *hdr,
265 struct bio *bio) 255 struct bio *bio)
266 { 256 {
267 int r, ret = 0; 257 int r, ret = 0;
268 258
269 /* 259 /*
270 * fill in all the output members 260 * fill in all the output members
271 */ 261 */
272 hdr->status = rq->errors & 0xff; 262 hdr->status = rq->errors & 0xff;
273 hdr->masked_status = status_byte(rq->errors); 263 hdr->masked_status = status_byte(rq->errors);
274 hdr->msg_status = msg_byte(rq->errors); 264 hdr->msg_status = msg_byte(rq->errors);
275 hdr->host_status = host_byte(rq->errors); 265 hdr->host_status = host_byte(rq->errors);
276 hdr->driver_status = driver_byte(rq->errors); 266 hdr->driver_status = driver_byte(rq->errors);
277 hdr->info = 0; 267 hdr->info = 0;
278 if (hdr->masked_status || hdr->host_status || hdr->driver_status) 268 if (hdr->masked_status || hdr->host_status || hdr->driver_status)
279 hdr->info |= SG_INFO_CHECK; 269 hdr->info |= SG_INFO_CHECK;
280 hdr->resid = rq->data_len; 270 hdr->resid = rq->data_len;
281 hdr->sb_len_wr = 0; 271 hdr->sb_len_wr = 0;
282 272
283 if (rq->sense_len && hdr->sbp) { 273 if (rq->sense_len && hdr->sbp) {
284 int len = min((unsigned int) hdr->mx_sb_len, rq->sense_len); 274 int len = min((unsigned int) hdr->mx_sb_len, rq->sense_len);
285 275
286 if (!copy_to_user(hdr->sbp, rq->sense, len)) 276 if (!copy_to_user(hdr->sbp, rq->sense, len))
287 hdr->sb_len_wr = len; 277 hdr->sb_len_wr = len;
288 else 278 else
289 ret = -EFAULT; 279 ret = -EFAULT;
290 } 280 }
291 281
292 rq->bio = bio; 282 rq->bio = bio;
293 r = blk_unmap_sghdr_rq(rq, hdr); 283 r = blk_unmap_sghdr_rq(rq, hdr);
294 if (ret) 284 if (ret)
295 r = ret; 285 r = ret;
296 286
297 return r; 287 return r;
298 } 288 }
299 EXPORT_SYMBOL_GPL(blk_complete_sghdr_rq); 289 EXPORT_SYMBOL_GPL(blk_complete_sghdr_rq);
300 290
301 static int sg_io(struct file *file, request_queue_t *q, 291 static int sg_io(struct file *file, request_queue_t *q,
302 struct gendisk *bd_disk, struct sg_io_hdr *hdr) 292 struct gendisk *bd_disk, struct sg_io_hdr *hdr)
303 { 293 {
304 unsigned long start_time; 294 unsigned long start_time;
305 int writing = 0, ret = 0, has_write_perm = 0; 295 int writing = 0, ret = 0, has_write_perm = 0;
306 struct request *rq; 296 struct request *rq;
307 char sense[SCSI_SENSE_BUFFERSIZE]; 297 char sense[SCSI_SENSE_BUFFERSIZE];
308 struct bio *bio; 298 struct bio *bio;
309 299
310 if (hdr->interface_id != 'S') 300 if (hdr->interface_id != 'S')
311 return -EINVAL; 301 return -EINVAL;
312 if (hdr->cmd_len > BLK_MAX_CDB) 302 if (hdr->cmd_len > BLK_MAX_CDB)
313 return -EINVAL; 303 return -EINVAL;
314 304
315 if (hdr->dxfer_len > (q->max_hw_sectors << 9)) 305 if (hdr->dxfer_len > (q->max_hw_sectors << 9))
316 return -EIO; 306 return -EIO;
317 307
318 if (hdr->dxfer_len) 308 if (hdr->dxfer_len)
319 switch (hdr->dxfer_direction) { 309 switch (hdr->dxfer_direction) {
320 default: 310 default:
321 return -EINVAL; 311 return -EINVAL;
322 case SG_DXFER_TO_DEV: 312 case SG_DXFER_TO_DEV:
323 writing = 1; 313 writing = 1;
324 break; 314 break;
325 case SG_DXFER_TO_FROM_DEV: 315 case SG_DXFER_TO_FROM_DEV:
326 case SG_DXFER_FROM_DEV: 316 case SG_DXFER_FROM_DEV:
327 break; 317 break;
328 } 318 }
329 319
330 rq = blk_get_request(q, writing ? WRITE : READ, GFP_KERNEL); 320 rq = blk_get_request(q, writing ? WRITE : READ, GFP_KERNEL);
331 if (!rq) 321 if (!rq)
332 return -ENOMEM; 322 return -ENOMEM;
333 323
334 if (file) 324 if (file)
335 has_write_perm = file->f_mode & FMODE_WRITE; 325 has_write_perm = file->f_mode & FMODE_WRITE;
336 326
337 if (blk_fill_sghdr_rq(q, rq, hdr, has_write_perm)) { 327 if (blk_fill_sghdr_rq(q, rq, hdr, has_write_perm)) {
338 blk_rq_unmap_user(bio, hdr->dxfer_len);
339 blk_put_request(rq); 328 blk_put_request(rq);
340 return -EFAULT; 329 return -EFAULT;
341 } 330 }
342 331
343 if (hdr->iovec_count) { 332 if (hdr->iovec_count) {
344 const int size = sizeof(struct sg_iovec) * hdr->iovec_count; 333 const int size = sizeof(struct sg_iovec) * hdr->iovec_count;
345 struct sg_iovec *iov; 334 struct sg_iovec *iov;
346 335
347 iov = kmalloc(size, GFP_KERNEL); 336 iov = kmalloc(size, GFP_KERNEL);
348 if (!iov) { 337 if (!iov) {
349 ret = -ENOMEM; 338 ret = -ENOMEM;
350 goto out; 339 goto out;
351 } 340 }
352 341
353 if (copy_from_user(iov, hdr->dxferp, size)) { 342 if (copy_from_user(iov, hdr->dxferp, size)) {
354 kfree(iov); 343 kfree(iov);
355 ret = -EFAULT; 344 ret = -EFAULT;
356 goto out; 345 goto out;
357 } 346 }
358 347
359 ret = blk_rq_map_user_iov(q, rq, iov, hdr->iovec_count, 348 ret = blk_rq_map_user_iov(q, rq, iov, hdr->iovec_count,
360 hdr->dxfer_len); 349 hdr->dxfer_len);
361 kfree(iov); 350 kfree(iov);
362 } else if (hdr->dxfer_len) 351 } else if (hdr->dxfer_len)
363 ret = blk_rq_map_user(q, rq, hdr->dxferp, hdr->dxfer_len); 352 ret = blk_rq_map_user(q, rq, hdr->dxferp, hdr->dxfer_len);
364 353
365 if (ret) 354 if (ret)
366 goto out; 355 goto out;
367 356
368 bio = rq->bio; 357 bio = rq->bio;
369 memset(sense, 0, sizeof(sense)); 358 memset(sense, 0, sizeof(sense));
370 rq->sense = sense; 359 rq->sense = sense;
371 rq->sense_len = 0; 360 rq->sense_len = 0;
372 rq->retries = 0; 361 rq->retries = 0;
373 362
374 start_time = jiffies; 363 start_time = jiffies;
375 364
376 /* ignore return value. All information is passed back to caller 365 /* ignore return value. All information is passed back to caller
377 * (if he doesn't check that is his problem). 366 * (if he doesn't check that is his problem).
378 * N.B. a non-zero SCSI status is _not_ necessarily an error. 367 * N.B. a non-zero SCSI status is _not_ necessarily an error.
379 */ 368 */
380 blk_execute_rq(q, bd_disk, rq, 0); 369 blk_execute_rq(q, bd_disk, rq, 0);
381 370
382 hdr->duration = ((jiffies - start_time) * 1000) / HZ; 371 hdr->duration = ((jiffies - start_time) * 1000) / HZ;
383 372
384 return blk_complete_sghdr_rq(rq, hdr, bio); 373 return blk_complete_sghdr_rq(rq, hdr, bio);
385 out: 374 out:
386 blk_put_request(rq); 375 blk_put_request(rq);
387 return ret; 376 return ret;
388 } 377 }
389 378
390 /** 379 /**
391 * sg_scsi_ioctl -- handle deprecated SCSI_IOCTL_SEND_COMMAND ioctl 380 * sg_scsi_ioctl -- handle deprecated SCSI_IOCTL_SEND_COMMAND ioctl
392 * @file: file this ioctl operates on (optional) 381 * @file: file this ioctl operates on (optional)
393 * @q: request queue to send scsi commands down 382 * @q: request queue to send scsi commands down
394 * @disk: gendisk to operate on (option) 383 * @disk: gendisk to operate on (option)
395 * @sic: userspace structure describing the command to perform 384 * @sic: userspace structure describing the command to perform
396 * 385 *
397 * Send down the scsi command described by @sic to the device below 386 * Send down the scsi command described by @sic to the device below
398 * the request queue @q. If @file is non-NULL it's used to perform 387 * the request queue @q. If @file is non-NULL it's used to perform
399 * fine-grained permission checks that allow users to send down 388 * fine-grained permission checks that allow users to send down
400 * non-destructive SCSI commands. If the caller has a struct gendisk 389 * non-destructive SCSI commands. If the caller has a struct gendisk
401 * available it should be passed in as @disk to allow the low level 390 * available it should be passed in as @disk to allow the low level
402 * driver to use the information contained in it. A non-NULL @disk 391 * driver to use the information contained in it. A non-NULL @disk
403 * is only allowed if the caller knows that the low level driver doesn't 392 * is only allowed if the caller knows that the low level driver doesn't
404 * need it (e.g. in the scsi subsystem). 393 * need it (e.g. in the scsi subsystem).
405 * 394 *
406 * Notes: 395 * Notes:
407 * - This interface is deprecated - users should use the SG_IO 396 * - This interface is deprecated - users should use the SG_IO
408 * interface instead, as this is a more flexible approach to 397 * interface instead, as this is a more flexible approach to
409 * performing SCSI commands on a device. 398 * performing SCSI commands on a device.
410 * - The SCSI command length is determined by examining the 1st byte 399 * - The SCSI command length is determined by examining the 1st byte
411 * of the given command. There is no way to override this. 400 * of the given command. There is no way to override this.
412 * - Data transfers are limited to PAGE_SIZE 401 * - Data transfers are limited to PAGE_SIZE
413 * - The length (x + y) must be at least OMAX_SB_LEN bytes long to 402 * - The length (x + y) must be at least OMAX_SB_LEN bytes long to
414 * accommodate the sense buffer when an error occurs. 403 * accommodate the sense buffer when an error occurs.
415 * The sense buffer is truncated to OMAX_SB_LEN (16) bytes so that 404 * The sense buffer is truncated to OMAX_SB_LEN (16) bytes so that
416 * old code will not be surprised. 405 * old code will not be surprised.
417 * - If a Unix error occurs (e.g. ENOMEM) then the user will receive 406 * - If a Unix error occurs (e.g. ENOMEM) then the user will receive
418 * a negative return and the Unix error code in 'errno'. 407 * a negative return and the Unix error code in 'errno'.
419 * If the SCSI command succeeds then 0 is returned. 408 * If the SCSI command succeeds then 0 is returned.
420 * Positive numbers returned are the compacted SCSI error codes (4 409 * Positive numbers returned are the compacted SCSI error codes (4
421 * bytes in one int) where the lowest byte is the SCSI status. 410 * bytes in one int) where the lowest byte is the SCSI status.
422 */ 411 */
423 #define OMAX_SB_LEN 16 /* For backward compatibility */ 412 #define OMAX_SB_LEN 16 /* For backward compatibility */
424 int sg_scsi_ioctl(struct file *file, struct request_queue *q, 413 int sg_scsi_ioctl(struct file *file, struct request_queue *q,
425 struct gendisk *disk, struct scsi_ioctl_command __user *sic) 414 struct gendisk *disk, struct scsi_ioctl_command __user *sic)
426 { 415 {
427 struct request *rq; 416 struct request *rq;
428 int err; 417 int err;
429 unsigned int in_len, out_len, bytes, opcode, cmdlen; 418 unsigned int in_len, out_len, bytes, opcode, cmdlen;
430 char *buffer = NULL, sense[SCSI_SENSE_BUFFERSIZE]; 419 char *buffer = NULL, sense[SCSI_SENSE_BUFFERSIZE];
431 420
432 if (!sic) 421 if (!sic)
433 return -EINVAL; 422 return -EINVAL;
434 423
435 /* 424 /*
436 * get in an out lengths, verify they don't exceed a page worth of data 425 * get in an out lengths, verify they don't exceed a page worth of data
437 */ 426 */
438 if (get_user(in_len, &sic->inlen)) 427 if (get_user(in_len, &sic->inlen))
439 return -EFAULT; 428 return -EFAULT;
440 if (get_user(out_len, &sic->outlen)) 429 if (get_user(out_len, &sic->outlen))
441 return -EFAULT; 430 return -EFAULT;
442 if (in_len > PAGE_SIZE || out_len > PAGE_SIZE) 431 if (in_len > PAGE_SIZE || out_len > PAGE_SIZE)
443 return -EINVAL; 432 return -EINVAL;
444 if (get_user(opcode, sic->data)) 433 if (get_user(opcode, sic->data))
445 return -EFAULT; 434 return -EFAULT;
446 435
447 bytes = max(in_len, out_len); 436 bytes = max(in_len, out_len);
448 if (bytes) { 437 if (bytes) {
449 buffer = kmalloc(bytes, q->bounce_gfp | GFP_USER| __GFP_NOWARN); 438 buffer = kmalloc(bytes, q->bounce_gfp | GFP_USER| __GFP_NOWARN);
450 if (!buffer) 439 if (!buffer)
451 return -ENOMEM; 440 return -ENOMEM;
452 441
453 memset(buffer, 0, bytes); 442 memset(buffer, 0, bytes);
454 } 443 }
455 444
456 rq = blk_get_request(q, in_len ? WRITE : READ, __GFP_WAIT); 445 rq = blk_get_request(q, in_len ? WRITE : READ, __GFP_WAIT);
457 446
458 cmdlen = COMMAND_SIZE(opcode); 447 cmdlen = COMMAND_SIZE(opcode);
459 448
460 /* 449 /*
461 * get command and data to send to device, if any 450 * get command and data to send to device, if any
462 */ 451 */
463 err = -EFAULT; 452 err = -EFAULT;
464 rq->cmd_len = cmdlen; 453 rq->cmd_len = cmdlen;
465 if (copy_from_user(rq->cmd, sic->data, cmdlen)) 454 if (copy_from_user(rq->cmd, sic->data, cmdlen))
466 goto error; 455 goto error;
467 456
468 if (in_len && copy_from_user(buffer, sic->data + cmdlen, in_len)) 457 if (in_len && copy_from_user(buffer, sic->data + cmdlen, in_len))
469 goto error; 458 goto error;
470 459
471 err = verify_command(rq->cmd, file->f_mode & FMODE_WRITE); 460 err = verify_command(rq->cmd, file->f_mode & FMODE_WRITE);
472 if (err) 461 if (err)
473 goto error; 462 goto error;
474 463
475 /* default. possible overriden later */ 464 /* default. possible overriden later */
476 rq->retries = 5; 465 rq->retries = 5;
477 466
478 switch (opcode) { 467 switch (opcode) {
479 case SEND_DIAGNOSTIC: 468 case SEND_DIAGNOSTIC:
480 case FORMAT_UNIT: 469 case FORMAT_UNIT:
481 rq->timeout = FORMAT_UNIT_TIMEOUT; 470 rq->timeout = FORMAT_UNIT_TIMEOUT;
482 rq->retries = 1; 471 rq->retries = 1;
483 break; 472 break;
484 case START_STOP: 473 case START_STOP:
485 rq->timeout = START_STOP_TIMEOUT; 474 rq->timeout = START_STOP_TIMEOUT;
486 break; 475 break;
487 case MOVE_MEDIUM: 476 case MOVE_MEDIUM:
488 rq->timeout = MOVE_MEDIUM_TIMEOUT; 477 rq->timeout = MOVE_MEDIUM_TIMEOUT;
489 break; 478 break;
490 case READ_ELEMENT_STATUS: 479 case READ_ELEMENT_STATUS:
491 rq->timeout = READ_ELEMENT_STATUS_TIMEOUT; 480 rq->timeout = READ_ELEMENT_STATUS_TIMEOUT;
492 break; 481 break;
493 case READ_DEFECT_DATA: 482 case READ_DEFECT_DATA:
494 rq->timeout = READ_DEFECT_DATA_TIMEOUT; 483 rq->timeout = READ_DEFECT_DATA_TIMEOUT;
495 rq->retries = 1; 484 rq->retries = 1;
496 break; 485 break;
497 default: 486 default:
498 rq->timeout = BLK_DEFAULT_SG_TIMEOUT; 487 rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
499 break; 488 break;
500 } 489 }
501 490
502 if (bytes && blk_rq_map_kern(q, rq, buffer, bytes, __GFP_WAIT)) { 491 if (bytes && blk_rq_map_kern(q, rq, buffer, bytes, __GFP_WAIT)) {
503 err = DRIVER_ERROR << 24; 492 err = DRIVER_ERROR << 24;
504 goto out; 493 goto out;
505 } 494 }
506 495
507 memset(sense, 0, sizeof(sense)); 496 memset(sense, 0, sizeof(sense));
508 rq->sense = sense; 497 rq->sense = sense;
509 rq->sense_len = 0; 498 rq->sense_len = 0;
510 rq->cmd_type = REQ_TYPE_BLOCK_PC; 499 rq->cmd_type = REQ_TYPE_BLOCK_PC;
511 500
512 blk_execute_rq(q, disk, rq, 0); 501 blk_execute_rq(q, disk, rq, 0);
513 502
514 out: 503 out:
515 err = rq->errors & 0xff; /* only 8 bit SCSI status */ 504 err = rq->errors & 0xff; /* only 8 bit SCSI status */
516 if (err) { 505 if (err) {
517 if (rq->sense_len && rq->sense) { 506 if (rq->sense_len && rq->sense) {
518 bytes = (OMAX_SB_LEN > rq->sense_len) ? 507 bytes = (OMAX_SB_LEN > rq->sense_len) ?
519 rq->sense_len : OMAX_SB_LEN; 508 rq->sense_len : OMAX_SB_LEN;
520 if (copy_to_user(sic->data, rq->sense, bytes)) 509 if (copy_to_user(sic->data, rq->sense, bytes))
521 err = -EFAULT; 510 err = -EFAULT;
522 } 511 }
523 } else { 512 } else {
524 if (copy_to_user(sic->data, buffer, out_len)) 513 if (copy_to_user(sic->data, buffer, out_len))
525 err = -EFAULT; 514 err = -EFAULT;
526 } 515 }
527 516
528 error: 517 error:
529 kfree(buffer); 518 kfree(buffer);
530 blk_put_request(rq); 519 blk_put_request(rq);
531 return err; 520 return err;
532 } 521 }
533 EXPORT_SYMBOL_GPL(sg_scsi_ioctl); 522 EXPORT_SYMBOL_GPL(sg_scsi_ioctl);
534 523
535 /* Send basic block requests */ 524 /* Send basic block requests */
536 static int __blk_send_generic(request_queue_t *q, struct gendisk *bd_disk, int cmd, int data) 525 static int __blk_send_generic(request_queue_t *q, struct gendisk *bd_disk, int cmd, int data)
537 { 526 {
538 struct request *rq; 527 struct request *rq;
539 int err; 528 int err;
540 529
541 rq = blk_get_request(q, WRITE, __GFP_WAIT); 530 rq = blk_get_request(q, WRITE, __GFP_WAIT);
542 rq->cmd_type = REQ_TYPE_BLOCK_PC; 531 rq->cmd_type = REQ_TYPE_BLOCK_PC;
543 rq->data = NULL; 532 rq->data = NULL;
544 rq->data_len = 0; 533 rq->data_len = 0;
545 rq->timeout = BLK_DEFAULT_SG_TIMEOUT; 534 rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
546 memset(rq->cmd, 0, sizeof(rq->cmd)); 535 memset(rq->cmd, 0, sizeof(rq->cmd));
547 rq->cmd[0] = cmd; 536 rq->cmd[0] = cmd;
548 rq->cmd[4] = data; 537 rq->cmd[4] = data;
549 rq->cmd_len = 6; 538 rq->cmd_len = 6;
550 err = blk_execute_rq(q, bd_disk, rq, 0); 539 err = blk_execute_rq(q, bd_disk, rq, 0);
551 blk_put_request(rq); 540 blk_put_request(rq);
552 541
553 return err; 542 return err;
554 } 543 }
555 544
556 static inline int blk_send_start_stop(request_queue_t *q, struct gendisk *bd_disk, int data) 545 static inline int blk_send_start_stop(request_queue_t *q, struct gendisk *bd_disk, int data)
557 { 546 {
558 return __blk_send_generic(q, bd_disk, GPCMD_START_STOP_UNIT, data); 547 return __blk_send_generic(q, bd_disk, GPCMD_START_STOP_UNIT, data);
559 } 548 }
560 549
561 int scsi_cmd_ioctl(struct file *file, struct gendisk *bd_disk, unsigned int cmd, void __user *arg) 550 int scsi_cmd_ioctl(struct file *file, struct gendisk *bd_disk, unsigned int cmd, void __user *arg)
562 { 551 {
563 request_queue_t *q; 552 request_queue_t *q;
564 int err; 553 int err;
565 554
566 q = bd_disk->queue; 555 q = bd_disk->queue;
567 if (!q) 556 if (!q)
568 return -ENXIO; 557 return -ENXIO;
569 558
570 if (blk_get_queue(q)) 559 if (blk_get_queue(q))
571 return -ENXIO; 560 return -ENXIO;
572 561
573 switch (cmd) { 562 switch (cmd) {
574 /* 563 /*
575 * new sgv3 interface 564 * new sgv3 interface
576 */ 565 */
577 case SG_GET_VERSION_NUM: 566 case SG_GET_VERSION_NUM:
578 err = sg_get_version(arg); 567 err = sg_get_version(arg);
579 break; 568 break;
580 case SCSI_IOCTL_GET_IDLUN: 569 case SCSI_IOCTL_GET_IDLUN:
581 err = scsi_get_idlun(q, arg); 570 err = scsi_get_idlun(q, arg);
582 break; 571 break;
583 case SCSI_IOCTL_GET_BUS_NUMBER: 572 case SCSI_IOCTL_GET_BUS_NUMBER:
584 err = scsi_get_bus(q, arg); 573 err = scsi_get_bus(q, arg);
585 break; 574 break;
586 case SG_SET_TIMEOUT: 575 case SG_SET_TIMEOUT:
587 err = sg_set_timeout(q, arg); 576 err = sg_set_timeout(q, arg);
588 break; 577 break;
589 case SG_GET_TIMEOUT: 578 case SG_GET_TIMEOUT:
590 err = sg_get_timeout(q); 579 err = sg_get_timeout(q);
591 break; 580 break;
592 case SG_GET_RESERVED_SIZE: 581 case SG_GET_RESERVED_SIZE:
593 err = sg_get_reserved_size(q, arg); 582 err = sg_get_reserved_size(q, arg);
594 break; 583 break;
595 case SG_SET_RESERVED_SIZE: 584 case SG_SET_RESERVED_SIZE:
596 err = sg_set_reserved_size(q, arg); 585 err = sg_set_reserved_size(q, arg);
597 break; 586 break;
598 case SG_EMULATED_HOST: 587 case SG_EMULATED_HOST:
599 err = sg_emulated_host(q, arg); 588 err = sg_emulated_host(q, arg);
600 break; 589 break;
601 case SG_IO: { 590 case SG_IO: {
602 struct sg_io_hdr hdr; 591 struct sg_io_hdr hdr;
603 592
604 err = -EFAULT; 593 err = -EFAULT;
605 if (copy_from_user(&hdr, arg, sizeof(hdr))) 594 if (copy_from_user(&hdr, arg, sizeof(hdr)))
606 break; 595 break;
607 err = sg_io(file, q, bd_disk, &hdr); 596 err = sg_io(file, q, bd_disk, &hdr);
608 if (err == -EFAULT) 597 if (err == -EFAULT)
609 break; 598 break;
610 599
611 if (copy_to_user(arg, &hdr, sizeof(hdr))) 600 if (copy_to_user(arg, &hdr, sizeof(hdr)))
612 err = -EFAULT; 601 err = -EFAULT;
613 break; 602 break;
614 } 603 }
615 case CDROM_SEND_PACKET: { 604 case CDROM_SEND_PACKET: {
616 struct cdrom_generic_command cgc; 605 struct cdrom_generic_command cgc;
617 struct sg_io_hdr hdr; 606 struct sg_io_hdr hdr;
618 607
619 err = -EFAULT; 608 err = -EFAULT;
620 if (copy_from_user(&cgc, arg, sizeof(cgc))) 609 if (copy_from_user(&cgc, arg, sizeof(cgc)))
621 break; 610 break;
622 cgc.timeout = clock_t_to_jiffies(cgc.timeout); 611 cgc.timeout = clock_t_to_jiffies(cgc.timeout);
623 memset(&hdr, 0, sizeof(hdr)); 612 memset(&hdr, 0, sizeof(hdr));
624 hdr.interface_id = 'S'; 613 hdr.interface_id = 'S';
625 hdr.cmd_len = sizeof(cgc.cmd); 614 hdr.cmd_len = sizeof(cgc.cmd);
626 hdr.dxfer_len = cgc.buflen; 615 hdr.dxfer_len = cgc.buflen;
627 err = 0; 616 err = 0;
628 switch (cgc.data_direction) { 617 switch (cgc.data_direction) {
629 case CGC_DATA_UNKNOWN: 618 case CGC_DATA_UNKNOWN:
630 hdr.dxfer_direction = SG_DXFER_UNKNOWN; 619 hdr.dxfer_direction = SG_DXFER_UNKNOWN;
631 break; 620 break;
632 case CGC_DATA_WRITE: 621 case CGC_DATA_WRITE:
633 hdr.dxfer_direction = SG_DXFER_TO_DEV; 622 hdr.dxfer_direction = SG_DXFER_TO_DEV;
634 break; 623 break;
635 case CGC_DATA_READ: 624 case CGC_DATA_READ:
636 hdr.dxfer_direction = SG_DXFER_FROM_DEV; 625 hdr.dxfer_direction = SG_DXFER_FROM_DEV;
637 break; 626 break;
638 case CGC_DATA_NONE: 627 case CGC_DATA_NONE:
639 hdr.dxfer_direction = SG_DXFER_NONE; 628 hdr.dxfer_direction = SG_DXFER_NONE;
640 break; 629 break;
641 default: 630 default:
642 err = -EINVAL; 631 err = -EINVAL;
643 } 632 }
644 if (err) 633 if (err)
645 break; 634 break;
646 635
647 hdr.dxferp = cgc.buffer; 636 hdr.dxferp = cgc.buffer;
648 hdr.sbp = cgc.sense; 637 hdr.sbp = cgc.sense;
649 if (hdr.sbp) 638 if (hdr.sbp)
650 hdr.mx_sb_len = sizeof(struct request_sense); 639 hdr.mx_sb_len = sizeof(struct request_sense);
651 hdr.timeout = cgc.timeout; 640 hdr.timeout = cgc.timeout;
652 hdr.cmdp = ((struct cdrom_generic_command __user*) arg)->cmd; 641 hdr.cmdp = ((struct cdrom_generic_command __user*) arg)->cmd;
653 hdr.cmd_len = sizeof(cgc.cmd); 642 hdr.cmd_len = sizeof(cgc.cmd);
654 643
655 err = sg_io(file, q, bd_disk, &hdr); 644 err = sg_io(file, q, bd_disk, &hdr);
656 if (err == -EFAULT) 645 if (err == -EFAULT)
657 break; 646 break;
658 647
659 if (hdr.status) 648 if (hdr.status)
660 err = -EIO; 649 err = -EIO;
661 650
662 cgc.stat = err; 651 cgc.stat = err;
663 cgc.buflen = hdr.resid; 652 cgc.buflen = hdr.resid;
664 if (copy_to_user(arg, &cgc, sizeof(cgc))) 653 if (copy_to_user(arg, &cgc, sizeof(cgc)))
665 err = -EFAULT; 654 err = -EFAULT;
666 655
667 break; 656 break;
668 } 657 }
669 658
670 /* 659 /*
671 * old junk scsi send command ioctl 660 * old junk scsi send command ioctl
672 */ 661 */
673 case SCSI_IOCTL_SEND_COMMAND: 662 case SCSI_IOCTL_SEND_COMMAND:
674 printk(KERN_WARNING "program %s is using a deprecated SCSI ioctl, please convert it to SG_IO\n", current->comm); 663 printk(KERN_WARNING "program %s is using a deprecated SCSI ioctl, please convert it to SG_IO\n", current->comm);
675 err = -EINVAL; 664 err = -EINVAL;
676 if (!arg) 665 if (!arg)
677 break; 666 break;
678 667
679 err = sg_scsi_ioctl(file, q, bd_disk, arg); 668 err = sg_scsi_ioctl(file, q, bd_disk, arg);
680 break; 669 break;
681 case CDROMCLOSETRAY: 670 case CDROMCLOSETRAY:
682 err = blk_send_start_stop(q, bd_disk, 0x03); 671 err = blk_send_start_stop(q, bd_disk, 0x03);
683 break; 672 break;
684 case CDROMEJECT: 673 case CDROMEJECT:
685 err = blk_send_start_stop(q, bd_disk, 0x02); 674 err = blk_send_start_stop(q, bd_disk, 0x02);
686 break; 675 break;
687 default: 676 default:
688 err = -ENOTTY; 677 err = -ENOTTY;
689 } 678 }
690 679
691 blk_put_queue(q); 680 blk_put_queue(q);
692 return err; 681 return err;
693 } 682 }
694 683
695 EXPORT_SYMBOL(scsi_cmd_ioctl); 684 EXPORT_SYMBOL(scsi_cmd_ioctl);
696 685