sahpi_struct_utils.c

HIP 硬件设备管理标准接口

	oh_append_offset(&mybuf, 1+offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "ReadOnly: %s\n", 
			(ctrlrec->DefaultMode.ReadOnly == SAHPI_TRUE) ? "TRUE" : "FALSE");
	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "WriteOnly: %s\n", 
			(ctrlrec->WriteOnly == SAHPI_TRUE) ? "TRUE" : "FALSE");
	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Oem: %d\n",ctrlrec->Oem);
	oh_append_bigtext(&mybuf, str);

	err = oh_copy_bigtext(textbuf, &mybuf);

	return(err);
}

/**
 * oh_build_invrec:
 * @textbuff: Buffer into which to store flattened ctrl rdr structure.
 * @invrec: Pointer to SaHpiInventoryRecT to be flattened.
 * @offsets: Number of offsets to start printing structure.
 * 
 * Flatten member data contained in SaHpiInventoryRecT struct to a text buffer.
 *
 * Returns:
 * SA_OK - normal operation.
 * SA_ERR_HPI_INVALID_PARAMS - Pointer parameter(s) are NULL.
 **/
static SaErrorT oh_build_invrec(oh_big_textbuffer *textbuff,const SaHpiInventoryRecT *invrec, int offsets)
{
	SaErrorT err;
	char str[SAHPI_MAX_TEXT_BUFFER_LENGTH];
	oh_big_textbuffer mybuf;

	if (!textbuff || !invrec) return(SA_ERR_HPI_INVALID_PARAMS);

	oh_init_bigtext(&mybuf);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "IdrId: %d\n",invrec->IdrId);
	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Persistent: %s\n",
		 (invrec->Persistent == SAHPI_TRUE) ? "TRUE" : "FALSE" );
	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Oem: %d\n",invrec->Oem);
	oh_append_bigtext(&mybuf, str);

	err = oh_copy_bigtext(textbuff, &mybuf);
	return(err);
}

/**
 * oh_build_wdogrec:
 * @textbuff: Buffer into which to store flattened watchdog rec structure.
 * @wdogrec: Pointer to SaHpiWatchdogRecT to be flattened.
 * @offsets: Number of offsets to start printing structure.
 * 
 * Flatten member data contained in SaHpiWatchdogRecT struct to a text buffer.
 *
 * Returns:
 * SA_OK - normal operation.
 * SA_ERR_HPI_INVALID_PARAMS - Pointer parameter(s) are NULL.
 **/
static SaErrorT oh_build_wdogrec(oh_big_textbuffer *textbuff,const SaHpiWatchdogRecT *wdogrec, int offsets)
{

	SaErrorT err;
	char str[SAHPI_MAX_TEXT_BUFFER_LENGTH];
	oh_big_textbuffer mybuf;

	if (!textbuff || !wdogrec) return(SA_ERR_HPI_INVALID_PARAMS);

	oh_init_bigtext(&mybuf);
	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "WatchdogNum: %d\n",wdogrec->WatchdogNum);
	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Oem: %d\n",wdogrec->Oem);
	oh_append_bigtext(&mybuf, str);

	err = oh_copy_bigtext(textbuff, &mybuf);
	return(err);
}

/**
 * oh_build_annrec:
 * @textbuff: Buffer into which to store flattened structure.
 * @annrec: Pointer to SaHpiAnnunciatorRecT to be flattened.
 * @offsets:  Number of offsets to start printing structure.
 * 
 * Flatten member data contained in SaHpiAnnunciatorRecT struct to a text buffer.
 *
 * Returns:
 * SA_OK - normal operation.
 * SA_ERR_HPI_INVALID_PARAMS - Pointer parameter(s) are NULL.
 **/
static SaErrorT oh_build_annrec(oh_big_textbuffer *textbuff,const SaHpiAnnunciatorRecT *annrec, int offsets)
{
	SaErrorT err;
	char str[SAHPI_MAX_TEXT_BUFFER_LENGTH];
	oh_big_textbuffer mybuf;

	if (!textbuff || !annrec) return(SA_ERR_HPI_INVALID_PARAMS);

	oh_init_bigtext(&mybuf);
	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "AnnunciatorNum: %d\n", annrec->AnnunciatorNum);
	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "AnnunciatorType: %s\n",
		 oh_lookup_annunciatortype(annrec->AnnunciatorType));
	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "ModeReadOnly: %s\n",
		 (annrec->ModeReadOnly == SAHPI_TRUE) ? "TRUE" : "FALSE" );
	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "MaxCondition: %d\n", annrec->MaxConditions);
	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Oem: %d\n", annrec->Oem);
	oh_append_bigtext(&mybuf, str);

	err = oh_copy_bigtext(textbuff, &mybuf);
	return(err);
}

/**
 * oh_fprint_eventloginfo:
 * @stream: File handle.
 * @thiselinfo: Pointer to SaHpiEventLogInfoT to be printed.
 * @offsets: Number of offsets to start printing structure.
 * 
 * Prints the member data contained in SaHpiEventLogInfoT struct to a file.
 * The MACRO oh_print_evenloginfo(), uses this function to print to STDOUT. 
 *
 * Returns:
 * SA_OK - normal operation.
 * SA_ERR_HPI_INVALID_PARAMS - Pointer parameter(s) are NULL.
 **/
SaErrorT oh_fprint_eventloginfo(FILE *stream, const SaHpiEventLogInfoT *thiselinfo, int offsets)
{	
	int err;
	oh_big_textbuffer mybuf;
	char str[SAHPI_MAX_TEXT_BUFFER_LENGTH];
	SaHpiTextBufferT  minibuf;

	if (!stream || !thiselinfo) {
		return(SA_ERR_HPI_INVALID_PARAMS);
	}
	
	oh_init_bigtext(&mybuf);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Entries: %d\n", thiselinfo->Entries);
	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Size: %d\n", thiselinfo->Size);
	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "UserEventMaxSize: %d\n", thiselinfo->UserEventMaxSize);
	oh_append_bigtext(&mybuf, str);
	
	oh_append_offset(&mybuf, offsets);
	err = oh_decode_time(thiselinfo->UpdateTimestamp, &minibuf);
	if (err)
		memcpy(minibuf.Data, "SAHPI_TIME_UNSPECIFIED", 
					sizeof("SAHPI_TIME_UNSPECIFIED"));
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "UpdateTimestamp: %s\n", minibuf.Data);
	oh_append_bigtext(&mybuf, str);	
	
	oh_append_offset(&mybuf, offsets);
	err = oh_decode_time(thiselinfo->CurrentTime, &minibuf);
	if (err)
		memcpy(minibuf.Data, "SAHPI_TIME_UNSPECIFIED", 
					sizeof("SAHPI_TIME_UNSPECIFIED"));
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "CurrentTime: %s\n", minibuf.Data);
	oh_append_bigtext(&mybuf, str);	

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Enabled: %s\n",
		 (thiselinfo->Enabled == SAHPI_TRUE) ? "TRUE" : "FALSE" );
	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "OverflowFlag: %s\n",
		 (thiselinfo->OverflowFlag == SAHPI_TRUE) ? "TRUE" : "FALSE" );
	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "OverflowResetable: %s\n",
		 (thiselinfo->OverflowResetable == SAHPI_TRUE) ? "TRUE" : "FALSE" );
	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "OverflowAction: %s\n",
		 oh_lookup_eventlogoverflowaction(thiselinfo->OverflowAction));
	oh_append_bigtext(&mybuf, str);
	
	err = oh_fprint_bigtext(stream, &mybuf);
	return(err);
}

/**
 * oh_fprint_eventlogentry:
 * @stream: File handle.
 * @thiseventlog: Pointer to SaHpiEventLogEntryT to be printed.
 * @offsets: Number of offsets to start printing structure.
 * 
 * Prints the member data contained in SaHpiEventLogEntryT struct to a file.
 * The MACRO oh_print_evenlogentry(), uses this function to print to STDOUT. 
 *
 * Returns:
 * SA_OK - normal operation.
 * SA_ERR_HPI_INVALID_PARAMS - Pointer parameter(s) are NULL.
 **/
SaErrorT oh_fprint_eventlogentry(FILE *stream, const SaHpiEventLogEntryT *thiseventlog, int offsets)
{	
	int err;
	oh_big_textbuffer mybuf, mybufX;
	char str[SAHPI_MAX_TEXT_BUFFER_LENGTH];
	SaHpiTextBufferT  minibuf;

	if (!stream || !thiseventlog) {
		return(SA_ERR_HPI_INVALID_PARAMS);
	}
	
	oh_init_bigtext(&mybuf);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "EntryId: %d\n", thiseventlog->EntryId);
	oh_append_bigtext(&mybuf, str);
	oh_append_offset(&mybuf, offsets);
	err = oh_decode_time(thiseventlog->Timestamp, &minibuf);
	if (err)
		memcpy(minibuf.Data, "SAHPI_TIME_UNSPECIFIED", 
					sizeof("SAHPI_TIME_UNSPECIFIED"));
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Timestamp: %s\n", minibuf.Data);
	oh_append_bigtext(&mybuf, str);	
	
	oh_init_bigtext(&mybufX);
	err = oh_build_event(&mybufX, &thiseventlog->Event, offsets);
	oh_append_bigtext(&mybuf, mybufX.Data);	
	
	err = oh_fprint_bigtext(stream, &mybuf);
	return(err);
}

/**
 * oh_fprint_event:
 * @stream: File handle.
 * @event: Pointer to SaHpiEventT to be printed.
 * @offsets: Number of offsets to start printing structure.
 * 
 * Prints the member data contained in SaHpiEventT struct to a file.
 * The MACRO oh_print_event(), uses this function to print to STDOUT. 
 *
 * Returns:
 * SA_OK - normal operation.
 * SA_ERR_HPI_INVALID_PARAMS - Pointer parameter(s) are NULL.
 **/
SaErrorT oh_fprint_event(FILE *stream, const SaHpiEventT *event, int offsets) 
{
	int err;
	oh_big_textbuffer buffer;
	
	if (!stream || !event) {
		return(SA_ERR_HPI_INVALID_PARAMS);
	}
	
	oh_init_bigtext(&buffer);

	err = oh_build_event(&buffer, event, offsets);
	if (err) { return(err); }

	err = oh_fprint_bigtext(stream, &buffer);
	if (err) { return(err); }

	return(SA_OK);
}

/**
 * oh_build_event:
 * @buffer: Pointer to space to decipher SaHpiEventT struct
 * @event: Pointer to the event to be deciphered
 * @offset: Number of offsets to start printing structure.
 * 
 * 
 * Returns:
 * SA_OK - normal operation.
 * SA_ERR_HPI_INVALID_PARAMS - Pointer parameter(s) are NULL.
 **/
static SaErrorT oh_build_event(oh_big_textbuffer *buffer, const SaHpiEventT *event, int offsets)
{
	char str[SAHPI_MAX_TEXT_BUFFER_LENGTH];
	SaErrorT err;
	SaHpiTextBufferT tmpbuffer;

	memset( buffer->Data, 0, OH_MAX_TEXT_BUFFER_LENGTH );
	memset( tmpbuffer.Data, 0, sizeof( tmpbuffer.Data ) );
	
	/* Event Type */
	oh_append_offset(buffer, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Event Type: %s\n", 
		 oh_lookup_eventtype(event->EventType));
	oh_append_bigtext(buffer, str);
	offsets++;
	
	/* Event Source */
	oh_append_offset(buffer, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Event Resource: %d\n", event->Source);
	oh_append_bigtext(buffer, str);

	/* Event Time */
	oh_append_offset(buffer, offsets);
	oh_decode_time(event->Timestamp, &tmpbuffer);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Event Timestamp: %s\n", tmpbuffer.Data);
	oh_append_bigtext(buffer, str);

	/* Event Severity */
	oh_append_offset(buffer, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Event Severity: %s\n",
		 oh_lookup_severity(event->Severity));
	oh_append_bigtext(buffer, str);
	
	switch (event->EventType) {
	case SAHPI_ET_RESOURCE:
		err = oh_build_event_resource(buffer, event, offsets);
		break;
	case SAHPI_ET_DOMAIN:
		err = oh_build_event_domain(buffer, event, offsets);
		break;
	case SAHPI_ET_SENSOR:
		err = oh_build_event_sensor(buffer, event, offsets);
		break;
	case SAHPI_ET_SENSOR_ENABLE_CHANGE:
		err = oh_build_event_sensor_enable_change(buffer, event, offsets);
		break;
	case SAHPI_ET_HOTSWAP:
		err = oh_build_event_hotswap(buffer, event, offsets);
		break;
	case SAHPI_ET_WATCHDOG:
		err = oh_build_event_watchdog(buffer, event, offsets);
		break;
	case SAHPI_ET_HPI_SW:
		err = oh_build_event_hpi_sw(buffer, event, offsets);
		break;
	case SAHPI_ET_OEM:
		err = oh_build_event_oem(buffer, event, offsets);
		break;
	case SAHPI_ET_USER:
		err = oh_build_event_user(buffer, event, offsets);
		break;
	default:
		dbg("Unrecognized Event Type=%d.", event->EventType);
		return(SA_ERR_HPI_INVALID_PARAMS);
	}
			
	if (err) { return(err); }
	return(SA_OK);
}

/**
 * oh_build_event_resource:
 * @buffer: Pointer to space to decipher SaHpiEventT struct
 * @event: Pointer to the event to be deciphered
 * @offset: Number of offsets to start printing structure.
 * 
 * Build ResourceEventTypeT value into string buffer.
 *
 * Returns:
 * SA_OK - normal operation.
 * SA_ERR_HPI_INVALID_PARAMS - Pointer parameter(s) are NULL.
 **/
static SaErrorT oh_build_event_resource(oh_big_textbuffer *buffer, const SaHpiEventT *event, int offsets)
{

	char str[SAHPI_MAX_TEXT_BUFFER_LENGTH];

	if (!buffer || !event)
		return(SA_ERR_HPI_INVALID_PARAMS);

	oh_append_offset(buffer, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "ResourceEvent: \n"); 
	oh_append_bigtext(buffer, str);

	oh_append_offset(buffer, 1+offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "ResourceEventType: %s\n", 
		 	oh_lookup_resourceeventtype(event->EventDataUnion.ResourceEvent.ResourceEventType));
	oh_append_bigtext(buffer, str);

	return(SA_OK);
}

/**
 * oh_build_event_domain:
 * @buffer: Pointer to space to decipher S