On 2024-02-13 14:31, Eric Dumazet wrote:On Tue, Feb 13, 2024 at 7:39 PM Paolo Abeni<pabeni(a)redhat.com> wrote:I wonder if the following could be acceptable: if (flags & MSG_PEEK) sk_peek_offset_fwd(sk, used); else if (peek_offset > 0) sk_peek_offset_bwd(sk, used); peek_offset is already present in the data cache, and if it has the value zero it means either that that sk->sk_peek_off is unused (-1) or actually is zero. Either way, no rewind is needed in that case. ///jonOn Tue, 2024-02-13 at 16:49 +0100, Eric Dumazet wrote:I was trying to avoid using an extra storage, I was not trying to implement the alternative myself :0) If the recvmsg( MSG_PEEK) is supposed to auto-advance the peek_offset, we probably need more than a mere 32bit field.On Tue, Feb 13, 2024 at 4:28 PM Paolo Abeni<pabeni(a)redhat.com> wrote:I feel like there is some misunderstanding, or at least I can't follow. Let me be more verbose, to try to clarify my reasoning. Two consecutive recvmsg(MSG_PEEK) calls for TCP after SO_PEEK_OFF will return adjacent data. AFAICS this is the same semantic currently implemented by UDP and unix sockets. Currently 'sk_peek_off' maintains the next offset to be peeked into the current receive queue. To implement the above behaviour, tcp_recvmsg() has to update 'sk_peek_off' after MSG_PEEK, to move the offset to the next data, and after a plain read, to account for the data removed from the receive queue. I proposed to let introduce a tcp-specific set_peek_off doing something alike: WRTIE_ONCE(sk->sk_peek_off, tcp_sk(sk)->copied_seq + val); so that the recvmsg will need to update sk_peek_off only for MSG_PEEK, while retaining the semantic described above. To keep the userspace interface unchanged that will need a paired tcp_get_peek_off(), so that getsockopt(SO_PEEK_OFF) could return to the user a plain offset. An additional bit flag will be needed to store the information "the user-space enabled peek with offset". I don't understand how a setsockopt(PEEK_OFFSET) variant would help avoiding touching sk->sk_peek_offset?On Tue, 2024-02-13 at 14:34 +0100, Eric Dumazet wrote: > This sk_peek_offset protocol, needing sk_peek_offset_bwd() in the non > MSG_PEEK case is very strange IMO. > > Ideally, we should read/write over sk_peek_offset only when MSG_PEEK > is used by the caller. > > That would only touch non fast paths. > > Since the API is mono-threaded anyway, the caller should not rely on > the fact that normal recvmsg() call > would 'consume' sk_peek_offset. Storing in sk_peek_seq the tcp next sequence number to be peeked should avoid changes in the non MSG_PEEK cases. AFAICS that would need a new get_peek_off() sock_op and a bit somewhere (in sk_flags?) to discriminate when sk_peek_seq is actually set. Would that be acceptable?We could have a parallel SO_PEEK_OFFSET option, reusing the same socket field. The new semantic would be : Supported by TCP (so far), and tcp recvmsg() only reads/writes this field when MSG_PEEK is used. Applications would have to clear the values themselves.> Thanks! > > Paolo >