From f5c2470e2cd8d3c3e3665b28e3f4123184d77c3a Mon Sep 17 00:00:00 2001 From: Remi Tricot-Le Breton Date: Tue, 28 Nov 2023 17:08:56 +0100 Subject: [PATCH] BUG/MINOR: cache: Remove incomplete entries from the cache when stream is closed When a stream is interrupted by the client before the full answer is stored in the cache, we end up with an incomplete entry in the cache that cannot be overwritten until it "naturally" expires. In such a case, we call the cache filter's cache_store_strm_deinit callback without ever calling cache_store_http_end which means that the 'complete' flag is never set on the concerned cache_entry. This patch adds a check on the 'complete' flag in the strm_deinit callback and removes the entry from the cache if it is incomplete. A way to exhibit this bug is to try to get the same "big" response on multiple clients at the same time thanks to h2load for instance, and to interrupt the client side before the answer can be fully stored in the cache. This patch can be backported up to 2.4 but it will need some rework starting with branch 2.8 because of the latest cache changes. (cherry picked from commit 23c810d04244166a1a205de510b898cf8bba2a5c) [cf: Adapted for 2.8] Signed-off-by: Christopher Faulet --- src/cache.c | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/cache.c b/src/cache.c index 8118387c9f7d..d3bf8dd07d12 100644 --- a/src/cache.c +++ b/src/cache.c @@ -536,7 +536,17 @@ cache_store_strm_deinit(struct stream *s, struct filter *filter) /* Everything should be released in the http_end filter, but we need to do it * there too, in case of errors */ if (st && st->first_block) { + struct cache_entry *object = (struct cache_entry *)st->first_block->data; + shctx_lock(shctx); + if (!object->complete) { + /* The stream was closed but the 'complete' flag was not + * set which means that cache_store_http_end was not + * called. The stream must have been closed before we + * could store the full answer in the cache. + */ + delete_entry(object); + } shctx_row_dec_hot(shctx, st->first_block); shctx_unlock(shctx); }