Control/User Plane Separation (CUPS) and PFCP
=============================================
:author:	Harald Welte <laforge@osmocom.org>
:copyright:	2021 by Harald Welte (License: CC-BY-SA)
:backend:	slidy
:max-width:	45em

== Overview

What this talk is about

* Relatively modern extension to 3GPP architecture
* splitting control and user plane in EPC

== Acronyms

* SGW: Serving Gateway (4G successor of SGSN)
* PGW: Packet Gateway (4G successor of GGSN)
* CUPS: Control / User Plane Separation
* PFCP: Packet Forwarding Control Protocol

== SGW and PGW in EPC

== CUPS

* CUPS completed in June 2017 (3GPP Release 14)
* Separates the SGW and PGW into Control + User Plane
* a bit like the split of MSC into MSC + MSC Server much earlier
* Control Plane note process only signaling
* User Plane nodes process only user plane
** SGW becomes SGW-C and SGW-U
** PGW becomes PGW-C and PGW-U
* CUPS described in 3GPP TS 23.214

== CUPS Architecture Reference Model

image::cups-arch-ref-model.png[width=850]

== Why CUPS

* scale out of user plane (significant increase in cellular bandwidth since 4G)
* control plane is typically not so performance constrained
* 1:N or N:M relation between control and user plane nodes
* ability to move de-centralized UPF closer to the edge
** reduces latency of user plane
** keeps hierarchical model of control plane in core network

== CUPS Interfaces / PFCP protocol

* Sxa interface between SGW-C and SGW-U
* Sxb interface between PGW-C and PGW-U
* based on new protocol PFCP
** based on UDP/IP, structurally similar to GTPv2C
*** UDP port 8805
** 3GPP spec enables interoperability, i.e. different vendors/equipment for control and user plane
* PFCP described in 3GPP TS 29.244

== CUPS Packet Processing Abstraction

image::cups-pfcp-stacking.png[width=850]

== Functions of CUPS

* Traffic Detection
* Charging / Usage Monitoring
* GTP-U IP / TEIDu allocation
* UE IP address allocation/renewal/release
* Control of User plane forwarding
** forwarding UE - PDN
** forwarding subject to buffering
*** e.g. to trigger paging in SGW)
** forwarding with "end marker"
*** used during hand-over

== Key PFCP concepts

* _Association_
** User Plane and Control Plane instance get to know each other
** Only one Association for each tuple of (CP + UP) element
* _Session_
** For each tunnel (bearer)

== Key PFCP _node related_ procedures

* Association setup / update / release
** only one association exists between each pair of CP + UP nodes
* Heartbeat

== Key PFCP _session related_ procedures

There are the following three key procedures:

* Sx session establishment
* Sx session modification
* Sx session termination

There is one session per EPC bearer.

Each session then consists of a potentially lengthy list of _rules_.

== CUPS Packet Processing Abstraction

image::cups-packet-processing.png[width=850]

== PDR: Packet Detection Rule

* Packet Detection Information
** Source Interface
** UE IP address
** local F-TEID
** SDF filters
* outer header removal
* FAR (Forwarding Action Rule) ID
* list of URR (Usage Reporting Rule) IDs
* list of QER (QoS Enforcement Rule) IDs

== FAR: Forwarding Action Rule

* Destination Interface
* Outer header creation
* Session End Marker
* Transport Level Marking
* Forwarding Policy
* Container for Header Enrichment
* Buffer Control Information
* Delay Downlink Packet Notification Info
* Extended Buffering Info

== URR: Usage Reporting Rule

* Reporting Triggers
* Measurement Thresholds (Periodic / Volume / Time / Event)
* Inactivity detection time
* Measurement Method + Information

== QER: QoS Enforcement Rule

* Maximum Bitrate
* Guaranteed Bitrate
* Packet Rate

== BAR: Buffering Action Rule

* FIXME


== CUPS and 5G

* 4G PGW-U becomes the 5G UPF (User Plane Function)
* 4G PGW-C becomes the 5G SMF (Session Management Function)
* Protocol to control it remains PFCP

== CUPS and 2G/3G

* Not explicitly specified (AFAICT)
* Any GTPv1C control plane instance can of course off-load its user plane to a UPF
* Whether or not CUPS is used is an implementation detail

== Open Source around CUPS

There are already several FOSS implementations of PFCP and CUPS

* open5gs
** control plane: C language smf
** user plane: C language userland with normal socket API
* ergw
** Erlang ergw control plane
** VPP/DPDK based UPF
* OMEC
** ngic-rtc: BESS/DPDK based user plane
** upf-epc: revised version of ngic-rtc user plane
* Free5GC
** custom non-mainline Linux kernel module for GTP handling
** https://github.com/free5gc/gtp5g.git
* soon likely also an osmocom project (osmo-upf)
** no dependency on out-of-mainline kernel code
** yet faster than a socket-API based userspace process


== EOF

End of File
