TL;DR
Software-Defined Networking (SDN) controllers struggle to reliably update network forwarding rules on real-world switches due to inconsistencies in how switches report the completion of these updates. This paper introduces RUM, a transparent layer that provides reliable acknowledgments of rule updates by observing both control and data plane behavior, ensuring rules are confirmed only after they are active in the data plane.
What Problem Does This Paper Address?
In SDN, a centralized controller manages network forwarding rules stored in switches' flow tables. The process of updating these rules is complex, and ensuring consistency across all switches is crucial for network stability and security. Ideally, a controller should know precisely when a rule modification has been successfully applied in a switch's data plane before issuing further commands. However, the OpenFlow protocol, the de facto standard for SDN, lacks a direct mechanism for such confirmations. While it offers "Barrier" commands, real-world switches often fail to implement these correctly. They might send a barrier reply before the rule is actually active in the data plane, leading to transient but severe issues like security policy violations or network black holes. This paper highlights that even with theoretically sound update strategies, practical implementations on buggy hardware can lead to network instability.
Methods
The core contribution of this paper is the RUM (Rule Update Monitoring) system, designed as a transparent layer between the SDN controller and the switches. RUM intercepts communication and provides reliable acknowledgments of rule modifications. It achieves this through several techniques, categorized into two main approaches:
- Control-Plane Only Techniques: These methods rely solely on control plane messages.
- Delayed Barrier Acknowledgments: If the delay between a barrier reply and data plane rule activation is measurable and bounded, RUM can simply wait for that duration before confirming the update.
- Adaptive Delay: This refines the previous method by dynamically adjusting the timeout based on estimated switch behavior and controller update rates.
- Modeling Switch Behavior: This involves building detailed models of switch performance to predict rule activation times.
- Data Plane Probes: These techniques actively monitor the data plane to confirm rule activation.
- Sequential Probing: For switches that respond to barriers too early but don't reorder rules, RUM inserts a special "probing rule" after each real rule modification. When this probing rule becomes active (detected by sending probe packets to the controller), it confirms the preceding real rule is also active.
- General Probing: This more robust technique handles switches that might reorder rules or have complex matching criteria. It involves reserving a specific header field (e.g., VLAN, ToS) and installing a high-priority "probe-catching" rule on each switch. RUM then crafts probe packets that are designed to match the specific rule being tested and are forwarded to the controller only when that rule is active. This method can also detect rule deletions.
- Network-Wide Probing: An extension of general probing that uses a single, versioned probing rule across multiple switches, reducing overhead.
RUM also provides a reliable barrier layer by intercepting barrier requests and replies, holding them until it can confirm data plane completion.
Datasets
Not discussed in the paper. The evaluation uses a custom testbed with a hardware OpenFlow switch and software switches, simulating network traffic.
Key Insights and Ideas
- Real-world switches are not perfect: Even with theoretically sound SDN update protocols, actual hardware implementations can be buggy, leading to significant network instability. The assumption of perfectly functioning switches is a critical flaw in many existing SDN update strategies.
- Control plane alone is insufficient: Relying solely on control plane messages like OpenFlow barriers is unreliable because switches often report completion prematurely.
- Data plane observation is key: The most reliable way to confirm rule updates is to observe their effect on actual data plane traffic.
- Trade-offs in probing: Data plane probing techniques offer strong guarantees but introduce overhead (rule installation, packet processing). The paper explores trade-offs between notification delay, update rate, and overhead.
- RUM as a transparent layer: The design of RUM as a layer that intercepts and modifies communication without requiring changes to existing controllers or switches is crucial for practical deployment.
Key Results
- Elimination of packet drops: The end-to-end experiment demonstrated that RUM's techniques, particularly data plane probing, completely eliminate packet drops that occur with standard OpenFlow barriers or simple timeout mechanisms.
- Improved update times: While control-plane-only techniques with timeouts can fix packet drops, they introduce significant delays. Data plane probing techniques, especially general probing, achieve update times close to the theoretical minimum without packet drops.
- Quantified delays: The paper quantifies the delay between data plane and control plane activation, showing that barrier replies can arrive up to 300ms before rules are active. RUM's probing techniques keep this delay within 70ms for 90% of modifications.
- Switch performance metrics: Benchmarks show that real hardware switches can process sufficient PacketOut and PacketIn messages per second to support RUM's probing mechanisms.
Limitations and Future Work
- Small-scale experiments: The authors acknowledge that their evaluation is based on small-scale experiments and that a large-scale testbed with hardware switches would be ideal.
- Assumption of non-overlapping rules (in some methods): Some of the simpler probing techniques assume rules do not overlap, which might not always hold in complex networks.
- Rule update rate limitations: While RUM guarantees correctness, the usable rule update rate can be impacted by the overhead of probing.
- Future work: The paper suggests that building better switch models could further optimize RUM's adaptive timeout and probing strategies. The authors also mention the potential for using vendor-specific messages or extending the OpenFlow API for more direct acknowledgments.
Summary updated