target: Use {get,put}_unaligned_be*() instead of open coding these functions
authorBart Van Assche <bart.vanassche@sandisk.com>
Tue, 23 May 2017 23:48:27 +0000 (16:48 -0700)
committerNicholas Bellinger <nab@linux-iscsi.org>
Fri, 7 Jul 2017 05:57:59 +0000 (22:57 -0700)
Introduce the function get_unaligned_be24(). Use {get,put}_unaligned_be*()
where appropriate. This patch does not change any functionality.

Signed-off-by: Bart Van Assche <bart.vanassche@sandisk.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Cc: Andy Grover <agrover@redhat.com>
Cc: David Disseldorp <ddiss@suse.de>
Signed-off-by: Nicholas Bellinger <nab@linux-iscsi.org>
drivers/target/target_core_alua.c
drivers/target/target_core_device.c
drivers/target/target_core_fabric_lib.c
drivers/target/target_core_pr.c
drivers/target/target_core_pscsi.c
drivers/target/target_core_sbc.c
drivers/target/target_core_spc.c
drivers/target/target_core_xcopy.c
include/target/target_core_backend.h

index fc4a9c303d559f95b1216857efd8ae6ce77b96ca..a91b7c25ffd411abba6932d0c5e6ce9556cce657 100644 (file)
@@ -205,8 +205,8 @@ target_emulate_report_target_port_groups(struct se_cmd *cmd)
                /*
                 * TARGET PORT GROUP
                 */
-               buf[off++] = ((tg_pt_gp->tg_pt_gp_id >> 8) & 0xff);
-               buf[off++] = (tg_pt_gp->tg_pt_gp_id & 0xff);
+               put_unaligned_be16(tg_pt_gp->tg_pt_gp_id, &buf[off]);
+               off += 2;
 
                off++; /* Skip over Reserved */
                /*
@@ -235,8 +235,8 @@ target_emulate_report_target_port_groups(struct se_cmd *cmd)
                        /*
                         * Set RELATIVE TARGET PORT IDENTIFIER
                         */
-                       buf[off++] = ((lun->lun_rtpi >> 8) & 0xff);
-                       buf[off++] = (lun->lun_rtpi & 0xff);
+                       put_unaligned_be16(lun->lun_rtpi, &buf[off]);
+                       off += 2;
                        rd_len += 4;
                }
                spin_unlock(&tg_pt_gp->tg_pt_gp_lock);
index 1f54b397bd57444b7149875cf89138c2c8f039e7..11c80c47b9d3e514686ae57fd1d6307101752cd4 100644 (file)
@@ -1091,19 +1091,19 @@ passthrough_parse_cdb(struct se_cmd *cmd,
              TRANSPORT_FLAG_PASSTHROUGH_PGR)) {
                if (cdb[0] == PERSISTENT_RESERVE_IN) {
                        cmd->execute_cmd = target_scsi3_emulate_pr_in;
-                       size = (cdb[7] << 8) + cdb[8];
+                       size = get_unaligned_be16(&cdb[7]);
                        return target_cmd_size_check(cmd, size);
                }
                if (cdb[0] == PERSISTENT_RESERVE_OUT) {
                        cmd->execute_cmd = target_scsi3_emulate_pr_out;
-                       size = (cdb[7] << 8) + cdb[8];
+                       size = get_unaligned_be16(&cdb[7]);
                        return target_cmd_size_check(cmd, size);
                }
 
                if (cdb[0] == RELEASE || cdb[0] == RELEASE_10) {
                        cmd->execute_cmd = target_scsi2_reservation_release;
                        if (cdb[0] == RELEASE_10)
-                               size = (cdb[7] << 8) | cdb[8];
+                               size = get_unaligned_be16(&cdb[7]);
                        else
                                size = cmd->data_length;
                        return target_cmd_size_check(cmd, size);
@@ -1111,7 +1111,7 @@ passthrough_parse_cdb(struct se_cmd *cmd,
                if (cdb[0] == RESERVE || cdb[0] == RESERVE_10) {
                        cmd->execute_cmd = target_scsi2_reservation_reserve;
                        if (cdb[0] == RESERVE_10)
-                               size = (cdb[7] << 8) | cdb[8];
+                               size = get_unaligned_be16(&cdb[7]);
                        else
                                size = cmd->data_length;
                        return target_cmd_size_check(cmd, size);
index cb6497ce4b61a81cbb9eba00bd79d0ecbc08f847..508da345b73fdb3561a434d8ed320469081ded5a 100644 (file)
@@ -34,6 +34,7 @@
 #include <linux/ctype.h>
 #include <linux/spinlock.h>
 #include <linux/export.h>
+#include <asm/unaligned.h>
 
 #include <scsi/scsi_proto.h>
 
@@ -216,8 +217,7 @@ static int iscsi_get_pr_transport_id(
        if (padding != 0)
                len += padding;
 
-       buf[2] = ((len >> 8) & 0xff);
-       buf[3] = (len & 0xff);
+       put_unaligned_be16(len, &buf[2]);
        /*
         * Increment value for total payload + header length for
         * full status descriptor
@@ -306,7 +306,7 @@ static char *iscsi_parse_pr_out_transport_id(
         */
        if (out_tid_len) {
                /* The shift works thanks to integer promotion rules */
-               add_len = (buf[2] << 8) | buf[3];
+               add_len = get_unaligned_be16(&buf[2]);
 
                tid_len = strlen(&buf[4]);
                tid_len += 4; /* Add four bytes for iSCSI Transport ID header */
index 129ca572673ceaed2aa6f4ca55d10bfcd6b1620a..9921d4d6bb4186594d5e7c95f12d88eb22f800f4 100644 (file)
@@ -1562,10 +1562,7 @@ core_scsi3_decode_spec_i_port(
         * first extract TransportID Parameter Data Length, and make sure
         * the value matches up to the SCSI expected data transfer length.
         */
-       tpdl = (buf[24] & 0xff) << 24;
-       tpdl |= (buf[25] & 0xff) << 16;
-       tpdl |= (buf[26] & 0xff) << 8;
-       tpdl |= buf[27] & 0xff;
+       tpdl = get_unaligned_be32(&buf[24]);
 
        if ((tpdl + 28) != cmd->data_length) {
                pr_err("SPC-3 PR: Illegal tpdl: %u + 28 byte header"
@@ -3221,12 +3218,8 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
                goto out_put_pr_reg;
        }
 
-       rtpi = (buf[18] & 0xff) << 8;
-       rtpi |= buf[19] & 0xff;
-       tid_len = (buf[20] & 0xff) << 24;
-       tid_len |= (buf[21] & 0xff) << 16;
-       tid_len |= (buf[22] & 0xff) << 8;
-       tid_len |= buf[23] & 0xff;
+       rtpi = get_unaligned_be16(&buf[18]);
+       tid_len = get_unaligned_be32(&buf[20]);
        transport_kunmap_data_sg(cmd);
        buf = NULL;
 
@@ -3552,16 +3545,6 @@ out_put_pr_reg:
        return ret;
 }
 
-static unsigned long long core_scsi3_extract_reservation_key(unsigned char *cdb)
-{
-       unsigned int __v1, __v2;
-
-       __v1 = (cdb[0] << 24) | (cdb[1] << 16) | (cdb[2] << 8) | cdb[3];
-       __v2 = (cdb[4] << 24) | (cdb[5] << 16) | (cdb[6] << 8) | cdb[7];
-
-       return ((unsigned long long)__v2) | (unsigned long long)__v1 << 32;
-}
-
 /*
  * See spc4r17 section 6.14 Table 170
  */
@@ -3619,8 +3602,8 @@ target_scsi3_emulate_pr_out(struct se_cmd *cmd)
        /*
         * From PERSISTENT_RESERVE_OUT parameter list (payload)
         */
-       res_key = core_scsi3_extract_reservation_key(&buf[0]);
-       sa_res_key = core_scsi3_extract_reservation_key(&buf[8]);
+       res_key = get_unaligned_be64(&buf[0]);
+       sa_res_key = get_unaligned_be64(&buf[8]);
        /*
         * REGISTER_AND_MOVE uses a different SA parameter list containing
         * SCSI TransportIDs.
@@ -3734,10 +3717,7 @@ core_scsi3_pri_read_keys(struct se_cmd *cmd)
        if (!buf)
                return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 
-       buf[0] = ((dev->t10_pr.pr_generation >> 24) & 0xff);
-       buf[1] = ((dev->t10_pr.pr_generation >> 16) & 0xff);
-       buf[2] = ((dev->t10_pr.pr_generation >> 8) & 0xff);
-       buf[3] = (dev->t10_pr.pr_generation & 0xff);
+       put_unaligned_be32(dev->t10_pr.pr_generation, buf);
 
        spin_lock(&dev->t10_pr.registration_lock);
        list_for_each_entry(pr_reg, &dev->t10_pr.registration_list,
@@ -3749,23 +3729,13 @@ core_scsi3_pri_read_keys(struct se_cmd *cmd)
                if ((add_len + 8) > (cmd->data_length - 8))
                        break;
 
-               buf[off++] = ((pr_reg->pr_res_key >> 56) & 0xff);
-               buf[off++] = ((pr_reg->pr_res_key >> 48) & 0xff);
-               buf[off++] = ((pr_reg->pr_res_key >> 40) & 0xff);
-               buf[off++] = ((pr_reg->pr_res_key >> 32) & 0xff);
-               buf[off++] = ((pr_reg->pr_res_key >> 24) & 0xff);
-               buf[off++] = ((pr_reg->pr_res_key >> 16) & 0xff);
-               buf[off++] = ((pr_reg->pr_res_key >> 8) & 0xff);
-               buf[off++] = (pr_reg->pr_res_key & 0xff);
-
+               put_unaligned_be64(pr_reg->pr_res_key, &buf[off]);
+               off += 8;
                add_len += 8;
        }
        spin_unlock(&dev->t10_pr.registration_lock);
 
-       buf[4] = ((add_len >> 24) & 0xff);
-       buf[5] = ((add_len >> 16) & 0xff);
-       buf[6] = ((add_len >> 8) & 0xff);
-       buf[7] = (add_len & 0xff);
+       put_unaligned_be32(add_len, &buf[4]);
 
        transport_kunmap_data_sg(cmd);
 
@@ -3796,10 +3766,7 @@ core_scsi3_pri_read_reservation(struct se_cmd *cmd)
        if (!buf)
                return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 
-       buf[0] = ((dev->t10_pr.pr_generation >> 24) & 0xff);
-       buf[1] = ((dev->t10_pr.pr_generation >> 16) & 0xff);
-       buf[2] = ((dev->t10_pr.pr_generation >> 8) & 0xff);
-       buf[3] = (dev->t10_pr.pr_generation & 0xff);
+       put_unaligned_be32(dev->t10_pr.pr_generation, &buf[0]);
 
        spin_lock(&dev->dev_reservation_lock);
        pr_reg = dev->dev_pr_res_holder;
@@ -3807,10 +3774,7 @@ core_scsi3_pri_read_reservation(struct se_cmd *cmd)
                /*
                 * Set the hardcoded Additional Length
                 */
-               buf[4] = ((add_len >> 24) & 0xff);
-               buf[5] = ((add_len >> 16) & 0xff);
-               buf[6] = ((add_len >> 8) & 0xff);
-               buf[7] = (add_len & 0xff);
+               put_unaligned_be32(add_len, &buf[4]);
 
                if (cmd->data_length < 22)
                        goto err;
@@ -3837,14 +3801,7 @@ core_scsi3_pri_read_reservation(struct se_cmd *cmd)
                else
                        pr_res_key = pr_reg->pr_res_key;
 
-               buf[8] = ((pr_res_key >> 56) & 0xff);
-               buf[9] = ((pr_res_key >> 48) & 0xff);
-               buf[10] = ((pr_res_key >> 40) & 0xff);
-               buf[11] = ((pr_res_key >> 32) & 0xff);
-               buf[12] = ((pr_res_key >> 24) & 0xff);
-               buf[13] = ((pr_res_key >> 16) & 0xff);
-               buf[14] = ((pr_res_key >> 8) & 0xff);
-               buf[15] = (pr_res_key & 0xff);
+               put_unaligned_be64(pr_res_key, &buf[8]);
                /*
                 * Set the SCOPE and TYPE
                 */
@@ -3882,8 +3839,7 @@ core_scsi3_pri_report_capabilities(struct se_cmd *cmd)
        if (!buf)
                return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 
-       buf[0] = ((add_len >> 8) & 0xff);
-       buf[1] = (add_len & 0xff);
+       put_unaligned_be16(add_len, &buf[0]);
        buf[2] |= 0x10; /* CRH: Compatible Reservation Hanlding bit. */
        buf[2] |= 0x08; /* SIP_C: Specify Initiator Ports Capable bit */
        buf[2] |= 0x04; /* ATP_C: All Target Ports Capable bit */
@@ -3947,10 +3903,7 @@ core_scsi3_pri_read_full_status(struct se_cmd *cmd)
        if (!buf)
                return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 
-       buf[0] = ((dev->t10_pr.pr_generation >> 24) & 0xff);
-       buf[1] = ((dev->t10_pr.pr_generation >> 16) & 0xff);
-       buf[2] = ((dev->t10_pr.pr_generation >> 8) & 0xff);
-       buf[3] = (dev->t10_pr.pr_generation & 0xff);
+       put_unaligned_be32(dev->t10_pr.pr_generation, &buf[0]);
 
        spin_lock(&dev->dev_reservation_lock);
        if (dev->dev_pr_res_holder) {
@@ -3992,14 +3945,8 @@ core_scsi3_pri_read_full_status(struct se_cmd *cmd)
                /*
                 * Set RESERVATION KEY
                 */
-               buf[off++] = ((pr_reg->pr_res_key >> 56) & 0xff);
-               buf[off++] = ((pr_reg->pr_res_key >> 48) & 0xff);
-               buf[off++] = ((pr_reg->pr_res_key >> 40) & 0xff);
-               buf[off++] = ((pr_reg->pr_res_key >> 32) & 0xff);
-               buf[off++] = ((pr_reg->pr_res_key >> 24) & 0xff);
-               buf[off++] = ((pr_reg->pr_res_key >> 16) & 0xff);
-               buf[off++] = ((pr_reg->pr_res_key >> 8) & 0xff);
-               buf[off++] = (pr_reg->pr_res_key & 0xff);
+               put_unaligned_be64(pr_reg->pr_res_key, &buf[off]);
+               off += 8;
                off += 4; /* Skip Over Reserved area */
 
                /*
@@ -4041,8 +3988,8 @@ core_scsi3_pri_read_full_status(struct se_cmd *cmd)
                if (!pr_reg->pr_reg_all_tg_pt) {
                        u16 sep_rtpi = pr_reg->tg_pt_sep_rtpi;
 
-                       buf[off++] = ((sep_rtpi >> 8) & 0xff);
-                       buf[off++] = (sep_rtpi & 0xff);
+                       put_unaligned_be16(sep_rtpi, &buf[off]);
+                       off += 2;
                } else
                        off += 2; /* Skip over RELATIVE TARGET PORT IDENTIFIER */
 
@@ -4062,10 +4009,7 @@ core_scsi3_pri_read_full_status(struct se_cmd *cmd)
                /*
                 * Set the ADDITIONAL DESCRIPTOR LENGTH
                 */
-               buf[off++] = ((desc_len >> 24) & 0xff);
-               buf[off++] = ((desc_len >> 16) & 0xff);
-               buf[off++] = ((desc_len >> 8) & 0xff);
-               buf[off++] = (desc_len & 0xff);
+               put_unaligned_be32(desc_len, &buf[off]);
                /*
                 * Size of full desctipor header minus TransportID
                 * containing $FABRIC_MOD specific) initiator device/port
@@ -4082,10 +4026,7 @@ core_scsi3_pri_read_full_status(struct se_cmd *cmd)
        /*
         * Set ADDITIONAL_LENGTH
         */
-       buf[4] = ((add_len >> 24) & 0xff);
-       buf[5] = ((add_len >> 16) & 0xff);
-       buf[6] = ((add_len >> 8) & 0xff);
-       buf[7] = (add_len & 0xff);
+       put_unaligned_be32(add_len, &buf[4]);
 
        transport_kunmap_data_sg(cmd);
 
index 3e4abb13f8ea4b46ad78de13eae74fd17ccda67a..e0be4aa3832833da778bc684119647ce65ab8649 100644 (file)
@@ -168,7 +168,7 @@ static void pscsi_tape_read_blocksize(struct se_device *dev,
        /*
         * If MODE_SENSE still returns zero, set the default value to 1024.
         */
-       sdev->sector_size = (buf[9] << 16) | (buf[10] << 8) | (buf[11]);
+       sdev->sector_size = get_unaligned_be24(&buf[9]);
 out_free:
        if (!sdev->sector_size)
                sdev->sector_size = 1024;
@@ -209,8 +209,7 @@ pscsi_get_inquiry_vpd_serial(struct scsi_device *sdev, struct t10_wwn *wwn)
        cdb[0] = INQUIRY;
        cdb[1] = 0x01; /* Query VPD */
        cdb[2] = 0x80; /* Unit Serial Number */
-       cdb[3] = (INQUIRY_VPD_SERIAL_LEN >> 8) & 0xff;
-       cdb[4] = (INQUIRY_VPD_SERIAL_LEN & 0xff);
+       put_unaligned_be16(INQUIRY_VPD_SERIAL_LEN, &cdb[3]);
 
        ret = scsi_execute_req(sdev, cdb, DMA_FROM_DEVICE, buf,
                              INQUIRY_VPD_SERIAL_LEN, NULL, HZ, 1, NULL);
@@ -245,8 +244,7 @@ pscsi_get_inquiry_vpd_device_ident(struct scsi_device *sdev,
        cdb[0] = INQUIRY;
        cdb[1] = 0x01; /* Query VPD */
        cdb[2] = 0x83; /* Device Identifier */
-       cdb[3] = (INQUIRY_VPD_DEVICE_IDENTIFIER_LEN >> 8) & 0xff;
-       cdb[4] = (INQUIRY_VPD_DEVICE_IDENTIFIER_LEN & 0xff);
+       put_unaligned_be16(INQUIRY_VPD_DEVICE_IDENTIFIER_LEN, &cdb[3]);
 
        ret = scsi_execute_req(sdev, cdb, DMA_FROM_DEVICE, buf,
                              INQUIRY_VPD_DEVICE_IDENTIFIER_LEN,
@@ -254,7 +252,7 @@ pscsi_get_inquiry_vpd_device_ident(struct scsi_device *sdev,
        if (ret)
                goto out;
 
-       page_len = (buf[2] << 8) | buf[3];
+       page_len = get_unaligned_be16(&buf[2]);
        while (page_len > 0) {
                /* Grab a pointer to the Identification descriptor */
                page_83 = &buf[off];
@@ -669,19 +667,17 @@ after_mode_sense:
                }
 
                if (cdb[0] == MODE_SELECT)
-                       bdl = (buf[3]);
+                       bdl = buf[3];
                else
-                       bdl = (buf[6] << 8) | (buf[7]);
+                       bdl = get_unaligned_be16(&buf[6]);
 
                if (!bdl)
                        goto after_mode_select;
 
                if (cdb[0] == MODE_SELECT)
-                       blocksize = (buf[9] << 16) | (buf[10] << 8) |
-                                       (buf[11]);
+                       blocksize = get_unaligned_be24(&buf[9]);
                else
-                       blocksize = (buf[13] << 16) | (buf[14] << 8) |
-                                       (buf[15]);
+                       blocksize = get_unaligned_be24(&buf[13]);
 
                sd->sector_size = blocksize;
        }
index ff4a6ec30adf5d0926b581c3e8422d9c240f6437..ca42fba882dbdd62719d35c79618bfcdc90bcb89 100644 (file)
@@ -71,14 +71,8 @@ sbc_emulate_readcapacity(struct se_cmd *cmd)
        else
                blocks = (u32)blocks_long;
 
-       buf[0] = (blocks >> 24) & 0xff;
-       buf[1] = (blocks >> 16) & 0xff;
-       buf[2] = (blocks >> 8) & 0xff;
-       buf[3] = blocks & 0xff;
-       buf[4] = (dev->dev_attrib.block_size >> 24) & 0xff;
-       buf[5] = (dev->dev_attrib.block_size >> 16) & 0xff;
-       buf[6] = (dev->dev_attrib.block_size >> 8) & 0xff;
-       buf[7] = dev->dev_attrib.block_size & 0xff;
+       put_unaligned_be32(blocks, &buf[0]);
+       put_unaligned_be32(dev->dev_attrib.block_size, &buf[4]);
 
        rbuf = transport_kmap_data_sg(cmd);
        if (rbuf) {
@@ -102,18 +96,8 @@ sbc_emulate_readcapacity_16(struct se_cmd *cmd)
        unsigned long long blocks = dev->transport->get_blocks(dev);
 
        memset(buf, 0, sizeof(buf));
-       buf[0] = (blocks >> 56) & 0xff;
-       buf[1] = (blocks >> 48) & 0xff;
-       buf[2] = (blocks >> 40) & 0xff;
-       buf[3] = (blocks >> 32) & 0xff;
-       buf[4] = (blocks >> 24) & 0xff;
-       buf[5] = (blocks >> 16) & 0xff;
-       buf[6] = (blocks >> 8) & 0xff;
-       buf[7] = blocks & 0xff;
-       buf[8] = (dev->dev_attrib.block_size >> 24) & 0xff;
-       buf[9] = (dev->dev_attrib.block_size >> 16) & 0xff;
-       buf[10] = (dev->dev_attrib.block_size >> 8) & 0xff;
-       buf[11] = dev->dev_attrib.block_size & 0xff;
+       put_unaligned_be64(blocks, &buf[0]);
+       put_unaligned_be32(dev->dev_attrib.block_size, &buf[8]);
        /*
         * Set P_TYPE and PROT_EN bits for DIF support
         */
@@ -134,8 +118,8 @@ sbc_emulate_readcapacity_16(struct se_cmd *cmd)
 
        if (dev->transport->get_alignment_offset_lbas) {
                u16 lalba = dev->transport->get_alignment_offset_lbas(dev);
-               buf[14] = (lalba >> 8) & 0x3f;
-               buf[15] = lalba & 0xff;
+
+               put_unaligned_be16(lalba, &buf[14]);
        }
 
        /*
@@ -262,18 +246,17 @@ static inline u32 transport_get_sectors_6(unsigned char *cdb)
 
 static inline u32 transport_get_sectors_10(unsigned char *cdb)
 {
-       return (u32)(cdb[7] << 8) + cdb[8];
+       return get_unaligned_be16(&cdb[7]);
 }
 
 static inline u32 transport_get_sectors_12(unsigned char *cdb)
 {
-       return (u32)(cdb[6] << 24) + (cdb[7] << 16) + (cdb[8] << 8) + cdb[9];
+       return get_unaligned_be32(&cdb[6]);
 }
 
 static inline u32 transport_get_sectors_16(unsigned char *cdb)
 {
-       return (u32)(cdb[10] << 24) + (cdb[11] << 16) +
-                   (cdb[12] << 8) + cdb[13];
+       return get_unaligned_be32(&cdb[10]);
 }
 
 /*
@@ -281,29 +264,23 @@ static inline u32 transport_get_sectors_16(unsigned char *cdb)
  */
 static inline u32 transport_get_sectors_32(unsigned char *cdb)
 {
-       return (u32)(cdb[28] << 24) + (cdb[29] << 16) +
-                   (cdb[30] << 8) + cdb[31];
+       return get_unaligned_be32(&cdb[28]);
 
 }
 
 static inline u32 transport_lba_21(unsigned char *cdb)
 {
-       return ((cdb[1] & 0x1f) << 16) | (cdb[2] << 8) | cdb[3];
+       return get_unaligned_be24(&cdb[1]) & 0x1fffff;
 }
 
 static inline u32 transport_lba_32(unsigned char *cdb)
 {
-       return (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
+       return get_unaligned_be32(&cdb[2]);
 }
 
 static inline unsigned long long transport_lba_64(unsigned char *cdb)
 {
-       unsigned int __v1, __v2;
-
-       __v1 = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
-       __v2 = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9];
-
-       return ((unsigned long long)__v2) | (unsigned long long)__v1 << 32;
+       return get_unaligned_be64(&cdb[2]);
 }
 
 /*
@@ -311,12 +288,7 @@ static inline unsigned long long transport_lba_64(unsigned char *cdb)
  */
 static inline unsigned long long transport_lba_64_ext(unsigned char *cdb)
 {
-       unsigned int __v1, __v2;
-
-       __v1 = (cdb[12] << 24) | (cdb[13] << 16) | (cdb[14] << 8) | cdb[15];
-       __v2 = (cdb[16] << 24) | (cdb[17] << 16) | (cdb[18] << 8) | cdb[19];
-
-       return ((unsigned long long)__v2) | (unsigned long long)__v1 << 32;
+       return get_unaligned_be64(&cdb[12]);
 }
 
 static sense_reason_t
@@ -1051,8 +1023,7 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                                cmd->t_task_cdb[1] & 0x1f);
                        return TCM_INVALID_CDB_FIELD;
                }
-               size = (cdb[10] << 24) | (cdb[11] << 16) |
-                      (cdb[12] << 8) | cdb[13];
+               size = get_unaligned_be32(&cdb[10]);
                break;
        case SYNCHRONIZE_CACHE:
        case SYNCHRONIZE_CACHE_16:
index 2a91ed3ef3801ecea225c4c0cd5356a0bc500ec0..f59ac767103185dddc3d6eb73cf335142bb90d2c 100644 (file)
@@ -287,8 +287,8 @@ check_t10_vend_desc:
                /* Skip over Obsolete field in RTPI payload
                 * in Table 472 */
                off += 2;
-               buf[off++] = ((lun->lun_rtpi >> 8) & 0xff);
-               buf[off++] = (lun->lun_rtpi & 0xff);
+               put_unaligned_be16(lun->lun_rtpi, &buf[off]);
+               off += 2;
                len += 8; /* Header size + Designation descriptor */
                /*
                 * Target port group identifier, see spc4r17
@@ -316,8 +316,8 @@ check_t10_vend_desc:
                off++; /* Skip over Reserved */
                buf[off++] = 4; /* DESIGNATOR LENGTH */
                off += 2; /* Skip over Reserved Field */
-               buf[off++] = ((tg_pt_gp_id >> 8) & 0xff);
-               buf[off++] = (tg_pt_gp_id & 0xff);
+               put_unaligned_be16(tg_pt_gp_id, &buf[off]);
+               off += 2;
                len += 8; /* Header size + Designation descriptor */
                /*
                 * Logical Unit Group identifier, see spc4r17
@@ -343,8 +343,8 @@ check_lu_gp:
                off++; /* Skip over Reserved */
                buf[off++] = 4; /* DESIGNATOR LENGTH */
                off += 2; /* Skip over Reserved Field */
-               buf[off++] = ((lu_gp_id >> 8) & 0xff);
-               buf[off++] = (lu_gp_id & 0xff);
+               put_unaligned_be16(lu_gp_id, &buf[off]);
+               off += 2;
                len += 8; /* Header size + Designation descriptor */
                /*
                 * SCSI name string designator, see spc4r17
@@ -431,8 +431,7 @@ check_scsi_name:
                /* Header size + Designation descriptor */
                len += (scsi_target_len + 4);
        }
-       buf[2] = ((len >> 8) & 0xff);
-       buf[3] = (len & 0xff); /* Page Length for VPD 0x83 */
+       put_unaligned_be16(len, &buf[2]); /* Page Length for VPD 0x83 */
        return 0;
 }
 EXPORT_SYMBOL(spc_emulate_evpd_83);
@@ -1288,7 +1287,7 @@ spc_parse_cdb(struct se_cmd *cmd, unsigned int *size)
                cmd->execute_cmd = spc_emulate_modeselect;
                break;
        case MODE_SELECT_10:
-               *size = (cdb[7] << 8) + cdb[8];
+               *size = get_unaligned_be16(&cdb[7]);
                cmd->execute_cmd = spc_emulate_modeselect;
                break;
        case MODE_SENSE:
@@ -1296,25 +1295,25 @@ spc_parse_cdb(struct se_cmd *cmd, unsigned int *size)
                cmd->execute_cmd = spc_emulate_modesense;
                break;
        case MODE_SENSE_10:
-               *size = (cdb[7] << 8) + cdb[8];
+               *size = get_unaligned_be16(&cdb[7]);
                cmd->execute_cmd = spc_emulate_modesense;
                break;
        case LOG_SELECT:
        case LOG_SENSE:
-               *size = (cdb[7] << 8) + cdb[8];
+               *size = get_unaligned_be16(&cdb[7]);
                break;
        case PERSISTENT_RESERVE_IN:
-               *size = (cdb[7] << 8) + cdb[8];
+               *size = get_unaligned_be16(&cdb[7]);
                cmd->execute_cmd = target_scsi3_emulate_pr_in;
                break;
        case PERSISTENT_RESERVE_OUT:
-               *size = (cdb[7] << 8) + cdb[8];
+               *size = get_unaligned_be16(&cdb[7]);
                cmd->execute_cmd = target_scsi3_emulate_pr_out;
                break;
        case RELEASE:
        case RELEASE_10:
                if (cdb[0] == RELEASE_10)
-                       *size = (cdb[7] << 8) | cdb[8];
+                       *size = get_unaligned_be16(&cdb[7]);
                else
                        *size = cmd->data_length;
 
@@ -1327,7 +1326,7 @@ spc_parse_cdb(struct se_cmd *cmd, unsigned int *size)
                 * Assume the passthrough or $FABRIC_MOD will tell us about it.
                 */
                if (cdb[0] == RESERVE_10)
-                       *size = (cdb[7] << 8) | cdb[8];
+                       *size = get_unaligned_be16(&cdb[7]);
                else
                        *size = cmd->data_length;
 
@@ -1338,7 +1337,7 @@ spc_parse_cdb(struct se_cmd *cmd, unsigned int *size)
                cmd->execute_cmd = spc_emulate_request_sense;
                break;
        case INQUIRY:
-               *size = (cdb[3] << 8) + cdb[4];
+               *size = get_unaligned_be16(&cdb[3]);
 
                /*
                 * Do implicit HEAD_OF_QUEUE processing for INQUIRY.
@@ -1349,7 +1348,7 @@ spc_parse_cdb(struct se_cmd *cmd, unsigned int *size)
                break;
        case SECURITY_PROTOCOL_IN:
        case SECURITY_PROTOCOL_OUT:
-               *size = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9];
+               *size = get_unaligned_be32(&cdb[6]);
                break;
        case EXTENDED_COPY:
                *size = get_unaligned_be32(&cdb[10]);
@@ -1361,19 +1360,18 @@ spc_parse_cdb(struct se_cmd *cmd, unsigned int *size)
                break;
        case READ_ATTRIBUTE:
        case WRITE_ATTRIBUTE:
-               *size = (cdb[10] << 24) | (cdb[11] << 16) |
-                      (cdb[12] << 8) | cdb[13];
+               *size = get_unaligned_be32(&cdb[10]);
                break;
        case RECEIVE_DIAGNOSTIC:
        case SEND_DIAGNOSTIC:
-               *size = (cdb[3] << 8) | cdb[4];
+               *size = get_unaligned_be16(&cdb[3]);
                break;
        case WRITE_BUFFER:
-               *size = (cdb[6] << 16) + (cdb[7] << 8) + cdb[8];
+               *size = get_unaligned_be24(&cdb[6]);
                break;
        case REPORT_LUNS:
                cmd->execute_cmd = spc_emulate_report_luns;
-               *size = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9];
+               *size = get_unaligned_be32(&cdb[6]);
                /*
                 * Do implicit HEAD_OF_QUEUE processing for REPORT_LUNS
                 * See spc4r17 section 5.3
index cac5a20a4de07ba554151c6099182c9e675efbed..f12cf0c12531f3a3420e28c226dcf33b5f521d12 100644 (file)
@@ -311,9 +311,7 @@ static int target_xcopy_parse_segdesc_02(struct se_cmd *se_cmd, struct xcopy_op
                (unsigned long long)xop->dst_lba);
 
        if (dc != 0) {
-               xop->dbl = (desc[29] & 0xff) << 16;
-               xop->dbl |= (desc[30] & 0xff) << 8;
-               xop->dbl |= desc[31] & 0xff;
+               xop->dbl = get_unaligned_be24(&desc[29]);
 
                pr_debug("XCOPY seg desc 0x02: DC=1 w/ dbl: %u\n", xop->dbl);
        }
index e475531565fdfb6808de54bf9b4c84de7a501584..b76071161cdc7f86816b3457e2aecdebb7f51d1e 100644 (file)
@@ -2,6 +2,7 @@
 #define TARGET_CORE_BACKEND_H
 
 #include <linux/types.h>
+#include <asm/unaligned.h>
 #include <target/target_core_base.h>
 
 #define TRANSPORT_FLAG_PASSTHROUGH             0x1
@@ -109,4 +110,11 @@ sector_t target_to_linux_sector(struct se_device *dev, sector_t lb);
 bool target_configure_unmap_from_queue(struct se_dev_attrib *attrib,
                                       struct request_queue *q);
 
+
+/* Only use get_unaligned_be24() if reading p - 1 is allowed. */
+static inline uint32_t get_unaligned_be24(const uint8_t *const p)
+{
+       return get_unaligned_be32(p - 1) & 0xffffffU;
+}
+
 #endif /* TARGET_CORE_BACKEND_H */