/*
* Read the platform configuration file from the EPROM.
*
* On success, an allocated buffer containing the data and its size are
* returned. It is up to the caller to free this buffer.
*
* Return value:
* 0 - success
* -ENXIO - no EPROM is available
* -EBUSY - not able to acquire access to the EPROM
* -ENOENT - no recognizable file written
* -ENOMEM - buffer could not be allocated
* -EINVAL - invalid EPROM contentents found
*/
int eprom_read_platform_config(struct hfi1_devdata *dd, void **data, u32 *size)
{
u32 directory[EP_PAGE_DWORDS]; /* aligned buffer */
int ret;
if (!dd->eprom_available)
return -ENXIO;
ret = acquire_chip_resource(dd, CR_EPROM, EPROM_TIMEOUT);
if (ret)
return -EBUSY;
/* read the last page of the segment for the EPROM format magic */
ret = read_length(dd, SEG_SIZE - EP_PAGE_SIZE, EP_PAGE_SIZE, directory);
if (ret)
goto done;
/* last dword of the segment contains a magic value */
if (directory[EP_PAGE_DWORDS - 1] == FOOTER_MAGIC) {
/* segment format */
ret = read_segment_platform_config(dd, directory, data, size);
} else {
/* partition format */
ret = read_partition_platform_config(dd, data, size);
}
done:
release_chip_resource(dd, CR_EPROM);
return ret;
}
/*
* Read the platform configuration file from the EPROM.
*
* On success, an allocated buffer containing the data and its size are
* returned. It is up to the caller to free this buffer.
*
* Return value:
* 0 - success
* -ENXIO - no EPROM is available
* -EBUSY - not able to acquire access to the EPROM
* -ENOENT - no recognizable file written
* -ENOMEM - buffer could not be allocated
*/
int eprom_read_platform_config(struct hfi1_devdata *dd, void **data, u32 *size)
{
u32 directory[EP_PAGE_DWORDS]; /* aligned buffer */
int ret;
if (!dd->eprom_available)
return -ENXIO;
ret = acquire_chip_resource(dd, CR_EPROM, EPROM_TIMEOUT);
if (ret)
return -EBUSY;
/* read the last page of P0 for the EPROM format magic */
ret = read_length(dd, P1_START - EP_PAGE_SIZE, EP_PAGE_SIZE, directory);
if (ret)
goto done;
/* last dword of P0 contains a magic indicator */
if (directory[EP_PAGE_DWORDS - 1] == 0) {
/* partition format */
ret = read_partition_platform_config(dd, data, size);
goto done;
}
/* nothing recognized */
ret = -ENOENT;
done:
release_chip_resource(dd, CR_EPROM);
return ret;
}
static readstat_error_t discard_vector(rdata_sexptype_header_t sexptype_header, size_t element_size, rdata_ctx_t *ctx) {
int32_t length;
readstat_error_t retval = READSTAT_OK;
if ((retval = read_length(&length, ctx)) != READSTAT_OK)
goto cleanup;
if (length > 0) {
if (lseek_st(ctx, length * element_size) == -1) {
return READSTAT_ERROR_READ;
}
} else if (ctx->error_handler) {
char error_buf[1024];
snprintf(error_buf, sizeof(error_buf), "Vector with non-positive length: %d\n", length);
ctx->error_handler(error_buf, ctx->user_ctx);
}
if (sexptype_header.attributes) {
rdata_sexptype_info_t temp_info;
if ((retval = read_sexptype_header(&temp_info, ctx)) != READSTAT_OK)
goto cleanup;
retval = recursive_discard(temp_info.header, ctx);
}
cleanup:
return retval;
}
/*
* Read all of partition 1. The actual file is at the front. Adjust
* the returned size if a trailing image magic is found.
*/
static int read_partition_platform_config(struct hfi1_devdata *dd, void **data,
u32 *size)
{
void *buffer;
void *p;
u32 length;
int ret;
buffer = kmalloc(P1_SIZE, GFP_KERNEL);
if (!buffer)
return -ENOMEM;
ret = read_length(dd, P1_START, P1_SIZE, buffer);
if (ret) {
kfree(buffer);
return ret;
}
/* scan for image magic that may trail the actual data */
p = strnstr(buffer, IMAGE_TRAIL_MAGIC, P1_SIZE);
if (p)
length = p - buffer;
else
length = P1_SIZE;
*data = buffer;
*size = length;
return 0;
}
/* return length of recieved packet on success.
* return 0 if could not read any packet.
* return -1 on failure (connection must be killed).
*/
static int read_packet_TCP_secure_connection(TCP_Secure_Connection *con, uint8_t *data, uint16_t max_len)
{
if (con->next_packet_length == 0) {
uint16_t len = read_length(con->sock);
if (len == (uint16_t)~0)
return -1;
if (len == 0)
return 0;
con->next_packet_length = len;
}
if (max_len + crypto_box_MACBYTES < con->next_packet_length)
return -1;
uint8_t data_encrypted[con->next_packet_length];
int len_packet = read_TCP_packet(con->sock, data_encrypted, con->next_packet_length);
if (len_packet != con->next_packet_length)
return 0;
con->next_packet_length = 0;
int len = decrypt_data_fast(con->shared_key, con->recv_nonce, data_encrypted, len_packet, data);
if (len + crypto_box_MACBYTES != len_packet)
return -1;
increment_nonce(con->recv_nonce);
return len;
}
/* Use a standard message across the unix sockets:
* 4 byte length of message as little endian encoded uint32_t followed by the
* string. Return NULL in case of failure. */
char *_recv_unix_msg(int sockd, int timeout1, int timeout2, const char *file, const char *func, const int line)
{
char *buf = NULL;
uint32_t msglen;
int ret, ern;
ret = wait_read_select(sockd, timeout1);
if (unlikely(ret < 1)) {
ern = errno;
LOGERR("Select1 failed in recv_unix_msg (%d)", ern);
goto out;
}
/* Get message length */
ret = read_length(sockd, &msglen, 4);
if (unlikely(ret < 4)) {
ern = errno;
LOGERR("Failed to read 4 byte length in recv_unix_msg (%d?)", ern);
goto out;
}
msglen = le32toh(msglen);
if (unlikely(msglen < 1 || msglen > 0x80000000)) {
LOGWARNING("Invalid message length %u sent to recv_unix_msg", msglen);
goto out;
}
ret = wait_read_select(sockd, timeout2);
if (unlikely(ret < 1)) {
ern = errno;
LOGERR("Select2 failed in recv_unix_msg (%d)", ern);
goto out;
}
buf = ckzalloc(msglen + 1);
ret = read_length(sockd, buf, msglen);
if (unlikely(ret < (int)msglen)) {
ern = errno;
LOGERR("Failed to read %u bytes in recv_unix_msg (%d?)", msglen, ern);
dealloc(buf);
}
out:
shutdown(sockd, SHUT_RD);
if (unlikely(!buf))
LOGERR("Failure in recv_unix_msg from %s %s:%d", file, func, line);
return buf;
}
/*
* read a sequence of bytes and add them to tree
*/
static void
read_bytes(unsigned int *offset, tvbuff_t *tvb, proto_tree *etch_tree)
{
int length;
read_type(offset, tvb, etch_tree);
length = read_length(offset, tvb, etch_tree);
proto_tree_add_item(etch_tree, hf_etch_bytes, tvb, *offset, length,
ENC_NA);
(*offset) += length;
}
static readstat_error_t read_generic_list(int attributes, rdata_ctx_t *ctx) {
readstat_error_t retval = READSTAT_OK;
int32_t length;
int i;
rdata_sexptype_info_t sexptype_info;
if ((retval = read_length(&length, ctx)) != READSTAT_OK)
goto cleanup;
for (i=0; i<length; i++) {
if ((retval = read_sexptype_header(&sexptype_info, ctx)) != READSTAT_OK)
goto cleanup;
if (sexptype_info.header.type == RDATA_SEXPTYPE_CHARACTER_VECTOR) {
int32_t vec_length;
if ((retval = read_length(&vec_length, ctx)) != READSTAT_OK)
goto cleanup;
if (ctx->column_handler) {
if (ctx->column_handler(NULL, READSTAT_TYPE_STRING, NULL, NULL, vec_length, ctx->user_ctx)) {
retval = READSTAT_ERROR_USER_ABORT;
goto cleanup;
}
}
retval = read_string_vector(vec_length, ctx->text_value_handler, ctx->user_ctx, ctx);
} else {
retval = read_value_vector(sexptype_info.header, NULL, ctx);
}
if (retval != READSTAT_OK)
goto cleanup;
}
if (attributes) {
if ((retval = read_attributes(&handle_data_frame_attribute, ctx)) != READSTAT_OK)
goto cleanup;
}
cleanup:
return retval;
}
//! @brief Read from peripheral until entire data framing packet read.
static status_t read_data_packet(framing_data_packet_t * packet, uint8_t * data, packet_type_t packetType)
{
// Read the packet header.
status_t status = read_header(&packet->header);
if (status != kStatus_Success)
{
return status;
}
if (packet->header.packetType == kFramingPacketType_Ping)
{
return serial_send_ping_response(g_bootloaderContext.activePeripheral);
}
uint8_t expectedPacketType = kFramingPacketType_Command;
if (packetType != kPacketType_Command)
{
expectedPacketType = kFramingPacketType_Data;
}
if (packet->header.packetType != expectedPacketType)
{
debug_printf("Error: read_data_packet found unexpected packet type 0x%x\r\n", packet->header.packetType);
return kStatus_Fail;
}
// Read the packet length.
status = read_length(packet);
if (status != kStatus_Success)
{
return status;
}
// Make sure the packet doesn't exceed the allocated buffer size.
packet->length = MIN(kIncomingPacketBufferSize, packet->length);
// Read the crc
status = read_crc16(packet);
if (status != kStatus_Success)
{
return status;
}
// Read the data.
if (packet->length > 0)
{
// Clear the data area so unsent parameters default to zero.
memset(data, 0, packet->length);
status = read_data(data, packet->length, kDefaultByteReadTimeoutMs * packet->length);
}
return status;
}
/*
* read a string and add it to tree
*/
static void
read_string(unsigned int *offset, tvbuff_t *tvb, proto_tree *etch_tree)
{
int byteLength;
read_type(offset, tvb, etch_tree);
byteLength = read_length(offset, tvb, etch_tree);
proto_tree_add_item(etch_tree, hf_etch_string, tvb, *offset,
byteLength, ENC_ASCII|ENC_NA);
(*offset) += byteLength;
}
static readstat_error_t read_string_vector(int32_t length, rdata_text_value_handler text_value_handler,
void *callback_ctx, rdata_ctx_t *ctx) {
int32_t string_length;
readstat_error_t retval = READSTAT_OK;
rdata_sexptype_info_t info;
size_t buffer_size = 4096;
char *buffer = NULL;
int i;
buffer = malloc(buffer_size);
for (i=0; i<length; i++) {
if ((retval = read_sexptype_header(&info, ctx)) != READSTAT_OK)
goto cleanup;
if (info.header.type != RDATA_SEXPTYPE_CHARACTER_STRING) {
retval = READSTAT_ERROR_PARSE;
goto cleanup;
}
if ((retval = read_length(&string_length, ctx)) != READSTAT_OK)
goto cleanup;
if (string_length + 1 > buffer_size) {
buffer = realloc(buffer, string_length + 1);
if (buffer == NULL) {
retval = READSTAT_ERROR_MALLOC;
goto cleanup;
}
}
if (read_st(ctx, buffer, string_length) != string_length) {
retval = READSTAT_ERROR_READ;
goto cleanup;
}
buffer[string_length] = '\0';
if (text_value_handler) {
if (text_value_handler(buffer, i, callback_ctx)) {
retval = READSTAT_ERROR_USER_ABORT;
goto cleanup;
}
}
}
cleanup:
if (buffer)
free(buffer);
return retval;
}
void TraCIClient::do_send_command( const CommandId command,
const TraciMessage &out,
TraciMessage &in ) const
{
// Preconditions
if ( ! socket_.get() )
{
std::cerr << "TraCIClient::do_send_command: no socket" << std::endl;
abort();
}
// Send command
try
{
socket_->sendExact( out );
socket_->receiveExact( in );
}
catch ( SocketException &e )
{
std::cerr << "Error in TraCIClient::do_send_command: " << e.what() << std::endl;
abort();
}
// check response
unsigned int command_start = in.position();
unsigned int command_length = read_length( in );
// check received command ID
UbyteType rcvdCommandId(in);
if ( command != rcvdCommandId )
{
std::cerr << sc_->world().scheduler().current_time();
std::cerr << ": Error in method TraCIClient::do_send_command, Server answered to command: ";
std::cerr << std::hex << "0x" << static_cast<unsigned int>(rcvdCommandId);
std::cerr << ". Expected command: 0x" << static_cast<unsigned int>(command) << std::dec << std::endl;
abort();
}
// check response status
const StatusResponseType response(in);
if ( !response.isSuccess() )
{
std::cerr << sc_->world().scheduler().current_time()
<< ": Error in method TraCIClient::do_send_command, Server returned error "
<< "[0x" << std::hex << std::setfill('0') << std::setw(2) << static_cast<unsigned int>(response.result) << "]: "
<< response.description << std::dec << std::setfill(' ') << std::endl;
abort();
}
// Right length?
check_position( in, command_start + command_length, "TraCIClient::do_send_command" );
}
static int handle_vector_attribute(char *key, rdata_sexptype_info_t val_info, rdata_ctx_t *ctx) {
readstat_error_t retval = READSTAT_OK;
if (strcmp(key, "levels") == 0) {
int32_t length;
if ((retval = read_length(&length, ctx)) != READSTAT_OK)
return retval;
retval = read_string_vector(length, ctx->value_label_handler, ctx->user_ctx, ctx);
} else if (strcmp(key, "class") == 0) {
int32_t length;
if ((retval = read_length(&length, ctx)) != READSTAT_OK)
return retval;
ctx->class_is_posixct = 0;
retval = read_string_vector(length, &handle_class_name, &ctx->class_is_posixct, ctx);
} else {
retval = recursive_discard(val_info.header, ctx);
}
return retval;
}
file *rl_decode(const char *data, long size) {
int i;
byte_buffer *buff = new_buffer(size);
memcpy(buff->buffer, data, size);
// 1. Get size of each run.
uchar bytes[2];
for (i = 0; i < 2; ++i) {
bytes[i] = get_next_byte(buff);
}
const ushort NUM_BITS = *((ushort *)bytes);
// 2. Decode data
int zeros = 1;
int remaining = 8 * size;
int max_len = (4 * size)/3;
byte_buffer *output = new_buffer(max_len);
i = 0;
while (remaining > NUM_BITS) {
int bits = read_length(buff, NUM_BITS);
for (i = 0; i < bits; ++i) {
if (zeros) {
append_bit_to_buffer(output, 0);
} else {
append_bit_to_buffer(output, 1);
}
}
zeros = (zeros == 0)? 1 : 0;
remaining -= NUM_BITS;
}
// 3. Convert output buffer to file
file *f = (file *)malloc(sizeof(file));
f->size = (long)output->current_byte;
f->data = (char *)malloc(f->size);
memcpy(f->data, output->buffer, f->size);
// 4. Free resources
free_buffer(output);
free_buffer(buff);
return f;
}
static int handle_data_frame_attribute(char *key, rdata_sexptype_info_t val_info, rdata_ctx_t *ctx) {
readstat_error_t retval = READSTAT_OK;
if (strcmp(key, "names") == 0 && val_info.header.type == RDATA_SEXPTYPE_CHARACTER_VECTOR) {
int32_t length;
if ((retval = read_length(&length, ctx)) != READSTAT_OK)
return retval;
retval = read_string_vector(length, ctx->column_name_handler, ctx->user_ctx, ctx);
} else if (strcmp(key, "label.table") == 0) {
retval = recursive_discard(val_info.header, ctx);
} else {
retval = recursive_discard(val_info.header, ctx);
}
return retval;
}
//---------------------------------------------------------------------
void TraCIClient::send_command( CommandId command,
const traci::TraciType & content,
traci::TraciType & answer ) const
throw( tcpip::SocketException )
{
Storage in;
send_command(command, content, in);
if ( !in.valid_pos() )
throw std::runtime_error( "traci::TraCIClient::send_command: missing response command" );
const unsigned int commandStart = in.position();
const unsigned int commandLength = read_length(in);
answer.read(in);
check_position( in, commandStart + commandLength, "TraCIClient::command_get_value" );
}
inline void QTrimImpl ( FORMAT<TUPLETYPE>& fq )
{
std::vector< float > sum_qscores;
MapQualityToSumScore ( std::get<3>(fq.data), sum_qscores );
size_t read_length ( std::get<1>(fq.data).size() );
size_t cut_pos(0);
while ( read_length > quality_score_trait_.min_read_length_ )
{
if ( sum_qscores[read_length-1] < quality_score_trait_.q_table_[read_length-1] )
{
++cut_pos;
--read_length;
}
else
break;
}
std::get<1>(fq.data).resize ( std::get<1>(fq.data).size() - cut_pos );
std::get<3>(fq.data).resize ( std::get<3>(fq.data).size() - cut_pos );
}
static codepoint_type decode(Iter c) {
size_t len = read_length(static_cast<codeunit_type>(*c));
codepoint_type res = 0;
// switch on first byte
switch (len) {
case 1: res = *c; break;
case 2: res = *c & 0x1f; break;
case 3: res = *c & 0x0f; break;
case 4: res = *c & 0x07; break;
default:
assert(false && "bad utf8 codeunit");
};
// then loop to catch remaining?
for (size_t i = 1; i < len; ++i) {
res = (res << 6) | (c[i] & 0x3f);
}
return res;
}
int main(int argc, char **argv) {
unsigned int status = 0;
int length = 0;
if ((status=usage(argc, argv, 2, 1)) == FILE_OPEN_SUCCESS) { // if correct arguments, i.e, having a input file
FILE *fp = fopen(argv[1], "r");
if ((status=parse_header(fp)) == PARSE_HEADER_SUCCESS) {
length = read_length(fp);
printf("length: %d\n", length);
char * msg;
msg = read_hidden_msg(fp, length);
printf("%s\n", msg); // ouput hidden messaage
}
fclose(fp);
}
return EXIT_SUCCESS;
}
/*
* read an array from tvb and add it to tree
*/
static void
read_array(unsigned int *offset, tvbuff_t *tvb, proto_tree *etch_tree)
{
int length;
/* array type */
read_type(offset, tvb, etch_tree);
/* Array of type: */
read_array_type(offset, tvb, etch_tree);
/* Array dim */
proto_tree_add_item(etch_tree, hf_etch_dim, tvb, *offset, 1, ENC_BIG_ENDIAN);
(*offset)++;
/* Array length */
length = read_length(offset, tvb, etch_tree);
for (; length > 0; length--) {
read_value(offset, tvb, etch_tree, hf_etch_value);
}
/* terminaton */
read_type(offset, tvb, etch_tree);
}
void main(void) {
unsigned char cal_length, cal_dia;
unsigned int length, dia, dia_offset, latest_l, latest_d;
unsigned int tot_acc, mass_acc, timb_acc;
unsigned int tot_num, mass_num, timb_num;
unsigned int count1, count2, count3;
OSCCON = 255;
OSCTUNEbits.PLLEN = 1;
TRISA = 0b00011111;
PORTA = 0;
ADCON1 = 0b00001101;
TRISB = 0;
PORTB = 0;
TRISC = 0b00010000;
PORTC = 0b00000000;
TRISD = 0;
PORTD = 0;
TRISE = 0;
PORTE = 0;
init_display();
init_counters();
LED1 = 0;
LED2 = 0;
LED3 = 0;
latest_l = 0;
latest_d = 0;
tot_acc = 0;
tot_num = 0;
timb_acc = 0;
timb_num = 0;
mass_acc = 0;
mass_num = 0;
cal_length = read_ad(0);
cal_dia = read_ad(1);
dia_offset = 2;
while (1) {
length = read_length(cal_length);
dia = dia_offset + read_diameter(cal_dia);
write_length(length);
write_dia(dia);
if (!CALIBRATE) {
count1 = read_counter(1);
count2 = read_counter(2);
count3 = read_counter(3);
cal_length = read_ad(0);
cal_dia = read_ad(1);
write_debug_info(cal_length, cal_dia, count1, count2, count3);
}
if (!RESET_DIA) {
reset_dia();
}
if (!RESET_LENGTH) {
delay(20000);
delay(20000);
if (!RESET_LENGTH) {
LED1 = 1;
if (length >= 100) {
tot_num = tot_num + 1;
tot_acc = tot_acc + length / 100;
latest_l = length;
latest_d = dia;
if (dia >= 15) {
timb_num = timb_num + 1;
timb_acc = timb_acc + length / 100;
} else {
mass_num = mass_num + 1;
mass_acc = mass_acc + length / 100;
}
}
reset_length();
while (!RESET_LENGTH) {
write_length(0);
write_dia(0);
write_length(8);
write_dia(8);
}
write_stats(latest_l, latest_d, tot_num, tot_acc, timb_num, timb_acc, mass_num, mass_acc);
LED1 = 0;
}
}
}
}
std::string request_get_dot_output(smx_simcall_t req, int value)
{
std::string label;
const smx_actor_t issuer = MC_smx_simcall_get_issuer(req);
switch (req->call) {
case SIMCALL_COMM_ISEND:
if (issuer->host)
label = simgrid::xbt::string_printf("[(%lu)%s] iSend", issuer->pid,
MC_smx_process_get_host_name(issuer));
else
label = bprintf("[(%lu)] iSend", issuer->pid);
break;
case SIMCALL_COMM_IRECV:
if (issuer->host)
label = simgrid::xbt::string_printf("[(%lu)%s] iRecv", issuer->pid,
MC_smx_process_get_host_name(issuer));
else
label = simgrid::xbt::string_printf("[(%lu)] iRecv", issuer->pid);
break;
case SIMCALL_COMM_WAIT: {
if (value == -1) {
if (issuer->host)
label = simgrid::xbt::string_printf("[(%lu)%s] WaitTimeout", issuer->pid,
MC_smx_process_get_host_name(issuer));
else
label = simgrid::xbt::string_printf("[(%lu)] WaitTimeout", issuer->pid);
} else {
smx_activity_t remote_act = simcall_comm_wait__get__comm(req);
simgrid::mc::Remote<simgrid::kernel::activity::Comm> temp_comm;
mc_model_checker->process().read(temp_comm, remote(
static_cast<simgrid::kernel::activity::Comm*>(remote_act)));
simgrid::kernel::activity::Comm* comm = temp_comm.getBuffer();
smx_actor_t src_proc = mc_model_checker->process().resolveProcess(
simgrid::mc::remote(comm->src_proc));
smx_actor_t dst_proc = mc_model_checker->process().resolveProcess(
simgrid::mc::remote(comm->dst_proc));
if (issuer->host)
label = simgrid::xbt::string_printf("[(%lu)%s] Wait [(%lu)->(%lu)]",
issuer->pid,
MC_smx_process_get_host_name(issuer),
src_proc ? src_proc->pid : 0,
dst_proc ? dst_proc->pid : 0);
else
label = simgrid::xbt::string_printf("[(%lu)] Wait [(%lu)->(%lu)]",
issuer->pid,
src_proc ? src_proc->pid : 0,
dst_proc ? dst_proc->pid : 0);
}
break;
}
case SIMCALL_COMM_TEST: {
smx_activity_t remote_act = simcall_comm_test__get__comm(req);
simgrid::mc::Remote<simgrid::kernel::activity::Comm> temp_comm;
mc_model_checker->process().read(temp_comm, remote(
static_cast<simgrid::kernel::activity::Comm*>(remote_act)));
simgrid::kernel::activity::Comm* comm = temp_comm.getBuffer();
if (comm->src_proc == nullptr || comm->dst_proc == nullptr) {
if (issuer->host)
label = simgrid::xbt::string_printf("[(%lu)%s] Test FALSE",
issuer->pid,
MC_smx_process_get_host_name(issuer));
else
label = bprintf("[(%lu)] Test FALSE", issuer->pid);
} else {
if (issuer->host)
label = simgrid::xbt::string_printf("[(%lu)%s] Test TRUE", issuer->pid,
MC_smx_process_get_host_name(issuer));
else
label = simgrid::xbt::string_printf("[(%lu)] Test TRUE", issuer->pid);
}
break;
}
case SIMCALL_COMM_WAITANY: {
unsigned long comms_size = read_length(
mc_model_checker->process(), remote(simcall_comm_waitany__get__comms(req)));
if (issuer->host)
label = simgrid::xbt::string_printf("[(%lu)%s] WaitAny [%d of %lu]",
issuer->pid,
MC_smx_process_get_host_name(issuer), value + 1,
comms_size);
else
label = simgrid::xbt::string_printf("[(%lu)] WaitAny [%d of %lu]",
issuer->pid, value + 1, comms_size);
break;
}
case SIMCALL_COMM_TESTANY:
if (value == -1) {
if (issuer->host)
label = simgrid::xbt::string_printf("[(%lu)%s] TestAny FALSE",
issuer->pid, MC_smx_process_get_host_name(issuer));
else
label = simgrid::xbt::string_printf("[(%lu)] TestAny FALSE", issuer->pid);
} else {
if (issuer->host)
label = simgrid::xbt::string_printf("[(%lu)%s] TestAny TRUE [%d of %lu]",
issuer->pid,
MC_smx_process_get_host_name(issuer), value + 1,
simcall_comm_testany__get__count(req));
else
label = simgrid::xbt::string_printf("[(%lu)] TestAny TRUE [%d of %lu]",
issuer->pid,
value + 1,
simcall_comm_testany__get__count(req));
}
break;
case SIMCALL_MUTEX_TRYLOCK:
label = simgrid::xbt::string_printf("[(%lu)] Mutex TRYLOCK", issuer->pid);
break;
case SIMCALL_MUTEX_LOCK:
label = simgrid::xbt::string_printf("[(%lu)] Mutex LOCK", issuer->pid);
break;
case SIMCALL_MC_RANDOM:
if (issuer->host)
label = simgrid::xbt::string_printf("[(%lu)%s] MC_RANDOM (%d)",
issuer->pid, MC_smx_process_get_host_name(issuer), value);
else
label = simgrid::xbt::string_printf("[(%lu)] MC_RANDOM (%d)", issuer->pid, value);
break;
default:
THROW_UNIMPLEMENTED;
}
const char* color = get_color(issuer->pid - 1);
return simgrid::xbt::string_printf(
"label = \"%s\", color = %s, fontcolor = %s", label.c_str(),
color, color);
}
char *request_get_dot_output(smx_simcall_t req, int value)
{
char *label = nullptr;
const smx_process_t issuer = MC_smx_simcall_get_issuer(req);
switch (req->call) {
case SIMCALL_COMM_ISEND:
if (issuer->host)
label =
bprintf("[(%lu)%s] iSend", issuer->pid,
MC_smx_process_get_host_name(issuer));
else
label = bprintf("[(%lu)] iSend", issuer->pid);
break;
case SIMCALL_COMM_IRECV:
if (issuer->host)
label =
bprintf("[(%lu)%s] iRecv", issuer->pid,
MC_smx_process_get_host_name(issuer));
else
label = bprintf("[(%lu)] iRecv", issuer->pid);
break;
case SIMCALL_COMM_WAIT: {
if (value == -1) {
if (issuer->host)
label =
bprintf("[(%lu)%s] WaitTimeout", issuer->pid,
MC_smx_process_get_host_name(issuer));
else
label = bprintf("[(%lu)] WaitTimeout", issuer->pid);
} else {
smx_synchro_t remote_act = simcall_comm_wait__get__comm(req);
s_smx_synchro_t synchro;
mc_model_checker->process().read_bytes(&synchro,
sizeof(synchro), remote(remote_act));
smx_process_t src_proc = MC_smx_resolve_process(synchro.comm.src_proc);
smx_process_t dst_proc = MC_smx_resolve_process(synchro.comm.dst_proc);
if (issuer->host)
label =
bprintf("[(%lu)%s] Wait [(%lu)->(%lu)]", issuer->pid,
MC_smx_process_get_host_name(issuer),
src_proc ? src_proc->pid : 0,
dst_proc ? dst_proc->pid : 0);
else
label =
bprintf("[(%lu)] Wait [(%lu)->(%lu)]", issuer->pid,
src_proc ? src_proc->pid : 0,
dst_proc ? dst_proc->pid : 0);
}
break;
}
case SIMCALL_COMM_TEST: {
smx_synchro_t remote_act = simcall_comm_test__get__comm(req);
s_smx_synchro_t synchro;
mc_model_checker->process().read_bytes(&synchro,
sizeof(synchro), remote(remote_act));
if (synchro.comm.src_proc == nullptr || synchro.comm.dst_proc == NULL) {
if (issuer->host)
label =
bprintf("[(%lu)%s] Test FALSE", issuer->pid,
MC_smx_process_get_host_name(issuer));
else
label = bprintf("[(%lu)] Test FALSE", issuer->pid);
} else {
if (issuer->host)
label =
bprintf("[(%lu)%s] Test TRUE", issuer->pid,
MC_smx_process_get_host_name(issuer));
else
label = bprintf("[(%lu)] Test TRUE", issuer->pid);
}
break;
}
case SIMCALL_COMM_WAITANY: {
unsigned long comms_size = read_length(
mc_model_checker->process(), remote(simcall_comm_waitany__get__comms(req)));
if (issuer->host)
label =
bprintf("[(%lu)%s] WaitAny [%d of %lu]", issuer->pid,
MC_smx_process_get_host_name(issuer), value + 1,
comms_size);
else
label =
bprintf("[(%lu)] WaitAny [%d of %lu]", issuer->pid, value + 1,
comms_size);
break;
}
case SIMCALL_COMM_TESTANY:
if (value == -1) {
if (issuer->host)
label =
bprintf("[(%lu)%s] TestAny FALSE", issuer->pid,
MC_smx_process_get_host_name(issuer));
else
label = bprintf("[(%lu)] TestAny FALSE", issuer->pid);
} else {
if (issuer->host)
label =
bprintf("[(%lu)%s] TestAny TRUE [%d of %lu]", issuer->pid,
MC_smx_process_get_host_name(issuer), value + 1,
xbt_dynar_length(simcall_comm_testany__get__comms(req)));
else
label =
bprintf("[(%lu)] TestAny TRUE [%d of %lu]", issuer->pid,
value + 1,
xbt_dynar_length(simcall_comm_testany__get__comms(req)));
}
break;
case SIMCALL_MUTEX_TRYLOCK:
label = bprintf("[(%lu)] Mutex TRYLOCK", issuer->pid);
break;
case SIMCALL_MUTEX_LOCK:
label = bprintf("[(%lu)] Mutex LOCK", issuer->pid);
break;
case SIMCALL_MC_RANDOM:
if (issuer->host)
label =
bprintf("[(%lu)%s] MC_RANDOM (%d)", issuer->pid,
MC_smx_process_get_host_name(issuer), value);
else
label = bprintf("[(%lu)] MC_RANDOM (%d)", issuer->pid, value);
break;
default:
THROW_UNIMPLEMENTED;
}
char* str =
bprintf("label = \"%s\", color = %s, fontcolor = %s", label,
colors[issuer->pid - 1], colors[issuer->pid - 1]);
xbt_free(label);
return str;
}
static readstat_error_t read_value_vector(rdata_sexptype_header_t header, const char *name, rdata_ctx_t *ctx) {
readstat_error_t retval = READSTAT_OK;
int32_t length;
size_t input_elem_size = 0;
void *vals = NULL;
size_t buf_len = 0;
int output_data_type;
int i;
switch (header.type) {
case RDATA_SEXPTYPE_REAL_VECTOR:
input_elem_size = sizeof(double);
output_data_type = READSTAT_TYPE_DOUBLE;
break;
case RDATA_SEXPTYPE_INTEGER_VECTOR:
input_elem_size = sizeof(int32_t);
output_data_type = READSTAT_TYPE_DOUBLE;
break;
case RDATA_SEXPTYPE_LOGICAL_VECTOR:
input_elem_size = sizeof(int32_t);
output_data_type = READSTAT_TYPE_DOUBLE;
break;
default:
retval = READSTAT_ERROR_PARSE;
break;
}
if (retval != READSTAT_OK)
goto cleanup;
if ((retval = read_length(&length, ctx)) != READSTAT_OK)
goto cleanup;
buf_len = length * input_elem_size;
vals = malloc(buf_len);
if (vals == NULL) {
retval = READSTAT_ERROR_MALLOC;
goto cleanup;
}
if (read_st(ctx, vals, buf_len) != buf_len) {
retval = READSTAT_ERROR_READ;
goto cleanup;
}
if (ctx->machine_needs_byteswap) {
if (input_elem_size == sizeof(double)) {
double *d_vals = (double *)vals;
for (i=0; i<buf_len/sizeof(double); i++) {
d_vals[i] = byteswap_double(d_vals[i]);
}
} else {
uint32_t *i_vals = (uint32_t *)vals;
for (i=0; i<buf_len/sizeof(uint32_t); i++) {
i_vals[i] = byteswap4(i_vals[i]);
}
}
}
ctx->class_is_posixct = 0;
if (header.attributes) {
if ((retval = read_attributes(&handle_vector_attribute, ctx)) != READSTAT_OK)
goto cleanup;
}
if (ctx->column_handler) {
if (header.type == RDATA_SEXPTYPE_LOGICAL_VECTOR ||
header.type == RDATA_SEXPTYPE_INTEGER_VECTOR) {
double *real_vals = malloc(length * sizeof(double));
int32_t *i_vals = (int32_t *)vals;
for (i=0; i<length; i++) {
if (i_vals[i] == INT32_MIN) {
real_vals[i] = NAN;
} else {
real_vals[i] = i_vals[i];
}
}
if (ctx->column_handler(name, output_data_type, NULL, real_vals, length, ctx->user_ctx)) {
retval = READSTAT_ERROR_USER_ABORT;
goto cleanup;
}
free(real_vals);
} else {
if (ctx->column_handler(name, output_data_type, ctx->class_is_posixct ? "%ts" : NULL, vals, length, ctx->user_ctx)) {
retval = READSTAT_ERROR_USER_ABORT;
goto cleanup;
}
}
}
cleanup:
return retval;
}
int main(int argc, char **argv)
{
int32 length;
int c, block = 1, last_type = ASCII;
ifp = stdin;
ofp = stdout;
print_banner();
if (argc > 3)
usage();
/* possibly open input & output files */
if (argc >= 2) {
ifp = fopen(argv[1], "r");
if (!ifp) {
fprintf(stderr, "error: cannot open %s for reading\n", argv[1]);
exit(1);
}
}
if (argc == 3) {
ofp = fopen(argv[2], "w");
if (!ofp) {
fprintf(stderr, "error: cannot open %s for writing\n", argv[2]);
exit(1);
}
}
#ifdef _MSDOS
/* As we are processing a PFB (binary) input */
/* file, we must set its file mode to binary. */
_setmode(_fileno(ifp), _O_BINARY);
#endif
/* main loop through blocks */
for (;;) {
c = fgetc(ifp);
if (c == EOF) {
break;
}
if (c != MARKER) {
fprintf(stderr,
"error: missing marker (128) at beginning of block %d",
block);
exit(1);
}
switch (c = fgetc(ifp)) {
case ASCII:
if (last_type != ASCII)
fputc('\n', ofp);
last_type = ASCII;
for (length = read_length(); length > 0; length--)
if ((c = fgetc(ifp)) == '\r')
fputc('\n', ofp);
else
fputc(c, ofp);
break;
case BINARY:
last_type = BINARY;
for (length = read_length(); length > 0; length--)
output_hex(fgetc(ifp));
break;
case DONE:
/* nothing to be done --- will exit at top of loop with EOF */
break;
default:
fprintf(stderr, "error: bad block type %d in block %d\n",
c, block);
break;
}
block++;
}
fclose(ifp);
fclose(ofp);
syncfs("/");
return 0;
}
bool format(const DistributedType* dtype)
{
Type type = dtype->get_type();
switch(type) {
case T_INVALID: {
out << "<invalid>";
break;
}
case T_INT8: {
if(!remaining(sizeof(int8_t))) {
return false;
}
int v = *(int8_t*)(in + offset);
offset += sizeof(int8_t);
out << v;
break;
}
case T_INT16: {
if(!remaining(sizeof(int16_t))) {
return false;
}
int v = swap_le(*(int16_t*)(in + offset));
offset += sizeof(int16_t);
out << v;
break;
}
case T_INT32: {
if(!remaining(sizeof(int32_t))) {
return false;
}
int v = swap_le(*(int32_t*)(in + offset));
offset += sizeof(int32_t);
out << v;
break;
}
case T_INT64: {
if(!remaining(sizeof(int64_t))) {
return false;
}
int64_t v = swap_le(*(int64_t*)(in + offset));
offset += sizeof(int64_t);
out << v;
break;
}
case T_UINT8: {
if(!remaining(sizeof(uint8_t))) {
return false;
}
unsigned int v = *(uint8_t*)(in + offset);
offset += sizeof(uint8_t);
out << v;
break;
}
case T_UINT16: {
if(!remaining(sizeof(uint16_t))) {
return false;
}
unsigned int v = swap_le(*(uint16_t*)(in + offset));
offset += sizeof(uint16_t);
out << v;
break;
}
case T_UINT32: {
if(!remaining(sizeof(uint32_t))) {
return false;
}
unsigned int v = swap_le(*(uint32_t*)(in + offset));
offset += sizeof(uint32_t);
out << v;
break;
}
case T_UINT64: {
if(!remaining(sizeof(uint64_t))) {
return false;
}
uint64_t v = swap_le(*(uint64_t*)(in + offset));
offset += sizeof(uint64_t);
out << v;
break;
}
case T_FLOAT32: {
if(!remaining(sizeof(float))) {
return false;
}
float v = (float)swap_le(*(float*)(in + offset));
offset += sizeof(float);
out << v;
break;
}
case T_FLOAT64: {
if(!remaining(sizeof(double))) {
return false;
}
double v = (double)swap_le(*(double*)(in + offset));
offset += sizeof(double);
out << v;
break;
}
case T_CHAR: {
if(!remaining(sizeof(char))) {
return false;
}
char v = *(char*)(in + offset);
format_quoted('\'', string(1, v), out);
offset += sizeof(char);
break;
}
case T_STRING: {
// Read string length
sizetag_t length = dtype->get_size();
// If we have a string alias format as a quoted string
if(dtype->has_alias() && dtype->get_alias() == "string") {
// Read string
if(!remaining(length)) {
return false;
}
string str((const char*)in + offset, length);
offset += length;
// Enquoute and escape string then output
format_quoted('"', str, out);
} else {
// Otherwise format as an array of char
out << '[';
const ArrayType* arr = dtype->as_array();
bool ok = format(arr->get_element_type());
if(!ok) {
return false;
}
for(unsigned int i = 1; i < arr->get_array_size(); ++i) {
out << ", ";
ok = format(arr->get_element_type());
if(!ok) {
return false;
}
}
out << ']';
}
break;
}
case T_VARSTRING: {
// If we have a string alias format as a quoted string
if(dtype->has_alias() && dtype->get_alias() == "string") {
// Read string length
if(!remaining(sizeof(sizetag_t))) {
return false;
}
sizetag_t length = read_length();
// Read string
if(!remaining(length)) {
return false;
}
string str((const char*)in + offset, length);
offset += length;
// Enquoute and escape string then output
format_quoted('"', str, out);
} else {
// Otherwise format as an array of char
out << '[';
// Read array byte length
if(!remaining(sizeof(sizetag_t))) {
out << ']';
return false;
}
sizetag_t length = read_length();
if(length == 0) {
out << ']';
break;
}
// Read array
if(!remaining(length)) {
out << ']';
return false;
}
size_t array_end = offset + length;
const ArrayType* arr = dtype->as_array();
bool ok = format(arr->get_element_type());
if(!ok) {
out << ']';
return false;
}
while(offset < array_end) {
out << ", ";
ok = format(arr->get_element_type());
if(!ok) {
out << ']';
return false;
}
}
// Check to make sure we didn't overshoot the array while reading
if(offset > array_end) {
out << ']';
return false;
}
out << ']';
}
break;
}
case T_BLOB: {
// Read blob length
sizetag_t length = dtype->get_size();
// If we have a blob alias format as a hex constant
if(dtype->has_alias() && dtype->get_alias() == "blob") {
// Read blob
if(!remaining(length)) {
return false;
}
string blob((const char*)in + offset, length);
offset += length;
// Format blob as a hex constant then output
format_hex(blob, out);
} else {
// Otherwise format as an array of uint8
out << '[';
const ArrayType* arr = dtype->as_array();
bool ok = format(arr->get_element_type());
if(!ok) {
out << ']';
return false;
}
for(unsigned int i = 1; i < arr->get_array_size(); ++i) {
out << ", ";
ok = format(arr->get_element_type());
if(!ok) {
out << ']';
return false;
}
}
out << ']';
}
break;
}
case T_VARBLOB: {
// If we have a blob alias format as a hex constant
if(dtype->has_alias() && dtype->get_alias() == "blob") {
// Read blob length
if(!remaining(sizeof(sizetag_t))) {
return false;
}
sizetag_t length = read_length();
// Read blob with length
if(!remaining(length)) {
return false;
}
string blob((const char*)in + offset - 2, length + 2);
offset += length;
// Format blob and length as a hex constant then output
format_hex(blob, out);
} else {
// Otherwise format as an array of uint8
out << '[';
// Read array byte length
if(!remaining(sizeof(sizetag_t))) {
out << ']';
return false;
}
sizetag_t length = read_length();
if(length == 0) {
out << ']';
break;
}
// Read array
if(!remaining(length)) {
out << ']';
return false;
}
size_t array_end = offset + length;
const ArrayType* arr = dtype->as_array();
bool ok = format(arr->get_element_type());
if(!ok) {
out << ']';
return false;
}
while(offset < array_end) {
out << ", ";
ok = format(arr->get_element_type());
if(!ok) {
out << ']';
return false;
}
}
// Check to make sure we didn't overshoot the array while reading
if(offset > array_end) {
out << ']';
return false;
}
out << ']';
}
break;
}
case T_ARRAY: {
out << '[';
const ArrayType* arr = dtype->as_array();
bool ok = format(arr->get_element_type());
if(!ok) {
out << ']';
return false;
}
for(unsigned int i = 1; i < arr->get_array_size(); ++i) {
out << ", ";
ok = format(arr->get_element_type());
if(!ok) {
out << ']';
return false;
}
}
out << ']';
break;
}
case T_VARARRAY: {
out << '[';
// Read array byte length
if(!remaining(sizeof(sizetag_t))) {
out << ']';
return false;
}
sizetag_t length = read_length();
if(length == 0) {
out << ']';
break;
}
// Read array
if(!remaining(length)) {
out << ']';
return false;
}
size_t array_end = offset + length;
const ArrayType* arr = dtype->as_array();
bool ok = format(arr->get_element_type());
if(!ok) {
out << ']';
return false;
}
while(offset < array_end) {
out << ", ";
ok = format(arr->get_element_type());
if(!ok) {
out << ']';
return false;
}
}
// Check to make sure we didn't overshoot the array while reading
if(offset > array_end) {
out << ']';
return false;
}
out << ']';
break;
}
case T_STRUCT: {
out << '{';
const Struct* strct = dtype->as_struct();
size_t num_fields = strct->get_num_fields();
if(num_fields > 0) {
bool ok = format(strct->get_field(0)->get_type());
if(!ok) {
out << '}';
return false;
}
for(unsigned int i = 1; i < num_fields; ++i) {
out << ", ";
ok = format(strct->get_field(i)->get_type());
if(!ok) {
out << '}';
return false;
}
}
}
out << '}';
break;
}
case T_METHOD: {
out << '(';
const Method* method = dtype->as_method();
size_t num_params = method->get_num_parameters();
if(num_params > 0) {
bool ok = format(method->get_parameter(0)->get_type());
if(!ok) {
out << ')';
return false;
}
for(unsigned int i = 1; i < num_params; ++i) {
out << ", ";
ok = format(method->get_parameter(i)->get_type());
if(!ok) {
out << ')';
return false;
}
}
}
out << ')';
break;
}
default: {
out << "<error>";
return false;
}
}
return true;
}
static readstat_error_t read_toplevel_object(const char *table_name, const char *key, rdata_ctx_t *ctx) {
rdata_sexptype_info_t sexptype_info;
readstat_error_t retval = READSTAT_OK;
if ((retval = read_sexptype_header(&sexptype_info, ctx)) != READSTAT_OK)
goto cleanup;
if (sexptype_info.header.type == RDATA_SEXPTYPE_REAL_VECTOR ||
sexptype_info.header.type == RDATA_SEXPTYPE_INTEGER_VECTOR ||
sexptype_info.header.type == RDATA_SEXPTYPE_LOGICAL_VECTOR) {
if (table_name == NULL && ctx->table_handler) {
if (ctx->table_handler(key, ctx->user_ctx)) {
retval = READSTAT_ERROR_USER_ABORT;
goto cleanup;
}
}
if ((retval = read_value_vector(sexptype_info.header, key, ctx)) != READSTAT_OK)
goto cleanup;
} else if (sexptype_info.header.type == RDATA_SEXPTYPE_CHARACTER_VECTOR) {
if (table_name == NULL && ctx->table_handler) {
if (ctx->table_handler(key, ctx->user_ctx)) {
retval = READSTAT_ERROR_USER_ABORT;
goto cleanup;
}
}
int32_t length;
if ((retval = read_length(&length, ctx)) != READSTAT_OK)
goto cleanup;
if (ctx->column_handler) {
if (ctx->column_handler(key, READSTAT_TYPE_STRING, NULL, NULL, length, ctx->user_ctx)) {
retval = READSTAT_ERROR_USER_ABORT;
goto cleanup;
}
}
if ((retval = read_string_vector(length, ctx->text_value_handler, ctx->user_ctx, ctx)) != READSTAT_OK)
goto cleanup;
} else if (sexptype_info.header.type == RDATA_SEXPTYPE_GENERIC_VECTOR &&
sexptype_info.header.object && sexptype_info.header.attributes) {
if (table_name != NULL) {
retval = recursive_discard(sexptype_info.header, ctx);
} else {
if (ctx->table_handler) {
if (ctx->table_handler(key, ctx->user_ctx)) {
retval = READSTAT_ERROR_USER_ABORT;
goto cleanup;
}
}
retval = read_generic_list(sexptype_info.header.attributes, ctx);
}
if (retval != READSTAT_OK)
goto cleanup;
} else {
if ((retval = recursive_discard(sexptype_info.header, ctx)) != READSTAT_OK)
goto cleanup;
}
cleanup:
return retval;
}
/*
* The segment magic has been checked. There is a footer and table of
* contents present.
*
* directory is a u32 aligned buffer of size EP_PAGE_SIZE.
*/
static int read_segment_platform_config(struct hfi1_devdata *dd,
void *directory, void **data, u32 *size)
{
struct hfi1_eprom_footer *footer;
struct hfi1_eprom_table_entry *table;
struct hfi1_eprom_table_entry *entry;
void *buffer = NULL;
void *table_buffer = NULL;
int ret, i;
u32 directory_size;
u32 seg_base, seg_offset;
u32 bytes_available, ncopied, to_copy;
/* the footer is at the end of the directory */
footer = (struct hfi1_eprom_footer *)
(directory + EP_PAGE_SIZE - sizeof(*footer));
/* make sure the structure version is supported */
if (footer->version != FOOTER_VERSION)
return -EINVAL;
/* oprom size cannot be larger than a segment */
if (footer->oprom_size >= SEG_SIZE)
return -EINVAL;
/* the file table must fit in a segment with the oprom */
if (footer->num_table_entries >
MAX_TABLE_ENTRIES(SEG_SIZE - footer->oprom_size))
return -EINVAL;
/* find the file table start, which precedes the footer */
directory_size = DIRECTORY_SIZE(footer->num_table_entries);
if (directory_size <= EP_PAGE_SIZE) {
/* the file table fits into the directory buffer handed in */
table = (struct hfi1_eprom_table_entry *)
(directory + EP_PAGE_SIZE - directory_size);
} else {
/* need to allocate and read more */
table_buffer = kmalloc(directory_size, GFP_KERNEL);
if (!table_buffer)
return -ENOMEM;
ret = read_length(dd, SEG_SIZE - directory_size,
directory_size, table_buffer);
if (ret)
goto done;
table = table_buffer;
}
/* look for the platform configuration file in the table */
for (entry = NULL, i = 0; i < footer->num_table_entries; i++) {
if (table[i].type == HFI1_EFT_PLATFORM_CONFIG) {
entry = &table[i];
break;
}
}
if (!entry) {
ret = -ENOENT;
goto done;
}
/*
* Sanity check on the configuration file size - it should never
* be larger than 4 KiB.
*/
if (entry->size > (4 * 1024)) {
dd_dev_err(dd, "Bad configuration file size 0x%x\n",
entry->size);
ret = -EINVAL;
goto done;
}
/* check for bogus offset and size that wrap when added together */
if (entry->offset + entry->size < entry->offset) {
dd_dev_err(dd,
"Bad configuration file start + size 0x%x+0x%x\n",
entry->offset, entry->size);
ret = -EINVAL;
goto done;
}
/* allocate the buffer to return */
buffer = kmalloc(entry->size, GFP_KERNEL);
if (!buffer) {
ret = -ENOMEM;
goto done;
}
/*
* Extract the file by looping over segments until it is fully read.
*/
seg_offset = entry->offset % SEG_SIZE;
seg_base = entry->offset - seg_offset;
ncopied = 0;
while (ncopied < entry->size) {
/* calculate data bytes available in this segment */
/* start with the bytes from the current offset to the end */
bytes_available = SEG_SIZE - seg_offset;
/* subtract off footer and table from segment 0 */
if (seg_base == 0) {
/*
* Sanity check: should not have a starting point
* at or within the directory.
*/
if (bytes_available <= directory_size) {
dd_dev_err(dd,
"Bad configuration file - offset 0x%x within footer+table\n",
entry->offset);
ret = -EINVAL;
goto done;
}
bytes_available -= directory_size;
}
/* calculate bytes wanted */
to_copy = entry->size - ncopied;
/* max out at the available bytes in this segment */
if (to_copy > bytes_available)
to_copy = bytes_available;
/*
* Read from the EPROM.
*
* The sanity check for entry->offset is done in read_length().
* The EPROM offset is validated against what the hardware
* addressing supports. In addition, if the offset is larger
* than the actual EPROM, it silently wraps. It will work
* fine, though the reader may not get what they expected
* from the EPROM.
*/
ret = read_length(dd, seg_base + seg_offset, to_copy,
buffer + ncopied);
if (ret)
goto done;
ncopied += to_copy;
/* set up for next segment */
seg_offset = footer->oprom_size;
seg_base += SEG_SIZE;
}
/* success */
ret = 0;
*data = buffer;
*size = entry->size;
done:
kfree(table_buffer);
if (ret)
kfree(buffer);
return ret;
}
void LVCssDeclaration::apply( css_style_rec_t * style )
{
if (!_data)
return;
int * p = _data;
for (;;)
{
switch (*p++)
{
case cssd_display:
style->display = (css_display_t) *p++;
break;
case cssd_white_space:
style->white_space = (css_white_space_t) *p++;
break;
case cssd_text_align:
style->text_align = (css_text_align_t) *p++;
break;
case cssd_text_align_last:
style->text_align_last = (css_text_align_t) *p++;
break;
case cssd_text_decoration:
style->text_decoration = (css_text_decoration_t) *p++;
break;
case cssd_hyphenate:
style->hyphenate = (css_hyphenate_t) *p++;
break;
case cssd_list_style_type:
style->list_style_type = (css_list_style_type_t) *p++;
break;
case cssd_list_style_position:
style->list_style_position = (css_list_style_position_t) *p++;
break;
case cssd_page_break_before:
style->page_break_before = (css_page_break_t) *p++;
break;
case cssd_page_break_after:
style->page_break_after = (css_page_break_t) *p++;
break;
case cssd_page_break_inside:
style->page_break_inside = (css_page_break_t) *p++;
break;
case cssd_vertical_align:
style->vertical_align = (css_vertical_align_t) *p++;
break;
case cssd_font_family:
style->font_family = (css_font_family_t) *p++;
break;
case cssd_font_names:
{
lString8 names;
names.reserve(64);
int len = *p++;
for (int i=0; i<len; i++)
names << (lChar8)(*p++);
names.pack();
style->font_name = names;
}
break;
case cssd_font_style:
style->font_style = (css_font_style_t) *p++;
break;
case cssd_font_weight:
style->font_weight = (css_font_weight_t) *p++;
break;
case cssd_font_size:
style->font_size = read_length( p );
break;
case cssd_text_indent:
style->text_indent = read_length( p );
break;
case cssd_line_height:
style->line_height = read_length( p );
break;
case cssd_letter_spacing:
style->letter_spacing = read_length( p );
break;
case cssd_color:
style->color = read_length( p );
break;
case cssd_background_color:
style->background_color = read_length( p );
break;
case cssd_width:
style->width = read_length( p );
break;
case cssd_height:
style->height = read_length( p );
break;
case cssd_margin_left:
style->margin[0] = read_length( p );
break;
case cssd_margin_right:
style->margin[1] = read_length( p );
break;
case cssd_margin_top:
style->margin[2] = read_length( p );
break;
case cssd_margin_bottom:
style->margin[3] = read_length( p );
break;
case cssd_margin:
style->margin[2] = read_length( p );
style->margin[1] = read_length( p );
style->margin[3] = read_length( p );
style->margin[0] = read_length( p );
break;
case cssd_padding_left:
style->padding[0] = read_length( p );
break;
case cssd_padding_right:
style->padding[1] = read_length( p );
break;
case cssd_padding_top:
style->padding[2] = read_length( p );
break;
case cssd_padding_bottom:
style->padding[3] = read_length( p );
break;
case cssd_padding:
style->padding[2] = read_length( p );
style->padding[1] = read_length( p );
style->padding[3] = read_length( p );
style->padding[0] = read_length( p );
break;
case cssd_stop:
return;
}
}
}
