aaru-dps/aaruremote
1
0
Fork 0
mirror of https://github.com/aaru-dps/aaruremote.git synced 2025-12-16 19:24:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Code refactor and format.

Browse Source
This commit is contained in:
Natalia Portillo
2020-10-31 02:28:50 +00:00
parent 00b30ece2e
commit fabe9f8b40
6 changed files with 151 additions and 198 deletions
Download Patch File Download Diff File Expand all files Collapse all files

205
freebsd/ata.c
View File

@@ -54,14 +54,14 @@ int32_t SendAtaChsCommand(void* device_ctx,
uint32_t* buf_len)
{
DeviceContext* ctx = device_ctx;
*duration = 0;
*sense = false;
union ccb* camccb;
int error;
int clock_error;
*duration = 0;
*sense = false;
union ccb* camccb;
int error;
int clock_error;
struct timespec start_tp;
struct timespec end_tp;
double start, end;
double start, end;
if(!ctx) return -1;
if(!ctx->device) return -1;
@@ -70,14 +70,14 @@ int32_t SendAtaChsCommand(void* device_ctx,
if(!camccb) return -1;
camccb->ccb_h.func_code = XPT_ATA_IO;
camccb->ccb_h.flags = AtaProtocolToCamFlags(protocol);
camccb->ccb_h.xflags = 0;
camccb->ccb_h.func_code = XPT_ATA_IO;
camccb->ccb_h.flags = AtaProtocolToCamFlags(protocol);
camccb->ccb_h.xflags = 0;
camccb->ccb_h.retry_count = 1;
camccb->ccb_h.cbfcnp = NULL;
camccb->ccb_h.timeout = timeout;
camccb->ataio.data_ptr = (u_int8_t *)buffer;
camccb->ataio.dxfer_len = *buf_len;
camccb->ccb_h.cbfcnp = NULL;
camccb->ccb_h.timeout = timeout;
camccb->ataio.data_ptr = (u_int8_t*)buffer;
camccb->ataio.dxfer_len = *buf_len;
camccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
camccb->ataio.cmd.flags = CAM_ATAIO_NEEDRESULT;
@@ -86,28 +86,23 @@ int32_t SendAtaChsCommand(void* device_ctx,
case AARUREMOTE_ATA_PROTOCOL_DMA:
case AARUREMOTE_ATA_PROTOCOL_DMA_QUEUED:
case AARUREMOTE_ATA_PROTOCOL_UDMA_IN:
case AARUREMOTE_ATA_PROTOCOL_UDMA_OUT:
camccb->ataio.cmd.flags |= CAM_ATAIO_DMA;
break;
case AARUREMOTE_ATA_PROTOCOL_FPDMA:
camccb->ataio.cmd.flags |= CAM_ATAIO_FPDMA;
break;
case AARUREMOTE_ATA_PROTOCOL_UDMA_OUT: camccb->ataio.cmd.flags |= CAM_ATAIO_DMA; break;
case AARUREMOTE_ATA_PROTOCOL_FPDMA: camccb->ataio.cmd.flags |= CAM_ATAIO_FPDMA; break;
}
camccb->ataio.cmd.command = registers.command;
camccb->ataio.cmd.lba_high = registers.cylinder_high;
camccb->ataio.cmd.lba_mid =registers.cylinder_low;
camccb->ataio.cmd.device = 0x40 |registers.device_head;
camccb->ataio.cmd.features = registers.feature;
camccb->ataio.cmd.sector_count= registers.sector_count;
camccb->ataio.cmd.lba_low= registers.sector;
camccb->ataio.cmd.command = registers.command;
camccb->ataio.cmd.lba_high = registers.cylinder_high;
camccb->ataio.cmd.lba_mid = registers.cylinder_low;
camccb->ataio.cmd.device = 0x40 | registers.device_head;
camccb->ataio.cmd.features = registers.feature;
camccb->ataio.cmd.sector_count = registers.sector_count;
camccb->ataio.cmd.lba_low = registers.sector;
clock_error = clock_gettime(CLOCK_REALTIME_PRECISE, &start_tp);
error = cam_send_ccb(ctx->device, camccb);
if(!clock_error)
clock_error = clock_gettime(CLOCK_REALTIME_PRECISE, &end_tp);
if(!clock_error) clock_error = clock_gettime(CLOCK_REALTIME_PRECISE, &end_tp);
if(!clock_error)
{
@@ -116,29 +111,27 @@ int32_t SendAtaChsCommand(void* device_ctx,
end = (double)end_tp.tv_sec * 1000.0;
end += (double)end_tp.tv_nsec / 1000000.0;
*duration = (uint32_t)(end-start);
*duration = (uint32_t)(end - start);
}
if(error < 0)
error = errno;
if(error < 0) error = errno;
if((camccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP &&
(camccb->ccb_h.status & CAM_STATUS_MASK) != CAM_ATA_STATUS_ERROR)
(camccb->ccb_h.status & CAM_STATUS_MASK) != CAM_ATA_STATUS_ERROR)
{
error = errno;
error = errno;
*sense = true;
}
if((camccb->ccb_h.status & CAM_STATUS_MASK) == CAM_ATA_STATUS_ERROR)
*sense = true;
if((camccb->ccb_h.status & CAM_STATUS_MASK) == CAM_ATA_STATUS_ERROR) *sense = true;
error_registers->cylinder_high = camccb->ataio.res.lba_high;
error_registers->cylinder_low = camccb->ataio.res.lba_mid;
error_registers->device_head = camccb->ataio.res.device;
error_registers->error = camccb->ataio.res.error;
error_registers->sector = camccb->ataio.res.lba_low;
error_registers->error = camccb->ataio.res.error;
error_registers->sector = camccb->ataio.res.lba_low;
error_registers->sector_count = camccb->ataio.res.sector_count;
error_registers->status = camccb->ataio.res.status;
error_registers->status = camccb->ataio.res.status;
cam_freeccb(camccb);
@@ -162,14 +155,14 @@ int32_t SendAtaLba28Command(void* device_ctx,
uint32_t* buf_len)
{
DeviceContext* ctx = device_ctx;
*duration = 0;
*sense = false;
union ccb* camccb;
int error;
int clock_error;
*duration = 0;
*sense = false;
union ccb* camccb;
int error;
int clock_error;
struct timespec start_tp;
struct timespec end_tp;
double start, end;
double start, end;
if(!ctx) return -1;
if(!ctx->device) return -1;
@@ -178,14 +171,14 @@ int32_t SendAtaLba28Command(void* device_ctx,
if(!camccb) return -1;
camccb->ccb_h.func_code = XPT_ATA_IO;
camccb->ccb_h.flags = AtaProtocolToCamFlags(protocol);
camccb->ccb_h.xflags = 0;
camccb->ccb_h.func_code = XPT_ATA_IO;
camccb->ccb_h.flags = AtaProtocolToCamFlags(protocol);
camccb->ccb_h.xflags = 0;
camccb->ccb_h.retry_count = 1;
camccb->ccb_h.cbfcnp = NULL;
camccb->ccb_h.timeout = timeout;
camccb->ataio.data_ptr = (u_int8_t *)buffer;
camccb->ataio.dxfer_len = *buf_len;
camccb->ccb_h.cbfcnp = NULL;
camccb->ccb_h.timeout = timeout;
camccb->ataio.data_ptr = (u_int8_t*)buffer;
camccb->ataio.dxfer_len = *buf_len;
camccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
camccb->ataio.cmd.flags = CAM_ATAIO_NEEDRESULT;
@@ -194,28 +187,23 @@ int32_t SendAtaLba28Command(void* device_ctx,
case AARUREMOTE_ATA_PROTOCOL_DMA:
case AARUREMOTE_ATA_PROTOCOL_DMA_QUEUED:
case AARUREMOTE_ATA_PROTOCOL_UDMA_IN:
case AARUREMOTE_ATA_PROTOCOL_UDMA_OUT:
camccb->ataio.cmd.flags |= CAM_ATAIO_DMA;
break;
case AARUREMOTE_ATA_PROTOCOL_FPDMA:
camccb->ataio.cmd.flags |= CAM_ATAIO_FPDMA;
break;
case AARUREMOTE_ATA_PROTOCOL_UDMA_OUT: camccb->ataio.cmd.flags |= CAM_ATAIO_DMA; break;
case AARUREMOTE_ATA_PROTOCOL_FPDMA: camccb->ataio.cmd.flags |= CAM_ATAIO_FPDMA; break;
}
camccb->ataio.cmd.command = registers.command;
camccb->ataio.cmd.lba_high = registers.lba_high;
camccb->ataio.cmd.lba_mid =registers.lba_mid;
camccb->ataio.cmd.device = 0x40 |registers.device_head;
camccb->ataio.cmd.features = registers.feature;
camccb->ataio.cmd.sector_count= registers.sector_count;
camccb->ataio.cmd.lba_low= registers.lba_low;
camccb->ataio.cmd.command = registers.command;
camccb->ataio.cmd.lba_high = registers.lba_high;
camccb->ataio.cmd.lba_mid = registers.lba_mid;
camccb->ataio.cmd.device = 0x40 | registers.device_head;
camccb->ataio.cmd.features = registers.feature;
camccb->ataio.cmd.sector_count = registers.sector_count;
camccb->ataio.cmd.lba_low = registers.lba_low;
clock_error = clock_gettime(CLOCK_REALTIME_PRECISE, &start_tp);
error = cam_send_ccb(ctx->device, camccb);
if(!clock_error)
clock_error = clock_gettime(CLOCK_REALTIME_PRECISE, &end_tp);
if(!clock_error) clock_error = clock_gettime(CLOCK_REALTIME_PRECISE, &end_tp);
if(!clock_error)
{
@@ -224,21 +212,19 @@ int32_t SendAtaLba28Command(void* device_ctx,
end = (double)end_tp.tv_sec * 1000.0;
end += (double)end_tp.tv_nsec / 1000000.0;
*duration = (uint32_t)(end-start);
*duration = (uint32_t)(end - start);
}
if(error < 0)
error = errno;
if(error < 0) error = errno;
if((camccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP &&
(camccb->ccb_h.status & CAM_STATUS_MASK) != CAM_ATA_STATUS_ERROR)
(camccb->ccb_h.status & CAM_STATUS_MASK) != CAM_ATA_STATUS_ERROR)
{
error = errno;
error = errno;
*sense = true;
}
if((camccb->ccb_h.status & CAM_STATUS_MASK) == CAM_ATA_STATUS_ERROR)
*sense = true;
if((camccb->ccb_h.status & CAM_STATUS_MASK) == CAM_ATA_STATUS_ERROR) *sense = true;
error_registers->lba_high = camccb->ataio.res.lba_high;
error_registers->lba_mid = camccb->ataio.res.lba_mid;
@@ -270,14 +256,14 @@ int32_t SendAtaLba48Command(void* device_ctx,
uint32_t* buf_len)
{
DeviceContext* ctx = device_ctx;
*duration = 0;
*sense = false;
union ccb* camccb;
int error;
int clock_error;
*duration = 0;
*sense = false;
union ccb* camccb;
int error;
int clock_error;
struct timespec start_tp;
struct timespec end_tp;
double start, end;
double start, end;
if(!ctx) return -1;
if(!ctx->device) return -1;
@@ -288,14 +274,14 @@ int32_t SendAtaLba48Command(void* device_ctx,
// TODO CHECK: 48-bit ATA CAM commands can crash FreeBSD < 9.2-RELEASE
camccb->ccb_h.func_code = XPT_ATA_IO;
camccb->ccb_h.flags = AtaProtocolToCamFlags(protocol);
camccb->ccb_h.xflags = 0;
camccb->ccb_h.func_code = XPT_ATA_IO;
camccb->ccb_h.flags = AtaProtocolToCamFlags(protocol);
camccb->ccb_h.xflags = 0;
camccb->ccb_h.retry_count = 1;
camccb->ccb_h.cbfcnp = NULL;
camccb->ccb_h.timeout = timeout;
camccb->ataio.data_ptr = (u_int8_t *)buffer;
camccb->ataio.dxfer_len = *buf_len;
camccb->ccb_h.cbfcnp = NULL;
camccb->ccb_h.timeout = timeout;
camccb->ataio.data_ptr = (u_int8_t*)buffer;
camccb->ataio.dxfer_len = *buf_len;
camccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
camccb->ataio.cmd.flags = CAM_ATAIO_NEEDRESULT | CAM_ATAIO_48BIT;
@@ -304,33 +290,28 @@ int32_t SendAtaLba48Command(void* device_ctx,
case AARUREMOTE_ATA_PROTOCOL_DMA:
case AARUREMOTE_ATA_PROTOCOL_DMA_QUEUED:
case AARUREMOTE_ATA_PROTOCOL_UDMA_IN:
case AARUREMOTE_ATA_PROTOCOL_UDMA_OUT:
camccb->ataio.cmd.flags |= CAM_ATAIO_DMA;
break;
case AARUREMOTE_ATA_PROTOCOL_FPDMA:
camccb->ataio.cmd.flags |= CAM_ATAIO_FPDMA;
break;
case AARUREMOTE_ATA_PROTOCOL_UDMA_OUT: camccb->ataio.cmd.flags |= CAM_ATAIO_DMA; break;
case AARUREMOTE_ATA_PROTOCOL_FPDMA: camccb->ataio.cmd.flags |= CAM_ATAIO_FPDMA; break;
}
camccb->ataio.cmd.command = registers.command;
camccb->ataio.cmd.device = 0x40 |registers.device_head;
camccb->ataio.cmd.lba_high_exp = (registers.lba_high & 0xFF00) >> 8;
camccb->ataio.cmd.lba_high = registers.lba_high & 0xFF;
camccb->ataio.cmd.lba_mid_exp =(registers.lba_mid & 0xFF00) >> 8;
camccb->ataio.cmd.lba_mid =registers.lba_mid & 0xFF;
camccb->ataio.cmd.lba_low_exp= (registers.lba_low & 0xFF00) >> 8;
camccb->ataio.cmd.lba_low= registers.lba_low & 0xFF;
camccb->ataio.cmd.features_exp = (registers.feature & 0xFF00) >> 8;
camccb->ataio.cmd.features = registers.feature & 0xFF;
camccb->ataio.cmd.sector_count_exp= (registers.sector_count & 0xFF00) >> 8;
camccb->ataio.cmd.sector_count= registers.sector_count & 0xFF;
camccb->ataio.cmd.command = registers.command;
camccb->ataio.cmd.device = 0x40 | registers.device_head;
camccb->ataio.cmd.lba_high_exp = (registers.lba_high & 0xFF00) >> 8;
camccb->ataio.cmd.lba_high = registers.lba_high & 0xFF;
camccb->ataio.cmd.lba_mid_exp = (registers.lba_mid & 0xFF00) >> 8;
camccb->ataio.cmd.lba_mid = registers.lba_mid & 0xFF;
camccb->ataio.cmd.lba_low_exp = (registers.lba_low & 0xFF00) >> 8;
camccb->ataio.cmd.lba_low = registers.lba_low & 0xFF;
camccb->ataio.cmd.features_exp = (registers.feature & 0xFF00) >> 8;
camccb->ataio.cmd.features = registers.feature & 0xFF;
camccb->ataio.cmd.sector_count_exp = (registers.sector_count & 0xFF00) >> 8;
camccb->ataio.cmd.sector_count = registers.sector_count & 0xFF;
clock_error = clock_gettime(CLOCK_REALTIME_PRECISE, &start_tp);
error = cam_send_ccb(ctx->device, camccb);
if(!clock_error)
clock_error = clock_gettime(CLOCK_REALTIME_PRECISE, &end_tp);
if(!clock_error) clock_error = clock_gettime(CLOCK_REALTIME_PRECISE, &end_tp);
if(!clock_error)
{
@@ -339,21 +320,19 @@ int32_t SendAtaLba48Command(void* device_ctx,
end = (double)end_tp.tv_sec * 1000.0;
end += (double)end_tp.tv_nsec / 1000000.0;
*duration = (uint32_t)(end-start);
*duration = (uint32_t)(end - start);
}
if(error < 0)
error = errno;
if(error < 0) error = errno;
if((camccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP &&
(camccb->ccb_h.status & CAM_STATUS_MASK) != CAM_ATA_STATUS_ERROR)
(camccb->ccb_h.status & CAM_STATUS_MASK) != CAM_ATA_STATUS_ERROR)
{
error = errno;
error = errno;
*sense = true;
}
if((camccb->ccb_h.status & CAM_STATUS_MASK) == CAM_ATA_STATUS_ERROR)
*sense = true;
if((camccb->ccb_h.status & CAM_STATUS_MASK) == CAM_ATA_STATUS_ERROR) *sense = true;
error_registers->lba_high = (camccb->ataio.res.lba_high_exp << 8) + camccb->ataio.res.lba_high;
error_registers->lba_mid = (camccb->ataio.res.lba_mid_exp << 8) + camccb->ataio.res.lba_mid;

29
freebsd/device.c
View File

@@ -64,8 +64,7 @@ void DeviceClose(void* device_ctx)
if(!ctx) return;
if(ctx->device)
cam_close_device(ctx->device);
if(ctx->device) cam_close_device(ctx->device);
close(ctx->fd);
@@ -75,9 +74,9 @@ void DeviceClose(void* device_ctx)
int32_t GetDeviceType(void* device_ctx)
{
DeviceContext* ctx = device_ctx;
union ccb* camccb;
int ret;
int32_t device_type = AARUREMOTE_DEVICE_TYPE_UNKNOWN;
union ccb* camccb;
int ret;
int32_t device_type = AARUREMOTE_DEVICE_TYPE_UNKNOWN;
if(!ctx) return -1;
if(!ctx->device) return -1;
@@ -99,25 +98,15 @@ int32_t GetDeviceType(void* device_ctx)
switch(camccb->cgd.protocol)
{
case PROTO_ATA:
case PROTO_SATAPM:
device_type = AARUREMOTE_DEVICE_TYPE_ATA;
break;
case PROTO_ATAPI:
device_type = AARUREMOTE_DEVICE_TYPE_ATAPI;
break;
case PROTO_SCSI:
device_type = AARUREMOTE_DEVICE_TYPE_SCSI;
break;
case PROTO_NVME:
device_type = AARUREMOTE_DEVICE_TYPE_NVME;
break;
case PROTO_SATAPM: device_type = AARUREMOTE_DEVICE_TYPE_ATA; break;
case PROTO_ATAPI: device_type = AARUREMOTE_DEVICE_TYPE_ATAPI; break;
case PROTO_SCSI: device_type = AARUREMOTE_DEVICE_TYPE_SCSI; break;
case PROTO_NVME: device_type = AARUREMOTE_DEVICE_TYPE_NVME; break;
case PROTO_MMCSD:
// TODO: MMC vs SD
device_type = AARUREMOTE_DEVICE_TYPE_MMC;
break;
default:
device_type = AARUREMOTE_DEVICE_TYPE_UNKNOWN;
break;
default: device_type = AARUREMOTE_DEVICE_TYPE_UNKNOWN; break;
}
cam_freeccb(camccb);

8
freebsd/freebsd.h
View File

@@ -19,14 +19,14 @@
#define AARUREMOTE_FREEBSD_FREEBSD_H_
// Included here as it seems to need to be after all others
#include <stdio.h>
#include <camlib.h>
#include <stdio.h>
typedef struct
{
int fd;
char device_path[4096];
struct cam_device *device;
int fd;
char device_path[4096];
struct cam_device* device;
} DeviceContext;
#endif // AARUREMOTE_FREEBSD_FREEBSD_H_

21
freebsd/list_devices.c
View File

@@ -28,13 +28,13 @@
DeviceInfoList* ListDevices()
{
DeviceInfoList* list_start = NULL, *list_current = NULL, *list_next = NULL;
DeviceInfoList * list_start = NULL, *list_current = NULL, *list_next = NULL;
DIR* dir;
struct dirent* dirent;
struct cam_device* camdev;
union ccb* camccb;
int ret;
int i;
union ccb* camccb;
int ret;
int i;
dir = opendir("/dev");
if(!dir) return NULL;
@@ -99,7 +99,7 @@ DeviceInfoList* ListDevices()
case PROTO_SATAPM:
// TODO: Split on space
strncpy(list_next->this.vendor, "ATA", 3);
strncpy(list_next->this.model, (const char *)camccb->cgd.ident_data.model, 40);
strncpy(list_next->this.model, (const char*)camccb->cgd.ident_data.model, 40);
// Trim spaces
for(i = 40; i > 0; i--)
@@ -109,18 +109,16 @@ DeviceInfoList* ListDevices()
list_next->this.model[i] = 0;
}
strncpy(list_next->this.serial, (const char *)camccb->cgd.ident_data.serial, 20);
strncpy(list_next->this.serial, (const char*)camccb->cgd.ident_data.serial, 20);
if(strncmp(camdev->sim_name, "ahcich", 6) == 0)
strncpy(list_next->this.bus, "SATA", 5);
if(strncmp(camdev->sim_name, "ahcich", 6) == 0) strncpy(list_next->this.bus, "SATA", 5);
else
strncpy(list_next->this.bus, "ATA", 4);
// TODO: This protocol didn't work in C#, does it work in C?
list_next->this.supported = strncmp(camdev->sim_name, "ata", 3) != 0;
if(camccb->cgd.protocol == PROTO_ATAPI)
goto protocol_atapi;
if(camccb->cgd.protocol == PROTO_ATAPI) goto protocol_atapi;
break;
case PROTO_SCSI:
@@ -128,8 +126,7 @@ DeviceInfoList* ListDevices()
strncpy(list_next->this.vendor, camccb->cgd.inq_data.vendor, 8);
strncpy(list_next->this.model, camccb->cgd.inq_data.product, 16);
if(strncmp(camdev->sim_name, "ata", 3) == 0 ||
strncmp(camdev->sim_name, "ahcich", 6) == 0)
if(strncmp(camdev->sim_name, "ata", 3) == 0 || strncmp(camdev->sim_name, "ahcich", 6) == 0)
strncpy(list_next->this.bus, "ATAPI", 5);
else
strncpy(list_next->this.bus, "SCSI", 4);

5
freebsd/pcmcia.c
View File

@@ -20,7 +20,4 @@
#include "../aaruremote.h"
#include "freebsd.h"
uint8_t GetPcmciaData(void* device_ctx, uint16_t* cis_len, char* cis)
{
return 0;
}
uint8_t GetPcmciaData(void* device_ctx, uint16_t* cis_len, char* cis) { return 0; }

81
freebsd/scsi.c
View File

@@ -38,31 +38,23 @@ int32_t SendScsiCommand(void* device_ctx,
uint32_t* sense_len)
{
DeviceContext* ctx = device_ctx;
*sense_len = 0;
*sense_buffer = NULL;
*duration = 0;
union ccb* camccb;
u_int32_t flags;
int error;
int clock_error;
*sense_len = 0;
*sense_buffer = NULL;
*duration = 0;
union ccb* camccb;
u_int32_t flags;
int error;
int clock_error;
struct timespec start_tp;
struct timespec end_tp;
double start, end;
double start, end;
switch(direction)
{
case AARUREMOTE_SCSI_DIRECTION_NONE:
flags = CAM_DIR_NONE;
break;
case AARUREMOTE_SCSI_DIRECTION_OUT:
flags = CAM_DIR_OUT;
break;
case AARUREMOTE_SCSI_DIRECTION_IN:
flags = CAM_DIR_IN;
break;
case AARUREMOTE_SCSI_DIRECTION_INOUT:
flags = CAM_DIR_BOTH;
break;
case AARUREMOTE_SCSI_DIRECTION_NONE: flags = CAM_DIR_NONE; break;
case AARUREMOTE_SCSI_DIRECTION_OUT: flags = CAM_DIR_OUT; break;
case AARUREMOTE_SCSI_DIRECTION_IN: flags = CAM_DIR_IN; break;
case AARUREMOTE_SCSI_DIRECTION_INOUT: flags = CAM_DIR_BOTH; break;
}
if(!ctx) return -1;
@@ -76,23 +68,22 @@ int32_t SendScsiCommand(void* device_ctx,
if(!camccb) return -1;
camccb->ccb_h.func_code = XPT_SCSI_IO;
camccb->ccb_h.flags = flags;
camccb->ccb_h.xflags = 0;
camccb->ccb_h.func_code = XPT_SCSI_IO;
camccb->ccb_h.flags = flags;
camccb->ccb_h.xflags = 0;
camccb->ccb_h.retry_count = 1;
camccb->ccb_h.cbfcnp = NULL;
camccb->ccb_h.timeout = timeout;
camccb->csio.data_ptr = (u_int8_t *)buffer;
camccb->csio.dxfer_len = *buf_len;
camccb->csio.sense_len = 32;
camccb->csio.cdb_len = cdb_len;
camccb->csio.tag_action = 0x20;
camccb->ccb_h.cbfcnp = NULL;
camccb->ccb_h.timeout = timeout;
camccb->csio.data_ptr = (u_int8_t*)buffer;
camccb->csio.dxfer_len = *buf_len;
camccb->csio.sense_len = 32;
camccb->csio.cdb_len = cdb_len;
camccb->csio.tag_action = 0x20;
if(cdb_len <= CAM_MAX_CDBLEN)
memcpy(camccb->csio.cdb_io.cdb_bytes, cdb, cdb_len);
if(cdb_len <= CAM_MAX_CDBLEN) memcpy(camccb->csio.cdb_io.cdb_bytes, cdb, cdb_len);
else
{
camccb->csio.cdb_io.cdb_ptr = (u_int8_t *)cdb;
camccb->csio.cdb_io.cdb_ptr = (u_int8_t*)cdb;
camccb->ccb_h.flags |= CAM_CDB_POINTER;
}
@@ -102,8 +93,7 @@ int32_t SendScsiCommand(void* device_ctx,
error = cam_send_ccb(ctx->device, camccb);
if(!clock_error)
clock_error = clock_gettime(CLOCK_REALTIME_PRECISE, &end_tp);
if(!clock_error) clock_error = clock_gettime(CLOCK_REALTIME_PRECISE, &end_tp);
if(!clock_error)
{
@@ -112,32 +102,33 @@ int32_t SendScsiCommand(void* device_ctx,
end = (double)end_tp.tv_sec * 1000.0;
end += (double)end_tp.tv_nsec / 1000000.0;
*duration = (uint32_t)(end-start);
*duration = (uint32_t)(end - start);
}
if(error < 0)
error = errno;
if(error < 0) error = errno;
if((camccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP &&
(camccb->ccb_h.status & CAM_STATUS_MASK) != CAM_SCSI_STATUS_ERROR)
(camccb->ccb_h.status & CAM_STATUS_MASK) != CAM_SCSI_STATUS_ERROR)
{
error = errno;
error = errno;
*sense = true;
}
if((camccb->ccb_h.status & CAM_STATUS_MASK) == CAM_SCSI_STATUS_ERROR)
{
*sense = true;
*sense_buffer = malloc(1);
*sense = true;
*sense_buffer = malloc(1);
(*sense_buffer)[0] = camccb->csio.scsi_status;
}
if((camccb->ccb_h.status & CAM_AUTOSNS_VALID) && camccb->csio.sense_len - camccb->csio.sense_resid > 0)
{
*sense = (camccb->ccb_h.status & CAM_STATUS_MASK) == CAM_SCSI_STATUS_ERROR;
*sense_buffer = malloc(camccb->csio.sense_len - camccb->csio.sense_resid);
*sense = (camccb->ccb_h.status & CAM_STATUS_MASK) == CAM_SCSI_STATUS_ERROR;
*sense_buffer = malloc(camccb->csio.sense_len - camccb->csio.sense_resid);
(*sense_buffer)[0] = camccb->csio.sense_data.error_code;
memcpy((*sense_buffer)+1, camccb->csio.sense_data.sense_buf, (camccb->csio.sense_len - camccb->csio.sense_resid) - 1);
memcpy((*sense_buffer) + 1,
camccb->csio.sense_data.sense_buf,
(camccb->csio.sense_len - camccb->csio.sense_resid) - 1);
}
cam_freeccb(camccb);