snmp_rsa_event.c

HIP 硬件设备管理标准接口

					if (get_interpreted_value(thresh_read_value,
					    working.EventDataUnion.SensorEvent.TriggerReading.Interpreted.Type,
					    &working.EventDataUnion.SensorEvent.TriggerReading.Interpreted.Value)) {
						dbg("Cannot convert trigger reading=%s for text=%s\n",
						    thresh_read_value, log_entry.text);
						return -1;
					}
					if (get_interpreted_value(thresh_trigger_value,
   					    working.EventDataUnion.SensorEvent.TriggerThreshold.Interpreted.Type,
					    &working.EventDataUnion.SensorEvent.TriggerThreshold.Interpreted.Value)) {
						dbg("Cannot convert trigger threshold=%s for text=%s\n",
						    thresh_trigger_value, log_entry.text);
						return -1;
					}		
				}
			}

                        /* Handle hot-swap events */
			else if (working.EventType == SAHPI_ET_HOTSWAP) {
				if (set_previous_event_state(hnd, &working, is_recovery_event, event_enabled)) {
					dbg("Cannot set previous state for hot-swap event = %s\n", log_entry.text);
					return -1;
				}
			}
			else {
				dbg("Design Error! RSA doesn't support events of type=%d\n", working.EventType);
				return -1;
			}
		} /* End found mapped event */
		else { /* Map to OEM Event - Log Not Mapped */
			if (map2oem(&working, &log_entry, EVENT_NOT_MAPPED)) {
				dbg("Cannot map to OEM Event %s", log_entry.text);
				return -1;
			}
		} /* End found "alertable" event string in hash */
	}
	else { /* Map to OEM Event - String not recognized as RSA "alertable" */
		if (map2oem(&working, &log_entry, EVENT_NOT_ALERTABLE)) {
			dbg("Cannot map to OEM Event %s", log_entry.text);
			return -1;
		}
	}

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

	return 0;
}

static Str2EventInfoT *findevent4dupstr(gchar *search_str, Str2EventInfoT *strhash_data, LogSource2ResourceT *resinfo)
{
	gchar dupstr[RSA_SEL_ENTRY_STRING];
	Str2EventInfoT *dupstr_hash_data;
	short strnum;

	strncpy(dupstr, search_str, RSA_SEL_ENTRY_STRING);
	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 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)->rsa_sensor_info.event_array[j].event != NULL; j++) {
				normalized_event = snmp_derive_objid(resinfo->ep,
						   (resinfo->sensor_array_ptr + i)->rsa_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_rsa_rpt_array[resinfo->rpt].rsa_res_info.event_array[i].event != NULL; i++) {
			normalized_event = snmp_derive_objid(resinfo->ep,
					   snmp_rsa_rpt_array[resinfo->rpt].rsa_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[6];
			gchar *tmpstr;

			sprintf(strnum_str,"%d", strnum);
			tmpstr = g_strconcat(search_str, HPIDUP_STRING, strnum_str, NULL);
			strncpy(dupstr, tmpstr, RSA_SEL_ENTRY_STRING);
			g_free(tmpstr);

			dupstr_hash_data = (Str2EventInfoT *)g_hash_table_lookup(rsa_str2event_hash, dupstr);
			if (dupstr_hash_data == NULL) {
				dbg("Cannot find duplicate string=%s\n", dupstr);
			}
		}
	}

	return NULL;
}

/*
 * This function parses RSA threshold log messages into their various 
 * sub-strings. Format is root string (in rsa_str2event_hash) followed by read threshold 
 * value string  followed by trigger threshold value string. Unfortunately can't
 * convert directly to sensor values yet because don't yet know if event mapped or
 * if it is, what the sensor's threshold data type is.
 */
static int parse_threshold_str(gchar *str, gchar *root_str, gchar *read_value_str, gchar *trigger_value_str) 
{
	gchar  **event_substrs = NULL;
	gchar  **thresh_substrs = NULL;
	int rtn_code=0;

	if (str == NULL || root_str == NULL || read_value_str == NULL || trigger_value_str == NULL) {
		dbg("Cannot parse threshold string; Input string(s) NULL\n");
		return -1;
	}

	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 event format %s properly", str);
		rtn_code = -1;
		goto CLEANUP;
	}

	if ((strlen(thresh_substrs[0]) > MAX_THRESHOLD_VALUE_STRINGSIZE) ||
	    (strlen(thresh_substrs[1]) > MAX_THRESHOLD_VALUE_STRINGSIZE)) {
		dbg("Threshold value string(s) exceed max size for string=%s\n", str);
		rtn_code = -1;
		goto CLEANUP;
	}
	
	strcpy(root_str, event_substrs[0]);
	strcpy(read_value_str, thresh_substrs[0]);
	strcpy(trigger_value_str, thresh_substrs[1]);

	if (root_str == NULL || read_value_str == NULL || trigger_value_str == NULL) {
		dbg("Cannot parse threshold str=%s into non-NULL parts\n", str);
		rtn_code = -1;
	}

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

	return rtn_code;
}

/**********************************
 * Set previous state info in event
 **********************************/
static int set_previous_event_state(void *hnd, SaHpiEventT *event, int recovery_event, int *event_enabled) 
{
	switch (event->EventType) {
	case SAHPI_ET_SENSOR:
	{
		SaHpiRdrT *rdr = oh_get_rdr_by_type(
			((struct oh_handler_state *)hnd)->rptcache, 
			event->Source, SAHPI_SENSOR_RDR, 
			event->EventDataUnion.SensorEvent.SensorNum);
		
		if (rdr == NULL) {
			return SA_ERR_HPI_NOT_PRESENT;
		}
		
		gpointer rsa_data = oh_get_rdr_data(
			((struct oh_handler_state *)hnd)->rptcache,
			event->Source, rdr->RecordId);
		
		if (rsa_data == NULL) {
			dbg("Sensor Data Pointer is NULL; RID=%x; SID=%d",
			    event->Source, 
			    event->EventDataUnion.SensorEvent.SensorNum);
			return -1;
		}

		/* Check to see if events are disabled for this sensor */
		if (!((struct RSA_SensorInfo *)rsa_data)->sensor_evt_enablement.SensorStatus &
		    SAHPI_SENSTAT_EVENTS_ENABLED) {
			*event_enabled = 0;
			return 0;
		}

		/********************************
		 * Set Current and Previous State 
		 ********************************/
		if (recovery_event) {

			/* Recovery state is stored in the previous state field in the
			   event's hash table. Dynamic data is stored in RDR not the 
			   event hash table, so event hash table uses previous
			   field to hold recovery data */
			
			SaHpiEventStateT tmpstate;
			tmpstate = ((struct RSA_SensorInfo *)rsa_data)->cur_state;

			/* Set both RDR/event's current state; Remember for recovery 
			   event hash's previous = recovery state */
			((struct RSA_SensorInfo *)rsa_data)->cur_state = 
				event->EventDataUnion.SensorEvent.PreviousState; 
			event->EventDataUnion.SensorEvent.EventState = 
				event->EventDataUnion.SensorEvent.PreviousState;
			event->EventDataUnion.SensorEvent.PreviousState = tmpstate;
		}
		else { /* Normal non-recovery case */
			event->EventDataUnion.SensorEvent.PreviousState = 
				((struct RSA_SensorInfo *)rsa_data)->cur_state;
			((struct RSA_SensorInfo *)rsa_data)->cur_state = 
				event->EventDataUnion.SensorEvent.EventState;
		}

		break;
	}
	case SAHPI_ET_HOTSWAP:
	{
		gpointer rsa_data = 
			oh_get_resource_data(((struct oh_handler_state *)hnd)->rptcache, event->Source);
		
		if (rsa_data == NULL) {
			dbg("HotSwap Data Pointer is NULL; RID=%x\n", event->Source);
			return -1;
		}
		
		/********************************
		 * Set Current and Previous State 
		 ********************************/
		if (recovery_event) {

			/* Recovery state is stored in the previous state field in the
			   event's hash table. Dynamic data is stored in RDR not the 
			   event hash table, so event hash table uses previous
			   field to hold recovery data */
			
			SaHpiHsStateT tmpstate;
			tmpstate = ((struct RSA_ResourceInfo *)rsa_data)->cur_state;

			/* Set both RDR/event's current state; Remember for recovery 
			   event hash's previous = recovery state */
			((struct RSA_ResourceInfo *)rsa_data)->cur_state = 
				event->EventDataUnion.HotSwapEvent.PreviousHotSwapState;
			event->EventDataUnion.HotSwapEvent.HotSwapState = 
				event->EventDataUnion.HotSwapEvent.PreviousHotSwapState;
			event->EventDataUnion.HotSwapEvent.PreviousHotSwapState = tmpstate;
		}
		else { /* Normal non-recovery case */
			event->EventDataUnion.HotSwapEvent.PreviousHotSwapState = 
				((struct RSA_ResourceInfo *)rsa_data)->cur_state;
			((struct RSA_ResourceInfo *)rsa_data)->cur_state = 
				event->EventDataUnion.HotSwapEvent.HotSwapState;
		}
		break;
	}
	default:
		dbg("Unrecognized Event Type=%d\n", event->EventType);
		return -1;
	}
	
	return 0;
}

/****************************************************
 * Translate RSA log message to HPI OEM Event
 ****************************************************/
static int map2oem(SaHpiEventT *event, rsa_sel_entry *sel_entry, OEMReasonCodeT reason)
{
	event->EventType = SAHPI_ET_OEM;
	event->EventDataUnion.OemEvent.MId = IBM_MANUFACTURING_ID;
	strncpy(event->EventDataUnion.OemEvent.OemEventData,
		sel_entry->text, SAHPI_OEM_EVENT_DATA_SIZE - 1);
	event->EventDataUnion.OemEvent.OemEventData
		[SAHPI_OEM_EVENT_DATA_SIZE - 1] = '\0';
	
	return 0;
}

/*****************************************************************
 * Translate RSA error log "Source" text to HPI Resource ID. 
 * Calculate Entity Path to find RID.
 * All Source text strings map to the Chassis's resource ID
 *****************************************************************/
int rsasrc2rid(void *hnd, gchar *src, LogSource2ResourceT *resinfo)
{
	int rpt_index;
	guint instance;
	gchar **src_parts = NULL;
	SaHpiEntityPathT ep, ep_root;
	SaHpiEntityTypeT entity_type;
	struct snmp_rsa_sensor *array_ptr;

	struct oh_handler_state *handle = (struct oh_handler_state *)hnd;
	char *root_tuple = (char *)g_hash_table_lookup(handle->config, "entity_root");

	/* Find top-level chassis entity path */
	ep_init(&ep);
        string2entitypath(root_tuple, &ep_root);        

        /* Chassis instance/type in root; other resources override these below */
	instance = ep_root.Entry[0].EntityLocation;
	entity_type = ep_root.Entry[0].EntityType;

	/* Break down Source text string to find source's rpt index and instance */
	src_parts = g_strsplit(src, "_", -1);
	if (src_parts == NULL) {
		dbg("Could not split error log's Source text string.");
		g_strfreev(src_parts);
		return -1;
	}

	rpt_index = RSA_RPT_ENTRY_CHASSIS;
	array_ptr = &snmp_rsa_chassis_sensors[0];

	g_strfreev(src_parts);

	/* Find rest of Entity Path and calculate RID */
	if (ep_concat(&ep, &snmp_rsa_rpt_array[rpt_index].rpt.ResourceEntity)) {
		dbg("ep_concat failed for RPT concat");
		return -1;
	}

	if (ep_concat(&ep, &ep_root)) {
		dbg("ep_concat failed to append root");
		return -1;
	}
	if (set_ep_instance(&ep, entity_type, instance)) {
		dbg("set_ep_instance failed. type=%d; instance=%d\n", entity_type, instance);
		return -1;
	}

	/* Fill in RID and RPT table info about Error Log's Source */
	resinfo->rpt = rpt_index;
	resinfo->sensor_array_ptr = array_ptr;
	resinfo->ep = ep;
	resinfo->rid = oh_uid_lookup(&ep);
	if (resinfo->rid == 0) {
		dbg("RID = 0");
		return -1;
	}
	
	return 0;
}

/*******************************************
 * Add event to Infrastructure's event queue
 *******************************************/
int snmp_rsa_add_to_eventq(void *hnd, SaHpiEventT *thisEvent)
{
        struct oh_event working;
        struct oh_event *e = NULL;
        struct oh_handler_state *handle = hnd;

        memset(&working, 0, sizeof(struct oh_event));

	/* Setting rdr id to event struct */	
	switch (thisEvent->EventType == SAHPI_ET_OEM)
	{
		case SAHPI_ET_OEM:
		case SAHPI_ET_HOTSWAP:
		case SAHPI_ET_USER:
			working.u.hpi_event.id = 0; /* There is no rdr associated to OEM event */
			break;			    /* Set rdrid to invalid value of 0         */
		case SAHPI_ET_SENSOR:
			working.u.hpi_event.id = 
				get_rdr_uid(SAHPI_SENSOR_RDR,
						thisEvent->EventDataUnion.SensorEvent.SensorNum);
			break;
		case SAHPI_ET_WATCHDOG:
			working.u.hpi_event.id = 
				get_rdr_uid(SAHPI_WATCHDOG_RDR,
						thisEvent->EventDataUnion.WatchdogEvent.WatchdogNum);
			break;			
		default:
			dbg("Something is wrong mapping RSA SNMP log entry into HPI Event\n");
			return -1;
			break;
	} 
	
        working.type = OH_ET_HPI;
        working.u.hpi_event.parent  = thisEvent->Source;       
        memcpy(&working.u.hpi_event.event, thisEvent, sizeof(SaHpiEventT));

        /* Insert entry to eventq for processing */
        e = g_malloc0(sizeof(struct oh_event));
        if (!e) {
                dbg("Out of memory!\n");
                return -1;
        }
        memcpy(e, &working, sizeof(struct oh_event));
        handle->eventq = g_slist_append(handle->eventq, e);

        return 0;
}