ibmhmc.c

在LINUX下实现HA的源代码

	}else if (strcmp(output, "Not Available") == 0
	|| strcmp(output, "Error") == 0) {
		state = STATE_INVALID;
	}
	FREE(output);
	output = NULL;

	if (state == STATE_INVALID) {
		PILCallLog(LOG, PIL_CRIT, "host %s in invalid state", host);
		return S_OOPS;
	}

	switch (request) {
	case ST_GENERIC_RESET:
		if (dev->hmcver < 4) {
			if (is_lpar) {
				if (state == STATE_ON) {
					output = do_shell_cmd(off_cmd, &status);
					if (0 != status) {
						PILCallLog(LOG, PIL_CRIT
						,	"command %s failed"
						,	off_cmd);
						return S_OOPS;
					}
				}
				for (i = 0; i < MAX_POWERON_RETRY; i++) {
					char *output2;
					output2 = do_shell_cmd(on_cmd, &status);
					if (output2 != NULL) {
						FREE(output2);
					}
					if (0 != status) {
						sleep(1);
					}else{
						break;
					}
				}
				if (MAX_POWERON_RETRY == i) {
					PILCallLog(LOG, PIL_CRIT
					,	"command %s failed"
					,	on_cmd);
					return S_OOPS;
				}
			}else{
				output = do_shell_cmd(reset_cmd, &status);
				if (0 != status) {
					PILCallLog(LOG, PIL_CRIT
					,	"command %s failed"
					,	reset_cmd);
					return S_OOPS;
				}
				break;
			}
		}else{
			if (state == STATE_ON) {
				output = do_shell_cmd(reset_cmd, &status);
			}else{
				output = do_shell_cmd(on_cmd, &status);
			}
			if (0 != status) {
				PILCallLog(LOG, PIL_CRIT
				,	"command %s failed", reset_cmd);
				return S_OOPS;
			}
		}
		break;
	default:
		return S_INVAL;
	}

	if (output != NULL) {
		FREE(output);
	}

	PILCallLog(LOG, PIL_INFO, "Host %s %s %d."
	,	host, __FUNCTION__, request);

	return S_OK;
}

/*
 *	Parse the information in the given configuration file,
 *	and stash it away...
 */
static int
ibmhmc_set_config_file(Stonith* s, const char * configname)
{
	FILE* cfgfile = NULL;
	struct HMCDevice* dev = NULL;
	char hostline[MAX_HOST_NAME_LEN];
	
	if (!ISHMCDEV(s)) {
		PILCallLog(LOG, PIL_CRIT, "invalid argument to %s"
		,	__FUNCTION__);
		return(S_OOPS);
	}

	dev = (struct HMCDevice*) s->pinfo;

	cfgfile = fopen(configname, "r");
	if (cfgfile == NULL)  {
		PILCallLog(LOG, PIL_CRIT, "Cannot open %s", configname);
		return(S_BADCONFIG);
	}

	while (fgets(hostline, sizeof(hostline), cfgfile) != NULL){
		if (*hostline == '#' || *hostline == '\n' || *hostline == EOS){
			continue;
		}

		return ibmhmc_parse_config_info(dev, hostline);
	}
	return S_BADCONFIG;
}

/*
 *	Parse the config information in the given string, and stash it away...
 */
static int
ibmhmc_set_config_info(Stonith* s, const char * info)
{
	struct HMCDevice* dev;

	if (!ISHMCDEV(s)) {
		PILCallLog(LOG, PIL_CRIT, "%s: invalid argument", __FUNCTION__);
		return(S_OOPS);
	}

	dev = (struct HMCDevice *)s->pinfo;

	return(ibmhmc_parse_config_info(dev, info));
}

static const char*
ibmhmc_getinfo(Stonith* s, int reqtype)
{
	struct HMCDevice* dev;
	const char* ret;

	if (!ISHMCDEV(s)) {
		PILCallLog(LOG, PIL_CRIT, "HMC_idinfo: invalid argument");
		return NULL;
	}

	dev = (struct HMCDevice *)s->pinfo;

	switch (reqtype) {
		case ST_DEVICEID:
			ret = _("IBM HMC Device");
			break;

		case ST_CONF_INFO_SYNTAX:
			ret = _("ipaddr [managedsyspat]...");
			break;

		case ST_CONF_FILE_SYNTAX:
			ret = _("ipaddr [managedsyspat]...\n"
			"All items must be on one line. "
			"Blank lines and lines beginning with # are ignored");
			break;

		case ST_DEVICEDESCR:
			ret = _("IBM Hardware Management Console (HMC)\n"
			"Use for IBM i5, p5, pSeries and OpenPower systems "
			"managed by HMC\n"
			"Optional parameter(s) after ipaddr is/are a "
			"white-space delimited list of patterns used to match "
			"managed system names; if last character is '*', all "
			"names that begin with the pattern are matched\n"
			" See " HMCURL " for more information.");
			break;

		default:
			ret = NULL;
			break;
	}
	return ret;
}

/*
 *	HMC Stonith destructor...
 */
static void
ibmhmc_destroy(Stonith *s)
{
	struct HMCDevice* dev;

	if (!ISHMCDEV(s)) {
		PILCallLog(LOG, PIL_CRIT, "%s: invalid argument", __FUNCTION__);
		return;
	}
	dev = (struct HMCDevice *)s->pinfo;

	dev->HMCid = NOTibmhmcID;
	if (dev->hmc) {
		FREE(dev->hmc);
		dev->hmc = NULL;
	}
	free_hmc_hostlist(dev);
	free_hmc_mansyspats(dev);
	FREE(dev);
}

static void *
ibmhmc_new(void)
{
	struct HMCDevice* dev = MALLOCT(struct HMCDevice);

	if (dev == NULL) {
		PILCallLog(LOG, PIL_CRIT, "out of memory");
		return(NULL);
	}
	memset(dev, 0, sizeof(*dev));
	dev->HMCid = HMCid;
	dev->hostlist = NULL;
	dev->hmc = NULL;
	dev->mansyspats = NULL;
	dev->hmcver = -1;
	return((void *)dev);
}

static int
get_hmc_hostlist(struct HMCDevice* dev)
{
	int i, j, status;
	char* output = NULL;
	char get_syslist[MAX_CMD_LEN];
	char host[MAX_HOST_NAME_LEN];
	gchar** syslist = NULL;
	gchar** name_mode = NULL;
	char get_lpar[MAX_CMD_LEN];
	gchar** lparlist = NULL;

	if(Debug){
		PILCallLog(LOG, PIL_DEBUG, "%s: called, dev->hmc=%s\n"
		,	__FUNCTION__, dev->hmc);
	}

	if (dev->hmc == NULL || *dev->hmc == 0){
		return S_BADCONFIG;
	}
	
	/* get the managed system's names of the hmc */
	if (dev->hmcver < 4) {
		snprintf(get_syslist, MAX_CMD_LEN, SSH_CMD " -l " HMCROOT
			" %s lssyscfg -r sys -F name:mode --all", dev->hmc);
	}else{
		snprintf(get_syslist, MAX_CMD_LEN, SSH_CMD 
			" -l " HMCROOT " %s lssyscfg -r sys -F name", dev->hmc);
	}
	if(Debug){
		PILCallLog(LOG, PIL_DEBUG, "%s: get_syslist=%s"
		,	__FUNCTION__, get_syslist);
	}

	output = do_shell_cmd(get_syslist, &status);
	if (output == NULL) {
		return S_BADCONFIG;
	}		
	syslist = g_strsplit(output, "\n", 0);
	FREE(output);

	/* for each managed system */
	for (i = 0; syslist[i] != NULL && syslist[i][0] != 0; i++) {
		if (dev->hmcver < 4) {
			name_mode = g_strsplit(syslist[i], ":", 2);
			if(Debug){
			PILCallLog(LOG, PIL_DEBUG
			,	"%s: name_mode0=%s, name_mode1=%s\n"
			,	__FUNCTION__, name_mode[0], name_mode[1]);
			}

			if (dev->mansyspats != NULL
			&& !pattern_match(dev->mansyspats, name_mode[0])) {
				continue;
			}

			/* if it is in fullsystempartition */
			if (NULL != name_mode[1]
			&& 0 == strncmp(name_mode[1], "0", 1)) {
				/* add the FullSystemPartition */
				snprintf(host, MAX_HOST_NAME_LEN
				,	"%s/FullSystemPartition", name_mode[0]);
				dev->hostlist = g_list_append(dev->hostlist 
				,	STRDUP(host));
			}else if (NULL != name_mode[1]
			&& 0 == strncmp(name_mode[1], "255", 3)){
				/* get its lpars */
				snprintf(get_lpar, MAX_CMD_LEN
				,	SSH_CMD " -l " HMCROOT
				" %s lssyscfg -m %s -r lpar -F name --all"
				,	dev->hmc, name_mode[0]);
				if(Debug){
					PILCallLog(LOG, PIL_DEBUG
					,	"%s: get_lpar=%s\n"
					,	__FUNCTION__, get_lpar);
				}

				output = do_shell_cmd(get_lpar, &status);
				if (output == NULL) {
					g_strfreev(name_mode);
					g_strfreev(syslist);
					return S_BADCONFIG;
				}		
				lparlist = g_strsplit(output, "\n", 0);
				FREE(output);
	
				/* for each lpar */
				for (j = 0
				; NULL != lparlist[j] && 0 != lparlist[j][0]
				; j++) {
					/* skip the full system partition */
					if (0 == strncmp(lparlist[j]
					,	FULLSYSTEMPARTITION
					,	strlen(FULLSYSTEMPARTITION))) {
						continue;
					}
					/* add the lpar */
					snprintf(host, MAX_HOST_NAME_LEN
					,	"%s/%s", name_mode[0]
					,	lparlist[j]);
					dev->hostlist = 
						g_list_append(dev->hostlist
						,	STRDUP(host));
				}
				g_strfreev(lparlist);
			}
			g_strfreev(name_mode);
		}else{
			if (dev->mansyspats != NULL
			&& !pattern_match(dev->mansyspats, syslist[i])) {
				continue;
			}

			/* get its lpars */
			snprintf(get_lpar, MAX_CMD_LEN
			,	SSH_CMD " -l " HMCROOT
				 " %s lssyscfg -m %s -r lpar -F name"
			,	dev->hmc, syslist[i]);
			if(Debug){
				PILCallLog(LOG, PIL_DEBUG, "%s: get_lpar=%s\n"
				,	__FUNCTION__, get_lpar);
			}

			output = do_shell_cmd(get_lpar, &status);
			if (output == NULL) {
				g_strfreev(syslist);
				return S_BADCONFIG;
			}		
			lparlist = g_strsplit(output, "\n", 0);
			FREE(output);

			/* for each lpar */
			for (j = 0
			; NULL != lparlist[j] && 0 != lparlist[j][0]
			; j++) {
				/* add the lpar */
				snprintf(host, MAX_HOST_NAME_LEN
				,	"%s/%s", syslist[i],lparlist[j]);
				dev->hostlist = g_list_append(dev->hostlist
						,	STRDUP(host));
			}
			g_strfreev(lparlist);
		}
	}
	g_strfreev(syslist);
	
	return S_OK;
}

static void
free_hmc_hostlist(struct HMCDevice* dev)
{
	if (dev->hostlist) {
		GList* node;
		while (NULL != (node=g_list_first(dev->hostlist))) {
			dev->hostlist = g_list_remove_link(dev->hostlist, node);
			FREE(node->data);
			g_list_free(node);
		}
		dev->hostlist = NULL;
	}
}

static int
get_hmc_mansyspats(struct HMCDevice * dev, const char *mansyspats)
{
	char *patscopy;
	int numpats;	
	int i;
	char *tmp;

	if(Debug){
		PILCallLog(LOG, PIL_DEBUG, "%s: called, mansyspats=%s\n"
		,	__FUNCTION__, mansyspats);
	}
	
	patscopy = STRDUP(mansyspats);
	if (patscopy == NULL) {
		PILCallLog(LOG, PIL_CRIT, "%s: out of memory", __FUNCTION__);
		return S_OOPS;
	}

	numpats = get_num_tokens(patscopy);	
	if (numpats > 0) {
		dev->mansyspats = MALLOC((numpats+1)*sizeof(char *));
		if (dev->mansyspats == NULL) {
			PILCallLog(LOG, PIL_CRIT, "%s: out of memory"
			,	__FUNCTION__);
			FREE(patscopy);
			return S_OOPS;
		}

		memset(dev->mansyspats, 0, (numpats+1)*sizeof(char *));

		/* White-space split the output here */
		i = 0;
		tmp = strtok(patscopy, WHITESPACE);
		while (tmp != NULL) {
			dev->mansyspats[i] = STRDUP(tmp);
			if (dev->mansyspats[i] == NULL) {
				PILCallLog(LOG, PIL_CRIT, "%s: out of memory"
				,	__FUNCTION__);
				free_hmc_mansyspats(dev);
				dev->mansyspats = NULL;
				FREE(patscopy);
				return S_OOPS;
			}
	
			if(Debug){
				PILCallLog(LOG, PIL_DEBUG
				,	"%s: adding pattern %s\n"
				,	__FUNCTION__, dev->mansyspats[i]);
			}

			/* no patterns necessary if all specified */
			if (strcmp(dev->mansyspats[i], "*") == 0) {
				ibmhmc_free_hostlist(dev->mansyspats);
				dev->mansyspats = NULL;
				break;
			}

			i++;
			tmp = strtok(NULL, WHITESPACE);
		}
	}
	FREE(patscopy);
	return S_OK;
}

static void
free_hmc_mansyspats(struct HMCDevice* dev)
{
	if (dev->mansyspats) {
		ibmhmc_free_hostlist(dev->mansyspats);
		dev->mansyspats = NULL;
	}
}

static char*
do_shell_cmd(const char* cmd, int* status)
{
	const int BUFF_LEN=4096;
	int read_len = 0;
	char buff[BUFF_LEN];
	char* data = NULL;
	GString* g_str_tmp = NULL;

	FILE* file = popen(cmd, "r");
	if (NULL == file) {
		return NULL;
	}

	g_str_tmp = g_string_new("");
	while(!feof(file)) {
		memset(buff, 0, BUFF_LEN);
		read_len = fread(buff, 1, BUFF_LEN, file);
		if (0 < read_len) {
			g_string_append(g_str_tmp, buff);
		}else{
			sleep(1);
		}
	}
	data = (char*)MALLOC(g_str_tmp->len+1);
	data[0] = data[g_str_tmp->len] = 0;
	strncpy(data, g_str_tmp->str, g_str_tmp->len);
	g_string_free(g_str_tmp, TRUE);

	*status = pclose(file);
	return data;
}

static int
check_hmc_status(const char* hmc)
{
	int status;
	char check_status[MAX_CMD_LEN];
	char* output = NULL;
	int rc = S_OK;

	if(Debug){
		PILCallLog(LOG, PIL_DEBUG, "%s: called, hmc=%s\n"
		,	__FUNCTION__, hmc);
	}

	snprintf(check_status, MAX_CMD_LEN
	,	SSH_CMD " -l " HMCROOT " %s lshmc -r -F ssh", hmc);
	if(Debug){
		PILCallLog(LOG, PIL_DEBUG, "%s: check_status %s\n"
		,	__FUNCTION__, check_status);
	}

	output = do_shell_cmd(check_status, &status);
	if (Debug) {
		PILCallLog(LOG, PIL_DEBUG, "%s: status=%d, output=%s\n"
		,	__FUNCTION__, status, output ? output : "(nil)");
	}

	if (NULL == output || strncmp(output, "enable", 6) != 0) {
		rc = S_BADCONFIG;
	}
	if (NULL != output) {
		FREE(output);
	}
	return rc;
}

static int
get_num_tokens(char *str)
{
	int namecount = 0;

	while (*str != EOS) {
		str += strspn(str, WHITESPACE);
		if (*str == EOS)
			break;
		str += strcspn(str, WHITESPACE);
		namecount++;
	}
	return namecount;
}

static gboolean
pattern_match(char **patterns, char *string)
{
	char **pattern;

	if(Debug){
		PILCallLog(LOG, PIL_DEBUG, "%s: called, string=%s\n"
		,	__FUNCTION__, string);
	}

	for (pattern = patterns; *pattern; pattern++) {
		int patlen = strlen(*pattern);

		if (pattern[0][patlen-1] == '*') {
			/* prefix match */
			if (strncmp(string, *pattern, patlen-1) == 0) {
				return TRUE;
			}
		}else{
			/* exact match */
			if (strcmp(string, *pattern) == 0) {
				return TRUE;
			}
		}
	}

	return FALSE;
}