snmp_bc_event.c

HIP 硬件设备管理标准接口

			memset(search_str, 0, SNMP_BC_MAX_SEL_ENTRY_LENGTH);
			strncpy(search_str, log_entry.text, (id_str - log_entry.text));
			search_str[(id_str - log_entry.text)] = '\0';
		}
	}

	/* Adjust "threshold" event strings */
	if (strstr(log_entry.text, LOG_THRESHOLD_VALUE_STRING)) {
		is_threshold_event = SAHPI_TRUE;
		oh_init_textbuffer(&thresh_read_value);
		oh_init_textbuffer(&thresh_trigger_value);
		err = snmp_bc_parse_threshold_str(search_str, root_str,
						  &thresh_read_value, &thresh_trigger_value);
		if (err) {
			dbg("Cannot parse threshold string=%s.", search_str);
		}
		else {
			memset(search_str, 0, SNMP_BC_MAX_SEL_ENTRY_LENGTH);
			strcpy(search_str, root_str);
		}
	}

	trace("Event search string=%s.", search_str);

	/* See if adjusted root string is in the errlog2event_hash table */
	strhash_data = (ErrLog2EventInfoT *)g_hash_table_lookup(errlog2event_hash, search_str);
	if (strhash_data) {
		/* Handle strings that have multiple event numbers */
		int dupovrovr = 0;
		if (strhash_data->event_dup) {
			strhash_data = snmp_bc_findevent4dupstr(search_str, strhash_data, &resinfo);
			if (strhash_data == NULL) {
				dbg("Cannot find valid event for duplicate string=%s and RID=%d.", 
				    search_str, resinfo.rid);
				if (snmp_bc_map2oem(&working, &log_entry,  EVENT_NOT_ALERTABLE)) {
					dbg("Cannot map to OEM Event %s.", log_entry.text);
					return(SA_ERR_HPI_INTERNAL_ERROR);
				}
				goto DONE;
			}
			if (strhash_data->event_ovr & OVR_RID) {
				dbg("Cannot have RID override on duplicate string=%s.", search_str);
				dupovrovr = 1;
			}
		}

		/* If OVR_SEV, use BCT-level severity calculated in off-line scripts */
		if (strhash_data->event_ovr & OVR_SEV) {
			event_severity = strhash_data->event_sev;
		}

		/* Look to see if event is mapped to an HPI entity */
		eventmap_info = (EventMapInfoT *)g_hash_table_lookup(custom_handle->event2hpi_hash_ptr, 
								     strhash_data->event);
		if (eventmap_info) {
                        /* Set static event data defined during resource discovery */
			working = eventmap_info->hpievent;
			/* Find RID */
			if (strhash_data->event_ovr & OVR_EXP) {
				/* If OVR_EXP, find RID of expansion card */
				err = snmp_bc_logsrc2rid(handle, log_entry.source, &resinfo,
							 strhash_data->event_ovr);
				if (err) {
					dbg("Cannot translate %s to RID. Error=%s.", 
					    log_entry.source, oh_lookup_error(err));
					return(err);
				}
				event_rid = resinfo.rid;
			}
			else {
				/* If OVR_RID, use RID from discovery - Used if want events from
				   a resource not distinguished by the Error Log "Source" field
				   (e.g. not a BLADE, SWITCH, or CHASSIS). OVR_EXP is a special
				   subset of OVR_RID - don't define both */
 				if ((strhash_data->event_ovr & OVR_RID) && !dupovrovr) {
					event_rid = eventmap_info->hpievent.Source;
				}
			}
			
			/* Set RID in structure - used in later calls */
			working.Source = event_rid;

			/* Handle sensor events */
			if (working.EventType == SAHPI_ET_SENSOR) {

				if (is_recovery_event == SAHPI_TRUE) {
					working.EventDataUnion.SensorEvent.Assertion = SAHPI_FALSE;
				}

				/* Determine severity of event */
				err = snmp_bc_set_event_severity(handle, eventmap_info, &working, &event_severity);

				/* Set optional event current and previous states, if possible */
				err = snmp_bc_set_cur_prev_event_states(handle, eventmap_info, 
									&working, is_recovery_event);

				/* Set optional event threshold trigger values */
				if (is_threshold_event == SAHPI_TRUE) {
					if (oh_encode_sensorreading(&thresh_read_value,
								    working.EventDataUnion.SensorEvent.TriggerReading.Type,
								    &working.EventDataUnion.SensorEvent.TriggerReading)) {
						dbg("Cannot convert trigger reading=%s; text=%s.",
						    thresh_read_value.Data, log_entry.text);
						return(SA_ERR_HPI_INTERNAL_ERROR);
					}
					working.EventDataUnion.SensorEvent.OptionalDataPresent =
						working.EventDataUnion.SensorEvent.OptionalDataPresent |
						SAHPI_SOD_TRIGGER_READING;
					
					if (oh_encode_sensorreading(&thresh_trigger_value,
								    working.EventDataUnion.SensorEvent.TriggerThreshold.Type,
								    &working.EventDataUnion.SensorEvent.TriggerThreshold)) {
						dbg("Cannot convert trigger threshold=%s; text=%s.",
						    thresh_trigger_value.Data, log_entry.text);
						return(SA_ERR_HPI_INTERNAL_ERROR);
					}
					working.EventDataUnion.SensorEvent.OptionalDataPresent =
						working.EventDataUnion.SensorEvent.OptionalDataPresent |
						SAHPI_SOD_TRIGGER_THRESHOLD;
				}
			}

                        /* Handle hot-swap events */
			else if (working.EventType == SAHPI_ET_HOTSWAP) {

				/* Determine severity of event. Sometimes a Recovery event is sent for a
                                   removal event to mean installed - don't want these "install" events 
                                   to pick up the resource's severity */
				if (is_recovery_event != SAHPI_TRUE) {
					snmp_bc_set_event_severity(handle, eventmap_info, &working, &event_severity);
				}

				/* Set event's state */
				snmp_bc_set_cur_prev_event_states(handle, eventmap_info,
								  &working, is_recovery_event);
			}
			else {
				dbg("Platform doesn't support events of type=%s.",
				    oh_lookup_eventtype(working.EventType));
				return(SA_ERR_HPI_INTERNAL_ERROR);
			}

			/************************************************** 
			 * Check to see if need to mark resource as failed.
                         **************************************************/
			if (eventmap_info->event_res_failure) {
				SaHpiRptEntryT *rpt = oh_get_resource_by_id(handle->rptcache, event->Source);
				if (rpt) {
					/* Only notify if change in status */
					if (rpt->ResourceFailed == SAHPI_FALSE) {
						rpt->ResourceFailed = SAHPI_TRUE;
						/* Add changed resource to event queue */
						struct oh_event *e = g_malloc0(sizeof(struct oh_event));
						if (e == NULL) {
							dbg("Out of memory.");
							return(SA_ERR_HPI_OUT_OF_SPACE);
						}
						
						e->type = OH_ET_RESOURCE;
						e->u.res_event.entry = *rpt;
						handle->eventq = g_slist_append(handle->eventq, e);
					}
				}
			}
		} /* End found mapped event */
		else { /* Map to OEM Event - Event not in event2hpi_hash or hasn't been discovered */
			if (snmp_bc_map2oem(&working, &log_entry, EVENT_NOT_MAPPED)) {
				dbg("Cannot map to OEM Event %s.", log_entry.text);
				return(SA_ERR_HPI_INTERNAL_ERROR);
			}
		}
	}
	else { /* Map to OEM Event - Log string not in errlog2event_hash */
		if (snmp_bc_map2oem(&working, &log_entry, EVENT_NOT_ALERTABLE)) {
			dbg("Cannot map to OEM Event %s.", log_entry.text);
			return(SA_ERR_HPI_INTERNAL_ERROR);
		}
	}

 DONE:
	working.Source = event_rid;
	working.Timestamp = event_time;
	working.Severity = event_severity;
	memcpy((void *)event, (void *)&working, sizeof(SaHpiEventT));

	return(SA_OK);
}

/**
 * snmp_bc_findevent4dupstr:
 * @search_str: Error Log string.
 * @strhash_data: Pointer to string to event ID mapping information.
 * @resinfo: Pointer to resource mapping information
 *
 * Returns a pointer to the error log event number to HPI event mapping 
 * information. A NULL is returned if the information cannot be found.
 * 
 * There are several identical Error Log messages strings that are shared by
 * multiple resources. The off-line scripts that populate errlog2event_hash
 * create unique entries for these duplicate strings by tacking on
 * an unique string (HPIDUP_STRING + duplicate number) to the error log message.
 * This is then stored in errlog2event_hash. So there is a unique mapping
 * for each resource with a duplicate string.
 * 
 * This routine goes finds the unique mapping for all the duplicate strings.
 * Then searches through all the resource's events and all the resource's
 * sensor events to find a match. It does this for each duplicate string
 * mapping until it finds a match or runs out of strings to test (in which
 * case, it returns NULL).
 *
 * Return values:
 * SA_OK - Normal case.
 * SA_ERR_HPI_INVALID_PARAMS - Parameter pointer(s) are NULL.
 **/
static ErrLog2EventInfoT *snmp_bc_findevent4dupstr(gchar *search_str,
						   ErrLog2EventInfoT *strhash_data,
						   LogSource2ResourceT *resinfo)
{
	gchar dupstr[SNMP_BC_MAX_SEL_ENTRY_LENGTH];
	ErrLog2EventInfoT *dupstr_hash_data;
	short strnum;

	if (!search_str || !strhash_data || !resinfo) {
		dbg("Invalid parameter.");
		return(NULL);
	}

	strncpy(dupstr, search_str, SNMP_BC_MAX_SEL_ENTRY_LENGTH);
	dupstr_hash_data = strhash_data;
	strnum = strhash_data->event_dup + 1; /* Original string plus dups */
       
	while (strnum && (dupstr_hash_data != NULL)) {
		int i,j;
		gchar *normalized_event; 

		/* Search entire sensor array for the duplicate string's event */
		for (i=0; (resinfo->sensor_array_ptr + i)->sensor.Num != 0; i++) {
			for (j=0; (resinfo->sensor_array_ptr + i)->sensor_info.event_array[j].event != NULL; j++) {
				normalized_event = oh_derive_string(&(resinfo->ep),
						   (resinfo->sensor_array_ptr + i)->sensor_info.event_array[j].event);
				if (!strcmp(dupstr_hash_data->event, normalized_event)) {
					g_free(normalized_event);
					return(dupstr_hash_data);
				}
				g_free(normalized_event);
			}
		}
		
		/* Search resource array for the duplicate string's event */
		for (i=0; snmp_rpt_array[resinfo->rpt].res_info.event_array[i].event != NULL; i++) {
			normalized_event = oh_derive_string(&(resinfo->ep),
					   snmp_rpt_array[resinfo->rpt].res_info.event_array[i].event);
			if (!strcmp(dupstr_hash_data->event, normalized_event)) {
				g_free(normalized_event);
				return(dupstr_hash_data);
			}
			g_free(normalized_event);
		}

		/* Find next duplicate string */
		strnum--;
		if (strnum) {
			gchar strnum_str[OH_MAX_LOCATION_DIGITS];
			gchar *tmpstr;

			snprintf(strnum_str, OH_MAX_LOCATION_DIGITS, "%d", strnum);
			tmpstr = g_strconcat(search_str, HPIDUP_STRING, strnum_str, NULL);
			strncpy(dupstr, tmpstr, SNMP_BC_MAX_SEL_ENTRY_LENGTH);
			g_free(tmpstr);

			dupstr_hash_data = (ErrLog2EventInfoT *)g_hash_table_lookup(errlog2event_hash, dupstr);
			if (dupstr_hash_data == NULL) {
				dbg("Cannot find duplicate string=%s.", dupstr);
			}
		}
	}

	return(NULL);
}

/**
 * snmp_bc_parse_threshold_str:
 * @str: Input Error Log threshold string.
 * @root_str: Location to store threshold's root string.
 * @read_value_str: Location to store threshold's read value string.
 * @trigger_value_str: Location to store threshold's trigger value string.
 *
 * Parses a Error Log threshold string into its root string, read, 
 * and trigger value strings.
 * 
 * Format is a root string (in the errlog2event_hash table) followed by a
 * read threshold value string, followed by a trigger threshold value string.
 * Unfortunately cannot convert directly to sensor values yet because 
 * don't yet know if event is in the event2hpi_hash table or if it is, 
 * what the sensor's threshold data type is.
 *
 * Return values:
 * SA_OK - Normal case.
 * SA_ERR_HPI_INVALID_PARAMS - Parameter pointer(s) are NULL.
 **/
static SaErrorT snmp_bc_parse_threshold_str(gchar *str,
					    gchar *root_str,
					    SaHpiTextBufferT *read_value_str,
					    SaHpiTextBufferT *trigger_value_str)
{
	gchar  **event_substrs = NULL;
	gchar  **thresh_substrs = NULL;
	SaErrorT err = SA_OK;

	if (!str || !root_str || !read_value_str || !trigger_value_str) {
		dbg("Invalid parameter.");
		return(SA_ERR_HPI_INVALID_PARAMS);
	}

	event_substrs = g_strsplit(str, LOG_READ_VALUE_STRING, -1);
	thresh_substrs = g_strsplit(event_substrs[1], LOG_THRESHOLD_VALUE_STRING, -1);

	if (thresh_substrs == NULL ||
	    (thresh_substrs[0] == NULL || thresh_substrs[0][0] == '\0') ||
	    (thresh_substrs[1] == NULL || thresh_substrs[1][0] == '\0') ||
	    (thresh_substrs[2] != NULL)) {
		dbg("Cannot split threshold string=%s.", str);
		err = SA_ERR_HPI_INTERNAL_ERROR;
		goto CLEANUP;
	}

	if ((strlen(thresh_substrs[0]) > SAHPI_MAX_TEXT_BUFFER_LENGTH) ||
	    (strlen(thresh_substrs[1]) > SAHPI_MAX_TEXT_BUFFER_LENGTH)) {
		dbg("Threshold value string(s) exceed max size for %s.", str);
		err = SA_ERR_HPI_INTERNAL_ERROR;
		goto CLEANUP;
	}
	
	strcpy(root_str, event_substrs[0]);
	oh_append_textbuffer(read_value_str, thresh_substrs[0]);
	oh_append_textbuffer(trigger_value_str, thresh_substrs[1]);

	if (root_str == NULL) {
		dbg("Cannot parse threshold string=%s.", str);
		err = SA_ERR_HPI_INTERNAL_ERROR;
	}

 CLEANUP:
	g_strfreev(event_substrs);
	g_strfreev(thresh_substrs);

	return(err);
}

/**
 * snmp_bc_set_event_severity:
 * @handle: Handler data pointer.
 * @eventmap_info: Event state and recovery information pointer.
 * @event: Event pointer.
 * @event_severity: Location to store severity.
 *
 * Overwrites normal severity, if sensor is of type SAHPI_EC_THRESHOLD or
 * SAHPI_EC_SEVERITY. If event is not one of these types, this routine 
 * checks to see if its an unexpected resource failure event. 
 * If it is, then the resource's severity (user writable) is used.
 *
 * Return values:
 * SA_OK - Normal case.
 * SA_ERR_HPI_INVALID_PARAMS - Parameter pointer(s) are NULL.
 **/
static SaErrorT snmp_bc_set_event_severity(struct oh_handler_state *handle,
					   EventMapInfoT *eventmap_info,
					   SaHpiEventT *event,
					   SaHpiSeverityT *event_severity)
{
	int sensor_severity_override = 0;

	if (!handle || !eventmap_info || !event || !event_severity) {
		dbg("Invalid parameter.");
		return(SA_ERR_HPI_INVALID_PARAMS);
	}
	
	if (event->EventType == SAHPI_ET_SENSOR) {

		/* Force HPI Threshold and Severity category severities */
		if (event->EventDataUnion.SensorEvent.EventCategory == SAHPI_EC_THRESHOLD) {
			sensor_severity_override = 1;
			if (event->EventDataUnion.SensorEvent.EventState & SAHPI_ES_LOWER_CRIT ||
			    event->EventDataUnion.SensorEvent.EventState & SAHPI_ES_UPPER_CRIT) {
				*event_severity = SAHPI_CRITICAL;
			}
			else {
				if (event->EventDataUnion.SensorEvent.EventState & SAHPI_ES_LOWER_MAJOR ||
				    event->EventDataUnion.SensorEvent.EventState & SAHPI_ES_UPPER_MAJOR) {
					*event_severity = SAHPI_MAJOR;
				}
				else {
					if (event->EventDataUnion.SensorEvent.EventState & SAHPI_ES_LOWER_MINOR ||
					    event->EventDataUnion.SensorEvent.EventState & SAHPI_ES_UPPER_MINOR) {
						*event_severity = SAHPI_MINOR;
					}
				}
			}
		}
		else {
			if (event->EventDataUnion.SensorEvent.EventCategory == SAHPI_EC_SEVERITY) {
				sensor_severity_override = 1;
				if (event->EventDataUnion.SensorEvent.EventState & SAHPI_ES_OK)
					*event_severity = SAHPI_OK;
				if (event->EventDataUnion.SensorEvent.EventState & SAHPI_ES_MINOR_FROM_OK)
					*event_severity = SAHPI_MINOR;
				if (event->EventDataUnion.SensorEvent.EventState & SAHPI_ES_MAJOR_FROM_LESS)
					*event_severity = SAHPI_MAJOR;
				if (event->EventDataUnion.SensorEvent.EventState & SAHPI_ES_CRITICAL_FROM_LESS)
					*event_severity = SAHPI_CRITICAL;
				if (event->EventDataUnion.SensorEvent.EventState & SAHPI_ES_MINOR_FROM_MORE)
					*event_severity = SAHPI_MINOR;
				if (event->EventDataUnion.SensorEvent.EventState & SAHPI_ES_MAJOR_FROM_CRITICAL)
					*event_severity = SAHPI_MAJOR;
				if (event->EventDataUnion.SensorEvent.EventState & SAHPI_ES_CRITICAL)
					*event_severity = SAHPI_CRITICAL;
				if (event->EventDataUnion.SensorEvent.EventState & SAHPI_ES_INFORMATIONAL)
					*event_severity = SAHPI_INFORMATIONAL;