Re: [PATCH 4/4] net/tls: implement ->read_sock()

Hannes Reinecke
2023-06-21T09:08:37Z

On 6/21/23 10:39, Sagi Grimberg wrote:
>
>>> On Tue, 20 Jun 2023 16:21:22 +0300 Sagi Grimberg wrote:
>>>>> +    err = tls_rx_reader_lock(sk, ctx, true);
>>>>> +    if (err < 0)
>>>>> +        return err;
>>>>
>>>> Unlike recvmsg or splice_read, the caller of read_sock is assumed to
>>>> have the socket locked, and tls_rx_reader_lock also calls lock_sock,
>>>> how is this not a deadlock?
>>>
>>> Yeah :|
>>>
>>>> I'm not exactly clear why the lock is needed here or what is the subtle
>>>> distinction between tls_rx_reader_lock and what lock_sock provides.
>>>
>>> It's a bit of a workaround for the consistency of the data stream.
>>> There's bunch of state in the TLS ULP and waiting for mem or data
>>> releases and re-takes the socket lock. So to stop the flow annoying
>>> corner case races I slapped a lock around all of the reader.
>>>
>>> IMHO depending on the socket lock for anything non-trivial and outside
>>> of the socket itself is a bad idea in general.
>>>
>>> The immediate need at the time was that if you did a read() and someone
>>> else did a peek() at the same time from a stream of A B C D you may read
>>> A D B C.
>>
>> Leaving me ever so confused.
>>
>> read_sock() is a generic interface; we cannot require a protocol
>> specific lock before calling it.
>>
>> What to do now?
>> Drop the tls_rx_read_lock from read_sock() again?
>
> Probably just need to synchronize the readers by splitting that from
> tls_rx_reader_lock:
> --
> diff --git a/net/tls/tls_sw.c b/net/tls/tls_sw.c
> index 53f944e6d8ef..53404c3fdcc6 100644
> --- a/net/tls/tls_sw.c
> +++ b/net/tls/tls_sw.c
> @@ -1845,13 +1845,10 @@ tls_read_flush_backlog(struct sock *sk, struct
> tls_prot_info *prot,
>         return sk_flush_backlog(sk);
>  }
>
> -static int tls_rx_reader_lock(struct sock *sk, struct tls_sw_context_rx
> *ctx,
> -                             bool nonblock)
> +static int tls_rx_reader_acquire(struct sock *sk, struct
> tls_sw_context_rx *ctx,
> +                            bool nonblock)
>  {
>         long timeo;
> -       int err;
> -
> -       lock_sock(sk);
>
>         timeo = sock_rcvtimeo(sk, nonblock);
>
> @@ -1865,26 +1862,30 @@ static int tls_rx_reader_lock(struct sock *sk,
> struct tls_sw_context_rx *ctx,
>                               !READ_ONCE(ctx->reader_present), &wait);
>                 remove_wait_queue(&ctx->wq, &wait);
>
> -               if (timeo <= 0) {
> -                       err = -EAGAIN;
> -                       goto err_unlock;
> -               }
> -               if (signal_pending(current)) {
> -                       err = sock_intr_errno(timeo);
> -                       goto err_unlock;
> -               }
> +               if (timeo <= 0)
> +                       return -EAGAIN;
> +               if (signal_pending(current))
> +                       return sock_intr_errno(timeo);
>         }
>
>         WRITE_ONCE(ctx->reader_present, 1);
>
>         return 0;
> +}
>
> -err_unlock:
> -       release_sock(sk);
> +static int tls_rx_reader_lock(struct sock *sk, struct tls_sw_context_rx
> *ctx,
> +                             bool nonblock)
> +{
> +       int err;
> +
> +       lock_sock(sk);
> +       err = tls_rx_reader_acquire(sk, ctx, nonblock);
> +       if (err)
> +               release_sock(sk);
>         return err;
>  }
>
> -static void tls_rx_reader_unlock(struct sock *sk, struct
> tls_sw_context_rx *ctx)
> +static void tls_rx_reader_release(struct sock *sk, struct
> tls_sw_context_rx *ctx)
>  {
>         if (unlikely(ctx->reader_contended)) {
>                 if (wq_has_sleeper(&ctx->wq))
> @@ -1896,6 +1897,11 @@ static void tls_rx_reader_unlock(struct sock *sk,
> struct tls_sw_context_rx *ctx)
>         }
>
>         WRITE_ONCE(ctx->reader_present, 0);
> +}
> +
> +static void tls_rx_reader_unlock(struct sock *sk, struct
> tls_sw_context_rx *ctx)
> +{
> +       tls_rx_reader_release(sk, ctx);
>         release_sock(sk);
>  }
> --
>
> Then read_sock can just acquire/release.

Good suggestion.
Will be including it in the next round.

Cheers,

Hannes