admin/libiscsi
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

Use the (un)marshalling functions scsi_get/set_uint16/32() anywhere in the code

Browse Source 
This has the nice side effect to remove the compiler warning
"dereferencing type-punned pointer will break strict-aliasing rules"
which occur since gcc-4.7.

There are 79 locations where the warning occurs. All of them are in
statements where the htonl/htons/ntohl/ntohs functions are used, e.g.:

in lib/pdu.c                itt = ntohl(*(uint32_t *)&in->hdr[16]);
in lib/scsi-lowlevel.c      *(uint32_t *)&task->cdb[2] = htonl(lba);

The warning is not related to the htonl/htons/ntohl/ntohs functions but
to the casting/dereferencing operation. If the dereferenced variable is
already a pointer, the warning does not not occur, e.g. this one:

in lib/pdu.c                itt = ntohl(*(uint32_t *)&in->data[16]);

The warning is caused by the -fstrict-aliasing option. The
-fstrict-aliasing option is enabled at optimization levels -O2, -O3, -Os.

Signed-off-by: Bernhard Kohl <bernhard.kohl@gmx.net>
This commit is contained in:
Bernhard Kohl
2012-11-23 23:14:09 +01:00
committed by Ronnie Sahlberg
parent 7e4b33dd31
commit 6644389907
5 changed files with 148 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
lib/iscsi-command.c
View File

@@ -329,12 +329,12 @@ iscsi_process_scsi_reply(struct iscsi_context *iscsi, struct iscsi_pdu *pdu,
struct iscsi_scsi_cbdata *scsi_cbdata = pdu->scsi_cbdata;
struct scsi_task *task = scsi_cbdata->task;
statsn = ntohl(*(uint32_t *)&in->hdr[24]);
statsn = scsi_get_uint32(&in->hdr[24]);
if (statsn > iscsi->statsn) {
iscsi->statsn = statsn;
}
maxcmdsn = ntohl(*(uint32_t *)&in->hdr[32]);
maxcmdsn = scsi_get_uint32(&in->hdr[32]);
if (maxcmdsn > iscsi->maxcmdsn) {
iscsi->maxcmdsn = maxcmdsn;
}
@@ -369,7 +369,7 @@ iscsi_process_scsi_reply(struct iscsi_context *iscsi, struct iscsi_pdu *pdu,
* These flags should only be set if the S flag is also set
*/
if (flags & (ISCSI_PDU_DATA_RESIDUAL_OVERFLOW|ISCSI_PDU_DATA_RESIDUAL_UNDERFLOW)) {
task->residual = ntohl(*((uint32_t *)&in->hdr[44]));
task->residual = scsi_get_uint32(&in->hdr[44]);
if (flags & ISCSI_PDU_DATA_RESIDUAL_UNDERFLOW) {
task->residual_status = SCSI_RESIDUAL_UNDERFLOW;
} else {
@@ -397,14 +397,14 @@ iscsi_process_scsi_reply(struct iscsi_context *iscsi, struct iscsi_pdu *pdu,
case 0x70:
case 0x71:
task->sense.key = task->datain.data[4] & 0x0f;
task->sense.ascq = ntohs(*(uint16_t *)
&(task->datain.data[14]));
task->sense.ascq = scsi_get_uint16(
&(task->datain.data[14]));
break;
case 0x72:
case 0x73:
task->sense.key = task->datain.data[3] & 0x0f;
task->sense.ascq = ntohs(*(uint16_t *)
&(task->datain.data[4]));
task->sense.ascq = scsi_get_uint16(
&(task->datain.data[4]));
break;
}
iscsi_set_error(iscsi, "SENSE KEY:%s(%d) ASCQ:%s(0x%04x)",
@@ -440,12 +440,12 @@ iscsi_process_scsi_data_in(struct iscsi_context *iscsi, struct iscsi_pdu *pdu,
struct scsi_task *task = scsi_cbdata->task;
int dsl;
statsn = ntohl(*(uint32_t *)&in->hdr[24]);
statsn = scsi_get_uint32(&in->hdr[24]);
if (statsn > iscsi->statsn) {
iscsi->statsn = statsn;
}
maxcmdsn = ntohl(*(uint32_t *)&in->hdr[32]);
maxcmdsn = scsi_get_uint32(&in->hdr[32]);
if (maxcmdsn > iscsi->maxcmdsn) {
iscsi->maxcmdsn = maxcmdsn;
}
@@ -458,7 +458,7 @@ iscsi_process_scsi_data_in(struct iscsi_context *iscsi, struct iscsi_pdu *pdu,
pdu->private_data);
return -1;
}
dsl = ntohl(*(uint32_t *)&in->hdr[4])&0x00ffffff;
dsl = scsi_get_uint32(&in->hdr[4]) & 0x00ffffff;
/* Dont add to reassembly buffer if we already have a user buffer */
if (scsi_task_get_data_in_buffer(task, 0, NULL) == NULL) {
@@ -495,7 +495,7 @@ iscsi_process_scsi_data_in(struct iscsi_context *iscsi, struct iscsi_pdu *pdu,
* These flags should only be set if the S flag is also set
*/
if (flags & (ISCSI_PDU_DATA_RESIDUAL_OVERFLOW|ISCSI_PDU_DATA_RESIDUAL_UNDERFLOW)) {
task->residual = ntohl(*((uint32_t *)&in->hdr[44]));
task->residual = scsi_get_uint32(&in->hdr[44]);
if (flags & ISCSI_PDU_DATA_RESIDUAL_UNDERFLOW) {
task->residual_status = SCSI_RESIDUAL_UNDERFLOW;
} else {
@@ -525,11 +525,11 @@ iscsi_process_r2t(struct iscsi_context *iscsi, struct iscsi_pdu *pdu,
{
uint32_t ttt, offset, len, maxcmdsn;
ttt = ntohl(*(uint32_t *)&in->hdr[20]);
offset = ntohl(*(uint32_t *)&in->hdr[40]);
len = ntohl(*(uint32_t *)&in->hdr[44]);
ttt = scsi_get_uint32(&in->hdr[20]);
offset = scsi_get_uint32(&in->hdr[40]);
len = scsi_get_uint32(&in->hdr[44]);
maxcmdsn = ntohl(*(uint32_t *)&in->hdr[32]);
maxcmdsn = scsi_get_uint32(&in->hdr[32]);
if (maxcmdsn > iscsi->maxcmdsn) {
iscsi->maxcmdsn = maxcmdsn;
}
@@ -1450,12 +1450,12 @@ iscsi_unmap_task(struct iscsi_context *iscsi, int lun, int anchor, int group,
scsi_free_scsi_task(task);
return NULL;
}
*((uint16_t *)&data[0]) = htons(xferlen - 2);
*((uint16_t *)&data[2]) = htons(xferlen - 8);
scsi_set_uint16(&data[0], xferlen - 2);
scsi_set_uint16(&data[2], xferlen - 8);
for (i = 0; i < list_len; i++) {
*((uint32_t *)&data[8 + 16 * i]) = htonl(list[0].lba >> 32);
*((uint32_t *)&data[8 + 16 * i + 4]) = htonl(list[0].lba & 0xffffffff);
*((uint32_t *)&data[8 + 16 * i + 8]) = htonl(list[0].num);
scsi_set_uint32(&data[8 + 16 * i], list[0].lba >> 32);
scsi_set_uint32(&data[8 + 16 * i + 4], list[0].lba & 0xffffffff);
scsi_set_uint32(&data[8 + 16 * i + 8], list[0].num);
}
outdata.data = data;
@@ -1481,9 +1481,9 @@ iscsi_get_user_in_buffer(struct iscsi_context *iscsi, struct iscsi_in_pdu *in, u
return NULL;
}
offset = ntohl(*(uint32_t *)&in->hdr[40]);
offset = scsi_get_uint32(&in->hdr[40]);
itt = ntohl(*(uint32_t *)&in->hdr[16]);
itt = scsi_get_uint32(&in->hdr[16]);
for (pdu = iscsi->waitpdu; pdu; pdu = pdu->next) {
if (pdu->itt == itt) {
break;

9
lib/login.c
View File

@@ -30,6 +30,7 @@
#include <string.h>
#include "iscsi.h"
#include "iscsi-private.h"
#include "scsi-lowlevel.h"
#include "md5.h"
static int
@@ -944,11 +945,11 @@ iscsi_process_login_reply(struct iscsi_context *iscsi, struct iscsi_pdu *pdu,
char *ptr = (char *)in->data;
int size = in->data_pos;
status = ntohs(*(uint16_t *)&in->hdr[36]);
status = scsi_get_uint16(&in->hdr[36]);
iscsi->statsn = ntohs(*(uint16_t *)&in->hdr[24]);
iscsi->statsn = scsi_get_uint16(&in->hdr[24]);
maxcmdsn = ntohl(*(uint32_t *)&in->hdr[32]);
maxcmdsn = scsi_get_uint32(&in->hdr[32]);
if (maxcmdsn > iscsi->maxcmdsn) {
iscsi->maxcmdsn = maxcmdsn;
}
@@ -1134,7 +1135,7 @@ struct iscsi_in_pdu *in)
{
uint32_t maxcmdsn;
maxcmdsn = ntohl(*(uint32_t *)&in->hdr[32]);
maxcmdsn = scsi_get_uint32(&in->hdr[32]);
if (maxcmdsn > iscsi->maxcmdsn) {
iscsi->maxcmdsn = maxcmdsn;
}

36
lib/pdu.c
View File

@@ -196,8 +196,8 @@ iscsi_pdu_add_data(struct iscsi_context *iscsi, struct iscsi_pdu *pdu,
}
/* update data segment length */
*(uint32_t *)&pdu->outdata.data[4] = htonl(pdu->outdata.size
- ISCSI_HEADER_SIZE);
scsi_set_uint32(&pdu->outdata.data[4], pdu->outdata.size
- ISCSI_HEADER_SIZE);
return 0;
}
@@ -207,8 +207,8 @@ iscsi_get_pdu_data_size(const unsigned char *hdr)
{
int size;
size = (ntohl(*(uint32_t *)&hdr[4])&0x00ffffff);
size = (size+3)&0xfffffffc;
size = scsi_get_uint32(&hdr[4]) & 0x00ffffff;
size = (size+3) & 0xfffffffc;
return size;
}
@@ -266,9 +266,9 @@ int iscsi_process_target_nop_in(struct iscsi_context *iscsi,
uint32_t ttt;
uint32_t statsn;
ttt = ntohl(*(uint32_t *)&in->hdr[20]);
ttt = scsi_get_uint32(&in->hdr[20]);
statsn = ntohl(*(uint32_t *)&in->hdr[24]);
statsn = scsi_get_uint32(&in->hdr[24]);
if (statsn > iscsi->statsn) {
iscsi->statsn = statsn;
}
@@ -298,7 +298,7 @@ int iscsi_process_reject(struct iscsi_context *iscsi,
return -1;
}
itt = ntohl(*(uint32_t *)&in->data[16]);
itt = scsi_get_uint32(&in->data[16]);
for (pdu = iscsi->waitpdu; pdu; pdu = pdu->next) {
if (pdu->itt == itt) {
@@ -332,7 +332,7 @@ iscsi_process_pdu(struct iscsi_context *iscsi, struct iscsi_in_pdu *in)
opcode = in->hdr[0] & 0x3f;
ahslen = in->hdr[4];
itt = ntohl(*(uint32_t *)&in->hdr[16]);
itt = scsi_get_uint32(&in->hdr[16]);
if (ahslen != 0) {
iscsi_set_error(iscsi, "cant handle expanded headers yet");
@@ -479,13 +479,13 @@ iscsi_process_pdu(struct iscsi_context *iscsi, struct iscsi_in_pdu *in)
void
iscsi_pdu_set_itt(struct iscsi_pdu *pdu, uint32_t itt)
{
*(uint32_t *)&pdu->outdata.data[16] = htonl(itt);
scsi_set_uint32(&pdu->outdata.data[16], itt);
}
void
iscsi_pdu_set_ritt(struct iscsi_pdu *pdu, uint32_t ritt)
{
*(uint32_t *)&pdu->outdata.data[20] = htonl(ritt);
scsi_set_uint32(&pdu->outdata.data[20], ritt);
}
void
@@ -503,43 +503,43 @@ iscsi_pdu_set_immediate(struct iscsi_pdu *pdu)
void
iscsi_pdu_set_ttt(struct iscsi_pdu *pdu, uint32_t ttt)
{
*(uint32_t *)&pdu->outdata.data[20] = htonl(ttt);
scsi_set_uint32(&pdu->outdata.data[20], ttt);
}
void
iscsi_pdu_set_cmdsn(struct iscsi_pdu *pdu, uint32_t cmdsn)
{
*(uint32_t *)&pdu->outdata.data[24] = htonl(cmdsn);
scsi_set_uint32(&pdu->outdata.data[24], cmdsn);
}
void
iscsi_pdu_set_rcmdsn(struct iscsi_pdu *pdu, uint32_t rcmdsn)
{
*(uint32_t *)&pdu->outdata.data[32] = htonl(rcmdsn);
scsi_set_uint32(&pdu->outdata.data[32], rcmdsn);
}
void
iscsi_pdu_set_datasn(struct iscsi_pdu *pdu, uint32_t datasn)
{
*(uint32_t *)&pdu->outdata.data[36] = htonl(datasn);
scsi_set_uint32(&pdu->outdata.data[36], datasn);
}
void
iscsi_pdu_set_expstatsn(struct iscsi_pdu *pdu, uint32_t expstatsnsn)
{
*(uint32_t *)&pdu->outdata.data[28] = htonl(expstatsnsn);
scsi_set_uint32(&pdu->outdata.data[28], expstatsnsn);
}
void
iscsi_pdu_set_bufferoffset(struct iscsi_pdu *pdu, uint32_t bufferoffset)
{
*(uint32_t *)&pdu->outdata.data[40] = htonl(bufferoffset);
scsi_set_uint32(&pdu->outdata.data[40], bufferoffset);
}
void
iscsi_pdu_set_cdb(struct iscsi_pdu *pdu, struct scsi_task *task)
{
memset(&pdu->outdata.data[32], 0, 16);
memset(&pdu->outdata.data[32], 0, 16);
memcpy(&pdu->outdata.data[32], task->cdb, task->cdb_size);
}
@@ -553,5 +553,5 @@ iscsi_pdu_set_lun(struct iscsi_pdu *pdu, uint32_t lun)
void
iscsi_pdu_set_expxferlen(struct iscsi_pdu *pdu, uint32_t expxferlen)
{
*(uint32_t *)&pdu->outdata.data[20] = htonl(expxferlen);
scsi_set_uint32(&pdu->outdata.data[20], expxferlen);
}

205
lib/scsi-lowlevel.c
View File

@@ -224,7 +224,7 @@ scsi_reportluns_cdb(int report_type, int alloc_len)
memset(task, 0, sizeof(struct scsi_task));
task->cdb[0] = SCSI_OPCODE_REPORTLUNS;
task->cdb[2] = report_type;
*(uint32_t *)&task->cdb[6] = htonl(alloc_len);
scsi_set_uint32(&task->cdb[6], alloc_len);
task->cdb_size = 12;
if (alloc_len != 0) {
@@ -246,7 +246,7 @@ scsi_reportluns_datain_getfullsize(struct scsi_task *task)
{
uint32_t list_size;
list_size = htonl(*(uint32_t *)&(task->datain.data[0])) + 8;
list_size = scsi_get_uint32(&task->datain.data[0]) + 8;
return list_size;
}
@@ -265,7 +265,7 @@ scsi_reportluns_datain_unmarshall(struct scsi_task *task)
return NULL;
}
list_size = htonl(*(uint32_t *)&(task->datain.data[0])) + 8;
list_size = scsi_get_uint32(&task->datain.data[0]) + 8;
if (list_size < task->datain.size) {
return NULL;
}
@@ -279,8 +279,7 @@ scsi_reportluns_datain_unmarshall(struct scsi_task *task)
list->num = num_luns;
for (i = 0; i < num_luns; i++) {
list->luns[i] = htons(*(uint16_t *)
&(task->datain.data[i*8+8]));
list->luns[i] = scsi_get_uint16(&task->datain.data[i*8+8]);
}
return list;
@@ -302,7 +301,7 @@ scsi_cdb_readcapacity10(int lba, int pmi)
memset(task, 0, sizeof(struct scsi_task));
task->cdb[0] = SCSI_OPCODE_READCAPACITY10;
*(uint32_t *)&task->cdb[2] = htonl(lba);
scsi_set_uint32(&task->cdb[2], lba);
if (pmi) {
task->cdb[8] |= 0x01;
@@ -348,7 +347,7 @@ scsi_cdb_readtoc(int msf, int format, int track_session, uint16_t alloc_len)
task->cdb[6] = 0xff & track_session;
}
*(uint16_t *)&task->cdb[7] = htons(alloc_len);
scsi_set_uint16(&task->cdb[7], alloc_len);
task->cdb_size = 10;
if (alloc_len != 0) {
@@ -370,7 +369,7 @@ scsi_readtoc_datain_getfullsize(struct scsi_task *task)
{
uint16_t toc_data_len;
toc_data_len = ntohs(*((uint16_t *)&task->datain.data[0])) + 2;
toc_data_len = scsi_get_uint16(&task->datain.data[0]) + 2;
return toc_data_len;
}
@@ -393,7 +392,7 @@ scsi_readtoc_desc_unmarshall(struct scsi_task *task, struct scsi_readtoc_list *l
list->desc[i].desc.toc.track
= task->datain.data[4+8*i+2];
list->desc[i].desc.toc.lba
= ntohl(*(uint32_t *)&task->datain.data[4+8*i+4]);
= scsi_get_uint32(&task->datain.data[4+8*i+4]);
break;
case SCSI_READ_SESSION_INFO:
list->desc[i].desc.ses.adr
@@ -403,7 +402,7 @@ scsi_readtoc_desc_unmarshall(struct scsi_task *task, struct scsi_readtoc_list *l
list->desc[i].desc.ses.first_in_last
= task->datain.data[4+8*i+2];
list->desc[i].desc.ses.lba
= ntohl(*(uint32_t *)&task->datain.data[4+8*i+4]);
= scsi_get_uint32(&task->datain.data[4+8*i+4]);
break;
case SCSI_READ_FULL_TOC:
list->desc[i].desc.full.session
@@ -538,22 +537,22 @@ scsi_serviceactionin_datain_unmarshall(struct scsi_task *task)
if (rc16 == NULL) {
return NULL;
}
rc16->returned_lba = ntohl(*(uint32_t *)&(task->datain.data[0]));
rc16->returned_lba = (rc16->returned_lba << 32) | ntohl(*(uint32_t *)&(task->datain.data[4]));
rc16->block_length = ntohl(*(uint32_t *)&(task->datain.data[8]));
rc16->returned_lba = scsi_get_uint32(&task->datain.data[0]);
rc16->returned_lba = (rc16->returned_lba << 32) | scsi_get_uint32(&task->datain.data[4]);
rc16->block_length = scsi_get_uint32(&task->datain.data[8]);
rc16->p_type = (task->datain.data[12] >> 1) & 0x07;
rc16->prot_en = task->datain.data[12] & 0x01;
rc16->p_i_exp = (task->datain.data[13] >> 4) & 0x0f;
rc16->lbppbe = task->datain.data[13] & 0x0f;
rc16->lbpme = !!(task->datain.data[14] & 0x80);
rc16->lbprz = !!(task->datain.data[14] & 0x40);
rc16->lalba = ntohs(*(uint16_t *)&(task->datain.data[14])) & 0x3fff;
rc16->lalba = scsi_get_uint16(&task->datain.data[14]) & 0x3fff;
return rc16;
}
case SCSI_GET_LBA_STATUS: {
struct scsi_get_lba_status *gls = scsi_malloc(task,
sizeof(*gls));
int32_t len = ntohl(*(uint32_t *)&(task->datain.data[0]));
int32_t len = scsi_get_uint32(&task->datain.data[0]);
int i;
if (gls == NULL) {
@@ -574,11 +573,11 @@ scsi_serviceactionin_datain_unmarshall(struct scsi_task *task)
}
for (i = 0; i < (int)gls->num_descriptors; i++) {
gls->descriptors[i].lba = ntohl(*(uint32_t *)&(task->datain.data[8 + i * sizeof(struct scsi_lba_status_descriptor) + 0]));
gls->descriptors[i].lba = scsi_get_uint32(&task->datain.data[8 + i * sizeof(struct scsi_lba_status_descriptor) + 0]);
gls->descriptors[i].lba <<= 32;
gls->descriptors[i].lba |= ntohl(*(uint32_t *)&(task->datain.data[8 + i * sizeof(struct scsi_lba_status_descriptor) + 4]));
gls->descriptors[i].lba |= scsi_get_uint32(&task->datain.data[8 + i * sizeof(struct scsi_lba_status_descriptor) + 4]);
gls->descriptors[i].num_blocks = ntohl(*(uint32_t *)&(task->datain.data[8 + i * sizeof(struct scsi_lba_status_descriptor) + 8]));
gls->descriptors[i].num_blocks = scsi_get_uint32(&task->datain.data[8 + i * sizeof(struct scsi_lba_status_descriptor) + 8]);
gls->descriptors[i].provisioning = task->datain.data[8 + i * sizeof(struct scsi_lba_status_descriptor) + 12] & 0x0f;
}
@@ -612,7 +611,7 @@ scsi_maintenancein_datain_getfullsize(struct scsi_task *task)
switch (scsi_maintenancein_sa(task)) {
case SCSI_REPORT_SUPPORTED_OP_CODES:
return ntohl(*(uint32_t *)&(task->datain.data[0])) + 4;
return scsi_get_uint32(&task->datain.data[0]) + 4;
default:
return -1;
}
@@ -635,7 +634,7 @@ scsi_maintenancein_datain_unmarshall(struct scsi_task *task)
return NULL;
}
len = ntohl(*(uint32_t *)&(task->datain.data[0]));
len = scsi_get_uint32(&task->datain.data[0]);
rsoc = scsi_malloc(task, sizeof(struct scsi_report_supported_op_codes) + len);
if (rsoc == NULL) {
return NULL;
@@ -697,7 +696,7 @@ scsi_cdb_report_supported_opcodes(int return_timeouts, uint32_t alloc_len)
task->cdb[2] |= 0x80;
}
*(uint32_t *)&task->cdb[6] = htonl(alloc_len);
scsi_set_uint32(&task->cdb[6], alloc_len);
task->cdb_size = 12;
if (alloc_len != 0) {
@@ -736,8 +735,8 @@ scsi_readcapacity10_datain_unmarshall(struct scsi_task *task)
return NULL;
}
rc10->lba = htonl(*(uint32_t *)&(task->datain.data[0]));
rc10->block_size = htonl(*(uint32_t *)&(task->datain.data[4]));
rc10->lba = scsi_get_uint32(&task->datain.data[0]);
rc10->block_size = scsi_get_uint32(&task->datain.data[4]);
return rc10;
}
@@ -764,7 +763,7 @@ scsi_cdb_inquiry(int evpd, int page_code, int alloc_len)
task->cdb[2] = page_code;
*(uint16_t *)&task->cdb[3] = htons(alloc_len);
scsi_set_uint16(&task->cdb[3], alloc_len);
task->cdb_size = 6;
if (alloc_len != 0) {
@@ -808,7 +807,7 @@ scsi_inquiry_datain_getfullsize(struct scsi_task *task)
case SCSI_INQUIRY_PAGECODE_DEVICE_IDENTIFICATION:
case SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS:
case SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING:
return ntohs(*(uint16_t *)&task->datain.data[2]) + 4;
return scsi_get_uint16(&task->datain.data[2]) + 4;
default:
return -1;
}
@@ -908,7 +907,7 @@ scsi_inquiry_unmarshall_device_identification(struct scsi_task *task)
{
struct scsi_inquiry_device_identification *inq = scsi_malloc(task,
sizeof(*inq));
int remaining = ntohs(*(uint16_t *)&task->datain.data[2]);
int remaining = scsi_get_uint16(&task->datain.data[2]);
unsigned char *dptr;
if (inq == NULL) {
@@ -977,17 +976,17 @@ scsi_inquiry_unmarshall_block_limits(struct scsi_task *task)
inq->wsnz = task->datain.data[4] & 0x01;
inq->max_cmp = task->datain.data[5];
inq->opt_gran = ntohs(*(uint16_t *)&task->datain.data[6]);
inq->max_xfer_len = ntohl(*(uint32_t *)&task->datain.data[8]);
inq->opt_xfer_len = ntohl(*(uint32_t *)&task->datain.data[12]);
inq->max_prefetch = ntohl(*(uint32_t *)&task->datain.data[16]);
inq->max_unmap = ntohl(*(uint32_t *)&task->datain.data[20]);
inq->max_unmap_bdc = ntohl(*(uint32_t *)&task->datain.data[24]);
inq->opt_unmap_gran = ntohl(*(uint32_t *)&task->datain.data[28]);
inq->opt_gran = scsi_get_uint16(&task->datain.data[6]);
inq->max_xfer_len = scsi_get_uint32(&task->datain.data[8]);
inq->opt_xfer_len = scsi_get_uint32(&task->datain.data[12]);
inq->max_prefetch = scsi_get_uint32(&task->datain.data[16]);
inq->max_unmap = scsi_get_uint32(&task->datain.data[20]);
inq->max_unmap_bdc = scsi_get_uint32(&task->datain.data[24]);
inq->opt_unmap_gran = scsi_get_uint32(&task->datain.data[28]);
inq->ugavalid = !!(task->datain.data[32]&0x80);
inq->unmap_gran_align = ntohl(*(uint32_t *)&task->datain.data[32]) & 0x7fffffff;
inq->max_ws_len = ntohl(*(uint32_t *)&task->datain.data[36]);
inq->max_ws_len = (inq->max_ws_len << 32) | ntohl(*(uint32_t *)&task->datain.data[40]);
inq->unmap_gran_align = scsi_get_uint32(&task->datain.data[32]) & 0x7fffffff;
inq->max_ws_len = scsi_get_uint32(&task->datain.data[36]);
inq->max_ws_len = (inq->max_ws_len << 32) | scsi_get_uint32(&task->datain.data[40]);
return inq;
}
@@ -1004,7 +1003,7 @@ scsi_inquiry_unmarshall_block_device_characteristics(struct scsi_task *task)
inq->device_type = task->datain.data[0]&0x1f;
inq->pagecode = task->datain.data[1];
inq->medium_rotation_rate = ntohs(*(uint16_t *)&task->datain.data[4]);
inq->medium_rotation_rate = scsi_get_uint16(&task->datain.data[4]);
return inq;
}
@@ -1133,8 +1132,8 @@ scsi_cdb_read10(uint32_t lba, uint32_t xferlen, int blocksize, int rdprotect, in
task->cdb[1] |= 0x02;
}
*(uint32_t *)&task->cdb[2] = htonl(lba);
*(uint16_t *)&task->cdb[7] = htons(xferlen/blocksize);
scsi_set_uint32(&task->cdb[2], lba);
scsi_set_uint16(&task->cdb[7], xferlen/blocksize);
task->cdb[6] |= (group_number & 0x1f);
@@ -1176,8 +1175,8 @@ scsi_cdb_read12(uint32_t lba, uint32_t xferlen, int blocksize, int rdprotect, in
task->cdb[1] |= 0x02;
}
*(uint32_t *)&task->cdb[2] = htonl(lba);
*(uint32_t *)&task->cdb[6] = htonl(xferlen/blocksize);
scsi_set_uint32(&task->cdb[2], lba);
scsi_set_uint32(&task->cdb[6], xferlen/blocksize);
task->cdb[10] |= (group_number & 0x1f);
@@ -1219,9 +1218,9 @@ scsi_cdb_read16(uint64_t lba, uint32_t xferlen, int blocksize, int rdprotect, in
task->cdb[1] |= 0x02;
}
*(uint32_t *)&task->cdb[2] = htonl(lba >> 32);
*(uint32_t *)&task->cdb[6] = htonl(lba & 0xffffffff);
*(uint32_t *)&task->cdb[10] = htonl(xferlen/blocksize);
scsi_set_uint32(&task->cdb[2], lba >> 32);
scsi_set_uint32(&task->cdb[6], lba & 0xffffffff);
scsi_set_uint32(&task->cdb[10], xferlen/blocksize);
task->cdb[14] |= (group_number & 0x1f);
@@ -1263,8 +1262,8 @@ scsi_cdb_write10(uint32_t lba, uint32_t xferlen, int blocksize, int wrprotect, i
task->cdb[1] |= 0x02;
}
*(uint32_t *)&task->cdb[2] = htonl(lba);
*(uint16_t *)&task->cdb[7] = htons(xferlen/blocksize);
scsi_set_uint32(&task->cdb[2], lba);
scsi_set_uint16(&task->cdb[7], xferlen/blocksize);
task->cdb[6] |= (group_number & 0x1f);
@@ -1306,8 +1305,8 @@ scsi_cdb_write12(uint32_t lba, uint32_t xferlen, int blocksize, int wrprotect, i
task->cdb[1] |= 0x02;
}
*(uint32_t *)&task->cdb[2] = htonl(lba);
*(uint32_t *)&task->cdb[6] = htonl(xferlen/blocksize);
scsi_set_uint32(&task->cdb[2], lba);
scsi_set_uint32(&task->cdb[6], xferlen/blocksize);
task->cdb[10] |= (group_number & 0x1f);
@@ -1349,9 +1348,9 @@ scsi_cdb_write16(uint64_t lba, uint32_t xferlen, int blocksize, int wrprotect, i
task->cdb[1] |= 0x02;
}
*(uint32_t *)&task->cdb[2] = htonl(lba >> 32);
*(uint32_t *)&task->cdb[6] = htonl(lba & 0xffffffff);
*(uint32_t *)&task->cdb[10] = htonl(xferlen/blocksize);
scsi_set_uint32(&task->cdb[2], lba >> 32);
scsi_set_uint32(&task->cdb[6], lba & 0xffffffff);
scsi_set_uint32(&task->cdb[10], xferlen/blocksize);
task->cdb[14] |= (group_number & 0x1f);
@@ -1393,9 +1392,9 @@ scsi_cdb_orwrite(uint64_t lba, uint32_t xferlen, int blocksize, int wrprotect, i
task->cdb[1] |= 0x02;
}
*(uint32_t *)&task->cdb[2] = htonl(lba >> 32);
*(uint32_t *)&task->cdb[6] = htonl(lba & 0xffffffff);
*(uint32_t *)&task->cdb[10] = htonl(xferlen/blocksize);
scsi_set_uint32(&task->cdb[2], lba >> 32);
scsi_set_uint32(&task->cdb[6], lba & 0xffffffff);
scsi_set_uint32(&task->cdb[10], xferlen/blocksize);
task->cdb[14] |= (group_number & 0x1f);
@@ -1437,8 +1436,8 @@ scsi_cdb_compareandwrite(uint64_t lba, uint32_t xferlen, int blocksize, int wrpr
task->cdb[1] |= 0x02;
}
*(uint32_t *)&task->cdb[2] = htonl(lba >> 32);
*(uint32_t *)&task->cdb[6] = htonl(lba & 0xffffffff);
scsi_set_uint32(&task->cdb[2], lba >> 32);
scsi_set_uint32(&task->cdb[6], lba & 0xffffffff);
task->cdb[13] = xferlen/blocksize;
task->cdb[14] |= (group_number & 0x1f);
@@ -1479,8 +1478,8 @@ scsi_cdb_verify10(uint32_t lba, uint32_t xferlen, int vprotect, int dpo, int byt
task->cdb[1] |= 0x02;
}
*(uint32_t *)&task->cdb[2] = htonl(lba);
*(uint16_t *)&task->cdb[7] = htons(xferlen/blocksize);
scsi_set_uint32(&task->cdb[2], lba);
scsi_set_uint16(&task->cdb[7], xferlen/blocksize);
task->cdb_size = 10;
if (xferlen != 0 && bytchk) {
@@ -1520,8 +1519,8 @@ scsi_cdb_verify12(uint32_t lba, uint32_t xferlen, int vprotect, int dpo, int byt
task->cdb[1] |= 0x02;
}
*(uint32_t *)&task->cdb[2] = htonl(lba);
*(uint32_t *)&task->cdb[6] = htonl(xferlen/blocksize);
scsi_set_uint32(&task->cdb[2], lba);
scsi_set_uint32(&task->cdb[6], xferlen/blocksize);
task->cdb_size = 12;
if (xferlen != 0 && bytchk) {
@@ -1561,9 +1560,9 @@ scsi_cdb_verify16(uint64_t lba, uint32_t xferlen, int vprotect, int dpo, int byt
task->cdb[1] |= 0x02;
}
*(uint32_t *)&task->cdb[2] = htonl(lba >> 32);
*(uint32_t *)&task->cdb[6] = htonl(lba & 0xffffffff);
*(uint32_t *)&task->cdb[10] = htonl(xferlen/blocksize);
scsi_set_uint32(&task->cdb[2], lba >> 32);
scsi_set_uint32(&task->cdb[6], lba & 0xffffffff);
scsi_set_uint32(&task->cdb[10], xferlen/blocksize);
task->cdb_size = 16;
if (xferlen != 0 && bytchk) {
@@ -1598,7 +1597,7 @@ scsi_cdb_unmap(int anchor, int group, uint16_t xferlen)
}
task->cdb[6] |= group & 0x1f;
*(uint16_t *)&task->cdb[7] = htons(xferlen);
scsi_set_uint16(&task->cdb[7], xferlen);
task->cdb_size = 10;
if (xferlen != 0) {
@@ -1642,11 +1641,11 @@ scsi_cdb_writesame10(int wrprotect, int anchor, int unmap, int pbdata, int lbdat
if (lbdata) {
task->cdb[1] |= 0x02;
}
*(uint32_t *)&task->cdb[2] = htonl(lba);
scsi_set_uint32(&task->cdb[2], lba);
if (group) {
task->cdb[6] |= (group & 0x1f);
}
*(uint16_t *)&task->cdb[7] = htons(num_blocks);
scsi_set_uint16(&task->cdb[7], num_blocks);
task->cdb_size = 10;
task->xfer_dir = SCSI_XFER_WRITE;
@@ -1686,9 +1685,9 @@ scsi_cdb_writesame16(int wrprotect, int anchor, int unmap, int pbdata, int lbdat
if (lbdata) {
task->cdb[1] |= 0x02;
}
*(uint32_t *)&task->cdb[2] = htonl(lba >> 32);
*(uint32_t *)&task->cdb[6] = htonl(lba & 0xffffffff);
*(uint32_t *)&task->cdb[10] = htonl(num_blocks);
scsi_set_uint32(&task->cdb[2], lba >> 32);
scsi_set_uint32(&task->cdb[6], lba & 0xffffffff);
scsi_set_uint32(&task->cdb[10], num_blocks);
if (group) {
task->cdb[14] |= (group & 0x1f);
}
@@ -1765,10 +1764,10 @@ scsi_parse_mode_caching(struct scsi_task *task, int pos, struct scsi_mode_page *
mp->caching.demand_read_retention_priority = (task->datain.data[pos+1] >> 4) & 0x0f;
mp->caching.write_retention_priority = task->datain.data[pos+1] & 0x0f;
mp->caching.disable_prefetch_transfer_length = htons(*(uint16_t *)&(task->datain.data[pos+2]));
mp->caching.minimum_prefetch = htons(*(uint16_t *)&(task->datain.data[pos+4]));
mp->caching.maximum_prefetch = htons(*(uint16_t *)&(task->datain.data[pos+6]));
mp->caching.maximum_prefetch_ceiling = htons(*(uint16_t *)&(task->datain.data[pos+8]));
mp->caching.disable_prefetch_transfer_length = scsi_get_uint16(&task->datain.data[pos+2]);
mp->caching.minimum_prefetch = scsi_get_uint16(&task->datain.data[pos+4]);
mp->caching.maximum_prefetch = scsi_get_uint16(&task->datain.data[pos+6]);
mp->caching.maximum_prefetch_ceiling = scsi_get_uint16(&task->datain.data[pos+8]);
mp->caching.fsw = task->datain.data[pos+10] & 0x80;
mp->caching.lbcss = task->datain.data[pos+10] & 0x40;
@@ -1776,7 +1775,7 @@ scsi_parse_mode_caching(struct scsi_task *task, int pos, struct scsi_mode_page *
mp->caching.nv_dis = task->datain.data[pos+10] & 0x01;
mp->caching.number_of_cache_segments = task->datain.data[pos+11];
mp->caching.cache_segment_size = htons(*(uint16_t *)&(task->datain.data[pos+12]));
mp->caching.cache_segment_size = scsi_get_uint16(&task->datain.data[pos+12]);
}
static void
@@ -1784,15 +1783,15 @@ scsi_parse_mode_disconnect_reconnect(struct scsi_task *task, int pos, struct scs
{
mp->disconnect_reconnect.buffer_full_ratio = task->datain.data[pos];
mp->disconnect_reconnect.buffer_empty_ratio = task->datain.data[pos+1];
mp->disconnect_reconnect.bus_inactivity_limit = htons(*(uint16_t *)&(task->datain.data[pos+2]));
mp->disconnect_reconnect.disconnect_time_limit = htons(*(uint16_t *)&(task->datain.data[pos+4]));
mp->disconnect_reconnect.connect_time_limit = htons(*(uint16_t *)&(task->datain.data[pos+6]));
mp->disconnect_reconnect.maximum_burst_size = htons(*(uint16_t *)&(task->datain.data[pos+8]));
mp->disconnect_reconnect.bus_inactivity_limit = scsi_get_uint16(&task->datain.data[pos+2]);
mp->disconnect_reconnect.disconnect_time_limit = scsi_get_uint16(&task->datain.data[pos+4]);
mp->disconnect_reconnect.connect_time_limit = scsi_get_uint16(&task->datain.data[pos+6]);
mp->disconnect_reconnect.maximum_burst_size = scsi_get_uint16(&task->datain.data[pos+8]);
mp->disconnect_reconnect.emdp = task->datain.data[pos+10] & 0x80;
mp->disconnect_reconnect.fair_arbitration = (task->datain.data[pos+10]>>4) & 0x0f;
mp->disconnect_reconnect.dimm = task->datain.data[pos+10] & 0x08;
mp->disconnect_reconnect.dtdc = task->datain.data[pos+10] & 0x07;
mp->disconnect_reconnect.first_burst_size = htons(*(uint16_t *)&(task->datain.data[pos+12]));
mp->disconnect_reconnect.first_burst_size = scsi_get_uint16(&task->datain.data[pos+12]);
}
static void
@@ -1806,8 +1805,8 @@ scsi_parse_mode_informational_exceptions_control(struct scsi_task *task, int pos
mp->iec.ebackerr = task->datain.data[pos] & 0x02;
mp->iec.logerr = task->datain.data[pos] & 0x01;
mp->iec.mrie = task->datain.data[pos+1] & 0x0f;
mp->iec.interval_timer = htonl(*(uint32_t *)&(task->datain.data[pos+2]));
mp->iec.report_count = htonl(*(uint32_t *)&(task->datain.data[pos+6]));
mp->iec.interval_timer = scsi_get_uint32(&task->datain.data[pos+2]);
mp->iec.report_count = scsi_get_uint32(&task->datain.data[pos+6]);
}
@@ -1854,7 +1853,7 @@ scsi_modesense_datain_unmarshall(struct scsi_task *task)
if (mp->spf) {
mp->subpage_code = task->datain.data[pos++];
mp->len = ntohs(*(uint16_t *)&task->datain.data[pos]);
mp->len = scsi_get_uint16(&task->datain.data[pos]);
pos += 2;
} else {
mp->subpage_code = 0;
@@ -1972,8 +1971,8 @@ scsi_cdb_synchronizecache10(int lba, int num_blocks, int syncnv, int immed)
if (immed) {
task->cdb[1] |= 0x02;
}
*(uint32_t *)&task->cdb[2] = htonl(lba);
*(uint16_t *)&task->cdb[7] = htons(num_blocks);
scsi_set_uint32(&task->cdb[2], lba);
scsi_set_uint16(&task->cdb[7], num_blocks);
task->cdb_size = 10;
task->xfer_dir = SCSI_XFER_NONE;
@@ -2004,9 +2003,9 @@ scsi_cdb_synchronizecache16(uint64_t lba, uint32_t num_blocks, int syncnv, int i
if (immed) {
task->cdb[1] |= 0x02;
}
*(uint32_t *)&task->cdb[2] = htonl(lba >> 32);
*(uint32_t *)&task->cdb[6] = htonl(lba & 0xffffffff);
*(uint32_t *)&task->cdb[10] = htonl(num_blocks);
scsi_set_uint32(&task->cdb[2], lba >> 32);
scsi_set_uint32(&task->cdb[6], lba & 0xffffffff);
scsi_set_uint32(&task->cdb[10], num_blocks);
task->cdb_size = 16;
task->xfer_dir = SCSI_XFER_NONE;
@@ -2034,9 +2033,9 @@ scsi_cdb_prefetch10(uint32_t lba, int num_blocks, int immed, int group)
if (immed) {
task->cdb[1] |= 0x02;
}
*(uint32_t *)&task->cdb[2] = htonl(lba);
scsi_set_uint32(&task->cdb[2], lba);
task->cdb[6] |= group & 0x1f;
*(uint16_t *)&task->cdb[7] = htons(num_blocks);
scsi_set_uint16(&task->cdb[7], num_blocks);
task->cdb_size = 10;
task->xfer_dir = SCSI_XFER_NONE;
@@ -2064,9 +2063,9 @@ scsi_cdb_prefetch16(uint64_t lba, int num_blocks, int immed, int group)
if (immed) {
task->cdb[1] |= 0x02;
}
*(uint32_t *)&task->cdb[2] = htonl(lba >> 32);
*(uint32_t *)&task->cdb[6] = htonl(lba & 0xffffffff);
*(uint32_t *)&task->cdb[10] = htonl(num_blocks);
scsi_set_uint32(&task->cdb[2], lba >> 32);
scsi_set_uint32(&task->cdb[6], lba & 0xffffffff);
scsi_set_uint32(&task->cdb[10], num_blocks);
task->cdb[14] |= group & 0x1f;
@@ -2095,7 +2094,7 @@ scsi_cdb_serviceactionin16(enum scsi_service_action_in sa, uint32_t xferlen)
task->cdb[1] = sa;
*(uint32_t *)&task->cdb[10] = htonl(xferlen);
scsi_set_uint32(&task->cdb[10], xferlen);
task->cdb_size = 16;
if (xferlen != 0) {
@@ -2135,9 +2134,9 @@ scsi_cdb_get_lba_status(uint64_t starting_lba, uint32_t alloc_len)
task->cdb[1] = SCSI_GET_LBA_STATUS;
*(uint32_t *)&task->cdb[2] = htonl(starting_lba >> 32);
*(uint32_t *)&task->cdb[6] = htonl(starting_lba & 0xffffffff);
*(uint32_t *)&task->cdb[10] = htonl(alloc_len);
scsi_set_uint32(&task->cdb[2], starting_lba >> 32);
scsi_set_uint32(&task->cdb[6], starting_lba & 0xffffffff);
scsi_set_uint32(&task->cdb[10], alloc_len);
task->cdb_size = 16;
if (alloc_len != 0) {
@@ -2174,8 +2173,8 @@ scsi_cdb_writeverify10(uint32_t lba, uint32_t xferlen, int blocksize, int wrprot
task->cdb[1] |= 0x02;
}
*(uint32_t *)&task->cdb[2] = htonl(lba);
*(uint16_t *)&task->cdb[7] = htons(xferlen/blocksize);
scsi_set_uint32(&task->cdb[2], lba);
scsi_set_uint16(&task->cdb[7], xferlen/blocksize);
task->cdb[6] |= (group_number & 0x1f);
@@ -2214,8 +2213,8 @@ scsi_cdb_writeverify12(uint32_t lba, uint32_t xferlen, int blocksize, int wrprot
task->cdb[1] |= 0x02;
}
*(uint32_t *)&task->cdb[2] = htonl(lba);
*(uint32_t *)&task->cdb[6] = htonl(xferlen/blocksize);
scsi_set_uint32(&task->cdb[2], lba);
scsi_set_uint32(&task->cdb[6], xferlen/blocksize);
task->cdb[10] |= (group_number & 0x1f);
@@ -2254,9 +2253,9 @@ scsi_cdb_writeverify16(uint64_t lba, uint32_t xferlen, int blocksize, int wrprot
task->cdb[1] |= 0x02;
}
*(uint32_t *)&task->cdb[2] = htonl(lba >> 32);
*(uint32_t *)&task->cdb[6] = htonl(lba & 0xffffffff);
*(uint32_t *)&task->cdb[10] = htonl(xferlen/blocksize);
scsi_set_uint32(&task->cdb[2], lba >> 32);
scsi_set_uint32(&task->cdb[6], lba & 0xffffffff);
scsi_set_uint32(&task->cdb[10], xferlen/blocksize);
task->cdb[14] |= (group_number & 0x1f);

2
lib/task_mgmt.c
View File

@@ -87,7 +87,7 @@ iscsi_process_task_mgmt_reply(struct iscsi_context *iscsi, struct iscsi_pdu *pdu
response = in->hdr[2];
maxcmdsn = ntohl(*(uint32_t *)&in->hdr[32]);
maxcmdsn = scsi_get_uint32(&in->hdr[32]);
if (maxcmdsn > iscsi->maxcmdsn) {
iscsi->maxcmdsn = maxcmdsn;
}