Is there any valid use case of bpf_csum_diff where from_size > 0, to_size = 0 and the return value is negative?

[shankarseal]

Excerpts of the documentation for bpf_csum_diff:

s64 bpf_csum_diff(__be32 *from, u32 from_size, __be32 *to, u32 to_size, __wsum seed)
Description
Compute a checksum difference, from the raw buffer pointed by from, of length from_size ... towards the raw buffer pointed by to, of size to_size .... An optional seed can be added to the value (**this can be cascaded, the seed may come from a previous call to the helper**).

This is flexible enough to be used in several ways:
...
With from_size > 0, to_size == 0 and seed set to checksum, it can be used when removing data from a packet.
...
Return
The checksum result, or a **negative error code in case of failure**.

Is there any valid use case of this function with the following?
from_size > 0, to_size == 0 for an input seed value such that the return value is < 0?
I am guessing the answer is no?

If NOT, wouldn't that mean that in the above case the return value from the function will be <0 and that conflicts with the constraint that return value is <0 only in error case?

@qmonnet , @teknoraver ?

[qmonnet]

I believe the checksum computed by the helper is on 32 bits, but the helper itself returns a s64 through r0 which is 64-bit long. So in that case the checksum returned should always be expressed as a positive 64-bit integer, unless I'm missing something?

As for the use case, I know about as much as the helper's doc: it can be useful when we remove data from a packet.

[shankarseal]

s64 is signed 64-bit integer I presume? Regardless of the length of the output integer, the question remains, if there are any valid scenarios when the API will return a negative checsum difference ?

[shankarseal]

I think I found the answer.

The csum_diff function uses 1's complement arithmetic, where subtracting the from_buffer means adding 1's complement of 16-bit chunks of the from_buffer treated as unsigned 16-bit integer. Overflows are tolerated, and its the job of the caller to fold the intermediate answer to get the final checksum.

So csum_diff is effectively this:
csum_diff = seed + ~(from_buffer) + to_buffer;;

The answer will be +ve except of course if overflow occurs on the 32 bit signed csum_diff. But that is clearly an error case. In non-error cases the output of this function is always > 0.