IPMIHost.cpp

//================================================================================
// Name        : IPMIHost.cpp
// Author      : Michael Ott
// Contact     : info@dcdb.it
// Copyright   : Leibniz Supercomputing Centre
// Description : Source file for IPMIHost class.
//================================================================================

//================================================================================
// This file is part of DCDB (DataCenter DataBase)
// Copyright (C) 2017-2019 Leibniz Supercomputing Centre
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
//================================================================================

#include "IPMIHost.h"
#include "timestamp.h"

#include <cstdio>
#include <cstdlib>
#include <cerrno>
#include <cstring>
#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>
#include <exception>

#include <freeipmi/freeipmi.h>
#include <freeipmi/api/ipmi-api.h>
#include <freeipmi/sensor-read/ipmi-sensor-read.h>

#define RETRIES 2

IPMIHost::IPMIHost(const std::string& name) :
    EntityInterface(name),
    _ipmiCtx(nullptr),
    _sensorReadCtx(nullptr),
    _userName("admin"),
    _password("admin"),
    _cache(""),
    _auth(IPMI_AUTHENTICATION_TYPE_MD5),
    _priv(IPMI_PRIVILEGE_LEVEL_ADMIN),
    _cipher(3),
    _ipmiVersion(1),
    _sessionTimeout(0),
    _retransmissionTimeout(0),
    _errorCount(0),
    _delayNextReadUntil(0) {
}

IPMIHost::IPMIHost(const IPMIHost& other) :
    EntityInterface(other),
    _ipmiCtx(nullptr),
    _sensorReadCtx(nullptr),
    _userName(other._userName),
    _password(other._password),
    _cache(other._cache),
    _auth(other._auth),
    _priv(other._priv),
    _cipher(other._cipher),
    _ipmiVersion(other._ipmiVersion),
    _sessionTimeout(other._sessionTimeout),
    _retransmissionTimeout(other._retransmissionTimeout),
    _errorCount(0),
    _delayNextReadUntil(other._delayNextReadUntil) {
}

IPMIHost::~IPMIHost() {}

IPMIHost& IPMIHost::operator=(const IPMIHost& other) {
    EntityInterface::operator=(other);
    _ipmiCtx = nullptr;
    _sensorReadCtx = nullptr;
    _userName = other._userName;
    _password = other._password;
    _cache = other._cache;
    _auth = other._auth;
    _priv = other._priv;
    _cipher = other._cipher;
    _ipmiVersion = other._ipmiVersion;
    _sessionTimeout = other._sessionTimeout;
    _retransmissionTimeout = other._retransmissionTimeout;
    _errorCount = 0;
    _delayNextReadUntil = other._delayNextReadUntil;

    return *this;
}

int IPMIHost::connect() {
	if (_ipmiCtx) {
		return 0;
	}
	
	if (!(_ipmiCtx = ipmi_ctx_create())) {
		_errorMsg = "Error creating IPMI context" + std::string(strerror(errno));
		return 1;
	}

	int workaround_flags = 0;
	int flags = IPMI_FLAGS_DEFAULT;
	int rc;
	if (_ipmiVersion == 1) {
		rc = ipmi_ctx_open_outofband(_ipmiCtx, _name.c_str(), _userName.c_str(), _password.c_str(), _auth, _priv, _sessionTimeout, _retransmissionTimeout, workaround_flags, flags);
	} else {
		rc = ipmi_ctx_open_outofband_2_0(_ipmiCtx, _name.c_str(), _userName.c_str(), _password.c_str(), NULL, 0, _priv, _cipher, _sessionTimeout, _retransmissionTimeout, workaround_flags, flags);
	}
	if (rc < 0) {
		_errorMsg = "Error opening IPMI connection: " + std::string(ipmi_ctx_errormsg(_ipmiCtx));
		ipmi_ctx_close(_ipmiCtx);
		ipmi_ctx_destroy(_ipmiCtx);
		_ipmiCtx = NULL;
		return 2;
	}

	return 0;
}

int IPMIHost::disconnect() {
	if (_sensorReadCtx) {
		ipmi_sensor_read_ctx_destroy(_sensorReadCtx);
		_sensorReadCtx = NULL;
	}
	
	if (_ipmiCtx) {
		ipmi_ctx_close(_ipmiCtx);
		ipmi_ctx_destroy(_ipmiCtx);
		_ipmiCtx = NULL;
		return 0;
	}
	return 1;
}

bool IPMIHost::getSdrRecord(uint16_t recordId, std::vector<uint8_t>& record) {
	ipmi_sdr_ctx_t	sdrCtx = ipmi_sdr_ctx_create();
	if (!sdrCtx) {
		throw std::runtime_error("Error creating SDR context: " + std::string(strerror(errno)));
		return false;
	}
	
	bool success = false;
	int retries = RETRIES;
	while (retries-- && !success) {
		if (connect() == 0) {
			if (ipmi_sdr_cache_open(sdrCtx, _ipmiCtx, _cache.c_str()) < 0) {
				if ((ipmi_sdr_ctx_errnum(sdrCtx) == IPMI_SDR_ERR_CACHE_READ_CACHE_DOES_NOT_EXIST) || (ipmi_sdr_ctx_errnum(sdrCtx) == IPMI_SDR_ERR_CACHE_INVALID) || (ipmi_sdr_ctx_errnum(sdrCtx) == IPMI_SDR_ERR_CACHE_OUT_OF_DATE)) {
					if ((ipmi_sdr_ctx_errnum(sdrCtx) == IPMI_SDR_ERR_CACHE_INVALID) || (ipmi_sdr_ctx_errnum(sdrCtx) == IPMI_SDR_ERR_CACHE_OUT_OF_DATE)) {
						LOG(debug) << _name << "Deleting SDR cache " << _cache;
						ipmi_sdr_cache_close(sdrCtx);
						ipmi_sdr_cache_delete(sdrCtx, _cache.c_str());
					}
					if (ipmi_sdr_cache_create(sdrCtx, _ipmiCtx, _cache.c_str(), IPMI_SDR_CACHE_CREATE_FLAGS_DEFAULT, NULL, NULL) == 0) {
						LOG(debug) << _name << ": Created new SDR cache " << _cache;
					} else {
						LOG(debug) << _name << ": Error creating new SDR cache " << _cache;
					}
				} else {
					_errorMsg = "Error opening SDR cache: " + std::string(ipmi_sdr_ctx_errormsg(sdrCtx));
					increaseErrorCount();
					disconnect();
				}
			} else {
				int recordLength = 0;
				uint8_t recordBuf[IPMI_SDR_MAX_RECORD_LENGTH];
		
				if (ipmi_sdr_cache_search_record_id(sdrCtx, recordId) < 0) {
					_errorMsg = "Error searching SDR record: " + std::string(ipmi_sdr_ctx_errormsg(sdrCtx));
				} else {
					if ((recordLength = ipmi_sdr_cache_record_read(sdrCtx, recordBuf, IPMI_SDR_MAX_RECORD_LENGTH)) < 0) {
						_errorMsg = "Error reading SDR record: " + std::string(ipmi_sdr_ctx_errormsg(sdrCtx));
					} else {
						record.insert(record.end(), &recordBuf[0], &recordBuf[recordLength]);
						success = true;
					}
				}
				ipmi_sdr_cache_close(sdrCtx);
			}
		} else {
			increaseErrorCount();
			disconnect();
		}
	}
	
	ipmi_sdr_ctx_destroy(sdrCtx);

	if (!success) {
		throw std::runtime_error(_errorMsg);
	}
	return success;
}
	
int IPMIHost::sendRawCmd(const uint8_t* rawCmd, unsigned int rawCmdLen, void* buf, unsigned int bufLen) {
	int len = -1;
	int i;

	if (!IPMI_NET_FN_RQ_VALID(rawCmd[1])) {
		throw std::runtime_error("Error sending raw IPMI command: Invalid netfn value");
		return 0;
	}
	
	bool success = false;
	int retries = RETRIES;
	while (retries-- && !success) {
		if (connect() == 0) {
			if ((len = ipmi_cmd_raw(_ipmiCtx, rawCmd[0], rawCmd[1], &rawCmd[2], rawCmdLen - 2, buf, bufLen)) < 0) {
				_errorMsg = "Error sending IPMI raw command: " + std::string(ipmi_ctx_errormsg(_ipmiCtx));
				increaseErrorCount();
				disconnect();
			} else {
				success = true;
			}
		} else {
			increaseErrorCount();
			disconnect();
		}
	}

#if 0
	std::cout << "IPMIHost::sendRawCmd() received " << len << " bytes: " << std::setw(2) << std::setfill('0') << std::hex;
	for (i = 0; i < len; i++) {
		std::cout << (unsigned) buf[i] << " ";
	}
	std::cout << std::dec << std::endl;
#endif

	if (!success) {
		throw std::runtime_error(_errorMsg);
		return -1;
	}
    
        _errorCount = 0;
        return len;
}
	
double IPMIHost::readSensorRecord(std::vector<uint8_t>& record) {
	uint8_t rawReading = 0;
	double *reading = NULL;
	uint16_t eventBitmask = 0;

	bool success = false;
	int retries = RETRIES;
	while (retries-- && !success) {
		if (connect() == 0) {
			if (!_sensorReadCtx) {
				_sensorReadCtx = ipmi_sensor_read_ctx_create(_ipmiCtx);
			}
			
			if (_sensorReadCtx) {
				if (ipmi_sensor_read(_sensorReadCtx, &record[0], record.size(), 0, &rawReading, &reading, &eventBitmask) < 0) {
					_errorMsg = "Error reading IPMI record: " + std::string(ipmi_sensor_read_ctx_errormsg(_sensorReadCtx));
					increaseErrorCount();
					disconnect();
				} else {
					success = true;
				}
			} else {
				_errorMsg = "Error creating sensor context: " + std::string(ipmi_ctx_errormsg(_ipmiCtx));
			}
		} else {
			increaseErrorCount();
			disconnect();
		}
	}

	double ret = .0;
	if (success && reading) {
	    //TODO should _delayNextReadUntil be reset here?
		_errorCount = 0;
		ret = *reading;
		free(reading);
	} else {
		throw std::runtime_error(_errorMsg);
	}
	
	return ret;
}

void IPMIHost::increaseErrorCount() {
	uint64_t now = getTimestamp();
	if (_errorCount < 25) {
		_errorCount++;
	}
	if (_errorCount > 5) {
		_delayNextReadUntil = now + MS_TO_NS(500 * (_errorCount - 5));
	}
}

void IPMIHost::printEntityConfig(LOG_LEVEL ll) {
    LOG_VAR(ll) << eInd << "IPMIHost: " << getHostName();
    LOG_VAR(ll) << eInd << "UserName:     " << getUserName();
#ifdef DEBUG
    LOG_VAR(ll) << eInd << "Password:     " << getPassword();
#else
    LOG_VAR(ll) << eInd << "Password not shown";
#endif
    LOG_VAR(ll) << eInd << "Cache:        " << getCache();
    LOG_VAR(ll) << eInd << "Auth:         " << getAuth();
    LOG_VAR(ll) << eInd << "Priv:         " << getPriv();
    LOG_VAR(ll) << eInd << "Cipher:       " << getCipher();
    LOG_VAR(ll) << eInd << "IPMI Version: " << getIpmiVersion();
    LOG_VAR(ll) << eInd << "Session Timeout:        " << _sessionTimeout;
    LOG_VAR(ll) << eInd << "Retransmission Timeout: " << _retransmissionTimeout;
}