Received-SPF: pass (google.com: domain of linux-kernel+bounces-68296-linux.lists.archive=gmail.com@vger.kernel.org designates 2604:1380:45d1:ec00::1 as permitted sender) client-ip=2604:1380:45d1:ec00::1;
Precedence: bulk
MIME-Version: 1.0
References: <20240207-fix_sparse_errors_checksum_tests-v6-0-4caa9629705b@rivosinc.com>
 <8dedf370-47e1-405d-85cf-53f3acfa16a0@roeck-us.net> <Zcmr8C1dTuaPvXqJ@ghost> <cbee3cb7-04bc-43bf-95af-774fb72f7905@roeck-us.net>
In-Reply-To: <cbee3cb7-04bc-43bf-95af-774fb72f7905@roeck-us.net>
From: Geert Uytterhoeven <geert@linux-m68k.org>
Date: Fri, 16 Feb 2024 10:01:05 +0100
Message-ID: <CAMuHMdWLQbWPVFaVri6PGPybbVZLunQ6kMUUhEW0KCp8oUMJow@mail.gmail.com>
Subject: Re: [PATCH v6 0/2] lib: checksum: Fix issues with checksum tests
To: Guenter Roeck <linux@roeck-us.net>
Cc: Charlie Jenkins <charlie@rivosinc.com>, David Laight <David.Laight@aculab.com>, 
	Palmer Dabbelt <palmer@dabbelt.com>, Andrew Morton <akpm@linux-foundation.org>, 
	linux-kernel@vger.kernel.org, kernel test robot <lkp@intel.com>
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

Hi G=C3=BCnter,

On Mon, Feb 12, 2024 at 6:13=E2=80=AFPM Guenter Roeck <linux@roeck-us.net> =
wrote:
> On Mon, Feb 12, 2024 at 12:26:08AM -0500, Charlie Jenkins wrote:
> > On Sun, Feb 11, 2024 at 11:18:36AM -0800, Guenter Roeck wrote:
> > > On 2/7/24 16:22, Charlie Jenkins wrote:
> > > > The ip_fast_csum and csum_ipv6_magic tests did not have the data
> > > > types properly casted, and improperly misaligned data.
> > > >
> > > > Signed-off-by: Charlie Jenkins <charlie@rivosinc.com>
> > >
> > > I sorted out most of the problems with this version, but I still get:
> > >
> > >     # test_csum_ipv6_magic: ASSERTION FAILED at lib/checksum_kunit.c:=
513
> > >     Expected ( u64)csum_result =3D=3D ( u64)expected, but
> > >         ( u64)csum_result =3D=3D 16630 (0x40f6)
> > >         ( u64)expected =3D=3D 65535 (0xffff)
> > >     not ok 5 test_csum_ipv6_magic
> > >
> > > on m68k:q800. This is suspicious because there is no 0xffff in
> > > expected_csum_ipv6_magic[]. With some debugging information:
> > >
> > > ####### num_tests=3D86 i=3D84 expect array size=3D84
> > > ####### MAX_LEN=3D512 WORD_ALIGNMENT=3D4 magic data size=3D42
> > >
> > > That means the loop
> > >
> > >     for (int i =3D 0; i < num_tests; i++) {
> > >             ...
> > >             expected =3D (__force __sum16)expected_csum_ipv6_magic[i]=
;
> > >             ...
> > >     }
> > >
> > > will access data beyond the end of the expected_csum_ipv6_magic[] arr=
ay,
> > > possibly because m68k doesn't pad struct csum_ipv6_magic_data to 44 b=
ytes.
> >
> > Okay I will check that out.
> >
> > >
> > > In this context, is the comment about proto having to be 0 really tru=
e ?
> > > It seems to me that the calculated checksum must be identical on both
> > > little and big endian systems. After all, they need to be able to tal=
k
> > > to each other.
> >
> > I agree, but I couldn't find a solution other than setting it to zero.
> > Maybe I am missing something simple...
> >
>
> Try the patch below on top of yours. It should work on both big and littl=
e
> endian systems.
>
> Key changes:
> - use random_buf directly instead of copying anything
> - no need to convert source / destination addresses
> - csum in the buffer is in network byte order and needs
>   to stay that way
> - len in the buffer is in network byte order and needs to be
>   converted to host byte order since that is expected by
>   csum_ipv6_magic()
> - the expected value is in host byte order and needs to be
>   converted to network byte order for comparison
> - protocol is just fine and converted by csum_ipv6_magic()
>   as needed

Thanks for your patch!

> --- a/lib/checksum_kunit.c
> +++ b/lib/checksum_kunit.c

> @@ -465,44 +468,36 @@ static void test_ip_fast_csum(struct kunit *test)
>         }
>  }
>
> +#define IPV6_NUM_TESTS ((MAX_LEN - sizeof(struct in6_addr) * 2 - sizeof(=
int) * 3) / WORD_ALIGNMENT)
> +
>  static void test_csum_ipv6_magic(struct kunit *test)
>  {
>  #if defined(CONFIG_NET)
> +       const struct in6_addr *saddr;
> +       const struct in6_addr *daddr;
> +       unsigned int len;
>         __sum16 csum_result, expected;
> -       struct csum_ipv6_magic_data {
> -               const struct in6_addr saddr;
> -               const struct in6_addr daddr;
> -               unsigned int len;
> -               __wsum csum;
> -               unsigned char proto;
> -       } data, *data_ptr;
> -       int num_tests =3D MAX_LEN / WORD_ALIGNMENT - sizeof(struct csum_i=
pv6_magic_data);
> +       unsigned char proto;
> +       unsigned int csum;
>
> -       for (int i =3D 0; i < num_tests; i++) {
> -               data_ptr =3D (struct csum_ipv6_magic_data *)(random_buf +=
 (i * WORD_ALIGNMENT));
> +       const int daddr_offset =3D sizeof(struct in6_addr);
> +       const int len_offset =3D sizeof(struct in6_addr) + sizeof(struct =
in6_addr);
> +       const int csum_offset =3D sizeof(struct in6_addr) + sizeof(struct=
 in6_addr) +
> +         sizeof(int);
> +       const int proto_offset =3D sizeof(struct in6_addr) + sizeof(struc=
t in6_addr) +
> +         sizeof(int) * 2;

Please no manual offset calculations.
Please fix the csum_ipv6_magic_data structure definition instead.

>
> -               cpu_to_be32_array((__be32 *)&data.saddr, (const u32 *)&da=
ta_ptr->saddr,
> -                                 sizeof_field(struct csum_ipv6_magic_dat=
a, saddr) / 4);
> -               cpu_to_be32_array((__be32 *)&data.daddr, (const u32 *)&da=
ta_ptr->daddr,
> -                                 sizeof_field(struct csum_ipv6_magic_dat=
a, daddr) / 4);
> -               data.len =3D data_ptr->len;
> -               data.csum =3D (__force __wsum)htonl((__force u32)data_ptr=
->csum);
> -               /*
> -                * proto must be zero to be compatible between big-endian=
 and
> -                * little-endian CPUs. On little-endian CPUs, proto is
> -                * converted to a big-endian 32-bit value before the chec=
ksum
> -                * operation. This causes proto to be in the most signifi=
cant
> -                * 8 bits on a little-endian CPU. On big-endian CPUs prot=
o will
> -                * remain in the least significant 8 bits. There does not=
 exist
> -                * a transformation to an arbitrary proto that will allow
> -                * csum_ipv6_magic to return the same value on a big-endi=
an and
> -                * little-endian CPUs.
> -                */
> -               data.proto =3D 0;
> -               csum_result =3D csum_ipv6_magic(&data.saddr, &data.daddr,
> -                                             data.len, data.proto,
> -                                             data.csum);
> -               expected =3D (__force __sum16)expected_csum_ipv6_magic[i]=
;
> +       for (int i =3D 0; i < IPV6_NUM_TESTS; i++) {
> +               int index =3D i * WORD_ALIGNMENT;
> +
> +               saddr =3D (const struct in6_addr *)(random_buf + index);
> +               daddr =3D (const struct in6_addr *)(random_buf + index + =
daddr_offset);
> +               len =3D ntohl(*(unsigned int *)(random_buf + index + len_=
offset));
> +               csum =3D *(unsigned int *)(random_buf + index + csum_offs=
et);
> +               proto =3D *(random_buf + index + proto_offset);
> +
> +               csum_result =3D csum_ipv6_magic(saddr, daddr, len, proto,=
 csum);
> +               expected =3D (__force __sum16)htons(expected_csum_ipv6_ma=
gic[i]);
>                 CHECK_EQ(csum_result, expected);
>         }
>  #endif /* !CONFIG_NET */

Gr{oetje,eeting}s,

                        Geert

--=20
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- geert@linux-m68k=
org

In personal conversations with technical people, I call myself a hacker. Bu=
t
when I'm talking to journalists I just say "programmer" or something like t=
hat.
                                -- Linus Torvalds