/**
* parse_main_a_scn
*
*/
int
parse_priv_hdr_scn(struct rtas_event *re)
{
struct rtas_priv_hdr_scn *privhdr;
privhdr = malloc(sizeof(*privhdr));
if (privhdr == NULL) {
errno = ENOMEM;
return -1;
}
memset(privhdr, 0, sizeof(*privhdr));
privhdr->shdr.raw_offset = re->offset;
/* Copy up through the creator subsection id. Sinc the subsection
* id can be ascii we null terminate it then copy the stuff after it.
*/
rtas_copy(RE_SHDR_OFFSET(privhdr), re, 48);
/* If the creator id is 'E', the the subsystem version is in ascii,
* copy this info to a null terminated string.
*/
if (privhdr->creator_id == RTAS_PH_CREAT_SERVICE_PROC) {
memcpy(privhdr->creator_subid_name,
&privhdr->creator_subid_hi, 8);
privhdr->creator_subid_name[8] = '\0';
}
add_re_scn(re, privhdr, RTAS_PRIV_HDR_SCN);
return 0;
}
/**
* parse_vend_specific_scn
*
*/
int
parse_vend_errlog_scn(struct rtas_event *re)
{
struct rtas_vend_errlog *ve;
ve = malloc(sizeof(*ve));
if (ve == NULL) {
errno = ENOMEM;
return -1;
}
ve->shdr.raw_offset = re->offset;
rtas_copy(RE_SHDR_OFFSET(ve), re, 4);
/* See if there is additional data */
ve->vendor_data_sz = re->event_length - re->offset;
if (ve->vendor_data_sz > 0) {
ve->vendor_data = malloc(ve->vendor_data_sz);
if (ve->vendor_data == NULL) {
errno = ENOMEM;
return -1;
}
rtas_copy(ve->vendor_data, re, ve->vendor_data_sz);
}
add_re_scn(re, ve, RTAS_VEND_ERRLOG_SCN);
return 0;
}
/**
* parse_generic_v6_scn
*
*/
int
parse_generic_v6_scn(struct rtas_event *re)
{
struct rtas_v6_generic *gen;
uint32_t copy_sz = sizeof(struct rtas_v6_hdr);
gen = malloc(sizeof(*gen));
if (gen == NULL) {
errno = ENOMEM;
return -1;
}
memset(gen, 0, sizeof(*gen));
gen->shdr.raw_offset = re->offset;
rtas_copy(RE_SHDR_OFFSET(gen), re, copy_sz);
if (gen->v6hdr.length > copy_sz) {
uint32_t data_sz = gen->v6hdr.length - copy_sz;
gen->data = malloc(data_sz);
if (gen->data == NULL) {
errno = ENOMEM;
return -1;
}
memset(gen->data, 0, data_sz);
rtas_copy(gen->data, re, data_sz);
}
add_re_scn(re, gen, RTAS_GENERIC_SCN);
return 0;
}
/**
* parse_ibm diag_scn
*
*/
int
parse_ibm_diag_scn(struct rtas_event *re)
{
struct rtas_ibm_diag_scn *ibmdiag;
ibmdiag = malloc(sizeof(*ibmdiag));
if (ibmdiag == NULL) {
errno = ENOMEM;
return -1;
}
ibmdiag->shdr.raw_offset = re->offset;
rtas_copy(RE_SHDR_OFFSET(ibmdiag), re, sizeof(uint32_t));
add_re_scn(re, ibmdiag, RTAS_IBM_DIAG_SCN);
return 0;
}
/**
* parse_cpu_scn
*
*/
int
parse_cpu_scn(struct rtas_event *re)
{
struct rtas_cpu_scn *cpu_scn;
cpu_scn = malloc(sizeof(*cpu_scn));
if (cpu_scn == NULL) {
errno = ENOMEM;
return -1;
}
cpu_scn->shdr.raw_offset = re->offset;
rtas_copy(RE_SHDR_OFFSET(cpu_scn), re, RE_V4_SCN_SZ);
add_re_scn(re, cpu_scn, RTAS_CPU_SCN);
return 0;
}
/**
* parse_usr_hdr_scn
*
*/
int
parse_usr_hdr_scn(struct rtas_event *re)
{
struct rtas_usr_hdr_scn *usrhdr;
usrhdr = malloc(sizeof(*usrhdr));
if (usrhdr == NULL) {
errno = ENOMEM;
return -1;
}
memset(usrhdr, 0, sizeof(*usrhdr));
usrhdr->shdr.raw_offset = re->offset;
rtas_copy(RE_SHDR_OFFSET(usrhdr), re, RE_USR_HDR_SCN_SZ);
add_re_scn(re, usrhdr, RTAS_USR_HDR_SCN);
return 0;
}
/**
* parse_mt_scn
*
*/
int
parse_mt_scn(struct rtas_event *re)
{
struct rtas_mt_scn *mt;
mt = malloc(sizeof(*mt));
if (mt == NULL) {
errno = ENOMEM;
return -1;
}
memset(mt, 0, sizeof(*mt));
mt->shdr.raw_offset = re->offset;
rtas_copy(RE_SHDR_OFFSET(mt), re, sizeof(struct rtas_v6_hdr_raw));
parse_mtms(re, &mt->mtms);
add_re_scn(re, mt, RTAS_MT_SCN);
return 0;
}
/**
* 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;
}
