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>
/* 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);
}
/*
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;
{
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);
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;
}
{
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;
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,
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)
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;
session->load_context.status);
break;
}
- uds_unlock_mutex(&session->load_context.mutex);
+ mutex_unlock(&session->load_context.mutex);
}
/*
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);
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);
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);
}
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;
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;
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;
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;
}
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);
* 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;
}
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,
} 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);
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);
}
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,
}
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;
}
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);
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);
}
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,
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;
}
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)) {
* 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;
}
* 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) {
/*
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,
{
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);
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);
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",
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;
}
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;
}
}
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;
{
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. */
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 */
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);
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 {
}
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;
/* 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;
}
* 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);
}
}
}
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;
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;
}
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',
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);
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);
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;
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");
}
/* 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
* 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;
* 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;
}
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;
}
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);
}
/*
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;
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);
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);
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);
projects / thirdparty / linux.git / commitdiff
