agora inbox for pgsql-hackers@postgresql.orghelp / color / mirror / Atom feed
[PATCH v5 10/10] Additional validation for buffer in the ring 107+ messages / 2 participants [nested] [flat]
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v5 10/10] Additional validation for buffer in the ring @ 2025-06-11 12:45 Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 0 siblings, 0 replies; 107+ messages in thread From: Ashutosh Bapat @ 2025-06-11 12:45 UTC (permalink / raw) If the buffer pool has been shrunk, the buffers in the buffer list may not be valid anymore. Modify GetBufferFromRing to check if the buffer is still valid before using it. This makes GetBufferFromRing() a bit more expensive because of additional boolean condition. That may not be expensive enough to affect query performance. The alternative to that is more complex as explained below. The strategy object is created in CurrentMemoryContext and is not available in any global structure thus accessible when processing buffer resizing barriers. We may modify GetAccessStrategy() to register strategy in a global linked list and then arrange to deregister it once it's no more in use. Looking at the places which use GetAccessStrategy(), fixing all those may be some work. Ashutosh Bapat --- src/backend/storage/buffer/freelist.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 41641bb3ae6..74d070733a4 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -948,12 +948,13 @@ GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state) strategy->current = 0; /* - * If the slot hasn't been filled yet, tell the caller to allocate a new - * buffer with the normal allocation strategy. He will then fill this - * slot by calling AddBufferToRing with the new buffer. + * If the slot hasn't been filled yet or the buffer in the slot has been + * invalidated when buffer pool was shrunk, tell the caller to allocate a new + * buffer with the normal allocation strategy. He will then fill this slot + * by calling AddBufferToRing with the new buffer. */ bufnum = strategy->buffers[strategy->current]; - if (bufnum == InvalidBuffer) + if (bufnum == InvalidBuffer || bufnum > NBuffers) return NULL; /* -- 2.49.0 --bwrlgp6w2ubxykjq-- ^ permalink raw reply [nested|flat] 107+ messages in thread
* [PATCH v25 2/4] Refactor index_concurrently_create_copy() for use with REPACK (CONCURRENTLY). @ 2025-08-11 13:31 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 107+ messages in thread From: Antonin Houska @ 2025-08-11 13:31 UTC (permalink / raw) This patch moves the code to index_create_copy() and adds a "concurrently" parameter so it can be used by REPACK (CONCURRENTLY). With the CONCURRENTLY option, REPACK cannot simply swap the heap file and rebuild its indexes. Instead, it needs to build a separate set of indexes (including system catalog entries) *before* the actual swap, to reduce the time AccessExclusiveLock needs to be held for. --- src/backend/catalog/index.c | 36 ++++++++++++++++++++++++++++-------- src/include/catalog/index.h | 3 +++ 2 files changed, 31 insertions(+), 8 deletions(-) diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c index 08d4b8e44d7..2b33bf04883 100644 --- a/src/backend/catalog/index.c +++ b/src/backend/catalog/index.c @@ -1290,15 +1290,31 @@ index_create(Relation heapRelation, /* * index_concurrently_create_copy * - * Create concurrently an index based on the definition of the one provided by - * caller. The index is inserted into catalogs and needs to be built later - * on. This is called during concurrent reindex processing. - * - * "tablespaceOid" is the tablespace to use for this index. + * Variant of index_create_copy(), called during concurrent reindex + * processing. */ Oid index_concurrently_create_copy(Relation heapRelation, Oid oldIndexId, Oid tablespaceOid, const char *newName) +{ + return index_create_copy(heapRelation, oldIndexId, tablespaceOid, newName, + true); +} + +/* + * index_create_copy + * + * Create an index based on the definition of the one provided by caller. The + * index is inserted into catalogs and needs to be built later on. + * + * "tablespaceOid" is the tablespace to use for this index. + * + * The actual implementation of index_concurrently_create_copy(), reusable for + * other purposes. + */ +Oid +index_create_copy(Relation heapRelation, Oid oldIndexId, Oid tablespaceOid, + const char *newName, bool concurrently) { Relation indexRelation; IndexInfo *oldInfo, @@ -1317,6 +1333,7 @@ index_concurrently_create_copy(Relation heapRelation, Oid oldIndexId, List *indexColNames = NIL; List *indexExprs = NIL; List *indexPreds = NIL; + int flags = 0; indexRelation = index_open(oldIndexId, RowExclusiveLock); @@ -1325,9 +1342,9 @@ index_concurrently_create_copy(Relation heapRelation, Oid oldIndexId, /* * Concurrent build of an index with exclusion constraints is not - * supported. + * supported. If !concurrently, ii_ExclusinOps is currently not needed. */ - if (oldInfo->ii_ExclusionOps != NULL) + if (oldInfo->ii_ExclusionOps != NULL && concurrently) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("concurrent index creation for exclusion constraints is not supported"))); @@ -1435,6 +1452,9 @@ index_concurrently_create_copy(Relation heapRelation, Oid oldIndexId, stattargets[i].isnull = isnull; } + if (concurrently) + flags = INDEX_CREATE_SKIP_BUILD | INDEX_CREATE_CONCURRENT; + /* * Now create the new index. * @@ -1458,7 +1478,7 @@ index_concurrently_create_copy(Relation heapRelation, Oid oldIndexId, indcoloptions->values, stattargets, reloptionsDatum, - INDEX_CREATE_SKIP_BUILD | INDEX_CREATE_CONCURRENT, + flags, 0, true, /* allow table to be a system catalog? */ false, /* is_internal? */ diff --git a/src/include/catalog/index.h b/src/include/catalog/index.h index dda95e54903..4bf909078d8 100644 --- a/src/include/catalog/index.h +++ b/src/include/catalog/index.h @@ -99,6 +99,9 @@ extern Oid index_concurrently_create_copy(Relation heapRelation, Oid oldIndexId, Oid tablespaceOid, const char *newName); +extern Oid index_create_copy(Relation heapRelation, Oid oldIndexId, + Oid tablespaceOid, const char *newName, + bool concurrently); extern void index_concurrently_build(Oid heapRelationId, Oid indexRelationId); -- 2.47.3 --ecl2euvoqutt27wj Content-Type: text/x-diff; charset=utf-8 Content-Disposition: attachment; filename="v25-0003-Move-conversion-of-a-historic-to-MVCC-snapshot-t.patch" ^ permalink raw reply [nested|flat] 107+ messages in thread
end of thread, other threads:[~2025-08-11 13:31 UTC | newest] Thread overview: 107+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-06-11 12:45 [PATCH v5 10/10] Additional validation for buffer in the ring Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> 2025-08-11 13:31 [PATCH v25 2/4] Refactor index_concurrently_create_copy() for use with REPACK (CONCURRENTLY). Antonin Houska <ah@cybertec.at>
This inbox is served by agora; see mirroring instructions for how to clone and mirror all data and code used for this inbox