scsi_ioctl.c 23 KB

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