Home / Call Flows / 5G / PCC Policy Enforcement

5G PCC Policy Enforcement Call Flow

call-flow 5G NR | 5GC | PCC | PCF | SMF | UPF

5G PCC Policy Enforcement is the procedure family that turns service policy into real traffic behavior.

It joins PCF decisions, SMF session control, and UPF enforcement so charging, gating, and QoS intent become operational reality.

Introduction

Many service problems that look like generic packet loss or poor quality are really policy-enforcement problems.

The right troubleshooting pattern is to trace the full path from policy trigger to SMF translation, then to PFCP state and finally to user-visible packet behavior.

What Is PCC Policy Enforcement in Simple Terms?

What starts the procedure: A policy, charging, or application event requires new service treatment.
What the UE and network want to achieve: Apply the correct gating, charging, or QoS behavior to the right traffic.
What success looks like: Live service behavior matches the intended policy outcome.
What failure means: Policy exists in control logic but not in actual traffic treatment.

Why this procedure matters

Policy enforcement is where business logic meets packet forwarding. If this layer drifts out of sync, users experience confusing service failures that are hard to explain without the full end-to-end picture.

Quick Fact Sheet

Procedure name	5G PCC Policy Enforcement
Domain	5G policy and charging control applied to live session and QoS behavior
Main trigger	Subscription, application, charging, or service conditions require policy enforcement on an active service
Start state	UE has registration and one or more sessions that can be influenced by policy
End state	SMF, UPF, and UE behavior reflect the intended PCC outcome
Main nodes	UE, AMF, SMF, UPF, PCF, application function when present
Main protocols	N7 policy control, NAS session signaling, PFCP, QoS rules
Main success outcome	The intended charging, QoS, gating, or usage policy becomes visible in real session behavior
Main failure outcome	Policy exists in control logic but is not enforced correctly in the live path
Most important messages	Policy update interactions, PDU Session Modification Command, PFCP updates, usage-trigger outcomes
Main specs	TS 23.503, TS 23.501, TS 23.502, TS 29.244

Preconditions

The UE already has registration and a service context that can be policy-controlled.
The PCF has enough subscription or application information to make a decision.
The SMF can translate that decision into session and forwarding rules.
The UPF can apply the resulting enforcement state in the live path.

Nodes and Interfaces

Nodes involved

Node	Role in this procedure
UE	Applies rule changes that affect how traffic is handled locally and how service behaves from the user side.
AMF	Relays session policy updates when NAS signaling toward the UE is required.
SMF	Translates policy decisions into session, QoS, and charging enforcement actions.
UPF	Enforces packet handling, forwarding, gating, and usage reporting behavior tied to PCC rules.
PCF	Owns policy decisions related to charging, QoS, steering, gating, and service treatment.
Application Function	May provide service intent that influences PCC decisions for a specific application flow.

Interfaces used

Interface	Path	Role
N7	SMF <-> PCF	Carries policy decisions that drive session and QoS enforcement.
N4	SMF <-> UPF	Installs packet handling and charging-related enforcement state.
N1	UE <-> AMF	Carries session updates that the UE must apply when PCC changes affect local behavior.
N11	AMF <-> SMF	Links NAS session updates to the policy-driven session logic.
N3 / NR-Uu	UPF <-> gNB and gNB <-> UE	Reveal whether the enforced policy is actually visible in live traffic.

End-to-End Call Flow

UE                AMF                SMF                PCF                UPF
|                  |                  |                  |                  |
|                  |                  |<-- policy event -|                  |
|                  |                  |-- request / sync ->|                |
|                  |                  |<-- policy rules ---|                |
|<-- session rule update if needed ---|                  |-- PFCP install -->|
|==== live traffic now reflects policy, charging, or gating behavior ======>|

Major Phases

Phase	What happens
1. Policy trigger	Charging, service intent, subscription, or usage state triggers a PCC decision.
2. SMF policy translation	The SMF converts the decision into session, QoS, and forwarding changes.
3. Enforcement installation	UPF and sometimes UE receive the new behavior.
4. Service behavior change	Traffic, gating, or charging outcomes become visible operationally.
5. Validation and monitoring	Counters, usage, and packet behavior confirm the policy is really active.

Step-by-Step Breakdown

A PCC event requires a new enforcement action

Sender -> receiver: Subscription / charging / AF -> PCF -> SMF

Message(s): Policy decision update

Purpose: Start the process that changes how an existing service should be treated.

State or context change: The session moves from its current enforcement state toward a new one.

Note: Understanding the business or service trigger helps explain every later network action.

SMF translates policy into actionable session behavior

Sender -> receiver: SMF internal rule building

Message(s): Session and QoS rule preparation

Purpose: Turn abstract policy into concrete forwarding, charging, and UE-visible rule changes.

State or context change: The network has a deployable enforcement model for the service.

Note: This is where policy intent can be lost if the session context or slice assumptions are wrong.

UPF and UE receive the enforcement change

Sender -> receiver: SMF -> UPF and SMF -> UE via AMF when needed

Message(s): PFCP update and possibly PDU Session Modification Command

Purpose: Activate the new policy in the user plane and, when relevant, in the UE rule set.

State or context change: The session now has a new enforcement posture.

Note: A policy update that never reaches the UPF is not real enforcement, only paperwork.

Traffic behavior changes under policy control

Sender -> receiver: UE <-> gNB <-> UPF

Message(s): Live packet flow with updated gating, QoS, or charging treatment

Purpose: Show the operational effect of the PCC decision.

State or context change: The service becomes measurably different from before the update.

Note: Look for packet drops, priority changes, or flow steering that align with the intended rule.

Usage and compliance are monitored

Sender -> receiver: UPF / SMF / PCF

Message(s): Usage reports and policy-state observation

Purpose: Confirm that the enforced policy continues behaving as intended.

State or context change: The policy outcome is now part of normal session operation.

Note: The best validation often combines signaling, counters, and user-plane evidence instead of using only one of them.

Important Messages in This Flow

Message	Protocol	Direction	Purpose in this procedure	What to inspect briefly
Policy update interaction	Policy control	PCF <-> SMF	Defines what enforcement outcome the session should adopt.	Anchor the trace on this decision when possible.
PDU Session Modification Command	NAS	SMF -> UE via AMF	Updates the UE when policy changes affect local session rules.	Check whether UE-facing rule changes match the policy intent.
PFCP session update	PFCP	SMF <-> UPF	Installs the actual enforcement logic in the user plane.	Most important proof that PCC became operational.
Usage reporting or service counters	Operational evidence	UPF / SMF / charging	Reveal whether the policy was enforced and observed over time.	Useful for validating charging and gating effects.

Important Parameters to Inspect

Parameter	What it is	Where it appears	Why it matters	Common issues
Policy rule identifier	Reference to the PCC decision being enforced.	Policy and SMF context	Lets you correlate the intent with the operational result.	Without this, policy troubleshooting becomes guesswork.
Affected session and QFI	The exact traffic context influenced by the rule.	SMF, NAS, and UPF traces	Shows the enforcement target.	Wrong session targeting causes surprising service impact.
Charging / gating action	Whether traffic should be allowed, blocked, rated, or shaped.	Policy decision and PFCP state	Defines the service outcome the user will feel.	Easy to misread if you only inspect QoS parameters.
QoS and filter changes	Detailed rule set that matches traffic to the enforced policy.	NAS and UPF state	Explains which packets are actually affected.	Filter mismatch makes policy look inconsistent.
Observed traffic effect	What changed in real packet or application behavior.	Live service observation	Best proof of enforcement success.	No user-plane evidence means no trustworthy conclusion.

Success Criteria

The policy trigger is clearly translated into session behavior.
PFCP installs the intended enforcement state in the UPF.
UE-facing updates are delivered when local behavior must change.
Traffic, QoS, charging, or gating outcomes match policy intent.

Common Failures and Troubleshooting

Symptom	Likely cause	Where to inspect	Relevant message(s)	Relevant interface(s)	Likely next step
Policy is accepted but traffic does not change	The decision never became real enforcement in the UPF or UE.	PFCP state and live packets.	Policy update / session modification	N4, N1, N3	This is the most common PCC troubleshooting pattern.
The wrong traffic is controlled	Filters or session targeting are wrong.	Affected session, QFI, and packet filters.	Rule payload	N1, N4	Always verify the intended application mapping.
Charging looks wrong after a policy update	Usage reporting or charging action does not match the PCC intent.	Usage reports and PCF/SMF correlation.	Policy and usage records	Charging interfaces	Treat charging evidence as part of the call flow outcome.
Service is degraded unexpectedly after enforcement	The policy was installed, but the resulting QoS or gating is harsher than intended.	5QI, gating action, and live KPIs.	PFCP and traffic outcome	N4, N3	This can be a valid enforcement result but an incorrect policy design.

Related sub-procedures

Related message reference pages

Related troubleshooting pages

FAQ

What is PCC Policy Enforcement?

It is the process that turns 5G policy decisions into real QoS, charging, gating, or traffic-handling behavior.

Which node really enforces PCC?

The SMF coordinates it, but the UPF usually provides the main user-plane enforcement.

What proves success?

The policy decision is visible in PFCP state and in live traffic or charging behavior.

What should I inspect first?

Start with the policy trigger, the affected session, the PFCP update, and the observed packet outcome.

Why is this page related to QoS flows?

Because many PCC decisions are delivered through QoS rules and session-modification behavior.