From nobody Fri Sep 20 16:52:55 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 120F4EB64D7 for ; Wed, 14 Jun 2023 03:21:04 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S242438AbjFNDVA (ORCPT ); Tue, 13 Jun 2023 23:21:00 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:48222 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242375AbjFNDUy (ORCPT ); Tue, 13 Jun 2023 23:20:54 -0400 Received: from mailgw01.mediatek.com (unknown [60.244.123.138]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 27DC0196 for ; Tue, 13 Jun 2023 20:20:52 -0700 (PDT) X-UUID: 7448ce220a6211ee9cb5633481061a41-20230614 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Type:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=0BfjF76ESE9qlEo/M4tmdgd9Cz9dPTxPRYkOuq+JFp8=; b=E0dHYKNdsOaYh3MOAGT2GsvbMcIC2y4EC3dm991DoRjPfVnqEEsaei1f4VWwDKugTbDooNFcZomNtZeGjjbtG4TZAVg/uLYvvmWkhgOU4FIpYA5tRHhgfIbrj4SvqlMq1/b7IrmdagCX1P9qOXQZzcXJaA9oPL6slhV6GqzfgkA=; X-CID-P-RULE: Release_Ham X-CID-O-INFO: VERSION:1.1.26,REQID:e1dc4df5-48b4-45c3-b398-782a15812266,IP:0,U RL:0,TC:0,Content:-5,EDM:0,RT:0,SF:100,FILE:0,BULK:0,RULE:Release_Ham,ACTI ON:release,TS:95 X-CID-INFO: VERSION:1.1.26,REQID:e1dc4df5-48b4-45c3-b398-782a15812266,IP:0,URL :0,TC:0,Content:-5,EDM:0,RT:0,SF:100,FILE:0,BULK:0,RULE:Spam_GS981B3D,ACTI ON:quarantine,TS:95 X-CID-META: VersionHash:cb9a4e1,CLOUDID:36c55a3e-de1e-4348-bc35-c96f92f1dcbb,B ulkID:230614112049KEA40V85,BulkQuantity:0,Recheck:0,SF:28|17|19|48|38|29,T C:nil,Content:0,EDM:-3,IP:nil,URL:0,File:nil,Bulk:nil,QS:nil,BEC:nil,COL:0 ,OSI:0,OSA:0,AV:0,LES:1,SPR:NO X-CID-BVR: 0 X-CID-BAS: 0,_,0,_ X-CID-FACTOR: TF_CID_SPAM_ASC,TF_CID_SPAM_FAS,TF_CID_SPAM_FSD,TF_CID_SPAM_SNR, TF_CID_SPAM_SDM X-UUID: 7448ce220a6211ee9cb5633481061a41-20230614 Received: from mtkmbs13n1.mediatek.inc [(172.21.101.193)] by mailgw01.mediatek.com (envelope-from ) (Generic MTA with TLSv1.2 ECDHE-RSA-AES256-GCM-SHA384 256/256) with ESMTP id 680255152; Wed, 14 Jun 2023 11:20:46 +0800 Received: from mtkmbs13n1.mediatek.inc (172.21.101.193) by mtkmbs10n2.mediatek.inc (172.21.101.183) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1118.26; Wed, 14 Jun 2023 11:20:45 +0800 Received: from mtksdccf07.mediatek.inc (172.21.84.99) by mtkmbs13n1.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.2.1118.26 via Frontend Transport; Wed, 14 Jun 2023 11:20:45 +0800 From: Wei Chin Tsai To: , Matthias Brugger , AngeloGioacchino Del Regno CC: , , , , Wei Chin Tsai , , Subject: [PATCH v2 1/3] kernel : process fork/exit: export symbol for fork/exit tracing functions Date: Wed, 14 Jun 2023 11:20:33 +0800 Message-ID: <20230614032038.11699-2-Wei-chin.Tsai@mediatek.com> X-Mailer: git-send-email 2.18.0 In-Reply-To: <20230614032038.11699-1-Wei-chin.Tsai@mediatek.com> References: <20230614032038.11699-1-Wei-chin.Tsai@mediatek.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" In ths Patch, we export symbols for two functions of "sched_process_fork" and "sched_process_exit" for process statistics. During the system running, some process will run in a second and then terminate. We hope that we can capture those processes' jiffies information for system performance analysis. Signed-off-by: Wei Chin Tsai --- kernel/exit.c | 2 ++ kernel/fork.c | 2 ++ 2 files changed, 4 insertions(+) diff --git a/kernel/exit.c b/kernel/exit.c index edb50b4c9972..410a3de14e09 100644 --- a/kernel/exit.c +++ b/kernel/exit.c @@ -81,6 +81,8 @@ */ static unsigned int oops_limit =3D 10000; =20 +EXPORT_TRACEPOINT_SYMBOL_GPL(sched_process_exit); + #ifdef CONFIG_SYSCTL static struct ctl_table kern_exit_table[] =3D { { diff --git a/kernel/fork.c b/kernel/fork.c index f81985dcc4bd..8fba356fb7c2 100644 --- a/kernel/fork.c +++ b/kernel/fork.c @@ -142,6 +142,8 @@ DEFINE_PER_CPU(unsigned long, process_counts) =3D 0; =20 __cacheline_aligned DEFINE_RWLOCK(tasklist_lock); /* outer */ =20 +EXPORT_TRACEPOINT_SYMBOL_GPL(sched_process_fork); + #ifdef CONFIG_PROVE_RCU int lockdep_tasklist_lock_is_held(void) { --=20 2.18.0 From nobody Fri Sep 20 16:52:55 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 71159EB64DA for ; Wed, 14 Jun 2023 03:21:10 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S242500AbjFNDVI (ORCPT ); Tue, 13 Jun 2023 23:21:08 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:48252 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242392AbjFNDU5 (ORCPT ); Tue, 13 Jun 2023 23:20:57 -0400 Received: from mailgw01.mediatek.com (unknown [60.244.123.138]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 86BFC196; Tue, 13 Jun 2023 20:20:55 -0700 (PDT) X-UUID: 76115b980a6211ee9cb5633481061a41-20230614 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Type:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=w48tSpLqh1bjHgLcJdsXqvkcCf7nU4CX/ADnj4B4dnk=; b=WVi6RE4eL72h0ItIjr69r/D4N7M9q45UPK3mGZQ3sMqUgG5nNUO20RSrL9uAEfkQACtT3Ys+Gsg/dz8NzB/0RzQ8HjLq6Sv8U2+14IEAu1Yo4M33HtKh/qXsM1IDPUNB4AKz7N6khn8f8JPZGw0WVrnaauBkIOjB1qgIHcasFXU=; X-CID-P-RULE: Release_Ham X-CID-O-INFO: VERSION:1.1.26,REQID:58c44784-1a93-475a-a639-9ef4b69fb3df,IP:0,U RL:0,TC:0,Content:-25,EDM:0,RT:0,SF:0,FILE:0,BULK:0,RULE:Release_Ham,ACTIO N:release,TS:-25 X-CID-META: VersionHash:cb9a4e1,CLOUDID:de9b8b3e-7aa7-41f3-a6bd-0433bee822f3,B ulkID:nil,BulkQuantity:0,Recheck:0,SF:102,TC:nil,Content:0,EDM:-3,IP:nil,U RL:0,File:nil,Bulk:nil,QS:nil,BEC:nil,COL:0,OSI:0,OSA:0,AV:0,LES:1,SPR:NO X-CID-BVR: 0 X-CID-BAS: 0,_,0,_ X-CID-FACTOR: TF_CID_SPAM_SNR X-UUID: 76115b980a6211ee9cb5633481061a41-20230614 Received: from mtkmbs11n1.mediatek.inc [(172.21.101.185)] by mailgw01.mediatek.com (envelope-from ) (Generic MTA with TLSv1.2 ECDHE-RSA-AES256-GCM-SHA384 256/256) with ESMTP id 1036596478; Wed, 14 Jun 2023 11:20:49 +0800 Received: from mtkmbs13n1.mediatek.inc (172.21.101.193) by mtkmbs10n1.mediatek.inc (172.21.101.34) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1118.26; Wed, 14 Jun 2023 11:20:48 +0800 Received: from mtksdccf07.mediatek.inc (172.21.84.99) by mtkmbs13n1.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.2.1118.26 via Frontend Transport; Wed, 14 Jun 2023 11:20:48 +0800 From: Wei Chin Tsai To: , Russell King , Matthias Brugger , AngeloGioacchino Del Regno CC: , , , , Wei Chin Tsai , , , Subject: [PATCH v2 2/3] memory: export symbols for memory related functions Date: Wed, 14 Jun 2023 11:20:34 +0800 Message-ID: <20230614032038.11699-3-Wei-chin.Tsai@mediatek.com> X-Mailer: git-send-email 2.18.0 In-Reply-To: <20230614032038.11699-1-Wei-chin.Tsai@mediatek.com> References: <20230614032038.11699-1-Wei-chin.Tsai@mediatek.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" In this patch, we modified 3 files and export symbols for 2 functions. Export symbols for "smap_gather_stats" functions so that user can have an idea for each user process memory's usage. Export symbols for "arch_vma_name" functions so that user can know the heap usage for each user process. According to these two information, user can do the memory statistics and anaysis. Signed-off-by: Wei Chin Tsai Reported-by: kernel test robot --- arch/arm/kernel/process.c | 1 + fs/proc/task_mmu.c | 5 +++-- kernel/signal.c | 1 + 3 files changed, 5 insertions(+), 2 deletions(-) diff --git a/arch/arm/kernel/process.c b/arch/arm/kernel/process.c index 0e8ff85890ad..df91412a1069 100644 --- a/arch/arm/kernel/process.c +++ b/arch/arm/kernel/process.c @@ -343,6 +343,7 @@ const char *arch_vma_name(struct vm_area_struct *vma) { return is_gate_vma(vma) ? "[vectors]" : NULL; } +EXPORT_SYMBOL_GPL(arch_vma_name); =20 /* If possible, provide a placement hint at a random offset from the * stack for the sigpage and vdso pages. diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c index 6259dd432eeb..814d7829a20b 100644 --- a/fs/proc/task_mmu.c +++ b/fs/proc/task_mmu.c @@ -773,8 +773,8 @@ static const struct mm_walk_ops smaps_shmem_walk_ops = =3D { * * Use vm_start of @vma as the beginning address if @start is 0. */ -static void smap_gather_stats(struct vm_area_struct *vma, - struct mem_size_stats *mss, unsigned long start) +void smap_gather_stats(struct vm_area_struct *vma, + struct mem_size_stats *mss, unsigned long start) { const struct mm_walk_ops *ops =3D &smaps_walk_ops; =20 @@ -809,6 +809,7 @@ static void smap_gather_stats(struct vm_area_struct *vm= a, else walk_page_range(vma->vm_mm, start, vma->vm_end, ops, mss); } +EXPORT_SYMBOL_GPL(smap_gather_stats); =20 #define SEQ_PUT_DEC(str, val) \ seq_put_decimal_ull_width(m, str, (val) >> 10, 8) diff --git a/kernel/signal.c b/kernel/signal.c index b5370fe5c198..a1abe77fcdc3 100644 --- a/kernel/signal.c +++ b/kernel/signal.c @@ -4700,6 +4700,7 @@ __weak const char *arch_vma_name(struct vm_area_struc= t *vma) { return NULL; } +EXPORT_SYMBOL_GPL(arch_vma_name); =20 static inline void siginfo_buildtime_checks(void) { --=20 2.18.0 From nobody Fri Sep 20 16:52:55 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id B37DFEB64D8 for ; Wed, 14 Jun 2023 03:21:30 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S242584AbjFNDV2 (ORCPT ); Tue, 13 Jun 2023 23:21:28 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:48324 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241554AbjFNDVP (ORCPT ); Tue, 13 Jun 2023 23:21:15 -0400 Received: from mailgw02.mediatek.com (unknown [210.61.82.184]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 06FD9171A for ; Tue, 13 Jun 2023 20:20:59 -0700 (PDT) X-UUID: 784eb9780a6211eeb20a276fd37b9834-20230614 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Type:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=U+Bcu1U0exAeQbQt9h4GQqRMREAFlpYCo+XCf4y+w9Q=; b=CiaGyK7y9IPprRybLw8Cgh2xbY7NDtUeaUtyf9kI2zI0D2FJQ/EtnnOLkRguTLAJZlGNnVOSCX366uO7LWBKsdLZybRnqa2urf5P+D8o7q4bTM7cqeJM6bzpW5ZUJg056iOoFrQ064pLQn+xfcP2Bk6BaYMDJS3gIt0Q9rYUkG4=; X-CID-P-RULE: Release_Ham X-CID-O-INFO: VERSION:1.1.26,REQID:2e6ada33-1bf5-4a83-b5b9-75e9e4ed6e00,IP:0,U RL:0,TC:0,Content:-5,EDM:0,RT:0,SF:0,FILE:0,BULK:0,RULE:Release_Ham,ACTION :release,TS:-5 X-CID-META: VersionHash:cb9a4e1,CLOUDID:4d64ff6e-2f20-4998-991c-3b78627e4938,B ulkID:nil,BulkQuantity:0,Recheck:0,SF:102,TC:nil,Content:0,EDM:-3,IP:nil,U RL:11|1,File:nil,Bulk:nil,QS:nil,BEC:nil,COL:0,OSI:0,OSA:0,AV:0,LES:1,SPR: NO X-CID-BVR: 0 X-CID-BAS: 0,_,0,_ X-CID-FACTOR: TF_CID_SPAM_ULN,TF_CID_SPAM_SNR X-UUID: 784eb9780a6211eeb20a276fd37b9834-20230614 Received: from mtkmbs13n2.mediatek.inc [(172.21.101.108)] by mailgw02.mediatek.com (envelope-from ) (Generic MTA with TLSv1.2 ECDHE-RSA-AES256-GCM-SHA384 256/256) with ESMTP id 1573197039; Wed, 14 Jun 2023 11:20:53 +0800 Received: from mtkmbs13n1.mediatek.inc (172.21.101.193) by mtkmbs10n1.mediatek.inc (172.21.101.34) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1118.26; Wed, 14 Jun 2023 11:20:52 +0800 Received: from mtksdccf07.mediatek.inc (172.21.84.99) by mtkmbs13n1.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.2.1118.26 via Frontend Transport; Wed, 14 Jun 2023 11:20:52 +0800 From: Wei Chin Tsai To: , Arnd Bergmann , "Greg Kroah-Hartman" , Matthias Brugger , AngeloGioacchino Del Regno CC: , , , , Wei Chin Tsai , , Subject: [PATCH v2 3/3] misc : mediatek_mbraink : Collect the system process and memory data Date: Wed, 14 Jun 2023 11:20:35 +0800 Message-ID: <20230614032038.11699-4-Wei-chin.Tsai@mediatek.com> X-Mailer: git-send-email 2.18.0 In-Reply-To: <20230614032038.11699-1-Wei-chin.Tsai@mediatek.com> References: <20230614032038.11699-1-Wei-chin.Tsai@mediatek.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" In this patch, we add the mediatek_mbrain folder including 7 files. Apart from Makefile and Kconfig, the aim of the other 5 files is to collect the process fork/exit tracing data and process memory pss, uss, rss, swap, and heap usage. User could use these kind of data to do the system analysis, and detect the unexpected process/memory issues. Furthermore, user can make use of process memory data to detect the memory leak issues. From memory heap aspect, user could know the java and native layer heap usage. Also, user can capture those processes which run in a second and then terminate immediately by add the hook functions in "sched_process_fork" and "sched_process_exit". Signed-off-by: Wei Chin Tsai --- drivers/misc/mediatek_mbraink/Kconfig | 15 + drivers/misc/mediatek_mbraink/Makefile | 5 + drivers/misc/mediatek_mbraink/mbraink_data.c | 417 ++++++++++++++++++ drivers/misc/mediatek_mbraink/mbraink_data.h | 66 +++ .../mbraink_ioctl_struct_define.h | 44 ++ drivers/misc/mediatek_mbraink/mbraink_main.c | 239 ++++++++++ drivers/misc/mediatek_mbraink/mbraink_main.h | 36 ++ 7 files changed, 822 insertions(+) create mode 100644 drivers/misc/mediatek_mbraink/Kconfig create mode 100644 drivers/misc/mediatek_mbraink/Makefile create mode 100644 drivers/misc/mediatek_mbraink/mbraink_data.c create mode 100644 drivers/misc/mediatek_mbraink/mbraink_data.h create mode 100644 drivers/misc/mediatek_mbraink/mbraink_ioctl_struct_defi= ne.h create mode 100644 drivers/misc/mediatek_mbraink/mbraink_main.c create mode 100644 drivers/misc/mediatek_mbraink/mbraink_main.h diff --git a/drivers/misc/mediatek_mbraink/Kconfig b/drivers/misc/mediatek_= mbraink/Kconfig new file mode 100644 index 000000000000..4a96059e4c57 --- /dev/null +++ b/drivers/misc/mediatek_mbraink/Kconfig @@ -0,0 +1,15 @@ +config MTK_MBRAINK + tristate "MTK MBRAINK support" + help + MBRAINK is a MediaTek in-house kernel module which can + communicate with android MBrain. + Set Y to enable this feature. + If unsure, Set N to stay with legancy feature. + +config MTK_MBRAINK_EXPORT_DEPENDED + tristate "MTK MBRAINK EXPORT DEPENDED support" + help + MBRAINK EXPORT DEPENDED option which + needs to export extra function in upstram kernel. + Set Y to enable this feature. + If unsure, Set N to stay with legancy feature. diff --git a/drivers/misc/mediatek_mbraink/Makefile b/drivers/misc/mediatek= _mbraink/Makefile new file mode 100644 index 000000000000..8d75b41a8097 --- /dev/null +++ b/drivers/misc/mediatek_mbraink/Makefile @@ -0,0 +1,5 @@ +subdir-ccflags-y +=3D -Wformat + +obj-${CONFIG_MTK_MBRAINK} +=3D mtk_mbraink.o + +mtk_mbraink-objs +=3D mbraink_data.o mbraink_main.o diff --git a/drivers/misc/mediatek_mbraink/mbraink_data.c b/drivers/misc/me= diatek_mbraink/mbraink_data.c new file mode 100644 index 000000000000..dad03124820a --- /dev/null +++ b/drivers/misc/mediatek_mbraink/mbraink_data.c @@ -0,0 +1,417 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2023 MediaTek Inc. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "mbraink_data.h" + +/*spinlock for mbraink tracing pidlist*/ +static DEFINE_SPINLOCK(tracing_pidlist_lock); +/*Please make sure that tracing pidlist is protected by spinlock*/ +struct mbraink_tracing_pidlist mbraink_tracing_pidlist_data[MAX_TRACE_NUM]; + +#if IS_ENABLED(CONFIG_ANON_VMA_NAME) +struct anon_vma_name *mbraink_anon_vma_name(struct vm_area_struct *vma) +{ + if (vma->vm_file) + return NULL; + + return vma->anon_name; +} +#else +struct anon_vma_name *mbraink_anon_vma_name(struct vm_area_struct *vma) +{ + return NULL; +} +#endif + +void mbraink_map_vma(struct vm_area_struct *vma, unsigned long cur_pss, + unsigned long *native_heap, unsigned long *java_heap) +{ + struct mm_struct *mm =3D vma->vm_mm; + const char *name =3D NULL; + + if (vma->vm_file) + return; + /* + * Print the dentry name for named mappings, and a + * special [heap] marker for the heap: + */ + + if (vma->vm_ops && vma->vm_ops->name) { + name =3D vma->vm_ops->name(vma); + if (name) { + if (strncmp(name, "dev/ashmem/libc malloc", 23) =3D=3D 0) + (*native_heap) +=3D cur_pss; + return; + } + } + + name =3D arch_vma_name(vma); + if (!name) { + struct anon_vma_name *anon_name; + + if (!mm) + return; + + if (vma->vm_start <=3D mm->brk && vma->vm_end >=3D mm->start_brk) { + (*native_heap) +=3D cur_pss; + return; + } + + if (vma->vm_start <=3D vma->vm_mm->start_stack && + vma->vm_end >=3D vma->vm_mm->start_stack) + return; + + anon_name =3D mbraink_anon_vma_name(vma); + if (anon_name) { + if (strstr(anon_name->name, "scudo")) + (*native_heap) +=3D cur_pss; + else if (strstr(anon_name->name, "libc_malloc")) + (*native_heap) +=3D cur_pss; + else if (strstr(anon_name->name, "GWP-ASan")) + (*native_heap) +=3D cur_pss; + else if (strstr(anon_name->name, "dalvik-alloc space")) + (*java_heap) +=3D cur_pss; + else if (strstr(anon_name->name, "dalvik-main space")) + (*java_heap) +=3D cur_pss; + else if (strstr(anon_name->name, "dalvik-large object space")) + (*java_heap) +=3D cur_pss; + else if (strstr(anon_name->name, "dalvik-free list large object space")) + (*java_heap) +=3D cur_pss; + else if (strstr(anon_name->name, "dalvik-non moving space")) + (*java_heap) +=3D cur_pss; + else if (strstr(anon_name->name, "dalvik-zygote space")) + (*java_heap) +=3D cur_pss; + } + } +} + +void mbraink_get_process_memory_info(pid_t current_pid, + struct mbraink_process_memory_data *process_memory_buffer) +{ + struct task_struct *t =3D NULL; + struct mm_struct *mm =3D NULL; + struct vm_area_struct *vma =3D NULL; + struct mem_size_stats mss; + unsigned short pid_count =3D 0; + unsigned long pss, uss, rss, swap, cur_pss; + unsigned long java_heap =3D 0, native_heap =3D 0; + struct vma_iterator vmi; + + memset(process_memory_buffer, 0, sizeof(struct mbraink_process_memory_dat= a)); + process_memory_buffer->pid =3D 0; + + read_lock(&tasklist_lock); + for_each_process(t) { + if (t->pid <=3D current_pid) + continue; + + mm =3D t->mm; + if (mm) { + java_heap =3D 0; + native_heap =3D 0; + pid_count =3D process_memory_buffer->pid_count; + + process_memory_buffer->drv_data[pid_count].pid =3D + (unsigned short)(t->pid); + process_memory_buffer->pid =3D + (unsigned short)(t->pid); + + memset(&mss, 0, sizeof(mss)); + get_task_struct(t); + mmgrab(mm); + read_unlock(&tasklist_lock); + mmap_read_lock(mm); + vma_iter_init(&vmi, mm, 0); + for_each_vma(vmi, vma) { + cur_pss =3D (unsigned long)(mss.pss >> PSS_SHIFT); + smap_gather_stats(vma, &mss, 0); + cur_pss =3D + ((unsigned long)(mss.pss >> PSS_SHIFT)) - cur_pss; + cur_pss =3D cur_pss / 1024; + mbraink_map_vma(vma, cur_pss, &native_heap, &java_heap); + } + mmap_read_unlock(mm); + read_lock(&tasklist_lock); + mmdrop(mm); + put_task_struct(t); + + pss =3D (unsigned long)(mss.pss >> PSS_SHIFT) / 1024; + uss =3D (mss.private_clean + mss.private_dirty) / 1024; + rss =3D (mss.resident) / 1024; + swap =3D (mss.swap) / 1024; + + process_memory_buffer->drv_data[pid_count].pss =3D pss; + process_memory_buffer->drv_data[pid_count].uss =3D uss; + process_memory_buffer->drv_data[pid_count].rss =3D rss; + process_memory_buffer->drv_data[pid_count].swap =3D swap; + process_memory_buffer->drv_data[pid_count].java_heap =3D + java_heap; + process_memory_buffer->drv_data[pid_count].native_heap =3D + native_heap; + process_memory_buffer->pid_count++; + + break; + } + } + read_unlock(&tasklist_lock); +} + +/***************************************************************** + * Note: this function can only be used during tracing function + * This function is only used in tracing function so that there + * is no need for task t spinlock protection + *****************************************************************/ +static u64 mbraink_get_specific_process_jiffies(struct task_struct *t) +{ + u64 stime =3D 0, utime =3D 0, cutime =3D 0, cstime =3D 0; + u64 process_jiffies =3D 0; + + if (t->pid =3D=3D t->tgid) { + cutime =3D t->signal->cutime; + cstime =3D t->signal->cstime; + if (t->flags & PF_KTHREAD) + task_cputime_adjusted(t, &utime, &stime); + else + thread_group_cputime_adjusted(t, &utime, &stime); + + process_jiffies =3D nsec_to_clock_t(utime) + + nsec_to_clock_t(stime) + + nsec_to_clock_t(cutime) + + nsec_to_clock_t(cstime); + } else { + task_cputime_adjusted(t, &utime, &stime); + process_jiffies =3D nsec_to_clock_t(utime) + nsec_to_clock_t(stime); + } + + return process_jiffies; +} + +/*************************************************************** + * Note: this function can only be used during tracing function + * This function is only used in tracing function so that there + * is no need for task t spinlock protection + **************************************************************/ +static u16 mbraink_get_specific_process_uid(struct task_struct *t) +{ + const struct cred *cred =3D NULL; + u16 val =3D 0; + + cred =3D get_task_cred(t); + val =3D cred->uid.val; + put_cred(cred); + + return val; +} + +static void mbraink_trace_sched_process_exit(void *data, struct task_struc= t *t) +{ + int i =3D 0; + struct timespec64 tv =3D { 0 }; + unsigned long flags; + + if (t->pid =3D=3D t->tgid) { + spin_lock_irqsave(&tracing_pidlist_lock, flags); + for (i =3D 0; i < MAX_TRACE_NUM; i++) { + if (mbraink_tracing_pidlist_data[i].pid =3D=3D (unsigned short)t->pid) { + ktime_get_real_ts64(&tv); + mbraink_tracing_pidlist_data[i].end =3D + (tv.tv_sec * 1000) + (tv.tv_nsec / 1000000); + mbraink_tracing_pidlist_data[i].jiffies =3D + mbraink_get_specific_process_jiffies(t); + mbraink_tracing_pidlist_data[i].dirty =3D true; + + break; + } + } + if (i =3D=3D MAX_TRACE_NUM) { + for (i =3D 0; i < MAX_TRACE_NUM; i++) { + if (mbraink_tracing_pidlist_data[i].pid =3D=3D 0) { + mbraink_tracing_pidlist_data[i].pid =3D + (unsigned short)(t->pid); + mbraink_tracing_pidlist_data[i].tgid =3D + (unsigned short)(t->tgid); + mbraink_tracing_pidlist_data[i].uid =3D + mbraink_get_specific_process_uid(t); + mbraink_tracing_pidlist_data[i].priority =3D + t->prio - MAX_RT_PRIO; + memcpy(mbraink_tracing_pidlist_data[i].name, + t->comm, TASK_COMM_LEN); + ktime_get_real_ts64(&tv); + mbraink_tracing_pidlist_data[i].end =3D + (tv.tv_sec * 1000) + (tv.tv_nsec / 1000000); + mbraink_tracing_pidlist_data[i].jiffies =3D + mbraink_get_specific_process_jiffies(t); + mbraink_tracing_pidlist_data[i].dirty =3D true; + + break; + } + } + if (i =3D=3D MAX_TRACE_NUM) { + pr_info("%s pid=3D%u:%s.\n", __func__, t->pid, t->comm); + memset(mbraink_tracing_pidlist_data, 0, + sizeof(struct mbraink_tracing_pidlist) * MAX_TRACE_NUM); + } + } + spin_unlock_irqrestore(&tracing_pidlist_lock, flags); + } +} + +static void mbraink_trace_sched_process_fork(void *data, struct task_struc= t *t, + struct task_struct *p) +{ + int i =3D 0; + struct timespec64 tv =3D { 0 }; + unsigned long flags; + + if (p->pid =3D=3D p->tgid) { + spin_lock_irqsave(&tracing_pidlist_lock, flags); + for (i =3D 0; i < MAX_TRACE_NUM; i++) { + if (mbraink_tracing_pidlist_data[i].pid =3D=3D 0) { + mbraink_tracing_pidlist_data[i].pid =3D (unsigned short)(p->pid); + mbraink_tracing_pidlist_data[i].tgid =3D (unsigned short)(p->tgid); + mbraink_tracing_pidlist_data[i].uid =3D + mbraink_get_specific_process_uid(p); + mbraink_tracing_pidlist_data[i].priority =3D p->prio - MAX_RT_PRIO; + memcpy(mbraink_tracing_pidlist_data[i].name, + p->comm, TASK_COMM_LEN); + ktime_get_real_ts64(&tv); + mbraink_tracing_pidlist_data[i].start =3D + (tv.tv_sec * 1000) + (tv.tv_nsec / 1000000); + mbraink_tracing_pidlist_data[i].dirty =3D true; + break; + } + } + + if (i =3D=3D MAX_TRACE_NUM) { + pr_info("%s child_pid=3D%u:%s.\n", __func__, p->pid, p->comm); + memset(mbraink_tracing_pidlist_data, 0, + sizeof(struct mbraink_tracing_pidlist) * MAX_TRACE_NUM); + } + spin_unlock_irqrestore(&tracing_pidlist_lock, flags); + } +} + +int mbraink_process_tracer_init(void) +{ + int ret =3D 0; + + memset(mbraink_tracing_pidlist_data, 0, + sizeof(struct mbraink_tracing_pidlist) * MAX_TRACE_NUM); + + ret =3D register_trace_sched_process_fork(mbraink_trace_sched_process_for= k, NULL); + if (ret) { + pr_notice("register_trace_sched_process_fork failed.\n"); + goto register_trace_sched_process_fork; + } + ret =3D register_trace_sched_process_exit(mbraink_trace_sched_process_exi= t, NULL); + if (ret) { + pr_notice("register register_trace_sched_process_exit failed.\n"); + goto register_trace_sched_process_exit; + } + + return ret; + +register_trace_sched_process_exit: + unregister_trace_sched_process_fork(mbraink_trace_sched_process_fork, NUL= L); +register_trace_sched_process_fork: + return ret; +} + +void mbraink_process_tracer_exit(void) +{ + unregister_trace_sched_process_fork(mbraink_trace_sched_process_fork, NUL= L); + unregister_trace_sched_process_exit(mbraink_trace_sched_process_exit, NUL= L); +} + +void mbraink_get_tracing_pid_info(unsigned short current_idx, + struct mbraink_tracing_pid_data *tracing_pid_buffer) +{ + int i =3D 0; + int ret =3D 0; + unsigned long flags; + unsigned short tracing_count =3D 0; + + spin_lock_irqsave(&tracing_pidlist_lock, flags); + + memset(tracing_pid_buffer, 0, sizeof(struct mbraink_tracing_pid_data)); + + for (i =3D current_idx; i < MAX_TRACE_NUM; i++) { + if (mbraink_tracing_pidlist_data[i].dirty =3D=3D 0) { + continue; + } else { + tracing_count =3D tracing_pid_buffer->tracing_count; + if (tracing_count < MAX_TRACE_PID_NUM) { + tracing_pid_buffer->drv_data[tracing_count].pid =3D + mbraink_tracing_pidlist_data[i].pid; + tracing_pid_buffer->drv_data[tracing_count].tgid =3D + mbraink_tracing_pidlist_data[i].tgid; + tracing_pid_buffer->drv_data[tracing_count].uid =3D + mbraink_tracing_pidlist_data[i].uid; + tracing_pid_buffer->drv_data[tracing_count].priority =3D + mbraink_tracing_pidlist_data[i].priority; + memcpy(tracing_pid_buffer->drv_data[tracing_count].name, + mbraink_tracing_pidlist_data[i].name, TASK_COMM_LEN); + tracing_pid_buffer->drv_data[tracing_count].start =3D + mbraink_tracing_pidlist_data[i].start; + tracing_pid_buffer->drv_data[tracing_count].end =3D + mbraink_tracing_pidlist_data[i].end; + tracing_pid_buffer->drv_data[tracing_count].jiffies =3D + mbraink_tracing_pidlist_data[i].jiffies; + tracing_pid_buffer->tracing_count++; + /*Deal with the end process record*/ + if (mbraink_tracing_pidlist_data[i].end !=3D 0) { + mbraink_tracing_pidlist_data[i].pid =3D 0; + mbraink_tracing_pidlist_data[i].tgid =3D 0; + mbraink_tracing_pidlist_data[i].uid =3D 0; + mbraink_tracing_pidlist_data[i].priority =3D 0; + memset(mbraink_tracing_pidlist_data[i].name, + 0, TASK_COMM_LEN); + mbraink_tracing_pidlist_data[i].start =3D 0; + mbraink_tracing_pidlist_data[i].end =3D 0; + mbraink_tracing_pidlist_data[i].jiffies =3D 0; + mbraink_tracing_pidlist_data[i].dirty =3D false; + } else { + mbraink_tracing_pidlist_data[i].dirty =3D false; + } + } else { + ret =3D -1; + tracing_pid_buffer->tracing_idx =3D i; + break; + } + } + } + pr_info("%s: current_idx =3D %u, count =3D %u\n", + __func__, tracing_pid_buffer->tracing_idx, tracing_pid_buffer->tracing_c= ount); + spin_unlock_irqrestore(&tracing_pidlist_lock, flags); +} diff --git a/drivers/misc/mediatek_mbraink/mbraink_data.h b/drivers/misc/me= diatek_mbraink/mbraink_data.h new file mode 100644 index 000000000000..2d1a6b488caa --- /dev/null +++ b/drivers/misc/mediatek_mbraink/mbraink_data.h @@ -0,0 +1,66 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright (c) 2023 MediaTek Inc. + */ +#ifndef MBRAINK_DATA_H +#define MBRAINK_DATA_H +#include +#include +#include +#include +#include + +#include "mbraink_ioctl_struct_define.h" + +#define PSS_SHIFT 12 +#define MAX_RT_PRIO 100 +#define MAX_TRACE_NUM 3072 + +struct mbraink_tracing_pidlist { + unsigned short pid; + unsigned short tgid; + unsigned short uid; + int priority; + char name[TASK_COMM_LEN]; + long long start; + long long end; + u64 jiffies; + bool dirty; +}; + +struct mem_size_stats { + unsigned long resident; + unsigned long shared_clean; + unsigned long shared_dirty; + unsigned long private_clean; + unsigned long private_dirty; + unsigned long referenced; + unsigned long anonymous; + unsigned long lazyfree; + unsigned long anonymous_thp; + unsigned long shmem_thp; + unsigned long file_thp; + unsigned long swap; + unsigned long shared_hugetlb; + unsigned long private_hugetlb; + u64 pss; + u64 pss_anon; + u64 pss_file; + u64 pss_shmem; + u64 pss_locked; + u64 swap_pss; + bool check_shmem_swap; +}; + +void mbraink_get_process_memory_info(pid_t current_pid, + struct mbraink_process_memory_data *process_memory_buffer); +int mbraink_process_tracer_init(void); +void mbraink_process_tracer_exit(void); +void mbraink_get_tracing_pid_info(unsigned short current_idx, + struct mbraink_tracing_pid_data *tracing_pid_buffer); +void smap_gather_stats(struct vm_area_struct *vma, + struct mem_size_stats *mss, unsigned long start); +void task_cputime_adjusted(struct task_struct *p, u64 *ut, u64 *st); +void thread_group_cputime_adjusted(struct task_struct *p, u64 *ut, u64 *st= ); +u64 nsec_to_clock_t(u64 x); +#endif diff --git a/drivers/misc/mediatek_mbraink/mbraink_ioctl_struct_define.h b/= drivers/misc/mediatek_mbraink/mbraink_ioctl_struct_define.h new file mode 100644 index 000000000000..d655d8893f0f --- /dev/null +++ b/drivers/misc/mediatek_mbraink/mbraink_ioctl_struct_define.h @@ -0,0 +1,44 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright (c) 2023 MediaTek Inc. + */ +#ifndef MBRAINK_IOCTL_STRUCT_H +#define MBRAINK_IOCTL_STRUCT_H + +#define MAX_MEM_STRUCT_SZ 4 +#define MAX_TRACE_PID_NUM 16 + +struct mbraink_process_memory_struct { + unsigned short pid; + unsigned long pss; + unsigned long uss; + unsigned long rss; + unsigned long swap; + unsigned long java_heap; + unsigned long native_heap; +}; + +struct mbraink_process_memory_data { + unsigned short pid; + unsigned short pid_count; + struct mbraink_process_memory_struct drv_data[MAX_MEM_STRUCT_SZ]; +}; + +struct mbraink_tracing_pid { + unsigned short pid; + unsigned short tgid; + unsigned short uid; + int priority; + char name[TASK_COMM_LEN]; + long long start; + long long end; + u64 jiffies; +}; + +struct mbraink_tracing_pid_data { + unsigned short tracing_idx; + unsigned short tracing_count; + struct mbraink_tracing_pid drv_data[MAX_TRACE_PID_NUM]; +}; + +#endif diff --git a/drivers/misc/mediatek_mbraink/mbraink_main.c b/drivers/misc/me= diatek_mbraink/mbraink_main.c new file mode 100644 index 000000000000..4e6aac51694a --- /dev/null +++ b/drivers/misc/mediatek_mbraink/mbraink_main.c @@ -0,0 +1,239 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2023 MediaTek Inc. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "mbraink_main.h" +#include "mbraink_data.h" + +struct mbraink_data mbraink_priv; + +static int mbraink_open(struct inode *inode, struct file *filp) +{ + return 0; +} + +static int mbraink_release(struct inode *inode, struct file *filp) +{ + return 0; +} + +static long mbraink_ioctl(struct file *filp, + unsigned int cmd, + unsigned long arg) +{ + long ret =3D 0; + + switch (cmd) { + case RO_PROCESS_MEMORY: + { + struct mbraink_process_memory_data process_memory_buffer; + + pid_t pid =3D 1; + + if (copy_from_user(&process_memory_buffer, + (struct mbraink_process_memory_data *)arg, + sizeof(process_memory_buffer))) { + pr_notice("copy process memory info from user Err!\n"); + return -EPERM; + } + + if (process_memory_buffer.pid > PID_MAX_DEFAULT || + process_memory_buffer.pid_count > PID_MAX_DEFAULT) { + pr_notice("process memory: Invalid pid_idx %u or pid_count %u\n", + process_memory_buffer.pid, process_memory_buffer.pid_count); + return -EINVAL; + } + pid =3D process_memory_buffer.pid; + + mbraink_get_process_memory_info(pid, &process_memory_buffer); + + if (copy_to_user((struct mbraink_process_memory_data *)arg, + &process_memory_buffer, + sizeof(process_memory_buffer))) { + pr_notice("Copy process_memory_info to UserSpace error!\n"); + return -EPERM; + } + break; + } + case RO_TRACE_PROCESS: + { + struct mbraink_tracing_pid_data tracing_pid_buffer; + + unsigned short tracing_idx =3D 0; + + if (copy_from_user(&tracing_pid_buffer, + (struct mbraink_tracing_pid_data *)arg, + sizeof(tracing_pid_buffer))) { + pr_notice("copy tracing_pid_buffer data from user Err!\n"); + return -EPERM; + } + + if (tracing_pid_buffer.tracing_idx > MAX_TRACE_NUM) { + pr_notice("invalid tracing_idx %u !\n", + tracing_pid_buffer.tracing_idx); + return -EINVAL; + } + tracing_idx =3D tracing_pid_buffer.tracing_idx; + + mbraink_get_tracing_pid_info(tracing_idx, &tracing_pid_buffer); + + if (copy_to_user((struct mbraink_tracing_pid_data *)arg, + &tracing_pid_buffer, + sizeof(tracing_pid_buffer))) { + pr_notice("Copy tracing_pid_buffer to UserSpace error!\n"); + return -EPERM; + } + break; + } + default: + pr_notice("illegal ioctl number %u.\n", cmd); + return -EINVAL; + } + + return ret; +} + +#if IS_ENABLED(CONFIG_COMPAT) +static long mbraink_compat_ioctl(struct file *filp, + unsigned int cmd, unsigned long arg) +{ + return mbraink_ioctl(filp, cmd, (unsigned long)compat_ptr(arg)); +} +#endif + +static const struct file_operations mbraink_fops =3D { + .owner =3D THIS_MODULE, + .open =3D mbraink_open, + .release =3D mbraink_release, + .unlocked_ioctl =3D mbraink_ioctl, +#if IS_ENABLED(CONFIG_COMPAT) + .compat_ioctl =3D mbraink_compat_ioctl, +#endif +}; + +#if IS_ENABLED(CONFIG_PM_SLEEP) +static int mbraink_suspend(struct device *dev) +{ + int ret; + + pr_info("[MBK_INFO] %s\n", __func__); + + ret =3D pm_generic_suspend(dev); + + return ret; +} + +static int mbraink_resume(struct device *dev) +{ + int ret; + + pr_info("[MBK_INFO] %s\n", __func__); + + ret =3D pm_generic_resume(dev); + + return ret; +} + +static const struct dev_pm_ops mbraink_class_dev_pm_ops =3D { + .suspend =3D mbraink_suspend, + .resume =3D mbraink_resume, +}; + +#define MBRAINK_CLASS_DEV_PM_OPS (&mbraink_class_dev_pm_ops) +#else +#define MBRAINK_CLASS_DEV_PM_OPS NULL +#endif /*end of CONFIG_PM_SLEEP*/ + +static int mbraink_dev_init(void) +{ + mbraink_priv.mbraink_dev_no =3D 0; + + /*Allocating Major number*/ + if ((alloc_chrdev_region(&mbraink_priv.mbraink_dev_no, 0, 1, CHRDEV_NAME)= ) < 0) { + pr_notice("Cannot allocate major number %u\n", + mbraink_priv.mbraink_dev_no); + return -EBADF; + } + + /*Initialize cdev structure*/ + cdev_init(&mbraink_priv.mbraink_cdev, &mbraink_fops); + + /*Adding character device to the system*/ + if ((cdev_add(&mbraink_priv.mbraink_cdev, mbraink_priv.mbraink_dev_no, 1)= ) < 0) { + pr_notice("Cannot add the device to the system\n"); + goto r_class; + } + + mbraink_priv.mbraink_class =3D class_create(THIS_MODULE, "mbraink_host"); + /*Register mbraink class*/ + if (IS_ERR(mbraink_priv.mbraink_class)) { + pr_notice("Cannot create the mbraink class\n"); + goto r_class; + } + mbraink_priv.mbraink_class->pm =3D MBRAINK_CLASS_DEV_PM_OPS; + + /*Register mbraink device*/ + if (IS_ERR(device_create(mbraink_priv.mbraink_class, + NULL, mbraink_priv.mbraink_dev_no, NULL, "mbraink"))) { + pr_notice("Cannot create the mbraink Device\n"); + goto r_device; + } + pr_info("[MBK_INFO] %s: Mbraink device init done.\n", __func__); + + return 0; + +r_device: + class_destroy(mbraink_priv.mbraink_class); +r_class: + unregister_chrdev_region(mbraink_priv.mbraink_dev_no, 1); + + return -EPERM; +} + +static int mbraink_init(void) +{ + int ret =3D 0; + + ret =3D mbraink_dev_init(); + if (ret) + pr_notice("mbraink device init failed.\n"); + + ret =3D mbraink_process_tracer_init(); + if (ret) + pr_notice("mbraink tracer init failed.\n"); + + return ret; +} + +static void mbraink_dev_exit(void) +{ + device_destroy(mbraink_priv.mbraink_class, mbraink_priv.mbraink_dev_no); + class_destroy(mbraink_priv.mbraink_class); + cdev_del(&mbraink_priv.mbraink_cdev); + unregister_chrdev_region(mbraink_priv.mbraink_dev_no, 1); + + pr_info("[MBK_INFO] %s: MBraink device exit done\n", __func__); +} + +static void mbraink_exit(void) +{ + mbraink_dev_exit(); + mbraink_process_tracer_exit(); +} + +module_init(mbraink_init); +module_exit(mbraink_exit); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR(""); +MODULE_DESCRIPTION("MBraink Linux Device Driver"); +MODULE_VERSION("1.0"); diff --git a/drivers/misc/mediatek_mbraink/mbraink_main.h b/drivers/misc/me= diatek_mbraink/mbraink_main.h new file mode 100644 index 000000000000..36549f0d90d1 --- /dev/null +++ b/drivers/misc/mediatek_mbraink/mbraink_main.h @@ -0,0 +1,36 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright (c) 2023 MediaTek Inc. + */ + +#ifndef MBRAINK_MAIN_H +#define MBRAINK_MAIN_H + +#include +#include +#include +#include +#include + +#include "mbraink_ioctl_struct_define.h" + +#define IOC_MAGIC 'k' + +/*Mbrain Delegate Info List*/ +#define PROCESS_MEMORY_INFO '4' +#define TRACE_PROCESS_INFO 'a' + +/*Mbrain Delegate IOCTL List*/ +#define RO_PROCESS_MEMORY _IOR(IOC_MAGIC, PROCESS_MEMORY_INFO, \ + struct mbraink_process_memory_data*) +#define RO_TRACE_PROCESS _IOR(IOC_MAGIC, TRACE_PROCESS_INFO, \ + struct mbraink_tracing_pid_data*) + +struct mbraink_data { +#define CHRDEV_NAME "mbraink_chrdev" + dev_t mbraink_dev_no; + struct cdev mbraink_cdev; + struct class *mbraink_class; +}; + +#endif /*end of MBRAINK_MAIN_H*/ --=20 2.18.0