mirror of
https://github.com/projectacrn/acrn-hypervisor.git
synced 2025-09-16 06:19:24 +00:00
monitor: an interface of acrn-dm
A monitor component will be added to acrn-dm, which crteats socket, bind and listening at /run/acrn/vmname. Acrnctl & acrnd could conn -ect to the socket for communication, using defined message, in include/monitor_msg.h For each defined message, a message handler callback could be registered via monitor_add_msg_handler(). On received of a defined message, a certain call back will be called. Each callback can only see the message sender's socket-fd. When acrn-dm want report something, not triggered by incoming message it can send broadcast message, use monitor_broadcast(). Acked-by: Eddie Dong <eddie.dong@intel.com> Reviewed-by: Geoffroy Van Cutsem <geoffroy.vancutsem@intel.com> Reviewed-by: Zhao Yakui <yakui.zhao@intel.com> Reviewed-by: Yin, Fengwei <fengwei.yin@intel.com> Signed-off-by: Tao, Yuhong <yuhong.tao@intel.com>
This commit is contained in:
Tao, Yuhong
Jack Ren
472
devicemodel/core/monitor.c
Normal file
472
devicemodel/core/monitor.c
Normal file
@@ -0,0 +1,472 @@
|
||||
/*
|
||||
* Project Acrn
|
||||
* Acrn-dm-monitor
|
||||
*
|
||||
* Copyright (C) 2018 Intel Corporation. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
* * Neither the name of Intel Corporation nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
*
|
||||
* Author: TaoYuhong <yuhong.tao@intel.com>
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/un.h>
|
||||
#include <pthread.h>
|
||||
#include <stdlib.h>
|
||||
#include <sys/queue.h>
|
||||
#include <errno.h>
|
||||
#include <time.h>
|
||||
#include "dm.h"
|
||||
#include "vmmapi.h"
|
||||
#include "mevent.h"
|
||||
#include "monitor.h"
|
||||
|
||||
/* Data structure and functions for processing received messages */
|
||||
struct monitor_msg_handle {
|
||||
struct vmm_msg msg;
|
||||
void (*callback) (struct vmm_msg * msg, struct msg_sender * sender,
|
||||
void *priv);
|
||||
void *priv;
|
||||
LIST_ENTRY(monitor_msg_handle) list;
|
||||
};
|
||||
|
||||
static LIST_HEAD(mmh_list_struct, monitor_msg_handle) mmh_head;
|
||||
static pthread_mutex_t mmh_mutex = PTHREAD_MUTEX_INITIALIZER;
|
||||
static int can_register_handler = 0; /* Do not allow anyone add his handler,
|
||||
untill we have added some researved ones */
|
||||
static int monitor_add_handler(struct monitor_msg_handle *handle)
|
||||
{
|
||||
struct monitor_msg_handle *hp;
|
||||
|
||||
pthread_mutex_lock(&mmh_mutex);
|
||||
|
||||
LIST_FOREACH(hp, &mmh_head, list)
|
||||
if (hp->msg.msgid == handle->msg.msgid) {
|
||||
fprintf(stderr, "%s %d\r\n", __FUNCTION__, __LINE__);
|
||||
pthread_mutex_unlock(&mmh_mutex);
|
||||
return -1;
|
||||
}
|
||||
LIST_INSERT_HEAD(&mmh_head, handle, list);
|
||||
pthread_mutex_unlock(&mmh_mutex);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int monitor_register_handler(struct vmm_msg *msg,
|
||||
void (*callback) (struct vmm_msg * msg,
|
||||
struct msg_sender * client,
|
||||
void *priv), void *priv)
|
||||
{
|
||||
struct monitor_msg_handle *handle;
|
||||
int ret;
|
||||
|
||||
if (!can_register_handler)
|
||||
return -1;
|
||||
|
||||
handle = calloc(1, sizeof(struct monitor_msg_handle));
|
||||
if (!handle) {
|
||||
fprintf(stderr, "%s %d\r\n", __FUNCTION__, __LINE__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
handle->msg.msgid = msg->msgid;
|
||||
handle->callback = callback;
|
||||
handle->priv = priv;
|
||||
|
||||
ret = monitor_add_handler(handle);
|
||||
if (ret)
|
||||
free(handle);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* messages handled by monitor */
|
||||
static int write_msg_to(int fd, void *data, unsigned long timeout_usec)
|
||||
{
|
||||
struct vmm_msg *msg = data;
|
||||
fd_set wfd;
|
||||
struct timeval timeout;
|
||||
int ret = 0;
|
||||
|
||||
if (msg->len < sizeof(struct vmm_msg)) {
|
||||
fprintf(stderr, "%s %d\r\n", __FUNCTION__, __LINE__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (msg->msgid > MSGID_MAX) {
|
||||
fprintf(stderr, "%s %d\r\n", __FUNCTION__, __LINE__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (msg->magic != VMM_MSG_MAGIC) {
|
||||
fprintf(stderr, "%s %d\r\n", __FUNCTION__, __LINE__);
|
||||
msg->magic = VMM_MSG_MAGIC;
|
||||
}
|
||||
|
||||
msg->timestamp = time(NULL);
|
||||
|
||||
FD_ZERO(&wfd);
|
||||
FD_SET(fd, &wfd);
|
||||
timeout.tv_sec = 0;
|
||||
timeout.tv_usec = timeout_usec;
|
||||
select(fd + 1, NULL, &wfd, NULL, &timeout);
|
||||
|
||||
if (FD_ISSET(fd, &wfd))
|
||||
ret = write(fd, msg, msg->len);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* MSG_HANDSHAKE, handshake message handler*/
|
||||
#define TIMEOUT_USEC 100000
|
||||
static VMM_MSG_STR(handshake_badname, "Error: bad name!");
|
||||
static VMM_MSG_STR(handshake_ok, "acrn-dm read you request");
|
||||
|
||||
static void handshake_acrn_dm(struct vmm_msg *msg, struct msg_sender *sender,
|
||||
void *priv)
|
||||
{
|
||||
struct vmm_msg_handshake *hsk = (void *)msg;
|
||||
int ret;
|
||||
|
||||
ret = strnlen(hsk->name, CLIENT_NAME_LEN);
|
||||
if (ret >= CLIENT_NAME_LEN) {
|
||||
write_msg_to(sender->fd, &handshake_badname, TIMEOUT_USEC);
|
||||
return;
|
||||
}
|
||||
|
||||
strncpy(sender->name, hsk->name, CLIENT_NAME_LEN);
|
||||
sender->broadcast = hsk->broadcast;
|
||||
|
||||
write_msg_to(sender->fd, &handshake_ok, TIMEOUT_USEC);
|
||||
}
|
||||
|
||||
static struct monitor_msg_handle handle_handshake = {
|
||||
.msg = {.msgid = MSG_HANDSHAKE},
|
||||
.callback = handshake_acrn_dm,
|
||||
};
|
||||
|
||||
/* vm manager can comunicate with dm-monitor, use unix socket,
|
||||
* the monitor is the server, and there may have many clients,
|
||||
* a client send a message, trigger right msg handler. And msg handler
|
||||
* should only reply to message sender.
|
||||
*/
|
||||
|
||||
static struct sockaddr_un monitor_addr; /* one monitor */
|
||||
static int monitor_fd;
|
||||
|
||||
struct vmm_client {
|
||||
/* msg_sender will be seen/modify by msg handler */
|
||||
struct msg_sender sender;
|
||||
|
||||
/* the rest should be invisible for msg_handler */
|
||||
struct sockaddr_un addr;
|
||||
int fd;
|
||||
socklen_t addr_len;
|
||||
void *buf;
|
||||
int len; /* buf len */
|
||||
struct mevent *mev;
|
||||
LIST_ENTRY(vmm_client) list;
|
||||
};
|
||||
|
||||
static LIST_HEAD(client_list_struct, vmm_client) client_head;
|
||||
static int num_client = 0;
|
||||
static pthread_mutex_t client_mutex = PTHREAD_MUTEX_INITIALIZER;
|
||||
|
||||
static void vmm_client_free_res(struct vmm_client *client)
|
||||
{
|
||||
mevent_delete(client->mev);
|
||||
close(client->fd);
|
||||
client->fd = -1;
|
||||
free(client->buf);
|
||||
client->buf = NULL;
|
||||
free(client);
|
||||
}
|
||||
|
||||
static void vmm_client_free(struct vmm_client *client)
|
||||
{
|
||||
pthread_mutex_lock(&client_mutex);
|
||||
LIST_REMOVE(client, list);
|
||||
num_client--;
|
||||
pthread_mutex_unlock(&client_mutex);
|
||||
|
||||
vmm_client_free_res(client);
|
||||
}
|
||||
|
||||
static VMM_MSG_STR(unsupported_msgid, "Error: unsupported msgid!");
|
||||
|
||||
static int monitor_parse_buf(struct vmm_client *client)
|
||||
{
|
||||
struct vmm_msg *msg;
|
||||
struct monitor_msg_handle *handle;
|
||||
size_t p = 0;
|
||||
int handled = 0;
|
||||
|
||||
if (client->len < sizeof(struct vmm_msg))
|
||||
return -1;
|
||||
do {
|
||||
msg = client->buf + p;
|
||||
|
||||
/* do we out-of-bounary? */
|
||||
if (p + msg->len > client->len) {
|
||||
fprintf(stderr, "%s %d\r\n", __FUNCTION__, __LINE__);
|
||||
break;
|
||||
}
|
||||
|
||||
LIST_FOREACH(handle, &mmh_head, list) {
|
||||
if (msg->magic != VMM_MSG_MAGIC)
|
||||
return -1;
|
||||
if (handle->msg.msgid != msg->msgid)
|
||||
continue;
|
||||
client->sender.fd = client->fd;
|
||||
handle->callback(msg, &client->sender, handle->priv);
|
||||
handled = 1;
|
||||
break;
|
||||
}
|
||||
p += msg->len;
|
||||
} while (p < client->len);
|
||||
|
||||
if (!handled)
|
||||
write_msg_to(client->fd, &unsupported_msgid, TIMEOUT_USEC);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void mevent_read_func(int fd, enum ev_type type, void *param)
|
||||
{
|
||||
struct vmm_client *client = param;
|
||||
|
||||
client->len = read(fd, client->buf, VMM_MSG_MAX_LEN);
|
||||
if (client->len <= 0) {
|
||||
fprintf(stderr, "Disconnect(%d)!\r\n", client->fd);
|
||||
vmm_client_free(client);
|
||||
return;
|
||||
}
|
||||
|
||||
if (client->len == VMM_MSG_MAX_LEN) {
|
||||
fprintf(stderr, "TODO: buf overflow!\r\n");
|
||||
return;
|
||||
}
|
||||
|
||||
monitor_parse_buf(client);
|
||||
}
|
||||
|
||||
static struct vmm_client *vmm_client_new(void)
|
||||
{
|
||||
struct vmm_client *client;
|
||||
|
||||
client = calloc(1, sizeof(struct vmm_client));
|
||||
if (!client) {
|
||||
fprintf(stderr, "%s %d\r\n", __FUNCTION__, __LINE__);
|
||||
goto alloc_client;
|
||||
}
|
||||
memset(client, 0, sizeof(struct vmm_client));
|
||||
|
||||
client->buf = calloc(1, VMM_MSG_MAX_LEN);
|
||||
if (!client->buf) {
|
||||
fprintf(stderr, "%s %d\r\n", __FUNCTION__, __LINE__);
|
||||
goto alloc_buf;
|
||||
}
|
||||
|
||||
client->addr_len = sizeof(client->addr);
|
||||
client->fd =
|
||||
accept(monitor_fd, (struct sockaddr *)&client->addr, &client->addr_len);
|
||||
if (client->fd < 0) {
|
||||
fprintf(stderr, "%s %d\r\n", __FUNCTION__, __LINE__);
|
||||
goto accept_con;
|
||||
}
|
||||
|
||||
client->mev =
|
||||
mevent_add(client->fd, EVF_READ, mevent_read_func, client);
|
||||
if (!client->mev) {
|
||||
fprintf(stderr, "%s %d\r\n", __FUNCTION__, __LINE__);
|
||||
goto add_mev;
|
||||
}
|
||||
|
||||
pthread_mutex_lock(&client_mutex);
|
||||
LIST_INSERT_HEAD(&client_head, client, list);
|
||||
num_client++;
|
||||
pthread_mutex_unlock(&client_mutex);
|
||||
|
||||
return client;
|
||||
|
||||
add_mev:
|
||||
close(client->fd);
|
||||
client->fd = -1;
|
||||
accept_con:
|
||||
free(client->buf);
|
||||
client->buf = NULL;
|
||||
alloc_buf:
|
||||
free(client);
|
||||
alloc_client:
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int monitor_broadcast(struct vmm_msg *msg)
|
||||
{
|
||||
struct vmm_client *client;
|
||||
fd_set wfd;
|
||||
int max_fd = 0;
|
||||
struct timeval timeout;
|
||||
int ret = 0;
|
||||
|
||||
if (msg->len < sizeof(struct vmm_msg)) {
|
||||
fprintf(stderr, "%s %d\r\n", __FUNCTION__, __LINE__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (msg->msgid > MSGID_MAX) {
|
||||
fprintf(stderr, "%s %d\r\n", __FUNCTION__, __LINE__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (msg->magic != VMM_MSG_MAGIC) {
|
||||
fprintf(stderr, "%s %d\r\n", __FUNCTION__, __LINE__);
|
||||
msg->magic = VMM_MSG_MAGIC;
|
||||
}
|
||||
|
||||
msg->timestamp = time(NULL);
|
||||
|
||||
pthread_mutex_lock(&client_mutex);
|
||||
|
||||
FD_ZERO(&wfd);
|
||||
LIST_FOREACH(client, &client_head, list) {
|
||||
if (!client->sender.broadcast)
|
||||
continue;
|
||||
FD_SET(client->fd, &wfd);
|
||||
if (client->fd > max_fd)
|
||||
max_fd = client->fd;
|
||||
}
|
||||
timeout.tv_sec = 0;
|
||||
timeout.tv_usec = 10000;
|
||||
select(max_fd + 1, NULL, &wfd, NULL, &timeout);
|
||||
|
||||
LIST_FOREACH(client, &client_head, list) {
|
||||
if (!client->sender.broadcast)
|
||||
continue;
|
||||
if (FD_ISSET(client->fd, &wfd)) {
|
||||
ret = write(client->fd, msg->payload,
|
||||
msg->len - sizeof(struct vmm_msg));
|
||||
if (ret < 0)
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
pthread_mutex_unlock(&client_mutex);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* monitor thread */
|
||||
static int monitor_running = 1;
|
||||
static pthread_t monitor_thread;
|
||||
|
||||
static void *monitor_server_func(void *arg)
|
||||
{
|
||||
struct vmm_client *client;
|
||||
while (monitor_running) {
|
||||
client = vmm_client_new();
|
||||
if (!client) {
|
||||
usleep(10000);
|
||||
continue;
|
||||
}
|
||||
fprintf(stderr, "Connected:%d\r\n", client->fd);
|
||||
}
|
||||
|
||||
fprintf(stderr, "%s quit!\r\n", __FUNCTION__);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int monitor_init(struct vmctx *ctx)
|
||||
{
|
||||
int ret;
|
||||
char path[128] = { };
|
||||
|
||||
ret = system("mkdir -p /run/acrn/");
|
||||
if (ret) {
|
||||
fprintf(stderr, "%s %d\r\n", __FUNCTION__, __LINE__);
|
||||
goto socket_err;
|
||||
}
|
||||
memset(&monitor_addr, 0, sizeof(monitor_addr));
|
||||
snprintf(path, sizeof(path), "/run/acrn/%s-monitor.socket", vmname);
|
||||
unlink(path);
|
||||
monitor_fd = socket(AF_UNIX, SOCK_STREAM, 0);
|
||||
if (monitor_fd < 0) {
|
||||
fprintf(stderr, "%s %d\r\n", __FUNCTION__, __LINE__);
|
||||
goto socket_err;
|
||||
}
|
||||
|
||||
monitor_addr.sun_family = AF_UNIX;
|
||||
strncpy(monitor_addr.sun_path, path, sizeof(monitor_addr.sun_path));
|
||||
ret = bind(monitor_fd, (struct sockaddr *)&monitor_addr, sizeof(monitor_addr));
|
||||
if (ret < 0) {
|
||||
fprintf(stderr, "%s %d\r\n", __FUNCTION__, __LINE__);
|
||||
goto bind_err;
|
||||
}
|
||||
|
||||
listen(monitor_fd, 1);
|
||||
ret = pthread_create(&monitor_thread, NULL, monitor_server_func, NULL);
|
||||
if (ret) {
|
||||
fprintf(stderr, "%s %d\r\n", __FUNCTION__, __LINE__);
|
||||
goto thread_err;
|
||||
}
|
||||
|
||||
/* Messages handled by monitor */
|
||||
monitor_add_handler(&handle_handshake);
|
||||
|
||||
__sync_fetch_and_add(&can_register_handler, 1);
|
||||
return 0;
|
||||
|
||||
thread_err:
|
||||
monitor_thread = 0;
|
||||
unlink(path);
|
||||
bind_err:
|
||||
close(monitor_fd);
|
||||
socket_err:
|
||||
return -1;
|
||||
}
|
||||
|
||||
void monitor_close(void)
|
||||
{
|
||||
struct vmm_client *client;
|
||||
if (!monitor_thread)
|
||||
return;
|
||||
shutdown(monitor_fd, SHUT_RDWR);
|
||||
close(monitor_fd);
|
||||
monitor_running = 0;
|
||||
pthread_join(monitor_thread, NULL);
|
||||
unlink(monitor_addr.sun_path);
|
||||
|
||||
/* client buf-mem and fd may be still in use by msg-handler */
|
||||
/* which is handled by mevent */
|
||||
pthread_mutex_lock(&client_mutex);
|
||||
LIST_FOREACH(client, &client_head, list) {
|
||||
vmm_client_free_res(client);
|
||||
}
|
||||
pthread_mutex_unlock(&client_mutex);
|
||||
}
|
||||
Reference in New Issue
Block a user