/*
* _read_ipmi_values read the Power sensor and update last_update_watt and times
*/
static xcc_raw_single_data_t *_read_ipmi_values(void)
{
xcc_raw_single_data_t *xcc_reading;
uint8_t buf_rs[IPMI_RAW_MAX_ARGS];
int rs_len = 0;
if (!IPMI_NET_FN_RQ_VALID(cmd_rq[1])) {
error("Invalid netfn value\n");
return NULL;
}
rs_len = ipmi_cmd_raw(ipmi_ctx,
cmd_rq[0], // Lun (logical unit number)
cmd_rq[1], // Net Function
&cmd_rq[2], // Command number + request data
cmd_rq_len - 2, // Length (in bytes)
&buf_rs, // response buffer
IPMI_RAW_MAX_ARGS // max response length
);
debug3("ipmi_cmd_raw: %s", ipmi_ctx_errormsg(ipmi_ctx));
if (rs_len != XCC_EXPECTED_RSPLEN) {
error("Invalid ipmi response length for XCC raw command: "
"%d bytes, expected %d", rs_len, XCC_EXPECTED_RSPLEN);
return NULL;
}
/* Due to memory alineation we must copy the data from the buffer */
xcc_reading = xmalloc(sizeof(xcc_raw_single_data_t));
if (slurm_ipmi_conf.flags & XCC_FLAG_FAKE) {
static uint32_t fake_past_read = 10774496;
static bool fake_inited = false;
if (!fake_inited) {
srand((unsigned) time(NULL));
fake_inited = true;
}
xcc_reading->fifo_inx = 0;
// Fake metric j
xcc_reading->j = fake_past_read + 550 + rand() % 200;
fake_past_read = xcc_reading->j;
xcc_reading->mj = 0;
xcc_reading->s = time(NULL); //Fake metric timestamp
xcc_reading->ms = 0;
} else {
memcpy(&xcc_reading->fifo_inx, buf_rs+2, 2);
memcpy(&xcc_reading->j, buf_rs+4, 4);
memcpy(&xcc_reading->mj, buf_rs+8, 2);
memcpy(&xcc_reading->s, buf_rs+10, 4);
memcpy(&xcc_reading->ms, buf_rs+14, 2);
}
return xcc_reading;
}
int
ipmi_openipmi_cmd_ipmb (ipmi_openipmi_ctx_t ctx,
uint8_t channel_number,
uint8_t rs_addr,
uint8_t lun,
uint8_t net_fn,
fiid_obj_t obj_cmd_rq,
fiid_obj_t obj_cmd_rs)
{
if (!ctx || ctx->magic != IPMI_OPENIPMI_CTX_MAGIC)
{
ERR_TRACE (ipmi_openipmi_ctx_errormsg (ctx), ipmi_openipmi_ctx_errnum (ctx));
return (-1);
}
if (!IPMI_CHANNEL_NUMBER_VALID (channel_number)
|| !IPMI_BMC_LUN_VALID (lun)
|| !IPMI_NET_FN_RQ_VALID (net_fn)
|| !fiid_obj_valid (obj_cmd_rq)
|| !fiid_obj_valid (obj_cmd_rs)
|| fiid_obj_packet_valid (obj_cmd_rq) <= 0)
{
OPENIPMI_SET_ERRNUM (ctx, IPMI_OPENIPMI_ERR_PARAMETERS);
return (-1);
}
if (!ctx->io_init)
{
OPENIPMI_SET_ERRNUM (ctx, IPMI_OPENIPMI_ERR_IO_NOT_INITIALIZED);
return (-1);
}
if (_openipmi_write (ctx,
channel_number,
rs_addr,
lun,
net_fn,
obj_cmd_rq,
1) < 0)
return (-1);
if (_openipmi_read (ctx,
obj_cmd_rs) < 0)
return (-1);
return (0);
}
int
ipmi_kcs_cmd (ipmi_kcs_ctx_t ctx,
uint8_t lun,
uint8_t net_fn,
fiid_obj_t obj_cmd_rq,
fiid_obj_t obj_cmd_rs)
{
if (!ctx || ctx->magic != IPMI_KCS_CTX_MAGIC)
{
ERR_TRACE (ipmi_kcs_ctx_errormsg (ctx), ipmi_kcs_ctx_errnum (ctx));
return (-1);
}
if (!IPMI_BMC_LUN_VALID (lun)
|| !IPMI_NET_FN_RQ_VALID (net_fn)
|| !fiid_obj_valid (obj_cmd_rq)
|| !fiid_obj_valid (obj_cmd_rs)
|| fiid_obj_packet_valid (obj_cmd_rq) <= 0)
{
KCS_SET_ERRNUM (ctx, IPMI_KCS_ERR_PARAMETERS);
return (-1);
}
if (!ctx->io_init)
{
KCS_SET_ERRNUM (ctx, IPMI_KCS_ERR_IO_NOT_INITIALIZED);
return (-1);
}
if (_ipmi_kcs_cmd_write (ctx, lun, net_fn, obj_cmd_rq) < 0)
return (-1);
if (_ipmi_kcs_cmd_read (ctx, obj_cmd_rs) < 0)
return (-1);
return (0);
}
int
ipmi_sunbmc_cmd (ipmi_sunbmc_ctx_t ctx,
uint8_t lun,
uint8_t net_fn,
fiid_obj_t obj_cmd_rq,
fiid_obj_t obj_cmd_rs)
{
if (!ctx || ctx->magic != IPMI_SUNBMC_CTX_MAGIC)
{
ERR_TRACE (ipmi_sunbmc_ctx_errormsg (ctx), ipmi_sunbmc_ctx_errnum (ctx));
return (-1);
}
if (!IPMI_BMC_LUN_VALID (lun)
|| !IPMI_NET_FN_RQ_VALID (net_fn)
|| !fiid_obj_valid (obj_cmd_rq)
|| !fiid_obj_valid (obj_cmd_rs)
|| fiid_obj_packet_valid (obj_cmd_rq) <= 0)
{
SUNBMC_SET_ERRNUM (ctx, IPMI_SUNBMC_ERR_PARAMETERS);
return (-1);
}
if (!ctx->io_init)
{
SUNBMC_SET_ERRNUM (ctx, IPMI_SUNBMC_ERR_IO_NOT_INITIALIZED);
return (-1);
}
if (ctx->putmsg_intf)
{
if (_sunbmc_write (ctx,
lun,
net_fn,
obj_cmd_rq) < 0)
return (-1);
if (_sunbmc_read (ctx,
obj_cmd_rs) < 0)
return (-1);
}
else
{
#if defined(HAVE_SYS_STROPTS_H)
struct strioctl istr;
bmc_reqrsp_t reqrsp;
uint8_t rq_buf_temp[IPMI_SUNBMC_BUFLEN];
uint8_t rq_buf[IPMI_SUNBMC_BUFLEN];
uint8_t rq_cmd;
unsigned int rq_buf_len;
uint8_t rs_buf[IPMI_SUNBMC_BUFLEN];
int len;
memset (&istr, '\0', sizeof (struct strioctl));
memset (&reqrsp, '\0', sizeof (bmc_reqrsp_t));
/* Due to API differences, we need to extract the cmd out of the
* request.
*/
memset (rq_buf_temp, '\0', IPMI_SUNBMC_BUFLEN);
if ((len = fiid_obj_get_all (obj_cmd_rq,
rq_buf_temp,
IPMI_SUNBMC_BUFLEN)) <= 0)
{
SUNBMC_SET_ERRNUM (ctx, IPMI_SUNBMC_ERR_INTERNAL_ERROR);
return (-1);
}
rq_cmd = rq_buf_temp[0];
if (len > 1)
{
/* -1 b/c of cmd */
memcpy (rq_buf, &rq_buf_temp[1], len - 1);
rq_buf_len = len - 1;
}
else
rq_buf_len = 0;
reqrsp.req.fn = net_fn;
reqrsp.req.lun = lun;
reqrsp.req.cmd = rq_cmd;
istr.ic_cmd = IOCTL_IPMI_KCS_ACTION;
istr.ic_timout = 0; /* spelled 'timout', not a typo */
istr.ic_len = sizeof (struct bmc_reqrsp);
istr.ic_dp = (char *)&reqrsp;
if (ioctl (ctx->device_fd,
I_STR,
&istr) < 0)
{
SUNBMC_ERRNO_TO_SUNBMC_ERRNUM (ctx, errno);
return (-1);
}
rs_buf[0] = reqrsp.rsp.cmd;
rs_buf[1] = reqrsp.rsp.ccode;
/* -2 b/c of cmd and ccode */
#if 0
/* achu: to remove warnings, IPMI_SUNBMC_BUFLEN > amount uint8_t can hold */
if (reqrsp.rsp.datalength >= (IPMI_SUNBMC_BUFLEN - 2))
reqrsp.rsp.datalength = IPMI_SUNBMC_BUFLEN - 2;
#endif
/* remove header data stuff in front we don't care about */
if (reqrsp.rsp.datalength > 3)
reqrsp.rsp.datalength -= 3;
else
reqrsp.rsp.datalength = 0;
memcpy (rs_buf + 2, reqrsp.rsp.data, reqrsp.rsp.datalength);
if (fiid_obj_set_all (obj_cmd_rs,
rs_buf,
reqrsp.rsp.datalength + 2) < 0)
{
SUNBMC_SET_ERRNUM (ctx, IPMI_SUNBMC_ERR_INTERNAL_ERROR);
return (-1);
}
#else /* !defined(HAVE_SYS_STROPTS_H) */
/* otherwise, device is not supported */
SUNBMC_SET_ERRNUM (ctx, IPMI_SUNBMC_ERR_DEVICE_NOT_SUPPORTED);
return (-1);
#endif /* !defined(HAVE_SYS_STROPTS_H) */
}
return (0);
}
static int
_sunbmc_write (ipmi_sunbmc_ctx_t ctx,
uint8_t lun,
uint8_t net_fn,
fiid_obj_t obj_cmd_rq)
{
#if defined(HAVE_SYS_STROPTS_H)
struct strbuf sbuf;
bmc_msg_t *msg = NULL;
bmc_req_t *req = NULL;
unsigned int msg_len;
uint8_t rq_buf_temp[IPMI_SUNBMC_BUFLEN];
uint8_t rq_buf[IPMI_SUNBMC_BUFLEN];
uint8_t rq_cmd;
unsigned int rq_buf_len;
int len;
#endif /* !defined(HAVE_SYS_STROPTS_H) */
int rv = -1;
assert (ctx);
assert (ctx->magic == IPMI_SUNBMC_CTX_MAGIC);
assert (IPMI_BMC_LUN_VALID (lun));
assert (IPMI_NET_FN_RQ_VALID (net_fn));
assert (fiid_obj_valid (obj_cmd_rq));
assert (fiid_obj_packet_valid (obj_cmd_rq) == 1);
assert (ctx->io_init);
assert (ctx->putmsg_intf);
#if defined(HAVE_SYS_STROPTS_H)
memset (&sbuf, '\0', sizeof (struct strbuf));
/* Due to API differences, we need to extract the cmd out of the
* request.
*/
memset (rq_buf_temp, '\0', IPMI_SUNBMC_BUFLEN);
if ((len = fiid_obj_get_all (obj_cmd_rq,
rq_buf_temp,
IPMI_SUNBMC_BUFLEN)) <= 0)
{
SUNBMC_SET_ERRNUM (ctx, IPMI_SUNBMC_ERR_INTERNAL_ERROR);
goto cleanup;
}
rq_cmd = rq_buf_temp[0];
if (len > 1)
{
memcpy (rq_buf, &rq_buf_temp[1], len - 1);
rq_buf_len = len - 1;
}
else
rq_buf_len = 0;
/* achu: see header for for how this is calculated */
msg_len = offsetof (bmc_msg_t, msg);
msg_len += sizeof (bmc_req_t);
msg_len += (rq_buf_len > SEND_MAX_PAYLOAD_SIZE) ? (rq_buf_len - SEND_MAX_PAYLOAD_SIZE) : 0;
if (!(msg = (bmc_msg_t *)malloc (msg_len)))
{
SUNBMC_SET_ERRNUM (ctx, IPMI_SUNBMC_ERR_OUT_OF_MEMORY);
goto cleanup;
}
msg->m_type = BMC_MSG_REQUEST;
msg->m_id = ctx->putmsg_intf_msg_id;
req = (bmc_req_t *)&(msg->msg[0]);
req->fn = net_fn;
req->lun = lun;
req->cmd = rq_cmd;
req->datalength = rq_buf_len;
memcpy (req->data, rq_buf, rq_buf_len);
sbuf.len = msg_len;
sbuf.buf = (char *)msg;
if (putmsg (ctx->device_fd, NULL, &sbuf, 0) < 0)
{
SUNBMC_ERRNO_TO_SUNBMC_ERRNUM (ctx, errno);
goto cleanup;
}
#else /* !defined(HAVE_SYS_STROPTS_H) */
/* otherwise, device is not supported */
SUNBMC_SET_ERRNUM (ctx, IPMI_SUNBMC_ERR_DEVICE_NOT_SUPPORTED);
goto cleanup;
#endif /* !(defined(HAVE_BMC_INTF_H) && defined(HAVE_SYS_STROPTS_H)) */
rv = 0;
cleanup:
#if defined(HAVE_SYS_STROPTS_H)
free (msg);
#endif /* !defined(HAVE_SYS_STROPTS_H) */
return (rv);
}
static int
_openipmi_write (ipmi_openipmi_ctx_t ctx,
uint8_t channel_number,
uint8_t rs_addr,
uint8_t lun,
uint8_t net_fn,
fiid_obj_t obj_cmd_rq,
unsigned int is_ipmb)
{
uint8_t rq_buf_temp[IPMI_OPENIPMI_BUFLEN];
uint8_t rq_buf[IPMI_OPENIPMI_BUFLEN];
uint8_t rq_cmd;
unsigned int rq_buf_len;
int len;
struct ipmi_system_interface_addr system_interface_addr;
struct ipmi_ipmb_addr ipmb_addr;
struct ipmi_req rq_packet;
assert (ctx);
assert (ctx->magic == IPMI_OPENIPMI_CTX_MAGIC);
assert (IPMI_CHANNEL_NUMBER_VALID (channel_number));
assert (IPMI_BMC_LUN_VALID (lun));
assert (IPMI_NET_FN_RQ_VALID (net_fn));
assert (fiid_obj_valid (obj_cmd_rq));
assert (fiid_obj_packet_valid (obj_cmd_rq) == 1);
/* Due to API differences, we need to extract the cmd out of the
* request.
*/
memset (rq_buf_temp, '\0', IPMI_OPENIPMI_BUFLEN);
if ((len = fiid_obj_get_all (obj_cmd_rq,
rq_buf_temp,
IPMI_OPENIPMI_BUFLEN)) <= 0)
{
OPENIPMI_SET_ERRNUM (ctx, IPMI_OPENIPMI_ERR_INTERNAL_ERROR);
return (-1);
}
rq_cmd = rq_buf_temp[0];
if (len > 1)
{
/* -1 b/c of cmd */
memcpy (rq_buf, &rq_buf_temp[1], len - 1);
rq_buf_len = len - 1;
}
else
rq_buf_len = 0;
if (!is_ipmb)
{
system_interface_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; /* openipmi macro */
system_interface_addr.channel = IPMI_CHANNEL_NUMBER_SYSTEM_INTERFACE; /* freeipmi macro */
system_interface_addr.lun = lun;
rq_packet.addr = (unsigned char *)&system_interface_addr;
rq_packet.addr_len = sizeof (struct ipmi_system_interface_addr);
}
else
{
ipmb_addr.addr_type = IPMI_IPMB_ADDR_TYPE; /* openipmi macro */
ipmb_addr.channel = channel_number;
ipmb_addr.slave_addr = rs_addr;
ipmb_addr.lun = lun;
rq_packet.addr = (unsigned char *)&ipmb_addr;
rq_packet.addr_len = sizeof (struct ipmi_ipmb_addr);
}
rq_packet.msgid = 0;
rq_packet.msg.netfn = net_fn;
rq_packet.msg.cmd = rq_cmd;
rq_packet.msg.data_len = rq_buf_len;
rq_packet.msg.data = rq_buf;
if (ioctl (ctx->device_fd,
IPMICTL_SEND_COMMAND,
&rq_packet) < 0)
{
OPENIPMI_ERRNO_TO_OPENIPMI_ERRNUM (ctx, errno);
return (-1);
}
return (0);
}
static int
_ipmi_kcs_cmd_write (ipmi_kcs_ctx_t ctx,
uint8_t lun,
uint8_t net_fn,
fiid_obj_t obj_cmd_rq)
{
uint8_t *pkt = NULL;
unsigned int pkt_len;
int hdr_len, cmd_len, rv = -1;
fiid_obj_t obj_hdr = NULL;
assert (ctx);
assert (ctx->magic == IPMI_KCS_CTX_MAGIC);
assert (IPMI_BMC_LUN_VALID (lun));
assert (IPMI_NET_FN_RQ_VALID (net_fn));
assert (fiid_obj_valid (obj_cmd_rq));
assert (fiid_obj_packet_valid (obj_cmd_rq) == 1);
if ((hdr_len = fiid_template_len_bytes (tmpl_hdr_kcs)) < 0)
{
KCS_ERRNO_TO_KCS_ERRNUM (ctx, errno);
goto cleanup;
}
if ((cmd_len = fiid_obj_len_bytes (obj_cmd_rq)) < 0)
{
KCS_FIID_OBJECT_ERROR_TO_KCS_ERRNUM (ctx, obj_cmd_rq);
goto cleanup;
}
if (!(obj_hdr = fiid_obj_create (tmpl_hdr_kcs)))
{
KCS_ERRNO_TO_KCS_ERRNUM (ctx, errno);
goto cleanup;
}
pkt_len = hdr_len + cmd_len;
if (!(pkt = (uint8_t *)malloc (pkt_len)))
{
KCS_SET_ERRNUM (ctx, IPMI_KCS_ERR_OUT_OF_MEMORY);
goto cleanup;
}
if (fill_hdr_ipmi_kcs (lun,
net_fn,
obj_hdr) < 0)
{
KCS_SET_ERRNUM (ctx, IPMI_KCS_ERR_INTERNAL_ERROR);
goto cleanup;
}
if (assemble_ipmi_kcs_pkt (obj_hdr,
obj_cmd_rq,
pkt,
pkt_len,
IPMI_INTERFACE_FLAGS_DEFAULT) < 0)
{
KCS_SET_ERRNUM (ctx, IPMI_KCS_ERR_INTERNAL_ERROR);
goto cleanup;
}
if (ipmi_kcs_write (ctx, pkt, pkt_len) < 0)
goto cleanup;
rv = 0;
cleanup:
fiid_obj_destroy (obj_hdr);
free (pkt);
return (rv);
}
