|
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [Xen-changelog] [xen-3.4-testing] xenstore: Make sure that libxs reports an error if xenstored drops
# HG changeset patch
# User Keir Fraser <keir.fraser@xxxxxxxxxx>
# Date 1275994822 -3600
# Node ID c4b9a16c20a2f8795d3be0b03387c2d2f7c02e4b
# Parent 2bbaf4e06c1d406c7fc5cba3cb53cfdc355aef70
xenstore: Make sure that libxs reports an error if xenstored drops
the connection, rather than getting stuck forever.
Patch from: Steven Smith <steven.smith@xxxxxxxxxxxxx>
Signed-off-by: Tim Deegan <Tim.Deegan@xxxxxxxxxx>
xen-unstable changeset: 21463:5be2d2a7f445
xen-unstable date: Thu May 27 08:20:26 2010 +0100
xenstore: Fix cleanup_pop() definition for some (buggy) pthread.h headers.
Signed-off-by: Keir Fraser <keir.fraser@xxxxxxxxxx>
xen-unstable changeset: 21374:9d53864d7be6
xen-unstable date: Thu May 13 12:21:16 2010 +0100
xs: avoid pthread_join deadlock in xs_daemon_close
Doing a pthread_cancel and join on the reader thread while holding all
the request/reply/watch mutexes can deadlock if the thread needs to
take any of those mutexes to exit. Kill off the reader thread before
taking any mutexes (which should be redundant if we're
single-threaded at that point).
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@xxxxxxxxxx>
xen-unstable changeset: 21354:9de69d816b11
xen-unstable date: Wed May 12 08:49:13 2010 +0100
xs: make sure mutexes are cleaned up and memory freed if the read
thread is cancelled
If the read thread is terminated with pthread cancel, it must make
sure all memory is freed and mutexes are unlocked.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@xxxxxxxxxx>
xen-unstable changeset: 21353:2dd3141b3e3e
xen-unstable date: Wed May 12 08:48:14 2010 +0100
---
tools/xenstore/xs.c | 104 ++++++++++++++++++++++++++++++++++++++--------------
1 files changed, 77 insertions(+), 27 deletions(-)
diff -r 2bbaf4e06c1d -r c4b9a16c20a2 tools/xenstore/xs.c
--- a/tools/xenstore/xs.c Fri Jun 04 10:52:01 2010 +0100
+++ b/tools/xenstore/xs.c Tue Jun 08 12:00:22 2010 +0100
@@ -85,6 +85,16 @@ struct xs_handle {
#define mutex_unlock(m) pthread_mutex_unlock(m)
#define condvar_signal(c) pthread_cond_signal(c)
#define condvar_wait(c,m,hnd) pthread_cond_wait(c,m)
+#define cleanup_push(f, a) \
+ pthread_cleanup_push((void (*)(void *))(f), (void *)(a))
+/*
+ * Some definitions of pthread_cleanup_pop() are a macro starting with an
+ * end-brace. GCC then complains if we immediately precede that with a label.
+ * Hence we insert a dummy statement to appease the compiler in this situation.
+ */
+#define cleanup_pop(run) ((void)0); pthread_cleanup_pop(run)
+
+#define read_thread_exists(h) (h->read_thr_exists)
static void *read_thread(void *arg);
@@ -102,6 +112,9 @@ struct xs_handle {
#define mutex_unlock(m) ((void)0)
#define condvar_signal(c) ((void)0)
#define condvar_wait(c,m,hnd) read_message(hnd)
+#define cleanup_push(f, a) ((void)0)
+#define cleanup_pop(run) ((void)0)
+#define read_thread_exists(h) (0)
#endif
@@ -227,17 +240,16 @@ void xs_daemon_close(struct xs_handle *h
{
struct xs_stored_msg *msg, *tmsg;
+#ifdef USE_PTHREAD
+ if (h->read_thr_exists) {
+ pthread_cancel(h->read_thr);
+ pthread_join(h->read_thr, NULL);
+ }
+#endif
+
mutex_lock(&h->request_mutex);
mutex_lock(&h->reply_mutex);
mutex_lock(&h->watch_mutex);
-
-#ifdef USE_PTHREAD
- if (h->read_thr_exists) {
- /* XXX FIXME: May leak an unpublished message buffer. */
- pthread_cancel(h->read_thr);
- pthread_join(h->read_thr, NULL);
- }
-#endif
list_for_each_entry_safe(msg, tmsg, &h->reply_list, list) {
free(msg->body);
@@ -307,16 +319,25 @@ static void *read_reply(
{
struct xs_stored_msg *msg;
char *body;
+ int read_from_thread;
+
+ read_from_thread = read_thread_exists(h);
#ifdef USE_PTHREAD
/* Read from comms channel ourselves if there is no reader thread. */
- if (!h->read_thr_exists && (read_message(h) == -1))
+ if (!read_from_thread && (read_message(h) == -1))
return NULL;
#endif
mutex_lock(&h->reply_mutex);
- while (list_empty(&h->reply_list))
+ while (list_empty(&h->reply_list) && (!read_from_thread ||
read_thread_exists(h)))
condvar_wait(&h->reply_condvar, &h->reply_mutex, h);
+ if (read_from_thread && !read_thread_exists(h)) {
+ mutex_unlock(&h->reply_mutex);
+ errno = EINVAL;
+ return NULL;
+ }
+ assert(!list_empty(&h->reply_list));
msg = list_top(&h->reply_list, struct xs_stored_msg, list);
list_del(&msg->list);
assert(list_empty(&h->reply_list));
@@ -624,8 +645,13 @@ char **xs_read_watch(struct xs_handle *h
mutex_lock(&h->watch_mutex);
/* Wait on the condition variable for a watch to fire. */
- while (list_empty(&h->watch_list))
+ while (list_empty(&h->watch_list) && read_thread_exists(h))
condvar_wait(&h->watch_condvar, &h->watch_mutex, h);
+ if (!read_thread_exists(h)) {
+ mutex_unlock(&h->watch_mutex);
+ errno = EINVAL;
+ return NULL;
+ }
msg = list_top(&h->watch_list, struct xs_stored_msg, list);
list_del(&msg->list);
@@ -846,44 +872,53 @@ static int read_message(struct xs_handle
{
struct xs_stored_msg *msg = NULL;
char *body = NULL;
- int saved_errno;
+ int saved_errno = 0;
+ int ret = -1;
/* Allocate message structure and read the message header. */
msg = malloc(sizeof(*msg));
if (msg == NULL)
goto error;
- if (!read_all(h->fd, &msg->hdr, sizeof(msg->hdr)))
- goto error;
+ cleanup_push(free, msg);
+ if (!read_all(h->fd, &msg->hdr, sizeof(msg->hdr))) { /* Cancellation
point */
+ saved_errno = errno;
+ goto error_freemsg;
+ }
/* Allocate and read the message body. */
body = msg->body = malloc(msg->hdr.len + 1);
if (body == NULL)
- goto error;
- if (!read_all(h->fd, body, msg->hdr.len))
- goto error;
+ goto error_freemsg;
+ cleanup_push(free, body);
+ if (!read_all(h->fd, body, msg->hdr.len)) { /* Cancellation point */
+ saved_errno = errno;
+ goto error_freebody;
+ }
+
body[msg->hdr.len] = '\0';
if (msg->hdr.type == XS_WATCH_EVENT) {
mutex_lock(&h->watch_mutex);
+ cleanup_push(pthread_mutex_unlock, &h->watch_mutex);
/* Kick users out of their select() loop. */
if (list_empty(&h->watch_list) &&
(h->watch_pipe[1] != -1))
- while (write(h->watch_pipe[1], body, 1) != 1)
+ while (write(h->watch_pipe[1], body, 1) != 1) /*
Cancellation point */
continue;
list_add_tail(&msg->list, &h->watch_list);
condvar_signal(&h->watch_condvar);
- mutex_unlock(&h->watch_mutex);
+ cleanup_pop(1);
} else {
mutex_lock(&h->reply_mutex);
/* There should only ever be one response pending! */
if (!list_empty(&h->reply_list)) {
mutex_unlock(&h->reply_mutex);
- goto error;
+ goto error_freebody;
}
list_add_tail(&msg->list, &h->reply_list);
@@ -892,14 +927,16 @@ static int read_message(struct xs_handle
mutex_unlock(&h->reply_mutex);
}
- return 0;
-
- error:
- saved_errno = errno;
- free(msg);
- free(body);
+ ret = 0;
+
+error_freebody:
+ cleanup_pop(ret == -1);
+error_freemsg:
+ cleanup_pop(ret == -1);
+error:
errno = saved_errno;
- return -1;
+
+ return ret;
}
#ifdef USE_PTHREAD
@@ -909,6 +946,19 @@ static void *read_thread(void *arg)
while (read_message(h) != -1)
continue;
+
+ /* Kick anyone waiting for a reply */
+ pthread_mutex_lock(&h->request_mutex);
+ h->read_thr_exists = 0;
+ pthread_mutex_unlock(&h->request_mutex);
+
+ pthread_mutex_lock(&h->reply_mutex);
+ pthread_cond_signal(&h->reply_condvar);
+ pthread_mutex_unlock(&h->reply_mutex);
+
+ pthread_mutex_lock(&h->watch_mutex);
+ pthread_cond_signal(&h->watch_condvar);
+ pthread_mutex_unlock(&h->watch_mutex);
return NULL;
}
_______________________________________________
Xen-changelog mailing list
Xen-changelog@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-changelog
|
 |
Lists.xenproject.org is hosted with RackSpace, monitoring our |