mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2025-04-09 14:45:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

dm vdo: remove vdo_perform_once

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

Signed-off-by: Matthew Sakai <msakai@redhat.com>
Signed-off-by: Mike Snitzer <snitzer@kernel.org>
This commit is contained in:
Matthew Sakai 2024-03-01 18:29:05 -05:00 committed by Mike Snitzer
parent d0464d8287
commit 7eb30fe18f
4 changed files with 10 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/md/dm-vdo/dm-vdo-target.c
View File

@ -34,6 +34,7 @@
#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"
@ -2872,6 +2873,7 @@ static int __init vdo_init(void)
/* 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);

30
drivers/md/dm-vdo/status-codes.c
View File

@ -40,10 +40,11 @@ const struct error_info vdo_status_list[] = {
{ "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;
@ -53,26 +54,7 @@ static void do_status_code_registration(void)
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;
}
/**

28
drivers/md/dm-vdo/thread-utils.c
View File

@ -17,7 +17,6 @@
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);
@ -27,31 +26,7 @@ struct thread {
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);
}
@ -62,7 +37,6 @@ static int thread_starter(void *arg)
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);

4
drivers/md/dm-vdo/thread-utils.h
View File

@ -12,11 +12,9 @@
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 */