ipmi_kcs_ctx_t
ipmi_kcs_ctx_create (void)
{
ipmi_kcs_ctx_t ctx = NULL;
if (!(ctx = (ipmi_kcs_ctx_t)malloc (sizeof (struct ipmi_kcs_ctx))))
{
ERRNO_TRACE (errno);
return (NULL);
}
ctx->magic = IPMI_KCS_CTX_MAGIC;
ctx->driver_address = IPMI_KCS_SMS_IO_BASE_DEFAULT;
ctx->register_spacing = IPMI_KCS_SMS_REGISTER_SPACING_DEFAULT;
ctx->flags = IPMI_KCS_FLAGS_DEFAULT;
ctx->poll_interval = IPMI_KCS_SLEEP_USECS;
#ifdef __FreeBSD__
#ifndef USE_IOPERM
ctx->dev_fd = -1;
#endif
#endif /* __FreeBSD__ */
ctx->io_init = 0;
if ((ctx->semid = driver_mutex_init ()) < 0)
{
ERRNO_TRACE (errno);
goto cleanup;
}
ctx->errnum = IPMI_KCS_ERR_SUCCESS;
return (ctx);
cleanup:
free (ctx);
return (NULL);
}
int
driver_mutex_init (void)
{
int semid = -1;
key_t key;
/* Allocate Mutex */
#ifndef NDEBUG
if ((key = ftok (IPMI_IPCKEY, IPMI_INBAND_PROJ_ID)) == ((key_t)-1))
/* When doing development out of the source code tree, the
* IPCKEY file may not yet exist, so we do a hack to get it to
* work. This is only when we work in debug mode.
*/
key = ftok (IPMI_DEBUG_IPCKEY, IPMI_INBAND_DEBUG_PROJ_ID);
#else /* !NDEBUG */
if ((key = ftok (IPMI_IPCKEY, IPMI_INBAND_PROJ_ID)) == ((key_t)-1))
{
ERRNO_TRACE (errno);
return (-1);
}
#endif /* NDEBUG */
if ((semid = semget (key, 1, IPC_CREAT | IPC_EXCL | 0600)) < 0)
{
if (errno == EEXIST) /* You are not the first one */
{
/* Get the orignial semid */
if ((semid = semget (key, 1, IPC_CREAT | 0600)) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
/* achu: errno may not get reset, so put it back to 0 */
errno = 0;
return (semid);
}
ERRNO_TRACE (errno);
return (-1);
}
/* You are the first one. Initialize the mutex now */
{
union semun mutex_init;
unsigned short values[1];
values[0] = 1;
mutex_init.array = values;
if (semctl (semid, 0, SETALL, mutex_init) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
}
return (semid);
}
int
debug_output_str (int fd, const char *prefix, const char *str)
{
/* achu: Yeah, I know this is slow. Figure out something better
* later.
*/
if (str)
{
char *ptr = (char *)str;
if (prefix)
{
if (debug_dprintf (fd, "%s", prefix) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
}
while (*ptr != '\0')
{
if (*ptr == '\n')
{
if (debug_dprintf (fd, "%c", *ptr++) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
if (prefix)
{
if (debug_dprintf (fd, "%s", prefix) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
}
}
else
{
if (debug_dprintf (fd, "%c", *ptr++) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
}
}
if (debug_dprintf (fd, "\n") < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
}
return (0);
}
int
fill_cmd_write_fru_data (uint8_t fru_device_id,
uint16_t fru_inventory_offset_to_write,
const void *data_to_write,
unsigned int data_to_write_len,
fiid_obj_t obj_cmd_rq)
{
if ((data_to_write
&& data_to_write_len > IPMI_FRU_DATA_MAX)
|| !fiid_obj_valid (obj_cmd_rq))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rq, tmpl_cmd_write_fru_data_rq) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
FILL_FIID_OBJ_CLEAR (obj_cmd_rq);
FILL_FIID_OBJ_SET (obj_cmd_rq, "cmd", IPMI_CMD_WRITE_FRU_DATA);
FILL_FIID_OBJ_SET (obj_cmd_rq, "fru_device_id", fru_device_id);
FILL_FIID_OBJ_SET (obj_cmd_rq, "fru_inventory_offset_to_write", fru_inventory_offset_to_write);
if (data_to_write && data_to_write_len)
FILL_FIID_OBJ_SET_DATA (obj_cmd_rq, "data_to_write", data_to_write, data_to_write_len);
return (0);
}
int
fill_cmd_read_fru_data (uint8_t fru_device_id,
uint16_t fru_inventory_offset_to_read,
uint8_t count_to_read,
fiid_obj_t obj_cmd_rq)
{
if (!fiid_obj_valid (obj_cmd_rq))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rq, tmpl_cmd_read_fru_data_rq) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
FILL_FIID_OBJ_CLEAR (obj_cmd_rq);
FILL_FIID_OBJ_SET (obj_cmd_rq, "cmd", IPMI_CMD_READ_FRU_DATA);
FILL_FIID_OBJ_SET (obj_cmd_rq, "fru_device_id", fru_device_id);
FILL_FIID_OBJ_SET (obj_cmd_rq, "fru_inventory_offset_to_read", fru_inventory_offset_to_read);
FILL_FIID_OBJ_SET (obj_cmd_rq, "count_to_read", count_to_read);
return (0);
}
int
fill_cmd_set_auxiliary_log_status (uint8_t log_type,
const void *log_data,
unsigned int log_data_len,
fiid_obj_t obj_cmd_rq)
{
if (!IPMI_AUXILIARY_LOG_TYPE_VALID (log_type)
|| !log_data
|| !log_data_len
|| !fiid_obj_valid (obj_cmd_rq))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rq, tmpl_cmd_set_auxiliary_log_status_rq) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
FILL_FIID_OBJ_CLEAR (obj_cmd_rq);
FILL_FIID_OBJ_SET (obj_cmd_rq, "cmd", IPMI_CMD_SET_AUXILIARY_LOG_STATUS);
FILL_FIID_OBJ_SET (obj_cmd_rq, "log_type", log_type);
FILL_FIID_OBJ_SET (obj_cmd_rq, "reserved", 0);
FILL_FIID_OBJ_SET_DATA (obj_cmd_rq,
"log_data",
log_data,
log_data_len);
return (0);
}
ssize_t
ipmi_network_sendto (int s,
const void *buf,
size_t len,
int flags,
const struct sockaddr *to,
socklen_t tolen)
{
ssize_t rv;
if (!buf
|| !len)
{
SET_ERRNO (EINVAL);
return (-1);
}
if ((rv = sendto (s, buf, len, flags, to, tolen)) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
return (rv);
}
int
fill_cmd_get_oem_netfn_iana_support (uint8_t channel_number,
uint8_t net_fn,
uint8_t list_index,
fiid_obj_t obj_cmd_rq)
{
if (!IPMI_CHANNEL_NUMBER_VALID (channel_number)
|| (net_fn != IPMI_NET_FN_GROUP_EXTENSION_RQ
&& net_fn != IPMI_NET_FN_OEM_GROUP_RQ)
|| !fiid_obj_valid (obj_cmd_rq))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rq, tmpl_cmd_get_oem_netfn_iana_support_rq) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
FILL_FIID_OBJ_CLEAR (obj_cmd_rq);
FILL_FIID_OBJ_SET (obj_cmd_rq, "cmd", IPMI_CMD_GET_OEM_NETFN_IANA_SUPPORT);
FILL_FIID_OBJ_SET (obj_cmd_rq, "channel_number", channel_number);
FILL_FIID_OBJ_SET (obj_cmd_rq, "reserved1", 0);
FILL_FIID_OBJ_SET (obj_cmd_rq, "net_fn", net_fn);
FILL_FIID_OBJ_SET (obj_cmd_rq, "reserved2", 0);
FILL_FIID_OBJ_SET (obj_cmd_rq, "list_index", list_index);
FILL_FIID_OBJ_SET (obj_cmd_rq, "reserved3", 0);
return (0);
}
int
fill_rmcp_hdr (uint8_t message_class, fiid_obj_t obj_rmcp_hdr)
{
if (!RMCP_HDR_MESSAGE_CLASS_VALID (message_class)
|| !fiid_obj_valid (obj_rmcp_hdr))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_rmcp_hdr, tmpl_rmcp_hdr) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
FILL_FIID_OBJ_CLEAR (obj_rmcp_hdr);
FILL_FIID_OBJ_SET (obj_rmcp_hdr, "version", RMCP_VERSION_1_0);
FILL_FIID_OBJ_SET (obj_rmcp_hdr, "reserved", 0);
FILL_FIID_OBJ_SET (obj_rmcp_hdr, "sequence_number", RMCP_HDR_SEQ_NUM_NO_RMCP_ACK);
FILL_FIID_OBJ_SET (obj_rmcp_hdr, "message_class.class", message_class);
FILL_FIID_OBJ_SET (obj_rmcp_hdr, "message_class.reserved", 0);
FILL_FIID_OBJ_SET (obj_rmcp_hdr, "message_class.ack", RMCP_HDR_MESSAGE_CLASS_BIT_RMCP_NORMAL);
return (0);
}
int
fill_lan_session_hdr (uint8_t authentication_type,
uint32_t session_sequence_number,
uint32_t session_id,
fiid_obj_t obj_lan_session_hdr)
{
if (!IPMI_AUTHENTICATION_TYPE_VALID (authentication_type)
|| !fiid_obj_valid (obj_lan_session_hdr))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_lan_session_hdr, tmpl_lan_session_hdr) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
FILL_FIID_OBJ_CLEAR (obj_lan_session_hdr);
FILL_FIID_OBJ_SET (obj_lan_session_hdr, "authentication_type", authentication_type);
FILL_FIID_OBJ_SET (obj_lan_session_hdr, "session_sequence_number", session_sequence_number);
FILL_FIID_OBJ_SET (obj_lan_session_hdr, "session_id", session_id);
/* authentication_code_data calculated in assemble_ipmi_lan_pkt */
/* ipmi_msg_len calculated in assemble_ipmi_lan_pkt */
return (0);
}
ssize_t
ipmi_network_recvfrom (int s,
void *buf,
size_t len,
int flags,
struct sockaddr *from,
socklen_t *fromlen)
{
ssize_t rv;
if (!buf
|| !len)
{
SET_ERRNO (EINVAL);
return (-1);
}
if ((rv = recvfrom (s, buf, len, flags, from, fromlen)) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
return (rv);
}
int
ipmi_rmcp_check_message_tag (fiid_obj_t pong, uint8_t message_tag)
{
uint8_t l_message_tag;
uint64_t val;
if (!fiid_obj_valid (pong))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (pong, tmpl_cmd_asf_presence_pong) < 0)
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_GET (pong, "message_tag", &val) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
l_message_tag = val;
if (message_tag == l_message_tag)
return (1);
return (0);
}
int
fill_hdr_ipmi_kcs (uint8_t lun,
uint8_t fn,
fiid_obj_t obj_kcs_hdr)
{
if (!IPMI_BMC_LUN_VALID (lun)
|| !IPMI_NET_FN_VALID (fn)
|| !fiid_obj_valid (obj_kcs_hdr))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_kcs_hdr, tmpl_hdr_kcs) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
FILL_FIID_OBJ_CLEAR (obj_kcs_hdr);
FILL_FIID_OBJ_SET (obj_kcs_hdr, "lun", lun);
FILL_FIID_OBJ_SET (obj_kcs_hdr, "net_fn", fn);
return (0);
}
int
fill_cmd_get_sel_entry (uint16_t reservation_id,
uint16_t record_id,
uint8_t offset_into_record,
uint8_t bytes_to_read,
fiid_obj_t obj_cmd_rq)
{
if (!fiid_obj_valid (obj_cmd_rq))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rq, tmpl_cmd_get_sel_entry_rq) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
FILL_FIID_OBJ_CLEAR (obj_cmd_rq);
FILL_FIID_OBJ_SET (obj_cmd_rq, "cmd", IPMI_CMD_GET_SEL_ENTRY);
FILL_FIID_OBJ_SET (obj_cmd_rq, "reservation_id", reservation_id);
FILL_FIID_OBJ_SET (obj_cmd_rq, "record_id", record_id);
FILL_FIID_OBJ_SET (obj_cmd_rq, "offset_into_record", offset_into_record);
FILL_FIID_OBJ_SET (obj_cmd_rq, "bytes_to_read", bytes_to_read);
return (0);
}
int
fill_cmd_clear_sel (uint16_t reservation_id,
uint8_t operation,
fiid_obj_t obj_cmd_rq)
{
if (!IPMI_SEL_CLEAR_OPERATION_VALID (operation)
|| !fiid_obj_valid (obj_cmd_rq))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rq, tmpl_cmd_clear_sel_rq) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
/* achu: the "CLR" is exactly from the spec. I know it looks dumb */
FILL_FIID_OBJ_CLEAR (obj_cmd_rq);
FILL_FIID_OBJ_SET (obj_cmd_rq, "cmd", IPMI_CMD_CLEAR_SEL);
FILL_FIID_OBJ_SET (obj_cmd_rq, "reservation_id", reservation_id);
FILL_FIID_OBJ_SET (obj_cmd_rq, "C", 'C');
FILL_FIID_OBJ_SET (obj_cmd_rq, "L", 'L');
FILL_FIID_OBJ_SET (obj_cmd_rq, "R", 'R');
FILL_FIID_OBJ_SET (obj_cmd_rq, "operation", operation);
return (0);
}
ipmi_sensor_read_ctx_t
ipmi_sensor_read_ctx_create (ipmi_ctx_t ipmi_ctx)
{
struct ipmi_sensor_read_ctx *ctx = NULL;
if (!ipmi_ctx)
{
SET_ERRNO (EINVAL);
return (NULL);
}
/* check that ipmi_ctx is open for use */
if (ipmi_ctx_get_target (ipmi_ctx, NULL, NULL) < 0)
{
SET_ERRNO (EINVAL);
return (NULL);
}
if (!(ctx = (ipmi_sensor_read_ctx_t)malloc (sizeof (struct ipmi_sensor_read_ctx))))
{
ERRNO_TRACE (errno);
return (NULL);
}
ctx->magic = IPMI_SENSOR_READ_CTX_MAGIC;
ctx->flags = IPMI_SENSOR_READ_FLAGS_DEFAULT;
ctx->ipmi_ctx = ipmi_ctx;
ctx->sdr_ctx = NULL;
if (!(ctx->sdr_ctx = ipmi_sdr_ctx_create ()))
{
ERRNO_TRACE (errno);
goto cleanup;
}
return (ctx);
cleanup:
if (ctx)
{
ipmi_sdr_ctx_destroy (ctx->sdr_ctx);
free (ctx);
}
return (NULL);
}
int
debug_output_byte_array (int fd, const char *prefix, const uint8_t *buf, unsigned int buf_len)
{
unsigned int count = 0;
assert (buf);
while (count < buf_len)
{
int i = 0;
if (prefix)
{
if (debug_dprintf (fd, "%s", prefix) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
}
if (debug_dprintf (fd, "[ ") < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
while (count < buf_len && i < IPMI_DEBUG_CHAR_PER_LINE)
{
if (debug_dprintf (fd, "%02Xh ", buf[count++]) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
i++;
}
if (debug_dprintf (fd, "]\n") < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
}
return (0);
}
int
fill_ipmb_msg_hdr (uint8_t rs_addr,
uint8_t net_fn,
uint8_t rs_lun,
uint8_t rq_addr,
uint8_t rq_lun,
uint8_t rq_seq,
fiid_obj_t obj_ipmb_msg_hdr)
{
uint8_t checksum_buf[1024];
int checksum_len;
uint8_t checksum;
if (!IPMI_NET_FN_VALID (net_fn)
|| !IPMI_BMC_LUN_VALID (rs_lun)
|| !IPMI_BMC_LUN_VALID (rq_lun)
|| (rq_seq > IPMI_IPMB_REQUESTER_SEQUENCE_NUMBER_MAX)
|| !fiid_obj_valid (obj_ipmb_msg_hdr))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_ipmb_msg_hdr, tmpl_ipmb_msg_hdr_rq) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
FILL_FIID_OBJ_CLEAR (obj_ipmb_msg_hdr);
FILL_FIID_OBJ_SET (obj_ipmb_msg_hdr, "rs_addr", rs_addr);
FILL_FIID_OBJ_SET (obj_ipmb_msg_hdr, "net_fn", net_fn);
FILL_FIID_OBJ_SET (obj_ipmb_msg_hdr, "rs_lun", rs_lun);
if ((checksum_len = fiid_obj_get_block (obj_ipmb_msg_hdr,
"rs_addr",
"net_fn",
checksum_buf,
1024)) < 0)
{
FIID_OBJECT_ERROR_TO_ERRNO (obj_ipmb_msg_hdr);
return (-1);
}
checksum = ipmi_checksum (checksum_buf, checksum_len);
FILL_FIID_OBJ_SET (obj_ipmb_msg_hdr, "checksum1", checksum);
FILL_FIID_OBJ_SET (obj_ipmb_msg_hdr, "rq_addr", rq_addr);
FILL_FIID_OBJ_SET (obj_ipmb_msg_hdr, "rq_lun", rq_lun);
FILL_FIID_OBJ_SET (obj_ipmb_msg_hdr, "rq_seq", rq_seq);
return (0);
}
int
fill_cmd_set_command_enables (uint8_t channel_number,
uint8_t net_fn,
uint8_t operation,
uint8_t lun,
uint8_t *enable_disable_bitmask,
unsigned int enable_disable_bitmask_len,
uint32_t net_fn_data,
fiid_obj_t obj_cmd_rq)
{
if (!IPMI_CHANNEL_NUMBER_VALID (channel_number)
|| !IPMI_NET_FN_VALID (net_fn)
|| !IPMI_FIRMWARE_FIREWALL_COMMAND_DISCOVERY_OPERATION_VALID (operation)
|| !IPMI_BMC_LUN_VALID (lun)
|| !enable_disable_bitmask
|| enable_disable_bitmask_len < IPMI_FIRMWARE_FIREWALL_COMMAND_DISCOVERY_ENABLE_DISABLE_BITMASK_LEN
|| !fiid_obj_valid (obj_cmd_rq))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rq, tmpl_cmd_set_command_enables_rq) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
FILL_FIID_OBJ_CLEAR (obj_cmd_rq);
FILL_FIID_OBJ_SET (obj_cmd_rq, "cmd", IPMI_CMD_SET_COMMAND_ENABLES);
FILL_FIID_OBJ_SET (obj_cmd_rq, "channel_number", channel_number);
FILL_FIID_OBJ_SET (obj_cmd_rq, "reserved1", 0);
FILL_FIID_OBJ_SET (obj_cmd_rq, "net_fn", net_fn);
FILL_FIID_OBJ_SET (obj_cmd_rq, "operation", operation);
FILL_FIID_OBJ_SET (obj_cmd_rq, "lun", lun);
FILL_FIID_OBJ_SET (obj_cmd_rq, "reserved2", 0);
FILL_FIID_OBJ_SET_DATA (obj_cmd_rq,
"enable_disable_mask",
enable_disable_bitmask,
IPMI_FIRMWARE_FIREWALL_COMMAND_DISCOVERY_ENABLE_DISABLE_BITMASK_LEN);
if (net_fn == IPMI_NET_FN_GROUP_EXTENSION_RQ
|| net_fn == IPMI_NET_FN_GROUP_EXTENSION_RS)
{
uint8_t tmp = net_fn_data;
FILL_FIID_OBJ_SET_DATA (obj_cmd_rq, "net_fn_data", &tmp, 1);
}
else if (net_fn == IPMI_NET_FN_OEM_GROUP_RQ
|| net_fn == IPMI_NET_FN_OEM_GROUP_RS)
FILL_FIID_OBJ_SET (obj_cmd_rq, "net_fn_data", net_fn_data);
return (0);
}
int
driver_mutex_lock (int semid)
{
/* achu: don't check for valid semid - responsibility of calling libs */
do {
if (semop (semid, &mutex_lock_buf, 1) < 0)
{
/* While blocked in this system call, the process caught a signal */
if (errno == EINTR)
continue;
ERRNO_TRACE (errno);
return (-1);
}
break;
} while (1);
return (0);
}
int
fill_cmd_get_command_sub_function_enables (uint8_t channel_number,
uint8_t net_fn,
uint8_t lun,
uint8_t command,
uint32_t net_fn_data,
fiid_obj_t obj_cmd_rq)
{
if (!IPMI_CHANNEL_NUMBER_VALID (channel_number)
|| !IPMI_NET_FN_VALID (net_fn)
|| !IPMI_BMC_LUN_VALID (lun)
|| !fiid_obj_valid (obj_cmd_rq))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rq, tmpl_cmd_get_command_sub_function_enables_rq) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
FILL_FIID_OBJ_CLEAR (obj_cmd_rq);
FILL_FIID_OBJ_SET (obj_cmd_rq, "cmd", IPMI_CMD_GET_COMMAND_SUB_FUNCTION_ENABLES);
FILL_FIID_OBJ_SET (obj_cmd_rq, "channel_number", channel_number);
FILL_FIID_OBJ_SET (obj_cmd_rq, "reserved1", 0);
FILL_FIID_OBJ_SET (obj_cmd_rq, "net_fn", net_fn);
FILL_FIID_OBJ_SET (obj_cmd_rq, "reserved2", 0);
FILL_FIID_OBJ_SET (obj_cmd_rq, "lun", lun);
FILL_FIID_OBJ_SET (obj_cmd_rq, "reserved3", 0);
FILL_FIID_OBJ_SET (obj_cmd_rq, "command", command);
if (net_fn == IPMI_NET_FN_GROUP_EXTENSION_RQ
|| net_fn == IPMI_NET_FN_GROUP_EXTENSION_RS)
{
uint8_t tmp = net_fn_data;
FILL_FIID_OBJ_SET_DATA (obj_cmd_rq, "net_fn_data", &tmp, 1);
}
else if (net_fn == IPMI_NET_FN_OEM_GROUP_RQ
|| net_fn == IPMI_NET_FN_OEM_GROUP_RS)
FILL_FIID_OBJ_SET (obj_cmd_rq, "net_fn_data", net_fn_data);
return (0);
}
int
fill_cmd_get_configurable_commands (uint8_t channel_number,
uint8_t net_fn,
uint8_t operation,
uint8_t lun,
uint32_t net_fn_data,
fiid_obj_t obj_cmd_rq)
{
if (!IPMI_CHANNEL_NUMBER_VALID (channel_number)
|| !IPMI_NET_FN_VALID (net_fn)
|| !IPMI_FIRMWARE_FIREWALL_COMMAND_DISCOVERY_OPERATION_VALID (operation)
|| !IPMI_BMC_LUN_VALID (lun)
|| !fiid_obj_valid (obj_cmd_rq))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rq, tmpl_cmd_get_configurable_commands_rq) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
FILL_FIID_OBJ_CLEAR (obj_cmd_rq);
FILL_FIID_OBJ_SET (obj_cmd_rq, "cmd", IPMI_CMD_GET_CONFIGURABLE_COMMANDS);
FILL_FIID_OBJ_SET (obj_cmd_rq, "channel_number", channel_number);
FILL_FIID_OBJ_SET (obj_cmd_rq, "reserved1", 0);
FILL_FIID_OBJ_SET (obj_cmd_rq, "net_fn", net_fn);
FILL_FIID_OBJ_SET (obj_cmd_rq, "operation", operation);
FILL_FIID_OBJ_SET (obj_cmd_rq, "lun", lun);
FILL_FIID_OBJ_SET (obj_cmd_rq, "reserved2", 0);
if (net_fn == IPMI_NET_FN_GROUP_EXTENSION_RQ
|| net_fn == IPMI_NET_FN_GROUP_EXTENSION_RS)
{
uint8_t tmp = net_fn_data;
FILL_FIID_OBJ_SET_DATA (obj_cmd_rq, "net_fn_data", &tmp, 1);
}
else if (net_fn == IPMI_NET_FN_OEM_GROUP_RQ
|| net_fn == IPMI_NET_FN_OEM_GROUP_RS)
FILL_FIID_OBJ_SET (obj_cmd_rq, "net_fn_data", net_fn_data);
return (0);
}
int
driver_mutex_unlock (int semid)
{
/* achu: don't check for valid semid - responsibility of calling libs */
if (semop (semid, &mutex_unlock_buf, 1) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
/* If you are in a loop to go grab LOCK again, Other tasks will
never get a chance until you break. Give fair chance to other
tasks as well. This is probably because of scheduler
optimizations in Linux kernel. --Anand Babu
*/
usleep (1);
return (0);
}
int
fill_cmd_get_sel_allocation_info (fiid_obj_t obj_cmd_rq)
{
if (!fiid_obj_valid (obj_cmd_rq))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rq, tmpl_cmd_get_sel_allocation_info_rq) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
FILL_FIID_OBJ_CLEAR (obj_cmd_rq);
FILL_FIID_OBJ_SET (obj_cmd_rq, "cmd", IPMI_CMD_GET_SEL_ALLOCATION_INFO);
return (0);
}
int
fill_cmd_reserve_sel (fiid_obj_t obj_cmd_rq)
{
if (!fiid_obj_valid (obj_cmd_rq))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rq, tmpl_cmd_reserve_sel_rq) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
FILL_FIID_OBJ_CLEAR (obj_cmd_rq);
FILL_FIID_OBJ_SET (obj_cmd_rq, "cmd", IPMI_CMD_RESERVE_SEL);
return (0);
}
int
fill_cmd_get_repository_info (fiid_obj_t obj_cmd_rq)
{
if (!fiid_obj_valid (obj_cmd_rq))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rq, tmpl_cmd_get_sdr_repository_info_rq) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
FILL_FIID_OBJ_CLEAR (obj_cmd_rq);
FILL_FIID_OBJ_SET (obj_cmd_rq, "cmd", IPMI_CMD_GET_SDR_REPOSITORY_INFO);
return (0);
}
int
fill_cmd_set_command_sub_function_enables_oem_iana (uint8_t channel_number,
uint8_t net_fn,
uint8_t lun,
uint8_t command,
uint32_t oem_iana,
uint32_t sub_function_enables1,
uint32_t *sub_function_enables2,
fiid_obj_t obj_cmd_rq)
{
if (!IPMI_CHANNEL_NUMBER_VALID (channel_number)
|| (net_fn != IPMI_NET_FN_OEM_GROUP_RQ
&& net_fn != IPMI_NET_FN_OEM_GROUP_RS)
|| !IPMI_BMC_LUN_VALID (lun)
|| !fiid_obj_valid (obj_cmd_rq))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rq, tmpl_cmd_set_command_sub_function_enables_rq) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
FILL_FIID_OBJ_CLEAR (obj_cmd_rq);
FILL_FIID_OBJ_SET (obj_cmd_rq, "cmd", IPMI_CMD_SET_COMMAND_SUB_FUNCTION_ENABLES);
FILL_FIID_OBJ_SET (obj_cmd_rq, "channel_number", channel_number);
FILL_FIID_OBJ_SET (obj_cmd_rq, "reserved1", 0);
FILL_FIID_OBJ_SET (obj_cmd_rq, "net_fn", net_fn);
FILL_FIID_OBJ_SET (obj_cmd_rq, "reserved2", 0);
FILL_FIID_OBJ_SET (obj_cmd_rq, "lun", lun);
FILL_FIID_OBJ_SET (obj_cmd_rq, "reserved3", 0);
FILL_FIID_OBJ_SET (obj_cmd_rq, "command", command);
FILL_FIID_OBJ_SET (obj_cmd_rq, "oem_iana", oem_iana);
FILL_FIID_OBJ_SET (obj_cmd_rq, "sub_function_enables1", sub_function_enables1);
if (sub_function_enables2)
FILL_FIID_OBJ_SET (obj_cmd_rq, "sub_function_enables2", *sub_function_enables2);
return (0);
}
ipmi_openipmi_ctx_t
ipmi_openipmi_ctx_create (void)
{
ipmi_openipmi_ctx_t ctx = NULL;
if (!(ctx = (ipmi_openipmi_ctx_t)malloc (sizeof (struct ipmi_openipmi_ctx))))
{
ERRNO_TRACE (errno);
return (NULL);
}
ctx->magic = IPMI_OPENIPMI_CTX_MAGIC;
ctx->flags = IPMI_OPENIPMI_FLAGS_DEFAULT;
ctx->driver_device = NULL;
ctx->device_fd = -1;
ctx->io_init = 0;
ctx->errnum = IPMI_OPENIPMI_ERR_SUCCESS;
return (ctx);
}
int
fill_cmd_get_sel_time_utc_offset (fiid_obj_t obj_cmd_rq)
{
if (!fiid_obj_valid (obj_cmd_rq))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rq, tmpl_cmd_get_sel_time_utc_offset_rq) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
FILL_FIID_OBJ_CLEAR (obj_cmd_rq);
FILL_FIID_OBJ_SET (obj_cmd_rq, "cmd", IPMI_CMD_GET_SEL_TIME_UTC_OFFSET);
return (0);
}
int
fill_cmd_set_sel_time (uint32_t time, fiid_obj_t obj_cmd_rq)
{
if (!fiid_obj_valid (obj_cmd_rq))
{
SET_ERRNO (EINVAL);
return (-1);
}
if (FIID_OBJ_TEMPLATE_COMPARE (obj_cmd_rq, tmpl_cmd_set_sel_time_rq) < 0)
{
ERRNO_TRACE (errno);
return (-1);
}
FILL_FIID_OBJ_CLEAR (obj_cmd_rq);
FILL_FIID_OBJ_SET (obj_cmd_rq, "cmd", IPMI_CMD_SET_SEL_TIME);
FILL_FIID_OBJ_SET (obj_cmd_rq, "time", time);
return (0);
}
