From 5206f05fdf77bb65c125ddb133cf46a59608c671 Mon Sep 17 00:00:00 2001 From: Andrew Opalach Date: Tue, 24 Dec 2024 14:52:51 -0500 Subject: Bring in line with dependency changes Signed-off-by: Andrew Opalach --- src/cache/handlers/cdio.c | 20 +++++++-------- src/cache/handlers/cdio.h | 6 ++--- src/cache/handlers/file.c | 2 +- src/cache/handlers/http.c | 62 +++++++++++++++++++++++------------------------ src/cache/handlers/http.h | 12 ++++----- 5 files changed, 50 insertions(+), 52 deletions(-) (limited to 'src/cache/handlers') diff --git a/src/cache/handlers/cdio.c b/src/cache/handlers/cdio.c index 23f87b6..b10bbf1 100644 --- a/src/cache/handlers/cdio.c +++ b/src/cache/handlers/cdio.c @@ -31,7 +31,7 @@ static bool handler_cdio_can_seek(struct cch_handler *handler) return true; } -static aki_thread_result AKI_THREADCALL cd_read_thread(void *userdata) +static nn_thread_result NNWT_THREADCALL cd_read_thread(void *userdata) { struct cch_handler_cdio *cdio = (struct cch_handler_cdio *)userdata; while (1) { @@ -41,7 +41,7 @@ static aki_thread_result AKI_THREADCALL cd_read_thread(void *userdata) } // cdio_read() here can block for a very long time so we buffer each read // before writing it to the backing. - long ret = cdio_cddap_read(cdio->drive, aki_buffer_get_ptr(&cdio->buffer, 0), cdio->sector, SECTORS_PER_STEP); + long ret = cdio_cddap_read(cdio->drive, nn_buffer_get_ptr(&cdio->buffer, 0), cdio->sector, SECTORS_PER_STEP); cdio_log_messages(cdio); al_assert(ret <= SECTORS_PER_STEP); off_t pointer = cdio->sector * CDIO_CD_FRAMESIZE_RAW; @@ -53,7 +53,7 @@ static aki_thread_result AKI_THREADCALL cd_read_thread(void *userdata) break; } if (ret == SECTORS_PER_STEP) { - al_memcpy(ptr, aki_buffer_get_ptr(&cdio->buffer, 0), BYTES_PER_STEP); + al_memcpy(ptr, nn_buffer_get_ptr(&cdio->buffer, 0), BYTES_PER_STEP); } else if (ret == -10) { al_log_error("cdio", "I/O error, skipping sector."); al_memset(ptr, 0, BYTES_PER_STEP); @@ -86,12 +86,12 @@ static void handler_cdio_maybe_spawn_worker(struct cch_handler *handler, size_t if (cdio->start == (lsn_t)index) return; if (al_atomic_load(s32)(&cdio->running, AL_ATOMIC_ACQUIRE)) { al_atomic_store(s32)(&cdio->running, 0, AL_ATOMIC_RELEASE); - aki_thread_join(&cdio->thread); + nn_thread_join(&cdio->thread); } cdio->start = index; cdio->sector = cdio->start; al_atomic_store(s32)(&cdio->running, 1, AL_ATOMIC_RELEASE); - aki_thread_create(&cdio->thread, cd_read_thread, cdio); + nn_thread_create(&cdio->thread, cd_read_thread, cdio); } static bool handler_cdio_wait_for_range(struct cch_handler *handler, struct cch_handler_wait *wait) @@ -106,7 +106,7 @@ static void handler_cdio_free(struct cch_handler **handler) cch_threaded_waits_disable_all(&cdio->handler); if (al_atomic_load(s32)(&cdio->running, AL_ATOMIC_RELAXED)) { al_atomic_store(s32)(&cdio->running, 0, AL_ATOMIC_RELAXED); - aki_thread_join(&cdio->thread); + nn_thread_join(&cdio->thread); } if (cdio->drive) { cdio_log_messages(cdio); @@ -189,7 +189,7 @@ struct cch_entry *cch_handler_cdio_create(void) entry->ref_count = 0; entry->unknown_size = false; entry->hash = 0; - aki_mutex_init(&entry->mutex); + nn_mutex_init(&entry->mutex); entry->handler->can_seek = handler_cdio_can_seek; entry->handler->maybe_spawn_worker = handler_cdio_maybe_spawn_worker; entry->handler->wait_for_range = handler_cdio_wait_for_range; @@ -198,9 +198,9 @@ struct cch_entry *cch_handler_cdio_create(void) al_str_from(&entry->handler->liana, "cdio"); if (!open_cd_drive(cdio)) return NULL; al_atomic_store(s32)(&cdio->running, 0, AL_ATOMIC_RELAXED); - aki_buffer_init(&cdio->buffer); - aki_buffer_ensure_space(&cdio->buffer, BYTES_PER_STEP); - aki_buffer_set_size(&cdio->buffer, BYTES_PER_STEP); + nn_buffer_init(&cdio->buffer); + nn_buffer_ensure_space(&cdio->buffer, BYTES_PER_STEP); + nn_buffer_set_size(&cdio->buffer, BYTES_PER_STEP); cch_threaded_waits_init(&cdio->handler); return entry; } diff --git a/src/cache/handlers/cdio.h b/src/cache/handlers/cdio.h index 953c988..3a3966a 100644 --- a/src/cache/handlers/cdio.h +++ b/src/cache/handlers/cdio.h @@ -1,5 +1,5 @@ #include -#include +#include #include #include @@ -13,9 +13,9 @@ struct cch_handler_cdio { lsn_t start; lsn_t end; lsn_t sector; + struct nn_buffer buffer; atomic(s32) running; - struct aki_thread thread; - struct aki_buffer buffer; + struct nn_thread thread; }; struct cch_entry *cch_handler_cdio_create(void); diff --git a/src/cache/handlers/file.c b/src/cache/handlers/file.c index 03e2814..c09aac0 100644 --- a/src/cache/handlers/file.c +++ b/src/cache/handlers/file.c @@ -42,7 +42,7 @@ struct cch_entry *cch_handler_file_create(str *path) entry->ref_count = 0; entry->unknown_size = false; entry->hash = 0; - aki_mutex_init(&entry->mutex); + nn_mutex_init(&entry->mutex); entry->handler->can_seek = handler_file_can_seek; entry->handler->maybe_spawn_worker = handler_file_maybe_spawn_worker; entry->handler->wait_for_range = handler_file_wait_for_range; diff --git a/src/cache/handlers/http.c b/src/cache/handlers/http.c index 71ae186..308633e 100644 --- a/src/cache/handlers/http.c +++ b/src/cache/handlers/http.c @@ -21,39 +21,37 @@ static size_t http_callback(void *userdata, u8 op, u8 *buf, s64 int0) struct cch_handler_http *http = (struct cch_handler_http *)userdata; size_t ret = (size_t)int0; switch (op) { - case AKI_HTTP_FINISHED: { - al_log_debug("cache_handler_http", "Transfer finished."); - break; - } - case AKI_HTTP_ERROR: { - cch_threaded_waits_disable_all(&http->handler); + case NNWT_HTTP_READ: + al_assert_and_return(0); + case NNWT_HTTP_WRITE: { + // If we got data before a Content-Length, assume the size is unknown. + if (cch_entry_get_size(http->handler.entry) < 0) { + cch_entry_set_size(http->handler.entry, 0); + } + http->backing->write(http->backing, buf, http->pointer, &ret); + http->pointer += ret; + cch_threaded_waits_evaluate(&http->handler, http->backing); break; } - case AKI_HTTP_RESPONSE_CODE: { + case NNWT_HTTP_RESPONSE_CODE: al_log_debug("cache_handler_http", "HTTP %ld.", int0); break; - } - case AKI_HTTP_REDIRECT: { - al_log_debug("cache_handler_http", "Redirect."); - break; - } - case AKI_HTTP_CONTENT_LENGTH: { + case NNWT_HTTP_CONTENT_LENGTH: { off_t content_length = (off_t)int0; al_log_debug("cache_handler_http", "Content-Length: %lld.", content_length); cch_entry_set_size(http->handler.entry, content_length); cch_threaded_waits_signal_any(&http->handler); break; } - case AKI_HTTP_WRITE: { - // If we got data before a Content-Length, assume the size is unknown. - if (cch_entry_get_size(http->handler.entry) < 0) { - cch_entry_set_size(http->handler.entry, 0); - } - http->backing->write(http->backing, buf, http->pointer, &ret); - http->pointer += ret; - cch_threaded_waits_evaluate(&http->handler, http->backing); + case NNWT_HTTP_REDIRECT: + al_log_debug("cache_handler_http", "Redirect %ld.", int0); + break; + case NNWT_HTTP_FINISHED: + al_log_debug("cache_handler_http", "Transfer finished."); + break; + case NNWT_HTTP_ERROR: + cch_threaded_waits_disable_all(&http->handler); break; - } default: break; } @@ -64,12 +62,12 @@ static void handler_http_maybe_spawn_worker(struct cch_handler *handler, size_t { struct cch_handler_http *http = (struct cch_handler_http *)handler; (void)index; - al_array_push(http->requests, (struct aki_http){ 0 }); - struct aki_http *request = &al_array_last(http->requests); - aki_http_init(request); - aki_http_set_url(request, &http->url); - aki_http_set_user_agent(request, USER_AGENT); - aki_http_request_stream(request, AKI_HTTP_GET, http->loop, http_callback, http); + al_array_push(http->requests, (struct nn_http){ 0 }); + struct nn_http *request = &al_array_last(http->requests); + nn_http_init(request); + nn_http_set_url(request, &http->url); + nn_http_set_user_agent(request, USER_AGENT); + nn_http_request_stream(request, NNWT_HTTP_GET, http->loop, http_callback, http); } static bool handler_http_wait_for_range(struct cch_handler *handler, struct cch_handler_wait *wait) @@ -82,9 +80,9 @@ static void handler_http_free(struct cch_handler **handler) { struct cch_handler_http *http = (struct cch_handler_http *)*handler; cch_threaded_waits_disable_all(&http->handler); - struct aki_http *request; + struct nn_http *request; al_array_foreach_ptr(http->requests, i, request) { - aki_http_close(request); + nn_http_close(request); } cch_threaded_waits_close(&http->handler); al_array_free(http->requests); @@ -94,7 +92,7 @@ static void handler_http_free(struct cch_handler **handler) *handler = NULL; } -struct cch_entry *cch_handler_http_create(str *url, struct aki_event_loop *loop) +struct cch_entry *cch_handler_http_create(str *url, struct nn_event_loop *loop) { struct cch_backing *backing = cch_backing_memory_create(1024 * 128); if (!backing) return NULL; @@ -106,7 +104,7 @@ struct cch_entry *cch_handler_http_create(str *url, struct aki_event_loop *loop) entry->ref_count = 0; entry->unknown_size = false; entry->hash = 0; - aki_mutex_init(&entry->mutex); + nn_mutex_init(&entry->mutex); entry->handler->can_seek = handler_http_can_seek; entry->handler->maybe_spawn_worker = handler_http_maybe_spawn_worker; entry->handler->wait_for_range = handler_http_wait_for_range; diff --git a/src/cache/handlers/http.h b/src/cache/handlers/http.h index 5f9df86..ef47173 100644 --- a/src/cache/handlers/http.h +++ b/src/cache/handlers/http.h @@ -1,8 +1,8 @@ #pragma once -#include -#include -#include +#include +#include +#include #include "../handler.h" #include "../entry.h" @@ -12,8 +12,8 @@ struct cch_handler_http { struct cch_backing *backing; str url; off_t pointer; - array(struct aki_http) requests; - struct aki_event_loop *loop; + array(struct nn_http) requests; + struct nn_event_loop *loop; }; -struct cch_entry *cch_handler_http_create(str *url, struct aki_event_loop *loop); +struct cch_entry *cch_handler_http_create(str *url, struct nn_event_loop *loop); -- cgit v1.2.3-101-g0448