target_core_sbc.c 37 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * SCSI Block Commands (SBC) parsing and emulation.
  4. *
  5. * (c) Copyright 2002-2013 Datera, Inc.
  6. *
  7. * Nicholas A. Bellinger <nab@kernel.org>
  8. */
  9. #include <linux/kernel.h>
  10. #include <linux/module.h>
  11. #include <linux/ratelimit.h>
  12. #include <linux/crc-t10dif.h>
  13. #include <linux/t10-pi.h>
  14. #include <asm/unaligned.h>
  15. #include <scsi/scsi_proto.h>
  16. #include <scsi/scsi_tcq.h>
  17. #include <target/target_core_base.h>
  18. #include <target/target_core_backend.h>
  19. #include <target/target_core_fabric.h>
  20. #include "target_core_internal.h"
  21. #include "target_core_ua.h"
  22. #include "target_core_alua.h"
  23. static sense_reason_t
  24. sbc_check_prot(struct se_device *, struct se_cmd *, unsigned char, u32, bool);
  25. static sense_reason_t sbc_execute_unmap(struct se_cmd *cmd);
  26. static sense_reason_t
  27. sbc_emulate_readcapacity(struct se_cmd *cmd)
  28. {
  29. struct se_device *dev = cmd->se_dev;
  30. unsigned char *cdb = cmd->t_task_cdb;
  31. unsigned long long blocks_long = dev->transport->get_blocks(dev);
  32. unsigned char *rbuf;
  33. unsigned char buf[8];
  34. u32 blocks;
  35. /*
  36. * SBC-2 says:
  37. * If the PMI bit is set to zero and the LOGICAL BLOCK
  38. * ADDRESS field is not set to zero, the device server shall
  39. * terminate the command with CHECK CONDITION status with
  40. * the sense key set to ILLEGAL REQUEST and the additional
  41. * sense code set to INVALID FIELD IN CDB.
  42. *
  43. * In SBC-3, these fields are obsolete, but some SCSI
  44. * compliance tests actually check this, so we might as well
  45. * follow SBC-2.
  46. */
  47. if (!(cdb[8] & 1) && !!(cdb[2] | cdb[3] | cdb[4] | cdb[5]))
  48. return TCM_INVALID_CDB_FIELD;
  49. if (blocks_long >= 0x00000000ffffffff)
  50. blocks = 0xffffffff;
  51. else
  52. blocks = (u32)blocks_long;
  53. put_unaligned_be32(blocks, &buf[0]);
  54. put_unaligned_be32(dev->dev_attrib.block_size, &buf[4]);
  55. rbuf = transport_kmap_data_sg(cmd);
  56. if (rbuf) {
  57. memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length));
  58. transport_kunmap_data_sg(cmd);
  59. }
  60. target_complete_cmd_with_length(cmd, GOOD, 8);
  61. return 0;
  62. }
  63. static sense_reason_t
  64. sbc_emulate_readcapacity_16(struct se_cmd *cmd)
  65. {
  66. struct se_device *dev = cmd->se_dev;
  67. struct se_session *sess = cmd->se_sess;
  68. int pi_prot_type = dev->dev_attrib.pi_prot_type;
  69. unsigned char *rbuf;
  70. unsigned char buf[32];
  71. unsigned long long blocks = dev->transport->get_blocks(dev);
  72. memset(buf, 0, sizeof(buf));
  73. put_unaligned_be64(blocks, &buf[0]);
  74. put_unaligned_be32(dev->dev_attrib.block_size, &buf[8]);
  75. /*
  76. * Set P_TYPE and PROT_EN bits for DIF support
  77. */
  78. if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) {
  79. /*
  80. * Only override a device's pi_prot_type if no T10-PI is
  81. * available, and sess_prot_type has been explicitly enabled.
  82. */
  83. if (!pi_prot_type)
  84. pi_prot_type = sess->sess_prot_type;
  85. if (pi_prot_type)
  86. buf[12] = (pi_prot_type - 1) << 1 | 0x1;
  87. }
  88. if (dev->transport->get_lbppbe)
  89. buf[13] = dev->transport->get_lbppbe(dev) & 0x0f;
  90. if (dev->transport->get_alignment_offset_lbas) {
  91. u16 lalba = dev->transport->get_alignment_offset_lbas(dev);
  92. put_unaligned_be16(lalba, &buf[14]);
  93. }
  94. /*
  95. * Set Thin Provisioning Enable bit following sbc3r22 in section
  96. * READ CAPACITY (16) byte 14 if emulate_tpu or emulate_tpws is enabled.
  97. */
  98. if (dev->dev_attrib.emulate_tpu || dev->dev_attrib.emulate_tpws) {
  99. buf[14] |= 0x80;
  100. /*
  101. * LBPRZ signifies that zeroes will be read back from an LBA after
  102. * an UNMAP or WRITE SAME w/ unmap bit (sbc3r36 5.16.2)
  103. */
  104. if (dev->dev_attrib.unmap_zeroes_data)
  105. buf[14] |= 0x40;
  106. }
  107. rbuf = transport_kmap_data_sg(cmd);
  108. if (rbuf) {
  109. memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length));
  110. transport_kunmap_data_sg(cmd);
  111. }
  112. target_complete_cmd_with_length(cmd, GOOD, 32);
  113. return 0;
  114. }
  115. static sense_reason_t
  116. sbc_emulate_startstop(struct se_cmd *cmd)
  117. {
  118. unsigned char *cdb = cmd->t_task_cdb;
  119. /*
  120. * See sbc3r36 section 5.25
  121. * Immediate bit should be set since there is nothing to complete
  122. * POWER CONDITION MODIFIER 0h
  123. */
  124. if (!(cdb[1] & 1) || cdb[2] || cdb[3])
  125. return TCM_INVALID_CDB_FIELD;
  126. /*
  127. * See sbc3r36 section 5.25
  128. * POWER CONDITION 0h START_VALID - process START and LOEJ
  129. */
  130. if (cdb[4] >> 4 & 0xf)
  131. return TCM_INVALID_CDB_FIELD;
  132. /*
  133. * See sbc3r36 section 5.25
  134. * LOEJ 0h - nothing to load or unload
  135. * START 1h - we are ready
  136. */
  137. if (!(cdb[4] & 1) || (cdb[4] & 2) || (cdb[4] & 4))
  138. return TCM_INVALID_CDB_FIELD;
  139. target_complete_cmd(cmd, SAM_STAT_GOOD);
  140. return 0;
  141. }
  142. sector_t sbc_get_write_same_sectors(struct se_cmd *cmd)
  143. {
  144. u32 num_blocks;
  145. if (cmd->t_task_cdb[0] == WRITE_SAME)
  146. num_blocks = get_unaligned_be16(&cmd->t_task_cdb[7]);
  147. else if (cmd->t_task_cdb[0] == WRITE_SAME_16)
  148. num_blocks = get_unaligned_be32(&cmd->t_task_cdb[10]);
  149. else /* WRITE_SAME_32 via VARIABLE_LENGTH_CMD */
  150. num_blocks = get_unaligned_be32(&cmd->t_task_cdb[28]);
  151. /*
  152. * Use the explicit range when non zero is supplied, otherwise calculate
  153. * the remaining range based on ->get_blocks() - starting LBA.
  154. */
  155. if (num_blocks)
  156. return num_blocks;
  157. return cmd->se_dev->transport->get_blocks(cmd->se_dev) -
  158. cmd->t_task_lba + 1;
  159. }
  160. EXPORT_SYMBOL(sbc_get_write_same_sectors);
  161. static sense_reason_t
  162. sbc_execute_write_same_unmap(struct se_cmd *cmd)
  163. {
  164. struct sbc_ops *ops = cmd->protocol_data;
  165. sector_t nolb = sbc_get_write_same_sectors(cmd);
  166. sense_reason_t ret;
  167. if (nolb) {
  168. ret = ops->execute_unmap(cmd, cmd->t_task_lba, nolb);
  169. if (ret)
  170. return ret;
  171. }
  172. target_complete_cmd(cmd, GOOD);
  173. return 0;
  174. }
  175. static sense_reason_t
  176. sbc_emulate_noop(struct se_cmd *cmd)
  177. {
  178. target_complete_cmd(cmd, GOOD);
  179. return 0;
  180. }
  181. static inline u32 sbc_get_size(struct se_cmd *cmd, u32 sectors)
  182. {
  183. return cmd->se_dev->dev_attrib.block_size * sectors;
  184. }
  185. static inline u32 transport_get_sectors_6(unsigned char *cdb)
  186. {
  187. /*
  188. * Use 8-bit sector value. SBC-3 says:
  189. *
  190. * A TRANSFER LENGTH field set to zero specifies that 256
  191. * logical blocks shall be written. Any other value
  192. * specifies the number of logical blocks that shall be
  193. * written.
  194. */
  195. return cdb[4] ? : 256;
  196. }
  197. static inline u32 transport_get_sectors_10(unsigned char *cdb)
  198. {
  199. return get_unaligned_be16(&cdb[7]);
  200. }
  201. static inline u32 transport_get_sectors_12(unsigned char *cdb)
  202. {
  203. return get_unaligned_be32(&cdb[6]);
  204. }
  205. static inline u32 transport_get_sectors_16(unsigned char *cdb)
  206. {
  207. return get_unaligned_be32(&cdb[10]);
  208. }
  209. /*
  210. * Used for VARIABLE_LENGTH_CDB WRITE_32 and READ_32 variants
  211. */
  212. static inline u32 transport_get_sectors_32(unsigned char *cdb)
  213. {
  214. return get_unaligned_be32(&cdb[28]);
  215. }
  216. static inline u32 transport_lba_21(unsigned char *cdb)
  217. {
  218. return get_unaligned_be24(&cdb[1]) & 0x1fffff;
  219. }
  220. static inline u32 transport_lba_32(unsigned char *cdb)
  221. {
  222. return get_unaligned_be32(&cdb[2]);
  223. }
  224. static inline unsigned long long transport_lba_64(unsigned char *cdb)
  225. {
  226. return get_unaligned_be64(&cdb[2]);
  227. }
  228. /*
  229. * For VARIABLE_LENGTH_CDB w/ 32 byte extended CDBs
  230. */
  231. static inline unsigned long long transport_lba_64_ext(unsigned char *cdb)
  232. {
  233. return get_unaligned_be64(&cdb[12]);
  234. }
  235. static sense_reason_t
  236. sbc_setup_write_same(struct se_cmd *cmd, unsigned char flags, struct sbc_ops *ops)
  237. {
  238. struct se_device *dev = cmd->se_dev;
  239. sector_t end_lba = dev->transport->get_blocks(dev) + 1;
  240. unsigned int sectors = sbc_get_write_same_sectors(cmd);
  241. sense_reason_t ret;
  242. if ((flags & 0x04) || (flags & 0x02)) {
  243. pr_err("WRITE_SAME PBDATA and LBDATA"
  244. " bits not supported for Block Discard"
  245. " Emulation\n");
  246. return TCM_UNSUPPORTED_SCSI_OPCODE;
  247. }
  248. if (sectors > cmd->se_dev->dev_attrib.max_write_same_len) {
  249. pr_warn("WRITE_SAME sectors: %u exceeds max_write_same_len: %u\n",
  250. sectors, cmd->se_dev->dev_attrib.max_write_same_len);
  251. return TCM_INVALID_CDB_FIELD;
  252. }
  253. /*
  254. * Sanity check for LBA wrap and request past end of device.
  255. */
  256. if (((cmd->t_task_lba + sectors) < cmd->t_task_lba) ||
  257. ((cmd->t_task_lba + sectors) > end_lba)) {
  258. pr_err("WRITE_SAME exceeds last lba %llu (lba %llu, sectors %u)\n",
  259. (unsigned long long)end_lba, cmd->t_task_lba, sectors);
  260. return TCM_ADDRESS_OUT_OF_RANGE;
  261. }
  262. /* We always have ANC_SUP == 0 so setting ANCHOR is always an error */
  263. if (flags & 0x10) {
  264. pr_warn("WRITE SAME with ANCHOR not supported\n");
  265. return TCM_INVALID_CDB_FIELD;
  266. }
  267. /*
  268. * Special case for WRITE_SAME w/ UNMAP=1 that ends up getting
  269. * translated into block discard requests within backend code.
  270. */
  271. if (flags & 0x08) {
  272. if (!ops->execute_unmap)
  273. return TCM_UNSUPPORTED_SCSI_OPCODE;
  274. if (!dev->dev_attrib.emulate_tpws) {
  275. pr_err("Got WRITE_SAME w/ UNMAP=1, but backend device"
  276. " has emulate_tpws disabled\n");
  277. return TCM_UNSUPPORTED_SCSI_OPCODE;
  278. }
  279. cmd->execute_cmd = sbc_execute_write_same_unmap;
  280. return 0;
  281. }
  282. if (!ops->execute_write_same)
  283. return TCM_UNSUPPORTED_SCSI_OPCODE;
  284. ret = sbc_check_prot(dev, cmd, flags >> 5, sectors, true);
  285. if (ret)
  286. return ret;
  287. cmd->execute_cmd = ops->execute_write_same;
  288. return 0;
  289. }
  290. static sense_reason_t xdreadwrite_callback(struct se_cmd *cmd, bool success,
  291. int *post_ret)
  292. {
  293. unsigned char *buf, *addr;
  294. struct scatterlist *sg;
  295. unsigned int offset;
  296. sense_reason_t ret = TCM_NO_SENSE;
  297. int i, count;
  298. if (!success)
  299. return 0;
  300. /*
  301. * From sbc3r22.pdf section 5.48 XDWRITEREAD (10) command
  302. *
  303. * 1) read the specified logical block(s);
  304. * 2) transfer logical blocks from the data-out buffer;
  305. * 3) XOR the logical blocks transferred from the data-out buffer with
  306. * the logical blocks read, storing the resulting XOR data in a buffer;
  307. * 4) if the DISABLE WRITE bit is set to zero, then write the logical
  308. * blocks transferred from the data-out buffer; and
  309. * 5) transfer the resulting XOR data to the data-in buffer.
  310. */
  311. buf = kmalloc(cmd->data_length, GFP_KERNEL);
  312. if (!buf) {
  313. pr_err("Unable to allocate xor_callback buf\n");
  314. return TCM_OUT_OF_RESOURCES;
  315. }
  316. /*
  317. * Copy the scatterlist WRITE buffer located at cmd->t_data_sg
  318. * into the locally allocated *buf
  319. */
  320. sg_copy_to_buffer(cmd->t_data_sg,
  321. cmd->t_data_nents,
  322. buf,
  323. cmd->data_length);
  324. /*
  325. * Now perform the XOR against the BIDI read memory located at
  326. * cmd->t_mem_bidi_list
  327. */
  328. offset = 0;
  329. for_each_sg(cmd->t_bidi_data_sg, sg, cmd->t_bidi_data_nents, count) {
  330. addr = kmap_atomic(sg_page(sg));
  331. if (!addr) {
  332. ret = TCM_OUT_OF_RESOURCES;
  333. goto out;
  334. }
  335. for (i = 0; i < sg->length; i++)
  336. *(addr + sg->offset + i) ^= *(buf + offset + i);
  337. offset += sg->length;
  338. kunmap_atomic(addr);
  339. }
  340. out:
  341. kfree(buf);
  342. return ret;
  343. }
  344. static sense_reason_t
  345. sbc_execute_rw(struct se_cmd *cmd)
  346. {
  347. struct sbc_ops *ops = cmd->protocol_data;
  348. return ops->execute_rw(cmd, cmd->t_data_sg, cmd->t_data_nents,
  349. cmd->data_direction);
  350. }
  351. static sense_reason_t compare_and_write_post(struct se_cmd *cmd, bool success,
  352. int *post_ret)
  353. {
  354. struct se_device *dev = cmd->se_dev;
  355. sense_reason_t ret = TCM_NO_SENSE;
  356. spin_lock_irq(&cmd->t_state_lock);
  357. if (success) {
  358. *post_ret = 1;
  359. if (cmd->scsi_status == SAM_STAT_CHECK_CONDITION)
  360. ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
  361. }
  362. spin_unlock_irq(&cmd->t_state_lock);
  363. /*
  364. * Unlock ->caw_sem originally obtained during sbc_compare_and_write()
  365. * before the original READ I/O submission.
  366. */
  367. up(&dev->caw_sem);
  368. return ret;
  369. }
  370. static sense_reason_t compare_and_write_callback(struct se_cmd *cmd, bool success,
  371. int *post_ret)
  372. {
  373. struct se_device *dev = cmd->se_dev;
  374. struct sg_table write_tbl = { };
  375. struct scatterlist *write_sg, *sg;
  376. unsigned char *buf = NULL, *addr;
  377. struct sg_mapping_iter m;
  378. unsigned int offset = 0, len;
  379. unsigned int nlbas = cmd->t_task_nolb;
  380. unsigned int block_size = dev->dev_attrib.block_size;
  381. unsigned int compare_len = (nlbas * block_size);
  382. sense_reason_t ret = TCM_NO_SENSE;
  383. int rc, i;
  384. /*
  385. * Handle early failure in transport_generic_request_failure(),
  386. * which will not have taken ->caw_sem yet..
  387. */
  388. if (!success && (!cmd->t_data_sg || !cmd->t_bidi_data_sg))
  389. return TCM_NO_SENSE;
  390. /*
  391. * Handle special case for zero-length COMPARE_AND_WRITE
  392. */
  393. if (!cmd->data_length)
  394. goto out;
  395. /*
  396. * Immediately exit + release dev->caw_sem if command has already
  397. * been failed with a non-zero SCSI status.
  398. */
  399. if (cmd->scsi_status) {
  400. pr_debug("compare_and_write_callback: non zero scsi_status:"
  401. " 0x%02x\n", cmd->scsi_status);
  402. *post_ret = 1;
  403. if (cmd->scsi_status == SAM_STAT_CHECK_CONDITION)
  404. ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
  405. goto out;
  406. }
  407. buf = kzalloc(cmd->data_length, GFP_KERNEL);
  408. if (!buf) {
  409. pr_err("Unable to allocate compare_and_write buf\n");
  410. ret = TCM_OUT_OF_RESOURCES;
  411. goto out;
  412. }
  413. if (sg_alloc_table(&write_tbl, cmd->t_data_nents, GFP_KERNEL) < 0) {
  414. pr_err("Unable to allocate compare_and_write sg\n");
  415. ret = TCM_OUT_OF_RESOURCES;
  416. goto out;
  417. }
  418. write_sg = write_tbl.sgl;
  419. /*
  420. * Setup verify and write data payloads from total NumberLBAs.
  421. */
  422. rc = sg_copy_to_buffer(cmd->t_data_sg, cmd->t_data_nents, buf,
  423. cmd->data_length);
  424. if (!rc) {
  425. pr_err("sg_copy_to_buffer() failed for compare_and_write\n");
  426. ret = TCM_OUT_OF_RESOURCES;
  427. goto out;
  428. }
  429. /*
  430. * Compare against SCSI READ payload against verify payload
  431. */
  432. for_each_sg(cmd->t_bidi_data_sg, sg, cmd->t_bidi_data_nents, i) {
  433. addr = (unsigned char *)kmap_atomic(sg_page(sg));
  434. if (!addr) {
  435. ret = TCM_OUT_OF_RESOURCES;
  436. goto out;
  437. }
  438. len = min(sg->length, compare_len);
  439. if (memcmp(addr, buf + offset, len)) {
  440. pr_warn("Detected MISCOMPARE for addr: %p buf: %p\n",
  441. addr, buf + offset);
  442. kunmap_atomic(addr);
  443. goto miscompare;
  444. }
  445. kunmap_atomic(addr);
  446. offset += len;
  447. compare_len -= len;
  448. if (!compare_len)
  449. break;
  450. }
  451. i = 0;
  452. len = cmd->t_task_nolb * block_size;
  453. sg_miter_start(&m, cmd->t_data_sg, cmd->t_data_nents, SG_MITER_TO_SG);
  454. /*
  455. * Currently assumes NoLB=1 and SGLs are PAGE_SIZE..
  456. */
  457. while (len) {
  458. sg_miter_next(&m);
  459. if (block_size < PAGE_SIZE) {
  460. sg_set_page(&write_sg[i], m.page, block_size,
  461. m.piter.sg->offset + block_size);
  462. } else {
  463. sg_miter_next(&m);
  464. sg_set_page(&write_sg[i], m.page, block_size,
  465. m.piter.sg->offset);
  466. }
  467. len -= block_size;
  468. i++;
  469. }
  470. sg_miter_stop(&m);
  471. /*
  472. * Save the original SGL + nents values before updating to new
  473. * assignments, to be released in transport_free_pages() ->
  474. * transport_reset_sgl_orig()
  475. */
  476. cmd->t_data_sg_orig = cmd->t_data_sg;
  477. cmd->t_data_sg = write_sg;
  478. cmd->t_data_nents_orig = cmd->t_data_nents;
  479. cmd->t_data_nents = 1;
  480. cmd->sam_task_attr = TCM_HEAD_TAG;
  481. cmd->transport_complete_callback = compare_and_write_post;
  482. /*
  483. * Now reset ->execute_cmd() to the normal sbc_execute_rw() handler
  484. * for submitting the adjusted SGL to write instance user-data.
  485. */
  486. cmd->execute_cmd = sbc_execute_rw;
  487. spin_lock_irq(&cmd->t_state_lock);
  488. cmd->t_state = TRANSPORT_PROCESSING;
  489. cmd->transport_state |= CMD_T_ACTIVE | CMD_T_SENT;
  490. spin_unlock_irq(&cmd->t_state_lock);
  491. __target_execute_cmd(cmd, false);
  492. kfree(buf);
  493. return ret;
  494. miscompare:
  495. pr_warn("Target/%s: Send MISCOMPARE check condition and sense\n",
  496. dev->transport->name);
  497. ret = TCM_MISCOMPARE_VERIFY;
  498. out:
  499. /*
  500. * In the MISCOMPARE or failure case, unlock ->caw_sem obtained in
  501. * sbc_compare_and_write() before the original READ I/O submission.
  502. */
  503. up(&dev->caw_sem);
  504. sg_free_table(&write_tbl);
  505. kfree(buf);
  506. return ret;
  507. }
  508. static sense_reason_t
  509. sbc_compare_and_write(struct se_cmd *cmd)
  510. {
  511. struct sbc_ops *ops = cmd->protocol_data;
  512. struct se_device *dev = cmd->se_dev;
  513. sense_reason_t ret;
  514. int rc;
  515. /*
  516. * Submit the READ first for COMPARE_AND_WRITE to perform the
  517. * comparision using SGLs at cmd->t_bidi_data_sg..
  518. */
  519. rc = down_interruptible(&dev->caw_sem);
  520. if (rc != 0) {
  521. cmd->transport_complete_callback = NULL;
  522. return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
  523. }
  524. /*
  525. * Reset cmd->data_length to individual block_size in order to not
  526. * confuse backend drivers that depend on this value matching the
  527. * size of the I/O being submitted.
  528. */
  529. cmd->data_length = cmd->t_task_nolb * dev->dev_attrib.block_size;
  530. ret = ops->execute_rw(cmd, cmd->t_bidi_data_sg, cmd->t_bidi_data_nents,
  531. DMA_FROM_DEVICE);
  532. if (ret) {
  533. cmd->transport_complete_callback = NULL;
  534. up(&dev->caw_sem);
  535. return ret;
  536. }
  537. /*
  538. * Unlock of dev->caw_sem to occur in compare_and_write_callback()
  539. * upon MISCOMPARE, or in compare_and_write_done() upon completion
  540. * of WRITE instance user-data.
  541. */
  542. return TCM_NO_SENSE;
  543. }
  544. static int
  545. sbc_set_prot_op_checks(u8 protect, bool fabric_prot, enum target_prot_type prot_type,
  546. bool is_write, struct se_cmd *cmd)
  547. {
  548. if (is_write) {
  549. cmd->prot_op = fabric_prot ? TARGET_PROT_DOUT_STRIP :
  550. protect ? TARGET_PROT_DOUT_PASS :
  551. TARGET_PROT_DOUT_INSERT;
  552. switch (protect) {
  553. case 0x0:
  554. case 0x3:
  555. cmd->prot_checks = 0;
  556. break;
  557. case 0x1:
  558. case 0x5:
  559. cmd->prot_checks = TARGET_DIF_CHECK_GUARD;
  560. if (prot_type == TARGET_DIF_TYPE1_PROT)
  561. cmd->prot_checks |= TARGET_DIF_CHECK_REFTAG;
  562. break;
  563. case 0x2:
  564. if (prot_type == TARGET_DIF_TYPE1_PROT)
  565. cmd->prot_checks = TARGET_DIF_CHECK_REFTAG;
  566. break;
  567. case 0x4:
  568. cmd->prot_checks = TARGET_DIF_CHECK_GUARD;
  569. break;
  570. default:
  571. pr_err("Unsupported protect field %d\n", protect);
  572. return -EINVAL;
  573. }
  574. } else {
  575. cmd->prot_op = fabric_prot ? TARGET_PROT_DIN_INSERT :
  576. protect ? TARGET_PROT_DIN_PASS :
  577. TARGET_PROT_DIN_STRIP;
  578. switch (protect) {
  579. case 0x0:
  580. case 0x1:
  581. case 0x5:
  582. cmd->prot_checks = TARGET_DIF_CHECK_GUARD;
  583. if (prot_type == TARGET_DIF_TYPE1_PROT)
  584. cmd->prot_checks |= TARGET_DIF_CHECK_REFTAG;
  585. break;
  586. case 0x2:
  587. if (prot_type == TARGET_DIF_TYPE1_PROT)
  588. cmd->prot_checks = TARGET_DIF_CHECK_REFTAG;
  589. break;
  590. case 0x3:
  591. cmd->prot_checks = 0;
  592. break;
  593. case 0x4:
  594. cmd->prot_checks = TARGET_DIF_CHECK_GUARD;
  595. break;
  596. default:
  597. pr_err("Unsupported protect field %d\n", protect);
  598. return -EINVAL;
  599. }
  600. }
  601. return 0;
  602. }
  603. static sense_reason_t
  604. sbc_check_prot(struct se_device *dev, struct se_cmd *cmd, unsigned char protect,
  605. u32 sectors, bool is_write)
  606. {
  607. int sp_ops = cmd->se_sess->sup_prot_ops;
  608. int pi_prot_type = dev->dev_attrib.pi_prot_type;
  609. bool fabric_prot = false;
  610. if (!cmd->t_prot_sg || !cmd->t_prot_nents) {
  611. if (unlikely(protect &&
  612. !dev->dev_attrib.pi_prot_type && !cmd->se_sess->sess_prot_type)) {
  613. pr_err("CDB contains protect bit, but device + fabric does"
  614. " not advertise PROTECT=1 feature bit\n");
  615. return TCM_INVALID_CDB_FIELD;
  616. }
  617. if (cmd->prot_pto)
  618. return TCM_NO_SENSE;
  619. }
  620. switch (dev->dev_attrib.pi_prot_type) {
  621. case TARGET_DIF_TYPE3_PROT:
  622. cmd->reftag_seed = 0xffffffff;
  623. break;
  624. case TARGET_DIF_TYPE2_PROT:
  625. if (protect)
  626. return TCM_INVALID_CDB_FIELD;
  627. cmd->reftag_seed = cmd->t_task_lba;
  628. break;
  629. case TARGET_DIF_TYPE1_PROT:
  630. cmd->reftag_seed = cmd->t_task_lba;
  631. break;
  632. case TARGET_DIF_TYPE0_PROT:
  633. /*
  634. * See if the fabric supports T10-PI, and the session has been
  635. * configured to allow export PROTECT=1 feature bit with backend
  636. * devices that don't support T10-PI.
  637. */
  638. fabric_prot = is_write ?
  639. !!(sp_ops & (TARGET_PROT_DOUT_PASS | TARGET_PROT_DOUT_STRIP)) :
  640. !!(sp_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DIN_INSERT));
  641. if (fabric_prot && cmd->se_sess->sess_prot_type) {
  642. pi_prot_type = cmd->se_sess->sess_prot_type;
  643. break;
  644. }
  645. if (!protect)
  646. return TCM_NO_SENSE;
  647. fallthrough;
  648. default:
  649. pr_err("Unable to determine pi_prot_type for CDB: 0x%02x "
  650. "PROTECT: 0x%02x\n", cmd->t_task_cdb[0], protect);
  651. return TCM_INVALID_CDB_FIELD;
  652. }
  653. if (sbc_set_prot_op_checks(protect, fabric_prot, pi_prot_type, is_write, cmd))
  654. return TCM_INVALID_CDB_FIELD;
  655. cmd->prot_type = pi_prot_type;
  656. cmd->prot_length = dev->prot_length * sectors;
  657. /**
  658. * In case protection information exists over the wire
  659. * we modify command data length to describe pure data.
  660. * The actual transfer length is data length + protection
  661. * length
  662. **/
  663. if (protect)
  664. cmd->data_length = sectors * dev->dev_attrib.block_size;
  665. pr_debug("%s: prot_type=%d, data_length=%d, prot_length=%d "
  666. "prot_op=%d prot_checks=%d\n",
  667. __func__, cmd->prot_type, cmd->data_length, cmd->prot_length,
  668. cmd->prot_op, cmd->prot_checks);
  669. return TCM_NO_SENSE;
  670. }
  671. static int
  672. sbc_check_dpofua(struct se_device *dev, struct se_cmd *cmd, unsigned char *cdb)
  673. {
  674. if (cdb[1] & 0x10) {
  675. /* see explanation in spc_emulate_modesense */
  676. if (!target_check_fua(dev)) {
  677. pr_err("Got CDB: 0x%02x with DPO bit set, but device"
  678. " does not advertise support for DPO\n", cdb[0]);
  679. return -EINVAL;
  680. }
  681. }
  682. if (cdb[1] & 0x8) {
  683. if (!target_check_fua(dev)) {
  684. pr_err("Got CDB: 0x%02x with FUA bit set, but device"
  685. " does not advertise support for FUA write\n",
  686. cdb[0]);
  687. return -EINVAL;
  688. }
  689. cmd->se_cmd_flags |= SCF_FUA;
  690. }
  691. return 0;
  692. }
  693. sense_reason_t
  694. sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
  695. {
  696. struct se_device *dev = cmd->se_dev;
  697. unsigned char *cdb = cmd->t_task_cdb;
  698. unsigned int size;
  699. u32 sectors = 0;
  700. sense_reason_t ret;
  701. cmd->protocol_data = ops;
  702. switch (cdb[0]) {
  703. case READ_6:
  704. sectors = transport_get_sectors_6(cdb);
  705. cmd->t_task_lba = transport_lba_21(cdb);
  706. cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
  707. cmd->execute_cmd = sbc_execute_rw;
  708. break;
  709. case READ_10:
  710. sectors = transport_get_sectors_10(cdb);
  711. cmd->t_task_lba = transport_lba_32(cdb);
  712. if (sbc_check_dpofua(dev, cmd, cdb))
  713. return TCM_INVALID_CDB_FIELD;
  714. ret = sbc_check_prot(dev, cmd, cdb[1] >> 5, sectors, false);
  715. if (ret)
  716. return ret;
  717. cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
  718. cmd->execute_cmd = sbc_execute_rw;
  719. break;
  720. case READ_12:
  721. sectors = transport_get_sectors_12(cdb);
  722. cmd->t_task_lba = transport_lba_32(cdb);
  723. if (sbc_check_dpofua(dev, cmd, cdb))
  724. return TCM_INVALID_CDB_FIELD;
  725. ret = sbc_check_prot(dev, cmd, cdb[1] >> 5, sectors, false);
  726. if (ret)
  727. return ret;
  728. cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
  729. cmd->execute_cmd = sbc_execute_rw;
  730. break;
  731. case READ_16:
  732. sectors = transport_get_sectors_16(cdb);
  733. cmd->t_task_lba = transport_lba_64(cdb);
  734. if (sbc_check_dpofua(dev, cmd, cdb))
  735. return TCM_INVALID_CDB_FIELD;
  736. ret = sbc_check_prot(dev, cmd, cdb[1] >> 5, sectors, false);
  737. if (ret)
  738. return ret;
  739. cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
  740. cmd->execute_cmd = sbc_execute_rw;
  741. break;
  742. case WRITE_6:
  743. sectors = transport_get_sectors_6(cdb);
  744. cmd->t_task_lba = transport_lba_21(cdb);
  745. cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
  746. cmd->execute_cmd = sbc_execute_rw;
  747. break;
  748. case WRITE_10:
  749. case WRITE_VERIFY:
  750. sectors = transport_get_sectors_10(cdb);
  751. cmd->t_task_lba = transport_lba_32(cdb);
  752. if (sbc_check_dpofua(dev, cmd, cdb))
  753. return TCM_INVALID_CDB_FIELD;
  754. ret = sbc_check_prot(dev, cmd, cdb[1] >> 5, sectors, true);
  755. if (ret)
  756. return ret;
  757. cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
  758. cmd->execute_cmd = sbc_execute_rw;
  759. break;
  760. case WRITE_12:
  761. sectors = transport_get_sectors_12(cdb);
  762. cmd->t_task_lba = transport_lba_32(cdb);
  763. if (sbc_check_dpofua(dev, cmd, cdb))
  764. return TCM_INVALID_CDB_FIELD;
  765. ret = sbc_check_prot(dev, cmd, cdb[1] >> 5, sectors, true);
  766. if (ret)
  767. return ret;
  768. cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
  769. cmd->execute_cmd = sbc_execute_rw;
  770. break;
  771. case WRITE_16:
  772. case WRITE_VERIFY_16:
  773. sectors = transport_get_sectors_16(cdb);
  774. cmd->t_task_lba = transport_lba_64(cdb);
  775. if (sbc_check_dpofua(dev, cmd, cdb))
  776. return TCM_INVALID_CDB_FIELD;
  777. ret = sbc_check_prot(dev, cmd, cdb[1] >> 5, sectors, true);
  778. if (ret)
  779. return ret;
  780. cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
  781. cmd->execute_cmd = sbc_execute_rw;
  782. break;
  783. case XDWRITEREAD_10:
  784. if (cmd->data_direction != DMA_TO_DEVICE ||
  785. !(cmd->se_cmd_flags & SCF_BIDI))
  786. return TCM_INVALID_CDB_FIELD;
  787. sectors = transport_get_sectors_10(cdb);
  788. if (sbc_check_dpofua(dev, cmd, cdb))
  789. return TCM_INVALID_CDB_FIELD;
  790. cmd->t_task_lba = transport_lba_32(cdb);
  791. cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
  792. /*
  793. * Setup BIDI XOR callback to be run after I/O completion.
  794. */
  795. cmd->execute_cmd = sbc_execute_rw;
  796. cmd->transport_complete_callback = &xdreadwrite_callback;
  797. break;
  798. case VARIABLE_LENGTH_CMD:
  799. {
  800. u16 service_action = get_unaligned_be16(&cdb[8]);
  801. switch (service_action) {
  802. case XDWRITEREAD_32:
  803. sectors = transport_get_sectors_32(cdb);
  804. if (sbc_check_dpofua(dev, cmd, cdb))
  805. return TCM_INVALID_CDB_FIELD;
  806. /*
  807. * Use WRITE_32 and READ_32 opcodes for the emulated
  808. * XDWRITE_READ_32 logic.
  809. */
  810. cmd->t_task_lba = transport_lba_64_ext(cdb);
  811. cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
  812. /*
  813. * Setup BIDI XOR callback to be run during after I/O
  814. * completion.
  815. */
  816. cmd->execute_cmd = sbc_execute_rw;
  817. cmd->transport_complete_callback = &xdreadwrite_callback;
  818. break;
  819. case WRITE_SAME_32:
  820. sectors = transport_get_sectors_32(cdb);
  821. if (!sectors) {
  822. pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not"
  823. " supported\n");
  824. return TCM_INVALID_CDB_FIELD;
  825. }
  826. size = sbc_get_size(cmd, 1);
  827. cmd->t_task_lba = get_unaligned_be64(&cdb[12]);
  828. ret = sbc_setup_write_same(cmd, cdb[10], ops);
  829. if (ret)
  830. return ret;
  831. break;
  832. default:
  833. pr_err("VARIABLE_LENGTH_CMD service action"
  834. " 0x%04x not supported\n", service_action);
  835. return TCM_UNSUPPORTED_SCSI_OPCODE;
  836. }
  837. break;
  838. }
  839. case COMPARE_AND_WRITE:
  840. if (!dev->dev_attrib.emulate_caw) {
  841. pr_err_ratelimited("se_device %s/%s (vpd_unit_serial %s) reject COMPARE_AND_WRITE\n",
  842. dev->se_hba->backend->ops->name,
  843. config_item_name(&dev->dev_group.cg_item),
  844. dev->t10_wwn.unit_serial);
  845. return TCM_UNSUPPORTED_SCSI_OPCODE;
  846. }
  847. sectors = cdb[13];
  848. /*
  849. * Currently enforce COMPARE_AND_WRITE for a single sector
  850. */
  851. if (sectors > 1) {
  852. pr_err("COMPARE_AND_WRITE contains NoLB: %u greater"
  853. " than 1\n", sectors);
  854. return TCM_INVALID_CDB_FIELD;
  855. }
  856. if (sbc_check_dpofua(dev, cmd, cdb))
  857. return TCM_INVALID_CDB_FIELD;
  858. /*
  859. * Double size because we have two buffers, note that
  860. * zero is not an error..
  861. */
  862. size = 2 * sbc_get_size(cmd, sectors);
  863. cmd->t_task_lba = get_unaligned_be64(&cdb[2]);
  864. cmd->t_task_nolb = sectors;
  865. cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB | SCF_COMPARE_AND_WRITE;
  866. cmd->execute_cmd = sbc_compare_and_write;
  867. cmd->transport_complete_callback = compare_and_write_callback;
  868. break;
  869. case READ_CAPACITY:
  870. size = READ_CAP_LEN;
  871. cmd->execute_cmd = sbc_emulate_readcapacity;
  872. break;
  873. case SERVICE_ACTION_IN_16:
  874. switch (cmd->t_task_cdb[1] & 0x1f) {
  875. case SAI_READ_CAPACITY_16:
  876. cmd->execute_cmd = sbc_emulate_readcapacity_16;
  877. break;
  878. case SAI_REPORT_REFERRALS:
  879. cmd->execute_cmd = target_emulate_report_referrals;
  880. break;
  881. default:
  882. pr_err("Unsupported SA: 0x%02x\n",
  883. cmd->t_task_cdb[1] & 0x1f);
  884. return TCM_INVALID_CDB_FIELD;
  885. }
  886. size = get_unaligned_be32(&cdb[10]);
  887. break;
  888. case SYNCHRONIZE_CACHE:
  889. case SYNCHRONIZE_CACHE_16:
  890. if (cdb[0] == SYNCHRONIZE_CACHE) {
  891. sectors = transport_get_sectors_10(cdb);
  892. cmd->t_task_lba = transport_lba_32(cdb);
  893. } else {
  894. sectors = transport_get_sectors_16(cdb);
  895. cmd->t_task_lba = transport_lba_64(cdb);
  896. }
  897. if (ops->execute_sync_cache) {
  898. cmd->execute_cmd = ops->execute_sync_cache;
  899. goto check_lba;
  900. }
  901. size = 0;
  902. cmd->execute_cmd = sbc_emulate_noop;
  903. break;
  904. case UNMAP:
  905. if (!ops->execute_unmap)
  906. return TCM_UNSUPPORTED_SCSI_OPCODE;
  907. if (!dev->dev_attrib.emulate_tpu) {
  908. pr_err("Got UNMAP, but backend device has"
  909. " emulate_tpu disabled\n");
  910. return TCM_UNSUPPORTED_SCSI_OPCODE;
  911. }
  912. size = get_unaligned_be16(&cdb[7]);
  913. cmd->execute_cmd = sbc_execute_unmap;
  914. break;
  915. case WRITE_SAME_16:
  916. sectors = transport_get_sectors_16(cdb);
  917. if (!sectors) {
  918. pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
  919. return TCM_INVALID_CDB_FIELD;
  920. }
  921. size = sbc_get_size(cmd, 1);
  922. cmd->t_task_lba = get_unaligned_be64(&cdb[2]);
  923. ret = sbc_setup_write_same(cmd, cdb[1], ops);
  924. if (ret)
  925. return ret;
  926. break;
  927. case WRITE_SAME:
  928. sectors = transport_get_sectors_10(cdb);
  929. if (!sectors) {
  930. pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
  931. return TCM_INVALID_CDB_FIELD;
  932. }
  933. size = sbc_get_size(cmd, 1);
  934. cmd->t_task_lba = get_unaligned_be32(&cdb[2]);
  935. /*
  936. * Follow sbcr26 with WRITE_SAME (10) and check for the existence
  937. * of byte 1 bit 3 UNMAP instead of original reserved field
  938. */
  939. ret = sbc_setup_write_same(cmd, cdb[1], ops);
  940. if (ret)
  941. return ret;
  942. break;
  943. case VERIFY:
  944. case VERIFY_16:
  945. size = 0;
  946. if (cdb[0] == VERIFY) {
  947. sectors = transport_get_sectors_10(cdb);
  948. cmd->t_task_lba = transport_lba_32(cdb);
  949. } else {
  950. sectors = transport_get_sectors_16(cdb);
  951. cmd->t_task_lba = transport_lba_64(cdb);
  952. }
  953. cmd->execute_cmd = sbc_emulate_noop;
  954. goto check_lba;
  955. case REZERO_UNIT:
  956. case SEEK_6:
  957. case SEEK_10:
  958. /*
  959. * There are still clients out there which use these old SCSI-2
  960. * commands. This mainly happens when running VMs with legacy
  961. * guest systems, connected via SCSI command pass-through to
  962. * iSCSI targets. Make them happy and return status GOOD.
  963. */
  964. size = 0;
  965. cmd->execute_cmd = sbc_emulate_noop;
  966. break;
  967. case START_STOP:
  968. size = 0;
  969. cmd->execute_cmd = sbc_emulate_startstop;
  970. break;
  971. default:
  972. ret = spc_parse_cdb(cmd, &size);
  973. if (ret)
  974. return ret;
  975. }
  976. /* reject any command that we don't have a handler for */
  977. if (!cmd->execute_cmd)
  978. return TCM_UNSUPPORTED_SCSI_OPCODE;
  979. if (cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) {
  980. unsigned long long end_lba;
  981. check_lba:
  982. end_lba = dev->transport->get_blocks(dev) + 1;
  983. if (((cmd->t_task_lba + sectors) < cmd->t_task_lba) ||
  984. ((cmd->t_task_lba + sectors) > end_lba)) {
  985. pr_err("cmd exceeds last lba %llu "
  986. "(lba %llu, sectors %u)\n",
  987. end_lba, cmd->t_task_lba, sectors);
  988. return TCM_ADDRESS_OUT_OF_RANGE;
  989. }
  990. if (!(cmd->se_cmd_flags & SCF_COMPARE_AND_WRITE))
  991. size = sbc_get_size(cmd, sectors);
  992. }
  993. return target_cmd_size_check(cmd, size);
  994. }
  995. EXPORT_SYMBOL(sbc_parse_cdb);
  996. u32 sbc_get_device_type(struct se_device *dev)
  997. {
  998. return TYPE_DISK;
  999. }
  1000. EXPORT_SYMBOL(sbc_get_device_type);
  1001. static sense_reason_t
  1002. sbc_execute_unmap(struct se_cmd *cmd)
  1003. {
  1004. struct sbc_ops *ops = cmd->protocol_data;
  1005. struct se_device *dev = cmd->se_dev;
  1006. unsigned char *buf, *ptr = NULL;
  1007. sector_t lba;
  1008. int size;
  1009. u32 range;
  1010. sense_reason_t ret = 0;
  1011. int dl, bd_dl;
  1012. /* We never set ANC_SUP */
  1013. if (cmd->t_task_cdb[1])
  1014. return TCM_INVALID_CDB_FIELD;
  1015. if (cmd->data_length == 0) {
  1016. target_complete_cmd(cmd, SAM_STAT_GOOD);
  1017. return 0;
  1018. }
  1019. if (cmd->data_length < 8) {
  1020. pr_warn("UNMAP parameter list length %u too small\n",
  1021. cmd->data_length);
  1022. return TCM_PARAMETER_LIST_LENGTH_ERROR;
  1023. }
  1024. buf = transport_kmap_data_sg(cmd);
  1025. if (!buf)
  1026. return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
  1027. dl = get_unaligned_be16(&buf[0]);
  1028. bd_dl = get_unaligned_be16(&buf[2]);
  1029. size = cmd->data_length - 8;
  1030. if (bd_dl > size)
  1031. pr_warn("UNMAP parameter list length %u too small, ignoring bd_dl %u\n",
  1032. cmd->data_length, bd_dl);
  1033. else
  1034. size = bd_dl;
  1035. if (size / 16 > dev->dev_attrib.max_unmap_block_desc_count) {
  1036. ret = TCM_INVALID_PARAMETER_LIST;
  1037. goto err;
  1038. }
  1039. /* First UNMAP block descriptor starts at 8 byte offset */
  1040. ptr = &buf[8];
  1041. pr_debug("UNMAP: Sub: %s Using dl: %u bd_dl: %u size: %u"
  1042. " ptr: %p\n", dev->transport->name, dl, bd_dl, size, ptr);
  1043. while (size >= 16) {
  1044. lba = get_unaligned_be64(&ptr[0]);
  1045. range = get_unaligned_be32(&ptr[8]);
  1046. pr_debug("UNMAP: Using lba: %llu and range: %u\n",
  1047. (unsigned long long)lba, range);
  1048. if (range > dev->dev_attrib.max_unmap_lba_count) {
  1049. ret = TCM_INVALID_PARAMETER_LIST;
  1050. goto err;
  1051. }
  1052. if (lba + range > dev->transport->get_blocks(dev) + 1) {
  1053. ret = TCM_ADDRESS_OUT_OF_RANGE;
  1054. goto err;
  1055. }
  1056. if (range) {
  1057. ret = ops->execute_unmap(cmd, lba, range);
  1058. if (ret)
  1059. goto err;
  1060. }
  1061. ptr += 16;
  1062. size -= 16;
  1063. }
  1064. err:
  1065. transport_kunmap_data_sg(cmd);
  1066. if (!ret)
  1067. target_complete_cmd(cmd, GOOD);
  1068. return ret;
  1069. }
  1070. void
  1071. sbc_dif_generate(struct se_cmd *cmd)
  1072. {
  1073. struct se_device *dev = cmd->se_dev;
  1074. struct t10_pi_tuple *sdt;
  1075. struct scatterlist *dsg = cmd->t_data_sg, *psg;
  1076. sector_t sector = cmd->t_task_lba;
  1077. void *daddr, *paddr;
  1078. int i, j, offset = 0;
  1079. unsigned int block_size = dev->dev_attrib.block_size;
  1080. for_each_sg(cmd->t_prot_sg, psg, cmd->t_prot_nents, i) {
  1081. paddr = kmap_atomic(sg_page(psg)) + psg->offset;
  1082. daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
  1083. for (j = 0; j < psg->length;
  1084. j += sizeof(*sdt)) {
  1085. __u16 crc;
  1086. unsigned int avail;
  1087. if (offset >= dsg->length) {
  1088. offset -= dsg->length;
  1089. kunmap_atomic(daddr - dsg->offset);
  1090. dsg = sg_next(dsg);
  1091. if (!dsg) {
  1092. kunmap_atomic(paddr - psg->offset);
  1093. return;
  1094. }
  1095. daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
  1096. }
  1097. sdt = paddr + j;
  1098. avail = min(block_size, dsg->length - offset);
  1099. crc = crc_t10dif(daddr + offset, avail);
  1100. if (avail < block_size) {
  1101. kunmap_atomic(daddr - dsg->offset);
  1102. dsg = sg_next(dsg);
  1103. if (!dsg) {
  1104. kunmap_atomic(paddr - psg->offset);
  1105. return;
  1106. }
  1107. daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
  1108. offset = block_size - avail;
  1109. crc = crc_t10dif_update(crc, daddr, offset);
  1110. } else {
  1111. offset += block_size;
  1112. }
  1113. sdt->guard_tag = cpu_to_be16(crc);
  1114. if (cmd->prot_type == TARGET_DIF_TYPE1_PROT)
  1115. sdt->ref_tag = cpu_to_be32(sector & 0xffffffff);
  1116. sdt->app_tag = 0;
  1117. pr_debug("DIF %s INSERT sector: %llu guard_tag: 0x%04x"
  1118. " app_tag: 0x%04x ref_tag: %u\n",
  1119. (cmd->data_direction == DMA_TO_DEVICE) ?
  1120. "WRITE" : "READ", (unsigned long long)sector,
  1121. sdt->guard_tag, sdt->app_tag,
  1122. be32_to_cpu(sdt->ref_tag));
  1123. sector++;
  1124. }
  1125. kunmap_atomic(daddr - dsg->offset);
  1126. kunmap_atomic(paddr - psg->offset);
  1127. }
  1128. }
  1129. static sense_reason_t
  1130. sbc_dif_v1_verify(struct se_cmd *cmd, struct t10_pi_tuple *sdt,
  1131. __u16 crc, sector_t sector, unsigned int ei_lba)
  1132. {
  1133. __be16 csum;
  1134. if (!(cmd->prot_checks & TARGET_DIF_CHECK_GUARD))
  1135. goto check_ref;
  1136. csum = cpu_to_be16(crc);
  1137. if (sdt->guard_tag != csum) {
  1138. pr_err("DIFv1 checksum failed on sector %llu guard tag 0x%04x"
  1139. " csum 0x%04x\n", (unsigned long long)sector,
  1140. be16_to_cpu(sdt->guard_tag), be16_to_cpu(csum));
  1141. return TCM_LOGICAL_BLOCK_GUARD_CHECK_FAILED;
  1142. }
  1143. check_ref:
  1144. if (!(cmd->prot_checks & TARGET_DIF_CHECK_REFTAG))
  1145. return 0;
  1146. if (cmd->prot_type == TARGET_DIF_TYPE1_PROT &&
  1147. be32_to_cpu(sdt->ref_tag) != (sector & 0xffffffff)) {
  1148. pr_err("DIFv1 Type 1 reference failed on sector: %llu tag: 0x%08x"
  1149. " sector MSB: 0x%08x\n", (unsigned long long)sector,
  1150. be32_to_cpu(sdt->ref_tag), (u32)(sector & 0xffffffff));
  1151. return TCM_LOGICAL_BLOCK_REF_TAG_CHECK_FAILED;
  1152. }
  1153. if (cmd->prot_type == TARGET_DIF_TYPE2_PROT &&
  1154. be32_to_cpu(sdt->ref_tag) != ei_lba) {
  1155. pr_err("DIFv1 Type 2 reference failed on sector: %llu tag: 0x%08x"
  1156. " ei_lba: 0x%08x\n", (unsigned long long)sector,
  1157. be32_to_cpu(sdt->ref_tag), ei_lba);
  1158. return TCM_LOGICAL_BLOCK_REF_TAG_CHECK_FAILED;
  1159. }
  1160. return 0;
  1161. }
  1162. void sbc_dif_copy_prot(struct se_cmd *cmd, unsigned int sectors, bool read,
  1163. struct scatterlist *sg, int sg_off)
  1164. {
  1165. struct se_device *dev = cmd->se_dev;
  1166. struct scatterlist *psg;
  1167. void *paddr, *addr;
  1168. unsigned int i, len, left;
  1169. unsigned int offset = sg_off;
  1170. if (!sg)
  1171. return;
  1172. left = sectors * dev->prot_length;
  1173. for_each_sg(cmd->t_prot_sg, psg, cmd->t_prot_nents, i) {
  1174. unsigned int psg_len, copied = 0;
  1175. paddr = kmap_atomic(sg_page(psg)) + psg->offset;
  1176. psg_len = min(left, psg->length);
  1177. while (psg_len) {
  1178. len = min(psg_len, sg->length - offset);
  1179. addr = kmap_atomic(sg_page(sg)) + sg->offset + offset;
  1180. if (read)
  1181. memcpy(paddr + copied, addr, len);
  1182. else
  1183. memcpy(addr, paddr + copied, len);
  1184. left -= len;
  1185. offset += len;
  1186. copied += len;
  1187. psg_len -= len;
  1188. kunmap_atomic(addr - sg->offset - offset);
  1189. if (offset >= sg->length) {
  1190. sg = sg_next(sg);
  1191. offset = 0;
  1192. }
  1193. }
  1194. kunmap_atomic(paddr - psg->offset);
  1195. }
  1196. }
  1197. EXPORT_SYMBOL(sbc_dif_copy_prot);
  1198. sense_reason_t
  1199. sbc_dif_verify(struct se_cmd *cmd, sector_t start, unsigned int sectors,
  1200. unsigned int ei_lba, struct scatterlist *psg, int psg_off)
  1201. {
  1202. struct se_device *dev = cmd->se_dev;
  1203. struct t10_pi_tuple *sdt;
  1204. struct scatterlist *dsg = cmd->t_data_sg;
  1205. sector_t sector = start;
  1206. void *daddr, *paddr;
  1207. int i;
  1208. sense_reason_t rc;
  1209. int dsg_off = 0;
  1210. unsigned int block_size = dev->dev_attrib.block_size;
  1211. for (; psg && sector < start + sectors; psg = sg_next(psg)) {
  1212. paddr = kmap_atomic(sg_page(psg)) + psg->offset;
  1213. daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
  1214. for (i = psg_off; i < psg->length &&
  1215. sector < start + sectors;
  1216. i += sizeof(*sdt)) {
  1217. __u16 crc;
  1218. unsigned int avail;
  1219. if (dsg_off >= dsg->length) {
  1220. dsg_off -= dsg->length;
  1221. kunmap_atomic(daddr - dsg->offset);
  1222. dsg = sg_next(dsg);
  1223. if (!dsg) {
  1224. kunmap_atomic(paddr - psg->offset);
  1225. return 0;
  1226. }
  1227. daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
  1228. }
  1229. sdt = paddr + i;
  1230. pr_debug("DIF READ sector: %llu guard_tag: 0x%04x"
  1231. " app_tag: 0x%04x ref_tag: %u\n",
  1232. (unsigned long long)sector, sdt->guard_tag,
  1233. sdt->app_tag, be32_to_cpu(sdt->ref_tag));
  1234. if (sdt->app_tag == T10_PI_APP_ESCAPE) {
  1235. dsg_off += block_size;
  1236. goto next;
  1237. }
  1238. avail = min(block_size, dsg->length - dsg_off);
  1239. crc = crc_t10dif(daddr + dsg_off, avail);
  1240. if (avail < block_size) {
  1241. kunmap_atomic(daddr - dsg->offset);
  1242. dsg = sg_next(dsg);
  1243. if (!dsg) {
  1244. kunmap_atomic(paddr - psg->offset);
  1245. return 0;
  1246. }
  1247. daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
  1248. dsg_off = block_size - avail;
  1249. crc = crc_t10dif_update(crc, daddr, dsg_off);
  1250. } else {
  1251. dsg_off += block_size;
  1252. }
  1253. rc = sbc_dif_v1_verify(cmd, sdt, crc, sector, ei_lba);
  1254. if (rc) {
  1255. kunmap_atomic(daddr - dsg->offset);
  1256. kunmap_atomic(paddr - psg->offset);
  1257. cmd->bad_sector = sector;
  1258. return rc;
  1259. }
  1260. next:
  1261. sector++;
  1262. ei_lba++;
  1263. }
  1264. psg_off = 0;
  1265. kunmap_atomic(daddr - dsg->offset);
  1266. kunmap_atomic(paddr - psg->offset);
  1267. }
  1268. return 0;
  1269. }
  1270. EXPORT_SYMBOL(sbc_dif_verify);