diff --git a/datarmnet_ext_dlkm_vendor_board.mk b/datarmnet_ext_dlkm_vendor_board.mk new file mode 100644 index 0000000000..cb75ff4176 --- /dev/null +++ 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 diff --git a/datarmnet_ext_dlkm_vendor_product.mk b/datarmnet_ext_dlkm_vendor_product.mk new file mode 100644 index 0000000000..8dc049f686 --- /dev/null +++ b/datarmnet_ext_dlkm_vendor_product.mk @@ -0,0 +1 @@ +PRODUCT_PACKAGES += rmnet_offload.ko diff --git a/offload/Android.mk b/offload/Android.mk new file mode 100644 index 0000000000..132f51a2a9 --- /dev/null +++ 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 diff --git a/offload/Kbuild b/offload/Kbuild new file mode 100644 index 0000000000..6b244bd490 --- /dev/null +++ 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 diff --git a/offload/Kconfig b/offload/Kconfig new file mode 100644 index 0000000000..13799e3143 --- /dev/null +++ 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 diff --git a/offload/Makefile b/offload/Makefile new file mode 100644 index 0000000000..268d1f2edd --- /dev/null +++ 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 diff --git a/offload/rmnet_offload_engine.c b/offload/rmnet_offload_engine.c new file mode 100644 index 0000000000..3b2a3b8bdc --- /dev/null +++ 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 +#include +#include +#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); +DATARMNET5d971be8b8DATARMNETa3d1da1cba.DATARMNET51e299cf9c[DATARMNET5d971be8b8];INIT_LIST_HEAD(& +DATARMNETd44a80d414->DATARMNETdaf24e965e);INIT_HLIST_NODE(&DATARMNETd44a80d414-> +DATARMNET0a9c7c9a12);}return DATARMNET6e89887168;} diff --git a/offload/rmnet_offload_engine.h b/offload/rmnet_offload_engine.h new file mode 100644 index 0000000000..58461dd522 --- /dev/null +++ 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 +#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 diff --git a/offload/rmnet_offload_knob.c b/offload/rmnet_offload_knob.c new file mode 100644 index 0000000000..cd892a026a --- /dev/null +++ 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 +#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) +DATARMNET8371e203e8DATARMNET9d5e08f187||(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;} diff --git a/offload/rmnet_offload_knob.h b/offload/rmnet_offload_knob.h new file mode 100644 index 0000000000..906f81efd3 --- /dev/null +++ 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 +enum{DATARMNETee792ef3a0,DATARMNETfbbc8e2e06,DATARMNETe9b360aea8, +DATARMNET6fb580e7bf,};u64 DATARMNET3d487d950f(u32 DATARMNETc8bfe161a0); +#endif diff --git a/offload/rmnet_offload_main.c b/offload/rmnet_offload_main.c new file mode 100644 index 0000000000..0562023137 --- /dev/null +++ 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 +#include +#include +#include +#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);} diff --git a/offload/rmnet_offload_main.h b/offload/rmnet_offload_main.h new file mode 100644 index 0000000000..0c9a84db12 --- /dev/null +++ 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 +#include +#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 " 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 " 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 + diff --git a/offload/rmnet_offload_state.c b/offload/rmnet_offload_state.c new file mode 100644 index 0000000000..3d48e3b1ed --- /dev/null +++ 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 +#include +#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); diff --git a/offload/rmnet_offload_state.h b/offload/rmnet_offload_state.h new file mode 100644 index 0000000000..1234c48600 --- /dev/null +++ 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 diff --git a/offload/rmnet_offload_stats.c b/offload/rmnet_offload_stats.c new file mode 100644 index 0000000000..3741e82c3b --- /dev/null +++ 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 +#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 +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 + diff --git a/offload/rmnet_offload_tcp.c b/offload/rmnet_offload_tcp.c new file mode 100644 index 0000000000..749829d508 --- /dev/null +++ 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);DATARMNET5d971be8b8DATARMNET7ff34eacb7;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;} diff --git a/offload/rmnet_offload_tcp.h b/offload/rmnet_offload_tcp.h new file mode 100644 index 0000000000..01d2e6e6b6 --- /dev/null +++ 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 diff --git a/offload/rmnet_offload_udp.c b/offload/rmnet_offload_udp.c new file mode 100644 index 0000000000..95c19510fc --- /dev/null +++ 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;} diff --git a/offload/rmnet_offload_udp.h b/offload/rmnet_offload_udp.h new file mode 100644 index 0000000000..9e2d847e3e --- /dev/null +++ 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