Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-23 04:31:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

dm vdo thread-utils: remove all uds_*_mutex wrappers

Browse Source 
Just use mutex_init, mutex_lock and mutex_unlock.

Signed-off-by: Mike Snitzer <snitzer@kernel.org>
Signed-off-by: Matthew Sakai <msakai@redhat.com>
This commit is contained in:
Mike Snitzer 2024-02-09 12:35:10 -06:00
parent 7f2e494ddd
commit fe6e4ccbe8
5 changed files with 96 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

110
drivers/md/dm-vdo/index-session.c
View File

@ -61,10 +61,10 @@ enum index_session_flag {
/* Release a reference to an index session. */
static void release_index_session(struct uds_index_session *index_session)
{
uds_lock_mutex(&index_session->request_mutex);
mutex_lock(&index_session->request_mutex);
if (--index_session->request_count == 0)
uds_broadcast_cond(&index_session->request_cond);
uds_unlock_mutex(&index_session->request_mutex);
mutex_unlock(&index_session->request_mutex);
}
/*
@ -76,10 +76,10 @@ static int get_index_session(struct uds_index_session *index_session)
unsigned int state;
int result = UDS_SUCCESS;
uds_lock_mutex(&index_session->request_mutex);
mutex_lock(&index_session->request_mutex);
index_session->request_count++;
state = index_session->state;
uds_unlock_mutex(&index_session->request_mutex);
mutex_unlock(&index_session->request_mutex);
if (state == IS_FLAG_LOADED) {
return UDS_SUCCESS;
@ -141,9 +141,9 @@ static void enter_callback_stage(struct uds_request *request)
{
if (request->status != UDS_SUCCESS) {
/* All request errors are considered unrecoverable */
uds_lock_mutex(&request->session->request_mutex);
mutex_lock(&request->session->request_mutex);
request->session->state |= IS_FLAG_DISABLED;
uds_unlock_mutex(&request->session->request_mutex);
mutex_unlock(&request->session->request_mutex);
}
uds_request_queue_enqueue(request->session->callback_queue, request);
@ -224,28 +224,14 @@ static int __must_check make_empty_index_session(struct uds_index_session **inde
if (result != UDS_SUCCESS)
return result;
result = uds_init_mutex(&session->request_mutex);
if (result != UDS_SUCCESS) {
uds_free(session);
return result;
}
mutex_init(&session->request_mutex);
uds_init_cond(&session->request_cond);
result = uds_init_mutex(&session->load_context.mutex);
if (result != UDS_SUCCESS) {
uds_destroy_mutex(&session->request_mutex);
uds_free(session);
return result;
}
mutex_init(&session->load_context.mutex);
uds_init_cond(&session->load_context.cond);
result = uds_make_request_queue("callbackW", &handle_callbacks,
&session->callback_queue);
if (result != UDS_SUCCESS) {
uds_destroy_mutex(&session->load_context.mutex);
uds_destroy_mutex(&session->request_mutex);
uds_free(session);
return result;
}
@ -268,7 +254,7 @@ static int __must_check start_loading_index_session(struct uds_index_session *in
{
int result;
uds_lock_mutex(&index_session->request_mutex);
mutex_lock(&index_session->request_mutex);
if (index_session->state & IS_FLAG_SUSPENDED) {
uds_log_info("Index session is suspended");
result = -EBUSY;
@ -279,20 +265,20 @@ static int __must_check start_loading_index_session(struct uds_index_session *in
index_session->state |= IS_FLAG_LOADING;
result = UDS_SUCCESS;
}
uds_unlock_mutex(&index_session->request_mutex);
mutex_unlock(&index_session->request_mutex);
return result;
}
static void finish_loading_index_session(struct uds_index_session *index_session,
int result)
{
uds_lock_mutex(&index_session->request_mutex);
mutex_lock(&index_session->request_mutex);
index_session->state &= ~IS_FLAG_LOADING;
if (result == UDS_SUCCESS)
index_session->state |= IS_FLAG_LOADED;
uds_broadcast_cond(&index_session->request_cond);
uds_unlock_mutex(&index_session->request_mutex);
mutex_unlock(&index_session->request_mutex);
}
static int initialize_index_session(struct uds_index_session *index_session,
@ -376,12 +362,12 @@ int uds_open_index(enum uds_open_index_type open_type,
static void wait_for_no_requests_in_progress(struct uds_index_session *index_session)
{
uds_lock_mutex(&index_session->request_mutex);
mutex_lock(&index_session->request_mutex);
while (index_session->request_count > 0) {
uds_wait_cond(&index_session->request_cond,
&index_session->request_mutex);
}
uds_unlock_mutex(&index_session->request_mutex);
mutex_unlock(&index_session->request_mutex);
}
static int __must_check save_index(struct uds_index_session *index_session)
@ -392,7 +378,7 @@ static int __must_check save_index(struct uds_index_session *index_session)
static void suspend_rebuild(struct uds_index_session *session)
{
uds_lock_mutex(&session->load_context.mutex);
mutex_lock(&session->load_context.mutex);
switch (session->load_context.status) {
case INDEX_OPENING:
session->load_context.status = INDEX_SUSPENDING;
@ -419,7 +405,7 @@ static void suspend_rebuild(struct uds_index_session *session)
session->load_context.status);
break;
}
uds_unlock_mutex(&session->load_context.mutex);
mutex_unlock(&session->load_context.mutex);
}
/*
@ -433,7 +419,7 @@ int uds_suspend_index_session(struct uds_index_session *session, bool save)
bool rebuilding = false;
/* Wait for any current index state change to complete. */
uds_lock_mutex(&session->request_mutex);
mutex_lock(&session->request_mutex);
while (session->state & IS_FLAG_CLOSING)
uds_wait_cond(&session->request_cond, &session->request_mutex);
@ -453,7 +439,7 @@ int uds_suspend_index_session(struct uds_index_session *session, bool save)
session->state |= IS_FLAG_SUSPENDED;
uds_broadcast_cond(&session->request_cond);
}
uds_unlock_mutex(&session->request_mutex);
mutex_unlock(&session->request_mutex);
if (no_work)
return uds_status_to_errno(result);
@ -465,11 +451,11 @@ int uds_suspend_index_session(struct uds_index_session *session, bool save)
else
result = uds_flush_index_session(session);
uds_lock_mutex(&session->request_mutex);
mutex_lock(&session->request_mutex);
session->state &= ~IS_FLAG_WAITING;
session->state |= IS_FLAG_SUSPENDED;
uds_broadcast_cond(&session->request_cond);
uds_unlock_mutex(&session->request_mutex);
mutex_unlock(&session->request_mutex);
return uds_status_to_errno(result);
}
@ -496,7 +482,7 @@ int uds_resume_index_session(struct uds_index_session *session,
bool no_work = false;
bool resume_replay = false;
uds_lock_mutex(&session->request_mutex);
mutex_lock(&session->request_mutex);
if (session->state & IS_FLAG_WAITING) {
uds_log_info("Index session is already changing state");
no_work = true;
@ -510,7 +496,7 @@ int uds_resume_index_session(struct uds_index_session *session,
if (session->state & IS_FLAG_LOADING)
resume_replay = true;
}
uds_unlock_mutex(&session->request_mutex);
mutex_unlock(&session->request_mutex);
if (no_work)
return result;
@ -518,16 +504,16 @@ int uds_resume_index_session(struct uds_index_session *session,
if ((session->index != NULL) && (bdev != session->parameters.bdev)) {
result = replace_device(session, bdev);
if (result != UDS_SUCCESS) {
uds_lock_mutex(&session->request_mutex);
mutex_lock(&session->request_mutex);
session->state &= ~IS_FLAG_WAITING;
uds_broadcast_cond(&session->request_cond);
uds_unlock_mutex(&session->request_mutex);
mutex_unlock(&session->request_mutex);
return uds_status_to_errno(result);
}
}
if (resume_replay) {
uds_lock_mutex(&session->load_context.mutex);
mutex_lock(&session->load_context.mutex);
switch (session->load_context.status) {
case INDEX_SUSPENDED:
session->load_context.status = INDEX_OPENING;
@ -548,14 +534,14 @@ int uds_resume_index_session(struct uds_index_session *session,
session->load_context.status);
break;
}
uds_unlock_mutex(&session->load_context.mutex);
mutex_unlock(&session->load_context.mutex);
}
uds_lock_mutex(&session->request_mutex);
mutex_lock(&session->request_mutex);
session->state &= ~IS_FLAG_WAITING;
session->state &= ~IS_FLAG_SUSPENDED;
uds_broadcast_cond(&session->request_cond);
uds_unlock_mutex(&session->request_mutex);
mutex_unlock(&session->request_mutex);
return UDS_SUCCESS;
}
@ -568,9 +554,9 @@ static int save_and_free_index(struct uds_index_session *index_session)
if (index == NULL)
return UDS_SUCCESS;
uds_lock_mutex(&index_session->request_mutex);
mutex_lock(&index_session->request_mutex);
suspended = (index_session->state & IS_FLAG_SUSPENDED);
uds_unlock_mutex(&index_session->request_mutex);
mutex_unlock(&index_session->request_mutex);
if (!suspended) {
result = uds_save_index(index);
@ -585,14 +571,14 @@ static int save_and_free_index(struct uds_index_session *index_session)
* Reset all index state that happens to be in the index
* session, so it doesn't affect any future index.
*/
uds_lock_mutex(&index_session->load_context.mutex);
mutex_lock(&index_session->load_context.mutex);
index_session->load_context.status = INDEX_OPENING;
uds_unlock_mutex(&index_session->load_context.mutex);
mutex_unlock(&index_session->load_context.mutex);
uds_lock_mutex(&index_session->request_mutex);
mutex_lock(&index_session->request_mutex);
/* Only the suspend bit will remain relevant. */
index_session->state &= IS_FLAG_SUSPENDED;
uds_unlock_mutex(&index_session->request_mutex);
mutex_unlock(&index_session->request_mutex);
return result;
}
@ -603,7 +589,7 @@ int uds_close_index(struct uds_index_session *index_session)
int result = UDS_SUCCESS;
/* Wait for any current index state change to complete. */
uds_lock_mutex(&index_session->request_mutex);
mutex_lock(&index_session->request_mutex);
while ((index_session->state & IS_FLAG_WAITING) ||
(index_session->state & IS_FLAG_CLOSING)) {
uds_wait_cond(&index_session->request_cond,
@ -620,7 +606,7 @@ int uds_close_index(struct uds_index_session *index_session)
} else {
index_session->state |= IS_FLAG_CLOSING;
}
uds_unlock_mutex(&index_session->request_mutex);
mutex_unlock(&index_session->request_mutex);
if (result != UDS_SUCCESS)
return uds_status_to_errno(result);
@ -629,10 +615,10 @@ int uds_close_index(struct uds_index_session *index_session)
result = save_and_free_index(index_session);
uds_log_debug("Closed index");
uds_lock_mutex(&index_session->request_mutex);
mutex_lock(&index_session->request_mutex);
index_session->state &= ~IS_FLAG_CLOSING;
uds_broadcast_cond(&index_session->request_cond);
uds_unlock_mutex(&index_session->request_mutex);
mutex_unlock(&index_session->request_mutex);
return uds_status_to_errno(result);
}
@ -645,7 +631,7 @@ int uds_destroy_index_session(struct uds_index_session *index_session)
uds_log_debug("Destroying index session");
/* Wait for any current index state change to complete. */
uds_lock_mutex(&index_session->request_mutex);
mutex_lock(&index_session->request_mutex);
while ((index_session->state & IS_FLAG_WAITING) ||
(index_session->state & IS_FLAG_CLOSING)) {
uds_wait_cond(&index_session->request_cond,
@ -653,7 +639,7 @@ int uds_destroy_index_session(struct uds_index_session *index_session)
}
if (index_session->state & IS_FLAG_DESTROYING) {
uds_unlock_mutex(&index_session->request_mutex);
mutex_unlock(&index_session->request_mutex);
uds_log_info("Index session is already closing");
return -EBUSY;
}
@ -661,32 +647,30 @@ int uds_destroy_index_session(struct uds_index_session *index_session)
index_session->state |= IS_FLAG_DESTROYING;
load_pending = ((index_session->state & IS_FLAG_LOADING) &&
(index_session->state & IS_FLAG_SUSPENDED));
uds_unlock_mutex(&index_session->request_mutex);
mutex_unlock(&index_session->request_mutex);
if (load_pending) {
/* Tell the index to terminate the rebuild. */
uds_lock_mutex(&index_session->load_context.mutex);
mutex_lock(&index_session->load_context.mutex);
if (index_session->load_context.status == INDEX_SUSPENDED) {
index_session->load_context.status = INDEX_FREEING;
uds_broadcast_cond(&index_session->load_context.cond);
}
uds_unlock_mutex(&index_session->load_context.mutex);
mutex_unlock(&index_session->load_context.mutex);
/* Wait until the load exits before proceeding. */
uds_lock_mutex(&index_session->request_mutex);
mutex_lock(&index_session->request_mutex);
while (index_session->state & IS_FLAG_LOADING) {
uds_wait_cond(&index_session->request_cond,
&index_session->request_mutex);
}
uds_unlock_mutex(&index_session->request_mutex);
mutex_unlock(&index_session->request_mutex);
}
wait_for_no_requests_in_progress(index_session);
result = save_and_free_index(index_session);
uds_request_queue_finish(index_session->callback_queue);
index_session->callback_queue = NULL;
uds_destroy_mutex(&index_session->load_context.mutex);
uds_destroy_mutex(&index_session->request_mutex);
uds_log_debug("Destroyed index session");
uds_free(index_session);
return uds_status_to_errno(result);
@ -747,8 +731,8 @@ void uds_wait_cond(struct cond_var *cv, struct mutex *mutex)
DEFINE_WAIT(__wait);
prepare_to_wait(&cv->wait_queue, &__wait, TASK_IDLE);
uds_unlock_mutex(mutex);
mutex_unlock(mutex);
schedule();
finish_wait(&cv->wait_queue, &__wait);
uds_lock_mutex(mutex);
mutex_lock(mutex);
}

42
drivers/md/dm-vdo/index.c
View File

@ -180,11 +180,11 @@ static int finish_previous_chapter(struct uds_index *index, u64 current_chapter_
int result;
struct chapter_writer *writer = index->chapter_writer;
uds_lock_mutex(&writer->mutex);
mutex_lock(&writer->mutex);
while (index->newest_virtual_chapter < current_chapter_number)
uds_wait_cond(&writer->cond, &writer->mutex);
result = writer->result;
uds_unlock_mutex(&writer->mutex);
mutex_unlock(&writer->mutex);
if (result != UDS_SUCCESS)
return uds_log_error_strerror(result,
@ -219,11 +219,11 @@ static unsigned int start_closing_chapter(struct uds_index *index,
unsigned int finished_zones;
struct chapter_writer *writer = index->chapter_writer;
uds_lock_mutex(&writer->mutex);
mutex_lock(&writer->mutex);
finished_zones = ++writer->zones_to_write;
writer->chapters[zone_number] = chapter;
uds_broadcast_cond(&writer->cond);
uds_unlock_mutex(&writer->mutex);
mutex_unlock(&writer->mutex);
return finished_zones;
}
@ -678,7 +678,7 @@ static void close_chapters(void *arg)
struct uds_index *index = writer->index;
uds_log_debug("chapter writer starting");
uds_lock_mutex(&writer->mutex);
mutex_lock(&writer->mutex);
for (;;) {
while (writer->zones_to_write < index->zone_count) {
if (writer->stop && (writer->zones_to_write == 0)) {
@ -686,7 +686,7 @@ static void close_chapters(void *arg)
* We've been told to stop, and all of the zones are in the same
* open chapter, so we can exit now.
*/
uds_unlock_mutex(&writer->mutex);
mutex_unlock(&writer->mutex);
uds_log_debug("chapter writer stopping");
return;
}
@ -698,7 +698,7 @@ static void close_chapters(void *arg)
* it seems safer in principle. It's OK to access the chapter and chapter_number
* fields without the lock since those aren't allowed to change until we're done.
*/
uds_unlock_mutex(&writer->mutex);
mutex_unlock(&writer->mutex);
if (index->has_saved_open_chapter) {
/*
@ -719,7 +719,7 @@ static void close_chapters(void *arg)
writer->collated_records,
index->newest_virtual_chapter);
uds_lock_mutex(&writer->mutex);
mutex_lock(&writer->mutex);
index->newest_virtual_chapter++;
index->oldest_virtual_chapter +=
uds_chapters_to_expire(index->volume->geometry,
@ -734,14 +734,14 @@ static void stop_chapter_writer(struct chapter_writer *writer)
{
struct thread *writer_thread = NULL;
uds_lock_mutex(&writer->mutex);
mutex_lock(&writer->mutex);
if (writer->thread != NULL) {
writer_thread = writer->thread;
writer->thread = NULL;
writer->stop = true;
uds_broadcast_cond(&writer->cond);
}
uds_unlock_mutex(&writer->mutex);
mutex_unlock(&writer->mutex);
if (writer_thread != NULL)
uds_join_threads(writer_thread);
@ -753,7 +753,6 @@ static void free_chapter_writer(struct chapter_writer *writer)
return;
stop_chapter_writer(writer);
uds_destroy_mutex(&writer->mutex);
uds_free_open_chapter_index(writer->open_chapter_index);
uds_free(writer->collated_records);
uds_free(writer);
@ -774,12 +773,7 @@ static int make_chapter_writer(struct uds_index *index,
return result;
writer->index = index;
result = uds_init_mutex(&writer->mutex);
if (result != UDS_SUCCESS) {
uds_free(writer);
return result;
}
mutex_init(&writer->mutex);
uds_init_cond(&writer->cond);
result = uds_allocate_cache_aligned(collated_records_size, "collated records",
@ -957,9 +951,9 @@ static bool check_for_suspend(struct uds_index *index)
if (index->load_context == NULL)
return false;
uds_lock_mutex(&index->load_context->mutex);
mutex_lock(&index->load_context->mutex);
if (index->load_context->status != INDEX_SUSPENDING) {
uds_unlock_mutex(&index->load_context->mutex);
mutex_unlock(&index->load_context->mutex);
return false;
}
@ -972,7 +966,7 @@ static bool check_for_suspend(struct uds_index *index)
uds_wait_cond(&index->load_context->cond, &index->load_context->mutex);
closing = (index->load_context->status == INDEX_FREEING);
uds_unlock_mutex(&index->load_context->mutex);
mutex_unlock(&index->load_context->mutex);
return closing;
}
@ -1261,14 +1255,14 @@ int uds_make_index(struct uds_configuration *config, enum uds_open_index_type op
}
if (index->load_context != NULL) {
uds_lock_mutex(&index->load_context->mutex);
mutex_lock(&index->load_context->mutex);
index->load_context->status = INDEX_READY;
/*
* If we get here, suspend is meaningless, but notify any thread trying to suspend
* us so it doesn't hang.
*/
uds_broadcast_cond(&index->load_context->cond);
uds_unlock_mutex(&index->load_context->mutex);
mutex_unlock(&index->load_context->mutex);
}
index->has_saved_open_chapter = loaded;
@ -1307,10 +1301,10 @@ void uds_wait_for_idle_index(struct uds_index *index)
{
struct chapter_writer *writer = index->chapter_writer;
uds_lock_mutex(&writer->mutex);
mutex_lock(&writer->mutex);
while (writer->zones_to_write > 0)
uds_wait_cond(&writer->cond, &writer->mutex);
uds_unlock_mutex(&writer->mutex);
mutex_unlock(&writer->mutex);
}
/* This function assumes that all requests have been drained. */

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

@ -26,27 +26,4 @@ void uds_perform_once(atomic_t *once_state, void (*function) (void));
int uds_join_threads(struct thread *thread);
/* FIXME: all below wrappers should be removed! */
static inline int __must_check uds_init_mutex(struct mutex *mutex)
{
mutex_init(mutex);
return UDS_SUCCESS;
}
static inline int uds_destroy_mutex(struct mutex *mutex)
{
return UDS_SUCCESS;
}
static inline void uds_lock_mutex(struct mutex *mutex)
{
mutex_lock(mutex);
}
static inline void uds_unlock_mutex(struct mutex *mutex)
{
mutex_unlock(mutex);
}
#endif /* UDS_THREADS_H */

40
drivers/md/dm-vdo/volume-index.c
View File

@ -286,13 +286,8 @@ void uds_free_volume_index(struct volume_index *volume_index)
if (volume_index == NULL)
return;
if (volume_index->zones != NULL) {
unsigned int zone;
for (zone = 0; zone < volume_index->zone_count; zone++)
uds_destroy_mutex(&volume_index->zones[zone].hook_mutex);
if (volume_index->zones != NULL)
uds_free(uds_forget(volume_index->zones));
}
uninitialize_volume_sub_index(&volume_index->vi_non_hook);
uninitialize_volume_sub_index(&volume_index->vi_hook);
@ -546,10 +541,10 @@ int uds_get_volume_index_record(struct volume_index *volume_index,
get_volume_sub_index_zone(&volume_index->vi_hook, name);
struct mutex *mutex = &volume_index->zones[zone].hook_mutex;
uds_lock_mutex(mutex);
mutex_lock(mutex);
result = get_volume_sub_index_record(&volume_index->vi_hook, name,
record);
uds_unlock_mutex(mutex);
mutex_unlock(mutex);
/* Remember the mutex so that other operations on the index record can use it. */
record->mutex = mutex;
} else {
@ -578,13 +573,13 @@ int uds_put_volume_index_record(struct volume_index_record *record, u64 virtual_
}
address = extract_address(sub_index, record->name);
if (unlikely(record->mutex != NULL))
uds_lock_mutex(record->mutex);
mutex_lock(record->mutex);
result = uds_put_delta_index_entry(&record->delta_entry, address,
convert_virtual_to_index(sub_index,
virtual_chapter),
record->is_found ? record->name->name : NULL);
if (unlikely(record->mutex != NULL))
uds_unlock_mutex(record->mutex);
mutex_unlock(record->mutex);
switch (result) {
case UDS_SUCCESS:
record->virtual_chapter = virtual_chapter;
@ -614,10 +609,10 @@ int uds_remove_volume_index_record(struct volume_index_record *record)
/* Mark the record so that it cannot be used again */
record->is_found = false;
if (unlikely(record->mutex != NULL))
uds_lock_mutex(record->mutex);
mutex_lock(record->mutex);
result = uds_remove_delta_index_entry(&record->delta_entry);
if (unlikely(record->mutex != NULL))
uds_unlock_mutex(record->mutex);
mutex_unlock(record->mutex);
return result;
}
@ -688,10 +683,10 @@ void uds_set_volume_index_zone_open_chapter(struct volume_index *volume_index,
* chapter number is changing.
*/
if (has_sparse(volume_index)) {
uds_lock_mutex(mutex);
mutex_lock(mutex);
set_volume_sub_index_zone_open_chapter(&volume_index->vi_hook,
zone_number, virtual_chapter);
uds_unlock_mutex(mutex);
mutex_unlock(mutex);
}
}
@ -730,12 +725,12 @@ int uds_set_volume_index_record_chapter(struct volume_index_record *record,
}
if (unlikely(record->mutex != NULL))
uds_lock_mutex(record->mutex);
mutex_lock(record->mutex);
result = uds_set_delta_entry_value(&record->delta_entry,
convert_virtual_to_index(sub_index,
virtual_chapter));
if (unlikely(record->mutex != NULL))
uds_unlock_mutex(record->mutex);
mutex_unlock(record->mutex);
if (result != UDS_SUCCESS)
return result;
@ -785,9 +780,9 @@ u64 uds_lookup_volume_index_name(const struct volume_index *volume_index,
if (!uds_is_volume_index_sample(volume_index, name))
return NO_CHAPTER;
uds_lock_mutex(mutex);
mutex_lock(mutex);
virtual_chapter = lookup_volume_sub_index_name(&volume_index->vi_hook, name);
uds_unlock_mutex(mutex);
mutex_unlock(mutex);
return virtual_chapter;
}
@ -1258,13 +1253,8 @@ int uds_make_volume_index(const struct uds_configuration *config, u64 volume_non
return result;
}
for (zone = 0; zone < config->zone_count; zone++) {
result = uds_init_mutex(&volume_index->zones[zone].hook_mutex);
if (result != UDS_SUCCESS) {
uds_free_volume_index(volume_index);
return result;
}
}
for (zone = 0; zone < config->zone_count; zone++)
mutex_init(&volume_index->zones[zone].hook_mutex);
split_configuration(config, &split);
result = initialize_volume_sub_index(&split.non_hook_config, volume_nonce, 'd',

38
drivers/md/dm-vdo/volume.c
View File

@ -554,7 +554,7 @@ static int process_entry(struct volume *volume, struct queued_read *entry)
page = select_victim_in_cache(&volume->page_cache);
uds_unlock_mutex(&volume->read_threads_mutex);
mutex_unlock(&volume->read_threads_mutex);
page_data = dm_bufio_read(volume->client, page_number, &page->buffer);
if (IS_ERR(page_data)) {
result = -PTR_ERR(page_data);
@ -564,7 +564,7 @@ static int process_entry(struct volume *volume, struct queued_read *entry)
cancel_page_in_cache(&volume->page_cache, page_number, page);
return result;
}
uds_lock_mutex(&volume->read_threads_mutex);
mutex_lock(&volume->read_threads_mutex);
if (entry->invalid) {
uds_log_warning("Page %u invalidated after read", page_number);
@ -626,7 +626,7 @@ static void read_thread_function(void *arg)
struct volume *volume = arg;
uds_log_debug("reader starting");
uds_lock_mutex(&volume->read_threads_mutex);
mutex_lock(&volume->read_threads_mutex);
while (true) {
struct queued_read *queue_entry;
int result;
@ -638,7 +638,7 @@ static void read_thread_function(void *arg)
result = process_entry(volume, queue_entry);
release_queued_requests(volume, queue_entry, result);
}
uds_unlock_mutex(&volume->read_threads_mutex);
mutex_unlock(&volume->read_threads_mutex);
uds_log_debug("reader done");
}
@ -769,7 +769,7 @@ static int get_volume_page_protected(struct volume *volume, struct uds_request *
/* Prepare to enqueue a read for the page. */
end_pending_search(&volume->page_cache, request->zone_number);
uds_lock_mutex(&volume->read_threads_mutex);
mutex_lock(&volume->read_threads_mutex);
/*
* Do the lookup again while holding the read mutex (no longer the fast case so this should
@ -787,7 +787,7 @@ static int get_volume_page_protected(struct volume *volume, struct uds_request *
* turns out to be significant in some cases. The page is not available yet so
* the order does not matter for correctness as it does below.
*/
uds_unlock_mutex(&volume->read_threads_mutex);
mutex_unlock(&volume->read_threads_mutex);
begin_pending_search(&volume->page_cache, physical_page,
request->zone_number);
return UDS_QUEUED;
@ -799,7 +799,7 @@ static int get_volume_page_protected(struct volume *volume, struct uds_request *
* the caller gets to look at it.
*/
begin_pending_search(&volume->page_cache, physical_page, request->zone_number);
uds_unlock_mutex(&volume->read_threads_mutex);
mutex_unlock(&volume->read_threads_mutex);
*page_ptr = page;
return UDS_SUCCESS;
}
@ -810,9 +810,9 @@ static int get_volume_page(struct volume *volume, u32 chapter, u32 page_number,
int result;
u32 physical_page = map_to_physical_page(volume->geometry, chapter, page_number);
uds_lock_mutex(&volume->read_threads_mutex);
mutex_lock(&volume->read_threads_mutex);
result = get_volume_page_locked(volume, physical_page, page_ptr);
uds_unlock_mutex(&volume->read_threads_mutex);
mutex_unlock(&volume->read_threads_mutex);
return result;
}
@ -1053,10 +1053,10 @@ void uds_forget_chapter(struct volume *volume, u64 virtual_chapter)
u32 i;
uds_log_debug("forgetting chapter %llu", (unsigned long long) virtual_chapter);
uds_lock_mutex(&volume->read_threads_mutex);
mutex_lock(&volume->read_threads_mutex);
for (i = 0; i < volume->geometry->pages_per_chapter; i++)
invalidate_page(&volume->page_cache, first_page + i);
uds_unlock_mutex(&volume->read_threads_mutex);
mutex_unlock(&volume->read_threads_mutex);
}
/*
@ -1141,10 +1141,10 @@ static int write_index_pages(struct volume *volume, u32 physical_chapter_number,
physical_chapter_number, index_page_number,
delta_list_number - 1);
uds_lock_mutex(&volume->read_threads_mutex);
mutex_lock(&volume->read_threads_mutex);
result = donate_index_page_locked(volume, physical_chapter_number,
index_page_number, page_buffer);
uds_unlock_mutex(&volume->read_threads_mutex);
mutex_unlock(&volume->read_threads_mutex);
if (result != UDS_SUCCESS) {
dm_bufio_release(page_buffer);
return result;
@ -1621,12 +1621,7 @@ int uds_make_volume(const struct uds_configuration *config, struct index_layout
return result;
}
result = uds_init_mutex(&volume->read_threads_mutex);
if (result != UDS_SUCCESS) {
uds_free_volume(volume);
return result;
}
mutex_init(&volume->read_threads_mutex);
uds_init_cond(&volume->read_threads_read_done_cond);
uds_init_cond(&volume->read_threads_cond);
@ -1675,10 +1670,10 @@ void uds_free_volume(struct volume *volume)
unsigned int i;
/* This works even if some threads weren't started. */
uds_lock_mutex(&volume->read_threads_mutex);
mutex_lock(&volume->read_threads_mutex);
volume->read_threads_exiting = true;
uds_broadcast_cond(&volume->read_threads_cond);
uds_unlock_mutex(&volume->read_threads_mutex);
mutex_unlock(&volume->read_threads_mutex);
for (i = 0; i < volume->read_thread_count; i++)
uds_join_threads(volume->reader_threads[i]);
uds_free(volume->reader_threads);
@ -1691,7 +1686,6 @@ void uds_free_volume(struct volume *volume)
if (volume->client != NULL)
dm_bufio_client_destroy(uds_forget(volume->client));
uds_destroy_mutex(&volume->read_threads_mutex);
uds_free_index_page_map(volume->index_page_map);
uds_free_radix_sorter(volume->radix_sorter);
uds_free(volume->geometry);