blob: 0359ee34390b22dac043a5406fad9e04aadb6d62 [file] [log] [blame]
/**
* Copyright © 2018 Intel Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <cxxabi.h>
#include <boost/asio/spawn.hpp>
#include <boost/callable_traits.hpp>
#include <ipmid/api-types.hpp>
#include <ipmid/message.hpp>
#include <phosphor-logging/log.hpp>
#include <user_channel/channel_layer.hpp>
#include <algorithm>
#include <cstdint>
#include <exception>
#include <memory>
#include <optional>
#include <stdexcept>
#include <tuple>
#include <utility>
#ifdef ALLOW_DEPRECATED_API
#include <ipmid/api.h>
#include <ipmid/oemrouter.hpp>
#endif /* ALLOW_DEPRECATED_API */
namespace ipmi
{
template <typename... Args>
static inline message::Response::ptr
errorResponse(message::Request::ptr request, ipmi::Cc cc, Args&&... args)
{
message::Response::ptr response = request->makeResponse();
response->cc = cc;
response->pack(args...);
return response;
}
static inline message::Response::ptr
errorResponse(message::Request::ptr request, ipmi::Cc cc)
{
message::Response::ptr response = request->makeResponse();
response->cc = cc;
return response;
}
/** @brief Exception extension that allows setting an IPMI return code */
class HandlerCompletion
{
public:
HandlerCompletion(Cc cc) noexcept : cc(cc) {}
Cc code() const noexcept
{
return cc;
}
private:
Cc cc;
};
/** @brief Exception extension that allows setting an IPMI return code and
* printing out a logged error */
class HandlerException : public HandlerCompletion, public std::runtime_error
{
public:
HandlerException(Cc cc, const char* what) :
HandlerCompletion(cc), std::runtime_error(what)
{}
HandlerException(Cc cc, const std::string& what) :
HandlerException(cc, what.c_str())
{}
};
static inline const char* currentExceptionType()
{
int status;
return abi::__cxa_demangle(abi::__cxa_current_exception_type()->name(), 0,
0, &status);
}
/**
* @brief Handler base class for dealing with IPMI request/response
*
* The subclasses are all templated so they can provide access to any type
* of command callback functions.
*/
class HandlerBase
{
public:
using ptr = std::shared_ptr<HandlerBase>;
virtual ~HandlerBase() = default;
/** @brief wrap the call to the registered handler with the request
*
* This is called from the running queue context after it has already
* created a request object that contains all the information required to
* execute the ipmi command. This function will return the response object
* pointer that owns the response object that will ultimately get sent back
* to the requester.
*
* This is a non-virtual function wrapper to the virtualized executeCallback
* function that actually does the work. This is required because of how
* templates and virtualization work together.
*
* @param request a shared_ptr to a Request object
*
* @return a shared_ptr to a Response object
*/
message::Response::ptr call(message::Request::ptr request)
{
return executeCallback(request);
}
private:
/** @brief call the registered handler with the request
*
* This is called from the running queue context after it has already
* created a request object that contains all the information required to
* execute the ipmi command. This function will return the response object
* pointer that owns the response object that will ultimately get sent back
* to the requester.
*
* @param request a shared_ptr to a Request object
*
* @return a shared_ptr to a Response object
*/
virtual message::Response::ptr
executeCallback(message::Request::ptr request) = 0;
};
/**
* @brief Main IPMI handler class
*
* New IPMI handlers will resolve into this class, which will read the signature
* of the registering function, attempt to extract the appropriate arguments
* from a request, pass the arguments to the function, and then pack the
* response of the function back into an IPMI response.
*/
template <typename Handler>
class IpmiHandler final : public HandlerBase
{
public:
explicit IpmiHandler(Handler&& handler) :
handler_(std::forward<Handler>(handler))
{}
private:
Handler handler_;
/** @brief call the registered handler with the request
*
* This is called from the running queue context after it has already
* created a request object that contains all the information required to
* execute the ipmi command. This function will return the response object
* pointer that owns the response object that will ultimately get sent back
* to the requester.
*
* Because this is the new variety of IPMI handler, this is the function
* that attempts to extract the requested parameters in order to pass them
* onto the callback function and then packages up the response into a plain
* old vector to pass back to the caller.
*
* @param request a shared_ptr to a Request object
*
* @return a shared_ptr to a Response object
*/
message::Response::ptr
executeCallback(message::Request::ptr request) override
{
message::Response::ptr response = request->makeResponse();
using CallbackSig = boost::callable_traits::args_t<Handler>;
using InputArgsType = typename utility::DecayTuple<CallbackSig>::type;
using UnpackArgsType = typename utility::StripFirstArgs<
utility::NonIpmiArgsCount<InputArgsType>::size(),
InputArgsType>::type;
using ResultType = boost::callable_traits::return_type_t<Handler>;
UnpackArgsType unpackArgs;
request->payload.trailingOk = false;
ipmi::Cc unpackError = request->unpack(unpackArgs);
if (unpackError != ipmi::ccSuccess)
{
response->cc = unpackError;
return response;
}
/* callbacks can contain an optional first argument of one of:
* 1) boost::asio::yield_context
* 2) ipmi::Context::ptr
* 3) ipmi::message::Request::ptr
*
* If any of those is part of the callback signature as the first
* argument, it will automatically get packed into the parameter pack
* here.
*
* One more special optional argument is an ipmi::message::Payload.
* This argument can be in any position, though logically it makes the
* most sense if it is the last. If this class is included in the
* handler signature, it will allow for the handler to unpack optional
* parameters. For example, the Set LAN Configuration Parameters
* command takes variable length (and type) values for each of the LAN
* parameters. This means that the only fixed data is the channel and
* parameter selector. All the remaining data can be extracted using
* the Payload class and the unpack API available to the Payload class.
*/
ResultType result;
try
{
std::optional<InputArgsType> inputArgs;
if constexpr (std::tuple_size<InputArgsType>::value > 0)
{
if constexpr (std::is_same<
std::tuple_element_t<0, InputArgsType>,
boost::asio::yield_context>::value)
{
inputArgs.emplace(std::tuple_cat(
std::forward_as_tuple(request->ctx->yield),
std::move(unpackArgs)));
}
else if constexpr (std::is_same<
std::tuple_element_t<0, InputArgsType>,
ipmi::Context::ptr>::value)
{
inputArgs.emplace(
std::tuple_cat(std::forward_as_tuple(request->ctx),
std::move(unpackArgs)));
}
else if constexpr (std::is_same<
std::tuple_element_t<0, InputArgsType>,
ipmi::message::Request::ptr>::value)
{
inputArgs.emplace(std::tuple_cat(
std::forward_as_tuple(request), std::move(unpackArgs)));
}
else
{
// no special parameters were requested (but others were)
inputArgs.emplace(std::move(unpackArgs));
}
}
else
{
// no parameters were requested
inputArgs = std::move(unpackArgs);
}
// execute the registered callback function and get the
// ipmi::RspType<>
result = std::apply(handler_, *inputArgs);
}
catch (const HandlerException& e)
{
phosphor::logging::log<phosphor::logging::level::INFO>(
"Handler produced exception",
phosphor::logging::entry("CC=%x", e.code()),
phosphor::logging::entry("EXCEPTION=%s", e.what()),
phosphor::logging::entry("NETFN=%x", request->ctx->netFn),
phosphor::logging::entry("CMD=%x", request->ctx->cmd));
return errorResponse(request, e.code());
}
catch (const std::exception& e)
{
phosphor::logging::log<phosphor::logging::level::ERR>(
"Handler failed to catch exception",
phosphor::logging::entry("EXCEPTION=%s", e.what()),
phosphor::logging::entry("NETFN=%x", request->ctx->netFn),
phosphor::logging::entry("CMD=%x", request->ctx->cmd));
return errorResponse(request, ccUnspecifiedError);
}
catch (const HandlerCompletion& c)
{
return errorResponse(request, c.code());
}
catch (...)
{
const char* what = currentExceptionType();
phosphor::logging::log<phosphor::logging::level::ERR>(
"Handler failed to catch exception",
phosphor::logging::entry("EXCEPTION=%s", what),
phosphor::logging::entry("NETFN=%x", request->ctx->netFn),
phosphor::logging::entry("CMD=%x", request->ctx->cmd));
return errorResponse(request, ccUnspecifiedError);
}
response->cc = std::get<0>(result);
auto payload = std::get<1>(result);
// check for optional payload
if (payload)
{
response->pack(*payload);
}
return response;
}
};
#ifdef ALLOW_DEPRECATED_API
static constexpr size_t maxLegacyBufferSize = 64 * 1024;
/**
* @brief Legacy IPMI handler class
*
* Legacy IPMI handlers will resolve into this class, which will behave the same
* way as the legacy IPMI queue, passing in a big buffer for the request and a
* big buffer for the response.
*
* As soon as all the handlers have been rewritten, this class will be marked as
* deprecated and eventually removed.
*/
template <>
class IpmiHandler<ipmid_callback_t> final : public HandlerBase
{
public:
explicit IpmiHandler(const ipmid_callback_t& handler, void* ctx = nullptr) :
handler_(handler), handlerCtx(ctx)
{}
private:
ipmid_callback_t handler_;
void* handlerCtx;
/** @brief call the registered handler with the request
*
* This is called from the running queue context after it has already
* created a request object that contains all the information required to
* execute the ipmi command. This function will return the response object
* pointer that owns the response object that will ultimately get sent back
* to the requester.
*
* Because this is the legacy variety of IPMI handler, this function does
* not really have to do much other than pass the payload to the callback
* and return response to the caller.
*
* @param request a shared_ptr to a Request object
*
* @return a shared_ptr to a Response object
*/
message::Response::ptr
executeCallback(message::Request::ptr request) override
{
message::Response::ptr response = request->makeResponse();
// allocate a big response buffer here
response->payload.resize(maxLegacyBufferSize);
size_t len = request->payload.size() - request->payload.rawIndex;
Cc ccRet{ccSuccess};
try
{
ccRet =
handler_(request->ctx->netFn, request->ctx->cmd,
request->payload.data() + request->payload.rawIndex,
response->payload.data(), &len, handlerCtx);
}
catch (const HandlerException& e)
{
phosphor::logging::log<phosphor::logging::level::INFO>(
"Legacy Handler produced exception",
phosphor::logging::entry("CC=%x", e.code()),
phosphor::logging::entry("EXCEPTION=%s", e.what()),
phosphor::logging::entry("NETFN=%x", request->ctx->netFn),
phosphor::logging::entry("CMD=%x", request->ctx->cmd));
return errorResponse(request, e.code());
}
catch (const std::exception& e)
{
phosphor::logging::log<phosphor::logging::level::ERR>(
"Legacy Handler failed to catch exception",
phosphor::logging::entry("EXCEPTION=%s", e.what()),
phosphor::logging::entry("NETFN=%x", request->ctx->netFn),
phosphor::logging::entry("CMD=%x", request->ctx->cmd));
return errorResponse(request, ccUnspecifiedError);
}
catch (const HandlerCompletion& c)
{
return errorResponse(request, c.code());
}
catch (...)
{
const char* what = currentExceptionType();
phosphor::logging::log<phosphor::logging::level::ERR>(
"Handler failed to catch exception",
phosphor::logging::entry("EXCEPTION=%s", what),
phosphor::logging::entry("NETFN=%x", request->ctx->netFn),
phosphor::logging::entry("CMD=%x", request->ctx->cmd));
return errorResponse(request, ccUnspecifiedError);
}
response->cc = ccRet;
response->payload.resize(len);
return response;
}
};
/**
* @brief Legacy IPMI OEM handler class
*
* Legacy IPMI OEM handlers will resolve into this class, which will behave the
* same way as the legacy IPMI queue, passing in a big buffer for the request
* and a big buffer for the response.
*
* As soon as all the handlers have been rewritten, this class will be marked as
* deprecated and eventually removed.
*/
template <>
class IpmiHandler<oem::Handler> final : public HandlerBase
{
public:
explicit IpmiHandler(const oem::Handler& handler) : handler_(handler) {}
private:
oem::Handler handler_;
/** @brief call the registered handler with the request
*
* This is called from the running queue context after it has already
* created a request object that contains all the information required to
* execute the ipmi command. This function will return the response object
* pointer that owns the response object that will ultimately get sent back
* to the requester.
*
* Because this is the legacy variety of IPMI handler, this function does
* not really have to do much other than pass the payload to the callback
* and return response to the caller.
*
* @param request a shared_ptr to a Request object
*
* @return a shared_ptr to a Response object
*/
message::Response::ptr
executeCallback(message::Request::ptr request) override
{
message::Response::ptr response = request->makeResponse();
// allocate a big response buffer here
response->payload.resize(maxLegacyBufferSize);
size_t len = request->payload.size() - request->payload.rawIndex;
Cc ccRet{ccSuccess};
try
{
ccRet =
handler_(request->ctx->cmd,
request->payload.data() + request->payload.rawIndex,
response->payload.data(), &len);
}
catch (const HandlerException& e)
{
phosphor::logging::log<phosphor::logging::level::INFO>(
"Legacy OEM Handler produced exception",
phosphor::logging::entry("CC=%x", e.code()),
phosphor::logging::entry("EXCEPTION=%s", e.what()),
phosphor::logging::entry("NETFN=%x", request->ctx->netFn),
phosphor::logging::entry("CMD=%x", request->ctx->cmd));
return errorResponse(request, e.code());
}
catch (const std::exception& e)
{
phosphor::logging::log<phosphor::logging::level::ERR>(
"Legacy OEM Handler failed to catch exception",
phosphor::logging::entry("EXCEPTION=%s", e.what()),
phosphor::logging::entry("NETFN=%x", request->ctx->netFn),
phosphor::logging::entry("CMD=%x", request->ctx->cmd));
return errorResponse(request, ccUnspecifiedError);
}
catch (const HandlerCompletion& c)
{
return errorResponse(request, c.code());
}
catch (...)
{
const char* what = currentExceptionType();
phosphor::logging::log<phosphor::logging::level::ERR>(
"Handler failed to catch exception",
phosphor::logging::entry("EXCEPTION=%s", what),
phosphor::logging::entry("NETFN=%x", request->ctx->netFn),
phosphor::logging::entry("CMD=%x", request->ctx->cmd));
return errorResponse(request, ccUnspecifiedError);
}
response->cc = ccRet;
response->payload.resize(len);
return response;
}
};
/**
* @brief create a legacy IPMI handler class and return a shared_ptr
*
* The queue uses a map of pointers to do the lookup. This function returns the
* shared_ptr that owns the Handler object.
*
* This is called internally via the ipmi_register_callback function.
*
* @param handler the function pointer to the callback
*
* @return A shared_ptr to the created handler object
*/
inline auto makeLegacyHandler(const ipmid_callback_t& handler,
void* ctx = nullptr)
{
HandlerBase::ptr ptr(new IpmiHandler<ipmid_callback_t>(handler, ctx));
return ptr;
}
/**
* @brief create a legacy IPMI OEM handler class and return a shared_ptr
*
* The queue uses a map of pointers to do the lookup. This function returns the
* shared_ptr that owns the Handler object.
*
* This is called internally via the Router::registerHandler method.
*
* @param handler the function pointer to the callback
*
* @return A shared_ptr to the created handler object
*/
inline auto makeLegacyHandler(oem::Handler&& handler)
{
HandlerBase::ptr ptr(
new IpmiHandler<oem::Handler>(std::forward<oem::Handler>(handler)));
return ptr;
}
#endif // ALLOW_DEPRECATED_API
/**
* @brief create an IPMI handler class and return a shared_ptr
*
* The queue uses a map of pointers to do the lookup. This function returns the
* shared_ptr that owns the Handler object.
*
* This is called internally via the ipmi::registerHandler function.
*
* @param handler the function pointer to the callback
*
* @return A shared_ptr to the created handler object
*/
template <typename Handler>
inline auto makeHandler(Handler&& handler)
{
HandlerBase::ptr ptr(
new IpmiHandler<Handler>(std::forward<Handler>(handler)));
return ptr;
}
namespace impl
{
// IPMI command handler registration implementation
bool registerHandler(int prio, NetFn netFn, Cmd cmd, Privilege priv,
::ipmi::HandlerBase::ptr handler);
bool registerGroupHandler(int prio, Group group, Cmd cmd, Privilege priv,
::ipmi::HandlerBase::ptr handler);
bool registerOemHandler(int prio, Iana iana, Cmd cmd, Privilege priv,
::ipmi::HandlerBase::ptr handler);
} // namespace impl
/**
* @brief main IPMI handler registration function
*
* This function should be used to register all new-style IPMI handler
* functions. This function just passes the callback to makeHandler, which
* creates a new wrapper object that will automatically extract the appropriate
* parameters for the callback function as well as pack up the response.
*
* @param prio - priority at which to register; see api.hpp
* @param netFn - the IPMI net function number to register
* @param cmd - the IPMI command number to register
* @param priv - the IPMI user privilige required for this command
* @param handler - the callback function that will handle this request
*
* @return bool - success of registering the handler
*/
template <typename Handler>
bool registerHandler(int prio, NetFn netFn, Cmd cmd, Privilege priv,
Handler&& handler)
{
auto h = ipmi::makeHandler(std::forward<Handler>(handler));
return impl::registerHandler(prio, netFn, cmd, priv, h);
}
/**
* @brief register a IPMI OEM group handler
*
* From IPMI 2.0 spec Network Function Codes Table (Row 2Ch):
* The first data byte position in requests and responses under this network
* function identifies the defining body that specifies command functionality.
* Software assumes that the command and completion code field positions will
* hold command and completion code values.
*
* The following values are used to identify the defining body:
* 00h PICMG - PCI Industrial Computer Manufacturer’s Group. (www.picmg.com)
* 01h DMTF Pre-OS Working Group ASF Specification (www.dmtf.org)
* 02h Server System Infrastructure (SSI) Forum (www.ssiforum.org)
* 03h VITA Standards Organization (VSO) (www.vita.com)
* DCh DCMI Specifications (www.intel.com/go/dcmi)
* all other Reserved
*
* When this network function is used, the ID for the defining body occupies
* the first data byte in a request, and the second data byte (following the
* completion code) in a response.
*
* @tparam Handler - implicitly specified callback function type
* @param prio - priority at which to register; see api.hpp
* @param netFn - the IPMI net function number to register
* @param cmd - the IPMI command number to register
* @param priv - the IPMI user privilige required for this command
* @param handler - the callback function that will handle this request
*
* @return bool - success of registering the handler
*
*/
template <typename Handler>
void registerGroupHandler(int prio, Group group, Cmd cmd, Privilege priv,
Handler&& handler)
{
auto h = ipmi::makeHandler(handler);
impl::registerGroupHandler(prio, group, cmd, priv, h);
}
/**
* @brief register a IPMI OEM IANA handler
*
* From IPMI spec Network Function Codes Table (Row 2Eh):
* The first three data bytes of requests and responses under this network
* function explicitly identify the OEM or non-IPMI group that specifies the
* command functionality. While the OEM or non-IPMI group defines the
* functional semantics for the cmd and remaining data fields, the cmd field
* is required to hold the same value in requests and responses for a given
* operation in order to be supported under the IPMI message handling and
* transport mechanisms.
*
* When this network function is used, the IANA Enterprise Number for the
* defining body occupies the first three data bytes in a request, and the
* first three data bytes following the completion code position in a
* response.
*
* @tparam Handler - implicitly specified callback function type
* @param prio - priority at which to register; see api.hpp
* @param netFn - the IPMI net function number to register
* @param cmd - the IPMI command number to register
* @param priv - the IPMI user privilige required for this command
* @param handler - the callback function that will handle this request
*
* @return bool - success of registering the handler
*
*/
template <typename Handler>
void registerOemHandler(int prio, Iana iana, Cmd cmd, Privilege priv,
Handler&& handler)
{
auto h = ipmi::makeHandler(handler);
impl::registerOemHandler(prio, iana, cmd, priv, h);
}
} // namespace ipmi
#ifdef ALLOW_DEPRECATED_API
/**
* @brief legacy IPMI handler registration function
*
* This function should be used to register all legacy IPMI handler
* functions. This function just behaves just as the legacy registration
* mechanism did, silently replacing any existing handler with a new one.
*
* @param netFn - the IPMI net function number to register
* @param cmd - the IPMI command number to register
* @param context - ignored
* @param handler - the callback function that will handle this request
* @param priv - the IPMI user privilige required for this command
*/
// [[deprecated("Use ipmi::registerHandler() instead")]]
void ipmi_register_callback(ipmi_netfn_t netFn, ipmi_cmd_t cmd,
ipmi_context_t context, ipmid_callback_t handler,
ipmi_cmd_privilege_t priv);
#endif /* ALLOW_DEPRECATED_API */