- take advantage of the new EVENT_FD_AUTOCLOSE flag

- use the tdb_chainlock_mark() call to allow us to guarantee forward progress in the ctdb_lockwait code

diff --git a/common/ctdb_daemon.c b/common/ctdb_daemon.c
index 616a7bc4b3d6441d51c602bdc34e55c2fcbddd93..476f34d0a7d263b1303055bfd061cada868e1161 100644 (file)
--- a/common/ctdb_daemon.c
+++ b/common/ctdb_daemon.c
@@ -249,8 +249,6 @@ static int ctdb_client_destructor(struct ctdb_client *client)
 {
        ctdb_reqid_remove(client->ctdb, client->client_id);
        client->ctdb->status.num_clients--;
-       close(client->fd);
-       client->fd = -1;
        return 0;
 }
 
@@ -678,8 +676,8 @@ int ctdb_start(struct ctdb_context *ctdb)
 
 
        ctdb->ev = event_context_init(NULL);
-       fde = event_add_fd(ctdb->ev, ctdb, fd[0], EVENT_FD_READ, ctdb_read_from_parent, &fd[0]);
-       fde = event_add_fd(ctdb->ev, ctdb, ctdb->daemon.sd, EVENT_FD_READ, ctdb_accept_client, ctdb);
+       fde = event_add_fd(ctdb->ev, ctdb, fd[0], EVENT_FD_READ|EVENT_FD_AUTOCLOSE, ctdb_read_from_parent, &fd[0]);
+       fde = event_add_fd(ctdb->ev, ctdb, ctdb->daemon.sd, EVENT_FD_READ|EVENT_FD_AUTOCLOSE, ctdb_accept_client, ctdb);
        ctdb_main_loop(ctdb);
 
        return 0;
@@ -720,7 +718,7 @@ int ctdb_start_daemon(struct ctdb_context *ctdb)
        talloc_set_destructor(domain_socket_name, unlink_destructor);   
 
        ctdb->ev = event_context_init(NULL);
-       fde = event_add_fd(ctdb->ev, ctdb, ctdb->daemon.sd, EVENT_FD_READ, 
+       fde = event_add_fd(ctdb->ev, ctdb, ctdb->daemon.sd, EVENT_FD_READ|EVENT_FD_AUTOCLOSE, 
                           ctdb_accept_client, ctdb);
        ctdb_main_loop(ctdb);
 

diff --git a/common/ctdb_io.c b/common/ctdb_io.c
index d09339561ae7a1b3bbf91f47ea62415e1a01bc92..872da9670977a77ea1c6b358d1979ccc51589ec9 100644 (file)
--- a/common/ctdb_io.c
+++ b/common/ctdb_io.c
@@ -273,7 +273,7 @@ int ctdb_queue_set_fd(struct ctdb_queue *queue, int fd)
        queue->fde = NULL;
 
        if (fd != -1) {
-               queue->fde = event_add_fd(queue->ctdb->ev, queue, fd, EVENT_FD_READ, 
+               queue->fde = event_add_fd(queue->ctdb->ev, queue, fd, EVENT_FD_READ|EVENT_FD_AUTOCLOSE, 
                                          queue_io_handler, queue);
                if (queue->fde == NULL) {
                        return -1;

diff --git a/common/ctdb_lockwait.c b/common/ctdb_lockwait.c
index d61e12633b7aced109e046bb306d87024d3937dd..470d89d1199db67b4ed039bb87ded1e4b2224e76 100644 (file)
--- a/common/ctdb_lockwait.c
+++ b/common/ctdb_lockwait.c
@@ -29,11 +29,13 @@
 
 struct lockwait_handle {
        struct ctdb_context *ctdb;
+       struct ctdb_db_context *ctdb_db;
        struct fd_event *fde;
        int fd[2];
        pid_t child;
        void *private_data;
        void (*callback)(void *);
+       TDB_DATA key;
        struct timeval start_time;
 };
 
@@ -45,19 +47,30 @@ static void lockwait_handler(struct event_context *ev, struct fd_event *fde,
        void (*callback)(void *) = h->callback;
        void *p = h->private_data;
        pid_t child = h->child;
+       TDB_DATA key = h->key;
+       struct tdb_context *tdb = h->ctdb_db->ltdb->tdb;
+       TALLOC_CTX *tmp_ctx = talloc_new(ev);
+
+       talloc_free(fde);
+
+       key.dptr = talloc_memdup(tmp_ctx, key.dptr, key.dsize);
+
        talloc_set_destructor(h, NULL);
-       close(h->fd[0]);
        ctdb_latency(&h->ctdb->status.max_lockwait_latency, h->start_time);
        h->ctdb->status.pending_lockwait_calls--;
-       talloc_free(h); 
+
+       tdb_chainlock_mark(tdb, key);
        callback(p);
+       tdb_chainlock_unmark(tdb, key);
+
+       kill(child, SIGKILL);
        waitpid(child, NULL, 0);
+       talloc_free(tmp_ctx);
 }
 
 static int lockwait_destructor(struct lockwait_handle *h)
 {
        h->ctdb->status.pending_lockwait_calls--;
-       close(h->fd[0]);
        kill(h->child, SIGKILL);
        waitpid(h->child, NULL, 0);
        return 0;
@@ -84,7 +97,7 @@ struct lockwait_handle *ctdb_lockwait(struct ctdb_db_context *ctdb_db,
        ctdb_db->ctdb->status.lockwait_calls++;
        ctdb_db->ctdb->status.pending_lockwait_calls++;
 
-       if (!(result = talloc_zero(ctdb_db, struct lockwait_handle))) {
+       if (!(result = talloc_zero(private_data, struct lockwait_handle))) {
                ctdb_db->ctdb->status.pending_lockwait_calls--;
                return NULL;
        }
@@ -110,13 +123,15 @@ struct lockwait_handle *ctdb_lockwait(struct ctdb_db_context *ctdb_db,
        result->callback = callback;
        result->private_data = private_data;
        result->ctdb = ctdb_db->ctdb;
+       result->ctdb_db = ctdb_db;
+       result->key = key;
 
        if (result->child == 0) {
+               char c = 0;
                close(result->fd[0]);
-               /*
-                * Do we need a tdb_reopen here?
-                */
                tdb_chainlock(ctdb_db->ltdb->tdb, key);
+               write(result->fd[1], &c, 1);
+               pause();
                _exit(0);
        }
 
@@ -124,7 +139,7 @@ struct lockwait_handle *ctdb_lockwait(struct ctdb_db_context *ctdb_db,
        talloc_set_destructor(result, lockwait_destructor);
 
        result->fde = event_add_fd(ctdb_db->ctdb->ev, result, result->fd[0],
-                                  EVENT_FD_READ, lockwait_handler,
+                                  EVENT_FD_READ|EVENT_FD_AUTOCLOSE, lockwait_handler,
                                   (void *)result);
        if (result->fde == NULL) {
                talloc_free(result);

diff --git a/common/ctdb_ltdb.c b/common/ctdb_ltdb.c
index 312d1b98c3982ffa25fe3046e222b7e21d896083..37f4627c564f1bece03570a3d5f22ede0492025e 100644 (file)
--- a/common/ctdb_ltdb.c
+++ b/common/ctdb_ltdb.c
@@ -193,7 +193,6 @@ static void lock_fetch_callback(void *p)
 {
        struct lock_fetch_state *state = talloc_get_type(p, struct lock_fetch_state);
        state->recv_pkt(state->recv_context, (uint8_t *)state->hdr, state->hdr->length);
-       talloc_free(state);
        DEBUG(2,(__location__ " PACKET REQUEUED\n"));
 }
 
@@ -252,7 +251,7 @@ int ctdb_ltdb_lock_requeue(struct ctdb_db_context *ctdb_db,
                return 0;
        }
 
-       state = talloc(ctdb_db, struct lock_fetch_state);
+       state = talloc(hdr, struct lock_fetch_state);
        state->ctdb = ctdb_db->ctdb;
        state->hdr = hdr;
        state->recv_pkt = recv_pkt;

diff --git a/common/ctdb_traverse.c b/common/ctdb_traverse.c
index c71457d717ed1c188e8688bd0f81506e44fc5a67..383bf3ae6548189b4ab470c0a9c52ba78671f195 100644 (file)
--- a/common/ctdb_traverse.c
+++ b/common/ctdb_traverse.c
@@ -74,7 +74,6 @@ static void ctdb_traverse_local_handler(uint8_t *rawdata, size_t length, void *p
  */
 static int traverse_local_destructor(struct ctdb_traverse_local_handle *h)
 {
-       close(h->fd[0]);
        kill(h->child, SIGKILL);
        waitpid(h->child, NULL, 0);
        return 0;