scsi_ioctl.c 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Changes:
  4. * Arnaldo Carvalho de Melo <[email protected]> 08/23/2000
  5. * - get rid of some verify_areas and use __copy*user and __get/put_user
  6. * for the ones that remain
  7. */
  8. #include <linux/module.h>
  9. #include <linux/blkdev.h>
  10. #include <linux/interrupt.h>
  11. #include <linux/errno.h>
  12. #include <linux/kernel.h>
  13. #include <linux/sched.h>
  14. #include <linux/mm.h>
  15. #include <linux/string.h>
  16. #include <linux/uaccess.h>
  17. #include <linux/cdrom.h>
  18. #include <scsi/scsi.h>
  19. #include <scsi/scsi_cmnd.h>
  20. #include <scsi/scsi_device.h>
  21. #include <scsi/scsi_eh.h>
  22. #include <scsi/scsi_host.h>
  23. #include <scsi/scsi_ioctl.h>
  24. #include <scsi/sg.h>
  25. #include <scsi/scsi_dbg.h>
  26. #include "scsi_logging.h"
  27. #define NORMAL_RETRIES 5
  28. #define IOCTL_NORMAL_TIMEOUT (10 * HZ)
  29. #define MAX_BUF PAGE_SIZE
  30. /**
  31. * ioctl_probe -- return host identification
  32. * @host: host to identify
  33. * @buffer: userspace buffer for identification
  34. *
  35. * Return an identifying string at @buffer, if @buffer is non-NULL, filling
  36. * to the length stored at * (int *) @buffer.
  37. */
  38. static int ioctl_probe(struct Scsi_Host *host, void __user *buffer)
  39. {
  40. unsigned int len, slen;
  41. const char *string;
  42. if (buffer) {
  43. if (get_user(len, (unsigned int __user *) buffer))
  44. return -EFAULT;
  45. if (host->hostt->info)
  46. string = host->hostt->info(host);
  47. else
  48. string = host->hostt->name;
  49. if (string) {
  50. slen = strlen(string);
  51. if (len > slen)
  52. len = slen + 1;
  53. if (copy_to_user(buffer, string, len))
  54. return -EFAULT;
  55. }
  56. }
  57. return 1;
  58. }
  59. static int ioctl_internal_command(struct scsi_device *sdev, char *cmd,
  60. int timeout, int retries)
  61. {
  62. int result;
  63. struct scsi_sense_hdr sshdr;
  64. const struct scsi_exec_args exec_args = {
  65. .sshdr = &sshdr,
  66. };
  67. SCSI_LOG_IOCTL(1, sdev_printk(KERN_INFO, sdev,
  68. "Trying ioctl with scsi command %d\n", *cmd));
  69. result = scsi_execute_cmd(sdev, cmd, REQ_OP_DRV_IN, NULL, 0, timeout,
  70. retries, &exec_args);
  71. SCSI_LOG_IOCTL(2, sdev_printk(KERN_INFO, sdev,
  72. "Ioctl returned 0x%x\n", result));
  73. if (result < 0)
  74. goto out;
  75. if (scsi_sense_valid(&sshdr)) {
  76. switch (sshdr.sense_key) {
  77. case ILLEGAL_REQUEST:
  78. if (cmd[0] == ALLOW_MEDIUM_REMOVAL)
  79. sdev->lockable = 0;
  80. else
  81. sdev_printk(KERN_INFO, sdev,
  82. "ioctl_internal_command: "
  83. "ILLEGAL REQUEST "
  84. "asc=0x%x ascq=0x%x\n",
  85. sshdr.asc, sshdr.ascq);
  86. break;
  87. case NOT_READY: /* This happens if there is no disc in drive */
  88. if (sdev->removable)
  89. break;
  90. fallthrough;
  91. case UNIT_ATTENTION:
  92. if (sdev->removable) {
  93. sdev->changed = 1;
  94. result = 0; /* This is no longer considered an error */
  95. break;
  96. }
  97. fallthrough; /* for non-removable media */
  98. default:
  99. sdev_printk(KERN_INFO, sdev,
  100. "ioctl_internal_command return code = %x\n",
  101. result);
  102. scsi_print_sense_hdr(sdev, NULL, &sshdr);
  103. break;
  104. }
  105. }
  106. out:
  107. SCSI_LOG_IOCTL(2, sdev_printk(KERN_INFO, sdev,
  108. "IOCTL Releasing command\n"));
  109. return result;
  110. }
  111. int scsi_set_medium_removal(struct scsi_device *sdev, char state)
  112. {
  113. char scsi_cmd[MAX_COMMAND_SIZE];
  114. int ret;
  115. if (!sdev->removable || !sdev->lockable)
  116. return 0;
  117. scsi_cmd[0] = ALLOW_MEDIUM_REMOVAL;
  118. scsi_cmd[1] = 0;
  119. scsi_cmd[2] = 0;
  120. scsi_cmd[3] = 0;
  121. scsi_cmd[4] = state;
  122. scsi_cmd[5] = 0;
  123. ret = ioctl_internal_command(sdev, scsi_cmd,
  124. IOCTL_NORMAL_TIMEOUT, NORMAL_RETRIES);
  125. if (ret == 0)
  126. sdev->locked = (state == SCSI_REMOVAL_PREVENT);
  127. return ret;
  128. }
  129. EXPORT_SYMBOL(scsi_set_medium_removal);
  130. /*
  131. * The scsi_ioctl_get_pci() function places into arg the value
  132. * pci_dev::slot_name (8 characters) for the PCI device (if any).
  133. * Returns: 0 on success
  134. * -ENXIO if there isn't a PCI device pointer
  135. * (could be because the SCSI driver hasn't been
  136. * updated yet, or because it isn't a SCSI
  137. * device)
  138. * any copy_to_user() error on failure there
  139. */
  140. static int scsi_ioctl_get_pci(struct scsi_device *sdev, void __user *arg)
  141. {
  142. struct device *dev = scsi_get_device(sdev->host);
  143. const char *name;
  144. if (!dev)
  145. return -ENXIO;
  146. name = dev_name(dev);
  147. /* compatibility with old ioctl which only returned
  148. * 20 characters */
  149. return copy_to_user(arg, name, min(strlen(name), (size_t)20))
  150. ? -EFAULT: 0;
  151. }
  152. static int sg_get_version(int __user *p)
  153. {
  154. static const int sg_version_num = 30527;
  155. return put_user(sg_version_num, p);
  156. }
  157. static int sg_set_timeout(struct scsi_device *sdev, int __user *p)
  158. {
  159. int timeout, err = get_user(timeout, p);
  160. if (!err)
  161. sdev->sg_timeout = clock_t_to_jiffies(timeout);
  162. return err;
  163. }
  164. static int sg_get_reserved_size(struct scsi_device *sdev, int __user *p)
  165. {
  166. int val = min(sdev->sg_reserved_size,
  167. queue_max_bytes(sdev->request_queue));
  168. return put_user(val, p);
  169. }
  170. static int sg_set_reserved_size(struct scsi_device *sdev, int __user *p)
  171. {
  172. int size, err = get_user(size, p);
  173. if (err)
  174. return err;
  175. if (size < 0)
  176. return -EINVAL;
  177. sdev->sg_reserved_size = min_t(unsigned int, size,
  178. queue_max_bytes(sdev->request_queue));
  179. return 0;
  180. }
  181. /*
  182. * will always return that we are ATAPI even for a real SCSI drive, I'm not
  183. * so sure this is worth doing anything about (why would you care??)
  184. */
  185. static int sg_emulated_host(struct request_queue *q, int __user *p)
  186. {
  187. return put_user(1, p);
  188. }
  189. static int scsi_get_idlun(struct scsi_device *sdev, void __user *argp)
  190. {
  191. struct scsi_idlun v = {
  192. .dev_id = (sdev->id & 0xff) +
  193. ((sdev->lun & 0xff) << 8) +
  194. ((sdev->channel & 0xff) << 16) +
  195. ((sdev->host->host_no & 0xff) << 24),
  196. .host_unique_id = sdev->host->unique_id
  197. };
  198. if (copy_to_user(argp, &v, sizeof(struct scsi_idlun)))
  199. return -EFAULT;
  200. return 0;
  201. }
  202. static int scsi_send_start_stop(struct scsi_device *sdev, int data)
  203. {
  204. u8 cdb[MAX_COMMAND_SIZE] = { };
  205. cdb[0] = START_STOP;
  206. cdb[4] = data;
  207. return ioctl_internal_command(sdev, cdb, START_STOP_TIMEOUT,
  208. NORMAL_RETRIES);
  209. }
  210. /*
  211. * Check if the given command is allowed.
  212. *
  213. * Only a subset of commands are allowed for unprivileged users. Commands used
  214. * to format the media, update the firmware, etc. are not permitted.
  215. */
  216. bool scsi_cmd_allowed(unsigned char *cmd, fmode_t mode)
  217. {
  218. /* root can do any command. */
  219. if (capable(CAP_SYS_RAWIO))
  220. return true;
  221. /* Anybody who can open the device can do a read-safe command */
  222. switch (cmd[0]) {
  223. /* Basic read-only commands */
  224. case TEST_UNIT_READY:
  225. case REQUEST_SENSE:
  226. case READ_6:
  227. case READ_10:
  228. case READ_12:
  229. case READ_16:
  230. case READ_BUFFER:
  231. case READ_DEFECT_DATA:
  232. case READ_CAPACITY: /* also GPCMD_READ_CDVD_CAPACITY */
  233. case READ_LONG:
  234. case INQUIRY:
  235. case MODE_SENSE:
  236. case MODE_SENSE_10:
  237. case LOG_SENSE:
  238. case START_STOP:
  239. case GPCMD_VERIFY_10:
  240. case VERIFY_16:
  241. case REPORT_LUNS:
  242. case SERVICE_ACTION_IN_16:
  243. case RECEIVE_DIAGNOSTIC:
  244. case MAINTENANCE_IN: /* also GPCMD_SEND_KEY, which is a write command */
  245. case GPCMD_READ_BUFFER_CAPACITY:
  246. /* Audio CD commands */
  247. case GPCMD_PLAY_CD:
  248. case GPCMD_PLAY_AUDIO_10:
  249. case GPCMD_PLAY_AUDIO_MSF:
  250. case GPCMD_PLAY_AUDIO_TI:
  251. case GPCMD_PAUSE_RESUME:
  252. /* CD/DVD data reading */
  253. case GPCMD_READ_CD:
  254. case GPCMD_READ_CD_MSF:
  255. case GPCMD_READ_DISC_INFO:
  256. case GPCMD_READ_DVD_STRUCTURE:
  257. case GPCMD_READ_HEADER:
  258. case GPCMD_READ_TRACK_RZONE_INFO:
  259. case GPCMD_READ_SUBCHANNEL:
  260. case GPCMD_READ_TOC_PMA_ATIP:
  261. case GPCMD_REPORT_KEY:
  262. case GPCMD_SCAN:
  263. case GPCMD_GET_CONFIGURATION:
  264. case GPCMD_READ_FORMAT_CAPACITIES:
  265. case GPCMD_GET_EVENT_STATUS_NOTIFICATION:
  266. case GPCMD_GET_PERFORMANCE:
  267. case GPCMD_SEEK:
  268. case GPCMD_STOP_PLAY_SCAN:
  269. /* ZBC */
  270. case ZBC_IN:
  271. return true;
  272. /* Basic writing commands */
  273. case WRITE_6:
  274. case WRITE_10:
  275. case WRITE_VERIFY:
  276. case WRITE_12:
  277. case WRITE_VERIFY_12:
  278. case WRITE_16:
  279. case WRITE_LONG:
  280. case WRITE_LONG_2:
  281. case WRITE_SAME:
  282. case WRITE_SAME_16:
  283. case WRITE_SAME_32:
  284. case ERASE:
  285. case GPCMD_MODE_SELECT_10:
  286. case MODE_SELECT:
  287. case LOG_SELECT:
  288. case GPCMD_BLANK:
  289. case GPCMD_CLOSE_TRACK:
  290. case GPCMD_FLUSH_CACHE:
  291. case GPCMD_FORMAT_UNIT:
  292. case GPCMD_REPAIR_RZONE_TRACK:
  293. case GPCMD_RESERVE_RZONE_TRACK:
  294. case GPCMD_SEND_DVD_STRUCTURE:
  295. case GPCMD_SEND_EVENT:
  296. case GPCMD_SEND_OPC:
  297. case GPCMD_SEND_CUE_SHEET:
  298. case GPCMD_SET_SPEED:
  299. case GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL:
  300. case GPCMD_LOAD_UNLOAD:
  301. case GPCMD_SET_STREAMING:
  302. case GPCMD_SET_READ_AHEAD:
  303. /* ZBC */
  304. case ZBC_OUT:
  305. return (mode & FMODE_WRITE);
  306. default:
  307. return false;
  308. }
  309. }
  310. EXPORT_SYMBOL(scsi_cmd_allowed);
  311. static int scsi_fill_sghdr_rq(struct scsi_device *sdev, struct request *rq,
  312. struct sg_io_hdr *hdr, fmode_t mode)
  313. {
  314. struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(rq);
  315. if (hdr->cmd_len < 6)
  316. return -EMSGSIZE;
  317. if (copy_from_user(scmd->cmnd, hdr->cmdp, hdr->cmd_len))
  318. return -EFAULT;
  319. if (!scsi_cmd_allowed(scmd->cmnd, mode))
  320. return -EPERM;
  321. scmd->cmd_len = hdr->cmd_len;
  322. rq->timeout = msecs_to_jiffies(hdr->timeout);
  323. if (!rq->timeout)
  324. rq->timeout = sdev->sg_timeout;
  325. if (!rq->timeout)
  326. rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
  327. if (rq->timeout < BLK_MIN_SG_TIMEOUT)
  328. rq->timeout = BLK_MIN_SG_TIMEOUT;
  329. return 0;
  330. }
  331. static int scsi_complete_sghdr_rq(struct request *rq, struct sg_io_hdr *hdr,
  332. struct bio *bio)
  333. {
  334. struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(rq);
  335. int r, ret = 0;
  336. /*
  337. * fill in all the output members
  338. */
  339. hdr->status = scmd->result & 0xff;
  340. hdr->masked_status = status_byte(scmd->result);
  341. hdr->msg_status = COMMAND_COMPLETE;
  342. hdr->host_status = host_byte(scmd->result);
  343. hdr->driver_status = 0;
  344. if (scsi_status_is_check_condition(hdr->status))
  345. hdr->driver_status = DRIVER_SENSE;
  346. hdr->info = 0;
  347. if (hdr->masked_status || hdr->host_status || hdr->driver_status)
  348. hdr->info |= SG_INFO_CHECK;
  349. hdr->resid = scmd->resid_len;
  350. hdr->sb_len_wr = 0;
  351. if (scmd->sense_len && hdr->sbp) {
  352. int len = min((unsigned int) hdr->mx_sb_len, scmd->sense_len);
  353. if (!copy_to_user(hdr->sbp, scmd->sense_buffer, len))
  354. hdr->sb_len_wr = len;
  355. else
  356. ret = -EFAULT;
  357. }
  358. r = blk_rq_unmap_user(bio);
  359. if (!ret)
  360. ret = r;
  361. return ret;
  362. }
  363. static int sg_io(struct scsi_device *sdev, struct sg_io_hdr *hdr, fmode_t mode)
  364. {
  365. unsigned long start_time;
  366. ssize_t ret = 0;
  367. int writing = 0;
  368. int at_head = 0;
  369. struct request *rq;
  370. struct scsi_cmnd *scmd;
  371. struct bio *bio;
  372. if (hdr->interface_id != 'S')
  373. return -EINVAL;
  374. if (hdr->dxfer_len > (queue_max_hw_sectors(sdev->request_queue) << 9))
  375. return -EIO;
  376. if (hdr->dxfer_len)
  377. switch (hdr->dxfer_direction) {
  378. default:
  379. return -EINVAL;
  380. case SG_DXFER_TO_DEV:
  381. writing = 1;
  382. break;
  383. case SG_DXFER_TO_FROM_DEV:
  384. case SG_DXFER_FROM_DEV:
  385. break;
  386. }
  387. if (hdr->flags & SG_FLAG_Q_AT_HEAD)
  388. at_head = 1;
  389. rq = scsi_alloc_request(sdev->request_queue, writing ?
  390. REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0);
  391. if (IS_ERR(rq))
  392. return PTR_ERR(rq);
  393. scmd = blk_mq_rq_to_pdu(rq);
  394. if (hdr->cmd_len > sizeof(scmd->cmnd)) {
  395. ret = -EINVAL;
  396. goto out_put_request;
  397. }
  398. ret = scsi_fill_sghdr_rq(sdev, rq, hdr, mode);
  399. if (ret < 0)
  400. goto out_put_request;
  401. ret = blk_rq_map_user_io(rq, NULL, hdr->dxferp, hdr->dxfer_len,
  402. GFP_KERNEL, hdr->iovec_count && hdr->dxfer_len,
  403. hdr->iovec_count, 0, rq_data_dir(rq));
  404. if (ret)
  405. goto out_put_request;
  406. bio = rq->bio;
  407. scmd->allowed = 0;
  408. start_time = jiffies;
  409. blk_execute_rq(rq, at_head);
  410. hdr->duration = jiffies_to_msecs(jiffies - start_time);
  411. ret = scsi_complete_sghdr_rq(rq, hdr, bio);
  412. out_put_request:
  413. blk_mq_free_request(rq);
  414. return ret;
  415. }
  416. /**
  417. * sg_scsi_ioctl -- handle deprecated SCSI_IOCTL_SEND_COMMAND ioctl
  418. * @q: request queue to send scsi commands down
  419. * @mode: mode used to open the file through which the ioctl has been
  420. * submitted
  421. * @sic: userspace structure describing the command to perform
  422. *
  423. * Send down the scsi command described by @sic to the device below
  424. * the request queue @q.
  425. *
  426. * Notes:
  427. * - This interface is deprecated - users should use the SG_IO
  428. * interface instead, as this is a more flexible approach to
  429. * performing SCSI commands on a device.
  430. * - The SCSI command length is determined by examining the 1st byte
  431. * of the given command. There is no way to override this.
  432. * - Data transfers are limited to PAGE_SIZE
  433. * - The length (x + y) must be at least OMAX_SB_LEN bytes long to
  434. * accommodate the sense buffer when an error occurs.
  435. * The sense buffer is truncated to OMAX_SB_LEN (16) bytes so that
  436. * old code will not be surprised.
  437. * - If a Unix error occurs (e.g. ENOMEM) then the user will receive
  438. * a negative return and the Unix error code in 'errno'.
  439. * If the SCSI command succeeds then 0 is returned.
  440. * Positive numbers returned are the compacted SCSI error codes (4
  441. * bytes in one int) where the lowest byte is the SCSI status.
  442. */
  443. static int sg_scsi_ioctl(struct request_queue *q, fmode_t mode,
  444. struct scsi_ioctl_command __user *sic)
  445. {
  446. struct request *rq;
  447. int err;
  448. unsigned int in_len, out_len, bytes, opcode, cmdlen;
  449. struct scsi_cmnd *scmd;
  450. char *buffer = NULL;
  451. if (!sic)
  452. return -EINVAL;
  453. /*
  454. * get in an out lengths, verify they don't exceed a page worth of data
  455. */
  456. if (get_user(in_len, &sic->inlen))
  457. return -EFAULT;
  458. if (get_user(out_len, &sic->outlen))
  459. return -EFAULT;
  460. if (in_len > PAGE_SIZE || out_len > PAGE_SIZE)
  461. return -EINVAL;
  462. if (get_user(opcode, sic->data))
  463. return -EFAULT;
  464. bytes = max(in_len, out_len);
  465. if (bytes) {
  466. buffer = kzalloc(bytes, GFP_NOIO | GFP_USER | __GFP_NOWARN);
  467. if (!buffer)
  468. return -ENOMEM;
  469. }
  470. rq = scsi_alloc_request(q, in_len ? REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0);
  471. if (IS_ERR(rq)) {
  472. err = PTR_ERR(rq);
  473. goto error_free_buffer;
  474. }
  475. scmd = blk_mq_rq_to_pdu(rq);
  476. cmdlen = COMMAND_SIZE(opcode);
  477. /*
  478. * get command and data to send to device, if any
  479. */
  480. err = -EFAULT;
  481. scmd->cmd_len = cmdlen;
  482. if (copy_from_user(scmd->cmnd, sic->data, cmdlen))
  483. goto error;
  484. if (in_len && copy_from_user(buffer, sic->data + cmdlen, in_len))
  485. goto error;
  486. err = -EPERM;
  487. if (!scsi_cmd_allowed(scmd->cmnd, mode))
  488. goto error;
  489. /* default. possible overridden later */
  490. scmd->allowed = 5;
  491. switch (opcode) {
  492. case SEND_DIAGNOSTIC:
  493. case FORMAT_UNIT:
  494. rq->timeout = FORMAT_UNIT_TIMEOUT;
  495. scmd->allowed = 1;
  496. break;
  497. case START_STOP:
  498. rq->timeout = START_STOP_TIMEOUT;
  499. break;
  500. case MOVE_MEDIUM:
  501. rq->timeout = MOVE_MEDIUM_TIMEOUT;
  502. break;
  503. case READ_ELEMENT_STATUS:
  504. rq->timeout = READ_ELEMENT_STATUS_TIMEOUT;
  505. break;
  506. case READ_DEFECT_DATA:
  507. rq->timeout = READ_DEFECT_DATA_TIMEOUT;
  508. scmd->allowed = 1;
  509. break;
  510. default:
  511. rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
  512. break;
  513. }
  514. if (bytes) {
  515. err = blk_rq_map_kern(q, rq, buffer, bytes, GFP_NOIO);
  516. if (err)
  517. goto error;
  518. }
  519. blk_execute_rq(rq, false);
  520. err = scmd->result & 0xff; /* only 8 bit SCSI status */
  521. if (err) {
  522. if (scmd->sense_len && scmd->sense_buffer) {
  523. /* limit sense len for backward compatibility */
  524. if (copy_to_user(sic->data, scmd->sense_buffer,
  525. min(scmd->sense_len, 16U)))
  526. err = -EFAULT;
  527. }
  528. } else {
  529. if (copy_to_user(sic->data, buffer, out_len))
  530. err = -EFAULT;
  531. }
  532. error:
  533. blk_mq_free_request(rq);
  534. error_free_buffer:
  535. kfree(buffer);
  536. return err;
  537. }
  538. int put_sg_io_hdr(const struct sg_io_hdr *hdr, void __user *argp)
  539. {
  540. #ifdef CONFIG_COMPAT
  541. if (in_compat_syscall()) {
  542. struct compat_sg_io_hdr hdr32 = {
  543. .interface_id = hdr->interface_id,
  544. .dxfer_direction = hdr->dxfer_direction,
  545. .cmd_len = hdr->cmd_len,
  546. .mx_sb_len = hdr->mx_sb_len,
  547. .iovec_count = hdr->iovec_count,
  548. .dxfer_len = hdr->dxfer_len,
  549. .dxferp = (uintptr_t)hdr->dxferp,
  550. .cmdp = (uintptr_t)hdr->cmdp,
  551. .sbp = (uintptr_t)hdr->sbp,
  552. .timeout = hdr->timeout,
  553. .flags = hdr->flags,
  554. .pack_id = hdr->pack_id,
  555. .usr_ptr = (uintptr_t)hdr->usr_ptr,
  556. .status = hdr->status,
  557. .masked_status = hdr->masked_status,
  558. .msg_status = hdr->msg_status,
  559. .sb_len_wr = hdr->sb_len_wr,
  560. .host_status = hdr->host_status,
  561. .driver_status = hdr->driver_status,
  562. .resid = hdr->resid,
  563. .duration = hdr->duration,
  564. .info = hdr->info,
  565. };
  566. if (copy_to_user(argp, &hdr32, sizeof(hdr32)))
  567. return -EFAULT;
  568. return 0;
  569. }
  570. #endif
  571. if (copy_to_user(argp, hdr, sizeof(*hdr)))
  572. return -EFAULT;
  573. return 0;
  574. }
  575. EXPORT_SYMBOL(put_sg_io_hdr);
  576. int get_sg_io_hdr(struct sg_io_hdr *hdr, const void __user *argp)
  577. {
  578. #ifdef CONFIG_COMPAT
  579. struct compat_sg_io_hdr hdr32;
  580. if (in_compat_syscall()) {
  581. if (copy_from_user(&hdr32, argp, sizeof(hdr32)))
  582. return -EFAULT;
  583. *hdr = (struct sg_io_hdr) {
  584. .interface_id = hdr32.interface_id,
  585. .dxfer_direction = hdr32.dxfer_direction,
  586. .cmd_len = hdr32.cmd_len,
  587. .mx_sb_len = hdr32.mx_sb_len,
  588. .iovec_count = hdr32.iovec_count,
  589. .dxfer_len = hdr32.dxfer_len,
  590. .dxferp = compat_ptr(hdr32.dxferp),
  591. .cmdp = compat_ptr(hdr32.cmdp),
  592. .sbp = compat_ptr(hdr32.sbp),
  593. .timeout = hdr32.timeout,
  594. .flags = hdr32.flags,
  595. .pack_id = hdr32.pack_id,
  596. .usr_ptr = compat_ptr(hdr32.usr_ptr),
  597. .status = hdr32.status,
  598. .masked_status = hdr32.masked_status,
  599. .msg_status = hdr32.msg_status,
  600. .sb_len_wr = hdr32.sb_len_wr,
  601. .host_status = hdr32.host_status,
  602. .driver_status = hdr32.driver_status,
  603. .resid = hdr32.resid,
  604. .duration = hdr32.duration,
  605. .info = hdr32.info,
  606. };
  607. return 0;
  608. }
  609. #endif
  610. if (copy_from_user(hdr, argp, sizeof(*hdr)))
  611. return -EFAULT;
  612. return 0;
  613. }
  614. EXPORT_SYMBOL(get_sg_io_hdr);
  615. #ifdef CONFIG_COMPAT
  616. struct compat_cdrom_generic_command {
  617. unsigned char cmd[CDROM_PACKET_SIZE];
  618. compat_caddr_t buffer;
  619. compat_uint_t buflen;
  620. compat_int_t stat;
  621. compat_caddr_t sense;
  622. unsigned char data_direction;
  623. unsigned char pad[3];
  624. compat_int_t quiet;
  625. compat_int_t timeout;
  626. compat_caddr_t unused;
  627. };
  628. #endif
  629. static int scsi_get_cdrom_generic_arg(struct cdrom_generic_command *cgc,
  630. const void __user *arg)
  631. {
  632. #ifdef CONFIG_COMPAT
  633. if (in_compat_syscall()) {
  634. struct compat_cdrom_generic_command cgc32;
  635. if (copy_from_user(&cgc32, arg, sizeof(cgc32)))
  636. return -EFAULT;
  637. *cgc = (struct cdrom_generic_command) {
  638. .buffer = compat_ptr(cgc32.buffer),
  639. .buflen = cgc32.buflen,
  640. .stat = cgc32.stat,
  641. .sense = compat_ptr(cgc32.sense),
  642. .data_direction = cgc32.data_direction,
  643. .quiet = cgc32.quiet,
  644. .timeout = cgc32.timeout,
  645. .unused = compat_ptr(cgc32.unused),
  646. };
  647. memcpy(&cgc->cmd, &cgc32.cmd, CDROM_PACKET_SIZE);
  648. return 0;
  649. }
  650. #endif
  651. if (copy_from_user(cgc, arg, sizeof(*cgc)))
  652. return -EFAULT;
  653. return 0;
  654. }
  655. static int scsi_put_cdrom_generic_arg(const struct cdrom_generic_command *cgc,
  656. void __user *arg)
  657. {
  658. #ifdef CONFIG_COMPAT
  659. if (in_compat_syscall()) {
  660. struct compat_cdrom_generic_command cgc32 = {
  661. .buffer = (uintptr_t)(cgc->buffer),
  662. .buflen = cgc->buflen,
  663. .stat = cgc->stat,
  664. .sense = (uintptr_t)(cgc->sense),
  665. .data_direction = cgc->data_direction,
  666. .quiet = cgc->quiet,
  667. .timeout = cgc->timeout,
  668. .unused = (uintptr_t)(cgc->unused),
  669. };
  670. memcpy(&cgc32.cmd, &cgc->cmd, CDROM_PACKET_SIZE);
  671. if (copy_to_user(arg, &cgc32, sizeof(cgc32)))
  672. return -EFAULT;
  673. return 0;
  674. }
  675. #endif
  676. if (copy_to_user(arg, cgc, sizeof(*cgc)))
  677. return -EFAULT;
  678. return 0;
  679. }
  680. static int scsi_cdrom_send_packet(struct scsi_device *sdev, fmode_t mode,
  681. void __user *arg)
  682. {
  683. struct cdrom_generic_command cgc;
  684. struct sg_io_hdr hdr;
  685. int err;
  686. err = scsi_get_cdrom_generic_arg(&cgc, arg);
  687. if (err)
  688. return err;
  689. cgc.timeout = clock_t_to_jiffies(cgc.timeout);
  690. memset(&hdr, 0, sizeof(hdr));
  691. hdr.interface_id = 'S';
  692. hdr.cmd_len = sizeof(cgc.cmd);
  693. hdr.dxfer_len = cgc.buflen;
  694. switch (cgc.data_direction) {
  695. case CGC_DATA_UNKNOWN:
  696. hdr.dxfer_direction = SG_DXFER_UNKNOWN;
  697. break;
  698. case CGC_DATA_WRITE:
  699. hdr.dxfer_direction = SG_DXFER_TO_DEV;
  700. break;
  701. case CGC_DATA_READ:
  702. hdr.dxfer_direction = SG_DXFER_FROM_DEV;
  703. break;
  704. case CGC_DATA_NONE:
  705. hdr.dxfer_direction = SG_DXFER_NONE;
  706. break;
  707. default:
  708. return -EINVAL;
  709. }
  710. hdr.dxferp = cgc.buffer;
  711. hdr.sbp = cgc.sense;
  712. if (hdr.sbp)
  713. hdr.mx_sb_len = sizeof(struct request_sense);
  714. hdr.timeout = jiffies_to_msecs(cgc.timeout);
  715. hdr.cmdp = ((struct cdrom_generic_command __user *) arg)->cmd;
  716. hdr.cmd_len = sizeof(cgc.cmd);
  717. err = sg_io(sdev, &hdr, mode);
  718. if (err == -EFAULT)
  719. return -EFAULT;
  720. if (hdr.status)
  721. return -EIO;
  722. cgc.stat = err;
  723. cgc.buflen = hdr.resid;
  724. if (scsi_put_cdrom_generic_arg(&cgc, arg))
  725. return -EFAULT;
  726. return err;
  727. }
  728. static int scsi_ioctl_sg_io(struct scsi_device *sdev, fmode_t mode,
  729. void __user *argp)
  730. {
  731. struct sg_io_hdr hdr;
  732. int error;
  733. error = get_sg_io_hdr(&hdr, argp);
  734. if (error)
  735. return error;
  736. error = sg_io(sdev, &hdr, mode);
  737. if (error == -EFAULT)
  738. return error;
  739. if (put_sg_io_hdr(&hdr, argp))
  740. return -EFAULT;
  741. return error;
  742. }
  743. /**
  744. * scsi_ioctl - Dispatch ioctl to scsi device
  745. * @sdev: scsi device receiving ioctl
  746. * @mode: mode the block/char device is opened with
  747. * @cmd: which ioctl is it
  748. * @arg: data associated with ioctl
  749. *
  750. * Description: The scsi_ioctl() function differs from most ioctls in that it
  751. * does not take a major/minor number as the dev field. Rather, it takes
  752. * a pointer to a &struct scsi_device.
  753. */
  754. int scsi_ioctl(struct scsi_device *sdev, fmode_t mode, int cmd,
  755. void __user *arg)
  756. {
  757. struct request_queue *q = sdev->request_queue;
  758. struct scsi_sense_hdr sense_hdr;
  759. /* Check for deprecated ioctls ... all the ioctls which don't
  760. * follow the new unique numbering scheme are deprecated */
  761. switch (cmd) {
  762. case SCSI_IOCTL_SEND_COMMAND:
  763. case SCSI_IOCTL_TEST_UNIT_READY:
  764. case SCSI_IOCTL_BENCHMARK_COMMAND:
  765. case SCSI_IOCTL_SYNC:
  766. case SCSI_IOCTL_START_UNIT:
  767. case SCSI_IOCTL_STOP_UNIT:
  768. printk(KERN_WARNING "program %s is using a deprecated SCSI "
  769. "ioctl, please convert it to SG_IO\n", current->comm);
  770. break;
  771. default:
  772. break;
  773. }
  774. switch (cmd) {
  775. case SG_GET_VERSION_NUM:
  776. return sg_get_version(arg);
  777. case SG_SET_TIMEOUT:
  778. return sg_set_timeout(sdev, arg);
  779. case SG_GET_TIMEOUT:
  780. return jiffies_to_clock_t(sdev->sg_timeout);
  781. case SG_GET_RESERVED_SIZE:
  782. return sg_get_reserved_size(sdev, arg);
  783. case SG_SET_RESERVED_SIZE:
  784. return sg_set_reserved_size(sdev, arg);
  785. case SG_EMULATED_HOST:
  786. return sg_emulated_host(q, arg);
  787. case SG_IO:
  788. return scsi_ioctl_sg_io(sdev, mode, arg);
  789. case SCSI_IOCTL_SEND_COMMAND:
  790. return sg_scsi_ioctl(q, mode, arg);
  791. case CDROM_SEND_PACKET:
  792. return scsi_cdrom_send_packet(sdev, mode, arg);
  793. case CDROMCLOSETRAY:
  794. return scsi_send_start_stop(sdev, 3);
  795. case CDROMEJECT:
  796. return scsi_send_start_stop(sdev, 2);
  797. case SCSI_IOCTL_GET_IDLUN:
  798. return scsi_get_idlun(sdev, arg);
  799. case SCSI_IOCTL_GET_BUS_NUMBER:
  800. return put_user(sdev->host->host_no, (int __user *)arg);
  801. case SCSI_IOCTL_PROBE_HOST:
  802. return ioctl_probe(sdev->host, arg);
  803. case SCSI_IOCTL_DOORLOCK:
  804. return scsi_set_medium_removal(sdev, SCSI_REMOVAL_PREVENT);
  805. case SCSI_IOCTL_DOORUNLOCK:
  806. return scsi_set_medium_removal(sdev, SCSI_REMOVAL_ALLOW);
  807. case SCSI_IOCTL_TEST_UNIT_READY:
  808. return scsi_test_unit_ready(sdev, IOCTL_NORMAL_TIMEOUT,
  809. NORMAL_RETRIES, &sense_hdr);
  810. case SCSI_IOCTL_START_UNIT:
  811. return scsi_send_start_stop(sdev, 1);
  812. case SCSI_IOCTL_STOP_UNIT:
  813. return scsi_send_start_stop(sdev, 0);
  814. case SCSI_IOCTL_GET_PCI:
  815. return scsi_ioctl_get_pci(sdev, arg);
  816. case SG_SCSI_RESET:
  817. return scsi_ioctl_reset(sdev, arg);
  818. }
  819. #ifdef CONFIG_COMPAT
  820. if (in_compat_syscall()) {
  821. if (!sdev->host->hostt->compat_ioctl)
  822. return -EINVAL;
  823. return sdev->host->hostt->compat_ioctl(sdev, cmd, arg);
  824. }
  825. #endif
  826. if (!sdev->host->hostt->ioctl)
  827. return -EINVAL;
  828. return sdev->host->hostt->ioctl(sdev, cmd, arg);
  829. }
  830. EXPORT_SYMBOL(scsi_ioctl);
  831. /*
  832. * We can process a reset even when a device isn't fully operable.
  833. */
  834. int scsi_ioctl_block_when_processing_errors(struct scsi_device *sdev, int cmd,
  835. bool ndelay)
  836. {
  837. if (cmd == SG_SCSI_RESET && ndelay) {
  838. if (scsi_host_in_recovery(sdev->host))
  839. return -EAGAIN;
  840. } else {
  841. if (!scsi_block_when_processing_errors(sdev))
  842. return -ENODEV;
  843. }
  844. return 0;
  845. }
  846. EXPORT_SYMBOL_GPL(scsi_ioctl_block_when_processing_errors);