/**
* parse_rtas_event
* @brief parse an rtas event creating a populated rtas_event structure
*
* @param buf buffer containing the binary RTAS event
* @param buflen length of the buffer 'buf'
* @return pointer to rtas_event
*/
struct rtas_event *
parse_rtas_event(char *buf, int buflen)
{
struct rtas_event *re;
struct rtas_event_hdr *re_hdr;
struct rtas_event_exthdr *rex_hdr;
int rc;
re = malloc(sizeof(*re));
if (re == NULL) {
errno = ENOMEM;
return NULL;
}
memset(re, 0, sizeof(*re));
re->buffer = buf;
re->event_no = -1;
re_hdr = malloc(sizeof(*re_hdr));
if (re_hdr == NULL) {
cleanup_rtas_event(re);
errno = ENOMEM;
return NULL;
}
rtas_copy(RE_SHDR_OFFSET(re_hdr), re, RE_EVENT_HDR_SZ);
add_re_scn(re, re_hdr, RTAS_EVENT_HDR);
/* Validate the length of the buffer passed in. */
re->event_length = re_hdr->ext_log_length + RE_EVENT_HDR_SZ;
if (re->event_length > buflen) {
cleanup_rtas_event(re);
return NULL;
}
re->version = re_hdr->version;
if (re_hdr->extended == 0)
return re;
rex_hdr = malloc(sizeof(*rex_hdr));
if (rex_hdr == NULL) {
cleanup_rtas_event(re);
errno = ENOMEM;
return NULL;
}
rtas_copy(RE_SHDR_OFFSET(rex_hdr), re, RE_EXT_HDR_SZ);
add_re_scn(re, rex_hdr, RTAS_EVENT_EXT_HDR);
if (re_hdr->version == 6)
return parse_v6_rtas_event(re);
switch (rex_hdr->format_type) {
case RTAS_EXTHDR_FMT_CPU:
rc = parse_cpu_scn(re);
break;
case RTAS_EXTHDR_FMT_EPOW:
rc = parse_epow_scn(re);
break;
case RTAS_EXTHDR_FMT_IBM_DIAG:
rc = parse_ibm_diag_scn(re);
break;
case RTAS_EXTHDR_FMT_IO:
rc = parse_io_scn(re);
break;
case RTAS_EXTHDR_FMT_MEMORY:
rc = parse_mem_scn(re);
break;
case RTAS_EXTHDR_FMT_POST:
rc = parse_post_scn(re);
break;
case RTAS_EXTHDR_FMT_IBM_SP:
rc = parse_sp_scn(re);
break;
case RTAS_EXTHDR_FMT_VEND_SPECIFIC_1:
case RTAS_EXTHDR_FMT_VEND_SPECIFIC_2:
rc = parse_vend_errlog_scn(re);
break;
default:
errno = EFAULT;
rc = -1;
break;
}
if ((rc == 0) && (re->offset < re->event_length))
rc = parse_vend_errlog_scn(re);
if (rc) {
cleanup_rtas_event(re);
re = NULL;
}
return re;
}
/**
* parse_v6_src_scn
* @brief parse a version 6 rtas SRC section
*
* @param re rtas_event pointer
* @param src_start pointer to beginning of SRC section
* @return 0 on success, !0 on failure
*/
int
parse_src_scn(struct rtas_event *re)
{
struct rtas_src_scn *src;
struct rtas_src_scn_raw *src_raw;
struct rtas_fru_scn *fru, *last_fru;
int total_len, srcsub_len;
src = malloc(sizeof(*src));
if (src == NULL) {
errno = ENOMEM;
return 1;
}
src_raw = malloc(sizeof(*src_raw));
if (src_raw == NULL) {
errno = ENOMEM;
return 1;
}
memset(src, 0, sizeof(*src));
memset(src_raw, 0, sizeof(*src_raw));
src->shdr.raw_offset = re->offset;
rtas_copy(src_raw, re, RE_SRC_SCN_SZ);
parse_v6_hdr(&src->v6hdr, &src_raw->v6hdr);
src->version = src_raw->version;
memcpy(&src->src_platform_data, &src_raw->src_platform_data,
sizeof(src->src_platform_data));
src->ext_refcode2 = be32toh(src_raw->ext_refcode2);
src->ext_refcode3 = be32toh(src_raw->ext_refcode3);
src->ext_refcode4 = be32toh(src_raw->ext_refcode4);
src->ext_refcode5 = be32toh(src_raw->ext_refcode5);
src->ext_refcode6 = be32toh(src_raw->ext_refcode6);
src->ext_refcode7 = be32toh(src_raw->ext_refcode7);
src->ext_refcode8 = be32toh(src_raw->ext_refcode8);
src->ext_refcode9 = be32toh(src_raw->ext_refcode9);
memcpy(&src->primary_refcode, &src_raw->primary_refcode,
sizeof(src->primary_refcode));
add_re_scn(re, src, re_scn_id(&src_raw->v6hdr));
if (!src_subscns_included(src))
return 0;
rtas_copy( (char *) src_raw + RE_SRC_SCN_SZ + 4, re, RE_SRC_SUBSCN_SZ);
src->subscn_id = src_raw->subscn_id;
src->subscn_platform_data = src_raw->subscn_platform_data;
src->subscn_length = be16toh(src_raw->subscn_length);
srcsub_len = src->subscn_length * 4; /*get number of bytes */
total_len = RE_SRC_SUBSCN_SZ;
last_fru = NULL;
do {
uint32_t fru_len, fru_end;
struct rtas_fru_hdr *last_fruhdr = NULL;
struct rtas_fru_scn_raw *rawfru;
fru = malloc(sizeof(*fru));
if (fru == NULL) {
cleanup_rtas_event(re);
errno = ENOMEM;
return 1;
}
memset(fru, 0, sizeof(*fru));
rawfru = (struct rtas_fru_scn_raw *)(re->buffer + re->offset);
parse_fru_scn(re, fru, rawfru);
fru_len = RE_FRU_SCN_SZ + fru->loc_code_length;
fru_end = re->offset + fru->length - fru_len;
while (re->offset < fru_end) {
struct rtas_fru_hdr *cur_fruhdr = NULL;
char *id = re->buffer + re->offset;
if (strncmp(id, "ID", 2) == 0)
cur_fruhdr = parse_fru_id_scn(re);
else if (strncmp(id, "PE", 2) == 0)
cur_fruhdr = parse_fru_pe_scn(re);
else if (strncmp(id, "MR", 2) == 0)
cur_fruhdr = parse_fru_mr_scn(re);
else {
re->offset++;
continue;
}
if (cur_fruhdr == NULL) {
cleanup_rtas_event(re);
return -1;
}
if (last_fruhdr == NULL)
fru->subscns = cur_fruhdr;
else
last_fruhdr->next = cur_fruhdr;
last_fruhdr = cur_fruhdr;
}
if (last_fru == NULL)
src->fru_scns = fru;
else
last_fru->next = fru;
last_fru = fru;
total_len += fru->length;
} while (total_len < srcsub_len);
return 0;
}
/**
* parse_v6_rtas_event
* @brief parse a version 6 RTAS event
*
* @param re rtas_event pointer
* @return rtas_event pointer on success, NULL on failure
*/
struct rtas_event *
parse_v6_rtas_event(struct rtas_event *re)
{
struct rtas_v6_hdr *v6hdr;
char *ibm;
ibm = re->buffer + re->offset;
/* Sanity Check for "IBM" string */
if (strncmp(ibm, "IBM", 3) != 0) {
cleanup_rtas_event(re);
errno = EFAULT;
return NULL;
}
re->offset += 4; /* IBM + NULL */
if (parse_priv_hdr_scn(re) != 0) {
cleanup_rtas_event(re);
return NULL;
}
if (parse_usr_hdr_scn(re) != 0) {
cleanup_rtas_event(re);
return NULL;
}
while (re->offset < re->event_length) {
int scn_id, rc;
v6hdr = (struct rtas_v6_hdr *)(re->buffer + re->offset);
scn_id = re_scn_id(v6hdr);
switch (scn_id) {
case RTAS_EPOW_SCN:
rc = parse_epow_scn(re);
break;
case RTAS_IO_SCN:
rc = parse_io_scn(re);
break;
case RTAS_DUMP_SCN:
rc = parse_dump_scn(re);
break;
case RTAS_LRI_SCN:
rc = parse_lri_scn(re);
break;
case RTAS_MT_SCN:
rc = parse_mt_scn(re);
break;
case RTAS_PSRC_SCN:
case RTAS_SSRC_SCN:
rc = parse_src_scn(re);
break;
default:
rc = parse_generic_v6_scn(re);
break;
}
if (rc) {
cleanup_rtas_event(re);
re = NULL;
break;
}
}
return re;
}
