Tc u32 — how to match L2 protocols in recent kernels

If I understand htb correctly, then the rate is "guaranteed". This means you have ideas about the rate of the "realtime" traffic. Only if this rate is exceeded, it will borrow. If several classes want to borrow, the prio should kick in. The guaranteed rates should add up the physical limit. Otherwise it's too much of a hassle.

IMHO, Case A will never really work since you need to have priority or rate-limiting at the root level. The priorities/rates in the different segment don't know anything of each other and will be handled equally.

The thing you probably want is: Put the "rate" for low and normal prio to 0 or close to it and add "ceiling" for the rest of the bandwidth, for high prio you guarantee a rate of 100% of the physical.

You can use mask, but it difficult:

 u32 match ip sport 4096 0xf000 = sport 4096-8191
 u32 match ip sport 8192 0xe000 = sport 8192-16383

0xf000/0xe000 is the mask. The word extracted from the packet is bit-wise with this mask before comparison.

value = 0001000000000000
mask  = 1111000000000000

start = 0001000000000000
end   = 0001111111111111

Also you can create many filter for one classid:

tc filter add dev eth0 parent 1:0 prio 3 protocol ip u32 match ip protocol 6 0xff match ip sport 10000 0xffff classid 1:13
tc filter add dev eth0 parent 1:0 prio 3 protocol ip u32 match ip protocol 6 0xff match ip sport 10001 0xffff classid 1:13
tc filter add dev eth0 parent 1:0 prio 3 protocol ip u32 match ip protocol 6 0xff match ip sport 10002 0xffff classid 1:13

For your example, your need create several 'tc filter':

first: sport 10000 0xfff0 (10000-10015)
second: sport 10016 0xffe0 (10016-10047)
.............

etc.

10000=10011100010000

0010011100010000
           |
     first not zero
1111111111111111
mask
1111111111110000=0xfff0

[Basically take the first number in the range (in this example 10,000) and convert it to binary ( 0010011100010000 ); then scan this binary number from right to left until you encounter the 1st non 0 bit; then make the bits from the left of that bit all into 1's inclusive, and all the bits to the right of it to zeros. That is how you come out to 0xfff0 as the mask.]