core: Rename pollfd_modify counter and its lock to device_close

This counter is now solely used for closing a device, so rename
the variable appropriately.

Signed-off-by: Chris Dickens <christopher.a.dickens@gmail.com>

diff --git a/libusb/core.c b/libusb/core.c
index 997368a..5d1b48d 100644 (file)
--- a/libusb/core.c
+++ b/libusb/core.c
@@ -1399,19 +1399,19 @@ void API_EXPORTED libusb_close(libusb_device_handle *dev_handle)
         * thread from doing event handling) because we will be removing a file
         * descriptor from the polling loop. */
 
-       /* record that we are messing with poll fds */
-       usbi_mutex_lock(&ctx->pollfd_modify_lock);
-       ctx->pollfd_modify++;
-       usbi_mutex_unlock(&ctx->pollfd_modify_lock);
+       /* record that we are closing a device */
+       usbi_mutex_lock(&ctx->device_close_lock);
+       ctx->device_close++;
+       usbi_mutex_unlock(&ctx->device_close_lock);
 
        /* write some data on control pipe to interrupt event handlers */
        r = usbi_write(ctx->ctrl_pipe[1], &dummy, sizeof(dummy));
        if (r <= 0) {
                usbi_warn(ctx, "internal signalling write failed, closing anyway");
                do_close(ctx, dev_handle);
-               usbi_mutex_lock(&ctx->pollfd_modify_lock);
-               ctx->pollfd_modify--;
-               usbi_mutex_unlock(&ctx->pollfd_modify_lock);
+               usbi_mutex_lock(&ctx->device_close_lock);
+               ctx->device_close--;
+               usbi_mutex_unlock(&ctx->device_close_lock);
                return;
        }
 
@@ -1426,10 +1426,10 @@ void API_EXPORTED libusb_close(libusb_device_handle *dev_handle)
        /* Close the device */
        do_close(ctx, dev_handle);
 
-       /* we're done with modifying poll fds */
-       usbi_mutex_lock(&ctx->pollfd_modify_lock);
-       ctx->pollfd_modify--;
-       usbi_mutex_unlock(&ctx->pollfd_modify_lock);
+       /* we're done with closing this device */
+       usbi_mutex_lock(&ctx->device_close_lock);
+       ctx->device_close--;
+       usbi_mutex_unlock(&ctx->device_close_lock);
 
        /* Release event handling lock and wake up event waiters */
        libusb_unlock_events(ctx);

diff --git a/libusb/io.c b/libusb/io.c
index 07010c4..7700e8c 100644 (file)
--- a/libusb/io.c
+++ b/libusb/io.c
@@ -1112,7 +1112,7 @@ int usbi_io_init(struct libusb_context *ctx)
 
        usbi_mutex_init(&ctx->flying_transfers_lock, NULL);
        usbi_mutex_init(&ctx->pollfds_lock, NULL);
-       usbi_mutex_init(&ctx->pollfd_modify_lock, NULL);
+       usbi_mutex_init(&ctx->device_close_lock, NULL);
        usbi_mutex_init_recursive(&ctx->events_lock, NULL);
        usbi_mutex_init(&ctx->event_waiters_lock, NULL);
        usbi_cond_init(&ctx->event_waiters_cond, NULL);
@@ -1173,7 +1173,7 @@ err_close_pipe:
 err:
        usbi_mutex_destroy(&ctx->flying_transfers_lock);
        usbi_mutex_destroy(&ctx->pollfds_lock);
-       usbi_mutex_destroy(&ctx->pollfd_modify_lock);
+       usbi_mutex_destroy(&ctx->device_close_lock);
        usbi_mutex_destroy(&ctx->events_lock);
        usbi_mutex_destroy(&ctx->event_waiters_lock);
        usbi_cond_destroy(&ctx->event_waiters_cond);
@@ -1196,7 +1196,7 @@ void usbi_io_exit(struct libusb_context *ctx)
 #endif
        usbi_mutex_destroy(&ctx->flying_transfers_lock);
        usbi_mutex_destroy(&ctx->pollfds_lock);
-       usbi_mutex_destroy(&ctx->pollfd_modify_lock);
+       usbi_mutex_destroy(&ctx->device_close_lock);
        usbi_mutex_destroy(&ctx->events_lock);
        usbi_mutex_destroy(&ctx->event_waiters_lock);
        usbi_cond_destroy(&ctx->event_waiters_cond);
@@ -1654,13 +1654,13 @@ int API_EXPORTED libusb_try_lock_events(libusb_context *ctx)
        unsigned int ru;
        USBI_GET_CONTEXT(ctx);
 
-       /* is someone else waiting to modify poll fds? if so, don't let this thread
+       /* is someone else waiting to close a device? if so, don't let this thread
         * start event handling */
-       usbi_mutex_lock(&ctx->pollfd_modify_lock);
-       ru = ctx->pollfd_modify;
-       usbi_mutex_unlock(&ctx->pollfd_modify_lock);
+       usbi_mutex_lock(&ctx->device_close_lock);
+       ru = ctx->device_close;
+       usbi_mutex_unlock(&ctx->device_close_lock);
        if (ru) {
-               usbi_dbg("someone else is modifying poll fds");
+               usbi_dbg("someone else is closing a device");
                return 1;
        }
 
@@ -1713,7 +1713,7 @@ void API_EXPORTED libusb_unlock_events(libusb_context *ctx)
 
        /* FIXME: perhaps we should be a bit more efficient by not broadcasting
         * the availability of the events lock when we are modifying pollfds
-        * (check ctx->pollfd_modify)? */
+        * (check ctx->device_close)? */
        usbi_mutex_lock(&ctx->event_waiters_lock);
        usbi_cond_broadcast(&ctx->event_waiters_cond);
        usbi_mutex_unlock(&ctx->event_waiters_lock);
@@ -1745,13 +1745,13 @@ int API_EXPORTED libusb_event_handling_ok(libusb_context *ctx)
        unsigned int r;
        USBI_GET_CONTEXT(ctx);
 
-       /* is someone else waiting to modify poll fds? if so, don't let this thread
+       /* is someone else waiting to close a device? if so, don't let this thread
         * continue event handling */
-       usbi_mutex_lock(&ctx->pollfd_modify_lock);
-       r = ctx->pollfd_modify;
-       usbi_mutex_unlock(&ctx->pollfd_modify_lock);
+       usbi_mutex_lock(&ctx->device_close_lock);
+       r = ctx->device_close;
+       usbi_mutex_unlock(&ctx->device_close_lock);
        if (r) {
-               usbi_dbg("someone else is modifying poll fds");
+               usbi_dbg("someone else is closing a device");
                return 0;
        }
 
@@ -1773,13 +1773,13 @@ int API_EXPORTED libusb_event_handler_active(libusb_context *ctx)
        unsigned int r;
        USBI_GET_CONTEXT(ctx);
 
-       /* is someone else waiting to modify poll fds? if so, don't let this thread
+       /* is someone else waiting to close a device? if so, don't let this thread
         * start event handling -- indicate that event handling is happening */
-       usbi_mutex_lock(&ctx->pollfd_modify_lock);
-       r = ctx->pollfd_modify;
-       usbi_mutex_unlock(&ctx->pollfd_modify_lock);
+       usbi_mutex_lock(&ctx->device_close_lock);
+       r = ctx->device_close;
+       usbi_mutex_unlock(&ctx->device_close_lock);
        if (r) {
-               usbi_dbg("someone else is modifying poll fds");
+               usbi_dbg("someone else is closing a device");
                return 1;
        }
 
@@ -2059,9 +2059,9 @@ redo_poll:
 
                /* read the dummy data from the control pipe unless someone is closing
                 * a device */
-               usbi_mutex_lock(&ctx->pollfd_modify_lock);
-               ru = ctx->pollfd_modify;
-               usbi_mutex_unlock(&ctx->pollfd_modify_lock);
+               usbi_mutex_lock(&ctx->device_close_lock);
+               ru = ctx->device_close;
+               usbi_mutex_unlock(&ctx->device_close_lock);
                if (!ru) {
                        ret = usbi_read(ctx->ctrl_pipe[0], &dummy, sizeof(dummy));
                        if (ret != sizeof(dummy)) {

diff --git a/libusb/libusbi.h b/libusb/libusbi.h
index 98cc4eb..ffca4a3 100644 (file)
--- a/libusb/libusbi.h
+++ b/libusb/libusbi.h
@@ -278,9 +278,9 @@ struct libusb_context {
        usbi_mutex_t pollfds_lock;
 
        /* a counter that is set when we want to interrupt event handling, in order
-        * to modify the poll fd set. and a lock to protect it. */
-       unsigned int pollfd_modify;
-       usbi_mutex_t pollfd_modify_lock;
+        * to safely close a device, and a lock to protect it. */
+       unsigned int device_close;
+       usbi_mutex_t device_close_lock;
 
        /* user callbacks for pollfd changes */
        libusb_pollfd_added_cb fd_added_cb;

diff --git a/libusb/version_nano.h b/libusb/version_nano.h
index b6431e8..2248132 100644 (file)
--- a/libusb/version_nano.h
+++ b/libusb/version_nano.h
@@ -1 +1 @@
-#define LIBUSB_NANO 10931
+#define LIBUSB_NANO 10932