upf

UPF

This project implements a 4G/5G User Plane Function (UPF) compliant with 3GPP TS23.501. It follows the 3GPP Control and User Plane Separation (CUPS) architecture, making use of the PFCP protocol for the communication between SMF (5G) / SPGW-C (4G) and UPF.

This UPF implementation is actively used as part of the Aether platform in conjunction with the SD-Core mobile core control plane.

Table Of Contents

• Overview
• Feature List
• Getting Started
• Contributing
• Support
• License

Overview

The UPF implementation consists of two layers:

• PFCP Agent (pfcp image, pfcpiface binary/module): a Go-based implementation of the PFCP northbound API used to interact with the mobile core control plane.
• Datapath: responsible for the actual data plane packet processing.

The PFCP Agent implements datapath plugins that translate PFCP messages to datapath-specific configurations. We currently support below datapath implementation:

• BESS: a software-based datapath built on top of the Berkeley Extensible Software Switch (BESS) framework. For more details, please see the ONFConnect 2019 talk and demo videos here and here.

  Note: BESS source is included in this repository under bess/.

PFCP Agent internally abstracts different datapaths using a common API, while the different plug-ins can use specific southbound protocols to communicate with the different datapath instances. Support for new datapaths can be provided by implementing new plugins.

This repository provides code to build two Docker images: pfcp (packaging the pfcpiface PFCP Agent binary) and bess (the BESS-based datapath).

To build all Docker images run:

make docker-build

To build a selected image use DOCKER_TARGETS:

DOCKER_TARGETS=pfcp make docker-build

The latest Docker images are also published in the OMEC project’s DockerHub registry: upf-bess, upf-pfcp.

BESS-UPF Components

Zoom-in

Feature List

PFCP Agent

• PFCP Association Setup/Release and Heartbeats
• Session Establishment/Modification with support for PFCP entities such as Packet Detection Rules (PDRs), Forwarding Action Rules (FARs), QoS Enforcement Rules (QERs).
• UPF-initiated PFCP association
• UPF-based UE IP address assignment
• Application filtering using SDF filters
• Generation of End Marker Packets
• Downlink Data Notification (DDN) using PFCP Session Report
• Integration with Prometheus for exporting PFCP and data plane-level metrics.
• Application filtering using application PFDs (experimental).

BESS-UPF

• IPv4 support
• N3, N4, N6, N9 interfacing
• Single & Multi-port support
• Monitoring/Debugging capabilities using
  • tcpdump on individual BESS modules
  • visualization web interface
  • command line shell interface for displaying statistics
• Static IP routing
• Dynamic IP routing
• Support for IPv4 datagrams reassembly
• Support for IPv4 packets fragmentation
• Support for UE IP NAT
• Service Data Flow (SDF) configuration via N4/PFCP
• I-UPF/A-UPF ULCL/Branching i.e., simultaneous N6/N9 support within PFCP session
• Downlink Data Notification (DDN) - notification only (no buffering)
• Basic QoS support, with per-slice and per-session rate limiting
• Per-flow latency and throughput metrics
• DSCP marking of GTPu packets by copying the DSCP value from the inner IP packet
• GTPu path monitoring
• Support for DPDK, AF_PACKET and AF_XDP modes

Getting started

Installation

Please see installation document here for details on how to set up the PFCP Agent with BESS-UPF.

Configuration

Please see the configuration guide here to learn more about the different configurations.

Testing

The UPF project currently implements three types of tests:

• Unit tests
• E2E integration tests
• PTF tests for BESS-UPF

Unit tests for the PFCP Agent’s code. To run unit tests use:

make test

E2E integration tests that verify the inter-working between the PFCP Agent and a datapath.

We provide two modes of E2E integration tests: native and docker.

The native mode invokes Go objects directly from the go test framework, thus it makes the test cases easier to debug. To run E2E integration tests for BESS-UPF in the native mode use:

make test-integration

PTF tests for BESS-UPF verify the BESS-based implementation of the UPF datapath (data plane). Details to run PTF tests for BESS-UPF can be found here.

Contributing

The UPF project welcomes new contributors. Feel free to propose a new feature, integrate a new UPF datapath or fix bugs!

Before contributing, please follow these guidelines:

• Check out the developer guide.
• We follow the best practices described in https://google.github.io/eng-practices/review/developer/. Get familiar with them before submitting a PR.
• Both unit and E2E integration tests must pass on CI. Please make sure that tests are passing with your change (see Testing section).

Reach out to us through

1. #sdcore-dev channel in Aether Community Slack
2. Raise Github issues

License

The project is licensed under the Apache License, version 2.0.