rmnet_offload: I721bd69521fe4aa8daebefb280d8d1509f91e673

Update module to version I721bd69521fe4aa8daebefb280d8d1509f91e673 Change-Id: I321b1be25fbed91b164c9fae9b606a2d87b62c92
2020-05-26 17:43:00 -06:00
commit 670ea10293
--- a/datarmnet_ext_dlkm_vendor_board.mk
+++ b/datarmnet_ext_dlkm_vendor_board.mk
@@ -0,0 +1,7 @@
+#Build rmnet modules
+DATA_DLKM_BOARD_PLATFORMS_LIST := lahaina
+ifneq ($(TARGET_BOARD_AUTO),true)
+ifeq ($(call is-board-platform-in-list,$(DATA_DLKM_BOARD_PLATFORMS_LIST)),true)
+BOARD_VENDOR_KERNEL_MODULES += $(KERNEL_MODULES_OUT)/rmnet_offload.ko
+endif
+endif
--- a/datarmnet_ext_dlkm_vendor_product.mk
+++ b/datarmnet_ext_dlkm_vendor_product.mk
@@ -0,0 +1 @@
+PRODUCT_PACKAGES += rmnet_offload.ko
--- a/offload/Android.mk
+++ b/offload/Android.mk
@@ -0,0 +1,44 @@
+ifneq ($(TARGET_BOARD_AUTO),true)
+ifneq ($(TARGET_PRODUCT),qssi)
+
+RMNET_OFFLOAD_DLKM_PLATFORMS_LIST := lahaina
+
+ifeq ($(call is-board-platform-in-list, $(RMNET_OFFLOAD_DLKM_PLATFORMS_LIST)),true)
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_PATH := $(KERNEL_MODULES_OUT)
+
+LOCAL_MODULE := rmnet_offload.ko
+LOCAL_SRC_FILES := \
+	rmnet_offload_state.c \
+	rmnet_offload_main.c \
+	rmnet_offload_engine.c \
+	rmnet_offload_tcp.c \
+	rmnet_offload_udp.c \
+	rmnet_offload_stats.c \
+	rmnet_offload_knob.c
+
+
+#path from build top to the core directory
+RMNET_CORE_PATH := vendor/qcom/opensource/datarmnet/core
+DLKM_DIR := $(TOP)/device/qcom/common/dlkm
+#absolute path to the build directory. Can't use $(TOP) here since
+#that resolves to ., and we pass this to Kbuild, where . is different
+RMNET_CORE_INC_DIR := $(shell pwd)/$(RMNET_CORE_PATH)
+
+#pass variables down to Kbuild environment
+KBUILD_OPTIONS := RMNET_CORE_INC_DIR=$(RMNET_CORE_INC_DIR)
+KBUILD_OPTIONS += RMNET_CORE_PATH=$(RMNET_CORE_PATH)
+KBUILD_OPTIONS_GKI := RMNET_CORE_INC_DIR=$(RMNET_CORE_INC_DIR)
+KBUILD_OPTIONS_GKI += RMNET_CORE_PATH=$(RMNET_CORE_PATH)/gki
+
+#Must be built after the core rmnet module
+LOCAL_ADDITIONAL_DEPENDENCIES := $(TARGET_OUT_INTERMEDIATES)/$(RMNET_CORE_PATH)/rmnet_core.ko
+LOCAL_ADDITIONAL_DEPENDENCIES_GKI := $(TARGET_OUT_INTERMEDIATES)/$(RMNET_CORE_PATH)/gki/rmnet_core.ko
+
+include $(DLKM_DIR)/AndroidKernelModule.mk
+
+endif #End of check for target
+endif #End of Check for qssi target
+endif #End of check for AUTO Target
--- a/offload/Kbuild
+++ b/offload/Kbuild
@@ -0,0 +1,10 @@
+#rmnet_perf needs the symbols from the core driver module
+KBUILD_EXTRA_SYMBOLS := $(shell pwd)/../../$(RMNET_CORE_PATH)/Module.symvers
+
+obj-m += rmnet_offload.o
+#Need core headers
+ccflags-y := -I$(RMNET_CORE_INC_DIR)
+rmnet_offload-y := rmnet_offload_state.o rmnet_offload_main.o \
+		   rmnet_offload_engine.o rmnet_offload_tcp.o \
+		   rmnet_offload_udp.o rmnet_offload_stats.o \
+		   rmnet_offload_knob.o
--- a/offload/Kconfig
+++ b/offload/Kconfig
@@ -0,0 +1,10 @@
+#
+# RMNET_OFFLOAD driver
+#
+
+menuconfig RMNET_OFFLOAD
+    tristate "Rmnet offload support"
+    default m
+    depends on RMNET_CORE
+    ---help---
+        Offload support for the RmNet driver
--- a/offload/Makefile
+++ b/offload/Makefile
@@ -0,0 +1,13 @@
+#By default build for CLD
+RMNET_OFFLOAD_SELECT := CONFIG_RMNET_OFFLOAD=m
+KBUILD_OPTIONS += $(RMNET_OFFLOAD_SELECT)
+KBUILD_OPTIONS += $(KBUILD_EXTRA) # Extra config if any
+
+all:
+	$(MAKE) -C $(KERNEL_SRC) M=$(shell pwd) modules $(KBUILD_OPTIONS)
+
+modules_install:
+	$(MAKE) INSTALL_MOD_STRIP=1 -C $(KERNEL_SRC) M=$(shell pwd) modules_install
+
+clean:
+	$(MAKE) -C $(KERNEL_SRC) M=$(PWD) clean
--- a/offload/rmnet_offload_engine.c
+++ b/offload/rmnet_offload_engine.c
@@ -0,0 +1,196 @@
+/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/log2.h>
+#include <linux/list.h>
+#include <linux/hashtable.h>
+#include "rmnet_descriptor.h"
+#include "rmnet_offload_state.h"
+#include "rmnet_offload_engine.h"
+#include "rmnet_offload_main.h"
+#include "rmnet_offload_tcp.h"
+#include "rmnet_offload_udp.h"
+#include "rmnet_offload_stats.h"
+#include "rmnet_offload_knob.h"
+#define DATARMNETc9a92fd5dc \
+	(const_ilog2(DATARMNET51fcd2e93a))
+static DEFINE_HASHTABLE(DATARMNETab0dbdf89d,DATARMNETc9a92fd5dc);static u32 
+DATARMNETb2ff7800c4(u8 DATARMNET22afafde5e){struct DATARMNET31caee06e2*
+DATARMNET0277af6816;int DATARMNET6090c652d3;u32 DATARMNET67497a3454=
+(0x145b+644-0x16df);hash_for_each(DATARMNETab0dbdf89d,DATARMNET6090c652d3,
+DATARMNET0277af6816,DATARMNET0a9c7c9a12){if(DATARMNET0277af6816->
+DATARMNET30d367f886&&DATARMNET0277af6816->DATARMNETb2a7197d60==
+DATARMNET22afafde5e){DATARMNET67497a3454++;DATARMNET3bdaf91675(
+DATARMNET0277af6816);}}return DATARMNET67497a3454;}static bool 
+DATARMNET5d54389061(u8 DATARMNET22afafde5e){u64 DATARMNET75cb1c0f3f;
+DATARMNET75cb1c0f3f=DATARMNET3d487d950f(DATARMNETe9b360aea8);if(
+DATARMNET75cb1c0f3f==DATARMNET651e3c6554)return true;if(DATARMNET75cb1c0f3f==
+DATARMNETb94ae69059&&DATARMNET22afafde5e==DATARMNET70889e5696)return true;if(
+DATARMNET75cb1c0f3f==DATARMNETda679f58ba&&DATARMNET22afafde5e==
+DATARMNETb02d95e937)return true;return false;}static bool DATARMNET9c6847635e(
+struct DATARMNET31caee06e2*DATARMNETd44a80d414,struct DATARMNETadd6ff90d0*
+DATARMNETc3ffad4b30){if(!DATARMNETd44a80d414->DATARMNET30d367f886)return false;
+if(DATARMNETc3ffad4b30->DATARMNET9f5b2909c8==(0x54a+6318-0x1df4)){struct 
+DATARMNETf61a39bce9*DATARMNETb5da236f91,*DATARMNET4e35bbb67d;DATARMNETb5da236f91
+=DATARMNETd44a80d414->DATARMNETd321db9bb1;DATARMNET4e35bbb67d=
+DATARMNETc3ffad4b30->DATARMNET574a565f78;if(DATARMNETb5da236f91->
+DATARMNET58886f3d9d^DATARMNET4e35bbb67d->DATARMNET58886f3d9d||
+DATARMNETb5da236f91->DATARMNET14d3de9c1a^DATARMNET4e35bbb67d->
+DATARMNET14d3de9c1a||DATARMNETb5da236f91->DATARMNETa803e4f68b^
+DATARMNET4e35bbb67d->DATARMNETa803e4f68b||DATARMNETb5da236f91->
+DATARMNET422c25939d^DATARMNET4e35bbb67d->DATARMNET422c25939d)return true;}else 
+if(DATARMNETc3ffad4b30->DATARMNET9f5b2909c8==(0x1ff5+182-0x20a5)){__be32 
+DATARMNET55aa748931,DATARMNET34282dc487;__be32 DATARMNETfc68f228ca;
+DATARMNET55aa748931=DATARMNETd44a80d414->DATARMNET85d5545fb8->
+DATARMNETd750a8b9e5;DATARMNET34282dc487=DATARMNETc3ffad4b30->DATARMNET1dab0af728
+->DATARMNETd750a8b9e5;DATARMNETfc68f228ca=DATARMNET55aa748931^
+DATARMNET34282dc487;if(DATARMNETfc68f228ca&htonl(267386880))return true;}return 
+false;}static bool DATARMNETa96491b775(struct DATARMNET31caee06e2*
+DATARMNETd44a80d414,struct DATARMNETadd6ff90d0*DATARMNETc3ffad4b30){__be16 
+DATARMNETffe972c30a,DATARMNETfee6a33770,DATARMNET063a3638c1,DATARMNETf80930b49f;
+if(!DATARMNETd44a80d414->DATARMNET30d367f886)return DATARMNETd44a80d414->
+DATARMNET2bb18bc9dd==DATARMNETc3ffad4b30->DATARMNET68ad0738e2;if(
+DATARMNETd44a80d414->DATARMNETb2a7197d60!=DATARMNETc3ffad4b30->
+DATARMNET072708db10)return false;DATARMNETffe972c30a=DATARMNETd44a80d414->
+DATARMNETef42c82b6f->DATARMNETaad9b0a864;DATARMNET063a3638c1=DATARMNETd44a80d414
+->DATARMNETef42c82b6f->DATARMNETd751c12d13;DATARMNETfee6a33770=
+DATARMNETc3ffad4b30->DATARMNETc51cdf696b->DATARMNETaad9b0a864;
+DATARMNETf80930b49f=DATARMNETc3ffad4b30->DATARMNETc51cdf696b->
+DATARMNETd751c12d13;if(DATARMNETffe972c30a^DATARMNETfee6a33770||
+DATARMNET063a3638c1^DATARMNETf80930b49f)return false;if(DATARMNETc3ffad4b30->
+DATARMNET9f5b2909c8==(0x19f+8819-0x240e)){struct DATARMNETf61a39bce9*
+DATARMNETb5da236f91,*DATARMNET4e35bbb67d;DATARMNETb5da236f91=DATARMNETd44a80d414
+->DATARMNETd321db9bb1;DATARMNET4e35bbb67d=DATARMNETc3ffad4b30->
+DATARMNET574a565f78;if(DATARMNETb5da236f91->DATARMNET7c6ed51964^
+DATARMNET4e35bbb67d->DATARMNET7c6ed51964||DATARMNETb5da236f91->
+DATARMNET799b2a47a5^DATARMNET4e35bbb67d->DATARMNET799b2a47a5)return false;}else 
+if(DATARMNETc3ffad4b30->DATARMNET9f5b2909c8==(0x53a+3466-0x12be)){struct 
+DATARMNETfab66e680d*DATARMNETb5da236f91,*DATARMNET4e35bbb67d;DATARMNETb5da236f91
+=DATARMNETd44a80d414->DATARMNET85d5545fb8;DATARMNET4e35bbb67d=
+DATARMNETc3ffad4b30->DATARMNET1dab0af728;if(memcmp(DATARMNETb5da236f91->
+DATARMNET0f6f3a8868,DATARMNET4e35bbb67d->DATARMNET0f6f3a8868,sizeof(
+DATARMNET4e35bbb67d->DATARMNET0f6f3a8868))||memcmp(DATARMNETb5da236f91->
+DATARMNET818f335f71,DATARMNET4e35bbb67d->DATARMNET818f335f71,sizeof(
+DATARMNET4e35bbb67d->DATARMNET818f335f71)))return false;}else{return false;}
+return true;}static struct DATARMNET31caee06e2*DATARMNET30062b5353(void){struct 
+DATARMNET8357daf015*DATARMNETf7e8f6395c=DATARMNETccc25794e0();struct 
+DATARMNET337e435e40*DATARMNET048da5e00c;struct DATARMNET31caee06e2*
+DATARMNETc5c31601b9;DATARMNET048da5e00c=&DATARMNETf7e8f6395c->
+DATARMNETa3d1da1cba;if(DATARMNET048da5e00c->DATARMNET762f0d12b6<
+DATARMNET51fcd2e93a){DATARMNETc5c31601b9=&DATARMNET048da5e00c->
+DATARMNET51e299cf9c[DATARMNET048da5e00c->DATARMNET762f0d12b6];
+DATARMNET048da5e00c->DATARMNET762f0d12b6++;return DATARMNETc5c31601b9;}
+DATARMNETc5c31601b9=&DATARMNET048da5e00c->DATARMNET51e299cf9c[
+DATARMNET048da5e00c->DATARMNETded3d12c96];DATARMNET048da5e00c->
+DATARMNETded3d12c96++;DATARMNET048da5e00c->DATARMNETded3d12c96%=
+DATARMNET51fcd2e93a;hash_del(&DATARMNETc5c31601b9->DATARMNET0a9c7c9a12);
+if(DATARMNETc5c31601b9->DATARMNET30d367f886){DATARMNET5d24865423(
+DATARMNETa05aa2c4a7);DATARMNET3bdaf91675(DATARMNETc5c31601b9);}return
+DATARMNETc5c31601b9;}static void DATARMNET3d9424a1f2(void){
+DATARMNET8f8c3a4cc3();if(DATARMNET54fd6bf483())DATARMNET5d24865423(
+DATARMNETc0fe927262);DATARMNET4c69e80b6f();}void DATARMNETafcdd1146f(void){
+rcu_assign_pointer(rmnet_perf_chain_end,DATARMNET3d9424a1f2);}void 
+DATARMNET28dfa538f2(void){rcu_assign_pointer(rmnet_perf_chain_end,NULL);}int 
+DATARMNET467c2610cd(u64 DATARMNET842aaafdc8,u64 DATARMNET7c1185ffbf){u32 
+DATARMNET67497a3454=(0x52d+7239-0x2174);if(DATARMNET842aaafdc8==
+DATARMNET7d2f8bdc64||DATARMNET7c1185ffbf==DATARMNET651e3c6554)return
+(0x1053+1012-0x1447);switch(DATARMNET7c1185ffbf){case DATARMNETb94ae69059:
+DATARMNET67497a3454=DATARMNETb2ff7800c4(DATARMNETb02d95e937);break;case 
+DATARMNETda679f58ba:DATARMNET67497a3454=DATARMNETb2ff7800c4(DATARMNET70889e5696)
+;break;case DATARMNET7d2f8bdc64:DATARMNET67497a3454=DATARMNET54fd6bf483();break;
+}DATARMNETa3edc29191(DATARMNET2ec91e73cf,DATARMNET67497a3454);return
+(0x349+1374-0x8a7);}void DATARMNET3bdaf91675(struct DATARMNET31caee06e2*
+DATARMNETd44a80d414){struct DATARMNET8357daf015*DATARMNETf7e8f6395c=
+DATARMNETccc25794e0();struct rmnet_frag_descriptor*DATARMNETb2b92619af,*
+DATARMNETe6a1f8e9a8,*DATARMNETb9b0dca770;u32 DATARMNET439e3442b2=
+DATARMNETd44a80d414->DATARMNET5f92dbf405+DATARMNETd44a80d414->
+DATARMNET2e943b139f+DATARMNETd44a80d414->DATARMNET00656e1145;if(!
+DATARMNETd44a80d414->DATARMNET30d367f886)return;DATARMNETb2b92619af=
+list_first_entry(&DATARMNETd44a80d414->DATARMNETdaf24e965e,struct 
+rmnet_frag_descriptor,list);if(!DATARMNETb2b92619af->gso_segs)
+DATARMNETb2b92619af->gso_segs=(0x1058+4757-0x22ec);DATARMNETb2b92619af->gso_size
+=DATARMNETd44a80d414->DATARMNET632219f39d;DATARMNETe6a1f8e9a8=
+DATARMNETb2b92619af;list_for_each_entry_safe_continue(DATARMNETe6a1f8e9a8,
+DATARMNETb9b0dca770,&DATARMNETd44a80d414->DATARMNETdaf24e965e,list){if(
+DATARMNETe6a1f8e9a8->hdr_ptr==rmnet_frag_data_ptr(DATARMNETe6a1f8e9a8)){if(!
+rmnet_frag_pull(DATARMNETe6a1f8e9a8,DATARMNETf7e8f6395c->DATARMNET547651077b,
+DATARMNETd44a80d414->DATARMNET2e943b139f+DATARMNETd44a80d414->
+DATARMNET00656e1145))continue;}list_del(&DATARMNETe6a1f8e9a8->list);
+list_add_tail(&DATARMNETe6a1f8e9a8->list,&DATARMNETb2b92619af->sub_frags);
+DATARMNETb2b92619af->gso_segs+=(DATARMNETe6a1f8e9a8->gso_segs)?:
+(0x11b6+461-0x1382);}DATARMNETb2b92619af->hash=DATARMNETd44a80d414->
+DATARMNET2bb18bc9dd;DATARMNET654b85a739(DATARMNETb2b92619af,DATARMNET439e3442b2)
+;DATARMNETd44a80d414->DATARMNET30d367f886=(0x1c9b+1105-0x20ec);
+DATARMNETd44a80d414->DATARMNET5f92dbf405=(0xb26+2684-0x15a2);}void 
+DATARMNET8b657e07e9(u32 DATARMNETb7b515b920){struct DATARMNET31caee06e2*
+DATARMNETd44a80d414;hash_for_each_possible(DATARMNETab0dbdf89d,
+DATARMNETd44a80d414,DATARMNET0a9c7c9a12,DATARMNETb7b515b920){if(
+DATARMNETd44a80d414->DATARMNET2bb18bc9dd==DATARMNETb7b515b920&&
+DATARMNETd44a80d414->DATARMNET30d367f886)DATARMNET3bdaf91675(DATARMNETd44a80d414
+);}}u32 DATARMNET54fd6bf483(void){struct DATARMNET31caee06e2*DATARMNETd44a80d414
+;int DATARMNET6090c652d3;u32 DATARMNET67497a3454=(0x16b4+2078-0x1ed2);
+hash_for_each(DATARMNETab0dbdf89d,DATARMNET6090c652d3,DATARMNETd44a80d414,
+DATARMNET0a9c7c9a12){if(DATARMNETd44a80d414->DATARMNET30d367f886){
+DATARMNET67497a3454++;DATARMNET3bdaf91675(DATARMNETd44a80d414);}}return 
+DATARMNET67497a3454;}void DATARMNETfc01092f09(struct DATARMNET31caee06e2*
+DATARMNETd44a80d414,struct DATARMNETadd6ff90d0*DATARMNETc3ffad4b30){if(
+DATARMNETc3ffad4b30->DATARMNET1e7926dc4c){DATARMNETd44a80d414->
+DATARMNET6b35defba1=DATARMNETc3ffad4b30->DATARMNET9f5b2909c8;DATARMNETd44a80d414
+->DATARMNET2e943b139f=DATARMNETc3ffad4b30->DATARMNETa7eaea0d00;
+DATARMNETd44a80d414->DATARMNETd321db9bb1=DATARMNETc3ffad4b30->
+DATARMNET574a565f78;DATARMNETd44a80d414->DATARMNETb2a7197d60=DATARMNETc3ffad4b30
+->DATARMNET072708db10;DATARMNETd44a80d414->DATARMNET00656e1145=
+DATARMNETc3ffad4b30->DATARMNETfeb7c81ac7;DATARMNETd44a80d414->
+DATARMNET9a5f6d68d4=DATARMNETc3ffad4b30->DATARMNET7ff34eacb7;DATARMNETd44a80d414
+->DATARMNET2bb18bc9dd=DATARMNETc3ffad4b30->DATARMNET68ad0738e2;
+DATARMNETd44a80d414->DATARMNET632219f39d=(DATARMNETc3ffad4b30->
+DATARMNET798fafaf36->gso_size)?:DATARMNETc3ffad4b30->DATARMNET5671455f38;if(
+DATARMNETc3ffad4b30->DATARMNET072708db10==DATARMNET70889e5696){__be32 
+DATARMNETff7464c709;if(DATARMNETc3ffad4b30->DATARMNET798fafaf36->tcp_seq_set)
+DATARMNETff7464c709=DATARMNETc3ffad4b30->DATARMNET798fafaf36->tcp_seq;else 
+DATARMNETff7464c709=DATARMNETc3ffad4b30->DATARMNET7ff34eacb7->
+DATARMNET614032cc71;DATARMNETd44a80d414->DATARMNET956bd73340=ntohl(
+DATARMNETff7464c709);}}if(DATARMNETc3ffad4b30->DATARMNET072708db10==
+DATARMNET70889e5696)DATARMNETd44a80d414->DATARMNET956bd73340+=
+DATARMNETc3ffad4b30->DATARMNET5671455f38;list_add_tail(&DATARMNETc3ffad4b30->
+DATARMNET798fafaf36->list,&DATARMNETd44a80d414->DATARMNETdaf24e965e);
+DATARMNETd44a80d414->DATARMNET30d367f886++;DATARMNETd44a80d414->
+DATARMNET5f92dbf405+=DATARMNETc3ffad4b30->DATARMNET5671455f38;}bool 
+DATARMNET9b8a1a69f3(struct DATARMNETadd6ff90d0*DATARMNETc3ffad4b30){struct 
+DATARMNET31caee06e2*DATARMNETd44a80d414;bool DATARMNET262f926565=false;if(!
+DATARMNET5d54389061(DATARMNETc3ffad4b30->DATARMNET072708db10)){
+DATARMNET5d24865423(DATARMNETdae7cbfd97);return false;}hash_for_each_possible(
+DATARMNETab0dbdf89d,DATARMNETd44a80d414,DATARMNET0a9c7c9a12,DATARMNETc3ffad4b30
+->DATARMNET68ad0738e2){bool DATARMNET4e4b105fa2;if(!DATARMNETa96491b775(
+DATARMNETd44a80d414,DATARMNETc3ffad4b30))continue;DATARMNETb9fc1ffb2f:
+DATARMNET4e4b105fa2=DATARMNET9c6847635e(DATARMNETd44a80d414,DATARMNETc3ffad4b30)
+;DATARMNETc3ffad4b30->DATARMNET1e7926dc4c=true;DATARMNET262f926565=true;switch(
+DATARMNETc3ffad4b30->DATARMNET072708db10){case DATARMNET70889e5696:return 
+DATARMNETb25a21aeeb(DATARMNETd44a80d414,DATARMNETc3ffad4b30,DATARMNET4e4b105fa2)
+;case DATARMNETb02d95e937:return DATARMNET9dd18589e3(DATARMNETd44a80d414,
+DATARMNETc3ffad4b30,DATARMNET4e4b105fa2);default:return false;}}if(!
+DATARMNET262f926565){DATARMNETd44a80d414=DATARMNET30062b5353();
+DATARMNETd44a80d414->DATARMNET2bb18bc9dd=DATARMNETc3ffad4b30->
+DATARMNET68ad0738e2;hash_add(DATARMNETab0dbdf89d,&DATARMNETd44a80d414->
+DATARMNET0a9c7c9a12,DATARMNETd44a80d414->DATARMNET2bb18bc9dd);goto 
+DATARMNETb9fc1ffb2f;}return false;}void DATARMNETde815547a0(void){struct 
+DATARMNET31caee06e2*DATARMNETd44a80d414;struct hlist_node*DATARMNETb9b0dca770;
+int DATARMNET6090c652d3;hash_for_each_safe(DATARMNETab0dbdf89d,
+DATARMNET6090c652d3,DATARMNETb9b0dca770,DATARMNETd44a80d414,DATARMNET0a9c7c9a12)
+hash_del(&DATARMNETd44a80d414->DATARMNET0a9c7c9a12);}int DATARMNETcce014cb1d(
+void){struct DATARMNET8357daf015*DATARMNETf7e8f6395c=DATARMNETccc25794e0();u8 
+DATARMNET5d971be8b8;for(DATARMNET5d971be8b8=(0xec5+3020-0x1a91);
+DATARMNET5d971be8b8<DATARMNET51fcd2e93a;DATARMNET5d971be8b8++){struct 
+DATARMNET31caee06e2*DATARMNETd44a80d414;DATARMNETd44a80d414=&DATARMNETf7e8f6395c
+->DATARMNETa3d1da1cba.DATARMNET51e299cf9c[DATARMNET5d971be8b8];INIT_LIST_HEAD(&
+DATARMNETd44a80d414->DATARMNETdaf24e965e);INIT_HLIST_NODE(&DATARMNETd44a80d414->
+DATARMNET0a9c7c9a12);}return DATARMNET6e89887168;}
--- a/offload/rmnet_offload_engine.h
+++ b/offload/rmnet_offload_engine.h
@@ -0,0 +1,38 @@
+/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef DATARMNETd6b6392f17
+#define DATARMNETd6b6392f17
+#include <linux/types.h>
+#include "rmnet_offload_main.h"
+#define DATARMNET51fcd2e93a (0x4f2+8429-0x25ad)
+enum{DATARMNET08dbe31d07,DATARMNET6b149bc29f,DATARMNET7d8a4bb6b1,};enum{
+DATARMNETf9e24b5cc7,DATARMNET651e3c6554=DATARMNETf9e24b5cc7,DATARMNETb94ae69059,
+DATARMNETda679f58ba,DATARMNET7d2f8bdc64,DATARMNETb2380d39af=DATARMNET7d2f8bdc64,
+};struct DATARMNET31caee06e2{struct hlist_node DATARMNET0a9c7c9a12;struct 
+list_head DATARMNETdaf24e965e;union{struct DATARMNETf61a39bce9*
+DATARMNETd321db9bb1;struct DATARMNETfab66e680d*DATARMNET85d5545fb8;};union{
+struct DATARMNET1bffb1c388*DATARMNET9a5f6d68d4;struct DATARMNET2d87db499d*
+DATARMNETef42c82b6f;};u32 DATARMNET2bb18bc9dd;u16 DATARMNET5f92dbf405;u16 
+DATARMNET2e943b139f;u16 DATARMNET00656e1145;u8 DATARMNET6b35defba1;u8 
+DATARMNETb2a7197d60;u32 DATARMNET956bd73340;u16 DATARMNET632219f39d;u8 
+DATARMNET30d367f886;};struct DATARMNET337e435e40{struct DATARMNET31caee06e2 
+DATARMNET51e299cf9c[DATARMNET51fcd2e93a];u8 DATARMNET762f0d12b6;u8 
+DATARMNETded3d12c96;};void DATARMNETafcdd1146f(void);void DATARMNET28dfa538f2(
+void);int DATARMNET467c2610cd(u64 DATARMNET842aaafdc8,u64 DATARMNET7c1185ffbf);
+void DATARMNET3bdaf91675(struct DATARMNET31caee06e2*DATARMNETd44a80d414);void 
+DATARMNET8b657e07e9(u32 DATARMNETb7b515b920);u32 DATARMNET54fd6bf483(void);void 
+DATARMNETfc01092f09(struct DATARMNET31caee06e2*DATARMNETd44a80d414,struct 
+DATARMNETadd6ff90d0*DATARMNETc3ffad4b30);bool DATARMNET9b8a1a69f3(struct 
+DATARMNETadd6ff90d0*DATARMNETc3ffad4b30);void DATARMNETde815547a0(void);int 
+DATARMNETcce014cb1d(void);
+#endif
--- a/offload/rmnet_offload_knob.c
+++ b/offload/rmnet_offload_knob.c
@@ -0,0 +1,75 @@
+/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/moduleparam.h>
+#include "rmnet_offload_knob.h"
+#include "rmnet_offload_main.h"
+#include "rmnet_offload_engine.h"
+#define DATARMNET619b9d5952(DATARMNETc8bfe161a0) \
+	static int __ ## DATARMNETc8bfe161a0(const char *DATARMNETc94d3d8015, const \
+struct kernel_param *DATARMNET8a7a56afc0) \
+	{ \
+		return DATARMNETedcd606b67(DATARMNETc94d3d8015, DATARMNET8a7a56afc0, \
+DATARMNETc8bfe161a0); \
+	}
+#define DATARMNETb11903a752(DATARMNETc8bfe161a0, DATARMNET3047f26bfe, \
+DATARMNET4ca0476636, DATARMNET4835fba60c, DATARMNET5303ed5f85) \
+	(struct DATARMNET7f0280a448) { \
+		.DATARMNETd30c98c72c = DATARMNET3047f26bfe, \
+		.DATARMNET9d5e08f187 = DATARMNET4ca0476636, \
+		.DATARMNETbcb261586d = DATARMNET4835fba60c, \
+		.DATARMNETf1c3fbdd8c = DATARMNET5303ed5f85, \
+		.DATARMNET900f84a38b = { \
+			.set = __ ## DATARMNETc8bfe161a0, \
+			.get = param_get_ullong, \
+		}, \
+	}
+#define DATARMNET72f6e45b34(DATARMNETbed8e2ed0c, DATARMNETc8bfe161a0) \
+	module_param_cb(DATARMNETbed8e2ed0c, &DATARMNETb73677dd8c[DATARMNETc8bfe161a0].\
+DATARMNET900f84a38b, \
+			&DATARMNETb73677dd8c[DATARMNETc8bfe161a0].DATARMNETd30c98c72c, \
+(0x1027+73-0xecc))
+struct DATARMNET7f0280a448{u64 DATARMNETd30c98c72c;u64 DATARMNET9d5e08f187;u64 
+DATARMNETbcb261586d;int(*DATARMNETf1c3fbdd8c)(u64 DATARMNET2582fdae21,u64 
+DATARMNET8371e203e8);struct kernel_param_ops DATARMNET900f84a38b;};static int 
+DATARMNETedcd606b67(const char*DATARMNETc94d3d8015,const struct kernel_param*
+DATARMNET8a7a56afc0,u32 DATARMNETc8bfe161a0);DATARMNET619b9d5952(
+DATARMNETee792ef3a0);DATARMNET619b9d5952(DATARMNETfbbc8e2e06);
+DATARMNET619b9d5952(DATARMNETe9b360aea8);static struct DATARMNET7f0280a448 
+DATARMNETb73677dd8c[DATARMNET6fb580e7bf]={DATARMNETb11903a752(
+DATARMNETee792ef3a0,65000,(0x194d+2561-0x234e),65000,NULL),DATARMNETb11903a752(
+DATARMNETfbbc8e2e06,65000,(0xfad+322-0x10ef),65000,NULL),DATARMNETb11903a752(
+DATARMNETe9b360aea8,DATARMNET651e3c6554,DATARMNETf9e24b5cc7,DATARMNETb2380d39af,
+DATARMNET467c2610cd),};static int DATARMNETedcd606b67(const char*
+DATARMNETc94d3d8015,const struct kernel_param*DATARMNET8a7a56afc0,u32 
+DATARMNETc8bfe161a0){struct DATARMNET7f0280a448*DATARMNETc628cb3ed7;unsigned 
+long long DATARMNET8371e203e8;u64 DATARMNET2582fdae21;int DATARMNET094475d445;if
+(DATARMNETc8bfe161a0>=DATARMNET6fb580e7bf)return-EINVAL;DATARMNET094475d445=
+kstrtoull(DATARMNETc94d3d8015,(0x1173+3661-0x1fc0),&DATARMNET8371e203e8);if(
+DATARMNET094475d445<(0x2f4+3088-0xf04))return DATARMNET094475d445;
+DATARMNETc628cb3ed7=&DATARMNETb73677dd8c[DATARMNETc8bfe161a0];if((u64)
+DATARMNET8371e203e8<DATARMNETc628cb3ed7->DATARMNET9d5e08f187||(u64)
+DATARMNET8371e203e8>DATARMNETc628cb3ed7->DATARMNETbcb261586d)return-ERANGE;
+DATARMNET8f8c3a4cc3();DATARMNET2582fdae21=*(u64*)DATARMNET8a7a56afc0->arg;if((
+u64)DATARMNET8371e203e8==DATARMNET2582fdae21){DATARMNET4c69e80b6f();return
+(0x451+6295-0x1ce8);}if(DATARMNETc628cb3ed7->DATARMNETf1c3fbdd8c){
+DATARMNET094475d445=DATARMNETc628cb3ed7->DATARMNETf1c3fbdd8c(DATARMNET2582fdae21
+,(u64)DATARMNET8371e203e8);if(DATARMNET094475d445<(0x1079+5304-0x2531)){
+DATARMNET4c69e80b6f();return DATARMNET094475d445;}}*(u64*)DATARMNET8a7a56afc0->
+arg=(u64)DATARMNET8371e203e8;DATARMNET4c69e80b6f();return(0x2a0+9324-0x270c);}
+DATARMNET72f6e45b34(rmnet_offload_knob0,DATARMNETee792ef3a0);DATARMNET72f6e45b34
+(rmnet_offload_knob1,DATARMNETfbbc8e2e06);DATARMNET72f6e45b34(
+rmnet_offload_knob2,DATARMNETe9b360aea8);u64 DATARMNET3d487d950f(u32 
+DATARMNETc8bfe161a0){struct DATARMNET7f0280a448*DATARMNETc628cb3ed7;if(
+DATARMNETc8bfe161a0>=DATARMNET6fb580e7bf)return(u64)~(0xc14+2053-0x1419);
+DATARMNETc628cb3ed7=&DATARMNETb73677dd8c[DATARMNETc8bfe161a0];return 
+DATARMNETc628cb3ed7->DATARMNETd30c98c72c;}
--- a/offload/rmnet_offload_knob.h
+++ b/offload/rmnet_offload_knob.h
@@ -0,0 +1,18 @@
+/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef DATARMNET3d4ba93d76
+#define DATARMNET3d4ba93d76
+#include <linux/types.h>
+enum{DATARMNETee792ef3a0,DATARMNETfbbc8e2e06,DATARMNETe9b360aea8,
+DATARMNET6fb580e7bf,};u64 DATARMNET3d487d950f(u32 DATARMNETc8bfe161a0);
+#endif
--- a/offload/rmnet_offload_main.c
+++ b/offload/rmnet_offload_main.c
@@ -0,0 +1,190 @@
+/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/compiler.h>
+#include <linux/rcupdate.h>
+#include <linux/jhash.h>
+#include <linux/spinlock.h>
+#include "rmnet_descriptor.h"
+#include "rmnet_handlers.h"
+#include "rmnet_map.h"
+#include "rmnet_offload_main.h"
+#include "rmnet_offload_state.h"
+#include "rmnet_offload_engine.h"
+#include "rmnet_offload_stats.h"
+static const char*DATARMNET9a36480134[]__always_unused={
+"\x49\x37\x32\x31\x62\x64\x36\x39\x35\x32\x31\x66\x65\x34\x61\x61\x38\x64\x61\x65\x62\x65\x66\x62\x32\x38\x30\x64\x38\x64\x31\x35\x30\x39\x66\x39\x31\x65\x36\x37\x33"
+,};static DEFINE_SPINLOCK(DATARMNET56235f0bb4);static u32 DATARMNETf6597f07e9(
+struct DATARMNETadd6ff90d0*DATARMNET809d788099){__be32 DATARMNET51e56c6582[
+(0x5b9+1700-0xc52)];u32 DATARMNETb65409e3b5;__be16 DATARMNETe048999b85=
+(0xb0c+7037-0x2689),DATARMNET6b15e99cb9=(0x6dc+1549-0xce9);if(
+DATARMNET809d788099->DATARMNET072708db10==DATARMNETb02d95e937||
+DATARMNET809d788099->DATARMNET072708db10==DATARMNET70889e5696){struct 
+DATARMNET2d87db499d*DATARMNET5829e80183=DATARMNET809d788099->DATARMNETc51cdf696b
+;DATARMNETe048999b85=DATARMNET5829e80183->DATARMNETaad9b0a864;
+DATARMNET6b15e99cb9=DATARMNET5829e80183->DATARMNETd751c12d13;}if(
+DATARMNET809d788099->DATARMNET9f5b2909c8==(0x10f3+703-0x13ae)){struct 
+DATARMNETf61a39bce9*DATARMNETf7a5ea0c29=DATARMNET809d788099->DATARMNET574a565f78
+;DATARMNET51e56c6582[(0x167b+1973-0x1e30)]=DATARMNETf7a5ea0c29->
+DATARMNET799b2a47a5;DATARMNET51e56c6582[(0xcb3+6554-0x264c)]=DATARMNETf7a5ea0c29
+->DATARMNET7c6ed51964;DATARMNET51e56c6582[(0x1c51+2147-0x24b2)]=
+DATARMNETf7a5ea0c29->DATARMNET065f40367c;DATARMNET51e56c6582[
+(0x1092+2502-0x1a55)]=DATARMNET6b15e99cb9;DATARMNET51e56c6582[
+(0x1300+1818-0x1a16)]=DATARMNETe048999b85;DATARMNETb65409e3b5=
+(0x1ac+8562-0x2319);}else{struct DATARMNETfab66e680d*DATARMNET6bd3c60da4=
+DATARMNET809d788099->DATARMNET1dab0af728;memcpy(&DATARMNET51e56c6582[
+(0x11d+5240-0x1595)],&DATARMNET6bd3c60da4->DATARMNET818f335f71[
+(0x8dd+4882-0x1bef)],sizeof(DATARMNET6bd3c60da4->DATARMNET818f335f71));memcpy(&
+DATARMNET51e56c6582[(0xbbd+5094-0x1f9e)],&DATARMNET6bd3c60da4->
+DATARMNET0f6f3a8868[(0x2fb+6889-0x1de4)],sizeof(DATARMNET6bd3c60da4->
+DATARMNET818f335f71));DATARMNET51e56c6582[(0x1438+742-0x1716)]=
+DATARMNET6bd3c60da4->DATARMNETa2be9ad0de;DATARMNET51e56c6582[(0x411+5381-0x190d)
+]=DATARMNET6b15e99cb9;DATARMNET51e56c6582[(0x1e1+3364-0xefb)]=
+DATARMNETe048999b85;DATARMNETb65409e3b5=(0x59b+5231-0x19ff);}return jhash2(
+DATARMNET51e56c6582,DATARMNETb65409e3b5,(0xeea+3831-0x1de1));}static void 
+DATARMNETee281dc788(u32 DATARMNET0eb96739bf){u32 DATARMNETc7bc65a2a5;if(
+DATARMNET0eb96739bf>50000)DATARMNETc7bc65a2a5=DATARMNETd096b7b9cd;else if(
+DATARMNET0eb96739bf>30000)DATARMNETc7bc65a2a5=DATARMNET1e2ecb33d1;else if(
+DATARMNET0eb96739bf>23000)DATARMNETc7bc65a2a5=DATARMNET3b1a812e5c;else if(
+DATARMNET0eb96739bf>14500)DATARMNETc7bc65a2a5=DATARMNET64bf04bc47;else if(
+DATARMNET0eb96739bf>(0x22ed+7824-0x2625))DATARMNETc7bc65a2a5=DATARMNET7069e38e48
+;else if(DATARMNET0eb96739bf>(0x1fd3+2486-0x2411))DATARMNETc7bc65a2a5=
+DATARMNETc005f7933f;else DATARMNETc7bc65a2a5=DATARMNET2eb3321438;
+DATARMNET5d24865423(DATARMNETc7bc65a2a5);}static bool DATARMNET00b745f472(struct
+ rmnet_frag_descriptor*DATARMNETa41162aa9b,struct DATARMNETadd6ff90d0*
+DATARMNET809d788099){u8*DATARMNET218e3007fa;u16 DATARMNET0eb96739bf;u16 
+DATARMNET0d3dcef7b0;if(DATARMNETa41162aa9b->hdrs_valid){DATARMNET809d788099->
+DATARMNET9f5b2909c8=DATARMNETa41162aa9b->ip_proto;DATARMNET809d788099->
+DATARMNETa7eaea0d00=DATARMNETa41162aa9b->ip_len;DATARMNET809d788099->
+DATARMNET072708db10=DATARMNETa41162aa9b->trans_proto;DATARMNET809d788099->
+DATARMNETfeb7c81ac7=DATARMNETa41162aa9b->trans_len;DATARMNET809d788099->
+DATARMNET574a565f78=(struct DATARMNETf61a39bce9*)DATARMNETa41162aa9b->hdr_ptr;
+DATARMNET809d788099->DATARMNET7ff34eacb7=(struct DATARMNET1bffb1c388*)(
+DATARMNETa41162aa9b->hdr_ptr+DATARMNETa41162aa9b->ip_len);DATARMNET809d788099->
+DATARMNET68ad0738e2=DATARMNETf6597f07e9(DATARMNET809d788099);DATARMNET809d788099
+->DATARMNET5671455f38=skb_frag_size(&DATARMNETa41162aa9b->frag);if(
+DATARMNETa41162aa9b->hdr_ptr==rmnet_frag_data_ptr(DATARMNETa41162aa9b))
+DATARMNET809d788099->DATARMNET5671455f38-=DATARMNETa41162aa9b->ip_len+
+DATARMNETa41162aa9b->trans_len;DATARMNET809d788099->DATARMNET798fafaf36=
+DATARMNETa41162aa9b;return false;}DATARMNET218e3007fa=rmnet_frag_data_ptr(
+DATARMNETa41162aa9b);DATARMNET0eb96739bf=skb_frag_size(&DATARMNETa41162aa9b->
+frag);DATARMNET809d788099->DATARMNET2f3cb41448=true;DATARMNET809d788099->
+DATARMNET9f5b2909c8=(DATARMNET218e3007fa[(0x2a+5400-0x1542)]&
+(0x1881+3821-0x267e))>>(0x16d+792-0x481);if(DATARMNET809d788099->
+DATARMNET9f5b2909c8==(0x73a+2289-0x1027)){struct DATARMNETf61a39bce9*
+DATARMNETf7a5ea0c29;DATARMNETf7a5ea0c29=(struct DATARMNETf61a39bce9*)
+DATARMNET218e3007fa;DATARMNET809d788099->DATARMNET574a565f78=DATARMNETf7a5ea0c29
+;DATARMNET809d788099->DATARMNETa7eaea0d00=DATARMNETf7a5ea0c29->
+DATARMNET422c25939d*(0x1235+3369-0x1f5a);DATARMNET809d788099->
+DATARMNET072708db10=DATARMNETf7a5ea0c29->DATARMNET065f40367c;if(
+DATARMNETf7a5ea0c29->DATARMNETa803e4f68b&htons(16383)){DATARMNET5d24865423(
+DATARMNET433e163a43);goto DATARMNET02a8afcd23;}DATARMNET0d3dcef7b0=ntohs(
+DATARMNETf7a5ea0c29->DATARMNETefd12e7a2b);DATARMNET809d788099->
+DATARMNET6cc77c7b3f=DATARMNET0d3dcef7b0!=DATARMNET0eb96739bf;}else if(
+DATARMNET809d788099->DATARMNET9f5b2909c8==(0x79a+292-0x8b8)){struct 
+DATARMNETfab66e680d*DATARMNET6bd3c60da4;int DATARMNET5fc606c6dc;__be16 
+DATARMNETe95a0a73b9;u8 DATARMNETcb5c3d9e39;DATARMNET6bd3c60da4=(struct 
+DATARMNETfab66e680d*)DATARMNET218e3007fa;DATARMNET809d788099->
+DATARMNET1dab0af728=DATARMNET6bd3c60da4;DATARMNETcb5c3d9e39=DATARMNET6bd3c60da4
+->DATARMNETa2be9ad0de;DATARMNET5fc606c6dc=rmnet_frag_ipv6_skip_exthdr(
+DATARMNETa41162aa9b,sizeof(*DATARMNET6bd3c60da4),&DATARMNETcb5c3d9e39,&
+DATARMNETe95a0a73b9);if(DATARMNET5fc606c6dc<(0x13d7+456-0x159f)){goto 
+DATARMNET02a8afcd23;}DATARMNET809d788099->DATARMNETa7eaea0d00=(u16)
+DATARMNET5fc606c6dc;DATARMNET809d788099->DATARMNET072708db10=DATARMNETcb5c3d9e39
+;if(DATARMNETe95a0a73b9){if(DATARMNET809d788099->DATARMNET072708db10==
+DATARMNET75cddb74df)DATARMNET809d788099->DATARMNETa7eaea0d00+=
+(0xc6f+3338-0x1971);DATARMNET5d24865423(DATARMNET433e163a43);goto 
+DATARMNET02a8afcd23;}DATARMNET0d3dcef7b0=ntohs(DATARMNET6bd3c60da4->
+DATARMNET5aeba29b95)+sizeof(*DATARMNET6bd3c60da4);DATARMNET809d788099->
+DATARMNET6cc77c7b3f=DATARMNET0d3dcef7b0!=DATARMNET0eb96739bf;}else{return true;}
+DATARMNET218e3007fa+=DATARMNET809d788099->DATARMNETa7eaea0d00;if(
+DATARMNET809d788099->DATARMNET072708db10==DATARMNET70889e5696){struct 
+DATARMNET1bffb1c388*DATARMNETbd1c0986f8;DATARMNETbd1c0986f8=(struct 
+DATARMNET1bffb1c388*)DATARMNET218e3007fa;DATARMNET809d788099->
+DATARMNET7ff34eacb7=DATARMNETbd1c0986f8;DATARMNET809d788099->DATARMNETfeb7c81ac7
+=DATARMNETbd1c0986f8->DATARMNET686636af95*(0xcb9+267-0xdc0);}else if(
+DATARMNET809d788099->DATARMNET072708db10==DATARMNETb02d95e937){struct 
+DATARMNET2d87db499d*DATARMNET5829e80183;DATARMNET5829e80183=(struct 
+DATARMNET2d87db499d*)DATARMNET218e3007fa;DATARMNET809d788099->
+DATARMNETc51cdf696b=DATARMNET5829e80183;DATARMNET809d788099->DATARMNETfeb7c81ac7
+=sizeof(*DATARMNET5829e80183);}else{goto DATARMNET02a8afcd23;}
+DATARMNET809d788099->DATARMNET2f3cb41448=false;DATARMNET809d788099->
+DATARMNET68ad0738e2=DATARMNETf6597f07e9(DATARMNET809d788099);if(!
+DATARMNET809d788099->DATARMNET6cc77c7b3f){DATARMNETa41162aa9b->ip_proto=
+DATARMNET809d788099->DATARMNET9f5b2909c8;DATARMNETa41162aa9b->ip_len=
+DATARMNET809d788099->DATARMNETa7eaea0d00;DATARMNETa41162aa9b->trans_proto=
+DATARMNET809d788099->DATARMNET072708db10;DATARMNETa41162aa9b->trans_len=
+DATARMNET809d788099->DATARMNETfeb7c81ac7;DATARMNETa41162aa9b->hdrs_valid=
+(0x9a3+3898-0x18dc);}DATARMNET02a8afcd23:DATARMNET809d788099->
+DATARMNET5671455f38=DATARMNET0eb96739bf-DATARMNET809d788099->DATARMNETa7eaea0d00
+-DATARMNET809d788099->DATARMNETfeb7c81ac7;if(DATARMNET809d788099->
+DATARMNET6cc77c7b3f)DATARMNET5d24865423(DATARMNETf4e67e1692);DATARMNET809d788099
+->DATARMNET798fafaf36=DATARMNETa41162aa9b;return false;}static void 
+DATARMNET5eaded9c32(struct rmnet_frag_descriptor*DATARMNETa41162aa9b,struct 
+rmnet_port*DATARMNETe8a5f322f0){struct DATARMNET8357daf015*DATARMNETf7e8f6395c=
+DATARMNETccc25794e0();struct DATARMNETadd6ff90d0 DATARMNET809d788099;memset(&
+DATARMNET809d788099,(0x1b23+1630-0x2181),sizeof(DATARMNET809d788099));
+DATARMNET8f8c3a4cc3();DATARMNETf7e8f6395c->DATARMNET547651077b=
+DATARMNETe8a5f322f0;if(DATARMNET00b745f472(DATARMNETa41162aa9b,&
+DATARMNET809d788099)){DATARMNET5d24865423(DATARMNET056a0fe195);
+rmnet_recycle_frag_descriptor(DATARMNETa41162aa9b,DATARMNETe8a5f322f0);goto 
+DATARMNETe1f307999b;}DATARMNET5d24865423(DATARMNET18d408a5a5);if(
+DATARMNET809d788099.DATARMNET2f3cb41448){goto DATARMNET52a3ca33f8;}else if(
+DATARMNET809d788099.DATARMNET6cc77c7b3f){DATARMNET8b657e07e9(DATARMNET809d788099
+.DATARMNET68ad0738e2);goto DATARMNET52a3ca33f8;}if(!DATARMNETa41162aa9b->
+csum_valid){goto DATARMNET52a3ca33f8;}if(!DATARMNET9b8a1a69f3(&
+DATARMNET809d788099))goto DATARMNET52a3ca33f8;goto DATARMNETe1f307999b;
+DATARMNET52a3ca33f8:DATARMNETf9d626d72b(&DATARMNET809d788099);
+DATARMNETe1f307999b:DATARMNET4c69e80b6f();}void DATARMNET8f8c3a4cc3(void){
+spin_lock_bh(&DATARMNET56235f0bb4);}void DATARMNET4c69e80b6f(void){
+spin_unlock_bh(&DATARMNET56235f0bb4);}void DATARMNETd9ec5f4e65(void){
+rcu_assign_pointer(rmnet_perf_desc_entry,DATARMNET5eaded9c32);}void 
+DATARMNET848914898b(void){rcu_assign_pointer(rmnet_perf_desc_entry,NULL);}bool 
+DATARMNET4e490d9d37(void){void(*DATARMNETb4f3500b6d)(struct 
+rmnet_frag_descriptor*DATARMNETa41162aa9b,struct rmnet_port*DATARMNETe8a5f322f0)
+;rcu_read_lock();DATARMNETb4f3500b6d=rcu_dereference(rmnet_perf_desc_entry);
+rcu_read_unlock();return DATARMNETb4f3500b6d!=NULL;}void DATARMNET654b85a739(
+struct rmnet_frag_descriptor*DATARMNETa41162aa9b,u32 DATARMNET30fde83b85){struct
+ DATARMNET8357daf015*DATARMNETf7e8f6395c=DATARMNETccc25794e0();
+DATARMNETee281dc788(DATARMNET30fde83b85);DATARMNET5d24865423(DATARMNET6b8a6c4f4e
+);rmnet_frag_deliver(DATARMNETa41162aa9b,DATARMNETf7e8f6395c->
+DATARMNET547651077b);}void DATARMNETf9d626d72b(struct DATARMNETadd6ff90d0*
+DATARMNET809d788099){struct rmnet_frag_descriptor*DATARMNETa41162aa9b=
+DATARMNET809d788099->DATARMNET798fafaf36;u32 DATARMNET0eb96739bf=
+DATARMNET809d788099->DATARMNET5671455f38+DATARMNET809d788099->
+DATARMNETa7eaea0d00+DATARMNET809d788099->DATARMNETfeb7c81ac7;if(
+DATARMNET0eb96739bf>65536)return;if(!DATARMNET809d788099->DATARMNET2f3cb41448)
+DATARMNETa41162aa9b->hash=DATARMNET809d788099->DATARMNET68ad0738e2;
+DATARMNET654b85a739(DATARMNETa41162aa9b,DATARMNET0eb96739bf);}void 
+DATARMNETfaa320a86a(void*DATARMNETe8a5f322f0){(void)DATARMNETe8a5f322f0;
+DATARMNETafcdd1146f();}void DATARMNET6b57fa3471(void*DATARMNETe8a5f322f0){struct
+ DATARMNET8357daf015*DATARMNETf7e8f6395c=DATARMNETccc25794e0();(void)
+DATARMNETe8a5f322f0;if(DATARMNETf7e8f6395c->DATARMNETfe5583a585.
+DATARMNETf82a9c29ed)DATARMNET28dfa538f2();}void DATARMNET4aefca6d3c(struct 
+rmnet_map_dl_ind_hdr*DATARMNETf3449c6d59,struct rmnet_map_control_command_header
+*DATARMNET23a4adcff8){struct DATARMNET8357daf015*DATARMNETf7e8f6395c=
+DATARMNETccc25794e0();(void)DATARMNET23a4adcff8;if(DATARMNETf7e8f6395c->
+DATARMNETfe5583a585.DATARMNETecff29bcbf&&DATARMNET54fd6bf483())
+DATARMNET5d24865423(DATARMNET51527f883c);DATARMNETf7e8f6395c->
+DATARMNETfe5583a585.DATARMNETecff29bcbf=true;DATARMNETf7e8f6395c->
+DATARMNETfe5583a585.DATARMNET26e013d9f7=DATARMNETf3449c6d59->le.seq;
+DATARMNETf7e8f6395c->DATARMNETfe5583a585.DATARMNETdd6feb57a5=DATARMNETf3449c6d59
+->le.pkts;}void DATARMNET94edfae28d(struct rmnet_map_dl_ind_trl*
+DATARMNET0303d63d24,struct rmnet_map_control_command_header*DATARMNET23a4adcff8)
+{struct DATARMNET8357daf015*DATARMNETf7e8f6395c=DATARMNETccc25794e0();(void)
+DATARMNET23a4adcff8;if(DATARMNETf7e8f6395c->DATARMNETfe5583a585.
+DATARMNET26e013d9f7!=DATARMNET0303d63d24->seq_le)DATARMNET5d24865423(
+DATARMNETae9ed9e102);if(DATARMNET54fd6bf483())DATARMNET5d24865423(
+DATARMNET3f56a10f4d);DATARMNETf7e8f6395c->DATARMNETfe5583a585.
+DATARMNETecff29bcbf=false;DATARMNETf7e8f6395c->DATARMNETfe5583a585.
+DATARMNET26e013d9f7=(0x1dfd+911-0x218c);DATARMNETf7e8f6395c->DATARMNETfe5583a585
+.DATARMNETdd6feb57a5=(0x2bb+6482-0x1c0d);}
--- a/offload/rmnet_offload_main.h
+++ b/offload/rmnet_offload_main.h
@@ -0,0 +1,70 @@
+/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef DATARMNET8ff259402c
+#define DATARMNET8ff259402c
+#include <linux/types.h>
+#include <asm/byteorder.h>
+#include "rmnet_descriptor.h"
+#include "rmnet_map.h"
+#define DATARMNET70889e5696		(0x11e1+4818-0x24ad)
+#define DATARMNETb02d95e937		(0x398+2717-0xe24)
+#define DATARMNET75cddb74df	(0x1d0+8549-0x2309)
+struct DATARMNETf61a39bce9{
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+u8 DATARMNET422c25939d:(0xc6f+4384-0x1d8b);u8 DATARMNET8f06b45a68:
+(0xe4+813-0x40d);
+#elif defined (__BIG_ENDIAN_BITFIELD)
+u8 DATARMNET8f06b45a68:(0x297+3591-0x109a);u8 DATARMNET422c25939d:
+(0x504+4747-0x178b);
+#else
+#error "<asm/byteorder.h> error"
+#endif
+u8 DATARMNET14d3de9c1a;__be16 DATARMNETefd12e7a2b;__be16 DATARMNET4de0560151;
+__be16 DATARMNETa803e4f68b;u8 DATARMNET58886f3d9d;u8 DATARMNET065f40367c;__be16 
+DATARMNET32d70026ed;__be32 DATARMNET7c6ed51964;__be32 DATARMNET799b2a47a5;};
+struct DATARMNETfab66e680d{__be32 DATARMNETd750a8b9e5;__be16 DATARMNET5aeba29b95
+;u8 DATARMNETa2be9ad0de;u8 DATARMNET63034bb4af;__be32 DATARMNET0f6f3a8868[
+(0xf34+819-0x1263)];__be32 DATARMNET818f335f71[(0xda6+1408-0x1322)];};struct 
+DATARMNET1bffb1c388{__be16 DATARMNET1addfaf963;__be16 DATARMNET88b102698d;__be32
+ DATARMNET614032cc71;__be32 DATARMNET5e09091b6e;
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+u8 DATARMNET0f1c1adba0:(0x975+7513-0x26ca);u8 DATARMNET686636af95:
+(0x5d8+6880-0x20b4);
+#elif defined (__BIG_ENDIAN_BITFIELD)
+u8 DATARMNET686636af95:(0x882+5440-0x1dbe);u8 DATARMNET0f1c1adba0:
+(0xbc6+6497-0x2523);
+#else
+#error "<asm/byteorder.h> error"
+#endif
+u8 DATARMNETf538480d20;__be16 DATARMNETf62e1ed00e;__be16 DATARMNETefa4b043cf;
+__be16 DATARMNETd93b885d17;};struct DATARMNET2d87db499d{__be16 
+DATARMNETaad9b0a864;__be16 DATARMNETd751c12d13;__be16 DATARMNET69d29eba58;__be16
+ DATARMNET7efecd6ba5;};struct DATARMNETadd6ff90d0{struct rmnet_frag_descriptor*
+DATARMNET798fafaf36;union{struct DATARMNETf61a39bce9*DATARMNET574a565f78;struct 
+DATARMNETfab66e680d*DATARMNET1dab0af728;};union{struct DATARMNET1bffb1c388*
+DATARMNET7ff34eacb7;struct DATARMNET2d87db499d*DATARMNETc51cdf696b;};u32 
+DATARMNET68ad0738e2;u16 DATARMNET5671455f38;u16 DATARMNETa7eaea0d00;u16 
+DATARMNETfeb7c81ac7;u8 DATARMNET9f5b2909c8;u8 DATARMNET072708db10;bool 
+DATARMNET1e7926dc4c;bool DATARMNET2f3cb41448;bool DATARMNET6cc77c7b3f;};void 
+DATARMNET8f8c3a4cc3(void);void DATARMNET4c69e80b6f(void);void 
+DATARMNETd9ec5f4e65(void);void DATARMNET848914898b(void);bool 
+DATARMNET4e490d9d37(void);void DATARMNET654b85a739(struct rmnet_frag_descriptor*
+DATARMNETa41162aa9b,u32 DATARMNET0eb96739bf);void DATARMNETf9d626d72b(struct 
+DATARMNETadd6ff90d0*DATARMNET809d788099);void DATARMNETfaa320a86a(void*
+DATARMNETe8a5f322f0);void DATARMNET6b57fa3471(void*DATARMNETe8a5f322f0);void 
+DATARMNET4aefca6d3c(struct rmnet_map_dl_ind_hdr*DATARMNETf3449c6d59,struct 
+rmnet_map_control_command_header*DATARMNET23a4adcff8);void DATARMNET94edfae28d(
+struct rmnet_map_dl_ind_trl*DATARMNET0303d63d24,struct 
+rmnet_map_control_command_header*DATARMNET23a4adcff8);
+#endif
+
--- a/offload/rmnet_offload_state.c
+++ b/offload/rmnet_offload_state.c
@@ -0,0 +1,100 @@
+/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/module.h>
+#include <linux/netdevice.h>
+#include "rmnet_map.h"
+#include "rmnet_private.h"
+#include "qmi_rmnet.h"
+#include "rmnet_offload_state.h"
+#include "rmnet_offload_engine.h"
+MODULE_LICENSE("\x47\x50\x4c\x20\x76\x32");
+#define DATARMNET47b52951b8 (0x68d+4280-0x1745)
+static struct DATARMNET8357daf015*DATARMNETf7e8f6395c;static void 
+DATARMNET39b47bda29(void){struct rmnet_port*DATARMNETe8a5f322f0=
+DATARMNETf7e8f6395c->DATARMNET547651077b;struct DATARMNET92f4d48c56*
+DATARMNET18063ff0ab;qmi_rmnet_ps_ind_deregister(DATARMNETe8a5f322f0,&
+DATARMNETf7e8f6395c->DATARMNETa0db7ef12a);DATARMNET18063ff0ab=&
+DATARMNETf7e8f6395c->DATARMNETfe5583a585;if(DATARMNET18063ff0ab->
+DATARMNETf82a9c29ed)rmnet_map_dl_ind_deregister(DATARMNETe8a5f322f0,&
+DATARMNET18063ff0ab->DATARMNET524c210c13);}static void DATARMNET296eb47249(void)
+{if(!DATARMNETf7e8f6395c)return;DATARMNET39b47bda29();DATARMNET848914898b();
+DATARMNET28dfa538f2();DATARMNET54fd6bf483();DATARMNETde815547a0();kfree(
+DATARMNETf7e8f6395c);DATARMNETf7e8f6395c=NULL;}static int DATARMNETd813fadf76(
+void){struct rmnet_port*DATARMNETe8a5f322f0=DATARMNETf7e8f6395c->
+DATARMNET547651077b;struct qmi_rmnet_ps_ind*DATARMNET83359ae71d;struct 
+DATARMNET92f4d48c56*DATARMNET18063ff0ab;struct rmnet_map_dl_ind*
+DATARMNET524c210c13;int DATARMNET094475d445=DATARMNET6e89887168;
+DATARMNET83359ae71d=&DATARMNETf7e8f6395c->DATARMNETa0db7ef12a;
+DATARMNET83359ae71d->ps_on_handler=DATARMNETfaa320a86a;DATARMNET83359ae71d->
+ps_off_handler=DATARMNET6b57fa3471;if(qmi_rmnet_ps_ind_register(
+DATARMNETe8a5f322f0,DATARMNET83359ae71d)){DATARMNET094475d445=
+DATARMNETee330d5a81;pr_warn(
+"\x25\x73\x28\x29\x3a\x20\x50\x53\x20\x43\x42\x20\x72\x65\x67\x69\x73\x74\x72\x61\x74\x69\x6f\x6e\x20\x66\x61\x69\x6c\x65\x64" "\n"
+,__func__);}if(DATARMNETe8a5f322f0->data_format&
+RMNET_INGRESS_FORMAT_DL_MARKER_V2){DATARMNET18063ff0ab=&DATARMNETf7e8f6395c->
+DATARMNETfe5583a585;DATARMNET524c210c13=&DATARMNET18063ff0ab->
+DATARMNET524c210c13;DATARMNET524c210c13->priority=DATARMNET47b52951b8;
+DATARMNET524c210c13->dl_hdr_handler_v2=DATARMNET4aefca6d3c;DATARMNET524c210c13->
+dl_trl_handler_v2=DATARMNET94edfae28d;if(rmnet_map_dl_ind_register(
+DATARMNETe8a5f322f0,DATARMNET524c210c13)){DATARMNETafcdd1146f();
+DATARMNET094475d445=DATARMNETee330d5a81;pr_warn(
+"\x25\x73\x28\x29\x3a\x20\x44\x4c\x20\x43\x42\x20\x72\x65\x67\x69\x73\x74\x72\x61\x74\x61\x74\x69\x6f\x6e\x20\x66\x61\x69\x6c\x65\x64" "\n"
+,__func__);}else{DATARMNET18063ff0ab->DATARMNETf82a9c29ed=true;}}else{
+DATARMNETafcdd1146f();DATARMNET094475d445=DATARMNETee330d5a81;pr_warn(
+"\x25\x73\x28\x29\x3a\x20\x44\x4c\x20\x6e\x6f\x74\x20\x65\x6e\x61\x62\x6c\x65\x64" "\n"
+,__func__);}return DATARMNET094475d445;}static int DATARMNETbe48169564(struct 
+rmnet_port*DATARMNETe8a5f322f0){int DATARMNET094475d445;DATARMNETf7e8f6395c=
+kzalloc(sizeof(*DATARMNETf7e8f6395c),GFP_KERNEL);if(!DATARMNETf7e8f6395c){pr_err
+(
+"\x25\x73\x28\x29\x3a\x20\x52\x65\x73\x6f\x75\x72\x63\x65\x20\x61\x6c\x6c\x6f\x63\x61\x74\x69\x6f\x6e\x20\x66\x61\x69\x6c\x65\x64" "\n"
+,__func__);return DATARMNETc50a12ee59;}DATARMNETf7e8f6395c->DATARMNET547651077b=
+DATARMNETe8a5f322f0;DATARMNET094475d445=DATARMNETcce014cb1d();if(
+DATARMNET094475d445<(0x15bb+934-0x1961))goto DATARMNET77e7361053;
+DATARMNET094475d445=DATARMNETd813fadf76();if(DATARMNET094475d445!=
+DATARMNET6e89887168){pr_warn(
+"\x25\x73\x28\x29\x3a\x20\x43\x61\x6c\x6c\x62\x61\x63\x6b\x20\x72\x65\x67\x69\x73\x74\x72\x61\x74\x69\x6f\x6e\x20\x66\x61\x69\x6c\x65\x64" "\n"
+,__func__);}DATARMNETd9ec5f4e65();return DATARMNET094475d445;DATARMNET77e7361053
+:kfree(DATARMNETf7e8f6395c);DATARMNETf7e8f6395c=NULL;return DATARMNET094475d445;
+}static int DATARMNETe4f68c17d0(struct notifier_block*DATARMNET9e976b309a,
+unsigned long DATARMNET081daa57e7,void*DATARMNET71ffe74cda){struct net_device*
+DATARMNET6db6ebb1e7=netdev_notifier_info_to_dev(DATARMNET71ffe74cda);struct 
+rmnet_port*DATARMNETe8a5f322f0;struct rmnet_priv*DATARMNET64e0e8cc28;int 
+DATARMNET094475d445;(void)DATARMNET9e976b309a;if(!DATARMNET6db6ebb1e7)goto 
+DATARMNET02a8afcd23;switch(DATARMNET081daa57e7){case NETDEV_REGISTER:if(
+DATARMNETf7e8f6395c||DATARMNET4e490d9d37()||strncmp(DATARMNET6db6ebb1e7->name,
+"\x72\x6d\x6e\x65\x74\x5f\x64\x61\x74\x61",(0xeab+5835-0x256c)))goto 
+DATARMNET02a8afcd23;DATARMNET64e0e8cc28=netdev_priv(DATARMNET6db6ebb1e7);
+DATARMNETe8a5f322f0=rmnet_get_port(DATARMNET64e0e8cc28->real_dev);if(!
+DATARMNETe8a5f322f0){pr_err(
+"\x25\x73\x28\x29\x3a\x20\x49\x6e\x76\x61\x6c\x69\x64\x20\x72\x6d\x6e\x65\x74\x20\x63\x6f\x6e\x66\x69\x67\x75\x72\x61\x74\x69\x6f\x6e\x20\x6f\x6e\x20\x25\x73" "\n"
+,__func__,DATARMNET6db6ebb1e7->name);goto DATARMNET02a8afcd23;}pr_info(
+"\x25\x73\x28\x29\x3a\x20\x49\x6e\x69\x74\x69\x61\x6c\x69\x7a\x69\x6e\x67\x20\x6f\x6e\x20\x64\x65\x76\x69\x63\x65\x20\x25\x73" "\n"
+,__func__,DATARMNET6db6ebb1e7->name);DATARMNET094475d445=DATARMNETbe48169564(
+DATARMNETe8a5f322f0);if(DATARMNET094475d445==DATARMNETc50a12ee59){pr_err(
+"\x25\x73\x28\x29\x3a\x20\x49\x6e\x69\x74\x69\x61\x6c\x69\x7a\x61\x74\x69\x6f\x6e\x20\x66\x61\x69\x6c\x65\x64" "\n"
+,__func__);goto DATARMNET02a8afcd23;}break;case NETDEV_UNREGISTER:if(!
+DATARMNETf7e8f6395c||!DATARMNET4e490d9d37()||strncmp(DATARMNET6db6ebb1e7->name,
+DATARMNETf7e8f6395c->DATARMNET547651077b->dev->name,IFNAMSIZ))goto 
+DATARMNET02a8afcd23;pr_info(
+"\x25\x73\x28\x29\x3a\x20\x55\x6e\x69\x6e\x69\x74\x69\x61\x6c\x69\x7a\x69\x6e\x67\x20\x6f\x6e\x20\x64\x65\x76\x69\x63\x65\x20\x25\x73" "\n"
+,__func__,DATARMNET6db6ebb1e7->name);DATARMNET296eb47249();break;}
+DATARMNET02a8afcd23:return NOTIFY_DONE;}static struct notifier_block 
+DATARMNET4dff0c2c8a={.notifier_call=DATARMNETe4f68c17d0,.priority=
+(0xc93+6150-0x2498),};static int __init DATARMNET99216255df(void){pr_info(
+"\x25\x73\x28\x29\x3a\x20\x72\x6d\x6e\x65\x74\x5f\x6f\x66\x66\x6c\x6f\x61\x64\x20\x69\x6e\x69\x74\x69\x61\x6c\x69\x7a\x69\x6e\x67" "\n"
+,__func__);return register_netdevice_notifier(&DATARMNET4dff0c2c8a);}static void
+ __exit DATARMNET16134ceac1(void){pr_info(
+"\x25\x73\x28\x29\x3a\x20\x72\x6d\x6e\x65\x74\x5f\x6f\x66\x66\x6c\x6f\x61\x64\x20\x65\x78\x69\x74\x69\x6e\x67" "\n"
+,__func__);unregister_netdevice_notifier(&DATARMNET4dff0c2c8a);}struct 
+DATARMNET8357daf015*DATARMNETccc25794e0(void){return DATARMNETf7e8f6395c;}
+module_init(DATARMNET99216255df);module_exit(DATARMNET16134ceac1);
--- a/offload/rmnet_offload_state.h
+++ b/offload/rmnet_offload_state.h
@@ -0,0 +1,28 @@
+/* Copyright (c) 2013-2014, 2016-2017, 2019-2020 The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef DATARMNETdd185571da
+#define DATARMNETdd185571da
+#include "rmnet_offload_engine.h"
+#include "rmnet_map.h"
+#include "rmnet_descriptor.h"
+#include "qmi_rmnet.h"
+enum{DATARMNET6e89887168,DATARMNETee330d5a81,DATARMNETc50a12ee59,};extern void(*
+rmnet_perf_desc_entry)(struct rmnet_frag_descriptor*DATARMNETa41162aa9b,struct 
+rmnet_port*DATARMNETe8a5f322f0);extern void(*rmnet_perf_chain_end)(void);struct 
+DATARMNET92f4d48c56{struct rmnet_map_dl_ind DATARMNET524c210c13;u32 
+DATARMNET26e013d9f7;u32 DATARMNETdd6feb57a5;bool DATARMNETf82a9c29ed;bool 
+DATARMNETecff29bcbf;};struct DATARMNET8357daf015{struct rmnet_port*
+DATARMNET547651077b;struct DATARMNET92f4d48c56 DATARMNETfe5583a585;struct 
+qmi_rmnet_ps_ind DATARMNETa0db7ef12a;struct DATARMNET337e435e40 
+DATARMNETa3d1da1cba;};struct DATARMNET8357daf015*DATARMNETccc25794e0(void);
+#endif
--- a/offload/rmnet_offload_stats.c
+++ b/offload/rmnet_offload_stats.c
@@ -0,0 +1,20 @@
+/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/moduleparam.h>
+#include "rmnet_offload_stats.h"
+static u64 DATARMNET3ef80acde3[DATARMNET730e872425];module_param_array_named(
+rmnet_offload_stat,DATARMNET3ef80acde3,ullong,NULL,(0x1889+1291-0x1c70));void 
+DATARMNETa3edc29191(u32 DATARMNET637046c4bc,u64 DATARMNETef3ecb031d){if(
+DATARMNET637046c4bc<DATARMNET730e872425)DATARMNET3ef80acde3[DATARMNET637046c4bc]
+=DATARMNETef3ecb031d;}void DATARMNET5d24865423(u32 DATARMNET637046c4bc){
+DATARMNETa3edc29191(DATARMNET637046c4bc,(0x1384+2583-0x1d9a));}
--- a/offload/rmnet_offload_stats.h
+++ b/offload/rmnet_offload_stats.h
@@ -0,0 +1,27 @@
+/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef DATARMNETc450946417
+#define DATARMNETc450946417
+#include <linux/types.h>
+enum{DATARMNET18d408a5a5,DATARMNET6b8a6c4f4e,DATARMNET056a0fe195,
+DATARMNET51527f883c,DATARMNETae9ed9e102,DATARMNET3f56a10f4d,DATARMNET433e163a43,
+DATARMNETf4e67e1692,DATARMNETa05aa2c4a7,DATARMNETc0fe927262,DATARMNETdae7cbfd97,
+DATARMNET2ec91e73cf,DATARMNET135dd1f8ca,DATARMNETf410872acc,DATARMNETa5e27cdfa7,
+DATARMNETd13a32652d,DATARMNET1cacdd7cfc,DATARMNET7dbef260b1,DATARMNET76bca11273,
+DATARMNETaee7f80b20,DATARMNETb3aa109946,DATARMNET2eb3321438,DATARMNETc005f7933f,
+DATARMNET7069e38e48,DATARMNET64bf04bc47,DATARMNET3b1a812e5c,DATARMNET1e2ecb33d1,
+DATARMNETd096b7b9cd,DATARMNET730e872425,};void DATARMNETa3edc29191(u32 
+DATARMNET637046c4bc,u64 DATARMNETef3ecb031d);void DATARMNET5d24865423(u32 
+DATARMNET637046c4bc);
+#endif
+
--- a/offload/rmnet_offload_tcp.c
+++ b/offload/rmnet_offload_tcp.c
@@ -0,0 +1,68 @@
+/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include "rmnet_descriptor.h"
+#include "rmnet_offload_main.h"
+#include "rmnet_offload_engine.h"
+#include "rmnet_offload_stats.h"
+#include "rmnet_offload_knob.h"
+static bool DATARMNET505c932e93(struct DATARMNETadd6ff90d0*DATARMNETc3ffad4b30){
+struct DATARMNET1bffb1c388*DATARMNETbd1c0986f8=DATARMNETc3ffad4b30->
+DATARMNET7ff34eacb7;__be32 DATARMNETae352fd67d;u8 DATARMNETf72fff5724=
+DATARMNETbd1c0986f8->DATARMNETf538480d20;DATARMNETae352fd67d=(0x89d+3341-0x14fb)
+;if((!DATARMNETc3ffad4b30->DATARMNET5671455f38&&(DATARMNETf72fff5724&
+(0x32d+5244-0x1799)))||(DATARMNETf72fff5724&DATARMNETae352fd67d))return true;
+return false;}static bool DATARMNET4863e9c5ae(struct DATARMNET31caee06e2*
+DATARMNETd44a80d414,struct DATARMNETadd6ff90d0*DATARMNETc3ffad4b30){struct 
+DATARMNET1bffb1c388*DATARMNETb5da236f91,*DATARMNET4e35bbb67d;u32 
+DATARMNETf5bcfe1e17,DATARMNET5d971be8b8;DATARMNETb5da236f91=DATARMNETd44a80d414
+->DATARMNET9a5f6d68d4;DATARMNET4e35bbb67d=DATARMNETc3ffad4b30->
+DATARMNET7ff34eacb7;DATARMNETf5bcfe1e17=DATARMNETb5da236f91->DATARMNET686636af95
+*(0x1cd7+2514-0x26a5);if(DATARMNET4e35bbb67d->DATARMNET686636af95*
+(0xee3+4488-0x2067)!=DATARMNETf5bcfe1e17)return true;for(DATARMNET5d971be8b8=
+sizeof(*DATARMNETb5da236f91);DATARMNET5d971be8b8<DATARMNETf5bcfe1e17;
+DATARMNET5d971be8b8+=(0xb4f+6315-0x23f6)){if(*(u32*)((u8*)DATARMNETb5da236f91+
+DATARMNET5d971be8b8)^*(u32*)((u8*)DATARMNET4e35bbb67d+DATARMNET5d971be8b8))
+return true;}return false;}static int DATARMNETb12f1716fd(struct 
+DATARMNET31caee06e2*DATARMNETd44a80d414,struct DATARMNETadd6ff90d0*
+DATARMNETc3ffad4b30){struct DATARMNET1bffb1c388*DATARMNET4e35bbb67d=
+DATARMNETc3ffad4b30->DATARMNET7ff34eacb7;u64 DATARMNETd9527bfa5e;u32 
+DATARMNET8875527b54,DATARMNETfc02a09052;if(DATARMNET505c932e93(
+DATARMNETc3ffad4b30)){DATARMNET5d24865423(DATARMNETf410872acc);return 
+DATARMNET08dbe31d07;}if(!DATARMNETd44a80d414->DATARMNET30d367f886)return 
+DATARMNET7d8a4bb6b1;if(DATARMNET4863e9c5ae(DATARMNETd44a80d414,
+DATARMNETc3ffad4b30)){DATARMNET5d24865423(DATARMNETa5e27cdfa7);return 
+DATARMNET6b149bc29f;}DATARMNET8875527b54=(DATARMNETc3ffad4b30->
+DATARMNET798fafaf36->tcp_seq_set)?ntohl(DATARMNETc3ffad4b30->DATARMNET798fafaf36
+->tcp_seq):ntohl(DATARMNET4e35bbb67d->DATARMNET614032cc71);if(
+DATARMNET8875527b54^DATARMNETd44a80d414->DATARMNET956bd73340){
+DATARMNET5d24865423(DATARMNETd13a32652d);return DATARMNET08dbe31d07;}
+DATARMNETfc02a09052=(DATARMNETc3ffad4b30->DATARMNET798fafaf36->gso_size)?:
+DATARMNETc3ffad4b30->DATARMNET5671455f38;if(DATARMNETfc02a09052!=
+DATARMNETd44a80d414->DATARMNET632219f39d){DATARMNET5d24865423(
+DATARMNET1cacdd7cfc);return DATARMNET6b149bc29f;}DATARMNETd9527bfa5e=
+DATARMNET3d487d950f(DATARMNETee792ef3a0);if(DATARMNETc3ffad4b30->
+DATARMNET5671455f38+DATARMNETd44a80d414->DATARMNET5f92dbf405>=
+DATARMNETd9527bfa5e){DATARMNET5d24865423(DATARMNET7dbef260b1);return 
+DATARMNET6b149bc29f;}DATARMNETc3ffad4b30->DATARMNET1e7926dc4c=false;return 
+DATARMNET7d8a4bb6b1;}bool DATARMNETb25a21aeeb(struct DATARMNET31caee06e2*
+DATARMNETd44a80d414,struct DATARMNETadd6ff90d0*DATARMNETc3ffad4b30,bool 
+DATARMNETc72284bb2d){int DATARMNET094475d445;if(DATARMNETc72284bb2d){
+DATARMNET5d24865423(DATARMNET135dd1f8ca);DATARMNET3bdaf91675(DATARMNETd44a80d414
+);DATARMNETf9d626d72b(DATARMNETc3ffad4b30);return true;}DATARMNET094475d445=
+DATARMNETb12f1716fd(DATARMNETd44a80d414,DATARMNETc3ffad4b30);if(
+DATARMNET094475d445==DATARMNET7d8a4bb6b1){DATARMNETfc01092f09(
+DATARMNETd44a80d414,DATARMNETc3ffad4b30);}else if(DATARMNET094475d445==
+DATARMNET6b149bc29f){DATARMNET3bdaf91675(DATARMNETd44a80d414);
+DATARMNETfc01092f09(DATARMNETd44a80d414,DATARMNETc3ffad4b30);}else{
+DATARMNET3bdaf91675(DATARMNETd44a80d414);DATARMNETf9d626d72b(DATARMNETc3ffad4b30
+);}return true;}
--- a/offload/rmnet_offload_tcp.h
+++ b/offload/rmnet_offload_tcp.h
@@ -0,0 +1,19 @@
+/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef DATARMNETc3f978cfbc
+#define DATARMNETc3f978cfbc
+#include "rmnet_offload_main.h"
+#include "rmnet_offload_engine.h"
+bool DATARMNETb25a21aeeb(struct DATARMNET31caee06e2*DATARMNETd44a80d414,struct 
+DATARMNETadd6ff90d0*DATARMNETc3ffad4b30,bool DATARMNETc72284bb2d);
+#endif
--- a/offload/rmnet_offload_udp.c
+++ b/offload/rmnet_offload_udp.c
@@ -0,0 +1,39 @@
+/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include "rmnet_descriptor.h"
+#include "rmnet_offload_main.h"
+#include "rmnet_offload_engine.h"
+#include "rmnet_offload_stats.h"
+#include "rmnet_offload_knob.h"
+static int DATARMNET83d48307c2(struct DATARMNET31caee06e2*DATARMNETd44a80d414,
+struct DATARMNETadd6ff90d0*DATARMNETc3ffad4b30){u64 DATARMNET0ee619d1b8;u16 
+DATARMNETfc02a09052;if(!DATARMNETd44a80d414->DATARMNET30d367f886)return 
+DATARMNET7d8a4bb6b1;DATARMNETfc02a09052=(DATARMNETc3ffad4b30->
+DATARMNET798fafaf36->gso_size)?:DATARMNETc3ffad4b30->DATARMNET5671455f38;if(
+DATARMNETfc02a09052!=DATARMNETd44a80d414->DATARMNET632219f39d){
+DATARMNET5d24865423(DATARMNETaee7f80b20);return DATARMNET6b149bc29f;}
+DATARMNET0ee619d1b8=DATARMNET3d487d950f(DATARMNETfbbc8e2e06);if(
+DATARMNETc3ffad4b30->DATARMNET5671455f38+DATARMNETd44a80d414->
+DATARMNET5f92dbf405>=DATARMNET0ee619d1b8){DATARMNET5d24865423(
+DATARMNETb3aa109946);return DATARMNET6b149bc29f;}DATARMNETc3ffad4b30->
+DATARMNET1e7926dc4c=false;return DATARMNET7d8a4bb6b1;}bool DATARMNET9dd18589e3(
+struct DATARMNET31caee06e2*DATARMNETd44a80d414,struct DATARMNETadd6ff90d0*
+DATARMNETc3ffad4b30,bool DATARMNETc72284bb2d){int DATARMNET094475d445;if(
+DATARMNETc72284bb2d){DATARMNET5d24865423(DATARMNET76bca11273);
+DATARMNET3bdaf91675(DATARMNETd44a80d414);DATARMNETf9d626d72b(DATARMNETc3ffad4b30
+);return true;}DATARMNET094475d445=DATARMNET83d48307c2(DATARMNETd44a80d414,
+DATARMNETc3ffad4b30);if(DATARMNET094475d445==DATARMNET7d8a4bb6b1){
+DATARMNETfc01092f09(DATARMNETd44a80d414,DATARMNETc3ffad4b30);}else if(
+DATARMNET094475d445==DATARMNET6b149bc29f){DATARMNET3bdaf91675(
+DATARMNETd44a80d414);DATARMNETfc01092f09(DATARMNETd44a80d414,DATARMNETc3ffad4b30
+);}return true;}
--- a/offload/rmnet_offload_udp.h
+++ b/offload/rmnet_offload_udp.h
@@ -0,0 +1,19 @@
+/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef DATARMNET4acb030b4f
+#define DATARMNET4acb030b4f
+#include "rmnet_offload_main.h"
+#include "rmnet_offload_engine.h"
+bool DATARMNET9dd18589e3(struct DATARMNET31caee06e2*DATARMNETd44a80d414,struct 
+DATARMNETadd6ff90d0*DATARMNETc3ffad4b30,bool DATARMNETc72284bb2d);
+#endif