net: buf: Simplify fragment handling

[carlescufi]

This patch reworks how fragments are handled in the net_buf infrastructure.

In particular, it removes the union around the node and frags members in the main net_buf structure. This is done so that both can be used at the same time, at a cost of 4 bytes per net_buf instance. This implies that the layout of net_buf instances changes whenever being inserted into a queue (fifo or lifo) or a linked list (slist).

Until now, this is what happened when enqueueing a net_buf with frags in a queue or linked list:

1.1 Before enqueueing:

  +--------+      +--------+      +--------+
  |#1  node|\     |#2  node|\     |#3  node|\
  |        | \    |        | \    |        | \
  | frags  |------| frags  |------| frags  |------NULL
  +--------+      +--------+      +--------+

net_buf #1 has 2 fragments, net_bufs #2 and #3. Both the node and frags pointers (they are the same, since they are unioned) point to the next fragment.

1.2 After enqueueing:

  +--------+      +--------+      +--------+      +--------+      +--------+
  |q/slist |------|#1  node|------|#2  node|------|#3  node|------|q/slist |
  |node    |      | *flag  | /    | *flag  | /    |        | /    |node    |
  |        |      | frags  |/     | frags  |/     | frags  |/     |        |
  +--------+      +--------+      +--------+      +--------+      +--------+

When enqueing a net_buf (in this case #1) that contains fragments, the current net_buf implementation actually enqueues all the fragments (in this case #2 and #3) as actual queue/slist items, since node and frags are one and the same in memory. This makes the enqueuing operation expensive and it makes it impossible to atomically dequeue. The *flag notation here means that the flags member has been set to NET_BUF_FRAGS in order to be able to reconstruct the frags pointers when dequeuing.

After this patch, the layout changes considerably:

2.1 Before enqueueing:

  +--------+       +--------+       +--------+
  |#1  node|--NULL |#2  node|--NULL |#3  node|--NULL
  |        |       |        |       |        |
  | frags  |-------| frags  |-------| frags  |------NULL
  +--------+       +--------+       +--------+

This is very similar to 1.1, except that now node and frags are different pointers, so node is just set to NULL.

2.2 After enqueueing:

  +--------+       +--------+       +--------+
  |q/slist |-------|#1  node|-------|q/slist |
  |node    |       |        |       |node    |
  |        |       | frags  |       |        |
  +--------+       +--------+       +--------+
                       |            +--------+       +--------+
                       |            |#2  node|--NULL |#3  node|--NULL
                       |            |        |       |        |
                       +------------| frags  |-------| frags  |------NULL
                                    +--------+       +--------+

When enqueuing net_buf #1, now we only enqueue that very item, instead of enqueing the frags as well, since now node and frags are separate pointers. This simplifies the operation and makes it atomic.

Resolves #52718.

Signed-off-by: Carles Cufi [email protected]

[desowin]

In other words, the put and get operations are now O(1) instead of O(N) where N is the number of linked in fragments.

[carlescufi]

In other words, the put and get operations are now O(1) instead of O(N) where N is the number of linked in fragments.

Exactly

[tbursztyka]

Ok as an intermediate change.

Shouldn't we remove frags pointer altogether at some point btw? To get back to smaller size, but also it would force code to use slist API to traverse net_buf etc... will be cleaner.