|
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [Xen-devel] [PATCH 13/17 v5] xen/arm: vpl011: Modify xenconsole to support multiple consoles
This patch adds the support for multiple consoles and introduces the iterator
functions to operate on multiple consoles.
This patch is in preparation to support a new vuart console.
Signed-off-by: Bhupinder Thakur <bhupinder.thakur@xxxxxxxxxx>
---
CC: Ian Jackson <ian.jackson@xxxxxxxxxxxxx>
CC: Wei Liu <wei.liu2@xxxxxxxxxx>
CC: Stefano Stabellini <sstabellini@xxxxxxxxxx>
CC: Julien Grall <julien.grall@xxxxxxx>
Changes since v4:
- Changes to make event channel handling per console rather than per domain.
Changes since v3:
- The changes in xenconsole have been split into four patches. This is the
third patch.
tools/console/daemon/io.c | 435 ++++++++++++++++++++++++++++++++--------------
1 file changed, 302 insertions(+), 133 deletions(-)
diff --git a/tools/console/daemon/io.c b/tools/console/daemon/io.c
index a2a3496..baf0e2e 100644
--- a/tools/console/daemon/io.c
+++ b/tools/console/daemon/io.c
@@ -90,12 +90,14 @@ struct buffer {
};
struct console {
+ char *ttyname;
int master_fd;
int master_pollfd_idx;
int slave_fd;
int log_fd;
struct buffer buffer;
char *xspath;
+ char *log_suffix;
int ring_ref;
xenevtchn_handle *xce_handle;
int xce_pollfd_idx;
@@ -107,16 +109,112 @@ struct console {
struct domain *d;
};
+struct console_data {
+ char *xsname;
+ char *ttyname;
+ char *log_suffix;
+};
+
+static struct console_data console_data[] = {
+
+ {
+ .xsname = "/console",
+ .ttyname = "tty",
+ .log_suffix = "",
+ },
+};
+
+#define MAX_CONSOLE (sizeof(console_data)/sizeof(struct console_data))
+
struct domain {
int domid;
bool is_dead;
unsigned last_seen;
struct domain *next;
- struct console console;
+ struct console console[MAX_CONSOLE];
};
static struct domain *dom_head;
+typedef void (*VOID_ITER_FUNC_ARG1)(struct console *);
+typedef bool (*BOOL_ITER_FUNC_ARG1)(struct console *);
+typedef int (*INT_ITER_FUNC_ARG1)(struct console *);
+typedef void (*VOID_ITER_FUNC_ARG2)(struct console *, void *);
+typedef int (*INT_ITER_FUNC_ARG3)(struct console *,
+ struct domain *dom, void **);
+
+static inline bool console_enabled(struct console *con)
+{
+ return con->local_port != -1;
+}
+
+static inline void console_iter_void_arg1(struct domain *d,
+
VOID_ITER_FUNC_ARG1 iter_func)
+{
+ int i = 0;
+ struct console *con = &(d->console[0]);
+
+ for (i = 0; i < MAX_CONSOLE; i++, con++)
+ {
+ iter_func(con);
+ }
+}
+
+static inline void console_iter_void_arg2(struct domain *d,
+
VOID_ITER_FUNC_ARG2 iter_func,
+
void *iter_data)
+{
+ int i = 0;
+ struct console *con = &(d->console[0]);
+
+ for (i = 0; i < MAX_CONSOLE; i++, con++)
+ {
+ iter_func(con, iter_data);
+ }
+}
+
+static inline bool console_iter_bool_arg1(struct domain *d,
+
BOOL_ITER_FUNC_ARG1 iter_func)
+{
+ int i = 0;
+ struct console *con = &(d->console[0]);
+
+ for (i = 0; i < MAX_CONSOLE; i++, con++)
+ {
+ if (iter_func(con))
+ return true;
+ }
+ return false;
+}
+
+static inline int console_iter_int_arg1(struct domain *d,
+
INT_ITER_FUNC_ARG1 iter_func)
+{
+ int i = 0;
+ struct console *con = &(d->console[0]);
+
+ for (i = 0; i < MAX_CONSOLE; i++, con++)
+ {
+ if (iter_func(con))
+ return 1;
+ }
+ return 0;
+}
+
+static inline int console_iter_int_arg3(struct domain *d,
+
INT_ITER_FUNC_ARG3 iter_func,
+
void **iter_data)
+{
+ int i = 0;
+ struct console *con = &(d->console[0]);
+
+ for (i = 0; i < MAX_CONSOLE; i++, con++)
+ {
+ if (iter_func(con, d, iter_data))
+ return 1;
+ }
+ return 0;
+}
static int write_all(int fd, const char* buf, size_t len)
{
while (len) {
@@ -163,12 +261,22 @@ static int write_with_timestamp(int fd, const char *data,
size_t sz,
return 0;
}
-static void buffer_append(struct console *con)
+static inline bool buffer_available(struct console *con)
+{
+ if (discard_overflowed_data ||
+ !con->buffer.max_capacity ||
+ con->buffer.size < con->buffer.max_capacity)
+ return true;
+ else
+ return false;
+}
+
+static void buffer_append(struct console *con, xenevtchn_port_or_error_t port)
{
struct buffer *buffer = &con->buffer;
+ struct xencons_interface *intf = con->interface;
struct domain *dom = con->d;
XENCONS_RING_IDX cons, prod, size;
- struct xencons_interface *intf = con->interface;
cons = intf->out_cons;
prod = intf->out_prod;
@@ -321,7 +429,7 @@ static int create_console_log(struct console *con)
return -1;
}
- snprintf(logfile, PATH_MAX-1, "%s/guest-%s.log", log_dir, data);
+ snprintf(logfile, PATH_MAX-1, "%s/guest-%s%s.log", log_dir, data,
con->log_suffix);
free(data);
logfile[PATH_MAX-1] = '\0';
@@ -473,7 +581,7 @@ static int console_create_tty(struct console *con)
}
free(path);
- success = (asprintf(&path, "%s/tty", con->xspath) != -1);
+ success = (asprintf(&path, "%s/%s", con->xspath, con->ttyname) != -1);
if (!success)
goto out;
success = xs_write(xs, XBT_NULL, path, slave, strlen(slave));
@@ -594,6 +702,7 @@ static int console_create_ring(struct console *con)
con->local_port = -1;
con->remote_port = -1;
+
if (con->xce_handle != NULL)
xenevtchn_close(con->xce_handle);
@@ -639,13 +748,13 @@ static bool watch_domain(struct domain *dom, bool watch)
{
char domid_str[3 + MAX_STRLEN(dom->domid)];
bool success;
- struct console *con = &dom->console;
+ struct console *con = &dom->console[0];
snprintf(domid_str, sizeof(domid_str), "dom%u", dom->domid);
if (watch) {
success = xs_watch(xs, con->xspath, domid_str);
if (success)
- console_create_ring(con);
+ console_iter_int_arg1(dom, console_create_ring);
else
xs_unwatch(xs, con->xspath, domid_str);
} else {
@@ -655,20 +764,59 @@ static bool watch_domain(struct domain *dom, bool watch)
return success;
}
-
-static struct domain *create_domain(int domid)
+static int console_init(struct console *con, struct domain *dom, void **data)
{
- struct domain *dom;
char *s;
+ int err = -1;
struct timespec ts;
- struct console *con;
+ struct console_data **con_data = (struct console_data **)data;
+ char *xsname;
if (clock_gettime(CLOCK_MONOTONIC, &ts) < 0) {
dolog(LOG_ERR, "Cannot get time of day %s:%s:L%d",
__FILE__, __FUNCTION__, __LINE__);
- return NULL;
+ return err;
+ }
+
+ con->master_fd = -1;
+ con->master_pollfd_idx = -1;
+ con->slave_fd = -1;
+ con->log_fd = -1;
+ con->ring_ref = -1;
+ con->local_port = -1;
+ con->remote_port = -1;
+ con->xce_pollfd_idx = -1;
+ con->next_period = ((long long)ts.tv_sec * 1000) + (ts.tv_nsec /
1000000) + RATE_LIMIT_PERIOD;
+ con->d = dom;
+ con->ttyname = (*con_data)->ttyname;
+ con->log_suffix = (*con_data)->log_suffix;
+ xsname = (*con_data)->xsname;
+ con->xspath = xs_get_domain_path(xs, dom->domid);
+ s = realloc(con->xspath, strlen(con->xspath) +
+ strlen(xsname) + 1);
+ if (s)
+ {
+ con->xspath = s;
+ strcat(con->xspath, xsname);
+ err = 0;
}
+ (*con_data)++;
+
+ return err;
+}
+
+static void console_free(struct console *con)
+{
+ if (con->xspath)
+ free(con->xspath);
+}
+
+static struct domain *create_domain(int domid)
+{
+ struct domain *dom;
+ struct console_data *con_data = &console_data[0];
+
dom = calloc(1, sizeof *dom);
if (dom == NULL) {
dolog(LOG_ERR, "Out of memory %s:%s():L%d",
@@ -678,27 +826,8 @@ static struct domain *create_domain(int domid)
dom->domid = domid;
- con = &dom->console;
- con->xspath = xs_get_domain_path(xs, dom->domid);
- s = realloc(con->xspath, strlen(con->xspath) +
- strlen("/console") + 1);
- if (s == NULL)
+ if (console_iter_int_arg3(dom, console_init, (void **)&con_data))
goto out;
- con->xspath = s;
- strcat(con->xspath, "/console");
-
- con->master_fd = -1;
- con->master_pollfd_idx = -1;
- con->slave_fd = -1;
- con->log_fd = -1;
- con->xce_pollfd_idx = -1;
- con->d = dom;
-
- con->next_period = ((long long)ts.tv_sec * 1000) + (ts.tv_nsec /
1000000) + RATE_LIMIT_PERIOD;
-
- con->ring_ref = -1;
- con->local_port = -1;
- con->remote_port = -1;
if (!watch_domain(dom, true))
goto out;
@@ -710,7 +839,7 @@ static struct domain *create_domain(int domid)
return dom;
out:
- free(con->xspath);
+ console_iter_void_arg1(dom, console_free);
free(dom);
return NULL;
}
@@ -740,38 +869,51 @@ static void remove_domain(struct domain *dom)
}
}
-static void cleanup_domain(struct domain *d)
+static void console_cleanup(struct console *con)
{
- struct console *con = &d->console;
-
- console_close_tty(con);
-
if (con->log_fd != -1) {
close(con->log_fd);
con->log_fd = -1;
}
- free(con->buffer.data);
- con->buffer.data = NULL;
+ if (con->buffer.data)
+ {
+ free(con->buffer.data);
+ con->buffer.data = NULL;
+ }
+
+ if (con->xspath)
+ {
+ free(con->xspath);
+ con->xspath = NULL;
+ }
+}
+
+static void cleanup_domain(struct domain *d)
+{
+ console_iter_void_arg1(d, console_close_tty);
- free(con->xspath);
- con->xspath = NULL;
+ console_iter_void_arg1(d, console_cleanup);
remove_domain(d);
}
-static void shutdown_domain(struct domain *d)
+static void console_close_evtchn(struct console *con)
{
- struct console *con = &d->console;
-
- d->is_dead = true;
- watch_domain(d, false);
- console_unmap_interface(con);
if (con->xce_handle != NULL)
xenevtchn_close(con->xce_handle);
+
con->xce_handle = NULL;
}
+static void shutdown_domain(struct domain *d)
+{
+ d->is_dead = true;
+ watch_domain(d, false);
+ console_iter_void_arg1(d, console_unmap_interface);
+ console_iter_void_arg1(d, console_close_evtchn);
+}
+
static unsigned enum_pass = 0;
static void enum_domains(void)
@@ -885,12 +1027,32 @@ static void handle_tty_write(struct console *con)
}
}
-static void handle_ring_read(struct domain *dom)
+static void console_evtchn_unmask(struct console *con, void *data)
+{
+ long long now = (long long)data;
+
+ if (!console_enabled(con))
+ return;
+
+ /* CS 16257:955ee4fa1345 introduces a 5ms fuzz
+ * for select(), it is not clear poll() has
+ * similar behavior (returning a couple of ms
+ * sooner than requested) as well. Just leave
+ * the fuzz here. Remove it with a separate
+ * patch if necessary */
+ if ((now+5) > con->next_period) {
+ con->next_period = now + RATE_LIMIT_PERIOD;
+ if (con->event_count >= RATE_LIMIT_ALLOWANCE)
+ (void)xenevtchn_unmask(con->xce_handle,
con->local_port);
+ con->event_count = 0;
+ }
+}
+
+static void handle_ring_read(struct console *con)
{
xenevtchn_port_or_error_t port;
- struct console *con = &dom->console;
- if (dom->is_dead)
+ if (con->d->is_dead)
return;
if ((port = xenevtchn_pending(con->xce_handle)) == -1)
@@ -898,10 +1060,23 @@ static void handle_ring_read(struct domain *dom)
con->event_count++;
- buffer_append(con);
+ buffer_append(con, port);
if (con->event_count < RATE_LIMIT_ALLOWANCE)
- (void)xenevtchn_unmask(con->xce_handle, port);
+ (void)xenevtchn_unmask(con->xce_handle, con->local_port);
+}
+
+static void handle_console_ring(struct console *con)
+{
+ if (con->event_count < RATE_LIMIT_ALLOWANCE) {
+ if (con->xce_handle != NULL &&
+ con->xce_pollfd_idx != -1 &&
+ !(fds[con->xce_pollfd_idx].revents &
+ ~(POLLIN|POLLOUT|POLLPRI)) &&
+ (fds[con->xce_pollfd_idx].revents &
+ POLLIN))
+ handle_ring_read(con);
+ }
}
static void handle_xs(void)
@@ -922,7 +1097,7 @@ static void handle_xs(void)
/* We may get watches firing for domains that have recently
been removed, so dom may be NULL here. */
if (dom && dom->is_dead == false)
- console_create_ring(&dom->console);
+ console_iter_int_arg1(dom, console_create_ring);
}
free(vec);
@@ -963,16 +1138,22 @@ static void handle_hv_logs(xenevtchn_handle *xce_handle,
bool force)
(void)xenevtchn_unmask(xce_handle, port);
}
+static void console_open_log(struct console *con)
+{
+ if (console_enabled(con))
+ {
+ if (con->log_fd != -1)
+ close(con->log_fd);
+ con->log_fd = create_console_log(con);
+ }
+}
+
static void handle_log_reload(void)
{
if (log_guest) {
struct domain *d;
for (d = dom_head; d; d = d->next) {
- struct console *con = &d->console;
-
- if (con->log_fd != -1)
- close(con->log_fd);
- con->log_fd = create_console_log(con);
+ console_iter_void_arg1(d, console_open_log);
}
}
@@ -1024,6 +1205,62 @@ static void reset_fds(void)
memset(fds, 0, sizeof(struct pollfd) * current_array_size);
}
+static void add_console_evtchn_fd(struct console *con, void *data)
+{
+ long long next_timeout = *((long long *)data);
+
+ if (con->event_count >= RATE_LIMIT_ALLOWANCE) {
+ /* Determine if we're going to be the next time slice to expire
*/
+ if (!next_timeout ||
+ con->next_period < next_timeout)
+ next_timeout = con->next_period;
+ } else if (con->xce_handle != NULL) {
+ if (buffer_available(con))
+ {
+ int evtchn_fd = xenevtchn_fd(con->xce_handle);
+ con->xce_pollfd_idx = set_fds(evtchn_fd,
+
POLLIN|POLLPRI);
+ }
+ }
+
+ *((long long *)data) = next_timeout;
+}
+
+static void add_console_tty_fd(struct console *con)
+{
+ if (con->master_fd != -1) {
+ short events = 0;
+ if (!con->d->is_dead && ring_free_bytes(con))
+ events |= POLLIN;
+
+ if (!buffer_empty(&con->buffer))
+ events |= POLLOUT;
+
+ if (events)
+ con->master_pollfd_idx =
+ set_fds(con->master_fd, events|POLLPRI);
+ }
+}
+
+static void handle_console_tty(struct console *con)
+{
+ if (con->master_fd != -1 && con->master_pollfd_idx != -1) {
+ if (fds[con->master_pollfd_idx].revents &
+ ~(POLLIN|POLLOUT|POLLPRI))
+ console_handle_broken_tty(con,
domain_is_valid(con->d->domid));
+ else {
+ if (fds[con->master_pollfd_idx].revents &
+ POLLIN)
+ handle_tty_read(con);
+ if (fds[con->master_pollfd_idx].revents &
+ POLLOUT)
+ handle_tty_write(con);
+ }
+ }
+ con->master_pollfd_idx = -1;
+ con->xce_pollfd_idx = -1;
+}
+
void handle_io(void)
{
int ret;
@@ -1081,55 +1318,11 @@ void handle_io(void)
/* Re-calculate any event counter allowances & unblock
domains with new allowance */
for (d = dom_head; d; d = d->next) {
- struct console *con = &d->console;
-
- /* CS 16257:955ee4fa1345 introduces a 5ms fuzz
- * for select(), it is not clear poll() has
- * similar behavior (returning a couple of ms
- * sooner than requested) as well. Just leave
- * the fuzz here. Remove it with a separate
- * patch if necessary */
- if ((now+5) > con->next_period) {
- con->next_period = now + RATE_LIMIT_PERIOD;
- if (con->event_count >= RATE_LIMIT_ALLOWANCE) {
- (void)xenevtchn_unmask(con->xce_handle,
con->local_port);
- }
- con->event_count = 0;
- }
- }
- for (d = dom_head; d; d = d->next) {
- struct console *con = &d->console;
-
- if (con->event_count >= RATE_LIMIT_ALLOWANCE) {
- /* Determine if we're going to be the next time
slice to expire */
- if (!next_timeout ||
- con->next_period < next_timeout)
- next_timeout = con->next_period;
- } else if (con->xce_handle != NULL) {
- if (discard_overflowed_data ||
- !con->buffer.max_capacity ||
- con->buffer.size <
con->buffer.max_capacity) {
- int evtchn_fd =
xenevtchn_fd(con->xce_handle);
- con->xce_pollfd_idx = set_fds(evtchn_fd,
-
POLLIN|POLLPRI);
- }
- }
-
- if (con->master_fd != -1) {
- short events = 0;
- if (!d->is_dead && ring_free_bytes(con))
- events |= POLLIN;
-
- if (!buffer_empty(&con->buffer))
- events |= POLLOUT;
-
- if (events)
- con->master_pollfd_idx =
- set_fds(con->master_fd,
- events|POLLPRI);
- }
- }
+ console_iter_void_arg2(d, console_evtchn_unmask, (void
*)now);
+ console_iter_void_arg2(d, add_console_evtchn_fd, (void
*)&next_timeout);
+ console_iter_void_arg1(d, add_console_tty_fd);
+ }
/* If any domain has been rate limited, we need to work
out what timeout to supply to poll */
@@ -1189,35 +1382,11 @@ void handle_io(void)
}
for (d = dom_head; d; d = n) {
- struct console *con = &d->console;
n = d->next;
- if (con->event_count < RATE_LIMIT_ALLOWANCE) {
- if (con->xce_handle != NULL &&
- con->xce_pollfd_idx != -1 &&
- !(fds[con->xce_pollfd_idx].revents &
- ~(POLLIN|POLLOUT|POLLPRI)) &&
- (fds[con->xce_pollfd_idx].revents &
- POLLIN))
- handle_ring_read(d);
- }
-
- if (con->master_fd != -1 && con->master_pollfd_idx !=
-1) {
- if (fds[con->master_pollfd_idx].revents &
- ~(POLLIN|POLLOUT|POLLPRI))
- console_handle_broken_tty(con,
- domain_is_valid(d->domid));
- else {
- if (fds[con->master_pollfd_idx].revents
&
- POLLIN)
- handle_tty_read(con);
- if (fds[con->master_pollfd_idx].revents
&
- POLLOUT)
- handle_tty_write(con);
- }
- }
- con->xce_pollfd_idx = con->master_pollfd_idx = -1;
+ console_iter_void_arg1(d, handle_console_ring);
+ console_iter_void_arg1(d, handle_console_tty);
if (d->last_seen != enum_pass)
shutdown_domain(d);
--
2.7.4
_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxx
https://lists.xen.org/xen-devel
|
 |
Lists.xenproject.org is hosted with RackSpace, monitoring our |