ROFL-PIPELINE library

Documentation

Introduction

The ROFL-pipeline library is a platform-agnostic OpenFlow 1.0, 1.2 and 1.3.X pipeline, built focusing on performance and extensibility. The objective is to create a unified common OpenFlow pipeline implementation that can be reused in several platforms. ROFL-pipeline is used by the eXtensible DataPath (xDPd) in several platforms.

Features:

• Complete dataplane data model.
• Complete OpenFlow 1.0, 1.2 and 1.3.X processing pipeline, including abstractions of switch (forwarding plane only), pipeline, table, entry, matches, actions... as well as the subsystems of timers and stats.
• Support for up to PHYSICAL_SWITCH_MAX_LS logical switch instances (OF datapaths) running in parallel.
• Support for multiple OpenFlow versions running simultaneously in different logical switches.
• Runtime port(interface) attachment/detachment to/from logical switches
• Platform indepedent: the library is decoupled from platform specific code.
• Extensible library:
  • New OpenFlow versions
  • New OpenFlow Matches
  • New OpenFlow Actions
  • New software Table Matching Algorithms (flow entry lookup)

How to use it

ROFL-pipeline can be used as:

• A data-model of the forwarding plane of an OpenFlow switch. This is how ROFL-HAL uses it.
• A data-model and state manager library. Keep the state of the flowmod entries installed, groupmods, associated timers, stats... and let the platform specific code capture events (flow_mod insertion, flow_mod removal) via OpenFlow asynchronous events and hooks APIs APIs to mangle ASIC or other devices configuration.
• A data-model, state manager and a software OpenFlow packet processing library. Use the Software Packet Processing (pp) APIs to process packets in software or hybrid hw/sw OF datapaths.

ROFL-pipeline is not...

• ...a full-fletched datapath
• ...a complete OpenFlow-enabled Forwarding Backend; ROFL-pipeline is deliverately a platform independent library, hence it does not deal with things like the I/O or other platform specific subsytems. Take a look at our xDPd for a complete OpenFlow-enabled Forwarding Backend that uses ROFL-pipeline.
• ...an OpenFlow endpoint. The OpenFlow endpoint is out of the scope of ROFL-pipeline library. Take a look at ROFL-common.

Architecture overview

                                                                    Legend:

                                                                    +--> API exposed by
                                                                         the library

                   +---------------------------------+              <+++ API consumed by
                   |            Data-model           |                   the library
Async events       +---------------------------------+
and hooks API <+++++                                 |
                   |         State management        ++++
Management API +--->                                 |  +   Platform APIs
                   +---------------------------------+  ++> (locking, atomic ops, packet mangling...)
                   |                                 |  +
                   |        Packet processing        ++++
                   |                                 | 
                   | +------------------------------+|
Pkt processing +-----|-> Matching algorithms APIs   ||
                   | +------------------------------+|
                   +---------------------------------+

Exposed by the library:

• Data-model core APIs and data structures : The data-model core APIs and data structures present a unified data-model of a dataplane.
• State managment API : Mananagement of the system's/device state (physical switch), including logical switches and ports.
• Software Packet Processing (pp) APIs : APIs used to process packets in software pipelines (software and hybrid software/hardware switches)

Consumed by the library:

• Platform dependent APIs, which are subdivided in:
  • Memory API : Memory management API definition (malloc, free..), that must be implemented by the library users.
  • Locking API : Locking (mutex, rwlock) API definition, that must be implemented by the library users.
  • Atomic Operations API : Atomic operations (atomic add, inc...) API definition, that must be implemented by the library users.
  • Packet Mangling API : Packet Mangling API is in charge of packet manipulation and must be implemented by the library users.
• OpenFlow asynchronous events and hooks APIs : APIs that library consumes to communicate asynchronous events (as well as some other hooks) to the endpoint or an intermediate layer; must be implemented by the library users.
• Extensible OpenFlow software matching algorithm APIs : APIs to extend ROFL-pipeline with new (software/hybrid) OpenFlow table matching algorithms.

Endiannes of packet values, matches and actions:

ROFL-pipeline uses Network Byte Order (NBO). The alignment of particular headers types has to be carefully taken into account. Please, read endianness section for more details.

Related projects:

• ROFL-common: Revised OpenFlow Library OpenFlow endpoint code.
• ROFL-HAL: Revised OpenFlow Hardware Abstraction Layer (HAL).
• xDPd: eXtensible DataPath daemon, a multi-platform open-source OpenFlow datapath.

Authors:

• Marc Sune Clos <marc.sune (at) bisdn.de>
• Victor Alvarez Roig <victor.alvarez (at) bisdn.de>
• Tobias Jungel <tobias.jungel (at) bisdn.de>
• Andreas Koepsel <andreas.koepsel (at) bisdn.de>

Copyright BISDN.

Licensing:

The code is distributed under MPL v2: http://www.mozilla.org/MPL/

The ROFL pipeline library is part of a more extensive C/C++ library called ROFL (Revised OpenFlow Library).