void test_create(struct osd_device *osd)
{
int ret = 0;
struct osd_command cmd;
int senselen_out;
uint8_t sense_out[OSD_MAX_SENSE];
uint8_t *data_out = NULL;
const void *data_in;
uint64_t data_out_len, data_in_len;
uint8_t *cp = NULL;
uint8_t pad = 0;
uint32_t len = 0;
/* create partition + empty getpage_setlist */
ret = osd_command_set_create_partition(&cmd, PARTITION_PID_LB);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, NULL, 0, &data_out,
&data_out_len, sense_out, &senselen_out);
assert(ret == 0);
/* create 1 object */
ret = osd_command_set_create(&cmd, USEROBJECT_PID_LB,
USEROBJECT_OID_LB, 1);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, NULL, 0, &data_out, &data_out_len,
sense_out, &senselen_out);
assert(ret == 0);
/* remove the object */
ret = osd_command_set_remove(&cmd, USEROBJECT_PID_LB,
USEROBJECT_OID_LB);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, NULL, 0, &data_out, &data_out_len,
sense_out, &senselen_out);
assert(ret == 0);
struct attribute_list attr = {
ATTR_GET_PAGE, CUR_CMD_ATTR_PG, 0, NULL, CCAP_TOTAL_LEN, 0
};
/* create 5 objects & get ccap */
ret = osd_command_set_create(&cmd, USEROBJECT_PID_LB, 0, 5);
assert(ret == 0);
ret = osd_command_attr_build(&cmd, &attr, 1);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, NULL, 0, &data_out,
&data_out_len, sense_out, &senselen_out);
assert(ret == 0);
assert(get_ntohl(&data_out[0]) == CUR_CMD_ATTR_PG);
assert(get_ntohl(&data_out[4]) == CCAP_TOTAL_LEN - 8);
assert(data_out[CCAP_OBJT_OFF] == USEROBJECT);
assert(get_ntohll(&data_out[CCAP_PID_OFF]) == USEROBJECT_PID_LB);
assert(get_ntohll(&data_out[CCAP_APPADDR_OFF]) == 0);
uint64_t i = get_ntohll(&data_out[CCAP_OID_OFF]);
assert (i == (USEROBJECT_PID_LB + 5 - 1));
free(data_out);
data_out = NULL;
data_out_len = 0;
i -= (5-1);
/* remove 5 objects */
for (;i < USEROBJECT_OID_LB + 5; i++) {
ret = osd_command_set_remove(&cmd, USEROBJECT_PID_LB, i);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, NULL, 0, &data_out,
&data_out_len, sense_out,
&senselen_out);
assert(ret == 0);
}
/* create 5 objects, set 2 attr on each */
char str1[MAXNAMELEN], str2[MAXNAMELEN];
sprintf(str1, "Madhuri Dixit Rocks!!");
sprintf(str2, "A ciggarate a day, kills a moron anyway.");
struct attribute_list setattr[] = {
{ATTR_SET, USEROBJECT_PG+LUN_PG_LB, 111, str1, strlen(str1)+1,
0
},
{ATTR_SET, USEROBJECT_PG+LUN_PG_LB+1, 321, str2,
strlen(str2)+1, 0
}
};
ret = osd_command_set_create(&cmd, USEROBJECT_PID_LB, 0, 5);
assert(ret == 0);
ret = osd_command_attr_build(&cmd, setattr, 2);
assert(ret == 0);
data_in = cmd.outdata;
data_in_len = cmd.outlen;
ret = osdemu_cmd_submit(osd, cmd.cdb, data_in, data_in_len, &data_out,
&data_out_len, sense_out, &senselen_out);
assert(ret == 0);
/* remove 5 objects and get previously set attributes for each */
struct attribute_list getattr[] = {
{ATTR_GET, USEROBJECT_PG+LUN_PG_LB+1, 321, NULL, strlen(str2),
0
},
{ATTR_GET, USEROBJECT_PG+LUN_PG_LB, 111, NULL, strlen(str1),
0
}
};
for (i = USEROBJECT_OID_LB; i < (USEROBJECT_OID_LB + 5); i++) {
ret = osd_command_set_remove(&cmd, USEROBJECT_PID_LB, i);
assert(ret == 0);
ret = osd_command_attr_build(&cmd, getattr, 2);
assert(ret == 0);
data_in = cmd.outdata;
data_in_len = cmd.outlen;
ret = osdemu_cmd_submit(osd, cmd.cdb, data_in, data_in_len,
&data_out, &data_out_len, sense_out,
&senselen_out);
assert(ret == 0);
assert(data_out[0] == RTRVD_SET_ATTR_LIST);
len = get_ntohl(&data_out[4]);
assert(len > 0);
cp = &data_out[8];
assert(get_ntohl(&cp[LE_PAGE_OFF]) == USEROBJECT_PG+LUN_PG_LB+1);
assert(get_ntohl(&cp[LE_NUMBER_OFF]) == 321);
len = get_ntohs(&cp[LE_LEN_OFF]);
assert((uint32_t)len == (strlen(str2)+1));
assert(memcmp(&cp[LE_VAL_OFF], str2, len) == 0);
cp += len + LE_VAL_OFF;
pad = (0x8 - ((uintptr_t)cp & 0x7)) & 0x7;
while (pad--)
assert(*cp == 0), cp++;
assert(get_ntohl(&cp[LE_PAGE_OFF]) == USEROBJECT_PG+LUN_PG_LB);
assert(get_ntohl(&cp[LE_NUMBER_OFF]) == 111);
len = get_ntohs(&cp[LE_LEN_OFF]);
assert((uint32_t)len == (strlen(str1)+1));
assert(memcmp(&cp[LE_VAL_OFF], str1, len) == 0);
cp += len + LE_VAL_OFF;
pad = (0x8 - ((uintptr_t)cp & 0x7)) & 0x7;
while (pad--)
assert(*cp == 0), cp++;
}
free(data_out);
data_out = NULL;
data_out_len = 0;
/* get all attributes in a page for an object */
ret = osd_command_set_create(&cmd, USEROBJECT_PID_LB,
USEROBJECT_OID_LB, 1);
assert(ret == 0);
setattr[0].page = USEROBJECT_PG+LUN_PG_LB+11;
setattr[1].page = USEROBJECT_PG+LUN_PG_LB+11;
ret = osd_command_attr_build(&cmd, setattr, 2);
assert(ret == 0);
data_in = cmd.outdata;
data_in_len = cmd.outlen;
ret = osdemu_cmd_submit(osd, cmd.cdb, data_in, data_in_len, &data_out,
&data_out_len, sense_out, &senselen_out);
assert(ret == 0);
struct attribute_list getallattr[] = {
{ ATTR_GET, USEROBJECT_PG+LUN_PG_LB+11, ATTRNUM_GETALL, NULL,
1024, 0,
},
};
ret = osd_command_set_get_attributes(&cmd, USEROBJECT_PID_LB,
USEROBJECT_OID_LB);
assert(ret == 0);
ret = osd_command_attr_build(&cmd, getallattr, 1);
assert(ret == 0);
data_in = cmd.outdata;
data_in_len = cmd.outlen;
ret = osdemu_cmd_submit(osd, cmd.cdb, data_in, data_in_len, &data_out,
&data_out_len, sense_out, &senselen_out);
assert(ret == 0);
assert(data_out[0] == RTRVD_SET_ATTR_LIST);
len = get_ntohl(&data_out[4]);
assert(len > 0);
cp = &data_out[8];
assert(get_ntohl(&cp[LE_PAGE_OFF]) == USEROBJECT_PG+LUN_PG_LB+11);
assert(get_ntohl(&cp[LE_NUMBER_OFF]) == 111);
len = get_ntohs(&cp[LE_LEN_OFF]);
assert((uint32_t)len == (strlen(str1)+1));
assert(memcmp(&cp[LE_VAL_OFF], str1, len) == 0);
cp += len + LE_VAL_OFF;
pad = (0x8 - ((uintptr_t)cp & 0x7)) & 0x7;
while (pad--)
assert(*cp == 0), cp++;
assert(get_ntohl(&cp[LE_PAGE_OFF]) == USEROBJECT_PG+LUN_PG_LB+11);
assert(get_ntohl(&cp[LE_NUMBER_OFF]) == 321);
len = get_ntohs(&cp[LE_LEN_OFF]);
assert((uint32_t)len == (strlen(str2)+1));
assert(memcmp(&cp[LE_VAL_OFF], str2, len) == 0);
cp += len + LE_VAL_OFF;
pad = (0x8 - ((uintptr_t)cp & 0x7)) & 0x7;
while (pad--)
assert(*cp == 0), cp++;
free(data_out);
data_out = NULL;
data_out_len = 0;
ret = osd_command_set_remove(&cmd, USEROBJECT_PID_LB,
USEROBJECT_OID_LB);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, NULL, 0, &data_out,
&data_out_len, sense_out, &senselen_out);
assert(ret == 0);
/* remove partition */
ret = osd_command_set_remove_partition(&cmd, PARTITION_PID_LB);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, NULL, 0, &data_out,
&data_out_len, sense_out, &senselen_out);
assert(ret == 0);
free(cmd.attr_malloc);
}
static int bidi_test(int fd, uint64_t pid, uint64_t oid)
{
int ret;
struct osd_command command;
struct attribute_list *attr, attr_proto = {
.page = 0x1,
.number = 0x82, /* logical length (not used capacity) */
.len = sizeof(uint64_t),
};
osd_info(__func__);
ret = osd_command_set_get_attributes(&command, pid, oid);
if (ret) {
osd_error_xerrno(ret, "%s: get_attributes failed", __func__);
printf("\n");
return 1;
}
ret = osd_command_attr_build(&command, &attr_proto, 1);
if (ret) {
osd_error_xerrno(ret, "%s: attr_build failed", __func__);
printf("\n");
return 1;
}
memset(command.indata, 0xaa, command.inlen_alloc);
ret = osd_submit_and_wait(fd, &command);
if (ret) {
osd_error_xerrno(ret, "%s: submit failed", __func__);
printf("\n");
return 1;
}
printf("%s: status %u sense len %u inlen %zu\n", __func__,
command.status, command.sense_len, command.inlen);
/* verify retrieved list */
osd_hexdump(command.indata, command.inlen_alloc);
ret = osd_command_attr_resolve(&command);
if (ret) {
osd_error("%s: attr_resolve failed", __func__);
printf("\n");
exit(1);
}
attr = command.attr;
if (attr->outlen != attr->len) {
osd_error("%s: short attr outlen %d", __func__,
attr->outlen);
exit(1);
}
printf("%s: logical length 0x%016llx\n\n", __func__,
llu(get_ntohll(attr->val)));
osd_command_attr_free(&command);
return 0;
}
static void iovec_write_test(int fd, uint64_t pid, uint64_t oid)
{
struct osd_command command;
const char buf1[] = "If iovec_write_test works,";
const char buf2[] = " you will see this sentence.";
char bufout[200];
struct bsg_iovec vec[2];
size_t tot_len;
int ret;
osd_info(__func__);
vec[0].iov_base = (iov_base_t)(uintptr_t) buf1;
vec[0].iov_len = sizeof(buf1)-1;
vec[1].iov_base = (iov_base_t)(uintptr_t) buf2;
vec[1].iov_len = sizeof(buf2);
tot_len = sizeof(buf1)-1 + sizeof(buf2);
memset(&command, 0, sizeof(command));
osd_command_set_write(&command, pid, oid, tot_len, 0);
command.cdb_len = OSD_CDB_SIZE;
command.outlen = tot_len;
command.outdata = vec;
command.iov_outlen = 2;
ret = osd_submit_and_wait(fd, &command);
if (ret) {
osd_error("%s: submit_and_wait failed", __func__);
return;
}
printf("%s: seemed to work\n", __func__);
/* read it back, non-iov */
memset(&command, 0, sizeof(command));
memset(bufout, 0, sizeof(bufout));
osd_command_set_read(&command, pid, oid, sizeof(bufout), 0);
command.cdb_len = OSD_CDB_SIZE;
command.inlen_alloc = sizeof(bufout);
command.indata = bufout;
ret = osd_submit_and_wait(fd, &command);
if (ret)
osd_error("%s: submit_and_wait failed", __func__);
printf("%s: read some bytes (%zu): %s\n\n", __func__,
command.inlen, bufout);
}
static void iovec_read_test(int fd, uint64_t pid, uint64_t oid)
{
struct osd_command command;
const char bufout[] = "A big line of data for iovec_read_test to get.";
char buf1[21];
char buf2[100];
struct bsg_iovec vec[2];
size_t tot_len;
int ret;
/* write it, non-iov */
osd_info(__func__);
memset(&command, 0, sizeof(command));
osd_command_set_write(&command, pid, oid, sizeof(bufout), 0);
command.cdb_len = OSD_CDB_SIZE;
command.outlen = sizeof(bufout);
command.outdata = bufout;
ret = osd_submit_and_wait(fd, &command);
if (ret) {
osd_error("%s: submit_and_wait failed", __func__);
return;
}
memset(buf1, 0, sizeof(buf1));
memset(buf2, 0, sizeof(buf2));
vec[0].iov_base = (iov_base_t)(uintptr_t) buf1;
vec[0].iov_len = sizeof(buf1)-1;
vec[1].iov_base = (iov_base_t)(uintptr_t) buf2;
vec[1].iov_len = sizeof(buf2);
tot_len = sizeof(buf1)-1 + sizeof(buf2);
memset(&command, 0, sizeof(command));
osd_command_set_read(&command, pid, oid, tot_len, 0);
command.cdb_len = OSD_CDB_SIZE;
command.inlen_alloc = tot_len;
command.indata = vec;
command.iov_inlen = 2;
ret = osd_submit_and_wait(fd, &command);
if (ret) {
osd_error("%s: submit_and_wait failed", __func__);
return;
}
buf1[sizeof(buf1)-1] = '\0'; /* terminate partial string */
printf("%s: read some bytes (%zu): %s + %s\n\n", __func__,
command.inlen, buf1, buf2);
}
static void attr_test(int fd, uint64_t pid, uint64_t oid)
{
int i, ret;
uint64_t len;
uint8_t *ts; /* odd 6-byte timestamp */
const uint8_t data[] = "Some data.";
/* const char attr_data[] = "An attribute.\n"; */
struct osd_command command;
struct attribute_list *attr, attr_proto[] = {
{
.type = ATTR_GET,
.page = 0x1, /* user info page */
.number = 0x82, /* logical length */
.len = sizeof(uint64_t),
},
{
.type = ATTR_GET,
void test_set_member_attributes(struct osd_device *osd)
{
struct osd_command cmd;
uint64_t pid = PARTITION_PID_LB;
uint64_t cid = COLLECTION_OID_LB;
uint64_t oid = 0;
uint8_t *data_out = NULL;
uint32_t page = 0;
const void *data_in;
uint64_t data_out_len, data_in_len;
uint8_t sense_out[OSD_MAX_SENSE];
int senselen_out;
int i, ret;
data_out = NULL;
data_out_len = 0;
/* create partition */
ret = osd_command_set_create_partition(&cmd, pid);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, NULL, 0, &data_out,
&data_out_len, sense_out, &senselen_out);
assert(ret == 0);
/* create collection */
ret = osd_command_set_create_collection(&cmd, pid, cid);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, NULL, 0, &data_out,
&data_out_len, sense_out, &senselen_out);
assert(ret == 0);
/* create 100 objects */
ret = osd_command_set_create(&cmd, pid, 0, 100);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, NULL, 0, &data_out,
&data_out_len, sense_out, &senselen_out);
assert(ret == 0);
assert(osd->ccap.oid == (USEROBJECT_OID_LB + 100));
/* put odd objects into the collection */
oid = USEROBJECT_OID_LB + 1;
for (i = 0; i < 100; i += 2) {
uint64_t attrval;
struct attribute_list attr = {
.type = ATTR_SET,
.page = USER_COLL_PG,
.number = 1,
.len = sizeof(attrval),
.val = &attrval,
};
set_htonll(&attrval, cid);
ret = osd_command_set_set_attributes(&cmd, pid, oid + i);
assert(ret == 0);
ret = osd_command_attr_build(&cmd, &attr, 1);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, cmd.outdata, cmd.outlen,
&data_out, &data_out_len,
sense_out, &senselen_out);
assert(ret == 0);
osd_command_attr_free(&cmd);
}
/* set attr on collection members */
uint64_t val1 = 123454321, val2 = 987654, val3 = 59999999;
char str1[MAXNAMELEN], str2[MAXNAMELEN], str3[MAXNAMELEN];
set_htonll(&val1, val1);
set_htonll(&val2, val2);
set_htonll(&val3, val3);
sprintf(str1, "GoMtI");
sprintf(str2, "DeViL");
sprintf(str3, "homeopath");
page = USEROBJECT_PG + LUN_PG_LB;
struct attribute_list attrs[] = {
{ATTR_SET, page+1, 2, str1, strlen(str1)+1, 0},
{ATTR_SET, page+21, 4, &val1, sizeof(val1), 0},
{ATTR_SET, page+5, 55, &val2, sizeof(val2), 0},
{ATTR_SET, page+666, 66, str2, strlen(str2)+1, 0},
{ATTR_SET, page+10, 10, str3, strlen(str3)+1, 0},
{ATTR_SET, page+2, 3, &val3, sizeof(val3), 0},
};
ret = osd_command_set_set_member_attributes(&cmd, pid, cid);
assert(ret == 0);
ret = osd_command_attr_build(&cmd, attrs, 6);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, cmd.outdata, cmd.outlen,
&data_out, &data_out_len, sense_out,
&senselen_out);
assert(ret == 0);
osd_command_attr_free(&cmd);
/* randomly select 5 objects, get their attrs and test */
for (i = 0; i < 6; i++) {
attrs[i].type = ATTR_GET;
}
srand(time(0));
for (i = 0; i < 5; i++) {
int r = (int)(50.0 * (rand()/(RAND_MAX+1.0)));
oid = USEROBJECT_OID_LB + 1 + 2*r;
ret = osd_command_set_get_attributes(&cmd, pid, oid);
assert(ret == 0);
ret = osd_command_attr_build(&cmd, attrs, 6);
assert(ret == 0);
data_in = cmd.outdata;
data_in_len = cmd.outlen;
ret = osdemu_cmd_submit(osd, cmd.cdb, data_in, data_in_len,
&data_out, &data_out_len, sense_out,
&senselen_out);
assert(ret == 0);
test_attr_vals(data_out, attrs, 6);
osd_command_attr_free(&cmd);
}
free(data_out);
data_out = NULL;
data_out_len = 0;
/* clean up */
oid = USEROBJECT_OID_LB + 1;
for (i=0; i<100; i++) {
ret = osd_command_set_remove(&cmd, pid, oid + i);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, NULL, 0, &data_out,
&data_out_len, sense_out,
&senselen_out);
assert(ret == 0);
}
cid = COLLECTION_OID_LB;
ret = osd_command_set_remove_collection(&cmd, pid, cid, 0);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, NULL, 0, &data_out,
&data_out_len, sense_out, &senselen_out);
ret = osd_command_set_remove_partition(&cmd, pid);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, NULL, 0, &data_out,
&data_out_len, sense_out, &senselen_out);
assert(ret == 0);
}
void test_atomics(struct osd_device *osd)
{
int ret = 0;
struct osd_command cmd;
int senselen_out;
uint8_t sense_out[OSD_MAX_SENSE];
uint8_t *cp = NULL;
uint8_t *data_out = NULL;
void *data_in = NULL;
uint64_t data_out_len, data_in_len;
/* create partition + empty getpage_setlist */
ret = osd_command_set_create_partition(&cmd, PARTITION_PID_LB);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, NULL, 0, &data_out,
&data_out_len, sense_out, &senselen_out);
assert(ret == 0);
/* create 1 object */
ret = osd_command_set_create(&cmd, USEROBJECT_PID_LB,
USEROBJECT_OID_LB, 1);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, NULL, 0, &data_out, &data_out_len,
sense_out, &senselen_out);
assert(ret == 0);
/* cas */
ret = osd_command_set_cas(&cmd, USEROBJECT_PID_LB, USEROBJECT_OID_LB,
8UL, 0);
assert(ret == 0);
data_in = Malloc(1024);
assert(data_in != NULL);
cp = data_in;
set_htonll(&cp[0], 0UL);
set_htonll(&cp[8], 5UL);
data_in_len = 16;
data_out = NULL;
data_out_len = 0;
ret = osdemu_cmd_submit(osd, cmd.cdb, data_in, data_in_len, &data_out,
&data_out_len, sense_out, &senselen_out);
assert(ret == 0);
assert(data_out != NULL);
assert(get_ntohll(&data_out[0]) == 0UL);
free(data_out);
data_out = NULL;
data_out_len = 0;
ret = osd_command_set_cas(&cmd, USEROBJECT_PID_LB, USEROBJECT_OID_LB,
8UL, 0);
assert(ret == 0);
cp = data_in;
set_htonll(&cp[0], 5UL);
set_htonll(&cp[8], 0UL);
data_in_len = 16;
ret = osdemu_cmd_submit(osd, cmd.cdb, data_in, data_in_len, &data_out,
&data_out_len, sense_out, &senselen_out);
assert(ret == 0);
assert(data_out != NULL);
assert(get_ntohll(&data_out[0]) == 5UL);
free(data_out);
data_out = NULL;
data_out_len = 0;
/* fa */
ret = osd_command_set_fa(&cmd, USEROBJECT_PID_LB, USEROBJECT_OID_LB,
8UL, 0);
assert(ret == 0);
cp = data_in;
set_htonll(&cp[0], 4UL);
data_in_len = 8;
ret = osdemu_cmd_submit(osd, cmd.cdb, data_in, data_in_len, &data_out,
&data_out_len, sense_out, &senselen_out);
assert(ret == 0);
assert(data_out != NULL);
assert(get_ntohll(&data_out[0]) == 0UL);
free(data_out);
data_out = NULL;
data_out_len = 0;
ret = osd_command_set_fa(&cmd, USEROBJECT_PID_LB, USEROBJECT_OID_LB,
8UL, 0);
assert(ret == 0);
cp = data_in;
set_htonll(&cp[0], 16UL);
data_in_len = 8;
ret = osdemu_cmd_submit(osd, cmd.cdb, data_in, data_in_len, &data_out,
&data_out_len, sense_out, &senselen_out);
assert(ret == 0);
assert(data_out != NULL);
assert(get_ntohll(&data_out[0]) == 4UL);
free(data_out);
data_out = NULL;
data_out_len = 0;
ret = osd_command_set_fa(&cmd, USEROBJECT_PID_LB, USEROBJECT_OID_LB,
8UL, 0);
assert(ret == 0);
cp = data_in;
set_htonll(&cp[0], -20L);
data_in_len = 8;
ret = osdemu_cmd_submit(osd, cmd.cdb, data_in, data_in_len, &data_out,
&data_out_len, sense_out, &senselen_out);
assert(ret == 0);
assert(data_out != NULL);
assert(get_ntohll(&data_out[0]) == 20UL);
free(data_out);
data_out = NULL;
data_out_len = 0;
ret = osd_command_set_fa(&cmd, USEROBJECT_PID_LB, USEROBJECT_OID_LB,
8UL, 0);
assert(ret == 0);
cp = data_in;
set_htonll(&cp[0], 1L);
data_in_len = 8;
ret = osdemu_cmd_submit(osd, cmd.cdb, data_in, data_in_len, &data_out,
&data_out_len, sense_out, &senselen_out);
assert(ret == 0);
assert(data_out != NULL);
assert(get_ntohll(&data_out[0]) == 0UL);
free(data_out);
data_out = NULL;
data_out_len = 0;
free(data_in);
/* gen_cas */
ret = osd_command_set_gen_cas(&cmd, USEROBJECT_PID_LB,
USEROBJECT_OID_LB);
assert(ret == 0);
char str1[MAXNAMELEN];
sprintf(str1, "some arbit string");
struct attribute_list attr[] = {
{ATTR_SET, USEROBJECT_PG+LUN_PG_LB, 1, NULL, 0, 0},
{ATTR_SET, USEROBJECT_PG+LUN_PG_LB, 1, str1, strlen(str1)+1,
0
},
{ATTR_RESULT, USEROBJECT_PG+LUN_PG_LB, 1, NULL, 0, 0}
};
ret = osd_command_attr_build(&cmd, attr, 3);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, cmd.outdata, cmd.outlen,
&data_out, &data_out_len, sense_out,
&senselen_out);
assert(ret == 0);
assert(data_out != NULL);
assert(data_out_len == 24);
attr[2].len = 0;
test_attr_vals(data_out, &attr[2], 1);
osd_command_attr_free(&cmd);
free(data_out);
data_out = NULL;
data_out_len = 0;
ret = osd_command_set_gen_cas(&cmd, USEROBJECT_PID_LB,
USEROBJECT_OID_LB);
assert(ret == 0);
char str2[MAXNAMELEN];
sprintf(str2, "a diff str");
struct attribute_list attr1[] = {
{ATTR_SET, USEROBJECT_PG+LUN_PG_LB, 1, str1, strlen(str1)+1,
0
},
{ATTR_SET, USEROBJECT_PG+LUN_PG_LB, 1, str2, strlen(str2)+1,
0
},
{ATTR_RESULT, USEROBJECT_PG+LUN_PG_LB, 1, str1, strlen(str1)+1,
0
}
};
ret = osd_command_attr_build(&cmd, attr1, 3);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, cmd.outdata, cmd.outlen,
&data_out, &data_out_len, sense_out,
&senselen_out);
assert(ret == 0);
assert(data_out != NULL);
test_attr_vals(data_out, &attr1[2], 1);
osd_command_attr_free(&cmd);
free(data_out);
data_out = NULL;
data_out_len = 0;
/* cond setattr */
ret = osd_command_set_cond_setattr(&cmd, USEROBJECT_PID_LB,
USEROBJECT_OID_LB);
assert(ret == 0);
char str3[MAXNAMELEN];
sprintf(str3, "setattr str");
struct attribute_list attr2[] = {
{ATTR_SET, USEROBJECT_PG+LUN_PG_LB, 1, str2, strlen(str2)+1,
0
}, /* cmp */
{ATTR_SET, USEROBJECT_PG+LUN_PG_LB, 1, str1, strlen(str1)+1,
0
}, /* swap */
{ATTR_SET, USEROBJECT_PG+LUN_PG_LB+100, 23, str3,
strlen(str3)+1, 0
},
{ATTR_RESULT, USEROBJECT_PG+LUN_PG_LB, 1, str2, strlen(str2)+1,
0
}
};
ret = osd_command_attr_build(&cmd, attr2, 4);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, cmd.outdata, cmd.outlen,
&data_out, &data_out_len, sense_out,
&senselen_out);
assert(ret == 0);
assert(data_out != NULL);
test_attr_vals(data_out, &attr2[3], 1);
osd_command_attr_free(&cmd);
free(data_out);
data_out = NULL;
data_out_len = 0;
attr2[2].type = ATTR_GET;
ret = osd_command_set_get_attributes(&cmd, USEROBJECT_PID_LB,
USEROBJECT_OID_LB);
assert(ret == 0);
ret = osd_command_attr_build(&cmd, &attr2[2], 1);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, cmd.outdata, cmd.outlen,
&data_out, &data_out_len, sense_out,
&senselen_out);
assert(ret == 0);
assert(data_out != NULL);
test_attr_vals(data_out, &attr2[2], 1);
osd_command_attr_free(&cmd);
free(data_out);
data_out = NULL;
data_out_len = 0;
/* clean up */
ret = osd_command_set_remove(&cmd, USEROBJECT_PID_LB,
USEROBJECT_OID_LB);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, NULL, 0, &data_out,
&data_out_len, sense_out, &senselen_out);
ret = osd_command_set_remove_partition(&cmd, PARTITION_PID_LB);
assert(ret == 0);
ret = osdemu_cmd_submit(osd, cmd.cdb, NULL, 0, &data_out,
&data_out_len, sense_out, &senselen_out);
assert(ret == 0);
}
.len = sizeof(attr_data),
},
{
.type = ATTR_GET_PAGE,
.page = 0x3, /* user timestamp page */
.number = 0x1, /* ctitme */
.val = &ts,
.len = 6,
},
#endif
};
/* so length will be interesting */
write_osd(fd, pid, oid, data, sizeof(data), 0);
ret = osd_command_set_get_attributes(&command, pid, oid);
if (ret) {
osd_error("%s: set_get_attributes failed", __func__);
printf("\n");
return;
}
ret = osd_command_attr_build(&command, attr_proto,
ARRAY_SIZE(attr_proto));
if (ret) {
osd_error("%s: attr_build failed", __func__);
printf("\n");
return;
}
ret = osd_submit_and_wait(fd, &command);
if (ret) {
osd_error("%s: submit_and_wait failed", __func__);
