dm vdo: remove vdo_perform_once

Remove obsolete function vdo_perform_once. Instead, initialize
necessary module state when loading the module.

Signed-off-by: Matthew Sakai <[e-mail]>
Signed-off-by: Mike Snitzer <[e-mail]>

drivers/md/dm-vdo/dm-vdo-target.c

···
 #include "string-utils.h"
 #include "thread-device.h"
 #include "thread-registry.h"
+#include "thread-utils.h"
 #include "types.h"
 #include "vdo.h"
 #include "vio.h"
···
 
 	/* Memory tracking must be initialized first for accurate accounting. */
 	vdo_memory_init();
+	vdo_initialize_threads_mutex();
 	vdo_initialize_thread_device_registry();
 	vdo_initialize_device_registry_once();
 	vdo_log_info("loaded version %s", CURRENT_VERSION);

drivers/md/dm-vdo/status-codes.c

···
 	{ "VDO_INVALID_ADMIN_STATE", "Invalid operation for current state" },
 };
 
-static atomic_t vdo_status_codes_registered = ATOMIC_INIT(0);
-static int status_code_registration_result;
-
-static void do_status_code_registration(void)
+/**
+ * vdo_register_status_codes() - Register the VDO status codes.
+ * Return: A success or error code.
+ */
+int vdo_register_status_codes(void)
 {
 	int result;
 
···
 	result = uds_register_error_block("VDO Status", VDO_STATUS_CODE_BASE,
 					  VDO_STATUS_CODE_BLOCK_END, vdo_status_list,
 					  sizeof(vdo_status_list));
-	/*
-	 * The following test handles cases where libvdo is statically linked against both the test
-	 * modules and the test driver (because multiple instances of this module call their own
-	 * copy of this function once each, resulting in multiple calls to register_error_block
-	 * which is shared in libuds).
-	 */
-	if (result == UDS_DUPLICATE_NAME)
-		result = UDS_SUCCESS;
-
-	status_code_registration_result = (result == UDS_SUCCESS) ? VDO_SUCCESS : result;
-}
-
-/**
- * vdo_register_status_codes() - Register the VDO status codes if needed.
- * Return: A success or error code.
- */
-int vdo_register_status_codes(void)
-{
-	vdo_perform_once(&vdo_status_codes_registered, do_status_code_registration);
-	return status_code_registration_result;
+	return (result == UDS_SUCCESS) ? VDO_SUCCESS : result;
 }
 
 /**

drivers/md/dm-vdo/thread-utils.c

···
 
 static struct hlist_head thread_list;
 static struct mutex thread_mutex;
-static atomic_t thread_once = ATOMIC_INIT(0);
 
 struct thread {
 	void (*thread_function)(void *thread_data);
···
 	struct completion thread_done;
 };
 
-#define ONCE_NOT_DONE 0
-#define ONCE_IN_PROGRESS 1
-#define ONCE_COMPLETE 2
-
-/* Run a function once only, and record that fact in the atomic value. */
-void vdo_perform_once(atomic_t *once, void (*function)(void))
-{
-	for (;;) {
-		switch (atomic_cmpxchg(once, ONCE_NOT_DONE, ONCE_IN_PROGRESS)) {
-		case ONCE_NOT_DONE:
-			function();
-			atomic_set_release(once, ONCE_COMPLETE);
-			return;
-		case ONCE_IN_PROGRESS:
-			cond_resched();
-			break;
-		case ONCE_COMPLETE:
-			return;
-		default:
-			return;
-		}
-	}
-}
-
-static void thread_init(void)
+void vdo_initialize_threads_mutex(void)
 {
 	mutex_init(&thread_mutex);
 }
···
 	struct thread *thread = arg;
 
 	thread->thread_task = current;
-	vdo_perform_once(&thread_once, thread_init);
 	mutex_lock(&thread_mutex);
 	hlist_add_head(&thread->thread_links, &thread_list);
 	mutex_unlock(&thread_mutex);

drivers/md/dm-vdo/thread-utils.h

···
 
 struct thread;
 
-
+void vdo_initialize_threads_mutex(void);
 int __must_check vdo_create_thread(void (*thread_function)(void *), void *thread_data,
 				   const char *name, struct thread **new_thread);
 void vdo_join_threads(struct thread *thread);
-
-void vdo_perform_once(atomic_t *once_state, void (*function) (void));
 
 #endif /* UDS_THREADS_H */