 @@ -1,14 +1,14 @@
-/*	$NetBSD: pthread_tsd.c,v 1.21 2020/04/19 20:46:04 joerg Exp $	*/
+/*	$NetBSD: pthread_tsd.c,v 1.22 2020/04/19 20:47:03 joerg Exp $	*/
 /*-
  * Copyright (c) 2001, 2007 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Nathan J. Williams, by Andrew Doran, and by Christos Zoulas.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -20,27 +20,27 @@
  * ``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 FOUNDATION 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.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: pthread_tsd.c,v 1.21 2020/04/19 20:46:04 joerg Exp $");
+__RCSID("$NetBSD: pthread_tsd.c,v 1.22 2020/04/19 20:47:03 joerg Exp $");
 /* Functions and structures dealing with thread-specific data */
 #include <errno.h>
 #include <sys/mman.h>
 #include "pthread.h"
 #include "pthread_int.h"
 #include "reentrant.h"
 #include "tsd.h"
 int pthread_keys_max;
 static pthread_mutex_t tsd_mutex = PTHREAD_MUTEX_INITIALIZER;
 static int nextkey;
 @@ -163,61 +163,58 @@ pthread_key_create(pthread_key_t *key, v
 	nextkey = (i + 1) % pthread_keys_max;
 	pthread_mutex_unlock(&tsd_mutex);
 	*key = i;
 	return 0;
+}
 /*
  * Each thread holds an array of pthread_keys_max pt_specific list
  * elements. When an element is used it is inserted into the appropriate
  * key bucket of pthread__tsd_list. This means that ptqe_prev == NULL,
  * means that the element is not threaded, ptqe_prev != NULL it is
- * already part of the list. When we set to a NULL value we delete from the
+ * already part of the list. If a key is set to a non-NULL value for the
- * list if it was in the list, and when we set to non-NULL value, we insert
+ * first time, it is added to the list.
  * in the list if it was not already there.
+ *
  * We keep this global array of lists of threads that have called
  * pthread_set_specific with non-null values, for each key so that
  * we don't have to check all threads for non-NULL values in
- * pthread_key_destroy
+ * pthread_key_destroy.
+ *
  * The assumption here is that a concurrent pthread_key_delete is already
  * undefined behavior. The mutex is taken only once per thread/key
  * combination.
+ *
  * We could keep an accounting of the number of specific used
  * entries per thread, so that we can update pt_havespecific when we delete
  * the last one, but we don't bother for now
  */
 int
 pthread__add_specific(pthread_t self, pthread_key_t key, const void *value)
+{
 	struct pt_specific *pt;
 	pthread__assert(key >= 0 && key < pthread_keys_max);
 	pthread_mutex_lock(&tsd_mutex);
 	pthread__assert(pthread__tsd_destructors[key] != NULL);
 	pt = &self->pt_specific[key];
 	self->pt_havespecific = 1;
-	if (value) {
+	if (value && !pt->pts_next.ptqe_prev) {
-		if (pt->pts_next.ptqe_prev == NULL)
+		pthread_mutex_lock(&tsd_mutex);
-			PTQ_INSERT_HEAD(&pthread__tsd_list[key], pt, pts_next);
+		PTQ_INSERT_HEAD(&pthread__tsd_list[key], pt, pts_next);
-	} else {
+		pthread_mutex_unlock(&tsd_mutex);
 		if (pt->pts_next.ptqe_prev != NULL) {
 			PTQ_REMOVE(&pthread__tsd_list[key], pt, pts_next);
 			pt->pts_next.ptqe_prev = NULL;
+	}
 	pt->pts_value = __UNCONST(value);
 	pthread_mutex_unlock(&tsd_mutex);
 	return 0;
+}
 int
 pthread_key_delete(pthread_key_t key)
+{
 	/*
 	 * This is tricky.  The standard says of pthread_key_create()
 	 * that new keys have the value NULL associated with them in
 	 * all threads.  According to people who were present at the
 	 * standardization meeting, that requirement was written
 	 * before pthread_key_delete() was introduced, and not
 @@ -363,27 +360,27 @@ pthread__destroy_tsd(pthread_t self)
 				continue;
 			pthread_mutex_lock(&tsd_mutex);
 			if (pt->pts_next.ptqe_prev != NULL)  {
 				PTQ_REMOVE(&pthread__tsd_list[i], pt, pts_next);
 				val = pt->pts_value;
 				pt->pts_value = NULL;
 				pt->pts_next.ptqe_prev = NULL;
 				destructor = pthread__tsd_destructors[i];
 			} else
 				destructor = NULL;
 			pthread_mutex_unlock(&tsd_mutex);
-			if (destructor != NULL) {
+			if (destructor != NULL && val != NULL) {
 				done = 0;
 				(*destructor)(val);
+			}
+		}
 	} while (!done && --iterations);
 	self->pt_havespecific = 0;
 	pthread_mutex_lock(&self->pt_lock);
+}
 void
 pthread__copy_tsd(pthread_t self)
+{