On 1/9/26 08:22, Michael S. Tsirkin wrote:
> On Wed, Jan 07, 2026 at 10:04:41PM +0100, Simon Schippers wrote:
>> This proposed function checks whether __ptr_ring_zero_tail() was invoked
>> within the last n calls to __ptr_ring_consume(), which indicates that new
>> free space was created. Since __ptr_ring_zero_tail() moves the tail to
>> the head - and no other function modifies either the head or the tail,
>> aside from the wrap-around case described below - detecting such a
>> movement is sufficient to detect the invocation of
>> __ptr_ring_zero_tail().
>>
>> The implementation detects this movement by checking whether the tail is
>> at most n positions behind the head. If this condition holds, the shift
>> of the tail to its current position must have occurred within the last n
>> calls to __ptr_ring_consume(), indicating that __ptr_ring_zero_tail() was
>> invoked and that new free space was created.
>>
>> This logic also correctly handles the wrap-around case in which
>> __ptr_ring_zero_tail() is invoked and the head and the tail are reset
>> to 0. Since this reset likewise moves the tail to the head, the same
>> detection logic applies.
>>
>> Co-developed-by: Tim Gebauer <[email protected]>
>> Signed-off-by: Tim Gebauer <[email protected]>
>> Signed-off-by: Simon Schippers <[email protected]>
>> ---
>> include/linux/ptr_ring.h | 13 +++++++++++++
>> 1 file changed, 13 insertions(+)
>>
>> diff --git a/include/linux/ptr_ring.h b/include/linux/ptr_ring.h
>> index a5a3fa4916d3..7cdae6d1d400 100644
>> --- a/include/linux/ptr_ring.h
>> +++ b/include/linux/ptr_ring.h
>> @@ -438,6 +438,19 @@ static inline int ptr_ring_consume_batched_bh(struct
>> ptr_ring *r,
>> return ret;
>> }
>>
>> +/* Returns true if the consume of the last n elements has created space
>> + * in the ring buffer (i.e., a new element can be produced).
>> + *
>> + * Note: Because of batching, a successful call to __ptr_ring_consume() /
>> + * __ptr_ring_consume_batched() does not guarantee that the next call to
>> + * __ptr_ring_produce() will succeed.
>
>
> I think the issue is it does not say what is the actual guarantee.
>
> Another issue is that the "Note" really should be more prominent,
> it really is part of explaining what the functions does.
>
> Hmm. Maybe we should tell it how many entries have been consumed and
> get back an indication of how much space this created?
>
> fundamentally
> n - (r->consumer_head - r->consumer_tail)?
No, that is wrong from my POV.
It always creates the same amount of space which is the batch size or
multiple batch sizes (or something less in the wrap-around case). That is
of course only if __ptr_ring_zero_tail() was executed at least once,
else it creates zero space.
>
>
> does the below sound good maybe?
>
> /* Returns the amound of space (number of new elements that can be
> * produced) that calls to ptr_ring_consume created.
> *
> * Getting n entries from calls to ptr_ring_consume() /
> * ptr_ring_consume_batched() does *not* guarantee that the next n calls to
> * ptr_ring_produce() will succeed.
> *
> * Use this function after consuming n entries to get a hint about
> * how much space was actually created.
>
>
>
>
>
>> + */
>> +static inline bool __ptr_ring_consume_created_space(struct ptr_ring *r,
>> + int n)
>> +{
>> + return r->consumer_head - r->consumer_tail < n;
>> +}
>> +
>> /* Cast to structure type and call a function without discarding from FIFO.
>> * Function must return a value.
>> * Callers must take consumer_lock.
>> --
>> 2.43.0
>
