video: tegra: nvmap: Fix print format specifier
[linux-3.10.git] / drivers / target / target_core_sbc.c
1 /*
2  * SCSI Block Commands (SBC) parsing and emulation.
3  *
4  * (c) Copyright 2002-2012 RisingTide Systems LLC.
5  *
6  * Nicholas A. Bellinger <nab@kernel.org>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21  */
22
23 #include <linux/kernel.h>
24 #include <linux/module.h>
25 #include <linux/ratelimit.h>
26 #include <asm/unaligned.h>
27 #include <scsi/scsi.h>
28
29 #include <target/target_core_base.h>
30 #include <target/target_core_backend.h>
31 #include <target/target_core_fabric.h>
32
33 #include "target_core_internal.h"
34 #include "target_core_ua.h"
35
36
37 static sense_reason_t
38 sbc_emulate_readcapacity(struct se_cmd *cmd)
39 {
40         struct se_device *dev = cmd->se_dev;
41         unsigned long long blocks_long = dev->transport->get_blocks(dev);
42         unsigned char *rbuf;
43         unsigned char buf[8];
44         u32 blocks;
45
46         if (blocks_long >= 0x00000000ffffffff)
47                 blocks = 0xffffffff;
48         else
49                 blocks = (u32)blocks_long;
50
51         buf[0] = (blocks >> 24) & 0xff;
52         buf[1] = (blocks >> 16) & 0xff;
53         buf[2] = (blocks >> 8) & 0xff;
54         buf[3] = blocks & 0xff;
55         buf[4] = (dev->dev_attrib.block_size >> 24) & 0xff;
56         buf[5] = (dev->dev_attrib.block_size >> 16) & 0xff;
57         buf[6] = (dev->dev_attrib.block_size >> 8) & 0xff;
58         buf[7] = dev->dev_attrib.block_size & 0xff;
59
60         rbuf = transport_kmap_data_sg(cmd);
61         if (rbuf) {
62                 memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length));
63                 transport_kunmap_data_sg(cmd);
64         }
65
66         target_complete_cmd_with_length(cmd, GOOD, 8);
67         return 0;
68 }
69
70 static sense_reason_t
71 sbc_emulate_readcapacity_16(struct se_cmd *cmd)
72 {
73         struct se_device *dev = cmd->se_dev;
74         unsigned char *rbuf;
75         unsigned char buf[32];
76         unsigned long long blocks = dev->transport->get_blocks(dev);
77
78         memset(buf, 0, sizeof(buf));
79         buf[0] = (blocks >> 56) & 0xff;
80         buf[1] = (blocks >> 48) & 0xff;
81         buf[2] = (blocks >> 40) & 0xff;
82         buf[3] = (blocks >> 32) & 0xff;
83         buf[4] = (blocks >> 24) & 0xff;
84         buf[5] = (blocks >> 16) & 0xff;
85         buf[6] = (blocks >> 8) & 0xff;
86         buf[7] = blocks & 0xff;
87         buf[8] = (dev->dev_attrib.block_size >> 24) & 0xff;
88         buf[9] = (dev->dev_attrib.block_size >> 16) & 0xff;
89         buf[10] = (dev->dev_attrib.block_size >> 8) & 0xff;
90         buf[11] = dev->dev_attrib.block_size & 0xff;
91         /*
92          * Set Thin Provisioning Enable bit following sbc3r22 in section
93          * READ CAPACITY (16) byte 14 if emulate_tpu or emulate_tpws is enabled.
94          */
95         if (dev->dev_attrib.emulate_tpu || dev->dev_attrib.emulate_tpws)
96                 buf[14] = 0x80;
97
98         rbuf = transport_kmap_data_sg(cmd);
99         if (rbuf) {
100                 memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length));
101                 transport_kunmap_data_sg(cmd);
102         }
103
104         target_complete_cmd_with_length(cmd, GOOD, 32);
105         return 0;
106 }
107
108 sector_t sbc_get_write_same_sectors(struct se_cmd *cmd)
109 {
110         u32 num_blocks;
111
112         if (cmd->t_task_cdb[0] == WRITE_SAME)
113                 num_blocks = get_unaligned_be16(&cmd->t_task_cdb[7]);
114         else if (cmd->t_task_cdb[0] == WRITE_SAME_16)
115                 num_blocks = get_unaligned_be32(&cmd->t_task_cdb[10]);
116         else /* WRITE_SAME_32 via VARIABLE_LENGTH_CMD */
117                 num_blocks = get_unaligned_be32(&cmd->t_task_cdb[28]);
118
119         /*
120          * Use the explicit range when non zero is supplied, otherwise calculate
121          * the remaining range based on ->get_blocks() - starting LBA.
122          */
123         if (num_blocks)
124                 return num_blocks;
125
126         return cmd->se_dev->transport->get_blocks(cmd->se_dev) -
127                 cmd->t_task_lba + 1;
128 }
129 EXPORT_SYMBOL(sbc_get_write_same_sectors);
130
131 static sense_reason_t
132 sbc_emulate_noop(struct se_cmd *cmd)
133 {
134         target_complete_cmd(cmd, GOOD);
135         return 0;
136 }
137
138 static inline u32 sbc_get_size(struct se_cmd *cmd, u32 sectors)
139 {
140         return cmd->se_dev->dev_attrib.block_size * sectors;
141 }
142
143 static int sbc_check_valid_sectors(struct se_cmd *cmd)
144 {
145         struct se_device *dev = cmd->se_dev;
146         unsigned long long end_lba;
147         u32 sectors;
148
149         sectors = cmd->data_length / dev->dev_attrib.block_size;
150         end_lba = dev->transport->get_blocks(dev) + 1;
151
152         if (cmd->t_task_lba + sectors > end_lba) {
153                 pr_err("target: lba %llu, sectors %u exceeds end lba %llu\n",
154                         cmd->t_task_lba, sectors, end_lba);
155                 return -EINVAL;
156         }
157
158         return 0;
159 }
160
161 static inline u32 transport_get_sectors_6(unsigned char *cdb)
162 {
163         /*
164          * Use 8-bit sector value.  SBC-3 says:
165          *
166          *   A TRANSFER LENGTH field set to zero specifies that 256
167          *   logical blocks shall be written.  Any other value
168          *   specifies the number of logical blocks that shall be
169          *   written.
170          */
171         return cdb[4] ? : 256;
172 }
173
174 static inline u32 transport_get_sectors_10(unsigned char *cdb)
175 {
176         return (u32)(cdb[7] << 8) + cdb[8];
177 }
178
179 static inline u32 transport_get_sectors_12(unsigned char *cdb)
180 {
181         return (u32)(cdb[6] << 24) + (cdb[7] << 16) + (cdb[8] << 8) + cdb[9];
182 }
183
184 static inline u32 transport_get_sectors_16(unsigned char *cdb)
185 {
186         return (u32)(cdb[10] << 24) + (cdb[11] << 16) +
187                     (cdb[12] << 8) + cdb[13];
188 }
189
190 /*
191  * Used for VARIABLE_LENGTH_CDB WRITE_32 and READ_32 variants
192  */
193 static inline u32 transport_get_sectors_32(unsigned char *cdb)
194 {
195         return (u32)(cdb[28] << 24) + (cdb[29] << 16) +
196                     (cdb[30] << 8) + cdb[31];
197
198 }
199
200 static inline u32 transport_lba_21(unsigned char *cdb)
201 {
202         return ((cdb[1] & 0x1f) << 16) | (cdb[2] << 8) | cdb[3];
203 }
204
205 static inline u32 transport_lba_32(unsigned char *cdb)
206 {
207         return (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
208 }
209
210 static inline unsigned long long transport_lba_64(unsigned char *cdb)
211 {
212         unsigned int __v1, __v2;
213
214         __v1 = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
215         __v2 = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9];
216
217         return ((unsigned long long)__v2) | (unsigned long long)__v1 << 32;
218 }
219
220 /*
221  * For VARIABLE_LENGTH_CDB w/ 32 byte extended CDBs
222  */
223 static inline unsigned long long transport_lba_64_ext(unsigned char *cdb)
224 {
225         unsigned int __v1, __v2;
226
227         __v1 = (cdb[12] << 24) | (cdb[13] << 16) | (cdb[14] << 8) | cdb[15];
228         __v2 = (cdb[16] << 24) | (cdb[17] << 16) | (cdb[18] << 8) | cdb[19];
229
230         return ((unsigned long long)__v2) | (unsigned long long)__v1 << 32;
231 }
232
233 static sense_reason_t
234 sbc_setup_write_same(struct se_cmd *cmd, unsigned char *flags, struct sbc_ops *ops)
235 {
236         unsigned int sectors = sbc_get_write_same_sectors(cmd);
237
238         if ((flags[0] & 0x04) || (flags[0] & 0x02)) {
239                 pr_err("WRITE_SAME PBDATA and LBDATA"
240                         " bits not supported for Block Discard"
241                         " Emulation\n");
242                 return TCM_UNSUPPORTED_SCSI_OPCODE;
243         }
244         if (sectors > cmd->se_dev->dev_attrib.max_write_same_len) {
245                 pr_warn("WRITE_SAME sectors: %u exceeds max_write_same_len: %u\n",
246                         sectors, cmd->se_dev->dev_attrib.max_write_same_len);
247                 return TCM_INVALID_CDB_FIELD;
248         }
249         /*
250          * Special case for WRITE_SAME w/ UNMAP=1 that ends up getting
251          * translated into block discard requests within backend code.
252          */
253         if (flags[0] & 0x08) {
254                 if (!ops->execute_write_same_unmap)
255                         return TCM_UNSUPPORTED_SCSI_OPCODE;
256
257                 cmd->execute_cmd = ops->execute_write_same_unmap;
258                 return 0;
259         }
260         if (!ops->execute_write_same)
261                 return TCM_UNSUPPORTED_SCSI_OPCODE;
262
263         cmd->execute_cmd = ops->execute_write_same;
264         return 0;
265 }
266
267 static void xdreadwrite_callback(struct se_cmd *cmd)
268 {
269         unsigned char *buf, *addr;
270         struct scatterlist *sg;
271         unsigned int offset;
272         int i;
273         int count;
274         /*
275          * From sbc3r22.pdf section 5.48 XDWRITEREAD (10) command
276          *
277          * 1) read the specified logical block(s);
278          * 2) transfer logical blocks from the data-out buffer;
279          * 3) XOR the logical blocks transferred from the data-out buffer with
280          *    the logical blocks read, storing the resulting XOR data in a buffer;
281          * 4) if the DISABLE WRITE bit is set to zero, then write the logical
282          *    blocks transferred from the data-out buffer; and
283          * 5) transfer the resulting XOR data to the data-in buffer.
284          */
285         buf = kmalloc(cmd->data_length, GFP_KERNEL);
286         if (!buf) {
287                 pr_err("Unable to allocate xor_callback buf\n");
288                 return;
289         }
290         /*
291          * Copy the scatterlist WRITE buffer located at cmd->t_data_sg
292          * into the locally allocated *buf
293          */
294         sg_copy_to_buffer(cmd->t_data_sg,
295                           cmd->t_data_nents,
296                           buf,
297                           cmd->data_length);
298
299         /*
300          * Now perform the XOR against the BIDI read memory located at
301          * cmd->t_mem_bidi_list
302          */
303
304         offset = 0;
305         for_each_sg(cmd->t_bidi_data_sg, sg, cmd->t_bidi_data_nents, count) {
306                 addr = kmap_atomic(sg_page(sg));
307                 if (!addr)
308                         goto out;
309
310                 for (i = 0; i < sg->length; i++)
311                         *(addr + sg->offset + i) ^= *(buf + offset + i);
312
313                 offset += sg->length;
314                 kunmap_atomic(addr);
315         }
316
317 out:
318         kfree(buf);
319 }
320
321 sense_reason_t
322 sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
323 {
324         struct se_device *dev = cmd->se_dev;
325         unsigned char *cdb = cmd->t_task_cdb;
326         unsigned int size;
327         u32 sectors = 0;
328         sense_reason_t ret;
329
330         switch (cdb[0]) {
331         case READ_6:
332                 sectors = transport_get_sectors_6(cdb);
333                 cmd->t_task_lba = transport_lba_21(cdb);
334                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
335                 cmd->execute_cmd = ops->execute_rw;
336                 break;
337         case READ_10:
338                 sectors = transport_get_sectors_10(cdb);
339                 cmd->t_task_lba = transport_lba_32(cdb);
340                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
341                 cmd->execute_cmd = ops->execute_rw;
342                 break;
343         case READ_12:
344                 sectors = transport_get_sectors_12(cdb);
345                 cmd->t_task_lba = transport_lba_32(cdb);
346                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
347                 cmd->execute_cmd = ops->execute_rw;
348                 break;
349         case READ_16:
350                 sectors = transport_get_sectors_16(cdb);
351                 cmd->t_task_lba = transport_lba_64(cdb);
352                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
353                 cmd->execute_cmd = ops->execute_rw;
354                 break;
355         case WRITE_6:
356                 sectors = transport_get_sectors_6(cdb);
357                 cmd->t_task_lba = transport_lba_21(cdb);
358                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
359                 cmd->execute_cmd = ops->execute_rw;
360                 break;
361         case WRITE_10:
362         case WRITE_VERIFY:
363                 sectors = transport_get_sectors_10(cdb);
364                 cmd->t_task_lba = transport_lba_32(cdb);
365                 if (cdb[1] & 0x8)
366                         cmd->se_cmd_flags |= SCF_FUA;
367                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
368                 cmd->execute_cmd = ops->execute_rw;
369                 break;
370         case WRITE_12:
371                 sectors = transport_get_sectors_12(cdb);
372                 cmd->t_task_lba = transport_lba_32(cdb);
373                 if (cdb[1] & 0x8)
374                         cmd->se_cmd_flags |= SCF_FUA;
375                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
376                 cmd->execute_cmd = ops->execute_rw;
377                 break;
378         case WRITE_16:
379                 sectors = transport_get_sectors_16(cdb);
380                 cmd->t_task_lba = transport_lba_64(cdb);
381                 if (cdb[1] & 0x8)
382                         cmd->se_cmd_flags |= SCF_FUA;
383                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
384                 cmd->execute_cmd = ops->execute_rw;
385                 break;
386         case XDWRITEREAD_10:
387                 if (cmd->data_direction != DMA_TO_DEVICE ||
388                     !(cmd->se_cmd_flags & SCF_BIDI))
389                         return TCM_INVALID_CDB_FIELD;
390                 sectors = transport_get_sectors_10(cdb);
391
392                 cmd->t_task_lba = transport_lba_32(cdb);
393                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
394
395                 /*
396                  * Setup BIDI XOR callback to be run after I/O completion.
397                  */
398                 cmd->execute_cmd = ops->execute_rw;
399                 cmd->transport_complete_callback = &xdreadwrite_callback;
400                 if (cdb[1] & 0x8)
401                         cmd->se_cmd_flags |= SCF_FUA;
402                 break;
403         case VARIABLE_LENGTH_CMD:
404         {
405                 u16 service_action = get_unaligned_be16(&cdb[8]);
406                 switch (service_action) {
407                 case XDWRITEREAD_32:
408                         sectors = transport_get_sectors_32(cdb);
409
410                         /*
411                          * Use WRITE_32 and READ_32 opcodes for the emulated
412                          * XDWRITE_READ_32 logic.
413                          */
414                         cmd->t_task_lba = transport_lba_64_ext(cdb);
415                         cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
416
417                         /*
418                          * Setup BIDI XOR callback to be run during after I/O
419                          * completion.
420                          */
421                         cmd->execute_cmd = ops->execute_rw;
422                         cmd->transport_complete_callback = &xdreadwrite_callback;
423                         if (cdb[1] & 0x8)
424                                 cmd->se_cmd_flags |= SCF_FUA;
425                         break;
426                 case WRITE_SAME_32:
427                         sectors = transport_get_sectors_32(cdb);
428                         if (!sectors) {
429                                 pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not"
430                                        " supported\n");
431                                 return TCM_INVALID_CDB_FIELD;
432                         }
433
434                         size = sbc_get_size(cmd, 1);
435                         cmd->t_task_lba = get_unaligned_be64(&cdb[12]);
436
437                         ret = sbc_setup_write_same(cmd, &cdb[10], ops);
438                         if (ret)
439                                 return ret;
440                         break;
441                 default:
442                         pr_err("VARIABLE_LENGTH_CMD service action"
443                                 " 0x%04x not supported\n", service_action);
444                         return TCM_UNSUPPORTED_SCSI_OPCODE;
445                 }
446                 break;
447         }
448         case READ_CAPACITY:
449                 size = READ_CAP_LEN;
450                 cmd->execute_cmd = sbc_emulate_readcapacity;
451                 break;
452         case SERVICE_ACTION_IN:
453                 switch (cmd->t_task_cdb[1] & 0x1f) {
454                 case SAI_READ_CAPACITY_16:
455                         cmd->execute_cmd = sbc_emulate_readcapacity_16;
456                         break;
457                 default:
458                         pr_err("Unsupported SA: 0x%02x\n",
459                                 cmd->t_task_cdb[1] & 0x1f);
460                         return TCM_INVALID_CDB_FIELD;
461                 }
462                 size = (cdb[10] << 24) | (cdb[11] << 16) |
463                        (cdb[12] << 8) | cdb[13];
464                 break;
465         case SYNCHRONIZE_CACHE:
466         case SYNCHRONIZE_CACHE_16:
467                 if (!ops->execute_sync_cache) {
468                         size = 0;
469                         cmd->execute_cmd = sbc_emulate_noop;
470                         break;
471                 }
472
473                 /*
474                  * Extract LBA and range to be flushed for emulated SYNCHRONIZE_CACHE
475                  */
476                 if (cdb[0] == SYNCHRONIZE_CACHE) {
477                         sectors = transport_get_sectors_10(cdb);
478                         cmd->t_task_lba = transport_lba_32(cdb);
479                 } else {
480                         sectors = transport_get_sectors_16(cdb);
481                         cmd->t_task_lba = transport_lba_64(cdb);
482                 }
483
484                 size = sbc_get_size(cmd, sectors);
485
486                 /*
487                  * Check to ensure that LBA + Range does not exceed past end of
488                  * device for IBLOCK and FILEIO ->do_sync_cache() backend calls
489                  */
490                 if (cmd->t_task_lba || sectors) {
491                         if (sbc_check_valid_sectors(cmd) < 0)
492                                 return TCM_ADDRESS_OUT_OF_RANGE;
493                 }
494                 cmd->execute_cmd = ops->execute_sync_cache;
495                 break;
496         case UNMAP:
497                 if (!ops->execute_unmap)
498                         return TCM_UNSUPPORTED_SCSI_OPCODE;
499
500                 size = get_unaligned_be16(&cdb[7]);
501                 cmd->execute_cmd = ops->execute_unmap;
502                 break;
503         case WRITE_SAME_16:
504                 sectors = transport_get_sectors_16(cdb);
505                 if (!sectors) {
506                         pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
507                         return TCM_INVALID_CDB_FIELD;
508                 }
509
510                 size = sbc_get_size(cmd, 1);
511                 cmd->t_task_lba = get_unaligned_be64(&cdb[2]);
512
513                 ret = sbc_setup_write_same(cmd, &cdb[1], ops);
514                 if (ret)
515                         return ret;
516                 break;
517         case WRITE_SAME:
518                 sectors = transport_get_sectors_10(cdb);
519                 if (!sectors) {
520                         pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
521                         return TCM_INVALID_CDB_FIELD;
522                 }
523
524                 size = sbc_get_size(cmd, 1);
525                 cmd->t_task_lba = get_unaligned_be32(&cdb[2]);
526
527                 /*
528                  * Follow sbcr26 with WRITE_SAME (10) and check for the existence
529                  * of byte 1 bit 3 UNMAP instead of original reserved field
530                  */
531                 ret = sbc_setup_write_same(cmd, &cdb[1], ops);
532                 if (ret)
533                         return ret;
534                 break;
535         case VERIFY:
536                 size = 0;
537                 cmd->execute_cmd = sbc_emulate_noop;
538                 break;
539         case REZERO_UNIT:
540         case SEEK_6:
541         case SEEK_10:
542                 /*
543                  * There are still clients out there which use these old SCSI-2
544                  * commands. This mainly happens when running VMs with legacy
545                  * guest systems, connected via SCSI command pass-through to
546                  * iSCSI targets. Make them happy and return status GOOD.
547                  */
548                 size = 0;
549                 cmd->execute_cmd = sbc_emulate_noop;
550                 break;
551         default:
552                 ret = spc_parse_cdb(cmd, &size);
553                 if (ret)
554                         return ret;
555         }
556
557         /* reject any command that we don't have a handler for */
558         if (!(cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) && !cmd->execute_cmd)
559                 return TCM_UNSUPPORTED_SCSI_OPCODE;
560
561         if (cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) {
562                 unsigned long long end_lba;
563
564                 end_lba = dev->transport->get_blocks(dev) + 1;
565                 if (((cmd->t_task_lba + sectors) < cmd->t_task_lba) ||
566                     ((cmd->t_task_lba + sectors) > end_lba)) {
567                         pr_err("cmd exceeds last lba %llu "
568                                 "(lba %llu, sectors %u)\n",
569                                 end_lba, cmd->t_task_lba, sectors);
570                         return TCM_INVALID_CDB_FIELD;
571                 }
572
573                 size = sbc_get_size(cmd, sectors);
574         }
575
576         return target_cmd_size_check(cmd, size);
577 }
578 EXPORT_SYMBOL(sbc_parse_cdb);
579
580 u32 sbc_get_device_type(struct se_device *dev)
581 {
582         return TYPE_DISK;
583 }
584 EXPORT_SYMBOL(sbc_get_device_type);
585
586 sense_reason_t
587 sbc_execute_unmap(struct se_cmd *cmd,
588         sense_reason_t (*do_unmap_fn)(struct se_cmd *, void *,
589                                       sector_t, sector_t),
590         void *priv)
591 {
592         struct se_device *dev = cmd->se_dev;
593         unsigned char *buf, *ptr = NULL;
594         sector_t lba;
595         int size;
596         u32 range;
597         sense_reason_t ret = 0;
598         int dl, bd_dl;
599
600         /* We never set ANC_SUP */
601         if (cmd->t_task_cdb[1])
602                 return TCM_INVALID_CDB_FIELD;
603
604         if (cmd->data_length == 0) {
605                 target_complete_cmd(cmd, SAM_STAT_GOOD);
606                 return 0;
607         }
608
609         if (cmd->data_length < 8) {
610                 pr_warn("UNMAP parameter list length %u too small\n",
611                         cmd->data_length);
612                 return TCM_PARAMETER_LIST_LENGTH_ERROR;
613         }
614
615         buf = transport_kmap_data_sg(cmd);
616         if (!buf)
617                 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
618
619         dl = get_unaligned_be16(&buf[0]);
620         bd_dl = get_unaligned_be16(&buf[2]);
621
622         size = cmd->data_length - 8;
623         if (bd_dl > size)
624                 pr_warn("UNMAP parameter list length %u too small, ignoring bd_dl %u\n",
625                         cmd->data_length, bd_dl);
626         else
627                 size = bd_dl;
628
629         if (size / 16 > dev->dev_attrib.max_unmap_block_desc_count) {
630                 ret = TCM_INVALID_PARAMETER_LIST;
631                 goto err;
632         }
633
634         /* First UNMAP block descriptor starts at 8 byte offset */
635         ptr = &buf[8];
636         pr_debug("UNMAP: Sub: %s Using dl: %u bd_dl: %u size: %u"
637                 " ptr: %p\n", dev->transport->name, dl, bd_dl, size, ptr);
638
639         while (size >= 16) {
640                 lba = get_unaligned_be64(&ptr[0]);
641                 range = get_unaligned_be32(&ptr[8]);
642                 pr_debug("UNMAP: Using lba: %llu and range: %u\n",
643                                  (unsigned long long)lba, range);
644
645                 if (range > dev->dev_attrib.max_unmap_lba_count) {
646                         ret = TCM_INVALID_PARAMETER_LIST;
647                         goto err;
648                 }
649
650                 if (lba + range > dev->transport->get_blocks(dev) + 1) {
651                         ret = TCM_ADDRESS_OUT_OF_RANGE;
652                         goto err;
653                 }
654
655                 ret = do_unmap_fn(cmd, priv, lba, range);
656                 if (ret)
657                         goto err;
658
659                 ptr += 16;
660                 size -= 16;
661         }
662
663 err:
664         transport_kunmap_data_sg(cmd);
665         if (!ret)
666                 target_complete_cmd(cmd, GOOD);
667         return ret;
668 }
669 EXPORT_SYMBOL(sbc_execute_unmap);