From bdeea7ce8b24c4c71363ff18d624088da9ec9bbb Mon Sep 17 00:00:00 2001 From: Sukchan Lee Date: Wed, 21 Oct 2020 22:54:40 -0400 Subject: [PATCH] Add troubleshoot for #621 --- .../troubleshoot/02-now-in-github-issues.md | 78 ++++++++++ docs/_posts/2020-10-09-release-v2.0.18.md | 2 +- lib/pfcp/handler.c | 30 ++++ lib/pfcp/types.h | 146 +++++++++++++++++- src/sgwc/s11-handler.c | 7 +- src/sgwu/context.c | 1 + src/upf/context.c | 1 + 7 files changed, 261 insertions(+), 4 deletions(-) diff --git a/docs/_docs/troubleshoot/02-now-in-github-issues.md b/docs/_docs/troubleshoot/02-now-in-github-issues.md index dea9244cf..59bd715e8 100644 --- a/docs/_docs/troubleshoot/02-now-in-github-issues.md +++ b/docs/_docs/troubleshoot/02-now-in-github-issues.md @@ -3,6 +3,84 @@ title: Now in the Github Issue head_inline: "" --- +#### Can I disable specific services if 5G functionally is not needed? + + +From v2.0.x, SGW was divided into SGW-C and SGW-U, and PGW function was seperated into SMF and UPF. + +In order to use 4G only, you need to run the process below. +```bash +$ open5gs-mmed +$ open5gs-sgwcd +$ open5gs-smfd +$ open5gs-sgwud +$ open5gs-upfd +$ open5gs-hssd +$ open5gs-pcrfd +``` + +And the process below is only used in 5G, so there is no need to run it. + +```bash +$ open5gs-nrfd +$ open5gs-amfd +$ open5gs-ausfd +$ open5gs-udmd +$ open5gs-udrd +``` + +However, among these, SMF and UPF are used by both 4G EPC and 5G Core. And SMF has a protocol stack to interact with 5G NRF. Therefore, if you run SMF without running 5G NRF, the following WARNING occurs in SMF. + +``` +10/08 14:44:03.045: [sbi] WARNING: [7] Failed to connect to ::1 port 7777: Connection refused (../lib/sbi/client.c:450) +10/08 14:44:03.045: [smf] INFO: PFCP associated (../src/smf/pfcp-sm.c:174) +10/08 14:44:03.046: [diam] INFO: CONNECTED TO 'pcrf.localdomain' (SCTP,soc#16): (../lib/diameter/common/logger.c:108) +10/08 14:44:06.046: [smf] WARNING: [3c85dd06-0996-41eb-a985-476fa905aefc] Retry to registration with NRF (../src/smf/nf-sm.c:161) +10/08 14:44:06.047: [sbi] WARNING: [7] Failed to connect to ::1 port 7777: Connection refused (../lib/sbi/client.c:450) +``` + +To prevent SMF from attempting to access the 5G NRF, you need to modify the SMF configuration file as below. + +```diff +$ diff -u ./install/etc/open5gs/smf.yaml.old ./install/etc/open5gs/smf.yaml +--- ./install/etc/open5gs/smf.yaml.old 2020-10-08 14:43:20.599734045 -0400 ++++ ./install/etc/open5gs/smf.yaml 2020-10-08 14:44:21.864952687 -0400 +@@ -168,9 +168,9 @@ + # - ::1 + # + smf: +- sbi: +- - addr: 127.0.0.4 +- port: 7777 ++# sbi: ++# - addr: 127.0.0.4 ++# port: 7777 + gtpc: + - addr: 127.0.0.4 + - addr: ::1 +@@ -214,12 +214,12 @@ + # - 127.0.0.10 + # - fe80::1%lo + # +-nrf: +- sbi: +- - addr: +- - 127.0.0.10 +- - ::1 +- port: 7777 ++#nrf: ++# sbi: ++# - addr: ++# - 127.0.0.10 ++# - ::1 ++# port: 7777 + + # + # upf: +``` + +If you set as above and run SMF, you do not need to run NRF. Seven daemons operate in 4G only state. + #### How to change UE IP Pool The Open5GS package contains a systemd-networkd configuration file for `ogstun`. Therefore, you must first modify the configuration file as follows. diff --git a/docs/_posts/2020-10-09-release-v2.0.18.md b/docs/_posts/2020-10-09-release-v2.0.18.md index b91c44c1b..0c506d696 100644 --- a/docs/_posts/2020-10-09-release-v2.0.18.md +++ b/docs/_posts/2020-10-09-release-v2.0.18.md @@ -1,5 +1,5 @@ --- -title: "v2.0.18 - 100+ UEs tested" +title: "v2.0.18 - 250+ UEs tested" date: 2020-10-09 07:53:00 -0400 categories: - Release diff --git a/lib/pfcp/handler.c b/lib/pfcp/handler.c index b4485bfcd..186763255 100644 --- a/lib/pfcp/handler.c +++ b/lib/pfcp/handler.c @@ -64,6 +64,16 @@ void ogs_pfcp_cp_handle_association_setup_request( ogs_pfcp_parse_user_plane_ip_resource_info(&info, message); ogs_pfcp_gtpu_resource_add(&node->gtpu_resource_list, &info); } + + if (req->up_function_features.presence) { + if (req->up_function_features.data && req->up_function_features.len) { + ogs_pfcp_self()->up_function_features_len = + req->up_function_features.len; + memcpy(&ogs_pfcp_self()->up_function_features, + req->up_function_features.data, + ogs_pfcp_self()->up_function_features_len); + } + } } void ogs_pfcp_cp_handle_association_setup_response( @@ -91,6 +101,16 @@ void ogs_pfcp_cp_handle_association_setup_response( ogs_pfcp_parse_user_plane_ip_resource_info(&info, message); ogs_pfcp_gtpu_resource_add(&node->gtpu_resource_list, &info); } + + if (rsp->up_function_features.presence) { + if (rsp->up_function_features.data && rsp->up_function_features.len) { + ogs_pfcp_self()->up_function_features_len = + rsp->up_function_features.len; + memcpy(&ogs_pfcp_self()->up_function_features, + rsp->up_function_features.data, + ogs_pfcp_self()->up_function_features_len); + } + } } void ogs_pfcp_up_handle_association_setup_request( @@ -100,6 +120,11 @@ void ogs_pfcp_up_handle_association_setup_request( ogs_assert(xact); ogs_pfcp_up_send_association_setup_response( xact, OGS_PFCP_CAUSE_REQUEST_ACCEPTED); + + if (req->cp_function_features.presence) { + ogs_pfcp_self()->cp_function_features.octet5 = + req->cp_function_features.u8; + } } void ogs_pfcp_up_handle_association_setup_response( @@ -108,6 +133,11 @@ void ogs_pfcp_up_handle_association_setup_response( { ogs_assert(xact); ogs_pfcp_xact_commit(xact); + + if (rsp->cp_function_features.presence) { + ogs_pfcp_self()->cp_function_features.octet5 = + rsp->cp_function_features.u8; + } } void ogs_pfcp_up_handle_pdr( diff --git a/lib/pfcp/types.h b/lib/pfcp/types.h index c1f832d15..ebb4193c1 100644 --- a/lib/pfcp/types.h +++ b/lib/pfcp/types.h @@ -97,9 +97,32 @@ typedef uint32_t ogs_pfcp_precedence_t; typedef uint8_t ogs_pfcp_interface_t; /* 8.2.25 UP Function Features */ + typedef struct ogs_pfcp_up_function_features_s { union { struct { +/* + * 5/8 TREU Sxb, Sxc, N4 + * Traffic Redirection Enforcement in the UP function is supported + * by the UP function. + * 5/7 HEEU Sxb, Sxc, N4 + * Header Enrichment of Uplink traffic is supported by the UP function. + * 5/6 PFDM Sxb, Sxc, N4 + * The PFD Management procedure is supported by the UP function. + * 5/5 FTUP Sxa, Sxb, N4 + * F-TEID allocation / release in the UP function is supported + * by the UP function. + * 5/4 TRST Sxb, Sxc, N4 + * Traffic Steering is supported by the UP function. + * 5/3 DLBD Sxa, N4 + * The buffering parameter 'DL Buffering Duration' is supported + * by the UP function. + * 5/2 DDND Sxa, N4 + * The buffering parameter 'Downlink Data Notification Delay' is supported + * by the UP function. + * 5/1 BUCP Sxa, N4 + * Downlink Data Buffering in CP function is supported by the UP function. + */ ED8(uint8_t treu:1;, uint8_t heeu:1;, uint8_t pfdm:1;, @@ -113,6 +136,28 @@ ED8(uint8_t treu:1;, }; union { struct { +/* + * 6/8 EPFAR Sxa, Sxb, Sxc, N4 + * The UP function supports the Enhanced PFCP Association Release feature + * (see clause 5.18). + * 6/7 PFDE Sxb, N4 + * The UP function supports a PFD Contents including a property + * with multiple values. + * 6/6 FRRT Sxb, N4 + * The UP function supports Framed Routing + * (see IETF RFC 2865 [37] and IETF RFC 3162 [38]). + * 6/5 TRACE Sxa, Sxb, Sxc, N4 + * The UP function supports Trace (see clause 5.15). + * 6/4 QUOAC Sxb, Sxc, N4 + * The UP function supports being provisioned with the Quota Action + * to apply when reaching quotas. + * 6/3 UDBC Sxb, Sxc, N4 + * Support of UL/DL Buffering Control + * 6/2 PDIU Sxa, Sxb, Sxc, N4 + * Support of PDI optimised signalling in UP function (see clause 5.2.1A.2). + * 6/1 EMPU Sxa, Sxb, N4 + * Sending of End Marker packets supported by the UP function. + */ ED8(uint8_t epfar:1;, uint8_t pfde:1;, uint8_t frrt:1;, @@ -126,6 +171,29 @@ ED8(uint8_t epfar:1;, }; union { struct { +/* + * 7/8 GCOM N4 + * UPF support of 5G VN Group Communication.(See clause 5.23) + * 7/7 BUNDL Sxa, Sxb, Sxc, N4 + * PFCP messages bunding (see clause 6.5) is supported by the UP function. + * 7/6 MTE N4 + * UPF supports multiple instances of Traffic Endpoint IDs in a PDI. + * 7/5 MNOP Sxa, Sxb, Sxc, N4 + * The UP function supports measurement of number of packets + * which is instructed with the flag 'Measurement of Number of Packets' + * in a URR.See also clause 5.2.2.2.1. + * 7/4 SSET N4 + * UPF support of PFCP sessions successively controlled + * by different SMFs of a same SMF Set (see clause 5.22). + * 7/3 UEIP Sxb, N4 + * The UP function supports allocating UE IP addresses or prefixes + * (see clause 5.21). + * 7/2 ADPDP Sxa, Sxb, Sxc, N4 + * The UP function supports the Activation and Deactivation + * of Pre-defined PDRs (see clause 5.19). + * 7/1 DPDRA Sxb, Sxc, N4 + * The UP function supports Deferred PDR Activation or Deactivation. + */ ED8(uint8_t gcom:1;, uint8_t bundl:1;, uint8_t mte:1;, @@ -139,6 +207,32 @@ ED8(uint8_t gcom:1;, }; union { struct { +/* + * 8/8 MPTCP N4 + * UPF support of MPTCP Proxy functionality (see clause 5.20) + * 8/7 TSCU N4 + * Time Sensitive Communication is supported by the UPF (see clause 5.26). + * 8/6 IP6PL N4 + * UPF supports: + * - UE IPv6 address(es) allocation with IPv6 prefix length other than + * default /64 (including allocating /128 individual IPv6 addresses), + * as specified in clause 4.6.2.2 of of 3GPP TS 23.316 [57]; and + * - multiple UE IPv6 addresses allocation using multiple instances + * of the UE IP Address IE in a same PDI or Traffic Endpoint, + * or using multiple PDIs or Traffic Endpoints + * with a different UE IP Address as specified in clause 5.21.1. + * 8/5 IPTV N4 + * UPF support of IPTV service (see clause 5.25) + * 8/4 NORP Sxa, Sxb, Sxc, N4 + * UP function support of Number of Reports as specified in clause 5.2.2.2. + * 8/3 VTIME Sxb,N4 + * UP function support of quota validity time feature. + * 8/2 RTTL N4 + * UPF supports redundant transmission at transport layer. + * 8/1 MPAS N4 + * UPF support for multiple PFCP associations to the SMFs in an SMF set + * (see clause 5.22.3). + */ ED8(uint8_t mptcp:1;, uint8_t tscu:1;, uint8_t ip6pl:1;, @@ -152,6 +246,27 @@ ED8(uint8_t mptcp:1;, }; union { struct { +/* + * 9/8 RDS Sxb, N4 + * UP function support of Reliable Data Service (see clause 5.29). + * 9/7 DDDS N4 + * UPF support of reporting the first buffered / discarded downlink data + * for downlink data delivery status notification. + * 9/6 ETHAR N4 + * UPF support of Ethernet PDU Session Anchor Relocation (see clause 5.13.6). + * 9/5 CIOT Sxb, N4 + * UP function support of CIoT feature, + * e.g.small data packet rate enforcement.(see 5.4.15) + * 9/4 MT-EDT Sxa + * SGW-U support of reporting the size of DL Data Packets. + * (see clause 5.2.4.1). + * 9/3 GPQM N4 + * UPF support of per GTP-U Path QoS monitoring (see clause 5.24.5). + * 9/2 QFQM N4 + * UPF support of per QoS flow per UE QoS monitoring (see clause 5.24.4). + * 9/1 ATSSS-LL N4 + * UPF support of ATSSS-LLL steering functionality (see clause 5.20) + */ ED8(uint8_t rds:1;, uint8_t ddds:1;, uint8_t ethar:1;, @@ -165,6 +280,10 @@ ED8(uint8_t rds:1;, }; union { struct { +/* + * 10/1 RTTWP N4 + * UPF support of RTT measurements towards the UE Without PMF. + */ ED2(uint8_t reserved:7;, uint8_t rttwp:1;) }; @@ -203,7 +322,32 @@ typedef uint8_t ogs_pfcp_apply_action_t; typedef struct ogs_pfcp_cp_function_features_s { union { struct { -ED8(uint8_t reserved:1;, + +/* + * 5/8 UIAUR Sxb, N4 + * CP function supports the UE IP Address Usage Reporting feature, + * i.e. receiving and handling of UE IP Address Usage Information IE + * (see clause 5.21.3.2). + * 5/7 ARDR Sxb, N4 + * CP function supports Additional Usage Reports + * in the PFCP Session Deletion Response (see clause 5.2.2.3.1). + * 5/6 MPAS N4 + * SMF support for multiple PFCP associations from an SMF set to a single UPF + * (see clause 5.22.3). + * 5/5 BUNDL Sxa, Sxb, Sxc, N4 + * PFCP messages bunding (see clause 6.5) is supported by the CP function. + * 5/4 SSET N4 + * SMF support of PFCP sessions successively controlled by different SMFs + * of a same SMF Set (see clause 5.22). + * 5/3 EPFAR Sxa, Sxb, Sxc, N4 + * The CP function supports the Enhanced PFCP Association Release feature + * (see clause 5.18). + * 5/2 OVRL Sxa, Sxb, Sxc, N4 + * Overload Control is supported by the CP function. + * 5/1 LOAD Sxa, Sxb, Sxc, N4 + * Load Control is supported by the CP function. + */ +ED8(uint8_t uiaur:1;, uint8_t apdr:1;, uint8_t mpas:1;, uint8_t bundl:1;, diff --git a/src/sgwc/s11-handler.c b/src/sgwc/s11-handler.c index 344a12f54..1b8c928ec 100644 --- a/src/sgwc/s11-handler.c +++ b/src/sgwc/s11-handler.c @@ -308,7 +308,6 @@ void sgwc_s11_handle_modify_bearer_request( } if (req->user_location_information.presence == 1) { - /* if GTP Node changes, End Marker is sent out or not */ decoded = ogs_gtp_parse_uli( &uli, &req->user_location_information); ogs_assert(req->user_location_information.len == decoded); @@ -334,7 +333,11 @@ void sgwc_s11_handle_modify_bearer_request( memcmp(&dl_tunnel->remote_ip, &remote_ip, sizeof(ogs_ip_t)) != 0) { /* eNB IP is changed during handover */ - flags |= OGS_PFCP_MODIFY_END_MARKER; + if (ogs_pfcp_self()->up_function_features.empu) { + flags |= OGS_PFCP_MODIFY_END_MARKER; + } else { + ogs_error("SGW-U does not support End Marker"); + } } memcpy(&dl_tunnel->remote_ip, &remote_ip, sizeof(ogs_ip_t)); diff --git a/src/sgwu/context.c b/src/sgwu/context.c index 7c91ba6b5..13ed78d71 100644 --- a/src/sgwu/context.c +++ b/src/sgwu/context.c @@ -38,6 +38,7 @@ void sgwu_context_init(void) ogs_log_install_domain(&__sgwu_log_domain, "sgwu", ogs_core()->log.level); /* Setup UP Function Features */ + ogs_pfcp_self()->up_function_features.ftup = 1; ogs_pfcp_self()->up_function_features.empu = 1; ogs_pfcp_self()->up_function_features_len = 2; diff --git a/src/upf/context.c b/src/upf/context.c index 75fa54811..fcff52289 100644 --- a/src/upf/context.c +++ b/src/upf/context.c @@ -38,6 +38,7 @@ void upf_context_init(void) ogs_log_install_domain(&__upf_log_domain, "upf", ogs_core()->log.level); /* Setup UP Function Features */ + ogs_pfcp_self()->up_function_features.ftup = 1; ogs_pfcp_self()->up_function_features.empu = 1; ogs_pfcp_self()->up_function_features_len = 2;