Skip to content
audiotale.net
Sign in
GuidesExplainer

RSS, RPS and RFS on Linux explained: receive queues, how to check them, and why NoisyTCP cares

How Linux spreads incoming packets across CPUs with RSS, RPS and RFS, where to see your settings, and why the NoisyTCP workaround is a single receive queue.

audiotale.net team

· 5 min read

Written by AI from the sources linked below. How we use AI

On this page
  1. In short
  2. Why Linux needs more than one receive queue
  3. RSS: the card spreads the load
  4. RPS: the same idea in software
  5. RFS and accelerated RFS: follow the application
  6. Where the security problem comes in
  7. Checking and changing your setup
  8. Common misunderstandings
  9. What we don't know
  10. Sources

In short

A modern network card has several receive queues, and Linux spreads incoming packets across them so that more than one CPU can work on network traffic at once. Receive Side Scaling (RSS) does the spreading in the card, Receive Packet Steering (RPS) does it in software, and Receive Flow Steering (RFS) aims packets at the CPU where the application is running. The same parallelism is a precondition for the NoisyTCP kernel bug, CVE-2026-99288, whose workaround is to go back to one receive queue. This guide explains what these features do, how to see whether your server uses them, and what you give up by switching them off.

Why Linux needs more than one receive queue

A network interface that handles packets on a single CPU hits a ceiling long before the cable does: that one CPU takes every interrupt and runs the network stack for every packet. The kernel's own scaling guide describes the fix as parallel receive paths, and lists the main mechanisms: RSS, RPS, RFS, accelerated RFS and, for sending, XPS. The first three decide which CPU handles an incoming packet.

The cost of that choice is ordering and cache. Packets of one TCP connection should be handled in order, and ideally on a CPU whose cache already holds that connection's data. So all of these features key off a hash of the packet's headers, which makes every packet of a flow land in the same place.

RSS: the card spreads the load

With RSS, a multi-queue network card computes a hash from the packet headers (typically a four-field hash, usually Toeplitz, according to the kernel documentation) and uses the low bits to index an indirection table of queue numbers. Each queue has its own interrupt, so each can be served by a different CPU. Practical points from the documentation:

  • The indirection table should have at least four times as many entries as there are queues, which keeps imbalance near 16 percent.
  • Specific flows can be pinned to a queue with n-tuple filters, for example TCP port 80, using ethtool --config-ntuple.
  • Each queue's interrupt shows up in /proc/interrupts, and irqbalance can override interrupt affinity you set by hand.
  • The guidance is one queue per CPU where the device allows it, limited to physical cores rather than hyperthreads, because interrupt work grows with every queue you add.

To see the queue ("channel") count on your card, the standard command is ethtool -l <interface>. The kernel scaling page we read does not cover that option, so check your ethtool man page.

RPS: the same idea in software

RPS is described as a software version of RSS. It works with any network card, even one with a single queue: during receive processing the kernel computes the hash, puts the packet on the chosen CPU's backlog queue, and wakes that CPU with an inter-processor interrupt. The cost is those extra interrupts between CPUs; the benefit is that no special hardware is needed.

It is off until configured and needs the kernel option CONFIG_RPS. You set a CPU bitmap per receive queue in /sys/class/net/<dev>/queues/rx-<n>/rps_cpus; a value of zero disables it. The documentation says that when RSS already maps one queue to each CPU, RPS is likely redundant.

There is also an optional RPS flow limit, aimed at one dominant flow or a spoofed-source flood. It only starts dropping once a CPU's backlog passes half of netdev_max_backlog, then drops packets from flows that take more than half of the last 256 packets. It is compiled in with CONFIG_NET_FLOW_LIMIT but off by default.

RFS and accelerated RFS: follow the application

RFS goes one step further: it steers packets to the CPU where the thread consuming them runs, so the data is already in that CPU's cache. It uses RPS to move the packet, and keeps two tables: a global one (/proc/sys/net/core/rps_sock_flow_entries) recording where each flow's application last ran, and a per-queue one (/sys/class/net/<dev>/queues/rx-<n>/rps_flow_cnt). A flow only moves to a new CPU when the old CPU has no outstanding packets for it, which avoids reordering. The documentation says a global table of 65,536 entries suits a moderately loaded server, and that busier machines may need 1,048,576 or more.

Accelerated RFS lets the card do the steering, if the card and driver support it. The documentation recommends enabling it whenever RFS is in use.

Where the security problem comes in

NoisyTCP is a race between two receive paths: one finds a TCP request socket through a stale lookup while another frees and reallocates the same memory. The researcher's write-up says the bug needs two or more RX queues, or RPS spreading packets across CPUs, so that two CPUs really do process related packets at the same moment, and that the attacker uses the receive-hash difference between IPv4 fragments and regular TCP packets to split the work. Red Hat's guidance matches: reduce the external interface to a single RX queue and disable RPS and RFS.

That is why this feature set shows up in a security advisory. Disabling it removes the concurrency the exploit needs, but it also removes the scaling these features exist to provide. Red Hat and the researcher list that workaround alongside another: turning off SYN cookies (net.ipv4.tcp_syncookies=0), which has its own cost. The kernel documentation describes SYN cookies as the fallback that protects a listener when its SYN backlog overflows, and it says they should not be relied on for high legitimate connection rates. On a host that sees SYN floods, disabling them removes that fallback. The default value is 1.

Checking and changing your setup

These are the places the documentation names. Treat the commands as a starting point and test on a non-production host first:

  1. Queue count: ethtool -l <interface>, with the number of combined or RX channels shown. See your ethtool man page for changing it.
  2. RPS: read /sys/class/net/<interface>/queues/rx-*/rps_cpus. All zeros means RPS is off for that queue.
  3. RFS: read /proc/sys/net/core/rps_sock_flow_entries. Zero means RFS is not in use.
  4. Interrupts: look at /proc/interrupts to see which CPUs serve which queue.
  5. Vendor patch first: the real fix for NoisyTCP is the kernel update; the Debian tracker lists fixed versions 6.1.192-2 and 6.12.117-1 for bookworm and trixie. Changing queues is a stopgap.

Cut the queue count only if you cannot patch soon, and expect lower throughput on busy servers. We have not measured the impact and do not claim a number.

Common misunderstandings

  • RSS and RPS are not the same thing. One runs in the card and raises interrupts on different CPUs; the other runs in the kernel and uses inter-processor interrupts.
  • More queues is not always better. The documentation says the smallest queue count that keeps every CPU from overloading is the right target, because interrupt work grows with each queue.
  • Virtual machines count. The NoisyTCP write-up reports its fastest triggers on QEMU/KVM virtual machines, so a virtual network card with several queues is in scope.

What we don't know

The documentation does not give a performance cost for running with a single queue, and the NoisyTCP sources do not say whether specific cloud network cards are affected. Check with your provider.

Sources

Written by

audiotale.net team

The official account of the people who run audiotale.net: announcements, conversation starters and the newsroom's drafts. Posts written with AI say so. Every other account here is a real person.