/* This function behaves exactly like read(). The only difference is
* that it accepts the gnutls_session_t and the content_type_t of data to
* receive (if called by the user the Content is Userdata only)
* It is intended to receive data, under the current session.
*
* The gnutls_handshake_description_t was introduced to support SSL V2.0 client hellos.
*/
ssize_t
_gnutls_recv_int (gnutls_session_t session, content_type_t type,
gnutls_handshake_description_t htype,
uint8_t * data, size_t data_size, void* seq,
unsigned int ms)
{
int ret;
if ((type != GNUTLS_ALERT && type != GNUTLS_HEARTBEAT) && (data_size == 0 || data == NULL))
return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
if (session->internals.read_eof != 0)
{
/* if we have already read an EOF
*/
return 0;
}
else if (session_is_valid (session) != 0
|| session->internals.may_not_read != 0)
{
gnutls_assert ();
return GNUTLS_E_INVALID_SESSION;
}
switch(session->internals.recv_state)
{
case RECV_STATE_DTLS_RETRANSMIT:
ret = _dtls_retransmit(session);
if (ret < 0)
return gnutls_assert_val(ret);
session->internals.recv_state = RECV_STATE_0;
case RECV_STATE_0:
_dtls_async_timer_check(session);
/* If we have enough data in the cache do not bother receiving
* a new packet. (in order to flush the cache)
*/
ret = check_buffers (session, type, data, data_size, seq);
if (ret != 0)
return ret;
ret = _gnutls_recv_in_buffers(session, type, htype, ms);
if (ret < 0 && ret != GNUTLS_E_SESSION_EOF)
return gnutls_assert_val(ret);
return check_buffers (session, type, data, data_size, seq);
default:
return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);
}
}
static int write_dpram32_and_check(struct ft1000_usb *ft1000dev,
u16 tempbuffer[], u16 dpram)
{
int status;
u16 resultbuffer[64];
int i;
for (i = 0; i < 10; i++) {
status = ft1000_write_dpram32(ft1000dev, dpram,
(u8 *)&tempbuffer[0], 64);
if (status == 0) {
/* Work around for ASIC bit stuffing problem. */
if ((tempbuffer[31] & 0xfe00) == 0xfe00) {
status = ft1000_write_dpram32(ft1000dev,
dpram+12, (u8 *)&tempbuffer[24],
64);
}
/* Let's check the data written */
status = ft1000_read_dpram32(ft1000dev, dpram,
(u8 *)&resultbuffer[0], 64);
if ((tempbuffer[31] & 0xfe00) == 0xfe00) {
if (check_buffers(tempbuffer, resultbuffer, 28,
0)) {
DEBUG("FT1000:download:DPRAM write failed 1 during bootloading\n");
usleep_range(9000, 11000);
break;
}
status = ft1000_read_dpram32(ft1000dev,
dpram+12,
(u8 *)&resultbuffer[0], 64);
if (check_buffers(tempbuffer, resultbuffer, 16,
24)) {
DEBUG("FT1000:download:DPRAM write failed 2 during bootloading\n");
usleep_range(9000, 11000);
break;
}
} else {
if (check_buffers(tempbuffer, resultbuffer, 32,
0)) {
DEBUG("FT1000:download:DPRAM write failed 3 during bootloading\n");
usleep_range(9000, 11000);
break;
}
}
if (status == 0)
break;
}
}
return status;
}
static
void
domapread(unsigned offset, unsigned size)
{
unsigned pg_offset;
unsigned map_size;
char *p;
offset -= offset % readbdy;
if (size == 0) {
if (!quiet && testcalls > simulatedopcount)
prt("skipping zero size read\n");
log4(OP_SKIPPED, OP_MAPREAD, offset, size);
return;
}
if (size + offset > file_size) {
if (!quiet && testcalls > simulatedopcount)
prt("skipping seek/read past end of file\n");
log4(OP_SKIPPED, OP_MAPREAD, offset, size);
return;
}
log4(OP_MAPREAD, offset, size, 0);
if (testcalls <= simulatedopcount)
return;
if (!quiet && ((progressinterval &&
testcalls % progressinterval == 0) ||
(debug &&
(monitorstart == -1 ||
(offset + size > monitorstart &&
(monitorend == -1 || offset <= monitorend))))))
prt("%lu mapread\t0x%x thru\t0x%x\t(0x%x bytes)\n", testcalls,
offset, offset + size - 1, size);
pg_offset = offset & page_mask;
map_size = pg_offset + size;
if ((p = (char *)mmap(0, map_size, PROT_READ, MAP_FILE | MAP_SHARED, fd,
(off_t)(offset - pg_offset))) == (char *)-1) {
prterr("domapread: mmap");
report_failure(190);
}
if (setjmp(jmpbuf) == 0) {
jmpbuf_good = 1;
memcpy(temp_buf, p + pg_offset, size);
check_eofpage("Read", offset, p, size);
jmpbuf_good = 0;
} else {
report_failure(1901);
}
if (munmap(p, map_size) != 0) {
prterr("domapread: munmap");
report_failure(191);
}
check_buffers(offset, size);
}
/* This function behaves exactly like read(). The only difference is
* that it accepts the gnutls_session_t and the content_type_t of data to
* receive (if called by the user the Content is Userdata only)
* It is intended to receive data, under the current session.
*
* The gnutls_handshake_description_t was introduced to support SSL V2.0 client hellos.
*/
ssize_t
_gnutls_recv_int (gnutls_session_t session, content_type_t type,
gnutls_handshake_description_t htype,
uint8_t * data, size_t data_size, void* seq)
{
int ret;
if (type != GNUTLS_ALERT && (data_size == 0 || data == NULL))
{
return GNUTLS_E_INVALID_REQUEST;
}
if (session->internals.read_eof != 0)
{
/* if we have already read an EOF
*/
return 0;
}
else if (session_is_valid (session) != 0
|| session->internals.may_not_read != 0)
{
gnutls_assert ();
return GNUTLS_E_INVALID_SESSION;
}
_dtls_async_timer_check(session);
/* If we have enough data in the cache do not bother receiving
* a new packet. (in order to flush the cache)
*/
ret = check_buffers (session, type, data, data_size, seq);
if (ret != 0)
return ret;
ret = _gnutls_recv_in_buffers(session, type, htype);
if (ret < 0 && ret != GNUTLS_E_SESSION_EOF)
return gnutls_assert_val(ret);
return check_buffers (session, type, data, data_size, seq);
}
void
doread(unsigned offset, unsigned size)
{
off_t ret;
unsigned iret;
offset -= offset % readbdy;
if (o_direct)
size -= size % readbdy;
if (size == 0) {
if (!quiet && testcalls > simulatedopcount && !o_direct)
prt("skipping zero size read\n");
log4(OP_SKIPPED, OP_READ, offset, size);
return;
}
if (size + offset > file_size) {
if (!quiet && testcalls > simulatedopcount)
prt("skipping seek/read past end of file\n");
log4(OP_SKIPPED, OP_READ, offset, size);
return;
}
log4(OP_READ, offset, size, 0);
if (testcalls <= simulatedopcount)
return;
if (!quiet &&
((progressinterval && testcalls % progressinterval == 0) ||
(fsx_debug &&
(monitorstart == -1 ||
(offset + size > monitorstart &&
(monitorend == -1 || offset <= monitorend))))))
prt("%lu read\t0x%x thru\t0x%x\t(0x%x bytes)\n", testcalls,
offset, offset + size - 1, size);
ret = lseek(fd, (off_t)offset, SEEK_SET);
if (ret == (off_t)-1) {
prterr("doread: lseek");
report_failure(140);
}
iret = fsxread(fd, temp_buf, size, offset);
if (iret != size) {
if (iret == -1)
prterr("doread: read");
else
prt("short read: 0x%x bytes instead of 0x%x\n",
iret, size);
report_failure(141);
}
check_buffers(offset, size);
}
void
check_clones()
{
char filename[1024];
char imagename[1024];
int ret, fd;
rbd_image_t cur_image;
struct stat file_info;
while (num_clones > 0) {
prt("checking clone #%d\n", num_clones);
--num_clones;
clone_imagename(imagename, sizeof(imagename), num_clones);
if ((ret = rbd_open(ioctx, imagename, &cur_image, NULL)) < 0) {
simple_err("check_clones: rbd open", ret);
exit(167);
}
clone_filename(filename, sizeof(filename), num_clones + 1);
if ((fd = open(filename, O_RDONLY)) < 0) {
simple_err("check_clones: open", -errno);
exit(168);
}
prt("checking image %s against file %s\n", imagename, filename);
if ((ret = fstat(fd, &file_info)) < 0) {
simple_err("check_clones: fstat", -errno);
exit(169);
}
if ((ret = pread(fd, good_buf, file_info.st_size, 0)) < 0) {
simple_err("check_clones: pread", -errno);
exit(170);
}
if ((ret = rbd_read(cur_image, 0, file_info.st_size, temp_buf)) < 0) {
simple_err("check_clones: rbd_read", ret);
exit(171);
}
close(fd);
check_buffers(0, file_info.st_size);
unlink(filename);
/* remove the snapshot if it exists, ignore
the error from the last clone. */
rbd_snap_unprotect(cur_image, "snap");
rbd_snap_remove(cur_image, "snap");
rbd_close(cur_image);
rbd_remove(ioctx, imagename);
}
}
bool run_1_err_test() {
prep_buffers();
uint32_t ecc = ecc_generate(buf1);
int byte_idx = rand()%512;
int bit_idx = rand()%8;
buf2[byte_idx] ^= 0x01 << bit_idx;
bool v = ecc_verify(buf2, ecc);
if (v) {
if (!check_buffers()) {
printf("VERIFIED but not FIXED\n");
return false;
}
}
return v;
}
int jed_spawn_fg_process (int (*f)(VOID_STAR), VOID_STAR cd)
{
int status;
int inited;
if ((Jed_Secure_Mode)
|| (Jed_Suspension_Not_Allowed))
{
msg_error ("Access to shell denied.");
return -1;
}
/* FIXME: X_Suspend_Hook should not be here. Currently, this hook is
* used only by GUI jed, where suspension makes no sense. Of course in
* this case, spawning a foreground process also does not make sense.
*/
if (Batch || (X_Suspend_Hook != NULL))
return (*f) (cd);
SLsig_block_signals ();
inited = Jed_Display_Initialized;
SLsig_unblock_signals ();
jed_reset_display();
#if !defined(IBMPC_SYSTEM) && !defined(VMS)
jed_reset_signals ();
#endif
reset_tty();
status = (*f) (cd);
if (inited)
{
#if !defined(IBMPC_SYSTEM) && !defined(VMS)
init_signals();
#endif
if (-1 == init_tty())
{
exit_error ("Unable to initialize terminal.", 0);
}
flush_input ();
jed_init_display ();
}
check_buffers();
return status;
}
void
doread(unsigned offset, unsigned size)
{
int ret;
offset -= offset % readbdy;
if (o_direct)
size -= size % readbdy;
if (size == 0) {
if (!quiet && testcalls > simulatedopcount && !o_direct)
prt("skipping zero size read\n");
log4(OP_SKIPPED, OP_READ, offset, size);
return;
}
if (size + offset > file_size) {
if (!quiet && testcalls > simulatedopcount)
prt("skipping seek/read past end of file\n");
log4(OP_SKIPPED, OP_READ, offset, size);
return;
}
log4(OP_READ, offset, size, 0);
if (testcalls <= simulatedopcount)
return;
if (!quiet &&
((progressinterval && testcalls % progressinterval == 0) ||
(debug &&
(monitorstart == -1 ||
(offset + size > monitorstart &&
(monitorend == -1 || offset <= monitorend))))))
prt("%lu read\t0x%x thru\t0x%x\t(0x%x bytes)\n", testcalls,
offset, offset + size - 1, size);
ret = ops->read(&ctx, offset, size, temp_buf);
if (ret != (int)size) {
if (ret < 0)
prterrcode("doread: ops->read", ret);
else
prt("short read: 0x%x bytes instead of 0x%x\n",
ret, size);
report_failure(141);
}
check_buffers(good_buf, temp_buf, offset, size);
}
/*---------------------------------------------------------------------------*/
static void advanceSlot(struct rtimer *t, void *ptr, int status) {
off(TURN_OFF);
last = RTIMER_TIME(t);
if(!(rtimer_set(t, last + REGULAR_SLOT, 1, (void (*)(struct rtimer *, void *))advanceSlot, NULL) == RTIMER_OK)) {
printf("%s\n", "WPI-MAC: Could not schedule task!!!!!");
}
if(current_slot == TOTAL_SLOTS + 1) {
current_slot = BROADCAST_SLOT;
} else {
current_slot++;
}
if(current_slot > (TOTAL_SLOTS - 1)) {
current_slot = BROADCAST_SLOT;
}
//printf("Slot is now %u\n", current_slot);
unsigned char somethingToSend = check_buffers(current_slot);
if(somethingToSend) {
// grab the necessary info from our queue
QueuedPacket *curr = QPQueue[current_slot];
real_send(curr->sent, curr->ptr, curr->packet);
} else if(current_slot == BROADCAST_SLOT || current_slot == node_id) { // just need to be awake to listen
// if(!(rtimer_set(t, last + CONTENTION_PREPARE + (CONTENTION_TICKS * (CONTENTION_SLOTS)), 1, (void (*)(struct rtimer *, void *))async_on, NULL) == RTIMER_OK)){
// printf("%s\n", "Could not schedule task!!!!!");
// }
rtimer_clock_t stall = last + CONTENTION_PREPARE + (CONTENTION_TICKS * (CONTENTION_SLOTS));
// printf("STALLLLL: %u %u %u %u\n", RTIMER_NOW(), stall, REGULAR_SLOT, last);
while(RTIMER_CLOCK_LT(RTIMER_NOW(), stall));
if(!radio_is_on) on();
} else {
// we can snooze
if(radio_is_on) off(TURN_OFF);
}
}
//---------------------------------------------------------------------------
// Function: write_blk
//
// Parameters: struct ft1000_device - device structure
// u16 **pUsFile - DSP image file pointer in u16
// u8 **pUcFile - DSP image file pointer in u8
// long word_length - length of the buffer to be written
// to DPRAM
//
// Returns: STATUS_SUCCESS - success
// STATUS_FAILURE - failure
//
// Description: This function writes a block of DSP image to DPRAM
//
// Notes:
//
//---------------------------------------------------------------------------
static u32 write_blk (struct ft1000_device *ft1000dev, u16 **pUsFile, u8 **pUcFile, long word_length)
{
u32 Status = STATUS_SUCCESS;
u16 dpram;
int loopcnt, i, j;
u16 tempword;
u16 tempbuffer[64];
u16 resultbuffer[64];
struct ft1000_info *pft1000info = netdev_priv(ft1000dev->net);
//DEBUG("FT1000:download:start word_length = %d\n",(int)word_length);
dpram = (u16)DWNLD_MAG1_PS_HDR_LOC;
tempword = *(*pUsFile);
(*pUsFile)++;
Status = ft1000_write_dpram16(ft1000dev, dpram, tempword, 0);
tempword = *(*pUsFile);
(*pUsFile)++;
Status = ft1000_write_dpram16(ft1000dev, dpram++, tempword, 1);
*pUcFile = *pUcFile + 4;
word_length--;
tempword = (u16)word_length;
word_length = (word_length / 16) + 1;
for (; word_length > 0; word_length--) /* In words */
{
loopcnt = 0;
for (i=0; i<32; i++)
{
if (tempword != 0)
{
tempbuffer[i++] = *(*pUsFile);
(*pUsFile)++;
tempbuffer[i] = *(*pUsFile);
(*pUsFile)++;
*pUcFile = *pUcFile + 4;
loopcnt++;
tempword--;
}
else
{
tempbuffer[i++] = 0;
tempbuffer[i] = 0;
}
}
//DEBUG("write_blk: loopcnt is %d\n", loopcnt);
//DEBUG("write_blk: bootmode = %d\n", bootmode);
//DEBUG("write_blk: dpram = %x\n", dpram);
if (pft1000info->bootmode == 0)
{
if (dpram >= 0x3F4)
Status = ft1000_write_dpram32 (ft1000dev, dpram, (u8 *)&tempbuffer[0], 8);
else
Status = ft1000_write_dpram32 (ft1000dev, dpram, (u8 *)&tempbuffer[0], 64);
}
else
{
for (j=0; j<10; j++)
{
Status = ft1000_write_dpram32 (ft1000dev, dpram, (u8 *)&tempbuffer[0], 64);
if (Status == STATUS_SUCCESS)
{
// Work around for ASIC bit stuffing problem.
if ( (tempbuffer[31] & 0xfe00) == 0xfe00)
{
Status = ft1000_write_dpram32(ft1000dev, dpram+12, (u8 *)&tempbuffer[24], 64);
}
// Let's check the data written
Status = ft1000_read_dpram32 (ft1000dev, dpram, (u8 *)&resultbuffer[0], 64);
if ( (tempbuffer[31] & 0xfe00) == 0xfe00)
{
if (check_buffers(tempbuffer, resultbuffer, 28, 0)) {
DEBUG("FT1000:download:DPRAM write failed 1 during bootloading\n");
msleep(10);
Status = STATUS_FAILURE;
break;
}
Status = ft1000_read_dpram32 (ft1000dev, dpram+12, (u8 *)&resultbuffer[0], 64);
if (check_buffers(tempbuffer, resultbuffer, 16, 24)) {
DEBUG("FT1000:download:DPRAM write failed 2 during bootloading\n");
msleep(10);
Status = STATUS_FAILURE;
break;
}
}
else
{
if (check_buffers(tempbuffer, resultbuffer, 32, 0)) {
DEBUG("FT1000:download:DPRAM write failed 3 during bootloading\n");
msleep(10);
Status = STATUS_FAILURE;
break;
}
}
if (Status == STATUS_SUCCESS)
break;
}
}
if (Status != STATUS_SUCCESS)
{
DEBUG("FT1000:download:Write failed tempbuffer[31] = 0x%x\n", tempbuffer[31]);
break;
}
}
dpram = dpram + loopcnt;
}
return Status;
}
int main(
int argc,
char *argv[])
{
int ret = -1;
int world_rank = 0;
MPI_Comm comm;
PVFS_BMI_addr_t *bmi_peer_array;
int *mpi_peer_array;
int num_clients;
struct bench_options opts;
struct mem_buffers mpi_send_bufs;
struct mem_buffers mpi_recv_bufs;
struct mem_buffers bmi_send_bufs;
struct mem_buffers bmi_recv_bufs;
enum bmi_buffer_type buffer_type = BMI_EXT_ALLOC;
double mpi_time, bmi_time;
bmi_context_id context;
/* start up benchmark environment */
ret = bench_init(&opts, argc, argv, &num_clients, &world_rank, &comm,
&bmi_peer_array, &mpi_peer_array, &context);
if (ret < 0)
{
fprintf(stderr, "bench_init() failure.\n");
return (-1);
}
/* verify that we didn't get any weird parameters */
if (num_clients > 1 || opts.num_servers > 1)
{
fprintf(stderr, "Too many procs specified.\n");
return (-1);
}
/* setup MPI buffers */
ret = alloc_buffers(&mpi_send_bufs, ITERATIONS, opts.message_len);
ret += alloc_buffers(&mpi_recv_bufs, ITERATIONS, opts.message_len);
if (ret < 0)
{
fprintf(stderr, "alloc_buffers() failure.\n");
return (-1);
}
/* setup BMI buffers (differs depending on command line args) */
if (opts.flags & BMI_ALLOCATE_MEMORY)
{
buffer_type = BMI_PRE_ALLOC;
ret = BMI_alloc_buffers(&bmi_send_bufs, ITERATIONS, opts.message_len,
bmi_peer_array[0], BMI_SEND);
ret += BMI_alloc_buffers(&bmi_recv_bufs, ITERATIONS, opts.message_len,
bmi_peer_array[0], BMI_RECV);
if (ret < 0)
{
fprintf(stderr, "BMI_alloc_buffers() failure.\n");
return (-1);
}
}
else
{
buffer_type = BMI_EXT_ALLOC;
ret = alloc_buffers(&bmi_send_bufs, ITERATIONS, opts.message_len);
ret += alloc_buffers(&bmi_recv_bufs, ITERATIONS, opts.message_len);
if (ret < 0)
{
fprintf(stderr, "alloc_buffers() failure.\n");
return (-1);
}
}
/* mark all send buffers */
ret = mark_buffers(&bmi_send_bufs);
ret += mark_buffers(&mpi_send_bufs);
if (ret < 0)
{
fprintf(stderr, "mark_buffers() failure.\n");
return (-1);
}
/******************************************************************/
/* Actually measure some stuff */
/* BMI series */
if (world_rank == 0)
{
ret = bmi_server(&opts, &bmi_recv_bufs, &bmi_send_bufs,
bmi_peer_array[0], buffer_type, &bmi_time, context);
}
else
{
ret = bmi_client(&opts, &bmi_recv_bufs, &bmi_send_bufs,
bmi_peer_array[0], buffer_type, &bmi_time, context);
}
if (ret < 0)
{
return (-1);
}
/* MPI series */
if (world_rank == 0)
{
ret = mpi_server(&opts, &mpi_recv_bufs, &mpi_send_bufs,
mpi_peer_array[0], &mpi_time);
}
else
{
ret = mpi_client(&opts, &mpi_recv_bufs, &mpi_send_bufs,
mpi_peer_array[0], &mpi_time);
}
if (ret < 0)
{
return (-1);
}
/******************************************************************/
#if 0
if (!(opts.flags & REUSE_BUFFERS))
{
/* verify received buffers */
ret = check_buffers(&mpi_recv_bufs);
if (ret < 0)
{
fprintf(stderr, "MPI buffer verification failed.\n");
return (-1);
}
ret = check_buffers(&bmi_recv_bufs);
if (ret < 0)
{
fprintf(stderr, "BMI buffer verification failed.\n");
return (-1);
}
}
#endif
/* print out results */
if (world_rank == 0)
{
bench_args_dump(&opts);
printf("number of iterations: %d\n", ITERATIONS);
printf
("all times measure round trip in seconds unless otherwise noted\n");
printf("\"ave\" field is computed as (total time)/iterations\n");
}
/* enforce output ordering */
fflush(stdout);
MPI_Barrier(MPI_COMM_WORLD);
if (world_rank != 0)
{
printf("%d\t%f\t%f\t(size,total,ave)", bmi_recv_bufs.size,
bmi_time, (bmi_time / ITERATIONS));
printf(" bmi server\n");
printf("%d\t%f\t%f\t(size,total,ave)", mpi_recv_bufs.size,
mpi_time, (mpi_time / ITERATIONS));
printf(" mpi server\n");
}
/* enforce output ordering */
fflush(stdout);
MPI_Barrier(MPI_COMM_WORLD);
if (world_rank == 0)
{
printf("%d\t%f\t%f\t(size,total,ave)", bmi_recv_bufs.size,
bmi_time, (bmi_time / ITERATIONS));
printf(" bmi client\n");
printf("%d\t%f\t%f\t(size,total,ave)", mpi_recv_bufs.size,
mpi_time, (mpi_time / ITERATIONS));
printf(" mpi client\n");
}
/* free buffers */
free_buffers(&mpi_send_bufs);
free_buffers(&mpi_recv_bufs);
if (opts.flags & BMI_ALLOCATE_MEMORY)
{
BMI_free_buffers(&bmi_send_bufs, bmi_peer_array[0], BMI_SEND);
BMI_free_buffers(&bmi_recv_bufs, bmi_peer_array[0], BMI_RECV);
}
else
{
free_buffers(&bmi_send_bufs);
free_buffers(&bmi_recv_bufs);
}
/* shutdown interfaces */
BMI_close_context(context);
BMI_finalize();
MPI_Finalize();
return 0;
}
/* Function that carries out read/write operations */
static int spim_io(const struct spi_slave *slave, struct spim_buffer *first,
struct spim_buffer *second)
{
u32 reg, base;
int i, trans_count, ret;
struct spim_buffer *transaction[2];
struct img_spi_slave *img_slave = get_img_slave(slave);
base = img_slave->base;
ret = check_buffers(slave, first, second);
if (ret)
return ret;
/*
* Soft reset peripheral internals, this will terminate any
* pending transactions
*/
write32_x(base + SPFI_CONTROL_REG_OFFSET, SPIM_SOFT_RESET_MASK);
write32_x(base + SPFI_CONTROL_REG_OFFSET, 0);
/* Port state register */
reg = read32_x(base + SPFI_PORT_STATE_REG_OFFSET);
reg = spi_write_reg_field(reg, SPFI_PORT_SELECT, slave->cs);
write32_x(base + SPFI_PORT_STATE_REG_OFFSET, reg);
/* Set transaction register */
reg = transaction_reg_setup(first, second);
write32_x(base + SPFI_TRANSACTION_REG_OFFSET, reg);
/* Clear status */
write32_x(base + SPFI_INT_CLEAR_REG_OFFSET, 0xffffffff);
/* Set control register */
reg = control_reg_setup(first, second);
write32_x(base + SPFI_CONTROL_REG_OFFSET, reg);
/* First transaction always exists */
transaction[0] = first;
trans_count = 1;
/* Is there a second transaction? */
if (second) {
transaction[1] = second;
trans_count++;
}
/* Now write/read FIFO's */
for (i = 0; i < trans_count; i++)
/* Which transaction to execute, "Send" or "Get"? */
if (transaction[i]->isread) {
/* Get */
ret = receivedata(slave, transaction[i]->buffer,
transaction[i]->size);
if (ret) {
printk(BIOS_ERR,
"%s: Error: receive data failed.\n",
__func__);
return ret;
}
} else {
/* Send */
ret = transmitdata(slave, transaction[i]->buffer,
transaction[i]->size);
if (ret) {
printk(BIOS_ERR,
"%s: Error: transmit data failed.\n",
__func__);
return ret;
}
}
/* Wait for end of the transaction */
ret = wait_status(base + SPFI_INT_STATUS_REG_OFFSET,
SPFI_ALLDONE_SHIFT);
if (ret)
return ret;
/*
* Soft reset peripheral internals, this will terminate any
* pending transactions
*/
write32_x(base + SPFI_CONTROL_REG_OFFSET, SPIM_SOFT_RESET_MASK);
write32_x(base + SPFI_CONTROL_REG_OFFSET, 0);
return SPIM_OK;
}
/* This function behaves exactly like read(). The only difference is
* that it accepts the gnutls_session_t and the content_type_t of data to
* receive (if called by the user the Content is Userdata only)
* It is intended to receive data, under the current session.
*
* The gnutls_handshake_description_t was introduced to support SSL V2.0 client hellos.
*/
ssize_t
_gnutls_recv_int (gnutls_session_t session, content_type_t type,
gnutls_handshake_description_t htype,
opaque * data, size_t sizeofdata)
{
int decrypted_length;
opaque version[2];
content_type_t recv_type;
uint16_t length;
uint8_t *ciphertext;
int ret, ret2;
uint16_t header_size;
int empty_packet = 0;
gnutls_datum_t data_enc, tmp;
record_parameters_st *record_params;
record_state_st *record_state;
ret = _gnutls_epoch_get (session, EPOCH_READ_CURRENT, &record_params);
if (ret < 0)
{
gnutls_assert ();
return ret;
}
/* Safeguard against processing data with an incomplete cipher state. */
if (!record_params->initialized)
{
gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
}
record_state = &record_params->read;
if (type != GNUTLS_ALERT && (sizeofdata == 0 || data == NULL))
{
return GNUTLS_E_INVALID_REQUEST;
}
begin:
if (empty_packet > MAX_EMPTY_PACKETS_SEQUENCE)
{
gnutls_assert ();
return GNUTLS_E_TOO_MANY_EMPTY_PACKETS;
}
if (session->internals.read_eof != 0)
{
/* if we have already read an EOF
*/
return 0;
}
else if (session_is_valid (session) != 0
|| session->internals.may_not_read != 0)
{
gnutls_assert ();
return GNUTLS_E_INVALID_SESSION;
}
/* If we have enough data in the cache do not bother receiving
* a new packet. (in order to flush the cache)
*/
ret = check_buffers (session, type, data, sizeofdata);
if (ret != 0)
return ret;
/* default headers for TLS 1.0
*/
header_size = RECORD_HEADER_SIZE;
if ((ret =
_gnutls_io_read_buffered (session, header_size, -1)) != header_size)
{
if (ret < 0 && gnutls_error_is_fatal (ret) == 0)
return ret;
session_invalidate (session);
if (type == GNUTLS_ALERT)
{
gnutls_assert ();
return 0; /* we were expecting close notify */
}
session_unresumable (session);
gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
ret = _mbuffer_linearize (&session->internals.record_recv_buffer);
if (ret != 0)
{
gnutls_assert ();
return ret;
}
_mbuffer_get_first (&session->internals.record_recv_buffer, &data_enc);
if ((ret =
record_check_headers (session, data_enc.data, type, htype, &recv_type,
version, &length, &header_size)) < 0)
{
gnutls_assert ();
return ret;
}
/* Here we check if the Type of the received packet is
* ok.
*/
if ((ret = check_recv_type (recv_type)) < 0)
{
gnutls_assert ();
return ret;
}
/* Here we check if the advertized version is the one we
* negotiated in the handshake.
*/
if ((ret = record_check_version (session, htype, version)) < 0)
{
gnutls_assert ();
session_invalidate (session);
return ret;
}
_gnutls_record_log
("REC[%p]: Expected Packet[%d] %s(%d) with length: %d\n", session,
(int) _gnutls_uint64touint32 (&record_state->sequence_number),
_gnutls_packet2str (type), type, (int) sizeofdata);
_gnutls_record_log ("REC[%p]: Received Packet[%d] %s(%d) with length: %d\n",
session,
(int)
_gnutls_uint64touint32 (&record_state->sequence_number),
_gnutls_packet2str (recv_type), recv_type, length);
if (length > MAX_RECV_SIZE)
{
_gnutls_record_log
("REC[%p]: FATAL ERROR: Received packet with length: %d\n",
session, length);
session_unresumable (session);
session_invalidate (session);
gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
/* check if we have that data into buffer.
*/
if ((ret =
_gnutls_io_read_buffered (session, header_size + length,
recv_type)) != header_size + length)
{
if (ret < 0 && gnutls_error_is_fatal (ret) == 0)
return ret;
session_unresumable (session);
session_invalidate (session);
gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
/* ok now we are sure that we can read all the data - so
* move on !
*/
ret = _mbuffer_linearize (&session->internals.record_recv_buffer);
if (ret != 0)
{
gnutls_assert ();
return ret;
}
_mbuffer_get_first (&session->internals.record_recv_buffer, &data_enc);
ciphertext = &data_enc.data[header_size];
ret = get_temp_recv_buffer (session, &tmp);
if (ret < 0)
{
gnutls_assert ();
return ret;
}
/* decrypt the data we got.
*/
ret =
_gnutls_decrypt (session, ciphertext, length, tmp.data, tmp.size,
recv_type, record_params);
if (ret < 0)
{
session_unresumable (session);
session_invalidate (session);
gnutls_assert ();
return ret;
}
_mbuffer_remove_bytes (&session->internals.record_recv_buffer,
header_size + length);
decrypted_length = ret;
/* Check if this is a CHANGE_CIPHER_SPEC
*/
if (type == GNUTLS_CHANGE_CIPHER_SPEC &&
recv_type == GNUTLS_CHANGE_CIPHER_SPEC)
{
_gnutls_record_log
("REC[%p]: ChangeCipherSpec Packet was received\n", session);
if ((size_t) ret != sizeofdata)
{ /* sizeofdata should be 1 */
gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
memcpy (data, tmp.data, sizeofdata);
return ret;
}
_gnutls_record_log
("REC[%p]: Decrypted Packet[%d] %s(%d) with length: %d\n", session,
(int) _gnutls_uint64touint32 (&record_state->sequence_number),
_gnutls_packet2str (recv_type), recv_type, decrypted_length);
/* increase sequence number
*/
if (_gnutls_uint64pp (&record_state->sequence_number) != 0)
{
session_invalidate (session);
gnutls_assert ();
return GNUTLS_E_RECORD_LIMIT_REACHED;
}
ret =
record_check_type (session, recv_type, type, htype, tmp.data,
decrypted_length);
if (ret < 0)
{
if (ret == GNUTLS_E_INT_RET_0)
return 0;
gnutls_assert ();
return ret;
}
/* Get Application data from buffer
*/
if ((recv_type == type) &&
(type == GNUTLS_APPLICATION_DATA ||
type == GNUTLS_HANDSHAKE || type == GNUTLS_INNER_APPLICATION))
{
ret = _gnutls_record_buffer_get (type, session, data, sizeofdata);
if (ret < 0)
{
gnutls_assert ();
return ret;
}
/* if the buffer just got empty
*/
if (_gnutls_record_buffer_get_size (type, session) == 0)
{
if ((ret2 = _gnutls_io_clear_peeked_data (session)) < 0)
{
gnutls_assert ();
return ret2;
}
}
}
else
{
gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET;
/* we didn't get what we wanted to
*/
}
/* (originally for) TLS 1.0 CBC protection.
* Actually this code is called if we just received
* an empty packet. An empty TLS packet is usually
* sent to protect some vulnerabilities in the CBC mode.
* In that case we go to the beginning and start reading
* the next packet.
*/
if (ret == 0)
{
empty_packet++;
goto begin;
}
return ret;
}
void
check_clone(int clonenum)
{
char filename[128];
char imagename[128];
int ret, fd;
struct rbd_ctx cur_ctx = RBD_CTX_INIT;
struct stat file_info;
char *good_buf, *temp_buf;
clone_imagename(imagename, sizeof(imagename), clonenum);
if ((ret = ops->open(imagename, &cur_ctx)) < 0) {
prterrcode("check_clone: ops->open", ret);
exit(167);
}
clone_filename(filename, sizeof(filename), clonenum + 1);
if ((fd = open(filename, O_RDONLY)) < 0) {
simple_err("check_clone: open", -errno);
exit(168);
}
prt("checking clone #%d, image %s against file %s\n",
clonenum, imagename, filename);
if ((ret = fstat(fd, &file_info)) < 0) {
simple_err("check_clone: fstat", -errno);
exit(169);
}
good_buf = NULL;
ret = posix_memalign((void **)&good_buf,
MAX(writebdy, (int)sizeof(void *)),
file_info.st_size);
if (ret > 0) {
prterrcode("check_clone: posix_memalign(good_buf)", -ret);
exit(96);
}
temp_buf = NULL;
ret = posix_memalign((void **)&temp_buf,
MAX(readbdy, (int)sizeof(void *)),
file_info.st_size);
if (ret > 0) {
prterrcode("check_clone: posix_memalign(temp_buf)", -ret);
exit(97);
}
if ((ret = pread(fd, good_buf, file_info.st_size, 0)) < 0) {
simple_err("check_clone: pread", -errno);
exit(170);
}
if ((ret = ops->read(&cur_ctx, 0, file_info.st_size, temp_buf)) < 0) {
prterrcode("check_clone: ops->read", ret);
exit(171);
}
close(fd);
if ((ret = ops->close(&cur_ctx)) < 0) {
prterrcode("check_clone: ops->close", ret);
exit(174);
}
check_buffers(good_buf, temp_buf, 0, file_info.st_size);
unlink(filename);
free(good_buf);
free(temp_buf);
}
