OpenState: programming platform-independent stateful OpenFlow applications inside the switch

G. Bianchi, M. Bonola, A. Capone, C. Cascone
Appears in: 
CCR April 2014

Software Defined Networking envisions smart centralized controllers governing the forwarding behavior of dumb low-cost switches. But are “dumb” switches an actual strategic choice, or (at least to some extent) are they a consequence of the lack of viable alternatives to OpenFlow as programmatic data plane forwarding interface? Indeed, some level of (programmable) control logic in the switches might be beneficial to offload logically centralized controllers (de facto complex distributed systems) from decisions just based on local states (versus network-wide knowledge), which could be handled at wire speed inside the device itself. Also, it would reduce the amount of flow processing tasks currently delegated to specialized middleboxes. The underlying challenge is: can we devise a stateful data plane programming abstraction (versus the stateless OpenFlow match/action table) which still entails high performance and remains consistent with the vendors’ preference for closed platforms? We posit that a promising answer revolves around the usage of extended finite state machines, as an extension (super-set) of the OpenFlow match/action abstraction. We concretely turn our proposed abstraction into an actual table-based API, and, perhaps surprisingly, we show how it can be supported by (mostly) reusing core primitives already implemented in OpenFlow devices.

Public Review By: 
Hitesh Ballani

Existing instantiations of software-defined networking focus on an extreme design point with a centralized controller governing dumb switches. The paper asks an interesting question - is this an explicit design choice or a compromise? The authors argue it is the latter and results from the fact that OpenFlow, the de-facto data plane API, does not allow programmers to deploy state at switches. To address this, the authors make the case for a stateful data plane API. This would allow controllers to offload some of their logic to switches. Control logic that only needs switch-local knowledge and hence, does not benefit from the controller's global visibility is a good candidate for such offloading. Specifically, this paper proposes a data plane abstraction that uses XFSMs (eXtensible Finite State Machines) to allow stateful processing of flows in switches. This abstraction can actually be implemented with minor modifications to OpenFlow 1.1 and the authors discuss two applications (port knocking and MAC learning) that can be implemented using it. The reviewers agreed that while many recent research efforts have proposed extensions to OpenFlow, the XFSM-based abstraction and the idea of stateful packet forwarding is neat, novel and could be very useful. Beyond questions specific to the abstraction such as the amount of state needed to represent state machines as lookup tables, we hope the paper will lead to a discussion of how switches may be able to implement some functionality achieved today through middleboxes, and whether this is a good idea in the first place.