/**
* Shutdown
*/
static void
hv_shutdown_cb(void *context)
{
uint8_t* buf;
hv_vmbus_channel* channel = context;
uint8_t execute_shutdown = 0;
hv_vmbus_icmsg_hdr* icmsghdrp;
uint32_t recv_len;
uint64_t request_id;
int ret;
hv_vmbus_shutdown_msg_data* shutdown_msg;
buf = receive_buffer[HV_SHUT_DOWN];
ret = hv_vmbus_channel_recv_packet(channel, buf, PAGE_SIZE,
&recv_len, &request_id);
if ((ret == 0) && recv_len > 0) {
icmsghdrp = (struct hv_vmbus_icmsg_hdr *)
&buf[sizeof(struct hv_vmbus_pipe_hdr)];
if (icmsghdrp->icmsgtype == HV_ICMSGTYPE_NEGOTIATE) {
hv_negotiate_version(icmsghdrp, NULL, buf);
} else {
shutdown_msg =
(struct hv_vmbus_shutdown_msg_data *)
&buf[sizeof(struct hv_vmbus_pipe_hdr) +
sizeof(struct hv_vmbus_icmsg_hdr)];
switch (shutdown_msg->flags) {
case 0:
case 1:
icmsghdrp->status = HV_S_OK;
execute_shutdown = 1;
if(bootverbose)
printf("Shutdown request received -"
" graceful shutdown initiated\n");
break;
default:
icmsghdrp->status = HV_E_FAIL;
execute_shutdown = 0;
printf("Shutdown request received -"
" Invalid request\n");
break;
}
}
icmsghdrp->icflags = HV_ICMSGHDRFLAG_TRANSACTION |
HV_ICMSGHDRFLAG_RESPONSE;
hv_vmbus_channel_send_packet(channel, buf,
recv_len, request_id,
HV_VMBUS_PACKET_TYPE_DATA_IN_BAND, 0);
}
if (execute_shutdown)
shutdown_nice(RB_POWEROFF);
}
/**
* Process heartbeat message
*/
static void
hv_heartbeat_cb(void *context)
{
uint8_t* buf;
hv_vmbus_channel* channel = context;
uint32_t recvlen;
uint64_t requestid;
int ret;
struct hv_vmbus_heartbeat_msg_data* heartbeat_msg;
struct hv_vmbus_icmsg_hdr* icmsghdrp;
buf = receive_buffer[HV_HEART_BEAT];
ret = hv_vmbus_channel_recv_packet(channel, buf, PAGE_SIZE, &recvlen,
&requestid);
if ((ret == 0) && recvlen > 0) {
icmsghdrp = (struct hv_vmbus_icmsg_hdr *)
&buf[sizeof(struct hv_vmbus_pipe_hdr)];
if (icmsghdrp->icmsgtype == HV_ICMSGTYPE_NEGOTIATE) {
hv_negotiate_version(icmsghdrp, NULL, buf);
} else {
heartbeat_msg =
(struct hv_vmbus_heartbeat_msg_data *)
&buf[sizeof(struct hv_vmbus_pipe_hdr) +
sizeof(struct hv_vmbus_icmsg_hdr)];
heartbeat_msg->seq_num += 1;
}
icmsghdrp->icflags = HV_ICMSGHDRFLAG_TRANSACTION |
HV_ICMSGHDRFLAG_RESPONSE;
hv_vmbus_channel_send_packet(channel, buf, recvlen, requestid,
HV_VMBUS_PACKET_TYPE_DATA_IN_BAND, 0);
}
}
/**
* Time Sync Channel message handler
*/
static void
hv_timesync_cb(void *context)
{
hv_vmbus_channel* channel;
hv_vmbus_icmsg_hdr* icmsghdrp;
uint32_t recvlen;
uint64_t requestId;
int ret;
uint8_t* time_buf;
struct hv_ictimesync_data* timedatap;
hv_timesync_sc *softc;
softc = (hv_timesync_sc*)context;
channel = softc->util_sc.hv_dev->channel;
time_buf = softc->util_sc.receive_buffer;
ret = hv_vmbus_channel_recv_packet(channel, time_buf,
PAGE_SIZE, &recvlen, &requestId);
if ((ret == 0) && recvlen > 0) {
icmsghdrp = (struct hv_vmbus_icmsg_hdr *) &time_buf[
sizeof(struct hv_vmbus_pipe_hdr)];
if (icmsghdrp->icmsgtype == HV_ICMSGTYPE_NEGOTIATE) {
hv_negotiate_version(icmsghdrp, NULL, time_buf);
} else {
timedatap = (struct hv_ictimesync_data *) &time_buf[
sizeof(struct hv_vmbus_pipe_hdr) +
sizeof(struct hv_vmbus_icmsg_hdr)];
hv_adj_guesttime(softc, timedatap->parenttime, timedatap->flags);
}
icmsghdrp->icflags = HV_ICMSGHDRFLAG_TRANSACTION
| HV_ICMSGHDRFLAG_RESPONSE;
hv_vmbus_channel_send_packet(channel, time_buf,
recvlen, requestId,
HV_VMBUS_PACKET_TYPE_DATA_IN_BAND, 0);
}
}
/*
* Callback routine that gets called whenever there is a message from host
*/
static
void hv_kvp_callback(void *context)
{
uint8_t* buf;
hv_vmbus_channel* channel = context;
uint32_t recvlen;
uint64_t requestid;
int ret;
struct hv_vmbus_icmsg_hdr* icmsghdrp;
buf = receive_buffer[0];
#if 0
/* If driver unloaded abruptly, return */
if (vmbus_kvp_channel == NULL)
{
#ifdef DEBUG
printf("hv_kvp_cb: kvp unloaded abruptly\n");
#endif
return;
}
#endif
/* Check if kvp is ready to process */
if (!hv_kvp_ready()) {
#ifdef DEBUG
printf("hv_kvp_cb: kvp is not ready..initing\n");
#endif
hv_queue_work_item(kvp_work_queue, hv_kvp_conn_register, NULL);
}
/* Check if already one transaction is under process */
if (hv_kvp_transaction_active()) {
#ifdef DEBUG
printf("hv_kvp_cb: Already one transaction is active\n");
#endif
return;
}
ret = hv_vmbus_channel_recv_packet(channel, buf, PAGE_SIZE * 2,
&recvlen, &requestid);
#ifdef DEBUG
printf("hv_kvp_cb: vmbus_recv ret:%d rLen:%d rId:%d\n",
ret, recvlen, (int)requestid);
#endif
if ((ret == 0) && (recvlen > 0)) {
icmsghdrp = (struct hv_vmbus_icmsg_hdr *)
&buf[sizeof(struct hv_vmbus_pipe_hdr)];
if (icmsghdrp->icmsgtype == HV_ICMSGTYPE_NEGOTIATE) {
#ifdef DEBUG
printf("hv_kvp_cb: Negotiate message received\n");
#endif
hv_negotiate_version(icmsghdrp, NULL, buf);
} else {
#ifdef DEBUG
printf("hv_kvp_cb: New host message received\n");
#endif
hv_kvp_transaction_init(recvlen,channel,requestid, buf);
hv_queue_work_item(kvp_work_queue,
hv_kvp_process_msg, NULL);
return; /* deferred response by KVP process */
}
icmsghdrp->icflags = HV_ICMSGHDRFLAG_TRANSACTION |
HV_ICMSGHDRFLAG_RESPONSE;
hv_vmbus_channel_send_packet(channel, buf, recvlen, requestid,
HV_VMBUS_PACKET_TYPE_DATA_IN_BAND, 0);
}
}
/*
* Function to read the kvp request buffer from host
* and interact with daemon
*/
static void
hv_kvp_process_request(void *context)
{
uint8_t *kvp_buf;
hv_vmbus_channel *channel = context;
uint32_t recvlen = 0;
uint64_t requestid;
struct hv_vmbus_icmsg_hdr *icmsghdrp;
int ret = 0;
uint64_t pending_cnt = 1;
hv_kvp_log_info("%s: entering hv_kvp_process_request\n", __func__);
kvp_buf = receive_buffer[HV_KVP];
ret = hv_vmbus_channel_recv_packet(channel, kvp_buf, 2 * PAGE_SIZE,
&recvlen, &requestid);
/*
* We start counting only after the daemon registers
* and therefore there could be requests pending in
* the VMBus that are not reflected in pending_cnt.
* Therefore we continue reading as long as either of
* the below conditions is true.
*/
while ((pending_cnt>0) || ((ret == 0) && (recvlen > 0))) {
if ((ret == 0) && (recvlen>0)) {
icmsghdrp = (struct hv_vmbus_icmsg_hdr *)
&kvp_buf[sizeof(struct hv_vmbus_pipe_hdr)];
hv_kvp_transaction_init(recvlen, channel, requestid, kvp_buf);
if (icmsghdrp->icmsgtype == HV_ICMSGTYPE_NEGOTIATE) {
hv_kvp_negotiate_version(icmsghdrp, NULL, kvp_buf);
hv_kvp_respond_host(ret);
/*
* It is ok to not acquire the mutex before setting
* req_in_progress here because negotiation is the
* first thing that happens and hence there is no
* chance of a race condition.
*/
kvp_globals.req_in_progress = false;
hv_kvp_log_info("%s :version negotiated\n", __func__);
} else {
if (!kvp_globals.daemon_busy) {
hv_kvp_log_info("%s: issuing qury to daemon\n", __func__);
mtx_lock(&kvp_globals.pending_mutex);
kvp_globals.req_timed_out = false;
kvp_globals.daemon_busy = true;
mtx_unlock(&kvp_globals.pending_mutex);
hv_kvp_send_msg_to_daemon();
hv_kvp_log_info("%s: waiting for daemon\n", __func__);
}
/* Wait 5 seconds for daemon to respond back */
tsleep(&kvp_globals, 0, "kvpworkitem", 5 * hz);
hv_kvp_log_info("%s: came out of wait\n", __func__);
}
}
mtx_lock(&kvp_globals.pending_mutex);
/* Notice that once req_timed_out is set to true
* it will remain true until the next request is
* sent to the daemon. The response from daemon
* is forwarded to host only when this flag is
* false.
*/
kvp_globals.req_timed_out = true;
/*
* Cancel request if so need be.
*/
if (hv_kvp_req_in_progress()) {
hv_kvp_log_info("%s: request was still active after wait so failing\n", __func__);
hv_kvp_respond_host(HV_KVP_E_FAIL);
kvp_globals.req_in_progress = false;
}
/*
* Decrement pending request count and
*/
if (kvp_globals.pending_reqs>0) {
kvp_globals.pending_reqs = kvp_globals.pending_reqs - 1;
}
pending_cnt = kvp_globals.pending_reqs;
mtx_unlock(&kvp_globals.pending_mutex);
/*
* Try reading next buffer
*/
recvlen = 0;
ret = hv_vmbus_channel_recv_packet(channel, kvp_buf, 2 * PAGE_SIZE,
&recvlen, &requestid);
hv_kvp_log_info("%s: read: context %p, pending_cnt %ju ret =%d, recvlen=%d\n",
__func__, context, pending_cnt, ret, recvlen);
}
}
/*
* Function to read the kvp request buffer from host
* and interact with daemon
*/
static void
hv_kvp_process_request(void *context, int pending)
{
uint8_t *kvp_buf;
hv_vmbus_channel *channel;
uint32_t recvlen = 0;
uint64_t requestid;
struct hv_vmbus_icmsg_hdr *icmsghdrp;
int ret = 0;
hv_kvp_sc *sc;
hv_kvp_log_info("%s: entering hv_kvp_process_request\n", __func__);
sc = (hv_kvp_sc*)context;
kvp_buf = sc->util_sc.receive_buffer;
channel = sc->util_sc.hv_dev->channel;
ret = hv_vmbus_channel_recv_packet(channel, kvp_buf, 2 * PAGE_SIZE,
&recvlen, &requestid);
while ((ret == 0) && (recvlen > 0)) {
icmsghdrp = (struct hv_vmbus_icmsg_hdr *)
&kvp_buf[sizeof(struct hv_vmbus_pipe_hdr)];
hv_kvp_transaction_init(sc, recvlen, requestid, kvp_buf);
if (icmsghdrp->icmsgtype == HV_ICMSGTYPE_NEGOTIATE) {
hv_kvp_negotiate_version(icmsghdrp, NULL, kvp_buf);
hv_kvp_respond_host(sc, ret);
/*
* It is ok to not acquire the mutex before setting
* req_in_progress here because negotiation is the
* first thing that happens and hence there is no
* chance of a race condition.
*/
sc->req_in_progress = false;
hv_kvp_log_info("%s :version negotiated\n", __func__);
} else {
if (!sc->daemon_busy) {
hv_kvp_log_info("%s: issuing qury to daemon\n", __func__);
mtx_lock(&sc->pending_mutex);
sc->req_timed_out = false;
sc->daemon_busy = true;
mtx_unlock(&sc->pending_mutex);
hv_kvp_send_msg_to_daemon(sc);
hv_kvp_log_info("%s: waiting for daemon\n", __func__);
}
/* Wait 5 seconds for daemon to respond back */
tsleep(sc, 0, "kvpworkitem", 5 * hz);
hv_kvp_log_info("%s: came out of wait\n", __func__);
}
mtx_lock(&sc->pending_mutex);
/* Notice that once req_timed_out is set to true
* it will remain true until the next request is
* sent to the daemon. The response from daemon
* is forwarded to host only when this flag is
* false.
*/
sc->req_timed_out = true;
/*
* Cancel request if so need be.
*/
if (hv_kvp_req_in_progress(sc)) {
hv_kvp_log_info("%s: request was still active after wait so failing\n", __func__);
hv_kvp_respond_host(sc, HV_KVP_E_FAIL);
sc->req_in_progress = false;
}
mtx_unlock(&sc->pending_mutex);
/*
* Try reading next buffer
*/
recvlen = 0;
ret = hv_vmbus_channel_recv_packet(channel, kvp_buf, 2 * PAGE_SIZE,
&recvlen, &requestid);
hv_kvp_log_info("%s: read: context %p, ret =%d, recvlen=%d\n",
__func__, context, ret, recvlen);
}
}