Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Get rid of c99isms in the form of variable number of args to CPP macros. 

This should slim down the resulting binaries a fair bit as well.
This commit is contained in:
agc 2006-03-12 18:47:27 +00:00
parent 40a6c72b1d
commit a4c7ca1aeb
23 changed files with 1663 additions and 1647 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
dist/iscsi/include/parameters.h vendored
View File

@ -146,25 +146,25 @@ void set_session_parameters(iscsi_parameter_t * , iscsi_sess_param_t
#define PARAM_LIST_DESTROY(LIST, ELSE) \
if (param_list_destroy(LIST)!=0) { \
TRACE_ERROR("param_list_destroy() failed\n"); \
iscsi_trace_error("param_list_destroy() failed\n"); \
ELSE; \
}
#define PARAM_LIST_ADD(LIST, TYPE, KEY, DFLT, VALID, ELSE) \
if (param_list_add(LIST, TYPE, KEY, DFLT, VALID)!=0) { \
TRACE_ERROR("param_list_add() failed\n"); \
iscsi_trace_error("param_list_add() failed\n"); \
ELSE; \
}
#define PARAM_TEXT_ADD(LIST, KEY, VAL, TEXT, LEN, SIZE, OFFER, ELSE ) \
if (param_text_add(LIST, KEY, VAL, TEXT, LEN, SIZE, OFFER)!=0) { \
TRACE_ERROR("param_text_add() failed\n"); \
iscsi_trace_error("param_text_add() failed\n"); \
ELSE; \
}
#define PARAM_TEXT_PARSE(LIST, CRED, TEXT, LEN, TEXT_OUT, LEN_OUT, SIZE, OFFER, ELSE ) \
if (param_text_parse(LIST, CRED, TEXT, LEN, TEXT_OUT, LEN_OUT, SIZE, OFFER)!=0) { \
TRACE_ERROR("param_text_parse_offer() failed\n"); \
iscsi_trace_error("param_text_parse_offer() failed\n"); \
ELSE; \
}
#endif

88
dist/iscsi/include/util.h vendored
View File

@ -129,69 +129,15 @@
EXTERN uint32_t iscsi_debug_level;
void set_debug(const char *);
/*
* Debugging Functions
*/
void set_debug(const char *);
void iscsi_trace(const int, const char *, ...);
void iscsi_trace_warning(const char *, ...);
void iscsi_trace_error(const char *, ...);
void iscsi_print_buffer(const char *, const size_t);
#ifdef CONFIG_ISCSI_DEBUG
#define TRACE(trace, args...) do { \
if (iscsi_debug_level & trace) { \
char _iscsi_trace_buf[8192]; \
(void) snprintf(_iscsi_trace_buf, sizeof(_iscsi_trace_buf), args); \
PRINT("pid %i:%s:%d: %s", \
ISCSI_GETPID, __FILE__, __LINE__, \
_iscsi_trace_buf); \
} \
} while (/* CONSTCOND */ 0)
#define PRINT_BUFF(buf, len) do { \
if (iscsi_debug_level & TRACE_NET_BUFF) { \
int _i; \
for (_i=0 ; _i < len; _i++) { \
if (_i % 4 == 0) { \
if (_i) { \
PRINT("\n"); \
} \
PRINT("%4i:", _i); \
} \
PRINT("%2x ", (uint8_t) (buf)[_i]); \
} \
if ((len + 1) % 32) { \
PRINT("\n"); \
} \
} \
} while (/* CONSTCOND */ 0)
#define TRACE_WARNING(args...) do { \
if (iscsi_debug_level & TRACE_WARN) { \
char _iscsi_trace_buf[8192]; \
(void) snprintf(_iscsi_trace_buf, sizeof(_iscsi_trace_buf), args); \
PRINT("pid %i:%s:%i: ***WARNING*** %s", \
ISCSI_GETPID, __FILE__, __LINE__, \
_iscsi_trace_buf); \
} \
} while (/* CONSTCOND */ 0)
#define PRINT printf
#else
#define TRACE(trace, args...)
#define TRACE_WARNING(args...)
#define PRINT_BUFF(buf, len)
#define PRINT(args...)
#endif
#define TRACE_ERROR(args...) do { \
char _iscsi_trace_buf[8192]; \
(void) snprintf(_iscsi_trace_buf, sizeof(_iscsi_trace_buf), args); \
PRINT("pid %i:%s:%i: ***ERROR*** %s", \
ISCSI_GETPID, __FILE__, __LINE__, \
_iscsi_trace_buf); \
syslog(LOG_ERR, "pid %d:%s:%d: ***ERROR*** %s", \
ISCSI_GETPID, __FILE__, __LINE__, \
_iscsi_trace_buf); \
} while (/* CONSTCOND */ 0)
/*
* Byte Order
@ -240,15 +186,7 @@ void set_debug(const char *);
/*
#endif .* !linux */
/*
* Process ID
*/
#ifdef __KERNEL__
#define ISCSI_GETPID current->pid
#else
#define ISCSI_GETPID getpid()
#endif
#ifndef HAVE_SOCKLEN_T
typedef int socklen_t;
@ -414,28 +352,28 @@ int iscsi_mutex_destroy(iscsi_mutex_t * );
#define ISCSI_LOCK(M, ELSE) do { \
if (iscsi_mutex_lock(M) != 0) { \
TRACE_ERROR("iscsi_mutex_lock() failed\n"); \
iscsi_trace_error("iscsi_mutex_lock() failed\n"); \
ELSE; \
} \
} while (/* CONSTCOND */ 0)
#define ISCSI_UNLOCK(M, ELSE) do { \
if (iscsi_mutex_unlock(M) != 0) { \
TRACE_ERROR("iscsi_mutex_unlock() failed\n"); \
iscsi_trace_error("iscsi_mutex_unlock() failed\n"); \
ELSE; \
} \
} while (/* CONSTCOND */ 0)
#define ISCSI_MUTEX_INIT(M, ELSE) do { \
if (iscsi_mutex_init(M) != 0) { \
TRACE_ERROR("iscsi_mutex_init() failed\n"); \
iscsi_trace_error("iscsi_mutex_init() failed\n"); \
ELSE; \
} \
} while (/* CONSTCOND */ 0)
#define ISCSI_MUTEX_DESTROY(M, ELSE) do { \
if (iscsi_mutex_destroy(M) != 0) { \
TRACE_ERROR("iscsi_mutex_destroy() failed\n"); \
iscsi_trace_error("iscsi_mutex_destroy() failed\n"); \
ELSE; \
} \
} while (/* CONSTCOND */ 0)
@ -557,26 +495,26 @@ typedef struct {
#define NO_CLEANUP {}
#define RETURN_GREATER(NAME, V1, V2, CU, RC) \
if ((V1)>(V2)) { \
TRACE_ERROR("Bad \"%s\": %u > %u.\n", NAME, (unsigned)V1, (unsigned)V2); \
iscsi_trace_error("Bad \"%s\": %u > %u.\n", NAME, (unsigned)V1, (unsigned)V2); \
CU; \
return RC; \
}
#define RETURN_NOT_EQUAL(NAME, V1, V2, CU, RC) \
if ((V1)!=(V2)) { \
TRACE_ERROR("Bad \"%s\": Got %u expected %u.\n", NAME, V1, V2); \
iscsi_trace_error("Bad \"%s\": Got %u expected %u.\n", NAME, V1, V2); \
CU; \
return RC; \
}
#define WARN_NOT_EQUAL(NAME, V1, V2) \
if ((V1)!=(V2)) { \
TRACE_WARNING("Bad \"%s\": Got %u expected %u.\n", NAME, V1, V2); \
iscsi_trace_warning("Bad \"%s\": Got %u expected %u.\n", NAME, V1, V2); \
}
#define RETURN_EQUAL(NAME, V1, V2, CU, RC) \
if ((V1)==(V2)) { \
TRACE_ERROR("Bad \"%s\": %u == %u.\n", NAME, V1, V2); \
iscsi_trace_error("Bad \"%s\": %u == %u.\n", NAME, V1, V2); \
CU; \
return RC; \
}

104
dist/iscsi/src/disk.c vendored
View File

@ -1,4 +1,4 @@
/* $NetBSD: disk.c,v 1.5 2006/02/24 20:47:30 agc Exp $ */
/* $NetBSD: disk.c,v 1.6 2006/03/12 18:47:28 agc Exp $ */
/*
* Copyright © 2006 Alistair Crooks. All rights reserved.
@ -441,13 +441,13 @@ device_write(disc_device_t *dp, void *buf, size_t cc)
switch (dp->xv[d].type) {
case DE_DEVICE:
if ((ret = device_write(dp->xv[d].u.dp, buf, cc)) < 0) {
TRACE_ERROR("device_write RAID1 device write failure\n");
iscsi_trace_error("device_write RAID1 device write failure\n");
return -1;
}
break;
case DE_EXTENT:
if ((ret = extent_write(dp->xv[d].u.xp, buf, cc)) < 0) {
TRACE_ERROR("device_write RAID1 extent write failure\n");
iscsi_trace_error("device_write RAID1 extent write failure\n");
return -1;
}
break;
@ -672,15 +672,15 @@ de_allocate(disc_de_t *de, char *filename)
size = de_getsize(de);
if (de_lseek(de, size - 1, SEEK_SET) == -1) {
TRACE_ERROR("error seeking \"%s\"\n", filename);
iscsi_trace_error("error seeking \"%s\"\n", filename);
return 0;
}
if (de_read(de, &ch, 1) == -1) {
TRACE_ERROR("error reading \"%s\"", filename);
iscsi_trace_error("error reading \"%s\"", filename);
return 0;
}
if (de_write(de, &ch, 1) == -1) {
TRACE_ERROR("error writing \"%s\"", filename);
iscsi_trace_error("error writing \"%s\"", filename);
return 0;
}
return 1;
@ -732,7 +732,7 @@ device_init(globals_t *gp, targv_t *tvp, disc_target_t *tp)
case 4096:
break;
default:
TRACE_ERROR("Invalid block len %" PRIu64 ". Choose one of 512, 1024, 2048, 4096.\n", disks.v[disks.c].blocklen);
iscsi_trace_error("Invalid block len %" PRIu64 ". Choose one of 512, 1024, 2048, 4096.\n", disks.v[disks.c].blocklen);
return -1;
}
#if 0
@ -742,31 +742,31 @@ device_init(globals_t *gp, targv_t *tvp, disc_target_t *tp)
#else
disks.v[disks.c].type = ISCSI_FS;
#endif
PRINT("DISK: %" PRIu64 " logical units (%" PRIu64 " blocks, %" PRIu64 " bytes/block), type %s\n",
printf("DISK: %" PRIu64 " logical units (%" PRIu64 " blocks, %" PRIu64 " bytes/block), type %s\n",
disks.v[disks.c].luns, disks.v[disks.c].blockc, disks.v[disks.c].blocklen,
(disks.v[disks.c].type == ISCSI_FS) ? "iscsi fs" :
(disks.v[disks.c].type == ISCSI_FS_MMAP) ? "iscsi fs mmap" : "iscsi ramdisk");
for (i = 0; i < disks.v[disks.c].luns; i++) {
PRINT("DISK: LU %i: ", i);
printf("DISK: LU %i: ", i);
if (disks.v[disks.c].type == ISCSI_RAMDISK) {
if ((disks.v[disks.c].ramdisk[i] = iscsi_malloc((unsigned)disks.v[disks.c].size)) == NULL) {
TRACE_ERROR("iscsi_malloc() failed\n");
iscsi_trace_error("iscsi_malloc() failed\n");
return -1;
}
TRACE(TRACE_ISCSI_DEBUG, "allocated %" PRIu64 " bytes at %p\n", disks.v[disks.c].size, disks.v[disks.c].ramdisk[i]);
PRINT("%" PRIu64 " MB ramdisk\n", disks.v[disks.c].size / MB(1));
iscsi_trace(TRACE_ISCSI_DEBUG, "allocated %" PRIu64 " bytes at %p\n", disks.v[disks.c].size, disks.v[disks.c].ramdisk[i]);
printf("%" PRIu64 " MB ramdisk\n", disks.v[disks.c].size / MB(1));
} else {
(void) strlcpy(disks.v[disks.c].filename, disc_get_filename(&tp->de), sizeof(disks.v[disks.c].filename));
if (de_open(&tp->de, O_CREAT | O_RDWR, 0666) == -1) {
TRACE_ERROR("error opening \"%s\"\n", disks.v[disks.c].filename);
iscsi_trace_error("error opening \"%s\"\n", disks.v[disks.c].filename);
return -1;
}
if (!allocate_space(tp)) {
TRACE_ERROR("error allocating space for \"%s\"", tp->target);
iscsi_trace_error("error allocating space for \"%s\"", tp->target);
return -1;
}
PRINT("%" PRIu64 " MB disk storage for \"%s\"\n", (de_getsize(&tp->de) / MB(1)), tp->target);
printf("%" PRIu64 " MB disk storage for \"%s\"\n", (de_getsize(&tp->de) / MB(1)), tp->target);
}
}
return disks.c++;
@ -796,7 +796,7 @@ device_command(target_session_t * sess, target_cmd_t * cmd)
initialized = 1;
}
if (!flag[lun]) {
PRINT("DISK: Simulating CHECK CONDITION with sense data (cdb 0x%x, lun %i)\n", cdb[0], lun);
printf("DISK: Simulating CHECK CONDITION with sense data (cdb 0x%x, lun %i)\n", cdb[0], lun);
flag[lun]++;
args->status = 0x02;
args->length = 1024;
@ -822,18 +822,18 @@ device_command(target_session_t * sess, target_cmd_t * cmd)
args->status = 0;
return 0;
}
TRACE(TRACE_SCSI_CMD, "SCSI op 0x%x (lun %i): \n", cdb[0], lun);
iscsi_trace(TRACE_SCSI_CMD, "SCSI op 0x%x (lun %i): \n", cdb[0], lun);
switch (cdb[0]) {
case TEST_UNIT_READY:
TRACE(TRACE_SCSI_CMD, "TEST_UNIT_READY\n");
iscsi_trace(TRACE_SCSI_CMD, "TEST_UNIT_READY\n");
args->status = 0;
args->length = 0;
break;
case INQUIRY:
TRACE(TRACE_SCSI_CMD, "INQUIRY\n");
iscsi_trace(TRACE_SCSI_CMD, "INQUIRY\n");
data = args->send_data;
(void) memset(data, 0x0, (unsigned) cdb[4]); /* Clear allocated buffer */
data[0] = 0; /* Peripheral Device Type */
@ -862,14 +862,14 @@ device_command(target_session_t * sess, target_cmd_t * cmd)
case LOAD_UNLOAD:
TRACE(TRACE_SCSI_CMD, "LOAD_UNLOAD\n");
iscsi_trace(TRACE_SCSI_CMD, "LOAD_UNLOAD\n");
args->status = 0;
args->length = 0;
break;
case READ_CAPACITY:
TRACE(TRACE_SCSI_CMD, "READ_CAPACITY\n");
iscsi_trace(TRACE_SCSI_CMD, "READ_CAPACITY\n");
data = args->send_data;
*((uint32_t *) (void *)data) = (uint32_t) ISCSI_HTONL((uint32_t) disks.v[sess->d].blockc - 1); /* Max LBA */
*((uint32_t *) (void *)(data + 4)) = (uint32_t) ISCSI_HTONL((uint32_t) disks.v[sess->d].blocklen); /* Block len */
@ -885,9 +885,9 @@ device_command(target_session_t * sess, target_cmd_t * cmd)
if (!len) {
len = 256;
}
TRACE(TRACE_SCSI_CMD, "WRITE_6(lba %u, len %u blocks)\n", lba, len);
iscsi_trace(TRACE_SCSI_CMD, "WRITE_6(lba %u, len %u blocks)\n", lba, len);
if (disk_write(sess, args, lun, lba, (unsigned) len) != 0) {
TRACE_ERROR("disk_write() failed\n");
iscsi_trace_error("disk_write() failed\n");
args->status = 0x01;
}
args->length = 0;
@ -900,9 +900,9 @@ device_command(target_session_t * sess, target_cmd_t * cmd)
len = cdb[4];
if (!len)
len = 256;
TRACE(TRACE_SCSI_CMD, "READ_6(lba %u, len %u blocks)\n", lba, len);
iscsi_trace(TRACE_SCSI_CMD, "READ_6(lba %u, len %u blocks)\n", lba, len);
if (disk_read(sess, args, lba, len, lun) != 0) {
TRACE_ERROR("disk_read() failed\n");
iscsi_trace_error("disk_read() failed\n");
args->status = 0x01;
}
args->input = 1;
@ -914,7 +914,7 @@ device_command(target_session_t * sess, target_cmd_t * cmd)
len = ISCSI_MODE_SENSE_LEN;
mode_data_len = len + 3;
TRACE(TRACE_SCSI_CMD, "MODE_SENSE_6(len %u blocks)\n", len);
iscsi_trace(TRACE_SCSI_CMD, "MODE_SENSE_6(len %u blocks)\n", len);
(void) memset(cp, 0x0, (size_t) mode_data_len);
/* magic constants courtesy of some values in the Lunix UNH iSCSI target */
cp[0] = mode_data_len;
@ -950,9 +950,9 @@ device_command(target_session_t * sess, target_cmd_t * cmd)
((uint8_t *) (void *) &len)[1] = cdb[7];
#endif
TRACE(TRACE_SCSI_CMD, "WRITE_10(lba %u, len %u blocks)\n", lba, len);
iscsi_trace(TRACE_SCSI_CMD, "WRITE_10(lba %u, len %u blocks)\n", lba, len);
if (disk_write(sess, args, lun, lba, (unsigned) len) != 0) {
TRACE_ERROR("disk_write() failed\n");
iscsi_trace_error("disk_write() failed\n");
args->status = 0x01;
}
args->length = 0;
@ -981,9 +981,9 @@ device_command(target_session_t * sess, target_cmd_t * cmd)
((uint8_t *) (void *) &len)[1] = cdb[7];
#endif
TRACE(TRACE_SCSI_CMD, "READ_10(lba %u, len %u blocks)\n", lba, len);
iscsi_trace(TRACE_SCSI_CMD, "READ_10(lba %u, len %u blocks)\n", lba, len);
if (disk_read(sess, args, lba, len, lun) != 0) {
TRACE_ERROR("disk_read() failed\n");
iscsi_trace_error("disk_read() failed\n");
args->status = 0x01;
}
args->input = 1;
@ -996,27 +996,27 @@ device_command(target_session_t * sess, target_cmd_t * cmd)
case SYNC_CACHE:
TRACE(TRACE_SCSI_CMD, "SYNC_CACHE\n");
iscsi_trace(TRACE_SCSI_CMD, "SYNC_CACHE\n");
args->status = 0;
args->length = 0;
break;
case LOG_SENSE:
TRACE(TRACE_SCSI_CMD, "LOG_SENSE\n");
iscsi_trace(TRACE_SCSI_CMD, "LOG_SENSE\n");
args->status = 0;
args->length = 0;
break;
case UNKNOWN_5E:
TRACE(TRACE_SCSI_CMD, "UNKNOWN_5E\n");
iscsi_trace(TRACE_SCSI_CMD, "UNKNOWN_5E\n");
args->status = 0;
args->length = 0;
break;
case REPORT_LUNS:
TRACE(TRACE_SCSI_CMD, "REPORT LUNS\n");
iscsi_trace(TRACE_SCSI_CMD, "REPORT LUNS\n");
data = args->send_data;
data[3] = CONFIG_DISK_MAX_LUNS;
/* just report CONFIG_DISK_MAX_LUNS LUNs and be done with it */
@ -1026,12 +1026,12 @@ device_command(target_session_t * sess, target_cmd_t * cmd)
break;
default:
TRACE_ERROR("UNKNOWN OPCODE 0x%x\n", cdb[0]);
iscsi_trace_error("UNKNOWN OPCODE 0x%x\n", cdb[0]);
/* to not cause confusion with some initiators */
args->status = 0x02;
break;
}
TRACE(TRACE_SCSI_DEBUG, "SCSI op 0x%x: done (status 0x%x)\n", cdb[0], args->status);
iscsi_trace(TRACE_SCSI_DEBUG, "SCSI op 0x%x: done (status 0x%x)\n", cdb[0], args->status);
return 0;
}
@ -1042,7 +1042,7 @@ device_shutdown(target_session_t *sess)
if (disks.v[sess->d].type == ISCSI_RAMDISK) {
for (i = 0; i < disks.v[sess->d].luns; i++) {
TRACE(TRACE_ISCSI_DEBUG, "freeing ramdisk[%i] (%p)\n", i, disks.v[sess->d].ramdisk[i]);
iscsi_trace(TRACE_ISCSI_DEBUG, "freeing ramdisk[%i] (%p)\n", i, disks.v[sess->d].ramdisk[i]);
iscsi_free(disks.v[sess->d].ramdisk[i]);
}
}
@ -1062,7 +1062,7 @@ disk_write(target_session_t *sess, iscsi_scsi_cmd_args_t *args, uint8_t lun, uin
struct iovec sg;
uint64_t extra = 0;
TRACE(TRACE_SCSI_DATA, "writing %" PRIu64 " bytes from socket into device at byte offset %" PRIu64 "\n", num_bytes, byte_offset);
iscsi_trace(TRACE_SCSI_DATA, "writing %" PRIu64 " bytes from socket into device at byte offset %" PRIu64 "\n", num_bytes, byte_offset);
/* Assign ptr for write data */
@ -1077,7 +1077,7 @@ disk_write(target_session_t *sess, iscsi_scsi_cmd_args_t *args, uint8_t lun, uin
case ISCSI_FS_MMAP:
extra = byte_offset % 4096;
if ((ptr = de_mmap(0, (size_t) (num_bytes + extra), PROT_WRITE, MAP_SHARED, &disks.v[sess->d].tv->v[sess->d].de, (off_t)(byte_offset - extra))) == NULL) {
TRACE_ERROR("mmap() failed\n");
iscsi_trace_error("mmap() failed\n");
return -1;
} else {
ptr += (uint32_t) extra;
@ -1089,32 +1089,32 @@ disk_write(target_session_t *sess, iscsi_scsi_cmd_args_t *args, uint8_t lun, uin
sg.iov_base = ptr;
sg.iov_len = (unsigned)num_bytes;
if (target_transfer_data(sess, args, &sg, 1) != 0) {
TRACE_ERROR("target_transfer_data() failed\n");
iscsi_trace_error("target_transfer_data() failed\n");
}
/* Finish up write */
switch(disks.v[sess->d].type) {
case ISCSI_FS:
if (de_lseek(&disks.v[sess->d].tv->v[sess->d].de, (off_t) byte_offset, SEEK_SET) == -1) {
TRACE_ERROR("lseek() to offset %" PRIu64 " failed\n", byte_offset);
iscsi_trace_error("lseek() to offset %" PRIu64 " failed\n", byte_offset);
return -1;
}
if (!target_writable(&disks.v[sess->d].tv->v[sess->d])) {
TRACE_ERROR("write() of %" PRIu64 " bytes failed at offset %" PRIu64 ", size %" PRIu64 "[READONLY TARGET]\n", num_bytes, byte_offset, de_getsize(&disks.v[sess->d].tv->v[0].de));
iscsi_trace_error("write() of %" PRIu64 " bytes failed at offset %" PRIu64 ", size %" PRIu64 "[READONLY TARGET]\n", num_bytes, byte_offset, de_getsize(&disks.v[sess->d].tv->v[0].de));
return -1;
}
if (de_write(&disks.v[sess->d].tv->v[sess->d].de, ptr, (unsigned) num_bytes) != num_bytes) {
TRACE_ERROR("write() of %" PRIu64 " bytes failed at offset %" PRIu64 ", size %" PRIu64 "\n", num_bytes, byte_offset, de_getsize(&disks.v[sess->d].tv->v[0].de));
iscsi_trace_error("write() of %" PRIu64 " bytes failed at offset %" PRIu64 ", size %" PRIu64 "\n", num_bytes, byte_offset, de_getsize(&disks.v[sess->d].tv->v[0].de));
return -1;
}
break;
case ISCSI_FS_MMAP:
ptr -= (uint32_t) extra;
if (de_munmap(&disks.v[sess->d].tv->v[sess->d].de, ptr, (size_t)(num_bytes + extra)) != 0) {
TRACE_ERROR("munmap() failed\n");
iscsi_trace_error("munmap() failed\n");
return -1;
}
}
TRACE(TRACE_SCSI_DATA, "wrote %" PRIu64 " bytes to device OK\n", num_bytes);
iscsi_trace(TRACE_SCSI_DATA, "wrote %" PRIu64 " bytes to device OK\n", num_bytes);
return 0;
}
@ -1147,8 +1147,8 @@ disk_read(target_session_t * sess, iscsi_scsi_cmd_args_t * args, uint32_t lba, u
RETURN_EQUAL("len", len, 0, NO_CLEANUP, -1);
if ((lba > (disks.v[sess->d].blockc - 1)) || ((lba + len) > disks.v[sess->d].blockc)) {
TRACE_ERROR("attempt to read beyond end of media\n");
TRACE_ERROR("max_lba = %" PRIu64 ", requested lba = %u, len = %u\n", disks.v[sess->d].blockc - 1, lba, len);
iscsi_trace_error("attempt to read beyond end of media\n");
iscsi_trace_error("max_lba = %" PRIu64 ", requested lba = %u, len = %u\n", disks.v[sess->d].blockc - 1, lba, len);
return -1;
}
switch (disks.v[sess->d].type) {
@ -1161,24 +1161,24 @@ disk_read(target_session_t * sess, iscsi_scsi_cmd_args_t * args, uint32_t lba, u
n = 0;
do {
if (de_lseek(&disks.v[sess->d].tv->v[sess->d].de, (off_t)(n + byte_offset), SEEK_SET) == -1) {
TRACE_ERROR("lseek() failed\n");
iscsi_trace_error("lseek() failed\n");
return -1;
}
rc = de_read(&disks.v[sess->d].tv->v[sess->d].de, ptr + n, (size_t)(num_bytes - n));
if (rc <= 0) {
TRACE_ERROR("read() failed: rc %i errno %i\n", rc, errno);
iscsi_trace_error("read() failed: rc %i errno %i\n", rc, errno);
return -1;
}
n += rc;
if (n < num_bytes) {
TRACE_ERROR("Got partial file read: %i bytes of %" PRIu64 "\n", rc, num_bytes - n + rc);
iscsi_trace_error("Got partial file read: %i bytes of %" PRIu64 "\n", rc, num_bytes - n + rc);
}
} while (n < num_bytes);
break;
case ISCSI_FS_MMAP:
if (last_ptr[lun]) {
if (de_munmap(&disks.v[sess->d].tv->v[sess->d].de, last_ptr[lun], (unsigned)(last_extra[lun] + last_num_bytes[lun])) != 0) {
TRACE_ERROR("munmap() failed\n");
iscsi_trace_error("munmap() failed\n");
return -1;
}
last_ptr[lun] = NULL;
@ -1187,7 +1187,7 @@ disk_read(target_session_t * sess, iscsi_scsi_cmd_args_t * args, uint32_t lba, u
}
extra = byte_offset % 4096;
if ((ptr = de_mmap(0, (size_t)(num_bytes + extra), PROT_READ, MAP_SHARED, &disks.v[sess->d].tv->v[0].de, (off_t)(byte_offset - extra))) == NULL) {
TRACE_ERROR("mmap() failed\n");
iscsi_trace_error("mmap() failed\n");
return -1;
}
/* Need to replace this with a callback */

120
dist/iscsi/src/driver.c vendored
View File

@ -102,13 +102,13 @@ MODULE_LICENSE("Dual BSD/GPL"); /* This source is under BSD License. This is th
static int driver_init(void) {
int i;
TRACE(TRACE_SCSI_DEBUG, "initializing iSCSI driver\n");
iscsi_trace(TRACE_SCSI_DEBUG, "initializing iSCSI driver\n");
if ((g_cmd=iscsi_malloc_atomic(sizeof(initiator_cmd_t)*CONFIG_INITIATOR_QUEUE_DEPTH))==NULL) {
TRACE_ERROR("iscsi_malloc_atomic() failed\n");
iscsi_trace_error("iscsi_malloc_atomic() failed\n");
return -1;
}
if ((g_iov=iscsi_malloc_atomic(sizeof(struct iovec*)*CONFIG_INITIATOR_QUEUE_DEPTH))==NULL) {
TRACE_ERROR("iscsi_malloc_atomic() failed\n");
iscsi_trace_error("iscsi_malloc_atomic() failed\n");
iscsi_free_atomic(g_cmd);
return -1;
}
@ -129,50 +129,50 @@ static int driver_init(void) {
}
for (i=0; i<CONFIG_INITIATOR_QUEUE_DEPTH; i++) {
if ((g_iov[i]=iscsi_malloc_atomic(sizeof(struct iovec)*SG_ALL))==NULL) {
TRACE_ERROR("iscsi_malloc_atomic() failed\n");
iscsi_trace_error("iscsi_malloc_atomic() failed\n");
DI_ERROR;
}
}
if (iscsi_queue_init(&g_cmd_q, CONFIG_INITIATOR_QUEUE_DEPTH)!=0) {
TRACE_ERROR("iscsi_queue_init() failed\n");
iscsi_trace_error("iscsi_queue_init() failed\n");
DI_ERROR;
}
if (iscsi_queue_init(&g_iovec_q, CONFIG_INITIATOR_QUEUE_DEPTH)!=0) {
TRACE_ERROR("iscsi_queue_init() failed\n");
iscsi_trace_error("iscsi_queue_init() failed\n");
DI_ERROR;
}
for (i=0; i<CONFIG_INITIATOR_QUEUE_DEPTH; i++) {
if ((g_cmd[i].ptr = iscsi_malloc_atomic(sizeof(iscsi_scsi_cmd_args_t)))==NULL) {
TRACE_ERROR("iscsi_malloc_atomic() failed\n");
iscsi_trace_error("iscsi_malloc_atomic() failed\n");
DI_ERROR;
}
g_cmd[i].type = ISCSI_SCSI_CMD;
if (iscsi_queue_insert(&g_cmd_q, &g_cmd[i])!=0) {
TRACE_ERROR("iscsi_queue_insert() failed\n");
iscsi_trace_error("iscsi_queue_insert() failed\n");
DI_ERROR;
}
if (iscsi_queue_insert(&g_iovec_q, g_iov[i])!=0) {
TRACE_ERROR("iscsi_queue_insert() failed\n");
iscsi_trace_error("iscsi_queue_insert() failed\n");
DI_ERROR;
}
}
memset(&g_stats, 0, sizeof(g_stats));
iscsi_spin_init(&g_stats.lock);
if (initiator_init()!=0) {
TRACE_ERROR("initiator_init() failed\n");
iscsi_trace_error("initiator_init() failed\n");
DI_ERROR;
}
TRACE(TRACE_SCSI_DEBUG, "iSCSI initialization complete\n");
iscsi_trace(TRACE_SCSI_DEBUG, "iSCSI initialization complete\n");
return 0;
}
static int driver_shutdown(void) {
int i;
TRACE(TRACE_SCSI_DEBUG, "shutting down iSCSI driver\n");
iscsi_trace(TRACE_SCSI_DEBUG, "shutting down iSCSI driver\n");
if (initiator_shutdown()!=0) {
TRACE_ERROR("initiator_shutdown() failed\n");
iscsi_trace_error("initiator_shutdown() failed\n");
return -1;
}
iscsi_spin_destroy(&g_stats.lock);
@ -184,7 +184,7 @@ static int driver_shutdown(void) {
}
iscsi_free_atomic(g_cmd);
iscsi_free_atomic(g_iov);
TRACE(TRACE_SCSI_DEBUG, "iSCSI driver shutdown complete\n");
iscsi_trace(TRACE_SCSI_DEBUG, "iSCSI driver shutdown complete\n");
return 0;
}
@ -196,10 +196,10 @@ static int driver_shutdown(void) {
int iscsi_detect(Scsi_Host_Template *tptr) {
struct Scsi_Host *ptr;
TRACE(TRACE_SCSI_DEBUG, "detecting iSCSI host\n");
iscsi_trace(TRACE_SCSI_DEBUG, "detecting iSCSI host\n");
spin_unlock(&io_request_lock);
if (driver_init()!=0) {
TRACE_ERROR("driver_init() failed\n");
iscsi_trace_error("driver_init() failed\n");
spin_lock(&io_request_lock);
return 0; /*No 'SCSI' host detected, return 0 */
@ -208,15 +208,15 @@ int iscsi_detect(Scsi_Host_Template *tptr) {
ptr->max_id = CONFIG_INITIATOR_NUM_TARGETS;
ptr->max_lun = CONFIG_DRIVER_MAX_LUNS;
ptr->max_cmd_len = 255;
TRACE(TRACE_SCSI_DEBUG, "iSCSI host detected\n");
iscsi_trace(TRACE_SCSI_DEBUG, "iSCSI host detected\n");
spin_lock(&io_request_lock);
return 1;
}
int iscsi_release(struct Scsi_Host *host) {
TRACE(TRACE_SCSI_DEBUG, "releasing iSCSI host\n");
iscsi_trace(TRACE_SCSI_DEBUG, "releasing iSCSI host\n");
driver_shutdown();
TRACE(TRACE_SCSI_DEBUG, "iSCSI host released\n");
iscsi_trace(TRACE_SCSI_DEBUG, "iSCSI host released\n");
return 0;
}
@ -228,15 +228,15 @@ int iscsi_bios_param(Disk *disk, kdev_t dev, int *ip) {
ip[1] = 63; /* sectors */
ip[2] = disk->capacity / (255 * 63); /* cylinders */
}
TRACE(TRACE_SCSI_DEBUG, "%u sectors, H/S/C: %u/%u/%u\n", disk->capacity, ip[0], ip[1], ip[2]);
iscsi_trace(TRACE_SCSI_DEBUG, "%u sectors, H/S/C: %u/%u/%u\n", disk->capacity, ip[0], ip[1], ip[2]);
return 0;
}
int iscsi_command(Scsi_Cmnd *SCpnt) {
TRACE(TRACE_SCSI_DEBUG, "0x%p: op 0x%x, chan %i, target %i, lun %i, bufflen %i, sg %i\n",
iscsi_trace(TRACE_SCSI_DEBUG, "0x%p: op 0x%x, chan %i, target %i, lun %i, bufflen %i, sg %i\n",
SCpnt, SCpnt->cmnd[0], SCpnt->channel, SCpnt->target, SCpnt->lun,
SCpnt->request_bufflen, SCpnt->use_sg);
TRACE_ERROR("NOT IMPLEMENTED\n");
iscsi_trace_error("NOT IMPLEMENTED\n");
return -1;
}
@ -253,10 +253,10 @@ int iscsi_done(void *ptr) {
} else {
SCpnt->result = -1;
}
TRACE(TRACE_SCSI_DEBUG, "scsi_arg 0x%p SCpnt 0x%p op 0x%x done (result %i)\n",
iscsi_trace(TRACE_SCSI_DEBUG, "scsi_arg 0x%p SCpnt 0x%p op 0x%x done (result %i)\n",
scsi_cmd, SCpnt, SCpnt->cmnd[0], SCpnt->result);
if ((scsi_cmd->input)&&(scsi_cmd->output)) {
TRACE_ERROR("bidi xfers not implemented\n");
iscsi_trace_error("bidi xfers not implemented\n");
return -1;
} else if (scsi_cmd->input) {
iscsi_spin_lock_irqsave(&g_stats.lock, &flags);
@ -284,13 +284,13 @@ int iscsi_done(void *ptr) {
hs = SCpnt->host_scribble;
SCpnt->host_scribble = NULL; /* for abort */
if (iscsi_queue_insert(&g_iovec_q, hs)!=0) {
TRACE_ERROR("iscsi_queue_insert() failed\n");
iscsi_trace_error("iscsi_queue_insert() failed\n");
return -1;
}
}
iscsi_free_atomic(scsi_cmd->ahs);
if (iscsi_queue_insert(&g_cmd_q, cmd)!=0) {
TRACE_ERROR("iscsi_queue_insert() failed\n");
iscsi_trace_error("iscsi_queue_insert() failed\n");
cmd->callback_arg = NULL; /* for abort */
return -1;
}
@ -298,7 +298,7 @@ int iscsi_done(void *ptr) {
if (SCpnt->result==0) {
SCpnt->scsi_done(SCpnt);
} else {
TRACE_ERROR("SCSI cmd 0x%x failed at iSCSI level (ignoring)\n", SCpnt->cmnd[0]);
iscsi_trace_error("SCSI cmd 0x%x failed at iSCSI level (ignoring)\n", SCpnt->cmnd[0]);
}
return 0;
}
@ -317,7 +317,7 @@ int iscsi_queuecommand(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *)) {
spin_unlock(&io_request_lock);
TRACE(TRACE_SCSI_DEBUG, "SCpnt %p: tid %i lun %i op 0x%x tag %u len %i sg %i buff 0x%p\n",
iscsi_trace(TRACE_SCSI_DEBUG, "SCpnt %p: tid %i lun %i op 0x%x tag %u len %i sg %i buff 0x%p\n",
SCpnt, SCpnt->target, SCpnt->lun, SCpnt->cmnd[0], SCpnt->tag, SCpnt->request_bufflen,
SCpnt->use_sg, SCpnt->buffer);
@ -352,7 +352,7 @@ int iscsi_queuecommand(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *)) {
iov = iscsi_queue_remove(&g_iovec_q);
if (iov == NULL) {
TRACE_ERROR("iscsi_queue_remove() failed\n");
iscsi_trace_error("iscsi_queue_remove() failed\n");
spin_lock(&io_request_lock);
return -1;
}
@ -369,7 +369,7 @@ int iscsi_queuecommand(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *)) {
/* Get free cmd structure */
if ((cmd=iscsi_queue_remove(&g_cmd_q))==NULL) {
TRACE_ERROR("iscsi_queue_remove() failed\n");
iscsi_trace_error("iscsi_queue_remove() failed\n");
spin_lock(&io_request_lock);
return -1;
}
@ -390,9 +390,9 @@ int iscsi_queuecommand(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *)) {
/* AHS for CDBs larget than 16 bytes */
if (SCpnt->cmd_len>16) {
TRACE(TRACE_ISCSI_DEBUG, "creating AHS for extended CDB (%i bytes)\n", SCpnt->cmd_len);
iscsi_trace(TRACE_ISCSI_DEBUG, "creating AHS for extended CDB (%i bytes)\n", SCpnt->cmd_len);
if ((scsi_cmd->ahs=iscsi_malloc_atomic(SCpnt->cmd_len-16))==NULL) {
TRACE_ERROR("iscsi_malloc_atomic() failed\n");
iscsi_trace_error("iscsi_malloc_atomic() failed\n");
spin_lock(&io_request_lock);
return -1;
}
@ -409,7 +409,7 @@ int iscsi_queuecommand(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *)) {
cmd->callback_arg = SCpnt;
cmd->isid = SCpnt->target;
if (initiator_enqueue(cmd)!=0) {
TRACE_ERROR("initiator_enqueue() failed\n");
iscsi_trace_error("initiator_enqueue() failed\n");
if (SCpnt->cmd_len>16) iscsi_free_atomic(scsi_cmd->ahs);
spin_lock(&io_request_lock);
return -1;
@ -423,7 +423,7 @@ int iscsi_proc_info (char *buffer, char **start, off_t offset, int length, int h
uint32_t infolen = 8192;
int len = 0;
TRACE(TRACE_SCSI_DEBUG, "buffer = 0x%p, offset %u, length = %i, hostno %i, writing %i\n",
iscsi_trace(TRACE_SCSI_DEBUG, "buffer = 0x%p, offset %u, length = %i, hostno %i, writing %i\n",
buffer, (unsigned) offset, length, hostno, writing);
/* writing resets counters */
@ -440,7 +440,7 @@ int iscsi_proc_info (char *buffer, char **start, off_t offset, int length, int h
return 0;
} else {
if ((info=iscsi_malloc_atomic(infolen))==NULL) {
TRACE_ERROR("iscsi_malloc_atomic() failed\n");
iscsi_trace_error("iscsi_malloc_atomic() failed\n");
return -1;
}
len += snprintf(info, infolen, "%s\n\n", driver_template.name);
@ -479,7 +479,7 @@ int iscsi_proc_info (char *buffer, char **start, off_t offset, int length, int h
len += snprintf(&info[len], infolen - len, "--------------------\n\n");
if ((len += initiator_info(&info[len], infolen, len))==-1) {
TRACE_ERROR("initiator_info() failed\n");
iscsi_trace_error("initiator_info() failed\n");
if (info != NULL) iscsi_free_atomic(info);
return -1;
}
@ -505,7 +505,7 @@ int iscsi_ioctl (Scsi_Device *dev, int cmd, void *argp) {
for (i=0; i<CONFIG_INITIATOR_NUM_TARGETS; i++) {
if (test_all(i, lun)!=0) {
TRACE_ERROR("test_all() failed\n");
iscsi_trace_error("test_all() failed\n");
return -1;
}
}
@ -517,17 +517,17 @@ void iscsi_select_queue_depths(struct Scsi_Host *host, Scsi_Device *scsi_devs) {
for (device = scsi_devs; device; device = device->next) {
if (device->host != host) {
TRACE_ERROR("got device for different host\n");
iscsi_trace_error("got device for different host\n");
continue;
}
if (device->tagged_supported) {
TRACE(TRACE_SCSI_DEBUG, "target %i lun %i supports TCQ\n", device->id, device->lun);
iscsi_trace(TRACE_SCSI_DEBUG, "target %i lun %i supports TCQ\n", device->id, device->lun);
device->tagged_queue = 1;
device->current_tag = 0;
device->queue_depth = CONFIG_INITIATOR_QUEUE_DEPTH;
TRACE(TRACE_SCSI_DEBUG, "device queue depth set to %i\n", device->queue_depth);
iscsi_trace(TRACE_SCSI_DEBUG, "device queue depth set to %i\n", device->queue_depth);
} else {
TRACE(TRACE_SCSI_DEBUG, "target %i lun %i does NOT support TCQ\n", device->id, device->lun);
iscsi_trace(TRACE_SCSI_DEBUG, "target %i lun %i does NOT support TCQ\n", device->id, device->lun);
device->queue_depth = 1;
}
}
@ -545,7 +545,7 @@ int iscsi_abort_handler (Scsi_Cmnd *SCpnt) {
unsigned long flags;
spin_unlock_irq(&io_request_lock);
TRACE_ERROR("aborting SCSI cmd 0x%p (op 0x%x, tid %i, lun %i)\n",
iscsi_trace_error("aborting SCSI cmd 0x%p (op 0x%x, tid %i, lun %i)\n",
SCpnt, SCpnt->cmnd[0], SCpnt->target, SCpnt->lun);
@ -561,7 +561,7 @@ int iscsi_abort_handler (Scsi_Cmnd *SCpnt) {
/* Abort the command */
if (initiator_abort(&g_cmd[i])!=0) {
TRACE_ERROR("initiator_abort() failed\n");
iscsi_trace_error("initiator_abort() failed\n");
spin_lock_irq(&io_request_lock);
return FAILED;
}
@ -570,7 +570,7 @@ int iscsi_abort_handler (Scsi_Cmnd *SCpnt) {
scsi_cmd = (iscsi_scsi_cmd_args_t *) g_cmd[i].ptr;
if ((scsi_cmd->input)&&(scsi_cmd->output)) {
TRACE_ERROR("bidi xfers not implemented\n");
iscsi_trace_error("bidi xfers not implemented\n");
spin_lock_irq(&io_request_lock);
return FAILED;
} else if (scsi_cmd->input) {
@ -595,58 +595,58 @@ int iscsi_abort_handler (Scsi_Cmnd *SCpnt) {
#if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,0)
if (in_interrupt()) {
TRACE_ERROR("aborting within interrupt (killing Tx and Rx threads)\n");
iscsi_trace_error("aborting within interrupt (killing Tx and Rx threads)\n");
#endif
TRACE_ERROR("killing Tx and Rx threads\n");
iscsi_trace_error("killing Tx and Rx threads\n");
kill_proc(sess->rx_worker.pid, SIGKILL, 1);
kill_proc(sess->tx_worker.pid, SIGKILL, 1);
sess->tx_worker.state = 0;
sess->rx_worker.state = 0;
#if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,0)
} else {
TRACE_ERROR("aborting outside interrupt (gracefully ending Tx and Rx)\n");
iscsi_trace_error("aborting outside interrupt (gracefully ending Tx and Rx)\n");
}
#endif
TRACE(TRACE_ISCSI_DEBUG, "destroying session\n");
iscsi_trace(TRACE_ISCSI_DEBUG, "destroying session\n");
if (session_destroy_i(sess)!=0) {
TRACE_ERROR("session_destroy() failed\n");
iscsi_trace_error("session_destroy() failed\n");
g_stats.aborts_failed++;
spin_lock_irq(&io_request_lock);
return FAILED;
}
} else {
TRACE(TRACE_ISCSI_DEBUG, "no session\n");
iscsi_trace(TRACE_ISCSI_DEBUG, "no session\n");
}
g_stats.aborts_success++;
TRACE_ERROR("successfully aborted SCSI cmd 0x%p (op 0x%x, tid %i, lun %i)\n",
iscsi_trace_error("successfully aborted SCSI cmd 0x%p (op 0x%x, tid %i, lun %i)\n",
SCpnt, SCpnt->cmnd[0], SCpnt->target, SCpnt->lun);
spin_lock_irq(&io_request_lock);
return SUCCESS;
}
int iscsi_device_reset_handler (Scsi_Cmnd *SCpnt) {
TRACE_ERROR("***********************\n");
TRACE_ERROR("*** DEVICE %i RESET ***\n", SCpnt->target);
TRACE_ERROR("***********************\n");
iscsi_trace_error("***********************\n");
iscsi_trace_error("*** DEVICE %i RESET ***\n", SCpnt->target);
iscsi_trace_error("***********************\n");
g_stats.device_resets++;
return SUCCESS;
}
int iscsi_bus_reset_handler (Scsi_Cmnd *SCpnt) {
TRACE_ERROR("********************\n");
TRACE_ERROR("*** BUS %i RESET ***\n", SCpnt->target);
TRACE_ERROR("********************\n");
iscsi_trace_error("********************\n");
iscsi_trace_error("*** BUS %i RESET ***\n", SCpnt->target);
iscsi_trace_error("********************\n");
g_stats.bus_resets++;
return SUCCESS;
}
int iscsi_host_reset_handler(Scsi_Cmnd *SCpnt) {
TRACE_ERROR("*********************\n");
TRACE_ERROR("*** HOST RESET %i ***\n", SCpnt->target);
TRACE_ERROR("*********************\n");
iscsi_trace_error("*********************\n");
iscsi_trace_error("*** HOST RESET %i ***\n", SCpnt->target);
iscsi_trace_error("*********************\n");
g_stats.host_resets++;
return SUCCESS;
}

724
dist/iscsi/src/initiator.c vendored
View File

File diff suppressed because it is too large Load Diff

12
dist/iscsi/src/iscsi-harness.c vendored
View File

@ -137,7 +137,7 @@ main(int argc, char **argv)
if (user == NULL) {
if ((pwp = getpwuid(geteuid())) == NULL) {
TRACE_ERROR("can't find user information\n");
iscsi_trace_error("can't find user information\n");
exit(EXIT_FAILURE);
}
user = pwp->pw_name;
@ -145,7 +145,7 @@ main(int argc, char **argv)
if (target != -1) {
if (target >= CONFIG_INITIATOR_NUM_TARGETS) {
TRACE_ERROR("initiator only configured with %i targets\n", CONFIG_INITIATOR_NUM_TARGETS);
iscsi_trace_error("initiator only configured with %i targets\n", CONFIG_INITIATOR_NUM_TARGETS);
exit(EXIT_FAILURE);
}
tgtlo = target;
@ -157,7 +157,7 @@ main(int argc, char **argv)
}
for (j = 0; j < iterations; j++) {
PRINT("<ITERATION %i>\n", j);
printf("<ITERATION %i>\n", j);
/* Ignore sigpipe */
@ -166,14 +166,14 @@ main(int argc, char **argv)
/* Initialize Initiator */
if (initiator_init(host, user, auth_type, mutual_auth, digest_type) == -1) {
TRACE_ERROR("initiator_init() failed\n");
iscsi_trace_error("initiator_init() failed\n");
return -1;
}
/* Run tests for each target */
for (i = tgtlo; i < tgthi; i++) {
if (test_all(i, lun) != 0) {
TRACE_ERROR("test_all() failed\n");
iscsi_trace_error("test_all() failed\n");
return -1;
}
}
@ -181,7 +181,7 @@ main(int argc, char **argv)
/* Shutdown Initiator */
if (initiator_shutdown() == -1) {
TRACE_ERROR("initiator_shutdown() failed\n");
iscsi_trace_error("initiator_shutdown() failed\n");
return -1;
}
}

8
dist/iscsi/src/iscsi-target.c vendored
View File

@ -1,4 +1,4 @@
/* $NetBSD: iscsi-target.c,v 1.7 2006/03/11 11:58:22 wiz Exp $ */
/* $NetBSD: iscsi-target.c,v 1.8 2006/03/12 18:47:28 agc Exp $ */
/*
* Copyright © 2006 Alistair Crooks. All rights reserved.
@ -141,14 +141,14 @@ main(int argc, char **argv)
}
/* Initialize target */
if (target_init(&g, &tv, TargetName) != 0) {
TRACE_ERROR("target_init() failed\n");
iscsi_trace_error("target_init() failed\n");
exit(EXIT_FAILURE);
}
#ifdef HAVE_DAEMON
/* if we are supposed to be a daemon, detach from controlling tty */
if (detach_me_harder && daemon(0, 0) < 0) {
TRACE_ERROR("daemon() failed\n");
iscsi_trace_error("daemon() failed\n");
exit(EXIT_FAILURE);
}
#endif
@ -158,7 +158,7 @@ main(int argc, char **argv)
/* Wait for connections */
if (target_listen(&g) != 0) {
TRACE_ERROR("target_listen() failed\n");
iscsi_trace_error("target_listen() failed\n");
}
return EXIT_SUCCESS;

642
dist/iscsi/src/iscsi.c vendored
View File

@ -62,15 +62,15 @@
int
iscsi_task_cmd_encap(uint8_t *header, iscsi_task_cmd_t * cmd)
{
TRACE(TRACE_ISCSI_ARGS, "Immediate: %i\n", cmd->immediate);
TRACE(TRACE_ISCSI_ARGS, "Function: %u\n", cmd->function);
TRACE(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
TRACE(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", cmd->tag);
TRACE(TRACE_ISCSI_ARGS, "Ref Tag: 0x%x\n", cmd->ref_tag);
TRACE(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
TRACE(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
TRACE(TRACE_ISCSI_ARGS, "RefCmdSN: %u\n", cmd->RefCmdSN);
TRACE(TRACE_ISCSI_ARGS, "ExpDataSN: %u\n", cmd->ExpDataSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Immediate: %i\n", cmd->immediate);
iscsi_trace(TRACE_ISCSI_ARGS, "Function: %u\n", cmd->function);
iscsi_trace(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
iscsi_trace(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", cmd->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "Ref Tag: 0x%x\n", cmd->ref_tag);
iscsi_trace(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "RefCmdSN: %u\n", cmd->RefCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpDataSN: %u\n", cmd->ExpDataSN);
(void) memset(header, 0x0, ISCSI_HEADER_LEN);
@ -113,15 +113,15 @@ iscsi_task_cmd_decap(uint8_t *header, iscsi_task_cmd_t * cmd)
RETURN_NOT_EQUAL("Bytes 40-43", *((uint32_t *) (void *) (header + 40)), 0, NO_CLEANUP, 1);
RETURN_NOT_EQUAL("Bytes 44-47", *((uint32_t *) (void *) (header + 44)), 0, NO_CLEANUP, 1);
TRACE(TRACE_ISCSI_ARGS, "Immediate: %i\n", cmd->immediate);
TRACE(TRACE_ISCSI_ARGS, "Function: %u\n", cmd->function);
TRACE(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
TRACE(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", cmd->tag);
TRACE(TRACE_ISCSI_ARGS, "Ref Tag: 0x%x\n", cmd->ref_tag);
TRACE(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
TRACE(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
TRACE(TRACE_ISCSI_ARGS, "RefCmdSN: %u\n", cmd->RefCmdSN);
TRACE(TRACE_ISCSI_ARGS, "ExpDataSN: %u\n", cmd->ExpDataSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Immediate: %i\n", cmd->immediate);
iscsi_trace(TRACE_ISCSI_ARGS, "Function: %u\n", cmd->function);
iscsi_trace(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
iscsi_trace(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", cmd->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "Ref Tag: 0x%x\n", cmd->ref_tag);
iscsi_trace(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "RefCmdSN: %u\n", cmd->RefCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpDataSN: %u\n", cmd->ExpDataSN);
return 0;
}
@ -136,12 +136,12 @@ iscsi_task_rsp_encap(uint8_t *header, iscsi_task_rsp_t * rsp)
uint32_t length;
TRACE(TRACE_ISCSI_ARGS, "Response: %u\n", rsp->response);
TRACE(TRACE_ISCSI_ARGS, "Length: %u\n", rsp->length);
TRACE(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", rsp->tag);
TRACE(TRACE_ISCSI_ARGS, "StatSN: %u\n", rsp->StatSN);
TRACE(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", rsp->ExpCmdSN);
TRACE(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", rsp->MaxCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Response: %u\n", rsp->response);
iscsi_trace(TRACE_ISCSI_ARGS, "Length: %u\n", rsp->length);
iscsi_trace(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", rsp->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "StatSN: %u\n", rsp->StatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", rsp->ExpCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", rsp->MaxCmdSN);
(void) memset(header, 0x0, ISCSI_HEADER_LEN);
@ -181,11 +181,11 @@ iscsi_task_rsp_decap(uint8_t *header, iscsi_task_rsp_t * rsp)
RETURN_NOT_EQUAL("Bytes 40-43", *((uint32_t *) (void *) (header + 40)), 0, NO_CLEANUP, 1);
RETURN_NOT_EQUAL("Bytes 44-47", *((uint32_t *) (void *) (header + 44)), 0, NO_CLEANUP, 1);
TRACE(TRACE_ISCSI_ARGS, "Response: %u\n", rsp->response);
TRACE(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", rsp->tag);
TRACE(TRACE_ISCSI_ARGS, "StatSN: %u\n", rsp->StatSN);
TRACE(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", rsp->ExpCmdSN);
TRACE(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", rsp->MaxCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Response: %u\n", rsp->response);
iscsi_trace(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", rsp->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "StatSN: %u\n", rsp->StatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", rsp->ExpCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", rsp->MaxCmdSN);
return 0;
}
@ -200,13 +200,13 @@ iscsi_nop_out_encap(uint8_t *header, iscsi_nop_out_args_t * cmd)
uint32_t length;
TRACE(TRACE_ISCSI_ARGS, "Immediate: %i\n", cmd->immediate);
TRACE(TRACE_ISCSI_ARGS, "Length: %u\n", cmd->length);
TRACE(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
TRACE(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", cmd->tag);
TRACE(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", cmd->transfer_tag);
TRACE(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
TRACE(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Immediate: %i\n", cmd->immediate);
iscsi_trace(TRACE_ISCSI_ARGS, "Length: %u\n", cmd->length);
iscsi_trace(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
iscsi_trace(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", cmd->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", cmd->transfer_tag);
iscsi_trace(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
(void) memset(header, 0x0, ISCSI_HEADER_LEN);
@ -249,13 +249,13 @@ iscsi_nop_out_decap(uint8_t *header, iscsi_nop_out_args_t * cmd)
RETURN_NOT_EQUAL("Bytes 40-43", *((uint32_t *) (void *) (header + 40)), 0, NO_CLEANUP, 1);
RETURN_NOT_EQUAL("Bytes 44-47", *((uint32_t *) (void *) (header + 44)), 0, NO_CLEANUP, 1);
TRACE(TRACE_ISCSI_ARGS, "Immediate: %i\n", cmd->immediate);
TRACE(TRACE_ISCSI_ARGS, "Length: %u\n", cmd->length);
TRACE(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
TRACE(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", cmd->tag);
TRACE(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", cmd->transfer_tag);
TRACE(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
TRACE(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Immediate: %i\n", cmd->immediate);
iscsi_trace(TRACE_ISCSI_ARGS, "Length: %u\n", cmd->length);
iscsi_trace(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
iscsi_trace(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", cmd->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", cmd->transfer_tag);
iscsi_trace(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
return 0;
}
@ -269,13 +269,13 @@ iscsi_nop_in_encap(uint8_t *header, iscsi_nop_in_args_t * cmd)
{
uint32_t length;
TRACE(TRACE_ISCSI_ARGS, "Length: %u\n", cmd->length);
TRACE(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
TRACE(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", cmd->tag);
TRACE(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", cmd->transfer_tag);
TRACE(TRACE_ISCSI_ARGS, "StatSN: %u\n", cmd->StatSN);
TRACE(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", cmd->ExpCmdSN);
TRACE(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", cmd->MaxCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Length: %u\n", cmd->length);
iscsi_trace(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
iscsi_trace(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", cmd->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", cmd->transfer_tag);
iscsi_trace(TRACE_ISCSI_ARGS, "StatSN: %u\n", cmd->StatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", cmd->ExpCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", cmd->MaxCmdSN);
(void) memset(header, 0x0, ISCSI_HEADER_LEN);
@ -318,13 +318,13 @@ iscsi_nop_in_decap(uint8_t *header, iscsi_nop_in_args_t * cmd)
RETURN_NOT_EQUAL("Bytes 40-43", *((uint32_t *) (void *) (header + 40)), 0, NO_CLEANUP, 1);
RETURN_NOT_EQUAL("Bytes 44-47", *((uint32_t *) (void *) (header + 44)), 0, NO_CLEANUP, 1);
TRACE(TRACE_ISCSI_ARGS, "Length: %u\n", cmd->length);
TRACE(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
TRACE(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", cmd->tag);
TRACE(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", cmd->transfer_tag);
TRACE(TRACE_ISCSI_ARGS, "StatSN: %u\n", cmd->StatSN);
TRACE(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", cmd->ExpCmdSN);
TRACE(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", cmd->MaxCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Length: %u\n", cmd->length);
iscsi_trace(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
iscsi_trace(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", cmd->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", cmd->transfer_tag);
iscsi_trace(TRACE_ISCSI_ARGS, "StatSN: %u\n", cmd->StatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", cmd->ExpCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", cmd->MaxCmdSN);
return 0;
}
@ -337,15 +337,15 @@ iscsi_text_cmd_encap(uint8_t *header, iscsi_text_cmd_args_t * cmd)
{
uint32_t length;
TRACE(TRACE_ISCSI_ARGS, "Immediate: %i\n", cmd->immediate);
TRACE(TRACE_ISCSI_ARGS, "Final: %i\n", cmd->final);
TRACE(TRACE_ISCSI_ARGS, "Continue: %i\n", cmd->cont);
TRACE(TRACE_ISCSI_ARGS, "Length: %u\n", cmd->length);
TRACE(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
TRACE(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", cmd->tag);
TRACE(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", cmd->transfer_tag);
TRACE(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
TRACE(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Immediate: %i\n", cmd->immediate);
iscsi_trace(TRACE_ISCSI_ARGS, "Final: %i\n", cmd->final);
iscsi_trace(TRACE_ISCSI_ARGS, "Continue: %i\n", cmd->cont);
iscsi_trace(TRACE_ISCSI_ARGS, "Length: %u\n", cmd->length);
iscsi_trace(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
iscsi_trace(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", cmd->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", cmd->transfer_tag);
iscsi_trace(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
(void) memset(header, 0x0, ISCSI_HEADER_LEN);
@ -397,15 +397,15 @@ iscsi_text_cmd_decap(uint8_t *header, iscsi_text_cmd_args_t * cmd)
RETURN_NOT_EQUAL("Bytes 40-43", *((uint32_t *) (void *) (header + 40)), 0, NO_CLEANUP, 1);
RETURN_NOT_EQUAL("Bytes 44-47", *((uint32_t *) (void *) (header + 44)), 0, NO_CLEANUP, 1);
TRACE(TRACE_ISCSI_ARGS, "Immediate: %i\n", cmd->immediate);
TRACE(TRACE_ISCSI_ARGS, "Final: %i\n", cmd->final);
TRACE(TRACE_ISCSI_ARGS, "Continue: %i\n", cmd->cont);
TRACE(TRACE_ISCSI_ARGS, "Length: %u\n", cmd->length);
TRACE(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
TRACE(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", cmd->tag);
TRACE(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", cmd->transfer_tag);
TRACE(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
TRACE(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Immediate: %i\n", cmd->immediate);
iscsi_trace(TRACE_ISCSI_ARGS, "Final: %i\n", cmd->final);
iscsi_trace(TRACE_ISCSI_ARGS, "Continue: %i\n", cmd->cont);
iscsi_trace(TRACE_ISCSI_ARGS, "Length: %u\n", cmd->length);
iscsi_trace(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
iscsi_trace(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", cmd->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", cmd->transfer_tag);
iscsi_trace(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
return 0;
}
@ -419,15 +419,15 @@ iscsi_text_rsp_encap(uint8_t *header, iscsi_text_rsp_args_t * rsp)
{
uint32_t length;
TRACE(TRACE_ISCSI_ARGS, "Final: %i\n", rsp->final);
TRACE(TRACE_ISCSI_ARGS, "Continue: %i\n", rsp->cont);
TRACE(TRACE_ISCSI_ARGS, "Length: %u\n", rsp->length);
TRACE(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", rsp->lun);
TRACE(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", rsp->tag);
TRACE(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", rsp->transfer_tag);
TRACE(TRACE_ISCSI_ARGS, "StatSN: %u\n", rsp->StatSN);
TRACE(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", rsp->ExpCmdSN);
TRACE(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", rsp->MaxCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Final: %i\n", rsp->final);
iscsi_trace(TRACE_ISCSI_ARGS, "Continue: %i\n", rsp->cont);
iscsi_trace(TRACE_ISCSI_ARGS, "Length: %u\n", rsp->length);
iscsi_trace(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", rsp->lun);
iscsi_trace(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", rsp->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", rsp->transfer_tag);
iscsi_trace(TRACE_ISCSI_ARGS, "StatSN: %u\n", rsp->StatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", rsp->ExpCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", rsp->MaxCmdSN);
(void) memset(header, 0x0, ISCSI_HEADER_LEN);
header[0] |= 0x00 | ISCSI_TEXT_RSP; /* Opcode */
@ -475,15 +475,15 @@ iscsi_text_rsp_decap(uint8_t *header, iscsi_text_rsp_args_t * rsp)
RETURN_NOT_EQUAL("Bytes 40-43", *((uint32_t *) (void *) (header + 40)), 0, NO_CLEANUP, 1);
RETURN_NOT_EQUAL("Bytes 44-47", *((uint32_t *) (void *) (header + 44)), 0, NO_CLEANUP, 1);
TRACE(TRACE_ISCSI_ARGS, "Final: %i\n", rsp->final);
TRACE(TRACE_ISCSI_ARGS, "Continue: %i\n", rsp->cont);
TRACE(TRACE_ISCSI_ARGS, "Length: %u\n", rsp->length);
TRACE(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", rsp->lun);
TRACE(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", rsp->tag);
TRACE(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", rsp->transfer_tag);
TRACE(TRACE_ISCSI_ARGS, "StatSN: %u\n", rsp->StatSN);
TRACE(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", rsp->ExpCmdSN);
TRACE(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", rsp->MaxCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Final: %i\n", rsp->final);
iscsi_trace(TRACE_ISCSI_ARGS, "Continue: %i\n", rsp->cont);
iscsi_trace(TRACE_ISCSI_ARGS, "Length: %u\n", rsp->length);
iscsi_trace(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", rsp->lun);
iscsi_trace(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", rsp->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", rsp->transfer_tag);
iscsi_trace(TRACE_ISCSI_ARGS, "StatSN: %u\n", rsp->StatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", rsp->ExpCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", rsp->MaxCmdSN);
return 0;
}
@ -497,20 +497,20 @@ iscsi_login_cmd_encap(uint8_t *header, iscsi_login_cmd_args_t * cmd)
{
uint32_t length;
TRACE(TRACE_ISCSI_ARGS, "Transit: %i\n", cmd->transit);
TRACE(TRACE_ISCSI_ARGS, "Continue: %i\n", cmd->cont);
TRACE(TRACE_ISCSI_ARGS, "CSG: %u\n", cmd->csg);
TRACE(TRACE_ISCSI_ARGS, "NSG: %u\n", cmd->nsg);
TRACE(TRACE_ISCSI_ARGS, "Version_min: %u\n", cmd->version_min);
TRACE(TRACE_ISCSI_ARGS, "Version_max: %u\n", cmd->version_max);
TRACE(TRACE_ISCSI_ARGS, "TotalAHSLength: %u\n", cmd->AHSlength);
TRACE(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", cmd->length);
TRACE(TRACE_ISCSI_ARGS, "ISID: %" PRIu64 "\n", cmd->isid);
TRACE(TRACE_ISCSI_ARGS, "TSIH: %hu\n", cmd->tsih);
TRACE(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", cmd->tag);
TRACE(TRACE_ISCSI_ARGS, "CID: %hu\n", cmd->cid);
TRACE(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
TRACE(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Transit: %i\n", cmd->transit);
iscsi_trace(TRACE_ISCSI_ARGS, "Continue: %i\n", cmd->cont);
iscsi_trace(TRACE_ISCSI_ARGS, "CSG: %u\n", cmd->csg);
iscsi_trace(TRACE_ISCSI_ARGS, "NSG: %u\n", cmd->nsg);
iscsi_trace(TRACE_ISCSI_ARGS, "Version_min: %u\n", cmd->version_min);
iscsi_trace(TRACE_ISCSI_ARGS, "Version_max: %u\n", cmd->version_max);
iscsi_trace(TRACE_ISCSI_ARGS, "TotalAHSLength: %u\n", cmd->AHSlength);
iscsi_trace(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", cmd->length);
iscsi_trace(TRACE_ISCSI_ARGS, "ISID: %" PRIu64 "\n", cmd->isid);
iscsi_trace(TRACE_ISCSI_ARGS, "TSIH: %hu\n", cmd->tsih);
iscsi_trace(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", cmd->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "CID: %hu\n", cmd->cid);
iscsi_trace(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
(void) memset(header, 0x0, ISCSI_HEADER_LEN);
@ -559,20 +559,20 @@ iscsi_login_cmd_decap(uint8_t *header, iscsi_login_cmd_args_t * cmd)
cmd->CmdSN = ISCSI_NTOHL(*((uint32_t *) (void *) (header + 24))); /* CmdSN */
cmd->ExpStatSN = ISCSI_NTOHL(*((uint32_t *) (void *) (header + 28))); /* ExpStatSN */
TRACE(TRACE_ISCSI_ARGS, "Transit: %i\n", cmd->transit);
TRACE(TRACE_ISCSI_ARGS, "Continue: %i\n", cmd->cont);
TRACE(TRACE_ISCSI_ARGS, "CSG: %u\n", cmd->csg);
TRACE(TRACE_ISCSI_ARGS, "NSG: %u\n", cmd->nsg);
TRACE(TRACE_ISCSI_ARGS, "Version_min: %u\n", cmd->version_min);
TRACE(TRACE_ISCSI_ARGS, "Version_max: %u\n", cmd->version_max);
TRACE(TRACE_ISCSI_ARGS, "TotalAHSLength: %u\n", cmd->AHSlength);
TRACE(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", cmd->length);
TRACE(TRACE_ISCSI_ARGS, "ISID: %" PRIu64 "\n", cmd->isid);
TRACE(TRACE_ISCSI_ARGS, "TSIH: %hu\n", cmd->tsih);
TRACE(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", cmd->tag);
TRACE(TRACE_ISCSI_ARGS, "CID: %hu\n", cmd->cid);
TRACE(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
TRACE(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Transit: %i\n", cmd->transit);
iscsi_trace(TRACE_ISCSI_ARGS, "Continue: %i\n", cmd->cont);
iscsi_trace(TRACE_ISCSI_ARGS, "CSG: %u\n", cmd->csg);
iscsi_trace(TRACE_ISCSI_ARGS, "NSG: %u\n", cmd->nsg);
iscsi_trace(TRACE_ISCSI_ARGS, "Version_min: %u\n", cmd->version_min);
iscsi_trace(TRACE_ISCSI_ARGS, "Version_max: %u\n", cmd->version_max);
iscsi_trace(TRACE_ISCSI_ARGS, "TotalAHSLength: %u\n", cmd->AHSlength);
iscsi_trace(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", cmd->length);
iscsi_trace(TRACE_ISCSI_ARGS, "ISID: %" PRIu64 "\n", cmd->isid);
iscsi_trace(TRACE_ISCSI_ARGS, "TSIH: %hu\n", cmd->tsih);
iscsi_trace(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", cmd->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "CID: %hu\n", cmd->cid);
iscsi_trace(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
RETURN_NOT_EQUAL("Byte 1, bits 2-3", (header[1] & 0x30) >> 4, 0, NO_CLEANUP, 1);
RETURN_NOT_EQUAL("Bytes 22-23", *((uint16_t *) (void *) (header + 22)), 0, NO_CLEANUP, 1);
@ -600,22 +600,22 @@ int
iscsi_login_rsp_encap(uint8_t *header, iscsi_login_rsp_args_t * rsp)
{
TRACE(TRACE_ISCSI_ARGS, "Transit: %i\n", rsp->transit);
TRACE(TRACE_ISCSI_ARGS, "Continue: %i\n", rsp->cont);
TRACE(TRACE_ISCSI_ARGS, "CSG: %u\n", rsp->csg);
TRACE(TRACE_ISCSI_ARGS, "NSG: %u\n", rsp->nsg);
TRACE(TRACE_ISCSI_ARGS, "Version_max: %u\n", rsp->version_max);
TRACE(TRACE_ISCSI_ARGS, "Version_active: %u\n", rsp->version_active);
TRACE(TRACE_ISCSI_ARGS, "TotalAHSLength: %u\n", rsp->AHSlength);
TRACE(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", rsp->length);
TRACE(TRACE_ISCSI_ARGS, "ISID: %" PRIu64 "\n", rsp->isid);
TRACE(TRACE_ISCSI_ARGS, "TSIH: %u\n", rsp->tsih);
TRACE(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", rsp->tag);
TRACE(TRACE_ISCSI_ARGS, "StatSN: %u\n", rsp->StatSN);
TRACE(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", rsp->ExpCmdSN);
TRACE(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", rsp->MaxCmdSN);
TRACE(TRACE_ISCSI_ARGS, "Status-Class: %u\n", rsp->status_class);
TRACE(TRACE_ISCSI_ARGS, "Status-Detail: %u\n", rsp->status_detail);
iscsi_trace(TRACE_ISCSI_ARGS, "Transit: %i\n", rsp->transit);
iscsi_trace(TRACE_ISCSI_ARGS, "Continue: %i\n", rsp->cont);
iscsi_trace(TRACE_ISCSI_ARGS, "CSG: %u\n", rsp->csg);
iscsi_trace(TRACE_ISCSI_ARGS, "NSG: %u\n", rsp->nsg);
iscsi_trace(TRACE_ISCSI_ARGS, "Version_max: %u\n", rsp->version_max);
iscsi_trace(TRACE_ISCSI_ARGS, "Version_active: %u\n", rsp->version_active);
iscsi_trace(TRACE_ISCSI_ARGS, "TotalAHSLength: %u\n", rsp->AHSlength);
iscsi_trace(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", rsp->length);
iscsi_trace(TRACE_ISCSI_ARGS, "ISID: %" PRIu64 "\n", rsp->isid);
iscsi_trace(TRACE_ISCSI_ARGS, "TSIH: %u\n", rsp->tsih);
iscsi_trace(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", rsp->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "StatSN: %u\n", rsp->StatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", rsp->ExpCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", rsp->MaxCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Status-Class: %u\n", rsp->status_class);
iscsi_trace(TRACE_ISCSI_ARGS, "Status-Detail: %u\n", rsp->status_detail);
(void) memset(header, 0x0, ISCSI_HEADER_LEN);
@ -670,23 +670,23 @@ iscsi_login_rsp_decap(uint8_t *header, iscsi_login_rsp_args_t * rsp)
rsp->status_class = header[36]; /* Status-Class */
rsp->status_detail = header[37]; /* Status-Detail */
TRACE(TRACE_ISCSI_ARGS, "Transit: %i\n", rsp->transit);
TRACE(TRACE_ISCSI_ARGS, "Continue: %i\n", rsp->cont);
TRACE(TRACE_ISCSI_ARGS, "CSG: %u\n", rsp->csg);
TRACE(TRACE_ISCSI_ARGS, "NSG: %u\n", rsp->nsg);
iscsi_trace(TRACE_ISCSI_ARGS, "Transit: %i\n", rsp->transit);
iscsi_trace(TRACE_ISCSI_ARGS, "Continue: %i\n", rsp->cont);
iscsi_trace(TRACE_ISCSI_ARGS, "CSG: %u\n", rsp->csg);
iscsi_trace(TRACE_ISCSI_ARGS, "NSG: %u\n", rsp->nsg);
TRACE(TRACE_ISCSI_ARGS, "Version_max: %u\n", rsp->version_max);
TRACE(TRACE_ISCSI_ARGS, "Version_active: %u\n", rsp->version_active);
TRACE(TRACE_ISCSI_ARGS, "TotalAHSLength: %u\n", rsp->AHSlength);
TRACE(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", rsp->length);
TRACE(TRACE_ISCSI_ARGS, "ISID: %" PRIu64 "\n", rsp->isid);
TRACE(TRACE_ISCSI_ARGS, "TSIH: %u\n", rsp->tsih);
TRACE(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", rsp->tag);
TRACE(TRACE_ISCSI_ARGS, "StatSN: %u\n", rsp->StatSN);
TRACE(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", rsp->ExpCmdSN);
TRACE(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", rsp->MaxCmdSN);
TRACE(TRACE_ISCSI_ARGS, "Status-Class: %u\n", rsp->status_class);
TRACE(TRACE_ISCSI_ARGS, "Status-Detail: %u\n", rsp->status_detail);
iscsi_trace(TRACE_ISCSI_ARGS, "Version_max: %u\n", rsp->version_max);
iscsi_trace(TRACE_ISCSI_ARGS, "Version_active: %u\n", rsp->version_active);
iscsi_trace(TRACE_ISCSI_ARGS, "TotalAHSLength: %u\n", rsp->AHSlength);
iscsi_trace(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", rsp->length);
iscsi_trace(TRACE_ISCSI_ARGS, "ISID: %" PRIu64 "\n", rsp->isid);
iscsi_trace(TRACE_ISCSI_ARGS, "TSIH: %u\n", rsp->tsih);
iscsi_trace(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", rsp->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "StatSN: %u\n", rsp->StatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", rsp->ExpCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", rsp->MaxCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Status-Class: %u\n", rsp->status_class);
iscsi_trace(TRACE_ISCSI_ARGS, "Status-Detail: %u\n", rsp->status_detail);
RETURN_NOT_EQUAL("Byte 1, bits 2-3", (header[1] & 0x30) >> 4, 0, NO_CLEANUP, 1);
RETURN_NOT_EQUAL("Bytes 20-23", *((uint32_t *) (void *) (header + 20)), 0, NO_CLEANUP, 1);
@ -706,12 +706,12 @@ int
iscsi_logout_cmd_encap(uint8_t *header, iscsi_logout_cmd_args_t * cmd)
{
TRACE(TRACE_ISCSI_ARGS, "Immediate: %i\n", cmd->immediate);
TRACE(TRACE_ISCSI_ARGS, "Reason: %u\n", cmd->reason);
TRACE(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", cmd->tag);
TRACE(TRACE_ISCSI_ARGS, "CID: %hu\n", cmd->cid);
TRACE(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
TRACE(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Immediate: %i\n", cmd->immediate);
iscsi_trace(TRACE_ISCSI_ARGS, "Reason: %u\n", cmd->reason);
iscsi_trace(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", cmd->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "CID: %hu\n", cmd->cid);
iscsi_trace(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
(void) memset(header, 0x0, ISCSI_HEADER_LEN);
@ -741,13 +741,13 @@ iscsi_logout_cmd_decap(uint8_t *header, iscsi_logout_cmd_args_t * cmd)
cmd->CmdSN = ISCSI_NTOHL(*((uint32_t *) (void *) (header + 24))); /* CmdSN */
cmd->ExpStatSN = ISCSI_NTOHL(*((uint32_t *) (void *) (header + 28))); /* ExpStatSN */
TRACE(TRACE_ISCSI_ARGS, "Immediate: %i\n", cmd->immediate);
TRACE(TRACE_ISCSI_ARGS, "Reason: %u\n", cmd->reason);
TRACE(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", cmd->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "Immediate: %i\n", cmd->immediate);
iscsi_trace(TRACE_ISCSI_ARGS, "Reason: %u\n", cmd->reason);
iscsi_trace(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", cmd->tag);
TRACE(TRACE_ISCSI_ARGS, "CID: %hu\n", cmd->cid);
TRACE(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
TRACE(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "CID: %hu\n", cmd->cid);
iscsi_trace(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
RETURN_NOT_EQUAL("Byte 0 bit 0", header[0] >> 7, 0, NO_CLEANUP, 1);
RETURN_NOT_EQUAL("Byte 1 bit 0", header[1] >> 7, 1, NO_CLEANUP, 1);
@ -773,15 +773,15 @@ int
iscsi_logout_rsp_encap(uint8_t *header, iscsi_logout_rsp_args_t * rsp)
{
TRACE(TRACE_ISCSI_ARGS, "Response: %u\n", rsp->response);
TRACE(TRACE_ISCSI_ARGS, "Length: %u\n", rsp->length);
TRACE(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", rsp->tag);
TRACE(TRACE_ISCSI_ARGS, "StatSN: %u\n", rsp->StatSN);
TRACE(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", rsp->ExpCmdSN);
TRACE(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", rsp->MaxCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Response: %u\n", rsp->response);
iscsi_trace(TRACE_ISCSI_ARGS, "Length: %u\n", rsp->length);
iscsi_trace(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", rsp->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "StatSN: %u\n", rsp->StatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", rsp->ExpCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", rsp->MaxCmdSN);
TRACE(TRACE_ISCSI_ARGS, "Time2Wait: %hu\n", rsp->Time2Wait);
TRACE(TRACE_ISCSI_ARGS, "Time2Retain: %hu\n", rsp->Time2Retain);
iscsi_trace(TRACE_ISCSI_ARGS, "Time2Wait: %hu\n", rsp->Time2Wait);
iscsi_trace(TRACE_ISCSI_ARGS, "Time2Retain: %hu\n", rsp->Time2Retain);
(void) memset(header, 0x0, ISCSI_HEADER_LEN);
@ -824,14 +824,14 @@ iscsi_logout_rsp_decap(uint8_t *header, iscsi_logout_rsp_args_t * rsp)
RETURN_NOT_EQUAL("Bytes 36-39", *((uint32_t *) (void *) (header + 36)), 0, NO_CLEANUP, 1);
RETURN_NOT_EQUAL("Bytes 44-47", *((uint32_t *) (void *) (header + 44)), 0, NO_CLEANUP, 1);
TRACE(TRACE_ISCSI_ARGS, "Response: %u\n", rsp->response);
TRACE(TRACE_ISCSI_ARGS, "Length: %u\n", rsp->length);
TRACE(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", rsp->tag);
TRACE(TRACE_ISCSI_ARGS, "StatSN: %u\n", rsp->StatSN);
TRACE(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", rsp->ExpCmdSN);
TRACE(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", rsp->MaxCmdSN);
TRACE(TRACE_ISCSI_ARGS, "Time2Wait: %hu\n", rsp->Time2Wait);
TRACE(TRACE_ISCSI_ARGS, "Time2Retain: %hu\n", rsp->Time2Retain);
iscsi_trace(TRACE_ISCSI_ARGS, "Response: %u\n", rsp->response);
iscsi_trace(TRACE_ISCSI_ARGS, "Length: %u\n", rsp->length);
iscsi_trace(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", rsp->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "StatSN: %u\n", rsp->StatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", rsp->ExpCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", rsp->MaxCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Time2Wait: %hu\n", rsp->Time2Wait);
iscsi_trace(TRACE_ISCSI_ARGS, "Time2Retain: %hu\n", rsp->Time2Retain);
return 0;
}
@ -844,19 +844,19 @@ int
iscsi_scsi_cmd_encap(uint8_t *header, iscsi_scsi_cmd_args_t * cmd)
{
TRACE(TRACE_ISCSI_ARGS, "Immediate: %i\n", cmd->immediate);
TRACE(TRACE_ISCSI_ARGS, "Final: %i\n", cmd->final);
TRACE(TRACE_ISCSI_ARGS, "Input: %i\n", cmd->input);
TRACE(TRACE_ISCSI_ARGS, "Output: %i\n", cmd->output);
TRACE(TRACE_ISCSI_ARGS, "ATTR: %i\n", cmd->attr);
TRACE(TRACE_ISCSI_ARGS, "TotalAHSLength: %u\n", cmd->ahs_len);
TRACE(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", cmd->length);
TRACE(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
TRACE(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", cmd->tag);
TRACE(TRACE_ISCSI_ARGS, "Transfer Length: %u\n", cmd->trans_len);
TRACE(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
TRACE(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
TRACE(TRACE_ISCSI_ARGS, "CDB: 0x%x\n", cmd->cdb[0]);
iscsi_trace(TRACE_ISCSI_ARGS, "Immediate: %i\n", cmd->immediate);
iscsi_trace(TRACE_ISCSI_ARGS, "Final: %i\n", cmd->final);
iscsi_trace(TRACE_ISCSI_ARGS, "Input: %i\n", cmd->input);
iscsi_trace(TRACE_ISCSI_ARGS, "Output: %i\n", cmd->output);
iscsi_trace(TRACE_ISCSI_ARGS, "ATTR: %i\n", cmd->attr);
iscsi_trace(TRACE_ISCSI_ARGS, "TotalAHSLength: %u\n", cmd->ahs_len);
iscsi_trace(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", cmd->length);
iscsi_trace(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
iscsi_trace(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", cmd->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "Transfer Length: %u\n", cmd->trans_len);
iscsi_trace(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "CDB: 0x%x\n", cmd->cdb[0]);
(void) memset(header, 0x0, ISCSI_HEADER_LEN);
@ -913,19 +913,19 @@ iscsi_scsi_cmd_decap(uint8_t *header, iscsi_scsi_cmd_args_t * cmd)
RETURN_NOT_EQUAL("Byte 2", header[2], 0, NO_CLEANUP, 1);
RETURN_NOT_EQUAL("Byte 3", header[3], 0, NO_CLEANUP, 1);
TRACE(TRACE_ISCSI_ARGS, "Immediate: %i\n", cmd->immediate);
TRACE(TRACE_ISCSI_ARGS, "Final: %i\n", cmd->final);
TRACE(TRACE_ISCSI_ARGS, "Input: %i\n", cmd->input);
TRACE(TRACE_ISCSI_ARGS, "Output: %i\n", cmd->output);
TRACE(TRACE_ISCSI_ARGS, "ATTR: %i\n", cmd->attr);
TRACE(TRACE_ISCSI_ARGS, "TotalAHSLength: %u\n", cmd->ahs_len);
TRACE(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", cmd->length);
TRACE(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
TRACE(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", cmd->tag);
TRACE(TRACE_ISCSI_ARGS, "Transfer Length: %u\n", cmd->trans_len);
TRACE(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
TRACE(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
TRACE(TRACE_ISCSI_ARGS, "CDB: 0x%x\n", cmd->cdb[0]);
iscsi_trace(TRACE_ISCSI_ARGS, "Immediate: %i\n", cmd->immediate);
iscsi_trace(TRACE_ISCSI_ARGS, "Final: %i\n", cmd->final);
iscsi_trace(TRACE_ISCSI_ARGS, "Input: %i\n", cmd->input);
iscsi_trace(TRACE_ISCSI_ARGS, "Output: %i\n", cmd->output);
iscsi_trace(TRACE_ISCSI_ARGS, "ATTR: %i\n", cmd->attr);
iscsi_trace(TRACE_ISCSI_ARGS, "TotalAHSLength: %u\n", cmd->ahs_len);
iscsi_trace(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", cmd->length);
iscsi_trace(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
iscsi_trace(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", cmd->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "Transfer Length: %u\n", cmd->trans_len);
iscsi_trace(TRACE_ISCSI_ARGS, "CmdSN: %u\n", cmd->CmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "CDB: 0x%x\n", cmd->cdb[0]);
return 0;
}
@ -938,20 +938,20 @@ int
iscsi_scsi_rsp_encap(uint8_t *header, iscsi_scsi_rsp_t * rsp)
{
TRACE(TRACE_ISCSI_ARGS, "Bidi Overflow: %i\n", rsp->bidi_overflow);
TRACE(TRACE_ISCSI_ARGS, "Bidi Underflow: %i\n", rsp->bidi_underflow);
TRACE(TRACE_ISCSI_ARGS, "Overflow: %i\n", rsp->overflow);
TRACE(TRACE_ISCSI_ARGS, "Underflow: %i\n", rsp->underflow);
TRACE(TRACE_ISCSI_ARGS, "iSCSI Response: %u\n", rsp->response);
TRACE(TRACE_ISCSI_ARGS, "SCSI Status: %u\n", rsp->status);
TRACE(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", rsp->length);
TRACE(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", rsp->tag);
TRACE(TRACE_ISCSI_ARGS, "StatSN: %u\n", rsp->StatSN);
TRACE(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", rsp->ExpCmdSN);
TRACE(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", rsp->MaxCmdSN);
TRACE(TRACE_ISCSI_ARGS, "ExpDataSN: %u\n", rsp->ExpDataSN);
TRACE(TRACE_ISCSI_ARGS, "Bidi Residual Count: %u\n", rsp->bidi_res_cnt);
TRACE(TRACE_ISCSI_ARGS, "Residual Count: %u\n", rsp->basic_res_cnt);
iscsi_trace(TRACE_ISCSI_ARGS, "Bidi Overflow: %i\n", rsp->bidi_overflow);
iscsi_trace(TRACE_ISCSI_ARGS, "Bidi Underflow: %i\n", rsp->bidi_underflow);
iscsi_trace(TRACE_ISCSI_ARGS, "Overflow: %i\n", rsp->overflow);
iscsi_trace(TRACE_ISCSI_ARGS, "Underflow: %i\n", rsp->underflow);
iscsi_trace(TRACE_ISCSI_ARGS, "iSCSI Response: %u\n", rsp->response);
iscsi_trace(TRACE_ISCSI_ARGS, "SCSI Status: %u\n", rsp->status);
iscsi_trace(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", rsp->length);
iscsi_trace(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", rsp->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "StatSN: %u\n", rsp->StatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", rsp->ExpCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", rsp->MaxCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpDataSN: %u\n", rsp->ExpDataSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Bidi Residual Count: %u\n", rsp->bidi_res_cnt);
iscsi_trace(TRACE_ISCSI_ARGS, "Residual Count: %u\n", rsp->basic_res_cnt);
(void) memset(header, 0x0, ISCSI_HEADER_LEN);
@ -1014,20 +1014,20 @@ iscsi_scsi_rsp_decap(uint8_t *header, iscsi_scsi_rsp_t * rsp)
RETURN_NOT_EQUAL("bidi_underflow", rsp->bidi_underflow, 0, NO_CLEANUP, 1);
RETURN_NOT_EQUAL("overflow", rsp->overflow, 0, NO_CLEANUP, 1);
TRACE(TRACE_ISCSI_ARGS, "Bidi Overflow: %i\n", rsp->bidi_overflow);
TRACE(TRACE_ISCSI_ARGS, "Bidi Underflow: %i\n", rsp->bidi_underflow);
TRACE(TRACE_ISCSI_ARGS, "Overflow: %i\n", rsp->overflow);
TRACE(TRACE_ISCSI_ARGS, "Underflow: %i\n", rsp->underflow);
TRACE(TRACE_ISCSI_ARGS, "iSCSI Response: %u\n", rsp->response);
TRACE(TRACE_ISCSI_ARGS, "SCSI Status: %u\n", rsp->status);
TRACE(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", rsp->length);
TRACE(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", rsp->tag);
TRACE(TRACE_ISCSI_ARGS, "Residual Count: %u\n", rsp->basic_res_cnt);
TRACE(TRACE_ISCSI_ARGS, "StatSN: %u\n", rsp->StatSN);
TRACE(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", rsp->ExpCmdSN);
TRACE(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", rsp->MaxCmdSN);
TRACE(TRACE_ISCSI_ARGS, "ExpDataSN: %u\n", rsp->ExpDataSN);
TRACE(TRACE_ISCSI_ARGS, "Bidi Residual Count: %u\n", rsp->bidi_res_cnt);
iscsi_trace(TRACE_ISCSI_ARGS, "Bidi Overflow: %i\n", rsp->bidi_overflow);
iscsi_trace(TRACE_ISCSI_ARGS, "Bidi Underflow: %i\n", rsp->bidi_underflow);
iscsi_trace(TRACE_ISCSI_ARGS, "Overflow: %i\n", rsp->overflow);
iscsi_trace(TRACE_ISCSI_ARGS, "Underflow: %i\n", rsp->underflow);
iscsi_trace(TRACE_ISCSI_ARGS, "iSCSI Response: %u\n", rsp->response);
iscsi_trace(TRACE_ISCSI_ARGS, "SCSI Status: %u\n", rsp->status);
iscsi_trace(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", rsp->length);
iscsi_trace(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", rsp->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "Residual Count: %u\n", rsp->basic_res_cnt);
iscsi_trace(TRACE_ISCSI_ARGS, "StatSN: %u\n", rsp->StatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", rsp->ExpCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", rsp->MaxCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpDataSN: %u\n", rsp->ExpDataSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Bidi Residual Count: %u\n", rsp->bidi_res_cnt);
return 0;
}
@ -1042,16 +1042,16 @@ iscsi_r2t_encap(uint8_t *header, iscsi_r2t_t * cmd)
{
uint32_t length;
TRACE(TRACE_ISCSI_ARGS, "TotalAHSLength: %u\n", cmd->AHSlength);
TRACE(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
TRACE(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", cmd->tag);
TRACE(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", cmd->transfer_tag);
TRACE(TRACE_ISCSI_ARGS, "StatSN: %u\n", cmd->StatSN);
TRACE(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", cmd->ExpCmdSN);
TRACE(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", cmd->MaxCmdSN);
TRACE(TRACE_ISCSI_ARGS, "R2TSN: %u\n", cmd->R2TSN);
TRACE(TRACE_ISCSI_ARGS, "Offset: %u\n", cmd->offset);
TRACE(TRACE_ISCSI_ARGS, "Length: %u\n", cmd->length);
iscsi_trace(TRACE_ISCSI_ARGS, "TotalAHSLength: %u\n", cmd->AHSlength);
iscsi_trace(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
iscsi_trace(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", cmd->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", cmd->transfer_tag);
iscsi_trace(TRACE_ISCSI_ARGS, "StatSN: %u\n", cmd->StatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", cmd->ExpCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", cmd->MaxCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "R2TSN: %u\n", cmd->R2TSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Offset: %u\n", cmd->offset);
iscsi_trace(TRACE_ISCSI_ARGS, "Length: %u\n", cmd->length);
(void) memset(header, 0x0, ISCSI_HEADER_LEN);
@ -1096,16 +1096,16 @@ iscsi_r2t_decap(uint8_t *header, iscsi_r2t_t * cmd)
RETURN_NOT_EQUAL("Bytes 8-11", *((uint32_t *) (void *) (header + 8)), 0, NO_CLEANUP, 1);
RETURN_NOT_EQUAL("Bytes 12-15", *((uint32_t *) (void *) (header + 12)), 0, NO_CLEANUP, 1);
TRACE(TRACE_ISCSI_ARGS, "AHSLength: %u\n", cmd->AHSlength);
TRACE(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
TRACE(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", cmd->tag);
TRACE(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", cmd->transfer_tag);
TRACE(TRACE_ISCSI_ARGS, "StatSN: %u\n", cmd->StatSN);
TRACE(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", cmd->ExpCmdSN);
TRACE(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", cmd->MaxCmdSN);
TRACE(TRACE_ISCSI_ARGS, "R2TSN: %u\n", cmd->R2TSN);
TRACE(TRACE_ISCSI_ARGS, "Offset: %u\n", cmd->offset);
TRACE(TRACE_ISCSI_ARGS, "Length: %u\n", cmd->length);
iscsi_trace(TRACE_ISCSI_ARGS, "AHSLength: %u\n", cmd->AHSlength);
iscsi_trace(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
iscsi_trace(TRACE_ISCSI_ARGS, "Tag: 0x%x\n", cmd->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", cmd->transfer_tag);
iscsi_trace(TRACE_ISCSI_ARGS, "StatSN: %u\n", cmd->StatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", cmd->ExpCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", cmd->MaxCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "R2TSN: %u\n", cmd->R2TSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Offset: %u\n", cmd->offset);
iscsi_trace(TRACE_ISCSI_ARGS, "Length: %u\n", cmd->length);
return 0;
}
@ -1117,14 +1117,14 @@ int
iscsi_write_data_encap(uint8_t *header, iscsi_write_data_t * cmd)
{
TRACE(TRACE_ISCSI_ARGS, "Final: %u\n", cmd->final);
TRACE(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", cmd->length);
TRACE(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
TRACE(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", cmd->tag);
TRACE(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", cmd->transfer_tag);
TRACE(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
TRACE(TRACE_ISCSI_ARGS, "DataSN: %u\n", cmd->DataSN);
TRACE(TRACE_ISCSI_ARGS, "Buffer Offset: %u\n", cmd->offset);
iscsi_trace(TRACE_ISCSI_ARGS, "Final: %u\n", cmd->final);
iscsi_trace(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", cmd->length);
iscsi_trace(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
iscsi_trace(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", cmd->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", cmd->transfer_tag);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "DataSN: %u\n", cmd->DataSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Buffer Offset: %u\n", cmd->offset);
(void) memset(header, 0x0, ISCSI_HEADER_LEN);
header[0] = 0x00 | ISCSI_WRITE_DATA; /* Opcode */
@ -1165,14 +1165,14 @@ iscsi_write_data_decap(uint8_t *header, iscsi_write_data_t * cmd)
RETURN_NOT_EQUAL("Byte 32-35", *((uint32_t *) (void *) (header + 32)), 0, NO_CLEANUP, 1);
RETURN_NOT_EQUAL("Byte 44-47", *((uint32_t *) (void *) (header + 44)), 0, NO_CLEANUP, 1);
TRACE(TRACE_ISCSI_ARGS, "Final: %u\n", cmd->final);
TRACE(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", cmd->length);
TRACE(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
TRACE(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", cmd->tag);
TRACE(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", cmd->transfer_tag);
TRACE(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
TRACE(TRACE_ISCSI_ARGS, "DataSN: %u\n", cmd->DataSN);
TRACE(TRACE_ISCSI_ARGS, "Buffer Offset: %u\n", cmd->offset);
iscsi_trace(TRACE_ISCSI_ARGS, "Final: %u\n", cmd->final);
iscsi_trace(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", cmd->length);
iscsi_trace(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
iscsi_trace(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", cmd->tag);
iscsi_trace(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", cmd->transfer_tag);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpStatSN: %u\n", cmd->ExpStatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "DataSN: %u\n", cmd->DataSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Buffer Offset: %u\n", cmd->offset);
return 0;
}
@ -1185,22 +1185,22 @@ int
iscsi_read_data_encap(uint8_t *header, iscsi_read_data_t * cmd)
{
TRACE(TRACE_ISCSI_ARGS, "Final: %i\n", cmd->final);
TRACE(TRACE_ISCSI_ARGS, "Acknowledge: %i\n", cmd->ack);
TRACE(TRACE_ISCSI_ARGS, "Overflow: %i\n", cmd->overflow);
TRACE(TRACE_ISCSI_ARGS, "Underflow: %i\n", cmd->underflow);
TRACE(TRACE_ISCSI_ARGS, "S_bit: %i\n", cmd->S_bit);
TRACE(TRACE_ISCSI_ARGS, "Status: %u\n", cmd->status);
TRACE(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", cmd->length);
TRACE(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
TRACE(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", cmd->task_tag);
TRACE(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", cmd->transfer_tag);
TRACE(TRACE_ISCSI_ARGS, "StatSN: %u\n", cmd->StatSN);
TRACE(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", cmd->ExpCmdSN);
TRACE(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", cmd->MaxCmdSN);
TRACE(TRACE_ISCSI_ARGS, "DataSN: %u\n", cmd->DataSN);
TRACE(TRACE_ISCSI_ARGS, "Buffer Offset %u\n", cmd->offset);
TRACE(TRACE_ISCSI_ARGS, "Residual Count: %u\n", cmd->res_count);
iscsi_trace(TRACE_ISCSI_ARGS, "Final: %i\n", cmd->final);
iscsi_trace(TRACE_ISCSI_ARGS, "Acknowledge: %i\n", cmd->ack);
iscsi_trace(TRACE_ISCSI_ARGS, "Overflow: %i\n", cmd->overflow);
iscsi_trace(TRACE_ISCSI_ARGS, "Underflow: %i\n", cmd->underflow);
iscsi_trace(TRACE_ISCSI_ARGS, "S_bit: %i\n", cmd->S_bit);
iscsi_trace(TRACE_ISCSI_ARGS, "Status: %u\n", cmd->status);
iscsi_trace(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", cmd->length);
iscsi_trace(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", cmd->lun);
iscsi_trace(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", cmd->task_tag);
iscsi_trace(TRACE_ISCSI_ARGS, "Transfer Tag: 0x%x\n", cmd->transfer_tag);
iscsi_trace(TRACE_ISCSI_ARGS, "StatSN: %u\n", cmd->StatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", cmd->ExpCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", cmd->MaxCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "DataSN: %u\n", cmd->DataSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Buffer Offset %u\n", cmd->offset);
iscsi_trace(TRACE_ISCSI_ARGS, "Residual Count: %u\n", cmd->res_count);
(void) memset(header, 0x0, ISCSI_HEADER_LEN);
@ -1272,20 +1272,20 @@ iscsi_read_data_decap(uint8_t *header, iscsi_read_data_t * cmd)
RETURN_NOT_EQUAL("Bytes 12-15", *((uint32_t *) (void *) (header + 12)), 0, NO_CLEANUP, 1);
RETURN_NOT_EQUAL("Bytes 44-47", *((uint32_t *) (void *) (header + 44)), 0, NO_CLEANUP, 1);
TRACE(TRACE_ISCSI_ARGS, "Final: %i\n", cmd->final);
TRACE(TRACE_ISCSI_ARGS, "Acknowledge: %i\n", cmd->ack);
TRACE(TRACE_ISCSI_ARGS, "Overflow: %i\n", cmd->overflow);
TRACE(TRACE_ISCSI_ARGS, "Underflow: %i\n", cmd->underflow);
TRACE(TRACE_ISCSI_ARGS, "S_bit: %i\n", cmd->S_bit);
TRACE(TRACE_ISCSI_ARGS, "Status: %u\n", cmd->status);
TRACE(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", cmd->length);
TRACE(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", cmd->task_tag);
TRACE(TRACE_ISCSI_ARGS, "Residual Count: %u\n", cmd->res_count);
TRACE(TRACE_ISCSI_ARGS, "StatSN: %u\n", cmd->StatSN);
TRACE(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", cmd->ExpCmdSN);
TRACE(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", cmd->MaxCmdSN);
TRACE(TRACE_ISCSI_ARGS, "DataSN: %u\n", cmd->DataSN);
TRACE(TRACE_ISCSI_ARGS, "Buffer Offset %u\n", cmd->offset);
iscsi_trace(TRACE_ISCSI_ARGS, "Final: %i\n", cmd->final);
iscsi_trace(TRACE_ISCSI_ARGS, "Acknowledge: %i\n", cmd->ack);
iscsi_trace(TRACE_ISCSI_ARGS, "Overflow: %i\n", cmd->overflow);
iscsi_trace(TRACE_ISCSI_ARGS, "Underflow: %i\n", cmd->underflow);
iscsi_trace(TRACE_ISCSI_ARGS, "S_bit: %i\n", cmd->S_bit);
iscsi_trace(TRACE_ISCSI_ARGS, "Status: %u\n", cmd->status);
iscsi_trace(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", cmd->length);
iscsi_trace(TRACE_ISCSI_ARGS, "Task Tag: 0x%x\n", cmd->task_tag);
iscsi_trace(TRACE_ISCSI_ARGS, "Residual Count: %u\n", cmd->res_count);
iscsi_trace(TRACE_ISCSI_ARGS, "StatSN: %u\n", cmd->StatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", cmd->ExpCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", cmd->MaxCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "DataSN: %u\n", cmd->DataSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Buffer Offset %u\n", cmd->offset);
return 0;
}
@ -1297,12 +1297,12 @@ int
iscsi_reject_encap(uint8_t *header, iscsi_reject_t * cmd)
{
TRACE(TRACE_ISCSI_ARGS, "Reason: %u\n", cmd->reason);
TRACE(TRACE_ISCSI_ARGS, "Length: %u\n", cmd->length);
TRACE(TRACE_ISCSI_ARGS, "StatSN: %u\n", cmd->StatSN);
TRACE(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", cmd->ExpCmdSN);
TRACE(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", cmd->MaxCmdSN);
TRACE(TRACE_ISCSI_ARGS, "DataSN: %u\n", cmd->DataSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Reason: %u\n", cmd->reason);
iscsi_trace(TRACE_ISCSI_ARGS, "Length: %u\n", cmd->length);
iscsi_trace(TRACE_ISCSI_ARGS, "StatSN: %u\n", cmd->StatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", cmd->ExpCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", cmd->MaxCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "DataSN: %u\n", cmd->DataSN);
(void) memset(header, 0x0, ISCSI_HEADER_LEN);
@ -1341,12 +1341,12 @@ iscsi_reject_decap(uint8_t *header, iscsi_reject_t * cmd)
RETURN_NOT_EQUAL("Bytes 40-43", *((uint32_t *) (void *) (header + 40)), 0, NO_CLEANUP, 1);
RETURN_NOT_EQUAL("Bytes 44-47", *((uint32_t *) (void *) (header + 44)), 0, NO_CLEANUP, 1);
TRACE(TRACE_ISCSI_ARGS, "Reason: %u\n", cmd->reason);
TRACE(TRACE_ISCSI_ARGS, "Length: %u\n", cmd->length);
TRACE(TRACE_ISCSI_ARGS, "StatSN: %u\n", cmd->StatSN);
TRACE(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", cmd->ExpCmdSN);
TRACE(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", cmd->MaxCmdSN);
TRACE(TRACE_ISCSI_ARGS, "DataSN: %u\n", cmd->DataSN);
iscsi_trace(TRACE_ISCSI_ARGS, "Reason: %u\n", cmd->reason);
iscsi_trace(TRACE_ISCSI_ARGS, "Length: %u\n", cmd->length);
iscsi_trace(TRACE_ISCSI_ARGS, "StatSN: %u\n", cmd->StatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", cmd->ExpCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", cmd->MaxCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "DataSN: %u\n", cmd->DataSN);
return 0;
}
@ -1365,14 +1365,14 @@ iscsi_amsg_decap(uint8_t *header, iscsi_async_msg_t * msg)
msg->AsyncEvent = header[36]; /* Async Event */
msg->AsyncVCode = header[37]; /* Async Vendor Code */
TRACE(TRACE_ISCSI_ARGS, "TotalAHSLength: %u\n", msg->AHSlength);
TRACE(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", msg->length);
TRACE(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", msg->lun);
TRACE(TRACE_ISCSI_ARGS, "StatSN: %u\n", msg->StatSN);
TRACE(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", msg->ExpCmdSN);
TRACE(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", msg->MaxCmdSN);
TRACE(TRACE_ISCSI_ARGS, "AsyncEvent: %u\n", msg->AsyncEvent);
TRACE(TRACE_ISCSI_ARGS, "AsyncVCode: %u\n", msg->AsyncVCode);
iscsi_trace(TRACE_ISCSI_ARGS, "TotalAHSLength: %u\n", msg->AHSlength);
iscsi_trace(TRACE_ISCSI_ARGS, "DataSegmentLength: %u\n", msg->length);
iscsi_trace(TRACE_ISCSI_ARGS, "LUN: %" PRIu64 "\n", msg->lun);
iscsi_trace(TRACE_ISCSI_ARGS, "StatSN: %u\n", msg->StatSN);
iscsi_trace(TRACE_ISCSI_ARGS, "ExpCmdSN: %u\n", msg->ExpCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "MaxCmdSN: %u\n", msg->MaxCmdSN);
iscsi_trace(TRACE_ISCSI_ARGS, "AsyncEvent: %u\n", msg->AsyncEvent);
iscsi_trace(TRACE_ISCSI_ARGS, "AsyncVCode: %u\n", msg->AsyncVCode);
return 0;
}

8
dist/iscsi/src/iscsiconfig.c vendored
View File

@ -133,7 +133,7 @@ main(int argc, char **argv)
if (user == NULL) {
if ((pwp = getpwuid(geteuid())) == NULL) {
TRACE_ERROR("can't find user information\n");
iscsi_trace_error("can't find user information\n");
exit(EXIT_FAILURE);
}
user = pwp->pw_name;
@ -141,7 +141,7 @@ main(int argc, char **argv)
if (target != -1) {
if (target >= CONFIG_INITIATOR_NUM_TARGETS) {
TRACE_ERROR("initiator only configured with %i targets\n", CONFIG_INITIATOR_NUM_TARGETS);
iscsi_trace_error("initiator only configured with %i targets\n", CONFIG_INITIATOR_NUM_TARGETS);
exit(EXIT_FAILURE);
}
tgtlo = target;
@ -160,7 +160,7 @@ main(int argc, char **argv)
for (i = optind ; i < argc ; i++) {
/* Initialize Initiator */
if (initiator_init(host, user, auth_type, mutual_auth, digest_type) == -1) {
TRACE_ERROR("initiator_init() failed\n");
iscsi_trace_error("initiator_init() failed\n");
exit(EXIT_FAILURE);
}
@ -169,7 +169,7 @@ main(int argc, char **argv)
/* Shutdown Initiator */
if (initiator_shutdown() == -1) {
TRACE_ERROR("initiator_shutdown() failed\n");
iscsi_trace_error("initiator_shutdown() failed\n");
exit(EXIT_FAILURE);
}
}

6
dist/iscsi/src/ktarget.c vendored
View File

@ -52,7 +52,7 @@ static int port = ISCSI_PORT; MODULE_PARM(port, "i");
static int accept_connections(void *arg) {
if (target_listen(port)!=0) {
TRACE_ERROR("target_listen() failed\n");
iscsi_trace_error("target_listen() failed\n");
}
return 0;
}
@ -62,7 +62,7 @@ int init_module(void) {
printk("Usage: port=<int>\n");
printk("\n");
if (target_init(DEFAULT_TARGET_NAME)!=0) {
TRACE_ERROR("target_init() failed\n");
iscsi_trace_error("target_init() failed\n");
return -1;
}
kernel_thread(accept_connections, NULL, 0);
@ -71,6 +71,6 @@ int init_module(void) {
void cleanup_module(void) {
if (target_shutdown()!=0) {
TRACE_ERROR("target_shutdown() failed\n");
iscsi_trace_error("target_shutdown() failed\n");
}
}

12
dist/iscsi/src/mount_iscsi.c vendored
View File

@ -1,4 +1,4 @@
/* $NetBSD: mount_iscsi.c,v 1.1.1.1 2006/02/08 18:56:18 agc Exp $ */
/* $NetBSD: mount_iscsi.c,v 1.2 2006/03/12 18:47:28 agc Exp $ */
/*
* Copyright © 2005 Alistair Crooks. All rights reserved.
@ -32,7 +32,7 @@
#ifndef lint
__COPYRIGHT("@(#) Copyright © 2005 \
The NetBSD Foundation, Inc. All rights reserved.");
__RCSID("$NetBSD: mount_iscsi.c,v 1.1.1.1 2006/02/08 18:56:18 agc Exp $");
__RCSID("$NetBSD: mount_iscsi.c,v 1.2 2006/03/12 18:47:28 agc Exp $");
#endif
#include <sys/types.h>
@ -255,7 +255,7 @@ main(int argc, char **argv)
}
for (j = 0; j < 1; j++) {
PRINT("<ITER %i>\n", j);
printf("<ITER %i>\n", j);
/* Ignore sigpipe */
@ -265,14 +265,14 @@ main(int argc, char **argv)
/* Initialize Initiator */
if (initiator_init(iqn.domain) == -1) {
TRACE_ERROR("initiator_init() failed\n");
iscsi_trace_error("initiator_init() failed\n");
return -1;
}
/* Run tests for each target */
for (i = begin_tid; i < end_tid; i++) {
if (test_all(i, lun) != 0) {
TRACE_ERROR("test_all() failed\n");
iscsi_trace_error("test_all() failed\n");
return -1;
}
}
@ -280,7 +280,7 @@ main(int argc, char **argv)
/* Shutdown Initiator */
if (initiator_shutdown() == -1) {
TRACE_ERROR("initiator_shutdown() failed\n");
iscsi_trace_error("initiator_shutdown() failed\n");
return -1;
}
}

12
dist/iscsi/src/osd-target.c vendored
View File

@ -1,4 +1,4 @@
/* $NetBSD: osd-target.c,v 1.3 2006/02/12 14:48:49 agc Exp $ */
/* $NetBSD: osd-target.c,v 1.4 2006/03/12 18:47:28 agc Exp $ */
/*
* Copyright © 2006 Alistair Crooks. All rights reserved.
@ -36,7 +36,7 @@
#ifndef lint
__COPYRIGHT("@(#) Copyright © 2006 \
The NetBSD Foundation, Inc. All rights reserved.");
__RCSID("$NetBSD: osd-target.c,v 1.3 2006/02/12 14:48:49 agc Exp $");
__RCSID("$NetBSD: osd-target.c,v 1.4 2006/03/12 18:47:28 agc Exp $");
#endif
#include "config.h"
@ -81,7 +81,7 @@ handler(int s)
if (ISCSI_GETPID != g_main_pid)
return;
if (target_shutdown(&g) != 0) {
TRACE_ERROR("target_shutdown() failed\n");
iscsi_trace_error("target_shutdown() failed\n");
return;
}
return;
@ -160,7 +160,7 @@ main(int argc, char **argv)
/* Initialize target */
for (i = optind ; i < argc ; i++) {
if (target_init(&g, &tv, TargetName, i) != 0) {
TRACE_ERROR("target_init() failed\n");
iscsi_trace_error("target_init() failed\n");
exit(EXIT_FAILURE);
}
}
@ -168,7 +168,7 @@ main(int argc, char **argv)
#ifdef HAVE_DAEMON
/* if we are supposed to be a daemon, detach from controlling tty */
if (detach_me_harder && daemon(0, 0) < 0) {
TRACE_ERROR("daemon() failed\n");
iscsi_trace_error("daemon() failed\n");
exit(EXIT_FAILURE);
}
#endif
@ -178,7 +178,7 @@ main(int argc, char **argv)
/* Wait for connections */
if (target_listen(&g) != 0) {
TRACE_ERROR("target_listen() failed\n");
iscsi_trace_error("target_listen() failed\n");
}
return EXIT_SUCCESS;

90
dist/iscsi/src/osd.c vendored
View File

@ -124,7 +124,7 @@ device_init(globals_t *gp, char *dev)
if (mkdir(base_dir, 0755) != 0) {
if (errno != EEXIST) {
TRACE_ERROR("error creating directory \"%s\" for OSD: errno %i\n", base_dir, errno);
iscsi_trace_error("error creating directory \"%s\" for OSD: errno %i\n", base_dir, errno);
return -1;
}
}
@ -134,7 +134,7 @@ device_init(globals_t *gp, char *dev)
sprintf(FileName, "%s/lun_%i", base_dir, i);
if (mkdir(FileName, 0755) != 0) {
if (errno != EEXIST) {
TRACE_ERROR("error creating \"%s\" for LU %i: errno %i\n", FileName, i, errno);
iscsi_trace_error("error creating \"%s\" for LU %i: errno %i\n", FileName, i, errno);
return -1;
}
}
@ -180,10 +180,10 @@ device_command(target_session_t * sess, target_cmd_t * cmd)
uint32_t index = 0;
int attr_len = 0;
TRACE(TRACE_SCSI_CMD, "SCSI op 0x%x (lun %llu)\n", args->cdb[0], args->lun);
iscsi_trace(TRACE_SCSI_CMD, "SCSI op 0x%x (lun %llu)\n", args->cdb[0], args->lun);
if (args->lun >= osd_luns) {
TRACE(TRACE_SCSI_DEBUG, "invalid lun: %llu\n", args->lun);
iscsi_trace(TRACE_SCSI_DEBUG, "invalid lun: %llu\n", args->lun);
args->status = 0x01;
return 0;
}
@ -193,14 +193,14 @@ device_command(target_session_t * sess, target_cmd_t * cmd)
case TEST_UNIT_READY:
TRACE(TRACE_SCSI_CMD, "TEST_UNIT_READY(lun %llu)\n", args->lun);
iscsi_trace(TRACE_SCSI_CMD, "TEST_UNIT_READY(lun %llu)\n", args->lun);
args->status = 0;
args->length = 0;
break;
case INQUIRY:
TRACE(TRACE_SCSI_CMD, "INQUIRY(lun %llu)\n", args->lun);
iscsi_trace(TRACE_SCSI_CMD, "INQUIRY(lun %llu)\n", args->lun);
data = args->send_data;
memset(data, 0, args->cdb[4]); /* Clear allocated buffer */
data[0] = 0x0e; /* Peripheral Device Type */
@ -247,7 +247,7 @@ device_command(target_session_t * sess, target_cmd_t * cmd)
if (osd_args.set_attributes_list_length) {
if ((set_list = iscsi_malloc_atomic(osd_args.set_attributes_list_length)) == NULL) {
TRACE_ERROR("iscsi_malloc_atomic() failed\n");
iscsi_trace_error("iscsi_malloc_atomic() failed\n");
goto done;
}
sg[sg_len].iov_base = set_list;
@ -256,7 +256,7 @@ device_command(target_session_t * sess, target_cmd_t * cmd)
}
if (osd_args.get_attributes_list_length) {
if ((get_list = iscsi_malloc_atomic(osd_args.get_attributes_list_length)) == NULL) {
TRACE_ERROR("iscsi_malloc_atomic() failed\n");
iscsi_trace_error("iscsi_malloc_atomic() failed\n");
goto done;
}
sg[sg_len].iov_base = get_list;
@ -265,7 +265,7 @@ device_command(target_session_t * sess, target_cmd_t * cmd)
}
if (osd_args.service_action == OSD_WRITE) {
if ((write_data = iscsi_malloc_atomic(osd_args.length)) == NULL) {
TRACE_ERROR("iscsi_malloc_atomic() failed\n");
iscsi_trace_error("iscsi_malloc_atomic() failed\n");
goto done;
}
sg[sg_len].iov_base = write_data;
@ -274,7 +274,7 @@ device_command(target_session_t * sess, target_cmd_t * cmd)
}
if (sg_len) {
if (target_transfer_data(sess, args, sg, sg_len) != 0) {
TRACE_ERROR("target_transfer_data() failed\n");
iscsi_trace_error("target_transfer_data() failed\n");
goto done;
}
}
@ -287,7 +287,7 @@ device_command(target_session_t * sess, target_cmd_t * cmd)
uint16_t len;
int i;
TRACE(TRACE_OSD, "OSD_SET_ATTR(lun %llu, GroupID 0x%x, UserID 0x%llx)\n", args->lun, osd_args.GroupID, osd_args.UserID);
iscsi_trace(TRACE_OSD, "OSD_SET_ATTR(lun %llu, GroupID 0x%x, UserID 0x%llx)\n", args->lun, osd_args.GroupID, osd_args.UserID);
for (i = 0; i < osd_args.set_attributes_list_length;) {
page = ISCSI_NTOHL(*((uint32_t *) (&(set_list[i]))));
i += 4;
@ -298,15 +298,15 @@ device_command(target_session_t * sess, target_cmd_t * cmd)
sprintf(FileName, "%s/lun_%llu/0x%x/0x%llx.0x%x.%u",
base_dir, args->lun, osd_args.GroupID, osd_args.UserID, page, attr);
if ((rc = open(FileName, O_WRONLY | O_CREAT, 0644)) == -1) {
TRACE_ERROR("error opening \"%s\": errno %i\n", FileName, errno);
iscsi_trace_error("error opening \"%s\": errno %i\n", FileName, errno);
goto done;
}
if (write(rc, set_list + i, len) != len) {
TRACE_ERROR("write() failed\n");
iscsi_trace_error("write() failed\n");
}
close(rc);
i += len;
TRACE(TRACE_OSD, "SET(0x%x,%u,%u>\n", page, attr, len);
iscsi_trace(TRACE_OSD, "SET(0x%x,%u,%u>\n", page, attr, len);
}
}
args->send_sg_len = 0;
@ -321,16 +321,16 @@ device_command(target_session_t * sess, target_cmd_t * cmd)
sprintf(FileName, "%s/lun_%llu/0x%x", base_dir, args->lun, GroupID);
rc = mkdir(FileName, 0755);
} while (rc == -1 && errno == EEXIST);
TRACE(TRACE_OSD, "OSD_CREATE_GROUP(lun %llu) --> 0x%x\n", args->lun, GroupID);
iscsi_trace(TRACE_OSD, "OSD_CREATE_GROUP(lun %llu) --> 0x%x\n", args->lun, GroupID);
args->status = 0;
break;
case OSD_REMOVE_GROUP:
TRACE(TRACE_OSD, "OSD_REMOVE_GROUP(lun %llu, 0x%x)\n", args->lun, osd_args.GroupID);
iscsi_trace(TRACE_OSD, "OSD_REMOVE_GROUP(lun %llu, 0x%x)\n", args->lun, osd_args.GroupID);
sprintf(FileName, "%s/lun_%llu/0x%x", base_dir, args->lun, osd_args.GroupID);
if ((rc = rmdir(FileName)) == -1) {
TRACE_ERROR("rmdir(\"%s\") failed: errno %i\n", FileName, errno);
iscsi_trace_error("rmdir(\"%s\") failed: errno %i\n", FileName, errno);
goto done;
}
args->status = 0;
@ -348,43 +348,43 @@ create_user_again:
goto create_user_again;
}
close(rc);
TRACE(TRACE_OSD, "OSD_CREATE(lun %llu, GroupID 0x%x) --> 0x%llx\n", args->lun, osd_args.GroupID, UserID);
iscsi_trace(TRACE_OSD, "OSD_CREATE(lun %llu, GroupID 0x%x) --> 0x%llx\n", args->lun, osd_args.GroupID, UserID);
args->status = 0;
break;
case OSD_REMOVE:
TRACE(TRACE_OSD, "OSD_REMOVE(lun %llu, 0x%llx)\n", args->lun, osd_args.UserID);
iscsi_trace(TRACE_OSD, "OSD_REMOVE(lun %llu, 0x%llx)\n", args->lun, osd_args.UserID);
sprintf(FileName, "%s/lun_%llu/0x%x/0x%llx",
base_dir, args->lun, osd_args.GroupID, osd_args.UserID);
if ((rc = unlink(FileName)) == -1) {
TRACE_ERROR("unlink(\"%s\") failed: errno %i\n", FileName, errno);
iscsi_trace_error("unlink(\"%s\") failed: errno %i\n", FileName, errno);
goto done;
}
sprintf(string, "rm -f %s/lun_%llu/0x%x/0x%llx.*", base_dir, args->lun, osd_args.GroupID, osd_args.UserID);
if (system(string) != 0) {
TRACE_ERROR("\"%s\" failed\n", string);
iscsi_trace_error("\"%s\" failed\n", string);
return -1;
}
args->status = 0;
break;
case OSD_WRITE:
TRACE(TRACE_OSD, "OSD_WRITE(lun %llu, GroupID 0x%x, UserID 0x%llx, length %llu, offset %llu)\n",
iscsi_trace(TRACE_OSD, "OSD_WRITE(lun %llu, GroupID 0x%x, UserID 0x%llx, length %llu, offset %llu)\n",
args->lun, osd_args.GroupID, osd_args.UserID, osd_args.length, osd_args.offset);
sprintf(FileName, "%s/lun_%llu/0x%x/0x%llx",
base_dir, args->lun, osd_args.GroupID, osd_args.UserID);
if ((rc = open(FileName, O_WRONLY, 0644)) == -1) {
TRACE_ERROR("error opening \"%s\": errno %i\n", FileName, errno);
iscsi_trace_error("error opening \"%s\": errno %i\n", FileName, errno);
goto write_done;
}
if (lseek(rc, osd_args.offset, SEEK_SET) == -1) {
TRACE_ERROR("error seeking \"%s\": errno %i\n", FileName, errno);
iscsi_trace_error("error seeking \"%s\": errno %i\n", FileName, errno);
goto write_done;
}
if (write(rc, write_data, osd_args.length) != osd_args.length) {
TRACE_ERROR("write() failed\n");
iscsi_trace_error("write() failed\n");
goto write_done;
}
close(rc);
@ -393,24 +393,24 @@ write_done:
break;
case OSD_READ:
TRACE(TRACE_OSD, "OSD_READ(lun %llu, GroupID 0x%x, UserID 0x%llx, length %llu, offset %llu)\n",
iscsi_trace(TRACE_OSD, "OSD_READ(lun %llu, GroupID 0x%x, UserID 0x%llx, length %llu, offset %llu)\n",
args->lun, osd_args.GroupID, osd_args.UserID, osd_args.length, osd_args.offset);
sprintf(FileName, "%s/lun_%llu/0x%x/0x%llx",
base_dir, args->lun, osd_args.GroupID, osd_args.UserID);
if ((rc = open(FileName, O_RDONLY, 0644)) == -1) {
TRACE_ERROR("error opening \"%s\": errno %i\n", FileName, errno);
iscsi_trace_error("error opening \"%s\": errno %i\n", FileName, errno);
goto read_done;
}
if ((read_data = iscsi_malloc_atomic(osd_args.length)) == NULL) {
TRACE_ERROR("iscsi_malloc_atomic() failed\n");
iscsi_trace_error("iscsi_malloc_atomic() failed\n");
goto read_done;
}
if (lseek(rc, osd_args.offset, SEEK_SET) == -1) {
TRACE_ERROR("error seeking \"%s\": errno %i\n", FileName, errno);
iscsi_trace_error("error seeking \"%s\": errno %i\n", FileName, errno);
goto read_done;
}
if (read(rc, read_data, osd_args.length) != osd_args.length) {
TRACE_ERROR("read() failed\n");
iscsi_trace_error("read() failed\n");
goto read_done;
}
close(rc);
@ -436,7 +436,7 @@ read_done:
break;
case OSD_GET_ATTR:
TRACE(TRACE_OSD, "OSD_GET_ATTR(lun %llu, GroupID 0x%x, UserID 0x%llx)\n",
iscsi_trace(TRACE_OSD, "OSD_GET_ATTR(lun %llu, GroupID 0x%x, UserID 0x%llx)\n",
args->lun, osd_args.GroupID, osd_args.UserID);
args->status = 0;
break;
@ -455,7 +455,7 @@ read_done:
if (osd_args.get_attributes_list_length || osd_args.get_attributes_page) {
if ((get_data = iscsi_malloc_atomic(osd_args.get_attributes_allocation_length)) == NULL) {
TRACE_ERROR("iscsi_malloc_atomic() failed\n");
iscsi_trace_error("iscsi_malloc_atomic() failed\n");
goto done;
}
}
@ -467,7 +467,7 @@ read_done:
i += 4;
index = ISCSI_NTOHL(*((uint32_t *) (&(get_list[i]))));
i += 4;
TRACE(TRACE_OSD, "GET(0x%x,%u)\n", page, index);
iscsi_trace(TRACE_OSD, "GET(0x%x,%u)\n", page, index);
switch (page) {
case 0x40000001:
@ -483,7 +483,7 @@ read_done:
attr_len += 4;
break;
default:
TRACE_ERROR("unknown attr index %u\n", index);
iscsi_trace_error("unknown attr index %u\n", index);
goto done;
}
break;
@ -510,7 +510,7 @@ read_done:
attr_len += 8;
break;
default:
TRACE_ERROR("unknown attr index %u\n", index);
iscsi_trace_error("unknown attr index %u\n", index);
goto done;
}
break;
@ -529,23 +529,23 @@ read_done:
sprintf(FileName, "%s/lun_%llu/0x%x/0x%llx.0x%x.%u",
base_dir, args->lun, osd_args.GroupID, osd_args.UserID, page, index);
if ((rc = open(FileName, O_RDONLY, 0644)) == -1) {
TRACE_ERROR("error opening \"%s\": errno %i\n", FileName, errno);
iscsi_trace_error("error opening \"%s\": errno %i\n", FileName, errno);
}
if (read(rc, get_data + attr_len, 480) != 480) {
TRACE_ERROR("read() failed\n");
iscsi_trace_error("read() failed\n");
goto done;
}
close(rc);
attr_len += 480;
break;
default:
TRACE_ERROR("unknown vendor attr index %u\n", index);
iscsi_trace_error("unknown vendor attr index %u\n", index);
goto done;
}
break;
default:
TRACE_ERROR("unknown page 0x%x\n", page);
iscsi_trace_error("unknown page 0x%x\n", page);
goto done;
}
}
@ -595,23 +595,23 @@ read_done:
sprintf(FileName, "%s/lun_%llu/0x%x/0x%llx.0x%x.%u",
base_dir, args->lun, osd_args.GroupID, osd_args.UserID, page, index);
if ((rc = open(FileName, O_RDONLY, 0644)) == -1) {
TRACE_ERROR("error opening \"%s\": errno %i\n", FileName, errno);
iscsi_trace_error("error opening \"%s\": errno %i\n", FileName, errno);
}
if (read(rc, get_data + attr_len, 480) != 480) {
TRACE_ERROR("read() failed\n");
iscsi_trace_error("read() failed\n");
goto done;
}
close(rc);
attr_len += 480;
break;
default:
TRACE_ERROR("page not yet supported\n");
iscsi_trace_error("page not yet supported\n");
goto done;
}
}
if (attr_len) {
if (attr_len != osd_args.get_attributes_allocation_length) {
TRACE_ERROR("allocation lengths differ: got %u, expected %u\n",
iscsi_trace_error("allocation lengths differ: got %u, expected %u\n",
osd_args.get_attributes_allocation_length, attr_len);
goto done;
}
@ -634,14 +634,14 @@ read_done:
break;
default:
TRACE_ERROR("UNKNOWN OPCODE 0x%x\n", args->cdb[0]);
iscsi_trace_error("UNKNOWN OPCODE 0x%x\n", args->cdb[0]);
args->status = 0x01;
break;
}
done:
TRACE(TRACE_SCSI_DEBUG, "SCSI op 0x%x: done (status 0x%x)\n", args->cdb[0], args->status);
iscsi_trace(TRACE_SCSI_DEBUG, "SCSI op 0x%x: done (status 0x%x)\n", args->cdb[0], args->status);
if (set_list) {
iscsi_free_atomic(set_list);
}

52
dist/iscsi/src/osd_ops.c vendored
View File

@ -47,25 +47,25 @@ extract_attribute(uint32_t page, uint32_t n, uint16_t len,
for (i = 0; i < length;) {
if (ISCSI_NTOHL(*(uint32_t *) (data + i)) != page) {
TRACE_ERROR("page mismatch: got 0x%x, expected 0x%x\n", ISCSI_NTOHL(*(uint32_t *) (data + i)), page);
iscsi_trace_error("page mismatch: got 0x%x, expected 0x%x\n", ISCSI_NTOHL(*(uint32_t *) (data + i)), page);
return -1;
}
i += 4;
if (ISCSI_NTOHL(*(uint32_t *) (data + i)) != n) {
TRACE_ERROR("index mismatch\n");
iscsi_trace_error("index mismatch\n");
return -1;
}
i += 4;
if (ISCSI_NTOHS(*(uint16_t *) (data + i)) != len) {
TRACE_ERROR("len mismatch\n");
iscsi_trace_error("len mismatch\n");
return -1;
}
i += 2;
TRACE(TRACE_DEBUG, "page 0x%x, index %u, len %u\n", page, n, len);
iscsi_trace(TRACE_DEBUG, "page 0x%x, index %u, len %u\n", page, n, len);
memcpy(val, data + i, len);
i += len;
}
TRACE(TRACE_DEBUG, "parsed %i bytes\n", i);
iscsi_trace(TRACE_DEBUG, "parsed %i bytes\n", i);
return i;
}
@ -107,15 +107,15 @@ osd_create_group(void *dev,
args.get_attributes_allocation_length = 14;
if (osd_exec(dev, &args, &mem) != 0) {
TRACE_ERROR("osd_exec() failed\n");
iscsi_trace_error("osd_exec() failed\n");
return -1;
}
if (extract_attribute(0x40000001, 0x1, 4, get_data, 14, GroupID) == -1) {
TRACE_ERROR("extract_attributes() failed\n");
iscsi_trace_error("extract_attributes() failed\n");
return -1;
}
*GroupID = ISCSI_NTOHL(*GroupID);
TRACE(TRACE_OSD, "osd_create_group() OK --> GroupID 0x%x\n", *GroupID);
iscsi_trace(TRACE_OSD, "osd_create_group() OK --> GroupID 0x%x\n", *GroupID);
return 0;
}
@ -158,15 +158,15 @@ osd_create(void *dev, uint32_t GroupID,
args.get_attributes_allocation_length = 18;
if (osd_exec(dev, &args, &mem) != 0) {
TRACE_ERROR("osd_exec() failed\n");
iscsi_trace_error("osd_exec() failed\n");
return -1;
}
if (extract_attribute(0x00000001, 0x2, 8, get_data, 18, UserID) == -1) {
TRACE_ERROR("extract_attributes() failed\n");
iscsi_trace_error("extract_attributes() failed\n");
return -1;
}
*UserID = ISCSI_NTOHLL(*UserID);
TRACE(TRACE_OSD, "osd_create(GroupID 0x%x) OK --> UserID 0x%llx\n", GroupID, *UserID);
iscsi_trace(TRACE_OSD, "osd_create(GroupID 0x%x) OK --> UserID 0x%llx\n", GroupID, *UserID);
return 0;
}
@ -190,10 +190,10 @@ osd_remove_group(void *dev, uint32_t GroupID,
args.service_action = OSD_REMOVE_GROUP;
args.GroupID = GroupID;
if (osd_exec(dev, &args, &mem) != 0) {
TRACE_ERROR("osd_exec() failed\n");
iscsi_trace_error("osd_exec() failed\n");
return -1;
}
TRACE(TRACE_OSD, "osd_remove_group(Group ID 0x%x) OK\n", GroupID);
iscsi_trace(TRACE_OSD, "osd_remove_group(Group ID 0x%x) OK\n", GroupID);
return 0;
}
@ -218,10 +218,10 @@ osd_remove(void *dev, uint32_t GroupID, uint64_t UserID,
args.UserID = UserID;
args.GroupID = GroupID;
if (osd_exec(dev, &args, &mem) != 0) {
TRACE_ERROR("osd_exec() failed\n");
iscsi_trace_error("osd_exec() failed\n");
return -1;
}
TRACE(TRACE_OSD, "osd_remove(GroupID 0x%x, UserID 0x%llx) OK\n", GroupID, UserID);
iscsi_trace(TRACE_OSD, "osd_remove(GroupID 0x%x, UserID 0x%llx) OK\n", GroupID, UserID);
return 0;
}
@ -234,7 +234,7 @@ osd_write(void *dev,
osd_args_t args;
OSD_OPS_MEM mem;
TRACE(TRACE_OSD, "osd_write(GroupID 0x%x, UserID 0x%llx, Offset %llu, Len %llu)\n", GroupID, UserID, offset, len);
iscsi_trace(TRACE_OSD, "osd_write(GroupID 0x%x, UserID 0x%llx, Offset %llu, Len %llu)\n", GroupID, UserID, offset, len);
mem.send_data = send_data;
mem.send_len = len;
mem.send_sg = sg_len;
@ -249,7 +249,7 @@ osd_write(void *dev,
args.offset = offset;
args.length = len;
if (osd_exec(dev, &args, &mem) != 0) {
TRACE_ERROR("osd_exec() failed\n");
iscsi_trace_error("osd_exec() failed\n");
return -1;
}
return 0;
@ -263,7 +263,7 @@ osd_read(void *dev,
osd_args_t args;
OSD_OPS_MEM mem;
TRACE(TRACE_OSD, "osd_read(GroupID 0x%x, UserID 0x%llx, Offset %llu, Len %llu)\n", GroupID, UserID, offset, len);
iscsi_trace(TRACE_OSD, "osd_read(GroupID 0x%x, UserID 0x%llx, Offset %llu, Len %llu)\n", GroupID, UserID, offset, len);
mem.send_data = NULL;
mem.send_len = 0;
mem.send_sg = 0;
@ -278,7 +278,7 @@ osd_read(void *dev,
args.offset = offset;
args.length = len;
if (osd_exec(dev, &args, &mem) != 0) {
TRACE_ERROR("osd_exec() failed\n");
iscsi_trace_error("osd_exec() failed\n");
return -1;
}
return 0;
@ -298,7 +298,7 @@ osd_set_one_attr(void *dev,
uint8_t *buffer = NULL;
#endif
TRACE(TRACE_OSD, "osd_set_one_attr(GroupID 0x%x, UserID 0x%llx, Page 0x%x, Index %u, Len %u)\n",
iscsi_trace(TRACE_OSD, "osd_set_one_attr(GroupID 0x%x, UserID 0x%llx, Page 0x%x, Index %u, Len %u)\n",
GroupID, UserID, page, n, len);
memset(&args, 0, sizeof(osd_args_t));
args.opcode = 0x7F;
@ -320,7 +320,7 @@ osd_set_one_attr(void *dev,
mem.send_sg = 2;
#else
if ((buffer = iscsi_malloc_atomic(10 + len)) == NULL) {
TRACE_ERROR("iscsi_malloc() failed\n");
iscsi_trace_error("iscsi_malloc() failed\n");
return -1;
}
memcpy(buffer, list, 10);
@ -334,7 +334,7 @@ osd_set_one_attr(void *dev,
mem.recv_sg = 0;
if (osd_exec(dev, &args, &mem) != 0) {
TRACE_ERROR("osd_exec() failed\n");
iscsi_trace_error("osd_exec() failed\n");
return -1;
}
if (buffer)
@ -359,7 +359,7 @@ osd_get_one_attr(void *dev,
uint8_t *buffer;
#endif
TRACE(TRACE_OSD, "osd_get_one_attr(GroupID 0x%x, UserID 0x%llx, Page 0x%x, Index %u, Alloc Len %u)\n",
iscsi_trace(TRACE_OSD, "osd_get_one_attr(GroupID 0x%x, UserID 0x%llx, Page 0x%x, Index %u, Alloc Len %u)\n",
GroupID, UserID, page, n, alloc_len);
memset(&args, 0, sizeof(osd_args_t));
args.opcode = 0x7F;
@ -375,7 +375,7 @@ osd_get_one_attr(void *dev,
mem.send_len = 8;
mem.send_sg = 0;
} else {
TRACE(TRACE_OSD, "requesting entire page or reference page\n");
iscsi_trace(TRACE_OSD, "requesting entire page or reference page\n");
mem.send_data = NULL;
mem.send_len = 0;
mem.send_sg = 0;
@ -391,7 +391,7 @@ osd_get_one_attr(void *dev,
mem.recv_sg = 2;
#else
if ((buffer = iscsi_malloc_atomic(10 + alloc_len)) == NULL) {
TRACE_ERROR("iscsi_malloc() failed\n");
iscsi_trace_error("iscsi_malloc() failed\n");
return -1;
}
mem.recv_data = buffer;
@ -400,7 +400,7 @@ osd_get_one_attr(void *dev,
#endif
args.get_attributes_allocation_length = 10 + alloc_len;
if (osd_exec(dev, &args, &mem) != 0) {
TRACE_ERROR("osd_exec() failed\n");
iscsi_trace_error("osd_exec() failed\n");
return -1;
}
memcpy(value, buffer + 10, alloc_len);

206
dist/iscsi/src/osdfs.c vendored
View File

@ -117,7 +117,7 @@ int osd_exec_via_scsi(void *dev, osd_args_t *args, OSD_OPS_MEM *m) {
int len = 0;
if (m->send_sg||m->recv_sg) {
TRACE_ERROR("scatter/gather not yet implemented!\n");
iscsi_trace_error("scatter/gather not yet implemented!\n");
return -1;
}
@ -146,7 +146,7 @@ int osd_exec_via_scsi(void *dev, osd_args_t *args, OSD_OPS_MEM *m) {
SRpnt->sr_data_direction = 0;
break;
default:
TRACE_ERROR("unsupported OSD service action 0x%x\n", args->service_action);
iscsi_trace_error("unsupported OSD service action 0x%x\n", args->service_action);
return -1;
}
OSD_ENCAP_CDB(args, cdb);
@ -155,7 +155,7 @@ int osd_exec_via_scsi(void *dev, osd_args_t *args, OSD_OPS_MEM *m) {
scsi_wait_req(SRpnt, cdb, ptr, len, 5*HZ, 5);
if (SRpnt->sr_result!=0) {
TRACE_ERROR("SCSI command failed (result %u)\n", SRpnt->sr_result);
iscsi_trace_error("SCSI command failed (result %u)\n", SRpnt->sr_result);
scsi_release_request(SRpnt);
SRpnt = NULL;
return -1;
@ -178,7 +178,7 @@ static int entries_get(kdev_t dev, uint64_t uid, char **entries, uint32_t *num,
uint16_t len;
if (osd_get_one_attr((void *)&dev, root_gid, uid, 0x30000000, 0x0, sizeof(struct inode), &osd_exec_via_scsi, &len, (void *) &inode)!=0) {
TRACE_ERROR("osd_get_one_attr() failed\n");
iscsi_trace_error("osd_get_one_attr() failed\n");
return -1;
}
*num = 0;
@ -187,11 +187,11 @@ static int entries_get(kdev_t dev, uint64_t uid, char **entries, uint32_t *num,
int n = 0;
if ((*entries=vmalloc(*size+1))==NULL) {
TRACE_ERROR("vmalloc() failed\n");
iscsi_trace_error("vmalloc() failed\n");
return -1;
}
if (osd_read((void *)&dev, root_gid, uid, 0, *size, *entries, 0, &osd_exec_via_scsi)!=0) {
TRACE_ERROR("osd_read() failed\n");
iscsi_trace_error("osd_read() failed\n");
vfree(*entries);
return -1;
}
@ -202,12 +202,12 @@ static int entries_get(kdev_t dev, uint64_t uid, char **entries, uint32_t *num,
if ((ptr2=strchr(ptr, '\n'))!=NULL) {
n++;
if ((ptr2 = strchr(ptr2+1, '\n'))==NULL) {
TRACE_ERROR("directory 0x%llx corrupted (line %i)\n", uid, n);
iscsi_trace_error("directory 0x%llx corrupted (line %i)\n", uid, n);
return -1;
}
(*num)++;
} else {
TRACE_ERROR("directory 0x%llx corrupted (line %i)\n", uid, n);
iscsi_trace_error("directory 0x%llx corrupted (line %i)\n", uid, n);
return -1;
}
ptr = ptr2+1;
@ -227,7 +227,7 @@ static int entry_add(kdev_t dev, ino_t dir_ino, ino_t entry_ino,
/* Get size of directory */
if (osd_get_one_attr((void *)&dev, root_gid, uid, 0x30000000, 0x0, sizeof(struct inode), &osd_exec_via_scsi, &len, (void *) &inode)!=0) {
TRACE_ERROR("osd_get_one_attr() failed\n");
iscsi_trace_error("osd_get_one_attr() failed\n");
return -1;
}
@ -236,7 +236,7 @@ static int entry_add(kdev_t dev, ino_t dir_ino, ino_t entry_ino,
sprintf(entry, "%s\n", name);
sprintf(entry+strlen(entry), "%li\n", entry_ino);
if (osd_write((void *)&dev, root_gid, uid, inode.i_size, strlen(entry), entry, 0, &osd_exec_via_scsi)!=0) {
TRACE_ERROR("osd_write() failed\n");
iscsi_trace_error("osd_write() failed\n");
return -1;
}
*new_size += strlen(entry);
@ -253,12 +253,12 @@ static int entry_del(kdev_t dev, ino_t dir_ino, ino_t ino, const char *name, uin
/* Read */
if (entries_get(dev, dir_ino, &entries, &num_entries, &size)!=0) {
TRACE_ERROR("entries_get() failed\n");
iscsi_trace_error("entries_get() failed\n");
return -1;
}
entries[size] = 0x0;
TRACE(TRACE_OSDFS, "dir_ino 0x%llx has %u entries\n", dir_uid, num_entries);
iscsi_trace(TRACE_OSDFS, "dir_ino 0x%llx has %u entries\n", dir_uid, num_entries);
if (num_entries) {
char *ptr = entries;
char *tmp = NULL;
@ -268,7 +268,7 @@ static int entry_del(kdev_t dev, ino_t dir_ino, ino_t ino, const char *name, uin
do {
n++;
if ((nl=strchr(ptr, '\n'))==NULL) {
TRACE_ERROR("directory 0x%llx corrupted (line %i)\n", dir_uid, n);
iscsi_trace_error("directory 0x%llx corrupted (line %i)\n", dir_uid, n);
return -1;
}
*nl = 0x0;
@ -278,28 +278,28 @@ static int entry_del(kdev_t dev, ino_t dir_ino, ino_t ino, const char *name, uin
*nl = '\n';
n++;
if ((ptr=strchr(nl+1, '\n'))==NULL) {
TRACE_ERROR("directory 0x%llx corrupted (line %i)\n", dir_uid, n);
iscsi_trace_error("directory 0x%llx corrupted (line %i)\n", dir_uid, n);
return -1;
}
ptr++;
} while (!tmp && *ptr);
if (!tmp) {
TRACE_ERROR("entry \"%s\" not found in dir 0x%llx\n", name, dir_uid);
iscsi_trace_error("entry \"%s\" not found in dir 0x%llx\n", name, dir_uid);
return -1;
}
if (entries+size-ptr) {
TRACE(TRACE_OSDFS, "writing remaining %u directory bytes at offset %u\n",
iscsi_trace(TRACE_OSDFS, "writing remaining %u directory bytes at offset %u\n",
entries+size-ptr, tmp-entries);
if (osd_write((void *)&dev, root_gid, dir_uid, tmp-entries, entries+size-ptr, ptr, 0, &osd_exec_via_scsi)!=0) {
TRACE_ERROR("osd_write() failed\n");
iscsi_trace_error("osd_write() failed\n");
return -1;
}
}
*new_size = size-(ptr-tmp);
vfree(entries);
} else {
TRACE_ERROR("dir 0x%llx has no entries\n", dir_uid);
iscsi_trace_error("dir 0x%llx has no entries\n", dir_uid);
return -1;
}
@ -312,10 +312,10 @@ static int entry_num(kdev_t dev, ino_t ino) {
uint64_t size;
if (entries_get(dev, ino, &entries, &num_entries, &size)!=0) {
TRACE_ERROR("entries_get() failed\n");
iscsi_trace_error("entries_get() failed\n");
return -1;
}
TRACE(TRACE_OSDFS, "ino %li has %i entries\n", ino, num_entries);
iscsi_trace(TRACE_OSDFS, "ino %li has %i entries\n", ino, num_entries);
if (num_entries) vfree(entries);
return num_entries;
}
@ -335,7 +335,7 @@ static void osdfs_set_ops(struct inode *inode) {
inode->i_op = &page_symlink_inode_operations;
break;
default:
TRACE_ERROR("UNKNOWN MODE\n");
iscsi_trace_error("UNKNOWN MODE\n");
}
inode->i_mapping->a_ops = &osdfs_aops;
}
@ -345,14 +345,14 @@ static struct inode *osdfs_get_inode(struct super_block *sb, int mode, int dev,
struct inode *inode;
ino_t ino = ObjectID;
TRACE(TRACE_OSDFS, "osdfs_get_inode(\"%s\", mode %i (%s))\n", name, mode,
iscsi_trace(TRACE_OSDFS, "osdfs_get_inode(\"%s\", mode %i (%s))\n", name, mode,
S_ISDIR(mode)?"DIR":(S_ISREG(mode)?"REG":"LNK"));
/* iget() gets a free VFS inode and subsequently call */
/* osdfds_read_inode() to fill the inode structure. */
if ((inode=iget(sb, ino))==NULL) {
TRACE_ERROR("iget() failed\n");
iscsi_trace_error("iget() failed\n");
return NULL;
}
@ -372,16 +372,16 @@ static void osdfs_read_inode(struct inode *inode) {
unsigned char *attr;
uint16_t len;
TRACE(TRACE_OSDFS, "osdfs_read_inode(ino 0x%x, major %i, minor %i)\n",
iscsi_trace(TRACE_OSDFS, "osdfs_read_inode(ino 0x%x, major %i, minor %i)\n",
(unsigned) ino, MAJOR(dev), MINOR(dev));
/* Get object attributes for rest of inode */
if ((attr=iscsi_malloc_atomic(sizeof(struct inode)))==NULL) {
TRACE_ERROR("iscsi_malloc_atomic() failed\n");
iscsi_trace_error("iscsi_malloc_atomic() failed\n");
}
if (osd_get_one_attr((void *)&dev, root_gid, uid, 0x30000000, 0x0, sizeof(struct inode), &osd_exec_via_scsi, &len, attr)!=0) {
TRACE_ERROR("osd_get_one_attr() failed\n");
iscsi_trace_error("osd_get_one_attr() failed\n");
return;
}
@ -400,7 +400,7 @@ static void osdfs_read_inode(struct inode *inode) {
}
void osdfs_dirty_inode(struct inode *inode) {
TRACE(TRACE_OSDFS, "osdfs_dirty_inode(ino 0x%x)\n", (unsigned) inode->i_ino);
iscsi_trace(TRACE_OSDFS, "osdfs_dirty_inode(ino 0x%x)\n", (unsigned) inode->i_ino);
}
void osdfs_write_inode(struct inode *inode, int sync) {
@ -408,41 +408,41 @@ void osdfs_write_inode(struct inode *inode, int sync) {
kdev_t dev = inode->i_sb->s_dev;
uint64_t uid = ino;
TRACE(TRACE_OSDFS, "osdfs_write_inode(0x%llx)\n", uid);
iscsi_trace(TRACE_OSDFS, "osdfs_write_inode(0x%llx)\n", uid);
if (osd_set_one_attr((void *)&dev, root_gid, uid, 0x30000000, 0x1, sizeof(struct inode), (void *) inode, &osd_exec_via_scsi)!=0) {
TRACE_ERROR("osd_set_one_attr() failed\n");
iscsi_trace_error("osd_set_one_attr() failed\n");
}
inode->i_state &= ~I_DIRTY;
}
void osdfs_put_inode(struct inode *inode) {
TRACE(TRACE_OSDFS, "osdfs_put_inode(0x%x)\n", (unsigned) inode->i_ino);
iscsi_trace(TRACE_OSDFS, "osdfs_put_inode(0x%x)\n", (unsigned) inode->i_ino);
}
void osdfs_delete_inode(struct inode *inode) {
TRACE(TRACE_OSDFS, "osdfs_delete_inode(%lu)\n", inode->i_ino);
iscsi_trace(TRACE_OSDFS, "osdfs_delete_inode(%lu)\n", inode->i_ino);
clear_inode(inode);
}
void osdfs_put_super(struct super_block *sb) {
TRACE_ERROR("osdfs_put_super() not implemented\n");
iscsi_trace_error("osdfs_put_super() not implemented\n");
}
void osdfs_write_super(struct super_block *sb) {
TRACE_ERROR("osdfs_write_super() not implemented\n");
iscsi_trace_error("osdfs_write_super() not implemented\n");
}
void osdfs_write_super_lockfs(struct super_block *sb) {
TRACE_ERROR("osdfs_write_super_lockfs() not implemented\n");
iscsi_trace_error("osdfs_write_super_lockfs() not implemented\n");
}
void osdfs_unlockfs(struct super_block *sb) {
TRACE_ERROR("osdfs_unlockfs() not implemented\n");
iscsi_trace_error("osdfs_unlockfs() not implemented\n");
}
int osdfs_statfs(struct super_block *sb, struct statfs *buff) {
TRACE(TRACE_OSDFS, "statfs()\n");
iscsi_trace(TRACE_OSDFS, "statfs()\n");
buff->f_type = OSDFS_MAGIC;
buff->f_bsize = PAGE_CACHE_SIZE;
buff->f_blocks = 256;
@ -456,17 +456,17 @@ int osdfs_statfs(struct super_block *sb, struct statfs *buff) {
}
int osdfs_remount_fs(struct super_block *sb, int *i, char *c) {
TRACE_ERROR("osdfs_remount_fs() not implemented\n");
iscsi_trace_error("osdfs_remount_fs() not implemented\n");
return -1;
}
void osdfs_clear_inode(struct inode *inode) {
TRACE(TRACE_OSDFS, "osdfs_clear_inode(ino %lu)\n", inode->i_ino);
iscsi_trace(TRACE_OSDFS, "osdfs_clear_inode(ino %lu)\n", inode->i_ino);
}
void osdfs_umount_begin(struct super_block *sb) {
TRACE_ERROR("osdfs_unmount_begin() not implemented\n");
iscsi_trace_error("osdfs_unmount_begin() not implemented\n");
}
static struct super_operations osdfs_ops = {
@ -493,12 +493,12 @@ static struct super_operations osdfs_ops = {
static int osdfs_create(struct inode *dir, struct dentry *dentry, int mode) {
TRACE(TRACE_OSDFS, "osdfs_create(\"%s\")\n", dentry->d_name.name);
iscsi_trace(TRACE_OSDFS, "osdfs_create(\"%s\")\n", dentry->d_name.name);
if (osdfs_mknod(dir, dentry, mode | S_IFREG, 0)!=0) {
TRACE_ERROR("osdfs_mknod() failed\n");
iscsi_trace_error("osdfs_mknod() failed\n");
return -1;
}
TRACE(TRACE_OSDFS, "file \"%s\" is inode 0x%x\n", dentry->d_name.name, (unsigned) dentry->d_inode->i_ino);
iscsi_trace(TRACE_OSDFS, "file \"%s\" is inode 0x%x\n", dentry->d_name.name, (unsigned) dentry->d_inode->i_ino);
return 0;
}
@ -513,18 +513,18 @@ static struct dentry * osdfs_lookup(struct inode *dir, struct dentry *dentry) {
uint32_t num_entries;
uint64_t size;
TRACE(TRACE_OSDFS, "osdfs_lookup(\"%s\" in dir ino %lu)\n", name, dir->i_ino);
iscsi_trace(TRACE_OSDFS, "osdfs_lookup(\"%s\" in dir ino %lu)\n", name, dir->i_ino);
/* Get directory entries */
ISCSI_LOCK(&g_mutex, return NULL);
if (entries_get(dev, uid, &entries, &num_entries, &size)!=0) {
TRACE_ERROR("entries_get() failed\n");
iscsi_trace_error("entries_get() failed\n");
ISCSI_UNLOCK(&g_mutex, return NULL);
return NULL;
}
ISCSI_UNLOCK(&g_mutex, return NULL);
TRACE(TRACE_OSDFS, "ino %li has %i entries\n", dir->i_ino, num_entries);
iscsi_trace(TRACE_OSDFS, "ino %li has %i entries\n", dir->i_ino, num_entries);
/* Search for this entry */
@ -538,9 +538,9 @@ static struct dentry * osdfs_lookup(struct inode *dir, struct dentry *dentry) {
ptr2 = strchr(ptr2+1, '\n');
if (!strcmp(ptr, name)) {
sscanf(ptr+strlen(ptr)+1, "%li", &ino);
TRACE(TRACE_OSDFS, "found \"%s\" at ino %li\n", name, ino);
iscsi_trace(TRACE_OSDFS, "found \"%s\" at ino %li\n", name, ino);
if ((inode=iget(dir->i_sb, ino))==NULL) {
TRACE_ERROR("iget() failed\n");
iscsi_trace_error("iget() failed\n");
return NULL;
}
}
@ -549,7 +549,7 @@ static struct dentry * osdfs_lookup(struct inode *dir, struct dentry *dentry) {
vfree(entries);
}
if (!inode) {
TRACE(TRACE_OSDFS, "\"%s\" not found\n", name);
iscsi_trace(TRACE_OSDFS, "\"%s\" not found\n", name);
}
d_add(dentry, inode);
@ -564,10 +564,10 @@ static int osdfs_link(struct dentry *old_dentry, struct inode * dir, struct dent
const char *name = dentry->d_name.name;
if (S_ISDIR(inode->i_mode)) return -EPERM;
TRACE(TRACE_OSDFS, "osdfs_link(%lu, \"%s\")\n", ino, name);
iscsi_trace(TRACE_OSDFS, "osdfs_link(%lu, \"%s\")\n", ino, name);
ISCSI_LOCK(&g_mutex, return -1);
if (entry_add(dev, dir_ino, ino, name, &dir->i_size)!=0) {
TRACE_ERROR("entry_add() failed\n");
iscsi_trace_error("entry_add() failed\n");
return -1;
}
inode->i_nlink++;
@ -587,7 +587,7 @@ static int osdfs_unlink(struct inode * dir, struct dentry *dentry) {
ino_t ino = dentry->d_inode->i_ino;
const char *name = dentry->d_name.name;
TRACE(TRACE_OSDFS, "osdfs_unlink(\"%s\", ino 0x%x)\n", name, (unsigned) ino);
iscsi_trace(TRACE_OSDFS, "osdfs_unlink(\"%s\", ino 0x%x)\n", name, (unsigned) ino);
ISCSI_LOCK(&g_mutex, return -1);
switch (inode->i_mode & S_IFMT) {
case S_IFREG:
@ -595,25 +595,25 @@ static int osdfs_unlink(struct inode * dir, struct dentry *dentry) {
break;
case S_IFDIR:
if (entry_num(dev, ino)) {
TRACE_ERROR("directory 0x%x still has %i entries\n",
iscsi_trace_error("directory 0x%x still has %i entries\n",
(unsigned) ino, entry_num(dev, ino));
ISCSI_UNLOCK(&g_mutex, return -1);
return -ENOTEMPTY;
}
}
if (entry_del(dev, dir_ino, ino, name, &(dir->i_size))!=0) {
TRACE_ERROR("entry_del() failed\n");
iscsi_trace_error("entry_del() failed\n");
ISCSI_UNLOCK(&g_mutex, return -1);
return -1;
}
osdfs_write_inode(dir, 0);
if (--inode->i_nlink) {
TRACE(TRACE_OSDFS, "ino 0x%x still has %i links\n", (unsigned) ino, inode->i_nlink);
iscsi_trace(TRACE_OSDFS, "ino 0x%x still has %i links\n", (unsigned) ino, inode->i_nlink);
osdfs_write_inode(inode, 0);
} else {
TRACE(TRACE_OSDFS, "ino 0x%x link count reached 0, removing object\n", (unsigned) ino);
iscsi_trace(TRACE_OSDFS, "ino 0x%x link count reached 0, removing object\n", (unsigned) ino);
if (osd_remove((void *)&dev, root_gid, ino, &osd_exec_via_scsi)!=0) {
TRACE_ERROR("osd_remove() failed\n");
iscsi_trace_error("osd_remove() failed\n");
return -1;
}
}
@ -625,26 +625,26 @@ static int osdfs_unlink(struct inode * dir, struct dentry *dentry) {
static int osdfs_symlink(struct inode * dir, struct dentry *dentry, const char * symname) {
struct inode *inode;
TRACE(TRACE_OSDFS, "osdfs_symlink(\"%s\"->\"%s\")\n", dentry->d_name.name, symname);
iscsi_trace(TRACE_OSDFS, "osdfs_symlink(\"%s\"->\"%s\")\n", dentry->d_name.name, symname);
if (osdfs_mknod(dir, dentry, S_IRWXUGO | S_IFLNK, 0)!=0) {
TRACE_ERROR("osdfs_mknod() failed\n");
iscsi_trace_error("osdfs_mknod() failed\n");
return -1;
}
inode = dentry->d_inode;
if (block_symlink(inode, symname, strlen(symname)+1)!=0) {
TRACE_ERROR("block_symlink() failed\n");
iscsi_trace_error("block_symlink() failed\n");
return -1;
}
TRACE(TRACE_OSDFS, "symbolic link \"%s\" is inode %lu\n", dentry->d_name.name, inode->i_ino);
iscsi_trace(TRACE_OSDFS, "symbolic link \"%s\" is inode %lu\n", dentry->d_name.name, inode->i_ino);
return 0;
}
static int osdfs_mkdir(struct inode * dir, struct dentry * dentry, int mode) {
TRACE(TRACE_OSDFS, "osdfs_mkdir(\"%s\")\n", dentry->d_name.name);
iscsi_trace(TRACE_OSDFS, "osdfs_mkdir(\"%s\")\n", dentry->d_name.name);
if (osdfs_mknod(dir, dentry, mode | S_IFDIR, 0)!=0) {
TRACE_ERROR("osdfs_mkdir() failed\n");
iscsi_trace_error("osdfs_mkdir() failed\n");
}
return 0;
@ -657,12 +657,12 @@ static int osdfs_mknod(struct inode *dir, struct dentry *dentry, int mode, int d
kdev_t dev = dir->i_sb->s_dev;
const char *name = dentry->d_name.name;
TRACE(TRACE_OSDFS, "osdfs_mknod(\"%s\")\n", dentry->d_name.name);
iscsi_trace(TRACE_OSDFS, "osdfs_mknod(\"%s\")\n", dentry->d_name.name);
/* Create object */
if (osd_create((void *)&dev, root_gid, &osd_exec_via_scsi, &uid)!=0) {
TRACE_ERROR("osd_create() failed\n");
iscsi_trace_error("osd_create() failed\n");
return -1;
}
@ -678,14 +678,14 @@ static int osdfs_mknod(struct inode *dir, struct dentry *dentry, int mode, int d
attr.i_nlink = 1;
if (osd_set_one_attr((void *)&dir->i_sb->s_dev, root_gid, uid, 0x30000000, 0x1, sizeof(struct inode),
&attr, &osd_exec_via_scsi)!=0) {
TRACE_ERROR("osd_set_one_attr() failed\n");
iscsi_trace_error("osd_set_one_attr() failed\n");
return -1;
}
/* Assign to an inode */
if ((inode = osdfs_get_inode(dir->i_sb, mode, dev, name, uid))==NULL) {
TRACE_ERROR("osdfs_get_inode() failed\n");
iscsi_trace_error("osdfs_get_inode() failed\n");
return -ENOSPC;
}
d_instantiate(dentry, inode);
@ -695,7 +695,7 @@ static int osdfs_mknod(struct inode *dir, struct dentry *dentry, int mode, int d
if (inode->i_ino != 1) {
ISCSI_LOCK(&g_mutex, return -1);
if (entry_add(dev, dir->i_ino, inode->i_ino, name, &dir->i_size)!=0) {
TRACE_ERROR("entry_add() failed\n");
iscsi_trace_error("entry_add() failed\n");
return -1;
}
osdfs_write_inode(dir, 0);
@ -714,10 +714,10 @@ static int osdfs_rename(struct inode *old_dir, struct dentry *old_dentry, struct
const char *old_name = old_dentry->d_name.name;
const char *new_name = new_dentry->d_name.name;
TRACE(TRACE_OSDFS, "old_dir = 0x%p (ino 0x%x)\n", old_dir, (unsigned) old_dir_ino);
TRACE(TRACE_OSDFS, "new_dir = 0x%p (ino 0x%x)\n", new_dir, (unsigned) new_dir_ino);
TRACE(TRACE_OSDFS, "old_dentry = 0x%p (ino 0x%x)\n", old_dentry, (unsigned) old_ino);
TRACE(TRACE_OSDFS, "new_dentry = 0x%p (ino 0x%x)\n", new_dentry, (unsigned) new_ino);
iscsi_trace(TRACE_OSDFS, "old_dir = 0x%p (ino 0x%x)\n", old_dir, (unsigned) old_dir_ino);
iscsi_trace(TRACE_OSDFS, "new_dir = 0x%p (ino 0x%x)\n", new_dir, (unsigned) new_dir_ino);
iscsi_trace(TRACE_OSDFS, "old_dentry = 0x%p (ino 0x%x)\n", old_dentry, (unsigned) old_ino);
iscsi_trace(TRACE_OSDFS, "new_dentry = 0x%p (ino 0x%x)\n", new_dentry, (unsigned) new_ino);
/*
* If we return -1, the VFS will implement a rename with a combination
@ -728,7 +728,7 @@ static int osdfs_rename(struct inode *old_dir, struct dentry *old_dentry, struct
ISCSI_LOCK(&g_mutex, return -1);
if (entry_del(dev, old_dir_ino, old_ino, old_name, &old_dir->i_size)!=0) {
TRACE_ERROR("error deleting old entry \"%s\"\n", old_name);
iscsi_trace_error("error deleting old entry \"%s\"\n", old_name);
ISCSI_UNLOCK(&g_mutex, return -1);
return -1;
}
@ -738,9 +738,9 @@ static int osdfs_rename(struct inode *old_dir, struct dentry *old_dentry, struct
/* Unlink entry from new directory */
if (new_dentry->d_inode) {
TRACE(TRACE_OSDFS, "unlinking existing file\n");
iscsi_trace(TRACE_OSDFS, "unlinking existing file\n");
if (osdfs_unlink(new_dir, new_dentry)!=0) {
TRACE_ERROR("osdfs_unlink() failed\n");
iscsi_trace_error("osdfs_unlink() failed\n");
return -1;
}
}
@ -749,7 +749,7 @@ static int osdfs_rename(struct inode *old_dir, struct dentry *old_dentry, struct
ISCSI_LOCK(&g_mutex, return -1);
if (entry_add(dev, new_dir_ino, new_ino, new_name, &new_dir->i_size)!=0) {
TRACE_ERROR("error adding new entry \"%s\"\n", new_name);
iscsi_trace_error("error adding new entry \"%s\"\n", new_name);
ISCSI_UNLOCK(&g_mutex, return -1);
return -1;
}
@ -778,7 +778,7 @@ static struct inode_operations osdfs_dir_inode_operations = {
static int osdfs_sync_file(struct file * file, struct dentry *dentry, int datasync) {
TRACE_ERROR("osdfs_syncfile() not implemented\n");
iscsi_trace_error("osdfs_syncfile() not implemented\n");
return -1;
}
@ -807,11 +807,11 @@ static int osdfs_readdir(struct file * filp, void * dirent, filldir_t filldir) {
uint64_t uid = ino;
name = dentry->d_name.name;
TRACE(TRACE_OSDFS, "osdfs_readdir(\"%s\", ino 0x%x, offset %i)\n",
iscsi_trace(TRACE_OSDFS, "osdfs_readdir(\"%s\", ino 0x%x, offset %i)\n",
name, (unsigned) ino, offset);
ISCSI_LOCK(&g_mutex, return -1);
if (entries_get(dev, uid, &entries, &num_entries, &size)!=0) {
TRACE_ERROR("entries_get() failed\n");
iscsi_trace_error("entries_get() failed\n");
ISCSI_UNLOCK(&g_mutex, return -1);
return -1;
}
@ -834,18 +834,18 @@ static int osdfs_readdir(struct file * filp, void * dirent, filldir_t filldir) {
case 0:
TRACE(TRACE_OSDFS, "adding \".\" (ino 0x%x)\n", (unsigned) ino);
iscsi_trace(TRACE_OSDFS, "adding \".\" (ino 0x%x)\n", (unsigned) ino);
if (filldir(dirent, ".", 1, filp->f_pos++, ino, DT_DIR) < 0) {
TRACE_ERROR("filldir() failed for \".\"??\n");
iscsi_trace_error("filldir() failed for \".\"??\n");
vfree(entries);
return -1;
}
case 1:
TRACE(TRACE_OSDFS, "adding \"..\" (ino 0x%x)\n", (unsigned) dentry->d_parent->d_inode->i_ino);
iscsi_trace(TRACE_OSDFS, "adding \"..\" (ino 0x%x)\n", (unsigned) dentry->d_parent->d_inode->i_ino);
if (filldir(dirent, "..", 2, filp->f_pos++, dentry->d_parent->d_inode->i_ino, DT_DIR) < 0) {
TRACE_ERROR("filldir() failed for \"..\"??\n");
iscsi_trace_error("filldir() failed for \"..\"??\n");
vfree(entries);
return -1;
}
@ -863,7 +863,7 @@ static int osdfs_readdir(struct file * filp, void * dirent, filldir_t filldir) {
offset--;
} else {
sscanf(ptr+strlen(ptr)+1, "%li", &ino);
TRACE(TRACE_OSDFS, "adding \"%s\" (ino 0x%x)\n", ptr, (unsigned) ino);
iscsi_trace(TRACE_OSDFS, "adding \"%s\" (ino 0x%x)\n", ptr, (unsigned) ino);
if (filldir(dirent, ptr, strlen(ptr), filp->f_pos++, ino, DT_UNKNOWN) < 0) {
vfree(entries);
return 0;
@ -898,7 +898,7 @@ static int osdfs_readpage(struct file *file, struct page * page) {
uint64_t len;
uint64_t uid = ino;
TRACE(TRACE_OSDFS, "osdfs_readpage(ino %lu, Offset %llu, Length %llu)\n", ino, Offset, Length);
iscsi_trace(TRACE_OSDFS, "osdfs_readpage(ino %lu, Offset %llu, Length %llu)\n", ino, Offset, Length);
if (Offset+Length>inode->i_size) {
len = inode->i_size-Offset;
} else {
@ -907,7 +907,7 @@ static int osdfs_readpage(struct file *file, struct page * page) {
if (!Page_Uptodate(page)) {
memset(kmap(page), 0, PAGE_CACHE_SIZE);
if (osd_read((void *)&dev, root_gid, uid, Offset, len, page->virtual, 0, &osd_exec_via_scsi)!=0) {
TRACE_ERROR("osd_read() failed\n");
iscsi_trace_error("osd_read() failed\n");
UnlockPage(page);
return -1;;
}
@ -915,7 +915,7 @@ static int osdfs_readpage(struct file *file, struct page * page) {
flush_dcache_page(page);
SetPageUptodate(page);
} else {
TRACE_ERROR("The page IS up to date???\n");
iscsi_trace_error("The page IS up to date???\n");
}
UnlockPage(page);
@ -923,7 +923,7 @@ static int osdfs_readpage(struct file *file, struct page * page) {
}
static int osdfs_prepare_write(struct file *file, struct page *page, unsigned offset, unsigned to) {
TRACE(TRACE_OSDFS, "osdfs_prepare_write(ino %lu, offset %u, to %u)\n", page->mapping->host->i_ino, offset, to);
iscsi_trace(TRACE_OSDFS, "osdfs_prepare_write(ino %lu, offset %u, to %u)\n", page->mapping->host->i_ino, offset, to);
return 0;
}
@ -935,10 +935,10 @@ static int osdfs_commit_write(struct file *file, struct page *page, unsigned off
ino_t ino = inode->i_ino;
uint64_t uid = ino;
TRACE(TRACE_OSDFS, "osdfs_commit_write(ino %lu, offset %u, to %u, Offset %llu, Length %llu)\n",
iscsi_trace(TRACE_OSDFS, "osdfs_commit_write(ino %lu, offset %u, to %u, Offset %llu, Length %llu)\n",
ino, offset, to, Offset, Length);
if (osd_write((void *)&dev, root_gid, uid, Offset, Length, page->virtual+offset, 0, &osd_exec_via_scsi)!=0) {
TRACE_ERROR("osd_write() failed\n");
iscsi_trace_error("osd_write() failed\n");
return -1;
}
if (Offset+Length>inode->i_size) {
@ -968,7 +968,7 @@ static struct super_block *osdfs_read_super(struct super_block *sb, void *data,
struct inode attr;
struct inode *inode;
TRACE(TRACE_OSDFS, "osdfs_read_super(major %i minor %i)\n", MAJOR(sb->s_dev), MINOR(sb->s_dev));
iscsi_trace(TRACE_OSDFS, "osdfs_read_super(major %i minor %i)\n", MAJOR(sb->s_dev), MINOR(sb->s_dev));
root_gid = root_uid = 0;
@ -986,16 +986,16 @@ static struct super_block *osdfs_read_super(struct super_block *sb, void *data,
}
if (!strncmp(opt, "uid=", 3)) {
if (sscanf(opt, "uid=0x%Lx", &root_uid)!=1) {
TRACE_ERROR("malformed option \"%s\"\n", opt);
iscsi_trace_error("malformed option \"%s\"\n", opt);
return NULL;
}
} else if (!strncmp(opt, "gid=", 3)) {
if (sscanf(opt, "gid=0x%x", &root_gid)!=1) {
TRACE_ERROR("malformed option \"%s\"\n", opt);
iscsi_trace_error("malformed option \"%s\"\n", opt);
return NULL;
}
} else {
TRACE_ERROR("unknown option \"%s\"\n", opt);
iscsi_trace_error("unknown option \"%s\"\n", opt);
return NULL;
}
}
@ -1012,39 +1012,39 @@ static struct super_block *osdfs_read_super(struct super_block *sb, void *data,
/* Create group object for root directory */
if (osd_create_group((void *)&sb->s_dev, &osd_exec_via_scsi, &root_gid)!=0) {
TRACE_ERROR("osd_create_group() failed\n");
iscsi_trace_error("osd_create_group() failed\n");
return NULL;
}
PRINT("** ROOT DIRECTORY GROUP OBJECT IS 0x%x **\n", root_gid);
printf("** ROOT DIRECTORY GROUP OBJECT IS 0x%x **\n", root_gid);
/* Create user object for root directory */
if (osd_create((void *)&sb->s_dev, root_gid, &osd_exec_via_scsi, &root_uid)!=0) {
TRACE_ERROR("osd_create() failed\n");
iscsi_trace_error("osd_create() failed\n");
return NULL;
}
PRINT("** ROOT DIRECTORY USER OBJECT IS 0x%llx **\n", root_uid);
printf("** ROOT DIRECTORY USER OBJECT IS 0x%llx **\n", root_uid);
/* Initialize Attributes */
memset(&attr, 0, sizeof(struct inode));
attr.i_mode = S_IFDIR | 0755;
if (osd_set_one_attr((void *)&sb->s_dev, root_gid, root_uid, 0x30000000, 0x1, sizeof(struct inode), (void *) &attr, &osd_exec_via_scsi)!=0) {
TRACE_ERROR("osd_set_one_attr() failed\n");
iscsi_trace_error("osd_set_one_attr() failed\n");
return NULL;
}
} else {
TRACE(TRACE_OSDFS, "using root directory in 0x%x:0x%llx\n", root_gid, root_uid);
iscsi_trace(TRACE_OSDFS, "using root directory in 0x%x:0x%llx\n", root_gid, root_uid);
}
/* Create inode for root directory */
if ((inode=osdfs_get_inode(sb, S_IFDIR | 0755, 0, "/", root_uid))==NULL) {
TRACE_ERROR("osdfs_get_inode() failed\n");
iscsi_trace_error("osdfs_get_inode() failed\n");
return NULL;
}
if ((sb->s_root=d_alloc_root(inode))==NULL) {
TRACE_ERROR("d_alloc_root() failed\n");
iscsi_trace_error("d_alloc_root() failed\n");
iput(inode);
return NULL;
}
@ -1061,13 +1061,13 @@ static DECLARE_FSTYPE_DEV(osdfs_fs_type, "osdfs", osdfs_read_super);
static int __init init_osdfs_fs(void) {
TRACE(TRACE_OSDFS, "init_osdfs_fs()\n");
iscsi_trace(TRACE_OSDFS, "init_osdfs_fs()\n");
ISCSI_MUTEX_INIT(&g_mutex, return -1);
return register_filesystem(&osdfs_fs_type);
}
static void __exit exit_osdfs_fs(void) {
TRACE(TRACE_OSDFS, "exit_osdfs_fs()\n");
iscsi_trace(TRACE_OSDFS, "exit_osdfs_fs()\n");
ISCSI_MUTEX_DESTROY(&g_mutex, printk("mutex_destroy() failed\n"));
unregister_filesystem(&osdfs_fs_type);
}

158
dist/iscsi/src/parameters.c vendored
View File

@ -61,7 +61,7 @@ param_list_add(iscsi_parameter_t ** head, int type, const char *key, const char
if (*head == NULL) {
if ((*head = iscsi_malloc_atomic(sizeof(iscsi_parameter_t))) == NULL) {
TRACE_ERROR("out of memory\n");
iscsi_trace_error("out of memory\n");
return -1;
}
param = *head;
@ -69,7 +69,7 @@ param_list_add(iscsi_parameter_t ** head, int type, const char *key, const char
for (param = *head; param->next != NULL; param = param->next) {
}
if ((param->next = iscsi_malloc_atomic(sizeof(iscsi_parameter_t))) == NULL) {
TRACE_ERROR("out of memory\n");
iscsi_trace_error("out of memory\n");
return -1;
}
param = param->next;
@ -92,7 +92,7 @@ param_list_add(iscsi_parameter_t ** head, int type, const char *key, const char
/* set offer and answer lists to NULL */
if ((param->value_l = iscsi_malloc_atomic(sizeof(iscsi_parameter_value_t))) == NULL) {
TRACE_ERROR("iscsi_malloc_atomic() failed\n");
iscsi_trace_error("iscsi_malloc_atomic() failed\n");
return -1;
}
param->value_l->next = NULL;
@ -114,7 +114,7 @@ param_list_add(iscsi_parameter_t ** head, int type, const char *key, const char
strcmp(valid, "no,yes") != 0 &&
strcmp(valid, "no") != 0 &&
strcmp(valid, "yes") != 0) {
TRACE_ERROR("bad <valid> field \"%s\" for ISCSI_PARAM_TYPE_BINARY\n", valid);
iscsi_trace_error("bad <valid> field \"%s\" for ISCSI_PARAM_TYPE_BINARY\n", valid);
return -1;
}
break;
@ -127,7 +127,7 @@ param_list_add(iscsi_parameter_t ** head, int type, const char *key, const char
strcmp(valid, "no,yes") != 0 &&
strcmp(valid, "no") != 0 &&
strcmp(valid, "yes") != 0) {
TRACE_ERROR("bad <valid> field \"%s\" for ISCSI_PARAM_TYPE_BINARY\n", valid);
iscsi_trace_error("bad <valid> field \"%s\" for ISCSI_PARAM_TYPE_BINARY\n", valid);
return -1;
}
break;
@ -138,11 +138,11 @@ param_list_add(iscsi_parameter_t ** head, int type, const char *key, const char
case ISCSI_PARAM_TYPE_LIST:
break;
default:
TRACE_ERROR("unknown parameter type %i\n", type);
iscsi_trace_error("unknown parameter type %i\n", type);
return -1;
}
TRACE(TRACE_ISCSI_PARAM, "\"%s\": valid \"%s\", default \"%s\", current \"%s\"\n",
iscsi_trace(TRACE_ISCSI_PARAM, "\"%s\": valid \"%s\", default \"%s\", current \"%s\"\n",
param->key, param->valid, param->dflt, param->value_l->value);
return 0;
}
@ -160,13 +160,13 @@ param_list_destroy(iscsi_parameter_t * head)
for (item_ptr = tmp->value_l; item_ptr != NULL; item_ptr = next) {
next = item_ptr->next;
/*
* TRACE(TRACE_ISCSI_PARAM, "freeing \"%s\"
* iscsi_trace(TRACE_ISCSI_PARAM, "freeing \"%s\"
* (%p)\n", item_ptr->value, item_ptr);
*/
iscsi_free_atomic(item_ptr);
}
}
/* TRACE(TRACE_ISCSI_PARAM, "freeing %p\n", tmp); */
/* iscsi_trace(TRACE_ISCSI_PARAM, "freeing %p\n", tmp); */
iscsi_free_atomic(tmp);
}
return 0;
@ -183,7 +183,7 @@ param_get(iscsi_parameter_t * head, const char *key)
return ptr;
}
}
TRACE_ERROR("key \"%s\" not found in param list\n", key);
iscsi_trace_error("key \"%s\" not found in param list\n", key);
return NULL;
}
@ -205,19 +205,19 @@ param_val_which(iscsi_parameter_t * head, const char *key, int which)
item_ptr = ptr->value_l;
for (i = 0; i != which; i++) {
if (item_ptr == NULL) {
TRACE_ERROR("item %i in value list is NULL\n", i);
iscsi_trace_error("item %i in value list is NULL\n", i);
return NULL;
}
item_ptr = item_ptr->next;
}
if (item_ptr == NULL) {
TRACE_ERROR("item %i in value list is NULL\n", which);
iscsi_trace_error("item %i in value list is NULL\n", which);
return NULL;
}
return item_ptr->value;
}
}
TRACE_ERROR("key \"%s\" not found in param list\n", key);
iscsi_trace_error("key \"%s\" not found in param list\n", key);
return NULL;
}
@ -237,7 +237,7 @@ param_val_delete_all(iscsi_parameter_t * head, char *key)
return 0;
}
}
TRACE_ERROR("key \"%s\" not found in param list\n", key);
iscsi_trace_error("key \"%s\" not found in param list\n", key);
return -1;
}
@ -252,7 +252,7 @@ param_val_reset(iscsi_parameter_t * head, const char *key)
return 0;
}
}
TRACE_ERROR("key \"%s\" not found in param list\n", key);
iscsi_trace_error("key \"%s\" not found in param list\n", key);
return -1;
}
@ -268,16 +268,16 @@ param_atoi(iscsi_parameter_t * head, const char *key)
if ((value = param_val(head, key)) != NULL) {
return iscsi_atoi(value);
} else {
TRACE_ERROR("value is NULL\n");
iscsi_trace_error("value is NULL\n");
return 0;
}
} else {
TRACE_ERROR("param \"%s\" has NULL value list\n", key);
iscsi_trace_error("param \"%s\" has NULL value list\n", key);
return 0;
}
}
}
TRACE_ERROR("key \"%s\" not found in param list\n", key);
iscsi_trace_error("key \"%s\" not found in param list\n", key);
return 0;
}
@ -290,17 +290,17 @@ param_equiv(iscsi_parameter_t * head, const char *key, const char *val)
for (ptr = head; ptr != NULL; ptr = ptr->next) {
if (strcmp(ptr->key, key) == 0) {
if (ptr->value_l == NULL) {
TRACE_ERROR("param \"%s\" has NULL value list\n", key);
iscsi_trace_error("param \"%s\" has NULL value list\n", key);
return 0;
}
if ((value = param_val(head, key)) == NULL) {
TRACE_ERROR("key \"%s\" value is NULL\n", key);
iscsi_trace_error("key \"%s\" value is NULL\n", key);
return 0;
}
return (strcmp(value, val) == 0);
}
}
TRACE_ERROR("key \"%s\" not found in param list\n", key);
iscsi_trace_error("key \"%s\" not found in param list\n", key);
return -1;
}
@ -319,7 +319,7 @@ param_num_vals(iscsi_parameter_t * head, char *key)
return num;
}
}
TRACE_ERROR("key \"%s\" not found in param list\n", key);
iscsi_trace_error("key \"%s\" not found in param list\n", key);
return -1;
}
@ -331,7 +331,7 @@ param_list_print(iscsi_parameter_t * head)
for (ptr = head; ptr != NULL; ptr = ptr->next) {
for (item_ptr = ptr->value_l; item_ptr != NULL; item_ptr = item_ptr->next) {
PRINT("\"%s\"=\"%s\"\n", ptr->key, item_ptr->value);
printf("\"%s\"=\"%s\"\n", ptr->key, item_ptr->value);
}
}
return 0;
@ -353,13 +353,13 @@ param_text_print(char *text, uint32_t text_len)
break;
if ((eq = strchr(ptr, '=')) == NULL) {
TRACE_ERROR("delimiter \'=\' not found in token \"%s\"\n", ptr);
iscsi_trace_error("delimiter \'=\' not found in token \"%s\"\n", ptr);
return -1;
}
strncpy(key, ptr, (unsigned)(eq - ptr));
key[(int)(eq - ptr)] = 0x0;
value = eq + 1;
PRINT("\"%s\"=\"%s\"\n", key, value);
printf("\"%s\"=\"%s\"\n", key, value);
}
return 0;
}
@ -400,7 +400,7 @@ find_credentials(cred_t *cred, char *user, const char *auth)
(void) memset(&e, 0x0, sizeof(e));
if (!conffile_open(&conf, _PATH_ISCSI_PASSWD, "r", ":", "#")) {
TRACE_ERROR("can't open `%s'\n", _PATH_ISCSI_PASSWD);
iscsi_trace_error("can't open `%s'\n", _PATH_ISCSI_PASSWD);
exit(EXIT_FAILURE);
}
while (conffile_getent(&conf, &e)) {
@ -462,11 +462,11 @@ param_parse_security(iscsi_parameter_t * head,
int ret = 1;
if ((chapstring = iscsi_malloc(ISCSI_CHAP_STRING_LENGTH)) == NULL) {
TRACE_ERROR("iscsi_malloc() failed\n");
iscsi_trace_error("iscsi_malloc() failed\n");
return -1;
}
if ((context = iscsi_malloc(sizeof(MD5Context_t))) == NULL) {
TRACE_ERROR("iscsi_malloc() failed\n");
iscsi_trace_error("iscsi_malloc() failed\n");
if (chapstring != NULL)
iscsi_free(chapstring);
return -1;
@ -541,14 +541,14 @@ param_parse_security(iscsi_parameter_t * head,
param->rx_offer = 0; /* reset */
if (cred->shared_secret == NULL && !find_credentials(cred, cred->user, "chap")) {
TRACE_ERROR("Unknown user `%s'\n", param_in->offer_rx);
iscsi_trace_error("Unknown user `%s'\n", param_in->offer_rx);
PPS_ERROR;
}
if (cred->user) {
(void) strlcpy(param->offer_tx, cred->user, sizeof(param->offer_tx));
} else {
TRACE_ERROR("no valid user credentials\n");
iscsi_trace_error("no valid user credentials\n");
PPS_ERROR;
}
@ -564,7 +564,7 @@ param_parse_security(iscsi_parameter_t * head,
MD5Update(context, &idData, 1);
if (cred->shared_secret == NULL) {
TRACE_ERROR("null shared secret\n");
iscsi_trace_error("null shared secret\n");
PPS_ERROR;
} else {
MD5Update(context, cred->shared_secret, strlen(cred->shared_secret));
@ -612,7 +612,7 @@ param_parse_security(iscsi_parameter_t * head,
user = (param_in->rx_offer) ? param_in->offer_rx : param_in->answer_rx;
if (!find_credentials(cred, user, "chap")) {
TRACE_ERROR("Unknown user `%s'\n", user);
iscsi_trace_error("Unknown user `%s'\n", user);
PPS_ERROR;
}
ret++;
@ -628,7 +628,7 @@ param_parse_security(iscsi_parameter_t * head,
chapstring, ISCSI_CHAP_STRING_LENGTH);
if (cred->shared_secret == NULL) {
TRACE_ERROR("Null shared secret in initiator\n");
iscsi_trace_error("Null shared secret in initiator\n");
PPS_ERROR;
} else {
MD5Update(context, cred->shared_secret, strlen(cred->shared_secret));
@ -644,7 +644,7 @@ param_parse_security(iscsi_parameter_t * head,
param_in->offer_rx, ISCSI_CHAP_STRING_LENGTH);
if (memcmp(respdata, chapdata, ISCSI_CHAP_DATA_LENGTH) != 0) {
TRACE_ERROR("Initiator authentication failed %x %x\n", *chapdata, *respdata);
iscsi_trace_error("Initiator authentication failed %x %x\n", *chapdata, *respdata);
PPS_ERROR;
} else {
PPS_CLEANUP;
@ -688,21 +688,21 @@ param_text_parse(iscsi_parameter_t * head,
*/
/* text has offers that need an answer. */
TRACE(TRACE_ISCSI_PARAM, "parsing %i %s bytes of text parameters\n", text_len_in, outgoing ? "outgoing" : "incoming");
iscsi_trace(TRACE_ISCSI_PARAM, "parsing %i %s bytes of text parameters\n", text_len_in, outgoing ? "outgoing" : "incoming");
if ((key = iscsi_malloc(ISCSI_PARAM_KEY_LEN)) == NULL) {
TRACE_ERROR("iscsi_malloc() failed\n");
iscsi_trace_error("iscsi_malloc() failed\n");
return -1;
}
if ((offer = iscsi_malloc(ISCSI_PARAM_MAX_LEN)) == NULL) {
TRACE_ERROR("iscsi_malloc() failed\n");
iscsi_trace_error("iscsi_malloc() failed\n");
if (key != NULL) {
iscsi_free(key);
}
return -1;
}
if ((valid = iscsi_malloc(ISCSI_PARAM_MAX_LEN)) == NULL) {
TRACE_ERROR("iscsi_malloc() failed\n");
iscsi_trace_error("iscsi_malloc() failed\n");
if (key != NULL) {
iscsi_free(key);
}
@ -712,7 +712,7 @@ param_text_parse(iscsi_parameter_t * head,
return -1;
}
if ((val1 = iscsi_malloc(ISCSI_PARAM_MAX_LEN)) == NULL) {
TRACE_ERROR("iscsi_malloc() failed\n");
iscsi_trace_error("iscsi_malloc() failed\n");
if (key != NULL) {
iscsi_free(key);
}
@ -725,7 +725,7 @@ param_text_parse(iscsi_parameter_t * head,
return -1;
}
if ((val2 = iscsi_malloc(ISCSI_PARAM_MAX_LEN)) == NULL) {
TRACE_ERROR("iscsi_malloc() failed\n");
iscsi_trace_error("iscsi_malloc() failed\n");
if (key != NULL) {
iscsi_free(key);
}
@ -753,9 +753,9 @@ param_text_parse(iscsi_parameter_t * head,
}
#if ISCSI_DEBUG
PRINT("**************************************************\n");
PRINT("* PARAMETERS NEGOTIATED *\n");
PRINT("* *\n");
printf("**************************************************\n");
printf("* PARAMETERS NEGOTIATED *\n");
printf("* *\n");
#endif
for (ptr = text_in; ptr - text_in < text_len_in; ptr += (strlen(ptr) + 1)) {
@ -772,7 +772,7 @@ param_text_parse(iscsi_parameter_t * head,
/* Extract <key>=<value> token from text_in */
if ((eq = strchr(ptr, '=')) == NULL) {
TRACE_ERROR("delimiter \'=\' not found in token \"%s\"\n", ptr);
iscsi_trace_error("delimiter \'=\' not found in token \"%s\"\n", ptr);
} else {
if ((int)(eq - ptr) >= (ISCSI_PARAM_KEY_LEN - 1)) {
if (!outgoing) {
@ -784,7 +784,7 @@ param_text_parse(iscsi_parameter_t * head,
PARAM_TEXT_ADD(head, tmp_key, "NotUnderstood", text_out, text_len_out, textsize, 0, PTP_ERROR);
}
} else {
PRINT("ignoring \"%s\"\n", key);
printf("ignoring \"%s\"\n", key);
}
goto next;
}
@ -805,7 +805,7 @@ param_text_parse(iscsi_parameter_t * head,
/* Key not understood. */
PARAM_TEXT_ADD(head, key, "NotUnderstood", text_out, text_len_out, textsize, 0, PTP_ERROR);
} else {
PRINT("ignoring \"%s\"\n", key);
printf("ignoring \"%s\"\n", key);
}
goto next;
}
@ -817,14 +817,14 @@ param_text_parse(iscsi_parameter_t * head,
if (param->rx_offer) {
param->tx_answer = 1; /* sending an answer */
(void) strlcpy(param->answer_tx, value, sizeof(param->answer_tx));
TRACE(TRACE_ISCSI_PARAM, "sending answer \"%s\"=\"%s\" for offer \"%s\"\n",
iscsi_trace(TRACE_ISCSI_PARAM, "sending answer \"%s\"=\"%s\" for offer \"%s\"\n",
param->key, param->answer_tx, param->offer_rx);
goto negotiate;
} else {
param->tx_offer = 1; /* sending an offer */
param->rx_offer = 0; /* reset */
(void) strlcpy(param->offer_tx, value, sizeof(param->offer_tx));
TRACE(TRACE_ISCSI_PARAM, "sending offer \"%s\"=\"%s\"\n", param->key, param->offer_tx);
iscsi_trace(TRACE_ISCSI_PARAM, "sending offer \"%s\"=\"%s\"\n", param->key, param->offer_tx);
if ((param->type == ISCSI_PARAM_TYPE_DECLARATIVE) ||
(param->type == ISCSI_PARAM_TYPE_DECLARE_MULTI)) {
goto negotiate;
@ -836,7 +836,7 @@ param_text_parse(iscsi_parameter_t * head,
param->rx_answer = 1; /* received an answer */
param->tx_offer = 0; /* reset */
(void) strlcpy(param->answer_rx, value, sizeof(param->answer_rx));
TRACE(TRACE_ISCSI_PARAM, "received answer \"%s\"=\"%s\" for offer \"%s\"\n",
iscsi_trace(TRACE_ISCSI_PARAM, "received answer \"%s\"=\"%s\" for offer \"%s\"\n",
param->key, param->answer_rx, param->offer_tx);
if ((ret = param_parse_security(head, param, cred,
@ -859,7 +859,7 @@ param_text_parse(iscsi_parameter_t * head,
} else {
param->rx_offer = 1; /* received an offer */
(void) strlcpy(param->offer_rx, value, sizeof(param->offer_rx));
TRACE(TRACE_ISCSI_PARAM, "received offer \"%s\"=\"%s\"\n", param->key, param->offer_rx);
iscsi_trace(TRACE_ISCSI_PARAM, "received offer \"%s\"=\"%s\"\n", param->key, param->offer_rx);
if ((ret = param_parse_security(head, param, cred,
text_out, text_len_out, textsize)) > 1) {
@ -895,16 +895,16 @@ answer:
/* Answer with current value if this is an inquiry (<key>=?) */
if (strcmp(value, "?") == 0) {
TRACE(TRACE_ISCSI_PARAM, "got inquiry for param \"%s\"\n", param->key);
iscsi_trace(TRACE_ISCSI_PARAM, "got inquiry for param \"%s\"\n", param->key);
if (param->value_l) {
if (param->value_l->value) {
(void) strlcpy(param->answer_tx, param->value_l->value, sizeof(param->answer_tx));
} else {
TRACE_ERROR("param \"%s\" has NULL value_l->value\n", param->key);
iscsi_trace_error("param \"%s\" has NULL value_l->value\n", param->key);
param->answer_tx[0] = 0x0;
}
} else {
TRACE_ERROR("param \"%s\" has NULL value_l\n", param->key);
iscsi_trace_error("param \"%s\" has NULL value_l\n", param->key);
param->answer_tx[0] = 0x0;
}
goto add_answer;
@ -922,7 +922,7 @@ binary_or:
strcmp(value, "no") != 0 &&
strcmp(value, "Yes") != 0 &&
strcmp(value, "No") != 0) {
TRACE_ERROR("\"%s\" is not a valid binary value\n", value);
iscsi_trace_error("\"%s\" is not a valid binary value\n", value);
(void) strlcpy(param->answer_tx, "Reject", sizeof(param->answer_tx));
goto add_answer;
}
@ -991,13 +991,13 @@ binary_or:
}
}
} else {
TRACE(TRACE_ISCSI_PARAM, "Valid list empty. Answering with first in offer list\n");
iscsi_trace(TRACE_ISCSI_PARAM, "Valid list empty. Answering with first in offer list\n");
(void) strlcpy(param->answer_tx, offer, sizeof(param->answer_tx));
goto add_answer;
}
TRACE(TRACE_ISCSI_PARAM, "\"%s\" is not a valid offer for key \"%s\" (must choose from \"%s\")\n", offer, param->key, param->valid);
iscsi_trace(TRACE_ISCSI_PARAM, "\"%s\" is not a valid offer for key \"%s\" (must choose from \"%s\")\n", offer, param->key, param->valid);
}
TRACE(TRACE_ISCSI_PARAM, "No Valid offers: \"%s\" is added as value for key \"%s\")\n", "Reject", param->key);
iscsi_trace(TRACE_ISCSI_PARAM, "No Valid offers: \"%s\" is added as value for key \"%s\")\n", "Reject", param->key);
(void) strlcpy(param->answer_tx, "Reject", sizeof(param->answer_tx));
break;
@ -1039,7 +1039,7 @@ numerical:
goto next;
}
add_answer: PARAM_TEXT_ADD(head, key, param->answer_tx, text_out, text_len_out, textsize, 0, PTP_ERROR);
TRACE(TRACE_ISCSI_PARAM, "answering \"%s\"=\"%s\"\n", param->key, param->answer_tx);
iscsi_trace(TRACE_ISCSI_PARAM, "answering \"%s\"=\"%s\"\n", param->key, param->answer_tx);
goto next;
@ -1070,7 +1070,7 @@ binary_or_negotiate:
strcmp(val1, "no") != 0 &&
strcmp(val1, "Irrelevant") != 0) {
/* Invalid value returned as answer. */
TRACE_ERROR("Invalid answer (%s) for key (%s)\n",
iscsi_trace_error("Invalid answer (%s) for key (%s)\n",
val1, key);
PTP_ERROR;
}
@ -1124,25 +1124,25 @@ numerical_negotiate:
case ISCSI_PARAM_TYPE_LIST:
if (outgoing) {
if (param->tx_offer) {
TRACE_ERROR("we should not be here\n"); /* error - we're sending
iscsi_trace_error("we should not be here\n"); /* error - we're sending
* an offer */
PTP_ERROR;
} else if (param->tx_answer) {
(void) strlcpy(val1, param->answer_tx, ISCSI_PARAM_MAX_LEN); /* we're sending an
* answer */
} else {
TRACE_ERROR("unexpected error\n");
iscsi_trace_error("unexpected error\n");
PTP_ERROR;
}
} else {
if (param->rx_offer) {
TRACE_ERROR("we should not be here\n"); /* error - we received
iscsi_trace_error("we should not be here\n"); /* error - we received
* an offer */
PTP_ERROR;
} else if (param->rx_answer) {
(void) strlcpy(val1, param->answer_rx, ISCSI_PARAM_MAX_LEN); /* we received an answer */
} else {
TRACE_ERROR("unexpected error\n");
iscsi_trace_error("unexpected error\n");
PTP_ERROR;
}
}
@ -1169,50 +1169,50 @@ numerical_negotiate:
}
}
} else {
TRACE(TRACE_ISCSI_PARAM, "Valid list empty??\n");
iscsi_trace(TRACE_ISCSI_PARAM, "Valid list empty??\n");
PTP_ERROR;
}
TRACE_ERROR("\"%s\" is not a valid value (must choose from \"%s\")\n", val1, param->valid);
iscsi_trace_error("\"%s\" is not a valid value (must choose from \"%s\")\n", val1, param->valid);
PTP_ERROR;
value_ok:
(void) strlcpy(param->negotiated, val1, sizeof(param->negotiated));
break;
}
TRACE(TRACE_ISCSI_PARAM, "negotiated \"%s\"=\"%s\"\n", param->key, param->negotiated);
iscsi_trace(TRACE_ISCSI_PARAM, "negotiated \"%s\"=\"%s\"\n", param->key, param->negotiated);
/* For inquiries, we don't commit the value. */
if (param->tx_offer && strcmp(param->offer_tx, "?") == 0) {
/* we're offering an inquiry */
TRACE(TRACE_ISCSI_PARAM, "sending an inquiry for \"%s\"\n", param->key);
iscsi_trace(TRACE_ISCSI_PARAM, "sending an inquiry for \"%s\"\n", param->key);
goto next;
} else if (param->rx_offer && strcmp(param->offer_rx, "?") == 0) {
/* we're receiving an inquiry */
TRACE(TRACE_ISCSI_PARAM, "received an inquiry for \"%s\"\n", param->key);
iscsi_trace(TRACE_ISCSI_PARAM, "received an inquiry for \"%s\"\n", param->key);
goto next;
} else if (param->tx_answer && strcmp(param->offer_rx, "?") == 0) {
/* we're answering an inquiry */
TRACE(TRACE_ISCSI_PARAM, "answering an inquiry for \"%s\"\n", param->key);
iscsi_trace(TRACE_ISCSI_PARAM, "answering an inquiry for \"%s\"\n", param->key);
goto next;
} else if (param->rx_answer && strcmp(param->offer_tx, "?") == 0) {
/* we're receiving an answer for our inquiry */
TRACE(TRACE_ISCSI_PARAM, "received an answer for inquiry on \"%s\"\n", param->key);
iscsi_trace(TRACE_ISCSI_PARAM, "received an answer for inquiry on \"%s\"\n", param->key);
goto next;
}
TRACE(TRACE_ISCSI_PARAM, "automatically committing \"%s\"=\"%s\"\n", param->key, param->negotiated);
iscsi_trace(TRACE_ISCSI_PARAM, "automatically committing \"%s\"=\"%s\"\n", param->key, param->negotiated);
c = param->negotiated[19];
param->negotiated[19] = 0x0;
#if ISCSI_DEBUG
PRINT("* %25s:%20s *\n", param->key, param->negotiated);
printf("* %25s:%20s *\n", param->key, param->negotiated);
#endif
param->negotiated[19] = c;
if (param->reset) {
TRACE(TRACE_ISCSI_PARAM, "deleting value list for \"%s\"\n", param->key);
iscsi_trace(TRACE_ISCSI_PARAM, "deleting value list for \"%s\"\n", param->key);
if (param_val_delete_all(head, param->key) != 0) {
TRACE_ERROR("param_val_delete_all() failed\n");
iscsi_trace_error("param_val_delete_all() failed\n");
PTP_ERROR;
}
param->reset = 0;
@ -1222,7 +1222,7 @@ value_ok:
for (item_ptr = param->value_l; item_ptr->next != NULL; item_ptr = item_ptr->next) {
}
if ((item_ptr->next = iscsi_malloc_atomic(sizeof(iscsi_parameter_value_t))) == NULL) {
TRACE_ERROR("iscsi_malloc_atomic() failed\n");
iscsi_trace_error("iscsi_malloc_atomic() failed\n");
PTP_ERROR;
}
item_ptr = item_ptr->next;
@ -1231,9 +1231,9 @@ value_ok:
item_ptr = param->value_l;
}
} else {
TRACE(TRACE_ISCSI_PARAM, "allocating value ptr\n");
iscsi_trace(TRACE_ISCSI_PARAM, "allocating value ptr\n");
if ((param->value_l = iscsi_malloc_atomic(sizeof(iscsi_parameter_value_t))) == NULL) {
TRACE_ERROR("iscsi_malloc_atomic() failed\n");
iscsi_trace_error("iscsi_malloc_atomic() failed\n");
PTP_ERROR;
}
item_ptr = param->value_l;
@ -1244,10 +1244,10 @@ next:
continue;
}
if (!outgoing) {
TRACE(TRACE_ISCSI_PARAM, "generated %d bytes response\n", *text_len_out);
iscsi_trace(TRACE_ISCSI_PARAM, "generated %d bytes response\n", *text_len_out);
}
#if ISCSI_DEBUG
PRINT("**************************************************\n");
printf("**************************************************\n");
#endif
PTP_CLEANUP;

76
dist/iscsi/src/so.c vendored
View File

@ -133,7 +133,7 @@ static int so_ioctl(struct inode * inode, struct file * file, unsigned int cmd,
Scsi_Device * SDev;
int osdinfo[4];
TRACE(TRACE_OSDSO, "so_ioctl()\n");
iscsi_trace(TRACE_OSDSO, "so_ioctl()\n");
SDev = rscsi_osds[DEVICE_NR(dev)].device;
/*
@ -240,7 +240,7 @@ static int so_ioctl(struct inode * inode, struct file * file, unsigned int cmd,
}
static void so_devname(unsigned int index, char *buffer) {
TRACE(TRACE_OSDSO, "so_devname(%i)\n", index);
iscsi_trace(TRACE_OSDSO, "so_devname(%i)\n", index);
sprintf(buffer, "so%i", index);
}
@ -249,13 +249,13 @@ static request_queue_t *so_find_queue(kdev_t dev)
Scsi_Osd *dpnt;
int target;
TRACE(TRACE_OSDSO, "so_find_queue()\n");
iscsi_trace(TRACE_OSDSO, "so_find_queue()\n");
target = DEVICE_NR(dev);
dpnt = &rscsi_osds[target];
if (!dpnt) {
TRACE_ERROR("no such device\n");
iscsi_trace_error("no such device\n");
return NULL;
}
return &dpnt->device->request_queue;
@ -269,7 +269,7 @@ static int so_init_command(Scsi_Cmnd * SCpnt)
osd_args_t args;
int index;
TRACE(TRACE_OSDSO, "so_init_command(MAJOR %i, MINOR %i)\n",
iscsi_trace(TRACE_OSDSO, "so_init_command(MAJOR %i, MINOR %i)\n",
MAJOR(SCpnt->request.rq_dev), MINOR(SCpnt->request.rq_dev));
index = MINOR(SCpnt->request.rq_dev);
so_devname(index, nbuff);
@ -279,26 +279,26 @@ static int so_init_command(Scsi_Cmnd * SCpnt)
if (index >= so_template.dev_max || !dpnt || !dpnt->device->online ||
block + SCpnt->request.nr_sectors > so[index].nr_sects) {
TRACE_ERROR("index %i: request out of range: %i offset + %li count > %li total sectors\n",
iscsi_trace_error("index %i: request out of range: %i offset + %li count > %li total sectors\n",
index, block, SCpnt->request.nr_sectors, so[index].nr_sects);
return 0;
}
block += so[index].start_sect;
if (dpnt->device->changed) {
TRACE_ERROR("SCSI osd has been changed. Prohibiting further I/O\n");
iscsi_trace_error("SCSI osd has been changed. Prohibiting further I/O\n");
return 0;
}
switch (SCpnt->request.cmd) {
case WRITE:
TRACE(TRACE_OSDSO, "Translating BLOCK WRITE to OBJECT WRITE\n");
iscsi_trace(TRACE_OSDSO, "Translating BLOCK WRITE to OBJECT WRITE\n");
if (!dpnt->device->writeable) {
TRACE_ERROR("device is not writable\n");
iscsi_trace_error("device is not writable\n");
return 0;
}
TRACE(TRACE_OSDSO, "Translating BLOCK WRITE (sector %i, len %i) to OBJECT WRITE\n", block, this_count);
iscsi_trace(TRACE_OSDSO, "Translating BLOCK WRITE (sector %i, len %i) to OBJECT WRITE\n", block, this_count);
memset(&args, 0, sizeof(osd_args_t));
args.opcode = 0x7f;
args.add_cdb_len = CONFIG_OSD_CDB_LEN-7;
@ -314,7 +314,7 @@ static int so_init_command(Scsi_Cmnd * SCpnt)
case READ:
TRACE(TRACE_OSDSO, "Translating BLOCK READ (sector %i, len %i) to OBJECT READ\n", block, this_count);
iscsi_trace(TRACE_OSDSO, "Translating BLOCK READ (sector %i, len %i) to OBJECT READ\n", block, this_count);
memset(&args, 0, sizeof(osd_args_t));
args.opcode = 0x7f;
args.add_cdb_len = CONFIG_OSD_CDB_LEN-7;
@ -365,7 +365,7 @@ static int so_open(struct inode *inode, struct file *filp)
Scsi_Device * SDev;
target = DEVICE_NR(inode->i_rdev);
TRACE(TRACE_OSDSO, "so_open()\n");
iscsi_trace(TRACE_OSDSO, "so_open()\n");
SCSI_LOG_HLQUEUE(1, printk("target=%d, max=%d\n", target, so_template.dev_max));
@ -439,7 +439,7 @@ static int so_release(struct inode *inode, struct file *file)
int target;
Scsi_Device * SDev;
TRACE(TRACE_OSDSO, "so_release()\n");
iscsi_trace(TRACE_OSDSO, "so_release()\n");
target = DEVICE_NR(inode->i_rdev);
SDev = rscsi_osds[target].device;
@ -501,7 +501,7 @@ static void rw_intr(Scsi_Cmnd * SCpnt)
int block_sectors = 1;
so_devname(DEVICE_NR(SCpnt->request.rq_dev), nbuff);
TRACE(TRACE_OSDSO, "rw_intr(/dev/%s, host %d, result 0x%x)\n", nbuff, SCpnt->host->host_no, result);
iscsi_trace(TRACE_OSDSO, "rw_intr(/dev/%s, host %d, result 0x%x)\n", nbuff, SCpnt->host->host_no, result);
/*
Handle MEDIUM ERRORs that indicate partial success. Since this is a
@ -576,7 +576,7 @@ static int check_scsiosd_media_change(kdev_t full_dev)
int flag = 0;
Scsi_Device * SDev;
TRACE(TRACE_OSDSO, "check_scsiosd_media_change()\n");
iscsi_trace(TRACE_OSDSO, "check_scsiosd_media_change()\n");
target = DEVICE_NR(full_dev);
SDev = rscsi_osds[target].device;
@ -641,11 +641,11 @@ static int so_init_oneosd(int i) {
char nbuff[6];
Scsi_Request *SRpnt;
TRACE(TRACE_OSDSO, "so_init_oneosd(%i)\n", i);
iscsi_trace(TRACE_OSDSO, "so_init_oneosd(%i)\n", i);
so_devname(i, nbuff);
if (rscsi_osds[i].device->online == FALSE) {
TRACE_ERROR("device is offline??\n");
iscsi_trace_error("device is offline??\n");
return i;
}
@ -663,7 +663,7 @@ static int so_init_oneosd(int i) {
SRpnt->sr_data_direction = SCSI_DATA_READ;
scsi_wait_req (SRpnt, (void *) cmd, NULL, 0, SO_TIMEOUT, MAX_RETRIES);
if (SRpnt->sr_result!=0) {
TRACE_ERROR("OSD not ready\n");
iscsi_trace_error("OSD not ready\n");
return i;
}
@ -700,18 +700,18 @@ static int so_registered;
static int so_init() {
int i;
TRACE(TRACE_OSDSO, "so_init()\n");
iscsi_trace(TRACE_OSDSO, "so_init()\n");
if (so_template.dev_noticed == 0) {
TRACE_ERROR("no OSDs noticed\n");
iscsi_trace_error("no OSDs noticed\n");
return 0;
}
if (!rscsi_osds) {
PRINT("%i osds detected \n", so_template.dev_noticed);
printf("%i osds detected \n", so_template.dev_noticed);
so_template.dev_max = so_template.dev_noticed;
}
if (so_template.dev_max > SCSI_OSDS_PER_MAJOR) {
TRACE_ERROR("so_template.dev_max (%i) > SCSI_OSDS_PER_MAJOR\n", so_template.dev_max);
iscsi_trace_error("so_template.dev_max (%i) > SCSI_OSDS_PER_MAJOR\n", so_template.dev_max);
so_template.dev_max = SCSI_OSDS_PER_MAJOR;
}
if (!so_registered) {
@ -729,7 +729,7 @@ static int so_init() {
/* Real devices */
if ((rscsi_osds = kmalloc(so_template.dev_max * sizeof(Scsi_Osd), GFP_ATOMIC))==NULL) {
TRACE_ERROR("kmalloc() failed\n");
iscsi_trace_error("kmalloc() failed\n");
goto cleanup_devfs;
}
memset(rscsi_osds, 0, so_template.dev_max * sizeof(Scsi_Osd));
@ -738,7 +738,7 @@ static int so_init() {
/* Partition sizes */
if ((so_sizes=kmalloc(so_template.dev_max*sizeof(int), GFP_ATOMIC))==NULL) {
TRACE_ERROR("kmalloc() failed\n");
iscsi_trace_error("kmalloc() failed\n");
goto cleanup_rscsi_osds;
}
memset(so_sizes, 0, so_template.dev_max*sizeof(int));
@ -747,7 +747,7 @@ static int so_init() {
/* Block sizes */
if ((so_blocksizes=kmalloc(so_template.dev_max*sizeof(int), GFP_ATOMIC))==NULL) {
TRACE_ERROR("kmalloc() failed\n");
iscsi_trace_error("kmalloc() failed\n");
goto cleanup_so_sizes;
}
blksize_size[SCSI_OSD_MAJOR] = so_blocksizes;
@ -755,7 +755,7 @@ static int so_init() {
/* Sector sizes */
if ((so_hardsizes=kmalloc(so_template.dev_max*sizeof(int), GFP_ATOMIC))==NULL) {
TRACE_ERROR("kmalloc() failed\n");
iscsi_trace_error("kmalloc() failed\n");
goto cleanup_so_blocksizes;
}
hardsect_size[SCSI_OSD_MAJOR] = so_hardsizes;
@ -763,7 +763,7 @@ static int so_init() {
/* Partitions */
if ((so=kmalloc(so_template.dev_max*sizeof(struct hd_struct), GFP_ATOMIC))==NULL) {
TRACE_ERROR("kmalloc() failed\n");
iscsi_trace_error("kmalloc() failed\n");
goto cleanup_so_hardsizes;
}
memset(so, 0, so_template.dev_max*sizeof(struct hd_struct));
@ -781,7 +781,7 @@ static int so_init() {
/* ??? */
if ((so_gendisk.de_arr=kmalloc(SCSI_OSDS_PER_MAJOR*sizeof(*so_gendisk.de_arr), GFP_ATOMIC))==NULL) {
TRACE_ERROR("kmalloc() failed\n");
iscsi_trace_error("kmalloc() failed\n");
goto cleanup_so;
}
memset(so_gendisk.de_arr, 0, SCSI_OSDS_PER_MAJOR * sizeof *so_gendisk.de_arr);
@ -789,13 +789,13 @@ static int so_init() {
/* Flags */
if ((so_gendisk.flags=kmalloc(SCSI_OSDS_PER_MAJOR*sizeof(*so_gendisk.flags),GFP_ATOMIC))==NULL) {
TRACE_ERROR("kmalloc() failed\n");
iscsi_trace_error("kmalloc() failed\n");
goto cleanup_so_gendisk_de_arr;
}
memset(so_gendisk.flags, 0, SCSI_OSDS_PER_MAJOR * sizeof *so_gendisk.flags);
if (so_gendisk.next) {
TRACE_ERROR("Why is this not NULL?\n");
iscsi_trace_error("Why is this not NULL?\n");
so_gendisk.next = NULL;
}
@ -825,7 +825,7 @@ static void so_finish()
struct gendisk *gendisk;
int i;
TRACE(TRACE_OSDSO, "so_finish()\n");
iscsi_trace(TRACE_OSDSO, "so_finish()\n");
blk_dev[SCSI_OSD_MAJOR].queue = so_find_queue;
for (gendisk = gendisk_head; gendisk != NULL; gendisk = gendisk->next)
@ -856,7 +856,7 @@ static void so_finish()
static int so_detect(Scsi_Device * SDp)
{
char nbuff[6];
TRACE(TRACE_OSDSO, "so_detect()\n");
iscsi_trace(TRACE_OSDSO, "so_detect()\n");
if (SDp->type != TYPE_OSD && SDp->type != TYPE_MOD)
return 0;
@ -876,7 +876,7 @@ static int so_attach(Scsi_Device * SDp)
Scsi_Osd *dpnt;
int i;
TRACE(TRACE_OSDSO, "so_attach(SDpnt 0x%p)\n", SDp);
iscsi_trace(TRACE_OSDSO, "so_attach(SDpnt 0x%p)\n", SDp);
if (SDp->type != TYPE_OSD && SDp->type != TYPE_MOD)
return 0;
@ -922,7 +922,7 @@ int revalidate_scsiosd(kdev_t dev, int maxusage)
int start;
int i;
TRACE(TRACE_OSDSO, "revalidate_scsiosd()\n");
iscsi_trace(TRACE_OSDSO, "revalidate_scsiosd()\n");
target = DEVICE_NR(dev);
@ -965,7 +965,7 @@ int revalidate_scsiosd(kdev_t dev, int maxusage)
static int fop_revalidate_scsiosd(kdev_t dev)
{
TRACE(TRACE_OSDSO, "fop_revalidate_scsiosd()\n");
iscsi_trace(TRACE_OSDSO, "fop_revalidate_scsiosd()\n");
return revalidate_scsiosd(dev, 0);
}
static void so_detach(Scsi_Device * SDp)
@ -975,7 +975,7 @@ static void so_detach(Scsi_Device * SDp)
int max_p;
int start;
TRACE(TRACE_OSDSO, "so_detach()\n");
iscsi_trace(TRACE_OSDSO, "so_detach()\n");
for (dpnt = rscsi_osds, i = 0; i < so_template.dev_max; i++, dpnt++)
if (dpnt->device == SDp) {
@ -1008,7 +1008,7 @@ static void so_detach(Scsi_Device * SDp)
static int __init init_so(void)
{
TRACE(TRACE_OSDSO, "init_so()\n");
iscsi_trace(TRACE_OSDSO, "init_so()\n");
so_template.module = THIS_MODULE;
return scsi_register_module(MODULE_SCSI_DEV, &so_template);
}
@ -1019,7 +1019,7 @@ static void __exit exit_so(void)
struct gendisk *sogd;
int removed = 0;
TRACE(TRACE_OSDSO, "exit_so()\n");
iscsi_trace(TRACE_OSDSO, "exit_so()\n");
scsi_unregister_module(MODULE_SCSI_DEV, &so_template);

4
dist/iscsi/src/storage.c vendored
View File

@ -1,4 +1,4 @@
/* $NetBSD: storage.c,v 1.2 2006/02/16 19:19:38 agc Exp $ */
/* $NetBSD: storage.c,v 1.3 2006/03/12 18:47:28 agc Exp $ */
/*
* Copyright © 2006 Alistair Crooks. All rights reserved.
@ -370,7 +370,7 @@ read_conf_file(const char *cf, targv_t *tvp, devv_t *dvp, extv_t *evp)
(void) fprintf(stderr, "Error: can't open `%s'\n", cf);
return 0;
}
PRINT("Reading configuration from `%s'\n", cf);
printf("Reading configuration from `%s'\n", cf);
(void) memset(&e, 0x0, sizeof(e));
while (conffile_getent(&conf, &e)) {
if (strncmp(e.sv.v[0], "extent", 6) == 0) {

418
dist/iscsi/src/target.c vendored
View File

File diff suppressed because it is too large Load Diff

264
dist/iscsi/src/tests.c vendored
View File

@ -81,24 +81,24 @@ int osd_command(void *dev, osd_args_t * args, OSD_OPS_MEM * mem);
*/
#if 0
TRACE(TRACE_SCSI_ARGS, " Peripheral device type: %u\n", data[0] & 0x1f);
TRACE(TRACE_SCSI_ARGS, " Removable bit: %u\n", data[1] >> 7);
TRACE(TRACE_SCSI_ARGS, " ANSI-approved version: %u\n", data[2] & 0x7);
TRACE(TRACE_SCSI_ARGS, " AENC: %u\n", data[3] >> 7);
TRACE(TRACE_SCSI_ARGS, " TrmIOP: %u\n", (data[3] & 0x40) >> 6);
TRACE(TRACE_SCSI_ARGS, " NormACA: %u\n", (data[3] & 0x20) >> 5);
TRACE(TRACE_SCSI_ARGS, " Additional length: %u\n", data[4]);
TRACE(TRACE_SCSI_ARGS, " RelAdr: %u\n", data[7] & 0x7);
TRACE(TRACE_SCSI_ARGS, " Bus32: %u\n", (data[7] & 0x40) >> 6);
TRACE(TRACE_SCSI_ARGS, " WBus16: %u\n", (data[7] & 0x20) >> 5);
TRACE(TRACE_SCSI_ARGS, " Sync: %u\n", (data[7] & 0x10) >> 4);
TRACE(TRACE_SCSI_ARGS, " Linked: %u\n", (data[7] & 0x08) >> 3);
TRACE(TRACE_SCSI_ARGS, " TransDis: %u\n", (data[7] & 0x04) >> 2);
TRACE(TRACE_SCSI_ARGS, " CmdQue: %u\n", (data[7] & 0x02) >> 1);
TRACE(TRACE_SCSI_ARGS, " SftRe: %u\n", (data[7] & 0x01));
TRACE(TRACE_SCSI_ARGS, " Vendor ID: %s\n", (data + 8));
TRACE(TRACE_SCSI_ARGS, " Product ID: %s\n", (data + 16));
TRACE(TRACE_SCSI_ARGS, " Revision Level: %s\n", (data + 32));
iscsi_trace(TRACE_SCSI_ARGS, " Peripheral device type: %u\n", data[0] & 0x1f);
iscsi_trace(TRACE_SCSI_ARGS, " Removable bit: %u\n", data[1] >> 7);
iscsi_trace(TRACE_SCSI_ARGS, " ANSI-approved version: %u\n", data[2] & 0x7);
iscsi_trace(TRACE_SCSI_ARGS, " AENC: %u\n", data[3] >> 7);
iscsi_trace(TRACE_SCSI_ARGS, " TrmIOP: %u\n", (data[3] & 0x40) >> 6);
iscsi_trace(TRACE_SCSI_ARGS, " NormACA: %u\n", (data[3] & 0x20) >> 5);
iscsi_trace(TRACE_SCSI_ARGS, " Additional length: %u\n", data[4]);
iscsi_trace(TRACE_SCSI_ARGS, " RelAdr: %u\n", data[7] & 0x7);
iscsi_trace(TRACE_SCSI_ARGS, " Bus32: %u\n", (data[7] & 0x40) >> 6);
iscsi_trace(TRACE_SCSI_ARGS, " WBus16: %u\n", (data[7] & 0x20) >> 5);
iscsi_trace(TRACE_SCSI_ARGS, " Sync: %u\n", (data[7] & 0x10) >> 4);
iscsi_trace(TRACE_SCSI_ARGS, " Linked: %u\n", (data[7] & 0x08) >> 3);
iscsi_trace(TRACE_SCSI_ARGS, " TransDis: %u\n", (data[7] & 0x04) >> 2);
iscsi_trace(TRACE_SCSI_ARGS, " CmdQue: %u\n", (data[7] & 0x02) >> 1);
iscsi_trace(TRACE_SCSI_ARGS, " SftRe: %u\n", (data[7] & 0x01));
iscsi_trace(TRACE_SCSI_ARGS, " Vendor ID: %s\n", (data + 8));
iscsi_trace(TRACE_SCSI_ARGS, " Product ID: %s\n", (data + 16));
iscsi_trace(TRACE_SCSI_ARGS, " Revision Level: %s\n", (data + 32));
#endif
int
@ -120,7 +120,7 @@ nop_out(uint64_t target, int lun, int length, int ping, const char *data)
nop_cmd.tag = 0xffffffff;
}
if (initiator_command(&cmd) != 0) {
TRACE_ERROR("initiator_command() failed\n");
iscsi_trace_error("initiator_command() failed\n");
return -1;
}
return 0;
@ -149,15 +149,15 @@ inquiry(uint64_t target, uint32_t lun, uint32_t *device_type)
cmd.ptr = &args;
if (initiator_command(&cmd) != 0) {
TRACE_ERROR("initiator_command() failed\n");
iscsi_trace_error("initiator_command() failed\n");
return -1;
}
if (args.status) {
TRACE_ERROR("INQUIRY failed (status 0x%x)\n", args.status);
iscsi_trace_error("INQUIRY failed (status 0x%x)\n", args.status);
return -1;
}
*device_type = data[0] & 0x1f;
TRACE(TRACE_SCSI_DEBUG, "Device Type 0x%x\n", *device_type);
iscsi_trace(TRACE_SCSI_DEBUG, "Device Type 0x%x\n", *device_type);
return 0;
}
@ -186,23 +186,23 @@ read_capacity(uint64_t target, uint32_t lun, uint32_t *max_lba, uint32_t *block_
cmd.ptr = &args;
if (initiator_command(&cmd) != 0) {
TRACE_ERROR("initiator_command() failed\n");
iscsi_trace_error("initiator_command() failed\n");
return -1;
}
if (args.status) {
TRACE_ERROR("READ_CAPACITY failed (status 0x%x)\n", args.status);
iscsi_trace_error("READ_CAPACITY failed (status 0x%x)\n", args.status);
return -1;
}
TRACE(TRACE_SCSI_DEBUG, "Max LBA (lun %u): %u\n", lun, *max_lba);
TRACE(TRACE_SCSI_DEBUG, "Block Len (lun %u): %u\n", lun, *block_len);
iscsi_trace(TRACE_SCSI_DEBUG, "Max LBA (lun %u): %u\n", lun, *max_lba);
iscsi_trace(TRACE_SCSI_DEBUG, "Block Len (lun %u): %u\n", lun, *block_len);
*max_lba = ISCSI_NTOHL(*((uint32_t *) (data)));
*block_len = ISCSI_NTOHL(*((uint32_t *) (data + 4)));
if (*max_lba == 0) {
TRACE_ERROR("Device returned Maximum LBA of zero\n");
iscsi_trace_error("Device returned Maximum LBA of zero\n");
return -1;
}
if (*block_len % 2) {
TRACE_ERROR("Device returned strange block len: %u\n", *block_len);
iscsi_trace_error("Device returned strange block len: %u\n", *block_len);
return -1;
}
return 0;
@ -229,13 +229,13 @@ write_read_test(uint64_t target, uint32_t lun, int type)
int i, j;
if ((type != 6) && (type != 10)) {
TRACE_ERROR("bad type, select 6 or 10\n");
iscsi_trace_error("bad type, select 6 or 10\n");
return -1;
}
/* determine last block on device */
if (read_capacity(target, lun, &max_lba, &block_len) != 0) {
TRACE_ERROR("read_capacity() failed\n");
iscsi_trace_error("read_capacity() failed\n");
return -1;
}
/* write pattern into first and last block on device */
@ -285,11 +285,11 @@ write_read_test(uint64_t target, uint32_t lun, int type)
cmd.ptr = &args;
cmd.type = ISCSI_SCSI_CMD;
if (initiator_command(&cmd) != 0) {
TRACE_ERROR("initiator_command() failed\n");
iscsi_trace_error("initiator_command() failed\n");
return -1;
}
if (args.status) {
TRACE_ERROR("initiator_command() failed\n");
iscsi_trace_error("initiator_command() failed\n");
return -1;
}
}
@ -337,16 +337,16 @@ write_read_test(uint64_t target, uint32_t lun, int type)
cmd.type = ISCSI_SCSI_CMD;
cmd.ptr = &args;
if (initiator_command(&cmd) != 0) {
TRACE_ERROR("initiator_command() failed\n");
iscsi_trace_error("initiator_command() failed\n");
return -1;
}
if (args.status) {
TRACE_ERROR("initiator_command() failed\n");
iscsi_trace_error("initiator_command() failed\n");
return -1;
}
for (j = 0; j < block_len; j++) {
if (data[j] != (uint8_t) (i + j)) {
TRACE_ERROR("Bad byte. data[%i] = %u, expected %u.\n",
iscsi_trace_error("Bad byte. data[%i] = %u, expected %u.\n",
j, data[j], (uint8_t) (i + j));
return -1;
}
@ -397,11 +397,11 @@ read_or_write(uint64_t target, uint32_t lun, uint32_t lba, uint32_t len,
/* Execute iSCSI command */
if (initiator_command(&cmd) != 0) {
TRACE_ERROR("initiator_command() failed\n");
iscsi_trace_error("initiator_command() failed\n");
return -1;
}
if (args.status) {
TRACE_ERROR("scsi_command() failed (status 0x%x)\n", args.status);
iscsi_trace_error("scsi_command() failed (status 0x%x)\n", args.status);
return -1;
}
return 0;
@ -423,40 +423,40 @@ throughput_test(uint32_t target, uint32_t lun, uint32_t length, uint32_t request
/* Get device block len & capacity */
if (read_capacity(target, lun, &max_lba, &block_len) != 0) {
TRACE_ERROR("read_capacity() failed\n");
iscsi_trace_error("read_capacity() failed\n");
return -1;
}
if (request % block_len) {
TRACE_ERROR("request must be a multiple of %u\n", block_len);
iscsi_trace_error("request must be a multiple of %u\n", block_len);
return -1;
}
if (!sg_factor) {
TRACE_ERROR("sg_factor must be at least 1\n");
iscsi_trace_error("sg_factor must be at least 1\n");
return -1;
}
if (request % sg_factor) {
TRACE_ERROR("request must be a multiple of sg_factor\n");
iscsi_trace_error("request must be a multiple of sg_factor\n");
return -1;
}
if (length % request) {
TRACE_ERROR("length must be a multiple of request\n");
iscsi_trace_error("length must be a multiple of request\n");
return -1;
}
if (length > ((max_lba + 1) * block_len)) {
TRACE_ERROR("attempt to read past device (max length %u)\n", max_lba * block_len);
iscsi_trace_error("attempt to read past device (max length %u)\n", max_lba * block_len);
return -1;
}
if ((sg = iscsi_malloc(sg_factor * sizeof(struct iovec))) == NULL) {
TRACE_ERROR("out of memory\n");
iscsi_trace_error("out of memory\n");
return -1;
}
if ((data = iscsi_malloc(sg_factor * sizeof(uint8_t *))) == NULL) {
TRACE_ERROR("out of memory\n");
iscsi_trace_error("out of memory\n");
return -1;
}
for (i = 0; i < sg_factor; i++) {
if ((data[i] = iscsi_malloc(request / sg_factor)) == NULL) {
TRACE_ERROR("out of memory\n");
iscsi_trace_error("out of memory\n");
return -1;
}
}
@ -475,11 +475,11 @@ throughput_test(uint32_t target, uint32_t lun, uint32_t length, uint32_t request
sg[j].iov_len = request / sg_factor;
}
if (read_or_write(target, lun, block_offset, num_blocks, block_len, (uint8_t *) sg, sg_factor, writing) != 0) {
TRACE_ERROR("read_10() failed\n");
iscsi_trace_error("read_10() failed\n");
goto done;
}
if (verbose && !((i + 1) % verbose)) {
PRINT("%u total bytes %s: this request (lba %u, len %u)\n",
printf("%u total bytes %s: this request (lba %u, len %u)\n",
(i + 1) * request, writing ? "written" : "read", block_offset, num_blocks);
}
}
@ -489,7 +489,7 @@ throughput_test(uint32_t target, uint32_t lun, uint32_t length, uint32_t request
/* Output results */
PRINT("%u MB %s in %.2f seconds --> %.2f MB/sec\n", length / 1048576, writing ? "written" : "read", (double) seconds,
printf("%u MB %s in %.2f seconds --> %.2f MB/sec\n", length / 1048576, writing ? "written" : "read", (double) seconds,
(double) (length / seconds) / 1048576);
done: for (i = 0; i < sg_factor; i++) {
@ -513,38 +513,38 @@ integrity_test(uint32_t target, uint32_t lun, uint32_t length, int sg_factor)
/* Get device block len & capacity; and check args */
if (read_capacity(target, lun, &max_lba, &block_len) != 0) {
TRACE_ERROR("read_capacity() failed\n");
iscsi_trace_error("read_capacity() failed\n");
return -1;
}
if (length % block_len) {
TRACE_ERROR("length must be a multiple of block len %u\n", block_len);
iscsi_trace_error("length must be a multiple of block len %u\n", block_len);
return -1;
}
if (!sg_factor) {
TRACE_ERROR("sg_factor must be at least 1\n");
iscsi_trace_error("sg_factor must be at least 1\n");
return -1;
}
if (length % sg_factor) {
TRACE_ERROR("length must be a multiple of sg_factor\n");
iscsi_trace_error("length must be a multiple of sg_factor\n");
return -1;
}
if (length > ((max_lba + 1) * block_len)) {
TRACE_ERROR("attempt to read past device (max length %u)\n", max_lba * block_len);
iscsi_trace_error("attempt to read past device (max length %u)\n", max_lba * block_len);
return -1;
}
/* Allocate sg and data buffers; fill data buffers with pattern */
if ((sg = iscsi_malloc(sg_factor * sizeof(struct iovec))) == NULL) {
TRACE_ERROR("out of memory\n");
iscsi_trace_error("out of memory\n");
return -1;
}
if ((data = iscsi_malloc(sg_factor * sizeof(uint8_t *))) == NULL) {
TRACE_ERROR("out of memory\n");
iscsi_trace_error("out of memory\n");
return -1;
}
for (i = 0; i < sg_factor; i++) {
if ((data[i] = iscsi_malloc(length / sg_factor)) == NULL) {
TRACE_ERROR("out of memory\n");
iscsi_trace_error("out of memory\n");
return -1;
}
for (j = 0; j < (length / sg_factor); j++) {
@ -560,14 +560,14 @@ integrity_test(uint32_t target, uint32_t lun, uint32_t length, int sg_factor)
sg[j].iov_len = length / sg_factor;
}
if (read_or_write(target, lun, 0, length / block_len, block_len, (uint8_t *) sg, sg_factor, 1) != 0) {
TRACE_ERROR("read_or_write() failed\n");
iscsi_trace_error("read_or_write() failed\n");
goto done;
}
for (i = 0; i < sg_factor; i++) {
for (j = 0; j < (length / sg_factor); j++) {
/* if (data[i][j] != (uint8_t)(i+j)) { */
if (data[i][j] != (uint8_t) (i + 1)) {
TRACE_ERROR("Bad byte data[%i][%i]: got %u, expected %u\n", i, j, data[i][j], (uint8_t) (i + j));
iscsi_trace_error("Bad byte data[%i][%i]: got %u, expected %u\n", i, j, data[i][j], (uint8_t) (i + j));
goto done;
}
}
@ -581,14 +581,14 @@ integrity_test(uint32_t target, uint32_t lun, uint32_t length, int sg_factor)
sg[j].iov_len = length / sg_factor;
}
if (read_or_write(target, lun, 0, length / block_len, block_len, (uint8_t *) sg, sg_factor, 0) != 0) {
TRACE_ERROR("read_or_write() failed\n");
iscsi_trace_error("read_or_write() failed\n");
goto done;
}
for (i = 0; i < sg_factor; i++) {
for (j = 0; j < (length / sg_factor); j++) {
/* if (data[i][j] != (uint8_t)(i+j)) { */
if (data[i][j] != (uint8_t) (i + 1)) {
TRACE_ERROR("Bad byte data[%i][%i]: got %u, expected %u\n", i, j, data[i][j], (uint8_t) (i + j));
iscsi_trace_error("Bad byte data[%i][%i]: got %u, expected %u\n", i, j, data[i][j], (uint8_t) (i + j));
goto done;
}
}
@ -613,7 +613,7 @@ nop_test(uint32_t target, uint32_t lun, uint32_t iters)
int i, j, k;
if ((data = iscsi_malloc(4096)) == NULL) {
TRACE_ERROR("iscsi_malloc() failed\n");
iscsi_trace_error("iscsi_malloc() failed\n");
return -1;
}
/* Fill with some pattern */
@ -627,7 +627,7 @@ nop_test(uint32_t target, uint32_t lun, uint32_t iters)
gettimeofday(&t_start, 0);
for (i = 0; i < iters; i++) {
if (nop_out(target, lun, j, k, data) != 0) {
TRACE_ERROR("nop_out() failed\n");
iscsi_trace_error("nop_out() failed\n");
return -1;
}
}
@ -635,7 +635,7 @@ nop_test(uint32_t target, uint32_t lun, uint32_t iters)
/* Output results */
PRINT("NOP_OUT (%4i bytes, ping = %i): %u iters in %.2f sec --> %.2f usec\n", j, k,
printf("NOP_OUT (%4i bytes, ping = %i): %u iters in %.2f sec --> %.2f usec\n", j, k,
iters, toSeconds(t_stop) - toSeconds(t_start),
((toSeconds(t_stop) - toSeconds(t_start)) * 1e6) / iters);
if (!j)
@ -669,16 +669,16 @@ latency_test(uint64_t target, uint32_t lun, uint8_t op, uint32_t iters)
if ((op == WRITE_10) || (op == READ_10)) {
if (read_capacity(target, lun, &max_lba, &block_len) != 0) {
TRACE_ERROR("read_capacity() failed\n");
iscsi_trace_error("read_capacity() failed\n");
return -1;
}
if ((data = iscsi_malloc(block_len)) == NULL) {
TRACE_ERROR("out of memory\n");
iscsi_trace_error("out of memory\n");
return -1;
}
} else {
if ((data = iscsi_malloc(1024)) == NULL) {
TRACE_ERROR("out of memory\n");
iscsi_trace_error("out of memory\n");
return -1;
}
}
@ -755,7 +755,7 @@ latency_test(uint64_t target, uint32_t lun, uint8_t op, uint32_t iters)
#endif
break;
default:
TRACE_ERROR("op 0x%x not implemented\n", op);
iscsi_trace_error("op 0x%x not implemented\n", op);
return -1;
}
@ -779,11 +779,11 @@ latency_test(uint64_t target, uint32_t lun, uint8_t op, uint32_t iters)
gettimeofday(&t_start, 0);
for (i = 0; i < iters; i++) {
if (initiator_command(&cmd) != 0) {
TRACE_ERROR("initiator_command() failed\n");
iscsi_trace_error("initiator_command() failed\n");
goto done;
}
if (args.status) {
TRACE_ERROR("scsi_command() failed (status 0x%x)\n", args.status);
iscsi_trace_error("scsi_command() failed (status 0x%x)\n", args.status);
goto done;
}
}
@ -791,7 +791,7 @@ latency_test(uint64_t target, uint32_t lun, uint8_t op, uint32_t iters)
/* Output results */
PRINT("SCSI op 0x%2x: %u iters in %.2f sec --> %.2f usec\n",
printf("SCSI op 0x%2x: %u iters in %.2f sec --> %.2f usec\n",
op, iters, toSeconds(t_stop) - toSeconds(t_start),
((toSeconds(t_stop) - toSeconds(t_start)) * 1e6) / iters);
@ -833,7 +833,7 @@ scatter_gather_test(uint64_t target, uint32_t lun, uint8_t op)
/* Number of iterations (xfer_chunk bytes read/written per iteration) */
if (xfer_size % xfer_chunk) {
TRACE_ERROR("xfer_size (%i) is not a multiple of xfer_chunk (%i)\n", xfer_size, xfer_chunk);
iscsi_trace_error("xfer_size (%i) is not a multiple of xfer_chunk (%i)\n", xfer_size, xfer_chunk);
return -1;
}
n = xfer_size / xfer_chunk;
@ -841,11 +841,11 @@ scatter_gather_test(uint64_t target, uint32_t lun, uint8_t op)
/* Number of blocks per iteration */
if (read_capacity(target, lun, &max_lba, &block_len) != 0) {
TRACE_ERROR("read_capacity() failed\n");
iscsi_trace_error("read_capacity() failed\n");
return -1;
}
if (xfer_chunk % block_len) {
TRACE_ERROR("xfer_chunk (%i) is not a multiple of block_len (%i)\n", xfer_chunk, block_len);
iscsi_trace_error("xfer_chunk (%i) is not a multiple of block_len (%i)\n", xfer_chunk, block_len);
return -1;
}
len = xfer_chunk / block_len;
@ -867,24 +867,24 @@ scatter_gather_test(uint64_t target, uint32_t lun, uint8_t op)
input = 1;
break;
default:
TRACE_ERROR("scatter/gather test not implemented for SCSI op 0x%x\n", op);
iscsi_trace_error("scatter/gather test not implemented for SCSI op 0x%x\n", op);
return -1;
}
/* Allocate buffers for scatter/gather */
if ((buff = iscsi_malloc(len * sizeof(uint8_t *))) == NULL) {
TRACE_ERROR("out of memory\n");
iscsi_trace_error("out of memory\n");
return -1;
}
for (i = 0; i < len; i++) {
buff[i] = iscsi_malloc(block_len);
if (buff[i] == NULL) {
TRACE_ERROR("out of memory\n");
iscsi_trace_error("out of memory\n");
}
}
if ((sg = iscsi_malloc(len * sizeof(struct iovec))) == NULL) {
TRACE_ERROR("out of memory\n");
iscsi_trace_error("out of memory\n");
return -1;
}
for (i = 0; i < len; i++) {
@ -941,11 +941,11 @@ scatter_gather_test(uint64_t target, uint32_t lun, uint8_t op)
cmd.ptr = &args;
if (initiator_command(&cmd) != 0) {
TRACE_ERROR("initiator_command() failed\n");
iscsi_trace_error("initiator_command() failed\n");
goto done;
}
if (args.status) {
TRACE_ERROR("scsi_command() failed (status 0x%x)\n", args.status);
iscsi_trace_error("scsi_command() failed (status 0x%x)\n", args.status);
goto done;
}
}
@ -980,57 +980,57 @@ osd_tests(int target, int lun)
uint16_t len;
if (osd_create_group((void *) &dev, &osd_command, &GroupID) != 0) {
TRACE_ERROR("osd_create_group() failed\n");
iscsi_trace_error("osd_create_group() failed\n");
return -1;
}
PRINT("OSD_CREATE_GROUP: PASSED\n");
printf("OSD_CREATE_GROUP: PASSED\n");
if (osd_create((void *) &dev, GroupID, &osd_command, &UserID) != 0) {
TRACE_ERROR("osd_create() failed\n");
iscsi_trace_error("osd_create() failed\n");
return -1;
}
PRINT("OSD_CREATE: PASSED\n");
printf("OSD_CREATE: PASSED\n");
if (osd_write((void *) &dev, GroupID, UserID, 0, 13, "Hello, World!", 0, &osd_command) != 0) {
TRACE_ERROR("osd_write() failed\n");
iscsi_trace_error("osd_write() failed\n");
return -1;
}
PRINT("OSD_WRITE: PASSED\n");
printf("OSD_WRITE: PASSED\n");
if (osd_read((void *) &dev, GroupID, UserID, 0, 13, buffer, 0, &osd_command) != 0) {
TRACE_ERROR("osd_write() failed\n");
iscsi_trace_error("osd_write() failed\n");
}
if (strncmp(buffer, "Hello, World!", 13)) {
TRACE_ERROR("osd_read() failed\n");
iscsi_trace_error("osd_read() failed\n");
return -1;
}
PRINT("OSD_READ: PASSED\n");
printf("OSD_READ: PASSED\n");
if (osd_set_one_attr((void *) &dev, GroupID, UserID, 0x30000000, 0x1, 480, buffer, &osd_command) != 0) {
TRACE_ERROR("osd_write() failed\n");
iscsi_trace_error("osd_write() failed\n");
}
PRINT("OSD_SET_ATTR: PASSED\n");
printf("OSD_SET_ATTR: PASSED\n");
if (osd_get_one_attr((void *) &dev, GroupID, UserID, 0x30000000, 0, 480, &osd_command, &len, buffer) != 0) {
TRACE_ERROR("osd_get_one_attr() failed\n");
iscsi_trace_error("osd_get_one_attr() failed\n");
}
if (strncmp(buffer, "Hello, World!", 13)) {
TRACE_ERROR("osd_read() failed\n");
iscsi_trace_error("osd_read() failed\n");
return -1;
}
PRINT("OSD_GET_ATTR: PASSED\n");
printf("OSD_GET_ATTR: PASSED\n");
if (osd_remove((void *) &dev, GroupID, UserID, &osd_command) != 0) {
TRACE_ERROR("osd_remove() failed\n");
iscsi_trace_error("osd_remove() failed\n");
return -1;
}
PRINT("OSD_REMOVE: PASSED\n");
printf("OSD_REMOVE: PASSED\n");
if (osd_remove_group((void *) &dev, GroupID, &osd_command) != 0) {
TRACE_ERROR("osd_remove_group() failed\n");
iscsi_trace_error("osd_remove_group() failed\n");
return -1;
}
PRINT("OSD_REMOVE: PASSED\n");
printf("OSD_REMOVE: PASSED\n");
return 0;
}
@ -1047,48 +1047,48 @@ disk_tests(int target, int lun)
/* Initial Tests */
if (read_capacity(target, lun, &max_lba, &block_len) != 0) {
TRACE_ERROR("read_capacity() failed\n");
iscsi_trace_error("read_capacity() failed\n");
return -1;
}
PRINT("read_capacity PASSED\n");
printf("read_capacity PASSED\n");
if (write_read_test(target, lun, 10) != 0) {
TRACE_ERROR("write_read_test() failed\n");
iscsi_trace_error("write_read_test() failed\n");
return -1;
}
PRINT("write_read_test PASSED\n");
printf("write_read_test PASSED\n");
if (integrity_test(target, lun, max_request_size, 1024) != 0) {
TRACE_ERROR("integrity_test() failed\n");
iscsi_trace_error("integrity_test() failed\n");
return -1;
}
PRINT("integrity_test PASSED\n");
printf("integrity_test PASSED\n");
/* Latency Tests */
if (latency_test(target, lun, READ_10, 1000) != 0) {
TRACE_ERROR("latency_test(READ_10) failed\n");
iscsi_trace_error("latency_test(READ_10) failed\n");
return -1;
}
if (latency_test(target, lun, WRITE_10, 1000) != 0) {
TRACE_ERROR("latency_test(WRITE_10) failed\n");
iscsi_trace_error("latency_test(WRITE_10) failed\n");
return -1;
}
if (latency_test(target, lun, READ_CAPACITY, 1000) != 0) {
TRACE_ERROR("latency_test(READ_CAPACITY) failed\n");
iscsi_trace_error("latency_test(READ_CAPACITY) failed\n");
return -1;
}
/* Throughput Tests */
for (request_size = min_request_size; request_size <= max_request_size; request_size *= 2) {
PRINT("%u bytes/request: ", request_size);
printf("%u bytes/request: ", request_size);
if (throughput_test(target, lun, xfer_size, request_size, (xfer_size / request_size) + 1, 1, 1) != 0) {
TRACE_ERROR("througput_test() failed\n");
iscsi_trace_error("througput_test() failed\n");
return -1;
}
}
for (request_size = min_request_size; request_size <= max_request_size; request_size *= 2) {
PRINT("%u bytes/request: ", request_size);
printf("%u bytes/request: ", request_size);
if (throughput_test(target, lun, xfer_size, request_size, (xfer_size / request_size) + 1, 0, 1) != 0) {
TRACE_ERROR("througput_test() failed\n");
iscsi_trace_error("througput_test() failed\n");
return -1;
}
}
@ -1104,66 +1104,66 @@ test_all(int target, int lun)
/* Initial Tests */
PRINT("##BEGIN INITIAL TESTS[%i:%i]##\n", target, lun);
printf("##BEGIN INITIAL TESTS[%i:%i]##\n", target, lun);
if (nop_out(target, lun, 13, 0, data) != 0) {
TRACE_ERROR("nop_out() failed\n");
iscsi_trace_error("nop_out() failed\n");
return -1;
}
PRINT("nop_out() PASSED\n");
printf("nop_out() PASSED\n");
if (nop_out(target, lun, 13, 1, data) != 0) {
TRACE_ERROR("nop_out() w/ ping failed\n");
iscsi_trace_error("nop_out() w/ ping failed\n");
return -1;
}
PRINT("nop_out() w/ ping PASSED\n");
printf("nop_out() w/ ping PASSED\n");
if (inquiry(target, lun, &device_type) != 0) {
TRACE_ERROR("inquiry() failed\n");
iscsi_trace_error("inquiry() failed\n");
return -1;
}
PRINT("inquiry() PASSED: device type 0x%x\n", device_type);
PRINT("##END INITIAL TESTS[%i:%i]##\n\n", target, lun);
printf("inquiry() PASSED: device type 0x%x\n", device_type);
printf("##END INITIAL TESTS[%i:%i]##\n\n", target, lun);
/* iSCSI Latency Tests */
PRINT("##BEGIN iSCSI LATENCY TESTS[%i:%i]##\n", target, lun);
printf("##BEGIN iSCSI LATENCY TESTS[%i:%i]##\n", target, lun);
if (nop_test(target, lun, 1000) != 0) {
TRACE_ERROR("nop_test() failed\n");
iscsi_trace_error("nop_test() failed\n");
return -1;
}
PRINT("##END iSCSI LATENCY TESTS[%i:%i]##\n\n", target, lun);
printf("##END iSCSI LATENCY TESTS[%i:%i]##\n\n", target, lun);
/* SCSI Latency Tests */
PRINT("##BEGIN SCSI LATENCY TESTS[%i:%i]##\n", target, lun);
printf("##BEGIN SCSI LATENCY TESTS[%i:%i]##\n", target, lun);
if (latency_test(target, lun, TEST_UNIT_READY, 1000) != 0) {
TRACE_ERROR("latency_test(TEST_UNIT_READY) failed\n");
iscsi_trace_error("latency_test(TEST_UNIT_READY) failed\n");
return -1;
}
if (latency_test(target, lun, INQUIRY, 1000) != 0) {
TRACE_ERROR("latency_test(INQUIRY) failed\n");
iscsi_trace_error("latency_test(INQUIRY) failed\n");
return -1;
}
PRINT("##END SCSI LATENCY TESTS[%i:%i]##\n\n", target, lun);
printf("##END SCSI LATENCY TESTS[%i:%i]##\n\n", target, lun);
/* Device-specific tests */
PRINT("##BEGIN DEVICE-SPECIFIC TESTS[%i:%i]##\n", target, lun);
printf("##BEGIN DEVICE-SPECIFIC TESTS[%i:%i]##\n", target, lun);
switch (device_type) {
case 0x00:
if (disk_tests(target, lun) != 0) {
TRACE_ERROR("disk_tests() failed\n");
iscsi_trace_error("disk_tests() failed\n");
return -1;
}
break;
case 0x0e:
if (osd_tests(target, lun) != 0) {
TRACE_ERROR("osd_tests() failed\n");
iscsi_trace_error("osd_tests() failed\n");
return -1;
}
break;
default:
break;
}
PRINT("##END DEVICE-SPECIFIC TESTS[%i:%i]##\n\n", target, lun);
printf("##END DEVICE-SPECIFIC TESTS[%i:%i]##\n\n", target, lun);
return 0;
}
@ -1240,11 +1240,11 @@ osd_command(void *dev, osd_args_t * args, OSD_OPS_MEM * m)
/* Execute initiator_cmd_t */
if (initiator_command(&initiator_cmd) != 0) {
TRACE_ERROR("initiator_command() failed\n");
iscsi_trace_error("initiator_command() failed\n");
return -1;
}
if (scsi_cmd.status != 0) {
TRACE_ERROR("SCSI command failed\n");
iscsi_trace_error("SCSI command failed\n");
return -1;
}
return 0;

88
dist/iscsi/src/usocktest.c vendored
View File

@ -128,12 +128,12 @@ int main(int argc, char *argv[]) {
} else if (!strcmp(argv[i], "-v")) {
i++; sscanf(argv[i], "%u", &VerboseFreq);
} else {
PRINT("Unknown option \"%s\"\n", argv[i]);
PRINT("%s\n", usage);
printf("Unknown option \"%s\"\n", argv[i]);
printf("%s\n", usage);
return -1;
}
}
if (argc == 1) PRINT("%s\n", usage);
if (argc == 1) printf("%s\n", usage);
IsTarget = (strlen(TargetIP)>0)?0:1;
/*
@ -157,16 +157,16 @@ int main(int argc, char *argv[]) {
*/
if (iscsi_sock_create(&iscsi_sock)!=0) {
TRACE_ERROR("iscsi_sock_create() failed\n");
iscsi_trace_error("iscsi_sock_create() failed\n");
return -1;
}
if (IsTarget) {
if (iscsi_sock_bind(iscsi_sock, Port)!=0) {
TRACE_ERROR("iscsi_sock_bind() failed\n");
iscsi_trace_error("iscsi_sock_bind() failed\n");
return -1;
}
if (iscsi_sock_listen(iscsi_sock)!=0) {
TRACE_ERROR("iscsi_sock_listen() failed\n");
iscsi_trace_error("iscsi_sock_listen() failed\n");
return -1;
}
}
@ -177,19 +177,19 @@ int main(int argc, char *argv[]) {
accept:
if (IsTarget) {
PRINT("Waiting for TCP connection on port %u\n", Port);
printf("Waiting for TCP connection on port %u\n", Port);
if(iscsi_sock_accept(iscsi_sock, &iscsi_sock_new)!=0) {
TRACE_ERROR("iscsi_sock_accept() failed\n");
iscsi_trace_error("iscsi_sock_accept() failed\n");
return -1;
}
PRINT("Connection accepted\n");
printf("Connection accepted\n");
} else {
printf("Connecting to %s\n", TargetIP);
if(iscsi_sock_connect(iscsi_sock, TargetIP, Port)!=0) {
TRACE_ERROR("iscsi_sock_connect() failed\n");
iscsi_trace_error("iscsi_sock_connect() failed\n");
return -1;
}
PRINT("Connected\n");
printf("Connected\n");
iscsi_sock_new = iscsi_sock;
}
@ -198,25 +198,25 @@ accept:
*/
if (!IsTarget) {
TRACE(TRACE_DEBUG, "Sending test parameters\n");
iscsi_trace(TRACE_DEBUG, "Sending test parameters\n");
sprintf(ctrlBufferSend, "%s:%s:%s:%s:%i:%i:%i",
HostSendPattern, HostRecvPattern, TargSendPattern, TargRecvPattern,
NumIters, VerboseFreq, Port);
if ((n=iscsi_sock_msg(iscsi_sock_new, 1, ctrlBuffSize, ctrlBufferSend, 0))!=ctrlBuffSize) {
TRACE_ERROR("iscsi_sock_msg() failed\n");
iscsi_trace_error("iscsi_sock_msg() failed\n");
return -1;
}
if ((n=iscsi_sock_msg(iscsi_sock_new, 0, ctrlBuffSize, ctrlBufferRecv, 0))!=ctrlBuffSize) {
TRACE_ERROR("iscsi_sock_msg() failed\n");
iscsi_trace_error("iscsi_sock_msg() failed\n");
return -1;
}
TRACE(TRACE_DEBUG, "Test parameters sent\n");
iscsi_trace(TRACE_DEBUG, "Test parameters sent\n");
} else {
char *ptr, *delim;
TRACE(TRACE_DEBUG, "Receiving test parameters\n");
iscsi_trace(TRACE_DEBUG, "Receiving test parameters\n");
if ((n=iscsi_sock_msg(iscsi_sock_new, 0, ctrlBuffSize, ctrlBufferRecv, 0))!=ctrlBuffSize) {
TRACE_ERROR("iscsi_sock_msg() failed\n");
iscsi_trace_error("iscsi_sock_msg() failed\n");
return -1;
}
ptr = ctrlBufferRecv;
@ -230,10 +230,10 @@ accept:
strncpy(TargRecvPattern, ptr, delim-ptr+1); TargRecvPattern[delim-ptr] = 0x0; ptr = delim+1;
sscanf(ptr, "%i:%i", &NumIters, &VerboseFreq);
if ((n=iscsi_sock_msg(iscsi_sock_new, 1, ctrlBuffSize, ctrlBufferSend, 0))!=ctrlBuffSize) {
TRACE_ERROR("iscsi_sock_msg() failed\n");
iscsi_trace_error("iscsi_sock_msg() failed\n");
return -1;
}
TRACE(TRACE_DEBUG, "Test parameters received\n");
iscsi_trace(TRACE_DEBUG, "Test parameters received\n");
}
/*
@ -243,25 +243,25 @@ accept:
HostSendTotal = 0; for (i=0; i<NumHostSendBuffs; i++) HostSendTotal += HostSendSize[i];
TargRecvTotal = 0; for (i=0; i<NumTargRecvBuffs; i++) TargRecvTotal += TargRecvSize[i];
if (HostSendTotal != TargRecvTotal) {
TRACE_ERROR("Host sending size (%i) > Target receiving size (%i)\n",
iscsi_trace_error("Host sending size (%i) > Target receiving size (%i)\n",
HostSendTotal, TargRecvTotal);
return -1;
}
HostRecvTotal = 0; for (i=0; i<NumHostRecvBuffs; i++) HostRecvTotal += HostRecvSize[i];
TargSendTotal = 0; for (i=0; i<NumTargSendBuffs; i++) TargSendTotal += TargSendSize[i];
if (HostRecvTotal != TargSendTotal) {
TRACE_ERROR("Host receiving size (%i) > Target sending size (%i)\n",
iscsi_trace_error("Host receiving size (%i) > Target sending size (%i)\n",
HostRecvTotal, TargSendTotal);
return -1;
}
TRACE(TRACE_DEBUG, "HostSendPattern: \"%s\"\n", HostSendPattern);
TRACE(TRACE_DEBUG, "HostRecvPattern: \"%s\"\n", HostRecvPattern);
TRACE(TRACE_DEBUG, "TargRecvPattern: \"%s\"\n", TargRecvPattern);
TRACE(TRACE_DEBUG, "TargSendPattern: \"%s\"\n", TargSendPattern);
TRACE(TRACE_DEBUG, "NumIters: %i\n", NumIters);
TRACE(TRACE_DEBUG, "VerboseFreq: %i\n", VerboseFreq);
TRACE(TRACE_DEBUG, "HostSendTotal: %i bytes\n", HostSendTotal);
TRACE(TRACE_DEBUG, "HostRecvTotal: %i bytes\n", HostRecvTotal);
iscsi_trace(TRACE_DEBUG, "HostSendPattern: \"%s\"\n", HostSendPattern);
iscsi_trace(TRACE_DEBUG, "HostRecvPattern: \"%s\"\n", HostRecvPattern);
iscsi_trace(TRACE_DEBUG, "TargRecvPattern: \"%s\"\n", TargRecvPattern);
iscsi_trace(TRACE_DEBUG, "TargSendPattern: \"%s\"\n", TargSendPattern);
iscsi_trace(TRACE_DEBUG, "NumIters: %i\n", NumIters);
iscsi_trace(TRACE_DEBUG, "VerboseFreq: %i\n", VerboseFreq);
iscsi_trace(TRACE_DEBUG, "HostSendTotal: %i bytes\n", HostSendTotal);
iscsi_trace(TRACE_DEBUG, "HostRecvTotal: %i bytes\n", HostRecvTotal);
/*
* Allocate buffers
@ -269,22 +269,22 @@ accept:
for (i=0; i<NumHostSendBuffs; i++)
if ((HostSendBuff[i]=iscsi_malloc(HostSendSize[i]))==NULL) {
TRACE_ERROR("out of memory\n");
iscsi_trace_error("out of memory\n");
return -1;
}
for (i=0; i<NumHostRecvBuffs; i++)
if ((HostRecvBuff[i]=iscsi_malloc(HostRecvSize[i]))==NULL) {
TRACE_ERROR("out of memory\n");
iscsi_trace_error("out of memory\n");
return -1;
}
for (i=0; i<NumTargSendBuffs; i++)
if ((TargSendBuff[i]=iscsi_malloc(TargSendSize[i]))==NULL) {
TRACE_ERROR("out of memory\n");
iscsi_trace_error("out of memory\n");
return -1;
}
for (i=0; i<NumTargRecvBuffs; i++)
if ((TargRecvBuff[i]=iscsi_malloc(TargRecvSize[i]))==NULL) {
TRACE_ERROR("out of memory\n");
iscsi_trace_error("out of memory\n");
return -1;
}
@ -296,27 +296,27 @@ accept:
gettimeofday(&t_start, 0);
for (i=0; i<NumIters; i++) {
TRACE(TRACE_DEBUG, "begin iteration %i\n", i);
iscsi_trace(TRACE_DEBUG, "begin iteration %i\n", i);
if (!IsTarget) {
/* Send to target */
for (j=0; j<NumHostSendBuffs; j++) {
if (iscsi_sock_msg(iscsi_sock_new, 1, HostSendSize[j], HostSendBuff[j], 0)!= HostSendSize[j]) {
TRACE_ERROR("iscsi_sock_msg() failed\n");
iscsi_trace_error("iscsi_sock_msg() failed\n");
return -1;
}
TRACE(TRACE_DEBUG, "Tx HostSendBuff[%i] (size %i)\n", j, HostSendSize[j]);
iscsi_trace(TRACE_DEBUG, "Tx HostSendBuff[%i] (size %i)\n", j, HostSendSize[j]);
}
/* Recv from target */
for (j=0; j<NumHostRecvBuffs; j++) {
if (iscsi_sock_msg(iscsi_sock_new, 0, HostRecvSize[j], HostRecvBuff[j], 0)!= HostRecvSize[j]) {
TRACE_ERROR("iscsi_sock_msg() failed\n");
iscsi_trace_error("iscsi_sock_msg() failed\n");
return -1;
}
TRACE(TRACE_DEBUG, "Rx HostRecvBuff[%i] (size %i)\n", j, HostRecvSize[j]);
iscsi_trace(TRACE_DEBUG, "Rx HostRecvBuff[%i] (size %i)\n", j, HostRecvSize[j]);
}
} else {
@ -324,27 +324,27 @@ accept:
for (j=0; j<NumTargRecvBuffs; j++) {
if (iscsi_sock_msg(iscsi_sock_new, 0, TargRecvSize[j], TargRecvBuff[j], 0)!= TargRecvSize[j]) {
TRACE_ERROR("iscsi_sock_msg() failed\n");
iscsi_trace_error("iscsi_sock_msg() failed\n");
return -1;
}
TRACE(TRACE_DEBUG, "Rx TargRecvBuff[%i] (size %i)\n", j, TargRecvSize[j]);
iscsi_trace(TRACE_DEBUG, "Rx TargRecvBuff[%i] (size %i)\n", j, TargRecvSize[j]);
}
/* Send to host */
for (j=0; j<NumTargSendBuffs; j++) {
if (iscsi_sock_msg(iscsi_sock_new, 1, TargSendSize[j], TargSendBuff[j], 0)!= TargSendSize[j]) {
TRACE_ERROR("iscsi_sock_msg() failed\n");
iscsi_trace_error("iscsi_sock_msg() failed\n");
return -1;
}
TRACE(TRACE_DEBUG, "Tx TargSendBuff[%i] (size %i)\n", j, TargSendSize[j]);
iscsi_trace(TRACE_DEBUG, "Tx TargSendBuff[%i] (size %i)\n", j, TargSendSize[j]);
}
}
if ((!IsTarget)&&((i+1)%VerboseFreq==0)) {
PRINT("Iter %i: %i total bytes sent, %i total bytes recv\n",
printf("Iter %i: %i total bytes sent, %i total bytes recv\n",
i+1, HostSendTotal*(i+1), HostRecvTotal*(i+1));
}
TRACE(TRACE_DEBUG, "end iteration %i\n", i);
iscsi_trace(TRACE_DEBUG, "end iteration %i\n", i);
}
gettimeofday(&t_stop, 0);

10
dist/iscsi/src/utest.c vendored
View File

@ -107,7 +107,7 @@ main(int argc, char *argv[])
}
if (target != -1) {
if (target >= CONFIG_INITIATOR_NUM_TARGETS) {
TRACE_ERROR("initiator only configured with %i targets\n", CONFIG_INITIATOR_NUM_TARGETS);
iscsi_trace_error("initiator only configured with %i targets\n", CONFIG_INITIATOR_NUM_TARGETS);
exit(EXIT_FAILURE);
}
tgtlo = target;
@ -119,7 +119,7 @@ main(int argc, char *argv[])
}
for (j = 0; j < iterations; j++) {
PRINT("<ITERATION %i>\n", j);
printf("<ITERATION %i>\n", j);
/* Ignore sigpipe */
@ -128,14 +128,14 @@ main(int argc, char *argv[])
/* Initialize Initiator */
if (initiator_init(host) == -1) {
TRACE_ERROR("initiator_init() failed\n");
iscsi_trace_error("initiator_init() failed\n");
return -1;
}
/* Run tests for each target */
for (i = tgtlo; i < tgthi; i++) {
if (test_all(i, lun) != 0) {
TRACE_ERROR("test_all() failed\n");
iscsi_trace_error("test_all() failed\n");
return -1;
}
}
@ -143,7 +143,7 @@ main(int argc, char *argv[])
/* Shutdown Initiator */
if (initiator_shutdown() == -1) {
TRACE_ERROR("initiator_shutdown() failed\n");
iscsi_trace_error("initiator_shutdown() failed\n");
return -1;
}
}

200
dist/iscsi/src/util.c vendored
View File

@ -98,7 +98,7 @@ iscsi_malloc_atomic(unsigned n)
void *ptr;
ptr = malloc(n);
TRACE(TRACE_MEM, "iscsi_malloc_atomic(%i) = 0x%p\n", n, ptr);
iscsi_trace(TRACE_MEM, "iscsi_malloc_atomic(%i) = 0x%p\n", n, ptr);
return ptr;
}
@ -108,7 +108,7 @@ iscsi_malloc(unsigned n)
void *ptr;
ptr = malloc(n);
TRACE(TRACE_MEM, "iscsi_malloc_atomic(%i) = 0x%p\n", n, ptr);
iscsi_trace(TRACE_MEM, "iscsi_malloc_atomic(%i) = 0x%p\n", n, ptr);
return ptr;
}
@ -116,14 +116,14 @@ void
iscsi_free_atomic(void *ptr)
{
(void) free(ptr);
TRACE(TRACE_MEM, "iscsi_free_atomic(0x%p)\n", ptr);
iscsi_trace(TRACE_MEM, "iscsi_free_atomic(0x%p)\n", ptr);
}
void
iscsi_free(void *ptr)
{
(void) free(ptr);
TRACE(TRACE_MEM, "iscsi_free(0x%p)\n", ptr);
iscsi_trace(TRACE_MEM, "iscsi_free(0x%p)\n", ptr);
}
/* debugging levels */
@ -150,11 +150,11 @@ int
iscsi_thread_create(iscsi_thread_t * thread, void *(*proc) (void *), void *arg)
{
if (pthread_create(&thread->pthread, NULL, proc, arg) != 0) {
TRACE_ERROR("pthread_create() failed\n");
iscsi_trace_error("pthread_create() failed\n");
return -1;
}
if (pthread_detach(thread->pthread) != 0) {
TRACE_ERROR("pthread_detach() failed\n");
iscsi_trace_error("pthread_detach() failed\n");
return -1;
}
return 0;
@ -169,7 +169,7 @@ iscsi_queue_init(iscsi_queue_t * q, int depth)
q->head = q->tail = q->count = 0;
q->depth = depth;
if ((q->elem = iscsi_malloc_atomic(depth * sizeof(void *))) == NULL) {
TRACE_ERROR("iscsi_malloc_atomic() failed\n");
iscsi_trace_error("iscsi_malloc_atomic() failed\n");
return -1;
}
iscsi_spin_init(&q->lock);
@ -201,7 +201,7 @@ iscsi_queue_insert(iscsi_queue_t * q, void *ptr)
iscsi_spin_lock_irqsave(&q->lock, &flags);
if (iscsi_queue_full(q)) {
TRACE_ERROR("QUEUE FULL\n");
iscsi_trace_error("QUEUE FULL\n");
iscsi_spin_unlock_irqrestore(&q->lock, &flags);
return -1;
}
@ -222,7 +222,7 @@ iscsi_queue_remove(iscsi_queue_t * q)
uint32_t flags = 0;
iscsi_spin_lock_irqsave(&q->lock, &flags);
if (!iscsi_queue_depth(q)) {
TRACE(TRACE_QUEUE, "QUEUE EMPTY\n");
iscsi_trace(TRACE_QUEUE, "QUEUE EMPTY\n");
iscsi_spin_unlock_irqrestore(&q->lock, &flags);
return NULL;
}
@ -236,6 +236,84 @@ iscsi_queue_remove(iscsi_queue_t * q)
return ptr;
}
void
iscsi_trace(const int trace, const char *fmt, ...)
{
#ifdef CONFIG_ISCSI_DEBUG
va_list vp;
char buf[8192];
if (iscsi_debug_level & trace) {
va_start(vp, fmt);
(void) snprintf(buf, sizeof(buf), fmt, vp);
printf("pid %i:%s:%d: %s",
ISCSI_GETPID, __FILE__, __LINE__,
buf);
va_end(vp);
}
#endif
}
void
iscsi_trace_warning(const char *fmt, ...)
{
#ifdef CONFIG_ISCSI_DEBUG
va_list vp;
char buf[8192];
if (iscsi_debug_level & TRACE_WARN) {
va_start(vp, fmt);
(void) snprintf(buf, sizeof(buf), fmt, vp);
printf("pid %i:%s:%d: ***WARNING*** %s",
ISCSI_GETPID, __FILE__, __LINE__,
buf);
va_end(vp);
}
#endif
}
void
iscsi_trace_error(const char *fmt, ...)
{
#ifdef CONFIG_ISCSI_DEBUG
va_list vp;
char buf[8192];
va_start(vp, fmt);
(void) snprintf(buf, sizeof(buf), fmt, vp);
va_end(vp);
printf("pid %i:%s:%d: ***WARNING*** %s",
ISCSI_GETPID, __FILE__, __LINE__,
buf);
syslog(LOG_ERR, "pid %d:%s:%d: ***ERROR*** %s",
ISCSI_GETPID, __FILE__, __LINE__,
buf);
#endif
}
void
iscsi_print_buffer(const char *buf, const size_t len)
{
#ifdef CONFIG_ISCSI_DEBUG
int i;
if (iscsi_debug_level & TRACE_NET_BUFF) {
for (i=0 ; i < len; i++) {
if (i % 4 == 0) {
if (i) {
printf("\n");
}
printf("%4i:", i);
}
printf("%2x ", (uint8_t) (buf)[i]);
}
if ((len + 1) % 32) {
printf("\n");
}
}
#endif
}
/*
* Hashing Functions
*/
@ -251,7 +329,7 @@ hash_init(hash_t * h, int n)
h->insertions = 0;
h->collisions = 0;
if ((h->bucket = iscsi_malloc_atomic(n * sizeof(initiator_cmd_t *))) == NULL) {
TRACE_ERROR("iscsi_malloc_atomic() failed\n");
iscsi_trace_error("iscsi_malloc_atomic() failed\n");
return -1;
}
for (i = 0; i < n; i++)
@ -270,13 +348,13 @@ hash_insert(hash_t * h, initiator_cmd_t * cmd, unsigned key)
i = key % (h->n);
if (h->bucket[i] == NULL) {
TRACE(TRACE_HASH, "inserting key %u (val 0x%p) into bucket[%i]\n", key, cmd, i);
iscsi_trace(TRACE_HASH, "inserting key %u (val 0x%p) into bucket[%i]\n", key, cmd, i);
h->bucket[i] = cmd;
} else {
cmd->hash_next = h->bucket[i];
h->bucket[i] = cmd;
h->collisions++;
TRACE(TRACE_HASH, "inserting key %u (val 0x%p) into bucket[%i] (collision)\n", key, cmd, i);
iscsi_trace(TRACE_HASH, "inserting key %u (val 0x%p) into bucket[%i] (collision)\n", key, cmd, i);
}
h->insertions++;
iscsi_spin_unlock(&h->lock);
@ -293,7 +371,7 @@ hash_remove(hash_t * h, unsigned key)
iscsi_spin_lock(&h->lock);
i = key % (h->n);
if (h->bucket[i] == NULL) {
TRACE_ERROR("bucket emtpy\n");
iscsi_trace_error("bucket emtpy\n");
curr = NULL;
} else {
prev = NULL;
@ -303,18 +381,18 @@ hash_remove(hash_t * h, unsigned key)
curr = curr->hash_next;
}
if (curr->key != key) {
TRACE_ERROR("key %u (0x%x) not found in bucket[%i]\n", key, key, i);
iscsi_trace_error("key %u (0x%x) not found in bucket[%i]\n", key, key, i);
curr = NULL;
} else {
if (prev == NULL) {
h->bucket[i] = h->bucket[i]->hash_next;
TRACE(TRACE_HASH, "removed key %u (val 0x%p) from head of bucket\n", key, curr);
iscsi_trace(TRACE_HASH, "removed key %u (val 0x%p) from head of bucket\n", key, curr);
} else {
prev->hash_next = curr->hash_next;
if (prev->hash_next == NULL) {
TRACE(TRACE_HASH, "removed key %u (val 0x%p) from end of bucket\n", key, curr);
iscsi_trace(TRACE_HASH, "removed key %u (val 0x%p) from end of bucket\n", key, curr);
} else {
TRACE(TRACE_HASH, "removed key %u (val 0x%p) from middle of bucket\n", key, curr);
iscsi_trace(TRACE_HASH, "removed key %u (val 0x%p) from middle of bucket\n", key, curr);
}
}
}
@ -348,13 +426,13 @@ modify_iov(struct iovec ** iov_ptr, int *iovc, uint32_t offset, uint32_t length)
for (i = 0; i < *iovc; i++) {
len += iov[i].iov_len;
if (len > offset) {
TRACE(TRACE_NET_IOV, "found offset %u in iov[%i]\n", offset, i);
iscsi_trace(TRACE_NET_IOV, "found offset %u in iov[%i]\n", offset, i);
break;
}
disp -= iov[i].iov_len;
}
if (i == *iovc) {
TRACE_ERROR("sum of iov lens (%u) < offset (%u)\n", len, offset);
iscsi_trace_error("sum of iov lens (%u) < offset (%u)\n", len, offset);
return -1;
}
iov[i].iov_len -= disp;
@ -374,14 +452,14 @@ modify_iov(struct iovec ** iov_ptr, int *iovc, uint32_t offset, uint32_t length)
for (i = 0; i < *iovc; i++) {
len += iov[i].iov_len;
if (len >= length) {
TRACE(TRACE_NET_IOV, "length %u ends in iovec[%i]\n", length, i);
iscsi_trace(TRACE_NET_IOV, "length %u ends in iovec[%i]\n", length, i);
break;
}
}
if (i == *iovc) {
TRACE_ERROR("sum of iovec lens (%u) < length (%u)\n", len, length);
iscsi_trace_error("sum of iovec lens (%u) < length (%u)\n", len, length);
for (i = 0; i < *iovc; i++) {
TRACE_ERROR("iov[%i].iov_base = %p (len %u)\n", i, iov[i].iov_base, (unsigned)iov[i].iov_len);
iscsi_trace_error("iov[%i].iov_base = %p (len %u)\n", i, iov[i].iov_base, (unsigned)iov[i].iov_len);
}
return -1;
}
@ -389,13 +467,13 @@ modify_iov(struct iovec ** iov_ptr, int *iovc, uint32_t offset, uint32_t length)
*iovc = i + 1;
#ifdef CONFIG_ISCSI_DEBUG
TRACE(TRACE_NET_IOV, "new iov:\n");
iscsi_trace(TRACE_NET_IOV, "new iov:\n");
len = 0;
for (i = 0; i < *iovc; i++) {
TRACE(TRACE_NET_IOV, "iov[%i].iov_base = %p (len %u)\n", i, iov[i].iov_base, (unsigned)iov[i].iov_len);
iscsi_trace(TRACE_NET_IOV, "iov[%i].iov_base = %p (len %u)\n", i, iov[i].iov_base, (unsigned)iov[i].iov_len);
len += iov[i].iov_len;
}
TRACE(TRACE_NET_IOV, "new iov length: %u bytes\n", len);
iscsi_trace(TRACE_NET_IOV, "new iov length: %u bytes\n", len);
#endif
return 0;
@ -407,7 +485,7 @@ iscsi_sock_setsockopt(iscsi_socket_t * sock, int level, int optname, void *optva
int rc;
if ((rc = setsockopt(*sock, level, optname, optval, optlen)) != 0) {
TRACE_ERROR("sock->ops->setsockopt() failed: rc %i errno %i\n", rc, errno);
iscsi_trace_error("sock->ops->setsockopt() failed: rc %i errno %i\n", rc, errno);
return -1;
}
return 0;
@ -419,7 +497,7 @@ iscsi_sock_getsockopt(iscsi_socket_t * sock, int level, int optname, void *optva
int rc;
if ((rc = getsockopt(*sock, level, optname, optval, optlen)) != 0) {
TRACE_ERROR("sock->ops->getsockopt() failed: rc %i errno %i\n", rc, errno);
iscsi_trace_error("sock->ops->getsockopt() failed: rc %i errno %i\n", rc, errno);
return -1;
}
return 0;
@ -431,11 +509,11 @@ iscsi_sock_create(iscsi_socket_t * sock)
int rc;
if ((rc = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
TRACE_ERROR("socket() failed: rc %i errno %i\n", rc, errno);
iscsi_trace_error("socket() failed: rc %i errno %i\n", rc, errno);
}
*sock = rc;
if (rc < 0) {
TRACE_ERROR("error creating socket (rc %i)\n", rc);
iscsi_trace_error("error creating socket (rc %i)\n", rc);
return -1;
}
return 0;
@ -452,7 +530,7 @@ iscsi_sock_bind(iscsi_socket_t sock, int port)
laddr.sin_addr.s_addr = INADDR_ANY;
laddr.sin_port = ISCSI_HTON16(port);
if ((rc = bind(sock, (struct sockaddr *) (void *) &laddr, sizeof(laddr))) < 0) {
TRACE_ERROR("bind() failed: rc %i errno %i\n", rc, errno);
iscsi_trace_error("bind() failed: rc %i errno %i\n", rc, errno);
return -1;
}
return 0;
@ -464,7 +542,7 @@ iscsi_sock_listen(iscsi_socket_t sock)
int rc;
if ((rc = listen(sock, 32)) < 0) {
TRACE_ERROR("listen() failed: rc %i errno %i\n", rc, errno);
iscsi_trace_error("listen() failed: rc %i errno %i\n", rc, errno);
return -1;
}
return 0;
@ -479,7 +557,7 @@ iscsi_sock_accept(iscsi_socket_t sock, iscsi_socket_t * newsock)
remoteAddrLen = sizeof(remoteAddr);
(void) memset(&remoteAddr, 0, sizeof(remoteAddr));
if ((*newsock = accept(sock, (struct sockaddr *) (void *)& remoteAddr, &remoteAddrLen)) < 0) {
TRACE(TRACE_NET_DEBUG, "accept() failed: rc %i errno %i\n", *newsock, errno);
iscsi_trace(TRACE_NET_DEBUG, "accept() failed: rc %i errno %i\n", *newsock, errno);
return -1;
}
@ -490,7 +568,7 @@ int
iscsi_sock_getsockname(iscsi_socket_t sock, struct sockaddr * name, unsigned *namelen)
{
if (getsockname(sock, name, namelen) != 0) {
TRACE_ERROR("getsockame() failed (errno %i)\n", errno);
iscsi_trace_error("getsockame() failed (errno %i)\n", errno);
return -1;
}
return 0;
@ -500,7 +578,7 @@ int
iscsi_sock_getpeername(iscsi_socket_t sock, struct sockaddr * name, unsigned *namelen)
{
if (getpeername(sock, name, namelen) != 0) {
TRACE_ERROR("getpeername() failed (errno %i)\n", errno);
iscsi_trace_error("getpeername() failed (errno %i)\n", errno);
return -1;
}
return 0;
@ -512,7 +590,7 @@ iscsi_sock_shutdown(iscsi_socket_t sock, int how)
int rc;
if ((rc = shutdown(sock, how)) != 0) {
TRACE(TRACE_NET_DEBUG, "shutdown() failed: rc %i, errno %i\n", rc, errno);
iscsi_trace(TRACE_NET_DEBUG, "shutdown() failed: rc %i, errno %i\n", rc, errno);
}
return 0;
}
@ -523,7 +601,7 @@ iscsi_sock_close(iscsi_socket_t sock)
int rc;
if ((rc = close(sock)) != 0) {
TRACE_ERROR("close() failed: rc %i errno %i\n", rc, errno);
iscsi_trace_error("close() failed: rc %i errno %i\n", rc, errno);
return -1;
}
return 0;
@ -548,14 +626,14 @@ iscsi_sock_connect(iscsi_socket_t sock, char *hostname, int port)
addr.sin_addr.s_addr = inet_addr(hostname);
#if ISCSI_SOCK_CONNECT_NONBLOCK == 1
if (fcntl(sock, F_SETFL, O_NONBLOCK) != 0) {
TRACE_ERROR("fcntl() failed");
iscsi_trace_error("fcntl() failed");
return -1;
}
#endif
rc = connect(sock, (struct sockaddr *) (void *) &addr, sizeof(addr));
#if ISCSI_SOCK_CONNECT_NONBLOCK == 1
if (fcntl(sock, F_SETFL, O_SYNC) != 0) {
TRACE_ERROR("fcntl() failed\n");
iscsi_trace_error("fcntl() failed\n");
return -1;
}
#endif
@ -568,7 +646,7 @@ iscsi_sock_connect(iscsi_socket_t sock, char *hostname, int port)
}
if (errno == EAGAIN || errno == EINPROGRESS || errno == EALREADY) {
if (i != ISCSI_SOCK_CONNECT_TIMEOUT - 1) {
PRINT("***SLEEPING***\n");
printf("***SLEEPING***\n");
ISCSI_SLEEP(1);
}
} else {
@ -576,7 +654,7 @@ iscsi_sock_connect(iscsi_socket_t sock, char *hostname, int port)
}
}
if (rc < 0) {
TRACE_ERROR("connect() to %s:%i failed (errno %i)\n", hostname, port, errno);
iscsi_trace_error("connect() to %s:%i failed (errno %i)\n", hostname, port, errno);
}
return rc;
}
@ -600,9 +678,9 @@ iscsi_sock_msg(iscsi_socket_t sock, int xmit, unsigned len, void *data, int iovc
uint32_t padding_len = 0;
int total_len = 0;
TRACE(TRACE_NET_DEBUG, "%s %i bytes on sock\n", xmit ? "sending" : "receiving", len);
iscsi_trace(TRACE_NET_DEBUG, "%s %i bytes on sock\n", xmit ? "sending" : "receiving", len);
if (iovc == 0) {
TRACE(TRACE_NET_DEBUG, "building singleton iovec (data %p, len %u)\n", data, len);
iscsi_trace(TRACE_NET_DEBUG, "building singleton iovec (data %p, len %u)\n", data, len);
singleton.iov_base = data;
singleton.iov_len = len;
iov = &singleton;
@ -615,7 +693,7 @@ iscsi_sock_msg(iscsi_socket_t sock, int xmit, unsigned len, void *data, int iovc
if ((remainder = len % ISCSI_SOCK_MSG_BYTE_ALIGN) != 0) {
if ((iov_padding = iscsi_malloc_atomic((iovc + 1) * sizeof(struct iovec))) == NULL) {
TRACE_ERROR("iscsi_malloc_atomic() failed\n");
iscsi_trace_error("iscsi_malloc_atomic() failed\n");
return -1;
}
memcpy(iov_padding, iov, iovc * sizeof(struct iovec));
@ -626,7 +704,7 @@ iscsi_sock_msg(iscsi_socket_t sock, int xmit, unsigned len, void *data, int iovc
iovc++;
memset(padding, 0, padding_len);
len += padding_len;
TRACE(TRACE_NET_DEBUG, "Added iovec for padding (len %u)\n", padding_len);
iscsi_trace(TRACE_NET_DEBUG, "Added iovec for padding (len %u)\n", padding_len);
}
/*
* We make copy of iovec if we're in debugging mode, as we'll print
@ -641,47 +719,47 @@ iscsi_sock_msg(iscsi_socket_t sock, int xmit, unsigned len, void *data, int iovc
/* Check iovec */
total_len = 0;
TRACE(TRACE_NET_DEBUG, "%s %i buffers\n", xmit ? "gathering from" : "scattering into", iovc);
iscsi_trace(TRACE_NET_DEBUG, "%s %i buffers\n", xmit ? "gathering from" : "scattering into", iovc);
for (i = 0; i < iovc; i++) {
TRACE(TRACE_NET_IOV, "iov[%i].iov_base = %p, len %u\n", i, iov[i].iov_base, (unsigned)iov[i].iov_len);
iscsi_trace(TRACE_NET_IOV, "iov[%i].iov_base = %p, len %u\n", i, iov[i].iov_base, (unsigned)iov[i].iov_len);
total_len += iov[i].iov_len;
}
if (total_len != len - n) {
TRACE_ERROR("iovcs sum to %i != total len of %i\n", total_len, len - n);
TRACE_ERROR("iov = %p\n", iov);
iscsi_trace_error("iovcs sum to %i != total len of %i\n", total_len, len - n);
iscsi_trace_error("iov = %p\n", iov);
for (i = 0; i < iovc; i++) {
TRACE_ERROR("iov[%i].iov_base = %p, len %u\n",
iscsi_trace_error("iov[%i].iov_base = %p, len %u\n",
i, iov[i].iov_base, (unsigned)iov[i].iov_len);
}
return -1;
}
if ((rc = (xmit) ? writev(sock, iov, iovc) : readv(sock, iov, iovc)) == 0) {
TRACE(TRACE_NET_DEBUG, "%s() failed: rc %i errno %i\n", (xmit) ? "writev" : "readv", rc, errno);
iscsi_trace(TRACE_NET_DEBUG, "%s() failed: rc %i errno %i\n", (xmit) ? "writev" : "readv", rc, errno);
break;
} else if (rc < 0) {
/* Temp FIXME */
TRACE_ERROR("%s() failed: rc %i errno %i\n", (xmit)?"writev":"readv", rc, errno);
iscsi_trace_error("%s() failed: rc %i errno %i\n", (xmit)?"writev":"readv", rc, errno);
break;
}
n += rc;
if (n < len) {
TRACE(TRACE_NET_DEBUG, "Got partial %s: %i bytes of %i\n", (xmit) ? "send" : "recv", rc, len - n + rc);
iscsi_trace(TRACE_NET_DEBUG, "Got partial %s: %i bytes of %i\n", (xmit) ? "send" : "recv", rc, len - n + rc);
total_len = 0;
for (i = 0; i < iovc; i++) {
total_len += iov[i].iov_len;
}
TRACE(TRACE_NET_IOV, "before modify_iov: %s %i buffers, total_len = %u, n = %u, rc = %u\n",
iscsi_trace(TRACE_NET_IOV, "before modify_iov: %s %i buffers, total_len = %u, n = %u, rc = %u\n",
xmit ? "gathering from" : "scattering into", iovc, total_len, n, rc);
if (modify_iov(&iov, &iovc, (unsigned) rc, len - n) != 0) {
TRACE_ERROR("modify_iov() failed\n");
iscsi_trace_error("modify_iov() failed\n");
break;
}
total_len = 0;
for (i = 0; i < iovc; i++) {
total_len += iov[i].iov_len;
}
TRACE(TRACE_NET_IOV, "after modify_iov: %s %i buffers, total_len = %u, n = %u, rc = %u\n\n",
iscsi_trace(TRACE_NET_IOV, "after modify_iov: %s %i buffers, total_len = %u, n = %u, rc = %u\n\n",
xmit ? "gathering from" : "scattering into", iovc, total_len, n, rc);
}
} while (n < len);
@ -689,7 +767,7 @@ iscsi_sock_msg(iscsi_socket_t sock, int xmit, unsigned len, void *data, int iovc
if (remainder) {
iscsi_free_atomic(iov_padding);
}
TRACE(TRACE_NET_DEBUG, "successfully %s %i bytes on sock (%i bytes padding)\n", xmit ? "sent" : "received", n, padding_len);
iscsi_trace(TRACE_NET_DEBUG, "successfully %s %i bytes on sock (%i bytes padding)\n", xmit ? "sent" : "received", n, padding_len);
return n - padding_len;
}
@ -713,7 +791,7 @@ iscsi_sock_send_header_and_data(iscsi_socket_t sock,
if (data_len && data_len <= ISCSI_SOCK_HACK_CROSSOVER) {
/* combine header and data into one iovec */
if (iovc >= ISCSI_MAX_IOVECS) {
TRACE_ERROR("iscsi_sock_msg() failed\n");
iscsi_trace_error("iscsi_sock_msg() failed\n");
return -1;
}
if (iovc == 0) {
@ -729,16 +807,16 @@ iscsi_sock_send_header_and_data(iscsi_socket_t sock,
iovc += 1;
}
if (iscsi_sock_msg(sock, Transmit, header_len + data_len, iov, iovc) != header_len + data_len) {
TRACE_ERROR("iscsi_sock_msg() failed\n");
iscsi_trace_error("iscsi_sock_msg() failed\n");
return -1;
}
} else {
if (iscsi_sock_msg(sock, Transmit, header_len, header, 0) != header_len) {
TRACE_ERROR("iscsi_sock_msg() failed\n");
iscsi_trace_error("iscsi_sock_msg() failed\n");
return -1;
}
if (data_len != 0 && iscsi_sock_msg(sock, Transmit, data_len, __UNCONST((const char *) data), iovc) != data_len) {
TRACE_ERROR("iscsi_sock_msg() failed\n");
iscsi_trace_error("iscsi_sock_msg() failed\n");
return -1;
}
}
@ -860,7 +938,7 @@ uint32_t
iscsi_atoi(char *value)
{
if (value == NULL) {
TRACE_ERROR("iscsi_atoi() called with NULL value\n");
iscsi_trace_error("iscsi_atoi() called with NULL value\n");
return 0;
}
return atoi(value);