static struct visorchannel *controlvm_channel;
-struct controlvm_payload_info {
+/* Manages the request payload in the controlvm channel */
+static struct controlvm_payload_info {
u8 __iomem *ptr; /* pointer to base address of payload pool */
u64 offset; /* offset from beginning of controlvm
* channel to beginning of payload * pool */
u32 bytes; /* number of bytes in payload pool */
-};
-
-/* Manages the request payload in the controlvm channel */
-static struct controlvm_payload_info ControlVm_payload_info;
+} controlvm_payload_info;
-struct livedump_info {
- struct controlvm_message_header Dumpcapture_header;
- struct controlvm_message_header Gettextdump_header;
- struct controlvm_message_header Dumpcomplete_header;
- BOOL Gettextdump_outstanding;
+/* Manages the info for a CONTROLVM_DUMP_CAPTURESTATE /
+ * CONTROLVM_DUMP_GETTEXTDUMP / CONTROLVM_DUMP_COMPLETE conversation.
+ */
+static struct livedump_info {
+ struct controlvm_message_header dumpcapture_header;
+ struct controlvm_message_header gettextdump_header;
+ struct controlvm_message_header dumpcomplete_header;
+ BOOL gettextdump_outstanding;
u32 crc32;
ulong length;
atomic_t buffers_in_use;
ulong destination;
-};
-/* Manages the info for a CONTROLVM_DUMP_CAPTURESTATE /
- * CONTROLVM_DUMP_GETTEXTDUMP / CONTROLVM_DUMP_COMPLETE conversation.
- */
-static struct livedump_info LiveDump_info;
+} livedump_info;
/* The following globals are used to handle the scenario where we are unable to
* offload the payload from a controlvm message due to memory requirements. In
return count;
}
-
static ssize_t remaining_steps_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
return count;
}
-#if 0
static void
-testUnicode(void)
-{
- wchar_t unicodeString[] = { 'a', 'b', 'c', 0 };
- char s[sizeof(unicodeString) * NLS_MAX_CHARSET_SIZE];
- wchar_t unicode2[99];
-
- /* NOTE: Either due to a bug, or feature I don't understand, the
- * kernel utf8_mbstowcs() and utf_wcstombs() do NOT copy the
- * trailed NUL byte!! REALLY!!!!! Arrrrgggghhhhh
- */
-
- LOGINF("sizeof(wchar_t) = %d", sizeof(wchar_t));
- LOGINF("utf8_wcstombs=%d",
- chrs = utf8_wcstombs(s, unicodeString, sizeof(s)));
- if (chrs >= 0)
- s[chrs] = '\0'; /* GRRRRRRRR */
- LOGINF("s='%s'", s);
- LOGINF("utf8_mbstowcs=%d", chrs = utf8_mbstowcs(unicode2, s, 100));
- if (chrs >= 0)
- unicode2[chrs] = 0; /* GRRRRRRRR */
- if (memcmp(unicodeString, unicode2, sizeof(unicodeString)) == 0)
- LOGINF("strings match... good");
- else
- LOGINF("strings did not match!!");
-}
-#endif
-
-static void
-busInfo_clear(void *v)
+bus_info_clear(void *v)
{
struct visorchipset_bus_info *p = (struct visorchipset_bus_info *) (v);
- if (p->proc_object) {
- visor_proc_DestroyObject(p->proc_object);
- p->proc_object = NULL;
- }
kfree(p->name);
p->name = NULL;
}
static void
-devInfo_clear(void *v)
+dev_info_clear(void *v)
{
struct visorchipset_device_info *p =
(struct visorchipset_device_info *)(v);
struct ultra_vbus_deviceinfo *driver_info)
{
down(¬ifier_lock);
- if (notifiers == NULL) {
+ if (!notifiers) {
memset(&BusDev_Server_Notifiers, 0,
sizeof(BusDev_Server_Notifiers));
serverregistered = 0; /* clear flag */
struct ultra_vbus_deviceinfo *driver_info)
{
down(¬ifier_lock);
- if (notifiers == NULL) {
+ if (!notifiers) {
memset(&BusDev_Client_Notifiers, 0,
sizeof(BusDev_Client_Notifiers));
clientregistered = 0; /* clear flag */
struct visorchipset_device_info *di, *tmp_di;
list_for_each_entry_safe(bi, tmp_bi, &bus_info_list, entry) {
- busInfo_clear(bi);
+ bus_info_clear(bi);
list_del(&bi->entry);
kfree(bi);
}
list_for_each_entry_safe(di, tmp_di, &dev_info_list, entry) {
- devInfo_clear(di);
+ dev_info_clear(di);
list_del(&di->entry);
kfree(di);
}
POSTCODE_LINUX_2(CHIPSET_INIT_ENTRY_PC, POSTCODE_SEVERITY_INFO);
if (chipset_inited) {
rc = -CONTROLVM_RESP_ERROR_ALREADY_DONE;
- goto Away;
+ goto cleanup;
}
chipset_inited = 1;
POSTCODE_LINUX_2(CHIPSET_INIT_EXIT_PC, POSTCODE_SEVERITY_INFO);
* features-aware driver. */
features |= ULTRA_CHIPSET_FEATURE_REPLY;
-Away:
+cleanup:
if (rc < 0)
cleanup_controlvm_structures();
if (inmsg->hdr.flags.response_expected)
visorchipset_save_message(struct controlvm_message *msg,
enum crash_obj_type type)
{
- u32 localSavedCrashMsgOffset;
- u16 localSavedCrashMsgCount;
+ u32 crash_msg_offset;
+ u16 crash_msg_count;
/* get saved message count */
if (visorchannel_read(controlvm_channel,
offsetof(struct spar_controlvm_channel_protocol,
saved_crash_message_count),
- &localSavedCrashMsgCount, sizeof(u16)) < 0) {
+ &crash_msg_count, sizeof(u16)) < 0) {
POSTCODE_LINUX_2(CRASH_DEV_CTRL_RD_FAILURE_PC,
POSTCODE_SEVERITY_ERR);
return;
}
- if (localSavedCrashMsgCount != CONTROLVM_CRASHMSG_MAX) {
+ if (crash_msg_count != CONTROLVM_CRASHMSG_MAX) {
POSTCODE_LINUX_3(CRASH_DEV_COUNT_FAILURE_PC,
- localSavedCrashMsgCount,
+ crash_msg_count,
POSTCODE_SEVERITY_ERR);
return;
}
if (visorchannel_read(controlvm_channel,
offsetof(struct spar_controlvm_channel_protocol,
saved_crash_message_offset),
- &localSavedCrashMsgOffset, sizeof(u32)) < 0) {
+ &crash_msg_offset, sizeof(u32)) < 0) {
POSTCODE_LINUX_2(CRASH_DEV_CTRL_RD_FAILURE_PC,
POSTCODE_SEVERITY_ERR);
return;
if (type == CRASH_BUS) {
if (visorchannel_write(controlvm_channel,
- localSavedCrashMsgOffset,
+ crash_msg_offset,
msg,
sizeof(struct controlvm_message)) < 0) {
POSTCODE_LINUX_2(SAVE_MSG_BUS_FAILURE_PC,
}
} else {
if (visorchannel_write(controlvm_channel,
- localSavedCrashMsgOffset +
+ crash_msg_offset +
sizeof(struct controlvm_message), msg,
sizeof(struct controlvm_message)) < 0) {
POSTCODE_LINUX_2(SAVE_MSG_DEV_FAILURE_PC,
EXPORT_SYMBOL_GPL(visorchipset_save_message);
static void
-bus_responder(enum controlvm_id cmdId, ulong busNo, int response)
+bus_responder(enum controlvm_id cmd_id, ulong bus_no, int response)
{
struct visorchipset_bus_info *p = NULL;
BOOL need_clear = FALSE;
- p = findbus(&bus_info_list, busNo);
+ p = findbus(&bus_info_list, bus_no);
if (!p)
return;
if (response < 0) {
- if ((cmdId == CONTROLVM_BUS_CREATE) &&
+ if ((cmd_id == CONTROLVM_BUS_CREATE) &&
(response != (-CONTROLVM_RESP_ERROR_ALREADY_DONE)))
/* undo the row we just created... */
- delbusdevices(&dev_info_list, busNo);
+ delbusdevices(&dev_info_list, bus_no);
} else {
- if (cmdId == CONTROLVM_BUS_CREATE)
+ if (cmd_id == CONTROLVM_BUS_CREATE)
p->state.created = 1;
- if (cmdId == CONTROLVM_BUS_DESTROY)
+ if (cmd_id == CONTROLVM_BUS_DESTROY)
need_clear = TRUE;
}
if (p->pending_msg_hdr.id == CONTROLVM_INVALID)
return; /* no controlvm response needed */
- if (p->pending_msg_hdr.id != (u32) cmdId)
+ if (p->pending_msg_hdr.id != (u32)cmd_id)
return;
controlvm_respond(&p->pending_msg_hdr, response);
p->pending_msg_hdr.id = CONTROLVM_INVALID;
if (need_clear) {
- busInfo_clear(p);
- delbusdevices(&dev_info_list, busNo);
+ bus_info_clear(p);
+ delbusdevices(&dev_info_list, bus_no);
}
}
static void
-device_changestate_responder(enum controlvm_id cmdId,
- ulong busNo, ulong devNo, int response,
- struct spar_segment_state responseState)
+device_changestate_responder(enum controlvm_id cmd_id,
+ ulong bus_no, ulong dev_no, int response,
+ struct spar_segment_state response_state)
{
struct visorchipset_device_info *p = NULL;
struct controlvm_message outmsg;
- p = finddevice(&dev_info_list, busNo, devNo);
+ p = finddevice(&dev_info_list, bus_no, dev_no);
if (!p)
return;
if (p->pending_msg_hdr.id == CONTROLVM_INVALID)
return; /* no controlvm response needed */
- if (p->pending_msg_hdr.id != cmdId)
+ if (p->pending_msg_hdr.id != cmd_id)
return;
controlvm_init_response(&outmsg, &p->pending_msg_hdr, response);
- outmsg.cmd.device_change_state.bus_no = busNo;
- outmsg.cmd.device_change_state.dev_no = devNo;
- outmsg.cmd.device_change_state.state = responseState;
+ outmsg.cmd.device_change_state.bus_no = bus_no;
+ outmsg.cmd.device_change_state.dev_no = dev_no;
+ outmsg.cmd.device_change_state.state = response_state;
if (!visorchannel_signalinsert(controlvm_channel,
CONTROLVM_QUEUE_REQUEST, &outmsg))
}
static void
-device_responder(enum controlvm_id cmdId, ulong busNo, ulong devNo,
+device_responder(enum controlvm_id cmd_id, ulong bus_no, ulong dev_no,
int response)
{
struct visorchipset_device_info *p = NULL;
BOOL need_clear = FALSE;
- p = finddevice(&dev_info_list, busNo, devNo);
+ p = finddevice(&dev_info_list, bus_no, dev_no);
if (!p)
return;
if (response >= 0) {
- if (cmdId == CONTROLVM_DEVICE_CREATE)
+ if (cmd_id == CONTROLVM_DEVICE_CREATE)
p->state.created = 1;
- if (cmdId == CONTROLVM_DEVICE_DESTROY)
+ if (cmd_id == CONTROLVM_DEVICE_DESTROY)
need_clear = TRUE;
}
if (p->pending_msg_hdr.id == CONTROLVM_INVALID)
return; /* no controlvm response needed */
- if (p->pending_msg_hdr.id != (u32) cmdId)
+ if (p->pending_msg_hdr.id != (u32)cmd_id)
return;
controlvm_respond(&p->pending_msg_hdr, response);
p->pending_msg_hdr.id = CONTROLVM_INVALID;
if (need_clear)
- devInfo_clear(p);
+ dev_info_clear(p);
}
static void
-bus_epilog(u32 busNo,
- u32 cmd, struct controlvm_message_header *msgHdr,
- int response, BOOL needResponse)
+bus_epilog(u32 bus_no,
+ u32 cmd, struct controlvm_message_header *msg_hdr,
+ int response, BOOL need_response)
{
BOOL notified = FALSE;
- struct visorchipset_bus_info *pBusInfo = findbus(&bus_info_list, busNo);
+ struct visorchipset_bus_info *bus_info = findbus(&bus_info_list,
+ bus_no);
- if (!pBusInfo)
+ if (!bus_info)
return;
- if (needResponse) {
- memcpy(&pBusInfo->pending_msg_hdr, msgHdr,
+ if (need_response) {
+ memcpy(&bus_info->pending_msg_hdr, msg_hdr,
sizeof(struct controlvm_message_header));
- } else
- pBusInfo->pending_msg_hdr.id = CONTROLVM_INVALID;
+ } else {
+ bus_info->pending_msg_hdr.id = CONTROLVM_INVALID;
+ }
down(¬ifier_lock);
if (response == CONTROLVM_RESP_SUCCESS) {
* - BusDev_Client can handle ONLY client
* devices */
if (BusDev_Server_Notifiers.bus_create) {
- (*BusDev_Server_Notifiers.bus_create) (busNo);
+ (*BusDev_Server_Notifiers.bus_create) (bus_no);
notified = TRUE;
}
- if ((!pBusInfo->flags.server) /*client */ &&
+ if ((!bus_info->flags.server) /*client */ &&
BusDev_Client_Notifiers.bus_create) {
- (*BusDev_Client_Notifiers.bus_create) (busNo);
+ (*BusDev_Client_Notifiers.bus_create) (bus_no);
notified = TRUE;
}
break;
case CONTROLVM_BUS_DESTROY:
if (BusDev_Server_Notifiers.bus_destroy) {
- (*BusDev_Server_Notifiers.bus_destroy) (busNo);
+ (*BusDev_Server_Notifiers.bus_destroy) (bus_no);
notified = TRUE;
}
- if ((!pBusInfo->flags.server) /*client */ &&
+ if ((!bus_info->flags.server) /*client */ &&
BusDev_Client_Notifiers.bus_destroy) {
- (*BusDev_Client_Notifiers.bus_destroy) (busNo);
+ (*BusDev_Client_Notifiers.bus_destroy) (bus_no);
notified = TRUE;
}
break;
*/
;
else
- bus_responder(cmd, busNo, response);
+ bus_responder(cmd, bus_no, response);
up(¬ifier_lock);
}
static void
-device_epilog(u32 busNo, u32 devNo, struct spar_segment_state state, u32 cmd,
- struct controlvm_message_header *msgHdr, int response,
- BOOL needResponse, BOOL for_visorbus)
+device_epilog(u32 bus_no, u32 dev_no, struct spar_segment_state state, u32 cmd,
+ struct controlvm_message_header *msg_hdr, int response,
+ BOOL need_response, BOOL for_visorbus)
{
struct visorchipset_busdev_notifiers *notifiers = NULL;
BOOL notified = FALSE;
- struct visorchipset_device_info *pDevInfo =
- finddevice(&dev_info_list, busNo, devNo);
+ struct visorchipset_device_info *dev_info =
+ finddevice(&dev_info_list, bus_no, dev_no);
char *envp[] = {
"SPARSP_DIAGPOOL_PAUSED_STATE = 1",
NULL
};
- if (!pDevInfo)
+ if (!dev_info)
return;
if (for_visorbus)
notifiers = &BusDev_Server_Notifiers;
else
notifiers = &BusDev_Client_Notifiers;
- if (needResponse) {
- memcpy(&pDevInfo->pending_msg_hdr, msgHdr,
+ if (need_response) {
+ memcpy(&dev_info->pending_msg_hdr, msg_hdr,
sizeof(struct controlvm_message_header));
- } else
- pDevInfo->pending_msg_hdr.id = CONTROLVM_INVALID;
+ } else {
+ dev_info->pending_msg_hdr.id = CONTROLVM_INVALID;
+ }
down(¬ifier_lock);
if (response >= 0) {
switch (cmd) {
case CONTROLVM_DEVICE_CREATE:
if (notifiers->device_create) {
- (*notifiers->device_create) (busNo, devNo);
+ (*notifiers->device_create) (bus_no, dev_no);
notified = TRUE;
}
break;
state.operating ==
segment_state_running.operating) {
if (notifiers->device_resume) {
- (*notifiers->device_resume) (busNo,
- devNo);
+ (*notifiers->device_resume) (bus_no,
+ dev_no);
notified = TRUE;
}
}
* where server is lost
*/
if (notifiers->device_pause) {
- (*notifiers->device_pause) (busNo,
- devNo);
+ (*notifiers->device_pause) (bus_no,
+ dev_no);
notified = TRUE;
}
} else if (state.alive == segment_state_paused.alive &&
/* this is lite pause where channel is
* still valid just 'pause' of it
*/
- if (busNo == g_diagpool_bus_no &&
- devNo == g_diagpool_dev_no) {
+ if (bus_no == g_diagpool_bus_no &&
+ dev_no == g_diagpool_dev_no) {
/* this will trigger the
* diag_shutdown.sh script in
* the visorchipset hotplug */
break;
case CONTROLVM_DEVICE_DESTROY:
if (notifiers->device_destroy) {
- (*notifiers->device_destroy) (busNo, devNo);
+ (*notifiers->device_destroy) (bus_no, dev_no);
notified = TRUE;
}
break;
*/
;
else
- device_responder(cmd, busNo, devNo, response);
+ device_responder(cmd, bus_no, dev_no, response);
up(¬ifier_lock);
}
bus_create(struct controlvm_message *inmsg)
{
struct controlvm_message_packet *cmd = &inmsg->cmd;
- ulong busNo = cmd->create_bus.bus_no;
+ ulong bus_no = cmd->create_bus.bus_no;
int rc = CONTROLVM_RESP_SUCCESS;
- struct visorchipset_bus_info *pBusInfo = NULL;
+ struct visorchipset_bus_info *bus_info = NULL;
-
- pBusInfo = findbus(&bus_info_list, busNo);
- if (pBusInfo && (pBusInfo->state.created == 1)) {
- POSTCODE_LINUX_3(BUS_CREATE_FAILURE_PC, busNo,
+ bus_info = findbus(&bus_info_list, bus_no);
+ if (bus_info && (bus_info->state.created == 1)) {
+ POSTCODE_LINUX_3(BUS_CREATE_FAILURE_PC, bus_no,
POSTCODE_SEVERITY_ERR);
rc = -CONTROLVM_RESP_ERROR_ALREADY_DONE;
- goto Away;
+ goto cleanup;
}
- pBusInfo = kzalloc(sizeof(struct visorchipset_bus_info), GFP_KERNEL);
- if (pBusInfo == NULL) {
- POSTCODE_LINUX_3(BUS_CREATE_FAILURE_PC, busNo,
+ bus_info = kzalloc(sizeof(*bus_info), GFP_KERNEL);
+ if (!bus_info) {
+ POSTCODE_LINUX_3(BUS_CREATE_FAILURE_PC, bus_no,
POSTCODE_SEVERITY_ERR);
rc = -CONTROLVM_RESP_ERROR_KMALLOC_FAILED;
- goto Away;
+ goto cleanup;
}
- INIT_LIST_HEAD(&pBusInfo->entry);
- pBusInfo->bus_no = busNo;
- pBusInfo->dev_no = cmd->create_bus.dev_count;
+ INIT_LIST_HEAD(&bus_info->entry);
+ bus_info->bus_no = bus_no;
+ bus_info->dev_no = cmd->create_bus.dev_count;
- POSTCODE_LINUX_3(BUS_CREATE_ENTRY_PC, busNo, POSTCODE_SEVERITY_INFO);
+ POSTCODE_LINUX_3(BUS_CREATE_ENTRY_PC, bus_no, POSTCODE_SEVERITY_INFO);
if (inmsg->hdr.flags.test_message == 1)
- pBusInfo->chan_info.addr_type = ADDRTYPE_LOCALTEST;
+ bus_info->chan_info.addr_type = ADDRTYPE_LOCALTEST;
else
- pBusInfo->chan_info.addr_type = ADDRTYPE_LOCALPHYSICAL;
+ bus_info->chan_info.addr_type = ADDRTYPE_LOCALPHYSICAL;
- pBusInfo->flags.server = inmsg->hdr.flags.server;
- pBusInfo->chan_info.channel_addr = cmd->create_bus.channel_addr;
- pBusInfo->chan_info.n_channel_bytes = cmd->create_bus.channel_bytes;
- pBusInfo->chan_info.channel_type_uuid =
+ bus_info->flags.server = inmsg->hdr.flags.server;
+ bus_info->chan_info.channel_addr = cmd->create_bus.channel_addr;
+ bus_info->chan_info.n_channel_bytes = cmd->create_bus.channel_bytes;
+ bus_info->chan_info.channel_type_uuid =
cmd->create_bus.bus_data_type_uuid;
- pBusInfo->chan_info.channel_inst_uuid = cmd->create_bus.bus_inst_uuid;
+ bus_info->chan_info.channel_inst_uuid = cmd->create_bus.bus_inst_uuid;
- list_add(&pBusInfo->entry, &bus_info_list);
+ list_add(&bus_info->entry, &bus_info_list);
- POSTCODE_LINUX_3(BUS_CREATE_EXIT_PC, busNo, POSTCODE_SEVERITY_INFO);
+ POSTCODE_LINUX_3(BUS_CREATE_EXIT_PC, bus_no, POSTCODE_SEVERITY_INFO);
-Away:
- bus_epilog(busNo, CONTROLVM_BUS_CREATE, &inmsg->hdr,
+cleanup:
+ bus_epilog(bus_no, CONTROLVM_BUS_CREATE, &inmsg->hdr,
rc, inmsg->hdr.flags.response_expected == 1);
}
bus_destroy(struct controlvm_message *inmsg)
{
struct controlvm_message_packet *cmd = &inmsg->cmd;
- ulong busNo = cmd->destroy_bus.bus_no;
- struct visorchipset_bus_info *pBusInfo;
+ ulong bus_no = cmd->destroy_bus.bus_no;
+ struct visorchipset_bus_info *bus_info;
int rc = CONTROLVM_RESP_SUCCESS;
- pBusInfo = findbus(&bus_info_list, busNo);
- if (!pBusInfo) {
+ bus_info = findbus(&bus_info_list, bus_no);
+ if (!bus_info)
rc = -CONTROLVM_RESP_ERROR_BUS_INVALID;
- goto Away;
- }
- if (pBusInfo->state.created == 0) {
+ else if (bus_info->state.created == 0)
rc = -CONTROLVM_RESP_ERROR_ALREADY_DONE;
- goto Away;
- }
-Away:
- bus_epilog(busNo, CONTROLVM_BUS_DESTROY, &inmsg->hdr,
+ bus_epilog(bus_no, CONTROLVM_BUS_DESTROY, &inmsg->hdr,
rc, inmsg->hdr.flags.response_expected == 1);
}
struct parser_context *parser_ctx)
{
struct controlvm_message_packet *cmd = &inmsg->cmd;
- ulong busNo = cmd->configure_bus.bus_no;
- struct visorchipset_bus_info *pBusInfo = NULL;
+ ulong bus_no = cmd->configure_bus.bus_no;
+ struct visorchipset_bus_info *bus_info = NULL;
int rc = CONTROLVM_RESP_SUCCESS;
char s[99];
- busNo = cmd->configure_bus.bus_no;
- POSTCODE_LINUX_3(BUS_CONFIGURE_ENTRY_PC, busNo, POSTCODE_SEVERITY_INFO);
+ bus_no = cmd->configure_bus.bus_no;
+ POSTCODE_LINUX_3(BUS_CONFIGURE_ENTRY_PC, bus_no,
+ POSTCODE_SEVERITY_INFO);
- pBusInfo = findbus(&bus_info_list, busNo);
- if (!pBusInfo) {
- POSTCODE_LINUX_3(BUS_CONFIGURE_FAILURE_PC, busNo,
+ bus_info = findbus(&bus_info_list, bus_no);
+ if (!bus_info) {
+ POSTCODE_LINUX_3(BUS_CONFIGURE_FAILURE_PC, bus_no,
POSTCODE_SEVERITY_ERR);
rc = -CONTROLVM_RESP_ERROR_BUS_INVALID;
- goto Away;
- }
- if (pBusInfo->state.created == 0) {
- POSTCODE_LINUX_3(BUS_CONFIGURE_FAILURE_PC, busNo,
+ } else if (bus_info->state.created == 0) {
+ POSTCODE_LINUX_3(BUS_CONFIGURE_FAILURE_PC, bus_no,
POSTCODE_SEVERITY_ERR);
rc = -CONTROLVM_RESP_ERROR_BUS_INVALID;
- goto Away;
- }
- /* TBD - add this check to other commands also... */
- if (pBusInfo->pending_msg_hdr.id != CONTROLVM_INVALID) {
- POSTCODE_LINUX_3(BUS_CONFIGURE_FAILURE_PC, busNo,
+ } else if (bus_info->pending_msg_hdr.id != CONTROLVM_INVALID) {
+ POSTCODE_LINUX_3(BUS_CONFIGURE_FAILURE_PC, bus_no,
POSTCODE_SEVERITY_ERR);
rc = -CONTROLVM_RESP_ERROR_MESSAGE_ID_INVALID_FOR_CLIENT;
- goto Away;
- }
-
- pBusInfo->partition_handle = cmd->configure_bus.guest_handle;
- pBusInfo->partition_uuid = parser_id_get(parser_ctx);
- parser_param_start(parser_ctx, PARSERSTRING_NAME);
- pBusInfo->name = parser_string_get(parser_ctx);
+ } else {
+ bus_info->partition_handle = cmd->configure_bus.guest_handle;
+ bus_info->partition_uuid = parser_id_get(parser_ctx);
+ parser_param_start(parser_ctx, PARSERSTRING_NAME);
+ bus_info->name = parser_string_get(parser_ctx);
- visorchannel_uuid_id(&pBusInfo->partition_uuid, s);
- POSTCODE_LINUX_3(BUS_CONFIGURE_EXIT_PC, busNo, POSTCODE_SEVERITY_INFO);
-Away:
- bus_epilog(busNo, CONTROLVM_BUS_CONFIGURE, &inmsg->hdr,
+ visorchannel_uuid_id(&bus_info->partition_uuid, s);
+ POSTCODE_LINUX_3(BUS_CONFIGURE_EXIT_PC, bus_no,
+ POSTCODE_SEVERITY_INFO);
+ }
+ bus_epilog(bus_no, CONTROLVM_BUS_CONFIGURE, &inmsg->hdr,
rc, inmsg->hdr.flags.response_expected == 1);
}
my_device_create(struct controlvm_message *inmsg)
{
struct controlvm_message_packet *cmd = &inmsg->cmd;
- ulong busNo = cmd->create_device.bus_no;
- ulong devNo = cmd->create_device.dev_no;
- struct visorchipset_device_info *pDevInfo = NULL;
- struct visorchipset_bus_info *pBusInfo = NULL;
+ ulong bus_no = cmd->create_device.bus_no;
+ ulong dev_no = cmd->create_device.dev_no;
+ struct visorchipset_device_info *dev_info = NULL;
+ struct visorchipset_bus_info *bus_info = NULL;
int rc = CONTROLVM_RESP_SUCCESS;
- pDevInfo = finddevice(&dev_info_list, busNo, devNo);
- if (pDevInfo && (pDevInfo->state.created == 1)) {
- POSTCODE_LINUX_4(DEVICE_CREATE_FAILURE_PC, devNo, busNo,
+ dev_info = finddevice(&dev_info_list, bus_no, dev_no);
+ if (dev_info && (dev_info->state.created == 1)) {
+ POSTCODE_LINUX_4(DEVICE_CREATE_FAILURE_PC, dev_no, bus_no,
POSTCODE_SEVERITY_ERR);
rc = -CONTROLVM_RESP_ERROR_ALREADY_DONE;
- goto Away;
+ goto cleanup;
}
- pBusInfo = findbus(&bus_info_list, busNo);
- if (!pBusInfo) {
- POSTCODE_LINUX_4(DEVICE_CREATE_FAILURE_PC, devNo, busNo,
+ bus_info = findbus(&bus_info_list, bus_no);
+ if (!bus_info) {
+ POSTCODE_LINUX_4(DEVICE_CREATE_FAILURE_PC, dev_no, bus_no,
POSTCODE_SEVERITY_ERR);
rc = -CONTROLVM_RESP_ERROR_BUS_INVALID;
- goto Away;
+ goto cleanup;
}
- if (pBusInfo->state.created == 0) {
- POSTCODE_LINUX_4(DEVICE_CREATE_FAILURE_PC, devNo, busNo,
+ if (bus_info->state.created == 0) {
+ POSTCODE_LINUX_4(DEVICE_CREATE_FAILURE_PC, dev_no, bus_no,
POSTCODE_SEVERITY_ERR);
rc = -CONTROLVM_RESP_ERROR_BUS_INVALID;
- goto Away;
+ goto cleanup;
}
- pDevInfo = kzalloc(sizeof(struct visorchipset_device_info), GFP_KERNEL);
- if (pDevInfo == NULL) {
- POSTCODE_LINUX_4(DEVICE_CREATE_FAILURE_PC, devNo, busNo,
+ dev_info = kzalloc(sizeof(*dev_info), GFP_KERNEL);
+ if (!dev_info) {
+ POSTCODE_LINUX_4(DEVICE_CREATE_FAILURE_PC, dev_no, bus_no,
POSTCODE_SEVERITY_ERR);
rc = -CONTROLVM_RESP_ERROR_KMALLOC_FAILED;
- goto Away;
+ goto cleanup;
}
- INIT_LIST_HEAD(&pDevInfo->entry);
- pDevInfo->bus_no = busNo;
- pDevInfo->dev_no = devNo;
- pDevInfo->dev_inst_uuid = cmd->create_device.dev_inst_uuid;
- POSTCODE_LINUX_4(DEVICE_CREATE_ENTRY_PC, devNo, busNo,
+ INIT_LIST_HEAD(&dev_info->entry);
+ dev_info->bus_no = bus_no;
+ dev_info->dev_no = dev_no;
+ dev_info->dev_inst_uuid = cmd->create_device.dev_inst_uuid;
+ POSTCODE_LINUX_4(DEVICE_CREATE_ENTRY_PC, dev_no, bus_no,
POSTCODE_SEVERITY_INFO);
if (inmsg->hdr.flags.test_message == 1)
- pDevInfo->chan_info.addr_type = ADDRTYPE_LOCALTEST;
+ dev_info->chan_info.addr_type = ADDRTYPE_LOCALTEST;
else
- pDevInfo->chan_info.addr_type = ADDRTYPE_LOCALPHYSICAL;
- pDevInfo->chan_info.channel_addr = cmd->create_device.channel_addr;
- pDevInfo->chan_info.n_channel_bytes = cmd->create_device.channel_bytes;
- pDevInfo->chan_info.channel_type_uuid =
+ dev_info->chan_info.addr_type = ADDRTYPE_LOCALPHYSICAL;
+ dev_info->chan_info.channel_addr = cmd->create_device.channel_addr;
+ dev_info->chan_info.n_channel_bytes = cmd->create_device.channel_bytes;
+ dev_info->chan_info.channel_type_uuid =
cmd->create_device.data_type_uuid;
- pDevInfo->chan_info.intr = cmd->create_device.intr;
- list_add(&pDevInfo->entry, &dev_info_list);
- POSTCODE_LINUX_4(DEVICE_CREATE_EXIT_PC, devNo, busNo,
+ dev_info->chan_info.intr = cmd->create_device.intr;
+ list_add(&dev_info->entry, &dev_info_list);
+ POSTCODE_LINUX_4(DEVICE_CREATE_EXIT_PC, dev_no, bus_no,
POSTCODE_SEVERITY_INFO);
-Away:
+cleanup:
/* get the bus and devNo for DiagPool channel */
- if (pDevInfo &&
- is_diagpool_channel(pDevInfo->chan_info.channel_type_uuid)) {
- g_diagpool_bus_no = busNo;
- g_diagpool_dev_no = devNo;
+ if (dev_info &&
+ is_diagpool_channel(dev_info->chan_info.channel_type_uuid)) {
+ g_diagpool_bus_no = bus_no;
+ g_diagpool_dev_no = dev_no;
}
- device_epilog(busNo, devNo, segment_state_running,
+ device_epilog(bus_no, dev_no, segment_state_running,
CONTROLVM_DEVICE_CREATE, &inmsg->hdr, rc,
inmsg->hdr.flags.response_expected == 1,
- FOR_VISORBUS(pDevInfo->chan_info.channel_type_uuid));
+ FOR_VISORBUS(dev_info->chan_info.channel_type_uuid));
}
static void
my_device_changestate(struct controlvm_message *inmsg)
{
struct controlvm_message_packet *cmd = &inmsg->cmd;
- ulong busNo = cmd->device_change_state.bus_no;
- ulong devNo = cmd->device_change_state.dev_no;
+ ulong bus_no = cmd->device_change_state.bus_no;
+ ulong dev_no = cmd->device_change_state.dev_no;
struct spar_segment_state state = cmd->device_change_state.state;
- struct visorchipset_device_info *pDevInfo = NULL;
+ struct visorchipset_device_info *dev_info = NULL;
int rc = CONTROLVM_RESP_SUCCESS;
- pDevInfo = finddevice(&dev_info_list, busNo, devNo);
- if (!pDevInfo) {
- POSTCODE_LINUX_4(DEVICE_CHANGESTATE_FAILURE_PC, devNo, busNo,
+ dev_info = finddevice(&dev_info_list, bus_no, dev_no);
+ if (!dev_info) {
+ POSTCODE_LINUX_4(DEVICE_CHANGESTATE_FAILURE_PC, dev_no, bus_no,
POSTCODE_SEVERITY_ERR);
rc = -CONTROLVM_RESP_ERROR_DEVICE_INVALID;
- goto Away;
- }
- if (pDevInfo->state.created == 0) {
- POSTCODE_LINUX_4(DEVICE_CHANGESTATE_FAILURE_PC, devNo, busNo,
+ } else if (dev_info->state.created == 0) {
+ POSTCODE_LINUX_4(DEVICE_CHANGESTATE_FAILURE_PC, dev_no, bus_no,
POSTCODE_SEVERITY_ERR);
rc = -CONTROLVM_RESP_ERROR_DEVICE_INVALID;
}
-Away:
- if ((rc >= CONTROLVM_RESP_SUCCESS) && pDevInfo)
- device_epilog(busNo, devNo, state, CONTROLVM_DEVICE_CHANGESTATE,
- &inmsg->hdr, rc,
+ if ((rc >= CONTROLVM_RESP_SUCCESS) && dev_info)
+ device_epilog(bus_no, dev_no, state,
+ CONTROLVM_DEVICE_CHANGESTATE, &inmsg->hdr, rc,
inmsg->hdr.flags.response_expected == 1,
FOR_VISORBUS(
- pDevInfo->chan_info.channel_type_uuid));
+ dev_info->chan_info.channel_type_uuid));
}
static void
my_device_destroy(struct controlvm_message *inmsg)
{
struct controlvm_message_packet *cmd = &inmsg->cmd;
- ulong busNo = cmd->destroy_device.bus_no;
- ulong devNo = cmd->destroy_device.dev_no;
- struct visorchipset_device_info *pDevInfo = NULL;
+ ulong bus_no = cmd->destroy_device.bus_no;
+ ulong dev_no = cmd->destroy_device.dev_no;
+ struct visorchipset_device_info *dev_info = NULL;
int rc = CONTROLVM_RESP_SUCCESS;
- pDevInfo = finddevice(&dev_info_list, busNo, devNo);
- if (!pDevInfo) {
+ dev_info = finddevice(&dev_info_list, bus_no, dev_no);
+ if (!dev_info)
rc = -CONTROLVM_RESP_ERROR_DEVICE_INVALID;
- goto Away;
- }
- if (pDevInfo->state.created == 0) {
+ else if (dev_info->state.created == 0)
rc = -CONTROLVM_RESP_ERROR_ALREADY_DONE;
- }
-Away:
- if ((rc >= CONTROLVM_RESP_SUCCESS) && pDevInfo)
- device_epilog(busNo, devNo, segment_state_running,
+ if ((rc >= CONTROLVM_RESP_SUCCESS) && dev_info)
+ device_epilog(bus_no, dev_no, segment_state_running,
CONTROLVM_DEVICE_DESTROY, &inmsg->hdr, rc,
inmsg->hdr.flags.response_expected == 1,
FOR_VISORBUS(
- pDevInfo->chan_info.channel_type_uuid));
+ dev_info->chan_info.channel_type_uuid));
}
/* When provided with the physical address of the controlvm channel
u8 __iomem *payload = NULL;
int rc = CONTROLVM_RESP_SUCCESS;
- if (info == NULL) {
+ if (!info) {
rc = -CONTROLVM_RESP_ERROR_PAYLOAD_INVALID;
- goto Away;
+ goto cleanup;
}
memset(info, 0, sizeof(struct controlvm_payload_info));
if ((offset == 0) || (bytes == 0)) {
rc = -CONTROLVM_RESP_ERROR_PAYLOAD_INVALID;
- goto Away;
+ goto cleanup;
}
payload = ioremap_cache(phys_addr + offset, bytes);
- if (payload == NULL) {
+ if (!payload) {
rc = -CONTROLVM_RESP_ERROR_IOREMAP_FAILED;
- goto Away;
+ goto cleanup;
}
info->offset = offset;
info->bytes = bytes;
info->ptr = payload;
-Away:
+cleanup:
if (rc < 0) {
- if (payload != NULL) {
+ if (payload) {
iounmap(payload);
payload = NULL;
}
static void
destroy_controlvm_payload_info(struct controlvm_payload_info *info)
{
- if (info->ptr != NULL) {
+ if (info->ptr) {
iounmap(info->ptr);
info->ptr = NULL;
}
initialize_controlvm_payload(void)
{
HOSTADDRESS phys_addr = visorchannel_get_physaddr(controlvm_channel);
- u64 payloadOffset = 0;
- u32 payloadBytes = 0;
+ u64 payload_offset = 0;
+ u32 payload_bytes = 0;
if (visorchannel_read(controlvm_channel,
offsetof(struct spar_controlvm_channel_protocol,
request_payload_offset),
- &payloadOffset, sizeof(payloadOffset)) < 0) {
+ &payload_offset, sizeof(payload_offset)) < 0) {
POSTCODE_LINUX_2(CONTROLVM_INIT_FAILURE_PC,
POSTCODE_SEVERITY_ERR);
return;
if (visorchannel_read(controlvm_channel,
offsetof(struct spar_controlvm_channel_protocol,
request_payload_bytes),
- &payloadBytes, sizeof(payloadBytes)) < 0) {
+ &payload_bytes, sizeof(payload_bytes)) < 0) {
POSTCODE_LINUX_2(CONTROLVM_INIT_FAILURE_PC,
POSTCODE_SEVERITY_ERR);
return;
}
initialize_controlvm_payload_info(phys_addr,
- payloadOffset, payloadBytes,
- &ControlVm_payload_info);
+ payload_offset, payload_bytes,
+ &controlvm_payload_info);
}
/* Send ACTION=online for DEVPATH=/sys/devices/platform/visorchipset.
{
struct parahotplug_request *req;
- req = kmalloc(sizeof(*req), GFP_KERNEL|__GFP_NORETRY);
- if (req == NULL)
+ req = kmalloc(sizeof(*req), GFP_KERNEL | __GFP_NORETRY);
+ if (!req)
return NULL;
req->id = parahotplug_next_id();
list_for_each_safe(pos, tmp, &Parahotplug_request_list) {
struct parahotplug_request *req =
list_entry(pos, struct parahotplug_request, list);
- if (time_after_eq(jiffies, req->expiration)) {
- list_del(pos);
- if (req->msg.hdr.flags.response_expected)
- controlvm_respond_physdev_changestate(
- &req->msg.hdr,
- CONTROLVM_RESP_ERROR_DEVICE_UDEV_TIMEOUT,
- req->msg.cmd.device_change_state.state);
- parahotplug_request_destroy(req);
- }
+
+ if (!time_after_eq(jiffies, req->expiration))
+ continue;
+
+ list_del(pos);
+ if (req->msg.hdr.flags.response_expected)
+ controlvm_respond_physdev_changestate(
+ &req->msg.hdr,
+ CONTROLVM_RESP_ERROR_DEVICE_UDEV_TIMEOUT,
+ req->msg.cmd.device_change_state.state);
+ parahotplug_request_destroy(req);
}
spin_unlock(&Parahotplug_request_list_lock);
req = parahotplug_request_create(inmsg);
- if (req == NULL)
+ if (!req)
return;
if (inmsg->cmd.device_change_state.state.active) {
* indicated it's done.
*/
spin_lock(&Parahotplug_request_list_lock);
- list_add_tail(&(req->list), &Parahotplug_request_list);
+ list_add_tail(&req->list, &Parahotplug_request_list);
spin_unlock(&Parahotplug_request_list_lock);
parahotplug_request_kickoff(req);
break;
}
- if (parser_ctx != NULL) {
+ if (parser_ctx) {
parser_done(parser_ctx);
parser_ctx = NULL;
}
inmsg = ControlVm_Pending_Msg;
ControlVm_Pending_Msg_Valid = FALSE;
gotACommand = TRUE;
- } else
+ } else {
gotACommand = read_controlvm_event(&inmsg);
+ }
}
handle_command_failed = FALSE;
static void
setup_crash_devices_work_queue(struct work_struct *work)
{
-
struct controlvm_message localCrashCreateBusMsg;
struct controlvm_message localCrashCreateDevMsg;
struct controlvm_message msg;
}
/* reuse IOVM create bus message */
- if (localCrashCreateBusMsg.cmd.create_bus.channel_addr != 0)
+ if (localCrashCreateBusMsg.cmd.create_bus.channel_addr != 0) {
bus_create(&localCrashCreateBusMsg);
- else {
+ } else {
POSTCODE_LINUX_2(CRASH_DEV_BUS_NULL_FAILURE_PC,
POSTCODE_SEVERITY_ERR);
return;
}
/* reuse create device message for storage device */
- if (localCrashCreateDevMsg.cmd.create_device.channel_addr != 0)
+ if (localCrashCreateDevMsg.cmd.create_device.channel_addr != 0) {
my_device_create(&localCrashCreateDevMsg);
- else {
+ } else {
POSTCODE_LINUX_2(CRASH_DEV_DEV_NULL_FAILURE_PC,
POSTCODE_SEVERITY_ERR);
return;
void
visorchipset_device_pause_response(ulong bus_no, ulong dev_no, int response)
{
-
device_changestate_responder(CONTROLVM_DEVICE_CHANGESTATE,
bus_no, dev_no, response,
segment_state_standby);
memset(&BusDev_Server_Notifiers, 0, sizeof(BusDev_Server_Notifiers));
memset(&BusDev_Client_Notifiers, 0, sizeof(BusDev_Client_Notifiers));
- memset(&ControlVm_payload_info, 0, sizeof(ControlVm_payload_info));
- memset(&LiveDump_info, 0, sizeof(LiveDump_info));
- atomic_set(&LiveDump_info.buffers_in_use, 0);
+ memset(&controlvm_payload_info, 0, sizeof(controlvm_payload_info));
+ memset(&livedump_info, 0, sizeof(livedump_info));
+ atomic_set(&livedump_info.buffers_in_use, 0);
if (visorchipset_testvnic) {
POSTCODE_LINUX_3(CHIPSET_INIT_FAILURE_PC, x, DIAG_SEVERITY_ERR);
periodic_controlvm_workqueue =
create_singlethread_workqueue("visorchipset_controlvm");
- if (periodic_controlvm_workqueue == NULL) {
+ if (!periodic_controlvm_workqueue) {
POSTCODE_LINUX_2(CREATE_WORKQUEUE_FAILED_PC,
DIAG_SEVERITY_ERR);
rc = -ENOMEM;
DIAG_SEVERITY_ERR);
goto Away;
}
-
}
Visorchipset_platform_device.dev.devt = MajorDev;
flush_workqueue(periodic_controlvm_workqueue);
destroy_workqueue(periodic_controlvm_workqueue);
periodic_controlvm_workqueue = NULL;
- destroy_controlvm_payload_info(&ControlVm_payload_info);
+ destroy_controlvm_payload_info(&controlvm_payload_info);
}
if (Putfile_buffer_list_pool) {
kmem_cache_destroy(Putfile_buffer_list_pool);
projects / firefly-linux-kernel-4.4.55.git / blobdiff